Refactor filters parameters

- introduce FilterRepresentations
- change filters lifecycle

Change-Id: I9416fca47a334d532a347cd5577795738c870933

4 files changed, 323 insertions, 66 deletions

diff --git a/src/com/android/gallery3d/filtershow/filters/FilterBasicRepresentation.java b/src/com/android/gallery3d/filtershow/filters/FilterBasicRepresentation.java
new file mode 100644
index 000000000..9e9c57ac5
--- /dev/null
+++ b/src/com/android/gallery3d/filtershow/filters/FilterBasicRepresentation.java
@@ -0,0 +1,124 @@
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ *
+ * 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.android.gallery3d.filtershow.filters;
+
+import com.android.gallery3d.app.Log;
+
+public class FilterBasicRepresentation extends FilterRepresentation {
+    private static final String LOGTAG = "FilterBasicRepresentation";
+    private int mMinimum;
+    private int mValue;
+    private int mMaximum;
+    private int mDefaultValue;
+    private int mPreviewValue;
+
+    public FilterBasicRepresentation(String name, int minimum, int value, int maximum) {
+        super(name);
+        mMinimum = minimum;
+        mMaximum = maximum;
+        setValue(value);
+    }
+
+    public String toString() {
+        return getName() + " : " + mMinimum + " < " + mValue + " < " + mMaximum;
+    }
+
+    @Override
+    public FilterRepresentation clone() throws CloneNotSupportedException {
+        FilterBasicRepresentation representation = (FilterBasicRepresentation) super.clone();
+        representation.setMinimum(getMinimum());
+        representation.setMaximum(getMaximum());
+        representation.setValue(getValue());
+        Log.v(LOGTAG, "cloning from <" + this + "> to <" + representation + ">");
+        return representation;
+    }
+
+    public void useParametersFrom(FilterRepresentation a) {
+        if (a instanceof FilterBasicRepresentation) {
+            FilterBasicRepresentation representation = (FilterBasicRepresentation) a;
+            setMinimum(representation.getMinimum());
+            setMaximum(representation.getMaximum());
+            setValue(representation.getValue());
+            setDefaultValue(representation.getDefaultValue());
+            setPreviewValue(representation.getPreviewValue());
+        }
+    }
+
+    @Override
+    public boolean equals(FilterRepresentation representation) {
+        if (super.equals(representation)) {
+            return false;
+        }
+        if (representation instanceof FilterBasicRepresentation) {
+            FilterBasicRepresentation basic = (FilterBasicRepresentation) representation;
+            if (basic.mMinimum == mMinimum
+                    && basic.mMaximum == mMaximum
+                    && basic.mValue == mValue
+                    && basic.mDefaultValue == mDefaultValue
+                    && basic.mPreviewValue == mPreviewValue) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public int getMinimum() {
+        return mMinimum;
+    }
+
+    public void setMinimum(int minimum) {
+        mMinimum = minimum;
+    }
+
+    public int getValue() {
+        return mValue;
+    }
+
+    public void setValue(int value) {
+        mValue = value;
+        if (mValue < mMinimum) {
+            mValue = mMinimum;
+        }
+        if (mValue > mMaximum) {
+            mValue = mMaximum;
+        }
+    }
+
+    public int getMaximum() {
+        return mMaximum;
+    }
+
+    public void setMaximum(int maximum) {
+        mMaximum = maximum;
+    }
+
+    public void setDefaultValue(int defaultValue) {
+        mDefaultValue = defaultValue;
+    }
+
+    public int getDefaultValue() {
+        return mDefaultValue;
+    }
+
+    public int getPreviewValue() {
+        return mPreviewValue;
+    }
+
+    public void setPreviewValue(int previewValue) {
+        mPreviewValue = previewValue;
+    }
+}
diff --git a/src/com/android/gallery3d/filtershow/filters/FilterDirectRepresentation.java b/src/com/android/gallery3d/filtershow/filters/FilterDirectRepresentation.java
new file mode 100644
index 000000000..3807ee1f5
--- /dev/null
+++ b/src/com/android/gallery3d/filtershow/filters/FilterDirectRepresentation.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ *
+ * 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.android.gallery3d.filtershow.filters;
+
+public class FilterDirectRepresentation extends FilterRepresentation {
+
+    public FilterDirectRepresentation(String name) {
+        super(name);
+    }
+
+    public boolean isNil() {
+        return true;
+    }
+
+}
diff --git a/src/com/android/gallery3d/filtershow/filters/FilterRepresentation.java b/src/com/android/gallery3d/filtershow/filters/FilterRepresentation.java
new file mode 100644
index 000000000..afa6ad18d
--- /dev/null
+++ b/src/com/android/gallery3d/filtershow/filters/FilterRepresentation.java
@@ -0,0 +1,110 @@
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ *
+ * 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.android.gallery3d.filtershow.filters;
+
+import com.android.gallery3d.app.Log;
+import com.android.gallery3d.filtershow.presets.ImagePreset;
+
+import java.util.HashMap;
+
+public class FilterRepresentation implements Cloneable {
+    private static final String LOGTAG = "FilterRepresentation";
+    private String mName;
+    private int mPriority;
+    private ImagePreset mPreset;
+    private boolean mShowParameterValue;
+    private Class mFilterClass;
+
+    public static String DEFAULT = "Default";
+
+    public FilterRepresentation(String name) {
+        mName = name;
+    }
+
+    @Override
+    public FilterRepresentation clone() throws CloneNotSupportedException {
+        FilterRepresentation representation = (FilterRepresentation) super.clone();
+        representation.setName(getName());
+        representation.setPriority(getPriority());
+        Log.v(LOGTAG, "cloning from <" + this + "> to <" + representation + ">");
+        return representation;
+    }
+
+    public boolean equals(FilterRepresentation representation) {
+        if (representation.mFilterClass == representation.mFilterClass
+                && representation.mName.equalsIgnoreCase(mName)
+                && representation.mPriority == mPriority
+                && representation.mShowParameterValue == mShowParameterValue) {
+            return true;
+        }
+        return false;
+    }
+
+    public String toString() {
+        return mName;
+    }
+
+    public void setName(String name) {
+        mName = name;
+    }
+
+    public String getName() {
+        return mName;
+    }
+
+    public void setPriority(int priority) {
+        mPriority = priority;
+    }
+
+    public int getPriority() {
+        return mPriority;
+    }
+
+    public void setImagePreset(ImagePreset preset) {
+        mPreset = preset;
+    }
+
+    public boolean isNil() {
+        return false;
+    }
+
+    public void useParametersFrom(FilterRepresentation a) {
+    }
+
+    public void setShowParameterValue(boolean showParameterValue) {
+        mShowParameterValue = showParameterValue;
+    }
+
+    public boolean showParameterValue() {
+        return mShowParameterValue;
+    }
+
+    public Class getFilterClass() {
+        return mFilterClass;
+    }
+
+    public void setFilterClass(Class filterClass) {
+        mFilterClass = filterClass;
+    }
+
+    public boolean same(FilterRepresentation b) {
+        if (b == null) {
+            return false;
+        }
+        return getFilterClass() == b.getFilterClass();
+    }
+}
diff --git a/src/com/android/gallery3d/filtershow/presets/ImagePreset.java b/src/com/android/gallery3d/filtershow/presets/ImagePreset.java
index d6a69af3e..6e9ab9fc9 100644
--- a/src/com/android/gallery3d/filtershow/presets/ImagePreset.java
+++ b/src/com/android/gallery3d/filtershow/presets/ImagePreset.java
@@ -21,8 +21,10 @@ import android.util.Log;
 
 import com.android.gallery3d.filtershow.ImageStateAdapter;
 import com.android.gallery3d.filtershow.cache.ImageLoader;
+import com.android.gallery3d.filtershow.filters.FilterRepresentation;
+import com.android.gallery3d.filtershow.filters.FiltersManager;
 import com.android.gallery3d.filtershow.filters.ImageFilter;
-import com.android.gallery3d.filtershow.filters.ImageFilterRS;
+import com.android.gallery3d.filtershow.filters.ImageFilterCurves;
 import com.android.gallery3d.filtershow.imageshow.GeometryMetadata;
 import com.android.gallery3d.filtershow.imageshow.ImageShow;
 
@@ -33,12 +35,13 @@ public class ImagePreset {
     private static final String LOGTAG = "ImagePreset";
 
     private ImageShow mEndPoint = null;
-    private ImageFilter mImageBorder = null;
+    private FilterRepresentation mImageBorder = null;
     private float mScaleFactor = 1.0f;
     private boolean mIsHighQuality = false;
     private ImageLoader mImageLoader = null;
 
-    protected Vector<ImageFilter> mFilters = new Vector<ImageFilter>();
+    private Vector<FilterRepresentation> mFilters = new Vector<FilterRepresentation>();
+
     protected String mName = "Original";
     private String mHistoryName = "Original";
     protected boolean mIsFxPreset = false;
@@ -74,9 +77,9 @@ public class ImagePreset {
                 mImageBorder = source.mImageBorder.clone();
             }
             for (int i = 0; i < source.mFilters.size(); i++) {
-                ImageFilter filter = source.mFilters.elementAt(i).clone();
-                filter.setImagePreset(this);
-                add(filter);
+                FilterRepresentation representation = source.mFilters.elementAt(i).clone();
+                representation.setImagePreset(this);
+                addFilter(representation);
             }
         } catch (java.lang.CloneNotSupportedException e) {
             Log.v(LOGTAG, "Exception trying to clone: " + e);
@@ -113,7 +116,7 @@ public class ImagePreset {
             return true;
         }
         for (int i = 0; i < mFilters.size(); i++) {
-            ImageFilter filter = mFilters.elementAt(i);
+            FilterRepresentation filter = mFilters.elementAt(i);
             if (!filter.isNil()) {
                 return true;
             }
@@ -128,13 +131,13 @@ public class ImagePreset {
         if (mGeoData.hasModifications()) {
             return false;
         }
-        for (ImageFilter filter : mFilters) {
-            if (filter.getFilterType() == ImageFilter.TYPE_VIGNETTE
-                    && !filter.isNil()) {
+        for (FilterRepresentation representation : mFilters) {
+            if (representation.getPriority() == ImageFilter.TYPE_VIGNETTE
+                && !representation.isNil()) {
                 return false;
             }
-            if (filter.getFilterType() == ImageFilter.TYPE_TINYPLANET
-                    && !filter.isNil()) {
+            if (representation.getPriority() == ImageFilter.TYPE_TINYPLANET
+                && !representation.isNil()) {
                 return false;
             }
         }
@@ -145,7 +148,7 @@ public class ImagePreset {
         mGeoData.set(m);
     }
 
-    private void setBorder(ImageFilter filter) {
+    private void setBorder(FilterRepresentation filter) {
         mImageBorder = filter;
     }
 
@@ -180,8 +183,8 @@ public class ImagePreset {
         }
         if (mDoApplyFilters && preset.mDoApplyFilters) {
             for (int i = 0; i < preset.mFilters.size(); i++) {
-                ImageFilter a = preset.mFilters.elementAt(i);
-                ImageFilter b = mFilters.elementAt(i);
+                FilterRepresentation a = preset.mFilters.elementAt(i);
+                FilterRepresentation b = mFilters.elementAt(i);
                 if (!a.equals(b)) {
                     return false;
                 }
@@ -190,14 +193,6 @@ public class ImagePreset {
         return true;
     }
 
-    public void usePreset(ImagePreset preset) {
-        for (int i = 0; i < preset.mFilters.size(); i++) {
-            ImageFilter a = preset.mFilters.elementAt(i);
-            ImageFilter b = mFilters.elementAt(i);
-            b.useFilter(a);
-        }
-    }
-
     public boolean same(ImagePreset preset) {
         if (preset == null) {
             return false;
@@ -223,7 +218,7 @@ public class ImagePreset {
             return false;
         }
 
-        if (mImageBorder != null && !mImageBorder.same(preset.mImageBorder)) {
+        if (mImageBorder != null && !mImageBorder.equals(preset.mImageBorder)) {
             return false;
         }
 
@@ -235,18 +230,15 @@ public class ImagePreset {
 
         if (mDoApplyFilters && preset.mDoApplyFilters) {
             for (int i = 0; i < preset.mFilters.size(); i++) {
-                ImageFilter a = preset.mFilters.elementAt(i);
-                ImageFilter b = mFilters.elementAt(i);
+                FilterRepresentation a = preset.mFilters.elementAt(i);
+                FilterRepresentation b = mFilters.elementAt(i);
                 if (!a.same(b)) {
                     return false;
                 }
             }
         }
-        return true;
-    }
 
-    public int nbFilters() {
-        return mFilters.size();
+        return true;
     }
 
     public int similarUpTo(ImagePreset preset) {
@@ -255,13 +247,13 @@ public class ImagePreset {
         }
 
         for (int i = 0; i < preset.mFilters.size(); i++) {
-            ImageFilter a = preset.mFilters.elementAt(i);
+            FilterRepresentation a = preset.mFilters.elementAt(i);
             if (i < mFilters.size()) {
-                ImageFilter b = mFilters.elementAt(i);
+                FilterRepresentation b = mFilters.elementAt(i);
                 if (!a.same(b)) {
                     return i;
                 }
-                if (a.getParameter() != b.getParameter()) {
+                if (!a.equals(b)) {
                     return i;
                 }
             } else {
@@ -279,15 +271,25 @@ public class ImagePreset {
         return mHistoryName;
     }
 
-    public void add(ImageFilter filter) {
+    public void showFilters() {
+        Log.v(LOGTAG, "\\\\\\ showFilters -- " + mFilters.size() + " filters");
+        int n = 0;
+        for (FilterRepresentation representation : mFilters) {
+            Log.v(LOGTAG, " filter " + n + " : " + representation.toString());
+            n++;
+        }
+        Log.v(LOGTAG, "/// showFilters -- " + mFilters.size() + " filters");
+    }
 
-        if (filter.getFilterType() == ImageFilter.TYPE_BORDER) {
-            setHistoryName(filter.getName());
-            setBorder(filter);
-        } else if (filter.getFilterType() == ImageFilter.TYPE_FX) {
+    public void addFilter(FilterRepresentation representation) {
+        Log.v(LOGTAG, "*** Add Filter *** " + representation);
+        if (representation.getPriority() == ImageFilter.TYPE_BORDER) {
+            setHistoryName(representation.getName());
+            setBorder(representation);
+        } else if (representation.getPriority() == ImageFilter.TYPE_FX) {
             boolean found = false;
             for (int i = 0; i < mFilters.size(); i++) {
-                byte type = mFilters.get(i).getFilterType();
+                int type = mFilters.elementAt(i).getPriority();
                 if (found) {
                     if (type != ImageFilter.TYPE_VIGNETTE) {
                         mFilters.remove(i);
@@ -296,38 +298,30 @@ public class ImagePreset {
                 }
                 if (type == ImageFilter.TYPE_FX) {
                     mFilters.remove(i);
-                    mFilters.add(i, filter);
-                    setHistoryName(filter.getName());
+                    mFilters.add(i, representation);
+                    setHistoryName(representation.getName());
                     found = true;
                 }
             }
             if (!found) {
-                mFilters.add(filter);
-                setHistoryName(filter.getName());
+                mFilters.add(representation);
+                setHistoryName(representation.getName());
             }
         } else {
-            mFilters.add(filter);
-            setHistoryName(filter.getName());
+            mFilters.add(representation);
+            setHistoryName(representation.getName());
         }
-        filter.setImagePreset(this);
+        representation.setImagePreset(this);
     }
 
-    public void remove(String filterName) {
-        ImageFilter filter = getFilter(filterName);
-        if (filter != null) {
-            mFilters.remove(filter);
-        }
-    }
-
-    public int getCount() {
-        return mFilters.size();
+    public void add(ImageFilter filter) {
     }
 
-    public ImageFilter getFilter(String name) {
+    public FilterRepresentation getRepresentation(FilterRepresentation filterRepresentation) {
         for (int i = 0; i < mFilters.size(); i++) {
-            ImageFilter filter = mFilters.elementAt(i);
-            if (filter.getName().equalsIgnoreCase(name)) {
-                return filter;
+            FilterRepresentation representation = mFilters.elementAt(i);
+            if (representation.getFilterClass() == filterRepresentation.getFilterClass()) {
+                return representation;
             }
         }
         return null;
@@ -337,10 +331,6 @@ public class ImagePreset {
         // do nothing here
     }
 
-    public void setEndpoint(ImageShow image) {
-        mEndPoint = image;
-    }
-
     public Bitmap apply(Bitmap original) {
         Bitmap bitmap = original;
         bitmap = applyFilters(bitmap, -1, -1);
@@ -355,7 +345,8 @@ public class ImagePreset {
 
     public Bitmap applyBorder(Bitmap bitmap) {
         if (mImageBorder != null && mDoApplyGeometry) {
-            bitmap = mImageBorder.apply(bitmap, mScaleFactor, mIsHighQuality);
+            ImageFilter filter = FiltersManager.getManager().getFilterForRepresentation(mImageBorder);
+            bitmap = filter.apply(bitmap, mScaleFactor, mIsHighQuality);
         }
         return bitmap;
     }
@@ -370,7 +361,9 @@ public class ImagePreset {
                 to = mFilters.size();
             }
             for (int i = from; i < to; i++) {
-                ImageFilter filter = mFilters.elementAt(i);
+                FilterRepresentation representation = mFilters.elementAt(i);
+                ImageFilter filter = FiltersManager.getManager().getFilterForRepresentation(representation);
+                filter.useRepresentation(representation);
                 bitmap = filter.apply(bitmap, mScaleFactor, mIsHighQuality);
             }
         }
@@ -383,7 +376,8 @@ public class ImagePreset {
             return;
         }
         imageStateAdapter.clear();
-        imageStateAdapter.addAll(mFilters);
+        // TODO: re-enable the state panel
+        // imageStateAdapter.addAll(mFilters);
         imageStateAdapter.notifyDataSetChanged();
     }