}

// -------------------------- INNER CLASSES --------------------------

	private static class ColorFiltersTreeTableModel extends DefaultTreeTableModel
	{
		public ColorFiltersTreeTableModel( List<ColorFilterGroup> colorFilterGroups )
		{
			super( createNodes( colorFilterGroups ) );
		}

		private static TreeTableNode createNodes( List<ColorFilterGroup> colorFilterGroups )
		{
			DefaultMutableTreeTableNode root = new DefaultMutableTreeTableNode( colorFilterGroups );
			for (ColorFilterGroup colorFilterGroup : colorFilterGroups)
			{
				DefaultMutableTreeTableNode groupNode = new DefaultMutableTreeTableNode( colorFilterGroup );
				List<LogEntryColorFilter> colorFilters = colorFilterGroup.getColorFilters();
				for (LogEntryColorFilter colorFilter : colorFilters)
				{
					DefaultMutableTreeTableNode colorFilterNode = new DefaultMutableTreeTableNode( colorFilter );
					groupNode.add( colorFilterNode );
				}
				root.add( groupNode );
			}

			return root;
		}

		public int getColumnCount()
		{
			return 2;
		}

		public Object getValueAt( Object node, int column )
		{
			if (node instanceof AbstractMutableTreeTableNode)
			{
				if (column == 2)
				{
					return node;
				}
				if (getUserObject( node ) instanceof ColorFilterGroup)
				{
					ColorFilterGroup group = (ColorFilterGroup)getUserObject( node );
					switch (column)
					{
						case 0:
							return group.getName();
					}
				}
				else if (getUserObject( node ) instanceof LogEntryColorFilter)
				{
					LogEntryColorFilter filter = (LogEntryColorFilter)getUserObject( node );
					switch (column)
					{
						case 0:
							return filter.getName();
						case 1:
							return filter.getColor();
					}
				}
			}

			return null;
		}

		private Object getUserObject( Object node )
		{
			return ((AbstractMutableTreeTableNode)node).getUserObject();
		}

		@Override
		public String getColumnName( int column )
		{
			switch (column)
			{
				case 0:
					return bundle.getString( "color.filter.table.name" );
				case 1:
					return bundle.getString( "color.filter.table.color" );
				default:
					throw new IllegalArgumentException( "Unknown column: " + column );
			}
		}

		@Override
		public Class<?> getColumnClass( int column )
		{
			switch (column)
			{
				case 0:
					return String.class;
				case 1:
					return Color.class;
			}

			return Object.class;
		}

		@Override
		public boolean isLeaf( Object o )
		{
			return o instanceof DefaultMutableTreeTableNode &&
					((DefaultMutableTreeTableNode)o).getUserObject() instanceof LogEntryColorFilter;
		}
	}

	private static class ColorFiltersTreeCellRenderer extends DefaultTreeCellRenderer
	{
		@Override
		public Component getTreeCellRendererComponent( JTree tree, Object value, boolean sel, boolean expanded, boolean leaf, int row, boolean hasFocus )
		{
			JLabel result = (JLabel)super.getTreeCellRendererComponent( tree, value, sel, expanded, leaf, row, hasFocus );
			if (((DefaultMutableTreeTableNode)value).getUserObject() instanceof ColorFilterGroup)
			{
				result.setText( ((ColorFilterGroup)((DefaultMutableTreeTableNode)value).getUserObject()).getName() );
			}
			else if (((DefaultMutableTreeTableNode)value).getUserObject() instanceof LogEntryColorFilter)
			{
				result.setText( ((LogEntryColorFilter)((DefaultMutableTreeTableNode)value).getUserObject()).getName() );
			}
			return result;
		}
	}

	private class ColorFiltersListSelectionListener implements TreeSelectionListener
	{
		public ColorFiltersListSelectionListener()
		{
		}

		public void valueChanged( TreeSelectionEvent e )
		{
			if (e.getOldLeadSelectionPath() != null)
			{
				DefaultMutableTreeTableNode node = (DefaultMutableTreeTableNode)e.getOldLeadSelectionPath().getLastPathComponent();
				if (node.getUserObject() instanceof LogEntryColorFilter)
				{
					checkColorFilterPanelForChanges( node );
				}
				else if (node.getUserObject() instanceof ColorFilterGroup)
				{
					checkColorFilterGroupPanelForChanges( node );
				}
			}

			TreePath newPath = e.getNewLeadSelectionPath();
			if (newPath != null)
			{
				DefaultMutableTreeTableNode mutableTreeTableNode = (DefaultMutableTreeTableNode)newPath.getLastPathComponent();
				if (mutableTreeTableNode.getUserObject() instanceof ColorFilterGroup)
				{
					updateViewForColorFilterGroup( mutableTreeTableNode );
				}
				else if (mutableTreeTableNode.getUserObject() instanceof LogEntryColorFilter)
				{
					updateViewForColorFilter( mutableTreeTableNode );
				}
				else
				{
					updateViewForNoSelection();
				}
			}
			else
			{
				updateViewForNoSelection();
			}
		}

		private void updateViewForColorFilter( DefaultMutableTreeTableNode mutableTreeTableNode )
		{
			addGroupButton.setEnabled( true );
			addFilterButton.setEnabled( false );
			deleteButton.setEnabled( true );
			LogEntryColorFilter filter = (LogEntryColorFilter)mutableTreeTableNode.getUserObject();
			if (filter != null)
			{
				colorFilterPanel.setColorFilter( filter );
				editPanelWrapper.removeAll();
				editPanelWrapper.add( Box.createVerticalStrut( 30 ) );
				editPanelWrapper.add( colorFilterPanel );
				editPanelWrapper.add( Box.createVerticalGlue() );

			editPanelUpdated();
		}
	}

	private class AddGroupAction extends AbstractAction
	{
		public AddGroupAction()
		{
			super( bundle.getString( "color.filter.group.add" ), new ImageIcon( AddGroupAction.class.getResource( "folder-new.png" ) ) );
		}

		public void actionPerformed( ActionEvent e )
		{
			ColorFilterGroup filterGroup = new ColorFilterGroup( bundle.getString( "color.filter.unnamed" ) );
			DefaultMutableTreeTableNode node = new DefaultMutableTreeTableNode( filterGroup );
			ColorFiltersTreeTableModel tableModel = (ColorFiltersTreeTableModel)treeTable.getTreeTableModel();
			DefaultMutableTreeTableNode root = (DefaultMutableTreeTableNode)tableModel.getRoot();
			tableModel.insertNodeInto( node, root, root.getChildCount() );
			treeTable.getTreeSelectionModel().setSelectionPath( new TreePath( tableModel.getPathToRoot( node ) ) );
		}
	}

	private class AddFilterAction extends AbstractAction
	{
		public AddFilterAction()
		{
			super( bundle.getString( "color.filter.add" ), new ImageIcon( AddFilterAction.class.getResource( "document-new.png" ) ) );
		}

		public void actionPerformed( ActionEvent e )
		{
			LogEntryColorFilter filter = new LogEntryColorFilter();
			filter.setName( bundle.getString( "color.filter.unnamed" ) );
			filter.setColor( Color.RED );
			DefaultMutableTreeTableNode node = new DefaultMutableTreeTableNode( filter );
			TreePath selectionPath = treeTable.getTreeSelectionModel().getSelectionPath();

			ColorFiltersTreeTableModel tableModel = (ColorFiltersTreeTableModel)treeTable.getTreeTableModel();
			DefaultMutableTreeTableNode groupNode = (DefaultMutableTreeTableNode)selectionPath.getLastPathComponent();
			ColorFilterGroup filterGroup = (ColorFilterGroup)groupNode.getUserObject();
			filterGroup.addColorFilter( filter );
			tableModel.insertNodeInto( node, groupNode, groupNode.getChildCount() );
			treeTable.getTreeSelectionModel().setSelectionPath( new TreePath( tableModel.getPathToRoot( node ) ) );
		}
	}

	private class DeleteAction extends AbstractAction
	{
		public DeleteAction()
		{
			super( bundle.getString( "button.remove" ), new ImageIcon( DeleteAction.class.getResource( "user-trash.png" ) ) );
		}

		public void actionPerformed( ActionEvent e )
		{
			TreePath selectionPath = treeTable.getTreeSelectionModel().getSelectionPath();
			if (selectionPath != null)
			{
				ColorFiltersTreeTableModel tableModel = (ColorFiltersTreeTableModel)treeTable.getTreeTableModel();
				DefaultMutableTreeTableNode toBeDeletedNode = (DefaultMutableTreeTableNode)selectionPath.getLastPathComponent();
				// find out which node to select next
				DefaultMutableTreeTableNode parentNode = (DefaultMutableTreeTableNode)toBeDeletedNode.getParent();
				if (parentNode.getUserObject() instanceof ColorFilterGroup)
				{
					ColorFilterGroup group = (ColorFilterGroup)parentNode.getUserObject();
					group.removeColorFilter( (LogEntryColorFilter)toBeDeletedNode.getUserObject() );
				}

				TreeTableNode nextToBeSelected = getNextToBeSelected( tableModel, toBeDeletedNode, parentNode );
				tableModel.removeNodeFromParent( toBeDeletedNode );
				if (nextToBeSelected == tableModel.getRoot())
				{
					updateViewForNoSelection();
				}
				else
				{
					treeTable.getTreeSelectionModel().setSelectionPath(
							new TreePath( tableModel.getPathToRoot( nextToBeSelected ) ) );
				}
			}
		}

		/**
		 * Find the node to select after deletion
		 *
		 * @param tableModel	  the table model
		 * @param toBeDeletedNode the node that needs to be deleted
		 * @param parentNode	  the parent node of the node that will need to be deleted
		 * @return the node to select after deletion
		 */
		private TreeTableNode getNextToBeSelected( ColorFiltersTreeTableModel tableModel, MutableTreeTableNode toBeDeletedNode, DefaultMutableTreeTableNode parentNode )
		{
			int currIdx = tableModel.getIndexOfChild( parentNode, toBeDeletedNode );
			TreeTableNode nextToBeSelected = null;
			if (parentNode.getChildCount() > currIdx)
			{
				nextToBeSelected = parentNode.getChildAt( currIdx );
			}
			if (nextToBeSelected == null && currIdx > 0)
			{
				nextToBeSelected = parentNode.getChildAt( currIdx + 1 );
			}
			else
			{
				nextToBeSelected = toBeDeletedNode.getParent();
			}
			return nextToBeSelected;
		}
	}

	private static class ColorColumnHighlighter extends AbstractHighlighter
	{
		protected Component doHighlight( Component component, ComponentAdapter componentAdapter )
		{
			if (componentAdapter.column == 1)
			{
				Color c = (Color)componentAdapter.getValueAt( componentAdapter.row, componentAdapter.column );
				component.setBackground( c );
				component.setForeground( c );
			}
			return component;
		}
	}

		result.add( editPanelWrapper, BorderLayout.EAST );

		return result;
	}

	private JPanel createColorFiltersPanel( EventList<ColorFilterGroup> colorFilterGroups )
	{
		JPanel result = new JPanel( new BorderLayout( 0, 7 ) );

		TreeTableModel model = new ColorFiltersTreeTableModel( colorFilterGroups );
		treeTable = new JXTreeTable( model );
		treeTable.setClosedIcon( new ImageIcon( ColorFiltersDialog.class.getResource( "folder.png" ) ) );
		treeTable.setOpenIcon( new ImageIcon( ColorFiltersDialog.class.getResource( "folder-open.png" ) ) );
		treeTable.setLeafIcon( new ImageIcon( ColorFiltersDialog.class.getResource( "text-x-generic.png" ) ) );

		treeTable.setTreeCellRenderer( new ColorFiltersTreeCellRenderer() );
		treeTable.addHighlighter( new ColorColumnHighlighter() );
		treeTable.setSelectionMode( ListSelectionModel.SINGLE_SELECTION );
		treeTable.getTreeSelectionModel().addTreeSelectionListener( new ColorFiltersListSelectionListener() );
		result.add( createFilterButtons(), BorderLayout.NORTH );
		JScrollPane pane = new JScrollPane( treeTable );
		pane.setPreferredSize( new Dimension( 50, 220 ) );
		result.add( pane, BorderLayout.CENTER );

		return result;
	}

	private JPanel createFilterButtons()
	{
		JPanel result = new JPanel( new FlowLayout( FlowLayout.LEFT, 0, 0 ) );
		addGroupButton = new JButton( new AddGroupAction() );
		result.add( addGroupButton );
		result.add( Box.createHorizontalStrut( 5 ) );
		addFilterButton = new JButton( new AddFilterAction() );
		addFilterButton.setEnabled( false );
		result.add( addFilterButton );
		result.add( Box.createHorizontalStrut( 5 ) );
		deleteButton = new JButton( new DeleteAction() );
		deleteButton.setEnabled( false );
		result.add( deleteButton );

		GuiUtilities.makeButtonWidthEqual( addGroupButton, addFilterButton, deleteButton );

		return result;
	}

/*
	private Component createButtonPanel()
	{
		JPanel result = new JPanel();
		result.setLayout( new FlowLayout( FlowLayout.RIGHT ) );

		JButton okButton = new JButton( bundle.getString( "button.ok" ) );
		okButton.addActionListener( new OkActionListener() );
		result.add( okButton );

		JButton cancelButton = new JButton( bundle.getString( "button.cancel" ) );
		cancelButton.addActionListener( new CancelActionListener() );
		result.add( cancelButton );

		getRootPane().setDefaultButton( okButton );
		GuiUtilities.makeButtonWidthEqual( okButton, cancelButton );

		return result;
	}
*/

	private void checkColorFilterPanelForChanges( DefaultMutableTreeTableNode mutableTreeTableNode )

		List<ColorFilterGroup> result = null;

		if (colorFilterGroups != null)
		{
			TableModel tableModel = treeTable.getModel();
			int rowCount = tableModel.getRowCount();
			result = new ArrayList<ColorFilterGroup>( rowCount );
			for (int i = 0; i < rowCount; i++)
			{
				DefaultMutableTreeTableNode node = (DefaultMutableTreeTableNode)tableModel.getValueAt( i, 2 );
				if (node.getUserObject() instanceof ColorFilterGroup)
				{
					result.add( (ColorFilterGroup)node.getUserObject() );
				}
			}
		}
		return result;
	}

	/**
	 * Selects thte given filter in the dialog
	 *
	 * @param filter the filter to select
	 */
	public void selectFilter( LogEntryColorFilter filter )
	{
		// First expand all items to make sure we get all rows
		treeTable.expandAll();
		int rowCount = treeTable.getModel().getRowCount();
		for (int i = 0; i < rowCount; i++)
		{
			DefaultMutableTreeTableNode node = (DefaultMutableTreeTableNode)treeTable.getModel().getValueAt( i, 2 );
			if (node != null && node.getUserObject().equals( filter ))
			{
				// Got the correct filter, let's select it
				TreePath treePath = calculateTreePath( node );
				treeTable.collapseAll();
				treeTable.expandPath( treePath );
				treeTable.getTreeSelectionModel().setSelectionPath( treePath );
			}
		}
	}