plugins/ui-designer/src/com/intellij/uiDesigner/radComponents/RadRootContainer.java

   1 /*
   2  * Copyright 2000-2009 JetBrains s.r.o.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package com.intellij.uiDesigner.radComponents;
  17
  18 import com.intellij.openapi.module.Module;
  19 import com.intellij.openapi.util.Comparing;
  20 import com.intellij.uiDesigner.FormEditingUtil;
  21 import com.intellij.uiDesigner.UIFormXmlConstants;
  22 import com.intellij.uiDesigner.XmlWriter;
  23 import com.intellij.uiDesigner.compiler.Utils;
  24 import com.intellij.uiDesigner.lw.*;
  25 import org.jetbrains.annotations.NonNls;
  26 import org.jetbrains.annotations.NotNull;
  27 import org.jetbrains.annotations.Nullable;
  28
  29 import javax.swing.*;
  30 import java.awt.Color;
  31 import java.util.ArrayList;
  32 import java.util.List;
  33 import java.util.Locale;
  34 import java.util.Collections;
  35
  36 /**
  37  * @author Anton Katilin
  38  * @author Vladimir Kondratyev
  39  */
  40 public final class RadRootContainer extends RadContainer implements IRootContainer {
  41   private String myClassToBind;
  42   private String myMainComponentBinding;
  43   private Locale myStringDescriptorLocale;
  44   private final List<RadButtonGroup> myButtonGroups = new ArrayList<RadButtonGroup>();
  45   private final List<LwInspectionSuppression> myInspectionSuppressions = new ArrayList<LwInspectionSuppression>();
  46
  47   public RadRootContainer(final Module module, final String id) {
  48     super(module, JPanel.class, id);
  49     getDelegee().setBackground(Color.WHITE);
  50   }
  51
  52   /**
  53    * Always returns <code>false</code> because root group isn't selectable.
  54    */
  55   public boolean isSelected() {
  56     return false;
  57   }
  58
  59   /**
  60    * <code>RadRootContainer</code> is not selectable
  61    */
  62   public void setSelected(final boolean ignored) { }
  63
  64   /**
  65    * @return full qualified name of the class. If there is no bound class
  66    * then the method returns <code>null</code>.
  67    */
  68   @Nullable
  69   public String getClassToBind(){
  70     return myClassToBind;
  71   }
  72
  73   public void setClassToBind(final String classToBind){
  74     myClassToBind = classToBind;
  75   }
  76
  77   public String getMainComponentBinding(){
  78     return myMainComponentBinding;
  79   }
  80
  81   public void setMainComponentBinding(final String mainComponentBinding){
  82     myMainComponentBinding = mainComponentBinding;
  83   }
  84
  85   public void write(final XmlWriter writer) {
  86     writer.startElement("form", Utils.FORM_NAMESPACE);
  87     try{
  88       writer.addAttribute("version", 1);
  89       final String classToBind = getClassToBind();
  90       if (classToBind != null){
  91         writer.addAttribute("bind-to-class", classToBind);
  92       }
  93       final String mainComponentBinding = getMainComponentBinding();
  94       if (mainComponentBinding != null) {
  95         writer.addAttribute("stored-main-component-binding", mainComponentBinding);
  96       }
  97       writeChildrenImpl(writer);
  98       if (myButtonGroups.size() > 0) {
  99         writer.startElement(UIFormXmlConstants.ELEMENT_BUTTON_GROUPS);
 100         for(RadButtonGroup group: myButtonGroups) {
 101           group.write(writer);
 102         }
 103         writer.endElement();
 104       }
 105       writeInspectionSuppressions(writer);
 106     }
 107     finally{
 108       writer.endElement(); // form
 109     }
 110   }
 111
 112   private void writeInspectionSuppressions(final XmlWriter writer) {
 113     if (myInspectionSuppressions.size() > 0) {
 114       writer.startElement(UIFormXmlConstants.ELEMENT_INSPECTION_SUPPRESSIONS);
 115       for(LwInspectionSuppression suppression: myInspectionSuppressions) {
 116         writer.startElement(UIFormXmlConstants.ELEMENT_SUPPRESS);
 117         writer.addAttribute(UIFormXmlConstants.ATTRIBUTE_INSPECTION, suppression.getInspectionId());
 118         if (suppression.getComponentId() != null) {
 119           writer.addAttribute(UIFormXmlConstants.ATTRIBUTE_ID, suppression.getComponentId());
 120         }
 121         writer.endElement();
 122       }
 123       writer.endElement();
 124     }
 125   }
 126
 127   @Override public void writeConstraints(final XmlWriter writer) {
 128     writer.startElement("constraints");
 129     try {
 130       myLayoutManager.writeChildConstraints(writer, this);
 131     } finally {
 132       writer.endElement(); // constraints
 133     }
 134   }
 135
 136   @Override @Nullable
 137   protected RadLayoutManager createInitialLayoutManager() {
 138     return RadXYLayoutManager.INSTANCE;
 139   }
 140
 141   public void setGroupForComponent(@NotNull RadComponent component, @Nullable RadButtonGroup value) {
 142     for(int i=myButtonGroups.size()-1; i >= 0; i--) {
 143       RadButtonGroup group = myButtonGroups.get(i);
 144       if (group == value) {
 145         group.add(component);
 146       }
 147       else {
 148         group.remove(component);
 149         if (group.isEmpty()) {
 150           myButtonGroups.remove(i);
 151         }
 152       }
 153     }
 154   }
 155
 156   public RadButtonGroup[] getButtonGroups() {
 157     return myButtonGroups.toArray(new RadButtonGroup[myButtonGroups.size()]);
 158   }
 159
 160   public String suggestGroupName() {
 161     int groupNumber = 1;
 162     group: while(true) {
 163       @NonNls String suggestedName = "buttonGroup" + groupNumber;
 164       for(RadButtonGroup group: myButtonGroups) {
 165         if (group.getName().equals(suggestedName)) {
 166           groupNumber++;
 167           continue group;
 168         }
 169       }
 170       return suggestedName;
 171     }
 172   }
 173
 174   public RadButtonGroup createGroup(final String groupName) {
 175     RadButtonGroup group = new RadButtonGroup(groupName);
 176     myButtonGroups.add(group);
 177     return group;
 178   }
 179
 180   public void deleteGroup(RadButtonGroup group) {
 181     myButtonGroups.remove(group);
 182   }
 183
 184   public void setButtonGroups(final IButtonGroup[] buttonGroups) {
 185     myButtonGroups.clear();
 186     for(IButtonGroup lwGroup: buttonGroups) {
 187       final String[] componentIds = lwGroup.getComponentIds();
 188       if (componentIds.length > 0) {
 189         RadButtonGroup group = createGroup(lwGroup.getName());
 190         group.setBound(lwGroup.isBound());
 191         group.addComponentIds(componentIds);
 192       }
 193     }
 194   }
 195
 196   public List<RadComponent> getGroupContents(final RadButtonGroup group) {
 197     ArrayList<RadComponent> result = new ArrayList<RadComponent>();
 198     for(String id: group.getComponentIds()) {
 199       RadComponent component = (RadComponent) FormEditingUtil.findComponent(this, id);
 200       if (component != null) {
 201         result.add(component);
 202       }
 203     }
 204     return result;
 205   }
 206
 207   public String getButtonGroupName(IComponent component) {
 208     for(RadButtonGroup group: myButtonGroups) {
 209       if (group.contains((RadComponent)component)) {
 210         return group.getName();
 211       }
 212     }
 213     return null;
 214   }
 215
 216   public String[] getButtonGroupComponentIds(String groupName) {
 217     for(RadButtonGroup group: myButtonGroups) {
 218       if (group.getName().equals(groupName)) {
 219         return group.getComponentIds();
 220       }
 221     }
 222     throw new IllegalArgumentException("Cannot find group " + groupName);
 223   }
 224
 225   public Locale getStringDescriptorLocale() {
 226     return myStringDescriptorLocale;
 227   }
 228
 229   public void setStringDescriptorLocale(final Locale stringDescriptorLocale) {
 230     myStringDescriptorLocale = stringDescriptorLocale;
 231   }
 232
 233   public void suppressInspection(String inspectionId, @Nullable RadComponent component) {
 234     for(int i=myInspectionSuppressions.size()-1; i >= 0; i--) {
 235       LwInspectionSuppression suppression = myInspectionSuppressions.get(i);
 236       if (suppression.getInspectionId().equals(inspectionId)) {
 237         if (component != null && (component.getId().equals(suppression.getComponentId()) || suppression.getComponentId() == null)) {
 238           return;
 239         }
 240         if (component == null && suppression.getComponentId() != null) {
 241           myInspectionSuppressions.remove(i);
 242         }
 243       }
 244     }
 245     myInspectionSuppressions.add(new LwInspectionSuppression(inspectionId, component == null ? null : component.getId()));
 246   }
 247
 248   public boolean isInspectionSuppressed(final String inspectionId, final String componentId) {
 249     for(LwInspectionSuppression suppression: myInspectionSuppressions) {
 250       if ((suppression.getComponentId() == null || suppression.getComponentId().equals(componentId)) &&
 251           suppression.getInspectionId().equals(inspectionId)) {
 252         return true;
 253       }
 254     }
 255     return false;
 256   }
 257
 258   public LwInspectionSuppression[] getInspectionSuppressions() {
 259     return myInspectionSuppressions.toArray(new LwInspectionSuppression[myInspectionSuppressions.size()]);
 260   }
 261
 262   public void setInspectionSuppressions(final LwInspectionSuppression[] inspectionSuppressions) {
 263     myInspectionSuppressions.clear();
 264     Collections.addAll(myInspectionSuppressions, inspectionSuppressions);
 265   }
 266
 267   public void removeInspectionSuppression(final LwInspectionSuppression suppression) {
 268     for(LwInspectionSuppression existing: myInspectionSuppressions) {
 269       if (existing.getInspectionId().equals(suppression.getInspectionId()) &&
 270         Comparing.equal(existing.getComponentId(), suppression.getComponentId())) {
 271         myInspectionSuppressions.remove(existing);
 272         break;
 273       }
 274     }
 275   }
 276 }