MES_Client/TGMES/Core.StlMes.Client.LgCommon/PublicMethod.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Diagnostics;
using System.Text;
using System.Text.RegularExpressions;
using System.Windows.Forms;
using System.Net;
using System.Net.NetworkInformation;

using Infragistics.Win;
using Infragistics.Win.Layout;
using Infragistics.Win.UltraWinGrid;
using Infragistics.Win.UltraWinEditors;
using Infragistics.Win.UltraWinDataSource;

using CoreFS.CA06;

namespace Core.StlMes.Client.LgCommon
{
    public enum CodeName
    {
        Code,
        Name
    }

    public class PublicMethod
    {
        #region 访问服务端

        /// <summary>
        /// 执行SQL返回数据集
        /// </summary>
        /// <param name="strSql">输入参数：SQL语句</param>
        /// <param name="bSuccess">输出参数：SQL是否执行成功</param>
        /// <param name="strMsg">输出参数：执行成功返回空，执行失败返回错误提示</param>
        /// <param name="Ob">输入参数：OpeBase对象，继承基类FrmBase的MDI窗口文件用this.ob传入，弹窗则由父窗口闯入引用</param>
        /// <returns>返回结果：执行成功返回的数据集，失败返回NULL</returns>
        public static DataSet GetData(string strSql, out bool bSuccess, out string strMsg, OpeBase Ob)
        {
            try
            {
                CoreClientParam ccp = new CoreClientParam();
                ccp.IfShowErrMsg = false;
                ccp.ServerName = "KgStlMes.DBHelp";
                ccp.MethodName = "getSqlInfo_Stl";
                ccp.ServerParams = new object[] { strSql };
                ccp = Ob.ExecuteSortResultByQueryToDataTable(ccp, CoreInvokeType.Internal);
                strMsg = ccp.ReturnInfo;

                if (!string.IsNullOrEmpty(strMsg) || ccp.SourceDataTable == null)
                {
                    bSuccess = false;
                    return null;
                }

                DataSet ds = new DataSet();
                ds.Tables.Add(ccp.SourceDataTable);
                bSuccess = true;
                return ds;
            }
            catch (Exception ex)
            {
                bSuccess = false;
                strMsg = ex.Message;
                return null;
            }
        }

        /// <summary>
        /// 执行SQL返回数据集
        /// </summary>
        /// <param name="strSql">输入参数：SQL语句</param>
        /// <param name="strInfo">执行SQL所代表的含义</param>
        /// <param name="Ob">输入参数：OpeBase对象，继承基类FrmBase的MDI窗口文件用this.ob传入，弹窗则由父窗口闯入引用</param>
        /// <returns>返回结果：执行成功返回的数据集，失败返回NULL</returns>
        public static DataSet GetDataCommon(string strSql, string strInfo, OpeBase Ob)
        {
            string strMsg = "";
            bool bSuccess = false;

            DataSet ds = GetData(strSql, out bSuccess, out strMsg, Ob);

            if (!string.IsNullOrEmpty(strInfo))
            {
                if (!strInfo.Contains("【") && !strInfo.Contains("】"))
                {
                    strInfo = "【" + strInfo + "】";
                }
            }

            if (!bSuccess)
            {
                MessageBox.Show(strInfo + "信息获取失败！" + (string.IsNullOrEmpty(strMsg) ? "" : "\r\n" + strMsg), "提示", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
                if (MessageBox.Show("是否重新获取" + strInfo + "信息？", "提示", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
                {
                    return GetDataCommon(strSql, strInfo, Ob);
                }
                return null;
            }

            return ds;
        }

        /// <summary>
        /// 执行单个SQL增删改操作
        /// </summary>
        /// <param name="strSql">输入参数：需要执行的SQL</param>
        /// <param name="strMsg">输出参数：执行成功返回空，执行失败返回错误提示</param>
        /// <param name="Ob">输入参数：OpeBase对象，继承基类FrmBase的MDI窗口文件用this.ob传入，弹窗则由父窗口闯入引用</param>
        /// <returns>返回结果：执行成功返回true，否则返回false </returns>
        public static bool SetData(string strSql, out string strMsg, OpeBase Ob)
        {
            if (string.IsNullOrEmpty(strSql))
            {
                strMsg = "未指定SQL语句！";
                return false;
            }

            int iRet = 0;

            return ExecuteProcedure("SetData", new object[] { strSql }, out iRet, out strMsg, Ob);
        }

        /// <summary>
        /// 执行存储过程返回执行结果
        /// </summary>
        /// <param name="strProcName">输入参数：存储过程名</param>
        /// <param name="args">输入参数：存储过程参数集合</param>
        /// <param name="iRet">输出参数：执行成功iRet大于零（可以自定义代码含义），执行失败返回0</param>
        /// <param name="strMsg">输出参数：执行成功返回空（或者根据需要返回用户需要信息），执行失败返回错误提示</param>
        /// <param name="Ob">输入参数：OpeBase对象，继承基类FrmBase的MDI窗口文件用this.ob传入，弹窗则由父窗口闯入引用</param>
        /// <returns>返回结果：执行成功返回true，否则返回false</returns>
        public static bool ExecuteProcedure(string strProcName, object[] args, out int iRet, out string strMsg, OpeBase Ob)
        {
            iRet = 0;
            strMsg = "";

            CoreClientParam ccp = new CoreClientParam();
            try
            {
                ccp.IfShowErrMsg = false;
                ccp.ServerName = "KgStlMes.DBHelp";
                ccp.MethodName = "doProcedure_Stl";
                ccp.ServerParams = new object[] { strProcName, args };
                ccp = Ob.ExecuteNonQuery(ccp, CoreInvokeType.Internal);
                ArrayList result = (ArrayList)ccp.ReturnObject;
                iRet = Convert.ToInt32(result[2]);
                strMsg = Convert.ToString(result[3]);
            }
            catch (Exception ex)
            {
                string strErr = (ccp == null ? "" : ccp.ReturnInfo);
                iRet = iRet > 0 ? iRet : 0;
                if (string.IsNullOrEmpty(strErr)) strMsg = ex.Message;
                else strMsg = strErr;
            }

            return (iRet > 0 ? true : false);
        }

        /// <summary>
        /// 执行跟SAP相关的存储过程返回执行结果
        /// </summary>
        /// <param name="strProcName">输入参数：存储过程名</param>
        /// <param name="args">输入参数：存储过程参数集合</param>
        /// <param name="iRet">输出参数：执行成功iRet大于零（可以自定义代码含义），执行失败返回0</param>
        /// <param name="strMsg">输出参数：执行成功返回空（或者根据需要返回用户需要信息），执行失败返回错误提示</param>
        /// <param name="Ob">输入参数：OpeBase对象，继承基类FrmBase的MDI窗口文件用this.ob传入，弹窗则由父窗口闯入引用</param>
        /// <returns>返回结果：执行成功返回true，否则返回false</returns>
        public static CoreFS.CA06.CoreClientParam ExecuteJKProcedure(string procedureName, object[] param, ArrayList jkparam, OpeBase Ob)
        {
            CoreFS.CA06.CoreClientParam ccp = new CoreFS.CA06.CoreClientParam();

            ccp.IfShowErrMsg = false;

            ccp.ServerParams = new object[] { procedureName, param, jkparam };
            ccp.ServerName = "Stl.port";
            ccp.MethodName = "gangquyewu";//服务端方法名
            ccp = Ob.ExecuteNonQuery(ccp, CoreFS.CA06.CoreInvokeType.Internal);
            return ccp;
        }


        #endregion

        public static void RefreshAndAutoSize(UltraGrid ultraGrid)
        {
            try
            {
                ultraGrid.DataBind();

                foreach (UltraGridBand band in ultraGrid.DisplayLayout.Bands)
                {
                    foreach (UltraGridColumn column in band.Columns)
                    {
                        column.PerformAutoResize(PerformAutoSizeType.AllRowsInBand);
                    }
                }

                ultraGrid.Refresh();
            }
            catch { }
        }

        public static void CopyDataToDatatable(ref DataTable src, ref DataTable dest, bool ClearExists)
        {
            if (src == null || dest == null)
            {
                return;
            }

            if (ClearExists)
            {
                dest.Rows.Clear();
            }

            DataRow CurRow, NewRow;

            for (int i = 0; i < src.Rows.Count; i++)
            {
                CurRow = src.Rows[i];
                NewRow = dest.NewRow();

                for (int j = 0; j < src.Columns.Count; j++)
                {
                    try
                    {
                        if (dest.Columns.Contains(src.Columns[j].ColumnName))
                        {
                            NewRow[src.Columns[j].ColumnName] = CurRow[j];
                        }
                    }
                    catch { }
                }

                dest.Rows.Add(NewRow);
            }
        }

        public static void CopyDataToDatatable(ref DataTable src, ref DataTable dest, bool ClearExists, ArrayList alistColumns, ArrayList alistValue)
        {
            if (src == null || dest == null)
            {
                return;
            }

            if (ClearExists)
            {
                dest.Rows.Clear();
            }

            DataRow CurRow, NewRow;

            for (int i = 0; i < src.Rows.Count; i++)
            {
                CurRow = src.Rows[i];
                NewRow = dest.NewRow();

                for (int j = 0; j < src.Columns.Count; j++)
                {
                    try
                    {
                        if (dest.Columns.Contains(src.Columns[j].ColumnName))
                        {
                            NewRow[src.Columns[j].ColumnName] = CurRow[j];
                        }
                    }
                    catch { }
                }

                if (alistColumns != null && alistValue != null)
                {
                    for (int idx = 0; idx < alistColumns.Count; idx++)
                    {
                        try
                        {
                            if (dest.Columns.Contains(alistColumns[idx].ToString()))
                            {
                                NewRow[alistColumns[idx].ToString()] = alistValue[idx];
                            }
                        }
                        catch { }
                    }
                }

                dest.Rows.Add(NewRow);
            }
        }

        public static bool GridContainsColumn(ref UltraGrid grid, string strColumn)
        {
            for (int i = 0; i < grid.DisplayLayout.Bands[0].Columns.Count; i++)
            {
                if (grid.DisplayLayout.Bands[0].Columns[i].Key.Equals(strColumn))
                    return true;
            }

            return false;
        }

        public static bool GridContainsColumn(ref UltraGrid grid, int BandIndex, string strColumn)
        {
            if (BandIndex <= grid.DisplayLayout.Bands.Count - 1)
            {
                for (int i = 0; i < grid.DisplayLayout.Bands[BandIndex].Columns.Count; i++)
                {
                    if (grid.DisplayLayout.Bands[BandIndex].Columns[i].Key.Equals(strColumn))
                        return true;
                }
            }

            return false;
        }

        public static bool SetMyComboEditor(ref UltraComboEditor cbEdt, ref ValueList vlist, bool bNull)
        {
            if (cbEdt == null || vlist == null)
            {
                return false;
            }

            cbEdt.Items.Clear();

            if (bNull)
            {
                cbEdt.Items.Add(null, "");
            }

            for (int i = 0; i < vlist.ValueListItems.Count; i++)
            {
                try
                {
                    cbEdt.Items.Add(vlist.ValueListItems[i].DataValue, vlist.ValueListItems[i].DisplayText);
                }
                catch { }
            }

            return true;
        }

        public static bool SetMyComboEditor(ref UltraComboEditor cbEdt, ref DataTable table, string strColumnDisplay, string strColumnValue, bool bNull)
        {
            if (cbEdt == null || table == null || !table.Columns.Contains(strColumnDisplay) || !table.Columns.Contains(strColumnValue))
            {
                return false;
            }

            string strText = "";
            object objValue = null;

            cbEdt.Items.Clear();

            if (bNull)
            {
                cbEdt.Items.Add(null, "");
            }

            for (int i = 0; i < table.Rows.Count; i++)
            {
                try
                {
                    strText = Convert.ToString(table.Rows[i][strColumnDisplay]);
                    objValue = table.Rows[i][strColumnValue];

                    cbEdt.Items.Add(objValue, strText);
                }
                catch { }
            }

            return true;
        }

        public static bool SetMyComboEditor(ref UltraComboEditor cbEdt, ref DataTable table, string strColumnDisplay, string strColumnValue, string[] strColumnTag, bool bNull)
        {
            if (cbEdt == null || table == null || !table.Columns.Contains(strColumnDisplay) || !table.Columns.Contains(strColumnValue))
            {
                return false;
            }

            for (int i = 0; i < strColumnTag.Length; i++)
            {
                if (!table.Columns.Contains(strColumnTag[i]))
                {
                    return false;
                }
            }

            string strText = "";
            object objValue = null;

            cbEdt.Items.Clear();

            if (bNull)
            {
                cbEdt.Items.Add(null, "");
            }

            Hashtable htbl;
            for (int i = 0; i < table.Rows.Count; i++)
            {
                try
                {
                    strText = Convert.ToString(table.Rows[i][strColumnDisplay]);
                    objValue = table.Rows[i][strColumnValue];

                    cbEdt.Items.Add(objValue, strText);

                    htbl = new Hashtable();
                    for (int j = 0; j < strColumnTag.Length; j++)
                    {
                        try
                        {
                            if (!htbl.Contains(strColumnTag[j]))
                                htbl.Add(strColumnTag[j], table.Rows[i][strColumnTag[j]]);
                        }
                        catch { }
                    }
                    cbEdt.Items[i].Tag = htbl;
                }
                catch { }
            }

            return true;
        }

        public static void InitUserControl(ref UltraDataSource ultDataSource, ref UltraGrid ultraGrid)
        {
            try
            {
                int iColumnsCount = ultDataSource.Band.Columns.Count;
                object[] obj = new object[iColumnsCount];

                ultDataSource.Rows.Clear();

                for (int i = 0; i < ultDataSource.Band.Columns.Count; i++)
                {
                    try
                    {
                        if (ultDataSource.Band.Columns[i].DataType == typeof(Bitmap) ||
                            ultDataSource.Band.Columns[i].DataType == typeof(Image))
                            obj[i] = null;
                        else if (ultDataSource.Band.Columns[i].DataType == typeof(DateTime))
                            obj[i] = DBNull.Value;
                        else if (ultDataSource.Band.Columns[i].DataType == typeof(decimal) ||
                                ultDataSource.Band.Columns[i].DataType == typeof(double) ||
                                ultDataSource.Band.Columns[i].DataType == typeof(Single))
                            obj[i] = 0;
                        else
                            obj[i] = "";
                    }
                    catch { }
                }
                ultDataSource.Rows.Add(obj);

                ultraGrid.UpdateData();
            }
            catch { }
        }

        public static void SetUltraGridCellReadOnly(ref UltraGrid ultraGrid, bool bReadOnly)
        {
            try
            {
                for (int i = 0; i < ultraGrid.DisplayLayout.Bands[0].Columns.Count; i++)
                {
                    try
                    {
                        ultraGrid.DisplayLayout.Bands[0].Columns[i].CellActivation = (bReadOnly ? Activation.ActivateOnly : Activation.AllowEdit);
                        ultraGrid.DisplayLayout.Bands[0].Columns[i].CellAppearance.BackColor = (bReadOnly ? Color.LightBlue : Color.White);
                    }
                    catch { }
                }
            }
            catch { }
        }

        public static void ResetUltraDataSource(ref UltraDataSource ultDataSource, ref UltraGrid ultraGrid)
        {
            try
            {
                if (ultDataSource.Rows.Count == 0) return;

                for (int i = 0; i < ultDataSource.Band.Columns.Count; i++)
                {
                    try
                    {
                        if (ultDataSource.Band.Columns[i].DataType == typeof(Bitmap) ||
                            ultDataSource.Band.Columns[i].DataType == typeof(Image))
                            ultDataSource.Rows[0][i] = null;
                        else if (ultDataSource.Band.Columns[i].DataType == typeof(DateTime))
                            ultDataSource.Rows[0][i] = DBNull.Value;
                        else if (ultDataSource.Band.Columns[i].DataType == typeof(decimal) ||
                            ultDataSource.Band.Columns[i].DataType == typeof(double) ||
                            ultDataSource.Band.Columns[i].DataType == typeof(Single))
                            ultDataSource.Rows[0][i] = 0;
                        else
                            ultDataSource.Rows[0][i] = "";
                    }
                    catch { }
                }

                ultraGrid.UpdateData();
            }
            catch { }
        }

        public static void SetDataSourceValue(ref UltraDataSource ultDataSource, ref UltraGrid ultraGrid, Hashtable Values)
        {
            try
            {
                if (ultDataSource.Rows.Count == 0 || Values == null) return;

                string Key = "";
                ArrayList Keys = new ArrayList(Values.Keys);

                for (int i = 0; i < Keys.Count; i++)
                {
                    try
                    {
                        Key = Keys[i].ToString();
                        ultDataSource.Rows[0][Key] = Values[Key];
                    }
                    catch { }
                }

                ultraGrid.UpdateData();
            }
            catch { }
        }

        public static ValueList InitValueListComparisonOperator()
        {
            ValueList vlist_ComparisonOperator = new ValueList();
            vlist_ComparisonOperator.ValueListItems.Add(" = ", "等于");
            vlist_ComparisonOperator.ValueListItems.Add(" > ", "大于");
            vlist_ComparisonOperator.ValueListItems.Add(" >= ", "大于等于");
            vlist_ComparisonOperator.ValueListItems.Add(" < ", "小于");
            vlist_ComparisonOperator.ValueListItems.Add(" <= ", "小于等于");
            vlist_ComparisonOperator.ValueListItems.Add(" <> ", "不等于");
            return vlist_ComparisonOperator;
        }

        public static ValueList InitValueListLgic()
        {
            ValueList vlist_Logic = new ValueList();
            vlist_Logic.ValueListItems.Add("1", "是");
            vlist_Logic.ValueListItems.Add("0", "否");
            return vlist_Logic;
        }

        public static ValueList GetValuelistBanci()
        {
            ValueList vlist = new ValueList();
            try
            {
                //两班倒    
                vlist.ValueListItems.Add("3", "大夜");
                vlist.ValueListItems.Add("1", "白班");
                vlist.ValueListItems.Add("2", "小夜");                
            }
            catch { }

            return vlist;
        }

        public static ValueList GetValuelistBanzu()
        {
            ValueList vlist = new ValueList();
            try
            {
                vlist.ValueListItems.Add("1", "甲班");
                vlist.ValueListItems.Add("2", "乙班");
                vlist.ValueListItems.Add("3", "丙班");
                vlist.ValueListItems.Add("4", "丁班");
            }
            catch { }

            return vlist;
        }

        public static string GetShiftClass(string strCode)
        {
            try
            {
                switch (strCode)
                {
                    //两班倒
                    case "1":
                        return "白班";
                    case "3":
                        return "大夜";
                    case "2":
                        return "小夜";
                    default:
                        return "";
                }
            }
            catch { }

            return "";
        }

        public static string GetShiftGroup(string strCode)
        {
            try
            {
                switch (strCode)
                {
                    case "1":
                        return "甲班";
                    case "2":
                        return "乙班";
                    case "3":
                        return "丙班";
                    case "4":
                        return "丁班";
                    default:
                        return "";
                }
            }
            catch { }

            return "";
        }

        public static bool IsValidShiftClass(string strCode)
        {
            return (strCode.Equals("1") || strCode.Equals("2") || strCode.Equals("3"));
        }

        public static bool IsValidShiftGroup(string strCode)
        {
            return (strCode.Equals("1") || strCode.Equals("2") || strCode.Equals("3") || strCode.Equals("4"));
        }

        public static DataSet GetProductInfo(OpeBase ob)
        {
            string strInfo = "产品";

            string strSql = "";
            strSql += Convert.ToString("select t.producttypecode basecode, t.producttypename basename").Trim() + " ";
            strSql += Convert.ToString("  from (select *").Trim() + " ";
            strSql += Convert.ToString("          from lims.com_producttype_gh t").Trim() + " ";
            strSql += Convert.ToString("         start with t.sortcode not in").Trim() + " ";
            strSql += Convert.ToString("                    (select distinct t.producttypecode").Trim() + " ";
            strSql += Convert.ToString("                       from lims.com_producttype_gh t)").Trim() + " ";
            strSql += Convert.ToString("        connect by prior t.producttypecode = t.sortcode) t").Trim() + " ";
            strSql += Convert.ToString(" where t.flag = '0'").Trim() + " ";
            strSql += Convert.ToString(" order by t.producttypecode").Trim();

            return GetDataCommon(strSql, strInfo, ob);
        }

        public static DataSet GetProductSortInfo(OpeBase ob)
        {
            string strInfo = "产品类别";

            string strSql = "select * from com_base_info t where t.sortcode = '2051' and t.memo in ('200601', '200602', '200603') order by t.basecode";

            return GetDataCommon(strSql, strInfo, ob);
        }

        public static DataSet GetCustomerInfo(OpeBase ob)
        {
            string strInfo = "客户";

            string strSql = "select t.buyer_id, t.buyer_name from slm_buyerinfo t order by t.buyer_name";

            return GetDataCommon(strSql, strInfo, ob);
        }

        public static DataSet GetSteelInfo(string strLargeFlag, OpeBase ob)
        {            
            string strInfo = "牌号";

            string strSql = "";
            strSql += Convert.ToString("select t.steelcode, t.steel steel, t.style largeflag").Trim() + " ";
            strSql += Convert.ToString("  from com_steel t").Trim() + " ";
            strSql += Convert.ToString(" where 1 = 1").Trim() + " " + (string.IsNullOrEmpty(strLargeFlag) ? "" : " and t.steeltype = '" + strLargeFlag + "' ");
            strSql += Convert.ToString(" order by t.style, t.steel").Trim();

            return GetDataCommon(strSql, strInfo, ob);
        }

        public static DataSet GetBaseInfo(string strSortCode, OpeBase ob)
        {
            string strInfo = "基础";

            string strSql = "select t.basecode, t.basename, t.sortcode"
            + "  from com_base_info t"
            + " where 1 = 1"
            + "   and t.sortcode in (" + strSortCode + ") "
            + " order by t.sortcode, t.basename";

            return GetDataCommon(strSql, strInfo, ob);
        }

        public static DataSet GetBaseInfo1(string strSortCode,string strCkType, OpeBase ob)
        {
            string strInfo = "";
            string strSql = " select t.buttressno, (select buttressname from ydm_bs_buttressconfig where buttressno = t.buttressno) buttressname from ydm_bs_buttressconfig t ,com_base_info t1 where t.managementno='" + strSortCode + "' "
              + " and t.storagesort='A' and t.storageattr=t1.basecode and t1.cktype='" + strCkType + "'";
            return GetDataCommon(strSql, strInfo, ob);

        }

        public static DataSet GetBaseInfoRecursive(string strInfo, string strSortCode, CodeName eCodeName, OpeBase ob)
        {
            string strSql = "select t.basecode, t.basename"
                        + "  from (select *"
                        + "          from com_base_info t"
                        + "         start with t.sortcode = '" + strSortCode + "'"
                        + "        connect by prior t.basecode = t.sortcode) t"
                        + " where t.flag = '0'"
                        + " order by " + (eCodeName == CodeName.Code ? "t.basecode" : "t.basename");

            return GetDataCommon(strSql, strInfo, ob);
        }

        public static ValueList GetValuelistWeightStatus()
        {
            ValueList vlist = new ValueList();
            try
            {
                vlist.ValueListItems.Add("01", "轧钢库");
                vlist.ValueListItems.Add("02", "移送待接收");
                vlist.ValueListItems.Add("03", "物流库");
                vlist.ValueListItems.Add("04", "退库待接收");
            }
            catch { }

            return vlist;
        }

        public static ValueList GeneralValuelist(ref Hashtable htbl)
        {
            if (htbl == null)
            {
                return null;
            }

            ArrayList alist = new ArrayList(htbl.Keys);

            ValueList vlist = new ValueList();

            for (int i = 0; i < alist.Count; i++)
            {
                try
                {
                    if (htbl.Contains(alist[i]))
                    {
                        vlist.ValueListItems.Add(alist[i], Convert.ToString(htbl[alist[i]]));
                    }
                }
                catch { }
            }

            return vlist;
        }

        public static ValueList GeneralValuelist(ref DataTable table, string strKey, string strText)
        {
            if (table == null || !table.Columns.Contains(strKey) || !table.Columns.Contains(strText))
            {
                return null;
            }

            ArrayList alist = new ArrayList();
            ValueList vlist = new ValueList();

            for (int i = 0; i < table.Rows.Count; i++)
            {
                try
                {
                    if (!alist.Contains(table.Rows[i][strKey]))
                    {
                        alist.Add(table.Rows[i][strKey]);
                        vlist.ValueListItems.Add(table.Rows[i][strKey], Convert.ToString(table.Rows[i][strText]));
                    }
                }
                catch { }
            }

            return vlist;
        }

        public static void SetGridValuelist(ref UltraGrid myGrid, string strColumn, ref ValueList vlist)
        {
            try
            {
                if (GridContainsColumn(ref myGrid, strColumn))
                {
                    myGrid.DisplayLayout.Bands[0].Columns[strColumn].ValueList = vlist;
                }
            }
            catch { }
            finally
            {
                myGrid.DisplayLayout.Bands[0].Columns[strColumn].Style = Infragistics.Win.UltraWinGrid.ColumnStyle.DropDownList;
            }
        }

        public static void SetGridValuelist(ref UltraGrid myGrid, int BandIndex, string strColumn, ref ValueList vlist)
        {
            try
            {
                if (GridContainsColumn(ref myGrid, BandIndex, strColumn))
                {
                    myGrid.DisplayLayout.Bands[BandIndex].Columns[strColumn].ValueList = vlist;
                }
            }
            catch { }
            finally
            {
                myGrid.DisplayLayout.Bands[BandIndex].Columns[strColumn].Style = Infragistics.Win.UltraWinGrid.ColumnStyle.DropDownList;
            }
        }

        public static Point SetChildWindowLocation(Size ChildWindowSize)
        {
            int width = Cursor.Position.X + ChildWindowSize.Width - Screen.PrimaryScreen.Bounds.Width;
            int height = Cursor.Position.Y + ChildWindowSize.Height - Screen.PrimaryScreen.Bounds.Height + 30;

            width = (width > 0) ? (Cursor.Position.X - width) : Cursor.Position.X;                      // X坐标
            height = (height > 0) ? (Cursor.Position.Y - height + 10) : (Cursor.Position.Y + 10);       // Y坐标

            return new Point(width, height);
        }

        public static void FixedWeightInfoHeaders(ref UltraGrid ultraGrid, ArrayList alistColumns)
        {
            try
            {
                if (ultraGrid == null || alistColumns == null || alistColumns.Count == 0)
                {
                    return;
                }

                ultraGrid.DisplayLayout.UseFixedHeaders = true;

                for (int i = 0; i < alistColumns.Count; i++)
                {
                    try
                    {
                        if (GridContainsColumn(ref ultraGrid, alistColumns[i].ToString()))
                        {
                            ultraGrid.DisplayLayout.Bands[0].Columns[alistColumns[i].ToString()].Header.Fixed = true;
                            ultraGrid.DisplayLayout.Bands[0].Columns[alistColumns[i].ToString()].Header.FixedHeaderIndicator = FixedHeaderIndicator.None;
                        }
                    }
                    catch (Exception ex)
                    {
                        Debug.WriteLine(ex.Message);
                    }
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.Message);
            }
        }

        public static void FixedWeightInfoHeaders(ref UltraGrid ultraGrid, int BandIndex, ArrayList alistColumns)
        {
            try
            {
                if (ultraGrid == null || alistColumns == null || alistColumns.Count == 0 ||
                    BandIndex < 0 || BandIndex > ultraGrid.DisplayLayout.Bands.Count - 1)
                {
                    return;
                }

                ultraGrid.DisplayLayout.UseFixedHeaders = true;

                for (int i = 0; i < alistColumns.Count; i++)
                {
                    try
                    {
                        if (GridContainsColumn(ref ultraGrid, alistColumns[i].ToString()))
                        {
                            ultraGrid.DisplayLayout.Bands[BandIndex].Columns[alistColumns[i].ToString()].Header.Fixed = true;
                            ultraGrid.DisplayLayout.Bands[BandIndex].Columns[alistColumns[i].ToString()].Header.FixedHeaderIndicator = FixedHeaderIndicator.None;
                        }
                    }
                    catch (Exception ex)
                    {
                        Debug.WriteLine(ex.Message);
                    }
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.Message);
            }
        }

        public static void SetGridColumnsReadOnly(ref UltraGrid ultraGrid, ArrayList alistAllowEdit, ArrayList alistActivateOnly, ArrayList alistNoEdit, ArrayList alistDisabled)
        {
            try
            {
                for (int i = 0; i < ultraGrid.Rows.Count; i++)
                {
                    if (alistAllowEdit != null && alistAllowEdit.Count > 0)
                    {
                        for (int j = 0; j < alistAllowEdit.Count; j++)
                        {
                            try
                            {
                                if (GridContainsColumn(ref ultraGrid, alistAllowEdit[j].ToString()))
                                {
                                    ultraGrid.Rows[i].Cells[alistAllowEdit[j].ToString()].Activation = Activation.AllowEdit;
                                }
                            }
                            catch (Exception ex)
                            {
                                Debug.WriteLine(ex.Message);
                            }
                        }
                    }

                    if (alistActivateOnly != null && alistActivateOnly.Count > 0)
                    {
                        for (int j = 0; j < alistActivateOnly.Count; j++)
                        {
                            try
                            {
                                if (GridContainsColumn(ref ultraGrid, alistActivateOnly[j].ToString()))
                                {
                                    ultraGrid.Rows[i].Cells[alistActivateOnly[j].ToString()].Activation = Activation.ActivateOnly;
                                }
                            }
                            catch (Exception ex)
                            {
                                Debug.WriteLine(ex.Message);
                            }
                        }
                    }

                    if (alistNoEdit != null && alistNoEdit.Count > 0)
                    {
                        for (int j = 0; j < alistNoEdit.Count; j++)
                        {
                            try
                            {
                                if (GridContainsColumn(ref ultraGrid, alistNoEdit[j].ToString()))
                                {
                                    ultraGrid.Rows[i].Cells[alistNoEdit[j].ToString()].Activation = Activation.NoEdit;
                                }
                            }
                            catch (Exception ex)
                            {
                                Debug.WriteLine(ex.Message);
                            }
                        }
                    }

                    if (alistDisabled != null && alistDisabled.Count > 0)
                    {
                        for (int j = 0; j < alistDisabled.Count; j++)
                        {
                            try
                            {
                                if (GridContainsColumn(ref ultraGrid, alistDisabled[j].ToString()))
                                {
                                    ultraGrid.Rows[i].Cells[alistDisabled[j].ToString()].Activation = Activation.Disabled;
                                }
                            }
                            catch (Exception ex)
                            {
                                Debug.WriteLine(ex.Message);
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.Message);
            }
        }

        public static bool HasCheckedRows(ref UltraGrid ultraGrid, string strColumnCondition, object value, string strOutColumn, out ArrayList alistValue, out string strMsg)
        {
            strMsg = "";
            alistValue = new ArrayList();

            try
            {
                if (ultraGrid == null || ultraGrid.Rows.Count == 0)
                {
                    return false;
                }

                if (!string.IsNullOrEmpty(strColumnCondition))
                {
                    if (!GridContainsColumn(ref ultraGrid, 0, strColumnCondition))
                    {
                        strMsg = "不存在条件字段【" + strColumnCondition + "】！";
                        return false;
                    }
                }

                if (string.IsNullOrEmpty(strOutColumn))
                {
                    strMsg = "未指定输出字段【" + strOutColumn + "】！";
                    return false;
                }

                if (!GridContainsColumn(ref ultraGrid, 0, strOutColumn))
                {
                    strMsg = "不存在输出字段【" + strOutColumn + "】！";
                    return false;
                }

                for (int i = 0; i < ultraGrid.Rows.Count; i++)
                {
                    if (!string.IsNullOrEmpty(strColumnCondition))
                    {
                        if (ultraGrid.Rows[i].Cells[strColumnCondition].Value.Equals(value))
                        {
                            alistValue.Add(ultraGrid.Rows[i].Cells[strOutColumn].Value);
                        }
                    }
                    else
                    {
                        alistValue.Add(ultraGrid.Rows[i].Cells[strOutColumn].Value);
                    }
                }

                return true;
            }
            catch (Exception ex)
            {
                strMsg = ex.Message;
                alistValue = null;
            }

            return false;
        }

        public static void SetUltraGridAppearance(Control Parent)
        {
            UltraGrid grid = null;

            foreach (Control ctrl in Parent.Controls)
            {
                try
                {
                    if (ctrl.GetType().Equals(typeof(UltraGrid)))
                    {
                        grid = (UltraGrid)ctrl;

                        if (grid == null)
                        {
                            continue;
                        }

                        try
                        {
                            if (grid.DisplayLayout.Bands.Count > 0)
                            {
                                if (grid.DisplayLayout.Bands[0].CardView)
                                {
                                    continue;
                                }

                                grid.DisplayLayout.UseFixedHeaders = true;
                                grid.DisplayLayout.ViewStyleBand = ViewStyleBand.Vertical;
                                grid.DisplayLayout.GroupByBox.Prompt = "将需要分组的列拖到此处";
                                grid.DisplayLayout.Override.MaxSelectedRows = 0;
                                grid.DisplayLayout.Override.SelectTypeRow = SelectType.Single;
                                grid.DisplayLayout.Override.SelectTypeCol = SelectType.None;
                                grid.DisplayLayout.Override.BorderStyleCell = UIElementBorderStyle.Solid;
                                grid.DisplayLayout.Override.BorderStyleRow = UIElementBorderStyle.Solid;
                                grid.DisplayLayout.Override.WrapHeaderText = DefaultableBoolean.True;

                                grid.DisplayLayout.Override.DataErrorRowAppearance.BackColor = Color.Lime;
                                grid.DisplayLayout.Override.SupportDataErrorInfo = SupportDataErrorInfo.RowsOnly;

                                grid.DisplayLayout.CaptionVisible = DefaultableBoolean.False;
                                grid.DisplayLayout.Override.HeaderStyle = HeaderStyle.Standard;
                                grid.DisplayLayout.Override.MinRowHeight = 22;
                                grid.DisplayLayout.Override.RowSelectors = DefaultableBoolean.True;
                                grid.DisplayLayout.Override.RowSelectorNumberStyle = RowSelectorNumberStyle.RowIndex;
                                grid.DisplayLayout.Override.CellClickAction = CellClickAction.EditAndSelectText;

                                grid.DisplayLayout.Override.ActiveRowAppearance.FontData.Bold = DefaultableBoolean.True;
                                grid.DisplayLayout.Override.ActiveRowAppearance.ForeColor = Color.Empty;
                                grid.DisplayLayout.Override.ActiveRowAppearance.BackColor = Color.Empty;

                                grid.DisplayLayout.Override.RowAppearance.BackColor = Color.White;
                                grid.DisplayLayout.Override.RowAppearance.BorderColor = Color.DarkGray;
                                grid.DisplayLayout.Override.RowAppearance.TextVAlign = VAlign.Middle;
                                grid.DisplayLayout.Override.RowAlternateAppearance.BackColor = Color.GhostWhite;// Color.FromArgb(229, 255, 229);

                                grid.DisplayLayout.Override.RowSelectorAppearance.BackColor = Color.LightSteelBlue;
                                grid.DisplayLayout.Override.HeaderAppearance.BackColor = Color.LightSteelBlue;
                            }
                        }
                        catch { }

                        try
                        {
                            if (grid.DisplayLayout.Bands.Count > 1)
                            {
                                grid.DisplayLayout.Bands[1].Override.HeaderAppearance.BackColor = Color.FromArgb(233, 242, 199);
                                grid.DisplayLayout.Bands[1].Override.HeaderAppearance.BackColor = Color.FromArgb(170, 184, 131);
                                grid.DisplayLayout.Bands[1].Override.HeaderAppearance.BackGradientStyle = GradientStyle.Vertical;

                                grid.DisplayLayout.Bands[1].Override.RowSelectorAppearance.BackColor = Color.FromArgb(233, 242, 199);
                                grid.DisplayLayout.Bands[1].Override.RowSelectorAppearance.BackColor = Color.FromArgb(170, 184, 131);
                                grid.DisplayLayout.Bands[1].Override.RowSelectorAppearance.BackGradientStyle = GradientStyle.Vertical;
                            }
                        }
                        catch { }

                        try
                        {
                            foreach (UltraGridBand band in grid.DisplayLayout.Bands)
                            {
                                band.Override.AllowRowLayoutCellSizing = RowLayoutSizing.None;
                                band.Override.AllowRowLayoutCellSpanSizing = GridBagLayoutAllowSpanSizing.None;
                                band.Override.AllowRowLayoutColMoving = GridBagLayoutAllowMoving.None;
                                band.Override.AllowRowLayoutLabelSizing = RowLayoutSizing.Horizontal;
                                band.Override.AllowRowLayoutLabelSpanSizing = GridBagLayoutAllowSpanSizing.None;
                            }
                        }
                        catch { }

                        try
                        {
                            grid.KeyDown += new KeyEventHandler(grid_KeyDown);
                        }
                        catch { }

                        try
                        {
                            grid.DoubleClickCell += new DoubleClickCellEventHandler(grid_DoubleClickCell);
                        }
                        catch { }
                        if (grid.DataSource != null)
                            RefreshAndAutoSize(grid);
                    }
                    else
                    {
                        SetUltraGridAppearance(ctrl);
                    }
                }
                catch (Exception ex)
                {
                    Debug.WriteLine(ex.Message);
                }
            }
        }

        public static bool GetHashtableMinKeyValue(Hashtable htbl, out int iValue)
        {
            iValue = 0;

            if (htbl == null || htbl.Count == 0)
            {
                return false;
            }

            try
            {
                ArrayList alist = new ArrayList(htbl.Keys);

                int iKey = 0;

                for (int idx = 0; idx < alist.Count; idx++)
                {
                    if (idx == 0)
                    {
                        iKey = Convert.ToInt32(alist[idx]);
                        iValue = Convert.ToInt32(htbl[alist[idx]]);
                    }
                    else if (Convert.ToInt32(alist[idx]) < iKey)
                    {
                        iKey = Convert.ToInt32(alist[idx]);
                        iValue = Convert.ToInt32(htbl[alist[idx]]);
                    }
                }

                return true;
            }
            catch
            {
                return false;
            }
        }

        public static bool GetHashtableMaxKeyValue(Hashtable htbl, out int iValue)
        {
            iValue = 0;

            if (htbl == null || htbl.Count == 0)
            {
                return false;
            }

            try
            {
                ArrayList alist = new ArrayList(htbl.Keys);

                int iKey = 0;

                for (int idx = 0; idx < alist.Count; idx++)
                {
                    if (idx == 0)
                    {
                        iKey = Convert.ToInt32(alist[idx]);
                        iValue = Convert.ToInt32(htbl[alist[idx]]);
                    }
                    else if (Convert.ToInt32(alist[idx]) > iKey)
                    {
                        iKey = Convert.ToInt32(alist[idx]);
                        iValue = Convert.ToInt32(htbl[alist[idx]]);
                    }
                }

                return true;
            }
            catch
            {
                return false;
            }
        }

        #region ultraGrid事件

        static void grid_KeyDown(object sender, KeyEventArgs e)
        {
            try
            {
                UltraGrid grid = (UltraGrid)sender;

                if (sender == null)
                {
                    return;
                }

                UltraGridCell cell = grid.ActiveCell;

                if (cell != null)
                {
                    bool bOK = false;
                    int iRow = cell.Row.Index;
                    int iColumn = cell.Column.Index;

                    if (e.KeyCode == Keys.Up)
                    {
                        iRow--;

                        if (iRow >= 0)
                        {
                            bOK = true;
                        }
                    }
                    else if (e.KeyCode == Keys.Down)
                    {
                        iRow++;

                        if (cell.Band.Index == 0)
                        {
                            if (iRow <= grid.Rows.Count - 1)
                            {
                                bOK = true;
                            }
                        }
                        else
                        {
                            if (iRow <= cell.Row.ParentRow.ChildBands[cell.Band.Key].Rows.Count - 1)
                            {
                                bOK = true;
                            }
                        }
                    }
                    else if (e.KeyCode == Keys.Left)
                    {
                        Hashtable htbl = new Hashtable();

                        int iCurr = cell.Column.RowLayoutColumnInfo.OriginX;

                        for (int i = 0; i < cell.Band.Columns.Count; i++)
                        {
                            if (!cell.Band.Columns[i].Hidden && cell.Band.Columns[i].RowLayoutColumnInfo.LabelPosition != LabelPosition.LabelOnly)
                            {
                                if (cell.Band.Columns[i].RowLayoutColumnInfo.OriginX < iCurr)
                                {
                                    if (!htbl.Contains(cell.Band.Columns[i].RowLayoutColumnInfo.OriginX))
                                    {
                                        htbl.Add(cell.Band.Columns[i].RowLayoutColumnInfo.OriginX, cell.Band.Columns[i].Index);
                                    }
                                }
                            }
                        }

                        if (GetHashtableMaxKeyValue(htbl, out iColumn))
                        {
                            bOK = true;
                        }
                    }
                    else if (e.KeyCode == Keys.Right)
                    {
                        Hashtable htbl = new Hashtable();

                        int iCurr = cell.Column.RowLayoutColumnInfo.OriginX;

                        for (int i = 0; i < cell.Band.Columns.Count; i++)
                        {
                            if (!cell.Band.Columns[i].Hidden && cell.Band.Columns[i].RowLayoutColumnInfo.LabelPosition != LabelPosition.LabelOnly)
                            {
                                if (cell.Band.Columns[i].RowLayoutColumnInfo.OriginX > iCurr)
                                {
                                    if (!htbl.Contains(cell.Band.Columns[i].RowLayoutColumnInfo.OriginX))
                                    {
                                        htbl.Add(cell.Band.Columns[i].RowLayoutColumnInfo.OriginX, cell.Band.Columns[i].Index);
                                    }
                                }
                            }
                        }

                        if (GetHashtableMinKeyValue(htbl, out iColumn))
                        {
                            bOK = true;
                        }
                    }

                    if (bOK)
                    {
                        if (cell.Band.Index == 0)
                        {
                            grid.ActiveCell = grid.Rows[iRow].Cells[iColumn];
                        }
                        else
                        {
                            grid.ActiveCell = cell.Row.ParentRow.ChildBands[cell.Band.Key].Rows[iRow].Cells[iColumn];
                        }
                        grid.PerformAction(UltraGridAction.EnterEditMode);
                    }
                }
            }
            catch { }
        }

        static void grid_DoubleClickCell(object sender, DoubleClickCellEventArgs e)
        {
            try
            {
                if (e.Cell.Row.HasChild())
                {
                    if (e.Cell.Row.IsExpanded)
                    {
                        e.Cell.Row.CollapseAll();
                    }
                    else
                    {
                        e.Cell.Row.ExpandAll();
                    }
                }
            }
            catch { }
        }

        #endregion

        public static bool IPCheck(string IP)
        {
            string Segment = @"(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)";
            return Regex.IsMatch(IP, ("^" + Segment + @"\." + Segment + @"\." + Segment + @"\." + Segment + "$"));
        }

        public static bool Pinging(string IP)
        {
            try
            {
                Ping ping = new Ping();
                PingOptions options = new PingOptions();
                options.DontFragment = true;
                byte[] buffer = Encoding.ASCII.GetBytes("TEST PING");
                PingReply reply = ping.Send(IP, 3000, buffer, options);

                if (reply.Status == IPStatus.Success)
                {
                    return true;
                }
            }
            catch { }

            return false;
        }

        public static bool CheckComboBoxSelection(UltraComboEditor cbEdit, string Caption, bool MustSelect, bool ShowError, out string Message)
        {
            Message = "";
            try
            {
                if (cbEdit != null)
                {
                    if (MustSelect)
                    {
                        if (cbEdit.SelectedIndex < 0)
                        {
                            Message = cbEdit.Text.Trim().Length > 0 ? Caption + "不正确，请从列表中选取！" : "请选择" + Caption + "！";

                            if (ShowError)
                            {
                                MessageBox.Show(Message, "提示", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
                            }

                            return false;
                        }
                    }
                    else
                    {
                        if (cbEdit.SelectedIndex < 0 && cbEdit.Text.Trim().Length > 0)
                        {
                            Message = Caption + "不正确，请从列表中选取！";

                            if (ShowError)
                            {
                                MessageBox.Show(Message, "提示", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
                            }

                            return false;
                        }
                    }
                }

                return true;
            }
            catch (Exception ex)
            {
                Message = Caption + "验证出错！\n" + ex.Message;

                if (ShowError)
                {
                    MessageBox.Show(Message, "提示", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
                }

                return false;
            }
        }

        public static void ResetHashtable(ref Hashtable htbl)
        {
            if (htbl == null)
            {
                htbl = new Hashtable();
            }
            else
            {
                htbl.Clear();
            }
        }

        public static void ResetArraylist(ref ArrayList alist)
        {
            if (alist == null)
            {
                alist = new ArrayList();
            }
            else
            {
                alist.Clear();
            }
        }

        public static ValueList GetClassTime(string strClass)
        {
            ValueList vlist = new ValueList();

            try
            {
                if (strClass == "1" || strClass == "2" || strClass == "3")
                {
                    int iHour = 0;

                    if (strClass == "1")
                    {
                        iHour = 8;
                    }
                    else if (strClass == "2")
                    {
                        iHour = 16;
                    }
                    else if (strClass == "3")
                    {
                        iHour = 0;
                    }

                    DateTime today = DateTime.Today.AddHours(iHour);

                    string strValue = "";

                    for (int i = 0; i < 8; i++)
                    {
                        strValue = today.AddHours(i).ToString("HH:mm") + "-" + today.AddHours(i + 1).AddMinutes(-1).ToString("HH:mm");
                        vlist.ValueListItems.Add(strValue, strValue);
                    }
                }
            }
            catch { }

            return vlist;
        }

        public static bool GetShift(string DatetimeExpression, out string Shift, OpeBase Ob)
        {
            string strInfo = "班次";
            string strSql = "select mes_lg_common.getlgshift1(" + DatetimeExpression + ") from dual";

            DataSet ds = GetDataCommon(strSql, strInfo, Ob);

            if (ds != null && ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
            {
                Shift = ds.Tables[0].Rows[0][0].ToString();
                return true;
            }

            Shift = "";
            return false;
        }

        public static void SetGridGroupBy(ref UltraGrid myGrid1, bool bAllowGroupBy)
        {
            try
            {
                if (!bAllowGroupBy)
                {
                    for (int i = 0; i < myGrid1.DisplayLayout.Bands[0].Columns.Count; i++)
                    {
                        try
                        {
                            if (myGrid1.DisplayLayout.Bands[0].Columns[i].IsGroupByColumn)
                                myGrid1.DisplayLayout.Bands[0].Columns[i].ResetIsGroupByColumn();
                        }
                        catch { }
                    }
                }
                myGrid1.DisplayLayout.GroupByBox.Hidden = !bAllowGroupBy;
            }
            catch { }
        }

        public static void SetUltraGridRowFilter(ref UltraGrid myGrid1, bool bAllowFilter)
        {
            try
            {
                if (bAllowFilter)
                {
                    if (myGrid1.DisplayLayout.Override.FilterUIType != FilterUIType.FilterRow)
                        myGrid1.DisplayLayout.Override.FilterUIType = FilterUIType.FilterRow;

                    for (int i = 0; i < myGrid1.DisplayLayout.Bands.Count; i++)
                    {
                        for (int j = 0; j < myGrid1.DisplayLayout.Bands[i].Columns.Count; j++)
                        {
                            try
                            {
                                if (!myGrid1.DisplayLayout.Bands[i].Columns[j].Hidden &&
                                    myGrid1.DisplayLayout.Bands[i].Columns[j].RowLayoutColumnInfo.LabelPosition != LabelPosition.LabelOnly)
                                    myGrid1.DisplayLayout.Bands[i].Columns[j].AllowRowFiltering = Infragistics.Win.DefaultableBoolean.True;
                            }
                            catch { }
                        }
                    }
                }
                else
                {
                    if (myGrid1.DisplayLayout.Override.FilterUIType != FilterUIType.HeaderIcons)
                        myGrid1.DisplayLayout.Override.FilterUIType = FilterUIType.HeaderIcons;

                    for (int i = 0; i < myGrid1.DisplayLayout.Bands.Count; i++)
                    {
                        try
                        {
                            myGrid1.DisplayLayout.Bands[i].ColumnFilters.ClearAllFilters();
                        }
                        catch { }

                        for (int j = 0; j < myGrid1.DisplayLayout.Bands[i].Columns.Count; j++)
                        {
                            try
                            {
                                myGrid1.DisplayLayout.Bands[i].Columns[j].AllowRowFiltering = Infragistics.Win.DefaultableBoolean.False;
                            }
                            catch { }
                        }
                    }
                }
            }
            catch { }
        }

        public static void SetUltraGridRowSort(ref UltraGrid myGrid1, bool bAllowSort)
        {
            try
            {
                if (bAllowSort)
                {
                    myGrid1.DisplayLayout.Override.HeaderClickAction = HeaderClickAction.SortMulti;
                }
                else
                {
                    for (int i = 0; i < myGrid1.DisplayLayout.Bands.Count; i++)
                    {
                        try
                        {
                            for (int j = 0; j < myGrid1.DisplayLayout.Bands[i].Columns.Count; j++)
                            {
                                myGrid1.DisplayLayout.Bands[i].Columns[j].SortIndicator = SortIndicator.None;
                            }
                        }
                        catch { }
                    }
                    myGrid1.DisplayLayout.Override.HeaderClickAction = HeaderClickAction.Default;
                }
            }
            catch { }
        }

        public static void SetStaticsInfoSum(ref UltraGrid myGrid1, ArrayList alistColumns, bool clearExists)
        {
            try
            {
                UltraGridBand band = myGrid1.DisplayLayout.Bands[0];
                if (clearExists)
                    band.Summaries.Clear();
                band.Override.SummaryFooterCaptionVisible = Infragistics.Win.DefaultableBoolean.False;

                for (int i = 0; i < alistColumns.Count; i++)
                {
                    try
                    {
                        SummarySettings summary = band.Summaries.Add(SummaryType.Sum, band.Columns[alistColumns[i].ToString()]);
                        summary.SummaryDisplayArea = SummaryDisplayAreas.BottomFixed;
                        summary.SummaryPosition = SummaryPosition.UseSummaryPositionColumn;
                        summary.DisplayFormat = "{0}";

                        summary.Appearance.TextHAlign = Infragistics.Win.HAlign.Right;
                        summary.Appearance.TextVAlign = Infragistics.Win.VAlign.Middle;
                        summary.Appearance.FontData.Bold = DefaultableBoolean.True;
                    }
                    catch { }
                }
            }
            catch { }
        }

        public static void SetUltraGridActiveCell(ref UltraGrid ultraGrid, int RowIndexNo, string ColumnName, bool EnterEditMode)
        {
            try
            {
                if (ultraGrid != null && RowIndexNo >= 0 && ultraGrid.Rows.Count >= RowIndexNo + 1)
                {
                    ultraGrid.ActiveCell = ultraGrid.Rows[RowIndexNo].Cells[ColumnName];

                    if (EnterEditMode)
                        ultraGrid.PerformAction(UltraGridAction.EnterEditMode);
                }
            }
            catch { }
        }

        public static string GetOracleDebugMethod(object[] ar)
        {
            string retstr = "";
            Int32 num = 1;
            //获取数组类型存储过程的 数组调试参数
            for (Int32 i = 0; i < ar.Length; i++)
            {
                if (ar[i] is ArrayList)
                {
                    retstr = retstr + "v" + num.ToString() + " str_ary_type:=new str_ary_type(";
                    for (Int32 s = 0; s < ((ArrayList)ar[i]).Count; s++)
                    {
                        retstr = retstr + "'" + ((ArrayList)ar[i])[s] + "',";
                    }

                    retstr = retstr.Substring(0, retstr.Length - 1) + ");\n";
                    num = num + 1;
                }
                else
                {
                    retstr = retstr + "v" + num.ToString() + " varchar2(50):= '" + ar[i].ToString() + "';\n";
                    num = num + 1;
                }
            }
            return retstr;
        }


    }
}