Esempio n. 1
0
        /// <summary>
        /// Append an item to it's parent and update the layout
        /// </summary>
        /// <param name="grid"></param>
        /// <param name="item"></param>
        public void AppendItemToGrid(Grid grid, TreeGridItem item)
        {
            RowDefinition row = new RowDefinition();
            grid.RowDefinitions.Add(row);
            grid.Children.Add(item);
            Grid.SetColumn(item, 0);
            Grid.SetRow(item, grid.RowDefinitions.Count - 1);
            item.HorizontalAlignment = HorizontalAlignment.Left;
            item.VerticalAlignment = VerticalAlignment.Top;

            TreeGridItem parent = GetDisplay(item.Model.Parent);

            if (parent != null)
            {
                Brush stroke = new SolidColorBrush(Color.FromArgb((byte)100, (byte)0, (byte)0, (byte)0.5));

                TreeGridLine line = new TreeGridLine()
                {
                    Line1 = new Line() { Stroke = stroke, StrokeThickness = 2 },
                    Line2 = new Line() { Stroke = stroke, StrokeThickness = 2 },
                    Line3 = new Line() { Stroke = stroke, StrokeThickness = 2 },
                    Start = parent,
                    End = item
                };

                UnderlayCanvas.Children.Add(line.Line1);
                UnderlayCanvas.Children.Add(line.Line2);
                UnderlayCanvas.Children.Add(line.Line3);
                _lines.Add(line);
            }

            UpdateDimensions(item, true);

            row.Height = new GridLength(item.Height);
        }
Esempio n. 2
0
        private void RemoveFromChildCanvases(BetTreeNodeModel node, TreeGridItem parentDisplay)
        {
            TreeGridItem nodeDisplay = _items.Find(x => x.DataContext == node);

            foreach (BetTreeNodeModel child in node.Children)
                RemoveFromChildCanvases(child, nodeDisplay);

            TreeGridStart start = GetGrid(parentDisplay, null);
            if (start != null)
                RemoveItem(start.MainGrid, nodeDisplay);
        }
Esempio n. 3
0
        private void UpdateGridDimensions(BetTreeNodeModel node, TreeGridItem itemDisplay, TreeGridItem parentDisplay)
        {
            TreeGridStart grid = GetGrid(parentDisplay, StartGrid);
            double height = 0, width = 0;

            for (int i = 0; i < grid.MainGrid.Children.Count; i++)
            {
                TreeGridItem child = grid.MainGrid.Children[i] as TreeGridItem;
                if (child.Visibility == Visibility.Visible)
                {
                    if (child.Width > width) width = child.Width;
                    height += child.Height;
                }
                if (child == itemDisplay)
                {
                    grid.MainGrid.RowDefinitions[i].Height = new GridLength(child.Height);
                }
            }

            grid.MainGrid.ColumnDefinitions[0].Width = new GridLength(width);
            grid.Width = width;
            grid.Height = height;
        }
Esempio n. 4
0
        protected bool RemoveItem(Grid parent, TreeGridItem child)
        {
            bool found = false;
            for (int i = 0; i < parent.Children.Count; i++)
            {
                if (parent.Children[i] == child)
                {
                    parent.Children.RemoveAt(i);
                    parent.RowDefinitions.RemoveAt(i);
                    found = true;

                    if (i < parent.Children.Count)
                        Grid.SetRow(parent.Children[i], i);
                }
                else if (found)
                {
                    Grid.SetRow(parent.Children[i], i);
                }
            }

            List<TreeGridLine> lines = _lines.Where(x => x.Start == child || x.End == child).ToList();
            foreach (TreeGridLine line in lines)
            {
                UnderlayCanvas.Children.Remove(line.Line1);
                UnderlayCanvas.Children.Remove(line.Line2);
                UnderlayCanvas.Children.Remove(line.Line3);
                _lines.Remove(line);
            }

            return found;
        }
Esempio n. 5
0
        protected void RootItemLayoutUpdated(TreeGridItem item)
        {
            BetTreeNodeModel node = item.DataContext as BetTreeNodeModel;
            TreeGridItem parentDisplay = _items.Find(x => x.DataContext == node.Parent);

            UpdateGridDimensions(node, item, parentDisplay);

            if (parentDisplay != null)
            {
                UpdateDimensions(parentDisplay, true);
            }

            UpdateCanvas(item.Model.Snapshot.Round);
        }
Esempio n. 6
0
 protected double GetGridStartTop(TreeGridItem item)
 {
     Canvas parent = _canvases[item.Model.Snapshot.Round];
     Point relativeLocation = item.TranslatePoint(new Point(0, 0), parent);
     return relativeLocation.Y;
 }
Esempio n. 7
0
 /// <summary>
 /// 
 /// </summary>
 /// <param name="node"></param>
 /// <param name="parentDisplay"></param>
 /// <returns></returns>
 protected TreeGridStart GetNewGridStart(BetTreeNodeModel node, TreeGridItem parentDisplay)
 {
     TreeGridStart start = new TreeGridStart();
     start.LinkedItem = parentDisplay;
     start.LayoutUpdated += this.RefreshCanvas;
     Canvas canvas = _canvases[node.Snapshot.Round];
     canvas.Children.Add(start);
     _grids[parentDisplay] = start;
     return start;
 }
Esempio n. 8
0
 protected TreeGridStart GetGrid(TreeGridItem item, TreeGridStart defaultGrid)
 {
     if (item != null && _grids.ContainsKey(item))
         return _grids[item];
     else
         return defaultGrid;
 }
Esempio n. 9
0
 /// <summary>
 /// Adds a node to the child grid of its parent
 /// </summary>
 /// <param name="node">The node to be added</param>
 /// <param name="parentDisplay">The parent grid to which the node is added</param>
 protected void AddStandardNode(BetTreeNodeModel node, TreeGridItem parentDisplay)
 {
     Grid parentGrid = parentDisplay.Children;
     TreeGridItem item = GetNewItem(node);
     AppendItemToGrid(parentGrid, item);
 }
Esempio n. 10
0
        /// <summary>
        /// Adds a node to the root of a round section
        /// </summary>
        /// <param name="node">The node to be added to the root</param>
        /// <param name="parentDisplay">The node parent from the previous round, or null of this is the first round</param>
        protected void AddRootNode(BetTreeNodeModel node, TreeGridItem parentDisplay)
        {
            TreeGridStart start = (parentDisplay == null) ? StartGrid : GetGrid(parentDisplay, null);
            if (start == null)
            {
                start = GetNewGridStart(node, parentDisplay);
            }

            TreeGridItem item = GetNewRootItem(node);
            AppendItemToGrid(start.MainGrid, item);
            UpdateGridDimensions(node, item, parentDisplay);
            UpdateCanvas(node.Snapshot.Round);
        }
Esempio n. 11
0
        /// <summary>
        /// Update the dimensions of a single grid item
        /// </summary>
        /// <param name="item">The item to be updated</param>
        /// <param name="expanded">Whether or not the item is expanded</param>
        public void UpdateDimensions(TreeGridItem item, bool expanded)
        {
            double childGridWidth = 0, childGridHeight = 0;

            for (int i = 0; expanded && i < item.Model.Children.Count; i++)
            {
                TreeGridItem child = GetDisplay(item.Model.Children[i]);

                if (child != null)
                {
                    if (child.Visibility != Visibility.Visible) continue;

                    if (child.Width > childGridWidth && child.Model.Snapshot.Round == item.Model.Snapshot.Round)
                        childGridWidth = child.Width;

                    if (i < item.Children.RowDefinitions.Count)
                        item.Children.RowDefinitions[i].Height = new GridLength(child.Height);

                    childGridHeight += child.Height;
                }
            }

            item.FixLayout(childGridWidth, childGridHeight);
        }
Esempio n. 12
0
        /// <summary>
        /// Get a new round root item and add the appropriate event handlers
        /// </summary>
        /// <param name="node">The node model from which the visual component should be derived</param>
        /// <returns>Visual representation of a node</returns>
        public TreeGridItem GetNewRootItem(BetTreeNodeModel node)
        {
            TreeGridItem item = new TreeGridItem();
            item.DoFixLayout += this.UpdateDimensions;
            item.ItemLayoutUpdated += this.RootItemLayoutUpdated;
            _items.Add(item);
            item.LayoutUpdated += this.RefreshCanvas;

            item.DataContext = node;
            node.ExpandCollapse += DoExpandCollapse;
            return item;
        }