/**
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

package org.netbeans.modules.tasklist.ui;

import java.awt.Color;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.Insets;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.FocusEvent;
import java.awt.event.FocusListener;
import java.awt.event.KeyEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.HashMap;
import java.util.Map;
import javax.swing.AbstractAction;
import javax.swing.Action;
import javax.swing.ActionMap;
import javax.swing.BorderFactory;
import javax.swing.Icon;
import javax.swing.ImageIcon;
import javax.swing.InputMap;
import javax.swing.JLabel;
import javax.swing.JPopupMenu;
import javax.swing.JTable;
import javax.swing.KeyStroke;
import javax.swing.ListSelectionModel;
import javax.swing.SwingConstants;
import javax.swing.UIManager;
import javax.swing.plaf.TableHeaderUI;
import javax.swing.plaf.TableUI;
import javax.swing.plaf.UIResource;
import javax.swing.table.DefaultTableCellRenderer;
import javax.swing.table.JTableHeader;
import javax.swing.table.TableCellRenderer;
import javax.swing.table.TableColumn;
import javax.swing.table.TableColumnModel;
import javax.swing.table.TableModel;
import org.netbeans.modules.tasklist.impl.OpenTaskAction;
import org.netbeans.spi.tasklist.Task;
import org.netbeans.modules.tasklist.trampoline.TaskGroup;
import org.openide.util.ImageUtilities;
import org.openide.util.NbBundle;

/**
 *
 * @author S. Aubrecht
 */
class TaskListTable extends JTable {
    
    private TableCellRenderer foldingGroupRenderer;
    private TableCellRenderer groupRenderer;
    
    private Action defaultAction = new DefaultAction();
    
    private Action nextTaskAction = new TaskNavigationAction( true );
    private Action prevTaskAction = new TaskNavigationAction( false );
    
    /** Creates a new instance of TaskListTable */
    public TaskListTable() {
        this.setAutoResizeMode(JTable.AUTO_RESIZE_LAST_COLUMN);
        addMouseListener( new MouseAdapter() {
            @Override
            public void mousePressed( MouseEvent e ) {
                maybePopup( e );
            }
            
            @Override
            public void mouseReleased( MouseEvent e ) {
                maybePopup( e );
            }
            
            @Override
            public void mouseClicked(MouseEvent e) {
                int row = rowAtPoint( e.getPoint() );
                if( isFoldingModel() ) {
                    FoldingTaskListModel foldingModel = getFoldingModel();
                    if( e.getClickCount() == 2 ) {
                        //handle group collapse/expand
                        if( foldingModel.isGroupRow( row ) ) {
                            foldingModel.toggleGroupExpanded( row );
                            return;
                        }
                    } else if( e.getClickCount() == 1 ) {
                        if( foldingModel.isGroupRow( row ) ) {
                            maybeExpandGroup( e.getPoint() );
                            return;
                        }
                    }
                }
                if( e.getClickCount() == 2 ) {
                    defaultAction.actionPerformed( null );
                }
            }
        });
        
        addFocusListener(new FocusListener() {

            public void focusGained(FocusEvent e) {
                repaintSelectedRow();
            }

            public void focusLost(FocusEvent e) {
                repaintSelectedRow();
            }
        });
        setSelectionMode( ListSelectionModel.SINGLE_SELECTION );
        setBorder( BorderFactory.createEmptyBorder() );
        
        setAutoCreateColumnsFromModel( false );
        
        int requiredRowHeight = 16+2+2*getIntercellSpacing().height;
        setRowHeight( Math.max( getRowHeight(), requiredRowHeight ) );
        
        InputMap inputMap = getInputMap( JTable.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT );
        Object right = inputMap.get( KeyStroke.getKeyStroke( KeyEvent.VK_RIGHT, 0 ) );
        Object left = inputMap.get( KeyStroke.getKeyStroke( KeyEvent.VK_LEFT, 0 ) );
        inputMap.put( KeyStroke.getKeyStroke( KeyEvent.VK_ENTER, 0 ), "defaultAction" ); // NOI18N
        
        getInputMap( JTable.WHEN_FOCUSED ).put( KeyStroke.getKeyStroke( KeyEvent.VK_F10, KeyEvent.SHIFT_DOWN_MASK ), "org.openide.actions.PopupAction" ); //NOI18N
        getActionMap().put( "org.openide.actions.PopupAction", new PopupAction() ); //NOI18N
        
        ActionMap actionMap = getActionMap();
        Action actionLeft = actionMap.get( left );
        Action actionRight = actionMap.get( right );
        
        actionMap.put( left, new ToggleGroupAction( false, actionLeft ) );
        actionMap.put( right, new ToggleGroupAction( true, actionRight ) );
        actionMap.put( "defaultAction", defaultAction ); // NOI18N
        
        actionMap.put( "jumpPrev", prevTaskAction ); // NOI18N
        actionMap.put( "jumpNext", nextTaskAction ); // NOI18N
//        actionMap.put (FindAction.class.getName (), this.findAction);
//        actionMap.put (javax.swing.text.DefaultEditorKit.copyAction, this.copyAction);
    }
    
    @Override
    public void createDefaultColumnsFromModel() {
        TableModel m = getModel();
        if( m != null ) {
            // Remove any current columns
            TableColumnModel cm = getColumnModel();
            while( cm.getColumnCount() > 0 ) {
                cm.removeColumn( cm.getColumn(0) );
	    }

            // Create new columns from the data model info
            for( int i=0; i<m.getColumnCount(); i++ ) {
                TableColumn newColumn = new MyTableColumn(i);
                if( i == TaskListModel.COL_LOCATION )
                    newColumn.setCellRenderer( new LeftDotRenderer() );
                else if( i != TaskListModel.COL_GROUP )
                    newColumn.setCellRenderer( new TooltipRenderer() );
                addColumn(newColumn);
            }
        }
    }
    
    @Override
    public void removeNotify() {
        if( getModel() instanceof TaskListModel )
            storeColumnState();
        super.removeNotify();
    }
    
    @Override
    protected JTableHeader createDefaultTableHeader() {
        JTableHeader res = new MyTableHeader( columnModel );
        res.setTable(this);
        return res;
    }
    
    @Override
    public TableCellRenderer getCellRenderer( int row, int col ) {
        if( col == 0 ) {
            if( isFoldingModel() && getFoldingModel().isGroupRow( row ) )
                return getFoldingGroupRenderer();
            return getGroupRenderer();
        }
        return super.getCellRenderer( row, col );
    }
    
    private void maybePopup( MouseEvent e ) {
        if( e.isPopupTrigger() ) {
            e.consume();
            int row = rowAtPoint( e.getPoint() );
            if( row >= 0 )
                getSelectionModel().setSelectionInterval( row, row );
            JPopupMenu popup = Util.createPopup( this );
            popup.show( this, e.getX(), e.getY() );
        }
    }
    
    private TableCellRenderer getFoldingGroupRenderer() {
        if( null == foldingGroupRenderer )
            foldingGroupRenderer = new FoldingTaskGroupRenderer();
        return foldingGroupRenderer;
    }
    
    private TableCellRenderer getGroupRenderer() {
        if( null == groupRenderer )
            groupRenderer = new TaskGroupRenderer();
        return groupRenderer;
    }
    
    private void maybeExpandGroup( Point point ) {
        int row = rowAtPoint( point );
        int col = columnAtPoint( point );
        if( 0 != col )
            return;
        Rectangle rect = getCellRect( row, col, false );
        TableCellRenderer renderer = getCellRenderer(row, col);
        prepareRenderer(renderer, row, col);
        if( renderer instanceof FoldingTaskGroupRenderer ) {
            Icon icon = ((FoldingTaskGroupRenderer)renderer).getIcon();
            rect.grow( 0, -(rect.height-openedIcon.getIconHeight())/2 );
            rect.x = getColumnModel().getColumnMargin(); //rect.width - icon.getIconWidth();
            rect.width = openedIcon.getIconWidth();
            if( rect.contains( point ) ) {
                FoldingTaskListModel foldingModel = getFoldingModel();
                foldingModel.toggleGroupExpanded( row );
            }
        }
    }
    
    private void storeColumnState() {
        int count = getColumnModel().getColumnCount();
        for( int i=0; i<count; i++ ) {
            TableColumn tc = getColumnModel().getColumn( i );
            if( tc instanceof MyTableColumn ) {
                ((MyTableColumn)tc).storeState();
            }
        }
    }
    
    @Override
    public void setUI( TableUI ui ) {
        super.setUI( new TaskListTableUI() );
        setTableHeader( createDefaultTableHeader() );
    }
    
    @Override
    public void setModel( TableModel newModel ) {
        if( getModel() instanceof TaskListModel && newModel != getModel() ) {
            storeColumnState();
            ((TaskListModel)getModel()).detach();
        }
            
        if( newModel instanceof TaskListModel ) {
            ((TaskListModel)newModel).attach();
        }
        super.setModel( newModel );
        createDefaultColumnsFromModel();
    }

    private boolean isFoldingModel() {
        return getModel() instanceof FoldingTaskListModel;
    }
    
    private FoldingTaskListModel getFoldingModel() {
        return isFoldingModel() ? (FoldingTaskListModel)getModel() : null;
    }
    
    @Override
    public String getToolTipText( MouseEvent e ) {
        int hitRowIndex = rowAtPoint( e.getPoint() );
        if( isFoldingModel() && getFoldingModel().isGroupRow( hitRowIndex ) ) {
            return getFoldingModel().getGroupAtRow( hitRowIndex ).getGroup().getDescription();
        }
        return super.getToolTipText( e );
    }
    
    Task getSelectedTask() {
        int selRow = getSelectedRow();
        if( selRow < 0 )
            return null;
        return ((TaskListModel)getModel()).getTaskAtRow( selRow );
    }
    
    int getSortColumn() {
        return ((TaskListModel)getModel()).getSortingColumnn();
    }
    
    void setSortColumn( int col ) {
        ((TaskListModel)getModel()).toggleSort( col );
    }
    
    boolean isAscendingSort() {
        return ((TaskListModel)getModel()).isAscendingSort();
    }
    
    void setAscendingSort( boolean asc ) {
        ((TaskListModel)getModel()).setAscendingSort( asc );
    }
    
//    @Override
//    public Rectangle getCellRect( int row, int col, boolean includeSpacing ) {
//        Rectangle res = super.getCellRect( row, col, includeSpacing );
//        if( isFoldingModel() && getFoldingModel().isGroupRow(row) ) {
//            res.x = 0;
//            res.width = getWidth();
//            if( !includeSpacing )
//                res.width -= getColumnModel().getColumnMargin();
//        }
//        return res;
//    }
    
    
    
    private static final Icon openedIcon = (Icon)UIManager.get("Tree.expandedIcon"); // NOI18N
    private static final Icon closedIcon = (Icon)UIManager.get("Tree.collapsedIcon"); // NOI18N
    
    private static Map<Image, ImageIcon> iconCache = new HashMap<Image, ImageIcon>(10);
    
    private class TaskGroupRenderer extends DefaultTableCellRenderer {
        
        @Override
        public Component getTableCellRendererComponent(JTable table, Object value,
                              boolean isSelected, boolean hasFocus, int row, int column) {
            Component res = super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
            if( res instanceof JLabel ) {
                if( value instanceof TaskGroup ) {
                    TaskGroup tg = (TaskGroup)value;
                    JLabel renderer = (JLabel)res;
                    renderer.setText( null );
                    ImageIcon icon = iconCache.get( tg.getIcon() );
                    if( null == icon ) {
                        icon = new ImageIcon( tg.getIcon() );
                        iconCache.put( tg.getIcon(), icon );
                    }
                    renderer.setIcon( icon );
                    renderer.setToolTipText( tg.getDescription() );
                    renderer.setHorizontalAlignment( JLabel.RIGHT );
                }
            }
            return res;
        }
    }

    private class FoldingTaskGroupRenderer extends DefaultTableCellRenderer {
        
        private final Color GTK_BK_COLOR = new Color( 184,207,229 );
        private final Color AQUA_BK_COLOR = new Color(225, 235, 240);

        private final boolean isGTK = "GTK".equals( UIManager.getLookAndFeel().getID() ); // NOI18N
        private final boolean isAqua = "Aqua".equals( UIManager.getLookAndFeel().getID() ); // NOI18N
        
        public FoldingTaskGroupRenderer() {
            //force initialization of PropSheet look'n'feel values 
            UIManager.get( "nb.propertysheet" ); // NOI18N
            setOpaque( true );
        }
        
        @Override
        public Component getTableCellRendererComponent(JTable table, Object value,
                              boolean isSelected, boolean hasFocus, int row, int column) {
            
            if( getFoldingModel().isGroupRow( row ) ) {
//                hasFocus = table.isFocusOwner() && isSelected;
            }
            Component res = super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
            if( res instanceof JLabel ) {
                if( value instanceof FoldingTaskListModel.FoldingGroup ) {
                    FoldingTaskListModel.FoldingGroup fg = (FoldingTaskListModel.FoldingGroup)value;
                    JLabel renderer = (JLabel)res;
                    renderer.setText( fg.getGroup().getDisplayName() + " ("+fg.getTaskCount()+")" );
                    Icon treeIcon = fg.isExpanded() ? openedIcon : closedIcon;
                    renderer.setIcon( treeIcon );
                    renderer.setToolTipText( fg.getGroup().getDescription() );
                    renderer.setHorizontalAlignment( JLabel.LEFT );
                    if( !isSelected )
                        renderer.setBackground( getBackgroundColor() );
                }
            }
            return res;
        }
        
        public Color getBackgroundColor() {
            if( isGTK ) {
                return GTK_BK_COLOR;
            } else if( isAqua ) {
                return AQUA_BK_COLOR;
            } else {
                return UIManager.getColor( "PropSheet.setBackground" ); //NOI18N
            }
        }
    }
    
    
    
    private class ToggleGroupAction extends AbstractAction {
        private Action defaultAction;
        private boolean expand;
        public ToggleGroupAction( boolean expand, Action defaultAction ) {
            this.defaultAction = defaultAction;
            this.expand = expand;
        }
    
        public void actionPerformed( ActionEvent e ) {
            if( isFoldingModel() ) {
                FoldingTaskListModel foldingModel = getFoldingModel();
                int selRow = getSelectedRow();
                if( selRow >= 0 ) {
                    FoldingTaskListModel.FoldingGroup group = foldingModel.getGroupAtRow( selRow );
                    if( null != group && group.isExpanded() != expand ) {
                        group.setExpanded( expand );
                        return;
                    }
                }
            }
            defaultAction.actionPerformed( e );
        }
    }
    
    
    
    private class MyTableHeader extends JTableHeader {
        
        public MyTableHeader( TableColumnModel model ) {
            super( model );
            addMouseListener( new MouseAdapter() {
                @Override
                public void mouseClicked(MouseEvent e) {
                    if( e.getClickCount() != 1 )
                        return;
                    int column = columnAtPoint( e.getPoint() );
                    if( column > 0 && getModel() instanceof TaskListModel ) {
                        ((TaskListModel)getModel()).toggleSort( column );
                        repaint();
                    }
                }
            });
            this.setReorderingAllowed( false );
        }
        
        @Override
        public void setDraggedColumn( TableColumn aColumn ) {
            if( null != aColumn && aColumn.getModelIndex() == 0 )
                return; //don't allow the first column to be dragged
            super.setDraggedColumn( aColumn );
        }

        @Override
        public void setDefaultRenderer(TableCellRenderer defaultRenderer) {
            if( !(defaultRenderer instanceof SortingHeaderRenderer) && !isNimbus() )
                defaultRenderer = new SortingHeaderRenderer( defaultRenderer );
            super.setDefaultRenderer( defaultRenderer );
        }
        
        @Override
        public void setUI(TableHeaderUI ui) {
            super.setUI(ui);
        }
    
        @Override
        public void setResizingColumn( TableColumn col ) {
            if( null != getResizingColumn() && null == col ) {
                storeColumnState();
            }
            super.setResizingColumn( col );
        }

        @Override
        public JTable getTable() {
            return TaskListTable.this;
        }
    }
    
    
    private class DefaultAction extends AbstractAction {
        
        public void actionPerformed(ActionEvent arg0) {
            Task t = getSelectedTask();
            if( null != t ) {
                Action a = Util.getDefaultAction( t );
                if( a.isEnabled() ) {
                    a.actionPerformed( null );
                } else {
                    Toolkit.getDefaultToolkit().beep();
                }
            }
        }
    }
    
    
    private class TaskNavigationAction extends AbstractAction {
        private boolean navigateToNextTask;
        public TaskNavigationAction( boolean navigateToNextTask ) {
            super( navigateToNextTask ? NbBundle.getMessage( TaskListTable.class, "LBL_NextTask" )  //NOI18N
                    : NbBundle.getMessage( TaskListTable.class, "LBL_PrevTask" ) ); //NOI18N
            this.navigateToNextTask = navigateToNextTask;
        }
    
        public void actionPerformed( ActionEvent e ) {
            if( 0 == getModel().getRowCount() )
                return;
            
            int currentRow = getSelectedRow();
            if( currentRow < 0 ) {
                currentRow = 0;
            } else if( !(isFoldingModel() && getFoldingModel().isGroupRow(currentRow)) ) {
                currentRow += (navigateToNextTask ? 1 : -1);
            }
            
            TaskListModel tlm = (TaskListModel)getModel();
            while( true ) {
                if( currentRow < 0 )
                    currentRow = tlm.getRowCount()-1;
                else if( currentRow >= tlm.getRowCount() )
                    currentRow = 0;
                Task t = tlm.getTaskAtRow( currentRow );
                if( null != t ) {
                    getSelectionModel().setSelectionInterval( currentRow, currentRow );
                    scrollRectToVisible( getCellRect( currentRow, 0, true ) );
                    Action a = new OpenTaskAction( t );
                    if( a.isEnabled() ) {
                        a.actionPerformed( e );
                    } else {
                        TaskListTopComponent.findInstance().requestActive();
                    }
                    break;
                } else if( isFoldingModel() ) {
                    FoldingTaskListModel.FoldingGroup fg = getFoldingModel().getGroupAtRow( currentRow );
                    if( !fg.isExpanded() )
                        fg.setExpanded( true );
                }
                currentRow += (navigateToNextTask ? 1 : -1);
            }
        }
    }
    
    
    private class MyTableColumn extends TableColumn {
        private float ratio;
        
        public MyTableColumn( int index ) {
            super( index );
            if( index == TaskListModel.COL_GROUP ) {
                setWidth( isFoldingModel() ? 35 : 20 );
                setMinWidth( isFoldingModel() ? 35 : 20 );
                setMaxWidth( isFoldingModel() ? 35 : 20 );
                setResizable( false );
            } else {
                switch( modelIndex ) {
                case TaskListModel.COL_DESCRIPTION:
                    ratio = 0.65f;
                    break;
                case TaskListModel.COL_LOCATION:
                    ratio = 0.2f;
                    break;
                case TaskListModel.COL_FILE:
                    ratio = 0.1f;
                    break;
                }
                ratio = Settings.getDefault().getPreferredColumnWidth( index, isFoldingModel(), ratio );
            }
        }
        
        @Override
        public int getPreferredWidth() {
            int idx = this.getModelIndex();
            if( isFoldingModel() && idx == TaskListModel.COL_GROUP )
                return getWidth();
            
            int totalWidth = getParent().getWidth();
            return (int)(totalWidth*ratio);
        }
        
        public void storeState() {
            float totalWidth = TaskListTable.this.getWidth();
            if( totalWidth > 0 ) {
                ratio = this.getWidth() / totalWidth;
                Settings.getDefault().setPreferredColumnWidth( getModelIndex(), isFoldingModel(), ratio );
            }
        }

        @Override
        public Object getHeaderValue() {
            Object res = super.getHeaderValue();
            if( isNimbus() && getModel() instanceof TaskListModel && res instanceof String ) {
                TaskListModel tlm = (TaskListModel) getModel();
                if( getModelIndex() == tlm.getSortingColumnn() ) {
                    String name = res.toString();
                    if( tlm.isAscendingSort() ) {
                        name += "  ʌ";
                    } else {
                        name += "  v";
                    }
                    res = name;
                }
            }
            return res;
        }
    }

    private static class LeftDotRenderer 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 );

            int availableWidth = table.getColumnModel().getColumn( column ).getWidth();
            availableWidth -= table.getIntercellSpacing().getWidth();
            Insets borderInsets = getBorder().getBorderInsets( (Component)this );
            availableWidth -= (borderInsets.left + borderInsets.right);
            String cellText = getText();
            FontMetrics fm = getFontMetrics( getFont() );

            if( fm.stringWidth(cellText) > availableWidth ) {
                setToolTipText( value.toString() );
                String dots = "..."; //NOI18N
                int textWidth = fm.stringWidth( dots );
                int nChars = cellText.length() - 1;
                for( ; nChars > 0; nChars-- ) {
                    textWidth += fm.charWidth( cellText.charAt( nChars ) );

                    if( textWidth > availableWidth ) {
                        break;
                    }
                }

                setText( dots + cellText.substring(nChars + 1) );
            } else {
                setToolTipText( null );
            }

            return this;
        }
    }
    

    private static class TooltipRenderer 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 );

            int availableWidth = table.getColumnModel().getColumn( column ).getWidth();
            availableWidth -= table.getIntercellSpacing().getWidth();
            Insets borderInsets = getBorder().getBorderInsets( (Component)this );
            availableWidth -= (borderInsets.left + borderInsets.right);
            String cellText = getText();
            FontMetrics fm = getFontMetrics( getFont() );

            if( fm.stringWidth(cellText) > availableWidth ) {
                setToolTipText( cellText );

            } else {
                setToolTipText( null );
            }

            return this;
        }
    }

    private class SortingHeaderRenderer implements TableCellRenderer, UIResource {
        
        private TableCellRenderer origRenderer;
        
        private static final String SORT_ASC_ICON = "org/netbeans/modules/tasklist/ui/resources/columnsSortedAsc.gif"; // NOI18N
        private static final String SORT_DESC_ICON = "org/netbeans/modules/tasklist/ui/resources/columnsSortedDesc.gif"; // NOI18N

        private JLabel defaultRenderer;
        
        SortingHeaderRenderer( TableCellRenderer origRenderer ) {
            this.origRenderer = origRenderer;
            if( isGTK() ) {
                TableCellRenderer ren = new JTableHeader().getDefaultRenderer();
                if( ren instanceof JLabel )
                    defaultRenderer = (JLabel) ren;
            }
        }

        /** Overrides superclass method. */
        public Component getTableCellRendererComponent( JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column ) {
            if( null == table ) {
                return new JLabel();
            }
            Component comp = origRenderer.getTableCellRendererComponent( table, value, isSelected, hasFocus, row, column );

            if( comp instanceof JLabel ) {
                JLabel label = (JLabel)comp;
                TaskListModel tlm = (TaskListModel)getModel();
                if( column == tlm.getSortingColumnn() ) {
                    label.setIcon( getProperIcon( !tlm.isAscendingSort() ) );
                    label.setHorizontalTextPosition( SwingConstants.LEADING );
                } else {
                    label.setIcon( NO_ICON );
                }
                if( isGTK() && null != defaultRenderer ) {
                    defaultRenderer.setText(label.getText());
                    Dimension prefSize = defaultRenderer.getPreferredSize();
                    if( prefSize.width > 1 && prefSize.height > 1 )
                        label.setPreferredSize(prefSize);
                    label.setText(" " + label.getText());
                }
            }

            return comp;
        }

        private ImageIcon getProperIcon( boolean descending ) {
            if( descending ) {
                return ImageUtilities.loadImageIcon(SORT_DESC_ICON, false);
            } else {
                return ImageUtilities.loadImageIcon(SORT_ASC_ICON, false);
            }
        }
    }

    private static final Icon NO_ICON = new Icon() {

        public void paintIcon(Component c, Graphics g, int x, int y) {
        }

        public int getIconWidth() {
            return 1;
        }

        public int getIconHeight() {
            return 12;
        }
    };
    
    private class PopupAction extends AbstractAction {
        public PopupAction() {
            super( "Popup" ); //NOI18N
        }
    
        public void actionPerformed( ActionEvent e ) {
            Point p = getPositionForPopup();

            if (p == null) {
                //we're going to create a popup menu for the root node
                p = new Point(0, 0);
            }

            JPopupMenu popup = Util.createPopup( TaskListTable.this );
            popup.show( TaskListTable.this, p.x, p.y );
        }
        
        @Override
        public boolean isEnabled() {
            return TaskListTable.this.isFocusOwner();
        }
    }
    
    private Point getPositionForPopup() {
        int selRow = getSelectedRow();

        if( selRow < 0 ) {
            return null;
        }

        Rectangle rect = getCellRect( selRow, 0, true );

        if( rect == null ) {
            return null;
        }

        return new Point(0, rect.y + rect.height );
    }

    @Override
    public Color getSelectionBackground() {
        if( !hasFocus() && !isNimbus() && !isGTK() )
            return getUnfocusedSelectionBackground();
        return UIManager.getColor("Table.selectionBackground");//NOI18N
    }

    @Override
    public Color getSelectionForeground() {
        if( !hasFocus() && !isNimbus() && !isGTK() )
            return getUnfocusedSelectionForeground();
        return UIManager.getColor("Table.selectionForeground");//NOI18N
    }
    
    private void repaintSelectedRow() {
        int selRow = getSelectedRow();
        if( selRow < 0 )
            return;
        Rectangle rect = getCellRect(selRow, 0, true);
        Rectangle rect2 = getCellRect(selRow, getColumnCount()-1, true);
        rect.width = rect2.x + rect2.width;
        repaint(rect);
    }

    private static Color unfocusedSelBg = null;
    /** Get the system-wide unfocused selection background color */
    private static Color getUnfocusedSelectionBackground() {
        if (unfocusedSelBg == null) {
            //allow theme/ui custom definition
            unfocusedSelBg = UIManager.getColor("nb.explorer.unfocusedSelBg"); //NOI18N
            
            if (unfocusedSelBg == null) {
                //try to get standard shadow color
                unfocusedSelBg = UIManager.getColor("controlShadow"); //NOI18N
                
                if (unfocusedSelBg == null) {
                    //Okay, the look and feel doesn't suport it, punt
                    unfocusedSelBg = Color.lightGray;
                }

                //Lighten it a bit because disabled text will use controlShadow/
                //gray
                if (!Color.WHITE.equals(unfocusedSelBg.brighter())) {
                    unfocusedSelBg = unfocusedSelBg.brighter();
                }
            }
        }

        return unfocusedSelBg;
    }

    private static Color unfocusedSelFg = null;
    /** Get the system-wide unfocused selection foreground color */
    private static Color getUnfocusedSelectionForeground() {
        if (unfocusedSelFg == null) {
            //allow theme/ui custom definition
            unfocusedSelFg = UIManager.getColor("nb.explorer.unfocusedSelFg"); //NOI18N
            
            if (unfocusedSelFg == null) {
                //try to get standard shadow color
                unfocusedSelFg = UIManager.getColor("textText"); //NOI18N
                
                if (unfocusedSelFg == null) {
                    //Okay, the look and feel doesn't suport it, punt
                    unfocusedSelFg = Color.BLACK;
                }
            }
        }

        return unfocusedSelFg;
    }
    
    private static boolean isGTK () {
        return "GTK".equals(UIManager.getLookAndFeel().getID()); //NOI18N
    }
    
    private static boolean isNimbus () {
        return "Nimbus".equals(UIManager.getLookAndFeel().getID()); //NOI18N
    }
}