serialui.h File Reference

#include <stdarg.h>
#include <windef.h>
#include <winbase.h>
#include <winuser.h>
#include <winnls.h>
#include "resource.h"

Include dependency graph for serialui.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_DIALOG_INFO
struct	_PARITY_INFO
struct	_STOPBIT_INFO

Macros
#define	WIN32_NO_STATUS
#define	_INC_WINDOWS
#define	COM_NO_WINDOWS_H
#define	UNIMPLEMENTED    return ERROR_CALL_NOT_IMPLEMENTED ;
#define	DEFAULT_BAUD_INDEX   6
#define	DEFAULT_BYTESIZE_INDEX   3
#define	DEFAULT_PARITY_INDEX   2
#define	DEFAULT_STOPBITS_INDEX   0

Typedefs
typedef struct _DIALOG_INFO	DIALOG_INFO
typedef struct _DIALOG_INFO *	LPDIALOG_INFO
typedef struct _PARITY_INFO	PARITY_INFO
typedef struct _PARITY_INFO *	PPARITY_INFO
typedef struct _STOPBIT_INFO	STOPBIT_INFO
typedef struct _STOPBIT_INFO *	PSTOPBIT_INFO

Functions
DWORD WINAPI	drvCommConfigDialogW (LPCWSTR lpszDevice, HWND hWnd, LPCOMMCONFIG lpCommConfig)
DWORD WINAPI	drvCommConfigDialogA (LPCSTR lpszDevice, HWND hWnd, LPCOMMCONFIG lpCommConfig)
DWORD WINAPI	drvSetDefaultCommConfigW (LPCWSTR lpszDevice, LPCOMMCONFIG lpCommConfig, DWORD dwSize)
DWORD WINAPI	drvSetDefaultCommConfigA (LPCSTR lpszDevice, LPCOMMCONFIG lpCommConfig, DWORD dwSize)
DWORD WINAPI	drvGetDefaultCommConfigW (LPCWSTR lpszDevice, LPCOMMCONFIG lpCommConfig, LPDWORD lpdwSize)
DWORD WINAPI	drvGetDefaultCommConfigA (LPCSTR lpszDevice, LPCOMMCONFIG lpCommConfig, LPDWORD lpdwSize)
INT_PTR CALLBACK	CommDlgProc (HWND hDlg, UINT Msg, WPARAM wParam, LPARAM lParam)
VOID	OkButton (HWND hDlg)

Macro Definition Documentation

_INC_WINDOWS

#define _INC_WINDOWS

Definition at line 10 of file serialui.h.

COM_NO_WINDOWS_H

#define COM_NO_WINDOWS_H

Definition at line 11 of file serialui.h.

DEFAULT_BAUD_INDEX

#define DEFAULT_BAUD_INDEX   6

Definition at line 23 of file serialui.h.

DEFAULT_BYTESIZE_INDEX

#define DEFAULT_BYTESIZE_INDEX   3

Definition at line 24 of file serialui.h.

DEFAULT_PARITY_INDEX

#define DEFAULT_PARITY_INDEX   2

Definition at line 25 of file serialui.h.

DEFAULT_STOPBITS_INDEX

#define DEFAULT_STOPBITS_INDEX   0

Definition at line 26 of file serialui.h.

UNIMPLEMENTED

#define UNIMPLEMENTED    return ERROR_CALL_NOT_IMPLEMENTED ;

Definition at line 20 of file serialui.h.

WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 9 of file serialui.h.

Typedef Documentation

DIALOG_INFO

typedef struct _DIALOG_INFO DIALOG_INFO

LPDIALOG_INFO

typedef struct _DIALOG_INFO * LPDIALOG_INFO

PARITY_INFO

typedef struct _PARITY_INFO PARITY_INFO

PPARITY_INFO

typedef struct _PARITY_INFO * PPARITY_INFO

PSTOPBIT_INFO

typedef struct _STOPBIT_INFO * PSTOPBIT_INFO

STOPBIT_INFO

typedef struct _STOPBIT_INFO STOPBIT_INFO

Function Documentation

CommDlgProc()

INT_PTR CALLBACK CommDlgProc	(	HWND	hDlg,
		UINT	Msg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 191 of file serialui.c.

{
    LPDIALOG_INFO lpDlgInfo = NULL;
    HWND hBox;
 
    switch (Msg)
    {
 
        case WM_INITDIALOG:
        {
            WCHAR wstr[255];
            RECT rc, rcDlg, rcOwner;
            HWND hOwner;
            INT i;
 
            lpDlgInfo = (LPDIALOG_INFO)lParam;
            SetWindowLongPtrW(hDlg, DWLP_USER, (LONG_PTR)lpDlgInfo);
 
            /* Set title */
            if(LoadStringW(hDllInstance, IDS_TITLE, wstr, sizeof(wstr) / sizeof(wstr[0])))
            {
                    SetWindowTextW(hDlg, wstr);
            }
 
                        /* FIXME - this won't work correctly systems with multiple monitors! */
                        if(!(hOwner = GetParent(hDlg)))
                hOwner = GetDesktopWindow();
 
            /* Position dialog in the center of owner window */
            GetWindowRect(hOwner, &rcOwner);
            GetWindowRect(hDlg, &rcDlg);
            CopyRect(&rc, &rcOwner);
            OffsetRect(&rcDlg, -rcDlg.left, -rcDlg.top);
            OffsetRect(&rc, -rc.left, -rc.top);
            OffsetRect(&rc, -rcDlg.right, -rcDlg.bottom);
            SetWindowPos(hDlg, HWND_TOP,
                rcOwner.left + (rc.right / 2),
                rcOwner.top + (rc.bottom / 2),
                0, 0, SWP_NOSIZE);
 
            /* Initialize baud rate combo */
            if(!(hBox = GetDlgItem(hDlg, IDC_BAUDRATE)))
                EndDialog(hDlg, ERROR_CANCELLED);
 
            for(i = 0; Bauds[i]; i++)
            {
                                wsprintf(wstr, L"%d", Bauds[i]);
                                SendMessageW(hBox, CB_INSERTSTRING, (WPARAM)i, (LPARAM)wstr);
                if(Bauds[i] == lpDlgInfo->lpCC->dcb.BaudRate)
                    SendMessageW(hBox, CB_SETCURSEL, (WPARAM)i, 0);
            }
 
            if(SendMessageW(hBox, CB_GETCURSEL, 0, 0) == CB_ERR)
                SendMessageW(hBox, CB_SETCURSEL, DEFAULT_BAUD_INDEX, 0);
 
            /* Initialize byte size combo */
            if(!(hBox = GetDlgItem(hDlg, IDC_BYTESIZE)))
                EndDialog(hDlg, ERROR_CANCELLED);
 
            for(i = 0; ByteSizes[i]; i++)
            {
                                wsprintf(wstr, L"%d", Bauds[i]);
                                SendMessageW(hBox, CB_INSERTSTRING, (WPARAM)i, (LPARAM)wstr);
                if(ByteSizes[i] == lpDlgInfo->lpCC->dcb.ByteSize)
                    SendMessageW(hBox, CB_SETCURSEL, (WPARAM)i, 0);
            }
 
            if(SendMessageW(hBox, CB_GETCURSEL, 0, 0) == CB_ERR)
                SendMessageW(hBox, CB_SETCURSEL, DEFAULT_BYTESIZE_INDEX, 0);
 
            /* Initialize parity combo */
            if(!(hBox = GetDlgItem(hDlg, IDC_PARITY)))
                EndDialog(hDlg, ERROR_CANCELLED);
 
            for(i = 0; Parities[i].StrId; i++)
            {
                if(LoadStringW(hDllInstance, Parities[i].StrId, wstr, sizeof(wstr) / sizeof(wstr[0])))
                {
                    SendMessageW(hBox, CB_INSERTSTRING, (WPARAM)i, (LPARAM)wstr);
                    if(Parities[i].Parity == lpDlgInfo->lpCC->dcb.Parity)
                        SendMessageW(hBox, CB_SETCURSEL, (WPARAM)i, 0);
                }
            }
 
            if(SendMessageW(hBox, CB_GETCURSEL, 0, 0)==CB_ERR)
                SendMessageW(hBox, CB_SETCURSEL, DEFAULT_PARITY_INDEX, 0);
 
            /* Initialize stop bits combo */
            if(!(hBox = GetDlgItem(hDlg, IDC_STOPBITS)))
                EndDialog(hDlg, ERROR_CANCELLED);
 
            for(i = 0; StopBits[i].StrId; i++)
            {
                if(LoadStringW(hDllInstance, StopBits[i].StrId, wstr, sizeof(wstr) / sizeof(wstr[0])))
                {
                    SendMessageW(hBox, CB_INSERTSTRING, (WPARAM)i, (LPARAM)wstr);
                    if(StopBits[i].StopBit == lpDlgInfo->lpCC->dcb.StopBits)
                        SendMessageW(hBox, CB_SETCURSEL, (WPARAM)i, 0);
                }
            }
 
            if(SendMessageW(hBox, CB_GETCURSEL, 0, 0)==CB_ERR)
                SendMessageW(hBox, CB_SETCURSEL, DEFAULT_STOPBITS_INDEX, 0);
 
            /* Initialize flow control combo */
            if(!(hBox = GetDlgItem(hDlg, IDC_FLOW)))
                EndDialog(hDlg, ERROR_CANCELLED);
 
            if(LoadStringW(hDllInstance, IDS_FC_NO, wstr, sizeof(wstr) / sizeof(wstr[0])))
            {
                SendMessageW(hBox, CB_INSERTSTRING, 0, (LPARAM)wstr);
                SendMessageW(hBox, CB_SETCURSEL, 0, 0);
                lpDlgInfo->InitialFlowIndex = 0;
            }
 
 
            if(LoadStringW(hDllInstance, IDS_FC_CTSRTS, wstr, sizeof(wstr) / sizeof(wstr[0])))
            {
                SendMessageW(hBox, CB_INSERTSTRING, 1, (LPARAM)wstr);
                if(lpDlgInfo->lpCC->dcb.fRtsControl == RTS_CONTROL_HANDSHAKE
                    || lpDlgInfo->lpCC->dcb.fOutxCtsFlow != FALSE)
                {
                    SendMessageW(hBox, CB_SETCURSEL, 1, 0);
                    lpDlgInfo->InitialFlowIndex = 1;
                }
            }
 
            if(LoadStringW(hDllInstance, IDS_FC_XONXOFF, wstr, sizeof(wstr) / sizeof(wstr[0])))
            {
                SendMessageW(hBox, CB_INSERTSTRING, 2, (LPARAM)wstr);
                if(lpDlgInfo->lpCC->dcb.fOutX || lpDlgInfo->lpCC->dcb.fInX)
                {
                    SendMessageW(hBox, CB_SETCURSEL, 2, 0);
                    lpDlgInfo->InitialFlowIndex = 2;
                }
            }
 
            /* Set focus */
            SetFocus(GetDlgItem(hDlg, IDC_OKBTN));
 
            return FALSE;
        } /* WM_INITDIALOG */
 
        case WM_COMMAND:
        {
            switch(wParam)
            {
                case IDC_CANCELBTN:
                    EndDialog(hDlg, ERROR_CANCELLED);
                    break;
                case IDC_OKBTN:
                    OkButton(hDlg);
                    EndDialog(hDlg, ERROR_SUCCESS);
                    break;
            }
            return TRUE;
        } /* WM_COMMAND */
 
        case WM_CLOSE:
        {
            EndDialog(hDlg, ERROR_CANCELLED);
            return TRUE;
        } /* WM_CLOSE */
 
        default:
            return FALSE;
    }
 
}

Referenced by drvCommConfigDialogW().

drvCommConfigDialogA()

DWORD WINAPI drvCommConfigDialogA	(	LPCSTR	lpszDevice,
		HWND	hWnd,
		LPCOMMCONFIG	lpCommConfig
	)

Definition at line 122 of file serialui.c.

{
    BOOL result;
    UINT len;
    WCHAR *wstr;
 
    len = MultiByteToWideChar(CP_ACP, 0, lpszDevice, -1, NULL, 0);
    if((wstr = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR))))
    {
        MultiByteToWideChar(CP_ACP, 0, lpszDevice, -1, wstr, len);
        result = drvCommConfigDialogW(wstr, hWnd, lpCommConfig);
        HeapFree(GetProcessHeap(), 0, wstr);
        return result;
    }
    else
        return ERROR_NOT_ENOUGH_MEMORY;
}

drvCommConfigDialogW()

DWORD WINAPI drvCommConfigDialogW	(	LPCWSTR	lpszDevice,
		HWND	hWnd,
		LPCOMMCONFIG	lpCommConfig
	)

Definition at line 101 of file serialui.c.

{
    DIALOG_INFO DialogInfo;
 
    if(!lpszDevice || !lpCommConfig)
    {
        return ERROR_INVALID_PARAMETER;
    }
 
    DialogInfo.lpszDevice = lpszDevice;
    DialogInfo.lpCC = lpCommConfig;
 
    return DialogBoxParamW(hDllInstance, MAKEINTRESOURCEW(IDD_COMMDLG),
                    hWnd, CommDlgProc, (LPARAM)&DialogInfo);
}

Referenced by drvCommConfigDialogA().

drvGetDefaultCommConfigA()

DWORD WINAPI drvGetDefaultCommConfigA	(	LPCSTR	lpszDevice,
		LPCOMMCONFIG	lpCommConfig,
		LPDWORD	lpdwSize
	)

Definition at line 175 of file serialui.c.

{
    UNIMPLEMENTED
}

drvGetDefaultCommConfigW()

DWORD WINAPI drvGetDefaultCommConfigW	(	LPCWSTR	lpszDevice,
		LPCOMMCONFIG	lpCommConfig,
		LPDWORD	lpdwSize
	)

Definition at line 165 of file serialui.c.

{
    UNIMPLEMENTED
}

drvSetDefaultCommConfigA()

DWORD WINAPI drvSetDefaultCommConfigA	(	LPCSTR	lpszDevice,
		LPCOMMCONFIG	lpCommConfig,
		DWORD	dwSize
	)

Definition at line 155 of file serialui.c.

{
    UNIMPLEMENTED
}

drvSetDefaultCommConfigW()

DWORD WINAPI drvSetDefaultCommConfigW	(	LPCWSTR	lpszDevice,
		LPCOMMCONFIG	lpCommConfig,
		DWORD	dwSize
	)

Definition at line 145 of file serialui.c.

{
    UNIMPLEMENTED
}

OkButton()

VOID OkButton

(

HWND

hDlg

)

Definition at line 362 of file serialui.c.

{
    LPDIALOG_INFO lpDlgInfo;
    UINT Index;
 
    lpDlgInfo = (LPDIALOG_INFO) GetWindowLongPtrW(hDlg, DWLP_USER);
 
    /* Baud rate */
    Index = SendMessageW(GetDlgItem(hDlg, IDC_BAUDRATE), CB_GETCURSEL, 0, 0);
    lpDlgInfo->lpCC->dcb.BaudRate = Bauds[Index];
 
    /* Byte size */
    Index = SendMessageW(GetDlgItem(hDlg, IDC_BYTESIZE), CB_GETCURSEL, 0, 0);
    lpDlgInfo->lpCC->dcb.ByteSize = ByteSizes[Index];
 
    /* Parity */
    Index = SendMessageW(GetDlgItem(hDlg, IDC_PARITY), CB_GETCURSEL, 0, 0);
    lpDlgInfo->lpCC->dcb.Parity = Parities[Index].Parity;
 
    /* Stop bits */
    Index = SendMessageW(GetDlgItem(hDlg, IDC_STOPBITS), CB_GETCURSEL, 0, 0);
    lpDlgInfo->lpCC->dcb.StopBits = StopBits[Index].StopBit;
 
    /* Flow Control */
    Index = SendMessageW(GetDlgItem(hDlg, IDC_FLOW), CB_GETCURSEL, 0, 0);
    if(lpDlgInfo->InitialFlowIndex != Index)
    {
        switch(Index)
        {
            case 0: /* NO */
                lpDlgInfo->lpCC->dcb.fDtrControl = DTR_CONTROL_DISABLE;
                lpDlgInfo->lpCC->dcb.fRtsControl = RTS_CONTROL_DISABLE;
                lpDlgInfo->lpCC->dcb.fOutxCtsFlow = FALSE;
                lpDlgInfo->lpCC->dcb.fOutxDsrFlow = FALSE;
                lpDlgInfo->lpCC->dcb.fOutX = FALSE;
                lpDlgInfo->lpCC->dcb.fInX = FALSE;
                break;
            case 1: /* CTS/RTS */
                lpDlgInfo->lpCC->dcb.fDtrControl = DTR_CONTROL_DISABLE;
                lpDlgInfo->lpCC->dcb.fRtsControl = RTS_CONTROL_HANDSHAKE;
                lpDlgInfo->lpCC->dcb.fOutxCtsFlow = TRUE;
                lpDlgInfo->lpCC->dcb.fOutxDsrFlow = FALSE;
                lpDlgInfo->lpCC->dcb.fOutX = FALSE;
                lpDlgInfo->lpCC->dcb.fInX = FALSE;
                break;
            case 2: /* XON/XOFF */
                lpDlgInfo->lpCC->dcb.fDtrControl = DTR_CONTROL_DISABLE;
                lpDlgInfo->lpCC->dcb.fRtsControl = RTS_CONTROL_DISABLE;
                lpDlgInfo->lpCC->dcb.fOutxCtsFlow = FALSE;
                lpDlgInfo->lpCC->dcb.fOutxDsrFlow = FALSE;
                lpDlgInfo->lpCC->dcb.fOutX = TRUE;
                lpDlgInfo->lpCC->dcb.fInX = TRUE;
                break;
        }
    }
}

Referenced by CommDlgProc().