private LayoutConstraints<?>[] removeLayoutDelegate(boolean extractConstraints) {
    int componentCount = layoutDelegate.getComponentCount();
    LayoutConstraints<?>[] constraints = null;

    if (componentCount > 0) {
      RADVisualComponent<?>[] radComps = radContainer.getSubComponents();
      if (radComps.length
          == componentCount) { // robustness: might be called after failed layout initialization
        if (extractConstraints) {
          constraints = new LayoutConstraints<?>[componentCount];
        }

        for (int i = 0; i < componentCount; i++) {
          LayoutConstraints<?> constr = layoutDelegate.getConstraints(i);
          if (extractConstraints) {
            constraints[i] = constr;
          }
          if (constr != null) {
            radComps[i].setLayoutConstraints(layoutDelegate.getClass(), constr);
          }
        }
      }
    }
    layoutDelegate.removeAll();
    layoutDelegate.clearContainer(getPrimaryContainer(), getPrimaryContainerDelegate());
    layoutDelegate = null;
    return constraints;
  }
 // components adding/removing
 public void injectComponents(
     RADVisualComponent<?>[] components, LayoutConstraints<?>[] aConstraints, int index) {
   if (index <= -1) {
     index = layoutDelegate.getComponentCount();
   }
   layoutDelegate.addComponents(components, aConstraints, index);
   for (RADVisualComponent<?> component : components) {
     component.resetConstraintsProperties();
   }
 }
 public LayoutConstraints<?> getConstraints(RADVisualComponent<?> radComp) {
   if (layoutDelegate != null) {
     int index = radComp.getComponentIndex(); // radContainer.getIndexOf(radComp);
     return index >= 0 && index < layoutDelegate.getComponentCount()
         ? layoutDelegate.getConstraints(index)
         : null;
   } else {
     return null;
   }
 }
  public void addComponents(
      RADVisualComponent<?>[] components, LayoutConstraints<?>[] aConstraints, int index) {
    if (index <= -1) {
      index = layoutDelegate.getComponentCount();
    }
    injectComponents(components, aConstraints, index);

    Component[] comps = new Component[components.length];
    for (int i = 0; i < components.length; i++) {
      comps[i] = components[i].getBeanInstance();
    }
    layoutDelegate.addComponentsToContainer(
        getPrimaryContainer(), getPrimaryContainerDelegate(), comps, index);
  }
 public void removeAll() {
   // first store constraints in meta components
   RADVisualComponent<?>[] components = radContainer.getSubComponents();
   for (int i = 0; i < components.length; i++) {
     LayoutConstraints<?> constr = layoutDelegate.getConstraints(i);
     if (constr != null) {
       components[i].setLayoutConstraints(layoutDelegate.getClass(), constr);
     }
   }
   // remove components from layout
   layoutDelegate.removeAll();
   // clear the primary container instance
   layoutDelegate.clearContainer(getPrimaryContainer(), getPrimaryContainerDelegate());
 }
  public boolean isLayoutChanged() {
    Container defaultContainer =
        (Container) BeanSupport.getDefaultInstance(radContainer.getBeanClass());
    Container defaultContDelegate = radContainer.getContainerDelegate(defaultContainer);

    return layoutDelegate.isLayoutChanged(defaultContainer, defaultContDelegate);
  }
  public void setLayoutDelegate(LayoutSupportDelegate newDelegate /*,
     boolean fromCode*/) throws Exception {
    LayoutConstraints<?>[] oldConstraints;
    LayoutSupportDelegate oldDelegate = layoutDelegate;

    if (layoutDelegate != null && (layoutDelegate != newDelegate /* || !fromCode*/)) {
      oldConstraints = removeLayoutDelegate(true);
    } else {
      oldConstraints = null;
    }

    layoutDelegate = newDelegate;
    propertySets = null;
    needInit = false;

    if (layoutDelegate != null) {
      try {
        layoutDelegate.initialize(this, null);
        fillLayout(oldConstraints);
        getPropertySets(); // force properties and listeners creation
      } catch (Exception ex) {
        removeLayoutDelegate(false);
        layoutDelegate = oldDelegate;
        if (layoutDelegate != null) {
          fillLayout(null);
        }
        throw ex;
      }
    }
  }
  @Override
  public void componentLayoutChanged(int index, PropertyChangeEvent ev)
      throws PropertyVetoException {
    RADVisualComponent<?> radComp = radContainer.getSubComponent(index);

    if (ev != null && ev.getPropertyName() != null) {
      layoutDelegate.acceptComponentLayoutChange(index, ev);

      FormModel formModel = radContainer.getFormModel();
      formModel.fireComponentLayoutChanged(
          radComp, ev.getPropertyName(), ev.getOldValue(), ev.getNewValue());

      if (radComp.getNodeReference() != null) // propagate the change to node
      {
        radComp
            .getNodeReference()
            .firePropertyChangeHelper(ev.getPropertyName(), ev.getOldValue(), ev.getNewValue());
      }
    } else {
      if (radComp.getNodeReference() != null) // propagate the change to node
      {
        radComp.getNodeReference().fireComponentPropertySetsChange();
      }
      radComp.resetConstraintsProperties();
    }
  }
  @Override
  public void updatePrimaryContainer() {
    Container cont = getPrimaryContainer();
    Container contDel = getPrimaryContainerDelegate();

    layoutDelegate.clearContainer(cont, contDel);
    layoutDelegate.setLayoutToContainer(cont, contDel);

    RADVisualComponent<?>[] components = radContainer.getSubComponents();
    if (components.length > 0) {
      Component[] comps = new Component[components.length];
      for (int i = 0; i < components.length; i++) {
        comps[i] = (Component) components[i].getBeanInstance();
      }
      layoutDelegate.addComponentsToContainer(cont, contDel, comps, 0);
    }
  }
  // copy layout delegate from another container
  public void copyLayoutDelegateFrom(
      LayoutSupportManager sourceLayoutSupport, RADVisualComponent<?>[] newRadComps) {
    LayoutSupportDelegate sourceDelegate = sourceLayoutSupport.getLayoutDelegate();

    int componentCount = sourceDelegate.getComponentCount();

    Container cont = getPrimaryContainer();
    Container contDel = getPrimaryContainerDelegate();

    if (layoutDelegate != null) {
      removeLayoutDelegate(false);
    }

    Component[] primaryComps = new Component[componentCount];

    for (int i = 0; i < componentCount; i++) {
      RADVisualComponent<?> radComp = newRadComps[i];
      primaryComps[i] = (Component) radComp.getBeanInstance();
    }

    LayoutSupportDelegate newDelegate = sourceDelegate.cloneLayoutSupport(this, newRadComps);

    newDelegate.setLayoutToContainer(cont, contDel);
    newDelegate.addComponentsToContainer(cont, contDel, primaryComps, 0);

    layoutDelegate = newDelegate;

    // Ensure correct propagation of copied properties (issue 50011, 72351)
    try {
      layoutDelegate.acceptContainerLayoutChange(null);
    } catch (PropertyVetoException pvex) {
      // should not happen
    }
  }
 public void initializeLayoutDelegate() throws Exception {
   if (layoutDelegate != null && needInit) {
     LayoutManager lmInstance =
         initializeFromInstance ? getPrimaryContainerDelegate().getLayout() : null;
     layoutDelegate.initialize(this, lmInstance); // , initializeFromCode);
     fillLayout(null);
     getPropertySets(); // force properties and listeners creation
     needInit = false;
   }
 }
 public boolean paintDragFeedback(
     Container container,
     Container containerDelegate,
     Component component,
     LayoutConstraints<?> newConstraints,
     int newIndex,
     Graphics g) {
   return layoutDelegate.paintDragFeedback(
       container, containerDelegate, component, newConstraints, newIndex, g);
 }
 public int getNewIndex(
     Container container,
     Container containerDelegate,
     Component component,
     int index,
     Point posInCont,
     Point posInComp) {
   return layoutDelegate.getNewIndex(
       container, containerDelegate, component, index, posInCont, posInComp);
 }
 public LayoutConstraints<?> getResizedConstraints(
     Container container,
     Container containerDelegate,
     Component component,
     int index,
     Rectangle originalBounds,
     Insets sizeChanges,
     Point posInCont) {
   return layoutDelegate.getResizedConstraints(
       container, containerDelegate, component, index, originalBounds, sizeChanges, posInCont);
 }
  public void removeComponent(RADVisualComponent<?> radComp, int index) {
    // first store constraints in the meta component
    LayoutConstraints<?> constr = layoutDelegate.getConstraints(index);
    if (constr != null) {
      radComp.setLayoutConstraints(layoutDelegate.getClass(), constr);
    }
    // remove the component from layout
    layoutDelegate.removeComponent(index);
    // remove the component instance from the primary container instance
    if (!layoutDelegate.removeComponentFromContainer(
        getPrimaryContainer(),
        getPrimaryContainerDelegate(),
        (Component)
            radComp
                .getBeanInstance())) { // layout delegate does not support removing individual
                                       // components,
      // so we clear the container and add the remaining components again
      layoutDelegate.clearContainer(getPrimaryContainer(), getPrimaryContainerDelegate());

      RADVisualComponent<?>[] radComps = radContainer.getSubComponents();
      if (radComps.length > 1) {
        // we rely on that radcomp was not removed from the model yet
        Component[] comps = new Component[radComps.length - 1];
        for (int i = 0; i < radComps.length; i++) {
          if (i != index) {
            Component comp = (Component) radComps[i].getBeanInstance();
            comps[i < index ? i : i - 1] = comp;
          }
        }
        layoutDelegate.addComponentsToContainer(
            getPrimaryContainer(), getPrimaryContainerDelegate(), comps, 0);
      }
    }
  }
  private void fillLayout(LayoutConstraints<?>[] oldConstraints) {
    RADVisualComponent<?>[] radComps = radContainer.getSubComponents();
    int componentCount = radComps.length;
    Component[] primaryComps = new Component[componentCount];
    LayoutConstraints<?>[] newConstraints = new LayoutConstraints<?>[componentCount];

    for (int i = 0; i < componentCount; i++) {
      primaryComps[i] = radComps[i].getBeanInstance();
      newConstraints[i] = radComps[i].getLayoutConstraints(layoutDelegate.getClass());
    }

    layoutDelegate.convertConstraints(oldConstraints, newConstraints, primaryComps);

    if (componentCount > 0) {
      layoutDelegate.acceptNewComponents(radComps, newConstraints, 0);
      layoutDelegate.addComponents(radComps, newConstraints, 0);

      for (int i = 0; i < componentCount; i++) {
        radComps[i].resetConstraintsProperties();
      }
    }

    // setup primary container
    Container cont = getPrimaryContainer();
    Container contDel = getPrimaryContainerDelegate();
    layoutDelegate.setLayoutToContainer(cont, contDel);
    if (componentCount > 0) {
      layoutDelegate.addComponentsToContainer(cont, contDel, primaryComps, 0);
    }
  }
  // properties and customizer
  public Node.PropertySet[] getPropertySets() {
    if (propertySets == null) {
      if (layoutDelegate == null) {
        return new Node.PropertySet[0]; // Issue 63916
      }
      propertySets = layoutDelegate.getPropertySets();

      for (Node.PropertySet propertySet : propertySets) {
        FormProperty<?>[] props = (FormProperty<?>[]) propertySet.getProperties();
        for (FormProperty<?> prop : props) {
          prop.addVetoableChangeListener(getLayoutListener());
          prop.addPropertyChangeListener(getLayoutListener());
        }
      }
    }
    return propertySets;
  }
  @Override
  public void containerLayoutChanged(PropertyChangeEvent ev) throws PropertyVetoException {
    if (ev != null && ev.getPropertyName() != null) {
      layoutDelegate.acceptContainerLayoutChange(ev);

      FormModel formModel = radContainer.getFormModel();
      formModel.fireContainerLayoutChanged(
          radContainer, ev.getPropertyName(), ev.getOldValue(), ev.getNewValue());
    } else {
      propertySets = null;
    }

    LayoutNode node = radContainer.getLayoutNodeReference();
    if (node != null) {
      // propagate the change to node
      if (ev != null && ev.getPropertyName() != null) {
        node.fireLayoutPropertiesChange();
      } else {
        node.fireLayoutPropertySetsChange();
      }
    }
  }
  // drag and drop support
  public LayoutConstraints<?> getNewConstraints(
      Container container,
      Container containerDelegate,
      Component component,
      int index,
      Point posInCont,
      Point posInComp) {

    LayoutConstraints<?> constraints =
        layoutDelegate.getNewConstraints(
            container, containerDelegate, component, index, posInCont, posInComp);
    String context = null;
    Object[] params = null;
    if (layoutDelegate instanceof AbstractLayoutSupport) {
      AbstractLayoutSupport support = (AbstractLayoutSupport) layoutDelegate;
      context = support.getAssistantContext();
      params = support.getAssistantParams();
    }
    context = (context == null) ? "generalPosition" : context; // NOI18N
    radContainer.getFormModel().getAssistantModel().setContext(context, params);
    return constraints;
  }
 // managing live components
 public void setLayoutToContainer(Container container, Container containerDelegate) {
   layoutDelegate.setLayoutToContainer(container, containerDelegate);
 }
 // arranging support
 public void arrangeContainer(Container container, Container containerDelegate) {
   layoutDelegate.arrangeContainer(container, containerDelegate);
 }
 // arranging support
 public void selectComponent(int index) {
   layoutDelegate.selectComponent(index);
 }
 // arranging support
 public void processMouseClick(Point p, Container cont, Container contDelegate) {
   layoutDelegate.processMouseClick(p, cont, contDelegate);
 }
 // data validation
 public void acceptNewComponents(
     RADVisualComponent<?>[] components, LayoutConstraints<?>[] constraints, int index) {
   layoutDelegate.acceptNewComponents(components, constraints, index);
 }
 // resizing support
 public int getResizableDirections(
     Container container, Container containerDelegate, Component component, int index) {
   return layoutDelegate.getResizableDirections(container, containerDelegate, component, index);
 }
 public LayoutConstraints<?> getStoredConstraints(RADVisualComponent<?> radComp) {
   return radComp.getLayoutConstraints(layoutDelegate.getClass());
 }
 // managing constraints
 public LayoutConstraints<?> getConstraints(int index) {
   return layoutDelegate.getConstraints(index);
 }
 public boolean clearContainer(Container container, Container containerDelegate) {
   return layoutDelegate.clearContainer(container, containerDelegate);
 }
 public boolean removeComponentFromContainer(
     Container container, Container containerDelegate, Component component) {
   return layoutDelegate.removeComponentFromContainer(container, containerDelegate, component);
 }
 public void addComponentsToContainer(
     Container container, Container containerDelegate, Component[] components, int index) {
   layoutDelegate.addComponentsToContainer(container, containerDelegate, components, index);
 }