Ejemplo n.º 1
0
 /// <summary>
 /// Constructor.
 /// </summary>
 /// <param name="elTipo">El tipo.</param>
 public CampoTipo(Tipo elTipo)
     : base(IdentificadorDeTipo)
 {
     miTipo = elTipo;
 }
        /// <summary>
        /// Devuelve el pincel para un tipo de polígono dado.
        /// </summary>
        /// <param name="elTipo">El tipo de polígono.</param>
        public static Brush Pincel(Tipo? elTipo)
        {
            // Pincel por defecto.
              Brush pincel = misPinceles[Tipo.TipoNulo];

              if (elTipo != null)
              {
            Brush pincelDelTipo = null;
            misPinceles.TryGetValue((Tipo)elTipo, out pincelDelTipo);
            if (pincelDelTipo != null)
            {
              pincel = pincelDelTipo;
            }
              }
              return pincel;
        }
            protected override void ProcesaLínea(string laLínea)
            {
                // Elimina espacios en blanco.
                string línea = laLínea.Trim();

                // Saltarse lineas en blanco y comentarios.
                bool laLíneaEstaEnBlanco = (línea == string.Empty);
                bool laLíneaEsComentario = línea.StartsWith("//");
                if (!laLíneaEstaEnBlanco & !laLíneaEsComentario)
                {
                  // Separa las letras.
                  string[] partes = línea.Split(',');

                  // Verifica que tenemos tres partes.
                  if (partes.Length != 3)
                  {
                throw new ArgumentException("No se encontraron 3 partes separadas por coma en la linea: " + línea);
                  }

                  // Lee las tres partes.
                  Tipo tipo = new Tipo(partes[0]);
                  Brush pincel = new SolidBrush(Color.FromName(partes[1]));
                  string descripción = partes[2];

                  // Llena los diccionarios.
                  misPinceles.Add(tipo, pincel);
                  Descripciones.Add(tipo, descripción);
                }
            }
 /// <summary>
 /// Devuelve la descripción para un tipo de polígono dado.
 /// </summary>
 /// <param name="elTipo">El tipo de polígono.</param>
 public static string Descripción(Tipo elTipo)
 {
     string descripcion;
       bool existe = Descripciones.TryGetValue(elTipo, out descripcion);
       if (!existe)
       {
     // Descripcion por defecto.
     descripcion = Descripciones[Tipo.TipoNulo];
       }
       return descripcion;
 }
        public void PruebaShowDialog()
        {
            #region Preparación general.
              // Crea un PDI para las pruebas.
              IEscuchadorDeEstatus escuchadorDeEstatus = new EscuchadorDeEstatusPorOmisión();
              ManejadorDeMapa manejadorDeMapa = new ManejadorDeMapa(escuchadorDeEstatus);
              string nombre = "Nombre";
              Tipo tipo = new Tipo("0xaaaa");
              const string clase = "POI";
              Coordenadas coordenadas = new Coordenadas(20, 30);
              List<Campo> campos = new List<Campo> {
              new CampoNombre (nombre),
              new CampoTipo (tipo),
              new CampoCoordenadas (CampoCoordenadas.IdentificadorDeCoordenadas, 0, coordenadas)
            };
              List<Pdi> pdis = new List<Pdi>{new Pdi(manejadorDeMapa, 1, clase, campos)};
              #endregion

              #region Caso 1: Apenas aparece la ventana el usuario apreta "Cambiar"
              {
            // En este caso el método Show() debería retornar None,
            // Y la propiedad TipoNuevo debería ser el tipo nulo.

            #region Preparación.
            // Inicializa objecto de prueba.
            VentanaCambiarTipoDePdi objectoDePrueba = new VentanaCambiarTipoDePdi();
            objectoDePrueba.Pdis = pdis;

            // Crea los probadores de los elementos de la interfase.
            ButtonTester botónCambiar = new ButtonTester("miBotónCambiar", objectoDePrueba);
            #endregion

            // Llama al método a probar.
            objectoDePrueba.Show();

            // Apreta el botón de "Cambiar".
            botónCambiar.Click();

            // Probar propiedades.
            Assert.AreEqual(DialogResult.None, objectoDePrueba.DialogResult, "DialogResult");
            Assert.AreEqual(Tipo.TipoNulo, objectoDePrueba.TipoNuevo, "TipoNuevo");
            Assert.AreEqual(pdis, objectoDePrueba.Pdis, "PDIs");

            // Cierra la ventana.
            objectoDePrueba.Close();
              }
              #endregion

              #region Caso 2: Apenas aparece la ventana el usuario apreta "Cancelar"
              {
            // En este caso el método Show() debería retornar Cancel,
            // Y la propiedad TipoNuevo debería ser el tipo nulo.

            #region Preparación.
            // Inicializa objecto de prueba.
            VentanaCambiarTipoDePdi objectoDePrueba = new VentanaCambiarTipoDePdi();
            objectoDePrueba.Pdis = pdis;

            // Crea los probadores de los elementos de la interfase.
            ButtonTester botónCancelar = new ButtonTester("miBotónCancelar", objectoDePrueba);
            #endregion

            // Llama al método a probar.
            objectoDePrueba.Show();

            // Apreta el botón de "Cancelar".
            botónCancelar.Click();

            // Probar propiedades.
            Assert.AreEqual(DialogResult.Cancel, objectoDePrueba.DialogResult, "DialogResult");
            Assert.AreEqual(Tipo.TipoNulo, objectoDePrueba.TipoNuevo, "TipoNuevo");
            Assert.AreEqual(pdis, objectoDePrueba.Pdis, "PDIs");

            // Cierra la ventana.
            objectoDePrueba.Close();
              }
              #endregion

              #region Caso 3: El usuario cambia el tipo inicial por uno válido.
              {
            // En este caso el método Show() debería retornar OK,
            // y la propiedad TipoNuevo debería ser el tipo nuevo.

            #region Preparación.
            // Inicializa objecto de prueba.
            VentanaCambiarTipoDePdi objectoDePrueba = new VentanaCambiarTipoDePdi();
            objectoDePrueba.Pdis = pdis;

            // Crea un tipo válido.
            string númeroTipoNuevoVálido = "100";
            Tipo tipoNuevoVálido = new Tipo("0x" + númeroTipoNuevoVálido);
            Assert.IsTrue(CaracterísticasDePdis.Descripciones.ContainsKey(tipoNuevoVálido), "El tipo nuevo debe ser conocido.");

            // Crea los probadores de los elementos de la interfase.
            ButtonTester botónCambiar = new ButtonTester("miBotónCambiar", objectoDePrueba);
            TextBoxTester textoTipoNuevo = new TextBoxTester("miTextoTipoNuevo", objectoDePrueba);
            #endregion

            // Llama al método a probar.
            objectoDePrueba.Show();

            // Simula el usuario poniendo un tipo válido.
            textoTipoNuevo.Properties.Focus();
            textoTipoNuevo.Enter(númeroTipoNuevoVálido);

            // Apreta el botón de "Cambiar".
            botónCambiar.Properties.Focus();
            botónCambiar.Click();

            // Probar propiedades.
            Assert.AreEqual(DialogResult.OK, objectoDePrueba.DialogResult, "DialogResult");
            Assert.AreEqual(tipoNuevoVálido, objectoDePrueba.TipoNuevo, "TipoNuevo");
            Assert.AreEqual(pdis, objectoDePrueba.Pdis, "PDIs");

            // Cierra la ventana.
            objectoDePrueba.Close();
              }
              #endregion

              #region Caso 4: El usuario cambia el tipo inicial por uno desconocido.
              {
            // En este caso el método Show() debería retornar None,
            // y la propiedad TipoNuevo debería ser el tipo desconocido.

            #region Preparación.
            // Inicializa objecto de prueba.
            VentanaCambiarTipoDePdi objectoDePrueba = new VentanaCambiarTipoDePdi();
            objectoDePrueba.Pdis = pdis;

            // Crea un tipo desconocido.
            string númeroTipoNuevoDesconocido = "bbbb";
            Tipo tipoNuevoDesconocido = new Tipo("0x" + númeroTipoNuevoDesconocido);
            Assert.IsFalse(CaracterísticasDePdis.Descripciones.ContainsKey(tipoNuevoDesconocido), "El tipo nuevo debe ser desconocido.");

            // Crea los probadores de los elementos de la interfase.
            ButtonTester botónCambiar = new ButtonTester("miBotónCambiar", objectoDePrueba);
            TextBoxTester textoTipoNuevo = new TextBoxTester("miTextoTipoNuevo", objectoDePrueba);
            #endregion

            // Llama al método a probar.
            objectoDePrueba.Show();

            // Simula el usuario poniendo un tipo desconocido.
            textoTipoNuevo.Properties.Focus();
            textoTipoNuevo.Enter(númeroTipoNuevoDesconocido);

            // Apreta el botón de "Cambiar".
            botónCambiar.Properties.Focus();
            botónCambiar.Click();

            // Probar propiedades.
            Assert.AreEqual(DialogResult.None, objectoDePrueba.DialogResult, "DialogResult");
            Assert.AreEqual(tipoNuevoDesconocido, objectoDePrueba.TipoNuevo, "TipoNuevo");
            Assert.AreEqual(pdis, objectoDePrueba.Pdis, "PDIs");

            // Cierra la ventana.
            objectoDePrueba.Close();
              }
              #endregion

              #region Caso 5: El usuario cambia el tipo inicial por uno inválido.
              {
            // En este caso el método Show() debería retornar None,
            // y la propiedad TipoNuevo debería ser el tipo nulo.

            #region Preparación.
            // Inicializa objecto de prueba.
            VentanaCambiarTipoDePdi objectoDePrueba = new VentanaCambiarTipoDePdi();
            objectoDePrueba.Pdis = pdis;

            // Crea un tipo inválido.
            // Un tipo inválido es aquel que genera una excepción cuando
            // se trata de construir una clase Tipo con el.
            string númeroTipoNuevoInválido = "ww";
            bool tipoEsInválido = false;
            try
            {
              new Tipo("0x" + númeroTipoNuevoInválido);
            }
            catch
            {
              tipoEsInválido = true;
            }
            Assert.IsTrue(tipoEsInválido, "El tipo nuevo debe ser inválido.");

            // Crea los probadores de los elementos de la interfase.
            ButtonTester botónCambiar = new ButtonTester("miBotónCambiar", objectoDePrueba);
            TextBoxTester textoTipoNuevo = new TextBoxTester("miTextoTipoNuevo", objectoDePrueba);
            #endregion

            // Llama al método a probar.
            objectoDePrueba.Show();

            // Simula el usuario poniendo un tipo inválido.
            textoTipoNuevo.Properties.Focus();
            textoTipoNuevo.Enter(númeroTipoNuevoInválido);

            // Apreta el botón de "Cambiar".
            botónCambiar.Properties.Focus();
            botónCambiar.Click();

            // Probar propiedades.
            Assert.AreEqual(DialogResult.None, objectoDePrueba.DialogResult, "DialogResult");
            Assert.AreEqual(Tipo.TipoNulo, objectoDePrueba.TipoNuevo, "TipoNuevo");
            Assert.AreEqual(pdis, objectoDePrueba.Pdis, "PDIs");

            // Cierra la ventana.
            objectoDePrueba.Close();
              }
              #endregion

              #region Caso 6: El usuario empiezar a cambiar el tipo, pero al final lo borra y lo deja en blanco.
              {
            // En este caso el método Show() debería retornar None,
            // y la propiedad TipoNuevo debería ser el tipo nulo.

            #region Preparación.
            // Inicializa objecto de prueba.
            VentanaCambiarTipoDePdi objectoDePrueba = new VentanaCambiarTipoDePdi();
            objectoDePrueba.Pdis = pdis;

            // Crea los probadores de los elementos de la interfase.
            ButtonTester botónCambiar = new ButtonTester("miBotónCambiar", objectoDePrueba);
            TextBoxTester textoTipoNuevo = new TextBoxTester("miTextoTipoNuevo", objectoDePrueba);
            #endregion

            // Llama al método a probar.
            objectoDePrueba.Show();

            // Simula el usuario empezando a cambiar el tipo y despues dejandolo en blanco.
            textoTipoNuevo.Properties.Focus();
            textoTipoNuevo.Enter("123");
            textoTipoNuevo.Properties.Text = string.Empty;

            // Apreta el botón de "Cambiar".
            botónCambiar.Properties.Focus();
            botónCambiar.Click();

            // Probar propiedades.
            Assert.AreEqual(DialogResult.None, objectoDePrueba.DialogResult, "DialogResult");
            Assert.AreEqual(Tipo.TipoNulo, objectoDePrueba.TipoNuevo, "TipoNuevo");
            Assert.AreEqual(pdis, objectoDePrueba.Pdis, "PDIs");

            // Cierra la ventana.
            objectoDePrueba.Close();
              }
              #endregion

              #region Caso 7: El usuario empiezar a cambiar el tipo, pero al final cancela.
              {
            // En este caso el método Show() debería retornar Cancel,
            // y la propiedad TipoNuevo debería ser el tipo nulo.

            #region Preparación.
            // Inicializa objecto de prueba.
            VentanaCambiarTipoDePdi objectoDePrueba = new VentanaCambiarTipoDePdi();
            objectoDePrueba.Pdis = pdis;

            // Crea los probadores de los elementos de la interfase.
            ButtonTester botónCancelar = new ButtonTester("miBotónCancelar", objectoDePrueba);
            TextBoxTester textoTipoNuevo = new TextBoxTester("miTextoTipoNuevo", objectoDePrueba);
            #endregion

            // Llama al método a probar.
            objectoDePrueba.Show();

            // Simula el usuario empezando a cambiar el tipo y despues dejandolo en blanco.
            textoTipoNuevo.Enter("123");
            textoTipoNuevo.Properties.Text = string.Empty;

            // Apreta el botón de "Cancelar".
            botónCancelar.Click();

            // Probar propiedades.
            Assert.AreEqual(DialogResult.Cancel, objectoDePrueba.DialogResult, "DialogResult");
            Assert.AreEqual(Tipo.TipoNulo, objectoDePrueba.TipoNuevo, "TipoNuevo");

            // Cierra la ventana.
            objectoDePrueba.Close();
              }
              #endregion

              #region Caso 8: Se usa con un PDI nulo.
              {
            // En este caso el método Show() debería retornar None,
            // y la propiedad TipoNuevo debería ser el tipo nulo.

            #region Preparación.
            // Inicializa objecto de prueba.
            VentanaCambiarTipoDePdi objectoDePrueba = new VentanaCambiarTipoDePdi();
            objectoDePrueba.Pdis = null;

            // Crea los probadores de los elementos de la interfase.
            ButtonTester botónCambiar = new ButtonTester("miBotónCambiar", objectoDePrueba);
            TextBoxTester textoTipoNuevo = new TextBoxTester("miTextoTipoNuevo", objectoDePrueba);
            #endregion

            // Llama al método a probar.
            objectoDePrueba.Show();

            // Simula el usuario empezando a cambiar el tipo y despues dejandolo en blanco.
            textoTipoNuevo.Properties.Focus();
            textoTipoNuevo.Enter("100");
            textoTipoNuevo.Properties.Text = string.Empty;

            // Apreta el botón de "Cambiar".
            botónCambiar.Properties.Focus();
            botónCambiar.Click();

            // Probar propiedades.
            Assert.AreEqual(DialogResult.None, objectoDePrueba.DialogResult, "DialogResult");
            Assert.AreEqual(Tipo.TipoNulo, objectoDePrueba.TipoNuevo, "TipoNuevo");

            // Cierra la ventana.
            objectoDePrueba.Close();
              }
              #endregion
        }
            protected override void ProcesaLínea(string laLínea)
            {
                // Elimina espacios en blanco.
                string línea = laLínea.Trim();

                // Saltarse lineas en blanco y comentarios.
                bool laLíneaEstaEnBlanco = (línea == string.Empty);
                bool laLíneaEsComentario = línea.StartsWith("//");
                if (!laLíneaEstaEnBlanco & !laLíneaEsComentario)
                {
                  // Separa las letras.
                  string[] partes = línea.Split(',');

                  // Verifica que tenemos dos partes.
                  if (partes.Length != 4)
                  {
                throw new ArgumentException("No se encontraron 4 partes separadas por coma en la linea: " + línea);
                  }

                  // Lee las cuatro partes.
                  Tipo tipo = new Tipo(partes[0]);
                  Color color = Color.FromName(partes[1]);
                  int ancho = int.Parse(partes[2]);
                  string descripción = partes[3];

                  // Llena los diccionarios.
                  Pen lápiz = new Pen(color, ancho);
                  misLápices.Add(tipo, lápiz);
                  misDescripciones.Add(tipo, descripción);
                }
            }
        /// <summary>
        /// Devuelve el lápiz para un tipo de polilinea dado.
        /// </summary>
        /// <param name="elTipo">El tipo de polilinea.</param>
        public static Pen Lápiz(Tipo? elTipo)
        {
            // Lápiz por defecto.
              Pen lápiz = misLápices[Tipo.TipoNulo];

              if (elTipo != null)
              {
            misLápices.TryGetValue((Tipo)elTipo, out lápiz);
              }

              return lápiz;
        }
Ejemplo n.º 8
0
 /// <summary>
 /// Constructor.
 /// </summary>
 /// <param name="elTipo">El tipo.</param>
 public CampoTipo(Tipo elTipo)
     : base(IdentificadorDeTipo)
 {
     miTipo = elTipo;
 }