2012. március 29., csütörtök

Angol szótár

A PCFórum-on találtam rá az alábbi cikkre: Kihívója támadt a Sztaki szótárnak

A TopSzótár nevű új oldalról van szó. Egy olyan angol-magyar szótárt kínál, mely áthidalja az általam ismert és eddig használt 2 szótárban - Sztaki és DictZone - tapasztalt nehézségeket, hiányosságokat. A keresőbe beírható ragozott, múltidejű, többes számú alak, a rendszer felismeri és kiadja az alapszót. Ezeket az alakokat ki is írja rendezetten minden szó esetén. Megjeleníti a szófajt, illetve kifejezéseket is, valamint néhol példamondatokat is meg tud jeleníteni. Emellett akasztófázhatunk is az oldalon, ha unjuk a banánt. :-)


2012. március 19., hétfő

Broken

Művelem magam az Evanescence, és csodálatos hangú énekesnője, Amy Lee munkássága terén. Bújom a YouTube-ot, számomra még ismeretlen számok után kutatva, és nyugodtan mondhatom, kincsekre is bukkanok. Az alábbi is egy ilyen: Amy Lee közreműködése a Seether nevű pretoriai bandával, a dal címe Broken.


Nagyon szép a gitárszólam, én libabőrözök végig. A srác hangja kellemes, mély, Amy pedig ebben a dalban sem okoz csalódást. A téma mély, nem éppen vidám. A klipp is egész jó, Amy-n jól állnak a szárnyak! :-)

Kötelező darab.

2012. március 18., vasárnap

URL encode-decode

Ha GET-es form-okkal dolgozunk, szükségünk lehet arra, hogy át tudjunk adni speciális karaktereket is a querystring-ben, például + vagy szóköz. Ebben van segítségünkre a beszédes domain-nel rendelkező alábbi eszköz, mely segít az oda-vissza kódolásban.

Reguláris kifejezésekhez

A szakdolimban elég sok reguláris kifejezést használtam, megfogalmazásukban az alábbi tool volt segítségemre:


Real-time kijelöli a szövegben a mintára illeszkedő részeket, ha pedig az egeret is ráviszed, kiírja az illeszkedés adatait (pl. kezdet, hossz, csoportok illesztett értékei).

2012. március 15., csütörtök

Imaginary verziók

Egyik kedvenc Evanescence számom, az Imaginary több verzióban is kikerült a stúdióból, tegnap találtam még két demót, fantasztikusak! :-)

Demo #1


Itt vannak a verziók YouTube linkekkel, válaszd ki, neked melyik tetszik! :-)


Részletek és dalszövegek: http://evanescencereference.info/wiki/index.php?title=Imaginary


2012. március 13., kedd

Szálak kordában tartása

Előfordul, hogy olyan programot írunk, amely előbb-utóbb 20-30, esetleg 50-100 szálat is indít, ami nem biztos, hogy egészséges. Szükségünk lehet arra, hogy limitáljuk az egy időben futó szálak számát. Ez azonban nem egy triviális feladat.

Első gondolat: statikus counter (a saját szál osztályunkban). Szinkronizált get, inc, dec, és várakoztatás indítás előtt, egy üres while ciklussal. Néhány szálnál ez látszólag működőképes megoldás (ha jól meg van írva). Azonban ez így önmagában nem elég. Elképzelhető, hogy két szál "egyszerre" lép ki a while ciklusból (vagyis "A" szál érzékeli, hogy csökkent a számláló, azaz kiléphet, de nem tudja olyan gyorsan visszanövelni a számlálót, hogy "B" szál ne tudjon szintén kilépni a várakozásból). Ebben az esetben máris limit+1 darab szálunk fut. Minél több szálunk van, annál többen várakoznak, annál nagyobb az esély arra, hogy "egyszerre" indulnak el a várakozás után, és annál több szál indulhat el, vagyis annál jobban meghaladja a limitet a szálak száma. Más megoldás kell: ütemező.

Ma sikerült saját magamtól összeraknom egy ilyet, és működik, nem merészkedik a limit fölé a counter. Igaz: nincs is counter! :-)

Alapötlet: tároljuk a futtatandó, ütemezendő szálakat egy listában, és legyen egy szál, ami menedzsel, ütemez. Folyamatosan figyeli a futó szálakat, és ha valamelyik leállt, akkor törli a listából, és indít egy újat (a legelső még nem futó szálat). Ennek értelmében a futó szálak egymás melletti listaelemek lesznek, mégpedig a lista elején, így elég csak a [0..(limit-1)] intervallumot figyelni. Ha egy szál leállt, töröljük a listából, ekkor a (limit-1)-es indexű listaelem lesz az a szál, amit el kell indítani (persze, ha van egyáltalán annyi elem).

Ezzel a megoldással teljes mértékben felügyeljük a szálak indítását, hiszen csak az ütemező maga indítja azokat. Mivel ciklusba van szervezve a vizsgálat, a szálakat, mint listaelemeket egymás után nézi meg, így konkurencia sincs, nem fordulhat elő, hogy "egyszerre" két szál is elinduljon. :-)

Ezen felül, ha a sok szálat elindító főszálnak szüksége van arra, hogy megvárja, amíg a szálai befejeződnek, elég csak az ütemező szálat figyelni, hogy fut-e még. Persze ez implementáció kérdése, de az én megvalósításom így működik.
import java.util.ArrayList;
import java.util.List;

public class ThreadScheduler extends Thread {

    private int limit = 3;
    private List<Thread> threads = new ArrayList<Thread>();

    public ThreadScheduler() {
        setName("ThreadScheduler");
    }

    public synchronized void add(Thread t) {
        threads.add(t);
    }

    private synchronized boolean manage() {
        for (int i = 0; i < limit && i < threads.size(); i++) {
            if (!threads.get(i).isAlive()) {
                threads.remove(i);
                if (threads.size() >= limit) {
                    threads.get(limit - 1).start();
                }
                break;
            }
        }
        return !threads.isEmpty();
    }

    @Override
    public void run() {
        for (int i = 0; i < limit && i < threads.size(); i++) {
            threads.get(i).start();
        }
        while (manage());
    }
}

A run() metódus először elindítja az első szálakat, a [0..(limit-1)] intervallumban, hogy a menedzselés ne törölje őket.

Használata pedig:
ThreadScheduler sched = new ThreadScheduler();

// szálak hozzáadása
sched.add(t);

// ütemezés indítása
sched.start();

// megvárhatjuk, mikor futott le mindegyik szál
while (sched.isAlive());
System.out.println("The End");

Egy lehetséges kiegészítés lehet még a megszakíthatóság. Ez esetben a run() metódus while ciklusának feltételéhez hozzá kell venni az isInterrupted() vizsgálatát, illetve a ciklus után egy elágazásban: ha megszakítás volt, akkor küldjön megszakítást a futó szálaknak. (És persze megvárni a még futó szálak befejeződését, végül pedig esetleg üríteni a listát.)

2012. március 12., hétfő

Metallica - Beyond Magnetic EP

A tavalyi év végén jelent meg az iTunes-on a Metallica új EP-je, a Beyond Magnetic.

Meghallgattam.

Amit tapasztalok (objektív dolgok): próbálnak új technikákat belevinni a zenéjükbe, Kirk játszik a tremolo karral és wah pedállal, illetve sokszor megtörik az ütemet, eltérnek a 4/4-től, hatásszünetet tartanak, hirtelen stílus-/hangzás-/ritmusváltásokat alkalmaznak track-en belül.


Amit gondolok (szubjektív dolgok): a riffek nem rosszak, a hangzások is el vannak találva. A szólók nekem gyengék, meg a számok is valahogy nekem nyögve-nyelősek, vérszegények. A váltások néhol túl hirtelenek. Nekem úgy tűnik, a Metallica veszített a lendületből. Érzem ezt azóta, hogy láttam egy koncertfelvételt a World Magnetic Tour-ról, ami csalódást okozott. Nem dobtam hátast a Beyond Magnetic-től. Nem fog eszembe jutni, hogy előszedjem ezt az EP-t a jövőben.

(A dalszöveget nem figyeltem, de nem is keltette fel az érdeklődésem.)

Ablak a képernyő közepére

A Swing általában nem foglalkozik azzal, hogy az ablakot hol helyezi el a képernyőn: a bal felső sarokban jeleníti meg az új ablakokat. A JavaFX 2 már valamelyest kiközepeli, de szerintem nem pontos (bár lehet, hogy csak azért, mert a kliens területet nézi a képernyőn, a tálcát levágva).

Pofon egyszerű megoldani az ablak középre igazítását. Le kell tudni kérdezni a képernyő méreteit, az ablak szélességét, és tudni kell állítani a pozíciót.

Swing-ben szükség van a java.awt csomag Dimension és Toolkit osztályára, illetőleg a Window-ra. Mivel ez utóbbiból származik a JFrame és a JDialog is, ha Window-ra oldjuk meg a problémát, az mindkettőhöz használható lesz.
public static void centerizeWindow(Window w) {
    Dimension s = Toolkit.getDefaultToolkit().getScreenSize();
    Dimension d = w.getSize();
    int left = (int) ((s.width - d.width) / 2);
    int top = (int) ((s.height - d.height) / 2);
    w.setLocation(left, top);
}

JavaFX-ben az ablakot a Stage reprezentálja. JavaFX-ben is elérhetjük a képernyő tulajdonságait, ehhez a javafx.stage.Screen, illetve a javafx.geometry.Rectangle2D importokra van szükségünk.
public static void centerizeStage(Stage stage) {
    Rectangle2D screen = Screen.getPrimary().getVisualBounds();
    stage.setX((int) ((screen.getMaxX() - stage.getWidth()) / 2));
    stage.setY((int) ((screen.getMaxY() - stage.getHeight()) / 2));
}

Valójában a Stage a javafx.stage.Window leszármazottja, és a fenti metódusban is a Window gettereit/settereit használjuk, de a Window-nak nincs más olyan származtatása, amit középre igazítanánk a képernyőn, így az egyszerűbb használat érdekében maradhat a Stage típusú paraméter.

2012. március 10., szombat

Runnin' Wild

Nagyon jó zenére programozni, hát még rock-ra! :D

Nemrég találtam az alábbi nótát, első hallásra megtetszett. Jó, hogy azért van 1-2 együttes manapság, amelyik tud zenét csinálni. A Runnin' Wild egy jó kis rock 'n' roll zúzás. Erősen AC/DC-s a zene: a riffek jellege, az effekt és a srác hangja is, de jól tolják - továbbviszik a stílust. Ők is ausztrálok, akárcsak a legendás AC/DC. Érdemes belehallgatni a többi számukba is. :-)

Airbourne - Runnin' Wild

Kódszépítés

A szakdolim fejlesztése során kitaláltam egy kis technikát, hogyan lehetne rövidebb és (számomra) esztétikusabb a kódom. Ott a JavaFX Label osztályával csináltam meg az alábbi trükköt, most általánosan írom le.

Ha van egy ilyen jellegű dolog:
Valami v = new Valami();
v.setA(1);
v.setB("akarmi");
v.setC(true);

Meg lehet csinálni azt, hogy származtatod az osztályt, beburkolod a függvényeket úgy, hogy meghívják az ősben levő függvényt, majd visszaadják az objektumot:
public class ValamiEx extends Valami {

    // konstruktorokat is le kell másolni, bennük super(...); hívással

    public ValamiEx setA(int i) {
        super.setA(i);
        return this;
    }

    public ValamiEx setB(String s) {
        super.setB(s);
        return this;
    }

    public ValamiEx setC(boolean b) {
        super.setC(b);
        return this;
    }
}

Ezzel a megoldással már a fenti kód le is rövidül:
Valami v = new ValamiEx().setA(1).setB("akarmi").setC(true);

Ezt a mintát alkalmazva egy Label objektum esetén akár egy sorban beállítható minden formázás:
Label label1 = new LabelEx("Hello LabelEx!").bold().italic().center(); // stb.

Szerintem legalábbis ez így esztétikusabb. :-)

2012. március 9., péntek

Billentyűkezelés JFrame-ben

Biztos sok Java-s programozótársam gondolkodott már azon, hogy lehetne Swing-es JFrame ablakban lekezelni a billentyűket, ha a KeyListener-es megoldás nem működik. Mert van olyan, hogy az nem működik: például a form-hoz hiába adod hozzá, nem csinál semmit, pláne ha van legalább egy gombod vagy beviteli meződ - mert akkor azok valamelyike lesz fókuszban és kapja el a billentyűleütés eseményét. Játékot ezzel nem lehet írni.

Létezik azonban egy globális billentyűzetkezelő mechanizmus, amihez hozzá lehet adni egy saját osztályt, aminek a metódusa szépen meghívódik minden billentyűzet esemény bekövetkezésekor, amíg a program fut, bármelyik objektum vagy form is legyen fókuszban. A KeyEventDispatcher interfészt kell megvalósítani, majd átadni az objektumot a KeyboardFocusManagernek.

Én minden ablakomba tettem egy saját dispatcher-t, de mivel ezek globálisan kapják el a billentyűeseményeket, írtam a metódusukba egy elágazást, hogy csak akkor kezelje le az eseményt, ha az adott ablak van fókuszban.

Példa:
public class MyWindow extends JFrame implements KeyEventDispatcher {

    public MyWindow() {
        KeyboardFocusManager.getCurrentKeyboardFocusManager().addKeyEventDispatcher(new MyKeyEventDispatcher());  
    }

    @Override
    private boolean dispatchKeyEvent(KeyEvent e) {     
        if (!MyWindow.this.isFocused()) return false;

        if (e.getID() == KeyEvent.KEY_PRESSED) { // lenyomva
            if (e.getKeyCode() == KeyEvent.VK_DOWN) {
                //...
            } // else if ...
        } else if (e.getID() == KeyEvent.KEY_RELEASED) { // felengedve
            // ...
        } else if (e.getID() == KeyEvent.KEY_TYPED) { // gépelve (?)
            // ...
        }
        return false;
    }
}
A RELEASE és TYPE ágakkal én nem nagyon foglalkoztam, nem is igazán tudom mi a különbség a TYPE és a PRESS között, ennek kikísérletezését rátok bízom.

2012. március 8., csütörtök

NetBeans 7.1 - megéri váltani?

Tegnap érdekes problémára derült fény.

A NetBeans 7.1beta-val készített projektet átültettem, hogy a 7.1-ben is fusson, de újabb gond akadt. NB-ből futtatva gyönyörűen megy, viszont az elkészített JAR fájl futtatáskor nem találja a lib-eket. A probléma a jar/META-INF/manifest.mf fájljában leledzik, ami tárolja azt a classpath-t, amit a JAR fájl használ futáskor.

A NB 7.1-es verziója konkrétan elfelejti definiálni a "JavaFX-Class-Path" értéket a manifest fájlban. Voltam olyan eszes, hogy backupoltam a 7.1beta-val készített JAR-t, így azzal össze tudtam hasonlítani, innen derült fény a turpisságra. (És azt, hogy melyik fájlban lehet gond, a témavezetőm mondta, úgyhogy innen is köszönet neki!)

Lehetséges konklúzió: maradjunk meg a NetBeans 7.1beta-nál? (És nézzük el, hogy néha exception-t dob a lassúság-detektora?)

A hibát még a 7.1.1-es verzióban sem javították.

2012. március 5., hétfő

Forráskód színezés Blogger-be

Már korábban is szemeztem ezzel a tool-lal, de azt hiszem egy fő témának a programozást megjelölő blogra illenék is reflexből beépítenem: SyntaxHighlighter. Ez arra jó, hogy szintaktikus színezést tud alkalmazni oldalba illesztett forráskódba. JS-sel dolgozik, és persze bővíthető.

Nagyon egyszerű beépíteni, ez a cikk jól leírja: link. Nem másolom át ide, felesleges, csak néhány kiegészítést tennék hozzá.

A cikkben azt írja, hogy a bejegyzés előnézetében a Blogger nem futtatja le a szkriptet, pedig igen. :-)

Illetve, én még hozzáadtam ezt a CSS sort a blogomhoz:

div .syntaxhighlighter { padding-bottom: 1px; }

Ugyanis a SH egy kicsit bugos: nem jól számítja ki a doboz magasságát, 1 pixellel kisebbre veszi, mint a tartalom, így megjelenik egy oldalsó scrollbar. A fenti CSS kóddal ez kiküszöbölhető.

A SH honlapján (fentebb linkeltem) fent van, milyen nyelveket támogat, és milyen témák vannak (elég gyér választék amúgy, de nyilván pofon egyszerű egyénit hozzáadni), illetve, hogy ezeket hogyan kell hozzáadni a szkripthez. (Pofon egyszerű, csak include-álni kell <link ... /> tag-ekkel.)

Cellaformázás JavaFX 2-ben

A szakdolim felületének építése során előjött egy érdekesség, amiről nem szól a fáma... akarom mondani a JavaFX tutorial: a TableView egyik oszlopában én linkeket szerettem volna látni, azaz kék, aláhúzott kattintható szöveget.

A TableView ugye egy megadott osztályhoz készül, és ennek mezőihez lehet megfeleltetni oszlopokat. A táblázat adatforrása pedig a megadott osztály példányaiból álló lista. (Ebben most nem fogok elmerülni, példakódhoz lásd: TableView tutorial)

Mivel a TableColumn osztályban nincs lehetőség formázásra, oszlop szinten, a cellaépítő függvényt kell kiegészíteni.

Tegyük fel, hogy van egy Link osztályom, aminek van egy url nevű String mezője, egy getterrel, és ehhez készítem az oszlopot. Eképpen sikerült megoldani (utána magyarázom):

TableColumn linkCol = new TableColumn("URL");
linkCol.setPrefWidth(250);
linkCol.setCellValueFactory(new PropertyValueFactory<Link, String>("url"));
final Callback<TableColumn<Link, String>, TableCell<Link, String>> cf
    = linkCol.getCellFactory();
linkCol.setCellFactory(
    new Callback<TableColumn<Link, String>, TableCell<Link, String>>() {

    public TableCell<Link, String> call(TableColumn<Link, String> param) {
        final TableCell<Link, String> cell = cf.call(param);
        cell.setStyle("-fx-text-fill: blue; -fx-underline: true");
        cell.setOnMouseClicked(new EventHandler<MouseEvent>() {

            public void handle(MouseEvent event) {
                System.out.println("LINK: " + cell.getText());
                // avagy: java.awt.Desktop.getDesktop().browse(
                //                          new URI(cell.getText()));
                // (persze a megfelelő előzetes ellenőrzésekkel)
            }
        });
        return cell;
    }
});

Vagyis először létrehozom és beállítom az oszlopot, utána lekérem a függvényt, amivel a JavaFX felépítene egy cellát, majd készítek egy saját cellaépítőt. Ebben az elsődleges dolog: meghívom a default cellaépítőt, amit lekértem az előbb, így már csak a plusz formázást kell hozzáadnom, illetve a kattintás eseménykezelőjét.

2012. március 4., vasárnap

JavaFX 2 - tapasztalatok

Pár napja fejeztem be a szakdolgozatom, aminek a GUI-ját JavaFX-ben dobtam össze, így az elmúlt 2 hónapban gyűjtött tapasztalataimat most megosztom e nagyszerű API-val kapcsolatban.

Mi is a JavaFX 2 ?

Egy API, mellyel GUI-t adhatunk Java projektünkhöz. Olyan, mint a Swing, csak sokkal szebb és funkciógazdagabb. Ha rákeresünk a JavaFX 1.x-es verzióira, láthatjuk, hogy annak külön szintaktikát vezettek be, szerencsére ez a 2.0-ban már nincs így, úgy használható, mint bármely más csomag. Csak telepíteni kell hozzá a fejlesztő kit-et, illetve a célgépen csak a runtime-ot. Emellett Java 7-et követel meg, illetve NetBeans 7.1-et (pontosabban). A NB-ben az új projekt varázslónál ki is lehet választani, hogy egy JavaFX projektet kezdesz, ekkor kapsz egy Hello World-öt.

A JDK telepítőjében a 7u2-es verziótól már megtalálható a JavaFX SDK is, tehát nem kell külön letölteni és installálni.

+ Előnyök

Gyönyörű grafikai elemeket tartalmaz, könnyen és gyorsan össze lehet dobni vele a felületet, a tutorial segít is benne. Emellett új kontrolok is vannak, például többféle grafikonnal is színesíthetjük projektünket (érdemes letölteni a samples csomagot!). Az elemeket CSS alapon lehet formázni, és van lehetőség effektezésre, akár animáltan is, és mivel a végeredmény lazán beágyazható weboldalba is, simán vetélytársa lehet a Flash-nek.

- Hátrányok

A tutorial csak az alapokat mutatja be, ha valami komolyabbat akarsz benne összerakni, bújni kell a doksit és izzadni pár cseppet, mire kitalálod, hogyan is kell. Az univerzalitás néhol a könnyű használat rovására megy. Például nekem nem tetszik az, ahogy a cellaformázást meg lehet oldani: ugyanis egyenként kell, oszloponként nem lehet. (cikkem erről)

Vannak benne bugok is, például a TextArea betűszínét még a legfrissebb 2.0.3-es verzióban sem képes átszínezni.


Hiányosságai is vannak, például nekem hiányzik egy onResize szerű event az ablakot formáló Stage objektumból. A kis méret / teljes méret gombokat sem lehet kikapcsolni, így dialog-ot készíteni benne (mert ugye nincs rá külön class) nehezebb.

Linkek

Minden (tutorial, letöltések) megtalálható itt: http://javafx.com
Érdemes a CSS referenciát könyvjelzőbe tenni, ha komolyabban is fejlesztesz a JavaFX-szel! :-)

2012. március 3., szombat

Megfelelő bélyegkép beállítása Facebook megosztáshoz

Probléma: ha közzé akarom tenni a blogomat a Facebook-on, Picard kapitány facepalm fotóját teszi be bélyegképnek a közösségi portál. De én nem azt a képet szeretném, hanem egy másikat.

Órákig gugliztam, és többször nekifutottam a keresésnek, mire a sok cikk között végre találtam egy normális leírást, hogyan is kell ezt megoldani.

Sok helyen dobálóznak a <link rel="image_src" href="..." /> tag-gel, de ez nem működik.

Utána említik az OpenGraph protokol property-jeit, amit meta tag-ben lehet átadni, ez már a megoldás egyik fele, de önmagában fabatkát sem ért.

A korrekt cikk, ami leírja mit kell csinálni, itt található: link. De én is leírom most.

Megoldás:


  1. Adj hozzá egy <meta property="og:image" content="..." /> tag-et a HTML laphoz (head részbe), ahol a "..." helyére írd be a képfájl URL-jét. (Bloggerben: Sablon -> HTML kód szerkesztése gomb.)
  2. Látogass el ide: Debugger, írd be az oldalad címét, majd ENTER. Ez a tool megmutatja, milyen infókat sikerült a Facebook-nak kinyernie a beírt URL-ről. Ami viszont még fontosabb, hogy nem csak megmutatja, hanem frissíti is a Facebook cache-t! Ez utóbbiért fontos ez a lépés.

(Blogger esetén várj 1-2 percet a 2 lépés között, hogy legyen ideje a Google-nek frissíteni a sablont a szerveren.)

2012. március 2., péntek

JDK, JavaFX és NetBeans upgrade

Ma úgy döntöttem, hogy upgrade-elem a NetBeans-emet 7.1beta-ról a 7.1 stabil változatra, illetve a JavaFX 2.0.2-met a 2.0.3-as verzióra. Közben viszont láttam, hogy a JDK-hoz a 7u2-től már hozzácsapják a JavaFX-et is, úgyhogy leszedtem a legfrissebb JDK 7u3-at is.

Eltávolítottam a régebbi változatokat szép sorjában, majd feltoltam mindent egymás után. Jó dolog egyébként, hogy a JDK-ban már a JFX is benne van, időt és adatforgalmat/helyet is megtakarítok vele, mert így a JDK telepítője csak 5 megával több, míg a külön JFX telepítő 14 körül van.

Viszont a gond ott kezdődött, hogy megnyitottam az új NetBeans-ben a beta verzióval fejlesztett projektemet.  Már megnyitáskor jelezte, hogy valami gond van a függőségekkel: a JavaFX platform neve megváltozott az új verzióban. Jó, ezt még egyszerű átállítani "Default JFX platform"-ról "Default JavaFX platform"-ra.

Ezután build-elés meghiúsult egy hibaüzenettel: Target "jfxsa-run" does not exist in the project <projektem neve>. Éreztem, hogy a build szkriptben lehet valami változtatás, de ehhez nem értek, úgyhogy gugliztam. A NetBeans fórumain redundánsan is jelezték, mint bugot. Valahol azt találtam, hogy instabil->stabil upgrade-hez nem adnak támogatást a fejlesztők. (Szerintem ez mocsokság.) Az egyik hozzászólásban azt írták, hogy új projekt létrehozásával és átpakolgatással megszűnik a gond. Persze én is gondoltam erre, csak reméltem, hogy lesz egyszerűbb megoldás is. Úgyhogy végül ezt csináltam. Létrehoztam másik mappában egy ugyanolyan nevű projektet, átcopy-ztam mindent, beállítottam a lib-eket, majd az nbproject mappa tartalmát áthúztam az eredeti projektmappámba.

Az EclipseLink JPA2.0-val meggyűlt a bajom. Csak úgy tudtam újra hozzáadni, hogy létrehoztam egy új entity class-t, azzal a NB beimportálta a lib-et, majd töröltem az osztályt, ezután pedig felülírtam a saját persistence.xml fájlommal az újonnan generáltat. És ekkor sikerült végre elérni, hogy az újraépített projekt működjön is.

Frissítés, 2012.03.08.

2012. március 1., csütörtök

Azure és a szökőév

Friss hír: a srácok a Microsoft-nál elfelejtették, mi is az a szökőév, így tegnap lehalt az Azure.

Cikk: http://www.hwsw.hu/hirek/48180/microsoft-azure-leallas-cloud-felho.html

Azért most így elgondolkodtam, hogy ha egy szökőnapot képesek kihagyni a számításból, akkor milyen hiányosságok lapulhatnak a biztonsági modulokban...