unused/net/miginfocom/swing/MigLayout.java

   1 package net.miginfocom.swing;
   2 /*
   3  * License (BSD):
   4  * ==============
   5  *
   6  * Copyright (c) 2004, Mikael Grev, MiG InfoCom AB. (miglayout (at) miginfocom (dot) com)
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without modification,
  10  * are permitted provided that the following conditions are met:
  11  * Redistributions of source code must retain the above copyright notice, this list
  12  * of conditions and the following disclaimer.
  13  * Redistributions in binary form must reproduce the above copyright notice, this
  14  * list of conditions and the following disclaimer in the documentation and/or other
  15  * materials provided with the distribution.
  16  * Neither the name of the MiG InfoCom AB nor the names of its contributors may be
  17  * used to endorse or promote products derived from this software without specific
  18  * prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  22  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  23  * IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
  24  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  25  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
  26  * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  27  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  29  * OF SUCH DAMAGE.
  30  *
  31  * @version 1.0
  32  * @author Mikael Grev, MiG InfoCom AB
  33  *         Date: 2006-sep-08
  34  */
  35
  36 import net.miginfocom.layout.*;
  37
  38 import javax.swing.*;
  39 import javax.swing.Timer;
  40 import java.awt.*;
  41 import java.awt.event.ActionEvent;
  42 import java.awt.event.ActionListener;
  43 import java.io.*;
  44 import java.util.*;
  45
  46 /** A very flexible layout manager.
  47  * <p>
  48  * Read the documentation that came with this layout manager for information on usage.
  49  */
  50 public class MigLayout implements LayoutManager2, Externalizable
  51 {
  52         // ******** Instance part ********
  53
  54         /** The component to string constraints mappings.
  55          */
  56         private final Map<Component, Object> scrConstrMap = new IdentityHashMap<Component, Object>(8);
  57
  58         /** Hold the serializable text representation of the constraints.
  59          */
  60         private Object layoutConstraints = "", colConstraints = "", rowConstraints = "";    // Should never be null!
  61
  62         // ******** Transient part ********
  63
  64         private transient ContainerWrapper cacheParentW = null;
  65
  66         private transient final Map<ComponentWrapper, CC> ccMap = new HashMap<ComponentWrapper, CC>(8);
  67         private transient javax.swing.Timer debugTimer = null;
  68
  69         private transient LC lc = null;
  70         private transient AC colSpecs = null, rowSpecs = null;
  71         private transient Grid grid = null;
  72         private transient int lastModCount = PlatformDefaults.getModCount();
  73         private transient int lastHash = -1;
  74         private transient Dimension lastInvalidSize = null;
  75         private transient boolean lastWasInvalid = false;  // Added in 3.7.1. May have regressions
  76         private transient Dimension lastParentSize = null;
  77
  78         private transient ArrayList<LayoutCallback> callbackList = null;
  79
  80         private transient boolean dirty = true;
  81
  82         /** Constructor with no constraints.
  83          */
  84         public MigLayout()
  85         {
  86                 this("", "", "");
  87         }
  88
  89         /** Constructor.
  90          * @param layoutConstraints The constraints that concern the whole layout. <code>null</code> will be treated as "".
  91          */
  92         public MigLayout(String layoutConstraints)
  93         {
  94                 this(layoutConstraints, "", "");
  95         }
  96
  97         /** Constructor.
  98          * @param layoutConstraints The constraints that concern the whole layout. <code>null</code> will be treated as "".
  99          * @param colConstraints The constraints for the columns in the grid. <code>null</code> will be treated as "".
 100          */
 101         public MigLayout(String layoutConstraints, String colConstraints)
 102         {
 103                 this(layoutConstraints, colConstraints, "");
 104         }
 105
 106         /** Constructor.
 107          * @param layoutConstraints The constraints that concern the whole layout. <code>null</code> will be treated as "".
 108          * @param colConstraints The constraints for the columns in the grid. <code>null</code> will be treated as "".
 109          * @param rowConstraints The constraints for the rows in the grid. <code>null</code> will be treated as "".
 110          */
 111         public MigLayout(String layoutConstraints, String colConstraints, String rowConstraints)
 112         {
 113                 setLayoutConstraints(layoutConstraints);
 114                 setColumnConstraints(colConstraints);
 115                 setRowConstraints(rowConstraints);
 116         }
 117
 118         /** Constructor.
 119          * @param layoutConstraints The constraints that concern the whole layout. <code>null</code> will be treated as an empty constraint.
 120          */
 121         public MigLayout(LC layoutConstraints)
 122         {
 123                 this(layoutConstraints, null, null);
 124         }
 125
 126         /** Constructor.
 127          * @param layoutConstraints The constraints that concern the whole layout. <code>null</code> will be treated as an empty constraint.
 128          * @param colConstraints The constraints for the columns in the grid. <code>null</code> will be treated as an empty constraint.
 129          */
 130         public MigLayout(LC layoutConstraints, AC colConstraints)
 131         {
 132                 this(layoutConstraints, colConstraints, null);
 133         }
 134
 135         /** Constructor.
 136          * @param layoutConstraints The constraints that concern the whole layout. <code>null</code> will be treated as an empty constraint.
 137          * @param colConstraints The constraints for the columns in the grid. <code>null</code> will be treated as an empty constraint.
 138          * @param rowConstraints The constraints for the rows in the grid. <code>null</code> will be treated as an empty constraint.
 139          */
 140         public MigLayout(LC layoutConstraints, AC colConstraints, AC rowConstraints)
 141         {
 142                 setLayoutConstraints(layoutConstraints);
 143                 setColumnConstraints(colConstraints);
 144                 setRowConstraints(rowConstraints);
 145         }
 146
 147         /** Returns layout constraints either as a <code>String</code> or {@link net.miginfocom.layout.LC} depending what was sent in
 148          * to the constructor or set with {@link #setLayoutConstraints(Object)}.
 149          * @return The layout constraints either as a <code>String</code> or {@link net.miginfocom.layout.LC} depending what was sent in
 150          * to the constructor or set with {@link #setLayoutConstraints(Object)}. Never <code>null</code>.
 151          */
 152         public Object getLayoutConstraints()
 153         {
 154                 return layoutConstraints;
 155         }
 156
 157         /** Sets the layout constraints for the layout manager instance as a String.
 158          * <p>
 159          * See the class JavaDocs for information on how this string is formatted.
 160          * @param constr The layout constraints as a String or {@link net.miginfocom.layout.LC} representation. <code>null</code> is converted to <code>""</code> for storage.
 161          * @throws RuntimeException if the constraint was not valid.
 162          */
 163         public void setLayoutConstraints(Object constr)
 164         {
 165                 if (constr == null || constr instanceof String) {
 166                         constr = ConstraintParser.prepare((String) constr);
 167                         lc = ConstraintParser.parseLayoutConstraint((String) constr);
 168                 } else if (constr instanceof LC) {
 169                         lc = (LC) constr;
 170                 } else {
 171                         throw new IllegalArgumentException("Illegal constraint type: " + constr.getClass().toString());
 172                 }
 173                 layoutConstraints = constr;
 174                 dirty = true;
 175         }
 176
 177         /** Returns the column layout constraints either as a <code>String</code> or {@link net.miginfocom.layout.AC}.
 178          * @return The column constraints either as a <code>String</code> or {@link net.miginfocom.layout.AC} depending what was sent in
 179          * to the constructor or set with {@link #setColumnConstraints(Object)}. Never <code>null</code>.
 180          */
 181         public Object getColumnConstraints()
 182         {
 183                 return colConstraints;
 184         }
 185
 186         /** Sets the column layout constraints for the layout manager instance as a String.
 187          * <p>
 188          * See the class JavaDocs for information on how this string is formatted.
 189          * @param constr The column layout constraints as a String or {@link net.miginfocom.layout.AC} representation. <code>null</code> is converted to <code>""</code> for storage.
 190          * @throws RuntimeException if the constraint was not valid.
 191          */
 192         public void setColumnConstraints(Object constr)
 193         {
 194                 if (constr == null || constr instanceof String) {
 195                         constr = ConstraintParser.prepare((String) constr);
 196                         colSpecs = ConstraintParser.parseColumnConstraints((String) constr);
 197                 } else if (constr instanceof AC) {
 198                         colSpecs = (AC) constr;
 199                 } else {
 200                         throw new IllegalArgumentException("Illegal constraint type: " + constr.getClass().toString());
 201                 }
 202                 colConstraints = constr;
 203                 dirty = true;
 204         }
 205
 206         /** Returns the row layout constraints either as a <code>String</code> or {@link net.miginfocom.layout.AC}.
 207          * @return The row constraints either as a <code>String</code> or {@link net.miginfocom.layout.AC} depending what was sent in
 208          * to the constructor or set with {@link #setRowConstraints(Object)}. Never <code>null</code>.
 209          */
 210         public Object getRowConstraints()
 211         {
 212                 return rowConstraints;
 213         }
 214
 215         /** Sets the row layout constraints for the layout manager instance as a String.
 216          * <p>
 217          * See the class JavaDocs for information on how this string is formatted.
 218          * @param constr The row layout constraints as a String or {@link net.miginfocom.layout.AC} representation. <code>null</code> is converted to <code>""</code> for storage.
 219          * @throws RuntimeException if the constraint was not valid.
 220          */
 221         public void setRowConstraints(Object constr)
 222         {
 223                 if (constr == null || constr instanceof String) {
 224                         constr = ConstraintParser.prepare((String) constr);
 225                         rowSpecs = ConstraintParser.parseRowConstraints((String) constr);
 226                 } else if (constr instanceof AC) {
 227                         rowSpecs = (AC) constr;
 228                 } else {
 229                         throw new IllegalArgumentException("Illegal constraint type: " + constr.getClass().toString());
 230                 }
 231                 rowConstraints = constr;
 232                 dirty = true;
 233         }
 234
 235         /** Returns a shallow copy of the constraints map.
 236          * @return A  shallow copy of the constraints map. Never <code>null</code>.
 237          */
 238         public Map<Component, Object> getConstraintMap()
 239         {
 240                 return new IdentityHashMap<Component, Object>(scrConstrMap);
 241         }
 242
 243         /** Sets the constraints map.
 244          * @param map The map. Will be copied.
 245          */
 246         public void setConstraintMap(Map<Component, Object> map)
 247         {
 248                 scrConstrMap.clear();
 249                 ccMap.clear();
 250                 for (Map.Entry<Component, Object> e : map.entrySet())
 251                         setComponentConstraintsImpl(e.getKey(), e.getValue(), true);
 252         }
 253
 254         /** Returns the component constraints as a String representation. This string is the exact string as set with {@link #setComponentConstraints(java.awt.Component, Object)}
 255          * or set when adding the component to the parent component.
 256          * <p>
 257          * See the class JavaDocs for information on how this string is formatted.
 258          * @param comp The component to return the constraints for.
 259          * @return The component constraints as a String representation or <code>null</code> if the component is not registered
 260          * with this layout manager. The returned values is either a String or a {@link net.miginfocom.layout.CC}
 261          * depending on what constraint was sent in when the component was added. May be <code>null</code>.
 262          */
 263         public Object getComponentConstraints(Component comp)
 264         {
 265                 synchronized(comp.getParent().getTreeLock()) {
 266                         return scrConstrMap.get(comp);
 267                 }
 268         }
 269
 270         /** Sets the component constraint for the component that already must be handled by this layout manager.
 271          * <p>
 272          * See the class JavaDocs for information on how this string is formatted.
 273          * @param constr The component constraints as a String or {@link net.miginfocom.layout.CC}. <code>null</code> is ok.
 274          * @param comp The component to set the constraints for.
 275          * @throws RuntimeException if the constraint was not valid.
 276          * @throws IllegalArgumentException If the component is not handling the component.
 277          */
 278         public void setComponentConstraints(Component comp, Object constr)
 279         {
 280                 setComponentConstraintsImpl(comp, constr, false);
 281         }
 282
 283         /** Sets the component constraint for the component that already must be handled by this layout manager.
 284          * <p>
 285          * See the class JavaDocs for information on how this string is formatted.
 286          * @param constr The component constraints as a String or {@link net.miginfocom.layout.CC}. <code>null</code> is ok.
 287          * @param comp The component to set the constraints for.
 288          * @param noCheck Does not check if the component is handled if true
 289          * @throws RuntimeException if the constraint was not valid.
 290          * @throws IllegalArgumentException If the component is not handling the component.
 291          */
 292         private void setComponentConstraintsImpl(Component comp, Object constr, boolean noCheck)
 293         {
 294                 Container parent = comp.getParent();
 295                 synchronized(parent != null ? parent.getTreeLock() : new Object()) { // 3.7.2. No sync if not added to a hierarchy. Defeats a NPE.
 296                         if (noCheck == false && scrConstrMap.containsKey(comp) == false)
 297                                 throw new IllegalArgumentException("Component must already be added to parent!");
 298
 299                         ComponentWrapper cw = new SwingComponentWrapper(comp);
 300
 301                         if (constr == null || constr instanceof String) {
 302                                 String cStr = ConstraintParser.prepare((String) constr);
 303
 304                                 scrConstrMap.put(comp, constr);
 305                                 ccMap.put(cw, ConstraintParser.parseComponentConstraint(cStr));
 306
 307                         } else if (constr instanceof CC) {
 308
 309                                 scrConstrMap.put(comp, constr);
 310                                 ccMap.put(cw, (CC) constr);
 311
 312                         } else {
 313                                 throw new IllegalArgumentException("Constraint must be String or ComponentConstraint: " + constr.getClass().toString());
 314                         }
 315
 316                         dirty = true;
 317                 }
 318         }
 319
 320         /** Returns if this layout manager is currently managing this component.
 321          * @param c The component to check. If <code>null</code> then <code>false</code> will be returned.
 322          * @return If this layout manager is currently managing this component.
 323          */
 324         public boolean isManagingComponent(Component c)
 325         {
 326                 return scrConstrMap.containsKey(c);
 327         }
 328
 329         /** Adds the callback function that will be called at different stages of the layout cycle.
 330          * @param callback The callback. Not <code>null</code>.
 331          */
 332         public void addLayoutCallback(LayoutCallback callback)
 333         {
 334                 if (callback == null)
 335                         throw new NullPointerException();
 336
 337                 if (callbackList == null)
 338                         callbackList = new ArrayList<LayoutCallback>(1);
 339
 340                 callbackList.add(callback);
 341
 342                 grid = null;
 343         }
 344
 345         /** Removes the callback if it exists.
 346          * @param callback The callback. May be <code>null</code>.
 347          */
 348         public void removeLayoutCallback(LayoutCallback callback)
 349         {
 350                 if (callbackList != null)
 351                         callbackList.remove(callback);
 352         }
 353
 354         /** Sets the debugging state for this layout manager instance. If debug is turned on a timer will repaint the last laid out parent
 355          * with debug information on top.
 356          * <p>
 357          * Red fill and dashed red outline is used to indicate occupied cells in the grid. Blue dashed outline indicate
 358          * component bounds set.
 359          * <p>
 360          * Note that debug can also be set on the layout constraints. There it will be persisted. The value set here will not. See the class
 361          * JavaDocs for information.
 362          * @param parentW The parent to set debug for.
 363          * @param b <code>true</code> means debug is turned on.
 364          */
 365         private void setDebug(final ComponentWrapper parentW, boolean b)
 366         {
 367                 if (b && (debugTimer == null || debugTimer.getDelay() != getDebugMillis())) {
 368                         if (debugTimer != null)
 369                                 debugTimer.stop();
 370
 371                         ContainerWrapper pCW = parentW.getParent();
 372                         final Component parent = pCW != null ? (Component) pCW.getComponent() : null;
 373
 374                         debugTimer = new Timer(getDebugMillis(), new MyDebugRepaintListener());
 375
 376                         if (parent != null) {
 377                                 SwingUtilities.invokeLater(new Runnable() {
 378                                         @Override
 379                                         public void run() {
 380                                                 Container p = parent.getParent();
 381                                                 if (p != null) {
 382                                                         if (p instanceof JComponent) {
 383                                                                 ((JComponent) p).revalidate();
 384                                                         } else {
 385                                                                 parent.invalidate();
 386                                                                 p.validate();
 387                                                         }
 388                                                 }
 389                                         }
 390                                 });
 391                         }
 392
 393                         debugTimer.setInitialDelay(100);
 394                         debugTimer.start();
 395
 396                 } else if (!b && debugTimer != null) {
 397                         debugTimer.stop();
 398                         debugTimer = null;
 399                 }
 400         }
 401
 402         /** Returns the current debugging state.
 403          * @return The current debugging state.
 404          */
 405         private boolean getDebug()
 406         {
 407                 return debugTimer != null;
 408         }
 409
 410         /** Returns the debug millis. Combines the value from {@link net.miginfocom.layout.LC#getDebugMillis()} and {@link net.miginfocom.layout.LayoutUtil#getGlobalDebugMillis()}
 411          * @return The combined value.
 412          */
 413         private int getDebugMillis()
 414         {
 415                 int globalDebugMillis = LayoutUtil.getGlobalDebugMillis();
 416                 return globalDebugMillis > 0 ? globalDebugMillis : lc.getDebugMillis();
 417         }
 418
 419         /** Check if something has changed and if so recreate it to the cached objects.
 420          * @param parent The parent that is the target for this layout manager.
 421          */
 422         private void checkCache(Container parent)
 423         {
 424                 if (parent == null)
 425                         return;
 426
 427                 if (dirty)
 428                         grid = null;
 429
 430                 cleanConstraintMaps(parent);
 431
 432                 // Check if the grid is valid
 433                 int mc = PlatformDefaults.getModCount();
 434                 if (lastModCount != mc) {
 435                         grid = null;
 436                         lastModCount = mc;
 437                 }
 438
 439                 if (!parent.isValid()) {
 440                         if (!lastWasInvalid) {
 441                                 lastWasInvalid = true;
 442
 443                                 int hash = 0;
 444                                 boolean resetLastInvalidOnParent = false; // Added in 3.7.3 to resolve a timing regression introduced in 3.7.1
 445                                 for (ComponentWrapper wrapper : ccMap.keySet()) {
 446                                         Object component = wrapper.getComponent();
 447                                         if (component instanceof JTextArea || component instanceof JEditorPane)
 448                                                 resetLastInvalidOnParent = true;
 449
 450                                         hash ^= wrapper.getLayoutHashCode();
 451                                         hash += 285134905;
 452                                 }
 453                                 if (resetLastInvalidOnParent)
 454                                         resetLastInvalidOnParent(parent);
 455
 456                                 if (hash != lastHash) {
 457                                         grid = null;
 458                                         lastHash = hash;
 459                                 }
 460
 461                                 Dimension ps = parent.getSize();
 462                                 if (lastInvalidSize == null || !lastInvalidSize.equals(ps)) {
 463                                         grid = null;
 464                                         lastInvalidSize = ps;
 465                                 }
 466                         }
 467                 } else {
 468                         lastWasInvalid = false;
 469                 }
 470
 471                 ContainerWrapper par = checkParent(parent);
 472
 473                 setDebug(par, getDebugMillis() > 0);
 474
 475                 if (grid == null)
 476                         grid = new Grid(par, lc, rowSpecs, colSpecs, ccMap, callbackList);
 477
 478                 dirty = false;
 479         }
 480
 481         /** Checks so all components in ccMap actually exist in the parent's collection. Removes
 482          * any references that don't.
 483          * @param parent The parent to compare ccMap against. Never null.
 484          */
 485         private void cleanConstraintMaps(Container parent)
 486         {
 487                 HashSet<Component> parentCompSet = new HashSet<Component>(Arrays.asList(parent.getComponents()));
 488
 489                 Iterator<Map.Entry<ComponentWrapper, CC>> it = ccMap.entrySet().iterator();
 490                 while(it.hasNext()) {
 491                         Component c = (Component) it.next().getKey().getComponent();
 492                         if (parentCompSet.contains(c) == false) {
 493                                 it.remove();
 494                                 scrConstrMap.remove(c);
 495                         }
 496                 }
 497         }
 498
 499         /**
 500          * @since 3.7.3
 501          */
 502         private void resetLastInvalidOnParent(Container parent)
 503         {
 504                 while (parent != null) {
 505                         LayoutManager layoutManager = parent.getLayout();
 506                         if (layoutManager instanceof MigLayout) {
 507                                 ((MigLayout) layoutManager).lastWasInvalid = false;
 508                         }
 509                         parent = parent.getParent();
 510                 }
 511         }
 512
 513         private ContainerWrapper checkParent(Container parent)
 514         {
 515                 if (parent == null)
 516                         return null;
 517
 518                 if (cacheParentW == null || cacheParentW.getComponent() != parent)
 519                         cacheParentW = new SwingContainerWrapper(parent);
 520
 521                 return cacheParentW;
 522         }
 523
 524         private long lastSize = 0;
 525
 526         @Override
 527         public void layoutContainer(final Container parent)
 528         {
 529                 synchronized(parent.getTreeLock()) {
 530                         checkCache(parent);
 531
 532                         Insets i = parent.getInsets();
 533                         int[] b = new int[] {
 534                                         i.left,
 535                                         i.top,
 536                                         parent.getWidth() - i.left - i.right,
 537                                         parent.getHeight() - i.top - i.bottom
 538                         };
 539
 540                         if (grid.layout(b, lc.getAlignX(), lc.getAlignY(), getDebug())) {
 541                                 grid = null;
 542                                 checkCache(parent);
 543                                 grid.layout(b, lc.getAlignX(), lc.getAlignY(), getDebug());
 544                         }
 545
 546                         long newSize = grid.getHeight()[1] + (((long) grid.getWidth()[1]) << 32);
 547                         if (lastSize != newSize) {
 548                                 lastSize = newSize;
 549                                 final ContainerWrapper containerWrapper = checkParent(parent);
 550                                 Window win = ((Window) SwingUtilities.getAncestorOfClass(Window.class, (Component)containerWrapper.getComponent()));
 551                                 if (win != null) {
 552                                    if (win.isVisible()) {
 553                                            SwingUtilities.invokeLater(new Runnable() {
 554                                                    @Override
 555                                                    public void run() {
 556                                                            adjustWindowSize(containerWrapper);
 557                                                    }
 558                                            });
 559                                    } else {
 560                                            adjustWindowSize(containerWrapper);
 561                                    }
 562                                 }
 563                         }
 564                         lastInvalidSize = null;
 565                 }
 566         }
 567
 568         /** Checks the parent window/popup if its size is within parameters as set by the LC.
 569          * @param parent The parent who's window to possibly adjust the size for.
 570          */
 571         private void adjustWindowSize(ContainerWrapper parent)
 572         {
 573                 BoundSize wBounds = lc.getPackWidth();
 574                 BoundSize hBounds = lc.getPackHeight();
 575
 576                 if (wBounds == BoundSize.NULL_SIZE && hBounds == BoundSize.NULL_SIZE)
 577                         return;
 578
 579                 Container packable = getPackable((Component) parent.getComponent());
 580
 581                 if (packable != null) {
 582
 583                         Component pc = (Component) parent.getComponent();
 584
 585                         Container c = pc instanceof Container ? (Container) pc : pc.getParent();
 586                         for (; c != null; c = c.getParent()) {
 587                                 LayoutManager layout = c.getLayout();
 588                                 if (layout instanceof BoxLayout || layout instanceof OverlayLayout)
 589                                         ((LayoutManager2) layout).invalidateLayout(c);
 590                         }
 591
 592                         Dimension prefSize = packable.getPreferredSize();
 593                         int targW = constrain(checkParent(packable), packable.getWidth(), prefSize.width, wBounds);
 594                         int targH = constrain(checkParent(packable), packable.getHeight(), prefSize.height, hBounds);
 595
 596                         Point p = packable.isShowing() ? packable.getLocationOnScreen() : packable.getLocation();
 597
 598                         int x = Math.round(p.x - ((targW - packable.getWidth()) * (1 - lc.getPackWidthAlign())));
 599                         int y = Math.round(p.y - ((targH - packable.getHeight()) * (1 - lc.getPackHeightAlign())));
 600
 601                         if (packable instanceof JPopupMenu) {
 602                                 JPopupMenu popupMenu = (JPopupMenu) packable;
 603                                 popupMenu.setVisible(false);
 604                                 popupMenu.setPopupSize(targW, targH);
 605                                 Component invoker = popupMenu.getInvoker();
 606                                 Point popPoint = new Point(x, y);
 607                                 SwingUtilities.convertPointFromScreen(popPoint, invoker);
 608                                 ((JPopupMenu) packable).show(invoker, popPoint.x, popPoint.y);
 609
 610                                 packable.setPreferredSize(null); // Reset preferred size so we don't read it again.
 611
 612                         } else {
 613                                 packable.setBounds(x, y, targW, targH);
 614                         }
 615                 }
 616         }
 617
 618         /** Returns a high level window or popup to pack, if any.
 619          * @return May be null.
 620          */
 621         private Container getPackable(Component comp)
 622         {
 623                 JPopupMenu popup = findType(JPopupMenu.class, comp);
 624                 if (popup != null) { // Lightweight/HeavyWeight popup must be handled separately
 625                         Container popupComp = popup;
 626                         while (popupComp != null) {
 627                                 if (popupComp.getClass().getName().contains("HeavyWeightWindow"))
 628                                         return popupComp; // Return the heavy weight window for normal processing
 629                                 popupComp = popupComp.getParent();
 630                         }
 631                         return popup; // Return the JPopup.
 632                 }
 633
 634                 return findType(Window.class, comp);
 635         }
 636
 637         public static <E> E findType(Class<E> clazz, Component comp)
 638         {
 639                 while (comp != null && !clazz.isInstance(comp))
 640                         comp = comp.getParent();
 641
 642                 return (E) comp;
 643         }
 644
 645
 646         private int constrain(ContainerWrapper parent, int winSize, int prefSize, BoundSize constrain)
 647         {
 648                 if (constrain == null)
 649                         return winSize;
 650
 651                 int retSize = winSize;
 652                 UnitValue wUV = constrain.getPreferred();
 653                 if (wUV != null)
 654                         retSize = wUV.getPixels(prefSize, parent, parent);
 655
 656                 retSize = constrain.constrain(retSize, prefSize, parent);
 657
 658                 return constrain.getGapPush() ? Math.max(winSize, retSize) : retSize;
 659         }
 660
 661         @Override
 662         public Dimension minimumLayoutSize(Container parent)
 663         {
 664                 synchronized(parent.getTreeLock()) {
 665                         return getSizeImpl(parent, LayoutUtil.MIN);
 666                 }
 667         }
 668
 669         @Override
 670         public Dimension preferredLayoutSize(Container parent)
 671         {
 672                 synchronized(parent.getTreeLock()) {
 673            if (lastParentSize == null || !parent.getSize().equals(lastParentSize)) {
 674                for (ComponentWrapper wrapper : ccMap.keySet()) {
 675                        if (wrapper.getContentBias() != -1) {
 676                        layoutContainer(parent);
 677                        break;
 678                    }
 679                }
 680            }
 681
 682            lastParentSize = parent.getSize();
 683            return getSizeImpl(parent, LayoutUtil.PREF);
 684                 }
 685         }
 686
 687         @Override
 688         public Dimension maximumLayoutSize(Container parent)
 689         {
 690                 return new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE);
 691         }
 692
 693         // Implementation method that does the job.
 694         private Dimension getSizeImpl(Container parent, int sizeType)
 695         {
 696                 checkCache(parent);
 697
 698                 Insets i = parent.getInsets();
 699
 700                 int w = LayoutUtil.getSizeSafe(grid != null ? grid.getWidth() : null, sizeType) + i.left + i.right;
 701                 int h = LayoutUtil.getSizeSafe(grid != null ? grid.getHeight() : null, sizeType) + i.top + i.bottom;
 702
 703                 return new Dimension(w, h);
 704         }
 705
 706         @Override
 707         public float getLayoutAlignmentX(Container parent)
 708         {
 709                 return lc != null && lc.getAlignX() != null ? lc.getAlignX().getPixels(1, checkParent(parent), null) : 0;
 710         }
 711
 712         @Override
 713         public float getLayoutAlignmentY(Container parent)
 714         {
 715                 return lc != null && lc.getAlignY() != null ? lc.getAlignY().getPixels(1, checkParent(parent), null) : 0;
 716         }
 717
 718         @Override
 719         public void addLayoutComponent(String s, Component comp)
 720         {
 721                 addLayoutComponent(comp, s);
 722         }
 723
 724         @Override
 725         public void addLayoutComponent(Component comp, Object constraints)
 726         {
 727                 synchronized(comp.getParent().getTreeLock()) {
 728                         setComponentConstraintsImpl(comp, constraints, true);
 729                 }
 730         }
 731
 732         @Override
 733         public void removeLayoutComponent(Component comp)
 734         {
 735                 synchronized(comp.getParent().getTreeLock()) {
 736                         scrConstrMap.remove(comp);
 737                         ccMap.remove(new SwingComponentWrapper(comp));
 738                         grid = null; // To clear references
 739                 }
 740         }
 741
 742         @Override
 743         public void invalidateLayout(Container target)
 744         {
 745                 dirty = true;
 746         }
 747
 748         // ************************************************
 749         // Persistence Delegate and Serializable combined.
 750         // ************************************************
 751
 752         private Object readResolve() throws ObjectStreamException
 753         {
 754                 return LayoutUtil.getSerializedObject(this);
 755         }
 756
 757         @Override
 758         public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
 759         {
 760                 LayoutUtil.setSerializedObject(this, LayoutUtil.readAsXML(in));
 761         }
 762
 763         @Override
 764         public void writeExternal(ObjectOutput out) throws IOException
 765         {
 766                 if (getClass() == MigLayout.class)
 767                         LayoutUtil.writeAsXML(out, this);
 768         }
 769
 770         private class MyDebugRepaintListener implements ActionListener
 771         {
 772                 @Override
 773                 public void actionPerformed(ActionEvent e)
 774                 {
 775                         if (grid != null) {
 776                                 Component comp = (Component) grid.getContainer().getComponent();
 777                                 if (comp.isShowing()) {
 778                                         grid.paintDebug();
 779                                         return;
 780                                 }
 781                         }
 782                         debugTimer.stop();
 783                         debugTimer = null;
 784                 }
 785         }
 786 }