zhipuzi_pos_windows/zhipuzi_pos_windows/wnd/CMainWnd.cpp

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

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

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

#include <urlmon.h>

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

#include "../worker/CMqttClientWorker.h"

#include "../worker/CChengzhongWorker.h"
#include "../worker/CDiandanAIShibieWorker.h"

#include "../wnd/CImageAttentionWnd.h"

#include "../tool/CSqlite3.h"

#include "../tool/CShuangpingTool.h"

void CMainWnd::Init()
{
	//初始化副屏
	CShuangpingTool::GetInstance()->InitWnd(GetHWND());

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

	//设置推送的消息窗口
	CMqttClientWorker::GetInstance()->SetHWND(GetHWND());

	//启动消息推送
	CMqttClientWorker::GetInstance()->Start();

	//给称重Worker设置窗口句柄
	CChengzhongWorker::GetInstance()->SetMainHWND(GetHWND());

	//设置AI识别消息窗口
	CDiandanAIShibieWorker::GetInstance()->SetHWND(GetHWND());

	//初始化所有页面，先创建页面对象，避免切换页面的时候被释放了
	CreatePages();

	//初始化左侧的功能的导航（一定要先初始化页面，再初始化导航，因为初始化导航的时候也会初始化默认选中的页面）
	UpdateGongnengDaohang();

    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")));

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

	//注册热键
	UpdateRegisterHotKey();

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

	//手动关闭一次键盘，避免被手动打开了
	//CSystem::HideSystemKeyboard();
}

void CMainWnd::End()
{
	//停止消息推送
	CMqttClientWorker::GetInstance()->Stop();

	//停止AI学习页面的摄像头线程
	CAIxuexiPageUI* page = static_cast<CAIxuexiPageUI*>(this->GetPage(CMainWnd::AIXUEXI));
	page->StopVideoThread();

	//停止设置页面的摄像头线程
	CSettingPageUI* settingPage = static_cast<CSettingPageUI*>(this->GetPage(CMainWnd::SETTING));
	settingPage->StopVideoThread();
}

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

	CSqlite3 sqlite;
	std::vector<CFood> foodlist = sqlite.GetAllFood();
	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"; //下载小图

		std::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();
	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"; //下载小图

		std::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, bool is_init_show)
{
	if (m_curPageName == name)
	{
		return;
	}

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

	if (m_curPageName != NOPAGE)
	{
		//这个是之前已经有一个页面了，切换页面，不能销毁之前的页面，否则容易崩溃
		pMainContentLayout->Remove(m_curPageUI);
	}

	CBasePageUI* pChildContainer = m_pages[name];

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

	m_curPageName = name;
	m_curPageUI = pChildContainer;

	if (is_init_show)
	{
		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);

	//执行完初始化，再绑定事件，避免事件触发时，页面还没有完全，特别是设置中心的初始化不能触发事件
	Init();

    m_pm.AddNotifier(this);

	//this->SetPaintWindow(m_pm.GetPaintWindow()); // 或类似方式获取 paint 窗口句柄
    return 0;
}

void CMainWnd::Notify(TNotifyUI& msg)
{
	CDuiString name = msg.pSender->GetName();
	std::wstring senderName = name;
	std::wstring senderClassName = msg.pSender->GetClass();

    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"))
    {
        HandleClickMsg(msg);
    }
    else if(msg.sType == _T("itemactivate"))
    {
    }
    else if(msg.sType == _T("itemselect"))
    {
        HandleItemSelectMsg(msg);
    }
	else if (msg.sType == _T("textchanged"))
	{
		//编辑框内容改变事件
		HandleTextChangedMsg(msg);
	}
	else if (msg.sType == _T("killfocus"))
	{
		//处理快捷键设置的状态问题
		if (senderName.find(L"setting_kuaijiejian_page_btn_") == 0)
		{
			m_IsKuaijiejian = false;
		}

		if (senderClassName == L"EditUI")
		{
			CSystem::HideSystemKeyboard();

			// 点餐页/预包装标签页商品搜索框：失去焦点且内容为空时恢复占位提示语
			LPCTSTR szEditName = NULL;
			LPCTSTR szTishiName = NULL;
			if (name == _T("diandan_food_search_edit"))
			{
				szEditName = _T("diandan_food_search_edit");
				szTishiName = _T("diandan_food_search_tishi");
			}
			else if (name == _T("saomashouyin_food_search_edit"))
			{
				szEditName = _T("saomashouyin_food_search_edit");
				szTishiName = _T("saomashouyin_food_search_tishi");
			}
			else if (name == _T("yubaozhuangbiaoqian_food_search_edit"))
			{
				szEditName = _T("yubaozhuangbiaoqian_food_search_edit");
				szTishiName = _T("yubaozhuangbiaoqian_food_search_tishi");
			}

			if (szEditName != NULL && szTishiName != NULL)
			{
				CControlUI* pEdit = m_pm.FindControl(szEditName);
				CControlUI* pTishi = m_pm.FindControl(szTishiName);
				if (pEdit != NULL && pTishi != NULL)
				{
					if (pEdit->GetText().IsEmpty()) pTishi->SetVisible(true);
				}
			}
		}
	}
	else if (msg.sType == _T("setfocus"))
	{
		if (senderClassName == L"EditUI")
		{
			if (CSetting::GetInstance()->GetParam("setting_xianshi_is_chumojianpan") == "1")
			{
				CSystem::ShowSystemKeyboard(m_hWnd);
			}

			// 点餐页/预包装标签页商品搜索框：获得焦点即隐藏占位提示语，避免与光标/输入文字重叠
			LPCTSTR szTishiName = NULL;
			if (name == _T("diandan_food_search_edit"))
			{
				szTishiName = _T("diandan_food_search_tishi");
			}
			else if (name == _T("saomashouyin_food_search_edit"))
			{
				szTishiName = _T("saomashouyin_food_search_tishi");
			}
			else if (name == _T("yubaozhuangbiaoqian_food_search_edit"))
			{
				szTishiName = _T("yubaozhuangbiaoqian_food_search_tishi");
			}

			if (szTishiName != NULL)
			{
				CControlUI* pTishi = m_pm.FindControl(szTishiName);
				if (pTishi != NULL) pTishi->SetVisible(false);
			}
		}
	}
}

void CMainWnd::HandleClickMsg(TNotifyUI& msg)
{
	CDuiString name = msg.pSender->GetName();

    if(msg.pSender == m_pCloseBtn)
    {
        if(CSetting::GetInstance()->GetParam("setting_is_close_min") == "1")
        {
            AddTrayIcon();
        }
        else
        {
			QuitApp();
        }

        return;
    }
    else if(msg.pSender == m_pMinBtn)
    {
        PostMessage(WM_SYSCOMMAND, SC_MINIMIZE, 0);
        return;
    }
    else if(msg.pSender == m_pMaxBtn)
    {
        PostMessage(WM_SYSCOMMAND, SC_MAXIMIZE, 0);
        return;
    }
    else if(msg.pSender == m_pRestoreBtn)
    {
        PostMessage(WM_SYSCOMMAND, SC_RESTORE, 0);
        return;
    }
	else if (name == L"main_kefubtn")
	{
		//展示客服二维码
		this->ShowKefu();
	}
	else if (name == L"main_appbtn")
	{
		this->ShowAppDownload();
	}
	else if (name == L"main_shangchengbtn")
	{
		this->ShowShangcheng();
	}
	else if (name == L"main_web_login_btn")
	{
		ShellExecute(NULL, _T("open"), _T("explorer.exe"), _T("https://www.zhipuzi.com/login.html"), NULL, SW_SHOW);
	}
    else if(name == _T("quitbtn"))
    {
		QuitApp();
    }
	else
	{
		if (this->m_curPageUI != NULL)
		{
			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") \
		|| ws_name == _T("main_shangpin") || ws_name == _T("main_kucun") || ws_name == _T("main_caigou") || ws_name == _T("main_zhengcan") || ws_name == _T("main_saomashouyin") || ws_name == _T("main_shoukuan") || ws_name == _T("main_yubaozhuangbiaoqian") || ws_name == _T("main_huhuanqucan"))
	{
		SwitchPageByName(ws_name);
	}
	else
	{
		if (this->m_curPageUI != NULL)
		{
			//除了主界面固定区域的事件，其他的事件全部分发给子页面
			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_HOTKEY:
		lRes = OnHotKey(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 DuiLib::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)
    {
		QuitApp();

        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;
}

void CMainWnd::OnFinalMessage(HWND /*hWnd*/)
{
	//销毁副屏
	CShuangpingTool::GetInstance()->DestoryWnd();

	//执行一些销毁操作
	this->End();

	m_pm.RemovePreMessageFilter(this);

	delete this;
};

/*
 *这个是窗口被销毁的时候调用的
 **/
LRESULT CMainWnd::OnDestroy(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
    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(), L"ButtonUI") != 0 &&
			_tcscmp(pControl->GetClass(), L"OptionUI") != 0 &&
			_tcscmp(pControl->GetClass(), L"TextUI") != 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 += std::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 += std::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;
}

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

	if (m_IsKuaijiejian)
	{
		//如果当前正在设置快捷键，就不处理快捷键消息，避免影响快捷键的重新设置
		bHandled = FALSE;
		return 0;
	}

	//判断响应了什么热键   
	if (wParam == WM_MYHOTKEY_WEIXIN_SHOUKUAN)
	{
		::PostMessage(m_pm.GetPaintWindow(), WM_MYHOTKEY_WEIXIN_SHOUKUAN, 0, 0);
	}
	else if (wParam == WM_MYHOTKEY_HUIYUAN_DENGLU)
	{
		::PostMessage(m_pm.GetPaintWindow(), WM_MYHOTKEY_HUIYUAN_DENGLU, 0, 0);
	}
	else if (wParam == WM_MYHOTKEY_HUIYUAN_SHOUKUAN)
	{
		::PostMessage(m_pm.GetPaintWindow(), WM_MYHOTKEY_HUIYUAN_SHOUKUAN, 0, 0);
	}
	else if (wParam == WM_MYHOTKEY_XIANJIN_SHOUKUAN)
	{
		::PostMessage(m_pm.GetPaintWindow(), WM_MYHOTKEY_XIANJIN_SHOUKUAN, 0, 0);
	}
	else if (wParam == WM_MYHOTKEY_QIANXIANG)
	{
		CPosPrinter printer;
		printer.OpenQianxiang();
	}
	else if (wParam == WM_MYHOTKEY_LOGOUT)
	{
		//退出登录
		this->LoginOut(1);
	}
	else if (wParam == WM_MYHOTKEY_DIANDAN)
	{
		this->SwitchPageByName(L"main_diandan");
	}
	else if (wParam == WM_MYHOTKEY_DINGDAN)
	{
		this->SwitchPageByName(L"main_dingdan");
	}
	else if (wParam == WM_MYHOTKEY_HUIYUAN)
	{
		this->SwitchPageByName(L"main_huiyuan");
	}
	else if (wParam == WM_MYHOTKEY_BAOBIAO)
	{
		this->SwitchPageByName(L"main_baobiao");
	}
	else if (wParam == WM_MYHOTKEY_JIAOBAN)
	{
		this->SwitchPageByName(L"main_jiaoban");
	}
	else if (wParam == WM_MYHOTKEY_SHEZHI)
	{
		this->SwitchPageByName(L"main_setting");
	}
	else if (wParam == WM_MYHOTKEY_SHANGPIN)
	{
		this->SwitchPageByName(L"main_shangpin");
	}
	else if (wParam == WM_MYHOTKEY_KUCUN)
	{
		this->SwitchPageByName(L"main_kucun");
	}
	else if (wParam == WM_MYHOTKEY_CAIGOU)
	{
		this->SwitchPageByName(L"main_caigou");
	}
	else if (wParam == WM_MYHOTKEY_ZHUOTAI)
	{
		this->SwitchPageByName(L"main_zhengcan");
	}
	else if (wParam == WM_MYHOTKEY_SHOUKUAN)
	{
		this->SwitchPageByName(L"main_shoukuan");
	}

	//m_pm.SetFocus(NULL);

	bHandled = TRUE;
	return  0;
}

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);
        //窗口最大化
        PostMessage(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);

            //退出程序
			QuitApp();
        }
    }

    bHandled = true;
    return 0;
}

void CMainWnd::LoginOut(int mode)
{
    CSetting::GetInstance()->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();
}

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

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

		pToastDlg->SetToast(toast_value);

		pToastDlg->ShowWindow();
	}
}

//根据更多里面的设置，刷新左边的功能导航
void CMainWnd::UpdateGongnengDaohang()
{
	//根据餐饮和零售的差异，先对常用和更多的字符串进行处理
	this->UpdateGongnengString();

	std::string changyongString = CSetting::GetInstance()->GetParam("setting_gongneng_changyong_string");
	std::vector<std::string> changyongVector;
	if (changyongString == "")
	{
		changyongVector.clear();
	}
	else
	{
		changyongVector = CLewaimaiString::Split(changyongString, ",");
	}

	//根据数据库保存的模块设置，初始化左侧的模块控件，并处理模块选中
	CVerticalLayoutUI* layout = static_cast<CVerticalLayoutUI*>(m_pm.FindControl(L"main_gongneng_daohang_layout"));
	layout->RemoveAll();

	for (size_t i = 0; i < changyongVector.size(); i++)
	{
		COptionUI* newOption = new COptionUI;
		
		//公共属性
		newOption->SetGroup(L"main_tab");
		newOption->SetFixedWidth(72);
		newOption->SetFixedHeight(66);

		newOption->SetFont(12);

		RECT padding;
		padding.left = 0;
		padding.top = 40;
		padding.right = 0;
		padding.bottom = 9;
		newOption->SetTextPadding(padding);

		newOption->SetSelectedTextColor(0xFFFFFFFF);
		newOption->SetSelectedBkColor(0xFF60B177);

		std::string curName = changyongVector[i];

		//开始设置个性化属性
		if (curName == "diandan")
		{
			newOption->SetName(L"main_diandan");
			newOption->SetText(L"点单");

			newOption->SetNormalImage(L"file='nav_diancan.png' source='0,0,24,24' dest='24,10,48,34'");
			newOption->SetSelectedImage(L"file='nav_diancan_on.png' source='0,0,24,24' dest='24,10,48,34'");
		}
		else if (curName == "dingdan")
		{
			newOption->SetName(L"main_dingdan");
			newOption->SetText(L"订单");

			newOption->SetNormalImage(L"file='nav_dingdan.png' source='0,0,24,24' dest='24,10,48,34'");
			newOption->SetSelectedImage(L"file='nav_dingdan_on.png' source='0,0,24,24' dest='24,10,48,34'");
		}
		else if (curName == "huiyuan")
		{
			newOption->SetName(L"main_huiyuan");
			newOption->SetText(L"会员");

			newOption->SetNormalImage(L"file='nav_huiyuan.png' source='0,0,24,24' dest='24,10,48,34'");
			newOption->SetSelectedImage(L"file='nav_huiyuan_on.png' source='0,0,24,24' dest='24,10,48,34'");
		}
		else if (curName == "baobiao")
		{
			newOption->SetName(L"main_baobiao");
			newOption->SetText(L"报表");

			newOption->SetNormalImage(L"file='nav_baobiao.png' source='0,0,24,24' dest='24,10,48,34'");
			newOption->SetSelectedImage(L"file='nav_baobiao_on.png' source='0,0,24,24' dest='24,10,48,34'");
		}
		else if (curName == "jiaoban")
		{
			newOption->SetName(L"main_jiaoban");
			newOption->SetText(L"交班");

			newOption->SetNormalImage(L"file='nav_jiaoban.png' source='0,0,24,24' dest='24,10,48,34'");
			newOption->SetSelectedImage(L"file='nav_jiaoban_on.png' source='0,0,24,24' dest='24,10,48,34'");
		}
		else if (curName == "setting")
		{
			newOption->SetName(L"main_setting");
			newOption->SetText(L"设置");

			newOption->SetNormalImage(L"file='nav_shezhi.png' source='0,0,24,24' dest='24,10,48,34'");
			newOption->SetSelectedImage(L"file='nav_shezhi_on.png' source='0,0,24,24' dest='24,10,48,34'");
		}
		else if (curName == "shangpin")
		{
			newOption->SetName(L"main_shangpin");
			newOption->SetText(L"商品");

			newOption->SetNormalImage(L"file='nav_shangpin.png' source='0,0,24,24' dest='24,10,48,34'");
			newOption->SetSelectedImage(L"file='nav_shangpin_on.png' source='0,0,24,24' dest='24,10,48,34'");
		}
		else if (curName == "kucun")
		{
			newOption->SetName(L"main_kucun");
			newOption->SetText(L"库存");

			newOption->SetNormalImage(L"file='nav_kucun.png' source='0,0,24,24' dest='24,10,48,34'");
			newOption->SetSelectedImage(L"file='nav_kucun_on.png' source='0,0,24,24' dest='24,10,48,34'");
		}
		else if (curName == "caigou")
		{
			newOption->SetName(L"main_caigou");
			newOption->SetText(L"采购");

			newOption->SetNormalImage(L"file='nav_caigou.png' source='0,0,24,24' dest='24,10,48,34'");
			newOption->SetSelectedImage(L"file='nav_caigou_on.png' source='0,0,24,24' dest='24,10,48,34'");
		}
		else if (curName == "zhengcan")
		{
			newOption->SetName(L"main_zhengcan");
			newOption->SetText(L"桌台收银");

			newOption->SetNormalImage(L"file='nav_zhuotai.png' source='0,0,24,24' dest='24,10,48,34'");
			newOption->SetSelectedImage(L"file='nav_zhuotai_on.png' source='0,0,24,24' dest='24,10,48,34'");
		}
		else if (curName == "saomashouyin")
		{
			newOption->SetName(L"main_saomashouyin");
			newOption->SetText(L"扫码收银");

			newOption->SetNormalImage(L"file='nav_shouyin.png' source='0,0,24,24' dest='24,10,48,34'");
			newOption->SetSelectedImage(L"file='nav_shouyin_on.png' source='0,0,24,24' dest='24,10,48,34'");
		}
		else if (curName == "shoukuan")
		{
			newOption->SetName(L"main_shoukuan");
			newOption->SetText(L"收款");

			newOption->SetNormalImage(L"file='nav_shoukuan.png' source='0,0,24,24' dest='24,10,48,34'");
			newOption->SetSelectedImage(L"file='nav_shoukuan_on.png' source='0,0,24,24' dest='24,10,48,34'");
		}
		else if (curName == "yubaozhuangbiaoqian")
		{
			newOption->SetName(L"main_yubaozhuangbiaoqian");
			newOption->SetText(L"预包装标签");

			RECT padding;
			padding.left = 0;
			padding.top = 40;
			padding.right = 0;
			padding.bottom = 9;
			newOption->SetTextPadding(padding);

			newOption->SetNormalImage(L"file='nav_biaoqian.png' source='0,0,24,24' dest='24,10,48,34'");
			newOption->SetSelectedImage(L"file='nav_biaoqian_on.png' source='0,0,24,24' dest='24,10,48,34'");
		}
		else if (curName == "huhuanqucan")
		{
			newOption->SetName(L"main_huhuanqucan");
			newOption->SetText(L"呼叫取餐");

			newOption->SetNormalImage(L"file='nav_huhuanqucan.png' source='0,0,24,24' dest='24,10,48,34'");
			newOption->SetSelectedImage(L"file='nav_huhuanqucan_on.png' source='0,0,24,24' dest='24,10,48,34'");
		}

		layout->Add(newOption);
	}

	//还要加入一个“更多”
	COptionUI* newOption = new COptionUI;

	//公共属性
	newOption->SetGroup(L"main_tab");
	newOption->SetFixedWidth(72);
	newOption->SetFixedHeight(66);

	newOption->SetFont(12);

	RECT padding;
	padding.left = 0;
	padding.top = 40;
	padding.right = 0;
	padding.bottom = 9;
	newOption->SetTextPadding(padding);

	newOption->SetSelectedTextColor(0xFFFFFFFF);
	newOption->SetSelectedBkColor(0xFF60B177);

	//开始设置个性化属性
	newOption->SetName(L"main_gengduo");
	newOption->SetText(L"更多");

	newOption->SetNormalImage(L"file='nav_gengduo.png' source='0,0,24,24' dest='24,10,48,34'");
	newOption->SetSelectedImage(L"file='nav_gengduo_on.png' source='0,0,24,24' dest='24,10,48,34'");

	layout->Add(newOption);

	//设置默认选中
	if (m_curOptionName != L"main_gengduo")
	{
		//不是在更多页面调整，那就是初始化的时候，默认选中第一个
		COptionUI* newOption = static_cast<COptionUI*>(layout->GetItemAt(0));

		m_curOptionName = newOption->GetName();
		m_curOption = newOption;

		//触发事件切换page
		newOption->Selected(true, false);

		//因为初始化在绑定消息之后，这里不用触发消息，手动切换页面
		this->SwitchPageByName(m_curOptionName);
	}
	else
	{
		//如果已经是更多页面，那么就选中更多，更多肯定是最后一个
		COptionUI* newOption = static_cast<COptionUI*>(layout->GetItemAt(changyongVector.size()));

		m_curOptionName = newOption->GetName();
		m_curOption = newOption;

		//已经选中更多，不用触发事件切换page
		newOption->Selected(true, false);
	}
}

//通过页面名字，切换页面，可以给更多页面调用
void CMainWnd::SwitchPageByName(std::wstring name)
{
	if (name == _T("main_diandan"))
	{
		this->SwitchPage(DIANDAN);
	}
	else if (name == _T("main_dingdan"))
	{
		this->SwitchPage(DINGDAN);
	}
	else if (name == L"main_huiyuan")
	{
		this->SwitchPage(HUIYUAN);
	}
	else if (name == L"main_baobiao")
	{
		this->SwitchPage(BAOBIAO);
	}
	else if (name == L"main_jiaoban")
	{
		this->SwitchPage(JIAOBAN);
	}
	else if (name == _T("main_setting"))
	{
		this->SwitchPage(SETTING);
	}
	else if (name == L"main_gengduo")
	{
		this->SwitchPage(GENGDUO);
	}
	else if (name == L"main_shangpin")
	{
		this->SwitchPage(SHANGPIN);
	}
	else if (name == L"main_zhengcan")
	{
		this->SwitchPage(ZHENGCAN);
	}
	else if (name == L"main_saomashouyin")
	{
		this->SwitchPage(SAOMASHOUYIN);
	}
	else if (name == L"main_shoukuan")
	{
		this->SwitchPage(SHOUKUAN);
	}
	else if (name == L"main_kucun")
	{
		this->SwitchPage(KUCUN);
	}
	else if (name == L"main_caigou")
	{
		this->SwitchPage(CAIGOU);
	}
	else if (name == L"main_yubaozhuangbiaoqian")
	{
		this->SwitchPage(YUBAOZHUANGBIAOQIAN);
	}
	else if (name == L"main_huhuanqucan")
	{
		this->SwitchPage(HUHUANQUCAN);
	}
	else
	{
		//没开通的页面暂时不跳转
		return;
	}

	//处理左侧的高亮与选中状态
	
	//先判断跳转的页面，是不是常用里面的
	std::string changyongString = CSetting::GetInstance()->GetParam("setting_gongneng_changyong_string");
	std::vector<std::string> changyongVector;
	if (changyongString == "")
	{
		changyongVector.clear();
	}
	else
	{
		changyongVector = CLewaimaiString::Split(changyongString, ",");
	}

	//把更多也算进去
	int size = changyongVector.size() + 1;

	CVerticalLayoutUI* layout = static_cast<CVerticalLayoutUI*>(m_pm.FindControl(L"main_gongneng_daohang_layout"));

	bool is_found = false;
	int index = 0;

	for (int i = 0; i < size; i++)
	{
		std::wstring curName = layout->GetItemAt(i)->GetName();
		if (curName == name)
		{
			//找到了常用里面的
			is_found = true;
			index = i;

			break;
		}
	}

	//先取消当前选中的导航
	if (m_curOption != NULL)
	{
		m_curOption->Selected(false, false);
	}

	if (is_found == true)
	{
		//新的跳转属于常用操作里面的
		COptionUI* op = static_cast<COptionUI*>(layout->GetItemAt(index));

		op->Selected(true, false);

		m_curOptionName = name;
		m_curOption = op;
	}
	else
	{
		//新的跳转不属于常用操作里面的
		m_curOptionName = L"";
		m_curOption = NULL;
	}
}

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

void CMainWnd::CreatePages()
{
	m_pages.clear();

	CBasePageUI* pChildContainer = NULL;

	{
		CDialogBuilder builder;
		CDialogBuilderCallbackEx cb;
		pChildContainer = static_cast<CBasePageUI*>(builder.Create(_T("diandan_page.xml"), (UINT)0, &cb, &m_pm));
		m_pages[DIANDAN] = pChildContainer;
	}

	{
		CDialogBuilder builder;
		CDialogBuilderCallbackEx cb;
		pChildContainer = static_cast<CBasePageUI*>(builder.Create(_T("waimaiorder_list_page.xml"), (UINT)0, &cb, &m_pm));
		m_pages[DINGDAN] = pChildContainer;
	}	

	{
		CDialogBuilder builder;
		CDialogBuilderCallbackEx cb;
		pChildContainer = static_cast<CBasePageUI*>(builder.Create(_T("setting_page.xml"), (UINT)0, &cb, &m_pm));
		m_pages[SETTING] = pChildContainer;
	}	

	{
		CDialogBuilder builder;
		CDialogBuilderCallbackEx cb;
		pChildContainer = static_cast<CBasePageUI*>(builder.Create(_T("huiyuan_page.xml"), (UINT)0, &cb, &m_pm));
		m_pages[HUIYUAN] = pChildContainer;
	}	

	{
		CDialogBuilder builder;
		CDialogBuilderCallbackEx cb;
		pChildContainer = static_cast<CBasePageUI*>(builder.Create(_T("waimaiorder_info_page.xml"), (UINT)0, &cb, &m_pm));
		m_pages[WAIMAIINFO] = pChildContainer;
	}	

	{
		CDialogBuilder builder;
		CDialogBuilderCallbackEx cb;
		pChildContainer = static_cast<CBasePageUI*>(builder.Create(_T("dianneiorder_list_page.xml"), (UINT)0, &cb, &m_pm));
		m_pages[DIANNEIDINGDAN] = pChildContainer;
	}	

	{
		CDialogBuilder builder;
		CDialogBuilderCallbackEx cb;
		pChildContainer = static_cast<CBasePageUI*>(builder.Create(_T("dianneiorder_info_page.xml"), (UINT)0, &cb, &m_pm));
		m_pages[DIANNEIINFO] = pChildContainer;
	}	

	{
		CDialogBuilder builder;
		CDialogBuilderCallbackEx cb;
		pChildContainer = static_cast<CBasePageUI*>(builder.Create(_T("baobiao_page.xml"), (UINT)0, &cb, &m_pm));
		m_pages[BAOBIAO] = pChildContainer;
	}	

	{
		CDialogBuilder builder;
		CDialogBuilderCallbackEx cb;
		pChildContainer = static_cast<CBasePageUI*>(builder.Create(_T("jiaoban_page.xml"), (UINT)0, &cb, &m_pm));
		m_pages[JIAOBAN] = pChildContainer;
	}	

	{
		CDialogBuilder builder;
		CDialogBuilderCallbackEx cb;
		pChildContainer = static_cast<CBasePageUI*>(builder.Create(_T("gengduo_page.xml"), (UINT)0, &cb, &m_pm));
		m_pages[GENGDUO] = pChildContainer;
	}

	{
		CDialogBuilder builder;
		CDialogBuilderCallbackEx cb;
		pChildContainer = static_cast<CBasePageUI*>(builder.Create(_T("shangpin_page.xml"), (UINT)0, &cb, &m_pm));
		m_pages[SHANGPIN] = pChildContainer;
	}

	{
		CDialogBuilder builder;
		CDialogBuilderCallbackEx cb;
		pChildContainer = static_cast<CBasePageUI*>(builder.Create(_T("zhengcan_page.xml"), (UINT)0, &cb, &m_pm));
		m_pages[ZHENGCAN] = pChildContainer;
	}

	{
		CDialogBuilder builder;
		CDialogBuilderCallbackEx cb;
		pChildContainer = static_cast<CBasePageUI*>(builder.Create(_T("saomashouyin_page.xml"), (UINT)0, &cb, &m_pm));
		m_pages[SAOMASHOUYIN] = pChildContainer;
	}

	{
		CDialogBuilder builder;
		CDialogBuilderCallbackEx cb;
		pChildContainer = static_cast<CBasePageUI*>(builder.Create(_T("caigou_page.xml"), (UINT)0, &cb, &m_pm));
		m_pages[CAIGOU] = pChildContainer;
	}

	{
		CDialogBuilder builder;
		CDialogBuilderCallbackEx cb;
		pChildContainer = static_cast<CBasePageUI*>(builder.Create(_T("kucun_page.xml"), (UINT)0, &cb, &m_pm));
		m_pages[KUCUN] = pChildContainer;
	}

	{
		CDialogBuilder builder;
		CDialogBuilderCallbackEx cb;
		pChildContainer = static_cast<CBasePageUI*>(builder.Create(_T("zhengcan_diandan_page.xml"), (UINT)0, &cb, &m_pm));
		m_pages[ZHENGCANDIANDAN] = pChildContainer;
	}

	{
		CDialogBuilder builder;
		CDialogBuilderCallbackEx cb;
		pChildContainer = static_cast<CBasePageUI*>(builder.Create(_T("zhengcanorder_list_page.xml"), (UINT)0, &cb, &m_pm));
		m_pages[ZHENGCANDINGDAN] = pChildContainer;
	}

	{
		CDialogBuilder builder;
		CDialogBuilderCallbackEx cb;
		pChildContainer = static_cast<CBasePageUI*>(builder.Create(_T("zhengcanorder_info_page.xml"), (UINT)0, &cb, &m_pm));
		m_pages[ZHENGCANINFO] = pChildContainer;
	}

	{
		CDialogBuilder builder;
		CDialogBuilderCallbackEx cb;
		pChildContainer = static_cast<CBasePageUI*>(builder.Create(_T("shoukuan_page.xml"), (UINT)0, &cb, &m_pm));
		m_pages[SHOUKUAN] = pChildContainer;
	}

	{
		CDialogBuilder builder;
		CDialogBuilderCallbackEx cb;
		pChildContainer = static_cast<CBasePageUI*>(builder.Create(_T("shoukuanorder_list_page.xml"), (UINT)0, &cb, &m_pm));
		m_pages[SHOUKUANDINGDAN] = pChildContainer;
	}

	{
		CDialogBuilder builder;
		CDialogBuilderCallbackEx cb;
		pChildContainer = static_cast<CBasePageUI*>(builder.Create(_T("shoukuanorder_info_page.xml"), (UINT)0, &cb, &m_pm));
		m_pages[SHOUKUANINFO] = pChildContainer;
	}

	{
		CDialogBuilder builder;
		CDialogBuilderCallbackEx cb;
		pChildContainer = static_cast<CBasePageUI*>(builder.Create(_T("aixuexi_page.xml"), (UINT)0, &cb, &m_pm));
		m_pages[AIXUEXI] = pChildContainer;
	}

	{
		CDialogBuilder builder;
		CDialogBuilderCallbackEx cb;
		pChildContainer = static_cast<CBasePageUI*>(builder.Create(_T("yubaozhuangbiaoqian_page.xml"), (UINT)0, &cb, &m_pm));
		m_pages[YUBAOZHUANGBIAOQIAN] = pChildContainer;
	}
	{
		CDialogBuilder builder;
		CDialogBuilderCallbackEx cb;
		pChildContainer = static_cast<CBasePageUI*>(builder.Create(_T("huhuanqucan_page.xml"), (UINT)0, &cb, &m_pm));
		m_pages[HUHUANQUCAN] = pChildContainer;
	}

	//对所有页面进行初始化构造控件
	for (std::map<int, CBasePageUI*>::iterator it = m_pages.begin(); it != m_pages.end(); it++)
	{
		it->second->InitControl();
	}
}

void CMainWnd::DestoryPages()
{
	//先把当前页面对象移出来，不销毁
	CContainerUI* pMainContentLayout = static_cast<CContainerUI*>(m_pm.FindControl(_T("main_content_layout")));
	if (m_curPageName != NOPAGE)
	{
		pMainContentLayout->Remove(m_curPageUI);
	}

	//销毁所有页面对象
	for (std::map<int, CBasePageUI*>::iterator it = m_pages.begin(); it != m_pages.end(); it++)
	{
		delete it->second;
	}
}

void CMainWnd::QuitApp()
{
	this->End();

	PostQuitMessage(0);
}

void CMainWnd::ShowKefu()
{
	CImageAttentionWnd* pYouhuiDlg = new CImageAttentionWnd();

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

		pYouhuiDlg->SetTitle(L"联系客服");
		pYouhuiDlg->SetAttentionText(L"请微信扫描二维码，添加客服微信，处理售后问题");
		pYouhuiDlg->SetAttentionImage(L"contact_me_qr.png", 396, 396);

		pYouhuiDlg->ShowModal();
	}
}

void CMainWnd::ShowAppDownload()
{
	CImageAttentionWnd* pYouhuiDlg = new CImageAttentionWnd();

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

		pYouhuiDlg->SetTitle(L"下载商家app");
		pYouhuiDlg->SetAttentionText(L"请微信扫描二维码，下载智铺子商家app，管理店铺更方便，功能更多");
		pYouhuiDlg->SetAttentionImage(L"app_qrcode.png", 300, 300);

		pYouhuiDlg->ShowModal();
	}
}

void CMainWnd::ShowShangcheng()
{
	CImageAttentionWnd* pYouhuiDlg = new CImageAttentionWnd();

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

		pYouhuiDlg->SetTitle(L"智铺子硬件商城");
		pYouhuiDlg->SetAttentionText(L"请微信扫描二维码，进入智铺子商城，采购收银系统配套硬件设备");
		pYouhuiDlg->SetAttentionImage(L"shangcheng_qrcode.png", 300, 300);

		pYouhuiDlg->ShowModal();
	}
}

void CMainWnd::UpdateGongnengString()
{
	//这个map用于记录当前常用和更多有哪些元素
	std::map<std::string, std::string> TmpMap;

	std::string changyongString = CSetting::GetInstance()->GetParam("setting_gongneng_changyong_string");
	std::vector<std::string> changyongVector;
	if (changyongString == "")
	{
		changyongVector.clear();
	}
	else
	{
		changyongVector = CLewaimaiString::Split(changyongString, ",");
	}

	//考虑到餐饮和零售的差异，这里要对功能导航的内容进行过滤处理
	for (std::vector<std::string>::iterator it = changyongVector.begin(); it != changyongVector.end(); it++)
	{
		TmpMap[*it] = "1";
	}

	//std::string newChangyong = CLewaimaiString::Merge(changyongVector, ",");
	//CSetting::GetInstance()->SetParam("setting_gongneng_changyong_string", newChangyong);

	//常用的处理完了，开始处理更多的
	std::string gengduoString = CSetting::GetInstance()->GetParam("setting_gongneng_gengduo_string");
	std::vector<std::string> gengduoVector;
	if (gengduoString == "")
	{
		gengduoVector.clear();
	}
	else
	{
		gengduoVector = CLewaimaiString::Split(gengduoString, ",");
	}

	std::vector<std::string> TmpgengduoVector;
	for (std::vector<std::string>::iterator it = gengduoVector.begin(); it != gengduoVector.end(); it++)
	{
		TmpgengduoVector.push_back(*it);

		TmpMap[*it] = "1";
	}
	
	//可能没有的模块加进来
	if (TmpMap.find("zhengcan") == TmpMap.end())
	{
		//餐饮版这时候没有zhengcan，说明切换过零售版被删除了，这里要加上
		TmpgengduoVector.push_back("zhengcan");
	}

	if (TmpMap.find("saomashouyin") == TmpMap.end())
	{
		//零售版这时候没有saomashouyin，说明切换过餐饮版被删除了，这里要加上
		TmpgengduoVector.push_back("saomashouyin");
	}

	//如果以后有其他零售版专属的，要在这里继续添加

	//新版本增加了扫码收银
	if (TmpMap.find("shoukuan") == TmpMap.end())
	{
		TmpgengduoVector.push_back("shoukuan");
	}

	if (TmpMap.find("yubaozhuangbiaoqian") == TmpMap.end())
	{
		TmpgengduoVector.push_back("yubaozhuangbiaoqian");
	}

	if (TmpMap.find("huhuanqucan") == TmpMap.end())
	{
		TmpgengduoVector.push_back("huhuanqucan");
	}

	//这个时候已经过滤掉了不需要的，加上了被删除的，可以保存数据库了
	gengduoVector = TmpgengduoVector;

	std::string newGengduo = CLewaimaiString::Merge(gengduoVector, ",");
	CSetting::GetInstance()->SetParam("setting_gongneng_gengduo_string", newGengduo);
}

void CMainWnd::UpdateRegisterHotKey()
{
	//微信收款
	UINT weixinshoukuan_mod = (UINT)atoi(CSetting::GetInstance()->GetParam("setting_kuaijiejian_weixinshoukuan_mod").c_str());
	UINT weixinshoukuan_vk = (UINT)atoi(CSetting::GetInstance()->GetParam("setting_kuaijiejian_weixinshoukuan_vk").c_str());

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

	RegisterHotKey(m_hWnd, WM_MYHOTKEY_WEIXIN_SHOUKUAN, weixinshoukuan_mod, weixinshoukuan_vk);

	//会员登录
	UINT huiyuandenglu_mod = (UINT)atoi(CSetting::GetInstance()->GetParam("setting_kuaijiejian_huiyuandenglu_mod").c_str());
	UINT huiyuandenglu_vk = (UINT)atoi(CSetting::GetInstance()->GetParam("setting_kuaijiejian_huiyuandenglu_vk").c_str());

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

	RegisterHotKey(m_hWnd, WM_MYHOTKEY_HUIYUAN_DENGLU, huiyuandenglu_mod, huiyuandenglu_vk);

	//会员收款
	UINT huiyuanshoukuan_mod = (UINT)atoi(CSetting::GetInstance()->GetParam("setting_kuaijiejian_huiyuanshoukuan_mod").c_str());
	UINT huiyuanshoukuan_vk = (UINT)atoi(CSetting::GetInstance()->GetParam("setting_kuaijiejian_huiyuanshoukuan_vk").c_str());

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

	RegisterHotKey(m_hWnd, WM_MYHOTKEY_HUIYUAN_SHOUKUAN, huiyuanshoukuan_mod, huiyuanshoukuan_vk);

	//现金收款
	UINT xianjinshoukuan_mod = (UINT)atoi(CSetting::GetInstance()->GetParam("setting_kuaijiejian_xianjinshoukuan_mod").c_str());
	UINT xianjinshoukuan_vk = (UINT)atoi(CSetting::GetInstance()->GetParam("setting_kuaijiejian_xianjinshoukuan_vk").c_str());

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

	RegisterHotKey(m_hWnd, WM_MYHOTKEY_XIANJIN_SHOUKUAN, xianjinshoukuan_mod, xianjinshoukuan_vk);

	//钱箱
	UINT qianxiang_mod = (UINT)atoi(CSetting::GetInstance()->GetParam("setting_kuaijiejian_qianxiang_mod").c_str());
	UINT qianxiang_vk = (UINT)atoi(CSetting::GetInstance()->GetParam("setting_kuaijiejian_qianxiang_vk").c_str());

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

	RegisterHotKey(m_hWnd, WM_MYHOTKEY_QIANXIANG, qianxiang_mod, qianxiang_vk);

	//退出登录
	UINT logout_mod = (UINT)atoi(CSetting::GetInstance()->GetParam("setting_kuaijiejian_logout_mod").c_str());
	UINT logout_vk = (UINT)atoi(CSetting::GetInstance()->GetParam("setting_kuaijiejian_logout_vk").c_str());

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

	RegisterHotKey(m_hWnd, WM_MYHOTKEY_LOGOUT, logout_mod, logout_vk);

	//点单页面
	UINT diandan_mod = (UINT)atoi(CSetting::GetInstance()->GetParam("setting_kuaijiejian_diandan_mod").c_str());
	UINT diandan_vk = (UINT)atoi(CSetting::GetInstance()->GetParam("setting_kuaijiejian_diandan_vk").c_str());

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

	RegisterHotKey(m_hWnd, WM_MYHOTKEY_DIANDAN, diandan_mod, diandan_vk);

	//订单页面
	UINT dingdan_mod = (UINT)atoi(CSetting::GetInstance()->GetParam("setting_kuaijiejian_dingdan_mod").c_str());
	UINT dingdan_vk = (UINT)atoi(CSetting::GetInstance()->GetParam("setting_kuaijiejian_dingdan_vk").c_str());

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

	RegisterHotKey(m_hWnd, WM_MYHOTKEY_DINGDAN, dingdan_mod, dingdan_vk);

	//会员页面
	UINT huiyuan_mod = (UINT)atoi(CSetting::GetInstance()->GetParam("setting_kuaijiejian_huiyuan_mod").c_str());
	UINT huiyuan_vk = (UINT)atoi(CSetting::GetInstance()->GetParam("setting_kuaijiejian_huiyuan_vk").c_str());

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

	RegisterHotKey(m_hWnd, WM_MYHOTKEY_HUIYUAN, huiyuan_mod, huiyuan_vk);

	//报表页面
	UINT baobiao_mod = (UINT)atoi(CSetting::GetInstance()->GetParam("setting_kuaijiejian_baobiao_mod").c_str());
	UINT baobiao_vk = (UINT)atoi(CSetting::GetInstance()->GetParam("setting_kuaijiejian_baobiao_vk").c_str());

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

	RegisterHotKey(m_hWnd, WM_MYHOTKEY_BAOBIAO, baobiao_mod, baobiao_vk);

	//交班页面
	UINT jiaoban_mod = (UINT)atoi(CSetting::GetInstance()->GetParam("setting_kuaijiejian_jiaoban_mod").c_str());
	UINT jiaoban_vk = (UINT)atoi(CSetting::GetInstance()->GetParam("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::GetInstance()->GetParam("setting_kuaijiejian_shezhi_mod").c_str());
	UINT shezhi_vk = (UINT)atoi(CSetting::GetInstance()->GetParam("setting_kuaijiejian_shezhi_vk").c_str());

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

	RegisterHotKey(m_hWnd, WM_MYHOTKEY_SHEZHI, shezhi_mod, shezhi_vk);

	//商品页面
	UINT shangpin_mod = (UINT)atoi(CSetting::GetInstance()->GetParam("setting_kuaijiejian_shangpin_mod").c_str());
	UINT shangpin_vk = (UINT)atoi(CSetting::GetInstance()->GetParam("setting_kuaijiejian_shangpin_vk").c_str());

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

	RegisterHotKey(m_hWnd, WM_MYHOTKEY_SHANGPIN, shangpin_mod, shangpin_vk);

	//库存页面
	UINT kucun_mod = (UINT)atoi(CSetting::GetInstance()->GetParam("setting_kuaijiejian_kucun_mod").c_str());
	UINT kucun_vk = (UINT)atoi(CSetting::GetInstance()->GetParam("setting_kuaijiejian_kucun_vk").c_str());

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

	RegisterHotKey(m_hWnd, WM_MYHOTKEY_KUCUN, kucun_mod, kucun_vk);

	//采购页面
	UINT caigou_mod = (UINT)atoi(CSetting::GetInstance()->GetParam("setting_kuaijiejian_caigou_mod").c_str());
	UINT caigou_vk = (UINT)atoi(CSetting::GetInstance()->GetParam("setting_kuaijiejian_caigou_vk").c_str());

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

	RegisterHotKey(m_hWnd, WM_MYHOTKEY_CAIGOU, caigou_mod, caigou_vk);

	//桌台收银页面
	UINT zhuotai_mod = (UINT)atoi(CSetting::GetInstance()->GetParam("setting_kuaijiejian_zhuotai_mod").c_str());
	UINT zhuotai_vk = (UINT)atoi(CSetting::GetInstance()->GetParam("setting_kuaijiejian_zhuotai_vk").c_str());

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

	RegisterHotKey(m_hWnd, WM_MYHOTKEY_ZHUOTAI, zhuotai_mod, zhuotai_vk);

	//收款页面
	UINT shoukuan_mod = (UINT)atoi(CSetting::GetInstance()->GetParam("setting_kuaijiejian_shoukuan_mod").c_str());
	UINT shoukuan_vk = (UINT)atoi(CSetting::GetInstance()->GetParam("setting_kuaijiejian_shoukuan_vk").c_str());

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

	RegisterHotKey(m_hWnd, WM_MYHOTKEY_SHOUKUAN, shoukuan_mod, shoukuan_vk);
}