jphone.org - 2008 August 26

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 :Foo = 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});
  }
...

Si bien esto no fue m?s que una traducci?n de la gu?a de conversi?n a JFX Script compilado, bastar? para que, junto con las partes anteriores de la gu?a, tengamos una lista mas o menos completa de la sintaxis del lenguaje. A partir de ahora, comenzaremos crear algunas aplicaciones sencillas, para comprender el funcionamiento de las funciones gr?ficas b?sicas. Como siempre, les dejo algunos sitios recomendados para visitar mientras voy d?ndole forma a las pr?ximas partes de este tutorial:

El blog de James Weaver, en el que este Java Champion nos ofrece ayuda para volvernos un "JavaFXpert". Algunos ejemplos son algo avanzados, pero pueden retroceder hasta los articulos de alrededor de febrero o marzo, en donde los ejemplos son m?s sencillos y luego avanzar desde all?.
Y dos articulos de su autoria: "Creating Rich Internet Applications With Compiled JavaFX Script Technology" y "Using UI Components in Compiled JavaFX Script Technology", ambos bastante b?sicos y comprensibles.

Nos vemos en la pr?xima entrega.