Paweł Machowski devBlog

JavaScript - TDD - konfiguracja środowiska

2010-12-05T19:47:00.009+01:00

Wpis ten traktuje jako notatkę odnośnie konfiguracji środowiska pod pisanie testów do JavaScriptu.

Piszemy w Intellij, do uruchomienia testów używamy js-test-driver.

Ściagamy JsTestDriver.jar, wrzucamy do jakiegoś folderu, odpalamy server


java -jar JsTestDriver.jar --port 9876

teraz wchodzimy w przeglądarce na http://localhost:9876/ i klikamy capture

Przeglądarka połączyła się z serwerem, będzie to nasze środowisko do uruchamiania testów. Możliwe jest jednoczesne więcej niż połączenie, wtedy będziemy mieli pewność, że testy przechodzą zarówno na IE7, IE8 oraz innych mniej popularnych przeglądarkach.

Przechodzimy do IDE, domyślnie do głównego folderu wrzucamy JsTestDriver.jar i tworzymy plik konfiguracyjny jsTestDriver.conf, przykładowa zawartość:


server: http://localhost:9876
load:
  - src/main/js/*.js
  - src/test/js/*.js

Dla Intellij 7 czy tam 8 istniał fikuśny plugin do uruchamiania testów w stylu JUnitu, ale nikomu nie chce się go przystosować do 9 więc trzeba zastosować pewne obejście.

File - Settings - External Tools - Add
Dajemy name JsTestRun, resztę zostawiamy uzupełniając pola

Program: C:\Program Files\Java\jre6\bin\java.exe
tu wiadomo, ścieżka do JRE

Parameters: -jar $ProjectFileDir$\JsTestDriver.jar --tests all
tu w zależności gdzie wrzuciliśmy jara

Working directory: $ProjectFileDir$\
wiadomo
ok, ok

Tworzmy przykładowe klasy i testy (przykłady ze strony projektu)


myapp = {};

myapp.Greeter = function() { };

myapp.Greeter.prototype.greet = function(name) {
  return "Hello " + name + "!";
};


GreeterTest = TestCase("GreeterTest");

GreeterTest.prototype.testGreet = function() {
  var greeter = new myapp.Greeter();
  assertEquals("Hello World!", greeter.greet("World"));
};

klikamy Tools - JsTestRun i otrzymujemy (np dla chrome, IE8), Settings - keymap warto dodać hotkey, w założeniu testy będziemy często uruchamiać.


Total 2 tests (Passed: 2; Fails: 0; Errors: 0) (0,00 ms)
  Chrome 8.0.552.215: Run 1 tests (Passed: 1; Fails: 0; Errors 0)
 (0,00 ms)
  Internet Explorer 8.0: Run 1 tests (Passed: 1; Fails: 0; Errors 0)
 (0,00 ms)

i gitara

edit...
jednak komuś się zachciało i dodano wsparcie w Intellij9

Scala x04 - Metody ciąg dalszy

2009-09-21T22:04:00.011+02:00

Java dostarcza nam 2 sposoby przekazywania argumentów do metod, przez referencje (a właściwie jej kopię) oraz przez wartość (dla typów prymitywnych). Scala udostępnia nam trzecią możliwość, przekazywanie argumentów przez nazwę (call-by-name). Jest to moje tłumaczenie, jak ktoś zna lepsza/oficjalne to proszę o korektę.
Definiujemy przykładową metodę, której wykonanie zajmuje dużo czasu, ta np. wykonuje miliard różnych czynności, wypisuje komunikat i zwraca jakiś tam rezultat (podwojony argument)


scala> def czasochlonnaMetoda(x : Int):Int = {
     //zaawansowane operacje na zmiennej x,
     //pobieranie danych z bazy na podstawie xmla
     //otrzymanego z web service'u 
       println("trwalo to z godzine")
       return 2 * x
     }
czasochlonnaMetoda: (Int)Int

Definiujemy drugą metodę, przyjmuje ona 2 argumenty, zwraca pierwszy w przypadku gdy jest on większy od zera, lub drugi w innej sytuacji.


scala> def szybkaMetoda(x : Int, y : Int):Int = {
      println("wykonujemy szybka metode")
      if(x > 0) x
      else y
     }
szybkaMetoda: (Int,Int)Int

//wywołujemy szybką metodę,
// przekazując jako 2 argument rezultat wykonania czasochłonnej metody
scala> szybkaMetoda(2, czasochlonnaMetoda(2))
trwalo to z godzine
wykonujemy szybka metode
res2: Int = 2

Wszystko przebiegło jak się spodziewaliśmy, wywołana została czasochłonna metoda, następnie wykonało się ciało szybkiej metody. Z treści metody widzimy, iż drugi argument nie był w ogóle wykorzystywany, a jednak straciliśmy na jego ewaluacje sporo czasu. Zdefiniujmy teraz szybką metodę w trochę inny sposób


//w liście parametrów dodajemy dziwny znaczek
scala> def szybszaMetoda(x : Int, y : => Int):Int = {
      println("szybsza metoda")
        if(x > 0) x
        else y
      }
szybszaMetoda: (Int,=> Int)Int

//i ponownie wywołujemy metodę
scala> szybszaMetoda(1, czasochlonnaMetoda(2))
szybsza metoda
res3: Int = 1

Ku naszemu zdziwieniu czasochłonna metoda w ogóle nie została wywołana, nie potrzebowaliśmy czasochłonnej ewaluacji drugiego parametru i nie została ona wykonana, coś pięknego. Stosujący przekazywanie parametrów przez nazwę, określenie ich wartości odbywa się dopiero w momencie, gdy następuje do nich odwołanie w ciele metody. Obrazuje to przykład


scala> szybszaMetoda(-1, czasochlonnaMetoda(2))
szybsza metoda
trwalo to z godzine
res4: Int = 4

Wyświetlany jest komunikat z szybszej metody, dopiero potem wykonuje się metoda, której rezultat przekazaliśmy jako parametr

Scala x03 - Metody

2009-09-17T21:49:00.004+02:00

Definicje metod rozpoczynają się od słowa def, następnie występuje nazwa metody wraz z listą parametrów i ich typów w nawiasach okrągłych. Poza nawiasem mamy dwukropek i typ zwracanej wartości, a po znaku równości ciało metody. Przykładowa definicja metody zwracającej różnicę 2 liczb wygląda następująco:


scala> def roznica(odjemna : Int, odjemnik : Int): Int = {
        return odjemna - odjemnik
      }
roznica: (Int,Int)Int

scala> roznica(2,4)
res0: Int = -2

Oczywiście w Scali polowa powyższego kodu jest opcjonalna, można powyższą metodę zapisać tak:


scala> def roznica(odjemna : Int, odjemnik :Int) = {
        odjemna - odjemnik
      }
roznica: (Int,Int)Int

Typ zwracanej wartości jest automagicznie wykrywany, więc można go opuścić (oczywiście w wielu wypadkach wskazane jest jednak jawne określenie). Metody domyślnie zwracają wynik działania ostatniej linijki ich kodu, więc return również można ominąć. Idąc dalej...


//jeżeli ciało funkcji zawiera jedną instrukcję, {} są opcjonalne
scala> def roznica(odjemna : Int, odjemnik : Int) = odjemna - odjemnik
roznica: (Int,Int)Int

Oczywiście możemy tworzyć również metody nie przyjmujące żadnych parametrów i nie zwracające żadnej wartości


scala> def sayDupa() = println("dupa")
sayDupa: ()Unit
scala> sayDupa
dupa

Jak widać typem zwracanej wartości jest Unit, odpowiednik void znanego z Javy (wszystkie metody klasy Javy zwracające void, są mapowane do metod zwracających Unit).

Scala x02 - Zmienne

2009-09-16T23:56:00.011+02:00

W Scali istnieją 2 typy zmiennych vals i vars. Val to zmienna przypominająca zmienna final z Javy, raz przypisanej do nich wartości nie można zmienić. Var to natomiast zwykłe zmienne, których wartość możemy zmieniać.


//definiujemy zmienna val
scala> val zmienna = "dupa"
//łańcuchy znaków w Scali zaimplementowano jako Javowe Stringi  
zmienna: java.lang.String = dupa   

scala> zmienna = "dupa2"
:5: error: reassignment to val
       zmienna = "dupa2"
//próba ponownego przypisania wartości do zmiennej kończy się błędem               

scala> var zmiennaVar = "Pierwsza wartosc" //definiujemy zmienną var
zmiennaVar: java.lang.String = Pierwsza wartosc

scala> zmiennaVar = "Nowa wartosc"
zmiennaVar: java.lang.String = Nowa wartosc
//tu już nie dostajemy komunikatu o błędzie,
//nowa wartość została przypisana
scala> println(zmiennaVar)
Nowa wartosc
scala>

Ciekawą rzeczą, jaką można zauważyć w tym przykładzie jest automatyczne wykrywanie typu zmiennej. Gdzie tylko to możliwe możemy pozostawiać kompilatorowi kontrole typu zmiennej, jednak nic nie szkodzi aby samemu go określić.


//w odróżnieniu od Javy, pierwsze nazwa zmiennej,
//potem dwukropek, następnie opcjonalny typ
//i przypisanie wartości.
scala> var x:java.lang.Long = 1L  
x: java.lang.Long = 1

Dla uzupełnienia, wszystkie typy prymitywne znane z Javy mają swoje odpowiedniki w Scali, np scala.Boolean odpowiada boolean, scala.Float to float. Kompilator Scali automagicznie zamienia, gdzie tylko możliwe, typy Scali na prymitywy.

Scala x01 - Podstawy

2009-09-04T23:44:00.006+02:00

I oto nadszedł pierwszy wpis na temat Scali. Nie będę rozpisywał się na temat teoretycznych cech języka, historii itd, te informacje łatwo można odnaleźć w Wikipedii
Co potrzebujemy aby zacząć programować w Scali?
Po pierwsze musimy posiadać JDK w wersji 1.5 lub wyższej. Programy napisane w Scali uruchamiane są na wirtualnej maszynie, więc bez Javy się nie obejdziemy.
Następnie pobieramy dystrybucje Scali, wypakowywujemy, oraz ustawiamy zmienne środowiskowe(PATH w Windows), aby mieć dostęp do plików znajdujących się w katalogu bin.
Jeżeli wszystko wykonaliśmy poprawnie, możemy sprawdzić wersję oraz uruchomić REPL (read-eval-print loop).


$ scala -version
Scala code runner version 2.7.5.final -- Copyright 2002-2009, LAMP/EPFL
$ scala
Welcome to Scala version 2.7.5.final (Java HotSpot(TM) Client VM,
 Java 1.6.0_14).
Type in expressions to have them evaluated.
Type :help for more information.
scala>
scala> 1 + 1
res0: Int = 2

Istnieją 3 sposoby uruchamiania programów
1. Używamy z linii poleceń.
2. Umieszczamy kod w pliku, następnie wywołujemy

$ scala foo.scala

3. Możemy przeprowadzić kompilacje do plików klas, z których można utworzyć archiwum JAR, tak samo jak w przypadku Javy. Używamy kompilatora scalac

$ scalac foo.scala bar.scala

Istnieje także kompilator fsc (fast scala compiler), skracający czas kompilacji (uruchamia się jako osobny proces)

Gratuluje, możesz zacząć tworzyć w Scali :)

Reanimacja, reaktywacja

2009-09-03T21:00:00.003+02:00

Po długiej przerwie w końcu udało mi się zebrać w sobie i postanowiłem reaktywować bloga. O czym będę pisał dalej? Na pewno nie zmieni się charakter wpisów, dalej będą notki o frameworkach, językach i tego typu dziwnych rzeczach. Będę starał się napisać co nieco o Scali, może uda mi się utworzyć jakaś serie wpisów na temat tego zdobywającego coraz większą popularność języka programowania. Ale co by nie zapeszać wstrzymam się z większymi obietnicami, zobaczymy jak czas i chęci pozwolą.

NetBeans 6.5 juz jest!

2008-11-22T21:24:00.004+01:00

Ukazała się finalna wersja NetBeans IDE 6.5!
Po raz pierwszy mamy możliwość pracy z IDE w naszym ojczystym języku.
Aby pobrac wersje pl należy na oficjalnej stronie wybrać more languages.
Jeżeli chcecie dowiedzieć się wiecej na temat tłumaczenia zapraszam tutaj :)

Maven 2 + Strus 2

2008-04-25T15:44:00.010+02:00

No więc zacznijmy zabawę. Co potrzebujemy do utworzenia przykładowego projektu Struts2 za pomocą Mavena? Po pierwsze oczywiście Mavena :P Znajdziemy go na http://maven.apache.org/download.html. Znajduje się tam dokładna instrukcja instalacji dla każdego systemu, wiec nie będę się tu zbędnie rozpisywał.
Sprawdzamy czy poprawnie zainstalowaliśmy Mavena


~$ mvn --version
Error: JAVA_HOME is not defined correctly.
 We cannot execute /usr/lib/jvm/java-6-sun-1.6.0.03/bin/java

No i zonk, widać dzisiejsza aktualizacja Ubuntu do nowej wersji namieszała mi trochę w zmiennych. Szybka aktualizacja JAVA_HOME i wszystko jest ok


~$ mvn --version
Maven version: 2.0.9
Java version: 1.6.0_06
OS name: "linux" version: "2.6.24-16-generic" arch: "i386" Family: "unix"

Tworzymy nowy projekt za pomocą archetypu


~$mvn archetype:create -DgroupId=sampleApp
-DartifactId=sample
-DarchetypeGroupId=org.apache.struts
-DarchetypeArtifactId=struts2-archetype-blank
-DarchetypeVersion=2.0.9-SNAPSHOT
-DremoteRepositories=http://people.apache.org/repo/m2-snapshot-repository
...
[INFO] ------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------
[INFO] Total time: 4 seconds
[INFO] Finished at: Fri Apr 25 16:19:53 CEST 2008
[INFO] Final Memory: 7M/13M
[INFO] ------------------------------------------------------

Jeżeli wszystko przebiegło bezproblemowo Maven utworzył szkielet aplikacji oraz kilka przykładowych klas i stron jsp składających się na naszą aplikację. Struktura wygenerowanych plików wygląda następująco.


|-- pom.xml
`-- src
    |-- main
    |   |-- java
    |   |   `-- sampleApp
    |   |       `-- example
    |   |           |-- ExampleSupport.java
    |   |           |-- HelloWorld.java
    |   |           `-- Login.java
    |   |-- resources
    |   |   |-- example
    |   |   |   |-- Login-validation.xml
    |   |   |   |-- package.properties
    |   |   |   `-- package_es.properties
    |   |   |-- example.xml
    |   |   `-- struts.xml
    |   `-- webapp
    |       |-- WEB-INF
    |       |   `-- web.xml
    |       |-- example
    |       |   |-- HelloWorld.jsp
    |       |   |-- Login.jsp
    |       |   |-- Menu.jsp
    |       |   |-- Missing.jsp
    |       |   |-- Register.jsp
    |       |   `-- Welcome.jsp
    |       `-- index.html
    `-- test
        `-- java
            `-- sampleApp
                `-- example
                    |-- ConfigTest.java
                    |-- HelloWorldTest.java
                    `-- LoginTest.java

No i mamy gotowy nasz projekt. Jeżeli chcemy pracować nad nim za pomocą IDE, Maven jest w stanie utworzyć pliki projektu dla 3 najpopularniejszych IDE, NetBeans, IntelliJ Idea oraz Eclipse. W zależności od naszych preferencji wybieramy


~$ mvn idea:idea
~$ mvn netbeans:netbeans
~$ mvn eclipse:eclipse

W tym poście nie będę zagłębiał się we wnętrze aplikacji. Uruchamiamy serwer np Tomcata


machu@ ~$ /usr/local/tomcat/bin/startup.sh
Using CATALINA_BASE:   /usr/local/tomcat
Using CATALINA_HOME:   /usr/local/tomcat
Using CATALINA_TMPDIR: /usr/local/tomcat/temp
Using JRE_HOME:       /usr/lib/jvm/java-6-sun-1.6.0.06

I umieszczamy nasza aplikacje na serwerze


~$ mvn tomcat:deploy
...
Results :

Tests run: 4, Failures: 0, Errors: 0, Skipped: 0

[INFO] [war:war]
[INFO] Packaging webapp
[INFO] Assembling webapp[sample] in [/home/machu/Project/sample/target/
sample-1.0-SNAPSHOT]
[INFO] Processing war project
[INFO] Webapp assembled in[87 msecs]
[INFO] Building war: /home/machu/Project/sample/target/
sample-1.0-SNAPSHOT.war
[INFO] [tomcat:deploy]
[INFO] Deploying war to http://localhost:8080/sample-1.0-SNAPSHOT  
[INFO] OK - Deployed application at context path /sample-1.0-SNAPSHOT
[INFO] ----------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ----------------------------------------------------
[INFO] Total time: 13 seconds
[INFO] Finished at: Sat Apr 26 21:55:16 CEST 2008
[INFO] Final Memory: 8M/23M
[INFO] ----------------------------------------------------
machu@ ~/Project/sample$

Maven buduje aplikacje, dodatkowo przeprowadza testy i deployuje. Wchodząc na http://localhost:8080/sample-1.0-SNAPSHOT możemy przekonać się ze nasza aplikacja działa :)

JRuby on Rails + NetBeans + Java DB

2008-03-25T11:55:00.015+01:00

Ruby tu, Ruby tam, stwórzmy więc coś :)
Czego potrzebujemy?
Po pierwsze NetBeans z obsługa Ruby i GlassFisha
No i to właściwie wszystko.
Przed uruchomieniem musimy skopiować jedną bibliotekę, mianowicie Glassfish_HOME\javadb\lib\derbyclient.jar
do
NetBeans_HOME\ruby1\jruby-1.0\lib"

Zabawę rozpoczniemy od utworzenia nowej bazy danychNazwa użytkownika, hasło..

Tworzymy nowy projekt, Ctrl+Shift+N, wybieramy Ruby, następnie Ruby on Rails ApplicationNastępnie wybieramy nazwę dla naszej aplikacji i jako bazę danych ustawiamy JavaDB

No i szkielet naszej aplikacji jest juz gotowy. Zacznijmy od konfiguracji pliku database.yml. Sekcje development zmieniamy na


development:
adapter: jdbc
driver: org.apache.derby.jdbc.ClientDriver
url: jdbc:derby://localhost:1527/GuestBook
username: machu
password: passwd

Teraz pora na wygenerowanie modelu
W nowo otwartym oknie, w polu Arguments wpisujemy Entry (nazwa naszego modelu).
Rails generator zaczyna pracować i po chwili mamy utworzony model

W powyższym oknie klikamy w create db/migrate/001_create_entries.rb
Zmieniamy zawartość otwartego pliku na


class CreateEntries < ActiveRecord::Migration
  def self.up
    create_table :entries do |t|
    end
    add_column :entries, :tytul, :string
    add_column :entries, :autor, :string
    add_column :entries, :tresc, :text
  end

  def self.down
    drop_table :entries
  end
end

Zapisujemy i dokonujemy migracji bazy danych
Mamy model, teraz czas na kontroler, ponownie używamy Rails generatora
W oknie projektu klikamy prawym na Controllers, wybieramy Generate, w nowo otwartym oknie w polu Name wpisujemy GuestBook. Została właśnie utworzona klasa guest_book_controller.rbJej zawartość zmieniamy na


class GuestBookController < ApplicationController
  scaffold :entry
end

Scaffold zapewnia nam w pełni automatyczne operacje na tabelach bazy danych, takie jak dodawanie, usuwanie, tworzenie itp

Nastepnie otwieramy plik routes.rb (znajduje się on w Configuration)
i zmieniamy

#map.connect '', :controller => "welcome"

map.connect '', :controller => "guest_book"

Pozostaje nam tylko usunąć plik index.html (znajduje sie w Public) i uruchomić naszą nową aplikacje :)
Klikamy na projekt i wybieramy Run (F6)

Swieta

2008-03-21T17:33:00.005+01:00

Tak w swiatecznej atmosferze :)

http://www.playwielkanoc.pl/

Java i JavaFX

2008-03-12T23:56:00.008+01:00

Jedna z wielu zalet JavyFX jest mozliwosc wykorzystania funkcjonalnosci klas Javy. Mamy dostep do calej biblioteki standardowe oraz wszelkich bibliotek nie pochodzacych od Sun'a, co daje nam olbrzymie mozliwosci :)


import javafx.ui.*;
import javafx.ui.canvas.*;
import javax.swing.JOptionPane;
import java.lang.System;
Frame{
height: 80
width: 150
visible: true
content:
 Button{
 text: "Click Me!"
 action: operation(){
     var msg = new JOptionPane();
     var userName = System.getProperty("user.name");
     msg.showMessageDialog(null,"Hello {userName}");
 }
}
}

Jak widac uzycie klas javy jest banalne, wystarczy dodac import, ewentualnie zastosowac pelna nazwe klasy (nalezy pamietac, aby ujac ja w takim wypadku w <<>>, co widac na zalaczonym obrazku


import javafx.ui.*;
import javafx.ui.canvas.*;
import javax.swing.JOptionPane;
import java.lang.System;
import java.awt.Color;

var button = new <<javax.swing.JButton()>>;
button.setText("Click Me!");
button.setBackground(Color.RED);

Frame{
height: 80
width: 150
visible: true
content:
 Widget{
 component: button
 onMouseClicked: operation(MouseEvent){
     var msg = new JOptionPane();
     var userName = System.getProperty("user.name");
     msg.showMessageDialog(null,"Hello {userName}");
 }
}
}

Przyklad ten potwierdza iz pod wszelkimi klasami javyFX tak naprawde ukrywaja sie klasy Swinga. Tworzymy tu obiekt JButton, ktory nastepnie przypisujemy jako komponent naszego wyswietlanego widgetu, rownie dobrze mozemy mu przypisac JOptionPane

Gwiazdka, co, jak, dlaczego?

2008-03-03T19:39:00.008+01:00

Postram sie teraz wyjasnic kilka kluczowych aspektow gwiazdki.
A wiec zaczynajmy.
1. Obiekt Group, pozwala nam wykonywac transformacje na kilku obiektach jednoczesnie
(w tym przypadku sa to 2 obiekty Star)
Dostepne transformacje to

transform: [translate(x, y)], przesuniecie
transform: [rotate(kat, x, y)], obrob o dany kat dookola punktu (x,y)
transform: [scale(x, y)], przeslakalowania
transform: [skew(x, y)], przekrzywienie

operator [] oznacza tablice, wiec transformacje mozemy ze soba laczyc:

transform: [translate(10, 10), scale(2, 2)]

dana grupa zostanie przesunieta o 10px i powiekszona dwukronie

2. Operator bind
Jest to jeden z kluczowych operatorow javyFX, pozwala nam (hmm jak to ujac, nie uzywajac slowa zbindowac) polaczyc ze soba 2 wartosci, w przypadku zmiany jednej, automatycznie zmianie ulega wartosc
drugiej. Najlepiej pokaze to na przykladzie


import javafx.ui.*;
import java.util.Date;

var someText= "TITLE";

var frame = Frame{
width:300
height:100
title: bind someText
visible:true
content:Label{
    text:"Get time!"
    onMouseClicked: operation(mEvent){
        var date = new Date();
        someText = "{date.hours}:{date.minutes}:{date.seconds}";
    }
}
};

Po kazdym kliknieciu do zmiennej someText przypisywana jest aktualny czas, dzieki zastosowania do tytulu ramki operatora bind, po kazdym kliknieciu jest on aktualizowany.
Do uzyskania aktualnego czasu uzylem klasy z poza JavyFX, stosowanie kodu javy w aplikacji FX przedstawie innym razem.

3. Animacje
Do tworzenia animacji wykorzystujemy operator dur. Jego zastosowanie jest proste jak budowac cepa. Okreslamy przedzial w jakim dana wartosc ma sie zmieniac np x = [1..100] i czas przez ktory ma sie to dokonac np. dur 100, w efekcie x co 1 milisekunde bedzie zwiekszac sie o 1. Po zbindowaniu do wartosci jakiegos pola(np. rozmiaru) uzyskujemy animacje

Gwiazdka

2008-02-26T21:26:00.004+01:00

A taka smieszna gwiazdka, mozna ja przesuwac i po kliknieciu sie dziwne rzeczy dzieja ;)


import javafx.ui.*;
import javafx.ui.canvas.*;

Frame{
  height: 200
  width: 400
  visible: true
  content: Canvas{
      content: Group{
          var x = 100
          var y = 100
          var angle = 0
          var rin = 20
          transform: bind [rotate(angle,x,y)]
          content:[
          Star {
              var: self
              cx: bind x
              cy: bind y
              rin: bind rin
              rout: 60
              points: 15
              startAngle: 0
              stroke: green
              fill: lightgreen
              strokeWidth: 2
              onMouseEntered: operation(mEvent){
                  self.cursor = HAND;
              }
              onMouseDragged: operation(mEvent){
                  x += mEvent.dragTranslation.x;
                  y += mEvent.dragTranslation.y;
              }
              onMouseClicked: operation(mEvent){
                  angle = [1..360] dur 1500;
                  rin = [1..100] dur 1500;
              }            
          },
          Star {
              cx: bind x
              cy: bind y
              rin: 30
              rout: 70
              points: 15
              startAngle: 60
              stroke: green
              fill: lightgreen
              strokeWidth: 2
          }
          ]        
      }
  }
}

Hello FXWorld !

2008-02-26T02:00:00.002+01:00

No wiec zaczynajmy. Aby uruchomic program w JavaFX Script ( dalej bede skracal to do JavaFX) mamy 2 opcje:

Instalujemy plugin do naszego ulubionego IDE (czyt. NetBeans) obslugujacy JaveFX, do Eclipsa istnieje takowy rowniez
Uzywamy JavaFXPada, web start, lub sciagamy

Osobiscie preferuje opcje NetBeans, w fxpadzie jakos dziwnie działa uzupełnianie składni. Do uruchamiania przykladowych programow fxpad powinien byc jednak wystarczajacy.

No wiec najprostszy program bedzie wygladal tak:


import javafx.ui.*;

Frame{
  width: 100
  height: 20
  content:
        Label{
          text: "HELLO WORLD FX!"
     }
  visible: true
}

Co sie tu dzieje? Wiec tworzona jest nowa ramka, ustalamy jej wysokosc i szerokosc, a jako zawartosc ustalamy etykiete z tekstem, czyz to nie proste ?:)

Dla pelnego wyjasnienia, zapisze to w inny troche sposob (rowniez poprawny kod javyFX )


var frame = new Frame();
frame.width = 100;
frame.height = 20;
frame.visible = true;

var label = new Label();
label.text = "HELLO WORLD FX!";

frame.content = label;

Efekt dzialania jest identyczny, w wiekszosci przypadkow stosuje sie jednak pierwszy zapis, jest on znacznie wygodniejszy.
Slowo kluczowe var oznacza zmienna, nie musimy okreslac jakiego jest typu, dzieje sie to na etapie kompilacji.

2008-02-26T01:57:00.001+01:00

No wiec zaczynajmy. Aby uruchomic program w JavaFX Script ( dalej bede skracal to do JavaFX) mamy 2 opcje:

Instalujemy plugin do naszego ulubionego IDE (czyt. NetBeans) obslugujacy JaveFX, do Eclipsa istnieja takowy rowniez
Uzywamy JavaFXPada, web start, lub sciagamy

Osobiscie preferuje opcje NetBeans, w fxpadzie jakos dziwnie działa uzupełnianie składni. Do uruchamiania

przykladowych programow fxpad powinien byc jednak wystarczajacy.

No wiec najprostszy program bedzie wygladal tak:
import javafx.ui.*;


Frame{
width: 100
height: 20
content:
Label{
text: "HELLO WORLD FX!"
}
visible: true
}

Powitanie

2008-02-26T00:04:00.000+01:00

Witam na nowo powstałym blogu, znajdziecie tu głownie informacje o JavieFX, Javie i innych tego typu bzdetach ;)