[Alg] GUI refactoring

[Alarmnummer]

Ik ben mijn gui wat aan het opschonen en vraag me af of er ook specifieke refactoring technieken zijn voor gui`s. Ik doel hierbij niet zozeer op de technieken die je zowel op de gui kan loslaten als op de niet gui code, maar echt op specifieke gui refactor technieken, zoals bv replace fat constructor by build methods, of replace dialogs by method.

Ik heb zitten bladeren op het internet, maar ben nog niets tegengekomen.

[ Voor 11% gewijzigd door Alarmnummer op 14-10-2003 15:27 ]

[yrew]

Heb je ze al wel gevonden die niet specifiek voor GUI's zijn? En kun je je GUI-code, ervan uitgaande dat je echt alleen UI-code in je GUI hebt staan (en geen bussinesslogic) nog wel verkleinen zonder dat de werking anders wordt. Ik kan me voorstellen dat je je eventafhandeling in minder regels kan schrijven, maar de gui opzich zelf lijkt me lastig. Kun je hier een voorbeeld van geven?

[Alarmnummer]

yrew schreef op 14 oktober 2003 @ 15:33:
Heb je ze al wel gevonden die niet specifiek voor GUI's zijn?

http://www.refactoring.com

En kun je je GUI-code, ervan uitgaande dat je echt alleen UI-code in je GUI hebt staan (en geen bussinesslogic) nog wel verkleinen zonder dat de werking anders wordt. Ik kan me voorstellen dat je je eventafhandeling in minder regels kan schrijven, maar de gui opzich zelf lijkt me lastig. Kun je hier een voorbeeld van geven?

Het hoef niet altijd zo te zijn dat je minder code krijgt.

Ik gebruik intussen een aantal technieken waarmee ik mijn gui makkelijker vind om mee te werken, bv replace fat constructor by build methods:

voor refactoring.

code:

public class BlaatPanel extends JPanel{

    public BlaatPanel(){
        super(new BorderLayout());
          
        JPanel buttonPanel = new JPanel(new FlowLayout());
        JButton okButton = new JButton(new OkAction());          
        panel.add(okButton);
        JButton cancelButton = new JButton(new CancelAction());
        panel.add(cancelButton);
          
        add(buttonPanel.BorderLayout.NORTH);
          
        JTextArea textArea= new JTextArea(); 
        JScrollPane scrollPane = new JScrollPane(textArea);
          
        add(scrollPane,BorderLayout.CENTER);
      }
}

Na refactoring.

code:

public class BlaatPanel extends JPanel{
    public BlaatPanel(){
        build();
    }
    
    private void build(){
        setLayout(new BorderLayout());
        
        add(buildTextComponent(),BorderLayout.CENTER);
        add(buildButtonComponent(),BorderLayout.SOUTH);
    }
    
    private JComponent buildTextComponent(){
        JTextArea textArea= new JTextArea(); 
        return new JScrollPane(textArea);    
    }
    
    private JComponent buildButtonComponent(){
        JButton okButton = new JButton(new OkAction());                    
        JButton cancelButton = new JButton(new CancelAction());
          
        JPanel panel = new JPanel(new FlowLayout());          
        panel.add(cancelButton);
        panel.add(okButton);
          
        return panel;
    }
}

[ Voor 8% gewijzigd door Alarmnummer op 14-10-2003 16:14 ]

[yrew]

Interessant, de link moet trouwens zijn...www.refactoring.com

Ik kom hier nog op terug....hoop ik. Voorlopig ben ik met GUI's helaas niet zo ver dat ik ze helemaal zelf maak. Over het algemeen gebruik ik nog de gui-designers die bij de IDE's zitten. Dusssz je hebt mij iig al geholpen alleen is het voor jou helaas één richtingsverkeer...tot nu toe.

[Alarmnummer]

yrew schreef op 14 October 2003 @ 16:10:
Interessant, de link moet trouwens zijn...www.refactoring.com

*schaamt zich diep* <- ziet er trouwens uit als een geile smilie

Ik kom hier nog op terug....hoop ik. Voorlopig ben ik met GUI's helaas niet zo ver dat ik ze helemaal zelf maak. Over het algemeen gebruik ik nog de gui-designers die bij de IDE's zitten. Dusssz je hebt mij iig al geholpen alleen is het voor jou helaas één richtingsverkeer...tot nu toe.

Gui`s laat ik al lang niet meer generen, maar schrijf ik tegenwoordig weer helemaal met de hand. Waar ik trouwens wel naar wil kijken is JBeaver. Hiermee bouw je je gui op mbv XML (dus ook extern configureerbaar), maar dmv queries sluit je je code erop aan. Hierbij heb je dus een strakke scheiding tussen logica en opbouw.

[bigben04]

Alarmnummer schreef op 14 October 2003 @ 16:16:
Gui`s laat ik al lang niet meer generen, maar schrijf ik tegenwoordig weer helemaal met de hand.

Ik inmiddels ook, mede dankzij je tip mbt JGoodies . De code wordt er inderdaad een stuk overzichtelijker van als je de GUI met de hand schrijft, mede omdat je het (zoals in je refactoring-techniek van hierboven) in hapklare brokken kan opdelen i.p.v. dat je een massa gegenereerde code hebt.

[ Voor 2% gewijzigd door bigben04 op 14-10-2003 16:45 . Reden: zinsbouw ]

[yrew]

Alarmnummer schreef op 14 oktober 2003 @ 16:16:
[...]

*schaamt zich diep* <- ziet er trouwens uit als een geile smilie


[...]

Gui`s laat ik al lang niet meer generen, maar schrijf ik tegenwoordig weer helemaal met de hand. Waar ik trouwens wel naar wil kijken is JBeaver

geile smilies ----- beavers ahum goed bezig

. Hiermee bouw je je gui op mbv XML (dus ook extern configureerbaar), maar dmv queries sluit je je code erop aan. Hierbij heb je dus een strakke scheiding tussen logica en opbouw.

hmmm, thanx ook eens naar kijken....Ik heb me al heel vaak voorgenomen om niet meer met gui designers te werken...maar tot nu toe scheelt het gewoon erg veel tijd...

mbt gui refactoring zou je het aanmaken van al je objecten kunnen verzorgen door 1 grote JComponentFabriek welke specifieke JComponentMachines aanroept...Ik weet niet of ik nu in de goede richting denk, maar je hebt al je componenten op die manier maar 1 keer gedefinieerd en je kunt heel snel een nieuw scherm samenstellen op die manier.

[Alarmnummer]

yrew schreef op 14 oktober 2003 @ 16:43:
hmmm, thanx ook eens naar kijken....Ik heb me al heel vaak voorgenomen om niet meer met gui designers te werken...maar tot nu toe scheelt het gewoon erg veel tijd...

Ik vind ze alleen handig voor prototypen (dus als een veredeld tekenpakket).

mbt gui refactoring zou je het aanmaken van al je objecten kunnen verzorgen door 1 grote JComponentFabriek welke specifieke JComponentMachines aanroept...Ik weet niet of ik nu in de goede richting denk, maar je hebt al je componenten op die manier maar 1 keer gedefinieerd en je kunt heel snel een nieuw scherm samenstellen op die manier.

Als je veel dingen hebt die erg op elkaar lijken, zou je het zo kunnen doen. Gui`s zijn bij mij helaas altijd wel maatwerk want het is iedere keer iets anders. Ik ben een tijd geleden ook op het idee gekomen om slimmere models en views te maken die automatisch al naar elkaar luisteren, ik vond alleen het uiteindelijk behoorlijk lomp aanvoelen. Volgens mij ga je dit ook krijgen met zo`n factory.

[edit]
Maar een handje vol van dit soort methodes kunnen wel handig zijn. Ze werken dan als een soort Facade/ Factor over je widgets: ze maken het aanroepen/werken ermee een stuk makkelijker.

voorbeeld:
JSplitPane buildBorderlessSplitPane(JComponent left, JComponent right, boolean vertical){...}

[ Voor 17% gewijzigd door Alarmnummer op 14-10-2003 17:00 ]

[yrew]

Ik heb net ff zitten kijken naar JBeaver, maar ook dit is een veredeld tekenpakket. hiermee worden wel de settings opgeslagen in XML, maar dit is helaas geen api. Althans niet te verkijgen zonder het pakket(à veel euro's).

Helaas zie ik zelf ook dat er veel maatwerk bij mijn guis komt kijken. Echter verwijt ik dit mezelf. Als ik globaal kijk zijn veel componenten namelijk wel gelijk en verschillen ze slechts in werking door code die er achter staat. Ik denk dan ook dat mijn gui's met een beter ontwerp veel globaler in opzet kunnen worden zonder dat daarbij de speciefieke eigenschappen van maatwerk verloren gaan.

[demonite]

Ik vind die tekenpakketten toch best handig. Als de convertor maar werkende code produceert maakt het mij niet uit hoe de gegenereerde code eruit ziet.

Waarom zou ik je gui code willen refactoren ? zodat het leesbaarder is ? waarom zou je het uberhaupt willen lezen ?

Ik werk nou al een tijdje met QT, maar die QtDesigner maakt toch best flexibele GUI's.. en die kun je altijd nog uitbreiden mbv eigen code. Die code staat dan weer in een ander bestand zodat je geen last hebt van die gegenereerde code.

Ik moet er niet aan denken dat ik al die layout rommel met de hand zou moeten maken..
Maarja, dit is misschien hetzelfde als met HTML, notepad vs dreamweaver oid

[Martin Sturm]

Het lijkt mij ook een beetje onzinnig je GUi te gaan refactoren. Zeker als je nu niet bepaalde belangrijke wijzigingen voor ogen hebt (als je dat wel hebt, heb ik niets getypt). Als je ontwerp goed is, is je Gui code toch al gescheiden van de business-logic en andere niet-presentatie-code, dus is het niet nodig om dat super netjes te krijgen indien het verder goed werkt.

[jelmervos]

Ik merk vaak dat de GUI (net als de DB) mee refactort met de business-logic.

Als ik bijvoorbeeld de classes voor het genereren van lijsten refactor (adressen, telefoonnummers, enz), dan past hier ook een standaard GUI onderdeel bij. Dit realiseren wij door gebruik te maken van Frames (Delphi). Daarmee bouw je 1 keer een herhalend GUI onderdeel en is het makkelijk te hergebruiken.

We halen sowieso alle dubbeling naar boven, of het nou om een classe gaat of om een UI onderdeel.

[ Voor 13% gewijzigd door jelmervos op 27-10-2003 20:01 ]

[Alarmnummer]

Martin Sturm schreef op 27 October 2003 @ 19:28:
Het lijkt mij ook een beetje onzinnig je GUi te gaan refactoren. Zeker als je nu niet bepaalde belangrijke wijzigingen voor ogen hebt (als je dat wel hebt, heb ik niets getypt). Als je ontwerp goed is, is je Gui code toch al gescheiden van de business-logic en andere niet-presentatie-code, dus is het niet nodig om dat super netjes te krijgen indien het verder goed werkt.

Hmmz... tja.. dan zou je net zo goed helemaal niet meer kunnen refactoren. Ik denk niet dat dat voor de onderhoud van een systeem zo verstandig is.

Imho zou er geen verschil moeten zijn tussen gui en non gui code en gui code moet op dezelfde manier behandeld worden.

Ik ben intussen aan het experimenteren met een andere wijze om gui op te zetten. Ik ging altijd extenden van panels om daar functionaliteit in te plaatsen, en intussen heb ik dit door build methodes ipv een fat constructor al erg veel plezieriger gemaakt om mee te werken. Maar verder vond ik het ontwerpen van gui`s nogal irritant omdat je dus geen interfaces hebt voor components ed (Java) en dat je dus vast zit aan zo`n akelige class.

Ik schrijf nu mijn gui`s zoals ik normale objecten ook schrijf. Ieder 'gui' object (die dus nergens meer van extend) heeft een build methode waarmee hij zijn grafisch object opbouwt en deze kan je later weer ophalen met

code:

JComponent getGUI(){..}

als volgt bv:

code:

JPanel panel = new JPanel(new BorderLayout());
panel.add(authorEditor.getGUI(),BorderLayout.CENTER);

Op deze manier kan ik mijn gui objecten 100 % ontwerpen zoals ik het wil hebben (ik hou namelijk wel van een goed ontworpen gui) en daarnaast kan ik eventueel het opbouwen van de gui overlaten aan bv een externe configuratie met XML.

[ Voor 3% gewijzigd door Alarmnummer op 28-10-2003 09:33 ]

[Alarmnummer]

Delphi schreef op 27 October 2003 @ 20:00:
Ik merk vaak dat de GUI (net als de DB) mee refactort met de business-logic.

Dat is ook heel logisch. Maar waar ik aan zit te denken is niet zozeer een verandering in requirements, maar echt het refactoren (verbeteren van design) van code.

ps:
ik schrijf alle gui`s intussen weer fijn met de hand. Ik heb vroeger een tijdje met JBuilder gewerkt, maar de code die gegenereerd wordt voldoet niet aan mijn eisen voor goeie code. Ik heb hierdoor dus de vrijheid om de gui`s volledig op mijn manier op te zetten en ik zit dus niet meer vast aan de beperkingen van een of andere gui tool.

Ik ben nu trouwens iets aan het rondkijken om de gui met XML te laten opbouwen. Hierdoor kan ik de opbouw buiten de applicatie houden en kan het ook eenvoudiger worden aangepakt. Het opbouwen van gui dmv XML past uitstekend in mijn nieuwe ontwerp strategie van gui`s, namelijk de gui`s binnen een normaal object houden en niet meer zoveel te extenden.

[ Voor 51% gewijzigd door Alarmnummer op 28-10-2003 09:37 ]

[alienfruit]

Eeew. GUI vanuit XML leuk voor de virussen Kun we mooi jou GUI pakken een programma maken die dezelfe GUI heeft maar volgens er wat anders met de input doet...

[Alarmnummer]

alienfruit schreef op 28 oktober 2003 @ 23:14:
Eeew. GUI vanuit XML leuk voor de virussen Kun we mooi jou GUI pakken een programma maken die dezelfe GUI heeft maar volgens er wat anders met de input doet...

Dat is leuk voor website zoals www.rabo-bank.nl, www.rabobank.org en www.rabobank.ru Maar voor een applicatie zie ik het gevaar er niet van in.

Extern gui`s aanmaken is voor mij handiger omdat mensen die meer met de opmaak van systemen bezig zijn hieraan kunnen sleutelen terwijl ik de stoere (en leukere) dingen blijf doen.

[alienfruit]

Zie niet in waarom dit alleen voor web-sites zou gelden Als je gebruikt maakt van xml-bestanden dat is het in principe gewoon ook gemakkelijk te gebruiken in andere programma's. Zelf ben ik dan ook niet blij met verschillende ide"en die Longhorn komen. Zoals het XML gebeuren in het GUI gebeuren, als ik het goed begrepen heb worden xml messages gestuurt. Vraag me af of dat bevordelijk is, ach longhorn pdc editie draait ook al niet op 800mhz pc.

[Alarmnummer]

alienfruit schreef op 30 oktober 2003 @ 11:59:
Zie niet in waarom dit alleen voor web-sites zou gelden Als je gebruikt maakt van xml-bestanden dat is het in principe gewoon ook gemakkelijk te gebruiken in andere programma's.

Het is idd makkelijk, maar aan de andere kant kan je een gui ook nabouwen. Het is misschien iets meer werk maar niet onoverkomelijk. Ik zie dus niet in waarom XML dan ineens zoveel onveiliger zou zijn.

Zelf ben ik dan ook niet blij met verschillende ide"en die Longhorn komen. Zoals het XML gebeuren in het GUI gebeuren, als ik het goed begrepen heb worden xml messages gestuurt. Vraag me af of dat bevordelijk is, ach longhorn pdc editie draait ook al niet op 800mhz pc.

Hmm tja. Ik denk voor mij dat al die nieuwe windows versies niet zo interessant zijn. Ik gebruik nauwelijk iets van de functionaliteit wat er allemaal aanwezig is. Ik blijf voorlopig fijn bij XP (omdat je een betere taakbalk hebt) anders zou ik net zo goed 2k draaien.

hmmz... behoorlijk offtopic