package arcommon.ui.other;

import java.awt.Component;
import java.awt.Container;
import java.awt.Dialog;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.Font;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.GraphicsConfiguration;
import java.awt.GraphicsDevice;
import java.awt.GraphicsEnvironment;
import java.awt.KeyboardFocusManager;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.Toolkit;
import java.awt.Window;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ComponentEvent;
import java.awt.event.ComponentListener;
import java.awt.event.KeyEvent;
import java.awt.event.WindowEvent;
import java.awt.font.TextLayout;
import java.awt.geom.Rectangle2D;
import java.io.File;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;

import javax.swing.AbstractAction;
import javax.swing.Action;
import javax.swing.ActionMap;
import javax.swing.InputMap;
import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JDialog;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JTree;
import javax.swing.KeyStroke;
import javax.swing.SwingUtilities;
import javax.swing.filechooser.FileNameExtensionFilter;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.TreePath;

import arcommon.DateUtil;
import arcommon.FileUtil;
import arcommon.MyThread;
import arcommon.ReflectionUtil;
import arcommon.StringUtil;
import arcommon.Util;

public class GUIUtil {
    public static String defaultSelectAFileOrDirectoryPath;
    
    public enum YesNoDialogAnswer {
        YES,
        NO,
        CANCEL
    }
    
    public static Window getFocusedWindow() {
        Window activeWindow = KeyboardFocusManager.getCurrentKeyboardFocusManager().getActiveWindow();
        return activeWindow;
    }

    public static String selectAFile(String baseFileName, boolean mustExist, String title) {
        return selectAFile(baseFileName, mustExist, title, null);
    }

    public static String selectAFile(String baseFileName, boolean mustExist, String title, String buttonText) {
        return selectAFileOrDirectory(getFocusedWindow(), baseFileName, JFileChooser.FILES_ONLY, mustExist, true, title, buttonText);
    }
    
    public static String selectADirectory(String basePath, boolean mustExist, String title) {
        return selectADirectory(basePath, mustExist, title, null);
    }

    public static String selectADirectory(String basePath, boolean mustExist, String title, String buttonText) {
        return selectAFileOrDirectory(getFocusedWindow(), basePath, JFileChooser.DIRECTORIES_ONLY, mustExist, false, title, buttonText);
    }
    
    private static String selectAFileOrDirectory(Component parentComponent, String baseFileName, final int fileSelectionMode, final boolean mustExist, boolean useFilter, String title, String buttonText) {
        JFileChooser chooser = new JFileChooser() {
            private static final long serialVersionUID = -8132855969954010280L;

            @Override
            public void approveSelection() {
                if (mustExist && !getSelectedFile().exists()) {
                    switch (fileSelectionMode) {
                        case JFileChooser.FILES_ONLY :
                            showErrorMessage("Select a existing file");
                        break;
                        case JFileChooser.DIRECTORIES_ONLY :
                            showErrorMessage("Select a existing directory");
                        break;
                        case JFileChooser.FILES_AND_DIRECTORIES :
                            showErrorMessage("Select a existing file or directory");
                        break;
                        default :
                            throw new RuntimeException("Unknown fileSelectionMode " + fileSelectionMode);
//                        break;
                    }
                    return ;
                }
    
                super.approveSelection();
            }
        };

        if (title != null && title.length() > 0) {
            chooser.setDialogTitle(title);
        }
        
        chooser.setFileSelectionMode(fileSelectionMode);
        
        if (baseFileName != null && !baseFileName.equals("")) {
            String existingParentPath = null;
            if (fileSelectionMode != JFileChooser.DIRECTORIES_ONLY) {
                // File
                String absoluteFileName = FileUtil.calculateAbsoluteFileName(baseFileName);
                if (FileUtil.exists(absoluteFileName)) {
                    existingParentPath = FileUtil.calculatePath(absoluteFileName);
                } else {
                    if (defaultSelectAFileOrDirectoryPath != null && defaultSelectAFileOrDirectoryPath.length() > 0) {
                        absoluteFileName = FileUtil.calculateAbsoluteFileName(defaultSelectAFileOrDirectoryPath, baseFileName);
                        if (FileUtil.exists(absoluteFileName)) {
                            existingParentPath = FileUtil.calculatePath(absoluteFileName);
                        }
                    }
                }
            } else {
                // Directory
                String absolutePath = FileUtil.calculateAbsolutePath(baseFileName);
                if (FileUtil.exists(absolutePath)) {
                    existingParentPath = absolutePath;
                } else {
                    if (defaultSelectAFileOrDirectoryPath != null && defaultSelectAFileOrDirectoryPath.length() > 0) {
                        absolutePath = FileUtil.calculateAbsolutePath(defaultSelectAFileOrDirectoryPath, baseFileName);
                        if (FileUtil.exists(absolutePath)) {
                            existingParentPath = absolutePath;
                        }
                    }
                }
            }
            
            if (existingParentPath == null) {
                String path = FileUtil.calculatePath(baseFileName);
                String absolutePath = null;
                if (defaultSelectAFileOrDirectoryPath != null && defaultSelectAFileOrDirectoryPath.length() > 0) {
                    absolutePath = FileUtil.calculateAbsolutePath(defaultSelectAFileOrDirectoryPath, path);
                } else {
                    absolutePath = FileUtil.calculateAbsolutePath(path);
                }
                existingParentPath = FileUtil.findExistingParent(absolutePath);
            }
            
            chooser.setCurrentDirectory(new File(existingParentPath));
            
            if (fileSelectionMode != JFileChooser.DIRECTORIES_ONLY) {
                // File
                String fileName = existingParentPath + FileUtil.calculateFileName(baseFileName);
                chooser.setSelectedFile(new File(fileName));
                if (useFilter) {
                    String extension = FileUtil.calculateExtension(baseFileName, false);
                    if (extension.length() > 0 && !extension.equals("*")) {
                        setFilter(chooser, extension);
                    }
                }
            }
        } else {
            if (defaultSelectAFileOrDirectoryPath != null && defaultSelectAFileOrDirectoryPath.length() > 0) {
                chooser.setCurrentDirectory(new File(defaultSelectAFileOrDirectoryPath));
            } else {
                chooser.setCurrentDirectory(new File(FileUtil.currentPath()));
            }
        }
        
        int returnValue = chooser.showDialog(parentComponent, buttonText);
        if (returnValue != JFileChooser.APPROVE_OPTION) {
            return null;
        }
        
        String result = chooser.getSelectedFile().getAbsolutePath();
        switch (fileSelectionMode) {
            case JFileChooser.FILES_ONLY :
                ;
            break;
            case JFileChooser.DIRECTORIES_ONLY :
                if (!result.endsWith(File.separator)) {
                    result += File.separator;
                }
            break;
            case JFileChooser.FILES_AND_DIRECTORIES :
                ;
            break;
            default :
                throw new RuntimeException("Unknown fileSelectionMode " + fileSelectionMode);
//          break;
        }
        
        return result;
    }
    
    private static void setFilter(JFileChooser chooser, String extension) {
        String description = StringUtil.firstCharUpperCase(extension) + " files";
        FileNameExtensionFilter filter = new FileNameExtensionFilter(description, extension);
        chooser.addChoosableFileFilter(filter);
        // This remove and add is done to move the "All files" filter last, and to make the created filter the selected one.
        chooser.removeChoosableFileFilter(chooser.getAcceptAllFileFilter());
        chooser.addChoosableFileFilter(chooser.getAcceptAllFileFilter());
    }

    public static void showInformation(String information) {
        showInformation(information, "Information");
    }

    private static void showInformation(String information, String title) {
        showMessage(information, title, JOptionPane.INFORMATION_MESSAGE);
    }

    public static void showWarning(String warning) {
        showWarning(warning, "Warning");
    }

    public static void showWarning(String warning, String title) {
        showMessage(warning, title, JOptionPane.WARNING_MESSAGE);
    }
    
    public static void showErrorMessage(String errorMessage) {
        showErrorMessage(errorMessage, "Error");
    }

    public static void showErrorMessage(String errorMessage, String title) {
        showMessage(errorMessage, title, JOptionPane.ERROR_MESSAGE);
    }

    private static void showMessage(String message, String title, int type) {
        validateDialogTextSize(message);
        validateDialogTextSize(title);
        JOptionPane.showMessageDialog(getFocusedWindow(), message, title, type);
    }

    public static boolean showInformationInTime(String message, int timeInMilliseconds) {
        return showMessageInTime(message, "Information", JOptionPane.INFORMATION_MESSAGE, timeInMilliseconds);
    }
    
    public static boolean showErrorMessageInTime(String message, int timeInMilliseconds) {
        return showMessageInTime(message, "Error", JOptionPane.ERROR_MESSAGE, timeInMilliseconds);
    }
    
    public static boolean showMessageInTime(final String message, final String title, final int type, final int timeInMilliseconds) {
        if (type > JOptionPane.QUESTION_MESSAGE) {
            throw new IllegalArgumentException("type > JOptionPane.QUESTION_MESSAGE " + type);
        }
        MyThread thread = new MyThread("Show in time thread") {
            int count = 0;
            public void doLoop() {
                if (count < timeInMilliseconds / DateUtil.SECOND_IN_MILLISECONDS) {
                    count++;
                    Util.sleep(DateUtil.SECOND_IN_MILLISECONDS);
                    return ;
                }
                Runnable runnable = new Runnable() {
                    public void run() {
                        Window[] windows = Frame.getWindows();
                        for (int k = 0; k < windows.length; k++) {
                            Window window = windows[k];
                            if (!window.isVisible()) {
                                continue;
                            }
                            if (!(window instanceof JDialog)) {
                                continue;
                            }
                            JDialog jdialog = (JDialog)window;
                            if (jdialog.getTitle().equals(title)) {
                                jdialog.setVisible(false);
                                break;
                            }
                        }
                    }
                };
                SwingUtilities.invokeLater(runnable);
                
                setRequestedToStop(true);
            }
        };
        thread.start();
        
        showMessage(message, title, type);
        
        if (thread.isAlive()) {
            thread.setRequestedToStop(true);
            return true;
        }
        return false;
    }

    public static Object showSelectDialog(String title, String label, Object[] options, Object currentValue) {
        validateDialogTextSize(title);
        validateDialogTextSize(label);
        return JOptionPane.showInputDialog(getFocusedWindow(), label, title, JOptionPane.QUESTION_MESSAGE, null, options, currentValue);
    }
    
    public static YesNoDialogAnswer showYesNoCancelDialog(String question) {
        return showYesNoCancelDialog(question, "Question");
    }

    public static YesNoDialogAnswer showYesNoCancelDialog(Component parentComponent, String question) {
        return showYesNoCancelDialog(parentComponent, question, "Question");
    }

    public static YesNoDialogAnswer showYesNoCancelDialog(String question, String title) {
        return showYesNoCancelDialog(getFocusedWindow(), question, title);
    }

    private static YesNoDialogAnswer showYesNoCancelDialog(Component parentComponent, String question, String title) {
        validateDialogTextSize(question);
        validateDialogTextSize(title);
        int result = JOptionPane.showConfirmDialog(parentComponent, question, title, JOptionPane.YES_NO_CANCEL_OPTION);
        switch (result) {
            case JOptionPane.YES_OPTION :
                return YesNoDialogAnswer.YES;
//          break;
            case JOptionPane.NO_OPTION :
                return YesNoDialogAnswer.NO;
//          break;
            case JOptionPane.CANCEL_OPTION :
                return YesNoDialogAnswer.CANCEL;
//          break;
            case JOptionPane.CLOSED_OPTION :
                return YesNoDialogAnswer.CANCEL;
//          break;
            default :
                throw new RuntimeException("Unknown option: " + result);
//          break;
        }
    }

    public static boolean showOkCancelDialog(String question) {
        return showOkCancelDialog(question, "Question");
    }

    public static boolean showOkCancelDialog(String question, String title) {
        return showOkCancelDialog(getFocusedWindow(), question, title);
    }

    private static boolean showOkCancelDialog(Component parentComponent, String question, String title) {
        validateDialogTextSize(question);
        validateDialogTextSize(title);
        return JOptionPane.showConfirmDialog(parentComponent, question, title, JOptionPane.OK_CANCEL_OPTION) == JOptionPane.OK_OPTION;
    }
    
    public static final int MAX_DIALOG_TEXT_LENGTH = 10000;
    public static final int MAX_DIALOG_TEXT_HEIGHT = 200;
    public static final int MAX_DIALOG_TEXT_WIDTH = 1000;
    
    private static void validateDialogTextSize(String dialogText) {
        if (dialogText == null) {
            throw new NullPointerException("dialogText == null");
        }
        if (dialogText.length() > MAX_DIALOG_TEXT_LENGTH) {
            throw new RuntimeException("dialogText.length() > MAX_DIALOG_TEXT_LENGTH (" + dialogText.length() + " > " + MAX_DIALOG_TEXT_LENGTH + ")\n"
                    + "dialogText: " + dialogText);
        }
        
        String[] split = dialogText.split("\n", StringUtil.STRING_SPLIT_INCLUDING_TRAILING_EMPTY_STRINGS);
        if (split.length > MAX_DIALOG_TEXT_HEIGHT) {
            throw new RuntimeException("Lines in dialogText > MAX_DIALOG_TEXT_HEIGHT (" + split.length + " > " + MAX_DIALOG_TEXT_HEIGHT + ")\n"
                    + "dialogText: " + dialogText);
        }
        for (int i = 0; i < split.length; i++) {
            if (split[i].length() > MAX_DIALOG_TEXT_WIDTH) {
                throw new RuntimeException("Line " + i + " in dialogText's width > MAX_DIALOG_TEXT_WIDTH (" + split[i].length() + " > " + MAX_DIALOG_TEXT_WIDTH + ")\n"
                        + "dialogText: " + dialogText);
            }
        }
    }
    
    public static void addAccelerator(JButton button, int keyCode, int modifiers, String keyName) {
        addAccelerator(button, button, keyCode, modifiers, keyName);
    }

    public static void addAccelerator(JComponent component, JButton button, int keyCode, int modifiers, String keyName) {
        addAccelerator(component, keyCode, modifiers, keyName, new GUIUtilAction(button));
    }
    
    public static void addAccelerator(JComponent component, int keyCode, int modifiers, String keyName, AbstractAction abstractAction) {
        InputMap inputMap = new InputMap();
        inputMap.setParent(component.getInputMap());
    
        KeyStroke keyStroke = KeyStroke.getKeyStroke(keyCode, modifiers);
        inputMap.put(keyStroke, keyName);
        
        component.setInputMap(JComponent.WHEN_FOCUSED, inputMap);
    
        ActionMap actionMap = new ActionMap();
        actionMap.setParent(component.getActionMap());
        
        actionMap.put(keyName, abstractAction);
        
        component.setActionMap(actionMap);
    }

    private static class GUIUtilAction extends AbstractAction {
        public JButton button;

        public GUIUtilAction(JButton pbutton) {
            button = pbutton;
        }
        
        public void actionPerformed(ActionEvent e) {
            ActionListener[] actionListeners = button.getActionListeners();
            for (int i = 0; i < actionListeners.length; i++) {
                actionListeners[i].actionPerformed(e);
            }
        }
    
        private static final long serialVersionUID = -7259480592949440746L;
    }
    
    public static void removeAccelerator(JComponent component, int keyCode, int modifiers) {
        KeyStroke keyStroke = KeyStroke.getKeyStroke(keyCode, modifiers);
        component.getInputMap().put(keyStroke, "none");
    }

    public static void printActionMap(ActionMap actionMap) {
        Object[] allKeys = actionMap.allKeys();
        for (int i = 0; i < allKeys.length; i++) {
            Action action = actionMap.get(allKeys[i]);
            System.out.println("  " + allKeys[i].toString() + " " + allKeys[i].getClass() + " " + action);
        }
        
        ActionMap parent = actionMap.getParent();
        if (parent != null) {
            printActionMap(parent);
        }
    }

    public static void printInputMap(InputMap inputMap) {
        Object[] allKeys = inputMap.allKeys();
        if (allKeys != null) {
            for (int i = 0; i < allKeys.length; i++) {
                System.out.println(" " + allKeys[i].toString() + " " + allKeys[i].getClass());
            }
        }
        
        InputMap parent = inputMap.getParent();
        if (parent != null) {
            printInputMap(parent);
        }
    }
    
/*    // Code copied from https://stackoverflow.com/questions/16121245/start-editing-in-a-jtable-cell-only-with-reasonable-keys
    // and modified a lot
    public static KeyStroke getKeyStrokeForAction(JComponent component, String actionName) {
        InputMap bindings = component.getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT);
        for (KeyStroke key : bindings.allKeys()) {
            Object binding = bindings.get(key);
            if (actionName.equals(binding)) {
                return KeyStroke.getKeyStroke(key.getKeyCode(), key.getModifiers(), true);
            }
        }
        return null;
    }*/
    
    public static void expandTree(JTree tree) {
        expandTree(tree, (DefaultMutableTreeNode)tree.getModel().getRoot());
    }
    
    public static void expandTree(JTree tree, DefaultMutableTreeNode node) {
        expandTreeNode(tree, node);
        for (int i = 0; i < node.getChildCount(); i++) {
            DefaultMutableTreeNode child = (DefaultMutableTreeNode)node.getChildAt(i);
            expandTree(tree, child);
        }
    }

    public static void expandTreeNode(JTree tree, DefaultMutableTreeNode node) {
        TreePath selectedPath = new TreePath(node.getPath());
        tree.expandPath(selectedPath);
    }

    public static void collapseTree(JTree tree) {
        int endIndex = tree.isRootVisible() ? 0 : -1;
        int row = tree.getRowCount() - 1;
        while (row >= endIndex) {
            tree.collapseRow(row);
            row--;
        }
    }
    
    public static Dimension getScreenSize() {
        return Toolkit.getDefaultToolkit().getScreenSize();
    }

    public static void packAndCenterOnScreen(Window window) {
        window.pack();
        centerOnScreen(window);
    }
    
    public static void centerOnScreen(Window window) {
        window.setLocationRelativeTo(null);
    }
    
    public static void centerOnParent(Dialog dialog) {
        Container parent = dialog.getParent();
        dialog.setLocationRelativeTo(parent);
    }
   
    private static GraphicsDevice device;
    private static JFrame fullScreenFrame;
    
    public static boolean inFullScreenMode() {
        return fullScreenFrame != null;
    }
    
    public static void showFullScreen(JFrame frame) {
        showFullScreen(frame, null);
    }
    
    public static void showFullScreen(JFrame frame, Point location) {
        if (!frame.isUndecorated() && !frame.isDisplayable()) {
            frame.setUndecorated(true);
        }
        fullScreenFrame = frame;
        if (location == null) {
            location = frame.getLocation();
        }
        GraphicsDevice[] screenDevices = GraphicsEnvironment.getLocalGraphicsEnvironment().getScreenDevices();
        for (int i = 0; i < screenDevices.length; i++) {
            GraphicsDevice screenDevice = screenDevices[i];
            GraphicsConfiguration[] configurations = screenDevice.getConfigurations();
            for (GraphicsConfiguration configuration : configurations) {
                Rectangle bounds = configuration.getBounds();
                if (bounds.contains(location)) {
                    device = screenDevice;
                    break;
                }
            }
        }
        if (device == null) {
            device = screenDevices[0];
        }
        device.setFullScreenWindow(frame);
    }
    
    public static void cancelFullScreen() {
        device.setFullScreenWindow(null);
        fullScreenFrame = null;
    }
    
    public static int calculateTextHeight(Graphics g, String text) {
        Graphics2D g2d = (Graphics2D)g;
        return (int)new TextLayout(text, g2d.getFont(), g2d.getFontRenderContext()).getBounds().getHeight();
    }

    public static int calculateTextWidth(Graphics g, String text) {
        Graphics2D g2d = (Graphics2D)g;
        return (int)new TextLayout(text, g2d.getFont(), g2d.getFontRenderContext()).getBounds().getWidth();
    }
    
/*    public static int calculateTextHeight(JComponent component, String text) {
        return component.getFontMetrics(component.getFont()).stringHeight(text); // Missing???
    }*/

    public static int calculateTextWidth(JComponent component, String text) {
        return component.getFontMetrics(component.getFont()).stringWidth(text);
    }
    
    public static Rectangle2D calculateTextBounds(Graphics g, String text) {
        Rectangle2D result = g.getFont().getStringBounds(text, ((Graphics2D)g).getFontRenderContext());
        return result;
    }
    
    public static Rectangle2D calculateTextBounds(JComponent component, Graphics g, String text) {
        return component.getFontMetrics(component.getFont()).getStringBounds(text, 0, text.length(), g);
    }
    
    public static Rectangle calculateComponentRectangle(Component c) {
        return calculateComponentRectangle(c, null);
    }
    
    public static Rectangle calculateComponentRectangle(Component c, Component rootPane) {
        if (rootPane == null) {
            rootPane = SwingUtilities.getRootPane(c);
        }
        Point topLeftLocation = SwingUtilities.convertPoint(c, new Point(0, 0), rootPane);
        Rectangle rectangle = new Rectangle((int)topLeftLocation.getX(), (int)topLeftLocation.getY(), c.getWidth() - 1, c.getHeight() - 1);
        return rectangle;
    }
    
    public static void setFontSize(Graphics g, int fontSize) {
        g.setFont(new Font(g.getFont().getFontName(), Font.PLAIN, fontSize));
    }
    
    public static void setFontSize(Graphics g, float fontSize) {
        Font font = deriveFontSize(g.getFont(), fontSize);
        g.setFont(font);
    }

    public static Font deriveBoldFont(Font font) {
        return font.deriveFont(Font.BOLD);
    }
    
    public static Font deriveFontSize(Font font, float fontSize) {
        return font.deriveFont(fontSize);
    }
    
    public static Component findChildComponentWithName(Container container, String name) {
        int count = container.getComponentCount();
        for (int i = 0; i < count; i++) {
            Component component = container.getComponent(i);
            if (component.getName() != null && component.getName().equals(name)) {
                return component;
            }
            if (component instanceof Container) {
                Component componentWithName = findChildComponentWithName((Container)component, name);
                if (componentWithName != null) {
                    return componentWithName;
                }
            }
        }
        return null;
    }
    
    public static void requestWindowToClose(Window window) {
        // Code copied from https://stackoverflow.com/questions/1234912/how-to-programmatically-close-a-jframe
        // and modified
        WindowEvent windowEvent = new WindowEvent(window, WindowEvent.WINDOW_CLOSING);
        Toolkit.getDefaultToolkit().getSystemEventQueue().postEvent(windowEvent);
    }
    
    public static void runInEventThread(Runnable runnable) {
        if (SwingUtilities.isEventDispatchThread()) {
            runnable.run();
        } else {
            SwingUtilities.invokeLater(runnable);
        }
    }
    
    public static void runInEventThreadAndWait(Runnable runnable) {
        if (SwingUtilities.isEventDispatchThread()) {
            runnable.run();
        } else {
            try {
                SwingUtilities.invokeAndWait(runnable);
            } catch (InvocationTargetException e) {
                throw new RuntimeException(e);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
    
    private static ComponentListener containerComponentListener;
    
    public static void makePanelChangeSizeOnTooManyComponents(Container container) {
        if (!(container.getLayout() instanceof FlowLayout)) {
            throw new RuntimeException("!container.getLayout() instanceof FlowLayout " + container.getLayout());
        }
        
        if (containerComponentListener == null) {
            containerComponentListener = new ComponentListener() {
                public void componentShown(ComponentEvent e) {
                    ;
                }
                
                public void componentResized(final ComponentEvent e) {
                    Container pcontainer = (Container)e.getComponent();
                    updatePanelSize(pcontainer);
                }
                
                public void componentMoved(ComponentEvent e) {
                    ;
                }
                
                public void componentHidden(ComponentEvent e) {
                    ;
                }
            };
        }
        
        container.addComponentListener(containerComponentListener);
    }
    
    private static void updatePanelSize(Container container) {
        Component[] components = container.getComponents();
        int maxHeight = -1;
        for (int i = 0; i < components.length; i++) {
            Component component = components[i];
            int h = component.getY() + component.getHeight() + ((FlowLayout)container.getLayout()).getVgap();
            maxHeight = Math.max(maxHeight, h);
        }
        container.setPreferredSize(new Dimension(container.getPreferredSize().width, maxHeight));
        container.invalidate();
//        container.revalidate(); // 1.7 only

        Container parent = container.getParent();
        if (parent == null) {
            return ;
        }
        Container parentParent = parent.getParent();
        if (parentParent == null) {
            return ;
        }
        parentParent.invalidate();
        parentParent.validate();
    }
    
    public static boolean getScrollLockSate() {
        return Toolkit.getDefaultToolkit().getLockingKeyState(KeyEvent.VK_SCROLL_LOCK);
    }
    
    public static void setLinuxApplicationName(String applicationName) {
        if (!Util.isLinuxOS()) {
            return ;
        }
        
        if (applicationName == null) {
            throw new RuntimeException("applicationName == null");
        }
        
        if (applicationName.length() == 0) {
            throw new RuntimeException("applicationName.length() == 0");
        }
        
        try {
            // Code copied from https://stackoverflow.com/questions/46454995/how-to-hide-warning-illegal-reflective-access-in-java-9-without-jvm-argument
            // and modified
            Class<?> classInPackage = ReflectionUtil.loadClass("sun.awt.X11.XToolkit");
            ReflectionUtil.openPackageForModuleAccess(classInPackage, GUIUtil.class);
        
            Toolkit toolkit = Toolkit.getDefaultToolkit();
            Field awtAppClassNameField = toolkit.getClass().getDeclaredField("awtAppClassName");
            awtAppClassNameField.setAccessible(true);
            awtAppClassNameField.set(toolkit, applicationName);
        } catch (Exception e) {
            // As this hack is only a cosmetic thing all exceptions from it will be ignored.
            Util.printMessageWithSourceLine("GUIUtil.setLinuxApplicationName(): Throw an " + e.getClass().getName() + " exception with message \"" + e.getMessage() + "\" => Ignored");
        }
    }
}