plugins/ui-designer/src/com/intellij/uiDesigner/palette/ComponentItem.java

/*
 * Copyright 2000-2009 JetBrains s.r.o.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.intellij.uiDesigner.palette;

import com.intellij.ide.dnd.DnDDragStartBean;
import com.intellij.ide.palette.PaletteItem;
import com.intellij.openapi.actionSystem.ActionGroup;
import com.intellij.openapi.actionSystem.ActionManager;
import com.intellij.openapi.actionSystem.CommonDataKeys;
import com.intellij.openapi.actionSystem.DataKey;
import com.intellij.openapi.actionSystem.LangDataKeys;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.module.ResourceFileUtil;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.util.IconLoader;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.psi.JavaPsiFacade;
import com.intellij.psi.PsiFile;
import com.intellij.psi.search.GlobalSearchScope;
import com.intellij.ui.ColoredListCellRenderer;
import com.intellij.ui.SimpleTextAttributes;
import com.intellij.uiDesigner.HSpacer;
import com.intellij.uiDesigner.UIDesignerBundle;
import com.intellij.uiDesigner.VSpacer;
import com.intellij.uiDesigner.binding.FormClassIndex;
import com.intellij.uiDesigner.core.GridConstraints;
import com.intellij.uiDesigner.lw.StringDescriptor;
import com.intellij.uiDesigner.propertyInspector.IntrospectedProperty;
import com.intellij.uiDesigner.radComponents.RadAtomicComponent;
import icons.UIDesignerIcons;
import org.jetbrains.annotations.NonNls;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

import javax.swing.*;
import java.awt.*;
import java.io.IOException;
import java.util.HashMap;
import java.util.List;

/**
 * @author Anton Katilin
 * @author Vladimir Kondratyev
 */
public final class ComponentItem implements Cloneable, PaletteItem {
  private static final Logger LOG = Logger.getInstance("#com.intellij.uiDesigner.palette.ComponentItem");

  public static final DataKey<ComponentItem> DATA_KEY = DataKey.create(ComponentItem.class.getName());

  @NonNls private String myClassName;
  private final GridConstraints myDefaultConstraints;
  /**
   * Do not use this member directly. Use {@link #getIcon()} instead.
   */
  private Icon myIcon;
  /**
   * Do not use this member directly. Use {@link #getSmallIcon()} instead.
   */
  private Icon mySmallIcon;
  /**
   * @see #getIconPath()
   * @see #setIconPath(java.lang.String)
   */
  private String myIconPath;
  /**
   * Do not access this field directly. Use {@link #getToolTipText()} instead.
   */
  final String myToolTipText;
  private final HashMap<String, StringDescriptor> myPropertyName2initialValue;
  /** Whether item is removable or not */
  private final boolean myRemovable;

  private boolean myAutoCreateBinding;
  private boolean myCanAttachLabel;
  private boolean myIsContainer;
  private boolean myAnyComponent;
  private Dimension myInitialSize;

  @NotNull private final Project myProject;

  public ComponentItem(
    @NotNull Project project,
    @NotNull final String className,
    @Nullable final String iconPath,
    @Nullable final String toolTipText,
    @NotNull final GridConstraints defaultConstraints,
    @NotNull final HashMap<String, StringDescriptor> propertyName2initialValue,
    final boolean removable,
    final boolean autoCreateBinding,
    final boolean canAttachLabel
  ){
    myAutoCreateBinding = autoCreateBinding;
    myCanAttachLabel = canAttachLabel;
    myProject = project;
    setClassName(className);
    setIconPath(iconPath);

    myToolTipText = toolTipText;
    myDefaultConstraints = defaultConstraints;
    myPropertyName2initialValue = propertyName2initialValue;

    myRemovable = removable;
  }

  /**
   * @return whether the item is removable from palette or not.
   */
  public boolean isRemovable() {
    return myRemovable;
  }

  private static String calcToolTipText(@NotNull final String className) {
    final int lastDotIndex = className.lastIndexOf('.');
    if (lastDotIndex != -1 && lastDotIndex != className.length() - 1/*not the last char in class name*/) {
      return className.substring(lastDotIndex + 1) + " (" + className.substring(0, lastDotIndex) + ")";
    }
    else{
      return className;
    }
  }

  /** Creates deep copy of the object. You can edit any properties of the returned object. */
  public ComponentItem clone(){
    final ComponentItem result = new ComponentItem(
      myProject,
      myClassName,
      myIconPath,
      myToolTipText,
      (GridConstraints)myDefaultConstraints.clone(),
      (HashMap<String, StringDescriptor>)myPropertyName2initialValue.clone(),
      myRemovable,
      myAutoCreateBinding,
      myCanAttachLabel
    );
    result.setIsContainer(myIsContainer);
    return result;
  }

  /**
   * @return string that represents path in the JAR file system that was used to load
   * icon returned by {@link #getIcon()} method. This method can returns <code>null</code>.
   * It means that palette item has some "unknown" item.
   */
  @Nullable String getIconPath() {
    return myIconPath;
  }

  /**
   * @param iconPath new path inside JAR file system. <code>null</code> means that
   * <code>iconPath</code> is not specified and some "unknown" icon should be used
   * to represent the {@link ComponentItem} in UI.
   */
  void setIconPath(@Nullable final String iconPath){
    myIcon = null; // reset cached icon
    mySmallIcon = null; // reset cached icon

    myIconPath = iconPath;
  }

  /**
   * @return item's icon. This icon is used to represent item at the toolbar.
   * Note, that the method never returns <code>null</code>. It returns some
   * default "unknown" icon for the items that has no specified icon in the XML.
   */
  @NotNull public Icon getIcon() {
    // Check cached value first
    if(myIcon != null){
      return myIcon;
    }

    // Create new icon
    if(myIconPath != null && myIconPath.length() > 0) {
      final VirtualFile iconFile = ResourceFileUtil.findResourceFileInScope(myIconPath, myProject, GlobalSearchScope.allScope(myProject));
      if (iconFile != null) {
        try {
          myIcon = new ImageIcon(iconFile.contentsToByteArray());
        }
        catch (IOException e) {
          myIcon = null;
        }
      }
      else {
        myIcon = IconLoader.findIcon(myIconPath);
      }
    }
    if(myIcon == null){
      myIcon = UIDesignerIcons.Unknown;
     }
    LOG.assertTrue(myIcon != null);
    return myIcon;
  }

  /**
   * @return small item's icon. This icon represents component in the
   * component tree. The method never returns <code>null</code>. It returns some
   * default "unknown" icon for the items that has no specified icon in the XML.
   */
  @NotNull public Icon getSmallIcon() {
    // Check cached value first
    if(mySmallIcon != null){
      return myIcon;
    }

    // [vova] It's safe to cast to ImageIcon here because all icons loaded by IconLoader
    // are ImageIcon(s).
    final Icon icon = getIcon();
    if (icon instanceof ImageIcon) {
      final ImageIcon imageIcon = (ImageIcon)icon;
      mySmallIcon = new MySmallIcon(imageIcon.getImage());
    }
    else {
      mySmallIcon = icon;
    }

    return mySmallIcon;
  }

  /**
   * @return name of component's class which is represented by the item.
   */
  @NotNull public String getClassName() {
    return myClassName;
  }

  public String getClassShortName() {
    final int lastDotIndex = myClassName.lastIndexOf('.');
    if (lastDotIndex != -1 && lastDotIndex != myClassName.length() - 1/*not the last char in class name*/) {
      return myClassName.substring(lastDotIndex + 1).replace('$', '.');
    }
    else{
      return myClassName.replace('$', '.');
    }
  }

  /**
   * @param className name of the class that will be instanteated when user drop
   * item on the form. Cannot be <code>null</code>. If the class does not exist or
   * could not be instanteated (for example, class has no default constructor,
   * it's not a subclass of JComponent, etc) then placeholder component will be
   * added to the form.
   */
  public void setClassName(@NotNull final String className){
    myClassName = className;
  }

  public String getToolTipText() {
    return myToolTipText != null ? myToolTipText : calcToolTipText(myClassName);
  }

  @NotNull public GridConstraints getDefaultConstraints() {
    return myDefaultConstraints;
  }

  /**
   * The method returns initial value of the property. Term
   * "initial" means that just after creation of RadComponent
   * all its properties are set into initial values.
   * The method returns <code>null</code> if the
   * initial property is not defined. Unfortunately we cannot
   * put this method into the constuctor of <code>RadComponent</code>.
   * The problem is that <code>RadComponent</code> is used in the
   * code genaration and code generation doesn't depend on any
   * <code>ComponentItem</code>, so we need to initialize <code>RadComponent</code>
   * in all places where it's needed explicitly.
   */
  public Object getInitialValue(final IntrospectedProperty property){
    return myPropertyName2initialValue.get(property.getName());
  }

  /**
   * Internal method. It should be used only to externalize initial item's values.
   * This method never returns <code>null</code>.
   */
  HashMap<String, StringDescriptor> getInitialValues(){
    return myPropertyName2initialValue;
  }

  public boolean isAutoCreateBinding() {
    return myAutoCreateBinding;
  }

  public void setAutoCreateBinding(final boolean autoCreateBinding) {
    myAutoCreateBinding = autoCreateBinding;
  }

  public boolean isCanAttachLabel() {
    return myCanAttachLabel;
  }

  public void setCanAttachLabel(final boolean canAttachLabel) {
    myCanAttachLabel = canAttachLabel;
  }

  public boolean isContainer() {
    return myIsContainer;
  }

  public void setIsContainer(final boolean isContainer) {
    myIsContainer = isContainer;
  }

  public boolean equals(final Object o) {
    if (this == o) return true;
    if (!(o instanceof ComponentItem)) return false;

    final ComponentItem componentItem = (ComponentItem)o;

    if (myClassName != null ? !myClassName.equals(componentItem.myClassName) : componentItem.myClassName != null) return false;
    if (myDefaultConstraints != null
        ? !myDefaultConstraints.equals(componentItem.myDefaultConstraints)
        : componentItem.myDefaultConstraints != null) {
      return false;
    }
    if (myIconPath != null ? !myIconPath.equals(componentItem.myIconPath) : componentItem.myIconPath != null) return false;
    if (myPropertyName2initialValue != null
        ? !myPropertyName2initialValue.equals(componentItem.myPropertyName2initialValue)
        : componentItem.myPropertyName2initialValue != null) {
      return false;
    }
    if (myToolTipText != null ? !myToolTipText.equals(componentItem.myToolTipText) : componentItem.myToolTipText != null) return false;

    return true;
  }

  public int hashCode() {
    int result;
    result = (myClassName != null ? myClassName.hashCode() : 0);
    result = 29 * result + (myDefaultConstraints != null ? myDefaultConstraints.hashCode() : 0);
    result = 29 * result + (myIconPath != null ? myIconPath.hashCode() : 0);
    result = 29 * result + (myToolTipText != null ? myToolTipText.hashCode() : 0);
    result = 29 * result + (myPropertyName2initialValue != null ? myPropertyName2initialValue.hashCode() : 0);
    return result;
  }

  public void customizeCellRenderer(ColoredListCellRenderer cellRenderer, boolean selected, boolean hasFocus) {
    cellRenderer.setIcon(getSmallIcon());
    if (myAnyComponent) {
      cellRenderer.append(UIDesignerBundle.message("palette.non.palette.component"), SimpleTextAttributes.REGULAR_ATTRIBUTES);
      cellRenderer.setToolTipText(UIDesignerBundle.message("palette.non.palette.component.tooltip"));
    }
    else {
      cellRenderer.append(getClassShortName(), SimpleTextAttributes.REGULAR_ATTRIBUTES);
      cellRenderer.setToolTipText(getToolTipText());
    }
  }

  @Nullable public DnDDragStartBean startDragging() {
    if (isAnyComponent()) return null;
    return new DnDDragStartBean(this);
  }

  @Nullable public ActionGroup getPopupActionGroup() {
    return (ActionGroup) ActionManager.getInstance().getAction("GuiDesigner.PaletteComponentPopupMenu");
  }

  @Nullable public Object getData(Project project, String dataId) {
    if (CommonDataKeys.PSI_ELEMENT.is(dataId)) {
      return JavaPsiFacade.getInstance(project).findClass(myClassName, GlobalSearchScope.allScope(project));
    }
    if (getClass().getName().equals(dataId)) {
      return this;
    }
    if (GroupItem.DATA_KEY.is(dataId)) {
      return Palette.getInstance(project).findGroup(this);
    }
    return null;
  }

  @Nullable public PsiFile getBoundForm() {
    if (myClassName.length() == 0 || myClassName.startsWith("javax.swing")) {
      return null;
    }
    List<PsiFile> boundForms = FormClassIndex.findFormsBoundToClass(myProject, myClassName.replace('$', '.'));
    if (boundForms.size() > 0) {
      return boundForms.get(0);
    }
    return null;
  }

  @NotNull
  public Dimension getInitialSize(final JComponent parent, final ClassLoader loader) {
    if (myInitialSize != null) {
      return myInitialSize;
    }
    myInitialSize = new Dimension(myDefaultConstraints.myPreferredSize);
    if (myInitialSize.width <= 0 || myInitialSize.height <= 0) {
      try {
        Class aClass = Class.forName(getClassName(), true, loader);
        RadAtomicComponent component = new RadAtomicComponent(aClass, "", Palette.getInstance(myProject));
        component.initDefaultProperties(this);
        final JComponent delegee = component.getDelegee();
        if (parent != null) {
          final Font font = parent.getFont();
          delegee.setFont(font);
        }
        Dimension prefSize = delegee.getPreferredSize();
        Dimension minSize = delegee.getMinimumSize();
        if (myInitialSize.width <= 0) {
          myInitialSize.width = prefSize.width;
        }
        if (myInitialSize.height <= 0) {
          myInitialSize.height = prefSize.height;
        }
        myInitialSize.width = Math.max(myInitialSize.width, minSize.width);
        myInitialSize.height = Math.max(myInitialSize.height, minSize.height);
      }
      catch (Exception e) {
        LOG.debug(e);
      }
    }
    return myInitialSize;
  }

  public static ComponentItem createAnyComponentItem(final Project project) {
    ComponentItem result = new ComponentItem(project, "", null, null,
                                             new GridConstraints(), new HashMap<String, StringDescriptor>(),
                                             false, false, false);
    result.myAnyComponent = true;
    return result;
  }

  public boolean isAnyComponent() {
    return myAnyComponent;
  }

  public boolean isSpacer() {
    return myClassName.equals(HSpacer.class.getName()) || myClassName.equals(VSpacer.class.getName());
  }

  private static final class MySmallIcon implements Icon{
    private final Image myImage;

    public MySmallIcon(@NotNull final Image delegate) {
      myImage = delegate;
    }

    public int getIconHeight() {
      return 18;
    }

    public int getIconWidth() {
      return 18;
    }

    public void paintIcon(final Component c, final Graphics g, final int x, final int y) {
      g.drawImage(myImage, 2, 2, 14, 14, c);
    }
  }
}