Develop and Download Open Source Software

Tera Term

Browse Subversion Repository

/[ttssh2]/trunk/teraterm/teraterm/buffer.c

Annotation of /trunk/teraterm/teraterm/buffer.c

Parent Directory Parent Directory | Revision Log Revision Log

Revision 6803 - (hide annotations) (download) (as text)
Tue Jun 13 10:42:58 2017 UTC (6 years, 9 months ago) by doda
File MIME type: text/x-csrc
File size: 99209 byte(s) 
NO_COPYLINE_FIX マクロを廃止。常に有効。
1 maya 3227 /* Tera Term
2     Copyright(C) 1994-1998 T. Teranishi
3     All rights reserved. */
4    
5     /* TERATERM.EXE, scroll buffer routines */
6    
7     #include "teraterm.h"
8     #include "tttypes.h"
9     #include <string.h>
10 yutakapon 4707 #include <stdio.h>
11 maya 3227
12     #include "ttwinman.h"
13     #include "teraprn.h"
14     #include "vtdisp.h"
15     #include "clipboar.h"
16     #include "telnet.h"
17     #include "ttplug.h" /* TTPLUG */
18    
19     #include "buffer.h"
20    
21     // URLを強調する（石崎氏パッチ 2005/4/2）
22     #define URL_EMPHASIS 1
23    
24     #define BuffXMax TermWidthMax
25     //#define BuffYMax 100000
26     //#define BuffSizeMax 8000000
27     // スクロールバッファの最大長を拡張 (2004.11.28 yutaka)
28     #define BuffYMax 500000
29     #define BuffSizeMax (BuffYMax * 80)
30    
31     // status line
32 doda 6435 int StatusLine; //0: none 1: shown
33 doda 5324 /* top, bottom, left & right margin */
34     int CursorTop, CursorBottom, CursorLeftM, CursorRightM;
35 maya 3227 BOOL Selected;
36     BOOL Wrap;
37    
38     static WORD TabStops[256];
39     static int NTabStops;
40    
41     static WORD BuffLock = 0;
42     static HANDLE HCodeBuff = 0;
43     static HANDLE HAttrBuff = 0;
44     static HANDLE HAttrBuff2 = 0;
45     static HANDLE HAttrBuffFG = 0;
46     static HANDLE HAttrBuffBG = 0;
47    
48     static PCHAR CodeBuff; /* Character code buffer */
49     static PCHAR AttrBuff; /* Attribute buffer */
50     static PCHAR AttrBuff2; /* Color attr buffer */
51     static PCHAR AttrBuffFG; /* Foreground color attr buffer */
52     static PCHAR AttrBuffBG; /* Background color attr buffer */
53     static PCHAR CodeLine;
54     static PCHAR AttrLine;
55     static PCHAR AttrLine2;
56     static PCHAR AttrLineFG;
57     static PCHAR AttrLineBG;
58     static LONG LinePtr;
59     static LONG BufferSize;
60     static int NumOfLinesInBuff;
61     static int BuffStartAbs, BuffEndAbs;
62     static POINT SelectStart, SelectEnd, SelectEndOld;
63     static BOOL BoxSelect;
64     static POINT DblClkStart, DblClkEnd;
65    
66     static int StrChangeStart, StrChangeCount;
67    
68     static BOOL SeveralPageSelect; // add (2005.5.15 yutaka)
69    
70     static TCharAttr CurCharAttr;
71    
72 doda 3743 HANDLE SaveBuff = NULL;
73     int SaveBuffX;
74     int SaveBuffY;
75    
76 maya 3227 LONG GetLinePtr(int Line)
77     {
78 maya 3393 LONG Ptr;
79 maya 3227
80 maya 3393 Ptr = (LONG)(BuffStartAbs + Line) * (LONG)(NumOfColumns);
81     while (Ptr>=BufferSize) {
82     Ptr = Ptr - BufferSize;
83     }
84     return Ptr;
85 maya 3227 }
86    
87     LONG NextLinePtr(LONG Ptr)
88     {
89 maya 3393 Ptr = Ptr + (LONG)NumOfColumns;
90     if (Ptr >= BufferSize) {
91     Ptr = Ptr - BufferSize;
92     }
93     return Ptr;
94 maya 3227 }
95    
96     LONG PrevLinePtr(LONG Ptr)
97     {
98 maya 3393 Ptr = Ptr - (LONG)NumOfColumns;
99     if (Ptr < 0) {
100     Ptr = Ptr + BufferSize;
101     }
102     return Ptr;
103 maya 3227 }
104    
105     BOOL ChangeBuffer(int Nx, int Ny)
106     {
107 maya 3393 HANDLE HCodeNew, HAttrNew, HAttr2New, HAttrFGNew, HAttrBGNew;
108     LONG NewSize;
109     int NxCopy, NyCopy, i;
110     PCHAR CodeDest, AttrDest, AttrDest2, AttrDestFG, AttrDestBG;
111     LONG SrcPtr, DestPtr;
112     WORD LockOld;
113 maya 3227
114 maya 3393 if (Nx > BuffXMax) {
115     Nx = BuffXMax;
116     }
117     if (ts.ScrollBuffMax > BuffYMax) {
118     ts.ScrollBuffMax = BuffYMax;
119     }
120     if (Ny > ts.ScrollBuffMax) {
121     Ny = ts.ScrollBuffMax;
122     }
123 maya 3227
124 maya 3393 if ( (LONG)Nx * (LONG)Ny > BuffSizeMax ) {
125     Ny = BuffSizeMax / Nx;
126     }
127 maya 3227
128 maya 3393 NewSize = (LONG)Nx * (LONG)Ny;
129 maya 3227
130 doda 3686 HCodeNew = NULL;
131     HAttrNew = NULL;
132     HAttr2New = NULL;
133     HAttrFGNew = NULL;
134     HAttrBGNew = NULL;
135 maya 3227
136 doda 3686 if ((HCodeNew=GlobalAlloc(GMEM_MOVEABLE, NewSize)) == NULL || (CodeDest=GlobalLock(HCodeNew)) == NULL) {
137     goto allocate_error;
138 maya 3393 }
139 doda 3686 if ((HAttrNew=GlobalAlloc(GMEM_MOVEABLE, NewSize)) == NULL || (AttrDest=GlobalLock(HAttrNew)) == NULL) {
140     goto allocate_error;
141 maya 3393 }
142 doda 3686 if ((HAttr2New=GlobalAlloc(GMEM_MOVEABLE, NewSize)) == NULL || (AttrDest2=GlobalLock(HAttr2New)) == NULL) {
143     goto allocate_error;
144 maya 3393 }
145 doda 3686 if ((HAttrFGNew=GlobalAlloc(GMEM_MOVEABLE, NewSize)) == NULL || (AttrDestFG=GlobalLock(HAttrFGNew)) == NULL) {
146     goto allocate_error;
147 maya 3393 }
148 doda 3686 if ((HAttrBGNew=GlobalAlloc(GMEM_MOVEABLE, NewSize)) == NULL || (AttrDestBG=GlobalLock(HAttrBGNew)) == NULL) {
149     goto allocate_error;
150 maya 3393 }
151 maya 3227
152 maya 3393 memset(&CodeDest[0], 0x20, NewSize);
153     memset(&AttrDest[0], AttrDefault, NewSize);
154     memset(&AttrDest2[0], AttrDefault, NewSize);
155     memset(&AttrDestFG[0], AttrDefaultFG, NewSize);
156     memset(&AttrDestBG[0], AttrDefaultBG, NewSize);
157     if ( HCodeBuff!=0 ) {
158     if ( NumOfColumns > Nx ) {
159     NxCopy = Nx;
160     }
161     else {
162     NxCopy = NumOfColumns;
163     }
164 maya 3227
165 maya 3393 if ( BuffEnd > Ny ) {
166     NyCopy = Ny;
167     }
168     else {
169     NyCopy = BuffEnd;
170     }
171     LockOld = BuffLock;
172     LockBuffer();
173     SrcPtr = GetLinePtr(BuffEnd-NyCopy);
174     DestPtr = 0;
175     for (i = 1 ; i <= NyCopy ; i++) {
176     memcpy(&CodeDest[DestPtr],&CodeBuff[SrcPtr],NxCopy);
177     memcpy(&AttrDest[DestPtr],&AttrBuff[SrcPtr],NxCopy);
178     memcpy(&AttrDest2[DestPtr],&AttrBuff2[SrcPtr],NxCopy);
179     memcpy(&AttrDestFG[DestPtr],&AttrBuffFG[SrcPtr],NxCopy);
180     memcpy(&AttrDestBG[DestPtr],&AttrBuffBG[SrcPtr],NxCopy);
181 doda 3766 if (AttrDest[DestPtr+NxCopy-1] & AttrKanji) {
182     CodeDest[DestPtr+NxCopy-1] = ' ';
183     AttrDest[DestPtr+NxCopy-1] ^= AttrKanji;
184     }
185 maya 3393 SrcPtr = NextLinePtr(SrcPtr);
186     DestPtr = DestPtr + (LONG)Nx;
187     }
188     FreeBuffer();
189     }
190     else {
191     LockOld = 0;
192     NyCopy = NumOfLines;
193     Selected = FALSE;
194     }
195 maya 3227
196 maya 3393 if (Selected) {
197     SelectStart.y = SelectStart.y - BuffEnd + NyCopy;
198     SelectEnd.y = SelectEnd.y - BuffEnd + NyCopy;
199     if (SelectStart.y < 0) {
200     SelectStart.y = 0;
201     SelectStart.x = 0;
202     }
203     if (SelectEnd.y<0) {
204     SelectEnd.x = 0;
205     SelectEnd.y = 0;
206     }
207 maya 3227
208 maya 3393 Selected = (SelectEnd.y > SelectStart.y) ||
209     ((SelectEnd.y=SelectStart.y) &&
210     (SelectEnd.x > SelectStart.x));
211     }
212 maya 3227
213 maya 3393 HCodeBuff = HCodeNew;
214     HAttrBuff = HAttrNew;
215     HAttrBuff2 = HAttr2New;
216     HAttrBuffFG = HAttrFGNew;
217     HAttrBuffBG = HAttrBGNew;
218     BufferSize = NewSize;
219     NumOfLinesInBuff = Ny;
220     BuffStartAbs = 0;
221     BuffEnd = NyCopy;
222 maya 3227
223 maya 3393 if (BuffEnd==NumOfLinesInBuff) {
224     BuffEndAbs = 0;
225     }
226     else {
227     BuffEndAbs = BuffEnd;
228     }
229 maya 3227
230 maya 3393 PageStart = BuffEnd - NumOfLines;
231    
232     LinePtr = 0;
233     if (LockOld>0) {
234     CodeBuff = (PCHAR)GlobalLock(HCodeBuff);
235     AttrBuff = (PCHAR)GlobalLock(HAttrBuff);
236     AttrBuff2 = (PCHAR)GlobalLock(HAttrBuff2);
237     AttrBuffFG = (PCHAR)GlobalLock(HAttrBuffFG);
238     AttrBuffBG = (PCHAR)GlobalLock(HAttrBuffBG);
239     CodeLine = CodeBuff;
240     AttrLine = AttrBuff;
241     AttrLine2 = AttrBuff2;
242     AttrLineFG = AttrBuffFG;
243     AttrLineBG = AttrBuffBG;
244     }
245     else {
246     GlobalUnlock(HCodeNew);
247     GlobalUnlock(HAttrNew);
248 doda 3621 GlobalUnlock(HAttr2New);
249     GlobalUnlock(HAttrFGNew);
250     GlobalUnlock(HAttrBGNew);
251 maya 3393 }
252     BuffLock = LockOld;
253    
254     return TRUE;
255 doda 3686
256     allocate_error:
257     if (CodeDest) GlobalUnlock(HCodeNew);
258     if (AttrDest) GlobalUnlock(HAttrNew);
259     if (AttrDest2) GlobalUnlock(HAttr2New);
260     if (AttrDestFG) GlobalUnlock(HAttrFGNew);
261     if (AttrDestBG) GlobalUnlock(HAttrBGNew);
262     if (HCodeNew) GlobalFree(HCodeNew);
263     if (HAttrNew) GlobalFree(HAttrNew);
264     if (HAttr2New) GlobalFree(HAttr2New);
265     if (HAttrFGNew) GlobalFree(HAttrFGNew);
266     if (HAttrBGNew) GlobalFree(HAttrBGNew);
267     return FALSE;
268 maya 3227 }
269    
270     void InitBuffer()
271     {
272 maya 3393 int Ny;
273 maya 3227
274 maya 3393 /* setup terminal */
275     NumOfColumns = ts.TerminalWidth;
276     NumOfLines = ts.TerminalHeight;
277 maya 3227
278 doda 6785 if (NumOfColumns <= 0)
279     NumOfColumns = 80;
280     else if (NumOfColumns > TermWidthMax)
281     NumOfColumns = TermWidthMax;
282    
283     if (NumOfLines <= 0)
284     NumOfLines = 24;
285     else if (NumOfLines > TermHeightMax)
286     NumOfLines = TermHeightMax;
287    
288 maya 3393 /* setup window */
289     if (ts.EnableScrollBuff>0) {
290     if (ts.ScrollBuffSize < NumOfLines) {
291     ts.ScrollBuffSize = NumOfLines;
292     }
293     Ny = ts.ScrollBuffSize;
294     }
295     else {
296     Ny = NumOfLines;
297     }
298 maya 3227
299 maya 3393 if (! ChangeBuffer(NumOfColumns,Ny)) {
300     PostQuitMessage(0);
301     }
302 maya 3227
303 maya 3393 if (ts.EnableScrollBuff>0) {
304     ts.ScrollBuffSize = NumOfLinesInBuff;
305     }
306 maya 3227
307 maya 3393 StatusLine = 0;
308 maya 3227 }
309    
310     void NewLine(int Line)
311     {
312 maya 3393 LinePtr = GetLinePtr(Line);
313     CodeLine = &CodeBuff[LinePtr];
314     AttrLine = &AttrBuff[LinePtr];
315     AttrLine2 = &AttrBuff2[LinePtr];
316     AttrLineFG = &AttrBuffFG[LinePtr];
317     AttrLineBG = &AttrBuffBG[LinePtr];
318 maya 3227 }
319    
320     void LockBuffer()
321     {
322 maya 3393 BuffLock++;
323     if (BuffLock>1) {
324     return;
325     }
326     CodeBuff = (PCHAR)GlobalLock(HCodeBuff);
327     AttrBuff = (PCHAR)GlobalLock(HAttrBuff);
328     AttrBuff2 = (PCHAR)GlobalLock(HAttrBuff2);
329     AttrBuffFG = (PCHAR)GlobalLock(HAttrBuffFG);
330     AttrBuffBG = (PCHAR)GlobalLock(HAttrBuffBG);
331     NewLine(PageStart+CursorY);
332 maya 3227 }
333    
334     void UnlockBuffer()
335     {
336 maya 3393 if (BuffLock==0) {
337     return;
338     }
339     BuffLock--;
340     if (BuffLock>0) {
341     return;
342     }
343     if (HCodeBuff!=NULL) {
344     GlobalUnlock(HCodeBuff);
345     }
346     if (HAttrBuff!=NULL) {
347     GlobalUnlock(HAttrBuff);
348     }
349     if (HAttrBuff2!=NULL) {
350     GlobalUnlock(HAttrBuff2);
351     }
352     if (HAttrBuffFG!=NULL) {
353     GlobalUnlock(HAttrBuffFG);
354     }
355     if (HAttrBuffBG!=NULL) {
356     GlobalUnlock(HAttrBuffBG);
357     }
358 maya 3227 }
359    
360     void FreeBuffer()
361     {
362 maya 3393 BuffLock = 1;
363     UnlockBuffer();
364     if (HCodeBuff!=NULL) {
365     GlobalFree(HCodeBuff);
366     HCodeBuff = NULL;
367     }
368     if (HAttrBuff!=NULL) {
369     GlobalFree(HAttrBuff);
370     HAttrBuff = NULL;
371     }
372     if (HAttrBuff2!=NULL) {
373     GlobalFree(HAttrBuff2);
374     HAttrBuff2 = NULL;
375     }
376     if (HAttrBuffFG!=NULL) {
377     GlobalFree(HAttrBuffFG);
378     HAttrBuffFG = NULL;
379     }
380     if (HAttrBuffBG!=NULL) {
381     GlobalFree(HAttrBuffBG);
382     HAttrBuffBG = NULL;
383     }
384 maya 3227 }
385    
386     void BuffAllSelect()
387     {
388     SelectStart.x = 0;
389     SelectStart.y = 0;
390     SelectEnd.x = 0;
391     SelectEnd.y = BuffEnd;
392     // SelectEnd.x = NumOfColumns;
393     // SelectEnd.y = BuffEnd - 1;
394     }
395    
396     void BuffScreenSelect()
397     {
398     int X, Y;
399     DispConvWinToScreen(0, 0, &X, &Y, NULL);
400     SelectStart.x = X;
401     SelectStart.y = Y + PageStart;
402     SelectEnd.x = 0;
403     SelectEnd.y = SelectStart.y + NumOfLines;
404     // SelectEnd.x = X + NumOfColumns;
405     // SelectEnd.y = Y + PageStart + NumOfLines - 1;
406     }
407    
408     void BuffCancelSelection()
409     {
410     SelectStart.x = 0;
411     SelectStart.y = 0;
412     SelectEnd.x = 0;
413     SelectEnd.y = 0;
414     }
415    
416     void BuffReset()
417     // Reset buffer status. don't update real display
418     // called by ResetTerminal()
419     {
420 maya 3393 int i;
421 maya 3227
422 maya 3393 /* Cursor */
423     NewLine(PageStart);
424     WinOrgX = 0;
425     WinOrgY = 0;
426     NewOrgX = 0;
427     NewOrgY = 0;
428 maya 3227
429 maya 3393 /* Top/bottom margin */
430     CursorTop = 0;
431     CursorBottom = NumOfLines-1;
432 doda 5324 CursorLeftM = 0;
433     CursorRightM = NumOfColumns-1;
434 maya 3227
435 maya 3393 /* Tab stops */
436     NTabStops = (NumOfColumns-1) >> 3;
437     for (i=1 ; i<=NTabStops ; i++) {
438     TabStops[i-1] = i*8;
439     }
440 maya 3227
441 maya 3393 /* Initialize text selection region */
442     SelectStart.x = 0;
443     SelectStart.y = 0;
444     SelectEnd = SelectStart;
445     SelectEndOld = SelectStart;
446     Selected = FALSE;
447 maya 3227
448 maya 3393 StrChangeCount = 0;
449     Wrap = FALSE;
450     StatusLine = 0;
451 maya 3227
452 maya 3393 SeveralPageSelect = FALSE; // yutaka
453 doda 3745
454     /* Alternate Screen Buffer */
455     BuffDiscardSavedScreen();
456 maya 3227 }
457    
458     void BuffScroll(int Count, int Bottom)
459     {
460 maya 3393 int i, n;
461     LONG SrcPtr, DestPtr;
462     int BuffEndOld;
463 maya 3227
464 maya 3393 if (Count>NumOfLinesInBuff) {
465     Count = NumOfLinesInBuff;
466     }
467 maya 3227
468 maya 3393 DestPtr = GetLinePtr(PageStart+NumOfLines-1+Count);
469     n = Count;
470     if (Bottom<NumOfLines-1) {
471     SrcPtr = GetLinePtr(PageStart+NumOfLines-1);
472     for (i=NumOfLines-1; i>=Bottom+1; i--) {
473     memcpy(&(CodeBuff[DestPtr]),&(CodeBuff[SrcPtr]),NumOfColumns);
474     memcpy(&(AttrBuff[DestPtr]),&(AttrBuff[SrcPtr]),NumOfColumns);
475     memcpy(&(AttrBuff2[DestPtr]),&(AttrBuff2[SrcPtr]),NumOfColumns);
476     memcpy(&(AttrBuffFG[DestPtr]),&(AttrBuffFG[SrcPtr]),NumOfColumns);
477     memcpy(&(AttrBuffBG[DestPtr]),&(AttrBuffBG[SrcPtr]),NumOfColumns);
478     memset(&(CodeBuff[SrcPtr]),0x20,NumOfColumns);
479     memset(&(AttrBuff[SrcPtr]),AttrDefault,NumOfColumns);
480 doda 4070 memset(&(AttrBuff2[SrcPtr]),CurCharAttr.Attr2 & Attr2ColorMask, NumOfColumns);
481 maya 3393 memset(&(AttrBuffFG[SrcPtr]),CurCharAttr.Fore,NumOfColumns);
482     memset(&(AttrBuffBG[SrcPtr]),CurCharAttr.Back,NumOfColumns);
483     SrcPtr = PrevLinePtr(SrcPtr);
484     DestPtr = PrevLinePtr(DestPtr);
485     n--;
486     }
487     }
488     for (i = 1 ; i <= n ; i++) {
489     memset(&CodeBuff[DestPtr],0x20,NumOfColumns);
490     memset(&AttrBuff[DestPtr],AttrDefault,NumOfColumns);
491 doda 4070 memset(&AttrBuff2[DestPtr],CurCharAttr.Attr2 & Attr2ColorMask, NumOfColumns);
492 maya 3393 memset(&AttrBuffFG[DestPtr],CurCharAttr.Fore,NumOfColumns);
493     memset(&AttrBuffBG[DestPtr],CurCharAttr.Back,NumOfColumns);
494     DestPtr = PrevLinePtr(DestPtr);
495     }
496 maya 3227
497 maya 3393 BuffEndAbs = BuffEndAbs + Count;
498     if (BuffEndAbs >= NumOfLinesInBuff) {
499     BuffEndAbs = BuffEndAbs - NumOfLinesInBuff;
500     }
501     BuffEndOld = BuffEnd;
502     BuffEnd = BuffEnd + Count;
503     if (BuffEnd >= NumOfLinesInBuff) {
504     BuffEnd = NumOfLinesInBuff;
505     BuffStartAbs = BuffEndAbs;
506     }
507     PageStart = BuffEnd-NumOfLines;
508 maya 3227
509 maya 3393 if (Selected) {
510     SelectStart.y = SelectStart.y - Count + BuffEnd - BuffEndOld;
511     SelectEnd.y = SelectEnd.y - Count + BuffEnd - BuffEndOld;
512     if ( SelectStart.y<0 ) {
513     SelectStart.x = 0;
514     SelectStart.y = 0;
515     }
516     if ( SelectEnd.y<0 ) {
517     SelectEnd.x = 0;
518     SelectEnd.y = 0;
519     }
520     Selected = (SelectEnd.y > SelectStart.y) ||
521     ((SelectEnd.y==SelectStart.y) &&
522     (SelectEnd.x > SelectStart.x));
523     }
524 maya 3227
525 maya 3393 NewLine(PageStart+CursorY);
526 maya 3227 }
527    
528     void NextLine()
529     {
530 maya 3393 LinePtr = NextLinePtr(LinePtr);
531     CodeLine = &CodeBuff[LinePtr];
532     AttrLine = &AttrBuff[LinePtr];
533     AttrLine2 = &AttrBuff2[LinePtr];
534     AttrLineFG = &AttrBuffFG[LinePtr];
535     AttrLineBG = &AttrBuffBG[LinePtr];
536 maya 3227 }
537    
538     void PrevLine()
539     {
540 maya 3393 LinePtr = PrevLinePtr(LinePtr);
541     CodeLine = &CodeBuff[LinePtr];
542     AttrLine = &AttrBuff[LinePtr];
543     AttrLine2 = &AttrBuff2[LinePtr];
544     AttrLineFG = &AttrBuffFG[LinePtr];
545     AttrLineBG = &AttrBuffBG[LinePtr];
546 maya 3227 }
547    
548     void EraseKanji(int LR)
549     {
550     // If cursor is on left/right half of a Kanji, erase it.
551     // LR: left(0)/right(1) flag
552    
553 maya 3393 if ((CursorX-LR>=0) &&
554     ((AttrLine[CursorX-LR] & AttrKanji) != 0)) {
555     CodeLine[CursorX-LR] = 0x20;
556     AttrLine[CursorX-LR] = CurCharAttr.Attr;
557     AttrLine2[CursorX-LR] = CurCharAttr.Attr2;
558     AttrLineFG[CursorX-LR] = CurCharAttr.Fore;
559     AttrLineBG[CursorX-LR] = CurCharAttr.Back;
560     if (CursorX-LR+1 < NumOfColumns) {
561     CodeLine[CursorX-LR+1] = 0x20;
562     AttrLine[CursorX-LR+1] = CurCharAttr.Attr;
563     AttrLine2[CursorX-LR+1] = CurCharAttr.Attr2;
564     AttrLineFG[CursorX-LR+1] = CurCharAttr.Fore;
565     AttrLineBG[CursorX-LR+1] = CurCharAttr.Back;
566     }
567     }
568 maya 3227 }
569    
570 doda 5371 void EraseKanjiOnLRMargin(LONG ptr, int count)
571     {
572     int i;
573     LONG pos;
574    
575     if (count < 1)
576     return;
577    
578     for (i=0; i<count; i++) {
579     pos = ptr + CursorLeftM-1;
580     if (CursorLeftM>0 && (AttrBuff[pos] & AttrKanji)) {
581     CodeBuff[pos] = 0x20;
582     AttrBuff[pos] &= ~AttrKanji;
583     pos++;
584     CodeBuff[pos] = 0x20;
585     AttrBuff[pos] &= ~AttrKanji;
586     }
587     pos = ptr + CursorRightM;
588     if (CursorRightM < NumOfColumns-1 && (AttrBuff[pos] & AttrKanji)) {
589     CodeBuff[pos] = 0x20;
590     AttrBuff[pos] &= ~AttrKanji;
591     pos++;
592     CodeBuff[pos] = 0x20;
593     AttrBuff[pos] &= ~AttrKanji;
594     }
595     ptr = NextLinePtr(ptr);
596     }
597     }
598    
599 maya 3227 void BuffInsertSpace(int Count)
600     // Insert space characters at the current position
601     // Count: Number of characters to be inserted
602     {
603 doda 5326 int MoveLen;
604 doda 5371 int extr=0;
605 doda 5324
606 doda 5326 if (CursorX < CursorLeftM || CursorX > CursorRightM)
607     return;
608    
609 maya 3393 NewLine(PageStart+CursorY);
610 maya 3227
611 doda 5324 if (ts.Language==IdJapanese || ts.Language==IdKorean || ts.Language==IdUtf8)
612 maya 3393 EraseKanji(1); /* if cursor is on right half of a kanji, erase the kanji */
613 maya 3227
614 doda 5371 if (CursorRightM < NumOfColumns-1 && (AttrLine[CursorRightM] & AttrKanji)) {
615     CodeLine[CursorRightM+1] = 0x20;
616     AttrLine[CursorRightM+1] &= ~AttrKanji;
617     extr = 1;
618     }
619    
620 doda 5326 if (Count > CursorRightM + 1 - CursorX)
621     Count = CursorRightM + 1 - CursorX;
622 doda 5324
623 doda 5326 MoveLen = CursorRightM + 1 - CursorX - Count;
624 doda 5324
625     if (MoveLen > 0) {
626     memmove(&(CodeLine[CursorX+Count]), &(CodeLine[CursorX]), MoveLen);
627     memmove(&(AttrLine[CursorX+Count]), &(AttrLine[CursorX]), MoveLen);
628     memmove(&(AttrLine2[CursorX+Count]), &(AttrLine2[CursorX]), MoveLen);
629     memmove(&(AttrLineFG[CursorX+Count]), &(AttrLineFG[CursorX]), MoveLen);
630     memmove(&(AttrLineBG[CursorX+Count]), &(AttrLineBG[CursorX]), MoveLen);
631 maya 3393 }
632 doda 5324 memset(&(CodeLine[CursorX]), 0x20, Count);
633     memset(&(AttrLine[CursorX]), AttrDefault, Count);
634     memset(&(AttrLine2[CursorX]), CurCharAttr.Attr2 & Attr2ColorMask, Count);
635     memset(&(AttrLineFG[CursorX]), CurCharAttr.Fore, Count);
636     memset(&(AttrLineBG[CursorX]), CurCharAttr.Back, Count);
637 maya 3393 /* last char in current line is kanji first? */
638 doda 5326 if ((AttrLine[CursorRightM] & AttrKanji) != 0) {
639 maya 3393 /* then delete it */
640 doda 5326 CodeLine[CursorRightM] = 0x20;
641 doda 5371 AttrLine[CursorRightM] &= ~AttrKanji;
642 maya 3393 }
643 doda 5371 BuffUpdateRect(CursorX, CursorY, CursorRightM+extr, CursorY);
644 maya 3227 }
645    
646     void BuffEraseCurToEnd()
647     // Erase characters from cursor to the end of screen
648     {
649 maya 3393 LONG TmpPtr;
650     int offset;
651     int i, YEnd;
652 maya 3227
653 maya 3393 NewLine(PageStart+CursorY);
654 doda 3416 if (ts.Language==IdJapanese || ts.Language==IdKorean || ts.Language==IdUtf8) {
655 maya 3393 EraseKanji(1); /* if cursor is on right half of a kanji, erase the kanji */
656     }
657     offset = CursorX;
658     TmpPtr = GetLinePtr(PageStart+CursorY);
659     YEnd = NumOfLines-1;
660 doda 5324 if (StatusLine && !isCursorOnStatusLine) {
661 maya 3393 YEnd--;
662     }
663     for (i = CursorY ; i <= YEnd ; i++) {
664     memset(&(CodeBuff[TmpPtr+offset]),0x20,NumOfColumns-offset);
665     memset(&(AttrBuff[TmpPtr+offset]),AttrDefault,NumOfColumns-offset);
666 doda 4070 memset(&(AttrBuff2[TmpPtr+offset]),CurCharAttr.Attr2 & Attr2ColorMask, NumOfColumns-offset);
667 maya 3393 memset(&(AttrBuffFG[TmpPtr+offset]),CurCharAttr.Fore,NumOfColumns-offset);
668     memset(&(AttrBuffBG[TmpPtr+offset]),CurCharAttr.Back,NumOfColumns-offset);
669     offset = 0;
670     TmpPtr = NextLinePtr(TmpPtr);
671     }
672     /* update window */
673     DispEraseCurToEnd(YEnd);
674 maya 3227 }
675    
676     void BuffEraseHomeToCur()
677     // Erase characters from home to cursor
678     {
679 maya 3393 LONG TmpPtr;
680     int offset;
681     int i, YHome;
682 maya 3227
683 maya 3393 NewLine(PageStart+CursorY);
684 doda 3416 if (ts.Language==IdJapanese || ts.Language==IdKorean || ts.Language==IdUtf8) {
685 maya 3393 EraseKanji(0); /* if cursor is on left half of a kanji, erase the kanji */
686     }
687     offset = NumOfColumns;
688 doda 5324 if (isCursorOnStatusLine) {
689 maya 3393 YHome = CursorY;
690     }
691     else {
692     YHome = 0;
693     }
694     TmpPtr = GetLinePtr(PageStart+YHome);
695     for (i = YHome ; i <= CursorY ; i++) {
696     if (i==CursorY) {
697     offset = CursorX+1;
698     }
699     memset(&(CodeBuff[TmpPtr]),0x20,offset);
700     memset(&(AttrBuff[TmpPtr]),AttrDefault,offset);
701 doda 4070 memset(&(AttrBuff2[TmpPtr]),CurCharAttr.Attr2 & Attr2ColorMask, offset);
702 maya 3393 memset(&(AttrBuffFG[TmpPtr]),CurCharAttr.Fore,offset);
703     memset(&(AttrBuffBG[TmpPtr]),CurCharAttr.Back,offset);
704     TmpPtr = NextLinePtr(TmpPtr);
705     }
706 maya 3227
707 maya 3393 /* update window */
708     DispEraseHomeToCur(YHome);
709 maya 3227 }
710    
711     void BuffInsertLines(int Count, int YEnd)
712     // Insert lines at current position
713     // Count: number of lines to be inserted
714     // YEnd: bottom line number of scroll region (screen coordinate)
715     {
716 doda 5324 int i, linelen;
717 doda 5371 int extl=0, extr=0;
718 maya 3393 LONG SrcPtr, DestPtr;
719 maya 3227
720 maya 3393 BuffUpdateScroll();
721 maya 3227
722 doda 5371 if (CursorLeftM > 0)
723     extl = 1;
724     if (CursorRightM < NumOfColumns-1)
725     extr = 1;
726     if (extl || extr)
727     EraseKanjiOnLRMargin(GetLinePtr(PageStart+CursorY), YEnd-CursorY+1);
728    
729 doda 5324 SrcPtr = GetLinePtr(PageStart+YEnd-Count) + CursorLeftM;
730     DestPtr = GetLinePtr(PageStart+YEnd) + CursorLeftM;
731     linelen = CursorRightM - CursorLeftM + 1;
732 maya 3393 for (i= YEnd-Count ; i>=CursorY ; i--) {
733 doda 5324 memcpy(&(CodeBuff[DestPtr]), &(CodeBuff[SrcPtr]), linelen);
734     memcpy(&(AttrBuff[DestPtr]), &(AttrBuff[SrcPtr]), linelen);
735     memcpy(&(AttrBuff2[DestPtr]), &(AttrBuff2[SrcPtr]), linelen);
736     memcpy(&(AttrBuffFG[DestPtr]), &(AttrBuffFG[SrcPtr]), linelen);
737     memcpy(&(AttrBuffBG[DestPtr]), &(AttrBuffBG[SrcPtr]), linelen);
738 maya 3393 SrcPtr = PrevLinePtr(SrcPtr);
739     DestPtr = PrevLinePtr(DestPtr);
740     }
741     for (i = 1 ; i <= Count ; i++) {
742 doda 5324 memset(&(CodeBuff[DestPtr]), 0x20, linelen);
743     memset(&(AttrBuff[DestPtr]), AttrDefault, linelen);
744     memset(&(AttrBuff2[DestPtr]), CurCharAttr.Attr2 & Attr2ColorMask, linelen);
745     memset(&(AttrBuffFG[DestPtr]), CurCharAttr.Fore, linelen);
746     memset(&(AttrBuffBG[DestPtr]), CurCharAttr.Back, linelen);
747 maya 3393 DestPtr = PrevLinePtr(DestPtr);
748     }
749 maya 3227
750 doda 5324 if (CursorLeftM > 0 || CursorRightM < NumOfColumns-1 || !DispInsertLines(Count, YEnd)) {
751 doda 5371 BuffUpdateRect(CursorLeftM-extl, CursorY, CursorRightM+extr, YEnd);
752 maya 3393 }
753 maya 3227 }
754    
755     void BuffEraseCharsInLine(int XStart, int Count)
756     // erase characters in the current line
757     // XStart: start position of erasing
758     // Count: number of characters to be erased
759     {
760 maya 3393 BOOL LineContinued=FALSE;
761 doda 3312
762 maya 3393 if (ts.EnableContinuedLineCopy && XStart == 0 && (AttrLine[0] & AttrLineContinued)) {
763     LineContinued = TRUE;
764     }
765 doda 3312
766 doda 3416 if (ts.Language==IdJapanese || ts.Language==IdKorean || ts.Language==IdUtf8) {
767 maya 3393 EraseKanji(1); /* if cursor is on right half of a kanji, erase the kanji */
768     }
769 maya 3227
770 maya 3393 NewLine(PageStart+CursorY);
771     memset(&(CodeLine[XStart]),0x20,Count);
772     memset(&(AttrLine[XStart]),AttrDefault,Count);
773 doda 4070 memset(&(AttrLine2[XStart]),CurCharAttr.Attr2 & Attr2ColorMask, Count);
774 maya 3393 memset(&(AttrLineFG[XStart]),CurCharAttr.Fore,Count);
775     memset(&(AttrLineBG[XStart]),CurCharAttr.Back,Count);
776 maya 3227
777 maya 3393 if (ts.EnableContinuedLineCopy) {
778     if (LineContinued) {
779     BuffLineContinued(TRUE);
780     }
781    
782     if (XStart + Count >= NumOfColumns) {
783     AttrBuff[NextLinePtr(LinePtr)] &= ~AttrLineContinued;
784     }
785     }
786 doda 3312
787 maya 3393 DispEraseCharsInLine(XStart, Count);
788 maya 3227 }
789    
790     void BuffDeleteLines(int Count, int YEnd)
791     // Delete lines from current line
792     // Count: number of lines to be deleted
793     // YEnd: bottom line number of scroll region (screen coordinate)
794     {
795 doda 5324 int i, linelen;
796 doda 5371 int extl=0, extr=0;
797 maya 3393 LONG SrcPtr, DestPtr;
798 maya 3227
799 maya 3393 BuffUpdateScroll();
800 maya 3227
801 doda 5371 if (CursorLeftM > 0)
802     extl = 1;
803     if (CursorRightM < NumOfColumns-1)
804     extr = 1;
805     if (extl || extr)
806     EraseKanjiOnLRMargin(GetLinePtr(PageStart+CursorY), YEnd-CursorY+1);
807    
808 doda 5324 SrcPtr = GetLinePtr(PageStart+CursorY+Count) + (LONG)CursorLeftM;
809     DestPtr = GetLinePtr(PageStart+CursorY) + (LONG)CursorLeftM;
810     linelen = CursorRightM - CursorLeftM + 1;
811 maya 3393 for (i=CursorY ; i<= YEnd-Count ; i++) {
812 doda 5324 memcpy(&(CodeBuff[DestPtr]), &(CodeBuff[SrcPtr]), linelen);
813     memcpy(&(AttrBuff[DestPtr]), &(AttrBuff[SrcPtr]), linelen);
814     memcpy(&(AttrBuff2[DestPtr]), &(AttrBuff2[SrcPtr]), linelen);
815     memcpy(&(AttrBuffFG[DestPtr]), &(AttrBuffFG[SrcPtr]), linelen);
816     memcpy(&(AttrBuffBG[DestPtr]), &(AttrBuffBG[SrcPtr]), linelen);
817 maya 3393 SrcPtr = NextLinePtr(SrcPtr);
818     DestPtr = NextLinePtr(DestPtr);
819     }
820     for (i = YEnd+1-Count ; i<=YEnd ; i++) {
821 doda 5324 memset(&(CodeBuff[DestPtr]), 0x20, linelen);
822     memset(&(AttrBuff[DestPtr]), AttrDefault, linelen);
823     memset(&(AttrBuff2[DestPtr]), CurCharAttr.Attr2 & Attr2ColorMask, linelen);
824     memset(&(AttrBuffFG[DestPtr]), CurCharAttr.Fore, linelen);
825     memset(&(AttrBuffBG[DestPtr]), CurCharAttr.Back, linelen);
826 maya 3393 DestPtr = NextLinePtr(DestPtr);
827     }
828 maya 3227
829 doda 5324 if (CursorLeftM > 0 || CursorRightM < NumOfColumns-1 || ! DispDeleteLines(Count,YEnd)) {
830 doda 5371 BuffUpdateRect(CursorLeftM-extl, CursorY, CursorRightM+extr, YEnd);
831 maya 3393 }
832 maya 3227 }
833    
834     void BuffDeleteChars(int Count)
835     // Delete characters in current line from cursor
836     // Count: number of characters to be deleted
837     {
838 doda 5325 int MoveLen;
839 doda 5371 int extr=0;
840 doda 5325
841     if (CursorX < CursorLeftM || CursorX > CursorRightM)
842     return;
843    
844 maya 3393 NewLine(PageStart+CursorY);
845 maya 3227
846 doda 3416 if (ts.Language==IdJapanese || ts.Language==IdKorean || ts.Language==IdUtf8) {
847 maya 3393 EraseKanji(0); /* if cursor is on left harf of a kanji, erase the kanji */
848     EraseKanji(1); /* if cursor on right half... */
849     }
850 maya 3227
851 doda 5371 if (CursorRightM < NumOfColumns-1 && (AttrLine[CursorRightM] & AttrKanji)) {
852     CodeLine[CursorRightM] = 0x20;
853     AttrLine[CursorRightM] &= ~AttrKanji;
854     CodeLine[CursorRightM+1] = 0x20;
855     AttrLine[CursorRightM+1] &= ~AttrKanji;
856     extr = 1;
857     }
858    
859 doda 5325 if (Count > CursorRightM + 1 - CursorX)
860     Count = CursorRightM + 1 - CursorX;
861    
862     MoveLen = CursorRightM + 1 - CursorX - Count;
863    
864     if (MoveLen > 0) {
865     memmove(&(CodeLine[CursorX]), &(CodeLine[CursorX+Count]), MoveLen);
866     memmove(&(AttrLine[CursorX]), &(AttrLine[CursorX+Count]), MoveLen);
867     memmove(&(AttrLine2[CursorX]), &(AttrLine2[CursorX+Count]), MoveLen);
868     memmove(&(AttrLineFG[CursorX]), &(AttrLineFG[CursorX+Count]), MoveLen);
869     memmove(&(AttrLineBG[CursorX]), &(AttrLineBG[CursorX+Count]), MoveLen);
870 maya 3393 }
871 doda 5325 memset(&(CodeLine[CursorX + MoveLen]), 0x20, Count);
872     memset(&(AttrLine[CursorX + MoveLen]), AttrDefault, Count);
873     memset(&(AttrLine2[CursorX + MoveLen]), CurCharAttr.Attr2 & Attr2ColorMask, Count);
874     memset(&(AttrLineFG[CursorX + MoveLen]), CurCharAttr.Fore, Count);
875     memset(&(AttrLineBG[CursorX + MoveLen]), CurCharAttr.Back, Count);
876 maya 3227
877 doda 5371 BuffUpdateRect(CursorX, CursorY, CursorRightM+extr, CursorY);
878 maya 3227 }
879    
880     void BuffEraseChars(int Count)
881     // Erase characters in current line from cursor
882     // Count: number of characters to be deleted
883     {
884 maya 3393 NewLine(PageStart+CursorY);
885 maya 3227
886 doda 3416 if (ts.Language==IdJapanese || ts.Language==IdKorean || ts.Language==IdUtf8) {
887 maya 3393 EraseKanji(0); /* if cursor is on left harf of a kanji, erase the kanji */
888     EraseKanji(1); /* if cursor on right half... */
889     }
890 maya 3227
891 maya 3393 if (Count > NumOfColumns-CursorX) {
892     Count = NumOfColumns-CursorX;
893     }
894     memset(&(CodeLine[CursorX]),0x20,Count);
895     memset(&(AttrLine[CursorX]),AttrDefault,Count);
896 doda 4070 memset(&(AttrLine2[CursorX]),CurCharAttr.Attr2 & Attr2ColorMask, Count);
897 maya 3393 memset(&(AttrLineFG[CursorX]),CurCharAttr.Fore,Count);
898     memset(&(AttrLineBG[CursorX]),CurCharAttr.Back,Count);
899 maya 3227
900 maya 3393 /* update window */
901     DispEraseCharsInLine(CursorX,Count);
902 maya 3227 }
903    
904     void BuffFillWithE()
905     // Fill screen with 'E' characters
906     {
907 maya 3393 LONG TmpPtr;
908     int i;
909 maya 3227
910 maya 3393 TmpPtr = GetLinePtr(PageStart);
911     for (i = 0 ; i <= NumOfLines-1-StatusLine ; i++) {
912     memset(&(CodeBuff[TmpPtr]),'E',NumOfColumns);
913     memset(&(AttrBuff[TmpPtr]),AttrDefault,NumOfColumns);
914     memset(&(AttrBuff2[TmpPtr]),AttrDefault,NumOfColumns);
915     memset(&(AttrBuffFG[TmpPtr]),AttrDefaultFG,NumOfColumns);
916     memset(&(AttrBuffBG[TmpPtr]),AttrDefaultBG,NumOfColumns);
917     TmpPtr = NextLinePtr(TmpPtr);
918     }
919     BuffUpdateRect(WinOrgX,WinOrgY,WinOrgX+WinWidth-1,WinOrgY+WinHeight-1);
920 maya 3227 }
921    
922     void BuffDrawLine(TCharAttr Attr, int Direction, int C)
923     { // IO-8256 terminal
924 maya 3393 LONG Ptr;
925     int i, X, Y;
926 maya 3227
927 maya 3393 if (C==0) {
928     return;
929     }
930     Attr.Attr |= AttrSpecial;
931 maya 3227
932 maya 3393 switch (Direction) {
933     case 3:
934     case 4:
935     if (Direction==3) {
936     if (CursorY==0) {
937     return;
938     }
939     Y = CursorY-1;
940     }
941     else {
942     if (CursorY==NumOfLines-1-StatusLine) {
943     return;
944     }
945     Y = CursorY+1;
946     }
947     if (CursorX+C > NumOfColumns) {
948     C = NumOfColumns-CursorX;
949     }
950     Ptr = GetLinePtr(PageStart+Y);
951     memset(&(CodeBuff[Ptr+CursorX]),'q',C);
952     memset(&(AttrBuff[Ptr+CursorX]),Attr.Attr,C);
953     memset(&(AttrBuff2[Ptr+CursorX]),Attr.Attr2,C);
954     memset(&(AttrBuffFG[Ptr+CursorX]),Attr.Fore,C);
955     memset(&(AttrBuffBG[Ptr+CursorX]),Attr.Back,C);
956     BuffUpdateRect(CursorX,Y,CursorX+C-1,Y);
957     break;
958     case 5:
959     case 6:
960     if (Direction==5) {
961     if (CursorX==0) {
962     return;
963     }
964     X = CursorX - 1;
965     }
966     else {
967     if (CursorX==NumOfColumns-1) {
968     X = CursorX-1;
969     }
970     else {
971     X = CursorX+1;
972     }
973     }
974     Ptr = GetLinePtr(PageStart+CursorY);
975     if (CursorY+C > NumOfLines-StatusLine) {
976     C = NumOfLines-StatusLine-CursorY;
977     }
978     for (i=1; i<=C; i++) {
979     CodeBuff[Ptr+X] = 'x';
980     AttrBuff[Ptr+X] = Attr.Attr;
981     AttrBuff2[Ptr+X] = Attr.Attr2;
982     AttrBuffFG[Ptr+X] = Attr.Fore;
983     AttrBuffBG[Ptr+X] = Attr.Back;
984     Ptr = NextLinePtr(Ptr);
985     }
986     BuffUpdateRect(X,CursorY,X,CursorY+C-1);
987     break;
988     }
989 maya 3227 }
990    
991     void BuffEraseBox
992     (int XStart, int YStart, int XEnd, int YEnd)
993     {
994 maya 3393 int C, i;
995     LONG Ptr;
996 maya 3227
997 maya 3393 if (XEnd>NumOfColumns-1) {
998     XEnd = NumOfColumns-1;
999     }
1000     if (YEnd>NumOfLines-1-StatusLine) {
1001     YEnd = NumOfLines-1-StatusLine;
1002     }
1003     if (XStart>XEnd) {
1004     return;
1005     }
1006     if (YStart>YEnd) {
1007     return;
1008     }
1009     C = XEnd-XStart+1;
1010     Ptr = GetLinePtr(PageStart+YStart);
1011     for (i=YStart; i<=YEnd; i++) {
1012     if ((XStart>0) &&
1013     ((AttrBuff[Ptr+XStart-1] & AttrKanji) != 0)) {
1014     CodeBuff[Ptr+XStart-1] = 0x20;
1015     AttrBuff[Ptr+XStart-1] = CurCharAttr.Attr;
1016     AttrBuff2[Ptr+XStart-1] = CurCharAttr.Attr2;
1017     AttrBuffFG[Ptr+XStart-1] = CurCharAttr.Fore;
1018     AttrBuffBG[Ptr+XStart-1] = CurCharAttr.Back;
1019     }
1020     if ((XStart+C<NumOfColumns) &&
1021     ((AttrBuff[Ptr+XStart+C-1] & AttrKanji) != 0)) {
1022     CodeBuff[Ptr+XStart+C] = 0x20;
1023     AttrBuff[Ptr+XStart+C] = CurCharAttr.Attr;
1024     AttrBuff2[Ptr+XStart+C] = CurCharAttr.Attr2;
1025     AttrBuffFG[Ptr+XStart+C] = CurCharAttr.Fore;
1026     AttrBuffBG[Ptr+XStart+C] = CurCharAttr.Back;
1027     }
1028     memset(&(CodeBuff[Ptr+XStart]),0x20,C);
1029     memset(&(AttrBuff[Ptr+XStart]),AttrDefault,C);
1030 doda 4070 memset(&(AttrBuff2[Ptr+XStart]),CurCharAttr.Attr2 & Attr2ColorMask, C);
1031 maya 3393 memset(&(AttrBuffFG[Ptr+XStart]),CurCharAttr.Fore,C);
1032     memset(&(AttrBuffBG[Ptr+XStart]),CurCharAttr.Back,C);
1033     Ptr = NextLinePtr(Ptr);
1034     }
1035     BuffUpdateRect(XStart,YStart,XEnd,YEnd);
1036 maya 3227 }
1037    
1038 doda 5090 void BuffFillBox(char ch, int XStart, int YStart, int XEnd, int YEnd)
1039     {
1040     int Cols, i;
1041     LONG Ptr;
1042    
1043     if (XEnd>NumOfColumns-1) {
1044     XEnd = NumOfColumns-1;
1045     }
1046     if (YEnd>NumOfLines-1-StatusLine) {
1047     YEnd = NumOfLines-1-StatusLine;
1048     }
1049     if (XStart>XEnd) {
1050     return;
1051     }
1052     if (YStart>YEnd) {
1053     return;
1054     }
1055     Cols = XEnd-XStart+1;
1056     Ptr = GetLinePtr(PageStart+YStart);
1057     for (i=YStart; i<=YEnd; i++) {
1058     if ((XStart>0) &&
1059     ((AttrBuff[Ptr+XStart-1] & AttrKanji) != 0)) {
1060     CodeBuff[Ptr+XStart-1] = 0x20;
1061     AttrBuff[Ptr+XStart-1] ^= AttrKanji;
1062     }
1063     if ((XStart+Cols<NumOfColumns) &&
1064     ((AttrBuff[Ptr+XStart+Cols-1] & AttrKanji) != 0)) {
1065     CodeBuff[Ptr+XStart+Cols] = 0x20;
1066     }
1067     memset(&(CodeBuff[Ptr+XStart]), ch, Cols);
1068     memset(&(AttrBuff[Ptr+XStart]), CurCharAttr.Attr, Cols);
1069 doda 5092 memset(&(AttrBuff2[Ptr+XStart]), CurCharAttr.Attr2, Cols);
1070 doda 5090 memset(&(AttrBuffFG[Ptr+XStart]), CurCharAttr.Fore, Cols);
1071     memset(&(AttrBuffBG[Ptr+XStart]), CurCharAttr.Back, Cols);
1072     Ptr = NextLinePtr(Ptr);
1073     }
1074     BuffUpdateRect(XStart, YStart, XEnd, YEnd);
1075     }
1076    
1077 doda 6174 //
1078     // TODO: 1 origin になってるのを 0 origin に直す
1079     //
1080 doda 5089 void BuffCopyBox(
1081     int SrcXStart, int SrcYStart, int SrcXEnd, int SrcYEnd, int SrcPage,
1082     int DstX, int DstY, int DstPage)
1083     {
1084     int i, C, L;
1085     LONG SPtr, DPtr;
1086    
1087     SrcXStart--;
1088     SrcYStart--;
1089     SrcXEnd--;
1090     SrcYEnd--;
1091     SrcPage--;
1092     DstX--;
1093     DstY--;
1094     DstPage--;
1095    
1096     if (SrcXEnd > NumOfColumns - 1) {
1097     SrcXEnd = NumOfColumns-1;
1098     }
1099     if (SrcYEnd > NumOfLines-1-StatusLine) {
1100     SrcYEnd = NumOfColumns-1;
1101     }
1102     if (SrcXStart > SrcXEnd ||
1103     SrcYStart > SrcYEnd ||
1104     DstX > NumOfColumns-1 ||
1105     DstY > NumOfLines-1-StatusLine) {
1106     return;
1107     }
1108    
1109     C = SrcXEnd - SrcXStart + 1;
1110     if (DstX + C > NumOfColumns) {
1111     C = NumOfColumns - DstX;
1112     }
1113     L = SrcYEnd - SrcYStart + 1;
1114     if (DstY + C > NumOfColumns) {
1115     C = NumOfColumns - DstX;
1116     }
1117    
1118     if (SrcXStart > DstX) {
1119     SPtr = GetLinePtr(PageStart+SrcYStart);
1120     DPtr = GetLinePtr(PageStart+DstY);
1121     for (i=0; i<L; i++) {
1122     memcpy(&(CodeBuff[DPtr+DstX]), &(CodeBuff[SPtr+SrcXStart]), C);
1123     memcpy(&(AttrBuff[DPtr+DstX]), &(AttrBuff[SPtr+SrcXStart]), C);
1124     memcpy(&(AttrBuff2[DPtr+DstX]), &(AttrBuff2[SPtr+SrcXStart]), C);
1125     memcpy(&(AttrBuffFG[DPtr+DstX]), &(AttrBuffFG[SPtr+SrcXStart]), C);
1126     memcpy(&(AttrBuffBG[DPtr+DstX]), &(AttrBuffBG[SPtr+SrcXStart]), C);
1127     SPtr = NextLinePtr(SPtr);
1128     DPtr = NextLinePtr(DPtr);
1129     }
1130     }
1131     else if (SrcXStart < DstX) {
1132     SPtr = GetLinePtr(PageStart+SrcYEnd);
1133     DPtr = GetLinePtr(PageStart+DstY+L-1);
1134     for (i=L; i>0; i--) {
1135     memcpy(&(CodeBuff[DPtr+DstX]), &(CodeBuff[SPtr+SrcXStart]), C);
1136     memcpy(&(AttrBuff[DPtr+DstX]), &(AttrBuff[SPtr+SrcXStart]), C);
1137     memcpy(&(AttrBuff2[DPtr+DstX]), &(AttrBuff2[SPtr+SrcXStart]), C);
1138     memcpy(&(AttrBuffFG[DPtr+DstX]), &(AttrBuffFG[SPtr+SrcXStart]), C);
1139     memcpy(&(AttrBuffBG[DPtr+DstX]), &(AttrBuffBG[SPtr+SrcXStart]), C);
1140     SPtr = PrevLinePtr(SPtr);
1141     DPtr = PrevLinePtr(DPtr);
1142     }
1143     }
1144     else if (SrcYStart != DstY) {
1145     SPtr = GetLinePtr(PageStart+SrcYStart);
1146     DPtr = GetLinePtr(PageStart+DstY);
1147     for (i=0; i<L; i++) {
1148     memmove(&(CodeBuff[DPtr+DstX]), &(CodeBuff[SPtr+SrcXStart]), C);
1149     memmove(&(AttrBuff[DPtr+DstX]), &(AttrBuff[SPtr+SrcXStart]), C);
1150     memmove(&(AttrBuff2[DPtr+DstX]), &(AttrBuff2[SPtr+SrcXStart]), C);
1151     memmove(&(AttrBuffFG[DPtr+DstX]), &(AttrBuffFG[SPtr+SrcXStart]), C);
1152     memmove(&(AttrBuffBG[DPtr+DstX]), &(AttrBuffBG[SPtr+SrcXStart]), C);
1153     SPtr = NextLinePtr(SPtr);
1154     DPtr = NextLinePtr(DPtr);
1155     }
1156     }
1157     BuffUpdateRect(DstX,DstY,DstX+C-1,DstY+L-1);
1158     }
1159    
1160 doda 5095 void BuffChangeAttrBox(int XStart, int YStart, int XEnd, int YEnd, PCharAttr attr, PCharAttr mask)
1161     {
1162     int C, i, j;
1163     LONG Ptr;
1164    
1165     if (XEnd>NumOfColumns-1) {
1166     XEnd = NumOfColumns-1;
1167     }
1168     if (YEnd>NumOfLines-1-StatusLine) {
1169     YEnd = NumOfLines-1-StatusLine;
1170     }
1171     if (XStart>XEnd || YStart>YEnd) {
1172     return;
1173     }
1174     C = XEnd-XStart+1;
1175     Ptr = GetLinePtr(PageStart+YStart);
1176    
1177     if (mask) { // DECCARA
1178     for (i=YStart; i<=YEnd; i++) {
1179     j = Ptr+XStart-1;
1180     if (XStart>0 && (AttrBuff[j] & AttrKanji)) {
1181     AttrBuff[j] = AttrBuff[j] & ~mask->Attr | attr->Attr;
1182     AttrBuff[j] = AttrBuff2[j] & ~mask->Attr2 | attr->Attr2;
1183     AttrBuffFG[j] = attr->Fore;
1184     AttrBuffBG[j] = attr->Back;
1185     j++;
1186     }
1187     while (j < Ptr+XStart+C) {
1188     AttrBuff[j] = AttrBuff[j] & ~mask->Attr | attr->Attr;
1189     AttrBuff2[j] = AttrBuff2[j] & ~mask->Attr2 | attr->Attr2;
1190     AttrBuffFG[j] = attr->Fore;
1191     AttrBuffBG[j] = attr->Back;
1192     j++;
1193     }
1194     if (XStart+C<NumOfColumns && (AttrBuff[j-1] & AttrKanji)) {
1195     AttrBuff[j] = AttrBuff[j] & ~mask->Attr | attr->Attr;
1196     AttrBuff2[j] = AttrBuff2[j] & ~mask->Attr2 | attr->Attr2;
1197     AttrBuffFG[j] = attr->Fore;
1198     AttrBuffBG[j] = attr->Back;
1199     }
1200     Ptr = NextLinePtr(Ptr);
1201     }
1202     }
1203     else { // DECRARA
1204     for (i=YStart; i<=YEnd; i++) {
1205     j = Ptr+XStart-1;
1206     if (XStart>0 && (AttrBuff[j] & AttrKanji)) {
1207     AttrBuff[j++] ^= attr->Attr;
1208     }
1209     while (j < Ptr+XStart+C) {
1210     AttrBuff[j++] ^= attr->Attr;
1211     }
1212     if (XStart+C<NumOfColumns && (AttrBuff[j-1] & AttrKanji)) {
1213     AttrBuff[j] ^= attr->Attr;
1214     }
1215     Ptr = NextLinePtr(Ptr);
1216     }
1217     }
1218     BuffUpdateRect(XStart, YStart, XEnd, YEnd);
1219     }
1220    
1221 maya 3227 int LeftHalfOfDBCS(LONG Line, int CharPtr)
1222     // If CharPtr is on the right half of a DBCS character,
1223     // return pointer to the left half
1224     // Line: points to a line in CodeBuff
1225     // CharPtr: points to a char
1226     // return: points to the left half of the DBCS
1227     {
1228 maya 3393 if ((CharPtr>0) &&
1229     ((AttrBuff[Line+CharPtr-1] & AttrKanji) != 0)) {
1230     CharPtr--;
1231     }
1232     return CharPtr;
1233 maya 3227 }
1234    
1235     int MoveCharPtr(LONG Line, int *x, int dx)
1236     // move character pointer x by dx character unit
1237     // in the line specified by Line
1238     // Line: points to a line in CodeBuff
1239     // x: points to a character in the line
1240     // dx: moving distance in character unit (-: left, +: right)
1241 maya 3393 // One DBCS character is counted as one character.
1242 maya 3227 // The pointer stops at the beginning or the end of line.
1243     // Output
1244     // x: new pointer. x points to a SBCS character or
1245     // the left half of a DBCS character.
1246     // return: actual moving distance in character unit
1247     {
1248 maya 3393 int i;
1249 maya 3227
1250 maya 3393 *x = LeftHalfOfDBCS(Line,*x);
1251     i = 0;
1252     while (dx!=0) {
1253     if (dx>0) { // move right
1254     if ((AttrBuff[Line+*x] & AttrKanji) != 0) {
1255     if (*x<NumOfColumns-2) {
1256     i++;
1257     *x = *x + 2;
1258     }
1259     }
1260     else if (*x<NumOfColumns-1) {
1261     i++;
1262     (*x)++;
1263     }
1264     dx--;
1265     }
1266     else { // move left
1267     if (*x>0) {
1268     i--;
1269     (*x)--;
1270     }
1271     *x = LeftHalfOfDBCS(Line,*x);
1272     dx++;
1273     }
1274 maya 3227 }
1275 maya 3393 return i;
1276 maya 3227 }
1277    
1278     void BuffCBCopy(BOOL Table)
1279     // copy selected text to clipboard
1280     {
1281 maya 3393 LONG MemSize;
1282     PCHAR CBPtr;
1283     LONG TmpPtr;
1284     int i, j, k, IStart, IEnd;
1285     BOOL Sp, FirstChar;
1286     BYTE b;
1287     BOOL LineContinued, PrevLineContinued;
1288 doda 6803
1289 maya 3393 LineContinued = FALSE;
1290 maya 3227
1291 maya 3393 if (TalkStatus==IdTalkCB) {
1292     return;
1293     }
1294     if (! Selected) {
1295     return;
1296     }
1297 maya 3227
1298     // --- open clipboard and get CB memory
1299 maya 3393 if (BoxSelect) {
1300     MemSize = (SelectEnd.x-SelectStart.x+3)*
1301     (SelectEnd.y-SelectStart.y+1) + 1;
1302     }
1303     else {
1304     MemSize = (SelectEnd.y-SelectStart.y)*
1305     (NumOfColumns+2) +
1306     SelectEnd.x - SelectStart.x + 1;
1307     }
1308     CBPtr = CBOpen(MemSize);
1309     if (CBPtr==NULL) {
1310     return;
1311     }
1312 maya 3227
1313     // --- copy selected text to CB memory
1314 maya 3393 LockBuffer();
1315 maya 3227
1316 maya 3393 CBPtr[0] = 0;
1317     TmpPtr = GetLinePtr(SelectStart.y);
1318     k = 0;
1319     for (j = SelectStart.y ; j<=SelectEnd.y ; j++) {
1320     if (BoxSelect) {
1321     IStart = SelectStart.x;
1322     IEnd = SelectEnd.x-1;
1323     }
1324     else {
1325     IStart = 0;
1326     IEnd = NumOfColumns-1;
1327     if (j==SelectStart.y) {
1328     IStart = SelectStart.x;
1329     }
1330     if (j==SelectEnd.y) {
1331     IEnd = SelectEnd.x-1;
1332     }
1333     }
1334     i = LeftHalfOfDBCS(TmpPtr,IStart);
1335     if (i!=IStart) {
1336     if (j==SelectStart.y) {
1337     IStart = i;
1338     }
1339     else {
1340     IStart = i + 2;
1341     }
1342     }
1343 maya 3227
1344 maya 3393 // exclude right-side space characters
1345     IEnd = LeftHalfOfDBCS(TmpPtr,IEnd);
1346     PrevLineContinued = LineContinued;
1347     LineContinued = FALSE;
1348     if (ts.EnableContinuedLineCopy && j!=SelectEnd.y && !BoxSelect) {
1349     LONG NextTmpPtr = NextLinePtr(TmpPtr);
1350     if ((AttrBuff[NextTmpPtr] & AttrLineContinued) != 0) {
1351     LineContinued = TRUE;
1352     }
1353     if (IEnd == NumOfColumns-1 &&
1354     (AttrBuff[TmpPtr + IEnd] & AttrLineContinued) != 0) {
1355     MoveCharPtr(TmpPtr,&IEnd,-1);
1356     }
1357     }
1358     if (!LineContinued)
1359     while ((IEnd>0) && (CodeBuff[TmpPtr+IEnd]==0x20)) {
1360     MoveCharPtr(TmpPtr,&IEnd,-1);
1361     }
1362     if ((IEnd==0) && (CodeBuff[TmpPtr]==0x20)) {
1363     IEnd = -1;
1364     }
1365     else if ((AttrBuff[TmpPtr+IEnd] & AttrKanji) != 0) { /* DBCS first byte? */
1366     IEnd++;
1367     }
1368 maya 3227
1369 maya 3393 Sp = FALSE;
1370     FirstChar = TRUE;
1371     i = IStart;
1372     while (i <= IEnd) {
1373     b = CodeBuff[TmpPtr+i];
1374     i++;
1375     if (! Sp) {
1376     if ((Table) && (b<=0x20)) {
1377     Sp = TRUE;
1378     b = 0x09;
1379     }
1380     if ((b!=0x09) || (! FirstChar) || PrevLineContinued) {
1381     FirstChar = FALSE;
1382     CBPtr[k] = b;
1383     k++;
1384     }
1385     }
1386     else {
1387     if (b>0x20) {
1388     Sp = FALSE;
1389     FirstChar = FALSE;
1390     CBPtr[k] = b;
1391     k++;
1392     }
1393     }
1394     }
1395 maya 3227
1396 maya 3393 if (!LineContinued)
1397     if (j < SelectEnd.y) {
1398     CBPtr[k] = 0x0d;
1399     k++;
1400     CBPtr[k] = 0x0a;
1401     k++;
1402     }
1403 maya 3227
1404 maya 3393 TmpPtr = NextLinePtr(TmpPtr);
1405     }
1406     CBPtr[k] = 0;
1407     LineContinued = FALSE;
1408     if (ts.EnableContinuedLineCopy && j!=SelectEnd.y && !BoxSelect && j<BuffEnd-1) {
1409     LONG NextTmpPtr = NextLinePtr(TmpPtr);
1410     if ((AttrBuff[NextTmpPtr] & AttrLineContinued) != 0) {
1411     LineContinued = TRUE;
1412     }
1413     if (IEnd == NumOfColumns-1 &&
1414     (AttrBuff[TmpPtr + IEnd] & AttrLineContinued) != 0) {
1415     MoveCharPtr(TmpPtr,&IEnd,-1);
1416     }
1417     }
1418     if (!LineContinued)
1419     UnlockBuffer();
1420 maya 3227
1421     // --- send CB memory to clipboard
1422 maya 3393 CBClose();
1423     return;
1424 maya 3227 }
1425    
1426     void BuffPrint(BOOL ScrollRegion)
1427     // Print screen or selected text
1428     {
1429 maya 3393 int Id;
1430     POINT PrintStart, PrintEnd;
1431     TCharAttr CurAttr, TempAttr;
1432     int i, j, count;
1433     int IStart, IEnd;
1434     LONG TmpPtr;
1435 maya 3227
1436 maya 3393 TempAttr = DefCharAttr;
1437 maya 3227
1438 maya 3393 if (ScrollRegion) {
1439     Id = VTPrintInit(IdPrnScrollRegion);
1440     }
1441     else if (Selected) {
1442     Id = VTPrintInit(IdPrnScreen | IdPrnSelectedText);
1443     }
1444     else {
1445     Id = VTPrintInit(IdPrnScreen);
1446     }
1447     if (Id==IdPrnCancel) {
1448     return;
1449     }
1450 maya 3227
1451 maya 3393 /* set print region */
1452     if (Id==IdPrnSelectedText) {
1453     /* print selected region */
1454     PrintStart = SelectStart;
1455     PrintEnd = SelectEnd;
1456     }
1457     else if (Id==IdPrnScrollRegion) {
1458     /* print scroll region */
1459     PrintStart.x = 0;
1460     PrintStart.y = PageStart + CursorTop;
1461     PrintEnd.x = NumOfColumns;
1462     PrintEnd.y = PageStart + CursorBottom;
1463     }
1464     else {
1465     /* print current screen */
1466     PrintStart.x = 0;
1467     PrintStart.y = PageStart;
1468     PrintEnd.x = NumOfColumns;
1469     PrintEnd.y = PageStart + NumOfLines - 1;
1470     }
1471     if (PrintEnd.y > BuffEnd-1) {
1472     PrintEnd.y = BuffEnd-1;
1473     }
1474 maya 3227
1475 maya 3393 LockBuffer();
1476 maya 3227
1477 maya 3393 TmpPtr = GetLinePtr(PrintStart.y);
1478     for (j = PrintStart.y ; j <= PrintEnd.y ; j++) {
1479     if (j==PrintStart.y) {
1480     IStart = PrintStart.x;
1481     }
1482     else {
1483     IStart = 0;
1484     }
1485     if (j == PrintEnd.y) {
1486     IEnd = PrintEnd.x - 1;
1487     }
1488     else {
1489     IEnd = NumOfColumns - 1;
1490     }
1491 maya 3227
1492 maya 3393 while ((IEnd>=IStart) &&
1493     (CodeBuff[TmpPtr+IEnd]==0x20) &&
1494     (AttrBuff[TmpPtr+IEnd]==AttrDefault) &&
1495     (AttrBuff2[TmpPtr+IEnd]==AttrDefault)) {
1496     IEnd--;
1497     }
1498 maya 3227
1499 maya 3393 i = IStart;
1500     while (i <= IEnd) {
1501     CurAttr.Attr = AttrBuff[TmpPtr+i] & ~ AttrKanji;
1502     CurAttr.Attr2 = AttrBuff2[TmpPtr+i];
1503     CurAttr.Fore = AttrBuffFG[TmpPtr+i];
1504     CurAttr.Back = AttrBuffBG[TmpPtr+i];
1505 maya 3227
1506 maya 3393 count = 1;
1507     while ((i+count <= IEnd) &&
1508     (CurAttr.Attr == (AttrBuff[TmpPtr+i+count] & ~ AttrKanji)) &&
1509     (CurAttr.Attr2 == AttrBuff2[TmpPtr+i+count]) &&
1510     (CurAttr.Fore == AttrBuffFG[TmpPtr+i+count]) &&
1511     (CurAttr.Back == AttrBuffBG[TmpPtr+i+count]) ||
1512     (i+count<NumOfColumns) &&
1513     ((AttrBuff[TmpPtr+i+count-1] & AttrKanji) != 0)) {
1514     count++;
1515     }
1516 maya 3227
1517 maya 3393 if (TCharAttrCmp(CurAttr, TempAttr) != 0) {
1518     PrnSetAttr(CurAttr);
1519     TempAttr = CurAttr;
1520     }
1521     PrnOutText(&(CodeBuff[TmpPtr+i]),count);
1522     i = i+count;
1523     }
1524     PrnNewLine();
1525     TmpPtr = NextLinePtr(TmpPtr);
1526     }
1527 maya 3227
1528 maya 3393 UnlockBuffer();
1529     VTPrintEnd();
1530 maya 3227 }
1531    
1532     void BuffDumpCurrentLine(BYTE TERM)
1533     // Dumps current line to the file (for path through printing)
1534     // HFile: file handle
1535     // TERM: terminator character
1536     // = LF or VT or FF
1537     {
1538 maya 3393 int i, j;
1539 maya 3227
1540 maya 3393 i = NumOfColumns;
1541     while ((i>0) && (CodeLine[i-1]==0x20)) {
1542     i--;
1543     }
1544     for (j=0; j<i; j++) {
1545     WriteToPrnFile(CodeLine[j],FALSE);
1546     }
1547     WriteToPrnFile(0,TRUE);
1548     if ((TERM>=LF) && (TERM<=FF)) {
1549     WriteToPrnFile(0x0d,FALSE);
1550     WriteToPrnFile(TERM,TRUE);
1551     }
1552 maya 3227 }
1553    
1554    
1555     /* begin - ishizaki */
1556     static void markURL(int x)
1557     {
1558     #ifdef URL_EMPHASIS
1559 doda 5428 LONG PrevCharPtr;
1560     CHAR PrevCharAttr, PrevCharCode;
1561 doda 5278
1562 yutakapon 3414 // RFC3986(Uniform Resource Identifier (URI): Generic Syntax)に準拠する
1563 maya 3227 // by sakura editor 1.5.2.1: etc_uty.cpp
1564     static const char url_char[] = {
1565     /* +0 +1 +2 +3 +4 +5 +6 +7 +8 +9 +A +B +C +D +E +F */
1566 doda 5426 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* +00: */
1567     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* +10: */
1568     0, -1, 0, -1, -1, -1, -1, 0, 0, 0, 0, -1, -1, -1, -1, -1, /* +20: " !"#$%&'()*+,-./" */
1569     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 0, -1, /* +30: "0123456789:;<=>?" */
1570     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* +40: "@ABCDEFGHIJKLMNO" */
1571     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 0, 0, -1, /* +50: "PQRSTUVWXYZ[\]^_" */
1572     0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* +60: "`abcdefghijklmno" */
1573     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, -1, 0, /* +70: "pqrstuvwxyz{|}~ " */
1574     /* 0 : not url char
1575     * -1 : url char
1576     * other: url head char --> url_table array number + 1
1577     */
1578 maya 3227 };
1579 yutakapon 3614 static char *prefix[] = {
1580     "https://",
1581     "http://",
1582     "sftp://",
1583     "tftp://",
1584     "news://",
1585     "ftp://",
1586     "mms://",
1587     NULL
1588     };
1589 maya 3227 unsigned char ch = CodeLine[x];
1590    
1591 doda 6435 if (ts.EnableClickableUrl == FALSE &&
1592 yutakapon 3615 (ts.ColorFlag & CF_URLCOLOR) == 0)
1593 maya 3227 return;
1594    
1595     // 直前の行から連結しているか。
1596     if (x == 0) {
1597 doda 5428 PrevCharPtr = PrevLinePtr(LinePtr) + NumOfColumns-1;
1598     PrevCharCode = CodeBuff[PrevCharPtr];
1599     PrevCharAttr = AttrBuff[PrevCharPtr];
1600 doda 5438 if ((PrevCharAttr & AttrURL) && !(AttrLine[0]&(AttrKanji|AttrSpecial)) && !(ch & 0x80) && url_char[ch]) {
1601     if ((AttrLine[0] & AttrLineContinued) || (ts.JoinSplitURL &&
1602     (PrevCharCode == ts.JoinSplitURLIgnoreEOLChar || ts.JoinSplitURLIgnoreEOLChar == '\0' ))) {
1603 doda 6435 AttrLine[0] |= AttrURL;
1604 doda 5433 }
1605 maya 3227 }
1606     return;
1607     }
1608    
1609     if ((x-1>=0) && (AttrLine[x-1] & AttrURL) &&
1610 doda 5438 !(AttrLine[x] & (AttrKanji|AttrSpecial)) &&
1611     ((!(ch & 0x80) && url_char[ch]) || (x == NumOfColumns - 1 && ch == ts.JoinSplitURLIgnoreEOLChar))) {
1612 doda 6435 AttrLine[x] |= AttrURL;
1613 maya 3227 return;
1614     }
1615    
1616     if ((x-2>=0) && !strncmp(&CodeLine[x-2], "://", 3)) {
1617 maya 3417 int i, len = -1;
1618 yutakapon 3608 RECT rc;
1619     int CaretX, CaretY;
1620 yutakapon 3614 char **p = prefix;
1621 yutakapon 3608
1622 yutakapon 3614 while (*p) {
1623     len = strlen(*p) - 1;
1624     if ((x-len>=0) && !strncmp(&CodeLine[x-len], *p, len)) {
1625     for (i = 0; i <= len; i++) {
1626 doda 6435 AttrLine[x-i] |= AttrURL;
1627 yutakapon 3614 }
1628     break;
1629     }
1630     p++;
1631 maya 3227 }
1632 yutakapon 3608
1633     /* ハイパーリンクの色属性変更は、すでに画面へ出力後に、バッファを遡って URL 属性を
1634     * 付け直すというロジックであるため、色が正しく描画されない場合がある。
1635     * 少々強引だが、ハイパーリンクを発見したタイミングで、その行に再描画指示を出すことで、
1636     * リアルタイムな色描画を実現する。
1637     * (2009.8.26 yutaka)
1638     */
1639     CaretX = (0-WinOrgX)*FontWidth;
1640     CaretY = (CursorY-WinOrgY)*FontHeight;
1641     rc.left = CaretX;
1642     rc.top = CaretY;
1643     rc.right = CaretX + NumOfColumns * FontWidth;
1644     rc.bottom = CaretY + FontHeight;
1645     InvalidateRect(HVTWin, &rc, FALSE);
1646 maya 3227 }
1647     #endif
1648     }
1649     /* end - ishizaki */
1650    
1651     void BuffPutChar(BYTE b, TCharAttr Attr, BOOL Insert)
1652     // Put a character in the buffer at the current position
1653     // b: character
1654     // Attr: attributes
1655     // Insert: Insert flag
1656     {
1657 doda 5324 int XStart, LineEnd, MoveLen;
1658 doda 5371 int extr = 0;
1659 maya 3227
1660 maya 3393 if (ts.EnableContinuedLineCopy && CursorX == 0 && (AttrLine[0] & AttrLineContinued)) {
1661     Attr.Attr |= AttrLineContinued;
1662     }
1663 doda 3312
1664 doda 3416 if (ts.Language==IdJapanese || ts.Language==IdKorean || ts.Language==IdUtf8) {
1665 maya 3393 EraseKanji(1); /* if cursor is on right half of a kanji, erase the kanji */
1666     if (! Insert) {
1667     EraseKanji(0); /* if cursor on left half... */
1668     }
1669     }
1670 maya 3227
1671 maya 3393 if (Insert) {
1672 doda 5324 if (CursorX > CursorRightM)
1673     LineEnd = NumOfColumns - 1;
1674     else
1675     LineEnd = CursorRightM;
1676    
1677 doda 5371 if (LineEnd < NumOfColumns - 1 && (AttrLine[LineEnd] & AttrKanji)) {
1678     CodeLine[LineEnd] = 0x20;
1679     AttrLine[LineEnd] &= ~AttrKanji;
1680     CodeLine[LineEnd+1] = 0x20;
1681     AttrLine[LineEnd+1] &= ~AttrKanji;
1682     extr = 1;
1683     }
1684    
1685 doda 5324 MoveLen = LineEnd - CursorX;
1686     if (MoveLen > 0) {
1687     memmove(&CodeLine[CursorX+1], &CodeLine[CursorX], MoveLen);
1688     memmove(&AttrLine[CursorX+1], &AttrLine[CursorX], MoveLen);
1689     memmove(&AttrLine2[CursorX+1], &AttrLine2[CursorX], MoveLen);
1690     memmove(&AttrLineFG[CursorX+1], &AttrLineFG[CursorX], MoveLen);
1691     memmove(&AttrLineBG[CursorX+1], &AttrLineBG[CursorX], MoveLen);
1692     }
1693 maya 3393 CodeLine[CursorX] = b;
1694     AttrLine[CursorX] = Attr.Attr;
1695     AttrLine2[CursorX] = Attr.Attr2;
1696     AttrLineFG[CursorX] = Attr.Fore;
1697     AttrLineBG[CursorX] = Attr.Back;
1698     /* last char in current line is kanji first? */
1699 doda 5324 if ((AttrLine[LineEnd] & AttrKanji) != 0) {
1700 maya 3393 /* then delete it */
1701 doda 5324 CodeLine[LineEnd] = 0x20;
1702     AttrLine[LineEnd] = CurCharAttr.Attr;
1703     AttrLine2[LineEnd] = CurCharAttr.Attr2;
1704     AttrLineFG[LineEnd] = CurCharAttr.Fore;
1705     AttrLineBG[LineEnd] = CurCharAttr.Back;
1706 maya 3393 }
1707     /* begin - ishizaki */
1708     markURL(CursorX+1);
1709     markURL(CursorX);
1710     /* end - ishizaki */
1711 maya 3227
1712 maya 3393 if (StrChangeCount==0) {
1713     XStart = CursorX;
1714     }
1715     else {
1716     XStart = StrChangeStart;
1717     }
1718     StrChangeCount = 0;
1719 doda 5371 BuffUpdateRect(XStart, CursorY, LineEnd+extr, CursorY);
1720 maya 3393 }
1721     else {
1722     CodeLine[CursorX] = b;
1723     AttrLine[CursorX] = Attr.Attr;
1724     AttrLine2[CursorX] = Attr.Attr2;
1725     AttrLineFG[CursorX] = Attr.Fore;
1726     AttrLineBG[CursorX] = Attr.Back;
1727     /* begin - ishizaki */
1728     markURL(CursorX);
1729     /* end - ishizaki */
1730 maya 3227
1731 maya 3393 if (StrChangeCount==0) {
1732     StrChangeStart = CursorX;
1733     }
1734     StrChangeCount++;
1735     }
1736 maya 3227 }
1737    
1738     void BuffPutKanji(WORD w, TCharAttr Attr, BOOL Insert)
1739     // Put a kanji character in the buffer at the current position
1740     // b: character
1741     // Attr: attributes
1742     // Insert: Insert flag
1743     {
1744 doda 5324 int XStart, LineEnd, MoveLen;
1745 doda 5371 int extr = 0;
1746 maya 3227
1747 maya 3393 if (ts.EnableContinuedLineCopy && CursorX == 0 && (AttrLine[0] & AttrLineContinued)) {
1748     Attr.Attr |= AttrLineContinued;
1749     }
1750 doda 3312
1751 maya 3393 EraseKanji(1); /* if cursor is on right half of a kanji, erase the kanji */
1752 maya 3227
1753 maya 3393 if (Insert) {
1754 doda 5324 if (CursorX > CursorRightM)
1755     LineEnd = NumOfColumns - 1;
1756     else
1757     LineEnd = CursorRightM;
1758 maya 3227
1759 doda 5371 if (LineEnd < NumOfColumns - 1 && (AttrLine[LineEnd] & AttrKanji)) {
1760     CodeLine[LineEnd] = 0x20;
1761     AttrLine[LineEnd] &= ~AttrKanji;
1762     CodeLine[LineEnd+1] = 0x20;
1763     AttrLine[LineEnd+1] &= ~AttrKanji;
1764     extr = 1;
1765     }
1766    
1767 doda 5324 MoveLen = LineEnd - CursorX - 1;
1768     if (MoveLen > 0) {
1769     memmove(&CodeLine[CursorX+2], &CodeLine[CursorX], MoveLen);
1770     memmove(&AttrLine[CursorX+2], &AttrLine[CursorX], MoveLen);
1771     memmove(&AttrLine2[CursorX+2], &AttrLine2[CursorX], MoveLen);
1772     memmove(&AttrLineFG[CursorX+2], &AttrLineFG[CursorX], MoveLen);
1773     memmove(&AttrLineBG[CursorX+2], &AttrLineBG[CursorX], MoveLen);
1774     }
1775    
1776 maya 3393 CodeLine[CursorX] = HIBYTE(w);
1777     AttrLine[CursorX] = Attr.Attr | AttrKanji; /* DBCS first byte */
1778     AttrLine2[CursorX] = Attr.Attr2;
1779     AttrLineFG[CursorX] = Attr.Fore;
1780     AttrLineBG[CursorX] = Attr.Back;
1781 doda 5324 if (CursorX < LineEnd) {
1782 maya 3393 CodeLine[CursorX+1] = LOBYTE(w);
1783     AttrLine[CursorX+1] = Attr.Attr;
1784     AttrLine2[CursorX+1] = Attr.Attr2;
1785     AttrLineFG[CursorX+1] = Attr.Fore;
1786     AttrLineBG[CursorX+1] = Attr.Back;
1787     }
1788     /* begin - ishizaki */
1789     markURL(CursorX);
1790     markURL(CursorX+1);
1791     /* end - ishizaki */
1792 maya 3227
1793 maya 3393 /* last char in current line is kanji first? */
1794 doda 5324 if ((AttrLine[LineEnd] & AttrKanji) != 0) {
1795 maya 3393 /* then delete it */
1796 doda 5324 CodeLine[LineEnd] = 0x20;
1797     AttrLine[LineEnd] = CurCharAttr.Attr;
1798     AttrLine2[LineEnd] = CurCharAttr.Attr2;
1799     AttrLineFG[LineEnd] = CurCharAttr.Fore;
1800     AttrLineBG[LineEnd] = CurCharAttr.Back;
1801 maya 3393 }
1802 maya 3227
1803 maya 3393 if (StrChangeCount==0) {
1804     XStart = CursorX;
1805     }
1806     else {
1807     XStart = StrChangeStart;
1808     }
1809     StrChangeCount = 0;
1810 doda 5371 BuffUpdateRect(XStart, CursorY, LineEnd+extr, CursorY);
1811 maya 3393 }
1812     else {
1813     CodeLine[CursorX] = HIBYTE(w);
1814     AttrLine[CursorX] = Attr.Attr | AttrKanji; /* DBCS first byte */
1815     AttrLine2[CursorX] = Attr.Attr2;
1816     AttrLineFG[CursorX] = Attr.Fore;
1817     AttrLineBG[CursorX] = Attr.Back;
1818     if (CursorX < NumOfColumns-1) {
1819     CodeLine[CursorX+1] = LOBYTE(w);
1820     AttrLine[CursorX+1] = Attr.Attr;
1821     AttrLine2[CursorX+1] = Attr.Attr2;
1822     AttrLineFG[CursorX+1] = Attr.Fore;
1823     AttrLineBG[CursorX+1] = Attr.Back;
1824     }
1825     /* begin - ishizaki */
1826     markURL(CursorX);
1827     markURL(CursorX+1);
1828     /* end - ishizaki */
1829 maya 3227
1830 maya 3393 if (StrChangeCount==0) {
1831     StrChangeStart = CursorX;
1832     }
1833     StrChangeCount = StrChangeCount + 2;
1834     }
1835 maya 3227 }
1836    
1837     BOOL CheckSelect(int x, int y)
1838     // subroutine called by BuffUpdateRect
1839     {
1840 maya 3393 LONG L, L1, L2;
1841 maya 3227
1842 maya 3393 if (BoxSelect) {
1843     return (Selected &&
1844     ((SelectStart.x<=x) && (x<SelectEnd.x) ||
1845     (SelectEnd.x<=x) && (x<SelectStart.x)) &&
1846     ((SelectStart.y<=y) && (y<=SelectEnd.y) ||
1847     (SelectEnd.y<=y) && (y<=SelectStart.y)));
1848     }
1849     else {
1850     L = MAKELONG(x,y);
1851     L1 = MAKELONG(SelectStart.x,SelectStart.y);
1852     L2 = MAKELONG(SelectEnd.x,SelectEnd.y);
1853 maya 3227
1854 maya 3393 return (Selected &&
1855     ((L1<=L) && (L<L2) || (L2<=L) && (L<L1)));
1856     }
1857 maya 3227 }
1858    
1859     void BuffUpdateRect
1860     (int XStart, int YStart, int XEnd, int YEnd)
1861     // Display text in a rectangular region in the screen
1862     // XStart: x position of the upper-left corner (screen cordinate)
1863     // YStart: y position
1864     // XEnd: x position of the lower-right corner (last character)
1865     // YEnd: y position
1866     {
1867 maya 3393 int i, j, count;
1868     int IStart, IEnd;
1869     int X, Y;
1870     LONG TmpPtr;
1871     TCharAttr CurAttr, TempAttr;
1872     BOOL CurSel, TempSel, Caret;
1873 maya 3227
1874 maya 3393 if (XStart >= WinOrgX+WinWidth) {
1875     return;
1876     }
1877     if (YStart >= WinOrgY+WinHeight) {
1878     return;
1879     }
1880     if (XEnd < WinOrgX) {
1881     return;
1882     }
1883     if (YEnd < WinOrgY) {
1884     return;
1885     }
1886 maya 3227
1887 maya 3393 if (XStart < WinOrgX) {
1888     XStart = WinOrgX;
1889     }
1890     if (YStart < WinOrgY) {
1891     YStart = WinOrgY;
1892     }
1893     if (XEnd >= WinOrgX+WinWidth) {
1894     XEnd = WinOrgX+WinWidth-1;
1895     }
1896     if (YEnd >= WinOrgY+WinHeight) {
1897     YEnd = WinOrgY+WinHeight-1;
1898     }
1899 maya 3227
1900 maya 3393 TempAttr = DefCharAttr;
1901     TempSel = FALSE;
1902 maya 3227
1903 maya 3393 Caret = IsCaretOn();
1904     if (Caret) {
1905     CaretOff();
1906     }
1907 maya 3227
1908 maya 3393 DispSetupDC(DefCharAttr, TempSel);
1909 maya 3227
1910 maya 3393 Y = (YStart-WinOrgY)*FontHeight;
1911     TmpPtr = GetLinePtr(PageStart+YStart);
1912     for (j = YStart+PageStart ; j <= YEnd+PageStart ; j++) {
1913     IStart = XStart;
1914     IEnd = XEnd;
1915 maya 3227
1916 maya 3393 IStart = LeftHalfOfDBCS(TmpPtr,IStart);
1917 maya 3227
1918 maya 3393 X = (IStart-WinOrgX)*FontWidth;
1919 maya 3227
1920 maya 3393 i = IStart;
1921     do {
1922     CurAttr.Attr = AttrBuff[TmpPtr+i] & ~ AttrKanji;
1923     CurAttr.Attr2 = AttrBuff2[TmpPtr+i];
1924     CurAttr.Fore = AttrBuffFG[TmpPtr+i];
1925     CurAttr.Back = AttrBuffBG[TmpPtr+i];
1926     CurSel = CheckSelect(i,j);
1927     count = 1;
1928     while ( (i+count <= IEnd) &&
1929     (CurAttr.Attr == (AttrBuff[TmpPtr+i+count] & ~ AttrKanji)) &&
1930     (CurAttr.Attr2==AttrBuff2[TmpPtr+i+count]) &&
1931     (CurAttr.Fore==AttrBuffFG[TmpPtr+i+count]) &&
1932     (CurAttr.Back==AttrBuffBG[TmpPtr+i+count]) &&
1933     (CurSel==CheckSelect(i+count,j)) ||
1934     (i+count<NumOfColumns) &&
1935     ((AttrBuff[TmpPtr+i+count-1] & AttrKanji) != 0) ) {
1936     count++;
1937     }
1938 maya 3227
1939 maya 3393 if (TCharAttrCmp(CurAttr, TempAttr) != 0 || (CurSel != TempSel)) {
1940     DispSetupDC(CurAttr, CurSel);
1941     TempAttr = CurAttr;
1942     TempSel = CurSel;
1943     }
1944     DispStr(&CodeBuff[TmpPtr+i],count,Y, &X);
1945     i = i+count;
1946     }
1947     while (i<=IEnd);
1948     Y = Y + FontHeight;
1949     TmpPtr = NextLinePtr(TmpPtr);
1950     }
1951     if (Caret) {
1952     CaretOn();
1953     }
1954 maya 3227 }
1955    
1956     void UpdateStr()
1957     // Display not-yet-displayed string
1958     {
1959 maya 3393 int X, Y;
1960     TCharAttr TempAttr;
1961 yutakapon 3656 int pos, len;
1962 maya 3227
1963 maya 3393 if (StrChangeCount==0) {
1964     return;
1965     }
1966     X = StrChangeStart;
1967     Y = CursorY;
1968     if (! IsLineVisible(&X, &Y)) {
1969     StrChangeCount = 0;
1970     return;
1971     }
1972 maya 3227
1973 maya 3393 TempAttr.Attr = AttrLine[StrChangeStart];
1974     TempAttr.Attr2 = AttrLine2[StrChangeStart];
1975     TempAttr.Fore = AttrLineFG[StrChangeStart];
1976     TempAttr.Back = AttrLineBG[StrChangeStart];
1977 yutakapon 3656
1978     /* これから描画する文字列の始まりが「URL構成文字属性」だった場合、
1979     * 当該色で行末までペイントされないようにする。
1980     * (2009.10.24 yutaka)
1981     */
1982 doda 3659 if (TempAttr.Attr & AttrURL) {
1983 yutakapon 3656 /* 開始位置からどこまでが AttrURL かをカウントする */
1984     len = 0;
1985     for (pos = 0 ; pos < StrChangeCount ; pos++) {
1986     if (TempAttr.Attr != AttrLine[StrChangeStart + pos])
1987     break;
1988     len++;
1989     }
1990     DispSetupDC(TempAttr, FALSE);
1991     DispStr(&CodeLine[StrChangeStart], len, Y, &X);
1992    
1993     /* 残りの文字列があれば、ふつうに描画を行う。*/
1994     if (len < StrChangeCount) {
1995     TempAttr.Attr = AttrLine[StrChangeStart + pos];
1996     TempAttr.Attr2 = AttrLine2[StrChangeStart + pos];
1997     TempAttr.Fore = AttrLineFG[StrChangeStart + pos];
1998     TempAttr.Back = AttrLineBG[StrChangeStart + pos];
1999    
2000     DispSetupDC(TempAttr, FALSE);
2001     DispStr(&CodeLine[StrChangeStart + pos], (StrChangeCount - len), Y, &X);
2002     }
2003     } else {
2004     DispSetupDC(TempAttr, FALSE);
2005     DispStr(&CodeLine[StrChangeStart],StrChangeCount,Y, &X);
2006     }
2007    
2008 maya 3393 StrChangeCount = 0;
2009 maya 3227 }
2010    
2011     #if 0
2012     void UpdateStrUnicode(void)
2013     // Display not-yet-displayed string
2014     {
2015     int X, Y;
2016     TCharAttr TempAttr;
2017    
2018     if (StrChangeCount==0) return;
2019     X = StrChangeStart;
2020     Y = CursorY;
2021     if (! IsLineVisible(&X, &Y))
2022     {
2023     StrChangeCount = 0;
2024     return;
2025     }
2026    
2027     TempAttr.Attr = AttrLine[StrChangeStart];
2028     TempAttr.Attr2 = AttrLine2[StrChangeStart];
2029     TempAttr.Fore = AttrLineFG[StrChangeStart];
2030     TempAttr.Back = AttrLineBG[StrChangeStart];
2031     DispSetupDC(TempAttr, FALSE);
2032     DispStr(&CodeLine[StrChangeStart],StrChangeCount,Y, &X);
2033     StrChangeCount = 0;
2034     }
2035     #endif
2036    
2037     void MoveCursor(int Xnew, int Ynew)
2038     {
2039 maya 3393 UpdateStr();
2040 maya 3227
2041 maya 3393 if (CursorY!=Ynew) {
2042     NewLine(PageStart+Ynew);
2043     }
2044 maya 3227
2045 maya 3393 CursorX = Xnew;
2046     CursorY = Ynew;
2047     Wrap = FALSE;
2048 maya 3227
2049 maya 3393 /* 最下行でだけ自動スクロールする*/
2050 doda 4469 if (ts.AutoScrollOnlyInBottomLine == 0 || WinOrgY == 0) {
2051 maya 3393 DispScrollToCursor(CursorX, CursorY);
2052     }
2053 maya 3227 }
2054    
2055     void MoveRight()
2056     /* move cursor right, but dont update screen.
2057     this procedure must be called from DispChar&DispKanji only */
2058     {
2059 maya 3393 CursorX++;
2060     /* 最下行でだけ自動スクロールする */
2061 doda 4469 if (ts.AutoScrollOnlyInBottomLine == 0 || WinOrgY == 0) {
2062 maya 3393 DispScrollToCursor(CursorX, CursorY);
2063     }
2064 maya 3227 }
2065    
2066     void BuffSetCaretWidth()
2067     {
2068 maya 3393 BOOL DW;
2069 maya 3227
2070 maya 3393 /* check whether cursor on a DBCS character */
2071     DW = (((BYTE)(AttrLine[CursorX]) & AttrKanji) != 0);
2072     DispSetCaretWidth(DW);
2073 maya 3227 }
2074    
2075     void ScrollUp1Line()
2076     {
2077 doda 5324 int i, linelen;
2078 doda 5371 int extl=0, extr=0;
2079 maya 3393 LONG SrcPtr, DestPtr;
2080 maya 3227
2081 maya 3393 if ((CursorTop<=CursorY) && (CursorY<=CursorBottom)) {
2082     UpdateStr();
2083 maya 3227
2084 doda 5371 if (CursorLeftM > 0)
2085     extl = 1;
2086     if (CursorRightM < NumOfColumns-1)
2087     extr = 1;
2088     if (extl || extr)
2089     EraseKanjiOnLRMargin(GetLinePtr(PageStart+CursorTop), CursorBottom-CursorTop+1);
2090    
2091 doda 5324 linelen = CursorRightM - CursorLeftM + 1;
2092     DestPtr = GetLinePtr(PageStart+CursorBottom) + CursorLeftM;
2093 maya 3393 for (i = CursorBottom-1 ; i >= CursorTop ; i--) {
2094     SrcPtr = PrevLinePtr(DestPtr);
2095 doda 5324 memcpy(&(CodeBuff[DestPtr]), &(CodeBuff[SrcPtr]), linelen);
2096     memcpy(&(AttrBuff[DestPtr]), &(AttrBuff[SrcPtr]), linelen);
2097     memcpy(&(AttrBuff2[DestPtr]), &(AttrBuff2[SrcPtr]), linelen);
2098     memcpy(&(AttrBuffFG[DestPtr]), &(AttrBuffFG[SrcPtr]), linelen);
2099     memcpy(&(AttrBuffBG[DestPtr]), &(AttrBuffBG[SrcPtr]), linelen);
2100 maya 3393 DestPtr = SrcPtr;
2101     }
2102 doda 5324 memset(&(CodeBuff[SrcPtr]), 0x20, linelen);
2103     memset(&(AttrBuff[SrcPtr]), AttrDefault, linelen);
2104     memset(&(AttrBuff2[SrcPtr]), CurCharAttr.Attr2 & Attr2ColorMask, linelen);
2105     memset(&(AttrBuffFG[SrcPtr]), CurCharAttr.Fore, linelen);
2106     memset(&(AttrBuffBG[SrcPtr]), CurCharAttr.Back, linelen);
2107 maya 3227
2108 doda 5324 if (CursorLeftM > 0 || CursorRightM < NumOfColumns-1)
2109 doda 5371 BuffUpdateRect(CursorLeftM-extl, CursorTop, CursorRightM+extr, CursorBottom);
2110 doda 5324 else
2111     DispScrollNLines(CursorTop, CursorBottom, -1);
2112 maya 3393 }
2113 maya 3227 }
2114    
2115     void BuffScrollNLines(int n)
2116     {
2117 doda 5324 int i, linelen;
2118 doda 5371 int extl=0, extr=0;
2119 maya 3393 LONG SrcPtr, DestPtr;
2120 maya 3227
2121 maya 3393 if (n<1) {
2122     return;
2123     }
2124     UpdateStr();
2125 maya 3227
2126 doda 5324 if (CursorLeftM == 0 && CursorRightM == NumOfColumns-1 && CursorTop == 0) {
2127     if (CursorBottom == NumOfLines-1) {
2128 maya 3393 WinOrgY = WinOrgY-n;
2129 doda 5324 /* 最下行でだけ自動スクロールする */
2130     if (ts.AutoScrollOnlyInBottomLine != 0 && NewOrgY != 0) {
2131     NewOrgY = WinOrgY;
2132     }
2133 maya 3393 BuffScroll(n,CursorBottom);
2134     DispCountScroll(n);
2135 doda 5324 return;
2136 maya 3393 }
2137 doda 5324 else if (CursorY <= CursorBottom) {
2138     /* 最下行でだけ自動スクロールする */
2139     if (ts.AutoScrollOnlyInBottomLine != 0 && NewOrgY != 0) {
2140     /* スクロールさせない場合の処理 */
2141     WinOrgY = WinOrgY-n;
2142     NewOrgY = WinOrgY;
2143     BuffScroll(n,CursorBottom);
2144     DispCountScroll(n);
2145     } else {
2146     BuffScroll(n,CursorBottom);
2147     DispScrollNLines(WinOrgY,CursorBottom,n);
2148     }
2149     return;
2150     }
2151 maya 3393 }
2152 doda 5324
2153     if ((CursorTop<=CursorY) && (CursorY<=CursorBottom)) {
2154 doda 5371 if (CursorLeftM > 0)
2155     extl = 1;
2156     if (CursorRightM < NumOfColumns-1)
2157     extr = 1;
2158     if (extl || extr)
2159     EraseKanjiOnLRMargin(GetLinePtr(PageStart+CursorTop), CursorBottom-CursorTop+1);
2160    
2161 doda 5324 linelen = CursorRightM - CursorLeftM + 1;
2162     DestPtr = GetLinePtr(PageStart+CursorTop) + (LONG)CursorLeftM;
2163 maya 3393 if (n<CursorBottom-CursorTop+1) {
2164 doda 5324 SrcPtr = GetLinePtr(PageStart+CursorTop+n) + (LONG)CursorLeftM;
2165 maya 3393 for (i = CursorTop+n ; i<=CursorBottom ; i++) {
2166 doda 5324 memmove(&(CodeBuff[DestPtr]), &(CodeBuff[SrcPtr]), linelen);
2167     memmove(&(AttrBuff[DestPtr]), &(AttrBuff[SrcPtr]), linelen);
2168     memmove(&(AttrBuff2[DestPtr]), &(AttrBuff2[SrcPtr]), linelen);
2169     memmove(&(AttrBuffFG[DestPtr]), &(AttrBuffFG[SrcPtr]), linelen);
2170     memmove(&(AttrBuffBG[DestPtr]), &(AttrBuffBG[SrcPtr]), linelen);
2171 maya 3393 SrcPtr = NextLinePtr(SrcPtr);
2172     DestPtr = NextLinePtr(DestPtr);
2173     }
2174     }
2175     else {
2176     n = CursorBottom-CursorTop+1;
2177     }
2178     for (i = CursorBottom+1-n ; i<=CursorBottom; i++) {
2179 doda 5324 memset(&(CodeBuff[DestPtr]), 0x20, linelen);
2180     memset(&(AttrBuff[DestPtr]), AttrDefault, linelen);
2181     memset(&(AttrBuff2[DestPtr]), CurCharAttr.Attr2 & Attr2ColorMask, linelen);
2182     memset(&(AttrBuffFG[DestPtr]), CurCharAttr.Fore, linelen);
2183     memset(&(AttrBuffBG[DestPtr]), CurCharAttr.Back, linelen);
2184 maya 3393 DestPtr = NextLinePtr(DestPtr);
2185     }
2186 doda 5324 if (CursorLeftM > 0 || CursorRightM < NumOfColumns-1)
2187 doda 5371 BuffUpdateRect(CursorLeftM-extl, CursorTop, CursorRightM+extr, CursorBottom);
2188 doda 5324 else
2189     DispScrollNLines(CursorTop, CursorBottom, n);
2190 maya 3393 }
2191 maya 3227 }
2192    
2193     void BuffRegionScrollUpNLines(int n) {
2194 doda 5339 int i, linelen;
2195 doda 5371 int extl=0, extr=0;
2196 maya 3393 LONG SrcPtr,