Farbe per Taste auswählen

Hallo,

wie kann ich bei der Source noch die Farben per Tastendruck wählen.



import java.awt.*;



public class SimplePaint extends JApplet {
   
   /**
	 * 
	 */
	private static final long serialVersionUID = 5311442674393780307L;



   public static void main(String[] args) {
      JFrame window = new JFrame("Simple Paint");
      SimplePaintPanel content = new SimplePaintPanel();
      window.setContentPane(content);
      window.setSize(600,480);
      window.setLocation(100,100);
      window.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
      window.setVisible(true);

   }
   
 
   public void init() {
      setContentPane( new SimplePaintPanel() );
   }
   
   
 
   public static class SimplePaintPanel extends JPanel
               implements MouseListener, MouseMotionListener {
      
     
      /**
	 * 
	 */
	private static final long serialVersionUID = -3008477350962597683L;

	private final static int BLACK = 0,
                        RED = 1,     
                        GREEN = 2,   
                        BLUE = 3, 
                        CYAN = 4,   
                        MAGENTA = 5,
                        YELLOW = 6;
      
      private int currentColor = BLACK;  
      
      

      
      private int prevX, prevY;   
      
      private boolean dragging;      
      
      private Graphics graphicsForDrawing; 
      
      
   
      SimplePaintPanel() {
         setBackground(Color.WHITE);
         addMouseListener(this);
         addMouseMotionListener(this);
      }
      
            
 
      public void paintComponent(Graphics g) {
         
         super.paintComponent(g);  
         
         int width = getWidth();    
         int height = getHeight();  
         
         int colorSpacing = (height - 56) / 7;

         
         g.setColor(Color.GRAY);
         g.drawRect(0, 0, width-1, height-1);
         g.drawRect(1, 1, width-3, height-3);
         g.drawRect(2, 2, width-5, height-5);
         

         
         g.fillRect(width - 56, 0, 56, height);
         

         
         g.setColor(Color.WHITE);
         g.fillRect(width-53,  height-53, 50, 50);
         g.setColor(Color.BLACK);
         g.drawRect(width-53, height-53, 49, 49);
         g.drawString("CLEAR", width-48, height-23); 
         
         /* Draw the seven color rectangles. */
         
         g.setColor(Color.BLACK);
         g.fillRect(width-53, 3 + 0*colorSpacing, 50, colorSpacing-3);
         g.setColor(Color.RED);
         g.fillRect(width-53, 3 + 1*colorSpacing, 50, colorSpacing-3);
         g.setColor(Color.GREEN);
         g.fillRect(width-53, 3 + 2*colorSpacing, 50, colorSpacing-3);
         g.setColor(Color.BLUE);
         g.fillRect(width-53, 3 + 3*colorSpacing, 50, colorSpacing-3);
         g.setColor(Color.CYAN);
         g.fillRect(width-53, 3 + 4*colorSpacing, 50, colorSpacing-3);
         g.setColor(Color.MAGENTA);
         g.fillRect(width-53, 3 + 5*colorSpacing, 50, colorSpacing-3);
         g.setColor(Color.YELLOW);
         g.fillRect(width-53, 3 + 6*colorSpacing, 50, colorSpacing-3);
         

         
         g.setColor(Color.WHITE);
         g.drawRect(width-55, 1 + currentColor*colorSpacing, 53, colorSpacing);
         g.drawRect(width-54, 2 + currentColor*colorSpacing, 51, colorSpacing-2);
         
      } 
      
      

      private void changeColor(int y) {
         
         int width = getWidth();         
         int height = getHeight();        
         int colorSpacing = (height - 56) / 7;  
         int newColor = y / colorSpacing;       
         
         if (newColor < 0 || newColor > 6)      
            return;
         

         
         Graphics g = getGraphics();
         g.setColor(Color.GRAY);
         g.drawRect(width-55, 1 + currentColor*colorSpacing, 53, colorSpacing);
         g.drawRect(width-54, 2 + currentColor*colorSpacing, 51, colorSpacing-2);
         currentColor = newColor;
         g.setColor(Color.WHITE);
         g.drawRect(width-55, 1 + currentColor*colorSpacing, 53, colorSpacing);
         g.drawRect(width-54, 2 + currentColor*colorSpacing, 51, colorSpacing-2);
         g.dispose();
         
      } 
      
      

      private void setUpDrawingGraphics() {
         graphicsForDrawing = getGraphics();
         switch (currentColor) {
         case BLACK:
            graphicsForDrawing.setColor(Color.BLACK);
            break;
         case RED:
            graphicsForDrawing.setColor(Color.RED);
            break;
         case GREEN:
            graphicsForDrawing.setColor(Color.GREEN);
            break;
         case BLUE:
            graphicsForDrawing.setColor(Color.BLUE);
            break;
         case CYAN:
            graphicsForDrawing.setColor(Color.CYAN);
            break;
         case MAGENTA:
            graphicsForDrawing.setColor(Color.MAGENTA);
            break;
         case YELLOW:
            graphicsForDrawing.setColor(Color.YELLOW);
            break;
         }
      } 
      
      
 
      public void mousePressed(MouseEvent evt) {
         
         int x = evt.getX();   
         int y = evt.getY();   
         
         int width = getWidth();    
         int height = getHeight();  
         
         if (dragging == true)  
            return;           
                                
                               
         
         if (x > width - 53) {

            if (y > height - 53)
               repaint();       
            else
               changeColor(y);  
         }
         else if (x > 3 && x < width - 56 && y > 3 && y < height - 3) {
            
            prevX = x;
            prevY = y;
            dragging = true;
            setUpDrawingGraphics();
         }
         
      } 
      
      
 
      public void mouseReleased(MouseEvent evt) {
         if (dragging == false)
            return;  
         dragging = false;
         graphicsForDrawing.dispose();
         graphicsForDrawing = null;
      }
      
      
   
      public void mouseDragged(MouseEvent evt) {
         
         if (dragging == false)
            return;  
         
         int x = evt.getX();   
         int y = evt.getY();   
         
         if (x < 3)                          
            x = 3;                           
         if (x > getWidth() - 57)       
            x = getWidth() - 57;
         
         if (y < 3)                          
            y = 3;                           
         if (y > getHeight() - 4)       
            y = getHeight() - 4;
         
         graphicsForDrawing.drawLine(prevX, prevY, x, y);  
         
         prevX = x;  
         prevY = y;
         
      } 
      
      
      public void mouseEntered(MouseEvent evt) { }   
      public void mouseExited(MouseEvent evt) { }    
      public void mouseClicked(MouseEvent evt) { }   
      public void mouseMoved(MouseEvent evt) { }     
      
      
   }  

} 

Danke für Eure Hilfe

Holger

Du könntest per Key Bindings Actions an Deine Komponente hängen, die die Farbe auf Tastendruck ändern.

ABER:

Das ist keine gute Idee. Entweder Du zeichnest auf ein Image und zeichnest dieses in Deine Komponente oder Du zeichnest alles innerhalb der paintComponent (den zu zeichnenden Inhalt dabei in Objekt Listen merken)
Aber getGraphics() auf Komponenten aufzurufen ist in 99,99999% der Fälle eine schlechte Idee.
In Deinem Fall sollte das gezeichnet verschwinden sobald Du das Fenster in den Hintergrund stellst und wieder vorholst oder einfach nur die Größe des Fensters änderst.

Hey Michael,

Du hast mit Deiner Anmerkung natürlich recht, aber für das Beispiel ist das egal.
Ich kann auch leider nicht wirklich JAVA sonder vb.net ist eher meine Welt.

Kannst Du mir anhand eines kleinen Codeschnipsels das mit der KEY Bindings Actions zeigen. Vielleicht sogar in meinem Code mit nur einer Farbe

Wäre echt nett
Holger

*** Edit ***

Hallo,

habe es nun mal so versucht, bekomme aber hinter Yellow beim ; ein Multible Line Fehler
Und die Toolkit.addAWTE… wird auch als Falsch gemarkert

    Toolkit toolkit = Toolkit.getDefaultToolkit();
    Toolkit.addAWTEventListener(this, eventMask);```


```  public void eventDispatched(AWTEvent event)
      {
        
        int ID = event.getID();
        
        if (ID == KeyEvent.KEY_PRESSED)
        {
          
          if (event.paramString().indexOf("1") ==  BLACK);
          else if (event.paramString().indexOf("2") == RED);
          else if (event.paramString().indexOf("3") == GREEN);
          else if (event.paramString().indexOf("4") == BLUE);
          else if (event.paramString().indexOf("5") == CYAN);
          else if (event.paramString().indexOf("6") == MAGENTA);
          else if (event.paramString().indexOf("7") == YELLOW);
          
          }
      ```

Danke
Holger

Da muss ein bisschen mit Reflections und
java.​lang.​System
public static String getProperty(String key)
gearbeitet werden:


import java.awt.Color;
import java.awt.Graphics;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.lang.reflect.Field;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.WindowConstants;

/**
 * @author CB
 */
public class ShowAColor {

    private static void drawColor(final Color color) {
        JFrame jf = new JFrame(color.toString());
        jf.add(new JPanel() {
            @Override
            protected void paintComponent(Graphics g) {
                g.setColor(color);
                g.fillOval(0, 0, this.getWidth(), this.getHeight());
            }
        });
        jf.setSize(200, 200);
        jf.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
        jf.setVisible(true);
    }

    public static void main(String[] args) throws Exception {
        Field[] colors = Class.forName("java.awt.Color").getDeclaredFields();
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String line;
        do {
            for (int i = 0; i < colors.length; i += 3) {
                for (int j = i; j < colors.length && j < i + 3; j++) {
                    System.out.printf("%-3d%-20s", j, colors[j].getName());
                }
                System.out.println("");
            }
            System.out.print("Bitte Farbe (Englisch) eingeben: ");
            line = br.readLine();
            Color color = (Color) colors[Integer.parseInt(line)].get(null);
            drawColor(color);
        } while (line != null && !line.isEmpty());
    }
}```

Edit: Sry, Zeile 46 war falsch.

Hallo CB,

Kannst du mir das vielleicht anhand von einer Farbe in meinem Code zeigen?
Ich verstehe das leider gerade gar nicht.
Ich sehe bei Dir auch gerade keinen Tastdruck, der abgefragt wird.

Holger

Welche Tasten sollen gedrückt werden? Auf welcher Komponente soll der Listener registriert werden? Worauf wird setXxx aufgerufen oder paintComponent überschrieben? Geht es hier um AWT/Swing -oder liege ich voll daneben? (Wahrscheinlich hat meine Antwort gar nix mit Deiner Frage zu tun…) :frowning:

Es soll z.B.: die Tast “r” gedrückt werden, dann soll die Farbe auf Rot wechseln.

Nein Du liegst mit AWT / Swing richtig

Holger

Verwende dafür am besten Keybindings:
http://docs.oracle.com/javase/tutorial/uiswing/misc/keybinding.html

Hey,

versteh ich das so richtig?

ich verwende hier die foldenen Zeilen

component.getInputMap().put(KeyStroke.getKeyStroke("r"),
                            "Farbe zuordnen");
component.getActionMap().put("Farbe zuordnen"),
                             anAction);

Farbe zuordnen = Variable == BLACK oder wie

Und kanns Du vielleicht mal in meinem Post schauen warum die If Else If Else Abfrage am Ende bei ; einen Fehler auswirft

Danke
Holger

Ps vielleicht noch an welcher Stelle ich das einbauen soll

if(Bedingung){
      somethingToDo();
}else if(Bedingung){
      somethingToDo();
}

hoffe das hilft dir

Und ist das mit den KeyBindings so, sehe ich das richtig

Danke
Übrigens das andere werde ich nachher (Essen) probieren.

Nur dafür fehlt mir ja eh noch die Tastaturabfrage

Holger

Ich bin weg, aber hier hast du was Funktionierendes, damit solltest du dir was basteln können.

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

/**
 *
 * @author Kiri
 */
public class test {
    private final static JPanel panel = new JPanel();
    private static Color color = Color.WHITE;
    public static void main(String[]args){
        JFrame window = new JFrame("Simple Paint");

        
        panel.setSize(400, 320);
        panel.setBackground(color);
        window.add(panel);
        window.setSize(600,480);
        window.setLocation(100,100);
        window.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
        window.setVisible(true);

        
        //für Rot
        Action setColorRed = new AbstractAction() {
            @Override
            public void actionPerformed(ActionEvent e) {
                color = Color.RED;
                panel.setBackground(color);
            }
        };
        window.getRootPane().getInputMap().put(KeyStroke.getKeyStroke("R"),
                            "setColorRed");
        window.getRootPane().getActionMap().put("setColorRed",
                             setColorRed);  
        
        //für Gelb
        Action setColorYellow = new AbstractAction() {
            @Override
            public void actionPerformed(ActionEvent e) {
                color = Color.YELLOW;
                panel.setBackground(color);
            }
        };
        window.getRootPane().getInputMap().put(KeyStroke.getKeyStroke("Y"),
                            "setColorYellow");
        window.getRootPane().getActionMap().put("setColorYellow",
                             setColorYellow);  
    }  
}

Kannst Du mir sagen,
wie ich das da einbauen kann

private void setUpDrawingGraphics() {
         graphicsForDrawing = getGraphics();
         switch (currentColor) {
         case BLACK:
            graphicsForDrawing.setColor(Color.BLACK);
            break;
         case RED:
            graphicsForDrawing.setColor(Color.RED);
            break;

Oder wie ich das
graphicsForDrawing.setColor(Color.RED)

beim Tastendruck befüllen kann

wäre nett

Danke
Holger

Am Ende des SimplePaintPanel-Konstruktors sowas:

            getInputMap().put(KeyStroke.getKeyStroke('r'), keyRed);
            getActionMap().put(keyRed, new AbstractAction() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    changeColorIndex(RED);
                    currentColor = RED;
                }
            });```
Die Methode `changeColor(int)` musst Du dann so umbauen, dass sie als Parameter auch den Farbindex statt des y-Wertes akzeptiert. Diese neue Methode habe ich hier `changeColorIndex(int)` genannt.

Es wäre recht unschön, das ganze so mehrfach untereinander zu kopieren. Als Minimum würde ich betrachten, es in eine Methode auszulagern, die das Binding für jeweils eine Farbe erledigt.