replaced <code></code> with more concise {@code}
[idea/community.git] / plugins / ui-designer / src / com / intellij / uiDesigner / propertyInspector / Property.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.propertyInspector;
17
18 import com.intellij.uiDesigner.radComponents.RadComponent;
19 import com.intellij.uiDesigner.lw.IProperty;
20 import com.intellij.uiDesigner.lw.IComponent;import com.intellij.openapi.diagnostic.Logger;
21 import org.jetbrains.annotations.NonNls;
22 import org.jetbrains.annotations.NotNull;
23 import org.jetbrains.annotations.Nullable;
24
25 import java.util.List;
26
27 /**
28  * @author Anton Katilin
29  * @author Vladimir Kondratyev
30  */
31 public abstract class Property<T extends RadComponent, V> implements IProperty {
32   public static final Property[] EMPTY_ARRAY=new Property[]{};
33
34   private static final Logger LOG = Logger.getInstance("#com.intellij.uiDesigner.propertyInspector.Property");
35
36   /**
37    * Parent property
38    */
39   private final Property myParent;
40   /**
41    * Propertie's name
42    */
43   private final String myName;
44
45   public Property(final Property parent, @NotNull @NonNls final String name) {
46     myParent = parent;
47     myName = name;
48   }
49
50   /**
51    * @return property's name.
52    */
53   @NotNull
54   public final String getName() {
55     return myName;
56   }
57
58   public Object getPropertyValue(final IComponent component) {
59     //noinspection unchecked
60     return getValue((T) component);
61   }
62
63   /**
64    * This method can extract value of the property from the
65    * instance of the RadComponent. This value is passed to the
66    * PropertyRenderer and PropertyEditor.
67    */
68   public abstract V getValue(T component);
69
70   /**
71    * Do not invoke this method outside Property class, bacuse
72    * {@code setValue(Component,Object)} does some additional work.
73    * This method exists only for convenience.
74    *
75    * @see #setValue(RadComponent,Object)
76    */
77   protected abstract void setValueImpl(T component, V value) throws Exception;
78
79
80   /**
81    * Sets the {@code value} of the property. This method is invoked
82    * after editing is complete.
83    *
84    * @param component component which property should be set
85    * @param value new propertie's value
86    *
87    * @exception Exception if passed {@code value} cannot
88    * be applied to the {@code component}. Note, the exception's
89    * message will be shown to the user.
90    */
91   public final void setValue(final T component, final V value) throws Exception{
92     setValueImpl(component, value);
93     markTopmostModified(component, true);
94     component.getDelegee().invalidate();
95   }
96
97   public final void setValueEx(T component, V value) {
98     try {
99       setValue(component, value);
100     }
101     catch(Exception ex) {
102       LOG.error(ex);
103     }
104   }
105
106   protected void markTopmostModified(final T component, final boolean modified) {
107     Property topmostParent = this;
108     while (topmostParent.getParent() != null) {
109       topmostParent = topmostParent.getParent();
110     }
111     if (modified) {
112       component.markPropertyAsModified(topmostParent);
113     }
114     else {
115       component.removeModifiedProperty(topmostParent);
116     }
117   }
118
119   /**
120    * @return property which is the parent for this property.
121    * The method can return {@code null} if the property
122    * doesn't have parent.
123    */
124   @Nullable
125   public final Property getParent() {
126     return myParent;
127   }
128
129   /**
130    * @return child properties.
131    * @param component
132    */
133   @NotNull public Property[] getChildren(final RadComponent component) {
134     return EMPTY_ARRAY;
135   }
136
137   /**
138    * @return property's renderer.
139    */
140   @NotNull
141   public abstract PropertyRenderer<V> getRenderer();
142
143   /**
144    * @return property's editor. The method allows to return {@code null}.
145    * In this case property is not editable.
146    */
147   @Nullable
148   public abstract PropertyEditor<V> getEditor();
149
150   public boolean appliesTo(T component) {
151     return true;
152   }
153
154   public boolean isModified(final T component) {
155     return false;
156   }
157
158   public void resetValue(T component) throws Exception {
159   }
160
161   public boolean appliesToSelection(List<RadComponent> selection) {
162     return true;
163   }
164
165   public boolean needRefreshPropertyList() {
166     return false;
167   }
168 }