fabryzziotaringa

El gigante informático lleva una semana sin resolver el problema, que lo hace vulnerable a un virus que entra a las computadoras de los usuarios y roba sus claves secretas. Según los expertos, lo más seguro es utilizar otro navegador. Las claves bancarias, las passwords de los correos electrónicos y todo aquello que se tipee en una máquina conectada a Internet podrían caer en manos de piratas informáticos y provocar desastres. Es que se acaba de detectar que el navegador Internet Explorer de Microsoft tiene un error de seguridad que permite que se instalen programas espías sin que los usuarios se den cuenta. El problema podría quedar en los archivos de la Era de los virus informáticos si no fuera porque afecta a la mayoría de los usuarios de Internet. Casi el 90% de las máquinas del mundo tiene instalada alguna versión del Explorer y lo prefieren casi siete de cada diez navegantes. Según reconoció Microsoft a Clarín, el error de seguridad fue detectado en la versión 7.0 de su producto estrella. Pero desde la empresa advierten que las anteriores también son "vulnerables". Ni siquiera se salva la versión de prueba del Internet Explorer 8. El agujero de seguridad se produce por un error en las llamadas "etiquetas XML", una parte del lenguaje web con que se programan los sitios. El fallo permite que se descarguen y autoejecuten en la maquina víctima programas dañinos o espías, sin que el usuario lo sepa, lo que lo vuelve extremadamente peligroso. Los hackers, aprovechando otros fallos de seguridad en servidores web, modificaron miles de sitios e instalaron troyanos (virus) que infectan las máquinas debido al bache del Internet Explorer. Entonces, cuando el usuario ingresa en esas webs llama automáticamente a esos virus que comienzan a descargase en su PC a través de este navegador sin que se pueda hacer nada para evitarlo. Se calcula que los usuarios pueden infectarse desde unas 10.000 páginas, la mayoría chinas. Cristian Borghello, director de Educación de ESET Latinoamérica, una empresa especializada en antivirus, explicó que los hackers ya han robado nombres de usuarios y claves de jugadores online de las computadoras infectadas. Pero que "nada les impide conseguir números y claves de cuentas bancarias", por ejemplo. Aníbal Jalaris, manager de infraestructura de Baufest, una empresa de desarrollo de software, explicó que el fallo "compromete a la totalidad de las máquinas que tienen Explorer y las pone en riesgo porque caen todas las defensas de frontera que uno tiene. Y eso obligará a verificar las instalaciones de cada una de ellas una vez que salga el 'parche' de seguridad". El agujero informático, que el gigante de software también reconoció en un comunicado oficial, es lo que se conoce como un "zero day exploit", es decir, un problema para el cual la empresa no ha tenido una solución. Por eso, la comunidad de bloggers y fanáticos de la tecnología lanzaron una campaña a través de Internet para prevenir a los usuarios y aconsejan pasarse a otros navegadores hasta tanto se solucione el fallo. Desde que detectó el fallo la semana pasada, Microsoft está trabajando a todo vapor para lanzar un "parche" que ponga fin a la "vulnerabilidad", como ellos le llaman a este problema. Según dijo a Clarín José Cella, Gerente de Iniciativas de Seguridad para Argentina y Uruguay, la actualización del software podría estar lista hoy mismo. Sin embargo, eso no resuelve el bache. Hasta tanto todos los usuarios se instalen el parche, el problema persiste. Por eso, las empresas de seguridad informática están actualizando sus antivirus para tratar de contener esta nueva epidemia que hasta ahora parece no haber atacado en América latina. Por el momento, la única solución 100 por ciento segura es usar otro navegador, como por ejemplo Firefox de la Fundación Mozilla, una entidad sin fines de lucro en la que colaboran miles de programadores y han logrado hacer de este browser uno de los más seguros del mundo. Otras opciones son Safari de Apple, Opera o el flamante Chrome de Google. Todos se pueden descargar gratis y no son vulnerables al error detectado por Microsoft. Fuente

Registrate y eliminá la publicidad! Java FX Script, primeros pasos ¿Qué es JavaFX Script? Parte 1: JavaFX Script es un lenguaje de scripting declarativo estáticamente tipado, llamado anteriormente F3 (Form Follows Function) que fue desarrollado en su mayoría por Chris Oliver, quien trabaja para Sun microsystems desde la adquisición de SeeBeyond Technology por parte de esta a fines de 2005. El compilador de JavaFX, así como gran parte de las bibliotecas gráficas y herramientas se encuentran liberadas con la licencia GPL2, a través del proyecto OpenJFX. JFXS Forma parte del conjunto de tecnologías JavaFX, las cuales tienen el propósito de facilitar la creación de Rich Internet Applications (RIAs) con gran cantidad de contenido multimedia, respetando siempre la idea de Java de poder luego ejecutarlas en forma independiente de la plataforma. Lo último que pudo verse de esta tecnología son las "draggable applets", que son aplicaciones (que como su nombre indica) pueden arrastrarse desde el navegador al escritorio, en donde se convierten en una especie de "widgets" (similares a aquellos del Dashboard en Mac OS X o los del Sidebar de Windows Vista), estas fueron presentadas en JavaOne 2008, y les dedicamos un post hace tiempo en el que pueden obtener más info. La idea de esta serie de artículos es introducir las características de este novedoso lenguaje a través de la realización de pequeños ejemplos. En esta primera parte solo utilizaremos el Pad de JavaFX (click en el link para ejecutarlo), que es una pequeña aplicación multiplataforma que podrán ejecutar desde Internet utilizando Java Web Start (sólo requiere tener instalado el JRE de Java). ¿Lenguaje declarativo?, ¿Estáticamente tipado? Para comenzar, la característica principal de JFXS es que es un lenguaje de tipo declarativo, esto significa que, en vez de explicar "como" realizar algo (el algoritmo, en los lenguajes imperativos), deberemos describir "que" es ese algo. Por ejemplo, en HTML, se declara el contenido de la pagina, pero no se explica como este será mostrado en la pantalla. En general, se consideran declarativos aquellos programas escritos en un lenguaje puramente funcional, lógico o basado en restricciones, formando un paradigma que contrasta con el imperativo. Para ver a que me refiero con "declarativo", podemos ver el siguiente programa JFXS: import javafx.ui.*; class HelloWorldModel { attribute saying: String; } var model = HelloWorldModel { saying: "Hello World" }; var win = Frame { title: bind "{model.saying} JavaFX" width: 200 content: TextField { value: bind model.saying } visible: true }; En el mismo podemos observar como aparecen una debajo de la otra las descripciones de los elementos que formaran parte de, en este caso, un frame con el mensaje "hello world". Nótese como, en ningún momento aparece un punto de entrada al programa (un método main, por ejemplo), en vez de esto, el motor de JFXS deberá leer todo el contenido del programa, para que luego el interprete decida que hacer con toda esta información. La segunda característica importante de JFXS es que es estáticamente tipado, esto quiere decir que la verificación de tipos se realiza en tiempo de compilación. Por lo tanto, si bien es un lenguaje de scripting, no podremos hacer cosas típicas de estos lenguajes como cambiar el tipo de una variable en tiempo de ejecución. Veamos el siguiente ejemplo: var myVariable = "Hello"; //linea 1 myVariable = 12345; // linea 2 En la linea 1, creamos la variable "myVariable" y le asignamos el String "Hello". En la linea 2, intentamos asignarle el valor 12345, sin las comillas, lo cual implica que el valor será interpretado como un integer, resultando en un error. Resultado de intentar realizar esta operación en JavaFX Pad Elementos del lenguaje Lamentablemente, y como en todos los tutoriales de un nuevo lenguaje, no podemos escaparnos de la introducción a los elementos del mismo. Puede que sea aburrido, pero es mejor conocerlos desde un principio que perder tiempo recurriendo a la ayuda luego, cuando estemos trabajando en ejemplos más interesantes. Tipos primitivos Para comenzar, veremos los tipos primitivos de JFXS, que se corresponden a tipos del lenguaje Java, de la siguiente forma: JavaFX Java String java.lang.String Boolean java.lang.Boolean Number java.lang.Number Integer byte,short,int,long,BigInteger Podemos utilizar en ellos los mismos métodos que utilizamos en programas Java, por ejemplo: var s = "que aburrido"; s.toUpperCase(); // retorna "QUE ABURRIDO"; s.substring(4); // retorna "aburrido"; var n = 4.5; n.intValue(); // retorna 4 (1.5).intValue(); // retorna 1 s.substring(n); // retorna "aburrido" var b = true; b instanceof Boolean; // retorna true Adicionalmente, los valores numéricos se truncan automáticamente cuando interactúan con métodos Java así como cuando se convierten Numbers a Integers. En JFXS podemos importar clases Java, crear objetos y llamar sus métodos. Por ejemplo: import javax.swing.JFrame; import javax.swing.JButton; import java.awt.event.ActionListener; import java.lang.System; var frame = new JFrame(); var button = new JButton("Apretame"; frame.getContentPane().add(button); button.addActionListener(new ActionListener() { operation actionPerformed(event) { System.out.println("Me apretaste"; } }); frame.pack(); frame.setVisible(true); Esto dará como resultado lo siguiente: Sin embargo, utilizar JFSX de esa forma rompe totalmente con la idea de sencillez propuesta por el lenguaje, por lo que una manera más apropiada de escribir el mismo programa sería: import javafx.ui.*; import java.lang.System; Frame { content: Button { text: "Apretame" action: operation() { System.out.println("Me apretaste"; } } visible: true } Pueden verificar el resultado copiando y pegando los códigos en el pad de JavaFX. Variables En JFXS la palabra reservada "var" encabeza la declaración de una nueva variable. Si no se especifica un tipo para la misma, el interprete lo inferirá de acuerdo al uso que le demos. Una declaración de variable en JFXS toma la siguiente forma: var nombreDeLaVariable : tipoDeLaVarible [?,+,*] = valor; Donde tanto los operadores "?", "+", "*" como el tipo de la variable (e incluso el valor) son opcionales. El signo de pregunta implica que la variable puede ser null, el asterisco que puede estar compuesta de cero o más ocurrencias y el signo de suma obliga a que al menos este compuesta de una ocurrencia. Por ejemplo: var numeros : Number* = [1,2,3]; //declara la variable "numeros" como un arreglo de 0 o más ocurrencias del tipo Number. Pero, dado que tanto el operador como el valor y el tipo son opcionales, el siguiente código logrará el mismo efecto: var nums = [1,2,3]; Por hoy esto es todo, pero en la próxima entrega veremos el uso de funciones, arreglos, expresiones, operadores y quizás algo de queries para arreglos, dependiendo de la longitud que vaya tomando el/ los articulos a medida que los escriba. Antes de dejarlos, les paso los datos para configurar el uso de la consola con programas JFXS, ya que la misma no viene configurada por defecto en ningún sistema operativo (esto es muy útil para ver el resultado de algunos programas utilizando System.out.println). Nota: deberán importar java.lang.System para hacer uso de la consola. * En Windows XP o Vista, vayan al panel de control, click en el icono de Java, y en el tab "Avanzado", seleccionen "Mostrar consola". * En Solaris, click en el icono Java en el tab de preferencias, y seleccionen "Mostrar consola" en el tab "Avanzado". Si no tienen un icono de Java en las preferencias, ejecuten la aplicación "ControlPanel" (o jcontrol) en el directorio bin de su distribución Java. * En Linux, busquen la aplicación ControlPanel (o jcontrol) dentro del directorio bin de su distribución Java. Ejecútenlo, y luego aparecerá el icono de Java en las preferencias, vayan al tab "Avanzado" y tilden "Mostrar Consola". * En Mac OS X, vayan a Aplications/Utilities/Java/ y ejecuten "preferencias de Java". En el tab "Avanzado", seleccionen "Ver consola". Al parecer, luego de hacer esto en algunos Mac con procesador Intel, puede surgir un error que hace que Java Web Start deje de funcionar. Para Solucionarlo vayan a Library/Caches/Java/deplyment.properties y cambien todos los valores osarch de "i386" (o "X86_64" a "ppc". En mi caso, esto no sucedió y todo funcionó correctamente. Panel de preferencias de Java Finalmente, en el Pad de JavaFX desactiven la opción "Run Automatically" y vacien la consola antes de ejecutar alguna aplicación. Para ejecutar las aplicaciones manualmente, utilicen la opción Run del menú homonimo del Pad. Programa que imprime "pepe" en la consola Java Java FX Script, primeros pasos - Parte 2 Antes de comenzar con esta segunda parte, quiero agradecerle a toda la gente que durante esta semana estuvo dejando comentarios y criticas sobre el curso, tanto en la sección "comentarios" del blog como aquellos que se comunicaron por email. Me alegra saber que hay tanta gente enganchada, ya que, como escribí en los comentarios, nunca pensé que esto (que pretendía ser una introducción a JFX que pasara casi desapercibida) iba a tener el nivel de respuesta que tuvo. Para aquellos que no estuvieron siguiendo los comentarios de la parte 1, les cuento como he decidido que siga esto: primero vamos a terminar de cubrir los aspectos básicos de la versión interpretada de JavaFX Script, para luego marcar las diferencias entre esta y la nueva versión de JFXS, JavaFX Script compilado. Una vez completo esto, vamos a empezar con ejemplos más avanzados. Sin más introducción, retomemos donde habíamos dejado en la parte 1: Nota: al igual que en la parte 1, sólo utilizaremos el pad de JavaFX para los ejemplos de esta parte. Expresiones Esta parte además de aburrida es mera sintaxis, a la que van a tener que recurrir una y otra vez hasta que la memoricen, así que me voy a limitar a copiar la tabla de operadores de la referencia, y a mostrarles un par de ejemplos (aquellos que estén acostumbrados a Java noten especialmente que el operador de "⁞no igualdad" y los booleanos cambian, lo cual puede ser un dolor de cabeza en sus primeros pasos por JFXS): Ejemplos varios: import java.lang.System; import java.lang.Math; var x = 2; var y = 4; var a = true; var b = false; System.out.println(x == y); // imprime false System.out.println(x <> y); // imprime true System.out.println(x < y); // imprime true System.out.println(x > y); // imprime true System.out.println(x >= y); // imprime false System.out.println(x <= y); // imprime true System.out.println(x + y); // imprime 6 System.out.println(x - y); // imprime -2 System.out.println(x * y); // imprime 8 System.out.println(x / y); // imprime 0.5 System.out.println(x % y); // imprime 2 System.out.println(a and b); // imprime false System.out.println(a or b); // imprime true System.out.println(not a); // imprime false System.out.println(sizeof [x,y]); // imprime 2 System.out.println([x,y][indexof . == 0]); // imprime 2 System.out.println(if a then x else y); // imprime 2 System.out.println(select q from q in [x, y] where q > 3); // imprime 4 System.out.println(foreach(q in [x, y] where q < 3) q); // imprime 2 System.out.println(Math.max(x, y)); // imprime 4 System.out.println("abc".toUpperCase()); // imprime ABC System.out.println(x instanceof Number); // imprime true x = 10; System.out.println(x); // imprime 10 Pasada la parte más pesada, volvamos a los mecanismos propios de JFXS: Literales y expresiones con Strings En JavaFX las cadenas de caracteres pueden ser declaradas usando comillas simples o dobles: var s = 'Hola'; var s = "Hola"; Es importante destacar que dentro de estas declaraciones, pueden incluirse referencias a variables (o incluso porciones de código) encerrándolas entre llaves ('{', '}'): var nombre = 'Pepe'; var s = "Hola {nombre}"; // s = 'Hola Pepe' var respuesta = true; var s = "La respuesta es {if respuesta then "Si" else "No"}"; // s = 'La respuesta es Si' A diferencia de Java, en JFXS los Strings declarados con comillas dobles pueden contener saltos de línea: var s = "Esto tiene varias lineas"; Arreglos Una de las estructuras más utilizadas en JFXS son los arreglos, los cuales representan una secuencia de elementos que, al igual que en Java, deben ser del mismo tipo. En este lenguaje, los arreglos poseen muchas funcionalidades, lo cual da lugar a un infinito número de posibilidades al momento de trabajar con ellos. Comencemos por ver como crear una variable de este tipo: var diasLaborales = ["Lun","Mar","Mie","Jue","Vie"]; var dias = [weekdays, ["Sab","Dom"]]; Cómo puede observarse en el ejemplo de arriba, los arreglos se crean utilizando corchetes y comas, y pueden crearse en base a otros arreglos. Sin embargo, es importante saber que los arreglos no son objetos en sí mismos y, además, que las expresiones que producen arreglos anidados (como la declaración de "dias" del ejemplo) son aplanadas automáticamente. Esto último implica que el valor de "dias" será en realidad '["Lun", "Mar", "Mie", "Jue", "Vie", "Sab", "Dom"]' y no '["Lun", "Mar", "Mie", "Jue", "Vie", ["Sab", "Dom"]]' (si bien la diferencia es sutil, puede llevar a errores). Si intentamos imprimir el valor del arreglo con "System.out.println(dias)" sólo veremos el primer elemento del arreglo, para obtener todos los elementos, tendremos que usar un índice. Además, cabe destacar que en JFXS no obtendremos una excepción "ArrayIndexOutOfBoundsException" como en Java al intentar acceder a un índice fuera de rango, en lugar de eso, obtendremos un cero. Para saber el tamaño de un arreglo, podemos usar el operador "sizeof": var n = sizeof dias; // n = 7 Pueden utilizarse dos puntos seguidos '..' para crear arreglos cuyos elementos formas series aritméticas, por ejemplo: var unoACien = [1..100]; var tamanio = sizeof unoACien; // tamanio == 100 var porTres = [1*3, 2*3 .. 10*3]; // [3,6,9,12,15,18,21,24,27,30] tamanio = sizeof porCien; // tamanio == 10 El Operador "[]" En JFXS el operador "[]" se utiliza para expresar una selección utilizando predicados Xquery-Update (similares a los de XPath). Este mecanismo se basa en la utilización de una variable de contexto, con la cual el interprete se encargará de localizar aquellos valores que cumplen con la condición planteada. Es importante destacar que es el valor y no el índice a lo que estaremos haciendo referencia. Para obtener el índice, debemos utilizar el operador "indexof": var nums = [1,2,3,4]; var numsMayoreQueDos = nums[n|n > 2]; // resulta en [3,4] var numsMenosLosDosPrimeros = nums[n|indexof n > 1]; // resulta en [3,4] El significado de la primera expresión es "los n, contenidos en num tal que ('|') n sea mayor a 2" mientras que el de la segunda es "los n tales que el índice de dichos n sea mayor que 1". Nota: En versiones anteriores de JFXS se aceptaba no declarar n y utilizar un punto en lugar de "n|n", por lo que es probable que lo encuentren en algún ejemplo más viejo. Bastará con intercambiar dicho punto por "n|n" para hacer que estos funcionen correctamente. Insertar y Borrar elementos en un arreglo Para realizar inserciones y borrados en los arreglos, se utilizan los operadores "insert" y "delete", los cuales soportan los siguientes modificadores: insert Expression1 [as first | as last] into Expression2: inserta la primera expresión al comienzo o al final de la segunda (la segunda debe ser un atributo o variable). insert Expression1 before Expression2: inserta la primera expresión antes de la segunda (la segunda debe ser una selección sobre un atributo o variable) insert Expression1 after Expression2: inserta la segunda expresión luego de la segunda (la segunda debe ser una selección sobre un atributo o variable) Para mayor claridad, veamos varios ejemplos varios de posibles usos de insert: var x = [1,2,3]; insert 12 into x; // resulta en [1,2,3,12] insert 10 as first into x; // resulta en [10,1,2,3,12] insert [99,100] as last into x; // resulta en [10,1,2,3,12,99,100] var y = [1,2,3]; insert 10 after y[n|n == 3]; // resulta en [1,2,3,10] insert 12 before y[1]; // resulta en [1,12,2,3,10] insert 13 after y[n|n == 2]; // resulta en [1, 12, 2, 13, 3, 10]; El operador "delete" funciona en forma similar, nótese que en caso de no especificar una expresión se borrará todo el arreglo: var x = [1,2,3]; insert 10 into x; // resulta en [1,2,3,10] insert 12 before x[1]; // resulta en [1,12,2,3,10] delete x[n|n == 12]; // resulta en [1,2,3,10] delete x[n|n >= 3]; // resulta en [1,2] insert 5 after x[n|n == 1]; // resulta en [1,5,2]; insert 13 as first into x; // resulta en [13, 1, 5, 2]; delete x; // borra el arreglo resulta en [] Queries en arreglos Además de estas operaciones, pueden realizarse Consultas (mejor conocidas como Queries) más complejas sobre los arreglos utilizando el mecanismo llamado "List Compehensions" a través de los operadores "select" y "foreach". Algunos ejemplos a continuación: var a:Integer* = select n*n from n in [1..10]; // resulta en [1,4,9,16,25,36,49,64,81,100] Lo que estamos diciendo es algo así como: "recorré los números de 1 a 10, asignando el número de turno a la variable 'n', elevalo al cuadrado y agregalo al arreglo 'a'". Pueden agregarse filtros utilizando el operador "where": var a:Integer* = select n*n from n in [1..10] where (n%2 == 0); // resulta en [4,16,36,64,100] Aquí estariamos diciendo: "recorré los numeros de 1 a 10, y asigná el número de turno a la variable 'n' sólo si es par, elevalo al cuadrado y agregalo al arreglo 'a'". Podemos realizar bucles sobre más de una variable resultando en, por ejemplo, el siguiente producto cartesiano: var a:Integer* = select n*m from n in [1..4], m in [100,200] where (n%2 == 0); // resulta en [200, 400, 400, 800] Aquí, decimos "recorré los números de 1 a 4, asigna el número a 'n' si es par, luego por cada n recorré el arreglo que contiene 100 y 200, asigná el elemento de turno a la variable 'm' y multiplicalo por n y agregalo al arreglo 'a'". Podríamos completarlo aún más agregando finalmente una condición sobre el segundo arreglo: var a:Integer* = select n*m from n in [1..4], m in [100,200] where (n%2 == 0) and (m==100); // resulta en [200, 400] Utilizando el operador "foreach", se pueden obtener los mismos resultados: var a:Integer* = foreach(n in [1..4], m in [100,200] where (n%2 == 0) ) n*m; // resulta en [200, 400, 400, 800] Formateado Finalmente, para cerrar esta parte veremos el operador "format as" que permite (como su nombre lo indica) dar formatos especificos a ciertos valores permitiendo, por ejemplo, su homogeneidad a la hora de almacenarlos, imprimirlos, etc. Para empezar, la sintaxis de format as es: expresión format as directiva En donde la directiva indica cual es la clase que se utilizará para dar el formato. Más especificamente, si la directiva comienza con '%' se utilizará la clase java.util.Formatter, en caso contrario si la expresión es de tipo Number se utilizará java.util.DecimalFormat, sino, si la expresión es de tipo Date se utilizará java.text.SimpleDataFormat. Algunos ejemplos: import java.util.Date; 100.896 format as <<%f>>; // resulta en '100.896000' 31.intValue() format as <<%02X>>; // resulta en '1F' var d = new Date(); d format as <<yyyy-MM-dd'T'HH:mm:ss.SSSZ>>; // resulta en '2005-10-31T08:04:31.323-0800' 0.00123 format as <<00.###E0>>; // resulta en '12.3E-4' El uso de las comillas francesas ('<<' y '>>') hace que JavaFX reconozca cualquier secuencia de caracteres encerrada en estas como un identificador (incluso los espacios en blanco). Esto permite utilizar las palabras reservadas de JFXS u otros identificadores ilegales como nombres de variables, clases, atributos o funciones. Lo que es más importante, permite llamar a métodos Java que poseen nombres de palabras reservadas en JavaFX, por ejemplo: import javax.swing.JTextArea; var textArea = new JTextArea(); textArea.<<insert>>("Hello", 0); Hasta aquí llegamos hoy. Del contenido básico sólo queda por cubrir: funciones, clases, sentencias de control y triggers (y algún que otro detalle), con lo cual es muy posible que quede completo con la próxima clase, que posiblemente esté publicando a mitad de la semana próxima. Hasta entonces, una buena practica puede ser la de comenzar a probar estos ejemplos, y modificarlos para ver toda la gama de posibilidades que provee JavaFX Script y, de paso, irse acostumbrando a la sintaxis del lenguaje. Java FX Script, primeros pasos - Parte 3 Antes que nada, pido perdón por no respetar la frecuencia de publicación que prometí, pero esta semana tuve un problema familiar y se me atrasó todo el trabajo. Sin más excusas, ahora si, la última entrega de la "referencia" de JavaFX script. En la primera y la segunda entrega en conjunto, ya conocimos: * Las características y el propósito de este lenguaje. * Los tipos primitivos * Declaración de variables * Expresiones * Manejo de cadenas de caracteres * Arreglos * El operador de selección * Queries sobre arreglos * Formateo de cadenas de caracteres En esta entrega, terminaremos entonces de cubrir los tópicos de la referencia oficial de JFX Script, comenzando por la declaración de clases: En JavaFX, la declaración de clases consiste en colocar la palabra reservada "class" seguida del nombre que deseamos darle. Finalmente, se coloca la lista de atributos, operaciones y funciones entre llaves, separadas por punto y coma. Si nuestra clase hereda funcionalidad de una o más clases, se coloca luego de su nombre la palabra reservada "extends", seguida de la lista de clases "padre" separadas por comas (a diferencia de Java, en JFXS sí existe la herencia múltiple): class Persona { attribute nombre: String; attribute padre: Persona inverse Person.hijos; attribute hijos: Persona* inverse Person.padre; function obtenerIngresosFamiliares(): Number; function obtenerCantidadDeHijos(): Number; operation casarseCon(pareja: Persona): Boolean; } Atributos, funciones y operaciones: En JavaFX un atributo se declara utilizando la palabra reservada "attribute" seguida del nombre deseado y, opcionalmente, el tipo, la cardinalidad ('?', '*' o '+') y una clausula "inverse" continuación. Declarar un atributo como "inverse" de otro implica que el interprete de JFXS realizará actualizaciones (inserción, borrado o reemplazo) en el atributo inverso ante una modificación en el atributo original. Los atributos multivaluados (es decir, los declarados con '*' o '+') son tratados como arreglos y, por ende, puede accederse a la información contenida en los mismos utilizando el operador de selección ("[]". La contraparte en JavaFX de los métodos en Java son las funciones y operaciones. Las primeras representan un subconjunto puramente funcional del lenguaje, se declaran utilizando la palabra reservada "function" y solo pueden contener declaraciones de variables y una sentencia de retorno. Son especialmente útiles para realizar operaciones matemáticas sencillas, por ejemplo: function z(a,b) { var x = a + b; var y = a - b; return sq(x) / sq (y); } function sq(n) {return n * n; } Las operaciones, por su parte, pueden contener cualquier cantidad de sentencias de control: condicionales, bucles, try and catch, etc Es decir, son bastante más similares a un método Java tradicional que las funciones. Se declaran utilizando la palabra clave "operation" y, además del nombre, debe colocarse la lista de parámetros entre paréntesis y el tipo de retorno deseado utilizando ": tipo de retorno", por ejemplo: operation substring(s:String, n:Number): String { try { return s.substring(n); } catch (e:StringIndexOutOfBoundsException) { throw "indice fuera de rango"; } } A diferencia de los métodos Java, en JFX el cuerpo de las funciones y operaciones debe definirse fuera de la clase: function Persona.obtenerCantidadDeHijos() { return sizeof this.hijos; } Así mismo, si deseamos darle valores iniciales a los atributos, debemos hacerlo fuera de la definición de la clase: import java.lang.System; class X { attribute a: Number; attribute b: Number; } attribute X.a = 10; attribute X.b = -1; var x = new ); System.out.println(x.a); // imprime 10 System.out.println(x.b); // imprime -1 Una vez definida nuestra clase, lo lógico es que creemos una o más instancias de la misma, para hacer esto JFXS soporta dos mecanismos: el primero, la sintaxis clásica de Java y, el segundo, la sintaxis declarativa propia de este lenguaje. La sintaxis clásica de Java consiste en realizar una llamada al constructor de la clase, pasando los valores de los atributos en el orden en que fueron declarados. La sintaxis declarativa consiste en: abrir llaves, para cada atributo colocar el nombre, dos puntos y el valor pretendido y finalizar cerrando llaves. Veamos un ejemplo utilizando la clase "Date" de Java: import java.util.Date; import java.lang.System; var date1 = new Date(95, 4, 23); // llamada a un constructor Java var date2 = Date { // creación de un "object literal" usando sintaxis declarativa month: 4 date: 23 year: 95 }; Triggers A diferencia de Java, las clases en JFXS no poseen constructores y, en general no se utilizan "setters" para los atributos. En vez de eso, el lenguaje provee un conjunto de triggers (similares a los de SQL) que permiten la manipulación de estos datos. En pocas palabras un trigger (que en castellano vendría siendo algo como "gatillo" es un conjunto de instrucciones que se programan para "dispararse" en respuesta a un evento dado. Es decir, la ocurrencia del evento presiona el gatillo que inicia la ejecución de las instrucciones. En JFXS pueden programarse triggers que respondan a eventos de creación de objetos, inserción, reemplazo y borrado de valores de atributos multivaluados. Triggers de creación de objetos los triggers de este tipo responden ante la creación de un objeto del tipo declarado en la sentencia "on new nombreDeLaClase". Por ejemplo: import java.lang.System; class X { attribute nums: Number*; } trigger on new X { insert [3,4] into this.nums; } var x = new ); System.out.println(x.nums == [3,4]); // imprime true Este trigger inserta los elementos 3 y 4 dentro del atributo multivaluado "numbs" de cada instancia de la clase X, al momento de su creación. Nótese la utilización de la palabra reservada "this" para indicar que nos referimos a la instancia actual. Triggers de inserción Un trigger de este tipo se disparará al momento de realizar una inserción en un atributo multivaluado. Por ejemplo: import java.lang.System; class X { attribute nums: Number*; } trigger on insert num into X.nums { System.out.println("acaba de insertar {num} en X.nums en la posición {indexof num}"; } var x = new ); insert 12 into x.nums; // imprime "acaba de insertar 12 en X.nums en la posición 0" insert 13 into x.nums; // imprime "acaba de insertar 13 en X.nums en la posición 1" Nótese el uso del mecanismo de inserción de inclusión de referencias a variables encerrándolas entre llaves, así como el uso de la instrucción "indexof ". Triggers de borrado Complementariamente a los triggers de inserción, existen los triggers que se disparan al borrarse un elemento de un atributo multivaluado: import java.lang.System; class X { attribute nums: Number*; } trigger on delete num from X.nums { System.out.println("acaba de borrar {num} de X.nums en la posición {indexof num}"; } var x = X { nums: [12, 13] }; delete x.nums[1]; // imprime "acaba de borrar 13 de X.nums en la posición 1" delete x.nums[0]; // imprime "acaba de borrar 13 de X.nums en la posición 0" Nota: "num" es sólo un nombre elegido al azar, la referencia a la variable que será insertada (o borrada) puede tomar cualquier nombre. Triggers de reemplazo Estos triggers se disparan al reemplazar el valor de un atributo por uno nuevo. En el ejemplo, "valorViejo" y "valorNuevo" son nombres elegidos al azar para las variables que tomaran los valores respectivos del elemento actual. Al igual que el nombre "num" de los ejemplos anteriores, estos nombres pueden ser cambiados a voluntad. import java.lang.System; class X { attribute nums: Number*; attribute num: Number?; } trigger on X.nums = valorNuevo { System.out.println("X.nums: se reemplazo {valorViejo} con {valorNuevo} en la posición {indexof valorNuevo}"; } trigger on X.num = valorNuevo { System.out.println("X.num: se reemplazo {valorViejo} con {valorNuevo}"; } var x = X { nums: [12, 13] num: 100 }; x.nums[1] = 5; // imprime "X.nums: se reemplazo 13 con 5 en la posición 1" x.num = 3; // imprime"X.num: se reemplazo 100 con 3" x.num = null; // "X.num: se reemplazo 3 con null" Sentencias JFXS soporta versiones similares de aquellas de Java. A saber: if/ else: igual a la de Java, solo que requiere el uso obligatorio de llaves: if (condition1) { System.out.println("Condition 1"; } else if (condition2) { System.out.println("Condition2"; } else { System.out.println("not Condition 1 or Condition 2"; } while: igual a la de Java, también requiere del uso de llaves obligatorio: var i = 0; while (i < 10) { if (i > 5) { break; } System.out.println("i = {i}"; i += 1; } try, catch y throw: iguales a las de Java, pero con la declaración de variables propia de JFXS. Es importante notar que en JFXS cualquier objeto puede ser "arrojado" y/o "atrapado", no sólo aquellos que extienden "java.lang.Throwable" try { throw "Hola"; } catch (s:String) { System.out.println("atrape un String: {s}"; } catch (any) { System.out.println("atrape algo que no es un Sting: {any}";⁞ } finally { System.out.println("finally..."; } for: en JFXS, la sentencia for utiliza la misma sintaxis que "foreach" (una de las "list comprehensions" que vimos en la segunda parte del curso): for (i in [0..10]) { System.out.println("i = {i}";⁞ } // imprime solo los números pares for (i in [0..10] where (i%2 == 0) ) { System.out.println("i = {i}"; } // imprime solo los números impares utilizando un rango for (i in [1,3..10]) { System.out.println("i = {i}"; } // imprime el producto cartesiano for (i in [0..10], j in [0..10]) { System.out.println(i); System.out.println(j); } return: identica a la de java: operation add(x, y) { return x + y; } break y continue: identicas a sus pares Java, solo que en JFXS no soportan el uso de etiquetas. Deben aparecer dentro de un bucle for o while: operation foo() { for (i in [0..10]) { if (i > 5) { break; } if (i % 2 == 0) { continue; } System.out.println(i); } } operation bar() { var i = 0; while (i < 10) { if (i > 5) { break; } if (i % 2 == 0) { continue; } System.out.println(i); i += 1; } } do y do later: Permite ejecutar un bloque de código JFX en un hilo en segundo plano. Normalmente, todo el código JFX se ejecuta en un único hilo (en particular en el hilo AWT Event Dispatch), unicamente el código contenido dentro de una sentencia "do" puede ejecutarse en otro hilo: import java.net.URL; import java.lang.StringBuffer; import java.lang.System; import java.io.InputStreamReader; import java.io.BufferedReader; // En el hilo AWT Event Dispatch var result = new StringBuffer(); do { // En un nuevo hilo en segundo plano var url = new URL("http://www.foo.com/abc.xml"; var is = url.openStream(); var reader = new BufferedReader(new InputStreamReader(is)); var line; while (true) { line = reader.readLine(); if (line == null) { break; } result.append(line); result.append("\n"; } } // Nuevamente en el hilo AWT Event Dispatch System.out.println("result = {result}"; El ejemplo anterior vemos como es posible mandar operaciones a segundo plano mientras continuamos con la ejecución de nuestra aplicación. En general esto es muy útil para no interrumpir la ejecución de las instrucciones propias de la interfaz gráfica, rompiendo así con la fluidez de la aplicación. Sin embargo, el código dentro de una sentencia "do" sólo puede acceder a objetos Java que, de ser necesario, deberán hacerse cargo de su sincronización. La sentencia "do later", en cambio, permite una ejecución asincronica del código que envuelve dentro del hilo AWD, en vez de una ejecución sincronica fuera del mismo (como lo hace "do": import java.lang.System; var saying1 = "Hola Mundo"; var saying2 = "Adios Mundo Cruel"; do later { System.out.println(saying1); } System.out.println(saying2); //imprime: Adios Mundo Cruel Hola Mundo Evaluación incremental Finalmente, la cereza de la torta: el mecanismo de evaluación incremental de JFXS. Este mecanismo permite que el valor de dos atributos se vincule utilizando la instrucción "bind", creando así en una especie de "Observer - Observable" entre ellos. De esta forma, el valor de un atributo cambiará cuando el atributo vinculado a este lo haga. Utilizando este mecanismo es posible encadenar los vínculos para generar interfaces gráficas que respondan en formas complejas a distintos eventos. Veamos un ejemplo sencillo: import java.lang.System; class X { attribute a: Number; attribute b: Number; } var x1 = X { a: 1 b: 2 }; var x2 = X { a: x1.a // no incremental b: bind x1.b // incremental }; System.out.println(x2.a); // imprime 1 System.out.println(x2.b); // imprime 2 x1.a = 5; x1.b = 5; System.out.println(x2.a); // imprime 1 System.out.println(x2.b); // imprime 5 Es fácil ver que el vinculo se da entre X1.b y X2.b, nótese que cuando el primero se actualiza, el segundo lo hace también. En el caso de las funciones, los valores que se modifican dentro de las mismas son evaluados incrementalmente (es decir, si estaban vinculados, los vínculos tendrán efecto). Por el contrario, dentro de las operaciones los valores no son evaluados incrementalmente. Otra versión de la evaluación incremental es la "perezosa" (lazy). En concordancia con su nombre, esta evaluación espera que el valor sea sometido a una lectura para verificar si debe actualizarse. Es común el uso de este mecanismo para manipular estructuras recursivas de datos. Modificando el ejemplo anterior podemos ver la evaluación perezosa en acción: import java.lang.System; class X { attribute a: Number; } var x1 = X { a: 1 }; var x2 = X { a: bind lazy x1.a // aún no se asignará ningún valor }; System.out.println(x2.a); // al leerlo, el valor se actualiza, e imprime 1 Java FX Script, primeros pasos - Parte 4 Cuando Sun presentó JavaFX en JavaOne 2007, JFX Script era aún un lenguaje interpretado. Sin embargo, desde un primer momento se aclaró que esto era sólo temporal, mientras el lenguaje pasaba de ser el resultado de la investigación personal (F3, de Chris Oliver) a un producto a ser introducido en el mercado. Es así como, después de un lapso de tiempo, JFX Script pasó de ser un lenguaje interpretado, a un lenguaje compilado, principalmente porque uno de las características principales que Sun pretende para las aplicaciones escritas en este lenguaje es un nivel de performance mayor que aquellas escritas en Javascript o ActionScript (de hecho, en los benchmarks realizados por Chris Oliver, el rendimiento de JFX Script fue 12 veces mayor que el de ActionScript. Al cambio de categoría del lenguaje se sumaron algunos cambios en la sintaxis, los cuales revisaremos hoy, siguiendo la guia de migración de Planet JFX (simplemente porque fue una de las más completas que conseguí), como para dar por terminada esta parte, y comenzar luego con ejemplos algo más complejos y aggiornados. Operaciones Antes: el lenguaje diferenciaba entre funciones y operaciones. class Foo { function times2(x) { return x * 2; } operation print(s) { System.out.println(s); } } Ahora: La sintaxis actual fusiona los dos conceptos en uno único: el de función, y utiliza la palabra reservada "function" para declararlas. Es decir, el único cambio que debemos realizar es el de renombrar las operaciones a funciones. class Foo { function times2(x) { return x * 2; } function print(s) { System.out.println(s); } } Inicialización de atributos Antes: los valores iniciales de los atributos debían declararse fuera del cuerpo de la clase. class Foo { attribute bar: Boolean; } attribute Foo.bar = true; Ahora: esto se hace igual que en Java, es decir, dentro de la clase. class Foo { attribute bar: Boolean = true; } Triggers de reemplazo Antes: los triggers de reemplazo se definían fuera de la clase, utilizando la sintaxis "trigger on atributo = valor" Sin inicialización: class Foo { attribute bar: Boolean; } trigger on Foo.bar = value { if (bar == true) { beep(); } } Con inicialización: class Foo { attribute bar: Boolean = true; } trigger on Foo.bar = value { if (bar == true) { beep(); } } Ahora: se definen dentro de la clase, como parte de la declaración del atributo, utilizando la sintaxis "on replace" Sin inicialización: class Foo { attribute bar: Boolean on replace { if (bar == true) { beep(); } }; } Con inicialización: class Foo { attribute bar: Boolean = true on replace { if (bar == true) { beep(); } }; } Cardinalidad Antes: el operador de cardinalidad era el asterisco ('*'). class Foo { attribute names :String*; } attribute names = ["Monica", "Rachel", "Phoebe"]; Ahora: se utilizan en lugar del asterisco, los corchetes ("[]". class Foo { attribute names :String[] = ["Monica", "Rachel", "Phoebe"]; } Literales objeto sin atributos Antes: podíamos referirnos a literales objeto sin atributos utilizando solo el nombre de su clase. Frame { title: "Show MenuSeparator" height: 180 width: 320 menubar: MenuBar { menus: Menu { text: "File" items: [MenuItem { text: "New" }, MenuItem { text: "Open" }, MenuItem { text: "Save" }, MenuSeparator, MenuItem { text: "Import" }] } } visible: true } Ahora: adicionalmente, debemos utilizar llaves ("{}". Frame { title: "Show MenuSeparator" height: 180 width: 320 menubar: MenuBar { menus: Menu { text: "File" items: [MenuItem { text: "New" }, MenuItem { text: "Open" }, MenuItem { text: "Save" }, MenuSeparator { }, MenuItem { text: "Import" }] } } visible: true } Instancias con nombre Antes: era posible utilizar algunas instancias con nombre, que representaban constantes predefinidas. Frame { title: "White Frame" background: white ... } Ahora: es necesario utilizar las constantes predefinidas, o literales objeto. Frame { title: "White Frame" background: Color.WHITE ... } O también: Frame { title: "White Frame" background: Color { red: 1 green: 1 blue: 1 opacity: 1 } ... } Literales objeto anónimo Antes: podíamos utilizar literales anónimos y dejar que el interprete infiriese el tipo de ese bloque de código. ... accelerator: { modifier: CTRL keyStroke: O } .... Ahora: ante la ausencia de interprete, es obligatorio declarar el tipo de cada bloque. ... accelerator: Accelerator { modifier: KeyModifier.CTRL keyStroke: KeyStroke.O } ... Sobreescribir funciones Antes: podíamos sobreescribir funciones sin necesidad de colocar el tipo de retorno en la declaración de las mismas. class MyWidget extends CompositeNode { ... function composeNode() { ... } } Ahora: es obligatorio escribirlo. class MyWidget extends CompositeNode { ... function composeNode() :Node { ... } } Binding bidireccional Antes: bastaba con colocar la palabra reservada "bind". ... TextField { value: bind model.firstName } ... Ahora: la sintaxis de JFX Script compilado requiere del uso de la clausula "with inverse". ... TextField { value: bind model.firstName with inverse } ... Casting de Number a Integer Antes: el casting era automático. ... var real :Number; num = 6.42; var integer :Integer; integer = real; ... Ahora: para evitar perdida de precisión en la compilación, debe utilizarse la función "intValue". ... var real :Number; num = 6.42; var integer :Integer = real.intValue(); ... Herencia Al menos hasta la versión del compilador de JavaFX de marzo de 2008, puede que sea necesario utilizar la palabra reservada "as" para evitar algunos problemas de herencia. Es decir, lo que antes hubiesemos hecho de esta forma: class Foo extends Rectangle { ... } ... ... content: Canvas { content: Foo { ... } ... } ... } Ahora debemos hacerlo así: class Foo extends Rectangle { ... } var foo oo = Foo { ... }; ... content: Canvas { content: foo as Node ... } ... } Bucles Antes: existían dos bucles, "for" y "foreach". ... for (Integer i = 0; i < element.length; i++) { System.out.println(element); } ... foreach (element in group) { System.out.println(element); } ... Ahora: al igual que con las funciones y operaciones, estos dos conceptos se fusionaron en uno solo que utiliza la palabra reservada "for" en su declaración. Este puede ser utilizado tanto como el "for" de Java así como el "foreach" de JFX Script. ... for (Integer i = 0; i < element.length; i++) { System.out.println({element}); } ... for (element in group where element.length() < 4) { System.out.println({element}); } ... Java FX Script, primeros pasos - Parte 5- El mas interesante Hoy finalmente vamos a comenzar a trabajar en algunos proyectos algo más entretenidos que aquellos de la referencia. Además vamos a dejar de lado el pad de JavaFX y comenzaremos a usar un ambiente de desarrollo integrado, que nos dará la posibilidad de administrar nuestros proyectos de una forma más amigable, nos permitirá arrastrar y soltar componentes en nuestros scripts y resaltará la sintaxis del lenguaje aumentando la claridad y la legibilidad del código. Utilizaremos el IDE NetBeans 6.1 (Nota: el plug-in aún no funciona con la beta 6.5), un ambiente de desarrollo modular, multiplataforma, gratuito y libre (GPL v2 y CDDL), el cual pueden obtener aquí. Además, necesitaremos Java SE Update 7 o mayor, que puede descargarse aquí. El ejemplo que realizaremos está tomado de javapassion, pueden encontrar la versión original aquí. Paso 1: instalar el plugin de JavaFX en NetBeans Empezaremos entonces por instalar el plugin de JavaFX en NetBeans, lo cual ampliará la funcionalidad original del IDE, agregando las funciones necesarias para desarrollar proyectos en el lenguaje JavaFX Script (si no poseemos NetBeans, podemos bajar una versión que incluye JavaFX aquí). Nota: para usar el update center de NetBeans, es necesario poseer una conexión a Internet. 1.1 - Abrir el update center. Abrimos NetBeans, vamos al menú herramientas, lo desplegamos y seleccionamos la opción "plugins". 1.2 - Obtener los plug-ins de interés. Dentro de la ventana "plugins" seleccionamos la pestaña "plugins disponibles", y buscamos aquellos que poseen la palabra "javafx" en su nombre. Seleccionamos los tres que el IDE encuentra ("JavaFX Wheater Sample" no es estrictamente necesario, pero es un ejemplo muy completo para observar y aprender algunas cosas) y procedemos a instalarlos. Finalmente reiniciamos el IDE para culminar la instalación. Paso 2: construir la aplicación "Hola Mundo" 2.1 - Crear un nuevo proyecto JavaFX. Para esto, vamos al menú "archivo" y seleccionamos la opción "nuevo proyecto". Dentro de la ventana correspondiente, seleccionamos "JavaFX" en la columna correspondiente a la categoría y "aplicación JavaFX script" en la columna "proyectos", a continuación, hacemos click en siguiente y completamos los datos del proyecto colocando como nombre del mismo "JavaFXHolaMundo" y dejando las otras opciones con sus valores por defecto. Finalmente, hacemos click en "finalizar", y dejamos que el IDE prepare nuestro ambiente de trabajo. 2.2 - Agregar un frame para alojar todos nuestros elementos. Esto podemos hacerlo arrastrando desde la paleta al código (donde dice "//place your code here" el elemento Frame, o escribiendo a mano la descripción del literal y sus propiedades (fijense que el caret les indica donde quedará el código una vez que suelten el botón del mouse). Dentro del código agregado podemos observar las propiedades titulo (title), ancho (width), alto (height), si es visible o no y la acción a realizar cuando el frame se cierre ("closeAction", en este caso, una llamada al método estático "close" de la clase "System", que hará que el programa finalice su ejecución). 2.3 - Modificar las propiedades del frame. Colocamos el valor de la propiedad height en 100, el de width en 400, y el titulo del frame lo cambiamos por "HolaMundoJavaFX". 2.4 - Construir y ejecutar el proyecto. Sencillo, simplemente hacemos click en el botón correspondiente, o podemos hacer click derecho sobre el proyecto y seleccionar la opción "ejecutar" del menú despegable. Nota: en la versión del plug-in para algunos sistemas operativos se encuentra disponible una característica llamada "preview" que nos permite previsualizar el resultado de los cambios que vayamos realizando en nuestro código. Para activarla solo deben hacer click en el icono correspondiente, que se encuentra en el extremo izquierdo de la barra de acciones justo encima del editor. Paso 3: agregar una etiqueta de texto a nuestro frame 3.1 - Agregar la etiqueta. Para esto, arrastramos el componente "text" desde la paleta hacia nuestro código, específicamente dentro de los contents del "stage" del frame. 3.2 - Editar el contenido del texto y su tamaño. Cambiamos el valor de la propiedad "content" por "Hola Mundo", y el de la propiedad "size" de la fuente por 24. 3.3 - Cambiar el color de relleno. Agregamos la propiedad "fill" con el valor "color.BLUE" en el componente "text". Necesitaran además agregar el "import" correspondiente para "Color", el mismo es "import javafx.scene.paint.Color". Nota: para ver una lista de propiedades de este y todos los componentes en el API de JavaFX, hacemos click en la opción "ayuda" de la barra de menús, expandimos la opción "referencias javadoc" y, seleccionamos la opción "documentación JavaFX Script". Luego vamos a la página correspondiente al API de JavaFX Script y buscamos los componentes y propiedades que nos interesen. Paso 4: Agregar un circulo al frame 4.1 - Preparar el terreno. Primero, agregamos una coma luego de la descripción del "text" en el "stage" (entre la llave y el corchete), en pos de separar las descripciones de los distintos componentes. 4.2 - Agregar el circulo. Ahora, arrastramos el componente "circle" desde el panel, y lo ubicamos luego de la coma que acabamos de colocar. 4.3 - Ubicar el circulo y ajustar sus propiedades. Damos a la propiedad "CenterX" (coordenada X del centro) el valor 200, a "CenterY" (coordenada Y del centro) y a "radius" (radio) el valor 30, y a "fill" (relleno), "Color.PINK". Paso 5: agregar un efecto al circulo 5.1 - Agregar el efecto lighting. Para agregar este efecto al circulo, debemos añadir la propiedad "effect" y darle el valor "lighting". La luz de este efecto la describiremos como de tipo "DistantLight", y al acimut (el ángulo de incidencia de la luz en el plano XY - experimenten cambiándole los valores para ver cual es el efecto que genera) de esta luz le daremos el valor 60. Además debemos agregarle 2 imports al código, que debería quedar de la siguiente forma (en negrita el código que tendríamos que agregar): package javafxholamundo; import javafx.application.Frame; import javafx.application.Stage; import javafx.scene.text.Text; import javafx.scene.Font; import javafx.scene.FontStyle; import javafx.scene.geometry.Circle; import javafx.scene.paint.Color; import javafx.scene.effect.Lighting; import javafx.scene.effect.light.DistantLight; import javafx.input.MouseEvent; /** * @author ezequiel */ // place your code here Frame { title: "JavaFXHolaMundo" width: 400 height: 100 closeAction: function() { java.lang.System.exit( 0 ); } visible: true stage: Stage { content: [Text { font: Font { size: 24 style: FontStyle.PLAIN } fill: Color.BLUE x: 10, y: 30 content: "HelloWorld" },Circle { centerX: 200, centerY: 30 radius: 30 fill: Color.PINK effect: Lighting { light: DistantLight { azimuth: 60 } } }] } } 5.2 - Hacer que la iluminación se encienda y apague al hacer click en el circulo. Para hacer esto, agregamos un efecto "onMousePressed" arrastrando y soltando el mismo debajo de la última propiedad del circulo. Adicionalmente, para agregar el comportamiento deseado, agregamos el siguiente código (bastante sencillo de comprender): package javafxholamundo; import javafx.application.Frame; import javafx.application.Stage; import javafx.scene.text.Text; import javafx.scene.Font; import javafx.scene.FontStyle; import javafx.scene.geometry.Circle; import javafx.scene.paint.Color; import javafx.scene.effect.Lighting; import javafx.scene.effect.light.DistantLight; import javafx.input.MouseEvent; /** * @author ezequiel */ // place your code here Frame { title: "JavaFXHolaMundo" width: 400 height: 100 closeAction: function() { java.lang.System.exit( 0 ); } visible: true var counter: Integer=0 stage: Stage { content: [Text { font: Font { size: 24 style: FontStyle.PLAIN } fill: Color.BLUE x: 10, y: 30 content: "HelloWorld" },Circle { centerX: 200, centerY: 30 radius: 30 fill: Color.PINK effect: Lighting { light: DistantLight { azimuth: 60 } } onMousePressed: function( e: MouseEvent ):Void { if (counter mod 2 == 0) { e.node.effect = null } else { e.node.effect = Lighting { light: DistantLight { azimuth: 60 } } } counter++ } }] } } Espero que les sea de utilidad, yo por mi parte no he tenido el tiempo de leerloa todo pero por las charlas que he visto del tema me parece que esta muy bueno ... Saludos. Fuente : http://blogs.sun.com/Argentina_ambassador/

Finalmente, JavaFX está entre nosotros Finalmente ya se a lanzado JavaFX 1.0. Simplemente quiero comentarles ya está online el sitio rediseñado de JavaFX, que incluye tutoriales y links para descargar la nueva versión del SDK, así como la nueva versión del plugin para NetBeans 6.5 y el Production Suite, que incluye herramientas y plugins que permiten exportar gráficos creados en herramientas como Photoshop o Illustrator al formato de JavaFX. fuente : http://blogs.sun.com/Argentina_ambassador/entry/finalmente_javafx_est%C3%A1_entre_nosotros Post Relacionados al tema -> http://taringa.net/posts/info/1832348/Todo-lo-que-tenes-que-saber-de-JavaFX.html

El Fundador de la Cruz Roja Henry Dunant nació el día 8 de mayo de 1828 en Ginebra, Suiza. Fue el primero de cinco hijos de una familia rica y considerada de profundas convicciones cristianas. En 1853 comenzó a trabajar en un banco. Estaba convencido de que tenía el deber religioso de usar su capacidad para triunfar en los negocios y así poder usar ese talento y riqueza en favor de los necesitados. Participó activamente en la fundación de la Alianza Mundial de Asociaciones Cristianas de Jóvenes (Y.M.C.A. por sus siglas en inglés) que se había creado en Londres. En 1855, sugirió fundar una Asociación Mundial de la Alianza Universal de las Uniones Cristianas de Jóvenes, cuyos delegados se reunirían, cada año, en otro país de acuerdo a un turno establecido. De esta suerte, la primera de dichas conferencias tuvo lugar en París en agosto de 1855. Dunant aportó una contribución valiosa para que la Y.M.C.A. se convirtiera en el poderoso movimiento mundial que es hoy. Además, fue el principal autor de la carta de la Y.M.C.A. Dunant se horrorizó al ver lo inadecuado de los servicios sanitarios militares y la agonía que sufrían los heridos durante la batalla de Solferino (Italia) que enfrentaba a Franceses y Austríacos. Después de numerosas gestiones logró en 1864, en Ginebra, Suiza, sentar las bases de la Cruz Roja junto con los representantes de 17 países. Esta entidad de auxilio para los heridos de guerra, sin distinción de nacionalidades, adoptó los colores de la bandera suiza pero invertidos: una cruz roja sobre un fondo blanco. Sus esfuerzos ayudaron a crear la Conferencia de Ginebra (1863) y después la Convención de Ginebra (1864). En 1901 compartió el primer Premio Nobel de la Paz. Así relataron José Luis Santana Gómez y José Luis Peraza Fernández la vida de Dunant y el origen de la Cruz Roja Internacional Anochecía, los soldados heridos trataban desesperados de respirar el aire viciado por el calor tórrido y el polvo, con voces cada vez más débiles imploraban auxilio. Al lado de algunos heridos, militares amigos se habían arrodillado, pero era muy poca la ayuda que les podían prestar para aliviar sus sufrimientos, pues carecían de medicamentos, víveres y agua. Sólo podían estrechar las manos de los moribundos entre las suyas y consolar los lo mejor posible. Era el 24 de junio de 1859, los ejércitos del imperio austríaco y de la alianza francosarda acababan de librar una batalla, en Solferino, un pueblo al norte de Italia, donde participaron 300000 soldados y resultaron muertos o heridos 40 000 de ellos. La carnicería había durado 16 horas. Tales desgracias eran normales, después de una horrible matanza en una batalla anterior, un general famoso, encogiéndose de hombros, dijo lleno de resignación: "No se hacen tortillas sin romper huevos". Pero en Solferino estuvo presente un civil, un comerciante que había ido a Italia en viaje de negocios. Lo que presenció en Solferino cambió su vida y la de millones de personas. Del horror que produjo en él, ese espectáculo de caos y dolor, surgiría más tarde el movimiento de la Cruz Roja y de la Media Luna Roja. Su nombre era Henry Dunant. Dunant nació en Suiza, en la ciudad de Ginebra, el 8 de mayo de 1828 en el seno de una familia religiosa y que se dedicaba más a realizar obras caritativas que a acumular riquezas. A los 18 años, Dunant ya era hombre serio y ferviente devoto. Su entregada vida y su cristiana compasión por los menesterosos lo llevó a ingresar en la "Liga de las Almas", cuyos miembros se dedicaban a socorrer espiritual y materialmente a los pobres y enfermos de Ginebra. Luego de presenciar la batalla de Solferino y de brindar su ayuda durante varios días a los heridos en combate, la idea de que tanta desgracia se podía evitar, no se apartaba de la mente de Dunant y llegó a la conclusión de que la única forma de estar en paz consigo mismo era escribir sobre el horror del que había sido testigo. Escribió un libro: Recuerdo de Solferino. No sólo se limitó a narrar los hechos sino que demostró que la mayor parte del sufrimiento hubiera podido evitarse sin dificultad. En ese libro, Dunant formula una pregunta esencial: ¿No se podrían fundar en tiempo de paz sociedades voluntarias de socorro compuestas de abnegados voluntarios altamente calificados cuya finalidad sea prestar o hacer que se preste, en tiempo de guerra, asistencia a los heridos? (Brown P. Henry Dunant: Fundador de la Cruz Roja. Ginebra: Federación Internacional de Sociedades de la Cruz Roja y Media Luna Roja, 1989). Dunant corrió con los gastos de la primera impresión de Recuerdo de Solferino y en noviembre de 1862 apareció la primera edición. La reacción que provocó el libro fue impresionante. El éxito arrollador de la obra dejó anonadado a Dunant. Recuerdo de Solferino fue la chispa que encendió la llamarada de entusiasmo y los esfuerzos que conducirían a la fundación de la Cruz Roja. El 23 de octubre de 1863, se reunió la primera conferencia de Ginebra, el propio Dunant quedó impresionado por la numerosa asistencia. A pesar de cierta resistencia, Dunant ganó la partida de la neutralidad de los servicios sanitarios y se adoptó la recomendación de que fueran reconocidos como neutrales las ambulancias, los médicos y sus asistentes, así como los habitantes del país que prestaran socorro a los heridos. Todos los países adoptarían un emblema universal, una cruz roja sobre fondo blanco que figuraría en ambulancias, hospitales militares, y como distintivo en la ropa del personal sanitario. Esta simple idea de Dunant puede parecer muy obvia, pero la verdad, es que antes de él nadie había encontrado la solución para evitar que se disparase, en el fragor de la batalla, sobre los miembros del servicio de sanidad. (Bugnion F. El emblema de la Cruz Roja. Reseña Histórica. CICR, Ginebra, 1977). Los Convenios de Ginebra fueron el primer tratado multilateral firmado por países, reunidos en tiempo de paz para prevenir el sufrimiento. En el transcurso de los años el Comité Internacional de la Cruz Roja (CICR) logró que los gobiernos actualizaran y revisaran estos convenios, los que cuentan con un reconocimiento prácticamente universal. (Pictet JS. La doctrina de la Cruz Roja. Ginebra: 1962). El CICR junto a la Federación Internacional de Sociedades de la Cruz Roja y de la Media Luna Roja y las Sociedades Nacionales, integran el Movimiento Internacional de éstas y tienden a cumplir un mismo objetivo: ayudar indiscriminadamente a quien sufre, contribuyendo a mantener y promover la paz en el mundo. Todos los integrantes de este movimiento se rigen por 7 principios fundamentales: humanidad, imparcialidad, neutralidad, independencia, voluntariedad, unidad y universalidad. La Primera Guerra Mundial representa el mayor desafío que debe afrontar la Cruz Roja, hasta ese momento: miles de voluntarios se movilizan para ayudar a los heridos en los campos de batalla y en 1917 el CICR obtiene el Premio Nobel de la Paz. Durante la Segunda Guerra Mundial, la Cruz Roja distribuye socorros por un valor total de 500 millones de francos suizos a la población civil de los territorios ocupados. El CICR realiza 11 000 visitas a prisioneros de guerra militares y civiles y les envía suministros de socorro evaluados en 3,5 mil millones de francos. Dos veces más obtendrá el Premio Nobel el CICR: en 1944 y en 1963 en unión de la Liga de Sociedades (hoy federación). Henry Dunant, como ha ocurrido con muchas grandes figuras, vivió en la miseria durante muchos años, errante de ciudad en ciudad y enfermo. Su único consuelo era ver que la Cruz Roja crecía a grandes pasos. Sus ideas ya habían salvado miles de vidas. Uno tras otro los países organizaban sus propias sociedades nacionales y empleaban los años de paz en preparar la asistencia a los heridos de los ejércitos en campañas. La bandera de la Cruz Roja comenzaba a ondear en muchos campos de batalla convirtiéndose en un emblema conocido, grupos de enfermeras diplomadas y camilleros, junto con suministros y socorros médicos iban detrás de cada ejército en marcha. En 1876, Turquía adoptó el símbolo de la Media Luna Roja en vez de la Cruz Roja: la Media Luna Roja que se extenderá a lo largo de los países musulmanes en todo el mundo. Dunant vivió en Heiden, pueblo situado al Este de Suiza, casi en el olvido total. Así hubiera seguido hasta el final de sus días, si en 1895 un joven periodista no se hubiera dedicado a escalar las montañas próximas al poblado. Charlando con la gente del lugar supo que el fundador de la Cruz Roja vivía en el hospital del pueblo y como buen periodista concertó una cita y lo entrevistó. Más de 30 años habían transcurrido desde la publicación de Recuerdo de Solferi no pero el público lo recordó. El artículo de este periodista, llamado Baumberger, provocó una respuesta abrumadora. Dunant comenzó a recibir cientos de cartas y muchas visitas de viejos conocidos, las Sociedades Nacionales de la Cruz Roja y Media Luna Roja del mundo eterno le rindieron homenaje. Finalmente en 1901 se acordó entregar a Henry Dunant el reconocimiento internacional más importante en mérito a sus obras. El Comité del Premio Nobel le concedió el primer Premio Nobel de la Paz en unión de Fréderic Passy, por quien Dunant sentía gran respeto. Murió a los 82 años, el domingo 30 de octubre de 1910. Del hombre peculiar de Ginebra, cuya visión casi fue demasiado grande para su propio bien, nació un movimiento que hoy se extiende por todo el mundo; que ha llegado a millones de personas; que presta socorro por igual a civiles y a militares: una realidad aún más pode rosa que el sueño de Dunant. Hoy, 133 años después de la fundación de la Cruz Roja, 186 naciones han firmado los convenios de Ginebra y existen 169 Sociedades Nacionales de la Cruz Roja y Media Luna Roja. Ningún otro tratado en la historia de la humanidad ha alcanzado un número igual de signatarios, y no existe ninguna organización humanitaria que cuente con tantos miembros (127 millones) en tantos países. Fuente

Registrate y eliminá la publicidad! Un comerciante chino de 26 años denunció que ayer, cuando fue a abrir el negocio, notó que intrusos habían entrado en su concesionaria de motos en la madrugada. Aseguró que sin forzar ninguna cerradura le sacaron cheques y 8 mil pesos en efectivo. Yu Huagiang parece nervioso. “¿Cuánto hay que pagar?, pregunta a la periodista, creyendo que la entrevista es para acordar un aviso en el diario para gratificar la devolución de su documento de identidad, un pasaje y el pasaporte que dice le robaron de su negocio en la madrugada del martes, mientras dormía en un departamento ubicado en la planta alta de “ Keller Motos”. Aunque entremezcla vocablos chinos con un español que domina a fuerza de años de residir en la Argentina, Yu dice que, más que el dinero y los cheques que también le llevaron, le importa recuperar sus documentos y el boleto con el que pensaba viajar el mes que viene a la China, para casarse. Huagiang es socio propietario junto a otro compatriota de “Keller Motos”, una concesionaria ubicada en avenida España 1070 San Luis Capital, unos metros al oeste de avenida Italia. Cada uno tiene un departamento en el segundo piso, justo arriba del salón de venta de motos. Según comentó a un empleado, Huagiang estuvo chateando hasta las tres de la madrugada. Después se acostó a dormir y no supo que intrusos habían entrado a una oficina situada en el ala este del negocio hasta las 9 del día siguiente, cuando fue a abrir el comercio. Según un empleado, además de los papeles, le sustrajeron nueve cheques por 9 mil pesos, dos por 2 mil y cinco sin monto, además de 8 mil pesos en efectivo. Lo singular del caso no solo es que ni Huagiang ni su socio se habría percatado del movimiento de los intrusos en la planta baja, sino que quien robó logró entrar sin violentar ningún acceso. El comercio tiene alarma, pero esa noche no sonó. “Aparentemente, habrían entrado por el fondo de la propiedad, que da a Cerámica San Luis. En el fondo hay una medianera y un portón de este mismo material”, contó el empleado mientras señalaba la puerta de chapa de la oficina que estaba con llave y que habría sido abierta sin violencia. “Fueron limpios. Inclusive no revolvieron en la oficina. El dinero y los cheques estaban en el primer cajón, que también tiene cerradura y estaba con llave”, dijo el empleado. Ese mueble tampoco estaba violentado. En el cajón, cuya llave habitualmente está en manos de los socios, se guardan cheques y dinero de las transacciones diarias. La denuncia por el hecho fue realizada en la Comisaría 6ª. “Está bastante nervioso, imaginate que necesita el pasaporte y el pasaje porque se casa el 16 de enero”, dijo el empleado. fuente

Hace algo de esto y te deja ... Video 1 : link: http://www.videos-star.com/watch.php?video=Y1o-BGLMi38 Video 2 : link: http://www.videos-star.com/watch.php?video=VtZ78unPZS4 Video 3 : link: http://www.videos-star.com/watch.php?video=5WnZ_MKEYts Que tarados estos tipos jaja...