/// <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;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="elTipo">El tipo.</param>
public CampoTipo(Tipo elTipo)
: base(IdentificadorDeTipo)
{
miTipo = elTipo;
}