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

package com.fr.design.sort.header;

import com.fr.base.FineColor;
import com.fr.base.i18n.BidiUtils;
import com.fr.base.svg.SVGIcon;
import com.fr.design.event.UIObserver;
import com.fr.design.event.UIObserverListener;
import com.fr.design.gui.icheckbox.UICheckBox;
import com.fr.design.gui.ilable.UILabel;
import com.fr.design.gui.ipoppane.PopupHider;
import com.fr.design.i18n.DesignSizeI18nManager;
import com.fr.design.i18n.Toolkit;
import com.fr.design.layout.TableLayoutHelper;
import com.fr.design.style.color.ColorControlWindow;
import com.fr.design.utils.gui.GUICoreUtils;
import com.fr.report.core.sort.header.HeaderIconBuilder;
import com.fr.report.core.sort.header.SortHeader;
import com.fr.report.core.sort.common.SortRule;

import javax.swing.*;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import java.awt.*;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.image.BufferedImage;
import java.util.ArrayList;

public class HeaderSortRulePane extends JPanel {
    IconButton ascIconButton;
    IconButton desIconButton;
    IconButton nosortIconButton;
    UICheckBox ascUICheckBox;
    UICheckBox desUICheckBox;
    UICheckBox nosortUICheckBox;
    Color defaultColor = new Color(33, 33, 34);
    public static final int ICON_LENGTH = 20;

    HeaderSortRulePane() {
        initComponents();
        initState(true);
        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.LEADING);
        BidiUtils.setOrientationByLocale(uiLabel);
        this.add(uiLabel, BorderLayout.NORTH);
    }

    void initSortRuleItem() {
        Component[][] components = new Component[][]{
                new Component[]{ascUICheckBox = new UICheckBox(SortRule.ASC.getDescription()), ascIconButton = new IconButton(SortRule.ASC)},
                new Component[]{desUICheckBox = new UICheckBox(SortRule.DES.getDescription()), desIconButton = new IconButton(SortRule.DES)},
                new Component[]{nosortUICheckBox = new UICheckBox(SortRule.NO_SORT.getDescription()), nosortIconButton = new IconButton(SortRule.NO_SORT)},
        };
        double[] rowSize = {ICON_LENGTH + 10, ICON_LENGTH + 10, ICON_LENGTH + 10};
        double[] columnSize =
                {DesignSizeI18nManager.getInstance().i18nDimension("com.fr.design.sort.rule.item").getWidth(), ICON_LENGTH + 10};
        JPanel sortRuleItem = TableLayoutHelper.createCommonTableLayoutPane(components, rowSize, columnSize, 0);
        this.add(sortRuleItem, BorderLayout.CENTER);
        initUICheckBoxChange(ascUICheckBox, ascIconButton);
        initUICheckBoxChange(desUICheckBox, desIconButton);
        initUICheckBoxChange(nosortUICheckBox, nosortIconButton);
    }

    void initUICheckBoxChange(UICheckBox uiCheckBox, IconButton iconButton) {
        uiCheckBox.addChangeListener(new ChangeListener() {
            @Override
            public void stateChanged(ChangeEvent e) {
                iconButton.setActiveState(uiCheckBox.isSelected());
            }
        });
    }

    void initState(boolean selected) {
        ascUICheckBox.setSelected(selected);
        desUICheckBox.setSelected(selected);
        nosortUICheckBox.setSelected(selected);
        ascIconButton.refreshIconLabelColor(new FineColor(defaultColor));
        desIconButton.refreshIconLabelColor(new FineColor(defaultColor));
        nosortIconButton.refreshIconLabelColor(new FineColor(defaultColor));
    }

    class IconButton extends JPanel implements UIObserver, PopupHider {
        SortRule sortRule;
        JLayeredPane jLayeredPane;
        UILabel iconLabel;
        FineColor fineColor = new FineColor(defaultColor);
        UIObserverListener uiObserverListener;
        boolean activeState;
        UILabel borderUiLabel;
        private ColorControlWindow colorSelector;

        IconButton(SortRule sortRule) {
            this.sortRule = sortRule;
            initComponents();
        }

        public boolean isActiveState() {
            return activeState;
        }

        public void setActiveState(boolean activeState) {
            if (activeState) {
                borderUiLabel.setBorder(BorderFactory.createLineBorder(Color.gray, 1));
            } else {
                borderUiLabel.setBorder(null);
            }
            this.activeState = activeState;
        }

        void initComponents() {
            jLayeredPane = new JLayeredPane();
            iconLabel = getIconLabel();
            borderUiLabel = new UILabel();
            borderUiLabel.setSize(ICON_LENGTH, ICON_LENGTH);
            borderUiLabel.setOpaque(true);
            borderUiLabel.setBackground(Color.WHITE);
            iconLabel.setSize(ICON_LENGTH, ICON_LENGTH);
            iconLabel.addMouseListener(new MouseAdapter() {
                @Override
                public void mouseClicked(MouseEvent e) {
                    if (activeState) {
                        showPopupMenu();
                    }
                }
            });
            jLayeredPane.setPreferredSize(new Dimension(ICON_LENGTH, ICON_LENGTH));
            jLayeredPane.add(iconLabel, JLayeredPane.POPUP_LAYER);
            jLayeredPane.add(borderUiLabel, JLayeredPane.MODAL_LAYER);
            this.add(jLayeredPane);
        }

        void refreshIconLabelColor(FineColor fineColor) {
            this.fineColor = fineColor;
            Icon icon = getIcon(fineColor);
            refreshIconLabel(icon);
        }

        Icon getIcon(FineColor fineColor) {
            BufferedImage bufferedImage = HeaderIconBuilder.getIcon(sortRule, fineColor);
            Icon icon = new SVGIcon(bufferedImage);
            return icon;
        }

        void refreshIconLabel(BufferedImage bufferedImage) {
            if (bufferedImage != null) {
                Icon icon = new SVGIcon(bufferedImage);
                refreshIconLabel(icon);
            }
        }

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

        UILabel getIconLabel() {
            return getIconLabel(new FineColor(defaultColor));
        }

        UILabel getIconLabel(FineColor fineColor) {
            Icon svgIcon = getIcon(fineColor);
            return new UILabel(svgIcon);
        }

        private void showPopupMenu() {
            hidePopupMenu();
            colorSelector = this.getColorSelector();
            GUICoreUtils.showPopupMenu(colorSelector, this, 0, this.getSize().height);
        }

        @Override
        public void hidePopupMenu() {
            if (colorSelector != null) {
                colorSelector.setVisible(false);
            }
            colorSelector = null;
        }

        private ColorControlWindow getColorSelector() {
            return new ColorControlWindow(false, IconButton.this) {
                @Override
                protected void colorChanged() {
                    Color color = this.getColor();
                    if (color instanceof FineColor) {
                        fineColor = (FineColor) color;
                    } else {
                        fineColor = new FineColor(color);
                    }
                    refreshIconLabelColor(fineColor);
                    hidePopupMenu();
                    uiObserverListener.doChange();
                }
            };
        }


        @Override
        public void registerChangeListener(UIObserverListener uiObserverListener) {
            this.uiObserverListener = uiObserverListener;
        }

        @Override
        public boolean shouldResponseChangeListener() {
            return true;
        }
    }

    public void populateBean(SortHeader.SortItem[] sortItems) {
        initState(sortItems == null);
        if (sortItems != null) {
            for (SortHeader.SortItem sortItem : sortItems) {
                SortRule sortRule = sortItem.getSortRule();
                BufferedImage bufferedImage = sortItem.getBufferedImage();
                FineColor fineColor = sortItem.getFineColor();
                if (sortRule == SortRule.ASC) {
                    ascIconButton.refreshIconLabel(bufferedImage);
                    ascIconButton.refreshIconLabelColor(fineColor);
                    ascUICheckBox.setSelected(true);
                } else if (sortRule == SortRule.DES) {
                    desIconButton.refreshIconLabel(bufferedImage);
                    desIconButton.refreshIconLabelColor(fineColor);
                    desUICheckBox.setSelected(true);
                } else if (sortRule == SortRule.NO_SORT) {
                    nosortIconButton.refreshIconLabel(bufferedImage);
                    nosortIconButton.refreshIconLabelColor(fineColor);
                    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.fineColor));
        }
        if (desUICheckBox.isSelected()) {
            items.add(new SortHeader.SortItem(SortRule.DES, desIconButton.fineColor));
        }
        if (nosortUICheckBox.isSelected()) {
            items.add(new SortHeader.SortItem(SortRule.NO_SORT, nosortIconButton.fineColor));
        }
        SortHeader.SortItem[] resultItems = new SortHeader.SortItem[items.size()];
        return items.toArray(resultItems);
    }

}