zhipuzi_pay_plugin/zhipuzi_pay_plugin/wnd/CValueWnd.cpp

#include "../pch/pch.h"
#include "CValueWnd.h"

#include "../tool/CComHelper.h"
#include "../tool/CSerialPort.h"
#include "../helper/CBitmapHelper.h"
#include "../network/CMessagePush.h"

#include "CLoginWnd.h"

void CValueWnd::Notify(TNotifyUI& msg)
{
    if(msg.sType == _T("click"))
    {
        if(msg.pSender->GetName() == _T("closebtn"))
        {
            PostQuitMessage(0);
            return;
        }
    }
}

void CValueWnd::Init()
{
    //初始化窗口位置
    InitWndPos();

	//抢焦点
	std::thread(&CValueWnd::TopMostWnd, this).detach();

	//注册热键
	UpdateRegisterHotKey();

    //添加托盘图标
    AddTrayIcon();

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

    //初始化菜单窗口
    pMenu = new CMenuWnd(this);
    pMenu->Create(NULL, L"智铺子收银插件菜单", WS_POPUP, WS_EX_TOOLWINDOW);
    pMenu->ShowWindow(false);

	//定位窗口的初始化
	pDingweiWnd = new CDingweiWnd();
	pDingweiWnd->Create(NULL, _T("智铺子收银插件窗口定位"), UI_WNDSTYLE_DIALOG, WS_EX_TOOLWINDOW, 0, 0, 0, 0, NULL);
	pDingweiWnd->ShowWindow(false);

	pDingweiInfoWnd = new CDingweiInfoWnd(this);
	pDingweiInfoWnd->Create(NULL, _T("智铺子收银插件窗口定位信息"), UI_WNDSTYLE_DIALOG, WS_EX_TOOLWINDOW, 0, 0, 0, 0, NULL);
	pDingweiInfoWnd->ShowWindow(false);

	//Ocr窗口初始化
	pOcrWnd = new COcrWnd(this);
	pOcrWnd->Create(NULL, _T("智铺子收银插件OCR定位"), UI_WNDSTYLE_FRAME, WS_EX_TOOLWINDOW , 0, 0, 0, 0, NULL);
	pOcrWnd->ShowWindow(false);

	//OCR的数据初始化
	if (m_tess.Init("./tessdata", "eng"))
	{
		LOG_INFO("OCRTesseract: Could not initialize tesseract.");
		MessageBox(m_hWnd, L"ocr语言库加载失败", L"错误", MB_OK);
	}

	m_tess.SetPageSegMode(tesseract::PageSegMode::PSM_SINGLE_LINE);
	m_tess.SetVariable("save_best_choices", "T");

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

    //再安装钩子
    BOOL ret = InstallHook();

    //开始启动监听
    RestartWatch();
}

/*
 *抢窗口前端，抢焦点
 **/
void CValueWnd::TopMostWnd()
{
	while (m_is_topmost)
	{
		::SetWindowPos(m_hWnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);

		if (m_is_show_shoukuan && m_shoukuanWnd != NULL)
		{
			//::SendMessage(m_shoukuanWnd->GetHWND(), WM_SHOUKUAN_UPDATE_FOCUS, NULL, NULL);
		}

		Sleep(100);
	}

	m_is_topmost = true;
}

void CValueWnd::StopTopMostWnd()
{
	m_is_topmost = false;

	while (m_is_topmost == false)
	{
		Sleep(120);
	}
}

void CValueWnd::RestartWatch()
{
	std::thread(&CValueWnd::StartWatchWork, this).detach();
}

void CValueWnd::StopWatch()
{
	m_isWatchWork = false;

	while (m_is_xunichuangkou_working || m_is_chuangkou_working || m_is_orc_working)
	{
		//等这3个线程全部退出
		Sleep(100);
	}
}

/*
 *根据当前数据库的设置，重启监听
 **/
void CValueWnd::StartWatchWork()
{
	//先暂停已有的监控
	StopWatch();

	//然后开始工作
	m_isWatchWork = true;

    std::string system_setting_jinezhuaqu_setting_type = CSetting::GetParam("system_setting_jinezhuaqu_setting_type");

    m_nWatchType = atoi(system_setting_jinezhuaqu_setting_type.c_str());

    if(m_nWatchType == 1)
    {
        //更新监听的端口号
        std::string system_setting_jinezhuaqu_setting_chuankou_num = CSetting::GetParam("system_setting_jinezhuaqu_setting_chuankou_num");

        if(system_setting_jinezhuaqu_setting_chuankou_num == "")
        {
            //参数错误
            return;
        }

        std::wstring ws_system_setting_jinezhuaqu_setting_chuankou_num = CLewaimaiString::UTF8ToUnicode(system_setting_jinezhuaqu_setting_chuankou_num);

        //设置窗口句柄
        ::SetHwnd(m_hWnd);

        //设置串口端口号
        std::transform(system_setting_jinezhuaqu_setting_chuankou_num.begin(), system_setting_jinezhuaqu_setting_chuankou_num.end(), system_setting_jinezhuaqu_setting_chuankou_num.begin(), ::toupper);
        std::transform(ws_system_setting_jinezhuaqu_setting_chuankou_num.begin(), ws_system_setting_jinezhuaqu_setting_chuankou_num.end(), ws_system_setting_jinezhuaqu_setting_chuankou_num.begin(), ::toupper);

        ::SetComNum(system_setting_jinezhuaqu_setting_chuankou_num.c_str(), ws_system_setting_jinezhuaqu_setting_chuankou_num.c_str(), system_setting_jinezhuaqu_setting_chuankou_num.size());
    }
    else if(m_nWatchType == 2)
    {
        //虚拟串口的模式
        std::thread(&CValueWnd::ReadXunichuankouValue, this).detach();
    }
    else if(m_nWatchType == 3)
    {
        //窗口模式
		m_watchWnd = NULL;

        std::thread(&CValueWnd::WatchWnd, this).detach();
    }
	else if (m_nWatchType == 4)
	{
		std::thread(&CValueWnd::StartOcrWork, this).detach();
	}
}

/*
 *读取客显金额的线程，一旦m_nWatchType不为2，那么就直接退出这个线程，下次设置的时候再开启
 **/
void CValueWnd::ReadXunichuankouValue()
{
    //读取虚拟串口的模式
    std::string system_setting_jinezhuaqu_setting_xunichuankou_num_2 = CSetting::GetParam("system_setting_jinezhuaqu_setting_xunichuankou_num_2");
    std::string system_setting_jinezhuaqu_setting_xunichuankou_botelv = CSetting::GetParam("system_setting_jinezhuaqu_setting_xunichuankou_botelv");

    CSerialPort serial(CLewaimaiString::UTF8ToUnicode(system_setting_jinezhuaqu_setting_xunichuankou_num_2), atoi(system_setting_jinezhuaqu_setting_xunichuankou_botelv.c_str()));

    bool ret = serial.openComm();

    if(!ret)
    {
        LOG_INFO("open com failed!");
        return;
    }

	m_is_xunichuangkou_working = true;

    char a[1024] = { 0 };

	//检查监控模式和波特率，如果变了就关闭掉
    while(m_nWatchType == 2 && m_isWatchWork)
    {
        memset(a, 0, 1024);

        //开始读取串口的数据
        DWORD nReaded = 0;

        serial.readFromComm(a, 1024, &nReaded);

        if(nReaded > 0)
        {
            UpdateKexian(a, nReaded);
        }

        Sleep(200);
    }

    serial.closeComm();

	m_is_xunichuangkou_working = false;
}

void CValueWnd::WatchWnd()
{
	m_is_chuangkou_working = true;

	std::string system_setting_jinezhuaqu_setting_chuangkou_process_name = CSetting::GetParam("system_setting_jinezhuaqu_setting_chuangkou_process_name");
	std::string system_setting_jinezhuaqu_setting_chuangkou_title = CSetting::GetParam("system_setting_jinezhuaqu_setting_chuangkou_title");
	std::string system_setting_jinezhuaqu_setting_chuangkou_zorder = CSetting::GetParam("system_setting_jinezhuaqu_setting_chuangkou_zorder");

	//如果模式变了，或者参数变了，就退出（因为会重新启动一个新的监控）
    while(m_nWatchType == 3 && m_isWatchWork)
    {
        if(m_watchWnd != NULL)
        {
			std::wstring value;

			TCHAR szTitle[MAX_PATH] = { 0 };
			LPWSTR lpWindowName = szTitle;     		

			int ret = ::SendMessageW(m_watchWnd, WM_GETTEXT, (WPARAM)(MAX_PATH), (LPARAM)lpWindowName);
            if(ret == 0)
            {
                //说明m_watchWnd已经失效了
                value = L"0.00";

                m_watchWnd = NULL;
            }
            else
            {
                value = lpWindowName;

				//先对获取到的值做一下处理，删除掉人民币符号
				CLewaimaiString::Replace(value, L"¥", L"");
            }

            if(value != m_watchValue)
            {
				//保存下来窗口获取到的值
                m_watchValue = value;

                SendMessage(WM_WATCH_WND_UPDATE, NULL, NULL);
            }
        }
        else
        {
            //获得进程名字
            std::wstring processName = CLewaimaiString::UTF8ToUnicode(system_setting_jinezhuaqu_setting_chuangkou_process_name);

            //根据进程名字，找到对应的主窗口
            HWND mainWnd = GetWndHwnd(processName.c_str(), system_setting_jinezhuaqu_setting_chuangkou_title);

            if(mainWnd ==  NULL)
            {
                //说明这个进程还没有启动
                m_watchWnd = NULL;
            }
            else
            {
                //根据Z序查找目标窗口               
                ValueWnd newWnd;
                newWnd.wndTitle = system_setting_jinezhuaqu_setting_chuangkou_title;
                newWnd.TopWnd = mainWnd;
                newWnd.z_order = atoi(system_setting_jinezhuaqu_setting_chuangkou_zorder.c_str());
                newWnd.processName = processName;
                newWnd.selfWnd = NULL;

                g_zorder = 0;

                EnumChildWindows(mainWnd, EnumMainwndChildProc, (LPARAM)(&newWnd));

                if(newWnd.selfWnd != NULL)
                {
                    //找到了
                    m_watchWnd = newWnd.selfWnd;
                }
            }
        }

        Sleep(200);
    }

	m_is_chuangkou_working = false;
}

void CValueWnd::StartOcrWork()
{
	m_is_orc_working = true;

	int system_setting_jinezhuaqu_setting_ocr_left = atoi(CSetting::GetParam("system_setting_jinezhuaqu_setting_ocr_left").c_str());
	int system_setting_jinezhuaqu_setting_ocr_top = atoi(CSetting::GetParam("system_setting_jinezhuaqu_setting_ocr_top").c_str());
	int system_setting_jinezhuaqu_setting_ocr_right = atoi(CSetting::GetParam("system_setting_jinezhuaqu_setting_ocr_right").c_str());
	int system_setting_jinezhuaqu_setting_ocr_bottom = atoi(CSetting::GetParam("system_setting_jinezhuaqu_setting_ocr_bottom").c_str());

	//如果模式变了，或者参数变了，就退出（因为会重新启动一个新的监控）
	while (m_nWatchType == 4 && m_isWatchWork)
	{
		RECT rect;
		rect.left = system_setting_jinezhuaqu_setting_ocr_left;
		rect.top = system_setting_jinezhuaqu_setting_ocr_top;
		rect.right = system_setting_jinezhuaqu_setting_ocr_right;
		rect.bottom = system_setting_jinezhuaqu_setting_ocr_bottom;

		if (IsRectEmpty(&rect))
		{
			
		}
		else
		{
			CBitmapHelper helper;

			std::string ocr_result;			
			bool ret = helper.OcrRect(m_tess, &rect, ocr_result);

			if (ret)
			{
				if (!atof(ocr_result.c_str()))
				{
					//识别结果不是有效的数字
					CLabelUI* valueLabel = static_cast<CLabelUI*>(m_pm.FindControl(_T("value")));

					valueLabel->SetText(L"0.00");
				}
				else
				{
					std::string format_value = CLewaimaiString::DoubleToString(atof(ocr_result.c_str()), 2);
					std::wstring ws_ocr_result = CLewaimaiString::UTF8ToUnicode(format_value);

					m_watchValue = ws_ocr_result;

					CLabelUI* valueLabel = static_cast<CLabelUI*>(m_pm.FindControl(_T("value")));

					valueLabel->SetText(ws_ocr_result.c_str());
				}
			}
		}

		Sleep(200);
	}

	m_is_orc_working = false;
}

LRESULT CValueWnd::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);

    m_pm.AddPreMessageFilter(this);

    CDialogBuilder builder;

    CControlUI* pRoot = builder.Create(_T("value.xml"), (UINT)0, NULL, &m_pm);
    ASSERT(pRoot && "Failed to parse XML");

    // 把这些控件绘制到本窗口上
    m_pm.AttachDialog(pRoot);

    // 把自己加入到CPaintManagerUI的m_aNotifiers数组中，用于处理Notify函数
    m_pm.AddNotifier(this);

    //进行一些初始化工作
    Init();

    return 0;
}

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

/*
 *这个是窗口被销毁的时候调用的
 **/
LRESULT CValueWnd::OnDestroy(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
    bHandled = FALSE;
    return 0;
}

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

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

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

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

LRESULT CValueWnd::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);

    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)
        {
            return HTCAPTION;
        }
    }

    return HTCLIENT;
}

LRESULT CValueWnd::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);

			string a = keytext;

			if (raw->data.keyboard.VKey >= 48 && raw->data.keyboard.VKey <= 57)
			{
				//只考虑数字
				if (m_is_start_catch == false)
				{
					m_is_start_catch = true;

					m_catch_string = "";

					char keytext[10] = { 0 };
					BYTE state[256] = { 0 };

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

					m_catch_string += string(keytext);

					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)
					{
						//如果超过了50ms，说明是人工输入的了，就重置所有状态
						m_is_start_catch = false;

						m_catch_string = "";
					}
					else
					{
						char keytext[10] = { 0 };
						BYTE state[256] = { 0 };

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

						m_catch_string += string(keytext);

						m_last_catch_clock = clock();
					}
				}
			}
			else if (raw->data.keyboard.VKey == 13)
			{
				//enter
				std::string last = m_catch_string;

				bool is_fukuanma = false;
				//判断是不是正常的付款码格式
				if (last.find("10") == 0 \
					|| last.find("11") == 0 \
					|| last.find("12") == 0 \
					|| last.find("13") == 0 \
					|| last.find("14") == 0 \
					|| last.find("15") == 0)
				{
					//微信付款码
					is_fukuanma = true;
				}
				else if (last.find("25") == 0 \
					|| last.find("26") == 0 \
					|| last.find("27") == 0 \
					|| last.find("28") == 0 \
					|| last.find("29") == 0 \
					|| last.find("30") == 0)
				{
					//支付宝付款码
					is_fukuanma = true;
				}

				if (is_fukuanma)
				{
					//得到一个合适的付款码
					if (m_is_show_shoukuan == false)
					{
						ShowShoukuan();
					}
				}				

				//不管是不是正常的付款码，收到enter后，这里都清空重来
				m_is_start_catch = false;
				m_catch_string = "";
			}
			else
			{
				//这种直接忽略，重新开始
				m_is_start_catch = false;

				m_catch_string = "";
			}
		}
	}
	delete[] lpbBuffer;

	bHandled = true;
	return 0;
}

LRESULT CValueWnd::OnLButtonDown(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
	pMenu->ShowWindow(false);

	bHandled = FALSE;
	return 0;
}

LRESULT CValueWnd::OnRButtonDown(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
	RECT rect;
	GetWindowRect(m_hWnd, &rect);

	::SetWindowPos(pMenu->GetHWND(), HWND_NOTOPMOST, rect.left, rect.bottom - 3, 0, 0, SWP_NOSIZE | SWP_NOACTIVATE);
	pMenu->ShowWindow(true);

	//右击后点别地可以清除“右击出来的菜单”
	SetForegroundWindow(pMenu->GetHWND());

	bHandled = FALSE;
	return 0;
}

LRESULT CValueWnd::OnKexianUpdate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
    //如果当前不是串口模式，直接忽略
    if(m_nWatchType != 1)
    {
        bHandled = TRUE;
        return true;
    }

    //收到了客显数据消息，读取客显数据
    char data[MAX_DATA_LENGTH] = { 0 };
    int data_length = 0;

    HookGetData(data, &data_length);

    if(data_length == 0)
    {
        bHandled = TRUE;
        return true;
    }

    UpdateKexian(data, data_length);

    bHandled = TRUE;
    return true;
}

LRESULT CValueWnd::OnWatchWndUpdate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
    CLabelUI* valueLabel = static_cast<CLabelUI*>(m_pm.FindControl(_T("value")));

	std::string utf8_watch_value = CLewaimaiString::UnicodeToUTF8(m_watchValue);

    std::string money_show = CLewaimaiString::DoubleToString(atof(utf8_watch_value.c_str()), 2);
    valueLabel->SetText(CLewaimaiString::UTF8ToUnicode(money_show).c_str());

    return TRUE;
}

LRESULT CValueWnd::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_NCLBUTTONDOWN:
        lRes = OnLButtonDown(uMsg, wParam, lParam, bHandled);
        break;

    case WM_NCRBUTTONDOWN:
        lRes = OnRButtonDown(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_SHOWTASK:
        lRes = OnTrayIcon(uMsg, wParam, lParam, bHandled);
        break;

    case WM_HOOK_MESSAGE:
        lRes = OnKexianUpdate(uMsg, wParam, lParam, bHandled);
        break;

    case WM_WATCH_WND_UPDATE:
        lRes = OnWatchWndUpdate(uMsg, wParam, lParam, bHandled);
        break;

	case WM_HOTKEY:
		lRes = OnHotKey(uMsg, wParam, lParam, bHandled);
		break;

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

    if(bHandled)
    {
        return lRes;
    }

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

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

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

void CValueWnd::ShowShoukuan()
{
	if (m_is_show_shoukuan == true)
	{
		return;
	}

	pMenu->ShowWindow(false);

	CShoukuanWnd* pShoukuanWnd = new CShoukuanWnd;
	if (pShoukuanWnd != NULL)
	{
		pShoukuanWnd->setValueWnd(this);

		pShoukuanWnd->Create(NULL, _T(""), UI_WNDSTYLE_DIALOG, WS_EX_TOOLWINDOW);
		pShoukuanWnd->SetIcon(IDI_ICON_DUILIB);
		pShoukuanWnd->CenterWindow();

		m_is_show_shoukuan = true;
		m_shoukuanWnd = pShoukuanWnd;

		//只要金额不为0，就初始化
		std::string utf8_watch_value = CLewaimaiString::UnicodeToUTF8(m_watchValue);
		if (atof(utf8_watch_value.c_str()) > 0.001)
		{			
			std::string format_string = CLewaimaiString::DoubleToString(atof(utf8_watch_value.c_str()), 2);
			m_watchValue = CLewaimaiString::UTF8ToUnicode(format_string);
			pShoukuanWnd->InitMoney(m_watchValue);
		}

		if (m_is_start_catch && m_catch_string.length() == 18)
		{
			pShoukuanWnd->InitFukuanma(m_catch_string);
		}

		pShoukuanWnd->ShowWindow(true);
	}
}

void CValueWnd::CloseShoukuan(bool isSuccess)
{
	m_is_show_shoukuan = false;

	m_shoukuanWnd->Close();
	m_shoukuanWnd = NULL;

	if (isSuccess)
	{
		//开始执行自动清台
		CCheckBoxUI* zidongqingtai_setting_work = static_cast<CCheckBoxUI*>(m_pm.FindControl(L"zidongqingtai_setting_work"));
		std::string zidongqingtai_is_work = CSetting::GetParam("zidongqingtai_is_work");

		if (zidongqingtai_is_work == "0")
		{
			return;
		}

		std::thread(&CValueWnd::HandleZidongqingtai, this).detach();
	}
}

void CValueWnd::HandleZidongqingtai()
{
	std::string zidongqingtai_time = CSetting::GetParam("zidongqingtai_time");
	int time = atoi(zidongqingtai_time.c_str());

	std::string zidongqingtai_num = CSetting::GetParam("zidongqingtai_num");
	int num = atoi(zidongqingtai_num.c_str());

	std::string zidongqingtai_huitian = CSetting::GetParam("zidongqingtai_huitian");
	int huitian = atoi(zidongqingtai_huitian.c_str());

	UINT zidongqingtai_kuaijiejian_1_mod = (UINT)atoi(CSetting::GetParam("zidongqingtai_kuaijiejian_1_mod").c_str());
	UINT zidongqingtai_kuaijiejian_1_vk = (UINT)atoi(CSetting::GetParam("zidongqingtai_kuaijiejian_1_vk").c_str());

	UINT zidongqingtai_kuaijiejian_2_mod = (UINT)atoi(CSetting::GetParam("zidongqingtai_kuaijiejian_2_mod").c_str());
	UINT zidongqingtai_kuaijiejian_2_vk = (UINT)atoi(CSetting::GetParam("zidongqingtai_kuaijiejian_2_vk").c_str());

	UINT zidongqingtai_kuaijiejian_3_mod = (UINT)atoi(CSetting::GetParam("zidongqingtai_kuaijiejian_3_mod").c_str());
	UINT zidongqingtai_kuaijiejian_3_vk = (UINT)atoi(CSetting::GetParam("zidongqingtai_kuaijiejian_3_vk").c_str());

	if (num >= 1)
	{
		//开始执行第一步
		Sleep(time);

		if (zidongqingtai_kuaijiejian_1_mod > 0)
		{
			CSystem::RunHotKey(zidongqingtai_kuaijiejian_1_mod, zidongqingtai_kuaijiejian_1_vk);
		}

		if (huitian == 1)
		{
			//这里开始执行回填
		}
	}	

	if (num >= 2)
	{
		//需要执行第二步
		Sleep(time);

		if (zidongqingtai_kuaijiejian_2_mod > 0)
		{
			CSystem::RunHotKey(zidongqingtai_kuaijiejian_2_mod, zidongqingtai_kuaijiejian_2_vk);
		}
	}

	if (num >= 3)
	{
		//需要执行第二步
		Sleep(time);

		if (zidongqingtai_kuaijiejian_3_mod > 0)
		{
			CSystem::RunHotKey(zidongqingtai_kuaijiejian_3_mod, zidongqingtai_kuaijiejian_3_vk);
		}
	}
}

void CValueWnd::ShowTuikuan()
{
	if (m_is_show_tuikuan == true)
	{
		return;
	}

	pMenu->ShowWindow(false);

	CTuikuanWnd* pTuikuanWnd = new CTuikuanWnd;
	if (pTuikuanWnd != NULL)
	{
		pTuikuanWnd->setValueWnd(this);

		pTuikuanWnd->Create(NULL, _T(""), UI_WNDSTYLE_DIALOG, WS_EX_TOOLWINDOW);
		pTuikuanWnd->SetIcon(IDI_ICON_DUILIB);
		pTuikuanWnd->CenterWindow();

		m_is_show_tuikuan = true;
		m_tuikuanWnd = pTuikuanWnd;

		//只要金额不为0，就初始化
		std::string utf8_watch_value = CLewaimaiString::UnicodeToUTF8(m_watchValue);
		if (false)
		{
			std::string format_string = CLewaimaiString::DoubleToString(atof(utf8_watch_value.c_str()), 2);
			m_watchValue = CLewaimaiString::UTF8ToUnicode(format_string);
			pTuikuanWnd->InitMoney(m_watchValue);
		}

		pTuikuanWnd->ShowWindow();
	}
}

void CValueWnd::CloseTuikuan()
{
	m_is_show_tuikuan = false;

	m_tuikuanWnd->Close();
	m_tuikuanWnd = NULL;
}

void CValueWnd::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);
}

LRESULT CValueWnd::OnTrayIcon(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
    //如果在图标中单击左键则还原
    if(lParam == WM_LBUTTONDOWN)
    {
		ShowTrayMenu();
    }
    //如果在图标中单击右键则弹出声明式菜单
    else if(lParam == WM_RBUTTONDOWN)
    {
        ShowTrayMenu();
    }

    bHandled = true;
    return 0;
}

LRESULT CValueWnd::OnHotKey(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
	UINT  fuModifiers = (UINT)LOWORD(lParam);
	UINT  uVirtKey = (UINT)HIWORD(lParam);

	if (m_is_show_setting)
	{
		//如果当前在设置页面，就不处理快捷键消息，避免影响快捷键的重新设置

		bHandled = FALSE;
		return 0;
	}

	//判断响应了什么热键   
	if (wParam == WM_MYHOTKEY_SHOUKUAN)
	{
		if (m_is_show_shoukuan == false)
		{
			ShowShoukuan();
		}
		else
		{
			CloseShoukuan();
		}
	}
	else if (wParam == WM_MYHOTKEY_TUIKUAN)
	{
		if (m_is_show_tuikuan == false)
		{
			ShowTuikuan();
		}
		else
		{
			CloseTuikuan();
		}
	}
	else if (wParam == WM_MYHOTKEY_JIAOYIJILU)
	{
		if (m_is_show_jiaoyijilu == false)
		{
			ShowJiaoyijilu();
		}
		else
		{
			CloseJiaoyijilu();
		}
	}
	else if (wParam == WM_MYHOTKEY_JIAOYIHUIZONG)
	{
		if (m_is_show_jiaoyihuizong == false)
		{
			ShowJiaoyihuizong();
		}
		else
		{
			CloseJiaoyihuizong();
		}
	}
	else if (wParam == WM_MYHOTKEY_JIAOBAN)
	{
		if (m_is_show_jiaoban == false)
		{
			ShowJiaoban();
		}
		else
		{
			CloseJiaoban();
		}
	}
	else if (wParam == WM_MYHOTKEY_SHEZHI)
	{
		if (m_is_show_setting == false)
		{
			ShowSystemSetting();
		}
		else
		{
			CloseSystemSetting();
		}
	}

	bHandled = TRUE;
	return  0;
}

void CValueWnd::ShowSystemSetting()
{
	//先隐藏目录
	pMenu->ShowWindow(false);

	//然后判断和显示系统设置
	if (m_is_show_setting == true)
	{
		return;
	}

	CSystemSettingWnd* pSystemSettingFrame = new CSystemSettingWnd(this);
	m_settingWnd = pSystemSettingFrame;

	if (pSystemSettingFrame != NULL)
	{
		m_is_show_setting = true;

		pSystemSettingFrame->Create(NULL, _T(""), UI_WNDSTYLE_DIALOG, WS_EX_TOOLWINDOW);
		pSystemSettingFrame->SetIcon(IDI_ICON_DUILIB);
		pSystemSettingFrame->CenterWindow();
		pSystemSettingFrame->ShowWindow(true);
	}
}

void CValueWnd::CloseSystemSetting()
{
	m_is_show_setting = false;

	m_settingWnd->Close();
	m_settingWnd = NULL;
}

void CValueWnd::ShowJiaoyijilu()
{
	//先隐藏目录
	pMenu->ShowWindow(false);

	//然后判断和显示系统设置
	if (m_is_show_jiaoyijilu == true)
	{
		return;
	}

	CJiaoyijiluWnd* pJiaoyijiluFrame = new CJiaoyijiluWnd(this);
	m_jiaoyijiluWnd = pJiaoyijiluFrame;

	if (pJiaoyijiluFrame != NULL)
	{
		m_is_show_jiaoyijilu = true;

		pJiaoyijiluFrame->Create(NULL, _T(""), UI_WNDSTYLE_DIALOG, WS_EX_TOOLWINDOW);
		pJiaoyijiluFrame->SetIcon(IDI_ICON_DUILIB);
		pJiaoyijiluFrame->CenterWindow();
		pJiaoyijiluFrame->ShowWindow(true);
	}
}

void CValueWnd::CloseJiaoyijilu()
{
	m_is_show_jiaoyijilu = false;

	m_jiaoyijiluWnd->Close();
	m_jiaoyijiluWnd = NULL;
}

void CValueWnd::ShowJiaoyihuizong()
{
	//先隐藏目录
	pMenu->ShowWindow(false);

	//然后判断和显示系统设置
	if (m_is_show_jiaoyihuizong == true)
	{
		return;
	}

	CJiaoyihuizongWnd* pjiaoyihuizongFrame = new CJiaoyihuizongWnd(this);
	m_jiaoyihuizongWnd = pjiaoyihuizongFrame;

	if (pjiaoyihuizongFrame != NULL)
	{
		m_is_show_jiaoyihuizong = true;

		pjiaoyihuizongFrame->Create(NULL, _T(""), UI_WNDSTYLE_DIALOG, WS_EX_TOOLWINDOW);
		pjiaoyihuizongFrame->SetIcon(IDI_ICON_DUILIB);
		pjiaoyihuizongFrame->CenterWindow();
		pjiaoyihuizongFrame->ShowWindow(true);		
	}
}

void CValueWnd::CloseJiaoyihuizong()
{
	m_is_show_jiaoyihuizong = false;

	m_jiaoyihuizongWnd->Close();
	m_jiaoyihuizongWnd = NULL;
}

void CValueWnd::ShowJiaoban()
{
	//先隐藏目录
	pMenu->ShowWindow(false);

	//然后判断和显示系统设置
	if (m_is_show_jiaoban == true)
	{
		return;
	}

	CJiaobanWnd* pjiaobanFrame = new CJiaobanWnd(this);
	m_jiaobanWnd = pjiaobanFrame;

	if (pjiaobanFrame != NULL)
	{
		m_is_show_jiaoban = true;

		pjiaobanFrame->setValueWnd(this);

		pjiaobanFrame->Create(NULL, _T(""), UI_WNDSTYLE_DIALOG, WS_EX_TOOLWINDOW);
		pjiaobanFrame->SetIcon(IDI_ICON_DUILIB);
		pjiaobanFrame->CenterWindow();
		pjiaobanFrame->ShowWindow(true);		
	}
}

void CValueWnd::CloseJiaoban()
{
	m_is_show_jiaoban = false;

	m_jiaobanWnd->Close();
	m_jiaobanWnd = NULL;
}

/*
 *执行退出前的清理工作，暂停所有工作线程，清理对象
 *返回true表示清理成功，返回false表示清理失败
 **/
bool CValueWnd::Clear()
{
	if (m_is_show_shoukuan || m_is_show_tuikuan)
	{
		//如果收款和退款窗口都没关闭，不允许进行清理
		return false;
	}

	//清理窗口
	if (m_is_show_jiaoyijilu)
	{
		CloseJiaoyijilu();
	}

	if (m_is_show_jiaoyihuizong)
	{
		CloseJiaoyihuizong();
	}

	if (m_is_show_jiaoban)
	{
		CloseJiaoban();
	}

	if (m_is_show_setting)
	{
		CloseSystemSetting();
	}

	//清理抢焦点的
	StopTopMostWnd();
	
	//取消注册的快捷键
	UnregisterHotKey(m_hWnd, WM_MYHOTKEY_SHOUKUAN);
	UnregisterHotKey(m_hWnd, WM_MYHOTKEY_TUIKUAN);
	UnregisterHotKey(m_hWnd, WM_MYHOTKEY_JIAOYIJILU);
	UnregisterHotKey(m_hWnd, WM_MYHOTKEY_JIAOYIHUIZONG);
	UnregisterHotKey(m_hWnd, WM_MYHOTKEY_JIAOBAN);
	UnregisterHotKey(m_hWnd, WM_MYHOTKEY_SHEZHI);

	//删除右下角的托盘
	Shell_NotifyIcon(NIM_DELETE, &m_trayIcon);

	//注意这里不能delete，这个对象会delete自己
	m_push->Stop();

	pMenu->Close();

	pDingweiWnd->Close();

	pDingweiInfoWnd->Close();

	pOcrWnd->Close();

	//注销Hook
	UninstallHook();

	//暂停数据监控
	StopWatch();

	this->Close();

	return true;
}

void CValueWnd::Logout()
{
	if (!this->Clear())
	{
		return;
	}

	//退出登录，取消自动登录
	CSetting::SetParam("setting_is_auto_login", "0", true);

	//创建登录窗口
	CLoginWnd* pLogin = new CLoginWnd();
	if (pLogin == NULL)
	{
		return;
	}

	pLogin->Create(NULL, _T("智铺子收银插件登录"), UI_WNDSTYLE_DIALOG, WS_EX_TOOLWINDOW, 0, 0, 0, 0, NULL);
	pLogin->SetIcon(IDI_ICON_DUILIB);
	pLogin->CenterWindow();

	pLogin->ShowWindow(true);
}

void CValueWnd::QuitApp()
{
	if (!this->Clear())
	{
		return;
	}

	//直接退出整个程序
	PostQuitMessage(0);
}

void CValueWnd::UpdateKexian(const char* data, int length)
{
    std::string new_data = data;

    //清屏命令
    std::string clear_command = "\f";

    //4个信号灯全灭
    std::string quanmie_command = "\x1bs0";

	//初始化命令
	std::string init_command = "\x1b\x40";

	//实际读取金额用到的命令
    std::string show_command = "\x1bQA";
	std::string show_command_2 = "QA";
    std::string type_command = "\x1bs";

    if(new_data == clear_command || new_data == quanmie_command || new_data == init_command)
    {
        //清屏命令，或者是熄灭灯的命令
        return;
    }

	int nShowType;
    if(new_data.find(show_command) == new_data.npos)
    {
		//没有\x1bQA，继续找有没有QA（比如思迅）
		if (new_data.find(show_command_2) == new_data.npos)
		{
			//完全没QA
			return;
		}
		else
		{
			nShowType = 2;
		}
    }
	else
	{
		nShowType = 1;
	}

    std::string money;

	int nPos;
	
	if (nShowType == 1)
	{
		nPos = new_data.find(show_command);;
	}
	else
	{
		nPos = new_data.find(show_command_2);
	}	

    int nTypePos = new_data.find(type_command, nPos + 1);

    if(nTypePos == new_data.npos)
    {
        //没有类型信息，有些收银机（比如思迅天店）就是不传类型信息，这种只有传什么显示什么了
        int nTabPos = new_data.find("\r", nPos + 1);

        if(nTabPos == new_data.npos)
        {
            //制表符也没有
            return;
        }

		if (nShowType == 1)
		{
			money = new_data.substr(nPos + 3, nTabPos - nPos - 3);
		}
		else
		{
			money = new_data.substr(nPos + 2, nTabPos - nPos - 2);
		}

        CLabelUI* valueLabel = static_cast<CLabelUI*>(m_pm.FindControl(_T("value")));

        std::string money_show = CLewaimaiString::DoubleToString(atof(money.c_str()), 2);
		m_watchValue = CLewaimaiString::UTF8ToUnicode(money_show);

        valueLabel->SetText(CLewaimaiString::UTF8ToUnicode(money_show).c_str());
    }
    else
    {
        std::string value_type = new_data.substr(nTypePos + 2, 1);
        money = new_data.substr(nPos + 3, nTypePos - nPos - 3 - 1);

        if(value_type == "2")
        {
            //这个表示是总计的，那么就要刷新金额显示
            CLabelUI* valueLabel = static_cast<CLabelUI*>(m_pm.FindControl(_T("value")));

            std::string money_show = CLewaimaiString::DoubleToString(atof(money.c_str()), 2);
			m_watchValue = CLewaimaiString::UTF8ToUnicode(money_show);

            valueLabel->SetText(CLewaimaiString::UTF8ToUnicode(money_show).c_str());
        }
        else
        {
            //这种情况传输的是一些找零、单价之类的信息，不更新客显金额
        }
    }

    return;
}

void CValueWnd::InitWndPos()
{
	ASSERT(::IsWindow(m_hWnd));
	ASSERT((GetWindowStyle(m_hWnd)&WS_CHILD) == 0);

	RECT rcDlg = { 0 };
	::GetWindowRect(m_hWnd, &rcDlg);

	int DlgWidth = rcDlg.right - rcDlg.left;
	int DlgHeight = rcDlg.bottom - rcDlg.top;

	RECT rcArea = { 0 };
	::GetWindowRect(::GetDesktopWindow(), &rcArea);

    int xLeft = rcArea.right - DlgWidth - 60;
    int yTop = 100;

    if(xLeft < rcArea.left)
    {
        xLeft = rcArea.left;
    }
    else if(xLeft + DlgWidth > rcArea.right)
    {
        xLeft = rcArea.right - DlgWidth;
    }

    if(yTop < rcArea.top)
    {
        yTop = rcArea.top;
    }
    else if(yTop + DlgHeight > rcArea.bottom)
    {
        yTop = rcArea.bottom - DlgHeight;
    }

    ::SetWindowPos(m_hWnd, HWND_TOPMOST, xLeft, yTop, 0, 0, SWP_NOSIZE | SWP_NOACTIVATE);
}

void CValueWnd::ShowTrayMenu()
{
    //获取鼠标坐标
    POINT pt;
    GetCursorPos(&pt);

	CRect rect;
	GetWindowRect(pMenu->GetHWND(), &rect);

	int height = rect.bottom - rect.top;

    //显示目录
	::SetWindowPos(pMenu->GetHWND(), HWND_NOTOPMOST, pt.x, pt.y - 15 - height, 0, 0, SWP_NOSIZE | SWP_NOACTIVATE);
	pMenu->ShowWindow(true);

	SetFocus(pMenu->GetHWND());

	//右击后点别地可以清除“右击出来的菜单”
	SetForegroundWindow(pMenu->GetHWND());
}

void CValueWnd::StartDingweiWnd()
{
	m_settingWnd->ShowWindow(false);

	m_is_dingwei_wnd = true;

	std::thread(&CValueWnd::StartDingweiWork, this).detach();
}

void CValueWnd::ConfirmDingweiWnd(std::wstring value, HWND hWnd)
{
	m_is_dingwei_wnd = false;

	m_settingWnd->SetDingweiWnd(value, hWnd);
}

void CValueWnd::CancalDingweiWnd()
{
	m_is_dingwei_wnd = false;
}

void CValueWnd::StartDingweiWork()
{
	while (m_is_dingwei_wnd)
	{
		//这个时候，是开始定位窗口了
		POINT pt;

		GetCursorPos(&pt);

		//将屏幕坐标保存起来
		POINT ptScreen = pt;

		//转换成桌面坐标
		HWND hDeskHandle = GetDesktopWindow();
		ScreenToClient(hDeskHandle, &pt);

		HWND hParent = hDeskHandle;
		HWND hChild = ChildWindowFromPointEx(hParent, pt, CWP_SKIPINVISIBLE | CWP_SKIPTRANSPARENT | CWP_SKIPDISABLED);

		if (hChild == pDingweiInfoWnd->GetHWND())
		{
			//这里表示是移动信息窗口了，这里就不要执行后面的刷新操作了
		}
		else
		{
			while (hChild != NULL && hChild != hParent)
			{
				//说明还有更下级的子窗口
				hParent = hChild;

				pt = ptScreen;
				ScreenToClient(hParent, &pt);

				hChild = ChildWindowFromPointEx(hParent, pt, CWP_SKIPINVISIBLE | CWP_SKIPTRANSPARENT);
			}

			HWND hWnd = hParent;

			RECT rect;
			GetWindowRect(hWnd, &rect);

			//在这个窗口上，画一个边框
			pDingweiWnd->ShowWindow(true);
			::SetWindowPos(pDingweiWnd->GetHWND(), HWND_TOPMOST, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, SWP_NOACTIVATE);

			//显示定位信息
			TCHAR szTitle[MAX_PATH] = { 0 };
			LPWSTR lpWindowName = szTitle;

			::SendMessageW(hWnd, WM_GETTEXT, (WPARAM)(MAX_PATH), (LPARAM)lpWindowName);

			//设置信息窗口的内容
			pDingweiInfoWnd->UpdateInfo(lpWindowName, hWnd);

			pDingweiInfoWnd->ShowWindow(true);

			int nWidth = rect.right - rect.left;
			if (nWidth < 380)
			{
				nWidth = 380;
			}

			::SetWindowPos(pDingweiInfoWnd->GetHWND(), HWND_TOPMOST, rect.left, rect.bottom, nWidth, 36, SWP_NOACTIVATE);
		}

		Sleep(100);
	}

	m_settingWnd->ShowWindow(true);
	pDingweiWnd->ShowWindow(false);
	pDingweiInfoWnd->ShowWindow(false);
}

void CValueWnd::StartOcrWnd()
{
	m_settingWnd->ShowWindow(false);

	m_is_orc_wnd = true;

	pOcrWnd->ShowWindow(true);

	//先默认居中
	::SetWindowPos(pOcrWnd->GetHWND(), HWND_TOPMOST, 0, 0, 320, 80, SWP_NOMOVE | SWP_NOACTIVATE);
	pOcrWnd->CenterWindow();
}

void CValueWnd::ConfirmOcrWnd(RECT rect)
{
	m_is_orc_wnd = false;
	pOcrWnd->ShowWindow(false);

	//保存截屏的结果
	m_settingWnd->SetOcrWnd(rect);

	//显示设置窗口
	m_settingWnd->ShowWindow(true);
}

void CValueWnd::CancelOcr()
{
	m_is_orc_wnd = false;
	pOcrWnd->ShowWindow(false);

	//显示设置窗口
	m_settingWnd->ShowWindow(true);
}

tesseract::TessBaseAPI& CValueWnd::GetTess()
{
	return m_tess;
}

void CValueWnd::UpdateRegisterHotKey()
{	
	//收款
	UINT shoukuan_mod = (UINT)atoi(CSetting::GetParam("system_setting_kuaijiejian_shoukuan_mod").c_str());
	UINT shoukuan_vk = (UINT)atoi(CSetting::GetParam("system_setting_kuaijiejian_shoukuan_vk").c_str());

	//先卸载旧的，再注册新的
	UnregisterHotKey(m_hWnd, WM_MYHOTKEY_SHOUKUAN);

	RegisterHotKey(m_hWnd, WM_MYHOTKEY_SHOUKUAN, shoukuan_mod, shoukuan_vk);

	//退款
	UINT tuikuan_mod = (UINT)atoi(CSetting::GetParam("system_setting_kuaijiejian_tuikuan_mod").c_str());
	UINT tuikuan_vk = (UINT)atoi(CSetting::GetParam("system_setting_kuaijiejian_tuikuan_vk").c_str());

	//先卸载旧的，再注册新的
	UnregisterHotKey(m_hWnd, WM_MYHOTKEY_TUIKUAN);

	RegisterHotKey(m_hWnd, WM_MYHOTKEY_TUIKUAN, tuikuan_mod, tuikuan_vk);

	//交易记录
	UINT jiaoyijilu_mod = (UINT)atoi(CSetting::GetParam("system_setting_kuaijiejian_jiaoyijilu_mod").c_str());
	UINT jiaoyijilu_vk = (UINT)atoi(CSetting::GetParam("system_setting_kuaijiejian_jiaoyijilu_vk").c_str());

	//先卸载旧的，再注册新的
	UnregisterHotKey(m_hWnd, WM_MYHOTKEY_JIAOYIJILU);

	RegisterHotKey(m_hWnd, WM_MYHOTKEY_JIAOYIJILU, jiaoyijilu_mod, jiaoyijilu_vk);

	//交易汇总
	UINT jiaoyihuizong_mod = (UINT)atoi(CSetting::GetParam("system_setting_kuaijiejian_jiaoyihuizong_mod").c_str());
	UINT jiaoyihuizong_vk = (UINT)atoi(CSetting::GetParam("system_setting_kuaijiejian_jiaoyihuizong_vk").c_str());

	//先卸载旧的，再注册新的
	UnregisterHotKey(m_hWnd, WM_MYHOTKEY_JIAOYIHUIZONG);

	RegisterHotKey(m_hWnd, WM_MYHOTKEY_JIAOYIHUIZONG, jiaoyihuizong_mod, jiaoyihuizong_vk);

	//交班
	UINT jiaoban_mod = (UINT)atoi(CSetting::GetParam("system_setting_kuaijiejian_jiaoban_mod").c_str());
	UINT jiaoban_vk = (UINT)atoi(CSetting::GetParam("system_setting_kuaijiejian_jiaoban_vk").c_str());

	//先卸载旧的，再注册新的
	UnregisterHotKey(m_hWnd, WM_MYHOTKEY_JIAOBAN);

	RegisterHotKey(m_hWnd, WM_MYHOTKEY_JIAOBAN, jiaoban_mod, jiaoban_vk);

	//设置
	UINT shezhi_mod = (UINT)atoi(CSetting::GetParam("system_setting_kuaijiejian_shezhi_mod").c_str());
	UINT shezhi_vk = (UINT)atoi(CSetting::GetParam("system_setting_kuaijiejian_shezhi_vk").c_str());

	//先卸载旧的，再注册新的
	UnregisterHotKey(m_hWnd, WM_MYHOTKEY_SHEZHI);

	RegisterHotKey(m_hWnd, WM_MYHOTKEY_SHEZHI, shezhi_mod, shezhi_vk);
}

//全局监听键盘输入
void CValueWnd::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");
	}
}

void CValueWnd::PrintTest()
{
	m_push->AddPrinter("", 3);
}

void CValueWnd::PrintZhifu(std::string out_trade_no)
{
	m_push->AddPrinter(out_trade_no, 1);
}

void CValueWnd::PrintTuikuan(std::string out_trade_no)
{
	m_push->AddPrinter(out_trade_no, 2);
}

void CValueWnd::PrintJiaoban(CJiaobanMessage& message)
{
	m_push->AddPrinter(message);
}