zhipuzi_pos_windows/zhipuzi_pos_windows/wnd/CMainWnd.cpp

#include "../pch/pch.h"
#include "CMainWnd.h"
#include "CLoginWnd.h"

#include "../control/ControlEx.h"
#include "../page/CWaimaiOrderInfoPageUI.h"
#include "../page/CDianneiOrderInfoPageUI.h"

#include "../network/CMessagePush.h"
#include "../print/CPosPrinter.h"

#include <urlmon.h>

#include "../wnd/CToastWnd.h"

#include "../tool/CChengzhongWorker.h"

void CMainWnd::Init()
{
	//设置店铺名字
	CLabelUI* pShopname = static_cast<CLabelUI*>(m_pm.FindControl(_T("main_shopname")));
	pShopname->SetText(CLewaimaiString::UTF8ToUnicode(CShopinfo::m_shopinfo.m_shop_name).c_str());

	m_curOptionName = L"main_diandan";
	m_curOption = static_cast<CControlUI*>(m_pm.FindControl(_T("main_diandan")));

    m_pCloseBtn = static_cast<CButtonUI*>(m_pm.FindControl(_T("closebtn")));
    m_pMaxBtn = static_cast<CButtonUI*>(m_pm.FindControl(_T("maxbtn")));
    m_pRestoreBtn = static_cast<CButtonUI*>(m_pm.FindControl(_T("restorebtn")));
    m_pMinBtn = static_cast<CButtonUI*>(m_pm.FindControl(_T("minbtn")));

	//默认选择点单页面
	this->SwitchPage(DIANDAN);

	//开启键盘输入监听
	RegKeyboardRawInput();

    //登录成功，启动消息和任务处理
    m_push = new CMessagePush(m_hWnd);
    m_push->Start();

	//启动打印队列
	CPosPrinterQueue::GetInstance()->StartWork();

	//启动称重任务
	CChengzhongWorker::GetInstance()->StartWork();

	//启动一个线程，开始同步商品图片
	std::thread(&CMainWnd::UpdateFoodImage, this).detach();
}

void CMainWnd::UpdateFoodImage()
{
	//先判断并创建临时目录
	string folderPath = CLewaimaiString::UnicodeToANSI(CSystem::GetProgramDir()) + "\\tmp\\image";
	std::wstring ws_folderPath = CLewaimaiString::ANSIToUnicode(folderPath);
	if (!CSystem::IsDirExist(ws_folderPath))
	{
		LOG_INFO("folderPath:" << folderPath.c_str() << "，没有找到对应的目录，即将创建");
		CSystem::CreateMultiLevel(folderPath);
	}

	CSqlite3 sqlite;
	std::vector<CFood> foodlist = sqlite.GetFoodByTypeid("0", true);
	for (std::vector<CFood>::iterator it = foodlist.begin(); it != foodlist.end(); it++)
	{
		CFood food = *it;

		if (food.goods_img.size() == 0)
		{
			//没有图片，直接跳过
			continue;
		}
		std::wstring ws_goods_img = food.getImageUrl();
		ws_goods_img += L"!max200"; //下载小图

		wstring imagePath = food.getImageTmpPath();
		if (CSystem::IsFileExist(imagePath))
		{
			//如果图片文件已经存在，直接跳过
			continue;
		}

		//图片还不存在，开始下载
		if (URLDownloadToFile(NULL, ws_goods_img.c_str(), imagePath.c_str(), 0, NULL) == S_OK)
		{
			//图片下载成功了，发个消息，更新图片
		}
		else
		{
			LOG_INFO("URLDownloadToFile Fail,Error"<<GetLastError());
		}
	}	

	//再处理商品套餐的图片
	std::vector<CFoodpackage> foodpackagelist = sqlite.GetFoodpackages(true);
	for (std::vector<CFoodpackage>::iterator it = foodpackagelist.begin(); it != foodpackagelist.end(); it++)
	{
		CFoodpackage food = *it;

		if (food.goods_img.size() == 0)
		{
			//没有图片，直接跳过
			continue;
		}
		std::wstring ws_goods_img = food.getImageUrl();
		ws_goods_img += L"!max200"; //下载小图

		wstring imagePath = food.getImageTmpPath();
		if (CSystem::IsFileExist(imagePath))
		{
			//如果图片文件已经存在，直接跳过
			continue;
		}

		//图片还不存在，开始下载
		if (URLDownloadToFile(NULL, ws_goods_img.c_str(), imagePath.c_str(), 0, NULL) == S_OK)
		{
			//图片下载成功了，发个消息，更新图片
		}
		else
		{
			LOG_INFO("URLDownloadToFile Fail,Error" << GetLastError());
		}
	}
}

void CMainWnd::SwitchPage(MainPageName name)
{
	if (m_curPageName == name)
	{
		return;
	}

	//先删除现在的子对象
	CContainerUI* pMainContentLayout = static_cast<CContainerUI*>(m_pm.FindControl(_T("main_content_layout")));
	pMainContentLayout->RemoveAll();

	//再创建一个对象
	CDialogBuilder builder;
	CDialogBuilderCallbackEx cb;

	CBasePageUI* pChildContainer = NULL;

	//注意事项：所有的子页面中的option不能带有selected="true"属性，如果带有这个属性，在下面的Create调用的时候就直接会生成一个selectchanged事件，但是这个时候
	//页面才刚刚Create，还没加入到窗口中，相关的变量对应关系也还没设置成功，会导致事件处理对象出现问题
	if (name == DIANDAN)
	{
		pChildContainer = static_cast<CBasePageUI*>(builder.Create(_T("diandan_page.xml"), (UINT)0, &cb, &m_pm));		
	}
	else if (name == DINGDAN)
	{
		pChildContainer = static_cast<CBasePageUI*>(builder.Create(_T("waimaiorder_list_page.xml"), (UINT)0, &cb, &m_pm));
	}
	else if (name == SHEZHI)
	{
		pChildContainer = static_cast<CBasePageUI*>(builder.Create(_T("setting_page.xml"), (UINT)0, &cb, &m_pm));
	}
	else if (name == HUIYUAN)
	{
		pChildContainer = static_cast<CBasePageUI*>(builder.Create(_T("huiyuan_page.xml"), (UINT)0, &cb, &m_pm));
	}
	else if (name == WAIMAIINFO)
	{
		pChildContainer = static_cast<CBasePageUI*>(builder.Create(_T("waimaiorder_info_page.xml"), (UINT)0, &cb, &m_pm));

		CWaimaiOrderInfoPageUI* pInfoPage = static_cast<CWaimaiOrderInfoPageUI*>(pChildContainer);
		pInfoPage->m_order_id = m_infopage_waimaiorder_id;
		pInfoPage->m_order_no = m_infopage_waimaiorder_no;
	}
	else if (name == DIANNEIDINGDAN)
	{
		pChildContainer = static_cast<CBasePageUI*>(builder.Create(_T("dianneiorder_list_page.xml"), (UINT)0, &cb, &m_pm));
	}
	else if (name == DIANNEIINFO)
	{
		pChildContainer = static_cast<CBasePageUI*>(builder.Create(_T("dianneiorder_info_page.xml"), (UINT)0, &cb, &m_pm));

		CDianneiOrderInfoPageUI* pInfoPage = static_cast<CDianneiOrderInfoPageUI*>(pChildContainer);
		pInfoPage->m_order_id = m_infopage_dianneiorder_id;
	}
	else if (name == BAOBIAO)
	{
		pChildContainer = static_cast<CBasePageUI*>(builder.Create(_T("baobiao_page.xml"), (UINT)0, &cb, &m_pm));
	}

	pChildContainer->SetMainWnd(this);
	pMainContentLayout->Add(pChildContainer);

	m_curPageName = name;
	m_curPageUI = pChildContainer;
	
	pChildContainer->InitShow();
}

LRESULT CMainWnd::OnCreate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
    LONG styleValue = ::GetWindowLong(*this, GWL_STYLE);
    styleValue &= ~WS_CAPTION;
    ::SetWindowLong(*this, GWL_STYLE, styleValue | WS_CLIPSIBLINGS | WS_CLIPCHILDREN);
    m_pm.Init(m_hWnd);
    CDialogBuilder builder;
    CDialogBuilderCallbackEx cb;
    CControlUI* pRoot = builder.Create(_T("main.xml"), (UINT)0, &cb, &m_pm);
    ASSERT(pRoot && "Failed to parse XML");
    m_pm.AttachDialog(pRoot);
    m_pm.AddNotifier(this);
    Init();
    return 0;
}

void CMainWnd::Notify(TNotifyUI& msg)
{
    if(msg.sType == _T("windowinit"))
    {
        
    }
    else if(msg.sType == _T("click"))
    {
        HandleClickMsg(msg);
    }
    else if(msg.sType == _T("selectchanged"))
    {
        HandleSelectChangeMsg(msg);
    }
    else if(msg.sType == _T("itemclick"))
    {
    }
    else if(msg.sType == _T("itemactivate"))
    {
    }
    else if(msg.sType == _T("itemselect"))
    {
        HandleItemSelectMsg(msg);
    }
	else if (msg.sType == _T("textchanged"))
	{
		//编辑框内容改变事件
		HandleTextChangedMsg(msg);
	}
}

void CMainWnd::HandleClickMsg(TNotifyUI& msg)
{
    if(msg.pSender == m_pCloseBtn)
    {
        if(CSetting::GetParam("setting_is_close_min") == "1")
        {
            AddTrayIcon();
        }
        else
        {
            PostQuitMessage(0);
        }

        return;
    }
    else if(msg.pSender == m_pMinBtn)
    {
        SendMessage(WM_SYSCOMMAND, SC_MINIMIZE, 0);
        return;
    }
    else if(msg.pSender == m_pMaxBtn)
    {
        SendMessage(WM_SYSCOMMAND, SC_MAXIMIZE, 0);
        return;
    }
    else if(msg.pSender == m_pRestoreBtn)
    {
        SendMessage(WM_SYSCOMMAND, SC_RESTORE, 0);
        return;
    }

    CDuiString name = msg.pSender->GetName();

    if(name == _T("quitbtn"))
    {
        /*Close()*/
		PostQuitMessage(0); // 因为activex的原因，使用close可能会出现错误
    }
	else
	{
		this->m_curPageUI->HandleClickMsg(msg);
	}
}

/**
 * 这个处理Option的切换
 */
void CMainWnd::HandleSelectChangeMsg(TNotifyUI& msg)
{
    CDuiString name = msg.pSender->GetName();
	std::wstring ws_name = name;

	if (ws_name == _T("main_diandan") || ws_name == _T("main_dingdan") || ws_name == _T("main_huiyuan") || ws_name == _T("main_baobiao") || ws_name == _T("main_jiaoban") || ws_name == _T("main_setting") || ws_name == _T("main_gengduo"))
	{
		if (m_curOptionName != ws_name)
		{
			//表示切换了tab
			m_curOption->SetBkColor(0x00000000);

			msg.pSender->SetBkColor(0xFF3CB371);

			m_curOptionName = ws_name;
			m_curOption = static_cast<CControlUI*>(msg.pSender);
		}
	}

    //先判断主页面的tab
	if (name == _T("main_diandan"))
	{
		this->SwitchPage(DIANDAN);
	}
    else if(name == _T("main_dingdan"))
    {
		this->SwitchPage(DIANNEIDINGDAN);
    }
	else if (name == L"main_huiyuan")
	{
		this->SwitchPage(HUIYUAN);
	}
	else if (name == L"main_baobiao")
	{
		this->SwitchPage(BAOBIAO);
	}
	else if (name == L"main_jiaoban")
	{

	}
    else if(name == _T("main_setting"))
    {
		this->SwitchPage(SHEZHI);
    }
	else if (name == L"main_gengduo")
	{

	}
	else
	{
		//除了主界面固定区域的事件，其他的事件全部分发给子页面
		this->m_curPageUI->HandleSelectChangeMsg(msg);
	}
}

void CMainWnd::HandleItemSelectMsg(TNotifyUI& msg)
{
	this->m_curPageUI->HandleItemSelectMsg(msg);
}

void CMainWnd::HandleTextChangedMsg(TNotifyUI& msg)
{
	this->m_curPageUI->HandleTextChangedMsg(msg);
}

LRESULT CMainWnd::HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    LRESULT lRes = 0;
    BOOL bHandled = TRUE;

    switch(uMsg)
    {
    case WM_CREATE:
        lRes = OnCreate(uMsg, wParam, lParam, bHandled);
        break;

    case WM_CLOSE:
        lRes = OnClose(uMsg, wParam, lParam, bHandled);
        break;

    case WM_DESTROY:
        lRes = OnDestroy(uMsg, wParam, lParam, bHandled);
        break;

    case WM_NCACTIVATE:
        lRes = OnNcActivate(uMsg, wParam, lParam, bHandled);
        break;

    case WM_NCCALCSIZE:
        lRes = OnNcCalcSize(uMsg, wParam, lParam, bHandled);
        break;

    case WM_NCPAINT:
        lRes = OnNcPaint(uMsg, wParam, lParam, bHandled);
        break;

    case WM_NCHITTEST:
        lRes = OnNcHitTest(uMsg, wParam, lParam, bHandled);
        break;

    case WM_SIZE:
        lRes = OnSize(uMsg, wParam, lParam, bHandled);
        break;

    case WM_GETMINMAXINFO:
        lRes = OnGetMinMaxInfo(uMsg, wParam, lParam, bHandled);
        break;

    case WM_SYSCOMMAND:
        lRes = OnSysCommand(uMsg, wParam, lParam, bHandled);
        break;

    case WM_SHOWTASK:
        lRes = OnTrayIcon(uMsg, wParam, lParam, bHandled);
        break;

	case WM_INPUT:
		lRes = OnInput(uMsg, wParam, lParam, bHandled);
		break;

	case WM_KEYDOWN:
		lRes = OnKeydown(uMsg, wParam, lParam, bHandled);
		break;

	case WM_KILLFOCUS:
		break;

    default:
        bHandled = FALSE;
    }

    if(bHandled)
    {
        return lRes;
    }

	bool ret = this->HandleCustomMessage(uMsg, wParam, lParam);
	if (ret)
	{
		//自定义消息已经处理
		return 0;
	}

    if(m_pm.MessageHandler(uMsg, wParam, lParam, lRes))
    {
        return lRes;
    }

    return CWindowWnd::HandleMessage(uMsg, wParam, lParam);
}

bool CMainWnd::HandleCustomMessage(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	if (uMsg == WM_LOGIN_AGAIN_OUT)
	{
		LoginOut(2);

		return true;
	}
	else
	{
		//走到这里，说明消息还没有被处理，那就不是MainWnd自己要处理的消息，应该是自定义的消息，交给各个子页面自己处理去
		if (m_curPageUI != NULL)
		{
			bool ret = this->m_curPageUI->HandleCustomMessage(uMsg, wParam, lParam);

			return ret;
		}
	}

	return false;
}

LRESULT CMainWnd::MessageHandler(UINT uMsg, WPARAM wParam, LPARAM lParam, bool& bHandled)
{
	return false;
}

LRESULT CMainWnd::OnSysCommand(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
    // 有时会在收到WM_NCDESTROY后收到wParam为SC_CLOSE的WM_SYSCOMMAND
    if(wParam == SC_CLOSE)
    {
        ::PostQuitMessage(0L);
        bHandled = TRUE;
        return 0;
    }

    BOOL bZoomed = ::IsZoomed(*this);
    LRESULT lRes = CWindowWnd::HandleMessage(uMsg, wParam, lParam);

    if(::IsZoomed(*this) != bZoomed)
    {
        if(!bZoomed)
        {
            CControlUI* pControl = static_cast<CControlUI*>(m_pm.FindControl(_T("maxbtn")));

            if(pControl)
            {
                pControl->SetVisible(false);
            }

            pControl = static_cast<CControlUI*>(m_pm.FindControl(_T("restorebtn")));

            if(pControl)
            {
                pControl->SetVisible(true);
            }
        }
        else
        {
            CControlUI* pControl = static_cast<CControlUI*>(m_pm.FindControl(_T("maxbtn")));

            if(pControl)
            {
                pControl->SetVisible(true);
            }

            pControl = static_cast<CControlUI*>(m_pm.FindControl(_T("restorebtn")));

            if(pControl)
            {
                pControl->SetVisible(false);
            }
        }
    }

    return lRes;
}

LRESULT CMainWnd::OnGetMinMaxInfo(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
    int primaryMonitorWidth = ::GetSystemMetrics(SM_CXSCREEN);
    int primaryMonitorHeight = ::GetSystemMetrics(SM_CYSCREEN);
    MONITORINFO oMonitor = {};
    oMonitor.cbSize = sizeof(oMonitor);
    ::GetMonitorInfo(::MonitorFromWindow(*this, MONITOR_DEFAULTTOPRIMARY), &oMonitor);
    CDuiRect rcWork = oMonitor.rcWork;
    rcWork.Offset(-oMonitor.rcMonitor.left, -oMonitor.rcMonitor.top);

    if(rcWork.right > primaryMonitorWidth)
    {
        rcWork.right = primaryMonitorWidth;
    }

    if(rcWork.bottom > primaryMonitorHeight)
    {
        rcWork.right = primaryMonitorHeight;
    }

    LPMINMAXINFO lpMMI = (LPMINMAXINFO)lParam;
    lpMMI->ptMaxPosition.x = rcWork.left;
    lpMMI->ptMaxPosition.y = rcWork.top;
    lpMMI->ptMaxSize.x = rcWork.right;
    lpMMI->ptMaxSize.y = rcWork.bottom;
    bHandled = FALSE;
    return 0;
}

LRESULT CMainWnd::OnSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
    SIZE szRoundCorner = m_pm.GetRoundCorner();

    if(!::IsIconic(*this) && (szRoundCorner.cx != 0 || szRoundCorner.cy != 0))
    {
        CDuiRect rcWnd;
        ::GetWindowRect(*this, &rcWnd);
        rcWnd.Offset(-rcWnd.left, -rcWnd.top);
        rcWnd.right++;
        rcWnd.bottom++;
        HRGN hRgn = ::CreateRoundRectRgn(rcWnd.left, rcWnd.top, rcWnd.right, rcWnd.bottom, szRoundCorner.cx, szRoundCorner.cy);
        ::SetWindowRgn(*this, hRgn, TRUE);
        ::DeleteObject(hRgn);
    }

    bHandled = FALSE;
    return 0;
}

LRESULT CMainWnd::OnClose(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
    bHandled = FALSE;
    return 0;
}

/*
 *这个是窗口被销毁的时候调用的
 **/
LRESULT CMainWnd::OnDestroy(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
    //直接退出程序，或者退出登录都会执行这个
    m_push->Stop();

	//停止打印任务
	CPosPrinterQueue::GetInstance()->StopWork();

	//停止称重任务
	CChengzhongWorker::GetInstance()->StopWork();

    bHandled = FALSE;
    return 0;
}

LRESULT CMainWnd::OnNcActivate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
    if(::IsIconic(*this))
    {
        bHandled = FALSE;
    }

    return (wParam == 0) ? TRUE : FALSE;
}

LRESULT CMainWnd::OnNcCalcSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
    return 0;
}

LRESULT CMainWnd::OnNcPaint(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
    return 0;
}

LRESULT CMainWnd::OnNcHitTest(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
    POINT pt;
    pt.x = GET_X_LPARAM(lParam);
    pt.y = GET_Y_LPARAM(lParam);
    ::ScreenToClient(*this, &pt);
    RECT rcClient;
    ::GetClientRect(*this, &rcClient);

    if(!::IsZoomed(*this))
    {
        RECT rcSizeBox = m_pm.GetSizeBox();

        if(pt.y < rcClient.top + rcSizeBox.top)
        {
            if(pt.x < rcClient.left + rcSizeBox.left)
            {
                return HTTOPLEFT;
            }

            if(pt.x > rcClient.right - rcSizeBox.right)
            {
                return HTTOPRIGHT;
            }

            return HTTOP;
        }
        else if(pt.y > rcClient.bottom - rcSizeBox.bottom)
        {
            if(pt.x < rcClient.left + rcSizeBox.left)
            {
                return HTBOTTOMLEFT;
            }

            if(pt.x > rcClient.right - rcSizeBox.right)
            {
                return HTBOTTOMRIGHT;
            }

            return HTBOTTOM;
        }

        if(pt.x < rcClient.left + rcSizeBox.left)
        {
            return HTLEFT;
        }

        if(pt.x > rcClient.right - rcSizeBox.right)
        {
            return HTRIGHT;
        }
    }

    RECT rcCaption = m_pm.GetCaptionRect();

    if(pt.x >= rcClient.left + rcCaption.left && pt.x < rcClient.right - rcCaption.right \
            && pt.y >= rcCaption.top && pt.y < rcCaption.bottom)
    {
        CControlUI* pControl = static_cast<CControlUI*>(m_pm.FindControl(pt));

        if(pControl && _tcscmp(pControl->GetClass(), DUI_CTR_BUTTON) != 0 &&
                _tcscmp(pControl->GetClass(), DUI_CTR_OPTION) != 0 &&
                _tcscmp(pControl->GetClass(), DUI_CTR_TEXT) != 0)
        {
            return HTCAPTION;
        }
    }

    return HTCLIENT;
}

LRESULT CMainWnd::OnInput(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
	UINT dwSize = 0;
	GetRawInputData((HRAWINPUT)lParam, (UINT)RID_INPUT, NULL, &dwSize, sizeof(RAWINPUTHEADER));//取数据,第一次调用函数将获取需要的字节大小		
	LPBYTE lpbBuffer = new BYTE[dwSize];//分配指定的缓冲区大小
	GetRawInputData((HRAWINPUT)lParam, (UINT)RID_INPUT, (LPVOID)lpbBuffer, (PUINT)&dwSize, (UINT)sizeof(RAWINPUTHEADER));//第二次调用获取原始输入数据，读入lpbBuffer

	RAWINPUT * raw = (RAWINPUT *)lpbBuffer;
	if (raw->header.dwType == RIM_TYPEKEYBOARD)//这里可以截获所有键盘信息,如需区分不同的键盘输入信息,可以通过设备句柄判断。
	{
		if (raw->data.keyboard.Message == WM_KEYDOWN)
		{

		}
		else if (raw->data.keyboard.Message == WM_KEYUP)
		{
			char keytext[10] = { 0 };
			BYTE state[256] = { 0 };

			//通过虚拟键盘码得到名字
			ToAscii(raw->data.keyboard.VKey, raw->data.keyboard.MakeCode, state, (LPWORD)keytext, 0);

			LOG_INFO("vkey:" << raw->data.keyboard.VKey<<", keytext:"<<keytext);

			if (raw->data.keyboard.VKey >= 48 && raw->data.keyboard.VKey <= 122)
			{
				char keytext[10] = { 0 };
				BYTE state[256] = { 0 };

				//通过虚拟键盘码得到名字
				ToAscii(raw->data.keyboard.VKey, raw->data.keyboard.MakeCode, state, (LPWORD)keytext, 0);

				//这里是数字和英文字母之间的字符，包含部分标点
				if (m_is_start_catch == false)
				{
					//第一次点击，还无法判定是人工还是机器输入的，先保存下来
					m_is_start_catch = true;

					m_catch_string = "";

					m_is_next_daxie = false;					

					m_catch_string += string(keytext);

					LOG_INFO("起始字符：" << keytext << "，累积：" << m_catch_string.c_str());

					m_last_catch_clock = clock();
				}
				else
				{
					//已经是在抓取过程中了
					clock_t now = clock();

					double total_t = (double)(now - m_last_catch_clock) / CLOCKS_PER_SEC;
					if (total_t > 0.05)
					{
						LOG_INFO("发现人工输入");

						//如果超过了50ms，说明是前面一个字符是人工输入的了，不能代表现在这个字符是人工输入的，把之前的字符清空，但是目前的这个字符还是要保存
						m_catch_string = "";

						m_is_next_daxie = false;

						//把当前字符保存下来
						m_catch_string += string(keytext);

						LOG_INFO("起始字符：" << keytext << "，累积：" << m_catch_string.c_str());

						m_last_catch_clock = clock();
					}
					else
					{
						//这种说明前一个和当前的字符，都是机器输入的，都保存下来
						std::string s_keytext = keytext;
						if (m_is_next_daxie == true)
						{
							//要把抓取的这个字符转为大写
							transform(s_keytext.begin(), s_keytext.end(), s_keytext.begin(), ::toupper);
						}

						//转换完了，再把状态还原
						m_is_next_daxie = false;

						m_catch_string += s_keytext;

						LOG_INFO("抓取字符：" << s_keytext.c_str() << "，累积：" << m_catch_string.c_str());

						m_last_catch_clock = clock();
					}
				}
			}
			else if (raw->data.keyboard.VKey == 13)
			{
				//输入了enter
				if (m_is_start_catch == true)
				{
					//正在抓取中，判断enter才有意义，否则没有意义

					clock_t now = clock();

					double total_t = (double)(now - m_last_catch_clock) / CLOCKS_PER_SEC;
					if (total_t > 0.05)
					{
						LOG_INFO("抓取enter人工");

						//如果超过了50ms，说明前面一个字符是人工输入的，那么相当于这次直接输入了一个enter，也没意义
						m_is_start_catch = false;
						m_catch_string = "";
						m_is_next_daxie = false;
					}
					else
					{
						LOG_INFO("抓取enter结束");

						//这种说明前一个字符和当前字符都是机器输入的，可以判定输入结束
						std::string last = m_catch_string;

						//对抓取结果，进行处理
						m_curPageUI->HandleTextCapture(last);

						//处理完成后，清空重来
						m_is_start_catch = false;
						m_catch_string = "";
						m_is_next_daxie = false;
					}
				}
				else
				{
					//还没开始抓取就输入了enter，没有意义，重新开始
					m_is_start_catch = false;
					m_catch_string = "";
					m_is_next_daxie = false;
				}
			}
			else if (raw->data.keyboard.VKey == 16)
			{
				//这个是大小写切换的按键，扫描大写字母的时候会用到，每个大写字母都是由2个组成，先来个16，再来个对应小写字母的asicc
				if (m_is_start_catch == false)
				{
					LOG_INFO("抓取第1个16");
					//说明第一个字符就是大写字母，暂时还无法判断是机器还是人工输入的，先开启抓取
					m_is_start_catch = true;

					m_catch_string = "";

					m_is_next_daxie = true;

					m_last_catch_clock = clock();
				}
				else
				{
					//已经在抓取中了
					clock_t now = clock();

					double total_t = (double)(now - m_last_catch_clock) / CLOCKS_PER_SEC;
					if (total_t > 0.05)
					{
						LOG_INFO("抓取16人工");
						//如果超过了50ms，只能说明之前的字符是人工输入的，不能代表目前的字符是人工输入的，把之前的清空

						m_catch_string = "";
						m_is_next_daxie = true;

						m_last_catch_clock = clock();
					}
					else
					{
						LOG_INFO("抓取16");
						//这个说明之前的和当前的都是机器输入的
						m_is_next_daxie = true;

						m_last_catch_clock = clock();
					}
				}
			}
			else
			{
				LOG_INFO("抓取结束，重新开始");
				//输入了无意义的字符，这种直接忽略，重新开始
				m_is_start_catch = false;

				m_catch_string = "";

				m_is_next_daxie = false;
			}
		}
	}
	delete[] lpbBuffer;

	bHandled = true;
	return 0;
}

LRESULT CMainWnd::OnKeydown(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
	if (wParam == VK_RETURN)
	{
		//这里目前主要作用是，拦截按钮自带的焦点enter响应

		bHandled = true;
		return 0;
	}
	else if (wParam == VK_ESCAPE)
	{
		bHandled = true;
		return 0;
	}

	//其他的按键事件，不能返回0
	bHandled = false;
	return -1;
}

void CMainWnd::AddTrayIcon()
{
    memset(&m_trayIcon, 0, sizeof(NOTIFYICONDATA));
    m_trayIcon.cbSize = sizeof(NOTIFYICONDATA);
    m_trayIcon.hIcon = ::LoadIcon(GetModuleHandle(NULL), MAKEINTRESOURCE(IDI_ICON_DUILIB));
    m_trayIcon.hWnd = m_hWnd;
    lstrcpy(m_trayIcon.szTip, _T("智铺子收银系统"));
    m_trayIcon.uCallbackMessage = WM_SHOWTASK;
    m_trayIcon.uFlags = NIF_ICON | NIF_MESSAGE | NIF_TIP;
    Shell_NotifyIcon(NIM_ADD, &m_trayIcon);
    ShowWindow(SW_HIDE);
}
LRESULT CMainWnd::OnTrayIcon(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
    //如果在图标中单击左键则还原
    if(lParam == WM_LBUTTONDOWN)
    {
        //删除托盘图标
        Shell_NotifyIcon(NIM_DELETE, &m_trayIcon);
        //显示主窗口
        ShowWindow(SW_SHOWNORMAL);
        //窗口最大化
        SendMessage(WM_SYSCOMMAND, SC_MAXIMIZE, 0);
    }

    //如果在图标中单击右键则弹出声明式菜单
    if(lParam == WM_RBUTTONDOWN)
    {
        //获取鼠标坐标
        POINT pt;
        GetCursorPos(&pt);
        //右击后点别地可以清除“右击出来的菜单”
        SetForegroundWindow(m_hWnd);
        //托盘菜单    win32程序使用的是HMENU，如果是MFC程序可以使用CMenu
        HMENU hMenu;
        //生成托盘菜单
        hMenu = CreatePopupMenu();
        //添加菜单,关键在于设置的一个标识符  WM_ONCLOSE 点击后会用到
        AppendMenu(hMenu, MF_STRING, WM_ONCLOSE, _T("退出"));
        //弹出菜单,并把用户所选菜单项的标识符返回
        int cmd = TrackPopupMenu(hMenu, TPM_RETURNCMD, pt.x, pt.y, NULL, m_hWnd, NULL);

        //如果标识符是WM_ONCLOSE则关闭
        if(cmd == WM_ONCLOSE)
        {
            m_trayIcon.hIcon = NULL;
            Shell_NotifyIcon(NIM_DELETE, &m_trayIcon);
            //退出程序
            ::PostQuitMessage(0);
        }
    }

    bHandled = true;
    return 0;
}

void CMainWnd::LoginOut(int mode)
{
    CSetting::SetParam("setting_is_auto_login", "0", true);
    CLoginWnd* pLogin = new CLoginWnd();

    if(pLogin == NULL)
    {
        return;
    }

    //设置模式
    pLogin->SetMode(mode);
    pLogin->Create(NULL, _T("智铺子收银系统登录"), UI_WNDSTYLE_DIALOG, 0, 0, 0, 0, 0, NULL);
    pLogin->SetIcon(IDI_ICON_DUILIB);
    pLogin->CenterWindow();

    ::ShowWindow(*pLogin, SW_SHOWNORMAL);

    Close();
}

CMessagePush* CMainWnd::getMessagePush()
{
	return m_push;
}

void CMainWnd::SetInfopageWaimaiorderParam(std::string order_id, std::string order_no)
{
	m_infopage_waimaiorder_id = order_id;
	m_infopage_waimaiorder_no = order_no;
}

void CMainWnd::SetInfopageDianneiorderParam(std::string order_id)
{
	m_infopage_dianneiorder_id = order_id;
}

void CMainWnd::ShowToast(std::wstring toast_value)
{
	CToastWnd* pYouhuiDlg = new CToastWnd();

	if (pYouhuiDlg != NULL)
	{
		pYouhuiDlg->Create(m_pm.GetPaintWindow(), _T(""), UI_WNDSTYLE_DIALOG, WS_EX_WINDOWEDGE);
		pYouhuiDlg->SetIcon(IDI_ICON_DUILIB);
		pYouhuiDlg->CenterWindow();

		pYouhuiDlg->SetToast(toast_value);

		pYouhuiDlg->ShowWindow();
	}
}

//全局监听键盘输入
void CMainWnd::RegKeyboardRawInput()
{
	RAWINPUTDEVICE rawInputDevice[1];
	rawInputDevice[0].usUsagePage = 0x01;//设备类
	rawInputDevice[0].usUsage = 0x06;//设备类内的具体设备
	rawInputDevice[0].dwFlags = RIDEV_INPUTSINK;//意味着即使窗口失去焦点位置，仍然会一直接收输入消息
	rawInputDevice[0].hwndTarget = m_hWnd;
	if (RegisterRawInputDevices(rawInputDevice, 1, sizeof(rawInputDevice[0])) == FALSE)
	{
		printf("RegisterRawInputDevices failed");
	}
}