zhipuzi_pos_windows/zhipuzi_pos_windows/print/CPosPrinterData.cpp

#include "pch.h"
#include "CPosPrinterData.h"

#include "../helper/CBitmapHelper.h"
#include <qrencode/qrencode.h>

CPosPrinterData::CPosPrinterData()
{
}


CPosPrinterData::~CPosPrinterData()
{
}

/*
 *打印收银小票
 **/
std::string CPosPrinterData::PrintWaimaiOrderShouyin(CWaimaiOrder& order)
{
    //读取当前收银打印机的设置
    std::string guige = CSetting::GetInstance()->GetParam("setting_printer_guige");
    std::string lianshu = CSetting::GetInstance()->GetParam("setting_printer_lianshu");
    int n_lianshu = atoi(lianshu.c_str());
	
    //正式开始打印
    for(int i = 0; i < n_lianshu; i++)
    {
        POS_Reset();

		//判断是否打印顶部logo
		if (CShopinfo::GetInstance()->m_machine_logo_open == "1")
		{
			std::wstring imagePath = CShopinfo::GetInstance()->GetImageTmpPathFromUrl(CShopinfo::GetInstance()->m_machine_logo_url);

			POS_OutBmp(imagePath);
			POS_FeedLine();
		}

		//打印店铺名字
		std::string shop_name = CLewaimaiString::UTF8ToGBK(order.m_shop_name);
        POS_TextOut(shop_name, true, true, 1);

        POS_FeedLine();
        POS_FeedLine();

		//打印预约、即时配送的提醒

		/*
		bool setting_printer_peisongshijian_big = false;

		if (CSetting::GetInstance()->GetParam("setting_printer_peisongshijian_big") == "1")
		{
			setting_printer_peisongshijian_big = true;
		}
		}*/

		if (order.m_is_selftake == "1")
		{
			std::string date = CLewaimaiString::UnicodeToGBK(L"【自取单】") + CLewaimaiString::UTF8ToGBK(order.m_delivery_date);
			POS_TextOut(date, false, true);
			POS_TextOut(CLewaimaiString::UnicodeToGBK(L"取货"), false, false);

			POS_FeedLine();

			//自取单打印取餐码
			if (CShopinfo::GetInstance()->m_version_type == "1")
			{
				//餐饮
				std::string date = CLewaimaiString::UnicodeToGBK(L"取餐号：") + CLewaimaiString::UTF8ToGBK(order.m_take_food_code);
				POS_TextOut(date, true, true, 1);
				POS_FeedLine();
			}
			else
			{
				//零售
				std::string date = CLewaimaiString::UnicodeToGBK(L"取货号：") + CLewaimaiString::UTF8ToGBK(order.m_take_food_code);
				POS_TextOut(date, true, true, 1);
				POS_FeedLine();
			}
		}
		else
		{
			if (order.m_delivertime == CLewaimaiString::UnicodeToUTF8(L"尽快送达"))
			{
				//非预约单
				std::string date = CLewaimaiString::UnicodeToGBK(L"【即时单】立即送达");
				POS_TextOut(date, false, true, 1);

				POS_FeedLine();
			}
			else
			{
				//预约单
				std::string date = CLewaimaiString::UnicodeToGBK(L"【预约单】") + CLewaimaiString::UTF8ToGBK(order.m_delivery_date);
				POS_TextOut(date, false, true);
				POS_TextOut(CLewaimaiString::UnicodeToGBK(L"送达"), false, false);

				POS_FeedLine();
			}
		}

		POS_FeedLine();
		
		//打印取货方式
		/*
        bool setting_printer_quhuo_big = false;

        if(CSetting::GetInstance()->GetParam("setting_printer_quhuo_big") == "1")
        {
            setting_printer_quhuo_big = true;
        }

        if(order.m_is_selftake == "1")
        {
			POS_TextOut(CLewaimaiString::UnicodeToGBK(L"到店自取订单"), false, setting_printer_quhuo_big, 1);
            POS_FeedLine();
            POS_FeedLine();
        }
        else
        {
			POS_TextOut(CLewaimaiString::UnicodeToGBK(L"外卖订单"), false, setting_printer_quhuo_big, 1);
            POS_FeedLine();
        }

        POS_FeedLine();
		*/

		//订单来源
		std::string from_type = CLewaimaiString::UnicodeToGBK(L"订单来源：#")  + order.m_restaurant_number + CLewaimaiString::UnicodeToGBK(L" ") + CLewaimaiString::UTF8ToGBK(order.m_from_type);
		POS_TextOut(from_type);
        POS_FeedLine();

        //订单号
        bool setting_printer_dingdanhao_big = false;

        if(CSetting::GetInstance()->GetParam("setting_printer_dingdanhao_big") == "1")
        {
            setting_printer_dingdanhao_big = true;
        }

		std::string order_num = CLewaimaiString::UnicodeToGBK(L"订 单 号：") + CLewaimaiString::UTF8ToGBK(order.m_order_num);
        POS_TextOut(order_num, false, setting_printer_dingdanhao_big);
        POS_FeedLine();

        //下单时间
        bool setting_printer_xiadanshijian_big = false;

        if(CSetting::GetInstance()->GetParam("setting_printer_xiadanshijian_big") == "1")
        {
            setting_printer_xiadanshijian_big = true;
        }

		std::string order_date = CLewaimaiString::UnicodeToGBK(L"下单时间：") + CLewaimaiString::UTF8ToGBK(order.m_order_date);
        POS_TextOut(order_date, false, setting_printer_xiadanshijian_big);
        POS_FeedLine();

        //姓名
        bool setting_printer_name_big = false;

        if(CSetting::GetInstance()->GetParam("setting_printer_name_big") == "1")
        {
            setting_printer_name_big = true;
        }

        if(order.m_is_selftake != "1")
        {
			std::string name = CLewaimaiString::UnicodeToGBK(L"姓名：") + CLewaimaiString::UTF8ToGBK(order.m_customer_name);
			
			//把下单次数也一起打印
			if (order.m_showordernum == "1")
			{
				name += CLewaimaiString::UnicodeToGBK(L"（第 ") + CLewaimaiString::UTF8ToGBK(order.m_customer_order_total) + CLewaimaiString::UnicodeToGBK(L" 次下单）");
			}

            POS_TextOut(name, false, setting_printer_name_big);
            POS_FeedLine();
        }

        //电话
        bool setting_printer_phone_big = false;

        if(CSetting::GetInstance()->GetParam("setting_printer_phone_big") == "1")
        {
            setting_printer_phone_big = true;
        }

		std::string phone = CLewaimaiString::UnicodeToGBK(L"电话：") + CLewaimaiString::UTF8ToGBK(order.m_phone);
        POS_TextOut(phone, false, setting_printer_phone_big);
        POS_FeedLine();

        //地址
        bool setting_printer_address_big = false;

        if(CSetting::GetInstance()->GetParam("setting_printer_address_big") == "1")
        {
            setting_printer_address_big = true;
        }

        if(order.m_is_selftake != "1")
        {
			std::string address = CLewaimaiString::UnicodeToGBK(L"地址：") + CLewaimaiString::UTF8ToGBK(order.m_address);
            POS_TextOut(address, false, setting_printer_address_big);
            POS_FeedLine();
        }

        //预设选项
		if(order.m_order_field.size() > 1)
		{
			if (order.m_is_selftake == "0")
			{
				//如果是外卖配送订单，移除最后的配送时间
				order.m_order_field.pop_back();
			}

			for(std::vector<CWaimaiOrderField>::iterator it = order.m_order_field.begin(); it != order.m_order_field.end(); it++)
			{
				std::string order_field = CLewaimaiString::UTF8ToGBK((*it).name) + CLewaimaiString::UnicodeToGBK(L"：") + CLewaimaiString::UTF8ToGBK((*it).value);
                POS_TextOut(order_field, false, false, 0);
                POS_FeedLine();
            }
        }

		//准备开始打印商品详情
		std::string lines;

		if(guige == "58")
		{
			lines = CLewaimaiString::UnicodeToGBK(L"--------------------------------");
        }
        else
        {
			lines = CLewaimaiString::UnicodeToGBK(L"------------------------------------------------");
        }

        POS_TextOut(lines);
        POS_FeedLine();

        //商品标题
        bool setting_printer_shangpin_big = false;

        if(CSetting::GetInstance()->GetParam("setting_printer_shangpin_big") == "1")
        {
            setting_printer_shangpin_big = true;
        }

        if(guige == "58")
        {
			POS_TextOut(CLewaimaiString::UnicodeToGBK(L"商品           单价   数量  金额"), false, setting_printer_shangpin_big);
        }
        else
        {
			POS_TextOut(CLewaimaiString::UnicodeToGBK(L"商品                         单价    数量   金额"), false, setting_printer_shangpin_big);
        }

        POS_FeedLine();

		if (order.m_manzeng_name.length() > 0)
		{
			CWaimaiOrderItem manzengItem;
			manzengItem.m_food_name = CLewaimaiString::GBKToUTF8(CLewaimaiString::UnicodeToGBK(L"【满赠】") + CLewaimaiString::UTF8ToGBK(order.m_manzeng_name));

			order.m_order_items.push_back(manzengItem);
		}

		//商品内容
		for(std::vector<CWaimaiOrderItem>::iterator it = order.m_order_items.begin(); it != order.m_order_items.end(); it++)
		{
			if (it->is_taocan_item == true)
			{
				//套餐的item，收银小票不打印
				continue;
			}

			std::string food_name = (*it).m_food_name;
            std::string food_price = (*it).m_item_price;
            std::string quantity = (*it).m_quantity;

            //计算总价
            double item_price = atof(food_price.c_str()) * atof(quantity.c_str());
            std::string food_total_price = CLewaimaiString::DoubleToString(item_price, 2);

			if (food_total_price == "0.00")
			{
				//这里是特殊处理满赠的展示
				food_total_price = "";
			}

            food_name = CLewaimaiString::UTF8ToGBK(food_name);

            //先输出商品名字
            std::vector<std::string> m_names;

            if(guige == "58")
            {
                m_names = HandleFoodname(food_name, 1);
            }
            else
            {
                m_names = HandleFoodname(food_name, 2);
            }

            std::string firstLine = m_names[0];
            int nGuige;

            if(guige == "58")
            {
                nGuige = 1;
            }
            else
            {
                nGuige = 2;
            }

            std::string priceShow = HandleFoodItemPrice(food_price, nGuige);
            std::string quantityShow = HandleFoodQuantity(quantity, nGuige);
            std::string priceTotalShow = HandleFoodTotalPrice(food_total_price, nGuige);
            std::string firstLineShow = firstLine + priceShow + quantityShow + priceTotalShow;

            POS_TextOut(firstLineShow, false, setting_printer_shangpin_big);
            POS_FeedLine();

            for(std::vector<std::string>::iterator it = m_names.begin() + 1; it != m_names.end(); it++)
            {
                POS_TextOut((*it), false, setting_printer_shangpin_big);
                POS_FeedLine();
            }
        }

        //判断是否有备注
        if(order.m_memo.length() > 0)
        {
            bool setting_printer_memo_big = false;

            if(CSetting::GetInstance()->GetParam("setting_printer_memo_big") == "1")
            {
                setting_printer_memo_big = true;
            }

            POS_FeedLine();
			std::string address = CLewaimaiString::UnicodeToGBK(L"顾客备注：") + CLewaimaiString::UTF8ToGBK(order.m_memo);
            POS_TextOut(address, false, setting_printer_memo_big);
            POS_FeedLine();
        }

        //结束商品详情打印
        POS_TextOut(lines);
        POS_FeedLine();

        //开始打印其他的费用
        bool is_other_money = false;
        bool setting_printer_price_big = false;

        if(CSetting::GetInstance()->GetParam("setting_printer_price_big") == "1")
        {
            setting_printer_price_big = true;
        }

        if(order.m_delivery > 0)
        {
			std::string delivery = CLewaimaiString::UnicodeToGBK(L"配送费：") + CLewaimaiString::DoubleToString((double)order.m_delivery, 2);
            POS_TextOut(delivery, false, setting_printer_price_big);
            POS_FeedLine();
            is_other_money = true;
        }

        if(order.m_is_dabao == "1")
        {
			std::string dabao = CLewaimaiString::UnicodeToGBK(L"打包费：") + CLewaimaiString::UTF8ToGBK(order.m_dabao_money);
            POS_TextOut(dabao, false, setting_printer_price_big);
            POS_FeedLine();
            is_other_money = true;
        }

        //开始显示增值服务费
        if(order.m_addservie.size() > 0)
        {
            for(std::vector<CWaimaiOrderField>::iterator it = order.m_addservie.begin(); it != order.m_addservie.end(); it++)
            {
				std::string addservice = CLewaimaiString::UTF8ToGBK((*it).name) + CLewaimaiString::UnicodeToGBK(L"：") + CLewaimaiString::DoubleToString((double)atof((*it).value.c_str()), 2);
                POS_TextOut(addservice, false, setting_printer_price_big);
                POS_FeedLine();
                is_other_money = true;
            }

            is_other_money = true;
        }

        if(order.m_discount < 10)
        {
			std::string discount = CLewaimaiString::UnicodeToGBK(L"打折：") + CLewaimaiString::DoubleToString((double)order.m_discount, 2) + CLewaimaiString::UnicodeToGBK(L"折");
            POS_TextOut(discount, false, setting_printer_price_big);
            POS_FeedLine();
            is_other_money = true;
        }

        if(order.m_is_member_discount == "1")
        {
			std::string member_discount = CLewaimaiString::UnicodeToGBK(L"会员优惠：-") + order.m_member_discount;
            POS_TextOut(member_discount, false, setting_printer_price_big);
            POS_FeedLine();
            is_other_money = true;
        }

        if(order.m_is_firstcut == "1")
        {
			std::string firstcut = CLewaimaiString::UnicodeToGBK(L"首单优惠：-") + order.m_firstcut_value;
            POS_TextOut(firstcut, false, setting_printer_price_big);
            POS_FeedLine();
            is_other_money = true;
        }

        //满减
		std::string::size_type position = order.m_promotion.find(":");

        if(position != order.m_promotion.npos)
        {
			std::string promotion_value;
            promotion_value.assign(order.m_promotion, position + 1);
			std::string promotion = CLewaimaiString::UnicodeToGBK(L"满减优惠：-") + CLewaimaiString::DoubleToString((double)(atof(promotion_value.c_str())), 2);
            POS_TextOut(promotion, false, setting_printer_price_big);
            POS_FeedLine();
            is_other_money = true;
        }

        if(order.m_coupon > 0)
        {
			std::string coupon = CLewaimaiString::UnicodeToGBK(L"优惠券：-") + CLewaimaiString::DoubleToString((double)order.m_coupon, 2);
            POS_TextOut(coupon, false, setting_printer_price_big);
            POS_FeedLine();
            is_other_money = true;
        }

        if(is_other_money)
        {
            POS_TextOut(lines);
            POS_FeedLine();
        }

        //最后显示总价
		POS_TextOut(CLewaimaiString::UnicodeToGBK(L"总计：￥") + CLewaimaiString::DoubleToString(order.m_price, 2), false, setting_printer_price_big, 2);
        POS_FeedLine();

        //显示付款方式
        bool setting_printer_pay_big = false;

        if(CSetting::GetInstance()->GetParam("setting_printer_pay_big") == "1")
        {
            setting_printer_pay_big = true;
        }

		POS_TextOut(CLewaimaiString::UnicodeToGBK(L"支付方式：") + CLewaimaiString::UTF8ToGBK(order.m_pay_type), false, setting_printer_pay_big, 2);

        POS_FeedLine();

		POS_FeedLine();
		POS_FeedLine();

		//是否打印底部二维码
		if (CShopinfo::GetInstance()->m_machine_qrcode_open == "1")
		{
			POS_OutQRCode(CLewaimaiString::UTF8ToGBK(CShopinfo::GetInstance()->m_machine_qrcode_url));
			POS_FeedLine();

			POS_TextOut(CLewaimaiString::UTF8ToGBK(CShopinfo::GetInstance()->m_machine_qrcode_title), false, false, 1);
			POS_FeedLine();
			POS_FeedLine();
		}

		if (CShopinfo::GetInstance()->m_self_defined_open == "1")
		{
			POS_TextOut(CLewaimaiString::UTF8ToGBK(CShopinfo::GetInstance()->m_self_defined_content1), false, false, 1);
			POS_FeedLine();
			POS_FeedLine();

			POS_TextOut(CLewaimaiString::UTF8ToGBK(CShopinfo::GetInstance()->m_self_defined_content2), false, false, 1);
			POS_FeedLine();
			POS_FeedLine();
		}

        //走纸几行再切
        POS_FeedLine();
        POS_FeedLine();
        POS_FeedLine();
        POS_FeedLine();
        POS_FeedLine();

        POS_CutPaper();
    }

    //还原打印机初始设置，有些傻逼收银设备居然不是自动调用，比如哗啦啦
    POS_Reset();

	return m_print_content;
}

std::string CPosPrinterData::PrintWaimaiOrderBiaoqian(CWaimaiOrder& order)
{
    std::string printer_usb = CSetting::GetInstance()->GetParam("setting_biaoqian_printer_usb");
    std::wstring ws_printer_usb = CLewaimaiString::UTF8ToUnicode(printer_usb);

	//读取标签纸的规格和方向
	int biaoqian_width, biaoqian_height;
	std::string printer_guige = CSetting::GetInstance()->GetParam("setting_biaoqian_printer_guige");
	if (printer_guige == "40*30mm")
	{
		biaoqian_width = 40;
		biaoqian_height = 30;
	}
	else  if (printer_guige == "35*25mm")
	{
		biaoqian_width = 35;
		biaoqian_height = 25;
	}
	else  if (printer_guige == "30*25mm")
	{
		biaoqian_width = 30;
		biaoqian_height = 25;
	}
	else  if (printer_guige == "30*20mm")
	{
		biaoqian_width = 30;
		biaoqian_height = 20;
	}
	else  if (printer_guige == "60*80mm")
	{
		biaoqian_width = 60;
		biaoqian_height = 80;
	}
	else  if (printer_guige == "80*60mm")
	{
		biaoqian_width = 80;
		biaoqian_height = 60;
	}
	else
	{
		biaoqian_width = 40;
		biaoqian_height = 30;
	}

	int nDIRECTION;
	std::string printer_fangxiang = CSetting::GetInstance()->GetParam("setting_biaoqian_printer_fangxiang");
	if (printer_fangxiang ==  "1")
	{
		nDIRECTION = 1;
	}
	else
	{
		nDIRECTION = 0;
	}

	//初始化标签打印机
	BIAOQIAN_Reset(biaoqian_width, biaoqian_height, nDIRECTION);

	std::vector<CWaimaiOrderItem> cur_printer_use; 

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

	if (setting_biaoqian_printer_is_type == "0")
	{
		for (std::vector<CWaimaiOrderItem>::iterator it = order.m_order_items.begin(); it != order.m_order_items.end(); it++)
		{
			if (it->is_taocan_item == false)
			{
				//如果当前商品的分类，在标签打印机设置的分类里面，才加入
				cur_printer_use.push_back(*it);
			}
		}
	}
	else
	{
		std::map<std::string, bool> ids_map;
		std::vector<std::string> ids = CLewaimaiString::Split(setting_biaoqian_printer_type_ids, ",");

		for (std::vector<std::string>::iterator it = ids.begin(); it != ids.end(); it++)
		{
			ids_map[(*it)] = true;
		}

		for (std::vector<CWaimaiOrderItem>::iterator it = order.m_order_items.begin(); it != order.m_order_items.end(); it++)
		{
			if (ids_map.find((*it).m_type_id) != ids_map.end() && it->is_taocan_item == false)
			{
				//如果当前商品的分类，在标签打印机设置的分类里面，才加入
				cur_printer_use.push_back(*it);
			}
		}
	}

	//先计算商品的总数量
	int foodNum = 0;

	for (std::vector<CWaimaiOrderItem>::iterator it = cur_printer_use.begin(); it != cur_printer_use.end(); it++)
	{
		std::string quantity = (*it).m_quantity;

		foodNum += atoi(quantity.c_str());
	}

	//商品内容
	int curFoodNum = 0;

    for(std::vector<CWaimaiOrderItem>::iterator it = cur_printer_use.begin(); it != cur_printer_use.end(); it++)
    {
        std::string food_name = (*it).m_food_name;
        std::string food_price = (*it).m_item_price;
        std::string quantity = (*it).m_quantity;

        //每份商品打印一个标签
        int nQuantity = atoi(quantity.c_str());

        for(int i = 0; i < nQuantity; i++)
        {
			std::string textData = "";

            curFoodNum++;

            std::string restaurant_number = order.m_restaurant_number;
			std::string order_num_info = CLewaimaiString::UnicodeToGBK(L"#") + CLewaimaiString::UTF8ToGBK(restaurant_number);

			//纸张宽度40mm的，是 320个点位（每mm8个），刚好可以放13个汉字，每个汉字宽度差不多是24，商品换行显示的时候，
			//每行最多12个汉字，也就是空24个，因此这里设置12，刚好左右各空一半
            textData += BIAOQIAN_TEXTGet(order_num_info, 12, 12, 1, 1);

            //打印份数
			std::string numInfo = std::to_string(curFoodNum) + CLewaimaiString::UnicodeToGBK(L"/") + std::to_string(foodNum);

			//计算份数的位置
			int nFenshuLeft = (biaoqian_width - 8) * 8;
            textData += BIAOQIAN_TEXTGet(numInfo, nFenshuLeft, 12, 1, 1);

            //每行最多显示12个汉字，这里要计算一下换行（要先转成ANSI格式）
            std::string handle_food_name = CLewaimaiString::UTF8ToGBK(food_name);
            std::vector<std::string> foodNameVector = HandleBiaoqianFoodname(handle_food_name, biaoqian_width);

            int nRow = 0;

            //考虑是否用大号字体
            bool is_big_name = false;

			/*暂时全部打印小字，这里注释掉
            if(foodNameVector.size() <= 2)
            {
                //不超过2行，可以用大的字体
                is_big_name = true;
            }*/

            //LOG_INFO("foodNameVector size:" << foodNameVector.size());
			
            for(std::vector<std::string>::iterator it = foodNameVector.begin(); it != foodNameVector.end(); it++)
            {
                LOG_INFO("nRow:" << nRow << ", 准备打印商品名字：" << (*it).c_str());

                if(is_big_name)
                {
                    textData += BIAOQIAN_TEXTGet(*it, 12, 42 + 60 * nRow, 1, 2);
                }
                else
                {
                    textData += BIAOQIAN_TEXTGet(*it, 12, 42 + 30 * nRow, 1, 1);
                }

                nRow++;
            }

			//如果是自取订单，打印取餐号m_take_food_code
			if (order.m_is_selftake == "1")
			{
				int nQucanmaY = 42 + 30 * nRow + 10;

				//打印取餐码
				std::string order_num_info = CLewaimaiString::UnicodeToGBK(L"取餐码：") + CLewaimaiString::UTF8ToGBK(order.m_take_food_code);
				BIAOQIAN_BARCODEOUT(CLewaimaiString::UTF8ToGBK(order.m_take_food_code), 12, nQucanmaY);
			}

			int nHeightNow;
			if (biaoqian_height <= 30)
			{
				nHeightNow = (biaoqian_height - 4) * 8;
			}
			else
			{
				nHeightNow = (30 - 4) * 8;
			}

            //打印价格
			std::string priceInfo = CLewaimaiString::UTF8ToGBK(food_price) + CLewaimaiString::UnicodeToGBK(L"元");
            textData += BIAOQIAN_TEXTGet(priceInfo, 12, nHeightNow, 1, 1);

			//打印订单号
			//std::string order_num = CLewaimaiString::UnicodeToGBK(L"订单号：") + CLewaimaiString::UTF8ToGBK(order.m_order_num);
			//textData += BIAOQIAN_TEXTGet(order_num, 172, nHeightNow, 1, 1);

			//这种是比较大的纸，可以打印更多的订单信息
			if (biaoqian_height >= 60)
			{
				nHeightNow = nHeightNow + 30 + 30;

				//先打印一个分割线
				int nZimuNum = (int)(biaoqian_width * 24 / 40);
				
				std::string line = "";
				for (int i = 0; i < nZimuNum; i++)
				{
					line += "-";
				}

				textData += BIAOQIAN_TEXTGet(line, 12, nHeightNow, 1, 1);
				nHeightNow += 30;
				
				if (order.m_is_selftake == "1")
				{
					std::string date = CLewaimaiString::UnicodeToGBK(L"配送时间：【自取单】") + CLewaimaiString::UTF8ToGBK(order.m_delivery_date);
					textData += BIAOQIAN_TEXTGet(date, 12, nHeightNow, 1, 1);
				}
				else
				{
					if (order.m_delivertime == CLewaimaiString::UnicodeToUTF8(L"尽快送达"))
					{
						//非预约单
						std::string date = CLewaimaiString::UnicodeToGBK(L"配送时间：【即时单】立即送达");
						textData += BIAOQIAN_TEXTGet(date, 12, nHeightNow, 1, 1);
					}
					else
					{
						//预约单
						std::string date = CLewaimaiString::UnicodeToGBK(L"配送时间：【预约单】") + CLewaimaiString::UTF8ToGBK(order.m_delivery_date) + CLewaimaiString::UnicodeToGBK(L"送达");
						textData += BIAOQIAN_TEXTGet(date, 12, nHeightNow, 1, 1);
					}
				}
				nHeightNow += 30;

				std::string pay_type = CLewaimaiString::UnicodeToGBK(L"支付方式：") + CLewaimaiString::UTF8ToGBK(order.m_pay_type);
				textData += BIAOQIAN_TEXTGet(pay_type, 12, nHeightNow, 1, 1);
				nHeightNow += 30;

				//打印分割线
				textData += BIAOQIAN_TEXTGet(line, 12, nHeightNow, 1, 1);
				nHeightNow += 30;

				std::string name = CLewaimaiString::UnicodeToGBK(L"姓名：") + CLewaimaiString::UTF8ToGBK(order.m_customer_name);
				textData += BIAOQIAN_TEXTGet(name, 12, nHeightNow, 1, 1);
				nHeightNow += 30;

				std::string phone = CLewaimaiString::UnicodeToGBK(L"电话：") + CLewaimaiString::UTF8ToGBK(order.m_phone);
				textData += BIAOQIAN_TEXTGet(phone, 12, nHeightNow, 1, 1);
				nHeightNow += 30;

				//地址有可能很长要换行，要处理一下
				std::string address = CLewaimaiString::UnicodeToGBK(L"地址：") + CLewaimaiString::UTF8ToGBK(order.m_address);

				//每行最多显示12个汉字，这里要计算一下换行（要先转成ANSI格式）
				std::string handle_address_name = address;
				std::vector<std::string> addressVector = HandleBiaoqianFoodname(handle_address_name, biaoqian_width, false);

				int nRow = 0;
				for (std::vector<std::string>::iterator it = addressVector.begin(); it != addressVector.end(); it++)
				{
					textData += BIAOQIAN_TEXTGet(*it, 12, nHeightNow, 1, 1);

					nRow++;

					nHeightNow += 30;
				}

				//高度60的打印完地址就结束了，高度80以上的接着打印
				if (biaoqian_height >= 80)
				{
					//预设选项
					if (order.m_order_field.size() > 1)
					{
						for (std::vector<CWaimaiOrderField>::iterator it = order.m_order_field.begin(); it != order.m_order_field.end() - 1; it++)
						{
							std::string order_field = CLewaimaiString::UTF8ToGBK((*it).name) + CLewaimaiString::UnicodeToGBK(L"：") + CLewaimaiString::UTF8ToGBK((*it).value);
							textData += BIAOQIAN_TEXTGet(order_field, 12, nHeightNow, 1, 1);

							nHeightNow += 30;
						}
					}

					//判断是否有备注
					if (order.m_memo.length() > 0)
					{
						//打印分割线
						textData += BIAOQIAN_TEXTGet(line, 12, nHeightNow, 1, 1);
						nHeightNow += 30;

						std::string memo = CLewaimaiString::UnicodeToGBK(L"顾客备注：") + CLewaimaiString::UTF8ToGBK(order.m_memo);
						textData += BIAOQIAN_TEXTGet(memo, 12, nHeightNow, 1, 1);

						nHeightNow += 30;
					}
				}
			}

			WriteData(textData);

			BIAOQIAN_PRINT();

			BIAOQIAN_CLS();
        }
    }

	return m_print_content;
}

std::vector<ChufangPrinterContent> CPosPrinterData::PrintWaimaiOrderChufang(CWaimaiOrder& order)
{
	std::vector<ChufangPrinterContent> datas;

    //读取厨房打印机信息
    std::vector<ChufangPrinter> total_printers = CSetting::GetInstance()->getChufangPrints();

    for(std::vector<ChufangPrinter>::iterator it = total_printers.begin(); it != total_printers.end(); it++)
    {
		//清空每个厨房打印机的打印内容
		m_print_content = "";

        ChufangPrinter printer = *it;
        std::string ip = printer.ip;

        std::string guige = printer.guige;
        std::string fendan = printer.fendan;
		std::string fenlei = printer.fenlei;
		std::string fenlei_ids = printer.fenlei_ids;

		std::vector<CWaimaiOrderItem> cur_printer_use;
		if (fenlei == "0")
		{
			cur_printer_use = order.m_order_items;
		}
		else
		{
			//如果开启了分类打印，就要比对了
			std::map<std::string, bool> ids_map;
			std::vector<std::string> ids = CLewaimaiString::Split(fenlei_ids, ",");

			for (std::vector<std::string>::iterator it = ids.begin(); it != ids.end(); it++)
			{
				ids_map[(*it)] = true;
			}

			for (std::vector<CWaimaiOrderItem>::iterator it = order.m_order_items.begin(); it != order.m_order_items.end(); it++)
			{
				if (ids_map.find((*it).m_type_id) != ids_map.end())
				{
					//如果当前商品的分类，在厨房打印机设置的分类里面，才加入
					cur_printer_use.push_back(*it);
				}
			}
		}

		if (cur_printer_use.size() == 0)
		{
			//如果这个厨房打印机没有商品可以打印（开启了商品分类打印可能出现），就直接跳过
			continue;
		}

        if(fendan == "0")
        {
            POS_Reset();
			POS_TextOut(CLewaimaiString::UnicodeToGBK(L"派工单"), true, true, 1);
            POS_FeedLine();

            POS_FeedLine();

			std::string order_type = CLewaimaiString::UnicodeToGBK(L"#") + order.m_restaurant_number + CLewaimaiString::UnicodeToGBK(L"  ");

            if(order.m_is_selftake == "1")
            {
				POS_TextOut(order_type + CLewaimaiString::UnicodeToGBK(L"到店自取订单"), false, true, 1);
                POS_FeedLine();

                POS_FeedLine();
            }
            else
            {
				POS_TextOut(order_type + CLewaimaiString::UnicodeToGBK(L"外卖订单"), false, true, 1);
                POS_FeedLine();

                POS_FeedLine();
            }

            //预设选项
            if(order.m_order_field.size() > 1)
            {
                for(std::vector<CWaimaiOrderField>::iterator it = order.m_order_field.begin(); it != order.m_order_field.end() - 1; it++)
                {
				std::string order_field = CLewaimaiString::UTF8ToGBK((*it).name) + CLewaimaiString::UnicodeToGBK(L"：") + CLewaimaiString::UTF8ToGBK((*it).value);
                    POS_TextOut(order_field, false, true, 0);
                    POS_FeedLine();
                }
            }

            //准备开始打印商品详情
			std::string lines;

            if(guige == "58")
            {
				lines = CLewaimaiString::UnicodeToGBK(L"--------------------------------");
            }
            else
            {
				lines = CLewaimaiString::UnicodeToGBK(L"------------------------------------------------");
            }

            POS_TextOut(lines);
            POS_FeedLine();

            //商品标题
            if(guige == "58")
            {
                POS_TextOut(CLewaimaiString::UnicodeToGBK(L"商品           单价   数量  金额"), false, true);
            }
            else
            {
                POS_TextOut(CLewaimaiString::UnicodeToGBK(L"商品                         单价    数量   金额"), false, true);
            }

            POS_FeedLine();

            //商品内容
            for(std::vector<CWaimaiOrderItem>::iterator it = cur_printer_use.begin(); it != cur_printer_use.end(); it++)
            {
				if (it->is_taocan == true)
				{
					//套餐的名字，厨房打印不打印
					continue;
				}

                std::string food_name = (*it).m_food_name;
                std::string food_price = (*it).m_item_price;
                std::string quantity = (*it).m_quantity;

                //计算总价
                double item_price = atof(food_price.c_str()) * atof(quantity.c_str());
                std::string food_total_price = CLewaimaiString::DoubleToString(item_price, 2);
                food_name = CLewaimaiString::UTF8ToGBK(food_name);
                //先输出商品名字
                std::vector<std::string> m_names;

                if(guige == "58")
                {
                    m_names = HandleFoodname(food_name, 1);
                }
                else
                {
                    m_names = HandleFoodname(food_name, 2);
                }

                std::string firstLine = m_names[0];
                int nGuige;

                if(guige == "58")
                {
                    nGuige = 1;
                }
                else
                {
                    nGuige = 2;
                }

                std::string priceShow = HandleFoodItemPrice(food_price, nGuige);
                std::string quantityShow = HandleFoodQuantity(quantity, nGuige);
                std::string priceTotalShow = HandleFoodTotalPrice(food_total_price, nGuige);
                std::string firstLineShow = firstLine + priceShow + quantityShow + priceTotalShow;
                POS_TextOut(firstLineShow, false, true, 0);
                POS_FeedLine();

                for(std::vector<std::string>::iterator it = m_names.begin() + 1; it != m_names.end(); it++)
                {
                    POS_TextOut((*it), false, true, 0);
                    POS_FeedLine();
                }
            }

            //判断是否有备注
            if(order.m_memo.length() > 0)
            {
                POS_FeedLine();
					std::string address = CLewaimaiString::UnicodeToGBK(L"顾客备注：") + CLewaimaiString::UTF8ToGBK(order.m_memo);
                POS_TextOut(address, false, true, 0);
                POS_FeedLine();
            }

            //结束商品详情打印
            POS_TextOut(lines);
            POS_FeedLine();

            POS_FeedLine();
            POS_FeedLine();
            POS_FeedLine();
            POS_FeedLine();
            POS_FeedLine();

            POS_CutPaper();

            //还原打印机初始设置，有些傻逼收银设备居然不是自动调用，比如哗啦啦
            POS_Reset();
        }
        else
        {
            POS_Reset();

            //分单模式下，每个商品打印一张单
            for(std::vector<CWaimaiOrderItem>::iterator it = cur_printer_use.begin(); it != cur_printer_use.end(); it++)
            {
				if (it->is_taocan == true)
				{
					//套餐的名字，厨房打印不打印
					continue;
				}

				POS_TextOut(CLewaimaiString::UnicodeToGBK(L"派工单"), true, true, 1);
                POS_FeedLine();

                POS_FeedLine();

				std::string order_type = CLewaimaiString::UnicodeToGBK(L"#") + order.m_restaurant_number + CLewaimaiString::UnicodeToGBK(L"  ");

                if(order.m_is_selftake == "1")
                {
					POS_TextOut(order_type + CLewaimaiString::UnicodeToGBK(L"到店自取订单"), false, true, 1);
                    POS_FeedLine();

                    POS_FeedLine();
                }
                else
                {
					POS_TextOut(order_type + CLewaimaiString::UnicodeToGBK(L"外卖订单"), false, true, 1);
                    POS_FeedLine();

                    POS_FeedLine();
                }

                //预设选项
                if(order.m_order_field.size() > 1)
                {
                    for(std::vector<CWaimaiOrderField>::iterator it = order.m_order_field.begin(); it != order.m_order_field.end() - 1; it++)
                    {
						std::string order_field = CLewaimaiString::UTF8ToGBK((*it).name) + "：" + CLewaimaiString::UTF8ToGBK((*it).value);
                        POS_TextOut(order_field, false, true, 0);
                        POS_FeedLine();
                    }
                }

                //准备开始打印商品详情
				std::string lines;

                if(guige == "58")
                {
					lines = CLewaimaiString::UnicodeToGBK(L"--------------------------------");
                }
                else
                {
					lines = CLewaimaiString::UnicodeToGBK(L"------------------------------------------------");
                }

                POS_TextOut(lines);
                POS_FeedLine();

                //商品标题
                if(guige == "58")
                {
                    POS_TextOut(CLewaimaiString::UnicodeToGBK(L"商品           单价   数量  金额"), false, true);
                }
                else
                {
                    POS_TextOut(CLewaimaiString::UnicodeToGBK(L"商品                         单价    数量   金额"), false, true);
                }

                POS_FeedLine();
                std::string food_name = (*it).m_food_name;
                std::string food_price = (*it).m_item_price;
                std::string quantity = (*it).m_quantity;
                //计算总价
                double item_price = atof(food_price.c_str()) * atof(quantity.c_str());
                std::string food_total_price = CLewaimaiString::DoubleToString(item_price, 2);
                food_name = CLewaimaiString::UTF8ToGBK(food_name);
                //先输出商品名字
                std::vector<std::string> m_names;

                if(guige == "58")
                {
                    m_names = HandleFoodname(food_name, 1);
                }
                else
                {
                    m_names = HandleFoodname(food_name, 2);
                }

                std::string firstLine = m_names[0];
                std::string priceShow = HandleFoodItemPrice(food_price, 2);
                std::string quantityShow = HandleFoodQuantity(quantity, 2);
                std::string priceTotalShow = HandleFoodTotalPrice(food_total_price, 2);
                std::string firstLineShow = firstLine + priceShow + quantityShow + priceTotalShow;
                POS_TextOut(firstLineShow, false, true, 0);
                POS_FeedLine();

                for(std::vector<std::string>::iterator it = m_names.begin() + 1; it != m_names.end(); it++)
                {
                    POS_TextOut((*it), false, true, 0);
                    POS_FeedLine();
                }

                //判断是否有备注
                if(order.m_memo.length() > 0)
                {
                    POS_FeedLine();
					std::string address = CLewaimaiString::UnicodeToGBK(L"顾客备注：") + CLewaimaiString::UTF8ToGBK(order.m_memo);
                    POS_TextOut(address, false, true, 0);
                    POS_FeedLine();
                }

                //结束商品详情打印
                POS_TextOut(lines);
                POS_FeedLine();

                POS_FeedLine();
                POS_FeedLine();
                POS_FeedLine();
                POS_FeedLine();
                POS_FeedLine();

                POS_CutPaper();
            }

            //还原打印机初始设置，有些傻逼收银设备居然不是自动调用，比如哗啦啦
            POS_Reset();
        }

		ChufangPrinterContent newData;
		newData.ip = ip;
		newData.data = m_print_content;

		datas.push_back(newData);
    }

	return datas;
}

std::string CPosPrinterData::PrintWaimaiOrderCancelShouyin(CWaimaiOrder& order)
{
	//读取当前收银打印机的设置
	std::string guige = CSetting::GetInstance()->GetParam("setting_printer_guige");

	//正式开始打印
	POS_Reset();

	POS_TextOut(CLewaimaiString::UnicodeToGBK(L"外卖订单取消通知"), true, true, 1);

	POS_FeedLine();
	POS_FeedLine();

	//打印店铺名字
	std::string shop_name = CLewaimaiString::UTF8ToGBK(order.m_shop_name);
	POS_TextOut(shop_name, true, true, 1);

	POS_FeedLine();
	POS_FeedLine();

	//打印预约、即时配送的提醒

	/*
	bool setting_printer_peisongshijian_big = false;

	if (CSetting::GetInstance()->GetParam("setting_printer_peisongshijian_big") == "1")
	{
		setting_printer_peisongshijian_big = true;
	}
	}*/

	if (order.m_is_selftake == "1")
	{
		std::string date = CLewaimaiString::UnicodeToGBK(L"【自取单】") + CLewaimaiString::UTF8ToGBK(order.m_delivery_date);
		POS_TextOut(date, false, true);
		POS_TextOut(CLewaimaiString::UnicodeToGBK(L"取货"), false, false);

		POS_FeedLine();

		//自取单打印取餐码
		if (CShopinfo::GetInstance()->m_version_type == "1")
		{
			//餐饮
			std::string date = CLewaimaiString::UnicodeToGBK(L"取餐号：") + CLewaimaiString::UTF8ToGBK(order.m_take_food_code);
			POS_TextOut(date, true, true, 1);
			POS_FeedLine();
		}
		else
		{
			//零售
			std::string date = CLewaimaiString::UnicodeToGBK(L"取货号：") + CLewaimaiString::UTF8ToGBK(order.m_take_food_code);
			POS_TextOut(date, true, true, 1);
			POS_FeedLine();
		}
	}
	else
	{
		if (order.m_delivertime == CLewaimaiString::UnicodeToUTF8(L"尽快送达"))
		{
			//非预约单
			std::string date = CLewaimaiString::UnicodeToGBK(L"【即时单】立即送达");
			POS_TextOut(date, false, true, 1);

			POS_FeedLine();
		}
		else
		{
			//预约单
			std::string date = CLewaimaiString::UnicodeToGBK(L"【预约单】") + CLewaimaiString::UTF8ToGBK(order.m_delivery_date);
			POS_TextOut(date, false, true);
			POS_TextOut(CLewaimaiString::UnicodeToGBK(L"送达"), false, false);

			POS_FeedLine();
		}
	}

	POS_FeedLine();

	//打印取货方式
	/*
	bool setting_printer_quhuo_big = false;

	if(CSetting::GetInstance()->GetParam("setting_printer_quhuo_big") == "1")
	{
		setting_printer_quhuo_big = true;
	}

	if(order.m_is_selftake == "1")
	{
		POS_TextOut(CLewaimaiString::UnicodeToGBK(L"到店自取订单"), false, setting_printer_quhuo_big, 1);
		POS_FeedLine();
		POS_FeedLine();
	}
	else
	{
		POS_TextOut(CLewaimaiString::UnicodeToGBK(L"外卖订单"), false, setting_printer_quhuo_big, 1);
		POS_FeedLine();
	}

	POS_FeedLine();
	*/

	//订单来源
	std::string from_type = CLewaimaiString::UnicodeToGBK(L"订单来源：#") + order.m_restaurant_number + CLewaimaiString::UnicodeToGBK(L" ") + CLewaimaiString::UTF8ToGBK(order.m_from_type);
	POS_TextOut(from_type);
	POS_FeedLine();

	//订单号
	bool setting_printer_dingdanhao_big = false;

	if (CSetting::GetInstance()->GetParam("setting_printer_dingdanhao_big") == "1")
	{
		setting_printer_dingdanhao_big = true;
	}

	std::string order_num = CLewaimaiString::UnicodeToGBK(L"订 单 号：") + CLewaimaiString::UTF8ToGBK(order.m_order_num);
	POS_TextOut(order_num, false, setting_printer_dingdanhao_big);
	POS_FeedLine();

	//下单时间
	bool setting_printer_xiadanshijian_big = false;

	if (CSetting::GetInstance()->GetParam("setting_printer_xiadanshijian_big") == "1")
	{
		setting_printer_xiadanshijian_big = true;
	}

	std::string order_date = CLewaimaiString::UnicodeToGBK(L"下单时间：") + CLewaimaiString::UTF8ToGBK(order.m_order_date);
	POS_TextOut(order_date, false, setting_printer_xiadanshijian_big);
	POS_FeedLine();

	//姓名
	bool setting_printer_name_big = false;

	if (CSetting::GetInstance()->GetParam("setting_printer_name_big") == "1")
	{
		setting_printer_name_big = true;
	}

	if (order.m_is_selftake != "1")
	{
		std::string name = CLewaimaiString::UnicodeToGBK(L"姓名：") + CLewaimaiString::UTF8ToGBK(order.m_customer_name);

		//把下单次数也一起打印
		if (order.m_showordernum == "1")
		{
			name += CLewaimaiString::UnicodeToGBK(L"（第 ") + CLewaimaiString::UTF8ToGBK(order.m_customer_order_total) + CLewaimaiString::UnicodeToGBK(L" 次下单）");
		}

		POS_TextOut(name, false, setting_printer_name_big);
		POS_FeedLine();
	}

	//电话
	bool setting_printer_phone_big = false;

	if (CSetting::GetInstance()->GetParam("setting_printer_phone_big") == "1")
	{
		setting_printer_phone_big = true;
	}

	std::string phone = CLewaimaiString::UnicodeToGBK(L"电话：") + CLewaimaiString::UTF8ToGBK(order.m_phone);
	POS_TextOut(phone, false, setting_printer_phone_big);
	POS_FeedLine();

	//地址
	bool setting_printer_address_big = false;

	if (CSetting::GetInstance()->GetParam("setting_printer_address_big") == "1")
	{
		setting_printer_address_big = true;
	}

	if (order.m_is_selftake != "1")
	{
		std::string address = CLewaimaiString::UnicodeToGBK(L"地址：") + CLewaimaiString::UTF8ToGBK(order.m_address);
		POS_TextOut(address, false, setting_printer_address_big);
		POS_FeedLine();
	}

	//预设选项
	if (order.m_order_field.size() > 1)
	{
		if (order.m_is_selftake == "0")
		{
			//如果是外卖配送订单，移除最后的配送时间
			order.m_order_field.pop_back();
		}

		for (std::vector<CWaimaiOrderField>::iterator it = order.m_order_field.begin(); it != order.m_order_field.end(); it++)
		{
			std::string order_field = CLewaimaiString::UTF8ToGBK((*it).name) + CLewaimaiString::UnicodeToGBK(L"：") + CLewaimaiString::UTF8ToGBK((*it).value);
			POS_TextOut(order_field, false, false, 0);
			POS_FeedLine();
		}
	}

	//准备开始打印商品详情
	std::string lines;

	if (guige == "58")
	{
		lines = CLewaimaiString::UnicodeToGBK(L"--------------------------------");
	}
	else
	{
		lines = CLewaimaiString::UnicodeToGBK(L"------------------------------------------------");
	}

	POS_TextOut(lines);
	POS_FeedLine();

	//商品标题
	bool setting_printer_shangpin_big = false;

	if (CSetting::GetInstance()->GetParam("setting_printer_shangpin_big") == "1")
	{
		setting_printer_shangpin_big = true;
	}

	if (guige == "58")
	{
		POS_TextOut(CLewaimaiString::UnicodeToGBK(L"商品           单价   数量  金额"), false, setting_printer_shangpin_big);
	}
	else
	{
		POS_TextOut(CLewaimaiString::UnicodeToGBK(L"商品                         单价    数量   金额"), false, setting_printer_shangpin_big);
	}

	POS_FeedLine();

	if (order.m_manzeng_name.length() > 0)
	{
		CWaimaiOrderItem manzengItem;
		manzengItem.m_food_name = CLewaimaiString::GBKToUTF8(CLewaimaiString::UnicodeToGBK(L"【满赠】") + CLewaimaiString::UTF8ToGBK(order.m_manzeng_name));

		order.m_order_items.push_back(manzengItem);
	}

	//商品内容
	for (std::vector<CWaimaiOrderItem>::iterator it = order.m_order_items.begin(); it != order.m_order_items.end(); it++)
	{
		if (it->is_taocan_item == true)
		{
			//套餐的item，收银小票不打印
			continue;
		}

		std::string food_name = (*it).m_food_name;
		std::string food_price = (*it).m_item_price;
		std::string quantity = (*it).m_quantity;

		//计算总价
		double item_price = atof(food_price.c_str()) * atof(quantity.c_str());
		std::string food_total_price = CLewaimaiString::DoubleToString(item_price, 2);

		if (food_total_price == "0.00")
		{
			//这里是特殊处理满赠的展示
			food_total_price = "";
		}

		food_name = CLewaimaiString::UTF8ToGBK(food_name);

		//先输出商品名字
		std::vector<std::string> m_names;

		if (guige == "58")
		{
			m_names = HandleFoodname(food_name, 1);
		}
		else
		{
			m_names = HandleFoodname(food_name, 2);
		}

		std::string firstLine = m_names[0];
		int nGuige;

		if (guige == "58")
		{
			nGuige = 1;
		}
		else
		{
			nGuige = 2;
		}

		std::string priceShow = HandleFoodItemPrice(food_price, nGuige);
		std::string quantityShow = HandleFoodQuantity(quantity, nGuige);
		std::string priceTotalShow = HandleFoodTotalPrice(food_total_price, nGuige);
		std::string firstLineShow = firstLine + priceShow + quantityShow + priceTotalShow;

		POS_TextOut(firstLineShow, false, setting_printer_shangpin_big);
		POS_FeedLine();

		for (std::vector<std::string>::iterator it = m_names.begin() + 1; it != m_names.end(); it++)
		{
			POS_TextOut((*it), false, setting_printer_shangpin_big);
			POS_FeedLine();
		}
	}

	//判断是否有备注
	if (order.m_memo.length() > 0)
	{
		bool setting_printer_memo_big = false;

		if (CSetting::GetInstance()->GetParam("setting_printer_memo_big") == "1")
		{
			setting_printer_memo_big = true;
		}

		POS_FeedLine();
		std::string address = CLewaimaiString::UnicodeToGBK(L"顾客备注：") + CLewaimaiString::UTF8ToGBK(order.m_memo);
		POS_TextOut(address, false, setting_printer_memo_big);
		POS_FeedLine();
	}

	//结束商品详情打印
	POS_TextOut(lines);
	POS_FeedLine();

	POS_TextOut(CLewaimaiString::UnicodeToGBK(L"该订单已被顾客取消，请停止出餐配送！！！"), true, true, 2);

	POS_FeedLine();
	POS_FeedLine();

	//走纸几行再切
	POS_FeedLine();
	POS_FeedLine();
	POS_FeedLine();
	POS_FeedLine();
	POS_FeedLine();

	POS_CutPaper();

	//还原打印机初始设置，有些傻逼收银设备居然不是自动调用，比如哗啦啦
	POS_Reset();

	return m_print_content;
}

std::vector<ChufangPrinterContent> CPosPrinterData::PrintWaimaiOrderCancelChufang(CWaimaiOrder& order)
{
	std::vector<ChufangPrinterContent> datas;

	//读取厨房打印机信息
	std::vector<ChufangPrinter> total_printers = CSetting::GetInstance()->getChufangPrints();

	for (std::vector<ChufangPrinter>::iterator it = total_printers.begin(); it != total_printers.end(); it++)
	{
		//清空每个厨房打印机的打印内容
		m_print_content = "";

		ChufangPrinter printer = *it;
		std::string ip = printer.ip;

		std::string guige = printer.guige;
		std::string fendan = printer.fendan;
		std::string fenlei = printer.fenlei;
		std::string fenlei_ids = printer.fenlei_ids;

		std::vector<CWaimaiOrderItem> cur_printer_use;
		if (fenlei == "0")
		{
			cur_printer_use = order.m_order_items;
		}
		else
		{
			//如果开启了分类打印，就要比对了
			std::map<std::string, bool> ids_map;
			std::vector<std::string> ids = CLewaimaiString::Split(fenlei_ids, ",");

			for (std::vector<std::string>::iterator it = ids.begin(); it != ids.end(); it++)
			{
				ids_map[(*it)] = true;
			}

			for (std::vector<CWaimaiOrderItem>::iterator it = order.m_order_items.begin(); it != order.m_order_items.end(); it++)
			{
				if (ids_map.find((*it).m_type_id) != ids_map.end())
				{
					//如果当前商品的分类，在厨房打印机设置的分类里面，才加入
					cur_printer_use.push_back(*it);
				}
			}
		}

		if (cur_printer_use.size() == 0)
		{
			//如果这个厨房打印机没有商品可以打印（开启了商品分类打印可能出现），就直接跳过
			continue;
		}

		if (fendan == "0")
		{
			POS_Reset();
			POS_TextOut(CLewaimaiString::UnicodeToGBK(L"外卖订单取消通知"), true, true, 1);
			POS_FeedLine();

			POS_FeedLine();

			std::string order_type = CLewaimaiString::UnicodeToGBK(L"#") + order.m_restaurant_number + CLewaimaiString::UnicodeToGBK(L"  ");

			if (order.m_is_selftake == "1")
			{
				POS_TextOut(order_type + CLewaimaiString::UnicodeToGBK(L"到店自取订单"), false, true, 1);
				POS_FeedLine();

				POS_FeedLine();
			}
			else
			{
				POS_TextOut(order_type + CLewaimaiString::UnicodeToGBK(L"外卖订单"), false, true, 1);
				POS_FeedLine();

				POS_FeedLine();
			}

			//预设选项
			if (order.m_order_field.size() > 1)
			{
				for (std::vector<CWaimaiOrderField>::iterator it = order.m_order_field.begin(); it != order.m_order_field.end() - 1; it++)
				{
					std::string order_field = CLewaimaiString::UTF8ToGBK((*it).name) + CLewaimaiString::UnicodeToGBK(L"：") + CLewaimaiString::UTF8ToGBK((*it).value);
					POS_TextOut(order_field, false, true, 0);
					POS_FeedLine();
				}
			}

			//准备开始打印商品详情
			std::string lines;

			if (guige == "58")
			{
				lines = CLewaimaiString::UnicodeToGBK(L"--------------------------------");
			}
			else
			{
				lines = CLewaimaiString::UnicodeToGBK(L"------------------------------------------------");
			}

			POS_TextOut(lines);
			POS_FeedLine();

			//商品标题
			if (guige == "58")
			{
				POS_TextOut(CLewaimaiString::UnicodeToGBK(L"商品           单价   数量  金额"), false, true);
			}
			else
			{
				POS_TextOut(CLewaimaiString::UnicodeToGBK(L"商品                         单价    数量   金额"), false, true);
			}

			POS_FeedLine();

			//商品内容
			for (std::vector<CWaimaiOrderItem>::iterator it = cur_printer_use.begin(); it != cur_printer_use.end(); it++)
			{
				if (it->is_taocan == true)
				{
					//套餐的名字，厨房打印不打印
					continue;
				}

				std::string food_name = (*it).m_food_name;
				std::string food_price = (*it).m_item_price;
				std::string quantity = (*it).m_quantity;

				//计算总价
				double item_price = atof(food_price.c_str()) * atof(quantity.c_str());
				std::string food_total_price = CLewaimaiString::DoubleToString(item_price, 2);
				food_name = CLewaimaiString::UTF8ToGBK(food_name);
				//先输出商品名字
				std::vector<std::string> m_names;

				if (guige == "58")
				{
					m_names = HandleFoodname(food_name, 1);
				}
				else
				{
					m_names = HandleFoodname(food_name, 2);
				}

				std::string firstLine = m_names[0];
				int nGuige;

				if (guige == "58")
				{
					nGuige = 1;
				}
				else
				{
					nGuige = 2;
				}

				std::string priceShow = HandleFoodItemPrice(food_price, nGuige);
				std::string quantityShow = HandleFoodQuantity(quantity, nGuige);
				std::string priceTotalShow = HandleFoodTotalPrice(food_total_price, nGuige);
				std::string firstLineShow = firstLine + priceShow + quantityShow + priceTotalShow;
				POS_TextOut(firstLineShow, false, true, 0);
				POS_FeedLine();

				for (std::vector<std::string>::iterator it = m_names.begin() + 1; it != m_names.end(); it++)
				{
					POS_TextOut((*it), false, true, 0);
					POS_FeedLine();
				}
			}

			//判断是否有备注
			if (order.m_memo.length() > 0)
			{
				POS_FeedLine();
				std::string address = CLewaimaiString::UnicodeToGBK(L"顾客备注：") + CLewaimaiString::UTF8ToGBK(order.m_memo);
				POS_TextOut(address, false, true, 0);
				POS_FeedLine();
			}

			//结束商品详情打印
			POS_TextOut(lines);
			POS_FeedLine();

			POS_TextOut(CLewaimaiString::UnicodeToGBK(L"该订单已被顾客取消，请停止出餐配送！！！"), true, true, 2);

			POS_FeedLine();
			POS_FeedLine();

			POS_FeedLine();
			POS_FeedLine();
			POS_FeedLine();
			POS_FeedLine();
			POS_FeedLine();

			POS_CutPaper();

			//还原打印机初始设置，有些傻逼收银设备居然不是自动调用，比如哗啦啦
			POS_Reset();
		}
		else
		{
			POS_Reset();

			//分单模式下，每个商品打印一张单
			for (std::vector<CWaimaiOrderItem>::iterator it = cur_printer_use.begin(); it != cur_printer_use.end(); it++)
			{
				if (it->is_taocan == true)
				{
					//套餐的名字，厨房打印不打印
					continue;
				}

				POS_TextOut(CLewaimaiString::UnicodeToGBK(L"外卖订单取消通知"), true, true, 1);
				POS_FeedLine();

				POS_FeedLine();

				std::string order_type = CLewaimaiString::UnicodeToGBK(L"#") + order.m_restaurant_number + CLewaimaiString::UnicodeToGBK(L"  ");

				if (order.m_is_selftake == "1")
				{
					POS_TextOut(order_type + CLewaimaiString::UnicodeToGBK(L"到店自取订单"), false, true, 1);
					POS_FeedLine();

					POS_FeedLine();
				}
				else
				{
					POS_TextOut(order_type + CLewaimaiString::UnicodeToGBK(L"外卖订单"), false, true, 1);
					POS_FeedLine();

					POS_FeedLine();
				}

				//预设选项
				if (order.m_order_field.size() > 1)
				{
					for (std::vector<CWaimaiOrderField>::iterator it = order.m_order_field.begin(); it != order.m_order_field.end() - 1; it++)
					{
						std::string order_field = CLewaimaiString::UTF8ToGBK((*it).name) + "：" + CLewaimaiString::UTF8ToGBK((*it).value);
						POS_TextOut(order_field, false, true, 0);
						POS_FeedLine();
					}
				}

				//准备开始打印商品详情
				std::string lines;

				if (guige == "58")
				{
					lines = CLewaimaiString::UnicodeToGBK(L"--------------------------------");
				}
				else
				{
					lines = CLewaimaiString::UnicodeToGBK(L"------------------------------------------------");
				}

				POS_TextOut(lines);
				POS_FeedLine();

				//商品标题
				if (guige == "58")
				{
					POS_TextOut(CLewaimaiString::UnicodeToGBK(L"商品           单价   数量  金额"), false, true);
				}
				else
				{
					POS_TextOut(CLewaimaiString::UnicodeToGBK(L"商品                         单价    数量   金额"), false, true);
				}

				POS_FeedLine();
				std::string food_name = (*it).m_food_name;
				std::string food_price = (*it).m_item_price;
				std::string quantity = (*it).m_quantity;
				//计算总价
				double item_price = atof(food_price.c_str()) * atof(quantity.c_str());
				std::string food_total_price = CLewaimaiString::DoubleToString(item_price, 2);
				food_name = CLewaimaiString::UTF8ToGBK(food_name);
				//先输出商品名字
				std::vector<std::string> m_names;

				if (guige == "58")
				{
					m_names = HandleFoodname(food_name, 1);
				}
				else
				{
					m_names = HandleFoodname(food_name, 2);
				}

				std::string firstLine = m_names[0];
				std::string priceShow = HandleFoodItemPrice(food_price, 2);
				std::string quantityShow = HandleFoodQuantity(quantity, 2);
				std::string priceTotalShow = HandleFoodTotalPrice(food_total_price, 2);
				std::string firstLineShow = firstLine + priceShow + quantityShow + priceTotalShow;
				POS_TextOut(firstLineShow, false, true, 0);
				POS_FeedLine();

				for (std::vector<std::string>::iterator it = m_names.begin() + 1; it != m_names.end(); it++)
				{
					POS_TextOut((*it), false, true, 0);
					POS_FeedLine();
				}

				//判断是否有备注
				if (order.m_memo.length() > 0)
				{
					POS_FeedLine();
					std::string address = CLewaimaiString::UnicodeToGBK(L"顾客备注：") + CLewaimaiString::UTF8ToGBK(order.m_memo);
					POS_TextOut(address, false, true, 0);
					POS_FeedLine();
				}

				//结束商品详情打印
				POS_TextOut(lines);
				POS_FeedLine();

				POS_TextOut(CLewaimaiString::UnicodeToGBK(L"该订单已被顾客取消，请停止出餐配送！！！"), true, true, 2);

				POS_FeedLine();
				POS_FeedLine();

				POS_FeedLine();
				POS_FeedLine();
				POS_FeedLine();
				POS_FeedLine();
				POS_FeedLine();

				POS_CutPaper();
			}

			//还原打印机初始设置，有些傻逼收银设备居然不是自动调用，比如哗啦啦
			POS_Reset();
		}

		ChufangPrinterContent newData;
		newData.ip = ip;
		newData.data = m_print_content;

		datas.push_back(newData);
	}

	return datas;
}

std::string CPosPrinterData::PrintDiandanOrderShouyin(CDiandanOrder& order)
{
	//读取当前收银打印机的设置
	std::string guige = CSetting::GetInstance()->GetParam("setting_printer_guige");
	std::string lianshu = CSetting::GetInstance()->GetParam("setting_printer_lianshu");
	int n_lianshu = atoi(lianshu.c_str());

	//正式开始打印
	for (int i = 0; i < n_lianshu; i++)
	{
		POS_Reset();

		//判断是否打印顶部logo
		if (CShopinfo::GetInstance()->m_machine_logo_open == "1")
		{
			std::wstring imagePath = CShopinfo::GetInstance()->GetImageTmpPathFromUrl(CShopinfo::GetInstance()->m_machine_logo_url);

			POS_OutBmp(imagePath);
			POS_FeedLine();
		}

		//打印店铺名字
		std::string shop_name = CLewaimaiString::UTF8ToGBK(order.shopname);
		POS_TextOut(shop_name, true, true, 1);

		POS_FeedLine();
		POS_FeedLine();

		if (CShopinfo::GetInstance()->m_version_type == "1")
		{
			//餐饮版才打印取餐号
			std::string date = CLewaimaiString::UnicodeToGBK(L"取餐号：") + CLewaimaiString::UTF8ToGBK(order.take_food_code);
			POS_TextOut(date, true, true, 1);
			POS_FeedLine();
		}

		POS_FeedLine();

		if (order.m_canpai.length() > 0)
		{
			std::string order_num = CLewaimaiString::UnicodeToGBK(L"餐牌/桌号：") + CLewaimaiString::UTF8ToGBK(order.m_canpai);
			POS_TextOut(order_num, false, false);
			POS_FeedLine();
		}

		//订单号
		bool setting_printer_dingdanhao_big = false;
		if (CSetting::GetInstance()->GetParam("setting_printer_dingdanhao_big") == "1")
		{
			setting_printer_dingdanhao_big = true;
		}

		std::string order_num = CLewaimaiString::UnicodeToGBK(L"订 单 号：") + CLewaimaiString::UTF8ToGBK(order.show_trade_no);
		POS_TextOut(order_num, false, setting_printer_dingdanhao_big);
		POS_FeedLine();

		//订单来源
		if (order.order_from == 1)
		{
			std::string from_type = CLewaimaiString::UnicodeToGBK(L"订单来源：收银系统");
			POS_TextOut(from_type);
			POS_FeedLine();
		}
		else if (order.order_from == 2)
		{
			std::string from_type = CLewaimaiString::UnicodeToGBK(L"订单来源：商家app");
			POS_TextOut(from_type);
			POS_FeedLine();
		}
		else if (order.order_from == 3)
		{
			std::string from_type = CLewaimaiString::UnicodeToGBK(L"订单来源：扫码下单");
			POS_TextOut(from_type);
			POS_FeedLine();
		}

		//下单时间
		bool setting_printer_xiadanshijian_big = false;

		if (CSetting::GetInstance()->GetParam("setting_printer_xiadanshijian_big") == "1")
		{
			setting_printer_xiadanshijian_big = true;
		}

		std::string order_date = CLewaimaiString::UnicodeToGBK(L"下单时间：") + CLewaimaiString::UTF8ToGBK(order.init_time);
		POS_TextOut(order_date, false, setting_printer_xiadanshijian_big);
		POS_FeedLine();

		std::string shouyinyuan = CLewaimaiString::UnicodeToGBK(L"收银员：") + CLewaimaiString::UTF8ToGBK(CSetting::GetInstance()->getUsername());
		POS_TextOut(shouyinyuan, false, false);
		POS_FeedLine();

		//预设选项
		/*
		if (order.m_order_field.size() > 1)
		{
			for (std::vector<CWaimaiOrderField>::iterator it = order.m_order_field.begin(); it != order.m_order_field.end() - 1; it++)
			{
				std::string order_field = CLewaimaiString::UTF8ToGBK((*it).name) + "：" + CLewaimaiString::UTF8ToGBK((*it).value);
				POS_TextOut(order_field, false, false, 0);
				POS_FeedLine();
			}
		}
		}*/

		//准备开始打印商品详情
		std::string lines;

		if (guige == "58")
		{
			lines = CLewaimaiString::UnicodeToGBK(L"--------------------------------");
		}
		else
		{
			lines = CLewaimaiString::UnicodeToGBK(L"------------------------------------------------");
		}

		POS_TextOut(lines);
		POS_FeedLine();

		//商品标题
		bool setting_printer_shangpin_big = false;

		if (CSetting::GetInstance()->GetParam("setting_printer_shangpin_big") == "1")
		{
			setting_printer_shangpin_big = true;
		}

		if (guige == "58")
		{
			POS_TextOut(CLewaimaiString::UnicodeToGBK(L"商品           单价   数量  金额"), false, setting_printer_shangpin_big);
		}
		else
		{
			POS_TextOut(CLewaimaiString::UnicodeToGBK(L"商品                         单价    数量   金额"), false, setting_printer_shangpin_big);
		}

		POS_FeedLine();

		/*/
		if (order.m_manzeng_name.length() > 0)
		{
			CWaimaiOrderItem manzengItem;
			manzengItem.m_food_name = CLewaimaiString::GBKToUTF8(CLewaimaiString::UnicodeToGBK(L"【满赠】") + CLewaimaiString::UTF8ToGBK(order.m_manzeng_name));

			order.m_order_items.push_back(manzengItem);
		}
		*/

		//商品内容
		for (std::vector<CDiandanOrderItemPrint>::iterator it = order.m_items_print.begin(); it != order.m_items_print.end(); it++)
		{
			if (it->is_taocan_item == true)
			{
				//套餐的item，收银小票不打印
				continue;
			}

			std::string food_name = (*it).m_food_name;
			std::string food_price = (*it).m_item_price;
			std::string quantity = (*it).m_quantity;

			//计算总价
			double item_price = atof(food_price.c_str()) * atof(quantity.c_str());
			std::string food_total_price = CLewaimaiString::DoubleToString(item_price, 2);

			if (food_total_price == "0.00")
			{
				//这里是特殊处理满赠的展示
				food_total_price = "";
			}

			food_name = CLewaimaiString::UTF8ToGBK(food_name);

			//先输出商品名字
			std::vector<std::string> m_names;

			if (guige == "58")
			{
				m_names = HandleFoodname(food_name, 1);
			}
			else
			{
				m_names = HandleFoodname(food_name, 2);
			}

			std::string firstLine = m_names[0];
			int nGuige;

			if (guige == "58")
			{
				nGuige = 1;
			}
			else
			{
				nGuige = 2;
			}

			std::string priceShow = HandleFoodItemPrice(food_price, nGuige);
			std::string quantityShow = HandleFoodQuantity(quantity, nGuige);
			std::string priceTotalShow = HandleFoodTotalPrice(food_total_price, nGuige);
			std::string firstLineShow = firstLine + priceShow + quantityShow + priceTotalShow;

			POS_TextOut(firstLineShow, false, setting_printer_shangpin_big);
			POS_FeedLine();

			for (std::vector<std::string>::iterator it = m_names.begin() + 1; it != m_names.end(); it++)
			{
				POS_TextOut((*it), false, setting_printer_shangpin_big);
				POS_FeedLine();
			}
		}

		//判断是否有备注
		if (order.m_memo.length() > 0)
		{
			bool setting_printer_memo_big = false;

			if (CSetting::GetInstance()->GetParam("setting_printer_memo_big") == "1")
			{
				setting_printer_memo_big = true;
			}

			POS_FeedLine();
			std::string address = CLewaimaiString::UnicodeToGBK(L"整单备注：") + CLewaimaiString::UTF8ToGBK(order.m_memo);
			POS_TextOut(address, false, setting_printer_memo_big);
			POS_FeedLine();
		}

		//结束商品详情打印
		POS_TextOut(lines);
		POS_FeedLine();

		//开始打印其他的费用
		bool is_other_money = false;
		bool setting_printer_price_big = false;

		if (CSetting::GetInstance()->GetParam("setting_printer_price_big") == "1")
		{
			setting_printer_price_big = true;
		}

		if (atof(order.m_dabao_money.c_str()) > 0)
		{
			std::string dabao = CLewaimaiString::UnicodeToGBK(L"打包费：") + CLewaimaiString::UTF8ToGBK(order.m_dabao_money);
			POS_TextOut(dabao, false, setting_printer_price_big);
			POS_FeedLine();
			is_other_money = true;
		}

		//开始显示增值服务费
		/*
		if (order.m_addservie.size() > 0)
		{
			for (std::vector<CWaimaiOrderField>::iterator it = order.m_addservie.begin(); it != order.m_addservie.end(); it++)
			{
				string addservice = CLewaimaiString::UTF8ToGBK((*it).name) + CLewaimaiString::UnicodeToGBK(L"：") + CLewaimaiString::DoubleToString((double)atof((*it).value.c_str()), 2);
				POS_TextOut(addservice, false, setting_printer_price_big);
				POS_FeedLine();
				is_other_money = true;
			}

			is_other_money = true;
		}
		}*/

		if (atof(order.m_shangpinquan_youhui.c_str()) > 0)
		{
			std::string youhui = CLewaimaiString::UnicodeToGBK(L"商品券优惠：") + order.m_shangpinquan_youhui + CLewaimaiString::UnicodeToGBK(L"元");
			POS_TextOut(youhui, false, setting_printer_price_big);
			POS_FeedLine();
			is_other_money = true;
		}

		if (atof(order.m_cika_youhui.c_str()) > 0)
		{
			std::string youhui = CLewaimaiString::UnicodeToGBK(L"次卡优惠：") + order.m_cika_youhui + CLewaimaiString::UnicodeToGBK(L"元");
			POS_TextOut(youhui, false, setting_printer_price_big);
			POS_FeedLine();
			is_other_money = true;
		}

		if (atof(order.m_total_member_youhui.c_str()) > 0)
		{
			std::string youhui = CLewaimaiString::UnicodeToGBK(L"商品会员价优惠：") + order.m_total_member_youhui + CLewaimaiString::UnicodeToGBK(L"元");
			POS_TextOut(youhui, false, setting_printer_price_big);
			POS_FeedLine();
			is_other_money = true;
		}

		if (atof(order.m_zhekou_youhui.c_str()) > 0)
		{
			std::string youhui = CLewaimaiString::UnicodeToGBK(L"整单折扣优惠：") + order.m_zhekou_youhui + CLewaimaiString::UnicodeToGBK(L"元");
			POS_TextOut(youhui, false, setting_printer_price_big);
			POS_FeedLine();
			is_other_money = true;
		}

		if (atof(order.m_member_zhekou_youhui.c_str()) > 0)
		{
			std::string youhui = CLewaimaiString::UnicodeToGBK(L"会员整单折扣优惠：") + order.m_member_zhekou_youhui + CLewaimaiString::UnicodeToGBK(L"元");
			POS_TextOut(youhui, false, setting_printer_price_big);
			POS_FeedLine();
			is_other_money = true;
		}

		if (atof(order.m_quanyika_youhui.c_str()) > 0)
		{
			std::string youhui = CLewaimaiString::UnicodeToGBK(L"权益卡优惠：") + order.m_quanyika_youhui + CLewaimaiString::UnicodeToGBK(L"元");
			POS_TextOut(youhui, false, setting_printer_price_big);
			POS_FeedLine();
			is_other_money = true;
		}

		if (atof(order.m_manjian_youhui.c_str()) > 0)
		{
			std::string youhui = CLewaimaiString::UnicodeToGBK(L"满减优惠：") + order.m_manjian_youhui + CLewaimaiString::UnicodeToGBK(L"元");
			POS_TextOut(youhui, false, setting_printer_price_big);
			POS_FeedLine();
			is_other_money = true;
		}

		if (atof(order.m_youhuiquan_youhui.c_str()) > 0)
		{
			std::string youhui = CLewaimaiString::UnicodeToGBK(L"优惠券优惠：") + order.m_youhuiquan_youhui + CLewaimaiString::UnicodeToGBK(L"元");
			POS_TextOut(youhui, false, setting_printer_price_big);
			POS_FeedLine();
			is_other_money = true;
		}

		if (atof(order.m_rengong_youhui.c_str()) > 0)
		{
			std::string youhui = CLewaimaiString::UnicodeToGBK(L"人工优惠：") + order.m_rengong_youhui + CLewaimaiString::UnicodeToGBK(L"元");
			POS_TextOut(youhui, false, setting_printer_price_big);
			POS_FeedLine();
			is_other_money = true;
		}

		if (atof(order.m_moling_youhui.c_str()) > 0)
		{
			std::string youhui = CLewaimaiString::UnicodeToGBK(L"抹零优惠：") + order.m_moling_youhui + CLewaimaiString::UnicodeToGBK(L"元");
			POS_TextOut(youhui, false, setting_printer_price_big);
			POS_FeedLine();
			is_other_money = true;
		}

		if (is_other_money)
		{
			POS_TextOut(lines);
			POS_FeedLine();
		}

		//最后显示总价
		POS_TextOut(CLewaimaiString::UnicodeToGBK(L"总计：") + order.m_total_price + CLewaimaiString::UnicodeToGBK(L"元"), false, setting_printer_price_big, 2);
		POS_FeedLine();

		//显示付款方式
		bool setting_printer_pay_big = false;

		if (CSetting::GetInstance()->GetParam("setting_printer_pay_big") == "1")
		{
			setting_printer_pay_big = true;
		}

		POS_TextOut(CLewaimaiString::UnicodeToGBK(L"支付方式：") + CLewaimaiString::UTF8ToGBK(order.shoukuan_type), false, setting_printer_pay_big, 2);
		POS_FeedLine();

		if (order.shoukuan_type == CLewaimaiString::UnicodeToUTF8(L"会员支付"))
		{
			POS_TextOut(CLewaimaiString::UnicodeToGBK(L"会员余额：") + CLewaimaiString::UTF8ToGBK(order.balance), false, false, 2);
			POS_FeedLine();

			POS_TextOut(CLewaimaiString::UnicodeToGBK(L"会员编号：") + CLewaimaiString::UTF8ToGBK(order.member_number), false, false, 2);
			POS_FeedLine();
		}

		POS_FeedLine();
		POS_FeedLine();

		//是否打印底部二维码
		if (CShopinfo::GetInstance()->m_machine_qrcode_open == "1")
		{
			POS_OutQRCode(CLewaimaiString::UTF8ToGBK(CShopinfo::GetInstance()->m_machine_qrcode_url));
			POS_FeedLine();

			POS_TextOut(CLewaimaiString::UTF8ToGBK(CShopinfo::GetInstance()->m_machine_qrcode_title), false, false, 1);
			POS_FeedLine();
			POS_FeedLine();
		}

		if (CShopinfo::GetInstance()->m_self_defined_open == "1")
		{
			POS_TextOut(CLewaimaiString::UTF8ToGBK(CShopinfo::GetInstance()->m_self_defined_content1), false, false, 1);
			POS_FeedLine();
			POS_FeedLine();

			POS_TextOut(CLewaimaiString::UTF8ToGBK(CShopinfo::GetInstance()->m_self_defined_content2), false, false, 1);
			POS_FeedLine();
			POS_FeedLine();
		}

		//走纸几行再切
		POS_FeedLine();
		POS_FeedLine();
		POS_FeedLine();
		POS_FeedLine();
		POS_FeedLine();

		POS_CutPaper();
	}

	//还原打印机初始设置，有些傻逼收银设备居然不是自动调用，比如哗啦啦
	POS_Reset();

	return m_print_content;
}

std::string CPosPrinterData::PrintDiandanOrderBiaoqian(CDiandanOrder& order)
{
	std::string printer_usb = CSetting::GetInstance()->GetParam("setting_biaoqian_printer_usb");
	std::wstring ws_printer_usb = CLewaimaiString::UTF8ToUnicode(printer_usb);

	//读取标签纸的规格和方向
	int biaoqian_width, biaoqian_height;
	std::string printer_guige = CSetting::GetInstance()->GetParam("setting_biaoqian_printer_guige");
	if (printer_guige == "40*30mm")
	{
		biaoqian_width = 40;
		biaoqian_height = 30;
	}
	else  if (printer_guige == "35*25mm")
	{
		biaoqian_width = 35;
		biaoqian_height = 25;
	}
	else  if (printer_guige == "30*25mm")
	{
		biaoqian_width = 30;
		biaoqian_height = 25;
	}
	else  if (printer_guige == "30*20mm")
	{
		biaoqian_width = 30;
		biaoqian_height = 20;
	}
	else
	{
		biaoqian_width = 40;
		biaoqian_height = 30;
	}

	int nDIRECTION;
	std::string printer_fangxiang = CSetting::GetInstance()->GetParam("setting_biaoqian_printer_fangxiang");
	if (printer_fangxiang == "1")
	{
		nDIRECTION = 1;
	}
	else
	{
		nDIRECTION = 0;
	}

	//初始化标签打印机
	BIAOQIAN_Reset(biaoqian_width, biaoqian_height, nDIRECTION);

	std::vector<CDiandanOrderItemPrint> cur_printer_use;

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

	if (setting_biaoqian_printer_is_type == "0")
	{
		for (std::vector<CDiandanOrderItemPrint>::iterator it = order.m_items_print.begin(); it != order.m_items_print.end(); it++)
		{
			if (it->is_taocan_item == false)
			{
				//如果当前商品的分类，在厨房打印机设置的分类里面，才加入
				cur_printer_use.push_back(*it);
			}
		}
	}
	else
	{
		std::map<std::string, bool> ids_map;
		std::vector<std::string> ids = CLewaimaiString::Split(setting_biaoqian_printer_type_ids, ",");

		for (std::vector<std::string>::iterator it = ids.begin(); it != ids.end(); it++)
		{
			ids_map[(*it)] = true;
		}

		for (std::vector<CDiandanOrderItemPrint>::iterator it = order.m_items_print.begin(); it != order.m_items_print.end(); it++)
		{
			if (ids_map.find((*it).m_type_id) != ids_map.end() && it->is_taocan_item == false)
			{
				//如果当前商品的分类，在厨房打印机设置的分类里面，才加入
				cur_printer_use.push_back(*it);
			}
		}
	}

	//先计算商品的总数量
	int foodNum = 0;

	for (std::vector<CDiandanOrderItemPrint>::iterator it = cur_printer_use.begin(); it != cur_printer_use.end(); it++)
	{
		std::string quantity = (*it).m_quantity;

		foodNum += atoi(quantity.c_str());
	}

	//商品内容
	int curFoodNum = 0;

	for (std::vector<CDiandanOrderItemPrint>::iterator it = cur_printer_use.begin(); it != cur_printer_use.end(); it++)
	{
		std::string food_name = (*it).m_food_name;
		std::string food_price = (*it).m_item_price;
		std::string quantity = (*it).m_quantity;

		//每份商品打印一个标签
		int nQuantity = atoi(quantity.c_str());

		for (int i = 0; i < nQuantity; i++)
		{
			std::string textData = "";

			//纸张宽度40mm的，是 320个点位（每mm8个），刚好可以放13个汉字，每个汉字宽度差不多是24，商品换行显示的时候，
			//每行最多12个汉字，也就是空24个，因此这里设置12，刚好左右各空一半

			//打印订单号
			std::string order_num = CLewaimaiString::UnicodeToGBK(L"订单号：") + CLewaimaiString::UTF8ToGBK(order.show_trade_no);
			textData += BIAOQIAN_TEXTGet(order_num, 12, 6, 1, 1);

			//打印份数
			int nNumX;
			if (biaoqian_width == 30)
			{
				nNumX = 170;
			}
			else if (biaoqian_width == 35)
			{
				nNumX = 210;
			}
			else if (biaoqian_width == 40)
			{
				nNumX = 250;
			}
			else
			{
				nNumX = 250;
			}
			curFoodNum++;

			std::string numInfo = std::to_string(curFoodNum) + "/" + std::to_string(foodNum);
			textData += BIAOQIAN_TEXTGet(numInfo, nNumX, 6, 1, 1);

			//每行最多显示12个汉字，这里要计算一下换行（要先转成ANSI格式）
			std::string handle_food_name = CLewaimaiString::UTF8ToGBK(food_name);
			std::vector<std::string> foodNameVector = HandleBiaoqianFoodname(handle_food_name, biaoqian_width);

			int nRow = 0;

			//考虑是否用大号字体
			bool is_big_name = false;

			/*暂时全部打印小字，这里注释掉
			if(foodNameVector.size() <= 2)
			{
				//不超过2行，可以用大的字体
				is_big_name = true;
			}*/

			//LOG_INFO("foodNameVector size:" << foodNameVector.size());

			for (std::vector<std::string>::iterator it = foodNameVector.begin(); it != foodNameVector.end(); it++)
			{
				LOG_INFO("nRow:" << nRow << ", 准备打印商品名字：" << (*it).c_str());

				if (is_big_name)
				{
					textData += BIAOQIAN_TEXTGet(*it, 12, 42 + 60 * nRow, 1, 2);
				}
				else
				{
					textData += BIAOQIAN_TEXTGet(*it, 12, 42 + 30 * nRow, 1, 1);
				}

				nRow++;
			}

			int nQucanmaY = 42 + 30 * nRow + 10;

			//打印取餐码
			BIAOQIAN_BARCODEOUT(CLewaimaiString::UTF8ToGBK(order.take_food_code), 12, nQucanmaY);

			int nHeightNow;
			if (biaoqian_height <= 30)
			{
				nHeightNow = (biaoqian_height - 4) * 8;
			}
			else
			{
				nHeightNow = (30 - 4) * 8;
			}

			//std::string order_num_info = CLewaimaiString::UnicodeToGBK(L"取餐码：") + CLewaimaiString::UTF8ToGBK(order.take_food_code);
			//textData += BIAOQIAN_TEXTGet(order_num_info, 132, nQucanmaY + 15, 1, 1);

			//打印价格
			std::string priceInfo = CLewaimaiString::UTF8ToGBK(food_price) + CLewaimaiString::UnicodeToGBK(L"元");
			textData += BIAOQIAN_TEXTGet(priceInfo, 12, nHeightNow, 1, 1);

			WriteData(textData);

			BIAOQIAN_PRINT();

			BIAOQIAN_CLS();
		}
	}

	return m_print_content;
}

std::vector<ChufangPrinterContent> CPosPrinterData::PrintDiandanOrderChufang(CDiandanOrder& order)
{
	std::vector<ChufangPrinterContent> datas;

	//读取厨房打印机信息
	std::vector<ChufangPrinter> total_printers = CSetting::GetInstance()->getChufangPrints();

	for (std::vector<ChufangPrinter>::iterator it = total_printers.begin(); it != total_printers.end(); it++)
	{
		//清空每个厨房打印机的打印内容
		m_print_content = "";

		ChufangPrinter printer = *it;
		std::string ip = printer.ip;

		std::string guige = printer.guige;
		std::string fendan = printer.fendan;
		std::string fenlei = printer.fenlei;
		std::string fenlei_ids = printer.fenlei_ids;

		std::vector<CDiandanOrderItemPrint> cur_printer_use;
		if (fenlei == "0")
		{
			cur_printer_use = order.m_items_print;
		}
		else
		{
			//如果开启了分类打印，就要比对了
			std::map<std::string, bool> ids_map;
			std::vector<std::string> ids = CLewaimaiString::Split(fenlei_ids, ",");

			for (std::vector<std::string>::iterator it = ids.begin(); it != ids.end(); it++)
			{
				ids_map[(*it)] = true;
			}

			for (std::vector<CDiandanOrderItemPrint>::iterator it = order.m_items_print.begin(); it != order.m_items_print.end(); it++)
			{
				if (ids_map.find((*it).m_type_id) != ids_map.end())
				{
					//如果当前商品的分类，在厨房打印机设置的分类里面，才加入
					cur_printer_use.push_back(*it);
				}
			}
		}

		if (cur_printer_use.size() == 0)
		{
			//如果这个厨房打印机没有商品可以打印（开启了商品分类打印可能出现），就直接跳过
			continue;
		}

		if (fendan == "0")
		{
			POS_Reset();
			POS_TextOut(CLewaimaiString::UnicodeToGBK(L"派工单"), true, true, 1);
			POS_FeedLine();

			POS_FeedLine();

			std::string order_type = CLewaimaiString::UnicodeToGBK(L"订单号：") + order.show_trade_no;
			POS_TextOut(order_type, false, false, 0);
			POS_FeedLine();

			std::string take_food_code = CLewaimaiString::UnicodeToGBK(L"取餐号：") + order.take_food_code;
			POS_TextOut(take_food_code, false, false, 0);
			POS_FeedLine();

			if (order.m_canpai.length() > 0)
			{
				std::string order_num = CLewaimaiString::UnicodeToGBK(L"餐牌/桌号：") + CLewaimaiString::UTF8ToGBK(order.m_canpai);
				POS_TextOut(order_num, false, false, 0);
				POS_FeedLine();
			}

				std::string init_time = CLewaimaiString::UnicodeToGBK(L"下单时间：") + order.init_time;
			POS_TextOut(init_time, false, false, 0);
			POS_FeedLine();

			//预设选项
			/*
			if (order.m_order_field.size() > 1)
			{
				for (std::vector<CWaimaiOrderField>::iterator it = order.m_order_field.begin(); it != order.m_order_field.end() - 1; it++)
				{
					string order_field = CLewaimaiString::UTF8ToGBK((*it).name) + "：" + CLewaimaiString::UTF8ToGBK((*it).value);
					POS_TextOut(order_field, false, true, 0);
					POS_FeedLine();
				}
			}
			}*/

			//准备开始打印商品详情
			std::string lines;

			if (guige == "58")
			{
				lines = CLewaimaiString::UnicodeToGBK(L"--------------------------------");
			}
			else
			{
				lines = CLewaimaiString::UnicodeToGBK(L"------------------------------------------------");
			}

			POS_TextOut(lines);
			POS_FeedLine();

			//商品标题
			if (guige == "58")
			{
				POS_TextOut(CLewaimaiString::UnicodeToGBK(L"商品           单价   数量  金额"), false, true);
			}
			else
			{
				POS_TextOut(CLewaimaiString::UnicodeToGBK(L"商品                         单价    数量   金额"), false, true);
			}

			POS_FeedLine();

			//商品内容
			for (std::vector<CDiandanOrderItemPrint>::iterator it = cur_printer_use.begin(); it != cur_printer_use.end(); it++)
			{
				if (it->is_taocan == true)
				{
					//套餐的名字，厨房打印不打印
					continue;
				}

				std::string food_name = (*it).m_food_name;
				std::string food_price = (*it).m_item_price;
				std::string quantity = (*it).m_quantity;

				//计算总价
				double item_price = atof(food_price.c_str()) * atof(quantity.c_str());
				std::string food_total_price = CLewaimaiString::DoubleToString(item_price, 2);
				food_name = CLewaimaiString::UTF8ToGBK(food_name);
				//先输出商品名字
				std::vector<std::string> m_names;

				if (guige == "58")
				{
					m_names = HandleFoodname(food_name, 1);
				}
				else
				{
					m_names = HandleFoodname(food_name, 2);
				}

				std::string firstLine = m_names[0];
				int nGuige;

				if (guige == "58")
				{
					nGuige = 1;
				}
				else
				{
					nGuige = 2;
				}

				std::string priceShow = HandleFoodItemPrice(food_price, nGuige);
				std::string quantityShow = HandleFoodQuantity(quantity, nGuige);
				std::string priceTotalShow = HandleFoodTotalPrice(food_total_price, nGuige);
				std::string firstLineShow = firstLine + priceShow + quantityShow + priceTotalShow;
				POS_TextOut(firstLineShow, false, true, 0);
				POS_FeedLine();

				for (std::vector<std::string>::iterator it = m_names.begin() + 1; it != m_names.end(); it++)
				{
					POS_TextOut((*it), false, true, 0);
					POS_FeedLine();
				}
			}

			//判断是否有备注
			if (order.m_memo.length() > 0)
			{
			POS_FeedLine();
			std::string address = CLewaimaiString::UnicodeToGBK(L"整单备注：") + CLewaimaiString::UTF8ToGBK(order.m_memo);
			POS_TextOut(address, false, true, 0);
				POS_FeedLine();
			}

			//结束商品详情打印
			POS_TextOut(lines);
			POS_FeedLine();

			POS_FeedLine();
			POS_FeedLine();
			POS_FeedLine();
			POS_FeedLine();
			POS_FeedLine();

			POS_CutPaper();

			//还原打印机初始设置，有些傻逼收银设备居然不是自动调用，比如哗啦啦
			POS_Reset();
		}
		else
		{
			POS_Reset();

			//分单模式下，每个商品打印一张单
			for (std::vector<CDiandanOrderItemPrint>::iterator it = cur_printer_use.begin(); it != cur_printer_use.end(); it++)
			{
				if (it->is_taocan == true)
				{
					//套餐的名字，厨房打印不打印
					continue;
				}

				POS_TextOut(CLewaimaiString::UnicodeToGBK(L"派工单"), true, true, 1);
				POS_FeedLine();

				POS_FeedLine();

				std::string order_type = CLewaimaiString::UnicodeToGBK(L"订单号：") + order.show_trade_no + "  ";

				POS_TextOut(order_type, false, true, 1);
				POS_FeedLine();

				std::string take_food_code = CLewaimaiString::UnicodeToGBK(L"取餐号：") + order.take_food_code;
				POS_TextOut(take_food_code, false, false, 0);
				POS_FeedLine();

				if (order.m_canpai.length() > 0)
				{
					std::string order_num = CLewaimaiString::UnicodeToGBK(L"餐牌/桌号：") + CLewaimaiString::UTF8ToGBK(order.m_canpai);
					POS_TextOut(order_num, false, false, 0);
					POS_FeedLine();
				}

				std::string init_time = CLewaimaiString::UnicodeToGBK(L"下单时间：") + order.init_time;
				POS_TextOut(init_time, false, false, 0);
				POS_FeedLine();

				POS_FeedLine();

				//预设选项
				/*
				if (order.m_order_field.size() > 1)
				{
					for (std::vector<CWaimaiOrderField>::iterator it = order.m_order_field.begin(); it != order.m_order_field.end() - 1; it++)
					{
						string order_field = CLewaimaiString::UTF8ToGBK((*it).name) + "：" + CLewaimaiString::UTF8ToGBK((*it).value);
						POS_TextOut(order_field, false, true, 0);
						POS_FeedLine();
					}
				}
				}*/

				//准备开始打印商品详情
				std::string lines;

				if (guige == "58")
				{
					lines = CLewaimaiString::UnicodeToGBK(L"--------------------------------");
				}
				else
				{
					lines = CLewaimaiString::UnicodeToGBK(L"------------------------------------------------");
				}

				POS_TextOut(lines);
				POS_FeedLine();

				//商品标题
				if (guige == "58")
				{
					POS_TextOut(CLewaimaiString::UnicodeToGBK(L"商品           单价   数量  金额"), false, true);
				}
				else
				{
					POS_TextOut(CLewaimaiString::UnicodeToGBK(L"商品                         单价    数量   金额"), false, true);
				}

				POS_FeedLine();
				std::string food_name = (*it).m_food_name;
				std::string food_price = (*it).m_item_price;
				std::string quantity = (*it).m_quantity;
				//计算总价
				double item_price = atof(food_price.c_str()) * atof(quantity.c_str());
				std::string food_total_price = CLewaimaiString::DoubleToString(item_price, 2);
				food_name = CLewaimaiString::UTF8ToGBK(food_name);
				//先输出商品名字
				std::vector<std::string> m_names;

				if (guige == "58")
				{
					m_names = HandleFoodname(food_name, 1);
				}
				else
				{
					m_names = HandleFoodname(food_name, 2);
				}

				std::string firstLine = m_names[0];
				std::string priceShow = HandleFoodItemPrice(food_price, 2);
				std::string quantityShow = HandleFoodQuantity(quantity, 2);
				std::string priceTotalShow = HandleFoodTotalPrice(food_total_price, 2);
				std::string firstLineShow = firstLine + priceShow + quantityShow + priceTotalShow;
				POS_TextOut(firstLineShow, false, true, 0);
				POS_FeedLine();

				for (std::vector<std::string>::iterator it = m_names.begin() + 1; it != m_names.end(); it++)
				{
					POS_TextOut((*it), false, true, 0);
					POS_FeedLine();
				}

				//判断是否有备注
				if (order.m_memo.length() > 0)
				{
					POS_FeedLine();
					std::string address = CLewaimaiString::UnicodeToGBK(L"顾客备注：") + CLewaimaiString::UTF8ToGBK(order.m_memo);
					POS_TextOut(address, false, true, 0);
					POS_FeedLine();
				}

				//结束商品详情打印
				POS_TextOut(lines);
				POS_FeedLine();

				POS_FeedLine();
				POS_FeedLine();
				POS_FeedLine();
				POS_FeedLine();
				POS_FeedLine();

				POS_CutPaper();
			}

			//还原打印机初始设置，有些傻逼收银设备居然不是自动调用，比如哗啦啦
			POS_Reset();
		}

		ChufangPrinterContent newData;
		newData.ip = ip;
		newData.data = m_print_content;

		datas.push_back(newData);
	}

	return datas;
}

std::string CPosPrinterData::PrintZhengcanOrderXiadanShouyin(CZhengcanOrder& order)
{
	//读取当前收银打印机的设置
	std::string guige = CSetting::GetInstance()->GetParam("setting_printer_guige");
	std::string lianshu = CSetting::GetInstance()->GetParam("setting_printer_lianshu");
	int n_lianshu = atoi(lianshu.c_str());

	//正式开始打印
	for (int i = 0; i < n_lianshu; i++)
	{
		POS_Reset();

		//判断是否打印顶部logo
		if (CShopinfo::GetInstance()->m_machine_logo_open == "1")
		{
			std::wstring imagePath = CShopinfo::GetInstance()->GetImageTmpPathFromUrl(CShopinfo::GetInstance()->m_machine_logo_url);

			POS_OutBmp(imagePath);
			POS_FeedLine();
		}

		//打印店铺名字
		std::string shop_name = CLewaimaiString::UTF8ToGBK(order.shopname);
		POS_TextOut(shop_name, true, true, 1);

		POS_FeedLine();
		POS_FeedLine();

		//打印点菜单
		std::string diancaidan = CLewaimaiString::UnicodeToGBK(L"点菜单");
		POS_TextOut(diancaidan, false, false, 1);

		POS_FeedLine();
		POS_FeedLine();

		//打印桌位
		std::string date = CLewaimaiString::UnicodeToGBK(L"桌位：") + CLewaimaiString::UTF8ToGBK(order.table_name);
		POS_TextOut(date, true, true, 0);

		POS_FeedLine();
		POS_FeedLine();

		//订单号
		bool setting_printer_dingdanhao_big = false;
		if (CSetting::GetInstance()->GetParam("setting_printer_dingdanhao_big") == "1")
		{
			setting_printer_dingdanhao_big = true;
		}

		std::string order_num = CLewaimaiString::UnicodeToGBK(L"订 单 号：") + CLewaimaiString::UTF8ToGBK(order.show_trade_no);
		POS_TextOut(order_num, false, setting_printer_dingdanhao_big);
		POS_FeedLine();

		//订单来源
		if (order.order_from == 1)
		{
			std::string from_type = CLewaimaiString::UnicodeToGBK(L"订单来源：收银系统");
			POS_TextOut(from_type);
			POS_FeedLine();
		}
		else if (order.order_from == 2)
		{
			std::string from_type = CLewaimaiString::UnicodeToGBK(L"订单来源：商家app");
			POS_TextOut(from_type);
			POS_FeedLine();
		}
		else if (order.order_from == 3)
		{
			std::string from_type = CLewaimaiString::UnicodeToGBK(L"订单来源：扫码下单");
			POS_TextOut(from_type);
			POS_FeedLine();
		}

		//下单时间
		bool setting_printer_xiadanshijian_big = false;

		if (CSetting::GetInstance()->GetParam("setting_printer_xiadanshijian_big") == "1")
		{
			setting_printer_xiadanshijian_big = true;
		}

		std::string order_date = CLewaimaiString::UnicodeToGBK(L"下单时间：") + CLewaimaiString::UTF8ToGBK(CLewaimaiTime::DatetimeToString(time(NULL)));
		POS_TextOut(order_date, false, setting_printer_xiadanshijian_big);
		POS_FeedLine();
		std::string shouyinyuan = CLewaimaiString::UnicodeToGBK(L"收银员：") + CLewaimaiString::UTF8ToGBK(CSetting::GetInstance()->getUsername());
		POS_TextOut(shouyinyuan, false, false);
		POS_FeedLine();

		//准备开始打印商品详情
		std::string lines;

		if (guige == "58")
		{
			lines = CLewaimaiString::UnicodeToGBK(L"--------------------------------");
		}
		else
		{
			lines = CLewaimaiString::UnicodeToGBK(L"------------------------------------------------");
		}

		POS_TextOut(lines);
		POS_FeedLine();

		//商品标题
		bool setting_printer_shangpin_big = false;

		if (CSetting::GetInstance()->GetParam("setting_printer_shangpin_big") == "1")
		{
			setting_printer_shangpin_big = true;
		}

		if (guige == "58")
		{
			POS_TextOut(CLewaimaiString::UnicodeToGBK(L"商品           单价   数量  金额"), false, setting_printer_shangpin_big);
		}
		else
		{
			POS_TextOut(CLewaimaiString::UnicodeToGBK(L"商品                         单价    数量   金额"), false, setting_printer_shangpin_big);
		}

		POS_FeedLine();

		int n_fenshu = 0;

		//商品内容
		for (std::vector<CZhengcanOrderItemPrint>::iterator it = order.m_items_print.begin(); it != order.m_items_print.end(); it++)
		{
			if (it->is_taocan_item == true)
			{
				//套餐的item，收银小票不打印
				continue;
			}

			std::string food_name = (*it).m_food_name;
			std::string food_price = (*it).m_item_price;
			std::string quantity = (*it).m_quantity;

			if (atof(quantity.c_str()) - atoi(quantity.c_str()) > 0.00001)
			{
				//数量为小数，称重商品
				n_fenshu += 1;
			}
			else
			{
				n_fenshu += atoi(quantity.c_str());
			}

			//计算总价
			double item_price = atof(food_price.c_str()) * atof(quantity.c_str());
			std::string food_total_price = CLewaimaiString::DoubleToString(item_price, 2);

			if (food_total_price == "0.00")
			{
				//这里是特殊处理满赠的展示
				food_total_price = "";
			}

			food_name = CLewaimaiString::UTF8ToGBK(food_name);

			//先输出商品名字
			std::vector<std::string> m_names;

			if (guige == "58")
			{
				m_names = HandleFoodname(food_name, 1);
			}
			else
			{
				m_names = HandleFoodname(food_name, 2);
			}

			std::string firstLine = m_names[0];
			int nGuige;

			if (guige == "58")
			{
				nGuige = 1;
			}
			else
			{
				nGuige = 2;
			}

			std::string priceShow = HandleFoodItemPrice(food_price, nGuige);
			std::string quantityShow = HandleFoodQuantity(quantity, nGuige);
			std::string priceTotalShow = HandleFoodTotalPrice(food_total_price, nGuige);
			std::string firstLineShow = firstLine + priceShow + quantityShow + priceTotalShow;

			POS_TextOut(firstLineShow, false, setting_printer_shangpin_big);
			POS_FeedLine();

			for (std::vector<std::string>::iterator it = m_names.begin() + 1; it != m_names.end(); it++)
			{
				POS_TextOut((*it), false, setting_printer_shangpin_big);
				POS_FeedLine();
			}
		}

		//判断是否有备注
		if (order.m_memo.length() > 0)
		{
			bool setting_printer_memo_big = false;

			if (CSetting::GetInstance()->GetParam("setting_printer_memo_big") == "1")
			{
				setting_printer_memo_big = true;
			}

			POS_FeedLine();
			std::string address = CLewaimaiString::UnicodeToGBK(L"整单备注：") + CLewaimaiString::UTF8ToGBK(order.m_memo);
			POS_TextOut(address, false, setting_printer_memo_big);
			POS_FeedLine();
		}

		//结束商品详情打印
		POS_TextOut(lines);
		POS_FeedLine();

		
		POS_TextOut(CLewaimaiString::UnicodeToGBK(L"共：") + std::to_string(n_fenshu) + CLewaimaiString::UnicodeToGBK(L"份"), false, false, 2);
		POS_FeedLine();
		POS_FeedLine();

		//是否打印底部二维码
		if (CShopinfo::GetInstance()->m_machine_qrcode_open == "1")
		{
			POS_OutQRCode(CLewaimaiString::UTF8ToGBK(CShopinfo::GetInstance()->m_machine_qrcode_url));
			POS_FeedLine();

			POS_TextOut(CLewaimaiString::UTF8ToGBK(CShopinfo::GetInstance()->m_machine_qrcode_title), false, false, 1);
			POS_FeedLine();
			POS_FeedLine();
		}

		if (CShopinfo::GetInstance()->m_self_defined_open == "1")
		{
			POS_TextOut(CLewaimaiString::UTF8ToGBK(CShopinfo::GetInstance()->m_self_defined_content1), false, false, 1);
			POS_FeedLine();
			POS_FeedLine();

			POS_TextOut(CLewaimaiString::UTF8ToGBK(CShopinfo::GetInstance()->m_self_defined_content2), false, false, 1);
			POS_FeedLine();
			POS_FeedLine();
		}

		//走纸几行再切
		POS_FeedLine();
		POS_FeedLine();
		POS_FeedLine();
		POS_FeedLine();
		POS_FeedLine();

		POS_CutPaper();
	}

	//还原打印机初始设置，有些傻逼收银设备居然不是自动调用，比如哗啦啦
	POS_Reset();

	return m_print_content;
}

std::string CPosPrinterData::PrintZhengcanOrderXiadanBiaoqian(CZhengcanOrder& order)
{
	std::string printer_usb = CSetting::GetInstance()->GetParam("setting_biaoqian_printer_usb");
	std::wstring ws_printer_usb = CLewaimaiString::UTF8ToUnicode(printer_usb);

	//读取标签纸的规格和方向
	int biaoqian_width, biaoqian_height;
	std::string printer_guige = CSetting::GetInstance()->GetParam("setting_biaoqian_printer_guige");
	if (printer_guige == "40*30mm")
	{
		biaoqian_width = 40;
		biaoqian_height = 30;
	}
	else  if (printer_guige == "35*25mm")
	{
		biaoqian_width = 35;
		biaoqian_height = 25;
	}
	else  if (printer_guige == "30*25mm")
	{
		biaoqian_width = 30;
		biaoqian_height = 25;
	}
	else  if (printer_guige == "30*20mm")
	{
		biaoqian_width = 30;
		biaoqian_height = 20;
	}
	else
	{
		biaoqian_width = 40;
		biaoqian_height = 30;
	}

	int nDIRECTION;
	std::string printer_fangxiang = CSetting::GetInstance()->GetParam("setting_biaoqian_printer_fangxiang");
	if (printer_fangxiang == "1")
	{
		nDIRECTION = 1;
	}
	else
	{
		nDIRECTION = 0;
	}

	//初始化标签打印机
	BIAOQIAN_Reset(biaoqian_width, biaoqian_height, nDIRECTION);

	std::vector<CZhengcanOrderItemPrint> cur_printer_use;

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

	if (setting_biaoqian_printer_is_type == "0")
	{
		for (std::vector<CZhengcanOrderItemPrint>::iterator it = order.m_items_print.begin(); it != order.m_items_print.end(); it++)
		{
			if (it->is_taocan_item == false)
			{
				//如果当前商品的分类，在厨房打印机设置的分类里面，才加入
				cur_printer_use.push_back(*it);
			}
		}
	}
	else
	{
		std::map<std::string, bool> ids_map;
		std::vector<std::string> ids = CLewaimaiString::Split(setting_biaoqian_printer_type_ids, ",");

		for (std::vector<std::string>::iterator it = ids.begin(); it != ids.end(); it++)
		{
			ids_map[(*it)] = true;
		}

		for (std::vector<CZhengcanOrderItemPrint>::iterator it = order.m_items_print.begin(); it != order.m_items_print.end(); it++)
		{
			if (ids_map.find((*it).m_type_id) != ids_map.end() && it->is_taocan_item == false)
			{
				//如果当前商品的分类，在厨房打印机设置的分类里面，才加入
				cur_printer_use.push_back(*it);
			}
		}
	}

	//先计算商品的总数量
	int foodNum = 0;

	for (std::vector<CZhengcanOrderItemPrint>::iterator it = cur_printer_use.begin(); it != cur_printer_use.end(); it++)
	{
		std::string quantity = (*it).m_quantity;

		foodNum += atoi(quantity.c_str());
	}

	//商品内容
	int curFoodNum = 0;

	for (std::vector<CZhengcanOrderItemPrint>::iterator it = cur_printer_use.begin(); it != cur_printer_use.end(); it++)
	{
		std::string food_name = (*it).m_food_name;
		std::string food_price = (*it).m_item_price;
		std::string quantity = (*it).m_quantity;

		//每份商品打印一个标签
		int nQuantity = atoi(quantity.c_str());

		for (int i = 0; i < nQuantity; i++)
		{
			std::string textData = "";

			curFoodNum++;

			//打印桌号
			std::string zhuoweiInfo = CLewaimaiString::UTF8ToGBK(order.table_name);
			textData += BIAOQIAN_TEXTGet(zhuoweiInfo, 12, 6, 1, 1);

			//打印份数
			std::string numInfo = std::to_string(curFoodNum) + "/" + std::to_string(foodNum);
			textData += BIAOQIAN_TEXTGet(numInfo, 180, 6, 1, 1);

			//每行最多显示12个汉字，这里要计算一下换行（要先转成ANSI格式）
			std::string handle_food_name = CLewaimaiString::UTF8ToGBK(food_name);
			std::vector<std::string> foodNameVector = HandleBiaoqianFoodname(handle_food_name, biaoqian_width);

			int nRow = 0;

			//考虑是否用大号字体
			bool is_big_name = false;

			/*暂时全部打印小字，这里注释掉
			if(foodNameVector.size() <= 2)
			{
				//不超过2行，可以用大的字体
				is_big_name = true;
			}*/

			//LOG_INFO("foodNameVector size:" << foodNameVector.size());

			for (std::vector<std::string>::iterator it = foodNameVector.begin(); it != foodNameVector.end(); it++)
			{
				LOG_INFO("nRow:" << nRow << ", 准备打印商品名字：" << (*it).c_str());

				if (is_big_name)
				{
					textData += BIAOQIAN_TEXTGet(*it, 12, 42 + 60 * nRow, 1, 2);
				}
				else
				{
					textData += BIAOQIAN_TEXTGet(*it, 12, 42 + 30 * nRow, 1, 1);
				}

				nRow++;
			}

			int nPriceY;
			if (biaoqian_height == 30)
			{
				nPriceY = 180;
			}
			else if (biaoqian_height == 25)
			{
				nPriceY = 140;
			}
			else if (biaoqian_height == 20)
			{
				nPriceY = 100;
			}

			//打印价格
			std::string priceInfo = CLewaimaiString::UTF8ToGBK(food_price) + CLewaimaiString::UnicodeToGBK(L"元");
			textData += BIAOQIAN_TEXTGet(priceInfo, 12, nPriceY, 1, 1);

			//打印订单号
			std::string order_num = CLewaimaiString::UnicodeToGBK(L"订单号：") + CLewaimaiString::UTF8ToGBK(order.show_trade_no);
			textData += BIAOQIAN_TEXTGet(order_num, 12, nPriceY + 30, 1, 1);

			WriteData(textData);

			BIAOQIAN_PRINT();

			BIAOQIAN_CLS();
		}
	}

	return m_print_content;
}

std::vector<ChufangPrinterContent> CPosPrinterData::PrintZhengcanOrderXiadanChufang(CZhengcanOrder& order)
{
	std::vector<ChufangPrinterContent> datas;

	//读取厨房打印机信息
	std::vector<ChufangPrinter> total_printers = CSetting::GetInstance()->getChufangPrints();

	for (std::vector<ChufangPrinter>::iterator it = total_printers.begin(); it != total_printers.end(); it++)
	{
		//清空每个厨房打印机的打印内容
		m_print_content = "";

		ChufangPrinter printer = *it;
		std::string ip = printer.ip;

		std::string guige = printer.guige;
		std::string fendan = printer.fendan;
		std::string fenlei = printer.fenlei;
		std::string fenlei_ids = printer.fenlei_ids;

		std::vector<CZhengcanOrderItemPrint> cur_printer_use;
		if (fenlei == "0")
		{
			cur_printer_use = order.m_items_print;
		}
		else
		{
			//如果开启了分类打印，就要比对了
			std::map<std::string, bool> ids_map;
			std::vector<std::string> ids = CLewaimaiString::Split(fenlei_ids, ",");

			for (std::vector<std::string>::iterator it = ids.begin(); it != ids.end(); it++)
			{
				ids_map[(*it)] = true;
			}

			for (std::vector<CZhengcanOrderItemPrint>::iterator it = order.m_items_print.begin(); it != order.m_items_print.end(); it++)
			{
				if (ids_map.find((*it).m_type_id) != ids_map.end())
				{
					//如果当前商品的分类，在厨房打印机设置的分类里面，才加入
					cur_printer_use.push_back(*it);
				}
			}
		}

		if (cur_printer_use.size() == 0)
		{
			//如果这个厨房打印机没有商品可以打印（开启了商品分类打印可能出现），就直接跳过
			continue;
		}

		if (fendan == "0")
		{
			POS_Reset();
			POS_TextOut(CLewaimaiString::UnicodeToGBK(L"派工单"), true, true, 1);
			POS_FeedLine();

			POS_FeedLine();

			std::string table_name = CLewaimaiString::UnicodeToGBK(L"桌号：") + CLewaimaiString::UTF8ToGBK(order.table_name);
			POS_TextOut(table_name, true, true, 1);
			POS_FeedLine();

			std::string order_type = CLewaimaiString::UnicodeToGBK(L"订单号：") + order.show_trade_no;
			POS_TextOut(order_type, false, false, 0);
			POS_FeedLine();

			std::string init_time = CLewaimaiString::UnicodeToGBK(L"下单时间：") + CLewaimaiTime::DatetimeToString(time(NULL));
			POS_TextOut(init_time, false, false, 0);
			POS_FeedLine();

			//预设选项
			/*
			if (order.m_order_field.size() > 1)
			{
				for (std::vector<CWaimaiOrderField>::iterator it = order.m_order_field.begin(); it != order.m_order_field.end() - 1; it++)
				{
					string order_field = CLewaimaiString::UTF8ToGBK((*it).name) + "：" + CLewaimaiString::UTF8ToGBK((*it).value);
					POS_TextOut(order_field, false, true, 0);
					POS_FeedLine();
				}
			}
			}*/

			//准备开始打印商品详情
			std::string lines;

			if (guige == "58")
			{
		lines = CLewaimaiString::UnicodeToGBK(L"--------------------------------");
			}
			else
			{
		lines = CLewaimaiString::UnicodeToGBK(L"------------------------------------------------");
			}

			POS_TextOut(lines);
			POS_FeedLine();

			//商品标题
			if (guige == "58")
			{
				POS_TextOut(CLewaimaiString::UnicodeToGBK(L"商品           单价   数量  金额"), false, true);
			}
			else
			{
				POS_TextOut(CLewaimaiString::UnicodeToGBK(L"商品                         单价    数量   金额"), false, true);
			}

			POS_FeedLine();

			//商品内容
			for (std::vector<CZhengcanOrderItemPrint>::iterator it = cur_printer_use.begin(); it != cur_printer_use.end(); it++)
			{
				if (it->is_taocan == true)
				{
					//套餐的名字，厨房打印不打印
					continue;
				}

				std::string food_name = (*it).m_food_name;
				std::string food_price = (*it).m_item_price;
				std::string quantity = (*it).m_quantity;

				//计算总价
				double item_price = atof(food_price.c_str()) * atof(quantity.c_str());
				std::string food_total_price = CLewaimaiString::DoubleToString(item_price, 2);
				food_name = CLewaimaiString::UTF8ToGBK(food_name);
				//先输出商品名字
				std::vector<std::string> m_names;

				if (guige == "58")
				{
					m_names = HandleFoodname(food_name, 1);
				}
				else
				{
					m_names = HandleFoodname(food_name, 2);
				}

				std::string firstLine = m_names[0];
				int nGuige;

				if (guige == "58")
				{
					nGuige = 1;
				}
				else
				{
					nGuige = 2;
				}

				std::string priceShow = HandleFoodItemPrice(food_price, nGuige);
				std::string quantityShow = HandleFoodQuantity(quantity, nGuige);
				std::string priceTotalShow = HandleFoodTotalPrice(food_total_price, nGuige);
				std::string firstLineShow = firstLine + priceShow + quantityShow + priceTotalShow;
				POS_TextOut(firstLineShow, false, true, 0);
				POS_FeedLine();

				for (std::vector<std::string>::iterator it = m_names.begin() + 1; it != m_names.end(); it++)
				{
					POS_TextOut((*it), false, true, 0);
					POS_FeedLine();
				}
			}

			//判断是否有备注
			if (order.m_memo.length() > 0)
			{
			POS_FeedLine();
			std::string address = CLewaimaiString::UnicodeToGBK(L"整单备注：") + CLewaimaiString::UTF8ToGBK(order.m_memo);
			POS_TextOut(address, false, true, 0);
				POS_FeedLine();
			}

			//结束商品详情打印
			POS_TextOut(lines);
			POS_FeedLine();

			POS_FeedLine();
			POS_FeedLine();
			POS_FeedLine();
			POS_FeedLine();
			POS_FeedLine();

			POS_CutPaper();

			//还原打印机初始设置，有些傻逼收银设备居然不是自动调用，比如哗啦啦
			POS_Reset();
		}
		else
		{
			POS_Reset();

			//分单模式下，每个商品打印一张单
			for (std::vector<CZhengcanOrderItemPrint>::iterator it = cur_printer_use.begin(); it != cur_printer_use.end(); it++)
			{
				if (it->is_taocan == true)
				{
					//套餐的名字，厨房打印不打印
					continue;
				}

			POS_TextOut(CLewaimaiString::UnicodeToGBK(L"派工单"), true, true, 1);
				POS_FeedLine();

				POS_FeedLine();

				std::string table_name = CLewaimaiString::UnicodeToGBK(L"桌号：") + CLewaimaiString::UTF8ToGBK(order.table_name);
				POS_TextOut(table_name, true, true, 1);
				POS_FeedLine();

				std::string order_type = CLewaimaiString::UnicodeToGBK(L"订单号：") + order.show_trade_no + "  ";

				POS_TextOut(order_type, false, true, 1);
				POS_FeedLine();

				POS_FeedLine();

				//预设选项
				/*
				if (order.m_order_field.size() > 1)
				{
					for (std::vector<CWaimaiOrderField>::iterator it = order.m_order_field.begin(); it != order.m_order_field.end() - 1; it++)
					{
						string order_field = CLewaimaiString::UTF8ToGBK((*it).name) + "：" + CLewaimaiString::UTF8ToGBK((*it).value);
						POS_TextOut(order_field, false, true, 0);
						POS_FeedLine();
					}
				}
				}*/

				//准备开始打印商品详情
				std::string lines;

				if (guige == "58")
				{
					lines = CLewaimaiString::UnicodeToGBK(L"--------------------------------");
				}
				else
				{
					lines = CLewaimaiString::UnicodeToGBK(L"------------------------------------------------");
				}

				POS_TextOut(lines);
				POS_FeedLine();

				//商品标题
				if (guige == "58")
				{
					POS_TextOut(CLewaimaiString::UnicodeToGBK(L"商品           单价   数量  金额"), false, true);
				}
				else
				{
					POS_TextOut(CLewaimaiString::UnicodeToGBK(L"商品                         单价    数量   金额"), false, true);
				}

				POS_FeedLine();
				std::string food_name = (*it).m_food_name;
				std::string food_price = (*it).m_item_price;
				std::string quantity = (*it).m_quantity;
				//计算总价
				double item_price = atof(food_price.c_str()) * atof(quantity.c_str());
				std::string food_total_price = CLewaimaiString::DoubleToString(item_price, 2);
				food_name = CLewaimaiString::UTF8ToGBK(food_name);
				//先输出商品名字
				std::vector<std::string> m_names;

				if (guige == "58")
				{
					m_names = HandleFoodname(food_name, 1);
				}
				else
				{
					m_names = HandleFoodname(food_name, 2);
				}

				std::string firstLine = m_names[0];
				std::string priceShow = HandleFoodItemPrice(food_price, 2);
				std::string quantityShow = HandleFoodQuantity(quantity, 2);
				std::string priceTotalShow = HandleFoodTotalPrice(food_total_price, 2);
				std::string firstLineShow = firstLine + priceShow + quantityShow + priceTotalShow;
				POS_TextOut(firstLineShow, false, true, 0);
				POS_FeedLine();

				for (std::vector<std::string>::iterator it = m_names.begin() + 1; it != m_names.end(); it++)
				{
					POS_TextOut((*it), false, true, 0);
					POS_FeedLine();
				}

				//判断是否有备注
				if (order.m_memo.length() > 0)
				{
					POS_FeedLine();
					std::string address = CLewaimaiString::UnicodeToGBK(L"顾客备注：") + CLewaimaiString::UTF8ToGBK(order.m_memo);
					POS_TextOut(address, false, true, 0);
					POS_FeedLine();
				}

				//结束商品详情打印
				POS_TextOut(lines);
				POS_FeedLine();

				POS_FeedLine();
				POS_FeedLine();
				POS_FeedLine();
				POS_FeedLine();
				POS_FeedLine();

				POS_CutPaper();
			}

			//还原打印机初始设置，有些傻逼收银设备居然不是自动调用，比如哗啦啦
			POS_Reset();
		}

		ChufangPrinterContent newData;
		newData.ip = ip;
		newData.data = m_print_content;

		datas.push_back(newData);
	}

	return datas;
}

std::vector<ChufangPrinterContent> CPosPrinterData::PrintZhengcanOrderTuicaiChufang(CZhengcanOrder& order)
{
	std::vector<ChufangPrinterContent> datas;

	//读取厨房打印机信息
	std::vector<ChufangPrinter> total_printers = CSetting::GetInstance()->getChufangPrints();

	for (std::vector<ChufangPrinter>::iterator it = total_printers.begin(); it != total_printers.end(); it++)
	{
		//清空每个厨房打印机的打印内容
		m_print_content = "";

		ChufangPrinter printer = *it;
		std::string ip = printer.ip;

		std::string guige = printer.guige;
		std::string fendan = printer.fendan;
		std::string fenlei = printer.fenlei;
		std::string fenlei_ids = printer.fenlei_ids;

		std::vector<CZhengcanOrderItemPrint> cur_printer_use;
		if (fenlei == "0")
		{
			cur_printer_use = order.m_items_print;
		}
		else
		{
			//如果开启了分类打印，就要比对了
			std::map<std::string, bool> ids_map;
			std::vector<std::string> ids = CLewaimaiString::Split(fenlei_ids, ",");

			for (std::vector<std::string>::iterator it = ids.begin(); it != ids.end(); it++)
			{
				ids_map[(*it)] = true;
			}

			for (std::vector<CZhengcanOrderItemPrint>::iterator it = order.m_items_print.begin(); it != order.m_items_print.end(); it++)
			{
				if (ids_map.find((*it).m_type_id) != ids_map.end())
				{
					//如果当前商品的分类，在厨房打印机设置的分类里面，才加入
					cur_printer_use.push_back(*it);
				}
			}
		}

		if (cur_printer_use.size() == 0)
		{
			//如果这个厨房打印机没有商品可以打印（开启了商品分类打印可能出现），就直接跳过
			continue;
		}

		if (fendan == "0")
		{
			POS_Reset();
			POS_TextOut(CLewaimaiString::UnicodeToGBK(L"退菜单"), true, true, 1);
			POS_FeedLine();

			POS_FeedLine();

			std::string table_name = CLewaimaiString::UnicodeToGBK(L"桌号：") + CLewaimaiString::UTF8ToGBK(order.table_name);
			POS_TextOut(table_name, true, true, 1);
			POS_FeedLine();

			std::string order_type = CLewaimaiString::UnicodeToGBK(L"订单号：") + order.show_trade_no;
			POS_TextOut(order_type, false, false, 0);
			POS_FeedLine();

			std::string init_time = CLewaimaiString::UnicodeToGBK(L"退菜时间：") + CLewaimaiTime::DatetimeToString(time(NULL));
			POS_TextOut(init_time, false, false, 0);
			POS_FeedLine();

			//预设选项
			/*
			if (order.m_order_field.size() > 1)
			{
				for (std::vector<CWaimaiOrderField>::iterator it = order.m_order_field.begin(); it != order.m_order_field.end() - 1; it++)
				{
					string order_field = CLewaimaiString::UTF8ToGBK((*it).name) + "：" + CLewaimaiString::UTF8ToGBK((*it).value);
					POS_TextOut(order_field, false, true, 0);
					POS_FeedLine();
				}
			}
			}*/

			//准备开始打印商品详情
			std::string lines;

			if (guige == "58")
			{
				lines = CLewaimaiString::UnicodeToGBK(L"--------------------------------");
			}
			else
			{
				lines = CLewaimaiString::UnicodeToGBK(L"------------------------------------------------");
			}

			POS_TextOut(lines);
			POS_FeedLine();

			//商品标题
			if (guige == "58")
			{
				POS_TextOut(CLewaimaiString::UnicodeToGBK(L"商品           单价   数量  金额"), false, true);
			}
			else
			{
				POS_TextOut(CLewaimaiString::UnicodeToGBK(L"商品                         单价    数量   金额"), false, true);
			}

			POS_FeedLine();

			//商品内容
			for (std::vector<CZhengcanOrderItemPrint>::iterator it = cur_printer_use.begin(); it != cur_printer_use.end(); it++)
			{
				if (it->is_taocan == true)
				{
					//套餐的名字，厨房打印不打印
					continue;
				}

				std::string food_name = (*it).m_food_name;
				std::string food_price = (*it).m_item_price;
				std::string quantity = (*it).m_quantity;

				//计算总价
				double item_price = atof(food_price.c_str()) * atof(quantity.c_str());
				std::string food_total_price = CLewaimaiString::DoubleToString(item_price, 2);
				food_name = CLewaimaiString::UnicodeToGBK(L"【退菜】") + CLewaimaiString::UTF8ToGBK(food_name);

				//先输出商品名字
				std::vector<std::string> m_names;

				if (guige == "58")
				{
					m_names = HandleFoodname(food_name, 1);
				}
				else
				{
					m_names = HandleFoodname(food_name, 2);
				}

				std::string firstLine = m_names[0];
				int nGuige;

				if (guige == "58")
				{
					nGuige = 1;
				}
				else
				{
					nGuige = 2;
				}

				std::string priceShow = HandleFoodItemPrice(food_price, nGuige);
				std::string quantityShow = HandleFoodQuantity(quantity, nGuige);
				std::string priceTotalShow = HandleFoodTotalPrice(food_total_price, nGuige);
				std::string firstLineShow = firstLine + priceShow + quantityShow + priceTotalShow;
				POS_TextOut(firstLineShow, false, true, 0);
				POS_FeedLine();

				for (std::vector<std::string>::iterator it = m_names.begin() + 1; it != m_names.end(); it++)
				{
					POS_TextOut((*it), false, true, 0);
					POS_FeedLine();
				}
			}

			//判断是否有备注
			if (order.m_memo.length() > 0)
			{
				POS_FeedLine();
				std::string address = CLewaimaiString::UnicodeToGBK(L"整单备注：") + CLewaimaiString::UTF8ToGBK(order.m_memo);
				POS_TextOut(address, false, true, 0);
				POS_FeedLine();
			}

			//结束商品详情打印
			POS_TextOut(lines);
			POS_FeedLine();

			POS_FeedLine();
			POS_FeedLine();
			POS_FeedLine();
			POS_FeedLine();
			POS_FeedLine();

			POS_CutPaper();

			//还原打印机初始设置，有些傻逼收银设备居然不是自动调用，比如哗啦啦
			POS_Reset();
		}
		else
		{
			POS_Reset();

			//分单模式下，每个商品打印一张单
			for (std::vector<CZhengcanOrderItemPrint>::iterator it = cur_printer_use.begin(); it != cur_printer_use.end(); it++)
			{
				if (it->is_taocan == true)
				{
					//套餐的名字，厨房打印不打印
					continue;
				}

				POS_TextOut(CLewaimaiString::UnicodeToGBK(L"退菜单"), true, true, 1);
				POS_FeedLine();

				POS_FeedLine();

				std::string order_type = CLewaimaiString::UnicodeToGBK(L"订单号：") + order.show_trade_no + "  ";

				POS_TextOut(order_type, false, true, 1);
				POS_FeedLine();

				POS_FeedLine();

				//预设选项
				/*
				if (order.m_order_field.size() > 1)
				{
					for (std::vector<CWaimaiOrderField>::iterator it = order.m_order_field.begin(); it != order.m_order_field.end() - 1; it++)
					{
						string order_field = CLewaimaiString::UTF8ToGBK((*it).name) + "：" + CLewaimaiString::UTF8ToGBK((*it).value);
						POS_TextOut(order_field, false, true, 0);
						POS_FeedLine();
					}
				}
				}*/

				//准备开始打印商品详情
				std::string lines;

				if (guige == "58")
				{
					lines = CLewaimaiString::UnicodeToGBK(L"--------------------------------");
				}
				else
				{
					lines = CLewaimaiString::UnicodeToGBK(L"------------------------------------------------");
				}

				POS_TextOut(lines);
				POS_FeedLine();

				//商品标题
				if (guige == "58")
				{
					POS_TextOut(CLewaimaiString::UnicodeToGBK(L"商品           单价   数量  金额"), false, true);
				}
				else
				{
					POS_TextOut(CLewaimaiString::UnicodeToGBK(L"商品                         单价    数量   金额"), false, true);
				}

				POS_FeedLine();
				std::string food_name = (*it).m_food_name;
				std::string food_price = (*it).m_item_price;
				std::string quantity = (*it).m_quantity;
				//计算总价
				double item_price = atof(food_price.c_str()) * atof(quantity.c_str());
				std::string food_total_price = CLewaimaiString::DoubleToString(item_price, 2);
				food_name = CLewaimaiString::UTF8ToGBK(food_name);
				//先输出商品名字
				std::vector<std::string> m_names;

				if (guige == "58")
				{
					m_names = HandleFoodname(food_name, 1);
				}
				else
				{
					m_names = HandleFoodname(food_name, 2);
				}

				std::string firstLine = m_names[0];
				std::string priceShow = HandleFoodItemPrice(food_price, 2);
				std::string quantityShow = HandleFoodQuantity(quantity, 2);
				std::string priceTotalShow = HandleFoodTotalPrice(food_total_price, 2);
				std::string firstLineShow = firstLine + priceShow + quantityShow + priceTotalShow;
				POS_TextOut(firstLineShow, false, true, 0);
				POS_FeedLine();

				for (std::vector<std::string>::iterator it = m_names.begin() + 1; it != m_names.end(); it++)
				{
					POS_TextOut((*it), false, true, 0);
					POS_FeedLine();
				}

				//判断是否有备注
				if (order.m_memo.length() > 0)
				{
					POS_FeedLine();
					std::string address = CLewaimaiString::UnicodeToGBK(L"顾客备注：") + CLewaimaiString::UTF8ToGBK(order.m_memo);
					POS_TextOut(address, false, true, 0);
					POS_FeedLine();
				}

				//结束商品详情打印
				POS_TextOut(lines);
				POS_FeedLine();

				POS_FeedLine();
				POS_FeedLine();
				POS_FeedLine();
				POS_FeedLine();
				POS_FeedLine();

				POS_CutPaper();
			}

			//还原打印机初始设置，有些傻逼收银设备居然不是自动调用，比如哗啦啦
			POS_Reset();
		}

		ChufangPrinterContent newData;
		newData.ip = ip;
		newData.data = m_print_content;

		datas.push_back(newData);
	}

	return datas;
}

std::string CPosPrinterData::PrintZhengcanOrderYulanShouyin(CZhengcanOrder& order)
{
	//读取当前收银打印机的设置
	std::string guige = CSetting::GetInstance()->GetParam("setting_printer_guige");
	std::string lianshu = CSetting::GetInstance()->GetParam("setting_printer_lianshu");
	int n_lianshu = atoi(lianshu.c_str());

	//正式开始打印
	for (int i = 0; i < n_lianshu; i++)
	{
		POS_Reset();

		//判断是否打印顶部logo
		if (CShopinfo::GetInstance()->m_machine_logo_open == "1")
		{
			std::wstring imagePath = CShopinfo::GetInstance()->GetImageTmpPathFromUrl(CShopinfo::GetInstance()->m_machine_logo_url);

			POS_OutBmp(imagePath);
			POS_FeedLine();
		}

		//打印店铺名字
		std::string shop_name = CLewaimaiString::UTF8ToGBK(order.shopname);
		POS_TextOut(shop_name, true, true, 1);

		POS_FeedLine();
		POS_FeedLine();

		//打印点菜单
		std::string diancaidan = CLewaimaiString::UnicodeToGBK(L"预览单");
		POS_TextOut(diancaidan, false, false, 1);

		POS_FeedLine();
		POS_FeedLine();

		//打印桌位
		std::string date = CLewaimaiString::UnicodeToGBK(L"桌位：") + CLewaimaiString::UTF8ToGBK(order.table_name);
		POS_TextOut(date, true, true, 0);

		POS_FeedLine();
		POS_FeedLine();

		//订单号
		bool setting_printer_dingdanhao_big = false;
		if (CSetting::GetInstance()->GetParam("setting_printer_dingdanhao_big") == "1")
		{
			setting_printer_dingdanhao_big = true;
		}

		std::string order_num = CLewaimaiString::UnicodeToGBK(L"订 单 号：") + CLewaimaiString::UTF8ToGBK(order.show_trade_no);
		POS_TextOut(order_num, false, setting_printer_dingdanhao_big);
		POS_FeedLine();

		//订单来源
		if (order.order_from == 1)
		{
			std::string from_type = CLewaimaiString::UnicodeToGBK(L"订单来源：收银系统");
			POS_TextOut(from_type);
			POS_FeedLine();
		}
		else if (order.order_from == 2)
		{
			std::string from_type = CLewaimaiString::UnicodeToGBK(L"订单来源：商家app");
			POS_TextOut(from_type);
			POS_FeedLine();
		}
		else if (order.order_from == 3)
		{
			std::string from_type = CLewaimaiString::UnicodeToGBK(L"订单来源：扫码下单");
			POS_TextOut(from_type);
			POS_FeedLine();
		}

		//下单时间
		bool setting_printer_xiadanshijian_big = false;

		if (CSetting::GetInstance()->GetParam("setting_printer_xiadanshijian_big") == "1")
		{
			setting_printer_xiadanshijian_big = true;
		}

		std::string kaitai_date = CLewaimaiString::UnicodeToGBK(L"开台时间：") + CLewaimaiString::UTF8ToGBK(order.m_kaitai_time);
		POS_TextOut(kaitai_date, false, setting_printer_xiadanshijian_big);
		POS_FeedLine();
		std::string order_date = CLewaimaiString::UnicodeToGBK(L"打印时间：") + CLewaimaiString::UTF8ToGBK(CLewaimaiTime::DatetimeToString(time(NULL)));
		POS_TextOut(order_date, false, setting_printer_xiadanshijian_big);
		POS_FeedLine();
		std::string shouyinyuan = CLewaimaiString::UnicodeToGBK(L"收银员：") + CLewaimaiString::UTF8ToGBK(CSetting::GetInstance()->getUsername());
		POS_TextOut(shouyinyuan, false, false);
		POS_FeedLine();

		//准备开始打印商品详情
		std::string lines;

		if (guige == "58")
		{
			lines = CLewaimaiString::UnicodeToGBK(L"--------------------------------");
		}
		else
		{
			lines = CLewaimaiString::UnicodeToGBK(L"------------------------------------------------");
		}

		POS_TextOut(lines);
		POS_FeedLine();

		//商品标题
		bool setting_printer_shangpin_big = false;

		if (CSetting::GetInstance()->GetParam("setting_printer_shangpin_big") == "1")
		{
			setting_printer_shangpin_big = true;
		}

		if (guige == "58")
		{
			POS_TextOut(CLewaimaiString::UnicodeToGBK(L"商品           单价   数量  金额"), false, setting_printer_shangpin_big);
		}
		else
		{
			POS_TextOut(CLewaimaiString::UnicodeToGBK(L"商品                         单价    数量   金额"), false, setting_printer_shangpin_big);
		}

		POS_FeedLine();

		int n_fenshu = 0;

		//商品内容
		for (std::vector<CZhengcanOrderItemPrint>::iterator it = order.m_items_print.begin(); it != order.m_items_print.end(); it++)
		{
			if (it->is_taocan_item == true)
			{
				//套餐的item，收银小票不打印
				continue;
			}

			std::string food_name = (*it).m_food_name;
			std::string food_price = (*it).m_item_price;
			std::string quantity = (*it).m_quantity;

			if (atof(quantity.c_str()) - atoi(quantity.c_str()) > 0.00001)
			{
				//数量为小数，称重商品
				n_fenshu += 1;
			}
			else
			{
				n_fenshu += atoi(quantity.c_str());
			}

			//计算总价
			double item_price = atof(food_price.c_str()) * atof(quantity.c_str());
			std::string food_total_price = CLewaimaiString::DoubleToString(item_price, 2);

			if (food_total_price == "0.00")
			{
				//这里是特殊处理满赠的展示
				food_total_price = "";
			}

			food_name = CLewaimaiString::UTF8ToGBK(food_name);

			if (it->is_tuicai == true)
			{
				food_name = CLewaimaiString::UnicodeToGBK(L"【退菜】") + food_name;
			}

			//先输出商品名字
			std::vector<std::string> m_names;

			if (guige == "58")
			{
				m_names = HandleFoodname(food_name, 1);
			}
			else
			{
				m_names = HandleFoodname(food_name, 2);
			}

			std::string firstLine = m_names[0];
			int nGuige;

			if (guige == "58")
			{
				nGuige = 1;
			}
			else
			{
				nGuige = 2;
			}

			std::string priceShow = HandleFoodItemPrice(food_price, nGuige);
			std::string quantityShow = HandleFoodQuantity(quantity, nGuige);
			std::string priceTotalShow = HandleFoodTotalPrice(food_total_price, nGuige);
			std::string firstLineShow = firstLine + priceShow + quantityShow + priceTotalShow;

			POS_TextOut(firstLineShow, false, setting_printer_shangpin_big);
			POS_FeedLine();

			for (std::vector<std::string>::iterator it = m_names.begin() + 1; it != m_names.end(); it++)
			{
				POS_TextOut((*it), false, setting_printer_shangpin_big);
				POS_FeedLine();
			}
		}

		//判断是否有备注
		if (order.m_memo.length() > 0)
		{
			bool setting_printer_memo_big = false;

			if (CSetting::GetInstance()->GetParam("setting_printer_memo_big") == "1")
			{
				setting_printer_memo_big = true;
			}

			POS_FeedLine();
			std::string address = CLewaimaiString::UnicodeToGBK(L"整单备注：") + CLewaimaiString::UTF8ToGBK(order.m_memo);
			POS_TextOut(address, false, setting_printer_memo_big);
			POS_FeedLine();
		}

		//结束商品详情打印
		POS_TextOut(lines);
		POS_FeedLine();

		//开始打印其他的费用
		bool is_other_money = false;
		bool setting_printer_price_big = false;

		if (CSetting::GetInstance()->GetParam("setting_printer_price_big") == "1")
		{
			setting_printer_price_big = true;
		}

		if (atof(order.m_dabao_money.c_str()) > 0)
		{
			std::string dabao = CLewaimaiString::UnicodeToGBK(L"打包费：") + CLewaimaiString::UTF8ToGBK(order.m_dabao_money);
			POS_TextOut(dabao, false, setting_printer_price_big);
			POS_FeedLine();
			is_other_money = true;
		}

		if (atof(order.m_chawei_money.c_str()) > 0)
		{
			std::string dabao = CLewaimaiString::UnicodeToGBK(L"茶位费：") + CLewaimaiString::UTF8ToGBK(order.m_chawei_money);
			POS_TextOut(dabao, false, setting_printer_price_big);
			POS_FeedLine();
			is_other_money = true;
		}

		if (atof(order.m_kaitai_money.c_str()) > 0)
		{
			std::string dabao = CLewaimaiString::UnicodeToGBK(L"开台费：") + CLewaimaiString::UTF8ToGBK(order.m_kaitai_money);
			POS_TextOut(dabao, false, setting_printer_price_big);
			POS_FeedLine();
			is_other_money = true;
		}

		//开始显示增值服务费
		/*
		if (order.m_addservie.size() > 0)
		{
			for (std::vector<CWaimaiOrderField>::iterator it = order.m_addservie.begin(); it != order.m_addservie.end(); it++)
			{
				string addservice = CLewaimaiString::UTF8ToGBK((*it).name) + "：" + CLewaimaiString::DoubleToString((double)atof((*it).value.c_str()), 2);
				POS_TextOut(addservice, false, setting_printer_price_big);
				POS_FeedLine();
				is_other_money = true;
			}

			is_other_money = true;
		}
		}*/

		if (atof(order.m_shangpinquan_youhui.c_str()) > 0)
		{
			std::string youhui = CLewaimaiString::UnicodeToGBK(L"商品券优惠：") + order.m_shangpinquan_youhui + CLewaimaiString::UnicodeToGBK(L"元");
			POS_TextOut(youhui, false, setting_printer_price_big);
			POS_FeedLine();
			is_other_money = true;
		}

		if (atof(order.m_cika_youhui.c_str()) > 0)
		{
			std::string youhui = CLewaimaiString::UnicodeToGBK(L"次卡优惠：") + order.m_cika_youhui + CLewaimaiString::UnicodeToGBK(L"元");
			POS_TextOut(youhui, false, setting_printer_price_big);
			POS_FeedLine();
			is_other_money = true;
		}

		if (atof(order.m_total_member_youhui.c_str()) > 0)
		{
			std::string youhui = CLewaimaiString::UnicodeToGBK(L"商品会员价优惠：") + order.m_total_member_youhui + CLewaimaiString::UnicodeToGBK(L"元");
			POS_TextOut(youhui, false, setting_printer_price_big);
			POS_FeedLine();
			is_other_money = true;
		}

		if (atof(order.m_zhekou_youhui.c_str()) > 0)
		{
			std::string youhui = CLewaimaiString::UnicodeToGBK(L"整单折扣优惠：") + order.m_zhekou_youhui + CLewaimaiString::UnicodeToGBK(L"元");
			POS_TextOut(youhui, false, setting_printer_price_big);
			POS_FeedLine();
			is_other_money = true;
		}

		if (atof(order.m_member_zhekou_youhui.c_str()) > 0)
		{
			std::string youhui = CLewaimaiString::UnicodeToGBK(L"会员整单折扣优惠：") + order.m_member_zhekou_youhui + CLewaimaiString::UnicodeToGBK(L"元");
			POS_TextOut(youhui, false, setting_printer_price_big);
			POS_FeedLine();
			is_other_money = true;
		}

		if (atof(order.m_quanyika_youhui.c_str()) > 0)
		{
			std::string youhui = CLewaimaiString::UnicodeToGBK(L"权益卡优惠：") + order.m_quanyika_youhui + CLewaimaiString::UnicodeToGBK(L"元");
			POS_TextOut(youhui, false, setting_printer_price_big);
			POS_FeedLine();
			is_other_money = true;
		}

		if (atof(order.m_manjian_youhui.c_str()) > 0)
		{
			std::string youhui = CLewaimaiString::UnicodeToGBK(L"满减优惠：") + order.m_manjian_youhui + CLewaimaiString::UnicodeToGBK(L"元");
			POS_TextOut(youhui, false, setting_printer_price_big);
			POS_FeedLine();
			is_other_money = true;
		}

		if (atof(order.m_youhuiquan_youhui.c_str()) > 0)
		{
			std::string youhui = CLewaimaiString::UnicodeToGBK(L"优惠券优惠：") + order.m_youhuiquan_youhui + CLewaimaiString::UnicodeToGBK(L"元");
			POS_TextOut(youhui, false, setting_printer_price_big);
			POS_FeedLine();
			is_other_money = true;
		}

		if (atof(order.m_rengong_youhui.c_str()) > 0)
		{
			std::string youhui = CLewaimaiString::UnicodeToGBK(L"人工优惠：") + order.m_rengong_youhui + CLewaimaiString::UnicodeToGBK(L"元");
			POS_TextOut(youhui, false, setting_printer_price_big);
			POS_FeedLine();
			is_other_money = true;
		}

		if (atof(order.m_moling_youhui.c_str()) > 0)
		{
			std::string youhui = CLewaimaiString::UnicodeToGBK(L"抹零优惠：") + order.m_moling_youhui + CLewaimaiString::UnicodeToGBK(L"元");
			POS_TextOut(youhui, false, setting_printer_price_big);
			POS_FeedLine();
			is_other_money = true;
		}

		if (is_other_money)
		{
			POS_TextOut(lines);
			POS_FeedLine();
		}

		//最后显示总价
		POS_TextOut(CLewaimaiString::UnicodeToGBK(L"总计：") + order.m_total_price + CLewaimaiString::UnicodeToGBK(L"元"), false, setting_printer_price_big, 2);
		POS_FeedLine();

		POS_FeedLine();
		POS_FeedLine();

		//是否打印底部二维码
		if (CShopinfo::GetInstance()->m_machine_qrcode_open == "1")
		{
			POS_OutQRCode(CLewaimaiString::UTF8ToGBK(CShopinfo::GetInstance()->m_machine_qrcode_url));
			POS_FeedLine();

			POS_TextOut(CLewaimaiString::UTF8ToGBK(CShopinfo::GetInstance()->m_machine_qrcode_title), false, false, 1);
			POS_FeedLine();
			POS_FeedLine();
		}

		if (CShopinfo::GetInstance()->m_self_defined_open == "1")
		{
			POS_TextOut(CLewaimaiString::UTF8ToGBK(CShopinfo::GetInstance()->m_self_defined_content1), false, false, 1);
			POS_FeedLine();
			POS_FeedLine();

			POS_TextOut(CLewaimaiString::UTF8ToGBK(CShopinfo::GetInstance()->m_self_defined_content2), false, false, 1);
			POS_FeedLine();
			POS_FeedLine();
		}

		//走纸几行再切
		POS_FeedLine();
		POS_FeedLine();
		POS_FeedLine();
		POS_FeedLine();
		POS_FeedLine();

		POS_CutPaper();
	}

	//还原打印机初始设置，有些傻逼收银设备居然不是自动调用，比如哗啦啦
	POS_Reset();

	return m_print_content;
}

std::string CPosPrinterData::PrintZhengcanOrderJiesuanShouyin(CZhengcanOrder& order)
{
	//读取当前收银打印机的设置
	std::string guige = CSetting::GetInstance()->GetParam("setting_printer_guige");
	std::string lianshu = CSetting::GetInstance()->GetParam("setting_printer_lianshu");
	int n_lianshu = atoi(lianshu.c_str());

	//正式开始打印
	for (int i = 0; i < n_lianshu; i++)
	{
		POS_Reset();

		//判断是否打印顶部logo
		if (CShopinfo::GetInstance()->m_machine_logo_open == "1")
		{
			std::wstring imagePath = CShopinfo::GetInstance()->GetImageTmpPathFromUrl(CShopinfo::GetInstance()->m_machine_logo_url);

			POS_OutBmp(imagePath);
			POS_FeedLine();
		}

		//打印店铺名字
		std::string shop_name = CLewaimaiString::UTF8ToGBK(order.shopname);
		POS_TextOut(shop_name, true, true, 1);

		POS_FeedLine();
		POS_FeedLine();

		//打印点菜单
		std::string diancaidan = CLewaimaiString::UnicodeToGBK(L"结算单");
		POS_TextOut(diancaidan, false, false, 1);

		POS_FeedLine();
		POS_FeedLine();

		//打印桌位
		std::string date = CLewaimaiString::UnicodeToGBK(L"桌位：") + CLewaimaiString::UTF8ToGBK(order.table_name);
		POS_TextOut(date, true, true, 0);

		POS_FeedLine();
		POS_FeedLine();

		//订单号
		bool setting_printer_dingdanhao_big = false;
		if (CSetting::GetInstance()->GetParam("setting_printer_dingdanhao_big") == "1")
		{
			setting_printer_dingdanhao_big = true;
		}

		std::string order_num = CLewaimaiString::UnicodeToGBK(L"订 单 号：") + CLewaimaiString::UTF8ToGBK(order.show_trade_no);
		POS_TextOut(order_num, false, setting_printer_dingdanhao_big);
		POS_FeedLine();

		//订单来源
		if (order.order_from == 1)
		{
			std::string from_type = CLewaimaiString::UnicodeToGBK(L"订单来源：收银系统");
			POS_TextOut(from_type);
			POS_FeedLine();
		}
		else if (order.order_from == 2)
		{
			std::string from_type = CLewaimaiString::UnicodeToGBK(L"订单来源：商家app");
			POS_TextOut(from_type);
			POS_FeedLine();
		}
		else if (order.order_from == 3)
		{
			std::string from_type = CLewaimaiString::UnicodeToGBK(L"订单来源：扫码下单");
			POS_TextOut(from_type);
			POS_FeedLine();
		}

		//下单时间
		bool setting_printer_xiadanshijian_big = false;

		if (CSetting::GetInstance()->GetParam("setting_printer_xiadanshijian_big") == "1")
		{
			setting_printer_xiadanshijian_big = true;
		}

		std::string kaitai_date = CLewaimaiString::UnicodeToGBK(L"开台时间：") + CLewaimaiString::UTF8ToGBK(order.m_kaitai_time);
		POS_TextOut(kaitai_date, false, setting_printer_xiadanshijian_big);
		POS_FeedLine();
		std::string order_date = CLewaimaiString::UnicodeToGBK(L"结算时间：") + CLewaimaiString::UTF8ToGBK(CLewaimaiTime::DatetimeToString(time(NULL)));
		POS_TextOut(order_date, false, setting_printer_xiadanshijian_big);
		POS_FeedLine();
		std::string shouyinyuan = CLewaimaiString::UnicodeToGBK(L"收银员：") + CLewaimaiString::UTF8ToGBK(CSetting::GetInstance()->getUsername());
		POS_TextOut(shouyinyuan, false, false);
		POS_FeedLine();

		//准备开始打印商品详情
		std::string lines;

		if (guige == "58")
		{
			lines = CLewaimaiString::UnicodeToGBK(L"--------------------------------");
		}
		else
		{
			lines = CLewaimaiString::UnicodeToGBK(L"------------------------------------------------");
		}

		POS_TextOut(lines);
		POS_FeedLine();

		//商品标题
		bool setting_printer_shangpin_big = false;

		if (CSetting::GetInstance()->GetParam("setting_printer_shangpin_big") == "1")
		{
			setting_printer_shangpin_big = true;
		}

		if (guige == "58")
		{
			POS_TextOut(CLewaimaiString::UnicodeToGBK(L"商品           单价   数量  金额"), false, setting_printer_shangpin_big);
		}
		else
		{
			POS_TextOut(CLewaimaiString::UnicodeToGBK(L"商品                         单价    数量   金额"), false, setting_printer_shangpin_big);
		}

		POS_FeedLine();

		int n_fenshu = 0;

		//商品内容
		for (std::vector<CZhengcanOrderItemPrint>::iterator it = order.m_items_print.begin(); it != order.m_items_print.end(); it++)
		{
			if (it->is_taocan_item == true)
			{
				//套餐的item，收银小票不打印
				continue;
			}

			std::string food_name = (*it).m_food_name;
			std::string food_price = (*it).m_item_price;
			std::string quantity = (*it).m_quantity;

			if (atof(quantity.c_str()) - atoi(quantity.c_str()) > 0.00001)
			{
				//数量为小数，称重商品
				n_fenshu += 1;
			}
			else
			{
				n_fenshu += atoi(quantity.c_str());
			}

			//计算总价
			double item_price = atof(food_price.c_str()) * atof(quantity.c_str());
			std::string food_total_price = CLewaimaiString::DoubleToString(item_price, 2);

			if (food_total_price == "0.00")
			{
				//这里是特殊处理满赠的展示
				food_total_price = "";
			}

			food_name = CLewaimaiString::UTF8ToGBK(food_name);

			if (it->is_tuicai == true)
			{
				food_name = "【退菜】" + food_name;
			}

			//先输出商品名字
			std::vector<std::string> m_names;

			if (guige == "58")
			{
				m_names = HandleFoodname(food_name, 1);
			}
			else
			{
				m_names = HandleFoodname(food_name, 2);
			}

			std::string firstLine = m_names[0];
			int nGuige;

			if (guige == "58")
			{
				nGuige = 1;
			}
			else
			{
				nGuige = 2;
			}

			std::string priceShow = HandleFoodItemPrice(food_price, nGuige);
			std::string quantityShow = HandleFoodQuantity(quantity, nGuige);
			std::string priceTotalShow = HandleFoodTotalPrice(food_total_price, nGuige);
			std::string firstLineShow = firstLine + priceShow + quantityShow + priceTotalShow;

			POS_TextOut(firstLineShow, false, setting_printer_shangpin_big);
			POS_FeedLine();

			for (std::vector<std::string>::iterator it = m_names.begin() + 1; it != m_names.end(); it++)
			{
				POS_TextOut((*it), false, setting_printer_shangpin_big);
				POS_FeedLine();
			}
		}

		//判断是否有备注
		if (order.m_memo.length() > 0)
		{
			bool setting_printer_memo_big = false;

			if (CSetting::GetInstance()->GetParam("setting_printer_memo_big") == "1")
			{
				setting_printer_memo_big = true;
			}

			POS_FeedLine();
			std::string address = CLewaimaiString::UnicodeToGBK(L"整单备注：") + CLewaimaiString::UTF8ToGBK(order.m_memo);
			POS_TextOut(address, false, setting_printer_memo_big);
			POS_FeedLine();
		}

		//结束商品详情打印
		POS_TextOut(lines);
		POS_FeedLine();

		//开始打印其他的费用
		bool is_other_money = false;
		bool setting_printer_price_big = false;

		if (CSetting::GetInstance()->GetParam("setting_printer_price_big") == "1")
		{
			setting_printer_price_big = true;
		}

		if (atof(order.m_dabao_money.c_str()) > 0)
		{
			std::string dabao = CLewaimaiString::UnicodeToGBK(L"打包费：") + CLewaimaiString::UTF8ToGBK(order.m_dabao_money);
			POS_TextOut(dabao, false, setting_printer_price_big);
			POS_FeedLine();
			is_other_money = true;
		}

		if (atof(order.m_chawei_money.c_str()) > 0)
		{
			std::string dabao = CLewaimaiString::UnicodeToGBK(L"茶位费：") + CLewaimaiString::UTF8ToGBK(order.m_chawei_money);
			POS_TextOut(dabao, false, setting_printer_price_big);
			POS_FeedLine();
			is_other_money = true;
		}

		if (atof(order.m_kaitai_money.c_str()) > 0)
		{
			std::string dabao = CLewaimaiString::UnicodeToGBK(L"开台费：") + CLewaimaiString::UTF8ToGBK(order.m_kaitai_money);
			POS_TextOut(dabao, false, setting_printer_price_big);
			POS_FeedLine();
			is_other_money = true;
		}

		//开始显示增值服务费
		/*
		if (order.m_addservie.size() > 0)
		{
			for (std::vector<CWaimaiOrderField>::iterator it = order.m_addservie.begin(); it != order.m_addservie.end(); it++)
			{
				string addservice = CLewaimaiString::UTF8ToGBK((*it).name) + "：" + CLewaimaiString::DoubleToString((double)atof((*it).value.c_str()), 2);
				POS_TextOut(addservice, false, setting_printer_price_big);
				POS_FeedLine();
				is_other_money = true;
			}

			is_other_money = true;
		}
		}*/

		if (atof(order.m_shangpinquan_youhui.c_str()) > 0)
		{
			std::string youhui = CLewaimaiString::UnicodeToGBK(L"商品券优惠：") + order.m_shangpinquan_youhui + CLewaimaiString::UnicodeToGBK(L"元");
			POS_TextOut(youhui, false, setting_printer_price_big);
			POS_FeedLine();
			is_other_money = true;
		}

		if (atof(order.m_cika_youhui.c_str()) > 0)
		{
			std::string youhui = CLewaimaiString::UnicodeToGBK(L"次卡优惠：") + order.m_cika_youhui + CLewaimaiString::UnicodeToGBK(L"元");
			POS_TextOut(youhui, false, setting_printer_price_big);
			POS_FeedLine();
			is_other_money = true;
		}

		if (atof(order.m_total_member_youhui.c_str()) > 0)
		{
			std::string youhui = CLewaimaiString::UnicodeToGBK(L"商品会员价优惠：") + order.m_total_member_youhui + CLewaimaiString::UnicodeToGBK(L"元");
			POS_TextOut(youhui, false, setting_printer_price_big);
			POS_FeedLine();
			is_other_money = true;
		}

		if (atof(order.m_zhekou_youhui.c_str()) > 0)
		{
			std::string youhui = CLewaimaiString::UnicodeToGBK(L"整单折扣优惠：") + order.m_zhekou_youhui + CLewaimaiString::UnicodeToGBK(L"元");
			POS_TextOut(youhui, false, setting_printer_price_big);
			POS_FeedLine();
			is_other_money = true;
		}

		if (atof(order.m_member_zhekou_youhui.c_str()) > 0)
		{
			std::string youhui = CLewaimaiString::UnicodeToGBK(L"会员整单折扣优惠：") + order.m_member_zhekou_youhui + CLewaimaiString::UnicodeToGBK(L"元");
			POS_TextOut(youhui, false, setting_printer_price_big);
			POS_FeedLine();
			is_other_money = true;
		}

		if (atof(order.m_quanyika_youhui.c_str()) > 0)
		{
			std::string youhui = CLewaimaiString::UnicodeToGBK(L"权益卡优惠：") + order.m_quanyika_youhui + CLewaimaiString::UnicodeToGBK(L"元");
			POS_TextOut(youhui, false, setting_printer_price_big);
			POS_FeedLine();
			is_other_money = true;
		}

		if (atof(order.m_manjian_youhui.c_str()) > 0)
		{
			std::string youhui = CLewaimaiString::UnicodeToGBK(L"满减优惠：") + order.m_manjian_youhui + CLewaimaiString::UnicodeToGBK(L"元");
			POS_TextOut(youhui, false, setting_printer_price_big);
			POS_FeedLine();
			is_other_money = true;
		}

		if (atof(order.m_youhuiquan_youhui.c_str()) > 0)
		{
			std::string youhui = CLewaimaiString::UnicodeToGBK(L"优惠券优惠：") + order.m_youhuiquan_youhui + CLewaimaiString::UnicodeToGBK(L"元");
			POS_TextOut(youhui, false, setting_printer_price_big);
			POS_FeedLine();
			is_other_money = true;
		}

		if (atof(order.m_rengong_youhui.c_str()) > 0)
		{
			std::string youhui = CLewaimaiString::UnicodeToGBK(L"人工优惠：") + order.m_rengong_youhui + CLewaimaiString::UnicodeToGBK(L"元");
			POS_TextOut(youhui, false, setting_printer_price_big);
			POS_FeedLine();
			is_other_money = true;
		}

		if (atof(order.m_moling_youhui.c_str()) > 0)
		{
			std::string youhui = CLewaimaiString::UnicodeToGBK(L"抹零优惠：") + order.m_moling_youhui + CLewaimaiString::UnicodeToGBK(L"元");
			POS_TextOut(youhui, false, setting_printer_price_big);
			POS_FeedLine();
			is_other_money = true;
		}

		if (is_other_money)
		{
			POS_TextOut(lines);
			POS_FeedLine();
		}

		//最后显示总价
		POS_TextOut(CLewaimaiString::UnicodeToGBK(L"总计：") + order.m_total_price + CLewaimaiString::UnicodeToGBK(L"元"), false, setting_printer_price_big, 2);
		POS_FeedLine();

		//显示付款方式
		bool setting_printer_pay_big = false;

		if (CSetting::GetInstance()->GetParam("setting_printer_pay_big") == "1")
		{
			setting_printer_pay_big = true;
		}

		POS_TextOut(CLewaimaiString::UnicodeToGBK(L"支付方式：") + CLewaimaiString::UTF8ToGBK(order.shoukuan_type), false, setting_printer_pay_big, 2);
		POS_FeedLine();

		if (order.shoukuan_type == CLewaimaiString::UnicodeToUTF8(L"会员支付"))
		{
			POS_TextOut(CLewaimaiString::UnicodeToGBK(L"会员余额：") + CLewaimaiString::UTF8ToGBK(order.balance), false, false, 2);
			POS_FeedLine();

			POS_TextOut(CLewaimaiString::UnicodeToGBK(L"会员编号：") + CLewaimaiString::UTF8ToGBK(order.member_number), false, false, 2);
			POS_FeedLine();
		}

		POS_FeedLine();
		POS_FeedLine();

		//是否打印底部二维码
		if (CShopinfo::GetInstance()->m_machine_qrcode_open == "1")
		{
			POS_OutQRCode(CLewaimaiString::UTF8ToGBK(CShopinfo::GetInstance()->m_machine_qrcode_url));
			POS_FeedLine();

			POS_TextOut(CLewaimaiString::UTF8ToGBK(CShopinfo::GetInstance()->m_machine_qrcode_title), false, false, 1);
			POS_FeedLine();
			POS_FeedLine();
		}

		if (CShopinfo::GetInstance()->m_self_defined_open == "1")
		{
			POS_TextOut(CLewaimaiString::UTF8ToGBK(CShopinfo::GetInstance()->m_self_defined_content1), false, false, 1);
			POS_FeedLine();
			POS_FeedLine();

			POS_TextOut(CLewaimaiString::UTF8ToGBK(CShopinfo::GetInstance()->m_self_defined_content2), false, false, 1);
			POS_FeedLine();
			POS_FeedLine();
		}

		//走纸几行再切
		POS_FeedLine();
		POS_FeedLine();
		POS_FeedLine();
		POS_FeedLine();
		POS_FeedLine();

		POS_CutPaper();
	}

	//还原打印机初始设置，有些傻逼收银设备居然不是自动调用，比如哗啦啦
	POS_Reset();

	return m_print_content;
}

std::string CPosPrinterData::PrintShoukuanOrderShouyin(CShoukuanOrder& order)
{
	//读取当前收银打印机的设置
	std::string guige = CSetting::GetInstance()->GetParam("setting_printer_guige");
	std::string lianshu = CSetting::GetInstance()->GetParam("setting_printer_lianshu");
	int n_lianshu = atoi(lianshu.c_str());

	//正式开始打印
	for (int i = 0; i < n_lianshu; i++)
	{
		POS_Reset();

		//判断是否打印顶部logo
		if (CShopinfo::GetInstance()->m_machine_logo_open == "1")
		{
			std::wstring imagePath = CShopinfo::GetInstance()->GetImageTmpPathFromUrl(CShopinfo::GetInstance()->m_machine_logo_url);

			POS_OutBmp(imagePath);
			POS_FeedLine();
		}

		//打印店铺名字
		std::string shop_name = CLewaimaiString::UTF8ToGBK(order.shopname);
		POS_TextOut(shop_name, true, true, 1);

		POS_FeedLine();

		POS_TextOut(CLewaimaiString::UnicodeToGBK(L"收款结算小票"), false, false, 1);

		POS_FeedLine();
		POS_FeedLine();

		//订单号
		bool setting_printer_dingdanhao_big = false;
		if (CSetting::GetInstance()->GetParam("setting_printer_dingdanhao_big") == "1")
		{
			setting_printer_dingdanhao_big = true;
		}

		std::string order_num = CLewaimaiString::UnicodeToGBK(L"订 单 号：") + CLewaimaiString::UTF8ToGBK(order.show_trade_no);
		POS_TextOut(order_num, false, setting_printer_dingdanhao_big);
		POS_FeedLine();

		//订单来源
		if (order.order_from == 1)
		{
			std::string from_type = CLewaimaiString::UnicodeToGBK(L"订单来源：收银系统");
			POS_TextOut(from_type);
			POS_FeedLine();
		}
		else if (order.order_from == 2)
		{
			std::string from_type = CLewaimaiString::UnicodeToGBK(L"订单来源：商家app");
			POS_TextOut(from_type);
			POS_FeedLine();
		}
		else if (order.order_from == 3)
		{
			std::string from_type = CLewaimaiString::UnicodeToGBK(L"订单来源：刷脸app");
			POS_TextOut(from_type);
			POS_FeedLine();
		}
		else if (order.order_from == 4)
		{
			std::string from_type = CLewaimaiString::UnicodeToGBK(L"订单来源：收银台");
			POS_TextOut(from_type);
			POS_FeedLine();
		}

		//下单时间
		bool setting_printer_xiadanshijian_big = false;

		if (CSetting::GetInstance()->GetParam("setting_printer_xiadanshijian_big") == "1")
		{
			setting_printer_xiadanshijian_big = true;
		}

		std::string order_date = CLewaimaiString::UnicodeToGBK(L"下单时间：") + CLewaimaiString::UTF8ToGBK(order.init_time);
		POS_TextOut(order_date, false, setting_printer_xiadanshijian_big);
		POS_FeedLine();

		std::string shouyinyuan = CLewaimaiString::UnicodeToGBK(L"收银员：") + CLewaimaiString::UTF8ToGBK(order.employee_name);
		POS_TextOut(shouyinyuan, false, false);
		POS_FeedLine();

		POS_FeedLine();

		//最后显示总价
		POS_TextOut(CLewaimaiString::UnicodeToGBK(L"总计：") + order.m_money + CLewaimaiString::UnicodeToGBK(L"元"), false, false, 0);
		POS_FeedLine();

		//显示付款方式
		bool setting_printer_pay_big = false;

		if (CSetting::GetInstance()->GetParam("setting_printer_pay_big") == "1")
		{
			setting_printer_pay_big = true;
		}

		POS_TextOut(CLewaimaiString::UnicodeToGBK(L"支付方式：") + CLewaimaiString::UTF8ToGBK(order.shoukuan_type), false, setting_printer_pay_big, 0);
		POS_FeedLine();

		if (order.shoukuan_type == CLewaimaiString::UnicodeToUTF8(L"会员支付"))
		{
			POS_TextOut(CLewaimaiString::UnicodeToGBK(L"会员余额：") + CLewaimaiString::UTF8ToGBK(order.balance), false, false, 0);
			POS_FeedLine();

			POS_TextOut(CLewaimaiString::UnicodeToGBK(L"会员编号：") + CLewaimaiString::UTF8ToGBK(order.member_number), false, false, 0);
			POS_FeedLine();
		}

		POS_FeedLine();
		POS_FeedLine();

		//是否打印底部二维码
		if (CShopinfo::GetInstance()->m_machine_qrcode_open == "1")
		{
			POS_OutQRCode(CLewaimaiString::UTF8ToGBK(CShopinfo::GetInstance()->m_machine_qrcode_url));
			POS_FeedLine();

			POS_TextOut(CLewaimaiString::UTF8ToGBK(CShopinfo::GetInstance()->m_machine_qrcode_title), false, false, 1);
			POS_FeedLine();
			POS_FeedLine();
		}

		if (CShopinfo::GetInstance()->m_self_defined_open == "1")
		{
			POS_TextOut(CLewaimaiString::UTF8ToGBK(CShopinfo::GetInstance()->m_self_defined_content1), false, false, 1);
			POS_FeedLine();
			POS_FeedLine();

			POS_TextOut(CLewaimaiString::UTF8ToGBK(CShopinfo::GetInstance()->m_self_defined_content2), false, false, 1);
			POS_FeedLine();
			POS_FeedLine();
		}

		//走纸几行再切
		POS_FeedLine();
		POS_FeedLine();
		POS_FeedLine();
		POS_FeedLine();
		POS_FeedLine();

		POS_CutPaper();
	}

	//还原打印机初始设置，有些傻逼收银设备居然不是自动调用，比如哗啦啦
	POS_Reset();

	return m_print_content;
}

std::string CPosPrinterData::PrintJiaobanOrder(CJiaobaoOrder& order)
{
	//读取当前收银打印机的设置
	std::string guige = CSetting::GetInstance()->GetParam("setting_printer_guige");

	//正式开始打印
	POS_Reset();

	POS_TextOut(CLewaimaiString::UnicodeToGBK(L"交班单"), true, true, 1);

	POS_FeedLine();
	POS_FeedLine();

	POS_FeedLine();

	//打印店铺名字
	std::string shop_name = CLewaimaiString::UnicodeToGBK(L"店铺名字：") + CLewaimaiString::UTF8ToGBK(order.shopname);
	POS_TextOut(shop_name);
	POS_FeedLine();

	std::string jiaoban_zhanghao = CLewaimaiString::UnicodeToGBK(L"交班账号：") + CLewaimaiString::UTF8ToGBK(order.employee_name);
	POS_TextOut(jiaoban_zhanghao);
	POS_FeedLine();

	std::string init_time = CLewaimaiString::UnicodeToGBK(L"上班时间：") + CLewaimaiString::UTF8ToGBK(order.m_init_time);
	POS_TextOut(init_time);
	POS_FeedLine();

	std::string end_time = CLewaimaiString::UnicodeToGBK(L"下班时间：") + CLewaimaiString::UTF8ToGBK(order.m_end_time);
	POS_TextOut(end_time);
	POS_FeedLine();

	//准备开始打印商品详情
	std::string lines;

	if (guige == "58")
	{
		lines = CLewaimaiString::UnicodeToGBK(L"--------------------------------");
	}
	else
	{
		lines = CLewaimaiString::UnicodeToGBK(L"------------------------------------------------");
	}

	POS_TextOut(lines);
	POS_FeedLine();

	std::string m_huiyuan_num = CLewaimaiString::UnicodeToGBK(L"店内订单数量：") + CLewaimaiString::UTF8ToGBK(order.m_diannei_num);
	POS_TextOut(m_huiyuan_num, false, false);
	POS_FeedLine();

	std::string m_waimai_value = CLewaimaiString::UnicodeToGBK(L"店内营业额：") + CLewaimaiString::UTF8ToGBK(order.m_diannei_value);
	POS_TextOut(m_waimai_value, false, false);
	POS_FeedLine();

	POS_FeedLine();

	/*
	string m_diannei_value = "新增会员数量：" + CLewaimaiString::UTF8ToGBK(order.m_huiyuan_num);
	POS_TextOut(m_diannei_value, false, false);
	POS_FeedLine();

	string m_huiyuan_value = "会员储值金额：" + CLewaimaiString::UTF8ToGBK(order.m_huiyuan_value);
	POS_TextOut(m_huiyuan_value, false, false);
	POS_FeedLine();

	POS_FeedLine();
	*/

	std::string m_diannei_refund_member = CLewaimaiString::UnicodeToGBK(L"店内退款订单数：") + CLewaimaiString::UTF8ToGBK(order.m_diannei_refund_member);
	POS_TextOut(m_diannei_refund_member, false, false);
	POS_FeedLine();

	std::string m_diannei_refund_money = CLewaimaiString::UnicodeToGBK(L"店内退款订单金额：") + CLewaimaiString::UTF8ToGBK(order.m_diannei_refund_money);
	POS_TextOut(m_diannei_refund_money, false, false);
	POS_FeedLine();

	std::string m_diannei_discount_money = CLewaimaiString::UnicodeToGBK(L"店内订单优惠金额：") + CLewaimaiString::UTF8ToGBK(order.m_diannei_discount_money);
	POS_TextOut(m_diannei_discount_money, false, false);
	POS_FeedLine();

	POS_FeedLine();

	std::string m_diannei_xianjin_value = CLewaimaiString::UnicodeToGBK(L"店内订单现金收入：") + CLewaimaiString::UTF8ToGBK(order.m_diannei_xianjin_value);
	POS_TextOut(m_diannei_xianjin_value, false, false);
	POS_FeedLine();

	std::string m_diannei_xianjin_tuikuan = CLewaimaiString::UnicodeToGBK(L"店内订单现金退款：") + CLewaimaiString::UTF8ToGBK(order.m_diannei_xianjin_tuikuan);
	POS_TextOut(m_diannei_xianjin_tuikuan, false, false);
	POS_FeedLine();

	std::string m_diannei_xianjin_zengzhang = CLewaimaiString::UnicodeToGBK(L"现金净增长：") + CLewaimaiString::UTF8ToGBK(order.m_diannei_xianjin_zengzhang);
	POS_TextOut(m_diannei_xianjin_zengzhang, false, false);
	POS_FeedLine();

	//结束商品详情打印
	POS_TextOut(lines);
	POS_FeedLine();

	//最后显示总价
	POS_TextOut(CLewaimaiString::UnicodeToGBK(L"请确认以上数据是否准确，并在下面签名"), false, false, 0);
	POS_FeedLine();

	POS_FeedLine();
	POS_FeedLine();

	POS_TextOut(CLewaimaiString::UnicodeToGBK(L"签名：____________________"), false, false, 0);
	POS_FeedLine();

	POS_FeedLine();

	POS_FeedLine();;
	POS_FeedLine();

	//走纸几行再切
	POS_FeedLine();
	POS_FeedLine();
	POS_FeedLine();
	POS_FeedLine();
	POS_FeedLine();

	POS_CutPaper();

	//还原打印机初始设置，有些傻逼收银设备居然不是自动调用，比如哗啦啦
	POS_Reset();

	return m_print_content;
}

std::string CPosPrinterData::PrintHuiyuanchongzhiOrder(CHuiyuanchongzhiOrder& order)
{
	//读取当前收银打印机的设置
	std::string guige = CSetting::GetInstance()->GetParam("setting_printer_guige");

	//正式开始打印
	POS_Reset();

	POS_TextOut(CLewaimaiString::UTF8ToGBK(order.shopname), true, true, 1);

	POS_FeedLine();
	POS_FeedLine();

	POS_TextOut(CLewaimaiString::UnicodeToGBK(L"会员充值结算单"), false, false, 1);

	POS_FeedLine();
	POS_FeedLine();

	//打印店铺名字
	std::string show_trade_no = CLewaimaiString::UnicodeToGBK(L"订单号：") + CLewaimaiString::UTF8ToGBK(order.show_trade_no);
	POS_TextOut(show_trade_no);
	POS_FeedLine();

	std::string account = CLewaimaiString::UnicodeToGBK(L"收银账号：") + CLewaimaiString::UTF8ToGBK(order.account);
	POS_TextOut(account);
	POS_FeedLine();

	std::string init_time = CLewaimaiString::UnicodeToGBK(L"充值时间：") + CLewaimaiString::UTF8ToGBK(order.init_time);
	POS_TextOut(init_time);
	POS_FeedLine();

	//准备开始打印商品详情
	std::string lines;

	if (guige == "58")
	{
		lines = CLewaimaiString::UnicodeToGBK(L"--------------------------------");
	}
	else
	{
		lines = CLewaimaiString::UnicodeToGBK(L"------------------------------------------------");
	}

	POS_TextOut(lines);
	POS_FeedLine();

	std::string member_num = CLewaimaiString::UnicodeToGBK(L"会员卡号：") + CLewaimaiString::UTF8ToGBK(order.member_num);
	POS_TextOut(member_num, false, false);
	POS_FeedLine();

	std::string chongzhi_value = CLewaimaiString::UnicodeToGBK(L"充值金额：") + CLewaimaiString::UTF8ToGBK(order.chongzhi_value) + CLewaimaiString::UnicodeToGBK(L"元");
	POS_TextOut(chongzhi_value, false, false);
	POS_FeedLine();

	std::string zengsong_value = CLewaimaiString::UnicodeToGBK(L"赠送金额：") + CLewaimaiString::UTF8ToGBK(order.zengsong_value) + CLewaimaiString::UnicodeToGBK(L"元");
	POS_TextOut(zengsong_value, false, false);
	POS_FeedLine();

	std::string balance_before = CLewaimaiString::UnicodeToGBK(L"充值前余额：") + CLewaimaiString::UTF8ToGBK(order.balance_before) + CLewaimaiString::UnicodeToGBK(L"元");
	POS_TextOut(balance_before, false, false);
	POS_FeedLine();

	std::string balance_after = CLewaimaiString::UnicodeToGBK(L"充值后余额：") + CLewaimaiString::UTF8ToGBK(order.balance_after) + CLewaimaiString::UnicodeToGBK(L"元");
	POS_TextOut(balance_after, false, false);
	POS_FeedLine();

	//结束商品详情打印
	POS_TextOut(lines);
	POS_FeedLine();

	std::string pay_type = CLewaimaiString::UnicodeToGBK(L"支付方式：") + order.pay_type;
	POS_TextOut(pay_type, false, false, 2);
	POS_FeedLine();

	POS_FeedLine();

	POS_FeedLine();;
	POS_FeedLine();

	//走纸几行再切
	POS_FeedLine();
	POS_FeedLine();
	POS_FeedLine();
	POS_FeedLine();
	POS_FeedLine();

	POS_CutPaper();

	//还原打印机初始设置，有些傻逼收银设备居然不是自动调用，比如哗啦啦
	POS_Reset();

	return m_print_content;
}

std::string CPosPrinterData::PrintShangpintiaomaBiaoqian(CFood& foodinfo, std::string weight)
{
	std::string printer_usb = CSetting::GetInstance()->GetParam("setting_biaoqian_printer_usb");
	std::wstring ws_printer_usb = CLewaimaiString::UTF8ToUnicode(printer_usb);

	//读取标签纸的规格和方向
	int biaoqian_width, biaoqian_height;
	std::string printer_guige = CSetting::GetInstance()->GetParam("setting_biaoqian_printer_guige");
	if (printer_guige == "40*30mm")
	{
		biaoqian_width = 40;
		biaoqian_height = 30;
	}
	else  if (printer_guige == "35*25mm")
	{
		biaoqian_width = 35;
		biaoqian_height = 25;
	}
	else  if (printer_guige == "30*25mm")
	{
		biaoqian_width = 30;
		biaoqian_height = 25;
	}
	else  if (printer_guige == "30*20mm")
	{
		biaoqian_width = 30;
		biaoqian_height = 20;
	}
	else
	{
		biaoqian_width = 40;
		biaoqian_height = 30;
	}

	int nDIRECTION;
	std::string printer_fangxiang = CSetting::GetInstance()->GetParam("setting_biaoqian_printer_fangxiang");
	if (printer_fangxiang == "1")
	{
		nDIRECTION = 1;
	}
	else
	{
		nDIRECTION = 0;
	}

	//初始化标签打印机
	BIAOQIAN_Reset(biaoqian_width, biaoqian_height, nDIRECTION);

	std::string food_name = foodinfo.name;
	std::string food_price = foodinfo.price;
	std::string unit = foodinfo.unit;

	std::string textData = "";

	//每行最多显示12个汉字，这里要计算一下换行（要先转成ANSI格式）
	std::string handle_food_name = CLewaimaiString::UTF8ToGBK(food_name);
	std::vector<std::string> foodNameVector = HandleBiaoqianFoodname(handle_food_name, biaoqian_width);

	int nRow = 0;

	//考虑是否用大号字体
	bool is_big_name = false;

	for (std::vector<std::string>::iterator it = foodNameVector.begin(); it != foodNameVector.end(); it++)
	{
		LOG_INFO("nRow:" << nRow << ", 准备打印商品名字：" << (*it).c_str());

		if (is_big_name)
		{
			textData += BIAOQIAN_TEXTGet(*it, 0, 12 + 60 * nRow, 1, 2);
		}
		else
		{
			textData += BIAOQIAN_TEXTGet(*it, 0, 12 + 30 * nRow, 1, 1);
		}

		nRow++;
	}

	std::string barcode;
	if (foodinfo.is_weight == "1")
	{
		//按照13位【FFWWWWWNNNNNC】格式
		std::string weightString = CLewaimaiString::DoubleToString(atof(weight.c_str()) * 1000, 0);
		weightString = CLewaimaiString::BuZifuLeft(weightString, 5 - weightString.length(), '0');

		barcode = "21" + CLewaimaiString::BuZifuLeft(foodinfo.weight_plu_code, 5 - foodinfo.weight_plu_code.length(), '0') + weightString;

		std::string checkCode = CLewaimaiString::GetBarcodeCheckCode(barcode);

		barcode += checkCode;
	}
	else
	{
		barcode = foodinfo.barcode;
	}

	BIAOQIAN_BARCODEOUT(barcode, 0, 22 + 30 * nRow);

	int nPriceY;
	if (biaoqian_height == 30)
	{
		nPriceY = 160;
	}
	else if (biaoqian_height == 25)
	{
		nPriceY = 140;
	}
	else if (biaoqian_height == 20)
	{
		nPriceY = 100;
	}
	
	if (foodinfo.is_weight == "1")
	{
		//打印单价
		std::string priceInfo = CLewaimaiString::UnicodeToGBK(L"单价：");
		textData += BIAOQIAN_TEXTGet(priceInfo, 0, nPriceY, 1, 1);

		std::string priceShow = CLewaimaiString::UTF8ToGBK(food_price) + CLewaimaiString::UnicodeToGBK(L"元");
		textData += BIAOQIAN_TEXTGet(priceShow, 0, nPriceY + 30, 1, 1);
		

		//打印净重
		std::string weightInfo = CLewaimaiString::UnicodeToGBK(L"净重：");
		textData += BIAOQIAN_TEXTGet(weightInfo, 100, nPriceY, 1, 1);
		
		std::string weightShow = weight + CLewaimaiString::UnicodeToGBK(L"kg");
		textData += BIAOQIAN_TEXTGet(weightShow, 100, nPriceY + 30, 1, 1);

		//打印净重
		std::string zongjiaInfo = CLewaimaiString::UnicodeToGBK(L"总价：");
		textData += BIAOQIAN_TEXTGet(zongjiaInfo, 200, nPriceY, 1, 1);

		std::string zongjiaShow = CLewaimaiString::DoubleToString(atof(CLewaimaiString::UTF8ToGBK(food_price).c_str()) * atof(weight.c_str()), 2) + CLewaimaiString::UnicodeToGBK(L"元");
		textData += BIAOQIAN_TEXTGet(zongjiaShow, 200, nPriceY + 30, 1, 1);
	}
	else
	{
		//打印价格
		std::string priceInfo = CLewaimaiString::UnicodeToGBK(L"单价：") + CLewaimaiString::UTF8ToGBK(food_price) + CLewaimaiString::UnicodeToGBK(L"元");
		textData += BIAOQIAN_TEXTGet(priceInfo, 0, nPriceY, 1, 1);
	}
	

	WriteData(textData);

	BIAOQIAN_PRINT();

	BIAOQIAN_CLS();

	return m_print_content;
}

std::string CPosPrinterData::GetQianxiangCommand()
{
	POS_QIANXIANG();

	return m_print_content;
}

void CPosPrinterData::WriteData(std::string msg)
{
	m_print_content += msg;
}

/*
 *这个函数只负责把数据拼接到打印缓存里面，不负责实际的发送数据
 **/
void CPosPrinterData::WriteBuf(const unsigned char* buf, int len)
{
	for (int i = 0; i < len; i++)
	{
		m_print_content += buf[i];
	}
}

int CPosPrinterData::POS_Reset(void)
{
    unsigned char s[2] = {0x1B, 0x40};
    WriteBuf(s, 2);
    return 0;
}

int CPosPrinterData::POS_FeedLine(void)
{
    unsigned char s[1] = {0x0A};
    WriteBuf(s, 1);
    return 0;
}

int CPosPrinterData::POS_Feed(void)
{
    unsigned char s[3] = { 0x1B, 0x4A, 0x00 };
    WriteBuf(s, 3);
    return 0;
}

int CPosPrinterData::POS_SetMotionUnit(int x, int y)
{
	std::string s;
    s = "\x1D\x50\xB4\xB4";
    WriteData(s);

    s = "\x1B\x53";
    WriteData(s);

    return 0;
}

int CPosPrinterData::POS_SET_MOVE_X()
{
    unsigned char s2[6] = { 0x1B, 0x44, 0x0C, 0x0E, 0x17, 0x00};
    WriteBuf(s2, 6);

    return 0;
}

int CPosPrinterData::POS_MOVE_X()
{
    unsigned char s[1] = { 0x09 };
    WriteBuf(s, 1);

    return 0;
}

int CPosPrinterData::POS_SET_ABS_X(int x, int y)
{
    unsigned char cx = (unsigned char)(x);
    unsigned char cy = (unsigned char)(y);
    unsigned char s1[4] = { 0x1B, 0x24, cx, cy };

    WriteBuf(s1, 4);
    return 0;
}

int CPosPrinterData::POS_SET_PRINT_AREA(int x, int y)
{
    unsigned char cx = (unsigned char)(x);
    unsigned char cy = (unsigned char)(y);

    unsigned char s1[4] = { 0x1D, 0x57, cx, cy };

    WriteBuf(s1, 4);
    return 0;
}

/*
 *align_type：0 左对齐 1 居中对齐 2右对齐
 **/
int CPosPrinterData::POS_TextOut(std::string abc, bool is_double_width, bool is_double_height, int align_type)
{
    if(is_double_width && is_double_height)
    {
        unsigned char s1[3] = { 0x1B, 0x21, 0x30 };
        WriteBuf(s1, 3);

        unsigned char s2[3] = { 0x1C, 0x21, 0x0c };
        WriteBuf(s2, 3);
    }
    else if(is_double_width && !is_double_height)
    {
        unsigned char s1[3] = { 0x1B, 0x21, 0x20 };
        WriteBuf(s1, 3);
        unsigned char s2[3] = { 0x1C, 0x21, 0x04 };
        WriteBuf(s2, 3);
    }
    else if(!is_double_width && is_double_height)
    {
        unsigned char s1[3] = { 0x1B, 0x21, 0x10 };
        WriteBuf(s1, 3);
        unsigned char s2[3] = { 0x1C, 0x21, 0x08 };
        WriteBuf(s2, 3);
    }
    else
    {
        unsigned char s1[3] = { 0x1B, 0x21, 0x00 };
        WriteBuf(s1, 3);
        unsigned char s2[3] = { 0x1C, 0x57, 0x00 };
        WriteBuf(s2, 3);
    }

    if(align_type == 0)
    {
        unsigned char s1[3] = { 0x1B, 0x61, 0x00 };
        WriteBuf(s1, 3);
    }
    else if(align_type == 1)
    {
        unsigned char s1[3] = { 0x1B, 0x61, 0x01 };
        WriteBuf(s1, 3);
    }
    else if(align_type == 2)
    {
        unsigned char s1[3] = { 0x1B, 0x61, 0x02 };
        WriteBuf(s1, 3);
    }
    else
    {
    }

    WriteData(abc);
    return 0;
}

/*
 *打印机切纸，直接切不走纸
 **/
int CPosPrinterData::POS_CutPaper()
{
    unsigned char s[4] = { 0x1D, 0x56, 0x01};
    WriteBuf(s, 3);
    return 0;
}

/*
 *先转换成ANSI格式才能传进来
 **/
void CPosPrinterData::POS_OutQRCode(std::string dataString)
{
	QRcode * qrCode = nullptr;
	qrCode = QRcode_encodeString(dataString.c_str(), 0, QR_ECLEVEL_H, QR_MODE_8, 1);
	if (qrCode == nullptr)
	{
		printf("error occur\n");
		return ;
	}

	unsigned int unWidth = qrCode->width;
	unsigned int unWidthAdjusted = unWidth * 8;
	unsigned int unHeightAjusted = unWidthAdjusted;

	unsigned char* realData = new unsigned char[unWidthAdjusted * unHeightAjusted];
	memset(realData, 0, unWidthAdjusted * unHeightAjusted);

	unsigned char* pSourceData = qrCode->data;

	for (unsigned int i = 0; i < unHeightAjusted; i++)
	{
		int realHeight = i / 8;
		for (unsigned int j = 0; j < unWidthAdjusted; j++)
		{
			int realWeight = j / 8;
			if (pSourceData[unWidth * realHeight + realWeight] & 1)
			{
				//表示这个像素要打印
				realData[unWidthAdjusted * i + j] = 1;
			}
			else
			{
				realData[unWidthAdjusted * i + j] = 0;
			}
		}
	}

	//设置行间距为0
	unsigned char data[3] = { 0x1B, 0x33, 0x00 };
	WriteBuf(data, 3);

	//设置图像居中对齐
	unsigned char data2[3] = { 0x1B, 0x61, 0x01 };
	WriteBuf(data2, 3);

	//选择位图模式
	unsigned char escBmp[5] = { 0x1B, 0x2A, 0x21, 0x00, 0x00 };

	escBmp[3] = (unsigned char)(unWidthAdjusted % 256);
	escBmp[4] = (unsigned char)(unWidthAdjusted / 256);

	//换行符，每打印一行都要发送这个，不然有些尺寸下图片会乱掉
	unsigned char change_line_tag = '\n';

	//存储每行数据的结构
	unsigned char* dataTmp = new unsigned char[unWidthAdjusted * 3];

	//循环图片像素打印图片
	for (unsigned int i = 0; i < (unHeightAjusted / 24 + 1); i++)
	{
		//设置模式为位图模式
		WriteBuf(escBmp, 5);

		//重新开始打印一行，置零
		memset(dataTmp, 0, unWidthAdjusted * 3);

		//循环宽
		for (unsigned int j = 0; j < unWidthAdjusted; j++)
		{
			for (unsigned int k = 0; k < 24; k++)
			{
				//找到有像素的区域，也就是未超出位图高度的区域
				if (((i * 24) + k) < unHeightAjusted)
				{
					if (realData[unWidthAdjusted * (i * 24 + k) + j] == 1)
					{
						//如果本来是黑色的像素，那么就把对应的数据位设置为1
						dataTmp[j * 3 + k / 8] += (unsigned char)(128 >> (k % 8));
					}
				}
			}
		}

		WriteBuf(dataTmp, unWidthAdjusted * 3);

		//换行符，这里必须要发这个，不然图片会乱
		WriteBuf(&change_line_tag, 1);
	}

	WriteBuf(&change_line_tag, 1);

	//还原默认的行间距
	unsigned char data3[2] = { 0x1B, 0x32 };
	WriteBuf(data3, 2);

	delete[] dataTmp;

	QRcode_free(qrCode);

	delete[] realData;

	return ;
}

void CPosPrinterData::POS_OutBmp(std::wstring ImagePath)
{
	//初始化
	POS_Reset();

	//设置行间距为0
	unsigned char data[3] = { 0x1B, 0x33, 0x00 };
	WriteBuf(data, 3);

	//设置图像居中对齐
	unsigned char data2[3] = { 0x1B, 0x61, 0x01 };
	WriteBuf(data2, 3);

	CBitmapHelper helper;
	helper.LoadImage(ImagePath.c_str());

	Bitmap* bmp = helper.getBmp();

	//先进行图片预处理
	unsigned int nWidth = bmp->GetWidth();
	unsigned int nHeight = bmp->GetHeight();

	//压缩尺寸
	if (nWidth > 380)
	{
		int newWidth = 380;
		int newHeight = (int)(nHeight / (nWidth / 380.0));

		helper.ScaleBitmap(newWidth, newHeight);;

		nWidth = newWidth;
		nHeight = newHeight;
	}

	//二值化
	helper.Image2Values();

	//获得最新的图像指针
	bmp = helper.getBmp();

	//选择位图模式
	unsigned char escBmp[5] = { 0x1B, 0x2A, 0x21, 0x00, 0x00 };

	escBmp[3] = (unsigned char)(nWidth % 256);
	escBmp[4] = (unsigned char)(nWidth / 256);

	Gdiplus::Color pixelColor;

	//换行符，每打印一行都要发送这个，不然有些尺寸下图片会乱掉
	unsigned char change_line_tag = '\n';

	//存储每行数据的结构
	unsigned char* dataTmp = new unsigned char[nWidth * 3];

	//循环图片像素打印图片
	for (unsigned int i = 0; i < (nHeight / 24 + 1); i++)
	{
		//设置模式为位图模式
		WriteBuf(escBmp, 5);

		//重新开始打印一行，置零
		memset(dataTmp, 0, nWidth * 3);

		//循环宽
		for (unsigned int j = 0; j < nWidth; j++)
		{
			for (unsigned int k = 0; k < 24; k++)
			{
				//找到有像素的区域，也就是未超出位图高度的区域
				if (((i * 24) + k) < nHeight)
				{
					bmp->GetPixel(j, (i * 24) + k, &pixelColor);
					unsigned char r = pixelColor.GetR();

					if (r == 0)
					{
						//如果本来是黑色的像素，那么就把对应的数据位设置为1
						dataTmp[j * 3 + k / 8] += (unsigned char)(128 >> (k % 8));
					}
				}
			}
		}

		WriteBuf(dataTmp, nWidth * 3);

		//换行符，这里必须要发这个，不然图片会乱
		WriteBuf(&change_line_tag, 1);
	}

	WriteBuf(&change_line_tag, 1);

	//还原默认的行间距
	unsigned char data3[2] = { 0x1B, 0x32 };
	WriteBuf(data3, 2);

	delete[] dataTmp;
}

void CPosPrinterData::POS_QIANXIANG()
{
	unsigned char s[5] = { 0x1B, 0x70, 0x00, 0x80, 0x80 };
	WriteBuf(s, 5);
}

void CPosPrinterData::BIAOQIAN_Reset(int nWidth, int nHeight, int nDirection)
{
    char endTag[3] = {0x0d, 0x0a, 0x00};

    std::string size = "SIZE " + std::to_string(nWidth) + " mm," + std::to_string(nHeight) + " mm";
    size += endTag;

    std::string gap = "GAP 2 mm,0 mm";
    gap += endTag;

    std::string speed = "SPEED 4.0";
    speed += endTag;

    std::string density = "DENSITY 12";
    density += endTag;

	std::string DIRECTION = "DIRECTION " + std::to_string(nDirection);
	DIRECTION += endTag;

    std::string REFERENCE = "REFERENCE 0,0";
    REFERENCE += endTag;

    std::string PEER = "SET PEEL OFF";
    PEER += endTag;

    std::string TEAR = "SET TEAR ON";
    TEAR += endTag;

    std::string cls = "CLS";
    cls += endTag;

    std::string data = size + gap + speed + density + DIRECTION + REFERENCE + PEER + TEAR + cls;

    WriteData(data);
}

/*
 *前进一张纸
 **/
void CPosPrinterData::BIAOQIAN_FORMFEED()
{
    char endTag[3] = { 0x0d, 0x0a, 0x00 };

    std::string formfeed = "FORMFEED";
    formfeed += endTag;

    WriteData(formfeed);
}

void CPosPrinterData::BIAOQIAN_TEXTOUT(std::string content, int x, int y, int x_multiplication, int y_multiplication)
{
    char endTag[3] = { 0x0d, 0x0a, 0x00 };

	std::string text = "TEXT ";

    text += std::to_string(x) + "," + std::to_string(y) + ",";
    text += "\"TSS24.BF2\",";
    text += std::to_string(0) + ",";
    text += std::to_string(x_multiplication) + "," + std::to_string(y_multiplication) + ",";
    text += "\"" + content + "\"";
    text += endTag;

    WriteData(text);
}

void CPosPrinterData::BIAOQIAN_BARCODEOUT(std::string content, int x, int y)
{
	char endTag[3] = { 0x0d, 0x0a, 0x00 };

	std::string text = "BARCODE ";

	text += std::to_string(x) + "," + std::to_string(y) + ",";
	text += "\"128\",";
	text += std::to_string(48) + ",";
	text += std::to_string(1) + "," + std::to_string(0) + "," + std::to_string(2) + "," + std::to_string(2) + ",";
	text += "\"" + content + "\"";
	text += endTag;

	WriteData(text);
}

std::string CPosPrinterData::BIAOQIAN_TEXTGet(std::string content, int x, int y, int x_multiplication, int y_multiplication)
{
	char endTag[3] = { 0x0d, 0x0a, 0x00 };

	std::string text = "TEXT ";

	text += std::to_string(x) + "," + std::to_string(y) + ",";
	text += "\"TSS24.BF2\",";
	text += std::to_string(0) + ",";
	text += std::to_string(x_multiplication) + "," + std::to_string(y_multiplication) + ",";
	text += "\"" + content + "\"";
	text += endTag;

	return text;
}

void CPosPrinterData::BIAOQIAN_PRINT()
{
    char endTag[3] = { 0x0d, 0x0a, 0x00 };

    std::string print = "PRINT 1";
    print += endTag;

    WriteData(print);
}

void CPosPrinterData::BIAOQIAN_CLS()
{
    char endTag[3] = { 0x0d, 0x0a, 0x00 };

    std::string cls = "CLS";
    cls += endTag;

    WriteData(cls);
}

void CPosPrinterData::CalWord(std::string s, int& nHanzi, int& nZimu)
{
    nHanzi = 0;
    nZimu = 0;
    const char* buffer = s.c_str();

    while(*buffer != '\0')
    {
        if(!(*buffer >= 0 && *buffer <= 127))
        {
            //汉字
            buffer++;
            buffer++;
            nHanzi++;
        }
        else
        {
            //字母
            buffer++;
            nZimu++;
        }
    }
}

/*
 *规格 1：58mm 2:80mm
 *默认长度 58mm：12 80mm：25
 *58mm刚好能显示6个汉字每行
 **/
std::vector<std::string>CPosPrinterData::HandleFoodname(std::string oldname, int guige)
{
    std::vector<std::string> newnameArray;
    int nHanzi, nZimu;
    CalWord(oldname, nHanzi, nZimu);
    int nWidth = nHanzi * 2 + nZimu;
    int maxWidth;

    if(guige == 1)
    {
        maxWidth = 12;
    }
    else
    {
        maxWidth = 25;
    }

    if(nWidth <= maxWidth)
    {
        //对于nWidth补空格
        for(int i = 0; i < maxWidth - nWidth; i++)
        {
            oldname += " ";
        }

        newnameArray.push_back(oldname);
        return newnameArray;
    }

    //宽度大于15的情况，如果超过了，就要进行换行截取
    const char* s = oldname.c_str();
    int nTmp = 0;
    int nTotal = 0;

    while(*s != '\0')
    {
        if(!(*s >= 0 && *s <= 127))
        {
            //汉字的情况
            s++;
            nTmp++;
            nTotal++;

            s++;
            nTmp++;
            nTotal++;
        }
        else
        {
            //字母的情况
            s++;
            nTmp++;
            nTotal++;
        }

        if(nTmp == maxWidth)
        {
            //这里开始要换行了
			std::string newnameItem;
            newnameItem.assign(oldname, nTotal - nTmp, nTmp);
            newnameArray.push_back(newnameItem);
            nTmp = 0;
        }
        else if(nTmp == maxWidth - 1)
        {
            //如果是第14个了，判断下一个是不是中文，如果是的话也要换行
            if(!(*(s + 1) >= 0 && *(s + 1) <= 127))
            {
                //下一个是中文，也要换行了，补齐一个空格
				std::string newnameItem;
                newnameItem.assign(oldname, nTotal - nTmp, nTmp);
                newnameItem += " ";
                newnameArray.push_back(newnameItem);
                nTmp = 0;
            }
        }
    }

    if(nTmp > 0)
    {
        //处理分隔后的最后一行
		std::string newnameItem;
        newnameItem.assign(oldname, nTotal - nTmp, nTmp);

        for(int i = 0; i < maxWidth - nTmp; i++)
        {
            newnameItem += " ";
        }

        newnameArray.push_back(newnameItem);
    }

    return newnameArray;
}

//默认长度 58mm：7 80mm：8
std::string CPosPrinterData::HandleFoodItemPrice(std::string oldprice, int guige)
{
    double price = atof(oldprice.c_str());

    if(price < 10.00)
    {
        //单位数
        if(guige == 1)
        {
            return "   " + oldprice;
        }
        else
        {
            return "    " + oldprice;
        }
    }
    else if(price > 9.99 && price < 100.00)
    {
        //双位数
        if(guige == 1)
        {
            return "  " + oldprice;
        }
        else
        {
            return "   " + oldprice;
        }
    }
    else if(price > 99.99 && price < 1000.00)
    {
        //三位数
        if(guige == 1)
        {
            return " " + oldprice;
        }
        else
        {
            return "  " + oldprice;
        }
    }
    else
    {
        //四位数
        if(guige == 1)
        {
            return " " + oldprice;
        }
        else
        {
            return " " + oldprice;
        }
    }
}

//默认长度 58mm：6 80mm：7
std::string CPosPrinterData::HandleFoodQuantity(std::string oldquantity, int guige)
{
	size_t length = oldquantity.size();

	size_t kongge_num;
	if (guige == 1)
	{
		kongge_num = 6 - length;
	}
	else
	{
		kongge_num = 7 - length;
	}

	std::string newquantity = oldquantity;
	for (size_t i = 0; i < kongge_num; i++)
	{
		newquantity = " " + newquantity;
	}

	return newquantity;
}

//默认长度 58mm：7 80mm：8
std::string CPosPrinterData::HandleFoodTotalPrice(std::string oldprice, int guige)
{
    double price = atof(oldprice.c_str());

    if(price < 10.00)
    {
        //单位数
        if(guige == 1)
        {
            return "   " + oldprice;
        }
        else
        {
            return "    " + oldprice;
        }
    }
    else if(price > 9.99 && price < 100.00)
    {
        //双位数
        if(guige == 1)
        {
            return "  " + oldprice;
        }
        else
        {
            return "   " + oldprice;
        }
    }
    else if(price > 99.99 && price < 1000.00)
    {
        //三位数
        if(guige == 1)
        {
            return " " + oldprice;
        }
        else
        {
            return "  " + oldprice;
        }
    }
    else
    {
        //四位数
        if(guige == 1)
        {
            return " " + oldprice;
        }
        else
        {
            return " " + oldprice;
        }
    }
}

std::vector<std::string> CPosPrinterData::HandleBiaoqianFoodname(std::string oldname, int nBiaoqianWidth, bool is_name_big)
{
    std::vector<std::string> newnameArray;
    int nHanzi, nZimu;
    CalWord(oldname, nHanzi, nZimu);

	//文字内容的实际宽度，1个汉字算2个宽度，1个英文或者数字、标点算1个（40mm宽度最多打印12个汉字 ）
    int nWidth = nHanzi * 2 + nZimu;

	if (is_name_big == true)
	{
		nWidth = nWidth * 2;
	}

    //40 *30mmm的标签，宽度最大24
    int maxWidth;
	if (nBiaoqianWidth == 40)
	{
		maxWidth = 24;
	}
	else if (nBiaoqianWidth == 35)
	{
		maxWidth = 21;
	}
	else if (nBiaoqianWidth == 30)
	{
		maxWidth = 18;
	}
	else if (nBiaoqianWidth == 60)
	{
		maxWidth = 36;
	}
	else if (nBiaoqianWidth == 80)
	{
		maxWidth = 48;
	}
	else
	{
		maxWidth = 24;
	}

    if(nWidth <= maxWidth)
    {
        //对于nWidth补空格
		int nSpaceNum = 0;
		if (is_name_big == true)
		{
			nSpaceNum = (maxWidth - nWidth) / 2;
		}
		else
		{
			nSpaceNum = maxWidth - nWidth;
		}

        for(int i = 0; i < nSpaceNum; i++)
        {
            oldname += " ";
        }

        newnameArray.push_back(oldname);
        return newnameArray;
    }

    //宽度大于15的情况，如果超过了，就要进行换行截取
    const char* s = oldname.c_str();
    int nTmp = 0;
    int nTotal = 0;

    while(*s != '\0')
    {
        if(!(*s >= 0 && *s <= 127))
        {
            //汉字的情况
            s++;
            nTmp++;
            nTotal++;

            s++;
            nTmp++;
            nTotal++;
        }
        else
        {
            //字母的情况
            s++;
            nTmp++;
            nTotal++;
        }

		if (is_name_big == true)
		{
			if (nTmp * 2 == maxWidth)
			{
				//这里开始要换行了
				std::string newnameItem;
				newnameItem.assign(oldname, nTotal - nTmp, nTmp);
				newnameArray.push_back(newnameItem);
				nTmp = 0;
			}
			else if (nTmp * 2 == maxWidth - 2)
			{
				//判断下一个是不是中文，如果是的话也要换行
				if (!(*(s + 1) >= 0 && *(s + 1) <= 127))
				{
					//下一个是中文，也要换行了，补齐一个空格
					std::string newnameItem;
					newnameItem.assign(oldname, nTotal - nTmp, nTmp);
					newnameItem += " ";
					newnameArray.push_back(newnameItem);
					nTmp = 0;
				}
			}
		}
		else
		{
			if (nTmp == maxWidth)
			{
				//这里开始要换行了
				std::string newnameItem;
				newnameItem.assign(oldname, nTotal - nTmp, nTmp);
				newnameArray.push_back(newnameItem);
				nTmp = 0;
			}
			else if (nTmp == maxWidth - 1)
			{
				//判断下一个是不是中文，如果是的话也要换行
				if (!(*(s + 1) >= 0 && *(s + 1) <= 127))
				{
					//下一个是中文，也要换行了，补齐一个空格
					std::string newnameItem;
					newnameItem.assign(oldname, nTotal - nTmp, nTmp);
					newnameItem += " ";
					newnameArray.push_back(newnameItem);
					nTmp = 0;
				}
			}
		}
    }

	if(nTmp > 0)
	{
		//处理分隔后的最后一行
		std::string newnameItem;
		newnameItem.assign(oldname, nTotal - nTmp, nTmp);

		int nSpaceNum = 0;
		if (is_name_big == true)
		{
			nSpaceNum = (maxWidth - nTmp) / 2;
		}
		else
		{
			nSpaceNum = maxWidth - nTmp;
		}

        for(int i = 0; i < nSpaceNum; i++)
        {
            newnameItem += " ";
        }

        newnameArray.push_back(newnameItem);
    }

    return newnameArray;
}