Exemple #1
0
        private void btnCut_Click(object sender, RoutedEventArgs e)
        {
            _numberOfPastes = 0;
            if (_selectedFigures.Count != 0)
            {
                nothingToPaste = false;
                cutOrCopy      = cutOrCopyMode.cut;

                cuttedOrCopiedArcs.Clear();
                cuttedOrCopiedFigures.Clear();

                cuttedOrCopiedFigures.AddRange(_selectedFigures);
                cuttedOrCopiedArcs.AddRange(_selectedArcs);

                List <PetriNetNode> cuttedF = new List <PetriNetNode>();
                List <VArc>         cuttedA = new List <VArc>();
                cuttedF.AddRange(cuttedOrCopiedFigures);
                cuttedA.AddRange(cuttedOrCopiedArcs);

                List <VArc> impl = new List <VArc>();
                AddThisArcsToListOfCuttedArcs(cuttedOrCopiedFigures, impl);

                List <PetriNetNode> cutF = new List <PetriNetNode>();
                List <VArc>         cutA = new List <VArc>();
                cutF.AddRange(cuttedOrCopiedFigures);
                cutA.AddRange(impl);

                UnselectFigures();//(selectedFigures, selectedArcs);

                List <PetriNetNode> old = new List <PetriNetNode>();
                foreach (PetriNetNode figure in cutF)
                {
                    PetriNetNode f = PetriNetNode.Create();
                    f.CoordX = figure.CoordX;
                    f.CoordY = figure.CoordY;
                    f.Id     = figure.Id;
                    old.Add(f);
                }

                CutFigures(cutF, cutA);

                CutCommand newCommand = new CutCommand(cuttedF, old, cuttedA, impl);
                Command.ExecutedCommands.Push(newCommand);
                Command.CanceledCommands.Clear();

                HideAllProperties();
            }
            else
            {
                nothingToPaste = true;
            }

            TurnOnSelectMode();
            btnCut.Focusable = false;
        }
Exemple #2
0
        public VArc(PetriNetNode first, PetriNetNode second)
        {
            //TODO Здесь очень большая опасность в случае сетей Петри!
            //TODO Можно засунуть неправильную сеть
            //TODO сейчас проверяю при создании сети вообще
            //Debug.Assert(((first is Place) && (second is Place)) || ((first is Transition) && (second is Transition)), "first and second must be of different types");

            From = first;
            To   = second;
            Counter++;//какой ужас! в конструкторе!!!
            Id     = "arc" + Counter;
            Weight = "1";
        }
Exemple #3
0
 public void ShowProperties(PetriNetNode selected)
 {
     foreach (VArc a in selected.ThisArcs)
     {
         VArc arc = a;
         if (a.To != selected)
         {
             textBoxOutgoingArcs.Text += arc.To.Id + "\n";
         }
         else
         {
             textBoxIngoinArcs.Text += arc.From.Id + "\n";
         }
     }
 }
        public void RemoveNode(PetriNetNode node)
        {
            node.IsSelect = false;
            VPlace place = node as VPlace;

            if (place != null)
            {
                //Net.places.Remove(place);
                VPlace selPlace = place;
                MainModelCanvas.Children.Remove(selPlace.NumberOfTokensLabel);
                while (selPlace.TokensList.Count != 0)
                {
                    MainModelCanvas.Children.Remove(selPlace.TokensList[0]);
                    selPlace.TokensList.RemoveAt(0);
                }
            }
            // else
            //   Net.transitions.Remove(selected as Transition);

            DeleteArcs(node.ThisArcs);
            //selected.ThisArcs.Clear();

            var objectToRemove = GetKeyByValueForFigures(node);

            _allFiguresObjectReferences.Remove(objectToRemove);

            Shape shapeToRemove = objectToRemove as Shape;

            if (shapeToRemove != null)
            {
                shapeToRemove.Stroke = Brushes.Black;
                MainModelCanvas.Children.Remove(shapeToRemove);
            }

            Label labelForRemove;

            NodesToLabelsInCanvas.TryGetValue(node, out labelForRemove);
            MainModelCanvas.Children.Remove(labelForRemove);

            Net.RemoveNode(node);
        }
Exemple #5
0
        public static List <VArc> OpenGraphMl(XmlDocument graphmlDoc, out bool exc)
        {
            var returnArcs = new List <VArc>();

            keys.Clear();
            exc = false;
            XmlNode graph = null;

            if (graphmlDoc.DocumentElement.LastChild.Name == "graph")
            {
                graph = graphmlDoc.DocumentElement.LastChild;
            }

            for (var i = 0; i < graphmlDoc.DocumentElement.ChildNodes.Count; i++)
            {
                if (graphmlDoc.DocumentElement.ChildNodes[i].Name != "key")
                {
                    continue;
                }
                string keyId = null, keyValue = null;
                for (var j = 0; j < graphmlDoc.DocumentElement.ChildNodes[i].Attributes.Count; j++)
                {
                    switch (graphmlDoc.DocumentElement.ChildNodes[i].Attributes[j].Name)
                    {
                    case "id":
                        keyId = graphmlDoc.DocumentElement.ChildNodes[i].Attributes[j].Value;
                        break;

                    case "attr.name":
                        keyValue = graphmlDoc.DocumentElement.ChildNodes[i].Attributes[j].Value;
                        break;
                    }
                }
                if (!keys.ContainsKey(keyId))
                {
                    keys.Add(keyId, keyValue);
                }
            }

            bool isArcsDirectedByDefault = false;

            if (graph == null)
            {
                MessageBox.Show("Node 'graph' is missed, check the file");
                exc = true;
                return(returnArcs);
            }
            else if (graph.LastChild.Name == "edgedefault")
            {
                if (graph.LastChild.Value == "directed")
                {
                    isArcsDirectedByDefault = true;
                }
            }
            XmlNodeList graphObjects = graph.ChildNodes;

            if (graphObjects.Count == 0)
            {
                MessageBox.Show("There are no nodes in the graph, check the file");
                exc = true;
                return(returnArcs);
            }

            foreach (XmlNode node in graphObjects)
            {
                var id = "";

                if (node.Name == "node")
                {
                    for (int i = 0; i < node.Attributes.Count; i++)
                    {
                        if (node.Attributes[i].Name == "id")
                        {
                            id = node.Attributes[i].Value;
                        }
                    }

                    VPlace place = VPlace.Create(0, 0);
                    place.Id = id;
                    PNEditorControl.Net.places.Add(place);
                    //SetOfFigures.Figures.Add(place);
                }
                else if (node.Name == "edge")
                {
                }
                else
                {
                    MessageBox.Show("The file contains element with foreign name, it will be ignored, check the file");
                }
            }

            if (PNEditorControl.Net.Nodes.Count == 0)
            {
                MessageBox.Show("There are no nodes in the graph, check the file");
                exc = true;
                return(returnArcs);
            }
            else
            {
                foreach (XmlNode node in graphObjects)
                {
                    if (node.Name != "edge")
                    {
                        continue;
                    }
                    PetriNetNode from = null, to = null;
                    string       fromId = null, toId = null, id = null, directed = null;

                    for (int i = 0; i < node.Attributes.Count; i++)
                    {
                        switch (node.Attributes[i].Name)
                        {
                        case "source":
                            fromId = node.Attributes[i].Value;
                            break;

                        case "target":
                            toId = node.Attributes[i].Value;
                            break;

                        case "id":
                            id = node.Attributes[i].Value;
                            break;

                        case "directed":
                            directed = node.Attributes[i].Value;
                            break;
                        }
                    }
                    double weight = 0;
                    if (node.FirstChild != null)
                    {
                        var data = node.FirstChild;
                        for (var i = 0; i < data.Attributes.Count; i++)
                        {
                            if (data.Attributes[i].Name != "key")
                            {
                                continue;
                            }
                            string weightValue;
                            keys.TryGetValue(data.Attributes[i].Value, out weightValue);
                            if (weightValue == "weight")
                            {
                                double.TryParse(data.InnerText.Replace('.', ','), out weight);
                            }
                        }
                    }

                    foreach (var figure in PNEditorControl.Net.Nodes)
                    {
                        if (figure.Id == fromId)
                        {
                            from = figure;
                        }
                        else if (figure.Id == toId)
                        {
                            to = figure;
                        }
                    }

                    var arc = new VArc(from, to)
                    {
                        Weight = weight > 1 ? weight.ToString(CultureInfo.InvariantCulture) : "1",
                        Id     = id
                    };
                    if (directed != null)
                    {
                        arc.IsDirected = directed == "true";
                    }
                    else
                    {
                        arc.IsDirected = isArcsDirectedByDefault;
                    }

                    returnArcs.Add(arc);
                }
            }
            return(returnArcs);
        }
Exemple #6
0
 public ChangeNameCommand(PetriNetNode figure, string oldN, string newN)
 {
     namedFigure = figure;
     oldName     = oldN;
     newName     = newN;
 }
Exemple #7
0
 public AddFigureCommand(PetriNetNode thisFigure, Shape thisShape)
 {
     newFigure = thisFigure;
     shape     = thisShape;
 }
        private void btnRedo_Click(object sender, RoutedEventArgs e)
        {
            btnSelect.IsEnabled = true;
            if (Command.CanceledCommands.Count != 0)
            {
                Command lastCommand = Command.CanceledCommands.Pop();
                if (lastCommand is AddFigureCommand)
                {
                    PetriNetNode currentFigure = (lastCommand as AddFigureCommand).newFigure;
                    Shape        shape         = (lastCommand as AddFigureCommand).shape;

                    if (currentFigure.IsSelect)
                    {
                        currentFigure.IsSelect = false;
                    }
                    if ((lastCommand as AddFigureCommand).newFigure is VPlace)
                    {
                        //Place.places.Add(currentFigure as Place);
                        Net.places.Add(currentFigure as VPlace);
                    }
                    else
                    {
                        //Transition.transitions.Add(currentFigure as Transition);
                        Net.transitions.Add(currentFigure as VTransition);
                    }
                    //SetOfFigures.Figures.Add(currentFigure);

                    Canvas.SetLeft(shape, currentFigure.CoordX);
                    Canvas.SetTop(shape, currentFigure.CoordY);
                    MainModelCanvas.Children.Add(shape);

                    _allFiguresObjectReferences.Add(shape, currentFigure);

                    AddFigureCommand newCommand = new AddFigureCommand(currentFigure, shape);
                    Command.ExecutedCommands.Push(newCommand);
                    btnUndo.IsEnabled = true;
                }
                else if (lastCommand is AddArcCommand)
                {
                    VArc newArc = (lastCommand as AddArcCommand).newArc;
                    if (newArc.IsSelect)
                    {
                        newArc.IsSelect = false;
                    }
                    Net.arcs.Add(newArc);
                    newArc.AddToThisArcsLists();

                    DrawArc(newArc);
                    RedrawArrowHeads(newArc);

                    AddArcCommand newCommand = new AddArcCommand(newArc);
                    Command.ExecutedCommands.Push(newCommand);
                }
                else if (lastCommand is AddTokensCommand)
                {
                    PetriNetNode figure = (lastCommand as AddTokensCommand).markedPlace;

                    VPlace place = (VPlace)figure;
                    place.NumberOfTokens = (lastCommand as AddTokensCommand).oldNumber;

                    if (place.NumberOfTokens == 0)
                    {
                        RemoveTokens(place);
                    }
                    if (place.NumberOfTokens >= 0 && place.NumberOfTokens < 5)
                    {
                        MainModelCanvas.Children.Remove(place.NumberOfTokensLabel);
                    }
                    AddTokens(place);

                    int temp = (lastCommand as AddTokensCommand).oldNumber;
                    (lastCommand as AddTokensCommand).oldNumber = (lastCommand as AddTokensCommand).newNumber;
                    (lastCommand as AddTokensCommand).newNumber = temp;

                    AddTokensCommand newCommand = new AddTokensCommand(place, (lastCommand as AddTokensCommand).oldNumber,
                                                                       (lastCommand as AddTokensCommand).newNumber);
                    Command.ExecutedCommands.Push(newCommand);
                }
                else if (lastCommand is ChangeNameCommand)
                {
                    PetriNetNode namedFigure = (lastCommand as ChangeNameCommand).namedFigure;
                    namedFigure.Label = (lastCommand as ChangeNameCommand).oldName;

                    ChangeLabel(namedFigure, (lastCommand as ChangeNameCommand).oldName);

                    string temp = (lastCommand as ChangeNameCommand).oldName;
                    (lastCommand as ChangeNameCommand).oldName = (lastCommand as ChangeNameCommand).newName;
                    (lastCommand as ChangeNameCommand).newName = temp;

                    ChangeNameCommand newCommand = new ChangeNameCommand(namedFigure, (lastCommand as ChangeNameCommand).oldName,
                                                                         (lastCommand as ChangeNameCommand).newName);
                    Command.ExecutedCommands.Push(newCommand);
                }
                else if (lastCommand is DragCommand)
                {
                    foreach (PetriNetNode figure in Net.Nodes)
                    {
                        foreach (PetriNetNode afterDragFigure in (lastCommand as DragCommand).figuresAfterDrag)
                        {
                            if (figure.Id == afterDragFigure.Id)
                            {
                                figure.CoordX = afterDragFigure.CoordX;
                                figure.CoordY = afterDragFigure.CoordY;
                            }
                        }
                    }

                    //List<PetriNetNode> newList = SetOfFigures.Figures;

                    foreach (PetriNetNode figure in Net.Nodes)//newList)
                    {
                        MoveFigure(figure);
                    }

                    DragCommand newCommand = new DragCommand((lastCommand as DragCommand).figuresBeforeDrag,
                                                             (lastCommand as DragCommand).figuresAfterDrag);
                    Command.ExecutedCommands.Push(newCommand);
                }
                else if (lastCommand is DeleteCommand)
                {
                    List <PetriNetNode> figures = (lastCommand as DeleteCommand).deletedFigures;
                    List <VArc>         arcs    = (lastCommand as DeleteCommand).deletedArcs;
                    DeleteFigures(figures, arcs);
                    DeleteCommand newCommand = new DeleteCommand(figures, arcs);
                    Command.ExecutedCommands.Push(newCommand);
                }
                else if (lastCommand is ChangeWeightCommand)
                {
                    VArc arc = (lastCommand as ChangeWeightCommand).arc;
                    MainModelCanvas.Children.Remove((lastCommand as ChangeWeightCommand).oldWeightLabel);

                    arc.Weight = (lastCommand as ChangeWeightCommand).newWeight;
                    (lastCommand as ChangeWeightCommand).newWeightLabel.Content = arc.Weight;

                    Canvas.SetLeft((lastCommand as ChangeWeightCommand).newWeightLabel, (arc.From.CoordX + arc.To.CoordX) / 2);
                    Canvas.SetTop((lastCommand as ChangeWeightCommand).newWeightLabel, (arc.From.CoordY + arc.To.CoordY) / 2 - 5);
                    MainModelCanvas.Children.Add((lastCommand as ChangeWeightCommand).newWeightLabel);

                    arc.WeightLabel = (lastCommand as ChangeWeightCommand).newWeightLabel;

                    ChangeWeightCommand newCommand = new ChangeWeightCommand(arc, (lastCommand as ChangeWeightCommand).oldWeight,
                                                                             arc.Weight, (lastCommand as ChangeWeightCommand).oldWeightLabel, arc.WeightLabel);
                    Command.ExecutedCommands.Push(newCommand);
                }
                else if (lastCommand is CutCommand)
                {
                    cuttedOrCopiedArcs.Clear();
                    cuttedOrCopiedFigures.Clear();

                    List <PetriNetNode> figures  = (lastCommand as CutCommand).cuttedFigures;
                    List <PetriNetNode> old      = (lastCommand as CutCommand).oldFigures;
                    List <VArc>         expArcs  = (lastCommand as CutCommand).explicitlyCuttedArcs;
                    List <VArc>         implArcs = (lastCommand as CutCommand).implicitlyCuttedArcs;

                    cuttedOrCopiedFigures.AddRange(figures);
                    cuttedOrCopiedArcs.AddRange(expArcs);

                    List <PetriNetNode> cutF = new List <PetriNetNode>();
                    List <VArc>         cutA = new List <VArc>();
                    cutF.AddRange(cuttedOrCopiedFigures);
                    cutA.AddRange(implArcs);

                    CutFigures(cutF, cutA);
                    _selectedFigures.Clear();
                    _selectedArcs.Clear();
                    ReassignSelectedProperties();

                    CutCommand newCommand = new CutCommand(figures, old, expArcs, implArcs);
                    Command.ExecutedCommands.Push(newCommand);
                }
                else if (lastCommand is PasteCommand)
                {
                    if (nothingToPaste == false)
                    {
                        List <PetriNetNode> figuresToPaste = (lastCommand as PasteCommand).pastedfigures;
                        List <VArc>         arcsToPaste    = (lastCommand as PasteCommand).pastedArcs;

                        double minX = figuresToPaste[0].CoordX, minY = figuresToPaste[0].CoordY;

                        foreach (PetriNetNode figure in figuresToPaste)
                        {
                            if (figure.CoordX < minX)
                            {
                                minX = figure.CoordX;
                            }
                            if (figure.CoordY < minY)
                            {
                                minY = figure.CoordY;
                            }
                        }

                        if (cutOrCopy == cutOrCopyMode.copy)
                        {
                            UnselectFigures();//(selectedFigures, selectedArcs);
                        }

                        foreach (PetriNetNode figure in figuresToPaste)
                        {
                            if (cutOrCopy == cutOrCopyMode.copy)
                            {
                                figure.DetectIdMatches(Net.Nodes);
                            }
                            figure.CoordX += -minX + ScrollViewerForMainModelCanvas.HorizontalOffset;
                            figure.CoordY += -minY + ScrollViewerForMainModelCanvas.VerticalOffset;
                        }
                        PasteCommand newCommand = new PasteCommand(figuresToPaste, arcsToPaste);
                        Command.ExecutedCommands.Push(newCommand);

                        if (cutOrCopy == cutOrCopyMode.cut)
                        {
                            arcsToPaste.RemoveAll(ShouldBeDeleted);
                        }

                        PasteFiguresAndArcs(figuresToPaste, arcsToPaste);
                    }
                }
            }

            EnableUndoRedoButtons();
            ReassignSelectedProperties();
            if (Command.CanceledCommands.Count == 0)
            {
                btnRedo.IsEnabled = false;
            }
            if (Command.ExecutedCommands.Count > 0)
            {
                btnUndo.IsEnabled = true;
            }
            TurnOnSelectMode();
        }
        private void btnUndo_Click(object sender, RoutedEventArgs e)
        {
            btnSelect.IsEnabled = true;
            if (Command.ExecutedCommands.Count != 0)
            {
                Command lastCommand = Command.ExecutedCommands.Peek();
                if (lastCommand is AddFigureCommand)
                {
                    PetriNetNode thisFigure = (lastCommand as AddFigureCommand).newFigure;
                    EnableAddButtons();

                    RemoveNode(thisFigure);

                    if (_selectedFigures.Contains(thisFigure))
                    {
                        _selectedFigures.Remove(thisFigure);
                        _selectedFigure = null;
                    }
                }
                else if (lastCommand is AddArcCommand)
                {
                    VArc thisArc = (lastCommand as AddArcCommand).newArc;
                    EnableAddButtons();

                    List <VArc> arcs = new List <VArc>();
                    arcs.Add(thisArc);
                    DeleteArcs(arcs);

                    if (_selectedArcs.Contains(thisArc))
                    {
                        _selectedArcs.Remove(thisArc);
                        _selectedArc = null;
                    }
                }
                else if (lastCommand is AddTokensCommand)
                {
                    PetriNetNode figure = (lastCommand as AddTokensCommand).markedPlace;
                    VPlace       place  = (VPlace)figure;
                    place.NumberOfTokens = (lastCommand as AddTokensCommand).oldNumber;


                    if (place.NumberOfTokens == 0)
                    {
                        RemoveTokens(place);
                    }
                    if (place.NumberOfTokens >= 0 && place.NumberOfTokens < 5)
                    {
                        MainModelCanvas.Children.Remove(place.NumberOfTokensLabel);
                    }

                    AddTokens(place);

                    int temp = (lastCommand as AddTokensCommand).oldNumber;
                    (lastCommand as AddTokensCommand).oldNumber = (lastCommand as AddTokensCommand).newNumber;
                    (lastCommand as AddTokensCommand).newNumber = temp;
                }
                else if (lastCommand is ChangeNameCommand)
                {
                    PetriNetNode namedFigure = (lastCommand as ChangeNameCommand).namedFigure;
                    namedFigure.Label = (lastCommand as ChangeNameCommand).oldName;

                    ChangeLabel(namedFigure, (lastCommand as ChangeNameCommand).oldName);

                    string temp = (lastCommand as ChangeNameCommand).oldName;
                    (lastCommand as ChangeNameCommand).oldName = (lastCommand as ChangeNameCommand).newName;
                    (lastCommand as ChangeNameCommand).newName = temp;
                }
                else if (lastCommand is DragCommand)
                {
                    foreach (PetriNetNode figure in Net.Nodes)
                    {
                        foreach (PetriNetNode f in (lastCommand as DragCommand).figuresBeforeDrag)
                        {
                            if (figure.Id == f.Id)
                            {
                                figure.CoordX = f.CoordX;
                                figure.CoordY = f.CoordY;
                            }
                        }
                    }

                    //List<PetriNetNode> newList = SetOfFigures.Figures;

                    foreach (PetriNetNode figure in Net.Nodes)//newlist
                    {
                        MoveFigure(figure);
                    }
                }
                else if (lastCommand is DeleteCommand)
                {
                    var restoredFigures = (lastCommand as DeleteCommand).deletedFigures;
                    var restoredArcs    = (lastCommand as DeleteCommand).deletedArcs;

                    //SetOfFigures.Figures.AddRange(restoredFigures);
                    foreach (PetriNetNode node in restoredFigures)
                    {
                        if (node is VPlace)
                        {
                            Net.places.Add(node as VPlace);
                        }
                        else
                        {
                            Net.transitions.Add(node as VTransition);
                        }
                    }
                    Net.arcs.AddRange(restoredArcs);

                    foreach (var figure in Net.Nodes)
                    {
                        if (restoredFigures.Contains(figure))
                        {
                            DrawFigure(figure);
                        }
                    }
                    foreach (var arc in Net.arcs)
                    {
                        if (restoredArcs.Contains(arc))
                        {
                            DisplayArc(arc);
                        }
                    }
                }
                else if (lastCommand is ChangeWeightCommand)
                {
                    VArc arc = (lastCommand as ChangeWeightCommand).arc;
                    MainModelCanvas.Children.Remove((lastCommand as ChangeWeightCommand).newWeightLabel);
                    arc.Weight      = (lastCommand as ChangeWeightCommand).oldWeight;
                    arc.WeightLabel = (lastCommand as ChangeWeightCommand).oldWeightLabel;


                    if (arc.Weight != "1")
                    {
                        (lastCommand as ChangeWeightCommand).oldWeightLabel.Content = arc.Weight;
                        Canvas.SetLeft((lastCommand as ChangeWeightCommand).oldWeightLabel,
                                       (arc.From.CoordX + arc.To.CoordX) / 2);
                        Canvas.SetTop((lastCommand as ChangeWeightCommand).oldWeightLabel,
                                      (arc.From.CoordY + arc.To.CoordY) / 2 - 5);
                        MainModelCanvas.Children.Add((lastCommand as ChangeWeightCommand).oldWeightLabel);
                    }
                }
                else if (lastCommand is CutCommand)
                {
                    List <PetriNetNode> cuttedFigures = (lastCommand as CutCommand).cuttedFigures;
                    List <PetriNetNode> old           = (lastCommand as CutCommand).oldFigures;
                    List <VArc>         cuttedArcs    = (lastCommand as CutCommand).implicitlyCuttedArcs;

                    //SetOfFigures.Figures.AddRange(cuttedFigures);
                    Net.arcs.AddRange(cuttedArcs);
                    foreach (PetriNetNode figure in cuttedFigures)//SetOfFigures.Figures)
                    {
                        //if (cuttedFigures.Contains(figure))
                        {
                            DrawFigure(figure);
                            figure.IsSelect = true;
                            foreach (PetriNetNode oldFigure in old)
                            {
                                if (figure.Id == oldFigure.Id)
                                {
                                    figure.CoordX = oldFigure.CoordX;
                                    figure.CoordY = oldFigure.CoordY;
                                    Shape shape = GetKeyByValueForFigures(figure) as Shape;
                                    Canvas.SetLeft(shape, figure.CoordX);
                                    Canvas.SetTop(shape, figure.CoordY);
                                    break;
                                }
                            }
                            MakeSelected(figure);
                        }
                    }
                    foreach (VArc arc in Net.arcs)
                    {
                        if (cuttedArcs.Contains(arc))
                        {
                            DisplayArc(arc);
                            _selectedArcs.Add(arc);
                            arc.IsSelect = true;
                            ColorArrow(arc);
                        }
                    }
                }
                else if (lastCommand is PasteCommand)
                {
                    List <PetriNetNode> figures = (lastCommand as PasteCommand).pastedfigures;
                    List <VArc>         arcs    = (lastCommand as PasteCommand).pastedArcs;

                    cuttedOrCopiedArcs.Clear();
                    cuttedOrCopiedFigures.Clear();

                    cuttedOrCopiedFigures.AddRange(figures);
                    cuttedOrCopiedArcs.AddRange(arcs);

                    CutFigures(cuttedOrCopiedFigures, cuttedOrCopiedArcs);

                    _selectedFigures.Clear();
                    _selectedArcs.Clear();
                    ReassignSelectedProperties();
                }
                Command.ExecutedCommands.Pop();
                Command.CanceledCommands.Push(lastCommand);
            }

            ReassignSelectedProperties();
            EnableUndoRedoButtons();
            if (Command.ExecutedCommands.Count == 0)
            {
                btnUndo.IsEnabled = false;
            }
            TurnOnSelectMode();
        }
 private object GetKeyByValueForFigures(PetriNetNode el)
 {
     return((from ex in _allFiguresObjectReferences where ex.Value.Equals(el) select ex.Key).FirstOrDefault());
 }
Exemple #11
0
        /// <summary>
        /// Read model from PNML
        /// </summary>
        /// <param name="pnmlDoc">pnml document</param>
        /// <param name="exc">shows whether any mistakes has been detected</param>
        public static List <VArc> OpenPnml(XmlDocument pnmlDoc, out bool exc)
        {
            var returnArcs = new List <VArc>();

            exc = false;
            XmlNode net = null;

            if (pnmlDoc.DocumentElement.FirstChild.Name == "net")
            {
                net = pnmlDoc.DocumentElement.FirstChild;
            }

            if (net == null)
            {
                MessageBox.Show("Node 'net' is missed, check the file");
                exc = true;
                return(returnArcs);
            }

            XmlNode page = null;

            for (var i = 0; i < net.ChildNodes.Count; i++)
            {
                if (net.ChildNodes[i].Name == "page")
                {
                    page = net.ChildNodes[i];
                }
            }

            if (page == null)
            {
                MessageBox.Show("Node 'page' is missed, check the file");
                exc = true;
                return(returnArcs);
            }

            var petriNetObjects = page.ChildNodes;

            if (petriNetObjects.Count == 0)
            {
                MessageBox.Show("There are no nodes in the net, check the file");
                exc = true;
                return(returnArcs);
            }

            foreach (XmlNode figure in petriNetObjects)
            {
                string id = "", name = "";
                int    numberOfTokens = 0;
                double x = -1, y = -1;

                if (figure.Name == "place" || figure.Name == "transition")
                {
                    for (var i = 0; i < figure.Attributes.Count; i++)
                    {
                        if (figure.Attributes[i].Name == "id")
                        {
                            id = figure.Attributes[i].Value;
                        }
                    }

                    var figureNodes = figure.ChildNodes;

                    //todo Какой-то очень стремный кусок кода. Нужно рефакторить

                    for (int i = 0; i < figureNodes.Count; i++)
                    {
                        if (figureNodes[i].Name == "name")
                        {
                            name = figureNodes[i].FirstChild.InnerText;
                        }
                        else if (figureNodes[i].Name == "graphics")
                        {
                            for (int j = 0; j < figureNodes[i].ChildNodes.Count; j++)
                            {
                                if (figureNodes[i].ChildNodes[j].Name == "position")
                                {
                                    for (int k = 0; k < figureNodes[i].ChildNodes[j].Attributes.Count; k++)
                                    {
                                        if (figureNodes[i].ChildNodes[j].Attributes[k].Name == "x")
                                        {
                                            if (double.TryParse(figureNodes[i].ChildNodes[j].Attributes[k].Value.Replace('.', ','), out x) == false || x < 0)
                                            {
                                                x = 0;
                                                MessageBox.Show("Node " + id + " has incorrect x-coordinate(it will be assumed as 0)");
                                            }
                                        }
                                        else if (figureNodes[i].ChildNodes[j].Attributes[k].Name == "y")
                                        {
                                            if (double.TryParse(figureNodes[i].ChildNodes[j].Attributes[k].Value.Replace('.', ','), out y) == false || y < 0)
                                            {
                                                y = 0;
                                                MessageBox.Show("Node " + id + " has incorrect y-coordinate(it will be assumed as 0)");
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        else if (figureNodes[i].Name == "initialMarking")
                        {
                            if (int.TryParse(figureNodes[i].FirstChild.InnerText, out numberOfTokens) == false)
                            {
                                numberOfTokens = 0;
                                MessageBox.Show("Place " + id + " has incorrect number of tokens(it will be assumed as 0)");
                            }
                        }
                    }

                    if (figure.Name == "place")
                    {
                        var place = VPlace.Create(x, y);
                        place.Id             = id;
                        place.Label          = name;
                        place.NumberOfTokens = numberOfTokens;
                        PNEditorControl.Net.places.Add(place);
                        //SetOfFigures.Figures.Add(place);
                    }
                    else
                    {
                        var transition = VTransition.Create(x, y);
                        transition.Id    = id;
                        transition.Label = name;
                        PNEditorControl.Net.transitions.Add(transition);
                        //SetOfFigures.Figures.Add(transition);
                    }
                }
                else if (figure.Name == "arc")
                {
                }
                else
                {
                    MessageBox.Show("The file contains element with foreign name, it will be ignored, check the file");
                }
            }
            if (PNEditorControl.Net.Nodes.Count == 0)
            {
                MessageBox.Show("There are no nodes in the net, check the file");
                exc = true;
                return(returnArcs);
            }
            else
            {
                foreach (XmlNode figure in petriNetObjects)
                {
                    if (figure.Name != "arc")
                    {
                        continue;
                    }

                    PetriNetNode from = null, to = null;
                    string       fromId = null, toId = null, id = null;

                    for (var i = 0; i < figure.Attributes.Count; i++)
                    {
                        switch (figure.Attributes[i].Name)
                        {
                        case "source":
                            fromId = figure.Attributes[i].Value;
                            break;

                        case "target":
                            toId = figure.Attributes[i].Value;
                            break;

                        case "id":
                            id = figure.Attributes[i].Value;
                            break;
                        }
                    }

                    var arcWeight = 1;
                    if (figure.FirstChild != null)
                    {
                        if (figure.FirstChild.Name == "name")
                        {
                            int.TryParse(figure.FirstChild.FirstChild.FirstChild.InnerText, out arcWeight);
                        }
                    }

                    foreach (var f in PNEditorControl.Net.Nodes)
                    {
                        if (f.Id == fromId)
                        {
                            from = f;
                        }
                        else if (f.Id == toId)
                        {
                            to = f;
                        }
                    }

                    var arc = new VArc(from, to)
                    {
                        Weight     = arcWeight.ToString(),
                        Id         = id,
                        IsDirected = true
                    };
                    returnArcs.Add(arc);
                }
            }
            return(returnArcs);
        }