Пример #1
0
        // apply column information to a grid
        // this will set the column positions, caption, format, and visibility
        // (any columns not included in the 'columns' array will not be displayed
        private void SetupColumns(C1FlexDataTree grid, string[] columns)
        {
            // initialize column position
            int position = grid.Cols.Fixed;

            // apply column information
            foreach (string s in columns)
            {
                // split column info (name, caption, format)
                string[] columnInfo = s.Split(',');

                // move column to proper position based on its name
                Column column = grid.Cols[columnInfo[0].Trim()];
                column.Move(position);
                position++;

                // apply caption
                if (columnInfo.Length > 1)
                {
                    column.Caption = columnInfo[1].Trim();
                }

                // apply format
                if (columnInfo.Length > 2)
                {
                    column.Format = columnInfo[2].Trim();
                }
            }

            // hide all other columns
            for (int i = position; i < grid.Cols.Count; i++)
            {
                grid.Cols[i].Visible = false;
            }
        }
Пример #2
0
        // update position of child grids when size changes
        //
        // when the grid is resized, move child grids so they
        // stay in their proper position.
        //
        override protected void OnSizeChanged(EventArgs e)
        {
            // always call base implementation
            base.OnSizeChanged(e);

            // if this is the top-level grid, update position of child grids
            C1FlexDataTree parent = Parent as C1FlexDataTree;

            if (parent == null)
            {
                UpdateChildren();
            }
        }
Пример #3
0
        // customize grid display to show selected columns, captions, formats, and data maps
        private void _flex_SetupColumns(object sender, System.EventArgs e)
        {
            // get grid that was just bound
            C1FlexDataTree grid = sender as C1FlexDataTree;

            if (grid == null)
            {
                return;
            }

            // get data source name
            ITypedList itl = grid.DataSource as ITypedList;

            if (itl == null)
            {
                return;
            }
            string tableName = itl.GetListName(null);

            // look up table in data set
            // (the table has formatting information in its ExtendedProperties)
            DataTable dt = _ds.Tables[tableName];

            // apply custom column order, captions, format
            string[] columns = dt.ExtendedProperties["ShowColumns"] as string[];
            if (columns != null)
            {
                SetupColumns(grid, columns);
            }

            // apply custom data maps
            foreach (Column gridColumn in grid.Cols)
            {
                DataColumn dataColumn = dt.Columns[gridColumn.Name];
                if (dataColumn == null)
                {
                    continue;
                }
                gridColumn.DataMap = dataColumn.ExtendedProperties["DataMap"] as IDictionary;
                if (gridColumn.DataMap != null)
                {
                    gridColumn.TextAlign = TextAlignEnum.LeftCenter;
                }
            }

            // all done, auto size to show mapped data
            grid.AutoSizeCols(1, grid.Cols.Count - 1, 12);
        }
Пример #4
0
 private void ApplyParentStyles(C1FlexDataTree parent)
 {
     if (parent != null)
     {
         ShowCursor  = parent.ShowCursor;
         AllowAddNew = parent.AllowAddNew;
         AllowDelete = parent.AllowDelete;
         BorderStyle = parent.BorderStyle;
         Styles.ParseString(parent.Styles.BuildString(true));
         foreach (GlyphEnum g in Enum.GetValues(typeof(GlyphEnum)))
         {
             Glyphs[g] = parent.Glyphs[g];
         }
         Cols[0].Width = parent.Cols[0].WidthDisplay;
     }
 }
Пример #5
0
        // update position of this child grid within its parent.
        // this is called by the UpdateChildren method above and also
        // when child grids are created.
        private void UpdatePosition()
        {
            // sanity
            C1FlexDataTree parent    = Parent as C1FlexDataTree;
            Row            parentRow = Tag as Row;

            if (parent == null || parentRow == null)
            {
                return;
            }

            // get cell rectangle
            int       row = parentRow.Index;
            Rectangle rc  = parent.GetCellRectDisplay(row, 0);

            // calculate child location and client size
            rc.X      = rc.Right;
            rc.Y      = rc.Bottom;
            rc.Width  = Cols[Cols.Count - 1].Right;
            rc.Height = Rows[Rows.Count - 1].Bottom;

            // make sure child grid width doesn't extend past parent client width
            int maxRight = parent.ClientSize.Width - 2;

            if (rc.Right > maxRight)
            {
                rc.Width = maxRight - rc.X;
            }

            // update size/position
            if (Location != rc.Location)
            {
                Location = rc.Location;
            }
            if (ClientSize != rc.Size)
            {
                ClientSize = rc.Size;
            }

            // update height of container row
            var updateRowIndex = row + 1;

            if (parent.Rows.Count > updateRowIndex)
            {
                parent.Rows[updateRowIndex].Height = Height;
            }
        }
Пример #6
0
        // update size/position of all child grids and of this grid within this parent.
        // this is called when the grid scrolls, when it's size changes, and when
        // rows or columns are added, removed, or resized.
        private void UpdateChildren()
        {
            try
            {
                // update position of all children
                for (int row = 0; row < Rows.Count; row++)
                {
                    C1FlexDataTree child = Rows[row].UserData as C1FlexDataTree;
                    if (child != null)
                    {
                        child.UpdatePosition();
                    }
                }
            }
            catch
            {
            }

            // and update position of this grid within its parent
            UpdatePosition();
        }
Пример #7
0
        // keep track of column with child information (if any)
        //
        // when the grid receives a Refresh notification from the DataSource,
        // scan the columns looking for subordinate tables, and keep track of
        // the column so we can draw the collapse/expand icons and bind the
        // child grids to the subordinate tables.
        //
        // note: this implementation keeps only one detail column per table.
        // if the master table contains several detail columns, the grid will
        // only show the first subordinate column. e.g. a Client table with
        // ClientOrders and ClientDetails would expand to show ClientOrders
        // only.
        //
        override protected void OnDataRefresh(ListChangedEventArgs e)
        {
            // always call base implementation
            base.OnDataRefresh(e);

            // only want the Reset event
            if (e.ListChangedType != ListChangedType.Reset)
            {
                return;
            }

            // clear any existing children
            for (int i = 0; i < Controls.Count; i++)
            {
                C1FlexDataTree childGrid = Controls[i] as C1FlexDataTree;
                if (childGrid != null)
                {
                    Controls.Remove(childGrid);
                    i--;
                }
            }

            // keep track of hierarchical column
            _colChild = null;
            foreach (Column col in Cols)
            {
                Type type = col.DataType;
                if (type != null && typeof(IList).IsAssignableFrom(type) && type != typeof(byte[]))
                {
                    _colChild = col;
                    break;
                }
            }

            // fire event to allow customization of master/child grids
            ParentGrid.OnSetupColumns(this);
        }
Пример #8
0
        // expand/collapse child grid
        //
        // if the user clicks the icons (drawn in the method above), either
        // create a child grid (and bind it to the detail records), or remove
        // the existing one.
        //
        override protected void OnBeforeMouseDown(BeforeMouseDownEventArgs e)
        {
            // always call base implementation
            base.OnBeforeMouseDown(e);

            // check that it's the Left button and that we have a hierarchy
            if (e.Button != MouseButtons.Left || _colChild == null)
            {
                return;
            }

            // check that it's a row header cell
            HitTestInfo hit = HitTest(e.X, e.Y);

            if (hit.Type != HitTestTypeEnum.RowHeader || hit.Row < Rows.Fixed)
            {
                return;
            }

            // check that the click was over the collapse/expand icon
            if (e.X < Cols[0].Right - (Glyphs[GlyphEnum.Collapsed].Width + 4) || _colChild[hit.Row] == null)
            {
                return;
            }

            // all checks OK, cancel click before proceeding
            e.Cancel = true;
            Select(hit.Row, Cols.Fixed, hit.Row, Cols.Count - 1, false);

            // create and show child grid
            if (Rows[hit.Row].UserData == null)
            {
                // create child grid
                C1FlexDataTree childGrid = new C1FlexDataTree();
                childGrid.Visible    = false;
                childGrid.ScrollBars = ScrollBars.Horizontal;

                // attach child grid to parent, set data source
                Controls.Add(childGrid);

                childGrid.ApplyParentStyles(this);
                childGrid.DataSource = _colChild[hit.Row];

                // save references:
                // child grid Tag property contains a reference to the parent row
                // parent row UserData contains a reference to the child grid
                childGrid.Tag          = Rows[hit.Row];
                Rows[hit.Row].UserData = childGrid;

                // add node row (unbound) to display child
                Rows.InsertNode(hit.Row + 1, -1);

                // move child grid into position, make it visible
                childGrid.UpdatePosition();
                childGrid.Visible = true;
                childGrid.Focus();
            }
            else             // hide and delete child grid
            {
                // get child grid
                C1FlexDataTree childGrid = (C1FlexDataTree)Rows[hit.Row].UserData;

                // break references
                Rows[hit.Row].UserData = null;
                childGrid.Tag          = null;

                // clear child and remove it from parent
                childGrid.Controls.Clear();
                Controls.Remove(childGrid);

                // delete container row
                var removeRowIndex = hit.Row + 1;
                if (Rows.Count > removeRowIndex)
                {
                    Rows.Remove(removeRowIndex);
                }
            }
        }