圖像采集，資料庫連接配接搜尋

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Linq;

using System.Text;

using System.Windows.Forms;

using System.Threading;

using System.IO;

using GxIAPINET;

using GxIAPINET.Sample.Common;

using System.Data.OleDb;

using System.Collections;

namespace GxSingleCam

{

public partial class GxSingleCam : Form

{

private OleDbConnection conn;

private OleDbDataAdapter da;

private DataSet ds;

bool                 m_bIsOpen                    = false;                           ///<裝置打開狀态
    bool                 m_bIsSnap                    = false;                           ///<發送開采指令辨別
    bool                 m_bTriggerMode               = false;                           ///<是否支援觸發模式
    bool                 m_bTriggerActive             = false;                           ///<是否支援觸發極性
    bool                 m_bTriggerSource             = false;                           ///<是否支援觸發源 
    bool                 m_bWhiteAuto                 = false;                           ///<辨別是否支援白平衡
    bool                 m_bBalanceRatioSelector      = false;                           ///<辨別是否支援白平衡通道
    bool                 m_bWhiteAutoSelectedIndex    = true;                            ///<白平衡清單框轉換标志
    IGXFactory           m_objIGXFactory              = null;                            ///<Factory對像
    IGXDevice            m_objIGXDevice               = null;                            ///<裝置對像
    IGXStream            m_objIGXStream               = null;                            ///<流對像
    IGXFeatureControl    m_objIGXFeatureControl       = null;                            ///<遠端裝置屬性控制器對像
    string               m_strBalanceWhiteAutoValue   = "Off";                           ///<自動白平衡目前的值
    GxBitmap             m_objGxBitmap                = null;                            ///<圖像顯示類對象
    string               m_strFilePath                = "";                              ///<應用程式目前路徑
   
    

    public GxSingleCam()
    {
        // 擷取應用程式的目前執行路徑
        m_strFilePath = Directory.GetCurrentDirectory().ToString();
        m_strFilePath = m_strFilePath + "\\GxSingleCamImages";

        //檢視是否存在此檔案
        if (!Directory.Exists(m_strFilePath))
        {
            Directory.CreateDirectory(m_strFilePath);
        }
        InitializeComponent();
    }
    //dakaishujuku
    private void opendata()
    {
        string connectionString = @"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=C:\Users\Administrator\Desktop\caiji1\data.mdb";
        string queryString = "SELECT ID, 底座編号,藥品名稱 FROM sheet1";
        this.conn = new OleDbConnection(connectionString);
        this.ds = new DataSet();
        this.ds.Tables.Add("sheet1");
        this.da = new OleDbDataAdapter(queryString, conn);
    }
    //填充清單框
    private void ListBoxFill()
    {
        if (this.ds.Tables[0].Rows != null) this.ds.Tables[0].Rows.Clear();
        this.listBoxEmployee.DataSource = null;
        this.listBoxEmployee.Items.Clear();
        this.da.Fill(ds, "sheet1");
        this.listBoxEmployee.DataSource = ds.Tables["sheet1"];
        this.listBoxEmployee.DisplayMember = "藥品名稱";
        this.listBoxEmployee.ValueMember = "ID";
    }

    /// <summary>
    /// 裝置打開後初始化界面
    /// </summary>
    private void __InitUI()
    {
        __InitEnumComBoxUI(m_cb_TriggerMode, "TriggerMode", m_objIGXFeatureControl, ref m_bTriggerMode);                      //觸發模式初始化
        __InitEnumComBoxUI(m_cb_TriggerSource, "TriggerSource", m_objIGXFeatureControl, ref m_bTriggerSource);                //觸發源初始化
        __InitEnumComBoxUI(m_cb_TriggerActivation, "TriggerActivation", m_objIGXFeatureControl, ref m_bTriggerActive);        //觸發極性初始化
        __InitShutterUI();                                                                                                    //曝光初始化
        __InitGainUI();                                                                                                       //增益的初始化
        __InitWhiteRatioUI();                                                                                                 //初始化白平衡系數相關控件
        __InitEnumComBoxUI(m_cb_AutoWhite, "BalanceWhiteAuto", m_objIGXFeatureControl, ref m_bWhiteAuto);                     //自動白平衡的初始化
        __InitEnumComBoxUI(m_cb_RatioSelector, "BalanceRatioSelector", m_objIGXFeatureControl, ref m_bBalanceRatioSelector);  //白平衡通道選擇


        //擷取白平衡目前的值
        bool bIsImplemented = false;             //是否支援
        bool bIsReadable = false;                //是否可讀
        // 擷取是否支援
        if (null != m_objIGXFeatureControl)
        {
            bIsImplemented = m_objIGXFeatureControl.IsImplemented("BalanceWhiteAuto");
            bIsReadable = m_objIGXFeatureControl.IsReadable("BalanceWhiteAuto");
            if (bIsImplemented)
            {
                if (bIsReadable)
                {
                    //擷取目前功能值
                    m_strBalanceWhiteAutoValue = m_objIGXFeatureControl.GetEnumFeature("BalanceWhiteAuto").GetValue();
                }
            }
        }
    }


    /// <summary>
    /// 對枚舉型變量按照功能名稱設定值
    /// </summary>
    /// <param name="strFeatureName">枚舉功能名稱</param>
    /// <param name="strValue">功能的值</param>
    /// <param name="objIGXFeatureControl">屬性控制器對像</param>
    private void __SetEnumValue(string strFeatureName, string strValue, IGXFeatureControl objIGXFeatureControl)
    {
        if (null != objIGXFeatureControl)
        {
            //設定目前功能值
            objIGXFeatureControl.GetEnumFeature(strFeatureName).SetValue(strValue);
        }
    }

    /// <summary>
    /// 枚舉型功能ComBox界面初始化
    /// </summary>
    /// <param name="cbEnum">ComboBox控件名稱</param>
    /// <param name="strFeatureName">枚舉型功能名稱</param>
    /// <param name="objIGXFeatureControl">屬性控制器對像</param>
    /// <param name="bIsImplemented">是否支援</param>
    private void __InitEnumComBoxUI(ComboBox cbEnum, string strFeatureName, IGXFeatureControl objIGXFeatureControl, ref bool bIsImplemented)
    {
        string strTriggerValue = "";                   //目前選擇項
        List<string> list = new List<string>();   //Combox将要填入的清單
        bool bIsReadable = false;                //是否可讀
        // 擷取是否支援
        if (null != objIGXFeatureControl)
        {

            bIsImplemented = objIGXFeatureControl.IsImplemented(strFeatureName);
            // 如果不支援則直接傳回
            if (!bIsImplemented)
            {
                return;
            }

            bIsReadable = objIGXFeatureControl.IsReadable(strFeatureName);

            if (bIsReadable)
            {
                list.AddRange(objIGXFeatureControl.GetEnumFeature(strFeatureName).GetEnumEntryList());
                //擷取目前功能值
                strTriggerValue = objIGXFeatureControl.GetEnumFeature(strFeatureName).GetValue();
            }

        }

        //清空組合框并更新資料到窗體
        cbEnum.Items.Clear();
        foreach (string str in list)
        {
            cbEnum.Items.Add(str);
        }

        //獲得相機值和枚舉到值進行比較，重新整理對話框
        for (int i = 0; i < cbEnum.Items.Count; i++)
        {
            string strTemp = cbEnum.Items[i].ToString();
            if (strTemp == strTriggerValue)
            {
                cbEnum.SelectedIndex = i;
                break;
            }
        }
    }

    /// <summary>
    /// 初始化白平衡系數相關控件
    /// </summary>
    private void __InitWhiteRatioUI()
    {
        double dWhiteRatio = 0.0;                       //目前曝光值
        double dMin = 0.0;                       //最小值
        double dMax = 0.0;                       //最大值
        string strUnit = "";                        //機關
        string strText = "";                        //顯示内容
        bool bIsBalanceRatio = false;                   //是否白平衡是否支援
        //擷取目前相機的白平衡系數、最小值、最大值和機關
        if (null != m_objIGXFeatureControl)
        {
            bIsBalanceRatio = m_objIGXFeatureControl.IsImplemented("BalanceRatio");
            if (!bIsBalanceRatio)
            {
                m_txt_BalanceRatio.Enabled = false; ;
                return;
            }
            dWhiteRatio = m_objIGXFeatureControl.GetFloatFeature("BalanceRatio").GetValue();
            dMin = m_objIGXFeatureControl.GetFloatFeature("BalanceRatio").GetMin();
            dMax = m_objIGXFeatureControl.GetFloatFeature("BalanceRatio").GetMax();
            strUnit = m_objIGXFeatureControl.GetFloatFeature("BalanceRatio").GetUnit();
        }

        //重新整理擷取白平衡系數範圍及機關到界面上
        strText = string.Format("白平衡系數({0}~{1}){2}", dMin.ToString("0.00"), dMax.ToString("0.00"), strUnit);
        m_lbl_WhiteRatio.Text = strText;

        //目前的白平衡系數的編輯框
        m_txt_BalanceRatio.Text = dWhiteRatio.ToString("0.00");
    }


    /// <summary>
    /// 曝光控制界面初始化
    /// </summary>
    private void __InitShutterUI()
    {
        double dCurShuter = 0.0;                       //目前曝光值
        double dMin = 0.0;                       //最小值
        double dMax = 0.0;                       //最大值
        string strUnit = "";                        //機關
        string strText = "";                        //顯示内容

        //擷取目前相機的曝光值、最小值、最大值和機關
        if (null != m_objIGXFeatureControl)
        {
            dCurShuter = m_objIGXFeatureControl.GetFloatFeature("ExposureTime").GetValue();
            dMin = m_objIGXFeatureControl.GetFloatFeature("ExposureTime").GetMin();
            dMax = m_objIGXFeatureControl.GetFloatFeature("ExposureTime").GetMax();
            strUnit = m_objIGXFeatureControl.GetFloatFeature("ExposureTime").GetUnit();
        }

        //重新整理曝光範圍及機關到界面上
        strText = string.Format("曝光時間({0}~{1}){2}", dMin.ToString("0.00"), dMax.ToString("0.00"), strUnit);
        m_lbl_Shutter.Text = strText;

        //目前的曝光值重新整理到曝光的編輯框
        m_txt_Shutter.Text = dCurShuter.ToString("0.00");
    }

    /// <summary>
    /// 增益控制界面初始化
    /// </summary>
    private void __InitGainUI()
    {
        double dCurGain = 0;             //目前增益值
        double dMin = 0.0;           //最小值
        double dMax = 0.0;           //最大值
        string strUnit = "";            //機關
        string strText = "";            //顯示内容

        //擷取目前相機的增益值、最小值、最大值和機關
        if (null != m_objIGXFeatureControl)
        {
            dCurGain = m_objIGXFeatureControl.GetFloatFeature("Gain").GetValue();
            dMin = m_objIGXFeatureControl.GetFloatFeature("Gain").GetMin();
            dMax = m_objIGXFeatureControl.GetFloatFeature("Gain").GetMax();
            strUnit = m_objIGXFeatureControl.GetFloatFeature("Gain").GetUnit();
        }

        //更新增益值範圍到界面
        strText = string.Format("增益({0}~{1}){2}", dMin.ToString("0.00"), dMax.ToString("0.00"), strUnit);
        m_lbl_Gain.Text = strText;

        //目前的增益值重新整理到增益的編輯框
        string strCurGain = dCurGain.ToString("0.00");
        m_txt_Gain.Text = strCurGain;
    }

    /// <summary>
    /// 更新界面
    /// </summary>
    void __UpdateUI()
    {
        //相機控制相關使能操作
        m_btn_OpenDevice.Enabled = !m_bIsOpen;
        m_btn_CloseDevice.Enabled = m_bIsOpen;
        m_btn_StartDevice.Enabled = m_bIsOpen && !m_bIsSnap;
        m_btn_StopDevice.Enabled = m_bIsSnap;

        //相機參數相關的使能操作
        m_cb_TriggerMode.Enabled = m_bIsOpen && m_bTriggerMode;
        m_cb_TriggerSource.Enabled = m_bIsOpen && m_bTriggerSource;
        m_cb_TriggerActivation.Enabled = m_bIsOpen && m_bTriggerActive;
        m_cb_RatioSelector.Enabled = m_bIsOpen && m_bBalanceRatioSelector;


        m_txt_Shutter.Enabled = m_bIsOpen;
        m_txt_Gain.Enabled = m_bIsOpen;
        m_txt_BalanceRatio.Enabled = m_bIsOpen
                                     && m_bBalanceRatioSelector
                                     && (m_strBalanceWhiteAutoValue == "Off");


        m_cb_AutoWhite.Enabled = m_bIsOpen && m_bWhiteAuto;
        m_btn_SoftTriggerCommand.Enabled = m_bIsOpen;
    }

    /// <summary>
    /// 相機初始化
    /// </summary>
    void __InitDevice()
    {
        if (null != m_objIGXFeatureControl)
        {
            //設定采集模式連續采集
            m_objIGXFeatureControl.GetEnumFeature("AcquisitionMode").SetValue("Continuous");
        }
    }

    /// <summary>
    /// 關閉流
    /// </summary>
    private void __CloseStream()
    {
        try
        {
            //關閉流
            if (null != m_objIGXStream)
            {
                m_objIGXStream.Close();
                m_objIGXStream = null;
            }
        }
        catch (Exception)
        {
        }
    }

    /// <summary>
    /// 關閉裝置
    /// </summary>
    private void __CloseDevice()
    {
        try
        {
            //關閉裝置
            if (null != m_objIGXDevice)
            {
                m_objIGXDevice.Close();
                m_objIGXDevice = null;
            }
        }
        catch (Exception)
        {
        }
    }

    /// <summary>
    /// 加載窗體執行初始化UI和庫
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void GxSingleCam_Load(object sender, EventArgs e)
    {
        try
        {
            //重新整理界面
            __UpdateUI();

            m_objIGXFactory = IGXFactory.GetInstance();
            m_objIGXFactory.Init();

        }
        catch (Exception ex)
        {
            MessageBox.Show(ex.Message);
        } 
    }

    /// <summary>
    /// 打開裝置打開流
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void m_btn_OpenDevice_Click(object sender, EventArgs e)
    {
        try
        {
            List<IGXDeviceInfo> listGXDeviceInfo = new List<IGXDeviceInfo>();

            //關閉流
            __CloseStream();
            // 如果裝置已經打開則關閉，保證相機在初始化出錯情況下能再次打開
            __CloseDevice();

            m_objIGXFactory.UpdateDeviceList(200, listGXDeviceInfo);

            // 判斷目前連接配接裝置個數
            if (listGXDeviceInfo.Count <= 0)
            {
                MessageBox.Show("未發現裝置!");
                return;
            }

            // 如果裝置已經打開則關閉，保證相機在初始化出錯情況下能再次打開
            if (null != m_objIGXDevice)
            {
                m_objIGXDevice.Close();
                m_objIGXDevice = null;
            }

            //打開清單第一個裝置

            m_objIGXDevice = m_objIGXFactory.OpenDeviceBySN(listGXDeviceInfo[0].GetSN(), GX_ACCESS_MODE.GX_ACCESS_EXCLUSIVE);
            m_objIGXFeatureControl = m_objIGXDevice.GetRemoteFeatureControl();


            //打開流
            if (null != m_objIGXDevice)
            {
                m_objIGXStream = m_objIGXDevice.OpenStream(0);
            }

            //初始化相機參數
            __InitDevice();

            // 擷取相機參數,初始化界面控件
            __InitUI();

            m_objGxBitmap = new GxBitmap(m_objIGXDevice, m_pic_ShowImage);

            // 更新裝置打開辨別
            m_bIsOpen = true;

            //重新整理界面
            __UpdateUI();

        }
        catch (Exception ex)
        {
            MessageBox.Show(ex.Message);
        } 
    }

    /// <summary>
    /// 關閉裝置關閉流
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void m_btn_CloseDevice_Click(object sender, EventArgs e)
    {
        try
        {
            try
            {
                // 如果未停采則先停止采集
                if (m_bIsSnap)
                {
                    if (null != m_objIGXFeatureControl)
                    {
                        m_objIGXFeatureControl.GetCommandFeature("AcquisitionStop").Execute();
                        m_objIGXFeatureControl = null;
                    }
                }
            }
            catch (Exception)
            {

            }

            m_bIsSnap = false;

            try
            {
                //停止流通道、登出采集回調和關閉流
                if (null != m_objIGXStream)
                {
                    m_objIGXStream.StopGrab();
                    //登出采集回調函數
                    m_objIGXStream.UnregisterCaptureCallback();
                    m_objIGXStream.Close();
                    m_objIGXStream = null;
                }
            }
            catch (Exception)
            {

            }

            try
            {
                //關閉裝置
                if (null != m_objIGXDevice)
                {
                    m_objIGXDevice.Close();
                    m_objIGXDevice = null;
                }
            }
            catch (Exception)
            {

            }

            m_bIsOpen = false;

            //重新整理界面
            __UpdateUI();
        }
        catch (Exception ex)
        {
            MessageBox.Show(ex.Message);
        } 
    }

    /// <summary>
    /// 開始采集
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void m_btn_StartDevice_Click(object sender, EventArgs e)
    {
        try
        {
            //開啟采集流通道
            if (null != m_objIGXStream)
            {
                //RegisterCaptureCallback第一個參數屬于使用者自定參數(類型必須為引用
                //類型)，若使用者想用這個參數可以在委托函數中進行使用
                m_objIGXStream.RegisterCaptureCallback(this, __CaptureCallbackPro);
                m_objIGXStream.StartGrab();
            }

            //發送開采指令
            if (null != m_objIGXFeatureControl)
            {
                m_objIGXFeatureControl.GetCommandFeature("AcquisitionStart").Execute();
            }
            m_bIsSnap = true;

            // 更新界面UI
            __UpdateUI();
        }
        catch (Exception ex)
        {
            MessageBox.Show(ex.Message);
        } 
    }

    /// <summary>
    /// 停止采集
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void m_btn_StopDevice_Click(object sender, EventArgs e)
    {
        try
        {

            //發送停采指令
            if (null != m_objIGXFeatureControl)
            {
                m_objIGXFeatureControl.GetCommandFeature("AcquisitionStop").Execute();
            }


            //關閉采集流通道
            if (null != m_objIGXStream)
            {
                m_objIGXStream.StopGrab();
                //登出采集回調函數
                m_objIGXStream.UnregisterCaptureCallback();
            }


            m_bIsSnap = false;

            // 更新界面UI
            __UpdateUI();
        }
        catch (Exception ex)
        {
            MessageBox.Show(ex.Message);
        } 
    }

    /// <summary>
    /// 圖像的顯示和存儲
    /// </summary>
    /// <param name="objIFrameData">圖像資訊對象</param>
    void ImageShowAndSave(IFrameData objIFrameData)
    {
        try
        {
            m_objGxBitmap.Show(objIFrameData);
        }
        catch (Exception)
        {
        }

        // 是否需要進行圖像儲存
        if (m_bSaveBmpImg.Checked)
        {
           string strlu = this.textBox1.Text;
            string stfFileName = m_strFilePath + "\\" + strlu + ".Png";  // 預設的圖像儲存名稱
            m_objGxBitmap.SaveBmp(objIFrameData, stfFileName);
        
        }
    }

    /// <summary>
    /// 回調函數,用于擷取圖像資訊和顯示圖像
    /// </summary>
    /// <param name="obj">使用者自定義傳入參數</param>
    /// <param name="objIFrameData">圖像資訊對象</param>
    private void __CaptureCallbackPro(object objUserParam, IFrameData objIFrameData)
    {
        try
        {
            GxSingleCam objGxSingleCam = objUserParam as GxSingleCam;
            objGxSingleCam.ImageShowAndSave(objIFrameData);
        }
        catch (Exception)
        {
        }
    }

    /// <summary>
    /// 切換"觸發模式"combox框響應函數
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void m_cb_TriggerMode_SelectedIndexChanged(object sender, EventArgs e)
    {
        try
        {
            string strValue = m_cb_TriggerMode.Text;
            __SetEnumValue("TriggerMode", strValue, m_objIGXFeatureControl);

            // 更新界面UI
            __UpdateUI();
        }
        catch (Exception ex)
        {
            MessageBox.Show(ex.Message);
        } 
    }

    /// <summary>
    /// 切換"觸發源"Combox消息響應函數
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void m_cb_TriggerSource_SelectedIndexChanged(object sender, EventArgs e)
    {
        try
        {
            string strValue = m_cb_TriggerSource.Text;
            __SetEnumValue("TriggerSource", strValue, m_objIGXFeatureControl);

            // 更新界面UI
            __UpdateUI();
        }
        catch (Exception ex)
        {
            MessageBox.Show(ex.Message);
        } 
    }

    /// <summary>
    /// 切換"觸發極性"Combox消息響應函數
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void m_cb_TriggerActivation_SelectedIndexChanged(object sender, EventArgs e)
    {
        try
        {
            string strValue = m_cb_TriggerActivation.Text;
            __SetEnumValue("TriggerActivation", strValue, m_objIGXFeatureControl);

            // 更新界面UI
            __UpdateUI();
        }
        catch (Exception ex)
        {
            MessageBox.Show(ex.Message);
        } 
    }


    /// <summary>
    /// 發送軟觸發指令
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void m_btn_SoftTriggerCommand_Click(object sender, EventArgs e)
    {
        try
        {
            //發送軟觸發指令
            if (null != m_objIGXFeatureControl)
            {
                m_objIGXFeatureControl.GetCommandFeature("TriggerSoftware").Execute();
            }

            // 更新界面UI
            __UpdateUI();
        }
        catch (Exception ex)
        {
            MessageBox.Show(ex.Message);
        } 
    }
 
   

    /// <summary>
    /*-----------------------------------------------------------------------
     * 當切換自動白平衡模式為Once時,裝置内部在設定完Once模式後會自動更新為off,
     * 為了與裝置狀态保持一緻,程式以代碼模拟該過程：判斷目前設定模式為Once後,
     * 将界面随即更新為off(由UpdateWhiteAutoUI()函數實作),但此過程會導緻函數
     * m_cb_AutoWhite_SelectedIndexChanged()執行兩次,第二次執行時自動白平衡
     * 選項已經更新為off,若重新執行可能會打斷Once的設定過程,引起白平衡不起作用,
     * 參數m_bWhiteAutoSelectedIndex即是為了解決函數重入問題而引入的變量
     ------------------------------------------------------------------------*/
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void m_cb_AutoWhite_SelectedIndexChanged(object sender, EventArgs e)
    {
        try
        {
            if (!m_bWhiteAutoSelectedIndex)
            {
                return;
            }
            string strValue = m_cb_AutoWhite.Text;
            __SetEnumValue("BalanceWhiteAuto", strValue, m_objIGXFeatureControl);
            m_strBalanceWhiteAutoValue = strValue;
            // 擷取白平衡系數更新界面
            __InitWhiteRatioUI();
            // 更新界面UI
            __UpdateUI();
        }
        catch (Exception ex)
        {
            MessageBox.Show(ex.Message);
        } 
    }

    /// <summary>
    /// 切換"白平衡通道"選項響應函數
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void m_cb_RatioSelector_SelectedIndexChanged(object sender, EventArgs e)
    {
        try
        {
            string strValue = m_cb_RatioSelector.Text;
            __SetEnumValue("BalanceRatioSelector", strValue, m_objIGXFeatureControl);
            // 擷取白平衡系數更新界面
            __InitWhiteRatioUI();
        }
        catch (Exception ex)
        {
            MessageBox.Show(ex.Message);
        } 
    }

    /// <summary>
    /// 窗體關閉、關閉流、關閉裝置、反初始化
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void GxSingleCam_FormClosed(object sender, FormClosedEventArgs e)
    {
        try
        {
            // 如果未停采則先停止采集
            if (m_bIsSnap)
            {
                if (null != m_objIGXFeatureControl)
                {
                    m_objIGXFeatureControl.GetCommandFeature("AcquisitionStop").Execute();
                }
            }
        }
        catch (Exception)
        {

        }

        try
        {
            //停止流通道、登出采集回調和關閉流
            if (null != m_objIGXStream)
            {
                m_objIGXStream.StopGrab();
                m_objIGXStream.UnregisterCaptureCallback();
                m_objIGXStream.Close();
                m_objIGXStream = null;
            }
        }
        catch (Exception)
        {

        }

        try
        {
            //關閉裝置
            if (null != m_objIGXDevice)
            {
                m_objIGXDevice.Close();
                m_objIGXDevice = null;
            }
        }
        catch (Exception)
        {

        }
       
        try
        {
            //反初始化
            if (null != m_objIGXFactory)
            {
                m_objIGXFactory.Uninit();
            }
        }
        catch (Exception)
        {

        }
    }

    /// <summary>
    /// 檢查是否輸入的是小數或整數，小數要求小數點最多8位
    /// </summary>
    /// <param name="sender">控件對象</param>
    /// <param name="e">按鍵響應事件</param>
    private void __CheckKeyPress(object sender, KeyPressEventArgs e)
    {
        if (!(((e.KeyChar >= '0') && (e.KeyChar <= '9')) || e.KeyChar <= 31))
        {
            if (e.KeyChar == '.')
            {
                if (((TextBox)sender).Text.Trim().IndexOf('.') > -1)
                    e.Handled = true;
            }
            else
                e.Handled = true;
        }
        else
        {
            if (e.KeyChar <= 31)
            {
                e.Handled = false;
            }
            else if (((TextBox)sender).Text.Trim().IndexOf('.') > -1)
            {
                if (((TextBox)sender).Text.Trim().Substring(((TextBox)sender).Text.Trim().IndexOf('.') + 1).Length >= 8)
                    e.Handled = true;
            }
        }
    }

    /// <summary>
    /// 判斷曝光結束事件是否輸入的是小數或整數
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void m_txt_Shutter_KeyPress(object sender, KeyPressEventArgs e)
    {
        __CheckKeyPress(sender, e);
    }

    /// <summary>
    /// 判斷增益是否輸入的是小數或整數
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void m_txt_Gain_KeyPress(object sender, KeyPressEventArgs e)
    {
        __CheckKeyPress(sender, e);
    }

    /// <summary>
    /// 判斷白平衡系數是否輸入的是小數或整數
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void m_txt_BalanceRatio_KeyPress(object sender, KeyPressEventArgs e)
    {
        __CheckKeyPress(sender, e);
    }

    /// <summary>
    /// 判斷是否有回車按下
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void GxSingleCam_KeyDown(object sender, KeyEventArgs e)
    {
        if (e.KeyCode == Keys.Return)
        {
            this.m_pic_ShowImage.Focus();
        }
    }

    /// <summary>
    /// 控制曝光時間的Edit框失去焦點的響應函數
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void m_txt_Shutter_Leave(object sender, EventArgs e)
    {
        double dShutterValue = 0.0;              //曝光值
        double dMin = 0.0;                       //最小值
        double dMax = 0.0;                       //最大值

        try
        {
            try
            {
                dShutterValue = Convert.ToDouble(m_txt_Shutter.Text);
            }
            catch (Exception)
            {
                __InitShutterUI();
                MessageBox.Show("請輸入正确的曝光時間");
                return;
            }

            //擷取目前相機的曝光值、最小值、最大值和機關
            if (null != m_objIGXFeatureControl)
            {
                dMin = m_objIGXFeatureControl.GetFloatFeature("ExposureTime").GetMin();
                dMax = m_objIGXFeatureControl.GetFloatFeature("ExposureTime").GetMax();
                //判斷輸入值是否在曝光時間的範圍内
                //若大于最大值則将曝光值設為最大值
                if (dShutterValue > dMax)
                {
                    dShutterValue = dMax;
                }
                //若小于最小值将曝光值設為最小值
                if (dShutterValue < dMin)
                {
                    dShutterValue = dMin;
                }

                m_txt_Shutter.Text = dShutterValue.ToString("F2");
                m_objIGXFeatureControl.GetFloatFeature("ExposureTime").SetValue(dShutterValue);
            }
        }
        catch (Exception ex)
        {
            MessageBox.Show(ex.Message);
        } 
    }

    /// <summary>
    /// 控制增益值的Edit框失去焦點的響應函數
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void m_txt_Gain_Leave(object sender, EventArgs e)
    {
        double dGain = 0;            //增益值
        double dMin = 0.0;           //最小值
        double dMax = 0.0;           //最大值
        try
        {
            try
            {
                dGain = Convert.ToDouble(m_txt_Gain.Text);
            }
            catch (Exception)
            {
                __InitGainUI();
                MessageBox.Show("請輸入正确的增益值");
                return;
            }

            //目前相機的增益值、最小值、最大值
            if (null != m_objIGXFeatureControl)
            {
                dMin = m_objIGXFeatureControl.GetFloatFeature("Gain").GetMin();
                dMax = m_objIGXFeatureControl.GetFloatFeature("Gain").GetMax();

                //判斷輸入值是否在增益值的範圍内
                //若輸入的值大于最大值則将增益值設定成最大值
                if (dGain > dMax)
                {
                    dGain = dMax;
                }

                //若輸入的值小于最小值則将增益的值設定成最小值
                if (dGain < dMin)
                {
                    dGain = dMin;
                }

                m_txt_Gain.Text = dGain.ToString("F2");
                m_objIGXFeatureControl.GetFloatFeature("Gain").SetValue(dGain);
            }
        }
        catch (Exception ex)
        {
            MessageBox.Show(ex.Message);
        } 
    }

    /// <summary>
    /// "白平衡系數"Edit框失去焦點響應函數
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void m_txt_BalanceRatio_Leave(object sender, EventArgs e)
    {
        double dBalanceRatio = 0;    //白平衡系數值
        double dMin = 0.0;           //最小值
        double dMax = 0.0;           //最大值
        try
        {
            try
            {
                dBalanceRatio = Convert.ToDouble(m_txt_BalanceRatio.Text);
            }
            catch (Exception)
            {
                __InitWhiteRatioUI();
                MessageBox.Show("請輸入正确的白平衡系數");
                return;
            }

            //目前相機的白平衡系數值、最小值、最大值
            if (null != m_objIGXFeatureControl)
            {
                dMin = m_objIGXFeatureControl.GetFloatFeature("BalanceRatio").GetMin();
                dMax = m_objIGXFeatureControl.GetFloatFeature("BalanceRatio").GetMax();

                //判斷輸入值是否在白平衡系數的範圍内
                //若大于最大值則将白平衡系數設為最大值
                if (dBalanceRatio > dMax)
                {
                    dBalanceRatio = dMax;
                }
                //若小于最小值将白平衡系數設為最小值
                if (dBalanceRatio < dMin)
                {
                    dBalanceRatio = dMin;
                }

                m_txt_BalanceRatio.Text = dBalanceRatio.ToString("F2");
                m_objIGXFeatureControl.GetFloatFeature("BalanceRatio").SetValue(dBalanceRatio);
            }
        }
        catch (Exception ex)
        {
            MessageBox.Show(ex.Message);
        } 
    }

    /// <summary>
    /// 更新自動白平衡從Once到off
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void m_timer_UpdateAutoWhite_Tick(object sender, EventArgs e)
    {
        try
        {
            string strValue = ""; //自動白平衡值
            Int32 i = 0;          //循環變量

            // 如果自動白平衡方式為Once,設定成功後實際的白平衡方式會自動變為off
            // 為與裝置狀态保持一緻程式以代碼模拟該過程：設定為Once後随即将界面更新為off
            if (m_strBalanceWhiteAutoValue == "Once")
            {
                try
                {
                    //擷取自動白平衡枚舉值
                    if (null != m_objIGXFeatureControl)
                    {
                        strValue = m_objIGXFeatureControl.GetEnumFeature("BalanceWhiteAuto").GetValue();
                    }
                }
                catch (Exception)
                {
                }
                m_strBalanceWhiteAutoValue = strValue;

                if (m_strBalanceWhiteAutoValue == "Off")
                {
                    for (i = 0; i < m_cb_AutoWhite.Items.Count; i++)
                    {
                        if (m_cb_AutoWhite.Items[i].ToString() == "Off")
                        {
                            m_cb_AutoWhite.SelectedIndex = i;
                            break;
                        }
                    }
                    __UpdateUI();
                }
            }
        }
        catch (Exception)
        {
        }
    }

    private void openbutton_Click_1(object sender, EventArgs e)
    {
        this.opendata();

        //tianchong
        this.ListBoxFill();
    }

    public string mess;
    private void surebutton_Click_1(object sender, EventArgs e)
    {
        textBox1.Text = string.Empty;
        string strcon = @"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=C:\Users\Administrator\Desktop\caiji1\data.mdb";
        using (OleDbConnection conn1 = new OleDbConnection(strcon))
        {
            conn1.Open();
            OleDbCommand cmd = conn1.CreateCommand();

            mess = listBoxEmployee.SelectedValue.ToString();
            cmd.CommandText = "SELECT ID, 藥品名稱 FROM Sheet1 WHERE  ID=" + mess;
            OleDbDataReader reader = cmd.ExecuteReader();
            string data="";
            while (reader.Read())
            {
                 data= string.Format("{0} {1}\r\n", reader[0], reader[1]);
                
            }
             this.textBox1.Text = data;
             reader.Close();
            

            //mess = listBoxEmployee.SelectedValue.ToString();
            //cmd.CommandText = "SELECT ID, 藥品名稱 FROM Sheet1 WHERE  藥品名稱=" + mess;
            //OleDbDataReader reader = cmd.ExecuteReader();
            //string data = "ID藥品名稱\r\n";
            //while (reader.Read())
            //{
            //    data = string.Format("{0} {1}\r\n", reader[0], reader[1]);
            //}
            //this.textBox1.Text = data;
            //reader.Close();
        }
    }

    //private void listBoxEmployee_SelectedIndexChanged_1(object sender, EventArgs e)
    //{
    //    textBox1.Clear();
    //}

}
           

}