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}