zhipuzi_pos_windows/zhipuzi_pos_windows/page/CSettingPageUI.cpp

#include "../pch/pch.h"
#include "CSettingPageUI.h"

#include "../wnd/CChufangSettingWnd.h"

#include "../print/CPosPrinter.h"
#include "../helper/CComHelper.h"
#include "../worker/CChengzhongWorker.h"

#include <boost/array.hpp>

//boost库的头文件
#include <boost/asio.hpp>
#include <boost/asio/io_context.hpp>
using boost::asio::ip::tcp;

#include "../tool/CFoodHandle.h"

CSettingPageUI::CSettingPageUI()
{

}


CSettingPageUI::~CSettingPageUI()
{
}

//初始化当前页面的展示，处理默认展示效果，在页面被加载的时候调用
void CSettingPageUI::InitControl()
{
	CLabelUI* version = static_cast<CLabelUI*>(this->FindSubControl(_T("setting_version")));
	version->SetText((L"版本号：" + CLewaimaiString::UTF8ToUnicode(CSystem::GetVersion())).c_str());

	CCheckBoxUI* box = NULL;
	CComboUI* com = NULL;

	//外卖订单设置
	box = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_is_new_waimai_voice")));
	if (CSetting::GetInstance()->GetParam("setting_is_new_waimai_voice") == "1")
	{
		box->Selected(true, false);
	}
	else
	{
		box->Selected(false, false);
	}

	box = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_is_new_waimai_autoconfirm")));
	if (CSetting::GetInstance()->GetParam("setting_is_new_waimai_autoconfirm") == "1")
	{
		box->Selected(true, false);
	}
	else
	{
		box->Selected(false, false);
	}

	box = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_is_new_waimai_printer")));
	if (CSetting::GetInstance()->GetParam("setting_is_new_waimai_printer") == "1")
	{
		box->Selected(true, false);
	}
	else
	{
		box->Selected(false, false);
	}

	box = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_is_new_waimai_biaoqian_printer")));
	if (CSetting::GetInstance()->GetParam("setting_is_new_waimai_biaoqian_printer") == "1")
	{
		box->Selected(true, false);
	}
	else
	{
		box->Selected(false, false);
	}

	box = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_is_new_waimai_chufang_printer")));
	if (CSetting::GetInstance()->GetParam("setting_is_new_waimai_chufang_printer") == "1")
	{
		box->Selected(true, false);
	}
	else
	{
		box->Selected(false, false);
	}

	//店内订单设置
	box = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_is_new_diannei_voice")));
	if (CSetting::GetInstance()->GetParam("setting_is_new_diannei_voice") == "1")
	{
		box->Selected(true, false);
	}
	else
	{
		box->Selected(false, false);
	}

	box = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_is_new_diannei_printer")));
	if (CSetting::GetInstance()->GetParam("setting_is_new_diannei_printer") == "1")
	{
		box->Selected(true, false);
	}
	else
	{
		box->Selected(false, false);
	}

	box = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_is_new_diannei_biaoqian_printer")));
	if (CSetting::GetInstance()->GetParam("setting_is_new_diannei_biaoqian_printer") == "1")
	{
		box->Selected(true, false);
	}
	else
	{
		box->Selected(false, false);
	}

	box = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_is_new_diannei_chufang_printer")));
	if (CSetting::GetInstance()->GetParam("setting_is_new_diannei_chufang_printer") == "1")
	{
		box->Selected(true, false);
	}
	else
	{
		box->Selected(false, false);
	}
	
	box = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_is_new_diannei_saomadiancan_printer")));
	if (CSetting::GetInstance()->GetParam("setting_is_new_diannei_saomadiancan_printer") == "1")
	{
		box->Selected(true, false);
	}
	else
	{
		box->Selected(false, false);
	}

	box = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_is_diannei_xianjin_qianxiang")));
	if (CSetting::GetInstance()->GetParam("setting_is_diannei_xianjin_qianxiang") == "1")
	{
		box->Selected(true, false);
	}
	else
	{
		box->Selected(false, false);
	}

	//小票打印
	com = static_cast<CComboUI*>(this->FindSubControl(_T("setting_printer_guige")));
	if (CSetting::GetInstance()->GetParam("setting_printer_guige") == "58")
	{
		com->SetInternVisible(true);
		com->SelectItem(0, false);
	}
	else
	{
		com->SetInternVisible(true);
		com->SelectItem(1, false);
	}

	com = static_cast<CComboUI*>(this->FindSubControl(_T("setting_printer_lianshu")));
	std::string setting_printer_lianshu = CSetting::GetInstance()->GetParam("setting_printer_lianshu");

	if (setting_printer_lianshu == "1")
	{
		com->SetInternVisible(true);
		com->SelectItem(0, false);
		com->SetText(L"1联");
	}
	else if (setting_printer_lianshu == "2")
	{
		com->SetInternVisible(true);
		com->SelectItem(1, false);
		com->SetText(L"2联");
	}
	else if (setting_printer_lianshu == "3")
	{
		com->SetInternVisible(true);
		com->SelectItem(2, false);
		com->SetText(L"3联");
	}
	else if (setting_printer_lianshu == "4")
	{
		com->SetInternVisible(true);
		com->SelectItem(3, false);
		com->SetText(L"4联");
	}

	com = static_cast<CComboUI*>(this->FindSubControl(_T("setting_printer_leixing")));
	std::string setting_printer_leixing = CSetting::GetInstance()->GetParam("setting_printer_leixing");

	CHorizontalLayoutUI* usb_layout = static_cast<CHorizontalLayoutUI*>(this->FindSubControl(_T("setting_printer_usb_layout")));
	CHorizontalLayoutUI* chuankou_layout = static_cast<CHorizontalLayoutUI*>(this->FindSubControl(_T("setting_printer_chuankou_layout")));
	CHorizontalLayoutUI* wangkou_layout = static_cast<CHorizontalLayoutUI*>(this->FindSubControl(_T("setting_printer_wangkou_layout")));

	if (setting_printer_leixing == "auto")
	{
		com->SetInternVisible(true);
		com->SelectItem(0, false);
		com->SetText(L"智能识别模式");

		//智能识别模式隐藏这3个
		usb_layout->SetVisible(false);
		chuankou_layout->SetVisible(false);
		wangkou_layout->SetVisible(false);
	}
	else if (setting_printer_leixing == "usb")
	{
		com->SetInternVisible(true);
		com->SelectItem(1, false);
		com->SetText(L"usb");

		//显示usb布局
		usb_layout->SetVisible(true);
		chuankou_layout->SetVisible(false);
		wangkou_layout->SetVisible(false);

		//usb下拉框默认选中
		CComboUI* com_usb = static_cast<CComboUI*>(this->FindSubControl(_T("setting_printer_usb")));
		com_usb->RemoveAll();

		//数据库中保存的之前的设置
		std::string setting_printer_usb = CSetting::GetInstance()->GetParam("setting_printer_usb");
		std::wstring ws_setting_printer_usb = CLewaimaiString::UTF8ToUnicode(setting_printer_usb);

		std::vector<std::wstring> usb_devices = CPosPrinterQueue::GetInstance()->getUsbDevices();

		int i = 0;
		int nSelect = -1;

		for (std::vector<std::wstring>::iterator it = usb_devices.begin(); it != usb_devices.end(); it++)
		{
			CListLabelElementUI* elem = new CListLabelElementUI();
			elem->SetText((*it).c_str());
			com_usb->Add(elem);

			if (*it == ws_setting_printer_usb)
			{
				nSelect = i;
			}

			i++;
		}

		com_usb->SetInternVisible(true);
		com_usb->SelectItem(nSelect, false);
		com_usb->SetText(CLewaimaiString::UTF8ToUnicode(setting_printer_usb).c_str());
	}
	else if (setting_printer_leixing == "bingkou")
	{
		com->SetInternVisible(true);
		com->SelectItem(2, false);
		com->SetText(L"并口");

		usb_layout->SetVisible(false);
		chuankou_layout->SetVisible(false);
		wangkou_layout->SetVisible(false);
	}
	else if (setting_printer_leixing == "chuankou")
	{
		com->SetInternVisible(true);
		com->SelectItem(3, false);
		com->SetText(L"串口");

		usb_layout->SetVisible(false);
		chuankou_layout->SetVisible(true);
		wangkou_layout->SetVisible(false);

		//串口下拉框默认选中
		CComboUI* com_chuankou = static_cast<CComboUI*>(this->FindSubControl(_T("setting_printer_com")));
		com_chuankou->RemoveAll();

		//数据库中保存的之前的设置
		std::string setting_printer_com = CSetting::GetInstance()->GetParam("setting_printer_com");
		std::wstring ws_setting_printer_com = CLewaimaiString::UTF8ToUnicode(setting_printer_com);

		CComHelper helper;
		std::vector<std::wstring> com_devices = helper.getComPort();

		int i = 0;
		int nSelect = -1;

		for (std::vector<std::wstring>::iterator it = com_devices.begin(); it != com_devices.end(); it++)
		{
			CListLabelElementUI* elem = new CListLabelElementUI();
			elem->SetText((*it).c_str());
			com_chuankou->Add(elem);

			if (*it == ws_setting_printer_com)
			{
				nSelect = i;
			}

			i++;
		}

		com_chuankou->SetInternVisible(true);
		com_chuankou->SelectItem(nSelect, false);
		com_chuankou->SetText(CLewaimaiString::UTF8ToUnicode(setting_printer_com).c_str());
	}
	else if (setting_printer_leixing == "wangkou")
	{
		com->SetInternVisible(true);
		com->SelectItem(4, false);
		com->SetText(L"网口");

		usb_layout->SetVisible(false);
		chuankou_layout->SetVisible(false);
		wangkou_layout->SetVisible(true);

		std::string setting_printer_wangkou_ip = CSetting::GetInstance()->GetParam("setting_printer_wangkou_ip");

		CEditUI* ip_edit = static_cast<CEditUI*>(this->FindSubControl(_T("setting_printer_wangkou_ip")));
		ip_edit->SetText(CLewaimaiString::UTF8ToUnicode(setting_printer_wangkou_ip).c_str());
	}

	box = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_printer_quhuo_big")));
	if (CSetting::GetInstance()->GetParam("setting_printer_quhuo_big") == "1")
	{
		box->Selected(true, false);
	}
	else
	{
		box->Selected(false, false);
	}

	box = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_printer_dingdanhao_big")));
	if (CSetting::GetInstance()->GetParam("setting_printer_dingdanhao_big") == "1")
	{
		box->Selected(true, false);
	}
	else
	{
		box->Selected(false, false);
	}

	box = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_printer_xiadanshijian_big")));
	if (CSetting::GetInstance()->GetParam("setting_printer_xiadanshijian_big") == "1")
	{
		box->Selected(true, false);
	}
	else
	{
		box->Selected(false, false);
	}

	box = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_printer_peisongshijian_big")));
	if (CSetting::GetInstance()->GetParam("setting_printer_peisongshijian_big") == "1")
	{
		box->Selected(true, false);
	}
	else
	{
		box->Selected(false, false);
	}

	box = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_printer_name_big")));
	if (CSetting::GetInstance()->GetParam("setting_printer_name_big") == "1")
	{
		box->Selected(true, false);
	}
	else
	{
		box->Selected(false, false);
	}

	box = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_printer_phone_big")));
	if (CSetting::GetInstance()->GetParam("setting_printer_phone_big") == "1")
	{
		box->Selected(true, false);
	}
	else
	{
		box->Selected(false, false);
	}

	box = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_printer_address_big")));
	if (CSetting::GetInstance()->GetParam("setting_printer_address_big") == "1")
	{
		box->Selected(true, false);
	}
	else
	{
		box->Selected(false, false);
	}

	box = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_printer_shangpin_big")));
	if (CSetting::GetInstance()->GetParam("setting_printer_shangpin_big") == "1")
	{
		box->Selected(true, false);
	}
	else
	{
		box->Selected(false, false);
	}

	box = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_printer_memo_big")));
	if (CSetting::GetInstance()->GetParam("setting_printer_memo_big") == "1")
	{
		box->Selected(true, false);
	}
	else
	{
		box->Selected(false, false);
	}

	box = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_printer_price_big")));
	if (CSetting::GetInstance()->GetParam("setting_printer_price_big") == "1")
	{
		box->Selected(true, false);
	}
	else
	{
		box->Selected(false, false);
	}

	box = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_printer_pay_big")));
	if (CSetting::GetInstance()->GetParam("setting_printer_pay_big") == "1")
	{
		box->Selected(true, false);
	}
	else
	{
		box->Selected(false, false);
	}

	//电子秤设置
	CComboUI* com_dianzicheng_xinghao = static_cast<CComboUI*>(this->FindSubControl(_T("setting_dianzicheng_xinghao")));
	std::string setting_dianzicheng_xinghao = CSetting::GetInstance()->GetParam("setting_dianzicheng_xinghao");

	if (setting_dianzicheng_xinghao == "dahua_acs")
	{
		com_dianzicheng_xinghao->SetInternVisible(true);
		com_dianzicheng_xinghao->SelectItem(0, false);
		com_dianzicheng_xinghao->SetText(L"大华ACS系列");
	}
	else if (setting_dianzicheng_xinghao == "dingjian_os2x")
	{
		com_dianzicheng_xinghao->SetInternVisible(true);
		com_dianzicheng_xinghao->SelectItem(1, false);
		com_dianzicheng_xinghao->SetText(L"顶尖OS2X系列");
	}

	//串口下拉框默认选中
	CComboUI* com_dianzicheng = static_cast<CComboUI*>(this->FindSubControl(_T("setting_dianzicheng_chuankou")));
	com_dianzicheng->RemoveAll();

	//数据库中保存的之前的设置
	std::string setting_dianzicheng_com = CSetting::GetInstance()->GetParam("setting_dianzicheng_com");
	std::wstring ws_setting_dianzicheng_com = CLewaimaiString::UTF8ToUnicode(setting_dianzicheng_com);

	CComHelper helper;
	std::vector<std::wstring> com_devices = helper.getComPort();

	int i = 0;
	int nSelect = -1;

	for (std::vector<std::wstring>::iterator it = com_devices.begin(); it != com_devices.end(); it++)
	{
		CListLabelElementUI* elem = new CListLabelElementUI();
		elem->SetText((*it).c_str());
		com_dianzicheng->Add(elem);

		if (*it == ws_setting_dianzicheng_com)
		{
			nSelect = i;
		}

		i++;
	}

	com_dianzicheng->SetInternVisible(true);
	com_dianzicheng->SelectItem(nSelect, false);
	com_dianzicheng->SetText(CLewaimaiString::UTF8ToUnicode(setting_dianzicheng_com).c_str());

	CComboUI* com_dianzicheng_botelv = static_cast<CComboUI*>(this->FindSubControl(_T("setting_dianzicheng_botelv")));
	std::string setting_dianzicheng_botelv = CSetting::GetInstance()->GetParam("setting_dianzicheng_botelv");

	if (setting_dianzicheng_botelv == "600")
	{
		com_dianzicheng_botelv->SetInternVisible(true);
		com_dianzicheng_botelv->SelectItem(0, false);
		com_dianzicheng_botelv->SetText(L"600");
	}
	else if (setting_dianzicheng_botelv == "1200")
	{
		com_dianzicheng_botelv->SetInternVisible(true);
		com_dianzicheng_botelv->SelectItem(1, false);
		com_dianzicheng_botelv->SetText(L"1200");
	}
	else if (setting_dianzicheng_botelv == "2400")
	{
		com_dianzicheng_botelv->SetInternVisible(true);
		com_dianzicheng_botelv->SelectItem(2, false);
		com_dianzicheng_botelv->SetText(L"2400");
	}
	else if (setting_dianzicheng_botelv == "4800")
	{
		com_dianzicheng_botelv->SetInternVisible(true);
		com_dianzicheng_botelv->SelectItem(3, false);
		com_dianzicheng_botelv->SetText(L"4800");
	}
	else if (setting_dianzicheng_botelv == "9600")
	{
		com_dianzicheng_botelv->SetInternVisible(true);
		com_dianzicheng_botelv->SelectItem(4, false);
		com_dianzicheng_botelv->SetText(L"9600");
	}
	else if (setting_dianzicheng_botelv == "19200")
	{
		com_dianzicheng_botelv->SetInternVisible(true);
		com_dianzicheng_botelv->SelectItem(5, false);
		com_dianzicheng_botelv->SetText(L"19200");
	}
	else if (setting_dianzicheng_botelv == "38400")
	{
		com_dianzicheng_botelv->SetInternVisible(true);
		com_dianzicheng_botelv->SelectItem(6, false);
		com_dianzicheng_botelv->SetText(L"38400");
	}

	//初始化是否连接电子秤的单选框
	CCheckBoxUI* box_chengzhong_weilianjie = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_dianzicheng_weilianjie")));
	CCheckBoxUI* box_chengzhong_yilianjie = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_dianzicheng_yilianjie")));

	CVerticalLayoutUI* dianzicheng_layout = static_cast<CVerticalLayoutUI*>(this->FindSubControl(_T("setting_dianzicheng_layout")));
	if (CSetting::GetInstance()->GetParam("setting_dianzicheng_is_lianjie") == "0")
	{
		box_chengzhong_weilianjie->Selected(true, false);
		box_chengzhong_yilianjie->Selected(false, false);

		dianzicheng_layout->SetVisible(false);
	}
	else
	{
		box_chengzhong_weilianjie->Selected(false, false);
		box_chengzhong_yilianjie->Selected(true, false);

		dianzicheng_layout->SetVisible(true);
	}

	//标签秤设置
	com = static_cast<CComboUI*>(this->FindSubControl(_T("setting_tiaomacheng_geshi")));
	std::string setting_tiaomacheng_geshi = CSetting::GetInstance()->GetParam("setting_tiaomacheng_geshi");

	if (setting_tiaomacheng_geshi == "1")
	{
		com->SetInternVisible(true);
		com->SelectItem(0, false);
		com->SetText(L"13位【FWWWWWWEEEEEC】");
	}
	else if (setting_tiaomacheng_geshi == "2")
	{
		com->SetInternVisible(true);
		com->SelectItem(1, false);
		com->SetText(L"13位【FWWWWWWNNNNNC】");
	}
	else if (setting_tiaomacheng_geshi == "3")
	{
		com->SetInternVisible(true);
		com->SelectItem(2, false);
		com->SetText(L"13位【FFWWWWWEEEEEC】");
	}
	else if (setting_tiaomacheng_geshi == "4")
	{
		com->SetInternVisible(true);
		com->SelectItem(3, false);
		com->SetText(L"13位【FFWWWWWNNNNNC】");
	}
	else if (setting_tiaomacheng_geshi == "5")
	{
		com->SetInternVisible(true);
		com->SelectItem(4, false);
		com->SetText(L"18位【FWWWWWWEEEEENNNNNC】");
	}
	else if (setting_tiaomacheng_geshi == "6")
	{
		com->SetInternVisible(true);
		com->SelectItem(5, false);
		com->SetText(L"18位【FWWWWWWNNNNNEEEEEC】");
	}
	else if (setting_tiaomacheng_geshi == "7")
	{
		com->SetInternVisible(true);
		com->SelectItem(6, false);
		com->SetText(L"18位【FFWWWWWEEEEENNNNNC】");
	}
	else if (setting_tiaomacheng_geshi == "8")
	{
		com->SetInternVisible(true);
		com->SelectItem(6, false);
		com->SetText(L"18位【FFWWWWWNNNNNEEEEEC】");
	}

	com = static_cast<CComboUI*>(this->FindSubControl(_T("setting_tiaomacheng_xinghao")));
	std::string setting_tiaomacheng_xinghao = CSetting::GetInstance()->GetParam("setting_tiaomacheng_xinghao");

	if (setting_tiaomacheng_xinghao == "dahua_tm")
	{
		com->SetInternVisible(true);
		com->SelectItem(0, false);
		com->SetText(L"大华TM系列");
	}

	std::string setting_tiaomacheng_ip = CSetting::GetInstance()->GetParam("setting_tiaomacheng_ip");

	CEditUI* tiaoma_ip_edit = static_cast<CEditUI*>(this->FindSubControl(_T("setting_tiaomacheng_ip")));
	tiaoma_ip_edit->SetText(CLewaimaiString::UTF8ToUnicode(setting_tiaomacheng_ip).c_str());

	//系统设置
	box = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_is_auto_start")));
	if (CSetting::GetInstance()->GetParam("setting_is_auto_start") == "1")
	{
		box->Selected(true, false);
	}
	else
	{
		box->Selected(false, false);
	}

	box = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_is_auto_login")));

	if (CSetting::GetInstance()->GetParam("setting_is_auto_login") == "1")
	{
		box->Selected(true, false);
	}
	else
	{
		box->Selected(false, false);
	}

	box = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_is_close_min")));

	if (CSetting::GetInstance()->GetParam("setting_is_close_min") == "1")
	{
		box->Selected(true, false);
	}
	else
	{
		box->Selected(false, false);
	}

	//初始化标签打印机的设置
	com = static_cast<CComboUI*>(this->FindSubControl(_T("setting_biaoqian_printer_leixing")));
	setting_printer_leixing = CSetting::GetInstance()->GetParam("setting_biaoqian_printer_leixing");

	usb_layout = static_cast<CHorizontalLayoutUI*>(this->FindSubControl(_T("setting_biaoqian_printer_usb_layout")));
	wangkou_layout = static_cast<CHorizontalLayoutUI*>(this->FindSubControl(_T("setting_biaoqian_printer_wangkou_layout")));

	if (setting_printer_leixing == "usb")
	{
		com->SetInternVisible(true);
		com->SelectItem(0, false);
		com->SetText(L"usb");

		//显示usb布局
		usb_layout->SetVisible(true);
		wangkou_layout->SetVisible(false);
	}
	else if (setting_printer_leixing == "wangkou")
	{
		com->SetInternVisible(true);
		com->SelectItem(1, false);
		com->SetText(L"网口");

		usb_layout->SetVisible(false);
		wangkou_layout->SetVisible(true);
	}

	//usb下拉框默认选中
	CComboUI* com_usb = static_cast<CComboUI*>(this->FindSubControl(_T("setting_biaoqian_printer_usb")));
	com_usb->RemoveAll();

	//数据库中保存的之前的设置
	std::string setting_biaoqian_printer_usb = CSetting::GetInstance()->GetParam("setting_biaoqian_printer_usb");
	std::wstring ws_setting_biaoqian_printer_usb = CLewaimaiString::UTF8ToUnicode(setting_biaoqian_printer_usb);

	std::vector<std::wstring> usb_devices = CPosPrinterQueue::GetInstance()->getUsbDevices();

	i = 0;
	nSelect = -1;

	for (std::vector<std::wstring>::iterator it = usb_devices.begin(); it != usb_devices.end(); it++)
	{
		CListLabelElementUI* elem = new CListLabelElementUI();
		elem->SetText((*it).c_str());
		com_usb->Add(elem);

		if (*it == ws_setting_biaoqian_printer_usb)
		{
			nSelect = i;
		}

		i++;
	}

	com_usb->SetInternVisible(true);
	com_usb->SelectItem(nSelect, false);
	com_usb->SetText(CLewaimaiString::UTF8ToUnicode(setting_biaoqian_printer_usb).c_str());

	//网口显示
	std::string setting_biaoqian_printer_wangkou_ip = CSetting::GetInstance()->GetParam("setting_biaoqian_printer_wangkou_ip");

	CEditUI* ip_edit = static_cast<CEditUI*>(this->FindSubControl(_T("setting_biaoqian_printer_wangkou_ip")));
	ip_edit->SetText(CLewaimaiString::UTF8ToUnicode(setting_biaoqian_printer_wangkou_ip).c_str());

	com = static_cast<CComboUI*>(this->FindSubControl(_T("setting_biaoqian_printer_guige")));
	std::string setting_biaoqian_printer_guige = CSetting::GetInstance()->GetParam("setting_biaoqian_printer_guige");

	if (setting_biaoqian_printer_guige == "40*30mm")
	{
		com->SetInternVisible(true);
		com->SelectItem(0, false);
		com->SetText(L"40*30mm");
	}
	else if (setting_biaoqian_printer_guige == "35*25mm")
	{
		com->SetInternVisible(true);
		com->SelectItem(1, false);
		com->SetText(L"35*25mm");
	}
	else if (setting_biaoqian_printer_guige == "30*25mm")
	{
		com->SetInternVisible(true);
		com->SelectItem(2, false);
		com->SetText(L"30*25mm");
	}
	else if (setting_biaoqian_printer_guige == "30*20mm")
	{
		com->SetInternVisible(true);
		com->SelectItem(3, false);
		com->SetText(L"30*20mm");
	}
	else if (setting_biaoqian_printer_guige == "60*80mm")
	{
		com->SetInternVisible(true);
		com->SelectItem(4, false);
		com->SetText(L"60*80mm");
	}
	else if (setting_biaoqian_printer_guige == "80*60mm")
	{
		com->SetInternVisible(true);
		com->SelectItem(5, false);
		com->SetText(L"80*60mm");
	}

	com = static_cast<CComboUI*>(this->FindSubControl(_T("setting_biaoqian_printer_fangxiang")));
	std::string setting_biaoqian_printer_fangxiang = CSetting::GetInstance()->GetParam("setting_biaoqian_printer_fangxiang");

	if (setting_biaoqian_printer_fangxiang == "1")
	{
		com->SetInternVisible(true);
		com->SelectItem(0, false);
		com->SetText(L"正方向");
	}
	else if (setting_biaoqian_printer_fangxiang == "0")
	{
		com->SetInternVisible(true);
		com->SelectItem(1, false);
		com->SetText(L"反方向");
	}

	box = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_biaoqian_printer_is_type")));
	if (CSetting::GetInstance()->GetParam("setting_biaoqian_printer_is_type") == "1")
	{
		box->Selected(true, false);
	}
	else
	{
		box->Selected(false, false);
	}

	std::string type_ids = CSetting::GetInstance()->GetParam("setting_biaoqian_printer_type_ids");
	std::vector<std::string> type_vector = CLewaimaiString::Split(type_ids, ",");

	//删除已经不存在的type_ids
	std::string new_foodtype_ids;
	CSqlite3 sqlite;
	for (std::vector<std::string>::iterator it = type_vector.begin(); it != type_vector.end(); it++)
	{
		CFoodType type;
		bool ret = sqlite.GetFoodtypeById((*it), type);
		if (!ret)
		{
			//分类被删掉了
			continue;
		}

		new_foodtype_ids += (*it) + ",";
	}

	//删掉不存在的type_id，更新内存和数据库
	new_foodtype_ids = new_foodtype_ids.substr(0, new_foodtype_ids.length() - 1);
	CSetting::GetInstance()->SetParam("setting_biaoqian_printer_type_ids", new_foodtype_ids);

	//重新赋值
	type_ids = new_foodtype_ids;
	type_vector = CLewaimaiString::Split(type_ids, ",");

	std::map<std::string, int> type_map;
	for (std::vector<std::string>::iterator it = type_vector.begin(); it != type_vector.end(); it++)
	{
		type_map[*it] = 1;
	}

	//把所有分类显示出来
	CVerticalLayoutUI* pFenleiLayout = static_cast<CVerticalLayoutUI*>(this->FindSubControl(_T("setting_biaoqian_printer_type_layout")));
	pFenleiLayout->RemoveAll();

	CSqlite3 sqlite_2;
	std::vector<CFoodType> foodtypes = sqlite_2.GetFoodtypes();
	for (std::vector<CFoodType>::iterator it = foodtypes.begin(); it != foodtypes.end(); it++)
	{
		CDialogBuilder builder;
		CListContainerElementUI* pEle = static_cast<CListContainerElementUI*>(builder.Create(_T("biaoqian_printer_setting_fenlei_select.xml"), (UINT)0, NULL, m_pManager));

		CCheckBoxUI* pCheck = static_cast<CCheckBoxUI*>(pEle->FindSubControl(_T("biaoqian_setting_fenleli_xuanze_checkbox")));
		pCheck->AddCustomAttribute(L"type_id", CLewaimaiString::UTF8ToUnicode((*it).id).c_str());

		if (type_map.find((*it).id) != type_map.end())
		{
			pCheck->Selected(true, false);
		}

		CLabelUI* pName = static_cast<CLabelUI*>(pEle->FindSubControl(_T("biaoqian_setting_fenleli_xuanze_name")));
		pName->SetText(CLewaimaiString::UTF8ToUnicode((*it).name).c_str());

		pFenleiLayout->Add(pEle);
	}

	pFenleiLayout->SetFixedHeight(foodtypes.size() * 30);


	//这里开始，初始化厨房打印机的设置
	CListUI* pPrinterList = static_cast<CListUI*>(this->FindSubControl(_T("setting_chufang_printer_list")));
	pPrinterList->RemoveAll();

	//获取厨房打印机的集合
	std::vector<ChufangPrinter> printers = CSetting::GetInstance()->getChufangPrints();

	for (std::vector<ChufangPrinter>::iterator it = printers.begin(); it != printers.end(); it++)
	{
		ChufangPrinter newPrinter = *it;
		CDialogBuilder builder;
		CListContainerElementUI* pEle = static_cast<CListContainerElementUI*>(builder.Create(_T("setting_chufang_printer_item.xml"), (UINT)0, NULL, m_pManager));

		CLabelUI* pName = static_cast<CLabelUI*>(pEle->FindSubControl(_T("setting_chufang_printer_item_name")));
		pName->SetText(CLewaimaiString::UTF8ToUnicode(newPrinter.name).c_str());

		CLabelUI* pIP = static_cast<CLabelUI*>(pEle->FindSubControl(_T("setting_chufang_printer_item_ip")));
		pIP->SetText(CLewaimaiString::UTF8ToUnicode(newPrinter.ip).c_str());

		CLabelUI* pGuige = static_cast<CLabelUI*>(pEle->FindSubControl(_T("setting_chufang_printer_guige")));

		if (newPrinter.guige == "58")
		{
			pGuige->SetText(L"58mm");
		}
		else
		{
			pGuige->SetText(L"80mm");
		}

		CLabelUI* pFendan = static_cast<CLabelUI*>(pEle->FindSubControl(_T("setting_chufang_printer_fendan")));

		if (newPrinter.fendan == "1")
		{
			pFendan->SetText(L"是");
		}
		else
		{
			pFendan->SetText(L"否");
		}

		CLabelUI* pFenlei = static_cast<CLabelUI*>(pEle->FindSubControl(_T("setting_chufang_printer_item_fenlei")));

		if (newPrinter.fenlei == "1")
		{
			pFenlei->SetText(L"是");
		}
		else
		{
			pFenlei->SetText(L"否");
		}

		std::string foodtypeNames = "";

		std::string foodtype_ids = newPrinter.fenlei_ids;

		//这个是删除掉不存在的type_id之后的
		std::string new_foodtype_ids = "";

		std::vector<std::string> ids = CLewaimaiString::Split(foodtype_ids, ",");

		CSqlite3 sqlite;
		for (std::vector<std::string>::iterator it = ids.begin(); it != ids.end(); it++)
		{
			CFoodType type;
			bool ret = sqlite.GetFoodtypeById((*it), type);
			if (!ret)
			{
				//分类被删掉了
				continue;
			}

			std::string name = type.name;

			foodtypeNames += name + CLewaimaiString::UnicodeToUTF8(L"、");

			new_foodtype_ids += (*it) + ",";
		}

		//删掉不存在的type_id，更新内存和数据库
		new_foodtype_ids = new_foodtype_ids.substr(0, new_foodtype_ids.length() - 1);

		if (new_foodtype_ids.compare(foodtype_ids) != 0)
		{
			CSetting::GetInstance()->UpdateChufangPrinter(newPrinter.date, newPrinter.name, newPrinter.ip, newPrinter.guige, newPrinter.fendan, newPrinter.fenlei, new_foodtype_ids, true);
		}

		std::wstring ws_foodtypeNames = CLewaimaiString::UTF8ToUnicode(foodtypeNames);
		ws_foodtypeNames = ws_foodtypeNames.substr(0, ws_foodtypeNames.size() - 1);

		CLabelUI* pFenleiIds = static_cast<CLabelUI*>(pEle->FindSubControl(_T("setting_chufang_printer_item_fenlei_ids")));
		pFenleiIds->SetText(ws_foodtypeNames.c_str());

		//设置标记属性，用于修改时候匹配
		pEle->AddCustomAttribute(L"date", CLewaimaiString::UTF8ToUnicode(newPrinter.date).c_str());
		pPrinterList->Add(pEle);
	}

	//初始化AI识别的设置
	box = static_cast<CCheckBoxUI *>(this->FindSubControl(_T("setting_is_ai_recognition_open")));
	if (CSetting::GetInstance()->GetParam("setting_is_ai_recognition_open") == "1")
	{
		box->Selected(true, false);
	}
	else
	{
		box->Selected(false, false);
	}

	//初始化展示设置
	CCheckBoxUI* box_youtu = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("xianshi_setting_youtu")));
	CCheckBoxUI* box_wutu = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("xianshi_setting_wutu")));
	if (CSetting::GetInstance()->GetParam("setting_xianshi_is_youtu") == "1")
	{
		box_youtu->Selected(true, false);
		box_wutu->Selected(false, false);
	}
	else
	{
		box_youtu->Selected(false, false);
		box_wutu->Selected(true, false);
	}
	
	//初始化快捷键展示
	this->InitKuaijiejianShow();
}

void CSettingPageUI::InitShow()
{

}

//处理按钮点击类事件
void CSettingPageUI::HandleClickMsg(TNotifyUI& msg)
{
	CDuiString name = msg.pSender->GetName();
	std::wstring ws_name = name;

	//开始处理设置页面的
	if (name == _T("setting_is_new_waimai_voice"))
	{
		CCheckBoxUI* box = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_is_new_waimai_voice")));

		//注意这里的IsSelected如果为true，表示的是点击前为true，而不是点击后为true，所以这里设置状态要反过来
		if (box->IsSelected())
		{
			CSetting::GetInstance()->SetParam("setting_is_new_waimai_voice", "0");
		}
		else
		{
			CSetting::GetInstance()->SetParam("setting_is_new_waimai_voice", "1");
		}
	}
	else if (name == _T("setting_is_new_waimai_autoconfirm"))
	{
		CCheckBoxUI* box = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_is_new_waimai_autoconfirm")));

		if (box->IsSelected())
		{
			CSetting::GetInstance()->SetParam("setting_is_new_waimai_autoconfirm", "0");
		}
		else
		{
			CSetting::GetInstance()->SetParam("setting_is_new_waimai_autoconfirm", "1");
		}
	}
	else if (name == _T("setting_is_new_waimai_printer"))
	{
		CCheckBoxUI* box = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_is_new_waimai_printer")));

		if (box->IsSelected())
		{
			CSetting::GetInstance()->SetParam("setting_is_new_waimai_printer", "0");
		}
		else
		{
			CSetting::GetInstance()->SetParam("setting_is_new_waimai_printer", "1");
		}
	}
	else if (name == _T("setting_is_new_waimai_biaoqian_printer"))
	{
		CCheckBoxUI* box = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_is_new_waimai_biaoqian_printer")));

		if (box->IsSelected())
		{
			CSetting::GetInstance()->SetParam("setting_is_new_waimai_biaoqian_printer", "0");
		}
		else
		{
			CSetting::GetInstance()->SetParam("setting_is_new_waimai_biaoqian_printer", "1");
		}
	}
	else if (name == _T("setting_is_new_waimai_chufang_printer"))
	{
		CCheckBoxUI* box = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_is_new_waimai_chufang_printer")));

		if (box->IsSelected())
		{
			CSetting::GetInstance()->SetParam("setting_is_new_waimai_chufang_printer", "0");
		}
		else
		{
			CSetting::GetInstance()->SetParam("setting_is_new_waimai_chufang_printer", "1");
		}
	}
	else if (name == _T("setting_is_new_diannei_voice"))
	{
		CCheckBoxUI* box = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_is_new_diannei_voice")));

		//注意这里的IsSelected如果为true，表示的是点击前为true，而不是点击后为true，所以这里设置状态要反过来
		if (box->IsSelected())
		{
			CSetting::GetInstance()->SetParam("setting_is_new_diannei_voice", "0");
		}
		else
		{
			CSetting::GetInstance()->SetParam("setting_is_new_diannei_voice", "1");
		}
	}
	else if (name == _T("setting_is_new_diannei_printer"))
	{
		CCheckBoxUI* box = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_is_new_diannei_printer")));

		if (box->IsSelected())
		{
			CSetting::GetInstance()->SetParam("setting_is_new_diannei_printer", "0");
		}
		else
		{
			CSetting::GetInstance()->SetParam("setting_is_new_diannei_printer", "1");
		}
	}
	else if (name == _T("setting_is_new_diannei_biaoqian_printer"))
	{
		CCheckBoxUI* box = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_is_new_diannei_biaoqian_printer")));

		if (box->IsSelected())
		{
			CSetting::GetInstance()->SetParam("setting_is_new_diannei_biaoqian_printer", "0");
		}
		else
		{
			CSetting::GetInstance()->SetParam("setting_is_new_diannei_biaoqian_printer", "1");
		}
	}
	else if (name == _T("setting_is_new_diannei_chufang_printer"))
	{
		CCheckBoxUI* box = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_is_new_diannei_chufang_printer")));

		if (box->IsSelected())
		{
			CSetting::GetInstance()->SetParam("setting_is_new_diannei_chufang_printer", "0");
		}
		else
		{
			CSetting::GetInstance()->SetParam("setting_is_new_diannei_chufang_printer", "1");
		}
	}
	else if (name == _T("setting_is_new_diannei_saomadiancan_printer"))
	{
		CCheckBoxUI* box = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_is_new_diannei_saomadiancan_printer")));

		if (box->IsSelected())
		{
			CSetting::GetInstance()->SetParam("setting_is_new_diannei_saomadiancan_printer", "0");
		}
		else
		{
			CSetting::GetInstance()->SetParam("setting_is_new_diannei_saomadiancan_printer", "1");
		}
	}
	else if (name == _T("setting_is_diannei_xianjin_qianxiang"))
	{
		CCheckBoxUI* box = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_is_diannei_xianjin_qianxiang")));

		if (box->IsSelected())
		{
			CSetting::GetInstance()->SetParam("setting_is_diannei_xianjin_qianxiang", "0");
		}
		else
		{
			CSetting::GetInstance()->SetParam("setting_is_diannei_xianjin_qianxiang", "1");
		}
	}
	else if (name == _T("setting_printer_wangkouk_save_btn"))
	{
		CEditUI* wangkou_ip = static_cast<CEditUI*>(this->FindSubControl(_T("setting_printer_wangkou_ip")));
		std::wstring ip = wangkou_ip->GetText();

		CSetting::GetInstance()->SetParam("setting_printer_wangkou_ip", CLewaimaiString::UnicodeToUTF8(ip));
	}
	else if (name == _T("setting_printer_quhuo_big"))
	{
		CCheckBoxUI* box = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_printer_quhuo_big")));

		if (box->IsSelected())
		{
			CSetting::GetInstance()->SetParam("setting_printer_quhuo_big", "0");
		}
		else
		{
			CSetting::GetInstance()->SetParam("setting_printer_quhuo_big", "1");
		}
	}
	else if (name == _T("setting_printer_dingdanhao_big"))
	{
		CCheckBoxUI* box = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_printer_dingdanhao_big")));

		if (box->IsSelected())
		{
			CSetting::GetInstance()->SetParam("setting_printer_dingdanhao_big", "0");
		}
		else
		{
			CSetting::GetInstance()->SetParam("setting_printer_dingdanhao_big", "1");
		}
	}
	else if (name == _T("setting_printer_xiadanshijian_big"))
	{
		CCheckBoxUI* box = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_printer_xiadanshijian_big")));

		if (box->IsSelected())
		{
			CSetting::GetInstance()->SetParam("setting_printer_xiadanshijian_big", "0");
		}
		else
		{
			CSetting::GetInstance()->SetParam("setting_printer_xiadanshijian_big", "1");
		}
	}
	else if (name == _T("setting_printer_peisongshijian_big"))
	{
		CCheckBoxUI* box = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_printer_peisongshijian_big")));

		if (box->IsSelected())
		{
			CSetting::GetInstance()->SetParam("setting_printer_peisongshijian_big", "0");
		}
		else
		{
			CSetting::GetInstance()->SetParam("setting_printer_peisongshijian_big", "1");
		}
	}
	else if (name == _T("setting_printer_name_big"))
	{
		CCheckBoxUI* box = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_printer_name_big")));

		if (box->IsSelected())
		{
			CSetting::GetInstance()->SetParam("setting_printer_name_big", "0");
		}
		else
		{
			CSetting::GetInstance()->SetParam("setting_printer_name_big", "1");
		}
	}
	else if (name == _T("setting_printer_phone_big"))
	{
		CCheckBoxUI* box = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_printer_phone_big")));

		if (box->IsSelected())
		{
			CSetting::GetInstance()->SetParam("setting_printer_phone_big", "0");
		}
		else
		{
			CSetting::GetInstance()->SetParam("setting_printer_phone_big", "1");
		}
	}
	else if (name == _T("setting_printer_address_big"))
	{
		CCheckBoxUI* box = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_printer_address_big")));

		if (box->IsSelected())
		{
			CSetting::GetInstance()->SetParam("setting_printer_address_big", "0");
		}
		else
		{
			CSetting::GetInstance()->SetParam("setting_printer_address_big", "1");
		}
	}
	else if (name == _T("setting_printer_shangpin_big"))
	{
		CCheckBoxUI* box = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_printer_shangpin_big")));

		if (box->IsSelected())
		{
			CSetting::GetInstance()->SetParam("setting_printer_shangpin_big", "0");
		}
		else
		{
			CSetting::GetInstance()->SetParam("setting_printer_shangpin_big", "1");
		}
	}
	else if (name == _T("setting_printer_memo_big"))
	{
		CCheckBoxUI* box = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_printer_memo_big")));

		if (box->IsSelected())
		{
			CSetting::GetInstance()->SetParam("setting_printer_memo_big", "0");
		}
		else
		{
			CSetting::GetInstance()->SetParam("setting_printer_memo_big", "1");
		}
	}
	else if (name == _T("setting_printer_price_big"))
	{
		CCheckBoxUI* box = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_printer_price_big")));

		if (box->IsSelected())
		{
			CSetting::GetInstance()->SetParam("setting_printer_price_big", "0");
		}
		else
		{
			CSetting::GetInstance()->SetParam("setting_printer_price_big", "1");
		}
	}
	else if (name == _T("setting_printer_pay_big"))
	{
		CCheckBoxUI* box = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_printer_pay_big")));

		if (box->IsSelected())
		{
			CSetting::GetInstance()->SetParam("setting_printer_pay_big", "0");
		}
		else
		{
			CSetting::GetInstance()->SetParam("setting_printer_pay_big", "1");
		}
	}
	else if (name == _T("setting_biaoqian_printer_wangkouk_save_btn"))
	{
		CEditUI* wangkou_ip = static_cast<CEditUI*>(this->FindSubControl(_T("setting_biaoqian_printer_wangkou_ip")));
		std::wstring ip = wangkou_ip->GetText();

		CSetting::GetInstance()->SetParam("setting_biaoqian_printer_wangkou_ip", CLewaimaiString::UnicodeToUTF8(ip));
	}
	else if (name == _T("setting_biaoqian_printer_is_type"))
	{
		CCheckBoxUI* box = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_biaoqian_printer_is_type")));

		if (box->IsSelected())
		{
			CSetting::GetInstance()->SetParam("setting_biaoqian_printer_is_type", "0");
		}
		else
		{
			CSetting::GetInstance()->SetParam("setting_biaoqian_printer_is_type", "1");
		}
	}
	else if (name == L"biaoqian_setting_fenleli_xuanze_checkbox")
	{
		std::wstring ws_type_id = msg.pSender->GetCustomAttribute(L"type_id");
		std::string type_id = CLewaimaiString::UnicodeToUTF8(ws_type_id);

		CCheckBoxUI* box = static_cast<CCheckBoxUI*>(msg.pSender);
		
		if (box->IsSelected())
		{
			//这里是从选中变为不选中，那么就删掉这个type_id
			std::string type_ids = CSetting::GetInstance()->GetParam("setting_biaoqian_printer_type_ids");
			std::vector<std::string> type_vector = CLewaimaiString::Split(type_ids, ",");

			int num = 0;
			for (std::vector<std::string>::iterator it = type_vector.begin(); it != type_vector.end(); it++)
			{
				if (*it == type_id)
				{
					break;
				}

				num++;
			}

			type_vector.erase(type_vector.begin() + num);

			std::string new_type_ids = CLewaimaiString::Merge(type_vector, ",");

			CSetting::GetInstance()->SetParam("setting_biaoqian_printer_type_ids", new_type_ids);
		}
		else
		{
			//这是从不选中变为选中
			std::string type_ids = CSetting::GetInstance()->GetParam("setting_biaoqian_printer_type_ids");

			std::string new_type_ids;
			if (type_ids == "")
			{
				new_type_ids = type_id;
			}
			else
			{
				new_type_ids = type_ids + "," + type_id;
			}		

			CSetting::GetInstance()->SetParam("setting_biaoqian_printer_type_ids", new_type_ids);
		}
	}
	else if (name == _T("setting_new_chufang_printer_btn"))
	{
		CChufangSettingWnd* pChufangFrame = new CChufangSettingWnd(1);

		if (pChufangFrame != NULL)
		{
			pChufangFrame->Create(m_pManager->GetPaintWindow(), _T(""), UI_WNDSTYLE_DIALOG, WS_EX_WINDOWEDGE);
			pChufangFrame->SetIcon(IDI_ICON_DUILIB);
			pChufangFrame->CenterWindow();
			UINT ret = pChufangFrame->ShowModal();

			if (ret == IDOK)
			{
				//这个时候是点击保存返回了，厨房打印机的数据已经建立好了，这个时候刷新表格的显示
				CListUI* pPrinterList = static_cast<CListUI*>(this->FindSubControl(_T("setting_chufang_printer_list")));

				//把最后一个厨房打印机取出来

				ChufangPrinter newPrinter = CSetting::GetInstance()->getLastChufangPrinter();
				CDialogBuilder builder;
				CListContainerElementUI* pEle = static_cast<CListContainerElementUI*>(builder.Create(_T("setting_chufang_printer_item.xml"), (UINT)0, NULL, m_pManager));

				CLabelUI* pName = static_cast<CLabelUI*>(pEle->FindSubControl(_T("setting_chufang_printer_item_name")));
				pName->SetText(CLewaimaiString::UTF8ToUnicode(newPrinter.name).c_str());

				CLabelUI* pIP = static_cast<CLabelUI*>(pEle->FindSubControl(_T("setting_chufang_printer_item_ip")));
				pIP->SetText(CLewaimaiString::UTF8ToUnicode(newPrinter.ip).c_str());

				CLabelUI* pGuige = static_cast<CLabelUI*>(pEle->FindSubControl(_T("setting_chufang_printer_guige")));

				if (newPrinter.guige == "58")
				{
					pGuige->SetText(L"58mm");
				}
				else
				{
					pGuige->SetText(L"80mm");
				}

				CLabelUI* pFendan = static_cast<CLabelUI*>(pEle->FindSubControl(_T("setting_chufang_printer_fendan")));

				if (newPrinter.fendan == "1")
				{
					pFendan->SetText(L"是");
				}
				else
				{
					pFendan->SetText(L"否");
				}

				CLabelUI* pFenlei = static_cast<CLabelUI*>(pEle->FindSubControl(_T("setting_chufang_printer_item_fenlei")));

				if (newPrinter.fenlei == "1")
				{
					pFenlei->SetText(L"是");
				}
				else
				{
					pFenlei->SetText(L"否");
				}

				std::string foodtypeNames = "";

				std::string foodtype_ids = newPrinter.fenlei_ids;
				std::vector<std::string> ids = CLewaimaiString::Split(foodtype_ids, ",");

				CSqlite3 sqlite;
				for (std::vector<std::string>::iterator it = ids.begin(); it != ids.end(); it++)
				{
					CFoodType foodtype;
					bool ret = sqlite.GetFoodtypeById(*it, foodtype);
					if (!ret)
					{
						continue;
					}

					std::string name = foodtype.name;
					std::wstring ws_name = CLewaimaiString::UTF8ToUnicode(name);
					foodtypeNames += name + "  ";
				}

				foodtypeNames = foodtypeNames.substr(0, foodtypeNames.size() - 1);
				std::wstring ws_foodtypeNames = CLewaimaiString::UTF8ToUnicode(foodtypeNames);

				CLabelUI* pFenleiIds = static_cast<CLabelUI*>(pEle->FindSubControl(_T("setting_chufang_printer_item_fenlei_ids")));
				pFenleiIds->SetText(ws_foodtypeNames.c_str());

				pEle->AddCustomAttribute(L"date", CLewaimaiString::UTF8ToUnicode(newPrinter.date).c_str());
				pPrinterList->Add(pEle);
			}
		}
	}
	else if (name == _T("setting_is_auto_start"))
	{
		CCheckBoxUI* box = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_is_auto_start")));

		if (box->IsSelected())
		{
			CSetting::GetInstance()->SetParam("setting_is_auto_start", "0");
			CSystem::cancelAutoStart();
		}
		else
		{
			CSetting::GetInstance()->SetParam("setting_is_auto_start", "1");
			CSystem::autostart();
		}
	}
	else if (name == _T("setting_is_auto_login"))
	{
		CCheckBoxUI* box = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_is_auto_login")));

		if (box->IsSelected())
		{
			CSetting::GetInstance()->SetParam("setting_is_auto_login", "0");
		}
		else
		{
			CSetting::GetInstance()->SetParam("setting_is_auto_login", "1");
		}
	}
	else if (name == _T("setting_is_close_min"))
	{
		CCheckBoxUI* box = static_cast<CCheckBoxUI*>(this->FindSubControl(_T("setting_is_close_min")));

		if (box->IsSelected())
		{
			CSetting::GetInstance()->SetParam("setting_is_close_min", "0");
		}
		else
		{
			CSetting::GetInstance()->SetParam("setting_is_close_min", "1");
		}
	}
	else if (name == _T("setting_chufang_printer_item_update_btn"))
	{
		CListUI* pPrinterList = static_cast<CListUI*>(this->FindSubControl(_T("setting_chufang_printer_list")));
		CListContainerElementUI* pEle = static_cast<CListContainerElementUI*>(msg.pSender->GetParent()->GetParent()->GetParent());
		std::wstring date = pEle->GetCustomAttribute(L"date");
		CChufangSettingWnd* pChufangFrame = new CChufangSettingWnd(2);
		pChufangFrame->SetPrinterDate(CLewaimaiString::UnicodeToUTF8(date));

		if (pChufangFrame != NULL)
		{
			pChufangFrame->Create(m_pManager->GetPaintWindow(), _T(""), UI_WNDSTYLE_DIALOG, WS_EX_WINDOWEDGE);
			pChufangFrame->SetIcon(IDI_ICON_DUILIB);
			pChufangFrame->CenterWindow();
			UINT ret = pChufangFrame->ShowModal();

			if (ret == IDOK)
			{
				//这个时候是点击保存返回了，厨房打印机的数据已经建立好了，这个时候刷新表格的显示
				CListUI* pPrinterList = static_cast<CListUI*>(this->FindSubControl(_T("setting_chufang_printer_list")));
				ChufangPrinter newPrinter = CSetting::GetInstance()->GetChufangPrinter(CLewaimaiString::UnicodeToUTF8(date));
				CLabelUI* pName = static_cast<CLabelUI*>(pEle->FindSubControl(_T("setting_chufang_printer_item_name")));
				pName->SetText(CLewaimaiString::UTF8ToUnicode(newPrinter.name).c_str());
				CLabelUI* pIP = static_cast<CLabelUI*>(pEle->FindSubControl(_T("setting_chufang_printer_item_ip")));
				pIP->SetText(CLewaimaiString::UTF8ToUnicode(newPrinter.ip).c_str());
				CLabelUI* pGuige = static_cast<CLabelUI*>(pEle->FindSubControl(_T("setting_chufang_printer_guige")));

				if (newPrinter.guige == "58")
				{
					pGuige->SetText(L"58mm");
				}
				else
				{
					pGuige->SetText(L"80mm");
				}

				CLabelUI* pFendan = static_cast<CLabelUI*>(pEle->FindSubControl(_T("setting_chufang_printer_fendan")));

				if (newPrinter.fendan == "1")
				{
					pFendan->SetText(L"是");
				}
				else
				{
					pFendan->SetText(L"否");
				}

				CLabelUI* pFenlei = static_cast<CLabelUI*>(pEle->FindSubControl(_T("setting_chufang_printer_item_fenlei")));

				if (newPrinter.fenlei == "1")
				{
					pFenlei->SetText(L"是");
				}
				else
				{
					pFenlei->SetText(L"否");
				}

				std::string foodtypeNames = "";

				std::string foodtype_ids = newPrinter.fenlei_ids;
				std::vector<std::string> ids = CLewaimaiString::Split(foodtype_ids, ",");

				CSqlite3 sqlite;
				for (std::vector<std::string>::iterator it = ids.begin(); it != ids.end(); it++)
				{
					CFoodType foodtype;
					bool ret = sqlite.GetFoodtypeById(*it, foodtype);
					if (!ret)
					{
						continue;
					}

					std::string name = foodtype.name;
					std::wstring ws_name = CLewaimaiString::UTF8ToUnicode(name);
					foodtypeNames += name + "  ";
				}

				foodtypeNames = foodtypeNames.substr(0, foodtypeNames.size() - 1);
				std::wstring ws_foodtypeNames = CLewaimaiString::UTF8ToUnicode(foodtypeNames);

				CLabelUI* pFenleiIds = static_cast<CLabelUI*>(pEle->FindSubControl(_T("setting_chufang_printer_item_fenlei_ids")));
				pFenleiIds->SetText(ws_foodtypeNames.c_str());
			}
		}
	}
	else if (name == _T("setting_chufang_printer_item_delete_btn"))
	{
		CListUI* pPrinterList = static_cast<CListUI*>(this->FindSubControl(_T("setting_chufang_printer_list")));
		CListContainerElementUI* pEle = static_cast<CListContainerElementUI*>(msg.pSender->GetParent()->GetParent()->GetParent());
		std::wstring date = pEle->GetCustomAttribute(L"date");
		//获得了ID，这个时候从内存和数据库中分别删除对应的记录
		CSetting::GetInstance()->DelChufangPrinter(CLewaimaiString::UnicodeToUTF8(date));
		pPrinterList->Remove(pEle);
	}
	else if (name == L"setting_tiaomacheng_saveip")
	{
		CEditUI* wangkou_ip = static_cast<CEditUI*>(this->FindSubControl(_T("setting_tiaomacheng_ip")));
		std::wstring ip = wangkou_ip->GetText();

		CSetting::GetInstance()->SetParam("setting_tiaomacheng_ip", CLewaimaiString::UnicodeToUTF8(ip));
	}
	else if (name == L"setting_tiaomacheng_tongbushangpin")
	{
		this->StartTongbuBiaoqiancheng();
	}
	else if (name == L"setting_tiaomacheng_tongburejian")
	{
		this->StartTongbuRejian();
	}
	else if (name == L"setting_tiaomacheng_qingkongplu")
	{
		this->StartQiongkongPLU();
	}
	else if (name == _T("setting_is_ai_recognition_open"))
	{
		CCheckBoxUI * box = static_cast<CCheckBoxUI *>(this->FindSubControl(_T("setting_is_ai_recognition_open")));

		if (box->IsSelected())
		{
			CSetting::GetInstance()->SetParam("setting_is_ai_recognition_open", "0");
		}
		else
		{
			CSetting::GetInstance()->SetParam("setting_is_ai_recognition_open", "1");
		}
	}
	else if (name == _T("setting_logout"))
	{
		//退出登录
		m_pMainWnd->LoginOut(1);
	}
	else if (ws_name.find(L"setting_kuaijiejian_page_btn_") == 0)
	{
		//这个时候设置快捷键的状态和类型
		m_mod = 0;
		m_vk = 0;
		m_isSet = false;

		if (m_pMainWnd->GetIsKuaijiejianSetting() == false)
		{
			m_pMainWnd->SetIsKuaijiejianSetting(true);
		}

		if (name == L"setting_kuaijiejian_page_btn_weixinshoukuan")
		{			
			m_kuaijiejian_type = 1;
		}
		else if (name == L"setting_kuaijiejian_page_btn_huiyuandenglu")
		{
			m_kuaijiejian_type = 2;
		}
		else if (name == L"setting_kuaijiejian_page_btn_huiyuanshoukuan")
		{
			m_kuaijiejian_type = 3;
		}
		else if (name == L"setting_kuaijiejian_page_btn_xianjinshoukuan")
		{
			m_kuaijiejian_type = 4;
		}
		else if (name == L"setting_kuaijiejian_page_btn_qianxiang")
		{
			m_kuaijiejian_type = 5;
		}
		else if (name == L"setting_kuaijiejian_page_btn_logout")
		{
			m_kuaijiejian_type = 6;
		}
		else if (name == L"setting_kuaijiejian_page_btn_tiaozhuan_diandan")
		{
			m_kuaijiejian_type = 7;
		}
		else if (name == L"setting_kuaijiejian_page_btn_tiaozhuan_dingdan")
		{
			m_kuaijiejian_type = 8;
		}
		else if (name == L"setting_kuaijiejian_page_btn_tiaozhuan_huiyuan")
		{
			m_kuaijiejian_type = 9;
		}
		else if (name == L"setting_kuaijiejian_page_btn_tiaozhuan_baobiao")
		{
			m_kuaijiejian_type = 10;
		}
		else if (name == L"setting_kuaijiejian_page_btn_tiaozhuan_jiaoban")
		{
			m_kuaijiejian_type = 11;
		}
		else if (name == L"setting_kuaijiejian_page_btn_tiaozhuan_shezhi")
		{
			m_kuaijiejian_type = 12;
		}
		else if (name == L"setting_kuaijiejian_page_btn_tiaozhuan_shangpin")
		{
			m_kuaijiejian_type = 13;
		}
		else if (name == L"setting_kuaijiejian_page_btn_tiaozhuan_kucun")
		{
			m_kuaijiejian_type = 14;
		}
		else if (name == L"setting_kuaijiejian_page_btn_tiaozhuan_caigou")
		{
			m_kuaijiejian_type = 15;
		}
		else if (name == L"setting_kuaijiejian_page_btn_tiaozhuan_zhuotai")
		{
			m_kuaijiejian_type = 16;
		}
		else if (name == L"setting_kuaijiejian_page_btn_tiaozhuan_shoukuan")
		{
			m_kuaijiejian_type = 17;
		}
	}
	else if (name == L"setting_tongbu_btn")
	{
		StartTongbu();
	}
}

//处理option切换事件，radio事件
void CSettingPageUI::HandleSelectChangeMsg(TNotifyUI& msg)
{
	CDuiString name = msg.pSender->GetName();

	//判断设置中心的tab
	if (name == _T("setting_waimai_order_switch"))
	{
		CTabLayoutUI* pControl = static_cast<CTabLayoutUI*>(this->FindSubControl(_T("setting_switch")));
		pControl->SelectItem(0);
	}
	if (name == _T("setting_diannei_order_switch"))
	{
		CTabLayoutUI* pControl = static_cast<CTabLayoutUI*>(this->FindSubControl(_T("setting_switch")));
		pControl->SelectItem(1);
	}
	else if (name == _T("setting_printer_switch"))
	{
		CTabLayoutUI* pControl = static_cast<CTabLayoutUI*>(this->FindSubControl(_T("setting_switch")));
		pControl->SelectItem(2);
	}
	else if (name == _T("setting_biaoqian_printer_switch"))
	{
		CTabLayoutUI* pControl = static_cast<CTabLayoutUI*>(this->FindSubControl(_T("setting_switch")));
		pControl->SelectItem(3);
	}
	else if (name == _T("setting_chufang_printer_switch"))
	{
		CTabLayoutUI* pControl = static_cast<CTabLayoutUI*>(this->FindSubControl(_T("setting_switch")));
		pControl->SelectItem(4);
	}
	else if (name == _T("setting_dianzicheng_switch"))
	{
		CTabLayoutUI* pControl = static_cast<CTabLayoutUI*>(this->FindSubControl(_T("setting_switch")));
		pControl->SelectItem(5);
	}
	else if (name == _T("setting_tiaomacheng_switch"))
	{
		CTabLayoutUI* pControl = static_cast<CTabLayoutUI*>(this->FindSubControl(_T("setting_switch")));
		pControl->SelectItem(6);
	}
	else if (name == _T("setting_ai_recognition_switch"))
	{
		CTabLayoutUI * pControl = static_cast<CTabLayoutUI *>(this->FindSubControl(_T("setting_switch")));
		pControl->SelectItem(7);
	}
	else if (name == _T("setting_xianshi_switch"))
	{
		CTabLayoutUI* pControl = static_cast<CTabLayoutUI*>(this->FindSubControl(_T("setting_switch")));
		pControl->SelectItem(8);
	}
	else if (name == _T("setting_tongbu_switch"))
	{
		CTabLayoutUI* pControl = static_cast<CTabLayoutUI*>(this->FindSubControl(_T("setting_switch")));
		pControl->SelectItem(9);

		CLabelUI* label = static_cast<CLabelUI*>(this->FindSubControl(L"setting_tongbu_result"));
		label->SetVisible(false);
	}
	else if (name == _T("setting_kuaijiejian_switch"))
	{
		CTabLayoutUI* pControl = static_cast<CTabLayoutUI*>(this->FindSubControl(_T("setting_switch")));
		pControl->SelectItem(10);

		CButtonUI* focusEdit = static_cast<CButtonUI*>(this->FindSubControl(_T("setting_kuaijiejian_page_btn_weixinshoukuan")));
		
		m_pManager->SetFocus(NULL);
	}
	else if (name == _T("setting_system_switch"))
	{
		CTabLayoutUI* pControl = static_cast<CTabLayoutUI*>(this->FindSubControl(_T("setting_switch")));
		pControl->SelectItem(11);
	}
	else if (name == _T("setting_system_about"))
	{
		CTabLayoutUI* pControl = static_cast<CTabLayoutUI*>(this->FindSubControl(_T("setting_switch")));
		pControl->SelectItem(12);
	}
	else if (name == _T("xianshi_setting_youtu"))
	{
		CSetting::GetInstance()->SetParam("setting_xianshi_is_youtu", "1");
	}
	else if (name == _T("xianshi_setting_wutu"))
	{
		CSetting::GetInstance()->SetParam("setting_xianshi_is_youtu", "0");
	}
	else if (name == _T("setting_dianzicheng_yilianjie"))
	{
		CSetting::GetInstance()->SetParam("setting_dianzicheng_is_lianjie", "1");

		CVerticalLayoutUI* dianzicheng_layout = static_cast<CVerticalLayoutUI*>(this->FindSubControl(_T("setting_dianzicheng_layout")));
		dianzicheng_layout->SetVisible(true);
	}
	else if (name == _T("setting_dianzicheng_weilianjie"))
	{
		CSetting::GetInstance()->SetParam("setting_dianzicheng_is_lianjie", "0");

		CVerticalLayoutUI* dianzicheng_layout = static_cast<CVerticalLayoutUI*>(this->FindSubControl(_T("setting_dianzicheng_layout")));
		dianzicheng_layout->SetVisible(false);
	}
}

//处理下拉框、radio的切换事件
void CSettingPageUI::HandleItemSelectMsg(TNotifyUI& msg)
{
	CDuiString name = msg.pSender->GetName();

	if (name == _T("setting_printer_guige"))
	{
		CComboUI* com = static_cast<CComboUI*>(this->FindSubControl(_T("setting_printer_guige")));

		if (com->GetCurSel() == 0)
		{
			CSetting::GetInstance()->SetParam("setting_printer_guige", "58");
		}
		else
		{
			CSetting::GetInstance()->SetParam("setting_printer_guige", "80");
		}
	}
	else if (name == _T("setting_printer_lianshu"))
	{
		CComboUI* com = static_cast<CComboUI*>(this->FindSubControl(_T("setting_printer_lianshu")));

		if (com->GetCurSel() == 0)
		{
			CSetting::GetInstance()->SetParam("setting_printer_lianshu", "1");
		}
		else if (com->GetCurSel() == 1)
		{
			CSetting::GetInstance()->SetParam("setting_printer_lianshu", "2");
		}
		else if (com->GetCurSel() == 2)
		{
			CSetting::GetInstance()->SetParam("setting_printer_lianshu", "3");
		}
		else if (com->GetCurSel() == 3)
		{
			CSetting::GetInstance()->SetParam("setting_printer_lianshu", "4");
		}
	}
	else if (name == _T("setting_printer_leixing"))
	{
		CComboUI* com = static_cast<CComboUI*>(this->FindSubControl(_T("setting_printer_leixing")));

		CHorizontalLayoutUI* usb_layout = static_cast<CHorizontalLayoutUI*>(this->FindSubControl(_T("setting_printer_usb_layout")));
		CHorizontalLayoutUI* chuankou_layout = static_cast<CHorizontalLayoutUI*>(this->FindSubControl(_T("setting_printer_chuankou_layout")));
		CHorizontalLayoutUI* wangkou_layout = static_cast<CHorizontalLayoutUI*>(this->FindSubControl(_T("setting_printer_wangkou_layout")));

		if (com->GetCurSel() == 0)
		{
			CSetting::GetInstance()->SetParam("setting_printer_leixing", "auto");

			usb_layout->SetVisible(false);
			chuankou_layout->SetVisible(false);
			wangkou_layout->SetVisible(false);
		}
		else if (com->GetCurSel() == 1)
		{
			CSetting::GetInstance()->SetParam("setting_printer_leixing", "usb");

			//显示usb布局
			usb_layout->SetVisible(true);
			chuankou_layout->SetVisible(false);
			wangkou_layout->SetVisible(false);

			//usb下拉框默认选中
			CComboUI* com_usb = static_cast<CComboUI*>(this->FindSubControl(_T("setting_printer_usb")));
			com_usb->RemoveAll();

			//数据库中保存的之前的设置
			std::string setting_printer_usb = CSetting::GetInstance()->GetParam("setting_printer_usb");
			std::wstring ws_setting_printer_usb = CLewaimaiString::UTF8ToUnicode(setting_printer_usb);

			std::vector<std::wstring> usb_devices = CPosPrinterQueue::GetInstance()->getUsbDevices();

			int i = 0;
			int nSelect = -1;

			for (std::vector<std::wstring>::iterator it = usb_devices.begin(); it != usb_devices.end(); it++)
			{
				CListLabelElementUI* elem = new CListLabelElementUI();
				elem->SetText((*it).c_str());
				com_usb->Add(elem);

				if (*it == ws_setting_printer_usb)
				{
					nSelect = i;
				}

				i++;
			}

			com_usb->SetInternVisible(true);
			com_usb->SelectItem(nSelect, false);
			com_usb->SetText(CLewaimaiString::UTF8ToUnicode(setting_printer_usb).c_str());
		}
		else if (com->GetCurSel() == 2)
		{
			CSetting::GetInstance()->SetParam("setting_printer_leixing", "bingkou");

			usb_layout->SetVisible(false);
			chuankou_layout->SetVisible(false);
			wangkou_layout->SetVisible(false);
		}
		else if (com->GetCurSel() == 3)
		{
			CSetting::GetInstance()->SetParam("setting_printer_leixing", "chuankou");

			usb_layout->SetVisible(false);
			chuankou_layout->SetVisible(true);
			wangkou_layout->SetVisible(false);

			//串口下拉框默认选中
			CComboUI* com_chuankou = static_cast<CComboUI*>(this->FindSubControl(_T("setting_printer_com")));
			com_chuankou->RemoveAll();

			//数据库中保存的之前的设置
			std::string setting_printer_com = CSetting::GetInstance()->GetParam("setting_printer_com");
			std::wstring ws_setting_printer_com = CLewaimaiString::UTF8ToUnicode(setting_printer_com);

			CComHelper helper;
			std::vector<std::wstring> com_devices = helper.getComPort();

			int i = 0;
			int nSelect = -1;

			for (std::vector<std::wstring>::iterator it = com_devices.begin(); it != com_devices.end(); it++)
			{
				CListLabelElementUI* elem = new CListLabelElementUI();
				elem->SetText((*it).c_str());
				com_chuankou->Add(elem);

				if (*it == ws_setting_printer_com)
				{
					nSelect = i;
				}

				i++;
			}

			com_chuankou->SetInternVisible(true);
			com_chuankou->SelectItem(nSelect, false);
			com_chuankou->SetText(CLewaimaiString::UTF8ToUnicode(setting_printer_com).c_str());
		}
		else if (com->GetCurSel() == 4)
		{
			CSetting::GetInstance()->SetParam("setting_printer_leixing", "wangkou");

			usb_layout->SetVisible(false);
			chuankou_layout->SetVisible(false);
			wangkou_layout->SetVisible(true);

			std::string setting_printer_wangkou_ip = CSetting::GetInstance()->GetParam("setting_printer_wangkou_ip");

			CEditUI* ip_edit = static_cast<CEditUI*>(this->FindSubControl(_T("setting_printer_wangkou_ip")));
			ip_edit->SetText(CLewaimaiString::UTF8ToUnicode(setting_printer_wangkou_ip).c_str());
		}
	}
	else if (name == _T("setting_printer_usb"))
	{
		CComboUI* com = static_cast<CComboUI*>(this->FindSubControl(_T("setting_printer_usb")));
		std::wstring usb_device = com->GetText();

		CSetting::GetInstance()->SetParam("setting_printer_usb", CLewaimaiString::UnicodeToUTF8(usb_device));
	}
	else if (name == _T("setting_printer_com"))
	{
		CComboUI* com = static_cast<CComboUI*>(this->FindSubControl(_T("setting_printer_com")));
		std::wstring com_device = com->GetText();

		CSetting::GetInstance()->SetParam("setting_printer_com", CLewaimaiString::UnicodeToUTF8(com_device));
	}
	else if (name == _T("setting_dianzicheng_xinghao"))
	{
		CComboUI* com = static_cast<CComboUI*>(this->FindSubControl(_T("setting_dianzicheng_xinghao")));

		if (com->GetCurSel() == 0)
		{
			CSetting::GetInstance()->SetParam("setting_dianzicheng_xinghao", "dahua_acs");
		}
		else if (com->GetCurSel() == 1)
		{
			CSetting::GetInstance()->SetParam("setting_dianzicheng_xinghao", "dingjian_os2x");
		}

		CChengzhongWorker::GetInstance()->RestartWork();
	}
	else if (name == _T("setting_dianzicheng_chuankou"))
	{
		CComboUI* com = static_cast<CComboUI*>(this->FindSubControl(_T("setting_dianzicheng_chuankou")));
		std::wstring com_device = com->GetText();

		CSetting::GetInstance()->SetParam("setting_dianzicheng_com", CLewaimaiString::UnicodeToUTF8(com_device));

		CChengzhongWorker::GetInstance()->RestartWork();
	}
	else if (name == _T("setting_dianzicheng_botelv"))
	{
		CComboUI* com = static_cast<CComboUI*>(this->FindSubControl(_T("setting_dianzicheng_botelv")));
		std::wstring com_device = com->GetText();

		CSetting::GetInstance()->SetParam("setting_dianzicheng_botelv", CLewaimaiString::UnicodeToUTF8(com_device));

		CChengzhongWorker::GetInstance()->RestartWork();
	}
	else if (name == _T("setting_tiaomacheng_geshi"))
	{
		CComboUI* com = static_cast<CComboUI*>(this->FindSubControl(_T("setting_tiaomacheng_geshi")));
		int nSelect = com->GetCurSel();

		CSetting::GetInstance()->SetParam("setting_tiaomacheng_geshi", std::to_string(nSelect + 1));
	}
	else if (name == _T("setting_tiaomacheng_xinghao"))
	{
		CComboUI* com = static_cast<CComboUI*>(this->FindSubControl(_T("setting_tiaomacheng_xinghao")));

		if (com->GetCurSel() == 0)
		{
			CSetting::GetInstance()->SetParam("setting_tiaomacheng_xinghao", "dahua_tm");
		}
	}
	else if (name == _T("setting_biaoqian_printer_leixing"))
	{
		CComboUI* com = static_cast<CComboUI*>(this->FindSubControl(_T("setting_biaoqian_printer_leixing")));

		CHorizontalLayoutUI* usb_layout = static_cast<CHorizontalLayoutUI*>(this->FindSubControl(_T("setting_biaoqian_printer_usb_layout")));
		CHorizontalLayoutUI* wangkou_layout = static_cast<CHorizontalLayoutUI*>(this->FindSubControl(_T("setting_biaoqian_printer_wangkou_layout")));

		if (com->GetCurSel() == 0)
		{
			CSetting::GetInstance()->SetParam("setting_biaoqian_printer_leixing", "usb");

			//显示usb布局
			usb_layout->SetVisible(true);
			wangkou_layout->SetVisible(false);
		}
		else if (com->GetCurSel() == 1)
		{
			CSetting::GetInstance()->SetParam("setting_biaoqian_printer_leixing", "wangkou");

			usb_layout->SetVisible(false);
			wangkou_layout->SetVisible(true);
		}
	}
	else if (name == _T("setting_biaoqian_printer_usb"))
	{
		CComboUI* com = static_cast<CComboUI*>(this->FindSubControl(_T("setting_biaoqian_printer_usb")));
		std::wstring usb_device = com->GetText();;

		CSetting::GetInstance()->SetParam("setting_biaoqian_printer_usb", CLewaimaiString::UnicodeToUTF8(usb_device));
	}
	else if (name == _T("setting_biaoqian_printer_guige"))
	{
		CComboUI* com = static_cast<CComboUI*>(this->FindSubControl(_T("setting_biaoqian_printer_guige")));

		if (com->GetCurSel() == 0)
		{
			CSetting::GetInstance()->SetParam("setting_biaoqian_printer_guige", "40*30mm");
		}
		else if (com->GetCurSel() == 1)
		{
			CSetting::GetInstance()->SetParam("setting_biaoqian_printer_guige", "35*25mm");
		}
		else if (com->GetCurSel() == 2)
		{
			CSetting::GetInstance()->SetParam("setting_biaoqian_printer_guige", "30*25mm");
		}
		else if (com->GetCurSel() == 3)
		{
			CSetting::GetInstance()->SetParam("setting_biaoqian_printer_guige", "30*20mm");
		}
		else if (com->GetCurSel() == 4)
		{
			CSetting::GetInstance()->SetParam("setting_biaoqian_printer_guige", "60*80mm");
		}
		else if (com->GetCurSel() == 5)
		{
			CSetting::GetInstance()->SetParam("setting_biaoqian_printer_guige", "80*60mm");
		}
	}
	else if (name == _T("setting_biaoqian_printer_fangxiang"))
	{
		CComboUI* com = static_cast<CComboUI*>(this->FindSubControl(_T("setting_biaoqian_printer_fangxiang")));

		if (com->GetCurSel() == 0)
		{
			CSetting::GetInstance()->SetParam("setting_biaoqian_printer_fangxiang", "1");
		}
		else if (com->GetCurSel() == 1)
		{
			CSetting::GetInstance()->SetParam("setting_biaoqian_printer_fangxiang", "0");
		}
	}
}

//处理编辑框输入内容改变事件
void CSettingPageUI::HandleTextChangedMsg(TNotifyUI& msg)
{

}

//处理扫码枪捕捉到的扫码信息
void CSettingPageUI::HandleTextCapture(std::string content)
{

}

bool CSettingPageUI::HandleCustomMessage(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	if (uMsg == WM_SETTING_TONGBU_SUCCESS)
	{
		CLabelUI* label = static_cast<CLabelUI*>(this->FindSubControl(L"setting_tongbu_result"));

		label->SetText(L"同步成功！");
		label->SetVisible(true);
	}
	else if (uMsg == WM_SETTING_TONGBU_FAIL)
	{
		CLabelUI* label = static_cast<CLabelUI*>(this->FindSubControl(L"setting_tongbu_result"));

		label->SetText(m_tongbu_error.c_str());
		label->SetVisible(true);
	}
	else if (uMsg == WM_KEYDOWN || uMsg == WM_SYSKEYDOWN || uMsg == WM_KEYUP || uMsg == WM_SYSKEYUP)
	{
		//处理热键的键盘消息
		if (m_pMainWnd->GetIsKuaijiejianSetting() == true)
		{
			//正在设置快捷键
			return OnHotKeyDown(uMsg, wParam, lParam);
		}
	}

	return false;
}

bool CSettingPageUI::OnHotKeyDown(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	if (uMsg == WM_KEYDOWN || uMsg == WM_SYSKEYDOWN)
	{
		if (wParam != VK_CONTROL && wParam != VK_MENU && wParam != VK_SHIFT)
		{
			//这个情况，按的是字母键之类的
			CDuiString duiText;

			if (VK_F1 <= wParam && wParam <= VK_F12)
			{
				//快捷键就是F1到F12，不需要搭配ctrl之类的
				m_mod = 0;
				duiText.Format(_T("F%d"), wParam - VK_F1 + 1);
			}
			else if (wParam == VK_BACK || wParam == VK_DELETE)
			{
				//按了删除键，清空快捷键
				m_mod = 0;
				duiText = L"";
			}
			else if (m_mod == MOD_CONTROL)
			{
				duiText.Format(_T("CTRL + %c"), wParam);
			}
			else if (m_mod == MOD_ALT)
			{
				duiText.Format(_T("ALT + %c"), wParam);
			}
			else if (m_mod == MOD_SHIFT)
			{
				duiText.Format(_T("SHIFT + %c"), wParam);
			}
			else if (m_mod == 0)
			{
				//直接按的字母键，无效
				m_mod = 0;
				m_vk = 0;
				m_isSet = false;

				return true;
			}

			//到这里来设置成功了，做展示
			if (m_kuaijiejian_type == 1)
			{
				CButtonUI* focusEdit = static_cast<CButtonUI*>(this->FindSubControl(_T("setting_kuaijiejian_page_btn_weixinshoukuan")));
				focusEdit->SetText(duiText);
			}
			else if (m_kuaijiejian_type == 2)
			{
				CButtonUI* focusEdit = static_cast<CButtonUI*>(this->FindSubControl(_T("setting_kuaijiejian_page_btn_huiyuandenglu")));
				focusEdit->SetText(duiText);
			}
			else if (m_kuaijiejian_type == 3)
			{
				CButtonUI* focusEdit = static_cast<CButtonUI*>(this->FindSubControl(_T("setting_kuaijiejian_page_btn_huiyuanshoukuan")));
				focusEdit->SetText(duiText);
			}
			else if (m_kuaijiejian_type == 4)
			{
				CButtonUI* focusEdit = static_cast<CButtonUI*>(this->FindSubControl(_T("setting_kuaijiejian_page_btn_xianjinshoukuan")));
				focusEdit->SetText(duiText);
			}
			else if (m_kuaijiejian_type == 5)
			{
				CButtonUI* focusEdit = static_cast<CButtonUI*>(this->FindSubControl(_T("setting_kuaijiejian_page_btn_qianxiang")));
				focusEdit->SetText(duiText);
			}
			else if (m_kuaijiejian_type == 6)
			{
				CButtonUI* focusEdit = static_cast<CButtonUI*>(this->FindSubControl(_T("setting_kuaijiejian_page_btn_logout")));
				focusEdit->SetText(duiText);
			}
			else if (m_kuaijiejian_type == 7)
			{
				CButtonUI* focusEdit = static_cast<CButtonUI*>(this->FindSubControl(_T("setting_kuaijiejian_page_btn_tiaozhuan_diandan")));
				focusEdit->SetText(duiText);
			}
			else if (m_kuaijiejian_type == 8)
			{
				CButtonUI* focusEdit = static_cast<CButtonUI*>(this->FindSubControl(_T("setting_kuaijiejian_page_btn_tiaozhuan_dingdan")));
				focusEdit->SetText(duiText);
			}
			else if (m_kuaijiejian_type == 9)
			{
				CButtonUI* focusEdit = static_cast<CButtonUI*>(this->FindSubControl(_T("setting_kuaijiejian_page_btn_tiaozhuan_huiyuan")));
				focusEdit->SetText(duiText);
			}
			else if (m_kuaijiejian_type == 10)
			{
				CButtonUI* focusEdit = static_cast<CButtonUI*>(this->FindSubControl(_T("setting_kuaijiejian_page_btn_tiaozhuan_baobiao")));
				focusEdit->SetText(duiText);
			}
			else if (m_kuaijiejian_type == 11)
			{
				CButtonUI* focusEdit = static_cast<CButtonUI*>(this->FindSubControl(_T("setting_kuaijiejian_page_btn_tiaozhuan_jiaoban")));
				focusEdit->SetText(duiText);
			}
			else if (m_kuaijiejian_type == 12)
			{
				CButtonUI* focusEdit = static_cast<CButtonUI*>(this->FindSubControl(_T("setting_kuaijiejian_page_btn_tiaozhuan_shezhi")));
				focusEdit->SetText(duiText);
			}
			else if (m_kuaijiejian_type == 13)
			{
				CButtonUI* focusEdit = static_cast<CButtonUI*>(this->FindSubControl(_T("setting_kuaijiejian_page_btn_tiaozhuan_shangpin")));
				focusEdit->SetText(duiText);
			}
			else if (m_kuaijiejian_type == 14)
			{
				CButtonUI* focusEdit = static_cast<CButtonUI*>(this->FindSubControl(_T("setting_kuaijiejian_page_btn_tiaozhuan_kucun")));
				focusEdit->SetText(duiText);
			}
			else if (m_kuaijiejian_type == 15)
			{
				CButtonUI* focusEdit = static_cast<CButtonUI*>(this->FindSubControl(_T("setting_kuaijiejian_page_btn_tiaozhuan_caigou")));
				focusEdit->SetText(duiText);
			}
			else if (m_kuaijiejian_type == 16)
			{
				CButtonUI* focusEdit = static_cast<CButtonUI*>(this->FindSubControl(_T("setting_kuaijiejian_page_btn_tiaozhuan_zhuotai")));
				focusEdit->SetText(duiText);
			}
			else if (m_kuaijiejian_type == 17)
			{
				CButtonUI* focusEdit = static_cast<CButtonUI*>(this->FindSubControl(_T("setting_kuaijiejian_page_btn_tiaozhuan_shoukuan")));
				focusEdit->SetText(duiText);
			}

			if (wParam == VK_BACK || wParam == VK_DELETE)
			{
				//按了删除键，清空快捷键
				m_vk = 0;
			}
			else
			{
				m_vk = wParam;
			}

			m_isSet = true;
		}
		else
		{
			//按的是控制键，这里只支持3选1，不能更多组合
			if (wParam == VK_CONTROL)
			{
				m_mod = MOD_CONTROL;
			}
			else if (wParam == VK_MENU)
			{
				m_mod = MOD_ALT;
			}
			else if (wParam == VK_SHIFT)
			{
				m_mod = MOD_SHIFT;
			}

			m_isSet = false;
		}
	}
	else if (uMsg == WM_KEYUP || uMsg == WM_SYSKEYUP)
	{
		//这个是只按了控制键，没有按其他的键
		if (!m_isSet)
		{
			if (wParam == VK_CONTROL)
			{
				m_mod = 0;
			}
			else if (wParam == VK_MENU)
			{
				m_mod = 0;
			}
			else if (wParam == VK_SHIFT)
			{
				m_mod = 0;
			}
		}
		else
		{
			//这里表示已经设置好了，等后面保存
			if (wParam != VK_CONTROL && wParam != VK_MENU && wParam != VK_SHIFT)
			{
				//准备开始注册热键了
				if (m_kuaijiejian_type == 1)
				{
					CSetting::GetInstance()->SetParam("setting_kuaijiejian_weixinshoukuan_mod", std::to_string(m_mod));
					CSetting::GetInstance()->SetParam("setting_kuaijiejian_weixinshoukuan_vk", std::to_string(m_vk));
				}
				else if (m_kuaijiejian_type == 2)
				{
					CSetting::GetInstance()->SetParam("setting_kuaijiejian_huiyuandenglu_mod", std::to_string(m_mod));
					CSetting::GetInstance()->SetParam("setting_kuaijiejian_huiyuandenglu_vk", std::to_string(m_vk));
				}
				else if (m_kuaijiejian_type == 3)
				{
					CSetting::GetInstance()->SetParam("setting_kuaijiejian_huiyuanshoukuan_mod", std::to_string(m_mod));
					CSetting::GetInstance()->SetParam("setting_kuaijiejian_huiyuanshoukuan_vk", std::to_string(m_vk));
				}
				else if (m_kuaijiejian_type == 4)
				{
					CSetting::GetInstance()->SetParam("setting_kuaijiejian_xianjinshoukuan_mod", std::to_string(m_mod));
					CSetting::GetInstance()->SetParam("setting_kuaijiejian_xianjinshoukuan_vk", std::to_string(m_vk));
				}
				else if (m_kuaijiejian_type == 5)
				{
					CSetting::GetInstance()->SetParam("setting_kuaijiejian_qianxiang_mod", std::to_string(m_mod));
					CSetting::GetInstance()->SetParam("setting_kuaijiejian_qianxiang_vk", std::to_string(m_vk));
				}
				else if (m_kuaijiejian_type == 6)
				{
					CSetting::GetInstance()->SetParam("setting_kuaijiejian_logout_mod", std::to_string(m_mod));
					CSetting::GetInstance()->SetParam("setting_kuaijiejian_logout_vk", std::to_string(m_vk));
				}
				else if (m_kuaijiejian_type == 7)
				{
					CSetting::GetInstance()->SetParam("setting_kuaijiejian_diandan_mod", std::to_string(m_mod));
					CSetting::GetInstance()->SetParam("setting_kuaijiejian_diandan_vk", std::to_string(m_vk));
				}
				else if (m_kuaijiejian_type == 8)
				{
					CSetting::GetInstance()->SetParam("setting_kuaijiejian_dingdan_mod", std::to_string(m_mod));
					CSetting::GetInstance()->SetParam("setting_kuaijiejian_dingdan_vk", std::to_string(m_vk));
				}
				else if (m_kuaijiejian_type == 9)
				{
					CSetting::GetInstance()->SetParam("setting_kuaijiejian_huiyuan_mod", std::to_string(m_mod));
					CSetting::GetInstance()->SetParam("setting_kuaijiejian_huiyuan_vk", std::to_string(m_vk));
				}
				else if (m_kuaijiejian_type == 10)
				{
					CSetting::GetInstance()->SetParam("setting_kuaijiejian_baobiao_mod", std::to_string(m_mod));
					CSetting::GetInstance()->SetParam("setting_kuaijiejian_baobiao_vk", std::to_string(m_vk));
				}
				else if (m_kuaijiejian_type == 11)
				{
					CSetting::GetInstance()->SetParam("setting_kuaijiejian_jiaoban_mod", std::to_string(m_mod));
					CSetting::GetInstance()->SetParam("setting_kuaijiejian_jiaoban_vk", std::to_string(m_vk));
				}
				else if (m_kuaijiejian_type == 12)
				{
					CSetting::GetInstance()->SetParam("setting_kuaijiejian_shezhi_mod", std::to_string(m_mod));
					CSetting::GetInstance()->SetParam("setting_kuaijiejian_shezhi_vk", std::to_string(m_vk));
				}
				else if (m_kuaijiejian_type == 13)
				{
					CSetting::GetInstance()->SetParam("setting_kuaijiejian_shangpin_mod", std::to_string(m_mod));
					CSetting::GetInstance()->SetParam("setting_kuaijiejian_shangpin_vk", std::to_string(m_vk));
				}
				else if (m_kuaijiejian_type == 14)
				{
					CSetting::GetInstance()->SetParam("setting_kuaijiejian_kucun_mod", std::to_string(m_mod));
					CSetting::GetInstance()->SetParam("setting_kuaijiejian_kucun_vk", std::to_string(m_vk));
				}
				else if (m_kuaijiejian_type == 15)
				{
					CSetting::GetInstance()->SetParam("setting_kuaijiejian_caigou_mod", std::to_string(m_mod));
					CSetting::GetInstance()->SetParam("setting_kuaijiejian_caigou_vk", std::to_string(m_vk));
				}
				else if (m_kuaijiejian_type == 16)
				{
					CSetting::GetInstance()->SetParam("setting_kuaijiejian_zhuotai_mod", std::to_string(m_mod));
					CSetting::GetInstance()->SetParam("setting_kuaijiejian_zhuotai_vk", std::to_string(m_vk));
				}
				else if (m_kuaijiejian_type == 17)
				{
					CSetting::GetInstance()->SetParam("setting_kuaijiejian_shoukuan_mod", std::to_string(m_mod));
					CSetting::GetInstance()->SetParam("setting_kuaijiejian_shoukuan_vk", std::to_string(m_vk));
				}

				m_pMainWnd->UpdateRegisterHotKey();
			}
		}
	}

	return true;
}

void CSettingPageUI::StartTongbuBiaoqiancheng()
{
	std::thread(&CSettingPageUI::HandleTongbuBiaoqiancheng, this).detach();
}

void CSettingPageUI::HandleTongbuBiaoqiancheng()
{
	boost::asio::io_context m_io;
	boost::asio::ip::tcp::socket m_socket(m_io);

	std::string ip = CSetting::GetInstance()->GetParam("setting_tiaomacheng_ip");

	//初始化连接
	try
	{
		boost::asio::ip::tcp::endpoint ep(boost::asio::ip::make_address(ip.c_str()), 4001);
		m_socket.connect(ep);
	}
	catch (std::exception& e)
	{
		std::string err = e.what();
		LOG_INFO("条码秤连接失败，IP地址：" << ip.c_str() << "，错误信息：" << err.c_str());

		m_errinfo = L"条码秤连接失败，请检查IP设置，IP地址：" + CLewaimaiString::UTF8ToUnicode(ip);
		MessageBoxW(NULL, m_errinfo.c_str(), L"条码秤连接失败", MB_OK);

		return;
	}

	//!0V + 4位PLU + A + 7位商品编码 + 6位数价格（单位分） + 模式（0：称重，1：计件，2：定重） + 000000 + 3位有效期 + 2位店号（01-99）+ 000000000000000 + 2位皮重（00-15）+
	//+	0000000000000000000000000000000B + 商品名称区位码 + CDE + 换行符
	CSqlite3 sqlite;
	std::vector<CFood> foods = sqlite.GetFoodForTiaomacheng();

	//注意这里商品只能一条一条的同步，不能很多条的命令拼装在一起同步
	for (std::vector<CFood>::iterator it = foods.begin(); it != foods.end(); it++)
	{
		std::string data = "";

		data += "!0V";

		//处理PLU；
		int n_plu = atoi(it->weight_plu_code.c_str());
		if (n_plu < 1)
		{
			//无效的plu
			continue;
		}
		else if (n_plu > 4000)
		{
			//无效的plu
			continue;
		}

		std::string plu = std::to_string(n_plu);
		plu = CLewaimaiString::BuZifuLeft(plu, 4 - plu.length(), '0');
		data += plu;

		data += "A";

		//处理商品编码
		int n_bianma = atoi(it->weight_food_code.c_str());
		if (n_bianma < 1)
		{
			//无效的编码
			continue;
		}
		else if (n_bianma > 999999)
		{
			//无效的编码
			continue;
		}

		std::string bianma = std::to_string(n_bianma);
		bianma = CLewaimaiString::BuZifuLeft(bianma, 7 - bianma.length(), '0');
		data += bianma;

		//价格
		std::string price = std::to_string((int)(atof(it->price.c_str()) * 100));
		data += CLewaimaiString::BuZifuLeft(price, 6 - price.length(), '0');

		//模式，称重
		data += '0';

		data += "000000";

		//有效期
		data += "000";

		//店号
		data += "01";

		data += "000000000000000";

		//皮重
		data += "00";

		data += "0000000000000000000000000000000B";

		//商品区位码
		std::string quweima = CLewaimaiString::GetQuweima(CLewaimaiString::UTF8ToUnicode(it->name));
		data += quweima;

		data += "CDE";

		data += 0x0d;
		data += 0x0a;

		try
		{
			m_socket.write_some(boost::asio::buffer(data.c_str(), data.length()));
		}
		catch (const std::exception& e)
		{
			LOG_INFO("条码秤发送PLU信息失败，错误信息：" << e.what());
			MessageBoxW(NULL, L"条码秤发送PLU信息失败", L"条码秤发送PLU信息失败", MB_OK);
			m_socket.close();
			return;
		}

		char buf[128] = { 0 };
		boost::system::error_code error;

		size_t len = m_socket.read_some(boost::asio::buffer(buf), error);
		std::string result = buf;

		LOG_INFO("发送PLU命令成功，返回信息：" << buf);
	}

	m_socket.close();
}

void CSettingPageUI::StartTongbuRejian()
{
	std::thread(&CSettingPageUI::HandleTongbuRejian, this).detach();
}

void CSettingPageUI::HandleTongbuRejian()
{
	boost::asio::io_context m_io;
	boost::asio::ip::tcp::socket m_socket(m_io);

	std::string ip = CSetting::GetInstance()->GetParam("setting_tiaomacheng_ip");

	//初始化连接
	try
	{
		boost::asio::ip::tcp::endpoint ep(boost::asio::ip::make_address(ip.c_str()), 4001);
		m_socket.connect(ep);
	}
	catch (std::exception& e)
	{
		std::string err = e.what();
		LOG_INFO("条码秤连接失败，IP地址：" << ip.c_str() << "，错误信息：" << err.c_str());

		m_errinfo = L"条码秤连接失败，请检查IP设置，IP地址：" + CLewaimaiString::UTF8ToUnicode(ip);
		MessageBoxW(NULL, m_errinfo.c_str(), L"条码秤连接失败", MB_OK);

		return;
	}

	std::string data = "";

	std::map<int, std::string> pluMap;

	CSqlite3 sqlite;
	std::vector<CFood> foods = sqlite.GetFoodForTiaomacheng();
	for (std::vector<CFood>::iterator it = foods.begin(); it != foods.end(); it++)
	{
		//处理PLU；
		int n_plu = atoi(it->weight_plu_code.c_str());
		if (n_plu < 1)
		{
			//无效的plu
			continue;;
		}

		if (n_plu > 142)
		{
			//也不处理
			continue;
		}

		std::string plu = std::to_string(n_plu);
		plu = CLewaimaiString::BuZifuLeft(plu, 4 - plu.length(), '0');
		
		pluMap[n_plu] = plu;
	}
	
	//前36个
	data += "!0L00A";

	for (int i = 1; i <= 36; i++)
	{
		std::string s_i = std::to_string(i);

		std::string buqi_i = CLewaimaiString::BuZifuLeft(s_i, 4 - s_i.length(), '0');

		if (pluMap.find(i) != pluMap.end())
		{
			//说明有这个plu的
			data += pluMap[i];
		}
		else
		{
			//没找到这个plu
			data += buqi_i;
		}
	}

	data += "B";
	data += 0x0d;
	data += 0x0a;

	//37到72
	data += "!0L01A";

	for (int i = 37; i <= 72; i++)
	{
		std::string s_i = std::to_string(i);

		std::string buqi_i = CLewaimaiString::BuZifuLeft(s_i, 4 - s_i.length(), '0');

		if (pluMap.find(i) != pluMap.end())
		{
			//说明有这个plu的
			data += pluMap[i];
		}
		else
		{
			//没找到这个plu
			data += buqi_i;
		}
	}

	data += "B";
	data += 0x0d;
	data += 0x0a;

	//73到108
	data += "!0L02A";

	for (int i = 73; i <= 108; i++)
	{
		std::string s_i = std::to_string(i);

		std::string buqi_i = CLewaimaiString::BuZifuLeft(s_i, 4 - s_i.length(), '0');

		if (pluMap.find(i) != pluMap.end())
		{
			//说明有这个plu的
			data += pluMap[i];
		}
		else
		{
			//没找到这个plu
			data += buqi_i;
		}
	}

	data += "B";
	data += 0x0d;
	data += 0x0a;

	//109到142（108+36=144，最后2个空着）
	data += "!0L03A";

	for (int i = 109; i <= 142; i++)
	{
		std::string s_i = std::to_string(i);

		std::string buqi_i = CLewaimaiString::BuZifuLeft(s_i, 4 - s_i.length(), '0');

		if (pluMap.find(i) != pluMap.end())
		{
			//说明有这个plu的
			data += pluMap[i];
		}
		else
		{
			//没找到这个plu
			data += buqi_i;
		}
	}

	//完了这里要补最后的0
	data += "00000000";

	data += "B";
	data += 0x0d;
	data += 0x0a;

	//网口走这里
	try
	{
		m_socket.write_some(boost::asio::buffer(data.c_str(), data.length()));
	}
	catch (const std::exception& e)
	{
		LOG_INFO("条码秤同步热键失败，错误信息：" << e.what());
		MessageBoxW(NULL, L"条码秤同步热键失败", L"条码秤同步热键失败", MB_OK);
		m_socket.close();
		return;
	}

	char buf[128] = { 0 };
	boost::system::error_code error;

	size_t len = m_socket.read_some(boost::asio::buffer(buf), error);
	std::string result = buf;

	LOG_INFO("条码秤同步热键成功，返回信息：" << buf);

	m_socket.close();
}

void CSettingPageUI::StartQiongkongPLU()
{
	std::thread(&CSettingPageUI::HandleQiongkongPLU, this).detach();
}

void CSettingPageUI::HandleQiongkongPLU()
{
	boost::asio::io_context m_io;
	boost::asio::ip::tcp::socket m_socket(m_io);

	std::string ip = CSetting::GetInstance()->GetParam("setting_tiaomacheng_ip");

	//初始化连接
	try
	{
		boost::asio::ip::tcp::endpoint ep(boost::asio::ip::make_address(ip.c_str()), 4001);
		m_socket.connect(ep);
	}
	catch (std::exception& e)
	{
		std::string err = e.what();
		LOG_INFO("条码秤连接失败，IP地址：" << ip.c_str() << "，错误信息：" << err.c_str());

		m_errinfo = L"条码秤连接失败，请检查IP设置，IP地址：" + CLewaimaiString::UTF8ToUnicode(ip);
		MessageBoxW(NULL, m_errinfo.c_str(), L"条码秤连接失败", MB_OK);

		return;
	}

	if (1)
	{
		std::string data = "";

		//先发送清空命令
		data += "!0IA";
		data += 0x0d;
		data += 0x0a;

		try
		{
			m_socket.write_some(boost::asio::buffer(data.c_str(), data.length()));
		}
		catch (const std::exception& e)
		{
			LOG_INFO("条码秤发送清空PLU失败，错误信息：" << e.what());
			MessageBoxW(NULL, L"条码秤发送清空PLU失败", L"条码秤发送清空PLU失败", MB_OK);
			m_socket.close();
			return;
		}

		char buf[128] = { 0 };
		boost::system::error_code error;

		size_t len = m_socket.read_some(boost::asio::buffer(buf), error);
		std::string result = buf;

		LOG_INFO("发送清空PLU命令成功，返回信息：" << buf);
	}

	if (1)
	{
		std::string data = "";

		///再清除记录
		data += "!0HA";
		data += 0x0d;
		data += 0x0a;

		try
		{
			m_socket.write_some(boost::asio::buffer(data.c_str(), data.length()));
		}
		catch (const std::exception& e)
		{
			LOG_INFO("条码秤发送清空历史记录失败，错误信息：" << e.what());
			MessageBoxW(NULL, L"条码秤发送清空历史记录失败", L"条码秤发送清空历史记录失败", MB_OK);
			m_socket.close();
			return;
		}

		char buf[128] = { 0 };
		boost::system::error_code error;

		size_t len = m_socket.read_some(boost::asio::buffer(buf), error);
		std::string result = buf;

		LOG_INFO("发送清空历史记录命令成功，返回信息：" << buf);
	}
}

void CSettingPageUI::StartTongbu()
{
	std::thread(&CSettingPageUI::HandleTongbu, this).detach();
}

void CSettingPageUI::HandleTongbu()
{
	bool ret = CFoodHandle::GetInstance()->InitAllFood();
	if (!ret)
	{
		m_tongbu_error = L"同步商品失败！";
		
		PostMessage(m_pManager->GetPaintWindow(), WM_SETTING_TONGBU_FAIL, 0, 0);

		return;
	}

	//获取店铺信息
	std::wstring errmsg;
	ret = CShopinfo::GetInstance()->UpdateOneShopinfo(errmsg);
	if (!ret)
	{
		m_tongbu_error = errmsg;

		PostMessage(m_pManager->GetPaintWindow(), WM_SETTING_TONGBU_FAIL, 0, 0);

		return;
	}

	PostMessage(m_pManager->GetPaintWindow(), WM_SETTING_TONGBU_SUCCESS, 0, 0);
}

void CSettingPageUI::InitKuaijiejianShow()
{
	//初始化快捷键的展示
	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());

	CDuiString weixinshoukuan_info;
	if (weixinshoukuan_mod == MOD_CONTROL)
	{
		weixinshoukuan_info.Format(_T("CTRL + %c"), weixinshoukuan_vk);
	}
	else if (weixinshoukuan_mod == MOD_ALT)
	{
		weixinshoukuan_info.Format(_T("ALT + %c"), weixinshoukuan_vk);
	}
	else if (weixinshoukuan_mod == MOD_SHIFT)
	{
		weixinshoukuan_info.Format(_T("SHIFT + %c"), weixinshoukuan_vk);
	}
	else if (weixinshoukuan_mod == 0)
	{
		if (weixinshoukuan_vk == 0)
		{
			weixinshoukuan_info = L"";
		}
		else
		{
			weixinshoukuan_info.Format(_T("F%d"), weixinshoukuan_vk - VK_F1 + 1);
		}
	}

	CButtonUI* weixinshoukuan_edit = static_cast<CButtonUI*>(this->FindSubControl(_T("setting_kuaijiejian_page_btn_weixinshoukuan")));
	weixinshoukuan_edit->SetText(weixinshoukuan_info);

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

	CDuiString huiyuandenglu_info;
	if (huiyuandenglu_mod == MOD_CONTROL)
	{
		huiyuandenglu_info.Format(_T("CTRL + %c"), huiyuandenglu_vk);
	}
	else if (huiyuandenglu_mod == MOD_ALT)
	{
		huiyuandenglu_info.Format(_T("ALT + %c"), huiyuandenglu_vk);
	}
	else if (huiyuandenglu_mod == MOD_SHIFT)
	{
		huiyuandenglu_info.Format(_T("SHIFT + %c"), huiyuandenglu_vk);
	}
	else if (huiyuandenglu_mod == 0)
	{
		if (huiyuandenglu_vk == 0)
		{
			huiyuandenglu_info = L"";
		}
		else
		{
			huiyuandenglu_info.Format(_T("F%d"), huiyuandenglu_vk - VK_F1 + 1);
		}
	}

	CButtonUI* huiyuandenglu_edit = static_cast<CButtonUI*>(this->FindSubControl(_T("setting_kuaijiejian_page_btn_huiyuandenglu")));
	huiyuandenglu_edit->SetText(huiyuandenglu_info);

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

	CDuiString huiyuanshoukuan_info;
	if (huiyuanshoukuan_mod == MOD_CONTROL)
	{
		huiyuanshoukuan_info.Format(_T("CTRL + %c"), huiyuanshoukuan_vk);
	}
	else if (huiyuanshoukuan_mod == MOD_ALT)
	{
		huiyuanshoukuan_info.Format(_T("ALT + %c"), huiyuanshoukuan_vk);
	}
	else if (huiyuanshoukuan_mod == MOD_SHIFT)
	{
		huiyuanshoukuan_info.Format(_T("SHIFT + %c"), huiyuanshoukuan_vk);
	}
	else if (huiyuanshoukuan_mod == 0)
	{
		if (huiyuanshoukuan_vk == 0)
		{
			huiyuanshoukuan_info = L"";
		}
		else
		{
			huiyuanshoukuan_info.Format(_T("F%d"), huiyuanshoukuan_vk - VK_F1 + 1);
		}
	}

	CButtonUI* huiyuanshoukuan_edit = static_cast<CButtonUI*>(this->FindSubControl(_T("setting_kuaijiejian_page_btn_huiyuanshoukuan")));
	huiyuanshoukuan_edit->SetText(huiyuanshoukuan_info);

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

	CDuiString xianjinshoukuan_info;
	if (xianjinshoukuan_mod == MOD_CONTROL)
	{
		xianjinshoukuan_info.Format(_T("CTRL + %c"), xianjinshoukuan_vk);
	}
	else if (xianjinshoukuan_mod == MOD_ALT)
	{
		xianjinshoukuan_info.Format(_T("ALT + %c"), xianjinshoukuan_vk);
	}
	else if (xianjinshoukuan_mod == MOD_SHIFT)
	{
		xianjinshoukuan_info.Format(_T("SHIFT + %c"), xianjinshoukuan_vk);
	}
	else if (xianjinshoukuan_mod == 0)
	{
		if (xianjinshoukuan_vk == 0)
		{
			xianjinshoukuan_info = L"";
		}
		else
		{
			xianjinshoukuan_info.Format(_T("F%d"), xianjinshoukuan_vk - VK_F1 + 1);
		}
	}

	CButtonUI* xianjinshoukuan_edit = static_cast<CButtonUI*>(this->FindSubControl(_T("setting_kuaijiejian_page_btn_xianjinshoukuan")));
	xianjinshoukuan_edit->SetText(xianjinshoukuan_info);

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

	CDuiString qianxiang_info;
	if (qianxiang_mod == MOD_CONTROL)
	{
		qianxiang_info.Format(_T("CTRL + %c"), qianxiang_vk);
	}
	else if (qianxiang_mod == MOD_ALT)
	{
		qianxiang_info.Format(_T("ALT + %c"), qianxiang_vk);
	}
	else if (qianxiang_mod == MOD_SHIFT)
	{
		qianxiang_info.Format(_T("SHIFT + %c"), qianxiang_vk);
	}
	else if (qianxiang_mod == 0)
	{
		if (qianxiang_vk == 0)
		{
			qianxiang_info = L"";
		}
		else
		{
			qianxiang_info.Format(_T("F%d"), qianxiang_vk - VK_F1 + 1);
		}
	}

	CButtonUI* qianxiang_edit = static_cast<CButtonUI*>(this->FindSubControl(_T("setting_kuaijiejian_page_btn_qianxiang")));
	qianxiang_edit->SetText(qianxiang_info);

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

	CDuiString logout_info;
	if (logout_mod == MOD_CONTROL)
	{
		logout_info.Format(_T("CTRL + %c"), logout_vk);
	}
	else if (logout_mod == MOD_ALT)
	{
		logout_info.Format(_T("ALT + %c"), logout_vk);
	}
	else if (logout_mod == MOD_SHIFT)
	{
		logout_info.Format(_T("SHIFT + %c"), logout_vk);
	}
	else if (logout_mod == 0)
	{
		if (logout_vk == 0)
		{
			logout_info = L"";
		}
		else
		{
			logout_info.Format(_T("F%d"), logout_vk - VK_F1 + 1);
		}
	}

	CButtonUI* logout_edit = static_cast<CButtonUI*>(this->FindSubControl(_T("setting_kuaijiejian_page_btn_logout")));
	logout_edit->SetText(logout_info);

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

	CDuiString diandan_info;
	if (diandan_mod == MOD_CONTROL)
	{
		diandan_info.Format(_T("CTRL + %c"), diandan_vk);
	}
	else if (diandan_mod == MOD_ALT)
	{
		diandan_info.Format(_T("ALT + %c"), diandan_vk);
	}
	else if (diandan_mod == MOD_SHIFT)
	{
		diandan_info.Format(_T("SHIFT + %c"), diandan_vk);
	}
	else if (diandan_mod == 0)
	{
		if (diandan_vk == 0)
		{
			diandan_info = L"";
		}
		else
		{
			diandan_info.Format(_T("F%d"), diandan_vk - VK_F1 + 1);
		}
	}

	CButtonUI* diandan_edit = static_cast<CButtonUI*>(this->FindSubControl(_T("setting_kuaijiejian_page_btn_tiaozhuan_diandan")));
	diandan_edit->SetText(diandan_info);

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

	CDuiString dingdan_info;
	if (dingdan_mod == MOD_CONTROL)
	{
		dingdan_info.Format(_T("CTRL + %c"), dingdan_vk);
	}
	else if (dingdan_mod == MOD_ALT)
	{
		dingdan_info.Format(_T("ALT + %c"), dingdan_vk);
	}
	else if (dingdan_mod == MOD_SHIFT)
	{
		dingdan_info.Format(_T("SHIFT + %c"), dingdan_vk);
	}
	else if (dingdan_mod == 0)
	{
		if (dingdan_vk == 0)
		{
			dingdan_info = L"";
		}
		else
		{
			dingdan_info.Format(_T("F%d"), dingdan_vk - VK_F1 + 1);
		}
	}

	CButtonUI* dingdan_edit = static_cast<CButtonUI*>(this->FindSubControl(_T("setting_kuaijiejian_page_btn_tiaozhuan_dingdan")));
	dingdan_edit->SetText(dingdan_info);

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

	CDuiString huiyuan_info;
	if (huiyuan_mod == MOD_CONTROL)
	{
		huiyuan_info.Format(_T("CTRL + %c"), huiyuan_vk);
	}
	else if (huiyuan_mod == MOD_ALT)
	{
		huiyuan_info.Format(_T("ALT + %c"), huiyuan_vk);
	}
	else if (huiyuan_mod == MOD_SHIFT)
	{
		huiyuan_info.Format(_T("SHIFT + %c"), huiyuan_vk);
	}
	else if (huiyuan_mod == 0)
	{
		if (huiyuan_vk == 0)
		{
			huiyuan_info = L"";
		}
		else
		{
			huiyuan_info.Format(_T("F%d"), huiyuan_vk - VK_F1 + 1);
		}
	}

	CButtonUI* huiyuan_edit = static_cast<CButtonUI*>(this->FindSubControl(_T("setting_kuaijiejian_page_btn_tiaozhuan_huiyuan")));
	huiyuan_edit->SetText(huiyuan_info);

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

	CDuiString baobiao_info;
	if (baobiao_mod == MOD_CONTROL)
	{
		baobiao_info.Format(_T("CTRL + %c"), baobiao_vk);
	}
	else if (baobiao_mod == MOD_ALT)
	{
		baobiao_info.Format(_T("ALT + %c"), baobiao_vk);
	}
	else if (baobiao_mod == MOD_SHIFT)
	{
		baobiao_info.Format(_T("SHIFT + %c"), baobiao_vk);
	}
	else if (baobiao_mod == 0)
	{
		if (baobiao_vk == 0)
		{
			baobiao_info = L"";
		}
		else
		{
			baobiao_info.Format(_T("F%d"), baobiao_vk - VK_F1 + 1);
		}
	}

	CButtonUI* baobiao_edit = static_cast<CButtonUI*>(this->FindSubControl(_T("setting_kuaijiejian_page_btn_tiaozhuan_baobiao")));
	baobiao_edit->SetText(baobiao_info);

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

	CDuiString jiaoban_info;
	if (jiaoban_mod == MOD_CONTROL)
	{
		jiaoban_info.Format(_T("CTRL + %c"), jiaoban_vk);
	}
	else if (jiaoban_mod == MOD_ALT)
	{
		jiaoban_info.Format(_T("ALT + %c"), jiaoban_vk);
	}
	else if (jiaoban_mod == MOD_SHIFT)
	{
		jiaoban_info.Format(_T("SHIFT + %c"), jiaoban_vk);
	}
	else if (jiaoban_mod == 0)
	{
		if (jiaoban_vk == 0)
		{
			jiaoban_info = L"";
		}
		else
		{
			jiaoban_info.Format(_T("F%d"), jiaoban_vk - VK_F1 + 1);
		}
	}

	CButtonUI* jiaoban_edit = static_cast<CButtonUI*>(this->FindSubControl(_T("setting_kuaijiejian_page_btn_tiaozhuan_jiaoban")));
	jiaoban_edit->SetText(jiaoban_info);

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

	CDuiString shezhi_info;
	if (shezhi_mod == MOD_CONTROL)
	{
		shezhi_info.Format(_T("CTRL + %c"), shezhi_vk);
	}
	else if (shezhi_mod == MOD_ALT)
	{
		shezhi_info.Format(_T("ALT + %c"), shezhi_vk);
	}
	else if (shezhi_mod == MOD_SHIFT)
	{
		shezhi_info.Format(_T("SHIFT + %c"), shezhi_vk);
	}
	else if (shezhi_mod == 0)
	{
		if (shezhi_vk == 0)
		{
			shezhi_info = L"";
		}
		else
		{
			shezhi_info.Format(_T("F%d"), shezhi_vk - VK_F1 + 1);
		}
	}

	CButtonUI* shezhi_edit = static_cast<CButtonUI*>(this->FindSubControl(_T("setting_kuaijiejian_page_btn_tiaozhuan_shezhi")));
	shezhi_edit->SetText(shezhi_info);

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

	CDuiString shangpin_info;
	if (shangpin_mod == MOD_CONTROL)
	{
		shangpin_info.Format(_T("CTRL + %c"), shangpin_vk);
	}
	else if (shangpin_mod == MOD_ALT)
	{
		shangpin_info.Format(_T("ALT + %c"), shangpin_vk);
	}
	else if (shangpin_mod == MOD_SHIFT)
	{
		shangpin_info.Format(_T("SHIFT + %c"), shangpin_vk);
	}
	else if (shangpin_mod == 0)
	{
		if (shangpin_vk == 0)
		{
			shangpin_info = L"";
		}
		else
		{
			shangpin_info.Format(_T("F%d"), shangpin_vk - VK_F1 + 1);
		}
	}

	CButtonUI* shangpin_edit = static_cast<CButtonUI*>(this->FindSubControl(_T("setting_kuaijiejian_page_btn_tiaozhuan_shangpin")));
	shangpin_edit->SetText(shangpin_info);

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

	CDuiString kucun_info;
	if (kucun_mod == MOD_CONTROL)
	{
		kucun_info.Format(_T("CTRL + %c"), kucun_vk);
	}
	else if (kucun_mod == MOD_ALT)
	{
		kucun_info.Format(_T("ALT + %c"), kucun_vk);
	}
	else if (kucun_mod == MOD_SHIFT)
	{
		kucun_info.Format(_T("SHIFT + %c"), kucun_vk);
	}
	else if (kucun_mod == 0)
	{
		if (kucun_vk == 0)
		{
			kucun_info = L"";
		}
		else
		{
			kucun_info.Format(_T("F%d"), kucun_vk - VK_F1 + 1);
		}
	}

	CButtonUI* kucun_edit = static_cast<CButtonUI*>(this->FindSubControl(_T("setting_kuaijiejian_page_btn_tiaozhuan_kucun")));
	kucun_edit->SetText(kucun_info);

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

	CDuiString caigou_info;
	if (caigou_mod == MOD_CONTROL)
	{
		caigou_info.Format(_T("CTRL + %c"), caigou_vk);
	}
	else if (caigou_mod == MOD_ALT)
	{
		caigou_info.Format(_T("ALT + %c"), caigou_vk);
	}
	else if (caigou_mod == MOD_SHIFT)
	{
		caigou_info.Format(_T("SHIFT + %c"), caigou_vk);
	}
	else if (caigou_mod == 0)
	{
		if (caigou_vk == 0)
		{
			caigou_info = L"";
		}
		else
		{
			caigou_info.Format(_T("F%d"), caigou_vk - VK_F1 + 1);
		}
	}

	CButtonUI* caigou_edit = static_cast<CButtonUI*>(this->FindSubControl(_T("setting_kuaijiejian_page_btn_tiaozhuan_caigou")));
	caigou_edit->SetText(caigou_info);

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

	CDuiString zhuotai_info;
	if (zhuotai_mod == MOD_CONTROL)
	{
		zhuotai_info.Format(_T("CTRL + %c"), zhuotai_vk);
	}
	else if (zhuotai_mod == MOD_ALT)
	{
		zhuotai_info.Format(_T("ALT + %c"), zhuotai_vk);
	}
	else if (zhuotai_mod == MOD_SHIFT)
	{
		zhuotai_info.Format(_T("SHIFT + %c"), zhuotai_vk);
	}
	else if (zhuotai_mod == 0)
	{
		if (zhuotai_vk == 0)
		{
			zhuotai_info = L"";
		}
		else
		{
			zhuotai_info.Format(_T("F%d"), zhuotai_vk - VK_F1 + 1);
		}
	}

	CButtonUI* zhuotai_edit = static_cast<CButtonUI*>(this->FindSubControl(_T("setting_kuaijiejian_page_btn_tiaozhuan_zhuotai")));
	zhuotai_edit->SetText(zhuotai_info);

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

	CDuiString shoukuan_info;
	if (shoukuan_mod == MOD_CONTROL)
	{
		shoukuan_info.Format(_T("CTRL + %c"), shoukuan_vk);
	}
	else if (shoukuan_mod == MOD_ALT)
	{
		shoukuan_info.Format(_T("ALT + %c"), shoukuan_vk);
	}
	else if (shoukuan_mod == MOD_SHIFT)
	{
		shoukuan_info.Format(_T("SHIFT + %c"), shoukuan_vk);
	}
	else if (shoukuan_mod == 0)
	{
		if (shoukuan_vk == 0)
		{
			shoukuan_info = L"";
		}
		else
		{
			shoukuan_info.Format(_T("F%d"), shoukuan_vk - VK_F1 + 1);
		}
	}

	CButtonUI* shoukuan_edit = static_cast<CButtonUI*>(this->FindSubControl(_T("setting_kuaijiejian_page_btn_tiaozhuan_shoukuan")));
	shoukuan_edit->SetText(shoukuan_info);
}