BAUDRATE(TTYInfo) = GetdwTTYItem(ghWndToolbarDlg, 
					                         IDC_BAUDCOMBO, 
					                         szBaud, 
					                         BaudTable, 
					                         sizeof(BaudTable)/sizeof(BaudTable[0]));

  PARITY(TTYInfo) = GetbTTYItem(ghWndToolbarDlg, 
				                        IDC_PARITYCOMBO, 
				                        szParity, 
				                        ParityTable, 
				                        sizeof(ParityTable)/sizeof(ParityTable[0]));

  STOPBITS(TTYInfo) = GetbTTYItem(ghWndToolbarDlg, 
				                          IDC_STOPBITSCOMBO, 
				                          szStopBits, 
				                          StopBitsTable, 
				                          sizeof(StopBitsTable)/sizeof(StopBitsTable[0]));

  LOCALECHO(TTYInfo) = IsDlgButtonChecked(ghWndToolbarDlg,IDC_LOCALECHOCHK);
  BYTESIZE(TTYInfo) = GetDlgItemInt(ghWndToolbarDlg,IDC_DATABITSCOMBO,NULL,FALSE);
  NEWLINE(TTYInfo) = IsDlgButtonChecked(ghWndToolbarDlg,IDC_LFBTN);
  AUTOWRAP(TTYInfo) = IsDlgButtonChecked(ghWndToolbarDlg,IDC_AUTOWRAPCHK);
  DISPLAYERRORS(TTYInfo) = IsDlgButtonChecked(ghWndToolbarDlg,IDC_DISPLAYERRORSCHK);

  NOREADING(TTYInfo) = IsDlgButtonChecked(ghWndToolbarDlg,IDC_NOREADINGCHK);
  NOWRITING(TTYInfo) = IsDlgButtonChecked(ghWndToolbarDlg,IDC_NOWRITINGCHK);
  NOEVENTS(TTYInfo)  = IsDlgButtonChecked(ghWndToolbarDlg,IDC_NOEVENTSCHK);
  NOSTATUS(TTYInfo)  = IsDlgButtonChecked(ghWndToolbarDlg,IDC_NOSTATUSCHK);

  if (CONNECTED(TTYInfo))      // if connected, then update port state
  {
	  UpdateConnection();
  }

  return;
}

BOOL UpdateConnection()
{
  DCB dcb = {0};
    
  dcb.DCBlength = sizeof(dcb);

  // get current DCB settings
  if (!GetCommState(COMDEV(TTYInfo),&dcb))
  {
	  ErrorReporter("GetCommState");
  }

  // update DCB rate, byte size, parity, and stop bits size
  dcb.BaudRate = BAUDRATE(TTYInfo);
  dcb.ByteSize = BYTESIZE(TTYInfo);
  dcb.Parity   = PARITY(TTYInfo);
  dcb.StopBits = STOPBITS(TTYInfo);

  // update event flags
  if (EVENTFLAGS(TTYInfo) & EV_RXFLAG)
  {
	  dcb.EvtChar = FLAGCHAR(TTYInfo);      
  }
  else
  {
	  dcb.EvtChar = '\0';
  }

  // update flow control settings
  dcb.fDtrControl     = DTRCONTROL(TTYInfo);
  dcb.fRtsControl     = RTSCONTROL(TTYInfo);

  dcb.fOutxCtsFlow    = CTSOUTFLOW(TTYInfo);
  dcb.fOutxDsrFlow    = DSROUTFLOW(TTYInfo);
  dcb.fDsrSensitivity = DSRINFLOW(TTYInfo);
  dcb.fOutX           = XONXOFFOUTFLOW(TTYInfo);
  dcb.fInX            = XONXOFFINFLOW(TTYInfo);
  dcb.fTXContinueOnXoff = TXAFTERXOFFSENT(TTYInfo);
  dcb.XonChar         = XONCHAR(TTYInfo);
  dcb.XoffChar        = XOFFCHAR(TTYInfo);
  dcb.XonLim          = XONLIMIT(TTYInfo);
  dcb.XoffLim         = XOFFLIMIT(TTYInfo);

  // DCB settings not in the user's control
  dcb.fParity = TRUE;

  // set new state
  if (!SetCommState(COMDEV(TTYInfo),&dcb))
  {
	  ErrorReporter("SetCommState");
  }

  // set new timeouts
  if (!SetCommTimeouts(COMDEV(TTYInfo),&(TIMEOUTSNEW(TTYInfo))))
	{
    ErrorReporter("SetCommTimeouts");
  }

  return TRUE;
}

void FillComboBox(HWND hCtrlWnd, 
                  char ** szString,
			            DWORD * npTable, 
                  WORD wTableLen, 
                  DWORD dwCurrentSetting)
{
  WORD wCount, wPosition ;

  for (wCount = 0;wCount < wTableLen;wCount++) 
  {
	  wPosition = LOWORD(SendMessage(hCtrlWnd,CB_ADDSTRING,0,(LPARAM)(LPSTR)szString[wCount]));

	  // use item data to store the actual table value
	  SendMessage(hCtrlWnd,CB_SETITEMDATA,(WPARAM)wPosition,(LPARAM) *(npTable + wCount));

	  // if this is our current setting, select it
	  if (*(npTable + wCount) == dwCurrentSetting)
    {
	    SendMessage(hCtrlWnd,CB_SETCURSEL,(WPARAM)wPosition,0L);
    }
  }
  
  return;
}

void SetComboBox(HWND hCtrlWnd,WORD wTableLen,DWORD dwNewSetting)
{
  WORD wCount, wItemData ;

  for (wCount = 0;wCount < wTableLen;wCount++) 
  {
	  wItemData = LOWORD(SendMessage(hCtrlWnd,CB_GETITEMDATA,(WPARAM)wCount,0L));

	  if (wItemData == dwNewSetting) 
    {
	    SendMessage(hCtrlWnd,CB_SETCURSEL,(WPARAM)wCount,0L);
	    break;
	  }
  }
  
  return;
}

BOOL SettingsDlgInit(HWND hDlg)
{
  char szBuffer[MAXLEN_TEMPSTR],szTemp[MAXLEN_TEMPSTR];
  WORD wCount, wMaxCOM, wPosition;

  wMaxCOM = MAXPORTS;
  strcpy(szTemp,"COM");

  // fill port combo box and make initial selection
  for (wCount = 0;wCount < wMaxCOM;wCount++) 
  {
	  wsprintf(szBuffer,"%s%d",(LPSTR)szTemp,wCount+1);
	  SendDlgItemMessage(hDlg,IDC_PORTCOMBO,CB_ADDSTRING,0,(LPARAM)(LPSTR)szBuffer);
  }

  SendDlgItemMessage(hDlg,IDC_PORTCOMBO,CB_SETCURSEL,(WPARAM)(PORT(TTYInfo)-1),0L);
   
  GetDlgItemText(hDlg,IDC_PORTCOMBO,gszPort,sizeof(gszPort));

  // fill baud combo box and make initial selection
  FillComboBox(GetDlgItem(hDlg,IDC_BAUDCOMBO),
		           szBaud, 
               BaudTable,
		           sizeof(BaudTable) / sizeof(BaudTable[0]),
		           BAUDRATE(TTYInfo));

  // fill data bits combo box and make initial selection
  for (wCount = 5;wCount < 9;wCount++) 
  {
	  wsprintf(szBuffer,"%d",wCount);
	  wPosition = LOWORD(SendDlgItemMessage(hDlg,IDC_DATABITSCOMBO,
						                              CB_ADDSTRING, 0,
						                              (LPARAM)(LPSTR)szBuffer));

	  // if wCount is current selection, tell the combo box
	  if (wCount == BYTESIZE(TTYInfo))
    {
	    SendDlgItemMessage(hDlg,IDC_DATABITSCOMBO,CB_SETCURSEL,(WPARAM)wPosition,0L);
    }
  }

  // fill parity combo box and make initial selection
  FillComboBox(GetDlgItem(hDlg,IDC_PARITYCOMBO),
		           szParity, 
               ParityTable,
		           sizeof(ParityTable) / sizeof(ParityTable[0]),
		           PARITY(TTYInfo));

  // fill stop bits combo box and make initial selection
  FillComboBox(GetDlgItem(hDlg,IDC_STOPBITSCOMBO),
		           szStopBits, 
               StopBitsTable,
		           sizeof(StopBitsTable) / sizeof(StopBitsTable[0]),
		           STOPBITS(TTYInfo));
  
  // set check marks based on TTY data
  CheckDlgButton(hDlg,IDC_LOCALECHOCHK,LOCALECHO(TTYInfo));
  CheckDlgButton(hDlg,IDC_DISPLAYERRORSCHK,DISPLAYERRORS(TTYInfo));
  CheckDlgButton(hDlg,IDC_LFBTN,NEWLINE(TTYInfo));
  CheckDlgButton(hDlg,IDC_AUTOWRAPCHK,AUTOWRAP(TTYInfo));

  CheckDlgButton(hDlg,IDC_NOWRITINGCHK,NOWRITING(TTYInfo));
  CheckDlgButton(hDlg,IDC_NOREADINGCHK,NOREADING(TTYInfo));
  CheckDlgButton(hDlg,IDC_NOSTATUSCHK,NOSTATUS(TTYInfo));
  CheckDlgButton(hDlg,IDC_NOEVENTSCHK,NOEVENTS(TTYInfo));

  return (TRUE);

} // end of SettingsDlgInit()

DWORD GetdwTTYItem(HWND hDlg,int idControl,char ** szString,DWORD * pTable,int iNumItems)
{
  int i;
  char szItem[MAXLEN_TEMPSTR];

  // Get current selection (a string)
  GetDlgItemText(hDlg,idControl,szItem,sizeof(szItem));
    
  // Compare current selection with table to find index of item.
	// If index is found, then return the DWORD item from table.
  for (i = 0;i < iNumItems;i++) 
  {
	  if (strcmp(szString[i],szItem) == 0)
	  {
      return pTable[i];
    }
  }

  return 0;
}

BYTE GetbTTYItem(HWND hDlg, int idControl, char ** szString, DWORD * pTable, int iNumItems)
{
  int i;
  char szItem[MAXLEN_TEMPSTR];

  // Get current selection (a string)
  GetDlgItemText(hDlg,idControl,szItem,sizeof(szItem));
    
  // Compare current selection with table to find index of item.
	// If index is found, then return the BYTE item from table.
   
  for (i = 0;i < iNumItems;i++) 
  {
	  if (strcmp(szString[i],szItem) == 0)
	  {
      return (BYTE)pTable[i];
    }
  }
    
  return 0;
}

BOOL CALLBACK ToolbarProc(HWND hWndDlg,UINT uMsg,WPARAM wParam,LPARAM lParam)
{
  BOOL fRet = FALSE;

  switch(uMsg)
  {
	  case WM_INITDIALOG:     // setup dialog with defaults
	       SettingsDlgInit(hWndDlg);
	       break;

	  case WM_COMMAND: 
	       {
		       switch(LOWORD(wParam))
		       {
		         case IDC_FONTBTN:       // font button pressed
			            {
			              CHOOSEFONT cf = {0};
			              LOGFONT lf;

			              lf = LFTTYFONT(TTYInfo);
			              cf.lStructSize = sizeof(CHOOSEFONT);
			              cf.hwndOwner = hWndDlg;
			              cf.lpLogFont = &lf;
			              cf.rgbColors = FGCOLOR(TTYInfo);
			              cf.Flags = CF_INITTOLOGFONTSTRUCT | CF_SCREENFONTS | CF_FIXEDPITCHONLY | \
				            CF_EFFECTS;

			              if (!ChooseFont(&cf))
                    {
				              break;
                    }

			              InitNewFont(lf,cf.rgbColors);

			              // fix scroll bar sizes since we may have more or less pixels per
			              // character now
			              SizeTTY(ghWndTTY,(WORD)XSIZE(TTYInfo),(WORD)YSIZE(TTYInfo));
			    
			              // repaint screen contents
			              InvalidateRect(ghWndTTY,NULL,TRUE);
			    
			              // kill old cursor
			              KillTTYFocus(ghWndTTY);
			    
			              // create new cursor
			              SetTTYFocus(ghWndTTY);
			            }
			
                  fRet = FALSE;
			            break;

		         case IDC_COMMEVENTSBTN:     // comm events button pressed
			            DialogBox(ghInst,MAKEINTRESOURCE(IDD_COMMEVENTSDLG),ghwndMain,CommEventsProc);
			            fRet = FALSE;
			            break;

		         case IDC_FLOWCONTROLBTN:
			            DialogBox(ghInst,MAKEINTRESOURCE(IDD_FLOWCONTROLDLG),ghwndMain,FlowControlProc);
			            fRet = FALSE;
			            break;

		         case IDC_TIMEOUTSBTN:
			            DialogBox(ghInst,MAKEINTRESOURCE(IDD_TIMEOUTSDLG),ghwndMain,TimeoutsProc);
			            fRet = FALSE;
			            break;

		         default:                    // some other control has been modified
			            if (CONNECTED(TTYInfo))
                  {
			              UpdateTTYInfo();
                  }
			            break;
		       }
	       }
	       break;

	  default:
	       break;
  }    

  return fRet;
}

void InitHexControl(HWND hdlg,WORD wIdNumberBox,WORD wIdCharBox,char chData)
{
  char szFlagText[3] = {0};
  char szFlagChar[2] = {0};
    
  // put character into char edit display control
  szFlagChar[0] = chData;
  SetDlgItemText(hdlg,wIdCharBox,szFlagChar);
    
  // put flag character into hex numeric edit control
  wsprintf(szFlagText,"%02x",0x000000FF & chData);
  SetDlgItemText(hdlg,wIdNumberBox,szFlagText);

  return;
}

char GetHexControl(HWND hdlg,WORD wIdNumberBox,WORD wIdCharBox)
{
  UINT uFlagValue;
  char chFlagEntered[3] = {0};
  char chFlag[2] = {0};
    
  // get numeric value from control
  if (0 == GetDlgItemText(hdlg,wIdNumberBox,chFlagEntered,3))
	{
    return 0;
  }

  sscanf(chFlagEntered,"%x",&uFlagValue);

  chFlag[0] = (char)uFlagValue;
  SetDlgItemText(hdlg,wIdCharBox,chFlag); // display character

  return chFlag[0];
}

void InitCommEventsDlg(HWND hdlg, DWORD dwEventFlags)
{
  int i,j;

  for (i = IDC_EVBREAKBTN,j = 0;i <= IDC_EVTXEMPTYBTN;i++,j++)
  {
	  CheckDlgButton(hdlg,i,dwEventFlags & EventFlagsTable[j]);
  }

  InitHexControl(hdlg,IDC_FLAGEDIT,IDC_FLAGCHAR,FLAGCHAR(TTYInfo));

  EnableWindow(GetDlgItem(hdlg,IDC_FLAGEDIT),dwEventFlags & EV_RXFLAG);
  EnableWindow(GetDlgItem(hdlg,IDC_FLAGCHAR),dwEventFlags & EV_RXFLAG);

  return;
}

void SaveCommEventsDlg(HWND hdlg)
{
  int i,j;
  DWORD dwNew = {0};
  char chNewFlag = '\0';
  BOOL fChangingRXFLAG;

  // create a flag out of dialog selections
  for (i = IDC_EVBREAKBTN,j = 0;i <= IDC_EVTXEMPTYBTN;i++,j++) 
  {
	  if (IsDlgButtonChecked(hdlg,i))
    {
	    dwNew |= EventFlagsTable[j];
    }
  }

  // get current flag character from dialog
  chNewFlag = GetHexControl(hdlg,IDC_FLAGEDIT,IDC_FLAGCHAR);
  fChangingRXFLAG = (EVENTFLAGS(TTYInfo) & EV_RXFLAG) != (dwNew & EV_RXFLAG);
  
  if (chNewFlag != FLAGCHAR(TTYInfo) || fChangingRXFLAG) 
  {
	  FLAGCHAR(TTYInfo) = chNewFlag;
	  UpdateTTYInfo();
  }

  // if new flags have been selected, or
  if (dwNew != EVENTFLAGS(TTYInfo))
	{
    EVENTFLAGS(TTYInfo) = dwNew;
  }

  return;
}

BOOL CALLBACK CommEventsProc(HWND hdlg,UINT uMessage,WPARAM wparam,LPARAM lparam)
{
  switch(uMessage)
  {
	  case WM_INITDIALOG:     // init controls
	       InitCommEventsDlg(hdlg,EVENTFLAGS(TTYInfo));
	       break;

	  case WM_COMMAND: 
	       switch(LOWORD(wparam))
	       {
		       case IDOK:
		            SaveCommEventsDlg(hdlg);
		    
		    		    // FALL THROUGH
		    
		       case IDCANCEL:
		            EndDialog(hdlg,LOWORD(wparam));
		            return TRUE;

		       case IDC_DEFAULTSBTN:
		            InitCommEventsDlg(hdlg,EVENTFLAGS_DEFAULT);
		            return TRUE;

		       case IDC_EVRXFLAGBTN:
		            EnableWindow(GetDlgItem(hdlg,IDC_FLAGEDIT),IsDlgButtonChecked(hdlg,IDC_EVRXFLAGBTN));
		            EnableWindow(GetDlgItem(hdlg,IDC_FLAGCHAR),IsDlgButtonChecked(hdlg,IDC_EVRXFLAGBTN));
		            return TRUE;

		       case IDC_FLAGEDIT:
		            GetHexControl(hdlg,IDC_FLAGEDIT,IDC_FLAGCHAR);
		            return TRUE;
	       }
	       break;
  }

  return FALSE;
}

void SaveFlowControlDlg(HWND hdlg)
{
  BOOL    fNewCTSOut, fNewDSROut, fNewDSRIn, fNewXOut, fNewXIn, fNewTXafterXoffSent;
  DWORD   dwNewDTRControl, dwNewRTSControl;
  WORD    wNewXONLimit, wNewXOFFLimit;
  char    chNewXON, chNewXOFF;
  BOOL    fSuccess;

  BOOL fUpdateDCB = FALSE;

  // update DTR and RTS control if needed
  dwNewDTRControl = GetdwTTYItem(hdlg,
                                 IDC_DTRCONTROLCOMBO, 
		                             szDTRControlString