Terra's Weblog

JavaFX 1.2 追加接続プログラム（plug-in）が動くようになった

2009-07-02T18:08:00.006+09:00

私は、まだ、NetBeans 6.5を使っています（6.5.1ではありません）。
過日、JavaFX 1.2 SDKとJDK 6 Update 13を導入した際に、NetBeans用のJavaFX追加接続プログラム（plug-in）もJavaFX 1.2相当のものを導入し直しました。ところが、JavaFXのプログラムを実行しようとすると、誤りが発生して実行できませんでした（見本の一部には実行できるものもありましたが･･･）。
追加接続プログラムに問題があり、その版が更新されれば実行できるようになるだろうと放っておきました。
ところが、本日たまたま古いJDKを整理し、それまでJDK 6 Update 11で動いていたNetBeans 6.5がJDK 6 Update 13で動くようになったところ、JavaFX 1.2のプログラムも正常に実行できるようになりました。
JDKを整理しなくても、NetBeansの設定変更でうまく対処できるのかもしれません。私のように、「追加接続プログラムの問題だ」とあきらめてしまう前に、一度調べてみると良いかもしれません。
なお、先ごろ公開されたNetBeans 6.7へは、JavaFX 1.2追加接続プログラムをうまく導入できないようです（NetBeans 6.7の導入ページにも、JavaFXは、NetBeans 6.5.1でのみ利用できまるとなってはいるのですが･･･）。John O'Conner氏が何とかしようと奮闘（？）されているようなのですが。興味のある方は、彼のBlogをご覧ください。

Servletから周期的にデータを取得するプログラムを作りました

2009-02-12T12:27:00.003+09:00

Servletから周期的にデータを取得して表示を更新する、JavaFXの役務依頼器（client）プログラムを作ってみました。

Servletへ1秒ごとにHTTPのGET要求を発行して数値データを文字列として取得し、棒図式と数字で実時間表示します（遠隔監視（Remote Monitor）を模擬した表示にしてみました。Servletは、監視データの代わりに現在の秒値を返します）。
コードの例は、こちらに載せています。

Servletと通信するプログラムを作りました

2009-02-10T20:47:00.005+09:00

Servletと通信するJavaFXの役務依頼器（client）プログラムを作ってみました。

「OK」ボタンが押されると、SwingTextFieldに入力された文字列を、HTTPのGET要求としてServletへ送ります。Servletでは、HttpServletRequest#getParameter()で送られてきた文字列を読み込み、前後に文字列を付加して依頼器へ送り返します。依頼器は、Servletから受信した文字列をTextとして表示します。
コードの例は、こちらに載せています。

Servlet接続プログラム作成の参考文書

2009-02-08T17:59:00.004+09:00

役務供給器（server）と通信する依頼器（client）側のJavaFXプログラムを開発する場合、試験用の供給器側プログラムをServletとして作成する、というのもひとつの手だと思います。NetBeansを利用すると、Servletプログラムの作成から配備までを容易に行うことができます。
今日は、Servletと接続するプログラムを作成する際に参考になる文書を紹介します。
Connecting to Servlets

段階式書式指定（CSS）に関する参考文書

2009-02-05T16:08:00.007+09:00

段階式書式指定（CSS（Cascading Style Sheets））を利用したJavaFX応用プログラムを開発する上で、参考になるWeb日誌と投稿を紹介します。
次のWeb日誌は、CSSとSkinクラスやControlクラスの関係について、簡潔な例を用いていて分かりやすく説明しています（表題には「Applets」とありますが、卓上型（desktop）プログラムとして実行できます）。
Styling your Applets with CSS

上のWeb日誌の例を試すときは、CSSファイル「style.css」を台本ファイルと同じディレクトリに置き、台本ファイル「Main.fx」の行

stylesheets: ["http://piliq.com/javafx/tutorials/css/style.css"];

を、次のように書き替えてから一括変換してください。

stylesheets: ["{__DIR__}style.css"];

CSSファイルの設定を書き替えると、台本ファイルを一括変換しなおさなくても、（台本を再実行しただけで）変更が反映されるのが分かります。

次の投稿には、段階式書式指定について詳しく説明されています。
CSS support control and skinning

上の投稿と次のWeb日誌をあわせて読むと、より分かりやすいかもしれません。
JavaFX in Style

作成時に列幅が指定可能な表部品を作ってみました

2009-01-29T02:03:00.004+09:00

「Planet JFX Wiki」に、javax.swing.JTableを使ったTable部品の見本が載っています。それにちょっと手を加えて、表を作成する際に列幅を指定できるようにしてみました。

コードの例は、こちらに載せています。

HTTP、XMLおよびJSONに関する参考文書

2009-01-27T16:51:00.004+09:00

JavaFXといえばRIAなので、今日は、HTTP、XMLおよびJSONの処理に関して、参考になるWeb日誌と応用見本のWeb面を紹介したいと思います。
HTTPとXMLに関する簡単な応用例として、次の2つのWeb日誌が参考になります。
Parsing a XML Sandwich with JavaFX
Reading Twitter with JavaFX

HTTPとXMLの応用見本としては、次のものが簡潔で分かりやすいと思います。
Interesting Photos : JavaFX Example Application

また、次のものは、HTTP、XMLおよびJSONの3つとも取り上げています。
Location-Based Coffee Shop Search

「JavaFXプログラミング言語の基礎補遺」を公開しました

2009-01-22T13:51:00.002+09:00

JavaFXに関するWeb面で、「JavaFXプログラミング言語の基礎補遺」を公開しました。「JavaFXプログラミング言語の基礎」では取り上げなかった細かなことや、やや発展的な事項について記述しました。

Spinner部品を作ってみました

2009-01-11T11:57:00.004+09:00

以前あったSpinnerクラスがJavaFX 1.0にはないので、JSpinnerを基に作ってみました。

コードの例は、こちらに載せています。

JavaFX追加接続の下見機能でWYSIWYG開発が可能に

2008-12-24T05:11:00.006+09:00

ちょっと古めかしい言葉を出してしまいましたが、MSのVisual StudioやNetBeansのMatisseのようなWYSIWYG環境でのソフトウェ開発が、JavaFXでも可能になりました。
それは、NetBeansなどのIDE用に提供されている、JavaFX追加接続（plug-in）プログラムの下見（preview）機能を利用した開発のことです。Visual StudioやMatisseのような、直接操作方式ではありませんが、編集作業と並行して実行時の姿が実時間で見られるので、かなり開発効率が上がります。
事前評価（preview）版のJavaFX追加接続にもその原型はあったのですが、原始コードの編集領域を分割して表示するため編集領域が狭くなる、コードによってはうまく表示ができないなど、正直言って「今一」の感が否めませんでした。しかし、JavaFX 1.0対応版では、これらの点かなり改善さているようです（まだ、それほど試した訳ではないので、問題点の有無を把握し切れてはいませんが）。
少なくとも、下見画面がIDEの窓とは独立した専用の窓に表示されるため、編集領域が狭くなることはありません。直接操作方式ではありませんが、元々JavaFX言語は宣言型の言語であり、VBやJavaに比べれば、画面表示とコードの対応が取りやすいこともあって、それほど苦にはなりません（もちろん、図形部品をマウスで引っ張りまわして好きな位置に配置したり、寸法を自由に変えられることに越したことはないのですが）。

JavaFX 1.0 SDK Update 1公開

2008-12-23T11:26:00.003+09:00

JavaFX 1.0 SDK Update 1が、12月19日に公開されました。公開直後は、導入用プログラムが更新前のものしか公開されていなかったのですが、今日改めて見てみたら、JavaFX 1.0 SDK Update 1用の導入プログラムに変更されていましたので、早速導入してしまいました。

狼おじさんになってしまうところでした

2008-12-16T15:46:00.005+09:00

昨日、私の不注意から、JavaFXのcontinue式に不具合があるとの投稿をしてしまいました。
再度確認したところ、continue式には、私が指摘したような不具合はないことが分かりました。
ここに、訂正して、お詫びいたします。
なお、誤った情報をこれ以上広めたくありませんので、まことに勝手ながら昨日の投稿は削除いたしました。
貴重なご指摘をいただいた、雪羽さんどうもありがとうございました。ここに、お礼を述べさせていただきます。

NetBeans用JavaFX追加接続プログラム日本語表示不具合

2008-12-13T14:47:00.003+09:00

JavaFX言語の入門書「JavaFXプログラミング言語の基礎」を書き始め、まだ第1章だけですがWebページで公開しました。
そこに載せている見本コードの動作確認をしていて分かったのですが、NetBeans用JavaFX追加接続プログラム（JavaFX 1.0相当版：JavaFX 1.0バージョン1.4.3、JavaFX SDK for Windowsバージョン1.3.3）の日本語表示には、まだ未修正の不具合があります。
これは、以前の投稿で記したものですが、標準出力に日本語文字列を表示するようなプログラムを一括変換すると誤りが発生するというものです。同じプログラムを、JavaFX 1.0 SDKのjavafxcでコマンド行から一括変換すると正常に変換でき、日本語が表示できます。したがって、Windows上で動作するNetBeans用JavaFX追加接続プログラムの標準出力への日本語表示に、問題が残っているようです。ちなみに、枠付き窓に日本語が表示できない不具合は、修正されています。
話は変わりますが、以前から、JavaFX言語は、表現力が高いばかりでなく、初心者がプログラミングを習得するのにも適した言語であると思っています。Java言語ですと、何はともあれ、「class」を定義しなければなりません。そこで、クラスとは何なのかの話をいきなり始めるか、「とりあえず、おまじない（？）と思って記述してください」と、クラスに関する説明を後回しにするかの選択をしなければなりません。
いずれにしても、説明する方も、また説明される方もあまりすっきりしません。
その点、JavaFXなら、println()関数の説明をするぐらいで「Hello world!」プログラムが書けますので、話が簡単です。また、JavaFX 1.0では、データ型の推定機能が復活しましたので、その点でもプログラミングが楽になります。しかも、動画や多重媒体応用プログラムが簡潔に書けるまでになります。
「JavaFX言語でプログラミングを学ぶ」といった講座が一般的になる、そんな日が早く来るといいのですが。

JavaFX 1.0 SDKが公開されました

2008-12-05T17:11:00.004+09:00

JavaFX 1.0 SDKが公開されましたので、早速導入してみました。
JavaFX 1.0 SDKは、JavaFX.comのStartページから導入できます。なお、同ページには、「Learning the JavaFX Script Programming Language」という指導書への連結が載っていますが、その指導書の中に記載されているJavaFX 1.0 SDK導入ページの連結をたどると、本日（12/5）現在では、事前評価（Preview）版の導入ページに案内されてしまいます。上記のStartページから導入すると、正式版が導入できます。
また、上記の指導書には、JDK 5またはJDK 6が必要と記されていますが、JavaFX 1.0 SDKを導入しようとすると、最新のJDK 6u11を導入するように求められます。

JavaFX Air Hockey program

2008-10-08T18:08:00.008+09:00

I made a Air Hockey game in JavaFX.
As for the program, named AirHockey.fx, plese refer to the code (modified to conform to JavaFX 1.0).
When you run the program, an air hockey game table with two aqua color mallets are displayed on your screen. Computer's goal (the upper one) and your goal (the lower one) are displayed in burlywood color.
Push the "SET" button to start the game. Then, a white puck appears on your side.
You can manipulate your mallet by the mouse as long as it resides in your area.
A velocity of your mallet is computed from its displacement by applying the scaling transformation. The scaling is modulated by the velocityScaling factor. You can make your mallet's velocity more real by moving the factor closer to 1.0.
You can also regulate the bounce back speed by adjusting the elastic modulus elastic.
In this program, a computer simply move its mallet back and forth. It has no ability to take the offensive. It is your business to make your opponent cool.
Enjoy yourself!

JavaFXで空中ホッケー遊技（Air hockey game）を作る

2008-10-07T16:45:00.013+09:00

JavaFXで、空中ホッケー遊技（Air hockey game）を作ってみました。
頭の中が沸騰しそうになったとき、しばらく空っぽにするのにいいですよ。
プログラムを実行すると、右の図のような空中ホッケーの卓が表示されます。薄茶色で表示されているところが得点圏（goal）で、青緑色で表示されているのが槌（mallet）です。
「SET」ボタンを押すと、図の位置に白い円盤（puck）が表示されます（プログラムを実行した直後や、得点した後は、円盤が表示されません）。
人間様用の槌（下側が「人間様」の領域で、上側が「計算機様」の領域です）をマウスで動かして（人間様の領域内にマウスを持っていくと、その後を槌が追います）、円盤を打ってみてください。
槌を速く動かしすぎると、槌で円盤を引きずるような動作をします。これは、マウスの位置の変化量から槌の速度を計算する際に、スケーリング変換を行っているためです。velocityScalingの値で、変換係数を調節してください。
また、円盤が卓の壁や槌に衝突してはね返されるとき、弾性係数を考慮して動きを計算しています。elasticの値で、弾性率を変えてみてください。
今回のものでは、計算機様は、ただ槌を往復させるだけで、何の芸も持ち合わせていません。計算機様にどんな芸を持たせるかが、これからの楽しみです。何の制限も持たせなければ、計算機様をいくらでも強くできますが、それでは勝負になりません。強過ぎても弱過ぎてもだめですし、（乱数に因らない）偶然の要素もないと面白くない、その辺りが工夫のしどころです。
最後に、原始コードを載せておきます。なお、前回の投稿で、仕立て節に定義した関数がうまく機能しないと記しましたが、（部品化を考慮して）仕立て節を別の台本ファイルで定義したことがまずかっただったようです。このプログラムのように、同じ台本ファイル内に仕立て節を定義する限り、特に問題はありませんでした。


/*
 * AirHockey.fx
 * The air hockey game.
 *
 * Created and modified:
 * V 1.0.0    2008/09/25
 */

package game;

import javafx.animation.*;
import javafx.application.*;
import javafx.input.*;
import javafx.scene.*;
import javafx.scene.effect.*;
import javafx.scene.effect.light.*;
import javafx.scene.geometry.*;
import javafx.scene.paint.*;
import javafx.scene.text.*;
import java.lang.Math;
import java.lang.System;

/**
 * @author terra
 */

var goalCorners: Disc[];
var mouseEvent: MouseEvent;

var tableWidth: Number = 300;
var tableHeight: Number = 400;
var goalWidth: Number = 80;
var goalCornerRadius: Number = 5;
var puckRadius: Number = 10;
var malletRadius: Number = 15;
var hittingAreaDepth: Number = tableHeight / 2 - malletRadius;
var elastic: Number = 0.95;
var velocityScaling = 0.35;
var malletCMaxV = 2;      // Maximum velocity of the computer's mallet.

var timingGenerator: Timeline = Timeline {
  repeatCount: Timeline.INDEFINITE
  keyFrames: KeyFrame {
    time: 20ms
    action: function(): Void {
      malletC.move();
      puck.move();
      malletH.calcuVelocity();
      puck.collide(malletH);
      puck.collide(malletC);
      for (corner in goalCorners) {
        puck.collide(corner);
      }
      score.judgeGoal();
    }
  }
};

var puck: Puck = Puck {
//  x: goalCornerRadius + tableWidth / 2
//  y: goalCornerRadius + 2 * tableHeight/ 3
  x: -(puckRadius + 1)
  y: goalCornerRadius + tableHeight / 2
  radius: puckRadius
  vX: 0, vY: 0
}

var malletH: MalletH = MalletH {        // Human's mallet.
  x: bind mouseEvent.getStageX()
  y: bind mouseEvent.getStageY()
  radius: malletRadius
  color: Color.AQUA
}

var malletC: MalletC = MalletC {        // Computer's mallet.
  x: goalCornerRadius + tableWidth / 2
  y: goalCornerRadius + malletRadius + puckRadius
  radius: malletRadius
  color: Color.AQUA
  vX: malletCMaxV, vY: 0
}

for (i in [0..1]) {
  for (j in [0..1]) {
    insert Disc {
      x: (tableWidth - goalWidth) / 2  + j * goalWidth
      y: i * (2 * goalCornerRadius + tableHeight)
      radius: goalCornerRadius
      color: Color.LIGHTGREY
    } into goalCorners;
  }
}

var score: Score = Score{}

Frame {
  title: "Air hockey"
  width: 2 * goalCornerRadius + tableWidth + 56 as Integer
  height: 2 * goalCornerRadius + tableHeight + 28 as Integer
  visible: true
  closeAction: function(): Void {System.exit(0);}
  stage: Stage {
    width: 2 * goalCornerRadius + tableWidth as Integer
    height: 2 * goalCornerRadius + tableHeight as Integer
    fill: Color.LIGHTGRAY
    content: [
      Rectangle {     // Jointed goal area.
        x: (tableWidth - goalWidth) / 2
        y: 0
        width: goalWidth
        height: 2 * goalCornerRadius + tableHeight +2
        fill: Color.BURLYWOOD
      },Rectangle {       // Table.
        x: goalCornerRadius, y: goalCornerRadius
        width: tableWidth, height: tableHeight
        fill: Color.OLIVE
      },
      Rectangle {       // Human's hittig area.
        x: goalCornerRadius + malletRadius
        y: goalCornerRadius + tableHeight - hittingAreaDepth
        width: tableWidth - 2 * malletRadius
        height: hittingAreaDepth - malletRadius
        fill: Color.OLIVE
        onMouseMoved: function(ev: MouseEvent): Void {
          mouseEvent = ev;
        }
      },
      Line {      // Center line.
        startX: goalCornerRadius
        startY: goalCornerRadius + tableHeight / 2
        endX: goalCornerRadius + tableWidth -1
        endY: goalCornerRadius + tableHeight / 2
        stroke: Color.BLUE
      },
      puck,
      malletH,
      malletC,
      goalCorners,
      ScoreIndicator {
        x: 2 * goalCornerRadius + tableWidth + 5 as Integer
        y: goalCornerRadius + tableHeight / 2 - 24 as Integer
        score: bind score.scoreC
      },
      ScoreIndicator {
        x: 2 * goalCornerRadius + tableWidth + 5 as Integer
        y: goalCornerRadius + tableHeight / 2 + 5 as Integer
        score: bind score.scoreH
      },
      Rectangle {       // "SET" button.
        x: 2 * goalCornerRadius + tableWidth + 5 as Integer
        y: goalCornerRadius + tableHeight - 30 as Integer
        width: 35, height: 30
        arcWidth: 8, arcHeight: 8
        fill: Color.DARKGREY
        effect: Lighting {
          light: DistantLight {
            azimuth: 225, elevation: 50
          }
        }
        onMousePressed: function(ev: MouseEvent): Void {
          puck.x = goalCornerRadius + tableWidth / 2;
          puck.y = goalCornerRadius + 2 * tableHeight/ 3;
          puck.vX = 0;
          puck.vY = 0;
          timingGenerator.start();
        }
      },
      Text {
        x: 2 * goalCornerRadius + tableWidth + 10 as Integer
        y: goalCornerRadius + tableHeight - 20 as Integer
        textOrigin: TextOrigin.TOP
        fill: Color.YELLOW
        font: Font {
          size: 14
          name: "Monospaced", style: FontStyle.BOLD
        }
        effect: DropShadow {
          offsetX: 3, offsetY: 3, radius: 2
          color: Color.BLACK
        }
        content: "SET"
      } 
    ]
  }
}


class Disc extends CustomNode {
  attribute x: Number;
  attribute y: Number;
  attribute radius: Number;
  attribute color: Color = Color.WHITE;
  attribute vX: Number;
  attribute vY: Number;
  attribute lastX: Number = x;
  attribute lastY: Number = y;
    
  function create(): Node {
    return Circle {
      centerX: bind x, centerY: bind y
      radius: bind radius
      fill: bind color
    };
  }
}

class Puck extends Disc {
  function move(): Void {
    x += vX;
    y += vY;

    if (x + radius > goalCornerRadius + tableWidth) {
      x = goalCornerRadius + tableWidth - radius;
      vX *= -1.0 * elastic;
    } else if (x - radius < goalCornerRadius) {
      x = goalCornerRadius + radius;
      vX *= -1.0 * elastic;
    }
    
    if (x >= 0) {
      if (y > 2 * goalCornerRadius + tableHeight) {
        // It crossed the Human's goal line.
        x = -(radius + 1);
        y = 2 * goalCornerRadius + tableHeight + radius;
        vX = 0;
        vY = 0;
      } else if (y + radius > tableHeight + goalCornerRadius) {
        if ((x < (tableWidth - goalWidth) / 2) 
            or (x > (tableWidth + goalWidth) / 2)) {
          y = tableHeight + goalCornerRadius - radius;
          vY *= -1.0 * elastic;
        }
      } else if (y < 0) {
        // It crossed the computer's goal line.
        x = -(radius + 1);
        y = -radius;
        vX = 0;
        vY = 0;
      } else if (y - radius < goalCornerRadius) {
        if ((x < (tableWidth - goalWidth) / 2) 
            or (x > (tableWidth + goalWidth) / 2)) {
          y = goalCornerRadius + radius;
          vY *= -1.0 * elastic;
        }
      }
    }
  }

  function collide(disc: Disc): Void {
    var distX: Number = disc.x - x;
    var distY: Number = disc.y - y;
    var minDist: Number = disc.radius + radius;
    var dist2: Number = distX * distX + distY * distY;
    var minDist2: Number = minDist * minDist;

    if (dist2 < minDist2) {
      var colAngle: Number = Math.atan2(distY, distX);
      var sinColAngle: Number = Math.sin(colAngle);
      var cosColAngle: Number = Math.cos(colAngle);

      var expres1: Number = disc.vX * cosColAngle + disc.vY * sinColAngle;
      var expres2: Number = vX * sinColAngle - vY * cosColAngle;
      var expres3: Number = vX * cosColAngle + vY * sinColAngle;

      x = disc.x - minDist * cosColAngle;
      y = disc.y - minDist * sinColAngle;

      vX = (1+ elastic) * expres1 * cosColAngle + expres2 * sinColAngle 
          - elastic * expres3 * cosColAngle;
      vY = (1+ elastic) * expres1 * sinColAngle - expres2 * cosColAngle
          - elastic * expres3 * sinColAngle;
    }
  }
}

class MalletH extends Disc {
  function calcuVelocity(): Void {
    vX = velocityScaling * (x - lastX);
    vY = velocityScaling * (y - lastY);
    lastX = x;
    lastY = y;
  }
}

class MalletC extends Disc {
  function move(): Void {
    x += vX;

    if (x + radius > 2 * goalCornerRadius + tableWidth / 2 
        + goalWidth / 2) {
      x = 2 * goalCornerRadius + tableWidth / 2 + goalWidth / 2 
          - radius;
      vX *= -1.0;
    } else if (x - radius < tableWidth / 2 - goalWidth / 2) {
      x = tableWidth / 2 - goalWidth / 2 + radius;
      vX *= -1.0;
    }
  }
}

class Score {
  attribute scoreC: Integer = 0;      // Computer's score.
  attribute scoreH: Integer = 0;      // Human's score.
  
  function judgeGoal(): Void {
    if (puck.x < 0) {
      if (puck.y > 2 * goalCornerRadius + tableHeight) {
        scoreC += 1;
      } else if (puck.y < 0) {
        scoreH += 1;
      }
      puck.y = goalCornerRadius + tableHeight / 2;
      timingGenerator.stop();
    }
  }
}

class ScoreIndicator extends CustomNode {
  attribute score: Integer = 0;
  attribute x: Integer = 0;
  attribute y: Integer = 0;
  attribute width: Integer = 21;
  attribute height: Integer = 18;
  attribute fillColor: Color = Color.WHITE;
  attribute borderColor: Color = Color.YELLOWGREEN;
  attribute scoreTextColor: Color = Color.BLACK;

  function create(): Node {
    Group {
      content: [
        Rectangle {
          x: x, y: y
          width: width, height: height
          arcWidth: 6, arcHeight: 6
          stroke: borderColor, fill: fillColor
          },
        Text {
          x: x + 4 * height / 18 as Integer
          y: y + 5 * height / 18 as Integer
          textOrigin: TextOrigin.TOP
          fill: scoreTextColor
          font: Font {
            size: 14 * height / 18 as Integer 
            name: "Monospaced", style: FontStyle.BOLD
          }
          content: bind "{%2d score}"
        }
      ]
    }
  }
}

仕立て節がうまく機能しない

2008-09-09T21:30:00.004+09:00

前回の投稿で、SCADA UIプログラム例をPAC類型に基づいて構成しなおしました。
そこで、SCADA UIの構成部品（数値指示計や棒図式指示計など）をjavafx.scene.CustomNodeクラスの派生クラスとしてPACエージェント化しようとしたのですが、どうもうまくいきません。
CustomNodeの派生クラスで、新たに関数を定義しているのですが、その関数が思ったように機能してくれません。関数の機能を限定し、「回避策」的なプログラミングを行えば、少なくともこれまでご紹介したSCADA UIプログラム例と同程度の機能を持った仕立て節を作ることは可能です。ですが、せっかく「仕立てる」のですから、あらが目立つようではどうも…。というわけで、もう少し一括変換器の成熟を待つことにしました。
JavaFX言語V1.0における変更点についても、これまでにご紹介したもの以外の変更があるのですが、すでにご紹介した内容についても更なる変更が生じていますので、こちらについても落ち着くのを待ってご紹介したほうが良さそうです。まだ「2008年の秋」は始まったばかりですから…。

JavaFX言語V1.0における変更：利用修飾子

2008-08-18T15:42:00.005+09:00

JavaFX言語のV1.0における変更点の内、利用修飾子について、その内容をご案内したいと思います。

var x;
var x : String;
var x = z + 22;
var x = bind f(q);
変数を宣言します。変数は、オブジェクト直定数で初期化したり、派生クラスで再定義したり、その値を読んだり、値を割り当てたり、もしくは既定値の式またはオブジェクト直定数の初期化で結合することができます。既定で利用可能なのは台本内からで、利用修飾子がない場合は、同じ台本内からのみ初期化、再定義、読むこと、割り当て、または結合が可能です。

def x = 100;
def x = a + b;
def x = bind a + b;
変数を定義します。定義内容は変更できません。この種の変数は、オブジェクト直定数で初期化したり、派生クラスで再定義したり、値を割り当てたりすることができません。既定で利用可能なのは台本内からで、利用修飾子がない場合は、同じ台本内からのみ読むこと、または結合が可能です。

public var x;
公開変数を宣言します。この変数は、どこからでも、初期化、再定義、読むこと、割り当て、もしくは結合が可能です。

public def x = "Hi";
公開変数を定義します。この定義は、どこからでも読むこと、および結合が可能ですが、値を割り当てたり、オブジェクト直定数で初期化したり、または派生クラスで再定義することはできません。

protected var x;
同じパッケージまたは派生クラスから利用可能な変数を宣言します。

protected def x = bind z;
同じパッケージまたは派生クラスから読むこと、または結合が可能な変数を定義します。

package var x;
同じパッケージから利用可能な変数を宣言します。

package def x = 42;
同じパッケージから読むこと、または結合が可能な変数を定義します。

public-readable var x;
どこからでも読むことはできますが、既定で利用可能な台本内からのみ、初期化または書くこと（割り当てまたは結合）が可能な変数を宣言します。

public-readable package var x;
どこからでも読むことはできますが、同じパッケージ内からのみ初期化または書くこと（割り当てまたは結合）が可能な変数を宣言します。

non-writable public var x = 1.0;
non-writable public var x;
公に利用できますが、書くこと（割り当てまたは結合）ができない変数を宣言します。どこからでも、初期化、再定義、または読むことは可能ですが、その値を変更することはできません。この場合、初期化は書くことにはあたりません。

non-writable var x = 1.0;
同じ台本内から初期化または読むことはできますが、値の割り当てまたは結合はできない変数を宣言します。

JavaFX言語V1.0における変更

2008-08-17T16:51:00.003+09:00

JavaFX言語のV1.0（初版）における変更点について、ご案内したいと思います。
まだ実装されていないものもあります。また、実装済みのものについては、古い構文も（警告はされるが）ある期間は引き続き機能するようです。ただし、最終的には、警告ではなく誤りになり、その切り替わり時点は決まっていないということのようです。

不等価演算子
不等価演算子「<>」は「!=」に置き換えられました。この件と次の剰余演算子の変更については、以前の投稿でも触れました。

剰余演算子
剰余演算子「%」は「mod」に置き換えられました。これに関連して、剰余代入演算子「%=」は、（「mod=」に置き換えられるのではなく）剰余代入演算子そのものが支援されなくなるため、「x = x mod y」のように記述することになります。
ちなみに、JavaFXの剰余演算はJavaのそれ（%）と同じで、剰余の符号は被除数の符号に合わせられます（被除数および／または除数が負数の場合の、剰余の符号に関係します）。

台本の取込み
import文は、Java言語の「import static」（J2SE 5.0で支援された、クラスの静的要素の取り込み）機能を含むように、拡張されました。

「+」による文字列連結の廃止
「+」演算子による文字列の連結は廃止されます。String型の変数aとbに格納した文字列の連結は、（「a + b」ではなく）「"{a}{b}"」と表します。

関数再定義
クラスの要素関数を再定義するときは、「override」鍵語が必要になります。

変数宣言
変数を宣言するときは、それがどこであれ、鍵語「var」と「def」が使用され、鍵語「attribute」（クラス属性を宣言）と「static」（台本水準の変数を定義）はなくなります。「def」を用いて定義した変数に（初期化以外で）値を割り当てると誤りになります。

利用修飾子
利用修飾子は、「public」、「package」、「protected」、「public-readable」および「non-writable」の5つとなり、「private」はなくなります。既定の利用可能性は、「台本内から利用可」です。
利用修飾子については、別途投稿します。

オブジェクト直定数構文
「オブジェクト直定数の振る舞いがいくぶんか限定され、構文も厳密になる」ようです。

再帰取込み
「import パッケージ名.*」構文は、「import パッケージ名.**」を支援するように拡張されます。これは、「指定されたパッケージとその下位パッケージに含まれるすべてを取り込む」ことを意味します。

仮引数の不変化
関数の仮引数は不変で、それらに値を割り当てると誤りになります。

SCADA UIプログラム例のJavaFX SDK対応書き換え：PAC類型適用

2008-08-14T17:26:00.007+09:00

先日の投稿で、SCADA UIプログラム例のJavaFX SDK対応の書き換えは、一応済みました。
今回は、プログラム構造を基本設計におけるPAC（Presentation-Abstraction-Control）類型を参考にして構成し直してみました。ただし、Presentation要素とAbstraction要素が、結合機能により、（Control要素を介さない）直接的なつながりを持っているので、純粋にはPAC類型と呼べないかも知れません。
しかし、機能的なまとまりをPACエージェントとして構成し、プログラム全体をそれらPACエージェントの階層化された木構造で構成しているという点においては、PAC類型に準じたものです。PAC類型については、F. ブッシュマン、ほか著の『ソフトウェアアーキテクチャソフトウェア開発のためのパターン体系』（株式会社トッパン，1999）に説明されています。
PACエージェントとして構成するため、Javaのプログラムを2つに分けました。
まずは、依頼機側の接続エージェントとなるJavaのプログラムを示します。


/*
* ClientSideConnection.java
* The Client-Side Connection agent for a SCADA application.
*
* Created and modified:
* V 1.0.0    2008/07/31
*/

package client;

/**
* @author terra
*/

class ClientSideConnection {

private int i = -1;

/**
* Create and return pseudo SCADA data as if received from a server.
*/
double receiveScadaData() {
  i += 1;
  if (i >= 360) {
    i = 0;
  }
  return (double) Math.sin(i * Math.PI / 180) * 100;
}

/**
 * Main method for testing this class.
 *
 * @param args the command line arguments
 */
public static void main(String[] args) {
  ClientSideConnection scc = new ClientSideConnection();

  for (int i = 0; i < 5; i++) {
    System.out.println(scc.receiveScadaData());
  }
}
}

次に、警報鳴動エージェントとなるJavaのプログラムを示します。


/*
* AlarmSounder.java
* The Temporary Alarm Sounder agent for a SCADA application.
* At some point, this agent will be rewritten in the JavaFX language.
*
* Created and modified:
* V 1.0.0    2008/08/11
*/

package client;

import java.applet.Applet;
import java.applet.AudioClip;
import javax.swing.JOptionPane;

/**
* @author terra
*/

class AlarmSounder {

private AudioClip ac = Applet.newAudioClip(
    AlarmSounder.class.getResource("ALERT.WAV"));

/**
 * Start sounding the alarm.
 */
public void startAlarm() {
  ac.loop();
}

/**
 * Stop sounding the alarm.
 */
public void stopAlarm() {
  ac.stop();
}

/**
 * Main method for testing this class.
 *
 * @param args the command line arguments
 */
public static void main(String[] args) {
  AlarmSounder as = new AlarmSounder();

  as.startAlarm();
  JOptionPane.showMessageDialog(null, "Alarm is sounding！",
      "Alarm test", JOptionPane.WARNING_MESSAGE);
  as.stopAlarm();
}
}

最後に、利用者インタフェース（UI）最上位エージェントである、UI枠付き窓エージェントのJavaFXプログラムを示します。


/*
* ScadaClientUI.fx
* The User Interface Frame (UIF) agent for a SCADA application.
*
* Created and modified:
* V 1.0.0    2008/08/01
*/

package client;

import javafx.animation.*;
import javafx.application.*;
import javafx.input.*;
import javafx.scene.*;
import javafx.scene.geometry.*;
import javafx.scene.paint.*;
import javafx.scene.text.*;
import java.lang.System;

/**
* @author terra
*/

var csc = new ClientSideConnection();   // Client-Side Connection agent.
var alarmSounder = new AlarmSounder();  // Alarm Sounder agent.

/*
* The Abstraction compenent of the UIF agent.
*/
class UIFAbstraction {
attribute numericDatum: Number;
attribute numericData: Number[] = for (i in [0..180]) 0.0;
attribute alarting: Boolean;
function getDisplayColor(value: Number): Color {
  var c: Color = Color.GREEN;
  if (value > 90.0) {
    c = Color.RED;
  } else if (value > 75.0) {
    c = Color.color(1.0, 0.6, 0.0);
  }
  return c;
}
function setNumericDatum(value: Number): Void {
  numericDatum = value;
  delete numericData[0];
  insert value into numericData;
  if (numericDatum > 90.0 and not alarting) {
    alarting = true;
    alarmSounder.startAlarm();
    alarmDialog.toFront();
    alarmDialog.visible = true;
  }
}
function setAlarting(alarting: Boolean): Void {
  this.alarting = alarting;
}
}
var uifa = UIFAbstraction {};

/*
* The Control compenent of the UIF agent.
*/
class UIFControl {
attribute schedular: Timeline = Timeline{
  repeatCount: Timeline.INDEFINITE
  keyFrames: KeyFrame {
    time: 200ms
    action: function(): Void {
      uifa.setNumericDatum(csc.receiveScadaData());
    }
  }
}
}
var uifc = UIFControl {};
uifc.schedular.start();

/*
* The Presentation compenent of the UIF agent.
*/
Frame {
title: "SCADA UI Example"
width: 800, height: 632
visible: true
closeAction: function(): Void {System.exit(0);}
stage: Stage {
  width: 800, height: 600
  fill: Color.color(0.9, 0.9, 0.9)
  content: [
    Group {
      translateX: 50, translateY: 50
      content: [
        Rectangle {
          width: 55, height: 18
          arcWidth: 4, arcHeight: 4
          stroke: Color.BLUE, fill: Color.WHITE
          },
        Text {
          x: 4, y: 5
          textOrigin: TextOrigin.TOP
          fill: bind uifa.getDisplayColor(uifa.numericDatum)
          font: Font {
            name: "Monospaced", size: 14, style: FontStyle.PLAIN
          }
          content: bind "{%7.2f uifa.numericDatum}"
        },
        Text {
          x: 60, y: 6
          textOrigin: TextOrigin.TOP
          font: Font {
            name: "Monospaced", size: 14, style: FontStyle.PLAIN
          }
          content: "m3/s"
        }
      ]
    },
    Group {
      translateX: 200, translateY: 50
      content: [
        Rectangle {
          width: 60, height: 120
          stroke: Color.BLUE, fill: Color.WHITE
        },
        Rectangle {
          x: 10, y: 10
          width: 10, height: 100
          fill: LinearGradient {
            startX: 0.0, startY: 0.0
            endX: 0.0, endY: 1.0
            stops: [
              Stop {offset: 0.05, color: Color.RED},
              Stop {offset: 0.0875, color: Color.color(1.0, 0.6, 0.0)},
              Stop {offset: 0.125, color: Color.LIMEGREEN},
            ]
          }
        },
        Rectangle {
          x: 10, y: 10
          width: 10, height: bind 50 - uifa.numericDatum / 2
          fill: Color.BLACK
        },
        Line {
          startX: 23, startY: 10
          endX: 23, endY: 110
          stroke: Color.BLACK
        },
        Group {
          translateX: 23, translateY: 10
          content: for (i in [-100..100 step 50]) Line {
            translateY: i / 2 + 50
            startX: 0, startY: 0
            endX: 3, endY: 0
            stroke: Color.BLACK
          }
        },
        Group {
          translateX: 32, translateY: 10
          content: for (i in [-100..100 step 50]) Text {
            translateY: 53 - i / 2
            content: "{i}"
            font: Font {
              name: "Monospaced", size: 10, style: FontStyle.PLAIN
            }
            horizontalAlignment: HorizontalAlignment.LEADING
            verticalAlignment: VerticalAlignment.TOP
          }
        }
      ]
    },
    Group {
      translateX: 50, translateY: 200
      content: [
        Rectangle {
          width: 230, height: 120
          stroke: Color.BLUE, fill: Color.WHITE
        },
        Rectangle {
          x: 10, y: 22
          width: 181, height: 88
          fill: Color.BLACK
        },
        Rectangle {
          x: 10, y: 15
          width: 181, height: 7
          fill: Color.GRAY
        },
        Rectangle {
          x: 10, y: 10
          width: 181, height: 5
          fill: Color.DARKGRAY
        },
        Line {
          startX: 194, startY: 10
          endX: 194, endY: 110
          stroke: Color.BLACK
        },
        Group {
          translateX: 194, translateY: 10
          content: for (i in [-100..100 step 50]) Line {
            translateY: i / 2 + 50
            startX: 0, startY: 0
            endX: 3, endY: 0
            stroke: Color.BLACK
          }
        },
        Group {
          translateX: 203, translateY: 11
          content: for (i in [-100..100 step 50]) Text {
            translateY: 53 - i / 2
            content: "{i}"
            font: Font {
              name: "Monospaced", size: 10, style: FontStyle.PLAIN
            }
            horizontalAlignment: HorizontalAlignment.LEADING
            verticalAlignment: VerticalAlignment.TOP
          }
        },
        Group {
          translateX: 10, translateY: 10
          content: for (i in [0..179]) Line {
            translateX: i
            startX: 0, startY: bind 50 - uifa.numericData[i] / 2
            endX: 1, endY: bind 50 - uifa.numericData[i + 1] / 2
            strokeWidth: 2
            stroke: bind uifa.getDisplayColor(uifa.numericData[i + 1])
          }
        }
      ]
    }
  ]
}
}

/*
* The Alarm Dialog agent.
*/
var alarmDialog = Dialog {
title: "Alarm"
width: 300, height: 60
visible: false
closeAction: function(): Void {
  alarmSounder.stopAlarm();
  uifa.alarting = false;
}
stage: Stage {
  content: Text {
    x: 10, y: 10
    textOrigin: TextOrigin.TOP
    fill: Color.RED
    font: Font {size: 14}
    content: "Flow rate exceeded the second upper limit!"
  }
}
}

第一段デフラグをする前に

2008-08-10T15:56:00.009+09:00

Windowsをお使いの皆さん、「ディスクデフラグ」はどうされていますか。
私はWindows ＸＰを使っていますが、以前は、毎週定期的に磁気円盤上のファイルの控えをとった後に、そのままデフラグを行っていました。
しかし、磁気円盤上に情報が正常に読み書きできない部分がある状態でデフラグを行うと、最悪の場合、Windows自体が損傷を受け、個人用計算機が立ち上がらなくなってしまうことがあるようです。
Windows 98では、磁気円盤上の情報の読み書きで誤りを検出すると、デフラグの途中で「スキャンディスクを行え」というような窓が表示され、デフラグが中断したように記憶していました。それで、磁気円盤の誤り検査を行わずに、いきなりデフラグを行っていたのですが、これが危険なことのようなのです。実際、私は痛い目にあってしまいました。
それ以来、デフラグを行う前には、磁気円盤の「エラーチェック」を行うようにしています（「そんなことは、常識だろ」といわれそうですが。なお、「エラーチェック」の方法をお知りになりたい場合は、「スタート」ボタンを押して表示される機能選択肢の「ヘルプとサポート」で検索してみてください）。私は、誤り検査だけしか行わない（修復や回復は行わない）ので、それほど時間はかかりません（修復や回復を行うように選択すると、駆動機構によってはWindowsを再起動する必要があります。再起動が必要ない駆動機構の場合でも、検査だけよりかなり時間がかかります）。
私にとっては、「そういうことは、早く教えてよ～」なことでした。「何事も先達はあらまほし…」といいますので、私の轍を踏むことのないようにと、老婆心ながら投稿しました（もっとも、誤り検出を行って正常なことを確認した上でデフラグを行えば安全だ、という保証があるわけではないのですが）。
なお、（私は経験していませんが、）「エラーチェック」で異常を検出すると、修復と回復を選択して、「エラーチェック」をし直すよう促す窓が表示されるようです。また、そもそもデフラグはあまり頻繁に行わないほうがよいと書かれているWebページもあります（頻繁に行ってもあまり効果がないとか、磁気円盤記憶装置の寿命を縮めるというのもありました。本当のところはどうなのでしょうか）。私は、分析の結果デフラグを行う必要がないと表示されたときは、デフラグを行わないようにしています（以前は、必要がないといわれてもデフラグを行っていましたが…）。

JavaFX台本型プログラミング言語基準（草案）：改訂版

2008-08-07T21:04:00.014+09:00

以前に和訳を投稿した「The JavaFX™ Script Programming Language Reference (Draft)」が改訂されましたので、訳の方も改めました。改訂内容としては、単に記述項目を追加しただけでなく、以前の記述内容や表現の見直しも行われています。
-------------------------------------------

JavaFX台本型プログラミング言語基準（草案）

目次
1.言語概要
2. クラスとオブジェクト
3.属性と関数
4.変数と基本データ型
5.式と演算子
6.列を宣言する
7.列を利用する
8.データ結合
9.引き金
10.動画
A.鍵語と予約語

1.言語概要
この章では、JavaFX™台本型プログラミング言語（訳注：以下、「JavaFX言語」と略記）の概要について説明する。ここでは、このプログラミング言語の主な特徴を高い水準で述べ、特定の構成概念についての詳述は後の章で行う。この本は、ウェブ（Web）ページにおいて、Java™ Web Startソフトウェアとしてまたは従来型の机上応用プログラムとして実行される、表現力豊かなインタネット依頼機応用プログラムや要素の、設計者および開発者を対象としたものである。読者がJavaScriptまたはJava™プログラミング言語（訳注：以下、「Java言語」と略記）のいずれか、または両者に精通していることを想定している。この文書は公式な言語仕様を定めたものではないが、現在支援されている言語の特徴のすべてに対する完全な基準とみなすことができる。
JavaFX言語は、次の特徴を有している。


   ・図式利用者インタフェース（GUI）構成部品の指定に宣言型構文を
     使用しており、開発者のプログラムコードをGUIの実際の配置に
     ぴたりと対応させることを可能にしている。
   ・宣言型データ結合と増分評価を使用しており、個々の構成部品を
     容易に作成および構成することを可能にしている。応用プログラムの
     データとGUIの構成部品は、自動的に同期がとられる。
   ・静的に型付けされており、Java言語において大規模プログラムの
     作成と保守を可能にしているのと同様のコード構造、再利用および
     情報隠ぺいなどの特性のほとんどを有している。
   ・どのような規模または複雑さのGUIも支援することができる。
   ・Swingの利用を容易にする。

以下の節では、JavaFX言語について駆け足で紹介する。しかるべき点についてはJava言語と比較および対比させながら、その核となる構文と機能についての一般的な導入を与える。そして、それぞれの主題は後の章で更に詳しく取り上げられる。

台本
JavaFX言語において、「台本」は1つ以上の宣言または式である。台本を評価することは、宣言または式を順序を追って評価することである。


   var ten : Integer = 10;
   java.lang.System.out.println("Twice {ten} is {2 * ten}.");

これは、次のように表示する。


   Twice 10 is 20.

Java言語で書かれた応用プログラムと異なり、台本は、いかなるクラス宣言または関数も含む必要がない。

クラス
クラスの定義は、Java言語と多くの共通点を持っているが、いくつかの相違点は注目に値する。たとえば、情報は、領域ではなく、属性に格納される。振る舞いは、操作ではなく、関数によってあらわにされる。次の例は、それぞれの基本構文を示す単純な矩形クラスを定義している。


   class Rectangle {

       attribute width: Integer;
       attribute height: Integer;

       function grow(): Void {
           grow(1);
       }

       function grow(amount: Integer): Void {
           width += amount;
           height += amount;
       }

   }

JavaFX言語は多重継承を支援しており、必要なら複数のクラスを継承することができる。
クラスは、第2章で詳しく取り上げられる。
属性と関数は、第3章で詳しく取り上げられる。

オブジェクト
オブジェクト直定数は、クラスの実体化のための簡便な構文を提供する。次のコードは、前述した矩形クラスの単一の実体を生成し、その幅と高さの属性を100に初期化する（newを必要としない点に留意すること）。


   Rectangle {

       width: 100
       height: 100

   }

このオブジェクトへの参照を格納するには、var鍵語を使う。


   var myRect = Rectangle {

       width: 100
       height: 100

   }

オブジェクトは、第2章で詳しく取り上げられる。
変数と基本データ型は、第4章で詳しく取り上げられる。

式と演算子
他のプログラミング言語と同様に、JavaFX言語は、式と演算子を支援する。
第5章は、JavaFX言語において利用可能な式と演算子について論じる。

列
列は、オブジェクトの順序付けられた一覧を保持する。これは、Java言語の配列にほぼ類似している。両方とも複数の値を保持し、0から始まる索引により検索される。


   var week = ["Monday","Tuesday","Wednesday","Thursday",
           "Friday","Saturday","Sunday"];
   var mon = week[0];
   var wed = week[2];
   var fri = week[4];

部分列も支援されている。


   var week = ["Monday","Tuesday","Wednesday","Thursday",
           "Friday","Saturday","Sunday"];
   var weekdays = week[0..4]; // 第1部分列
   var weekend = week[5..6]; // 第2部分列

第6章は列の宣言の基本を取り上げており、一方、第7章は列の利用に焦点を当てている。

データ結合
データ結合は、複数オブジェクトの状態を同期させるための簡便な構文を提供する。2つのオブジェクトが互いに結合されると、1番目のオブジェクトが更新されたときはいつも2番目のオブジェクトの値が自動的に変更される。データ結合の一般的な利用法は、GUI部品をその基となるデータに同期させ続けることである。


   import javafx.application.Frame;
   import javafx.application.Stage;
   import javafx.scene.text.Text;

   var myString = "Hello World!";

   Frame {
       width: 50
       height: 50
       visible: true
       stage: Stage {
           content: Text {
               content: bind myString
           }
       }
   }

   // コードのほかの部分でmyStringを変更すると、
   // GUIの文字列も自動的に変更される。

データ結合は、第8章で詳しく取り上げられる。

引き金
引き金は、ある条件が満たされると実行されるコードの区画である。たとえば、ある属性の値が不適切なものに設定された場合には、注意を喚起してほしいと思うかもしれない。次の例は、その基本的な引き金の構文を示す。


   import java.lang.System;

   ReplaceDemo {

       mySensitiveData: "Will anyone notice?"

   }

   class ReplaceDemo {
       attribute mySensitiveData: String
           on replace {
               System.out.println("I noticed a change!");
           };

           // 応用特有の保護手段コードがここに書かれる
   }

引き金は、第9章で詳しく取り上げられる。

2.クラスとオブジェクト

クラスを取り込む
取り込み文は、Java言語と同様に機能する。その構文は、


   import パッケージ名.クラス名;

および


   import パッケージ名.*;

である。
取り込み文が存在する場合は、それ以外のすべての応用コードの前になければならない。JavaFX言語は、自身の組み込みライブラリクラスのための名前空間（パッケージjavafx.*）を定義しているが、標準的なJava言語のクラスを取り込むこともできる。


   import javafx.application.*;
   import java.lang.System;

   ...

クラスを定義する
クラスを指定するための構文は、class鍵語に続けたクラス名、任意選択としてのextends鍵語とカンマで区切った基底クラス名の一覧、左中括弧、それぞれセミコロンで終結している属性と関数の一覧、および右中括弧からなる。
JavaFX言語は多重継承を支援しており、そうしたものとして、新たな用語と規定を定義している。


   ・単純クラスは、Java言語で書かれたクラスを直接的または間接的に
      拡張した任意のクラスである。
   ・複合クラスは、単純クラスに当てはまらないすべてのクラスである。
   ・既定では、JavaFX言語で書かれたクラスは複合クラスである。
   ・クラスは、1つの単純クラスだけを拡張することができる。
     そうしたクラスは、単純クラスとなる。クラスはまた、任意の数の
     複合クラスまたはJava言語のインタフェースを拡張することもできる。

注記：現在のところ、単純クラスはJavaクラスに変換され、一方、複合クラスはJavaクラスとJavaインタフェースに変換される。

クラスはpublicと宣言することができ、それは、そのクラスが台本のどこからでも利用できることを意味する。さもなければ、そのクラスを含んでいる台本からのみ利用できる（これが既定）。
JavaFX言語は構築子を支援していない。その代わりに、オブジェクト直定数を使用しなければならない。構築子の作用をまねるためには、新たなオブジェクトを返す関数を定義し、その関数を呼び出す。

オブジェクトを定義する
前の章で述べたように、クラス実体化の推奨方法はオブジェクト直定数を使うことである。この形式のオブジェクト割り当ては、クラス名とその後に続く中括弧でくくった属性初期化子の一覧から構成される宣言的構文を用いる。それぞれの初期化子は、属性名に、コロンとその属性の値を定義する式を続けて構成する。しかしながら、オブジェクトを生成する際にnew鍵語を使うこともできる。


   import java.io.File;

   var tmpPath = "/home/users/docs/tmp.txt"
   var myFile = new File("tmp.txt");

3.属性と関数

属性
属性はオブジェクトの状態を定める。それらは、attribute鍵語に、属性名、コロン（任意選択）、属性の型（任意選択）を続け、セミコロンで終結させたものを用いて宣言される。


   attribute 属性名 : 属性型  ;

属性の既定値を宣言することができる（後で、オブジェクト直定数で規定される値に定義しなおすことができる）。初期化子は、新たに生成されるオブジェクトの状況に即して、クラス宣言内で属性が指定された順に評価される。


   import java.lang.System;

   class X {
       attribute a: Number = 10;
       attribute b: Number = -1;
   }

   var x = X { };
   System.out.println(x.a); // 10.0を表示する
   System.out.println(x.b); // -1.0を表示する

明示的な初期化が行われないと、それぞれの属性は妥当な既定値に設定される。


   import java.lang.System;

   class DefaultValuesDemo {
       attribute a: Number;
       attribute b: Integer;
       attribute c: Boolean;
       attribute d: String;
   }

   var demo = DefaultValuesDemo {};
   System.out.println("Default Value: " + demo.a);
   System.out.println("Default Value: " + demo.b);
   System.out.println("Default Value: " + demo.c);
   System.out.println("Default Value: " + demo.d);

上記コードは、次の既定値を画面に表示する（注記：最後の行は、空文字列を表示する）。


   Default Value: 0.0
   Default Value: 0
   Default Value: false
   Default Value:

データ型は、第4章で取り上げられている。

関数
関数はオブジェクトの振る舞いを定める。関数は次の形式を取る。


   function 関数名 (属性名 : 属性型, ...): 戻り型 本体

ここで、本体は任意の式でかまわない。
関数は第一級オブジェクトである（たとえば、変数に割り当てたり、引数としてほかの関数へ渡すことができる）。
第1章で、何も引数を取らず、そして何も値を返さないgrow関数を定義している簡単な例を示した。


   ...

   function grow(): Void {
       grow(1);
   }

   ...

その例証では、利用者が特定の寸法を指定できるようにした、関数の多重定義版も与えた。


   ...

   function grow(amount: Integer): Void {
       width += amount;
       height += amount;
   }

   ...

関数は、無名関数にもなりうる。無名関数は、GUI構成部品のaction属性に振る舞いを割り当てる際に、しばしば利用される。


   // GUIにおいて

   ...

   action: function() {
       System.out.println("Click!");
   }

   ...

4.変数と基本データ型

変数
第1章で論じたように、var鍵語は、新たな変数をプログラムに導入するために用いられる。変数の型は、それを宣言する際に指定してもよいが、指定は任意選択である。宣言から変数の型が省略されると、その型は変数の用いられ方からを推測することができる。
変数宣言は、次の形式を取る。


   var 変数名 : 型 = 初期化子;

例：


   var num = 1; // 推測された型
   var num : Number = 2;
   var firstName = "John"; // 推測された型
   var lastName : String = "Doe";

変数の命名法の慣例は、Java言語における慣例と同一である。クラス名は、各単語の最初の文字を大文字にする（MyClass）。関数名は小文字で始まるが、後に続く各単語の最初の文字は大文字にする（myFunctionName）。定数は、下線文字で区切られた単語により、すべて大文字で表されなければならない（MY_CONSTANT）。
二重山括弧<<>>で閉じられた（空白文字を含む）いかなる文字列も、識別子として扱われる。これにより、JavaFX言語の鍵語（または、ほかの通常では不正な識別子）を、クラス、変数、関数、または属性の名前として用いることができる。
例：


   var <<delete>> = 100;

また、JavaFX言語の鍵語と同じ名前の（Java言語で書かれた）操作を呼び出すこともできる。


   import javax.swing.JTextArea;

   var textArea = new JTextArea();
   textArea.<<insert>>("Hello", 0);

変数の存続期間は、少なくとも、それを含むコード区画の存続期間と同じである。

基本データ型
JavaFX言語では、原始型（プリミティブ型）という用語は使わない。代わりに、5つの基本データ型を定義しており、応用コードで常に利用することができる。
5つの基本データ型は、次のようにJava言語に対応付けられる。


               表 4.1  基本データ型
   JavaFX言語                      Java言語
   String                          java.lang.String
   Boolean                         java.lang.Boolean
   Number                          java.lang.Number
   Integer                         byte,short,int,long,BigInteger
   Duration                        該当なし

最初の4つのデータ型は、Java言語でもしばしば使われるので、ほとんどの開発者には既になじみのあるものであろう。しかし、Duration型はこれまでになく、JavaFX言語に特有のものである。javafx.lang.Durationクラスは、時間の単位（ミリ秒、秒、分、または時間）を表す。Durationクラスを実体化するための簡略表現である、時間直定数も支援している。


   5ms; // 5ミリ秒
   10s; // 10秒
   30m; // 30分
   1h;  // 1時間

整数を表す型については、引数または戻り値をJava言語で書かれた操作と受け渡しするときに、自動的に強制型変換が行われる。
文字列に関しては、一重引用符または二重引用符のいずれかを用いて文字列直定数を指定することができる。


   var s1 = 'Hello';
   var s2 = "Hello";

一重引用符と二重引用符は対称性を持っている。一重引用符を二重引用符の中に埋め込むことができるし、二重引用符を一重引用符の中に埋め込むこともできる。どちらにも、中括弧「{}」を用いて式を埋め込むことができる。


   var name = 'Joe';
   var s = "Hello {name}"; // s = 'Hello Joe'

埋め込まれた式自体が引用符で囲まれた文字列を含むことができるので、次々に、さらなる埋め込み式を含むことができる。


   var answer = true;
   var s = "The answer is {if (answer) "Yes" else "No"}";
           // s = 'The answer is Yes'

Java言語と異なり、JavaFX言語の文字列直定数は、改行文字を含むことができる。
文字列式に付加的な書式設定接頭辞を与えることにより、数値と日付をどのように文字列に変換するかについても制御することができる。この付加的な書式設定接頭辞は、java.util.Formatterの仕様に従う。


   import java.util.Date;

   var hexStr = "hex of 13 is 0x{%02X 13}";
   // hexStr = "hex of 13 is 0x0D"       
   var date = new Date(107, 10, 11);
   var dateStr = "{%tc date}"; 
   // dateStr = "日 11 11 00:00:00 JST 2007"

訳注：原文では、「var dateStr = "{%tc date}";」文末のセミコロン（;）が抜け落ちている。また、日本では、日付は上記コメントの書式で表示される。

5.式と演算子

式
Java言語と異なり、JavaFX言語は式言語である。すべての実行文は、0個以上の入力とそれに続く0個（または1個）の出力から構成される式である。これには、条件、繰り返し、およびコード区画も含まれる。
次に実例を示す。


   import java.lang.Math;
   import java.lang.System;

   var rand = (Math.random() * 100).intValue();
   var s:String = null;
   if (rand mod 2 == 0) {
       s = "rand is even"
   } else {
       s = "rand is odd"
   };

   System.out.println(s);

訳注：原文では、剰余演算子として「%」を使用しているが、表 5.1に載っているように、これは「mod」に変わっている。したがって、上記のコード例もmodで書き換えている。

区画式
区画式は、中括弧で囲まれた、セミコロン区切り文（宣言または式でもよい）の羅列から構成される。（区画内の）最後の文が式なら、その式の値が区画式の値となる。さもなければ、区画式はvoid型となる。
次の区画式は、数個の数を加え、その結果をtotalという名前の変数に格納する。


   import java.lang.System;

   var nums = [5, 7, 3, 9];
   var total = {
       var sum = 0;
       for (a in nums) { sum += a };
       sum;
   }

   System.out.println("Total is {total} ");

値域式
値域式は、次の構文により、等差数列を形成している数値の列を定める。


   [数1..数2]

上記の式は、数1から数2までの整数（両端含む）からなる列を定める。
値域式の簡単な例は、次のようなものであろう。


   import java.lang.System;

   var nums = [0..3];
   System.out.println(nums == [0,1,2,3]); // trueと表示する

既定では各数値間の刻み幅は1だが、異なる刻み幅を指定することもできる。たとえば、次の式は、1から10の間の奇数からなる列を定める。


   [1..10 step 2]

降順に並んだ値域を生成するためは、終了値が開始値より小さいことを確認し、負数の刻み幅を指定する。


   import java.lang.System;

   var nums = [3..0 step -1];
   System.out.println(nums == [3,2,1,0]); // trueと表示する

次の宣言文は、実際には空の列を宣言することに留意せよ。


   var nums1 = [3..0 ];
   var nums2 = [3..0 step 1];

条件式
if式は、Java言語におけるifと似ている。


   if (condition1) {
       System.out.println("Condition 1");
   } else if (condition2) {
       System.out.println("Condition2");
   } else {
       System.out.println("not Condition 1 or Condition 2");
   }

Java言語は、if式と条件式（たとえば、a < b ? a : b）の両方を含んでいる。JavaFX言語のif式は、その両者に代わるものである。

繰り返し式
for式
for式は列とともに用いられるので、第7章で論じる。

while式
while式はJava言語の場合と同様であるが、whileの本体を囲む中括弧が常に必要である。
例：


   import java.lang.System;

   var i = 0;
   while (i < 10) {
       if (i > 5) {
           break;
       }
       System.out.println("i = {i}");
       i += 1;
   }

そのほかの式
return式は、Java言語において見られるものと同一である。


   function add(x, y) {
       return x + y;
   }

throw式は、Java言語のものと似ているが、java.lang.Throwableを拡張したオブジェクトだけが投げられたり捕捉されたりできる。


   import java.lang.Exception;

   function foo() {
       throw new Exception("this is a java exception");
   }

   function bar() {
       throw "just a string";
   }

try式とcatch式は、Java言語のものと似ているが、JavaFX言語の変数宣言の構文を用いる。


   try {
       throw "Hello";
   } catch (s:String) {
       System.out.println("caught a String: {s}");
   } catch (any) {
       System.out.println("caught something not a String: {any}");
   } finally {
       System.out.println("finally...");
   }

break式とcontinue式は、Java言語のものと似ているが、ラベルは支援されていない。
例：


   import java.lang.System;

   function foo() {
       for (i in [0..10]) {
           if (i > 5) {
               break;
           }
           if (i mod 2 == 0) {
               continue;
           }
           System.out.println(i);
       }
   }

   function bar() {
       var i = 0;
       while (i < 10) {
           if (i > 5) {
               break;
           }
           if (i mod 2 == 0) {
               continue;
           }
           System.out.println(i);
           i += 1;
       }
   }

演算子
JavaFX言語は、Java言語にみられるものと同様の標準的な演算子を提供する。次の表は、Java言語における等価演算子と比較させながら、優先順位に従ってそれらの演算子を一覧表にしたものである。


                        表 5.1  演算子の優先順位
   優先度  JavaFX演算子    演算                Java演算子    評価順序
   1       function()      JavaFX関数
           ()              括弧内の式
           new             オブジェクト生成
           {オブジェクト   オブジェクト生成
             直定数}         と初期化
   2       ++ (後置)       1増後代入           ++            右から左
           -- (後置)       1減後代入           --
   3       ++ (前置)       1増前代入           ++            右から左
           -- (前置)       1減前代入           --
           not             論理否定
           sizeof          列の要素数
           reverse         列の反転
           indexof         列要素の索引
  
  
   4       *               乗算                *             左から右
           /               除算                /
           mod             剰余                %
   5       +               加算                +             左から右
           -               減算                -
   6       ==              等価                ==            左から右
           !=              不等価              !=
           <               小なり              <
           <=              以下                <=
           >               大なり              >
           >=              以上                >=
   7       instanceof      型検査              instanceof
           as              型変換
   8       or              論理OR              ||            右から左
   9       and             論理AND             &&            右から左
   10      +=              加算代入            +=
           -=              減算代入            -+
           *=              乗算代入            *=
           /=              除算代入            /=
           %=              剰余代入            %=
   11      =               代入                =

例：


   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); // falseを表示する
   System.out.println(x != y); // trueを表示する
   System.out.println(x < y);  // trueを表示する
   System.out.println(x > y);  // falseを表示する
   System.out.println(x >= y); // falseを表示する
   System.out.println(x <= y);  // trueを表示する
   System.out.println(x + y);  // 6を表示する
   System.out.println(x - y);  // -2を表示する
   System.out.println(x * y);  // 8を表示する
   System.out.println(x / y);   // 0を表示する
   System.out.println(x mod y);   // 2を表示する
   System.out.println(a and b); // falseを表示する
   System.out.println(a or b);  // trueを表示する
   System.out.println(not a);  // falseを表示する
   System.out.println(sizeof [x,y]); // 2 を表示する
   System.out.println([x,y][e | indexof e == 0]); // [ 2 ]を表示する
   System.out.println(if (a) x else y); // 2を表示する
   System.out.println(for(q in [x, y] where q < 3) q); // [ 2 ]を表示する
   System.out.println(Math.max(x, y)); // 4を表示する
   System.out.println("abc".toUpperCase()); // ABCを表示する
   System.out.println(x); // 2を表示する

訳注：原文で使用している「<>」演算子と「%」演算子は、それぞれ、「!=」と「mod」に書き換えた。

6.列を宣言する
先に述べた5つの基本データ型に加え、JavaFX言語は、「列」として知られたデータ構造を提供する。列はJava言語の配列に似ているが、異なる点もある。
次のコードはいくつかの例を示す。


   var weekDays = ["Mon","Tue","Wed","Thur","Fri"];
   var days = [weekDays, ["Sat","Sun"]];

列は、オブジェクトの順序付けられた一覧を表す。しかしながら、列そのものはオブジェクトではないため、入れ子構造を取ることはできない。列は、値により等価であるとみなされる。列の長さが等しく、かつそれらの要素が同一であるとき、列は等しい。（上記のdaysの初期化におけるように）入れ子になった列を形成する式は、自動的に平準化される。


   days == ["Mon","Tue","Wed","Thur","Fri","Sat","Sun"]; // trueを返す

さらに、単一のオブジェクトは、1つのオブジェクトからなる列に等価である。


   1 == [1]; // trueを返す

列の型は、「[]」注釈を用いて宣言される。


   var xs:Number[]; // 数の列
   var strs:String[]; // 文字列の列

列の要素は共通の型を持たねばならず、その型はオブジェクトであっても良い。列は、Java言語の配列のように、索引付けることがきる。


   var wednesday = days[2];

次の例のように、その要素が等差数列をなしている列に対する「..」を用いた簡便な表記法もある。


   var nums = [1..100];

この簡略記法により、各要素を手入力する必要がなくなる。
[]演算子は、述語形式の選択も表す。述語は、次の形式を取る。


   列[変数名| 論理式]

例：


   var nums = [1,2,3,4];
   var numsGreaterThanTwo = nums[n|n > 2];

この手の式は、元の列の要素の内、述部の条件を満たすものから構成される新たな列を返す。
最後になったが、部分列は、列の一部を利用できるようにする。


   seq[a..b]  // 索引aとbの間（両端含む）の列
   seq[a..<b] // 索引a（含む）とb（含まない）の間の列
   seq[a..]  // seq[a..<sizeof seq]に同じ
   seq[a..<] // 一貫性を保つため、seq[a..<sizeof seq-1] に同じ

次の章で述べるように、いくつもの異なる方法で、列または部分列を利用および／または変更することができる。

7.列を利用する

forを用いた列の繰り返し
JavaFX言語は、for演算子を用いた列内包を支援する。列内包は、1つ以上の入力列、任意選択としてのろ過器、および式から構成される。各入力列は変数と関連している。列内包の結果は、元となる列の要素の組み合わせの内で、ろ過器の条件を満たすものに、式を適用した結果であるところの新たな列である。
次のプログラムはこの構文の実例を示したもので、曲集の一覧から曲の一部が表題となっているものを特定するためにfor演算子を用いている。


   class Album {
       attribute title: String;
       attribute artist: String;
       attribute tracks: String[];
   }

   var albums =
       [Album {
           title: "A Hard Day's Night"
           artist: "The Beatles"
           tracks:
               ["A Hard Day's Night",
                "I Should Have Known Better",
                "If I Fell",
                "I'm Happy Just To Dance With You",
                "And I Love Her",
                "Tell Me Why",
                "Can't Buy Me Love",
                "Any Time At All",
                "I'll Cry Instead",
                "Things We Said Today",
                "When I Get Home",
                "You Can't Do That"]
       },
       Album {
           title: "Circle Of Love"
           artist: "Steve Miller Band"
           tracks:
               ["Heart Like A Wheel",
                "Get On Home",
                "Baby Wanna Dance",
                "Circle Of Love",
                "Macho City"]
       }];

   for (album in albums, track in album.tracks)  {
       if (album.title == track)
           java.lang.System.out.println("TITLE TRACK = {track}")
       else
           java.lang.System.out.println("Track = {track}")
   }

出力：
TITLE TRACK = A Hard Day's Night
Track = I Should Have Known Better
Track = If I Fell
Track = I'm Happy Just To Dance With You
Track = And I Love Her
Track = Tell Me Why
Track = Can't Buy Me Love
Track = Any Time At All
Track = I'll Cry Instead
Track = Things We Said Today
Track = When I Get Home
Track = You Can't Do That
Track = Heart Like A Wheel
Track = Get On Home
Track = Baby Wanna Dance
TITLE TRACK = Circle Of Love
Track = Macho City

次に示すのは、ろ過器を用いた別の例である。これは、数を受け取ってその因数の一覧を返す関数を定義したものである。


   function factors(n:Number) {
       return for (i in [1 .. n/2] where n mod i == 0) i;
   }

訳注：原文の「%」演算子を、「mod」に書き換えた。

forの内包の中で、indexof演算子を用いることができる。その構文は「indexof 名称」で、「名称」は繰り返し変数の名前である。その値は、基となる列における繰り返しの「索引」値である。
次の例に示したように、indexof演算子は列の抽出に使用することもできる。


   var nums = [1..5];
   var numsExceptTheFirstTwo = nums[n|indexof n > 1]; // [ 3, 4, 5 ]を返す

列変数を変更する
insertは、列に新たな要素を挿入する。


   insert x into seq
   insert x before seq[idx]
   insert x after seq[idx]

deleteは、列から要素を取り除く。


   delete seq
   delete x from seq
   delete seq[idx]
   delete seq[a..b]

次のコードは、挿入と削除の双方の例である。


   // 挿入の例

   var nums = [1..5];
   var x = 6;
   insert x into nums; // 結果は、[ 1, 2, 3, 4, 5, 6 ]
   x++;
   insert x before nums[0]; // 結果は、[ 7, 1, 2, 3, 4, 5, 6 ]
   x++;
   insert x after nums[3]; // 結果は、[ 7, 1, 2, 3, 8, 4, 5, 6 ]

   // 削除の例

   nums = [1..5];
   delete 2 from nums; // 結果は、[ 1, 3, 4, 5 ]
   delete nums[0];// 結果は、[ 3, 4, 5 ]
   nums = [1..10]; // 結果は、[ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]
   delete nums[3..7]; // 結果は、[ 1, 2, 3, 9, 10 ]
   delete nums; // 結果は、[ ]
   nums = [1..10];
   delete nums[5..]; // 結果は、[ 1, 2, 3, 4, 5 ]
   delete nums[0..<]; // 結果は、[ 5 ]

訳注：原文では、最後の「delete nums[0..<];」文が「delete nums[0..>];」と誤記されている。

列の要素を逆順に並べ替えることもできる。


   var nums = [1..5];
   reverse nums; // [ 5, 4, 3, 2, 1 ]を返す

訳注：2008年7月23日時点のNetBeans 6.1用JavaFX追加接続（Plugin）プログラムで動作確認したところ、「reverse nums;」だけでは、元のnums の要素の並びは変わらなかった（並び替えた結果を利用するためには、「nums = reverse nums;」のように列変数に代入しなおす必要がある。その意味では、delete演算子とは用法が異なる）。

8.データ結合
bind鍵語は、対象となる変数の値を別の変数の値に結びつける。


   let x = bind someExpression;

これは、someExpressionの結果を変数xに結びつける。someExpressionの値が変わると、xの値も自動的に更新される。結び付けられる変数は、ある基本データ型の単純な値、式の結果、区画式の結果、もしくは結合関数でもよい（let鍵語は、それらに割り当てることができない変数を導入する）。

再計算して更新する
ある状況では、更新がどのように行われるか、あるいはsomeExpressionが変化することはどういう意味なのかを厳密に知っている必要ある。結び付けられる値が変化すると、最小限の再計算が実行される。この再計算は、ある限られた状況において問題になるだけである。たとえば、オブジェクトの生成を必要とする結合が実行される場合で、オブジェクトの同一性の理由から、新たなオブジェクトが実際に生成されたかどうかが問題となるような場合である。


   let sum = bind expr1 + expr2;

expr2が変化するとsumは再計算されるが、expr1は再計算されない。expr1に対する値はすでに格納されており、単にその値を再度取ってくるだけである。

次に実例を示す。


   import java.lang.System;

   var y = 3;
   function ten() : Integer { 10 }
   let sum = bind ten() + y;
   System.out.println(sum);
   y = 7;
   System.out.println(sum);

このプログラムの出力は次のようになる。


   13
   17

yが7に設定されたとき、関数ten()は変化していないので再度呼び出されることはない。関数値は記憶されており再利用される。

結合と区画式
bindにおいて、区画式の中に存在しうる文は変数宣言だけである。bind内では、（1増および1減を含め）値の割り当ては禁止されていることに留意せよ。したがって、結合区画式は次のような形式を取る。


   bind { var a = expr; var b = expr; var c = expr; expr }

結合された式に対するいかなる変化も更新を引き起こし、その更新は最小限なので、変数は効率的に結合される。while、insertおよびdeleteは式なので、bindの中に現れてはならないことに留意せよ。

結合と条件式
次の例を考えてみよ。


   let x = bind if (condExpr) expr1 else expr2;

condExprが変わると、if式のどちらの分岐が評価されるのかが変わる。expr1またはexpr2に対する変化は、どちらも、他方の式の再計算を引き起こすことはない。

結合とfor式
次の例を考えてみよ。


   let newSeq = bind for (elem in seq) expr;

もしseqが変わっても、それでもseqに残っている要素に対応するnewSeqの要素は、再計算されない。言い換えれば、要素がseqに挿入されると、その要素にexprを適用した結果がnewSeqの相当する位置に挿入され、newSeqのほかの要素は再計算されない。
この例外は、exprがindexof elemを使用しているために、索引の値が変化した要素を更新する必要がある場合であるが、最小限の更新という規定には合致している。


   import java.lang.System;

   var min = 0;
   var max = 3;
   function square(x : Integer) : Integer { x*x }
   let values = bind for (x in [min..max]) square(x);
   System.out.println(values);
   max = 5;
   System.out.println(values);
   min = 1;
   System.out.println(values);
   min = 0;
   System.out.println(values);

この場合、次の再計算が実行される。


   ・0から3の2乗を計算する。
   ・4と5の2乗を計算する（maxが変わっても、0から3の2乗は再計算されない）。
   ・ほかの値は再計算せず、0の2乗を削除する。
   ・0の2乗を戻す。これは、再計算を必要とする。
     この動作は、代わりにinsertやdeleteを用いても同様である。

結合とオブジェクト直定数
オブジェクト直定数は、演算子や非結合関数のように機能する。オブジェクト直定数の引数の


   let pt = bind Point { x: myX  y: myY  }

myXが変わると、JavaFX言語は、新たなPointオブジェクトを生成する。これは、不変オブジェクトに対して予期された振る舞いでもある。
新たなオブジェクトを生成せずに、xの値がmyXの値を追跡するようにするためには、結合が必要になる。


   let pt = bind Point { x: bind myX  y: myY  }

この例に対しては、おそらくyも同様に結合したいと思うだろう。


   let pt = bind Point { x: bind myX  y: bind myY  }

ここで、ptは常に同じPointオブジェクトの実体と結合したままである。それは、最初の結合がなくても同様である。


   let pt = Point { x: bind myX  y: bind myY  }

結合と関数
非結合関数は、bound鍵語が前置されていない関数である。Java言語の操作やJavaFX言語の関数の呼び出しに関して、その引数のいずれかが変更されると、JavaFX言語はその関数を再度呼び出すが、関数の本体は暗箱である。関数が、その入力となる引数以外に持っている依存性により再計算が引き起こされることはない。


   import java.lang.System;

   class Point {
       attribute x : Number;
       attribute y : Number;
   }

   var scale = 1.0;

   function makePoint(x0 : Number, y0 : Number) : Point {
       Point {
           x: x0 * scale
           y: y0 * scale
        }
   }

   var myX = 3.0;
   var myY = 3.0;
   let pt = bind makePoint(myX, myY);
   System.out.println(pt.x);
   myX = 10.0;
   System.out.println(pt.x);
   scale = 2.0;
   System.out.println(pt.x);

出力：


   3.0
   10.0
   10.0

引数myXを変更すると、関数makePointは再度呼び出される。しかし、関数makePointは暗箱である。よって、scaleに割り当てられた値を変更しても、当然ではあろうが、関数は再計算されない。これこそが、結合関数が意図したものである。結合関数は予期された更新を引き起こす。
結合関数は、その本体として、結合された区画式を持っている（それゆえに、結合区画式に関する上述の制限を有している）。結合関数に結びつけると、引数以外の変化も更新を引き起こし、かつ引数の変更も調べられる。上述の関数makePointは結合関数にしてもよい。


   bound function makePoint(x0 : Number, y0 : Number) : Point {

そうすれば、scaleに割り当てられた値の変化は更新（20.0）を引き起こす。myXが変わるとx0 * scaleだけが再計算され、y0 * scaleは再計算されないことに留意せよ。
結合とは別のところで結合関数を呼び出すことは、非結合関数を呼び出すことと同じことである。

9.引き金

置換引き金
置換引き金に対する構文は次のとおりである。


    "on" "replace"
       [旧値]
       [ "[" 最低索引値 ".." 最高索引値 "]" "=" 新要素 ]
       区画

置換引き金は、引き金を取り付けた変数に対するすべての変更の後に呼び出される。構文上の非終端子である旧値、最低索引値、最高索引値、および新要素は、その本体が区画から成る関数に対する事実上の仮引数である。


   ・旧値は変数の事前の値であり、変数と同じ型を持つ。
   ・最低索引値と最高索引値は、旧値の置換対象となる部分の範囲を
     区切る。それらの型はIntegerである。純然たる挿入に対しては、
     「最高索引値==最低索引値-1」である。
   ・新要素は、部分列「旧値[最低索引値..最高索引値]」を
     置き換える値の列である。その型は変数と同じである。

引数「[最低索引値..最高索引値]=新要素」は、引き金が取り付けられた変数が列型であるときのみ許される。
旧値と新要素は非対称であることに留意せよ。旧値は、引き金が取り付けられた変数の事前の値であり、一方、新要素は、変更対象となる要素のみから成る、その変数の新値の部分列である。
置換引金の構文は、部分列の割り当てを思い起こさせるようになっている。たとえば：


   attribute x
           on replace oldVal[lo..hi]=newVals { exp };
   var save = x;
   x[i..j] = y;

すると、oldVal はsaveに、loはiに、hiはjに、そしてnewValsはyに結びつけられた上で、expが評価される。
統合置換引き金は、部分列の割り当てとうまく機能する。たとえば、次のように結合を定義することができる。


   attribute x;
   attribute y = bind x;

これは次と等価である。


   attribute x =
           on replace [i..j]=n
           { y[i..j]=n };
   attribute y = [];

次のように、yがxの写像だとする。


   attribute x;
   attribute y = bind for (xi in x) f(xi);

これは次と等価である。


   attribute x =
           on replace [i..j]=n
           { y[i..j] = for (k in n) f(k) };
   attribute y = [];

列の要素のある範囲を削除または置換すること、もしくは列を一箇所に挿入することは、すべて単一の引き金呼び出しに帰着する。述語条件を満たすすべての要素の削除のような、別の演算のあるものは、複数の引き金呼び出しに分解できるかもしれない。その場合、それぞれの引き金呼び出しから見える状態は一致している。特に、プログラマに可視の状態は、あたかも（たとえば）述語削除が独立な部分列削除演算の組として実装されているかのようである。

10.動画

動画概要
JavaFXは、主こま（齣）動画（key frame animation）を支援する。これは、プログラマが、各場面の動画による状態遷移を、時系列上のある点における状態の断面（主こま）を宣言することにより表現する宣言様式である。JavaFX言語は、主こま動画の2つの基本的な種類、離散と補間を支援する。その違いは、後者では、専用の補間関数がそれぞれの動画のこま間に存在する状態を計算する。どちらの場合も、処理系は自動的に動画を実行し、要求に従って動画を停止、中断、再開、反転、または繰り返す。
高次では、主こま動画は次のように表現することができる。


   ・動画は、javafx.animation.Timelineオブジェクトにより表される
     時系列に沿って再生される。
   ・それぞれの時系列は、javafx.animation.KeyFrameオブジェクト
     により表される2つ以上の主こまを含む。
   ・それぞれの時系列は、それを表現するある種の属性（autoReverse、
     repeatCount、toggle、など）と、再生を制御するいくつかの関数
     （start()、stop()、pause()、およびresume()）を提供する。
   ・それぞれの主こまには、それを含んでいる時系列における相対時刻が
     付随し、それ自身、3つのもの、主値の一覧、従時系列、および
     「引き金」を含む。含まれている従時系列のそれぞれは、主こまの
     主時刻からの相対開始点で評価される。それゆえ、時系列は、
     階層的に構成し、従時系列を含むことができる。従時系列自身、
     同じことを繰り返すことができる。「引き金」は、それが存在すれば、
     主こまで指定された時刻に実行される手続きコードの区画である。
   ・javafx.animation.KeyValueオブジェクトは、ある特性に対し、
     その前の主こまからの相対で「中割り」の値を計算するために
     用いられる関数とともに、主こまのその時刻におけるその特性の
     最終状態を表す。

注記：Timelineオブジェクトは、図式動画とは無関係な、汎用の時間に基づく演算に対しても使用することできる。

離散動画
離散動画では、特定の性質の値が、主こまの時刻に、主こまで与えられた値に瞬時に変化する。たとえば、よく知られた「転げ回るデューク」の動画を考えてみよう。そこでは、動きの錯覚が、一組の画像を単にパラパラめくりすることによりもたらされる。こうした動画は、それぞれの動画のこまの「中間」を計算しないので、「離散的」である。


   import javafx.application.Frame;
   import javafx.application.Stage;
   import javafx.scene.paint.Color;
   import javafx.scene.image.Image;
   import javafx.scene.image.ImageView;
   import javafx.animation.KeyFrame;
   import javafx.animation.Timeline;

   // 画像データを読み込む
   var images = for (i in [1..17]) {
       Image { url: "file:images/T{i}.gif"};
               // 画像は手元に格納されていると仮定する

       // ウェブから画像を読み込むには、代わりに次の行
       // （訳注：原文では1行）を使用する
       // Image {url: "http://java.sun.com/applets/other/
       //         TumblingDuke/images/T{i}.gif"};

   }

   // 最初の画像を設定する
   var currDuke = images[0];


   // 画像を繰り返すための時系列を生成する
   var timeline = Timeline {
       toggle: true
       keyFrames: for (image in images) {
           KeyFrame {
               time: 100ms* indexof image
                       // 各こまは100ms離れる
               action: function(){currDuke=image;}
           }
       }
   }

   Frame {

       title: "Click on Duke!"
       width: 250
       height: 150
       visible: true
       stage: Stage {
           content: ImageView {
               image: bind currDuke;
               onMouseClicked: function(e) {timeline.start();}
           }
       }
   }

最初に、このプログラムは画像を記憶装置に読み込み、現在の画像を表すための変数（currDuke）を生成する。次に、時系列を生成し、いくつかの主こま（画像当たり1つ）を設定する。それぞれの主こまは100 msずつ離れて配置され、その画像をcurrDukeに割り当てる。最後に、GUIはその表示画像をcurrDukeと結合し、応用プログラムが動画のこまを繰り返すにつれて、現在の画像が画面上に表示されることを保証する。

補間動画
動画には、動的に計算しなければならない状態を持っているものもある。次に取り上げる例は、二次元の矩形をその寸法を変えながら回転させ、かつある範囲の表示色を繰り返す。この動画は、動画の経路に沿ったすべての可能な位置に主こまを生成する代わりに、プログラマが数個の主こま（開始、中間、終了）を単に宣言し、処理系にその中間のすべてを計算させるので、補間であるとされる。


   import javafx.application.Frame;
   import javafx.application.Stage;
   import javafx.scene.geometry.Rectangle;
   import javafx.scene.paint.Color;
   import javafx.scene.transform.Transform;
   import javafx.scene.Cursor;
   import javafx.animation.Timeline;
   import javafx.animation.Interpolator;

   Frame {
       title: "Animation Demo";
       width: 500
       height: 400
       visible: true
       stage: Stage {
           content: Rectangle {

               // 変数を宣言する
               var rotation = 0.0;
               var size = 1.0;
               var color = Color.GREEN;

               // 属性を初期化する
               cursor: Cursor.HAND
               height: 50
               width: 50
               fill: bind color
               transform: bind [Transform.translate(100,100),
                       Transform.scale(size,size),
                       Transform.rotate(rotation,25,25)]

               // 動画の時系列を生成する
               var myTimeline = Timeline {

                   toggle: true

                   // 主こま
                   var begin = at (0s) {
                       size => 1.0;
                       color => Color.GREEN;
                       rotation => 0.0;
                   }

                   var mid = at (0.5s) {
                       color => Color.PURPLE
                               tween Interpolator.EASEBOTH;
                   }

                   var end = at (1s) {
                       size => 3.0 tween Interpolator.LINEAR;
                       color => Color.RED
                               tween Interpolator.EASEBOTH;
                       rotation => 360.0
                               tween Interpolator.EASEBOTH;
                   }

                   keyFrames: [begin,mid,end]
               }

               onMouseClicked: function(e) {
                   myTimeline.start();
               }
           }
       }
   }

主こま動画は通常のオブジェクトから生成されるが、作業をより容易にするため、特有の構文、すなわち、=>、tween、およびat演算子が提供されることに留意せよ。この例では、主こまを「at」演算子を用いて生成した。これは、KeyFrameオブジェクトの直定数構築子である。

A.鍵語と予約語
この付録は、JavaFX言語において予約された単語を記録したものである。


                     表 A.1  鍵語と予約語
                         実装済み鍵語
abstract                    attribute     bind          break
class         continue      delete        false         for
function      if            import        init          insert
             new           not           null          package
private                     public                      return
super         sizeof                      this          throw
try           true          var           while         after
and           as            before                      catch
             dur           else          exclusive     extends
finally                                   in            bound
indexof       into          inverse       lazy
on            or            replace       step
with          where         instanceof    override      at
then          tween

                         予約済み鍵語
assert        by            do            first         from
last          let           protected     readonly      typeof
lazy

SCADA UIプログラム例のJavaFX SDK対応書き換え：残り

2008-08-03T18:11:00.008+09:00

SCADA UIプログラム例の残りの部分を、JavaFX SDK対応に書き換えました。
新たな書き換えの要因として、次のものがあります。
・差分が1と異なる列の指定のしかたが、たとえば、[0,20..100]から[0..100 step 20]のように変わった。
・ConfirmDialogがないので、 javafx.application.Dialogに変えた。
SCADA UI構成単位のJavaFXファイルを置き換えて、企画を再構築して実行すると、図のような画面が表示されます。
次に、SCADA UI構成単位のJavaFXファイルを示します。


/*
 * ScadaClientUI.fx
 * An example of a User Interface (UI) module of the client-side
 * Presentation component for a SCADA application.
 *
 * Created and modified:
 * V 1.0.0    2008/08/01
 */

package client;

import javafx.animation.*;
import javafx.application.*;
import javafx.scene.*;
import javafx.scene.geometry.*;
import javafx.scene.paint.*;
import javafx.scene.text.*;
import java.lang.System;
import client.ScadaClientControl;

/**
 * @author terra
 */

var scc: ScadaClientControl = new ScadaClientControl();

/*
 * A control compenent for SCADA Data in the UI module.
 */
class ScadaDataControl {
  attribute newNumericDatum: Number;
  attribute numericData: Number[] = for (i in [0..180]) 0.0;
  attribute alarting: Boolean;
  attribute schedular: Timeline = Timeline{
    repeatCount: Timeline.INDEFINITE
    keyFrames: KeyFrame {
      time: 200ms
      action: function(): Void {
        newNumericDatum = scc.receiveData();
        delete numericData[0];
        insert newNumericDatum into numericData;
        if (newNumericDatum > 90.0 and not alarting) {
          alarting = true;
          scc.startAlarm();
          Dialog {
            title: "Alarm"
            width: 300, height: 60
            visible: true
            closeAction: function() {
              scc.stopAlarm();
              alarting = false;
            }
            stage: Stage {
              content: Text {
                x: 10, y: 10
                textOrigin: TextOrigin.TOP
                fill: Color.RED
                font: Font {size: 14}
                content: "Flow rate exceeded the second upper limit!"
              }
            }
          }
        }
      }
    }
  }
  function getDisplayColor(value: Number): Color {
    var c: Color = Color.GREEN;
    if (value > 90.0) {
      c = Color.RED;
    } else if (value > 75.0) {
      c = Color.color(1.0, 0.6, 0.0);
    }
    return c;
  }
}

var sdc = ScadaDataControl {};
sdc.schedular.start();

Frame {
  title: "SCADA UI Example"
  width: 800, height: 632
  visible: true
  closeAction: function(): Void {System.exit(0);}
  stage: Stage {
    width: 800, height: 600
    fill: Color.color(0.9, 0.9, 0.9)
    content: [
      Group {
        translateX: 50, translateY: 50
        content: [
          Rectangle {
            width: 55, height: 18
            arcWidth: 4, arcHeight: 4
            stroke: Color.BLUE, fill: Color.WHITE
          },
          Text {
            x: 4, y: 5
            textOrigin: TextOrigin.TOP
            fill: bind sdc.getDisplayColor(sdc.newNumericDatum)
            font: Font {
              name: "Monospaced", size: 14, style: FontStyle.PLAIN
            }
            content: bind "{%7.2f sdc.newNumericDatum}"
          },
          Text {
            x: 60, y: 6
            textOrigin: TextOrigin.TOP
            font: Font {
              name: "Monospaced", size: 14, style: FontStyle.PLAIN
            }
            content: "m3/s"
          }
        ]
      },
      Group {
        translateX: 200, translateY: 50
        content: [
          Rectangle {
            width: 60, height: 120
            stroke: Color.BLUE, fill: Color.WHITE
          },
          Rectangle {
            x: 10, y: 10
            width: 10, height: 100
            fill: LinearGradient {
              startX: 0.0, startY: 0.0
              endX: 0.0, endY: 1.0
              stops: [
                Stop {offset: 0.05, color: Color.RED},
                Stop {offset: 0.0875, color: Color.color(1.0, 0.6, 0.0)},
                Stop {offset: 0.125, color: Color.LIMEGREEN},
              ]
            }
          },
          Rectangle {
            x: 10, y: 10
            width: 10, height: bind 50 - sdc.newNumericDatum / 2
            fill: Color.BLACK
          },
          Line {
            startX: 23, startY: 10
            endX: 23, endY: 110
            stroke: Color.BLACK
          },
          Group {
            translateX: 23, translateY: 10
            content: for (i in [-100..100 step 50]) Line {
              translateY: i / 2 + 50
              startX: 0, startY: 0
              endX: 3, endY: 0
              stroke: Color.BLACK
            }
          },
          Group {
            translateX: 32, translateY: 10
            content: for (i in [-100..100 step 50]) Text {
              translateY: 53 - i / 2
              content: "{i}"
              font: Font {
                name: "Monospaced", size: 10, style: FontStyle.PLAIN
              }
              horizontalAlignment: HorizontalAlignment.LEADING
              verticalAlignment: VerticalAlignment.TOP
            }
          }
        ]
      },
      Group {
        translateX: 50, translateY: 200
        content: [
          Rectangle {
            width: 230, height: 120
            stroke: Color.BLUE, fill: Color.WHITE
          },
          Rectangle {
            x: 10, y: 22
            width: 181, height: 88
            fill: Color.BLACK
          },
          Rectangle {
            x: 10, y: 15
            width: 181, height: 7
            fill: Color.GRAY
          },
          Rectangle {
            x: 10, y: 10
            width: 181, height: 5
            fill: Color.DARKGRAY
          },
          Line {
            startX: 194, startY: 10
            endX: 194, endY: 110
            stroke: Color.BLACK
          },
          Group {
            translateX: 194, translateY: 10
            content: for (i in [-100..100 step 50]) Line {
              translateY: i / 2 + 50
              startX: 0, startY: 0
              endX: 3, endY: 0
              stroke: Color.BLACK
            }
          },
          Group {
            translateX: 203, translateY: 11
            content: for (i in [-100..100 step 50]) Text {
              translateY: 53 - i / 2
              content: "{i}"
              font: Font {
                name: "Monospaced", size: 10, style: FontStyle.PLAIN
              }
              horizontalAlignment: HorizontalAlignment.LEADING
              verticalAlignment: VerticalAlignment.TOP
            }
          },
          Group {
            translateX: 10, translateY: 10
            content: for (i in [0..179]) Line {
              translateX: i
              startX: 0, startY: bind 50 - sdc.numericData[i] / 2
              endX: 1, endY: bind 50 - sdc.numericData[i + 1] / 2
              strokeWidth: 2
              stroke: bind sdc.getDisplayColor(sdc.numericData[i + 1])
            }
          }
        ]
      }
    ]
  }
}

SCADA UIプログラム例のJavaFX SDK対応書き換え：数値指示計

2008-08-02T15:49:00.019+09:00

次に、SCADA UIプログラムの例を、JavaFX SDK対応に書き換えてみます。今回は、数値指示計の部分を書き換えました。
逐次解釈型では、Textオブジェクトで「%m.nf」形式の書式付き出力を行うと、頭の空白文字が無視されという不備な点がありましたが、それは修正されています。
NetBeansで、JavaFX企画を作成し、SCADA UI構成単位のJavaFXファイルと依頼機を模擬する制御構成単位のJavaファイルを作成し、警報音源ファイルを置いて、企画を構築して実行すると、図のような数値指示計の画面が表示されます。
次に、SCADA UI構成単位のJavaFXファイルを示します。


/*
 * ScadaClientUI.fx
 * An example of a User Interface (UI) module of the client-side Presentation
 * component for a SCADA application.
 *
 * Created and modified:
 * V 1.0.0    2008/08/01
 */

package client;

import javafx.animation.*;
import javafx.application.*;
import javafx.scene.*;
import javafx.scene.geometry.*;
import javafx.scene.paint.*;
import javafx.scene.text.*;
import java.lang.System;
import client.ScadaClientControl;

/**
 * @author terra
 */

var scc: ScadaClientControl = new ScadaClientControl();

/*
 * A control compenent for SCADA Data in the UI module.
 */
class ScadaDataControl {
  attribute numericData: Number;
  attribute schedular: Timeline = Timeline{
   repeatCount: Timeline.INDEFINITE
   keyFrames: KeyFrame {
     time: 200ms
     action: function(): Void {
       numericData = scc.receiveData();
     }
   }
  }
  function getDisplayColor(value: Number): Color {
    var c: Color = Color.GREEN;
    if (value > 90.0) {
      c = Color.RED;
    } else if (value > 75.0) {
      c = Color.color(1.0, 0.6, 0.0);
    }
    return c;
  }
}

var sdc = ScadaDataControl {};
sdc.schedular.start();

Frame {
  title: "SCADA UI Example"
  width: 800, height: 632
  visible: true
  closeAction: function(): Void {System.exit(0);}
  stage: Stage {
   width: 800, height: 600
   fill: Color.color(0.9, 0.9, 0.9)
   content: [
     Group {
       translateX: 50, translateY: 50
       content: [
         Rectangle {
           width: 55, height: 18
           arcWidth: 4, arcHeight: 4
           stroke: Color.BLUE, fill: Color.WHITE
         },
         Text {
           x: 4, y: 5
           textOrigin: TextOrigin.TOP
           fill: bind sdc.getDisplayColor(sdc.numericData)
           font: Font {name: "Monospaced", size: 14, style: FontStyle.PLAIN}
           content: bind "{%7.2f sdc.numericData}"
         },
         Text {
           x: 60, y: 6
           textOrigin: TextOrigin.TOP
           font: Font {name: "Monospaced", size: 14, style: FontStyle.PLAIN}
           content: "m3/s"
         }
       ]
     }
   ]
  }
}

また、模擬依頼機制御構成単位のJavaファイルを示します。


/*
 * ScadaClientControl.java
 * An example of the client-side Control component for a SCADA application.
 *
 * Created and modified:
 * V 1.0.0    2008/07/31
 */

package client;

import java.applet.Applet;
import java.applet.AudioClip;
import javax.swing.JOptionPane;

/**
 * @author terra
 */

public class ScadaClientControl {
  private AudioClip ac = Applet.newAudioClip(
     ScadaClientControl.class.getResource("ALERT.WAV"));
  private int i = -1;

  /**
   * Create and return pseudo SCADA data as if received from a server.
   */
  public double receiveData() {
   i += 1;
   if (i >= 360) {
     i = 0;
   }
   return (double) Math.sin(i * Math.PI / 180) * 100;
  }

  /**
   * Start sounding the alarm.
  */
  public void startAlarm() {
    ac.loop();
  }

  /**
   * Stop sounding the alarm.
   */
  public void stopAlarm() {
    ac.stop();
  }

  /**
   * Main method for testing this class.
   *
   * @param args the command line arguments
   */
  public static void main(String[] args) {
    ScadaClientControl scc = new ScadaClientControl();

    for (int i = 0; i < 5; i++) {
      System.out.println(scc.receiveData());
    }

    scc.startAlarm();
    JOptionPane.showMessageDialog(null, "Alarm is sounding！", "Alarm test",
        JOptionPane.WARNING_MESSAGE);
    scc.stopAlarm();
  }
}

目覚まし時計プログラムをJavaFX SDK対応に書き換える

2008-07-30T18:12:00.006+09:00

以前に投稿した、目覚まし時計プログラムをJavaFX SDK対応に書き換えてみました。
JavaFX SDKのAPI文書に、Spinnerクラスが見つからなかったので、Sliderクラスに置き換えてみました。また、パッケージ名を「timer」から「clock」に変更しています。
NetBeansで、JavaFX企画を作成し、目覚まし時計プログラムの本体JavaFXファイルと警報鳴動Javaファイルを作成し、警報音源ファイルを置いて、企画を構築して実行すると、図のような画面が表示されます。
次に、本体の目覚まし時計JavaFXファイルを示します。


package clock;

import javafx.animation.Timeline;
import javafx.animation.KeyFrame;
import javafx.application.Frame;
import javafx.application.Stage;
import javafx.ext.swing.BorderPanel;
import javafx.ext.swing.Button;
import javafx.ext.swing.Canvas;
import javafx.ext.swing.FlowPanel;
import javafx.ext.swing.GridPanel;
import javafx.ext.swing.Label;
import javafx.ext.swing.Slider;
import javafx.ext.swing.SwingFrame;
import javafx.ext.swing.Slider;
import javafx.ext.swing.TextField;
import javafx.scene.Font;
import javafx.scene.FontStyle;
import javafx.scene.Group;
import javafx.scene.HorizontalAlignment;
import javafx.scene.VerticalAlignment;
import javafx.scene.geometry.Circle;
import javafx.scene.geometry.Line;
import javafx.scene.geometry.Rectangle;
import javafx.scene.layout.VBox;
import javafx.scene.Orientation;
import javafx.scene.paint.Color;
import javafx.scene.text.Text;
import javafx.scene.transform.Translate;
import javafx.scene.transform.Rotate;

import java.lang.Math;
import java.lang.System;
import java.util.Date;

import clock.Sound;

public class Alarm {
 private attribute elapsed: Number;
 public attribute seconds: Integer = 0;
 public attribute minutes: Integer = 0;
 public attribute hours: Integer = 0;
 public attribute count: Number = 0;
 public attribute startTime: Number;
 public attribute elapsedTime: Number;
 public attribute remainingTime: Number;
 public attribute alarmEnabled: Boolean = false;
 public attribute running: Boolean = false on replace {
   if ((alarmEnabled == true) and (remainingTime <= 0)) {
     alarmEnabled = false;
     Sound.alarm();
   }
 };
 public attribute timer: Timeline = Timeline {
   repeatCount : Timeline.INDEFINITE
   keyFrames : KeyFrame {
     time: 1s
     action: function(): Void {
       var now = new Date();
       elapsedTime = now.getTime() / 1000 - startTime;
       remainingTime = count - elapsedTime;
       seconds = remainingTime mod 60 as Integer;
       minutes = (remainingTime / 60) mod 60 as Integer;
       hours = (remainingTime / 60) / 60 as Integer;
       if (elapsedTime >= count) {
         timer.stop();
         running = false;
         hours = 0;
         minutes = 0;
         seconds = 0;
       } else {
         running = true;
       }
     }
   }
 };
}

SwingFrame {
 var alarm = Alarm {}
 title: "Alarm Clock"
 width: 250
 height: 350
 visible: true
 closeAction: function(): Void {
   System.exit(0);
 }
 content: BorderPanel {
   center: Canvas {
     content: Group {
       var font = Font {
         name: "Dialog"
         style: FontStyle.PLAIN
         size: 15
       };
       var secs: Number = bind alarm.seconds
       var mins: Number = bind alarm.minutes + secs / 60
       var hrs: Number = bind alarm.hours + mins / 60
       content: [
         Rectangle {
           width: 250, height: 215
           fill: Color.color(0.9, 0.9, 0.9)
         },
         Circle {
           centerX: 120, centerY: 90, radius: 80
           fill: Color.WHITE, stroke: Color.BLACK
           strokeWidth: 1},
         Group {
           transform: Translate {x: 120, y: 100}
           content: for (i in [1..12]) Text {
             var radians = Math.toRadians(30 * i - 90)
             transform: Translate {x: 70 * Math.cos(radians),
                 y: 70 * Math.sin(radians)}
             content: "{i}"
             horizontalAlignment: HorizontalAlignment.CENTER
             verticalAlignment: VerticalAlignment.CENTER
           }
         },
         Group {
           transform: [Translate {x: 120, y: 90}]
           var hourHand = Line {
             startX: 0, startY: 0, endX: 0, endY: -35,
             strokeWidth: 4, stroke: Color.BLACK
             transform: bind Rotate {angle: hrs * 30, x: 0, y: 0}
           }
           var minuteHand = Line {
             startX: 0, startY: 0, endX: 0, endY: -55,
             strokeWidth: 2, stroke: Color.BLUE,
             transform: bind Rotate {angle: mins * 6, x: 0, y: 0}
           }
           var secondHand = Line {
             startX: 0, startY: 0, endX: 0, endY: -75,
             strokeWidth: 1, stroke: Color.RED,
             transform: bind Rotate {angle: alarm.seconds * 6, x: 0, y: 0}
           }
           content: [hourHand, minuteHand, secondHand]
         },
         Circle {
           centerX: 120, centerY: 90, radius: 3
           fill: Color.BLACK, stroke: Color.BLACK
         }
       ]
     },
   }
   bottom: GridPanel {
     rows: 4
     columns: 1
     content: [
       FlowPanel {
         background: Color.WHITE
         content: [
           Slider {
             minimum: 0, maximum: 11
             value: bind alarm.hours with inverse
             enabled: bind not(alarm.running)
           },
           Label {
             enabled: bind not(alarm.running)
             text: "hour"
           }
         ]
       },
       FlowPanel {
         background: Color.WHITE
         content: [
           Slider {
             minimum: 0, maximum: 59
             value: bind alarm.minutes with inverse
             enabled: bind not(alarm.running)
           },
           Label {
             enabled: bind not(alarm.running)
             text: "min "
           }
         ]
       },
       FlowPanel {
         background: Color.WHITE
         content: [
           Slider {
             minimum: 0, maximum: 59
             value: bind alarm.seconds with inverse
             enabled: bind not(alarm.running)
           },
           Label {
             enabled: bind not(alarm.running)
             text: "sec "
           }
         ]
       },
       FlowPanel {
         background: Color.WHITE
         hgap: 40
         content: [
           Button {
             enabled: bind alarm.running
             text: "Stop"
             action: bind function(): Void {
               alarm.running = false;
               alarm.timer.stop();
             }
           },
           Button {
             enabled: bind not(alarm.running)
             text: "Start"
             action: function(): Void {
               var date = new Date();
               alarm.count = alarm.hours * 3600 + alarm.minutes * 60
                   + alarm.seconds;
               alarm.startTime = date.getTime() / 1000;
               alarm.remainingTime = alarm.count;
               if (alarm.count != 0) {
                 alarm.alarmEnabled = true;
                 alarm.running = true;
                 alarm.timer.start();
               }
             }
           }
         ]
       }
     ]
   }
 }
}

また、次に警報鳴動Javaファイルを示します。


package clock;

import java.applet.Applet;
import java.applet.AudioClip;
import javax.swing.JOptionPane;

public class Sound {
 public static void alarm() {
   AudioClip ac
       = Applet.newAudioClip(Sound.class.getResource("TestMusic.wav"));
   ac.loop();
   JOptionPane.showMessageDialog(null, "時間ですよ！", "警告！警告！",
       JOptionPane.WARNING_MESSAGE);
   ac.stop();
 }

 public static void main(String[] args) {
   Sound.alarm();
 }
}

上述のJavaFX API文書は、実装されているものとクラス名や属性名が異なっていたり、未実装の機能が存在します。そのため、現状では、多少の試行錯誤が必要です。
また、「The JavaFX™ Script Programming Language Reference (Draft)」の「Chapter 5. Expressions and Operators」に載っている演算子の表は、「JavaFX台本型プログラミング言語基準（草案）：第5章」を投稿した後に、変更されています。演算子の剰余は「%」から「mod」に、不等価は「<>」から「!=」になりました。変更があったことについては記されておらず（元元、Draft（草案）ですから、仕方ありませんが…）、同ページに載っているコード例では、前の演算子がそのまま使われているので、注意が必要です（「表の方が最新です」と言いたいのですが、「以上」の演算子「>=」が「=>」（動画の補間直定数生成演算子）になっているなど、いくつか誤記があります。…）。

基本的なマウス入力の見本

2008-07-26T19:25:00.006+09:00

同じく、NetBeans 6.1用JavaFX追加接続（Plugin）プログラムに付属している見本を参考に、基本的なマウス入力応用プログラムの見本を作ってみました。
実行すると、図のように、マウス指示器の座標と押されたマウスボタンの番号（一番左のボタンが1。押されていないときは0）が、マウス指示器に追随して表示されます（それ用の画像取り込み用具を使っていないので、肝心のマウス指示器の画像を取り込めていませんが、あしからず）。空色の矩形の中にマウスを移動すると、矩形が半透明で表示されます。
次に、コードを示します。


package deviceInput;

import javafx.application.Frame;
import javafx.application.Stage;
import javafx.input.MouseEvent;
import javafx.scene.Group;
import javafx.scene.geometry.Rectangle;
import javafx.scene.paint.Color;
import javafx.scene.text.Text;
import javafx.scene.text.TextOrigin;
import javafx.scene.transform.Translate;

import java.lang.System;

Frame {
 var mouseEvent: MouseEvent;
 title: "Mouse Input"
 width: 400
 height: 332
 visible: true
 closeAction: function(): Void {
   System.exit(0);
 }
 stage: Stage {
   width: 400
   height: 300
   content: [
     Rectangle {
       x: 50, y: 50
       width: 300, height: 200
       fill: Color.LIGHTGRAY
       onMousePressed: function(ev: MouseEvent): Void {
         mouseEvent = ev;
       }
       onMouseClicked: function(ev: MouseEvent): Void {
         mouseEvent = ev;
       }
       onMouseReleased: function(ev: MouseEvent): Void {
         mouseEvent = ev;
       }
       onMouseMoved: function(ev: MouseEvent): Void {
         mouseEvent = ev;
       }           
     },
     Rectangle {
       x: 150, y: 100
       width: 100, height: 100
       fill: Color.SKYBLUE
       onMouseEntered: function(ev: MouseEvent): Void {
         ev.node.opacity = 0.5;
       }
       onMouseExited: function(ev: MouseEvent): Void {
         ev.node.opacity = 1.0;
       }           
     },
     Group {
       transform : Translate {x: bind mouseEvent.getX() + 20,
           y: bind mouseEvent.getY()}
       content : [
         Text {
           textOrigin: TextOrigin.TOP
           fill: Color.RED
           content: "StageX:"
         },
         Text {
           translateX: 45
           textOrigin: TextOrigin.TOP
           fill: Color.RED
           content: bind "{mouseEvent.getStageX() as Integer}"
         },
         Text {
           translateX: 80
           textOrigin: TextOrigin.TOP
           fill: Color.RED
           content: "StageY:"
         },
         Text {
           translateX: 125
           textOrigin: TextOrigin.TOP
           fill: Color.RED
           content: bind "{mouseEvent.getStageY() as Integer}"
         },
         Text {
           translateY: 15
           textOrigin: TextOrigin.TOP
           fill: Color.RED
           content: "X:"
         },
         Text {
           translateX: 15, translateY: 15
           textOrigin: TextOrigin.TOP
           fill: Color.RED
           content: bind "{mouseEvent.getX() as Integer}"
         },
         Text {
           translateX: 50, translateY: 15
           textOrigin: TextOrigin.TOP
           fill: Color.RED
           content: "Y:"
         },
         Text {
           translateX: 65, translateY: 15
           textOrigin: TextOrigin.TOP
           fill: Color.RED
           content: bind "{mouseEvent.getY() as Integer}"
         },
         Text {
           translateY: 30
           textOrigin: TextOrigin.TOP
           fill: Color.RED
           content: "Button:"
         },
         Text {
           translateX: 40, translateY: 30
           textOrigin: TextOrigin.TOP
           fill: Color.RED
           content: bind "{mouseEvent.getButton()}"
         }
       ]
     }
   ]       
 }
}

マウス事象は、その事象が発生した図式の節（graph node。見本コードでは、Rectangleオブジェクトを使用している）の、事象属性（onXxxYyy）に定義した呼び戻し関数を用いて取得します。マウス事象から、マウスの座標やボタン開閉器の番号などの情報が得られます。詳しいことは、「JavaFX API」を参照してください。
なお、図からもわかりますが、現状（2008/07/23現在の日々構築版追加接続プログラム）では、入力される座標に、一部不具合があるようです。マウス事象が発生した節の原点に対する相対位置を返す関数getX()/getY()は、その節を含むStageの原点に関する相対位置を返すgetStageX()/getStageY()と同じ値を返してしまいます（画面上の絶対位置を返すgetScreenX()/getScreenY()は、正常に機能しています）。

基本的な動画の見本

2008-07-19T20:04:00.020+09:00

NetBeans 6.1用JavaFX追加接続（Plugin）プログラムに付属している見本を参考に、基本的な動画応用プログラムの見本を作ってみました。
実行すると、図のような円が色を変えながら左右に往復運動します。
次に、コードを示します。


package motionPicture;

import javafx.animation.KeyFrame;
import javafx.animation.Timeline;
import javafx.application.Frame;
import javafx.application.Stage;
import javafx.scene.geometry.Circle;
import javafx.scene.paint.Color;
import javafx.scene.text.Text;

import java.lang.System;

var x: Integer = 50;
var vx: Integer = 1;
var color: Color = Color.rgb(25, 50, 0);

var timeline: Timeline = Timeline {
  repeatCount: Timeline.INDEFINITE
  keyFrames:
    KeyFrame {
      time: 10ms
      action: function(): Void {
        x += vx;
        color = Color.rgb((x / 2), x, 0);
        if (x < 50) {
          vx = 1;
        } else if (x > 250) {
          vx = -1;
        }
      }
    }
};

timeline.start();

Frame {
  title: "Basic Motion"
  width: 310
  height: 130
  visible: true
  closeAction: function(): Void {
    System.exit(0);
  }
  stage: Stage {
    fill: Color.LIGHTGRAY
    content: Circle {
      centerX: bind x, centerY: 50, radius: 30
      fill: bind color
    }
  }
}

動画は、前はdur演算子を用いて実現していましたが、JavaFX SDKでは、javafx.animation.Timelineクラスの機能を利用します。
repeatCount属性には、動画の繰り返し回数を、0以上の整数で指定します。無限に繰り返すときは、上記のように、Timeline.INDEFINITEを指定します。
keyFrames属性には、KeyFrameの列を指定します。
そして、start()関数を呼び出すと、動画が開始します。
また、各KeyFrameのtime属性には、Timelineの1周期における相対時刻を指定します。
action属性には、Timelineの各周期で、time属性で指定した時間が経過したときに呼び出される関数を指定します。上記の例では、無名関数で動画処理を定義しています。
以上が、基本的な動画の記述方法の例です。
最後に、ご注意を一言。本当は、枠付き窓の表題は（「Basic Motion」ではなく）日本語で表示したかったのですが、私が利用している、2008/07/16現在の日々構築版追加接続プログラムでは日本語表示ができません、（標準出力へも表示できません）。「MS932にマップできない」旨の誤り通報文が表示されて構築できなかったり、構築には成功しても、表示は文字化けを起こします。
Javaのプログラムからは問題なく日本語表示できるので、JavaFX追加接続プログラムに関連した問題と思われますが、原因は不明です（追加接続プログラム自体の問題なのか、設定上の問題なのかも分かりません）。

NetBeans 6.1用JavaFX追加接続プログラムの更新

2008-07-17T19:52:00.003+09:00

最近のJavaFXについては、「The JavaFX™ Script Programming Language Reference (Draft)」が公開されていることを、以前の投稿でご紹介しました。それと一緒に、「JavaFX API」も最新のものが公開されています。
ただ、このAPI文書はJavaFX SDKに対応したものなので、「The JavaFX™ Script Programming Language Reference (Draft)」文書のコード例で引用されているjavafx.guiパッケージなどは、もう載っていません。
私は、NetBeans 6.1にJavaFX追加接続（Plugin）プログラム（2008/06/15現在の日々構築版）を追加導入して使っていたのですが、導入時点では、JavaFX SDKには対応していませんでした。最近紹介される見本プログラムはJavaFX SDKに対応したものになっていますので、この機会に、最新の追加接続プログラムに更新することにしました。
（NetBeans 6.1とそのJavaFX追加接続プログラムの導入をお考えの方は、、「Downloading and Installing a Developmental Build of JavaFX Script Plugin for NetBeans IDE 6.1」が参考になります。ただし、JDKは、（JDK 5ではなく）JDK 6を導入しておいたほうが良いかも知れません。以前の投稿でも記しましたが、JDK 5では一括変換済みコードが実行できないことがありました。少なくとも、私自身はJDK 5で動作させたことはありません）
最新の追加接続プログラム（2008/07/16現在の日々構築版）を入手し、以前行った手順と同じようにして追加接続プログラムを更新しようとしたのですが、パソコンに取り込み済みの追加接続プログラムの更新方法が分かりません（NetBeansにあまり習熟していないので）。しかたなく、すでに導入済みの追加接続プログラムを取り外してから、改めて最新版を導入しなおすことにしました。
更新が済み、NetBeansを再起動すると、作成済みの企画（Project）の名称が朱字で表示され、「参照の問題を解決せよ」なる旨の通報窓が表示されます。指示されように、基盤（Platform）環境にJavaFX SDK（私の環境では、選択肢に「JavaFX SDK #1」がありましたので、それ）を追加すると、企画名が元の黒字表示に戻り、「参照の問題」が解決したようです。

JavaFX台本型プログラミング言語基準（草案）：付録A

2008-07-05T22:14:00.001+09:00

A.鍵語と予約語
この付録は、JavaFX™台本型プログラミング言語において予約された単語を記録したものである。

表A.1  鍵語と予約語
実装済み鍵語
abstract   attribute  bind  break
class  continue  delete  false  for
function  if  import  init  insert
 new  not  null  package
private   public   return
super  sizeof  static  this  throw
try  true  var  while  after
and  as  before   catch
 dur  else  exclusive  extends
finally    in  bound
indexof  into  inverse  lazy 
on  or  replace  step 
with  where  instanceof  override  at
then  tween       

予約済み鍵語
assert  by  do  first  from
last  let  protected  readonly  typeof
lazy

JavaFX台本型プログラミング言語基準（草案）：第9章

2008-07-05T21:34:00.003+09:00

9.引き金
9.1 置換引き金
置換引き金に対する構文は次のとおりである。

"on" "replace"
[旧値]
[ "[" 最低索引値 ".." 最高索引値 "]" "=" 新要素 ]
区画

置換引き金は、引き金を取り付けた変数に対するすべての変更に続いて呼び出される。構文上の非終端子である旧値、最低索引値、最高索引値、および新要素は、その本体が区画であるところの関数に対する、事実上の仮引数である。
・旧値は変数の事前の値であり、変数と同じ型を持つ。
・最低索引値と最高索引値は、旧値において置換対象となる部分の範囲を区切る。それらの型はIntegerである。純然たる挿入に対しては、「最高索引値==最低索引値-1」である。
・新要素は、部分列「旧値[最低索引値..最高索引値]」を置き換える値の列である。その型は変数と同じである。
引数「[最低索引値..最高索引値]=新要素」は、引き金が取り付けられた変数が列型であるときのみ認められる。
旧値と新要素は非対称であることに留意せよ。すなわち、旧値は、引き金が取り付けられた変数の事前の値であるのに対し、新要素は、その変数で変更される要素のみを含んでいる新値の部分列であるということである。
置換引金の構文は、部分列の割り当てを思い起こさせるようになっている。次を想定する。

attribute x
on replace oldVal[lo..hi]=newVals { exp };
var save = x;
x[i..j] = y;

すると、oldVal はsaveに、loはiに、hiはjに、そしてnewValsはyに結びつけられた上で、expが評価される。
統合置換引き金は、部分列の割り当てとうまく機能する。たとえば、次のように結合を定義することができる。

attribute x;
attribute y = bind x;

これは次と等価である。

attribute x =
on replace [i..j]=n
{ y[i..j]=n };
attribute y = [];

次のように、yがxの写像だとする。

attribute x;
attribute y = bind for (xi in x) f(xi);

これは次と等価である。

attribute x =
on replace [i..j]=n
{ y[i..j] = for (k in n) f(k) };
attribute y = [];

列の要素のある範囲を削除または置換すること、もしくは列を一箇所に挿入することは、すべて単一の引き金呼び出しに帰着する。述語条件を満たすすべての要素の削除のような、別の演算のあるものは、複数の引き金呼び出しに分解できるかもしれない。In that case the state as seen by each trigger invocation is consistent in the sense that the programmer-visible state is as if the predicate-delete (for example) were implemented as a set of independent slice-delete operations.

陳謝：最後の文は、拙には何が言いたいのか判然としないため、原文のまま載せておきます。m(_ _；)m

JavaFX台本型プログラミング言語基準（草案）：第8章

2008-07-04T21:39:00.001+09:00

8.データ結合
bind鍵語は、対象となる変数の値を別の変数の値に結びつける。

let x = bind someExpression;

これは、someExpressionの結果を変数xに結びつける。someExpressionの値が変わると、xの値も自動的に更新される。結び付けられる変数は、ある基本データ型の単純な値、式の結果、区画式の結果または結合関数でもよい（let鍵語は、それらに割り当てることができない変数を導入する）。

8.1 再計算して更新する
ある状況では、更新がどのように行われるか、あるいは結び付けられる値が変化するということはどういう意味なのかを厳密に知っている必要ある。結び付けられる値が変化すると、最小限の再計算が実行される。このことは、ある限られた状況において重要となる。たとえば、オブジェクトの生成を必要とする結合が実行される場合で、オブジェクトの同一性の理由から、新たなオブジェクトが実際に生成されるか否かが問題となるような状況である。

let sum = bind expr1 + expr2;

（上記の例で、）expr2が変化するとsumは再計算されるが、expr1は再計算されない。expr1に対する値はすでに格納されており、単にその値を再度取ってくるだけである。

次に実例を示す。

import java.lang.System;

var y = 3;
function ten() : Integer { 10 }
let sum = bind ten() + y;
System.out.println(sum);
y = 7;
System.out.println(sum);

このプログラムの出力は次のようになる。

13
17

yが7に設定されたとき、関数ten()は変化していないので再度呼び出されることはない。関数値は記憶されており再利用される。

8.2 結合と区画式
結合において、区画式の中に存在しうるのは変数宣言文だけである。（1増および1減を含め）値の割り当ては禁止されていることに留意せよ。したがって、結合区画式は次のような形式を取る。

bind { var a = expr; var b = expr; var c = expr; expr }

結合された式に対するいかなる変化も更新を引き起こし、その更新は最小限なので、変数が有効的に結合されていることを確認するのは容易である。while、insertおよびdeleteは文なので、結合の中に現れてはならないことに留意せよ。

8.3 結合と条件式
次の例を考えてみよ。

let x = bind if (condExpr) expr1 else expr2;

condExprが変わると、if文のどちらの分岐が評価されるのかも変わる。expr1またはexpr2に対する変化は、どちらも、もう一方の式の再計算を引き起こすことはない。

8.4 結合とfor式
次の例を考えてみよ。

let newSeq = bind for (elem in seq) expr;

たとえseqが変わっても、依然としてseqに存在し続けている要素に対応するnewSeqの要素は、再計算されない。言い換えれば、要素がseqに挿入されると、その要素にexprを適用した結果がnewSeqの相当する位置に挿入され、newSeqの他の要素は再計算されない。
例外は、exprがindexof elemを使用しているために、索引の値が変化した要素を更新する必要がある場合であるが、最小限の更新という既定には合致している。

import java.lang.System;

var min = 0;
var max = 3;
function square(x : Integer) : Integer { x*x }
let values = bind for (x in [min..max]) square(x);
System.out.println(values);
max = 5;
System.out.println(values);
min = 1;
System.out.println(values);
min = 0;
System.out.println(values);

この場合、次の再計算が実行される。
・0から3の2乗を計算する。
・4と5の2乗を計算する（maxが変わっても、0から3の2乗は再計算されない）。
・ほかの値は再計算せず、0の2乗を削除する。
・0の2条を戻す。これは、その値の再計算を必要とする。この動作は、代わりにinsertやdeleteを用いても同様である。

8.5 結合とオブジェクト直定数
オブジェクト直定数は、演算子や非結合関数のように機能する。オブジェクト直定数の引数の一つが変化すると、オブジェクト直定数は再実行（新たな実体が生成）される。

let pt = bind Point { x: myX y: myY }

myXが変わると、JavaFX台本型プログラミング言語は、新たなPointオブジェクトを生成する。これは、不変オブジェクトに対して予期された振る舞いでもある。
新たなオブジェクトを生成せずに、xの値がmyXの値を追跡するようにするためには、結合が必要になる。

let pt = bind Point { x: bind myX y: myY }

この例に対しては、おそらくyも同様に結合した方が良いだろう。

let pt = bind Point { x: bind myX y: bind myY }

ここで、ptは常に同じPointオブジェクトの実体と結合したままである。それは、冒頭のbindがなくても同様である。

let pt = Point { x: bind myX y: bind myY }

8.6 結合と関数
非結合関数は、bound鍵語が前置されていない関数である。Javaプログラミング言語の操作やJavaFX台本型プログラミング言語の関数の呼び出しに関して、その引数のいずれかが変更されると、JavaFX台本型プログラミング言語はその関数を再度呼び出すが、関数の本体は暗箱である。関数が、その入力となる引数以外に持っている依存性のゆえに再計算されることはない。

import java.lang.System;

class Point {
attribute x : Number;
attribute y : Number;
}

var scale = 1.0;

function makePoint(x0 : Number, y0 : Number) : Point {
Point {
x: x0 * scale
y: y0 * scale
}
}

var myX = 3.0;
var myY = 3.0;
let pt = bind makePoint(myX, myY);
System.out.println(pt.x);
myX = 10.0;
System.out.println(pt.x);
scale = 2.0;
System.out.println(pt.x);

出力。

3.0
10.0
10.0

引数myXを変更すると、関数makePointは再度呼び出される。しかし、関数makePointは暗箱である。よって、scaleに割り当てられた値が変更されても、当然ではあろうが、関数は再計算されない。これこそが、結合関数が役立つことを意図された場面である。結合関数が予期された更新をもたらしてくれる。
結合関数は、その本体として、結合される区画式を持っている（それゆえに、結合区画式に関する上述の制限を有している）。結合関数に結びつけると、引数以外の変化も更新を引き起こし、かつ引数の変更も調べられる。上述の関数makePointを結合関数にすると次のようになる。

bound function makePoint(x0 : Number, y0 : Number) : Point {

今度こそ、scaleに割り当てられた値の変化は更新（20.0）を引き起こす。myXが変わるとx0 * scaleだけが再計算され、y0 * scaleは再計算されないことに留意せよ。
結合とは別のところで結合関数を呼び出すことは、非結合関数を呼び出すことと同じことである。

JavaFX台本型プログラミング言語基準（草案）：第7章

2008-07-03T17:17:00.006+09:00

7.列内包
7.1 forを用いた列の繰り返し
JavaFX台本型プログラミング言語は、for演算子を用いた列内包を支援する。列内包は、1つ以上の入力列、任意選択としてのろ過器、および式から構成される。各入力列は、変数と関連している。列内包の結果は、元となる列の要素の内でろ過器の条件を満たすものの組合せに、式を適用したものからなる新たな列である。
次のプログラムはこの構文の実例を示したもので、曲集の一覧から曲の一部が表題となっているものを特定するためにfor演算子を用いている。

class Album {
attribute title: String;
attribute artist: String;
attribute tracks: String[];
}

var albums =
[Album {
title: "A Hard Day's Night"
artist: "The Beatles"
tracks:
["A Hard Day's Night",
"I Should Have Known Better",
"If I Fell",
"I'm Happy Just To Dance With You",
"And I Love Her",
"Tell Me Why",
"Can't Buy Me Love",
"Any Time At All",
"I'll Cry Instead",
"Things We Said Today",
"When I Get Home",
"You Can't Do That"]
},
Album {
title: "Circle Of Love"
artist: "Steve Miller Band"
tracks:
["Heart Like A Wheel",
"Get On Home",
"Baby Wanna Dance",
"Circle Of Love",
"Macho City"]
}];

for (album in albums, track in album.tracks) {
if (album.title == track)
java.lang.System.out.println("TITLE TRACK = {track}")
else
java.lang.System.out.println("Track = {track}")
}

出力：

TITLE TRACK = A Hard Day's Night
Track = I Should Have Known Better
Track = If I Fell
Track = I'm Happy Just To Dance With You
Track = And I Love Her
Track = Tell Me Why
Track = Can't Buy Me Love
Track = Any Time At All
Track = I'll Cry Instead
Track = Things We Said Today
Track = When I Get Home
Track = You Can't Do That
Track = Heart Like A Wheel
Track = Get On Home
Track = Baby Wanna Dance
TITLE TRACK = Circle Of Love
Track = Macho City

次に示すのは、ろ過器を用いた別の例である。これは、数を受け取ってその因数の一覧を返す関数を定義したものである。

function factors(n:Number) {
return for (i in [1 .. n/2] where n % i == 0) i;
}

訳注：この例では、:Number型の「因数」の列を戻すので、正確には「因数」とは呼べないが…。

forに対する内包の中で、indexof演算子を使用することができる。その構文は「indexof 名称」で、名称は繰り返し変数の名前である。その値は、基となる列における繰り返しの索引の値である。
次の例に示したように、indexof演算子は列の抽出に使用することもできる。

var nums = [1..5];
var numsExceptTheFirstTwo = nums[n|indexof n > 1]; // [ 3, 4, 5 ]を返す

7.2 列変数の変更
insertは、列に新たな要素を挿入する。

insert x into seq
insert x before seq[idx]
insert x after seq[idx]

deleteは、列から要素を取り除く。

delete seq
delete x from seq
delete seq[idx]
delete seq[a..b]

次のコードは、それぞれの例である。

// 挿入の例

var nums = [1..5];
var x = 6;
insert x into nums; // 結果は、[ 1, 2, 3, 4, 5, 6 ]
x++;
insert x before nums[0]; // 結果は、[ 7, 1, 2, 3, 4, 5, 6 ]
x++;
insert x after nums[3]; // 結果は、[ 7, 1, 2, 3, 8, 4, 5, 6 ]

// 削除の例

nums = [1..5];
delete 2 from nums; // 結果は、[ 1, 3, 4, 5 ]
delete nums[0];// 結果は、[ 3, 4, 5 ]
nums = [1..10]; // 結果は、[ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]
delete nums[3..7]; // 結果は、[ 1, 2, 3, 9, 10 ]
delete nums; // 結果は、[ ]
nums = [1..10];
delete nums[5..]; // 結果は、[ 1, 2, 3, 4, 5 ]
delete nums[0..<]; // 結果は、[ 5 ]

訳注：原文では、最後の「delete nums[0..<];」文が「delete nums[0..>];」と誤記されている。

列の要素を逆順に並べ替えることもできる。

var nums = [1..5];
reverse nums; // [ 5, 4, 3, 2, 1 ]を返す

訳注：2008年6月15日時点のNetBeans 6.1用JavaFX追加接続（Plugin）プログラムで動作確認したところ、「reverse nums;」だけでは、元のnums の要素の並びは変わらなかった（並び替えた結果を利用するためには、「nums = reverse nums;」のように列変数に代入しなおす必要がある。その意味では、delete演算子とは用法が異なる）。

JavaFX台本型プログラミング言語基準（草案）：第6章

2008-07-03T13:56:00.001+09:00

6.列
先に述べた5つの基本データ型に加え、JavaFX台本型プログラミング言語は、列として知られたデータ構造を提供する。列はJavaプログラミング言語の配列に似ているが、異なる点もある。
次のコードはある例を示す。

var weekDays = ["Mon","Tue","Wed","Thur","Fri"];
var days = [weekDays, ["Sat","Sun"]];

列は、オブジェクトの順序付けられた一覧を表す。しかしながら、列そのものはオブジェクトではないため、入れ子構造を取ることはできない。列は、値により等価であるとみなされる。すなわち、列の長さが等しく、それらの要素が同一であるとき、列は等しくなる。（上記のdaysの初期化におけるように）入れ子になった列を形成する式は、自動的に平準化される。

days == ["Mon","Tue","Wed","Thur","Fri","Sat","Sun"]; // trueを返す

さらに、単一のオブジェクトは、1つのオブジェクトからなる列に等価である。

1 == [1]; // trueを返す

列の型は、「[]」注釈を用いて宣言される。

var xs:Number[]; // 数の列
var strs:String[]; // 文字列の列

列の要素は共通の型を持たねばならず、その型はオブジェクトであっても良い。列は、Javaプログラミング言語の配列のように、索引付けることがきる。

var wednesday = days[2];

次のように、その要素が等差数列をなしている列のための、「..」を用いた簡便な表記法もある。

var nums = [1..100];

この簡略記法により、各要素を手入力する必要がなくなる。
[]演算子は、述語形式の選択も表す。述語は、次の形式を取る。

列[変数名| 論理式]

例：

var nums = [1,2,3,4];
var numsGreaterThanTwo = nums[n|n > 2];

上記の式は、元の列の要素の内、述部の条件を満たすものから構成された新たな列を返す。
最後に、部分列は、列の一部を利用できるようにする。

seq[a..b] // 索引aとbの間（両端含む）の列
seq[a..<b] // 索引a（含む）とb（含まない）の間の列
seq[a..] // seq[a..<sizeof seq]に同じ
seq[a..<] // 一貫性を保つため、seq[a..<sizeof seq-1] に同じ

列や部分列を、利用および／または変更するいくつもの異なる方法がある。次の章では、JavaFX台本型プログラミング言語の一覧内包の特徴について探求する。

JavaFX台本型プログラミング言語基準（草案）：第5章

2008-07-02T21:02:00.006+09:00

5.式、文、および演算子
5.1 式
Javaプログラミング言語と異なり、JavaFX台本型プログラミング言語は式言語である。すべての実行文は、0個以上の入力とそれに続く単一の出力から構成される式である。これには、条件、繰り返し、ならびにコード区画さえも含まれる。
次に実例を示す。

import java.lang.Math;
import java.lang.System;

var rand = (Math.random() * 100).intValue();
var s:String = null;
if (rand % 2 == 0) {
s = "rand is even"
} else {
s = "rand is odd"
};

System.out.println(s);

上記の例で、条件式ifのthen節とelse節は、それ自体が式、すなわち区画式である。

5.2 区画式
区画式は、中括弧（{}）で囲まれた、セミコロン（;）区切り文（宣言または式でもよい）の一覧から構成される。（区画内の）最後の文が式なら、その式の値が区画式の値となる。さもなければ、区画式はvoid型となる。
したがって、先の例は次のように書くこともできる。

import java.lang.Math;
import java.lang.System;

var rand = (Math.random() * 100).intValue();
var s:String =
if (rand % 2 == 0) {
"rand is even";
} else {
"rand is odd";
};

System.out.println(s);

あるいは、（次のように）中括弧を省略することができる。

import java.lang.Math;
import java.lang.System;

var rand = (Math.random() * 100).intValue();
var s:String = if (rand % 2 == 0) "rand is even" else "rand is odd";

System.out.println(s);

Javaプログラミング言語は、if文と条件式「a < b ? a : b」の両方を持っている。区画式のおかげで、JavaFX台本型プログラミング言語のif式は、両者の代わりをしている。

5.3 値域式
値域式は、次の構文により、等差数列を形成している数値の列を定める。

[数1..数2]

値域式は、数1から数2までの整数（両端含む）からなる列を定める。値域式の簡単な例として、次のようなものが考えられる。

import java.lang.System;

var nums = [0..3];
System.out.println(nums == [0,1,2,3]); // trueと表示する

既定では数値間の間隔は1だが、異なる値を指定することもできる。たとえば、次の式は、1から10の間の奇数からなる列を定める。

[1..10 step 2]

降順の値域を生成するためは、2つ目の値が1つ目の値より小さいことを確認し、負数の間隔を指定する。

import java.lang.System;

var nums = [3..0 step -1];
System.out.println(nums == [3,2,1,0]); // trueと表示する

次の宣言文は、実際には空の列を宣言することに留意せよ。

var nums1 = [3..0 ];
var nums2 = [3..0 step 1];

5.4 条件式
if式は、else節がさらなるif式でない限りthen節とelse節を囲む中括弧が常に必要であるという点を除いて、Java™プログラミング言語における表現と似ている。

if (condition1) {
System.out.println("Condition 1");
} else if (condition2) {
System.out.println("Condition2");
} else {
System.out.println("not Condition 1 or Condition 2");
}

5.5 繰り返し式

5.6 文
return文は、Javaプログラミング言語において見られるものと同一である。

function add(x, y) {
return x + y;
}

throw文は、（Javaプログラミング言語では）java.lang.Throwableを拡張したオブジェクトだけが投げられたり捕捉されたりできるという点を除き、Javaプログラミング言語のものと似ている。

import java.lang.Exception;

function foo() {
throw new Exception("this is a java exception");
}

function bar() {
throw "just a string";
}

tryとcatch文は、Javaプログラミング言語のものと似ているが、JavaFX台本型プログラミング言語の変数宣言の構文を用いる。

try {
throw "Hello";
} catch (s:String) {
System.out.println("caught a String: {s}");
} catch (any) {
System.out.println("caught something not a String: {any}");
} finally {
System.out.println("finally...");
}

break文とcontinue文は、Javaプログラミング言語のものと似ている。しかし、ラベルは支援されていない。break文とcontinue文は、whileまたはfor繰り返しの本体内に現れなければならない。

5.7 演算子
JavaFX台本型プログラミング言語は、Javaプログラミング言語にみられるものと同様の標準的な演算子を提供する。次の表は、Javaプログラミング言語における等価物と比較させながら、優先順位に従って演算子を一覧表にしたものである。


                          表 5.1  演算子の優先順位
優先度  JavaFX演算子   演算                        Java演算子    結合規則
1          =                     代入                        =                   右から左
2          +=                    加算代入                +=
          -=                    減算代入                -+
          *=                    乗算代入                *=
          /=                    除算代入                /=
          %=                    剰余代入                %=
3          and                   論理and                 &&                  右から左
4          or                     論理or                   ||                    右から左
5          instanceof          実体                      instanceof        右から左
          as                    型変換                   該当なし
          sizeof               配列長                   該当なし
          indexof             索引位置                該当なし
          new                  生成                      new
          op()                  関数呼び出し          該当なし
          x.op()                要素関数呼び出し
6          ==                    等価                       ==                   左から右
          <>                 不等価                    !=
          <=                 以下                       <= 
          <-      
          <                   小なり                     < 
          >                      大なり                     >
7          +                      加算                       +                    右から左
          -                      減算、算術否定        -
8          *                      乗算                        *                   右から左
          /                      除算                        /
          %                      剰余
          =>                    動画
9          ++ (前置)           1増                          ++                  右から左
          -- (前置)          １減                          --
10         ++ (後置)          1増                          ++                  右から左
          -- (後置)          １減                          --


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); // falseを表示する
System.out.println(x <> y); // trueを表示する
System.out.println(x < y);  // trueを表示する
System.out.println(x > y);  // falseを表示する
System.out.println(x >= y); // falseを表示する
System.out.println(x <= y);  // trueを表示する
System.out.println(x + y);  // 6を表示する
System.out.println(x - y);  // -2を表示する
System.out.println(x * y);  // 8を表示する
System.out.println(x / y);   // 0を表示する
System.out.println(x % y);   // 2を表示する
System.out.println(a and b); // falseを表示する
System.out.println(a or b);  // trueを表示する
System.out.println(not a);  // falseを表示する
System.out.println(sizeof [x,y]); // 2 を表示する
System.out.println([x,y][e | indexof e == 0]); // [ 2 ]を表示する
System.out.println(if (a) x else y); // 2を表示する
System.out.println(for(q in [x, y] where q < 3) q); // [ 2 ]を表示する
System.out.println(Math.max(x, y)); // 4を表示する
System.out.println("abc".toUpperCase()); // ABCを表示する
System.out.println(x); // 2を表示する

JavaFX台本型プログラミング言語基準（草案）：第4章

2008-07-01T16:25:00.009+09:00

4.変数と基本データ型
4.1 変数
第1章で論じたように、var鍵語は、新たな変数をプログラムに導入するために用いられる。変数の型は、それを宣言する際に指定してもよいが、そうするか否かは自由である。変数の型が宣言から省略されると、その用いられ方から型が推測される。
変数宣言は、次の形式を取る。

var 変数名 : 型 = 初期化子;

例：

var num = 1; // 推測された型
var num : Number = 2;
var firstName = "John"; // 推測された型
var lastName : String = "Doe";

変数命名法の慣例は、Java™プログラミング言語に見られるものと同様である。クラス名は、各単語の最初の文字を大文字にする（MyClass）。関数名は小文字で始まるが、後に続く各単語の最初の文字は大文字にする（myFunctionName）。定数は、下線文字で区切られた単語により、すべて大文字で表されなければならない（MY_CONSTANT）。
フランス引用符<<>>で囲まれた（空白文字を含む）いかなる文字列も、識別子として扱われる。これにより、JavaFX™台本型プログラミング言語の鍵語（または、他の、通常は不正な識別子）を、クラス、変数、関数、または属性の名前として用いることができる。
例：

var <<delete>> = 100;

これは、JavaFX台本型プログラミング言語の鍵語と同じ名前の（Javaプログラミング言語で書かれた）操作を呼び出すことも可能にしている。

import javax.swing.JTextArea;

var textArea = new JTextArea();
textArea.<<insert>>("Hello", 0);

変数の存続期間は、少なくともそれを含むコード区画の存続期間と同じである。

4.2 基本データ型
JavaFX台本型プログラミング言語では、原始型（プリミティブ型）という用語は使わない。代わりに、5つの基本データ型を定義しており、応用コードで常に利用することができる。
5つの基本データ型は、次のようにJavaプログラミング言語に対応付けられる。

表4.1 基本型

JavaFX台本型プログラミング言語     Javaプログラミング言語
String                                           java.lang.String
Boolean                                        java.lang.Boolean
Number                                        java.lang.Number
Integer                                         byte,short,int,long,BigInteger
Duration                                       該当なし

最初の4つの型は、Javaプログラミング言語でもしばしば使われるので、ほとんどの開発者には既におなじみであろう。しかし、Duration型はこれまでになく、JavaFX台本型プログラミング言語に特有のものである。javafx.lang.Durationクラスは、時間の単位（ミリ秒、秒、分、または時間）を表す。Durationクラスを実体化するための簡略表現である、時間直定数も支援している。

5ms; // 5ミリ秒
10s; // 10秒
30m; // 30分
1h; // 1時間

整数を表す型については、Javaプログラミング言語で書かれた操作と引数または戻り値を受け渡すときに、自動的に強制型変換が行われる。
文字列に関しては、一重引用符または二重引用符を用いて文字列直定数を指定することができる。

var s1 = 'Hello';
var s2 = "Hello";

その違いは、後者（二重引用符）を用いると、中括弧（{}）の中に式を埋め込むことができることにある。

var name = 'Joe';
var s = "Hello {name}"; // s = 'Hello Joe'

中括弧を用いると、一括変換器は、埋め込まれた式に対する型を推測し、文字列へ強制型変換することができる。
埋め込まれた式自体が引用符で囲まれた文字列を含むことができるので、次々に、さらなる埋め込み式を含むことができる。

var answer = true;
var s = "The answer is {if (answer) "Yes" else "No"}"; // s = 'The answer is Yes'

Javaプログラミング言語と異なり、JavaFX台本型プログラミング言語の二重引用符付き文字列は、改行文字を含むことができる。
付加的な書式設定接頭辞を与えることにより、数値とデータがどのように文字列に変換されるかについても制御することができる。そうした接頭辞は、java.util.Formatterの仕様に従う。

import java.util.Date;

var hexStr = "hex of 13 is 0x{%02X 13}"; // hexStr = "hex of 13 is 0x0D"
var date = new Date(107, 10, 11);
var dateStr = "{%tc date}"; // dateStr = "日 11 11 00:00:00 JST 2007"

訳注：原文では、「var dateStr = "{%tc date}";」文末のセミコロン（;）が抜け落ちている。また、日本では、日付は上記コメントの書式で表示される。

JavaFX台本型プログラミング言語基準（草案）：第3章

2008-06-30T14:27:00.002+09:00

3.属性と関数
3.1 属性
属性はオブジェクトの状態を定める。それらは、attribute鍵語に続けた、属性名、コロン（:）、セミコロン（;）で終結する属性型で宣言される。

attribute 属性名 : 属性型 ;

属性の既定値を宣言することができる（後で、オブジェクト直定数で与えられる値に定義しなおすことができる）。初期化子は、新たに生成されたオブジェクトのもとで、クラス宣言内で属性が指定された順に評価される。

import java.lang.System;

class X {
attribute a: Number = 10;
attribute b: Number = -1;
}

var x = X { };
System.out.println(x.a); // 10.0を表示する
System.out.println(x.b); // -1.0を表示する

明示的な初期化が行われないと、それぞれの属性は妥当な既定値に設定される。

import java.lang.System;

class DefaultValuesDemo {
attribute a: Number;
attribute b: Integer;
attribute c: Boolean;
attribute d: String;
}

var demo = DefaultValuesDemo {};
System.out.println("Default Value: " + demo.a);
System.out.println("Default Value: " + demo.b);
System.out.println("Default Value: " + demo.c);
System.out.println("Default Value: " + demo.d);

上記コードは、次の既定値を画面に表示する（注記：最後の行は、空文字列を表示する）。

Default Value: 0.0
Default Value: 0
Default Value: false
Default Value:

データ型は、第4章で取り上げられている。

3.2 関数
関数はオブジェクトの振る舞いを定める。関数は次の形式を取る。

関数名 (属性名 : 属性型, ...): 戻り型本体

ここで、本体は任意の式でかまわない。
関数は第一級オブジェクトである（たとえば、変数に割り当てたり、引数としてほかの関数へ渡すことができる）。
第1章で、何も引数を取らず、何も値を返さないgrow関数を定義している簡単な例を示した。

...

function grow(): Void {
width++;
height++;
}

...

その例証では、利用者が特定の寸法を指定できるようにした形の、関数の多重定義版も与えた。

...

function grow(amount: Integer): Void {
width += amount;
height += amount;
}

...

関数は無名にもなりうる。無名関数は、GUI構成部品のaction属性に振る舞いを割り当てる際に、しばしば利用される。

import java.lang.System;
import javafx.gui.*;

Frame {
visible: true
content: FlowPanel {
content: Button {
text: "Click Me!"
action: function() {
System.out.println("Click!");
}
}
}
}

JavaFX台本型プログラミング言語基準（草案）：第2章

2008-06-29T12:41:00.006+09:00

2.クラスとオブジェクト
2.1 クラスを取り込む
import文は、Javaプログラミング言語と同様に機能する。その構文は、

import パッケージ名.クラス名;

または、

import パッケージ名.*;

である。
import文が存在する場合は、それ以外のすべての応用コードの前になければならない。JavaFX台本型プログラミング言語は、自身の組み込みライブラリクラスのための名前空間（パッケージjavafx.*）を定義しているが、標準的なJavaプログラミング言語のクラスを取り込むこともできる。

import java.lang.System;
import javafx.gui.*;

Frame {
visible: true
content: FlowPanel {
content: Button {
text: "Click Me"
action: function() {
System.out.println("Click!");
}
}
}
}

クラスに関する利用修飾子は、Javaプログラミング言語におけるのと同様に機能する。クラスは、public、protected、またはprivateとして宣言でき、それぞれ、どこからでも（public）、現行のパッケージ内または派生クラス内から（protected）、もしくは現行クラス内のみから（private）利用できる。
注記：JavaFX台本型プログラミング言語は、構築子を支援していない。構築子の作用をまねるためには、新たなオブジェクトを返す静的関数を定義し、代わりにその関数を呼び出すことである。

2.2 クラスを定義する
JavaFX台本型プログラミング言語は多重継承を支援しており、そうしたものとして、新たな用語と規定を定義している。
・単純クラスは、Javaプログラミング言語で書かれたクラスを直接的または間接的に拡張した任意のクラスである。
・複合クラスは、単純クラスには当てはまらないすべてのクラスである。
・既定では、JavaFX台本型プログラミング言語で書かれたクラスは複合クラスである。
・クラスは、単純クラス一つだけを拡張することができる。そうしたクラスは、単純クラスとなる。クラスはまた、任意の数の複合クラスまたはJavaプログラミング言語のインタフェースを拡張することもできる。
注記：現在のところ、単純クラスはJavaクラスに変換され、複合クラスはJavaクラスとJavaインタフェースに変換される。
クラスを指定するための構文は、class鍵語に続けたクラス名、任意としてのextends鍵語とカンマ（,）で区切った基底クラス名の一覧、左中括弧（{）、それぞれセミコロン（;）で終結している属性と関数の一覧、そして右中括弧（}）からなる。
既定では、クラスは同じ原始ファイルの中（モジュール通用範囲としても知られている）でのみ利用できるが、publicと宣言することによりどこからでも利用することができる。JavaFX台本型プログラミング言語は構築子を支援していないことに留意すること。構築子の作用をまねるためには、新たなオブジェクトを返す静的関数を定義し、代わりにその関数を呼び出すことである。

2.3 オブジェクトを定義する
前の章で述べたように、クラス実体化の推奨方法はオブジェクト直定数を使うことである。この形式のオブジェクト割り当ては、クラス名とその後に続く中括弧でくくった属性初期化子の一覧から構成される宣言的構文を用いる。それぞれの初期化子は、属性名に、コロン（:）と属性の値を定義する式を続けて構成する。
オブジェクトを生成する際にnew鍵語を使うこともできるが、それは、Javaプログラミング言語のクラスの実体化がオブジェクト直定数によっては不可能である場合のために取っておくべきである。

import java.io.File;

var tmpPath = "/home/users/docs/tmp.txt"
var myFile = new File("tmp.txt");

JavaFX台本型プログラミング言語基準（草案）：第1章

2008-06-27T20:10:00.008+09:00

以前から、一括変換型に変わったJavaFX言語の全ぼうを知りたいと思っていたのですが、ちょうどいい文書「The JavaFX™ Script Programming Language Reference (Draft)」が、しばらく前に公開されました。
今回から何回かに分けて、その和訳を載せたいと思います。訳にはつたないところもありますが、ご容赦ください。また、コード例の部分では、字下げが抜けてしまっているため読みづらいと思いますが、あわせてご容赦ください。
今回は、目次と第1章です。
---------------------------------------------------------
JavaFX台本型プログラミング言語基準（草案）

目次
1.言語概要
2. クラスとオブジェクト
3.属性と関数
4.変数と基本データ型
5.式、文、および演算子
6.列
7.列内包
8.データ結合
9.引き金
A.鍵語と予約語

1.言語概要
この章では、JavaFX台本型プログラミング言語の概要について説明する。ここでは主な特徴の概要を述べ、特定の構成概念についての詳述は後の章で行う。この本は、Java™ Web Startソフトウェアとしてまたは従来型の机上応用プログラムとしてウェブ（Web）ページ内で実行される、表現力豊かなインタネット依頼者側応用プログラムや要素の、設計者および開発者を対象としたものである。読者がJavaScriptおよび／またはJava™プログラミング言語に精通していることを想定している。
JavaFX台本型プログラミング言語は、
・図式利用者インタフェース（GUI）構成部品の指定に宣言型構文を使用しており、開発者のプログラムコードをGUIの実際の配置にぴたりと対応させることを可能にしている。
・宣言型データ結合と増分評価を使用しており、個々の構成部品を容易に作成および構成することを可能にしている。（データ結合により）応用プログラムのデータとGUIの構成部品は、自動的に同期がとられる。
・静的に型付けされており、Javaプログラミング言語において大規模プログラムの作成と保守を可能にしているコード構造、再利用および情報隠ぺいなどの特性と同様のものをほとんどを持っている。
・Javaプログラミング言語によるソフトウェア開発のための基準実装IDE（統合開発環境）であるNetBeansIDEを含め、すべての主要IDEと連携する。
・どのような規模または複雑さのGUIも提供することができる。
・Swingの使用を容易にする。
以下の節では、JavaFX台本型プログラミング言語について駆け足で紹介する。しかるべき点についてはJavaプログラミング言語と比較および対比させながら、その核となる構文と機能についての一般的な導入を与える。そして、それぞれの主題は後の章で更に詳しく取り上げられる。

1.1 クラス
クラスの定義は、Javaプログラミング言語と多くの共通点を持っているが、相違点もある。たとえば、情報は、領域ではなく、属性に格納される。振る舞いは、操作ではなく、関数によってあらわにされる。次の例は、それぞれの基本構文を示す簡単な矩形クラスを定義している。

class Rectangle {
attribute width: Integer;
attribute height: Integer;

function grow(): Void {
width++;
height++;
}

function grow(amount: Integer): Void {
width += amount;
height += amount;
}
}

Javaプログラミング言語とは異なり、クラス定義では、既存のライブラリを単に利用する必要はない。更に、JavaFX台本型プログラミング言語は多重継承を支援しており、必要なら複数のクラスを継承することができる。
クラスは、第2章で詳しく取り上げられる。
属性と関数は、第3章で詳しく取り上げられる。

1.2 オブジェクト
オブジェクト直定数は、クラスの実体化のための簡単な構文を提供する。次のコードは、前述した矩形クラスの単一の実体を生成し、その幅と高さの属性を100に初期化する（newを必要としない点に留意すること）。

Rectangle {
width: 100
height 100
}

このオブジェクトへの参照を格納するには、var鍵語を使う。

var myRect = Rectangle {
width: 100
height 100
}

オブジェクトは、第2章で詳しく取り上げられる。
変数と基本データ型は、第4章で詳しく取り上げられる。

1.3 式、文、および演算子
他のプログラミング言語と同様に、JavaFX台本型プログラミング言語は、式、文、および演算子を支援する。
第5章は、JavaFX台本型プログラミング言語において利用可能な式、文、および演算子について論じる。

1.4 列
列は、オブジェクトの順序付けられた一覧を保持する。これは、Javaプログラミング言語の配列にほぼ類似している。両方とも複数の値を保持し、0から始まる索引により検索される。

var week = ["Monday","Tuesday","Wednesday","Thursday",
"Friday","Saturday","Sunday"];
var mon = week[0];
var wed = week[2];
var fri = week[4];

部分列も支援されている。

var week = ["Monday","Tuesday","Wednesday","Thursday",
"Friday","Saturday","Sunday"];
var weekdays = week[0..4]; // 第1部分列
var weekend = week[5..6]; // 第2部分列

第6章は列宣言の基本を取り上げており、第7章は列内包に焦点を当てている。

1.5 データ結合
データ結合は、複数オブジェクトの状態を同期させるための簡単な構文を提供する。2つのオブジェクトが互いに結合されると、1番目のオブジェクトが更新されたときはいつも2番目のオブジェクトの値が自動的に変更される。データ結合の一般的な利用法は、GUI部品をその基となるデータに同期し続けることである。

import javafx.gui.Frame;
import javafx.gui.Button;

var myString = "Click Me";

Frame {
width: 50
height: 50
visible: true
content:
Button {
text: bind myString
}
}
// コードのほかの部分でmyStringを変更すると、
// ボタン上の文字列も自動的に変更される。

データ結合は、第8章で詳しく取り上げられる。

1.6 引き金
引き金は、ある条件が満たされると実行されるコードの区画である。たとえば、ある属性の値が不適切なものに設定されることを、防ぐための処置を講じたいと思うことがあるかもしれない。次の例は、引き金の基本構文を示す。

import java.lang.System;

ReplaceDemo {
mySensitiveData: "Will anyone notice?"
}

class ReplaceDemo {
attribute mySensitiveData: String
on replace {
System.out.println("I noticed a change!");
};
// 応用特有の保護手段コードがここに書かれる
}

引き金は、第9章で詳しく取り上げられる。

一括変換型JavaFX指導書連載第1回の要

2008-02-02T19:53:00.000+09:00

いきなりつまずいてしまいましたが、Sun Developer Network (SDN) のTechnical Articles and Tips > JavaFX Technologyに、6箇月18回にわたって連載される一括変換型JavaFXスクリプト指導書について、主に逐次解釈型JavaFXとの相違点を中心にまとめておきたいと思います。
まずは、第1回目の「Creating Rich Internet Applications With Compiled JavaFX Script Technology」から。
1.定数値の記述方法の変更
Frameオブジェクトのbackground属性に指定する色名や、Fontオブジェクトのstyle属性に指定する書体名などの定数値は、逐次解釈型ではそれぞれwhite、BOLDのようにクラス名なしで記述していましたが、一括変換型ではColor.WHITE、FontStyle.BOLDのようにクラス名付きで記述します。
2.手続きの記述方法の統一
Buttonオブジェクトのaction属性などに指定する戻り値なしの手続きは、逐次解釈型ではoperation()として定義していましたが、一括変換型では戻り値なしのfunction()として定義します。operation()はfunction()に統一されます。

一括変換済みJavaFXコードが実行できるようになりました

2008-02-02T15:17:00.000+09:00

前回の投稿で記した、一括変換済みJavaFXコードの実行時誤りが解決しました。
前回の投稿でも記しましたが、私が使用していたJDKの版数は、JDK 1.5.0_11でした。これを、JDK 1.6.0_04（今日現在の最新版）に更新することにより、無事一括変換済みJavaFXコードを実行することができるようになりました。
いつかはJDK 6に更新しなくてはと思いながら先延ばししていたものですから、すっきりしました（どうしても、「動いているものはいじるな」という気が働いてしまうものですから）。また、NetBeansも、6.0.1日本語版に更新しなくてはと思っていたので、ちょうど良かったです（それにしても、NetBeans 6.0.1日本語版は、なかなか公開されませんね）。
JDKを更新した後、念のため、

archive.zipを展開しなおし、一括変換も再度行いました。
なお、以前の投稿で

記したように、OpenJFX逐次解釈器のbinディレクトリをPATH環境変数に設定している場合は、「OpenJFX\trunk\bin;」を「archive/openjfx-compiler/dist/bin;」に置き換えるのを忘れないでください（「OpenJFX\trunk\bin;」の前に追加してもかまいませんが）。
今度のjavafx命令は、実行しても余計な報告文を表示しないので、すっきりしてます。また、私のように、CLASSPATH環境変数に何かを設定していても、そのまま（CLASSPATHの値を空にすることなく）実行できます:-)

JavaFX一括変換器の変換誤りの原因が分かりました

2008-02-01T22:37:00.000+09:00

前回の投稿で述べたJavaFX一括変換器の誤りの原因が分かりました。
なんと、一括変換器の不具合ではなく、コード例1のコードに誤りがありました。コード例の中ほどに、
-----------------------
MessageDialog {

                    title: "JavaFX Script Rocks!"
                  // This string has a newline in the source code.
                  message: "JavaFX Script is Simple, Elegant,
                  and Leverages the Power of Java

--------------------------
という記述があります。そのmessage属性の設定文で、閉じ二重引用符が抜けていることが原因でした（正しくは、「・・・ Power of Java"」と二重引用符で終わらなければならない）。
不足している二重引用符を追加すると、無事一括変換が実行されます。
ところが、実行に移ると、今度は次のような誤りが発生してしまいました。
------------------------------
Exception in thread "main" java.lang.UnsupportedClassVersionError: Bad version number in .class file
at java.lang.ClassLoader.defineClass1(Native Method)
at java.lang.ClassLoader.defineClass(ClassLoader.java:620)
...
------------------------------
指導書には、JRE ５以降を使用すれば実行できると書いてあり、私は、JDK 1.5.0_11を使用しているのですが、どうもそうではないようです（まだ、Javaの版数に原因があると決まったわけではないのですが）。「一難さってまた一難」というところですが、また何か分かりましたら投稿します。
どなたか、JDK 6で試された方はいらっしゃいませんか。

一括変換型JavaFX指導書の連載が始まったのですが…

2008-02-01T14:46:00.000+09:00

Sun Developer Network (SDN) のTechnical Articles and Tips > JavaFX Technologyで、一括変換型JavaFXスクリプトについての18回連載が開始されました。
早速、第1回目の「Creating Rich Internet Applications With Compiled JavaFX Script Technology」を読み、勇んでJavaFX一括変換器の保管ファイルを入手し、記事に載っていたコード例1を一括変換してみました。ところが、「line 56:0 rule RBRACE failed predicate: { !BraceQuoteTracker.rightBraceLikeQuote(CUR_QUOTE_CTX) }?」という誤り文が、繰り返して表示されるだけで、一括変換できませんでした。
内容から察するに、中括弧の処理がうまくできないようですが、コード例には特に問題があるようには思えません。また、誤り文の表示が無限に繰り返される点からも、一括変換器自体に問題がありそうです。
JavaFXの一括変換器が利用できるのを心待ちにしていただけに、ちょっと残念です。
何か分かったら、また投稿します。

JavaFX SCADA UI：警報を発する（2）

2008-01-21T12:12:00.000+09:00

Javaプログラムで警報音を鳴動させる準備が整いましたので、JavaFXのプログラムで警報文の表示と警報音の鳴動開始／停止を制御させます。
依頼者プログラムから模擬計測値を入力したところで、その値と現在警報を発生中か否かを判定して、警報音の鳴動と警報文の表示制御を行っています。
今回、警報文の表示には、JavaFXのConfirmDialogクラスを使ってみました。表示された対話窓にある「了解」ボタンを押すと、onYes属性に定義した操作を実行する仕組みです。
企画を構築して実行すると枠付き窓が表示されます。模擬計測値が90.0を超えると、下図のような警報文の対話窓が表示されます。模擬計測値が設定値を超えている限り、了解ボタンを押しても何度でも警報が発生するようにしています。
プログラム例では、表示速度を3倍に速くしています。:-P)

package client;

import javafx.ui.*;
import javafx.ui.canvas.*;
import java.lang.System;
import client.ScadaClient;

class ScadaDataModel {
attribute presenting: Boolean;
attribute alarting: Boolean;
attribute timingGenerator: Number;
attribute numericDatum: Number;
attribute numericData: Number*;
attribute sc: ScadaClient;
function formatNumber(value:Number): String;
operation getDisplayColor(value:Number): Color;
}

attribute ScadaDataModel.timingGenerator
= bind [1..180] dur 60000 linear continue if presenting;

attribute ScadaDataModel.numericData
= foreach (i in [0..180]) 0;

function ScadaDataModel.formatNumber(value:Number): String {
return value format as <<##0.00>>;
}

operation ScadaDataModel.getDisplayColor(value:Number): Color {
var c:Color = green;
if (value > 90.0) {
c = red;
} else if (value > 75.0) {
c = Color {red: 1.0, green: 0.5, blue: 0.0};
}
return c;
}

trigger on new ScadaDataModel {
sc = new ScadaClient();
}

trigger on ScadaDataModel.timingGenerator = value {
numericDatum = sc.receiveData();
delete numericData[0];
insert numericDatum as last into numericData;
System.out.println("受信生データ: {numericDatum}");
System.out.println("書式化データ: {formatNumber(numericDatum)}");
if ((numericDatum > 90.0) and (not alarting)) {
alarting = true;
sc.startAlarm();
ConfirmDialog {
title: "警報"
message: "流量が上上限値を超過しました！"
visible: true
onYes:
operation() {
sc.stopAlarm();
alarting = false;
}
}
}
}

Frame {
var scadaData = ScadaDataModel {presenting: true, alarting: false}
title: "JavaFX SCADA UI"
centerOnScreen: true
width: 800
height: 600
background: Color {red: 0.9, green: 0.9, blue: 0.9}
onClose: operation() {System.exit(0);}
content: BorderPanel {
center: Canvas {
content:
[Group {
transform: translate(50, 50)
content:
[Rect {
height: 18
width: 50
arcHeight: 4
arcWidth: 4
stroke: blue
fill: white
},
Text {
content: bind scadaData.formatNumber(scadaData.numericDatum)
font: new Font("Monospaced", "PLAIN", 14)
x: 47
y: 4
halign: TRAILING
fill: bind scadaData.getDisplayColor(scadaData.numericDatum)
},
Text {
content: "m3/s"
x: 54
y: 6
}
]
},
Group {
transform: translate(200, 50)
content:
[
Rect {
height: 120
width: 55
stroke: blue
fill: white
},
Rect {
x: 10
y: 10
height: 100
width: 10
fill: LinearGradient {
x1: 0, y1: 0, x2: 0, y2: 1
stops:
[Stop {
offset: 0.1
color: red
},
Stop {
offset: 0.2
color: Color {red: 1.0, green: 0.5, blue: 0.0}
},
Stop {
offset: 0.4
color: Color {red: 0.5, green: 1.0, blue: 0.0}
}]
spreadMethod: PAD
}
},
Rect {
x: 10
y: 10
height: bind 100 - scadaData.numericDatum
width: 10
fill: Color {red: 0.5, green: 0.5, blue: 0.5}
},
Line {
x1: 23
y1: 10
x2: 23
y2: 110
stroke: black
},
Group {
transform: translate(23, 10)
content: foreach (i in [0,20..100])
Line {
transform: [translate(0, i)]
x1: 0
y1: 0
x2: 3
y2: 0
stroke: black
}
},
Group {
transform: translate(32, 10)
content: foreach (i in [0,20..100])
Text {
transform: [translate(0, 100 - i)]
content: "{i}"
font: new Font("Monospaced", "PLAIN", 8)
valign: MIDDLE
halign: LEADING
}
}
]
},
Group {
transform: translate(50, 200)
content:
[
Rect {
height: 120
width: 230
stroke: blue
fill: white
},
Rect {
x: 10
y: 35
height: 76
width: 181
fill: black
},
Rect {
x: 10
y: 20
height: 15
width: 181
fill: Color {red: 0.3, green: 0.3, blue: 0.3}
},
Rect {
x: 10
y: 10
height: 10
width: 181
fill: Color {red: 0.5, green: 0.5, blue: 0.5}
},
Line {
x1: 194
y1: 10
x2: 194
y2: 110
stroke: black
},
Group {
transform: translate(194, 10)
content: foreach (i in [0,20..100])
Line {
transform: [translate(0, i)]
x1: 0
y1: 0
x2: 3
y2: 0
stroke: black
}
},
Group {
transform: translate(203, 10)
content: foreach (i in [0,20..100])
Text {
transform: [translate(0, 100 - i)]
content: "{i}"
font: new Font("Monospaced", "PLAIN", 8)
valign: MIDDLE
halign: LEADING
}
},
Group {
transform: translate(10, 10)
content: foreach (i in [0..179])
Line {
transform: [translate(i, 0)]
x1: 0
y1: bind 100 - scadaData.numericData[i]
x2: 1
y2: bind 100 - scadaData.numericData[i + 1]
stroke: bind scadaData.getDisplayColor(scadaData.numericData[i + 1])
strokeWidth: 2
}
}
]
}
]
}
}
visible: true
}

IBMのdeveloperWorksでJavaFXが紹介されました

2008-01-17T16:26:00.000+09:00

ついに、IBMのdeveloperWorksにもJavaFXについての手引が載りました。これを機会に、JavaFXがより普及するとうれしいのですが。

JavaFX SCADA UI：警報を発する

2008-01-15T12:29:00.000+09:00

次に、SCADA情報として入力した模擬計測値が、あらかじめ設定した値を超えたら警報を発するようにしてみます。
まず、Javaで記述した模擬依頼者プログラムにコードを追加し、警報音の鳴動開始と、同停止手続きを追加します。
警報音のファイルは、構築子を定義してその中で読み込むようにしたかったのですが、構築子を定義すると、なぜかJavaFXのプログラムからJavaプログラムの手続きを呼び出さなくなってしまいます（誤りが発生するわけでもありません）。仕方ないので、実体変数の定義時に初期化を行って、音声ファイルを読み込むようにしました。
私は、警報音ファイルとして、自分のPCにあった「ALERT.WAV」を使用しました。Javaのプログラムでの音声ファイルの扱いについては、この投稿を参照してください（今回、警報文は、JavaFXのプログラムで表示することにしました。また、鳴動開始と停止を別の手続きにしています）。
音声ファイルを「企画名\build\classes\包み名」ディレクトリに置きます。そして、NetBeansの「プロジェクト」窓でJavaファイルをマウスで右押しし、「ファイルをコンパイル」を選択実行して、Javaファイルを一括変換しておきます。
最後に、Javaプログラムのコードを載せておきます。

package client;

import java.applet.Applet;
import java.applet.AudioClip;

public class ScadaClient {

private AudioClip ac = Applet.newAudioClip(ScadaClient.class.getResource("ALERT.WAV"));
// 模擬SCADAデータ生成用作業変数。
private int i = -1;

public double receiveData() {
// 模擬SCADAデータを生成して返す。
i += 1;
if (i >= 360) {
i = 0;
}
return (double)(Math.abs(Math.sin(i * Math.PI / 180.0) * 100));
}

public void startAlarm() {
ac.loop();
}
public void stopAlarm() {
ac.stop();
}

public static void main(String[] args) {
ScadaClient sc = new ScadaClient();
for (int i = 0; i < 5; i++) {
System.out.println(sc.receiveData());
}
}
}

JavaFX SCADA UI：記録計を作る

2008-01-11T16:12:00.000+09:00

前回の棒図式指示計に加えて、記録計を作ります。
表示装置上の記録計は、常に最新の情報を何点分か配列変数に保持しておき、その情報に基づいて線図式を描画することで実現できます。
Java言語等で配列変数を扱う場合、最新の情報が得られるたびに、既存の配列要素をずらして新たな情報を追加するという操作を行う必要があります。単純な処理ですが、あまり美しいものではありません。
JavaFXでは、単に、配列から最も古い情報を削除し、新たな情報を所要の位置に挿入するだけで済みます。添え字の付け替え操作が不要なため、簡潔で無駄のない記述が可能です。
プログラムの例では、模擬依頼者から新たな情報を取得するたびに、配列の先頭要素を削除し、取得した情報を配列の末尾に挿入しています。
後は、保持している情報を基にして、線図式を描画するだけです。
企画を構築して実行すると枠付き窓が表示され、窓の左下に右図のような記録計が表示されます。

package client;

import javafx.ui.*;
import javafx.ui.canvas.*;
import java.lang.System;
import client.ScadaClient;

class ScadaDataModel {
attribute presenting: Boolean;
attribute timingGenerator: Number;
attribute numericDatum: Number;
attribute numericData: Number*;
attribute sc: ScadaClient;
function formatNumber(value:Number): String;
operation displayColor(value:Number): Color;
}

attribute ScadaDataModel.timingGenerator
= bind [1..60] dur 60000 linear continue if presenting;

attribute ScadaDataModel.numericData
= foreach (i in [0..180]) 0;

function ScadaDataModel.formatNumber(value:Number): String {
return value format as <<##0.00>>;
}

operation ScadaDataModel.displayColor(value:Number): Color {
var c:Color = green;
if (value > 90.0) {c = red;}
else if (value > 75.0) {c = Color {red: 1.0, green: 0.5, blue: 0.0};}
return c;
}

trigger on new ScadaDataModel {
sc = new ScadaClient();
}

trigger on ScadaDataModel.timingGenerator = value {
numericDatum = sc.receiveData();
delete numericData[0];
insert numericDatum as last into numericData;
System.out.println("受信生データ: {numericDatum}");
System.out.println("書式化データ: {formatNumber(numericDatum)}");
}

Frame {
var scadaData = ScadaDataModel {presenting: true}
title: "JavaFX SCADA UI"
centerOnScreen: true
width: 800
height: 600
background: Color {red: 0.9, green: 0.9, blue: 0.9}
onClose: operation() {System.exit(0);}
content: BorderPanel {
center: Canvas {
content:
[Group {
transform: translate(50, 50)
content:
[Rect {
height: 18
width: 50
arcHeight: 4
arcWidth: 4
stroke: blue
fill: white
},
Text {
content: bind scadaData.formatNumber(scadaData.numericDatum)
font: new Font("Monospaced", "PLAIN", 14)
x: 47
y: 4
halign: TRAILING
fill: bind scadaData.displayColor(scadaData.numericDatum)
},
Text {
content: "m3/s"
x: 54
y: 6
}
]
},
Group {
transform: translate(200, 50)
content:
[
Rect {
height: 120
width: 55
stroke: blue
fill: white
},
Rect {
x: 10
y: 10
height: 100
width: 10
fill: LinearGradient {
x1: 0, y1: 0, x2: 0, y2: 1
stops:
[Stop {
offset: 0.1
color: red
},
Stop {
offset: 0.2
color: Color {red: 1.0, green: 0.5, blue: 0.0}
},
Stop {
offset: 0.4
color: Color {red: 0.5, green: 1.0, blue: 0.0}
}]
spreadMethod: PAD
}
},
Rect {
x: 10
y: 10
height: bind 100 - scadaData.numericDatum
width: 10
fill: Color {red: 0.5, green: 0.5, blue: 0.5}
},
Line {
x1: 23
y1: 10
x2: 23
y2: 110
stroke: black
},
Group {
transform: translate(23, 10)
content: foreach (i in [0,20..100])
Line {
transform: [translate(0, i)]
x1: 0
y1: 0
x2: 3
y2: 0
stroke: black
}
},
Group {
transform: translate(32, 10)
content: foreach (i in [0,20..100])
Text {
transform: [translate(0, 100 - i)]
content: "{i}"
font: new Font("Monospaced", "PLAIN", 8)
valign: MIDDLE
halign: LEADING
}
}
]
},
Group {
transform: translate(50, 200)
content:
[
Rect {
height: 120
width: 230
stroke: blue
fill: white
},
Rect {
x: 10
y: 35
height: 76
width: 181
fill: black
},
Rect {
x: 10
y: 20
height: 15
width: 181
fill: Color {red: 0.3, green: 0.3, blue: 0.3}
},
Rect {
x: 10
y: 10
height: 10
width: 181
fill: Color {red: 0.5, green: 0.5, blue: 0.5}
},
Line {
x1: 194
y1: 10
x2: 194
y2: 110
stroke: black
},
Group {
transform: translate(194, 10)
content: foreach (i in [0,20..100])
Line {
transform: [translate(0, i)]
x1: 0
y1: 0
x2: 3
y2: 0
stroke: black
}
},
Group {
transform: translate(203, 10)
content: foreach (i in [0,20..100])
Text {
transform: [translate(0, 100 - i)]
content: "{i}"
font: new Font("Monospaced", "PLAIN", 8)
valign: MIDDLE
halign: LEADING
}
},
Group {
transform: translate(10, 10)
content: foreach (i in [0..179])
Line {
transform: [translate(i, 0)]
x1: 0
y1: bind 100 - scadaData.numericData[i]
x2: 1
y2: bind 100 - scadaData.numericData[i + 1]
stroke: bind scadaData.displayColor(scadaData.numericData[i + 1])
strokeWidth: 2
}
}
]
}
]
}
}
visible: true
}

JavaFX SCADA UI：図式指示計を作る

2007-12-22T14:44:00.000+09:00

続いて、棒図式指示計を作ってみます。こちらの方は、特に言語上問題になる点はありません。
ただの棒図式ではつまらないので、線形階調表示LinearGradientを指定して棒図式を描かせてみました。階調表示の指定が簡単になるよう、棒図式の矩形は固定の高さで描き、背景となる矩形の方の高さを指示計の値に合わせて変えています。
また、目盛線と目盛値は、foreach文を使って生成しています。
企画を構築して実行すると枠付き窓が表示され、数値指示計の横に右図のような棒図式指示計が表示されます。
下に載せたプログラムの例では、結果が早く見られるよう、画面の更新間隔を0.5秒にしてあります。

package client;

import javafx.ui.*;
import javafx.ui.canvas.*;
import java.lang.System;
import client.ScadaClient;

class ScadaDataModel {
attribute presenting: Boolean;
attribute timingGenerator: Number;
attribute numericData: Number;
attribute sc: ScadaClient;
function formatNumber(value:Number): String;
operation textColor(value:Number): Color;
}

attribute ScadaDataModel.timingGenerator
= bind [1..120] dur 60000 linear continue if presenting;

function ScadaDataModel.formatNumber(value:Number): String {
return value format as <<##0.00>>;
}

operation ScadaDataModel.textColor(value:Number): Color {
var c:Color = green;
if (value > 90.0) {c = red;}
else if (value > 75.0) {c = Color {red: 1.0, green: 0.5, blue: 0.0};}
return c;
}

trigger on new ScadaDataModel {
sc = new ScadaClient();
}

trigger on ScadaDataModel.timingGenerator = value {
numericData = sc.receiveData();
System.out.println("受信生データ: {numericData}");
System.out.println("書式化データ: {formatNumber(numericData)}");
}

Frame {
var scadaData = ScadaDataModel {presenting: true}
title: "JavaFX SCADA UI"
centerOnScreen: true
width: 800
height: 600
background: Color {red: 0.9, green: 0.9, blue: 0.9}
onClose: operation() {System.exit(0);}
content: BorderPanel {
center: Canvas {
content:
[Group {
transform: translate(50, 50)
content:
[Rect {
height: 18
width: 50
arcHeight: 4
arcWidth: 4
stroke: blue
fill: white
},
Text {
content: bind scadaData.formatNumber(scadaData.numericData)
font: new Font("Monospaced", "PLAIN", 14)
x: 47
y: 4
halign: TRAILING
fill: bind scadaData.textColor(scadaData.numericData)
},
Text {
content: "m3/s"
x: 54
y: 6
}
]
},
Group {
transform: translate(200, 50)
content:
[
Rect {
height: 120
width: 55
stroke: blue
fill: white
},
Rect {
x: 10
y: 10
height: 100
width: 10
fill: LinearGradient {
x1: 0, y1: 0, x2: 0, y2: 1
stops:
[Stop {
offset: 0.1
color: red
},
Stop {
offset: 0.2
color: Color {red: 1.0, green: 0.5, blue: 0.0}
},
Stop {
offset: 0.4
color: Color {red: 0.5, green: 1.0, blue: 0.0}
}]
spreadMethod: PAD
}
},
Rect {
x: 10
y: 10
height: bind 100 - scadaData.numericData
width: 10
fill: Color {red: 0.5, green: 0.5, blue: 0.5}
},
Line {
x1: 23
y1: 10
x2: 23
y2: 110
stroke: black
},
Group {
transform: translate(23, 10)
content: foreach (i in [0,20..100])
Line {
transform: [translate(0, i)]
x1: 0
y1: 0
x2: 3
y2: 0
stroke: black
}
},
Group {
transform: translate(34, 10)
content: foreach (i in [0,20..100])
Text {
transform: [translate(0, 100 - i)]
content: "{i}"
font: new Font("Monospaced", "PLAIN", 8)
valign: MIDDLE
halign: LEADING
}
}
]
}
]
}
}
visible: true
}

JavaFX SCADA UI：数値指示計を作る

2007-12-20T12:16:00.000+09:00

Javaプログラムから受け取った実数値を、JavaFXプログラムで書式設定して表示することができました。そこで、ごく簡単な数値表示器を仕立て、枠付き窓の適当な位置に配置してみたいと思います。
実数値を表示する文字列Text、その背景となる矩形Rect、および単位を表示する文字列Textを、Groupで組にし、アフィン変換transformを指定して、画面上の任意の位置に配置します。
実数値に設定した書式は固定幅ではないので、Textのhalign属性にTRAILINGを指定し、文字列の末尾（文字列を囲む矩形の右上隅の点）を座標指定の基準点とします。
また、数値指示計に表示される文字は、等幅の書体の方が読みやすいので、Textのfont属性にはMonospacedのＦｏｎｔを生成して設定しています。
ただ数値を表示するだけでは面白くないので、数値が上限値と上上限値を超えると、表示色が緑から橙、赤と変わるようにしてみました。「上上限値」という言い方は計測制御の分野独特のもので、上限値を2段階に設け、その上の方の上限値をさします（同様に、下の方の下限値は「下下限値」と言います）。英語だとなんと言うんでしょうね。「Upper maximum」では、ちょっと意味が違うし…。
ScadaDataModelクラスにtextColor()操作を定義し、引数で渡された値によって、3種類の色オブジェクトColorを返すようにしました。この操作をTextオブジェクトのfill属性に結合し、数値にあわせてその表示色を変えています。
企画を構築して実行すると、枠付き窓が表示され、その左上の方に右図のような簡易数値指示計が表示されます。
等幅の書体を指定したので、小数点もそれなりの幅を持って表示されます。しかし、表示を繰り返していると、なぜか数値表示の部分だけが左右に微妙にぶれてしまいます。ＪａｖａＦＸも、細かい点での改良の余地は、まだまだありそうですね。
いつもどおり、最後に源コードを載せておきます。

package client;

import javafx.ui.*;
import javafx.ui.canvas.*;
import java.lang.System;
import client.ScadaClient;

class ScadaDataModel {
attribute presenting: Boolean;
attribute timingGenerator: Number;
attribute numericData: Number;
attribute sc: ScadaClient;
function formatNumber(value:Number): String;
operation textColor(value:Number): Color;
}

attribute ScadaDataModel.timingGenerator
= bind [1..60] dur 60000 linear continue if presenting;

function ScadaDataModel.formatNumber(value:Number): String {
return value format as <<##0.00>>;
}

operation ScadaDataModel.textColor(value:Number): Color {
var c:Color = green;
if (value > 10.0) {c = red;}
else if (value > 5.0) {c = Color {red: 1.0, green: 0.5, blue: 0.0};}
return c;
}

trigger on new ScadaDataModel {
sc = new ScadaClient();
}

trigger on ScadaDataModel.timingGenerator = value {
numericData = sc.receiveData();
System.out.println("受信生データ: {numericData}");
System.out.println("書式化データ: {formatNumber(numericData)}");
}

Frame {
var scadaData = ScadaDataModel {presenting: true}
title: "JavaFX SCADA UI"
centerOnScreen: true
width: 800
height: 600
background: Color {red: 0.9, green: 0.9, blue: 0.9}
onClose: operation() {System.exit(0);}
content: BorderPanel {
center: Canvas {
content:
[Group {
transform: translate(50, 50)
content:
[Rect {
height: 18
width: 50
arcHeight: 4
arcWidth: 4
stroke: blue
fill: white
},
Text {
content: bind scadaData.formatNumber(scadaData.numericData)
font: new Font("Monospaced", "PLAIN", 14)
x: 47
y: 4
halign: TRAILING
fill: bind scadaData.textColor(scadaData.numericData)
},
Text {
content: "m3/s"
x: 54
y: 6
}]
}]
}
}
visible: true
}

JavaFX SCADA UI：UIプログラムで数値を表示する

2007-12-19T12:04:00.000+09:00

Javaで記述した模擬依頼者プログラムから、UIプログラムへSCADA情報（実数値）を渡す準備ができました。そこで、JavaFXでUIプログラムを記述して、それを枠付き窓に数値表示させることにします。
数値は、JavaFXの書式設定演算子formatを利用して、小数点以下第2位までの表示とします。書式として、「##0.00」形式を指定しました。丸め方法も指定できると良かったのですが、現状のJavaFXではそこまで記述できません。
Javaでは数値の書式として、「%m.nf」形式で全体の桁数と小数点以下の桁数を指定することができます。JavaFXでもこの書式を使えないわけではありません。UIの窓に数値指示計として表示するには、こちらの方が都合はいいです。
しかし、現状では「%m.nf」形式の使用にいろいろと制限がついてしまいます。私のプログラムでは、置換引金の処理で、Javaプログラムから数値を読み込んでいます。「%m.nf」形式を有効にするためには、この区画の中でJavaクラスの実体を生成し、その参照変数を介して実体手続きを呼び出すようにするか、実体を生成したくない場合は、クラス手続きを呼び出すようにしなければなりません。そうしないと、「illegal format specifier %8.2f」のような誤りになってしまいます。
更に、そうして「%m.nf」形式で書式を設定しても、それを割り当てる図形要素によって、書式が有効になるものとならないものがあります。Label要素では有効ですが、Text要素では無効で、頭の空白文字は無視されてしまいます。
今回の例では、書式指定が利用できることを示すために、Label要素を使用していますので、「%m.nf」形式を指定しても問題はありません。しかし、後で、文字列を図形や画像と組み合わせて表示できるよう、Text要素を使うつもりですので、「%m.nf」形式は使用しませんでした。
前説が長くなりましたが、プログラムの作成に話を進めます。12月18日の投稿で作成した「Javaアプリケーションプロジェクト」内に、UIプログラム用のJavaFXファイルを作成します。以前に紹介した目覚まし時計のプログラムでは、JavaとJavaFXの企画（Project）を分けました。今回は、同じJava企画にJavaFXプログラムも記述します。その方が、構築作業が楽になります。
私は、「ScadaClientUI」という名前でJavaFXファイルを作成しました。ファイルを作成したら、企画名をマウスで右押しし、表示される状況目録から、「プロパティー」を選択します。表示された窓の「カテゴリ」から「実行」を選択し、右側に表示された「引数」文字列枠に、作成したJavaFXのファイル名を包み名付きで設定します。私は、包み名を「client」としましたので、「client.ScadaClientUI」と設定しました。
ページの最後にコードを載せておきます。なお、目覚まし時計と同様に、編集用具上では「import client.ScadaClient;」の「ScadaClient」の部分に、誤りを示す赤い波線が表示されますが、無視します。
企画を構築して実行すると、次のように、出力窓と枠付き窓に書式化された数値が、1秒ごとに表示されます（ときどき、表示の更新が欠落することがありますが、そこはご愛嬌ということで）。

package client;

import javafx.ui.*;
import javafx.ui.canvas.*;
import java.lang.System;
import client.ScadaClient;

class ScadaDataModel {
attribute presenting: Boolean;
attribute timingGenerator: Number;
attribute numericData: Number;
attribute sc: ScadaClient;
function formatNumber(value:Number): String;
}

attribute ScadaDataModel.timingGenerator
= bind [1..60] dur 60000 linear continue if presenting;

function ScadaDataModel.formatNumber(value:Number): String {
return value format as <<##0.00>>;
}

trigger on new ScadaDataModel {
sc = new ScadaClient();
}

trigger on ScadaDataModel.timingGenerator = value {
numericData = sc.receiveData();
System.out.println("受信生データ: {numericData}");
System.out.println("書式化データ: {formatNumber(numericData)}");
}

Frame {
var scadaData = ScadaDataModel {presenting: true}
title: "JavaFX SCADA UI"
centerOnScreen: true
width: 400
height: 200
onClose: operation() {System.exit(0);}
content: Label {
text: bind scadaData.formatNumber(scadaData.numericData)
}
visible: true
}

JavaFX SCADA UI：模擬依頼者を作る

2007-12-18T12:03:00.000+09:00

これから、JavaFXでSCADAのUIプログラムを構築していきます。最初に、UIプログラムにSCADA情報を提供する依頼者の処理を模擬するプログラムを、Javaで作ります。
依頼者からUIプログラムへは倍精度浮動小数点数の模擬情報を渡し、UIプログラムで数値指示計や図式指示計などにその値を数値や図式として表示させます。値は何でも良いのですが、とりあえず正弦関数の絶対値を100倍して渡すことにしました。依頼者の手続きが呼び出されるたびに、正弦関数の角度を1度ずつ増やして計算します。
まず、NetBeansで「Javaアプリケーションプロジェクト」（名前は任意）を作成します。同様に任意の「パッケージ名」と「クラス名」を指定して、Javaクラスを作成します。私は、パッケージ名に「client」、クラス名に「ScadaClient」を指定しました。
Javaクラスには実体手続きを定義し、上記の値を計算して戻り値として返すようにしました。また、主手続きで、作成した実体手続きの動作確認を行っています。
私が作成したコードを、最後に載せておきます（例によって、字下げが消えてるため、読みづらくてすみません）。Javaアプリケーションプロジェクトを構築・実行すると、0～4度までの5つの正弦関数値が、出力窓に表示されます。

package client;

public class ScadaClient {

// 模擬SCADAデータ生成用作業変数。
private int i = -1;

public double receiveData() {
// 模擬SCADAデータを生成して返す。
i += 1;
if (i >= 360) {
i = 0;
}
return (double)(Math.abs(Math.sin(i * Math.PI / 180.0) * 100));
}

public static void main(String[] args) {
ScadaClient sc = new ScadaClient();
for (int i = 0; i <>

JavaFX SCADA UI：はじめに

2007-12-17T17:13:00.000+09:00

前に、目覚まし時計を作りましたので、次は、SCADAのUIをJavaFXで作ってみたいと思います。
そもそも、JavaFXを含め、RIAの調査を始めたきっかけが、SCADAのUIをAppletよりも簡単かつ表現力豊かに構築する方法はないかということでしたので、ようやく本題に突入と言ったところでしょうか。
SCADAとは、「Supervisory Control And Data Acquisition」の頭文字をとったもので、日本では「遠隔監視制御システム」などと呼ばれています。その名のとおり、諸所に分散した施設の設備や機器の運転情報を収集して処理するとともに、運転制御をも行う機構です（監視だけを行うものもあります）。
関連する技術分野が多方面に及ぶ（分散処理、画像処理、データベース、AI、電子郵便、携帯端末、RAS、などなど、数え上げると切りがない）ため、プログラミングの題材としては、なかなか面白いものです。
機構全体としては、かなり膨大なものになりうるのですが、ここではその内のUI部分を（それも、かなり単純化して）構築することにします。したがって、SCADA役務の依頼者と提供者間の通信の実現方法については考慮しません。何らかの方法で依頼者はSCADA役務の提供を受けることができる、という前提で作成します。
例によって、開発環境としてNeｔBeansを使います。「それでは、…」と言いたいところですが、今日は前置きで終わりです。

JavaFX安定版の公開時期

2007-12-16T12:34:00.000+09:00

JavaFX共同体討論場に載せられていた投稿によると、JavaFXのある程度の安定版公開時期は、来年のJavaOneのころになるようです。
今は、その黎明期の姿を垣間見ることができる、貴重なときなのかもしれません。

SunもJavaFX用GUI構築用具を開発中

2007-12-13T14:19:00.000+09:00

ベルギーで開催されたJavaPolis 2007（ヨーロッパ版のJavaOne）において、SunのJames Gosling氏が基調講演を行い、SunがJavaFX用のGUI構築用具の原型版を開発中であることを披露されました。
JavaFXにおけるGUIプログラミングは、Javaにおけるそれよりはるかに容易になったとはいえ、やはりGUIはWYSIWYGで設計したいものです。NetBeansのMatisseようなGUI構築用具を一度使うと、正直、WYSIWYGで編集できないのはつらいものがあります。
JavaFX用のGUI構築用具としては、ご存知のように、JFXBuilderというお試し用具もあるようですが、Sunのものはどのような機能を提供してくれるのか、今から楽しみです。

JavaFXファイルでJavaクラスを輸入するときはご注意を

2007-12-11T20:11:00.000+09:00

現状の逐次解釈（Interpreter）版のJavaFXプログラムで、Javaのクラスを輸入（import）して使うときは、ちょっと注意が必要です。
少なくとも現状の逐次解釈版のJavaFX（一括変換（Compiler）版では調べていません）プログラムでは、java.lang.Systemクラスなどを輸入して使う場合、包み（Package）全体の輸入宣言「import java.lang.*;」で済ますと、思わぬ誤動作をすることがありますので注意が必要です。
私が経験した事例では、java.lang包みの輸入宣言を行っているプログラムで、クラスに数値（Number）型の属性を定義し、その属性に実数を格納したときに、その整数部分しか格納されないというものでした（同じプログラム内で、クラス属性ではなく、数値型としてvar宣言した変数には実数として格納されるので、ややこしい）。
いろいろ調べた結果、包み全体ではなく、java.lang.Systemクラスを明示的に宣言することで、この不具合が解消されることが分かりました。
もともと、Javaのプログラムでも、包み全体ではなく、なるべく個々のクラスごとに輸入宣言を記述する方が良いとはされていますが、包み全体の輸入を宣言してもプログラムが誤動作をすることはありません。ですから、包みの宣言でも正常に動作するのが、本来の姿だとは思いますが。

JavaFX言語の展開：置換引金の定義場所と構文の変更

2007-12-08T12:03:00.000+09:00

これまで、クラス属性の置換引金はクラス本体の外で定義していましたが、これからは、クラス属性の宣言の一部として記述するようになります。そして、置換引金の構文も、鍵語が「trigger on」から「on replace」へと、置換処理の定義であることを明示したものに変わります。
（旧）

class Foo {
     attribute bar: Boolean = true;
}
trigger on Foo.bar = value {
     if (bar == true) {
         beep();
     }
}

（新）

class Foo {
     attribute bar: Boolean = true on replace {
         if (bar == true) {
             beep();
         }
     };
 }

JavaFX言語の展開：クラス属性の初期値の設定場所

2007-12-07T11:14:00.000+09:00

これまで、クラスの属性（attribute）が初期値を持つ場合、クラス本体の外でその設定を行っていました。これからは、Javaのように、クラスの本体内で属性の宣言と初期値の設定を行うようになります。
（旧）

class Foo {
    attribute bar: Boolean;
}

attribute Foo.bar = true;

（新）

class Foo {
    attribute bar: Boolean = true;
}

JavaFX言語の展開：関数と操作の統合

2007-12-06T12:11:00.000+09:00

11月27日の投稿でも少しふれましたが、ＪａｖａＦＸ言語も、コンパイラのサポートとともに、より明快で使いやすいものへと発展しようとしています。
そこで、ＪａｖａＦＸはどのように変わるのか、ということについて検討中の話題も含めて整理しておきたいと思います。
まずは、「functionとoperationの統合」についてです。
現状のインタプリタ版では、手続きの記述方法として関数（function）と操作（operation）の２つが用意されています。関数は、return文を用いて必ず値を返し、結合演算子（bind）を明示的に指定しなくても、その本体は差分評価（incremental evaluation）されます。それに対して、操作の方は、必ずしも値を返す必要がなく、関数では使えない制御文が使えます。その代わり、操作の本体は関数のように暗黙的に差分評価されることはありません。
しかし、手続きとして関数と操作の２種類があると紛らわしいので、次のように関数に統合されることになります（「旧」はこれまでのインタプリタ版で用いられていた構文を、「新」はコンパイラ版で新しく適用される構文を意味します）。
（旧）

class Foo {
 function times2(x) { return x * 2; }
 operation print(s) { System.out.println(s); }
}

（新）

class Foo {
 function times2(x) { return x * 2; }
 function print(s)  { System.out.println(s); }
}

JavaFXでアラーム時計を作る（完成で～す！）

2007-12-05T11:51:00.000+09:00

タイマの残り時間が０になるとアラームが鳴るようになりましたので、タイマの時間をＵＩから設定できるようにします。また、タイマが作動中に電話などの割り込みが入ったときは、カウントダウンを一時中断できるようにもしてみます。
完成したタイマのウィンドウイメージは、右の図のようになります（昔よく見かけた柱時計みたいになってしまいました）。
タイマの時間をスピナで設定し、スタートボタンを押すとカウントダウンを開始し、ストップボタンを押すとカウントダウンを停止します。時間設定のスピナは、残り時間のディジタル表示器の役目もしてくれます。
コード自体は、いたってシンプルなので、JavaFX Script プログラミング言語リファレンスや深く学ぼう JavaFX Script 言語を参考に読んでいただければ、何を行っているかすぐ分かると思います。
と言うわけで、ごちゃごちゃ書かずに、変更版のアラーム時計ＪａｖａＦＸファイル「AlarmClock.fx」のソースコード全体を載せてしまいます。

package timer;

import javafx.ui.*;
import javafx.ui.canvas.*;
import java.util.Date;
import java.lang.Math;
import java.lang.System;
import timer.Sound;

public class Timer {
private attribute elapsed: Number;
public attribute seconds: Number;
public attribute minutes: Integer;
public attribute hours: Integer;
public attribute count: Number;
public attribute startTime: Number;
public attribute elapsedTime: Number;
public attribute remainingTime: Number;
public attribute running: Boolean;
public attribute alarmEnabled: Boolean;
}

attribute Timer.elapsed = bind if running
then [1..10] dur 1000 linear while running continue if running
else 0;

trigger on Timer.elapsed = value {
var now = new Date();
elapsedTime = now.getTime() / 1000 - startTime;
remainingTime = count - elapsedTime;
running = if (elapsedTime >= count) then false else running;
seconds = remainingTime % 60;
minutes = ((Integer)remainingTime / 60) % 60;
hours = ((Integer)remainingTime / 60) / 60;
hours = if (elapsedTime >= count) then 0 else hours;
minutes = if (elapsedTime >= count) then 0 else minutes;
seconds = if (elapsedTime >= count) then 0 else seconds;
}

trigger on Timer.running = value {
if ((alarmEnabled == true) and (remainingTime <= 0)) {
alarmEnabled = false;
Sound.alarm();
}
}

Frame {
var t = Timer {seconds:0, minutes:0, hours:0, count:0,
running:false, alarmEnabled:false}
title: "JavaFX アラーム"
height: 350
width: 215
onClose: operation() {System.exit(0);}
content: BorderPanel {
center: Canvas {
content:
Group {
var font = new Font("Dialog", "PLAIN", 15)
var secs = bind t.seconds
var mins = bind t.minutes + secs / 60
var hrs = bind t.hours + mins / 60
content:
[Rect {
height: 400
width: 225
fill: Color {red:0.9, green:0.9, blue:0.9}
},
Circle {cx: 100, cy: 100, radius: 80, fill: white, stroke: black, strokeWidth: 1},
Group {
transform: translate(100, 100)
content: foreach (i in [1..12])
Text {
var radians = Math.toRadians(30 * i - 90)
transform: [translate((70 * Math.cos(radians)), (70 * Math.sin(radians)))]
content: "{i}"
valign: MIDDLE
halign: CENTER
}
},
Group {
transform: translate(100, 100)
var hourHand =
Line {x1: 0, y1: 0, x2: 0, y2: -35,
strokeWidth: 4, stroke: black
transform: bind rotate((hrs * 30), 0, 0)
}
var minuteHand =
Line {x1: 0, y1: 0, x2: 0, y2: -55,
strokeWidth: 2, stroke: blue,
transform: bind rotate((mins * 6), 0, 0)
}
var secondHand =
Line {x1: 0, y1: 0, x2: 0, y2: -75,
strokeWidth: 1, stroke: red,
transform: bind rotate((t.seconds * 6), 0, 0)
}
content: [hourHand, minuteHand, secondHand]
},
Circle {cx: 100, cy: 100, radius: 3, fill: black, stroke: black }]
},
}
bottom: Box {
background: white
orientation: VERTICAL
content:
[FlowPanel {
content:
[Spinner {
enabled: bind not(t.running)
min: 0
max: 23
value: bind t.hours
},
SimpleLabel {
enabled: bind not(t.running)
text: "時"
}]
},
FlowPanel {
content:
[Spinner {
enabled: bind not(t.running)
min: 0
max: 59
value: bind t.minutes
},
SimpleLabel {
enabled: bind not(t.running)
text: "分"
}]
},
FlowPanel {
content:
[Spinner {
enabled: bind not(t.running)
min: 0
max: 59
value: bind t.seconds
},
SimpleLabel {
enabled: bind not(t.running)
text: "秒"
}]
},
FlowPanel {
content:
[Button {
enabled: bind t.running
text: "ストップ"
action: bind operation() {
t.running = false;
}
},
RigidArea {
width: 20
},
Button {
enabled: bind not(t.running)
text: "スタート"
action: operation() {
var date = new Date();
t.count = t.hours * 3600 + t.minutes * 60 + t.seconds;
t.startTime = date.getTime() / 1000;
t.remainingTime = t.count;
if (t.count <> 0) {
t.alarmEnabled = true;
t.running = true;
}
}
}]
}]
}
}
visible: true
}

JavaFXでアラーム時計を作る（3）

2007-12-04T12:30:00.000+09:00

アラーム音再生やメッセージ表示の準備ができたので、ＪａｖａＦＸのプログラムからこれを呼び出せるようにしてみます（以降、いずれもＮｅｔＢｅａｎｓで作業を行う場合を例に記述しています）。
作成したアラーム出力Ｊａｖａアプリケーションプロジェクトの、「〈プロジェクト名〉\build\classes\〈パッケージ名〉\」ディレクトリの下に構築されたクラスファイル（私の場合は、「Sound..class」）と、コピーしておいたサウンドファイル（同様に、「TestMusic.wav」）を、ともに、アラーム時計ＪａｖａＦＸアプリケーションプロジェクトの方の「〈プロジェクト名〉\build\classes\〈パッケージ名〉\」ディレクトリの下にコピーします。
そして、１２月２日の投稿で紹介した上記のアラーム時計ＪａｖａＦＸファイル（同じく「AlarmClock.fx」）に、以下の変更を加えます。
まず、アラーム出力クラスのインポート文を追加します（以下、いずれも私が指定したパッケージ名やファイル名で記述します）。

import timer.Sound;

このとき、「Sound」の下に赤い波線が表示され、「undefined type ...」のエラーアイコンが表示されますが、無視します（エラーメッセージが表示されますが、ちゃんとクラスファイルを認識しています）。
そして、Timer.elapsedの置換triggerアクションの定義に続けて、次のTimer.runningの置換triggerアクションの定義を追加します。

trigger on Timer.running = value {
if (remainingTime <= 0) {Sound.alarm();} }

これで、準備が整いました。最後に、アラーム時計アプリケーションのプロジェクトを構築しなおして（このとき、「Clean and Build Project」を実行しないように注意します。せっかくコピーしたアラーム出力クラスファイルとサウンドファイルが消されてしまいます）、プロジェクトを実行します。
アラーム時計のウィンドウが表示され、タイマに設定した時間（現在は１０秒固定）が経過すると、アラーム音が鳴り、メッセージウィンドウが表示されます。

ここまでくれば、アラームタイマはほとんど完成したも同然です。あとは、タイマの時間を設定できるようにするだけですが、今日はここまで。いつものように、ソースコード全体を載せておきます。

package timer;

import javafx.ui.*;
import javafx.ui.canvas.*;
import java.util.Date;
import java.lang.Math;
import java.lang.System;
import timer.Sound;

public class Timer {
private attribute elapsed: Number;
public attribute seconds: Number;
public attribute minutes: Integer;
public attribute hours: Integer;
public attribute count: Number;
public attribute startTime: Number;
public attribute elapsedTime: Number;
public attribute remainingTime: Number;
public attribute running: Boolean;
}

attribute Timer.elapsed = bind if running
then [1..10] dur 1000 linear while running continue if running
else 0;

trigger on Timer.elapsed = value {
var now = new Date();
elapsedTime = now.getTime() / 1000 - startTime;
remainingTime = count - elapsedTime;
running = if (elapsedTime >= count) then false else true;
seconds = remainingTime % 60;
minutes = ((Integer)remainingTime / 60) % 60;
hours = ((Integer)remainingTime / 60) / 60;
hours = if (elapsedTime >= count) then 0 else hours;
}

trigger on Timer.running = value {
if (remainingTime <= 0) {Sound.alarm();}
}

var date = new Date();

Frame {
var t = Timer {seconds:10, minutes:0, hours:0, count:10,
startTime:(date.getTime() / 1000), running:true}
title: "JavaFX アラーム"
height: 225
width: 215
onClose: operation() {System.exit(0);}
content:
Canvas {
content:
Group {
var font = new Font("Dialog", "PLAIN", 15)
var secs = bind t.seconds
var mins = bind t.minutes + secs / 60
var hrs = bind t.hours + mins / 60
content:
[Rect {
height: 225
width: 225
fill: white
},
Circle {cx: 100, cy: 100, radius: 80, fill: white, stroke: black, strokeWidth: 1},
Group {
transform: translate(100, 100)
content: foreach (i in [1..12])
Text {
var radians = Math.toRadians(30 * i - 90)
transform: [translate((70 * Math.cos(radians)), (70 * Math.sin(radians)))]
content: "{i}"
valign: MIDDLE
halign: CENTER
}
},
Group {
transform: translate(100, 100)
var hourHand =
Line {x1: 0, y1: 0, x2: 0, y2: -35,
strokeWidth: 4, stroke: black
transform: bind rotate((hrs * 30), 0, 0)
}
var minuteHand =
Line {x1: 0, y1: 0, x2: 0, y2: -55,
strokeWidth: 2, stroke: blue,
transform: bind rotate((mins * 6), 0, 0)
}
var secondHand =
Line {x1: 0, y1: 0, x2: 0, y2: -75,
strokeWidth: 1, stroke: red,
transform: bind rotate((t.seconds * 6), 0, 0)
}
content: [hourHand, minuteHand, secondHand]
},
Circle {cx: 100, cy: 100, radius: 3, fill: black, stroke: black }]
},
}
visible: true
}

JavaFXでアラーム時計を作る（2）

2007-12-03T10:50:00.000+09:00

せっかく、時計がカウントダウン表示されるようになったので、時間になったらアラーム音が鳴って、メッセージウィンドウが表示されるようにしてみます。
残念ながら、現状のJavaFX自体には、サウンド再生のサポートはありません（アニメーションと同期させてサウンドを再生するなどの応用を考えると、JavaFXでサウンドの再生やアニメーションとの同期などを簡潔に記述できるといいのですが…）。そこで、Javaのプログラムで音の再生とメッセージの表示を行うクラスを作成し、JavaFXのプログラムからそれを呼び出すことにしました。
NetBeansでJavaアプリケーションのプロジェクト（名前は任意）を作成し、パッケージ名を「timer」、ファイル名を「Sound.java」として、クラスファイルを作成します（パッケージ名は、作成済みのJavaFXファイルで指定したパッケージ名にあわせました。ファイル名は、その名前でJavaFXプログラムから参照しさえすれば、何でもかまいません）。
サウンドの再生には、Java Appletなどで使うAudioClipクラスを利用します。ただ、Appletを作るわけではないので、java.applet.AppletクラスのクラスメソッドnewAudioClip()でサウンドファイルを読み込むようにします。このメソッドの引数には、サウンドファイルのURLを指定しないといけないのですが、それでは不便なので、作成するクラスの基底クラスclassからgetResource()メソッドを呼びだして、サウンドファイルのURLを取得し、引数に指定します。
AudioClipを生成したら、あとは、そのplay()メソッドを呼び出してサウンドをワンタイム再生するか、loop()メソッドとstop()メソッドで繰り返し再生とその停止を行うようにします。私は、メッセージウィンドウの表示に先立ってサウンドの繰り返し再生を起動し、メッセージウィンドウが閉じられたら再生を停止するようにしました。
サウンドファイルのタイプとしては、「.au」ファイルと「.wav」ファイルのどちらも指定できます。自分のパソコンから好きな音のファイルを捜してきて（ネットワークからダウンロードしてもいいのですが、得体の知れないものは怖いので）、そのファイルを、作成するクラスの「.class」ファイルが出力されるディレクトリ（プロジェクトファイルの下の「build\classes\〈パッケージ名〉\」ディレクトリ）にコピーします（このとき、ファイル検索ウィンドウからファイルを持ってくるときは、ファイルの移動を行わないように注意してください。不用意にドラッグするとファイルが移動され、元の場所からなくなってしまいます）。私は、「TestMusic.wav」という、ちょっと軽快な音楽が演奏されるファイルを選びました。
メッセージウィンドウの表示には、おなじみのJOptionPane.showMessageDialog()を使用しました。showMessageDialog（ＶＢのMsgboxに相当）は、ちょっとしたデバッグなどにも使えて便利なのですが、ダイアログウィンドウが必ずしもウィンドウスタックの最前面に表示されるわけではない、という難点（？）があります。この点については、同じように不便だと思われた方がいらしたようで、改造版を作られています。興味のある方は、Googleなどで検索してみてください。
作成したプロジェクトを構築して実行すると、サウンドが再生されて、メッセージダイアログが表示されます。
話が長くなってしまいましたので、今日はここまでです。最後にソースを載せておきます（いつものように、インデントが消えてしまっています。ＨＴＭＬで編集すればいいのでしょうけれど…）。

package timer;

import java.applet.Applet;
import java.applet.AudioClip;
import javax.swing.JOptionPane;

public class Sound {

public static void alarm() {
AudioClip ac
= Applet.newAudioClip(Sound.class.getResource("TestMusic.wav"));
// ac.play();
ac.loop();
JOptionPane.showMessageDialog(null, "時間ですよ！", "警告！警告！", JOptionPane.WARNING_MESSAGE);
ac.stop();
}

public static void main(String[] args) {
Sound.alarm();
}
}

JavaFXでアラーム時計を作る

2007-12-02T12:13:00.000+09:00

11月28日の投稿でアナログ時計のアプリケーションを紹介しましたが、それにちょっと手を入れて、アラームタイマを作ってみます。まずは、10秒固定でカウントダウン表示するようにしてみます。
NetBeansで、適当な名前でJavaFXプロジェクトを作ります。今回は、package名を設定することにし、「timer」を指定しました。ファイル名も何でも良いのですが、「AlarmClock.fx」としました。
まず、11月28日に投稿したコードをそのままコピーしてファイルに貼り付けます。
次に、コードの先頭にpackage宣言

package timer;

を追加します。次に、Timerクラスのminutesとhoursの型をIntegerに変更します。

public attribute minutes: Integer;
public attribute hours: Integer;

更に、Timerクラスに次の4つのattributeを追加します。

public attribute count: Number;
public attribute startTime: Number;
public attribute elapsedTime: Number;
public attribute remainingTime: Number;

そして、Timer.elapsedの設定コードの「continue if true」の部分を「continue if running」と書き換えます。

attribute Timer.elapsed = bind if running
then [1..10] dur 1000 linear while running continue if running
else 0;

次に、Timer.elapsedの置換triggerアクションの定義を次のように変えます。

trigger on Timer.elapsed = value {
var now = new Date();
elapsedTime = now.getTime() / 1000 - startTime;
remainingTime = count - elapsedTime;
running = if (elapsedTime >= count) then false else true;
seconds = remainingTime % 60;
minutes = ((Integer)remainingTime / 60) % 60;
hours = ((Integer)remainingTime / 60) / 60;
hours = if (elapsedTime >= count) then 0 else hours;
}

そして、Frameインスタンスの定義の前に次の行を追加し、

var date = new Date();

Frameインスタンス内のTimerインスタンス生成コードを、次のように変更すれば完成です。

var t = Timer {seconds:10, minutes:0, hours:0, count:10,
startTime:(date.getTime() / 1000), running:true}

とりあえず、カウントダウンする10秒は、ハードコードしました。最後に全体のコードを載せておきます。

package timer;

import javafx.ui.*;
import javafx.ui.canvas.*;
import java.util.Date;
import java.lang.Math;
import java.lang.System;

public class Timer {
private attribute elapsed: Number;
public attribute seconds: Number;
public attribute minutes: Integer;
public attribute hours: Integer;
public attribute count: Number;
public attribute startTime: Number;
public attribute elapsedTime: Number;
public attribute remainingTime: Number;
public attribute running: Boolean;
}

attribute Timer.elapsed = bind if running
then [1..10] dur 1000 linear while running continue if running
else 0;

trigger on Timer.elapsed = value {
var now = new Date();
elapsedTime = now.getTime() / 1000 - startTime;
remainingTime = count - elapsedTime;
running = if (elapsedTime >= count) then false else true;
seconds = remainingTime % 60;
minutes = ((Integer)remainingTime / 60) % 60;
hours = ((Integer)remainingTime / 60) / 60;
hours = if (elapsedTime >= count) then 0 else hours;
}

var date = new Date();

Frame {
var t = Timer {seconds:10, minutes:0, hours:0, count:10,
startTime:(date.getTime() / 1000), running:true}
title: "JavaFX アラーム"
height: 225
width: 215
onClose: operation() {System.exit(0);}
content:
Canvas {
content:
Group {
var font = new Font("Dialog", "PLAIN", 15)
var secs = bind t.seconds
var mins = bind t.minutes + secs / 60
var hrs = bind t.hours + mins / 60
content:
[Rect {
height: 225
width: 225
fill: white
},
Circle {cx: 100, cy: 100, radius: 80, fill: white, stroke: black, strokeWidth: 1},
Group {
transform: translate(100, 100)
content: foreach (i in [1..12])
Text {
var radians = Math.toRadians(30 * i - 90)
transform: [translate((70 * Math.cos(radians)), (70 * Math.sin(radians)))]
content: "{i}"
valign: MIDDLE
halign: CENTER
}
},
Group {
transform: translate(100, 100)
var hourHand =
Line {x1: 0, y1: 0, x2: 0, y2: -35,
strokeWidth: 4, stroke: black
transform: bind rotate((hrs * 30), 0, 0)
}
var minuteHand =
Line {x1: 0, y1: 0, x2: 0, y2: -55,
strokeWidth: 2, stroke: blue,
transform: bind rotate((mins * 6), 0, 0)
}
var secondHand =
Line {x1: 0, y1: 0, x2: 0, y2: -75,
strokeWidth: 1, stroke: red,
transform: bind rotate((t.seconds * 6), 0, 0)
}
content: [hourHand, minuteHand, secondHand]
},
Circle {cx: 100, cy: 100, radius: 3, fill: black, stroke: black }]
},
}
visible: true
}

コマンドラインからのJavaFXインタプリタの起動

2007-12-01T10:40:00.000+09:00

（以下の例はWindowsの場合です。ほかのOS環境では読み替えてください）
コマンドラインからJavaFXインタプリタを起動するには、まず、PATH環境変数にOpenJFXをインストールしたディレクトリの下にある「trunk\bin」ディレクトリを設定します。例えば、OpenJFXをCドライブの下に「OpenJFX」という名前でインストールした場合は、「C:\OpenJFX\trunk\bin;」をPATH環境変数に追加します。
そして、コマンドプロンプトウィンドウを開いてJavaFXアプリケーションを保存したディレクトリに移動し、次のようにコマンドを入力します（「JfxApp.fx」アプリケーションを起動する場合の例）。
>javafx JfxApp
もし、CLASSPATH環境変数を設定しているために「Exception in thread "main" java.lang.NoClassDefFoundError: ...」と、エラー表示されてアプリケーションを起動できないときは（私の場合がそうでした）、次のようにコマンドを入力して、CLASSPATHの値を空にしてから実行します。
>set classpath=
>javafx JfxApp
（「set classpath=」で、現在のコマンドプロンプトウィンドウのCLASSPATH の設定を解除します。ほかのコマンドプロンプトウィンドウのCLASSPATH設定には影響を与えません）。

JavaFXで動的アプリケーションを作る

2007-11-28T18:31:00.000+09:00

NetBeans上にJavaFXの開発環境をインストールしたので、JavaFXらしい動きのあるアプリケーションを作って動かしてみることにしました。
と言っても、JavaFXPad用に書かれた時計のアプリケーションを、Frameウィンドウ上で動くように、ちょっと手を入れただけです（Javaと異なり、このような例ではファイル名として任意のものを指定できます）。変更したのは、次の2点です。
1.TimerクラスのインスタンスをFrame内に直接生成する。
2.Frameウィンドウを閉じたときにJVMが停止するように、onCloseオペレーションを追加する。
秒針が滑らかに動くのを見ると、ちょっと感動ものです。参考までに、コードを載せておきます（適当にインデントを追加してください）。オリジナルと比べると変更箇所が分かります。

import javafx.ui.*;
import javafx.ui.canvas.*;
import java.util.Date;
import java.lang.Math;
import java.lang.System;

public class Timer {
private attribute elapsed: Number;
public attribute minutes: Number;
public attribute seconds: Number;
public attribute hours: Number;
public attribute running: Boolean;
}

attribute Timer.elapsed = bind if running
then [1..20] dur 1000 linear while running continue if true
else 0;

trigger on Timer.elapsed = value {
var now = new Date();
minutes = now.getMinutes();
seconds = now.getSeconds() + (now.getTime() % 1000) / 1000;
hours = now.getHours();
}

Frame {
var t = Timer {running:true}
onClose: operation() {System.exit(0);}
title: "JavaFX 時計"
height: 225
width: 215
content:
Canvas {
content:
Group {
var font = new Font("Dialog", "PLAIN", 15)
var secs = bind t.seconds
var mins = bind t.minutes + secs / 60
var hrs = bind t.hours + mins / 60
content:
[Rect {
height: 225
width: 225
fill: white
},
Circle {cx: 100, cy: 100, radius: 80, fill: white, stroke: black, strokeWidth: 1},
Group {
transform: translate(100, 100)
content: foreach (i in [1..12])
Text {
var radians = Math.toRadians(30 * i - 90)
transform: [translate((70 * Math.cos(radians)), (70 * Math.sin(radians)))]
content: "{i}"
valign: MIDDLE
halign: CENTER
}
},
Group {
transform: translate(100, 100)
var hourHand =
Line {x1: 0, y1: 0, x2: 0, y2: -35,
strokeWidth: 4, stroke: black
transform: bind rotate((hrs * 30), 0, 0)
}
var minuteHand =
Line {x1: 0, y1: 0, x2: 0, y2: -55,
strokeWidth: 2, stroke: blue,
transform: bind rotate((mins * 6), 0, 0)
}
var secondHand =
Line {x1: 0, y1: 0, x2: 0, y2: -75,
strokeWidth: 1, stroke: red,
transform: bind rotate((t.seconds * 6), 0, 0)
}
content: [hourHand, minuteHand, secondHand]
},
Circle {cx: 100, cy: 100, radius: 3, fill: black, stroke: black }]
}
}
visible: true
}

JavaFXコンパイラが実用になると構文が変わる

2007-11-27T16:13:00.000+09:00

現在のJavaFXファイルの実行はインタプリタ方式ですが、JavaFXコンパイラの開発が鋭意勧められています。
コンパイラが実用になると、それに伴ってJavaFXの構文も多少変わるようです。まだ検討中のものあるようでその全貌は分かりませんが、少なくとも私には、よりシンプルな記述が可能になる方向に変わろうとしているように思えます。
どのように変わろうとしているのか興味がおありの方は、Planet JFXのページ、Weaverさんのブログをご覧ください。

NetBeansへのJavaFX開発環境のインストール

2007-11-26T14:42:00.000+09:00

「次回は・・・」と言いながら、1回間があいてしまいました。しかも、今回はその内のIDE（NetBeans）へのJavaFX開発環境のインストールの分だけです（もう予告するのは止めにしよう）。
JavaFXPadは、いかがだったでしょうか。日本語も、特に何の設定もすることなく表示できたことと思います。ただし、JavaFXPadを起動したときに表示される「JavaFX」の文字ように、フォントとして日本語の字体を含まないもの（この例では「faceName: 'Verdana'」）を設定していると、日本語の文字が四角い枠で表示されてしまいます。その場合は、日本語の字体を含むフォントを指定する（たとえば「faceName: 'Sans-Selif'」と記述する）か、フォントまたはフォント名の指定そのもの（この例では「faceName: 'Verdana',」の部分）を削除してしまえば、日本語が表示されます。
JavaFXの構文を学習したら、OpenJFXホームページに紹介されているJavaFX Script 2D Graphics Tutorialにアクセスして、2Dグラフィックスのチュートリアルをダウンロードして調べてみると面白いです。図形のアフィン変換も簡単に指定できるので、durオペレータと組み合わせると、ちょっとした動的アプリケーションならすぐに作れます。ちなみにdurオペレータの構文については、白石さんの日記に詳しく説明されていています。
前説が長くなりましたが、IDEへのJavaFX開発環境のインストールについては、OpenJFXホームページの「ダウンロード」に、手順を記したページへのリンクが載っています。ちなみに、私はNetBeans IDE 5.5 用 JavaFX Script プラグイン: ダウンロードとインストレーション手順に従って、NetBeans 5.5へプラグインをインストールして使っています（プラットフォームは、Windows XP SP2、JDK 1.5.0_11です）。
NetBeansでのJavaFXプログラムの作成と実行方法については、OpenJFXホームページに載っているJavaFX Script 言語はじめの一歩が参考になります。GUIコンポーネントの使い方については、深く学ぼう JavaFX Script 言語にひととおり紹介されています。今まで敬遠していたレイアウトマネジャも、比較的容易に利用できるのがうれしいです（これから主流になるであろう携帯端末上で動作するアプリケーションを構築することを考えると、レイアウトマネジャの利用は必須だと思っていますので）。
また、クライアント／サーバアプリケーションの簡単な例については、Learning JavaFX Script, Part 3: Client-Server Communication With JAX-WSが参考になります（人の褌で相撲を取っているので、「参考になります」ばかり）。

JavaFXのコンパイラがより簡単に入手可能

2007-11-25T11:32:00.000+09:00

これまでは、ソースコードを入手して自分で構築しないと使えなかったJavaFXコンパイラですが、構築済みのものをダウンロードして使えるようになったようです（Jim Weaverさんのブログ、Planet JFXのページを参照してください）。
私自身は、まだ試していません。すぐに利用できるようになるという、次の省スペース版が出たら試してみようかと思っています。

JavaFXことはじめ

2007-11-24T14:41:00.001+09:00

最近（といっても11月に入ってからですが）、JavaFXについて調べています。
JavaFX言語の開発実行環境は、手軽に利用できるものが用意されているので、それをダウンロードして、最新のプログラミング言語（いわゆるRIAというもの）を試してみることにしました。Javaの知識が多少なりともあるため取っつきやすく、表現力豊かなデスクトップアプリケーションが簡単に作成できるので、ちょっと楽しくなりました。
まずは、SunのJavaFX紹介ページにアクセスして、JavaFX Scriptを入手しました。このページで紹介されているのは、JavaFXの２Dグラフィックスのチュートリアルでした。最初は、JavaFX言語の構文が分からずたいしたことはできませんでしたが、それでも、モーフィングのデモは期待にたがわないものであることを予感させてくれました。
次に、紹介ページに記載されているOpenJFXプロジェクトのページにアクセスし、「デモ」の中から JavaFX Script JavaFXPad Demoをクリックして、JavaFXPadを入手しました。JavaFXPadを利用すると、コーディングするそばからプログラミングの結果が見られるので、ちょっとJavaFXを試してみるという用途には最適です。JavaFXPadを使って、OpenJFXプロジェクトのページに載っているJavaFX Script プログラミング言語リファレンスや、稚内北星学園大学のJavaFX 2007などでJavaFX言語の基礎を習得することにしました（私はこの順番で読んだのですが、最初にJavaFX 2007の方を読んだ方が分かりやすかったかなと、思います）。
OpenJFXプロジェクトのページには、このほかにもいろいろと情報が載っており、それらのリンク（wiki、メーリングリスト、ブログなど）をたどるとリアルタイムで新しい言語の誕生に触れることができるので、毎日わくわくしながら読んでいます。
次回は、IDE（NetBeans）上への開発環境の構築と、コマンドラインからのJavaFXインタプリタ起動についてお話したいと思っています。