package fr.ifremer.quadrige3.ui.swing.table;
   
   /*
    * #%L
    * Reef DB :: UI
    * $Id:$
    * $HeadURL:$
    * %%
    * Copyright (C) 2014 - 2015 Ifremer
   * %%
   * This program is free software: you can redistribute it and/or modify
   * it under the terms of the GNU Affero General Public License as published by
   * the Free Software Foundation, either version 3 of the License, or
   * (at your option) any later version.
   *
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU General Public License for more details.
   *
   * You should have received a copy of the GNU Affero General Public License
   * along with this program.  If not, see <http://www.gnu.org/licenses/>.
   * #L%
   */
  
  import fr.ifremer.quadrige3.ui.swing.ApplicationUIUtil;
  import fr.ifremer.quadrige3.ui.swing.table.action.AdditionalTableActions;
  import org.apache.commons.lang3.ObjectUtils;
  import org.jdesktop.swingx.action.AbstractActionExt;
  import org.jdesktop.swingx.decorator.Highlighter;
  import org.jdesktop.swingx.table.ColumnControlPopup.ActionGrouper;
  import org.jdesktop.swingx.table.TableColumnExt;
  
  import javax.swing.Action;
  import javax.swing.table.TableCellEditor;
  import javax.swing.table.TableCellRenderer;
  import javax.swing.table.TableColumn;
  import java.awt.event.ActionEvent;
  import java.beans.PropertyChangeListener;
  import java.util.ArrayList;
  import java.util.Comparator;
  import java.util.List;
  import java.util.Optional;
  
  import static org.nuiton.i18n.I18n.t;
  
  /**
   * Override version of ColumnControlButton for a JXTable/JXTreeTable. All non hideable columns are not displayed in the popup
   *
   * @author Ludovic Pecquot <ludovic.pecquot@e-is.pro>
   */
  public class ColumnControlButton extends org.jdesktop.swingx.table.ColumnControlButton {
  
      /**
       * <p>Constructor for ColumnControlButton.</p>
       *
       * @param table a {@link SwingTable} object.
       */
      ColumnControlButton(SwingTable table) {
          super(table);
  
          AbstractActionExt showAllColumnAction = new AbstractActionExt(t("quadrige3.table.showAllColumn")) {
  
              @Override
              public void actionPerformed(ActionEvent e) {
  
                  for (ColumnVisibilityAction action : getColumnVisibilityActions()) {
                      action.setSelected(true);
                  }
  
              }
          };
  
          showAllColumnAction.putValue(GroupKeyActionGrouper.GROUP_KEY, 0);
          table.getActionMap().put(ColumnControlButton.COLUMN_CONTROL_MARKER + "showAllColumn", showAllColumnAction);
  
          // Add all other AdditionalTableActions
          Action additionalActions = table.getActionMap().get(AdditionalTableActions.ACTION_NAME);
          if (additionalActions instanceof AdditionalTableActions) {
              List<Action> actions = ((AdditionalTableActions) additionalActions).getActions();
              for (int i = 0; i < actions.size(); i++) {
                  Action action = actions.get(i);
                  action.putValue(GroupKeyActionGrouper.GROUP_KEY,
                          Optional.ofNullable(action.getValue(AdditionalTableActions.ACTION_TARGET_GROUP))
                                  .orElse(AdditionalTableActions.DEFAULT_ACTION_TARGET_GROUP));
                  // add the additional action with another key
                  table.getActionMap().put(ColumnControlButton.COLUMN_CONTROL_MARKER + "z_additionalAction" + i, action);
              }
          }
  
          setActionGrouper(new GroupKeyActionGrouper());
      }
  
      /**
       * {@inheritDoc}
       */
      @Override
      protected ColumnVisibilityAction createColumnVisibilityAction(TableColumn column) {
          if (!(column instanceof TableColumnExt)) return null;
         TableColumnExt columnExt = (TableColumnExt) column;
         if (!columnExt.isHideable() || columnExt instanceof HiddenColumn) {
             return null;
         }
         return super.createColumnVisibilityAction(new DelegateTableColumnExt(columnExt));
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     protected void addVisibilityActionItems() {
         final List<ColumnVisibilityAction> actions = new ArrayList<>(getColumnVisibilityActions());
 
         // Sort actions by name (= column label)
         actions.sort((o1, o2) -> ObjectUtils.compare(o1.getName(), o2.getName()));
         getColumnControlPopup().addVisibilityActionItems(actions);
     }
 
     public static class GroupKeyActionGrouper implements ActionGrouper {
 
         //Marker to support custom grouping of additional actions. (Issue #swingx-968)
         static final String GROUP_KEY = "customActionGroup";
 
         @Override
         public <A extends Action> List<List<A>> group(List<A> actions) {
             List<List<A>> result = new ArrayList<>();
             List<Object> keys = new ArrayList<>();
             List<A> noKey = new ArrayList<>();
             for (A action : actions) {
                 Object groupKey = action.getValue(GROUP_KEY);
                 if (groupKey != null) {
                     int index = keys.indexOf(groupKey);
                     if (index < 0) {
                         keys.add(groupKey);
                         index = keys.size() - 1;
                         result.add(new ArrayList<>());
                     }
                     result.get(index).add(action);
                 } else {
                     noKey.add(action);
                 }
 
             }
             result.add(0, noKey);
             return result;
         }
     }
 
     /**
      * Delegate TableColumn with cleaner header value
      */
     private class DelegateTableColumnExt extends TableColumnExt {
 
         private final TableColumnExt delegate;
 
         DelegateTableColumnExt(TableColumnExt delegate) {
             this.delegate = delegate;
         }
 
         /**
          * remove HTML tags from delegate table columns
          * @return clean header value
          */
         @Override
         public Object getHeaderValue() {
             Object headerValue = delegate.getHeaderValue();
             if (headerValue instanceof String) {
                 String header = (String) headerValue;
                 return ApplicationUIUtil.removeHtmlTags(header);
             }
             return headerValue;
         }
 
         @Override
         public void setHighlighters(Highlighter... highlighters) {
             delegate.setHighlighters(highlighters);
         }
 
         @Override
         public Highlighter[] getHighlighters() {
             return delegate.getHighlighters();
         }
 
         @Override
         public void addHighlighter(Highlighter highlighter) {
             delegate.addHighlighter(highlighter);
         }
 
         @Override
         public void removeHighlighter(Highlighter highlighter) {
             delegate.removeHighlighter(highlighter);
         }
 
 //        @Override
 //        public CompoundHighlighter getCompoundHighlighter() {
 //            return delegate.getCompoundHighlighter();
 //        }
 //
 //        @Override
 //        public ChangeListener getHighlighterChangeListener() {
 //            return delegate.getHighlighterChangeListener();
 //        }
 //
 //        @Override
 //        public ChangeListener createHighlighterChangeListener() {
 //            return delegate.createHighlighterChangeListener();
 //        }
 
         @Override
         public boolean getResizable() {
             return delegate.getResizable();
         }
 
         @Override
         public void setEditable(boolean editable) {
             delegate.setEditable(editable);
         }
 
         @Override
         public boolean isEditable() {
             return delegate.isEditable();
         }
 
         @Override
         public void setPrototypeValue(Object value) {
             delegate.setPrototypeValue(value);
         }
 
         @Override
         public Object getPrototypeValue() {
             return delegate.getPrototypeValue();
         }
 
         @Override
         public void setComparator(Comparator<?> comparator) {
             delegate.setComparator(comparator);
         }
 
         @Override
         public Comparator<?> getComparator() {
             return delegate.getComparator();
         }
 
         @Override
         public void setSortable(boolean sortable) {
             delegate.setSortable(sortable);
         }
 
         @Override
         public boolean isSortable() {
             return delegate.isSortable();
         }
 
         @Override
         public void setToolTipText(String toolTipText) {
             delegate.setToolTipText(toolTipText);
         }
 
         @Override
         public String getToolTipText() {
             return delegate.getToolTipText();
         }
 
         @Override
         public void setTitle(String title) {
             delegate.setTitle(title);
         }
 
         @Override
         public String getTitle() {
             return delegate.getTitle();
         }
 
         @Override
         public void setVisible(boolean visible) {
             delegate.setVisible(visible);
         }
 
         @Override
         public boolean isVisible() {
             return delegate.isVisible();
         }
 
         @Override
         public void setHideable(boolean hideable) {
             delegate.setHideable(hideable);
         }
 
         @Override
         public boolean isHideable() {
             return delegate.isHideable();
         }
 
         @Override
         public void putClientProperty(Object key, Object value) {
             delegate.putClientProperty(key, value);
         }
 
         @Override
         public Object getClientProperty(Object key) {
             return delegate.getClientProperty(key);
         }
 
 //        @Override
 //        public void copyFrom(TableColumnExt original) {
 //            delegate.copyFrom(original);
 //        }
 
 //        @Override
 //        public void copyClientPropertiesFrom(TableColumnExt original) {
 //            delegate.copyClientPropertiesFrom(original);
 //        }
 
 //        @Override
 //        public void firePropertyChange(String propertyName, Object oldValue, Object newValue) {
 //            delegate.firePropertyChange(propertyName, oldValue, newValue);
 //        }
 
         @Override
         public void updateUI() {
             delegate.updateUI();
         }
 
         @Override
         public void setModelIndex(int modelIndex) {
             delegate.setModelIndex(modelIndex);
         }
 
         @Override
         public int getModelIndex() {
             return delegate.getModelIndex();
         }
 
         @Override
         public void setIdentifier(Object identifier) {
             delegate.setIdentifier(identifier);
         }
 
         @Override
         public Object getIdentifier() {
             return delegate.getIdentifier();
         }
 
         @Override
         public void setHeaderValue(Object headerValue) {
             delegate.setHeaderValue(headerValue);
         }
 
         @Override
         public void setHeaderRenderer(TableCellRenderer headerRenderer) {
             delegate.setHeaderRenderer(headerRenderer);
         }
 
         @Override
         public TableCellRenderer getHeaderRenderer() {
             return delegate.getHeaderRenderer();
         }
 
         @Override
         public void setCellRenderer(TableCellRenderer cellRenderer) {
             delegate.setCellRenderer(cellRenderer);
         }
 
         @Override
         public TableCellRenderer getCellRenderer() {
             return delegate.getCellRenderer();
         }
 
         @Override
         public void setCellEditor(TableCellEditor cellEditor) {
             delegate.setCellEditor(cellEditor);
         }
 
         @Override
         public TableCellEditor getCellEditor() {
             return delegate.getCellEditor();
         }
 
         @Override
         public void setWidth(int width) {
             delegate.setWidth(width);
         }
 
         @Override
         public int getWidth() {
             return delegate.getWidth();
         }
 
         @Override
         public void setPreferredWidth(int preferredWidth) {
             delegate.setPreferredWidth(preferredWidth);
         }
 
         @Override
         public int getPreferredWidth() {
             return delegate.getPreferredWidth();
         }
 
         @Override
         public void setMinWidth(int minWidth) {
             delegate.setMinWidth(minWidth);
         }
 
         @Override
         public int getMinWidth() {
             return delegate.getMinWidth();
         }
 
         @Override
         public void setMaxWidth(int maxWidth) {
             delegate.setMaxWidth(maxWidth);
         }
 
         @Override
         public int getMaxWidth() {
             return delegate.getMaxWidth();
         }
 
         @Override
         public void setResizable(boolean isResizable) {
             delegate.setResizable(isResizable);
         }
 
         @Override
         public void sizeWidthToFit() {
             delegate.sizeWidthToFit();
         }
 
 //        @Override
 //        @Deprecated
 //        public void disableResizedPosting() {
 //            delegate.disableResizedPosting();
 //        }
 //
 //        @Override
 //        @Deprecated
 //        public void enableResizedPosting() {
 //            delegate.enableResizedPosting();
 //        }
 
         @Override
         public void addPropertyChangeListener(PropertyChangeListener listener) {
             delegate.addPropertyChangeListener(listener);
         }
 
         @Override
         public void removePropertyChangeListener(PropertyChangeListener listener) {
             delegate.removePropertyChangeListener(listener);
         }
 
         @Override
         public PropertyChangeListener[] getPropertyChangeListeners() {
             return delegate.getPropertyChangeListeners();
         }
 
 //        @Override
 //        public TableCellRenderer createDefaultHeaderRenderer() {
 //            return delegate.createDefaultHeaderRenderer();
 //        }
     }
 }