/// <summary>
/// Funcion hecha por VS al hacer doble click en ->. Esto debe ser el "search" del navegador.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnIr_Click(object sender, EventArgs e)
{
// Analizo la url ingresada. Si no comienza con http://, lo fuerzo.
if (!this.txtUrl.Text.Contains("http://"))
{
this.txtUrl.Text = "http://" + this.txtUrl.Text;
}
// Si no tiene extension tira
try
{
// Comienzo declarando una variable "Uri" y creo un Descargador.
Uri link = new Uri(this.txtUrl.Text);
Descargador descargador = new Descargador(link);
// Invovo al evento publico progresoDescarga y le paso el proceso. Luego al evento publico finDescarga.
descargador.progresoDescarga += this.ProgresoDescarga;
descargador.finDescarga += this.FinDescarga;
// Creo un hilo, pasandole referencia del metodo "public void IniciarDescarga()"
Thread hilo = new Thread(descargador.IniciarDescarga);
hilo.Start();
// Guardo la URL en el archivo.
archivos.guardar(this.txtUrl.Text);
}
catch (Exception exc)
{
this.rtxtHtmlCode.Text = exc.Message;
}
}
private void btnIr_Click(object sender, EventArgs e)
{
string url = txtUrl.Text;
//List<string> datos ;
if (!url.ToLower().StartsWith("http://"))
{
url = "http://" + url;
this.txtUrl.Text = url;
}
try
{
Uri uri = new Uri(url);
Descargador descargador = new Descargador(uri);
descargador.pCarga += new Descargador.ProgresoCarga(this.ProgresoDescarga);
descargador.descarga += new Descargador.Descarga(this.FinDescarga);
Thread hilo = new Thread(descargador.IniciarDescarga);
hilo.Start();
archivos.guardar(url);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
private void btnIr_Click(object sender, EventArgs e)
{
Uri direccion;
try
{
if (this.txtUrl.Text.Contains("https://") || this.txtUrl.Text.Contains("http://"))
{
direccion = new Uri(this.txtUrl.Text);
}
else
{
throw new Exception("Falta ingresar HTTP");
}
if (direccion != null)
{
Descargador descar = new Descargador(direccion);
descar.downloading += new Descargando(this.ProgresoDescarga);
descar.terminado += new Descargado(this.FinDescarga);
Thread hilo = new Thread(descar.IniciarDescarga);
hilo.Start();
archivos.guardar(this.txtUrl.Text);
}
}
catch (Exception exc)
{
MessageBox.Show(exc.ToString());
}
}
private void btnIr_Click(object sender, EventArgs e)
{
try
{
//mostrar y guardar en historial
string aux = "";
string aux2;
aux = "http://" + txtUrl.Text;
if (aux.StartsWith("http://"))
{
aux2 = aux;
}
else
{
aux2 = "http://" + aux;// string con http:// por defecto
}
Uri uri = new Uri(aux2);
Descargador web = new Descargador(uri);
web.EventoTiempo += new Hilo.Descargador.EventTiempo(ProgresoDescarga); //llama a ProgresoDescarga y genera la barra de carga
web.EventoFinal += new Hilo.Descargador.EventRaise(FinDescarga); //Llama a FinDescarga muestra el contenido en rtxtHtmlCode
Thread hilo = new Thread(web.IniciarDescarga);
hilo.Start(); //inicia el hilo (web.iniciarDescarga)
//web.IniciarDescarga();
//FinDescarga(aux2);
//rtxtHtmlCode.Text = aux2;
archivos.guardar(aux2);
}
catch (Exception auxExc)
{
MessageBox.Show("Introducir direccion web!!!");
}
}
private void btnIr_Click(object sender, EventArgs e)
{
try
{
Uri direccion;
Descargador descargador;
Thread hilo;
if (!this.txtUrl.Text.Contains("http://"))
{
this.txtUrl.Text = "http://" + this.txtUrl.Text;
}
direccion = new Uri(this.txtUrl.Text);
descargador = new Descargador(direccion);
descargador.ProgresoDescarga += this.ProgresoDescarga;
descargador.DescargaCompletada += this.FinDescarga;
hilo = new Thread(descargador.IniciarDescarga);
hilo.Start();
archivos.guardar(direccion.ToString());
}
catch (Exception exc)
{
MessageBox.Show(exc.Message);
}
}
/// <summary>
/// Al precionar el boton ir, se completara la url en caso de ser necesario y se realizara la descarga del contenido.
/// Luego se guarda la url en el archivo donde se almacena el historial
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnIr_Click(object sender, EventArgs e)
{
Uri url;
try
{
if (Uri.TryCreate(this.txtUrl.Text, UriKind.Absolute, out url) == false)
{
txtUrl.Text = "http://" + txtUrl.Text;
url = new Uri(txtUrl.Text);
}
Descargador descargador = new Descargador(url);
descargador.progresoDescarga += this.ProgresoDescarga;
descargador.finDescarga += this.FinDescarga;
Thread h = new Thread(descargador.IniciarDescarga);
h.Start();
archivos.guardar(this.txtUrl.Text);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Error!", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
private void btnIr_Click(object sender, EventArgs e)
{
string aux = "";
string aux2;
aux = "http://" + txtUrl.Text;
if (aux.StartsWith("http://"))
{
aux2 = aux;
}
else
{
aux2 = "http://" + aux;
}
Uri uri = new Uri(aux2);
Descargador web = new Descargador(uri);
web.EventoProgreso += new Hilo.Descargador.EventProgreso(ProgresoDescarga);
web.EventoCompletado += new Hilo.Descargador.EventCompletado(FinDescarga);
Thread hilo = new Thread(web.IniciarDescarga);
hilo.Start();
archivos.guardar(aux2);
}
private void btnIr_Click(object sender, EventArgs e)
{
if (!txtUrl.Text.Contains("http://") && !txtUrl.Text.Contains("https://"))
{
txtUrl.Text = "http://" + txtUrl.Text;
}
try
{
archivos.guardar(txtUrl.Text);
}
catch (Exception)
{
MessageBox.Show("Error al guardar historial");
}
try
{
descargador = new Descargador(new Uri(txtUrl.Text));
this.descargador.progreso += ProgresoDescarga;
this.descargador.finDescarga += FinDescarga;
hiloDescarga = new Thread(descargador.IniciarDescarga);
hiloDescarga.Start();
}
catch (Exception)
{
MessageBox.Show("Error al realizar la descarga.");
}
}
/// <summary>
/// accede a la pagina
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnIr_Click(object sender, EventArgs e)
{
if (!this.txtUrl.Text.Contains("https://"))
{
this.txtUrl.Text = this.txtUrl.Text.Insert(0, "https://");
}
Uri link = new Uri(this.txtUrl.Text);
try
{
Descargador descarga = new Descargador(link);
descarga.ProgresoDescarga += this.ProgresoDescarga;
descarga.FinDescarga += this.FinDescarga;
Thread hilo = new Thread(new ThreadStart(descarga.IniciarDescarga));
hilo.Start();
}
catch (Exception)
{
MessageBox.Show("Error en la pagina buscada");
}
finally
{
archivos.guardar(this.txtUrl.Text);
}
}
/// <summary>
/// Descarga como texto la pagina ingresada en el buscador y guarda su direccion (URL) en el archivo
/// con el cual se inicializo el atributo archivo de la clase.
/// </summary>
/// <param name="sender">Objeto que lanzo el evento.</param>
/// <param name="e">Argumentos pasados por el evento.</param>
private void btnIr_Click(object sender, EventArgs e)
{
try
{
Uri direccionWeb;
Descargador descargador;
Thread t;
this.txtUrl.Text = "http://" + this.txtUrl.Text;
direccionWeb = new Uri(this.txtUrl.Text);
descargador = new Descargador(direccionWeb);
// a los eventos del objeto descargador le registro sus respectivos manejadores...
descargador.CambioPorcentajeDescargaEvento += this.ProgresoDescarga;
descargador.DescargaFinalizadaEvento += this.FinDescarga;
descargador.ErrorEvento += this.ErrorDescargaMensaje;
// archivos es un objeto Texto instanciado con la direccion del archivo "historico.dat"
// guardar en el archivo la direccion ingresada.
archivo.guardar(direccionWeb.ToString());
// asigno al hilo la funcion a ejecutar.
t = new Thread(new ThreadStart(descargador.IniciarDescarga));
// comienza ejecucion.
t.Start();
}
catch (ArchivosException ex)
{
MessageBox.Show(ex.Message);
}
catch (Exception ex)
{
MessageBox.Show("ERROR. Algo fallo." + ex.Message);
}
}
/// <summary>
/// Verifica que la URL que se escribió en txtUrl sea válida, la guarda en el historial y inicializa la descarga,
/// laza exception si hubo algún problema al generar el descargador
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnIr_Click(object sender, EventArgs e)
{
if (txtUrl.Text == "Escriba aquí..." || !Regex.IsMatch(txtUrl.Text, @"\.(com|ar|net)$"))
{
MessageBox.Show("(!) Ingrese una URL válida");
}
else
{
if (!txtUrl.Text.Contains("http://"))
{
txtUrl.Text = "http://" + txtUrl.Text;
}
if (!archivos.guardar(txtUrl.Text))
{
MessageBox.Show("(!) No se pudo guardar la URL en el historial");
}
try
{
Descargador dl = new Descargador(new Uri(txtUrl.Text));
dl.ProgresoDL += ProgresoDescarga;
dl.FinDL += FinDescarga;
Thread tDl = new Thread(dl.IniciarDescarga);
tDl.Start();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
}
private void btnIr_Click(object sender, EventArgs e)
{
this.rtxtHtmlCode.Text = "";
//Si al texto ingresado en el textBox no se le antepuso "http://", se lo agrego.
string auxUrl = "";
if (!this.txtUrl.Text.Contains("http://"))
{
auxUrl = "http://" + txtUrl.Text;
}
try
{
Uri aux = new Uri(auxUrl);
Descargador desc = new Descargador(aux);
desc.progreso += this.ProgresoDescarga;
desc.fin += this.FinDescarga;
//Inicio el hilo pasándole el método del Descargador.
Thread miThread = new Thread(desc.IniciarDescarga);
miThread.Start();
this.txtUrl.Text = auxUrl;
archivos.guardar(auxUrl);
}
catch (Exception excep)
{
MessageBox.Show(excep.Message);
}
}
public bool agregarNuevaUrl(string param)
{
try
{
Archivos.Texto archivos = new Archivos.Texto(frmHistorial.ARCHIVO_HISTORIAL);
archivos.guardar(param);
return(true);
}
catch (Exception e)
{
throw new Exception("Agregando nueva url error: " + e.Message);
}
}
/// <summary>
/// Crea un URI con la url e inicia la descarga del codigo de la pagina web.
/// Guarda la direccion en el archivo
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnIr_Click(object sender, EventArgs e)
{
try
{
Uri direccion = new UriBuilder(this.txtUrl.Text).Uri;
Descargador cliente = new Descargador(direccion);
archivos.guardar(direccion.ToString());
cliente.ProgresoDescarga += this.ProgresoDescarga;
cliente.DescargaFinalizada += this.FinDescarga;
Thread T = new Thread(new ThreadStart(cliente.IniciarDescarga));
T.Start();
}
catch (Exception)
{
}
}
private void btnIr_Click(object sender, EventArgs e)
{
if (!(this.txtUrl.Text.StartsWith("http://")))
{
this.txtUrl.Text = "http://" + this.txtUrl.Text;
}
Uri uri = new Uri(this.txtUrl.Text);
archivos.guardar(this.txtUrl.Text);
Descargador descargador = new Descargador(uri);
ProgresoDescargaCallback progresoDescarga = ProgresoDescarga;
FinDescargaCallback finDescarga = FinDescarga;
descargador.IniciarDescarga();
progresoDescarga.Invoke(descargador._progreso);
finDescarga.Invoke(descargador._html);
Thread thread = new Thread(() =>
{
while (true)
{
if (descargador._progreso < 100)
{
progresoDescarga.Invoke(descargador._progreso);
if (descargador._progreso == 100)
{
progresoDescarga.Invoke(descargador._progreso);
break;
}
}
}
while (true)
{
if (descargador._html != "")
{
finDescarga.Invoke(descargador._html);
break;
}
}
});
thread.Start();
}
private void btnIr_Click(object sender, EventArgs e)
{
try
{
Uri direccion = new Uri("http://" + this.txtUrl.Text);
Descargador descargador = new Descargador(direccion);
descargador.progChanged += new ProgressChanged(this.ProgresoDescarga);
descargador.progCompleted += new ProgressCompleted(this.FinDescarga);
Thread hilo = new Thread(descargador.IniciarDescarga);
hilo.Start();
archivos.guardar(this.txtUrl.Text);
}catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Guarda en el archivo Jornada.txt los datos de la Jornada como texto.
/// El archivo se encontrara en EntidadesInstanciables/bin/Debug/
/// </summary>
/// <param name="jornada">Jornada que se desea guardar.</param>
/// <returns>
/// true si se pudo guardar. Si no puede guardar lanzara una excepcion ArchivosException.
/// false si no.
/// </returns>
public static bool Guardar(Jornada jornada)
{
/*
* Sigo pensando que tiene errores el TP, por ej esta funcion nunca va a devolver false, por lo tanto
* no tiene sentido que devuelva un bool. Sin embargo Es la forma en la que mas sentido le encontre
* segun el constructor de la clase ArchivosException y segun los metodos de las clases Texto y Xml que devuelven bool.
*/
bool b = false;
try
{
Archivos.Texto objTexto = new Archivos.Texto();
b = objTexto.guardar("Jornada.txt", jornada.ToString());
}
catch (Exception e)
{
throw new ArchivosException(e);
}
return(b);
}
private void btnIr_Click(object sender, EventArgs e)
{
try
{
if (!(txtUrl.Text.Substring(0, 4) == "http"))
{
txtUrl.Text = "http://" + txtUrl.Text;
}
archivos.guardar(txtUrl.Text);
Descargador descargador = new Descargador(new Uri(txtUrl.Text));
descargador.Progreso += this.ProgresoDescarga;
descargador.Completo += this.FinDescarga;
Thread hilo = new Thread(descargador.IniciarDescarga);
hilo.Start();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
private void btnIr_Click(object sender, EventArgs e)
{
try
{
if (txtUrl.Text.Substring(0, 7) != "http://")
{
txtUrl.Text = "http://" + txtUrl.Text;
}
archivos.guardar(txtUrl.Text);
Descargador desc = new Descargador(new Uri(txtUrl.Text));
desc.DelAux += ProgresoDescarga;
desc.DelAux2 += FinDescarga;
Thread hilo = new Thread(desc.IniciarDescarga);
hilo.Start();
}
catch (Exception exc)
{
MessageBox.Show(exc.Message);
//throw exc;
}
}
private void FinDescarga(string html)
{
try
{
if (rtxtHtmlCode.InvokeRequired)
{
FinDescargaCallback d = new FinDescargaCallback(FinDescarga);
this.Invoke(d, new object[] { html });
}
else
{
rtxtHtmlCode.Text = html;
Uri aux;
this.checkUrl(out aux);
archivos.guardar(aux.ToString());
}
}
catch (Exception e)
{
MessageBox.Show("PROBLEMAS" + e.ToString());
}
}
/// <summary>
/// De ser necesario modifico el url ingresado en txtUrl para que sea correcto y lanzo los eventos
/// Luego guardo la pagina buscada
/// En caso de haber algun error, lanzo evento con el mensaje de la excepcion
/// </summary>
private void btnIr_Click(object sender, EventArgs e)
{
try
{
Uri url;
if (!(Uri.TryCreate(this.txtUrl.Text, UriKind.Absolute, out url)))
{
txtUrl.Text = "http://" + txtUrl.Text;
url = new Uri(txtUrl.Text);
}
Descargador hilo = new Descargador(url);
hilo.DescargaEnProgreso += this.ProgresoDescarga;
hilo.DescargaFinalizada += this.FinDescarga;
hilo.IniciarDescarga();
archivos.guardar(this.txtUrl.Text);
}
catch (Exception ex)
{
this.FinDescarga(ex.Message);
}
}
private void btnIr_Click(object sender, EventArgs e)
{
try
{
Regex reg = new Regex(@"^[Hh]ttp://");
if (!reg.IsMatch(txtUrl.Text))
{
txtUrl.Text = "http://" + txtUrl.Text;
}
Descargador descargador = new Descargador(new Uri(this.txtUrl.Text));
descargador.enProgreso += new Descargador.EnProgreso(this.ProgresoDescarga);
descargador.completo += new Descargador.Completo(this.FinDescarga);
Thread hilo = new Thread(descargador.IniciarDescarga);
hilo.Start();
archivos.guardar(this.txtUrl.Text);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
static void Main(string[] args)
{
/* Por lo que entiendo, para serializar se necesita que las clases tengan
* acceso a los miembros. si tienen miembros privados, que estos tengan sus
* propiedades publicas correspondientes. Y tambien tienen que tener
* un constructor por defecto. */
Person p = new Person("nacho");
Person p1 = new Person("eze");
Person p2 = new Person("marta");
Family f = new Family();
f.lsPerson.Add(p);
f.lsPerson.Add(p1);
f.lsPerson.Add(p2);
/* serializacion xml */
/* guardar */
bool b = false;
try
{
Archivos.Xml <Family> objXml = new Archivos.Xml <Family>();
b = objXml.guardar("family.xml", f);
}
catch (Exception e)
{
Console.WriteLine("ERROR: " + e.Message);
}
Console.WriteLine("b vale: " + b);
/* leer xml */
Console.WriteLine("\n\n");
Console.WriteLine("LEO EL ARCHIVO.");
Family f2;
try
{
Archivos.Xml <Family> auxLeer = new Archivos.Xml <Family>();
auxLeer.leer("Family.xml", out f2);
}
catch (Exception e)
{
Console.WriteLine("ERROR: " + e.Message);
}
/* ARCHIVOS txt */
/* guardar */
//Family f = new Family();
bool b2 = false;
try
{
Archivos.Texto objTexto = new Archivos.Texto();
b2 = objTexto.guardar("Family.txt", f.ToString());
}
catch (Exception e)
{
Console.WriteLine("ERROR: " + e.Message);
}
/* lectura */
string datos = "";
try
{
Archivos.Texto objTexto = new Archivos.Texto();
objTexto.leer("Family.txt", out datos);
}
catch (Exception e)
{
Console.WriteLine("ERROR: " + e.Message);
}
Console.WriteLine("Datos Leidos: ");
Console.WriteLine(datos);
Console.ReadKey();
}
