replaced <code></code> with more concise {@code}
[idea/community.git] / 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.util.Comparing;
19 import com.intellij.psi.codeStyle.JavaCodeStyleManager;
20 import com.intellij.psi.codeStyle.SuggestedNameInfo;
21 import com.intellij.psi.codeStyle.VariableKind;
22 import com.intellij.ui.JBColor;
23 import com.intellij.uiDesigner.FormEditingUtil;
24 import com.intellij.uiDesigner.ModuleProvider;
25 import com.intellij.uiDesigner.UIFormXmlConstants;
26 import com.intellij.uiDesigner.XmlWriter;
27 import com.intellij.uiDesigner.compiler.Utils;
28 import com.intellij.uiDesigner.lw.IButtonGroup;
29 import com.intellij.uiDesigner.lw.IComponent;
30 import com.intellij.uiDesigner.lw.IRootContainer;
31 import com.intellij.uiDesigner.lw.LwInspectionSuppression;
32 import com.intellij.util.ui.UIUtil;
33 import org.jetbrains.annotations.NonNls;
34 import org.jetbrains.annotations.NotNull;
35 import org.jetbrains.annotations.Nullable;
36
37 import javax.swing.*;
38 import java.awt.*;
39 import java.util.ArrayList;
40 import java.util.Collections;
41 import java.util.List;
42 import java.util.Locale;
43
44 /**
45  * @author Anton Katilin
46  * @author Vladimir Kondratyev
47  */
48 public final class RadRootContainer extends RadContainer implements IRootContainer {
49   private String myClassToBind;
50   private String myMainComponentBinding;
51   private Locale myStringDescriptorLocale;
52   private final List<RadButtonGroup> myButtonGroups = new ArrayList<>();
53   private final List<LwInspectionSuppression> myInspectionSuppressions = new ArrayList<>();
54
55   public RadRootContainer(final ModuleProvider module, final String id) {
56     super(module, JPanel.class, id);
57     getDelegee().setBackground(new JBColor(Color.WHITE, UIUtil.getListBackground()));
58   }
59
60   /**
61    * Always returns {@code false} because root group isn't selectable.
62    */
63   public boolean isSelected() {
64     return false;
65   }
66
67   /**
68    * {@code RadRootContainer} is not selectable
69    */
70   public void setSelected(final boolean ignored) { }
71
72   /**
73    * @return full qualified name of the class. If there is no bound class
74    * then the method returns {@code null}.
75    */
76   @Nullable
77   public String getClassToBind(){
78     return myClassToBind;
79   }
80
81   public void setClassToBind(final String classToBind){
82     myClassToBind = classToBind;
83   }
84
85   public String getMainComponentBinding(){
86     return myMainComponentBinding;
87   }
88
89   public void setMainComponentBinding(final String mainComponentBinding){
90     myMainComponentBinding = mainComponentBinding;
91   }
92
93   public void write(final XmlWriter writer) {
94     writer.startElement("form", Utils.FORM_NAMESPACE);
95     try{
96       writer.addAttribute("version", 1);
97       final String classToBind = getClassToBind();
98       if (classToBind != null){
99         writer.addAttribute("bind-to-class", classToBind);
100       }
101       final String mainComponentBinding = getMainComponentBinding();
102       if (mainComponentBinding != null) {
103         writer.addAttribute("stored-main-component-binding", mainComponentBinding);
104       }
105       writeChildrenImpl(writer);
106       if (myButtonGroups.size() > 0) {
107         writer.startElement(UIFormXmlConstants.ELEMENT_BUTTON_GROUPS);
108         for(RadButtonGroup group: myButtonGroups) {
109           group.write(writer);
110         }
111         writer.endElement();
112       }
113       writeInspectionSuppressions(writer);
114     }
115     finally{
116       writer.endElement(); // form
117     }
118   }
119
120   private void writeInspectionSuppressions(final XmlWriter writer) {
121     if (myInspectionSuppressions.size() > 0) {
122       writer.startElement(UIFormXmlConstants.ELEMENT_INSPECTION_SUPPRESSIONS);
123       for(LwInspectionSuppression suppression: myInspectionSuppressions) {
124         writer.startElement(UIFormXmlConstants.ELEMENT_SUPPRESS);
125         writer.addAttribute(UIFormXmlConstants.ATTRIBUTE_INSPECTION, suppression.getInspectionId());
126         if (suppression.getComponentId() != null) {
127           writer.addAttribute(UIFormXmlConstants.ATTRIBUTE_ID, suppression.getComponentId());
128         }
129         writer.endElement();
130       }
131       writer.endElement();
132     }
133   }
134
135   @Override public void writeConstraints(final XmlWriter writer) {
136     writer.startElement("constraints");
137     try {
138       myLayoutManager.writeChildConstraints(writer, this);
139     } finally {
140       writer.endElement(); // constraints
141     }
142   }
143
144   @Override @Nullable
145   protected RadLayoutManager createInitialLayoutManager() {
146     return RadXYLayoutManager.INSTANCE;
147   }
148
149   public void setGroupForComponent(@NotNull RadComponent component, @Nullable RadButtonGroup value) {
150     for(int i=myButtonGroups.size()-1; i >= 0; i--) {
151       RadButtonGroup group = myButtonGroups.get(i);
152       if (group == value) {
153         group.add(component);
154       }
155       else {
156         group.remove(component);
157         if (group.isEmpty()) {
158           myButtonGroups.remove(i);
159         }
160       }
161     }
162   }
163
164   public RadButtonGroup[] getButtonGroups() {
165     return myButtonGroups.toArray(new RadButtonGroup[myButtonGroups.size()]);
166   }
167
168   public String suggestGroupName() {
169     int groupNumber = 1;
170     group: while(true) {
171       @NonNls String suggestedName = "buttonGroup" + groupNumber;
172       // we don't have a project in snapshooter
173       if (getModule() != null) {
174         SuggestedNameInfo nameInfo =
175           JavaCodeStyleManager.getInstance(getProject()).suggestVariableName(VariableKind.FIELD, suggestedName, null, null);
176         suggestedName = nameInfo.names[0];
177       }
178       for(RadButtonGroup group: myButtonGroups) {
179         if (group.getName().equals(suggestedName)) {
180           groupNumber++;
181           continue group;
182         }
183       }
184       return suggestedName;
185     }
186   }
187
188   public RadButtonGroup createGroup(final String groupName) {
189     RadButtonGroup group = new RadButtonGroup(groupName);
190     myButtonGroups.add(group);
191     return group;
192   }
193
194   public void deleteGroup(RadButtonGroup group) {
195     myButtonGroups.remove(group);
196   }
197
198   public void setButtonGroups(final IButtonGroup[] buttonGroups) {
199     myButtonGroups.clear();
200     for(IButtonGroup lwGroup: buttonGroups) {
201       final String[] componentIds = lwGroup.getComponentIds();
202       if (componentIds.length > 0) {
203         RadButtonGroup group = createGroup(lwGroup.getName());
204         group.setBound(lwGroup.isBound());
205         group.addComponentIds(componentIds);
206       }
207     }
208   }
209
210   public List<RadComponent> getGroupContents(final RadButtonGroup group) {
211     ArrayList<RadComponent> result = new ArrayList<>();
212     for(String id: group.getComponentIds()) {
213       RadComponent component = (RadComponent) FormEditingUtil.findComponent(this, id);
214       if (component != null) {
215         result.add(component);
216       }
217     }
218     return result;
219   }
220
221   public String getButtonGroupName(IComponent component) {
222     for(RadButtonGroup group: myButtonGroups) {
223       if (group.contains((RadComponent)component)) {
224         return group.getName();
225       }
226     }
227     return null;
228   }
229
230   public String[] getButtonGroupComponentIds(String groupName) {
231     for(RadButtonGroup group: myButtonGroups) {
232       if (group.getName().equals(groupName)) {
233         return group.getComponentIds();
234       }
235     }
236     throw new IllegalArgumentException("Cannot find group " + groupName);
237   }
238
239   public Locale getStringDescriptorLocale() {
240     return myStringDescriptorLocale;
241   }
242
243   public void setStringDescriptorLocale(final Locale stringDescriptorLocale) {
244     myStringDescriptorLocale = stringDescriptorLocale;
245   }
246
247   public void suppressInspection(String inspectionId, @Nullable RadComponent component) {
248     for(int i=myInspectionSuppressions.size()-1; i >= 0; i--) {
249       LwInspectionSuppression suppression = myInspectionSuppressions.get(i);
250       if (suppression.getInspectionId().equals(inspectionId)) {
251         if (component != null && (component.getId().equals(suppression.getComponentId()) || suppression.getComponentId() == null)) {
252           return;
253         }
254         if (component == null && suppression.getComponentId() != null) {
255           myInspectionSuppressions.remove(i);
256         }
257       }
258     }
259     myInspectionSuppressions.add(new LwInspectionSuppression(inspectionId, component == null ? null : component.getId()));
260   }
261
262   public boolean isInspectionSuppressed(final String inspectionId, final String componentId) {
263     for(LwInspectionSuppression suppression: myInspectionSuppressions) {
264       if ((suppression.getComponentId() == null || suppression.getComponentId().equals(componentId)) &&
265           suppression.getInspectionId().equals(inspectionId)) {
266         return true;
267       }
268     }
269     return false;
270   }
271
272   public LwInspectionSuppression[] getInspectionSuppressions() {
273     return myInspectionSuppressions.toArray(new LwInspectionSuppression[myInspectionSuppressions.size()]);
274   }
275
276   public void setInspectionSuppressions(final LwInspectionSuppression[] inspectionSuppressions) {
277     myInspectionSuppressions.clear();
278     Collections.addAll(myInspectionSuppressions, inspectionSuppressions);
279   }
280
281   public void removeInspectionSuppression(final LwInspectionSuppression suppression) {
282     for(LwInspectionSuppression existing: myInspectionSuppressions) {
283       if (existing.getInspectionId().equals(suppression.getInspectionId()) &&
284         Comparing.equal(existing.getComponentId(), suppression.getComponentId())) {
285         myInspectionSuppressions.remove(existing);
286         break;
287       }
288     }
289   }
290 }