Esempio n. 1
0
        private void selecionarObjeto(double mouseX, double mouseY)
        {
            var ponto        = new Ponto4D(mouseX, mouseY);
            var dentroDaBBox = this.objetoSelecionado != null && this.objetoSelecionado.BBox.DentroDaArea(ponto);

            if (this.objetoSelecionado != null && this.objetoSelecionado is Poligono && !this.movendoVertice && dentroDaBBox)
            {
                this.movendoVertice = true;
                ((Poligono)this.objetoSelecionado).SelecionarVertice(ponto);
                return;
            }
            else if (this.objetoSelecionado != null && this.objetoSelecionado is Poligono && this.movendoVertice && dentroDaBBox)
            {
                this.movendoVertice = false;
                ((Poligono)this.objetoSelecionado).SetVerticeSelecionado(null);
                return;
            }
            this.objetoSelecionado = null;
            foreach (Objeto objeto in this.objetosLista)
            {
                if (objeto is Poligono)
                {
                    var aux = ((Poligono)objeto).GetObjetoSelecao(ponto);
                    if (aux != null)
                    {
                        this.objetoSelecionado = aux;
                        break;
                    }
                }
            }
        }
Esempio n. 2
0
 private void criarFilho(double mouseX, double mouseY)
 {
     if (objetoNovo == null)
     {
         objetoNovo = new Poligono(objetoId + 1, objetoSelecionado);
         objetoSelecionado.FilhoAdicionar(objetoNovo);
         objetoNovo.PontosAdicionar(new Ponto4D(mouseX, mouseY));
         objetoNovo.PontosAdicionar(new Ponto4D(mouseX, mouseY));
     }
     else
     {
         objetoNovo.PontosAdicionar(new Ponto4D(mouseX, mouseY));
     }
 }
Esempio n. 3
0
 private void criarObjeto(double mouseX, double mouseY)
 {
     if (objetoNovo == null)
     {
         objetoNovo = new Poligono(objetoId + 1, null);
         objetosLista.Add(objetoNovo);
         objetoNovo.PontosAdicionar(new Ponto4D(mouseX, mouseY));
         objetoNovo.PontosAdicionar(new Ponto4D(mouseX, mouseY));
     }
     else
     {
         objetoNovo.PontosAdicionar(new Ponto4D(mouseX, mouseY));
     }
 }
 /// <summary>
 /// Método que permite remover o vértice selecionado.
 /// </summary>
 private void ApagarPontoAtual()
 {
     if (objetoNovo != null)
     {
         if (objetoNovo.QuantidadePontos() > 2)
         {
             objetoNovo.RemoverUltimoPonto();
         }
         else if (objetoNovo.QuantidadePontos() == 2)
         {
             objetoNovo.RemoverUltimoPonto();
             objetosLista.Remove(objetoNovo);
             objetoNovo = null;
         }
     }
 }
        /// <summary>
        /// Método que permite inserir vértice no polígono atual. Mostra o rastro ao desenhar segmentos do polígono
        /// </summary>
        private void AdicionarPoligono()
        {
            if (objetoSelecionado != null)
            {
                if (adicionarFilhos == true)
                {
                    if (objetoFilho == null)
                    {
                        objetoFilho = new ObjetoAramado("A" + ++objetoId);
                        objetoFilho.PontosAdicionar(new Ponto4D(mouseX, mouseY));
                    }
                    objetoFilho.DefinirPrimitiva(tipoPrimitiva);
                    objetoFilho.PontosAdicionar(new Ponto4D(mouseX, mouseY));
                    objetoSelecionado.FilhoAdicionar(objetoFilho);
                }
                else
                {
                    pontoSelecionado.X = mouseX;
                    pontoSelecionado.Y = mouseY;
                    objetoSelecionado.ReprocessarBBox();
                    pontoSelecionado         = null;
                    pontoSelecionadoOriginal = null;
                    objetoSelecionado        = null;
                    bBoxDesenhar             = false;
                }
            }
            else
            {
                adicionarFilhos = false;
                if (objetoNovo == null)
                {
                    objetoNovo = new ObjetoAramado("A" + ++objetoId);
                    objetoNovo.DefinirPrimitiva(tipoPrimitiva);
                    objetosLista.Add(objetoNovo);
                    objetoNovo.PontosAdicionar(new Ponto4D(mouseX, mouseY));
                }
                else
                {
                    objetoNovo.DefinirPrimitiva(tipoPrimitiva);
                }

                objetoNovo.PontosAdicionar(new Ponto4D(mouseX, mouseY));
            }
        }
        protected override void OnKeyDown(KeyboardKeyEventArgs e)
        {
            // N3-Exe2: usar o arquivo docs/umlClasses.wsd
            // N3-Exe3: usar o arquivo bin/documentação.XML -> ver exemplo CG_Biblioteca/bin/documentação.XML
            switch (e.Key)
            {
            case Key.Escape:     // N3-Exe4: Inserir ponto no polígono atual
                Exit();
                break;

            case Key.C:
                Console.Clear();
                break;

            case Key.X:
                if (objetoSelecionado != null)
                {
                    objetoSelecionado.PontosExibirObjeto();
                }
                break;

            case Key.E:     // Exibe os pontos do polígono
            {
                for (var i = 0; i < objetosLista.Count; i++)
                {
                    objetosLista[i].PontosExibirObjeto();
                }
                break;
            }

            case Key.O:
                bBoxDesenhar = !bBoxDesenhar;     // N3-Exe9: exibe a BBox
                break;

            case Key.M:     // Exibe a matriz
                if (objetoSelecionado != null)
                {
                    objetoSelecionado.ExibeMatriz();
                }
                break;

            case Key.P:     // N3-Exe7: Desenhar polígonos abertos ou fechados
                if (objetoNovo != null)
                {
                    tipoPrimitiva = tipoPrimitiva == PrimitiveType.LineStrip ? PrimitiveType.LineLoop : PrimitiveType.LineStrip;
                    objetoNovo.DefinirPrimitiva(tipoPrimitiva);
                }
                break;

            case Key.I:     // Atribui a matriz identidade
                if (objetoSelecionado != null)
                {
                    objetoSelecionado.AtribuirIdentidade();
                }
                break;

            case Key.Left:     // N3-Exe10: translação esquerda
                if (objetoSelecionado != null)
                {
                    objetoSelecionado.AplicarTransformacao(ObjetoAramado.TranslacaoXY, -10, 0);
                }
                break;

            case Key.Right:     // N3-Exe10: translação direita
                if (objetoSelecionado != null)
                {
                    objetoSelecionado.AplicarTransformacao(ObjetoAramado.TranslacaoXY, 10, 0);
                }
                break;

            case Key.Up:     // N3-Exe10: translação cima
                if (objetoSelecionado != null)
                {
                    objetoSelecionado.AplicarTransformacao(ObjetoAramado.TranslacaoXY, 0, 10);
                }
                break;

            case Key.Down:     // N3-Exe10: translação baixo
                if (objetoSelecionado != null)
                {
                    objetoSelecionado.AplicarTransformacao(ObjetoAramado.TranslacaoXY, 0, -10);
                }
                break;

            case Key.D:     // N3-Exe4: Remove vértice do polígono atual
                ApagarPontoAtual();
                break;

            case Key.V:     // N3-Exe4: Remove vértice do polígono selecionado
                RemoverPontoSelecionado();
                break;

            case Key.PageUp:     // N3-Exe11: escala
                if (objetoSelecionado != null)
                {
                    objetoSelecionado.AplicarTransformacao(ObjetoAramado.EscalaXY, 2, 2);
                }
                break;

            case Key.PageDown:     // N3-Exe11: escala
                if (objetoSelecionado != null)
                {
                    objetoSelecionado.AplicarTransformacao(ObjetoAramado.EscalaXY, 0.5, 0.5);
                }
                break;

            case Key.Home:     // N3-Exe11: escala
                if (objetoSelecionado != null)
                {
                    objetoSelecionado.AplicarTransformacao(ObjetoAramado.EscalaXYBBox, 0.5);
                }
                break;

            case Key.End:     // N3-Exe11: escala
                if (objetoSelecionado != null)
                {
                    objetoSelecionado.AplicarTransformacao(ObjetoAramado.EscalaXYBBox, 2);
                }
                break;

            case Key.Number1:     // N3-Exe12: rotação
                if (objetoSelecionado != null)
                {
                    objetoSelecionado.AplicarTransformacao(ObjetoAramado.RotacaoZ, 10);
                }
                break;

            case Key.Number2:     // N3-Exe12: rotação
                if (objetoSelecionado != null)
                {
                    objetoSelecionado.AplicarTransformacao(ObjetoAramado.RotacaoZ, -10);
                }
                break;

            case Key.Number3:     // N3-Exe12: rotação
                if (objetoSelecionado != null)
                {
                    objetoSelecionado.AplicarTransformacao(ObjetoAramado.RotacaoZBBox, 10);
                }
                break;

            case Key.Number4:     // N3-Exe12: rotação
                if (objetoSelecionado != null)
                {
                    objetoSelecionado.AplicarTransformacao(ObjetoAramado.RotacaoZBBox, -10);
                }
                break;

            case Key.T:     // N3-Exe4: Remve todos os vértices do polígono selecionado
                if (objetoSelecionado != null)
                {
                    objetoSelecionado.PontosRemoverTodos();
                }
                break;

            case Key.U:     // N3-Exe4: Remve o último vértice adicionado do polígono selecionado
                if (objetoSelecionado != null)
                {
                    objetoSelecionado.PontosRemoverUltimo();
                    if (objetoSelecionado.QuantidadePontos() == 0)
                    {
                        objetoSelecionado = null;
                    }
                }
                break;

            case Key.R:     // N3-Exe8: Muda a cor do polígono selecionado para vermelho
                if (objetoSelecionado != null)
                {
                    objetoSelecionado.Cor = Color.Red;
                }
                break;

            case Key.S:     // Seleciona o ponto do polígono mais próximo do clique
            {
                foreach (ObjetoAramado objeto in objetosLista)
                {
                    bool isInside = objeto.IsPointInPolygon(new Ponto4D(mouseX, mouseY));
                    if (isInside)
                    {
                        objetoSelecionado = objeto;
                        adicionarFilhos   = false;
                        break;
                    }
                }
                break;
            }

            case Key.G:     // N3-Exe8: Muda a cor do polígono selecionado para verde
                if (objetoSelecionado != null)
                {
                    objetoSelecionado.Cor = Color.Green;
                }
                break;

            case Key.B:     // N3-Exe8: Muda a cor do polígono selecionado para azul
                if (objetoSelecionado != null)
                {
                    objetoSelecionado.Cor = Color.Blue;
                }
                break;

            case Key.Enter:     // N3-Exe4: Finaliza o polígono atual
                if (objetoFilho != null)
                {
                    objetoFilho.PontosRemoverUltimo();
                    adicionarFilhos   = false;
                    objetoFilho       = null;
                    objetoSelecionado = null;
                    objetoNovo        = null;
                    pontoSelecionado  = null;
                }
                else if (objetoNovo != null)
                {
                    objetoSelecionado = objetoNovo;
                    objetoNovo.PontosRemoverUltimo();     // N3-Exe6: "troque" para deixar o rastro
                    objetoNovo = null;
                }
                break;

            case Key.Space:     // N3-Exe4: Inserir ponto no polígono atual
                AdicionarPoligono();
                break;

            case Key.F:
                adicionarFilhos = true;
                if (pontoSelecionado != null && pontoSelecionadoOriginal != null)
                {
                    pontoSelecionado.X = pontoSelecionadoOriginal.X;
                    pontoSelecionado.Y = pontoSelecionadoOriginal.Y;
                    pontoSelecionado   = null;
                }
                break;

            case Key.Number9:
                objetoSelecionado = null;     //TODO: remover está tecla e atribuir o null qdo não tiver um poligono
                break;
            }
        }
Esempio n. 7
0
 protected override void OnKeyDown(OpenTK.Input.KeyboardKeyEventArgs e)
 {
     // N3-Exe2: usar o arquivo docs/umlClasses.wsd
     // N3-Exe3: usar o arquivo bin/documentação.XML -> ver exemplo CG_Biblioteca/bin/documentação.XML
     if (e.Key == Key.Escape)
     {
         Exit();
     }
     else if (e.Key == Key.E)    // N3-Exe4: ajuda a conferir se os poligonos e vértices estão certos
     {
         for (var i = 0; i < objetosLista.Count; i++)
         {
             objetosLista[i].PontosExibirObjeto();
         }
     }
     else if (e.Key == Key.O)
     {
         bBoxDesenhar = !bBoxDesenhar;   // N3-Exe9: exibe a BBox
     }
     else if (e.Key == Key.M)
     {
         objetoSelecionado.ExibeMatriz();
     }
     else if (e.Key == Key.P)
     {
         objetoSelecionado.PontosExibirObjeto();
     }
     else if (e.Key == Key.I)
     {
         objetoSelecionado.AtribuirIdentidade();
     }
     //FIXME: não está atualizando a BBox com as transformações geométricas
     else if (e.Key == Key.Left)
     {
         objetoSelecionado.TranslacaoXY(-10, 0);
     }
     else if (e.Key == Key.Right)
     {
         objetoSelecionado.TranslacaoXY(10, 0);
     }
     else if (e.Key == Key.Up)
     {
         objetoSelecionado.TranslacaoXY(0, 10);
     }
     else if (e.Key == Key.Down)
     {
         objetoSelecionado.TranslacaoXY(0, -10);
     }
     else if (e.Key == Key.PageUp)
     {
         objetoSelecionado.EscalaXY(1.1, 1.1);
     }
     else if (e.Key == Key.PageDown)
     {
         objetoSelecionado.EscalaXY(0.9, 0.9);
     }
     else if (e.Key == Key.Home)
     {
         objetoSelecionado.EscalaXYBBox(0.5);
     }
     else if (e.Key == Key.End)
     {
         objetoSelecionado.EscalaXYBBox(2);
     }
     else if (e.Key == Key.Number1)
     {
         objetoSelecionado.RotacaoZ(10);
     }
     else if (e.Key == Key.Number2)
     {
         objetoSelecionado.RotacaoZ(-10);
     }
     else if (e.Key == Key.Number3)
     {
         objetoSelecionado.RotacaoZBBox(10);
     }
     else if (e.Key == Key.Number4)
     {
         objetoSelecionado.RotacaoZBBox(-10);
     }
     else if (e.Key == Key.Enter)
     {
         objetoSelecionado = objetoNovo;
         objetoNovo.PontosRemoverUltimo();   // N3-Exe6: "troque" para deixar o rastro
         objetoNovo = null;
     }
     else if (e.Key == Key.Space)
     {
         if (this.criandoObjeto)
         {
             this.criandoObjeto = false;
             if (this.objetoNovo != null)
             {
                 this.objetoNovo.PontosRemoverUltimo();
             }
             this.objetoNovo = null;
         }
         else
         {
             this.criandoObjeto = true;
         }
     }
     else if (e.Key == Key.Delete)
     {
         if (this.objetoSelecionado != null && !this.movendoVertice)
         {
             if (this.objetoSelecionado.PaiRef != null)
             {
                 this.objetoSelecionado.PaiRef.RemoverFilho(this.objetoSelecionado);
             }
             else
             {
                 this.objetosLista.Remove(this.objetoSelecionado);
             }
             this.objetoSelecionado = null;
         }
         else if (this.objetoSelecionado != null && this.movendoVertice)
         {
             ((Poligono)this.objetoSelecionado).RemoverVerticeSelecionado();
             this.movendoVertice = false;
         }
     }
     else if (e.Key == Key.C)
     {
         if (this.objetoSelecionado != null)
         {
             this.objetoSelecionado.Aberto = !this.objetoSelecionado.Aberto;
         }
     }
     else if (e.Key == Key.F)
     {
         this.criandoFilho = this.objetoSelecionado != null && !this.criandoFilho;
     }
     else if (e.Key == Key.R)
     {
         if (this.objetoSelecionado != null)
         {
             this.objetoSelecionado.AddRed();
         }
     }
     else if (e.Key == Key.G)
     {
         if (this.objetoSelecionado != null)
         {
             this.objetoSelecionado.AddGreen();
         }
     }
     else if (e.Key == Key.B)
     {
         if (this.objetoSelecionado != null)
         {
             this.objetoSelecionado.AddBlue();
         }
     }
 }