[java] Lijntje tekenen

[Gamebuster]

Ik ben maar eens begonnen met java en ik probeer iets simpels: een lijntje tekenen.

De tutorials laten het zo makkelijk lijken, maar al die voorbeelden werken met applets, terwijl ik gewoon een normale venster wil. Met een beetje rond copy-pasten van codes en logisch nadenken kwam ik aan de volgende code:

Java:

import java.awt.*;
import java.awt.geom.*;
import java.awt.image.*;
import javax.swing.*;

public class helloWorld {
    public static void main(String[] args) {
        javax.swing.SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                JFrame frame = new JFrame("helloWorld :D");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                
                BufferedImage buffer = new BufferedImage(480,272,BufferedImage.TYPE_INT_RGB);
                Graphics2D gfx = buffer.createGraphics();
                
                gfx.setPaint(Color.black);
                gfx.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
                gfx.draw(new Line2D.Double(10,20,30,40));
                
                frame.setSize(480,272);
                frame.pack();
                frame.setVisible(true);
            }
        });
    }
}

Na het "compileren" van de code krijg ik geen errors. Bij het uitvoeren van het "programma" krijg ik netjes een venster van 480x272 pixels groot met de titel "helloWorld :D". Ik krijg echter geen lijntje.

De gehele code heb ik gepakt uit voorbeelden gepakt met normale venstertjes, echter, lijn 13 tot 18 (BufferedImage buffer tot gfx.draw) heb ik uit voorbeelden met een java applet. Waarschijnlijk moet ik het gfx-object invoegen in het frame-object zodat het weergegeven wordt, maar ik zou niet weten hoe.

Hoe dan ook; ik wil een lijntje in mijn venster hebben met zo min mogelijk (zo simpel mogelijke) code. Wie kan me helpen?

[ Voor 0% gewijzigd door Gamebuster op 15-12-2009 15:32 . Reden: hoogte en breedte van ImageBuffer aangepast naar grootte van venster. ]

[Mischa_NL]

Gamebuster schreef op dinsdag 15 december 2009 @ 15:30:
Ik ben maar eens begonnen met java en ik probeer iets simpels: een lijntje tekenen.

De tutorials laten het zo makkelijk lijken, maar al die voorbeelden werken met applets, terwijl ik gewoon een normale venster wil. Met een beetje rond copy-pasten van codes en logisch nadenken kwam ik aan de volgende code:

Java:

import java.awt.*;
import java.awt.geom.*;
import java.awt.image.*;
import javax.swing.*;

public class helloWorld {
    public static void main(String[] args) {
        javax.swing.SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                JFrame frame = new JFrame("helloWorld :D");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                
                BufferedImage buffer = new BufferedImage(480,272,BufferedImage.TYPE_INT_RGB);
                Graphics2D gfx = buffer.createGraphics();
                
                gfx.setPaint(Color.black);
                gfx.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
                gfx.draw(new Line2D.Double(10,20,30,40));
                
                frame.setSize(480,272);
                frame.pack();
                frame.setVisible(true);
            }
        });
    }
}

Na het "compileren" van de code krijg ik geen errors. Bij het uitvoeren van het "programma" krijg ik netjes een venster van 480x272 pixels groot met de titel "helloWorld :D". Ik krijg echter geen lijntje.

De gehele code heb ik gepakt uit voorbeelden gepakt met normale venstertjes, echter, lijn 13 tot 18 (BufferedImage buffer tot gfx.draw) heb ik uit voorbeelden met een java applet. Waarschijnlijk moet ik het gfx-object invoegen in het frame-object zodat het weergegeven wordt, maar ik zou niet weten hoe.

Hoe dan ook; ik wil een lijntje in mijn venster hebben met zo min mogelijk (zo simpel mogelijke) code. Wie kan me helpen?

Ik moet zeggen dat ik nog nooit in java gewerkt heb maar ik denk dat het iets te maken heeft met het feit dat je: een buffer maakt en dmv gfx op dit buffer gaat tekenen...
Ik denk dat dit allemaal perfect werkt.
Alleen ik zie niet waar jij buffer tekent in je form?
Het lijkt me dat je buffer toch in dat form moet verwerken?

[CodeCaster]

Je hebt een leeg frame en een buffer waar je wat in hebt getekend, maar nu moet je de inhoud van die buffer nog tekenen op het frame

@Mischa_NL

[ Voor 47% gewijzigd door CodeCaster op 15-12-2009 15:47 . Reden: Toch maar geen (verkeerde) code voorzeggen :+ ]

[Gamebuster]

Java:

import java.awt.*;
import java.awt.geom.*;
import java.awt.image.*;
import javax.swing.*;

public class helloWorld {
    public static void main(String[] args) {
        javax.swing.SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                JFrame frame = new JFrame("helloWorld :D");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                
                BufferedImage buffer = new BufferedImage(480,272,BufferedImage.TYPE_INT_RGB);
                Graphics2D gfx = buffer.createGraphics();
                
                gfx.setPaint(Color.black);
                gfx.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
                gfx.draw(new Line2D.Double(10,20,30,40));
                
                frame.paint(gfx);
                
                frame.setSize(480,272);
                frame.pack();
                frame.setVisible(true);
            }
        });
    }
}

Nog steeds hetzelfde lege venster maar geen errors.

[ Voor 2% gewijzigd door Gamebuster op 15-12-2009 15:50 . Reden: kleine aanpassing ]

[CodeCaster]

Dat komt omdat je nu in de run()-methode bezig bent met tekenen: op dat moment is het panel nog helemaal niet zichtbaar. Je moet even kijken naar de diverse (re)paint/update-methoden die de Java-componenten hanteren.

[Kwistnix]

De beste optie is om zelf een sub klasse te maken van een JPanel, daarvan de paintComponent() te overriden, daar je custom paint logica in te defineren en een instantie van dat JPanel toe te voegen aan het content pane van het JFrame. Er zijn een aantal dingen waar je rekening mee moet houden en die staan mooi uitgelegd en opgesomd in deze tutorial.

[Gamebuster]

Java:

import java.awt.*;
import java.awt.geom.*;
import java.awt.image.*;
import javax.swing.*;

public class helloWorld {
    public static void main(String[] args) throws InterruptedException {
        //javax.swing.SwingUtilities.invokeLater(new Runnable() {
        //  public void run() {
                JFrame frame = new JFrame("helloWorld :D");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                
                BufferedImage buffer = new BufferedImage(480,272,BufferedImage.TYPE_INT_RGB);
                Graphics2D gfx = buffer.createGraphics();
                
                gfx.setPaint(Color.black);
                gfx.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
                gfx.draw(new Line2D.Double(10,20,30,40));
                
                frame.paint(gfx);
                
                frame.setSize(480,272);
                frame.pack();
                frame.setVisible(true);
                
                while(true) {
                    Thread.sleep(60);
                    frame.repaint();
                }
        //  }
        //});
    }
}

Eindeloze loop met repaints; Nog steeds geen errors of bijwerkingen. Zou ik zo brutaal mogen zijn om te vragen of iemand gewoon mijn code werkend kan maken met wat kleine aanpassingen? Na uren tutorials doorzoeken wil ik wel eens wat werkend zien zodat ik wat verder kan proberen.

[CodeCaster]

Ik heb hier geen Java-IDE of -compiler, en daarnaast is dat ook niet de bedoeling van GoT, maar ik kan je wel een hint geven: repaint moet je alleen aanroepen als er iets veranderd is, en de code voor het tekenen zelf moet je in paintComponent(Graphics g) zetten.

[boe2]

dude, dat laatste codefragment is gewoon goor.
1) Je tekent alles naar een buffer, maar met die buffer zelf doe je niets
2) Ik heb niet veel ervaring met Java, maar normaalgezien heeft het zelf een paint method die je moet overriden ipv een eindeloze loop in je main te knallen (die volgens mij je app volledig bevriest ook)
3) Leer eerst eens de basics van het programmeren

[Gamebuster]

Boeboe schreef op dinsdag 15 december 2009 @ 17:10:
dude, dat laatste codefragment is gewoon goor.
1) Je tekent alles naar een buffer, maar met die buffer zelf doe je niets
2) Ik heb niet veel ervaring met Java, maar normaalgezien heeft het zelf een paint method die je moet overriden ipv een eindeloze loop in je main te knallen (die volgens mij je app volledig bevriest ook)
3) Leer eerst eens de basics van het programmeren

1) met de buffer doe ik niets nee, wat ik ermee moet doen is dus juist de vraag.
2) bevriezen doet-ie niet door sleep en de eindeloze loop was als test; iemand vertelde dat het niet werkte omdat het venster nog niet weergegeven werd, dus ik voegde een eindeloze loop toe met een timeout zodat-ie misschien na zoveel milliseconden wel klaar was om erin te tekenen. niet dus. Heb ik waarschijnlijk verkeerd begrepen
3) een lijntje tekenen is niet basic genoeg? Het is niet zo dat ik hierna ga proberen om meteen animaties met dat lijntje te maken en daarna p2p connecties ga proberen te programmeren voor een simpele multiplayergame. programmeren kan ik wel, het is alleen de overstap van php/html naar java.

CodeCaster schreef op dinsdag 15 december 2009 @ 17:00:
Ik heb hier geen Java-IDE of -compiler, en daarnaast is dat ook niet de bedoeling van GoT, maar ik kan je wel een hint geven: repaint moet je alleen aanroepen als er iets veranderd is, en de code voor het tekenen zelf moet je in paintComponent(Graphics g) zetten.

de functie paintComponent(java.awt.Graphics) vind ik alleen bij JPanel instances, en daar is-ie protected. De functie zelf bestaat niet en JFrame, BufferedImage en Graphics2D kennen deze methode niet; althans, ik kreeg zulke errors.

code:

^Ctoby@toby-desktop:~/Desktop/java/helloWorld$ javac helloWorld.java;java helloWldl
helloWorld.java:20: cannot find symbol
symbol  : method paintComponent(java.awt.Graphics2D)
location: class javax.swing.JFrame
                frame.paintComponent(gfx);
                     ^
1 error
toby@toby-desktop:~/Desktop/java/helloWorld$ javac helloWorld.java;java helloWorld
helloWorld.java:22: paintComponent(java.awt.Graphics) has protected access in javax.swing.JComponent
                pane.paintComponent(gfx);
                    ^
1 error

[ Voor 3% gewijzigd door Gamebuster op 15-12-2009 17:46 ]

[Woy]

Nee maar je kan natuurlijk ook iets verder kijken dan je neus lang is.

Een JFrame heeft wel een protected void Paint(Graphics g). Als je nou eens een class maakt die erft van een JFrame en daar de methode Paint overide.

In die methode kun je dan g gebruiken om direct op het Form te tekenen.

Netter is het om een component te maken ( bijvoorbeeld afgeleid van JPanel ), en die gewoon toe te voegen aan de child components van je JFrame.

Maar ik zou voorstellen om eens een goed Java boek te kopen of een paar goede tutorials over de GUI toolkit die je gebruikt door te lezen ( Swing in dit geval )

[terje7601]

In 2 stappen:
1) maak een subklasse van JComponent waarin je de "paintComponent(Graphics g)" methode override met je eigen painting code
2) voeg een instance van die subklasse toe aan je JFrame m.b.v. de methode "setContentPane(Container contentPane)"

Overigens lijkt Swing me nu niet meteen het meest voor de hand liggende onderwerp om mee te beginnen.

[Remus]

Gamebuster schreef op dinsdag 15 december 2009 @ 15:30:
Ik ben maar eens begonnen met java en ik probeer iets simpels: een lijntje tekenen.

De tutorials laten het zo makkelijk lijken, maar al die voorbeelden werken met applets, terwijl ik gewoon een normale venster wil. Met een beetje rond copy-pasten van codes en logisch nadenken kwam ik aan de volgende code:

Voorbeelden met applets (iig JApplet) zijn bijna altijd (bijna) één op één over te zetten naar een JFrame applicatie.

[Gamebuster]

Woy schreef op dinsdag 15 december 2009 @ 18:50:
Nee maar je kan natuurlijk ook iets verder kijken dan je neus lang is.

Een JFrame heeft wel een protected void Paint(Graphics g). Als je nou eens een class maakt die erft van een JFrame en daar de methode Paint overide.

In die methode kun je dan g gebruiken om direct op het Form te tekenen.

Netter is het om een component te maken ( bijvoorbeeld afgeleid van JPanel ), en die gewoon toe te voegen aan de child components van je JFrame.

Maar ik zou voorstellen om eens een goed Java boek te kopen of een paar goede tutorials over de GUI toolkit die je gebruikt door te lezen ( Swing in dit geval )

Ik heb een boek (the java tutorial, fourth edition) en ik lees de swing onderdelen, alleen de voorbeelden zijn meestal veel te ingewikkeld (veel te veel code) of zijn applets. Ik heb dus op basis van die tutorials en voorbeelden deze code geschreven, die dus niet werkt.

"Netter is het om een component te maken ( bijvoorbeeld afgeleid van JPanel ), en die gewoon toe te voegen aan de child components van je JFrame."
wat is een component?

Remus schreef op dinsdag 15 december 2009 @ 22:02:
[...]

Voorbeelden met applets (iig JApplet) zijn bijna altijd (bijna) één op één over te zetten naar een JFrame applicatie.

Dat is dus precies hetgene wat ik hier geprobeerd heb

terje7601 schreef op dinsdag 15 december 2009 @ 19:10:
In 2 stappen:
1) maak een subklasse van JComponent waarin je de "paintComponent(Graphics g)" methode override met je eigen painting code
2) voeg een instance van die subklasse toe aan je JFrame m.b.v. de methode "setContentPane(Container contentPane)"

Overigens lijkt Swing me nu niet meteen het meest voor de hand liggende onderwerp om mee te beginnen.

Ah, dat klinkt wel alsof het werkt, maar is er geen andere (simpeler, korter, netter) manier?
Ik zal het eens proberen.

Overigens is swing niet het 1e wat ik doe. Ik heb al wat andere scriptjes geschreven en hetgene waar ik juist naar uitkijk met java is visuele programma's. De commandline apps zijn niet zo leuk te maken.

[ Voor 4% gewijzigd door Gamebuster op 15-12-2009 22:32 ]

[qanar]

terje7601 schreef op dinsdag 15 december 2009 @ 19:10:
In 2 stappen:
1) maak een subklasse van JComponent waarin je de "paintComponent(Graphics g)" methode override met je eigen painting code
2) voeg een instance van die subklasse toe aan je JFrame m.b.v. de methode "setContentPane(Container contentPane)"

Overigens lijkt Swing me nu niet meteen het meest voor de hand liggende onderwerp om mee te beginnen.

idd correcte manier.

[pedorus]

Dit is gewoon niet zo'n makkelijk voorbeeld om mee te beginnen. Als je snel een oplossing wil zien: [google=java show bufferedimage]...

(Als het echt om 1 lijntje gaat moet je je afvragen of je wel iets gebufferd wil hebben, of dat je het beter gewoon direct kan tekenen.)

Maar normaal gesproken ga je niet zomaar iets tekenen, maar gebruik je reeds bestaande components, zoals knoppen enzo.

[terje7601]

Gamebuster schreef op dinsdag 15 december 2009 @ 22:29:
Ik heb een boek (the java tutorial, fourth edition) en ik lees de swing onderdelen, alleen de voorbeelden zijn meestal veel te ingewikkeld (veel te veel code) of zijn applets. Ik heb dus op basis van die tutorials en voorbeelden deze code geschreven, die dus niet werkt.

Lees je het boek ook in volgorde? In veel boeken is dat namelijk wel de bedoeling

Hieronder een werkend voorbeeld van hetgeen je probeerde:

Java:

import java.awt.*;
import javax.swing.*;

public class HelloWorld {

    public static void main(String[] args) {
        SwingUtilities.invokeLater(new Runnable() {
            
            public void run() {
                JFrame frame = new JFrame("Hello World");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                
                frame.setContentPane(new JComponent() {
                    
                    {   setPreferredSize(new Dimension(480, 272));      }

                    protected void paintComponent(Graphics g) {
                        super.paintComponent(g);
                        g.setColor(Color.RED);
                        g.drawLine(10, 20, 30, 40);
                    }
                    
                });
                
                frame.pack();
                frame.setVisible(true);
            }

        });
    } 

}

[Gamebuster]

Ik moet zeggen:
ik ben onder de indruk. Ik probeer 1 lijntje te tekenen en ik kreeg mijn lijntje. Helaas had het wel een kleine bijwerking:


"screenshot" van de kleine bijwerking. Klik op een foto om deze vergroot weer te geven. Op de achtergrond is dit topic zichtbaar. Daaroverheen zit het venster van de linux teksteditor die ik gebruik, welke nu volledig zwart is geworden. Het java venstertje zelf is gesloten in de hoop dat probleem daarna weg zou gaan, maar het sluiten van het venster had geen enkel effect.


"screenshot" na het uitvoeren van "/etc/init.d/gdm restart", wat het probleem niet verhielp. De verschoven achtergrond is veroorzaakt als poging tot het openen van Firefox.

Dit was serieus de 1e keer dat ik linux moest herstarten omdat er niet meer mee te werken was. Nooit eerder heb ik linux hoeven herstarten; op z'n ergst moest ik /etc/init.d/gdm restart uitvoeren, maar dat had geen enkele bijwerking deze keer!

Ik ben ook niet nieuw met dit verschijnsel; ik ken deze leuke vierkantjes. Ik had ze eerder gekregen toen ik aan het kloten was met CUDA in C/C++, maar wat was in windows vista. Geinig om te zien dat het dus ook in linux kan. Vreemd dat een simpele java app die schade kan aanrichten...

De code:

Java:

// GameOfLife.java
import ui.window;

public class GameOfLife {
    public static void main(String[] args) {
        window uiWindow = new window("Game of Life");
    }
}

// ui/window.java
package ui;

import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
import javax.swing.*; 

public class window extends JFrame {
    public window(){this("Untitled Window",320,240);}
    public window(String title){this(title,320,240);}
    public window(int width, int height){this("Untitled Window",width,height);}
    public window(String title, int width, int height) {
        setTitle(title);
        setDefaultCloseOperation(EXIT_ON_CLOSE);
        
        setSize(width,height);
        
        Dimension size = getToolkit().getScreenSize();
        setLocation(size.width/2-getWidth()/2,size.height/2-getHeight()/2);
        
        pack();
        setVisible(true);
    }
    
    public void paint(Graphics g) {
        Graphics2D g2 = (Graphics2D) g;
        g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
            
        g2.setPaint(Color.black);
        g2.draw(new Line2D.Double(10,20,30,40));
    }
}

Vreemd hoor... zeker omdat mijn lijntje wel weergegeven was voordat er allemaal rare vlakken en stippen overheen kwamen.

[ Voor 11% gewijzigd door Gamebuster op 16-12-2009 00:05 ]

[terje7601]

Hier levert je code alvast geen problemen op (= Windows Vista) & het zou me ook verbazen dat Java tot zo 'n dingen in staat is (zeker met deze code).

PS: heb je het hoofdstuk over java naming conventions al gelezen?
class-names beginnen met een hoofdletter
& i.p.v. Color.black gebruik je beter Color.BLACK

[_Noldy]

Ik ben het er niet mee eens dat het de java app is geweest. Je gebruikt nou ook niet zulke ingewikkelde code. Wel een hoop gedonder om een simpel lijntje te tekenen. Ik ben ook niet vies van code kopieren + plakken (en eventueel aanpassen) maar het is goed te zorgen dat je precies weet wat er gebeurd in die code.

Een goede java tutorial is wel handig.

Wat ik zelf zo slap vind aasna paintComponent is dit:
protected void paintComponent(Graphics g) {
super.paintComponent(g);

Waarom zou ik die op de super aan willen roepen als ik hem overschrijf? Deze logica ontgaat me geheel.

[Gamebuster]

terje7601 schreef op woensdag 16 december 2009 @ 00:31:
Hier levert je code alvast geen problemen op (= Windows Vista) & het zou me ook verbazen dat Java tot zo 'n dingen in staat is (zeker met deze code).

PS: heb je het hoofdstuk over java naming conventions al gelezen?
class-names beginnen met een hoofdletter
& i.p.v. Color.black gebruik je beter Color.BLACK

"class-names beginnen met een hoofdletter"
Owke, bedankt voor de info. Ik heb het wel gelezen, maar dat ben ik waarschijnlijk vergeten.

"het zou me ook verbazen dat Java tot zo 'n dingen in staat is"
Ik ben erachter gekomen dat het weghalen van het anti-aliasing lijntje het probleem verhelpt. Ik denk dat dit een specifiek probleem was van mijn systeem icm. anti-aliasing.

Ik heb gelukkig nu mijn streepje en ben druk aan het coden

_Noldy schreef op woensdag 16 december 2009 @ 00:40:
Ik ben het er niet mee eens dat het de java app is geweest. Je gebruikt nou ook niet zulke ingewikkelde code. Wel een hoop gedonder om een simpel lijntje te tekenen. Ik ben ook niet vies van code kopieren + plakken (en eventueel aanpassen) maar het is goed te zorgen dat je precies weet wat er gebeurd in die code.

Een goede java tutorial is wel handig.

Wat ik zelf zo slap vind aasna paintComponent is dit:
protected void paintComponent(Graphics g) {
super.paintComponent(g);

Waarom zou ik die op de super aan willen roepen als ik hem overschrijf? Deze logica ontgaat me geheel.

"Ik ben het er niet mee eens dat het de java app is geweest."
Het begon zodra ik de app startte... maar anti-aliasing weghalen hielp. Zal wel een specifiek probleem zijn van mijn systeem.

"Ik ben ook niet vies van code kopieren + plakken (en eventueel aanpassen) maar het is goed te zorgen dat je precies weet wat er gebeurd in die code."
Klopt, maar ik leer liever een taal door eerst te copy/pasten en daarna te kijken hoe het nou precies werkt. Ik heb ook een paar keer met directX en CUDA gekloot, dus weet wel ongeveer hoe die buffers etc werken, maar mijn kennis is ver van compleet.

Ik ben nu druk bezig vierkantjes te maken om "John Conway's Game of Life" na te maken. De code hoeft niet perfect of netjes te zijn en efficientie is ook nog niet mijn doel; Ik wil het gewoon laten werken. Later zal ik me focussen op efficientie en netheid. Zo heb ik tot nu toe al mijn talen en omgevingen leren kennen. (voornamelijk php en javascript)

[ Voor 49% gewijzigd door Gamebuster op 16-12-2009 00:58 ]

[_Noldy]

Gamebuster schreef op woensdag 16 december 2009 @ 00:53:

"Ik ben ook niet vies van code kopieren + plakken (en eventueel aanpassen) maar het is goed te zorgen dat je precies weet wat er gebeurd in die code."
Klopt, maar ik leer liever een taal door eerst te copy/pasten en daarna te kijken hoe het nou precies werkt. Ik heb ook een paar keer met directX en CUDA gekloot, dus weet wel ongeveer hoe die buffers etc werken, maar mijn kennis is ver van compleet.

Ik ben nu druk bezig vierkantjes te maken om "John Conway's Game of Life" na te maken. De code hoeft niet perfect of netjes te zijn en efficientie is ook nog niet mijn doel; Ik wil het gewoon laten werken. Later zal ik me focussen op efficientie en netheid. Zo heb ik tot nu toe al mijn talen en omgevingen leren kennen. (voornamelijk php en javascript)

Ik hoop niet dat je je aangevallen voelde, is niet mijn bedoeling geweest. Het is niet verkeerd om wat kant en klare code te hebben om mee te spelen. In jouw geval zou ik ook kiezen voor een leeromgeving zoals Blue-J. Hierin is het OO goed weergegeven en hoef je niet te beginnen met GUI s te bouwen.

Javadoc, documentatie is alleen niet te onderschatten. Natuurlijk hoef je geen boek te schrijven maar je moet er vooral zelf ook weer wat duidelijkheid uit weten te halen. En vaak is het ook zo dat wanneer je het nu niet doet, je het nooit zal gaan doen.

Php heeft wat basis in Java zelfs javascript (eerste 4 letters en wat notaties) maar het is een geheel andere orde van programmeren. Er wordt wel eens gesproken over heiligschennis wanneer sommige mensen php programmeren noemen omdat het scripten zou moeten zijn.

Maar een goede tutorial en investeren in het OO denken is echt de moeite waard! Boeken kopen vaak ook nog wel, maar dat kan mijn voorkeur zijn.

[terje7601]

@Gamebuster: heb je het probleem nog steeds als je als eerste lijn in je "void paint(Graphics g)"-methode het volgende zet (& dus met de rendering hint ingeschakeld):

Java:

super.paint(g);

?

@_Noldy

_Noldy schreef op woensdag 16 december 2009 @ 00:40:Wat ik zelf zo slap vind aasna paintComponent is dit:
protected void paintComponent(Graphics g) {
super.paintComponent(g);

Waarom zou ik die op de super aan willen roepen als ik hem overschrijf? Deze logica ontgaat me geheel.

In dit geval: omdat in de Javadoc voor deze methode in JComponent het volgende terug te vinden is:

If you override this in a subclass [...]. Further, if you do not invoker super's implementation you must honor the opaque property, that is if this component is opaque, you must completely fill in the background in a non-opaque color. If you do not honor the opaque property you will likely see visual artifacts.

Dus ofwel zorg je dat je dit allemaal zelf doet bij het overriden, ofwel gebruik je "super".

Het is trouwens helemaal niet onlogisch om super te gebruiken bij het overriden van een methode. Geregeld kun je bij het overriden logica gebruiken die je al geïmplementeerd hebt in je parent class. Bij het subclassen van standaard Java classes, is het soms ook aangeraden/noodzakelijk om super aan te roepen zodat je ervan kunt uitgaan dat het default behavior correct is.

[Verwijderd]

Boeboe schreef op dinsdag 15 december 2009 @ 17:10:
dude, dat laatste codefragment is gewoon goor.
3) Leer eerst eens de basics van het programmeren

of je kraakt weer iemand onnodig af. Hier heeft die persoon toch niks aan we zitten hier om elkaar te helpen

[Gamebuster]

terje7601 schreef op woensdag 16 december 2009 @ 11:10:
@Gamebuster: heb je het probleem nog steeds als je als eerste lijn in je "void paint(Graphics g)"-methode het volgende zet (& dus met de rendering hint ingeschakeld):

Java:

super.paint(g);

?

@_Noldy


[...]


In dit geval: omdat in de Javadoc voor deze methode in JComponent het volgende terug te vinden is:

[...]

Dus ofwel zorg je dat je dit allemaal zelf doet bij het overriden, ofwel gebruik je "super".

Het is trouwens helemaal niet onlogisch om super te gebruiken bij het overriden van een methode. Geregeld kun je bij het overriden logica gebruiken die je al geïmplementeerd hebt in je parent class. Bij het subclassen van standaard Java classes, is het soms ook aangeraden/noodzakelijk om super aan te roepen zodat je ervan kunt uitgaan dat het default behavior correct is.

Java:

    public void paint(Graphics g) {
        super.paint(g);
        Graphics2D g2 = (Graphics2D) g;
        
        g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); 
            
        g2.setPaint(Color.BLACK);
        g2.setStroke(new BasicStroke(1));
        g2.draw(new Rectangle2D.Double(32,32,16,16));
    }

Nog steeds hetzelfde probleem.

(haalt regel 5 weer weg)

Overigens, wanneer ik een vierkantje neerzet op offset 32, 32 wordt die offset gemeten vanaf de linker-bovenhoek van het venster en niet vanaf de inhoud van het venster:



Nou is dat niet zo'n ramp, maar het is ook niet echt helemaal de bedoeling. Waarschijnlijk moet ik nu iets van een layer aanmaken in dat venster en daarin gaan tekenen. Ik ga 'ff verder proberen; ik kan me herinneren dat voorbeelden al hun "tekeningen" in een "pane" hadden en niet in het frame.

-edit-
Ah, het is me gelukt

Java:

public class GameWindow extends JPanel {
    protected UiWindow window;
    
    public GameWindow() {
        window = new UiWindow("Game of Life");
        window.getContentPane().add(this);
    }
    
    public void paint(Graphics g) {
        super.paint(g);
        Graphics2D g2 = (Graphics2D) g; 
            
        g2.setPaint(Color.BLACK);
        g2.setStroke(new BasicStroke(1));
        g2.draw(new Rectangle2D.Double(32,32,16,16));
    }
}

[ Voor 10% gewijzigd door Gamebuster op 17-12-2009 01:06 ]

[terje7601]

Gamebuster schreef op donderdag 17 december 2009 @ 00:49:
Nog steeds hetzelfde probleem.

(haalt regel 5 weer weg)

Welke versie van Ubuntu (meende ik te zien in je screenshot?) & welke update van Java 1.6 gebruik je aub? Ik zou graag eens proberen om het probleem hier te reproduceren.

Gamebuster schreef op donderdag 17 december 2009 @ 00:49:
Overigens, wanneer ik een vierkantje neerzet op offset 32, 32 wordt die offset gemeten vanaf de linker-bovenhoek van het venster en niet vanaf de inhoud van het venster:

[afbeelding]

Nou is dat niet zo'n ramp, maar het is ook niet echt helemaal de bedoeling. Waarschijnlijk moet ik nu iets van een layer aanmaken in dat venster en daarin gaan tekenen. Ik ga 'ff verder proberen; ik kan me herinneren dat voorbeelden al hun "tekeningen" in een "pane" hadden en niet in het frame.

-edit-
Ah, het is me gelukt

Java:

public class GameWindow extends JPanel {
    protected UiWindow window;
    
    public GameWindow() {
        window = new UiWindow("Game of Life");
        window.getContentPane().add(this);
    }
    
    public void paint(Graphics g) {
        super.paint(g);
        Graphics2D g2 = (Graphics2D) g; 
            
        g2.setPaint(Color.BLACK);
        g2.setStroke(new BasicStroke(1));
        g2.draw(new Rectangle2D.Double(32,32,16,16));
    }
}

Zie hier voor wat meer uitleg over panes.

Nog een paar dingen i.v.m. je code:
*als je "custom painting" wil doen, override je "paintComponent" & niet "paint" (& doe je dus ook super.paintComponent(g); dan)
*het zou m.i. logischer zijn om je "UiWindow" uit die klasse te houden. Stom voorbeeld misschien, maar als je bijv. 4 games of life simultaan wil spelen, dan heb je 4 GameWindow's & maar 1 UiWindow nodig.
*vaak kan het ook handig zijn om een "setPreferredSize()" (& eventueel setMin.. & setMax..) te doen, om te garanderen dat je component standaard genoeg ruimte heeft
*in dit geval lijkt het me voldoende om van JComponent te extenden, ipv JPanel

[Gamebuster]

terje7601 schreef op donderdag 17 december 2009 @ 13:55:
[...]

Welke versie van Ubuntu (meende ik te zien in je screenshot?) & welke update van Java 1.6 gebruik je aub? Ik zou graag eens proberen om het probleem hier te reproduceren.


[...]


Zie hier voor wat meer uitleg over panes.

Nog een paar dingen i.v.m. je code:
*als je "custom painting" wil doen, override je "paintComponent" & niet "paint" (& doe je dus ook super.paintComponent(g); dan)
*het zou m.i. logischer zijn om je "UiWindow" uit die klasse te houden. Stom voorbeeld misschien, maar als je bijv. 4 games of life simultaan wil spelen, dan heb je 4 GameWindow's & maar 1 UiWindow nodig.
*vaak kan het ook handig zijn om een "setPreferredSize()" (& eventueel setMin.. & setMax..) te doen, om te garanderen dat je component standaard genoeg ruimte heeft
*in dit geval lijkt het me voldoende om van JComponent te extenden, ipv JPanel

Ik heb hier inderdaad linux ubuntu, namelijk versie 9.04 (x86). Verder heb ik een 9800GT 1024mb videokaart van asus met Nvidia driver 180.44

Als ik nog 'ff verder kijk kom ik X-server-version 11.0 tegen en Server Vendor vErsion is gelijk aan 1.6.0.

Verder herhaal ik even dat dit niet de 1e keer is dat ik dit verschijnsel zie. Echter, hiervoor had ik het met een kleine CUDA applicatie met een dual GTX280 en een compleet andere computer. Bovendien was dat in windows 7. Daarom vermoed ik dat dit iets dieps is in de nvidia drivers of hardware en dat dit niet een java probleem is. (Heb de applicatie helaas niet meer)

Verder is mijn OOP structuur inderdaad niet helemaal 100%. Ik heb alle classes al verwijderd en alles in 1 file gepropt om me 'ff te focussen om gewoon een klein simpel spelletje te schrijven en niet een ruim OOP project.

Ondertussen heb ik de volgende code:

Java:

import java.lang.Math;
import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
import javax.swing.*;

public class GameOfLife extends JPanel implements MouseListener, MouseMotionListener {
    protected final int GRID_SIZE = 4096;
    protected final int DEFAULT_WINDOW_WIDTH = 550;
    protected final int DEFAULT_WINDOW_HEIGHT = 340;
    protected final int DEFAULT_GRID_PIXEL_SIZE = 16;
    
    protected JFrame window;
    
    protected boolean[][] grid;
    
    protected int gridPixelSize;//Grid-size in pixels.
    protected int gridOffsetX;//Absolute X-offset in grids.
    protected int gridOffsetY;//Absolute Y-offset in grids.
    protected int pixelOffsetX;//Relative X-offset in pixels.
    protected int pixelOffsetY;//Relative Y-offset in pixels.
    
    public static void main(String[] args) {
        GameOfLife game = new GameOfLife();
    }
    
    public GameOfLife() {
        try {       
            resetView();
            
            window = new JFrame();
        
            window.setTitle("Game of Life");
            window.setDefaultCloseOperation(window.EXIT_ON_CLOSE);
        
            window.pack();
            window.setSize(DEFAULT_WINDOW_WIDTH,DEFAULT_WINDOW_HEIGHT);
        
            Dimension size = window.getToolkit().getScreenSize();
            window.setLocation(size.width/2-DEFAULT_WINDOW_WIDTH/2,size.height/2-DEFAULT_WINDOW_HEIGHT/2);
            
            window.setVisible(true);
        
            window.getContentPane().add(this);
        
            setBackground(Color.WHITE);
        
            addMouseMotionListener(this);
            addMouseListener(this);
            
            grid = new boolean[GRID_SIZE][GRID_SIZE];
            for(int x=0;x<GRID_SIZE;x++) {
                for(int y=0;y<GRID_SIZE;y++) {
                    grid[x][y]=false;
                }
            }
        } catch(OutOfMemoryError e) {
            fatalError("Out of Memory");
        }
    }
    
    public void resetView() {
        gridPixelSize = DEFAULT_GRID_PIXEL_SIZE;
        setGridViewPosition(GRID_SIZE/2,GRID_SIZE/2);
    }
    
    public void setGridViewPosition(int x, int y) {
        gridOffsetX = x;
        pixelOffsetX = 0;
        
        gridOffsetY = y;
        pixelOffsetY = 0;
    }
    
    public void movePixelViewPosition(int x, int y) {
        pixelOffsetX += x;
        gridOffsetX += Math.floor(pixelOffsetX/gridPixelSize);
        pixelOffsetX = pixelOffsetX%gridPixelSize;
        
        pixelOffsetY += y;
        gridOffsetY += Math.floor(gridOffsetY/gridPixelSize);
        pixelOffsetY = pixelOffsetY%gridPixelSize;
    }
    
    public void fatalError(String message) {
            JFrame errorWindow = new JFrame();
            
            errorWindow.setTitle("Fatal error");
            
            JPanel panel = new JPanel();
            panel.add(new JLabel(message));
            panel.setBorder(BorderFactory.createEmptyBorder(10,40,10,40));
            
            errorWindow.getContentPane().add(panel);
            
            errorWindow.setDefaultCloseOperation(window.EXIT_ON_CLOSE);
            
            errorWindow.pack();
            
            Dimension size = window.getToolkit().getScreenSize();
            errorWindow.setLocation(size.width/2-errorWindow.getWidth()/2,size.height/2-errorWindow.getHeight()/2);
            
            errorWindow.setVisible(true);
    }
    
    public void paint(Graphics g) {
        //super.paint(g); //don't know if this one is needed...
        Graphics2D g2 = (Graphics2D) g;
        
        g2.setPaint(Color.GRAY);
        g2.setStroke(new BasicStroke(1));
        
        int viewablePixelSizeX = window.getWidth();
        int viewableGridSizeX = (viewablePixelSizeX/gridPixelSize)+1;
        int absoluteGridOffsetX = gridOffsetX-(viewableGridSizeX/2);
        int relativePixelOffsetX = -gridPixelSize+((absoluteGridOffsetX*gridPixelSize+viewablePixelSizeX/2)+pixelOffsetX)%gridPixelSize;
        
        int viewablePixelSizeY = window.getHeight();
        int viewableGridSizeY = (viewablePixelSizeY/gridPixelSize)+1;
        int absoluteGridOffsetY = gridOffsetY-(viewableGridSizeY/2);
        int relativePixelOffsetY = -gridPixelSize+((absoluteGridOffsetY*gridPixelSize+viewablePixelSizeY/2)+pixelOffsetY)%gridPixelSize;
        
        for(int x=0;x<viewablePixelSizeX;x++) {
            for(int y=0;y<viewableGridSizeY;y++) {
                g2.draw(new Rectangle2D.Double((x*gridPixelSize)+relativePixelOffsetX,(y*gridPixelSize)+relativePixelOffsetY,gridPixelSize,gridPixelSize));
            }
        }
        
    }
    
    public void mouseClicked(MouseEvent e){}
    public void mouseEntered(MouseEvent e){}
    public void mouseExited(MouseEvent e){}
    public void mousePressed(MouseEvent e){}
    public void mouseReleased(MouseEvent e){}
    public void mouseMoved(MouseEvent e){}
    public void mouseDragged(MouseEvent e){}
}

Ik zal eens kijken naar paintComponent ipv paint, want de offset is nog steeds vanuit het venster en niet vanuit de binnenkant van het venster.

Dit is trouwens het spel wat ik namaak:
Wikipedia: Game of Life

bestaande java versie:
http://www.bitstorm.org/gameoflife/

Voor de verslaafden van mega-versies van het spel is er een native linux versie verkrijgbaar via "applications add & remove" door gewoon "game of life" in te tikken, waarbij je het spel "golly" zal vinden. Golly is ook geport naar mac en windows.

Meer over Golly:
http://golly.sourceforge.net/

[NMe]

Gamebuster schreef op vrijdag 18 december 2009 @ 11:55:
Dit is trouwens het spel wat ik namaak:
Wikipedia: Game of Life

Ik denk niet dat er veel developers zijn die Conway's Game of Life niet kennen, 't is een veel gebruikte praktijkoefening op scholen. Ikzelf heb het ooit voor de lol nog geschreven:

http://crew.tweakers.net/NMe/life.exe

[Matis]

Hehe, dat was mijn eerste *AI* programma dat ik schreef

[boe2]

Heb me er zelf ook nog mee beziggehouden, niet zo lang geleden zelfs


Source code

En ik heb ook nog mijn Silverlight versie die ik nog steeds eens volledig moet afwerken. Game of Life blijft een leuk projectje om een taal wat te verkennen

[ Voor 13% gewijzigd door boe2 op 18-12-2009 13:47 ]

[Gamebuster]

NMe schreef op vrijdag 18 december 2009 @ 12:00:
[...]

Ik denk niet dat er veel developers zijn die Conway's Game of Life niet kennen, 't is een veel gebruikte praktijkoefening op scholen. Ikzelf heb het ooit voor de lol nog geschreven:
[afbeelding]
http://crew.tweakers.net/NMe/life.exe

Ligt het aan mij (wine?) of loopt die simulatie nogal langzaam
Kan-ie niet sneller? (zelfs op "snel" gaat ie nogal langzaam)

[NMe]

Gamebuster schreef op vrijdag 18 december 2009 @ 12:29:
[...]

Ligt het aan mij (wine?) of loopt die simulatie nogal langzaam
Kan-ie niet sneller? (zelfs op "snel" gaat ie nogal langzaam)

't Is niet echt geweldig geschreven dus nee, meer dan 4 frames/sec ga je niet halen. 't Ging me ook meer om de oefening en de mogelijkheid tot het aanpassen van de regels.

[Verwijderd]

NMe schreef op vrijdag 18 december 2009 @ 12:00:
[...]

Ik denk niet dat er veel developers zijn die Conway's Game of Life niet kennen, 't is een veel gebruikte praktijkoefening op scholen. Ikzelf heb het ooit voor de lol nog geschreven:
[afbeelding]
http://crew.tweakers.net/NMe/life.exe

Welk control heb je voor het grid gebruikt als ik vragen mag?

[NMe]

Een kleurplaat. (Ik weet niet meer hoe die dingen waarop je mag tekenen binnen de VCL heten. )

[Caelorum]

NMe schreef op vrijdag 18 december 2009 @ 12:00:
[...]

Ik denk niet dat er veel developers zijn die Conway's Game of Life niet kennen, 't is een veel gebruikte praktijkoefening op scholen. Ikzelf heb het ooit voor de lol nog geschreven:

Heb ik wat lessen gemist dan?
Ziet er wel interesant genoeg uit om eens een keertje op een saai avondje te maken...

[Gamebuster]

Code:
(te lang om te posten)
http://levensweg.net/host/3ED4819D/GameOfLife.txt

Dit is het uiteindelijk geworden

Vast een verschrikkelijke code die vast veel opbouwende kritiek kan gebruiken. Maar he, het is mijn 1e "echte" applicatie in java waarbij ik als doel had om te leren een custom UI te maken met custom mouse- en keyboard event handlers: oftewel: een simpel spelletje.

Ik ga zeker meer dingetjes proberen te maken. Ik ga ook zeker 'ff spelen met de netwerk functies en kijken of ik wat 3D dingetjes kan maken.

[roy-t]

Het eerste dat me opvalt is die out of memory error die je catched. Je kunt erg grote 2D boolean arrays maken op een standaard machine (4GB werkgeheugen tegenwoordig) ik denk zelfs dat boolean[Int.Max][Int.Max] nog makkelijk binnen 4GB past, dus dat is een beetje overdreven vind ik.

Verder even snel door heen gescrolled en ik zie zo geen major wtfs. Maar misschien zitten er nog wel wat gekke dingen in als je er rustig over heen leest.

[Nick_S]

Ook even snel erover heen gekeken, maar het vangen van een NPE is ook standaard een WTF.

[Woy]

roy-t schreef op maandag 28 december 2009 @ 00:39:
Het eerste dat me opvalt is die out of memory error die je catched. Je kunt erg grote 2D boolean arrays maken op een standaard machine (4GB werkgeheugen tegenwoordig) ik denk zelfs dat boolean[Int.Max][Int.Max] nog makkelijk binnen 4GB past, dus dat is een beetje overdreven vind ik.

Maar het is natuurlijk maar de vraag of je ook daadwerkelijk 4 GB tot je beschikking hebt voor je java programma. Standaard staat het beschikbare geheugen volgens mij veel lager ingesteld.

Nou weet ik ook niet zeker of je nog wel goed kunt recoveren van een OutOfMemmoryError, maar daar kunnen de Java experts vast wat meer over zeggen.

[Gamebuster]

roy-t schreef op maandag 28 december 2009 @ 00:39:
Het eerste dat me opvalt is die out of memory error die je catched. Je kunt erg grote 2D boolean arrays maken op een standaard machine (4GB werkgeheugen tegenwoordig) ik denk zelfs dat boolean[Int.Max][Int.Max] nog makkelijk binnen 4GB past, dus dat is een beetje overdreven vind ik.

Verder even snel door heen gescrolled en ik zie zo geen major wtfs. Maar misschien zitten er nog wel wat gekke dingen in als je er rustig over heen leest.

een boolean kost 1bit of 1byte. Int.Max is 2.147.483.647. Als ik een normale array van zoveel booleans wil opslaan kost dat me al 2Gb of 2GB. In dit geval is het echter een multidimensionale array: (2^31-1)^2 dus. Dat kost 4.611x10^18 Bytes of Bitjes. Dat past Nooooit in 4GB.

Zodra je een gridsize van 2048 neemt zit je al op 4Gbit of 4Gbyte; zo vreemd is die error dus niet. Druk maar een paar keer op + en je hebt 'm al.

[Creepy]

2048 * 2048 Bytes (laten we even het ongunstigste geval nemen, dus niet 1 bit voor 1 boolean maar 1 byte) = 4194304 Bytes = 4096 KiloBytes = 4 MegaBytes. Dat past makkelijk in je geheugen lijkt me
Een 2D array van MAXINT * MAXINT word wel erg lastig ja.

[ Voor 16% gewijzigd door Creepy op 29-12-2009 01:13 ]

[Gamebuster]

Creepy schreef op dinsdag 29 december 2009 @ 01:05:
2048 * 2048 Bytes (laten we even het ongunstigste geval nemen, dus niet 1 bit voor 1 boolean maar 1 byte) = 4194304 Bytes = 4096 KiloBytes = 4 MegaBytes. Dat past makkelijk in je geheugen lijkt me
Een 2D array van MAXINT * MAXINT word wel erg lastig ja.

Och, wat ben ik toch weer wakker

je hebt gelijk