Posted: Dezember 13th, 2011 | Author: admin | Filed under: Programmieren | Tags: download, herunterladen, Java, Layout, TableLayout, Tutorial | 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
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(100, 100, 450, 300);
contentPane = new JPanel();
double[][] layout = new double[][]{
// X-Achse
{0.4, 0.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");
}
} |
Posted: Juni 21st, 2011 | Author: admin | Filed under: Programmieren | Tags: Beispiel, chat, Example, Java, Mulitcast, MulticastSocket, network, Netzwerk Nachricht, senden, Socket, Tutorial | No Comments »
Als 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
Posted: Juni 2nd, 2011 | Author: Lukas | Filed under: Fotografie, Tutorials | Tags: Farbwerte, Kontrast, Photoshop, Tutorial | 1 Comment »
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.
Posted: April 2nd, 2011 | Author: admin | Filed under: Programmieren, Tutorials | Tags: einrichten, Entwicklung, Java, slick, slick2D, Spiele, Tutorial | 2 Comments »
Seit einiger Zeit befasse ich mich mit der Java 2D Spiele-Engine Slick (Danke an Tobse). Deswegen habe ich mir gedacht wieso nicht ein Tutorial schreiben. Heraus gekommen ist ein Dokument welches beschreibt wie man Slick einrichtet, wie mein sein erstes Projekt erstellt und wie man ein erstes Spiel entwickelt. Als Beispiel-Spiel habe ich mich für einen Pong-Klon entschieden.
Hier geht’s zum Slick Tutorial:
Posted: November 3rd, 2010 | Author: admin | Filed under: Programmieren | Tags: Beispiel, Checkbox, Example, JCheckBox, JList, List, ListCellRenderer, ListModel, toString(), Tutorial | 2 Comments »
Für mein neustes Programm jCalFilter, welches Einträge in einem Kalender im ICS-Format filtern kann, habe ich eine JList gebraucht in der ich Termine auswählen kann. Dafür eignete sich am Besten eine JList die JCheckboxes beinhaltet. Mit diesem kleinen Tutorial möchte ich euch zeugen wie ihr das realisieren könnt.
Das fertige Programm soll so aussehen:
Als Datenkapsel verwende ich ein Objekt Person welches lediglich die Informationen Vorname, Name und Alter abspeichert. Des weiteren bietet die Klasse Person noch eine toString()-Methode. In dieser wird der Text zurückgegeben der jeweils in der Liste angezeigt werden soll.
Person.java
public class Person {
private String name;
private String vorname;
private int alter;
public Person(String name, String vorname, int alter){
this.name = name;
this.vorname = vorname;
this.alter = alter;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getVorname() {
return vorname;
}
public void setVorname(String vorname) {
this.vorname = vorname;
}
public int getAlter() {
return alter;
}
public void setAlter(int alter) {
this.alter = alter;
}
@Override
public String toString() {
return vorname + " " + name + " (" + alter + ")";
}
} |
Nun kommen wir zum eigentlichen Kern der Implementierung. Die Klasse JCheckBoxList erbt einfach von JList. Diese beinhaltet einen ListCellRenderer in dem Formatierungen verändert werden können. Zusätzlich bietet die Klasse JCheckBoxList eine Methode selectAll() und deselectAll() an, um eben alle Häkchen zu setzten oder um die Auswahl aller Häkchen zu entfernen.
JCheckBoxList.java
import java.awt.Component;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import javax.swing.JCheckBox;
import javax.swing.JList;
import javax.swing.ListCellRenderer;
import javax.swing.ListSelectionModel;
import javax.swing.UIManager;
public class JCheckBoxList extends JList {
public JCheckBoxList() {
setCellRenderer(new CellRenderer());
addMouseListener(new MouseAdapter() {
public void mousePressed(MouseEvent e) {
int index = locationToIndex(e.getPoint());
if (index != -1) {
JCheckBox checkbox = (JCheckBox) getModel().getElementAt(
index);
checkbox.setSelected(!checkbox.isSelected());
repaint();
}
}
});
setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
}
protected class CellRenderer implements ListCellRenderer {
public Component getListCellRendererComponent(JList list, Object value,
int index, boolean isSelected, boolean cellHasFocus) {
JCheckBox checkbox = (JCheckBox) value;
if (isSelected) {
// checkbox.setBorderPainted(true);
// checkbox.setForeground(UIManager.getColor("List.selectionForeground"));
// checkbox.setBackground(UIManager.getColor("List.selectionBackground"));
} else {
// checkbox.setBorderPainted(false);
// checkbox.setForeground(UIManager.getColor("List.foreground"));
checkbox.setBackground(UIManager.getColor("List.background"));
}
return checkbox;
}
}
public void selectAll() {
int size = this.getModel().getSize();
for (int i = 0; i < size; i++) {
JCheckBox checkbox = (JCheckboxWithObject) this.getModel()
.getElementAt(i);
checkbox.setSelected(true);
}
this.repaint();
}
public void deselectAll() {
int size = this.getModel().getSize();
for (int i = 0; i < size; i++) {
JCheckBox checkbox = (JCheckboxWithObject) this.getModel()
.getElementAt(i);
checkbox.setSelected(false);
}
this.repaint();
}
} |
Um die Verbindung zwischen einer Person und der Checkbox herzustellen habe ich das Objekt JCheckboxWithObject erstellt. Diese Klasse erbt von JCheckBox aber beinhaltet zusätzlich noch ein Objekt vom Typ Object in dem man irgendein Objekt ablegen kann. In unserem Fall ein Objekt vom Typ Person. Die Checkbox wird, im Konstruktor und der Setter-Methode, nun mit dem Rückgabestring der toString()-Methode des jeweiligen Objektes(Person) beschriftet.
JCheckboxWithObject.java
import javax.swing.JCheckBox;
public class JCheckboxWithObject extends JCheckBox{
private Object object;
public JCheckboxWithObject (Object object){
this.object = object;
this.setText(object.toString());
}
public Object getObject() {
return object;
}
public void setObject(Object object) {
this.object = object;
this.setText(object.toString());
}
} |
Nun kann die Datenstruktur wie folgt angewendet werden. Das Ergebnis seht ihr ja oben.
Main.java
import javax.swing.DefaultListModel;
import javax.swing.JFrame;
import javax.swing.SwingUtilities;
import javax.swing.UIManager;
public class Main {
{
// Set Look & Feel
try {
UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
SwingUtilities.invokeLater(new Runnable() {
public void run() {
// Fenster
JFrame frame = new JFrame();
// Checkboxliste
DefaultListModel personenListModel = new DefaultListModel();
JCheckBoxList list = new JCheckBoxList();
list.setModel(personenListModel);
// Daten hinzufügen
Person hans = new Person("Wurst", "Hans", 24);
Person peter = new Person("Müller", "Peter", 36);
Person klaus = new Person("Wagner", "Klaus", 29);
JCheckboxWithObject hansCheckbox = new JCheckboxWithObject(hans);
JCheckboxWithObject peterCheckbox = new JCheckboxWithObject(
peter);
JCheckboxWithObject klausCheckbox = new JCheckboxWithObject(
klaus);
personenListModel.addElement(hansCheckbox);
personenListModel.addElement(peterCheckbox);
personenListModel.addElement(klausCheckbox);
frame.getContentPane().add(list);
frame.setVisible(true);
frame.setTitle("JCheckbox in JList");
frame.setSize(200, 200);
}
});
}
} |
Download
Hier könnt ihr euch denn ganzen Quellcode herunterladen.
