コード例 #1
0
ファイル: Funcoes.cs プロジェクト: marlonluft/DeadLockWPF
        public void CriarLinha(int ProcessoID, int RecursoID, bool? Deadlock, bool Processo)
        {
            SolidColorBrush[] Strokes = { Brushes.Black, Brushes.Blue, Brushes.Red };
            int x = 0;
            int repetido = 0;

            /*=================================*/
            Wpf_DeadLock.Model.Processos processoM = new Processos();
            Wpf_DeadLock.Model.Recursos recursoM = new Recursos();

            /*=================================*/
            switch (Processo)
            {
                case true:
                    x = 0;
                    break;
                case false:
                    x = 1;
                    break;
            }

            switch (Deadlock)
            {
                case true:

                    foreach (var item in Linhas)
                    {
                        if (item.ProcessoID == ProcessoID &&
                            item.RecursoID == RecursoID &&
                            item.Processo == Processo)
                        {
                            if(item.Path.Stroke != Strokes[2])
                            {
                                MessageBox.Show("Possivel DeadLock");
                            }

                            item.Path.Stroke = Strokes[2];                            
                            break;
                        }
                    }
                    break;

                case false:

                    foreach (var item in Linhas)
                    {
                        if (item.ProcessoID == ProcessoID &&
                            item.RecursoID == RecursoID &&
                            item.Processo == Processo)
                        {
                            Linhas.Remove(item);
                            MessageBox.Show("Linha irá ser Removida");
                            break;
                        }
                    }
                    break;
            }

            if (Deadlock == null)
            {
                foreach (var item in Processos)
                {
                    if (item.ID == ProcessoID)
                    {
                        processoM = item;
                        break;
                    }
                }
                foreach (var item in Recursos)
                {
                    if (item.ID == RecursoID)
                    {
                        recursoM = item;
                        break;
                    }
                }

                System.Windows.Shapes.Path p;
                p = new System.Windows.Shapes.Path();
                p.Stroke = Strokes[x];
                p.StrokeThickness = 2;

                for (int i = 0; i < Linhas.Count; i++)
                {
                    if (Linhas[i].ProcessoID == ProcessoID &&
                    Linhas[i].RecursoID == RecursoID)
                    {
                        repetido++;//Espaçamento entre linhas repetidas...
                    }
                }

                if (Processo)
                {
                    //Linhas com pontos de partida de processos
                    if (recursoM.Top < (processoM.Top + 50) && recursoM.Top > (processoM.Top - 50))
                    {
                        if (recursoM.Left > processoM.Left)
                        {
                            //linha direita
                            p.Data = Geometry.Parse(
                                "M " + (processoM.Left + 40) + " " + (processoM.Top + 10) +
                                " L " + ((int)((processoM.Left + recursoM.Left) / 2)) + " " + ((int)(((processoM.Top + 10) + (recursoM.Top + 20)) / 2) + (repetido * 5)) +
                                " L " + recursoM.Left + " " + (recursoM.Top + 20) +
                                " L " + recursoM.Left + " " + ((recursoM.Top + 20) + 5) +
                                " L " + (recursoM.Left + 5) + " " + (recursoM.Top + 20) +
                                " L " + recursoM.Left + " " + ((recursoM.Top + 20) - 5) +
                                " L " + recursoM.Left + " " + (recursoM.Top + 20));
                        }
                        else
                        {
                            //linha esquerda
                            p.Data = Geometry.Parse(
                                "M " + (processoM.Left) + " " + (processoM.Top + 10) +
                                " L " + ((int)((processoM.Left + (recursoM.Left + 40)) / 2)) + " " + ((int)(((processoM.Top + 10) + (recursoM.Top + 20)) / 2) + (repetido * 5)) +
                                " L " + (recursoM.Left + 40) + " " + (recursoM.Top + 20) +
                                " L " + (recursoM.Left + 40) + " " + ((recursoM.Top + 20) + 5) +
                                " L " + ((recursoM.Left + 40) - 5) + " " + (recursoM.Top + 20) +
                                " L " + (recursoM.Left + 40) + " " + ((recursoM.Top + 20) - 5) +
                                " L " + (recursoM.Left + 40) + " " + (recursoM.Top + 20));
                        }
                    }
                    else
                    {
                        if (recursoM.Left > (processoM.Left + 50))
                        {
                            repetido = repetido * 15;
                        }
                        else
                        {
                            repetido = repetido * 5;
                        }

                        if (recursoM.Top > (processoM.Top + 50))
                        {
                            //linha baixo
                            p.Data = Geometry.Parse(
                                "M " + (processoM.Left + 20) + " " + (processoM.Top + 20) +
                                " L " + ((int)(((processoM.Left + 20) + (recursoM.Left)) / 2) + repetido) + " " + ((int)((recursoM.Top + (processoM.Top + 20)) / 2)) +
                                " L " + (recursoM.Left + 20) + " " + recursoM.Top +
                                " L " + ((recursoM.Left + 20) + 5) + " " + (recursoM.Top - 10) +
                                " L " + ((recursoM.Left + 20) - 5) + " " + (recursoM.Top - 10) +
                                " L " + (recursoM.Left + 20) + " " + recursoM.Top);
                        }
                        else
                        {
                            //linha topo
                            p.Data = Geometry.Parse(
                                "M " + (processoM.Left + 20) + " " + processoM.Top +
                                " L " + (((int)((processoM.Left + 20) + (recursoM.Left + 20)) / 2) + repetido) + " " + ((int)(((recursoM.Top + 40) + processoM.Top) / 2)) +
                                " L " + (recursoM.Left + 20) + " " + (recursoM.Top + 40) +
                                " L " + ((recursoM.Left + 20) + 5) + " " + ((recursoM.Top + 40) + 10) +
                                " L " + ((recursoM.Left + 20) - 5) + " " + ((recursoM.Top + 40) + 10) +
                                " L " + (recursoM.Left + 20) + " " + (recursoM.Top + 40));
                        }
                    }

                }
                else
                {
                    //Linhas com pontos de partida de de recursos
                    if (processoM.Top < (recursoM.Top + 50) && processoM.Top > (recursoM.Top - 50))
                    {
                        if (processoM.Left > recursoM.Left)
                        {
                            //linha direita
                            p.Data = Geometry.Parse(
                                "M " + (recursoM.Left + 40) + " " + (recursoM.Top + 20) +
                                " L " + ((int)((recursoM.Left + processoM.Left) / 2)) + " " + ((int)(((recursoM.Top + 20) + (processoM.Top + 10)) / 2) + (repetido * 5)) +
                                " L " + processoM.Left + " " + (processoM.Top + 10) +
                                " L " + processoM.Left + " " + ((processoM.Top + 10) + 5) +
                                " L " + (processoM.Left + 5) + " " + (processoM.Top + 10) +
                                " L " + processoM.Left + " " + ((processoM.Top + 10) - 5) +
                                " L " + processoM.Left + " " + (processoM.Top + 10));
                        }
                        else
                        {
                            //linha esquerda
                            p.Data = Geometry.Parse(
                                "M " + (recursoM.Left) + " " + (recursoM.Top + 20) +
                                " L " + ((int)((recursoM.Left + (processoM.Left + 40)) / 2)) + " " + ((int)(((recursoM.Top + 20) + (processoM.Top + 10)) / 2) + (repetido * 5)) +
                                " L " + (processoM.Left + 40) + " " + (processoM.Top + 10) +
                                " L " + (processoM.Left + 40) + " " + ((processoM.Top + 10) + 5) +
                                " L " + ((processoM.Left + 40) - 5) + " " + (processoM.Top + 10) +
                                " L " + (processoM.Left + 40) + " " + ((processoM.Top + 10) - 5) +
                                " L " + (processoM.Left + 40) + " " + (processoM.Top + 10));
                        }
                    }
                    else
                    {
                        if (recursoM.Left > (processoM.Left + 50))
                        {
                            repetido = repetido * 15;
                        }
                        else
                        {
                            repetido = repetido * 5;
                        }

                        if (processoM.Top > (recursoM.Top + 50))
                        {
                            //linha baixo
                            p.Data = Geometry.Parse(
                                "M " + (recursoM.Left + 20) + " " + (recursoM.Top + 40) +
                                " L " + ((int)(((recursoM.Left + 20) + (processoM.Left)) / 2) + repetido) + " " + ((int)((processoM.Top + (recursoM.Top + 40)) / 2)) +
                                " L " + (processoM.Left + 20) + " " + processoM.Top +
                                " L " + ((processoM.Left + 20) + 5) + " " + (processoM.Top - 10) +
                                " L " + ((processoM.Left + 20) - 5) + " " + (processoM.Top - 10) +
                                " L " + (processoM.Left + 20) + " " + processoM.Top);
                        }
                        else
                        {
                            //linha topo
                            p.Data = Geometry.Parse(
                                "M " + (recursoM.Left + 20) + " " + recursoM.Top +
                                " L " + (((int)((recursoM.Left + 20) + (processoM.Left + 20)) / 2) + repetido) + " " + ((int)(((processoM.Top + 40) + recursoM.Top) / 2)) +
                                " L " + (processoM.Left + 20) + " " + (processoM.Top + 20) +
                                " L " + ((processoM.Left + 20) + 5) + " " + ((processoM.Top + 20) + 10) +
                                " L " + ((processoM.Left + 20) - 5) + " " + ((processoM.Top + 20) + 10) +
                                " L " + (processoM.Left + 20) + " " + (processoM.Top + 20));
                        }
                    }
                }

                cont++;
                Linha linha = new Linha { ID = cont, ProcessoID = ProcessoID, RecursoID = RecursoID, Path = p, Processo = Processo };
                Linhas.Add(linha);
            }
        }
コード例 #2
0
        private void btnFinalizar_Click(object sender, RoutedEventArgs e)
        {
            if (WPRecursos2.Items.Count > 0 || WPProcessos2.Items.Count > 0)
            {

                //Inicializa as listas
                funcoes.Processos = new List<Processos>();
                funcoes.Recursos = new List<Recursos>();
                funcoes.Linhas = new List<Linha>();
                funcoes.Elementos = new List<UIElement>();

                //Criar e adiciona a lista os recursos
                int Top = 110;
                int Left = 10;
                for (int i = 0; i < WPRecursos.Items.Count; i++)
                {
                    Recursos recurso = new Recursos();
                    recurso.ID = i;
                    if (string.IsNullOrWhiteSpace(((UCRescurso)WPRecursos.Items[i]).txtPontos.Text))
                    {
                        recurso.Pontos_Disponivel = 1;
                    }
                    else
                    {
                        recurso.Pontos_Disponivel = int.Parse(((UCRescurso)WPRecursos.Items[i]).txtPontos.Text);
                    }
                    recurso.Top = Top;
                    recurso.Left = Left;
                    recurso.Processos_Necessarios = new List<int>();
                    funcoes.Recursos.Add(recurso);
                    Left += 60;
                }

                //Criar e adiciona a lista os processos
                Top = 10;
                Left = 10;
                for (int i = 0; i < WPProcessos.Items.Count; i++)
                {
                    Processos processo = new Processos();
                    processo.ID = i;
                    processo.Top = Top;
                    processo.Left = Left;
                    processo.Recursos_Necessarios = new List<int>();
                    funcoes.Processos.Add(processo);
                    Left += 60;
                }

                /*=================================================================================*/

                //Adiciona os processos necessários pelo recurso
                for (int i = 0; i < WPRecursos2.Items.Count; i++)
                {
                    for (int x = 0; x < funcoes.Recursos.Count; x++)
                    {
                        if (FiltrarNumero(((UCRequer)WPRecursos2.Items[i]).cmb1.SelectedValue.ToString()) == funcoes.Recursos[x].ID)
                        {
                            funcoes.Recursos[x].Processos_Necessarios.Add(FiltrarNumero(((UCRequer)WPRecursos2.Items[i]).cmb2.SelectedValue.ToString()));
                            break;
                        }
                    }
                }

                //Adiciona os recursos necessários pelo processo
                for (int i = 0; i < WPProcessos2.Items.Count; i++)
                {
                    for (int x = 0; x < funcoes.Processos.Count; x++)
                    {
                        if (FiltrarNumero(((UCRequer)WPProcessos2.Items[i]).cmb1.SelectedValue.ToString()) == funcoes.Processos[x].ID)
                        {
                            funcoes.Processos[x].Recursos_Necessarios.Add(FiltrarNumero(((UCRequer)WPProcessos2.Items[i]).cmb2.SelectedValue.ToString()));
                            break;
                        }
                    }
                }

                //Guargar quantidade de processos que necessitam de recursos e vice versa
                for (int i = 0; i < funcoes.Processos.Count; i++)
                {
                    if (funcoes.Processos[i].Recursos_Necessarios.Count > 0)
                    {
                        funcoes.Processos_Necessitam_Recursos++;
                    }
                }
                for (int i = 0; i < funcoes.Recursos.Count; i++)
                {
                    if (funcoes.Recursos[i].Processos_Necessarios.Count > 0)
                    {
                        funcoes.Recursos_Necessitam_Processos++;
                    }
                }

                funcoes.Ilustrar();
                funcoes.Quantidade_Processos = WPProcessos2.Items.Count;
                funcoes.Quantidade_Recursos = WPRecursos2.Items.Count;

                MainWindow main = new MainWindow();
                main.funcoes = funcoes;
                main.Closing += Window_Closing;
                this.Hide();
                main.ShowDialog();
            }
            else
            {
                MessageBox.Show("Adicione alguma condição antes de continuar!");
            }
        }