[Ttssh2-commit] [8721] AttrBuff, AttrBuff2 を削除

Back to archive index
scmno****@osdn***** scmno****@osdn*****
2020年 4月 13日 (月) 01:41:16 JST


Revision: 8721
          https://osdn.net/projects/ttssh2/scm/svn/commits/8721
Author:   zmatsuo
Date:     2020-04-13 01:41:15 +0900 (Mon, 13 Apr 2020)
Log Message:
-----------
AttrBuff, AttrBuff2 を削除

Modified Paths:
--------------
    branches/unicode_buf_2/teraterm/teraterm/buffer.c

-------------- next part --------------
Modified: branches/unicode_buf_2/teraterm/teraterm/buffer.c
===================================================================
--- branches/unicode_buf_2/teraterm/teraterm/buffer.c	2020-04-12 16:41:08 UTC (rev 8720)
+++ branches/unicode_buf_2/teraterm/teraterm/buffer.c	2020-04-12 16:41:15 UTC (rev 8721)
@@ -70,6 +70,8 @@
 	wchar_t	wc2[2];
 	unsigned char fg;
 	unsigned char bg;
+	unsigned char attr;
+	unsigned char attr2;
 } buff_char_t;
 
 #define BuffXMax TermWidthMax
@@ -92,8 +94,8 @@
 static WORD BuffLock = 0;
 
 static PCHAR CodeBuff;  /* Character code buffer */
-static PCHAR AttrBuff;  /* Attribute buffer */
-static PCHAR AttrBuff2; /* Color attr 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 */
 #define ATR 0
@@ -178,6 +180,16 @@
 	p->bg = bg;
 }
 
+static void BuffSetChar4(buff_char_t *buff, char32_t u32, unsigned char fg, unsigned char bg, unsigned char attr, unsigned char attr2, char property)
+{
+	buff_char_t *p = buff;
+	BuffSetChar2(p, u32, property, TRUE, FALSE);
+	p->fg = fg;
+	p->bg = bg;
+	p->attr = attr;
+	p->attr2 = attr2;
+}
+
 static void BuffSetChar(buff_char_t *buff, char32_t u32, char property)
 {
 	BuffSetChar2(buff, u32, property, TRUE, FALSE);
@@ -217,6 +229,7 @@
 	}
 }
 
+// TODO: \x83\x8A\x81[\x83N\x94\xAD\x90\xB6
 static void memcpyW(buff_char_t *dest, const buff_char_t *src, size_t count)
 {
 	size_t i;
@@ -238,7 +251,7 @@
 	}
 }
 
-static void memsetW(buff_char_t *dest, wchar_t ch, unsigned char fg, unsigned char bg, size_t count)
+static void memsetW(buff_char_t *dest, wchar_t ch, unsigned char fg, unsigned char bg, unsigned char attr, unsigned char attr2, size_t count)
 {
 	size_t i;
 	for (i=0; i<count; i++) {
@@ -245,6 +258,8 @@
 		BuffSetChar(dest, ch, 'H');
 		dest->fg = fg;
 		dest->bg = bg;
+		dest->attr = attr;
+		dest->attr2 = attr2;
 		dest++;
 	}
 }
@@ -305,7 +320,8 @@
 //	PCHAR CodeLine = &CodeBuff[LinePtr];
 	LONG NewSize;
 	int NxCopy, NyCopy, i;
-	PCHAR CodeDest, AttrDest, AttrDest2;
+	PCHAR CodeDest;
+//	PCHAR AttrDest, AttrDest2;
 //	PCHAR AttrDestFG, AttrDestBG;
 	LONG SrcPtr, DestPtr;
 	WORD LockOld;
@@ -328,8 +344,8 @@
 	NewSize = (LONG)Nx * (LONG)Ny;
 
 	CodeDest = NULL;
-	AttrDest = NULL;
-	AttrDest2 = NULL;
+//	AttrDest = NULL;
+//	AttrDest2 = NULL;
 //	AttrDestFG = NULL;
 //	AttrDestBG = NULL;
 	CodeDestW = NULL;
@@ -338,6 +354,7 @@
 	if (CodeDest == NULL) {
 		goto allocate_error;
 	}
+#if 0
 	AttrDest = malloc(NewSize);
 	if (AttrDest == NULL) {
 		goto allocate_error;
@@ -346,6 +363,7 @@
 	if (AttrDest2 == NULL) {
 		goto allocate_error;
 	}
+#endif
 #if 0
 	AttrDestFG = malloc(NewSize);
 	if (AttrDestFG == NULL) {
@@ -363,9 +381,9 @@
 
 	memset(&CodeDest[0], 0x20, NewSize);
 	memset(&CodeDestW[0], 0, NewSize * sizeof(buff_char_t));
-	memsetW(&CodeDestW[0], 0x20, AttrDefaultFG, AttrDefaultBG, NewSize);
-	memset(&AttrDest[0], AttrDefault, NewSize);
-	memset(&AttrDest2[0], AttrDefault, NewSize);
+	memsetW(&CodeDestW[0], 0x20, AttrDefaultFG, AttrDefaultBG, AttrDefault, AttrDefault, NewSize);
+//	memset(&AttrDest[0], AttrDefault, NewSize);
+//	memset(&AttrDest2[0], AttrDefault, NewSize);
 //	memset(&AttrDestFG[0], AttrDefaultFG, NewSize);
 //	memset(&AttrDestBG[0], AttrDefaultBG, NewSize);
 	if ( CodeBuff != NULL ) {
@@ -389,14 +407,20 @@
 		for (i = 1 ; i <= NyCopy ; i++) {
 			memcpy(&CodeDest[DestPtr],&CodeBuff[SrcPtr],NxCopy);
 			memcpyW(&CodeDestW[DestPtr],&CodeBuffW[SrcPtr],NxCopy);
-			memcpy(&AttrDest[DestPtr],&AttrBuff[SrcPtr],NxCopy);
-			memcpy(&AttrDest2[DestPtr],&AttrBuff2[SrcPtr],NxCopy);
+//			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 0
 			if (AttrDest[DestPtr+NxCopy-1] & AttrKanji) {
 				CodeDest[DestPtr+NxCopy-1] = ' ';
 				AttrDest[DestPtr+NxCopy-1] ^= AttrKanji;
 			}
+#endif
+			if (CodeDestW[DestPtr+NxCopy-1].attr & AttrKanji) {
+				CodeDest[DestPtr+NxCopy-1] = ' ';
+				CodeDestW[DestPtr+NxCopy-1].attr ^= AttrKanji;
+			}
 			SrcPtr = NextLinePtr(SrcPtr);
 			DestPtr = DestPtr + (LONG)Nx;
 		}
@@ -426,8 +450,8 @@
 	}
 
 	CodeBuff = CodeDest;
-	AttrBuff = AttrDest;
-	AttrBuff2 = AttrDest2;
+//	AttrBuff = AttrDest;
+//	AttrBuff2 = AttrDest2;
 //	AttrBuffFG = AttrDestFG;
 //	AttrBuffBG = AttrDestBG;
 	CodeBuffW = CodeDestW;
@@ -465,8 +489,8 @@
 
 allocate_error:
 	if (CodeDest)   free(CodeDest);
-	if (AttrDest)   free(AttrDest);
-	if (AttrDest2)  free(AttrDest2);
+//	if (AttrDest)   free(AttrDest);
+//	if (AttrDest2)  free(AttrDest2);
 //	if (AttrDestFG) free(AttrDestFG);
 //	if (AttrDestBG) free(AttrDestBG);
 	if (CodeDestW)  free(CodeDestW);
@@ -558,6 +582,7 @@
 		free(CodeBuffW);
 		CodeBuffW = NULL;
 	}
+#if 0
 	if (AttrBuff!=NULL) {
 		free(AttrBuff);
 		AttrBuff = NULL;
@@ -566,6 +591,7 @@
 		free(AttrBuff2);
 		AttrBuff2 = NULL;
 	}
+#endif
 #if 0
 	if (AttrBuffFG!=NULL) {
 		free(AttrBuffFG);
@@ -670,14 +696,14 @@
 		for (i=NumOfLines-1; i>=Bottom+1; i--) {
 			memcpy(&(CodeBuff[DestPtr]),&(CodeBuff[SrcPtr]),NumOfColumns);
 			memcpyW(&(CodeBuffW[DestPtr]),&(CodeBuffW[SrcPtr]),NumOfColumns);
-			memcpy(&(AttrBuff[DestPtr]),&(AttrBuff[SrcPtr]),NumOfColumns);
-			memcpy(&(AttrBuff2[DestPtr]),&(AttrBuff2[SrcPtr]),NumOfColumns);
+//			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);
-			memsetW(&(CodeBuffW[SrcPtr]),0x20,CurCharAttr.Fore, CurCharAttr.Back, NumOfColumns);
-			memset(&(AttrBuff[SrcPtr]),AttrDefault,NumOfColumns);
-			memset(&(AttrBuff2[SrcPtr]),CurCharAttr.Attr2 & Attr2ColorMask, NumOfColumns);
+			memsetW(&(CodeBuffW[SrcPtr]),0x20,CurCharAttr.Fore, CurCharAttr.Back, AttrDefault, CurCharAttr.Attr2 & Attr2ColorMask, NumOfColumns);
+//			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);
@@ -688,9 +714,9 @@
 	for (i = 1 ; i <= n ; i++) {
 		buff_char_t *b = &CodeBuffW[DestPtr];
 		memset(&CodeBuff[DestPtr],0x20,NumOfColumns);
-		memsetW(b ,0x20, CurCharAttr.Fore, CurCharAttr.Back, NumOfColumns);
-		memset(&AttrBuff[DestPtr],AttrDefault,NumOfColumns);
-		memset(&AttrBuff2[DestPtr],CurCharAttr.Attr2 & Attr2ColorMask, NumOfColumns);
+		memsetW(b ,0x20, CurCharAttr.Fore, CurCharAttr.Back, AttrDefault, CurCharAttr.Attr2 & Attr2ColorMask, NumOfColumns);
+//		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);
@@ -727,36 +753,6 @@
 	NewLine(PageStart+CursorY);
 }
 
-#if 0
-static void NextLine()
-{
-	LinePtr = NextLinePtr(LinePtr);
-#if ATR
-	CodeLine = &CodeBuff[LinePtr];
-	AttrLine = &AttrBuff[LinePtr];
-	AttrLine2 = &AttrBuff2[LinePtr];
-	AttrLineFG = &AttrBuffFG[LinePtr];
-	AttrLineBG = &AttrBuffBG[LinePtr];
-	CodeLineW = &CodeBuffW[LinePtr];
-#endif
-}
-#endif
-
-#if 0
-static void PrevLine()
-{
-	LinePtr = PrevLinePtr(LinePtr);
-#if ATR
-	CodeLine = &CodeBuff[LinePtr];
-	AttrLine = &AttrBuff[LinePtr];
-	AttrLine2 = &AttrBuff2[LinePtr];
-	AttrLineFG = &AttrBuffFG[LinePtr];
-	AttrLineBG = &AttrBuffBG[LinePtr];
-	CodeLineW = &CodeBuffW[LinePtr];
-#endif
-}
-#endif
-
 // If cursor is on left/right half of a Kanji, erase it.
 //   LR: left(0)/right(1) flag
 //	LR	0	\x83J\x81[\x83\\x83\x8B\x82\xAA\x8A\xBF\x8E\x9A\x82̍\xB6\x91\xA4
@@ -765,8 +761,8 @@
 {
 #if !ATR
 	PCHAR CodeLine = &CodeBuff[LinePtr];
-	PCHAR AttrLine = &AttrBuff[LinePtr];
-	PCHAR AttrLine2 = &AttrBuff2[LinePtr];
+//	PCHAR AttrLine = &AttrBuff[LinePtr];
+//	PCHAR AttrLine2 = &AttrBuff2[LinePtr];
 //	PCHAR AttrLineFG = &AttrBuffFG[LinePtr];
 //	PCHAR AttrLineBG = &AttrBuffBG[LinePtr];
 	buff_char_t * CodeLineW = &CodeBuffW[LinePtr];
@@ -784,8 +780,10 @@
 		// \x91S\x8Ap\x82\xF0\x82‚Ԃ\xB7
 		BuffSetChar(p, ' ', 'H');
 		CodeLine[bx] = 0x20;
-		AttrLine[bx] = CurCharAttr.Attr;
-		AttrLine2[bx] = CurCharAttr.Attr2;
+		p->attr = CurCharAttr.Attr;
+		p->attr2 = CurCharAttr.Attr2;
+//		AttrLine[bx] = CurCharAttr.Attr;
+//		AttrLine2[bx] = CurCharAttr.Attr2;
 //		AttrLineFG[bx] = CurCharAttr.Fore;
 //		AttrLineBG[bx] = CurCharAttr.Back;
 		p->fg = CurCharAttr.Fore;
@@ -793,8 +791,10 @@
 		if (bx+1 < NumOfColumns) {
 			BuffSetChar(p + 1, ' ', 'H');
 			CodeLine[bx+1] = 0x20;
-			AttrLine[bx+1] = CurCharAttr.Attr;
-			AttrLine2[bx+1] = CurCharAttr.Attr2;
+			(p+1)->attr = CurCharAttr.Attr;
+			(p+1)->attr2 = CurCharAttr.Attr2;
+//			AttrLine[bx+1] = CurCharAttr.Attr;
+//			AttrLine2[bx+1] = CurCharAttr.Attr2;
 //			AttrLineFG[bx+1] = CurCharAttr.Fore;
 //			AttrLineBG[bx+1] = CurCharAttr.Back;
 			(p+1)->fg = CurCharAttr.Fore;
@@ -813,24 +813,29 @@
 
 	for (i=0; i<count; i++) {
 		pos = ptr + CursorLeftM-1;
-		if (CursorLeftM>0 && (AttrBuff[pos] & AttrKanji)) {
+		if (CursorLeftM>0 && (CodeBuffW[pos].attr & AttrKanji)) {
 			CodeBuff[pos] = 0x20;
 			BuffSetChar(&CodeBuffW[pos], 0x20, 'H');
-			AttrBuff[pos] &= ~AttrKanji;
+//			AttrBuff[pos] &= ~AttrKanji;
+			CodeBuffW[pos].attr &= ~AttrKanji;
 			pos++;
 			CodeBuff[pos] = 0x20;
 			BuffSetChar(&CodeBuffW[pos], 0x20, 'H');
-			AttrBuff[pos] &= ~AttrKanji;
+//			AttrBuff[pos] &= ~AttrKanji;
+			CodeBuffW[pos].attr &= ~AttrKanji;
 		}
 		pos = ptr + CursorRightM;
-		if (CursorRightM < NumOfColumns-1 && (AttrBuff[pos] & AttrKanji)) {
+//		if (CursorRightM < NumOfColumns-1 && (AttrBuff[pos] & AttrKanji)) {
+		if (CursorRightM < NumOfColumns-1 && (CodeBuffW[pos].attr & AttrKanji)) {
 			CodeBuff[pos] = 0x20;
 			BuffSetChar(&CodeBuffW[pos], 0x20, 'H');
-			AttrBuff[pos] &= ~AttrKanji;
+//			AttrBuff[pos] &= ~AttrKanji;
+			CodeBuffW[pos].attr &= ~AttrKanji;
 			pos++;
 			CodeBuff[pos] = 0x20;
 			BuffSetChar(&CodeBuffW[pos], 0x20, 'H');
-			AttrBuff[pos] &= ~AttrKanji;
+//			AttrBuff[pos] &= ~AttrKanji;
+			CodeBuffW[pos].attr &= ~AttrKanji;
 		}
 		ptr = NextLinePtr(ptr);
 	}
@@ -842,8 +847,8 @@
 {
 #if !ATR
 	PCHAR CodeLine = &CodeBuff[LinePtr];
-	PCHAR AttrLine = &AttrBuff[LinePtr];
-	PCHAR AttrLine2 = &AttrBuff2[LinePtr];
+//	PCHAR AttrLine = &AttrBuff[LinePtr];
+//	PCHAR AttrLine2 = &AttrBuff2[LinePtr];
 //	PCHAR AttrLineFG = &AttrBuffFG[LinePtr];
 //	PCHAR AttrLineBG = &AttrBuffBG[LinePtr];
 	buff_char_t * CodeLineW = &CodeBuffW[LinePtr];
@@ -864,15 +869,16 @@
 		/* if cursor is on right half of a kanji, erase the kanji */
 		BuffSetChar(b - 1, ' ', 'H');
 		BuffSetChar(b, ' ', 'H');
-		AttrLine[CursorX] &= ~AttrKanji;
+		b->attr &= ~AttrKanji;
 		sx--;
 		extr++;
 	}
 
-	if (CursorRightM < NumOfColumns - 1 && (AttrLine[CursorRightM] & AttrKanji)) {
+	if (CursorRightM < NumOfColumns - 1 && (CodeLineW[CursorRightM].attr & AttrKanji)) {
 		CodeLine[CursorRightM + 1] = 0x20;
 		BuffSetChar(&CodeLineW[CursorRightM + 1], 0x20, 'H');
-		AttrLine[CursorRightM + 1] &= ~AttrKanji;
+//		AttrLine[CursorRightM + 1] &= ~AttrKanji;
+		CodeLineW[CursorRightM + 1].attr &= ~AttrKanji;
 		extr++;
 	}
 
@@ -884,23 +890,25 @@
 	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(&(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, CurCharAttr.Fore, CurCharAttr.Back, Count);
-	memset(&(AttrLine[CursorX]), AttrDefault, Count);
-	memset(&(AttrLine2[CursorX]), CurCharAttr.Attr2 & Attr2ColorMask, Count);
+	memsetW(&(CodeLineW[CursorX]), 0x20, CurCharAttr.Fore, CurCharAttr.Back, AttrDefault, CurCharAttr.Attr2, 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) {
+//	if ((AttrLine[CursorRightM] & AttrKanji) != 0) {
+	if ((CodeLineW[CursorRightM].attr & AttrKanji) != 0) {
 		/* then delete it */
 		CodeLine[CursorRightM] = 0x20;
 		BuffSetChar(&CodeLineW[CursorRightM], 0x20, 'H');
-		AttrLine[CursorRightM] &= ~AttrKanji;
+//		AttrLine[CursorRightM] &= ~AttrKanji;
+		CodeLineW[CursorRightM].attr &= ~AttrKanji;
 	}
 	BuffUpdateRect(sx, CursorY, CursorRightM + extr, CursorY);
 }
@@ -924,9 +932,9 @@
 	}
 	for (i = CursorY ; i <= YEnd ; i++) {
 		memset(&(CodeBuff[TmpPtr+offset]),0x20,NumOfColumns-offset);
-		memsetW(&(CodeBuffW[TmpPtr+offset]),0x20,CurCharAttr.Fore, CurCharAttr.Back, NumOfColumns-offset);
-		memset(&(AttrBuff[TmpPtr+offset]),AttrDefault,NumOfColumns-offset);
-		memset(&(AttrBuff2[TmpPtr+offset]),CurCharAttr.Attr2 & Attr2ColorMask, NumOfColumns-offset);
+		memsetW(&(CodeBuffW[TmpPtr+offset]),0x20,CurCharAttr.Fore, CurCharAttr.Back, AttrDefault, CurCharAttr.Attr2 & Attr2ColorMask, NumOfColumns-offset);
+//		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;
@@ -960,9 +968,9 @@
 			offset = CursorX+1;
 		}
 		memset(&(CodeBuff[TmpPtr]),0x20,offset);
-		memsetW(&(CodeBuffW[TmpPtr]),0x20, CurCharAttr.Fore, CurCharAttr.Back, offset);
-		memset(&(AttrBuff[TmpPtr]),AttrDefault,offset);
-		memset(&(AttrBuff2[TmpPtr]),CurCharAttr.Attr2 & Attr2ColorMask, offset);
+		memsetW(&(CodeBuffW[TmpPtr]),0x20, CurCharAttr.Fore, CurCharAttr.Back, AttrDefault, CurCharAttr.Attr2 & Attr2ColorMask, offset);
+//		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);
@@ -996,8 +1004,8 @@
 	for (i= YEnd-Count ; i>=CursorY ; i--) {
 		memcpy(&(CodeBuff[DestPtr]), &(CodeBuff[SrcPtr]), linelen);
 		memcpyW(&(CodeBuffW[DestPtr]), &(CodeBuffW[SrcPtr]), linelen);
-		memcpy(&(AttrBuff[DestPtr]), &(AttrBuff[SrcPtr]), linelen);
-		memcpy(&(AttrBuff2[DestPtr]), &(AttrBuff2[SrcPtr]), linelen);
+//		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);
@@ -1005,9 +1013,9 @@
 	}
 	for (i = 1 ; i <= Count ; i++) {
 		memset(&(CodeBuff[DestPtr]), 0x20, linelen);
-		memsetW(&(CodeBuffW[DestPtr]), 0x20, CurCharAttr.Fore, CurCharAttr.Back, linelen);
-		memset(&(AttrBuff[DestPtr]), AttrDefault, linelen);
-		memset(&(AttrBuff2[DestPtr]), CurCharAttr.Attr2 & Attr2ColorMask, linelen);
+		memsetW(&(CodeBuffW[DestPtr]), 0x20, CurCharAttr.Fore, CurCharAttr.Back, AttrDefault, CurCharAttr.Attr2 & Attr2ColorMask, linelen);
+//		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);
@@ -1025,8 +1033,8 @@
 {
 #if !ATR
 	PCHAR CodeLine = &CodeBuff[LinePtr];
-	PCHAR AttrLine = &AttrBuff[LinePtr];
-	PCHAR AttrLine2 = &AttrBuff2[LinePtr];
+//	PCHAR AttrLine = &AttrBuff[LinePtr];
+//	PCHAR AttrLine2 = &AttrBuff2[LinePtr];
 //	PCHAR AttrLineFG = &AttrBuffFG[LinePtr];
 //	PCHAR AttrLineBG = &AttrBuffBG[LinePtr];
 	buff_char_t * CodeLineW = &CodeBuffW[LinePtr];
@@ -1033,7 +1041,8 @@
 #endif
 	BOOL LineContinued=FALSE;
 
-	if (ts.EnableContinuedLineCopy && XStart == 0 && (AttrLine[0] & AttrLineContinued)) {
+//	if (ts.EnableContinuedLineCopy && XStart == 0 && (AttrLine[0] & AttrLineContinued)) {
+	if (ts.EnableContinuedLineCopy && XStart == 0 && (CodeLineW[0].attr & AttrLineContinued)) {
 		LineContinued = TRUE;
 	}
 
@@ -1043,9 +1052,9 @@
 
 	NewLine(PageStart+CursorY);
 	memset(&(CodeLine[XStart]),0x20,Count);
-	memsetW(&(CodeLineW[XStart]),0x20, CurCharAttr.Fore, CurCharAttr.Back, Count);
-	memset(&(AttrLine[XStart]),AttrDefault,Count);
-	memset(&(AttrLine2[XStart]),CurCharAttr.Attr2 & Attr2ColorMask, Count);
+	memsetW(&(CodeLineW[XStart]),0x20, CurCharAttr.Fore, CurCharAttr.Back, AttrDefault, CurCharAttr.Attr2 & Attr2ColorMask, Count);
+//	memset(&(AttrLine[XStart]),AttrDefault,Count);
+//	memset(&(AttrLine2[XStart]),CurCharAttr.Attr2 & Attr2ColorMask, Count);
 //	memset(&(AttrLineFG[XStart]),CurCharAttr.Fore,Count);
 //	memset(&(AttrLineBG[XStart]),CurCharAttr.Back,Count);
 
@@ -1055,7 +1064,8 @@
 		}
 
 		if (XStart + Count >= NumOfColumns) {
-			AttrBuff[NextLinePtr(LinePtr)] &= ~AttrLineContinued;
+//			AttrBuff[NextLinePtr(LinePtr)] &= ~AttrLineContinued;
+			CodeBuffW[NextLinePtr(LinePtr)].attr &= ~AttrLineContinued;
 		}
 	}
 
@@ -1086,8 +1096,8 @@
 	for (i=CursorY ; i<= YEnd-Count ; i++) {
 		memcpy(&(CodeBuff[DestPtr]), &(CodeBuff[SrcPtr]), linelen);
 		memcpyW(&(CodeBuffW[DestPtr]), &(CodeBuffW[SrcPtr]), linelen);
-		memcpy(&(AttrBuff[DestPtr]), &(AttrBuff[SrcPtr]), linelen);
-		memcpy(&(AttrBuff2[DestPtr]), &(AttrBuff2[SrcPtr]), linelen);
+//		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);
@@ -1095,9 +1105,9 @@
 	}
 	for (i = YEnd+1-Count ; i<=YEnd ; i++) {
 		memset(&(CodeBuff[DestPtr]), 0x20, linelen);
-		memsetW(&(CodeBuffW[DestPtr]), 0x20, CurCharAttr.Fore, CurCharAttr.Back, linelen);
-		memset(&(AttrBuff[DestPtr]), AttrDefault, linelen);
-		memset(&(AttrBuff2[DestPtr]), CurCharAttr.Attr2 & Attr2ColorMask,  linelen);
+		memsetW(&(CodeBuffW[DestPtr]), 0x20, CurCharAttr.Fore, CurCharAttr.Back, AttrDefault, CurCharAttr.Attr2 & Attr2ColorMask, linelen);
+//		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);
@@ -1114,8 +1124,8 @@
 {
 #if !ATR
 	PCHAR CodeLine = &CodeBuff[LinePtr];
-	PCHAR AttrLine = &AttrBuff[LinePtr];
-	PCHAR AttrLine2 = &AttrBuff2[LinePtr];
+//	PCHAR AttrLine = &AttrBuff[LinePtr];
+//	PCHAR AttrLine2 = &AttrBuff2[LinePtr];
 //	PCHAR AttrLineFG = &AttrBuffFG[LinePtr];
 //	PCHAR AttrLineBG = &AttrBuffBG[LinePtr];
 	buff_char_t * CodeLineW = &CodeBuffW[LinePtr];
@@ -1153,13 +1163,16 @@
 		}
 	}
 
-	if (CursorRightM < NumOfColumns - 1 && (AttrLine[CursorRightM] & AttrKanji)) {
+//	if (CursorRightM < NumOfColumns - 1 && (AttrLine[CursorRightM] & AttrKanji)) {
+	if (CursorRightM < NumOfColumns - 1 && (CodeLineW[CursorRightM].attr & AttrKanji)) {
 		CodeLine[CursorRightM] = 0x20;
 		BuffSetChar(&CodeLineW[CursorRightM], 0x20, 'H');
-		AttrLine[CursorRightM] &= ~AttrKanji;
+//		AttrLine[CursorRightM] &= ~AttrKanji;
+		CodeLineW[CursorRightM].attr &= ~AttrKanji;
 		CodeLine[CursorRightM + 1] = 0x20;
 		BuffSetChar(&CodeLineW[CursorRightM + 1], 0x20, 'H');
-		AttrLine[CursorRightM + 1] &= ~AttrKanji;
+//		AttrLine[CursorRightM + 1] &= ~AttrKanji;
+		CodeLineW[CursorRightM + 1].attr &= ~AttrKanji;
 		extr = 1;
 	}
 
@@ -1168,15 +1181,15 @@
 	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(&(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]), ' ', CurCharAttr.Fore, CurCharAttr.Back, Count);
-	memset(&(AttrLine[CursorX + MoveLen]), AttrDefault, Count);
-	memset(&(AttrLine2[CursorX + MoveLen]), CurCharAttr.Attr2 & Attr2ColorMask, Count);
+	memsetW(&(CodeLineW[CursorX + MoveLen]), ' ', CurCharAttr.Fore, CurCharAttr.Back, AttrDefault, CurCharAttr.Attr2 & Attr2ColorMask, 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);
 
@@ -1189,8 +1202,8 @@
 {
 #if !ATR
 	PCHAR CodeLine = &CodeBuff[LinePtr];
-	PCHAR AttrLine = &AttrBuff[LinePtr];
-	PCHAR AttrLine2 = &AttrBuff2[LinePtr];
+//	PCHAR AttrLine = &AttrBuff[LinePtr];
+//	PCHAR AttrLine2 = &AttrBuff2[LinePtr];
 //	PCHAR AttrLineFG = &AttrBuffFG[LinePtr];
 //	PCHAR AttrLineBG = &AttrBuffBG[LinePtr];
 	buff_char_t * CodeLineW = &CodeBuffW[LinePtr];
@@ -1231,9 +1244,9 @@
 	}
 
 	memset(&(CodeLine[CursorX]), 0x20, Count);
-	memsetW(&(CodeLineW[CursorX]), 0x20, CurCharAttr.Fore, CurCharAttr.Back, Count);
-	memset(&(AttrLine[CursorX]), AttrDefault, Count);
-	memset(&(AttrLine2[CursorX]), CurCharAttr.Attr2 & Attr2ColorMask, Count);
+	memsetW(&(CodeLineW[CursorX]), 0x20, CurCharAttr.Fore, CurCharAttr.Back, AttrDefault, CurCharAttr.Attr2 & Attr2ColorMask, 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);
 
@@ -1250,9 +1263,9 @@
 	TmpPtr = GetLinePtr(PageStart);
 	for (i = 0 ; i <= NumOfLines-1-StatusLine ; i++) {
 		memset(&(CodeBuff[TmpPtr]),'E',NumOfColumns);
-		memsetW(&(CodeBuffW[TmpPtr]),'E', AttrDefaultFG, AttrDefaultBG, NumOfColumns);
-		memset(&(AttrBuff[TmpPtr]),AttrDefault,NumOfColumns);
-		memset(&(AttrBuff2[TmpPtr]),AttrDefault,NumOfColumns);
+		memsetW(&(CodeBuffW[TmpPtr]),'E', AttrDefaultFG, AttrDefaultBG, AttrDefault, AttrDefault, NumOfColumns);
+//		memset(&(AttrBuff[TmpPtr]),AttrDefault,NumOfColumns);
+//		memset(&(AttrBuff2[TmpPtr]),AttrDefault,NumOfColumns);
 //		memset(&(AttrBuffFG[TmpPtr]),AttrDefaultFG,NumOfColumns);
 //		memset(&(AttrBuffBG[TmpPtr]),AttrDefaultBG,NumOfColumns);
 		TmpPtr = NextLinePtr(TmpPtr);
@@ -1290,9 +1303,9 @@
 			}
 			Ptr = GetLinePtr(PageStart+Y);
 			memset(&(CodeBuff[Ptr+CursorX]),'q',C);
-			memsetW(&(CodeBuffW[Ptr+CursorX]),'q', Attr.Fore, Attr.Back, C);
-			memset(&(AttrBuff[Ptr+CursorX]),Attr.Attr,C);
-			memset(&(AttrBuff2[Ptr+CursorX]),Attr.Attr2,C);
+			memsetW(&(CodeBuffW[Ptr+CursorX]),'q', Attr.Fore, Attr.Back, Attr.Attr, Attr.Attr2, C);
+//			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);
@@ -1319,9 +1332,9 @@
 			}
 			for (i=1; i<=C; i++) {
 				CodeBuff[Ptr+X] = 'x';
-				BuffSetChar3(&CodeBuffW[Ptr+X], 0x20, Attr.Fore, Attr.Back, 'H');
-				AttrBuff[Ptr+X] = Attr.Attr;
-				AttrBuff2[Ptr+X] = Attr.Attr2;
+				BuffSetChar4(&CodeBuffW[Ptr+X], 0x20, Attr.Fore, Attr.Back, Attr.Attr, Attr.Attr2, 'H');
+//				AttrBuff[Ptr+X] = Attr.Attr;
+//				AttrBuff2[Ptr+X] = Attr.Attr2;
 //				AttrBuffFG[Ptr+X] = Attr.Fore;
 //				AttrBuffBG[Ptr+X] = Attr.Back;
 				Ptr = NextLinePtr(Ptr);
@@ -1331,8 +1344,7 @@
 	}
 }
 
-void BuffEraseBox
-  (int XStart, int YStart, int XEnd, int YEnd)
+void BuffEraseBox(int XStart, int YStart, int XEnd, int YEnd)
 {
 	int C, i;
 	LONG Ptr;
@@ -1353,27 +1365,27 @@
 	Ptr = GetLinePtr(PageStart+YStart);
 	for (i=YStart; i<=YEnd; i++) {
 		if ((XStart>0) &&
-		    ((AttrBuff[Ptr+XStart-1] & AttrKanji) != 0)) {
+		    ((CodeBuffW[Ptr+XStart-1].attr & AttrKanji) != 0)) {
 			CodeBuff[Ptr+XStart-1] = 0x20;
-			BuffSetChar3(&CodeBuffW[Ptr+XStart-1], 0x20, CurCharAttr.Fore, CurCharAttr.Back, 'H');
-			AttrBuff[Ptr+XStart-1] = CurCharAttr.Attr;
-			AttrBuff2[Ptr+XStart-1] = CurCharAttr.Attr2;
+			BuffSetChar4(&CodeBuffW[Ptr+XStart-1], 0x20, CurCharAttr.Fore, CurCharAttr.Back, CurCharAttr.Attr, CurCharAttr.Attr2, 'H');
+//			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)) {
+		    ((CodeBuffW[Ptr+XStart+C-1].attr & AttrKanji) != 0)) {
 			CodeBuff[Ptr+XStart+C] = 0x20;
-			BuffSetChar3(&CodeBuffW[Ptr+XStart+C], 0x20, CurCharAttr.Fore, CurCharAttr.Back, 'H');
-			AttrBuff[Ptr+XStart+C] = CurCharAttr.Attr;
-			AttrBuff2[Ptr+XStart+C] = CurCharAttr.Attr2;
+			BuffSetChar4(&CodeBuffW[Ptr+XStart+C], 0x20, CurCharAttr.Fore, CurCharAttr.Back, CurCharAttr.Attr, CurCharAttr.Attr2, 'H');
+//			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);
-		memsetW(&(CodeBuffW[Ptr+XStart]),0x20, CurCharAttr.Fore, CurCharAttr.Back, C);
-		memset(&(AttrBuff[Ptr+XStart]),AttrDefault,C);
-		memset(&(AttrBuff2[Ptr+XStart]),CurCharAttr.Attr2 & Attr2ColorMask, C);
+		memsetW(&(CodeBuffW[Ptr+XStart]),0x20, CurCharAttr.Fore, CurCharAttr.Back, AttrDefault, CurCharAttr.Attr2 & Attr2ColorMask, C);
+//		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);
@@ -1402,20 +1414,20 @@
 	Ptr = GetLinePtr(PageStart+YStart);
 	for (i=YStart; i<=YEnd; i++) {
 		if ((XStart>0) &&
-		    ((AttrBuff[Ptr+XStart-1] & AttrKanji) != 0)) {
+		    ((CodeBuffW[Ptr+XStart-1].attr & AttrKanji) != 0)) {
 			CodeBuff[Ptr+XStart-1] = 0x20;
 			BuffSetChar(&CodeBuffW[Ptr + XStart - 1], 0x20, 'H');
-			AttrBuff[Ptr+XStart-1] ^= AttrKanji;
+			CodeBuffW[Ptr+XStart-1].attr ^= AttrKanji;
 		}
 		if ((XStart+Cols<NumOfColumns) &&
-		    ((AttrBuff[Ptr+XStart+Cols-1] & AttrKanji) != 0)) {
+		    ((CodeBuffW[Ptr+XStart+Cols-1].attr & AttrKanji) != 0)) {
 			CodeBuff[Ptr+XStart+Cols] = 0x20;
 			BuffSetChar(&CodeBuffW[Ptr + XStart + Cols], 0x20, 'H');
 		}
 		memset(&(CodeBuff[Ptr+XStart]), ch, Cols);
-		memsetW(&(CodeBuffW[Ptr+XStart]), ch, CurCharAttr.Fore, CurCharAttr.Back, Cols);
-		memset(&(AttrBuff[Ptr+XStart]), CurCharAttr.Attr, Cols);
-		memset(&(AttrBuff2[Ptr+XStart]), CurCharAttr.Attr2, Cols);
+		memsetW(&(CodeBuffW[Ptr+XStart]), ch, CurCharAttr.Fore, CurCharAttr.Back, CurCharAttr.Attr, CurCharAttr.Attr2, Cols);
+//		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);
@@ -1470,8 +1482,8 @@
 		for (i=0; i<L; i++) {
 			memcpy(&(CodeBuff[DPtr+DstX]), &(CodeBuff[SPtr+SrcXStart]), C);
 			memcpyW(&(CodeBuffW[DPtr+DstX]), &(CodeBuffW[SPtr+SrcXStart]), C);
-			memcpy(&(AttrBuff[DPtr+DstX]), &(AttrBuff[SPtr+SrcXStart]), C);
-			memcpy(&(AttrBuff2[DPtr+DstX]), &(AttrBuff2[SPtr+SrcXStart]), C);
+//			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);
@@ -1484,8 +1496,8 @@
 		for (i=L; i>0; i--) {
 			memcpy(&(CodeBuff[DPtr+DstX]), &(CodeBuff[SPtr+SrcXStart]), C);
 			memcpyW(&(CodeBuffW[DPtr+DstX]), &(CodeBuffW[SPtr+SrcXStart]), C);
-			memcpy(&(AttrBuff[DPtr+DstX]), &(AttrBuff[SPtr+SrcXStart]), C);
-			memcpy(&(AttrBuff2[DPtr+DstX]), &(AttrBuff2[SPtr+SrcXStart]), C);
+//			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);
@@ -1498,8 +1510,8 @@
 		for (i=0; i<L; i++) {
 			memmove(&(CodeBuff[DPtr+DstX]), &(CodeBuff[SPtr+SrcXStart]), C);
 			memmoveW(&(CodeBuffW[DPtr+DstX]), &(CodeBuffW[SPtr+SrcXStart]), C);
-			memmove(&(AttrBuff[DPtr+DstX]), &(AttrBuff[SPtr+SrcXStart]), C);
-			memmove(&(AttrBuff2[DPtr+DstX]), &(AttrBuff2[SPtr+SrcXStart]), C);
+//			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);
@@ -1529,9 +1541,9 @@
 	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 (XStart>0 && (CodeBuffW[j].attr & AttrKanji)) {
+				CodeBuffW[j].attr = (CodeBuffW[j].attr & ~mask->Attr) | attr->Attr;
+				CodeBuffW[j].attr2 = (CodeBuffW[j].attr2 & ~mask->Attr2) | attr->Attr2;
 //				if (mask->Attr2 & Attr2Fore) { AttrBuffFG[j] = attr->Fore; }
 //				if (mask->Attr2 & Attr2Back) { AttrBuffBG[j] = attr->Back; }
 				if (mask->Attr2 & Attr2Fore) { CodeBuffW[j].fg = attr->Fore; }
@@ -1538,16 +1550,16 @@
 				if (mask->Attr2 & Attr2Back) { CodeBuffW[j].bg = attr->Back; }
 			}
 			while (++j < Ptr+XStart+C) {
-				AttrBuff[j] = AttrBuff[j] & ~mask->Attr | attr->Attr;
-				AttrBuff2[j] = AttrBuff2[j] & ~mask->Attr2 | attr->Attr2;
+				CodeBuffW[j].attr = (CodeBuffW[j].attr & ~mask->Attr) | attr->Attr;
+				CodeBuffW[j].attr2 = (CodeBuffW[j].attr2 & ~mask->Attr2) | attr->Attr2;
 //				if (mask->Attr2 & Attr2Fore) { AttrBuffFG[j] = attr->Fore; }
 //				if (mask->Attr2 & Attr2Back) { AttrBuffBG[j] = attr->Back; }
 				if (mask->Attr2 & Attr2Fore) { CodeBuffW[j].fg = attr->Fore; }
 				if (mask->Attr2 & Attr2Back) { CodeBuffW[j].bg = 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 (XStart+C<NumOfColumns && (CodeBuffW[j-1].attr & AttrKanji)) {
+				CodeBuffW[j].attr = (CodeBuffW[j].attr & ~mask->Attr) | attr->Attr;
+				CodeBuffW[j].attr2 = (CodeBuffW[j].attr2 & ~mask->Attr2) | attr->Attr2;
 //				if (mask->Attr2 & Attr2Fore) { AttrBuffFG[j] = attr->Fore; }
 //				if (mask->Attr2 & Attr2Back) { AttrBuffBG[j] = attr->Back; }
 				if (mask->Attr2 & Attr2Fore) { CodeBuffW[j].fg = attr->Fore; }
@@ -1559,14 +1571,14 @@
 	else { // DECRARA
 		for (i=YStart; i<=YEnd; i++) {
 			j = Ptr+XStart-1;
-			if (XStart>0 && (AttrBuff[j] & AttrKanji)) {
-				AttrBuff[j] ^= attr->Attr;
+			if (XStart>0 && (CodeBuffW[j].attr & AttrKanji)) {
+				CodeBuffW[j].attr ^= attr->Attr;
 			}
 			while (++j < Ptr+XStart+C) {
-				AttrBuff[j] ^= attr->Attr;
+				CodeBuffW[j].attr ^= attr->Attr;
 			}
-			if (XStart+C<NumOfColumns && (AttrBuff[j-1] & AttrKanji)) {
-				AttrBuff[j] ^= attr->Attr;
+			if (XStart+C<NumOfColumns && (CodeBuffW[j-1].attr & AttrKanji)) {
+				CodeBuffW[j].attr ^= attr->Attr;
 			}
 			Ptr = NextLinePtr(Ptr);
 		}
@@ -1596,9 +1608,9 @@
 			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 (XStart > 0 && (CodeBuffW[i].attr & AttrKanji)) {
+				CodeBuffW[i].attr = CodeBuffW[i].attr & ~mask->Attr | attr->Attr;
+				CodeBuffW[i].attr2 = CodeBuffW[i].attr2 & ~mask->Attr2 | attr->Attr2;
 //				if (mask->Attr2 & Attr2Fore) { AttrBuffFG[i] = attr->Fore; }
 //				if (mask->Attr2 & Attr2Back) { AttrBuffBG[i] = attr->Back; }
 				if (mask->Attr2 & Attr2Fore) { CodeBuffW[i].fg = attr->Fore; }
@@ -1605,16 +1617,16 @@
 				if (mask->Attr2 & Attr2Back) { CodeBuffW[i].bg = attr->Back; }
 			}
 			while (++i < endp) {
-				AttrBuff[i] = AttrBuff[i] & ~mask->Attr | attr->Attr;
-				AttrBuff2[i] = AttrBuff2[i] & ~mask->Attr2 | attr->Attr2;
+				CodeBuffW[i].attr = CodeBuffW[i].attr & ~mask->Attr | attr->Attr;
+				CodeBuffW[i].attr2 = CodeBuffW[i].attr2 & ~mask->Attr2 | attr->Attr2;
 //				if (mask->Attr2 & Attr2Fore) { AttrBuffFG[i] = attr->Fore; }
 //				if (mask->Attr2 & Attr2Back) { AttrBuffBG[i] = attr->Back; }
 				if (mask->Attr2 & Attr2Fore) { CodeBuffW[i].fg = attr->Fore; }
 				if (mask->Attr2 & Attr2Back) { CodeBuffW[i].bg = 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 (XEnd < NumOfColumns-1 && (CodeBuffW[i-1].attr & AttrKanji)) {
+				CodeBuffW[i].attr = CodeBuffW[i].attr & ~mask->Attr | attr->Attr;
+				CodeBuffW[i].attr2 = CodeBuffW[i].attr2 & ~mask->Attr2 | attr->Attr2;
 //				if (mask->Attr2 & Attr2Fore) { AttrBuffFG[i] = attr->Fore; }
 //				if (mask->Attr2 & Attr2Back) { AttrBuffBG[i] = attr->Back; }
 				if (mask->Attr2 & Attr2Fore) { CodeBuffW[i].fg = attr->Fore; }
@@ -1625,9 +1637,9 @@
 			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 (XStart > 0 && (CodeBuffW[i].attr & AttrKanji)) {
+				CodeBuffW[i].attr = CodeBuffW[i].attr & ~mask->Attr | attr->Attr;
+				CodeBuffW[i].attr2 = CodeBuffW[i].attr2 & ~mask->Attr2 | attr->Attr2;
 //				if (mask->Attr2 & Attr2Fore) { AttrBuffFG[i] = attr->Fore; }
 //				if (mask->Attr2 & Attr2Back) { AttrBuffBG[i] = attr->Back; }
 				if (mask->Attr2 & Attr2Fore) { CodeBuffW[i].fg = attr->Fore; }
@@ -1634,8 +1646,8 @@
 				if (mask->Attr2 & Attr2Back) { CodeBuffW[i].bg = attr->Back; }
 			}
 			while (++i < endp) {
-				AttrBuff[i] = AttrBuff[i] & ~mask->Attr | attr->Attr;
-				AttrBuff2[i] = AttrBuff2[i] & ~mask->Attr2 | attr->Attr2;
+				CodeBuffW[i].attr = CodeBuffW[i].attr & ~mask->Attr | attr->Attr;
+				CodeBuffW[i].attr2 = CodeBuffW[i].attr2 & ~mask->Attr2 | attr->Attr2;
 //				if (mask->Attr2 & Attr2Fore) { AttrBuffFG[i] = attr->Fore; }
 //				if (mask->Attr2 & Attr2Back) { AttrBuffBG[i] = attr->Back; }
 				if (mask->Attr2 & Attr2Fore) { CodeBuffW[i].fg = attr->Fore; }
@@ -1648,8 +1660,8 @@
 				endp = Ptr + NumOfColumns;
 
 				while (i < endp) {
-					AttrBuff[i] = AttrBuff[i] & ~mask->Attr | attr->Attr;
-					AttrBuff2[i] = AttrBuff2[i] & ~mask->Attr2 | attr->Attr2;
+					CodeBuffW[i].attr = CodeBuffW[i].attr & ~mask->Attr | attr->Attr;
+					CodeBuffW[i].attr2 = CodeBuffW[i].attr2 & ~mask->Attr2 | attr->Attr2;
 //					if (mask->Attr2 & Attr2Fore) { AttrBuffFG[i] = attr->Fore; }
 //					if (mask->Attr2 & Attr2Back) { AttrBuffBG[i] = attr->Back; }
 					if (mask->Attr2 & Attr2Fore) { CodeBuffW[i].fg = attr->Fore; }
@@ -1663,8 +1675,8 @@
 			endp = Ptr + XEnd + 1;
 
 			while (i < endp) {
-				AttrBuff[i] = AttrBuff[i] & ~mask->Attr | attr->Attr;
-				AttrBuff2[i] = AttrBuff2[i] & ~mask->Attr2 | attr->Attr2;
+				CodeBuffW[i].attr = CodeBuffW[i].attr & ~mask->Attr | attr->Attr;
+				CodeBuffW[i].attr2 = CodeBuffW[i].attr2 & ~mask->Attr2 | attr->Attr2;
 //				if (mask->Attr2 & Attr2Fore) { AttrBuffFG[i] = attr->Fore; }
 //				if (mask->Attr2 & Attr2Back) { AttrBuffBG[i] = attr->Back; }
 				if (mask->Attr2 & Attr2Fore) { CodeBuffW[i].fg = attr->Fore; }
@@ -1671,9 +1683,9 @@
 				if (mask->Attr2 & Attr2Back) { CodeBuffW[i].bg = 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 (XEnd < NumOfColumns-1 && (CodeBuffW[i-1].attr & AttrKanji)) {
+				CodeBuffW[i].attr = CodeBuffW[i].attr & ~mask->Attr | attr->Attr;
+				CodeBuffW[i].attr2 = CodeBuffW[i].attr2 & ~mask->Attr2 | attr->Attr2;
 //				if (mask->Attr2 & Attr2Fore) { AttrBuffFG[i] = attr->Fore; }
 //				if (mask->Attr2 & Attr2Back) { AttrBuffBG[i] = attr->Back; }
 				if (mask->Attr2 & Attr2Fore) { CodeBuffW[i].fg = attr->Fore; }
@@ -1686,14 +1698,14 @@
 			i = Ptr + XStart - 1;
 			endp = Ptr + XEnd + 1;
 
-			if (XStart > 0 && (AttrBuff[i] & AttrKanji)) {
-				AttrBuff[i] ^= attr->Attr;
+			if (XStart > 0 && (CodeBuffW[i].attr & AttrKanji)) {
+				CodeBuffW[i].attr ^= attr->Attr;
 			}
 			while (++i < endp) {
-				AttrBuff[i] ^= attr->Attr;
+				CodeBuffW[i].attr ^= attr->Attr;
 			}
-			if (XEnd < NumOfColumns-1 && (AttrBuff[i-1] & AttrKanji)) {
-				AttrBuff[i] ^= attr->Attr;
+			if (XEnd < NumOfColumns-1 && (CodeBuffW[i-1].attr & AttrKanji)) {
+				CodeBuffW[i].attr ^= attr->Attr;
 			}
 		}
 		else {
@@ -1700,11 +1712,11 @@
 			i = Ptr + XStart - 1;
 			endp = Ptr + NumOfColumns;
 
-			if (XStart > 0 && (AttrBuff[i] & AttrKanji)) {
-				AttrBuff[i] ^= attr->Attr;
+			if (XStart > 0 && (CodeBuffW[i].attr & AttrKanji)) {
+				CodeBuffW[i].attr ^= attr->Attr;
 			}
 			while (++i < endp) {
-				AttrBuff[i] ^= attr->Attr;
+				CodeBuffW[i].attr ^= attr->Attr;
 			}
 
 			for (j=0; j < YEnd-YStart-1; j++) {
@@ -1713,7 +1725,7 @@
 				endp = Ptr + NumOfColumns;
 
 				while (i < endp) {
-					AttrBuff[i] ^= attr->Attr;
+					CodeBuffW[i].attr ^= attr->Attr;
 					i++;
 				}
 			}
@@ -1723,11 +1735,11 @@
 			endp = Ptr + XEnd + 1;
 
 			while (i < endp) {
-				AttrBuff[i] ^= attr->Attr;
+				CodeBuffW[i].attr ^= attr->Attr;
 				i++;
 			}
-			if (XEnd < NumOfColumns-1 && (AttrBuff[i-1] & AttrKanji)) {
-				AttrBuff[i] ^= attr->Attr;
+			if (XEnd < NumOfColumns-1 && (CodeBuffW[i-1].attr & AttrKanji)) {
+				CodeBuffW[i].attr ^= attr->Attr;
 			}
 			Ptr = NextLinePtr(Ptr);
 		}
@@ -1743,7 +1755,7 @@
 //   return: points to the left half of the DBCS
 {
 	if ((CharPtr>0) &&
-		((AttrBuff[Line+CharPtr-1] & AttrKanji) != 0)) {
+		((CodeBuffW[Line+CharPtr-1].attr & AttrKanji) != 0)) {
 		CharPtr--;
 	}
 	return CharPtr;
@@ -1768,7 +1780,7 @@
 	i = 0;
 	while (dx!=0) {
 		if (dx>0) { // move right
-			if ((AttrBuff[Line+*x] & AttrKanji) != 0) {
+			if ((CodeBuffW[Line+*x].attr & AttrKanji) != 0) {
 				if (*x<NumOfColumns-2) {
 					i++;
 					*x = *x + 2;
@@ -1842,7 +1854,7 @@
 			// \x8Ds\x91I\x91\xF0\x82̏ꍇ\x82̂\xDD
 			if (ts.EnableContinuedLineCopy && y!= ey ) {
 				LONG NextTmpPtr = NextLinePtr(TmpPtr);
-				if ((AttrBuff[NextTmpPtr] & AttrLineContinued) != 0) {
+				if ((CodeBuffW[NextTmpPtr].attr & AttrLineContinued) != 0) {
 					LineContinued = TRUE;
 				}
 			}
@@ -2035,7 +2047,7 @@
 		return FALSE;
 	}
 	while(x < 0) {
-		if (LineContinued && (AttrBuff[TmpPtr+0] & AttrLineContinued) == 0) {
+		if (LineContinued && (CodeBuffW[TmpPtr+0].attr & AttrLineContinued) == 0) {
 			// \x8Ds\x82\xAA\x8Cp\x91\xB1\x82\xB5\x82Ă\xA2\x82邩\x8Dl\x97\xB6 & \x8Cp\x91\xB1\x82\xB5\x82Ă\xA2\x82Ȃ\xA2
 			x = 0;	// \x8Ds\x93\xAA\x82\xA9\x82\xE7\x82Ƃ\xB7\x82\xE9
 			break;
@@ -2045,7 +2057,7 @@
 		y--;
 	}
 	while(x > NumOfColumns) {
-		if (LineContinued && (AttrBuff[TmpPtr+NumOfColumns-1] & AttrLineContinued) == 0) {
+		if (LineContinued && (CodeBuffW[TmpPtr+NumOfColumns-1].attr & AttrLineContinued) == 0) {
 			// \x8Ds\x82\xAA\x8Cp\x91\xB1\x82\xB5\x82Ă\xA2\x82邩\x8Dl\x97\xB6 & \x8Cp\x91\xB1\x82\xB5\x82Ă\xA2\x82Ȃ\xA2
 			x = 0;	// \x8Ds\x93\xAA\x82\xA9\x82\xE7\x82Ƃ\xB7\x82\xE9
 			break;
@@ -2072,7 +2084,7 @@
 		// \x8E\x9F\x82̕\xB6\x8E\x9A
 		x++;
 		if (x == NumOfColumns) {
-			if (LineContinued && (AttrBuff[TmpPtr+NumOfColumns-1] & AttrLineContinued) != 0) {
+			if (LineContinued && (CodeBuffW[TmpPtr+NumOfColumns-1].attr & AttrLineContinued) != 0) {
 				// \x8E\x9F\x82̍s\x82\xD6
 				x = 0;
 				TmpPtr = NextLinePtr(TmpPtr);
@@ -2259,15 +2271,15 @@
 
 		while ((IEnd>=IStart) &&
 		       (CodeBuff[TmpPtr+IEnd]==0x20) &&
-		       (AttrBuff[TmpPtr+IEnd]==AttrDefault) &&
-		       (AttrBuff2[TmpPtr+IEnd]==AttrDefault)) {
+		       (CodeBuffW[TmpPtr+IEnd].attr==AttrDefault) &&
+		       (CodeBuffW[TmpPtr+IEnd].attr2==AttrDefault)) {
 			IEnd--;
 		}
 
 		i = IStart;
 		while (i <= IEnd) {
-			CurAttr.Attr = AttrBuff[TmpPtr+i] & ~ AttrKanji;
-			CurAttr.Attr2 = AttrBuff2[TmpPtr+i];
+			CurAttr.Attr = CodeBuffW[TmpPtr+i].attr & ~ AttrKanji;
+			CurAttr.Attr2 = CodeBuffW[TmpPtr+i].attr2;
 //			CurAttr.Fore = AttrBuffFG[TmpPtr+i];
 //			CurAttr.Back = AttrBuffBG[TmpPtr+i];
 			CurAttr.Fore = CodeBuffW[TmpPtr+i].fg;
@@ -2275,14 +2287,14 @@
 
 			count = 1;
 			while ((i+count <= IEnd) &&
-			       (CurAttr.Attr == (AttrBuff[TmpPtr+i+count] & ~ AttrKanji)) &&
-			       (CurAttr.Attr2 == AttrBuff2[TmpPtr+i+count]) &&
+			       (CurAttr.Attr == (CodeBuffW[TmpPtr+i+count].attr & ~ AttrKanji)) &&
+			       (CurAttr.Attr2 == CodeBuffW[TmpPtr+i+count].attr2) &&
 //			       (CurAttr.Fore == AttrBuffFG[TmpPtr+i+count]) &&
 //			       (CurAttr.Back == AttrBuffBG[TmpPtr+i+count]) ||
 				   (CurAttr.Fore == CodeBuffW[TmpPtr+i].fg) &&
 				   (CurAttr.Back == CodeBuffW[TmpPtr+i].bg) ||
 			       (i+count<NumOfColumns) &&
-			       ((AttrBuff[TmpPtr+i+count-1] & AttrKanji) != 0)) {
+			       ((CodeBuffW[TmpPtr+i+count-1].attr & AttrKanji) != 0)) {
 				count++;
 			}
 
@@ -2355,14 +2367,16 @@
 static void markURL(int x)
 {
 #if !ATR
+	buff_char_t *CodeLineW = &CodeBuffW[LinePtr];
 	PCHAR CodeLine = &CodeBuff[LinePtr];
-	PCHAR AttrLine = &AttrBuff[LinePtr];
+//	PCHAR AttrLine = &AttrBuff[LinePtr];
 //	PCHAR AttrLine2 = &AttrBuff2[LinePtr];
 //	PCHAR AttrLineFG = &AttrBuffFG[LinePtr];
 //	PCHAR AttrLineBG = &AttrBuffBG[LinePtr];
 #endif
 	LONG PrevCharPtr;
-	CHAR PrevCharAttr, PrevCharCode;
+//	CHAR PrevCharAttr;
+	CHAR PrevCharCode;
 
 	// RFC3986(Uniform Resource Identifier (URI): Generic Syntax)\x82ɏ\x80\x8B\x92\x82\xB7\x82\xE9
 	// by sakura editor 1.5.2.1: etc_uty.cpp
@@ -2399,22 +2413,24 @@
 
 	// \x92\xBC\x91O\x82̍s\x82\xA9\x82\xE7\x98A\x8C\x8B\x82\xB5\x82Ă\xA2\x82邩\x81B
 	if (x == 0) {
+		buff_char_t *PrevCodeBufW;
 		PrevCharPtr = PrevLinePtr(LinePtr) + NumOfColumns-1;
 		PrevCharCode = CodeBuff[PrevCharPtr];
-		PrevCharAttr = AttrBuff[PrevCharPtr];
-		if ((PrevCharAttr & AttrURL) && !(AttrLine[0]&(AttrKanji|AttrSpecial)) && !(ch & 0x80) && url_char[ch]) {
-			if ((AttrLine[0] & AttrLineContinued) || (ts.JoinSplitURL &&
+		//PrevCharAttr = AttrBuff[PrevCharPtr];
+		PrevCodeBufW = &CodeBuffW[PrevCharPtr];
+		if ((PrevCodeBufW[0].attr & AttrURL) && !(PrevCodeBufW[0].attr&(AttrKanji|AttrSpecial)) && !(ch & 0x80) && url_char[ch]) {
+			if ((CodeLineW[0].attr & AttrLineContinued) || (ts.JoinSplitURL &&
 			    (PrevCharCode == ts.JoinSplitURLIgnoreEOLChar || ts.JoinSplitURLIgnoreEOLChar == '\0' ))) {
-				AttrLine[0] |= AttrURL;
+				CodeLineW[0].attr |= AttrURL;
 			}
 		}
 		return;
 	}
 
-	if ((x-1>=0) && (AttrLine[x-1] & AttrURL) &&
-	  !(AttrLine[x] & (AttrKanji|AttrSpecial)) &&
+	if ((x-1>=0) && (CodeLineW[x-1].attr & AttrURL) &&
+	  !(CodeLineW[x].attr & (AttrKanji|AttrSpecial)) &&
 	  ((!(ch & 0x80) && url_char[ch]) || (x == NumOfColumns - 1 && ch == ts.JoinSplitURLIgnoreEOLChar))) {
-		AttrLine[x] |= AttrURL;
+		CodeLineW[x].attr |= AttrURL;
 		return;
 	}
 
@@ -2428,7 +2444,7 @@
 			if ((x-len>=0) && !strncmp(&CodeLine[x-len], *p, len)) {
 				size_t i;
 				for (i = 0; i <= len; i++) {
-					AttrLine[x-i] |= AttrURL;
+					CodeLineW[x-i].attr |= AttrURL;
 				}
 				break;
 			}
@@ -2459,8 +2475,8 @@
 {
 #if !ATR
 	PCHAR CodeLine = &CodeBuff[LinePtr];
-	PCHAR AttrLine = &AttrBuff[LinePtr];
-	PCHAR AttrLine2 = &AttrBuff2[LinePtr];
+//	PCHAR AttrLine = &AttrBuff[LinePtr];
+//	PCHAR AttrLine2 = &AttrBuff2[LinePtr];
 //	PCHAR AttrLineFG = &AttrBuffFG[LinePtr];
 //	PCHAR AttrLineBG = &AttrBuffBG[LinePtr];
 	buff_char_t * CodeLineW = &CodeBuffW[LinePtr];
@@ -2468,7 +2484,7 @@
 	int XStart, LineEnd, MoveLen;
 	int extr = 0;
 
-	if (ts.EnableContinuedLineCopy && CursorX == 0 && (AttrLine[0] & AttrLineContinued)) {
+	if (ts.EnableContinuedLineCopy && CursorX == 0 && (CodeLineW[0].attr & AttrLineContinued)) {
 		Attr.Attr |= AttrLineContinued;
 	}
 
@@ -2480,11 +2496,11 @@
 		else
 			LineEnd = CursorRightM;
 
-		if (LineEnd < NumOfColumns - 1 && (AttrLine[LineEnd] & AttrKanji)) {
+		if (LineEnd < NumOfColumns - 1 && (CodeLineW[LineEnd].attr & AttrKanji)) {
 			CodeLine[LineEnd] = 0x20;
-			AttrLine[LineEnd] &= ~AttrKanji;
+			CodeLineW[LineEnd].attr &= ~AttrKanji;
 			CodeLine[LineEnd+1] = 0x20;
-			AttrLine[LineEnd+1] &= ~AttrKanji;
+			CodeLineW[LineEnd+1].attr &= ~AttrKanji;
 			extr = 1;
 		}
 
@@ -2491,8 +2507,8 @@
 		MoveLen = LineEnd - CursorX - 1;
 		if (MoveLen > 0) {
 			memmove(&CodeLine[CursorX+2], &CodeLine[CursorX], MoveLen);
-			memmove(&AttrLine[CursorX+2], &AttrLine[CursorX], MoveLen);
-			memmove(&AttrLine2[CursorX+2], &AttrLine2[CursorX], MoveLen);
+//			memmove(&AttrLine[CursorX+2], &AttrLine[CursorX], MoveLen);
+//			memmove(&AttrLine2[CursorX+2], &AttrLine2[CursorX], MoveLen);
 //			memmove(&AttrLineFG[CursorX+2], &AttrLineFG[CursorX], MoveLen);
 //			memmove(&AttrLineBG[CursorX+2], &AttrLineBG[CursorX], MoveLen);
 			memmoveW(&CodeLineW[CursorX+2], &CodeLineW[CursorX], MoveLen);
@@ -2499,8 +2515,8 @@
 		}
 
 		CodeLine[CursorX] = HIBYTE(w);
-		AttrLine[CursorX] = Attr.Attr | AttrKanji; /* DBCS first byte */
-		AttrLine2[CursorX] = Attr.Attr2;
+		CodeLineW[CursorX].attr = Attr.Attr | AttrKanji; /* DBCS first byte */
+		CodeLineW[CursorX].attr2 = Attr.Attr2;
 //		AttrLineFG[CursorX] = Attr.Fore;
 //		AttrLineBG[CursorX] = Attr.Back;
 		CodeLineW[CursorX].fg = Attr.Fore;
@@ -2507,8 +2523,8 @@
 		CodeLineW[CursorX].bg = Attr.Back;
 		if (CursorX < LineEnd) {
 			CodeLine[CursorX+1] = LOBYTE(w);
-			AttrLine[CursorX+1] = Attr.Attr;
-			AttrLine2[CursorX+1] = Attr.Attr2;
+			CodeLineW[CursorX+1].attr = Attr.Attr;
+			CodeLineW[CursorX+1].attr2 = Attr.Attr2;
 //			AttrLineFG[CursorX+1] = Attr.Fore;
 //			AttrLineBG[CursorX+1] = Attr.Back;
 			CodeLineW[CursorX+1].fg = Attr.Fore;
@@ -2520,11 +2536,11 @@
 		/* end - ishizaki */
 
 		/* last char in current line is kanji first? */
-		if ((AttrLine[LineEnd] & AttrKanji) != 0) {
+		if ((CodeLineW[LineEnd].attr & AttrKanji) != 0) {
 			/* then delete it */
 			CodeLine[LineEnd] = 0x20;
-			AttrLine[LineEnd] = CurCharAttr.Attr;
-			AttrLine2[LineEnd] = CurCharAttr.Attr2;
+			CodeLineW[LineEnd].attr = CurCharAttr.Attr;
+			CodeLineW[LineEnd].attr2 = CurCharAttr.Attr2;
 //			AttrLineFG[LineEnd] = CurCharAttr.Fore;
 //			AttrLineBG[LineEnd] = CurCharAttr.Back;
 			CodeLineW[LineEnd].fg = Attr.Fore;
@@ -2542,8 +2558,8 @@
 	}
 	else {
 		CodeLine[CursorX] = HIBYTE(w);
-		AttrLine[CursorX] = Attr.Attr | AttrKanji; /* DBCS first byte */
-		AttrLine2[CursorX] = Attr.Attr2;
+		CodeLineW[CursorX].attr = Attr.Attr | AttrKanji; /* DBCS first byte */
+		CodeLineW[CursorX].attr2 = Attr.Attr2;
 //		AttrLineFG[CursorX] = Attr.Fore;
 //		AttrLineBG[CursorX] = Attr.Back;
 		CodeLineW[CursorX].fg = Attr.Fore;
@@ -2550,8 +2566,8 @@
 		CodeLineW[CursorX].bg = Attr.Back;
 		if (CursorX < NumOfColumns-1) {
 			CodeLine[CursorX+1] = LOBYTE(w);
-			AttrLine[CursorX+1] = Attr.Attr;
-			AttrLine2[CursorX+1] = Attr.Attr2;
+			CodeLineW[CursorX+1].attr = Attr.Attr;
+			CodeLineW[CursorX+1].attr2 = Attr.Attr2;
 //			AttrLineFG[CursorX+1] = Attr.Fore;
 //			AttrLineBG[CursorX+1] = Attr.Back;
 			CodeLineW[CursorX+1].fg = Attr.Fore;
@@ -2622,7 +2638,7 @@
 			int sy = p / NumOfColumns;
 			int sx = p % NumOfColumns;
 			int ptr = GetLinePtr(PageStart + sy) + sx;
-			if ((AttrBuff[ptr] & AttrURL) == 0) {
+			if ((CodeBuffW[ptr].attr & AttrURL) == 0) {
 				break;
 			}
 			p--;
@@ -2696,7 +2712,7 @@
 				return TRUE;
 			}
 			rx = x;
-			AttrBuff[TmpPtr + x] |= AttrURL;
+			CodeBuffW[TmpPtr + x].attr |= AttrURL;
 		}
 	}
 	*sx_match_e = rx;
@@ -2718,7 +2734,7 @@
 	sx = 0;
 	sy = cur_y;
 	TmpPtr = GetLinePtr(PageStart + sy);
-	while ((AttrBuff[TmpPtr] & AttrLineContinued) != 0) {
+	while ((CodeBuffW[TmpPtr].attr & AttrLineContinued) != 0) {
 		if (sy == 0) {
 			break;
 		}
@@ -2730,7 +2746,7 @@
 	ex = NumOfColumns - 1;
 	ey = cur_y;
 	TmpPtr = GetLinePtr(PageStart + ey);
-	while ((AttrBuff[TmpPtr + NumOfColumns - 1] & AttrLineContinued) != 0) {
+	while ((CodeBuffW[TmpPtr + NumOfColumns - 1].attr & AttrLineContinued) != 0) {
 		ey++;
 		TmpPtr = NextLinePtr(TmpPtr);
 	}
@@ -2758,7 +2774,7 @@
 			}
 			TmpPtr = GetLinePtr(PageStart + y);
 			for (x = sx_i; x < ex_i; x++) {
-				AttrBuff[TmpPtr + x] &= ~AttrURL;
+				CodeBuffW[TmpPtr + x].attr &= ~AttrURL;
 			}
 		}
 	}
@@ -2822,7 +2838,7 @@
 static void mark_url_w(int cur_x, int cur_y)
 {
 #if !ATR
-	PCHAR AttrLine = &AttrBuff[LinePtr];
+//	PCHAR AttrLine = &AttrBuff[LinePtr];
 //	PCHAR AttrLine2 = &AttrBuff2[LinePtr];
 //	PCHAR AttrLineFG = &AttrBuffFG[LinePtr];
 //	PCHAR AttrLineBG = &AttrBuffBG[LinePtr];
@@ -2843,15 +2859,15 @@
 	// 1\x82‘O\x82̃Z\x83\x8B\x82\xAAURL?
 	if (x == 0) {
 		// \x88\xEA\x94ԍ\xB6\x82̎\x9E\x82́A\x91O\x82̍s\x82\xA9\x82\xE7\x8Cp\x91\xB1\x82\xB5\x82Ă\xA2\x82āA\x91O\x82̍s\x82̍ŌオURL\x82\xBE\x82\xC1\x82\xBD\x8E\x9E
-		if ((AttrLine[0] & AttrLineContinued) != 0) {
+		if ((CodeLineW[0].attr & AttrLineContinued) != 0) {
 			const LONG TmpPtr = GetLinePtr(PageStart + cur_y - 1);
-			if ((AttrBuff[TmpPtr + NumOfColumns - 1] & AttrURL) != 0) {
+			if ((CodeBuffW[TmpPtr + NumOfColumns - 1].attr & AttrURL) != 0) {
 				prev = TRUE;
 			}
 		}
 	}
 	else {
-		if (AttrLine[x - 1] & AttrURL) {
+		if (CodeLineW[x - 1].attr & AttrURL) {
 			prev = TRUE;
 		}
 	}
@@ -2859,15 +2875,15 @@
 	// 1\x82Œ\xE3\x82\xEB\x82̃Z\x83\x8B\x82\xAAURL?
 	if (x == NumOfColumns - 1) {
 		// \x88\xEA\x94ԉE
-		if ((AttrLine[x] & AttrLineContinued) != 0) {
+		if ((CodeLineW[x].attr & AttrLineContinued) != 0) {
 			const LONG TmpPtr = GetLinePtr(PageStart + cur_y + 1);
-			if ((AttrBuff[TmpPtr + NumOfColumns - 1] & AttrURL) != 0) {
+			if ((CodeLineW[TmpPtr + NumOfColumns - 1].attr & AttrURL) != 0) {
 				next = TRUE;
 			}
 		}
 	}
 	else {
-		if (AttrLine[x + 1] & AttrURL) {
+		if (CodeLineW[x + 1].attr & AttrURL) {
 			next = TRUE;
 		}
 	}
@@ -2877,7 +2893,7 @@
 			if (isURLchar(u32)) {
 				// URL\x82ɂ͂\xB3\x82܂\xEA\x82Ă\xA2\x82āAURL\x82ɂȂ肦\x82\xE9\x83L\x83\x83\x83\x89\x83N\x83^
 				int ptr = GetLinePtr(PageStart + cur_y) + cur_x;
-				AttrBuff[ptr] |= AttrURL;
+				CodeLineW[ptr].attr |= AttrURL;
 				return;
 			}
 			// 1line\x8C\x9F\x8D\xB8
@@ -2893,7 +2909,7 @@
 			// \x81\xA8 \x83J\x81[\x83\\x83\x8B\x88ʒu\x82\xC9URL\x83A\x83g\x83\x8A\x83r\x83\x85\x81[\x83g\x82\xF0\x82‚\xAF\x82\xE9
 			if (isURLchar(u32)) {
 				// URL\x82\xF0\x90L\x82΂\xB7
-				AttrLine[x] |= AttrURL;
+				CodeLineW[x].attr |= AttrURL;
 			}
 			return;
 		}
@@ -2918,7 +2934,7 @@
 		ey = sy;
 		if (x < len) {
 			// \x92Z\x82\xA2
-			if ((AttrLine[0] & AttrLineContinued) == 0) {
+			if ((CodeLineW[0].attr & AttrLineContinued) == 0) {
 				// \x91O\x82̍s\x82ƘA\x8C\x8B\x82\xB5\x82Ă\xA2\x82Ȃ\xA2
 				continue;
 			}
@@ -2939,7 +2955,7 @@
 	// \x83}\x83b\x83`\x82\xB5\x82\xBD\x82̂\xC5URL\x91\xAE\x90\xAB\x82\xF0\x95t\x82\xAF\x82\xE9
 	if (sy == ey) {
 		for (i = 0; i <= len; i++) {
-			AttrLine[sx + i] |= AttrURL;
+			CodeLineW[sx + i].attr |= AttrURL;
 		}
 		if (StrChangeStart > sx) {
 			StrChangeStart = sx;
@@ -2951,7 +2967,7 @@
 		int xx = sx;
 		size_t left = len + 1;
 		while (left > 0) {
-			AttrBuff[TmpPtr + xx] |= AttrURL;
+			CodeLineW[TmpPtr + xx].attr |= AttrURL;
 			xx++;
 			if (xx == NumOfColumns) {
 				int draw_x = sx;
@@ -3056,8 +3072,8 @@
 {
 #if !ATR
 	PCHAR CodeLine = &CodeBuff[LinePtr];
-	PCHAR AttrLine = &AttrBuff[LinePtr];
-	PCHAR AttrLine2 = &AttrBuff2[LinePtr];
+//	PCHAR AttrLine = &AttrBuff[LinePtr];
+//	PCHAR AttrLine2 = &AttrBuff2[LinePtr];
 //	PCHAR AttrLineFG = &AttrBuffFG[LinePtr];
 //	PCHAR AttrLineBG = &AttrBuffBG[LinePtr];
 	buff_char_t * CodeLineW = &CodeBuffW[LinePtr];
@@ -3098,7 +3114,7 @@
 	OutputDebugPrintfW(L"BuffPutUnicode(U+%06x,(%d,%d)\n", u32, CursorX, CursorY);
 #endif
 
-	if (ts.EnableContinuedLineCopy && CursorX == 0 && (AttrLine[0] & AttrLineContinued)) {
+	if (ts.EnableContinuedLineCopy && CursorX == 0 && (CodeLineW[0].attr & AttrLineContinued)) {
 		Attr.Attr |= AttrLineContinued;
 	}
 
@@ -3221,10 +3237,10 @@
 			}
 
 			// \x88\xEA\x94ԍŌ\xE3\x82̕\xB6\x8E\x9A\x82\xAA\x91S\x8Ap\x82̏ꍇ\x81A
-			if (LineEnd <= NumOfColumns - 1 && (AttrLine[LineEnd - 1] & AttrKanji)) {
+			if (LineEnd <= NumOfColumns - 1 && (CodeLineW[LineEnd - 1].attr & AttrKanji)) {
 				CodeLine[LineEnd - 1] = 0x20;
 				BuffSetChar(&CodeLineW[LineEnd - 1], 0x20, 'H');
-				AttrLine[LineEnd] &= ~AttrKanji;
+				CodeLineW[LineEnd].attr &= ~AttrKanji;
 				//				CodeLine[LineEnd+1] = 0x20;
 				//				AttrLine[LineEnd+1] &= ~AttrKanji;
 				extr = 1;
@@ -3235,8 +3251,8 @@
 				if (MoveLen > 0) {
 					memmove(&CodeLine[CursorX + 2], &CodeLine[CursorX], MoveLen);
 					memmoveW(&(CodeLineW[CursorX + 2]), &(CodeLineW[CursorX]), MoveLen);
-					memmove(&AttrLine[CursorX + 2], &AttrLine[CursorX], MoveLen);
-					memmove(&AttrLine2[CursorX + 2], &AttrLine2[CursorX], MoveLen);
+//					memmove(&AttrLine[CursorX + 2], &AttrLine[CursorX], MoveLen);
+//					memmove(&AttrLine2[CursorX + 2], &AttrLine2[CursorX], MoveLen);
 //					memmove(&AttrLineFG[CursorX + 2], &AttrLineFG[CursorX], MoveLen);
 //					memmove(&AttrLineBG[CursorX + 2], &AttrLineBG[CursorX], MoveLen);
 				}
@@ -3246,8 +3262,8 @@
 				if (MoveLen > 0) {
 					memmove(&CodeLine[CursorX + 1], &CodeLine[CursorX], MoveLen);
 					memmoveW(&(CodeLineW[CursorX + 1]), &(CodeLineW[CursorX]), MoveLen);
-					memmove(&AttrLine[CursorX + 1], &AttrLine[CursorX], MoveLen);
-					memmove(&AttrLine2[CursorX + 1], &AttrLine2[CursorX], MoveLen);
+//					memmove(&AttrLine[CursorX + 1], &AttrLine[CursorX], MoveLen);
+//					memmove(&AttrLine2[CursorX + 1], &AttrLine2[CursorX], MoveLen);
 //					memmove(&AttrLineFG[CursorX + 1], &AttrLineFG[CursorX], MoveLen);
 //					memmove(&AttrLineBG[CursorX + 1], &AttrLineBG[CursorX], MoveLen);
 				}
@@ -3255,8 +3271,10 @@
 
 			CodeLine[CursorX] = b1;
 			BuffSetChar2(&CodeLineW[CursorX], u32, width_property, half_width, emoji);
-			AttrLine[CursorX] = Attr.Attr;
-			AttrLine2[CursorX] = Attr.Attr2;
+			CodeLineW[CursorX].attr = Attr.Attr;
+			CodeLineW[CursorX].attr2 = Attr.Attr2;
+//			AttrLine[CursorX] = Attr.Attr;
+//			AttrLine2[CursorX] = Attr.Attr2;
 //			AttrLineFG[CursorX] = Attr.Fore;
 //			AttrLineBG[CursorX] = Attr.Back;
 			CodeLineW[CursorX].fg = Attr.Fore;
@@ -3265,8 +3283,8 @@
 				CodeLine[CursorX + 1] = 0;
 				BuffSetChar(&CodeLineW[CursorX + 1], 0, 'H');
 				CodeLineW[CursorX + 1].Padding = TRUE;
-				AttrLine[CursorX + 1] = Attr.Attr;
-				AttrLine2[CursorX + 1] = Attr.Attr2;
+				CodeLineW[CursorX + 1].attr = Attr.Attr;
+				CodeLineW[CursorX + 1].attr2 = Attr.Attr2;
 //				AttrLineFG[CursorX + 1] = Attr.Fore;
 //				AttrLineBG[CursorX + 1] = Attr.Back;
 				CodeLineW[CursorX + 1].fg = Attr.Fore;
@@ -3280,12 +3298,12 @@
 #endif
 
 			/* last char in current line is kanji first? */
-			if ((AttrLine[LineEnd] & AttrKanji) != 0) {
+			if ((CodeLineW[LineEnd].attr & AttrKanji) != 0) {
 				/* then delete it */
 				CodeLine[LineEnd] = 0x20;
 				BuffSetChar(&CodeLineW[LineEnd], 0x20, 'H');
-				AttrLine[LineEnd] = CurCharAttr.Attr;
-				AttrLine2[LineEnd] = CurCharAttr.Attr2;
+				CodeLineW[LineEnd].attr = CurCharAttr.Attr;
+				CodeLineW[LineEnd].attr2 = CurCharAttr.Attr2;
 //				AttrLineFG[LineEnd] = CurCharAttr.Fore;
 //				AttrLineBG[LineEnd] = CurCharAttr.Back;
 				CodeLineW[LineEnd].fg = CurCharAttr.Fore;
@@ -3307,8 +3325,8 @@
 				buff_char_t *p = &CodeLineW[CursorX];
 				BuffSetChar(p, u32, 'H');
 				p->Padding = TRUE;
-				AttrLine[CursorX] = Attr.Attr;
-				AttrLine2[CursorX] = Attr.Attr2;
+				CodeLineW[CursorX].attr = Attr.Attr;
+				CodeLineW[CursorX].attr2 = Attr.Attr2;
 //				AttrLineFG[CursorX] = Attr.Fore;
 //				AttrLineBG[CursorX] = Attr.Back;
 				CodeLineW[CursorX].fg = Attr.Fore;
@@ -3334,13 +3352,13 @@
 				CodeLine[CursorX] = b1;
 				BuffSetChar2(&CodeLineW[CursorX], u32, width_property, half_width, emoji);
 				if (half_width) {
-					AttrLine[CursorX] = Attr.Attr;
+					CodeLineW[CursorX].attr = Attr.Attr;
 				}
 				else {
 					// \x91S\x8Ap
-					AttrLine[CursorX] = Attr.Attr | AttrKanji;
+					CodeLineW[CursorX].attr = Attr.Attr | AttrKanji;
 				}
-				AttrLine2[CursorX] = Attr.Attr2;
+				CodeLineW[CursorX].attr2 = Attr.Attr2;
 //				AttrLineFG[CursorX] = Attr.Fore;
 //				AttrLineBG[CursorX] = Attr.Back;
 				CodeLineW[CursorX].fg = Attr.Fore;
@@ -3353,8 +3371,8 @@
 						BuffSetChar(p, 0, 'H');
 						p->Padding = TRUE;
 						CodeLine[CursorX + 1] = b2;
-						AttrLine[CursorX + 1] = 0;
-						AttrLine2[CursorX + 1] = 0;
+						CodeLineW[CursorX + 1].attr = 0;
+						CodeLineW[CursorX + 1].attr2 = 0;
 //						AttrLineFG[CursorX + 1] = 0;
 //						AttrLineBG[CursorX + 1] = 0;
 						CodeLineW[CursorX + 1].fg = 0;
@@ -3499,8 +3517,8 @@
 				// \x8Dŏ\x89\x82ɕ\\x8E\xA6\x82\xB5\x82悤\x82Ƃ\xB5\x82\xBD\x95\xB6\x8E\x9A\x82\xAA\x91S\x8Ap\x82̉E\x82\xBE\x82\xC1\x82\xBD\x8Fꍇ
 				ptr--;
 			}
-			CurAttr.Attr = AttrBuff[ptr] & ~ AttrKanji;
-			CurAttr.Attr2 = AttrBuff2[ptr];
+			CurAttr.Attr = CodeBuffW[ptr].attr & ~ AttrKanji;
+			CurAttr.Attr2 = CodeBuffW[ptr].attr2;
 //			CurAttr.Fore = AttrBuffFG[ptr];
 //			CurAttr.Back = AttrBuffBG[ptr];
 			CurAttr.Fore = CodeBuffW[ptr].fg;
@@ -3730,7 +3748,8 @@
 void BuffSetCaretWidth()
 {
 #if !ATR
-	PCHAR AttrLine = &AttrBuff[LinePtr];
+	buff_char_t *CodeLineW = &CodeBuffW[LinePtr];
+//	PCHAR AttrLine = &AttrBuff[LinePtr];
 //	PCHAR AttrLine2 = &AttrBuff2[LinePtr];
 //	PCHAR AttrLineFG = &AttrBuffFG[LinePtr];
 //	PCHAR AttrLineBG = &AttrBuffBG[LinePtr];
@@ -3738,7 +3757,7 @@
 	BOOL DW;
 
 	/* check whether cursor on a DBCS character */
-	DW = (((BYTE)(AttrLine[CursorX]) & AttrKanji) != 0);
+	DW = (((BYTE)(CodeLineW[CursorX]).attr & AttrKanji) != 0);
 	DispSetCaretWidth(DW);
 }
 
@@ -3764,16 +3783,16 @@
 			SrcPtr = PrevLinePtr(DestPtr);
 			memcpy(&(CodeBuff[DestPtr]), &(CodeBuff[SrcPtr]), linelen);
 			memcpyW(&(CodeBuffW[DestPtr]), &(CodeBuffW[SrcPtr]), linelen);
-			memcpy(&(AttrBuff[DestPtr]), &(AttrBuff[SrcPtr]), linelen);
-			memcpy(&(AttrBuff2[DestPtr]), &(AttrBuff2[SrcPtr]), linelen);
+//			memcpy(&(AttrBuff[DestPtr]), &(AttrBuff[SrcPtr]), linelen);
+//			memcpy(&(AttrBuff2[DestPtr]), &(AttrBuff2[SrcPtr]), linelen);
 //			memcpy(&(AttrBuffFG[DestPtr]), &(AttrBuffFG[SrcPtr]), linelen);
 //			memcpy(&(AttrBuffBG[DestPtr]), &(AttrBuffBG[SrcPtr]), linelen);
 			DestPtr = SrcPtr;
 		}
 		memset(&(CodeBuff[SrcPtr]), 0x20, linelen);
-		memsetW(&(CodeBuffW[SrcPtr]), 0x20, CurCharAttr.Fore, CurCharAttr.Back, linelen);
-		memset(&(AttrBuff[SrcPtr]), AttrDefault, linelen);
-		memset(&(AttrBuff2[SrcPtr]), CurCharAttr.Attr2 & Attr2ColorMask, linelen);
+		memsetW(&(CodeBuffW[SrcPtr]), 0x20, CurCharAttr.Fore, CurCharAttr.Back, AttrDefault, CurCharAttr.Attr2 & Attr2ColorMask, linelen);
+//		memset(&(AttrBuff[SrcPtr]), AttrDefault, linelen);
+//		memset(&(AttrBuff2[SrcPtr]), CurCharAttr.Attr2 & Attr2ColorMask, linelen);
 //		memset(&(AttrBuffFG[SrcPtr]), CurCharAttr.Fore, linelen);
 //		memset(&(AttrBuffBG[SrcPtr]), CurCharAttr.Back, linelen);
 
@@ -3837,8 +3856,8 @@
 			for (i = CursorTop+n ; i<=CursorBottom ; i++) {
 				memmove(&(CodeBuff[DestPtr]), &(CodeBuff[SrcPtr]), linelen);
 				memmoveW(&(CodeBuffW[DestPtr]), &(CodeBuffW[SrcPtr]), linelen);
-				memmove(&(AttrBuff[DestPtr]), &(AttrBuff[SrcPtr]), linelen);
-				memmove(&(AttrBuff2[DestPtr]), &(AttrBuff2[SrcPtr]), linelen);
+//				memmove(&(AttrBuff[DestPtr]), &(AttrBuff[SrcPtr]), linelen);
+//				memmove(&(AttrBuff2[DestPtr]), &(AttrBuff2[SrcPtr]), linelen);
 //				memmove(&(AttrBuffFG[DestPtr]), &(AttrBuffFG[SrcPtr]), linelen);
 //				memmove(&(AttrBuffBG[DestPtr]), &(AttrBuffBG[SrcPtr]), linelen);
 				SrcPtr = NextLinePtr(SrcPtr);
@@ -3850,9 +3869,9 @@
 		}
 		for (i = CursorBottom+1-n ; i<=CursorBottom; i++) {
 			memset(&(CodeBuff[DestPtr]), 0x20, linelen);
-			memsetW(&(CodeBuffW[DestPtr]), 0x20, CurCharAttr.Fore, CurCharAttr.Back, linelen);
-			memset(&(AttrBuff[DestPtr]), AttrDefault, linelen);
-			memset(&(AttrBuff2[DestPtr]), CurCharAttr.Attr2 & Attr2ColorMask, linelen);
+			memsetW(&(CodeBuffW[DestPtr]), 0x20, CurCharAttr.Fore, CurCharAttr.Back, AttrDefault, CurCharAttr.Attr2 & Attr2ColorMask, linelen);
+//			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);
@@ -3900,8 +3919,8 @@
 			for (i = CursorTop+n ; i<=CursorBottom ; i++) {
 				memmove(&(CodeBuff[DestPtr]), &(CodeBuff[SrcPtr]), linelen);
 				memmoveW(&(CodeBuffW[DestPtr]), &(CodeBuffW[SrcPtr]), linelen);
-				memmove(&(AttrBuff[DestPtr]), &(AttrBuff[SrcPtr]), linelen);
-				memmove(&(AttrBuff2[DestPtr]), &(AttrBuff2[SrcPtr]), linelen);
+//				memmove(&(AttrBuff[DestPtr]), &(AttrBuff[SrcPtr]), linelen);
+//				memmove(&(AttrBuff2[DestPtr]), &(AttrBuff2[SrcPtr]), linelen);
 //				memmove(&(AttrBuffFG[DestPtr]), &(AttrBuffFG[SrcPtr]), linelen);
 //				memmove(&(AttrBuffBG[DestPtr]), &(AttrBuffBG[SrcPtr]), linelen);
 				SrcPtr = NextLinePtr(SrcPtr);
@@ -3913,9 +3932,9 @@
 		}
 		for (i = CursorBottom+1-n ; i<=CursorBottom; i++) {
 			memset(&(CodeBuff[DestPtr]), 0x20, linelen);
-			memsetW(&(CodeBuffW[DestPtr]), 0x20, CurCharAttr.Fore, CurCharAttr.Back, linelen);
-			memset(&(AttrBuff[DestPtr]), AttrDefault, linelen);
-			memset(&(AttrBuff2[DestPtr]), CurCharAttr.Attr2 & Attr2ColorMask, linelen);
+			memsetW(&(CodeBuffW[DestPtr]), 0x20, CurCharAttr.Fore, CurCharAttr.Back, AttrDefault, CurCharAttr.Attr2 & Attr2ColorMask, linelen);
+//			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);
@@ -3954,8 +3973,8 @@
 		for (i=CursorBottom-n ; i>=CursorTop ; i--) {
 			memmove(&(CodeBuff[DestPtr]), &(CodeBuff[SrcPtr]), linelen);
 			memmoveW(&(CodeBuffW[DestPtr]), &(CodeBuffW[SrcPtr]), linelen);
-			memmove(&(AttrBuff[DestPtr]), &(AttrBuff[SrcPtr]), linelen);
-			memmove(&(AttrBuff2[DestPtr]), &(AttrBuff2[SrcPtr]), linelen);
+//			memmove(&(AttrBuff[DestPtr]), &(AttrBuff[SrcPtr]), linelen);
+//			memmove(&(AttrBuff2[DestPtr]), &(AttrBuff2[SrcPtr]), linelen);
 //			memmove(&(AttrBuffFG[DestPtr]), &(AttrBuffFG[SrcPtr]), linelen);
 //			memmove(&(AttrBuffBG[DestPtr]), &(AttrBuffBG[SrcPtr]), linelen);
 			SrcPtr = PrevLinePtr(SrcPtr);
@@ -3967,9 +3986,9 @@
 	}
 	for (i = CursorTop+n-1; i>=CursorTop; i--) {
 		memset(&(CodeBuff[DestPtr]), 0x20, linelen);
-		memsetW(&(CodeBuffW[DestPtr]), 0x20, CurCharAttr.Fore, CurCharAttr.Back, linelen);
-		memset(&(AttrBuff[DestPtr]), AttrDefault, linelen);
-		memset(&(AttrBuff2[DestPtr]), CurCharAttr.Attr2 & Attr2ColorMask, linelen);
+		memsetW(&(CodeBuffW[DestPtr]), 0x20, CurCharAttr.Fore, CurCharAttr.Back, AttrDefault, CurCharAttr.Attr2 & Attr2ColorMask, linelen);
+//		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);
@@ -4017,7 +4036,7 @@
 //   check if a character is the word delimiter
 static BOOL IsDelimiter(LONG Line, int CharPtr)
 {
-	if ((AttrBuff[Line+CharPtr] & AttrKanji) !=0) {
+	if ((CodeBuffW[Line+CharPtr].attr & AttrKanji) !=0) {
 		return (ts.DelimDBCS!=0);
 	}
 	return (strchr(ts.DelimList,CodeBuff[Line+CharPtr])!=NULL);
@@ -4071,13 +4090,13 @@
 	int ex;
 
 	sx = x;
-	while (AttrBuff[TmpPtr + sx] & AttrURL) {
+	while (CodeBuffW[TmpPtr + sx].attr & AttrURL) {
 		sx--;
 	}
 	sx++;
 
 	ex = x;
-	while (AttrBuff[TmpPtr + ex] & AttrURL) {
+	while (CodeBuffW[TmpPtr + ex].attr & AttrURL) {
 		ex++;
 	}
 
@@ -4193,7 +4212,7 @@
 		LockBuffer();
 		TmpPtr = GetLinePtr(Y);
 		/* start - ishizaki */
-		if (AttrBuff[TmpPtr+X] & AttrURL) {
+		if (CodeBuffW[TmpPtr+X].attr & AttrURL) {
 			BoxSelect = FALSE;
 			SelectEnd = SelectStart;
 			ChangeSelectRegion();
@@ -4255,15 +4274,15 @@
 
 		if (IsDelimiter(TmpPtr,IStart)) {
 			b = CodeBuff[TmpPtr+IStart];
-			DBCS = (AttrBuff[TmpPtr+IStart] & AttrKanji) != 0;
+			DBCS = (CodeBuffW[TmpPtr+IStart].attr & AttrKanji) != 0;
 			while ((b==CodeBuff[TmpPtr+IStart]) ||
 			       DBCS &&
-			       ((AttrBuff[TmpPtr+IStart] & AttrKanji)!=0)) {
+			       ((CodeBuffW[TmpPtr+IStart].attr & AttrKanji)!=0)) {
 				MoveCharPtr(TmpPtr,&IStart,-1); // move left
 				if (ts.EnableContinuedLineCopy) {
 					if (IStart<=0) {
 						// \x8D\xB6\x92[\x82̏ꍇ
-						if (YStart>0 && AttrBuff[TmpPtr] & AttrLineContinued) {
+						if (YStart>0 && CodeBuffW[TmpPtr].attr & AttrLineContinued) {
 							// \x91O\x82̍s\x82Ɉړ\xAE\x82\xB7\x82\xE9
 							YStart--;
 							TmpPtr = GetLinePtr(YStart);
@@ -4282,7 +4301,7 @@
 				}
 			}
 			if ((b!=CodeBuff[TmpPtr+IStart]) &&
-			    ! (DBCS && ((AttrBuff[TmpPtr+IStart] & AttrKanji)!=0))) {
+			    ! (DBCS && ((CodeBuffW[TmpPtr+IStart].attr & AttrKanji)!=0))) {
 				// \x8DŏI\x88ʒu\x82\xAA Delimiter \x82łȂ\xA2\x8Fꍇ\x82ɂ͂ЂƂ‰E\x82ɂ\xB8\x82炷
 				if (ts.EnableContinuedLineCopy && IStart == NumOfColumns-1) {
 					// \x89E\x92[\x82̏ꍇ\x82ɂ͎\x9F\x82̍s\x82ֈړ\xAE\x82\xB7\x82\xE9
@@ -4300,13 +4319,13 @@
 			i = 1;
 			while (((b==CodeBuff[TmpPtr+IEnd]) ||
 			        DBCS &&
-			        ((AttrBuff[TmpPtr+IEnd] & AttrKanji)!=0))) {
+			        ((CodeBuffW[TmpPtr+IEnd].attr & AttrKanji)!=0))) {
 				i = MoveCharPtr(TmpPtr,&IEnd,1); // move right
 				if (ts.EnableContinuedLineCopy) {
 					if (i==0) {
 						// \x89E\x92[\x82̏ꍇ
 						if (YEnd<BuffEnd &&
-						    AttrBuff[TmpPtr+IEnd+1+DBCS] & AttrLineContinued) {
+							CodeBuffW[TmpPtr+IEnd+1+DBCS].attr & AttrLineContinued) {
 							// \x8E\x9F\x82̍s\x82Ɉړ\xAE\x82\xB7\x82\xE9
 							YEnd++;
 							TmpPtr = GetLinePtr(YEnd);
@@ -4331,7 +4350,7 @@
 				if (ts.EnableContinuedLineCopy) {
 					if (IStart<=0) {
 						// \x8D\xB6\x92[\x82̏ꍇ
-						if (YStart>0 && AttrBuff[TmpPtr] & AttrLineContinued) {
+						if (YStart>0 && CodeBuffW[TmpPtr].attr & AttrLineContinued) {
 							// \x91O\x82̍s\x82Ɉړ\xAE\x82\xB7\x82\xE9
 							YStart--;
 							TmpPtr = GetLinePtr(YStart);
@@ -4370,7 +4389,7 @@
 				if (ts.EnableContinuedLineCopy) {
 					if (i==0) {
 						// \x89E\x92[\x82̏ꍇ
-						if (YEnd<BuffEnd && AttrBuff[TmpPtr+IEnd+1] & AttrLineContinued) {
+						if (YEnd<BuffEnd && CodeBuffW[TmpPtr+IEnd+1].attr & AttrLineContinued) {
 							// \x8E\x9F\x82̍s\x82Ɉړ\xAE\x82\xB7\x82\xE9
 							YEnd++;
 							TmpPtr = GetLinePtr(YEnd);
@@ -4513,8 +4532,8 @@
 	TmpPtr = GetLinePtr(SelectStart.y);
 	// check if the cursor is on the right half of a character
 	if ((SelectStartTmp.x>0) &&
-	    ((AttrBuff[TmpPtr+SelectStartTmp.x-1] & AttrKanji) != 0) ||
-	    ((AttrBuff[TmpPtr+SelectStartTmp.x] & AttrKanji) == 0) &&
+	    ((CodeBuffW[TmpPtr+SelectStartTmp.x-1].attr & AttrKanji) != 0) ||
+	    ((CodeBuffW[TmpPtr+SelectStartTmp.x].attr & AttrKanji) == 0) &&
 	     Right) {
 		SelectStartTmp.x++;
 	}
@@ -4563,9 +4582,9 @@
 	LockBuffer();
 	// check if the cursor is on the right half of a character
 	if ((X>0) &&
-	    ((AttrBuff[TmpPtr+X-1] & AttrKanji) != 0) ||
+	    ((CodeBuffW[TmpPtr+X-1].attr & AttrKanji) != 0) ||
 	    (X<NumOfColumns) &&
-	    ((AttrBuff[TmpPtr+X] & AttrKanji) == 0) &&
+	    ((CodeBuffW[TmpPtr+X].attr & AttrKanji) == 0) &&
 	    Right) {
 		X++;
 	}
@@ -4613,11 +4632,11 @@
 			i = 1;
 			if (IsDelimiter(TmpPtr,X)) {
 				b = CodeBuff[TmpPtr+X];
-				DBCS = (AttrBuff[TmpPtr+X] & AttrKanji) != 0;
+				DBCS = (CodeBuffW[TmpPtr+X].attr & AttrKanji) != 0;
 				while ((i!=0) &&
 				       ((b==CodeBuff[TmpPtr+SelectEnd.x]) ||
 				        DBCS &&
-				        ((AttrBuff[TmpPtr+SelectEnd.x] & AttrKanji)!=0))) {
+				        ((CodeBuffW[TmpPtr+SelectEnd.x].attr & AttrKanji)!=0))) {
 					i = MoveCharPtr(TmpPtr,(int *)&SelectEnd.x,1); // move right
 				}
 			}
@@ -4641,16 +4660,16 @@
 			}
 			if (IsDelimiter(TmpPtr,SelectEnd.x)) {
 				b = CodeBuff[TmpPtr+SelectEnd.x];
-				DBCS = (AttrBuff[TmpPtr+SelectEnd.x] & AttrKanji) != 0;
+				DBCS = (CodeBuffW[TmpPtr+SelectEnd.x].attr & AttrKanji) != 0;
 				while ((SelectEnd.x>0) &&
 				       ((b==CodeBuff[TmpPtr+SelectEnd.x]) ||
 				       DBCS &&
-				       ((AttrBuff[TmpPtr+SelectEnd.x] & AttrKanji)!=0))) {
+				       ((CodeBuffW[TmpPtr+SelectEnd.x].attr & AttrKanji)!=0))) {
 					MoveCharPtr(TmpPtr,(int *)&SelectEnd.x,-1); // move left
 				}
 				if ((b!=CodeBuff[TmpPtr+SelectEnd.x]) &&
 				    ! (DBCS &&
-				    ((AttrBuff[TmpPtr+SelectEnd.x] & AttrKanji)!=0))) {
+				    ((CodeBuffW[TmpPtr+SelectEnd.x].attr & AttrKanji)!=0))) {
 					MoveCharPtr(TmpPtr,(int *)&SelectEnd.x,1);
 				}
 			}
@@ -4821,7 +4840,7 @@
 		}
 
 		if (! ChangeBuffer(Nx,Nb)) {
-			return NULL;
+			return;
 		}
 		if (ts.EnableScrollBuff>0) {
 			ts.ScrollBuffSize = NumOfLinesInBuff;
@@ -4994,9 +5013,9 @@
 
 	NewLine(0);
 	memset(&CodeBuff[0],0x20,BufferSize);
-	memsetW(&CodeBuffW[0],0x20, CurCharAttr.Fore, CurCharAttr.Back, BufferSize);
-	memset(&AttrBuff[0],AttrDefault,BufferSize);
-	memset(&AttrBuff2[0],CurCharAttr.Attr2 & Attr2ColorMask, BufferSize);
+	memsetW(&CodeBuffW[0],0x20, CurCharAttr.Fore, CurCharAttr.Back, AttrDefault, CurCharAttr.Attr2 & Attr2ColorMask, BufferSize);
+//	memset(&AttrBuff[0],AttrDefault,BufferSize);
+//	memset(&AttrBuff2[0],CurCharAttr.Attr2 & Attr2ColorMask, BufferSize);
 //	memset(&AttrBuffFG[0],CurCharAttr.Fore,BufferSize);
 //	memset(&AttrBuffBG[0],CurCharAttr.Back,BufferSize);
 
@@ -5203,7 +5222,8 @@
 void BuffLineContinued(BOOL mode)
 {
 #if !ATR
-	PCHAR AttrLine = &AttrBuff[LinePtr];
+	buff_char_t* CodeLineW = &CodeBuffW[LinePtr];
+//	PCHAR AttrLine = &AttrBuff[LinePtr];
 //	PCHAR AttrLine2 = &AttrBuff2[LinePtr];
 //	PCHAR AttrLineFG = &AttrBuffFG[LinePtr];
 //	PCHAR AttrLineBG = &AttrBuffBG[LinePtr];
@@ -5210,9 +5230,9 @@
 #endif
 	if (ts.EnableContinuedLineCopy) {
 		if (mode) {
-			AttrLine[0] |= AttrLineContinued;
+			CodeLineW[0].attr |= AttrLineContinued;
 		} else {
-			AttrLine[0] &= ~AttrLineContinued;
+			CodeLineW[0].attr &= ~AttrLineContinued;
 		}
 	}
 }
@@ -5253,8 +5273,8 @@
 			for (i=0; i<NumOfLines; i++) {
 				memcpy(&CodeDest[DestPtr], &CodeBuff[SrcPtr], NumOfColumns);
 				memcpyW(&CodeDestW[DestPtr], &CodeBuffW[SrcPtr], NumOfColumns);
-				memcpy(&AttrDest[DestPtr], &AttrBuff[SrcPtr], NumOfColumns);
-				memcpy(&AttrDest2[DestPtr], &AttrBuff2[SrcPtr], NumOfColumns);
+//				memcpy(&AttrDest[DestPtr], &AttrBuff[SrcPtr], NumOfColumns);
+//				memcpy(&AttrDest2[DestPtr], &AttrBuff2[SrcPtr], NumOfColumns);
 //				memcpy(&AttrDestFG[DestPtr], &AttrBuffFG[SrcPtr], NumOfColumns);
 //				memcpy(&AttrDestBG[DestPtr], &AttrBuffBG[SrcPtr], NumOfColumns);
 				SrcPtr = NextLinePtr(SrcPtr);
@@ -5308,14 +5328,14 @@
 		for (i=0; i<CopyY; i++) {
 			memcpy(&CodeBuff[DestPtr], &CodeSrc[SrcPtr], CopyX);
 			memcpyW(&CodeBuffW[DestPtr], &CodeSrcW[SrcPtr], CopyX);
-			memcpy(&AttrBuff[DestPtr], &AttrSrc[SrcPtr], CopyX);
-			memcpy(&AttrBuff2[DestPtr], &AttrSrc2[SrcPtr], CopyX);
+//			memcpy(&AttrBuff[DestPtr], &AttrSrc[SrcPtr], CopyX);
+//			memcpy(&AttrBuff2[DestPtr], &AttrSrc2[SrcPtr], CopyX);
 //			memcpy(&AttrBuffFG[DestPtr], &AttrSrcFG[SrcPtr], CopyX);
 //			memcpy(&AttrBuffBG[DestPtr], &AttrSrcBG[SrcPtr], CopyX);
-			if (AttrBuff[DestPtr+CopyX-1] & AttrKanji) {
+			if (CodeBuffW[DestPtr+CopyX-1].attr & AttrKanji) {
 				CodeBuff[DestPtr+CopyX-1] = ' ';
 				BuffSetChar(&CodeBuffW[DestPtr+CopyX-1], 0x20, 'H');
-				AttrBuff[DestPtr+CopyX-1] ^= AttrKanji;
+				CodeBuffW[DestPtr+CopyX-1].attr ^= AttrKanji;
 			}
 			SrcPtr += SaveBuffX;
 			DestPtr = NextLinePtr(DestPtr);
@@ -5341,8 +5361,9 @@
 // Erase characters from cursor to the end of screen
 {
 #if !ATR
+	buff_char_t* CodeLineW = &CodeBuffW[LinePtr];
 //	PCHAR AttrLine = &AttrBuff[LinePtr];
-	PCHAR AttrLine2 = &AttrBuff2[LinePtr];
+//	PCHAR AttrLine2 = &AttrBuff2[LinePtr];
 //	PCHAR AttrLineFG = &AttrBuffFG[LinePtr];
 //	PCHAR AttrLineBG = &AttrBuffBG[LinePtr];
 #endif
@@ -5352,7 +5373,7 @@
 
 	NewLine(PageStart+CursorY);
 	if (ts.Language==IdJapanese || ts.Language==IdKorean || ts.Language==IdUtf8) {
-		if (!(AttrLine2[CursorX] & Attr2Protect)) {
+		if (!(CodeLineW[CursorX].attr2 & Attr2Protect)) {
 			EraseKanji(1); /* if cursor is on right half of a kanji, erase the kanji */
 		}
 	}
@@ -5364,10 +5385,10 @@
 	}
 	for (i = CursorY ; i <= YEnd ; i++) {
 		for (j = TmpPtr + offset; j < TmpPtr + NumOfColumns - offset; j++) {
-			if (!(AttrBuff2[j] & Attr2Protect)) {
+			if (!(CodeLineW[j].attr2 & Attr2Protect)) {
 				CodeBuff[j] = 0x20;
 				BuffSetChar(&CodeBuffW[j], 0x20, 'H');
-				AttrBuff[j] &= AttrSgrMask;
+				CodeLineW[j].attr &= AttrSgrMask;
 			}
 		}
 		offset = 0;
@@ -5381,8 +5402,9 @@
 // Erase characters from home to cursor
 {
 #if !ATR
-//	PCHAR AttrLine = &AttrBuff[LinePtr];
-	PCHAR AttrLine2 = &AttrBuff2[LinePtr];
+	buff_char_t* CodeLineW = &CodeBuffW[LinePtr];
+	//	PCHAR AttrLine = &AttrBuff[LinePtr];
+//	PCHAR AttrLine2 = &AttrBuff2[LinePtr];
 //	PCHAR AttrLineFG = &AttrBuffFG[LinePtr];
 //	PCHAR AttrLineBG = &AttrBuffBG[LinePtr];
 #endif
@@ -5392,7 +5414,7 @@
 
 	NewLine(PageStart+CursorY);
 	if (ts.Language==IdJapanese || ts.Language==IdKorean || ts.Language==IdUtf8) {
-		if (!(AttrLine2[CursorX] & Attr2Protect)) {
+		if (!(CodeLineW[CursorX].attr2 & Attr2Protect)) {
 			EraseKanji(0); /* if cursor is on left half of a kanji, erase the kanji */
 		}
 	}
@@ -5409,10 +5431,10 @@
 			offset = CursorX+1;
 		}
 		for (j = TmpPtr; j < TmpPtr + offset; j++) {
-			if (!(AttrBuff2[j] & Attr2Protect)) {
+			if (!(CodeLineW[j].attr2 & Attr2Protect)) {
 				CodeBuff[j] = 0x20;
 				BuffSetChar(&CodeBuffW[j], 0x20, 'H');
-				AttrBuff[j] &= AttrSgrMask;
+				CodeBuffW[j].attr &= AttrSgrMask;
 			}
 		}
 		TmpPtr = NextLinePtr(TmpPtr);
@@ -5427,8 +5449,7 @@
 	BuffSelectedEraseCurToEnd();
 }
 
-void BuffSelectiveEraseBox
-  (int XStart, int YStart, int XEnd, int YEnd)
+void BuffSelectiveEraseBox(int XStart, int YStart, int XEnd, int YEnd)
 {
 	int C, i, j;
 	LONG Ptr;
@@ -5449,24 +5470,24 @@
 	Ptr = GetLinePtr(PageStart+YStart);
 	for (i=YStart; i<=YEnd; i++) {
 		if ((XStart>0) &&
-		    ((AttrBuff[Ptr+XStart-1] & AttrKanji) != 0) &&
-		    ((AttrBuff2[Ptr+XStart-1] & Attr2Protect) == 0)) {
+		    ((CodeBuffW[Ptr+XStart-1].attr & AttrKanji) != 0) &&
+		    ((CodeBuffW[Ptr+XStart-1].attr2 & Attr2Protect) == 0)) {
 			CodeBuff[Ptr+XStart-1] = 0x20;
 			BuffSetChar(&CodeBuffW[Ptr+XStart-1], 0x20, 'H');
-			AttrBuff[Ptr+XStart-1] &= AttrSgrMask;
+			CodeBuffW[Ptr+XStart-1].attr &= AttrSgrMask;
 		}
 		if ((XStart+C<NumOfColumns) &&
-		    ((AttrBuff[Ptr+XStart+C-1] & AttrKanji) != 0) &&
-		    ((AttrBuff2[Ptr+XStart+C-1] & Attr2Protect) == 0)) {
+		    ((CodeBuffW[Ptr+XStart+C-1].attr & AttrKanji) != 0) &&
+		    ((CodeBuffW[Ptr+XStart+C-1].attr2 & Attr2Protect) == 0)) {
 			CodeBuff[Ptr+XStart+C] = 0x20;
 			BuffSetChar(&CodeBuffW[Ptr+XStart+C], 0x20, 'H');
-			AttrBuff[Ptr+XStart+C] &= AttrSgrMask;
+			CodeBuffW[Ptr+XStart+C].attr &= AttrSgrMask;
 		}
 		for (j=Ptr+XStart; j<Ptr+XStart+C; j++) {
-			if (!(AttrBuff2[j] & Attr2Protect)) {
+			if (!(CodeBuffW[j].attr2 & Attr2Protect)) {
 				CodeBuff[j] = 0x20;
 				BuffSetChar(&CodeBuffW[j], 0x20, 'H');
-				AttrBuff[j] &= AttrSgrMask;
+				CodeBuffW[j].attr &= AttrSgrMask;
 			}
 		}
 		Ptr = NextLinePtr(Ptr);
@@ -5481,8 +5502,8 @@
 {
 #if !ATR
 	PCHAR CodeLine = &CodeBuff[LinePtr];
-	PCHAR AttrLine = &AttrBuff[LinePtr];
-	PCHAR AttrLine2 = &AttrBuff2[LinePtr];
+//	PCHAR AttrLine = &AttrBuff[LinePtr];
+//	PCHAR AttrLine2 = &AttrBuff2[LinePtr];
 //	PCHAR AttrLineFG = &AttrBuffFG[LinePtr];
 //	PCHAR AttrLineBG = &AttrBuffBG[LinePtr];
 	buff_char_t * CodeLineW = &CodeBuffW[LinePtr];
@@ -5490,12 +5511,12 @@
 	int i;
 	BOOL LineContinued=FALSE;
 
-	if (ts.EnableContinuedLineCopy && XStart == 0 && (AttrLine[0] & AttrLineContinued)) {
+	if (ts.EnableContinuedLineCopy && XStart == 0 && (CodeLineW[0].attr & AttrLineContinued)) {
 		LineContinued = TRUE;
 	}
 
 	if (ts.Language==IdJapanese || ts.Language==IdKorean || ts.Language==IdUtf8) {
-		if (!(AttrLine2[CursorX] & Attr2Protect)) {
+		if (!(CodeLineW[CursorX].attr2 & Attr2Protect)) {
 			EraseKanji(1); /* if cursor is on right half of a kanji, erase the kanji */
 		}
 	}
@@ -5502,10 +5523,10 @@
 
 	NewLine(PageStart+CursorY);
 	for (i=XStart; i < XStart + Count; i++) {
-		if (!(AttrLine2[i] & Attr2Protect)) {
+		if (!(CodeLineW[i].attr2 & Attr2Protect)) {
 			CodeLine[i] = 0x20;
 			BuffSetChar(&CodeLineW[i], 0x20, 'H');
-			AttrLine[i] &= AttrSgrMask;
+			CodeLineW[i].attr &= AttrSgrMask;
 		}
 	}
 
@@ -5515,7 +5536,7 @@
 		}
 
 		if (XStart + Count >= NumOfColumns) {
-			AttrBuff[NextLinePtr(LinePtr)] &= ~AttrLineContinued;
+			CodeBuffW[NextLinePtr(LinePtr)].attr &= ~AttrLineContinued;
 		}
 	}
 
@@ -5534,10 +5555,10 @@
 	for (i = CursorTop; i <= CursorBottom; i++) {
 		Ptr = LPtr + CursorLeftM;
 
-		if (AttrBuff[LPtr+CursorRightM] & AttrKanji) {
+		if (CodeBuffW[LPtr+CursorRightM].attr & AttrKanji) {
 			CodeBuff[LPtr+CursorRightM] = 0x20;
 			BuffSetChar(&CodeBuffW[LPtr+CursorRightM], 0x20, 'H');
-			AttrBuff[LPtr+CursorRightM] &= ~AttrKanji;
+			CodeBuffW[LPtr+CursorRightM].attr &= ~AttrKanji;
 			if (CursorRightM < NumOfColumns-1) {
 				CodeBuff[LPtr+CursorRightM+1] = 0x20;
 				BuffSetChar(&CodeBuffW[LPtr+CursorRightM+1], 0x20, 'H');
@@ -5544,28 +5565,28 @@
 			}
 		}
 
-		if (AttrBuff[Ptr+count-1] & AttrKanji) {
+		if (CodeBuffW[Ptr+count-1].attr & AttrKanji) {
 			CodeBuff[Ptr+count] = 0x20;
 			BuffSetChar(&CodeBuffW[Ptr+count], 0x20, 'H');
 		}
 
-		if (CursorLeftM > 0 && AttrBuff[Ptr-1] & AttrKanji) {
+		if (CursorLeftM > 0 && CodeBuffW[Ptr-1].attr & AttrKanji) {
 			CodeBuff[Ptr-1] = 0x20;
 			BuffSetChar(&CodeBuffW[Ptr-1], 0x20, 'H');
-			AttrBuff[Ptr-1] &= ~AttrKanji;
+			CodeBuffW[Ptr-1].attr &= ~AttrKanji;
 		}
 
 		memmove(&(CodeBuff[Ptr]),   &(CodeBuff[Ptr+count]),   MoveLen);
 		memmoveW(&(CodeBuffW[Ptr]),   &(CodeBuffW[Ptr+count]),   MoveLen);
-		memmove(&(AttrBuff[Ptr]),   &(AttrBuff[Ptr+count]),   MoveLen);
-		memmove(&(AttrBuff2[Ptr]),  &(AttrBuff2[Ptr+count]),  MoveLen);
+//		memmove(&(AttrBuff[Ptr]),   &(AttrBuff[Ptr+count]),   MoveLen);
+//		memmove(&(AttrBuff2[Ptr]),  &(AttrBuff2[Ptr+count]),  MoveLen);
 //		memmove(&(AttrBuffFG[Ptr]), &(AttrBuffFG[Ptr+count]), MoveLen);
 //		memmove(&(AttrBuffBG[Ptr]), &(AttrBuffBG[Ptr+count]), MoveLen);
 
 		memset(&(CodeBuff[Ptr+MoveLen]),   0x20,             count);
-		memsetW(&(CodeBuffW[Ptr+MoveLen]), 0x20, CurCharAttr.Fore, CurCharAttr.Back, count);
-		memset(&(AttrBuff[Ptr+MoveLen]),   AttrDefault,      count);
-		memset(&(AttrBuff2[Ptr+MoveLen]),  CurCharAttr.Attr2 & Attr2ColorMask, count);
+		memsetW(&(CodeBuffW[Ptr+MoveLen]), 0x20, CurCharAttr.Fore, CurCharAttr.Back, AttrDefault, CurCharAttr.Attr2 & Attr2ColorMask, count);
+//		memset(&(AttrBuff[Ptr+MoveLen]),   AttrDefault,      count);
+//		memset(&(AttrBuff2[Ptr+MoveLen]),  CurCharAttr.Attr2 & Attr2ColorMask, count);
 //		memset(&(AttrBuffFG[Ptr+MoveLen]), CurCharAttr.Fore, count);
 //		memset(&(AttrBuffBG[Ptr+MoveLen]), CurCharAttr.Back, count);
 
@@ -5587,15 +5608,15 @@
 	for (i = CursorTop; i <= CursorBottom; i++) {
 		Ptr = LPtr + CursorLeftM;
 
-		if (CursorRightM < NumOfColumns-1 && AttrBuff[LPtr+CursorRightM] & AttrKanji) {
+		if (CursorRightM < NumOfColumns-1 && CodeBuffW[LPtr+CursorRightM].attr & AttrKanji) {
 			CodeBuff[LPtr+CursorRightM+1] = 0x20;
 			BuffSetChar(&CodeBuffW[LPtr+CursorRightM+1], 0x20, 'H');
 		}
 
-		if (CursorLeftM > 0 && AttrBuff[Ptr-1] & AttrKanji) {
+		if (CursorLeftM > 0 && CodeBuffW[Ptr-1].attr & AttrKanji) {
 			CodeBuff[Ptr-1] = 0x20;
 			BuffSetChar(&CodeBuffW[Ptr-1], 0x20, 'H');
-			AttrBuff[Ptr-1] &= ~AttrKanji;
+			CodeBuffW[Ptr-1].attr &= ~AttrKanji;
 			CodeBuff[Ptr] = 0x20;
 			BuffSetChar(&CodeBuffW[Ptr], 0x20, 'H');
 		}
@@ -5602,22 +5623,22 @@
 
 		memmove(&(CodeBuff[Ptr+count]),   &(CodeBuff[Ptr]),   MoveLen);
 		memmoveW(&(CodeBuffW[Ptr+count]),   &(CodeBuffW[Ptr]),   MoveLen);
-		memmove(&(AttrBuff[Ptr+count]),   &(AttrBuff[Ptr]),   MoveLen);
-		memmove(&(AttrBuff2[Ptr+count]),  &(AttrBuff2[Ptr]),  MoveLen);
+//		memmove(&(AttrBuff[Ptr+count]),   &(AttrBuff[Ptr]),   MoveLen);
+//		memmove(&(AttrBuff2[Ptr+count]),  &(AttrBuff2[Ptr]),  MoveLen);
 //		memmove(&(AttrBuffFG[Ptr+count]), &(AttrBuffFG[Ptr]), MoveLen);
 //		memmove(&(AttrBuffBG[Ptr+count]), &(AttrBuffBG[Ptr]), MoveLen);
 
 		memset(&(CodeBuff[Ptr]),   0x20,             count);
-		memsetW(&(CodeBuffW[Ptr]),   0x20, CurCharAttr.Fore, CurCharAttr.Back, count);
-		memset(&(AttrBuff[Ptr]),   AttrDefault,      count);
-		memset(&(AttrBuff2[Ptr]),  CurCharAttr.Attr2 & Attr2ColorMask, count);
+		memsetW(&(CodeBuffW[Ptr]),   0x20, CurCharAttr.Fore, CurCharAttr.Back, AttrDefault, CurCharAttr.Attr2 & Attr2ColorMask, count);
+//		memset(&(AttrBuff[Ptr]),   AttrDefault,      count);
+//		memset(&(AttrBuff2[Ptr]),  CurCharAttr.Attr2 & Attr2ColorMask, count);
 //		memset(&(AttrBuffFG[Ptr]), CurCharAttr.Fore, count);
 //		memset(&(AttrBuffBG[Ptr]), CurCharAttr.Back, count);
 
-		if (AttrBuff[LPtr+CursorRightM] & AttrKanji) {
+		if (CodeBuffW[LPtr+CursorRightM].attr & AttrKanji) {
 			CodeBuff[LPtr+CursorRightM] = 0x20;
 			BuffSetChar(&CodeBuffW[LPtr+CursorRightM], 0x20, 'H');
-			AttrBuff[LPtr+CursorRightM] &= ~AttrKanji;
+			CodeBuffW[LPtr+CursorRightM].attr &= ~AttrKanji;
 		}
 
 		LPtr = NextLinePtr(LPtr);
@@ -5720,7 +5741,7 @@
 	TmpPtr = GetLinePtr(Y);
 	LockBuffer();
 
-	if (AttrBuff[TmpPtr+X] & AttrURL)
+	if (CodeBuffW[TmpPtr+X].attr & AttrURL)
 		Result = TRUE;
 	else
 		Result = FALSE;
@@ -5771,7 +5792,7 @@
 		cs[1] = 0;
 		mb[0] = c;
 		mb[1] = 0;
-	} else if ((AttrBuff[TmpPtr+X] & AttrKanji) == 0) {
+	} else if ((CodeBuffW[TmpPtr+X].attr & AttrKanji) == 0) {
 		// not DBCS(?TODO)
 		if (_ismbblead(c)) {
 			cs[0] = '*';
@@ -5818,7 +5839,7 @@
 		aswprintf(&mb_str, L"0x%02x%02x", mb[0], mb[1]);
 	}
 	{
-		const unsigned char attr = AttrBuff[TmpPtr+X];
+		const unsigned char attr = CodeBuffW[TmpPtr+X].attr;
 		wchar_t *attr_str;
 		if (attr == 0) {
 			attr_str = _wcsdup(L"");
@@ -5930,8 +5951,8 @@
 void BuffSetCursorCharAttr(int x, int y, TCharAttr Attr)
 {
 	const LONG TmpPtr = GetLinePtr(PageStart+y);
-	AttrBuff[TmpPtr + x] = Attr.Attr;
-	AttrBuff2[TmpPtr + x] = Attr.Attr2;
+	CodeBuffW[TmpPtr + x].attr = Attr.Attr;
+	CodeBuffW[TmpPtr + x].attr2 = Attr.Attr2;
 //	AttrBuffFG[TmpPtr + x] = Attr.Fore;
 //	AttrBuffBG[TmpPtr + x] = Attr.Back;
 	CodeBuffW[TmpPtr + x].fg = Attr.Fore;
@@ -5942,8 +5963,8 @@
 {
 	const LONG TmpPtr = GetLinePtr(PageStart+y);
 	TCharAttr Attr;
-	Attr.Attr = AttrBuff[TmpPtr + x];
-	Attr.Attr2 = AttrBuff2[TmpPtr + x];
+	Attr.Attr = CodeBuffW[TmpPtr + x].attr;
+	Attr.Attr2 = CodeBuffW[TmpPtr + x].attr2;
 //	Attr.Fore = AttrBuffFG[TmpPtr + x];
 //	Attr.Back =AttrBuffBG[TmpPtr + x];
 	Attr.Fore = CodeBuffW[TmpPtr + x].fg;


Ttssh2-commit メーリングリストの案内
Back to archive index