Open-Source-Software-Entwicklung und Downloads

Tera Term

Browse Subversion Repository

/[ttssh2]/trunk/teraterm/ttptek/tekesc.c

Diff of /trunk/teraterm/ttptek/tekesc.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 3226 by maya, Tue Mar 24 09:37:20 2009 UTC revision 3227 by maya, Tue Mar 24 15:10:33 2009 UTC
# Line 1  Line 1 
1  /* Tera Term  /* Tera Term
2   Copyright(C) 1994-1998 T. Teranishi   Copyright(C) 1994-1998 T. Teranishi
3   All rights reserved. */   All rights reserved. */
4    
5  /* TTTEK.DLL, TEK escape sequences */  /* TTTEK.DLL, TEK escape sequences */
6  #include "teraterm.h"  #include "teraterm.h"
7  #include "tttypes.h"  #include "tttypes.h"
8  #include "tektypes.h"  #include "tektypes.h"
9  #include "ttcommon.h"  #include "ttcommon.h"
10  #include <math.h>  #include <math.h>
11  #include <string.h>  #include <string.h>
12    
13  #include "tekesc.h"  #include "tekesc.h"
14    
15  void Log1Byte(PComVar cv, BYTE b)  void Log1Byte(PComVar cv, BYTE b)
16  {  {
17    ((PCHAR)(cv->LogBuf))[cv->LogPtr] = b;    ((PCHAR)(cv->LogBuf))[cv->LogPtr] = b;
18    cv->LogPtr++;    cv->LogPtr++;
19    if (cv->LogPtr >= InBuffSize)    if (cv->LogPtr >= InBuffSize)
20      cv->LogPtr = cv->LogPtr - InBuffSize;      cv->LogPtr = cv->LogPtr - InBuffSize;
21    if (cv->LCount >= InBuffSize)    if (cv->LCount >= InBuffSize)
22    {    {
23      cv->LCount = InBuffSize;      cv->LCount = InBuffSize;
24      cv->LStart = cv->LogPtr;      cv->LStart = cv->LogPtr;
25    }    }
26    else cv->LCount++;    else cv->LCount++;
27  }  }
28    
29  void ChangeTextSize(PTEKVar tk, PTTSet ts)  void ChangeTextSize(PTEKVar tk, PTTSet ts)
30  {  {
31    SelectObject(tk->MemDC,tk->TEKFont[tk->TextSize]);    SelectObject(tk->MemDC,tk->TEKFont[tk->TextSize]);
32    tk->FontWidth = tk->FW[tk->TextSize];    tk->FontWidth = tk->FW[tk->TextSize];
33    tk->FontHeight = tk->FH[tk->TextSize];    tk->FontHeight = tk->FH[tk->TextSize];
34    
35    if (tk->Active) TEKChangeCaret(tk, ts);    if (tk->Active) TEKChangeCaret(tk, ts);
36  }  }
37    
38  void BackSpace(PTEKVar tk, PComVar cv)  void BackSpace(PTEKVar tk, PComVar cv)
39  {  {
40    tk->CaretX = tk->CaretX - tk->FontWidth;    tk->CaretX = tk->CaretX - tk->FontWidth;
41    if (tk->CaretX < 0) tk->CaretX = 0;    if (tk->CaretX < 0) tk->CaretX = 0;
42    if (cv->HLogBuf != NULL) Log1Byte(cv,BS);    if (cv->HLogBuf != NULL) Log1Byte(cv,BS);
43  }  }
44    
45  void LineFeed(PTEKVar tk, PComVar cv)  void LineFeed(PTEKVar tk, PComVar cv)
46  {  {
47    tk->CaretY = tk->CaretY + tk->FontHeight;    tk->CaretY = tk->CaretY + tk->FontHeight;
48    if (tk->CaretY > tk->ScreenHeight)    if (tk->CaretY > tk->ScreenHeight)
49    {    {
50      tk->CaretY = tk->FontHeight;      tk->CaretY = tk->FontHeight;
51      if ((tk->CaretOffset==0) || (tk->CaretX < tk->CaretOffset))      if ((tk->CaretOffset==0) || (tk->CaretX < tk->CaretOffset))
52      {      {
53        tk->CaretOffset = tk->ScreenWidth >> 1;        tk->CaretOffset = tk->ScreenWidth >> 1;
54        tk->CaretX = tk->CaretX + tk->CaretOffset;        tk->CaretX = tk->CaretX + tk->CaretOffset;
55        if (tk->CaretX >= tk->ScreenWidth)        if (tk->CaretX >= tk->ScreenWidth)
56          tk->CaretX = tk->CaretOffset;          tk->CaretX = tk->CaretOffset;
57      }      }
58      else {      else {
59        tk->CaretX = tk->CaretX - tk->CaretOffset;        tk->CaretX = tk->CaretX - tk->CaretOffset;
60        tk->CaretOffset = 0;        tk->CaretOffset = 0;
61      }      }
62    }    }
63    if (cv->HLogBuf != NULL) Log1Byte(cv,LF);    if (cv->HLogBuf != NULL) Log1Byte(cv,LF);
64  }  }
65    
66  void CarriageReturn(PTEKVar tk, PComVar cv)  void CarriageReturn(PTEKVar tk, PComVar cv)
67  {  {
68    tk->CaretX = tk->CaretOffset;    tk->CaretX = tk->CaretOffset;
69    if (cv->HLogBuf != NULL) Log1Byte(cv,CR);    if (cv->HLogBuf != NULL) Log1Byte(cv,CR);
70  }  }
71    
72  void Tab(PTEKVar tk, PComVar cv)  void Tab(PTEKVar tk, PComVar cv)
73  {  {
74    if (cv->HLogBuf != NULL) Log1Byte(cv,HT);    if (cv->HLogBuf != NULL) Log1Byte(cv,HT);
75    tk->CaretX = tk->CaretX + (tk->FontWidth << 3);    tk->CaretX = tk->CaretX + (tk->FontWidth << 3);
76    if (tk->CaretX >= tk->ScreenWidth)    if (tk->CaretX >= tk->ScreenWidth)
77    {    {
78      CarriageReturn(tk,cv);      CarriageReturn(tk,cv);
79      LineFeed(tk,cv);      LineFeed(tk,cv);
80    }    }
81  }  }
82    
83  void EnterVectorMode(PTEKVar tk)  void EnterVectorMode(PTEKVar tk)
84  {  {
85    tk->MoveFlag = TRUE;    tk->MoveFlag = TRUE;
86    tk->Drawing = FALSE;    tk->Drawing = FALSE;
87    tk->DispMode = IdVectorMode;    tk->DispMode = IdVectorMode;
88  }  }
89    
90  void EnterMarkerMode(PTEKVar tk)  void EnterMarkerMode(PTEKVar tk)
91  {  {
92    tk->MoveFlag = TRUE;    tk->MoveFlag = TRUE;
93    tk->Drawing = FALSE;    tk->Drawing = FALSE;
94    tk->DispMode = IdMarkerMode;    tk->DispMode = IdMarkerMode;
95  }  }
96    
97  void EnterPlotMode(PTEKVar tk)  void EnterPlotMode(PTEKVar tk)
98  {  {
99    if (tk->DispMode == IdAlphaMode)    if (tk->DispMode == IdAlphaMode)
100      tk->CaretOffset = 0;      tk->CaretOffset = 0;
101    
102    tk->PlotX =    tk->PlotX =
103      (int)((float)(tk->CaretX) / (float)(tk->ScreenWidth) *      (int)((float)(tk->CaretX) / (float)(tk->ScreenWidth) *
104            (float)(ViewSizeX));            (float)(ViewSizeX));
105    tk->PlotY =    tk->PlotY =
106      (int)((float)(tk->ScreenHeight-1-tk->CaretY) /      (int)((float)(tk->ScreenHeight-1-tk->CaretY) /
107            (float)(tk->ScreenHeight) * (float)(ViewSizeY));            (float)(tk->ScreenHeight) * (float)(ViewSizeY));
108    tk->DispMode = IdPlotMode;    tk->DispMode = IdPlotMode;
109    tk->JustAfterRS = TRUE;    tk->JustAfterRS = TRUE;
110  }  }
111    
112  void EnterAlphaMode(PTEKVar tk)  void EnterAlphaMode(PTEKVar tk)
113  {  {
114    if ((tk->DispMode == IdVectorMode) ||    if ((tk->DispMode == IdVectorMode) ||
115        (tk->DispMode == IdPlotMode))        (tk->DispMode == IdPlotMode))
116      tk->CaretOffset = 0;      tk->CaretOffset = 0;
117    
118    tk->DispMode = IdAlphaMode;    tk->DispMode = IdAlphaMode;
119    tk->Drawing = FALSE;    tk->Drawing = FALSE;
120  }  }
121    
122  void EnterUnknownMode(PTEKVar tk)  void EnterUnknownMode(PTEKVar tk)
123  {  {
124    if ((tk->DispMode == IdVectorMode) ||    if ((tk->DispMode == IdVectorMode) ||
125        (tk->DispMode == IdPlotMode))        (tk->DispMode == IdPlotMode))
126      tk->CaretOffset = 0;      tk->CaretOffset = 0;
127    
128    tk->DispMode = IdUnknownMode;    tk->DispMode = IdUnknownMode;
129  }  }
130    
131  void TEKMoveTo(PTEKVar tk, PTTSet ts, int X, int Y, BOOL Draw)  void TEKMoveTo(PTEKVar tk, PTTSet ts, int X, int Y, BOOL Draw)
132  {  {
133    HDC DC;    HDC DC;
134    HPEN OldPen;    HPEN OldPen;
135    
136    if (Draw)    if (Draw)
137    {    {
138      DC = GetDC(tk->HWin);      DC = GetDC(tk->HWin);
139      OldPen = SelectObject(DC,tk->Pen);      OldPen = SelectObject(DC,tk->Pen);
140      SetBkColor(DC,ts->TEKColor[1]);      SetBkColor(DC,ts->TEKColor[1]);
141      SetBkMode(DC, 1);      SetBkMode(DC, 1);
142      if ((tk->CaretX == X) && (tk->CaretY==Y))      if ((tk->CaretX == X) && (tk->CaretY==Y))
143      {      {
144        SetPixel(DC,X,Y,tk->PenColor);        SetPixel(DC,X,Y,tk->PenColor);
145        SetPixel(tk->MemDC,X,Y,tk->MemPenColor);        SetPixel(tk->MemDC,X,Y,tk->MemPenColor);
146      }      }
147      else {      else {
148        MoveToEx(DC,tk->CaretX,tk->CaretY,NULL);        MoveToEx(DC,tk->CaretX,tk->CaretY,NULL);
149        LineTo(DC,X,Y);        LineTo(DC,X,Y);
150        MoveToEx(tk->MemDC,tk->CaretX,tk->CaretY,NUL);        MoveToEx(tk->MemDC,tk->CaretX,tk->CaretY,NUL);
151        LineTo(tk->MemDC,X,Y);        LineTo(tk->MemDC,X,Y);
152      }      }
153      SelectObject(DC,OldPen);      SelectObject(DC,OldPen);
154      ReleaseDC(tk->HWin,DC);      ReleaseDC(tk->HWin,DC);
155    }    }
156    tk->CaretX = X;    tk->CaretX = X;
157    tk->CaretY = Y;    tk->CaretY = Y;
158  }  }
159    
160  void DrawMarker(PTEKVar tk)  void DrawMarker(PTEKVar tk)
161  {  {
162    BYTE b;    BYTE b;
163    RECT R;    RECT R;
164    HFONT OldFont;    HFONT OldFont;
165    COLORREF OldColor;    COLORREF OldColor;
166    
167    switch (tk->MarkerType) {    switch (tk->MarkerType) {
168      case 0: b = 0xb7; break;      case 0: b = 0xb7; break;
169      case 1: b = '+'; break;      case 1: b = '+'; break;
170      case 2: b = 0xc5; break;      case 2: b = 0xc5; break;
171      case 3: b = '*'; break;      case 3: b = '*'; break;
172      case 4: b = 'o'; break;      case 4: b = 'o'; break;
173      case 5: b = 0xb4; break;      case 5: b = 0xb4; break;
174      case 6: b = 'O'; break;      case 6: b = 'O'; break;
175      case 7: b = 0xe0; break;      case 7: b = 0xe0; break;
176      case 8: b = 0xc6; break;      case 8: b = 0xc6; break;
177      case 9: b = 0xa8; break;      case 9: b = 0xa8; break;
178      case 10: b = 0xa7; break;      case 10: b = 0xa7; break;
179      default:      default:
180        b = '+';        b = '+';
181    }    }
182    OldFont = SelectObject(tk->MemDC,tk->MarkerFont);    OldFont = SelectObject(tk->MemDC,tk->MarkerFont);
183    OldColor = SetTextColor(tk->MemDC,tk->PenColor);    OldColor = SetTextColor(tk->MemDC,tk->PenColor);
184    SetTextAlign(tk->MemDC,TA_CENTER | TA_BOTTOM | TA_NOUPDATECP);    SetTextAlign(tk->MemDC,TA_CENTER | TA_BOTTOM | TA_NOUPDATECP);
185    ExtTextOut(tk->MemDC,tk->CaretX,tk->CaretY+tk->MarkerH/2,    ExtTextOut(tk->MemDC,tk->CaretX,tk->CaretY+tk->MarkerH/2,
186      0,NULL,&b,1,NULL);      0,NULL,&b,1,NULL);
187    SetTextAlign(tk->MemDC,TA_LEFT | TA_BOTTOM | TA_NOUPDATECP);    SetTextAlign(tk->MemDC,TA_LEFT | TA_BOTTOM | TA_NOUPDATECP);
188    SelectObject(tk->MemDC,OldFont);    SelectObject(tk->MemDC,OldFont);
189    SetTextColor(tk->MemDC,OldColor);    SetTextColor(tk->MemDC,OldColor);
190    R.left = tk->CaretX-  tk->MarkerW;    R.left = tk->CaretX-  tk->MarkerW;
191    R.right = tk->CaretX + tk->MarkerW;    R.right = tk->CaretX + tk->MarkerW;
192    R.top = tk->CaretY - tk->MarkerH;    R.top = tk->CaretY - tk->MarkerH;
193    R.bottom = tk->CaretY + tk->MarkerH;    R.bottom = tk->CaretY + tk->MarkerH;
194    InvalidateRect(tk->HWin,&R,FALSE);    InvalidateRect(tk->HWin,&R,FALSE);
195  }  }
196    
197  void Draw(PTEKVar tk, PComVar cv, PTTSet ts, BYTE b)  void Draw(PTEKVar tk, PComVar cv, PTTSet ts, BYTE b)
198  {  {
199    int X, Y;    int X, Y;
200    
201    if (! tk->Drawing)    if (! tk->Drawing)
202    {    {
203      tk->LoXReceive = FALSE;      tk->LoXReceive = FALSE;
204      tk->LoCount = 0;      tk->LoCount = 0;
205      tk->Drawing = TRUE;      tk->Drawing = TRUE;
206      if (tk->DispMode==IdMarkerMode)      if (tk->DispMode==IdMarkerMode)
207      {      {
208        tk->MoveFlag = TRUE;        tk->MoveFlag = TRUE;
209        tk->MarkerFlag = TRUE;        tk->MarkerFlag = TRUE;
210      }      }
211      else      else
212        tk->MarkerFlag = FALSE;        tk->MarkerFlag = FALSE;
213    }    }
214    
215    if (b<=0x1f)    if (b<=0x1f)
216    {    {
217      CommInsert1Byte(cv,b);      CommInsert1Byte(cv,b);
218      return;      return;
219    }    }
220    else if ((b>=0x20) && (b<=0x3f))    else if ((b>=0x20) && (b<=0x3f))
221    {    {
222      if (tk->LoCount==0)      if (tk->LoCount==0)
223        tk->HiY = b - 0x20;        tk->HiY = b - 0x20;
224      else      else
225        tk->HiX = b - 0x20;        tk->HiX = b - 0x20;
226    }    }
227    else if ((b>=0x40) && (b<=0x5f))    else if ((b>=0x40) && (b<=0x5f))
228    {    {
229      tk->LoX = b - 0x40;      tk->LoX = b - 0x40;
230      tk->LoXReceive = TRUE;      tk->LoXReceive = TRUE;
231    }    }
232    else if ((b>=0x60) && (b<=0x7f))    else if ((b>=0x60) && (b<=0x7f))
233    {    {
234      tk->LoA = tk->LoB;      tk->LoA = tk->LoB;
235      tk->LoB = b - 0x60;      tk->LoB = b - 0x60;
236      tk->LoCount++;      tk->LoCount++;
237    }    }
238    
239    if (! tk->LoXReceive) return;    if (! tk->LoXReceive) return;
240    
241    tk->Drawing = FALSE;    tk->Drawing = FALSE;
242    tk->ParseMode = ModeFirst;    tk->ParseMode = ModeFirst;
243    
244    if (tk->LoCount > 1)    if (tk->LoCount > 1)
245      tk->Extra = tk->LoA;      tk->Extra = tk->LoA;
246    if (tk->LoCount > 0)    if (tk->LoCount > 0)
247      tk->LoY = tk->LoB;      tk->LoY = tk->LoB;
248    
249    X = (int)((float)(tk->HiX*128 + tk->LoX*4 + (tk->Extra & 3)) /    X = (int)((float)(tk->HiX*128 + tk->LoX*4 + (tk->Extra & 3)) /
250              (float)(ViewSizeX) * (float)(tk->ScreenWidth));              (float)(ViewSizeX) * (float)(tk->ScreenWidth));
251    Y = tk->ScreenHeight - 1 -    Y = tk->ScreenHeight - 1 -
252      (int)((float)(tk->HiY * 128 + tk->LoY * 4 + tk->Extra / 4) /      (int)((float)(tk->HiY * 128 + tk->LoY * 4 + tk->Extra / 4) /
253            (float)(ViewSizeY) * (float)(tk->ScreenHeight));            (float)(ViewSizeY) * (float)(tk->ScreenHeight));
254    TEKMoveTo(tk,ts,X,Y,! tk->MoveFlag);    TEKMoveTo(tk,ts,X,Y,! tk->MoveFlag);
255    tk->MoveFlag = FALSE;    tk->MoveFlag = FALSE;
256    if (tk->MarkerFlag)    if (tk->MarkerFlag)
257      DrawMarker(tk);      DrawMarker(tk);
258    tk->MarkerFlag = FALSE;    tk->MarkerFlag = FALSE;
259  }  }
260    
261  void Plot(PTEKVar tk, PTTSet ts, BYTE b)  void Plot(PTEKVar tk, PTTSet ts, BYTE b)
262  {  {
263    int X, Y;    int X, Y;
264    
265    X = 0;    X = 0;
266    Y = 0;    Y = 0;
267    switch (b) {    switch (b) {
268      case 'A': X = 4; break;      case 'A': X = 4; break;
269      case 'B': X = -4; break;      case 'B': X = -4; break;
270      case 'D': Y = 4; break;      case 'D': Y = 4; break;
271      case 'E':      case 'E':
272        X = 4;        X = 4;
273        Y = 4;        Y = 4;
274        break;        break;
275      case 'F':      case 'F':
276        X = -4;        X = -4;
277        Y = 4;        Y = 4;
278        break;        break;
279      case 'H': Y = -4; break;      case 'H': Y = -4; break;
280      case 'I':      case 'I':
281        X = 4;        X = 4;
282        Y = -4;        Y = -4;
283        break;        break;
284      case 'J':      case 'J':
285        X = -4;        X = -4;
286        Y = -4;        Y = -4;
287        break;        break;
288      default:      default:
289        return;        return;
290    }    }
291    tk->PlotX = tk->PlotX + X;    tk->PlotX = tk->PlotX + X;
292    if (tk->PlotX < 0) tk->PlotX = 0;    if (tk->PlotX < 0) tk->PlotX = 0;
293    if (tk->PlotX >= ViewSizeX)    if (tk->PlotX >= ViewSizeX)
294      tk->PlotX = ViewSizeX - 1;      tk->PlotX = ViewSizeX - 1;
295    tk->PlotY = tk->PlotY + Y;    tk->PlotY = tk->PlotY + Y;
296    if (tk->PlotY < 0) tk->PlotY = 0;    if (tk->PlotY < 0) tk->PlotY = 0;
297    if (tk->PlotY >= ViewSizeY)    if (tk->PlotY >= ViewSizeY)
298      tk->PlotY = ViewSizeY - 1;      tk->PlotY = ViewSizeY - 1;
299    X = (int)((float)(tk->PlotX) / (float)(ViewSizeX) *    X = (int)((float)(tk->PlotX) / (float)(ViewSizeX) *
300              (float)(tk->ScreenWidth));              (float)(tk->ScreenWidth));
301    Y = tk->ScreenHeight - 1 -    Y = tk->ScreenHeight - 1 -
302      (int)((float)(tk->PlotY) / (float)(ViewSizeY) *      (int)((float)(tk->PlotY) / (float)(ViewSizeY) *
303            (float)(tk->ScreenHeight));            (float)(tk->ScreenHeight));
304    TEKMoveTo(tk,ts,X,Y,tk->PenDown);    TEKMoveTo(tk,ts,X,Y,tk->PenDown);
305  }  }
306    
307  void DispChar(PTEKVar tk, PComVar cv, BYTE b)  void DispChar(PTEKVar tk, PComVar cv, BYTE b)
308  {  {
309    int Dx[2];    int Dx[2];
310    RECT R;    RECT R;
311    
312    Dx[0] = tk->FontWidth;    Dx[0] = tk->FontWidth;
313    Dx[1] = tk->FontWidth;    Dx[1] = tk->FontWidth;
314    ExtTextOut(tk->MemDC,tk->CaretX,tk->CaretY,0,NULL,&b,1,&Dx[0]);    ExtTextOut(tk->MemDC,tk->CaretX,tk->CaretY,0,NULL,&b,1,&Dx[0]);
315    R.left = tk->CaretX;    R.left = tk->CaretX;
316    R.right = tk->CaretX + tk->FontWidth;    R.right = tk->CaretX + tk->FontWidth;
317    R.top = tk->CaretY - tk->FontHeight;    R.top = tk->CaretY - tk->FontHeight;
318    R.bottom = tk->CaretY;    R.bottom = tk->CaretY;
319    InvalidateRect(tk->HWin,&R,FALSE);    InvalidateRect(tk->HWin,&R,FALSE);
320    tk->CaretX = R.right;    tk->CaretX = R.right;
321    
322    if (cv->HLogBuf != NULL) Log1Byte(cv,b);    if (cv->HLogBuf != NULL) Log1Byte(cv,b);
323    
324    if (tk->CaretX > tk->ScreenWidth - tk->FontWidth)    if (tk->CaretX > tk->ScreenWidth - tk->FontWidth)
325    {    {
326      CarriageReturn(tk,cv);      CarriageReturn(tk,cv);
327      LineFeed(tk,cv);      LineFeed(tk,cv);
328    }    }
329  }  }
330    
331  void TEKBeep(PTTSet ts)  void TEKBeep(PTTSet ts)
332  {  {
333    if (ts->Beep!=0)    if (ts->Beep!=0)
334      MessageBeep(0);      MessageBeep(0);
335  }  }
336    
337  void ParseFirst(PTEKVar tk, PTTSet ts, PComVar cv, BYTE b)  void ParseFirst(PTEKVar tk, PTTSet ts, PComVar cv, BYTE b)
338  {  {
339    if (tk->DispMode == IdAlphaMode)    if (tk->DispMode == IdAlphaMode)
340    {    {
341      switch (b) {      switch (b) {
342        case 0x07: TEKBeep(ts); break;        case 0x07: TEKBeep(ts); break;
343        case 0x08: BackSpace(tk,cv); break;        case 0x08: BackSpace(tk,cv); break;
344        case 0x09: Tab(tk,cv); break;        case 0x09: Tab(tk,cv); break;
345        case 0x0a: LineFeed(tk,cv); break;        case 0x0a: LineFeed(tk,cv); break;
346        case 0x0b:        case 0x0b:
347        case 0x0c: break;        case 0x0c: break;
348        case 0x0d:        case 0x0d:
349          CarriageReturn(tk,cv);          CarriageReturn(tk,cv);
350          if (ts->CRReceive==IdCRLF)          if (ts->CRReceive==IdCRLF)
351            CommInsert1Byte(cv,0x0A);            CommInsert1Byte(cv,0x0A);
352          break;          break;
353        case 0x18:        case 0x18:
354          if (ts->AutoWinSwitch > 0)          if (ts->AutoWinSwitch > 0)
355          tk->ChangeEmu = IdVT; /* Enter VT Mode */          tk->ChangeEmu = IdVT; /* Enter VT Mode */
356          break;          break;
357        case 0x19:        case 0x19:
358        case 0x1a: break;        case 0x1a: break;
359        case 0x1b:        case 0x1b:
360          tk->ParseMode = ModeEscape;          tk->ParseMode = ModeEscape;
361          return;          return;
362        case 0x1c: EnterMarkerMode(tk); break;        case 0x1c: EnterMarkerMode(tk); break;
363        case 0x1d: EnterVectorMode(tk); break;        case 0x1d: EnterVectorMode(tk); break;
364        case 0x1e: EnterPlotMode(tk); break;        case 0x1e: EnterPlotMode(tk); break;
365        case 0x1f: break;        case 0x1f: break;
366        case 0x7f: if (tk->Drawing) Draw(tk,cv,ts,b); break;        case 0x7f: if (tk->Drawing) Draw(tk,cv,ts,b); break;
367        default:        default:
368          if (b<=0x06) break;          if (b<=0x06) break;
369          if ((b>=0x0e) && (b<=0x17)) break;          if ((b>=0x0e) && (b<=0x17)) break;
370          if (tk->Drawing) Draw(tk,cv,ts,b);          if (tk->Drawing) Draw(tk,cv,ts,b);
371            else DispChar(tk,cv,b);            else DispChar(tk,cv,b);
372      }      }
373    }    }
374    else if ((tk->DispMode==IdVectorMode) ||    else if ((tk->DispMode==IdVectorMode) ||
375             (tk->DispMode==IdMarkerMode))             (tk->DispMode==IdMarkerMode))
376    {    {
377      switch (b) {      switch (b) {
378        case 0x07:        case 0x07:
379          if (tk->MoveFlag)          if (tk->MoveFlag)
380            tk->MoveFlag = FALSE;            tk->MoveFlag = FALSE;
381          else          else
382            TEKBeep(ts);            TEKBeep(ts);
383          break;          break;
384        case 0x0d:        case 0x0d:
385          CommInsert1Byte(cv,0x0d);          CommInsert1Byte(cv,0x0d);
386          EnterAlphaMode(tk); /* EnterAlphaMode */          EnterAlphaMode(tk); /* EnterAlphaMode */
387          break;          break;
388        case 0x18:        case 0x18:
389          if (ts->AutoWinSwitch > 0)          if (ts->AutoWinSwitch > 0)
390          tk->ChangeEmu = IdVT; /* Enter VT Mode */          tk->ChangeEmu = IdVT; /* Enter VT Mode */
391          break;          break;
392        case 0x19:        case 0x19:
393        case 0x1a: break;        case 0x1a: break;
394        case 0x1b:        case 0x1b:
395          tk->ParseMode = ModeEscape;          tk->ParseMode = ModeEscape;
396          return;          return;
397        case 0x1c: EnterMarkerMode(tk); break;        case 0x1c: EnterMarkerMode(tk); break;
398        case 0x1d: EnterVectorMode(tk); break;        case 0x1d: EnterVectorMode(tk); break;
399        case 0x1e: EnterPlotMode(tk); break;        case 0x1e: EnterPlotMode(tk); break;
400        case 0x1f: EnterAlphaMode(tk); break;        case 0x1f: EnterAlphaMode(tk); break;
401        default:        default:
402          if (b<=0x06) break;          if (b<=0x06) break;
403          if ((b>=0x08) && (b<=0x0c)) break;          if ((b>=0x08) && (b<=0x0c)) break;
404          if ((b>=0x0e) && (b<=0x17)) break;          if ((b>=0x0e) && (b<=0x17)) break;
405          Draw(tk,cv,ts,b);          Draw(tk,cv,ts,b);
406      }      }
407    }    }
408    else if (tk->DispMode==IdPlotMode)    else if (tk->DispMode==IdPlotMode)
409    {    {
410      switch (b) {      switch (b) {
411        case 0x07: TEKBeep(ts); break;        case 0x07: TEKBeep(ts); break;
412        case 0x0d:        case 0x0d:
413          CommInsert1Byte(cv,0x0d);          CommInsert1Byte(cv,0x0d);
414          EnterAlphaMode(tk); /* EnterAlphaMode */          EnterAlphaMode(tk); /* EnterAlphaMode */
415          break;          break;
416        case 0x18:        case 0x18:
417          if (ts->AutoWinSwitch > 0)          if (ts->AutoWinSwitch > 0)
418          tk->ChangeEmu = IdVT; /* Enter VT Mode */          tk->ChangeEmu = IdVT; /* Enter VT Mode */
419          break;          break;
420        case 0x19:        case 0x19:
421        case 0x1a: break;        case 0x1a: break;
422        case 0x1b:        case 0x1b:
423          tk->ParseMode = ModeEscape;          tk->ParseMode = ModeEscape;
424          return;          return;
425        case 0x1c: EnterMarkerMode(tk); break;        case 0x1c: EnterMarkerMode(tk); break;
426        case 0x1d: EnterVectorMode(tk); break;        case 0x1d: EnterVectorMode(tk); break;
427        case 0x1e: EnterPlotMode(tk); break;        case 0x1e: EnterPlotMode(tk); break;
428        case 0x1f: EnterAlphaMode(tk); break; /* EnterAlphaMode */        case 0x1f: EnterAlphaMode(tk); break; /* EnterAlphaMode */
429        case 0x7f: break;        case 0x7f: break;
430        default:        default:
431          if (b<=0x06) break;          if (b<=0x06) break;
432          if ((b>=0x08) && (b<=0x0c)) break;          if ((b>=0x08) && (b<=0x0c)) break;
433          if ((b>=0x0e) && (b<=0x17)) break;          if ((b>=0x0e) && (b<=0x17)) break;
434    
435          if (tk->JustAfterRS)          if (tk->JustAfterRS)
436          {          {
437            if (b==0x20)            if (b==0x20)
438              tk->PenDown = FALSE;              tk->PenDown = FALSE;
439            else if (b=='P')            else if (b=='P')
440              tk->PenDown = TRUE;              tk->PenDown = TRUE;
441            else            else
442              EnterUnknownMode(tk);              EnterUnknownMode(tk);
443            tk->JustAfterRS = FALSE;            tk->JustAfterRS = FALSE;
444          }          }
445          else          else
446            Plot(tk,ts,b);            Plot(tk,ts,b);
447      }      }
448    }    }
449    else {    else {
450      switch (b) {      switch (b) {
451        case 0x1f: EnterAlphaMode(tk); break;        case 0x1f: EnterAlphaMode(tk); break;
452      }      }
453    }    }
454    
455    tk->ParseMode = ModeFirst;    tk->ParseMode = ModeFirst;
456  }  }
457    
458  void SelectCode(PTEKVar tk, PTTSet ts, BYTE b)  void SelectCode(PTEKVar tk, PTTSet ts, BYTE b)
459  {  {
460    switch (b) {    switch (b) {
461      case ' ':      case ' ':
462        if (tk->SelectCodeFlag == '#')        if (tk->SelectCodeFlag == '#')
463          tk->SelectCodeFlag = b;          tk->SelectCodeFlag = b;
464        return;        return;
465      case '!':      case '!':
466        if (tk->SelectCodeFlag == '%')        if (tk->SelectCodeFlag == '%')
467          tk->SelectCodeFlag = b;          tk->SelectCodeFlag = b;
468        return;        return;
469      case '0': break;      case '0': break;
470      case '1':      case '1':
471      case '2':      case '2':
472        if ((tk->SelectCodeFlag == ' ') ||        if ((tk->SelectCodeFlag == ' ') ||
473            (tk->SelectCodeFlag == '!'))            (tk->SelectCodeFlag == '!'))
474          tk->ChangeEmu = IdVT; /* enter VT mode */          tk->ChangeEmu = IdVT; /* enter VT mode */
475        break;        break;
476      case '3':      case '3':
477        if (tk->SelectCodeFlag == '!')        if (tk->SelectCodeFlag == '!')
478          tk->ChangeEmu = IdVT; /* enter VT mode */          tk->ChangeEmu = IdVT; /* enter VT mode */
479        break;        break;
480      case '5':      case '5':
481        if (tk->SelectCodeFlag == ' ')        if (tk->SelectCodeFlag == ' ')
482          tk->ChangeEmu = IdVT; /* enter VT mode */          tk->ChangeEmu = IdVT; /* enter VT mode */
483        break;        break;
484      default:      default:
485        if (b <= US) return;        if (b <= US) return;
486    }    }
487    if ((0x20<=b) && (b<0x7f)) tk->ParseMode = ModeFirst;    if ((0x20<=b) && (b<0x7f)) tk->ParseMode = ModeFirst;
488    tk->SelectCodeFlag = 0;    tk->SelectCodeFlag = 0;
489    if (ts->AutoWinSwitch == 0) tk->ChangeEmu = 0;    if (ts->AutoWinSwitch == 0) tk->ChangeEmu = 0;
490  }  }
491    
492  COLORREF ColorIndex(COLORREF Fore, COLORREF Back, WORD w)  COLORREF ColorIndex(COLORREF Fore, COLORREF Back, WORD w)
493  {  {
494    switch (w) {    switch (w) {
495      case 1:  return Fore;      case 1:  return Fore;
496      case 2:  return RGB(255,  0,  0); /* Red */      case 2:  return RGB(255,  0,  0); /* Red */
497      case 3:  return RGB(  0,255,  0); /* Green */      case 3:  return RGB(  0,255,  0); /* Green */
498      case 4:  return RGB(  0,  0,255); /* Blue */      case 4:  return RGB(  0,  0,255); /* Blue */
499      case 5:  return RGB(  0,255,255); /* Cyan */      case 5:  return RGB(  0,255,255); /* Cyan */
500      case 6:  return RGB(255,  0,255); /* Magenta */      case 6:  return RGB(255,  0,255); /* Magenta */
501      case 7:  return RGB(255,255,  0); /* Yellow */      case 7:  return RGB(255,255,  0); /* Yellow */
502      case 8:  return RGB(255,128,  0); /* Orange */      case 8:  return RGB(255,128,  0); /* Orange */
503      case 9:  return RGB(128,255,  0); /* Green-Yellow */      case 9:  return RGB(128,255,  0); /* Green-Yellow */
504      case 10: return RGB(  0,255,128); /* Green-Cyan */      case 10: return RGB(  0,255,128); /* Green-Cyan */
505      case 11: return RGB(  0,128,255); /* Blue-Cyan */      case 11: return RGB(  0,128,255); /* Blue-Cyan */
506      case 12: return RGB(128,  0,255); /* Blue-Magenta */      case 12: return RGB(128,  0,255); /* Blue-Magenta */
507      case 13: return RGB(255,  0,128); /* Red-Magenta */      case 13: return RGB(255,  0,128); /* Red-Magenta */
508      case 14: return RGB( 85, 85, 85); /* Dark gray */      case 14: return RGB( 85, 85, 85); /* Dark gray */
509      case 15: return RGB(170,170,170); /* Light gray */      case 15: return RGB(170,170,170); /* Light gray */
510    }    }
511    return Back;    return Back;
512  }  }
513    
514  void SetLineIndex(PTEKVar tk, PTTSet ts, WORD w)  void SetLineIndex(PTEKVar tk, PTTSet ts, WORD w)
515  // change graphic color  // change graphic color
516  {  {
517    HDC TempDC;    HDC TempDC;
518    
519    tk->PenColor = ColorIndex(ts->TEKColor[0],ts->TEKColor[1],w);    tk->PenColor = ColorIndex(ts->TEKColor[0],ts->TEKColor[1],w);
520    TempDC = GetDC(tk->HWin);    TempDC = GetDC(tk->HWin);
521    tk->PenColor = GetNearestColor(TempDC,tk->PenColor);    tk->PenColor = GetNearestColor(TempDC,tk->PenColor);
522    ReleaseDC(tk->HWin,TempDC);    ReleaseDC(tk->HWin,TempDC);
523    if (ts->TEKColorEmu > 0)    if (ts->TEKColorEmu > 0)
524      tk->MemPenColor = tk->PenColor;      tk->MemPenColor = tk->PenColor;
525    else    else
526      if (tk->PenColor == ts->TEKColor[1])      if (tk->PenColor == ts->TEKColor[1])
527        tk->MemPenColor = tk->MemBackColor;        tk->MemPenColor = tk->MemBackColor;
528      else      else
529        tk->MemPenColor = tk->MemForeColor;        tk->MemPenColor = tk->MemForeColor;
530    
531    DeleteObject(tk->Pen);    DeleteObject(tk->Pen);
532    tk->Pen = CreatePen(tk->ps,1,tk->PenColor);    tk->Pen = CreatePen(tk->ps,1,tk->PenColor);
533        
534    SelectObject(tk->MemDC, tk->OldMemPen);    SelectObject(tk->MemDC, tk->OldMemPen);
535    DeleteObject(tk->MemPen);    DeleteObject(tk->MemPen);
536    tk->MemPen = CreatePen(tk->ps,1,tk->MemPenColor);    tk->MemPen = CreatePen(tk->ps,1,tk->MemPenColor);
537    tk->OldMemPen = SelectObject(tk->MemDC,tk->MemPen);    tk->OldMemPen = SelectObject(tk->MemDC,tk->MemPen);
538  }  }
539    
540  void SetTextIndex(PTEKVar tk, PTTSet ts, WORD w)  void SetTextIndex(PTEKVar tk, PTTSet ts, WORD w)
541  // change text color  // change text color
542  {  {
543    HDC TempDC;    HDC TempDC;
544    
545    tk->TextColor = ColorIndex(ts->TEKColor[0],ts->TEKColor[1],w);    tk->TextColor = ColorIndex(ts->TEKColor[0],ts->TEKColor[1],w);
546    TempDC = GetDC(tk->HWin);    TempDC = GetDC(tk->HWin);
547    tk->TextColor = GetNearestColor(TempDC,tk->TextColor);    tk->TextColor = GetNearestColor(TempDC,tk->TextColor);
548    ReleaseDC(tk->HWin,TempDC);    ReleaseDC(tk->HWin,TempDC);
549    if (ts->TEKColorEmu > 0)    if (ts->TEKColorEmu > 0)
550      tk->MemTextColor = tk->TextColor;      tk->MemTextColor = tk->TextColor;
551    else    else
552      if (tk->TextColor == ts->TEKColor[1])      if (tk->TextColor == ts->TEKColor[1])
553        tk->MemTextColor = tk->MemBackColor;        tk->MemTextColor = tk->MemBackColor;
554      else      else
555        tk->MemTextColor = tk->MemForeColor;        tk->MemTextColor = tk->MemForeColor;
556    
557    SetTextColor(tk->MemDC, tk->MemTextColor);    SetTextColor(tk->MemDC, tk->MemTextColor);
558  }  }
559    
560  void SetColorIndex(PTEKVar tk, PTTSet ts, WORD w)  void SetColorIndex(PTEKVar tk, PTTSet ts, WORD w)
561  // change color for text & graphics  // change color for text & graphics
562  {  {
563    SetLineIndex(tk,ts,w);    SetLineIndex(tk,ts,w);
564    SetTextIndex(tk,ts,w);    SetTextIndex(tk,ts,w);
565  }  }
566    
567  void SetLineStyle(PTEKVar tk, BYTE b)  void SetLineStyle(PTEKVar tk, BYTE b)
568  {  {
569    switch (b) {    switch (b) {
570      case 0: tk->ps = PS_SOLID; break;      case 0: tk->ps = PS_SOLID; break;
571      case 1: tk->ps = PS_DOT; break;      case 1: tk->ps = PS_DOT; break;
572      case 2: tk->ps = PS_DASHDOT; break;      case 2: tk->ps = PS_DASHDOT; break;
573      case 3: tk->ps = PS_DASH; break;      case 3: tk->ps = PS_DASH; break;
574      case 4: tk->ps = PS_DASH; break;      case 4: tk->ps = PS_DASH; break;
575      case 5: tk->ps = PS_DASHDOTDOT; break;      case 5: tk->ps = PS_DASHDOTDOT; break;
576      case 6: tk->ps = PS_DASHDOT; break;      case 6: tk->ps = PS_DASHDOT; break;
577      case 7: tk->ps = PS_DASH; break;      case 7: tk->ps = PS_DASH; break;
578      case 8: tk->ps = PS_DASHDOTDOT; break;      case 8: tk->ps = PS_DASHDOTDOT; break;
579      default:      default:
580        tk->ps = PS_SOLID;        tk->ps = PS_SOLID;
581    }    }
582    if (tk->Pen != NULL) DeleteObject(tk->Pen);    if (tk->Pen != NULL) DeleteObject(tk->Pen);
583    tk->Pen = CreatePen(tk->ps,1,tk->PenColor);    tk->Pen = CreatePen(tk->ps,1,tk->PenColor);
584    
585    SelectObject(tk->MemDC, tk->OldMemPen);    SelectObject(tk->MemDC, tk->OldMemPen);
586    if (tk->MemPen != NULL) DeleteObject(tk->MemPen);    if (tk->MemPen != NULL) DeleteObject(tk->MemPen);
587    tk->MemPen = CreatePen(tk->ps,1,tk->MemPenColor);    tk->MemPen = CreatePen(tk->ps,1,tk->MemPenColor);
588    tk->OldMemPen = SelectObject(tk->MemDC,tk->MemPen);    tk->OldMemPen = SelectObject(tk->MemDC,tk->MemPen);
589  }  }
590    
591  void TwoOpCode(PTEKVar tk, PTTSet ts, PComVar cv, BYTE b)  void TwoOpCode(PTEKVar tk, PTTSet ts, PComVar cv, BYTE b)
592  {  {
593    double Re;    double Re;
594    
595    if (tk->OpCount == 2)    if (tk->OpCount == 2)
596    {    {
597      tk->OpCount--;      tk->OpCount--;
598      tk->Op2OC = b << 8;      tk->Op2OC = b << 8;
599      return;      return;
600    }    }
601    else if (tk->OpCount == 1)    else if (tk->OpCount == 1)
602    {    {
603      if (b <= 0x1a) return;      if (b <= 0x1a) return;
604      else if ((b>=0x1b) && (b<=0x1f))      else if ((b>=0x1b) && (b<=0x1f))
605      {      {
606        CommInsert1Byte(cv,b);        CommInsert1Byte(cv,b);
607        tk->ParseMode = ModeFirst;        tk->ParseMode = ModeFirst;
608        return;        return;
609      }      }
610      else {      else {
611        tk->OpCount--;        tk->OpCount--;
612        tk->Op2OC = tk->Op2OC + b;        tk->Op2OC = tk->Op2OC + b;
613        switch (tk->Op2OC) {        switch (tk->Op2OC) {
614          case IdMove: tk->PrmCountMax = 0; break;          case IdMove: tk->PrmCountMax = 0; break;
615          case IdDraw: tk->PrmCountMax = 0; break;          case IdDraw: tk->PrmCountMax = 0; break;
616          case IdDrawMarker: tk->PrmCountMax = 0; break;          case IdDrawMarker: tk->PrmCountMax = 0; break;
617          case IdGraphText: tk->PrmCountMax = 1; break;          case IdGraphText: tk->PrmCountMax = 1; break;
618          case IdSetDialogVisibility: tk->PrmCountMax = 1; break;          case IdSetDialogVisibility: tk->PrmCountMax = 1; break;
619          case IdSetGraphTextSize: tk->PrmCountMax = 3; break;          case IdSetGraphTextSize: tk->PrmCountMax = 3; break;
620          case IdSetWriteMode: tk->PrmCountMax = 1; break;          case IdSetWriteMode: tk->PrmCountMax = 1; break;
621          case IdSetLineIndex: tk->PrmCountMax = 1; break;          case IdSetLineIndex: tk->PrmCountMax = 1; break;
622          case IdSetMarkerType: tk->PrmCountMax = 1; break;          case IdSetMarkerType: tk->PrmCountMax = 1; break;
623          case IdSetCharPath: tk->PrmCountMax = 1; break;          case IdSetCharPath: tk->PrmCountMax = 1; break;
624          case IdSetPrecision: tk->PrmCountMax = 1; break;          case IdSetPrecision: tk->PrmCountMax = 1; break;
625          case IdSetRotation: tk->PrmCountMax = 2; break;          case IdSetRotation: tk->PrmCountMax = 2; break;
626          case IdSetTextIndex: tk->PrmCountMax = 1; break;          case IdSetTextIndex: tk->PrmCountMax = 1; break;
627          case IdSetLineStyle: tk->PrmCountMax = 1; break;          case IdSetLineStyle: tk->PrmCountMax = 1; break;
628          default:          default:
629            tk->PrmCountMax = 0;            tk->PrmCountMax = 0;
630        }        }
631        memset(tk->Prm2OC,0,sizeof(tk->Prm2OC));        memset(tk->Prm2OC,0,sizeof(tk->Prm2OC));
632        tk->PrmCount = 0;        tk->PrmCount = 0;
633        if (tk->PrmCountMax > 0) return;        if (tk->PrmCountMax > 0) return;
634      }      }
635    }    }
636    
637    if (tk->PrmCount < tk->PrmCountMax)    if (tk->PrmCount < tk->PrmCountMax)
638    {    {
639      if (b <= 0x1a) return;      if (b <= 0x1a) return;
640      else if ((b>=0x1b) && (b<=0x1f))      else if ((b>=0x1b) && (b<=0x1f))
641      {      {
642        CommInsert1Byte(cv,b);        CommInsert1Byte(cv,b);
643        tk->PrmCount = tk->PrmCountMax;        tk->PrmCount = tk->PrmCountMax;
644        tk->ParseMode = ModeFirst;        tk->ParseMode = ModeFirst;
645      }      }
646      else if ((b>=0x20) && (b<=0x2f))      else if ((b>=0x20) && (b<=0x2f))
647      {  /* LoI (minus) */      {  /* LoI (minus) */
648        tk->Prm2OC[tk->PrmCount] =        tk->Prm2OC[tk->PrmCount] =
649          - (tk->Prm2OC[tk->PrmCount]*16 + b - 0x20);          - (tk->Prm2OC[tk->PrmCount]*16 + b - 0x20);
650        tk->PrmCount++;        tk->PrmCount++;
651      }      }
652      else if ((b>=0x30) && (b<=0x3f))      else if ((b>=0x30) && (b<=0x3f))
653      {  /* LoI (plus) */      {  /* LoI (plus) */
654        tk->Prm2OC[tk->PrmCount] =        tk->Prm2OC[tk->PrmCount] =
655        tk->Prm2OC[tk->PrmCount]*16 + b - 0x30;        tk->Prm2OC[tk->PrmCount]*16 + b - 0x30;
656        tk->PrmCount++;        tk->PrmCount++;
657      }      }
658      else if ((b>=0x40) && (b<=0x7f))      else if ((b>=0x40) && (b<=0x7f))
659        tk->Prm2OC[tk->PrmCount] =        tk->Prm2OC[tk->PrmCount] =
660        tk->Prm2OC[tk->PrmCount]*64 + b - 0x40;        tk->Prm2OC[tk->PrmCount]*64 + b - 0x40;
661    }    }
662    
663    if (tk->PrmCount < tk->PrmCountMax) return;    if (tk->PrmCount < tk->PrmCountMax) return;
664    
665    switch (tk->Op2OC) {    switch (tk->Op2OC) {
666      case IdMove:      case IdMove:
667        tk->LoXReceive = FALSE;        tk->LoXReceive = FALSE;
668        tk->LoCount = 0;        tk->LoCount = 0;
669        tk->Drawing = TRUE;        tk->Drawing = TRUE;
670        tk->MoveFlag = TRUE;        tk->MoveFlag = TRUE;
671        tk->MarkerFlag = FALSE;        tk->MarkerFlag = FALSE;
672        break;        break;
673      case IdDraw:      case IdDraw:
674        tk->LoXReceive = FALSE;        tk->LoXReceive = FALSE;
675        tk->LoCount = 0;        tk->LoCount = 0;
676        tk->Drawing = TRUE;        tk->Drawing = TRUE;
677        tk->MoveFlag = FALSE;        tk->MoveFlag = FALSE;
678        tk->MarkerFlag = FALSE;        tk->MarkerFlag = FALSE;
679        break;        break;
680      case IdDrawMarker:      case IdDrawMarker:
681        tk->LoXReceive = FALSE;        tk->LoXReceive = FALSE;
682        tk->LoCount = 0;        tk->LoCount = 0;
683        tk->Drawing = TRUE;        tk->Drawing = TRUE;
684        tk->MoveFlag = TRUE;        tk->MoveFlag = TRUE;
685        tk->MarkerFlag = TRUE;        tk->MarkerFlag = TRUE;
686        break;        break;
687      case IdGraphText:      case IdGraphText:
688        tk->GTCount = 0;        tk->GTCount = 0;
689        tk->GTLen = tk->Prm2OC[0];        tk->GTLen = tk->Prm2OC[0];
690        if (tk->GTLen>0)        if (tk->GTLen>0)
691          tk->ParseMode = ModeGT;          tk->ParseMode = ModeGT;
692        else        else
693          tk->ParseMode = ModeFirst;          tk->ParseMode = ModeFirst;
694        return;        return;
695      case IdSetDialogVisibility: break;      case IdSetDialogVisibility: break;
696      case IdSetGraphTextSize:      case IdSetGraphTextSize:
697        tk->GTWidth = tk->Prm2OC[0];        tk->GTWidth = tk->Prm2OC[0];
698        tk->GTHeight = tk->Prm2OC[1];        tk->GTHeight = tk->Prm2OC[1];
699        tk->GTSpacing = tk->Prm2OC[2];        tk->GTSpacing = tk->Prm2OC[2];
700        if ((tk->GTWidth==0) &&        if ((tk->GTWidth==0) &&
701            (tk->GTHeight==0) &&            (tk->GTHeight==0) &&
702            (tk->GTSpacing==0))            (tk->GTSpacing==0))
703        {        {
704          tk->GTWidth=39;          tk->GTWidth=39;
705          tk->GTHeight=59;          tk->GTHeight=59;
706          tk->GTSpacing=12;          tk->GTSpacing=12;
707        }        }
708        if (tk->GTWidth<=0) tk->GTWidth=39;        if (tk->GTWidth<=0) tk->GTWidth=39;
709        if (tk->GTHeight<=0) tk->GTWidth=59;        if (tk->GTHeight<=0) tk->GTWidth=59;
710        if (tk->GTSpacing<=0) tk->GTSpacing=0;        if (tk->GTSpacing<=0) tk->GTSpacing=0;
711        break;        break;
712      case IdSetWriteMode: break;      case IdSetWriteMode: break;
713      case IdSetLineIndex:      case IdSetLineIndex:
714        SetLineIndex(tk,ts,tk->Prm2OC[0]);        SetLineIndex(tk,ts,tk->Prm2OC[0]);
715        break;        break;
716      case IdSetMarkerType:      case IdSetMarkerType:
717        tk->MarkerType = tk->Prm2OC[0];        tk->MarkerType = tk->Prm2OC[0];
718        break;        break;
719      case IdSetCharPath: break;      case IdSetCharPath: break;
720      case IdSetPrecision: break;      case IdSetPrecision: break;
721      case IdSetRotation:      case IdSetRotation:
722        Re = (double)tk->Prm2OC[0] *        Re = (double)tk->Prm2OC[0] *
723          pow(2.0,(double)tk->Prm2OC[1]);          pow(2.0,(double)tk->Prm2OC[1]);
724        Re = fmod(Re,360.0);        Re = fmod(Re,360.0);
725        if (Re<0) Re = Re + 360.0;        if (Re<0) Re = Re + 360.0;
726        if (Re<45.0)        if (Re<45.0)
727          tk->GTAngle=0;          tk->GTAngle=0;
728        else if (Re<135.0)        else if (Re<135.0)
729          tk->GTAngle = 1;          tk->GTAngle = 1;
730        else if (Re<315.0)        else if (Re<315.0)
731          tk->GTAngle = 2;          tk->GTAngle = 2;
732        else        else
733          tk->GTAngle = 3;          tk->GTAngle = 3;
734        break;        break;
735      case IdSetTextIndex:      case IdSetTextIndex:
736        SetTextIndex(tk,ts,tk->Prm2OC[0]);        SetTextIndex(tk,ts,tk->Prm2OC[0]);
737        break;        break;
738      case IdSetLineStyle:      case IdSetLineStyle:
739        SetLineStyle(tk,(BYTE)(tk->Prm2OC[0]));        SetLineStyle(tk,(BYTE)(tk->Prm2OC[0]));
740        break;        break;
741    }    }
742    
743    tk->ParseMode = ModeFirst;    tk->ParseMode = ModeFirst;
744  }  }
745    
746    void EscPage(PTEKVar tk) /* Clear Screen and enter ALPHAMODE */    void EscPage(PTEKVar tk) /* Clear Screen and enter ALPHAMODE */
747    {    {
748      RECT R;      RECT R;
749    
750      SetLineStyle(tk,0);      SetLineStyle(tk,0);
751      GetClientRect(tk->HWin,&R);      GetClientRect(tk->HWin,&R);
752      FillRect(tk->MemDC,&R,tk->MemBackGround);      FillRect(tk->MemDC,&R,tk->MemBackGround);
753      InvalidateRect(tk->HWin,&R,FALSE);      InvalidateRect(tk->HWin,&R,FALSE);
754      UpdateWindow(tk->HWin);      UpdateWindow(tk->HWin);
755      EnterAlphaMode(tk);      EnterAlphaMode(tk);
756      tk->CaretX = 0;      tk->CaretX = 0;
757      tk->CaretOffset = 0;      tk->CaretOffset = 0;
758      tk->CaretY = 0;      tk->CaretY = 0;
759    }    }
760    
761  void TEKEscape(PTEKVar tk, PTTSet ts, PComVar cv, BYTE b)  void TEKEscape(PTEKVar tk, PTTSet ts, PComVar cv, BYTE b)
762  {  {
763    switch (b) {    switch (b) {
764      case 0x00: return;      case 0x00: return;
765      case 0x0a: return;      case 0x0a: return;
766      case 0x0c: EscPage(tk); break;      case 0x0c: EscPage(tk); break;
767      case 0x0d: return;      case 0x0d: return;
768      case 0x1a:      case 0x1a:
769        tk->GIN = TRUE;        tk->GIN = TRUE;
770        /* Capture mouse */        /* Capture mouse */
771        SetCapture(tk->HWin);        SetCapture(tk->HWin);
772        EnterAlphaMode(tk);        EnterAlphaMode(tk);
773        break;        break;
774      case 0x1b: return;      case 0x1b: return;
775      case 0x1c:      case 0x1c:
776      case 0x1d:      case 0x1d:
777      case 0x1e:      case 0x1e:
778      case 0x1f:      case 0x1f:
779        CommInsert1Byte(cv,b); break;        CommInsert1Byte(cv,b); break;
780      case '#':      case '#':
781        tk->ParseMode = ModeSelectCode;        tk->ParseMode = ModeSelectCode;
782        tk->SelectCodeFlag = b;        tk->SelectCodeFlag = b;
783        return;        return;
784      case '%':      case '%':
785        tk->ParseMode = ModeSelectCode;        tk->ParseMode = ModeSelectCode;
786        tk->SelectCodeFlag = b;        tk->SelectCodeFlag = b;
787        return;        return;
788      case '2':      case '2':
789        if (ts->AutoWinSwitch > 0)        if (ts->AutoWinSwitch > 0)
790          tk->ChangeEmu = IdVT; /* Enter VT Mode */          tk->ChangeEmu = IdVT; /* Enter VT Mode */
791        break;        break;
792      case '[':      case '[':
793        tk->CSCount = 0;        tk->CSCount = 0;
794        tk->ParseMode = ModeCS;        tk->ParseMode = ModeCS;
795        return;        return;
796      case 0x7f: return;      case 0x7f: return;
797      default:      default:
798        if ((b>='8') && (b<=';'))        if ((b>='8') && (b<=';'))
799        {        {
800          if (tk->TextSize != b-0x38)          if (tk->TextSize != b-0x38)
801          {          {
802            tk->TextSize = b-0x38;            tk->TextSize = b-0x38;
803            ChangeTextSize(tk,ts);            ChangeTextSize(tk,ts);
804          }          }
805          break;          break;
806        }        }
807        else if ((b>='I') && (b<='Z'))        else if ((b>='I') && (b<='Z'))
808        {        {
809          tk->ParseMode = Mode2OC;          tk->ParseMode = Mode2OC;
810          tk->OpCount = 2;          tk->OpCount = 2;
811          TwoOpCode(tk,ts,cv,b);          TwoOpCode(tk,ts,cv,b);
812          return;          return;
813        }        }
814        else if ((b>=0x60) && (b<=0x6f))        else if ((b>=0x60) && (b<=0x6f))
815        {        {
816          SetLineStyle(tk,(BYTE)((b-0x60) & 7));          SetLineStyle(tk,(BYTE)((b-0x60) & 7));
817          break;          break;
818        }        }
819    }    }
820    tk->ParseMode = ModeFirst;    tk->ParseMode = ModeFirst;
821  }  }
822    
823    void CSSetAttr(PTEKVar tk, PTTSet ts)    void CSSetAttr(PTEKVar tk, PTTSet ts)
824    {    {
825      int i, P;      int i, P;
826    
827      for (i=1 ; i<=tk->NParam ; i++)      for (i=1 ; i<=tk->NParam ; i++)
828      {      {
829        P = tk->Param[i];        P = tk->Param[i];
830        if (P<0) P = 0;        if (P<0) P = 0;
831        switch (P) {        switch (P) {
832          /* Clear */          /* Clear */
833          case 0:          case 0:
834            SetColorIndex(tk,ts,1);            SetColorIndex(tk,ts,1);
835            break;            break;
836          /* Bold */          /* Bold */
837          case 1:          case 1:
838            break;            break;
839          /* Under line */          /* Under line */
840          case 4:          case 4:
841            break;            break;
842          /* Blink */          /* Blink */
843          case 5:          case 5:
844            break;            break;
845          /* Reverse */          /* Reverse */
846          case 7:          case 7:
847            break;            break;
848          /* Bold off */          /* Bold off */
849          case 22:          case 22:
850            break;            break;
851          /* Under line off */          /* Under line off */
852          case 24:          case 24:
853            break;            break;
854          /* Blink off */          /* Blink off */
855          case 25:          case 25:
856            break;            break;
857          /* Reverse off */          /* Reverse off */
858          case 27:          case 27:
859            break;            break;
860          // colors for text & graphics          // colors for text & graphics
861          case 30: SetColorIndex(tk,ts,0); break;          case 30: SetColorIndex(tk,ts,0); break;
862          case 31: SetColorIndex(tk,ts,2); break;          case 31: SetColorIndex(tk,ts,2); break;
863          case 32: SetColorIndex(tk,ts,3); break;          case 32: SetColorIndex(tk,ts,3); break;
864          case 33: SetColorIndex(tk,ts,7); break;          case 33: SetColorIndex(tk,ts,7); break;
865          case 34: SetColorIndex(tk,ts,4); break;          case 34: SetColorIndex(tk,ts,4); break;
866          case 35: SetColorIndex(tk,ts,6); break;          case 35: SetColorIndex(tk,ts,6); break;
867          case 36: SetColorIndex(tk,ts,5); break;          case 36: SetColorIndex(tk,ts,5); break;
868          case 37: SetColorIndex(tk,ts,1); break;          case 37: SetColorIndex(tk,ts,1); break;
869          case 39: SetColorIndex(tk,ts,1); break;          case 39: SetColorIndex(tk,ts,1); break;
870        }        }
871      }      }
872    }    }
873    
874  void ParseCS(PTEKVar tk, PTTSet ts, PComVar cv)  void ParseCS(PTEKVar tk, PTTSet ts, PComVar cv)
875  {  {
876    #define IntCharMax 5    #define IntCharMax 5
877    int i = 0;    int i = 0;
878    BYTE IntChar[IntCharMax+1];    BYTE IntChar[IntCharMax+1];
879    int ICount = 0;    int ICount = 0;
880    BOOL FirstPrm = TRUE;    BOOL FirstPrm = TRUE;
881    BYTE Prv = 0;    BYTE Prv = 0;
882    BOOL MoveToVT;    BOOL MoveToVT;
883    BYTE b;    BYTE b;
884    
885    tk->NParam = 1;    tk->NParam = 1;
886    tk->Param[1] = -1;    tk->Param[1] = -1;
887    do {    do {
888      b = tk->CSBuff[i++];      b = tk->CSBuff[i++];
889      if ((b>=0x20) && (b<=0x2F))      if ((b>=0x20) && (b<=0x2F))
890      {      {
891        if (ICount<IntCharMax) ICount++;        if (ICount<IntCharMax) ICount++;
892        IntChar[ICount] = b;        IntChar[ICount] = b;
893      }      }
894      else if ((b>=0x30) && (b<=0x39))      else if ((b>=0x30) && (b<=0x39))
895      {      {
896        if (tk->Param[tk->NParam] < 0)        if (tk->Param[tk->NParam] < 0)
897          tk->Param[tk->NParam] = 0;          tk->Param[tk->NParam] = 0;
898        if (tk->Param[tk->NParam]<1000)        if (tk->Param[tk->NParam]<1000)
899          tk->Param[tk->NParam] = tk->Param[tk->NParam]*10 + b - 0x30;          tk->Param[tk->NParam] = tk->Param[tk->NParam]*10 + b - 0x30;
900      }      }
901      else if (b==0x3B)      else if (b==0x3B)
902      {      {
903        if (tk->NParam < NParamMax)        if (tk->NParam < NParamMax)
904        {        {
905          tk->NParam++;          tk->NParam++;
906          tk->Param[tk->NParam] = -1;          tk->Param[tk->NParam] = -1;
907        }        }
908      }      }
909      else if ((b>=0x3C) && (b<=0x3F))      else if ((b>=0x3C) && (b<=0x3F))
910      {      {
911        if (FirstPrm) Prv = b;        if (FirstPrm) Prv = b;
912      }      }
913      FirstPrm = FALSE;      FirstPrm = FALSE;
914    } while ((i<tk->CSCount) &&    } while ((i<tk->CSCount) &&
915             ! ((b>=0x40) && (b<=0x7E)));             ! ((b>=0x40) && (b<=0x7E)));
916    
917    MoveToVT = FALSE;    MoveToVT = FALSE;
918    if ((b>=0x40) && (b<=0x7E))    if ((b>=0x40) && (b<=0x7E))
919    {    {
920      switch (ICount) {      switch (ICount) {
921        /* no intermediate char */        /* no intermediate char */
922        case 0:        case 0:
923          switch (Prv) {          switch (Prv) {
924            /* no private parameters */            /* no private parameters */
925            case 0:            case 0:
926              switch (b) {              switch (b) {
927                case 'm': CSSetAttr(tk,ts); break;                case 'm': CSSetAttr(tk,ts); break;
928                default: MoveToVT = TRUE;                default: MoveToVT = TRUE;
929              }              }
930              break;              break;
931            case '?':            case '?':
932              // ignore ^[?38h (select TEK mode)              // ignore ^[?38h (select TEK mode)
933              if ((b!='h') || (tk->Param[1]!=38))              if ((b!='h') || (tk->Param[1]!=38))
934                MoveToVT = TRUE;                MoveToVT = TRUE;
935              break;              break;
936            default:            default:
937              MoveToVT = TRUE;              MoveToVT = TRUE;
938          }          }
939          break;          break;
940        default:        default:
941          MoveToVT = TRUE;          MoveToVT = TRUE;
942      } /* end of switch (Icount) */      } /* end of switch (Icount) */
943    }    }
944    else    else
945      MoveToVT = TRUE;      MoveToVT = TRUE;
946    
947    if ((ts->AutoWinSwitch>0) && MoveToVT)    if ((ts->AutoWinSwitch>0) && MoveToVT)
948    {    {
949      for (i=tk->CSCount-1 ; i>=0; i--)      for (i=tk->CSCount-1 ; i>=0; i--)
950        CommInsert1Byte(cv,tk->CSBuff[i]);        CommInsert1Byte(cv,tk->CSBuff[i]);
951      CommInsert1Byte(cv,0x5B);      CommInsert1Byte(cv,0x5B);
952      CommInsert1Byte(cv,0x1B);      CommInsert1Byte(cv,0x1B);
953      tk->ChangeEmu = IdVT;      tk->ChangeEmu = IdVT;
954    }    }
955    tk->ParseMode = ModeFirst;    tk->ParseMode = ModeFirst;
956  }  }
957    
958  void ControlSequence(PTEKVar tk, PTTSet ts, PComVar cv, BYTE b)  void ControlSequence(PTEKVar tk, PTTSet ts, PComVar cv, BYTE b)
959  {  {
960    switch (b) {    switch (b) {
961      case 0x1B:      case 0x1B:
962      case 0x1C:      case 0x1C:
963      case 0x1D:      case 0x1D:
964      case 0x1E:      case 0x1E:
965      case 0x1F:      case 0x1F:
966        CommInsert1Byte(cv,b); break;        CommInsert1Byte(cv,b); break;
967      default:      default:
968        if (tk->CSCount < sizeof(tk->CSBuff))        if (tk->CSCount < sizeof(tk->CSBuff))
969        {        {
970          tk->CSBuff[tk->CSCount++] = b;          tk->CSBuff[tk->CSCount++] = b;
971          if ((b>=0x40) && (b<=0x7E))          if ((b>=0x40) && (b<=0x7E))
972            ParseCS(tk,ts,cv);            ParseCS(tk,ts,cv);
973          return;          return;
974        }        }
975    }    }
976    tk->ParseMode = ModeFirst;    tk->ParseMode = ModeFirst;
977  }  }
978    
979  void GraphText(PTEKVar tk, PTTSet ts, PComVar cv, BYTE b)  void GraphText(PTEKVar tk, PTTSet ts, PComVar cv, BYTE b)
980  {  {
981    int i, Dx[80];    int i, Dx[80];
982    HFONT TempFont, TempOld;    HFONT TempFont, TempOld;
983    LOGFONT lf;    LOGFONT lf;
984    RECT R;    RECT R;
985    int W, H;    int W, H;
986    TEXTMETRIC Metrics;    TEXTMETRIC Metrics;
987    
988    switch (b) {    switch (b) {
989      case 0x1B:      case 0x1B:
990      case 0x1C:      case 0x1C:
991      case 0x1D:      case 0x1D:
992      case 0x1E:      case 0x1E:
993      case 0x1F:      case 0x1F:
994        CommInsert1Byte(cv,b); break;        CommInsert1Byte(cv,b); break;
995      default:      default:
996        tk->GTBuff[tk->GTCount++] = b;        tk->GTBuff[tk->GTCount++] = b;
997        if ((tk->GTCount>=sizeof(tk->GTBuff)) ||        if ((tk->GTCount>=sizeof(tk->GTBuff)) ||
998            (tk->GTCount>=tk->GTLen))            (tk->GTCount>=tk->GTLen))
999        {        {
1000          memcpy(&lf,&tk->TEKlf,sizeof(lf));          memcpy(&lf,&tk->TEKlf,sizeof(lf));
1001          switch (tk->GTAngle) {          switch (tk->GTAngle) {
1002            case 0: lf.lfEscapement = 0; break;            case 0: lf.lfEscapement = 0; break;
1003            case 1: lf.lfEscapement = 900; break;            case 1: lf.lfEscapement = 900; break;
1004            case 2: lf.lfEscapement = 1800; break;            case 2: lf.lfEscapement = 1800; break;
1005            case 3: lf.lfEscapement = 2700; break;            case 3: lf.lfEscapement = 2700; break;
1006          }          }
1007          W = (int)((float)tk->GTWidth / (float)ViewSizeX *          W = (int)((float)tk->GTWidth / (float)ViewSizeX *
1008                    (float)tk->ScreenWidth);                    (float)tk->ScreenWidth);
1009          H = (int)((float)tk->GTHeight / (float)ViewSizeY *          H = (int)((float)tk->GTHeight / (float)ViewSizeY *
1010                    (float)tk->ScreenHeight);                    (float)tk->ScreenHeight);
1011          lf.lfWidth = W;          lf.lfWidth = W;
1012          lf.lfHeight = H;          lf.lfHeight = H;
1013          TempFont = CreateFontIndirect(&lf);                      TempFont = CreateFontIndirect(&lf);            
1014          TempOld = SelectObject(tk->MemDC,TempFont);          TempOld = SelectObject(tk->MemDC,TempFont);
1015          W = (int)((float)(tk->GTWidth + tk->GTSpacing) /          W = (int)((float)(tk->GTWidth + tk->GTSpacing) /
1016                    (float)ViewSizeX *                    (float)ViewSizeX *
1017                    (float)tk->ScreenWidth);                    (float)tk->ScreenWidth);
1018          GetTextMetrics(tk->MemDC, &Metrics);          GetTextMetrics(tk->MemDC, &Metrics);
1019          if (W < Metrics.tmAveCharWidth)          if (W < Metrics.tmAveCharWidth)
1020            W = Metrics.tmAveCharWidth;            W = Metrics.tmAveCharWidth;
1021          H = Metrics.tmHeight;          H = Metrics.tmHeight;
1022          for (i=0; i <= tk->GTLen; i++)          for (i=0; i <= tk->GTLen; i++)
1023            Dx[i] = W;            Dx[i] = W;
1024          SetTextAlign(tk->MemDC,TA_LEFT | TA_BASELINE | TA_NOUPDATECP);          SetTextAlign(tk->MemDC,TA_LEFT | TA_BASELINE | TA_NOUPDATECP);
1025          ExtTextOut(tk->MemDC,tk->CaretX,tk->CaretY,0,NULL,tk->GTBuff,tk->GTLen,&Dx[0]);          ExtTextOut(tk->MemDC,tk->CaretX,tk->CaretY,0,NULL,tk->GTBuff,tk->GTLen,&Dx[0]);
1026          SetTextAlign(tk->MemDC,TA_LEFT | TA_BOTTOM | TA_NOUPDATECP);          SetTextAlign(tk->MemDC,TA_LEFT | TA_BOTTOM | TA_NOUPDATECP);
1027          SelectObject(tk->MemDC,TempOld);          SelectObject(tk->MemDC,TempOld);
1028          DeleteObject(TempFont);          DeleteObject(TempFont);
1029          switch (tk->GTAngle) {          switch (tk->GTAngle) {
1030            case 0:            case 0:
1031              R.left = tk->CaretX;              R.left = tk->CaretX;
1032              R.top = tk->CaretY - H;              R.top = tk->CaretY - H;
1033              R.right = tk->CaretX + tk->GTLen*W;              R.right = tk->CaretX + tk->GTLen*W;
1034              R.bottom = tk->CaretY + H;              R.bottom = tk->CaretY + H;
1035              tk->CaretX = R.right;              tk->CaretX = R.right;
1036              break;              break;
1037            case 1:            case 1:
1038              R.left = tk->CaretX - H;              R.left = tk->CaretX - H;
1039              R.top = tk->CaretY - tk->GTLen*W;              R.top = tk->CaretY - tk->GTLen*W;
1040              R.right = tk->CaretX + H;              R.right = tk->CaretX + H;
1041              R.bottom = tk->CaretY;              R.bottom = tk->CaretY;
1042              tk->CaretY = R.top;              tk->CaretY = R.top;
1043              break;              break;
1044            case 2:            case 2:
1045              R.left = tk->CaretX - tk->GTLen*W;              R.left = tk->CaretX - tk->GTLen*W;
1046              R.top = tk->CaretY - H;              R.top = tk->CaretY - H;
1047              R.right = tk->CaretX;              R.right = tk->CaretX;
1048              R.bottom = tk->CaretY + H;              R.bottom = tk->CaretY + H;
1049              tk->CaretX = R.left;              tk->CaretX = R.left;
1050              break;              break;
1051            case 3:            case 3:
1052              R.left = tk->CaretX - H;              R.left = tk->CaretX - H;
1053              R.top = tk->CaretY;              R.top = tk->CaretY;
1054              R.right = tk->CaretX + H;              R.right = tk->CaretX + H;
1055              R.bottom = tk->CaretY + tk->GTLen*W;              R.bottom = tk->CaretY + tk->GTLen*W;
1056              tk->CaretY = R.bottom;              tk->CaretY = R.bottom;
1057              break;              break;
1058          }          }
1059          InvalidateRect(tk->HWin,&R,FALSE);          InvalidateRect(tk->HWin,&R,FALSE);
1060          break;          break;
1061        }        }
1062        return;        return;
1063    }    }
1064    tk->ParseMode = ModeFirst;    tk->ParseMode = ModeFirst;
1065  }  }
Legend:
Removed from v.3226  
changed lines
  Added in v.3227
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
Über OSDN
Software suchen
Entwickeln Software
Hilfeseiten