teraterm/teraterm/buffer.c

/*
 * Copyright (C) 1994-1998 T. Teranishi
 * (C) 2004-2020 TeraTerm Project
 * All rights reserved.
 *
 * 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. The name of the author 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.
 */

/* TERATERM.EXE, scroll buffer routines */

#include "teraterm.h"
#include <string.h>
#include <stdio.h>
#include <windows.h>
#define _CRTDBG_MAP_ALLOC
#include <crtdbg.h>
#include <mbstring.h>
#include <assert.h>
#include <errno.h>

#include "tttypes.h"
#include "ttwinman.h"
#include "teraprn.h"
#include "vtdisp.h"
#include "clipboar.h"
#include "telnet.h"
#include "ttplug.h" /* TTPLUG */
#include "codeconv.h"
#include "unicode.h"
#include "buffer.h"
#include "unicode_test.h"
#include "asprintf.h"

#if UNICODE_INTERNAL_BUFF

typedef unsigned long char32_t;         // C++11

// �o�b�t�@�������p1������������
typedef struct {
        char32_t u32;
        char32_t u32_last;
        char WidthProperty;                             // 'W' or 'F' or 'H' or 'A' (����������)
        char HalfWidth;                                 // TRUE/FALSE = ���p/�S�p (�\������������������)
        char Padding;                                   // TRUE = �S�p�������l���� or �s�����l����
        char Emoji;                                             // TRUE = �G����
        unsigned char CombinationCharCount16;   // charactor count
        unsigned char CombinationCharSize16;            // buffer size
        unsigned char CombinationCharCount32;
        unsigned char CombinationCharSize32;
        wchar_t *pCombinationChars16;
        char32_t *pCombinationChars32;
        wchar_t wc2[2];
} buff_char_t;
#endif

#define BuffXMax TermWidthMax
//#define BuffYMax 100000
//#define BuffSizeMax 8000000
// �X�N���[���o�b�t�@�����������g�� (2004.11.28 yutaka)
#define BuffYMax 500000
#define BuffSizeMax (BuffYMax * 80)

// status line
int StatusLine; //0: none 1: shown
/* top, bottom, left & right margin */
int CursorTop, CursorBottom, CursorLeftM, CursorRightM;
BOOL Selected, Selecting;
BOOL Wrap;

static WORD TabStops[256];
static int NTabStops;

static WORD BuffLock = 0;

static PCHAR CodeBuff;  /* Character code buffer */
static PCHAR AttrBuff;  /* Attribute buffer */
static PCHAR AttrBuff2; /* Color attr buffer */
static PCHAR AttrBuffFG; /* Foreground color attr buffer */
static PCHAR AttrBuffBG; /* Background color attr buffer */
static PCHAR CodeLine;
static PCHAR AttrLine;
static PCHAR AttrLine2;
static PCHAR AttrLineFG;
static PCHAR AttrLineBG;
#if UNICODE_INTERNAL_BUFF
static buff_char_t *CodeBuffW;
static buff_char_t *CodeLineW;
#endif
static LONG LinePtr;
static LONG BufferSize;
static int NumOfLinesInBuff;
static int BuffStartAbs, BuffEndAbs;
static POINT SelectStart, SelectStartTmp, SelectEnd, SelectEndOld;
static DWORD SelectStartTime;
static BOOL BoxSelect;
static POINT DblClkStart, DblClkEnd;

// �`��
static int StrChangeStart;      // �`���J�n X (Y=CursorY)
static int StrChangeCount;      // �`���L�����N�^��(���p�P��),0�������`����������������

static BOOL SeveralPageSelect;  // add (2005.5.15 yutaka)

static TCharAttr CurCharAttr;

static char *SaveBuff = NULL;
static int SaveBuffX;
static int SaveBuffY;

#if UNICODE_INTERNAL_BUFF
static void BuffDrawLineI(int DrawX, int DrawY, int SY, int IStart, int IEnd);
#endif

#if UNICODE_INTERNAL_BUFF
static void BuffSetChar2(buff_char_t *buff, char32_t u32, char property, BOOL half_width, char emoji)
{
        size_t wstr_len;
        buff_char_t *p = buff;
        if (p->pCombinationChars16 != NULL) {
                free(p->pCombinationChars16);
                p->pCombinationChars16 = NULL;
        }
        p->CombinationCharCount16 = 0;
        p->CombinationCharSize16 = 0;
        if (p->pCombinationChars32 != NULL) {
                free(p->pCombinationChars32);
                p->pCombinationChars32 = NULL;
        }
        p->CombinationCharCount32 = 0;
        p->CombinationCharSize32 = 0;
        p->WidthProperty = property;
        p->HalfWidth = (char)half_width;
        p->u32 = u32;
        p->u32_last = u32;
        p->Padding = FALSE;
        p->Emoji = emoji;

        //
        wstr_len = UTF32ToUTF16(u32, &p->wc2[0], 2);
        switch (wstr_len) {
        case 0:
        default:
                p->wc2[0] = 0;
                p->wc2[1] = 0;
                break;
        case 1:
                p->wc2[1] = 0;
                break;
        case 2:
                break;
        }
}

static void BuffSetChar(buff_char_t *buff, char32_t u32, char property)
{
        BuffSetChar2(buff, u32, property, TRUE, FALSE);
}

/**
 *      �����������A�R���r�l�[�V����
 */
static void BuffAddChar(buff_char_t *buff, char32_t u32)
{
        buff_char_t *p = buff;
        assert(p->u32 != 0);
        // �������������������g������
        if (p->CombinationCharSize16 < p->CombinationCharCount16 + 2) {
                size_t new_size = p->CombinationCharSize16;
                new_size = new_size == 0 ? 5 : new_size * 2;
                p->pCombinationChars16 = realloc(p->pCombinationChars16, sizeof(wchar_t) * new_size);
                p->CombinationCharSize16 = (char)new_size;
        }
        if (p->CombinationCharSize32 < p->CombinationCharCount32 + 2) {
                size_t new_size = p->CombinationCharSize32;
                new_size = new_size == 0 ? 5 : new_size * 2;
                p->pCombinationChars32 = realloc(p->pCombinationChars32, sizeof(char32_t) * new_size);
                p->CombinationCharSize32 = (char)new_size;
        }

        // UTF-32
        p->u32_last = u32;
        p->pCombinationChars32[(size_t)p->CombinationCharCount32] = u32;
        p->CombinationCharCount32++;

        // UTF-16
        {
                wchar_t *u16 = &p->pCombinationChars16[(size_t)p->CombinationCharCount16];
                size_t wlen = UTF32ToUTF16(u32, u16, 2);
                p->CombinationCharCount16 += (char)wlen;
        }
}

static void memcpyW(buff_char_t *dest, const buff_char_t *src, size_t count)
{
        size_t i;
        memcpy(dest, src, count * sizeof(buff_char_t));
        for (i=0; i<count; i++) {
                buff_char_t *p = &dest[i];
                size_t size = p->CombinationCharSize16;
                if (size > 0) {
                        wchar_t *new_buf = malloc(sizeof(wchar_t) * size);
                        memcpy(new_buf, p->pCombinationChars16, sizeof(wchar_t) * size);
                        p->pCombinationChars16 = new_buf;
                }
                size = p->CombinationCharSize32;
                if (size > 0) {
                        char32_t *new_buf = malloc(sizeof(char32_t) * size);
                        memcpy(new_buf, p->pCombinationChars32, sizeof(char32_t) * size);
                        p->pCombinationChars32 = new_buf;
                }
        }
}

static void memsetW(buff_char_t *dest, wchar_t ch, size_t count)
{
        size_t i;
        for (i=0; i<count; i++) {
                BuffSetChar(dest, ch, 'H');
                dest++;
        }
}

static void memmoveW(buff_char_t *dest, const buff_char_t *src, size_t count)
{
        memmove(dest, src, count * sizeof(buff_char_t));
}

static BOOL IsBuffPadding(const buff_char_t *b)
{
        if (b->Padding == TRUE)
                return TRUE;
        if (b->u32 == 0)
                return TRUE;
        return FALSE;
}

static BOOL IsBuffFullWidth(const buff_char_t *b)
{
        if (b->HalfWidth == FALSE)
                return TRUE;
        return FALSE;
}

#endif

static LONG GetLinePtr(int Line)
{
        LONG Ptr;

        Ptr = (LONG)(BuffStartAbs + Line) * (LONG)(NumOfColumns);
        while (Ptr>=BufferSize) {
                Ptr = Ptr - BufferSize;
        }
        return Ptr;
}

static LONG NextLinePtr(LONG Ptr)
{
        Ptr = Ptr + (LONG)NumOfColumns;
        if (Ptr >= BufferSize) {
                Ptr = Ptr - BufferSize;
        }
        return Ptr;
}

static LONG PrevLinePtr(LONG Ptr)
{
        Ptr = Ptr - (LONG)NumOfColumns;
        if (Ptr < 0) {
                Ptr = Ptr + BufferSize;
        }
        return Ptr;
}

static BOOL ChangeBuffer(int Nx, int Ny)
{
        LONG NewSize;
        int NxCopy, NyCopy, i;
        PCHAR CodeDest, AttrDest, AttrDest2, AttrDestFG, AttrDestBG;
        LONG SrcPtr, DestPtr;
        WORD LockOld;
#if UNICODE_INTERNAL_BUFF
        buff_char_t *CodeDestW;
#endif

        if (Nx > BuffXMax) {
                Nx = BuffXMax;
        }
        if (ts.ScrollBuffMax > BuffYMax) {
                ts.ScrollBuffMax = BuffYMax;
        }
        if (Ny > ts.ScrollBuffMax) {
                Ny = ts.ScrollBuffMax;
        }

        if ( (LONG)Nx * (LONG)Ny > BuffSizeMax ) {
                Ny = BuffSizeMax / Nx;
        }

        NewSize = (LONG)Nx * (LONG)Ny;

        CodeDest = NULL;
        AttrDest = NULL;
        AttrDest2 = NULL;
        AttrDestFG = NULL;
        AttrDestBG = NULL;
#if UNICODE_INTERNAL_BUFF
        CodeDestW = NULL;
#endif

        CodeDest = malloc(NewSize);
        if (CodeDest == NULL) {
                goto allocate_error;
        }
        AttrDest = malloc(NewSize);
        if (AttrDest == NULL) {
                goto allocate_error;
        }
        AttrDest2 = malloc(NewSize);
        if (AttrDest2 == NULL) {
                goto allocate_error;
        }
        AttrDestFG = malloc(NewSize);
        if (AttrDestFG == NULL) {
                goto allocate_error;
        }
        AttrDestBG = malloc(NewSize);
        if (AttrDestBG == NULL) {
                goto allocate_error;
        }
#if UNICODE_INTERNAL_BUFF
        CodeDestW = malloc(NewSize * sizeof(buff_char_t));
        if (CodeDestW == NULL) {
                goto allocate_error;
        }
#endif

        memset(&CodeDest[0], 0x20, NewSize);
#if UNICODE_INTERNAL_BUFF
        memset(&CodeDestW[0], 0, NewSize * sizeof(buff_char_t));
        memsetW(&CodeDestW[0], 0x20, NewSize);
#endif
        memset(&AttrDest[0], AttrDefault, NewSize);
        memset(&AttrDest2[0], AttrDefault, NewSize);
        memset(&AttrDestFG[0], AttrDefaultFG, NewSize);
        memset(&AttrDestBG[0], AttrDefaultBG, NewSize);
        if ( CodeBuff != NULL ) {
                if ( NumOfColumns > Nx ) {
                        NxCopy = Nx;
                }
                else {
                        NxCopy = NumOfColumns;
                }

                if ( BuffEnd > Ny ) {
                        NyCopy = Ny;
                }
                else {
                        NyCopy = BuffEnd;
                }
                LockOld = BuffLock;
                LockBuffer();
                SrcPtr = GetLinePtr(BuffEnd-NyCopy);
                DestPtr = 0;
                for (i = 1 ; i <= NyCopy ; i++) {
                        memcpy(&CodeDest[DestPtr],&CodeBuff[SrcPtr],NxCopy);
#if UNICODE_INTERNAL_BUFF
                        memcpyW(&CodeDestW[DestPtr],&CodeBuffW[SrcPtr],NxCopy);
#endif
                        memcpy(&AttrDest[DestPtr],&AttrBuff[SrcPtr],NxCopy);
                        memcpy(&AttrDest2[DestPtr],&AttrBuff2[SrcPtr],NxCopy);
                        memcpy(&AttrDestFG[DestPtr],&AttrBuffFG[SrcPtr],NxCopy);
                        memcpy(&AttrDestBG[DestPtr],&AttrBuffBG[SrcPtr],NxCopy);
                        if (AttrDest[DestPtr+NxCopy-1] & AttrKanji) {
                                CodeDest[DestPtr+NxCopy-1] = ' ';
                                AttrDest[DestPtr+NxCopy-1] ^= AttrKanji;
                        }
                        SrcPtr = NextLinePtr(SrcPtr);
                        DestPtr = DestPtr + (LONG)Nx;
                }
                FreeBuffer();
        }
        else {
                LockOld = 0;
                NyCopy = NumOfLines;
                Selected = FALSE;
        }

        if (Selected) {
                SelectStart.y = SelectStart.y - BuffEnd + NyCopy;
                SelectEnd.y = SelectEnd.y - BuffEnd + NyCopy;
                if (SelectStart.y < 0) {
                        SelectStart.y = 0;
                        SelectStart.x = 0;
                }
                if (SelectEnd.y<0) {
                        SelectEnd.x = 0;
                        SelectEnd.y = 0;
                }

                Selected = (SelectEnd.y > SelectStart.y) ||
                           ((SelectEnd.y == SelectStart.y) &&
                            (SelectEnd.x > SelectStart.x));
        }

        CodeBuff = CodeDest;
        AttrBuff = AttrDest;
        AttrBuff2 = AttrDest2;
        AttrBuffFG = AttrDestFG;
        AttrBuffBG = AttrDestBG;
#if UNICODE_INTERNAL_BUFF
        CodeBuffW = CodeDestW;
#endif
        BufferSize = NewSize;
        NumOfLinesInBuff = Ny;
        BuffStartAbs = 0;
        BuffEnd = NyCopy;

        if (BuffEnd==NumOfLinesInBuff) {
                BuffEndAbs = 0;
        }
        else {
                BuffEndAbs = BuffEnd;
        }

        PageStart = BuffEnd - NumOfLines;

        LinePtr = 0;
        if (LockOld>0) {
                CodeLine = CodeBuff;
#if UNICODE_INTERNAL_BUFF
                CodeLineW = CodeBuffW;
#endif
                AttrLine = AttrBuff;
                AttrLine2 = AttrBuff2;
                AttrLineFG = AttrBuffFG;
                AttrLineBG = AttrBuffBG;
        }
        else {
                ;
        }
        BuffLock = LockOld;

        return TRUE;

allocate_error:
        if (CodeDest)   free(CodeDest);
        if (AttrDest)   free(AttrDest);
        if (AttrDest2)  free(AttrDest2);
        if (AttrDestFG) free(AttrDestFG);
        if (AttrDestBG) free(AttrDestBG);
#if UNICODE_INTERNAL_BUFF
        if (CodeDestW)  free(CodeDestW);
#endif
        return FALSE;
}

void InitBuffer()
{
        int Ny;

        /* setup terminal */
        NumOfColumns = ts.TerminalWidth;
        NumOfLines = ts.TerminalHeight;

        if (NumOfColumns <= 0)
                NumOfColumns = 80;
        else if (NumOfColumns > TermWidthMax)
                NumOfColumns = TermWidthMax;

        if (NumOfLines <= 0)
                NumOfLines = 24;
        else if (NumOfLines > TermHeightMax)
                NumOfLines = TermHeightMax;

        /* setup window */
        if (ts.EnableScrollBuff>0) {
                if (ts.ScrollBuffSize < NumOfLines) {
                        ts.ScrollBuffSize = NumOfLines;
                }
                Ny = ts.ScrollBuffSize;
        }
        else {
                Ny = NumOfLines;
        }

        if (! ChangeBuffer(NumOfColumns,Ny)) {
                PostQuitMessage(0);
        }

        if (ts.EnableScrollBuff>0) {
                ts.ScrollBuffSize = NumOfLinesInBuff;
        }

        StatusLine = 0;
}

static void NewLine(int Line)
{
        LinePtr = GetLinePtr(Line);
        CodeLine = &CodeBuff[LinePtr];
        AttrLine = &AttrBuff[LinePtr];
        AttrLine2 = &AttrBuff2[LinePtr];
        AttrLineFG = &AttrBuffFG[LinePtr];
        AttrLineBG = &AttrBuffBG[LinePtr];
#if UNICODE_INTERNAL_BUFF
        CodeLineW = &CodeBuffW[LinePtr];
#endif
}

void LockBuffer()
{
        BuffLock++;
        if (BuffLock>1) {
                return;
        }
        NewLine(PageStart+CursorY);
}

void UnlockBuffer()
{
        if (BuffLock==0) {
                return;
        }
        BuffLock--;
        if (BuffLock>0) {
                return;
        }
}

void FreeBuffer()
{
        BuffLock = 1;
        UnlockBuffer();
        if (CodeBuff!=NULL) {
                free(CodeBuff);
                CodeBuff = NULL;
        }
#if UNICODE_INTERNAL_BUFF
        if (CodeBuffW != NULL) {
                free(CodeBuffW);
                CodeBuffW = NULL;
        }
#endif
        if (AttrBuff!=NULL) {
                free(AttrBuff);
                AttrBuff = NULL;
        }
        if (AttrBuff2!=NULL) {
                free(AttrBuff2);
                AttrBuff2 = NULL;
        }
        if (AttrBuffFG!=NULL) {
                free(AttrBuffFG);
                AttrBuffFG = NULL;
        }
        if (AttrBuffBG!=NULL) {
                free(AttrBuffBG);
                AttrBuffBG = NULL;
        }
}

void BuffAllSelect()
{
        SelectStart.x = 0;
        SelectStart.y = 0;
        SelectEnd.x = 0;
        SelectEnd.y = BuffEnd;
//      SelectEnd.x = NumOfColumns;
//      SelectEnd.y = BuffEnd - 1;
        Selecting = TRUE;
}

void BuffScreenSelect()
{
        int X, Y;
        DispConvWinToScreen(0, 0, &X, &Y, NULL);
        SelectStart.x = X;
        SelectStart.y = Y + PageStart;
        SelectEnd.x = 0;
        SelectEnd.y = SelectStart.y + NumOfLines;
//      SelectEnd.x = X + NumOfColumns;
//      SelectEnd.y = Y + PageStart + NumOfLines - 1;
        Selecting = TRUE;
}

void BuffCancelSelection()
{
        SelectStart.x = 0;
        SelectStart.y = 0;
        SelectEnd.x = 0;
        SelectEnd.y = 0;
        Selecting = FALSE;
}

void BuffReset()
// Reset buffer status. don't update real display
//   called by ResetTerminal()
{
        int i;

        /* Cursor */
        NewLine(PageStart);
        WinOrgX = 0;
        WinOrgY = 0;
        NewOrgX = 0;
        NewOrgY = 0;

        /* Top/bottom margin */
        CursorTop = 0;
        CursorBottom = NumOfLines-1;
        CursorLeftM = 0;
        CursorRightM = NumOfColumns-1;

        /* Tab stops */
        NTabStops = (NumOfColumns-1) >> 3;
        for (i=1 ; i<=NTabStops ; i++) {
                TabStops[i-1] = (WORD)(i*8);
        }

        /* Initialize text selection region */
        SelectStart.x = 0;
        SelectStart.y = 0;
        SelectEnd = SelectStart;
        SelectEndOld = SelectStart;
        Selected = FALSE;

        StrChangeCount = 0;
        Wrap = FALSE;
        StatusLine = 0;

        SeveralPageSelect = FALSE; // yutaka

        /* Alternate Screen Buffer */
        BuffDiscardSavedScreen();
}

void BuffScroll(int Count, int Bottom)
{
        int i, n;
        LONG SrcPtr, DestPtr;
        int BuffEndOld;

        if (Count>NumOfLinesInBuff) {
                Count = NumOfLinesInBuff;
        }

        DestPtr = GetLinePtr(PageStart+NumOfLines-1+Count);
        n = Count;
        if (Bottom<NumOfLines-1) {
                SrcPtr = GetLinePtr(PageStart+NumOfLines-1);
                for (i=NumOfLines-1; i>=Bottom+1; i--) {
                        memcpy(&(CodeBuff[DestPtr]),&(CodeBuff[SrcPtr]),NumOfColumns);
#if UNICODE_INTERNAL_BUFF
                        memcpyW(&(CodeBuffW[DestPtr]),&(CodeBuffW[SrcPtr]),NumOfColumns);
#endif
                        memcpy(&(AttrBuff[DestPtr]),&(AttrBuff[SrcPtr]),NumOfColumns);
                        memcpy(&(AttrBuff2[DestPtr]),&(AttrBuff2[SrcPtr]),NumOfColumns);
                        memcpy(&(AttrBuffFG[DestPtr]),&(AttrBuffFG[SrcPtr]),NumOfColumns);
                        memcpy(&(AttrBuffBG[DestPtr]),&(AttrBuffBG[SrcPtr]),NumOfColumns);
                        memset(&(CodeBuff[SrcPtr]),0x20,NumOfColumns);
#if UNICODE_INTERNAL_BUFF
                        memsetW(&(CodeBuffW[SrcPtr]),0x20,NumOfColumns);
#endif
                        memset(&(AttrBuff[SrcPtr]),AttrDefault,NumOfColumns);
                        memset(&(AttrBuff2[SrcPtr]),CurCharAttr.Attr2 & Attr2ColorMask, NumOfColumns);
                        memset(&(AttrBuffFG[SrcPtr]),CurCharAttr.Fore,NumOfColumns);
                        memset(&(AttrBuffBG[SrcPtr]),CurCharAttr.Back,NumOfColumns);
                        SrcPtr = PrevLinePtr(SrcPtr);
                        DestPtr = PrevLinePtr(DestPtr);
                        n--;
                }
        }
        for (i = 1 ; i <= n ; i++) {
                memset(&CodeBuff[DestPtr],0x20,NumOfColumns);
#if UNICODE_INTERNAL_BUFF
                memsetW(&CodeBuffW[DestPtr],0x20,NumOfColumns);
#endif
                memset(&AttrBuff[DestPtr],AttrDefault,NumOfColumns);
                memset(&AttrBuff2[DestPtr],CurCharAttr.Attr2 & Attr2ColorMask, NumOfColumns);
                memset(&AttrBuffFG[DestPtr],CurCharAttr.Fore,NumOfColumns);
                memset(&AttrBuffBG[DestPtr],CurCharAttr.Back,NumOfColumns);
                DestPtr = PrevLinePtr(DestPtr);
        }

        BuffEndAbs = BuffEndAbs + Count;
        if (BuffEndAbs >= NumOfLinesInBuff) {
                BuffEndAbs = BuffEndAbs - NumOfLinesInBuff;
        }
        BuffEndOld = BuffEnd;
        BuffEnd = BuffEnd + Count;
        if (BuffEnd >= NumOfLinesInBuff) {
                BuffEnd = NumOfLinesInBuff;
                BuffStartAbs = BuffEndAbs;
        }
        PageStart = BuffEnd-NumOfLines;

        if (Selected) {
                SelectStart.y = SelectStart.y - Count + BuffEnd - BuffEndOld;
                SelectEnd.y = SelectEnd.y - Count + BuffEnd - BuffEndOld;
                if ( SelectStart.y<0 ) {
                        SelectStart.x = 0;
                        SelectStart.y = 0;
                }
                if ( SelectEnd.y<0 ) {
                        SelectEnd.x = 0;
                        SelectEnd.y = 0;
                }
                Selected = (SelectEnd.y > SelectStart.y) ||
                       ((SelectEnd.y==SelectStart.y) &&
                        (SelectEnd.x > SelectStart.x));
        }

        NewLine(PageStart+CursorY);
}

void NextLine()
{
        LinePtr = NextLinePtr(LinePtr);
        CodeLine = &CodeBuff[LinePtr];
        AttrLine = &AttrBuff[LinePtr];
        AttrLine2 = &AttrBuff2[LinePtr];
        AttrLineFG = &AttrBuffFG[LinePtr];
        AttrLineBG = &AttrBuffBG[LinePtr];
#if UNICODE_INTERNAL_BUFF
        CodeLineW = &CodeBuffW[LinePtr];
#endif
}

void PrevLine()
{
        LinePtr = PrevLinePtr(LinePtr);
        CodeLine = &CodeBuff[LinePtr];
        AttrLine = &AttrBuff[LinePtr];
        AttrLine2 = &AttrBuff2[LinePtr];
        AttrLineFG = &AttrBuffFG[LinePtr];
        AttrLineBG = &AttrBuffBG[LinePtr];
#if UNICODE_INTERNAL_BUFF
        CodeLineW = &CodeBuffW[LinePtr];
#endif
}

// If cursor is on left/right half of a Kanji, erase it.
//   LR: left(0)/right(1) flag
//      LR      0       �J�[�\��������������
//              1       �J�[�\�����������E��
static void EraseKanji(int LR)
{
#if UNICODE_INTERNAL_BUFF
        buff_char_t *p;
        int bx;
        if (CursorX < LR) {
                // �S�p������������
                return;
        }
        bx = CursorX-LR;
        p = &CodeLineW[bx];
        if (IsBuffFullWidth(p)) {
                // �S�p��������
                BuffSetChar(p, ' ', 'H');
                CodeLine[bx] = 0x20;
                AttrLine[bx] = CurCharAttr.Attr;
                AttrLine2[bx] = CurCharAttr.Attr2;
                AttrLineFG[bx] = CurCharAttr.Fore;
                AttrLineBG[bx] = CurCharAttr.Back;
                if (bx+1 < NumOfColumns) {
                        BuffSetChar(p + 1, ' ', 'H');
                        CodeLine[bx+1] = 0x20;
                        AttrLine[bx+1] = CurCharAttr.Attr;
                        AttrLine2[bx+1] = CurCharAttr.Attr2;
                        AttrLineFG[bx+1] = CurCharAttr.Fore;
                        AttrLineBG[bx+1] = CurCharAttr.Back;
                }
        }
#else
        if ((CursorX-LR>=0) &&
            ((AttrLine[CursorX-LR] & AttrKanji) != 0)) {
                CodeLine[CursorX-LR] = 0x20;
                AttrLine[CursorX-LR] = CurCharAttr.Attr;
                AttrLine2[CursorX-LR] = CurCharAttr.Attr2;
                AttrLineFG[CursorX-LR] = CurCharAttr.Fore;
                AttrLineBG[CursorX-LR] = CurCharAttr.Back;
                if (CursorX-LR+1 < NumOfColumns) {
                        CodeLine[CursorX-LR+1] = 0x20;
                        AttrLine[CursorX-LR+1] = CurCharAttr.Attr;
                        AttrLine2[CursorX-LR+1] = CurCharAttr.Attr2;
                        AttrLineFG[CursorX-LR+1] = CurCharAttr.Fore;
                        AttrLineBG[CursorX-LR+1] = CurCharAttr.Back;
                }
        }
#endif
}

void EraseKanjiOnLRMargin(LONG ptr, int count)
{
        int i;
        LONG pos;

        if (count < 1)
                return;

        for (i=0; i<count; i++) {
                pos = ptr + CursorLeftM-1;
                if (CursorLeftM>0 && (AttrBuff[pos] & AttrKanji)) {
                        CodeBuff[pos] = 0x20;
#if UNICODE_INTERNAL_BUFF
                        BuffSetChar(&CodeBuffW[pos], 0x20, 'H');
#endif
                        AttrBuff[pos] &= ~AttrKanji;
                        pos++;
                        CodeBuff[pos] = 0x20;
#if UNICODE_INTERNAL_BUFF
                        BuffSetChar(&CodeBuffW[pos], 0x20, 'H');
#endif
                        AttrBuff[pos] &= ~AttrKanji;
                }
                pos = ptr + CursorRightM;
                if (CursorRightM < NumOfColumns-1 && (AttrBuff[pos] & AttrKanji)) {
                        CodeBuff[pos] = 0x20;
#if UNICODE_INTERNAL_BUFF
                        BuffSetChar(&CodeBuffW[pos], 0x20, 'H');
#endif
                        AttrBuff[pos] &= ~AttrKanji;
                        pos++;
                        CodeBuff[pos] = 0x20;
#if UNICODE_INTERNAL_BUFF
                        BuffSetChar(&CodeBuffW[pos], 0x20, 'H');
#endif
                        AttrBuff[pos] &= ~AttrKanji;
                }
                ptr = NextLinePtr(ptr);
        }
}

// Insert space characters at the current position
//   Count: Number of characters to be inserted
#if UNICODE_INTERNAL_BUFF
void BuffInsertSpace(int Count)
{
        int MoveLen;
        int extr = 0;
        int sx;
        buff_char_t *b;

        if (CursorX < CursorLeftM || CursorX > CursorRightM)
                return;

        NewLine(PageStart + CursorY);

        sx = CursorX;
        b = &CodeLineW[CursorX];
        if (IsBuffPadding(b)) {
                /* if cursor is on right half of a kanji, erase the kanji */
                BuffSetChar(b - 1, ' ', 'H');
                BuffSetChar(b, ' ', 'H');
                AttrLine[CursorX] &= ~AttrKanji;
                sx--;
                extr++;
        }

        if (CursorRightM < NumOfColumns - 1 && (AttrLine[CursorRightM] & AttrKanji)) {
                CodeLine[CursorRightM + 1] = 0x20;
                BuffSetChar(&CodeLineW[CursorRightM + 1], 0x20, 'H');
                AttrLine[CursorRightM + 1] &= ~AttrKanji;
                extr++;
        }

        if (Count > CursorRightM + 1 - CursorX)
                Count = CursorRightM + 1 - CursorX;

        MoveLen = CursorRightM + 1 - CursorX - Count;

        if (MoveLen > 0) {
                memmove(&(CodeLine[CursorX + Count]), &(CodeLine[CursorX]), MoveLen);
                memmoveW(&(CodeLineW[CursorX + Count]), &(CodeLineW[CursorX]), MoveLen);
                memmove(&(AttrLine[CursorX + Count]), &(AttrLine[CursorX]), MoveLen);
                memmove(&(AttrLine2[CursorX + Count]), &(AttrLine2[CursorX]), MoveLen);
                memmove(&(AttrLineFG[CursorX + Count]), &(AttrLineFG[CursorX]), MoveLen);
                memmove(&(AttrLineBG[CursorX + Count]), &(AttrLineBG[CursorX]), MoveLen);
        }
        memset(&(CodeLine[CursorX]), 0x20, Count);
        memsetW(&(CodeLineW[CursorX]), 0x20, Count);
        memset(&(AttrLine[CursorX]), AttrDefault, Count);
        memset(&(AttrLine2[CursorX]), CurCharAttr.Attr2 & Attr2ColorMask, Count);
        memset(&(AttrLineFG[CursorX]), CurCharAttr.Fore, Count);
        memset(&(AttrLineBG[CursorX]), CurCharAttr.Back, Count);
        /* last char in current line is kanji first? */
        if ((AttrLine[CursorRightM] & AttrKanji) != 0) {
                /* then delete it */
                CodeLine[CursorRightM] = 0x20;
                BuffSetChar(&CodeLineW[CursorRightM], 0x20, 'H');
                AttrLine[CursorRightM] &= ~AttrKanji;
        }
        BuffUpdateRect(sx, CursorY, CursorRightM + extr, CursorY);
}
#else
void BuffInsertSpace(int Count)
// Insert space characters at the current position
//   Count: Number of characters to be inserted
{
        int MoveLen;
        int extr=0;

        if (CursorX < CursorLeftM || CursorX > CursorRightM)
                return;

        NewLine(PageStart+CursorY);

        if (ts.Language==IdJapanese || ts.Language==IdKorean || ts.Language==IdUtf8)
                EraseKanji(1); /* if cursor is on right half of a kanji, erase the kanji */

        if (CursorRightM < NumOfColumns-1 && (AttrLine[CursorRightM] & AttrKanji)) {
                CodeLine[CursorRightM+1] = 0x20;
#if UNICODE_INTERNAL_BUFF
                BuffSetChar(&CodeLineW[CursorRightM + 1], 0x20, 'H');
#endif
                AttrLine[CursorRightM+1] &= ~AttrKanji;
                extr = 1;
        }

        if (Count > CursorRightM + 1 - CursorX)
                Count = CursorRightM + 1 - CursorX;

        MoveLen = CursorRightM + 1 - CursorX - Count;

        if (MoveLen > 0) {
                memmove(&(CodeLine[CursorX+Count]), &(CodeLine[CursorX]), MoveLen);
#if UNICODE_INTERNAL_BUFF
                memmoveW(&(CodeLineW[CursorX+Count]), &(CodeLineW[CursorX]), MoveLen);
#endif
                memmove(&(AttrLine[CursorX+Count]), &(AttrLine[CursorX]), MoveLen);
                memmove(&(AttrLine2[CursorX+Count]), &(AttrLine2[CursorX]), MoveLen);
                memmove(&(AttrLineFG[CursorX+Count]), &(AttrLineFG[CursorX]), MoveLen);
                memmove(&(AttrLineBG[CursorX+Count]), &(AttrLineBG[CursorX]), MoveLen);
        }
        memset(&(CodeLine[CursorX]), 0x20, Count);
#if UNICODE_INTERNAL_BUFF
        memsetW(&(CodeLineW[CursorX]), 0x20, Count);
#endif
        memset(&(AttrLine[CursorX]), AttrDefault, Count);
        memset(&(AttrLine2[CursorX]), CurCharAttr.Attr2 & Attr2ColorMask, Count);
        memset(&(AttrLineFG[CursorX]), CurCharAttr.Fore, Count);
        memset(&(AttrLineBG[CursorX]), CurCharAttr.Back, Count);
        /* last char in current line is kanji first? */
        if ((AttrLine[CursorRightM] & AttrKanji) != 0) {
                /* then delete it */
                CodeLine[CursorRightM] = 0x20;
#if UNICODE_INTERNAL_BUFF
                BuffSetChar(&CodeLineW[CursorRightM], 0x20, 'H');
#endif
                AttrLine[CursorRightM] &= ~AttrKanji;
        }
        BuffUpdateRect(CursorX, CursorY, CursorRightM+extr, CursorY);
}
#endif

void BuffEraseCurToEnd()
// Erase characters from cursor to the end of screen
{
        LONG TmpPtr;
        int offset;
        int i, YEnd;

        NewLine(PageStart+CursorY);
        if (ts.Language==IdJapanese || ts.Language==IdKorean || ts.Language==IdUtf8) {
                EraseKanji(1); /* if cursor is on right half of a kanji, erase the kanji */
        }
        offset = CursorX;
        TmpPtr = GetLinePtr(PageStart+CursorY);
        YEnd = NumOfLines-1;
        if (StatusLine && !isCursorOnStatusLine) {
                YEnd--;
        }
        for (i = CursorY ; i <= YEnd ; i++) {
                memset(&(CodeBuff[TmpPtr+offset]),0x20,NumOfColumns-offset);
#if UNICODE_INTERNAL_BUFF
                memsetW(&(CodeBuffW[TmpPtr+offset]),0x20,NumOfColumns-offset);
#endif
                memset(&(AttrBuff[TmpPtr+offset]),AttrDefault,NumOfColumns-offset);
                memset(&(AttrBuff2[TmpPtr+offset]),CurCharAttr.Attr2 & Attr2ColorMask, NumOfColumns-offset);
                memset(&(AttrBuffFG[TmpPtr+offset]),CurCharAttr.Fore,NumOfColumns-offset);
                memset(&(AttrBuffBG[TmpPtr+offset]),CurCharAttr.Back,NumOfColumns-offset);
                offset = 0;
                TmpPtr = NextLinePtr(TmpPtr);
        }
        /* update window */
        DispEraseCurToEnd(YEnd);
}

void BuffEraseHomeToCur()
// Erase characters from home to cursor
{
        LONG TmpPtr;
        int offset;
        int i, YHome;

        NewLine(PageStart+CursorY);
        if (ts.Language==IdJapanese || ts.Language==IdKorean || ts.Language==IdUtf8) {
                EraseKanji(0); /* if cursor is on left half of a kanji, erase the kanji */
        }
        offset = NumOfColumns;
        if (isCursorOnStatusLine) {
                YHome = CursorY;
        }
        else {
                YHome = 0;
        }
        TmpPtr = GetLinePtr(PageStart+YHome);
        for (i = YHome ; i <= CursorY ; i++) {
                if (i==CursorY) {
                        offset = CursorX+1;
                }
                memset(&(CodeBuff[TmpPtr]),0x20,offset);
#if UNICODE_INTERNAL_BUFF
                memsetW(&(CodeBuffW[TmpPtr]),0x20,offset);
#endif
                memset(&(AttrBuff[TmpPtr]),AttrDefault,offset);
                memset(&(AttrBuff2[TmpPtr]),CurCharAttr.Attr2 & Attr2ColorMask, offset);
                memset(&(AttrBuffFG[TmpPtr]),CurCharAttr.Fore,offset);
                memset(&(AttrBuffBG[TmpPtr]),CurCharAttr.Back,offset);
                TmpPtr = NextLinePtr(TmpPtr);
        }

        /* update window */
        DispEraseHomeToCur(YHome);
}

void BuffInsertLines(int Count, int YEnd)
// Insert lines at current position
//   Count: number of lines to be inserted
//   YEnd: bottom line number of scroll region (screen coordinate)
{
        int i, linelen;
        int extl=0, extr=0;
        LONG SrcPtr, DestPtr;

        BuffUpdateScroll();

        if (CursorLeftM > 0)
                extl = 1;
        if (CursorRightM < NumOfColumns-1)
                extr = 1;
        if (extl || extr)
                EraseKanjiOnLRMargin(GetLinePtr(PageStart+CursorY), YEnd-CursorY+1);

        SrcPtr = GetLinePtr(PageStart+YEnd-Count) + CursorLeftM;
        DestPtr = GetLinePtr(PageStart+YEnd) + CursorLeftM;
        linelen = CursorRightM - CursorLeftM + 1;
        for (i= YEnd-Count ; i>=CursorY ; i--) {
                memcpy(&(CodeBuff[DestPtr]), &(CodeBuff[SrcPtr]), linelen);
#if UNICODE_INTERNAL_BUFF
                memcpyW(&(CodeBuffW[DestPtr]), &(CodeBuffW[SrcPtr]), linelen);
#endif
                memcpy(&(AttrBuff[DestPtr]), &(AttrBuff[SrcPtr]), linelen);
                memcpy(&(AttrBuff2[DestPtr]), &(AttrBuff2[SrcPtr]), linelen);
                memcpy(&(AttrBuffFG[DestPtr]), &(AttrBuffFG[SrcPtr]), linelen);
                memcpy(&(AttrBuffBG[DestPtr]), &(AttrBuffBG[SrcPtr]), linelen);
                SrcPtr = PrevLinePtr(SrcPtr);
                DestPtr = PrevLinePtr(DestPtr);
        }
        for (i = 1 ; i <= Count ; i++) {
                memset(&(CodeBuff[DestPtr]), 0x20, linelen);
#if UNICODE_INTERNAL_BUFF
                memsetW(&(CodeBuffW[DestPtr]), 0x20, linelen);
#endif
                memset(&(AttrBuff[DestPtr]), AttrDefault, linelen);
                memset(&(AttrBuff2[DestPtr]), CurCharAttr.Attr2 & Attr2ColorMask, linelen);
                memset(&(AttrBuffFG[DestPtr]), CurCharAttr.Fore, linelen);
                memset(&(AttrBuffBG[DestPtr]), CurCharAttr.Back, linelen);
                DestPtr = PrevLinePtr(DestPtr);
        }

        if (CursorLeftM > 0 || CursorRightM < NumOfColumns-1 || !DispInsertLines(Count, YEnd)) {
                BuffUpdateRect(CursorLeftM-extl, CursorY, CursorRightM+extr, YEnd);
        }
}

void BuffEraseCharsInLine(int XStart, int Count)
// erase characters in the current line
//  XStart: start position of erasing
//  Count: number of characters to be erased
{
        BOOL LineContinued=FALSE;

        if (ts.EnableContinuedLineCopy && XStart == 0 && (AttrLine[0] & AttrLineContinued)) {
                LineContinued = TRUE;
        }

        if (ts.Language==IdJapanese || ts.Language==IdKorean || ts.Language==IdUtf8) {
                EraseKanji(1); /* if cursor is on right half of a kanji, erase the kanji */
        }

        NewLine(PageStart+CursorY);
        memset(&(CodeLine[XStart]),0x20,Count);
#if UNICODE_INTERNAL_BUFF
        memsetW(&(CodeLineW[XStart]),0x20,Count);
#endif
        memset(&(AttrLine[XStart]),AttrDefault,Count);
        memset(&(AttrLine2[XStart]),CurCharAttr.Attr2 & Attr2ColorMask, Count);
        memset(&(AttrLineFG[XStart]),CurCharAttr.Fore,Count);
        memset(&(AttrLineBG[XStart]),CurCharAttr.Back,Count);

        if (ts.EnableContinuedLineCopy) {
                if (LineContinued) {
                        BuffLineContinued(TRUE);
                }

                if (XStart + Count >= NumOfColumns) {
                        AttrBuff[NextLinePtr(LinePtr)] &= ~AttrLineContinued;
                }
        }

        DispEraseCharsInLine(XStart, Count);
}

void BuffDeleteLines(int Count, int YEnd)
// Delete lines from current line
//   Count: number of lines to be deleted
//   YEnd: bottom line number of scroll region (screen coordinate)
{
        int i, linelen;
        int extl=0, extr=0;
        LONG SrcPtr, DestPtr;

        BuffUpdateScroll();

        if (CursorLeftM > 0)
                extl = 1;
        if (CursorRightM < NumOfColumns-1)
                extr = 1;
        if (extl || extr)
                EraseKanjiOnLRMargin(GetLinePtr(PageStart+CursorY), YEnd-CursorY+1);

        SrcPtr = GetLinePtr(PageStart+CursorY+Count) + (LONG)CursorLeftM;
        DestPtr = GetLinePtr(PageStart+CursorY) + (LONG)CursorLeftM;
        linelen = CursorRightM - CursorLeftM + 1;
        for (i=CursorY ; i<= YEnd-Count ; i++) {
                memcpy(&(CodeBuff[DestPtr]), &(CodeBuff[SrcPtr]), linelen);
#if UNICODE_INTERNAL_BUFF
                memcpyW(&(CodeBuffW[DestPtr]), &(CodeBuffW[SrcPtr]), linelen);
#endif
                memcpy(&(AttrBuff[DestPtr]), &(AttrBuff[SrcPtr]), linelen);
                memcpy(&(AttrBuff2[DestPtr]), &(AttrBuff2[SrcPtr]), linelen);
                memcpy(&(AttrBuffFG[DestPtr]), &(AttrBuffFG[SrcPtr]), linelen);
                memcpy(&(AttrBuffBG[DestPtr]), &(AttrBuffBG[SrcPtr]), linelen);
                SrcPtr = NextLinePtr(SrcPtr);
                DestPtr = NextLinePtr(DestPtr);
        }
        for (i = YEnd+1-Count ; i<=YEnd ; i++) {
                memset(&(CodeBuff[DestPtr]), 0x20, linelen);
#if UNICODE_INTERNAL_BUFF
                memsetW(&(CodeBuffW[DestPtr]), 0x20, linelen);
#endif
                memset(&(AttrBuff[DestPtr]), AttrDefault, linelen);
                memset(&(AttrBuff2[DestPtr]), CurCharAttr.Attr2 & Attr2ColorMask,  linelen);
                memset(&(AttrBuffFG[DestPtr]), CurCharAttr.Fore, linelen);
                memset(&(AttrBuffBG[DestPtr]), CurCharAttr.Back, linelen);
                DestPtr = NextLinePtr(DestPtr);
        }

        if (CursorLeftM > 0 || CursorRightM < NumOfColumns-1 || ! DispDeleteLines(Count,YEnd)) {
                BuffUpdateRect(CursorLeftM-extl, CursorY, CursorRightM+extr, YEnd);
        }
}

// Delete characters in current line from cursor
//   Count: number of characters to be deleted
#if UNICODE_INTERNAL_BUFF
void BuffDeleteChars(int Count)
{
        int MoveLen;
        int extr = 0;
        buff_char_t *b;

        if (Count > CursorRightM + 1 - CursorX)
                Count = CursorRightM + 1 - CursorX;

        if (CursorX < CursorLeftM || CursorX > CursorRightM)
                return;

        NewLine(PageStart + CursorY);

        b = &CodeLineW[CursorX];

        if (IsBuffPadding(b)) {
                // �S�p���E���A�S�p���X�y�[�X���u��������
                BuffSetChar(b - 1, ' ', 'H');
                BuffSetChar(b, ' ', 'H');
        }
        if (IsBuffFullWidth(b)) {
                // �S�p�������A�S�p���X�y�[�X���u��������
                BuffSetChar(b, ' ', 'H');
                BuffSetChar(b + 1, ' ', 'H');
        }
        if (Count > 1) {
                // �I�[���`�F�b�N
                if (IsBuffPadding(b + Count)) {
                        // �S�p���E���A�S�p���X�y�[�X���u��������
                        BuffSetChar(b + Count - 1, ' ', 'H');
                        BuffSetChar(b + Count, ' ', 'H');
                }
        }

        if (CursorRightM < NumOfColumns - 1 && (AttrLine[CursorRightM] & AttrKanji)) {
                CodeLine[CursorRightM] = 0x20;
                BuffSetChar(&CodeLineW[CursorRightM], 0x20, 'H');
                AttrLine[CursorRightM] &= ~AttrKanji;
                CodeLine[CursorRightM + 1] = 0x20;
                BuffSetChar(&CodeLineW[CursorRightM + 1], 0x20, 'H');
                AttrLine[CursorRightM + 1] &= ~AttrKanji;
                extr = 1;
        }

        MoveLen = CursorRightM + 1 - CursorX - Count;

        if (MoveLen > 0) {
                memmove(&(CodeLine[CursorX]), &(CodeLine[CursorX + Count]), MoveLen);
                memmoveW(&(CodeLineW[CursorX]), &(CodeLineW[CursorX + Count]), MoveLen);
                memmove(&(AttrLine[CursorX]), &(AttrLine[CursorX + Count]), MoveLen);
                memmove(&(AttrLine2[CursorX]), &(AttrLine2[CursorX + Count]), MoveLen);
                memmove(&(AttrLineFG[CursorX]), &(AttrLineFG[CursorX + Count]), MoveLen);
                memmove(&(AttrLineBG[CursorX]), &(AttrLineBG[CursorX + Count]), MoveLen);
        }
        memset(&(CodeLine[CursorX + MoveLen]), 0x20, Count);
        memsetW(&(CodeLineW[CursorX + MoveLen]), ' ', Count);
        memset(&(AttrLine[CursorX + MoveLen]), AttrDefault, Count);
        memset(&(AttrLine2[CursorX + MoveLen]), CurCharAttr.Attr2 & Attr2ColorMask, Count);
        memset(&(AttrLineFG[CursorX + MoveLen]), CurCharAttr.Fore, Count);
        memset(&(AttrLineBG[CursorX + MoveLen]), CurCharAttr.Back, Count);

        BuffUpdateRect(CursorX, CursorY, CursorRightM + extr, CursorY);
}
#else
void BuffDeleteChars(int Count)
{
        int MoveLen;
        int extr=0;

        if (CursorX < CursorLeftM || CursorX > CursorRightM)
                return;

        NewLine(PageStart+CursorY);

        if (ts.Language==IdJapanese || ts.Language==IdKorean || ts.Language==IdUtf8) {
                EraseKanji(0); /* if cursor is on left harf of a kanji, erase the kanji */
                EraseKanji(1); /* if cursor on right half... */
        }

        if (CursorRightM < NumOfColumns-1 && (AttrLine[CursorRightM] & AttrKanji)) {
                CodeLine[CursorRightM] = 0x20;
                AttrLine[CursorRightM] &= ~AttrKanji;
                CodeLine[CursorRightM+1] = 0x20;
                AttrLine[CursorRightM+1] &= ~AttrKanji;
                extr = 1;
        }

        if (Count > CursorRightM + 1 - CursorX)
                Count = CursorRightM + 1 - CursorX;

        MoveLen = CursorRightM + 1 - CursorX - Count;

        if (MoveLen > 0) {
                memmove(&(CodeLine[CursorX]), &(CodeLine[CursorX+Count]), MoveLen);
                memmove(&(AttrLine[CursorX]), &(AttrLine[CursorX+Count]), MoveLen);
                memmove(&(AttrLine2[CursorX]), &(AttrLine2[CursorX+Count]), MoveLen);
                memmove(&(AttrLineFG[CursorX]), &(AttrLineFG[CursorX+Count]), MoveLen);
                memmove(&(AttrLineBG[CursorX]), &(AttrLineBG[CursorX+Count]), MoveLen);
        }
        memset(&(CodeLine[CursorX + MoveLen]), 0x20, Count);
        memset(&(AttrLine[CursorX + MoveLen]), AttrDefault, Count);
        memset(&(AttrLine2[CursorX + MoveLen]), CurCharAttr.Attr2 & Attr2ColorMask, Count);
        memset(&(AttrLineFG[CursorX + MoveLen]), CurCharAttr.Fore, Count);
        memset(&(AttrLineBG[CursorX + MoveLen]), CurCharAttr.Back, Count);

        BuffUpdateRect(CursorX, CursorY, CursorRightM+extr, CursorY);
}
#endif

// Erase characters in current line from cursor
//   Count: number of characters to be deleted
#if UNICODE_INTERNAL_BUFF
void BuffEraseChars(int Count)
{
        int extr = 0;
        int sx = CursorX;
        buff_char_t *b;
        NewLine(PageStart + CursorY);

        if (Count > NumOfColumns - CursorX) {
                Count = NumOfColumns - CursorX;
        }

        b = &CodeLineW[CursorX];
        if (IsBuffPadding(b)) {
                // �S�p���E���A�S�p���X�y�[�X���u��������
                BuffSetChar(b - 1, ' ', 'H');
                BuffSetChar(b, ' ', 'H');
                sx--;
                extr++;
        }
        if (IsBuffFullWidth(b)) {
                // �S�p�������A�S�p���X�y�[�X���u��������
                BuffSetChar(b, ' ', 'H');
                BuffSetChar(b + 1, ' ', 'H');
                if (Count == 1) {
                        extr++;
                }
        }
        if (Count > 1) {
                // �I�[���`�F�b�N
                if (IsBuffPadding(b + Count)) {
                        // �S�p���E���A�S�p���X�y�[�X���u��������
                        BuffSetChar(b + Count - 1, ' ', 'H');
                        BuffSetChar(b + Count, ' ', 'H');
                        extr++;
                }
        }

        memset(&(CodeLine[CursorX]), 0x20, Count);
#if UNICODE_INTERNAL_BUFF
        memsetW(&(CodeLineW[CursorX]), 0x20, Count);
#endif
        memset(&(AttrLine[CursorX]), AttrDefault, Count);
        memset(&(AttrLine2[CursorX]), CurCharAttr.Attr2 & Attr2ColorMask, Count);
        memset(&(AttrLineFG[CursorX]), CurCharAttr.Fore, Count);
        memset(&(AttrLineBG[CursorX]), CurCharAttr.Back, Count);

        /* update window */
        DispEraseCharsInLine(sx, Count + extr);
}
#else
void BuffEraseChars(int Count)
{
        NewLine(PageStart+CursorY);

        if (ts.Language==IdJapanese || ts.Language==IdKorean || ts.Language==IdUtf8) {
                EraseKanji(0); /* if cursor is on left harf of a kanji, erase the kanji */
                EraseKanji(1); /* if cursor on right half... */
        }

        if (Count > NumOfColumns-CursorX) {
                Count = NumOfColumns-CursorX;
        }
        memset(&(CodeLine[CursorX]),0x20,Count);
#if UNICODE_INTERNAL_BUFF
        memsetW(&(CodeLineW[CursorX]),0x20,Count);
#endif
        memset(&(AttrLine[CursorX]),AttrDefault,Count);
        memset(&(AttrLine2[CursorX]),CurCharAttr.Attr2 & Attr2ColorMask, Count);
        memset(&(AttrLineFG[CursorX]),CurCharAttr.Fore,Count);
        memset(&(AttrLineBG[CursorX]),CurCharAttr.Back,Count);

        /* update window */
        DispEraseCharsInLine(CursorX,Count);
}
#endif

void BuffFillWithE()
// Fill screen with 'E' characters
{
        LONG TmpPtr;
        int i;

        TmpPtr = GetLinePtr(PageStart);
        for (i = 0 ; i <= NumOfLines-1-StatusLine ; i++) {
                memset(&(CodeBuff[TmpPtr]),'E',NumOfColumns);
#if UNICODE_INTERNAL_BUFF
                memsetW(&(CodeBuffW[TmpPtr]),'E',NumOfColumns);
#endif
                memset(&(AttrBuff[TmpPtr]),AttrDefault,NumOfColumns);
                memset(&(AttrBuff2[TmpPtr]),AttrDefault,NumOfColumns);
                memset(&(AttrBuffFG[TmpPtr]),AttrDefaultFG,NumOfColumns);
                memset(&(AttrBuffBG[TmpPtr]),AttrDefaultBG,NumOfColumns);
                TmpPtr = NextLinePtr(TmpPtr);
        }
        BuffUpdateRect(WinOrgX,WinOrgY,WinOrgX+WinWidth-1,WinOrgY+WinHeight-1);
}

void BuffDrawLine(TCharAttr Attr, int Direction, int C)
{ // IO-8256 terminal
        LONG Ptr;
        int i, X, Y;

        if (C==0) {
                return;
        }
        Attr.Attr |= AttrSpecial;

        switch (Direction) {
                case 3:
                case 4:
                        if (Direction==3) {
                                if (CursorY==0) {
                                        return;
                                }
                                Y = CursorY-1;
                        }
                        else {
                                if (CursorY==NumOfLines-1-StatusLine) {
                                        return;
                                }
                                Y = CursorY+1;
                        }
                        if (CursorX+C > NumOfColumns) {
                                C = NumOfColumns-CursorX;
                        }
                        Ptr = GetLinePtr(PageStart+Y);
                        memset(&(CodeBuff[Ptr+CursorX]),'q',C);
#if UNICODE_INTERNAL_BUFF
                        memsetW(&(CodeBuffW[Ptr+CursorX]),'q',C);
#endif
                        memset(&(AttrBuff[Ptr+CursorX]),Attr.Attr,C);
                        memset(&(AttrBuff2[Ptr+CursorX]),Attr.Attr2,C);
                        memset(&(AttrBuffFG[Ptr+CursorX]),Attr.Fore,C);
                        memset(&(AttrBuffBG[Ptr+CursorX]),Attr.Back,C);
                        BuffUpdateRect(CursorX,Y,CursorX+C-1,Y);
                        break;
                case 5:
                case 6:
                        if (Direction==5) {
                                if (CursorX==0) {
                                        return;
                                }
                                X = CursorX - 1;
                        }
                        else {
                                if (CursorX==NumOfColumns-1) {
                                        X = CursorX-1;
                                }
                                else {
                                        X = CursorX+1;
                                }
                        }
                        Ptr = GetLinePtr(PageStart+CursorY);
                        if (CursorY+C > NumOfLines-StatusLine) {
                                C = NumOfLines-StatusLine-CursorY;
                        }
                        for (i=1; i<=C; i++) {
                                CodeBuff[Ptr+X] = 'x';
#if UNICODE_INTERNAL_BUFF
                                BuffSetChar(&CodeBuffW[Ptr+X], 0x20, 'H');
#endif
                                AttrBuff[Ptr+X] = Attr.Attr;
                                AttrBuff2[Ptr+X] = Attr.Attr2;
                                AttrBuffFG[Ptr+X] = Attr.Fore;
                                AttrBuffBG[Ptr+X] = Attr.Back;
                                Ptr = NextLinePtr(Ptr);
                        }
                        BuffUpdateRect(X,CursorY,X,CursorY+C-1);
                        break;
        }
}

void BuffEraseBox
  (int XStart, int YStart, int XEnd, int YEnd)
{
        int C, i;
        LONG Ptr;

        if (XEnd>NumOfColumns-1) {
                XEnd = NumOfColumns-1;
        }
        if (YEnd>NumOfLines-1-StatusLine) {
                YEnd = NumOfLines-1-StatusLine;
        }
        if (XStart>XEnd) {
                return;
        }
        if (YStart>YEnd) {
                return;
        }
        C = XEnd-XStart+1;
        Ptr = GetLinePtr(PageStart+YStart);
        for (i=YStart; i<=YEnd; i++) {
                if ((XStart>0) &&
                    ((AttrBuff[Ptr+XStart-1] & AttrKanji) != 0)) {
                        CodeBuff[Ptr+XStart-1] = 0x20;
#if UNICODE_INTERNAL_BUFF
                        BuffSetChar(&CodeBuffW[Ptr+XStart-1], 0x20, 'H');
#endif
                        AttrBuff[Ptr+XStart-1] = CurCharAttr.Attr;
                        AttrBuff2[Ptr+XStart-1] = CurCharAttr.Attr2;
                        AttrBuffFG[Ptr+XStart-1] = CurCharAttr.Fore;
                        AttrBuffBG[Ptr+XStart-1] = CurCharAttr.Back;
                }
                if ((XStart+C<NumOfColumns) &&
                    ((AttrBuff[Ptr+XStart+C-1] & AttrKanji) != 0)) {
                        CodeBuff[Ptr+XStart+C] = 0x20;
#if UNICODE_INTERNAL_BUFF
                        BuffSetChar(&CodeBuffW[Ptr+XStart+C], 0x20, 'H');
#endif
                        AttrBuff[Ptr+XStart+C] = CurCharAttr.Attr;
                        AttrBuff2[Ptr+XStart+C] = CurCharAttr.Attr2;
                        AttrBuffFG[Ptr+XStart+C] = CurCharAttr.Fore;
                        AttrBuffBG[Ptr+XStart+C] = CurCharAttr.Back;
                }
                memset(&(CodeBuff[Ptr+XStart]),0x20,C);
#if UNICODE_INTERNAL_BUFF
                memsetW(&(CodeBuffW[Ptr+XStart]),0x20,C);
#endif
                memset(&(AttrBuff[Ptr+XStart]),AttrDefault,C);
                memset(&(AttrBuff2[Ptr+XStart]),CurCharAttr.Attr2 & Attr2ColorMask, C);
                memset(&(AttrBuffFG[Ptr+XStart]),CurCharAttr.Fore,C);
                memset(&(AttrBuffBG[Ptr+XStart]),CurCharAttr.Back,C);
                Ptr = NextLinePtr(Ptr);
        }
        BuffUpdateRect(XStart,YStart,XEnd,YEnd);
}

void BuffFillBox(char ch, int XStart, int YStart, int XEnd, int YEnd)
{
        int Cols, i;
        LONG Ptr;

        if (XEnd>NumOfColumns-1) {
                XEnd = NumOfColumns-1;
        }
        if (YEnd>NumOfLines-1-StatusLine) {
                YEnd = NumOfLines-1-StatusLine;
        }
        if (XStart>XEnd) {
                return;
        }
        if (YStart>YEnd) {
                return;
        }
        Cols = XEnd-XStart+1;
        Ptr = GetLinePtr(PageStart+YStart);
        for (i=YStart; i<=YEnd; i++) {
                if ((XStart>0) &&
                    ((AttrBuff[Ptr+XStart-1] & AttrKanji) != 0)) {
                        CodeBuff[Ptr+XStart-1] = 0x20;
#if UNICODE_INTERNAL_BUFF
                        BuffSetChar(&CodeBuffW[Ptr + XStart - 1], 0x20, 'H');
#endif
                        AttrBuff[Ptr+XStart-1] ^= AttrKanji;
                }
                if ((XStart+Cols<NumOfColumns) &&
                    ((AttrBuff[Ptr+XStart+Cols-1] & AttrKanji) != 0)) {
                        CodeBuff[Ptr+XStart+Cols] = 0x20;
#if UNICODE_INTERNAL_BUFF
                        BuffSetChar(&CodeBuffW[Ptr + XStart + Cols], 0x20, 'H');
#endif
                }
                memset(&(CodeBuff[Ptr+XStart]), ch, Cols);
#if UNICODE_INTERNAL_BUFF
                memsetW(&(CodeBuffW[Ptr+XStart]), ch, Cols);
#endif
                memset(&(AttrBuff[Ptr+XStart]), CurCharAttr.Attr, Cols);
                memset(&(AttrBuff2[Ptr+XStart]), CurCharAttr.Attr2, Cols);
                memset(&(AttrBuffFG[Ptr+XStart]), CurCharAttr.Fore, Cols);
                memset(&(AttrBuffBG[Ptr+XStart]), CurCharAttr.Back, Cols);
                Ptr = NextLinePtr(Ptr);
        }
        BuffUpdateRect(XStart, YStart, XEnd, YEnd);
}

//
// TODO: 1 origin �������������� 0 origin ������
//
void BuffCopyBox(
        int SrcXStart, int SrcYStart, int SrcXEnd, int SrcYEnd, int SrcPage,
        int DstX, int DstY, int DstPage)
{
        int i, C, L;
        LONG SPtr, DPtr;

        SrcXStart--;
        SrcYStart--;
        SrcXEnd--;
        SrcYEnd--;
        SrcPage--;
        DstX--;
        DstY--;
        DstPage--;

        if (SrcXEnd > NumOfColumns - 1) {
                SrcXEnd = NumOfColumns-1;
        }
        if (SrcYEnd > NumOfLines-1-StatusLine) {
                SrcYEnd = NumOfColumns-1;
        }
        if (SrcXStart > SrcXEnd ||
            SrcYStart > SrcYEnd ||
            DstX > NumOfColumns-1 ||
            DstY > NumOfLines-1-StatusLine) {
                return;
        }

        C = SrcXEnd - SrcXStart + 1;
        if (DstX + C > NumOfColumns) {
                C = NumOfColumns - DstX;
        }
        L = SrcYEnd - SrcYStart + 1;
        if (DstY + C > NumOfColumns) {
                C = NumOfColumns - DstX;
        }

        if (SrcXStart > DstX) {
                SPtr = GetLinePtr(PageStart+SrcYStart);
                DPtr = GetLinePtr(PageStart+DstY);
                for (i=0; i<L; i++) {
                        memcpy(&(CodeBuff[DPtr+DstX]), &(CodeBuff[SPtr+SrcXStart]), C);
#if UNICODE_INTERNAL_BUFF
                        memcpyW(&(CodeBuffW[DPtr+DstX]), &(CodeBuffW[SPtr+SrcXStart]), C);
#endif
                        memcpy(&(AttrBuff[DPtr+DstX]), &(AttrBuff[SPtr+SrcXStart]), C);
                        memcpy(&(AttrBuff2[DPtr+DstX]), &(AttrBuff2[SPtr+SrcXStart]), C);
                        memcpy(&(AttrBuffFG[DPtr+DstX]), &(AttrBuffFG[SPtr+SrcXStart]), C);
                        memcpy(&(AttrBuffBG[DPtr+DstX]), &(AttrBuffBG[SPtr+SrcXStart]), C);
                        SPtr = NextLinePtr(SPtr);
                        DPtr = NextLinePtr(DPtr);
                }
        }
        else if (SrcXStart < DstX) {
                SPtr = GetLinePtr(PageStart+SrcYEnd);
                DPtr = GetLinePtr(PageStart+DstY+L-1);
                for (i=L; i>0; i--) {
                        memcpy(&(CodeBuff[DPtr+DstX]), &(CodeBuff[SPtr+SrcXStart]), C);
#if UNICODE_INTERNAL_BUFF
                        memcpyW(&(CodeBuffW[DPtr+DstX]), &(CodeBuffW[SPtr+SrcXStart]), C);
#endif
                        memcpy(&(AttrBuff[DPtr+DstX]), &(AttrBuff[SPtr+SrcXStart]), C);
                        memcpy(&(AttrBuff2[DPtr+DstX]), &(AttrBuff2[SPtr+SrcXStart]), C);
                        memcpy(&(AttrBuffFG[DPtr+DstX]), &(AttrBuffFG[SPtr+SrcXStart]), C);
                        memcpy(&(AttrBuffBG[DPtr+DstX]), &(AttrBuffBG[SPtr+SrcXStart]), C);
                        SPtr = PrevLinePtr(SPtr);
                        DPtr = PrevLinePtr(DPtr);
                }
        }
        else if (SrcYStart != DstY) {
                SPtr = GetLinePtr(PageStart+SrcYStart);
                DPtr = GetLinePtr(PageStart+DstY);
                for (i=0; i<L; i++) {
                        memmove(&(CodeBuff[DPtr+DstX]), &(CodeBuff[SPtr+SrcXStart]), C);
#if UNICODE_INTERNAL_BUFF
                        memmoveW(&(CodeBuffW[DPtr+DstX]), &(CodeBuffW[SPtr+SrcXStart]), C);
#endif
                        memmove(&(AttrBuff[DPtr+DstX]), &(AttrBuff[SPtr+SrcXStart]), C);
                        memmove(&(AttrBuff2[DPtr+DstX]), &(AttrBuff2[SPtr+SrcXStart]), C);
                        memmove(&(AttrBuffFG[DPtr+DstX]), &(AttrBuffFG[SPtr+SrcXStart]), C);
                        memmove(&(AttrBuffBG[DPtr+DstX]), &(AttrBuffBG[SPtr+SrcXStart]), C);
                        SPtr = NextLinePtr(SPtr);
                        DPtr = NextLinePtr(DPtr);
                }
        }
        BuffUpdateRect(DstX,DstY,DstX+C-1,DstY+L-1);
}

void BuffChangeAttrBox(int XStart, int YStart, int XEnd, int YEnd, PCharAttr attr, PCharAttr mask)
{
        int C, i, j;
        LONG Ptr;

        if (XEnd>NumOfColumns-1) {
                XEnd = NumOfColumns-1;
        }
        if (YEnd>NumOfLines-1-StatusLine) {
                YEnd = NumOfLines-1-StatusLine;
        }
        if (XStart>XEnd || YStart>YEnd) {
                return;
        }
        C = XEnd-XStart+1;
        Ptr = GetLinePtr(PageStart+YStart);

        if (mask) { // DECCARA
                for (i=YStart; i<=YEnd; i++) {
                        j = Ptr+XStart-1;
                        if (XStart>0 && (AttrBuff[j] & AttrKanji)) {
                                AttrBuff[j] = AttrBuff[j] & ~mask->Attr | attr->Attr;
                                AttrBuff2[j] = AttrBuff2[j] & ~mask->Attr2 | attr->Attr2;
                                if (mask->Attr2 & Attr2Fore) { AttrBuffFG[j] = attr->Fore; }
                                if (mask->Attr2 & Attr2Back) { AttrBuffBG[j] = attr->Back; }
                        }
                        while (++j < Ptr+XStart+C) {
                                AttrBuff[j] = AttrBuff[j] & ~mask->Attr | attr->Attr;
                                AttrBuff2[j] = AttrBuff2[j] & ~mask->Attr2 | attr->Attr2;
                                if (mask->Attr2 & Attr2Fore) { AttrBuffFG[j] = attr->Fore; }
                                if (mask->Attr2 & Attr2Back) { AttrBuffBG[j] = attr->Back; }
                        }
                        if (XStart+C<NumOfColumns && (AttrBuff[j-1] & AttrKanji)) {
                                AttrBuff[j] = AttrBuff[j] & ~mask->Attr | attr->Attr;
                                AttrBuff2[j] = AttrBuff2[j] & ~mask->Attr2 | attr->Attr2;
                                if (mask->Attr2 & Attr2Fore) { AttrBuffFG[j] = attr->Fore; }
                                if (mask->Attr2 & Attr2Back) { AttrBuffBG[j] = attr->Back; }
                        }
                        Ptr = NextLinePtr(Ptr);
                }
        }
        else { // DECRARA
                for (i=YStart; i<=YEnd; i++) {
                        j = Ptr+XStart-1;
                        if (XStart>0 && (AttrBuff[j] & AttrKanji)) {
                                AttrBuff[j] ^= attr->Attr;
                        }
                        while (++j < Ptr+XStart+C) {
                                AttrBuff[j] ^= attr->Attr;
                        }
                        if (XStart+C<NumOfColumns && (AttrBuff[j-1] & AttrKanji)) {
                                AttrBuff[j] ^= attr->Attr;
                        }
                        Ptr = NextLinePtr(Ptr);
                }
        }
        BuffUpdateRect(XStart, YStart, XEnd, YEnd);
}

void BuffChangeAttrStream(int XStart, int YStart, int XEnd, int YEnd, PCharAttr attr, PCharAttr mask)
{
        int i, j, endp;
        LONG Ptr;

        if (XEnd>NumOfColumns-1) {
                XEnd = NumOfColumns-1;
        }
        if (YEnd>NumOfLines-1-StatusLine) {
                YEnd = NumOfLines-1-StatusLine;
        }
        if (XStart>XEnd || YStart>YEnd) {
                return;
        }

        Ptr = GetLinePtr(PageStart+YStart);

        if (mask) { // DECCARA
                if (YStart == YEnd) {
                        i = Ptr + XStart - 1;
                        endp = Ptr + XEnd + 1;

                        if (XStart > 0 && (AttrBuff[i] & AttrKanji)) {
                                AttrBuff[i] = AttrBuff[i] & ~mask->Attr | attr->Attr;
                                AttrBuff2[i] = AttrBuff2[i] & ~mask->Attr2 | attr->Attr2;
                                if (mask->Attr2 & Attr2Fore) { AttrBuffFG[i] = attr->Fore; }
                                if (mask->Attr2 & Attr2Back) { AttrBuffBG[i] = attr->Back; }
                        }
                        while (++i < endp) {
                                AttrBuff[i] = AttrBuff[i] & ~mask->Attr | attr->Attr;
                                AttrBuff2[i] = AttrBuff2[i] & ~mask->Attr2 | attr->Attr2;
                                if (mask->Attr2 & Attr2Fore) { AttrBuffFG[i] = attr->Fore; }
                                if (mask->Attr2 & Attr2Back) { AttrBuffBG[i] = attr->Back; }
                        }
                        if (XEnd < NumOfColumns-1 && (AttrBuff[i-1] & AttrKanji)) {
                                AttrBuff[i] = AttrBuff[i] & ~mask->Attr | attr->Attr;
                                AttrBuff2[i] = AttrBuff2[i] & ~mask->Attr2 | attr->Attr2;
                                if (mask->Attr2 & Attr2Fore) { AttrBuffFG[i] = attr->Fore; }
                                if (mask->Attr2 & Attr2Back) { AttrBuffBG[i] = attr->Back; }
                        }
                }
                else {
                        i = Ptr + XStart - 1;
                        endp = Ptr + NumOfColumns;

                        if (XStart > 0 && (AttrBuff[i] & AttrKanji)) {
                                AttrBuff[i] = AttrBuff[i] & ~mask->Attr | attr->Attr;
                                AttrBuff2[i] = AttrBuff2[i] & ~mask->Attr2 | attr->Attr2;
                                if (mask->Attr2 & Attr2Fore) { AttrBuffFG[i] = attr->Fore; }
                                if (mask->Attr2 & Attr2Back) { AttrBuffBG[i] = attr->Back; }
                        }
                        while (++i < endp) {
                                AttrBuff[i] = AttrBuff[i] & ~mask->Attr | attr->Attr;
                                AttrBuff2[i] = AttrBuff2[i] & ~mask->Attr2 | attr->Attr2;
                                if (mask->Attr2 & Attr2Fore) { AttrBuffFG[i] = attr->Fore; }
                                if (mask->Attr2 & Attr2Back) { AttrBuffBG[i] = attr->Back; }
                        }

                        for (j=0; j < YEnd-YStart-1; j++) {
                                Ptr = NextLinePtr(Ptr);
                                i = Ptr;
                                endp = Ptr + NumOfColumns;

                                while (i < endp) {
                                        AttrBuff[i] = AttrBuff[i] & ~mask->Attr | attr->Attr;
                                        AttrBuff2[i] = AttrBuff2[i] & ~mask->Attr2 | attr->Attr2;
                                        if (mask->Attr2 & Attr2Fore) { AttrBuffFG[i] = attr->Fore; }
                                        if (mask->Attr2 & Attr2Back) { AttrBuffBG[i] = attr->Back; }
                                        i++;
                                }
                        }

                        Ptr = NextLinePtr(Ptr);
                        i = Ptr;
                        endp = Ptr + XEnd + 1;

                        while (i < endp) {
                                AttrBuff[i] = AttrBuff[i] & ~mask->Attr | attr->Attr;
                                AttrBuff2[i] = AttrBuff2[i] & ~mask->Attr2 | attr->Attr2;
                                if (mask->Attr2 & Attr2Fore) { AttrBuffFG[i] = attr->Fore; }
                                if (mask->Attr2 & Attr2Back) { AttrBuffBG[i] = attr->Back; }
                                i++;
                        }
                        if (XEnd < NumOfColumns-1 && (AttrBuff[i-1] & AttrKanji)) {
                                AttrBuff[i] = AttrBuff[i] & ~mask->Attr | attr->Attr;
                                AttrBuff2[i] = AttrBuff2[i] & ~mask->Attr2 | attr->Attr2;
                                if (mask->Attr2 & Attr2Fore) { AttrBuffFG[i] = attr->Fore; }
                                if (mask->Attr2 & Attr2Back) { AttrBuffBG[i] = attr->Back; }
                        }
                }
        }
        else { // DECRARA
                if (YStart == YEnd) {
                        i = Ptr + XStart - 1;
                        endp = Ptr + XEnd + 1;

                        if (XStart > 0 && (AttrBuff[i] & AttrKanji)) {
                                AttrBuff[i] ^= attr->Attr;
                        }
                        while (++i < endp) {
                                AttrBuff[i] ^= attr->Attr;
                        }
                        if (XEnd < NumOfColumns-1 && (AttrBuff[i-1] & AttrKanji)) {
                                AttrBuff[i] ^= attr->Attr;
                        }
                }
                else {
                        i = Ptr + XStart - 1;
                        endp = Ptr + NumOfColumns;

                        if (XStart > 0 && (AttrBuff[i] & AttrKanji)) {
                                AttrBuff[i] ^= attr->Attr;
                        }
                        while (++i < endp) {
                                AttrBuff[i] ^= attr->Attr;
                        }

                        for (j=0; j < YEnd-YStart-1; j++) {
                                Ptr = NextLinePtr(Ptr);
                                i = Ptr;
                                endp = Ptr + NumOfColumns;

                                while (i < endp) {
                                        AttrBuff[i] ^= attr->Attr;
                                        i++;
                                }
                        }

                        Ptr = NextLinePtr(Ptr);
                        i = Ptr;
                        endp = Ptr + XEnd + 1;

                        while (i < endp) {
                                AttrBuff[i] ^= attr->Attr;
                                i++;
                        }
                        if (XEnd < NumOfColumns-1 && (AttrBuff[i-1] & AttrKanji)) {
                                AttrBuff[i] ^= attr->Attr;
                        }
                        Ptr = NextLinePtr(Ptr);
                }
        }
        BuffUpdateRect(0, YStart, NumOfColumns-1, YEnd);
}

static int LeftHalfOfDBCS(LONG Line, int CharPtr)
// If CharPtr is on the right half of a DBCS character,
// return pointer to the left half
//   Line: points to a line in CodeBuff
//   CharPtr: points to a char
//   return: points to the left half of the DBCS
{
        if ((CharPtr>0) &&
                ((AttrBuff[Line+CharPtr-1] & AttrKanji) != 0)) {
                CharPtr--;
        }
        return CharPtr;
}

static int MoveCharPtr(LONG Line, int *x, int dx)
// move character pointer x by dx character unit
//   in the line specified by Line
//   Line: points to a line in CodeBuff
//   x: points to a character in the line
//   dx: moving distance in character unit (-: left, +: right)
//      One DBCS character is counted as one character.
//      The pointer stops at the beginning or the end of line.
// Output
//   x: new pointer. x points to a SBCS character or
//      the left half of a DBCS character.
//   return: actual moving distance in character unit
{
        int i;

        *x = LeftHalfOfDBCS(Line,*x);
        i = 0;
        while (dx!=0) {
                if (dx>0) { // move right
                        if ((AttrBuff[Line+*x] & AttrKanji) != 0) {
                                if (*x<NumOfColumns-2) {
                                        i++;
                                        *x = *x + 2;
                                }
                        }
                        else if (*x<NumOfColumns-1) {
                                i++;
                                (*x)++;
                        }
                        dx--;
                }
                else { // move left
                        if (*x>0) {
                                i--;
                                (*x)--;
                        }
                        *x = LeftHalfOfDBCS(Line,*x);
                        dx++;
                }
        }
        return i;
}

/**
 *      (�N���b�v�{�[�h�p��)������������
 *      @param[in]      sx,sy,ex,ey     �I������
 *      @param[in]      box_select      TRUE=���^(���`)�I��
 *                                                      FALSE=�s�I��
 *      @param[out] _str_len    ��������(�����[L'\0'������)
 *                              NULL����������������
 *      @return         ������
 *                              �g�p���� free() ��������
 */
#if UNICODE_INTERNAL_BUFF
static wchar_t *BuffGetStringForCB(int sx, int sy, int ex, int ey, BOOL box_select, size_t *_str_len)
{
        wchar_t *str_w;
        size_t str_size;        // �m�������T�C�Y
        size_t k;
        LONG TmpPtr;
        int IStart, IEnd;
        int x, y;
        BOOL LineContinued;

        str_size = NumOfColumns * (ey - sy + 1);
        str_w = malloc(sizeof(wchar_t) * str_size);

        LockBuffer();

        str_w[0] = 0;
        TmpPtr = GetLinePtr(sy);
        k = 0;
        for (y = sy; y<=ey ; y++) {
                if (box_select) {
                        IStart = SelectStart.x;
                        IEnd = SelectEnd.x-1;
                }
                else {
                        IStart = 0;
                        IEnd = NumOfColumns-1;
                        if (y== sy) {
                                IStart = sx;
                        }
                        if (y== ey) {
                                IEnd = ex -1;
                        }
                }

                // �����s����������?
                LineContinued = FALSE;
                if (!box_select) {
                        // �s�I������������
                        if (ts.EnableContinuedLineCopy && y!= ey ) {
                                LONG NextTmpPtr = NextLinePtr(TmpPtr);
                                if ((AttrBuff[NextTmpPtr] & AttrLineContinued) != 0) {
                                        LineContinued = TRUE;
                                }
                        }
                }

                if (!LineContinued) {
                        while ((IEnd>0)) {
                                // �R�s�[�s�v��������
                                const buff_char_t *b = &CodeBuffW[TmpPtr + IEnd];
                                if (b->u32 == 0x20) {
                                        MoveCharPtr(TmpPtr,&IEnd,-1);   // �����l����
                                }
                                else {
                                        break;
                                }
                        }
                }

                x = IStart;
                while (x <= IEnd) {
                        const buff_char_t *b = &CodeBuffW[TmpPtr + x];
                        if (b->u32 != 0) {
                                str_w[k++] = b->wc2[0];
                                if (b->wc2[1] != 0) {
                                        str_w[k++] = b->wc2[1];
                                }
                                if (k + 2 >= str_size) {
                                        str_size *= 2;
                                        str_w = realloc(str_w, sizeof(wchar_t) * str_size);
                                }
                                {
                                        int i;
                                        // �R���r�l�[�V����
                                        if (k + b->CombinationCharCount16 >= str_size) {
                                                str_size += + b->CombinationCharCount16;
                                                str_w = realloc(str_w, sizeof(wchar_t) * str_size);
                                        }
                                        for (i = 0 ; i < (int)b->CombinationCharCount16; i++) {
                                                str_w[k++] = b->pCombinationChars16[i];
                                        }
                                }
                        }
                        x++;
                }

                if (y < ey) {
                        // ���s��������(�������s���O������)
                        if (!LineContinued) {
                                str_w[k++] = 0x0d;
                                str_w[k++] = 0x0a;
                        }
                }

                TmpPtr = NextLinePtr(TmpPtr);
        }
        str_w[k++] = 0;

        UnlockBuffer();

        if (_str_len != NULL) {
                *_str_len = k;
        }
        return str_w;
}
#endif

/**
 *      (x,y) ��1������ str��������������
 *              *�� 1������������wchar_t�����\������������
 *
 *      @param          y               PageStart + CursorY
 *      @param          str             1����(wchar_t��)
 *      @param          len             ��������
 *      @retval         0=�}�b�`����������
 *                              �}�b�`������������
 */
#if UNICODE_INTERNAL_BUFF
static size_t MatchOneString(int x, int y, const wchar_t *str, size_t len)
{
        int match_pos = 0;
        int TmpPtr = GetLinePtr(y);
        const buff_char_t *b = &CodeBuffW[TmpPtr + x];
        if (b->wc2[1] == 0) {
                // �T���Q�[�g�y�A��������
                if (str[match_pos] != b->wc2[0]) {
                        return 0;
                }
                match_pos++;
                len--;
        } else {
                // �T���Q�[�g�y�A
                if (len < 2) {
                        return 0;
                }
                if (str[match_pos+0] != b->wc2[0] ||
                        str[match_pos+1] != b->wc2[1]) {
                        return 0;
                }
                match_pos+=2;
                len-=2;
        }
        if (b->CombinationCharCount16 > 0) {
                // �R���r�l�[�V����
                int i;
                if (len < b->CombinationCharCount16) {
                        return 0;
                }
                for (i = 0 ; i < (int)b->CombinationCharCount16; i++) {
                        if (str[match_pos++] != b->pCombinationChars16[i]) {
                                return 0;
                        }
                }
                len -= b->CombinationCharCount16;
        }
        return match_pos;
}
#endif

/**
 *      (x,y)���� str��������������
 *
 *      @param          x               �}�C�i�X�����A�����s������������
 *      @param          y               PageStart + CursorY
 *      @param          LineCntinued    TRUE=�s���p�����l������
 *      @retval         TRUE    �}�b�`����
 *      @retval         FALSE   �}�b�`����������
 */
#if UNICODE_INTERNAL_BUFF
static BOOL MatchString(int x, int y, const wchar_t *str, BOOL LineContinued)
{
        BOOL result;
        int TmpPtr = GetLinePtr(y);
        size_t len = wcslen(str);
        if (len == 0) {
                return FALSE;
        }
        while(x < 0) {
                if (LineContinued && (AttrBuff[TmpPtr+0] & AttrLineContinued) == 0) {
                        // �s���p�������������l�� & �p������������
                        x = 0;  // �s������������
                        break;
                }
                TmpPtr = PrevLinePtr(TmpPtr);
                x += NumOfColumns;
                y--;
        }
        while(x > NumOfColumns) {
                if (LineContinued && (AttrBuff[TmpPtr+NumOfColumns-1] & AttrLineContinued) == 0) {
                        // �s���p�������������l�� & �p������������
                        x = 0;  // �s������������
                        break;
                }
                TmpPtr = NextLinePtr(TmpPtr);
                x -= NumOfColumns;
        }

        for(;;) {
                // 1����������������
                size_t match_len = MatchOneString(x, y, str, len);
                if (match_len == 0) {
                        result = FALSE;
                        break;
                }
                len -= match_len;
                if (len == 0) {
                        // �S���������I������
                        result = TRUE;
                        break;
                }
                str += match_len;

                // ��������
                x++;
                if (x == NumOfColumns) {
                        if (LineContinued && (AttrBuff[TmpPtr+NumOfColumns-1] & AttrLineContinued) != 0) {
                                // �����s��
                                x = 0;
                                TmpPtr = NextLinePtr(TmpPtr);
                                y++;
                        } else {
                                // �s��
                                result = FALSE;
                                break;
                        }
                }
        }

        return result;
}
#endif

/**
 *      (sx,sy)����(ex,ey)������ str ���}�b�`�����������T����
 *      ���u������
 *
 *      @param          sy,ex   PageStart + CursorY
 *      @param[out]     x               �}�b�`�������u
 *      @param[out]     y               �}�b�`�������u
 *      @retval         TRUE    �}�b�`����
 */
#if UNICODE_INTERNAL_BUFF
static BOOL BuffGetMatchPosFromString(
        int sx, int sy, int ex, int ey, const wchar_t *str,
        int *match_x, int *match_y)
{