Пример #1
0
        private void Button_Click(object sender, RoutedEventArgs e)
        {
            if (!allFilled())
            {
                MessageBox.Show("You have to enter all data");
                return;
            }

            if ((_mn.graphView.DataContext as GraphViewModel).dvrp != null)
            {
                MessageBox.Show("Second part of regulator exists!");
                return;
            }

            if (globalVertices.ContainsKey(lineTo.Text) && lineTo.Text != last_value)
            {
                MessageBox.Show("Node with that ID already exists, change Line segment to input.");
                return;
            }


            DataVertexRegulator        dvr = setupDataVertexRegulatorObject();
            DataVertexRegulatorPartial dvrp;

            if ((_mn.graphView.DataContext as GraphViewModel).dvrp != null)
            {
                dvrp = (_mn.graphView.DataContext as GraphViewModel).dvrp;
                dynamicButton.Content = "Update";
            }
            else
            {
                dvrp = new DataVertexRegulatorPartial()
                {
                    typeOfVertex         = DataVertex.TypeOfVertex.REGULATOR_PARTIAL_VERTEX,
                    Text                 = "Synchronous machine second ending: " + dvr.Line_Segment_To,
                    RegulatorID          = dvr.Line_Segment_To,
                    Element_id           = dvr.Line_Segment_To,
                    CompensatorSettingsB = dvr.CompensatorSettingsB,
                    R_SettingB           = dvr.R_SettingB,
                    X_SettingB           = dvr.X_SettingB,
                    VoltageLevelB        = dvr.VoltageLevelB,
                };
                (_mn.graphView.DataContext as GraphViewModel).dvrp = dvrp;
            }



            if (dynamicButton.Content.ToString() == "Update")
            {
                (_mn.graphView.DataContext as GraphViewModel).UpdateVertices(dvr, dvrp, last_value, length.Text);
                last_value = dvr.Line_Segment_To;
            }
            else
            {
                (_mn.graphView.DataContext as GraphViewModel).CreateComplexVertexWithPartialType(dvr, dvrp, dv, length.Text);
            }

            _mn.CloseAllWindows();
        }
        public void PrepareComplexVertexForDelete(DataVertex dv)
        {
            VertexControl vc = GetVertexControlWithDataVertex(dv.Element_id);

            Point p = CreatePointBasedOn(vc);

            DeleteVertex(dv);


            if (dv.typeOfVertex == DataVertex.TypeOfVertex.REGULATOR_VERTEX)
            {
                dvr = (DataVertexRegulator)dv;
                if (dvr.Line_Segment_To != null)
                {
                    if (mainWindow.GlobalVertices.Keys.Contains(dvr.Line_Segment_To))
                    {
                        DeleteVertex(mainWindow.GlobalVertices[dvr.Line_Segment_To]);
                        mainWindow.GlobalVertices.Remove(dvr.Line_Segment_To);
                        dvrp = null;
                    }
                }

                dvr = null;
            }
            else if (dv.typeOfVertex == DataVertex.TypeOfVertex.TRANSFORMER_VERTEX)
            {
                dvt = (DataVertexTransformer)dv;
                if (dvt.Line_to != null)
                {
                    if (mainWindow.GlobalVertices.Keys.Contains(dvt.Line_to))
                    {
                        DeleteVertex(mainWindow.GlobalVertices[dvt.Line_to]);
                        mainWindow.GlobalVertices.Remove(dvt.Line_to);
                        dvtp = null;
                    }
                }

                dvt = null;
            }

            mainWindow.enableButtonIfEdgesExists();
            mainWindow.CloseAllWindows();
        }
        private void CreateRegulatorPartialVertex(DataVertex dv, double m = 0, double n = 0)
        {
            VertexControl vc;
            DataVertexRegulatorPartial dvrp = new DataVertexRegulatorPartial()
            {
                Text = dv.Text, Element_id = dv.Element_id
            };

            dvrp.typeOfVertex = DataVertex.TypeOfVertex.REGULATOR_PARTIAL_VERTEX;
            vc = new VertexControl(dvrp);

            if (m == 0)
            {
                dvrp.Text = "Synchronous machine second ending: " + dvrp.Element_id;
                vc.SetPosition(new Point(x, y));
            }
            else
            {
                vc.SetPosition(m, n);
            }

            //dv.typeOfVertex = DataVertex.TypeOfVertex.SEGMENT_VERTEX;
            mainWindow.GlobalVertices.Add(dvrp.Element_id, dvrp);
            vc.SetPosition(new Point(x, y));
            vc.Background = Brushes.IndianRed;
            mainWindow.graphView.Area.AddVertexAndData(dvrp, vc, true);

            Point point = CreatePointBasedOn(vc);

            if (graphState == GraphState.NORMAL)
            {
                x += 30;
                y += 30;
            }
            this.dvrp = dvrp;
            return;
        }
        public void DeleteVertex(DataVertex dv)
        {
            //Area.RemoveVertex(globalVertices[dv.Text]);
            mainWindow.GlobalVertices.Remove(dv.Element_id);
            Console.WriteLine(mainWindow.GlobalVertices);
            bool is_empty = true;
            bool has_edge = false;


            is_empty = CheckIfZeroEdgesExist();


            //if 0 edges exist we can remove it
            RemoveIfZeroEdgesExist(is_empty, dv.Element_id);

            //if more then 0 edges exist we look for them
            has_edge = RemoveIfMoreThenZeroEdgesExist(dv);

            //if its not empty and its has edges, its third case, we delete it
            if (!is_empty && !has_edge)
            {
                VertexControl vc = GetVertexControlWithDataVertex(dv.Element_id);

                if (vc == null)
                {
                    return;
                }

                mainWindow.graphView.Area.RemoveVertex((vc.Vertex as DataVertex));
            }


            if (dv.typeOfVertex == DataVertex.TypeOfVertex.REGULATOR_VERTEX)
            {
                dvr = null;

                if (dvrp != null)
                {
                    DeleteVertex(dvrp);
                    dvrp = null;
                }
            }


            if (dv.typeOfVertex == DataVertex.TypeOfVertex.TRANSFORMER_VERTEX)
            {
                dvt = null;
                if (dvtp != null)
                {
                    DeleteVertex(dvtp);
                    dvtp = null;
                }
            }


            //now we look for his edges and delete them
            foreach (string key in mainWindow.GlobalEdges.Keys)
            {
                foreach (DataEdge de in mainWindow.GlobalEdges[key])
                {
                    if (de.Target.Element_id == dv.Element_id)
                    {
                        mainWindow.GlobalEdges[key].Remove(de);

                        if (mainWindow.graphView.Area.EdgesList.ContainsKey(de))
                        {
                            mainWindow.graphView.Area.RemoveEdge(de);
                            break;
                        }
                    }
                }
            }


            if (dv.typeOfVertex == DataVertex.TypeOfVertex.REGULATOR_PARTIAL_VERTEX || dv.typeOfVertex == DataVertex.TypeOfVertex.TRANSFORMER_PARTIAL_VERTEX)
            {
                foreach (DataVertex temp in mainWindow.graphView.Area.VertexList.Keys)
                {
                    if (temp.Element_id == dv.Element_id)
                    {
                        mainWindow.graphView.Area.RemoveVertex(temp);
                        break;
                    }
                }
            }

            if (graphState == GraphState.NORMAL)
            {
                undoRedoCommander.addUndoCommand(new Command("DeleteVertex", dv));
            }
        }