Come si fa ?

[spillo491]

Ciao a tutti devo realizzare un programma ma non so da che parte incominciare:

devo costruire una griglia con assi numerati e dare la possibilità all'utente di indicare dei punti su di essa. In particolare:
1 click --> pallino su griglia
2 click --> croce su griglia
In base alle regioni della griglia in cui si hanno pallini e croci il programma deve elaborare i dati e dare un uscita secondo una funzione conosciuta

Mi sapete dare qualche idea ?

Io so programmare un po in java e so usare Matlab

[spillo491]

Nessuno mi sa dare un'idea su come procedere ?

[PGI-Bis]

E' difficile darti un'idea senza offrire anche la soluzione completa dell'esercizio.

Potresti iniziare creando un oggetto Griglia che conservi una matrice di oggetti Simbolo (PALLINO o CROCE).

Dai alla griglia la capacità di modificare il valore di una delle sue celle.

Crea un ascoltatore di eventi prodotti dalla griglia.

Quando la griglia subisce la modifica di una delle sue celle, dopo aver immagazzinato la modifica, le fai sparare un evento in direzione di tutti gli ascoltatori registrati.

Crea un pannello che proietti sullo schermo i dati della griglia. Dota questo pannello di un ascoltatore di eventi che sia connesso alla griglia.

Quando questo ascoltatore riceverà un evento dalla griglia, proietterà sullo schermo le modifiche intervenute (un pallino o una crocetta nella posizione stabilita per la cella modificata).

Quando giunge il momento di calcolare la funzione, prendi la griglia e la passi ad un oggetto, chiamiamolo Processore, che analizza i valori delle celle e, in base ad una logica da te stabilita, produca la Funzione.

E' più facile a farsi che a dirsi.

[spillo491]

Grazie mille PGI, a me non sembra poi cosi facile perchè sono alle basi della programmazione però ci provo.
Quindi posso fare tutto in java ?

[PGI-Bis]

Yesssss. Tu prova. Se incontri difficoltà chiedi.

[spillo491]

Ma in pratica devo realizzare un APPLET ?

[andbin]

Originariamente inviato da spillo491

Ma in pratica devo realizzare un APPLET ?

Se deve stare dentro una pagina HTML, sì. Altrimenti crei una normale applicazione. Puoi stabilirlo tu, se non ti sono state date precise specifiche.

[PGI-Bis]

Non lo so ma sospetto di no.

Un Applet Java è un programma eseguito all'interno di un web browser distribuito attraverso una pagina html.

Eventualmente è dotato di un'interfaccia grafica utente che può apparire come una finestra o come un elemento dinamico della pagina html.

Io penso che tu voglia o deva realizzare un programma stand-alone: autonomo, dove l'autonomia vale "non serve il web browser".

Dunque, niente Applet.

[lovaz]

Ci sarebbe appletviewer.

[PGI-Bis]

appletviewer è uno strumento di sviluppo incluso nel JDK che non appartiene alla piattaforma Java standard.

[spillo491]

Si avete ragione, io non voglio un programma che sia eseguito da un web browser ma un programma stand alone.
Quindi questo codice che avevo trovato in rete non posso riutilizzarlo ?

import java.awt.*;

public class DrawAndClick extends java.applet.Applet {

//

public boolean mouseDown(Event e, int x, int y) {

// il metodo getGraphics() della classe BufferedImage
// restituisce un oggetto Graphics
Graphics g = getGraphics();
g.fillRect(x-2,y-2,4,4);

return true;
}

public void paint(Graphics g) {

int i, j;

// Disegno una griglia con assi che vanno da 0 a 300
// Ogni quadratino ha lato 30

for(i=0; i<=300; i=i+30) {
// disegna le linee verticali della griglia
//public void drawLine(int x1, int y1, int x2, int y2)
g.drawLine(0,i,300,i);
// disegna le linee orizzontali della griglia
g.drawLine(i,0,i,300);
}
}

}

[lovaz]

Originariamente inviato da PGI-Bis

appletviewer è uno strumento di sviluppo incluso nel JDK che non appartiene alla piattaforma Java standard.

Non sapevo...

Comunque puoi facilmente convertire quell'applet in applicazione,
vedi ad esempio qui:
http://www.rgagnon.com/javadetails/java-0305.html
Aggiungi una J davanti a Panel, Frame, Button...

[PGI-Bis]

Occhio che quel codice non solo e non tanto è vecchio (Java 1.1) ma fa un uso non corretto della pipeline di rendering di Java.

Se mi dai 5 minuti butto giù un esempio di griglia. So che, essendo un esercizio scolastico, potrebbe sembrare non corretto ma se non v'hanno spiegato nulla di interfacce grafiche utente, disegno e Swing tanto vale prendere l'esercizio come primo passo in quest'universo. Comunque scrivo solo una traccia, un indizio.

[spillo491]

Ok grazie

[lovaz]

Effettivamente fa un po' schifo...
colpa della mia pigrizia, ho messo il primo link di google

[spillo491]

Ma credo si riferisca al mio codice

[PGI-Bis]

M'è venuto non breve ma piuttosto esplicito.

Con pallini e crocette.

Codice PHP:

/** Rappresentazione di un tipo di dato "Simbolico" */
public enum Simbolo {
    VUOTO,
    PALLINO,
    CROCE
} 


mettiamo su una griglia:

Codice PHP:

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

/** Rappresentazione di una griglia di simboli. */
public class Grid {
    /* Numero di righe della griglia */
    private final int numeroDiRighe;

    /* Numero di colonne della griglia */
    private final int numeroDiColonne;

    /* Contenuto della griglia */
    private final Simbolo[] celle;

    /** Inizializza una griglia */
    public Grid(int numeroDiRighe, int numeroDiColonne) {
        this.numeroDiRighe = numeroDiRighe;
        this.numeroDiColonne = numeroDiColonne;
        celle = new Simbolo[numeroDiRighe * numeroDiColonne];
        inizializzaCelle();
    }

    /** Restituisce il numero di colonne che compongono questa griglia */
    public int getNumeroDiColonne() {
        return numeroDiColonne;
    }

    /** Restituisce il numero di righe che compongono questa griglia */
    public int getNumeroDiRighe() {
        return numeroDiRighe;
    }

    /** Restituisce il simbolo contenuto in una cella della griglia */
    public Simbolo getSimboloCella(int indiceRiga, int indiceColonna) {
        return celle[subscript(indiceRiga, indiceColonna)];
    }

    /** Imposta il simbolo contenuto in una cella della griglia */
    public void setSimboloCella(Simbolo simbolo, int indiceRiga, int indiceColonna) {
        celle[subscript(indiceRiga, indiceColonna)] = simbolo;
    }

    /** Restituisce il numero di celle della griglia */
    public int getNumeroDiCelle() {
        return celle.length;
    }

    /** Restituisce la cella di indice subscript */
    public Simbolo getSimboloCella(int indiceSubscript) {
        return celle[indiceSubscript];
    }

    /* Calcola l'indice di accesso agli elementi di una matrice linearizzata */
    public int subscript(int indiceRiga, int indiceColonna) {
        return indiceRiga * numeroDiColonne + indiceColonna;
    }

    /* inverso di subscript */
    public void superScript(int indiceCella, java.awt.Point result) {
        result.x = indiceCella % numeroDiColonne;
        result.y = indiceCella / numeroDiColonne;
    }

    /* Crea una matrice linearizzata e assegna ad ogni elemento un
    valore iniziale */
    private void inizializzaCelle() {
        java.util.Arrays.fill(celle, Simbolo.VUOTO);
    }
} 


Questa è una mezza vista. Ti risparmio l'architettura MVC anche se la griglia sarebbe un ottimo esempio di modello. DrawAndClick è un componente Swing (un componente è un pezzo di interfaccia grafica utente che si inserisce in un contenitore che va dentro ad una finestra) a cui è affidata, in cotruzione, una griglia (Grid) e che si occupa sia di disegnarla che di modificarla in seguito alla pressione di un pulsante del mouse.

Codice PHP:

import javax.swing.*;
import java.awt.*;
import java.awt.geom.*; //contiene le definizioni delle figure geometriche vettoriali Java2D
import java.awt.event.*;
import java.awt.image.*;

/** Vista (e controllo) su una griglia */
public class DrawAndClick extends JComponent {
    /* Un buffer fuori schermo per pre-calcolare il disegno della
    griglia. Assume un valore in initializeBackBuffer(), dopo addNotify(). */
    private BufferedImage backBuffer;

    /* La pipeline di rendering del buffer fuori schermo. Assume un
    valore in initializeBackBuffer(), dopo addNotify(). */
    private Graphics2D backBufferGraphics;

    /* Rappresentazione vettoriale del "pallino" */
    private Shape figuraPallino;

    /* Rappresentazione vettoriale della "croce" */
    private Shape figuraCroce;

    /* Distanza tra il bordo della cella e le figure dei simboli */
    private int margineInterno = 4;

    /* Altezza di una cella */
    private int larghezzaCella = 10;

    /* Larghezza di una cella */
    private int altezzaCella = 10;

    /* Griglia di celle */
    private Grid griglia;

    /** Inizializza un DrawAndClick che da una veste grafica alla griglia in
    argomento. */
    public DrawAndClick(Grid griglia) {
        this.griglia = griglia;
        setDimensioniCella(larghezzaCella, altezzaCella);

        /* Queste linee connettono a questo JComponent (DrawAndClick extends JComponent...)
        un ascoltatore di eventi prodotti dal mouse. Il meccanismo di gestione degli eventi
        di AWT/Swing farà in modo che quando l'utente prema uno dei pulsanti del mouse
        nell'area del desktop occupata da questo JComponent sia invocato il metodo "mouseClicked"
        del MouseListener qui associato */
        addMouseListener(new MouseAdapter() {
            public void mouseClicked(MouseEvent e) {
                gestisciClickDelMouse(e.getPoint());
            }
        });
    }

    /** Invocato autonomamente quando la radice dell'albero di proiezione
    a cui questo componente appartiene diviene visualizzabile. A noi interessa
    perchè a partire da quel momento getGraphicsConfiguration(), usato per
    inizializzare il buffer backBuffer, restituisce un valore diverso da null */
    public void addNotify() {
        super.addNotify();
        initializeBackBuffer();
    }

    /** Invocato in costruzione */
    public void setDimensioniCella(int larghezza, int altezza) {
        /* GeneralPath è un percorso vettoriale */
        GeneralPath croce = new GeneralPath();
        croce.moveTo(0, 0);
        croce.lineTo(larghezza - margineInterno, altezza - margineInterno);
        croce.moveTo(larghezza - margineInterno, 0);
        croce.lineTo(0, altezza - margineInterno);
        figuraCroce = croce;

        /* Un ellisse per il pallino */
        Ellipse2D.Float pallino = new Ellipse2D.Float(
            0, 0, larghezza - margineInterno, altezza - margineInterno);
        figuraPallino = pallino;

        larghezzaCella = larghezza;
        altezzaCella = altezza;

        /* Attribuisce a questo componente Swing una dimensione di cui un
        LayoutManager può tenere conto */
        Dimension dimensioniPannello = new Dimension(
            larghezzaCella * griglia.getNumeroDiColonne() + 1,
            altezzaCella * griglia.getNumeroDiRighe() + 1);
        setMinimumSize(dimensioniPannello);
        setMaximumSize(dimensioniPannello);
        setPreferredSize(dimensioniPannello);
    }

    /** Ridefinisce l'omonimo metodo di JComponent che disegna questo
    componente Swing */
    protected void paintComponent(Graphics graphics) {
        super.paintComponent(graphics);
        graphics.drawImage(backBuffer, 0, 0, null);
    }

    /* Questo metodo è invocato autonomamente quando si clicca il
    mouse su questo componente. */
    private void gestisciClickDelMouse(Point puntoDiPressione) {
        /* Dal punto sullo schermo passa alla cella */
        int indiceRiga = puntoDiPressione.y / altezzaCella;
        int indiceColonna = puntoDiPressione.x / larghezzaCella;
        if(indiceRiga < griglia.getNumeroDiRighe() && indiceColonna < griglia.getNumeroDiColonne()) {
            cambiaSimboloCella(indiceRiga, indiceColonna);
        }
    }

    /** Cambia il simbolo della cella di indice numeroDiRiga, numeroDiColonna */
    private void cambiaSimboloCella(int indiceRiga, int indiceColonna) {
        Simbolo simboloAttuale = griglia.getSimboloCella(indiceRiga, indiceColonna);
        Simbolo nuovoSimbolo;
        if(simboloAttuale == Simbolo.VUOTO) {
            nuovoSimbolo = Simbolo.PALLINO;
        } else if(simboloAttuale == Simbolo.PALLINO) {
            nuovoSimbolo = Simbolo.CROCE;
        } else if(simboloAttuale == Simbolo.CROCE) {
            nuovoSimbolo = Simbolo.VUOTO;
        } else {
            throw new RuntimeException("Hai dimenticato qualcosa? :D");
        }
        griglia.setSimboloCella(nuovoSimbolo, indiceRiga, indiceColonna);
        aggiornaProiezioneCella(indiceRiga, indiceColonna, backBufferGraphics);
        repaint();
    }

    /* Disegna lo sfondo del contenitore */
    private void disegnaSfondo(Graphics2D pipeline) {
        pipeline.setPaint(Color.WHITE);
        pipeline.fillRect(0, 0, backBuffer.getWidth(), backBuffer.getHeight());
    }

    /* Disegna l'intera griglia */
    private void disegnaGriglia(Graphics2D pipeline) {
        Point coordinateCella = new Point();
        pipeline.setPaint(Color.BLACK);
        for(int indiceCella = 0; indiceCella < griglia.getNumeroDiCelle(); indiceCella++) {
            /* Tramite la griglia, ottiene la posizione (indiceDiRiga, indiceDiColonna)
            della cella di indice indiceCella nella matrice della griglia. Questa posizione
            è immagazzinata nel punto coordinateCella */
            griglia.superScript(indiceCella, coordinateCella);

            /* Disegna un rettangolo che rappresenta il bordo della cella */
            int posizioneXCella = coordinateCella.x * larghezzaCella;
            int posizioneYCella = coordinateCella.y * altezzaCella;
            pipeline.drawRect(posizioneXCella, posizioneYCella, larghezzaCella, altezzaCella);

            /* Disegna il simbolo contenuto nella cella*/
            int spostamentoXFigura = posizioneXCella + margineInterno / 2;
            int spostamentoYFigura = posizioneYCella + margineInterno / 2;
            Simbolo simboloCella = griglia.getSimboloCella(indiceCella);
            pipeline.translate(spostamentoXFigura, spostamentoYFigura);
            if(simboloCella == Simbolo.PALLINO) {
                pipeline.fill(figuraPallino);
            } else if(simboloCella == Simbolo.CROCE) {
                pipeline.draw(figuraCroce);
            }
            pipeline.translate(-spostamentoXFigura, -spostamentoYFigura);
        }
    }

    /* Aggiorna una cella della griglia */
    private void aggiornaProiezioneCella(int indiceRiga, int indiceColonna, Graphics2D pipeline) {
        int posizioneXCella = indiceColonna * larghezzaCella;
        int posizioneYCella = indiceRiga * altezzaCella;
        pipeline.setPaint(getBackground());
        pipeline.fillRect(posizioneXCella, posizioneYCella, larghezzaCella, altezzaCella);
        pipeline.setPaint(Color.BLACK);
        pipeline.drawRect(posizioneXCella, posizioneYCella, larghezzaCella, altezzaCella);
        Simbolo simboloCella = griglia.getSimboloCella(indiceRiga, indiceColonna);
        int spostamentoXFigura = posizioneXCella + margineInterno / 2;
        int spostamentoYFigura = posizioneYCella + margineInterno / 2;
        pipeline.translate(spostamentoXFigura, spostamentoYFigura);
        if(simboloCella == Simbolo.PALLINO) {
            pipeline.fill(figuraPallino);
        } else if(simboloCella == Simbolo.CROCE) {
            pipeline.draw(figuraCroce);
        }
        pipeline.translate(-spostamentoXFigura, -spostamentoYFigura);
    }

    /* Inizializza il buffer su cui è disegnata la rappresentazione della griglia */
    private void initializeBackBuffer() {
        backBuffer = getGraphicsConfiguration().createCompatibleImage(
            griglia.getNumeroDiRighe() * altezzaCella + 1,
            griglia.getNumeroDiColonne() * larghezzaCella + 1,
            Transparency.OPAQUE);
        backBufferGraphics = backBuffer.createGraphics();
        backBufferGraphics.setRenderingHint(
            RenderingHints.KEY_ANTIALIASING,
            RenderingHints.VALUE_ANTIALIAS_ON);
        disegnaSfondo(backBufferGraphics);
        disegnaGriglia(backBufferGraphics);
    }
} 


Resta il punto d'entrata dell'applicazione autonoma. Avrai sicuramente già visto una classe "Main", questa è una classe Main il cui metodo main apre sullo schermo una finestra. Questa finestra contiene un DrawAndClick a cui è affidato un Grid.

Codice PHP:

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

/** Classe principale dell'applicazione autonoma */
public class Main {

    /** Punto d'entrata del programma */
    public static void main(String[] args) {
        /* Avvio dell'interfaccia grafica: */
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                new Main().apriFinestra();
            }
        });
    }

    private WindowListener ascoltatoreEventiFinestra = new WindowAdapter() {
        /** Questo metodo è invocato autonomamente quando l'utente cerca di
        chiudere la finestra */
        public void windowClosing(WindowEvent e) {
            chiudiProgramma();
        }
    };

    /* La griglia */
    private Grid griglia = new Grid(30, 30);

    /* Il pannello che proietta la griglia */
    private DrawAndClick contenitoreGriglia = new DrawAndClick(griglia);

    /* La finestra principale del programma */
    private JFrame finestra = new JFrame("DrawAndClick");

    /* Inizializza i componenti dell'interfaccia */
    private Main() {
        /* Assegna un colore di sfondo al contenitore della griglia */
        contenitoreGriglia.setBackground(Color.WHITE);
        contenitoreGriglia.setOpaque(true);

        /* Da una dimensione alle cella del contenitore della griglia */
        contenitoreGriglia.setDimensioniCella(20, 20);

        /* Collega l'ascoltatore di eventi prodotti da una finestra alla
        finestra */
        finestra.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
        finestra.addWindowListener(ascoltatoreEventiFinestra);

        /* Inserisce il pannello che proietta la griglia nella finestra */
        finestra.add(contenitoreGriglia, BorderLayout.CENTER);
    }

    /* Proietta la finestra principale sul desktop */
    private void apriFinestra() {
        finestra.pack();
        finestra.setVisible(true);
    }

    /* Da ascoltatoreFinestra.windowClosing */
    private void chiudiProgramma() {
        finestra.dispose();
    }
} 


Nota che il contenuto del metodo main, quello strano SwingUtilities.eccetera, è necessario, in quella forma o in forme equivalenti, per questioni di programmazione concorrente.

Per domande, dubbi, curiosità siamo qui.

[spillo491]

Sei trooppo gentile

Ho provato a compilare e funziona !!!
Adesso me lo guardo con calma e cerco di capire il tutto

Grazie ancora

PS: Ma tu sei il pgi del forum MokaByte ?

[spillo491]

Codice PHP:

public void setDimensioniCella(int larghezza, int altezza) { 
        /* GeneralPath è un percorso vettoriale */ 
        GeneralPath croce = new GeneralPath(); 
        croce.moveTo(0, 0); 
        croce.lineTo(larghezza - margineInterno, altezza - margineInterno); 
        croce.moveTo(larghezza - margineInterno, 0); 
        croce.lineTo(0, altezza - margineInterno); 
        figuraCroce = croce; 


L'istruzione "croce.moveTo(0, 0);" porta il cursore nell'angolo in alto a sx della cella ? Da quanto ho capito queste istruzioni dovrebbero disegnare la croce ma non mi tornano le coordinate?

[PGI-Bis]

No, se intendo correttamente.

GeneralPath è la definizione di un poligono da settimana enigmistica: unisci tutti i puntini e vedi cosa salta fuori.

E' uno java.awt.geom.Shape, cioè una figura geometrica 2D. Un oggetto Shape può essere rifilato al metodo draw o fill di un Graphics2D e il risultato è che la figura geometrica viene riprodotta alla foce della pipeline di rendering. Sullo schermo o in memoria, dipende. Comunque sia, la creazione di un oggetto di tipo Shape (GeneralPath ad esempio) non comporta anche il disegno di quella figura.

Le linee di codice che quoti creano e mettono da parte, per un uso futuro, una crocetta. La crocetta è fatta di due linee separate e incrociate. Le diagonali di un quadrato.

Ci sono diversi tipi di Shape nel package java.awt.geom. Non c'è la crocetta. Per crearla, quindi, uso GeneralPath. La linea:

croce.moveTo(0, 0);

usa il metodo moveTo per dire al GeneralPath: "qui inizia un segmento separato da tutti gli altri".

La linea:

croce.lineTo(larghezza - margineInterno, altezza - margineInterno);

usa il metodo lineTo per dire al GeneralPath: "immagazzina un segmento retto che parte dal punto precedente, quello del moveTo nel nostro caso, e arriva fino a (larghezza - margineIntero, altezza - margineInterno)". Una delle due diagonali di un rettangolo, quella che inizia dall'estremo in alto a sinistra e finisce in basso a destra.

La linea seguente:

croce.moveTo(larghezza - margineInterno, 0);

dice al GeneralPath di immagazzinare quel punto come l'inizio di un segmento non connesso. E' il primo punto della seconda diagonale: in alto a destra.

L'ultima linea:

croce.lineTo(0, altezza - margineInterno);

dice al GeneralPath di immagazzinare una linea che va dal punto precedente, quello del moveTo, al punto (0, altezza - margineInterno). E' il secondo punto della seconda diagonale: in basso a sinistra.

Nel sistema di coordinate della pipeline di rendering Java2D (accessibile tramite un oggetto Graphics2D), l'origine degli assi è "in alto a sinistra". X cresce "verso destra", Y cresce "verso il basso".

Ripeto, quello istruzioni creano una croce ma non la disegnano. Il disegno della croce avviene quando trovi un "pipeline.draw(figuraCroce)". Noterai come quelle istruzioni siano precedute da un "pipeline.translate". Questo perchè, come si nota nella costruzione del GeneralPath, la crocetta è costruita come una linea che parte dal punto (0,0) e va fino al punto, in ipotesi, (10, 10) più una linea che parte dal punto (10, 0) e va fino al punto (0, 10). Un semplice pipeline.draw(figuraCroce) disegnerebbe questa croce come risulta dai suoi punti: sempre in alto a sinistra dello schermo. Spostando il sistema di coordinate con translate, prima del disegno, siamo in grado di far apparire una stessa figura in punti diversi dello schermo senza cambiare le coordinate dei suoi punti (ma cambiando l'origine degli assi del sistema di coordinate a cui appartiene al figura).