LFTTYFONT(TTYInfo).lfUnderline =      0 ;
  LFTTYFONT(TTYInfo).lfStrikeOut =      0 ;
  LFTTYFONT(TTYInfo).lfCharSet =        OEM_CHARSET ;
  LFTTYFONT(TTYInfo).lfOutPrecision =   OUT_DEFAULT_PRECIS ;
  LFTTYFONT(TTYInfo).lfClipPrecision =  CLIP_DEFAULT_PRECIS ;
  LFTTYFONT(TTYInfo).lfQuality =        DEFAULT_QUALITY ;
  LFTTYFONT(TTYInfo).lfPitchAndFamily = FIXED_PITCH | FF_MODERN ;
  strcpy(LFTTYFONT(TTYInfo).lfFaceName, "FixedSys" ) ;

  InitNewFont(LFTTYFONT(TTYInfo), RGB(0,0,0));

  ClearTTYContents();

  return (TRUE) ;
}

void DestroyTTYInfo()
{
  DeleteObject(HTTYFONT(TTYInfo));
}

void StartThreads(void)
{
  DWORD dwReadStatId;
  DWORD dwWriterId;

  READSTATTHREAD(TTYInfo) = CreateThread(NULL, 
                                         0,
                                         (LPTHREAD_START_ROUTINE) ReaderAndStatusProc,
                                         (LPVOID) ghWndTTY, 
                                         0, 
                                         &dwReadStatId);

  if (READSTATTHREAD(TTYInfo) == NULL)
  {
    ErrorInComm("CreateThread(Reader/Status)");
  }

  WRITERTHREAD(TTYInfo) = CreateThread(NULL, 
                                       0, 
                                       (LPTHREAD_START_ROUTINE) WriterProc, 
                                       (LPVOID) NULL, 
                                       0, 
                                       &dwWriterId);
                   
  if (WRITERTHREAD(TTYInfo) == NULL)
  {
    ErrorInComm("CreateThread(Writer)");
  }

  return;
}

HANDLE SetupCommPort()
{
  // get tty settings from settings dialog
  UpdateTTYInfo();

  // open communication port handle
  COMDEV(TTYInfo) = CreateFile(gszPort,  
                               GENERIC_READ | GENERIC_WRITE, 
                               0, 
                               0, 
                               OPEN_EXISTING,
                               FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED,
                               0);

  if (COMDEV(TTYInfo) == INVALID_HANDLE_VALUE) 
  {   
    ErrorReporter("CreateFile");
    return NULL;
  }

  // Save original comm timeouts and set new ones
  if (!GetCommTimeouts( COMDEV(TTYInfo),&(TIMEOUTSORIG(TTYInfo))))
  {
    ErrorReporter("GetCommTimeouts");
  }

  // Set port state
  UpdateConnection();

  // set comm buffer sizes
  SetupComm(COMDEV(TTYInfo),MAX_READ_BUFFER,MAX_WRITE_BUFFER);

  // raise DTR
  if (!EscapeCommFunction(COMDEV(TTYInfo),SETDTR))
  {
    ErrorReporter("EscapeCommFunction(SETDTR)");
  }

  // start threads and set initial thread state to not done
  StartThreads();

  // set overall connect flag
  CONNECTED(TTYInfo) = TRUE ;

  return COMDEV(TTYInfo);
}

DWORD WaitForThreads(DWORD dwTimeout)
{	
  HANDLE hThreads[2];
  DWORD  dwRes;

  hThreads[0] = READSTATTHREAD(TTYInfo);
  hThreads[1] = WRITERTHREAD(TTYInfo);

  // set thread exit event here
  SetEvent(ghThreadExitEvent);

  dwRes = WaitForMultipleObjects(2,hThreads,TRUE,dwTimeout);
  
  switch(dwRes)
  {
    case WAIT_OBJECT_0:
    case WAIT_OBJECT_0 + 1: 
         dwRes = WAIT_OBJECT_0;
         break;

    case WAIT_TIMEOUT:
         if (WaitForSingleObject(READSTATTHREAD(TTYInfo),0) == WAIT_TIMEOUT)
         {
           OutputDebugString("Reader/Status Thread didn't exit.\n\r");
         }

         if (WaitForSingleObject(WRITERTHREAD(TTYInfo),0) == WAIT_TIMEOUT)
         {
           OutputDebugString("Writer Thread didn't exit.\n\r");
         }
         break;

    default:
         ErrorReporter("WaitForMultipleObjects");
         break;
  }

  // reset thread exit event here
  ResetEvent(ghThreadExitEvent);

  return dwRes;
}

BOOL BreakDownCommPort()
{
  if (!CONNECTED(TTYInfo))
  {
    return FALSE;
  }

  CONNECTED(TTYInfo) = FALSE;

  // wait for the threads for a small period
  if (WaitForThreads(20000) != WAIT_OBJECT_0)
  { 
    // if threads haven't exited, then they will interfere with a new 
    // connection. I must abort the entire program.
    ErrorHandler("Error closing port.");
  }

  // lower DTR
  if (!EscapeCommFunction(COMDEV(TTYInfo),CLRDTR))
  {
    ErrorReporter("EscapeCommFunction(CLRDTR)");
  }

  // restore original comm timeouts
  if (!SetCommTimeouts(COMDEV(TTYInfo),&(TIMEOUTSORIG(TTYInfo))))
  {
    ErrorReporter("SetCommTimeouts (Restoration to original)");
  }

  // Purge reads/writes, input buffer and output buffer
  if (!PurgeComm(COMDEV(TTYInfo),PURGE_FLAGS))
  {
    ErrorReporter("PurgeComm");
  }

  CloseHandle(COMDEV(TTYInfo));
  CloseHandle(READSTATTHREAD(TTYInfo));
  CloseHandle(WRITERTHREAD(TTYInfo));

  return TRUE;
}

BOOL DisconnectOK()
{
  if (!CONNECTED(TTYInfo))
  {
    return TRUE;
  }
    
  return ((MessageBox(ghwndMain,"OK to Disconnect?",gszPort,MB_YESNO)) == IDYES);
}

void TransferRepeatCreate(LPCTSTR lpszFileName,DWORD dwFrequency)
{
  HMENU hMenu;
  UINT  MenuFlags ;
  DWORD dwFileSize;
  DWORD dwMaxPackets;
  DWORD dwPacketSize;
  DWORD dwRead;

  // open the file
  hFile = OpenTheFile(lpszFileName);
  
  if (hFile == INVALID_HANDLE_VALUE)
  {
    return;
  }

  // modify transfer menu
  hMenu = GetMenu(ghwndMain);
  MenuFlags = MF_DISABLED | MF_GRAYED;
  EnableMenuItem(hMenu,ID_TRANSFER_SENDFILETEXT,MenuFlags);
  EnableMenuItem(hMenu,ID_TRANSFER_SENDREPEATEDLY,MenuFlags);
  EnableMenuItem(hMenu,ID_TRANSFER_ABORTREPEATEDSENDING,MF_ENABLED);
  EnableMenuItem(hMenu,ID_TRANSFER_RECEIVEFILETEXT,MenuFlags);

  // enable abort button and progress bar
  SetWindowText(GetDlgItem(ghWndStatusDlg, IDC_ABORTBTN), "Abort Tx");
  ShowWindow(GetDlgItem(ghWndStatusDlg, IDC_ABORTBTN), SW_SHOW);

  if (!GetTransferSizes(hFile,&dwPacketSize,&dwMaxPackets,&dwFileSize)) 
  {
    TransferRepeatDestroy();
    return;
  }

  // Allocate a buffer
  lpBuf = (char*)HeapAlloc(ghWriterHeap,0,dwFileSize);

  if (lpBuf == NULL) 
  {
    ErrorReporter("HeapAlloc (data block from writer heap).\r\nFile is too large");
    TransferRepeatDestroy();
    return;
  }

  // fill the buffer
  if (!ReadFile(hFile,lpBuf,dwFileSize,&dwRead,NULL)) 
  {
    ErrorReporter("Can't read from file\n");
    TransferRepeatDestroy();
  }

  if (dwRead != dwFileSize)
  {
    ErrorReporter("Didn't read entire file\n");
  }
        
  mmTimer = timeSetEvent((UINT)dwFrequency,10,TransferRepeatDo,dwRead,TIME_PERIODIC);
    
  if (mmTimer == (MMRESULT) NULL) 
  {
    ErrorReporter("Could not create mm timer");
    TransferRepeatDestroy();
  }
  else 
  {
    REPEATING(TTYInfo) = TRUE;
    OutputDebugString("Timer setup.\n");
  }

  return;
}

void TransferRepeatDestroy()
{
  HMENU hMenu;
  DWORD MenuFlags;
  MMRESULT mmRes;

  if (mmTimer != (MMRESULT) NULL) 
  {
    mmRes = timeKillEvent(mmTimer);
    
    if (mmRes != TIMERR_NOERROR)
    {
      ErrorReporter("Can't kill mm timer");
    }
    
    mmTimer = (MMRESULT)NULL;
  }

  // close the file
  CloseHandle(hFile);

  // inform writer to abort all pending write requests
  if (!WriterAddFirstNodeTimeout(WRITE_ABORT,0,0,NULL,NULL,NULL,500))
  {
    ErrorReporter("Couldn't inform writer to abort sending.");
  }

  // free the buffer
  if (!HeapFree(ghWriterHeap, 0, lpBuf))
  {
    ErrorReporter("HeapFree (data block from writer heap)");
  }
    
  REPEATING(TTYInfo) = FALSE;
  OutputDebugString("Repeated transfer destroyed.\r\n");

  // enable transfer menu
  hMenu = GetMenu(ghwndMain);
  MenuFlags = MF_ENABLED;
  EnableMenuItem(hMenu,ID_TRANSFER_ABORTREPEATEDSENDING, MF_DISABLED | MF_GRAYED);
  EnableMenuItem(hMenu,ID_TRANSFER_SENDFILETEXT, MenuFlags);
  EnableMenuItem(hMenu,ID_TRANSFER_SENDREPEATEDLY, MenuFlags);
  EnableMenuItem(hMenu,ID_TRANSFER_RECEIVEFILETEXT, MenuFlags);

  ShowWindow(GetDlgItem(ghWndStatusDlg,IDC_ABORTBTN),SW_HIDE);
    
  return;
}

void CALLBACK TransferRepeatDo(UINT uTimerId,UINT uRes,DWORD dwFileSize,DWORD dwRes1,DWORD dwRes2)
{
  if (!WriterAddNewNodeTimeout(WRITE_BLOCK,dwFileSize,0,lpBuf,0,0,10))
  {
    PostMessage(ghwndMain,WM_COMMAND,ID_TRANSFER_ABORTSENDING,MAKELPARAM(IDC_ABORTBTN,0));
  }    
   
  return;
}

void TransferFileTextStart(LPCTSTR lpstrFileName)
{
  DWORD dwThreadId;
  HMENU hMenu;
  UINT  MenuFlags ;

  // open the file
  hFile = OpenTheFile(lpstrFileName);
  
  if (hFile == INVALID_HANDLE_VALUE)
  {
    return;
  }

  // modify transfer menu
  hMenu = GetMenu(ghwndMain);
  MenuFlags = MF_DISABLED | MF_GRAYED;
  EnableMenuItem(hMenu,ID_TRANSFER_SENDFILETEXT,MenuFlags);
  EnableMenuItem(hMenu,ID_TRANSFER_SENDREPEATEDLY,MenuFlags);
  EnableMenuItem(hMenu,ID_TRANSFER_ABORTSENDING,MF_ENABLED);
  EnableMenuItem(hMenu,ID_TRANSFER_RECEIVEFILETEXT,MenuFlags);
    
  // enable abort button and progress bar
  gfAbortTransfer = FALSE;
  SetWindowText(GetDlgItem(ghWndStatusDlg,IDC_ABORTBTN),"Abort Tx");
  ShowWindow(GetDlgItem(ghWndStatusDlg,IDC_ABORTBTN),SW_SHOW);
  ShowWindow(GetDlgItem(ghWndStatusDlg,IDC_TRANSFERPROGRESS),SW_SHOW);

  // start the transfer thread
  hTransferAbortEvent = CreateEvent(NULL,TRUE,FALSE,NULL);
    
  if (hTransferAbortEvent == NULL)
  {
    ErrorReporter("CreateEvent(Transfer Abort Event)");
  }

  hTransferThread = CreateThread(NULL,0,TransferThreadProc,(LPVOID)hFile,0,&dwThreadId);

  if (hTransferThread == NULL) 
  {
    ErrorReporter("CreateThread (Transfer Thread)");
    TransferFileTextEnd();
  }
  else
  {
    TRANSFERRING(TTYInfo) = TRUE;
  }

  return;
}

void TransferFileTextEnd()
{
  HMENU hMenu;
  UINT MenuFlags ;

  // stop the transfer thread
  SetEvent(hTransferAbortEvent);

  OutputDebugString("Waiting for transfer thread...\n");

  if (WaitForSingleObject(hTransferThread,3000) != WAIT_OBJECT_0) 
  {
    ErrorReporter("TransferThread didn't stop.");
    TerminateThread(hTransferThread, 0);
  }
  else
  {
    OutputDebugString("Transfer thread exited\n");
  }

  CloseHandle(hTransferAbortEvent);
  CloseHandle(hTransferThread);

  TRANSFERRING(TTYInfo) = FALSE;

  // enable transfer menu
  hMenu = GetMenu(ghwndMain);
  MenuFlags = MF_ENABLED;
  EnableMenuItem(hMenu,ID_TRANSFER_SENDFILETEXT,MenuFlags);
  EnableMenuItem(hMenu,ID_TRANSFER_SENDREPEATEDLY,MenuFlags);
  EnableMenuItem(hMenu,ID_TRANSFER_RECEIVEFILETEXT,MenuFlags);
  EnableMenuItem(hMenu,ID_TRANSFER_ABORTSENDING,MF_DISABLED | MF_GRAYED);
    
  // disable abort button and progress bar
  ShowWindow(GetDlgItem(ghWndStatusDlg,IDC_ABORTBTN),SW_HIDE);
  ShowWindow(GetDlgItem(ghWndStatusDlg,IDC_TRANSFERPROGRESS),SW_HIDE);

  // close the file
  CloseHandle(hFile);
}

void ReceiveFileText(LPCTSTR lpstrFileName,BOOL cooked)
{
  HMENU hMenu;
  UINT MenuFlags ;

  // create the file
  ghFileCapture = CreateTheFile(lpstrFileName);
  
  if (ghFileCapture == INVALID_HANDLE_VALUE)
  {
    return;
  }

  // setup transfer, disable file menu
  hMenu = GetMenu(ghwndMain);
  MenuFlags = MF_DISABLED | MF_GRAYED;
  EnableMenuItem(hMenu,ID_FILE_CONNECT,MenuFlags);
  EnableMenuItem(hMenu,ID_FILE_DISCONNECT,MenuFlags);
    
  // disable transfer menu
  EnableMenuItem(hMenu,ID_TRANSFER_SENDFILETEXT,MenuFlags);
  EnableMenuItem(hMenu,ID_TRANSFER_RECEIVEFILETEXT,MenuFlags);
  EnableMenuItem(hMenu,ID_TRANSFER_SENDREPEATEDLY,MenuFlags);

  // disable dBlackBoxPlus menu
  EnableMenuItem(hMenu,ID_BLACKBOX_DUMPRAW,MenuFlags);
  EnableMenuItem(hMenu,ID_BLACKBOX_DUMPCOOKED,MenuFlags);
  EnableMenuItem(hMenu,ID_BLACKBOX_STOPSCREENDUMP,MenuFlags);
  EnableMenuItem(hMenu,ID_BLACKBOX_CAPTURERAW,MenuFlags);
  EnableMenuItem(hMenu,ID_BLACKBOX_CAPTURECOOKED,MenuFlags);
    
  // enable abort button and progress bar
  gfAbortTransfer = FALSE;
  SetWindowText(GetDlgItem(ghWndStatusDlg,IDC_ABORTBTN),"Close Capture");
  ShowWindow(GetDlgItem(ghWndStatusDlg,IDC_ABORTBTN),SW_SHOW);
  ShowWindow(GetDlgItem(ghWndStatusDlg,IDC_TRANSFERPROGRESS),SW_SHOW);

  // send file until done or abort
  CaptureFile(ghFileCapture,GetDlgItem(ghWndStatusDlg,IDC_TRANSFERPROGRESS),cooked);

  // enable menu
  hMenu = GetMenu(ghwndMain);
  MenuFlags = MF_ENABLED;
  ChangeConnection(ghwndMain,CONNECTED(TTYInfo));
    
  // enable transfer menu
  EnableMenuItem(hMenu,ID_TRANSFER_SENDFILETEXT,MenuFlags);
  EnableMenuItem(hMenu,ID_TRANSFER_RECEIVEFILETEXT,MenuFlags);
  EnableMenuItem(hMenu,ID_TRANSFER_SENDREPEATEDLY,MenuFlags);

  // enable/disable dBlackBoxPlus menu
  EnableMenuItem(hMenu,ID_BLACKBOX_DUMPRAW,MF_DISABLED|MF_GRAYED);
  EnableMenuItem(hMenu,ID_BLACKBOX_DUMPCOOKED,MF_DISABLED|MF_GRAYED);
  EnableMenuItem(hMenu,ID_BLACKBOX_STOPSCREENDUMP,MenuFlags);
  EnableMenuItem(hMenu,ID_BLACKBOX_CAPTURERAW,MenuFlags);
  EnableMenuItem(hMenu,ID_BLACKBOX_CAPTURECOOKED,MenuFlags);

  // hide abort button and progress bar
  ShowWindow(GetDlgItem(ghWndStatusDlg,IDC_ABORTBTN),SW_HIDE);
  ShowWindow(GetDlgItem(ghWndStatusDlg,IDC_TRANSFERPROGRESS),SW_HIDE);
    
  gfAbortTransfer = FALSE;