![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tty.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / comm|
Return to tty.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / comm |
1.1 root 1: //---------------------------------------------------------------------------
2: //
3: // Module: tty.c
4: //
5: // Purpose:
6: // The sample application demonstrates the usage of the COMM
7: // API. It implements the new COMM API of Windows 3.1.
8: //
9: // NOTE: no escape sequences are translated, only
10: // the necessary control codes (LF, CR, BS, etc.)
11: //
12: // Description of functions:
13: // Descriptions are contained in the function headers.
14: //
15: // Development Team:
16: // Bryan A. Woodruff
17: //
18: // History: Date Author Comment
19: //
20: // 5/ 8/91 BryanW Wrote it.
21: //
22: // 10/18/91 BryanW Sanitized code & comments.
23: //
24: // 10/22/91 BryanW Minor bug fixes.
25: //
26: // 12/31/91 BryanW Ported to Win32 (NT).
27: //
28: // 2/10/92 BryanW Fixed a problem with ReadCommBlock()
29: // and error detection. ReadComm() is
30: // now performed... if the result is < 0
31: // the error status is read using
32: // GetCommError() and displayed. The
33: // length is adjusted (*= -1).
34: //
35: // 2/13/92 BryanW Updated to provide the option to
36: // implement/handle CN_RECEIVE
37: // notifications.
38: //
39: // 2/13/92 BryanW Implemented forced DTR control. DTR
40: // is asserted on connect and dropped
41: // on disconnect.
42: //
43: // 2/21/92 BryanW Removed overhead of local memory
44: // functions - now uses LPTR for
45: // allocation from heap.
46: //
47: // 2/26/92 BryanW Fixed off by one problem in paint
48: // calculations.
49: //
50: // 6/15/92 BryanW Ported the "updated" version of TTY
51: // for Win 3.1 including bug fixes.
52: //
53: //---------------------------------------------------------------------------
54: //
55: // Written by Microsoft Product Support Services, Windows Developer Support.
56: // Copyright (c) 1991 Microsoft Corporation. All Rights Reserved.
57: //
58: //---------------------------------------------------------------------------
59:
60: #include "tty.h"
61:
62: //---------------------------------------------------------------------------
63: // int PASCAL WinMain( HANDLE hInstance, HANDLE hPrevInstance,
64: // LPSTR lpszCmdLine, int nCmdShow )
65: //
66: // Description:
67: // This is the main window loop!
68: //
69: // Parameters:
70: // As documented for all WinMain() functions.
71: //
72: // History: Date Author Comment
73: // 5/ 8/91 BryanW Wrote it.
74: //
75: //---------------------------------------------------------------------------
76:
77: int PASCAL WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance,
78: LPSTR lpszCmdLine, int nCmdShow )
79: {
80: HWND hTTYWnd ;
81: MSG msg ;
82:
83: if (!hPrevInstance)
84: if (!InitApplication( hInstance ))
85: return ( FALSE ) ;
86:
87: if (NULL == (hTTYWnd = InitInstance( hInstance, nCmdShow )))
88: return ( FALSE ) ;
89:
90: while (GetMessage( &msg, NULL, 0, 0 ))
91: {
92: if (!TranslateAccelerator( hTTYWnd, ghAccel, &msg ))
93: {
94: TranslateMessage( &msg ) ;
95: DispatchMessage( &msg ) ;
96: }
97: }
98: return ( (int) msg.wParam ) ;
99:
100: } // end of WinMain()
101:
102: //---------------------------------------------------------------------------
103: // BOOL NEAR InitApplication( HANDLE hInstance )
104: //
105: // Description:
106: // First time initialization stuff. This registers information
107: // such as window classes.
108: //
109: // Parameters:
110: // HANDLE hInstance
111: // Handle to this instance of the application.
112: //
113: // History: Date Author Comment
114: // 5/ 8/91 BryanW Wrote it.
115: // 10/22/91 BryanW Fixed background color problem.
116: //
117: //---------------------------------------------------------------------------
118:
119: BOOL NEAR InitApplication( HANDLE hInstance )
120: {
121: WNDCLASS wndclass ;
122:
123: // register tty window class
124:
125: wndclass.style = NULL ;
126: wndclass.lpfnWndProc = TTYWndProc ;
127: wndclass.cbClsExtra = 0 ;
128: wndclass.cbWndExtra = TTYEXTRABYTES ;
129: wndclass.hInstance = hInstance ;
130: wndclass.hIcon = LoadIcon( hInstance, MAKEINTRESOURCE( TTYICON ) );
131: wndclass.hCursor = LoadCursor( NULL, IDC_ARROW ) ;
132: wndclass.hbrBackground = (HBRUSH) (COLOR_WINDOW + 1) ;
133: wndclass.lpszMenuName = MAKEINTRESOURCE( TTYMENU ) ;
134: wndclass.lpszClassName = gszTTYClass ;
135:
136: return( RegisterClass( &wndclass ) ) ;
137:
138: } // end of InitApplication()
139:
140: //---------------------------------------------------------------------------
141: // HWND NEAR InitInstance( HANDLE hInstance, int nCmdShow )
142: //
143: // Description:
144: // Initializes instance specific information.
145: //
146: // Parameters:
147: // HANDLE hInstance
148: // Handle to instance
149: //
150: // int nCmdShow
151: // How do we show the window?
152: //
153: // History: Date Author Comment
154: // 5/ 8/91 BryanW Wrote it.
155: //
156: //---------------------------------------------------------------------------
157:
158: HWND NEAR InitInstance( HANDLE hInstance, int nCmdShow )
159: {
160: HWND hTTYWnd ;
161:
162: // load accelerators
163: ghAccel = LoadAccelerators( hInstance, MAKEINTRESOURCE( TTYACCEL ) ) ;
164:
165: // create the TTY window
166: hTTYWnd = CreateWindow( gszTTYClass, gszAppName,
167: WS_OVERLAPPEDWINDOW,
168: CW_USEDEFAULT, CW_USEDEFAULT,
169: CW_USEDEFAULT, CW_USEDEFAULT,
170: NULL, NULL, hInstance, NULL ) ;
171:
172: if (NULL == hTTYWnd)
173: return ( NULL ) ;
174:
175: ShowWindow( hTTYWnd, nCmdShow ) ;
176: UpdateWindow( hTTYWnd ) ;
177:
178: return ( hTTYWnd ) ;
179:
180: } // end of InitInstance()
181:
182: //---------------------------------------------------------------------------
183: // LRESULT FAR PASCAL TTYWndProc( HWND hWnd, UINT uMsg,
184: // WPARAM wParam, LPARAM lParam )
185: //
186: // Description:
187: // This is the TTY Window Proc. This handles ALL messages
188: // to the tty window.
189: //
190: // Parameters:
191: // As documented for Window procedures.
192: //
193: // Win-32 Porting Issues:
194: // - WM_HSCROLL and WM_VSCROLL packing is different under Win-32.
195: // - Needed LOWORD() of wParam for WM_CHAR messages.
196: //
197: // History: Date Author Comment
198: // 5/ 9/91 BryanW Wrote it.
199: // 6/15/92 BryanW Kill focus before disconnecting.
200: // 6/15/92 BryanW Ported to Win-32.
201: //
202: //---------------------------------------------------------------------------
203:
204: LRESULT FAR PASCAL TTYWndProc( HWND hWnd, UINT uMsg,
205: WPARAM wParam, LPARAM lParam )
206: {
207: switch (uMsg)
208: {
209: case WM_CREATE:
210: return ( CreateTTYInfo( hWnd ) ) ;
211:
212: case WM_COMMAND:
213: {
214: switch ( LOWORD( wParam ) )
215: {
216: case IDM_CONNECT:
217: if (!OpenConnection( hWnd ))
218: MessageBox( hWnd, "Connection failed.", gszAppName,
219: MB_ICONEXCLAMATION ) ;
220: break ;
221:
222: case IDM_DISCONNECT:
223: KillTTYFocus( hWnd ) ;
224: CloseConnection( hWnd ) ;
225: break ;
226:
227: case IDM_SETTINGS:
228: {
229: NPTTYINFO npTTYInfo ;
230:
231: if (NULL == (npTTYInfo = GETNPTTYINFO( hWnd )))
232: return ( FALSE ) ;
233: GoModalDialogBoxParam( GETHINST( hWnd ),
234: MAKEINTRESOURCE( SETTINGSDLGBOX ), hWnd,
235: SettingsDlgProc,
236: (LPARAM) (LPSTR) npTTYInfo ) ;
237:
238: // if fConnected, set new COM parameters
239:
240: if (CONNECTED( npTTYInfo ))
241: {
242: if (!SetupConnection( hWnd ))
243: MessageBox( hWnd, "Settings failed!", gszAppName,
244: MB_ICONEXCLAMATION ) ;
245: }
246: }
247: break ;
248:
249: case IDM_ABOUT:
250: GoModalDialogBoxParam ( GETHINST( hWnd ),
251: MAKEINTRESOURCE( ABOUTDLGBOX ),
252: hWnd,
253: AboutDlgProc, NULL ) ;
254: break;
255:
256: case IDM_EXIT:
257: PostMessage( hWnd, WM_CLOSE, NULL, 0L ) ;
258: break ;
259: }
260: }
261: break ;
262:
263: case WM_COMMNOTIFY:
264: ProcessCOMMNotification( hWnd, wParam, lParam ) ;
265: break ;
266:
267: case WM_PAINT:
268: PaintTTY( hWnd ) ;
269: break ;
270:
271: case WM_SIZE:
272: SizeTTY( hWnd, HIWORD( lParam ), LOWORD( lParam ) ) ;
273: break ;
274:
275: case WM_HSCROLL:
276: #ifdef WIN32
277: ScrollTTYHorz( hWnd, LOWORD( wParam ), HIWORD( wParam ) ) ;
278: #else
279: ScrollTTYHorz( hWnd, (WORD) wParam, LOWORD( lParam ) ) ;
280: #endif
281: break ;
282:
283: case WM_VSCROLL:
284: #ifdef WIN32
285: ScrollTTYVert( hWnd, LOWORD( wParam ), HIWORD( wParam ) ) ;
286: #else
287: ScrollTTYVert( hWnd, (WORD) wParam, LOWORD( lParam ) ) ;
288: #endif
289: break ;
290:
291: case WM_CHAR:
292: #ifdef WIN32
293: ProcessTTYCharacter( hWnd, LOBYTE( LOWORD( wParam ) ) ) ;
294: #else
295: ProcessTTYCharacter( hWnd, LOBYTE( wParam ) ) ;
296: #endif
297: break ;
298:
299: case WM_SETFOCUS:
300: SetTTYFocus( hWnd ) ;
301: break ;
302:
303: case WM_KILLFOCUS:
304: KillTTYFocus( hWnd ) ;
305: break ;
306:
307: case WM_DESTROY:
308: DestroyTTYInfo( hWnd ) ;
309: PostQuitMessage( 0 ) ;
310: break ;
311:
312: case WM_CLOSE:
313: if (IDOK != MessageBox( hWnd, "OK to close window?", "TTY Sample",
314: MB_ICONQUESTION | MB_OKCANCEL ))
315: break ;
316:
317: // fall through
318:
319: default:
320: return( DefWindowProc( hWnd, uMsg, wParam, lParam ) ) ;
321: }
322: return 0L ;
323:
324: } // end of TTYWndProc()
325:
326: //---------------------------------------------------------------------------
327: // LRESULT NEAR CreateTTYInfo( HWND hWnd )
328: //
329: // Description:
330: // Creates the tty information structure and sets
331: // menu option availability. Returns -1 if unsuccessful.
332: //
333: // Parameters:
334: // HWND hWnd
335: // Handle to main window.
336: //
337: // Win-32 Porting Issues:
338: // - Needed to initialize TERMWND( npTTYInfo ) for secondary thread.
339: // - Needed to create/initialize overlapped structures used in reads &
340: // writes to COMM device.
341: //
342: // History: Date Author Comment
343: // 10/18/91 BryanW Pulled from tty window proc.
344: // 1/13/92 BryanW Fixed bug with invalid handle
345: // caused by WM_SIZE sent by
346: // ResetTTYScreen().
347: //
348: //---------------------------------------------------------------------------
349:
350: LRESULT NEAR CreateTTYInfo( HWND hWnd )
351: {
352: HMENU hMenu ;
353: NPTTYINFO npTTYInfo ;
354:
355: if (NULL == (npTTYInfo =
356: (NPTTYINFO) LocalAlloc( LPTR, sizeof( TTYINFO ) )))
357: return ( (LRESULT) -1 ) ;
358:
359: // initialize TTY info structure
360:
361: COMDEV( npTTYInfo ) = 0 ;
362: CONNECTED( npTTYInfo ) = FALSE ;
363: CURSORSTATE( npTTYInfo ) = CS_HIDE ;
364: LOCALECHO( npTTYInfo ) = FALSE ;
365: AUTOWRAP( npTTYInfo ) = TRUE ;
366: PORT( npTTYInfo ) = 1 ;
367: BAUDRATE( npTTYInfo ) = CBR_9600 ;
368: BYTESIZE( npTTYInfo ) = 8 ;
369: FLOWCTRL( npTTYInfo ) = FC_RTSCTS ;
370: PARITY( npTTYInfo ) = NOPARITY ;
371: STOPBITS( npTTYInfo ) = ONESTOPBIT ;
372: XONXOFF( npTTYInfo ) = FALSE ;
373: XSIZE( npTTYInfo ) = 0 ;
374: YSIZE( npTTYInfo ) = 0 ;
375: XSCROLL( npTTYInfo ) = 0 ;
376: YSCROLL( npTTYInfo ) = 0 ;
377: XOFFSET( npTTYInfo ) = 0 ;
378: YOFFSET( npTTYInfo ) = 0 ;
379: COLUMN( npTTYInfo ) = 0 ;
380: ROW( npTTYInfo ) = 0 ;
381: HTTYFONT( npTTYInfo ) = NULL ;
382: FGCOLOR( npTTYInfo ) = RGB( 0, 0, 0 ) ;
383: USECNRECEIVE( npTTYInfo ) = TRUE ;
384: DISPLAYERRORS( npTTYInfo ) = TRUE ;
385: #ifdef WIN32
386: TERMWND( npTTYInfo ) = hWnd ;
387:
388: // create I/O event used for overlapped reads / writes
389:
390: READ_OS( npTTYInfo ).hEvent = CreateEvent( NULL, // no security
391: TRUE, // explicit reset req
392: FALSE, // initial event reset
393: NULL ) ; // no name
394: if (READ_OS( npTTYInfo ).hEvent == NULL)
395: {
396: LocalFree( npTTYInfo ) ;
397: return ( -1 ) ;
398: }
399: WRITE_OS( npTTYInfo ).hEvent = CreateEvent( NULL, // no security
400: TRUE, // explicit reset req
401: FALSE, // initial event reset
402: NULL ) ; // no name
403: if (NULL == WRITE_OS( npTTYInfo ).hEvent)
404: {
405: CloseHandle( READ_OS( npTTYInfo ).hEvent ) ;
406: LocalFree( npTTYInfo ) ;
407: return ( -1 ) ;
408: }
409:
410: // create "posted notification" event
411:
412: POSTEVENT( npTTYInfo ) = CreateEvent( NULL, // no security
413: TRUE, // manual reset
414: TRUE, // initial event is set
415: NULL ) ; // no name
416:
417: if (POSTEVENT( npTTYInfo ) == NULL)
418: {
419: CloseHandle( READ_OS( npTTYInfo ).hEvent ) ;
420: CloseHandle( WRITE_OS( npTTYInfo ).hEvent ) ;
421: LocalFree( npTTYInfo ) ;
422: return ( -1 ) ;
423: }
424: #endif
425:
426: // clear screen space
427:
428: _fmemset( SCREEN( npTTYInfo ), ' ', MAXROWS * MAXCOLS ) ;
429:
430: // setup default font information
431:
432: LFTTYFONT( npTTYInfo ).lfHeight = 12 ;
433: LFTTYFONT( npTTYInfo ).lfWidth = 0 ;
434: LFTTYFONT( npTTYInfo ).lfEscapement = 0 ;
435: LFTTYFONT( npTTYInfo ).lfOrientation = 0 ;
436: LFTTYFONT( npTTYInfo ).lfWeight = 0 ;
437: LFTTYFONT( npTTYInfo ).lfItalic = 0 ;
438: LFTTYFONT( npTTYInfo ).lfUnderline = 0 ;
439: LFTTYFONT( npTTYInfo ).lfStrikeOut = 0 ;
440: LFTTYFONT( npTTYInfo ).lfCharSet = OEM_CHARSET ;
441: LFTTYFONT( npTTYInfo ).lfOutPrecision = OUT_DEFAULT_PRECIS ;
442: LFTTYFONT( npTTYInfo ).lfClipPrecision = CLIP_DEFAULT_PRECIS ;
443: LFTTYFONT( npTTYInfo ).lfQuality = DEFAULT_QUALITY ;
444: LFTTYFONT( npTTYInfo ).lfPitchAndFamily = FIXED_PITCH | FF_MODERN ;
445: LFTTYFONT( npTTYInfo ).lfFaceName[0] = NULL ;
446:
447: // set TTYInfo handle before any further message processing.
448:
449: SETNPTTYINFO( hWnd, npTTYInfo ) ;
450:
451: // reset the character information, etc.
452:
453: ResetTTYScreen( hWnd, npTTYInfo ) ;
454:
455: hMenu = GetMenu( hWnd ) ;
456: EnableMenuItem( hMenu, IDM_DISCONNECT,
457: MF_GRAYED | MF_DISABLED | MF_BYCOMMAND ) ;
458: EnableMenuItem( hMenu, IDM_CONNECT, MF_ENABLED | MF_BYCOMMAND ) ;
459:
460: return ( (LRESULT) TRUE ) ;
461:
462: } // end of CreateTTYInfo()
463:
464: //---------------------------------------------------------------------------
465: // BOOL NEAR DestroyTTYInfo( HWND hWnd )
466: //
467: // Description:
468: // Destroys block associated with TTY window handle.
469: //
470: // Parameters:
471: // HWND hWnd
472: // handle to TTY window
473: //
474: // Win-32 Porting Issues:
475: // - Needed to clean up event objects created during initialization.
476: //
477: // History: Date Author Comment
478: // 5/ 8/91 BryanW Wrote it.
479: // 6/15/92 BryanW Ported to Win-32.
480: //
481: //---------------------------------------------------------------------------
482:
483: BOOL NEAR DestroyTTYInfo( HWND hWnd )
484: {
485: NPTTYINFO npTTYInfo ;
486:
487: if (NULL == (npTTYInfo = GETNPTTYINFO( hWnd )))
488: return ( FALSE ) ;
489:
490: // force connection closed (if not already closed)
491:
492: if (CONNECTED( npTTYInfo ))
493: CloseConnection( hWnd ) ;
494:
495: #ifdef WIN32
496: // clean up event objects
497:
498: CloseHandle( READ_OS( npTTYInfo ).hEvent ) ;
499: CloseHandle( WRITE_OS( npTTYInfo ).hEvent ) ;
500: CloseHandle( POSTEVENT( npTTYInfo ) ) ;
501: #endif
502:
503: DeleteObject( HTTYFONT( npTTYInfo ) ) ;
504:
505: LocalFree( npTTYInfo ) ;
506: return ( TRUE ) ;
507:
508: } // end of DestroyTTYInfo()
509:
510: //---------------------------------------------------------------------------
511: // BOOL NEAR ResetTTYScreen( HWND hWnd, NPTTYINFO npTTYInfo )
512: //
513: // Description:
514: // Resets the TTY character information and causes the
515: // screen to resize to update the scroll information.
516: //
517: // Parameters:
518: // NPTTYINFO npTTYInfo
519: // pointer to TTY info structure
520: //
521: // History: Date Author Comment
522: // 10/20/91 BryanW Wrote it.
523: //
524: //---------------------------------------------------------------------------
525:
526: BOOL NEAR ResetTTYScreen( HWND hWnd, NPTTYINFO npTTYInfo )
527: {
528: HDC hDC ;
529: TEXTMETRIC tm ;
530: RECT rcWindow ;
531:
532: if (NULL == npTTYInfo)
533: return ( FALSE ) ;
534:
535: if (NULL != HTTYFONT( npTTYInfo ))
536: DeleteObject( HTTYFONT( npTTYInfo ) ) ;
537:
538: HTTYFONT( npTTYInfo ) = CreateFontIndirect( &LFTTYFONT( npTTYInfo ) ) ;
539:
540: hDC = GetDC( hWnd ) ;
541: SelectObject( hDC, HTTYFONT( npTTYInfo ) ) ;
542: GetTextMetrics( hDC, &tm ) ;
543: ReleaseDC( hWnd, hDC ) ;
544:
545: XCHAR( npTTYInfo ) = tm.tmAveCharWidth ;
546: YCHAR( npTTYInfo ) = tm.tmHeight + tm.tmExternalLeading ;
547:
548: // a slimy hack to force the scroll position, region to
549: // be recalculated based on the new character sizes
550:
551: GetWindowRect( hWnd, &rcWindow ) ;
552: SendMessage( hWnd, WM_SIZE, SIZENORMAL,
553: (LPARAM) MAKELONG( rcWindow.right - rcWindow.left,
554: rcWindow.bottom - rcWindow.top ) ) ;
555:
556: return ( TRUE ) ;
557:
558: } // end of ResetTTYScreen()
559:
560: //---------------------------------------------------------------------------
561: // BOOL NEAR PaintTTY( HWND hWnd )
562: //
563: // Description:
564: // Paints the rectangle determined by the paint struct of
565: // the DC.
566: //
567: // Parameters:
568: // HWND hWnd
569: // handle to TTY window (as always)
570: //
571: // History: Date Author Comment
572: // 5/ 9/91 BryanW Wrote it.
573: // 10/22/91 BryanW Problem with background color
574: // and "off by one" fixed.
575: //
576: // 2/25/92 BryanW Off-by-one not quite fixed...
577: // also resolved min/max problem
578: // for windows extended beyond
579: // the "TTY display".
580: //
581: //---------------------------------------------------------------------------
582:
583: BOOL NEAR PaintTTY( HWND hWnd )
584: {
585: int nRow, nCol, nEndRow, nEndCol, nCount, nHorzPos, nVertPos ;
586: HDC hDC ;
587: HFONT hOldFont ;
588: NPTTYINFO npTTYInfo ;
589: PAINTSTRUCT ps ;
590: RECT rect ;
591:
592: if (NULL == (npTTYInfo = GETNPTTYINFO( hWnd )))
593: return ( FALSE ) ;
594:
595: hDC = BeginPaint( hWnd, &ps ) ;
596: hOldFont = SelectObject( hDC, HTTYFONT( npTTYInfo ) ) ;
597: SetTextColor( hDC, FGCOLOR( npTTYInfo ) ) ;
598: SetBkColor( hDC, GetSysColor( COLOR_WINDOW ) ) ;
599: rect = ps.rcPaint ;
600: nRow =
601: min( MAXROWS - 1,
602: max( 0, (rect.top + YOFFSET( npTTYInfo )) / YCHAR( npTTYInfo ) ) ) ;
603: nEndRow =
604: min( MAXROWS - 1,
605: ((rect.bottom + YOFFSET( npTTYInfo ) - 1) / YCHAR( npTTYInfo ) ) ) ;
606: nCol =
607: min( MAXCOLS - 1,
608: max( 0, (rect.left + XOFFSET( npTTYInfo )) / XCHAR( npTTYInfo ) ) ) ;
609: nEndCol =
610: min( MAXCOLS - 1,
611: ((rect.right + XOFFSET( npTTYInfo ) - 1) / XCHAR( npTTYInfo ) ) ) ;
612: nCount = nEndCol - nCol + 1 ;
613: for (; nRow <= nEndRow; nRow++)
614: {
615: nVertPos = (nRow * YCHAR( npTTYInfo )) - YOFFSET( npTTYInfo ) ;
616: nHorzPos = (nCol * XCHAR( npTTYInfo )) - XOFFSET( npTTYInfo ) ;
617: rect.top = nVertPos ;
618: rect.bottom = nVertPos + YCHAR( npTTYInfo ) ;
619: rect.left = nHorzPos ;
620: rect.right = nHorzPos + XCHAR( npTTYInfo ) * nCount ;
621: SetBkMode( hDC, OPAQUE ) ;
622: ExtTextOut( hDC, nHorzPos, nVertPos, ETO_OPAQUE | ETO_CLIPPED, &rect,
623: (LPSTR)( SCREEN( npTTYInfo ) + nRow * MAXCOLS + nCol ),
624: nCount, NULL ) ;
625: }
626: SelectObject( hDC, hOldFont ) ;
627: EndPaint( hWnd, &ps ) ;
628: MoveTTYCursor( hWnd ) ;
629: return ( TRUE ) ;
630:
631: } // end of PaintTTY()
632:
633: //---------------------------------------------------------------------------
634: // BOOL NEAR SizeTTY( HWND hWnd, WORD wVertSize, WORD wHorzSize )
635: //
636: // Description:
637: // Sizes TTY and sets up scrolling regions.
638: //
639: // Parameters:
640: // HWND hWnd
641: // handle to TTY window
642: //
643: // WORD wVertSize
644: // new vertical size
645: //
646: // WORD wHorzSize
647: // new horizontal size
648: //
649: // History: Date Author Comment
650: // 5/ 8/ 91 BryanW Wrote it
651: //
652: //---------------------------------------------------------------------------
653:
654: BOOL NEAR SizeTTY( HWND hWnd, WORD wVertSize, WORD wHorzSize )
655: {
656: int nScrollAmt ;
657: NPTTYINFO npTTYInfo ;
658:
659: if (NULL == (npTTYInfo = GETNPTTYINFO( hWnd )))
660: return ( FALSE ) ;
661:
662: YSIZE( npTTYInfo ) = (int) wVertSize ;
663: YSCROLL( npTTYInfo ) = max( 0, (MAXROWS * YCHAR( npTTYInfo )) -
664: YSIZE( npTTYInfo ) ) ;
665: nScrollAmt = min( YSCROLL( npTTYInfo ), YOFFSET( npTTYInfo ) ) -
666: YOFFSET( npTTYInfo ) ;
667: ScrollWindow( hWnd, 0, -nScrollAmt, NULL, NULL ) ;
668:
669: YOFFSET( npTTYInfo ) = YOFFSET( npTTYInfo ) + nScrollAmt ;
670: SetScrollPos( hWnd, SB_VERT, YOFFSET( npTTYInfo ), FALSE ) ;
671: SetScrollRange( hWnd, SB_VERT, 0, YSCROLL( npTTYInfo ), TRUE ) ;
672:
673: XSIZE( npTTYInfo ) = (int) wHorzSize ;
674: XSCROLL( npTTYInfo ) = max( 0, (MAXCOLS * XCHAR( npTTYInfo )) -
675: XSIZE( npTTYInfo ) ) ;
676: nScrollAmt = min( XSCROLL( npTTYInfo ), XOFFSET( npTTYInfo )) -
677: XOFFSET( npTTYInfo ) ;
678: ScrollWindow( hWnd, 0, -nScrollAmt, NULL, NULL ) ;
679: XOFFSET( npTTYInfo ) = XOFFSET( npTTYInfo ) + nScrollAmt ;
680: SetScrollPos( hWnd, SB_HORZ, XOFFSET( npTTYInfo ), FALSE ) ;
681: SetScrollRange( hWnd, SB_HORZ, 0, XSCROLL( npTTYInfo ), TRUE ) ;
682:
683: InvalidateRect( hWnd, NULL, TRUE ) ;
684:
685: return ( TRUE ) ;
686:
687: } // end of SizeTTY()
688:
689: //---------------------------------------------------------------------------
690: // BOOL NEAR ScrollTTYVert( HWND hWnd, WORD wScrollCmd, WORD wScrollPos )
691: //
692: // Description:
693: // Scrolls TTY window vertically.
694: //
695: // Parameters:
696: // HWND hWnd
697: // handle to TTY window
698: //
699: // WORD wScrollCmd
700: // type of scrolling we're doing
701: //
702: // WORD wScrollPos
703: // scroll position
704: //
705: // History: Date Author Comment
706: // 5/ 8/91 BryanW Wrote it.
707: //
708: //---------------------------------------------------------------------------
709:
710: BOOL NEAR ScrollTTYVert( HWND hWnd, WORD wScrollCmd, WORD wScrollPos )
711: {
712: int nScrollAmt ;
713: NPTTYINFO npTTYInfo ;
714:
715: if (NULL == (npTTYInfo = GETNPTTYINFO( hWnd )))
716: return ( FALSE ) ;
717:
718: switch (wScrollCmd)
719: {
720: case SB_TOP:
721: nScrollAmt = -YOFFSET( npTTYInfo ) ;
722: break ;
723:
724: case SB_BOTTOM:
725: nScrollAmt = YSCROLL( npTTYInfo ) - YOFFSET( npTTYInfo ) ;
726: break ;
727:
728: case SB_PAGEUP:
729: nScrollAmt = -YSIZE( npTTYInfo ) ;
730: break ;
731:
732: case SB_PAGEDOWN:
733: nScrollAmt = YSIZE( npTTYInfo ) ;
734: break ;
735:
736: case SB_LINEUP:
737: nScrollAmt = -YCHAR( npTTYInfo ) ;
738: break ;
739:
740: case SB_LINEDOWN:
741: nScrollAmt = YCHAR( npTTYInfo ) ;
742: break ;
743:
744: case SB_THUMBPOSITION:
745: nScrollAmt = wScrollPos - YOFFSET( npTTYInfo ) ;
746: break ;
747:
748: default:
749: return ( FALSE ) ;
750: }
751: if ((YOFFSET( npTTYInfo ) + nScrollAmt) > YSCROLL( npTTYInfo ))
752: nScrollAmt = YSCROLL( npTTYInfo ) - YOFFSET( npTTYInfo ) ;
753: if ((YOFFSET( npTTYInfo ) + nScrollAmt) < 0)
754: nScrollAmt = -YOFFSET( npTTYInfo ) ;
755: ScrollWindow( hWnd, 0, -nScrollAmt, NULL, NULL ) ;
756: YOFFSET( npTTYInfo ) = YOFFSET( npTTYInfo ) + nScrollAmt ;
757: SetScrollPos( hWnd, SB_VERT, YOFFSET( npTTYInfo ), TRUE ) ;
758:
759: return ( TRUE ) ;
760:
761: } // end of ScrollTTYVert()
762:
763: //---------------------------------------------------------------------------
764: // BOOL NEAR ScrollTTYHorz( HWND hWnd, WORD wScrollCmd, WORD wScrollPos )
765: //
766: // Description:
767: // Scrolls TTY window horizontally.
768: //
769: // Parameters:
770: // HWND hWnd
771: // handle to TTY window
772: //
773: // WORD wScrollCmd
774: // type of scrolling we're doing
775: //
776: // WORD wScrollPos
777: // scroll position
778: //
779: // History: Date Author Comment
780: // 5/ 8/91 BryanW Wrote it.
781: //
782: //---------------------------------------------------------------------------
783:
784: BOOL NEAR ScrollTTYHorz( HWND hWnd, WORD wScrollCmd, WORD wScrollPos )
785: {
786: int nScrollAmt ;
787: NPTTYINFO npTTYInfo ;
788:
789: if (NULL == (npTTYInfo = GETNPTTYINFO( hWnd )))
790: return ( FALSE ) ;
791:
792: switch (wScrollCmd)
793: {
794: case SB_TOP:
795: nScrollAmt = -XOFFSET( npTTYInfo ) ;
796: break ;
797:
798: case SB_BOTTOM:
799: nScrollAmt = XSCROLL( npTTYInfo ) - XOFFSET( npTTYInfo ) ;
800: break ;
801:
802: case SB_PAGEUP:
803: nScrollAmt = -XSIZE( npTTYInfo ) ;
804: break ;
805:
806: case SB_PAGEDOWN:
807: nScrollAmt = XSIZE( npTTYInfo ) ;
808: break ;
809:
810: case SB_LINEUP:
811: nScrollAmt = -XCHAR( npTTYInfo ) ;
812: break ;
813:
814: case SB_LINEDOWN:
815: nScrollAmt = XCHAR( npTTYInfo ) ;
816: break ;
817:
818: case SB_THUMBPOSITION:
819: nScrollAmt = wScrollPos - XOFFSET( npTTYInfo ) ;
820: break ;
821:
822: default:
823: return ( FALSE ) ;
824: }
825: if ((XOFFSET( npTTYInfo ) + nScrollAmt) > XSCROLL( npTTYInfo ))
826: nScrollAmt = XSCROLL( npTTYInfo ) - XOFFSET( npTTYInfo ) ;
827: if ((XOFFSET( npTTYInfo ) + nScrollAmt) < 0)
828: nScrollAmt = -XOFFSET( npTTYInfo ) ;
829: ScrollWindow( hWnd, -nScrollAmt, 0, NULL, NULL ) ;
830: XOFFSET( npTTYInfo ) = XOFFSET( npTTYInfo ) + nScrollAmt ;
831: SetScrollPos( hWnd, SB_HORZ, XOFFSET( npTTYInfo ), TRUE ) ;
832:
833: return ( TRUE ) ;
834:
835: } // end of ScrollTTYHorz()
836:
837: //---------------------------------------------------------------------------
838: // BOOL NEAR SetTTYFocus( HWND hWnd )
839: //
840: // Description:
841: // Sets the focus to the TTY window also creates caret.
842: //
843: // Parameters:
844: // HWND hWnd
845: // handle to TTY window
846: //
847: // History: Date Author Comment
848: // 5/ 9/91 BryanW Wrote it.
849: //
850: //---------------------------------------------------------------------------
851:
852: BOOL NEAR SetTTYFocus( HWND hWnd )
853: {
854: NPTTYINFO npTTYInfo ;
855:
856: if (NULL == (npTTYInfo = GETNPTTYINFO( hWnd )))
857: return ( FALSE ) ;
858:
859: if (CONNECTED( npTTYInfo ) && (CURSORSTATE( npTTYInfo ) != CS_SHOW))
860: {
861: CreateCaret( hWnd, NULL, XCHAR( npTTYInfo ), YCHAR( npTTYInfo ) ) ;
862: ShowCaret( hWnd ) ;
863: CURSORSTATE( npTTYInfo ) = CS_SHOW ;
864: }
865: MoveTTYCursor( hWnd ) ;
866: return ( TRUE ) ;
867:
868: } // end of SetTTYFocus()
869:
870: //---------------------------------------------------------------------------
871: // BOOL NEAR KillTTYFocus( HWND hWnd )
872: //
873: // Description:
874: // Kills TTY focus and destroys the caret.
875: //
876: // Parameters:
877: // HWND hWnd
878: // handle to TTY window
879: //
880: // History: Date Author Comment
881: // 5/ 9/91 BryanW Wrote it.
882: //
883: //---------------------------------------------------------------------------
884:
885: BOOL NEAR KillTTYFocus( HWND hWnd )
886: {
887: NPTTYINFO npTTYInfo ;
888:
889: if (NULL == (npTTYInfo = GETNPTTYINFO( hWnd )))
890: return ( FALSE ) ;
891:
892: if (CONNECTED( npTTYInfo ) && (CURSORSTATE( npTTYInfo ) != CS_HIDE))
893: {
894: HideCaret( hWnd ) ;
895: DestroyCaret() ;
896: CURSORSTATE( npTTYInfo ) = CS_HIDE ;
897: }
898: return ( TRUE ) ;
899:
900: } // end of KillTTYFocus()
901:
902: //---------------------------------------------------------------------------
903: // BOOL NEAR MoveTTYCursor( HWND hWnd )
904: //
905: // Description:
906: // Moves caret to current position.
907: //
908: // Parameters:
909: // HWND hWnd
910: // handle to TTY window
911: //
912: // History: Date Author Comment
913: // 5/ 9/91 BryanW Wrote it.
914: //
915: //---------------------------------------------------------------------------
916:
917: BOOL NEAR MoveTTYCursor( HWND hWnd )
918: {
919: NPTTYINFO npTTYInfo ;
920:
921: if (NULL == (npTTYInfo = GETNPTTYINFO( hWnd )))
922: return ( FALSE ) ;
923:
924: if (CONNECTED( npTTYInfo ) && (CURSORSTATE( npTTYInfo ) & CS_SHOW))
925: SetCaretPos( (COLUMN( npTTYInfo ) * XCHAR( npTTYInfo )) -
926: XOFFSET( npTTYInfo ),
927: (ROW( npTTYInfo ) * YCHAR( npTTYInfo )) -
928: YOFFSET( npTTYInfo ) ) ;
929:
930: return ( TRUE ) ;
931:
932: } // end of MoveTTYCursor()
933:
934: //---------------------------------------------------------------------------
935: // BOOL NEAR ProcessCOMMNotification( HWND hWnd,
936: // WPARAM wParam, LPARAM lParam ) ;
937: //
938: // Description:
939: // Processes the WM_COMMNOTIFY message from the COMM.DRV.
940: //
941: // Parameters:
942: // HWND hWnd
943: // handle to TTY window
944: //
945: // WPARAM wParam
946: // specifes the device (nCid)
947: //
948: // LPARAM lParam
949: // LOWORD contains event trigger
950: // HIWORD is NULL
951: //
952: // Win-32 Porting Issues:
953: // - Function was constrained by WORD and LONG declarations.
954: // - Processing under Win-32 is much simpler and additionally
955: // requires the "posted message" flag to be cleared.
956: //
957: // History: Date Author Comment
958: // 5/10/91 BryanW Wrote it.
959: // 10/18/91 BryanW Updated to verify the event.
960: // 6/15/92 BryanW Removed WORD and LONG constraints.
961: // 6/15/92 BryanW Ported to Win-32.
962: //
963: //---------------------------------------------------------------------------
964:
965: BOOL NEAR ProcessCOMMNotification( HWND hWnd, WPARAM wParam, LPARAM lParam )
966: {
967: int nLength ;
968: BYTE abIn[ MAXBLOCK + 1] ;
969: NPTTYINFO npTTYInfo ;
970: MSG msg ;
971:
972: if (NULL == (npTTYInfo = GETNPTTYINFO( hWnd )))
973: return ( FALSE ) ;
974:
975: #ifdef WIN32
976: // verify that it is a COMM event sent by our thread
977:
978: if (CN_EVENT & LOWORD( lParam ) != CN_EVENT)
979: return ( FALSE ) ;
980:
981: // We loop here since it is highly likely that the buffer
982: // can been filled while we are reading this block. This
983: // is especially true when operating at high baud rates
984: // (e.g. >= 9600 baud).
985:
986: do
987: {
988: if (nLength = ReadCommBlock( hWnd, (LPSTR) abIn, MAXBLOCK ))
989: {
990: WriteTTYBlock( hWnd, (LPSTR) abIn, nLength ) ;
991:
992: // force a paint
993:
994: UpdateWindow( hWnd ) ;
995: }
996: }
997: while (!PeekMessage( &msg, NULL, 0, 0, PM_NOREMOVE) || (nLength > 0)) ;
998:
999: // clear our "posted notification" flag
1000:
1001: SetEvent( POSTEVENT( npTTYInfo ) ) ;
1002: #else
1003: if (!USECNRECEIVE( npTTYInfo ))
1004: {
1005: // verify that it is a COMM event specified by our mask
1006:
1007: if (CN_EVENT & LOWORD( lParam ) != CN_EVENT)
1008: return ( FALSE ) ;
1009:
1010: // For Windows 3.1, rested reset the event word so we are notified
1011: // when the next event occurs
1012:
1013: GetCommEventMask( COMDEV( npTTYInfo ), EV_RXCHAR ) ;
1014:
1015: // We loop here since it is highly likely that the buffer
1016: // can been filled while we are reading this block. This
1017: // is especially true when operating at high baud rates
1018: // (e.g. >= 9600 baud).
1019:
1020: do
1021: {
1022: if (nLength = ReadCommBlock( hWnd, (LPSTR) abIn, MAXBLOCK ))
1023: {
1024: WriteTTYBlock( hWnd, (LPSTR) abIn, nLength ) ;
1025:
1026: // force a paint
1027:
1028: UpdateWindow( hWnd ) ;
1029: }
1030: }
1031: while (!PeekMessage( &msg, NULL, 0, 0, PM_NOREMOVE) || (nLength > 0)) ;
1032: }
1033: else
1034: {
1035: // verify that it is a receive event
1036:
1037: if (CN_RECEIVE & LOWORD( lParam ) != CN_RECEIVE)
1038: return ( FALSE ) ;
1039:
1040: do
1041: {
1042: if (nLength = ReadCommBlock( hWnd, (LPSTR) abIn, MAXBLOCK ))
1043: {
1044: WriteTTYBlock( hWnd, (LPSTR) abIn, nLength ) ;
1045:
1046: // force a paint
1047:
1048: UpdateWindow( hWnd ) ;
1049: }
1050: }
1051: while ((!PeekMessage( &msg, NULL, 0, 0, PM_NOREMOVE )) ||
1052: (ComStat.cbInQue >= MAXBLOCK)) ;
1053: }
1054: #endif
1055:
1056: return ( TRUE ) ;
1057:
1058: } // end of ProcessCOMMNotification()
1059:
1060: //---------------------------------------------------------------------------
1061: // BOOL NEAR ProcessTTYCharacter( HWND hWnd, BYTE bOut )
1062: //
1063: // Description:
1064: // This simply writes a character to the port and echos it
1065: // to the TTY screen if fLocalEcho is set. Some minor
1066: // keyboard mapping could be performed here.
1067: //
1068: // Parameters:
1069: // HWND hWnd
1070: // handle to TTY window
1071: //
1072: // BYTE bOut
1073: // byte from keyboard
1074: //
1075: // History: Date Author Comment
1076: // 5/11/91 BryanW Wrote it.
1077: //
1078: //---------------------------------------------------------------------------
1079:
1080: BOOL NEAR ProcessTTYCharacter( HWND hWnd, BYTE bOut )
1081: {
1082: NPTTYINFO npTTYInfo ;
1083:
1084: if (NULL == (npTTYInfo = GETNPTTYINFO( hWnd )))
1085: return ( FALSE ) ;
1086:
1087: if (!CONNECTED( npTTYInfo ))
1088: return ( FALSE ) ;
1089:
1090: WriteCommByte( hWnd, bOut ) ;
1091: if (LOCALECHO( npTTYInfo ))
1092: WriteTTYBlock( hWnd, &bOut, 1 ) ;
1093:
1094: return ( TRUE ) ;
1095:
1096: } // end of ProcessTTYCharacter()
1097:
1098: //---------------------------------------------------------------------------
1099: // BOOL NEAR OpenConnection( HWND hWnd )
1100: //
1101: // Description:
1102: // Opens communication port specified in the TTYINFO struct.
1103: // It also sets the CommState and notifies the window via
1104: // the fConnected flag in the TTYINFO struct.
1105: //
1106: // Parameters:
1107: // HWND hWnd
1108: // handle to TTY window
1109: //
1110: // Win-32 Porting Issues:
1111: // - OpenComm() is not supported under Win-32. Use OpenFile()
1112: // and setup for OVERLAPPED_IO.
1113: // - Win-32 has specific communication timeout parameters.
1114: // - Created the secondary thread for event notification.
1115: //
1116: // History: Date Author Comment
1117: // 5/ 9/91 BryanW Wrote it.
1118: //
1119: //---------------------------------------------------------------------------
1120:
1121: BOOL NEAR OpenConnection( HWND hWnd )
1122: {
1123: char szPort[ 10 ], szTemp[ 10 ] ;
1124: BOOL fRetVal ;
1125: HCURSOR hOldCursor, hWaitCursor ;
1126: HMENU hMenu ;
1127: NPTTYINFO npTTYInfo ;
1128:
1129: #ifdef WIN32
1130: HANDLE hCommWatchThread ;
1131: DWORD dwThreadID ;
1132: COMMTIMEOUTS CommTimeOuts ;
1133: #endif
1134:
1135: if (NULL == (npTTYInfo = GETNPTTYINFO( hWnd )))
1136: return ( FALSE ) ;
1137:
1138: // show the hourglass cursor
1139: hWaitCursor = LoadCursor( NULL, IDC_WAIT ) ;
1140: hOldCursor = SetCursor( hWaitCursor ) ;
1141:
1142: // load the COM prefix string and append port number
1143:
1144: LoadString( GETHINST( hWnd ), IDS_COMPREFIX, szTemp, sizeof( szTemp ) ) ;
1145: wsprintf( szPort, "%s%d", (LPSTR) szTemp, PORT( npTTYInfo ) ) ;
1146:
1147: // open COMM device
1148:
1149: #ifdef WIN32
1150: if ((COMDEV( npTTYInfo ) =
1151: CreateFile( szPort, GENERIC_READ | GENERIC_WRITE,
1152: 0, // exclusive access
1153: NULL, // no security attrs
1154: OPEN_EXISTING,
1155: FILE_FLAG_OVERLAPPED, // overlapped I/O
1156: NULL )) == (HANDLE) -1 )
1157: return ( FALSE ) ;
1158: else
1159: {
1160: // purge any information in the buffer
1161:
1162: PurgeComm( COMDEV( npTTYInfo ), PURGE_TXABORT | PURGE_RXABORT |
1163: PURGE_TXCLEAR | PURGE_RXCLEAR ) ;
1164:
1165: // set up for overlapped non-blocking I/O
1166:
1167: CommTimeOuts.ReadIntervalTimeout = 0xFFFFFFFF ;
1168: CommTimeOuts.ReadTotalTimeoutMultiplier = 0 ;
1169: CommTimeOuts.ReadTotalTimeoutConstant = 0 ;
1170: CommTimeOuts.WriteTotalTimeoutMultiplier = 0 ;
1171: CommTimeOuts.WriteTotalTimeoutConstant = 0 ;
1172: SetCommTimeouts( COMDEV( npTTYInfo ), &CommTimeOuts ) ;
1173: }
1174: #else
1175: if ((COMDEV( npTTYInfo ) = OpenComm( szPort, RXQUEUE, TXQUEUE )) < 0)
1176: return ( FALSE ) ;
1177: #endif
1178:
1179: fRetVal = SetupConnection( hWnd ) ;
1180:
1181: if (fRetVal)
1182: {
1183: CONNECTED( npTTYInfo ) = TRUE ;
1184:
1185: #ifdef WIN32
1186: // In the case of Win32, we create a secondary thread
1187: // to watch for an event.
1188:
1189: if (NULL == (hCommWatchThread =
1190: CreateThread( (LPSECURITY_ATTRIBUTES) NULL,
1191: 0,
1192: (LPTHREAD_START_ROUTINE) CommWatchProc,
1193: (LPVOID) npTTYInfo,
1194: NULL, &dwThreadID )))
1195: {
1196: CONNECTED( npTTYInfo ) = FALSE ;
1197: CloseHandle( COMDEV( npTTYInfo ) ) ;
1198: fRetVal = FALSE ;
1199: }
1200: else
1201: {
1202: THREADID( npTTYInfo ) = dwThreadID ;
1203: HTHREAD( npTTYInfo ) = hCommWatchThread ;
1204:
1205: // assert DTR
1206:
1207: EscapeCommFunction( COMDEV( npTTYInfo ), SETDTR ) ;
1208:
1209:
1210: SetTTYFocus( hWnd ) ;
1211:
1212: hMenu = GetMenu( hWnd ) ;
1213: EnableMenuItem( hMenu, IDM_DISCONNECT,
1214: MF_ENABLED | MF_BYCOMMAND ) ;
1215: EnableMenuItem( hMenu, IDM_CONNECT,
1216: MF_GRAYED | MF_DISABLED | MF_BYCOMMAND ) ;
1217: }
1218: #else
1219: // Under Windows 3.1, we set up notifications from COMM.DRV
1220:
1221: if (!USECNRECEIVE( npTTYInfo ))
1222: {
1223: // In this case we really are only using the notifications
1224: // for the received characters - it could be expanded to
1225: // cover the changes in CD or other status lines.
1226:
1227: SetCommEventMask( COMDEV( npTTYInfo ), EV_RXCHAR ) ;
1228:
1229: // Enable notifications for events only.
1230:
1231: // NB: This method does not use the specific
1232: // in/out queue triggers.
1233:
1234: EnableCommNotification( COMDEV( npTTYInfo ), hWnd, -1, -1 ) ;
1235: }
1236: else
1237: {
1238: // Enable notification for CN_RECEIVE events.
1239:
1240: EnableCommNotification( COMDEV( npTTYInfo ), hWnd, MAXBLOCK, -1 ) ;
1241: }
1242:
1243: // assert DTR
1244:
1245: EscapeCommFunction( COMDEV( npTTYInfo ), SETDTR ) ;
1246:
1247:
1248: SetTTYFocus( hWnd ) ;
1249:
1250: hMenu = GetMenu( hWnd ) ;
1251: EnableMenuItem( hMenu, IDM_DISCONNECT,
1252: MF_ENABLED | MF_BYCOMMAND ) ;
1253: EnableMenuItem( hMenu, IDM_CONNECT,
1254: MF_GRAYED | MF_DISABLED | MF_BYCOMMAND ) ;
1255: #endif
1256: }
1257: else
1258: {
1259: CONNECTED( npTTYInfo ) = FALSE ;
1260:
1261: #ifdef WIN32
1262: CloseHandle( COMDEV( npTTYInfo ) ) ;
1263: #else
1264: CloseComm( COMDEV( npTTYInfo ) ) ;
1265: #endif
1266: }
1267:
1268: // restore cursor
1269:
1270: SetCursor( hOldCursor ) ;
1271:
1272: return ( fRetVal ) ;
1273:
1274: } // end of OpenConnection()
1275:
1276: //---------------------------------------------------------------------------
1277: // BOOL NEAR SetupConnection( HWND hWnd )
1278: //
1279: // Description:
1280: // This routines sets up the DCB based on settings in the
1281: // TTY info structure and performs a SetCommState().
1282: //
1283: // Parameters:
1284: // HWND hWnd
1285: // handle to TTY window
1286: //
1287: // Win-32 Porting Issues:
1288: // - Win-32 requires a slightly different processing of the DCB.
1289: // Changes were made for configuration of the hardware handshaking
1290: // lines.
1291: //
1292: // History: Date Author Comment
1293: // 5/ 9/91 BryanW Wrote it.
1294: //
1295: //---------------------------------------------------------------------------
1296:
1297: BOOL NEAR SetupConnection( HWND hWnd )
1298: {
1299: BOOL fRetVal ;
1300: BYTE bSet ;
1301: DCB dcb ;
1302: NPTTYINFO npTTYInfo ;
1303:
1304: if (NULL == (npTTYInfo = GETNPTTYINFO( hWnd )))
1305: return ( FALSE ) ;
1306:
1307: #ifdef WIN32
1308: dcb.DCBlength = sizeof( DCB ) ;
1309: #endif
1310:
1311: GetCommState( COMDEV( npTTYInfo ), &dcb ) ;
1312:
1313: dcb.BaudRate = BAUDRATE( npTTYInfo ) ;
1314: dcb.ByteSize = BYTESIZE( npTTYInfo ) ;
1315: dcb.Parity = PARITY( npTTYInfo ) ;
1316: dcb.StopBits = STOPBITS( npTTYInfo ) ;
1317:
1318: // setup hardware flow control
1319:
1320: bSet = (BYTE) ((FLOWCTRL( npTTYInfo ) & FC_DTRDSR) != 0) ;
1321: #ifdef WIN32
1322: dcb.fOutxDsrFlow = bSet ;
1323: if (bSet)
1324: dcb.fDtrControl = DTR_CONTROL_HANDSHAKE ;
1325: else
1326: dcb.fDtrControl = DTR_CONTROL_ENABLE ;
1327: #else
1328: dcb.fOutxDsrFlow = dcb.fDtrflow = bSet ;
1329: dcb.DsrTimeout = (bSet) ? 30 : 0 ;
1330: #endif
1331:
1332: bSet = (BYTE) ((FLOWCTRL( npTTYInfo ) & FC_RTSCTS) != 0) ;
1333: #ifdef WIN32
1334: dcb.fOutxCtsFlow = bSet ;
1335: if (bSet)
1336: dcb.fRtsControl = RTS_CONTROL_HANDSHAKE ;
1337: else
1338: dcb.fRtsControl = RTS_CONTROL_ENABLE ;
1339: #else
1340: dcb.fOutxCtsFlow = dcb.fRtsflow = bSet ;
1341: dcb.CtsTimeout = (bSet) ? 30 : 0 ;
1342: #endif
1343:
1344: // setup software flow control
1345:
1346: bSet = (BYTE) ((FLOWCTRL( npTTYInfo ) & FC_XONXOFF) != 0) ;
1347:
1348: dcb.fInX = dcb.fOutX = bSet ;
1349: dcb.XonChar = ASCII_XON ;
1350: dcb.XoffChar = ASCII_XOFF ;
1351: dcb.XonLim = 100 ;
1352: dcb.XoffLim = 100 ;
1353:
1354: // other various settings
1355:
1356: dcb.fBinary = TRUE ;
1357: dcb.fParity = TRUE ;
1358:
1359: #ifndef WIN32
1360: dcb.fRtsDisable = FALSE ;
1361: dcb.fDtrDisable = FALSE ;
1362: fRetVal = !(SetCommState( &dcb ) < 0) ;
1363: #else
1364: fRetVal = SetCommState( COMDEV( npTTYInfo ), &dcb ) ;
1365: #endif
1366:
1367: return ( fRetVal ) ;
1368:
1369: } // end of SetupConnection()
1370:
1371: //---------------------------------------------------------------------------
1372: // BOOL NEAR CloseConnection( HWND hWnd )
1373: //
1374: // Description:
1375: // Closes the connection to the port. Resets the connect flag
1376: // in the TTYINFO struct.
1377: //
1378: // Parameters:
1379: // HWND hWnd
1380: // handle to TTY window
1381: //
1382: // Win-32 Porting Issues:
1383: // - Needed to stop secondary thread. SetCommMask() will signal the
1384: // WaitCommEvent() event and the thread will halt when the
1385: // CONNECTED() flag is clear.
1386: // - Use new PurgeComm() API to clear communications driver before
1387: // closing device.
1388: //
1389: // History: Date Author Comment
1390: // 5/ 9/91 BryanW Wrote it.
1391: // 6/15/92 BryanW Ported to Win-32.
1392: //
1393: //---------------------------------------------------------------------------
1394:
1395: BOOL NEAR CloseConnection( HWND hWnd )
1396: {
1397: HMENU hMenu ;
1398: NPTTYINFO npTTYInfo ;
1399:
1400: if (NULL == (npTTYInfo = GETNPTTYINFO( hWnd )))
1401: return ( FALSE ) ;
1402:
1403: // set connected flag to FALSE
1404:
1405: CONNECTED( npTTYInfo ) = FALSE ;
1406:
1407: #ifdef WIN32
1408: // disable event notification and wait for thread
1409: // to halt
1410:
1411: SetCommMask( COMDEV( npTTYInfo ), NULL ) ;
1412:
1413: // block until thread has been halted
1414:
1415: while (THREADID( npTTYInfo ) != NULL) ;
1416: #else
1417: // Disable event notification. Using a NULL hWnd tells
1418: // the COMM.DRV to disable future notifications.
1419:
1420: EnableCommNotification( COMDEV( npTTYInfo ), NULL, -1, -1 ) ;
1421: #endif
1422:
1423: // kill the focus
1424:
1425: KillTTYFocus( hWnd ) ;
1426:
1427: // drop DTR
1428:
1429: EscapeCommFunction( COMDEV( npTTYInfo ), CLRDTR ) ;
1430:
1431: #ifdef WIN32
1432: // purge any outstanding reads/writes and close device handle
1433:
1434: PurgeComm( COMDEV( npTTYInfo ), PURGE_TXABORT | PURGE_RXABORT |
1435: PURGE_TXCLEAR | PURGE_RXCLEAR ) ;
1436: CloseHandle( COMDEV( npTTYInfo ) ) ;
1437: #else
1438: // close comm connection
1439:
1440: CloseComm( COMDEV( npTTYInfo ) ) ;
1441: #endif
1442:
1443: // change the selectable items in the menu
1444:
1445: hMenu = GetMenu( hWnd ) ;
1446: EnableMenuItem( hMenu, IDM_DISCONNECT,
1447: MF_GRAYED | MF_DISABLED | MF_BYCOMMAND ) ;
1448: EnableMenuItem( hMenu, IDM_CONNECT,
1449: MF_ENABLED | MF_BYCOMMAND ) ;
1450:
1451: return ( TRUE ) ;
1452:
1453: } // end of CloseConnection()
1454:
1455: //---------------------------------------------------------------------------
1456: // int NEAR ReadCommBlock( HWND hWnd, LPSTR lpszBlock, int nMaxLength )
1457: //
1458: // Description:
1459: // Reads a block from the COM port and stuffs it into
1460: // the provided block.
1461: //
1462: // Parameters:
1463: // HWND hWnd
1464: // handle to TTY window
1465: //
1466: // LPSTR lpszBlock
1467: // block used for storage
1468: //
1469: // int nMaxLength
1470: // max length of block to read
1471: //
1472: // Win-32 Porting Issues:
1473: // - ReadComm() has been replaced by ReadFile() in Win-32.
1474: // - Overlapped I/O has been implemented.
1475: //
1476: // History: Date Author Comment
1477: // 5/10/91 BryanW Wrote it.
1478: //
1479: //---------------------------------------------------------------------------
1480:
1481: int NEAR ReadCommBlock( HWND hWnd, LPSTR lpszBlock, int nMaxLength )
1482: {
1483: #ifdef WIN32
1484: DWORD nLength ;
1485: BOOL fReadStat ;
1486: COMSTAT ComStat ;
1487: DWORD dwErrorFlags ;
1488: #else
1489: int nLength, nError ;
1490: #endif
1491:
1492: char szError[ 10 ] ;
1493: NPTTYINFO npTTYInfo ;
1494:
1495: if (NULL == (npTTYInfo = GETNPTTYINFO( hWnd )))
1496: return ( FALSE ) ;
1497:
1498: #ifdef WIN32
1499: ClearCommError( COMDEV( npTTYInfo ), &dwErrorFlags, &ComStat ) ;
1500: if ((dwErrorFlags > 0) && DISPLAYERRORS( npTTYInfo ))
1501: {
1502: wsprintf( szError, "<CE-%u>", dwErrorFlags ) ;
1503: WriteTTYBlock( hWnd, szError, lstrlen( szError ) ) ;
1504: }
1505: nLength = min( (DWORD) nMaxLength, ComStat.cbInQue ) ;
1506: if (nLength > 0)
1507: {
1508: fReadStat = ReadFile( COMDEV( npTTYInfo ), lpszBlock,
1509: nLength, &nLength, &READ_OS( npTTYInfo ) ) ;
1510: if (!fReadStat)
1511: {
1512: if (GetLastError() == ERROR_IO_PENDING)
1513: {
1514: OutputDebugString( "ReadCommBlock: I/O Pending.\r\n" ) ;
1515:
1516: // wait for a second for this transmission to complete
1517:
1518: if (WaitForSingleObject( READ_OS( npTTYInfo ).hEvent, 1000 ))
1519: nLength = 0 ;
1520: else
1521: {
1522: GetOverlappedResult( COMDEV( npTTYInfo ),
1523: &READ_OS( npTTYInfo ),
1524: &nLength, FALSE ) ;
1525: READ_OS( npTTYInfo ).Offset += nLength ;
1526: }
1527: }
1528: else
1529: // some other error occurred
1530:
1531: nLength = 0 ;
1532: }
1533: }
1534: #else
1535: nLength = ReadComm( COMDEV( npTTYInfo ), lpszBlock, nMaxLength ) ;
1536:
1537: if (nLength < 0)
1538: {
1539: nLength *= -1 ;
1540: while (nError = GetCommError( COMDEV( npTTYInfo ), NULL ))
1541: {
1542: if (DISPLAYERRORS( npTTYInfo ))
1543: {
1544: wsprintf( szError, "<CE-%d>", nError ) ;
1545: WriteTTYBlock( hWnd, szError, lstrlen( szError ) ) ;
1546: }
1547: }
1548: }
1549: #endif
1550:
1551: return ( nLength ) ;
1552:
1553: } // end of ReadCommBlock()
1554:
1555: //---------------------------------------------------------------------------
1556: // BOOL NEAR WriteCommByte( HWND hWnd, BYTE bByte )
1557: //
1558: // Description:
1559: // Writes a byte to the COM port specified in the associated
1560: // TTY info structure.
1561: //
1562: // Parameters:
1563: // HWND hWnd
1564: // handle to TTY window
1565: //
1566: // BYTE bByte
1567: // byte to write to port
1568: //
1569: // Win-32 Porting Issues:
1570: // - WriteComm() has been replaced by WriteFile() in Win-32.
1571: // - Overlapped I/O has been implemented.
1572: //
1573: // History: Date Author Comment
1574: // 5/10/91 BryanW Wrote it.
1575: //
1576: //---------------------------------------------------------------------------
1577:
1578: BOOL NEAR WriteCommByte( HWND hWnd, BYTE bByte )
1579: {
1580: #ifdef WIN32
1581: BOOL fWriteStat ;
1582: DWORD dwBytesWritten ;
1583: #endif
1584: NPTTYINFO npTTYInfo ;
1585:
1586: if (NULL == (npTTYInfo = GETNPTTYINFO( hWnd )))
1587: return ( FALSE ) ;
1588:
1589: #ifdef WIN32
1590: fWriteStat = WriteFile( COMDEV( npTTYInfo ), (LPSTR) &bByte, 1,
1591: &dwBytesWritten, &WRITE_OS( npTTYInfo ) ) ;
1592: if (!fWriteStat && (GetLastError() == ERROR_IO_PENDING))
1593: {
1594: OutputDebugString( "WriteCommByte: I/O Pending.\r\n" ) ;
1595:
1596: // wait for a second for this transmission to complete
1597:
1598: if (WaitForSingleObject( WRITE_OS( npTTYInfo ).hEvent, 1000 ))
1599: dwBytesWritten = 0 ;
1600: else
1601: {
1602: GetOverlappedResult( COMDEV( npTTYInfo ),
1603: &WRITE_OS( npTTYInfo ),
1604: &dwBytesWritten, FALSE ) ;
1605: WRITE_OS( npTTYInfo ).Offset += dwBytesWritten ;
1606: }
1607: }
1608: #else
1609: WriteComm( COMDEV( npTTYInfo ), (LPSTR) &bByte, 1 ) ;
1610: #endif
1611: return ( TRUE ) ;
1612:
1613: } // end of WriteCommByte()
1614:
1615: //---------------------------------------------------------------------------
1616: // BOOL NEAR WriteTTYBlock( HWND hWnd, LPSTR lpBlock, int nLength )
1617: //
1618: // Description:
1619: // Writes block to TTY screen. Nothing fancy - just
1620: // straight TTY.
1621: //
1622: // Parameters:
1623: // HWND hWnd
1624: // handle to TTY window
1625: //
1626: // LPSTR lpBlock
1627: // far pointer to block of data
1628: //
1629: // int nLength
1630: // length of block
1631: //
1632: // History: Date Author Comment
1633: // 5/ 9/91 BryanW Wrote it.
1634: // 5/20/91 BryanW Modified... not character based,
1635: // block based now. It was processing
1636: // per char.
1637: //
1638: //---------------------------------------------------------------------------
1639:
1640: BOOL NEAR WriteTTYBlock( HWND hWnd, LPSTR lpBlock, int nLength )
1641: {
1642: int i ;
1643: NPTTYINFO npTTYInfo ;
1644: RECT rect ;
1645:
1646: if (NULL == (npTTYInfo = GETNPTTYINFO( hWnd )))
1647: return ( FALSE ) ;
1648:
1649: for (i = 0 ; i < nLength; i++)
1650: {
1651: switch (lpBlock[ i ])
1652: {
1653: case ASCII_BEL:
1654: // Bell
1655: MessageBeep( 0 ) ;
1656: break ;
1657:
1658: case ASCII_BS:
1659: // Backspace
1660: if (COLUMN( npTTYInfo ) > 0)
1661: COLUMN( npTTYInfo ) -- ;
1662: MoveTTYCursor( hWnd ) ;
1663: break ;
1664:
1665: case ASCII_CR:
1666: // Carriage return
1667: COLUMN( npTTYInfo ) = 0 ;
1668: MoveTTYCursor( hWnd ) ;
1669: if (!NEWLINE( npTTYInfo ))
1670: break;
1671:
1672: // fall through
1673:
1674: case ASCII_LF:
1675: // Line feed
1676: if (ROW( npTTYInfo )++ == MAXROWS - 1)
1677: {
1678: _fmemmove( (LPSTR) (SCREEN( npTTYInfo )),
1679: (LPSTR) (SCREEN( npTTYInfo ) + MAXCOLS),
1680: (MAXROWS - 1) * MAXCOLS ) ;
1681: _fmemset( (LPSTR) (SCREEN( npTTYInfo ) + (MAXROWS - 1) * MAXCOLS),
1682: ' ', MAXCOLS ) ;
1683: InvalidateRect( hWnd, NULL, FALSE ) ;
1684: ROW( npTTYInfo )-- ;
1685: }
1686: MoveTTYCursor( hWnd ) ;
1687: break ;
1688:
1689: default:
1690: *(SCREEN( npTTYInfo ) + ROW( npTTYInfo ) * MAXCOLS +
1691: COLUMN( npTTYInfo )) = lpBlock[ i ] ;
1692: rect.left = (COLUMN( npTTYInfo ) * XCHAR( npTTYInfo )) -
1693: XOFFSET( npTTYInfo ) ;
1694: rect.right = rect.left + XCHAR( npTTYInfo ) ;
1695: rect.top = (ROW( npTTYInfo ) * YCHAR( npTTYInfo )) -
1696: YOFFSET( npTTYInfo ) ;
1697: rect.bottom = rect.top + YCHAR( npTTYInfo ) ;
1698: InvalidateRect( hWnd, &rect, FALSE ) ;
1699:
1700: // Line wrap
1701: if (COLUMN( npTTYInfo ) < MAXCOLS - 1)
1702: COLUMN( npTTYInfo )++ ;
1703: else if (AUTOWRAP( npTTYInfo ))
1704: WriteTTYBlock( hWnd, "\r\n", 2 ) ;
1705: break;
1706: }
1707: }
1708: return ( TRUE ) ;
1709:
1710: } // end of WriteTTYBlock()
1711:
1712: //---------------------------------------------------------------------------
1713: // VOID NEAR GoModalDialogBoxParam( HINSTANCE hInstance,
1714: // LPCSTR lpszTemplate, HWND hWnd,
1715: // DLGPROC lpDlgProc, LPARAM lParam )
1716: //
1717: // Description:
1718: // It is a simple utility function that simply performs the
1719: // MPI and invokes the dialog box with a DWORD paramter.
1720: //
1721: // Parameters:
1722: // similar to that of DialogBoxParam() with the exception
1723: // that the lpDlgProc is not a procedure instance
1724: //
1725: // History: Date Author Comment
1726: // 5/10/91 BryanW Wrote it.
1727: //
1728: //---------------------------------------------------------------------------
1729:
1730: VOID NEAR GoModalDialogBoxParam( HINSTANCE hInstance, LPCSTR lpszTemplate,
1731: HWND hWnd, DLGPROC lpDlgProc, LPARAM lParam )
1732: {
1733: DLGPROC lpProcInstance ;
1734:
1735: lpProcInstance = (DLGPROC) MakeProcInstance( (FARPROC) lpDlgProc,
1736: hInstance ) ;
1737: DialogBoxParam( hInstance, lpszTemplate, hWnd, lpProcInstance, lParam ) ;
1738: FreeProcInstance( (FARPROC) lpProcInstance ) ;
1739:
1740: } // end of GoModalDialogBoxParam()
1741:
1742: //---------------------------------------------------------------------------
1743: // BOOL FAR PASCAL AboutDlgProc( HWND hDlg, UINT uMsg,
1744: // WPARAM wParam, LPARAM lParam )
1745: //
1746: // Description:
1747: // Simulates the Windows System Dialog Box.
1748: //
1749: // Parameters:
1750: // Same as standard dialog procedures.
1751: //
1752: // History: Date Author Comment
1753: // 10/19/91 BryanW Added this little extra.
1754: //
1755: //---------------------------------------------------------------------------
1756:
1757: BOOL FAR PASCAL AboutDlgProc( HWND hDlg, UINT uMsg,
1758: WPARAM wParam, LPARAM lParam )
1759: {
1760: switch (uMsg)
1761: {
1762: case WM_INITDIALOG:
1763: {
1764: #ifdef WIN32
1765: char szBuffer[ MAXLEN_TEMPSTR ], szTemp[ MAXLEN_TEMPSTR ];
1766: DWORD dwFreeMemory ;
1767: WORD wRevision, wVersion ;
1768: #else
1769: int idModeString ;
1770: char szBuffer[ MAXLEN_TEMPSTR ], szTemp[ MAXLEN_TEMPSTR ] ;
1771: DWORD dwFreeMemory, dwWinFlags ;
1772: WORD wFreeResources, wRevision, wVersion ;
1773: #endif
1774:
1775: #ifdef ABOUTDLG_USEBITMAP
1776: // if we are using the bitmap, hide the icon
1777:
1778: ShowWindow( GetDlgItem( hDlg, IDD_ABOUTICON ), SW_HIDE ) ;
1779: #endif
1780: // sets up the version number for Windows
1781:
1782: wVersion = LOWORD( GetVersion() ) ;
1783: wRevision = HIBYTE( wVersion ) ;
1784: wVersion = LOBYTE( wVersion ) ;
1785:
1786: GetDlgItemText( hDlg, IDD_TITLELINE, szTemp, sizeof( szTemp ) ) ;
1787: wsprintf( szBuffer, szTemp, wVersion, wRevision ) ;
1788: SetDlgItemText( hDlg, IDD_TITLELINE, szBuffer ) ;
1789:
1790: // sets up version number for TTY
1791:
1792: GetDlgItemText( hDlg, IDD_VERSION, szTemp, sizeof( szTemp ) ) ;
1793: wsprintf( szBuffer, szTemp, VER_MAJOR, VER_MINOR, VER_BUILD ) ;
1794: SetDlgItemText( hDlg, IDD_VERSION, (LPSTR) szBuffer ) ;
1795:
1796: // get by-line
1797:
1798: LoadString( GETHINST( hDlg ), IDS_BYLINE, szBuffer,
1799: sizeof( szBuffer ) ) ;
1800: SetDlgItemText( hDlg, IDD_BYLINE, szBuffer ) ;
1801:
1802: #ifndef WIN32
1803: // set windows mode information
1804:
1805: dwWinFlags = GetWinFlags() ;
1806: if (dwWinFlags & WF_ENHANCED)
1807: idModeString = IDS_MODE_ENHANCED ;
1808: else if (dwWinFlags & WF_STANDARD)
1809: idModeString = IDS_MODE_STANDARD ;
1810: else if (dwWinFlags & WF_WLO)
1811: idModeString = IDS_MODE_WLO ;
1812: else
1813: idModeString = IDS_MODE_UNDEF ;
1814:
1815: LoadString( GETHINST( hDlg ), idModeString, szBuffer,
1816: sizeof( szBuffer ) ) ;
1817: SetDlgItemText( hDlg, IDD_WINDOWSMODE, szBuffer ) ;
1818: #else
1819: SetDlgItemText( hDlg, IDD_WINDOWSMODE, "NT Mode" ) ;
1820: #endif
1821:
1822: // get free memory information
1823:
1824: dwFreeMemory = GetFreeSpace( 0 ) / 1024L ;
1825: GetDlgItemText( hDlg, IDD_FREEMEM, szTemp, sizeof( szTemp ) ) ;
1826: wsprintf( szBuffer, szTemp, dwFreeMemory ) ;
1827: SetDlgItemText( hDlg, IDD_FREEMEM, (LPSTR) szBuffer ) ;
1828:
1829: #ifndef WIN32
1830: // get free resources information
1831:
1832: wFreeResources = GetFreeSystemResources( 0 ) ;
1833: GetDlgItemText( hDlg, IDD_RESOURCES, szTemp, sizeof( szTemp ) ) ;
1834: wsprintf( szBuffer, szTemp, wFreeResources ) ;
1835: SetDlgItemText( hDlg, IDD_RESOURCES, (LPSTR) szBuffer ) ;
1836: #endif
1837: }
1838: return ( TRUE ) ;
1839:
1840: #ifdef ABOUTDLG_USEBITMAP
1841: // used to paint the bitmap
1842:
1843: case WM_PAINT:
1844: {
1845: HBITMAP hBitMap ;
1846: HDC hDC, hMemDC ;
1847: PAINTSTRUCT ps ;
1848:
1849: // load bitmap and display it
1850:
1851: hDC = BeginPaint( hDlg, &ps ) ;
1852: if (NULL != (hMemDC = CreateCompatibleDC( hDC )))
1853: {
1854: hBitMap = LoadBitmap( GETHINST( hDlg ),
1855: MAKEINTRESOURCE( TTYBITMAP ) ) ;
1856: hBitMap = SelectObject( hMemDC, hBitMap ) ;
1857: BitBlt( hDC, 10, 10, 64, 64, hMemDC, 0, 0, SRCCOPY ) ;
1858: DeleteObject( SelectObject( hMemDC, hBitMap ) ) ;
1859: DeleteDC( hMemDC ) ;
1860: }
1861: EndPaint( hDlg, &ps ) ;
1862: }
1863: break ;
1864: #endif
1865:
1866: case WM_COMMAND:
1867: if (LOWORD( wParam ) == IDD_OK)
1868: {
1869: EndDialog( hDlg, TRUE ) ;
1870: return ( TRUE ) ;
1871: }
1872: break;
1873: }
1874: return ( FALSE ) ;
1875:
1876: } // end of AboutDlgProc()
1877:
1878: //---------------------------------------------------------------------------
1879: // VOID NEAR FillComboBox( HINSTANCE hInstance, HWND hCtrlWnd, int nIDString,
1880: // WORD NEAR *npTable, WORD wTableLen,
1881: // WORD wCurrentSetting )
1882: //
1883: // Description:
1884: // Fills the given combo box with strings from the resource
1885: // table starting at nIDString. Associated items are
1886: // added from given table. The combo box is notified of
1887: // the current setting.
1888: //
1889: // Parameters:
1890: // HINSTANCE hInstance
1891: // handle to application instance
1892: //
1893: // HWND hCtrlWnd
1894: // handle to combo box control
1895: //
1896: // int nIDString
1897: // first resource string id
1898: //
1899: // DWORD NEAR *npTable
1900: // near point to table of associated values
1901: //
1902: // WORD wTableLen
1903: // length of table
1904: //
1905: // DWORD dwCurrentSetting
1906: // current setting (for combo box selection)
1907: //
1908: // History: Date Author Comment
1909: // 10/20/91 BryanW Pulled from the init procedure.
1910: //
1911: //---------------------------------------------------------------------------
1912:
1913: VOID NEAR FillComboBox( HINSTANCE hInstance, HWND hCtrlWnd, int nIDString,
1914: DWORD NEAR *npTable, WORD wTableLen,
1915: DWORD dwCurrentSetting )
1916: {
1917: char szBuffer[ MAXLEN_TEMPSTR ] ;
1918: WORD wCount, wPosition ;
1919:
1920: for (wCount = 0; wCount < wTableLen; wCount++)
1921: {
1922: // load the string from the string resources and
1923: // add it to the combo box
1924:
1925: LoadString( hInstance, nIDString + wCount, szBuffer, sizeof( szBuffer ) ) ;
1926: wPosition = LOWORD( SendMessage( hCtrlWnd, CB_ADDSTRING, NULL,
1927: (LPARAM) (LPSTR) szBuffer ) ) ;
1928:
1929: // use item data to store the actual table value
1930:
1931: SendMessage( hCtrlWnd, CB_SETITEMDATA, (WPARAM) wPosition,
1932: (LPARAM) *(npTable + wCount) ) ;
1933:
1934: // if this is our current setting, select it
1935:
1936: if (*(npTable + wCount) == dwCurrentSetting)
1937: SendMessage( hCtrlWnd, CB_SETCURSEL, (WPARAM) wPosition, NULL ) ;
1938: }
1939:
1940: } // end of FillComboBox()
1941:
1942: //---------------------------------------------------------------------------
1943: // BOOL NEAR SettingsDlgInit( HWND hDlg )
1944: //
1945: // Description:
1946: // Puts current settings into dialog box (via CheckRadioButton() etc.)
1947: //
1948: // Parameters:
1949: // HWND hDlg
1950: // handle to dialog box
1951: //
1952: // Win-32 Porting Issues:
1953: // - Constants require DWORD arrays for baud rate table, etc.
1954: // - There is no "MAXCOM" function in Win-32. Number of COM ports
1955: // is assumed to be 4.
1956: //
1957: // History: Date Author Comment
1958: // 5/11/91 BryanW Wrote it.
1959: // 10/20/91 BryanW Dialog revision.
1960: // 10/24/91 BryanW Fixed bug with EscapeCommFunction().
1961: // 6/15/92 BryanW Ported to Win-32.
1962: //
1963: //---------------------------------------------------------------------------
1964:
1965: BOOL NEAR SettingsDlgInit( HWND hDlg )
1966: {
1967: char szBuffer[ MAXLEN_TEMPSTR ], szTemp[ MAXLEN_TEMPSTR ] ;
1968: NPTTYINFO npTTYInfo ;
1969: WORD wCount, wMaxCOM, wPosition ;
1970:
1971: if (NULL == (npTTYInfo = (NPTTYINFO) GET_PROP( hDlg, ATOM_TTYINFO )))
1972: return ( FALSE ) ;
1973:
1974: #ifdef WIN32
1975: wMaxCOM = 4 ;
1976: #else
1977: wMaxCOM = LOWORD( EscapeCommFunction( NULL, GETMAXCOM ) ) + 1 ;
1978: #endif
1979:
1980: // load the COM prefix from resources
1981:
1982: LoadString( GETHINST( hDlg ), IDS_COMPREFIX, szTemp, sizeof( szTemp ) ) ;
1983:
1984: // fill port combo box and make initial selection
1985:
1986: for (wCount = 0; wCount < wMaxCOM; wCount++)
1987: {
1988: wsprintf( szBuffer, "%s%d", (LPSTR) szTemp, wCount + 1 ) ;
1989: SendDlgItemMessage( hDlg, IDD_PORTCB, CB_ADDSTRING, NULL,
1990: (LPARAM) (LPSTR) szBuffer ) ;
1991: }
1992: SendDlgItemMessage( hDlg, IDD_PORTCB, CB_SETCURSEL,
1993: (WPARAM) (PORT( npTTYInfo ) - 1), NULL ) ;
1994:
1995: // disable COM port combo box if connection has already been
1996: // established (e.g. OpenComm() already successful)
1997:
1998: EnableWindow( GetDlgItem( hDlg, IDD_PORTCB ), !CONNECTED( npTTYInfo ) ) ;
1999:
2000: // fill baud combo box and make initial selection
2001:
2002: FillComboBox( GETHINST( hDlg ), GetDlgItem( hDlg, IDD_BAUDCB ),
2003: IDS_BAUD110, BaudTable,
2004: sizeof( BaudTable ) / sizeof( BaudTable[ 0 ] ),
2005: BAUDRATE( npTTYInfo ) ) ;
2006:
2007: // fill data bits combo box and make initial selection
2008:
2009: for (wCount = 5; wCount < 9; wCount++)
2010: {
2011: wsprintf( szBuffer, "%d", wCount ) ;
2012: wPosition = LOWORD( SendDlgItemMessage( hDlg, IDD_DATABITSCB,
2013: CB_ADDSTRING, NULL,
2014: (LPARAM) (LPSTR) szBuffer ) ) ;
2015:
2016: // if current selection, tell the combo box
2017:
2018: if (wCount == BYTESIZE( npTTYInfo ))
2019: SendDlgItemMessage( hDlg, IDD_DATABITSCB, CB_SETCURSEL,
2020: (WPARAM) wPosition, NULL ) ;
2021: }
2022:
2023: // fill parity combo box and make initial selection
2024:
2025: FillComboBox( GETHINST( hDlg ), GetDlgItem( hDlg, IDD_PARITYCB ),
2026: IDS_PARITYNONE, ParityTable,
2027: sizeof( ParityTable ) / sizeof( ParityTable[ 0 ] ),
2028: PARITY( npTTYInfo ) ) ;
2029:
2030: // fill stop bits combo box and make initial selection
2031:
2032: FillComboBox( GETHINST( hDlg ), GetDlgItem( hDlg, IDD_STOPBITSCB ),
2033: IDS_ONESTOPBIT, StopBitsTable,
2034: sizeof( StopBitsTable ) / sizeof ( StopBitsTable ),
2035: STOPBITS( npTTYInfo ) ) ;
2036:
2037: // initalize the flow control settings
2038:
2039: CheckDlgButton( hDlg, IDD_DTRDSR,
2040: (FLOWCTRL( npTTYInfo ) & FC_DTRDSR) > 0 ) ;
2041: CheckDlgButton( hDlg, IDD_RTSCTS,
2042: (FLOWCTRL( npTTYInfo ) & FC_RTSCTS) > 0 ) ;
2043: CheckDlgButton( hDlg, IDD_XONXOFF,
2044: (FLOWCTRL( npTTYInfo ) & FC_XONXOFF) > 0 ) ;
2045:
2046: // other TTY settings
2047:
2048: CheckDlgButton( hDlg, IDD_AUTOWRAP, AUTOWRAP( npTTYInfo ) ) ;
2049: CheckDlgButton( hDlg, IDD_NEWLINE, NEWLINE( npTTYInfo ) ) ;
2050: CheckDlgButton( hDlg, IDD_LOCALECHO, LOCALECHO( npTTYInfo ) ) ;
2051:
2052: // control options
2053:
2054: #ifdef WIN32
2055: // "Use CN_RECEIVE" is not valid under Win-32
2056:
2057: EnableWindow( GetDlgItem( hDlg, IDD_USECNRECEIVE ), FALSE ) ;
2058: #else
2059: CheckDlgButton( hDlg, IDD_USECNRECEIVE, USECNRECEIVE( npTTYInfo ) ) ;
2060:
2061: // disable Use CN_RECEIVE option if connection has already been
2062: // established (e.g. OpenComm() already successful)
2063:
2064: EnableWindow( GetDlgItem( hDlg, IDD_USECNRECEIVE ),
2065: !CONNECTED( npTTYInfo ) ) ;
2066: #endif
2067:
2068: CheckDlgButton( hDlg, IDD_DISPLAYERRORS, DISPLAYERRORS( npTTYInfo ) ) ;
2069:
2070: return ( TRUE ) ;
2071:
2072: } // end of SettingsDlgInit()
2073:
2074: //---------------------------------------------------------------------------
2075: // BOOL NEAR SelectTTYFont( HWND hDlg )
2076: //
2077: // Description:
2078: // Selects the current font for the TTY screen.
2079: // Uses the Common Dialog ChooseFont() API.
2080: //
2081: // Parameters:
2082: // HWND hDlg
2083: // handle to settings dialog
2084: //
2085: // History: Date Author Comment
2086: // 10/20/91 BryanW Wrote it.
2087: //
2088: //---------------------------------------------------------------------------
2089:
2090: BOOL NEAR SelectTTYFont( HWND hDlg )
2091: {
2092: CHOOSEFONT cfTTYFont ;
2093: NPTTYINFO npTTYInfo ;
2094:
2095: if (NULL == (npTTYInfo = (NPTTYINFO) GET_PROP( hDlg, ATOM_TTYINFO )))
2096: return ( FALSE ) ;
2097:
2098: cfTTYFont.lStructSize = sizeof( CHOOSEFONT ) ;
2099: cfTTYFont.hwndOwner = hDlg ;
2100: cfTTYFont.hDC = NULL ;
2101: cfTTYFont.rgbColors = FGCOLOR( npTTYInfo ) ;
2102: cfTTYFont.lpLogFont = &LFTTYFONT( npTTYInfo ) ;
2103: cfTTYFont.Flags = CF_SCREENFONTS | CF_FIXEDPITCHONLY |
2104: CF_EFFECTS | CF_INITTOLOGFONTSTRUCT ;
2105: cfTTYFont.lCustData = NULL ;
2106: cfTTYFont.lpfnHook = NULL ;
2107: cfTTYFont.lpTemplateName = NULL ;
2108: cfTTYFont.hInstance = GETHINST( hDlg ) ;
2109:
2110: if (ChooseFont( &cfTTYFont ))
2111: {
2112: FGCOLOR( npTTYInfo ) = cfTTYFont.rgbColors ;
2113: ResetTTYScreen( GetParent( hDlg ), npTTYInfo ) ;
2114: }
2115:
2116: return ( TRUE ) ;
2117:
2118: } // end of SelectTTYFont()
2119:
2120: //---------------------------------------------------------------------------
2121: // BOOL NEAR SettingsDlgTerm( HWND hDlg )
2122: //
2123: // Description:
2124: // Puts dialog contents into TTY info structure.
2125: //
2126: // Parameters:
2127: // HWND hDlg
2128: // handle to settings dialog
2129: //
2130: // Win-32 Porting Issues:
2131: // - Baud rate requires DWORD values.
2132: //
2133: // History: Date Author Comment
2134: // 5/11/91 BryanW Wrote it.
2135: // 6/15/92 BryanW Ported to Win-32.
2136: //
2137: //---------------------------------------------------------------------------
2138:
2139: BOOL NEAR SettingsDlgTerm( HWND hDlg )
2140: {
2141: NPTTYINFO npTTYInfo ;
2142: WORD wSelection ;
2143:
2144: if (NULL == (npTTYInfo = (NPTTYINFO) GET_PROP( hDlg, ATOM_TTYINFO )))
2145: return ( FALSE ) ;
2146:
2147: // get port selection
2148:
2149: PORT( npTTYInfo ) =
2150: LOBYTE( LOWORD( SendDlgItemMessage( hDlg, IDD_PORTCB,
2151: CB_GETCURSEL,
2152: NULL, NULL ) ) + 1 ) ;
2153: // get baud rate selection
2154:
2155: wSelection =
2156: LOWORD( SendDlgItemMessage( hDlg, IDD_BAUDCB, CB_GETCURSEL,
2157: NULL, NULL ) ) ;
2158: #ifdef WIN32
2159: BAUDRATE( npTTYInfo ) =
2160: SendDlgItemMessage( hDlg, IDD_BAUDCB, CB_GETITEMDATA,
2161: (WPARAM) wSelection, NULL ) ;
2162: #else
2163: BAUDRATE( npTTYInfo ) =
2164: LOWORD( SendDlgItemMessage( hDlg, IDD_BAUDCB, CB_GETITEMDATA,
2165: (WPARAM) wSelection, NULL ) ) ;
2166: #endif
2167:
2168: // get data bits selection
2169:
2170: BYTESIZE( npTTYInfo ) =
2171: LOBYTE( LOWORD( SendDlgItemMessage( hDlg, IDD_DATABITSCB,
2172: CB_GETCURSEL,
2173: NULL, NULL ) ) + 5 ) ;
2174:
2175: // get parity selection
2176:
2177: wSelection =
2178: LOWORD( SendDlgItemMessage( hDlg, IDD_PARITYCB, CB_GETCURSEL,
2179: NULL, NULL ) ) ;
2180: PARITY( npTTYInfo ) =
2181: LOBYTE( LOWORD( SendDlgItemMessage( hDlg, IDD_PARITYCB,
2182: CB_GETITEMDATA,
2183: (WPARAM) wSelection,
2184: NULL ) ) ) ;
2185:
2186: // get stop bits selection
2187:
2188: wSelection =
2189: LOWORD( SendDlgItemMessage( hDlg, IDD_STOPBITSCB, CB_GETCURSEL,
2190: NULL, NULL ) ) ;
2191: STOPBITS( npTTYInfo ) =
2192: LOBYTE( LOWORD( SendDlgItemMessage( hDlg, IDD_STOPBITSCB,
2193: CB_GETITEMDATA,
2194: (WPARAM) wSelection, NULL ) ) ) ;
2195:
2196: // get flow control settings
2197:
2198: FLOWCTRL( npTTYInfo ) = 0 ;
2199: if (IsDlgButtonChecked( hDlg, IDD_DTRDSR ))
2200: FLOWCTRL( npTTYInfo ) |= FC_DTRDSR ;
2201: if (IsDlgButtonChecked( hDlg, IDD_RTSCTS ))
2202: FLOWCTRL( npTTYInfo ) |= FC_RTSCTS ;
2203: if (IsDlgButtonChecked( hDlg, IDD_XONXOFF ))
2204: FLOWCTRL( npTTYInfo ) |= FC_XONXOFF ;
2205:
2206: // get other various settings
2207:
2208: AUTOWRAP( npTTYInfo ) = IsDlgButtonChecked( hDlg, IDD_AUTOWRAP ) ;
2209: NEWLINE( npTTYInfo ) = IsDlgButtonChecked( hDlg, IDD_NEWLINE ) ;
2210: LOCALECHO( npTTYInfo ) = IsDlgButtonChecked( hDlg, IDD_LOCALECHO ) ;
2211:
2212: // control options
2213:
2214: USECNRECEIVE( npTTYInfo ) = IsDlgButtonChecked( hDlg, IDD_USECNRECEIVE ) ;
2215: DISPLAYERRORS( npTTYInfo ) = IsDlgButtonChecked( hDlg, IDD_DISPLAYERRORS ) ;
2216:
2217: return ( TRUE ) ;
2218:
2219: } // end of SettingsDlgTerm()
2220:
2221: //---------------------------------------------------------------------------
2222: // BOOL FAR PASCAL SettingsDlgProc( HWND hDlg, UINT uMsg,
2223: // WPARAM wParam, LPARAM lParam )
2224: //
2225: // Description:
2226: // This handles all of the user preference settings for
2227: // the TTY.
2228: //
2229: // Parameters:
2230: // same as all dialog procedures
2231: //
2232: // Win-32 Porting Issues:
2233: // - npTTYInfo is a DWORD in Win-32.
2234: //
2235: // History: Date Author Comment
2236: // 5/10/91 BryanW Wrote it.
2237: // 10/20/91 BryanW Now uses window properties to
2238: // store TTYInfo handle. Also added
2239: // font selection.
2240: // 6/15/92 BryanW Ported to Win-32.
2241: //
2242: //---------------------------------------------------------------------------
2243:
2244: BOOL FAR PASCAL SettingsDlgProc( HWND hDlg, UINT uMsg,
2245: WPARAM wParam, LPARAM lParam )
2246: {
2247: switch (uMsg)
2248: {
2249: case WM_INITDIALOG:
2250: {
2251: NPTTYINFO npTTYInfo ;
2252:
2253: // get & save pointer to TTY info structure
2254:
2255: #ifdef WIN32
2256: npTTYInfo = (NPTTYINFO) lParam ;
2257: #else
2258: npTTYInfo = (NPTTYINFO) LOWORD( lParam ) ;
2259: #endif
2260:
2261: SET_PROP( hDlg, ATOM_TTYINFO, (HANDLE) npTTYInfo ) ;
2262:
2263: return ( SettingsDlgInit( hDlg ) ) ;
2264: }
2265:
2266: case WM_COMMAND:
2267: switch ( LOWORD( wParam ))
2268: {
2269: case IDD_FONT:
2270: return ( SelectTTYFont( hDlg ) ) ;
2271:
2272: case IDD_OK:
2273: // Copy stuff into structure
2274: SettingsDlgTerm( hDlg ) ;
2275: EndDialog( hDlg, TRUE ) ;
2276: return ( TRUE ) ;
2277:
2278: case IDD_CANCEL:
2279: // Just end
2280: EndDialog( hDlg, TRUE ) ;
2281: return ( TRUE ) ;
2282: }
2283: break;
2284:
2285: case WM_DESTROY:
2286: REMOVE_PROP( hDlg, ATOM_TTYINFO ) ;
2287: break ;
2288: }
2289: return ( FALSE ) ;
2290:
2291: } // end of SettingsDlgProc()
2292:
2293: #ifdef WIN32
2294:
2295: //************************************************************************
2296: // DWORD FAR PASCAL CommWatchProc( LPSTR lpData )
2297: //
2298: // Description:
2299: // A secondary thread that will watch for COMM events.
2300: //
2301: // Parameters:
2302: // LPSTR lpData
2303: // 32-bit pointer argument
2304: //
2305: // Win-32 Porting Issues:
2306: // - Added this thread to watch the communications device and
2307: // post notifications to the associated window.
2308: //
2309: // History: Date Author Comment
2310: // 12/31/91 BryanW Wrote it.
2311: // 6/12/92 BryanW CommWaitEvent() now uses
2312: // an overlapped structure.
2313: //
2314: //************************************************************************
2315:
2316: DWORD FAR PASCAL CommWatchProc( LPSTR lpData )
2317: {
2318: DWORD cbTransfer ;
2319: DWORD dwEvtMask ;
2320: NPTTYINFO npTTYInfo = (NPTTYINFO) lpData ;
2321: OVERLAPPED os ;
2322:
2323: memset( &os, 0, sizeof( OVERLAPPED ) ) ;
2324:
2325: // create I/O event used for overlapped read
2326:
2327: os.hEvent = CreateEvent( NULL, // no security
2328: TRUE, // explicit reset req
2329: FALSE, // initial event reset
2330: NULL ) ; // no name
2331: if (os.hEvent == NULL)
2332: {
2333: MessageBox( NULL, "Failed to create event for thread!", "TTY Error!",
2334: MB_ICONEXCLAMATION | MB_OK ) ;
2335: return ( FALSE ) ;
2336: }
2337:
2338: if (!SetCommMask( COMDEV( npTTYInfo ), EV_RXCHAR ))
2339: return ( FALSE ) ;
2340:
2341: while ( CONNECTED( npTTYInfo ) )
2342: {
2343: dwEvtMask = NULL ;
2344:
2345: if (!WaitCommEvent( COMDEV( npTTYInfo ), &dwEvtMask, &os ))
2346: {
2347: if (ERROR_IO_PENDING == GetLastError())
2348: {
2349: GetOverlappedResult( COMDEV( npTTYInfo ), &os, &cbTransfer, TRUE ) ;
2350: os.Offset += cbTransfer ;
2351: }
2352: }
2353:
2354: if ((dwEvtMask & EV_RXCHAR) == EV_RXCHAR)
2355: {
2356: // wait for "posted notification" flag to clear
2357:
2358: WaitForSingleObject( POSTEVENT( npTTYInfo ), 0xFFFFFFFF ) ;
2359:
2360: // reset event
2361:
2362: ResetEvent( POSTEVENT( npTTYInfo ) ) ;
2363:
2364: // last message was processed, O.K. to post
2365:
2366: PostMessage( TERMWND( npTTYInfo ), WM_COMMNOTIFY,
2367: (WPARAM) COMDEV( npTTYInfo ),
2368: MAKELONG( CN_EVENT, 0 ) ) ;
2369: }
2370: }
2371:
2372: // get rid of event handle
2373:
2374: CloseHandle( os.hEvent ) ;
2375:
2376: // clear information in structure (kind of a "we're done flag")
2377:
2378: THREADID( npTTYInfo ) = NULL ;
2379: HTHREAD( npTTYInfo ) = NULL ;
2380:
2381: return( TRUE ) ;
2382:
2383: } // end of CommWatchProc()
2384:
2385: #endif
2386:
2387: //---------------------------------------------------------------------------
2388: // End of File: tty.c
2389: //---------------------------------------------------------------------------
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.