public void Salvar(string nomeArq)
        {
            StreamWriter arq = new StreamWriter(nomeArq);

            var atual = objetos.primeiro;

            while (atual != null)
            {
                if (atual.info.GetType().Equals(typeof(Circulo)))
                {
                    Circulo circ = atual.info as Circulo;
                    arq.WriteLine(circ.ToString());
                }
                else
                if (atual.info.GetType().Equals(typeof(Retangulo)))
                {
                    Retangulo ret = atual.info as Retangulo;
                    arq.WriteLine(ret.ToString());
                }
                else
                if (atual.info.GetType().Equals(typeof(Linha)))
                {
                    Linha lin = atual.info as Linha;
                    arq.WriteLine(lin.ToString());
                }
                else
                if (atual.info.GetType().Equals(typeof(Elipse)))
                {
                    Elipse el = atual.info as Elipse;
                    arq.WriteLine(el.ToString());
                }
                atual = atual.prox;
            }
            arq.Close();
        }
        public override bool Contem(Ponto p)
        {
            NoLista <Ponto> inicio, fim;

            if (vertices.QtosNos == 0)
            {
                return(false);
            }
            if (vertices.QtosNos == 1)
            {
                return(vertices.primeiro.info.Contem(p));
            }
            inicio = vertices.primeiro;
            fim    = inicio.prox;
            while (fim != null)
            {
                var l = new Linha(inicio.info, fim.info);
                if (l.Contem(p))
                {
                    return(true);
                }
                inicio = fim;
                fim    = fim.prox;
            }
            return(false);
        }
        public Linha[] GetLados()
        {
            var lados = new Linha[4];

            for (int counter = 0; counter < 4; counter++)
            {
                lados[counter] = new Linha(this.Vertices[counter], this.Vertices[(counter + 1) % 4]);
            }
            return(lados);
        }
示例#4
0
        private void abrirToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (dlgAbrir.ShowDialog() == DialogResult.OK)     // abertura do arquivo, sua leitura e armazenamento de figuras na lista ligada
            {
                StreamReader arq = new StreamReader(dlgAbrir.FileName);

                drawArea.Objetos = new ListaSimples <Figura>();
                Color  c = new Color();
                Ponto  pi; // ponto inicial/origem/centro
                string linha = null;
                nomeArqAberto = dlgAbrir.FileName;
                while ((linha = arq.ReadLine()) != null)
                {
                    string fig = linha.Substring(0, 5);
                    fig = fig.Trim();
                    if (fig.Equals("p"))                                                    //assim como na documentação das instruções, foi feito o abrir
                    {                                                                       //verificando, sempre, a primeira letra para identificar a figura
                                                                                            //a ser criada
                        c = Color.FromArgb(Convert.ToInt16(linha.Substring(15, 5)),
                                           Convert.ToInt16(linha.Substring(20, 5)), Convert.ToInt16(linha.Substring(25, 5)));

                        pi = new Ponto(Convert.ToInt16(linha.Substring(5, 5)), Convert.ToInt16(linha.Substring(10, 5)), c);
                        drawArea.AdicionarObjeto(pi);
                    }
                    else
                    if (fig.Equals("c"))
                    {
                        c = Color.FromArgb(Convert.ToInt16(linha.Substring(15, 5)),
                                           Convert.ToInt16(linha.Substring(20, 5)), Convert.ToInt16(linha.Substring(25, 5)));

                        pi = new Ponto(Convert.ToInt16(linha.Substring(5, 5)), Convert.ToInt16(linha.Substring(10, 5)));
                        Circulo circ = new Circulo(pi, Convert.ToInt16(linha.Substring(30, 5)), c);
                        drawArea.AdicionarObjeto(circ);
                    }
                    else
                    if (fig.Equals("l"))
                    {
                        c = Color.FromArgb(Convert.ToInt16(linha.Substring(15, 5)),
                                           Convert.ToInt16(linha.Substring(20, 5)), Convert.ToInt16(linha.Substring(25, 5)));

                        pi = new Ponto(Convert.ToInt16(linha.Substring(5, 5)), Convert.ToInt16(linha.Substring(10, 5)));
                        Ponto Pf = new Ponto(Convert.ToInt16(linha.Substring(30, 5)), Convert.ToInt16(linha.Substring(35, 5)));


                        Linha l = new Linha(pi, Pf, c);
                        drawArea.AdicionarObjeto(l);
                    }
                    else
                    if (fig.Equals("e"))
                    {
                        pi = new Ponto(Convert.ToInt16(linha.Substring(5, 5)), Convert.ToInt16(linha.Substring(10, 5)));

                        c = Color.FromArgb(Convert.ToInt16(linha.Substring(15, 5)),
                                           Convert.ToInt16(linha.Substring(20, 5)), Convert.ToInt16(linha.Substring(25, 5)));
                        int    raio1 = Convert.ToInt16(linha.Substring(30, 5));
                        int    raio2 = Convert.ToInt16(linha.Substring(35, 5));
                        Elipse el    = new Elipse(pi, raio1, raio2);
                        el.CorContorno = c;
                        drawArea.AdicionarObjeto(el);
                    }
                }
                arq.Close();
                Graphics.FromImage(salvo).Clear(BackColor);
                drawArea.Context = Graphics.FromImage(salvo);   //O picturebox 'empresta' o contexto para o arquivo bitmap
                drawArea.Desenhar();
                drawArea.Context    = pbAreaDesenho.CreateGraphics();
                pbAreaDesenho.Image = salvo;
            }
        }
示例#5
0
        private void pbAreaDesenho_MouseMove(object sender, MouseEventArgs e)
        {
            statusPosicao.Text = "X: " + e.X + ", Y: " + e.Y;

            var posCursor = new Ponto(e.X, e.Y);

            var temp = (Bitmap)salvo.Clone();   //Cria um bitmap temporário para exibir formas ainda não definitivas

            if (!pontos.estaVazia() && selTool != "")
            {
                switch (selTool)
                {
                case "circulo":
                    var c = drawArea.Objetos.ultimo.info as Circulo;
                    c.SetRaio(Convert.ToInt32(new Ponto(c.Posicao.X, c.Posicao.Y).GetDistancia(posCursor)));
                    break;

                case "retangulo":
                    //var r = (drawArea.Objetos.ultimo.info as Retangulo);
                    var pInicial = new Ponto(Math.Min(posCursor.Posicao.X, pontos.primeiro.info.Posicao.X), Math.Min(posCursor.Posicao.Y, pontos.primeiro.info.Posicao.Y));
                    var pFinal   = new Ponto(Math.Max(posCursor.Posicao.X, pontos.primeiro.info.Posicao.X), Math.Max(posCursor.Posicao.Y, pontos.primeiro.info.Posicao.Y));
                    (drawArea.Objetos.ultimo.info as Retangulo).Posicao = pInicial.ToPoint();
                    (drawArea.Objetos.ultimo.info as Retangulo).Altura  = pFinal.Y - pInicial.Y;
                    (drawArea.Objetos.ultimo.info as Retangulo).Largura = pFinal.X - pInicial.X;
                    statusDesenho.Text = "Retangulo(";
                    foreach (Ponto p in (drawArea.Objetos.ultimo.info as Retangulo).Vertices)
                    {
                        statusDesenho.Text += "(" + p.X + "," + p.Y + ")";
                    }
                    statusDesenho.Text += "), Largura: " + (drawArea.Objetos.ultimo.info as Retangulo).Largura + ", Altura: " + (drawArea.Objetos.ultimo.info as Retangulo).Altura;
                    break;

                case "linha":
                    (drawArea.Objetos.ultimo.info as Linha).PontoFim = posCursor;
                    break;

                case "polilinha":
                    (drawArea.Objetos.ultimo.info as Polilinha).Vertices.ultimo.info = posCursor;
                    break;

                case "desenho livre":
                    (drawArea.Objetos.ultimo.info as Polilinha).Vertices.insereAposFim(new NoLista <Ponto>(posCursor, null));
                    break;

                case "elipse":
                    pInicial = new Ponto(Math.Min(posCursor.Posicao.X, pontos.primeiro.info.Posicao.X), Math.Min(posCursor.Posicao.Y, pontos.primeiro.info.Posicao.Y));
                    pFinal   = new Ponto(Math.Max(posCursor.Posicao.X, pontos.primeiro.info.Posicao.X), Math.Max(posCursor.Posicao.Y, pontos.primeiro.info.Posicao.Y));
                    (drawArea.Objetos.ultimo.info as Elipse).Posicao = pInicial.ToPoint();
                    (drawArea.Objetos.ultimo.info as Elipse).Altura  = pFinal.Y - pInicial.Y;
                    (drawArea.Objetos.ultimo.info as Elipse).Largura = pFinal.X - pInicial.X;
                    break;

                case "selecao":
                    selecionados = new ListaSimples <Figura>();
                    pInicial     = new Ponto(Math.Min(posCursor.Posicao.X, pontos.primeiro.info.Posicao.X), Math.Min(posCursor.Posicao.Y, pontos.primeiro.info.Posicao.Y));
                    pFinal       = new Ponto(Math.Max(posCursor.Posicao.X, pontos.primeiro.info.Posicao.X), Math.Max(posCursor.Posicao.Y, pontos.primeiro.info.Posicao.Y));
                    var rect = new Retangulo(pInicial, Math.Abs(pFinal.X - pInicial.X), Math.Abs(pFinal.Y - pInicial.Y));
                    rect.CorContorno      = Color.Black;
                    rect.Preencher        = true;
                    rect.Espessura        = 3;
                    rect.CorPreenchimento = Color.FromArgb(60, 0, 0, 255);
                    rect.desenhar(Graphics.FromImage(temp));

                    if (pontos.QtosNos < 2)
                    {
                        pontos.insereAposFim(new NoLista <Ponto>(posCursor, null));
                    }
                    pontos.primeiro.prox.info = posCursor;
                    //pontos.insereAposFim(new NoLista<Ponto>(pInicial, null));
                    //pontos.insereAposFim(new NoLista<Ponto>(pFinal, null));
                    break;

                case "deslocar":
                    //var deltaX = posCursor.X - pontos.primeiro.info.X;
                    //var deltaY = posCursor.Y - pontos.primeiro.info.Y;
                    //var atual = selecionados.primeiro;
                    break;
                }
            }

            if ((selTool == "selecao" || selTool == "deslocar" || selTool == "ajustar" || selTool == "rotacionar") && !selecionados.estaVazia())
            {
                var       forma = selecionados.primeiro;
                Retangulo rec;
                while (forma != null)
                {
                    switch (forma.info.GetType().ToString())    //Destaca 'pontos notáveis' nas figuras selecionadas
                    {
                    case "pEditorGrafico.Retangulo":
                        foreach (Ponto p in (forma.info as Retangulo).Vertices)
                        {
                            rec                  = new Retangulo(new Ponto(p.X - 2, p.Y - 2), 4, 4);
                            rec.Espessura        = 2;
                            rec.Preencher        = true;
                            rec.CorPreenchimento = Color.LightGray;
                            rec.desenhar(Graphics.FromImage(temp));
                        }
                        break;

                    case "pEditorGrafico.Circulo":
                        var pt = new Ponto(forma.info.Posicao.X - 2, forma.info.Posicao.Y - 2) + new Ponto((forma.info as Circulo).Raio, 0);
                        rec                  = new Retangulo(pt, 4, 4);
                        rec.Espessura        = 2;
                        rec.Preencher        = true;
                        rec.CorPreenchimento = Color.LightGray;
                        rec.desenhar(Graphics.FromImage(temp));
                        break;

                    case "pEditorGrafico.Linha":
                        foreach (Ponto p in (forma.info as Linha).Vertices)
                        {
                            rec                  = new Retangulo(new Ponto(p.X - 2, p.Y - 2), 4, 4);
                            rec.Espessura        = 2;
                            rec.Preencher        = true;
                            rec.CorPreenchimento = Color.LightGray;
                            rec.desenhar(Graphics.FromImage(temp));
                        }
                        break;

                    case "pEditorGrafico.Ponto":
                        pt                   = (forma.info as Ponto);
                        rec                  = new Retangulo(new Ponto(pt.X - 2, pt.Y - 2), 4, 4);
                        rec.Espessura        = 2;
                        rec.Preencher        = true;
                        rec.CorPreenchimento = Color.LightGray;
                        rec.desenhar(Graphics.FromImage(temp));
                        break;

                    case "pEditorGrafico.Polilinha":
                        var poli    = (forma.info as Polilinha);
                        var vertice = poli.Vertices.primeiro;
                        while (vertice != null)
                        {
                            rec                  = new Retangulo(new Ponto(vertice.info.X - 2, vertice.info.Y - 2), 4, 4);
                            rec.Espessura        = 2;
                            rec.Preencher        = true;
                            rec.CorPreenchimento = Color.LightGray;
                            rec.desenhar(Graphics.FromImage(temp));
                            vertice = vertice.prox;
                        }
                        break;

                    case "pEditorGrafico.Elipse":
                        Ponto[] ladosEl;
                        ladosEl = new Ponto[4];
                        var el = (forma.info as Elipse);
                        ladosEl[0] = new Ponto(el.Posicao.X + el.Largura / 2, el.Posicao.Y);
                        ladosEl[1] = new Ponto(el.Posicao.X + el.Largura, el.Posicao.Y + el.Altura / 2);
                        ladosEl[2] = new Ponto(el.Posicao.X + el.Largura / 2, el.Posicao.Y + el.Altura);
                        ladosEl[3] = new Ponto(el.Posicao.X, el.Posicao.Y + el.Altura / 2);
                        foreach (Ponto p in ladosEl)
                        {
                            rec                  = new Retangulo(new Ponto(p.X - 2, p.Y - 2), 4, 4);
                            rec.Espessura        = 2;
                            rec.Preencher        = true;
                            rec.CorPreenchimento = Color.LightGray;
                            rec.desenhar(Graphics.FromImage(temp));
                        }
                        break;
                    }
                    forma = forma.prox;
                }
            }
            NoLista <Figura> atual;

            /*if(!selecionados.estaVazia() && selTool=="deslocar")
             * {
             *  bool achou = false;
             *  //pbAreaDesenho.Cursor = Cursors.Default;
             *  atual = selecionados.primeiro;
             *  while(atual != null)
             *  {
             *      if(atual.info.Contem(posCursor))
             *      {
             *          achou = true;
             *          break;
             *      }
             *      atual = atual.prox;
             *  }
             *  if (achou && pbAreaDesenho.Cursor!=Cursors.Hand)
             *      pbAreaDesenho.Cursor = Cursors.Hand;
             *  else
             *      if(pbAreaDesenho.Cursor != Cursors.Default)
             *          pbAreaDesenho.Cursor = Cursors.Default;
             * }*/

            if (!drawArea.Objetos.estaVazia())
            {
                drawArea.Objetos.ultimo.info.desenhar(Graphics.FromImage(temp));
            }

            atual = drawArea.Objetos.primeiro;
            while (atual != null)
            {
                switch (atual.info.GetType().ToString())
                {
                case "pEditorGrafico.Retangulo":
                    foreach (Ponto p in (atual.info as Retangulo).Vertices)
                    {
                        if (p.GetDistancia(posCursor) <= 4)
                        {
                            new Retangulo(new Ponto(p.X - 2, p.Y - 2), 4, 4).desenhar(Graphics.FromImage(temp));
                            break;
                        }
                    }
                    break;

                case "pEditorGrafico.Circulo":
                    var l = new Linha((atual.info as Circulo).GetCentro(), posCursor, Color.Black);
                    //statusDesenho.Text = "Inclinação: " + l.GetInclinacao();
                    var pCirculo = (atual.info as Circulo).GetPonto(l.GetInclinacao());
                    if (pCirculo.GetDistancia(posCursor) <= 6)
                    {
                        new Retangulo(new Ponto(pCirculo.X - 2, pCirculo.Y - 2), 4, 4).desenhar(Graphics.FromImage(temp));
                        break;
                    }
                    break;

                case "pEditorGrafico.Linha":
                    foreach (Ponto p in (atual.info as Linha).Vertices)
                    {
                        if (p.GetDistancia(posCursor) <= 4)
                        {
                            new Retangulo(new Ponto(p.X - 2, p.Y - 2), 4, 4).desenhar(Graphics.FromImage(temp));
                            break;
                        }
                    }
                    break;

                case "pEditorGrafico.Ponto":
                    var pt = (atual.info as Ponto);
                    if ((atual.info as Ponto).GetDistancia(posCursor) <= 4)
                    {
                        new Retangulo(new Ponto(pt.X - 2, pt.Y - 2), 4, 4).desenhar(Graphics.FromImage(temp));
                        break;
                    }
                    break;

                case "pEditorGrafico.Polilinha":
                    var poli    = (atual.info as Polilinha);
                    var vertice = poli.Vertices.primeiro;
                    while (vertice != null)
                    {
                        if (vertice.info.GetDistancia(posCursor) <= 4)
                        {
                            new Retangulo(new Ponto(vertice.info.X - 2, vertice.info.Y - 2), 4, 4).desenhar(Graphics.FromImage(temp));
                            break;
                        }
                        vertice = vertice.prox;
                    }
                    break;

                case "pEditorGrafico.Elipse":
                    Ponto[] ladosEl;
                    ladosEl = new Ponto[4];
                    var el = (atual.info as Elipse);
                    ladosEl[0] = new Ponto(el.Posicao.X + el.Largura / 2, el.Posicao.Y);
                    ladosEl[1] = new Ponto(el.Posicao.X + el.Largura, el.Posicao.Y + el.Altura / 2);
                    ladosEl[2] = new Ponto(el.Posicao.X + el.Largura / 2, el.Posicao.Y + el.Altura);
                    ladosEl[3] = new Ponto(el.Posicao.X, el.Posicao.Y + el.Altura / 2);
                    foreach (Ponto p in ladosEl)
                    {
                        if (p.GetDistancia(posCursor) <= 4)
                        {
                            new Retangulo(new Ponto(p.X - 2, p.Y - 2), 4, 4).desenhar(Graphics.FromImage(temp));
                            break;
                        }
                    }
                    break;
                }
                atual = atual.prox;
            }
            pbAreaDesenho.Image = temp;
        }