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.
jueves, 25 de agosto de 2016
jueves, 30 de junio de 2016
Truco Java - Uso de ListIterator
By Migueljueves, junio 30, 2016CONSEJOS, java, LISTITERATOR, PROGRMACION, TIPS, TRUCO
No hay comentarios:
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 y facebook.
martes, 28 de junio de 2016
Truco Delphi - Enviar emails usando el servicio Gmail de Google
By Miguelmartes, junio 28, 2016CONSEJOS, DELPHI, GMAIL, INDY PROGRMACION, TIPS, TRUCO
9 comentarios:
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 y facebook.
jueves, 23 de junio de 2016
Truco Delphi - MessageBox organizados y personalizados.
By Migueljueves, junio 23, 2016CONSEJOS, DELPHI, MESSAGEBOX, PROGRMACION, TIPS, TRUCO
No hay comentarios:
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:
- MessageBox es una función de la Api de Windows, por tanto, los textos de los botones estarán localizados al idioma del sistema.
- 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;
Si tienes cualquier duda o comentario recuerda que puedes exponerlo aquí o bien mediante nuestro twitter y facebook.
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.
Enlace original en inglés: http://www.digitaltrends.com/ features/what-happens-when- anyone-can-code/
lunes, 20 de junio de 2016
Truco Delphi - Ocultar icono de nuestra aplicación en barra de tareas
By Miguellunes, junio 20, 2016CONSEJOS, DELPHI, ICONO, OVERRIDE, PROGRMACION, TIPS, TRUCO
No hay comentarios:
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:
Si tienes cualquier duda o comentario recuerda que puedes exponerlo aquí o bien mediante nuestro twitter y facebook.
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.
viernes, 17 de junio de 2016
Truco Java - Añadir imágenes a un JTable desde un campo Blob en MySQL
By Miguelviernes, junio 17, 2016BLOB, CONSEJOS, IMAGEICON, java, JGRID, PROGRMACION, SWING, TIPS, TRUCO
2 comentarios:
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 |