CloseHandle(ghFileCapture);

  return; // returns when file transfer is complete or aborted
}

HANDLE OpenTheFile(LPCTSTR lpFName)
{
  HANDLE hTemp;

  hTemp = CreateFile(lpFName,GENERIC_READ,FILE_SHARE_READ,NULL,OPEN_EXISTING,0,NULL);

  if (hTemp == INVALID_HANDLE_VALUE)
  {
    ErrorReporter("CreateFile");
  }

  return hTemp;
}

HANDLE CreateTheFile(LPCTSTR lpFName)
{
  HANDLE hTemp;

  hTemp = CreateFile(lpFName,GENERIC_WRITE,0,NULL,CREATE_ALWAYS,0,NULL);

  if (hTemp == INVALID_HANDLE_VALUE)
  {
    ErrorReporter("CreateFile");
  }

  return hTemp;
}

BOOL GetTransferSizes(HANDLE hFile,DWORD* pdwDataPacketSize,DWORD* pdwNumPackets,DWORD* pdwFileSize)
{
  BY_HANDLE_FILE_INFORMATION fi;

  if (!GetFileInformationByHandle(hFile,&fi)) 
  {
    ErrorReporter("GetFileInformationByHandle");
    return FALSE;
  }
  else 
  {
    if (fi.nFileSizeHigh) 
    {
      MessageBox(ghwndMain,"File is too large to transfer.","File Transfer Error",MB_OK);
      return FALSE;
    }

    // setup packet size, file size and compute the number of packets
    *pdwDataPacketSize = MAX_WRITE_BUFFER;
    *pdwFileSize = fi.nFileSizeLow;
    *pdwNumPackets = *pdwFileSize / *pdwDataPacketSize;

    if (*pdwNumPackets > 65534) 
    {
      MessageBox(ghwndMain,"File is too large for buffer size.","File Transfer Error",MB_OK);
      return FALSE;
    }
  }

  return TRUE;
}

void ShowTransferStatistics(DWORD dwEnd,DWORD dwStart,DWORD dwBytesTransferred)
{
  char szTemp[100];
  DWORD dwSecs;

  dwSecs = (dwEnd - dwStart) / 1000;

  // display only if dwSecs != 0; if dwSecs == 0, then divide by zero occurs.
  if (dwSecs != 0) 
  {
    wsprintf(szTemp,"Bytes transferred: %d\r\nBytes/Second: %d\r\n",dwBytesTransferred,dwBytesTransferred / dwSecs);
    UpdateStatus(szTemp);
  }

  return;
}

UINT CheckForMessages()
{
  MSG msg;

  if (PeekMessage(&msg,NULL,0,0,PM_REMOVE)) 
  {
    if (msg.message == WM_CLOSE) 
    {
      PostMessage(ghwndMain,WM_CLOSE,0,0);
      return WM_CLOSE;
    }

    if (msg.message == WM_SYSCOMMAND && msg.wParam == SC_CLOSE) 
    {            
      PostMessage(ghwndMain,WM_CLOSE,0,0);
      return WM_CLOSE;
    }

    if (!TranslateAccelerator(ghwndMain,ghAccel,&msg)) 
    {
      TranslateMessage(&msg);
      DispatchMessage(&msg);
    }

    return TRUE ;
  }
    
  return FALSE ;
}

void CaptureFile(HANDLE hFile,HWND hWndProgress,BOOL cooked)
{
  UINT uMsgResult;
  
  if (cooked)
  {
    gdwReceiveState = RECEIVE_CAPTUREDBLACKBOXCOOKED;
  }
  else
  {
    gdwReceiveState = RECEIVE_CAPTURED;
  }

  while (!gfAbortTransfer) 
  {
    uMsgResult = CheckForMessages();

    // If WM_CLOSE is retrieved, then exit.
    // If no message is retrieved, then sleep a little.
    // If any other message is retrieved, check for another one.
    switch(uMsgResult)
    {
      case WM_CLOSE:  gfAbortTransfer = TRUE; break;
      case FALSE:     Sleep(200);             break;
      case TRUE:                              break;
    }
  }

  gdwReceiveState = RECEIVE_TTY;

  return;
}

DWORD WINAPI TransferThreadProc(LPVOID lpV)
{
  DWORD  dwPacketSize, dwMaxPackets, dwFileSize;
  DWORD  dwStartTime;
  HWND   hWndProgress;
  HANDLE hFileHandle;
  HANDLE hDataHeap;
  BOOL fStarted = TRUE;
  BOOL fAborting = FALSE;

  hFileHandle = (HANDLE) lpV;
  hWndProgress = GetDlgItem(ghWndStatusDlg,IDC_TRANSFERPROGRESS);

  // set up transfer metrics
  if (!GetTransferSizes(hFileHandle,&dwPacketSize,&dwMaxPackets,&dwFileSize))
  {
    fAborting = TRUE;
  }
  else 
  {
    SendMessage(hWndProgress,PBM_SETRANGE,0,MAKELPARAM(0,dwMaxPackets+1));
    SendMessage(hWndProgress,PBM_SETSTEP,(WPARAM)1,0);
    SendMessage(hWndProgress,PBM_SETPOS,0,0);
  }

  // set up transfer heaps
  if (!fAborting) 
  {
    SYSTEM_INFO sysInfo;
    GetSystemInfo(&sysInfo);
    hDataHeap = HeapCreate(0, sysInfo.dwPageSize * 2, sysInfo.dwPageSize * 10);
    
    if (hDataHeap == NULL) 
    {
      ErrorReporter("HeapCreate(Data Heap)");
      fAborting = TRUE;
    }
  }

  // inform writer thread that a file is about to be transferred
  if (!fAborting) 
  {
    if (!WriterAddNewNode(WRITE_FILESTART,dwFileSize,0,NULL,NULL,NULL))
    {
      fAborting = TRUE;
    }
  }

  OutputDebugString("Xfer: About to start sending data\n");

  // Get Transfer Start Time
  dwStartTime = GetTickCount();

  if (WaitForSingleObject(hTransferAbortEvent,0) == WAIT_OBJECT_0)
  {
    fAborting = TRUE;
  }

  while (!fAborting) 
  {
    char * lpDataBuf;
    PWRITEREQUEST pWrite;

    // transfer file, loop until all blocks of file have been read
    lpDataBuf = (char*)HeapAlloc(hDataHeap,0,dwPacketSize);
    pWrite = (WRITEREQUEST*)HeapAlloc(ghWriterHeap,0,sizeof(WRITEREQUEST));
    
    if ((lpDataBuf != NULL) && (pWrite != NULL)) 
    {
      DWORD dwRead;

      // read from file into new buffer
      if (ReadFile(hFileHandle,lpDataBuf,dwPacketSize,&dwRead,NULL)) 
      {
        WriterAddExistingNode(pWrite,WRITE_FILE,dwRead,0,lpDataBuf,hDataHeap,hWndProgress);

        if (dwRead != dwPacketSize) // eof
        {
          break;
        }
      }
    }
    else 
    {
      BOOL fRes;
      // Either the data heap is full, or the writer heap is full.
      // Free any allocated block, wait a little and try again.
      // Waiting lets the writer thread send some blocks and free
      // the data blocks from the data heap and the control
      // blocks from the writer heap.
      if (lpDataBuf) 
      {
        EnterCriticalSection(&gcsDataHeap);
        fRes = HeapFree(hDataHeap,0,lpDataBuf);
        LeaveCriticalSection(&gcsDataHeap);
        
        if (!fRes)
        {
          ErrorReporter("HeapFree(Data block)");
        }
      }

      if (pWrite) 
      {
        EnterCriticalSection(&gcsWriterHeap);
        fRes = HeapFree(ghWriterHeap,0,pWrite);
        LeaveCriticalSection(&gcsWriterHeap);
                
        if (!fRes)
        {
          ErrorReporter("HeapFree(Writer block)");
        }
      }

      OutputDebugString("Xfer: A heap is full.  Waiting...\n");

      // wait a little
      // check for abort during the wait
      if (WaitForSingleObject(hTransferAbortEvent,200) == WAIT_OBJECT_0)
      {
        fAborting = TRUE;
      }
    }

    // has the user aborted?
    if (WaitForSingleObject(hTransferAbortEvent,0) == WAIT_OBJECT_0)
    {
      fAborting = TRUE;
    }
  }

  OutputDebugString("Xfer: Done sending packets.\n");

  if (fAborting) 
  {
    // inform writer that transfer is aborting
    OutputDebugString("Xfer: Sending Abort Packet to writer\n");
    WriterAddFirstNodeTimeout(WRITE_ABORT,dwFileSize,0,NULL,NULL,NULL,500);
  }
  else
  {
    WriterAddNewNodeTimeout(WRITE_FILEEND,dwFileSize,0,NULL,NULL,NULL,500);
  }
        
  {
    // wait til writer thread finishes with all blocks
    HANDLE hEvents[2];
    DWORD dwRes;
    BOOL  fTransferComplete;
        
    hEvents[0] = ghTransferCompleteEvent;
    hEvents[1] = hTransferAbortEvent;

    OutputDebugString("Xfer: Waiting for transfer complete signal from writer\n");
      
    do 
    {
      ResetEvent(hTransferAbortEvent);

      dwRes = WaitForMultipleObjects(2, hEvents, FALSE, INFINITE);
        
      switch(dwRes) 
      {
        case WAIT_OBJECT_0:      
             fTransferComplete = TRUE;   
             OutputDebugString("Transfer complete signal rec'd\n");
             break;

        case WAIT_OBJECT_0 + 1:  
             fAborting = TRUE;           
             OutputDebugString("Transfer abort signal rec'd\n");
             OutputDebugString("Xfer: Sending Abort Packet to writer\n");
               
             if (!WriterAddFirstNodeTimeout(WRITE_ABORT,dwFileSize,0,NULL,NULL,NULL,500))
             {
               ErrorReporter("Can't add abort packet\n");
             } 
             break;

        case WAIT_TIMEOUT:  
             break;
            
        default:
             ErrorReporter("WaitForMultipleObjects(Transfer Complete Event and Transfer Abort Event)");
             fTransferComplete = TRUE;
             break;
      }
    } while (!fTransferComplete);
  }

  OutputDebugString("Xfer: transfer complete\n");

  // report statistics
  if (!fAborting)
  {
    ShowTransferStatistics(GetTickCount(),dwStartTime,dwFileSize);
  }

  // break down metrics
  PostMessage(hWndProgress,PBM_SETPOS,0,0);

  // break down heaps
  if (hDataHeap != NULL) 
  {
    if (!HeapDestroy(hDataHeap))
    {
      ErrorReporter("HeapDestroy(data heap)");
    }
  }

  // If I am done without user intervention, then post the
  // "abort" message myself.  This will cause the main thread to
  // clean up after the file transfer.
  if (!fAborting)
  {
    PostMessage(ghwndMain,WM_COMMAND,ID_TRANSFER_ABORTSENDING,0);
  }

  // exit thread
  return 0;
}

void OpenSettingsToolbar(HWND hWnd)
{
  ghWndToolbarDlg = CreateDialog(ghInst,MAKEINTRESOURCE(IDD_TOOLBARSETTINGS),hWnd,ToolbarProc);

  if (ghWndToolbarDlg == NULL)
  {
	  ErrorReporter("CreateDialog (Toolbar Dialog)");
  }

  return;
}

void ChangeConnection(HWND hwnd,BOOL fConnected)
{
  HMENU hMenu;
  int i;

  if (fConnected) 
  {
	  // The port is connected.  Need to :
	  //  Disable connect menu and enable disconnect menu.
	  //  Enable file transfer menu
	  //  Disable comm port selection box
	  //  Disable no writing, no reading, no events, no status check boxes
	  //  Enable status check boxes
	  //  Set focus to the child tty window
	  hMenu = GetMenu(hwnd);
	  EnableMenuItem(hMenu,ID_FILE_CONNECT,MF_GRAYED|MF_DISABLED|MF_BYCOMMAND);
	  EnableMenuItem(hMenu,ID_FILE_DISCONNECT,MF_ENABLED|MF_BYCOMMAND);
	  EnableMenuItem(hMenu,ID_TRANSFER_SENDFILETEXT,MF_ENABLED|MF_BYCOMMAND);
	  EnableMenuItem(hMenu,ID_TRANSFER_RECEIVEFILETEXT,MF_ENABLED|MF_BYCOMMAND);
	  EnableMenuItem(hMenu,ID_TRANSFER_SENDREPEATEDLY,MF_ENABLED|MF_BYCOMMAND);
	  EnableMenuItem(hMenu,ID_TRANSFER_ABORTSENDING,MF_DISABLED|MF_GRAYED|MF_BYCOMMAND);
	  EnableMenuItem(hMenu,ID_TRANSFER_ABORTREPEATEDSENDING,MF_DISABLED|MF_GRAYED|MF_BYCOMMAND);
	  EnableMenuItem(hMenu,ID_BLACKBOX_DUMPRAW,MF_DISABLED|MF_GRAYED|MF_BYCOMMAND);
	  EnableMenuItem(hMenu,ID_BLACKBOX_DUMPCOOKED,MF_DISABLED|MF_GRAYED|MF_BYCOMMAND);
	  EnableMenuItem(hMenu,ID_BLACKBOX_STOPSCREENDUMP,MF_ENABLED|MF_BYCOMMAND);
    EnableMenuItem(hMenu,ID_BLACKBOX_CAPTURERAW,MF_ENABLED|MF_BYCOMMAND);
    EnableMenuItem(hMenu,ID_BLACKBOX_CAPTURECOOKED,MF_ENABLED|MF_BYCOMMAND);

	  EnableWindow(GetDlgItem(ghWndToolbarDlg,IDC_PORTCOMBO),FALSE);
	  EnableWindow(GetDlgItem(ghWndToolbarDlg,IDC_NOWRITINGCHK),FALSE);
	  EnableWindow(GetDlgItem(ghWndToolbarDlg,IDC_NOREADINGCHK),FALSE);
	  EnableWindow(GetDlgItem(ghWndToolbarDlg,IDC_NOEVENTSCHK),FALSE);
	  EnableWindow(GetDlgItem(ghWndToolbarDlg,IDC_NOSTATUSCHK),FALSE);

	  for (i = IDC_STATCTS;i <= IDC_STATRLSD;i++)
    {
	    EnableWindow(GetDlgItem(ghWndStatusDlg,i),TRUE);
    }

	  for (i = IDC_CTSHOLDCHK;i <= IDC_RXCHAREDIT;i++)
    {
	    EnableWindow(GetDlgItem(ghWndStatusDlg,i),TRUE);
    }
    
	  SetFocus(ghWndTTY);
  }
  else 
  {
	  // Not connected, do opposite of above.
	  hMenu = GetMenu(hwnd);
	  EnableMenuItem(hMenu,ID_FILE_CONNECT,MF_ENABLED|MF_BYCOMMAND);
	  EnableMenuItem(hMenu,ID_FILE_DISCONNECT,MF_GRAYED|MF_DISABLED|MF_BYCOMMAND);

	  EnableMenuItem(hMenu,ID_TRANSFER_SENDFILETEXT,MF_DISABLED|MF_GRAYED|MF_BYCOMMAND);
	  EnableMenuItem(hMenu,ID_TRANSFER_RECEIVEFILETEXT,MF_DISABLED|MF_GRAYED|MF_BYCOMMAND);
	  EnableMenuItem(hMenu,ID_TRANSFER_SENDREPEATEDLY,MF_DISABLED|MF_GRAYED|MF_BYCOMMAND);
	  EnableMenuItem(hMenu,ID_TRANSFER_ABORTSENDING,MF_DISABLED|MF_GRAYED|MF_BYCOMMAND);
	  EnableMenuItem(hMenu,ID_TRANSFER_ABORTREPEATEDSENDING,MF_DISABLED|MF_GRAYED|MF_BYCOMMAND);
	  EnableMenuItem(hMenu,ID_BLACKBOX_DUMPRAW,MF_ENABLED|MF_BYCOMMAND);
	  EnableMenuItem(hMenu,ID_BLACKBOX_DUMPCOOKED,MF_ENABLED|MF_BYCOMMAND);
	  EnableMenuItem(hMenu,ID_BLACKBOX_STOPSCREENDUMP,MF_DISABLED|MF_GRAYED|MF_BYCOMMAND);
    EnableMenuItem(hMenu,ID_BLACKBOX_CAPTURERAW,MF_GRAYED|MF_DISABLED|MF_BYCOMMAND);
    EnableMenuItem(hMenu,ID_BLACKBOX_CAPTURECOOKED,MF_GRAYED|MF_DISABLED|MF_BYCOMMAND);

	  EnableWindow(GetDlgItem(ghWndToolbarDlg,IDC_PORTCOMBO),TRUE);
	  EnableWindow(GetDlgItem(ghWndToolbarDlg,IDC_NOWRITINGCHK),TRUE);
	  EnableWindow(GetDlgItem(ghWndToolbarDlg,IDC_NOREADINGCHK),TRUE);
	  EnableWindow(GetDlgItem(ghWndToolbarDlg,IDC_NOEVENTSCHK),TRUE);
	  EnableWindow(GetDlgItem(ghWndToolbarDlg,IDC_NOSTATUSCHK),TRUE);

	  for (i = IDC_STATCTS;i <= IDC_STATRLSD;i++) 
    {
	    CheckDlgButton(ghWndStatusDlg,i,0);
	    EnableWindow(GetDlgItem(ghWndStatusDlg,i),FALSE);
	  }

	  for (i = IDC_CTSHOLDCHK;i <= IDC_RXCHAREDIT;i++) 
    {
	    if (i != IDC_TXCHAREDIT && i != IDC_RXCHAREDIT)
      {
		    CheckDlgButton(ghWndStatusDlg,i,0);
      }
	    else
      {
		    SetDlgItemInt(ghWndStatusDlg,i,0,FALSE);
      }

	    EnableWindow( GetDlgItem(ghWndStatusDlg, i), FALSE);
	  }

	  SetFocus(ghwndMain);
  }

  return;
}

void UpdateTTYInfo()
{
  // update globals from dialog settings
  GetDlgItemText(ghWndToolbarDlg,IDC_PORTCOMBO,gszPort,sizeof(gszPort));