EDIT

/**

* Copyright (C) 2018 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.taxeditor.editor.descriptiveDataSet.matrix;

import java.io.IOException;

import java.io.StringReader;

import java.io.StringWriter;

import java.util.Collection;

import java.util.Properties;

import java.util.function.Consumer;

import org.apache.commons.lang.StringUtils;

import org.eclipse.jface.viewers.ArrayContentProvider;

import org.eclipse.jface.viewers.ComboViewer;

import org.eclipse.jface.viewers.LabelProvider;

import org.eclipse.nebula.widgets.nattable.NatTable;

import org.eclipse.nebula.widgets.nattable.command.VisualRefreshCommand;

import org.eclipse.nebula.widgets.nattable.export.command.ExportCommand;

import org.eclipse.nebula.widgets.nattable.persistence.PersistenceHelper;

import org.eclipse.nebula.widgets.nattable.persistence.command.DisplayPersistenceDialogCommand;

import org.eclipse.nebula.widgets.nattable.persistence.command.DisplayPersistenceDialogCommandHandler;

import org.eclipse.nebula.widgets.nattable.persistence.command.IStateChangedListener;

import org.eclipse.nebula.widgets.nattable.persistence.command.StateChangeEvent;

import org.eclipse.nebula.widgets.nattable.persistence.gui.PersistenceDialog;

import org.eclipse.nebula.widgets.nattable.tree.command.TreeCollapseAllCommand;

import org.eclipse.nebula.widgets.nattable.tree.command.TreeExpandAllCommand;

import org.eclipse.nebula.widgets.nattable.viewport.ViewportLayer;

import org.eclipse.swt.SWT;

import org.eclipse.swt.events.SelectionAdapter;

import org.eclipse.swt.events.SelectionEvent;

import org.eclipse.swt.graphics.Image;

import org.eclipse.swt.layout.GridData;

import org.eclipse.swt.layout.GridLayout;

import org.eclipse.swt.widgets.Button;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Label;

import eu.etaxonomy.cdm.api.application.ICdmRepository;

import eu.etaxonomy.cdm.api.service.IPreferenceService;

import eu.etaxonomy.cdm.model.metadata.CdmPreference;

import eu.etaxonomy.cdm.model.metadata.PreferencePredicate;

import eu.etaxonomy.taxeditor.editor.l10n.Messages;

import eu.etaxonomy.taxeditor.model.ImageResources;

import eu.etaxonomy.taxeditor.model.MessagingUtils;

import eu.etaxonomy.taxeditor.preference.PreferencesUtil;

import eu.etaxonomy.taxeditor.store.CdmStore;

/**

 * @author pplitzner

 * @since Jul 9, 2018

 *

 */

public class CharacterMatrixToolbar extends Composite {

    private CharacterMatrix matrix;

    private Label wsLabel;

    private DisplayPersistenceDialogCommandHandler displayPersistenceDialogCommandHandler;

    private Properties natTableState;

    public CharacterMatrixToolbar(CharacterMatrix matrix, int style) {

        super(matrix, style);

        this.matrix = matrix;

        init();

    }

    private void init() {

        setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false));

        setLayout(new GridLayout(10, false));

        wsLabel = new Label(this, SWT.NONE);

        Button btnToggleTooltips = new Button(this, SWT.TOGGLE);

        Button btnToggleTree = new Button(this, SWT.PUSH);

        Button btnToggleFlat = new Button(this, SWT.PUSH);

        Button btnCollapseAll = new Button(this, SWT.PUSH);

        Button btnExpandAll = new Button(this, SWT.PUSH);

        Button btnFreezeSuppInfo = new Button(this, SWT.TOGGLE);

        ComboViewer comboStates = new ComboViewer(this, SWT.DROP_DOWN);

        Button btnManageState = new Button(this, SWT.PUSH);

        Button btnExcelExport = new Button(this, SWT.PUSH);

        /**

         * Toggle tooltips button

         */

        initButton(

                btnToggleTooltips,

                ImageResources.getImage(ImageResources.LIGHT_BULB),

                "Show tooltips",

                null,

                true,

                true,

                (e)->matrix.toogleIsShowTooltips()

                );

        /**

         * Toogle tree button

         */

        initButton(

                btnToggleTree,

                ImageResources.getImage(ImageResources.HIERARCHICAL),

                Messages.CharacterMatrix_SHOW_HIERARCHY,

                null,

                false,

                true,

                (e)->matrix.toggleTreeFlat(true, btnToggleFlat, btnToggleTree, btnCollapseAll, btnExpandAll, btnFreezeSuppInfo)

                );

        /**

         * Toogle flat button

         */

        initButton(

                btnToggleFlat,

                ImageResources.getImage(ImageResources.FLAT),

                Messages.CharacterMatrix_SHOW_FLAT_LIST,

                null,

                true,

                false,

                (e)->matrix.toggleTreeFlat(false, btnToggleFlat, btnToggleTree, btnCollapseAll, btnExpandAll, btnFreezeSuppInfo)

                );

        /**

         *

         * Collapse button

         */

        initButton(

                btnCollapseAll,

                ImageResources.getImage(ImageResources.COLLAPSE_ALL),

                Messages.CharacterMatrix_COLLAPSE,

                null,

                true,

                false,

                (e)->matrix.getNatTable().doCommand(new TreeCollapseAllCommand())

                );

        /**

         * Expand button

         */

        initButton(

                btnExpandAll,

                ImageResources.getImage(ImageResources.EXPAND_ALL),

                Messages.CharacterMatrix_EXPAND,

                null,

                true,

                false,

                (e)->matrix.getNatTable().doCommand(new TreeExpandAllCommand())

                );

        /**

         * Freeze supplemental info button

         */

        initButton(

                btnFreezeSuppInfo,

                ImageResources.getImage(ImageResources.LOCK_ICON),

                Messages.CharacterMatrix_LOCK_COLUMNS,

                null,

                true,

                true,

                (e)->{

                    boolean isSelected = btnFreezeSuppInfo.getSelection();

                    matrix.freezeSupplementalColumns(isSelected);

                    btnFreezeSuppInfo.setImage(isSelected?

                            ImageResources.getImage(ImageResources.LOCK_ICON):

                                ImageResources.getImage(ImageResources.LOCK_OPEN_ICON));

                }

                );

        /**

         * Table state persistence

         */

        natTableState = new Properties();

        //load persisted state

        try {

            CdmPreference preference = PreferencesUtil.getPreferenceFromDB(PreferencePredicate.CharacterMatrixTableState);

            if(preference!=null){

                natTableState.load(new StringReader(preference.getValue()));

            }

        } catch (IOException e1) {

            MessagingUtils.error(getClass(), e1);

        }

        // create a combobox for showing the available view states

        Collection<String> availableStates = PersistenceHelper.getAvailableStates(natTableState);

        if(availableStates.isEmpty()){

            natTableState.put(StringUtils.EMPTY, StringUtils.EMPTY); // add default config if no states are persisted

            natTableState.setProperty(PersistenceDialog.ACTIVE_VIEW_CONFIGURATION_KEY, StringUtils.EMPTY);

            availableStates.add(StringUtils.EMPTY);

        }

        comboStates.setLabelProvider(new LabelProvider(){

            @Override

            public String getText(Object element) {

                if(element instanceof String && ((String) element).isEmpty()){

                    return Messages.CharacterMatrix_DEFAULT;

                }

                return super.getText(element);

            }

        });

        comboStates.setContentProvider(new ArrayContentProvider());

        comboStates.addSelectionChangedListener(e->

        {

            int index = comboStates.getCombo().getSelectionIndex();

            if (index >= 0) {

                String selected = comboStates.getCombo().getItem(index);

                // load the state

                matrix.getNatTable().loadState(selected, natTableState);

                natTableState.setProperty(PersistenceDialog.ACTIVE_VIEW_CONFIGURATION_KEY, selected);

            }

        });

        comboStates.setInput(availableStates);

        if(comboStates.getCombo().getItemCount()>0){

           selectStateItem(comboStates, Messages.CharacterMatrix_DEFAULT);

        }

        displayPersistenceDialogCommandHandler = new DisplayPersistenceDialogCommandHandler(natTableState, matrix.getNatTable());

        // add listener to update the combo on view state management changes

        displayPersistenceDialogCommandHandler.addStateChangeListener(new IStateChangedListener() {

            @Override

            public void handleStateChange(StateChangeEvent event) {

                comboStates.setInput(PersistenceHelper.getAvailableStates(natTableState));

                selectStateItem(comboStates, event.getViewConfigName());

            }

        });

        // add button to show dialog

        btnManageState.setImage(ImageResources.getImage(ImageResources.SETTINGS));

        btnManageState.setToolTipText(Messages.CharacterMatrix_VIEW_CONFIG);

        btnManageState.addSelectionListener(new SelectionAdapter() {

            @Override

            public void widgetSelected(SelectionEvent e) {

                getNatTableState().remove(NatTable.INITIAL_PAINT_COMPLETE_FLAG);

                matrix.getNatTable().doCommand(new DisplayPersistenceDialogCommand(matrix.getNatTable()));

                Object activeConfig = natTableState.get(PersistenceDialog.ACTIVE_VIEW_CONFIGURATION_KEY);

                if(activeConfig!=null){

                    selectStateItem(comboStates, activeConfig.toString());

                }

                persistTableState();

            }

        });

        /**

         * excel export

         */

        btnExcelExport.setToolTipText(Messages.CharacterMatrix_EXPORT);

        btnExcelExport.setImage(ImageResources.getImage(ImageResources.EXPORT));

        btnExcelExport.addSelectionListener(new SelectionAdapter() {

            @Override

            public void widgetSelected(SelectionEvent e) {

                // hack for fixing #8332

                // By scrolling for only 1 pixel the export then exports all rows

                ViewportLayer viewportLayer = matrix.getBodyLayer().getViewportLayer();

                if(viewportLayer.getOrigin().getY()==0){

                    viewportLayer.setOriginY(1);

                }

                matrix.getNatTable().doCommand(

                        new ExportCommand(

                                matrix.getNatTable().getConfigRegistry(),

                                matrix.getNatTable().getShell()));

                matrix.getNatTable().doCommand(new VisualRefreshCommand());

            }

        });

    }

    private void persistTableState() {

        if(matrix.getNatTableState()!=null){

            StringWriter writer = new StringWriter();

            try {

                matrix.getNatTableState().store(writer, null);

                ICdmRepository controller = CdmStore.getCurrentApplicationConfiguration();

                if (controller != null){

                    IPreferenceService service = controller.getPreferenceService();

                    CdmPreference pref = CdmPreference.NewTaxEditorInstance(PreferencePredicate.CharacterMatrixTableState, writer.toString());

                    service.set(pref);

                    PreferencesUtil.updateDBPreferences();

                }

            } catch (IOException e) {

                MessagingUtils.error(getClass(), e);

            }

        }

    }

    private void selectStateItem(ComboViewer comboStates, String stateName){

        if(stateName.equals(StringUtils.EMPTY)){

            stateName = Messages.CharacterMatrix_DEFAULT;

        }

        String[] items = comboStates.getCombo().getItems();

        for(int i=0;i<items.length;i++){

            if(items[i].equals(stateName)){

                comboStates.getCombo().select(i);

                break;

            }

        }

    }

    private void initButton(Button button, Image image, String tooltipText,

            String label, boolean enabled, boolean selected, Consumer<SelectionEvent> widgetSelected){

        if(image!=null){

            button.setImage(image);

        }

        if(label!=null){

            button.setText(label);

        }

        if(tooltipText!=null){

            button.setToolTipText(tooltipText);

        }

        button.setSelection(selected);

        button.setEnabled(enabled);

        button.addSelectionListener(new SelectionAdapter() {

            @Override

            public void widgetSelected(SelectionEvent e) {

                widgetSelected.accept(e);

            }

        });

    }

    public Label getWsLabel() {

        return wsLabel;

    }

    public Properties getNatTableState() {

        return natTableState;

    }

    public DisplayPersistenceDialogCommandHandler getDisplayPersistenceDialogCommandHandler() {

        return displayPersistenceDialogCommandHandler;

    }

}