Java JButton und ActionListener

Posted: Mai 16th, 2012 | Filed under: Allgemein, Java, Programmieren, Tutorials | Tags: , , , , , , , | No Comments »

Hier ein kleines Beispiel für alle Java Swing Neulinge. Mit Hilfe eines ActionListeners könnt ihr Klicks auf einen JButton abfangen. Funktioniert natürlich auch, falls ihr die Schaltfläche mit der Tastatur auslöst (zum Beispiel bei Focus mit Hilfe der Leertaste).

import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;

public class JButtonExample implements ActionListener{
    
    private JButton button;

    public JButtonExample() {
        // Fenster anlegen
        JFrame frame = new JFrame();
        frame.setTitle("JButton Example");
        frame.setLayout(new BorderLayout());
        
        // Button anlegen
        this.button = new JButton("OK");

        // Eventhandler für Button zuweisen
        this.button.addActionListener(this);
        
        // Button der Frame hinzufügen
        frame.add(this.button);
        
        // Fenster zentrieren
        frame.setSize(350,150);
        frame.setLocationRelativeTo(null);
        
        // Fenster sichbar machen
        frame.setVisible(true);
    }
    
    public static void main(String[] args) {
        new JButtonExample();
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        if(button == e.getSource()){
            System.out.println("Button wurde geklickt!");
        }
    }
}

Ich hoffe ich konnte dem ein oder anderen mit diesem Tutorial helfen =)


Tutorial: TeXlipse und LaTeX Starthilfe

Posted: Februar 21st, 2012 | Filed under: Software | Tags: , , , , | No Comments »

Es ist nicht so einfach TeXlipse und LaTeX zum Laufen zu bekommen, deswegen hier ein kleines Tutorial wie ihr die ganze Maschinerie in Gange bringt.

1. TeXlipse hier herunterladen http://sourceforge.net/projects/texlipse/ (zB.:texlipse_1.5.0 src.zip)

2. Den Ordner “net.sourceforge.textlipse_X.X.X” in der ZIP-Datei in den Ordner …”eclipse/plugins/” kopieren.

image

 

3. “MiKTeX Basic Installer” hier herunterladen und installieren: http://miktex.org/

image

 

4. Eclipse starten und unter “Window –> Preferences –> Texlipse –> Builder Settings”: Bin Directory mit folgendem Pfad: “C:\Programme\MiKTeX 2.9\miktex\bin” auswählen. Siehe Markierung 1 um Bild:

image

Anschließend füllen sich alle leeren Klammern in der Liste außer PsLatex. Das macht aber nichts.

 

5.  Nun müsst ihr noch den Viewer auswählen. Dies könnt ihr im gleichen Menüzweig erledigen, ich verwende natürlich sumatraPDF, dieser eignet sich hervorragend dafür:

image 

 

6. Über “File –> New LaTeX Project”  könnt ihr ein neues Projekt anlegen. Speichert ihr nun die *.tex – Datei wird diese automatisch kompiliert und ihr könnt sie euch mit “STRG + 4” anzeigen lassen.


Java TableLayout Beispiel / Example

Posted: Dezember 13th, 2011 | Filed under: Java, Programmieren | Tags: , , , , , | 1 Comment »

Oft benutzte ich in meinen Anwendungen das praktische TableLayout. Es ist standardmäßig kein Bestandteil von Java, ihr könnt euch jedoch die Bibliothek hier herunterladen: http://java.sun.com/products/jfc/tsc/articles/tablelayout/apps/TableLayout.jar

Mit dem TableLayout könnt ihr folgende Größen definieren:

  • Prozentuale (in Prozent 0.5 = 50%)
  • Absolute (Pixel 200 = 200 Pixel)
  • Relative (TableLayout.FILL = den restlichen Platz verwenden)

Also Beispiel hier mehrere Buttons:

  • Spalten: 40%, 30%, TableLayout.FILL
  • Reihen: 200 Pixel, TableLayout.FILL

image

Hier der Quellcode:

import info.clearthought.layout.TableLayout;

import java.awt.EventQueue;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class TableLayoutTutorial extends JFrame {

  private JPanel contentPane;

  /**
   * Launch the application.
   */
  public static void main(String[] args) {
    EventQueue.invokeLater(new Runnable() {
      public void run() {
        try {
          TableLayoutTutorial frame = new TableLayoutTutorial();
          frame.setVisible(true);
        catch (Exception e) {
          e.printStackTrace();
        }
      }
    });
  }

  /**
   * Create the frame.
   */
  public TableLayoutTutorial() {
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    setBounds(100100450300);
    contentPane = new JPanel();
    
    double[][] layout = new double[][]{
        // X-Achse
        {0.40.3, TableLayout.FILL},
        
        // Y-Achse
        {200, TableLayout.FILL}
    };

    TableLayout contentPaneLayout = new TableLayout(layout);
    contentPane.setLayout(contentPaneLayout);
    setContentPane(contentPane);
    
    // "0,0" X-Position, Y-Position
    contentPane.add(new JButton("40% / 200")"0,0");
    contentPane.add(new JButton("30% / 200")"1,0");
    contentPane.add(new JButton("REST / 200")"2,0");
    
    contentPane.add(new JButton("40% / REST")"0,1");
    contentPane.add(new JButton("30% / REST")"1,1");
    contentPane.add(new JButton("REST / REST")"2,1");
  }

}

Java Chat Tutorial

Posted: Juni 21st, 2011 | Filed under: Java, Programmieren | Tags: , , , , , , , , , , | 1 Comment »

imageAls ich meinen Netzwerk-Chat jLanChat programmiert habe, musste ich mich intensiv mit diesem Thema beschäftigen. Herkömmlicherweise verwendet man zum versenden von Nachrichten das sogenannte Client-Server Prinzip. Will zum Beispiel PC1 eine Nachricht an PC2 senden so muss PC2 einen Socket öffnen mit dem sich PC1 dann verbindet und über diesen Socket die Nachricht sendet. Will man nun eine Nachrichtenleitung mit mehren PCs aufbauen so benötigt man schnell einen Server, mit dem sich dann alle Clients verbinden und über diesen dann kommunizieren.

Wenn wir die Kommunikation über Multicast (Punkt zu Gruppe) tätigen brauchen wir keinen Server. Denn fast alle Router/Switches unterstützen Multicast.

Alle Teilnehmer verbinden sich mit dem Switch/Router und treten einer Gruppe, in Form einer IP-Adresse und eines Ports (z.B.: 230.0.0.1:4447), bei. Bekommt der Switch/Router jetzt eine Nachricht eines Clients mit der Gruppen-Adresse als Zieladresse vervielfältigt der Switch/Router diese Nachricht und sendet sie an alle die der Gruppe beigetreten sind, auch an den der die Nachricht abgesendet hat. So kann man zum Beispiel einen serverlosen Chat aufbauen. Wenn man’s genau nimmt übernimmt der Switch/Router jetzt unsere Serverfunktion.

Um das Ganze in JAVA zu realisieren muss man folgende Bibliothek ins Projekt einbinden: http://commons.apache.org/lang/

Hier unser Beispiel, Es gibt eine Sender-Klasse und eine Empfänger-Klasse:

Sender

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.InetAddress;
import java.net.MulticastSocket;


public class Sender {

  public static void main(String[] args) {
    // Netzwerk-Gruppe
    String NETWORK_GROUP = "230.0.0.1";
    // Netzwerk-Gruppen Port
    int NETWORK_GROUP_PORT = 4447;
    // Client-Port
    int CLIENT_MULTICAST_PORT = 4446;
   
    // Nachrichten-Codierung
    String TEXT_ENCODING = "UTF8";
   
    try {
      MulticastSocket socket =  new MulticastSocket(CLIENT_MULTICAST_PORT);
      byte[] message = "Hallo Welt".getBytes(TEXT_ENCODING);
     
      // Nachricht an Gruppe senden
      socket.send(new DatagramPacket(message, message.length , InetAddress.getByName(NETWORK_GROUP) ,
NETWORK_GROUP_PORT
));
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

 

Empfänger

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.InetAddress;
import java.net.MulticastSocket;


public class Receiver {

  public static void main(String[] args) {
    // Netzwerk-Gruppe
    String NETWORK_GROUP = "230.0.0.1";
    // Netzwerk-Gruppen Port
    int NETWORK_GROUP_PORT = 4447;
   
    // Nachrichten-Codierung
    String TEXT_ENCODING = "UTF8";
   
    InetAddress group;
    MulticastSocket socket;
 
    try {
      // Gruppe anlegen
      group = InetAddress.getByName(NETWORK_GROUP);
      socket = new MulticastSocket(NETWORK_GROUP_PORT);
     
      // Gruppe beitreten
      socket.joinGroup(group);
     
      byte[] bytes = new byte[65536];
      DatagramPacket packet = new DatagramPacket(bytes, bytes.length);
     
      while(true){
        // Warten auf Nachricht
        socket.receive(packet);
        String message = new String(packet.getData(),0,packet.getLength(), TEXT_ENCODING);
        System.out.println(message);
      }   
     
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

 

Ich hoffe ich konnte dem ein oder anderen damit helfen.

Das ganze könnt ihr euch als Eclipse Projekt hier herunterladen (inklusive Bibliotheken): Eclipse Projekt – Tutorial Net Send


Elegante Kontrasterhöhung in Photoshop

Posted: Juni 2nd, 2011 | Filed under: Fotografie, Tutorials | Tags: , , , | 3 Comments »

Ich möchte hier eine recht elegante Methode vorstellen, mithilfe von Photoshop, eine ressourcenschonende Kontrasterhöhung vorzunehmen. Vorteile dieser Methode sind,  im Vergleich zur herkömmlichen Vorgehensweise, die eben erwähnte Verschonung der Ressourcen von Eingriffen, eine leichte Regulierung und Nachregulierung und vor allem die Beständigkeit der gegebenen Farbwerte.

Die Technik basiert auf einer Überlagerung des Stock-Bilds mit seinem kontrastreichsten Farbkanal. Gehen wir das Thema Schritt für Schritt an und öffnen ein zu bearbeitendes Bild in Photoshop (In meinem Fall Photoshop CS4, die Methode sollte aber in jeder mir bekannten Version analog durchführbar sein und auch auf andere Bearbeitungsprogramme wie Gimp u.Ä. übertragbar sein).

Ich entscheide mich hier für ein Portrait. Es fällt auf, dass das Bild ohnehin schon sehr kontrastreiche Züge hat, ich will aber versuchen Hautmerkmale, Schattierungen und Haare besonders hervorstechen zu lassen um dem Bild einen verunreinigten Touch zu geben.

Mit dem Reiter „Kanäle“ im Ebenen-Fenster wechseln wir in die Kanalansicht des Bildes.

 

Wir werden jetzt versuchen den Farkanal mit den kontrastreichsten Farbinformationen zu finden. Es lässt sich hier erkennen, dass die Farbwerte des Bilds durch den RGB-Modus gespeichert werden. In Photoshop lassen sich die drei Farbkanäle für Rot, Grün und Blau einzeln anzeigen und bearbeiten. Die einzelnen Farbkanäle stellen die Intensität jeder der drei Farben in den entsprechenden Bereichen dar. Das letztendliche Bild entsteht dann dadurch, dass die Farbwerte für jeden Pixel verrechnet werden. Analog funktioniert dieses Prinzip auch für die anderen Modi wie CMYK. Das Akronym steht hierbei für Cyan, Magenta, Yellow und Key (Schwarz). Wir gehen also jeden einzelnen dieser Kanäle durch und vergleichen nach Kontrast.

Ich konzentriere mich hier auf die Farbinformation im Bereich des Gesichts und stelle fest, dass in meinem Fall der Blau-Kanal den höchsten Kontrast bietet.

Diese kontrastreiche Graustufendarstellung unseres Bilds möchten wir jetzt als eigene Ebene einfügen. Am einfachsten funktioniert dies, indem wir, mit aktiviertem Blaukanal, den gesamten Darstellungsbereich mit Strg+a auswählen und mit Strg+c kopieren. Anschließend verlassen wir den einzelnen Kanal, aktivieren wieder den gesamten RGB-Bereich und wechseln in den Reiter „Ebenen“. Hier erstellen wir eine neue Ebene und fügen den zuvor kopierten Blaukanal mit Hilfe von Strg+v ein.

Um die beiden Ebenen miteinander zu verrechnen, wählen wir für unsere neue Blaukanal-Ebene den Ebenenmodus „Ineinanderkopieren“. Durch die Wahl dieses Ebenenmodus haben wir den entscheidensten Vorteil zur herkömmlichen Kontrasterhöhung mit Gradationskurven etc. gewonnen: Veränderungen der Farbintensität bleiben minimal und bleiben nachträglich steuerbar. Ein Blick in die Spezifikation Adobes zum Ebenenmodus „Ineinanderkopieren“ verrät:

Multiplies or screens the colors, depending on the base color. Patterns or colors overlay the existing pixels while preserving the highlights and shadows of the base color. The base color is not replaced but is mixed with the blend color to reflect the lightness or darkness of the original color.

Zum Vergleich habe ich auf das ursprüngliche Bild eine, zugegebener Maßen übertrieben starke, Kontrasterhöhung mit der Gradationskurve für den RGB-Modus durchgeführt. Dabei wird eine krasse Farbänderung ins Rote beobachtet, ohne dass dabei der Detailgrad erreicht wird, den wir bei unserer Methode beobachten können.

Zum Schluss lässt sich die erwirkte Kontrasterhöhung gegebenenfalls abschwächen oder verstärken, indem die Deckkraft der Blaukanalebene verringert, bzw. die selbige Ebene einfach beliebig oft dupliziert wird. Außerdem ist es durchaus denkbar diese Kontrasterhöhung durch das Anwenden einer Ebenenmaske auf die Kanalebene selektiv ein- oder auszublenden, was die Methode äußerst anpassbar macht.