zhipuzi_pos_windows/lewaimai_dispatch/wnd/CMainWnd.cpp

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

#include "CChufangSettingWnd.h"

#include "../control/ControlEx.h"
#include "../control/CWaimaiOrderInfoUI.h"

#include "../tool/CSetting.h"

void CMainWnd::Init()
{
    m_pCloseBtn = static_cast<CButtonUI*>(m_pm.FindControl(_T("closebtn")));
    m_pMaxBtn = static_cast<CButtonUI*>(m_pm.FindControl(_T("maxbtn")));
    m_pRestoreBtn = static_cast<CButtonUI*>(m_pm.FindControl(_T("restorebtn")));
    m_pMinBtn = static_cast<CButtonUI*>(m_pm.FindControl(_T("minbtn")));
}

LRESULT CMainWnd::OnCreate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
    LONG styleValue = ::GetWindowLong(*this, GWL_STYLE);
    styleValue &= ~WS_CAPTION;
    ::SetWindowLong(*this, GWL_STYLE, styleValue | WS_CLIPSIBLINGS | WS_CLIPCHILDREN);

    m_pm.Init(m_hWnd);
    CDialogBuilder builder;
    CDialogBuilderCallbackEx cb;

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

    m_pm.AttachDialog(pRoot);
    m_pm.AddNotifier(this);

    Init();

    OrderListUI* orderlist = static_cast<OrderListUI*>(m_pm.FindControl(_T("orderlist")));
    orderlist->Refresh();

    //初始化设置中心的状态
    InitSettingStatus();

    return 0;
}

void CMainWnd::Notify(TNotifyUI& msg)
{
    if(msg.sType == _T("windowinit"))
    {
        OnPrepare();
    }

    else if(msg.sType == _T("click"))
    {
        HandleClickMsg(msg);
    }

    else if(msg.sType == _T("selectchanged"))
    {
        HandleSelectChangeMsg(msg);
    }

    else if(msg.sType == _T("itemclick"))
    {

    }
    else if(msg.sType == _T("itemactivate"))
    {

    }
    else if(msg.sType == _T("itemselect"))
    {
        HandleItemSelectMsg(msg);
    }
}

void CMainWnd::HandleClickMsg(TNotifyUI& msg)
{
    if(msg.pSender == m_pCloseBtn)
    {
        COptionUI* pControl = static_cast<COptionUI*>(m_pm.FindControl(_T("hallswitch")));

        if(pControl && pControl->IsSelected() == false)
        {
            CControlUI* pFadeControl = m_pm.FindControl(_T("fadeEffect"));

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

        else
        {
            /*Close()*/PostQuitMessage(0); // 因为activex的原因，使用close可能会出现错误
        }

        return;
    }

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

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

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

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

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

    else if(name == _T("waimai_order_list_print"))
    {
        CWaimaiOrderItemUI* item = static_cast<CWaimaiOrderItemUI*>(msg.pSender->GetParent()->GetParent());
        std::string waimai_order_id = item->getOrderID();
        std::string waimai_order_no = item->getOrderNo();

        CWaimaiOrder order;
        order.InitData(waimai_order_id, waimai_order_no);

        CPosPrinter printer;
        printer.PrintWaimaiOrder(order);
    }

    else if(name == _T("waimai_order_list_confirme"))
    {
        CWaimaiOrderItemUI* item = static_cast<CWaimaiOrderItemUI*>(msg.pSender->GetParent()->GetParent());
        std::string waimai_order_id = item->getOrderID();

        CWaimaiOrder order;
        bool ret = order.ConfirmeOrder(waimai_order_id);

        if(ret)
        {
            //如果确认成功，将被确认的订单删除掉
            OrderListUI* orderlist = static_cast<OrderListUI*>(m_pm.FindControl(_T("orderlist")));
            int index = orderlist->GetItemIndex(item);
            orderlist->RemoveAt(index);
        }
    }

    else if(name == _T("waimai_order_list_success"))
    {
        CWaimaiOrderItemUI* item = static_cast<CWaimaiOrderItemUI*>(msg.pSender->GetParent()->GetParent());
        std::string waimai_order_id = item->getOrderID();

        CWaimaiOrder order;
        bool ret = order.SuccessOrder(waimai_order_id);

        if(ret)
        {
            //如果确认成功，将被确认的订单删除掉
            OrderListUI* orderlist = static_cast<OrderListUI*>(m_pm.FindControl(_T("orderlist")));
            int index = orderlist->GetItemIndex(item);
            orderlist->RemoveAt(index);
        }
    }

    else if(name == _T("waimai_order_list_fail"))
    {
        //外卖订单的打印
        CWaimaiOrderItemUI* item = static_cast<CWaimaiOrderItemUI*>(msg.pSender->GetParent()->GetParent());
        std::string waimai_order_id = item->getOrderID();

        CWaimaiOrder order;
        bool ret = order.FailOrder(waimai_order_id, "windows收银机测试");

        if(ret)
        {
            //如果设为失败成功，将被设为失败的订单删除掉
            OrderListUI* orderlist = static_cast<OrderListUI*>(m_pm.FindControl(_T("orderlist")));
            int index = orderlist->GetItemIndex(item);
            orderlist->RemoveAt(index);
        }
    }

    else if(name == _T("waimai_order_list_agree"))
    {
        CWaimaiOrderItemUI* item = static_cast<CWaimaiOrderItemUI*>(msg.pSender->GetParent()->GetParent());
        std::string waimai_order_id = item->getOrderID();

        CWaimaiOrder order;
        bool ret = order.AgreeRefund(waimai_order_id);

        if(ret)
        {
            //同意退款之后，订单变为失败状态
            OrderListUI* orderlist = static_cast<OrderListUI*>(m_pm.FindControl(_T("orderlist")));
            int index = orderlist->GetItemIndex(item);
            orderlist->RemoveAt(index);
        }
    }

    else if(name == _T("waimai_order_list_disagree"))
    {
        CWaimaiOrderItemUI* item = static_cast<CWaimaiOrderItemUI*>(msg.pSender->GetParent()->GetParent());
        std::string waimai_order_id = item->getOrderID();

        CWaimaiOrder order;
        bool ret = order.DisagreeRefund(waimai_order_id);

        if(ret)
        {
            //不同意退款，订单还是退款中，等待第三方客服处理
            //OrderListUI* orderlist = static_cast<OrderListUI*>(m_pm.FindControl(_T("orderlist")));
            //int index = orderlist->GetItemIndex(item);
            //orderlist->RemoveAt(index);
        }
    }
    else if(name == _T("waimai_order_list_info"))
    {
        CWaimaiOrderItemUI* item = static_cast<CWaimaiOrderItemUI*>(msg.pSender->GetParent()->GetParent());
        std::string waimai_order_id = item->getOrderID();
        std::string waimai_order_no = item->getOrderNo();

        //请求服务器，获取订单数据
        CWaimaiOrder order;
        order.InitData(waimai_order_id, waimai_order_no);

        //刷新订单详情页数据
        CWaimaiOrderInfoUI* order_info_page = static_cast<CWaimaiOrderInfoUI*>(m_pm.FindControl(_T("waimaiorder_info_page")));
        order_info_page->SetDate(order);
        order_info_page->Refresh(order);

        //显示订单详情页的内容
        CTabLayoutUI* pControl = static_cast<CTabLayoutUI*>(m_pm.FindControl(_T("switch")));

        if(pControl && pControl->GetCurSel() != 1)
        {
            pControl->SelectItem(1);
        }
    }

    else if(name == _T("waimai_order_list_last"))
    {
        OrderListUI* orderlist = static_cast<OrderListUI*>(m_pm.FindControl(_T("orderlist")));

        orderlist->LastPage();
    }

    else if(name == _T("waimai_order_list_next"))
    {
        OrderListUI* orderlist = static_cast<OrderListUI*>(m_pm.FindControl(_T("orderlist")));

        orderlist->NextPage();
    }

    else if(name == _T("waimai_order_list_refresh"))
    {
        OrderListUI* orderlist = static_cast<OrderListUI*>(m_pm.FindControl(_T("orderlist")));

        orderlist->Refresh();
    }

    else if(name == _T("waimai_order_info_page_return"))
    {
        CTabLayoutUI* pControl = static_cast<CTabLayoutUI*>(m_pm.FindControl(_T("switch")));

        if(pControl && pControl->GetCurSel() != 0)
        {
            pControl->SelectItem(0);
        }

        //刷新当前列表
        OrderListUI* orderlist = static_cast<OrderListUI*>(m_pm.FindControl(_T("orderlist")));
        orderlist->Refresh();
    }

    else if(name == _T("waimai_order_info_page_print"))
    {
        CWaimaiOrderInfoUI* order_info_page = static_cast<CWaimaiOrderInfoUI*>(m_pm.FindControl(_T("waimaiorder_info_page")));

        CPosPrinter printer;
        printer.PrintWaimaiOrder(order_info_page->m_order);
    }

    else if(name == _T("waimai_order_info_page_confirme"))
    {
        CWaimaiOrderInfoUI* order_info_page = static_cast<CWaimaiOrderInfoUI*>(m_pm.FindControl(_T("waimaiorder_info_page")));

        std::string waimai_order_id = order_info_page->m_order.m_order_id;
        std::string waimai_order_no = order_info_page->m_order.m_order_no;

        CWaimaiOrder order;
        bool ret = order.ConfirmeOrder(waimai_order_id);

        if(ret)
        {
            //确认成功，这里怎么处理
            //请求服务器，获取订单数据
            CWaimaiOrder new_order;
            new_order.InitData(waimai_order_id, waimai_order_no);

            //刷新订单详情页数据
            order_info_page->SetDate(new_order);
            order_info_page->Refresh(new_order);
        }
    }

    else if(name == _T("waimai_order_info_page_success"))
    {
        CWaimaiOrderInfoUI* order_info_page = static_cast<CWaimaiOrderInfoUI*>(m_pm.FindControl(_T("waimaiorder_info_page")));

        std::string waimai_order_id = order_info_page->m_order.m_order_id;
        std::string waimai_order_no = order_info_page->m_order.m_order_no;

        CWaimaiOrder order;
        bool ret = order.SuccessOrder(waimai_order_id);

        if(ret)
        {
            //订单设为成功，这里怎么处理
            //请求服务器，获取订单数据
            CWaimaiOrder new_order;
            new_order.InitData(waimai_order_id, waimai_order_no);

            //刷新订单详情页数据
            order_info_page->SetDate(new_order);
            order_info_page->Refresh(new_order);
        }
    }

    else if(name == _T("waimai_order_info_page_fail"))
    {
        CWaimaiOrderInfoUI* order_info_page = static_cast<CWaimaiOrderInfoUI*>(m_pm.FindControl(_T("waimaiorder_info_page")));

        std::string waimai_order_id = order_info_page->m_order.m_order_id;
        std::string waimai_order_no = order_info_page->m_order.m_order_no;

        CWaimaiOrder order;
        bool ret = order.FailOrder(waimai_order_id, "Windwos收银机测试");

        if(ret)
        {
            //订单设为失败，这里怎么处理
            //请求服务器，获取订单数据
            CWaimaiOrder new_order;
            new_order.InitData(waimai_order_id, waimai_order_no);

            //刷新订单详情页数据
            order_info_page->SetDate(new_order);
            order_info_page->Refresh(new_order);
        }
    }

    else if(name == _T("waimai_order_info_page_agree"))
    {
        CWaimaiOrderInfoUI* order_info_page = static_cast<CWaimaiOrderInfoUI*>(m_pm.FindControl(_T("waimaiorder_info_page")));

        std::string waimai_order_id = order_info_page->m_order.m_order_id;
        std::string waimai_order_no = order_info_page->m_order.m_order_no;

        CWaimaiOrder order;
        bool ret = order.AgreeRefund(waimai_order_id);

        if(ret)
        {
            //订单设为成功，这里怎么处理
            //请求服务器，获取订单数据
            CWaimaiOrder new_order;
            new_order.InitData(waimai_order_id, waimai_order_no);

            //刷新订单详情页数据
            order_info_page->SetDate(new_order);
            order_info_page->Refresh(new_order);
        }
    }

    else if(name == _T("waimai_order_info_page_disagree"))
    {
        CWaimaiOrderInfoUI* order_info_page = static_cast<CWaimaiOrderInfoUI*>(m_pm.FindControl(_T("waimaiorder_info_page")));

        std::string waimai_order_id = order_info_page->m_order.m_order_id;
        std::string waimai_order_no = order_info_page->m_order.m_order_no;

        CWaimaiOrder order;
        bool ret = order.DisagreeRefund(waimai_order_id);

        if(ret)
        {
            //订单设为成功，这里怎么处理
            //请求服务器，获取订单数据
            CWaimaiOrder new_order;
            new_order.InitData(waimai_order_id, waimai_order_no);

            //刷新订单详情页数据
            order_info_page->SetDate(new_order);
            order_info_page->Refresh(new_order);
        }
    }

    //开始处理设置页面的
    else if(name == _T("setting_is_new_waimai_voice"))
    {
        CCheckBoxUI* box = static_cast<CCheckBoxUI*>(m_pm.FindControl(_T("setting_is_new_waimai_voice")));

        //注意这里的IsSelected如果为true，表示的是点击前为true，而不是点击后为true，所以这里设置状态要反过来
        if(box->IsSelected())
        {
            CSetting::SetParam("setting_is_new_waimai_voice", "0");
        }

        else
        {
            CSetting::SetParam("setting_is_new_waimai_voice", "1");
        }
    }

    else if(name == _T("setting_is_new_waimai_autoconfirm"))
    {
        CCheckBoxUI* box = static_cast<CCheckBoxUI*>(m_pm.FindControl(_T("setting_is_new_waimai_autoconfirm")));

        if(box->IsSelected())
        {
            CSetting::SetParam("setting_is_new_waimai_autoconfirm", "0");
        }

        else
        {
            CSetting::SetParam("setting_is_new_waimai_autoconfirm", "1");
        }
    }

    else if(name == _T("setting_is_new_waimai_dialog"))
    {
        CCheckBoxUI* box = static_cast<CCheckBoxUI*>(m_pm.FindControl(_T("setting_is_new_waimai_dialog")));

        if(box->IsSelected())
        {
            CSetting::SetParam("setting_is_new_waimai_dialog", "0");
        }

        else
        {
            CSetting::SetParam("setting_is_new_waimai_dialog", "1");
        }
    }

    else if(name == _T("setting_is_new_waimai_printer"))
    {
        CCheckBoxUI* box = static_cast<CCheckBoxUI*>(m_pm.FindControl(_T("setting_is_new_waimai_printer")));

        if(box->IsSelected())
        {
            CSetting::SetParam("setting_is_new_waimai_printer", "0");
        }

        else
        {
            CSetting::SetParam("setting_is_new_waimai_printer", "1");
        }
    }

    else if(name == _T("setting_is_new_waimai_chufang_printer"))
    {
        CCheckBoxUI* box = static_cast<CCheckBoxUI*>(m_pm.FindControl(_T("setting_is_new_waimai_chufang_printer")));

        if(box->IsSelected())
        {
            CSetting::SetParam("setting_is_new_waimai_chufang_printer", "0");
        }

        else
        {
            CSetting::SetParam("setting_is_new_waimai_chufang_printer", "1");
        }
    }

    else if(name == _T("setting_new_chufang_printer_btn"))
    {
        CChufangSettingWnd* pChufangFrame = new CChufangSettingWnd(1);

        if(pChufangFrame != NULL)
        {
            pChufangFrame->Create(this->GetHWND(), _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*>(m_pm.FindControl(_T("setting_chufang_printer_list")));

                //把最后一个厨房打印机取出来
                ChufangPrinter newPrinter = CSetting::getLastChufangPrinter();

                CDialogBuilder builder;
                CListContainerElementUI* pEle = static_cast<CListContainerElementUI*>(builder.Create(_T("setting_chufang_printer_item.xml"), (UINT)0, NULL, &m_pm));

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

				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*>(m_pm.FindControl(_T("setting_is_auto_start")));

        if(box->IsSelected())
        {
            CSetting::SetParam("setting_is_auto_start", "0");
        }

        else
        {
            CSetting::SetParam("setting_is_auto_start", "1");
        }
    }

    else if(name == _T("setting_is_auto_login"))
    {
        CCheckBoxUI* box = static_cast<CCheckBoxUI*>(m_pm.FindControl(_T("setting_is_auto_login")));

        if(box->IsSelected())
        {
            CSetting::SetParam("setting_is_auto_login", "0");
        }

        else
        {
            CSetting::SetParam("setting_is_auto_login", "1");
        }
    }

    else if(name == _T("setting_is_close_min"))
    {
        CCheckBoxUI* box = static_cast<CCheckBoxUI*>(m_pm.FindControl(_T("setting_is_close_min")));

        if(box->IsSelected())
        {
            CSetting::SetParam("setting_is_close_min", "0");
        }

        else
        {
            CSetting::SetParam("setting_is_close_min", "1");
        }
    }
	else if (name == _T("setting_chufang_printer_item_update_btn"))
	{
		CListUI* pPrinterList = static_cast<CListUI*>(m_pm.FindControl(_T("setting_chufang_printer_list")));

		CListContainerElementUI* pEle = static_cast<CListContainerElementUI*>(msg.pSender->GetParent()->GetParent()->GetParent());
		wstring date = pEle->GetCustomAttribute(L"date");

		CChufangSettingWnd* pChufangFrame = new CChufangSettingWnd(2);
		pChufangFrame->SetPrinterDate(CLewaimaiString::UnicodeToUTF8(date));

		if (pChufangFrame != NULL)
		{
			pChufangFrame->Create(this->GetHWND(), _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*>(m_pm.FindControl(_T("setting_chufang_printer_list")));

				//把最后一个厨房打印机取出来
				ChufangPrinter newPrinter = CSetting::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"否");
				}
			}
		}
	}
	else if (name == _T("setting_chufang_printer_item_delete_btn"))
	{
		CListUI* pPrinterList = static_cast<CListUI*>(m_pm.FindControl(_T("setting_chufang_printer_list")));

		CListContainerElementUI* pEle = static_cast<CListContainerElementUI*>(msg.pSender->GetParent()->GetParent()->GetParent());
		wstring date = pEle->GetCustomAttribute(L"date");

		//获得了ID，这个时候从内存和数据库中分别删除对应的记录
		CSetting::DelChufangPrinter(CLewaimaiString::UnicodeToUTF8(date));

		pPrinterList->Remove(pEle);
	}
}

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

    //先判断主页面的tab
    if(name == _T("main_waimai"))
    {
        CTabLayoutUI* pControl = static_cast<CTabLayoutUI*>(m_pm.FindControl(_T("switch")));

        if(pControl && pControl->GetCurSel() != 0)
        {
            pControl->SelectItem(0);
        }
    }

    else if(name == _T("main_setting"))
    {
        CTabLayoutUI* pControl = static_cast<CTabLayoutUI*>(m_pm.FindControl(_T("switch")));

        if(pControl && pControl->GetCurSel() != 2)
        {
            pControl->SelectItem(2);
        }
    }

    else if(name == _T("main_contact"))
    {
        CTabLayoutUI* pControl = static_cast<CTabLayoutUI*>(m_pm.FindControl(_T("switch")));

        if(pControl && pControl->GetCurSel() != 3)
        {
            pControl->SelectItem(3);
        }
    }

    //判断外卖的tab
    else if(name == _T("waimai_open_switch") || name == _T("waimai_confirmed_switch") || name == _T("waimai_delivery_switch") || name == _T("waimai_success_switch") || name == _T("waimai_fail_switch") || name == _T("waimai_cancel_switch") || name == _T("waimai_refund_switch"))
    {
        OrderListUI* orderlist = static_cast<OrderListUI*>(m_pm.FindControl(_T("orderlist")));

        //切换状态全部重新开始从第1页
        orderlist->SetPage(1);

        if(name == _T("waimai_open_switch"))
        {
            orderlist->SetStatus(1);
        }

        else if(name == _T("waimai_confirmed_switch"))
        {
            orderlist->SetStatus(2);
        }

        else if(name == _T("waimai_delivery_switch"))
        {
            orderlist->SetStatus(3);
        }

        else if(name == _T("waimai_success_switch"))
        {
            orderlist->SetStatus(4);
        }

        else if(name == _T("waimai_fail_switch"))
        {
            orderlist->SetStatus(5);
        }

        else if(name == _T("waimai_cancel_switch"))
        {
            orderlist->SetStatus(6);
        }

        else if(name == _T("waimai_refund_switch"))
        {
            orderlist->SetStatus(7);
        }

        orderlist->Refresh();
    }

    //判断设置中心的tab
    else if(name == _T("setting_waimai_order_switch"))
    {
        CTabLayoutUI* pControl = static_cast<CTabLayoutUI*>(m_pm.FindControl(_T("setting_switch")));
        pControl->SelectItem(0);
    }

    else if(name == _T("setting_printer_switch"))
    {
        CTabLayoutUI* pControl = static_cast<CTabLayoutUI*>(m_pm.FindControl(_T("setting_switch")));
        pControl->SelectItem(1);
    }

    else if(name == _T("setting_chufang_printer_switch"))
    {
        CTabLayoutUI* pControl = static_cast<CTabLayoutUI*>(m_pm.FindControl(_T("setting_switch")));
        pControl->SelectItem(2);
    }

    else if(name == _T("setting_system_switch"))
    {
        CTabLayoutUI* pControl = static_cast<CTabLayoutUI*>(m_pm.FindControl(_T("setting_switch")));
        pControl->SelectItem(3);
    }

    else if(name == _T("setting_system_update"))
    {
        CTabLayoutUI* pControl = static_cast<CTabLayoutUI*>(m_pm.FindControl(_T("setting_switch")));
        pControl->SelectItem(4);
    }
}

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

    if(name == _T("setting_printer_guige"))
    {
        CComboUI* com = static_cast<CComboUI*>(m_pm.FindControl(_T("setting_printer_guige")));

        if(com->GetCurSel() == 0)
        {
            CSetting::SetParam("setting_printer_guige", "58");
        }

        else
        {
            CSetting::SetParam("setting_printer_guige", "80");
        }
    }

    else if(name == _T("setting_printer_lianshu"))
    {
        CComboUI* com = static_cast<CComboUI*>(m_pm.FindControl(_T("setting_printer_lianshu")));

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

        else if(com->GetCurSel() == 1)
        {
            CSetting::SetParam("setting_printer_lianshu", "2");
        }

        else if(com->GetCurSel() == 2)
        {
            CSetting::SetParam("setting_printer_lianshu", "3");
        }

        else if(com->GetCurSel() == 3)
        {
            CSetting::SetParam("setting_printer_lianshu", "4");
        }
    }
}

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

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

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

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

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

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

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

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

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

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

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

    default:
        bHandled = FALSE;
    }

    if(bHandled)
    {
        return lRes;
    }

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

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

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

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

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

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

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

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

        else
        {
            CControlUI* pControl = static_cast<CControlUI*>(m_pm.FindControl(_T("maxbtn")));

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

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

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

    return lRes;
}

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

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

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

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

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

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

    bHandled = FALSE;
    return 0;
}

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

    RECT rcClient;
    ::GetClientRect(*this, &rcClient);

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

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

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

            return HTTOP;
        }

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

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

            return HTBOTTOM;
        }

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

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

    RECT rcCaption = m_pm.GetCaptionRect();

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

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

    return HTCLIENT;
}

void CMainWnd::InitSettingStatus()
{
    CCheckBoxUI* box = NULL;
    CComboUI* com = NULL;

    box = static_cast<CCheckBoxUI*>(m_pm.FindControl(_T("setting_is_new_waimai_voice")));

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

    else
    {
        box->Selected(false, false);
    }

    box = static_cast<CCheckBoxUI*>(m_pm.FindControl(_T("setting_is_new_waimai_autoconfirm")));

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

    else
    {
        box->Selected(false, false);
    }

    box = static_cast<CCheckBoxUI*>(m_pm.FindControl(_T("setting_is_new_waimai_dialog")));

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

    else
    {
        box->Selected(false, false);
    }

    box = static_cast<CCheckBoxUI*>(m_pm.FindControl(_T("setting_is_new_waimai_printer")));

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

    else
    {
        box->Selected(false, false);
    }

    com = static_cast<CComboUI*>(m_pm.FindControl(_T("setting_printer_guige")));

    if(CSetting::GetParam("setting_printer_guige") == "58")
    {
        com->SetInternVisible(true);
        com->SelectItem(0, false, false);
    }

    else
    {
        com->SetInternVisible(true);
        com->SelectItem(1, false, false);
    }

    com = static_cast<CComboUI*>(m_pm.FindControl(_T("setting_printer_lianshu")));
    std::string setting_printer_lianshu = CSetting::GetParam("setting_printer_lianshu");

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

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

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

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

    box = static_cast<CCheckBoxUI*>(m_pm.FindControl(_T("setting_is_new_waimai_chufang_printer")));

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

    else
    {
        box->Selected(false, false);
    }

    box = static_cast<CCheckBoxUI*>(m_pm.FindControl(_T("setting_is_auto_start")));

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

    else
    {
        box->Selected(false, false);
    }

    box = static_cast<CCheckBoxUI*>(m_pm.FindControl(_T("setting_is_auto_login")));

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

    else
    {
        box->Selected(false, false);
    }

    box = static_cast<CCheckBoxUI*>(m_pm.FindControl(_T("setting_is_close_min")));

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

    else
    {
        box->Selected(false, false);
    }

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

    //获取厨房打印机的集合
    std::vector<ChufangPrinter> printers = CSetting::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_pm));

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

		pEle->AddCustomAttribute(L"date", CLewaimaiString::UTF8ToUnicode(newPrinter.date).c_str());

        pPrinterList->Add(pEle);
    }

}