zhipuzi_pos_windows/lewaimai_dispatch/wnd/CGameFrameWnd.cpp

#include "../pch/pch.h"
#include "CGameFrameWnd.h"

#include "ControlEx.h"
#include "CWaimaiOrderInfoUI.h"

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

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

    Init();
    return 0;
}

void CGameFrameWnd::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"))
    {
        if(msg.pSender->GetName() == _T("chatCombo"))
        {
            CEditUI* pChatEdit = static_cast<CEditUI*>(m_pm.FindControl(_T("chatEdit")));
            if(pChatEdit)
            {
                pChatEdit->SetText(msg.pSender->GetText());
            }
            static_cast<CComboUI*>(msg.pSender)->SelectItem(-1);
        }
    }
}

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

void CGameFrameWnd::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_saomaxiadan"))
    {
        CTabLayoutUI* pControl = static_cast<CTabLayoutUI*>(m_pm.FindControl(_T("switch")));
        if(pControl && pControl->GetCurSel() != 2)
        {
            pControl->SelectItem(2);
        }
    }
    else if(name == _T("main_setting"))
    {
        CTabLayoutUI* pControl = static_cast<CTabLayoutUI*>(m_pm.FindControl(_T("switch")));
        if(pControl && pControl->GetCurSel() != 3)
        {
            pControl->SelectItem(3);
        }
    }
    else if(name == _T("main_web"))
    {
        CTabLayoutUI* pControl = static_cast<CTabLayoutUI*>(m_pm.FindControl(_T("switch")));
        if(pControl && pControl->GetCurSel() != 4)
        {
            pControl->SelectItem(4);
        }
    }

    //判断外卖的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();
    }
}

LRESULT CGameFrameWnd::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 CGameFrameWnd::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 CGameFrameWnd::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 CGameFrameWnd::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 CGameFrameWnd::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;
}