Exemple #1
0
        private void DrawFunc(GraphItemViewModel graph)
        {
            var exp      = graph.Expression;
            var geometry = new StreamGeometry();

            using (var context = geometry.Open())
            {
                bool   startFlag = true;
                double y;
                double tempY;
                for (double x = -centerX / cm; x <= (currentWidth - centerX) / cm; x += 0.03 * slider.Value)
                {
                    parameters.Variables["x"] = x;
                    y = (double)exp.Execute(parameters);

                    tempY = centerY - (y * cm);
                    if (double.IsNaN(y) || tempY < 0 || tempY > currentHeight)
                    {
                        startFlag = true;
                    }
                    else
                    {
                        if (startFlag)
                        {
                            context.BeginFigure(new Point(centerX + (x * cm), tempY), false, false);
                            startFlag = false;
                        }

                        context.LineTo(new Point(centerX + (x * cm), tempY), true, false);
                    }
                }
            }

            geometry.Freeze();

            var funcVisual = new DrawingVisual();
            var brush      = new SolidColorBrush(graph.ChartColor);
            var pen        = new Pen(brush, 1);

            pen.Freeze();
            using (DrawingContext context = funcVisual.RenderOpen())
                context.DrawGeometry(brush, pen, geometry);
            graph.Visual = funcVisual;
            canvas.AddVisual(funcVisual);
        }
Exemple #2
0
        public void QueryContextMenu(ContextMenuUI ui, MouseEvent evt, params object[] obj)
        {
            GraphItemViewModel switchableItemViewModel =
                obj
                .OfType <DiagramNodeViewModel>()
                .FirstOrDefault(commandVm => commandVm.GraphItemObject is ISwitchableClassOrStructNodeSystem);
            ISwitchableClassOrStructNodeSystem switchableItem = null;

            if (switchableItemViewModel != null)
            {
                switchableItem =
                    (ISwitchableClassOrStructNodeSystem)((DiagramNodeViewModel)switchableItemViewModel).GraphItemObject;
            }
            else
            {
                switchableItemViewModel =
                    obj
                    .OfType <TypedItemViewModel>()
                    .FirstOrDefault(commandVm => commandVm.MemberInfo is ISwitchableClassOrStructNodeSystem);
                if (switchableItemViewModel != null)
                {
                    switchableItem =
                        (ISwitchableClassOrStructNodeSystem)((TypedItemViewModel)switchableItemViewModel).MemberInfo;
                }
            }

            if (switchableItemViewModel != null && switchableItem != null)
            {
                ui.AddCommand(new ContextMenuItem
                {
                    Title   = "Is Struct",
                    Checked = switchableItem.IsStruct,
                    Command = new SetNodeIsStructCommand
                    {
                        Item          = switchableItem,
                        ItemViewModel = switchableItemViewModel,
                        IsStruct      = !switchableItem.IsStruct
                    }
                });
            }
        }
        public bool KeyDown(bool control, bool alt, bool shift, KeyCode character)
        {
            if (character == KeyCode.F2)
            {
                GraphItemViewModel selectNodeItem = InvertGraphEditor.CurrentDiagramViewModel.SelectedNodeItem;
                if (selectNodeItem != null)
                {
                    DiagramNodeItem nodeItem = selectNodeItem.DataObject as DiagramNodeItem;
                    if (nodeItem != null)
                    {
                        nodeItem.IsEditing = true;
                        return(false);
                    }
                }

                DiagramNodeViewModel selectedNode = InvertGraphEditor.CurrentDiagramViewModel.SelectedNode;
                if (selectedNode != null)
                {
                    InvertApplication.Execute(new RenameCommand()
                    {
                        ViewModel = selectedNode
                    });
                    return(false);
                }
            }
            if (character == KeyCode.Delete)
            {
                DiagramNodeViewModel selectedNode = InvertGraphEditor.CurrentDiagramViewModel.SelectedNode;
                if (selectedNode != null)
                {
                    InvertApplication.Execute(new DeleteCommand()
                    {
                        Item = new[] { selectedNode.DataObject as IDataRecord }
                    });
                    return(false);
                }
            }
            return(false);
        }
//        void Update()
//        {
//            if (TreeModel != null && TreeModel.IsDirty) TreeModel.Refresh();
//            Repaint();
//        }

        public void SelectionChanged(GraphItemViewModel selected)
        {
            if (TreeModel == null)
            {
                return;
            }
            var selectedData = selected == null ? null : selected.DataObject;

            if (selectedData != TreeModel.SelectedData)
            {
                var item = TreeModel.TreeData.FirstOrDefault(_ => _.Data == selectedData);
                if (item != null)
                {
                    TreeModel.SelectedIndex = item.Index;
                    TreeModel.ExpandPathTo(item);
                    TreeModel.ScrollToItem(item);
                }
                else
                {
                    TreeModel.SelectedIndex = -1;
                }
            }
        }
 public void SelectionChanged(GraphItemViewModel selected)
 {
     Debug.Log("Item selected: " + selected.GetType().Name);
 }
        public void Select(GraphItemViewModel viewModelObject)
        {
            if (viewModelObject == null) return;

            InspectorViewModel.TargetViewModel = viewModelObject;

            if (viewModelObject.IsSelected)
            {
                return;
            }
            if (LastMouseEvent != null && LastMouseEvent.ModifierKeyStates != null && !LastMouseEvent.ModifierKeyStates.Alt)
                DeselectAll();

            viewModelObject.IsSelected = true;
            InvertApplication.SignalEvent<IGraphSelectionEvents>(
                _ => _.SelectionChanged(viewModelObject));
        }
 public void SelectionChanged(GraphItemViewModel selected)
 {
     SelectItem(selected.DataObject as IDataRecord);
 }
Exemple #8
0
 public Drawer(GraphItemViewModel viewModelObject) : base(viewModelObject)
 {
 }
Exemple #9
0
 public void SelectionChanged(GraphItemViewModel selected)
 {
     HideSelection();
 }
Exemple #10
0
 protected Drawer(GraphItemViewModel viewModelObject)
 {
     ViewModelObject = viewModelObject;
 }
Exemple #11
0
 protected Drawer(GraphItemViewModel viewModelObject)
 {
     ViewModelObject = viewModelObject;
 }
 public void SelectionChanged(GraphItemViewModel selected)
 {
     Debug.Log("Item selected: "+selected.GetType().Name);
 }
Exemple #13
0
        public void Remove(GraphItemViewModel exp)
        {
            listOfGraphs.Remove(exp);

            view.Graphs = listOfGraphs.AsReadOnly();
        }
//        void Update()
//        {
//            if (TreeModel != null && TreeModel.IsDirty) TreeModel.Refresh();
//            Repaint();
//        }

        public void SelectionChanged(GraphItemViewModel selected)
        {
            if (TreeModel == null) return;
            var selectedData = selected == null ? null : selected.DataObject;

            if (selectedData != TreeModel.SelectedData)
            {
                var item = TreeModel.TreeData.FirstOrDefault(_ => _.Data == selectedData);
                if (item != null)
                {
                    TreeModel.SelectedIndex = item.Index;
                    TreeModel.ExpandPathTo(item);
                    TreeModel.ScrollToItem(item);
                }
                else
                {
                    TreeModel.SelectedIndex = -1;
                }
            }
        }
 public void SelectionChanged(GraphItemViewModel selected)
 {
     HideSelection();
 }
 public GenericChildItemHeaderDrawer(GraphItemViewModel viewModelObject)
     : base(viewModelObject)
 {
 }