///<summary>
        /// FilterScan
        ///</summary>
        ///<param name="gridColumn"></param>
        public FilterScan(GridColumn gridColumn)
        {
            _GridColumn = gridColumn;

            _OnScanComplete = new EventHandler(OnScanComplete);
            _ScanListDelegate = new ScanListDelegate(AddScanItems);
        }

        ///<summary>
        /// CustomFilter
        ///</summary>
        public CustomFilter(GridPanel gridPanel, GridColumn gridColumn, string filterText)
        {
            _GridPanel = gridPanel;
            _GridColumn = gridColumn;

            InitializeComponent();
            InitializeText();
            InitializeFilter(filterText);

            PositionWindow(_GridPanel.SuperGrid);
        }

        private string GetColumnText(GridColumn col, int index)
        {
            string s = index + " ";

            if (string.IsNullOrEmpty(col.Name) == false)
                return (s + "-" + col.Name);

            if (string.IsNullOrEmpty(col.HeaderText) == false)
                return (s + "-" + col.HeaderText);

            return (s);
        }

        ///<summary>
        /// CustomFilter
        ///</summary>
        public CustomFilterEx(GridPanel gridPanel,
            GridColumn gridColumn, string filterText)
        {
            _GridPanel = gridPanel;
            _GridColumn = gridColumn;

            InitializeComponent();
            InitializeText();
            InitializeFilter(filterText);

            PositionWindow(_GridPanel.SuperGrid);

            FormClosing += CustomFilterExFormClosing;

            filterExprEdit1.InputTextChanged += FilterExprEdit1InputTextChanged;
        }

        /// <summary>
        /// Handles invocation of FilterEndEdit events
        /// </summary>
        internal void DoFilterEndEditEvent(GridColumn column)
        {
            if (FilterEndEdit != null)
            {
                GridFilterEndEditEventArgs ev = new
                    GridFilterEndEditEventArgs(column.GridPanel, column);

                FilterEndEdit(this, ev);
            }
        }

        static internal void RenderCheckBox(
            Graphics g, GridFilter gf, GridColumn column, Rectangle bounds)
        {
            object value = column.FilterValue;

            if (_sizeCheckBox == null)
            {
                _sizeCheckBox = new MyCheckBoxX();

                _sizeCheckBox.Text = "";
                _sizeCheckBox.BackColor = Color.Transparent;
            }

            _sizeCheckBox.Enabled = false;
            _sizeCheckBox.Size = new Size(20, 20);
            _sizeCheckBox.BackColor = GetSimpleColor(gf.GetEffectiveStyle(column));

            if (value is CheckState)
                _sizeCheckBox.CheckState = (CheckState)value;
            else
                _sizeCheckBox.CheckState = CheckState.Indeterminate;

            Rectangle r = new Rectangle(0, 0, 20, 20);

            using (Bitmap bm = new Bitmap(20, 20))
            {
                _sizeCheckBox.DrawToBitmap(bm, r);

                Rectangle t = bounds;

                if (bounds.Width > r.Width)
                {
                    t.X += (t.Width - r.Width - 1) / 2;
                    t.Width = r.Width;
                }

                if (bounds.Height > r.Height)
                {
                    t.Y += (t.Height - r.Height) / 2;
                    t.Height = r.Height;
                }

                g.DrawImage(bm, t);
            }
        }

        /// <summary>
        /// Handles invocation of PreRenderFilterRowEvent events
        /// </summary>
        internal bool DoPreRenderFilterRowEvent(Graphics g,
            GridFilter filter, GridColumn column, RenderParts parts, Rectangle bounds)
        {
            if (PreRenderFilterRow != null)
            {
                GridPanel panel = filter.GridPanel;

                GridPreRenderFilterRowEventArgs ev = new
                    GridPreRenderFilterRowEventArgs(g, panel, filter, column, parts, bounds);

                PreRenderFilterRow(this, ev);

                return (ev.Cancel);
            }

            return (false);
        }

        /// <summary>
        /// Handles invocation of PreRenderFilterPopupGripBar events
        /// </summary>
        internal bool DoPreRenderFilterPopupGripBarEvent(
            Graphics g, FilterPopup filterPopup, GridColumn gridColumn, Rectangle bounds)
        {
            if (PreRenderFilterPopupGripBar != null)
            {
                GridPreRenderFilterPopupGripBarEventArgs ev = new
                    GridPreRenderFilterPopupGripBarEventArgs(g, filterPopup, gridColumn, bounds);

                PreRenderFilterPopupGripBar(this, ev);

                return (ev.Cancel);
            }

            return (false);
        }

        /// <summary>
        /// Handles invocation of FilterPopupOpening events
        /// </summary>
        internal bool DoFilterPopupOpeningEvent(GridColumn column, FilterPopup filterPopup)
        {
            if (FilterPopupOpening != null)
            {
                GridFilterPopupOpeningEventArgs ev = new
                    GridFilterPopupOpeningEventArgs(column.GridPanel, column, filterPopup);

                FilterPopupOpening(this, ev);

                return (ev.Cancel);
            }

            return (false);
        }

        /// <summary>
        /// Handles invocation of FilterPopupLoaded events
        /// </summary>
        internal void DoFilterPopupLoadedEvent(GridColumn column, FilterPopup filterPopup)
        {
            if (FilterPopupLoaded != null)
            {
                GridFilterPopupLoadedEventArgs ev = new
                    GridFilterPopupLoadedEventArgs(column.GridPanel, column, filterPopup);

                FilterPopupLoaded(this, ev);
            }
        }

        /// <summary>
        /// Handles invocation of FilterLoadItems events
        /// </summary>
        internal bool DoFilterLoadItemsEvent(GridColumn column, ComboBoxEx comboBox)
        {
            if (FilterLoadItems != null)
            {
                GridFilterLoadItemsEventArgs ev = new
                    GridFilterLoadItemsEventArgs(column.GridPanel, column, comboBox);

                FilterLoadItems(this, ev);

                return (ev.Cancel);
            }

            return (false);
        }

        /// <summary>
        /// Handles invocation of FilterItemsLoaded events
        /// </summary>
        internal void DoFilterItemsLoadedEvent(GridColumn column, ComboBoxEx comboBox)
        {
            if (FilterItemsLoaded != null)
            {
                GridFilterItemsLoadedEventArgs ev = new
                    GridFilterItemsLoadedEventArgs(column.GridPanel, column, comboBox);

                FilterItemsLoaded(this, ev);
            }
        }

        /// <summary>
        /// Handles invocation of FilterHelpOpening events
        /// </summary>
        internal bool DoFilterHelpOpeningEvent(GridPanel panel, GridColumn column, SampleExpr sampleExpr)
        {
            if (FilterHelpOpening != null)
            {
                GridFilterHelpOpeningEventArgs ev = new
                    GridFilterHelpOpeningEventArgs(panel, column, sampleExpr);

                FilterHelpOpening(this, ev);

                return (ev.Cancel);
            }

            return (false);
        }

        /// <summary>
        /// Handles invocation of FilterHelpClosing events
        /// </summary>
        internal void DoFilterHelpClosingEvent(GridPanel panel, GridColumn column, SampleExpr sampleExpr)
        {
            if (FilterHelpClosing != null)
            {
                GridFilterHelpClosingEventArgs ev = new
                    GridFilterHelpClosingEventArgs(panel, column, sampleExpr);

                FilterHelpClosing(this, ev);
            }
        }

        /// <summary>
        /// Handles invocation of FilterHeaderClick events
        /// </summary>
        internal bool DoFilterHeaderClickEvent(
            GridPanel gridPanel, GridColumn gridColumn, MouseEventArgs e)
        {
            if (FilterHeaderClick != null)
            {
                GridFilterHeaderClickEventArgs ev = new
                    GridFilterHeaderClickEventArgs(gridPanel, gridColumn, e);

                FilterHeaderClick(this, ev);

                return (ev.Cancel);
            }

            return (false);
        }

        /// <summary>
        /// Handles invocation of PreRenderColumnHeaderEvent events
        /// </summary>
        internal bool DoPreRenderColumnHeaderEvent(Graphics g,
            GridColumnHeader header, GridColumn column, RenderParts parts, Rectangle bounds)
        {
            if (PreRenderColumnHeader != null)
            {
                GridPanel panel = header.GridPanel;

                GridPreRenderColumnHeaderEventArgs ev = new
                    GridPreRenderColumnHeaderEventArgs(g, panel, header, column, parts, bounds);

                PreRenderColumnHeader(this, ev);

                return (ev.Cancel);
            }

            return (false);
        }

        /// <summary>
        /// Handles invocation of PostRenderFilterPopupGripBar events
        /// </summary>
        internal void DoPostRenderFilterPopupGripBarEvent(
            Graphics g, FilterPopup filterPopup, GridColumn gridColumn, Rectangle bounds)
        {
            if (PostRenderFilterPopupGripBar != null)
            {
                GridPostRenderFilterPopupGripBarEventArgs ev = new
                    GridPostRenderFilterPopupGripBarEventArgs(g, filterPopup, gridColumn, bounds);

                PostRenderFilterPopupGripBar(this, ev);
            }
        }

        /// <summary>
        /// Handles invocation of FilterPopupValueChanged events
        /// </summary>
        internal bool DoFilterPopupValueChangedEvent(GridColumn column, FilterItemType filterItemType,
            ref object filterValue, ref object filterDisplayValue, ref string filterExpr)
        {
            if (FilterPopupValueChanged != null)
            {
                GridFilterPopupValueChangedEventArgs ev = 
                    new GridFilterPopupValueChangedEventArgs(column.GridPanel,
                    column, filterItemType, filterValue, filterDisplayValue, filterExpr);

                FilterPopupValueChanged(this, ev);

                filterValue = ev.FilterValue;
                filterDisplayValue = ev.FilterDisplayValue;
                filterExpr = ev.FilterExpr;

                return (ev.Cancel);
            }

            return (false);
        }

        /// <summary>
        /// Handles invocation of PostRenderFilterRow events
        /// </summary>
        internal void DoPostRenderFilterRowEvent(Graphics g,
            GridFilter filter, GridColumn column, RenderParts parts, Rectangle bounds)
        {
            if (PostRenderFilterRow != null)
            {
                GridPanel panel = filter.GridPanel;

                GridPostRenderFilterRowEventArgs ev = new
                    GridPostRenderFilterRowEventArgs(g, panel, filter, column, parts, bounds);

                PostRenderFilterRow(this, ev);
            }
        }

        /// <summary>
        /// Handles invocation of GetFilterEditType events
        /// </summary>
        internal void DoGetFilterEditTypeEvent(
            GridColumn gridColumn, ref FilterEditType filterType)
        {
            if (GetFilterEditType != null)
            {
                GridGetFilterEditTypeEventArgs ev = new
                    GridGetFilterEditTypeEventArgs(gridColumn.GridPanel, gridColumn, filterType);

                GetFilterEditType(this, ev);

                filterType = ev.FilterEditType;
            }
        }