Ich bin ein relativer Neuling im Bereich MVC, hab mir allerdings schon einiges angeschaut aber noch lange nicht alles verstanden 
Deshalb wollte ich mich mal an ein Beispiel waagen, um das Prinzip zu verstehen, Observer zu nutzen etc.
Meine Ausgangslage:
Ich hab eine View in der Rechts (BorderPanel.East) ein Counter durch das Drücken eines Buttons hochgezählt wird.
Dies habe ich mit einem Observer realisiert und bis auf 2 Unklarheiten verstanden:
1. Erfolg meine Initialisierung an der richtigen Stelle? [siehe Klasse RunMVC Zeile 17]
2. Wie setze ich es um, wenn ich Beispielsweise einen 2.Button einbaue, der auf klick ein anderes Feld updaten soll? Es wird doch dann auch die update-Methode in der View angesprochen - wie Unterscheide ich hier dann?
Nun möchte ich im Zentrum (BorderPanel.Center) eine TreeView mit Checkboxen anlegen. (Für einen solchen Tree habe ich
Klassen und Methoden gefunden [siehe Klasse CheckBoxTree].
Bisher erzeuge ich den Tree noch statisch in der View (Methode: createPanelCenter) da ich nicht weiß wie und wo ich das eigentlich machen müsste.
Mein Ziel ist es beim Start der Anwendung eine Textdatei auszulesen, aus der ich die Daten für den Aufbau des Tree's auslese.
Nach MVC müsste doch beim Start der Controller eine Methode im Model aufrufen, welche die Datei ausließt, anschließend die Daten
irgendwie an die View übergibt und diese dann den Tree mit den übergebenen Werten zusammenbastelt, oder?
Vielen Dank schonmal für die Hilfe!
RunMVC
View
Model
Controller
Zeugs für CheckboxTree
Deshalb wollte ich mich mal an ein Beispiel waagen, um das Prinzip zu verstehen, Observer zu nutzen etc.
Meine Ausgangslage:
Ich hab eine View in der Rechts (BorderPanel.East) ein Counter durch das Drücken eines Buttons hochgezählt wird.
Dies habe ich mit einem Observer realisiert und bis auf 2 Unklarheiten verstanden:
1. Erfolg meine Initialisierung an der richtigen Stelle? [siehe Klasse RunMVC Zeile 17]
2. Wie setze ich es um, wenn ich Beispielsweise einen 2.Button einbaue, der auf klick ein anderes Feld updaten soll? Es wird doch dann auch die update-Methode in der View angesprochen - wie Unterscheide ich hier dann?
Nun möchte ich im Zentrum (BorderPanel.Center) eine TreeView mit Checkboxen anlegen. (Für einen solchen Tree habe ich
Klassen und Methoden gefunden [siehe Klasse CheckBoxTree].
Bisher erzeuge ich den Tree noch statisch in der View (Methode: createPanelCenter) da ich nicht weiß wie und wo ich das eigentlich machen müsste.
Mein Ziel ist es beim Start der Anwendung eine Textdatei auszulesen, aus der ich die Daten für den Aufbau des Tree's auslese.
Nach MVC müsste doch beim Start der Controller eine Methode im Model aufrufen, welche die Datei ausließt, anschließend die Daten
irgendwie an die View übergibt und diese dann den Tree mit den übergebenen Werten zusammenbastelt, oder?
Vielen Dank schonmal für die Hilfe!
RunMVC
Java:
package mvc_tree;
public class RunMVC {
private int start_value = 11;
public RunMVC() {
Model myModel = new Model();
View myView = new View();
myModel.addObserver(myView);
Controller myController = new Controller();
myController.addModel(myModel);
myController.addView(myView);
/*
* Ist das Initialisieren des Counters hier RICHTIG?
*/
myController.initModel(start_value);
myView.addController(myController);
}
}View
Java:
package mvc_tree;
import java.awt.BorderLayout;
import java.awt.FlowLayout;
import java.awt.Panel;
import java.awt.Frame;
import java.awt.event.WindowEvent;
import java.awt.event.WindowAdapter;
import java.lang.Integer;
import java.util.Observable;
import java.util.Vector;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextField;
import javax.swing.JTree;
class View implements java.util.Observer {
private JTextField _txtCounter;
private JButton _btnAddOne;
public View() {
System.out.println("View()");
Frame frame = new Frame("simple MVC");
Panel _pnl = new Panel();
_pnl.setLayout(new BorderLayout());
_pnl.add(createPanelEast(), BorderLayout.EAST);
_pnl.add(createPanelCenter(), BorderLayout.CENTER);
frame.add(_pnl);
frame.addWindowListener(new CloseListener());
frame.setSize(400, 400);
frame.setLocation(100, 100);
frame.setVisible(true);
}
private JComponent createPanelEast() {
JLabel lblCounter = new JLabel("counter");
_txtCounter = new JTextField(10);
_btnAddOne = new JButton("Add 1");
JPanel pnl = new JPanel();
pnl.setLayout(new FlowLayout(FlowLayout.LEFT));
pnl.add(lblCounter);
pnl.add(_txtCounter);
pnl.add(_btnAddOne);
return pnl;
}
private JComponent createPanelCenter(){
JPanel pnl = new JPanel();
pnl.setLayout(new BorderLayout());
CheckBoxNode testNodes1[] = {
new CheckBoxNode("bllaaa", true),
new CheckBoxNode("blii", true),
new CheckBoxNode("bluuu", true) };
CheckBoxNode testNodes2[] = {
new CheckBoxNode(
"foo", false),
new CheckBoxNode("bar", true) };
Vector node1Vector = new NamedVector("Rootnode 1",
testNodes2);
Vector node2Vector = new NamedVector("Rootnode 2", testNodes1);
Object rootNodes[] = { node1Vector, node2Vector };
Vector rootVector = new NamedVector("Root", rootNodes);
JTree tree = new JTree(rootVector);
CheckBoxNodeRenderer renderer = new CheckBoxNodeRenderer();
tree.setCellRenderer(renderer);
tree.setCellEditor(new CheckBoxNodeEditor(tree));
tree.setEditable(true);
JScrollPane scrollPane = new JScrollPane(tree);
pnl.add(scrollPane);
return pnl;
}
// Called from the Model
public void update(Observable obs, Object obj) {
_txtCounter.setText("" + ((Integer) obj).intValue()); // obj is an Object, need to
}
// to initialise TextField
public void setValue(int v) {
_txtCounter.setText("" + v);
}
public void addController(ActionListener controller) {
System.out.println("View : adding controller");
_btnAddOne.addActionListener(controller);
}
public static class CloseListener extends WindowAdapter {
public void windowClosing(WindowEvent e) {
e.getWindow().setVisible(false);
System.exit(0);
}
}
}Model
Java:
package mvc_tree;
public class Model extends java.util.Observable {
private int counter;
public Model() {
System.out.println("Model()");
}
public void setLabelCounter(int value) {
this.counter = value;
System.out.println("Model init: counter = " + counter);
setChanged();
notifyObservers(counter);
}
public void incrementValue() {
++counter;
System.out.println("Model : counter = " + counter);
setChanged();
notifyObservers(counter);
}
}Controller
Java:
package mvc_tree;
class Controller implements java.awt.event.ActionListener {
Model model;
View view;
public Controller() {
System.out.println ("Controller()");
}
public void actionPerformed(java.awt.event.ActionEvent e){
System.out.println("Controller: action Performed");
model.incrementValue();
}
public void addModel(Model m){
System.out.println("Controller: adding model");
this.model = m;
}
public void addView(View v){
System.out.println("Controller: adding view");
this.view = v;
}
/*
*
* Hier Methode zum ermitteln der Tree anstoßen?
* und setzen? aber wie?
*
*/
public void initModel(int x){
model.setLabelCounter(x);
}
}Zeugs für CheckboxTree
Java:
package mvc_tree;
import java.awt.Color;
import java.awt.Component;
import java.awt.Font;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.awt.event.MouseEvent;
import java.util.EventObject;
import java.util.Vector;
import javax.swing.AbstractCellEditor;
import javax.swing.JCheckBox;
import javax.swing.JTree;
import javax.swing.UIManager;
import javax.swing.event.ChangeEvent;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeCellRenderer;
import javax.swing.tree.TreeCellEditor;
import javax.swing.tree.TreeCellRenderer;
import javax.swing.tree.TreePath;
class CheckBoxNodeRenderer implements TreeCellRenderer {
private JCheckBox leafRenderer = new JCheckBox();
private DefaultTreeCellRenderer nonLeafRenderer = new DefaultTreeCellRenderer();
Color selectionBorderColor, selectionForeground, selectionBackground,
textForeground, textBackground;
protected JCheckBox getLeafRenderer() {
return leafRenderer;
}
public CheckBoxNodeRenderer() {
Font fontValue;
fontValue = UIManager.getFont("Tree.font");
if (fontValue != null) {
leafRenderer.setFont(fontValue);
}
Boolean booleanValue = (Boolean) UIManager
.get("Tree.drawsFocusBorderAroundIcon");
leafRenderer.setFocusPainted((booleanValue != null)
&& (booleanValue.booleanValue()));
selectionBorderColor = UIManager.getColor("Tree.selectionBorderColor");
selectionForeground = UIManager.getColor("Tree.selectionForeground");
selectionBackground = UIManager.getColor("Tree.selectionBackground");
textForeground = UIManager.getColor("Tree.textForeground");
textBackground = UIManager.getColor("Tree.textBackground");
}
public Component getTreeCellRendererComponent(JTree tree, Object value,
boolean selected, boolean expanded, boolean leaf, int row,
boolean hasFocus) {
Component returnValue;
if (leaf) {
String stringValue = tree.convertValueToText(value, selected,
expanded, leaf, row, false);
leafRenderer.setText(stringValue);
leafRenderer.setSelected(false);
leafRenderer.setEnabled(tree.isEnabled());
if (selected) {
leafRenderer.setForeground(selectionForeground);
leafRenderer.setBackground(selectionBackground);
} else {
leafRenderer.setForeground(textForeground);
leafRenderer.setBackground(textBackground);
}
if ((value != null) && (value instanceof DefaultMutableTreeNode)) {
Object userObject = ((DefaultMutableTreeNode) value)
.getUserObject();
if (userObject instanceof CheckBoxNode) {
CheckBoxNode node = (CheckBoxNode) userObject;
leafRenderer.setText(node.getText());
leafRenderer.setSelected(node.isSelected());
}
}
returnValue = leafRenderer;
} else {
returnValue = nonLeafRenderer.getTreeCellRendererComponent(tree,
value, selected, expanded, leaf, row, hasFocus);
}
return returnValue;
}
}
class CheckBoxNodeEditor extends AbstractCellEditor implements TreeCellEditor {
CheckBoxNodeRenderer renderer = new CheckBoxNodeRenderer();
ChangeEvent changeEvent = null;
JTree tree;
public CheckBoxNodeEditor(JTree tree) {
this.tree = tree;
}
public Object getCellEditorValue() {
JCheckBox checkbox = renderer.getLeafRenderer();
CheckBoxNode checkBoxNode = new CheckBoxNode(checkbox.getText(),
checkbox.isSelected());
return checkBoxNode;
}
public boolean isCellEditable(EventObject event) {
boolean returnValue = false;
if (event instanceof MouseEvent) {
MouseEvent mouseEvent = (MouseEvent) event;
TreePath path = tree.getPathForLocation(mouseEvent.getX(),
mouseEvent.getY());
if (path != null) {
Object node = path.getLastPathComponent();
if ((node != null) && (node instanceof DefaultMutableTreeNode)) {
DefaultMutableTreeNode treeNode = (DefaultMutableTreeNode) node;
Object userObject = treeNode.getUserObject();
returnValue = ((treeNode.isLeaf()) && (userObject instanceof CheckBoxNode));
}
}
}
return returnValue;
}
public Component getTreeCellEditorComponent(JTree tree, Object value,
boolean selected, boolean expanded, boolean leaf, int row) {
Component editor = renderer.getTreeCellRendererComponent(tree, value,
true, expanded, leaf, row, true);
// editor always selected / focused
ItemListener itemListener = new ItemListener() {
public void itemStateChanged(ItemEvent itemEvent) {
if (stopCellEditing()) {
fireEditingStopped();
}
}
};
if (editor instanceof JCheckBox) {
((JCheckBox) editor).addItemListener(itemListener);
}
return editor;
}
}
class CheckBoxNode {
String text;
boolean selected;
public CheckBoxNode(String text, boolean selected) {
this.text = text;
this.selected = selected;
}
public boolean isSelected() {
return selected;
}
public void setSelected(boolean newValue) {
selected = newValue;
}
public String getText() {
return text;
}
public void setText(String newValue) {
text = newValue;
}
public String toString() {
return getClass().getName() + "[" + text + "/" + selected + "]";
}
}
class NamedVector extends Vector {
String name;
public NamedVector(String name) {
this.name = name;
}
public NamedVector(String name, Object elements[]) {
this.name = name;
for (int i = 0, n = elements.length; i < n; i++) {
add(elements[i]);
}
}
public String toString() {
return "[" + name + "]";
}
}
Zuletzt bearbeitet:
