/// <summary>
        /// 更新预览数据源(排序)
        /// </summary>
        public void UpdateOrdPrintDOsOrder()
        {
            if (LstOrdPrintDOsPreview == null)
            {
                return;
            }
            arryOrdPrintDOsPreview = LstOrdPrintDOsPreview.ToArray();
            List <DORowPrtFlags> lstDORowPrtFlags = new List <DORowPrtFlags>();

            for (int i = 0; i < arryOrdPrintDOsPreview.Length; i++)
            {
                DORowPrtFlags rowFlag    = new DORowPrtFlags();
                DORowPrtFlags rowFlagOrg = dicDORowPrtFlagsPreview[arryOrdPrintDOsPreview[i].Id_or];
                rowFlag.ForceAfterToNewPage = rowFlagOrg.ForceAfterToNewPage;
                rowFlag.ForceInOneGridRow   = rowFlagOrg.ForceInOneGridRow;
                rowFlag.MarkType            = rowFlagOrg.MarkType;
                rowFlag.InvalidPrtType      = rowFlagOrg.InvalidPrtType;
                rowFlag.IsDataRemedy        = rowFlagOrg.IsDataRemedy;
                lstDORowPrtFlags.Add(rowFlag);
            }
            prtDORowsAssistPreview = new PrtDORowsAssist(lstDORowPrtFlags);
        }
        /// <summary>
        /// 设置打印行的辅助属性,根据lastPrintDO,ordPrintDO判断是否需要强制换页打印
        /// </summary>
        /// <param name="lastPrintDO">上一条数据</param>
        /// <param name="ordPrintDO">当前数据</param>
        /// <param name="lastRowPrtFlags">上一条标记</param>
        /// <param name="doRowPrtFlags">当前参数</param>
        private void setRowPrtFlags(OrdPrintDO lastPrintDO, OrdPrintDO ordPrintDO, ref DORowPrtFlags lastRowPrtFlags, ref DORowPrtFlags doRowPrtFlags)
        {
            if (ordPrintDO != null)
            {
                doRowPrtFlags.IsDataRemedy   = (bool)ordPrintDO.Fg_chk_stop;
                doRowPrtFlags.InvalidPrtType = ordPrintDO.Fg_chk_canc == true ? DORowPrtFlags.ENumInvalidPrtType.TextWithDelLine : DORowPrtFlags.ENumInvalidPrtType.NotInvalid;
            }

            if (lastPrintDO != null)
            {
                // 如果跨科室需要重新打印
                if (cfgViewModel.IsUseNewDeptPage())
                {
                    // 科室不同,设置强制换页
                    if (lastPrintDO.Id_dep_nur != ordPrintDO.Id_dep_nur)
                    {
                        //强制下一条数据换页
                        lastRowPrtFlags.ForceAfterToNewPage = FBoolean.True;
                    }
                }
            }
        }
        /// <summary>
        /// 获取单页补打展现数据以及打印数据
        /// </summary>
        /// <param name="paramDTO"></param>
        /// <param name="detailDOAssist"></param>
        /// <returns></returns>
        private OrdPrintDO[] getPreviewSingleOrds(OrdPrintParamDTO paramDTO, out List <OrdPrintDO> ordPrintList, out List <DORowPrtFlags> rowFlagsList, out PrtDORowsAssist detailDOAssist)
        {
            //获取指定页码所有已打印的数据
            OrdPrintDO[] ordPrintDOsPrted = this.getPrtedOrdsByPage(paramDTO.Id_en, paramDTO.Fg_long, new List <int> {
                (int)paramDTO.Page_num
            });

            //获取指定页码需要补打作废线or停止时间的数据
            OrdPrintDataDTO[] ordPrintDataDTOsToPrt = getCancAndStopSingleOrds(paramDTO);

            // 需要打印作废标记or停止时间的医嘱集合
            Dictionary <string, OrdPrintDataDTO> ordPrintDataDTOsPrtedDic = new Dictionary <string, OrdPrintDataDTO>();

            foreach (OrdPrintDataDTO dataDTO in ordPrintDataDTOsToPrt)
            {
                if (!ordPrintDataDTOsPrtedDic.ContainsKey(dataDTO.Id_or))
                {
                    ordPrintDataDTOsPrtedDic.Add(dataDTO.Id_or, dataDTO);
                }
            }

            ordPrintList = new List <OrdPrintDO>();
            rowFlagsList = new List <DORowPrtFlags>();
            //设置标记参数
            List <DORowPrtFlags> rowFlagList = new List <DORowPrtFlags>();

            foreach (OrdPrintDO ordPrintDO in ordPrintDOsPrted)
            {
                DORowPrtFlags rowFlag = new DORowPrtFlags();
                rowFlag.AtPageIx       = (int)ordPrintDO.Page_num;
                rowFlag.AtGridRowIx    = (int)ordPrintDO.Row_num;
                rowFlag.TakeGridRowCnt = 0;//单页补打,所有数据都需要打印,行数设为0
                //rowFlag.TakeGridRowCnt = (int)ordPrintDO.Row_cnt;
                //rowFlag.ForceInOneGridRow = ordPrintDO.Fg_reformrow == FBoolean.True;// 重整标识行不换行
                if (ordPrintDO.Fg_reformrow == FBoolean.True)
                {
                    rowFlag.ForceInOneGridRow = true;                            // 重整标识行不换行
                    rowFlag.MarkType          = DORowPrtFlags.ENumMarkType.Text; //重整标记行内容标红
                }
                //根据作废打印标识Fg_canc_prn,判断是否打印过作废线,
                //打印过作废线的同时显示内容和作废线(黑)
                rowFlag.InvalidPrtType = ordPrintDO.Fg_canc_prn == true ? DORowPrtFlags.ENumInvalidPrtType.TextWithDelLine : DORowPrtFlags.ENumInvalidPrtType.NotInvalid;

                rowFlag.IsDataRemedy = (bool)ordPrintDO.Fg_stop_prn;
                //判断在已打印数据中,是否有需要补打作废线or停止时间
                if (ordPrintDO.Id_or != null && ordPrintDataDTOsPrtedDic.ContainsKey(ordPrintDO.Id_or))
                {
                    //需要补打停止时间的:停止时间、医生、护士
                    if (ordPrintDataDTOsPrtedDic[ordPrintDO.Id_or].Fg_chk_stop == true)
                    {
                        rowFlag.IsDataRemedy   = true;
                        ordPrintDO.Fg_chk_stop = FBoolean.True;                                           //停止标识
                        ordPrintDO.Fg_stop_prn = FBoolean.True;                                           //停止打印标识
                        this.setOrdPrintDatetime(ordPrintDataDTOsPrtedDic[ordPrintDO.Id_or], ordPrintDO); //设置停止时间
                    }
                    //需要补打作废线的:作废线(黑)、内容(黑)
                    if (ordPrintDataDTOsPrtedDic[ordPrintDO.Id_or].Fg_chk_canc == true)
                    {
                        ordPrintDO.Fg_chk_canc = FBoolean.True; //作废标识
                        ordPrintDO.Fg_canc_prn = FBoolean.True; //作废打印标识
                        rowFlag.InvalidPrtType = DORowPrtFlags.ENumInvalidPrtType.TextWithDelLine;
                    }

                    ordPrintList.Add(ordPrintDO);
                    rowFlagsList.Add(rowFlag);
                }

                rowFlagList.Add(rowFlag);
            }

            detailDOAssist = new PrtDORowsAssist(rowFlagList);

            return(ordPrintDOsPrted);
        }
        /// <summary>
        /// 整合需要显示的已打印数据、待打印数据(重整包括重整标记行),设置待打医嘱数据标志、以及待打印数据的打印参数
        /// </summary>
        /// <param name="ordPrintDOsPrted">已打印医嘱数据</param>
        /// <param name="ordPrintDataDTOsPrted">已打印医嘱数据中,需要补打作废线和停止时间的数据</param>
        /// <param name="ordPrintDataDTOsToPrt">待打印医嘱数据</param>
        /// <param name="rowFlagList">返回行标记参数</param>
        /// <param name="bReset">续打or重整</param>
        /// <returns></returns>
        private OrdPrintDO[] mergeOrdPrintDOsConAndRes(OrdPrintDO[] ordPrintDOsPrted, OrdPrintDataDTO[] ordPrintDataDTOsPrted, OrdPrintDataDTO[] ordPrintDataDTOsToPrt, ref List <DORowPrtFlags> rowFlagList, bool bReset)
        {
            //一般续打/重整整体数据集合
            List <OrdPrintDO> ordPrintDOsConAndResList = new List <OrdPrintDO>();

            #region 已打印数据
            // 已打印的最后一条数据
            OrdPrintDO ordPrintDOLast = null;
            // 科室/病区/床位更换前的最后一行医嘱的行标记参数
            DORowPrtFlags rowPrtFlagLast = null;
            // 如果已经存在打印数据,取最后一行,否则为空
            if (ordPrintDOsPrted != null && ordPrintDOsPrted.Length > 0)
            {
                ordPrintDOLast = ordPrintDOsPrted[ordPrintDOsPrted.Length - 1];
            }

            // 需要补打作废线or停止时间的医嘱字典(医嘱id_or为键)
            Dictionary <string, OrdPrintDataDTO> ordPrintDataDTOsPrtedDic = new Dictionary <string, OrdPrintDataDTO>();
            if (!bReset && ordPrintDataDTOsPrted != null && ordPrintDataDTOsPrted.Length > 0)
            {
                foreach (OrdPrintDataDTO dataDTO in ordPrintDataDTOsPrted)
                {
                    //排除重复id_or
                    if (!ordPrintDataDTOsPrtedDic.ContainsKey(dataDTO.Id_or))
                    {
                        ordPrintDataDTOsPrtedDic.Add(dataDTO.Id_or, dataDTO);
                    }
                }
            }

            //TODO 如果待打印树第一行不是换页标记,则显示已打印数据,否则不显示已打数据
            // 待打印数据第一条页码,如果已打数据不是打印到纸张最后一行(需要换纸),则待打印数据不设置该值
            int pageNum = 0;
            // 是否需要新启动一页打印
            // 如果是新起一页打印,rowAssist为待打印数据信息数组,否则为已打印、待打印页面、行号、所在行信息
            bool isNewPage = this.isUseNewPage(ordPrintDOLast, ref pageNum);
            //不是新起一页,则需要显示已打印数据最后一页的数据,置灰显示
            if (!isNewPage)
            {
                ordPrintDOsConAndResList.AddRange(ordPrintDOsPrted);

                // 对已打印数据设置标记参数的页码、行号、行数、打印作废标记
                for (int i = 0; i < ordPrintDOsConAndResList.Count; i++)
                {
                    DORowPrtFlags rowFlag = new DORowPrtFlags();
                    rowFlag.AtPageIx       = (int)ordPrintDOsConAndResList[i].Page_num;
                    rowFlag.AtGridRowIx    = (int)ordPrintDOsConAndResList[i].Row_num;
                    rowFlag.TakeGridRowCnt = (int)ordPrintDOsConAndResList[i].Row_cnt;
                    //根据作废打印标识Fg_canc_prn,判断是否打印过作废线,
                    //打印过作废线的同时显示内容和作废线(置灰),否则只显示内容(置灰)
                    rowFlag.InvalidPrtType = ordPrintDOsConAndResList[i].Fg_canc_prn == true ? DORowPrtFlags.ENumInvalidPrtType.HasPrted : DORowPrtFlags.ENumInvalidPrtType.NotInvalid;
                    //判断在已打印数据中,是否有需要补打作废线or停止时间
                    if (!bReset && ordPrintDataDTOsPrtedDic.ContainsKey(ordPrintDOsConAndResList[i].Id_or))
                    {
                        //需要补打停止时间的:停止时间、医生、护士
                        if (ordPrintDataDTOsPrtedDic[ordPrintDOsConAndResList[i].Id_or].Fg_chk_stop == true)
                        {
                            rowFlag.IsDataRemedy = true;
                            ordPrintDOsConAndResList[i].Fg_chk_stop = FBoolean.True;                                                            //停止标识
                            ordPrintDOsConAndResList[i].Fg_stop_prn = FBoolean.True;                                                            //停止打印标识
                            this.setOrdPrintDatetime(ordPrintDataDTOsPrtedDic[ordPrintDOsConAndResList[i].Id_or], ordPrintDOsConAndResList[i]); //设置停止时间
                        }
                        //需要补打作废线的:作废线(黑)、内容(置灰)
                        if (ordPrintDataDTOsPrtedDic[ordPrintDOsConAndResList[i].Id_or].Fg_chk_canc == true)
                        {
                            ordPrintDOsConAndResList[i].Fg_chk_canc = FBoolean.True; //作废标识
                            ordPrintDOsConAndResList[i].Fg_canc_prn = FBoolean.True; //作废打印标识
                            rowFlag.InvalidPrtType = DORowPrtFlags.ENumInvalidPrtType.DelLine;
                            //rowFlag.IsDataRemedy = true;
                        }
                    }
                    rowFlagList.Add(rowFlag);
                }

                //获取最后一条已打印数据的标记参数
                if (rowFlagList != null && rowFlagList.Count > 0)
                {
                    rowPrtFlagLast = rowFlagList[rowFlagList.Count - 1];
                }
            }
            #endregion

            #region 重整标记行
            // 如果是重整打印,则在已打印数据的后一行加重整标记行
            if (bReset)
            {
                //重整行标记参数
                DORowPrtFlags rowFlagReset = new DORowPrtFlags();
                rowFlagReset.ForceInOneGridRow = true;                            // 重整标记行,内容强制不换行
                rowFlagReset.MarkType          = DORowPrtFlags.ENumMarkType.Text; //重整标记行内容标红

                if (isNewPage)
                {
                    rowFlagReset.AtPageIx = pageNum;; //新起一页
                    isNewPage             = false;
                }
                rowFlagList.Add(rowFlagReset);

                //重整行数据(取待打印第一条数据进行拷贝)
                ordPrintDOsConAndResList.Add(getOrdPrintDOReset(ordPrintDataDTOsToPrt[0]));
            }
            #endregion

            #region 待打印数据
            // 设置未打印的数据
            for (int i = 0; i < ordPrintDataDTOsToPrt.Length; i++)
            {
                // 对于直接打印的数据不需要设置页码、页号等信息
                DORowPrtFlags rowFlag = new DORowPrtFlags();
                // 如果上页正好打印到最后一行时,新页需要设置页码
                if (isNewPage)
                {
                    rowFlag.AtPageIx = pageNum;//新起一页
                    isNewPage        = false;
                }

                //将医嘱待打印数据对象转换为医嘱打印的数据对象,设置格式化医嘱内容、生效时间、停止时间、医生、护士
                OrdPrintDO ordPrintData = this.convertOrdPrintData(ordPrintDataDTOsToPrt[i], i > 0 && ordPrintDataDTOsToPrt[i - 1].Id_or.Equals(ordPrintDataDTOsToPrt[i].Id_or));
                ordPrintDOsConAndResList.Add(ordPrintData);

                // 设置标记参数
                this.setRowPrtFlags(ordPrintDOLast, ordPrintData, ref rowPrtFlagLast, ref rowFlag);

                // 用于判断后一条医嘱与前一条医嘱打印时是否在同一页,以及记录页码等信息
                ordPrintDOLast = ordPrintData;
                rowPrtFlagLast = rowFlag;

                rowFlagList.Add(rowFlag);
            }
            #endregion

            return(ordPrintDOsConAndResList.ToArray());
        }