001// License: GPL. For details, see LICENSE file.
002package org.openstreetmap.josm.gui.dialogs;
003
004import java.awt.Dimension;
005import java.util.ArrayList;
006import java.util.List;
007
008import javax.swing.BoxLayout;
009import javax.swing.JPanel;
010import javax.swing.JSplitPane;
011
012import org.openstreetmap.josm.gui.widgets.MultiSplitLayout.Divider;
013import org.openstreetmap.josm.gui.widgets.MultiSplitLayout.Leaf;
014import org.openstreetmap.josm.gui.widgets.MultiSplitLayout.Node;
015import org.openstreetmap.josm.gui.widgets.MultiSplitLayout.Split;
016import org.openstreetmap.josm.gui.widgets.MultiSplitPane;
017import org.openstreetmap.josm.tools.CheckParameterUtil;
018import org.openstreetmap.josm.tools.Destroyable;
019import org.openstreetmap.josm.tools.JosmRuntimeException;
020import org.openstreetmap.josm.tools.bugreport.BugReport;
021
022/**
023 * This is the panel displayed on the right side of JOSM. It displays a list of panels.
024 */
025public class DialogsPanel extends JPanel implements Destroyable {
026    private final List<ToggleDialog> allDialogs = new ArrayList<>();
027    private final MultiSplitPane mSpltPane = new MultiSplitPane();
028    private static final int DIVIDER_SIZE = 5;
029
030    /**
031     * Panels that are added to the multisplitpane.
032     */
033    private final List<JPanel> panels = new ArrayList<>();
034
035    /**
036     * If {@link #initialize(List)} was called. read only from outside
037     */
038    public boolean initialized;
039
040    private final JSplitPane myParent;
041
042    /**
043     * Creates a new {@link DialogsPanel}.
044     * @param parent The parent split pane that allows this panel to change it's size.
045     */
046    public DialogsPanel(JSplitPane parent) {
047        this.myParent = parent;
048    }
049
050    /**
051     * Initializes this panel
052     * @param pAllDialogs The list of dialogs this panel should contain on start.
053     */
054    public void initialize(List<ToggleDialog> pAllDialogs) {
055        if (initialized) {
056            throw new IllegalStateException("Panel can only be initialized once.");
057        }
058        initialized = true;
059        allDialogs.clear();
060
061        for (ToggleDialog dialog: pAllDialogs) {
062            add(dialog, false);
063        }
064
065        this.add(mSpltPane);
066        reconstruct(Action.RESTORE_SAVED, null);
067    }
068
069    /**
070     * Add a new {@link ToggleDialog} to the list of known dialogs and trigger reconstruct.
071     * @param dlg The dialog to add
072     */
073    public void add(ToggleDialog dlg) {
074        add(dlg, true);
075    }
076
077    /**
078     * Add a new {@link ToggleDialog} to the list of known dialogs.
079     * @param dlg The dialog to add
080     * @param doReconstruct <code>true</code> if reconstruction should be triggered.
081     */
082    public void add(ToggleDialog dlg, boolean doReconstruct) {
083        allDialogs.add(dlg);
084        dlg.setDialogsPanel(this);
085        dlg.setVisible(false);
086        final JPanel p = new MinSizePanel();
087        p.setLayout(new BoxLayout(p, BoxLayout.Y_AXIS));
088        p.setVisible(false);
089
090        int dialogIndex = allDialogs.size() - 1;
091        mSpltPane.add(p, 'L'+Integer.toString(dialogIndex));
092        panels.add(p);
093
094        if (dlg.isDialogShowing()) {
095            dlg.showDialog();
096            if (dlg.isDialogInCollapsedView()) {
097                dlg.isCollapsed = false;    // pretend to be in Default view, this will be set back by collapse()
098                dlg.collapse();
099            }
100            if (doReconstruct) {
101                reconstruct(Action.INVISIBLE_TO_DEFAULT, dlg);
102            }
103            dlg.showNotify();
104        } else {
105            dlg.hideDialog();
106        }
107    }
108
109    static final class MinSizePanel extends JPanel {
110        @Override
111        public Dimension getMinimumSize() {
112            // Honoured by the MultiSplitPaneLayout when the entire Window is resized
113            return new Dimension(0, 40);
114        }
115    }
116
117    /**
118     * What action was performed to trigger the reconstruction
119     */
120    public enum Action {
121        /**
122         * The panel was invisible previously
123         */
124        INVISIBLE_TO_DEFAULT,
125        /**
126         * The panel was collapsed by the user.
127         */
128        COLLAPSED_TO_DEFAULT,
129        /**
130         * Restore saved heights.
131         * @since 14425
132         */
133        RESTORE_SAVED,
134        /*  INVISIBLE_TO_COLLAPSED,    does not happen */
135        /**
136         * else. (Remaining elements have more space.)
137         */
138        ELEMENT_SHRINKS
139    }
140
141    /**
142     * Reconstruct the view, if the configurations of dialogs has changed.
143     * @param action what happened, so the reconstruction is necessary
144     * @param triggeredBy the dialog that caused the reconstruction
145     */
146    public void reconstruct(Action action, ToggleDialog triggeredBy) {
147
148        final int n = allDialogs.size();
149
150        /**
151         * reset the panels
152         */
153        for (JPanel p: panels) {
154            p.removeAll();
155            p.setVisible(false);
156        }
157
158        /**
159         * Add the elements to their respective panel.
160         *
161         * Each panel contains one dialog in default view and zero or more
162         * collapsed dialogs on top of it. The last panel is an exception
163         * as it can have collapsed dialogs at the bottom as well.
164         * If there are no dialogs in default view, show the collapsed ones
165         * in the last panel anyway.
166         */
167        JPanel p = panels.get(n-1); // current Panel (start with last one)
168        int k = -1;                 // indicates that current Panel index is N-1, but no default-view-Dialog has been added to this Panel yet.
169        for (int i = n-1; i >= 0; --i) {
170            final ToggleDialog dlg = allDialogs.get(i);
171            if (dlg.isDialogInDefaultView()) {
172                if (k == -1) {
173                    k = n-1;
174                } else {
175                    --k;
176                    p = panels.get(k);
177                }
178                p.add(dlg, 0);
179                p.setVisible(true);
180            } else if (dlg.isDialogInCollapsedView()) {
181                p.add(dlg, 0);
182                p.setVisible(true);
183            }
184        }
185
186        if (k == -1) {
187            k = n-1;
188        }
189        final int numPanels = n - k;
190
191        /**
192         * Determine the panel geometry
193         */
194        if (action == Action.RESTORE_SAVED || action == Action.ELEMENT_SHRINKS) {
195            for (int i = 0; i < n; ++i) {
196                final ToggleDialog dlg = allDialogs.get(i);
197                if (dlg.isDialogInDefaultView()) {
198                    final int ph = action == Action.RESTORE_SAVED ? dlg.getLastHeight() : dlg.getPreferredHeight();
199                    final int ah = dlg.getSize().height;
200                    dlg.setPreferredSize(new Dimension(Integer.MAX_VALUE, ah < 20 ? ph : ah));
201                }
202            }
203        } else {
204            CheckParameterUtil.ensureParameterNotNull(triggeredBy, "triggeredBy");
205
206            int sumP = 0;   // sum of preferred heights of dialogs in default view (without the triggering dialog)
207            int sumA = 0;   // sum of actual heights of dialogs in default view (without the triggering dialog)
208            int sumC = 0;   // sum of heights of all collapsed dialogs (triggering dialog is never collapsed)
209
210            for (ToggleDialog dlg: allDialogs) {
211                if (dlg.isDialogInDefaultView()) {
212                    if (dlg != triggeredBy) {
213                        sumP += dlg.getPreferredHeight();
214                        sumA += dlg.getHeight();
215                    }
216                } else if (dlg.isDialogInCollapsedView()) {
217                    sumC += dlg.getHeight();
218                }
219            }
220
221            /**
222             * If we add additional dialogs on startup (e.g. geoimage), they may
223             * not have an actual height yet.
224             * In this case we simply reset everything to it's preferred size.
225             */
226            if (sumA == 0) {
227                reconstruct(Action.ELEMENT_SHRINKS, null);
228                return;
229            }
230
231            /** total Height */
232            final int h = mSpltPane.getMultiSplitLayout().getModel().getBounds().getSize().height;
233
234            /** space, that is available for dialogs in default view (after the reconfiguration) */
235            final int s2 = h - (numPanels - 1) * DIVIDER_SIZE - sumC;
236
237            final int hpTrig = triggeredBy.getPreferredHeight();
238            if (hpTrig <= 0) throw new IllegalStateException(); // Must be positive
239
240            /** The new dialog gets a fair share */
241            final int hnTrig = hpTrig * s2 / (hpTrig + sumP);
242            triggeredBy.setPreferredSize(new Dimension(Integer.MAX_VALUE, hnTrig));
243
244            /** This is remaining for the other default view dialogs */
245            final int r = s2 - hnTrig;
246
247            /**
248             * Take space only from dialogs that are relatively large
249             */
250            int dm = 0;        // additional space needed by the small dialogs
251            int dp = 0;        // available space from the large dialogs
252            for (int i = 0; i < n; ++i) {
253                final ToggleDialog dlg = allDialogs.get(i);
254                if (dlg != triggeredBy && dlg.isDialogInDefaultView()) {
255                    final int ha = dlg.getSize().height;                              // current
256                    final int h0 = ha * r / sumA;                                     // proportional shrinking
257                    final int he = dlg.getPreferredHeight() * s2 / (sumP + hpTrig);  // fair share
258                    if (h0 < he) {                  // dialog is relatively small
259                        int hn = Math.min(ha, he);  // shrink less, but do not grow
260                        dm += hn - h0;
261                    } else {                        // dialog is relatively large
262                        dp += h0 - he;
263                    }
264                }
265            }
266            /** adjust, without changing the sum */
267            for (int i = 0; i < n; ++i) {
268                final ToggleDialog dlg = allDialogs.get(i);
269                if (dlg != triggeredBy && dlg.isDialogInDefaultView()) {
270                    final int ha = dlg.getHeight();
271                    final int h0 = ha * r / sumA;
272                    final int he = dlg.getPreferredHeight() * s2 / (sumP + hpTrig);
273                    if (h0 < he) {
274                        int hn = Math.min(ha, he);
275                        dlg.setPreferredSize(new Dimension(Integer.MAX_VALUE, hn));
276                    } else {
277                        int d = dp == 0 ? 0 : ((h0-he) * dm / dp);
278                        dlg.setPreferredSize(new Dimension(Integer.MAX_VALUE, h0 - d));
279                    }
280                }
281            }
282        }
283
284        /**
285         * create Layout
286         */
287        final List<Node> ch = new ArrayList<>();
288
289        for (int i = k; i <= n-1; ++i) {
290            if (i != k) {
291                ch.add(new Divider());
292            }
293            Leaf l = new Leaf('L'+Integer.toString(i));
294            l.setWeight(1.0 / numPanels);
295            ch.add(l);
296        }
297
298        if (numPanels == 1) {
299            Node model = ch.get(0);
300            mSpltPane.getMultiSplitLayout().setModel(model);
301        } else {
302            Split model = new Split();
303            model.setRowLayout(false);
304            model.setChildren(ch);
305            mSpltPane.getMultiSplitLayout().setModel(model);
306        }
307
308        mSpltPane.getMultiSplitLayout().setDividerSize(DIVIDER_SIZE);
309        mSpltPane.getMultiSplitLayout().setFloatingDividers(true);
310        mSpltPane.revalidate();
311
312        /**
313         * Hide the Panel, if there is nothing to show
314         */
315        if (numPanels == 1 && panels.get(n-1).getComponents().length == 0) {
316            myParent.setDividerSize(0);
317            this.setVisible(false);
318        } else {
319            if (this.getWidth() != 0) { // only if josm started with hidden panel
320                this.setPreferredSize(new Dimension(this.getWidth(), 0));
321            }
322            this.setVisible(true);
323            myParent.setDividerSize(5);
324            myParent.resetToPreferredSizes();
325        }
326    }
327
328    @Override
329    public void destroy() {
330        for (ToggleDialog t : allDialogs) {
331            try {
332                t.destroy();
333            } catch (JosmRuntimeException | IllegalArgumentException | IllegalStateException e) {
334                throw BugReport.intercept(e).put("dialog", t).put("dialog-class", t.getClass());
335            }
336        }
337        mSpltPane.removeAll();
338        allDialogs.clear();
339        panels.clear();
340    }
341
342    /**
343     * Replies the instance of a toggle dialog of type <code>type</code> managed by this
344     * map frame
345     *
346     * @param <T> toggle dialog type
347     * @param type the class of the toggle dialog, i.e. UserListDialog.class
348     * @return the instance of a toggle dialog of type <code>type</code> managed by this
349     * map frame; null, if no such dialog exists
350     *
351     */
352    public <T> T getToggleDialog(Class<T> type) {
353        for (ToggleDialog td : allDialogs) {
354            if (type.isInstance(td))
355                return type.cast(td);
356        }
357        return null;
358    }
359}