lewaimai_pos_windows/lewaimai_pos_windows/wnd/CMainWnd.cpp

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

#include "CChufangSettingWnd.h"

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

#include "../network/CMessagePush.h"
#include "CWaimaiOrderFailReasonWnd.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")));

    //初始化外卖订单列表
    COptionUI* waimai_tab = static_cast<COptionUI*>(m_pm.FindControl(_T("main_waimai")));

    if(waimai_tab->IsSelected())
    {
        OrderListUI* orderlist = static_cast<OrderListUI*>(m_pm.FindControl(_T("orderlist")));
        orderlist->Refresh();
    }

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

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

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

void CMainWnd::Notify(TNotifyUI& msg)
{
    if(msg.sType == _T("windowinit"))
    {
        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)
    {
        if(CSetting::GetParam("setting_is_close_min") == "1")
        {
            AddTrayIcon();
        }
        else
        {
            PostQuitMessage(0);
        }

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

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

    if(name == _T("quitbtn"))
    {
        /*Close()*/PostQuitMessage(0); // 因为activex的原因，使用close可能会出现错误
    }
    else 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();
        m_push->AddPinter(waimai_order_id, waimai_order_no, 2);
    }
    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();
        CWaimaiOrderFailReasonWnd* pWaimaiFailFrame = new CWaimaiOrderFailReasonWnd();
        pWaimaiFailFrame->Create(this->GetHWND(), _T(""), UI_WNDSTYLE_DIALOG, WS_EX_WINDOWEDGE);
        pWaimaiFailFrame->SetIcon(IDI_ICON_DUILIB);
        pWaimaiFailFrame->CenterWindow();
        UINT ret = pWaimaiFailFrame->ShowModal();

        if(ret == IDOK)
        {
            std::string sReason = pWaimaiFailFrame->getReason();
            CWaimaiOrder order;
            bool ret = order.FailOrder(waimai_order_id, sReason);

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

        delete pWaimaiFailFrame;
    }
    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")));
        m_push->AddPinter(order_info_page->m_order.m_order_id, order_info_page->m_order.m_order_no, 2);
    }
    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;
        CWaimaiOrderFailReasonWnd* pWaimaiFailFrame = new CWaimaiOrderFailReasonWnd();
        pWaimaiFailFrame->Create(this->GetHWND(), _T(""), UI_WNDSTYLE_DIALOG, WS_EX_WINDOWEDGE);
        pWaimaiFailFrame->SetIcon(IDI_ICON_DUILIB);
        pWaimaiFailFrame->CenterWindow();
        UINT ret = pWaimaiFailFrame->ShowModal();

        if(ret == IDOK)
        {
            std::string sReason = pWaimaiFailFrame->getReason();
            CWaimaiOrder order;
            bool ret = order.FailOrder(waimai_order_id, sReason);

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

        delete pWaimaiFailFrame;
    }
    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("waimai_order_info_page_refund"))
    {
        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.Refund(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_printer_wangkouk_save_btn"))
    {
        CEditUI* wangkou_ip = static_cast<CEditUI*>(m_pm.FindControl(_T("setting_printer_wangkou_ip")));
        wstring ip = wangkou_ip->GetText();

        CSetting::SetParam("setting_printer_wangkou_ip", CLewaimaiString::UnicodeToUTF8(ip));
    }
    else if(name == _T("setting_printer_quhuo_big"))
    {
        CCheckBoxUI* box = static_cast<CCheckBoxUI*>(m_pm.FindControl(_T("setting_printer_quhuo_big")));

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

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

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

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

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

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

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

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

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

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

        if(box->IsSelected())
        {
            CSetting::SetParam("setting_printer_pay_big", "0");
        }
        else
        {
            CSetting::SetParam("setting_printer_pay_big", "1");
        }
    }
    else if(name == _T("setting_is_new_waimai_biaoqian_printer"))
    {
        CCheckBoxUI* box = static_cast<CCheckBoxUI*>(m_pm.FindControl(_T("setting_is_new_waimai_biaoqian_printer")));

        if(box->IsSelected())
        {
            CSetting::SetParam("setting_is_new_waimai_biaoqian_printer", "0");
        }
        else
        {
            CSetting::SetParam("setting_is_new_waimai_biaoqian_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"否");
                }

				std::string foodtypeNames = "";

				std::string foodtype_ids = newPrinter.fenlei_ids;
				std::vector<string> ids = CLewaimaiString::Split(foodtype_ids, ",");
				for (std::vector<string>::iterator it = ids.begin(); it != ids.end(); it++)
				{
					std::string name = CSetting::getFoodtypeName((*it));
					std::wstring ws_name = CLewaimaiString::UTF8ToUnicode(name);
					if (name == "zhipuzi_not_found_xxx")
					{
						//这种情况是以前保存的分类后来被删掉了
					}
					else
					{
						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*>(m_pm.FindControl(_T("setting_is_auto_start")));

        if(box->IsSelected())
        {
            CSetting::SetParam("setting_is_auto_start", "0");
            CSystem::cancelAutoStart();
        }
        else
        {
            CSetting::SetParam("setting_is_auto_start", "1");
            CSystem::autostart();
        }
    }
    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"否");
				}

				std::string foodtypeNames = "";

				std::string foodtype_ids = newPrinter.fenlei_ids;
				std::vector<string> ids = CLewaimaiString::Split(foodtype_ids, ",");
				for (std::vector<string>::iterator it = ids.begin(); it != ids.end(); it++)
				{
					std::string name = CSetting::getFoodtypeName((*it));
					std::wstring ws_name = CLewaimaiString::UTF8ToUnicode(name);
					if (name == "zhipuzi_not_found_xxx")
					{
						//这种情况是以前保存的分类后来被删掉了
					}
					else
					{
						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*>(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);
    }
    else if(name == _T("setting_logout"))
    {
        //退出登录
        LoginOut(1);
    }
}

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_biaoqian_printer_switch"))
    {
        CTabLayoutUI* pControl = static_cast<CTabLayoutUI*>(m_pm.FindControl(_T("setting_switch")));
        pControl->SelectItem(2);
    }
    else if(name == _T("setting_chufang_printer_switch"))
    {
        CTabLayoutUI* pControl = static_cast<CTabLayoutUI*>(m_pm.FindControl(_T("setting_switch")));
        pControl->SelectItem(3);
    }
    else if(name == _T("setting_system_switch"))
    {
        CTabLayoutUI* pControl = static_cast<CTabLayoutUI*>(m_pm.FindControl(_T("setting_switch")));
        pControl->SelectItem(4);
    }
    else if(name == _T("setting_system_about"))
    {
        CTabLayoutUI* pControl = static_cast<CTabLayoutUI*>(m_pm.FindControl(_T("setting_switch")));
        pControl->SelectItem(5);
    }
}

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");
        }
    }
    else if(name == _T("setting_printer_leixing"))
    {
        CComboUI* com = static_cast<CComboUI*>(m_pm.FindControl(_T("setting_printer_leixing")));

        CHorizontalLayoutUI* usb_layout = static_cast<CHorizontalLayoutUI*>(m_pm.FindControl(_T("setting_printer_usb_layout")));
        CHorizontalLayoutUI* wangkou_layout = static_cast<CHorizontalLayoutUI*>(m_pm.FindControl(_T("setting_printer_wangkou_layout")));

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

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

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

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

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

            CPosPrinter printer;
            printer.InitUsb();
            std::vector<std::wstring> usb_devices = printer.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, false);
            com_usb->SetText(CLewaimaiString::UTF8ToUnicode(setting_printer_usb).c_str());
        }
        else if(com->GetCurSel() == 2)
        {
            CSetting::SetParam("setting_printer_leixing", "bingkou");

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

            usb_layout->SetVisible(false);
            wangkou_layout->SetVisible(false);
        }
        else if(com->GetCurSel() == 4)
        {
            CSetting::SetParam("setting_printer_leixing", "wangkou");

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

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

            CEditUI* ip_edit = static_cast<CEditUI*>(m_pm.FindControl(_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*>(m_pm.FindControl(_T("setting_printer_usb")));
        wstring usb_device = com->GetText();

        CSetting::SetParam("setting_printer_usb", CLewaimaiString::UnicodeToUTF8(usb_device));
    }
    else if(name == _T("setting_biaoqian_printer_usb"))
    {
        CComboUI* com = static_cast<CComboUI*>(m_pm.FindControl(_T("setting_biaoqian_printer_usb")));
        wstring usb_device = com->GetText();;

        CSetting::SetParam("setting_biaoqian_printer_usb", CLewaimaiString::UnicodeToUTF8(usb_device));
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

    case WM_ORDERLIST_REFRESH:
        lRes = OnOrderlistRefresh(uMsg, wParam, lParam, bHandled);
        break;

    case WM_LOGIN_AGAIN_OUT:
        lRes = OnLoginOut(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::MessageHandler(UINT uMsg, WPARAM wParam, LPARAM lParam, bool& bHandled)
{
    return false;
}

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

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

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

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

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

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

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

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

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

    return lRes;
}

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

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

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

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

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

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

    bHandled = FALSE;
    return 0;
}

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

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

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

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

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

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

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

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

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

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

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

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

            return HTBOTTOM;
        }

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

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

    RECT rcCaption = m_pm.GetCaptionRect();

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

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

    return HTCLIENT;
}

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

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

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

    bHandled = true;
    return 0;
}

LRESULT CMainWnd::OnOrderlistRefresh(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
    OrderListUI* orderlist = static_cast<OrderListUI*>(m_pm.FindControl(_T("orderlist")));
    orderlist->DoRefresh();
    return 1;
}

LRESULT CMainWnd::OnLoginOut(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
    LoginOut(2);
    bHandled = true;
    return 1;
}

void CMainWnd::InitSettingStatus()
{
    //显示当前软件版本和登录账号信息
    CLabelUI* name_version = static_cast<CLabelUI*>(m_pm.FindControl(_T("main_name_version")));
    std::wstring wsShowName = L"乐外卖接单软件 " + CLewaimaiString::UTF8ToUnicode(CSystem::GetVersion());

    std::string last_login_username = CSetting::GetParam("last_login_username");
    std::wstring wx_last_login_username = CLewaimaiString::UTF8ToUnicode(last_login_username);

    wsShowName += L"（登录账号：" + wx_last_login_username + L"）";

    name_version->SetText(wsShowName.c_str());

    CLabelUI* version = static_cast<CLabelUI*>(m_pm.FindControl(_T("setting_version")));
    version->SetText((L"版本号：" + CLewaimaiString::UTF8ToUnicode(CSystem::GetVersion())).c_str());

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

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

    CHorizontalLayoutUI* usb_layout = static_cast<CHorizontalLayoutUI*>(m_pm.FindControl(_T("setting_printer_usb_layout")));
    CHorizontalLayoutUI* wangkou_layout = static_cast<CHorizontalLayoutUI*>(m_pm.FindControl(_T("setting_printer_wangkou_layout")));

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

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

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

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

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

        CPosPrinter printer;
        printer.InitUsb();
        std::vector<std::wstring> usb_devices = printer.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, false);
        com_usb->SetText(CLewaimaiString::UTF8ToUnicode(setting_printer_usb).c_str());
    }
    else if(setting_printer_leixing == "bingkou")
    {
        com->SetInternVisible(true);
        com->SelectItem(2, false, false);
        com->SetText(L"并口");

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

        usb_layout->SetVisible(false);
        wangkou_layout->SetVisible(false);
    }
    else if(setting_printer_leixing == "wangkou")
    {
        com->SetInternVisible(true);
        com->SelectItem(4, false, false);
        com->SetText(L"网口");

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    //厨房打印机设置
    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);
    }

    //初始化标签打印机的设置
    box = static_cast<CCheckBoxUI*>(m_pm.FindControl(_T("setting_is_new_waimai_biaoqian_printer")));

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

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

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

    CPosPrinter printer;
    printer.InitUsb(2);
    std::vector<std::wstring> usb_devices = printer.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_biaoqian_printer_usb)
        {
            nSelect = i;
        }

        i++;
    }

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

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

    //获取当前店铺的商品分类信息，用于设置厨房打印机的分类打印

    //先清空一次分类（主要考虑退出登陆重新登录的情况）
    CSetting::ClearFoodtype();

	std::string shop_id = CLewaimaiHttpClient::getShopId();
	if (shop_id != "0")
	{
		std::map<string, string> params;
		params["shop_id"] = shop_id;

		std::string response;

		std::string url = "/goodstype/getlist";

		CLewaimaiHttpClient::Request(url.c_str(), params, response);

		rapidjson::Document document;
		document.Parse(response.c_str());

		if (document.HasParseError())
		{
			LOG_INFO("parse response error!");
			return;
		}

		if (!document.HasMember("errcode") || !document.HasMember("errmsg") || !document.HasMember("data"))
		{
			LOG_INFO("json error!");
			return;
		}

		rapidjson::Value& v_errcode = document["errcode"];
		int errcode = v_errcode.GetInt();

		if (errcode != 0)
		{
			LOG_INFO("response failed! message:" << document["errmsg"].GetString());
			return;
		}

		//获得数据成功，把分类信息保存起来
		rapidjson::Value& data = document["data"];

		rapidjson::Value& v_rows = data["goods_types"];

		for (rapidjson::SizeType i = 0; i < v_rows.Size(); ++i)
		{
			rapidjson::Value& v_row_i = v_rows[i];

			std::string type_id = v_row_i["type_id"].GetString();
			std::string name = v_row_i["name"].GetString();

			CSetting::AddFoodtype(name, type_id);
		}
	}

    //获取厨房打印机的集合
    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"否");
        }

        std::string foodtypeNames = "";

        std::string foodtype_ids = newPrinter.fenlei_ids;

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

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

        for(std::vector<string>::iterator it = ids.begin(); it != ids.end(); it++)
        {
            std::string name = CSetting::getFoodtypeName((*it));

            if(name == "zhipuzi_not_found_xxx")
            {
                //这种情况是以前保存的分类后来被删掉了
            }
            else
            {
                foodtypeNames += name + "  ";

                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::UpdateChufangPrinter(newPrinter.date, newPrinter.name, newPrinter.ip, newPrinter.guige, newPrinter.fendan, newPrinter.fenlei, new_foodtype_ids, true);
        }

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

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

    if(pLogin == NULL)
    {
        return;
    }

    //设置模式
    pLogin->SetMode(mode);
    pLogin->Create(NULL, _T("乐外卖接单软件登录"), UI_WNDSTYLE_DIALOG, 0, 0, 0, 0, 0, NULL);
    pLogin->SetIcon(IDI_ICON_DUILIB);
    pLogin->CenterWindow();

    ::ShowWindow(*pLogin, SW_SHOWNORMAL);

    Close();
}