mirror of
https://git.FreeBSD.org/src.git
synced 2024-12-18 10:35:55 +00:00
e843ad34c1
effect immediately, but required a following (normally redundant) G0 into GL mapping. This adds one layer of indirection (thus might make it slower), but fixes the broken box character drawing in pcvt. Hellmuth and Bruce are unfortunately too busy too review this right now, but i wanna have it in 2.2 since it has often been asked in the past.
2188 lines
52 KiB
C
2188 lines
52 KiB
C
/*
|
|
* Copyright (c) 1992, 1995 Hellmuth Michaelis and Joerg Wunsch.
|
|
*
|
|
* Copyright (c) 1992, 1993 Brian Dunford-Shore.
|
|
*
|
|
* All rights reserved.
|
|
*
|
|
* This code is derived from software contributed to Berkeley by
|
|
* William Jolitz and Don Ahn.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. All advertising materials mentioning features or use of this software
|
|
* must display the following acknowledgement:
|
|
* This product includes software developed by Hellmuth Michaelis,
|
|
* Brian Dunford-Shore and Joerg Wunsch.
|
|
* 4. The name authors may not be used to endorse or promote products
|
|
* derived from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
|
|
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
*
|
|
* @(#)pcvt_vtf.c, 3.20, Last Edit-Date: [Wed Apr 5 18:08:50 1995]
|
|
*/
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
*
|
|
* pcvt_vtf.c VT220 Terminal Emulator Functions
|
|
* -------------------------------------------------
|
|
* -hm ------------ Release 3.00 --------------
|
|
* -hm integrating NetBSD-current patches
|
|
* -hm integrating patch from Thomas Gellekum
|
|
* -hm fixed bug fkey labels not properly (re)set after ris
|
|
* -hm Michael Havemester fixed NOFASTSCROLL define bug
|
|
* -hm set caps/scroll/num_lock in vt_str() and made led_update()
|
|
* -hm applying patch from Joerg fixing Crtat bug
|
|
* -hm fixing NOFASTSCROLL operation for MDA/Hercules
|
|
* -jw/hm fixing bug in roll_up() and roll_down()
|
|
* -hm fastscroll/Crtat bugfix from Lon Willett
|
|
* -hm patch for non-XSERVER/UCONSOLE compiles from Rafal Boni
|
|
* -hm bugfix: PCVT_USL_COMPAT renamed to PCVT_USL_VT_COMPAT ...
|
|
*
|
|
*---------------------------------------------------------------------------*/
|
|
|
|
#include "vt.h"
|
|
#if NVT > 0
|
|
|
|
#define PCVT_INCLUDE_VT_SELATTR /* get inline function from pcvt_hdr.h */
|
|
|
|
#include <i386/isa/pcvt/pcvt_hdr.h> /* global include */
|
|
#include <i386/isa/pcvt/pcvt_tbl.h> /* character set conversion tables */
|
|
|
|
static void clear_dld ( struct video_state *svsp );
|
|
static void init_dld ( struct video_state *svsp );
|
|
static void init_udk ( struct video_state *svsp );
|
|
static void respond ( struct video_state *svsp );
|
|
static void roll_down ( struct video_state *svsp, int n );
|
|
static void selective_erase ( struct video_state *svsp, u_short *pcrtat,
|
|
int length );
|
|
static void swcsp ( struct video_state *svsp, u_short *ctp );
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* DECSTBM - set top and bottom margins
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
vt_stbm(struct video_state *svsp)
|
|
{
|
|
/* both 0 => scrolling region = entire screen */
|
|
|
|
if((svsp->parms[0] == 0) && (svsp->parms[1] == 0))
|
|
{
|
|
svsp->cur_offset = 0;
|
|
svsp->scrr_beg = 0;
|
|
svsp->scrr_len = svsp->screen_rows;
|
|
svsp->scrr_end = svsp->scrr_len - 1;
|
|
svsp->col = 0;
|
|
return;
|
|
}
|
|
|
|
if(svsp->parms[1] <= svsp->parms[0])
|
|
return;
|
|
|
|
/* range parm 1 */
|
|
|
|
if(svsp->parms[0] < 1)
|
|
svsp->parms[0] = 1;
|
|
else if(svsp->parms[0] > svsp->screen_rows-1)
|
|
svsp->parms[0] = svsp->screen_rows-1;
|
|
|
|
/* range parm 2 */
|
|
|
|
if(svsp->parms[1] < 2)
|
|
svsp->parms[1] = 2;
|
|
else if(svsp->parms[1] > svsp->screen_rows)
|
|
svsp->parms[1] = svsp->screen_rows;
|
|
|
|
svsp->scrr_beg = svsp->parms[0]-1; /* begin of scrolling region */
|
|
svsp->scrr_len = svsp->parms[1] - svsp->parms[0] + 1; /* no of lines */
|
|
svsp->scrr_end = svsp->parms[1]-1;
|
|
|
|
/* cursor to first pos */
|
|
if(svsp->m_om)
|
|
svsp->cur_offset = svsp->scrr_beg * svsp->maxcol;
|
|
else
|
|
svsp->cur_offset = 0;
|
|
|
|
svsp->col = 0;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* SGR - set graphic rendition
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
vt_sgr(struct video_state *svsp)
|
|
{
|
|
register int i = 0;
|
|
u_short setcolor = 0;
|
|
char colortouched = 0;
|
|
|
|
do
|
|
{
|
|
switch(svsp->parms[i++])
|
|
{
|
|
case 0: /* reset to normal attributes */
|
|
svsp->vtsgr = VT_NORMAL;
|
|
break;
|
|
|
|
case 1: /* bold */
|
|
svsp->vtsgr |= VT_BOLD;
|
|
break;
|
|
|
|
case 4: /* underline */
|
|
svsp->vtsgr |= VT_UNDER;
|
|
break;
|
|
|
|
case 5: /* blinking */
|
|
svsp->vtsgr |= VT_BLINK;
|
|
break;
|
|
|
|
case 7: /* reverse */
|
|
svsp->vtsgr |= VT_INVERSE;
|
|
break;
|
|
|
|
case 22: /* not bold */
|
|
svsp->vtsgr &= ~VT_BOLD;
|
|
break;
|
|
|
|
case 24: /* not underlined */
|
|
svsp->vtsgr &= ~VT_UNDER;
|
|
break;
|
|
|
|
case 25: /* not blinking */
|
|
svsp->vtsgr &= ~VT_BLINK;
|
|
break;
|
|
|
|
case 27: /* not reverse */
|
|
svsp->vtsgr &= ~VT_INVERSE;
|
|
break;
|
|
|
|
case 30: /* foreground colors */
|
|
case 31:
|
|
case 32:
|
|
case 33:
|
|
case 34:
|
|
case 35:
|
|
case 36:
|
|
case 37:
|
|
if(color)
|
|
{
|
|
colortouched = 1;
|
|
setcolor |= ((fgansitopc[(svsp->parms[i-1]-30) & 7]) << 8);
|
|
}
|
|
break;
|
|
|
|
case 40: /* background colors */
|
|
case 41:
|
|
case 42:
|
|
case 43:
|
|
case 44:
|
|
case 45:
|
|
case 46:
|
|
case 47:
|
|
if(color)
|
|
{
|
|
colortouched = 1;
|
|
setcolor |= ((bgansitopc[(svsp->parms[i-1]-40) & 7]) << 8);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
while(i <= svsp->parmi);
|
|
if(color)
|
|
{
|
|
if(colortouched)
|
|
svsp->c_attr = setcolor;
|
|
else
|
|
svsp->c_attr = ((sgr_tab_color[svsp->vtsgr]) << 8);
|
|
}
|
|
else
|
|
{
|
|
if(adaptor_type == MDA_ADAPTOR)
|
|
svsp->c_attr = ((sgr_tab_imono[svsp->vtsgr]) << 8);
|
|
else
|
|
svsp->c_attr = ((sgr_tab_mono[svsp->vtsgr]) << 8);
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* CUU - cursor up
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
vt_cuu(struct video_state *svsp)
|
|
{
|
|
register int p = svsp->parms[0];
|
|
|
|
if (p <= 0) /* parameter min */
|
|
p = 1;
|
|
|
|
p = min(p, svsp->row - svsp->scrr_beg);
|
|
|
|
if (p <= 0)
|
|
return;
|
|
|
|
svsp->cur_offset -= (svsp->maxcol * p);
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* CUD - cursor down
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
vt_cud(struct video_state *svsp)
|
|
{
|
|
register int p = svsp->parms[0];
|
|
|
|
if (p <= 0)
|
|
p = 1;
|
|
|
|
p = min(p, svsp->scrr_end - svsp->row);
|
|
|
|
if (p <= 0)
|
|
return;
|
|
|
|
svsp->cur_offset += (svsp->maxcol * p);
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* CUF - cursor forward
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
vt_cuf(struct video_state *svsp)
|
|
{
|
|
register int p = svsp->parms[0];
|
|
|
|
if(svsp->col == ((svsp->maxcol)-1)) /* already at right margin */
|
|
return;
|
|
|
|
if(p <= 0) /* parameter min = 1 */
|
|
p = 1;
|
|
else if(p > ((svsp->maxcol)-1)) /* parameter max = 79 */
|
|
p = ((svsp->maxcol)-1);
|
|
|
|
if((svsp->col + p) > ((svsp->maxcol)-1))/* not more than right margin */
|
|
p = ((svsp->maxcol)-1) - svsp->col;
|
|
|
|
svsp->cur_offset += p;
|
|
svsp->col += p;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* CUB - cursor backward
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
vt_cub(struct video_state *svsp)
|
|
{
|
|
register int p = svsp->parms[0];
|
|
|
|
if(svsp->col == 0) /* already at left margin ? */
|
|
return;
|
|
|
|
if(p <= 0) /* parameter min = 1 */
|
|
p = 1;
|
|
else if(p > ((svsp->maxcol)-1)) /* parameter max = 79 */
|
|
p = ((svsp->maxcol)-1);
|
|
|
|
if((svsp->col - p) <= 0) /* not more than left margin */
|
|
p = svsp->col;
|
|
|
|
svsp->cur_offset -= p;
|
|
svsp->col -= p;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* ED - erase in display
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
vt_clreos(struct video_state *svsp)
|
|
{
|
|
switch(svsp->parms[0])
|
|
{
|
|
case 0:
|
|
fillw(user_attr | ' ', svsp->Crtat + svsp->cur_offset,
|
|
svsp->Crtat +
|
|
(svsp->maxcol * svsp->screen_rows) -
|
|
(svsp->Crtat + svsp->cur_offset));
|
|
break;
|
|
|
|
case 1:
|
|
fillw(user_attr | ' ', svsp->Crtat,
|
|
svsp->Crtat + svsp->cur_offset -
|
|
svsp->Crtat + 1 );
|
|
break;
|
|
|
|
case 2:
|
|
fillw(user_attr | ' ', svsp->Crtat,
|
|
svsp->maxcol * svsp->screen_rows);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* EL - erase in line
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
vt_clreol(struct video_state *svsp)
|
|
{
|
|
switch(svsp->parms[0])
|
|
{
|
|
case 0:
|
|
fillw(user_attr | ' ',
|
|
svsp->Crtat + svsp->cur_offset,
|
|
svsp->maxcol-svsp->col);
|
|
break;
|
|
|
|
case 1:
|
|
fillw(user_attr | ' ',
|
|
svsp->Crtat + svsp->cur_offset - svsp->col,
|
|
svsp->col + 1);
|
|
break;
|
|
|
|
case 2:
|
|
fillw(user_attr | ' ',
|
|
svsp->Crtat + svsp->cur_offset - svsp->col,
|
|
svsp->maxcol);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* CUP - cursor position / HVP - horizontal & vertical position
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
vt_curadr(struct video_state *svsp)
|
|
{
|
|
if(svsp->m_om) /* relative to scrolling region */
|
|
{
|
|
if((svsp->parms[0] == 0) && (svsp->parms[1] == 0))
|
|
{
|
|
svsp->cur_offset = svsp->scrr_beg * svsp->maxcol;
|
|
svsp->col = 0;
|
|
svsp->abs_write = 0;
|
|
return;
|
|
}
|
|
|
|
if(svsp->parms[0] <= 0)
|
|
svsp->parms[0] = 1;
|
|
else if(svsp->parms[0] > svsp->scrr_len)
|
|
svsp->parms[0] = svsp->scrr_len;
|
|
|
|
if(svsp->parms[1] <= 0 )
|
|
svsp->parms[1] = 1;
|
|
if(svsp->parms[1] > svsp->maxcol)
|
|
svsp->parms[1] = svsp->maxcol;
|
|
|
|
svsp->cur_offset = (svsp->scrr_beg * svsp->maxcol) +
|
|
((svsp->parms[0] - 1) * svsp->maxcol) +
|
|
svsp->parms[1] - 1;
|
|
svsp->col = svsp->parms[1] - 1;
|
|
svsp->abs_write = 0;
|
|
}
|
|
else /* relative to screen start */
|
|
{
|
|
if((svsp->parms[0] == 0) && (svsp->parms[1] == 0))
|
|
{
|
|
svsp->cur_offset = 0;
|
|
svsp->col = 0;
|
|
svsp->abs_write = 0;
|
|
return;
|
|
}
|
|
|
|
if(svsp->parms[0] <= 0)
|
|
svsp->parms[0] = 1;
|
|
else if(svsp->parms[0] > svsp->screen_rows)
|
|
svsp->parms[0] = svsp->screen_rows;
|
|
|
|
if(svsp->parms[1] <= 0 )
|
|
svsp->parms[1] = 1;
|
|
if(svsp->parms[1] > svsp->maxcol) /* col */
|
|
svsp->parms[1] = svsp->maxcol;
|
|
|
|
svsp->cur_offset = (((svsp->parms[0]-1)*svsp->maxcol) +
|
|
(svsp->parms[1]-1));
|
|
svsp->col = svsp->parms[1]-1;
|
|
|
|
if (svsp->cur_offset >=
|
|
((svsp->scrr_beg + svsp->scrr_len + 1) * svsp->maxcol))
|
|
|
|
svsp->abs_write = 1;
|
|
else
|
|
svsp->abs_write = 0;
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* RIS - reset to initial state (hard emulator runtime reset)
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
vt_ris(struct video_state *svsp)
|
|
{
|
|
fillw(user_attr | ' ', svsp->Crtat, svsp->maxcol * svsp->screen_rows);
|
|
svsp->cur_offset = 0; /* cursor upper left corner */
|
|
svsp->col = 0;
|
|
svsp->row = 0;
|
|
svsp->lnm = 0; /* CR only */
|
|
clear_dld(svsp); /* clear download charset */
|
|
vt_clearudk(svsp); /* clear user defined keys */
|
|
svsp->selchar = 0; /* selective attribute off */
|
|
vt_str(svsp); /* and soft terminal reset */
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* DECSTR - soft terminal reset (SOFT emulator runtime reset)
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
vt_str(struct video_state *svsp)
|
|
{
|
|
int i;
|
|
|
|
clr_parms(svsp); /* escape parameter init */
|
|
svsp->state = STATE_INIT; /* initial state */
|
|
|
|
svsp->dis_fnc = 0; /* display functions reset */
|
|
|
|
svsp->sc_flag = 0; /* save cursor position */
|
|
svsp->transparent = 0; /* enable control code processing */
|
|
|
|
for(i = 0; i < MAXTAB; i++) /* setup tabstops */
|
|
{
|
|
if(!(i % 8))
|
|
svsp->tab_stops[i] = 1;
|
|
else
|
|
svsp->tab_stops[i] = 0;
|
|
}
|
|
|
|
svsp->irm = 0; /* replace mode */
|
|
svsp->m_om = 0; /* origin mode */
|
|
svsp->m_awm = 1; /* auto wrap mode */
|
|
|
|
#if PCVT_INHIBIT_NUMLOCK
|
|
svsp->num_lock = 0; /* keypad application mode */
|
|
#else
|
|
svsp->num_lock = 1; /* keypad numeric mode */
|
|
#endif
|
|
|
|
svsp->scroll_lock = 0; /* reset keyboard modes */
|
|
svsp->caps_lock = 0;
|
|
|
|
svsp->ckm = 1; /* cursor key mode = "normal" ... */
|
|
svsp->scrr_beg = 0; /* start of scrolling region */
|
|
svsp->scrr_len = svsp->screen_rows; /* no. of lines in scrolling region */
|
|
svsp->abs_write = 0; /* scrr is complete screen */
|
|
svsp->scrr_end = svsp->scrr_len - 1;
|
|
|
|
if(adaptor_type == EGA_ADAPTOR || adaptor_type == VGA_ADAPTOR)
|
|
{
|
|
svsp->G0 = cse_ascii; /* G0 = ascii */
|
|
svsp->G1 = cse_ascii; /* G1 = ascii */
|
|
svsp->G2 = cse_supplemental; /* G2 = supplemental */
|
|
svsp->G3 = cse_supplemental; /* G3 = supplemental */
|
|
svsp->GL = &svsp->G0; /* GL = G0 */
|
|
svsp->GR = &svsp->G2; /* GR = G2 */
|
|
}
|
|
else
|
|
{
|
|
svsp->G0 = csd_ascii; /* G0 = ascii */
|
|
svsp->G1 = csd_ascii; /* G1 = ascii */
|
|
svsp->G2 = csd_supplemental; /* G2 = supplemental */
|
|
svsp->G3 = csd_supplemental; /* G3 = supplemental */
|
|
svsp->GL = &svsp->G0; /* GL = G0 */
|
|
svsp->GR = &svsp->G2; /* GR = G2 */
|
|
}
|
|
|
|
svsp->vtsgr = VT_NORMAL; /* no attributes */
|
|
svsp->c_attr = user_attr; /* reset sgr to normal */
|
|
|
|
svsp->selchar = 0; /* selective attribute off */
|
|
vt_initsel(svsp);
|
|
|
|
init_ufkl(svsp); /* init user fkey labels */
|
|
init_sfkl(svsp); /* init system fkey labels */
|
|
|
|
update_led(); /* update keyboard LED's */
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* RI - reverse index, move cursor up
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
vt_ri(struct video_state *svsp)
|
|
{
|
|
if(svsp->cur_offset >= ((svsp->scrr_beg * svsp->maxcol) + svsp->maxcol))
|
|
svsp->cur_offset -= svsp->maxcol;
|
|
else
|
|
roll_down(svsp, 1);
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* IND - index, move cursor down
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
vt_ind(struct video_state *svsp)
|
|
{
|
|
if(svsp->cur_offset < (svsp->scrr_end * svsp->maxcol))
|
|
svsp->cur_offset += svsp->maxcol;
|
|
else
|
|
roll_up(svsp, 1);
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* NEL - next line, first pos of next line
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
vt_nel(struct video_state *svsp)
|
|
{
|
|
if(svsp->cur_offset < (svsp->scrr_end * svsp->maxcol))
|
|
{
|
|
svsp->cur_offset += (svsp->maxcol-svsp->col);
|
|
svsp->col = 0;
|
|
}
|
|
else
|
|
{
|
|
roll_up(svsp, 1);
|
|
svsp->cur_offset -= svsp->col;
|
|
svsp->col = 0;
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* set dec private modes, esc [ ? x h
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
vt_set_dec_priv_qm(struct video_state *svsp)
|
|
{
|
|
switch(svsp->parms[0])
|
|
{
|
|
case 0: /* error, ignored */
|
|
case 1: /* CKM - cursor key mode */
|
|
svsp->ckm = 1;
|
|
break;
|
|
|
|
case 2: /* ANM - ansi/vt52 mode */
|
|
break;
|
|
|
|
case 3: /* COLM - column mode */
|
|
vt_col(svsp, SCR_COL132);
|
|
break;
|
|
|
|
case 4: /* SCLM - scrolling mode */
|
|
case 5: /* SCNM - screen mode */
|
|
break;
|
|
|
|
case 6: /* OM - origin mode */
|
|
svsp->m_om = 1;
|
|
break;
|
|
|
|
case 7: /* AWM - auto wrap mode */
|
|
svsp->m_awm = 1;
|
|
swritefkl(7,(u_char *)"AUTOWRAPENABLE *",svsp);
|
|
break;
|
|
|
|
case 8: /* ARM - auto repeat mode */
|
|
kbrepflag = 1;
|
|
break;
|
|
|
|
case 9: /* INLM - interlace mode */
|
|
case 10: /* EDM - edit mode */
|
|
case 11: /* LTM - line transmit mode */
|
|
case 12: /* */
|
|
case 13: /* SCFDM - space compression / field delimiting */
|
|
case 14: /* TEM - transmit execution mode */
|
|
case 15: /* */
|
|
case 16: /* EKEM - edit key execution mode */
|
|
break;
|
|
|
|
case 25: /* TCEM - text cursor enable mode */
|
|
if(vsp == svsp)
|
|
sw_cursor(1); /* cursor on */
|
|
svsp->cursor_on = 1;
|
|
break;
|
|
|
|
case 42: /* NRCM - 7bit NRC characters */
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* reset dec private modes, esc [ ? x l
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
vt_reset_dec_priv_qm(struct video_state *svsp)
|
|
{
|
|
switch(svsp->parms[0])
|
|
{
|
|
case 0: /* error, ignored */
|
|
case 1: /* CKM - cursor key mode */
|
|
svsp->ckm = 0;
|
|
break;
|
|
|
|
case 2: /* ANM - ansi/vt52 mode */
|
|
break;
|
|
|
|
case 3: /* COLM - column mode */
|
|
vt_col(svsp, SCR_COL80);
|
|
break;
|
|
|
|
case 4: /* SCLM - scrolling mode */
|
|
case 5: /* SCNM - screen mode */
|
|
break;
|
|
|
|
case 6: /* OM - origin mode */
|
|
svsp->m_om = 0;
|
|
break;
|
|
|
|
case 7: /* AWM - auto wrap mode */
|
|
svsp->m_awm = 0;
|
|
swritefkl(7,(u_char *)"AUTOWRAPENABLE ",svsp);
|
|
break;
|
|
|
|
case 8: /* ARM - auto repeat mode */
|
|
kbrepflag = 0;
|
|
break;
|
|
|
|
case 9: /* INLM - interlace mode */
|
|
case 10: /* EDM - edit mode */
|
|
case 11: /* LTM - line transmit mode */
|
|
case 12: /* */
|
|
case 13: /* SCFDM - space compression / field delimiting */
|
|
case 14: /* TEM - transmit execution mode */
|
|
case 15: /* */
|
|
case 16: /* EKEM - edit key execution mode */
|
|
break;
|
|
|
|
case 25: /* TCEM - text cursor enable mode */
|
|
if(vsp == svsp)
|
|
sw_cursor(0); /* cursor off */
|
|
svsp->cursor_on = 0;
|
|
break;
|
|
|
|
case 42: /* NRCM - 7bit NRC characters */
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* set ansi modes, esc [ x
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
vt_set_ansi(struct video_state *svsp)
|
|
{
|
|
switch(svsp->parms[0])
|
|
{
|
|
case 0: /* error, ignored */
|
|
case 1: /* GATM - guarded area transfer mode */
|
|
case 2: /* KAM - keyboard action mode */
|
|
case 3: /* CRM - Control Representation mode */
|
|
break;
|
|
|
|
case 4: /* IRM - insert replacement mode */
|
|
svsp->irm = 1; /* Insert mode */
|
|
break;
|
|
|
|
case 5: /* SRTM - status report transfer mode */
|
|
case 6: /* ERM - erasue mode */
|
|
case 7: /* VEM - vertical editing mode */
|
|
case 10: /* HEM - horizontal editing mode */
|
|
case 11: /* PUM - position unit mode */
|
|
case 12: /* SRM - send-receive mode */
|
|
case 13: /* FEAM - format effector action mode */
|
|
case 14: /* FETM - format effector transfer mode */
|
|
case 15: /* MATM - multiple area transfer mode */
|
|
case 16: /* TTM - transfer termination */
|
|
case 17: /* SATM - selected area transfer mode */
|
|
case 18: /* TSM - tabulation stop mode */
|
|
case 19: /* EBM - editing boundary mode */
|
|
break;
|
|
|
|
case 20: /* LNM - line feed / newline mode */
|
|
svsp->lnm = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* reset ansi modes, esc [ x
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
vt_reset_ansi(struct video_state *svsp)
|
|
{
|
|
switch(svsp->parms[0])
|
|
{
|
|
case 0: /* error, ignored */
|
|
case 1: /* GATM - guarded area transfer mode */
|
|
case 2: /* KAM - keyboard action mode */
|
|
case 3: /* CRM - Control Representation mode */
|
|
break;
|
|
|
|
case 4: /* IRM - insert replacement mode */
|
|
svsp->irm = 0; /* Replace mode */
|
|
break;
|
|
|
|
case 5: /* SRTM - status report transfer mode */
|
|
case 6: /* ERM - erasue mode */
|
|
case 7: /* VEM - vertical editing mode */
|
|
case 10: /* HEM - horizontal editing mode */
|
|
case 11: /* PUM - position unit mode */
|
|
case 12: /* SRM - send-receive mode */
|
|
case 13: /* FEAM - format effector action mode */
|
|
case 14: /* FETM - format effector transfer mode */
|
|
case 15: /* MATM - multiple area transfer mode */
|
|
case 16: /* TTM - transfer termination */
|
|
case 17: /* SATM - selected area transfer mode */
|
|
case 18: /* TSM - tabulation stop mode */
|
|
case 19: /* EBM - editing boundary mode */
|
|
break;
|
|
|
|
case 20: /* LNM - line feed / newline mode */
|
|
svsp->lnm = 0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* clear tab stop(s)
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
vt_clrtab(struct video_state *svsp)
|
|
{
|
|
int i;
|
|
|
|
if(svsp->parms[0] == 0)
|
|
svsp->tab_stops[svsp->col] = 0;
|
|
else if(svsp->parms[0] == 3)
|
|
{
|
|
for(i=0; i<MAXTAB; i++)
|
|
svsp->tab_stops[i] = 0;
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* DECSC - save cursor & attributes
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
vt_sc(struct video_state *svsp)
|
|
{
|
|
svsp->sc_flag = 1;
|
|
svsp->sc_row = svsp->row;
|
|
svsp->sc_col = svsp->col;
|
|
svsp->sc_cur_offset = svsp->cur_offset;
|
|
svsp->sc_attr = svsp->c_attr;
|
|
svsp->sc_awm = svsp->m_awm;
|
|
svsp->sc_om = svsp->m_om;
|
|
svsp->sc_G0 = svsp->G0;
|
|
svsp->sc_G1 = svsp->G1;
|
|
svsp->sc_G2 = svsp->G2;
|
|
svsp->sc_G3 = svsp->G3;
|
|
svsp->sc_GL = svsp->GL;
|
|
svsp->sc_GR = svsp->GR;
|
|
svsp->sc_sel = svsp->selchar;
|
|
svsp->sc_vtsgr = svsp->vtsgr;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* DECRC - restore cursor & attributes
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
vt_rc(struct video_state *svsp)
|
|
{
|
|
if(svsp->sc_flag == 1)
|
|
{
|
|
svsp->sc_flag = 0;
|
|
svsp->row = svsp->sc_row;
|
|
svsp->col = svsp->sc_col;
|
|
svsp->cur_offset = svsp->sc_cur_offset;
|
|
svsp->c_attr = svsp->sc_attr;
|
|
svsp->m_awm = svsp->sc_awm;
|
|
svsp->m_om = svsp->sc_om;
|
|
svsp->G0 = svsp->sc_G0;
|
|
svsp->G1 = svsp->sc_G1;
|
|
svsp->G2 = svsp->sc_G2;
|
|
svsp->G3 = svsp->sc_G3;
|
|
svsp->GL = svsp->sc_GL;
|
|
svsp->GR = svsp->sc_GR;
|
|
svsp->selchar = svsp->sc_sel;
|
|
svsp->vtsgr = svsp->sc_vtsgr;
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* designate a character set as G0, G1, G2 or G3 for 94/96 char sets
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
vt_designate(struct video_state *svsp)
|
|
{
|
|
u_short *ctp = NULL;
|
|
u_char ch;
|
|
|
|
if(svsp->whichi == 1)
|
|
ch = svsp->which[0];
|
|
else
|
|
{
|
|
int i;
|
|
|
|
if(svsp->dld_id[0] == '\0')
|
|
return;
|
|
|
|
if(!(((adaptor_type == EGA_ADAPTOR) ||
|
|
(adaptor_type == VGA_ADAPTOR)) &&
|
|
(vgacs[svsp->vga_charset].secondloaded)))
|
|
{
|
|
return;
|
|
}
|
|
|
|
for(i = (svsp->whichi)-1; i >= 0; i--)
|
|
{
|
|
if(svsp->which[i] != svsp->dld_id[i])
|
|
return;
|
|
}
|
|
#ifdef HAVECSE_DOWNLOADABLE
|
|
ctp = cse_downloadable;
|
|
swcsp(svsp, ctp);
|
|
#endif
|
|
return;
|
|
}
|
|
|
|
if(((adaptor_type == EGA_ADAPTOR) || (adaptor_type == VGA_ADAPTOR)) &&
|
|
(vgacs[svsp->vga_charset].secondloaded))
|
|
{
|
|
if((ch == svsp->dld_id[0]) && (svsp->dld_id[1] == '\0'))
|
|
{
|
|
#ifdef HAVECSE_DOWNLOADABLE
|
|
ctp = cse_downloadable;
|
|
swcsp(svsp, ctp);
|
|
#endif
|
|
return;
|
|
}
|
|
|
|
switch(ch)
|
|
{
|
|
case 'A': /* British or ISO-Latin-1 */
|
|
switch(svsp->state)
|
|
{
|
|
case STATE_BROPN: /* designate G0 */
|
|
case STATE_BRCLO: /* designate G1 */
|
|
case STATE_STAR: /* designate G2 */
|
|
case STATE_PLUS: /* designate G3 */
|
|
#ifdef HAVECSE_BRITISH
|
|
ctp = cse_british;
|
|
#endif
|
|
break;
|
|
|
|
case STATE_MINUS: /* designate G1 (96)*/
|
|
case STATE_DOT: /* designate G2 (96)*/
|
|
case STATE_SLASH: /* designate G3 (96)*/
|
|
#ifdef HAVECSE_ISOLATIN
|
|
ctp = cse_isolatin;
|
|
#endif
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case 'B': /* USASCII */
|
|
#ifdef HAVECSE_ASCII
|
|
ctp = cse_ascii;
|
|
#endif
|
|
break;
|
|
|
|
case 'C': /* Finnish */
|
|
case '5': /* Finnish */
|
|
#ifdef HAVECSE_FINNISH
|
|
ctp = cse_finnish;
|
|
#endif
|
|
break;
|
|
|
|
case 'E': /* Norwegian/Danish */
|
|
case '6': /* Norwegian/Danish */
|
|
#ifdef HAVECSE_NORWEGIANDANISH
|
|
ctp = cse_norwegiandanish;
|
|
#endif
|
|
break;
|
|
|
|
case 'H': /* Swedish */
|
|
case '7': /* Swedish */
|
|
#ifdef HAVECSE_SWEDISH
|
|
ctp = cse_swedish;
|
|
#endif
|
|
break;
|
|
|
|
case 'K': /* German */
|
|
#ifdef HAVECSE_GERMAN
|
|
ctp = cse_german;
|
|
#endif
|
|
break;
|
|
|
|
case 'Q': /* French Canadien */
|
|
#ifdef HAVECSE_FRENCHCANADA
|
|
ctp = cse_frenchcanada;
|
|
#endif
|
|
break;
|
|
|
|
case 'R': /* French */
|
|
#ifdef HAVECSE_FRENCH
|
|
ctp = cse_french;
|
|
#endif
|
|
break;
|
|
|
|
case 'Y': /* Italian */
|
|
#ifdef HAVECSE_ITALIAN
|
|
ctp = cse_italian;
|
|
#endif
|
|
break;
|
|
|
|
case 'Z': /* Spanish */
|
|
#ifdef HAVECSE_SPANISH
|
|
ctp = cse_spanish;
|
|
#endif
|
|
break;
|
|
|
|
case '0': /* special graphics */
|
|
#ifdef HAVECSE_SPECIAL
|
|
ctp = cse_special;
|
|
#endif
|
|
break;
|
|
|
|
case '1': /* alternate ROM */
|
|
#ifdef HAVECSE_ALTERNATEROM1
|
|
ctp = cse_alternaterom1;
|
|
#endif
|
|
break;
|
|
|
|
case '2': /* alt ROM, spec graphics */
|
|
#ifdef HAVECSE_ALTERNATEROM2
|
|
ctp = cse_alternaterom2;
|
|
#endif
|
|
break;
|
|
|
|
case '3': /* HP Roman 8, upper 128 chars*/
|
|
#ifdef HAVECSE_ROMAN8
|
|
ctp = cse_roman8;
|
|
#endif
|
|
break;
|
|
|
|
case '4': /* Dutch */
|
|
#ifdef HAVECSE_DUTCH
|
|
ctp = cse_dutch;
|
|
#endif
|
|
break;
|
|
|
|
case '<': /* DEC Supplemental */
|
|
#ifdef HAVECSE_SUPPLEMENTAL
|
|
ctp = cse_supplemental;
|
|
#endif
|
|
break;
|
|
|
|
case '=': /* Swiss */
|
|
#ifdef HAVECSE_SWISS
|
|
ctp = cse_swiss;
|
|
#endif
|
|
break;
|
|
|
|
case '>': /* DEC Technical */
|
|
#ifdef HAVECSE_TECHNICAL
|
|
ctp = cse_technical;
|
|
#endif
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch(ch)
|
|
{
|
|
case 'A': /* British or ISO-Latin-1 */
|
|
switch(svsp->state)
|
|
{
|
|
case STATE_BROPN: /* designate G0 */
|
|
case STATE_BRCLO: /* designate G1 */
|
|
case STATE_STAR: /* designate G2 */
|
|
case STATE_PLUS: /* designate G3 */
|
|
#ifdef HAVECSD_BRITISH
|
|
ctp = csd_british;
|
|
#endif
|
|
break;
|
|
|
|
case STATE_MINUS: /* designate G1 (96)*/
|
|
case STATE_DOT: /* designate G2 (96)*/
|
|
case STATE_SLASH: /* designate G3 (96)*/
|
|
#ifdef HAVECSD_ISOLATIN
|
|
ctp = csd_isolatin;
|
|
#endif
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case 'B': /* USASCII */
|
|
#ifdef HAVECSD_ASCII
|
|
ctp = csd_ascii;
|
|
#endif
|
|
break;
|
|
|
|
case 'C': /* Finnish */
|
|
case '5': /* Finnish */
|
|
#ifdef HAVECSD_FINNISH
|
|
ctp = csd_finnish;
|
|
#endif
|
|
break;
|
|
|
|
case 'E': /* Norwegian/Danish */
|
|
case '6': /* Norwegian/Danish */
|
|
#ifdef HAVECSD_NORWEGIANDANISH
|
|
ctp = csd_norwegiandanish;
|
|
#endif
|
|
break;
|
|
|
|
case 'H': /* Swedish */
|
|
case '7': /* Swedish */
|
|
#ifdef HAVECSD_SWEDISH
|
|
ctp = csd_swedish;
|
|
#endif
|
|
break;
|
|
|
|
case 'K': /* German */
|
|
#ifdef HAVECSD_GERMAN
|
|
ctp = csd_german;
|
|
#endif
|
|
break;
|
|
|
|
case 'Q': /* French Canadien */
|
|
#ifdef HAVECSD_FRENCHCANADA
|
|
ctp = csd_frenchcanada;
|
|
#endif
|
|
break;
|
|
|
|
case 'R': /* French */
|
|
#ifdef HAVECSD_FRENCH
|
|
ctp = csd_french;
|
|
#endif
|
|
break;
|
|
|
|
case 'Y': /* Italian */
|
|
#ifdef HAVECSD_ITALIAN
|
|
ctp = csd_italian;
|
|
#endif
|
|
break;
|
|
|
|
case 'Z': /* Spanish */
|
|
#ifdef HAVECSD_SPANISH
|
|
ctp = csd_spanish;
|
|
#endif
|
|
break;
|
|
|
|
case '0': /* special graphics */
|
|
#ifdef HAVECSD_SPECIAL
|
|
ctp = csd_special;
|
|
#endif
|
|
break;
|
|
|
|
case '1': /* alternate ROM */
|
|
#ifdef HAVECSD_ALTERNATEROM1
|
|
ctp = csd_alternaterom1;
|
|
#endif
|
|
break;
|
|
|
|
case '2': /* alt ROM, spec graphics */
|
|
#ifdef HAVECSD_ALTERNATEROM2
|
|
ctp = csd_alternaterom2;
|
|
#endif
|
|
break;
|
|
|
|
case '3': /* HP Roman 8, upper 128 chars*/
|
|
#ifdef HAVECSD_ROMAN8
|
|
ctp = csd_roman8;
|
|
#endif
|
|
break;
|
|
|
|
case '4': /* Dutch */
|
|
#ifdef HAVECSD_DUTCH
|
|
ctp = csd_dutch;
|
|
#endif
|
|
break;
|
|
|
|
case '<': /* DEC Supplemental */
|
|
#ifdef HAVECSD_SUPPLEMENTAL
|
|
ctp = csd_supplemental;
|
|
#endif
|
|
break;
|
|
|
|
case '=': /* Swiss */
|
|
#ifdef HAVECSD_SWISS
|
|
ctp = csd_swiss;
|
|
#endif
|
|
break;
|
|
|
|
case '>': /* DEC Technical */
|
|
#ifdef HAVECSD_TECHNICAL
|
|
ctp = csd_technical;
|
|
#endif
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
swcsp(svsp, ctp);
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* device attributes
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
vt_da(struct video_state *svsp)
|
|
{
|
|
static u_char *response = (u_char *)DA_VT220;
|
|
|
|
svsp->report_chars = response;
|
|
svsp->report_count = 18;
|
|
respond(svsp);
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* screen alignment display
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
vt_aln(struct video_state *svsp)
|
|
{
|
|
register int i;
|
|
|
|
svsp->cur_offset = 0;
|
|
svsp->col = 0;
|
|
|
|
for(i=0; i < (svsp->screen_rows*svsp->maxcol); i++)
|
|
{
|
|
*(svsp->Crtat + svsp->cur_offset) = user_attr | 'E';
|
|
vt_selattr(svsp);
|
|
svsp->cur_offset++;
|
|
svsp->col++;
|
|
}
|
|
|
|
svsp->cur_offset = 0; /* reset everything ! */
|
|
svsp->col = 0;
|
|
svsp->row = 0;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* request terminal parameters
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
vt_reqtparm(struct video_state *svsp)
|
|
{
|
|
static u_char *answr = (u_char *)"\033[3;1;1;120;120;1;0x";
|
|
|
|
svsp->report_chars = answr;
|
|
svsp->report_count = 20;
|
|
respond(svsp);
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* invoke selftest
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
vt_tst(struct video_state *svsp)
|
|
{
|
|
clear_dld(svsp);
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* device status reports
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
vt_dsr(struct video_state *svsp)
|
|
{
|
|
static u_char *answr = (u_char *)"\033[0n";
|
|
static u_char *panswr = (u_char *)"\033[?13n"; /* Printer Unattached */
|
|
static u_char *udkanswr = (u_char *)"\033[?21n"; /* UDK Locked */
|
|
static u_char *langanswr = (u_char *)"\033[?27;1n"; /* North American*/
|
|
static u_char buffer[16];
|
|
int i = 0;
|
|
|
|
switch(svsp->parms[0])
|
|
{
|
|
case 5: /* return status */
|
|
svsp->report_chars = answr;
|
|
svsp->report_count = 4;
|
|
respond(svsp);
|
|
break;
|
|
|
|
case 6: /* return cursor position */
|
|
buffer[i++] = 0x1b;
|
|
buffer[i++] = '[';
|
|
if((svsp->row+1) > 10)
|
|
buffer[i++] = ((svsp->row+1) / 10) + '0';
|
|
buffer[i++] = ((svsp->row+1) % 10) + '0';
|
|
buffer[i++] = ';';
|
|
if((svsp->col+1) > 10)
|
|
buffer[i++] = ((svsp->col+1) / 10) + '0';
|
|
buffer[i++] = ((svsp->col+1) % 10) + '0';
|
|
buffer[i++] = 'R';
|
|
buffer[i++] = '\0';
|
|
|
|
svsp->report_chars = buffer;
|
|
svsp->report_count = i;
|
|
respond(svsp);
|
|
break;
|
|
|
|
case 15: /* return printer status */
|
|
svsp->report_chars = panswr;
|
|
svsp->report_count = 6;
|
|
respond(svsp);
|
|
break;
|
|
|
|
case 25: /* return udk status */
|
|
svsp->report_chars = udkanswr;
|
|
svsp->report_count = 6;
|
|
respond(svsp);
|
|
break;
|
|
|
|
case 26: /* return language status */
|
|
svsp->report_chars = langanswr;
|
|
svsp->report_count = 8;
|
|
respond(svsp);
|
|
break;
|
|
|
|
default: /* nothing else valid */
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* IL - insert line
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
vt_il(struct video_state *svsp)
|
|
{
|
|
register int p = svsp->parms[0];
|
|
|
|
if((svsp->row >= svsp->scrr_beg) && (svsp->row <= svsp->scrr_end))
|
|
{
|
|
if(p <= 0)
|
|
p = 1;
|
|
else if(p > svsp->scrr_end - svsp->row)
|
|
p = svsp->scrr_end - svsp->row;
|
|
|
|
svsp->cur_offset -= svsp->col;
|
|
svsp->col = 0;
|
|
if(svsp->row == svsp->scrr_beg)
|
|
roll_down(svsp, p);
|
|
else
|
|
{
|
|
bcopy(svsp->Crtat + svsp->cur_offset,
|
|
svsp->Crtat + svsp->cur_offset + (p * svsp->maxcol),
|
|
svsp->maxcol * (svsp->scrr_end-svsp->row+1-p) * CHR );
|
|
|
|
fillw(user_attr | ' ',
|
|
svsp->Crtat + svsp->cur_offset,
|
|
p * svsp->maxcol);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* ICH - insert character
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
vt_ic(struct video_state *svsp)
|
|
{
|
|
register int p = svsp->parms[0];
|
|
|
|
if(p <= 0)
|
|
p = 1;
|
|
else if(p > svsp->maxcol-svsp->col)
|
|
p = svsp->maxcol-svsp->col;
|
|
|
|
while(p--)
|
|
{
|
|
bcopy((svsp->Crtat + svsp->cur_offset),
|
|
(svsp->Crtat + svsp->cur_offset) + 1,
|
|
(((svsp->maxcol)-1)-svsp->col) * CHR);
|
|
|
|
*(svsp->Crtat + svsp->cur_offset) = user_attr | ' ';
|
|
vt_selattr(svsp);
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* DL - delete line
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
vt_dl(struct video_state *svsp)
|
|
{
|
|
register int p = svsp->parms[0];
|
|
|
|
if((svsp->row >= svsp->scrr_beg) && (svsp->row <= svsp->scrr_end))
|
|
{
|
|
if(p <= 0)
|
|
p = 1;
|
|
else if(p > svsp->scrr_end - svsp->row)
|
|
p = svsp->scrr_end - svsp->row;
|
|
|
|
svsp->cur_offset -= svsp->col;
|
|
svsp->col = 0;
|
|
|
|
if(svsp->row == svsp->scrr_beg)
|
|
roll_up(svsp, p);
|
|
else
|
|
{
|
|
bcopy(svsp->Crtat + svsp->cur_offset + (p * svsp->maxcol),
|
|
svsp->Crtat + svsp->cur_offset,
|
|
svsp->maxcol * (svsp->scrr_end-svsp->row+1-p) * CHR );
|
|
|
|
fillw(user_attr | ' ',
|
|
svsp->Crtat + ((svsp->scrr_end-p+1) * svsp->maxcol),
|
|
p * svsp->maxcol);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* DCH - delete character
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
vt_dch(struct video_state *svsp)
|
|
{
|
|
register int p = svsp->parms[0];
|
|
|
|
if(p <= 0)
|
|
p = 1;
|
|
else if(p > svsp->maxcol-svsp->col)
|
|
p = svsp->maxcol-svsp->col;
|
|
|
|
while(p--)
|
|
{
|
|
bcopy((svsp->Crtat + svsp->cur_offset)+1,
|
|
(svsp->Crtat + svsp->cur_offset),
|
|
(((svsp->maxcol)-1) - svsp->col)* CHR );
|
|
|
|
*((svsp->Crtat + svsp->cur_offset) +
|
|
((svsp->maxcol)-1)-svsp->col) = user_attr | ' ';
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* scroll up
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
vt_su(struct video_state *svsp)
|
|
{
|
|
register int p = svsp->parms[0];
|
|
|
|
if(p <= 0)
|
|
p = 1;
|
|
else if(p > svsp->screen_rows-1)
|
|
p = svsp->screen_rows-1;
|
|
|
|
roll_up(svsp, p);
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* scroll down
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
vt_sd(struct video_state *svsp)
|
|
{
|
|
register int p = svsp->parms[0];
|
|
|
|
if(p <= 0)
|
|
p = 1;
|
|
else if(p > svsp->screen_rows-1)
|
|
p = svsp->screen_rows-1;
|
|
|
|
roll_down(svsp, p);
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* ECH - erase character
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
vt_ech(struct video_state *svsp)
|
|
{
|
|
register int p = svsp->parms[0];
|
|
|
|
if(p <= 0)
|
|
p = 1;
|
|
else if(p > svsp->maxcol-svsp->col)
|
|
p = svsp->maxcol-svsp->col;
|
|
|
|
fillw(user_attr | ' ', (svsp->Crtat + svsp->cur_offset), p);
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* media copy (NO PRINTER AVAILABLE IN KERNEL ...)
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
vt_mc(struct video_state *svsp)
|
|
{
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* Device Control String State Machine Entry for:
|
|
*
|
|
* DECUDK - user-defined keys and
|
|
* DECDLD - downloadable charset
|
|
*
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
vt_dcsentry(U_char ch, struct video_state *svsp)
|
|
{
|
|
switch(svsp->dcs_state)
|
|
{
|
|
case DCS_INIT:
|
|
switch(ch)
|
|
{
|
|
case '0':
|
|
case '1':
|
|
case '2':
|
|
case '3':
|
|
case '4':
|
|
case '5':
|
|
case '6':
|
|
case '7':
|
|
case '8':
|
|
case '9': /* parameters */
|
|
svsp->parms[svsp->parmi] *= 10;
|
|
svsp->parms[svsp->parmi] += (ch -'0');
|
|
break;
|
|
|
|
case ';': /* next parameter */
|
|
svsp->parmi =
|
|
(svsp->parmi+1 < MAXPARMS) ?
|
|
svsp->parmi+1 : svsp->parmi;
|
|
break;
|
|
|
|
case '|': /* DECUDK */
|
|
svsp->transparent = 1;
|
|
init_udk(svsp);
|
|
svsp->dcs_state = DCS_AND_UDK;
|
|
break;
|
|
|
|
case '{': /* DECDLD */
|
|
svsp->transparent = 1;
|
|
init_dld(svsp);
|
|
svsp->dcs_state = DCS_DLD_DSCS;
|
|
break;
|
|
|
|
default: /* failsafe */
|
|
svsp->transparent = 0;
|
|
svsp->state = STATE_INIT;
|
|
svsp->dcs_state = DCS_INIT;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case DCS_AND_UDK: /* DCS ... | */
|
|
switch(ch)
|
|
{
|
|
case '0':
|
|
case '1':
|
|
case '2':
|
|
case '3':
|
|
case '4':
|
|
case '5':
|
|
case '6':
|
|
case '7':
|
|
case '8':
|
|
case '9': /* fkey number */
|
|
svsp->udk_fnckey *= 10;
|
|
svsp->udk_fnckey += (ch -'0');
|
|
break;
|
|
|
|
case '/': /* Key */
|
|
svsp->dcs_state = DCS_UDK_DEF;
|
|
break;
|
|
|
|
case 0x1b: /* ESC */
|
|
svsp->dcs_state = DCS_UDK_ESC;
|
|
break;
|
|
|
|
default:
|
|
svsp->transparent = 0;
|
|
svsp->state = STATE_INIT;
|
|
svsp->dcs_state = DCS_INIT;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case DCS_UDK_DEF: /* DCS ... | fnckey / */
|
|
switch(ch)
|
|
{
|
|
case '0':
|
|
case '1':
|
|
case '2':
|
|
case '3':
|
|
case '4':
|
|
case '5':
|
|
case '6':
|
|
case '7':
|
|
case '8':
|
|
case '9':
|
|
if(svsp->udk_deflow) /* low nibble */
|
|
{
|
|
svsp->udk_def[svsp->udk_defi] |= (ch -'0');
|
|
svsp->udk_deflow = 0;
|
|
svsp->udk_defi = (svsp->udk_defi+1 >= MAXUDKDEF) ?
|
|
svsp->udk_defi : svsp->udk_defi+1;
|
|
}
|
|
else /* high nibble */
|
|
{
|
|
svsp->udk_def[svsp->udk_defi] = ((ch -'0') << 4);
|
|
svsp->udk_deflow = 1;
|
|
}
|
|
break;
|
|
|
|
case 'a':
|
|
case 'b':
|
|
case 'c':
|
|
case 'd':
|
|
case 'e':
|
|
case 'f':
|
|
if(svsp->udk_deflow) /* low nibble */
|
|
{
|
|
svsp->udk_def[svsp->udk_defi] |= (ch - 'a' + 10);
|
|
svsp->udk_deflow = 0;
|
|
svsp->udk_defi = (svsp->udk_defi+1 >= MAXUDKDEF) ?
|
|
svsp->udk_defi : svsp->udk_defi+1;
|
|
}
|
|
else /* high nibble */
|
|
{
|
|
svsp->udk_def[svsp->udk_defi] = ((ch - 'a' + 10) << 4);
|
|
svsp->udk_deflow = 1;
|
|
}
|
|
break;
|
|
|
|
|
|
|
|
case 'A':
|
|
case 'B':
|
|
case 'C':
|
|
case 'D':
|
|
case 'E':
|
|
case 'F':
|
|
if(svsp->udk_deflow) /* low nibble */
|
|
{
|
|
svsp->udk_def[svsp->udk_defi] |= (ch - 'A' + 10);
|
|
svsp->udk_deflow = 0;
|
|
svsp->udk_defi = (svsp->udk_defi+1 >= MAXUDKDEF) ?
|
|
svsp->udk_defi : svsp->udk_defi+1;
|
|
}
|
|
else /* high nibble */
|
|
{
|
|
svsp->udk_def[svsp->udk_defi] = ((ch - 'A' + 10) << 4);
|
|
svsp->udk_deflow = 1;
|
|
}
|
|
break;
|
|
|
|
case ';': /* next function key */
|
|
vt_udk(svsp);
|
|
svsp->dcs_state = DCS_AND_UDK;
|
|
break;
|
|
|
|
case 0x1b: /* ESC */
|
|
svsp->dcs_state = DCS_UDK_ESC;
|
|
break;
|
|
|
|
default:
|
|
svsp->transparent = 0;
|
|
svsp->state = STATE_INIT;
|
|
svsp->dcs_state = DCS_INIT;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case DCS_UDK_ESC: /* DCS ... | fkey/def ... ESC */
|
|
switch(ch)
|
|
{
|
|
case '\\': /* ST */
|
|
vt_udk(svsp);
|
|
svsp->transparent = 0;
|
|
svsp->state = STATE_INIT;
|
|
svsp->dcs_state = DCS_INIT;
|
|
break;
|
|
|
|
default:
|
|
svsp->transparent = 0;
|
|
svsp->state = STATE_INIT;
|
|
svsp->dcs_state = DCS_INIT;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
|
|
case DCS_DLD_DSCS: /* got DCS ... { */
|
|
if(ch >= ' ' && ch <= '/') /* intermediates ... */
|
|
{
|
|
svsp->dld_dscs[svsp->dld_dscsi] = ch;
|
|
svsp->dld_id[svsp->dld_dscsi] = ch;
|
|
if(svsp->dld_dscsi >= DSCS_LENGTH)
|
|
{
|
|
svsp->transparent = 0;
|
|
svsp->state = STATE_INIT;
|
|
svsp->dcs_state = DCS_INIT;
|
|
svsp->dld_id[0] = '\0';
|
|
}
|
|
else
|
|
{
|
|
svsp->dld_dscsi++;
|
|
}
|
|
}
|
|
else if(ch >= '0' && ch <= '~') /* final .... */
|
|
{
|
|
svsp->dld_dscs[svsp->dld_dscsi] = ch;
|
|
svsp->dld_id[svsp->dld_dscsi++] = ch;
|
|
svsp->dld_id[svsp->dld_dscsi] = '\0';
|
|
svsp->dcs_state = DCS_DLD_DEF;
|
|
}
|
|
else
|
|
{
|
|
svsp->transparent = 0;
|
|
svsp->state = STATE_INIT;
|
|
svsp->dcs_state = DCS_INIT;
|
|
svsp->dld_id[0] = '\0';
|
|
}
|
|
break;
|
|
|
|
case DCS_DLD_DEF: /* DCS ... { dscs */
|
|
switch(ch)
|
|
{
|
|
case 0x1b: /* ESC */
|
|
svsp->dcs_state = DCS_DLD_ESC;
|
|
break;
|
|
|
|
case '/': /* sixel upper / lower divider */
|
|
svsp->dld_sixel_lower = 1;
|
|
break;
|
|
|
|
case ';': /* character divider */
|
|
vt_dld(svsp);
|
|
svsp->parms[1]++; /* next char */
|
|
break;
|
|
|
|
default:
|
|
if (svsp->dld_sixel_lower)
|
|
{
|
|
if(ch >= '?' && ch <= '~')
|
|
svsp->sixel.lower[svsp->dld_sixelli] = ch - '?';
|
|
svsp->dld_sixelli =
|
|
(svsp->dld_sixelli+1 < MAXSIXEL) ?
|
|
svsp->dld_sixelli+1 : svsp->dld_sixelli;
|
|
}
|
|
else
|
|
{
|
|
if(ch >= '?' && ch <= '~')
|
|
svsp->sixel.upper[svsp->dld_sixelui] = ch - '?';
|
|
svsp->dld_sixelui =
|
|
(svsp->dld_sixelui+1 < MAXSIXEL) ?
|
|
svsp->dld_sixelui+1 : svsp->dld_sixelui;
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case DCS_DLD_ESC: /* DCS ... { dscs ... / ... ESC */
|
|
switch(ch)
|
|
{
|
|
case '\\': /* String Terminator ST */
|
|
vt_dld(svsp);
|
|
svsp->transparent = 0;
|
|
svsp->state = STATE_INIT;
|
|
svsp->dcs_state = DCS_INIT;
|
|
break;
|
|
|
|
default:
|
|
svsp->transparent = 0;
|
|
svsp->state = STATE_INIT;
|
|
svsp->dcs_state = DCS_INIT;
|
|
svsp->dld_id[0] = '\0';
|
|
break;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
svsp->transparent = 0;
|
|
svsp->state = STATE_INIT;
|
|
svsp->dcs_state = DCS_INIT;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* User Defineable Keys
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
vt_udk(struct video_state *svsp)
|
|
{
|
|
int key, start, max, i;
|
|
int usedff = 0;
|
|
|
|
if(svsp->parms[0] != 1) /* clear all ? */
|
|
{
|
|
vt_clearudk(svsp);
|
|
svsp->parms[0] = 1;
|
|
}
|
|
|
|
if(svsp->udk_fnckey < 17 || svsp->udk_fnckey > 34)
|
|
{
|
|
init_udk(svsp);
|
|
return;
|
|
}
|
|
|
|
key = svsp->udk_fnckey - 17; /* index into table */
|
|
|
|
if(svsp->ukt.length[key] == 0) /* never used ? */
|
|
{
|
|
if(svsp->udkff < MAXUDKDEF-2) /* space available ? */
|
|
{
|
|
start = svsp->udkff; /* next sequential */
|
|
max = MAXUDKDEF - svsp->udkff; /* space available */
|
|
svsp->ukt.first[key] = start; /* start entry */
|
|
usedff = 1; /* flag to update later */
|
|
}
|
|
else /* no space */
|
|
{
|
|
init_udk(svsp);
|
|
return;
|
|
}
|
|
}
|
|
else /* in use, redefine */
|
|
{
|
|
start = svsp->ukt.first[key]; /* start entry */
|
|
max = svsp->ukt.length[key]; /* space available */
|
|
}
|
|
|
|
if(max < 2) /* hmmm .. */
|
|
{
|
|
init_udk(svsp);
|
|
return;
|
|
}
|
|
|
|
max--; /* adjust for tailing '\0' */
|
|
|
|
for(i = 0; i < max && i < svsp->udk_defi; i++)
|
|
svsp->udkbuf[start++] = svsp->udk_def[i];
|
|
|
|
svsp->udkbuf[start] = '\0'; /* make it a string, see pcvt_kbd.c */
|
|
svsp->ukt.length[key] = i+1; /* count for tailing '\0' */
|
|
if(usedff)
|
|
svsp->udkff += (i+2); /* new start location */
|
|
|
|
init_udk(svsp);
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* clear all User Defineable Keys
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
vt_clearudk(struct video_state *svsp)
|
|
{
|
|
register int i;
|
|
|
|
for(i = 0; i < MAXUDKEYS; i++)
|
|
{
|
|
svsp->ukt.first[i] = 0;
|
|
svsp->ukt.length[i] = 0;
|
|
}
|
|
svsp->udkff = 0;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* Down line LoaDable Fonts
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
vt_dld(struct video_state *svsp)
|
|
{
|
|
unsigned char vgacharset;
|
|
unsigned char vgachar[16];
|
|
unsigned char vgacharb[16];
|
|
|
|
if(vgacs[svsp->vga_charset].secondloaded)
|
|
vgacharset = vgacs[svsp->vga_charset].secondloaded;
|
|
else
|
|
return;
|
|
|
|
svsp->parms[1] = (svsp->parms[1] < 1) ? 1 :
|
|
((svsp->parms[1] > 0x7E) ? 0x7E : svsp->parms[1]);
|
|
|
|
if(svsp->parms[2] != 1) /* Erase all characters ? */
|
|
{
|
|
clear_dld(svsp);
|
|
svsp->parms[2] = 1; /* Only erase all characters once per sequence */
|
|
}
|
|
|
|
sixel_vga(&(svsp->sixel),vgachar);
|
|
|
|
switch(vgacs[vgacharset].char_scanlines & 0x1F)
|
|
{
|
|
case 7:
|
|
vga10_vga8(vgachar,vgacharb);
|
|
break;
|
|
|
|
case 9:
|
|
default:
|
|
vga10_vga10(vgachar,vgacharb);
|
|
break;
|
|
|
|
case 13:
|
|
vga10_vga14(vgachar,vgacharb);
|
|
break;
|
|
|
|
case 15:
|
|
vga10_vga16(vgachar,vgacharb);
|
|
break;
|
|
}
|
|
|
|
loadchar(vgacharset, svsp->parms[1] + 0xA0, 16, vgacharb);
|
|
|
|
init_dld(svsp);
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* select character attributes
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
vt_sca(struct video_state *svsp)
|
|
{
|
|
switch(svsp->parms[0])
|
|
{
|
|
case 1:
|
|
svsp->selchar = 1;
|
|
break;
|
|
case 0:
|
|
case 2:
|
|
default:
|
|
svsp->selchar = 0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* initalize selective attribute bit array
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
vt_initsel(struct video_state *svsp)
|
|
{
|
|
register int i;
|
|
|
|
for(i = 0;i < MAXDECSCA;i++)
|
|
svsp->decsca[i] = 0;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* DECSEL - selective erase in line
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
vt_sel(struct video_state *svsp)
|
|
{
|
|
switch(svsp->parms[0])
|
|
{
|
|
case 0:
|
|
selective_erase(svsp, (svsp->Crtat + svsp->cur_offset),
|
|
svsp->maxcol-svsp->col);
|
|
break;
|
|
|
|
case 1:
|
|
selective_erase(svsp, (svsp->Crtat + svsp->cur_offset)-
|
|
svsp->col, svsp->col + 1);
|
|
break;
|
|
|
|
case 2:
|
|
selective_erase(svsp, (svsp->Crtat + svsp->cur_offset)-
|
|
svsp->col, svsp->maxcol);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* DECSED - selective erase in display
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
vt_sed(struct video_state *svsp)
|
|
{
|
|
switch(svsp->parms[0])
|
|
{
|
|
case 0:
|
|
selective_erase(svsp, (svsp->Crtat + svsp->cur_offset),
|
|
svsp->Crtat + (svsp->maxcol * svsp->screen_rows) -
|
|
(svsp->Crtat + svsp->cur_offset));
|
|
break;
|
|
|
|
case 1:
|
|
selective_erase(svsp, svsp->Crtat,
|
|
(svsp->Crtat + svsp->cur_offset) - svsp->Crtat + 1 );
|
|
break;
|
|
|
|
case 2:
|
|
selective_erase(svsp, svsp->Crtat,
|
|
svsp->maxcol * svsp->screen_rows);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* scroll screen n lines up
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
roll_up(struct video_state *svsp, int n)
|
|
{
|
|
|
|
#if (PCVT_NOFASTSCROLL==0)
|
|
|
|
if(svsp->scrr_beg == 0 && /* if scroll region is whole screen */
|
|
svsp->scrr_len == svsp->screen_rows &&
|
|
(svsp != vsp || /* and either running in memory */
|
|
(svsp->screen_rows == svsp->screen_rowsize && /* or no fkeys */
|
|
adaptor_type != MDA_ADAPTOR))) /* and not on MDA/Hercules */
|
|
{
|
|
u_short *Memory =
|
|
|
|
#if PCVT_USL_VT_COMPAT
|
|
(vsp != svsp || (vsp->vt_status & VT_GRAFX)) ?
|
|
#else
|
|
(vsp != svsp) ?
|
|
#endif
|
|
|
|
svsp->Memory : Crtat;
|
|
|
|
if(svsp->Crtat > (Memory + (svsp->screen_rows - n) *
|
|
svsp->maxcol))
|
|
{
|
|
bcopy(svsp->Crtat + svsp->maxcol * n, Memory,
|
|
svsp->maxcol * (svsp->screen_rows - n) * CHR);
|
|
|
|
svsp->Crtat = Memory;
|
|
}
|
|
else
|
|
{
|
|
svsp->Crtat += n * svsp->maxcol;
|
|
}
|
|
|
|
#if PCVT_USL_VT_COMPAT
|
|
if(vsp == svsp && !(vsp->vt_status & VT_GRAFX))
|
|
#else
|
|
if(vsp == svsp)
|
|
#endif
|
|
|
|
{
|
|
outb(addr_6845, CRTC_STARTADRH);
|
|
outb(addr_6845+1, (svsp->Crtat - Crtat) >> 8);
|
|
outb(addr_6845, CRTC_STARTADRL);
|
|
outb(addr_6845+1, (svsp->Crtat - Crtat));
|
|
}
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
bcopy( svsp->Crtat + ((svsp->scrr_beg + n) * svsp->maxcol),
|
|
svsp->Crtat + (svsp->scrr_beg * svsp->maxcol),
|
|
svsp->maxcol * (svsp->scrr_len - n) * CHR );
|
|
}
|
|
|
|
fillw( user_attr | ' ',
|
|
svsp->Crtat + ((svsp->scrr_end - n + 1) * svsp->maxcol),
|
|
n * svsp->maxcol);
|
|
|
|
/*XXX*/ if(svsp->scroll_lock && svsp->openf && curproc)
|
|
tsleep((caddr_t)&(svsp->scroll_lock), PUSER, "scrlck", 0);
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* scroll screen n lines down
|
|
*---------------------------------------------------------------------------*/
|
|
static void
|
|
roll_down(struct video_state *svsp, int n)
|
|
{
|
|
|
|
#if (PCVT_NOFASTSCROLL==0)
|
|
|
|
if(svsp->scrr_beg == 0 && /* if scroll region is whole screen */
|
|
svsp->scrr_len == svsp->screen_rows &&
|
|
(svsp != vsp || /* and either running in memory */
|
|
(svsp->screen_rows == svsp->screen_rowsize && /* or no fkeys */
|
|
adaptor_type != MDA_ADAPTOR))) /* and not on MDA/Hercules */
|
|
{
|
|
u_short *Memory =
|
|
|
|
#if PCVT_USL_VT_COMPAT
|
|
(vsp != svsp || (vsp->vt_status & VT_GRAFX)) ?
|
|
#else
|
|
(vsp != svsp) ?
|
|
#endif
|
|
svsp->Memory : Crtat;
|
|
|
|
if (svsp->Crtat < (Memory + n * svsp->maxcol))
|
|
{
|
|
bcopy(svsp->Crtat,
|
|
Memory + svsp->maxcol * (svsp->screen_rows + n),
|
|
svsp->maxcol * (svsp->screen_rows - n) * CHR);
|
|
|
|
svsp->Crtat = Memory + svsp->maxcol * svsp->screen_rows;
|
|
}
|
|
else
|
|
{
|
|
svsp->Crtat -= n * svsp->maxcol;
|
|
}
|
|
|
|
#if PCVT_USL_VT_COMPAT
|
|
if(vsp == svsp && !(vsp->vt_status & VT_GRAFX))
|
|
#else
|
|
if(vsp == svsp)
|
|
#endif
|
|
|
|
{
|
|
outb(addr_6845, CRTC_STARTADRH);
|
|
outb(addr_6845+1, (svsp->Crtat - Crtat) >> 8);
|
|
outb(addr_6845, CRTC_STARTADRL);
|
|
outb(addr_6845+1, (svsp->Crtat - Crtat));
|
|
}
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
bcopy( svsp->Crtat + (svsp->scrr_beg * svsp->maxcol),
|
|
svsp->Crtat + ((svsp->scrr_beg + n) * svsp->maxcol),
|
|
svsp->maxcol * (svsp->scrr_len - n) * CHR );
|
|
}
|
|
|
|
fillw( user_attr | ' ',
|
|
svsp->Crtat + (svsp->scrr_beg * svsp->maxcol),
|
|
n * svsp->maxcol);
|
|
|
|
/*XXX*/ if(svsp->scroll_lock && svsp->openf && curproc)
|
|
tsleep((caddr_t)&(svsp->scroll_lock), PUSER, "scrlck", 0);
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* switch charset pointers
|
|
*---------------------------------------------------------------------------*/
|
|
static void
|
|
swcsp(struct video_state *svsp, u_short *ctp)
|
|
{
|
|
if(ctp == NULL)
|
|
return;
|
|
|
|
switch(svsp->state)
|
|
{
|
|
case STATE_BROPN: /* designate G0 */
|
|
svsp->G0 = ctp;
|
|
break;
|
|
|
|
case STATE_BRCLO: /* designate G1 */
|
|
case STATE_MINUS: /* designate G1 (96) */
|
|
svsp->G1 = ctp;
|
|
break;
|
|
|
|
case STATE_STAR: /* designate G2 */
|
|
case STATE_DOT: /* designate G2 (96) */
|
|
svsp->G2 = ctp;
|
|
break;
|
|
|
|
case STATE_PLUS: /* designate G3 */
|
|
case STATE_SLASH: /* designate G3 (96) */
|
|
svsp->G3 = ctp;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* process terminal responses
|
|
*---------------------------------------------------------------------------*/
|
|
static void
|
|
respond(struct video_state *svsp)
|
|
{
|
|
if(!(svsp->openf)) /* are we opened ? */
|
|
return;
|
|
|
|
while (*svsp->report_chars && svsp->report_count > 0)
|
|
{
|
|
(*linesw[svsp->vs_tty->t_line].l_rint)
|
|
(*svsp->report_chars++ & 0xff, svsp->vs_tty);
|
|
svsp->report_count--;
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* Initialization for User Defineable Keys
|
|
*---------------------------------------------------------------------------*/
|
|
static void
|
|
init_udk(struct video_state *svsp)
|
|
{
|
|
svsp->udk_defi = 0;
|
|
svsp->udk_deflow = 0;
|
|
svsp->udk_fnckey = 0;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* Clear loaded downloadable (DLD) character set
|
|
*---------------------------------------------------------------------------*/
|
|
static void
|
|
clear_dld(struct video_state *svsp)
|
|
{
|
|
register int i;
|
|
unsigned char vgacharset;
|
|
unsigned char vgachar[16];
|
|
|
|
if(vgacs[svsp->vga_charset].secondloaded)
|
|
vgacharset = vgacs[svsp->vga_charset].secondloaded;
|
|
else
|
|
return;
|
|
|
|
for(i=0;i < 16;i++) /* A zeroed character, vt220 has inverted '?' */
|
|
vgachar[i] = 0x00;
|
|
|
|
for(i=1;i <= 94;i++) /* Load (erase) all characters */
|
|
loadchar(vgacharset, i + 0xA0, 16, vgachar);
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* Initialization for Down line LoaDable Fonts
|
|
*---------------------------------------------------------------------------*/
|
|
static void
|
|
init_dld(struct video_state *svsp)
|
|
{
|
|
register int i;
|
|
|
|
svsp->dld_dscsi = 0;
|
|
svsp->dld_sixel_lower = 0;
|
|
svsp->dld_sixelli = 0;
|
|
svsp->dld_sixelui = 0;
|
|
|
|
for(i = 0;i < MAXSIXEL;i++)
|
|
svsp->sixel.lower[i] = svsp->sixel.upper[i] = 0;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* selective erase a region
|
|
*---------------------------------------------------------------------------*/
|
|
static void
|
|
selective_erase(struct video_state *svsp, u_short *pcrtat, int length)
|
|
{
|
|
register int i, j;
|
|
|
|
for(j = pcrtat - svsp->Crtat, i = 0;i < length;i++,pcrtat++)
|
|
{
|
|
if(!(svsp->decsca[INT_INDEX(j+i)] & (1 << BIT_INDEX(j+i))))
|
|
{
|
|
*pcrtat &= 0xFF00; /* Keep the video character attributes */
|
|
*pcrtat += ' '; /* Erase the character */
|
|
}
|
|
}
|
|
}
|
|
|
|
#endif /* NVT > 0 */
|
|
|
|
/* ------------------------- E O F ------------------------------------------*/
|
|
|