/*!
\class Win_QextSerialPort
\version 0.70 (pre-alpha)
\author Wayne Roth

A cross-platform serial port class.
This class encapsulates the Windows portion of QextSerialPort.  The user will be notified of 
errors and possible portability conflicts at run-time by default - this behavior can be turned 
off by defining _TTY_NOWARN_ (to turn off all warnings) or _TTY_NOWARN_PORT_ (to turn off 
portability warnings) in the project.  Note that defining _TTY_NOWARN_ also defines 
_TTY_NOWARN_PORT_.

\note 
On Windows NT/2000/XP this class uses Win32 serial port functions by default.  The user may 
select POSIX behavior under NT, 2000, or XP ONLY by defining _TTY_POSIX_ in the project. I can 
make no guarantees as to the quality of POSIX support under NT/2000 however.

*/

#include <stdio.h>
#include "win_qextserialport.h"

/*!
\fn Win_QextSerialPort::Win_QextSerialPort()
Default constructor.  Note that the name of the device used by a Win_QextSerialPort constructed 
with this constructor will be determined by #defined constants, or lack thereof - the default 
behavior is the same as _TTY_LINUX_.  Possible naming conventions and their associated constants 
are:

\verbatim

Constant         Used By         Naming Convention
----------       -------------   ------------------------
_TTY_WIN_        Windows         COM1, COM2
_TTY_IRIX_       SGI/IRIX        /dev/ttyf1, /dev/ttyf2
_TTY_HPUX_       HP-UX           /dev/tty1p0, /dev/tty2p0
_TTY_SUN_        SunOS/Solaris   /dev/ttya, /dev/ttyb
_TTY_DIGITAL_    Digital UNIX    /dev/tty01, /dev/tty02
_TTY_LINUX_      Linux           /dev/ttyS0, /dev/ttyS1
<none>           Linux           /dev/ttyS0, /dev/ttyS1
\endverbatim

This constructor associates the object with the first port on the system, e.g. COM1 for Windows 
platforms.  See the other constructor if you need a port other than the first.
*/
Win_QextSerialPort::Win_QextSerialPort():QextSerialBase() {}

/*!Win_QextSerialPort::Win_QextSerialPort(const Win_QextSerialPort&)
Copy constructor.
*/
Win_QextSerialPort::Win_QextSerialPort(const Win_QextSerialPort& s):QextSerialBase(s.portName) {
    portOpen=s.portOpen;
    lastErr=s.lastErr;
    memcpy(portName, s.portName, sizeof(portName));
    Settings.FlowControl=s.Settings.FlowControl;
    Settings.Parity=s.Settings.Parity;
    Settings.DataBits=s.Settings.DataBits;
    Settings.StopBits=s.Settings.StopBits;
    Settings.BaudRate=s.Settings.BaudRate;
    Win_Handle=s.Win_Handle;
	memcpy(&Win_CommConfig, &s.Win_CommConfig, sizeof(COMMCONFIG));
	memcpy(&Win_CommTimeouts, &s.Win_CommTimeouts, sizeof(COMMTIMEOUTS));
}

/*!
\fn Win_QextSerialPort::Win_QextSerialPort(const char* devName)
Constructs a serial port attached to the port specified by devName.
devName is the name of the device, which is windowsystem-specific, 
e.g."COM2" or "/dev/ttyS0".
*/
Win_QextSerialPort::Win_QextSerialPort(const char* name):QextSerialBase(name) {
    setTimeout(0, 500);
}

/*!
\fn Win_QextSerialPort::Win_QextSerialPort(const PortSettings& settings)
Constructs a port with default name and specified settings.
*/
Win_QextSerialPort::Win_QextSerialPort(const PortSettings& settings) {
    construct();
    setBaudRate(settings.BaudRate);
    setDataBits(settings.DataBits);
    setStopBits(settings.StopBits);
    setParity(settings.Parity);
    setFlowControl(settings.FlowControl);
    setTimeout(settings.Timeout_Sec, settings.Timeout_Millisec);
}

/*!
\fn Win_QextSerialPort::Win_QextSerialPort(const char* name, const PortSettings& settings)
Constructs a port with specified name and settings.
*/
Win_QextSerialPort::Win_QextSerialPort(const char* name, const PortSettings& settings) {
    construct();
    setName(name);
    setBaudRate(settings.BaudRate);
    setDataBits(settings.DataBits);
    setStopBits(settings.StopBits);
    setParity(settings.Parity);
    setFlowControl(settings.FlowControl);
    setTimeout(settings.Timeout_Sec, settings.Timeout_Millisec);
}

/*!
\fn Win_QextSerialPort::~Win_QextSerialPort() 
Standard destructor.
*/
Win_QextSerialPort::~Win_QextSerialPort() {
    if (portOpen) {
        close();
    }
}

/*!
\fn Win_QextSerialPort& operator=(const Win_QextSerialPort& s) 
overrides the = operator
*/
Win_QextSerialPort& Win_QextSerialPort::operator=(const Win_QextSerialPort& s) {
    portOpen=s.isOpen();
    lastErr=s.lastErr;
    memcpy(portName, s.portName, sizeof(portName));
    Settings.FlowControl=s.Settings.FlowControl;
    Settings.Parity=s.Settings.Parity;
    Settings.DataBits=s.Settings.DataBits;
    Settings.StopBits=s.Settings.StopBits;
    Settings.BaudRate=s.Settings.BaudRate;
    Win_Handle=s.Win_Handle;
	memcpy(&Win_CommConfig, &s.Win_CommConfig, sizeof(COMMCONFIG));
	memcpy(&Win_CommTimeouts, &s.Win_CommTimeouts, sizeof(COMMTIMEOUTS));
    return *this;
}

/*!
\fn Win_QextSerialPort::construct(void)
Common constructor function, called by all versions of Win_QextSerialPort::Win_QextSerialPort().
Sets up default port settings (115200 8N1 Hardware flow control where supported, otherwise no
flow control, and 500 ms timeout).
*/
void Win_QextSerialPort::construct(void) {
    QextSerialBase::construct();
    setBaudRate(BAUD115200);
    setDataBits(DATA_8);
    setStopBits(STOP_1);
    setParity(PAR_NONE);
    setFlowControl(FLOW_HARDWARE);
    Win_Handle=INVALID_HANDLE_VALUE;
}

/*!
\fn bool Win_QextSerialPort::open(int)
Opens a serial port.  Note that this function does not specify which device to open.  If you need
to open a device by name, see Win_QextSerialPort::open(const char*).  This function has no effect
if the port associated with the class is already open.  The port is also configured to the current
settings, as stored in the Settings structure.
*/
bool Win_QextSerialPort::open(int) {
    unsigned long confSize;
    LOCK_MUTEX();
    if (!portOpen) {

        /*open the port*/
        Win_Handle=CreateFileA(portName, GENERIC_READ|GENERIC_WRITE, 
                              FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
        if (Win_Handle!=INVALID_HANDLE_VALUE) {
            portOpen=true;

            /*configure port settings*/
            GetCommConfig(Win_Handle, &Win_CommConfig, &confSize);
            GetCommState(Win_Handle, &(Win_CommConfig.dcb));
            Win_CommConfig.dcb.fBinary=TRUE;
            Win_CommConfig.dcb.fInX=FALSE;
            Win_CommConfig.dcb.fOutX=FALSE;
	        Win_CommConfig.dcb.fAbortOnError=FALSE;
            Win_CommConfig.dcb.fNull=FALSE;

            /*half second timeout by default*/
	        setTimeout(Win_CommTimeouts.ReadTotalTimeoutConstant/1000, 
                       Win_CommTimeouts.ReadTotalTimeoutConstant%1000);

            /*set up parameters*/
            setBaudRate(Settings.BaudRate);
            setDataBits(Settings.DataBits);
            setStopBits(Settings.StopBits);                               
            setParity(Settings.Parity);
            setFlowControl(Settings.FlowControl);
        }
    }
    UNLOCK_MUTEX();
    return portOpen;
}

/*!
\fn void Win_QextSerialPort::close()
Closes a serial port.  This function has no effect if the serial port associated with the class
is not currently open.
*/
void Win_QextSerialPort::close() {
    LOCK_MUTEX();
    CloseHandle(Win_Handle);
    portOpen=false;
    UNLOCK_MUTEX();
}

/*!
\fn void Win_QextSerialPort::flush()
Flushes all pending I/O to the serial port.  This function has no effect if the serial port
associated with the class is not currently open.
*/
void Win_QextSerialPort::flush() {
    LOCK_MUTEX();
    if (portOpen) {
        FlushFileBuffers(Win_Handle);
    }
    UNLOCK_MUTEX();
}

/*!
\fn Offset Win_QextSerialPort::size() const
This function will return the number of bytes waiting in the receive queue of the serial port.
It is included primarily to provide a complete QIODevice interface, and will not record errors
in the lastErr member (because it is const).  This function is also not thread-safe - in 
multithreading situations, use Win_QextSerialPort::bytesWaiting() instead.
*/
Offset Win_QextSerialPort::size() const {
    int availBytes;
    COMSTAT Win_ComStat;
    DWORD Win_ErrorMask=0;
    ClearCommError(Win_Handle, &Win_ErrorMask, &Win_ComStat);
    availBytes = Win_ComStat.cbInQue;
    return (Offset)availBytes;
}

/*!
\fn int Win_QextSerialPort::bytesWaiting()
Returns the number of bytes waiting in the port's receive queue.  This function will return 0 if
the port is not currently open, or -1 on error.  Error information can be retrieved by calling 
Win_QextSerialPort::getLastError().
*/
int Win_QextSerialPort::bytesWaiting() {
    LOCK_MUTEX();
    if (portOpen) {
        DWORD Errors;
        COMSTAT Status;
        BOOL success=ClearCommError(Win_Handle, &Errors, &Status);
        translateError(Errors);
        if (success) {
            lastErr=E_NO_ERROR;
            UNLOCK_MUTEX();
            return Status.cbInQue;
        }
        UNLOCK_MUTEX();
        return (unsigned int)-1;
    }
    UNLOCK_MUTEX();
    return 0;
}

/*!
\fn void Win_QextSerialPort::translateError(unsigned long error)
Translates a system-specific error code to a QextSerialPort error code.  Used internally.
*/
void Win_QextSerialPort::translateError(unsigned long error) {
    if (error&CE_BREAK) {
        lastErr=E_BREAK_CONDITION;
    }
    else if (error&CE_FRAME) {
        lastErr=E_FRAMING_ERROR;
    }
    else if (error&CE_IOE) {
        lastErr=E_IO_ERROR;
    }
    else if (error&CE_MODE) {
        lastErr=E_INVALID_FD;
    }
    else if (error&CE_OVERRUN) {
        lastErr=E_BUFFER_OVERRUN;
    }
    else if (error&CE_RXPARITY) {
        lastErr=E_RECEIVE_PARITY_ERROR;
    }
    else if (error&CE_RXOVER) {
        lastErr=E_RECEIVE_OVERFLOW;
    }
    else if (error&CE_TXFULL) {
        lastErr=E_TRANSMIT_OVERFLOW;
    }
}
            
/*!
\fn Q_LONG Win_QextSerialPort::readBlock(char *data, uint maxlen)
Reads a block of data from the serial port.  This function will read at most maxlen bytes from
the serial port and place them in the buffer pointed to by data.  Return value is the number of 
bytes actually read, or -1 on error.  This function will have no effect if the serial port 
associated with the class is not currently open.
*/
Q_LONG Win_QextSerialPort::readBlock(char *data, 
#ifdef QTVER_PRE_30                                     
                                     uint maxlen) 
#else
                                     unsigned long maxlen)
#endif
{
    LOCK_MUTEX();
    int retVal=0;
    if (portOpen) {
        COMSTAT Win_ComStat;
        DWORD Win_BytesRead=0;
        DWORD Win_ErrorMask=0;
        ClearCommError(Win_Handle, &Win_ErrorMask, &Win_ComStat);
        if (Win_ComStat.cbInQue && 
            (!ReadFile(Win_Handle, (void*)data, (DWORD)maxlen, &Win_BytesRead, NULL)
            || Win_BytesRead==0)) {
            lastErr=E_READ_FAILED;
            retVal=-1;
        }
        else {
            retVal=((int)Win_BytesRead);