//START fx FILE
package classobjectfunctins;

/**import statement for java.lang.System
*There is no pre imports for java.lang package by compiler.
*So to put System.out.println()'s we need to import System class
*/

import java.lang.System;

class Rectangle{
   attribute length:Number;
   attribute width:Number;
   function area(  ):Number{
      return length * width;
   }
}

class Cuboid{
   attribute height:Number=10;
   attribute length:Number=10;
   attribute width:Number=10;
   function volume():Number{
      return volume(height,length,width);
   }
//overloaded functions
   function volume(a:Number,b:Number,c:Number):Number{
      return a * b * c;
   }
}
/////////////////////////////////////////////////////////
//Usage one
//define variable
var rect1 = Rectangle{}
//assine values
rect1.length=100;
rect1.width=50;

//call function
System.out.println("Usage one:"+rect1.area());//5000.0

/////////////////////////////////////////////////////////
//Usage two
//define variable with attribute values
var rect2 = Rectangle{
   length:12
   width:45
};
System.out.println("Usage two:"+rect2.area());//540.0

/////////////////////////////////////////////////////////
//Usage three
var cuboid = Cuboid{};
//using function without parameters
System.out.println("Usage three no args:"+cuboid.volume());//2520.0

//using overloaded method
System.out.println("Usage three no args:"+cuboid.volume(10,10,10));//1000.0

//END fx FILE

First we goit to make two classes Rectangle and Cuboid.

Cuboid class has 3 attributes and 2 overloaded functions,

We assign assign attribute values at same time.

First usage we create variable, assign Rectangle class object and

assign some values to the attributes.

Second usage we create we create object and assign variables at the same time.

Last we call overloaded functions

This is simple hello world using java.

public class HelloWorld {
  public static void main(){
    System.out.println("Hello Wold.");
  }
}

and this is using javafx

import java.lang.System;
System.out.println("Hello World.");

Only thing with jfx is you have to import all the import statements.

I'm betting for JavaFX, Android and java as a serious gaming platform. Lets hope we will see more before year ends (i just cant wait). Maybe i'll be toying around with the new features of java and showing it to you.

Yeah i know, its old news but who cares.

Desktop widgets are small, interactive applications that perform frequently used functions and provide access to services on the Internet, such as news, weather, time, maps, or even stock quotes. There has been an explosion of interest in desktop widgets for the consumer space including access to popular services such as Flickr, MySpace, and YouTube. However, there has been very little movement on the enterprise front to provide equivalent desktop widgets for corporate applications.

There are a number of issues that prevent the widespread corporate adoption of widgets:

• Security Issues - Security holes and vulnerabilities have plagued all the major widget platforms, and the general lack of rigorous security has prevented the deployment of widget engines within large corporations.
• Limited Platform Support - Unlike web applications, which can be deployed seamlessly across multiple OS and hardware platforms, most of the widget frameworks are limited to a few select platforms.
• Proprietary Systems - All the major widget frameworks are closed source and proprietary. As a technology vendor, this puts you at the mercy of the framework provider who may choose to change, upgrade, or even suspend their service at any time.
• Restrictive License Agreements - Given the above issues, it should not be a surprise that several of the popular widget frameworks have specific language in their license agreements that limit or prohibit commercial use to reduce liability.

Enter WidgetFX, the first desktop widget platform designed specifically for the requirements of large enterprises.

About WidgetFX

WidgetFX is an open-source desktop widget platform built on top of Sun's new JavaFX technology. Widgets can be written in a combination of JavaFX Script and Java to take advantage of a very rich platform for graphics, animation, and media capabilities.

Unlike the available consumer focused widget frameworks, WidgetFX was born out of the need for a sustainable corporate widget framework. In order to meet this requirement it had to address corporate security needs, provide seamless cross-platform support, and be distributed under an unencumbered open-source license.

The initial v0.1 launch of WidgetFX was very successful, with over five thousand unique visitors from ninety six different countries in only the first few days. Here is a view of the geographic diversity courtesy of Google Analytics:

[caption id="attachment_872" align="alignnone" width="460" caption="WidgetFX Geographical Distribution"][/caption]

The current release of WidgetFX includes a fully functional widget dock and is primarily focused on widget developers to give them the tools and documentation needed to start writing widgets today. Subsequent releases are planned to continue enhancing security, performance, and end user experience in anticipation of a Fall JavaFX release by Sun.

Widget Security

While users expect the same security restrictions browsers impose on web applications, most widget frameworks give widgets equal privileges to installed applications with full access to the disk and network. Regardless of how trustworthy the company providing the framework may be, 3rd party widgets could expose sensitive passwords or corporate secrets outside the corporate firewall. For this reason many large corporations have chosen to completely disallow or severely restrict the use of widgets on their intranet as part of their IT Governance policy.

Even widgets developed by trusted corporations are subject to security holes, such as the infamous Windows Gadget RSS Exploit:

"If a user subscribed to a malicious RSS feed in the Feed Headlines Gadget or added a malicious contacts file in the Contacts Gadget or a user clicked on a malicious link in the Weather Gadget an attacker could potentially run code on the system."

Similar security holes have plagued Yahoo Widgets with an ActiveX Buffer Overlow Vulnerability, and Google Gadgets where an XSS vulnerability allowed complete takeover of a user's computer.

In contrast, WidgetFX has the ability to take advantage of the proven Java security model, which is based on a secure sandbox for isolating applications. Applications running within the sandbox are restricted from accessing the user's files, changing data, or running arbitrary code. However, if a widget needs additional permissions it can request access from the user for reading a file, accessing a website, or even printing. For even greater access, a signed widget can request full permissions, but must be granted access by the user subject to their corporate security policy. This insulates the user from malicious code, and simplifies corporate governance of widgets within an enterprise.

Cross Platform Support

One of the traditional challenges of UI development is that certain user interface features are only available on a specific platform, which limits the capabilities of cross-platform toolkits. Therefore, it is no surprise that the most successful widget frameworks support only a single OS platform.

This provides challenges for corporations who want to adopt a standard for widget frameworks. Even if a corporation has standardized on Windows, they cannot deploy Windows Sidebar widgets without first upgrading all workstations to Vista.

There is an even greater challenge for corporations developing widgets, because they must rewrite widgets for each platform they need to support for their end users. Since there is no standardization across Widget frameworks, this also means retesting and certifying widgets per platform.

WidgetFX takes advantage of Java's cross-platform support to provide a consistent user experience across Windows, Mac OS X, and even UNIX variants such as Linux and Solaris. With the release of Java SE 6 Update 10, WidgetFX will be further enhanced by features normally only available with native platform toolkits, such as translucent/shaped windows and system tray integration. Sun also plans to take the JavaFX platform mobile, which means deployment of common widgets across desktops and mobile devices is in the foreseeable future.

Open-Source Licensing

WidgetFX is licensed under the GNU Public License v3 under similar terms as the Java platform. This helps to keep the WidgetFX engine free for all companies and interested parties to contribute while also allowing development of commercial widgets for sale and distribution.

On the other hand, most of the popular consumer widget frameworks are proprietary, which restricts what you can do with them commercially. Some of the limitations you may encounter include restrictions on redistribution, lack of control over compatibility and version upgrades, and even blatant restrictions on enterprise or commercial use.

Quoting from the Yahoo Widgets terms of service:

"[Yahoo Widgets] is designed for consumer, personal use. It is not designed for enterprise, commercial, or human safety purposes. Its failure in such cases could lead to injury or damage for which you agree that Yahoo! is not responsible."

Good luck getting your IT or legal department to approve use of a framework like this!

Summary

WidgetFX is an emerging technology for developing desktop widgets that can securely run in a corporate environment. The v0.1 release is designed to get developers started writing widgets early in anticipation of a fall launch of JavaFX technology by Sun. For more information about WidgetFX, including apidocs, tutorials, and a live application, visit WidgetFX.org.

A palavra hoje é:  JavaFx (Fale JavaFx em inglês, fica algo como Java Effects, tendeu? heim? heim? um trocadilho!).

JavaFx é um conjunto de produtos para criar RIA (Rich Internet Applications), mas não deixe o nome te enganar, funciona muito bem para desktop, na verdade você constrói uma aplicação Desktop e joga para o browser (falando bem por alto claro).

O JavaFx, até o momento é composto po JavaFx Script e JavaFx Mobile. Hoje vou comentar sobre o JavaFx Script, o mobile fica pra próxima.

O JavaFx Script, é uma linguagem Script, criada para que você possa rapidamente criar aplicações com alto nível visual. Ele é uma liguagem interpretada e não compilada e é quase uma extensão do Java. É possível misturar o código Java e JavaFx sem problema algum.

O JavaFx ainda não tem tanto suporte quanto eu gostaria, mas já dá pra brincar com ele. Ainda não tenho coragem de coloca-lo no cliente, mas já andei usando aqui e o futuro parece promissor.

Bom.. Vamos por a mão na massa, pra começar vou colocar aqui como fazer um simples Hello World com JavaFx e NetBeans:

1) Primeiro vamos baixar o plugin JavaFx para NetBeans (MAS É CLARO QUE JÁ EXISTE), vá em Ferramentas -> Plugin, selecione os plugins JavaFx Kit, JavaFx SDK for Windows (se estiver no Windows) e se quiser ver um exemplo mais complexo, JavaFx Weather Sample;

2) Agora vá em Arquivo -> Novo Projeto, selecione a categoria JavaFx e selecione o projeto JavaFX Script Application, cliquem em Próximo. Mude o nome para HelloWorld (ou para PrototipoGostosao, se quiser) e clique em finalizar;

Vai ser criado o projeto e abrirá um arquivo Main.fx.   AI QUE SUSTO! .FX???? siiim .fx é a extensão do javaFx para as "classes". Pronto, contraiu, mas relaxou...

3) Agora com o Main.fx aberto, vá até a Paleta de componentes do NetBeans, geralmente do lado direito, clique e arraste o componente SwingFrame, que está no grupo Swing Componente até a linha logo abaixo do comentário //place your code here. Renomeie a propriedade title: de "MyApplication" para "Titulo Hello World";

Ele já faz os imports necessários. O código ficará:

[sourcecode language='java']
package helloworld;

import javafx.application.Frame;
import javafx.application.Stage;

//Place your Code Here
SwingFrame {
title: "Hello World"
width: 200
height: 200
closeAction: function() {
java.lang.System.exit( 0 );
}
visible: true

menus: [  ]

content: Canvas {
content: []
}
}
[/sourcecode]
4) Ótimo, agora apague o bloco:

Canvas {
content: []
}

que está na parte:


content: Canvas {
content: []
}

6) Agora clique e arraste o componente TextField no Swing Components até a parta content:  (onde você acabou de apagar o Canvas e mude a propriedade Text: de "TextField" para "Hello World", essa parte é meio confusa,  mas veja como vai ficar o seu código:

[sourcecode language='java']
package helloworld;

import javafx.ext.swing.SwingFrame;
import javafx.ext.swing.Canvas;
import javafx.ext.swing.TextField;

// place your code here
SwingFrame {
title: "Hello World"
width: 200
height: 200
closeAction: function() {
java.lang.System.exit( 0 );
}
visible: true

menus: [  ]

content:TextField {
columns: 10
text: "Hello World"
editable: true
}
}
[/sourcecode]
Agora veja que legal, clique no botão que aparece na figura abaixo:

Viram? é possível fazer um Preview do que você está fazendo e ele vai mudando dinamicamente.

Agora é Salvar o arquivo, clicar com o botão direito no Projeto criado e Run Project!! Tá.. aí você diz: "mas que coisa idiota, isso eu podia fazer com Swing".

Concordo, não vou negar que Swing de vez em quando é legal (OPA!), mas isso é um exemplo EXTREMAMENTE Básico, vamos melhorar agora o exemplo e utilizar o Bind:

1) Recorte o bloco TextField que foi criado na classe anterior:
[sourcecode language='java']
TextField {
columns: 10
text: "HelloWorld"
editable: true
}
[/sourcecode]

2) vá até a linha abaixo do comentário //place your code here e acima do início do SwingFrame e escreva: var textField1 = e depois cole o TextField que foi recortado.

3) Agora na propriedade title: do swingFrame, substitua o valor "HelloWorld" para bind {textField1.text} (retire as aspas também) - Aqui você vinculou a propriedade title do SwingFrame com a propriedade text do textField1;

4) No content: que você retirou a TextField, digite: textField1

Segue abaixo o código completo:

[sourcecode language='java']
package helloworld;

import javafx.ext.swing.SwingFrame;
import javafx.ext.swing.Canvas;
import javafx.ext.swing.TextField;

/**
* @author Prototipo
*/

// place your code here
var textField1 = TextField {
columns: 10
text: "HelloWorld"
editable: true
}

SwingFrame {
title: bind {textField1.text}
width: 200
height: 200
closeAction: function() {
java.lang.System.exit( 0 );
}
visible: true

menus: [ ]

content: textField1
}
[/sourcecode]

Agora execute a aplicação e mude o texto da TextField. Você pode vincular a inúmeros objetos, até mesmo a propriedade de um modelo.

Além disso, acessem o site oficial do JavaFx, vejam alguns exemplos e CHOREM MEROS MORTAIS!!

In press previews for JavaFX, Sun Fellow James Gosling explained:

Most scripting languages are oriented at banging out Web pages. This is oriented around interfaces that are highly animated.

—James Gosling,

There are parts of the world where a person's desktop computer is their cell phone, and that's the kind of end point that we're going to get to,

—James Gosling,

JavaFX is anticipated to compete on the desktop with Adobe Flash Player, Adobe AIR, OpenLaszlo, and Microsoft Silverlight. It may also target Blu-ray Disc's interactive BD-J platform, although as yet no plans for a Blu-ray release have been announced.

Tutorials on javafx.com

Creating GUIs Using JavaFX Script

This lesson describes the JavaFX SDK Runtime functionality for creating GUIs. It gives you a high-level explanation of the feature and offers instructions on how to create GUIs using the functionality.

The JavaFX SDK runtime is the foundation library of JavaFX platform, allowing content developers, designers, and GUI architects to quickly and easily create GUIs for Rich Internet Applications. Based on the underlying scene graph functionality, the library provides the ability to present objects in scenes such as a frame containing a circle with a defined filling and stroke, and apply different types of lighting, animation, and transformation effects. For more information about the scene graph API, see the project page at scenegraph.dev.java.net and Presenting Visual Objects lesson.

To learn how to create the GUI using JavaFX Script, consider a task of creating simple graphics: a rounded rectangle and a text string with a drop shadow.

The following code sample shows how you do it in a traditional way using Java 2D:

import java.applet.Applet;
import java.awt.font.*;
import java.awt.geom.*;
import java.awt.*;
...
public class SimpleButton extends Applet {
...
	public void paint(Graphics g) {
	  Graphics2D g2 = (Graphics2D) g;
	  g.setColor(Color.LIGHT_GRAY);
	  g2.fillRoundRect(10, 10, 200, 50, 15, 15);

	  Font font = new Font("Serif", Font.BOLD, 20);
	  g.setFont(font);
	  String textString = "Java 2D";
	  FontRenderContext frc = ((Graphics2D)g).getFontRenderContext();
	  Rectangle2D bounds = font.getStringBounds(textString, frc);
	  int wText = (int)bounds.getWidth();
	  int TextX = 10 + 200/2 - wText/2;

	  g.setColor(Color.DARK_GRAY);
	  g.drawString(textString, TextX + 1, 39);
	  g.setColor(Color.YELLOW);
	  g.drawString(textString, TextX, 40);
	}
...
}

Figure 1: Java 2D Sample

To drop a shadow, this code sets a contrast color and uses an additional drawString method with offset coordinates.

The JavaFX Script Language and JavaFX Runtime classes enable developers to render the same graphic context more easily and more clearly:

import javafx.scene.*;
import javafx.scene.paint.*;
import javafx.scene.geometry.*;
import javafx.scene.text.*;
import javafx.scene.effect.*;
import javafx.ext.swing.*;

SwingFrame {
  title: "Simple (JavaFX demo)"
  width: 228
  height: 98
  content: Canvas {
    content: Group {
      content: [
        Rectangle {
          x: 10   y: 10
          width: 200   height: 50
          arcWidth: 15   arcHeight: 15
          fill: Color.web("#C0C0C0")
        },
        Text {
          x: 110   y: 40
          content: "JavaFX"
          font: Font {
            name: "Serif"
            size: 20
            style: FontStyle.BOLD
          }
          fill: Color.YELLOW
          horizontalAlignment: HorizontalAlignment.CENTER
          effect: DropShadow {
            offsetX: 2   offsetY: -2   radius: 6
            color: Color.BLACK
          }
        }
      ]
    }
  }
  visible: true
}

This code sample defines a Group object containing two elements: Rectangle and Text. Shape parameters and coordinates as well as font and colors are set using corresponding attributes - x , y, font, size, style, fill and color. The effect attribute applies a drop shadow to the Text element.

To enhance this code, apply a lighting effect to the Group:

import javafx.scene.*;
import javafx.scene.paint.*;
import javafx.scene.geometry.*;
import javafx.scene.text.*;
import javafx.scene.effect.*;
import javafx.scene.effect.light.*;
import javafx.ext.swing.*;

Group {
  content: [
    Rectangle{...}
    Text {...}
  ] effect: Lighting{light: DistantLight {azimuth: 225}}
}

Figure 2: JavaFX Script Sample

The azimuth attribute defines a direction angle for the light source on the XY plane, in degrees.
More visual effects are available in the javafx.scene.effect and javafx.scene.effect.light packages. Refer to the API doc or to API Reference for more information. The entire code of this program is available in the JavaFXGraphics.fx file.

Applying Data Binding

Data binding is one of the advantageous features in JavaFX Script Language. It enables all public attributes and functions to be bound. For example, you can bind the window title to the TextField, so whatever you type automatically appears in the window title without handling event listeners. For the graphical sample, you create a slider to vary the angle of the distant light source.

Figure 3: Data Binding Sample

To add the slider to the Group, use the ComponentView class.

var slider = Slider{minimum: 0 maximum: 360 value: 20};

(more)

The demo application is a stopwatch widget that measures and displays time intervals accurate to within hundredths of a second. The application interface is a dial that has a second hand, two small dials that display tenths and hundredths of a second, and a digital display that shows time elapsed in minutes, seconds, and tenths and hundredths of a second. On the top of the main dial there are two buttons, green and red. The green button starts or stops the time measure. Once the green button is pressed during time measure, the stopwatch stops indicating the time elapsed, however the actual time measuring continues. This feature allows recording intermediate results. The red button resets the elapsed time.

Figure 1: Stopwatch Widget

Creating the Application GUI

The demo uses a number of JavaFX SDK Runtime classes to build the application UI and implement graphical effects.

The following code draws the inner and the outer circle of the main stopwatch. Note the use of the Circle, LinearGradient, and RadialGradient classes. These classes are used to draw circles with a 140- and 134- pixel radius and fill them with the linear and radial gradient respectively. The radius of the circle is defined by the radius attribute, the start and end colors of the gradient are defined using the Stop and color attributes.

Group { translateX: 40 translateY: 40 content: [
  Circle {
    centerX: 140
    centerY: 140
    radius: 140
    fill:LinearGradient { startX:0 startY:0 endX:1 endY:1
      stops: [
        Stop { offset:0 color: webcolor("#3c3c3c") },
        Stop { offset:1 color: webcolor("#010101") }
      ]
    }
  },
Circle {
  centerX: 140
  centerY: 140
  radius: 134
  fill: RadialGradient { centerX:0.5 centerY:0.5 radius:0.5
    stops: [
      Stop { offset:0 color: rgba(20,20,20,1) },
      Stop { offset:0.9499 color: rgba(20,20,20,1) },
      Stop { offset:0.95 color: rgba(20,20,20,1) },
      Stop { offset:0.975 color: rgba(20,20,20,1) },
      Stop { offset:1 color: rgba(84,84,84,0) }
    ]
  }
},
...

Also note that the Group class groups the two circles to enable them share a coordinate space and to be transformed as a group.

The numbers "0", "15, "30", "45" below the tick marks are implemented using the Text class. Here is the code that draws a white "0".

Text {
  font: Font{name: "Courier" size: 16, style: FontStyle.BOLD}
  x: 141 y: 47
  content: "0"
  horizontalAlignment: HorizontalAlignment.CENTER
  fill: webcolor("#FFFFFF")
},
...

Note that the code uses font to set the font style and its size, x and y attributes to define the position of the tick mark, and content to display "0". It also fills the tick mark with yellow using fill with a defined web code for this color.

The hand of the main dial comprises of two rectangles and a circle created using the Circle and Rectangle classes. Additionally, lighting effect is applied to the dial using Lighting class:

Group {
  content: [
    Group {
      content: [
        Circle {centerX: 140 centerY: 140 radius: 8
          fill: webcolor("#FF0000")},
        Rectangle{x: -1.5 y: -20 width: 3 height: 120
            fill: webcolor("#FF0000")
            rotate: bind handAngle
            translateX: 140
            translateY: 140},
        Rectangle{x: -1.5 y: -40 width: 3 height: 20
            fill: webcolor("#FFFFFF")
            rotate: bind handAngle
            translateX: 140
            translateY: 140}
      ]
      effect: Lighting{
        light: DistantLight {azimuth: 225}
      }
    }
  ]
...

(more)

Demo: JavaFX, creating a sphere with shadow on silveiraneto.net

Silveira Neto describes on your blog an interesting JavaFX demo and its graphics potentialities.

This is a short tutorial about some JavaFX elements like ellipses, circles, effects and gradients.

In the first code we are creating a frame with a ellipse with center in (120,140), 60 pixels of horizontal radius, 20 pixels of vertical radius and color black. We have also a circle with center in (100,100), 50 pixels of radius and color red. The idea is make this circle appears like a sphere and make the ellipse look like a shadow.

view plaincopy to clipboardprint?


import javafx.application.*; 
import javafx.scene.paint.*; 
import javafx.scene.geometry.*; 
 
Frame { 
 title: "JavaFX Sphere", width: 300, height: 300, visible: true 
 stage: Stage { 
 content: [ 
 Ellipse { 
 centerX: 120, centerY: 140, radiusX: 60, radiusY: 20 
 fill: Color.BLACK 
 }, 
 Circle { centerX: 100, centerY: 100, radius: 50, fill: Color.RED } 
 ] 
 } 
} 

view plaincopy to clipboardprint?


import javafx.application.*; 
import javafx.scene.paint.*; 
import javafx.scene.geometry.*; 
 
Frame { 
 title: "JavaFX Sphere", width: 300, height: 300, visible: true 
 stage: Stage { 
 content: [ 
 Ellipse { 
 centerX: 120, centerY: 140, radiusX: 60, radiusY: 20 
 fill: Color.BLACK 
 }, 
 Circle { centerX: 100, centerY: 100, radius: 50, fill: Color.RED } 
 ] 
 } 
} 

import javafx.application.*;
import javafx.scene.paint.*;
import javafx.scene.geometry.*;

Frame {
    title: "JavaFX Sphere", width: 300, height: 300, visible: true
    stage: Stage {
        content: [
            Ellipse {
                 centerX: 120, centerY: 140, radiusX: 60, radiusY: 20
                 fill: Color.BLACK
            },
            Circle { centerX: 100, centerY: 100, radius: 50, fill: Color.RED }
        ]
    }
}

Now we will just add two thing, a effect and a radial gradient.

First we’ll just add javafx.scene.effect.* to our import list and just call the gaussian blur effect in our ellipse with

[wikipedia.org]
[http://javafx.com/]
[http://silveiraneto.net/]
[http://learnjavafx.typepad.com]
[javapassion.com]