-->
<shape xmlns:android="http://schemas.android.com/apk/res/android"
- android:shape="oval" >
+ android:shape="rectangle" >
<size android:width="20dp" android:height="20dp"/>
<corners
android:radius="10dp" />
<solid android:color="@color/red"/>
+ <stroke android:width="2dp"
+ android:color="#ff000000"/>
</shape>
limitations under the License.
-->
-<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
- xmlns:tools="http://schemas.android.com/tools"
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+ android:orientation="vertical"
android:id="@+id/RelativeLayout1"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:background="@color/default_background"
- tools:context=".ColorPickerActivity" >
+ >
- <com.android.gallery3d.filtershow.colorpicker.ColorRectView
+ <com.android.gallery3d.filtershow.colorpicker.ColorOpacityView
+ android:id="@+id/colorOpacityView"
+ android:layout_width="match_parent"
+ android:layout_height="0dp"
+ android:layout_weight="1"/>
+
+ <com.android.gallery3d.filtershow.colorpicker.ColorSVRectView
android:id="@+id/colorRectView"
- android:layout_width="fill_parent"
- android:layout_height="fill_parent"
- android:layout_marginLeft="10dp"
- android:layout_marginTop="10dp"
- android:layout_marginBottom="10dp"
- android:layout_marginRight="1dp"
- android:layout_above="@+id/colorOpacityView"
- android:layout_toLeftOf="@+id/colorValueView" />
-
- <com.android.gallery3d.filtershow.colorpicker.ColorValueView
- android:id="@+id/colorValueView"
- android:layout_width="90dp"
- android:layout_height="fill_parent"
- android:layout_alignParentRight = "true"
- android:layout_above="@+id/colorOpacityView" />
+ android:layout_width="match_parent"
+ android:layout_height="0dp"
+ android:layout_weight="4"
+ android:layout_marginRight="1dp" />
- <com.android.gallery3d.filtershow.colorpicker.ColorOpacityView
- android:id="@+id/colorOpacityView"
- android:layout_width="match_parent"
- android:layout_height="90dp"
- android:layout_above="@+id/btnSelect" />
+ <com.android.gallery3d.filtershow.colorpicker.ColorHueView
+ android:id="@+id/ColorHueView"
+ android:layout_width="match_parent"
+ android:layout_height="0dp"
+ android:layout_weight="1" />
<Button
android:id="@+id/btnSelect"
android:layout_width="match_parent"
android:layout_height="wrap_content"
- android:text="@string/color_pick_select"
- android:layout_alignParentBottom = "true"
- />
+ android:text="@string/color_pick_select" />
-</RelativeLayout>
\ No newline at end of file
+</LinearLayout>
\ No newline at end of file
--- /dev/null
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ 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.
+-->
+
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+ xmlns:app="http://schemas.android.com/apk/res/com.example.imagefilterharness"
+ android:layout_width="match_parent"
+ android:layout_height="wrap_content"
+ android:orientation="horizontal" >
+ <HorizontalScrollView
+ android:id="@+id/scrollList"
+ android:layout_width="0dp"
+ android:layout_weight="5"
+ android:layout_height="match_parent"
+ android:scrollbars="none" >
+
+ <LinearLayout
+ android:id="@+id/listStyles"
+ android:layout_width="wrap_content"
+ android:layout_height="match_parent"
+ android:orientation="horizontal" >
+
+ <Button
+ android:id="@+id/draw_color_button01"
+ android:layout_width="0dip"
+ android:layout_height="wrap_content"
+ android:layout_weight="1"
+ android:background="@drawable/filtershow_color_picker_circle"
+ android:layout_margin="2dp" />
+ <Button
+ android:id="@+id/draw_color_button02"
+ android:layout_width="0dip"
+ android:layout_height="wrap_content"
+ android:layout_weight="1"
+ android:background="@drawable/filtershow_color_picker_circle"
+ android:layout_margin="2dp" />
+ <Button
+ android:id="@+id/draw_color_button03"
+ android:layout_width="0dip"
+ android:layout_height="wrap_content"
+ android:layout_weight="1"
+ android:background="@drawable/filtershow_color_picker_circle"
+ android:layout_margin="2dp" />
+ <Button
+ android:id="@+id/draw_color_button04"
+ android:layout_width="0dip"
+ android:layout_height="wrap_content"
+ android:layout_weight="1"
+ android:background="@drawable/filtershow_color_picker_circle"
+ android:layout_margin="2dp" />
+ <Button
+ android:id="@+id/draw_color_button05"
+ android:layout_width="0dip"
+ android:layout_height="wrap_content"
+ android:layout_weight="1"
+ android:background="@drawable/filtershow_color_picker_circle"
+ android:layout_margin="2dp" />
+
+ </LinearLayout>
+ </HorizontalScrollView>
+ <Button
+ android:id="@+id/draw_color_popupbutton"
+ android:layout_width="0dp"
+ android:layout_height="match_parent"
+ android:layout_weight="1"
+ android:background="@android:drawable/ic_menu_more"
+ android:layout_margin="1dp"
+ />
+</LinearLayout>
+
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res/com.example.imagefilterharness"
android:layout_width="match_parent"
- android:layout_height="match_parent"
+ android:layout_height="wrap_content"
android:orientation="horizontal" >
<HorizontalScrollView
android:id="@+id/scrollList"
android:layout_width="match_parent"
- android:layout_height="match_parent"
+ android:layout_height="wrap_content"
android:scrollbars="none" >
<LinearLayout
android:id="@+id/draw_menu_style"
android:title="@string/draw_style"/>
<item
- android:id="@+id/draw_menu_opacity"
- android:title="@string/draw_opacity"/>
- <item
- android:id="@+id/draw_menu_value"
- android:title="@string/draw_value"/>
- <item
- android:id="@+id/draw_menu_saturation"
- android:title="@string/draw_saturation"/>
- <item
- android:id="@+id/draw_menu_hue"
- android:title="@string/draw_hue"/>
- <item
android:id="@+id/draw_menu_size"
android:title="@string/draw_size"/>
<item
+ android:id="@+id/draw_menu_color"
+ android:title="@string/draw_color"/>
+ <item
android:id="@+id/draw_menu_clear"
android:title="@string/draw_clear"/>
</group>
<color name="gradcontrol_line_color">#FFFFFF</color>
<color name="gradcontrol_line_shadow">#000000</color>
<color name="draw_rect_border">#888888</color>
+ <color name="color_chooser_unslected_border">#00000000</color>
+ <color name="color_chooser_slected_border">#a7a7a7</color>
</resources>
\ No newline at end of file
<!-- Label for the Brightness to draw in [CHAR LIMIT=14] -->
<string name="draw_value">Brightness</string>
<!-- Label for the color to draw in [CHAR LIMIT=14] -->
- <string name="draw_opacity">Opacity</string>
+ <string name="draw_color">Color</string>
<!-- Label for the line style of drawing in [CHAR LIMIT=14] -->
<string name="draw_style_line">Lines</string>
<!-- Label for the Marker brush style of drawing in [CHAR LIMIT=14] -->
import android.graphics.LinearGradient;
import android.graphics.Paint;
import android.graphics.RadialGradient;
+import android.graphics.RectF;
import android.graphics.Shader;
import android.util.AttributeSet;
import android.util.DisplayMetrics;
public class ColorHueView extends View implements ColorListener {
- private float mRadius;
private float mWidth;
- private Paint mBarPaint1;
+
private Paint mLinePaint1;
private Paint mLinePaint2;
- private Paint mCheckPaint;
-
+ private Paint mPaint = new Paint();
private float mHeight;
private Paint mDotPaint;
private int mBgcolor = 0;
-
+ Bitmap mBitmap;
private float mDotRadius;
private float mBorder;
- private float[] mHSVO = new float[4];
+ private float[] mHSVO = {0.f,0.f,0.f,0.f};
private int mSliderColor;
private float mDotX = mBorder;
private float mDotY = mBorder;
- private final static float DOT_SIZE = ColorRectView.DOT_SIZE;
- public final static float BORDER_SIZE = 20;;
- private ArrayList<ColorListener> mColorListeners = new ArrayList<ColorListener>();
+ public final static float DOT_SIZE = 20;
+ public final static float BORDER_SIZE = 20;
+ RectF mRect = new RectF();
+ int[] mTmpBuff;
+ float[] mTmpHSV = new float[3];
+ private Paint mCheckPaint;
public ColorHueView(Context ctx, AttributeSet attrs) {
super(ctx, attrs);
float mDpToPix = metrics.density;
mDotRadius = DOT_SIZE * mDpToPix;
mBorder = BORDER_SIZE * mDpToPix;
- mBarPaint1 = new Paint();
mDotPaint = new Paint();
mDotPaint.setColor(ctx.getResources().getColor(R.color.slider_dot_color));
mSliderColor = ctx.getResources().getColor(R.color.slider_line_color);
- mBarPaint1.setStyle(Paint.Style.FILL);
mLinePaint1 = new Paint();
mLinePaint1.setColor(Color.GRAY);
mLinePaint2.setColor(mSliderColor);
mLinePaint2.setStrokeWidth(4);
- int[] colors = new int[16 * 16];
- for (int i = 0; i < colors.length; i++) {
- int y = i / (16 * 8);
- int x = (i / 8) % 2;
- colors[i] = (x == y) ? 0xFFAAAAAA : 0xFF444444;
+ mBitmap = Bitmap.createBitmap(256, 7, Bitmap.Config.ARGB_8888);
+ mTmpBuff = new int[256 * 7];
+ mPaint.setAntiAlias(true);
+ mPaint.setFilterBitmap(true);
+ fillBitmap();
+ makeCheckPaint();
+ }
+
+ void fillBitmap() {
+ int w = mBitmap.getWidth();
+ int h = mBitmap.getHeight();
+
+ for (int x = 0; x < w; x++) {
+ float hue = 360 * (x) / (float) w;
+
+
+ int color = Color.HSVToColor((int)(mHSVO[3]*255),mHSVO);
+ mTmpBuff[x + w * 2] = color;
+ mTmpBuff[x + w * 3] = color;
+ mTmpBuff[x + w * 4] = color;
+
+ mTmpHSV[0] = hue;
+ mTmpHSV[1] = 1;
+ mTmpHSV[2] = 1;
+ color = Color.HSVToColor(mTmpHSV);
+ mTmpBuff[x] = color;
+ mTmpBuff[x + w] = color;
+ mTmpBuff[x + w * 5] = color;
+ mTmpBuff[x + w * 6] = color;
}
- Bitmap bitmap = Bitmap.createBitmap(colors, 16, 16, Bitmap.Config.ARGB_8888);
- BitmapShader bs = new BitmapShader(bitmap, Shader.TileMode.REPEAT, Shader.TileMode.REPEAT);
- mCheckPaint = new Paint();
- mCheckPaint.setShader(bs);
+
+ mBitmap.setPixels(mTmpBuff, 0, w, 0, 0, w, h);
}
+
public boolean onDown(MotionEvent e) {
return true;
}
if (mDotX > mWidth - mBorder) {
mDotX = mWidth - mBorder;
}
- mHSVO[3] = (mDotX - mBorder) / (mWidth - mBorder * 2);
+ mHSVO[0] = 360 * (mDotX - mBorder) / (mWidth - mBorder * 2);
notifyColorListeners(mHSVO);
setupButton();
- invalidate((int) (ox - mDotRadius), (int) (oy - mDotRadius), (int) (ox + mDotRadius),
- (int) (oy + mDotRadius));
- invalidate(
- (int) (mDotX - mDotRadius), (int) (mDotY - mDotRadius), (int) (mDotX + mDotRadius),
- (int) (mDotY + mDotRadius));
+ fillBitmap();
+// invalidate((int) (ox - mDotRadius), (int) (oy - mDotRadius), (int) (ox + mDotRadius),
+// (int) (oy + mDotRadius));
+// invalidate(
+// (int) (mDotX - mDotRadius), (int) (mDotY - mDotRadius), (int) (mDotX + mDotRadius),
+// (int) (mDotY + mDotRadius));
+ invalidate();
return true;
}
private void setupButton() {
- float pos = mHSVO[3] * (mWidth - mBorder * 2);
+ float pos = mHSVO[0] / 360 * (mWidth - mBorder * 2);
mDotX = pos + mBorder;
- int[] colors3 = new int[] {
- mSliderColor, mSliderColor, 0x66000000, 0 };
- RadialGradient g = new RadialGradient(mDotX, mDotY, mDotRadius, colors3, new float[] {
- 0, .3f, .31f, 1 }, Shader.TileMode.CLAMP);
+ int[] colors3 = new int[]{
+ mSliderColor, mSliderColor, 0x66000000, 0};
+ RadialGradient g = new RadialGradient(mDotX, mDotY, mDotRadius, colors3, new float[]{
+ 0, .3f, .31f, 1}, Shader.TileMode.CLAMP);
mDotPaint.setShader(g);
}
mWidth = w;
mHeight = h;
mDotY = mHeight / 2;
- updatePaint();
setupButton();
}
- private int[] mColors = new int[] {
- 0xFFFF0000,// red
- 0xFFFFFF00,// yellow
- 0xFF00FF00,// green
- 0xFF00FFFF,// cyan
- 0xFF0000FF,// blue
- 0xFFFF00FF,// magenta
- 0xFFFF0000,// red
- };
-
- private void updatePaint() {
-
- int color2 = Color.HSVToColor(mHSVO);
- int color1 = color2 & 0xFFFFFF;
-
- Shader sg = new LinearGradient(
- mBorder, mBorder, mWidth - mBorder, mBorder,
- mColors, null, Shader.TileMode.CLAMP);
- mBarPaint1.setShader(sg);
-
- }
@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
canvas.drawColor(mBgcolor);
- canvas.drawRect(mBorder, mBorder, mWidth - mBorder, mHeight - mBorder, mCheckPaint);
- canvas.drawRect(mBorder, mBorder, mWidth - mBorder, mHeight - mBorder, mBarPaint1);
+
+ mRect.left = mBorder;
+ mRect.right = mWidth - mBorder;
+ mRect.top = mBorder;
+ mRect.bottom = mHeight - mBorder;
+ canvas.drawRect(mRect,mCheckPaint);
+ canvas.drawBitmap(mBitmap, null, mRect, mPaint);
+
+
canvas.drawLine(mDotX, mDotY, mWidth - mBorder, mDotY, mLinePaint1);
canvas.drawLine(mBorder, mDotY, mDotX, mDotY, mLinePaint2);
if (mDotX != Float.NaN) {
}
}
+ private void makeCheckPaint(){
+ int[] colors = new int[16 * 16];
+ for (int i = 0; i < colors.length; i++) {
+ int y = i / (16 * 8);
+ int x = (i / 8) % 2;
+ colors[i] = (x == y) ? 0xFFAAAAAA : 0xFF444444;
+ }
+ Bitmap bitmap = Bitmap.createBitmap(colors, 16, 16, Bitmap.Config.ARGB_8888);
+ BitmapShader bs = new BitmapShader(bitmap, Shader.TileMode.REPEAT, Shader.TileMode.REPEAT);
+ mCheckPaint = new Paint();
+ mCheckPaint.setShader(bs);
+ }
+
@Override
public void setColor(float[] hsv) {
System.arraycopy(hsv, 0, mHSVO, 0, mHSVO.length);
-
- float oy = mDotY;
-
- updatePaint();
+ fillBitmap();
setupButton();
invalidate();
}
+ ArrayList<ColorListener> mColorListeners = new ArrayList<ColorListener>();
+
public void notifyColorListeners(float[] hsvo) {
for (ColorListener l : mColorListeners) {
l.setColor(hsvo);
private int mSliderColor;
private float mDotX = mBorder;
private float mDotY = mBorder;
- private final static float DOT_SIZE = ColorRectView.DOT_SIZE;
+ private final static float DOT_SIZE = ColorHueView.DOT_SIZE;
public final static float BORDER_SIZE = 20;;
public ColorOpacityView(Context ctx, AttributeSet attrs) {
mLinePaint2.setColor(mSliderColor);
mLinePaint2.setStrokeWidth(4);
+ makeCheckPaint();
+ }
+
+ private void makeCheckPaint(){
int[] colors = new int[16 * 16];
for (int i = 0; i < colors.length; i++) {
int y = i / (16 * 8);
mDotX = pos + mBorder;
int[] colors3 = new int[] {
- mSliderColor, mSliderColor, 0x66000000, 0 };
+ mSliderColor, mSliderColor, 0x66000000, 0 };
RadialGradient g = new RadialGradient(mDotX, mDotY, mDotRadius, colors3, new float[] {
- 0, .3f, .31f, 1 }, Shader.TileMode.CLAMP);
+ 0, .3f, .31f, 1 }, Shader.TileMode.CLAMP);
mDotPaint.setShader(g);
}
public void setColor(float[] hsv) {
System.arraycopy(hsv, 0, mHSVO, 0, mHSVO.length);
- float oy = mDotY;
-
updatePaint();
setupButton();
invalidate();
import android.content.Context;
import android.graphics.Color;
import android.graphics.drawable.GradientDrawable;
+import android.util.DisplayMetrics;
import android.view.View;
+import android.view.WindowManager;
import android.widget.Button;
import android.widget.ToggleButton;
import com.android.gallery3d.R;
-public class ColorPickerDialog extends Dialog implements ColorListener {
+public class ColorPickerDialog extends Dialog {
ToggleButton mSelectedButton;
GradientDrawable mSelectRect;
-
- float[] mHSVO = new float[4];
+ ColorHueView mColorHueView;
+ ColorSVRectView mColorSVRectView;
+ ColorOpacityView mColorOpacityView;
+ float[] mHSVO = new float[4]; // hue=0..360, sat & val opacity = 0...1
public ColorPickerDialog(Context context, final ColorListener cl) {
super(context);
-
+ DisplayMetrics metrics = new DisplayMetrics();
+ WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
+ wm.getDefaultDisplay().getMetrics(metrics);
+ int height = metrics.heightPixels*8/10;
+ int width = metrics.widthPixels*8/10;
+ getWindow().setLayout(width, height);
setContentView(R.layout.filtershow_color_picker);
- ColorValueView csv = (ColorValueView) findViewById(R.id.colorValueView);
- ColorRectView cwv = (ColorRectView) findViewById(R.id.colorRectView);
- ColorOpacityView cvv = (ColorOpacityView) findViewById(R.id.colorOpacityView);
+ mColorHueView = (ColorHueView) findViewById(R.id.ColorHueView);
+ mColorSVRectView = (ColorSVRectView) findViewById(R.id.colorRectView);
+ mColorOpacityView = (ColorOpacityView) findViewById(R.id.colorOpacityView);
float[] hsvo = new float[] {
123, .9f, 1, 1 };
Button sel = (Button) findViewById(R.id.btnSelect);
sel.setOnClickListener(new View.OnClickListener() {
- @Override
+ @Override
public void onClick(View v) {
ColorPickerDialog.this.dismiss();
if (cl != null) {
}
});
- cwv.setColor(hsvo);
- cvv.setColor(hsvo);
- csv.setColor(hsvo);
- csv.addColorListener(cwv);
- cwv.addColorListener(csv);
- csv.addColorListener(cvv);
- cwv.addColorListener(cvv);
- cvv.addColorListener(cwv);
- cvv.addColorListener(csv);
- cvv.addColorListener(this);
- csv.addColorListener(this);
- cwv.addColorListener(this);
+ mColorSVRectView.setColor(hsvo);
+ mColorOpacityView.setColor(hsvo);
+ mColorHueView.setColor(hsvo);
+ mColorHueView.addColorListener(mColorSVRectView);
+ mColorSVRectView.addColorListener(mColorHueView);
+ mColorHueView.addColorListener(mColorOpacityView);
+ mColorSVRectView.addColorListener(mColorOpacityView);
+ mColorOpacityView.addColorListener(mColorSVRectView);
+ mColorOpacityView.addColorListener(mColorHueView);
+ ColorListener colorListener = new ColorListener(){
+
+ @Override
+ public void setColor(float[] hsvo) {
+ System.arraycopy(hsvo, 0, mHSVO, 0, mHSVO.length);
+ int color = Color.HSVToColor(hsvo);
+ mSelectRect.setColor(color);
+ setButtonColor(mSelectedButton, hsvo);
+ }
+ };
+ mColorOpacityView.addColorListener(colorListener);
+ mColorHueView.addColorListener(colorListener);
+ mColorSVRectView.addColorListener(colorListener);
}
float[] hsv = (float[]) v.getTag();
- ColorValueView csv = (ColorValueView) findViewById(R.id.colorValueView);
- ColorRectView cwv = (ColorRectView) findViewById(R.id.colorRectView);
+ ColorHueView csv = (ColorHueView) findViewById(R.id.ColorHueView);
+ ColorSVRectView cwv = (ColorSVRectView) findViewById(R.id.colorRectView);
ColorOpacityView cvv = (ColorOpacityView) findViewById(R.id.colorOpacityView);
cwv.setColor(hsv);
cvv.setColor(hsv);
csv.setColor(hsv);
}
- @Override
+
public void setColor(float[] hsvo) {
- System.arraycopy(hsvo, 0, mHSVO, 0, mHSVO.length);
- int color = Color.HSVToColor(hsvo);
- mSelectRect.setColor(color);
- setButtonColor(mSelectedButton, hsvo);
+ mColorOpacityView.setColor(hsvo);
+ mColorHueView.setColor(hsvo);
+ mColorSVRectView.setColor(hsvo);
}
private void setButtonColor(ToggleButton button, float[] hsv) {
--- /dev/null
+/*
+ * 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.colorpicker;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.LinearGradient;
+import android.graphics.Paint;
+import android.graphics.RadialGradient;
+import android.graphics.Rect;
+import android.graphics.RectF;
+import android.graphics.Shader;
+import android.graphics.SweepGradient;
+import android.util.AttributeSet;
+import android.util.DisplayMetrics;
+import android.view.MotionEvent;
+import android.view.View;
+
+import com.android.gallery3d.R;
+
+import java.util.ArrayList;
+
+public class ColorSVRectView extends View implements ColorListener {
+ private float mDpToPix;
+
+ private float mCtrY = 100;
+ private Paint mPaint1;
+
+ private float mCtrX = 100;
+ private Paint mDotPaint = new Paint();
+ private float mDotRadus;
+ private float mBorder;
+
+ private float mDotX = Float.NaN;
+ private float mDotY;
+ private int mSliderColor = 0xFF33B5E5;
+ private float[] mHSVO = new float[]{0, 1, 1, 1};
+ RectF mRect = new RectF();
+
+ private int mWidth;
+ private int mHeight;
+ public final static float DOT_SIZE = 20;
+ public final static float BORDER_SIZE = 20;
+ Bitmap mBitmap;
+
+ public ColorSVRectView(Context ctx, AttributeSet attrs) {
+ super(ctx, attrs);
+
+ DisplayMetrics metrics = ctx.getResources().getDisplayMetrics();
+ mDpToPix = metrics.density;
+ mDotRadus = DOT_SIZE * mDpToPix;
+ mBorder = BORDER_SIZE * mDpToPix;
+
+ mPaint1 = new Paint();
+
+
+ mDotPaint.setStyle(Paint.Style.FILL);
+ if (isInEditMode()) {
+ mDotPaint.setColor(0x646464);
+ mSliderColor = 0x888888;
+ } else {
+ mDotPaint.setColor(ctx.getResources().getColor(R.color.slider_dot_color));
+ mSliderColor = ctx.getResources().getColor(R.color.slider_line_color);
+ }
+ mPaint1.setStyle(Paint.Style.FILL);
+ mPaint1.setAntiAlias(true);
+ mPaint1.setFilterBitmap(true);
+
+ mBitmap = Bitmap.createBitmap(64, 46, Bitmap.Config.ARGB_8888);
+ fillBitmap();
+ }
+
+ void fillBitmap() {
+ int w = mBitmap.getWidth();
+ int h = mBitmap.getHeight();
+ int[] buff = new int[w * h];
+ float[] hsv = new float[3];
+ hsv[0] = mHSVO[0];
+ for (int i = 0; i < w * h; i++) {
+ float sat = (i % w) / (float) w;
+ float val = (w - i / w) / (float) w;
+ hsv[1] = sat;
+ hsv[2] = val;
+ buff[i] = Color.HSVToColor(hsv);
+ }
+ mBitmap.setPixels(buff, 0, w, 0, 0, w, h);
+ }
+
+ private void setUpColorPanel() {
+ updateDot();
+ updateDotPaint();
+ fillBitmap();
+
+ }
+
+
+ @Override
+ protected void onDraw(Canvas canvas) {
+ super.onDraw(canvas);
+ Rect r = canvas.getClipBounds();
+ mRect.set(r);
+ mRect.top += mBorder;
+ mRect.bottom -= mBorder;
+ mRect.left += mBorder;
+ mRect.right -= mBorder;
+ canvas.drawBitmap(mBitmap, null, mRect, mPaint1);
+
+ if (mDotX != Float.NaN) {
+
+ canvas.drawCircle(mDotX, mDotY, mDotRadus, mDotPaint);
+ }
+ }
+
+
+ public boolean onDown(MotionEvent e) {
+ return true;
+ }
+
+ @Override
+ public boolean onTouchEvent(MotionEvent event) {
+
+ invalidate((int) (mDotX - mDotRadus), (int) (mDotY - mDotRadus), (int) (mDotX + mDotRadus),
+ (int) (mDotY + mDotRadus));
+ float x = event.getX();
+ float y = event.getY();
+
+ x = Math.max(Math.min(x, mWidth - mBorder), mBorder);
+ y = Math.max(Math.min(y, mHeight - mBorder), mBorder);
+ mDotX = x;
+ mDotY = y;
+ float sat = 1 - (mDotY - mBorder) / (mHeight - 2 * mBorder);
+ if (sat > 1) {
+ sat = 1;
+ }
+
+ float value = (mDotX - mBorder) / (mHeight - 2 * mBorder);
+ mHSVO[2] = sat;
+ mHSVO[1] = value;
+ notifyColorListeners(mHSVO);
+ updateDotPaint();
+ invalidate((int) (mDotX - mDotRadus), (int) (mDotY - mDotRadus), (int) (mDotX + mDotRadus),
+ (int) (mDotY + mDotRadus));
+
+ return true;
+ }
+
+ @Override
+ protected void onSizeChanged(int w, int h, int oldw, int oldh) {
+ mWidth = w;
+ mHeight = h;
+ mCtrY = h / 2f;
+ mCtrX = w / 2f;
+
+ setUpColorPanel();
+ }
+
+
+ private void updateDot() {
+
+ double hue = mHSVO[0];
+ double sat = mHSVO[1];
+ double val = mHSVO[2];
+ double opc = mHSVO[3];
+
+ mDotX = (float) (mBorder + (mHeight - 2 * mBorder) * sat);
+ mDotY = (float) ((1 - val) * (mHeight - 2 * mBorder) + mBorder);
+
+ }
+
+ private void updateDotPaint() {
+ int[] colors3 = new int[]{
+ mSliderColor, mSliderColor, 0x66000000, 0};
+ RadialGradient g = new RadialGradient(mDotX, mDotY, mDotRadus, colors3, new float[]{
+ 0, .3f, .31f, 1}, Shader.TileMode.CLAMP);
+ mDotPaint.setShader(g);
+
+ }
+
+ @Override
+ public void setColor(float[] hsvo) {
+ if (hsvo[0] == mHSVO[0]
+ && hsvo[1] == mHSVO[1]
+ && hsvo[2] == mHSVO[2]) {
+ mHSVO[3] = hsvo[3]; // we don't update if color stays the same
+ return;
+ }
+ System.arraycopy(hsvo, 0, mHSVO, 0, mHSVO.length);
+
+ setUpColorPanel();
+ invalidate();
+
+ updateDot();
+ updateDotPaint();
+
+ }
+
+ ArrayList<ColorListener> mColorListeners = new ArrayList<ColorListener>();
+
+ public void notifyColorListeners(float[] hsv) {
+ for (ColorListener l : mColorListeners) {
+ l.setColor(hsv);
+ }
+ }
+
+ public void addColorListener(ColorListener l) {
+ mColorListeners.add(l);
+ }
+
+ public void removeColorListener(ColorListener l) {
+ mColorListeners.remove(l);
+ }
+}
--- /dev/null
+package com.android.gallery3d.filtershow.controller;
+
+import android.app.ActionBar.LayoutParams;
+import android.content.Context;
+import android.content.res.Resources;
+import android.graphics.Color;
+import android.graphics.drawable.GradientDrawable;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.Button;
+import android.widget.LinearLayout;
+
+import com.android.gallery3d.R;
+import com.android.gallery3d.filtershow.colorpicker.ColorListener;
+import com.android.gallery3d.filtershow.colorpicker.ColorPickerDialog;
+import com.android.gallery3d.filtershow.editors.Editor;
+
+import java.util.Arrays;
+import java.util.Vector;
+
+public class ColorChooser implements Control {
+ private final String LOGTAG = "StyleChooser";
+ protected ParameterColor mParameter;
+ protected LinearLayout mLinearLayout;
+ protected Editor mEditor;
+ private View mTopView;
+ private Vector<Button> mIconButton = new Vector<Button>();
+ protected int mLayoutID = R.layout.filtershow_control_color_chooser;
+ Context mContext;
+ private int mTransparent;
+ private int mSelected;
+ private static final int OPACITY_OFFSET = 3;
+ private int[] mButtonsID = {
+ R.id.draw_color_button01,
+ R.id.draw_color_button02,
+ R.id.draw_color_button03,
+ R.id.draw_color_button04,
+ R.id.draw_color_button05,
+ };
+ private Button[] mButton = new Button[mButtonsID.length];
+ int[] mBasColors = {
+ Color.RED & 0x80FFFFFF,
+ Color.GREEN & 0x80FFFFFF,
+ Color.BLUE & 0x80FFFFFF,
+ Color.BLACK & 0x80FFFFFF,
+ Color.WHITE & 0x80FFFFFF
+ };
+ int mSelectedButton = 0;
+
+ @Override
+ public void setUp(ViewGroup container, Parameter parameter, Editor editor) {
+ container.removeAllViews();
+ Resources res = container.getContext().getResources();
+ mTransparent = res.getColor(R.color.color_chooser_unslected_border);
+ mSelected = res.getColor(R.color.color_chooser_slected_border);
+ mEditor = editor;
+ mContext = container.getContext();
+ mParameter = (ParameterColor) parameter;
+ LayoutInflater inflater =
+ (LayoutInflater) mContext.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
+ mTopView = inflater.inflate(mLayoutID, container, true);
+ mLinearLayout = (LinearLayout) mTopView.findViewById(R.id.listStyles);
+ mTopView.setVisibility(View.VISIBLE);
+
+ mIconButton.clear();
+ LayoutParams lp = new LayoutParams(120, 120);
+
+ for (int i = 0; i < mButtonsID.length; i++) {
+ final Button button = (Button) mTopView.findViewById(mButtonsID[i]);
+ mButton[i] = button;
+ float[] hsvo = new float[4];
+ Color.colorToHSV(mBasColors[i], hsvo);
+ hsvo[OPACITY_OFFSET] = (0xFF & (mBasColors[i] >> 24)) / (float) 255;
+ button.setTag(hsvo);
+ GradientDrawable sd = ((GradientDrawable) button.getBackground());
+
+ sd.setColor(mBasColors[i]);
+ sd.setStroke(3, (mSelectedButton == i) ? mSelected : mTransparent);
+
+ final int buttonNo = i;
+ button.setOnClickListener(new View.OnClickListener() {
+ @Override
+ public void onClick(View arg0) {
+ selectColor(arg0, buttonNo);
+ }
+ });
+ }
+ Button button = (Button) mTopView.findViewById(R.id.draw_color_popupbutton);
+
+ button.setOnClickListener(new View.OnClickListener() {
+ @Override
+ public void onClick(View arg0) {
+ showColorPicker();
+ }
+ });
+
+ }
+
+ public void setColorSet(int[] basColors) {
+ for (int i = 0; i < mBasColors.length; i++) {
+ mBasColors[i] = basColors[i];
+ float[] hsvo = new float[4];
+ Color.colorToHSV(mBasColors[i], hsvo);
+ hsvo[OPACITY_OFFSET] = (0xFF & (mBasColors[i] >> 24)) / (float) 255;
+ mButton[i].setTag(hsvo);
+ GradientDrawable sd = ((GradientDrawable) mButton[i].getBackground());
+ sd.setColor(mBasColors[i]);
+ }
+
+ }
+
+ public int[] getColorSet() {
+ return mBasColors;
+ }
+
+ private void resetBorders() {
+ for (int i = 0; i < mButtonsID.length; i++) {
+ final Button button = mButton[i];
+
+ GradientDrawable sd = ((GradientDrawable) button.getBackground());
+ sd.setColor(mBasColors[i]);
+ sd.setStroke(3, (mSelectedButton == i) ? mSelected : mTransparent);
+ }
+ }
+
+ public void selectColor(View button, int buttonNo) {
+ mSelectedButton = buttonNo;
+ float[] hsvo = (float[]) button.getTag();
+ mParameter.setValue(Color.HSVToColor((int) (hsvo[OPACITY_OFFSET] * 255), hsvo));
+ resetBorders();
+ }
+
+ @Override
+ public View getTopView() {
+ return mTopView;
+ }
+
+ @Override
+ public void setPrameter(Parameter parameter) {
+ mParameter = (ParameterColor) parameter;
+ updateUI();
+ }
+
+ @Override
+ public void updateUI() {
+ if (mParameter == null) {
+ return;
+ }
+ }
+
+ public void changeSelectedColor(float[] hsvo) {
+ int c = Color.HSVToColor((int) (hsvo[3] * 255), hsvo);
+ final Button button = mButton[mSelectedButton];
+
+ GradientDrawable sd = ((GradientDrawable) button.getBackground());
+ sd.setColor(c);
+ mBasColors[mSelectedButton] = c;
+ mParameter.setValue(Color.HSVToColor((int) (hsvo[OPACITY_OFFSET] * 255), hsvo));
+ button.setTag(hsvo);
+ button.invalidate();
+ }
+
+ public void showColorPicker() {
+ ColorListener cl = new ColorListener() {
+ @Override
+ public void setColor(float[] hsvo) {
+ changeSelectedColor(hsvo);
+ }
+ };
+ ColorPickerDialog cpd = new ColorPickerDialog(mContext, cl);
+ float[] c = (float[]) mButton[mSelectedButton].getTag();
+ cpd.setColor(Arrays.copyOf(c, 4));
+ cpd.show();
+ }
+}
--- /dev/null
+/*
+ * 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.controller;
+
+public class ParameterColor implements Parameter {
+ public static String sParameterType = "ParameterColor";
+ protected Control mControl;
+ protected FilterView mEditor;
+ float[] mHSVO = new float[4];
+ String mParameterName;
+ int mValue;
+ public final int ID;
+
+ public ParameterColor(int id) {
+ ID = id;
+ }
+
+ @Override
+ public String getParameterType() {
+ return sParameterType;
+ }
+
+ public void setColor(float[] hsvo) {
+ mHSVO = hsvo;
+ }
+
+ public float[] getColor() {
+ mHSVO[3] = getValue() ;
+ return mHSVO;
+ }
+
+
+ public void copyFrom(Parameter src) {
+ if (!(src instanceof BasicParameterInt)) {
+ throw new IllegalArgumentException(src.getClass().getName());
+ }
+ BasicParameterInt p = (BasicParameterInt) src;
+
+ mValue = p.mValue;
+ }
+
+
+ @Override
+ public String getParameterName() {
+ return mParameterName;
+ }
+
+ @Override
+ public String getValueString() {
+ return "("+Integer.toHexString(mValue)+")";
+ }
+
+ @Override
+ public void setController(Control control) {
+ mControl = control;
+ }
+
+ public int getValue() {
+ return mValue;
+ }
+
+ public void setValue(int value) {
+ mValue = value;
+ }
+
+ @Override
+ public String toString() {
+ return getValueString();
+ }
+
+ @Override
+ public void setFilterView(FilterView editor) {
+ mEditor = editor;
+ }
+}
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
+import android.graphics.Color;
import android.view.MenuItem;
import android.view.View;
import android.view.View.OnClickListener;
import com.android.gallery3d.R;
import com.android.gallery3d.filtershow.controller.BitmapCaller;
+import com.android.gallery3d.filtershow.controller.ColorChooser;
import com.android.gallery3d.filtershow.controller.FilterView;
import com.android.gallery3d.filtershow.filters.FilterDrawRepresentation;
import com.android.gallery3d.filtershow.filters.FilterRepresentation;
private static final String LOGTAG = "EditorDraw";
public static final int ID = R.id.editorDraw;
public ImageDraw mImageDraw;
- private static final int MODE_BRIGHTNESS = FilterDrawRepresentation.PARAM_BRIGHTNESS;
- private static final int MODE_SATURATION = FilterDrawRepresentation.PARAM_SATURATION;
private static final int MODE_SIZE = FilterDrawRepresentation.PARAM_SIZE;
- private static final int MODE_HUEE = FilterDrawRepresentation.PARAM_HUE;
private static final int MODE_SIZEE = FilterDrawRepresentation.PARAM_SIZE;
- private static final int MODE_OPACITY = FilterDrawRepresentation.PARAM_OPACITY;
private static final int MODE_STYLE = FilterDrawRepresentation.PARAM_STYLE;
+ private static final int MODE_COLOR = FilterDrawRepresentation.PARAM_COLOR;
int[] brushIcons = {
R.drawable.brush_flat,
R.drawable.brush_round,
R.drawable.brush_marker,
R.drawable.brush_spatter
};
-
+ int[] mBasColors = {
+ Color.RED & 0x80FFFFFF,
+ Color.GREEN & 0x80FFFFFF,
+ Color.BLUE & 0x80FFFFFF,
+ Color.BLACK & 0x80FFFFFF,
+ Color.WHITE & 0x80FFFFFF
+ };
String mParameterString;
public EditorDraw() {
FilterDrawRepresentation drawRep = (FilterDrawRepresentation) getLocalRepresentation();
mImageDraw.setFilterDrawRepresentation(drawRep);
drawRep.getParam(FilterDrawRepresentation.PARAM_STYLE).setFilterView(this);
- drawRep.setPramMode(FilterDrawRepresentation.PARAM_HUE);
+ drawRep.setPramMode(FilterDrawRepresentation.PARAM_COLOR);
mParameterString = mContext.getString(R.string.draw_hue);
control(drawRep.getCurrentParam(), mEditControl);
}
idraw.resetParameter();
commitLocalRepresentation();
break;
- case R.id.draw_menu_hue:
- rep.setPramMode(FilterDrawRepresentation.PARAM_HUE);
- break;
- case R.id.draw_menu_opacity:
- rep.setPramMode(FilterDrawRepresentation.PARAM_OPACITY);
- break;
- case R.id.draw_menu_saturation:
- rep.setPramMode(FilterDrawRepresentation.PARAM_SATURATION);
- break;
case R.id.draw_menu_size:
rep.setPramMode(FilterDrawRepresentation.PARAM_SIZE);
break;
case R.id.draw_menu_style:
rep.setPramMode(FilterDrawRepresentation.PARAM_STYLE);
break;
- case R.id.draw_menu_value:
- rep.setPramMode(FilterDrawRepresentation.PARAM_BRIGHTNESS);
+ case R.id.draw_menu_color:
+ rep.setPramMode(FilterDrawRepresentation.PARAM_COLOR);
break;
}
if (item.getItemId() != R.id.draw_menu_clear) {
mParameterString = item.getTitle().toString();
}
+ if (mControl instanceof ColorChooser) {
+ ColorChooser c = (ColorChooser) mControl;
+ mBasColors = c.getColorSet();
+ }
control(rep.getCurrentParam(), mEditControl);
+ if (mControl instanceof ColorChooser) {
+ ColorChooser c = (ColorChooser) mControl;
+ c.setColorSet(mBasColors);
+ }
mControl.updateUI();
mView.invalidate();
}
caller.available(bitmap);
}
- public int getBrushIcon(int type){
- return brushIcons[type];
+ public int getBrushIcon(int type) {
+ return brushIcons[type];
}
}
import com.android.gallery3d.R;
import com.android.gallery3d.filtershow.controller.ActionSlider;
import com.android.gallery3d.filtershow.controller.BasicSlider;
+import com.android.gallery3d.filtershow.controller.ColorChooser;
import com.android.gallery3d.filtershow.controller.Control;
import com.android.gallery3d.filtershow.controller.Parameter;
import com.android.gallery3d.filtershow.controller.ParameterActionAndInt;
import com.android.gallery3d.filtershow.controller.ParameterBrightness;
+import com.android.gallery3d.filtershow.controller.ParameterColor;
import com.android.gallery3d.filtershow.controller.ParameterHue;
import com.android.gallery3d.filtershow.controller.ParameterInteger;
import com.android.gallery3d.filtershow.controller.ParameterOpacity;
landscapeMap.put(ParameterOpacity.sParameterType, SliderOpacity.class);
portraitMap.put(ParameterBrightness.sParameterType, SliderBrightness.class);
landscapeMap.put(ParameterBrightness.sParameterType, SliderBrightness.class);
+ portraitMap.put(ParameterColor.sParameterType, ColorChooser.class);
+ landscapeMap.put(ParameterColor.sParameterType, ColorChooser.class);
portraitMap.put(ParameterInteger.sParameterType, BasicSlider.class);
landscapeMap.put(ParameterInteger.sParameterType, TitledSlider.class);
import com.android.gallery3d.filtershow.controller.BasicParameterStyle;
import com.android.gallery3d.filtershow.controller.Parameter;
import com.android.gallery3d.filtershow.controller.ParameterBrightness;
+import com.android.gallery3d.filtershow.controller.ParameterColor;
import com.android.gallery3d.filtershow.controller.ParameterHue;
import com.android.gallery3d.filtershow.controller.ParameterOpacity;
import com.android.gallery3d.filtershow.controller.ParameterSaturation;
import java.io.IOException;
import java.util.Arrays;
+import java.util.Iterator;
import java.util.Vector;
public class FilterDrawRepresentation extends FilterRepresentation {
private static final String LOGTAG = "FilterDrawRepresentation";
public static final int PARAM_SIZE = 0;
- public static final int PARAM_HUE = 1;
- public static final int PARAM_BRIGHTNESS = 2;
- public static final int PARAM_SATURATION = 3;
- public static final int PARAM_OPACITY = 4;
- public static final int PARAM_STYLE = 5;
+
+ public static final int PARAM_STYLE = 1;
+ public static final int PARAM_COLOR = 2;
private BasicParameterInt mParamSize = new BasicParameterInt(PARAM_SIZE, 20, 2, 300);
- private BasicParameterInt mParamHue = new ParameterHue(PARAM_HUE, 0);
- private BasicParameterInt mParamBrightness = new ParameterBrightness(PARAM_BRIGHTNESS, 220);
- private BasicParameterInt mParamSaturation = new ParameterSaturation(PARAM_SATURATION, 200);
- private ParameterOpacity mParamOpacity = new ParameterOpacity(PARAM_OPACITY, 200);
+
private BasicParameterStyle mParamStyle = new BasicParameterStyle(PARAM_STYLE, 5);
+ ParameterColor mParamColor = new ParameterColor(PARAM_COLOR);
int mParamMode;
Parameter mCurrentParam = mParamSize;
private static final String SERIAL_COLOR = "color";
private Parameter[] mAllParam = {
mParamSize,
- mParamHue,
- mParamBrightness,
- mParamSaturation,
- mParamOpacity,
- mParamStyle
+ mParamStyle,
+ mParamColor
};
public void setPramMode(int mode) {
public int noPoints = 0;
public float[] mPoints = new float[20];
+ public StrokeData() {
+ }
+
+ public StrokeData(StrokeData copy) {
+ mType = copy.mType;
+ mPath = new Path(copy.mPath);
+ mRadius = copy.mRadius;
+ mColor = copy.mColor;
+ noPoints = copy.noPoints;
+ mPoints = Arrays.copyOf(copy.mPoints, copy.mPoints.length);
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (!(o instanceof StrokeData)) {
+ return false;
+ }
+ StrokeData sd = (StrokeData) o;
+ if (mType != sd.mType
+ || mRadius != sd.mRadius
+ || noPoints != sd.noPoints
+ || mColor != sd.mColor) {
+ return false;
+ }
+ return mPath.equals(sd.mPath);
+ }
+
@Override
public String toString() {
return "stroke(" + mType + ", path(" + (mPath) + "), " + mRadius + " , "
}
}
- public String getValueString() {
+ static String colorHexString(int val) {
+ String str = "00000000" + Integer.toHexString(val);
+ str = "0x" + str.substring(str.length() - 8);
+ return str;
+ }
+ public String getValueString() {
+ int val;
switch (mParamMode) {
+ case PARAM_COLOR:
+ val = ((ParameterColor) mAllParam[mParamMode]).getValue();
+ return ((val > 0) ? " +" : " ") + colorHexString(val);
case PARAM_SIZE:
- case PARAM_HUE:
- case PARAM_BRIGHTNESS:
- case PARAM_SATURATION:
- case PARAM_OPACITY:
- int val = ((BasicParameterInt) mAllParam[mParamMode]).getValue();
+ val = ((BasicParameterInt) mAllParam[mParamMode]).getValue();
return ((val > 0) ? " +" : " ") + val;
case PARAM_STYLE:
return "";
-
}
return "";
}
mCurrent = null;
}
if (representation.mDrawing != null) {
- mDrawing = (Vector<StrokeData>) representation.mDrawing.clone();
+ mDrawing = new Vector<StrokeData>();
+ for (Iterator<StrokeData> elem = representation.mDrawing.iterator(); elem.hasNext(); ) {
+ StrokeData next = elem.next();
+ mDrawing.add(new StrokeData(next));
+ }
} else {
mDrawing = null;
}
FilterDrawRepresentation fdRep = (FilterDrawRepresentation) representation;
if (fdRep.mDrawing.size() != mDrawing.size())
return false;
- if (fdRep.mCurrent == null && (mCurrent == null || mCurrent.mPath == null)) {
- return true;
+ if (fdRep.mCurrent == null ^ (mCurrent == null || mCurrent.mPath == null)) {
+ return false;
}
+
+
if (fdRep.mCurrent != null && mCurrent != null && mCurrent.mPath != null) {
if (fdRep.mCurrent.noPoints == mCurrent.noPoints) {
return true;
}
return false;
}
+
+ int n = mDrawing.size();
+ for (int i = 0; i < n; i++) {
+ StrokeData a = mDrawing.get(i);
+ StrokeData b = mDrawing.get(i);
+ if (!a.equals(b)){
+ return false;
+ }
+ }
+ return true;
}
return false;
}
private int computeCurrentColor(){
- float hue = 360 * mParamHue.getValue() / (float) mParamHue.getMaximum();
- float sat = mParamSaturation.getValue() / (float) mParamSaturation.getMaximum();
- float val = mParamBrightness.getValue() / (float) mParamBrightness.getMaximum();
- int op = mParamOpacity.getValue();
- float[] hsv = new float[]{hue, sat, val};
- return Color.HSVToColor(op, hsv);
+ return mParamColor.getValue();
}
public void fillStrokeParameters(StrokeData sd){
import android.graphics.PorterDuffColorFilter;
import com.android.gallery3d.R;
+import com.android.gallery3d.app.Log;
import com.android.gallery3d.filtershow.cache.ImageLoader;
import com.android.gallery3d.filtershow.filters.FilterDrawRepresentation.StrokeData;
import com.android.gallery3d.filtershow.imageshow.MasterImage;
return;
}
if (quality == FilterEnvironment.QUALITY_FINAL) {
+ Log.v(LOGTAG,"################### paint QUALITY_FINAL");
+
for (FilterDrawRepresentation.StrokeData strokeData : mParameters.getDrawing()) {
paint(strokeData, canvas, originalRotateToScreen, quality);
}
StrokeData stroke = mParameters.getCurrentDrawing();
if (stroke != null) {
+ Log.v(LOGTAG,"################### paint current");
+
paint(stroke, canvas, originalRotateToScreen, quality);
}
}
for (int i = mCachedStrokes; i < n; i++) {
paint(v.get(i), drawCache, originalRotateToScreen, FilterEnvironment.QUALITY_PREVIEW);
}
+ Log.v(LOGTAG,"################### filling buffer with "+mCachedStrokes+" to "+n);
mCachedStrokes = n;
}
public void setFilterDrawRepresentation(FilterDrawRepresentation fr) {
mFRep = fr;
+ mTmpStrokData =
+ new FilterDrawRepresentation.StrokeData();
}
public Drawable getIcon(Context context) {
OSDN Git Service
