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