design/designer-realize/src/main/java/com/fr/design/sort/header/HeaderSortRulePane.java

package com.fr.design.sort.header;

import com.fr.base.svg.SVGIcon;
import com.fr.base.svg.SVGTranscoder;
import com.fr.design.event.UIObserverListener;
import com.fr.design.gui.icheckbox.UICheckBox;
import com.fr.design.gui.ilable.UILabel;
import com.fr.design.i18n.Toolkit;
import com.fr.design.layout.TableLayoutHelper;
import com.fr.design.mainframe.theme.edit.ui.ColorListPane;
import com.fr.general.IOUtils;
import com.fr.report.core.sort.header.SortHeader;
import com.fr.report.core.sort.common.SortRule;
import org.apache.batik.transcoder.TranscoderInput;

import javax.swing.*;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.util.ArrayList;

public class HeaderSortRulePane extends JPanel {


    private static final String ASC_ICON_TEMPLATE_PATH = "/com/fr/design/images/sort/asc.svg";
    private static final String DES_ICON_TEMPLATE_PATH = "/com/fr/design/images/sort/des.svg";
    private static final String NOSORT_ICON_TEMPLATE_PATH = "/com/fr/design/images/sort/nosort.svg";
    IconButton ascIconButton;
    IconButton desIconButton;
    IconButton nosortIconButton;
    UICheckBox ascUICheckBox;
    UICheckBox desUICheckBox;
    UICheckBox nosortUICheckBox;


    HeaderSortRulePane() {
        initComponents();
        initState();
        this.setBorder(BorderFactory.createEmptyBorder(0, 15, 0, 15));
    }

    void initComponents() {
        this.setLayout(new BorderLayout());
        initUILabel();
        initSortRuleItem();
        this.setPreferredSize(new Dimension(160, 160));
    }

    void initUILabel() {
        UILabel uiLabel = new UILabel(Toolkit.i18nText("Fine-Design_Sort_Header_Sort_Basis"), SwingConstants.LEFT);
        this.add(uiLabel, BorderLayout.NORTH);
    }

    void initSortRuleItem() {
        Component[][] components = new Component[][]{
                new Component[]{ascUICheckBox = new UICheckBox(SortRule.ASC.getDescription()), ascIconButton = new IconButton(ASC_ICON_TEMPLATE_PATH)},
                new Component[]{desUICheckBox = new UICheckBox(SortRule.DES.getDescription()), desIconButton = new IconButton(DES_ICON_TEMPLATE_PATH)},
                new Component[]{nosortUICheckBox = new UICheckBox(SortRule.NO_SORT.getDescription()), nosortIconButton = new IconButton(NOSORT_ICON_TEMPLATE_PATH)},
        };
        double[] rowSize = {24, 24, 24};
        double[] columnSize = {80, 30};
        JPanel sortRuleItem = TableLayoutHelper.createCommonTableLayoutPane(components, rowSize, columnSize, 0);
        this.add(sortRuleItem, BorderLayout.CENTER);
    }

    void initState() {
        ascUICheckBox.setSelected(false);
        desUICheckBox.setSelected(false);
        nosortUICheckBox.setSelected(false);
        ascIconButton.refreshIconLabelColor(new Color(33, 33, 34));
        desIconButton.refreshIconLabelColor(new Color(33, 33, 34));
        nosortIconButton.refreshIconLabelColor(new Color(33, 33, 34));
    }


    class IconButton extends JPanel {
        JLayeredPane jLayeredPane;
        String iconTemplatePath;
        UILabel iconLabel;
        ColorListPane.ColorButton colorButton;
        Color color;
        BufferedImage bufferedImage;
        UIObserverListener uiObserverListener;

        IconButton(String iconTemplatePath) {
            this.iconTemplatePath = iconTemplatePath;
            initComponents();
        }

        void initComponents() {
            jLayeredPane = new JLayeredPane();
            iconLabel = getIconLabel(iconTemplatePath);


            UILabel emptyUiLabel = new UILabel();
            emptyUiLabel.setSize(16, 16);
            emptyUiLabel.setOpaque(true);
            emptyUiLabel.setBackground(Color.WHITE);
            iconLabel.setSize(16, 16);
            colorButton = new ColorListPane.ColorButton(Color.CYAN);
            colorButton.setSize(16, 16);
            colorButton.addChangeListener(new ChangeListener() {
                @Override
                public void stateChanged(ChangeEvent e) {
                    color = colorButton.getSelectObject();
                    refreshIconLabelColor(color);
                    if (uiObserverListener != null) {
                        uiObserverListener.doChange();
                    }
                }
            });
            jLayeredPane.setPreferredSize(new Dimension(16, 16));

            jLayeredPane.add(iconLabel, JLayeredPane.POPUP_LAYER);
            jLayeredPane.add(emptyUiLabel, JLayeredPane.MODAL_LAYER);
            jLayeredPane.add(colorButton, JLayeredPane.PALETTE_LAYER);
            this.add(jLayeredPane);
        }

        void refreshIconLabelColor(Color color) {
            Icon icon = getIcon(iconTemplatePath, color);
            refreshIconLabel(icon);
        }

        void refreshIconLabel(Icon icon) {
            if (icon != null) {
                iconLabel.removeAll();
                iconLabel.setIcon(icon);
                iconLabel.repaint();
            }
        }

        UILabel getIconLabel(String iconPath) {
            return getIconLabel(iconPath, new Color(33, 33, 34));
        }

        UILabel getIconLabel(String iconPath, Color color) {
            Icon svgIcon = getIcon(iconPath, color);
            return new UILabel(svgIcon);
        }

        Icon getIcon(String iconPath, Color color) {
            try {
                InputStream inputStream = IOUtils.getResourceAsStream(iconPath, HeaderSortRulePane.class);
                String svgText = getSvgText(inputStream);
                svgText = svgText.replaceAll("\\{fillColor\\}", shiftColor(color));
                InputStream svgInputStream = new ByteArrayInputStream(svgText.getBytes());
                TranscoderInput input = new TranscoderInput(svgInputStream);
                bufferedImage = SVGTranscoder.createImage(1.0, input).getImage();
                SVGIcon svgIcon = new SVGIcon(bufferedImage);
                return svgIcon;
            } catch (Exception e) {

            }
            return null;

        }

        String shiftColor(Color color) {
            StringBuilder stringBuilder = new StringBuilder();
            stringBuilder.append(shiftValue(color.getRed()));
            stringBuilder.append(shiftValue(color.getGreen()));
            stringBuilder.append(shiftValue(color.getBlue()));
            return stringBuilder.toString();
        }

        String shiftValue(int value) {
            int resultValue = (int) ((((float) value) / 255) * 99);
            if (resultValue < 10) {
                return "0" + resultValue;
            } else {
                return "" + resultValue;
            }
        }

        private String getSvgText(InputStream inputStream) throws Exception {
            StringBuffer stringBuffer = new StringBuffer();
            byte[] b = new byte[1024];
            for (int n; (n = inputStream.read(b)) != -1; ) {
                stringBuffer.append(new String(b, 0, n));
            }
            return stringBuffer.toString();
        }

        public void addListener(UIObserverListener uiObserverListener) {
            this.uiObserverListener = uiObserverListener;
        }


        public void removeListener(UIObserverListener uiObserverListener) {
            this.uiObserverListener = null;
        }
    }


    public void populateBean(SortHeader.SortItem[] sortItems) {
        initState();
        if (sortItems != null) {
            for (SortHeader.SortItem sortItem : sortItems) {
                SortRule sortRule = sortItem.getSortRule();
                BufferedImage bufferedImage = sortItem.getBufferedImage();
                Icon icon = null;
                if (bufferedImage != null) {
                    icon = new SVGIcon(bufferedImage);
                }
                if (sortRule == SortRule.ASC) {
                    ascIconButton.refreshIconLabel(icon);
                    ascUICheckBox.setSelected(true);
                } else if (sortRule == SortRule.DES) {
                    desIconButton.refreshIconLabel(icon);
                    desUICheckBox.setSelected(true);
                } else if (sortRule == SortRule.NO_SORT) {
                    nosortIconButton.refreshIconLabel(icon);
                    nosortUICheckBox.setSelected(true);
                }

            }
        }
    }

    public SortHeader.SortItem[] updateBean() {
        java.util.List<SortHeader.SortItem> items = new ArrayList<>();
        if (ascUICheckBox.isSelected()) {
            items.add(new SortHeader.SortItem(SortRule.ASC, ascIconButton.bufferedImage));
        }
        if (desUICheckBox.isSelected()) {
            items.add(new SortHeader.SortItem(SortRule.DES, desIconButton.bufferedImage));
        }
        if (nosortUICheckBox.isSelected()) {
            items.add(new SortHeader.SortItem(SortRule.NO_SORT, nosortIconButton.bufferedImage));
        }
        SortHeader.SortItem[] resultItems = new SortHeader.SortItem[items.size()];
        return items.toArray(resultItems);
    }

    public void addListener(UIObserverListener uiObserverListener) {
        ascIconButton.addListener(uiObserverListener);
        desIconButton.addListener(uiObserverListener);
        nosortIconButton.addListener(uiObserverListener);
        ascUICheckBox.registerChangeListener(uiObserverListener);
        desUICheckBox.registerChangeListener(uiObserverListener);
        nosortUICheckBox.registerChangeListener(uiObserverListener);
    }


    public void removeListener(UIObserverListener uiObserverListener) {
        ascIconButton.removeListener(uiObserverListener);
        desIconButton.removeListener(uiObserverListener);
        nosortIconButton.removeListener(uiObserverListener);
        ascUICheckBox.removeChangeListener();
        desUICheckBox.removeChangeListener();
        nosortUICheckBox.removeChangeListener();
    }
}