diff --git a/sdk/jme3-core/src/com/jme3/gde/core/filters/AbstractFilterNode.java b/sdk/jme3-core/src/com/jme3/gde/core/filters/AbstractFilterNode.java index 7b8be6451..96a1c7457 100644 --- a/sdk/jme3-core/src/com/jme3/gde/core/filters/AbstractFilterNode.java +++ b/sdk/jme3-core/src/com/jme3/gde/core/filters/AbstractFilterNode.java @@ -35,6 +35,7 @@ import com.jme3.gde.core.sceneexplorer.nodes.properties.SceneExplorerProperty; import com.jme3.gde.core.sceneexplorer.nodes.properties.ScenePropertyChangeListener; import com.jme3.post.Filter; import java.io.IOException; +import java.lang.reflect.Field; import javax.swing.Action; import org.openide.actions.DeleteAction; import org.openide.loaders.DataObject; @@ -112,13 +113,12 @@ public abstract class AbstractFilterNode extends AbstractNode implements FilterN Sheet sheet = super.createSheet(); Sheet.Set set = Sheet.createPropertiesSet(); set.setDisplayName("Filter"); - set.setName(Node.class.getName()); + set.setName("Filter"); Filter obj = filter; if (obj == null) { return sheet; } - set.put(makeProperty(obj, String.class, "getName", "setName", "Name")); - set.put(makeProperty(obj, boolean.class, "isEnabled", "setEnabled", "Enabled")); + createFields(Filter.class, set, obj); sheet.put(set); return sheet; @@ -161,6 +161,20 @@ public abstract class AbstractFilterNode extends AbstractNode implements FilterN } return prop; } + + protected void createFields(Class c, Sheet.Set set, Object obj) throws SecurityException { + for (Field field : c.getDeclaredFields()) { + Filter.FilterParameter param = field.getAnnotation(Filter.FilterParameter.class); + if (param != null) { + String name = field.getName().substring(0, 1).toUpperCase() + field.getName().substring(1); + String getter = "get"; + if (field.getType().equals(boolean.class)) { + getter = "is"; + } + set.put(makeProperty(obj, field.getType(), getter + name, "set" + name, param.name())); + } + } + } public void propertyChange(final String name, final Object before, final Object after) { fireSave(true); diff --git a/sdk/jme3-core/src/com/jme3/gde/core/filters/FilterPostProcessorNode.java b/sdk/jme3-core/src/com/jme3/gde/core/filters/FilterPostProcessorNode.java index 16b597193..7e1c979e8 100644 --- a/sdk/jme3-core/src/com/jme3/gde/core/filters/FilterPostProcessorNode.java +++ b/sdk/jme3-core/src/com/jme3/gde/core/filters/FilterPostProcessorNode.java @@ -42,18 +42,12 @@ import java.util.List; import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import javax.swing.Action; -import org.openide.actions.CopyAction; -import org.openide.actions.CutAction; -import org.openide.actions.DeleteAction; -import org.openide.actions.PasteAction; -import org.openide.actions.RenameAction; import org.openide.nodes.AbstractNode; import org.openide.nodes.Children; import org.openide.nodes.Node; import org.openide.util.Exceptions; import org.openide.util.ImageUtilities; import org.openide.util.Lookup; -import org.openide.util.actions.SystemAction; /** * diff --git a/sdk/jme3-core/src/com/jme3/gde/core/filters/impl/JmeWaterFilter.java b/sdk/jme3-core/src/com/jme3/gde/core/filters/impl/JmeWaterFilter.java new file mode 100644 index 000000000..b1eebcead --- /dev/null +++ b/sdk/jme3-core/src/com/jme3/gde/core/filters/impl/JmeWaterFilter.java @@ -0,0 +1,95 @@ +/* + * Copyright (c) 2009-2010 jMonkeyEngine + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of 'jMonkeyEngine' nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package com.jme3.gde.core.filters.impl; + +import com.jme3.gde.core.filters.AbstractFilterNode; +import com.jme3.gde.core.filters.FilterNode; +import com.jme3.post.Filter; +import com.jme3.water.WaterFilter; +import org.openide.loaders.DataObject; +import org.openide.nodes.Node; +import org.openide.nodes.Sheet; + +/** + * + * @author Rémy Bouquet + */ +@org.openide.util.lookup.ServiceProvider(service = FilterNode.class) +public class JmeWaterFilter extends AbstractFilterNode { + + public JmeWaterFilter() { + } + + public JmeWaterFilter(WaterFilter filter, DataObject object, boolean readOnly) { + super(filter); + this.dataObject = object; + this.readOnly = readOnly; + } + + @Override + protected Sheet createSheet() { + Sheet sheet = super.createSheet(); + + Sheet.Set set = Sheet.createPropertiesSet(); + set.setDisplayName("Water"); + set.setName("Water"); + WaterFilter obj = (WaterFilter) filter; + + if (obj == null) { + return sheet; + } + + createFields(WaterFilter.class, set, obj); + + sheet.put(set); + return sheet; + + } + +// private boolean hasAnnotation(Field f, Class annotation){ +// for (int i = 0; i < f.getDeclaredAnnotations().length; i++) { +// if(f.getAnnotations()[i].equals(annotation)){ +// return true; +// } +// } +// return false; +// } + @Override + public Class getExplorerObjectClass() { + return WaterFilter.class; + } + + @Override + public Node[] createNodes(Object key, DataObject dataObject, boolean readOnly) { + return new Node[]{new JmeWaterFilter((WaterFilter) key, dataObject, readOnly)}; + } +} diff --git a/sdk/jme3-core/src/com/jme3/gde/core/filters/impl/NewWaterFilterAction.java b/sdk/jme3-core/src/com/jme3/gde/core/filters/impl/NewWaterFilterAction.java new file mode 100644 index 000000000..8e9f9854a --- /dev/null +++ b/sdk/jme3-core/src/com/jme3/gde/core/filters/impl/NewWaterFilterAction.java @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2009-2010 jMonkeyEngine + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of 'jMonkeyEngine' nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package com.jme3.gde.core.filters.impl; + +import com.jme3.gde.core.filters.actions.AbstractNewFilterAction; +import com.jme3.gde.core.filters.actions.NewFilterAction; +import com.jme3.post.Filter; +import com.jme3.water.WaterFilter; + +/** + * + * @author Rémy Bouquet + */ +@org.openide.util.lookup.ServiceProvider(service = NewFilterAction.class) +public class NewWaterFilterAction extends AbstractNewFilterAction { + + public NewWaterFilterAction() { + name = "Water"; + } + + @Override + protected Filter doCreateFilter() { + return new WaterFilter(); + } +} diff --git a/sdk/jme3-core/src/com/jme3/gde/core/sceneexplorer/nodes/properties/SceneExplorerProperty.java b/sdk/jme3-core/src/com/jme3/gde/core/sceneexplorer/nodes/properties/SceneExplorerProperty.java index fafa3e1e6..17167f439 100644 --- a/sdk/jme3-core/src/com/jme3/gde/core/sceneexplorer/nodes/properties/SceneExplorerProperty.java +++ b/sdk/jme3-core/src/com/jme3/gde/core/sceneexplorer/nodes/properties/SceneExplorerProperty.java @@ -38,6 +38,7 @@ import com.jme3.gde.core.undoredo.SceneUndoRedoManager; import com.jme3.math.ColorRGBA; import com.jme3.math.Matrix3f; import com.jme3.math.Quaternion; +import com.jme3.math.Vector2f; import com.jme3.math.Vector3f; import java.lang.reflect.InvocationTargetException; import java.util.Iterator; @@ -76,7 +77,10 @@ public class SceneExplorerProperty extends PropertySupport.Reflection { setPropertyEditorClass(ColorRGBAPropertyEditor.class); } else if (valueType == EmitterShape.class) { setPropertyEditorClass(EmitterShapePropertyEditor.class); + } else if (valueType == Vector2f.class) { + setPropertyEditorClass(Vector2fPropertyEditor.class); } + for (SceneExplorerPropertyEditor di : Lookup.getDefault().lookupAll(SceneExplorerPropertyEditor.class)) { di.setEditor(valueType, this); } @@ -160,8 +164,8 @@ public class SceneExplorerProperty extends PropertySupport.Reflection { } protected void addUndo(final Object before, final Object after) { - SceneUndoRedoManager undoRedo=Lookup.getDefault().lookup(SceneUndoRedoManager.class); - if(undoRedo==null){ + SceneUndoRedoManager undoRedo = Lookup.getDefault().lookup(SceneUndoRedoManager.class); + if (undoRedo == null) { Logger.getLogger(SceneExplorerProperty.class.getName()).log(Level.WARNING, "Cannot access SceneUndoRedoManager"); return; } diff --git a/sdk/jme3-core/src/com/jme3/gde/core/sceneexplorer/nodes/properties/Vector2fPropertyEditor.java b/sdk/jme3-core/src/com/jme3/gde/core/sceneexplorer/nodes/properties/Vector2fPropertyEditor.java new file mode 100644 index 000000000..af8642226 --- /dev/null +++ b/sdk/jme3-core/src/com/jme3/gde/core/sceneexplorer/nodes/properties/Vector2fPropertyEditor.java @@ -0,0 +1,124 @@ +/* + * Copyright (c) 2009-2010 jMonkeyEngine + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of 'jMonkeyEngine' nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package com.jme3.gde.core.sceneexplorer.nodes.properties; + +import com.jme3.math.Vector2f; +import java.awt.Component; +import java.awt.Graphics; +import java.awt.Rectangle; +import java.beans.PropertyChangeEvent; +import java.beans.PropertyChangeListener; +import java.beans.PropertyEditor; +import java.util.Iterator; +import java.util.LinkedList; + +/** + * + * @author normenhansen + */ +public class Vector2fPropertyEditor implements PropertyEditor { + + private LinkedList listeners = new LinkedList(); + private Vector2f vector = new Vector2f(); + + public void setValue(Object value) { + if (value instanceof Vector2f) { + vector.set((Vector2f) value); + } + } + + public Object getValue() { + return vector; + } + + public boolean isPaintable() { + return false; + } + + public void paintValue(Graphics gfx, Rectangle box) { + throw new UnsupportedOperationException("Not supported yet."); + } + + public String getJavaInitializationString() { + return null; + } + + public String getAsText() { + return "[" + vector.x + ", " + vector.y + "]"; + } + + public void setAsText(String text) throws IllegalArgumentException { + text = text.replace('[', ' '); + text = text.replace(']', ' '); + String[] values = text.split(","); + if (values.length != 2) { + throw (new IllegalArgumentException("String not correct")); + } + float[] floats = new float[2]; + for (int i = 0; i < values.length; i++) { + String string = values[i]; + floats[i] = Float.parseFloat(string); + } + Vector2f old = new Vector2f(); + old.set(vector); + vector.set(floats[0], floats[1]); + notifyListeners(old, vector); + } + + public String[] getTags() { + return null; + } + + public Component getCustomEditor() { + throw new UnsupportedOperationException("Not supported yet."); + } + + public boolean supportsCustomEditor() { + return false; + } + + public void addPropertyChangeListener(PropertyChangeListener listener) { + listeners.add(listener); + } + + public void removePropertyChangeListener(PropertyChangeListener listener) { + listeners.remove(listener); + } + + private void notifyListeners(Vector2f before, Vector2f after) { + for (Iterator it = listeners.iterator(); it.hasNext();) { + PropertyChangeListener propertyChangeListener = it.next(); + //TODO: check what the "programmatic name" is supposed to be here.. for now its Vector2f + propertyChangeListener.propertyChange(new PropertyChangeEvent(this, null, before, after)); + } + } +}