vc.c

这是一个介绍 linux 编程知识的文章。

/*
 * KON2 - Kanji ON Console -
 * Copyright (C) 1992-1996 Takashi MANABE ([e-mail])
 * 
 * CCE - Console Chinese Environment -
 * Copyright (C) 1998-1999 Rui He ([e-mail])
 *
 * VCOnGUI - Virtual Console On MiniGUI -
 * Copyright (C) 1999 Wei Yongming ([e-mail])
 *
 */

/*
**  This source is free software; you can redistribute it and/or
**  modify it under the terms of the GNU General Public
**  License as published by the Free Software Foundation; either
**  version 2 of the License, or (at your option) any later version.
**
**  This software is distributed in the hope that it will be useful,
**  but WITHOUT ANY WARRANTY; without even the implied warranty of
**  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
**  General Public License for more details.
**
**  You should have received a copy of the GNU General Public
**  License along with this library; if not, write to the Free
**  Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
**  MA 02111-1307, USA
*/

// Create date: 1999.09.23
//
// Modify records:
//
//  Who             When        Where       For What                Status
//-----------------------------------------------------------------------------
//
// TODO:
//

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/vt.h>
#include <sys/ioctl.h>
#include <sys/time.h>
#include <fcntl.h>
#include <signal.h>
#include <termio.h>
#include <pthread.h>
#include <semaphore.h>
#include <dirent.h>

#include <minigui/common.h>
#include <minigui/minigui.h>
#include <minigui/gdi.h>
#include <minigui/window.h>
#include <minigui/control.h>

#include "vcongui.h"
#include "resource.h"
#include "defs.h"
#include "vc.h"
#include "vt.h"
#include "paint.h"

static void TextClearBand (CONINFO *con, int top, int btm);

PCONINFO AllocConInfo ()
{
    PCONINFO pCONINFO;

    if ( !(pCONINFO = malloc (sizeof (CONINFO))) )
        return NULL;

    memset (pCONINFO, 0, sizeof (CONINFO));

    pCONINFO->cols = VGASTD_NUMBER_COLS;
    pCONINFO->rows = VGASTD_NUMBER_ROWS;
    pCONINFO->termType = IDM_80X25;

    return pCONINFO;
}


void FreeConInfo (PCONINFO pCONINFO)
{
    free (pCONINFO);
}

/*
  con->flagBuff:
  |      7|      6|      5|4||3|2|1|0|
  |CLEAN_S|LATCH_2|LATCH_1| ||<----->|
  |0=latch|  byte2|  byte1| ||   LANG|

  Usage: CLEAN_S         indicate if we need to redraw this char
         LATCH_1/LATCH_2 double byte char (Chinese, Japanese, Korean)
         LANG            language, we can support BIG5/GB same screen
*/

/* blatch clear the bit 7 of array head  byte , force to redraw */
static inline void blatch(void *head, int n)
{
    __asm__("\t clc\n"
        "1:\n"
        "\t andb %%bl, (%%eax)\n"
        "\t incl %%eax\n"
        "\t loop 1b\n"
        :
        : "eax" ((long)head), "bl" (0x7F), "c" (n)
        : "bl", "cx" );
}

/* long latch */
static inline void llatch(void *head, int n)
{
    __asm__("\t clc\n"
        "1:\n"
        "\t andl %%ebx, (%%eax)\n"
        "\t addl $4, %%eax\n"
        "\t loop 1b\n"
        :
        : "eax" ((long)head), "ebx" (0x7F7F7F7F), "c" (n>>2)
        : "ebx", "cx" );
}

static inline u_int TextAddress (CONINFO *con, u_int x, u_int y)
{
    return (con->textHead + x + y * con->dispxmax) % con->textSize;
}

static inline bool IsKanji (CONINFO *con, u_int x, u_int y)
{
    return(*(con->flagBuff + TextAddress (con, x, y)) & CODEIS_1);
}

static inline bool IsKanji2 (CONINFO *con, u_int x, u_int y)
{
    return(*(con->flagBuff + TextAddress (con, x, y)) & CODEIS_2);
}

/****************************************************************************
 *                     TextDeleteChar/TextInsertChar                        *
 ****************************************************************************/
void TextDeleteChar (CONINFO *con, int n)
{
    u_int addr, dx;
    
    addr = TextAddress (con, con->x, con->y);
    dx = con->dispxmax - con->x - n;
    
    bmove (con->textBuff + addr, con->textBuff + addr + n, dx);
    bmove (con->attrBuff + addr, con->attrBuff + addr + n, dx);
    blatch (con->flagBuff + addr, dx);
    
    addr = TextAddress (con, con->dispxmax - n, con->y);

    bzero2 (con->textBuff + addr, n);
    bzero2 (con->attrBuff + addr, n);
    bzero2 (con->flagBuff + addr, n);
}

void TextInsertChar (CONINFO *con, int n)
{
    u_int addr, dx;

#if 0
    addr = TextAddress (con, con->dispxmax, con->y);
    dx = con->dispxmax - con->x - n;
    
    brmove (con->textBuff + addr, con->textBuff + addr - n, dx + 1);
    brmove (con->attrBuff + addr, con->attrBuff + addr - n, dx + 1);
    
    addr = TextAddress (con, con->x, con->y);
    blatch (con->flagBuff + addr + n, dx);
    bzero2 (con->textBuff + addr, n);
    bzero2 (con->attrBuff + addr, n);
    bzero2 (con->flagBuff + addr, n);
#else
    addr = TextAddress (con, con->x, con->y);
    dx = con->dispxmax - con->x - n;
    
    memmove (con->textBuff + addr + n, con->textBuff + addr, dx);
    memmove (con->attrBuff + addr + n, con->attrBuff + addr, dx);
    
    addr = TextAddress (con, con->x, con->y);
    blatch (con->flagBuff + addr + n, dx);
    bzero2 (con->textBuff + addr, n);
    bzero2 (con->attrBuff + addr, n);
    bzero2 (con->flagBuff + addr, n);
#endif
}

/****************************************************************************
 *                     TextScrollUp/TextScrollDown                          *
 *                     TextMoveUp/TextMoveDown                              *
 *                        ScrollUp/ScrollDown                               *
 ****************************************************************************/

static void TextScrollUp (CONINFO *con, int line)
{
    int oldhead, len;

    oldhead = con->textHead;
    con->textHead += line * con->dispxmax;

    if (con->textHead > con->textSize) {
    
        con->textHead -= con->textSize;
        len = con->textSize - oldhead;
        
        if (con->textHead) {
            lzero (con->textBuff, con->textHead);
            lzero (con->attrBuff, con->textHead);
            lzero (con->flagBuff, con->textHead);
        }
    }
    else
        len = con->textHead - oldhead;

    lzero (con->textBuff + oldhead, len);
    lzero (con->attrBuff + oldhead, len);
    lzero (con->flagBuff + oldhead, len);
}

static void TextScrollDown (CONINFO *con, int line)
{
    int oldhead, len;

    oldhead = con->textHead;
    con->textHead -= line * con->dispxmax;

    if (con->textHead < 0) {
        con->textHead += con->textSize;
        if (oldhead) {
            lzero(con->textBuff, oldhead);
            lzero(con->attrBuff, oldhead);
            lzero(con->flagBuff, oldhead);
        }
        len = con->textSize - con->textHead;
    }
    else
        len = oldhead - con->textHead;

    lzero (con->textBuff + con->textHead, len);
    lzero (con->attrBuff + con->textHead, len);
    lzero (con->flagBuff + con->textHead, len);
}

void TextMoveUp (CONINFO *con, int top, int btm, int line)
{
    int n, src, dst;

    if (btm - top - line + 1 <= 0) {
        TextClearBand (con, top, btm);
        return;
    }
    
    for (n = top; n <= btm - line; n ++) {
        dst = TextAddress (con, 0, n);
        src = TextAddress (con, 0, n + line);
        lmove (con->textBuff + dst, con->textBuff + src, con->dispxmax);
        lmove (con->attrBuff + dst, con->attrBuff + src, con->dispxmax);
        lmove (con->flagBuff + dst, con->flagBuff + src, con->dispxmax);
        llatch (con->flagBuff + dst, con->dispxmax);
    }
    
    TextClearBand (con, btm - line + 1, btm);
}

void TextMoveDown (CONINFO *con, int top, int btm, int line)
{
    int n, src, dst;

    if (btm - top - line + 1 <= 0) {
        TextClearBand (con, top, btm);
        return;
    }
    
    for (n = btm; n >= top + line; n --) {
        dst = TextAddress (con, 0, n);
        src = TextAddress (con, 0, n - line);
        lmove (con->textBuff + dst, con->textBuff + src, con->dispxmax);
        lmove (con->attrBuff + dst, con->attrBuff + src, con->dispxmax);
        lmove (con->flagBuff + dst, con->flagBuff + src, con->dispxmax);
        llatch (con->flagBuff + dst, con->dispxmax);
    }

    TextClearBand (con, top, top + line - 1);
}

void ScrollUp (CONINFO *con, int line)
{
#if 1
    TextMoveUp(con, con->ymin, con->ymax, line);
#else
    if (con->soft) {
        TextMoveUp(con, con->ymin, con->ymax, line);
    }
    else {
        TextScrollUp (con, line);
        con->scrollLine += line;
    }
#endif
}

void ScrollDown (CONINFO *con, int line)
{
#if 1
    TextMoveDown (con, con->ymin, con->ymax, line);
#else
    if (con->soft) {
        TextMoveDown(con,con->ymin, con->ymax, line);
    }
    else {
        TextScrollDown (con, line);
        con->scrollLine -= line;
    }
#endif
}

/****************************************************************************
 *                       TextClearAll/TextClearEol                          *
 *                       TextClearEos/TextClearBand                         *
 ****************************************************************************/
void TextClearAll (CONINFO *con)
{
    // lzero (con->textBuff, con->textSize);
    // lzero (con->attrBuff, con->textSize);
    memset(con->textBuff, 0x20, con->textSize);
    memset(con->attrBuff, ((con->bcol << 4) | con->fcol), con->textSize);
    lzero (con->flagBuff, con->textSize);
    con->textClear = true;
}

void TextClearEol (CONINFO *con, u_char mode)
{
    u_int  addr;
    u_char len, x=0;

    switch(mode) {
    case 1:
        len = con->x;
        break;
        
    case 2:
        len = con->dispxmax;
        break;

    default:
        x = con->x;
        len = con->dispxmax - con->x;
        break;
    }
    
    addr = TextAddress (con, x, con->y);
    // bzero2 (con->textBuff + addr, len);
    // bzero2 (con->attrBuff + addr, len);
    memset (con->textBuff + addr, 0x20, len);
    memset (con->attrBuff + addr, (con->bcol << 4) | con->fcol, len);
    bzero2 (con->flagBuff + addr, len);     /* needless to latch */
}

void TextClearEos (CONINFO *con, u_char mode)
{
    int addr, len, y;

    if (mode == 2) {
        TextClearAll (con);
        return;
    }

    switch(mode) {
    case 1:
        for (y = 0; y < con->y; y ++) {
            addr = TextAddress (con, 0, y);

            // lzero (con->textBuff + addr, con->dispxmax);
            // lzero (con->attrBuff + addr, con->dispxmax);
            memset (con->textBuff + addr, 0x20, con->dispxmax);
            memset (con->attrBuff + addr, 
                    (con->bcol << 4) | con->fcol, con->dispxmax);

            lzero (con->flagBuff + addr, con->dispxmax);
            /* needless to latch */
        }
        
        addr = TextAddress (con, 0, con->y);
        // bzero2 (con->textBuff + addr, con->x);
        // bzero2 (con->attrBuff + addr, con->x);
        memset (con->textBuff + addr, 0x20, con->x);
        memset (con->attrBuff + addr, (con->bcol << 4) | con->fcol, con->x);
        bzero2 (con->flagBuff + addr, con->x); /* needless to latch */
        break;
        
    default:
        for (y = con->y + 1; y <= con->dispymax; y ++) {
            addr = TextAddress (con, 0, y);
            // lzero (con->textBuff + addr, con->dispxmax);
            // lzero (con->attrBuff + addr, con->dispxmax);
            memset (con->textBuff + addr, 0x20, con->dispxmax);
            memset (con->attrBuff + addr, 
                    (con->bcol << 4) | con->fcol, con->dispxmax);