Dépôt officiel du code source de l'ERP OpenConcerto

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 * 
 * Copyright 2011-2019 OpenConcerto, by ILM Informatique. All rights reserved.
 * 
 * The contents of this file are subject to the terms of the GNU General Public License Version 3
 * only ("GPL"). You may not use this file except in compliance with the License. You can obtain a
 * copy of the License at http://www.gnu.org/licenses/gpl-3.0.html See the License for the specific
 * language governing permissions and limitations under the License.
 * 
 * When distributing the software, include this License Header Notice in each file.
 */
 
 package org.openconcerto.erp.config;

import org.openconcerto.erp.core.common.ui.StatusPanel;
import org.openconcerto.erp.panel.UserExitConf;
import org.openconcerto.erp.panel.UserExitPanel;
import org.openconcerto.erp.rights.MenuComboRightEditor;
import org.openconcerto.sql.PropsConfiguration;
import org.openconcerto.sql.users.UserManager;
import org.openconcerto.sql.users.rights.UserRightsManager;
import org.openconcerto.task.TodoListPanel;
import org.openconcerto.task.config.ComptaBasePropsConfiguration;
import org.openconcerto.ui.AutoHideTabbedPane;
import org.openconcerto.ui.MenuUtils;
import org.openconcerto.ui.SwingThreadUtils;
import org.openconcerto.ui.group.Group;
import org.openconcerto.ui.group.Item;
import org.openconcerto.ui.state.WindowStateManager;
import org.openconcerto.utils.JImage;
import org.openconcerto.utils.OSXAdapter;

import java.awt.Color;
import java.awt.Container;
import java.awt.Desktop;
import java.awt.Dimension;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Image;
import java.awt.event.ActionEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.io.File;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

import javax.swing.AbstractAction;
import javax.swing.Action;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;
import javax.swing.JSeparator;
import javax.swing.SwingUtilities;

import net.jcip.annotations.GuardedBy;

public class MainFrame extends JFrame {

    // menus
    public static final String STRUCTURE_MENU = "menu.organization";
    public static final String PAYROLL_MENU = "menu.payroll";
    public static final String PAYMENT_MENU = "menu.payment";
    public static final String STATS_MENU = "menu.stats";
    public static final String DECLARATION_MENU = "menu.report";
    public static final String STATE_MENU = "menu.accounting";
    public static final String LIST_MENU = "menu.list";
    public static final String CREATE_MENU = "menu.create";
    public static final String FILE_MENU = "menu.file";
    public static final String HELP_MENU = "menu.help";

    public static final String PREFS_MENU_ITEM = "preferences";
    public static final String QUIT_MENU_ITEM = "quit";
    public static final String ABOUT_MENU_ITEM = "information";

    static private final List<Runnable> runnables = new ArrayList<Runnable>();
    @GuardedBy("MainFrame")
    static private MainFrame instance = null;

    // thread safe
    public synchronized static MainFrame getInstance() {
        return instance;
    }

    public synchronized static MainFrame resetInstance() {
        final MainFrame res = instance;
        setInstance(null);
        if (res != null) {
            res.setVisible(false);
            res.dispose();
        }
        return res;
    }

    private synchronized static void setInstance(MainFrame f) {
        assert SwingUtilities.isEventDispatchThread();
        if (f != null && instance != null)
            throw new IllegalStateException("More than one main frame");
        instance = f;
        if (f != null) {
            for (final Runnable r : runnables)
                r.run();
            runnables.clear();
        }
    }

    /**
     * Execute the runnable in the EDT after the main frame has been created. Thus if the main frame
     * has already been created and we're in the EDT, execute <code>r</code> immediately.
     * 
     * @param r the runnable to run.
     * @see #getInstance()
     */
    public static void invoke(final Runnable r) {
        SwingThreadUtils.invoke(new Runnable() {
            @Override
            public void run() {
                if (getInstance() == null) {
                    runnables.add(r);
                } else {
                    r.run();
                }
            }
        });
    }

    private final AutoHideTabbedPane tabContainer;
    private TodoListPanel todoPanel;
    private JImage image;

    public TodoListPanel getTodoPanel() {
        return this.todoPanel;
    }

    public MainFrame(final PropsConfiguration conf) {
        super();

        this.setIconImage(new ImageIcon(MainFrame.class.getResource("frameicon.png")).getImage());

        Container co = this.getContentPane();
        co.setLayout(new GridBagLayout());
        GridBagConstraints c = new GridBagConstraints();
        c.fill = GridBagConstraints.HORIZONTAL;
        c.gridx = 0;
        c.gridy = 0;
        // // co.add(new RangeSlider(2005), c);
        c.weightx = 1;
        c.weighty = 0;
        this.image = new JImage(ComptaBasePropsConfiguration.class.getResource("logo.png"));
        this.image.setBackground(Color.WHITE);
        this.image.check();
        co.add(this.image, c);
        c.weighty = 0;
        c.gridy++;
        c.fill = GridBagConstraints.BOTH;
        co.add(new JSeparator(JSeparator.HORIZONTAL), c);
        c.gridy++;
        c.weighty = 1;
        this.tabContainer = new AutoHideTabbedPane();
        co.add(this.tabContainer, c);
        Dimension minSize;
        final String confSuffix;
        if (!Gestion.isMinimalMode()) {
            this.todoPanel = new TodoListPanel(UserManager.getInstance());
            this.getTabbedPane().addTab("Tâches", this.todoPanel);
            minSize = new Dimension(800, 600);
            confSuffix = "";
        } else {
            minSize = null;
            confSuffix = "-minimal";
        }
        c.weighty = 0;
        c.gridy++;
        c.fill = GridBagConstraints.HORIZONTAL;
        co.add(StatusPanel.getInstance(), c);

        if (minSize == null) {
            this.pack();
            minSize = new Dimension(this.getSize());
        }
        this.setMinimumSize(minSize);

        final File confFile = new File(conf.getConfDir(), "Configuration" + File.separator + "Frame" + File.separator + "mainFrame" + confSuffix + ".xml");
        new WindowStateManager(this, confFile).loadState();

        this.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent arg0) {
                quit();
            }
        });

        setInstance(this);

        final Thread dbConn = conf.createDBCheckThread(this, new Runnable() {
            @Override
            public void run() {
                // the user has already clicked "Quit" don't ask him again
                // Further the DB is unavailable so most actions (e.g. backup) cannot run
                UserExitPanel.exit(UserExitConf.DEFAULT);
            }
        });
        dbConn.start();

        // Overrive logo
        final Image im = conf instanceof ComptaPropsConfiguration ? ((ComptaPropsConfiguration) conf).getCustomLogo() : null;
        if (im != null) {
            image.setImage(im);
        }

    }

    // create the UI menu from the MenuAndActions and hide items handled by java.awt.Desktop
    public final void initMenuBar() {
        final MenuManager mm = MenuManager.getInstance();
        final PropertyChangeListener listener = new PropertyChangeListener() {
            @Override
            public void propertyChange(PropertyChangeEvent evt) {
                // TODO change only if needed (mind the actions)
                setJMenuBar(createMenu(mm));
                getLayeredPane().revalidate();
            }
        };
        mm.addPropertyChangeListener(listener);
        listener.propertyChange(null);
    }

    private final JMenuBar createMenu(final MenuManager mm) {
        final JMenuBar result = new JMenuBar();
        final Group g = mm.getGroup();
        for (int i = 0; i < g.getSize(); i++) {
            final Item item = g.getItem(i);
            if (item.getLocalHint().isVisible() && UserRightsManager.getCurrentUserRights().haveRight(MenuComboRightEditor.ID_RIGHT, item.getId()))
                result.add(createJMenuFrom(item, mm));
        }
        return result;
    }

    private final JMenu createJMenuFrom(final Item item, final MenuManager mm) {
        assert item.getLocalHint().isVisible();
        final String id = item.getId();
        final String name = mm.getLabelForId(id);
        final String menuLabel;
        final Color c;
        if (name == null || name.trim().isEmpty()) {
            menuLabel = id;
            c = new Color(200, 65, 20);
        } else {
            menuLabel = name;
            c = null;
        }
        assert menuLabel != null;
        final JMenu m = new JMenu(menuLabel);
        if (c != null)
            m.setForeground(c);

        if (item instanceof Group) {
            createMenuItemsRec(mm, m, Collections.<String> emptyList(), (Group) item);
        } else if (UserRightsManager.getCurrentUserRights().haveRight(MenuComboRightEditor.ID_RIGHT, item.getId())) {
            m.add(createJMenuItemForId(id, mm));
        }
        return m;
    }

    private final void createMenuItemsRec(final MenuManager mm, final JMenu topLevelMenu, final List<String> path, final Group g) {
        assert g.getLocalHint().isVisible();
        for (int i = 0; i < g.getSize(); i++) {
            final Item child = g.getItem(i);
            if (!child.getLocalHint().isVisible() || !UserRightsManager.getCurrentUserRights().haveRight(MenuComboRightEditor.ID_RIGHT, child.getId()))
                continue;

            if (child instanceof Group) {
                final List<String> newPath = new ArrayList<String>(path);
                newPath.add(child.getId());
                createMenuItemsRec(mm, topLevelMenu, newPath, (Group) child);
            } else {
                final List<String> newPath;
                if (path.size() % 2 == 0) {
                    newPath = new ArrayList<String>(path);
                    newPath.add(null);
                } else {
                    newPath = path;
                }
                MenuUtils.addMenuItem(createJMenuItemForId(child.getId(), mm), topLevelMenu, newPath);
            }
        }
    }

    static public String getFirstNonEmpty(final List<String> l) {
        for (final String s : l) {
            if (s != null && !s.trim().isEmpty()) {
                return s;
            }
        }
        return null;
    }

    private final JMenuItem createJMenuItemForId(final String id, final MenuManager mm) {
        final String mngrLabel = mm.getLabelForId(id);
        final Action mngrAction = mm.getActionForId(id);
        final String mngrActionName = mngrAction == null || mngrAction.getValue(Action.NAME) == null ? null : mngrAction.getValue(Action.NAME).toString();

        final String label = getFirstNonEmpty(Arrays.asList(mngrLabel, mngrActionName, id));
        assert label != null;
        final Action action;
        final Color fg;
        if (mngrAction == null) {
            action = new AbstractAction(label) {
                @Override
                public void actionPerformed(ActionEvent e) {
                    JOptionPane.showMessageDialog(MainFrame.this, "No action for " + id);
                }
            };
            fg = new Color(200, 65, 95);
        } else {
            action = mngrAction;
            // Allow to leave the name blank at action creation, then set it here so that it can be
            // used in actionPerformed()
            if (mngrActionName == null)
                action.putValue(Action.NAME, label);
            fg = label.equals(id) ? new Color(20, 65, 200) : null;
        }

        final JMenuItem res = new JMenuItem(action);
        // don't use action name but the provided label
        res.setHideActionText(true);
        res.setText(label);
        if (fg != null)
            res.setForeground(fg);
        return res;
    }

    public JMenuItem addMenuItem(final Action action, final String... path) {
        return this.addMenuItem(action, Arrays.asList(path));
    }

    /**
     * Adds a menu item to this menu. The path should be an alternation of menu and group within
     * that menu. All items within the same group will be grouped together inside separators. Menus
     * will be created as needed.
     * 
     * @param action the action to perform.
     * @param path where to add the menu item.
     * @return the newly created item.
     * @throws IllegalArgumentException if path is not even.
     */
    public JMenuItem addMenuItem(final Action action, final List<String> path) throws IllegalArgumentException {
        if (path.size() == 0 || path.size() % 2 != 0)
            throw new IllegalArgumentException("Path should be of the form menu/group/menu/group/... : " + path);
        final JMenu topLevelMenu = getMenu(path.get(0));
        return MenuUtils.addMenuItem(action, topLevelMenu, path.subList(1, path.size()));
    }

    // get or create (at the end) a top level menu
    private JMenu getMenu(final String name) {
        final JMenu existing = MenuUtils.findChild(this.getJMenuBar(), name, JMenu.class);
        final JMenu res;
        if (existing == null) {
            res = new JMenu(name);
            // insert before the help menu
            this.getJMenuBar().add(res, this.getJMenuBar().getComponentCount() - 1);
        } else {
            res = existing;
        }
        return res;
    }

    /**
     * Remove the passed item from this menu. This method handles the cleanup of separators and
     * empty menus.
     * 
     * @param item the item to remove.
     * @throws IllegalArgumentException if <code>item</code> is not in this menu.
     */
    public void removeMenuItem(final JMenuItem item) throws IllegalArgumentException {
        if (SwingThreadUtils.getAncestorOrSelf(JMenuBar.class, item) != this.getJMenuBar())
            throw new IllegalArgumentException("Item not in this menu " + item);
        MenuUtils.removeMenuItem(item);
    }

    public void registerDesktopEvents(final MenuAndActions menuAndActions) {
        // First try standard >=9 way, otherwise fall back to com.apple.eawt.Application
        if (!this.registerAWTDesktopEvents(menuAndActions))
            this.registerForMacOSXEvents(menuAndActions);
    }

    private boolean registerAWTDesktopEvents(final MenuAndActions menuAndActions) {
        if (!Desktop.isDesktopSupported())
            return false;
        final Desktop desktop = Desktop.getDesktop();
        final boolean quitHandled = registerAWTDesktopEvent(desktop, "QuitHandler", "APP_QUIT_HANDLER", menuAndActions, QUIT_MENU_ITEM);
        final boolean aboutHandled = registerAWTDesktopEvent(desktop, "AboutHandler", "APP_ABOUT", menuAndActions, ABOUT_MENU_ITEM);
        final boolean prefsHandled = registerAWTDesktopEvent(desktop, "PreferencesHandler", "APP_PREFERENCES", menuAndActions, PREFS_MENU_ITEM);
        return quitHandled && aboutHandled && prefsHandled;
    }

    private boolean registerAWTDesktopEvent(final Desktop desktop, final String handlerClassName, final String desktopActionName, final MenuAndActions menuAndActions, final String menuActionName) {
        final Desktop.Action appPrefsAction;
        try {
            appPrefsAction = Desktop.Action.valueOf(desktopActionName);
        } catch (Exception e) {
            // JRE <9, fallback to the old way
            return false;
        }
        if (!desktop.isSupported(appPrefsAction)) {
            // JRE >= 9, but not supported
            return false;
        }
        try {
            final Class<?> prefHandlerClass = Class.forName("java.awt.desktop." + handlerClassName);
            final Object prefHandler = Proxy.newProxyInstance(prefHandlerClass.getClassLoader(), new Class<?>[] { prefHandlerClass }, new InvocationHandler() {
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    menuAndActions.getAction(menuActionName).actionPerformed(null);
                    return null;
                }
            });
            desktop.getClass().getMethod("set" + handlerClassName, prefHandlerClass).invoke(desktop, prefHandler);
            menuAndActions.setMenuItemVisible(menuActionName, false);
            return true;
        } catch (Exception e) {
            // Unknown error, still try to fallback to the old way
            e.printStackTrace();
            return false;
        }
    }

    // Generic registration with the Mac OS X application menu
    // Checks the platform, then attempts to register with the Apple EAWT
    // See OSXAdapter.java to see how this is done without directly referencing any Apple APIs
    // Remove once depending on Java 11.
    @Deprecated
    public void registerForMacOSXEvents(final MenuAndActions menuAndActions) {
        if (Gestion.MAC_OS_X) {
            try {
                // Generate and register the OSXAdapter, passing it a hash of all the methods we
                // wish to use as delegates for various com.apple.eawt.ApplicationListener methods
                OSXAdapter.setQuitHandler(this, getClass().getDeclaredMethod("quit", new Class[0]));
                OSXAdapter.setAboutHandler(this, getClass().getDeclaredMethod("about", new Class[0]));
                OSXAdapter.setPreferencesHandler(this, getClass().getDeclaredMethod("preferences", new Class[0]));
                menuAndActions.setMenuItemVisible(QUIT_MENU_ITEM, false);
                menuAndActions.setMenuItemVisible(ABOUT_MENU_ITEM, false);
                menuAndActions.setMenuItemVisible(PREFS_MENU_ITEM, false);
                // no OSXAdapter.setFileHandler() for now
            } catch (Exception e) {
                System.err.println("Error while loading the OSXAdapter:");
                e.printStackTrace();
            }
        }
    }

    // used by OSXAdapter
    @Deprecated
    public final void preferences() {
        MenuManager.getInstance().getActionForId(PREFS_MENU_ITEM).actionPerformed(null);
    }

    @Deprecated
    public final void about() {
        MenuManager.getInstance().getActionForId(ABOUT_MENU_ITEM).actionPerformed(null);
    }

    public boolean quit() {
        if (this.getTodoPanel() != null)
            this.getTodoPanel().stopUpdate();
        Gestion.askForExit();
        return false;
    }

    public final AutoHideTabbedPane getTabbedPane() {
        return this.tabContainer;
    }
}