// tstmodemDlg.cpp : implementation file
//

// todo:
//		- state needs to be visible with checked menu entries.
//		- output window needs to be better formatted
//		- input edit should always get the focus.
//		- comioctl check needs to be reset when changing ports.

// todo:
//     create listbox which supports different classes of text:
//     'red' for received
//     'blue' for transmitted
//     'black' for local messages
// also, optionally timing delays should be displayed.
// and possibly non-ascii data in <small>hex</small>
// also add option to enable/disable display of specific classes.

#include "stdafx.h"
#include "tstmodem.h"
#include "tstmodemDlg.h"
#include "bitbutton.h"

#include "serialport.h"
#include "kernelState.h"
#include "RILState.h"
#include "serialparams.h"
#include "bitcontroller.h"

#include "debug.h"
#include "stringutils.h"
#include "boost_lite.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

#if 0
	char *initstrings[]= {
		"Z",
		"E1Q0V1",
		"&C1&D2S0=0S3=13S4=10",
		"S5=8S7=45S8=2S10=14",
		"TX4+CRC=1;+CMEE=1;+CR=1;+CSCS=\"GSM\"",
		"+CMGF=0;+CSCB=1,\"\",\"\";+CBST=71,0,1",
		"+CLIP=1;+FCLASS=0",
		"+GMI",
		"+GMM",
		"+GMR",
		"+GSN",
		"+CGMI",
		"+CGMM",
		"+CGMR",
		"+CGSN",
		"+CPMS=\"SM\",\"SM\",\"SM\"",
		"+CNMI=1,1,2,2,1;+CRLP=61,61,78,6",
		"+CREG=1;+COPS=3,2;^SCKS=1;+CSSN=1,1",
		"+CPBS=\"SM\";^SMGO=1;+CEER",
		NULL
	};
#endif
const char *g_initstrings[]= {
    "Z",
    "E0Q0V1",
    "&C1S0=0S2=43S3=13S4=10",
    "S5=8S7=45S8=2S10=14",
    "&D2+CRC=1;+CMEE=1;+CR=1;+CSCS=\"GSM\"",
    "+CMGF=0;+CLIP=1",
    "+FCLASS=0",
    "+GMI",
    "+GMM",
    "+GMR",
    "",
    "+CGMI",
    "+CGMM",
    "+CGMR",
    "+CGSN",
    "TX4S6=3S11=90+CPMS=\"BM\",\"SM\",\"BM\"",
    "+CNMI=2,1,0,0,0",
    "+CRLP=120,120,48,6",
    "+CREG=1;+COPS=3,2;+IPR=19200;+CMOD=0",
    NULL
};

void ConvertHexToBytes(CString& hexstr, CString& newstr);
void ConvertBytesToHex(CString& str, CString& hexstr);

/////////////////////////////////////////////////////////////////////////////
// CTstmodemDlg dialog

CTstmodemDlg::CTstmodemDlg(CWnd* pParent /*=NULL*/)
	: CDialog(CTstmodemDlg::IDD, pParent)
{
	//{{AFX_DATA_INIT(CTstmodemDlg)
	//}}AFX_DATA_INIT
	// Note that LoadIcon does not require a subsequent DestroyIcon in Win32

	m_bUpdateBits= false;

	m_kernel= NULL;
	m_ril= NULL;
	m_gpio_bits= NULL;
	m_a400_bits= NULL;
}

void CTstmodemDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CTstmodemDlg)
	DDX_Control(pDX, IDC_CHECK_RTSCTS_FLOWCTL, m_cCheckRtsCtsFlowControl);
	DDX_Control(pDX, IDC_CHECK_DOBITS, m_cCheckDoBits);
	DDX_Control(pDX, IDC_CHECK_OPENDEVICE, m_cCheckOpenDevice);
	DDX_Control(pDX, IDC_CHECK_COM_IOCTL, m_cCheckComIoctl);
	DDX_Control(pDX, IDC_CHECK_DEBUG_IN_OUTPUT, m_cCheckDebugInOutput);
	DDX_Control(pDX, IDC_CHECK_KERNEL_03C8, m_cCheckKernel03c8);
	DDX_Control(pDX, IDC_STATUS_XMIT, m_cStatusTransmit);
	DDX_Control(pDX, IDC_STATUS_RCV, m_cStatusReceive);
	DDX_Control(pDX, IDC_COUNTER_XMIT, m_cCounterTransmit);
	DDX_Control(pDX, IDC_COUNTER_RLSD, m_cCounterRLSD);
	DDX_Control(pDX, IDC_COUNTER_ERR, m_cCounterERR);
	DDX_Control(pDX, IDC_COUNTER_RING, m_cCounterRing);
	DDX_Control(pDX, IDC_COUNTER_RCV, m_cCounterReceive);
	DDX_Control(pDX, IDC_COUNTER_DSR, m_cCounterDSR);
	DDX_Control(pDX, IDC_COUNTER_CTS, m_cCounterCTS);
	DDX_Control(pDX, IDC_COUNTER_BRK, m_cCounterBreak);
	DDX_Control(pDX, IDC_CHECK_GSMRESET, m_cCheckGsmReset);
	DDX_Control(pDX, IDC_CHECK_CLEARSCREEN, m_cCheckClearScreen);
	DDX_Control(pDX, IDC_CHECK_GSM_MODE, m_cCheckGsmMode);
	DDX_Control(pDX, IDC_RECEIVE_DATA, m_cListReceiveData);
	DDX_Control(pDX, IDC_CHECK_ENABLE_RIL, m_cCheckEnableRil);
	DDX_Control(pDX, IDC_CHECK_IR, m_cCheckIR);
	DDX_Control(pDX, IDC_TRANSMIT_DATA, m_cEditTransmitData);
	DDX_Control(pDX, IDC_CHECK_HEX, m_cCheckHexData);
	DDX_Control(pDX, IDC_CHECK_CR, m_cCheckAddCR);
	DDX_Control(pDX, IDC_CHECK_LF, m_cCheckAddLF);
	DDX_Control(pDX, IDC_STATUS_RLSD, m_cStatusRLSD);
	DDX_Control(pDX, IDC_STATUS_ERR, m_cStatusERR);
	DDX_Control(pDX, IDC_STATUS_RING, m_cStatusRing);
	DDX_Control(pDX, IDC_STATUS_BRK, m_cStatusBreak);
	DDX_Control(pDX, IDC_STATUS_DSR, m_cStatusDSR);
	DDX_Control(pDX, IDC_STATUS_CTS, m_cStatusCTS);
	DDX_Control(pDX, IDC_CHECK_RTS, m_cCheckRTS);
	DDX_Control(pDX, IDC_CHECK_DTR, m_cCheckDTR);
	DDX_Control(pDX, IDC_CHECK_BRK, m_cCheckBreak);
	//}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CTstmodemDlg, CDialog)
	//{{AFX_MSG_MAP(CTstmodemDlg)
	ON_BN_CLICKED(IDC_CHECK_DTR, OnCheckDtr)
	ON_BN_CLICKED(IDC_CHECK_RTS, OnCheckRts)
	ON_BN_CLICKED(IDC_CHECK_BRK, OnCheckBrk)
	ON_BN_CLICKED(IDC_BUTTON_TRANSMIT, OnButtonTransmit)
	ON_BN_CLICKED(IDC_CHECK_IR, OnCheckIr)
	ON_BN_CLICKED(IDC_CHECK_HEX, OnCheckHex)
	ON_WM_CLOSE()
	ON_BN_CLICKED(IDC_CHECK_ENABLE_RIL, OnCheckEnableRil)
	ON_BN_CLICKED(IDC_CHECK_GSMRESET, OnCheckGsmreset)
	ON_BN_CLICKED(IDC_CHECK_CLEARSCREEN, OnCheckClearScreen)
	ON_BN_CLICKED(IDC_CHECK_GSM_MODE, OnCheckGsmMode)
	ON_BN_CLICKED(IDC_CHECK_KERNEL_03C8, OnCheckKernel03c8)
	ON_BN_CLICKED(IDC_CHECK_DEBUG_IN_OUTPUT, OnCheckDebugInOutput)
	ON_BN_CLICKED(IDC_CHECK_COM_IOCTL, OnCheckComIoctl)
	ON_BN_CLICKED(IDC_CHECK_OPENDEVICE, OnCheckOpendevice)
	ON_WM_TIMER()
	ON_BN_CLICKED(IDC_CHECK_DOBITS, OnCheckDobits)
	ON_BN_CLICKED(IDC_CHECK_RTSCTS_FLOWCTL, OnCheckRtsctsFlowctl)
	//}}AFX_MSG_MAP
	ON_MESSAGE(WM_RECEIVEDATA, OnReceiveData)
	ON_COMMAND_RANGE(IDM_MENU_SPEED1, IDM_MENU_SPEED49, OnSpeedMenu)
	ON_COMMAND_RANGE(IDM_MENU_BITS1, IDM_MENU_BITS49, OnBitsMenu)
	ON_COMMAND_RANGE(IDM_MENU_PORT1, IDM_MENU_PORT49, OnPortMenu)
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CTstmodemDlg message handlers
void SetCheckbox(CButton& checkbox, int value)
{
	checkbox.SetCheck(value ? BST_CHECKED : BST_UNCHECKED);
}

/////////////////////////////////////////////////////////////
// dynamically creating the menu bar
void AddMenuToCommandBar(CCeCommandBar &cmdbar, TCHAR *name, int menuid, CMenu *popup);
CMenu *MakeMenu(int menuid, CStringArray *itemlist, CString& dfl);

void CTstmodemDlg::InitializeMenu()
{
	//m_wndCommandBar.m_bShowSharedNewButton = TRUE;

	if(!m_wndCommandBar.Create(this))
	//	|| !m_wndCommandBar.InsertMenuBar(IDR_MENUBAR1)
	{
		error("creating menu");
		return;
	}
	AddMenuToCommandBar(m_wndCommandBar, L"port", IDR_MENU_PORT, MakeMenu(IDR_MENU_PORT+1, SerialParams::GetDeviceList(), SerialParams::GetDefaultPort()));
	AddMenuToCommandBar(m_wndCommandBar, L"speed", IDR_MENU_SPEED, MakeMenu(IDR_MENU_SPEED+1, SerialParams::GetSpeedList(), SerialParams::GetDefaultSpeed()));
	AddMenuToCommandBar(m_wndCommandBar, L"bits", IDR_MENU_BITS, MakeMenu(IDR_MENU_BITS+1, SerialParams::GetBitsList(), SerialParams::GetDefaultBits()));

	::DrawMenuBar(GetSafeHwnd());


}
void AddMenuToCommandBar(CCeCommandBar &cmdbar, TCHAR *name, int menuid, CMenu *popup)
{
	// from http://www.pocketpccode.com/forum/read.php?TID=469
	CToolBarCtrl &pToolbar = cmdbar.GetToolBarCtrl();

	TBBUTTON tbb0;
	tbb0.iBitmap = I_IMAGENONE;
	tbb0.fsState = TBSTATE_ENABLED;
#define TBSTYLE_NO_DROPDOWN_ARROW 0x0080
	tbb0.fsStyle = TBSTYLE_DROPDOWN|TBSTYLE_AUTOSIZE|TBSTYLE_NO_DROPDOWN_ARROW;
	tbb0.dwData = (UINT)popup->m_hMenu;
	tbb0.iString = (UINT)name; // Unicode String
	tbb0.idCommand = menuid; // unique

	pToolbar.InsertButton(pToolbar.GetButtonCount(),&tbb0);

}

CMenu *MakeMenu(int menuid, CStringArray *itemlist, CString& dfl)
{
	if (itemlist==NULL) {
		debug("ERROR: no items for menu %d\n", menuid);
		return NULL;
	}

	CMenu *pMenu = new CMenu();
	pMenu->CreatePopupMenu(); 

    int idxdfl= 0;
	for(int i=0 ; i < itemlist->GetSize() ; i++)
	{
		if (!pMenu->AppendMenu(MF_STRING|MF_ENABLED, menuid+i, itemlist->GetAt(i)))
			error("failed to add menuentry\n");
        if (itemlist->GetAt(i)==dfl)
            idxdfl= i;
	}
	delete itemlist;

	pMenu->CheckMenuRadioItem(0, itemlist->GetSize()-1, idxdfl, MF_BYPOSITION);

	return pMenu;
}

/////////////////////////////////////////////////////////////////
// create bits control
void CTstmodemDlg::CreateBitsControl()
{
	RECT prect;	this->GetWindowRect(&prect);
	RECT rect;	m_cListReceiveData.GetWindowRect(&rect);

    // create just below the modem output

	int ypos= rect.bottom-prect.top+2;
	int xpos= (prect.right-prect.left-32*(BIT_WIDTH+1))/2;

	m_gpio_bits= new BitController(0xa9040000, 0xa9040004, 0xffffffff);
	m_gpio_bits->CreateControl(this, xpos, ypos);
	m_gpio_bits->UpdateValues();

	m_a400_bits= new BitController(0xa4000068, 0xa4000064, 0x0000ffff);
	m_a400_bits->CreateControl(this, xpos, ypos+BIT_WIDTH+3);
	m_gpio_bits->UpdateValues();
}

/////////////////////////////////////////////////////////////////
// init dialog
BOOL CTstmodemDlg::OnInitDialog()
{
	CDialog::OnInitDialog();

    DWORD base= GetDialogBaseUnits();
    debug("baseunits: %d x %d\n", base&0xffff, base>>16);
    RECT dlgrect;
    GetClientRect(&dlgrect);
    debug("client: (%d x %d)\n", dlgrect.right, dlgrect.bottom);
    // portrait: pixels: 240 x 268, dialogunits: 160 x 195
    for (int dx=-1 ; dx<=1 ; dx++)
    for (int dy=-1 ; dy<=1 ; dy++)
    {
        dlgrect.right = 160+dx;
        dlgrect.bottom = 195+dy;
        debug("dlg: (%d x %d) ->", dlgrect.right, dlgrect.bottom);
        MapDialogRect(&dlgrect);
        debug("pixels:  (%d x %d)\n", dlgrect.right, dlgrect.bottom);
    }
    // landscape: pixels: 320 x 188, dialogunits: 213 x 137
    for (int dx=-1 ; dx<=1 ; dx++)
    for (int dy=-1 ; dy<=1 ; dy++)
    {
        dlgrect.right = 213+dx;
        dlgrect.bottom = 137+dy;
        debug("dlg: (%d x %d) ->", dlgrect.right, dlgrect.bottom);
        MapDialogRect(&dlgrect);
        debug("pixels:  (%d x %d)\n", dlgrect.right, dlgrect.bottom);
    }

/*
	LOGFONT lf;
	::GetObject((HFONT)GetStockObject(SYSTEM_FONT),sizeof(lf),&lf);

	debug("default font: w=%d h=%d wg=%d\n", lf.lfWidth, lf.lfHeight, lf.lfWeight);

	//lf.lfWidth= 6;
	//lf.lfHeight /= 2;
	_tcscpy(lf.lfFaceName, L"Tahoma");
	CFont font; font.CreateFontIndirect(&lf);

	m_cListReceiveData.SetFont(&font);
	m_cEditTransmitData.SetFont(&font);
*/
#if _WITH_GPIOBITDISPLAY
	CreateBitsControl();
#else
    m_cCheckDoBits.ShowWindow(SW_HIDE);
#endif

	InitializeMenu();
/*
	SetCheckbox(m_cCheckGsmReset, m_kernel->Get_a4000068_bit6());
	SetCheckbox(m_cCheckGsmMode, m_kernel->Get_a4000064_bit6());
	SetCheckbox(m_cCheckKernel03c8, m_kernel->Get_ac0203c8());

	SetCheckbox(m_cCheckEnableRil, true);
*/
    m_cCheckGsmMode.ShowWindow(SW_HIDE);
    m_cCheckKernel03c8.ShowWindow(SW_HIDE);

	SetCheckbox(m_cCheckDebugInOutput, true);
	SetCheckbox(m_cCheckAddCR, true);

	DebugRegisterWindow(this);

    m_cEditTransmitData.SetFocus();
	return FALSE; // false: no default focus
}


void CTstmodemDlg::SetModels(SerialPort& port, KernelState& kernel, RILState& ril)
{
	m_port= &port;
	m_kernel= &kernel;
	m_ril= &ril;
}

void CTstmodemDlg::OnCheckDtr() 
{
	if (!m_port->SetDTR(m_cCheckDTR.GetCheck()==BST_CHECKED))
        SetCheckbox(m_cCheckDTR, false);
}

void CTstmodemDlg::OnCheckRts() 
{
	if (!m_port->SetRTS(m_cCheckRTS.GetCheck()==BST_CHECKED))
        SetCheckbox(m_cCheckRTS, false);
}

void CTstmodemDlg::OnCheckBrk() 
{
	if (!m_port->SetBreak(m_cCheckBreak.GetCheck()==BST_CHECKED))
        SetCheckbox(m_cCheckBreak, false);
}

void CTstmodemDlg::OnCheckRtsctsFlowctl() 
{
	if (!m_port->SetRtsCtsFlowControl(m_cCheckRtsCtsFlowControl.GetCheck()==BST_CHECKED))
        SetCheckbox(m_cCheckRtsCtsFlowControl, false);
}

void CTstmodemDlg::OnCheckIr() 
{
	if (!m_port->SetIRMode(m_cCheckIR.GetCheck()==BST_CHECKED))
        SetCheckbox(m_cCheckIR, false);
}
void CTstmodemDlg::OnCheckHex() 
{
	if (m_cCheckHexData.GetCheck()==BST_CHECKED)
    {
        CString hex;
        CString str;
        m_cEditTransmitData.GetWindowText(str);
		ConvertBytesToHex(str, hex);
        m_cEditTransmitData.SetWindowText(hex);
    }
    else {
        CString hex;
        CString str;
        m_cEditTransmitData.GetWindowText(hex);
		ConvertHexToBytes(hex, str);
        m_cEditTransmitData.SetWindowText(str);
    }
}
LRESULT CTstmodemDlg::OnReceiveData(WPARAM wParam, LPARAM lParam)
{
	CString str;
	m_port->ReceiveData(str);

	m_cListReceiveData.appendString(str, 0);

    if (wcsstr(str.GetBuffer(0), L"\nOK\r")) {
        boost::mutex::scoped_lock lock(m_okmtx);

        m_ok= true;
        m_okcond.notify_one();
    }

	// todo: add config flag to enable/disable logging
	FILE *f= fopen("\\com.log", "a+");
	if (f)
	{
		fprintf(f, "%ls", str.GetBuffer(0));
		fclose(f);
	}

	return 0;
}

void SetState(CButton& button, CStatic& counter, bool state)
{
	bool oldstate= (button.GetState()==BST_PUSHED);
	//debug("old=%d new=%d  state=%d check=%d\n", oldstate, state, button.GetState(), button.GetCheck());
	if (state!=oldstate)
	{
		button.SetState(state);

		CString str;
		counter.GetWindowText(str);
		DWORD nr= _tcstoul(str.GetBuffer(0), 0, 0);
		str.Format(L"%d", nr+1);
		counter.SetWindowText(str);
	}
}
void MySetEvent(CButton& button, CStatic& counter)
{
	bool state= button.GetState()==BST_PUSHED;
	button.SetState(!state);

	CString str;
	counter.GetWindowText(str);
	DWORD nr= _tcstoul(str.GetBuffer(0), 0, 0);
	str.Format(L"%d", nr+1);
	counter.SetWindowText(str);
}
void CTstmodemDlg::CommEventBreak(bool state)
{
	SetState(m_cStatusBreak, m_cCounterBreak, state);
}
void CTstmodemDlg::CommEventCTS(bool state)
{
	SetState(m_cStatusCTS, m_cCounterCTS, state);
}
void CTstmodemDlg::CommEventRing(bool state)
{
	SetState(m_cStatusRing, m_cCounterRing, state);
}
void CTstmodemDlg::CommEventRLSD(bool state)
{
	SetState(m_cStatusRLSD, m_cCounterRLSD, state);
}
void CTstmodemDlg::CommEventERR(bool state)
{
	SetState(m_cStatusERR, m_cCounterERR, state);
}

void CTstmodemDlg::CommEventDSR(bool state)
{
	SetState(m_cStatusDSR, m_cCounterDSR, state);
}
void CTstmodemDlg::CommEventReceive()
{
	MySetEvent(m_cStatusReceive, m_cCounterReceive);
}
void CTstmodemDlg::CommEventTransmit()
{
	MySetEvent(m_cStatusTransmit, m_cCounterTransmit);
}
void CTstmodemDlg::CommEventInputOverFlow()
{
//	SetState(m_cStatusRcvOverflow, m_cCounterRcvOverflow, state);
}
void CTstmodemDlg::CommEventOutputOverFlow()
{
//	SetState(m_cStatusXmitOverflow, m_cCounterXmitOverflow, state);
}

bool toNyble(char c, int& nyble)
{
	if (c>='0' && c<='9')
	{
		nyble= c-'0';
		return true;
	}
	if (c>='A' && c<='F')
	{
		nyble= c-'A'+10;
		return true;
	}
	if (c>='a' && c<='f')
	{
		nyble= c-'a'+10;
		return true;
	}
	return false;
}
char toHex(BYTE c)
{
    return '0' + c + (c>9?'a'-'0'-10:0);
}

void ConvertHexToBytes(CString& hexstr, CString& newstr)
{
	int buflen= hexstr.GetLength()/2;
	TCHAR *buf= newstr.GetBuffer(buflen+1);
	int bi=0;
	int ni=1;	// nyble index ( 1=high, 0=low )

	int hexlen= hexstr.GetLength();
	TCHAR *hexbuf= hexstr.GetBuffer(0);
	int si=0;

	while (si<hexlen)
	{
		char c= (char)hexbuf[si++];
		int nyble;
		if (toNyble(c, nyble))
		{
			if (ni)
				buf[bi] = nyble<<4;
			else
				buf[bi++] |= nyble;
			ni= 1-ni;
		}
	}
    buf[bi]=0;
	newstr.ReleaseBuffer(bi);
}
void ConvertBytesToHex(CString& str, CString& hexstr)
{
	int buflen= str.GetLength()*3;
	TCHAR *hexbuf= hexstr.GetBuffer(buflen+1);
	int bi=0;

	int strlen= str.GetLength();
	TCHAR *strbuf= str.GetBuffer(0);
	int si=0;

	while (bi<strlen)
	{
        if (si)
            hexbuf[si++]= ' ';
        hexbuf[si++]= toHex(strbuf[bi]>>4);
        hexbuf[si++]= toHex(strbuf[bi]&0xF);
        bi++;
    }
    hexbuf[si]= 0;
	hexstr.ReleaseBuffer(si);
}

void CTstmodemDlg::OnButtonTransmit() 
{
	CString str;
	m_cEditTransmitData.GetWindowText(str);

	if (m_cCheckHexData.GetCheck()==BST_CHECKED)
	{
		CString hex= str;
		ConvertHexToBytes(hex, str);
	}
	else
	{
        if (m_cCheckAddCR.GetCheck()==BST_CHECKED)
            str += "\r";
        if (m_cCheckAddLF.GetCheck()==BST_CHECKED)
            str += "\n";
	}

	m_cListReceiveData.appendString(str, 1);

	m_port->SendData(str);
}

void CTstmodemDlg::OnClose() 
{
	DebugRegisterWindow(NULL);

	CDialog::OnClose();
}

void CTstmodemDlg::OnCheckEnableRil() 
{
	if (m_cCheckEnableRil.GetCheck()==BST_CHECKED)
	{
		if (!m_ril->open())
			SetCheckbox(m_cCheckEnableRil, false);
        else if (!m_ril->enable())
			SetCheckbox(m_cCheckEnableRil, false);
	}
	else
	{
		m_ril->disable();
		m_ril->close();
	}
}
DWORD CTstmodemDlg::staticthreadproc(CTstmodemDlg* self)
{
    return self->sendcommandlist();
}
DWORD CTstmodemDlg::sendcommandlist()
{
    boost::mutex::scoped_lock lock(m_okmtx);
    for (const char**p= g_initstrings ; *p && !m_okstop ; p++) {
        m_ok= false;
		CString str; str.Format(L"AT%hs\r", *p);

        m_cListReceiveData.appendString(str, 1);

        if (!m_port->SendData(str))
            break;

        DWORD t0= GetTickCount();
        while (!m_ok && !m_okstop && GetTickCount()-t0<5000)
            m_okcond.wait(lock, 500);
        if (!m_ok)
            debug("ERROR: no ok received\n");
    }
    SetCheckbox(m_cCheckGsmReset, false);
    return 0;
}
void CTstmodemDlg::OnCheckGsmreset() 
{
    boost::mutex::scoped_lock lock(m_okmtx);
	//m_kernel->Set_a4000068_bit6(m_cCheckGsmReset.GetCheck()==BST_CHECKED);
    if (m_cCheckGsmReset.GetCheck()==BST_CHECKED) {
        m_okstop= false;
        DWORD id;
        CloseHandle(CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)CTstmodemDlg::staticthreadproc, this, 0, &id));
    }
    else {
        m_okstop= true;
        m_okcond.notify_one();
    }
}
void CTstmodemDlg::OnCheckClearScreen() 
{
    m_cListReceiveData.ResetContent();
    SetCheckbox(m_cCheckClearScreen, false);
}
void CTstmodemDlg::OnCheckGsmMode() 
{	
	//m_kernel->Set_a4000064_bit6(m_cCheckGsmMode.GetCheck()==BST_CHECKED);
}

void CTstmodemDlg::OnCheckKernel03c8() 
{
	//m_kernel->Set_ac0203c8((m_cCheckKernel03c8.GetCheck()==BST_CHECKED) ? 1 : 0 );
}

void CTstmodemDlg::OnCheckDebugInOutput() 
{
	DebugRegisterWindow( (m_cCheckDebugInOutput.GetCheck()==BST_CHECKED) ? this : NULL );

	debug("debugwindow %d\n", m_cCheckDebugInOutput.GetCheck()==BST_CHECKED);
}

void CTstmodemDlg::OnCheckComIoctl() 
{
	// can only be set, since I don't know the 'unset' ioctl.
	//   ( reading serial3.dll, I see 0xaaaa5677 .. 0xaaaa5679 
	//      as special ioctls though )
	if (m_cCheckComIoctl.GetCheck()==BST_CHECKED)
	{
		if (!m_port->SendIoctl())
			SetCheckbox(m_cCheckComIoctl, false);
	}
	else
		SetCheckbox(m_cCheckComIoctl, true);
}

void CTstmodemDlg::OnCheckOpendevice() 
{
	if (m_cCheckOpenDevice.GetCheck()==BST_CHECKED)
	{
		if (!m_port->open())
			SetCheckbox(m_cCheckOpenDevice, false);
	}
	else
		m_port->close();
}

//////////////////////////////////////////////////////////////////////////
//  menu handlers
void FindMenuString(CCeCommandBar *cmdbar, UINT menuentryid, CString &str);


void CTstmodemDlg::OnSpeedMenu(UINT nId) 
{
	//debug("app.speed %d\n", nId);
	CString str;
	FindMenuString(&m_wndCommandBar, nId, str);
	m_port->SetSpeed(str);
}
void CTstmodemDlg::OnBitsMenu(UINT nId)
{
	//debug("bits %d\n", nId);
	CString str;
	FindMenuString(&m_wndCommandBar, nId, str);
	m_port->SetBits(str);
}
void CTstmodemDlg::OnPortMenu(UINT nId)
{
	//debug("port %d\n", nId);
	CString str;
	FindMenuString(&m_wndCommandBar, nId, str);
	m_port->SetPort(str);

	// reset userinterface items
	SetCheckbox(m_cCheckOpenDevice, false);
	SetCheckbox(m_cCheckComIoctl, false);
}

void FindMenuString(CCeCommandBar *cmdbar, UINT menuentryid, CString &str)
{
	CToolBarCtrl *ctrl= (CToolBarCtrl *)cmdbar;

	for (int i=0 ; i<3 ; i++)
	{
		UINT id, style;
		int image;
		cmdbar->GetButtonInfo(i, id, style, image);

		TBBUTTONINFO tbbi;
		tbbi.cbSize= sizeof(TBBUTTONINFO);
		tbbi.dwMask= TBIF_LPARAM;

		if (!ctrl->GetButtonInfo(id, &tbbi))
			continue;

		if (!tbbi.lParam)
			continue;

		CMenu *menu= CMenu::FromHandle((HMENU)tbbi.lParam);
		if (menu->GetMenuString(menuentryid, str, MF_BYCOMMAND)) {
			menu->CheckMenuRadioItem(id+1, id+49, menuentryid, MF_BYCOMMAND);
			return;
		}
	}
}

void CTstmodemDlg::OnTimer(UINT nIDEvent) 
{
	if (m_bUpdateBits && m_gpio_bits && m_a400_bits) {
		m_gpio_bits->UpdateValues();
		m_a400_bits->UpdateValues();
	}

	CDialog::OnTimer(nIDEvent);
}

void CTstmodemDlg::OnCheckDobits() 
{
	m_bUpdateBits= (m_cCheckDoBits.GetCheck()==BST_CHECKED);
    if (m_bUpdateBits)
        SetTimer(1, 200, NULL);
    else
        KillTimer(1);
}

void CTstmodemDlg::appendString(const TCHAR *str)
{
    // debug output
	m_cListReceiveData.appendString(str, 2);
}