[client] rework tables to jtables for ImageListWindow

6 files changed, 753 insertions, 159 deletions

diff --git a/dozentenmodul/src/main/java/org/openslx/dozmod/gui/helper/ImageTableModel.java b/dozentenmodul/src/main/java/org/openslx/dozmod/gui/helper/ImageTableModel.java
new file mode 100644
index 00000000..443bb4c6
--- /dev/null
+++ b/dozentenmodul/src/main/java/org/openslx/dozmod/gui/helper/ImageTableModel.java
@@ -0,0 +1,69 @@
+package org.openslx.dozmod.gui.helper;
+
+import java.util.List;
+
+import javax.swing.table.AbstractTableModel;
+
+import org.openslx.bwlp.thrift.iface.ImageSummaryRead;
+import org.openslx.bwlp.thrift.iface.OperatingSystem;
+import org.openslx.bwlp.thrift.iface.UserInfo;
+import org.openslx.dozmod.thrift.MetaDataCache;
+import org.openslx.dozmod.thrift.UserCache;
+import org.openslx.dozmod.util.FormatHelper;
+
+public class ImageTableModel extends AbstractTableModel {
+
+	private static final long serialVersionUID = 3335684645951493805L;
+	protected String[] columnNames = new String[] {
+		"Name", "OS", "Verantwortlicher", "Letztes Update", "Größe"
+	};
+	protected Class<?>[] columnClasses = new Class[] { 
+			String.class, String.class, String.class, String.class, String.class
+	};
+	private List<ImageSummaryRead> items = null;
+
+	public ImageSummaryRead get(int index) {
+		return items.get(index);
+	}
+	public void setItems(List<ImageSummaryRead> items) {
+		this.items = items;
+		fireTableDataChanged();
+	}
+	@Override
+	public int getColumnCount() {
+		return columnNames.length;
+	}
+
+	public boolean isCellEditable(int row, int col)
+    { return false; }
+	
+	@Override
+	public int getRowCount() {
+		if (items == null) {
+			return 0;
+		}
+		return items.size();
+	}
+	public Class<?> getColumnClass(int c) {
+
+        return columnClasses[c];
+    }
+	public String getColumnName(int c) {
+
+        return columnNames[c];
+    }
+	@Override
+	public Object getValueAt(int rowIndex, int columnIndex) {
+		ImageSummaryRead item = items.get(rowIndex);
+		OperatingSystem os = MetaDataCache.getOsById(item.getOsId());
+		UserInfo user = UserCache.find(item.getOwnerId());
+		switch(columnIndex) {
+		    case 0: return item.getImageName();
+		    case 1: return os == null ? "Unknown" : os.getOsName();
+		    case 2: return FormatHelper.userName(user);
+		    case 3: return FormatHelper.shortDate(item.getUpdateTime());
+		    case 4: return item.getCurrentVersionId() == null ? "-" : FormatHelper.bytes(item.getFileSize(), false);
+		    default: return null;
+		}
+	}
+}
diff --git a/dozentenmodul/src/main/java/org/openslx/dozmod/gui/helper/ResizeColumnListener.java b/dozentenmodul/src/main/java/org/openslx/dozmod/gui/helper/ResizeColumnListener.java
new file mode 100644
index 00000000..104885fe
--- /dev/null
+++ b/dozentenmodul/src/main/java/org/openslx/dozmod/gui/helper/ResizeColumnListener.java
@@ -0,0 +1,74 @@
+package org.openslx.dozmod.gui.helper;
+
+import java.awt.*;
+import java.awt.event.*;
+import javax.swing.*;
+import javax.swing.table.*;
+
+public class ResizeColumnListener implements MouseListener {
+	private static Cursor resizeCursor = Cursor.getPredefinedCursor(Cursor.E_RESIZE_CURSOR);
+
+	private MouseListener uiListener;
+	private JTableHeader header;
+	private TableColumnAdjuster tca;
+
+	public ResizeColumnListener(JTable table) {
+		header = table.getTableHeader();
+		tca = new TableColumnAdjuster(table);
+
+		MouseListener[] listeners = header.getMouseListeners();
+
+		for (MouseListener ml : listeners) {
+			String className = ml.getClass().toString();
+
+			if (className.contains("BasicTableHeaderUI")) {
+				uiListener = ml;
+				header.removeMouseListener(ml);
+				header.addMouseListener(this);
+			}
+		}
+	}
+
+	@Override
+	public void mouseClicked(MouseEvent e) {
+		if (header.getCursor() != resizeCursor) {
+			uiListener.mouseClicked(e);
+			return;
+		}
+
+		// Handle the double click event to resize the column
+		// Note: The last 3 pixels + 3 pixels of next column are for resizing,
+		// so we need to adjust the mouse point to get the actual column.
+
+		if (e.getClickCount() == 2) {
+			Point p = e.getPoint();
+			p.x -= 3;
+			int column = header.columnAtPoint(p);
+			tca.adjustColumn(column);
+
+			// Generate event to reset the cursor
+			header.dispatchEvent(new MouseEvent(header, MouseEvent.MOUSE_MOVED, e.getWhen(), e.getModifiers(), e.getX(),
+					e.getY(), 0, false));
+		}
+	}
+
+	@Override
+	public void mouseEntered(MouseEvent e) {
+		uiListener.mouseEntered(e);
+	}
+
+	@Override
+	public void mouseExited(MouseEvent e) {
+		uiListener.mouseExited(e);
+	}
+
+	@Override
+	public void mousePressed(MouseEvent e) {
+		uiListener.mousePressed(e);
+	}
+
+	@Override
+	public void mouseReleased(MouseEvent e) {
+		uiListener.mouseReleased(e);
+	}
+}
\ No newline at end of file
diff --git a/dozentenmodul/src/main/java/org/openslx/dozmod/gui/helper/TableColumnAdjuster.java b/dozentenmodul/src/main/java/org/openslx/dozmod/gui/helper/TableColumnAdjuster.java
new file mode 100644
index 00000000..2e9da14c
--- /dev/null
+++ b/dozentenmodul/src/main/java/org/openslx/dozmod/gui/helper/TableColumnAdjuster.java
@@ -0,0 +1,391 @@
+package org.openslx.dozmod.gui.helper;
+
+import java.awt.Component;
+import java.awt.event.ActionEvent;
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
+import java.util.HashMap;
+import java.util.Map;
+
+import javax.swing.AbstractAction;
+import javax.swing.Action;
+import javax.swing.JTable;
+import javax.swing.KeyStroke;
+import javax.swing.SwingUtilities;
+import javax.swing.event.TableModelEvent;
+import javax.swing.event.TableModelListener;
+import javax.swing.table.TableCellRenderer;
+import javax.swing.table.TableColumn;
+import javax.swing.table.TableColumnModel;
+import javax.swing.table.TableModel;
+
+/*
+ *	Class to manage the widths of colunmns in a table.
+ *
+ *  Various properties control how the width of the column is calculated.
+ *  Another property controls whether column width calculation should be dynamic.
+ *  Finally, various Actions will be added to the table to allow the user
+ *  to customize the functionality.
+ *
+ *  This class was designed to be used with tables that use an auto resize mode
+ *  of AUTO_RESIZE_OFF. With all other modes you are constrained as the width
+ *  of the columns must fit inside the table. So if you increase one column, one
+ *  or more of the other columns must decrease. Because of this the resize mode
+ *  of RESIZE_ALL_COLUMNS will work the best.
+ */
+public class TableColumnAdjuster implements PropertyChangeListener, TableModelListener {
+	private JTable table;
+	private int spacing;
+	private boolean isColumnHeaderIncluded;
+	private boolean isColumnDataIncluded;
+	private boolean isOnlyAdjustLarger;
+	private boolean isDynamicAdjustment;
+	private Map<TableColumn, Integer> columnSizes = new HashMap<TableColumn, Integer>();
+
+	/*
+	 * Specify the table and use default spacing
+	 */
+	public TableColumnAdjuster(JTable table) {
+		this(table, 6);
+	}
+
+	/*
+	 * Specify the table and spacing
+	 */
+	public TableColumnAdjuster(JTable table, int spacing) {
+		this.table = table;
+		this.spacing = spacing;
+		setColumnHeaderIncluded(true);
+		setColumnDataIncluded(true);
+		setOnlyAdjustLarger(false);
+		setDynamicAdjustment(false);
+		installActions();
+	}
+
+	/*
+	 * Adjust the widths of all the columns in the table
+	 */
+	public void adjustColumns() {
+		TableColumnModel tcm = table.getColumnModel();
+
+		for (int i = 0; i < tcm.getColumnCount(); i++) {
+			adjustColumn(i);
+		}
+	}
+
+	/*
+	 * Adjust the width of the specified column in the table
+	 */
+	public void adjustColumn(final int column) {
+		TableColumn tableColumn = table.getColumnModel().getColumn(column);
+
+		if (!tableColumn.getResizable())
+			return;
+
+		int columnHeaderWidth = getColumnHeaderWidth(column);
+		int columnDataWidth = getColumnDataWidth(column);
+		int preferredWidth = Math.max(columnHeaderWidth, columnDataWidth);
+
+		updateTableColumn(column, preferredWidth);
+	}
+
+	/*
+	 * Calculated the width based on the column name
+	 */
+	private int getColumnHeaderWidth(int column) {
+		if (!isColumnHeaderIncluded)
+			return 0;
+
+		TableColumn tableColumn = table.getColumnModel().getColumn(column);
+		Object value = tableColumn.getHeaderValue();
+		TableCellRenderer renderer = tableColumn.getHeaderRenderer();
+
+		if (renderer == null) {
+			renderer = table.getTableHeader().getDefaultRenderer();
+		}
+
+		Component c = renderer.getTableCellRendererComponent(table, value, false, false, -1, column);
+		return c.getPreferredSize().width;
+	}
+
+	/*
+	 * Calculate the width based on the widest cell renderer for the given
+	 * column.
+	 */
+	private int getColumnDataWidth(int column) {
+		if (!isColumnDataIncluded)
+			return 0;
+
+		int preferredWidth = 0;
+		int maxWidth = table.getColumnModel().getColumn(column).getMaxWidth();
+
+		for (int row = 0; row < table.getRowCount(); row++) {
+			preferredWidth = Math.max(preferredWidth, getCellDataWidth(row, column));
+
+			// We've exceeded the maximum width, no need to check other rows
+
+			if (preferredWidth >= maxWidth)
+				break;
+		}
+
+		return preferredWidth;
+	}
+
+	/*
+	 * Get the preferred width for the specified cell
+	 */
+	private int getCellDataWidth(int row, int column) {
+		// Inovke the renderer for the cell to calculate the preferred width
+
+		TableCellRenderer cellRenderer = table.getCellRenderer(row, column);
+		Component c = table.prepareRenderer(cellRenderer, row, column);
+		int width = c.getPreferredSize().width + table.getIntercellSpacing().width;
+
+		return width;
+	}
+
+	/*
+	 * Update the TableColumn with the newly calculated width
+	 */
+	private void updateTableColumn(int column, int width) {
+		final TableColumn tableColumn = table.getColumnModel().getColumn(column);
+
+		if (!tableColumn.getResizable())
+			return;
+
+		width += spacing;
+
+		// Don't shrink the column width
+
+		if (isOnlyAdjustLarger) {
+			width = Math.max(width, tableColumn.getPreferredWidth());
+		}
+
+		columnSizes.put(tableColumn, new Integer(tableColumn.getWidth()));
+
+		table.getTableHeader().setResizingColumn(tableColumn);
+		tableColumn.setWidth(width);
+	}
+
+	/*
+	 * Restore the widths of the columns in the table to its previous width
+	 */
+	public void restoreColumns() {
+		TableColumnModel tcm = table.getColumnModel();
+
+		for (int i = 0; i < tcm.getColumnCount(); i++) {
+			restoreColumn(i);
+		}
+	}
+
+	/*
+	 * Restore the width of the specified column to its previous width
+	 */
+	private void restoreColumn(int column) {
+		TableColumn tableColumn = table.getColumnModel().getColumn(column);
+		Integer width = columnSizes.get(tableColumn);
+
+		if (width != null) {
+			table.getTableHeader().setResizingColumn(tableColumn);
+			tableColumn.setWidth(width.intValue());
+		}
+	}
+
+	/*
+	 * Indicates whether to include the header in the width calculation
+	 */
+	public void setColumnHeaderIncluded(boolean isColumnHeaderIncluded) {
+		this.isColumnHeaderIncluded = isColumnHeaderIncluded;
+	}
+
+	/*
+	 * Indicates whether to include the model data in the width calculation
+	 */
+	public void setColumnDataIncluded(boolean isColumnDataIncluded) {
+		this.isColumnDataIncluded = isColumnDataIncluded;
+	}
+
+	/*
+	 * Indicates whether columns can only be increased in size
+	 */
+	public void setOnlyAdjustLarger(boolean isOnlyAdjustLarger) {
+		this.isOnlyAdjustLarger = isOnlyAdjustLarger;
+	}
+
+	/*
+	 * Indicate whether changes to the model should cause the width to be
+	 * dynamically recalculated.
+	 */
+	public void setDynamicAdjustment(boolean isDynamicAdjustment) {
+		// May need to add or remove the TableModelListener when changed
+
+		if (this.isDynamicAdjustment != isDynamicAdjustment) {
+			if (isDynamicAdjustment) {
+				table.addPropertyChangeListener(this);
+				table.getModel().addTableModelListener(this);
+			} else {
+				table.removePropertyChangeListener(this);
+				table.getModel().removeTableModelListener(this);
+			}
+		}
+
+		this.isDynamicAdjustment = isDynamicAdjustment;
+	}
+
+	//
+	// Implement the PropertyChangeListener
+	//
+	public void propertyChange(PropertyChangeEvent e) {
+		// When the TableModel changes we need to update the listeners
+		// and column widths
+
+		if ("model".equals(e.getPropertyName())) {
+			TableModel model = (TableModel) e.getOldValue();
+			model.removeTableModelListener(this);
+
+			model = (TableModel) e.getNewValue();
+			model.addTableModelListener(this);
+			adjustColumns();
+		}
+	}
+
+	//
+	// Implement the TableModelListener
+	//
+	public void tableChanged(final TableModelEvent e) {
+		if (!isColumnDataIncluded)
+			return;
+
+		// Needed when table is sorted.
+
+		SwingUtilities.invokeLater(new Runnable() {
+			public void run() {
+				// A cell has been updated
+
+				int column = table.convertColumnIndexToView(e.getColumn());
+
+				if (e.getType() == TableModelEvent.UPDATE && column != -1) {
+					// Only need to worry about an increase in width for this
+					// cell
+
+					if (isOnlyAdjustLarger) {
+						int row = e.getFirstRow();
+						TableColumn tableColumn = table.getColumnModel().getColumn(column);
+
+						if (tableColumn.getResizable()) {
+							int width = getCellDataWidth(row, column);
+							updateTableColumn(column, width);
+						}
+					}
+
+					// Could be an increase of decrease so check all rows
+
+					else {
+						adjustColumn(column);
+					}
+				}
+
+				// The update affected more than one column so adjust all
+				// columns
+
+				else {
+					adjustColumns();
+				}
+			}
+		});
+	}
+
+	/*
+	 * Install Actions to give user control of certain functionality.
+	 */
+	private void installActions() {
+		installColumnAction(true, true, "adjustColumn", "control ADD");
+		installColumnAction(false, true, "adjustColumns", "control shift ADD");
+		installColumnAction(true, false, "restoreColumn", "control SUBTRACT");
+		installColumnAction(false, false, "restoreColumns", "control shift SUBTRACT");
+
+		installToggleAction(true, false, "toggleDynamic", "control MULTIPLY");
+		installToggleAction(false, true, "toggleLarger", "control DIVIDE");
+	}
+
+	/*
+	 * Update the input and action maps with a new ColumnAction
+	 */
+	private void installColumnAction(boolean isSelectedColumn, boolean isAdjust, String key, String keyStroke) {
+		Action action = new ColumnAction(isSelectedColumn, isAdjust);
+		KeyStroke ks = KeyStroke.getKeyStroke(keyStroke);
+		table.getInputMap().put(ks, key);
+		table.getActionMap().put(key, action);
+	}
+
+	/*
+	 * Update the input and action maps with new ToggleAction
+	 */
+	private void installToggleAction(boolean isToggleDynamic, boolean isToggleLarger, String key, String keyStroke) {
+		Action action = new ToggleAction(isToggleDynamic, isToggleLarger);
+		KeyStroke ks = KeyStroke.getKeyStroke(keyStroke);
+		table.getInputMap().put(ks, key);
+		table.getActionMap().put(key, action);
+	}
+
+	/*
+	 * Action to adjust or restore the width of a single column or all columns
+	 */
+	class ColumnAction extends AbstractAction {
+		private boolean isSelectedColumn;
+		private boolean isAdjust;
+
+		public ColumnAction(boolean isSelectedColumn, boolean isAdjust) {
+			this.isSelectedColumn = isSelectedColumn;
+			this.isAdjust = isAdjust;
+		}
+
+		@Override
+		public void actionPerformed(ActionEvent e) {
+			// Handle selected column(s) width change actions
+
+			if (isSelectedColumn) {
+				int[] columns = table.getSelectedColumns();
+
+				for (int i = 0; i < columns.length; i++) {
+					if (isAdjust)
+						adjustColumn(columns[i]);
+					else
+						restoreColumn(columns[i]);
+				}
+			} else {
+				if (isAdjust)
+					adjustColumns();
+				else
+					restoreColumns();
+			}
+		}
+	}
+
+	/*
+	 * Toggle properties of the TableColumnAdjuster so the user can customize
+	 * the functionality to their preferences
+	 */
+	class ToggleAction extends AbstractAction {
+		private boolean isToggleDynamic;
+		private boolean isToggleLarger;
+
+		public ToggleAction(boolean isToggleDynamic, boolean isToggleLarger) {
+			this.isToggleDynamic = isToggleDynamic;
+			this.isToggleLarger = isToggleLarger;
+		}
+
+		@Override
+		public void actionPerformed(ActionEvent e) {
+			if (isToggleDynamic) {
+				setDynamicAdjustment(!isDynamicAdjustment);
+				return;
+			}
+
+			if (isToggleLarger) {
+				setOnlyAdjustLarger(!isOnlyAdjustLarger);
+				return;
+			}
+		}
+	}
+}
\ No newline at end of file
diff --git a/dozentenmodul/src/main/java/org/openslx/dozmod/gui/helper/TableRenderer.java b/dozentenmodul/src/main/java/org/openslx/dozmod/gui/helper/TableRenderer.java
new file mode 100644
index 00000000..eaaee8bf
--- /dev/null
+++ b/dozentenmodul/src/main/java/org/openslx/dozmod/gui/helper/TableRenderer.java
@@ -0,0 +1,23 @@
+package org.openslx.dozmod.gui.helper;
+
+import java.awt.Component;
+
+import javax.swing.JTable;
+import javax.swing.table.DefaultTableCellRenderer;
+
+/**
+ * This renderer simply removes the default dotted border when
+ * a cell is selected
+ * @author joe
+ *
+ */
+public class TableRenderer extends DefaultTableCellRenderer {
+
+    @Override
+    public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
+        super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column); 
+        setBorder(noFocusBorder);
+        return this;
+    }
+
+}
\ No newline at end of file
diff --git a/dozentenmodul/src/main/java/org/openslx/dozmod/gui/window/ImageListWindow.java b/dozentenmodul/src/main/java/org/openslx/dozmod/gui/window/ImageListWindow.java
index 2392409e..bd820ff7 100644
--- a/dozentenmodul/src/main/java/org/openslx/dozmod/gui/window/ImageListWindow.java
+++ b/dozentenmodul/src/main/java/org/openslx/dozmod/gui/window/ImageListWindow.java
@@ -1,13 +1,19 @@
 package org.openslx.dozmod.gui.window;
 
-import java.util.List;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+import java.util.ArrayList;
+
+import javax.swing.RowFilter;
+import javax.swing.RowSorter;
+import javax.swing.RowSorter.SortKey;
+import javax.swing.SortOrder;
+import javax.swing.SwingUtilities;
+import javax.swing.event.ListSelectionEvent;
+import javax.swing.event.ListSelectionListener;
+import javax.swing.table.TableRowSorter;
 
 import org.apache.log4j.Logger;
-import org.eclipse.jface.viewers.DoubleClickEvent;
-import org.eclipse.jface.viewers.IDoubleClickListener;
-import org.eclipse.jface.viewers.ISelectionChangedListener;
-import org.eclipse.jface.viewers.IStructuredSelection;
-import org.eclipse.jface.viewers.SelectionChangedEvent;
 import org.eclipse.jface.window.Window;
 import org.eclipse.jface.wizard.WizardDialog;
 import org.eclipse.swt.events.KeyAdapter;
@@ -21,101 +27,49 @@ import org.openslx.bwlp.thrift.iface.ImageSummaryRead;
 import org.openslx.bwlp.thrift.iface.UserInfo;
 import org.openslx.dozmod.gui.Gui;
 import org.openslx.dozmod.gui.MainWindow;
-import org.openslx.dozmod.gui.helper.ImageListComparator;
-import org.openslx.dozmod.gui.helper.ImageListFilter;
+import org.openslx.dozmod.gui.helper.ImageTableModel;
 import org.openslx.dozmod.gui.helper.MessageType;
-import org.openslx.dozmod.gui.helper.TableHelper;
+import org.openslx.dozmod.gui.helper.TableColumnAdjuster;
 import org.openslx.dozmod.gui.window.layout.ImageListWindowLayout;
 import org.openslx.dozmod.gui.wizard.ImageWizard;
 import org.openslx.dozmod.thrift.ImageCache;
-import org.openslx.dozmod.thrift.Session;
 import org.openslx.dozmod.thrift.UserCache;
 import org.openslx.dozmod.util.FormatHelper;
-import org.openslx.thrifthelper.ThriftManager;
-import org.openslx.util.QuickTimer;
-import org.openslx.util.QuickTimer.Task;
 
 public class ImageListWindow extends ImageListWindowLayout {
 
 	private final static Logger LOGGER = Logger.getLogger(ImageListWindow.class);
 
+	TableRowSorter<ImageTableModel> sorter = new TableRowSorter<ImageTableModel>();
 
 	public ImageListWindow(final Shell mainShell) {
 		super(mainShell);
-
-		// Comparator for column sorting
-		ImageListComparator comparator = new ImageListComparator();
-		tableViewer.setComparator(comparator);
-		// creating the columns with sorting functionality through comparator
-		TableHelper.createImageTableColumns(tableViewer);
-
+      
+		SwingUtilities.invokeLater(new Runnable() {
+			public void run() {
+				ImageTableModel itm = new ImageTableModel();
+				sorter.setSortsOnUpdates(true);
+				sorter.setModel(itm);
+				ArrayList<SortKey> list = new ArrayList<SortKey>();
+				list.add( new RowSorter.SortKey(0, SortOrder.ASCENDING) );
+				sorter.setSortKeys(list);
+				jtable.setRowSorter(sorter);
+				jtable.setModel(itm);
+			}
+		});
 		// filter the objects in the table depending on the search field
 		searchTextField.addKeyListener(new KeyAdapter() {
 			public void keyReleased(KeyEvent ke) {
-				filter.setSearchText(searchTextField.getText());
-				tableViewer.refresh();
-			}
-		});
-
-		// apply object filtering
-		filter = new ImageListFilter();
-		tableViewer.addFilter(filter);
-
-		// the listeners to set the detailed info of the selected image
-		tableViewer.addSelectionChangedListener(new ISelectionChangedListener() {
-			@Override
-			public void selectionChanged(SelectionChangedEvent event) {
-				IStructuredSelection selection = (IStructuredSelection) event.getSelection();
-				ImageSummaryRead image = (ImageSummaryRead) selection.getFirstElement();
-				if (image == null)
-					return;
-				// -- Set details --
-				// set the image name
-				setFieldText(imageSelectedNameLabel, image.getImageName());
-				// set the image
-				setFieldText(idInfo, image.getImageBaseId());
-				// set the current version of the image
-				setFieldText(versionInfo, image.getCurrentVersionId());
-				// set the time, the image has last been updated
-				lastUpdateInfo.setText(FormatHelper.shortDate(image.getUpdateTime()));
-				// info about the image permissions
-				ImagePermissions perms = image.getUserPermissions();
-				if (perms == null)
-					perms = image.getDefaultPermissions();
-				if (perms != null)
-					setFieldText(permissionInfo, perms.toString());
-				// the owner id of the selected image
-				UserInfo user = UserCache.find(image.getOwnerId());
-				setFieldText(ownerInfo, FormatHelper.userName(user));
-
-				// set the template info
-				if (image.isTemplate) {
-					templateInfo.setText("ja");
-				} else {
-					templateInfo.setText("Nein");
-				}
-			}
-
-			private void setFieldText(Text control, String content) {
-				if (content == null) {
-					control.setText("<null>");
-				} else {
-					control.setText(content);
-				}
-			}
-		});
-
-		// Double click entry -> open details window
-		tableViewer.addDoubleClickListener(new IDoubleClickListener() {
-			@Override
-			public void doubleClick(DoubleClickEvent event) {
-				IStructuredSelection selection = (IStructuredSelection) event.getSelection();
-				ImageSummaryRead image = (ImageSummaryRead) selection.getFirstElement();
-				if (image == null)
-					return;
-				ImageDetailsWindow popup = MainWindow.openPopup(ImageDetailsWindow.class, true, false);
-				if (popup != null)
-					popup.setImage(image.getImageBaseId());
+				Gui.asyncExec(new Runnable() {
+					public void run() {
+						RowFilter<ImageTableModel, Object> filter = null;
+						try {
+							filter = RowFilter.regexFilter(".*" + searchTextField.getText() + ".*");
+					    } catch (java.util.regex.PatternSyntaxException e) {
+					        return;
+					    }
+						sorter.setRowFilter(filter);
+					}});
 			}
 		});
 
@@ -137,72 +91,92 @@ public class ImageListWindow extends ImageListWindowLayout {
 			}
 		});
 
-		//deleteImageVersion
-		deleteButton.addSelectionListener(new SelectionAdapter() {
+
+		// return to mainMenu
+		backButton.addSelectionListener(new SelectionAdapter() {
 			@Override
-			public void widgetSelected(final SelectionEvent e) {
-				IStructuredSelection selection = (IStructuredSelection) tableViewer.getSelection();
-				if (selection == null) {
-					MainWindow.showMessageBox("SELECIT ONULL!", MessageType.ERROR, LOGGER, null);
-					return;
+			public void widgetSelected(SelectionEvent e) {
+//				MainWindow.showPage(MainMenuWindow.class);
+				refreshList(true);
+			}
+		});
+		
+		// SWING TABLE STUFF
+		jtable.getSelectionModel().addListSelectionListener(new ListSelectionListener() {
+			
+			@Override
+			public void valueChanged(ListSelectionEvent e) {
+				ImageTableModel model = (ImageTableModel) jtable.getModel();
+				int rowIndex = jtable.getSelectedRow();
+				ImageSummaryRead image = null;
+				if (rowIndex != -1) {
+					image = model.get(jtable.convertRowIndexToModel(jtable.getSelectedRow()));
+					LOGGER.debug(image.toString());
+				} else {
+					LOGGER.error("No selection!");
 				}
-				final ImageSummaryRead image = (ImageSummaryRead) selection.getFirstElement();
-				if (image == null) {
-					MainWindow.showMessageBox("IMAGE ONULL!", MessageType.ERROR, LOGGER, null);
+				final ImageSummaryRead finalImage = image;
+				if (image == null)
 					return;
-				}
-				LOGGER.debug("Trying to delete: " + image);
-
-				QuickTimer.scheduleOnce(new Task() {
-					@Override
-					public void fire() {
-						Throwable t = null;
-						try {
-							ThriftManager.getSatClient().deleteImageVersion(Session.getSatelliteToken(),
-									image.getCurrentVersionId());
-						} catch (Exception e) {
-							t = e;
-						}
-						final Throwable t2 = t;
-						Gui.display.asyncExec(new Runnable() {
-							@Override
-							public void run() {
-								deleteCallback(image, t2);
-							}
-						});
+				Gui.asyncExec(new Runnable() {
+					public void run() {
+						updateDetailPane(finalImage);
 					}
 				});
 			}
 		});
-
-		// return to mainMenu
-		backButton.addSelectionListener(new SelectionAdapter() {
-			@Override
-			public void widgetSelected(SelectionEvent e) {
-				MainWindow.showPage(MainMenuWindow.class);
-			}
+		jtable.addMouseListener(new MouseAdapter() {
+		    public void mousePressed(MouseEvent me) {
+		        if (me.getClickCount() == 2) {
+		            // your valueChanged overridden method
+					ImageTableModel model = (ImageTableModel) jtable.getModel();
+					int rowIndex = jtable.getSelectedRow();
+					ImageSummaryRead image = null;
+					if (rowIndex != -1) {
+						image = model.get(jtable.convertRowIndexToModel(rowIndex));
+						LOGGER.debug(image.toString());
+					} else {
+						LOGGER.error("No selection!");
+					}
+					final ImageSummaryRead finalImage = image;
+					if (finalImage == null)
+						return;
+					Gui.asyncExec(new Runnable() {
+						public void run() {
+							ImageDetailsWindow popup = MainWindow.openPopup(ImageDetailsWindow.class, true, false);
+							if (popup != null)
+								popup.setImage(finalImage.getImageBaseId());
+						}
+					});
+		        }
+		    }
 		});
+
 	}
 
 	private void refreshList(final boolean forceRefresh) {
 		if (isDisposed())
 			return;
-		tableViewer.getTable().setEnabled(false);
-		QuickTimer.scheduleOnce(new Task() {
+		SwingUtilities.invokeLater(new Runnable() {
 			@Override
-			public void fire() {
-				final List<ImageSummaryRead> imageList = ImageCache.get(forceRefresh);
-				Gui.asyncExec(new Runnable() {
-					@Override
-					public void run() {
-						if (isDisposed())
-							return;
-						tableViewer.setInput(imageList);
-						tableViewer.refresh();
-						tableViewer.getTable().setEnabled(true);
-						newButton.setFocus();
-					}
-				});
+			public void run() {
+				ImageTableModel itm = (ImageTableModel) jtable.getModel();
+				itm.setItems(ImageCache.get(forceRefresh));
+				itm.fireTableDataChanged();
+			
+				if (sorter.getSortKeys().isEmpty()) {
+					ArrayList<SortKey> list = new ArrayList<SortKey>();
+					list.add( new RowSorter.SortKey(0, SortOrder.ASCENDING) );
+					sorter.setSortKeys(list);
+					LOGGER.debug("Sortkeys: " + sorter.getSortKeys().get(0).getColumn());
+				} else {
+					LOGGER.debug("Existing: " + sorter.getSortKeys().get(0).getColumn());
+				}
+
+				sorter.sort();
+				TableColumnAdjuster tca = new TableColumnAdjuster(jtable);
+				tca.adjustColumns();
+
 			}
 		});
 	}
@@ -226,8 +200,37 @@ public class ImageListWindow extends ImageListWindowLayout {
 		}
 	}
 
-	public ImageSummaryRead getCurrentImageSummaryRead() {
-		IStructuredSelection selection = (IStructuredSelection) tableViewer.getSelection();
-		return (ImageSummaryRead) selection.getFirstElement();
+	public void updateDetailPane(ImageSummaryRead image) {
+		// -- Set details --
+		// set the image name
+		setFieldText(imageSelectedNameLabel, image.getImageName());
+		// set the image
+		setFieldText(idInfo, image.getImageBaseId());
+		// set the current version of the image
+		setFieldText(versionInfo, image.getCurrentVersionId());
+		// set the time, the image has last been updated
+		lastUpdateInfo.setText(FormatHelper.shortDate(image.getUpdateTime()));
+		// info about the image permissions
+		ImagePermissions perms = image.getUserPermissions();
+		if (perms == null)
+			perms = image.getDefaultPermissions();
+		if (perms != null)
+			setFieldText(permissionInfo, perms.toString());
+		// the owner id of the selected image
+		UserInfo user = UserCache.find(image.getOwnerId());
+		setFieldText(ownerInfo, FormatHelper.userName(user));
+		// set the template info
+		if (image.isTemplate) {
+			templateInfo.setText("ja");
+		} else {
+			templateInfo.setText("Nein");
+		}
+	}
+	private void setFieldText(Text control, String content) {
+		if (content == null) {
+			control.setText("<null>");
+		} else {
+			control.setText(content);
+		}
 	}
 }
diff --git a/dozentenmodul/src/main/java/org/openslx/dozmod/gui/window/layout/ImageListWindowLayout.java b/dozentenmodul/src/main/java/org/openslx/dozmod/gui/window/layout/ImageListWindowLayout.java
index 6397c820..4133c835 100644
--- a/dozentenmodul/src/main/java/org/openslx/dozmod/gui/window/layout/ImageListWindowLayout.java
+++ b/dozentenmodul/src/main/java/org/openslx/dozmod/gui/window/layout/ImageListWindowLayout.java
@@ -1,8 +1,18 @@
 package org.openslx.dozmod.gui.window.layout;
 
-import org.eclipse.jface.viewers.ArrayContentProvider;
-import org.eclipse.jface.viewers.TableViewer;
+import java.awt.BorderLayout;
+import java.awt.Frame;
+
+import javax.swing.JPanel;
+import javax.swing.JRootPane;
+import javax.swing.JScrollPane;
+import javax.swing.JTable;
+import javax.swing.ListSelectionModel;
+import javax.swing.SwingUtilities;
+
+import org.apache.log4j.Logger;
 import org.eclipse.swt.SWT;
+import org.eclipse.swt.awt.SWT_AWT;
 import org.eclipse.swt.graphics.Font;
 import org.eclipse.swt.graphics.FontData;
 import org.eclipse.swt.layout.GridData;
@@ -12,14 +22,16 @@ import org.eclipse.swt.widgets.Button;
 import org.eclipse.swt.widgets.Composite;
 import org.eclipse.swt.widgets.Group;
 import org.eclipse.swt.widgets.Label;
-import org.eclipse.swt.widgets.Table;
 import org.eclipse.swt.widgets.Text;
 import org.openslx.dozmod.gui.Gui;
 import org.openslx.dozmod.gui.helper.CompositePage;
-import org.openslx.dozmod.gui.helper.ImageListFilter;
+import org.openslx.dozmod.gui.helper.ResizeColumnListener;
+import org.openslx.dozmod.gui.helper.TableRenderer;
 
 public abstract class ImageListWindowLayout extends CompositePage {
 
+	private final static Logger LOGGER = Logger.getLogger(ImageListWindowLayout.class);
+
 	protected String infoTitleString = "Übersicht Virtuelle Maschinen";
 	protected String newButtonLabel = "Neu";
 	protected String editButtonLabel = "Bearbeiten";
@@ -48,9 +60,8 @@ public abstract class ImageListWindowLayout extends CompositePage {
 	protected Text templateInfo;
 
 	protected final Text searchTextField;
-
-	protected final TableViewer tableViewer;
-	protected ImageListFilter filter;
+	
+	protected JTable jtable;
 
 	protected String infoTextString = "Hier können Sie Virtuelle Maschinen hochladen, herunterladen, bearbeiten und löschen.";
 
@@ -81,7 +92,7 @@ public abstract class ImageListWindowLayout extends CompositePage {
 
 
 		// -- group for the table --
-		Group tableGroup = new Group(this, SWT.BORDER);
+		final Group tableGroup = new Group(this, SWT.BORDER);
 		tableGroup.setText(tableGroupLabel);
 		GridData tgLayoutData = new GridData(SWT.FILL, SWT.FILL, true, true);
 		tgLayoutData.minimumWidth = 400;
@@ -103,18 +114,41 @@ public abstract class ImageListWindowLayout extends CompositePage {
 		searchTextField.setMessage("Name, Verantwortlicher, OS");
 		// -- end group of filter --
 
-		// table
-		Table vmTable = new Table(tableGroup, SWT.BORDER | SWT.V_SCROLL | SWT.H_SCROLL);
-		GridData tableGridData = new GridData(SWT.FILL, SWT.FILL, true, true);
-		vmTable.setLayoutData(tableGridData);
-		vmTable.setHeaderVisible(true);
-		vmTable.setLinesVisible(true);
-
-		// TableViewer on the table
-		tableViewer = new TableViewer(vmTable);
-		tableViewer.setContentProvider(ArrayContentProvider.getInstance());
-
-
+		// table composite to embed the swing table
+		final Composite comp = new Composite(tableGroup, SWT.NO_BACKGROUND | SWT.EMBEDDED);
+		comp.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
+		final Frame frame = SWT_AWT.new_Frame(comp);
+		SwingUtilities.invokeLater(new Runnable() {
+			public void run() {
+				try {
+					System.setProperty("sun.awt.noerasebackground", "true");
+				} catch (NoSuchMethodError error) {
+					LOGGER.error("BAD");
+				}
+				// auto-resize-on-scroll http://stackoverflow.com/questions/17858132/automatically-adjust-jtable-column-to-fit-content
+				JPanel panel = new JPanel(new BorderLayout());
+				frame.add(panel);
+				JRootPane root = new JRootPane();
+				panel.add(root);
+				java.awt.Container contentPane = root.getContentPane();
+				// init table
+				jtable = new JTable();
+				jtable.setShowGrid(false);
+				jtable.setCellSelectionEnabled(false);
+				jtable.createDefaultColumnsFromModel();
+				jtable.setAutoCreateRowSorter(true);
+				jtable.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
+				jtable.getTableHeader().setReorderingAllowed(false);
+				jtable.setDefaultRenderer(Object.class, new TableRenderer());
+				jtable.setRowSelectionAllowed(true);
+				jtable.getSelectionModel().setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
+//				jtable.setFont(new java.awt.Font("URW Gothic", java.awt.Font.PLAIN, 12));
+				new ResizeColumnListener(jtable);
+				JScrollPane scrollPane = new JScrollPane(jtable);
+				contentPane.setLayout(new BorderLayout());
+				contentPane.add(scrollPane);
+			}
+		});
 
 		// create, modify, download and delete buttons
 		Composite buttonComposite = new Composite(tableGroup, SWT.NONE);