Páginas

Traducir

Desbloquear gestor de arranque / bootloader Huawei P8Lite ALE-21 2015 y otros modelos con HCU Client

¿ Qué es el gestor de arranque o bootloader ?

Es un pequeño programa que se inicia al encender el móvil y que se encarga de ejecutar el sistema operativo

¿ Para que desbloquear el gestor de arranque o bootloader ?

En la mayoría de móviles el gestor de arranque viene bloqueado para solo instalar el sistema operativo que permite el fabricante. Por lo tanto si lo desbloqueamos podremos instalar otros sistemas operativos o revisiones mas actualizadas en el móvil que antes no se permitía. El riesgo es que estos sistemas operativos como no son los oficiales carezcan de garantías para el buen funcionamiento del dispositivo.

¿ Como desbloquear un dispositivo Huawei ?

Se necesita un código de desbloqueo. Hasta hace poco el propio fabricante lo suministraba con solo pedirlo por correo electrónico. Pero apartir de Agosto de 2018 el fabricante ha dejado de hacerlo y si se pide por correo electrónico recibirás esta respuesta:

" Gracias por contactar con Huawei Device España.

Con el objetivo de mantener la mejor experiencia de usuario y evitar los diferentes problemas que podrían producirse del flasheo de ROMs, incluyendo fallos de sistema, fallos en el rendimiento de la batería y el riesgo de pérdida de datos personales, Huawei dejará de proporcionar los códigos de desbloqueo del bootloader. Siguiendo adelante, Huawei renueva su compromiso con proporcionar servicios y experiencias de calidad a sus usuarios. Gracias por su apoyo constante."

Por lo tanto la única manera de tener actualmente tu código de desbloqueo para tu dispositivo es con la ayuda de programas de terceros a cambio de un pequeño coste económico. Por ejemplo se puede usar el software HCU Client especial para dispositivos Huawei y obtener tu código de desbloqueo por unos 4Euros por ejemplo para el modelo Huawei P8Lite 2015.

¿ Cómo obtener mi código y desbloquear mi dispositivo Huawei con HCU Client ?

Antes hay que asegurarse que el programa soporta el dispositivo Huawei que tenemos. Cómo ejemplo y he comentado mas atrás la versión de Septiembre de 2018 soporta el Huawei P8Lite 2015 ALE-21

Una vez sabemos esto seguimos los siguientes pasos:

  1. En nuestro dispositivo vamos a Ajustes>Información del sistema y pulsamos 10 veces sobre el número de compilación para desbloquear las opciones de desarrollador Después de esto, vamos a Ajustes>Opciones de desarrollador y activamos la casilla “Habilitar desbloqueo OEM” y “Habilitar depuración USB“.
  2. Instalar HiSuite y en configuración poner que no se ejecute cuando conectes dispositivo.
  3. Crear cuenta para instalar HCU Client y así obtener código de desbloqueo del bootloader.

    Creamos una cuenta para poder usar el programa HCU Client https://www.dc-unlocker.com/buy Con esta cuenta compraremos créditos para poder obtener el código de desbloqueo. Los créditos se pueden comprar con PayPal y se necesitan 4 créditos para el Huawei P8Lite. Cada crédito vale 1 euro. Para ver el precio de todas las opciones disponibles http://hcu-client.com/buy/. Una vez pagado nos dan el password de nuestro usuario y salen los créditos que hemos comprado.

    Instalamos HCU Client bajandonos el software de https://hcu-client.com/download/

    Nos descargamos un archivo ZIP cuando lo descomprimimos nos pedirá password ZIP que será: hcu ( Viene indicado en la web cuando lo vamos a descargar ) y conectamos el cable usb del dispositivo a nuestro ordenador

    Dentro de la carpeta descomprimida veremos que hay dos programas adb y fastboot estos sirven basicamente para grabar imagenes de rom en el móvil

    Ejecutamos el programa HCU en modo administrador.

    Una vez cargado alomejor nos pide actualizar a nueva version decimos que si. En el momento de escribir el manual se bajaba la version 287 y actualizaba a 290.

    Con el programa ya en marcha pulso en el telefono: *#*#2846579#*#*

    Saldrá un menú. Entonces seleccionamos "Background Settings" - "USB ports settings" - "Manufacture mode".

    Luego iniciamos sesión en nuestra cuenta de HCU CLient. En pestaña Account introducimos nuestro User Name y Password ( El que creamos al comprar los créditos ). Elegimos opción Read Phone Info para leer datos de nuestro dispositivo.

    En pestaña Unlock vamos a Read Bootloader code para que nos muestre el código de desbloqueo.

  4. Instalar los drivers para poder usar los comandos de adb y fastboot.

    Puede que tengamos que instalar los drivers para el adb. De internet obtuve el archivo de instalación Windows llamado "UniversalAdbSetup6.msi". Este archivo se puede encontrar si bajamos el software TWRP + SUPERSU. El software TWRP y SUPERSU NO son necesarios para quitar el bloqueo del dispositivo pero los drivers adb SI. TWRP es un software que permite hacer copia de seguridad, formatear, limpiar, instalar firmwares y roms personalizadas... SuperSu es un software que gestiona los accesos de superusuario al móvil, dar permisos y acceder de forma libre a la memoria del dispostivo…

  5. Desbloquear dispositivo con nuestro código.

    Con el dispositivo conectado al ordenador, abrimos una ventana de terminal con las teclas Windows + R y escribimos lo siguiente para reiniciar en modo fastboot: "adb reboot bootloader"

    Una vez en modo fastboot escribimos lo siguiente para ver el estado del bootloader: "fastboot oem get-bootinfo"

    Para desbloquear el bootloader escribimos: "fastboot oem unlock xxxxxxx del cual xxxxxxx será nuestro código."

Dispositivos IoT Internet de las cosas.

Comparativa dispositivos IoT, Raspberry Pi Zero W, Adafruit Feather 32u4, Amica NodeMCU V2


Raspberry Pi Zero W Adafruit Feather 32u4 BLE Esp8266 NodeMCU V2

Precio 11.0 € 25.6 € 2.6 €
Dimensiones 65,9mm x 31,3mm x 4,8mm 51,0mm x 23,0mm x 7,2mm 49,2mm x 25,7mm x 4,8mm
PCB 65,0mm x 30,3mm x 1,5mm 50,7mm x 23,0mm x 1,6mm 48,2mm x 25,7mm x 1,6mm
Peso 9 gr 8 gr 8 gr
Sistema operativo Si No No
Soporte IDE Arduino No Si Si
Procesador Broadcomm BCM2835 ARM11 ATmega32u4 ESP8266Ex
Frecuencia 1 Ghz 8 Mhz 80Mhz o 160Mhz
GPU VideoCore IV  No No
Interface HDMI, 2 x microUSB, microSD, conector camara 1 x microUSB, alimentador LiPo 1 x microUSB
Almacenamiento microSD 32 Kb Flash 4 Mb Flash
Wifi Cypress CYW43438 802.11ac/b/g/n No ESP8266Ex 802.11b/g/n
Bluetooth Cypress CYW43438, Bluetooth Low Energy nRF51822, Bluetooth Low Energy No
Circuiteria batería Li-Po No Si No
GPIO pines 40 20 16

*Información de cada modelo según fabricante. Alguna característica puede variar por cambio del fabricante o error al transcribirlo

Raspberry Pi: Instalar varios sistemas operativos con Berryboot

Berryboot es un gestor de arranque para la Raspberry Pi con procesador ARM. Este programa también actua como instalador, permitiendo que tengamos múltiples distribuciones Linux por ejemplo en una tarjeta SD o disco duro externo USB. Al trabajar con Berryboot tendremos normalmente 2 particiones una de arranque que puede llegar a ocupar 30Mb y otra para sistemas operativos. Otra de las ventajas es que podemos clonar una instalación de un sistema operativo.

Instalar Debian en modo consola

Como ejemplo vamos a instalar una distribución Debian 'Raspbian Lite' para Raspberry Pi en modo consola que no ocupara mas de 400Mb.

Estos serán los pasos a seguir:

  • Tener una micro-SD de almenos 2Gb
  • Formateamos el SD a FAT32
  • Ir a la página de BerryBoot 'pinchar aquí'
  • Descargamos el archivo .zip que contiene la versión para quad-core Raspberry Pi2 y Pi3 y la descomprimimos.
  • Copiamos todos los archivos y carpetas a la raíz del SD que hemos formateado anteriormente.
  • Insertamos la tarjeta SD con BerryBoot en la ranura de la Raspberry.
  • Conectamos teclado, ratón y monitor hdmi.
  • Si queremos instalar el sistema operativo en otro medio como otra SD o disco duro externo USB lo conectamos ahora.
  • Conectamos la alimentación y esperamos a que salga la pantalla de Bienvenida de instalación.
  • En esta pantalla elegimos red Wifi o Cableado. Configuración local como zona 'Europe/Madrid' y teclado 'es'.
  • Luego seleccionamos el disco para instalar el sistema operativo. En este caso se ha optado por instalarlo en otra SD conectada al USB.
  • En la siguiente pantalla elegimos como sistema operativo 'Raspbian Lite 2016' versión consola.
  • Por último comenzará la descarga e instalación de 'Raspbian'.
  • Tenemos ya instalado el sistema, solo falta entrar con login 'pi' y password 'raspberry'.
  • Antes de desconectar la raspberry de la alimentación teclear 'sudo shutdown' o 'shutdown' en el sistema ya que puede corromperse el sistema de archivos.

Comparación pantalla entre modelos iPhone

Comparación de modelos

Se muestra una tabla comparativa de las características de cada pantalla de los modelos iPhone. Esta tabla será útil sobre todo para diseñadores o programadores iOS

iPhone Pantalla Resolución Pixels por pulgada Relación de aspecto @x Puntos en pantalla
2G /3G /3GS 3.5" 480 x 320 163 ppi 3/2 1x 480 x 320
4 /4S 3.5" 960 x 640 326 ppi 3/2 2x 480 x 320
5 /5C /5S 4" 1136 x 640 326 ppi 71/40 2x 568 x 320
6 4.7" 1334 x 750 326 ppi 667/375 2x 667 x 375
6 Plus 5.5" 2208 x 1242
*1920 x 1080
401 ppi 16/9 3x 736 x 414
6s 4.7" 1334 x 750 326 ppi 16/9 3x 736 x 414
6s Plus 5.5" 2208 x 1242
*1920 x 1080
401 ppi 16/9 3x 736 x 414
SE 4" 1136 x 640 326 ppi 71/40 2x 667 x 375
7 4.7" 1334 x 750 326 ppi 667/375 2x 667 x 375
7 Plus 5.5" 2208 x 1242
*1920 x 1080
401 ppi 16/9 3x 736 x 414
8 4.7" 1334 x 750 326 ppi 667/375 2x 667 x 375
8 Plus 5.5" 2208 x 1242
*1920 x 1080
401 ppi 16/9 3x 736 x 414
X 5.8" 2436 x 1125 458 ppi 812/375 3x 812 x 375
Xs 5.8" 2436 x 1125 458 ppi 812/375 3x 812 x 375
Max 6.5" 2688 x 1242 458 ppi 448/207 3x 896 x 414
Xr 6.1" 1792 x 828 326 ppi 448/207 2x 896 x 414
11 6.1" 1792 x 828 326 ppi 448/207 2x 896 x 414
11 Pro 5.8" 2436 x 1125 458 ppi 812/375 3x 812 x 375
11 Pro Max 6.5" 2688 x 1242 458 ppi 448/207 3x 896 x 414
SE 2020 4.7" 1334 x 750 326 ppi 16/9 2x 667 x 375
12 Mini 5.4" 2340 x 1080 476 ppi 13/6 3x 780 x 360
12 6.1" 2532 x 1170 460 ppi 422/19 3x 844 x 390
12 Pro 6.1" 2532 x 1170 460 ppi 422/195 3x 844 x 390
12 Pro Max 6.7" 2778 x 1284 458 ppi 463/214 3x 926 x 428

* Antes que la imagen se muestre en pantalla se reajusta a una resolución mas baja (downsampling / 1.15)

Miniprograma que apuesta quinielas de futbol en C# + WPF

En un anterior artículo se desarrollo un miniprograma escrito en Java que hacia apuestas de quinielas. En este artículo se pretende hacer lo mismo pero programandolo en C# + desarrollo de interfaces con WPF ( Windows Presentation Foundation ) y Visual Studio 2015. El aspecto sera el mismo para que pueda compararse el codigo escrito en Java del anterior articulo con este. Veremos como el codigo que no depende del interface gráfico es muy parecido.

Cada boleto esta compuesto de 8 columnas con 14 partidos. Los partidos de cada columna son apuestas con tres valores 1, X, 2. Si un equipo gana en casa es un 1, si empata es una X y si pierde es un 2. La ultima apuesta o pleno al 15 son los números de goles marcados por cada equipo que juega ese partido 0, 1, 2, M. Donde M es 3 o mas goles.

Lenguaje

Escribiremos el código en C# usando ademas lenguaje de marcas XAML (WPF) una variante de XML introducida por microsoft para dibujar la interface gráfica. Como entorno de desarrollo se usa Visual Studio 2015

Diseño

Nada mas empezar mostraremos un mensaje de bienvenida y el menú con las opciones de pronosticar apuestas, configuración e información sobre la versión del programa.

Sobre las opciones: Apuesta, 1x2%, ?.

  • Apuesta: Elegir 'Empezar' que será la que nos calcule el pronostico y salga por pantalla.
  • 1X2 %: Configuraciones que nos calculara pronósticos al azar según porcentaje elegido.
  • ?: Información sobre la versión del programa.

Código

Iniciado Visual Studio 2015, creamos un nuevo proyecto eligiendo la plantilla "WPF Application" y le pondremos de nombre "WpfQuiniela2000". El siguiente paso con ayuda del entorno "Visual" que aparece en la pestaña "MainWindow.xaml" sera diseñar o dibujar el aspecto gráfico de la aplicación con el raton y retocar si hace falta el código que ira escribiendo en lenguaje XAML que aparece en la ventana inferior.

En la zona vertical izquierda del entorno tenemos varios desplegables, entre ellos el "Toolbox" que seran los objetos graficos con los que construiremos la interface. Algunos objetos usados son "Label" como etiquetas, "Grid" contenedor de otros objetos, "Menu" para diseñar el menu de opciones... A medida que vamos posicionando, redimensionando en la zona "Design" y rellenando los atributos de los objetos que aparece en la ventana "Properties" iremos viendo como aparece el codigo XAML en la zona "XAML".

Diseño de la interfaz gráfica

En la ventana con el código en XAML tendremos esta plantilla que nos crea Visual Studio a la que le iremos agregando o modificando algunas cosas.

En la zona inferior derecha vamos a "Properties" y cambiamos alguna de las propiedades de la ventana "Window" del código. El titulo de la ventana en "Title" lo dejamos como "Quinielas 2000", el ancho y alto lo modificamos con las variables "Width" 220 y "Height" 300. La ventana no sera redimensionable pero si minimizable esto se cambia en la propiedad "ResizeMode" desplegando CanMinimize. Si ahora miramos el código XAML veremos una línea con lo siguiente:

 Title="Quinielas 2000" Height="300" Width="220" ResizeMode="CanMinimize">

En el menú "Toolbox" elegimos el objeto "Menu" y con el ratón lo posicionamos en el diseño en la parte superior de la ventana de la aplicación que estamos construyendo.

Lo siguiente será posicionar el ratón encima del menú donde queremos la primera lista de opciones "Apuesta" hacer click en botón derecho y seleccionaremos la opción "Add MenuItem". En la ventana "Properties - Common - Header" le pondremos el nombre de la opción "Apuesta". Con las opciones "1X2%" y "?" procedemos a hacer los mismos pasos.

Para crear los submenús posicionamos el ratón encima de la opción principal y seleccionamos también "Add MenuItem". En el caso de "Apuesta" crearemos un submenú al que llamaremos "Empezar". Con los siguientes submenús de las opciones que quedan haremos tambien el mismo proceso. El código de una opción con submenú debe ser parecido a este:

  <MenuItem Header="Apuesta" Height="24">
    <MenuItem Header="Empezar" HorizontalAlignment="Left" Width="145">
  </MenuItem>

Como cada submenú nos debe llevar a ejecutar una acción cuando se pulse en ella, en el propio diseño hacemos "Click" en estos para que nos agregue automáticamente al código XAML el atributo "Click" con el nombre del evento que contendrá el código en C# que se ejecutará en cada caso. Ademas daremos un nombre identificador con el atributo "x:Name" a cada línea XAML que define el submenú.

  <MenuItem Header="Apuesta" Height="24">
    <MenuItem x:Name="mnEmpezar" Header="Empezar" HorizontalAlignment="Left" Width="145" Click="mnEmpezar_Click">
  </MenuItem>

En los tres submenús de la opción "1X2 %" además agregaremos un "RadioButton" a cada uno. El primero de la lista sera el seleccionado por defecto con el atributo "IsChecked='True'".

  <MenuItem Header="1X2 %">
    <RadioButton x:Name="mnOpcion1" Click="mnOpcion1_Click" IsChecked="True" >
      <MenuItem Header="55,56 - 33,33 - 11,11" HorizontalAlignment="Left" Width="206" Margin="0,0,-60,0"/>
    </RadioButton>
    <RadioButton x:Name="mnOpcion2" Click="mnOpcion2_Click">
      <MenuItem  Header="55,56 - 22,22 - 22,22" HorizontalAlignment="Left" Width="206" Margin="0,0,-60,0"/>
    </RadioButton>
    <RadioButton x:Name="mnOpcion3" Click="mnOpcion3_Click">
      <MenuItem Header="33,33 - 33,33 - 33,33" HorizontalAlignment="Left" Width="205" Margin="0,0,-60,0"/>
    </RadioButton>
  </MenuItem>

El mensaje de bienvenida lo escribiremos dentro del mismo contenedor "Grid" donde hemos creado el Menú. Seleccionando de "Toolbox" el objeto "Label" centrada en horizontal,vertical y con texto en negrita. Este contenedor será el mismo donde también visualizaremos los pronósticos de las apuestas.

El código XAML resultante seria este:

  <Label x:Name="lbBienvenido" Content="¡ Bienvenido a Quiniela 2000 !" HorizontalAlignment="Center" VerticalAlignment="Center" Margin="0" FontWeight="Bold"  />

La última parte del diseño será crear otro contenedor "Grid" dividido en 2 columnas y 17 filas para mostrar los pronósticos. Vamos a "Toolbox" elegimos el objeto "Grid" para posicionarlo y redimensionarlo dentro de la ventana. El código se vera como este:

  <Grid x:Name="grEmpezar"  VerticalAlignment="Bottom" Width="214" Height="239" HorizontalAlignment="Center" >
  </Grid>

dentro del contenedor se añadirán las 2 columnas con el atributo "Grid.ColumnDefinition" y 17 filas con "Grid.RowDefinition" rellenando el código que falta manualmente dentro de la zona XAML en la ventana inferior del editor de Visual Studio.

La primera fila "RowDefinition" donde pondremos las etiquetas "Partido" y "Pronostico" tendrá una altura de 2 celdas indicándoselo con "Height='2*'"

  <Grid.ColumnDefinitions>
    <ColumnDefinition />
    <ColumnDefinition />
  </Grid.ColumnDefinitions>
  <Grid.RowDefinitions>
    <RowDefinition Height="2*" />
    <RowDefinition />
    <RowDefinition />
    <RowDefinition />
    <RowDefinition />
    <RowDefinition />
    <RowDefinition />
    <RowDefinition />
    <RowDefinition />
    <RowDefinition />
    <RowDefinition />
    <RowDefinition />
    <RowDefinition />
    <RowDefinition />
    <RowDefinition />
    <RowDefinition />
    <RowDefinition />
  </Grid.RowDefinitions>

Introduciremos después el código manualmente para posicionar en la primera fila del contenedor "grEmpezar" las etiquetas "Partido" y "Pronostico" rodeadas por un borde de color negro. Al iniciar la aplicación estas dos etiquetas no pueden ser visibles ya que inicialmente se esta dando un mensaje de bienvenida. Asi que le damos el atributo de ocultar con "Visibility='Hidden'". Cuando en el menú elijamos la opción empezar con el código en C# cambiaremos este atributo a visible.

  <Border x:Name="bgPartido" Grid.Row="0" Grid.Column="0" BorderBrush="Black" BorderThickness="1" VerticalAlignment="Center" Margin="5,4,0,0" Visibility="Hidden"> 
    <Label x:Name="lbPartido" Content="Partido"  VerticalAlignment="Top" FontWeight="Bold" Foreground="Black"  FontSize="9.333" HorizontalAlignment="Center" />
  </Border>
  <Border x:Name="bgPronostico" Grid.Row="0" Grid.Column="1" BorderBrush="Black" BorderThickness="1" VerticalAlignment="Center" Margin="0,4,5,0" Visibility="Hidden">
    <Label x:Name="lbPronostico" Content="Pronostico" VerticalAlignment="Top" FontWeight="Bold" Foreground="Black" FontSize="9.333" HorizontalAlignment="Center"/>
  </Border>

Con esto ya habremos acabado el diseño gráfico de la interfaz con ayuda XAML y del entorno Visual. Lo siguiente será acabar el resto del programa que calculará los pronósticos introduciendo código en C#

Código XAML final del diseño gráfico:

<Window x:Class="WpfQuiniela2000.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:WpfApplication2"
        mc:Ignorable="d"
        Title="Quinielas 2000" Height="300" Width="220" ResizeMode="CanMinimize">
    <Grid>
        <Menu x:Name="menu" HorizontalAlignment="Left" Width="212" Margin="0,0,0,239">
            <MenuItem Header="Apuesta" Height="24">
                <MenuItem x:Name="mnEmpezar" Header="Empezar" HorizontalAlignment="Left" Width="145" Click="mnEmpezar_Click"/>
            </MenuItem>
            <MenuItem Header="1X2 %">
                <RadioButton x:Name="mnOpcion1" Click="mnOpcion1_Click" IsChecked="True" >
                    <MenuItem Header="55,56 - 33,33 - 11,11" HorizontalAlignment="Left" Width="206" Margin="0,0,-60,0"/>
                </RadioButton>
                <RadioButton x:Name="mnOpcion2" Click="mnOpcion2_Click">
                    <MenuItem  Header="55,56 - 22,22 - 22,22" HorizontalAlignment="Left" Width="206" Margin="0,0,-60,0"/>
                </RadioButton>
                <RadioButton x:Name="mnOpcion3" Click="mnOpcion3_Click">
                    <MenuItem Header="33,33 - 33,33 - 33,33" HorizontalAlignment="Left" Width="205" Margin="0,0,-60,0"/>
                </RadioButton>
            </MenuItem>
            <MenuItem Header="?">
                <MenuItem x:Name="mnSobre" Header="Sobre ..." HorizontalAlignment="Left" Width="120" Margin="0,0,-48,0" Click="mnSobre_Click" />
            </MenuItem>
        </Menu>
        <Label x:Name="lbBienvenido" Content="¡ Bienvenido a Quiniela 2000 !" HorizontalAlignment="Center" VerticalAlignment="Center" Margin="0"  FontWeight="Bold"  />
        <Grid x:Name="grEmpezar"  VerticalAlignment="Bottom" Width="214" Height="239" HorizontalAlignment="Center" >
            <Grid.ColumnDefinitions>
                <ColumnDefinition />
                <ColumnDefinition />
            </Grid.ColumnDefinitions>
            <Grid.RowDefinitions>
                <RowDefinition Height="2*" />
                <RowDefinition />
                <RowDefinition />
                <RowDefinition />
                <RowDefinition />
                <RowDefinition />
                <RowDefinition />
                <RowDefinition />
                <RowDefinition />
                <RowDefinition />
                <RowDefinition />
                <RowDefinition />
                <RowDefinition />
                <RowDefinition />
                <RowDefinition />
                <RowDefinition />
                <RowDefinition />
            </Grid.RowDefinitions>
            <Border x:Name="bgPartido" Grid.Row="0" Grid.Column="0" BorderBrush="Black" BorderThickness="1" VerticalAlignment="Center" Margin="5,4,0,0" Visibility="Hidden"> 
                <Label x:Name="lbPartido" Content="Partido"  VerticalAlignment="Top" FontWeight="Bold" Foreground="Black"  FontSize="9.333" HorizontalAlignment="Center" />
            </Border>
            <Border x:Name="bgPronostico" Grid.Row="0" Grid.Column="1" BorderBrush="Black" BorderThickness="1" VerticalAlignment="Center" Margin="0,4,5,0" Visibility="Hidden">
                <Label x:Name="lbPronostico" Content="Pronostico" VerticalAlignment="Top" FontWeight="Bold" Foreground="Black" FontSize="9.333" HorizontalAlignment="Center"/>
            </Border>
        </Grid>
    </Grid>
</Window>

Código de control del programa.

Visual Studio cuando empieza el proyecto crea también una plantilla inicial con el código básico en C# para ejecutar el programa. Ha este código en la plantilla con nombre MainWindow.xaml.cs se irá añadiendo el código necesario para los cálculos, control de los eventos del ratón,...

Por lo tanto tendremos un código inicial en C# lo mas parecido a este:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;

namespace WpfQuiniela2000
{
    /// 
    /// Interaction logic for MainWindow.xaml
    /// 
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
        }
    }
}

En la parte anterior del diseño de la interfaz cuando hacíamos click en los menus para agregar los atributos al lenguaje de marcas XAML (MainWindow.xaml) también nos creaba en la pestaña de código C# (MainWindow.xaml.cs) el correspondiente de control de eventos.

Por lo tanto deberíamos tener además este código ya creado:

private void mnSobre_Click(object sender, RoutedEventArgs e)
{

}

private void mnOpcion1_Click(object sender, RoutedEventArgs e)
{
       
}

private void mnOpcion2_Click(object sender, RoutedEventArgs e)
{

}

private void mnOpcion3_Click(object sender, RoutedEventArgs e)
{

}

private void mnEmpezar_Click(object sender, RoutedEventArgs e)
{

}

Nos ha creado 5 métodos identificados con el nombre del atributo x:Name de la zona del diseño donde se había hecho Click con el ratón. Cada método será llamado por su evento correspondiente y ejecutará él código que se haya rellenado en su interior.

Así por ejemplo tenemos que cuando el programa este en ejecución y se hace Click en "?" del menú se crea un evento que llama al método mnSobre_Click donde nos ejecutará el código interno correspondiente. Para los demás eventos que llamaran a sus métodos _Click el proceso es el mismo.

Opción "Apuesta" evento mnEmpezar

Declaramos una variable global llamada 'modoApuesta' que vamos a necesitar en la subrutina del evento para saber que configuración tomar a la hora de representar el pronostico de la apuesta. También usamos un objeto llamado "rnd" para que nos de los pronosticos al azar.

static int modoApuesta=1;
Random rnd = new Random((int)DateTime.Now.Millisecond);

Rellenamos también el código del evento que llamará al metodo "mnEmpezar_Click".

private void mnEmpezar_Click(object sender, RoutedEventArgs e)
{
  lbBienvenido.Visibility= Visibility.Hidden;
  bgPartido.Visibility = Visibility.Visible;
  bgPronostico.Visibility = Visibility.Visible;
  grEmpezar.Children.RemoveRange(2,33);
  for (int i = 1, c; i <= 16; i++)
    {
      if (i < 15) c = i; else c = 15;
      TextBlock txtBlockCasilla = new TextBlock();
      txtBlockCasilla.Text = ""+c;
      txtBlockCasilla.FontSize = 10;
      txtBlockCasilla.HorizontalAlignment = HorizontalAlignment.Center;
      Grid.SetRow(txtBlockCasilla, i); Grid.SetColumn(txtBlockCasilla, 0);
      grEmpezar.Children.Add(txtBlockCasilla);
      TextBlock txtBlockApuesta = new TextBlock();
      txtBlockApuesta.Text = generaCasilla(modoApuesta, c);
      txtBlockApuesta.FontSize = 10;
      txtBlockApuesta.HorizontalAlignment = HorizontalAlignment.Center;
      Grid.SetRow(txtBlockApuesta, i); Grid.SetColumn(txtBlockApuesta, 1);
      grEmpezar.Children.Add(txtBlockApuesta);
    }
}

También creamos una función generaCasilla() que va a utilizar el método mnEmpezar_Click que nos da el resultado de la casilla apostada según la variable modoApuesta

private String generaCasilla(int modo, int casilla )
{ 
  int num;

  if (casilla < 15)
  {
    num = rnd.Next(0,9); // Devuelve 0 a 8 
    switch (modo)
    {
      case 1: // 55,56 - 33,33 - 11,11
        switch (num)
        {
          case 0: case 1: case 2: case 3: case 4: return "1";
          case 5: case 6: case 7: return "X";
          case 8: return "2";
        }
        break;
      case 2: // 55,56 - 22,22 - 22,22
        switch (num)
        {
          case 0: case 1: case 2: case 3: case 4: return "1";
          case 5: case 6: return "X";
          case 7: case 8: return "2";
        }
        break;
      case 3: // 33,33 - 33,33 - 33,33
        switch (num)
        {
          case 0: case 1: case 2: return "1";
          case 3: case 4: case 5: return "X";
          case 6: case 7: case 8: return "2";
        }
        break;
    }
  }
  else
  {
    num = rnd.Next(0,4); // Devuelve 0 a 3
    switch (num)
    {
      case 0: return "0";
      case 1: return "1";
      case 2: return "2";
      case 3: return "M";
    }
  }
  return "";
  }
}

Opción "1X2 %" eventos mnOpcion1, mnOpcion2, mnOpcion3

Damos valor a la variable global modoApuesta según la opción del menú configura

private void mnOpcion1_Click(object sender, RoutedEventArgs e)
{
  modoApuesta = 1;    
}

private void mnOpcion2_Click(object sender, RoutedEventArgs e)
{
  modoApuesta = 2;
}

private void mnOpcion3_Click(object sender, RoutedEventArgs e)
{
  modoApuesta = 3;
}

Opción "?" evento mnSobre

Visualizamos una ventana con información del programa con el método MessageBox.Show()

private void mnSobre_Click(object sender, RoutedEventArgs e)
{
  MessageBox.Show("Quiniela 2000 Version 1.0", "Sobre Quiniela",MessageBoxButton.OK, MessageBoxImage.Information);
}

Código C# completo

Aquí esta el código completo del programa correspondiente a la parte de control de menú y calculos.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;

namespace WpfQuiniela2000
{
    /// 
    /// Interaction logic for MainWindow.xaml
    /// 
    public partial class MainWindow : Window
    {
        static int modoApuesta=1;
        Random rnd = new Random((int)DateTime.Now.Millisecond);

        public MainWindow()
        {
            InitializeComponent();
        }

        private void mnSobre_Click(object sender, RoutedEventArgs e)
        {
            MessageBox.Show("Quiniela 2000 Version 1.0", "Sobre Quiniela",MessageBoxButton.OK, MessageBoxImage.Information);
        }

        private void mnOpcion1_Click(object sender, RoutedEventArgs e)
        {
            modoApuesta = 1;
        }

        private void mnOpcion2_Click(object sender, RoutedEventArgs e)
        {
            modoApuesta = 2;
        }

        private void mnOpcion3_Click(object sender, RoutedEventArgs e)
        {
            modoApuesta = 3;
        }

        private void mnEmpezar_Click(object sender, RoutedEventArgs e)
        {
            lbBienvenido.Visibility= Visibility.Hidden;
            bgPartido.Visibility = Visibility.Visible;
            bgPronostico.Visibility = Visibility.Visible;
            grEmpezar.Children.RemoveRange(2,33);
            for (int i = 1, c; i <= 16; i++)
            {
                if (i < 15) c = i; else c = 15;
                TextBlock txtBlockCasilla = new TextBlock();
                txtBlockCasilla.Text = ""+c;
                txtBlockCasilla.FontSize = 10;
                txtBlockCasilla.HorizontalAlignment = HorizontalAlignment.Center;
                Grid.SetRow(txtBlockCasilla, i); Grid.SetColumn(txtBlockCasilla, 0);
                grEmpezar.Children.Add(txtBlockCasilla);
                TextBlock txtBlockApuesta = new TextBlock();
                txtBlockApuesta.Text = generaCasilla(modoApuesta, c);
                txtBlockApuesta.FontSize = 10;
                txtBlockApuesta.HorizontalAlignment = HorizontalAlignment.Center;
                Grid.SetRow(txtBlockApuesta, i); Grid.SetColumn(txtBlockApuesta, 1);
                grEmpezar.Children.Add(txtBlockApuesta);
            }
        }

        private String generaCasilla(int modo, int casilla )
        { 
            int num;

            if (casilla < 15)
            {
                num = rnd.Next(0,9); // Devuelve 0 a 8 
                switch (modo)
                {
                    case 1: // 55,56 - 33,33 - 11,11
                        switch (num)
                        {
                            case 0: case 1: case 2: case 3: case 4: return "1";
                            case 5: case 6: case 7: return "X";
                            case 8: return "2";
                        }
                        break;
                    case 2: // 55,56 - 22,22 - 22,22
                        switch (num)
                        {
                            case 0: case 1: case 2: case 3: case 4: return "1";
                            case 5: case 6: return "X";
                            case 7: case 8: return "2";
                        }
                        break;
                    case 3: // 33,33 - 33,33 - 33,33
                        switch (num)
                        {
                            case 0: case 1: case 2: return "1";
                            case 3: case 4: case 5: return "X";
                            case 6: case 7: case 8: return "2";
                        }
                        break;
                }
            }
            else
            {
                num = rnd.Next(0,4); // Devuelve 0 a 3
                switch (num)
                {
                    case 0: return "0";
                    case 1: return "1";
                    case 2: return "2";
                    case 3: return "M";
                }
            }
            return "";
        }
    }
}

Cambiar de orden las cuentas de correo con Thunderbird

El cliente de correo Thunderbird no viene con un sistema en el panel de opciones para cambiar de orden las cuentas de correo. Para ello se tendrá que hacer manualmente editando el fichero prefs.js o añadir algún complemento como Manually sort folders 1.1



  • Descargar el complemento Manually sort folders 1.1que será un fichero con extensión .xpi
  • Abrimos Thunderbird
  • En el panel superior hacer clic en icono Mostrar el menú Thunderbird
  • En el desplegable de opciones hacer clic en Complementos
  • Se muestra ventana "Administrador de complementos"
  • Ir a rueda dentada y hacer clic herramientas para todos los complementos
  • En el desplegable de opciones hacer clic en "Instalar complemento desde archivo..."
  • Instalar buscando el complemento que habíamos descargado
  • Una vez instalado ir a ventana "Administrador de complementos"
  • Ir a menú panel izquierdo opción "Extensiones"
  • Seleccionamos el complemento instalado
  • Hacer clic en botón opciones
  • Se muestra nueva ventana "Manually sort folders"
  • Hacer clic en pestaña Ordenar cuentas
  • Mover la cuenta que queremos cambiar de orden con los botones flecha arriba o abajo
  • Por ultimo hacer clic en botón Reiniciar Thunderbird


Acceder a Yahoo Mail o Gmail con Thunderbird. Usar cuenta de correo web en escritorio.

Para acceder a una cuenta de correo web casi siempre se utiliza un navegador tipo Explorer, Firefox, Opera... necesitaremos tener conexión para consultar los correos. Si tenemos varias cuentas de distintos proveedores es difícil de gestionar. Además algunas veces pasa que el acceso mediante navegador es lento especialmente si en el servidor se abusa de la tecnología Ajax.

Si accedemos mediante un programa desde el escritorio a la cuenta lo haremos mediante un cliente de correo y el acceso es algo mas rápido. Además los mensajes se almacenan de forma física en el ordenador pudiéndose consultar sin necesidad de conexión. Es posible la gestión centralizada de varias cuentas de distintos proveedores desde el mismo programa. El cliente siempre deberá estar abierto para que se sincronize con los servidores de correo de cada proveedor recibiendo y enviando mensajes.

En el siguiente ejemplo usaremos una cuenta de correo Yahoo Mail con un cliente de correo gratuito para escritorio llamado Thunderbird.

Preparamos cuenta Yahoo Mail para el cliente de correo.

  • Iniciar sesión de Yahoo Mail
  • Ir al menú superior en el icono de configuración
  • Seleccionar Configuración
  • Elegir Cuentas
  • Ir a Buzones de Correo y hacer clic en la cuenta
  • Vamos a "Acceder a Yahoo Mail desde cualquier otro sitio" para seleccionar POP
  • Elegimos como gestionar los mensajes de spam. Por ejemplo "Descargar spam, pero añadir 'Spam' como prefijo"
  • Hacemos clic en Guardar

Agregaremos Yahoo Mail al cliente de correo Thunderbird.

  • Iniciar Thunderbird
  • Hacer clic en Correo electrónico en "Crear una cuenta nueva"
  • Saldrá una nueva ventana "¿ Le gustaría tener una nueva dirección de correo ?", hacer clic en Saltarse esto y usar mi cuenta de correo existente
  • Seguidamente en la ventana "Configuración de cuenta de correo" rellenamos el formulario con Su nombre:Dirección de correo:Contraseña:
  • Hacer clic en Continuar
  • Se configura automáticamente ya que el proveedor Yahoo esta en la base de datos de Thunderbird
  • Queda seleccionado el protocolo IMAP. Se recomienda IMAP ya que POP3 descarga los mensajes eliminándolos del servidor de Yahoo
  • Hacer clic en Hecho

Gmail con Thunderbird

La configuración de Thunderbird con otros proveedores de cuentas de correo como por ejemplo "Gmail" se hace igual. En el proceso de agregar la cuenta "Gmail" se abrirá automaticamente el navegador pidiendo la contraseña para conectarse al servidor de Gmail y nos avisara que Thunderbird pide permiso para usar la cuenta. Damos el permiso y la cuenta quedará agregada.

Miniprograma que apuesta quinielas de futbol en Java

Vamos a crear un pequeño programa en Java para generar apuestas de futbol. Las apuestas serán del tipo quinielísticas igual que los boletos que se venden en España.

Cada boleto esta compuesto de 8 columnas con 14 partidos. Los partidos de cada columna son apuestas con tres valores 1, X, 2. Si un equipo gana en casa es un 1, si empata es una X y si pierde es un 2. La ultima apuesta o pleno al 15 son los números de goles marcados por cada equipo que juega ese partido 0, 1, 2, M. Donde M es 3 o mas goles.

Lenguaje

Escribiremos el código con programación estructurada en funciones y lenguaje Java SE por ser ejecutable tanto en Windows como en Linux. Usaremos un editor de texto o Eclipse.

Diseño

Nada mas empezar mostraremos un mensaje de bienvenida y el menú con las opciones de pronosticar apuestas, configuración e información sobre la versión del programa.

Sobre las opciones: Apuesta, 1x2%, ?.

  • Apuesta: Elegir 'Empezar' que será la que nos calcule el pronostico y salga por pantalla.
  • 1X2 %: Configuraciones que nos calculara pronósticos al azar según porcentaje elegido.
  • ?: Información sobre la versión del programa.

Código

Escribiremos casi todo el código dentro del método main(). Nombramos a la ventana de la aplicación como 'Quiniela 2000'. La ventana tendrá un tamaño de 220 x 300 pixels no redimensionable.

  
  JFrame ventana = new JFrame("Quiniela 2000");  // Ventana
  ventana.setSize(220, 300); // 220 ancho x 300 alto   
  ventana.setResizable(false); // No dimensionable
  ventana.setVisible(true); // Visible
  ventana.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

Lo siguiente será escribir el código del menú con sus tres opciones.

  JMenuBar barraMenu=new JMenuBar(); // Barra menu
  ventana.setJMenuBar(barraMenu);
  JMenu calcular= new JMenu("Apuesta"); // Menu Apuesta
  barraMenu.add(calcular);
  JMenuItem empezar=new JMenuItem("Empezar"); // Submenu Empezar
  calcular.add(empezar);
  JMenu configurar= new JMenu("1X2 %");  // Menu Configurar
  barraMenu.add(configurar);
  ButtonGroup grupo = new ButtonGroup(); // Grupo radioButton
  JRadioButtonMenuItem rbMenuItem1,rbMenuItem2,rbMenuItem3;
  rbMenuItem1=new JRadioButtonMenuItem("55,56 - 33,33 - 11,11"); // Submenu 5-3-1
  rbMenuItem1.setSelected(true); // Por defecto esta opción seleccionada
  grupo.add(rbMenuItem1);
  configurar.add(rbMenuItem1); 
  rbMenuItem2=new JRadioButtonMenuItem("55,56 - 22,22 - 22,22"); // Submenu 5-2-2
  grupo.add(rbMenuItem2); 
  configurar.add(rbMenuItem2);
  rbMenuItem3=new JRadioButtonMenuItem("33,33 - 33,33 - 33,33"); // Submenu 3-3-3
  grupo.add(rbMenuItem3);
  configurar.add(rbMenuItem3); 
  JMenu acercaDe= new JMenu("?"); // Menu Acerca de... 
  barraMenu.add(acercaDe);
  JMenuItem sobreQuiniela=new JMenuItem("Sobre Quiniela"); // Submenu Sobre..
  acercaDe.add(sobreQuiniela);

El mensaje de bienvenida lo escribiremos como una etiqueta centrada en horizontal y vertical dentro de un contenedor tipo JPanel. Este contenedor será el mismo donde también visualizaremos los pronósticos de las apuestas.

  JPanel panel=new JPanel(new GridLayout(1,1));  // Tipo Panel
  JLabel labelBienvenido= new JLabel("¡ Bienvenido a Quiniela 2000 !",SwingConstants.CENTER);
  labelBienvenido.setVerticalAlignment(SwingConstants.CENTER);
  panel.add(labelBienvenido); // Agregar etiqueta a Panel
  ventana.add(panel); // Agregar Panel a Ventana

Ahora nos toca añadir los eventos a cada opción del menú para según lo que se elija hacer una cosa u otra.Con ActionListener y ActionPerformed crearemos la subrutinas de la opciones para los eventos de menú.

Evento accionEmpezar.

Declaramos una variable global llamada 'modoApuesta' que vamos a necesitar en la subrutina del evento para saber que configuración tomar a la hora de representar el pronostico de la apuesta.

  public class Programa  { 
    static int modoApuesta=1;
 
    // Metodo principal 
    public static void main(String[] args) {

Dentro del método principal declaramos el objeto evento accionEmpezar con su código.

  JLabel labelPartido = new JLabel("Partido",SwingConstants.CENTER);
  JLabel labelPronostico= new JLabel("Pronostico",SwingConstants.CENTER);
  Border border = LineBorder.createGrayLineBorder();
  labelPartido.setBorder(border);
  labelPronostico.setBorder(border);

  ActionListener accionEmpezar=new ActionListener() {
    public void actionPerformed(ActionEvent e) {
      panel.setLayout(new GridLayout(17,2));
      panel.removeAll();
      panel.add(labelPartido);
      panel.add(labelPronostico);
      for (int i=1, c;i<=16;i++) {
        if (i<15) c=i; else c=15;
        panel.add(new JLabel(""+c,SwingConstants.CENTER));
        panel.add(new JLabel(generaCasilla(modoApuesta,c),SwingConstants.CENTER));
      }  
      panel.revalidate();
    }
  };

Dentro de la Clase creamos un método generaCasilla() que va a utilizar el evento accionEmpezar que nos da el resultado de la casilla apostada según la variable modoApuesta

  public static String generaCasilla(int modo, int casilla) {
    Random rnd = new Random();
    int num;
  
    if (casilla<15) {
      num = rnd.nextInt(9); // Devuelve 0 a 8 
      switch(modo) {
        case 1: // 55,56 - 33,33 - 11,11
          switch(num) { 
            case 0: case 1: case 2: case 3: case 4: return "1"; 
            case 5: case 6: case 7: return "X"; 
            case 8: return "2"; 
          } break; 
        case 2: // 55,56 - 22,22 - 22,22
          switch(num) {
            case 0: case 1: case 2: case 3: case 4: return "1"; 
            case 5: case 6: return "X";
            case 7: case 8: return "2";
          } break;
        case 3: // 33,33 - 33,33 - 33,33
          switch(num) { 
            case 0: case 1: case 2:   return "1"; 
            case 3: case 4: case 5:   return "X"; 
            case 6: case 7: case 8:   return "2"; 
          } break;
      }
    }
    else {
     num=rnd.nextInt(4); // Devuelve 0 a 3
       switch(num) {
         case 0: return "0";
         case 1: return "1";
         case 2: return "2";
         case 3: return "M";
       }
    }
    return "";
  }

Evento accionConfigura.

Damos valor a la variable global modoApuesta según la opción del menú configura

  String primero = new String("Boton1");
  String segundo = new String("Boton2");
  String tercero = new String("Boton3");
   
  ActionListener accionConfigura=new ActionListener() {
    public void actionPerformed(ActionEvent e) {
      if (e.getActionCommand() == primero) modoApuesta=1;
      else
        if (e.getActionCommand() == segundo) modoApuesta=2;
        else
          if (e.getActionCommand() == tercero) modoApuesta=3;
    }
  };

Evento accionAcercaDe.

Visualizamos una ventana con información del programa con el método JOptionPane.showMessageDialog()

  ActionListener accionAcercaDe=new ActionListener() {
    public void actionPerformed(ActionEvent e) {
      JOptionPane.showMessageDialog(ventana, "Quiniela 2000 Version 1.0",
      "Sobre Quiniela",JOptionPane.INFORMATION_MESSAGE); 
      // El primer parametro muestra ventana en medio
    }
  };

Por último nos queda asignar a cada evento de la opción del menú su rutina.

  empezar.addActionListener(accionEmpezar);
  
  rbMenuItem1.addActionListener(accionConfigura);
  rbMenuItem1.setActionCommand(primero);
   
  rbMenuItem2.addActionListener(accionConfigura);
  rbMenuItem2.setActionCommand(segundo);
   
  rbMenuItem3.addActionListener(accionConfigura);
  rbMenuItem3.setActionCommand(tercero);
      
  sobreQuiniela.addActionListener(accionAcercaDe); 

Código completo

Aquí esta el código completo del programa.

  package com.popularfan.quiniela1;

  import java.awt.GridLayout;
  import java.util.Random;
  import javax.swing.*;
  import java.awt.event.*;
  import javax.swing.border.LineBorder;
  import javax.swing.border.Border;

  public class Programa  { 
 
    static int modoApuesta=1;
 
    // Metodo principal 
 
    public static void main(String[] args) {
 
      // ##################### VENTANA #############################
  
      JFrame ventana = new JFrame("Quiniela 2000");  // Ventana
      ventana.setSize(220, 300); // 220 ancho x 300 alto  
      ventana.setResizable(false); // No dimensionable
      ventana.setVisible(true); // Visible
      ventana.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  
      // ##################### BARRA MENU ##########################
  
      JMenuBar barraMenu=new JMenuBar(); // Barra menu
      ventana.setJMenuBar(barraMenu);
      JMenu calcular= new JMenu("Apuesta"); // Menu Apuesta
      barraMenu.add(calcular);
      JMenuItem empezar=new JMenuItem("Empezar"); // Submenu Empezar
      calcular.add(empezar);
      JMenu configurar= new JMenu("1X2 %");  // Menu Configurar
      barraMenu.add(configurar);
      ButtonGroup grupo = new ButtonGroup(); // Grupo radioButton
      JRadioButtonMenuItem rbMenuItem1,rbMenuItem2,rbMenuItem3;
      rbMenuItem1=new JRadioButtonMenuItem("55,56 - 33,33 - 11,11"); // Submenu 5-3-1
      rbMenuItem1.setSelected(true); // Por defecto esta opción seleccionada
      grupo.add(rbMenuItem1);
      configurar.add(rbMenuItem1); 
      rbMenuItem2=new JRadioButtonMenuItem("55,56 - 22,22 - 22,22"); // Submenu 5-2-2
      grupo.add(rbMenuItem2);
      configurar.add(rbMenuItem2);
      rbMenuItem3=new JRadioButtonMenuItem("33,33 - 33,33 - 33,33"); // Submenu 3-3-3
      grupo.add(rbMenuItem3);
      configurar.add(rbMenuItem3);
      JMenu acercaDe= new JMenu("?"); // Menu Acerca de...
      barraMenu.add(acercaDe);
      JMenuItem sobreQuiniela=new JMenuItem("Sobre Quiniela"); // Submenu Sobre..
      acercaDe.add(sobreQuiniela);
     
      // ##################### PANEL ###############################
  
      JPanel panel=new JPanel(new GridLayout(1,1));  // Tipo Panel
      JLabel labelBienvenido= new JLabel("¡ Bienvenido a Quiniela 2000 !",SwingConstants.CENTER);
      labelBienvenido.setVerticalAlignment(SwingConstants.CENTER);
      panel.add(labelBienvenido); // Agregar etiqueta a Panel
      ventana.add(panel); // Agregar Panel a Ventana
  
      // ##################### EVENTOS MENU  #######################
  
      // Evento Empezar
  
      JLabel labelPartido = new JLabel("Partido",SwingConstants.CENTER);
      JLabel labelPronostico= new JLabel("Pronostico",SwingConstants.CENTER);
      Border border = LineBorder.createGrayLineBorder();
      labelPartido.setBorder(border);
      labelPronostico.setBorder(border);
  
      ActionListener accionEmpezar=new ActionListener() {
        public void actionPerformed(ActionEvent e) {
          panel.setLayout(new GridLayout(17,2));
          panel.removeAll();
          panel.add(labelPartido);
          panel.add(labelPronostico);
          for (int i=1, c;i<=16;i++) {
            if (i<15) c=i; else c=15;
            panel.add(new JLabel(""+c,SwingConstants.CENTER));
            panel.add(new JLabel(generaCasilla(modoApuesta,c),SwingConstants.CENTER));
          }  
          panel.revalidate();
        }
      };
  
      // Evento Configura
    
      String primero = new String("Boton1");
      String segundo = new String("Boton2");
      String tercero = new String("Boton3");
     
      ActionListener accionConfigura=new ActionListener() {
        public void actionPerformed(ActionEvent e) {
          if (e.getActionCommand() == primero) modoApuesta=1;
          else
            if (e.getActionCommand() == segundo) modoApuesta=2;
            else
              if (e.getActionCommand() == tercero) modoApuesta=3;
        }
      };
   
      // Evento Acerca De.. 
  
      ActionListener accionAcercaDe=new ActionListener() {
        public void actionPerformed(ActionEvent e) {
          JOptionPane.showMessageDialog(ventana, "Quiniela 2000 Version 1.0",
          "Sobre Quiniela",JOptionPane.INFORMATION_MESSAGE); // El primer parametro muestra ventana en medio
        }
      };
     
  
      // Asignar cada evento con su opcion de menu
  
      empezar.addActionListener(accionEmpezar);
  
      rbMenuItem1.addActionListener(accionConfigura);
      rbMenuItem1.setActionCommand(primero);
   
      rbMenuItem2.addActionListener(accionConfigura);
      rbMenuItem2.setActionCommand(segundo);
   
      rbMenuItem3.addActionListener(accionConfigura);
      rbMenuItem3.setActionCommand(tercero);
  
      sobreQuiniela.addActionListener(accionAcercaDe);  
    
    }

    // Metodo calcular pronostico casillas
 
    public static String generaCasilla(int modo, int casilla) {
  
      Random rnd = new Random();
      int num;
  
      if (casilla<15) {
        num = rnd.nextInt(9); // Devuelve 0 a 8 
        switch(modo) {
          case 1: // 55,56 - 33,33 - 11,11
            switch(num) { 
              case 0: case 1: case 2: case 3: case 4: return "1"; 
              case 5: case 6: case 7: return "X"; 
              case 8: return "2"; 
            } break; 
          case 2: // 55,56 - 22,22 - 22,22
            switch(num) {
              case 0: case 1: case 2: case 3: case 4: return "1"; 
              case 5: case 6: return "X";
              case 7: case 8: return "2";
            } break;
          case 3: // 33,33 - 33,33 - 33,33
            switch(num) { 
              case 0: case 1: case 2:   return "1"; 
              case 3: case 4: case 5:   return "X"; 
              case 6: case 7: case 8:   return "2"; 
            } break;
       }
     }
     else {
       num=rnd.nextInt(4); // Devuelve 0 a 3
       switch(num) {
         case 0: return "0";
         case 1: return "1";
         case 2: return "2";
         case 3: return "M";
       }
     }
     return "";
   }
 }

"Hola Mundo" en Java e interfaz grafica editado con Eclipse

Se muestra un código de ejemplo en Java SE donde aparece el típico mensaje 'Hola Mundo".

Como editor para introducir el código usaremos el IDE Eclipse. En caso de no tenerlo se puede descargar gratuitamente.

Abrimos el entorno y en la barra de menú superior elegimos: New - Java Project

Se nos abrirá una ventana llamada nuevo proyecto Java ( New Java Project ). Escribimos un nombre de proyecto en el campo de texto Nombre Proyecto ( Project Name ) en este caso lo llamaremos Ventana.

Ahora tendremos una zona en la parte izquierda del editor llamada Explorador de paquetes ( Package Explorer ) donde aparecerá un arbol desplegable con el nombre del paquete Ventana. Pulsamos en el escrito Ventana y aparece desplegado una lista de elementos entre ellos uno llamado src. Pulsamos con el boton derecho del raton y elegimos las opciones New - Class para crear una nueva clase.

En la ventana que se nos abrirá llamada Nueva Clase Java ( New Java Class ) rellenaremos el campo de texto paquete ( Package ) con un nombre. En este caso ponemos com.popularfan.ejemplo1

En el campo de texto Nombre ( Name ) escribimos el nombre de la clase principal que contendrá nuestro programa. Le llamaremos Programa

Ahora con el editor configurado nos queda solo escribir el código para que nos aparezca un ' Hola Mundo ' dentro de una ventana.

Empezamos poniendo el comando

package com.popularfan.ejemplo1; 
que es donde se encontrara el archivo con el código que creamos.

Para mostrar la ventana trabajaremos con la interfaz visual de java llamada Swing. Luego importamos algunos paquetes que contienen clases de esta interfaz que vamos a necesitar como JFrame, JPanel y JLahel.

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JLabel;

La clase JFrame es la encargada de implementar la Ventana que nos mostrara en el sistema operativo.

La clase JPanel es un contenedor de componentes donde podemos poner objetos como etiquetas, botones, cajas de texto, etc..

La clase JLabel es la que define una etiqueta o letrero en nuestro caso tendremos una etiqueta que contiene la frase ' Hola Mundo '

Definimos la clase Programa y dentro definimos el método especial llamado main que será el punto de partida de nuestro programa.

public class Programa {

  public static void main(String[] args) {

  }
}

Dentro del método main creamos tres objetos ventana, panel y etiqueta. Estos objetos los declararemos del tipo que correspondan según la clase JFrame, JPanel o JLabel ademas les reservaremos memoria ( instanciaremos ) con new y las iniciaremos con un valor entre paréntesis si hace falta.

JFrame ventana = new JFrame("Ventana Principal");
JPanel panel = new JPanel();
JLabel etiqueta = new JLabel("¡ Hola Mundo !");

En el código vemos como al objeto ventana le hemos puesto el nombre de "Ventana Principal". El objeto etiqueta contiene la frase "¡ Hola Mundo !".

Seguidamente agregamos el objeto etiqueta al objeto panel que es el que contiene los objetos para mostrar en la ventana.

panel.add(etiqueta);

Finalmente configuramos el objeto ventana con algunos métodos.

ventana.setContentPane(panel);
ventana.setSize(320,200);
ventana.setVisible(true);
ventana.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

Con el método setContentPane() insertamos el panel que debe visualizar la ventana. Con setSize() configuramos el ancho y alto de la ventana. Con setVisible() hacemos la ventana visible. Con setDafaultCloseOperation() cuando se pulse el botón correspondiente cerrara la ventana y saldremos del programa.

El código final quedara así:

package com.popularfan.ejemplo1; 

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JLabel;

public class Programa {

  public static void main(String[] args) {

    JFrame ventana = new JFrame("Ventana Principal");
    JPanel panel = new JPanel();
    JLabel etiqueta = new JLabel("¡ Hola Mundo !");

    panel.add(etiqueta);
    ventana.setContentPane(panel);
    ventana.setSize(320,200);
    ventana.setVisible(true);
    ventana.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  }
}

Para correr el programa iremos al menú superior con iconos de eclipse y pulsamos el icono verde con triangulito blanco.

Texto en movimiento o 'scroll' con Javascript

" Cuando hablamos de 'scroll' nos referimos al movimiento de un texto, grafico o contenido de un videojuego que se desplaza en horizontal, vertical o ambos por la pantalla. "

Cuando hablamos de 'scroll' nos referimos al movimiento de un texto, grafico o contenido de un videojuego que se desplaza en horizontal, vertical o ambos por la pantalla.

En HTML esto se puede hacer con la etiqueta llamada marquesina o <marquee> pero le falta alguna opción sofisticada, el movimiento puede ser algo brusco y con el nuevo HTML5 pasa a estar obsoleta.

He creado una rutina de 'scroll' simple para agregarla en alguna pagina que estemos realizando, se pueden combinar varios 'scrolls' para hacer efectos interesantes.

Para que funcione tendremos que darle un nombre de identificador en CSS, añadir el 'scroll' a una clase llamada 'Scroll' en Javascript y por ultimo declararlo en HTML para que lo muestre.

Empezamos creando en CSS un nombre de identificador cualquiera por ejemplo 'scroll1' para el contenedor que albergara el texto.

Seguidamente ponemos otro nombre de identificador para una etiqueta <span> que albergara el texto a mover.

Debe quedar asi:

#scroll1
  {
    width:300px;
    background: #cccccc;
    direction: ltr; 
  }
    
#scroll1Frase
  {
    font-style: italic;
    font-weight: bold;
    font-size: 200px;  
    font-family: Arial, sans-serif;
  }  

Se puede ver que en #scroll1 declaramos el sentido en el que se movera el texto que será de derecha a izquierda con 'ltr' para hacerlo de izquierda a derecha simplemente se modifica con 'rtl'. En #scroll1Frase declaramos el formato de texto.

Luego creamos el código JavaScript que nos moverá el texto:

function Scroll(nombre)
  {
    this.id=nombre;
    this.avanza=avanza;
    this.anchoContenedor=document.getElementById(this.id)
    .parentNode.offsetWidth; 
    document.getElementById(this.id)
    .parentNode.style.overflow="hidden";  
    document.getElementById(this.id)
    .parentNode.style.whiteSpace="nowrap";
    document.getElementById(this.id)
    .parentNode.style.textIndent="0px";
    this.el=document.getElementById(this.id).parentNode;
    this.as=this.el.getElementsByTagName("span");     
    this.xo=this.anchoContenedor;
    this.contenido=this.as[0].innerHTML;
    this.anchoTexto=this.as[0].offsetWidth;
    this.dif=this.as[0].offsetWidth-this.xo; 
  }
   
function avanza(velocidad,modo)
  {
    this.as[0].parentNode.style.textIndent=""+this.xo+"px";
    if (this.anchoTexto>this.anchoContenedor) 
      {
        if (modo==0)
          {
            if (this.xo<=-this.dif) 
              this.as[0].innerHTML=this.contenido+this.contenido;

            if (this.xo<=-this.dif-this.anchoContenedor)
             {
               this.as[0].innerHTML=this.contenido;
               this.xo=0;
             } 
          }
     
        if (modo==1)
          if (this.xo<=-this.dif-this.anchoContenedor) 
            this.xo=this.anchoContenedor;
    
        if (modo==2)
          if (this.xo<=-this.dif-this.anchoContenedor) 
            { 
              this.xo=this.xo-velocidad; 
              velocidad=0; 
            }
      }
    else
      { 
        if (modo!=2)
          if (this.xo<=-this.anchoTexto) 
            this.xo=this.anchoContenedor;
          else 
            if (this.xo<=-this.anchoTexto) 
              { 
                this.xo=this.xo-velocidad; 
                velocidad=0; 
              }
      }
    this.xo=this.xo-velocidad;
  }  
  
window.onload=function()
  {
    var scroll1= new Scroll('scroll1Frase');
    window.setInterval( function (){ scroll1.avanza(5,0) }, 10 ); 
    // 5=salto o velocidad en pixels, 10=msg.
  }

Como se puede ver en la parte de codigo de carga en 'window.onload' hemos creado una clase Scroll y luego un objeto de esa clase llamado 'scroll1' en este caso coincide con el nombre declarado en la parte de CSS pero no tiene porque ser igual. En el constructor de la clase tenemos que poner el nombre del identificador de la etiqueta <span> que contendrá el texto. En nuestro caso se llamara 'scroll1Frase' como lo habíamos escrito en CSS.

Con 'window.setInterval' llamamos al método 'avanza()' de la clase Scroll que es el método que nos desplazara el texto.

El método avanza tiene dos parámetros:

El primer parámetro '5' el numero de pixels de desplazamiento.

El segundo parámetro puede ser 0,1 o 2.

0: Repite texto inmediatamente después de acabar.

1: Repite texto pero espera a que la frase acabe.

2: No repite texto.

El numero '10' en setInterval corresponde a una llamada cada 10 milisegundos.

Por ultimo escribiremos la parte de código en HTML que nos falta:

<div id="scroll1">
   <span id="scroll1Frase" >
     Esto es una prueba de texto que se desplaza.
   </span>
</div>

IMPORTANTE: Se tendra siempre que crear un contenedor <div> con identificador y dentro solo una etiqueta <span> con identificador para cada texto en movimiento, sino el resultado no será el esperado. Habrá que crear tambien un objeto nuevo para cada texto que se quiera desplazar por ejemplo scroll2, scroll3...

Dibujar punto en Html5

Alguna vez utilizado las primitivas gráficas con html5 nos ha faltado la de dibujar puntos. Una solución podría ser agregar a la librería de JavaScript ya existente un método al que llamaremos punto con los parámetros x e y.

Para dibujar un punto hacemos servir el método "fillRect" que nos dibuja un rectángulo. Los parámetros que hay que pasar son el origen x e y mas el ancho y alto. Como vamos a dibujar un punto pondremos ancho y alto con valor igual a 1.

CanvasRenderingContext2D.prototype.punto = function(x,y) { this.fillRect(x,y,1,1); }

El código completo con la solución se muestra seguidamente.

<!--DOCTYPE html--> <html> <title>Prueba punto</title> <head> <!-- Definimos estilos --> <style type="text/css"> body { background: black; } #lienzo { width: 400px; height: 400px; background: #f2f4ff; } </style> <!-- Introducimos código JavaScript --> <script type="text/javascript"> CanvasRenderingContext2D.prototype.punto = function(x,y) { this.fillRect(x,y,1,1); } window.onload=function() { ele=document.getElementById('lienzo'); ctx=ele.getContext("2d"); maximo=299; minimo=99; for (i=0;i<50000;i++) { x=Math.floor(Math.random()*(maximo-minimo+1))+minimo; y=Math.floor(Math.random()*(maximo-minimo+1))+minimo; cr=Math.floor(Math.random()*(255+1)); cg=Math.floor(Math.random()*(255+1)); cb=Math.floor(Math.random()*(255+1)); ctx.fillStyle = "rgba("+cr+","+cg+","+cb+",1)"; ctx.punto(x,y); } } </script> </head> <body> <!-- width="" height="" si variamos aqui escalamos --> <canvas id="lienzo" width="400" height="400"> <p>Navegador no soporta canvas. Aquí debería haber una imagen</p> </canvas> </body> </html>

Si ejecutamos este código podremos ver una zona cuadrada rellena de puntos en varios colores.

Construir un reloj analogico usando canvas en Html5, Css y Javascript

Usando varias tecnologías para navegadores como HTML5+CSS+Javascript voy a crear el codigo para visualizar un 'Reloj'.

Tu navegador no soporta canvas: Aquí deberías de ver una imagen :

Creo un fichero de texto con el nombre 'reloj.html' y agrego el codigo con cualquier editor de textos.

Para escribir el codigo del programa recomiendo usar el 'Notepad++' ya que es gratuito.

Primero creo la estructura HTML con su parte CSS y JavaScript. Defino el documento HTML5 con !DOCTYPE html

<!DOCTYPE html>
<HTML>
  <title>Ejemplo Reloj</title>

<head>
  <!-- Estilos CSS -->
  <style type="text/css">
  </style>

  <!-- Codigo JavaScript -->
  <script type="text/javascript">
  </script>
</head>

<!-- Cuerpo HTML5 -->
<body>
</body>
</HTML>

En la parte del cuerpo HTML5 se crea el canvas o lienzo. El tamaño 400 de ancho por 400 de alto. Este tamaño debe ser el mismo que se declare en la parte de CSS porque sino nos hace un escalado de la imagen.

Dentro de la etiqueta <canvas> hay un párrafo que se visualiza´en el caso que nuestro explorador no soporte la etiqueta <canvas> de Html5.

<canvas id="lienzo" width="200" height="200">
  <p>Tu navegador no soporta canvas: Aquí deberías de ver una imagen: </p>
</canvas>

En la parte de estilo CSS se da al fondo de la página un color negro y al lienzo un azul claro. También se define el tamaño del lienzo a 200 ancho por 200 alto.

body
  {
    background: black;
  }

#lienzo
  {
    width: 200px;
    height: 200px;
    background: #C3DCFC;
  }

En la parte código JavaScript se crea el programa con sus funciones para que muestre el reloj analógico sobre el lienzo.

Como el reloj tiene manecillas y forma circular eso quiere decir que se va a trabajar con senos, cosenos, radianes y grados para saber en que posición del reloj esta cada manecilla.

Se crea un nuevo metodo que no existe en la clase Math de Javascript para que devuelva un valor en grados a radianes y se agrega a esta clase.

Math.degToRad = function(deg) // Agregamos método a la clase estática
  {
    return deg*Math.PI/180;
  }

Para empezar a ejecutar el codigo JavaScript cuando toda la pagina ha sido cargada se usa window.onload=function(){ } . Dentro de las llaves estará el programa principal que ira llamando a las demás funciones. Para empezar a dibujar en el lienzo que se ha definido anteriormente se debe obtener un contexto de representación del Canvas. El contexto de representación que se usa será en 2D para gráficos en 2D. Para obtener un contexto de representación se llama al método getContext del elemento canvas.

window.onload=function()
  {
    ele=document.getElementById('lienzo');
    ctx=ele.getContext("2d");
  }

Llegados a este punto abriendo con el navegador el archivo reloj.html se veria la siguiente imagen:

Dentro de la funcion principal se agregaran variables que servirán para ayudar a las funciones que se crearan mas adelante para que sepan el punto central, margenes y tamaño del reloj. En la línea final se escribe una función con el nombre relojIniciar(); que es la que llama a las funciones restantes.

xmax=ele.offsetWidth; // ancho de lienzo
ymax=ele.offsetHeight; // alto de lienzo
xo=xmax/2; // Centro reloj coordenada x
yo=ymax/2; // Centro reloj coordenada y
radiox=xo-(xo/10); // Tamaño del radio ancho de la circunferencia
radioy=yo-(yo/10); // Tamaño del radio alto de la circunferencia

relojIniciar();

Se crea una función llamada relojCarcasa() que será la que dibuje los 12 puntos horarios en circulo. Con el metodo fillRect() se da a cada punto horario un ancho de 4x4 pixels. Con fillStyle se da un color negro eligiendo las tres componentes del color rgb a 0 'rgba(0,0,0, 1)'. Entre ctx.beginPath() y ctx.stroke() se dibuja las líneas o puntos del lienzo. Para situar los puntos horarios en circulo se hace uso de la formula polar de la circunferencia donde coordenada x=radio*sin(angulo) e y=radio*cos(angulo). En JavaScript los métodos Math.sin() y Math.cos() utilizan radianes por lo que si se piensa en grados habrá que hacer la conversión con el metodo Math.degToRad() que se había creado al principio. Para dividir una circunferencia en 12 partes se hace una parte por cada 30 grados y esto es lo que nos hace el bucle con el for.

function relojCarcasa() // Circulo con puntos
  {
    ctx.fillStyle = 'rgba(0,0,0, 1)';
    ctx.beginPath();
    for (ang=0; ang<360; ang=ang+30)
      {
        radianes=Math.degToRad(ang);
        x=radiox*Math.sin(radianes);
        y=radioy*Math.cos(radianes);
        x=x+xo;
        y=y+yo;
        ctx.fillRect(x,y,4,4);
      }
    ctx.stroke();
  }

Si se abre el navegador y se llama solo a la función relojCarcasa() desde la principal obtenemos esta imagen:

Se crean las tres manecillas del reloj con tres funciones llamadas relojManecillaHora(pos), relojManecillaMinuto(pos), relojManecillaSegundo(pos). Cada función recibirá un valor numérico que corresponderá a la posición de hora, minuto o segundo de la manecilla en el reloj. Con lineWidth se da grosor a la línea que dibuja la manecilla y con strokeStyle se da el color. Para dibujar las manecillas se hace con el método que dibuja líneas lineTo(x,y) siendo el origen de la línea el que posiciona con el método moveTo(xo,yo). Se usa la formula polar de la circunferencia para colocar cada manecilla en su lugar.

function relojManecillaHora(pos)
  {
    ctx.lineWidth = 4;
    ctx.strokeStyle = 'rgba(0,0,0, 1)';
    ctx.beginPath();
    radianes=Math.degToRad(180-pos*30); // hora
    x=radiox/1.5*Math.sin(radianes);
    y=radioy/1.5*Math.cos(radianes);
    x=x+xo;
    y=y+yo;
    ctx.moveTo(xo,yo);
    ctx.lineTo(x,y);
    ctx.stroke();
  }

function relojManecillaMinuto(pos)
  {
    ctx.lineWidth = 2;
    ctx.strokeStyle = 'rgba(0,0,0, 1)';
    ctx.beginPath();
    radianes=Math.degToRad(180-pos*6); // minuto
    x=radiox/1.25*Math.sin(radianes);
    y=radioy/1.25*Math.cos(radianes);
    x=x+xo;
    y=y+yo;
    ctx.moveTo(xo,yo);
    ctx.lineTo(x,y);
    ctx.stroke();
  }

function relojManecillaSegundo(pos)
  {
    ctx.lineWidth = 1;
    ctx.strokeStyle = 'rgba(221,64,4, 1)';
    ctx.beginPath();
    radianes=Math.degToRad(180-pos*6); // segundo
    x=radiox*Math.sin(radianes);
    y=radioy*Math.cos(radianes);
    x=x+xo;
    y=y+yo;
    ctx.moveTo(xo,yo);
    ctx.lineTo(x,y);
    ctx.stroke();
  }

En este punto ya se tienen las funciones mas básicas del reloj, solo falta crear una función que asigne la hora a las manecillas y las dibuje junto a la carcasa a la cual se llamara relojAvanza(). Se utiliza la clase Date() que nos dara la hora, minutos, segundos del sistema con los métodos getSeconds(), getMinutes(), getHours().

function relojAvanza()
  {
    var f=new Date();
    ctx.clearRect(0,0,xmax,ymax);//borra canvas, hacerla transparente o sin contenido gráfico
    relojCarcasa();
    relojManecillaSegundo(f.getSeconds());
    relojManecillaMinuto(f.getMinutes());
    relojManecillaHora(f.getHours());
  }

También se necesitara otra función que se encargue de llamar cada segundo a relojAvanza() que es la que se ha llamado en un punto anterior relojIniciar(). Esta función usa el método setInterval('función()',ms) cada intervalo de un valor en milisegundos ira llamando a 'función()' en este caso 1000 será 1 segundo.

function relojIniciar()
  {
    window.setInterval('relojAvanza()', 1000);
  }

Ya estaría acabado todo el código. Si ahora abrimos el fichero 'reloj.html' con el navegador podremos ver el reloj analógico marcando el tiempo actual.

Las variables en JavaScript se han declarado globales y se ha programado pensando en programación estructurada mediante funciones y no mediante objetos.