Dulifuli és a GUI frameworkök

Dulifuli ezt mondja:

Be kell valljam, hogy idestova 20 éve programozok PC-kre GUI-s alkalmazásokat. Előtte meg 8 évig más gépekre csináltam GUI-s alkalmazásokat. Ez idő alatt azt tapasztaltam, hogy a sokféle framework van, de egyik sem jó, még közel sem jó. Egyszerűen idegesítően vackok. Utálom mindet!

Mintha olyan emberek készítették volna őket, akik még sosem készítettek ablakos programot. Mint amikor a szakácsok főznek - de sosem kóstolják meg, mit főztek. Grrr!

Hm, miért pattog ennyire? Hiszen ott van az Internet megannyi szépséges példaprogrammal! Sőt, az Oracle oldalán lépésről-lépésre végigvezetnek az összes GUI-val kapcsolatos tudnivalón! De Dulifuli tovább pattog:

Na ne már! Figyu, csinálni akarok egy egyszerű ablakot, ha beírod a nevedet, akkor kiírja, hogy Helló meg a beírt nevet. Ennyit:

Egy legegyszerűbb program

ami tényleg nagyon "egyszerű", csak ennyi az egész a lehető legrövidebben:

import java.awt.GridLayout;

import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JTextField;
import javax.swing.event.DocumentEvent;
import javax.swing.event.DocumentListener;

public class HelloGui {
    String name="Geza";

    public HelloGui() {
        JFrame frame=new JFrame("Hello");       
        frame.setLayout(new GridLayout(2, 2));
        frame.add(new JLabel("Név:"));
        JTextField nameEdit=new JTextField(name);
        frame.add(nameEdit);
        frame.add(new JLabel("Hello"));
        JLabel nameLabel=new JLabel(name);
        frame.add(nameLabel);

        nameEdit.getDocument().addDocumentListener(new DocumentListener() {
            @Override
            public void removeUpdate(DocumentEvent e) {
                changed();
            }

            @Override
            public void insertUpdate(DocumentEvent e) {
                changed();
            }

            @Override
            public void changedUpdate(DocumentEvent e) {
                changed();
            }

            public void changed() {
                name=nameEdit.getText();
                nameLabel.setText(name);
            }

        });

        frame.pack();
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
    }

    public static void main(String[] args) {
        new HelloGui();
    }
}

Na ezt magyarázza valaki meg.

Én csak 5 egyszerű dolgot szeretnék: egy ablak, három szöveges label, és egy beviteli mező. Miért kell ehhez 54 sornyi masszívan érthetetlen kódot írni?

Hát no, igen, ezt tényleg picit hosszú lett, és tényleg picit olvashatatlan is. De Dulikám, tudod, vannak ilyen interaktív GUI szerkesztők, amikkel egyszerűen az egérrel ledobálod az ablakra a vezérlőket, és készen is vagy! Tudod, Eclipse WindowBuilder, vagy ott a NetBeans is!

Eclipse WindowBuilder

Ha ezzel megvagy, akkor ez elkészíti az egész GUI kódot, és készen is vagy, nem?

Egy frászt vagyok készen! Ezek az eszközök a munka kisebbik felében segítenek csak. Arra jó, hogy gyorsan ledobáljak mindent, hogy hogy nézzen ki az ablak, de utána megint nekem kell szájbarágni a Swingnek, hogy mikor mi történjen.

Az előző példaprogram nem sok mindent csinál - de több mint a fele arról szól, hogy mi történjen: ha valaki átírja a nevet, akkor rögtön írja ki az új nevet alá. Utálom a fél megoldásokat. Te örülnél, ha kapnál egy fél poharat?

De akkor most mit szeretnél, Dulikám?

Megmondom én jól neked! Tessék, itt van Dulifuli öt pontja! Ami hét! (Mert I hate.) És ne hívj Dulikádnak! Az olyan fura!

1) Egy ablakban lévő dologhoz egyetlen sort kelljen írni.

2) Automatikusan rendezze el az ablakban a vezérlőket - értelmesen, ne kelljen nekem megadni, hogy hány sor meg hány oszlop lesz, meg hogy mi mekkora legyen.

3) Minden logikusan és értelmesen nézzen ki és viselkedjen magától. Például, ha átméretezik az ablakot, akkor ilyet ne csináljon:

Ez mi???

4) Minél kevesebbet kelljen megtanulni a frameworkről. A frameworkök jönnek-mennek, nem vicces, hogy 100 osztályt és ezek minden metódusát fejben kell tartani ahhoz, hogy GUI-t lehessen csinálni.

5) Támogassa már az alapvető megjelenési dolgokat: a szám-formátumokat, tizedeseket, dátum-formátumot, és tudja a nyelvi fordításokat is, hiszen nem mindenki magyarul akarja használni a programomat. Nehogy már ezzel is nekem kelljen foglalkozni.

6) Támogassa már az alapvető ellenőrzéseket: tudja, hogy szám-mezőbe csak számot írunk bele, figyeljen a megadott minimum-maximum értékek betartására. Ezt úgy is nevezik, hogy validátorok.

7) Legyen már képes arra, hogy a változóim értékét megjeleníti, vagy éppen szerkeszti magától. Ne nekem kelljen a képernyőn lévő szövegmezőből kivenni a nevet, és berakni a name változóba, hanem ez magától történjen. Ezt úgy is nevezik, hogy data binding.

Pont ezeket a pontokat pont nem csinálja meg egyik csili-vili egérrel-összedobálós interaktív ablakszerkesztő sem. Sőt, amit csinálnak az sokszor inkább hátrány, mint segítség. Programozál már natív Java-ban Androidot? Brrr, hogy ott mit csinál az interaktív szerkesztő, az... na jó, erre most nem vagy kíváncsi.

Hát őőő, ezek tulajdonképpen mind-mind fontos dolgok. De Dulikám, izé, Dulifuli, ezeket ugye meg lehet csinálni Swing-ben is, nem? Tudom, egy kicsit dolgozni kell vele, mert épp ezek nincsenek készen, de mondjuk a Buttonok (tudod, mint az Ok gomb) egészen szépek! Tetszik, ahogy kinéznek!

Haggyá' má' ezzel! Nem megmondtam, hogy nem akarok Eiffel tornyot csinálni gyufaszálakból! Attól még, hogy lehetséges, nem éri meg. Azért mert mindenki így csinálja, attól még nem ez az egyetlen jó megoldás!

Gyufaszálakból... naná...

De Dulifuli, hogy mi a helyzet a modern eszközökkel? Mondjuk a JavaFX lehet, hogy jobb lenne?

Mondom, nem érted a lényeget! Ha azt kérdezed, hogy hogyan kell Javaban ablakot csinálni, a helyes válasz, hogy Swingben. Esetleg JavaFX-ben.

De a helyes kérdés az lenne, hogy milyen alapvető dolgokat szeretnénk készen megkapni, hogy könnyű legyen programozni? Ezért magyarázok, nem azért, hogy katicabogarakat dekoráljak a hét pontommal!

Egy ablakos üzleti program 1%-a maga az ablak és a vezérlők kinézete, 10% amit ténylegesen csinál a program (számol valamit, ilyesmi), és a maradék 89% a fenti 7 dolog kerülgetése.

Tudod mit? Megmutatom, mit tudnak a cuccok a hét pontból!

Azt hiszed, hogy szándékosan húztam le mindent? Lássunk egy példát. A Vaadin egy modern webes Java GUI framework, és tényleg nagyon sok mindent tud. Vannak validátorok is, tizedesek is - de csekély 10 sor, mire egyetlen beviteli mezőhöz beállítok mindent.

Szerintem ez elég macerás. Grrr! Ez mindig felbosszant! Hogy lehet egy egyszerű dolog ennyire bonyolult!

No és akkor, izé, szerinted, Dulifuli, mit kellene csinálni? Most találjunk ki valami még újabb frameworkot?

Ne már, senki más nem emlékszik, hogy az 1990-es években egy iskolás gyerek megírt egy teljes raktárkészlet-programot egy délután alatt?

Vajon hogy csinálta? Nem kellett zseninek lenni, akkortájt még ilyen ósdi nyelveket használtunk, mint a Clipper.

Nézd csak meg: egy sorban négy dolog: Label kirakása, szövegmező kirakása, a szövegmező összekötése egy változóval (sőt, rögtön az adatbázissal, ez a Customer->Name), és még validálja is, hogy nem lehet a mezőt üresen hagyni. Egyetlen sorban. 1990-ben.

@  1, 0 SAY "Nev:"  GET Customer->Name VALID !empty(Customer->Name)
READ

Nem értem, akkor azt mondod, hogy programozzunk Clipperben? Fura lenne, úgy gondolom, meg különben is eddig a Javaról volt szó...

Azt mondom, hogy legyünk már észnél. Nem értem meg, hogy mi az oka, hogy egyszerű dolgokat bonyolultan kell programozni. Hiszen ha több, mint 25 évvel ezelőtt az akkori ósdi gépeken lehetett egyszerűen programozni, akkor oly sok évvel később a mai modern ember miért gáncsolja el saját magát...

Utálom, utálom utálom. Egyesek képesek többoldalas példaprogramokat közzétenni a neten, hogy megmutassák, milyen "egyszerű" megcsinálni valamit, ami 25 éve 2 sornyi program volt. Hát semmit sem tanulunk a saját hibáinkból?

Jól van, kérlek nyugodj meg. Most már értem, hogy mi a gond, és tényleg jó lenne, ha nem kellene heteken át tanulmányozni a doksikat, hogy csináljak egy egyszerű ablakot, ami ésszerűen működik.

De nagyon kár, hogy nincs olyan framework, ami mind a 7 pontot jól csinálná! Mert ha lenne, akkor nem is kellene az egész Swinget megtanulni. Ráadásul sokkal könnyebben, és gyorsabban sokkal jobb progikat tudnék csinálni...

Akkor miért nem csinálsz egyet magadnak?

Erre én:

Hogy a csudába???