Hallo,
Ich versuche schon seit 2 Tagen unter meinem JTree und JTable Platz zu bekommen. Also ich möchte das unter den beiden Noch ca ein Bereich von 100Pixel frei bleibt wo ich z.B. Buttons einfügen kann !!!
Hier der Code:
Jemand ne Idee ???
Ich versuche schon seit 2 Tagen unter meinem JTree und JTable Platz zu bekommen. Also ich möchte das unter den beiden Noch ca ein Bereich von 100Pixel frei bleibt wo ich z.B. Buttons einfügen kann !!!
Hier der Code:
Java:
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.util.*;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.table.*;
import javax.swing.tree.*;
//import javazoom.jl.player.Player;
import javax.media.*;
public class MP3Player extends JFrame implements KeyListener, MouseListener, TreeSelectionListener {
// Anfang Attribute
private File[] mp3Files;
private File directory;
private Player player;
private DefaultMutableTreeNode root;
private final TreeTablePanel treeTablePanel;
private final JTree tree;
float laut=1.0f;
// Ende Attribute
public MP3Player() {
this.setTitle("MP3 Player");
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setSize(850, 500);
this.setLocationRelativeTo(null);
setLayout(new GridLayout());
this.directory = new File("music/");
if (!directory.isDirectory()) {
directory.mkdir();
System.err.println("Dies ist kein Verzeichnis: " + directory);
}
mp3Files = readDirectory();
// Anfang Komponenten
DefaultTreeModel model = new DefaultTreeModel(createTree(directory));
treeTablePanel = new TreeTablePanel(this, model, null);
treeTablePanel.setBorder(BorderFactory.createTitledBorder("Your Music: "));
tree = treeTablePanel.addTreeSelectionListener(this);
tree.setSelectionRow(1);
add(treeTablePanel, BorderLayout.CENTER);
this.setVisible(true);
addKeyListener(this);
addMouseListener(this);
laut = 1.0f;
// Ende Komponenten
}
// Anfang Methoden
private File[] readDirectory() {
File[] files = directory.listFiles(new FileFilter() {
@Override
public boolean accept(File currentFile) {
return currentFile.getName().toLowerCase().endsWith(".mp3");
}
});
return files;
}
public static void main(String[] args) {
new MP3Player();
}
public void valueChanged(TreeSelectionEvent e) {
TreePath selectionPath = tree.getSelectionPath();
if (selectionPath == null) {
return;
}
Object comp = selectionPath.getLastPathComponent();
TableNode node = (TableNode) ((DefaultMutableTreeNode) comp).getUserObject();
String path = node.getDataRow().get(0).toString();
File mp3ToPlay = new File(path);
if (!mp3ToPlay.exists() || !mp3ToPlay.isFile()) {
return;
}
if (player != null) {//javax.media.Player
player.stop();
}
this.play(mp3ToPlay);
}
private void play(File mp3) {
try {
player = Manager.createRealizedPlayer(mp3.toURI().toURL());//javax.media.Player
// BufferedInputStream input = new BufferedInputStream(new FileInputStream(mp3));
// player = new Player(input);
} catch (Exception e) {
System.out.println("Error: " + e);
}
Thread playInBackground = new Thread() {
@Override
public void run() {
try {
player.start();//javax.media.Player
player.getGainControl().setLevel(laut);
// player.play();
// player.close();
} catch (Exception e) {
System.out.println(e);
}
}
};
playInBackground.start();
}
private DefaultMutableTreeNode createTree(File directory) {
// create root node and add more nodes
root = new DefaultMutableTreeNode(new TableNode(directory.getName(), directory.getPath(), null));
load(root);
return root;
}
private void load(DefaultMutableTreeNode node) {
TableNode n = (TableNode) node.getUserObject();
String path = n.getDataRow().get(0).toString();
File f = new File(path);
if (f.isDirectory()) {
mp3Files = f.listFiles();
for (File file : mp3Files) {
DefaultMutableTreeNode newNode = new DefaultMutableTreeNode(
new TableNode(file.getName(), file.getPath(), file.length()));
if (file.isDirectory()) {
node.add(newNode);
load(newNode);
} else {
node.add(newNode);
}
}
}
}
public void keyPressed(KeyEvent e)
{
System.out.println("User pressed key " + e.getKeyCode());
}
public void keyReleased(KeyEvent e)
{
System.out.println("User released key " + e.getKeyCode());
}
public void keyTyped(KeyEvent e)
{
System.out.println("User typed key " + e.getKeyCode());
}
public void mouseClicked(MouseEvent e)
{
int x=e.getX();
int y=e.getY();
System.out.println("Maus at "+x+" "+y);
}
public void mouseEntered(MouseEvent e)
{
System.out.println("User clicked mouse " + e.getClickCount() + " times!");
}
public void mouseExited(MouseEvent e)
{
}
public void mousePressed(MouseEvent e)
{
}
public void mouseReleased(MouseEvent e)
{
}
public void mouseMoved(MouseEvent e)
{
}
public void mouseDragged(MouseEvent e)
{
}
// Ende Methoden
}
/** JTable that has different renderers depending on the classes in TreeModel */
class Table extends JTable {
void registerRenderers() {
// setDefaultRenderer(Color.class, new TableColorRenderer(Color.WHITE));
}
public Table() {
super();
registerRenderers();
}
public Table(TableModel dm) {
super(dm);
registerRenderers();
}
public Table(TableModel dm, TableColumnModel cm) {
super(dm, cm);
registerRenderers();
}
@Override
public TableCellRenderer getCellRenderer(int row, int column) {
Object value = getModel().getValueAt(row, column);
if (value == null) {
value = "";
}
/** enable to have custom renderers depending on class of cell */
TableCellRenderer tcr = getDefaultRenderer(value.getClass());
return tcr;
}
@Override
public Rectangle getCellRect(int row, int column, boolean includeSpacing) {
Rectangle sRect = super.getCellRect(row, column, includeSpacing);
if ((row < 0) || (column < 0) ||
(getRowCount() <= row) || (getColumnCount() <= column)) {
return sRect;
}
int index = 0;
int columnMargin = getColumnModel().getColumnMargin();
Rectangle cellFrame = new Rectangle();
if (column > 0 && shouldCombineCells(row)) {
return cellFrame;
}
int aCellHeight = rowHeight;
cellFrame.y = row * aCellHeight;
cellFrame.height = aCellHeight;
Enumeration enumeration = getColumnModel().getColumns();
while (enumeration.hasMoreElements()) {
TableColumn aColumn = (TableColumn) enumeration.nextElement();
cellFrame.width = aColumn.getWidth() + columnMargin;
if (index == column) {
break;
}
cellFrame.x += cellFrame.width;
index++;
}
while (enumeration.hasMoreElements() && shouldCombineCells(row)) {
TableColumn aColumn = (TableColumn) enumeration.nextElement();
cellFrame.width += aColumn.getWidth() + columnMargin;
}
if (!includeSpacing) {
Dimension spacing = getIntercellSpacing();
cellFrame.setBounds(cellFrame.x + spacing.width / 2,
cellFrame.y + spacing.height / 2,
cellFrame.width - spacing.width,
cellFrame.height - spacing.height);
}
return cellFrame;
}
private boolean shouldCombineCells(int row) {
TableAdapter model = (TableAdapter) getModel();
JTree tree = model.getTree();
DefaultMutableTreeNode node = (DefaultMutableTreeNode) tree.getPathForRow(row).getLastPathComponent();
return node.getLevel() < 1;
}
}
/*
JTree already has a good data model (DefaultTreeModel), and it's easier
to implement an adapter that simply puts a TableModel on top of the TreeModel,
rather than to implement JTree renderers in a JTable and work around the API
to achieve correct displays.
The class "TableAdapter" puts an AbstractTableModel on top of DefaultTreeModel
which is suggested by Swing for a JTree. The TableModel consists of the
dataRow vector from "TableNode". The TableAdapter is also responsible for
firing updates on the table data in case the JTree is collapsed or expanded.
*/
class TableAdapter extends AbstractTableModel {
private JTree tree;
private JTable table;
private int[] sel_rows;
private ListSelectionListener selectionListener;
private String[] columnNames = {"Path", "Size"};
public TableAdapter(JTree t) {
tree = t;
tree.addTreeExpansionListener(new TreeExpansionListener() {
public void treeExpanded(TreeExpansionEvent event) {
fireTableDataChanged();
select();
}
public void treeCollapsed(TreeExpansionEvent event) {
fireTableDataChanged();
select();
}
});
}
public void addTable(JTable t) {
table = t;
table.setBackground(Color.lightGray);
tree.addTreeSelectionListener(new TreeSelectionListener() {
public void valueChanged(TreeSelectionEvent e) {
sel_rows = tree.getSelectionRows();
select();
}
});
selectionListener = new ListSelectionListener() {
public void valueChanged(ListSelectionEvent e) {
int row = table.getSelectedRow();
tree.setSelectionRow(row);
table.repaint();
}
};
table.getSelectionModel().addListSelectionListener(selectionListener);
}
public JTree getTree() {
return tree;
}
private void select() {
if (sel_rows != null) {
table.getSelectionModel().setSelectionInterval(sel_rows[0], sel_rows[0]);
}
}
//assumes all nodes have same number of items as root node
public int getColumnCount() {
DefaultMutableTreeNode root = (DefaultMutableTreeNode) tree.getModel().getRoot();
TableNode n = (TableNode) root.getUserObject();
return n.getDataRow().size();
}
public int getRowCount() {
return tree.getRowCount();
}
@Override
public String getColumnName(int col) {
return columnNames[col];
}
public Object getValueAt(int row, int col) {
TreePath tPath = tree.getPathForRow(row);
Object[] oPath = tPath.getPath();
int len = oPath.length;
DefaultMutableTreeNode node = (DefaultMutableTreeNode) oPath[len - 1];
TableNode treeNode = (TableNode) node.getUserObject();
Vector dataRow = treeNode.getDataRow();
return dataRow.elementAt(col);
}
@Override
public void setValueAt(Object value, int row, int col) {
TreePath tPath = tree.getPathForRow(row);
Object[] oPath = tPath.getPath();
int len = oPath.length;
DefaultMutableTreeNode node = (DefaultMutableTreeNode) oPath[len - 1];
TableNode treeNode = (TableNode) node.getUserObject();
Vector dataRow = treeNode.getDataRow();
dataRow.setElementAt(value, col);
}
@Override
public Class getColumnClass(int c) {
DefaultMutableTreeNode root = (DefaultMutableTreeNode) tree.getModel().getRoot();
TableNode n = (TableNode) root.getUserObject();
return n.getDataRow().elementAt(c).getClass();
}
@Override
public boolean isCellEditable(int rowIndex, int columnIndex) {
return false;
}
}
/*
TreeModels contain DefaultMutableTreeNodes. Each DefaultMutableTreeNode
contains a UserObject for which we can easily create a class "TableNode"
having a String to be displayed in the JTree, and a vector of objects
to be displayed in the JTable.
*/
class TableNode {
private String label;
private Vector dataRow;
public TableNode(String s, Object x, Object y) {
label = s;
dataRow = new Vector();
dataRow.add(x);
dataRow.add(y);
}
@Override
public String toString() {
return label;
}
public Vector getDataRow() {
return dataRow;
}
}
class TreeTablePanel extends JPanel implements TableModelListener {
private JTree tree;
private Rectangle selectedRowBounds;
private Color selectionColor;
private TableAdapter adapter;
private Table table;
private JSplitPane splitPane;
private JTableHeader tableHeader;
private JButton btAdd;
private TreeTablePanel[] treeTablePanels;
private Frame frame;
private final JScrollPane scrollPane;
public TreeTablePanel(Frame frame, DefaultTreeModel model, TreeTablePanel[] treeTablePanels) {
super(new BorderLayout());
this.frame = frame;
this.treeTablePanels = treeTablePanels;
tree = new JTree(model) {
//Override paintComponent of JTree:
@Override
public void paintComponent(final Graphics g) {
if (selectedRowBounds != null) {
//Set selection Color:
g.setColor(selectionColor);
//Draw selection rectangle using the width of JTree:
g.fillRect(0, (int) selectedRowBounds.getY(), getWidth(), (int) selectedRowBounds.getHeight());
}
super.paintComponent(g);
}
};
adapter = new TableAdapter(tree);
table = new Table(adapter);
customizeTable(table);
customizeTree(tree, table);
customizeSplitpane(tree, table);
adapter.addTableModelListener(this);
//
scrollPane = new JScrollPane(splitPane);
add(scrollPane, BorderLayout.CENTER);
JPanel header = new JPanel(null);
tableHeader = table.getTableHeader();
header.add(tableHeader);
header.setPreferredSize(new Dimension(0, 16));
add(header, BorderLayout.NORTH);
btAdd = new JButton();
btAdd.setVisible(false);
add(btAdd, BorderLayout.SOUTH);
btAdd.setAction(new AbstractAction("Add") {
public void actionPerformed(ActionEvent e) {
DefaultMutableTreeNode n = new DefaultMutableTreeNode(new TableNode("NEW", "", Color.GREEN));
DefaultMutableTreeNode parent = (DefaultMutableTreeNode) tree.getLastSelectedPathComponent();
if (parent != null) {
parent.add(n);
((DefaultTreeModel) tree.getModel()).nodeStructureChanged(parent);
table.repaint();
validate();
}
}
});
}
private void customizeTable(final JTable table) {
table.getSelectionModel().setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
//connect Selection listeners
adapter.addTable(table);
table.setRowHeight(18);
table.addComponentListener(new ComponentAdapter() {
@Override
public void componentResized(ComponentEvent e) {
if (table.isShowing()) {
Point loc = table.getLocationOnScreen();
tableHeader.setBounds(
new Rectangle(loc.x - frame.getLocation().x - 3 -
getInsets().left, 0, 1100, 18));
tableHeader.setReorderingAllowed(false);
}
}
});
}
private void customizeTree(final JTree tree, final JTable table) {
tree.setShowsRootHandles(true);
tree.setRowHeight(table.getRowHeight());
tree.setFocusable(false);
selectionColor = table.getSelectionBackground();
tree.putClientProperty("JTree.lineStyle", "Horizontal");
tree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
tree.setOpaque(false);
//Adapt the default selection colors:
DefaultTreeCellRenderer renderer = (DefaultTreeCellRenderer) tree.getCellRenderer();
renderer.setBorderSelectionColor(Color.WHITE);
renderer.setBackgroundSelectionColor(new Color(0, 0, 0, 0));
//Add the TreeSelectionListener:
TreeSelectionModel selectionModel = tree.getSelectionModel();
selectionModel.addTreeSelectionListener(new TreeSelectionListener() {
public void valueChanged(final TreeSelectionEvent e) {
paintSelectionRect();
}
});
//Add the TreeExpansionListener:
tree.addTreeExpansionListener(new TreeExpansionListener() {
public void treeCollapsed(final TreeExpansionEvent event) {
paintSelectionRect();
}
public void treeExpanded(final TreeExpansionEvent event) {
paintSelectionRect();
}
});
//Add MouseListener if you want to listen to whole line width:
tree.addMouseListener(new MouseAdapter() {
@Override
public void mousePressed(final MouseEvent e) {
int row = tree.getClosestRowForLocation(e.getX(), e.getY());
if (e.getClickCount() == 2) {
if (tree.isCollapsed(row)) {
tree.expandRow(row);
} else {
tree.collapseRow(row);
}
} else {
tree.setSelectionRow(row);
}
}
});
}
private void customizeSplitpane(final JTree tree, final JTable table) {
splitPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, tree, table);
splitPane.setDividerLocation(250);
splitPane.setBackground(Color.WHITE);
splitPane.setContinuousLayout(true);
}
//This method is called in valueChanged, treeCollapsed and treeExpanded
//to paint the selection rectangle:
private void paintSelectionRect() {
//Get selected row bounds:
int[] rows = tree.getSelectionRows();
if (rows == null) {
selectedRowBounds = null;
return;
}
selectedRowBounds = tree.getRowBounds(rows[0]);
//Repaint the JTree:
tree.repaint();
}
public void tableChanged(TableModelEvent e) {
if (treeTablePanels != null) {
for (TreeTablePanel treeTablePanel : treeTablePanels) {
treeTablePanel.getTable().repaint();
}
}
}
public Table getTable() {
return table;
}
public JTree addTreeSelectionListener(TreeSelectionListener l) {
tree.getSelectionModel().addTreeSelectionListener(l);
return tree;
}
}Jemand ne Idee ???
