jueves, 25 de agosto de 2016

Cómo bloquear / desactivar / eliminar los anuncios de Skype



Todos los que usamos Skype nos hemos acostumbrado a convivir con los anuncios que la aplicación nos muestra pero, ¿sabíais que se pueden desactivar de una manera muy sencilla? Sigue leyendo y te explico cómo.


Compartir:

jueves, 30 de junio de 2016

Truco Java - Uso de ListIterator

Hoy más que un truco os voy a poner un ejemplo de utilización de la clase ListIterator
ListIterator es un iterador secuencial que posibilita recorrer listas en cualquier sentido. Hay que tener presente que la posición de un iterador no representa ningún valor real de la lista, siempre estará entre dos elementos, al principio o al final.



En el ejemplo vamos a recorrer un Array de cadenas extrayendo los valores numéricos y posteriormente recorriendo la lista hacia adelante y hacia atrás.

 
package TrucosIExpression;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.ListIterator;

/**
 *
 * @author InvalidExpression
 */
public class Truco1 {

    /**
     * Metodo que extray todos los valores numéricos de un array de cadenas
     * y lo devuelve en un ArrayList
     * @param cadenas String[] .
     * @return ArrayList con valores numericos extraidos.
     */
    public ArrayList extraerNumeros(String[] cadenas) {
        if (cadenas == null) {
            throw new IllegalArgumentException("Parámetro erroneo.");
        } else {
            ArrayList arrayCadenas = new ArrayList();
            arrayCadenas.addAll(Arrays.asList(cadenas));
            ListIterator listaIterador;
            listaIterador = arrayCadenas.listIterator();
            while (listaIterador.hasNext()) {
                String cadena = (String) listaIterador.next();
                try {
                    Integer numero = new Integer(cadena);
                } catch (NumberFormatException e) {
                    listaIterador.remove();
                }
            }
            return arrayCadenas;
        }
    }

    /**
     * Metodo main.
     *
     * @param args String[] args.
     */
    public static void main(String[] args) {
        Truco1 trucoIterator = new Truco1();
        String[] cadenas = {"SILLA","5", "1", "4", "MESA", 
                            "8", "ZAPATO", "CERVEZA", "10", "12"};
        ArrayList arrayNumeros = trucoIterator.extraerNumeros(cadenas);
        ListIterator iterador = arrayNumeros.listIterator();
        //Recorremos de principio a fin con hasNext
        while (iterador.hasNext()) {
            System.out.println(iterador.next());
        }
        //Recorremos desde el final hasta el principio.
        while (iterador.hasPrevious()) {
            System.out.println(iterador.previous());
        }
    }
}

El resultado de la ejecución de este pequeño programa en NetBeans sería el siguiente:


Si necesitáis más información sobre ListIterator podéis encontrarla aquí.

Si tienes cualquier duda o comentario recuerda que puedes exponerlo aquí o bien mediante nuestro twitter facebook.
Compartir:

martes, 28 de junio de 2016

Truco Delphi - Enviar emails usando el servicio Gmail de Google

En el truco de hoy os voy a enseñar como podéis enviar correos electrónicos desde vuestra aplicación Delphi mediante vuestra cuenta Gmail.


Para ello vamos a hacer uso de los componentes Indy disponibles en cualquier versión de RAD Studio (en el truco se utiliza la versión XE8 pero está testeado en XE5 también).

Vamos a crearnos una función SendGMail con el siguiente código:
 
procedure SendGmail(pUsuario, pPassword, pAsunto, pCuerpo, pDestino : string);
var
  Smtp : TidSMTP;
  ManejadorSSL : TidSSLIOHandlerSocketOpenSSL;
  Mensaje: TIdMessage;
begin
  ManejadorSSL := TIdSSLIOHandlerSocketOpenSSL.Create(nil);
  with ManejadorSSL do
  begin
   Destination := 'smtp.gmail.com:587';
   Host := 'smtp.gmail.com';
   MaxLineAction := maException;
   Port := 587;
   SSLOptions.Method := sslvTLSv1;
   SSLOptions.Mode := sslmUnassigned;
   SSLOptions.VerifyMode := [];
   SSlOptions.VerifyDepth := 0;
  end;

  Smtp := TIdSMTP.Create( nil );

  with Smtp do
  begin
    IoHandler := ManejadorSSL;
    Host := 'smtp.gmail.com';
    Port := 25;
    Username := pUsuario;
    Password := pPassword;
    UseTLS := utUseExplicitTLS;
  end;

  Mensaje := TIdMessage.Create(nil);
  with Mensaje do
  begin
    Clear;
    Subject := pAsunto;
    Body.Text := pCuerpo;
    Recipients.Add;
    Recipients.Items[0].Address := pDestino;
  end;

  Smtp.Connect;
  if smtp.Connected then
  begin
    smtp.Send(Mensaje);
    smtp.Disconnect;
  end;

  FreeAndNil(Smtp);
  FreeAndNil(Mensaje);
  FreeAndNil(ManejadorSSL);

end;


Y ya está, solamente tendremos que llamar a esta función con los parámetros relativos a nuestra cuenta para enviar nuestro correo.

En lugar de crear los objetos dinámicamente, podéis pegar objetos directamente desde la paleta de componentes en vuestro formulario y ahorraros el create; si lo hacéis dinámicamente no olvidéis incluir en el uses las referencias necesarias:

uses
  [...] IdMessage, IdIOHandler, IdIOHandlerSocket, IdIOHandlerStack,
  IdSSL, IdSSLOpenSSL, IdBaseComponent, IdComponent, IdTCPConnection,
  IdTCPClient, IdExplicitTLSClientServerBase, IdMessageClient, IdSMTPBase,
  IdSMTP,IdAttachmentFile,IdGlobal;

Observaréis que falta la opción de adjuntar algún archivo, pero eso lo vamos a dejar para futuros trucos.

Si tienes cualquier duda o comentario recuerda que puedes exponerlo aquí o bien mediante nuestro twitter facebook.

Compartir:

jueves, 23 de junio de 2016

Truco Delphi - MessageBox organizados y personalizados.

Si eres, o has sido, programador Delphi, seguramente te has encontrado muchas aplicaciones donde se utiliza la función Showmessage, MessageBox o Messagedlg o incluso todas a la vez de manera desorganizada y no unificada.


En este truco/post os voy a mostrar como organizar vuestros mensajes de aplicación en una única unidad y como personalizarlos con vuestros propios iconos sin necesidad de crear formularios específicos para ellos.

Mi recomendación es que utilicéis siempre MessageBox, por dos motivos:
  1. MessageBox es una función de la Api de Windows, por tanto, los textos de los botones estarán localizados al idioma del sistema.
  2. Permite una mayor personalización y control de los mensajes mostrados.
En toda aplicación suelen utilizarse, al menos, tres tipos de mensajes de diálogo con el usuario; Mensajes de error, mensajes de aviso y mensajes de pregunta.

Mi recomendación es que os creéis una unidad donde agrupéis todos esos mensajes de manera que podáis utilizarlos en toda la aplicación, por ejemplo algo así:

  
unit UDialogos;

interface

uses Windows;

procedure MensajeError(owner: HWND; p_texto :string);
procedure MensajeAviso(owner: HWND; p_texto :string);
function Pregunta(owner: HWND; p_texto, p_titulo: string) : boolean;

implementation

procedure MensajeError(owner: HWND; p_texto :string);
begin
  MessageBox(owner, pchar(p_texto), 'Error',
               MB_ICONERROR or MB_OK or MB_TASKMODAL)
end;

procedure MensajeAviso(owner: HWND; p_texto :string);
begin
  MessageBox(owner, pchar(p_texto),'Aviso',
               MB_ICONINFORMATION or MB_OK or MB_TASKMODAL )
end;

function Pregunta(owner: HWND; p_texto, p_titulo: string) : boolean;
begin
  result := MessageBox(owner, pchar(p_texto), pchar(p_titulo),
               MB_ICONQUESTION or MB_YESNO or MB_TASKMODAL) = IDYES
end;

end.


De esta manera tendremos todos los mensajes localizados en una unidad de nuestra aplicación y a nuestra disposición para cuando los necesitemos.

Es importante utilizar correctamente el parámetro "owner" de esas funciones y pasárles siempre el "Handle" del formulario que llama a la función ("Self.Handle") para que los diálogos sepan delante de quién deben mostrarse.

Si no os gustan los iconos por defecto que muestra Windows, siempre podéis utilizar los vuestros utilizando "MB_USERICON", pero en este caso deberéis utilizar la función MessageBoxIndirect.

Supongamos que tenemos un icono en los recursos de nuestra aplicación llamado 'ICONICO' y que queremos mostrarlo en un mensaje de dialogo concreto, escribiríamos lo siguiente:

  
procedure MensajePersonalizado(owner: HWND; p_texto, p_titulo :string);
var
  flags : uint;
  MsgPars: TMsgBoxParams;
begin
  flags := MB_USERICON or MB_OK or MB_DEFBUTTON1 or MB_TASKMODAL;

  //Establecemos los parámetros
  with MsgPars do
  begin
    cbSize := SizeOf(MsgPars);
    hwndOwner := owner;
    hInstance := Sysinit.hInstance;
    lpszText := PChar(p_texto);
    lpszCaption := pchar(p_titulo );
    dwStyle := flags;
    lpszIcon := 'ICONICO'; //Nuestro icono en los recursos
    dwContextHelpId := 0;
    lpfnMsgBoxCallback := nil;
    dwLanguageId := LANG_NEUTRAL;
  end;

  MessageBoxIndirect(MsgPars);

end;



Una última consideración sobre utilizar MB_OKCANCEL o MB_YESNO. Cualquier flag que incluya OK y/o CANCEL responderá a las teclas "Intro" para el OK y "Escape" para el CANCEL, es decir, si utilizáis MB_YESNO, "intro" y "escape" no funcionarán, si utilizáis MB_OKCANCEL, si que lo harán.

Si tienes cualquier duda o comentario recuerda que puedes exponerlo aquí o bien mediante nuestro twitter facebook.
Compartir:

martes, 21 de junio de 2016

¿Qué pasaría si todo el mundo fuese capaz de programar? Estamos a punto de averiguarlo.


Podemos estar entrando en una era en la que cualquiera es capaz de hacer programas, a pesar de que no sepan programación – al menos no de la manera en la que la mayoría nosotros lo entendemos ahora mismo.

He empezado a jugar con una aplicación para iPad llamada Ready, que permite a los más pequeños hacer pequeños juegos, aplicaciones sencillas, y proyectos digitales creativos. Utiliza una sencilla interfaz “drag-and-drop” (arrastra y suelta) para crear objetos, cambiar sus propiedades, y hacer que interactúen entre ellos o con el usuario.


Crear una pelota, proporcionarle “físicas” para que responda a la gravedad; convertirla en goma para que “rebote” sobre las superficies; hacer una barra que se mueva de izquierda a derecha con los cursores; construir un muro de bloques que desaparecen cuando son golpeados por la pelota y listo… tenemos un Arkanoid de toda la vida.

Lo que WYSISWYG (lo que ves es lo que obtienes) hizo por la creación de documentos, lo hacerReady por la programación. Pero los efectos podrían ir más allá que el mero ahorro de tiempo.

Programación Drag-and-Drop

Ready realmente es un escritorio de Unity, el motor de juego multiplataforma que a su vez está basado en C y C++. Al permitir a los niños desarrollar juegos simplemente utilizando drag-and-drop e interfaces if/then, Ready sitúa a jóvenes desarrolladores un nivel por encima de lo que podríamos considerar como código “real” – pero sigue permitiéndoles crear desde cero.

Yendo más allá, imagino que los usuarios, con el tiempo, serán capaces de profundizar lo suficiente para crear sus propios objetos y elementos – quizá incluso ofreciéndolos a otros en un mercado digital. Piensa en un Minecraft, pero construido desde el principio para ser una plataforma creativa completamente abierta.


Las buenas ideas son más valoradas que el buen código.

Jugar con estas herramientas hace que me pregunte si, dentro de poco, todos nosotros estaremos desarrollando de esta manera. ¿Podría "Ready" y otros escritorios similares hacer por la programación lo que hizo Photoshop por las imágenes o Word por la creación documental?. Si lo hace, entonces la creación de aplicaciones por “no-programadores” con buenas ideas podría ser inminente. Aunque el código puede no ser tan elegante ni optimizado como si un desarrollador lo escribiera desde cero, este tipo de aplicaciones serían válidas como prototipos.


Cuanto más fáciles sean los ordenadores, más se alejan los usuarios de ser programadores.


Un conjunto configurable de elementos y objetos como "Ready" puede que no tenga en cuenta las infinitas posibilidades y nuevas innovaciones de la codificación pura, pero la mayoría de los programas actualmente no usan ese tipo de innovación de todos modos. Pensemos en Uber. Una aplicación GPS enlazada a una aplicación de cobros enlazada a una aplicación de citas. Y los nuevos programadores no van a intentar crear nada tan robusto como una plataforma de intercambio de ficheros global ni nada parecido.

Antes de que los más puristas empecéis a atacar el concepto de una programación que se dirige más hacia PowerPoint que hacia Python, consideremos por un momento que podríamos decir lo mismo sobre cualquier lenguaje de programación. Después de todo C++ o cualquier lenguaje de alto nivel, pasa a través de un compilador para convertirse en algo que la mayoría de nosotros es incapaz de leer. Y el programa en sí mismo se asienta sobre un sistema operativo, y lenguaje ensamblador, e instrucciones máquina, y arquitectura basada en chips… Puedes considerarte a ti mismo un desarrollador de software competente sin haber bajado jamás a ese nivel de comprensión.

Créeme, yo me encuentro entre los puristas, resentidos por la aparición del Mac y otras interfaces que parecían diseñadas intencionadamente para hacer la computación “más fácil” simplemente distanciando a los usuarios de las funciones básicas. Microsoft hizo que invocásemos a “the wizard” (el mago), como si fuera algo misterioso que las aplicaciones y sus extensiones acabasen en el directorio correcto. Cuanto más fáciles sean los ordenadores, más se alejan los usuarios de ser programadores. Echo de menos mi fichero autoexec.bat



Más que un simple ahorro de tiempo.


Ready” me hace pensar que la simplificación de las interfaces de usuario puede, finalmente, ofrecer algo distinto a un simple distanciamiento del código: el poder. La gratificación instantánea de construir algo en “Ready” proporciona esa sensación de poder – casi como ser el autor de Hypercard en los primeros días de Macintosh o construir un sitio en WordPress cuando mi ambición y necesidades superan claramente mis habilidades. Hay un plug-in de WordPress para casi todo lo que puedo querer hacer en mi sitio.

Una cosa es cierta, si la gente no tiene que escribir código, puede que nunca entiendan cómo funcionan realmente las cosas. Estarán limitados por las posibilidades ofrecidas por los creadores de las plataformas, a través de las cuales ensamblarán componentes prefabricados en aplicaciones y otras experiencias digitales.

Del mismo modo que dimos la bienvenida a los usuarios de AOL al Internet real, “Ready” y otras aplicaciones, pueden hacer entrar a legiones de “desarrolladores civiles” en la industria de los juegos y las aplicaciones. Con la democracia viene un poco de embrutecimiento. No van a ser maestros en programación, pero tampoco son maestros en música los compositores que escriben las canciones de las bandas de garaje. Esta puede ser la realidad creativa “mash-up” hacia la que vamos. (El mashup es un género musical que consiste en la creación de un nuevo tema mediante la combinación de fragmentos (loops), instrumentos concretos, pistas vocales (a cappellas) y pistas instrumentales a cachitos o enteras de otros temas anteriormente ya realizados por otros). Hay mucho que aprender si quieres estar al día. Yo era bueno en Pascal, pero hoy en día los lenguajes de programación son muy duros y puede que no compense lo suficiente aprenderlos.

Este puede ser el momento en que finalmente entramos en la era de “Bandas de Garage” de la creación de aplicaciones y juegos. Las cosas pueden ponerse complicadas, pero también serán menos comerciales, brillantes y funcionalmente opacas.

A pesar de todo, en un mundo en el que escribir código se ha convertido en una habilidad rara y valiosa, una plataforma como “Ready” permite a las masas experimentar el poder de la creación.

Esa experiencia, por si misma, puede ser más importante que cualquiera de las aplicaciones que creemos. Cambia la manera en la que percibimos el panorama digital en el que gastamos gran parte de nuestras vidas. Ahora mismo todo es software creado por otros, pero con las herramientas correctas, podría ser el software que imaginemos y creemos por nosotros mismos.

Estoy listo para eso.


Artículo por: Douglas Rushkoff. Traducido y adaptado por: Miguel Montero Gámez.


Si tienes cualquier duda o comentario recuerda que puedes exponerlo aquí o bien mediante nuestro twitter facebook.
Compartir:

lunes, 20 de junio de 2016

Truco Delphi - Ocultar icono de nuestra aplicación en barra de tareas

Hoy toca un truco rápido, fácil y para toda la familia que consiste en ocultar el icono de nuestra aplicación de la barra de tareas en Delphi.

¿Para que sirve esto? Bueno, eso depende; imaginad que necesitáis hacer una aplicación iconizada en el área de notificaciones (Al lado del reloj) y que queréis que cuando se muestre no aparezca el icono en la barra de tareas (igual que el reloj de Windows por ejemplo).

Para ello solamente tendremos que anular la función CreateParams de la clase TForm para codificar nosotros mismos lo que necesitamos de la siguiente manera:
  
TfrmPrincipal = class(TForm)
  private
    { Private declarations }
  protected
    procedure CreateParams(var Params: TCreateParams); override;
  public
    { Public declarations }
  end;

procedure TfrmPrincipal.CreateParams(var Params: TCreateParams);
begin
  inherited;
  Params.ExStyle := Params.ExStyle and not WS_EX_APPWINDOW;
  Params.WndParent := Application.Handle;
end;

Si tienes cualquier duda o comentario recuerda que puedes exponerlo aquí o bien mediante nuestro twitter y facebook.
Compartir:

viernes, 17 de junio de 2016

Truco Java - Añadir imágenes a un JTable desde un campo Blob en MySQL

Hoy hemos realizado una encuesta a través del twitter del blog preguntandoos sobre que lenguaje queríais el siguiente truco y ha ganado JAVA.

Por suerte estoy realizando un master de JAVA ahora mismo y a diario me surgen problemas y dudas que voy solventando y que, seguramente, sean las mismas que tengáis vosotros si estáis empezando con este lenguaje.

En el truco que nos ocupa hoy os voy a enseñar cómo solucioné la cuestión de mostrar un campo de imagen (tipo BLOB en MySQL) en un JTable.


Os pondré el código que rellena la tabla y luego os destacaré un par de secciones que son las que considero más importantes.

Este es el código en cuestión:

    /**
     * Procedimiento LlenarTabla
     * Utilizando el procedimiento modeloImagen.listImagen,
     * se rellena la tabla pasada por parametro.
     * @param tablaImagenes
     * @throws java.sql.SQLException
     * @throws java.io.IOException
     */
    public void LlenarTabla(JTable tablaImagenes) throws SQLException, IOException{
        DefaultTableModel modeloTabla = new DefaultTableModel() {
            @Override //Redefinimos el método getColumnClass
            public Class getColumnClass(int column){
                switch(column) {
                    case 0: return Object.class;
                    case 1: return Object.class;
                    case 2: return Object.class;
                    case 3: return ImageIcon.class;
                    default: return Object.class;
                }
            }
        };
        //Establecemos el modelo correspondiente en la JTable
        tablaImagenes.setModel(modeloTabla);
        
        //Añadimos las columnas correspondientes
        modeloTabla.addColumn("ID IMAGEN");
        modeloTabla.addColumn("ES CATEGORIA");
        modeloTabla.addColumn("DESCRIPCION");
        modeloTabla.addColumn("IMAGEN"); //Esta es la columna [3], es la que
                                         //nos interesa que sea una imagen.
                
        Object[] columna = new Object[4];
        
        ArrayList<imagen> listaImagenes = modeloImagenes.ListarImagenXEsCategoria("","");
        
        int numRegistros = listaImagenes.size();
        
        for (int i = 0; i < numRegistros; i++) {
            columna[0] = listaImagenes.get(i).getIdImagen();
            columna[1] = listaImagenes.get(i).getEsCategoria();
            columna[2] = listaImagenes.get(i).getDescripcion(); 

            //Transformamos el campo blob en ImageIcon
            Blob blob = listaImagenes.get(i).getImagen();
            int blobLength = (int) blob.length();  
            byte[] bytes = blob.getBytes(1, blobLength);
            blob.free();
            BufferedImage img = ImageIO.read(new ByteArrayInputStream(bytes));
            ImageIcon icon = new ImageIcon(img); 
            
            //Añadimos la imagen a la columna correspondiente
            columna[3] = icon;
            
            //Añadimos la fila al modelo
            modeloTabla.addRow(columna);
            
            //Establecemos el alto de la fila                                   
            tablaImagenes.setRowHeight(i, icon.getIconHeight());    
        }
        
   } 


No voy a entrar en el detalle de cómo recupero los datos de MySQL ni de cómo se define la clase Imagen (si queréis el código podéis pedírmelo en los comentarios y os lo facilitaré), pero sí quiero que prestéis atención a este código:

        DefaultTableModel modeloTabla = new DefaultTableModel() {
            @Override //Redefinimos el método getColumnClass
            public Class getColumnClass(int column){
                switch(column) {
                    case 0: return Object.class;
                    case 1: return Object.class;
                    case 2: return Object.class;
                    case 3: return ImageIcon.class;
                    default: return Object.class;
                }
            }
        };

Ese fragmento de código define el modelo que utilizará el objeto JTable y sobre el hemos de redefinir el método getColumnClass para que, en la columna [3] nos devuelva un ImageIcon, que es lo que queremos mostrar.

Otra parte importante del código, y que seguro que muchos ya conocéis, es el encargado de convertir el campo BLOB en un ImageIcon.
 
            //Transformamos el campo blob en ImageIcon
            Blob blob = listaImagenes.get(i).getImagen();
            int blobLength = (int) blob.length();  
            byte[] bytes = blob.getBytes(1, blobLength);
            blob.free();
            BufferedImage img = ImageIO.read(new ByteArrayInputStream(bytes));
            ImageIcon icon = new ImageIcon(img); 
            

Con estos sencillos pasos podemos obtener el resultado deseado.

Resultado final en una aplicación SWING

Si tienes cualquier duda o comentario recuerda que puedes exponerlo aquí o bien mediante nuestro twitter y facebook.
Compartir:

Stream

Con la tecnología de Blogger.

BoosterBlog

BoosterBlog
BoosterBlog

Timeline Twitter

Seguidores

Seguidores