Merge "Create a GrGLDefaultInterface for Android."
diff --git a/Android.mk b/Android.mk
index cb5f89e..6461d9b 100644
--- a/Android.mk
+++ b/Android.mk
@@ -30,6 +30,7 @@
src/core/SkCordic.cpp \
src/core/SkDebug.cpp \
src/core/SkFloatBits.cpp \
+ src/core/SkFontHost.cpp \
src/core/SkPoint.cpp \
src/core/SkRect.cpp \
src/core/SkRegion.cpp \
@@ -181,6 +182,7 @@
src/utils/SkBoundaryPatch.cpp \
src/utils/SkCamera.cpp \
src/utils/SkDumpCanvas.cpp \
+ src/utils/SkEGLContext_none.cpp \
src/utils/SkInterpolator.cpp \
src/utils/SkLayer.cpp \
src/utils/SkOSFile.cpp \
@@ -290,7 +292,6 @@
gpu/src/GrInOrderDrawBuffer.cpp \
gpu/src/GrMatrix.cpp \
gpu/src/GrMemory.cpp \
- gpu/src/GrPath.cpp \
gpu/src/GrPathUtils.cpp \
gpu/src/GrRectanizer_fifo.cpp \
gpu/src/GrResource.cpp \
diff --git a/android_sample/SampleApp/Android.mk b/android_sample/SampleApp/Android.mk
new file mode 100644
index 0000000..6d62c35
--- /dev/null
+++ b/android_sample/SampleApp/Android.mk
@@ -0,0 +1,71 @@
+######################################
+# Build the app.
+######################################
+
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_SRC_FILES := \
+ $(call all-java-files-under, src)
+
+LOCAL_PACKAGE_NAME := SampleApp
+
+LOCAL_JNI_SHARED_LIBRARIES := libskia-sample
+
+include $(BUILD_PACKAGE)
+
+######################################
+# Build the shared library.
+######################################
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_C_INCLUDES += \
+ external/skia/include/core \
+ external/skia/include/config \
+ external/skia/include/effects \
+ external/skia/include/images \
+ external/skia/include/utils \
+ external/skia/include/utils/android \
+ external/skia/include/views \
+ external/skia/samplecode \
+ external/skia/include/xml \
+ external/skia/include/gpu \
+ external/skia/src/core \
+ external/skia/gpu/include \
+ frameworks/base/core/jni/android/graphics \
+ frameworks/base/native/include/android \
+ $(LOCAL_PATH)/jni
+
+LOCAL_SHARED_LIBRARIES := \
+ libcutils \
+ libutils \
+ libskia \
+ libandroid_runtime \
+ libGLESv2
+
+LOCAL_STATIC_LIBRARIES := \
+ libskiagpu
+
+LOCAL_PRELINK_MODULE := false
+
+LOCAL_MODULE := libskia-sample
+
+LOCAL_SRC_FILES := \
+ ../../src/ports/SkXMLParser_empty.cpp \
+ jni/sample-jni.cpp
+
+include external/skia/src/views/views_files.mk
+LOCAL_SRC_FILES += $(addprefix ../../src/views/, $(SOURCE))
+
+include external/skia/src/xml/xml_files.mk
+LOCAL_SRC_FILES += $(addprefix ../../src/xml/, $(SOURCE))
+
+include external/skia/samplecode/samplecode_files.mk
+LOCAL_SRC_FILES += $(addprefix ../../samplecode/, $(SOURCE))
+
+include $(BUILD_SHARED_LIBRARY)
diff --git a/android_sample/SampleApp/AndroidManifest.xml b/android_sample/SampleApp/AndroidManifest.xml
new file mode 100644
index 0000000..e323246
--- /dev/null
+++ b/android_sample/SampleApp/AndroidManifest.xml
@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2011 Skia
+
+ 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.
+-->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ package="com.skia.sampleapp"
+ android:versionCode="1"
+ android:versionName="1.0">
+ <uses-sdk android:minSdkVersion="3" />
+ <application android:label="@string/app_name"
+ android:debuggable="true">
+ <activity android:name=".SampleApp"
+ android:theme="@android:style/Theme.Holo.NoActionBar"
+ android:label="@string/app_name">
+ <intent-filter>
+ <action android:name="android.intent.action.MAIN" />
+ <category android:name="android.intent.category.LAUNCHER" />
+ </intent-filter>
+ </activity>
+ </application>
+</manifest>
diff --git a/android_sample/SampleApp/README.txt b/android_sample/SampleApp/README.txt
new file mode 100644
index 0000000..a7d8e54
--- /dev/null
+++ b/android_sample/SampleApp/README.txt
@@ -0,0 +1,25 @@
+Building the sample app for Android using an Android tree:
+
+Copy this folder into an Android tree in packages/apps. In addition to jni,
+res, and src, there needs to be a fourth folder named "skia_extra". This
+will include the skia files which are not part of an Android checkout. It
+should have three folders: include, samplecode, and src.
+
+skia/trunk/include/views -> skia_extra/include/views
+skia/trunk/include/xml -> skia_extra/include/xml
+
+skia/trunk/samplecode -> skia_extra/samplecode
+
+skia/trunk/src/views -> skia_extra/src/views
+skia/trunk/src/ports/SkXMLParser_empty.cpp -> skia_extra/src/ports/
+skia/trunk/src/xml -> skia_extra/src/xml
+
+skia/trunk/include/utils/android/AndroidKeyToSkKey.h -> jni/
+
+From packages/apps/SampleApp, type "mm" to build, and install the
+resulting apk.
+
+(It may be necessary to remove samples that do not build from
+skia_extra/samplecode/samplecode_files.mk)
+
+TODO: Instructions for building from SDK/NDK
diff --git a/android_sample/SampleApp/jni/sample-jni.cpp b/android_sample/SampleApp/jni/sample-jni.cpp
new file mode 100644
index 0000000..529047c
--- /dev/null
+++ b/android_sample/SampleApp/jni/sample-jni.cpp
@@ -0,0 +1,208 @@
+/*
+ * Copyright (C) 2011 Skia
+ *
+ * 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.
+ *
+ */
+
+#include <jni.h>
+
+#include "SkCanvas.h"
+#include "GraphicsJNI.h"
+#include "SkEvent.h"
+#include "SkWindow.h"
+#include "SkApplication.h"
+#include "utils/android/AndroidKeyToSkKey.h"
+
+///////////////////////////////////////////
+///////////////// Globals /////////////////
+///////////////////////////////////////////
+
+struct ActivityGlue {
+ JNIEnv* m_env;
+ jweak m_obj;
+ jmethodID m_setTitle;
+ ActivityGlue() {
+ m_env = NULL;
+ m_obj = NULL;
+ m_setTitle = NULL;
+ }
+} gActivityGlue;
+
+struct WindowGlue {
+ jweak m_obj;
+ jmethodID m_inval;
+ WindowGlue() {
+ m_obj = NULL;
+ m_inval = NULL;
+ }
+} gWindowGlue;
+
+SkOSWindow* gWindow;
+
+///////////////////////////////////////////
+///////////// SkOSWindow impl /////////////
+///////////////////////////////////////////
+
+void SkOSWindow::onSetTitle(const char title[])
+{
+ if (gActivityGlue.m_env) {
+ JNIEnv* env = gActivityGlue.m_env;
+ jstring string = env->NewStringUTF(title);
+ env->CallVoidMethod(gActivityGlue.m_obj, gActivityGlue.m_setTitle,
+ string);
+ env->DeleteLocalRef(string);
+ }
+}
+
+void SkOSWindow::onHandleInval(const SkIRect& rect)
+{
+ if (!gActivityGlue.m_env || !gWindowGlue.m_inval || !gWindowGlue.m_obj) {
+ return;
+ }
+ gActivityGlue.m_env->CallVoidMethod(gWindowGlue.m_obj, gWindowGlue.m_inval,
+ rect.fLeft, rect.fTop, rect.fRight, rect.fBottom);
+}
+
+///////////////////////////////////////////
+/////////////// SkEvent impl //////////////
+///////////////////////////////////////////
+
+void SkEvent::SignalQueueTimer(SkMSec) {}
+
+void SkEvent::SignalNonEmptyQueue() {}
+
+///////////////////////////////////////////
+////////////////// JNI ////////////////////
+///////////////////////////////////////////
+
+static jmethodID GetJMethod(JNIEnv* env, jclass clazz, const char name[],
+ const char signature[])
+{
+ jmethodID m = env->GetMethodID(clazz, name, signature);
+ if (!m) SkDebugf("Could not find Java method %s\n", name);
+ return m;
+}
+
+extern "C" {
+JNIEXPORT void JNICALL Java_com_skia_sampleapp_SampleApp_drawToCanvas(
+ JNIEnv* env, jobject thiz, jobject jcanvas);
+JNIEXPORT void JNICALL Java_com_skia_sampleapp_SampleApp_init(
+ JNIEnv* env, jobject thiz);
+JNIEXPORT void JNICALL Java_com_skia_sampleapp_SampleApp_term(
+ JNIEnv* env, jobject thiz);
+JNIEXPORT void JNICALL Java_com_skia_sampleapp_SampleApp_updateSize(
+ JNIEnv* env, jobject thiz, jint w, jint h);
+JNIEXPORT bool JNICALL Java_com_skia_sampleapp_SampleApp_handleKeyDown(
+ JNIEnv* env, jobject thiz, jint keyCode, jint uni);
+JNIEXPORT bool JNICALL Java_com_skia_sampleapp_SampleApp_handleKeyUp(
+ JNIEnv* env, jobject thiz, jint keyCode);
+JNIEXPORT void JNICALL Java_com_skia_sampleapp_SampleApp_handleClick(
+ JNIEnv* env, jobject thiz, jint x, jint y, jint state);
+JNIEXPORT void JNICALL Java_com_skia_sampleapp_SampleApp_createOSWindow(
+ JNIEnv* env, jobject thiz, jobject jsampleView);
+};
+
+JNIEXPORT bool JNICALL Java_com_skia_sampleapp_SampleApp_handleKeyDown(
+ JNIEnv* env, jobject thiz, jint keyCode, jint uni)
+{
+ bool handled = gWindow->handleKey(AndroidKeycodeToSkKey(keyCode));
+ handled |= gWindow->handleChar((SkUnichar) uni);
+ return handled;
+}
+
+JNIEXPORT bool JNICALL Java_com_skia_sampleapp_SampleApp_handleKeyUp(JNIEnv* env,
+ jobject thiz, jint keyCode)
+{
+ return gWindow->handleKeyUp(AndroidKeycodeToSkKey(keyCode));
+}
+
+JNIEXPORT void JNICALL Java_com_skia_sampleapp_SampleApp_handleClick(JNIEnv* env,
+ jobject thiz, jint x, jint y, jint jstate)
+{
+ SkView::Click::State state;
+ switch(jstate) {
+ case 0: // MotionEvent.ACTION_DOWN
+ state = SkView::Click::kDown_State;
+ break;
+ case 1: // MotionEvent.ACTION_UP
+ case 3: // MotionEvent.ACTION_CANCEL
+ state = SkView::Click::kUp_State;
+ break;
+ case 2: // MotionEvent.ACTION_MOVE
+ state = SkView::Click::kMoved_State;
+ break;
+ default:
+ SkDebugf("motion event ignored\n");
+ return;
+ }
+ gWindow->handleClick(x, y, state);
+}
+
+JNIEXPORT void JNICALL Java_com_skia_sampleapp_SampleApp_updateSize(JNIEnv* env,
+ jobject thiz, jint w, jint h)
+{
+ gWindow->resize(w, h);
+}
+
+JNIEXPORT void JNICALL Java_com_skia_sampleapp_SampleApp_createOSWindow(
+ JNIEnv* env, jobject thiz, jobject jsampleView)
+{
+ gWindow = create_sk_window(NULL);
+ // Only using a method on View.
+ jclass clazz = gActivityGlue.m_env->FindClass("android/view/View");
+ gWindowGlue.m_obj = gActivityGlue.m_env->NewWeakGlobalRef(jsampleView);
+ gWindowGlue.m_inval = GetJMethod(gActivityGlue.m_env, clazz, "invalidate",
+ "(IIII)V");
+ gActivityGlue.m_env->DeleteLocalRef(clazz);
+}
+
+JNIEXPORT void JNICALL Java_com_skia_sampleapp_SampleApp_init(JNIEnv* env,
+ jobject thiz)
+{
+ gActivityGlue.m_env = env;
+ // Only using a method on Activity.
+ jclass clazz = env->FindClass("android/app/Activity");
+ gActivityGlue.m_obj = env->NewWeakGlobalRef(thiz);
+ gActivityGlue.m_setTitle = GetJMethod(env, clazz, "setTitle",
+ "(Ljava/lang/CharSequence;)V");
+ env->DeleteLocalRef(clazz);
+
+ application_init();
+}
+
+JNIEXPORT void JNICALL Java_com_skia_sampleapp_SampleApp_term(JNIEnv* env,
+ jobject thiz)
+{
+ application_term();
+ if (gWindowGlue.m_obj) {
+ env->DeleteWeakGlobalRef(gWindowGlue.m_obj);
+ gWindowGlue.m_obj = NULL;
+ }
+ if (gActivityGlue.m_obj) {
+ env->DeleteWeakGlobalRef(gActivityGlue.m_obj);
+ gActivityGlue.m_obj = NULL;
+ }
+ delete gWindow;
+ gWindow = NULL;
+}
+
+
+JNIEXPORT void JNICALL Java_com_skia_sampleapp_SampleApp_drawToCanvas(
+ JNIEnv* env, jobject thiz, jobject jcanvas)
+{
+ if (!gWindow) return;
+ gWindow->update(NULL);
+ SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas);
+ canvas->drawBitmap(gWindow->getBitmap(), 0, 0);
+}
diff --git a/android_sample/SampleApp/res/layout/layout.xml b/android_sample/SampleApp/res/layout/layout.xml
new file mode 100644
index 0000000..d71116b
--- /dev/null
+++ b/android_sample/SampleApp/res/layout/layout.xml
@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2011 Skia
+
+ 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"
+ android:id="@+id/holder"
+ android:orientation="vertical"
+ android:layout_width="match_parent"
+ android:layout_height="wrap_content">
+ <TextView android:id="@+id/title_view"
+ android:layout_width="match_parent"
+ android:layout_height="wrap_content"
+ />
+</LinearLayout>
+
diff --git a/android_sample/SampleApp/res/values/strings.xml b/android_sample/SampleApp/res/values/strings.xml
new file mode 100644
index 0000000..72d3bc8
--- /dev/null
+++ b/android_sample/SampleApp/res/values/strings.xml
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2011 Skia
+
+ 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.
+-->
+<resources>
+ <string name="app_name">SampleApp</string>
+</resources>
diff --git a/android_sample/SampleApp/src/com/skia/sampleapp/SampleApp.java b/android_sample/SampleApp/src/com/skia/sampleapp/SampleApp.java
new file mode 100644
index 0000000..b02c4d7
--- /dev/null
+++ b/android_sample/SampleApp/src/com/skia/sampleapp/SampleApp.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright (C) 2011 Skia
+ *
+ * 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.skia.sampleapp;
+
+import android.app.Activity;
+import android.content.Context;
+import android.graphics.Canvas;
+import android.os.Bundle;
+import android.util.AttributeSet;
+import android.view.KeyEvent;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+
+public class SampleApp extends Activity
+{
+ private TextView mTitle;
+
+ public class SampleView extends View {
+ public SampleView(Context context) {
+ super(context);
+ createOSWindow(this);
+ }
+
+ @Override
+ protected void onDraw(Canvas canvas) {
+ drawToCanvas(canvas);
+ }
+
+ @Override
+ protected void onSizeChanged(int w, int h, int oldw, int oldh) {
+ updateSize(w, h);
+ }
+
+ @Override
+ public boolean onTouchEvent(MotionEvent event) {
+ final int x = (int) event.getX();
+ final int y = (int) event.getY();
+ final int action = event.getAction();
+ handleClick(x, y, action);
+ return true;
+ }
+ }
+
+ @Override
+ public void onCreate(Bundle savedInstanceState)
+ {
+ super.onCreate(savedInstanceState);
+
+ init();
+ setContentView(R.layout.layout);
+ mTitle = (TextView) findViewById(R.id.title_view);
+ LinearLayout holder = (LinearLayout) findViewById(R.id.holder);
+ View view = new SampleView(this);
+ holder.addView(view, new LinearLayout.LayoutParams(
+ ViewGroup.LayoutParams.MATCH_PARENT,
+ ViewGroup.LayoutParams.MATCH_PARENT));
+ }
+
+ @Override
+ public void onDestroy()
+ {
+ term();
+ super.onDestroy();
+ }
+
+ @Override
+ public boolean dispatchKeyEvent(KeyEvent event) {
+ switch (event.getAction()) {
+ case KeyEvent.ACTION_DOWN:
+ int uni = event.getUnicodeChar(event.getMetaState());
+ return handleKeyDown(event.getKeyCode(), uni);
+ case KeyEvent.ACTION_UP:
+ return handleKeyUp(event.getKeyCode());
+ default:
+ return false;
+ }
+ }
+
+ @Override
+ public void setTitle(CharSequence title) {
+ mTitle.setText(title);
+ }
+
+ private native void drawToCanvas(Canvas canvas);
+ private native void init();
+ private native void term();
+ // Currently depends on init having already been called.
+ private native void createOSWindow(SampleView view);
+ private native void updateSize(int w, int h);
+ private native void handleClick(int x, int y, int state);
+ private native boolean handleKeyDown(int key, int uni);
+ private native boolean handleKeyUp(int key);
+
+ static {
+ System.loadLibrary("skia-sample");
+ }
+}
diff --git a/bench/Android.mk b/bench/Android.mk
index b20aef9..71523af 100644
--- a/bench/Android.mk
+++ b/bench/Android.mk
@@ -6,6 +6,9 @@
BitmapBench.cpp \
DecodeBench.cpp \
FPSBench.cpp \
+ GradientBench.cpp \
+ MatrixBench.cpp \
+ PathBench.cpp \
RectBench.cpp \
RepeatTileBench.cpp \
TextBench.cpp \
@@ -17,7 +20,8 @@
../src/utils/SkNWayCanvas.cpp \
../src/utils/SkParse.cpp
-LOCAL_SHARED_LIBRARIES := libcutils libskia
+LOCAL_SHARED_LIBRARIES := libcutils libskia libGLESv2
+LOCAL_STATIC_LIBRARIES := libskiagpu
LOCAL_C_INCLUDES := \
external/skia/include/config \
external/skia/include/core \
diff --git a/bench/MatrixBench.cpp b/bench/MatrixBench.cpp
new file mode 100644
index 0000000..d963bc7
--- /dev/null
+++ b/bench/MatrixBench.cpp
@@ -0,0 +1,229 @@
+#include "SkBenchmark.h"
+#include "SkMatrix.h"
+#include "SkRandom.h"
+#include "SkString.h"
+
+class MatrixBench : public SkBenchmark {
+ SkString fName;
+ enum { N = 100000 };
+public:
+ MatrixBench(void* param, const char name[]) : INHERITED(param) {
+ fName.printf("matrix_%s", name);
+ }
+
+ virtual void performTest() = 0;
+
+protected:
+ virtual int mulLoopCount() const { return 1; }
+
+ virtual const char* onGetName() {
+ return fName.c_str();
+ }
+
+ virtual void onDraw(SkCanvas* canvas) {
+ int n = N * this->mulLoopCount();
+ for (int i = 0; i < n; i++) {
+ this->performTest();
+ }
+ }
+
+private:
+ typedef SkBenchmark INHERITED;
+};
+
+// we want to stop the compiler from eliminating code that it thinks is a no-op
+// so we have a non-static global we increment, hoping that will convince the
+// compiler to execute everything
+int gMatrixBench_NonStaticGlobal;
+
+#define always_do(pred) \
+ do { \
+ if (pred) { \
+ ++gMatrixBench_NonStaticGlobal; \
+ } \
+ } while (0)
+
+class EqualsMatrixBench : public MatrixBench {
+public:
+ EqualsMatrixBench(void* param) : INHERITED(param, "equals") {}
+protected:
+ virtual void performTest() {
+ SkMatrix m0, m1, m2;
+
+ m0.reset();
+ m1.reset();
+ m2.reset();
+ always_do(m0 == m1);
+ always_do(m1 == m2);
+ always_do(m2 == m0);
+ always_do(m0.getType());
+ always_do(m1.getType());
+ always_do(m2.getType());
+ }
+private:
+ typedef MatrixBench INHERITED;
+};
+
+class ScaleMatrixBench : public MatrixBench {
+public:
+ ScaleMatrixBench(void* param) : INHERITED(param, "scale") {
+
+ fM0.reset();
+ fM1.setScale(fSX, fSY);
+ fM2.setTranslate(fSX, fSY);
+ fSX = fSY = SkFloatToScalar(1.5f);
+ }
+protected:
+ virtual void performTest() {
+ SkMatrix m;
+ m = fM0; m.preScale(fSX, fSY);
+ m = fM1; m.preScale(fSX, fSY);
+ m = fM2; m.preScale(fSX, fSY);
+ }
+private:
+ SkMatrix fM0, fM1, fM2;
+ SkScalar fSX, fSY;
+ typedef MatrixBench INHERITED;
+};
+
+// having unknown values in our arrays can throw off the timing a lot, perhaps
+// handling NaN values is a lot slower. Anyway, this guy is just meant to put
+// reasonable values in our arrays.
+template <typename T> void init9(T array[9]) {
+ SkRandom rand;
+ for (int i = 0; i < 9; i++) {
+ array[i] = rand.nextSScalar1();
+ }
+}
+
+// Test the performance of setConcat() non-perspective case:
+// using floating point precision only.
+class FloatConcatMatrixBench : public MatrixBench {
+public:
+ FloatConcatMatrixBench(void* p) : INHERITED(p, "concat_floatfloat") {
+ init9(mya);
+ init9(myb);
+ init9(myr);
+ }
+protected:
+ virtual int mulLoopCount() const { return 4; }
+
+ static inline void muladdmul(float a, float b, float c, float d,
+ float* result) {
+ *result = a * b + c * d;
+ }
+ virtual void performTest() {
+ const float* a = mya;
+ const float* b = myb;
+ float* r = myr;
+ muladdmul(a[0], b[0], a[1], b[3], &r[0]);
+ muladdmul(a[0], b[1], a[1], b[4], &r[1]);
+ muladdmul(a[0], b[2], a[1], b[5], &r[2]);
+ r[2] += a[2];
+ muladdmul(a[3], b[0], a[4], b[3], &r[3]);
+ muladdmul(a[3], b[1], a[4], b[4], &r[4]);
+ muladdmul(a[3], b[2], a[4], b[5], &r[5]);
+ r[5] += a[5];
+ r[6] = r[7] = 0.0f;
+ r[8] = 1.0f;
+ }
+private:
+ float mya [9];
+ float myb [9];
+ float myr [9];
+ typedef MatrixBench INHERITED;
+};
+
+static inline float SkDoubleToFloat(double x) {
+ return static_cast<float>(x);
+}
+
+// Test the performance of setConcat() non-perspective case:
+// using floating point precision but casting up to float for
+// intermediate results during computations.
+class FloatDoubleConcatMatrixBench : public MatrixBench {
+public:
+ FloatDoubleConcatMatrixBench(void* p) : INHERITED(p, "concat_floatdouble") {
+ init9(mya);
+ init9(myb);
+ init9(myr);
+ }
+protected:
+ virtual int mulLoopCount() const { return 4; }
+
+ static inline void muladdmul(float a, float b, float c, float d,
+ float* result) {
+ *result = SkDoubleToFloat((double)a * b + (double)c * d);
+ }
+ virtual void performTest() {
+ const float* a = mya;
+ const float* b = myb;
+ float* r = myr;
+ muladdmul(a[0], b[0], a[1], b[3], &r[0]);
+ muladdmul(a[0], b[1], a[1], b[4], &r[1]);
+ muladdmul(a[0], b[2], a[1], b[5], &r[2]);
+ r[2] += a[2];
+ muladdmul(a[3], b[0], a[4], b[3], &r[3]);
+ muladdmul(a[3], b[1], a[4], b[4], &r[4]);
+ muladdmul(a[3], b[2], a[4], b[5], &r[5]);
+ r[5] += a[5];
+ r[6] = r[7] = 0.0f;
+ r[8] = 1.0f;
+ }
+private:
+ float mya [9];
+ float myb [9];
+ float myr [9];
+ typedef MatrixBench INHERITED;
+};
+
+// Test the performance of setConcat() non-perspective case:
+// using double precision only.
+class DoubleConcatMatrixBench : public MatrixBench {
+public:
+ DoubleConcatMatrixBench(void* p) : INHERITED(p, "concat_double") {
+ init9(mya);
+ init9(myb);
+ init9(myr);
+ }
+protected:
+ virtual int mulLoopCount() const { return 4; }
+
+ static inline void muladdmul(double a, double b, double c, double d,
+ double* result) {
+ *result = a * b + c * d;
+ }
+ virtual void performTest() {
+ const double* a = mya;
+ const double* b = myb;
+ double* r = myr;
+ muladdmul(a[0], b[0], a[1], b[3], &r[0]);
+ muladdmul(a[0], b[1], a[1], b[4], &r[1]);
+ muladdmul(a[0], b[2], a[1], b[5], &r[2]);
+ r[2] += a[2];
+ muladdmul(a[3], b[0], a[4], b[3], &r[3]);
+ muladdmul(a[3], b[1], a[4], b[4], &r[4]);
+ muladdmul(a[3], b[2], a[4], b[5], &r[5]);
+ r[5] += a[5];
+ r[6] = r[7] = 0.0;
+ r[8] = 1.0;
+ }
+private:
+ double mya [9];
+ double myb [9];
+ double myr [9];
+ typedef MatrixBench INHERITED;
+};
+
+
+static SkBenchmark* M0(void* p) { return new EqualsMatrixBench(p); }
+static SkBenchmark* M1(void* p) { return new ScaleMatrixBench(p); }
+static SkBenchmark* M2(void* p) { return new FloatConcatMatrixBench(p); }
+static SkBenchmark* M3(void* p) { return new FloatDoubleConcatMatrixBench(p); }
+static SkBenchmark* M4(void* p) { return new DoubleConcatMatrixBench(p); }
+
+static BenchRegistry gReg0(M0);
+static BenchRegistry gReg1(M1);
+static BenchRegistry gReg2(M2);
+static BenchRegistry gReg3(M3);
+static BenchRegistry gReg4(M4);
diff --git a/bench/bench_compare.py b/bench/bench_compare.py
new file mode 100644
index 0000000..f6909b1
--- /dev/null
+++ b/bench/bench_compare.py
@@ -0,0 +1,140 @@
+'''
+Created on May 16, 2011
+
+@author: bungeman
+'''
+import sys
+import getopt
+import re
+
+def parse(lines):
+ """Takes iterable lines of bench output, returns {bench:{config:time}}."""
+
+ benches = {}
+ current_bench = None
+
+ for line in lines:
+ #see if this line starts a new bench
+ new_bench = re.search('running bench \[\d+ \d+\] (.{28})', line)
+ if new_bench:
+ current_bench = new_bench.group(1)
+
+ #add configs on this line to the current bench
+ if current_bench:
+ for new_config in re.finditer(' (.{4}): msecs = (\d+\.\d+)', line):
+ current_config = new_config.group(1)
+ current_time = float(new_config.group(2))
+ if current_bench in benches:
+ benches[current_bench][current_config] = current_time
+ else:
+ benches[current_bench] = {current_config : current_time}
+
+ return benches
+
+def usage():
+ """Prints simple usage information."""
+
+ print '-o <file> the old bench output file.'
+ print '-n <file> the new bench output file.'
+ print '-h causes headers to be output.'
+ print '-f <fieldSpec> which fields to output and in what order.'
+ print ' Not specifying is the same as -f "bcondp".'
+ print ' b: bench'
+ print ' c: config'
+ print ' o: old time'
+ print ' n: new time'
+ print ' d: diff'
+ print ' p: percent diff'
+
+
+def main():
+ """Parses command line and writes output."""
+
+ try:
+ opts, args = getopt.getopt(sys.argv[1:], "f:o:n:h")
+ except getopt.GetoptError, err:
+ print str(err)
+ usage()
+ sys.exit(2)
+
+ column_formats = {
+ 'b' : '{bench: >28} ',
+ 'c' : '{config: <4} ',
+ 'o' : '{old_time: >10.2f} ',
+ 'n' : '{new_time: >10.2f} ',
+ 'd' : '{diff: >+10.2f} ',
+ 'p' : '{diffp: >+7.1%} ',
+ }
+ header_formats = {
+ 'b' : '{bench: >28} ',
+ 'c' : '{config: <4} ',
+ 'o' : '{old_time: >10} ',
+ 'n' : '{new_time: >10} ',
+ 'd' : '{diff: >10} ',
+ 'p' : '{diffp: >7} ',
+ }
+
+ old = None
+ new = None
+ column_format = ""
+ header_format = ""
+ columns = 'bcondp'
+ header = False
+
+ for option, value in opts:
+ if option == "-o":
+ old = value
+ elif option == "-n":
+ new = value
+ elif option == "-h":
+ header = True
+ elif option == "-f":
+ columns = value
+ else:
+ usage()
+ assert False, "unhandled option"
+
+ if old is None or new is None:
+ usage()
+ sys.exit(2)
+
+ for column_char in columns:
+ if column_formats[column_char]:
+ column_format += column_formats[column_char]
+ header_format += header_formats[column_char]
+ else:
+ usage()
+ sys.exit(2)
+
+ if header:
+ print header_format.format(
+ bench='bench'
+ , config='conf'
+ , old_time='old'
+ , new_time='new'
+ , diff='diff'
+ , diffp='diffP'
+ )
+
+ old_benches = parse(open(old, 'r'))
+ new_benches = parse(open(new, 'r'))
+
+ for old_bench, old_configs in old_benches.items():
+ if old_bench in new_benches:
+ new_configs = new_benches[old_bench]
+ for old_config, old_time in old_configs.items():
+ if old_config in new_configs:
+ new_time = new_configs[old_config]
+ old_time = old_configs[old_config]
+ print column_format.format(
+ bench=old_bench.strip()
+ , config=old_config.strip()
+ , old_time=old_time
+ , new_time=new_time
+ , diff=(old_time - new_time)
+ , diffp=((old_time-new_time)/old_time)
+ )
+
+
+if __name__ == "__main__":
+ main()
diff --git a/bench/benchmain.cpp b/bench/benchmain.cpp
index 4f6d81c..066573a 100644
--- a/bench/benchmain.cpp
+++ b/bench/benchmain.cpp
@@ -6,6 +6,9 @@
#include "SkPicture.h"
#include "SkString.h"
#include "SkTime.h"
+#include "GrContext.h"
+#include "SkGpuDevice.h"
+#include "SkEGLContext.h"
#include "SkBenchmark.h"
@@ -30,6 +33,7 @@
}
}
+#if 0
static bool equal(const SkBitmap& bm1, const SkBitmap& bm2) {
if (bm1.width() != bm2.width() ||
bm1.height() != bm2.height() ||
@@ -43,9 +47,9 @@
return false;
}
}
-
return true;
}
+#endif
class Iter {
public:
@@ -62,7 +66,7 @@
}
return NULL;
}
-
+
private:
const BenchRegistry* fBench;
void* fParam;
@@ -102,7 +106,7 @@
*p++ = c | (SK_A32_MASK << SK_A32_SHIFT);
}
}
-
+
SkString str;
make_filename(name, &str);
str.appendf("_%s.png", config);
@@ -118,7 +122,7 @@
r.set(SkIntToScalar(10), SkIntToScalar(10),
SkIntToScalar(w*2/3), SkIntToScalar(h*2/3));
canvas->clipRect(r, SkRegion::kIntersect_Op);
-
+
r.set(SkIntToScalar(w/3), SkIntToScalar(h/3),
SkIntToScalar(w-10), SkIntToScalar(h-10));
canvas->clipRect(r, SkRegion::kXOR_Op);
@@ -143,21 +147,6 @@
canvas->translate(-x, -y);
}
-static void compare_pict_to_bitmap(SkPicture* pict, const SkBitmap& bm) {
- SkBitmap bm2;
-
- bm2.setConfig(bm.config(), bm.width(), bm.height());
- bm2.allocPixels();
- erase(bm2);
-
- SkCanvas canvas(bm2);
- canvas.drawPicture(*pict);
-
- if (!equal(bm, bm2)) {
- SkDebugf("----- compare_pict_to_bitmap failed\n");
- }
-}
-
static bool parse_bool_arg(char * const* argv, char* const* stop, bool* var) {
if (argv < stop) {
*var = atoi(*argv) != 0;
@@ -166,16 +155,43 @@
return false;
}
+enum Backend {
+ kRaster_Backend,
+ kGPU_Backend,
+ kPDF_Backend,
+};
+
+static SkDevice* make_device(SkBitmap::Config config, const SkIPoint& size,
+ Backend backend, GrContext* context) {
+ SkDevice* device = NULL;
+ SkBitmap bitmap;
+ bitmap.setConfig(config, size.fX, size.fY);
+
+ switch (backend) {
+ case kRaster_Backend:
+ bitmap.allocPixels();
+ erase(bitmap);
+ device = new SkDevice(NULL, bitmap, true);
+ break;
+ case kGPU_Backend:
+ device = new SkGpuDevice(context, bitmap, SkGpuDevice::Current3DApiRenderTarget());
+// device->clear(0xFFFFFFFF);
+ break;
+ case kPDF_Backend:
+ default:
+ SkASSERT(!"unsupported");
+ }
+ return device;
+}
+
static const struct {
SkBitmap::Config fConfig;
const char* fName;
+ Backend fBackend;
} gConfigs[] = {
- { SkBitmap::kARGB_8888_Config, "8888" },
- { SkBitmap::kRGB_565_Config, "565", },
-#if 0
- { SkBitmap::kARGB_4444_Config, "4444", },
- { SkBitmap::kA8_Config, "A8", }
-#endif
+ { SkBitmap::kARGB_8888_Config, "8888", kRaster_Backend },
+ { SkBitmap::kRGB_565_Config, "565", kRaster_Backend },
+ { SkBitmap::kARGB_8888_Config, "GPU", kGPU_Backend },
};
static int findConfig(const char config[]) {
@@ -189,7 +205,7 @@
int main (int argc, char * const argv[]) {
SkAutoGraphics ag;
-
+
SkTDict<const char*> defineDict(1024);
int repeatDraw = 1;
int forceAlpha = 0xFF;
@@ -199,16 +215,16 @@
bool doScale = false;
bool doRotate = false;
bool doClip = false;
- bool doPict = false;
const char* matchStr = NULL;
bool hasStrokeWidth = false;
float strokeWidth;
-
+
SkString outDir;
SkBitmap::Config outConfig = SkBitmap::kNo_Config;
const char* configName = "";
+ Backend backend = kRaster_Backend; // for warning
int configCount = SK_ARRAY_COUNT(gConfigs);
-
+
char* const* stop = argv + argc;
for (++argv; argv < stop; ++argv) {
if (strcmp(*argv, "-o") == 0) {
@@ -219,8 +235,6 @@
outDir.append("/");
}
}
- } else if (strcmp(*argv, "-pict") == 0) {
- doPict = true;
} else if (strcmp(*argv, "-repeat") == 0) {
argv++;
if (argv < stop) {
@@ -290,6 +304,7 @@
if (index >= 0) {
outConfig = gConfigs[index].fConfig;
configName = gConfigs[index].fName;
+ backend = gConfigs[index].fBackend;
configCount = 1;
} else {
SkString str;
@@ -316,7 +331,7 @@
return -1;
}
}
-
+
// report our current settings
{
SkString str;
@@ -324,7 +339,13 @@
forceAlpha, forceAA, forceFilter);
log_progress(str);
}
-
+
+ GrContext* context = NULL;
+ SkEGLContext eglContext;
+ if (eglContext.init(1024, 1024)) {
+ context = GrContext::CreateGLShaderContext();
+ }
+
Iter iter(&defineDict);
SkBenchmark* bench;
while ((bench = iter.next()) != NULL) {
@@ -340,32 +361,34 @@
if (hasStrokeWidth) {
bench->setStrokeWidth(strokeWidth);
}
-
+
// only run benchmarks if their name contains matchStr
if (matchStr && strstr(bench->getName(), matchStr) == NULL) {
continue;
}
-
+
{
SkString str;
str.printf("running bench [%d %d] %28s", dim.fX, dim.fY,
bench->getName());
log_progress(str);
}
-
+
for (int configIndex = 0; configIndex < configCount; configIndex++) {
if (configCount > 1) {
outConfig = gConfigs[configIndex].fConfig;
configName = gConfigs[configIndex].fName;
+ backend = gConfigs[configIndex].fBackend;
}
- SkBitmap bm;
- bm.setConfig(outConfig, dim.fX, dim.fY);
- bm.allocPixels();
- erase(bm);
-
- SkCanvas canvas(bm);
-
+ if (kGPU_Backend == backend && NULL == context) {
+ continue;
+ }
+
+ SkDevice* device = make_device(outConfig, dim, backend, context);
+ SkCanvas canvas(device);
+ device->unref();
+
if (doClip) {
performClip(&canvas, dim.fX, dim.fY);
}
@@ -375,33 +398,27 @@
if (doRotate) {
performRotate(&canvas, dim.fX, dim.fY);
}
-
+
+ //warm up caches if needed
if (repeatDraw > 1) {
SkAutoCanvasRestore acr(&canvas, true);
bench->draw(&canvas);
+ if (kGPU_Backend == backend && context) {
+ context->flush();
+ glFinish();
+ }
}
-
+
SkMSec now = SkTime::GetMSecs();
for (int i = 0; i < repeatDraw; i++) {
- SkCanvas* c = &canvas;
-
- SkNWayCanvas nway;
- SkPicture* pict = NULL;
- if (doPict) {
- pict = new SkPicture;
- nway.addCanvas(pict->beginRecording(bm.width(), bm.height()));
- nway.addCanvas(&canvas);
- c = &nway;
- }
-
- SkAutoCanvasRestore acr(c, true);
- bench->draw(c);
-
- if (pict) {
- compare_pict_to_bitmap(pict, bm);
- pict->unref();
- }
+ SkAutoCanvasRestore acr(&canvas, true);
+ bench->draw(&canvas);
}
+ if (kGPU_Backend == backend && context) {
+ context->flush();
+ glFinish();
+ }
+
if (repeatDraw > 1) {
double duration = SkTime::GetMSecs() - now;
SkString str;
@@ -409,7 +426,8 @@
log_progress(str);
}
if (outDir.size() > 0) {
- saveFile(bench->getName(), configName, outDir.c_str(), bm);
+ saveFile(bench->getName(), configName, outDir.c_str(),
+ device->accessBitmap(false));
}
}
log_progress("\n");
diff --git a/gm/Android.mk b/gm/Android.mk
index b3aeadf..acfb4a5 100644
--- a/gm/Android.mk
+++ b/gm/Android.mk
@@ -8,6 +8,7 @@
complexclip.cpp \
filltypes.cpp \
gradients.cpp \
+ nocolorbleed.cpp \
pathfill.cpp \
points.cpp \
poly2poly.cpp \
diff --git a/gm/bitmapfilters.cpp b/gm/bitmapfilters.cpp
index 0487fe6..3903913 100644
--- a/gm/bitmapfilters.cpp
+++ b/gm/bitmapfilters.cpp
@@ -3,15 +3,20 @@
namespace skiagm {
static void make_bm(SkBitmap* bm) {
- const SkColor colors[] = {
+ const SkColor colors[4] = {
SK_ColorRED, SK_ColorGREEN,
SK_ColorBLUE, SK_ColorWHITE
};
- SkColorTable* ctable = new SkColorTable(colors, 4);
+ SkPMColor colorsPM[4];
+ for (size_t i = 0; i < SK_ARRAY_COUNT(colors); ++i) {
+ colorsPM[i] = SkPreMultiplyColor(colors[i]);
+ }
+ SkColorTable* ctable = new SkColorTable(colorsPM, 4);
+
bm->setConfig(SkBitmap::kIndex8_Config, 2, 2);
bm->allocPixels(ctable);
ctable->unref();
-
+
*bm->getAddr8(0, 0) = 0;
*bm->getAddr8(1, 0) = 1;
*bm->getAddr8(0, 1) = 2;
@@ -57,7 +62,7 @@
canvas->translate(SkIntToScalar(48), 0);
canvas->scale(SkIntToScalar(scale), SkIntToScalar(scale));
-
+
x += draw_set(canvas, bm, 0, &paint);
paint.reset();
paint.setAlpha(0x80);
@@ -90,7 +95,7 @@
SkScalar x = SkIntToScalar(10);
SkScalar y = SkIntToScalar(10);
-
+
canvas->translate(x, y);
y = draw_row(canvas, fBM8);
canvas->translate(0, y);
@@ -100,7 +105,7 @@
canvas->translate(0, y);
draw_row(canvas, fBM32);
}
-
+
private:
typedef GM INHERITED;
};
diff --git a/gm/blurs.cpp b/gm/blurs.cpp
index 26fdc79..c934178 100644
--- a/gm/blurs.cpp
+++ b/gm/blurs.cpp
@@ -5,14 +5,14 @@
class BlursGM : public GM {
public:
- BlursGM() {}
+ BlursGM() {}
protected:
virtual SkString onShortName() {
return SkString("blurs");
}
- virtual SkISize onISize() {
+ virtual SkISize onISize() {
return make_isize(700, 500);
}
@@ -37,8 +37,8 @@
SkPaint paint;
paint.setAntiAlias(true);
- paint.setTextSize(25);
- canvas->translate(-40, 0);
+ paint.setTextSize(SkIntToScalar(25));
+ canvas->translate(SkIntToScalar(-40), SkIntToScalar(0));
SkBlurMaskFilter::BlurFlags flags = SkBlurMaskFilter::kNone_BlurFlag;
for (int j = 0; j < 2; j++) {
@@ -46,27 +46,32 @@
paint.setColor(SK_ColorBLUE);
for (size_t i = 0; i < SK_ARRAY_COUNT(gRecs); i++) {
if (gRecs[i].fStyle != NONE) {
- SkMaskFilter* mf = SkBlurMaskFilter::Create(20,
- gRecs[i].fStyle,
- flags);
+ SkMaskFilter* mf = SkBlurMaskFilter::Create(
+ SkIntToScalar(20), gRecs[i].fStyle, flags
+ );
paint.setMaskFilter(mf)->unref();
} else {
paint.setMaskFilter(NULL);
}
- canvas->drawCircle(200 + gRecs[i].fCx*100,
- 200 + gRecs[i].fCy*100, 50, paint);
+ canvas->drawCircle(SkIntToScalar(200 + gRecs[i].fCx*100)
+ , SkIntToScalar(200 + gRecs[i].fCy*100)
+ , SkIntToScalar(50)
+ , paint);
}
// draw text
{
- SkMaskFilter* mf = SkBlurMaskFilter::Create(4,
- SkBlurMaskFilter::kNormal_BlurStyle,
- flags);
+ SkMaskFilter* mf = SkBlurMaskFilter::Create(
+ SkIntToScalar(4)
+ , SkBlurMaskFilter::kNormal_BlurStyle
+ , flags
+ );
paint.setMaskFilter(mf)->unref();
SkScalar x = SkIntToScalar(70);
SkScalar y = SkIntToScalar(400);
paint.setColor(SK_ColorBLACK);
canvas->drawText("Hamburgefons Style", 18, x, y, paint);
- canvas->drawText("Hamburgefons Style", 18, x, y + SkIntToScalar(50), paint);
+ canvas->drawText("Hamburgefons Style", 18
+ , x, y + SkIntToScalar(50), paint);
paint.setMaskFilter(NULL);
paint.setColor(SK_ColorWHITE);
x -= SkIntToScalar(2);
@@ -75,7 +80,7 @@
}
canvas->restore();
flags = SkBlurMaskFilter::kHighQuality_BlurFlag;
- canvas->translate(350, 0);
+ canvas->translate(SkIntToScalar(350), SkIntToScalar(0));
}
}
diff --git a/gm/gm_files.mk b/gm/gm_files.mk
index e867820..fec20b6 100644
--- a/gm/gm_files.mk
+++ b/gm/gm_files.mk
@@ -3,6 +3,7 @@
blurs.cpp \
filltypes.cpp \
gradients.cpp \
+ nocolorbleed.cpp \
pathfill.cpp \
points.cpp \
poly2poly.cpp \
diff --git a/gm/gmmain.cpp b/gm/gmmain.cpp
index 6267fd4..ea205e3 100644
--- a/gm/gmmain.cpp
+++ b/gm/gmmain.cpp
@@ -441,7 +441,7 @@
const char* readPath = NULL; // if non-null, were we read from to compare
const char* diffPath = NULL; // if non-null, where we write our diffs (from compare)
- bool doReplay = false;
+ bool doReplay = true;
bool doSerialize = false;
const char* const commandName = argv[0];
char* const* stop = argv + argc;
@@ -461,8 +461,8 @@
if (argv < stop && **argv) {
diffPath = *argv;
}
- } else if (strcmp(*argv, "--replay") == 0) {
- doReplay = true;
+ } else if (strcmp(*argv, "--noreplay") == 0) {
+ doReplay = false;
} else if (strcmp(*argv, "--serialize") == 0) {
doSerialize = true;
} else {
diff --git a/gm/nocolorbleed.cpp b/gm/nocolorbleed.cpp
new file mode 100755
index 0000000..3dec7cc
--- /dev/null
+++ b/gm/nocolorbleed.cpp
@@ -0,0 +1,75 @@
+#include "gm.h"
+
+namespace skiagm {
+
+class NoColorBleedGM : public GM {
+public:
+ NoColorBleedGM() {}
+
+protected:
+ virtual SkString onShortName() {
+ return SkString("nocolorbleed");
+ }
+
+ virtual SkISize onISize() {
+ return make_isize(200, 200);
+ }
+
+ void drawBG(SkCanvas* canvas) {
+ canvas->drawColor(0xFFDDDDDD);
+ }
+
+ virtual void onDraw(SkCanvas* canvas) {
+ drawBG(canvas);
+
+ SkBitmap sprite;
+ sprite.setConfig(SkBitmap::kARGB_8888_Config, 4, 4, 4*sizeof(SkColor));
+ const SkColor spriteData[16] = {
+ SK_ColorBLACK, SK_ColorCYAN, SK_ColorMAGENTA, SK_ColorYELLOW,
+ SK_ColorBLACK, SK_ColorWHITE, SK_ColorBLACK, SK_ColorRED,
+ SK_ColorGREEN, SK_ColorBLACK, SK_ColorWHITE, SK_ColorBLUE,
+ SK_ColorYELLOW, SK_ColorMAGENTA, SK_ColorCYAN, SK_ColorBLACK
+ };
+ sprite.allocPixels();
+ sprite.lockPixels();
+ SkPMColor* addr = sprite.getAddr32(0, 0);
+ for (size_t i = 0; i < SK_ARRAY_COUNT(spriteData); ++i) {
+ addr[i] = SkPreMultiplyColor(spriteData[i]);
+ }
+ sprite.unlockPixels();
+
+ // We draw a magnified subrect of the sprite
+ // sample interpolation may cause color bleeding around edges
+ // the subrect is a pure white area
+ SkIRect srcRect;
+ SkRect dstRect;
+ SkPaint paint;
+ paint.setFilterBitmap(true);
+ //First row : full texture with and without filtering
+ srcRect.setXYWH(0, 0, 4, 4);
+ dstRect.setXYWH(SkIntToScalar(0), SkIntToScalar(0)
+ , SkIntToScalar(100), SkIntToScalar(100));
+ canvas->drawBitmapRect(sprite, &srcRect, dstRect, &paint);
+ dstRect.setXYWH(SkIntToScalar(100), SkIntToScalar(0)
+ , SkIntToScalar(100), SkIntToScalar(100));
+ canvas->drawBitmapRect(sprite, &srcRect, dstRect);
+ //Second row : sub rect of texture with and without filtering
+ srcRect.setXYWH(1, 1, 2, 2);
+ dstRect.setXYWH(SkIntToScalar(25), SkIntToScalar(125)
+ , SkIntToScalar(50), SkIntToScalar(50));
+ canvas->drawBitmapRect(sprite, &srcRect, dstRect, &paint);
+ dstRect.setXYWH(SkIntToScalar(125), SkIntToScalar(125)
+ , SkIntToScalar(50), SkIntToScalar(50));
+ canvas->drawBitmapRect(sprite, &srcRect, dstRect);
+ }
+
+private:
+ typedef GM INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static GM* MyFactory(void*) { return new NoColorBleedGM; }
+static GMRegistry reg(MyFactory);
+
+}
diff --git a/gm/pathfill.cpp b/gm/pathfill.cpp
index ec56942..713847f 100644
--- a/gm/pathfill.cpp
+++ b/gm/pathfill.cpp
@@ -6,14 +6,15 @@
typedef SkScalar (*MakePathProc)(SkPath*);
static SkScalar make_frame(SkPath* path) {
- SkRect r = { 10, 10, 630, 470 };
- path->addRoundRect(r, 15, 15);
+ SkRect r = { SkIntToScalar(10), SkIntToScalar(10),
+ SkIntToScalar(630), SkIntToScalar(470) };
+ path->addRoundRect(r, SkIntToScalar(15), SkIntToScalar(15));
SkPaint paint;
paint.setStyle(SkPaint::kStroke_Style);
- paint.setStrokeWidth(5);
+ paint.setStrokeWidth(SkIntToScalar(5));
paint.getFillPath(*path, path);
- return 15;
+ return SkIntToScalar(15);
}
static SkScalar make_triangle(SkPath* path) {
@@ -24,21 +25,23 @@
path->lineTo(SkIntToScalar(gCoord[2]), SkIntToScalar(gCoord[3]));
path->lineTo(SkIntToScalar(gCoord[4]), SkIntToScalar(gCoord[5]));
path->close();
- path->offset(10, 0);
+ path->offset(SkIntToScalar(10), SkIntToScalar(0));
return SkIntToScalar(30);
}
static SkScalar make_rect(SkPath* path) {
- SkRect r = { 10, 10, 30, 30 };
+ SkRect r = { SkIntToScalar(10), SkIntToScalar(10),
+ SkIntToScalar(30), SkIntToScalar(30) };
path->addRect(r);
- path->offset(10, 0);
+ path->offset(SkIntToScalar(10), SkIntToScalar(0));
return SkIntToScalar(30);
}
static SkScalar make_oval(SkPath* path) {
- SkRect r = { 10, 10, 30, 30 };
+ SkRect r = { SkIntToScalar(10), SkIntToScalar(10),
+ SkIntToScalar(30), SkIntToScalar(30) };
path->addOval(r);
- path->offset(10, 0);
+ path->offset(SkIntToScalar(10), SkIntToScalar(0));
return SkIntToScalar(30);
}
@@ -56,8 +59,8 @@
x += dx;
path->lineTo(x, y + dy);
}
- path->lineTo(x, y + 2 * dy);
- path->lineTo(x0, y + 2 * dy);
+ path->lineTo(x, y + (2 * dy));
+ path->lineTo(x0, y + (2 * dy));
path->close();
return SkIntToScalar(30);
}
@@ -100,7 +103,7 @@
SkPath fPath[N];
SkScalar fDY[N];
public:
- PathFillGM() {
+ PathFillGM() {
for (size_t i = 0; i < N; i++) {
fDY[i] = gProcs[i](&fPath[i]);
}
@@ -111,7 +114,7 @@
return SkString("pathfill");
}
- virtual SkISize onISize() {
+ virtual SkISize onISize() {
return make_isize(640, 480);
}
@@ -127,7 +130,7 @@
for (size_t i = 0; i < N; i++) {
canvas->drawPath(fPath[i], paint);
- canvas->translate(0, fDY[i]);
+ canvas->translate(SkIntToScalar(0), fDY[i]);
}
}
diff --git a/gm/shadertext.cpp b/gm/shadertext.cpp
index 1cf562c..ea87823 100644
--- a/gm/shadertext.cpp
+++ b/gm/shadertext.cpp
@@ -11,7 +11,7 @@
bm->eraseColor(0);
SkCanvas canvas(*bm);
- SkScalar s = w < h ? w : h;
+ SkScalar s = SkIntToScalar(SkMin32(w, h));
SkPoint pts[] = { { 0, 0 }, { s, s } };
SkColor colors[] = { SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE };
SkScalar pos[] = { 0, SK_Scalar1/2, SK_Scalar1 };
@@ -121,7 +121,7 @@
const char text[] = "Shaded Text";
const int textLen = SK_ARRAY_COUNT(text) - 1;
- static int pointSize = SkIntToScalar(48);
+ const int pointSize = 48;
int w = pointSize * textLen;
int h = pointSize;
@@ -194,5 +194,3 @@
static GMRegistry reg(MyFactory);
}
-
-
diff --git a/gm/shadows.cpp b/gm/shadows.cpp
index 5afde49..bba997f 100644
--- a/gm/shadows.cpp
+++ b/gm/shadows.cpp
@@ -1,32 +1,29 @@
#include "gm.h"
-#include "SkPicture.h"
-#include "SkRectShape.h"
#include "SkBlurDrawLooper.h"
namespace skiagm {
///////////////////////////////////////////////////////////////////////////////
-class ShadowsGM : public GM {
+static void setup(SkPaint* paint, SkColor c, SkScalar strokeWidth) {
+ paint->setColor(c);
+ if (strokeWidth < 0) {
+ paint->setStyle(SkPaint::kFill_Style);
+ } else {
+ paint->setStyle(SkPaint::kStroke_Style);
+ paint->setStrokeWidth(strokeWidth);
+ }
+}
+class ShadowsGM : public GM {
public:
SkPath fCirclePath;
- SkPaint fPaint;
- SkRectShape fRectShape;
+ SkRect fRect;
+
ShadowsGM() {
fCirclePath.addCircle(SkIntToScalar(20), SkIntToScalar(20), SkIntToScalar(10) );
- fPaint.setStrokeWidth(SkIntToScalar(4));
- fPaint.setAntiAlias(true);
- fPaint.setColor(0xFF00FF00);
- fPaint.setStyle(SkPaint::kStroke_Style);
- SkRect rect;
- rect.set(SkIntToScalar(10), SkIntToScalar(10),
- SkIntToScalar(30), SkIntToScalar(30));
- fRectShape.setRect(rect);
- fRectShape.paint().setColor(SK_ColorRED);
- }
-
- virtual ~ShadowsGM() {
+ fRect.set(SkIntToScalar(10), SkIntToScalar(10),
+ SkIntToScalar(30), SkIntToScalar(30));
}
protected:
@@ -47,43 +44,61 @@
SkBlurDrawLooper* shadowLoopers[5];
shadowLoopers[0] =
- new SkBlurDrawLooper (10, 5, 10, 0xFF0000FF,
+ new SkBlurDrawLooper (SkIntToScalar(10), SkIntToScalar(5),
+ SkIntToScalar(10), 0xFF0000FF,
SkBlurDrawLooper::kIgnoreTransform_BlurFlag |
SkBlurDrawLooper::kOverrideColor_BlurFlag |
SkBlurDrawLooper::kHighQuality_BlurFlag );
SkAutoUnref aurL0(shadowLoopers[0]);
shadowLoopers[1] =
- new SkBlurDrawLooper (10, 5, 10, 0xFF0000FF,
+ new SkBlurDrawLooper (SkIntToScalar(10), SkIntToScalar(5),
+ SkIntToScalar(10), 0xFF0000FF,
SkBlurDrawLooper::kIgnoreTransform_BlurFlag |
SkBlurDrawLooper::kOverrideColor_BlurFlag );
SkAutoUnref aurL1(shadowLoopers[1]);
shadowLoopers[2] =
- new SkBlurDrawLooper (5, 5, 10, 0xFF000000,
+ new SkBlurDrawLooper (SkIntToScalar(5), SkIntToScalar(5),
+ SkIntToScalar(10), 0xFF000000,
SkBlurDrawLooper::kIgnoreTransform_BlurFlag |
SkBlurDrawLooper::kHighQuality_BlurFlag );
SkAutoUnref aurL2(shadowLoopers[2]);
shadowLoopers[3] =
- new SkBlurDrawLooper (5, -5 ,-10, 0x7FFF0000,
+ new SkBlurDrawLooper (SkIntToScalar(5), SkIntToScalar(-5),
+ SkIntToScalar(-10), 0x7FFF0000,
SkBlurDrawLooper::kIgnoreTransform_BlurFlag |
SkBlurDrawLooper::kOverrideColor_BlurFlag |
SkBlurDrawLooper::kHighQuality_BlurFlag );
SkAutoUnref aurL3(shadowLoopers[3]);
shadowLoopers[4] =
- new SkBlurDrawLooper (0, 5, 5, 0xFF000000,
+ new SkBlurDrawLooper (SkIntToScalar(0), SkIntToScalar(5),
+ SkIntToScalar(5), 0xFF000000,
SkBlurDrawLooper::kIgnoreTransform_BlurFlag |
SkBlurDrawLooper::kOverrideColor_BlurFlag |
SkBlurDrawLooper::kHighQuality_BlurFlag );
SkAutoUnref aurL4(shadowLoopers[4]);
- for (int looper = 0; looper < 5; looper ++)
- {
- fRectShape.paint().setLooper(shadowLoopers[looper]);
- canvas->resetMatrix();
- canvas->translate(SkIntToScalar(looper*40), SkIntToScalar(0));
- canvas->drawShape(&fRectShape);
- fPaint.setLooper(shadowLoopers[looper]);
+ static const struct {
+ SkColor fColor;
+ SkScalar fStrokeWidth;
+ } gRec[] = {
+ { SK_ColorRED, -SK_Scalar1 },
+ { SK_ColorGREEN, SkIntToScalar(4) },
+ };
+
+ SkPaint paint;
+ paint.setAntiAlias(true);
+ for (size_t i = 0; i < SK_ARRAY_COUNT(shadowLoopers); ++i) {
+ SkAutoCanvasRestore acr(canvas, true);
+
+ paint.setLooper(shadowLoopers[i]);
+
+ canvas->translate(SkIntToScalar(i*40), SkIntToScalar(0));
+ setup(&paint, gRec[0].fColor, gRec[0].fStrokeWidth);
+ canvas->drawRect(fRect, paint);
+
canvas->translate(SkIntToScalar(0), SkIntToScalar(40));
- canvas->drawPath(fCirclePath, fPaint);
+ setup(&paint, gRec[1].fColor, gRec[1].fStrokeWidth);
+ canvas->drawPath(fCirclePath, paint);
}
}
diff --git a/gm/shapes.cpp b/gm/shapes.cpp
index 324ce7e..5daea0a 100644
--- a/gm/shapes.cpp
+++ b/gm/shapes.cpp
@@ -57,6 +57,8 @@
for (size_t i = 0; i < SK_ARRAY_COUNT(fMatrixRefs); i++) {
SkSafeRef(fMatrixRefs[i] = fGroup.getShapeMatrixRef(i));
}
+ SkScalar c = SkIntToScalar(50);
+ fMatrixRefs[3]->preRotate(SkIntToScalar(30), c, c);
}
virtual ~ShapesGM() {
@@ -81,10 +83,6 @@
virtual void onDraw(SkCanvas* canvas) {
this->drawBG(canvas);
- SkMatrix saveM = *fMatrixRefs[3];
- SkScalar c = SkIntToScalar(50);
- fMatrixRefs[3]->preRotate(SkIntToScalar(30), c, c);
-
SkMatrix matrix;
SkGroupShape* gs = new SkGroupShape;
@@ -111,8 +109,6 @@
canvas->drawPicture(*pict);
pict->unref();
#endif
-
- *fMatrixRefs[3] = saveM;
}
private:
diff --git a/gm/strokerects.cpp b/gm/strokerects.cpp
index b716407..891b95a 100644
--- a/gm/strokerects.cpp
+++ b/gm/strokerects.cpp
@@ -29,14 +29,14 @@
class StrokeRectGM : public GM {
public:
- StrokeRectGM() {}
+ StrokeRectGM() {}
protected:
virtual SkString onShortName() {
return SkString("strokerects");
}
- virtual SkISize onISize() {
+ virtual SkISize onISize() {
return make_isize(W*2, H*2);
}
@@ -63,7 +63,10 @@
SkAutoCanvasRestore acr(canvas, true);
canvas->translate(SW * x, SH * y);
- canvas->clipRect(SkRect::MakeLTRB(2, 2, SW - 2, SH - 2));
+ canvas->clipRect(SkRect::MakeLTRB(
+ SkIntToScalar(2), SkIntToScalar(2)
+ , SW - SkIntToScalar(2), SH - SkIntToScalar(2)
+ ));
SkRandom rand;
for (int i = 0; i < N; i++) {
diff --git a/gpu/include/GrClipIterator.h b/gpu/include/GrClipIterator.h
index 1fcbdd1..f7f74a7 100644
--- a/gpu/include/GrClipIterator.h
+++ b/gpu/include/GrClipIterator.h
@@ -47,7 +47,7 @@
* Return the current path. It is an error to call this when isDone() is
* true or when getType() is kRect_Type.
*/
- virtual GrPathIter* getPathIter() = 0;
+ virtual const GrPath* getPath() = 0;
/**
* Return the fill rule for the path. It is an error to call this when
diff --git a/gpu/include/GrConfig.h b/gpu/include/GrConfig.h
index f1f2437..9ee37c7 100644
--- a/gpu/include/GrConfig.h
+++ b/gpu/include/GrConfig.h
@@ -189,7 +189,7 @@
// debug -vs- release
//
-extern void GrPrintf(const char format[], ...);
+extern GR_API void GrPrintf(const char format[], ...);
/**
* GR_STRING makes a string of X where X is expanded before conversion to a string
diff --git a/gpu/include/GrContext.h b/gpu/include/GrContext.h
index 951c0e6..58c53ba 100644
--- a/gpu/include/GrContext.h
+++ b/gpu/include/GrContext.h
@@ -25,7 +25,6 @@
class GrFontCache;
class GrGpu;
struct GrGpuStats;
-class GrPathIter;
class GrVertexBufferAllocPool;
class GrIndexBufferAllocPool;
class GrInOrderDrawBuffer;
@@ -191,35 +190,16 @@
* on failure.
*/
GrResource* createPlatformSurface(const GrPlatformSurfaceDesc& desc);
-
/**
- * DEPRECATED, WILL BE REMOVED SOON. USE createPlatformSurface.
- *
- * Wraps an externally-created rendertarget in a GrRenderTarget.
- * @param platformRenderTarget 3D API-specific render target identifier
- * e.g. in GL platforamRenderTarget is an FBO
- * id.
- * @param stencilBits the number of stencil bits that the render
- * target has.
- * @param isMultisampled specify whether the render target is
- * multisampled.
- * @param width width of the render target.
- * @param height height of the render target.
- */
- GrRenderTarget* createPlatformRenderTarget(intptr_t platformRenderTarget,
- int stencilBits,
- bool isMultisampled,
- int width, int height);
-
- /**
- * DEPRECATED, WILL BE REMOVED SOON. USE createPlatformSurface.
- *
* Reads the current target object (e.g. FBO or IDirect3DSurface9*) and
* viewport state from the underlying 3D API and wraps it in a
* GrRenderTarget. The GrRenderTarget will not attempt to delete/destroy the
* underlying object in its destructor and it is up to caller to guarantee
* that it remains valid while the GrRenderTarget is used.
*
+ * Will not detect that the render target is also a texture. If you need
+ * to also use the render target as a GrTexture use createPlatformSurface.
+ *
* @return the newly created GrRenderTarget
*/
GrRenderTarget* createRenderTargetFrom3DApiState();
@@ -323,22 +303,14 @@
* Draws a path.
*
* @param paint describes how to color pixels.
- * @param pathIter the path to draw
+ * @param path the path to draw
* @param fill the path filling rule to use.
* @param translate optional additional translation applied to the
* path.
*/
- void drawPath(const GrPaint& paint,
- GrPathIter* pathIter,
- GrPathFill fill,
+ void drawPath(const GrPaint& paint, const GrPath& path, GrPathFill fill,
const GrPoint* translate = NULL);
- /**
- * Helper version of drawPath that takes a GrPath
- */
- void drawPath(const GrPaint& paint,
- const GrPath& path,
- GrPathFill fill,
- const GrPoint* translate = NULL);
+
/**
* Draws vertices with a paint.
*
@@ -585,16 +557,9 @@
void drawClipIntoStencil();
- GrPathRenderer* getPathRenderer(const GrDrawTarget* target,
- GrPathIter* path,
- GrPathFill fill);
+ GrPathRenderer* getPathRenderer(const GrDrawTarget*, const GrPath&, GrPathFill);
struct OffscreenRecord;
- // we currently only expose stage 0 through the paint so use stage 1. We
- // use stage 1 for the offscreen.
- enum {
- kOffscreenStage = 1,
- };
bool doOffscreenAA(GrDrawTarget* target,
const GrPaint& paint,
@@ -613,6 +578,15 @@
const GrIRect& boundRect,
OffscreenRecord* record);
+ // computes vertex layout bits based on the paint. If paint expresses
+ // a texture for a stage, the stage coords will be bound to postitions
+ // unless hasTexCoords[s]==true in which case stage s's input coords
+ // are bound to tex coord index s. hasTexCoords == NULL is a shortcut
+ // for an array where all the values are false.
+ static int PaintStageVertexLayoutBits(
+ const GrPaint& paint,
+ const bool hasTexCoords[GrPaint::kTotalStages]);
+
};
/**
diff --git a/gpu/include/GrContext_impl.h b/gpu/include/GrContext_impl.h
index fae4e92..c79a191 100644
--- a/gpu/include/GrContext_impl.h
+++ b/gpu/include/GrContext_impl.h
@@ -40,19 +40,15 @@
const COL_SRC* colorSrc,
const IDX_SRC* idxSrc) {
- GrVertexLayout layout = 0;
-
GrDrawTarget::AutoReleaseGeometry geo;
GrDrawTarget* target = this->prepareToDraw(paint, kUnbuffered_DrawCategory);
- if (NULL != paint.getTexture()) {
- if (NULL != texCoordSrc) {
- layout |= GrDrawTarget::StageTexCoordVertexLayoutBit(0,0);
- } else {
- layout |= GrDrawTarget::StagePosAsTexCoordVertexLayoutBit(0);
- }
- }
+ bool hasTexCoords[GrPaint::kTotalStages] = {
+ NULL != texCoordSrc, // texCoordSrc provides explicit stage 0 coords
+ 0 // remaining stages use positions
+ };
+ GrVertexLayout layout = PaintStageVertexLayoutBits(paint, hasTexCoords);
if (NULL != colorSrc) {
layout |= GrDrawTarget::kColor_VertexLayoutBit;
diff --git a/gpu/include/GrDrawTarget.h b/gpu/include/GrDrawTarget.h
index 93b381d..cd70d3e 100644
--- a/gpu/include/GrDrawTarget.h
+++ b/gpu/include/GrDrawTarget.h
@@ -32,7 +32,6 @@
class GrClipIterator;
class GrVertexBuffer;
class GrIndexBuffer;
-class GrEffect;
class GrDrawTarget : public GrRefCnt {
public:
@@ -51,10 +50,21 @@
* or not.
*/
enum {
- kNumStages = 2,
+ kNumStages = 3,
kMaxTexCoords = kNumStages
};
+
+ /**
+ * The absolute maximum number of edges that may be specified for
+ * a single draw call when performing edge antialiasing. This is used for
+ * the size of several static buffers, so implementations of getMaxEdges()
+ * (below) should clamp to this value.
+ */
+ enum {
+ kMaxEdges = 32
+ };
+
/**
* Bitfield used to indicate which stages are in use.
*/
@@ -79,9 +89,6 @@
kNoColorWrites_StateBit = 0x08, //<! If set it disables writing colors.
// Useful while performing stencil
// ops.
- kEdgeAA_StateBit = 0x10, //<! Perform edge anti-aliasing.
- // Requires the edges to be passed in
- // setEdgeAAData().
// subclass may use additional bits internally
kDummyStateBit,
@@ -129,6 +136,20 @@
fCurrDrawState.fStencilSettings.setDisabled();
}
+ class Edge {
+ public:
+ Edge() {}
+ Edge(float x, float y, float z) : fX(x), fY(y), fZ(z) {}
+ GrPoint intersect(const Edge& other) {
+ return GrPoint::Make(
+ (fY * other.fZ - other.fY * fZ) /
+ (fX * other.fY - other.fX * fY),
+ (fX * other.fZ - other.fX * fZ) /
+ (other.fX * fY - fX * other.fY));
+ }
+ float fX, fY, fZ;
+ };
+
protected:
struct DrState {
@@ -137,19 +158,26 @@
// all DrState members should default to something
// valid by the memset
memset(this, 0, sizeof(DrState));
- // This is an exception to our memset, since it will
- // result in no change.
+
+ // memset exceptions
fColorFilterXfermode = SkXfermode::kDstIn_Mode;
+ fFirstCoverageStage = kNumStages;
+
+ // pedantic assertion that our ptrs will
+ // be NULL (0 ptr is mem addr 0)
GrAssert((intptr_t)(void*)NULL == 0LL);
+
+ // default stencil setting should be disabled
GrAssert(fStencilSettings.isDisabled());
+ fFirstCoverageStage = kNumStages;
}
uint32_t fFlagBits;
GrBlendCoeff fSrcBlend;
GrBlendCoeff fDstBlend;
GrColor fBlendConstant;
GrTexture* fTextures[kNumStages];
- GrEffect* fEffects[kNumStages];
GrSamplerState fSamplerStates[kNumStages];
+ int fFirstCoverageStage;
GrRenderTarget* fRenderTarget;
GrColor fColor;
DrawFace fDrawFace;
@@ -158,7 +186,8 @@
GrStencilSettings fStencilSettings;
GrMatrix fViewMatrix;
- float fEdgeAAEdges[18];
+ Edge fEdgeAAEdges[kMaxEdges];
+ int fEdgeAANumEdges;
bool operator ==(const DrState& s) const {
return 0 == memcmp(this, &s, sizeof(DrState));
}
@@ -245,6 +274,18 @@
}
/**
+ * Shortcut for preConcatSamplerMatrix on all stages in mask with same
+ * matrix
+ */
+ void preConcatSamplerMatrices(int stageMask, const GrMatrix& matrix) {
+ for (int i = 0; i < kNumStages; ++i) {
+ if ((1 << i) & stageMask) {
+ this->preConcatSamplerMatrix(i, matrix);
+ }
+ }
+ }
+
+ /**
* Gets the matrix of a stage's sampler
*
* @param stage the stage to of sampler to get
@@ -343,6 +384,26 @@
void setDrawFace(DrawFace face) { fCurrDrawState.fDrawFace = face; }
/**
+ * A common pattern is to compute a color with the initial stages and then
+ * modulate that color by a coverage value in later stage(s) (AA, mask-
+ * filters, glyph mask, etc). Color-filters, xfermodes, etc should be
+ * computed based on the pre-coverage-modulated color. The division of
+ * stages between color-computing and coverage-computing is specified by
+ * this method. Initially this is kNumStages (all stages are color-
+ * computing).
+ */
+ void setFirstCoverageStage(int firstCoverageStage) {
+ fCurrDrawState.fFirstCoverageStage = firstCoverageStage;
+ }
+
+ /**
+ * Gets the index of the first coverage-computing stage.
+ */
+ int getFirstCoverageStage() const {
+ return fCurrDrawState.fFirstCoverageStage;
+ }
+
+ /**
* Gets whether the target is drawing clockwise, counterclockwise,
* or both faces.
* @return the current draw face(s).
@@ -392,7 +453,7 @@
* @param srcCoef coeffecient applied to the src color.
* @param dstCoef coeffecient applied to the dst color.
*/
- void setBlendFunc(GrBlendCoeff srcCoef, GrBlendCoeff dstCoef);
+ void setBlendFunc(GrBlendCoeff srcCoeff, GrBlendCoeff dstCoeff);
/**
* Sets the blending function constant referenced by the following blending
@@ -498,7 +559,7 @@
* @param edges 3 * 6 float values, representing the edge
* equations in Ax + By + C form
*/
- void setEdgeAAData(const float edges[18]);
+ void setEdgeAAData(const Edge* edges, int numEdges);
private:
static const int TEX_COORD_BIT_CNT = kNumStages*kMaxTexCoords;
@@ -766,6 +827,15 @@
*/
virtual void clear(const GrIRect* rect, GrColor color) = 0;
+ /**
+ * Returns the maximum number of edges that may be specified in a single
+ * draw call when performing edge antialiasing. This is usually limited
+ * by the number of fragment uniforms which may be uploaded. Must be a
+ * minimum of six, since a triangle's vertices each belong to two boundary
+ * edges which may be distinct.
+ */
+ virtual int getMaxEdges() const { return 6; }
+
///////////////////////////////////////////////////////////////////////////
class AutoStateRestore : ::GrNoncopyable {
diff --git a/gpu/include/GrFontScaler.h b/gpu/include/GrFontScaler.h
index 77730d7..ab73ea4 100644
--- a/gpu/include/GrFontScaler.h
+++ b/gpu/include/GrFontScaler.h
@@ -21,7 +21,7 @@
#include "GrGlyph.h"
#include "GrKey.h"
-class GrPath;
+class SkPath;
/**
* This is a virtual base class which Gr's interface to the host platform's
@@ -37,7 +37,7 @@
virtual bool getPackedGlyphBounds(GrGlyph::PackedID, GrIRect* bounds) = 0;
virtual bool getPackedGlyphImage(GrGlyph::PackedID, int width, int height,
int rowBytes, void* image) = 0;
- virtual bool getGlyphPath(uint16_t glyphID, GrPath*) = 0;
+ virtual bool getGlyphPath(uint16_t glyphID, SkPath*) = 0;
};
#endif
diff --git a/gpu/include/GrGLDefines.h b/gpu/include/GrGLDefines.h
index 29e56f3..6c2483b 100644
--- a/gpu/include/GrGLDefines.h
+++ b/gpu/include/GrGLDefines.h
@@ -69,6 +69,12 @@
/* GL_DST_ALPHA */
/* GL_ONE_MINUS_DST_ALPHA */
+/* ExtendedBlendFactors */
+#define GR_GL_SRC1_COLOR 0x88F9
+#define GR_GL_ONE_MINUS_SRC1_COLOR 0x88FA
+/* GL_SRC1_ALPHA */
+#define GR_GL_ONE_MINUS_SRC1_ALPHA 0x88FB
+
/* BlendEquationSeparate */
#define GR_GL_FUNC_ADD 0x8006
#define GR_GL_BLEND_EQUATION 0x8009
@@ -318,6 +324,8 @@
#define GR_GL_ACTIVE_ATTRIBUTE_MAX_LENGTH 0x8B8A
#define GR_GL_SHADING_LANGUAGE_VERSION 0x8B8C
#define GR_GL_CURRENT_PROGRAM 0x8B8D
+#define GR_GL_MAX_FRAGMENT_UNIFORM_COMPONENTS 0x8B49
+#define GR_GL_MAX_VERTEX_UNIFORM_COMPONENTS 0x8B4A
/* StencilFunction */
#define GR_GL_NEVER 0x0200
diff --git a/gpu/include/GrGLInterface.h b/gpu/include/GrGLInterface.h
index 591ab8c..150e8e4 100644
--- a/gpu/include/GrGLInterface.h
+++ b/gpu/include/GrGLInterface.h
@@ -63,6 +63,7 @@
typedef unsigned char GrGLboolean;
typedef unsigned int GrGLbitfield;
typedef signed char GrGLbyte;
+typedef char GrGLchar;
typedef short GrGLshort;
typedef int GrGLint;
typedef int GrGLsizei;
@@ -199,6 +200,9 @@
// Buffer mapping (extension in ES).
typedef GrGLvoid* (GR_GL_FUNCTION_TYPE *GrGLMapBufferProc)(GrGLenum target, GrGLenum access);
typedef GrGLboolean (GR_GL_FUNCTION_TYPE *GrGLUnmapBufferProc)(GrGLenum target);
+
+ // Dual source blending
+ typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLBindFragDataLocationIndexedProc)(GrGLuint program, GrGLuint colorNumber, GrGLuint index, const GrGLchar * name);
} // extern "C"
/*
@@ -333,6 +337,9 @@
GrGLMapBufferProc fMapBuffer;
GrGLUnmapBufferProc fUnmapBuffer;
+ // Dual Source Blending
+ GrGLBindFragDataLocationIndexedProc fBindFragDataLocationIndexed;
+
// Code that initializes this struct using a static initializer should
// make this the last entry in the static initializer. It can help to guard
// against failing to initialize newly-added members of this struct.
diff --git a/gpu/include/GrGpu.h b/gpu/include/GrGpu.h
index e44956f..574a430 100644
--- a/gpu/include/GrGpu.h
+++ b/gpu/include/GrGpu.h
@@ -60,6 +60,21 @@
public:
/**
+ * Additional blend coeffecients for dual source blending, not exposed
+ * through GrPaint/GrContext.
+ */
+ enum ExtendedBlendCoeffs {
+ // source 2 refers to second output color when
+ // using dual source blending.
+ kS2C_BlendCoeff = kPublicBlendCoeffCount,
+ kIS2C_BlendCoeff,
+ kS2A_BlendCoeff,
+ kIS2A_BlendCoeff,
+
+ kTotalBlendCoeffCount
+ };
+
+ /**
* Create an instance of GrGpu that matches the specified Engine backend.
* If the requested engine is not supported (at compile-time or run-time)
* this returns NULL.
@@ -109,20 +124,6 @@
*/
GrTexture* createTexture(const GrTextureDesc& desc,
const void* srcData, size_t rowBytes);
- /**
- * Wraps an externally-created rendertarget in a GrRenderTarget.
- * @param platformRenderTarget handle to the the render target in the
- * underlying 3D API. Interpretation depends on
- * GrGpu subclass in use.
- * @param stencilBits number of stencil bits the target has
- * @param isMultisampled specify whether the RT is multisampled
- * @param width width of the render target
- * @param height height of the render target
- */
- GrRenderTarget* createPlatformRenderTarget(intptr_t platformRenderTarget,
- int stencilBits,
- bool isMultisampled,
- int width, int height);
GrResource* createPlatformSurface(const GrPlatformSurfaceDesc& desc);
@@ -204,6 +205,15 @@
bool supports4x4DownsampleFilter() const { return f4X4DownsampleFilterSupport; }
/**
+ * Does this instance support dual-source blending? Required for proper
+ * blending with partial coverage with certain blend modes (dst coeff is
+ * not 1, ISA, or ISC)
+ */
+ bool supportsDualSourceBlending() const {
+ return fDualSourceBlendingSupport;
+ }
+
+ /**
* Gets the minimum width of a render target. If a texture/rt is created
* with a width less than this size the GrGpu object will clamp it to this
* value.
@@ -385,6 +395,7 @@
bool fAALineSupport;
bool fFSAASupport;
bool f4X4DownsampleFilterSupport; // supports GrSamplerState::k4x4Downsample_Filter
+ bool fDualSourceBlendingSupport;
// set by subclass to true if index and vertex buffers can be locked, false
// otherwise.
@@ -427,11 +438,6 @@
const void* srcData,
size_t rowBytes) = 0;
virtual GrResource* onCreatePlatformSurface(const GrPlatformSurfaceDesc& desc) = 0;
- virtual GrRenderTarget* onCreatePlatformRenderTarget(
- intptr_t platformRenderTarget,
- int stencilBits,
- bool isMultisampled,
- int width, int height) = 0;
virtual GrRenderTarget* onCreateRenderTargetFrom3DApiState() = 0;
virtual GrVertexBuffer* onCreateVertexBuffer(uint32_t size,
bool dynamic) = 0;
@@ -513,8 +519,7 @@
void prepareIndexPool();
// determines the path renderer used to draw a clip path element.
- GrPathRenderer* getClipPathRenderer(GrPathIter* path,
- GrPathFill fill);
+ GrPathRenderer* getClipPathRenderer(const SkPath& path, GrPathFill fill);
void handleDirtyContext() {
if (fContextIsDirty) {
diff --git a/gpu/include/GrPaint.h b/gpu/include/GrPaint.h
index 3035ca1..a7923f5 100644
--- a/gpu/include/GrPaint.h
+++ b/gpu/include/GrPaint.h
@@ -25,12 +25,17 @@
/**
* The paint describes how pixels are colored when the context draws to
- * them.
+ * them. TODO: Make this a "real" class with getters and setters, default
+ * values, and documentation.
*/
class GrPaint {
public:
+ enum {
+ kMaxTextures = 1,
+ kMaxMasks = 1,
+ };
- // All the paint fields are public except texture (it's ref-counted)
+ // All the paint fields are public except textures/samplers
GrBlendCoeff fSrcBlendCoeff;
GrBlendCoeff fDstBlendCoeff;
bool fAntiAlias;
@@ -38,22 +43,75 @@
GrColor fColor;
- GrSamplerState fSampler;
-
GrColor fColorFilterColor;
SkXfermode::Mode fColorFilterXfermode;
- void setTexture(GrTexture* texture) {
+ void setTexture(int i, GrTexture* texture) {
+ GrAssert((unsigned)i < kMaxTextures);
GrSafeRef(texture);
- GrSafeUnref(fTexture);
- fTexture = texture;
+ GrSafeUnref(fTextures[i]);
+ fTextures[i] = texture;
}
- GrTexture* getTexture() const { return fTexture; }
+ GrTexture* getTexture(int i) const {
+ GrAssert((unsigned)i < kMaxTextures);
+ return fTextures[i];
+ }
+
+ GrSamplerState* getTextureSampler(int i) {
+ GrAssert((unsigned)i < kMaxTextures);
+ return fTextureSamplers + i;
+ }
+
+ const GrSamplerState* getTextureSampler(int i) const {
+ GrAssert((unsigned)i < kMaxTextures);
+ return fTextureSamplers + i;
+ }
+
+ // The mask can be alpha-only or per channel. It is applied
+ // after the colorfilter
+ void setMask(int i, GrTexture* mask) {
+ GrAssert((unsigned)i < kMaxMasks);
+ GrSafeRef(mask);
+ GrSafeUnref(fMaskTextures[i]);
+ fMaskTextures[i] = mask;
+ }
+
+ GrTexture* getMask(int i) const {
+ GrAssert((unsigned)i < kMaxMasks);
+ return fMaskTextures[i];
+ }
+
+ // mask's sampler matrix is always applied to the positions
+ // (i.e. no explicit texture coordinates)
+ GrSamplerState* getMaskSampler(int i) {
+ GrAssert((unsigned)i < kMaxMasks);
+ return fMaskSamplers + i;
+ }
+
+ const GrSamplerState* getMaskSampler(int i) const {
+ GrAssert((unsigned)i < kMaxMasks);
+ return fMaskSamplers + i;
+ }
+
+ // pre-concats sampler matrices for non-NULL textures and masks
+ void preConcatActiveSamplerMatrices(const GrMatrix& matrix) {
+ for (int i = 0; i < kMaxTextures; ++i) {
+ fTextureSamplers[i].preConcatMatrix(matrix);
+ }
+ for (int i = 0; i < kMaxMasks; ++i) {
+ fMaskSamplers[i].preConcatMatrix(matrix);
+ }
+ }
// uninitialized
GrPaint() {
- fTexture = NULL;
+ for (int i = 0; i < kMaxTextures; ++i) {
+ fTextures[i] = NULL;
+ }
+ for (int i = 0; i < kMaxMasks; ++i) {
+ fMaskTextures[i] = NULL;
+ }
}
GrPaint(const GrPaint& paint) {
@@ -67,22 +125,35 @@
fColorFilterColor = paint.fColorFilterColor;
fColorFilterXfermode = paint.fColorFilterXfermode;
- fSampler = paint.fSampler;
- fTexture = paint.fTexture;
- GrSafeRef(fTexture);
+ for (int i = 0; i < kMaxTextures; ++i) {
+ fTextureSamplers[i] = paint.fTextureSamplers[i];
+ fTextures[i] = paint.fTextures[i];
+ GrSafeRef(fTextures[i]);
+ }
+ for (int i = 0; i < kMaxMasks; ++i) {
+ fMaskSamplers[i] = paint.fMaskSamplers[i];
+ fMaskTextures[i] = paint.fMaskTextures[i];
+ GrSafeRef(fMaskTextures[i]);
+ }
}
~GrPaint() {
- GrSafeUnref(fTexture);
+ for (int i = 0; i < kMaxTextures; ++i) {
+ GrSafeUnref(fTextures[i]);
+ }
+ for (int i = 0; i < kMaxMasks; ++i) {
+ GrSafeUnref(fMaskTextures[i]);
+ }
}
- // sets paint to src-over, solid white, no texture
+ // sets paint to src-over, solid white, no texture, no mask
void reset() {
- resetBlend();
- resetOptions();
- resetColor();
- resetTexture();
- resetColorFilter();
+ this->resetBlend();
+ this->resetOptions();
+ this->resetColor();
+ this->resetTextures();
+ this->resetColorFilter();
+ this->resetMasks();
}
void resetColorFilter() {
@@ -90,8 +161,60 @@
fColorFilterColor = GrColorPackRGBA(0xff, 0xff, 0xff, 0xff);
}
+ bool hasTexture() const {
+ return 0 != this->getActiveTextureStageMask();
+ }
+
+ bool hasMask() const {
+ return 0 != this->getActiveMaskStageMask();
+ }
+
+ bool hasTextureOrMask() const {
+ return this->hasTexture() || this->hasMask();
+ }
+
+ // helpers for GrContext, GrTextContext
+ int getActiveTextureStageMask() const {
+ int mask = 0;
+ for (int i = 0; i < kMaxTextures; ++i) {
+ if (NULL != fTextures[i]) {
+ mask |= 1 << (i + kFirstTextureStage);
+ }
+ }
+ return mask;
+ }
+
+ int getActiveMaskStageMask() const {
+ int mask = 0;
+ for (int i = 0; i < kMaxMasks; ++i) {
+ if (NULL != fMaskTextures[i]) {
+ mask |= 1 << (i + kFirstMaskStage);
+ }
+ }
+ return mask;
+ }
+
+ int getActiveStageMask() const {
+ return this->getActiveTextureStageMask() |
+ this->getActiveMaskStageMask();
+ }
+
+ // internal use
+ // GrPaint's textures and masks map to the first N stages
+ // of GrDrawTarget in that order (textures followed by masks)
+ enum {
+ kFirstTextureStage = 0,
+ kFirstMaskStage = kMaxTextures,
+ kTotalStages = kMaxTextures + kMaxMasks,
+ };
+
private:
- GrTexture* fTexture;
+
+ GrSamplerState fTextureSamplers[kMaxTextures];
+ GrSamplerState fMaskSamplers[kMaxMasks];
+
+ GrTexture* fTextures[kMaxTextures];
+ GrTexture* fMaskTextures[kMaxMasks];
void resetBlend() {
fSrcBlendCoeff = kOne_BlendCoeff;
@@ -107,11 +230,19 @@
fColor = GrColorPackRGBA(0xff, 0xff, 0xff, 0xff);
}
- void resetTexture() {
- setTexture(NULL);
- fSampler.setClampNoFilter();
+ void resetTextures() {
+ for (int i = 0; i < kMaxTextures; ++i) {
+ this->setTexture(i, NULL);
+ fTextureSamplers[i].setClampNoFilter();
+ }
}
+ void resetMasks() {
+ for (int i = 0; i < kMaxMasks; ++i) {
+ this->setMask(i, NULL);
+ fMaskSamplers[i].setClampNoFilter();
+ }
+ }
};
#endif
diff --git a/gpu/include/GrPath.h b/gpu/include/GrPath.h
index f958329..c23cfc4 100644
--- a/gpu/include/GrPath.h
+++ b/gpu/include/GrPath.h
@@ -18,91 +18,10 @@
#ifndef GrPath_DEFINED
#define GrPath_DEFINED
-#include "GrPathSink.h"
-#include "GrPathIter.h"
-#include "GrTDArray.h"
-#include "GrPoint.h"
-#include "GrRect.h"
+#include "GrTypes.h"
+#include "SkPath.h"
-class GrPath : public GrPathSink {
-public:
- GrPath();
- GrPath(const GrPath&);
- explicit GrPath(GrPathIter&);
- virtual ~GrPath();
-
- GrConvexHint getConvexHint() const { return fConvexHint; }
- void setConvexHint(GrConvexHint hint) { fConvexHint = hint; }
-
- const GrRect& getConservativeBounds() const { return fConservativeBounds; }
-
- void resetFromIter(GrPathIter*);
-
- bool operator ==(const GrPath& path) const;
- bool operator !=(const GrPath& path) const { return !(*this == path); }
- // overrides from GrPathSink
-
- virtual void moveTo(GrScalar x, GrScalar y);
- virtual void lineTo(GrScalar x, GrScalar y);
- virtual void quadTo(GrScalar x0, GrScalar y0, GrScalar x1, GrScalar y1);
- virtual void cubicTo(GrScalar x0, GrScalar y0, GrScalar x1, GrScalar y1,
- GrScalar x2, GrScalar y2);
- virtual void close();
-
- /**
- * Offset the path by (tx, ty), adding tx to the horizontal position
- * and adds ty to the vertical position of every point.
- */
- void offset(GrScalar tx, GrScalar ty);
-
- class Iter : public GrPathIter {
- public:
- /**
- * Creates an uninitialized iterator
- */
- Iter();
-
- Iter(const GrPath& path);
-
- // overrides from GrPathIter
- virtual GrPathCmd next(GrPoint points[]);
- virtual GrConvexHint convexHint() const;
- virtual GrPathCmd next();
- virtual void rewind();
- virtual bool getConservativeBounds(GrRect* rect) const;
-
- /**
- * Sets iterator to begining of path
- */
- void reset(const GrPath& path);
- private:
- const GrPath* fPath;
- GrPoint fLastPt;
- int fCmdIndex;
- int fPtIndex;
- };
-
- static void ConvexUnitTest();
-
-private:
-
- GrTDArray<GrPathCmd> fCmds;
- GrTDArray<GrPoint> fPts;
- GrConvexHint fConvexHint;
- GrRect fConservativeBounds;
-
- // this ensures we have a moveTo at the start of each contour
- inline void ensureMoveTo();
-
- bool wasLastVerb(GrPathCmd cmd) const {
- int count = fCmds.count();
- return count > 0 && cmd == fCmds[count - 1];
- }
-
- friend class Iter;
-
- typedef GrPathSink INHERITED;
-};
+typedef SkPath GrPath;
#endif
diff --git a/gpu/include/GrPathIter.h b/gpu/include/GrPathIter.h
deleted file mode 100644
index e67ff69..0000000
--- a/gpu/include/GrPathIter.h
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
- Copyright 2010 Google Inc.
-
- 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.
- */
-
-
-#ifndef GrPathIter_DEFINED
-#define GrPathIter_DEFINED
-
-#include "GrRect.h"
-
-/**
- 2D Path iterator. Porting layer creates a subclass of this. It allows Ganesh to
- parse the top-level API's 2D paths. Supports lines, quadratics, and cubic
- pieces and moves (multi-part paths).
- */
-class GrPathIter {
-public:
-
- virtual ~GrPathIter() {};
-
- /**
- * Iterates through the path. Should not be called after
- * kEnd_Command has been returned once. This version retrieves the
- * points for the command.
- * @param points The points relevant to returned commend. See Command
- * enum for number of points valid for each command.
- * @return The next command of the path.
- */
- virtual GrPathCmd next(GrPoint points[4]) = 0;
-
- /**
- * If the host API has knowledge of the convexity of the path
- * it can be communicated by this hint. Gr can analyze the path
- * as it is iterated. So it is not necessary to do additional work to
- * compute convexity status if it isn't already determined.
- *
- * @return a hint about the convexity of the path.
- */
- virtual GrConvexHint convexHint() const = 0;
-
- /**
- * Iterates through the path. Should not be called after
- * kEnd_Command has been returned once. This version does not retrieve the
- * points for the command.
- * @return The next command of the path.
- */
- virtual GrPathCmd next() = 0;
-
- /**
- * Returns conservative bounds on the path points. If returns false then
- * no bounds are available.
- */
- virtual bool getConservativeBounds(GrRect* rect) const = 0;
-
- /**
- Restarts iteration from the beginning.
- */
- virtual void rewind() = 0;
-
-};
-
-#endif
diff --git a/gpu/include/GrPathRenderer.h b/gpu/include/GrPathRenderer.h
index 21cab6b..1ebad4f 100644
--- a/gpu/include/GrPathRenderer.h
+++ b/gpu/include/GrPathRenderer.h
@@ -19,7 +19,7 @@
#include "GrDrawTarget.h"
-class GrPathIter;
+class SkPath;
struct GrPoint;
/**
@@ -37,8 +37,7 @@
*
* @return true if the path can be drawn by this object, false otherwise.
*/
- virtual bool canDrawPath(const GrDrawTarget* target,
- GrPathIter* path,
+ virtual bool canDrawPath(const GrDrawTarget* target, const SkPath& path,
GrPathFill fill) const = 0;
/**
@@ -57,7 +56,7 @@
*/
virtual void drawPath(GrDrawTarget* target,
GrDrawTarget::StageBitfield stages,
- GrPathIter* path,
+ const SkPath& path,
GrPathFill fill,
const GrPoint* translate) = 0;
@@ -80,7 +79,7 @@
* clips.
*/
virtual bool requiresStencilPass(const GrDrawTarget* target,
- GrPathIter* path,
+ const SkPath& path,
GrPathFill fill) const { return false; }
/**
@@ -102,7 +101,7 @@
* the path. NULL means (0,0).
*/
virtual void drawPathToStencil(GrDrawTarget* target,
- GrPathIter* path,
+ const SkPath& path,
GrPathFill fill,
const GrPoint* translate) {
GrCrash("Unexpected call to drawPathToStencil.");
@@ -113,7 +112,7 @@
* having FSAA enabled for a render target)
*/
virtual bool supportsAA(GrDrawTarget* target,
- GrPathIter* path,
+ const SkPath& path,
GrPathFill fill) { return false; }
/**
@@ -138,26 +137,26 @@
bool stencilWrapOpsSupport);
virtual bool canDrawPath(const GrDrawTarget* target,
- GrPathIter* path,
+ const SkPath& path,
GrPathFill fill) const { return true; }
virtual void drawPath(GrDrawTarget* target,
GrDrawTarget::StageBitfield stages,
- GrPathIter* path,
+ const SkPath& path,
GrPathFill fill,
const GrPoint* translate);
virtual bool requiresStencilPass(const GrDrawTarget* target,
- GrPathIter* path,
+ const SkPath& path,
GrPathFill fill) const;
virtual void drawPathToStencil(GrDrawTarget* target,
- GrPathIter* path,
+ const SkPath& path,
GrPathFill fill,
const GrPoint* translate);
private:
void onDrawPath(GrDrawTarget* target,
GrDrawTarget::StageBitfield stages,
- GrPathIter* path,
+ const SkPath& path,
GrPathFill fill,
const GrPoint* translate,
bool stencilOnly);
diff --git a/gpu/include/GrSamplerState.h b/gpu/include/GrSamplerState.h
index dd47c53..373ea94 100644
--- a/gpu/include/GrSamplerState.h
+++ b/gpu/include/GrSamplerState.h
@@ -94,6 +94,7 @@
fSampleMode = kNormal_SampleMode;
fFilter = filter;
fMatrix.setIdentity();
+ fTextureDomain.setEmpty();
}
GrSamplerState(WrapMode wx, WrapMode wy, Filter filter) {
@@ -102,6 +103,7 @@
fSampleMode = kNormal_SampleMode;
fFilter = filter;
fMatrix.setIdentity();
+ fTextureDomain.setEmpty();
}
GrSamplerState(WrapMode wx, WrapMode wy,
@@ -111,6 +113,7 @@
fSampleMode = kNormal_SampleMode;
fFilter = filter;
fMatrix = matrix;
+ fTextureDomain.setEmpty();
}
GrSamplerState(WrapMode wx, WrapMode wy, SampleMode sample,
@@ -120,12 +123,15 @@
fSampleMode = sample;
fMatrix = matrix;
fFilter = filter;
+ fTextureDomain.setEmpty();
}
WrapMode getWrapX() const { return fWrapX; }
WrapMode getWrapY() const { return fWrapY; }
SampleMode getSampleMode() const { return fSampleMode; }
const GrMatrix& getMatrix() const { return fMatrix; }
+ const GrRect& getTextureDomain() const { return fTextureDomain; }
+ bool hasTextureDomain() const {return SkIntToScalar(0) != fTextureDomain.right();}
Filter getFilter() const { return fFilter; }
bool isGradient() const {
@@ -146,6 +152,13 @@
void setMatrix(const GrMatrix& matrix) { fMatrix = matrix; }
/**
+ * Sets the sampler's texture coordinate domain to a
+ * custom rectangle, rather than the default (0,1).
+ * This option is currently only supported with kClamp_WrapMode
+ */
+ void setTextureDomain(const GrRect& textureDomain) { fTextureDomain = textureDomain; }
+
+ /**
* Multiplies the current sampler matrix a matrix
*
* After this call M' = M*m where M is the old matrix, m is the parameter
@@ -169,6 +182,7 @@
fSampleMode = kNormal_SampleMode;
fFilter = kNearest_Filter;
fMatrix.setIdentity();
+ fTextureDomain.setEmpty();
}
GrScalar getRadial2CenterX1() const { return fRadial2CenterX1; }
@@ -198,6 +212,7 @@
SampleMode fSampleMode;
Filter fFilter;
GrMatrix fMatrix;
+ GrRect fTextureDomain;
// these are undefined unless fSampleMode == kRadial2_SampleMode
GrScalar fRadial2CenterX1;
diff --git a/gpu/include/GrScalar.h b/gpu/include/GrScalar.h
index a26b67c..35cd61a 100644
--- a/gpu/include/GrScalar.h
+++ b/gpu/include/GrScalar.h
@@ -40,6 +40,7 @@
#define GrScalarHalf(a) SkScalarHalf(a)
#define GrScalarAve(a,b) SkScalarAve(a,b)
#define GrMul(a,b) SkScalarMul(a,b)
+#define GrScalarDiv(a,b) SkScalarDiv(a, b)
#define GrScalarToFloat(a) SkScalarToFloat(a)
#define GrFloatToScalar(a) SkScalarToFloat(a)
#define GrIntToScalar(a) SkIntToScalar(a)
diff --git a/gpu/include/GrStencil.h b/gpu/include/GrStencil.h
index b014ee5..44a390d 100644
--- a/gpu/include/GrStencil.h
+++ b/gpu/include/GrStencil.h
@@ -159,7 +159,7 @@
return kKeep_StencilOp == fFrontPassOp &&
kKeep_StencilOp == fBackPassOp &&
kKeep_StencilOp == fFrontFailOp &&
- kKeep_StencilOp == fFrontFailOp &&
+ kKeep_StencilOp == fBackFailOp &&
kAlways_StencilFunc == fFrontFunc &&
kAlways_StencilFunc == fBackFunc;
}
diff --git a/gpu/include/GrTesselatedPathRenderer.h b/gpu/include/GrTesselatedPathRenderer.h
index accd114..e37e66b 100644
--- a/gpu/include/GrTesselatedPathRenderer.h
+++ b/gpu/include/GrTesselatedPathRenderer.h
@@ -25,22 +25,22 @@
virtual void drawPath(GrDrawTarget* target,
GrDrawTarget::StageBitfield stages,
- GrPathIter* path,
+ const GrPath& path,
GrPathFill fill,
const GrPoint* translate);
virtual bool canDrawPath(const GrDrawTarget* target,
- GrPathIter* path,
+ const GrPath& path,
GrPathFill fill) const;
virtual bool requiresStencilPass(const GrDrawTarget* target,
- GrPathIter* path,
+ const GrPath& path,
GrPathFill fill) const { return false; }
virtual void drawPathToStencil(GrDrawTarget* target,
- GrPathIter* path,
+ const GrPath& path,
GrPathFill fill,
const GrPoint* translate);
virtual bool supportsAA(GrDrawTarget* target,
- GrPathIter* path,
+ const GrPath& path,
GrPathFill fill);
};
diff --git a/gpu/include/GrTypes.h b/gpu/include/GrTypes.h
index 08b10f0..9348375 100644
--- a/gpu/include/GrTypes.h
+++ b/gpu/include/GrTypes.h
@@ -18,11 +18,9 @@
#ifndef GrTypes_DEFINED
#define GrTypes_DEFINED
+#include "SkTypes.h"
#include "GrConfig.h"
-#include <memory.h>
-#include <string.h>
-
////////////////////////////////////////////////////////////////////////////////
/**
@@ -53,7 +51,7 @@
* Macro to round n up to the next multiple of 4, or return it unchanged if
* n is already a multiple of 4
*/
-#define GrALIGN4(n) (((n) + 3) >> 2 << 2)
+#define GrALIGN4(n) SkAlign4(n)
#define GrIsALIGN4(n) (((n) & 3) == 0)
template <typename T> const T& GrMin(const T& a, const T& b) {
@@ -111,7 +109,7 @@
/**
* Count elements in an array
*/
-#define GR_ARRAY_COUNT(array) (sizeof(array) / sizeof(array[0]))
+#define GR_ARRAY_COUNT(array) SK_ARRAY_COUNT(array)
//!< allocate a block of memory, will never return NULL
extern void* GrMalloc(size_t bytes);
@@ -232,7 +230,7 @@
kConstA_BlendCoeff, //<! constant color alpha
kIConstA_BlendCoeff, //<! one minus constant color alpha
- kBlendCoeffCount
+ kPublicBlendCoeffCount
};
/**
diff --git a/gpu/src/GrBinHashKey.h b/gpu/src/GrBinHashKey.h
index 683528b..565b460 100644
--- a/gpu/src/GrBinHashKey.h
+++ b/gpu/src/GrBinHashKey.h
@@ -28,19 +28,20 @@
public:
GrBinHashKeyBuilder() {}
virtual ~GrBinHashKeyBuilder() {}
- virtual void keyData(const uint8_t *dataToAdd, size_t len) = 0;
+ virtual void keyData(const uint32_t *dataToAdd, size_t len) = 0;
};
/**
* Hash function class than can take a data stream of indeterminate length.
- * It also has the ability to recieve data in several chunks (steamed). The
- * hash function used is Adler-32.
+ * It also has the ability to recieve data in several chunks (steamed). The
+ * hash function used is the One-at-a-Time Hash
+ * (http://burtleburtle.net/bob/hash/doobs.html).
*
- * Keys are built in two passes the first pass builds the key until the
+ * Keys are built in two passes the first pass builds the key until the
* allocated storage for the key runs out, raw data accumulation stops, but
* the calculation of the 32-bit hash value and total key length continue.
* The second pass is only necessary if storage ran-out during the first pass.
- * If that is the case, the heap storage portion of the key will be
+ * If that is the case, the heap storage portion of the key will be
* re-allocated so that the entire key can be stored in the second pass.
*
* Code for building a key:
@@ -57,9 +58,8 @@
template<typename Entry, size_t StackSize>
class GrBinHashKey : public GrBinHashKeyBuilder {
public:
- GrBinHashKey()
- : fA(1)
- , fB(0)
+ GrBinHashKey()
+ : fA(0)
, fLength(0)
, fHeapData(NULL)
, fPhysicalSize(StackSize)
@@ -77,15 +77,15 @@
// errors with template classes, which are hard to trace back to the use
// of assignment.
GrBinHashKey(const GrBinHashKey<Entry, StackSize>&) {}
- GrBinHashKey<Entry, StackSize>& operator=(const GrBinHashKey<Entry,
+ GrBinHashKey<Entry, StackSize>& operator=(const GrBinHashKey<Entry,
StackSize>&) {
return this;
}
-public:
+public:
void copyAndTakeOwnership(GrBinHashKey<Entry, StackSize>& key) {
- memcpy(this, &key, sizeof(*this));
GrAssert(key.fIsValid);
+ copyFields(key);
if (fUseHeap) {
key.fHeapData = NULL; // ownership transfer
}
@@ -98,7 +98,7 @@
void deepCopyFrom(const GrBinHashKey<Entry, StackSize>& key) {
GrAssert(key.fIsValid);
- memcpy(this, &key, sizeof(key));
+ copyFields(key);
if (fUseHeap) {
fHeapData = reinterpret_cast<uint8_t*>(
GrMalloc(sizeof(uint8_t) * fPhysicalSize));
@@ -121,7 +121,7 @@
if (1 == fPass) {
bool passNeeded = false;
if (fLength > fPhysicalSize) {
- // If the first pass ran out of space the we need to
+ // If the first pass ran out of space the we need to
// re-allocate and perform a second pass
GrFree(fHeapData);
fHeapData = reinterpret_cast<uint8_t*>(
@@ -132,14 +132,15 @@
fLength = 0;
}
fPass++;
- return passNeeded;
+ return passNeeded;
}
return false;
}
- void keyData(const uint8_t *dataToAdd, size_t len) {
+ void keyData(const uint32_t *dataToAdd, size_t len) {
GrAssert(fIsValid);
GrAssert(fPass);
+ GrAssert(GrIsALIGN4(len));
if (fUseHeap) {
GrAssert(fHeapData);
GrAssert(fLength + len <= fPhysicalSize);
@@ -155,13 +156,18 @@
fLength += len;
if (1 == fPass) {
- // update the 32-bit hash
- while (len) {
- fA = (fA + *dataToAdd) % kBigPrime;
- fB = (fB + fA) % kBigPrime;
- dataToAdd++;
- len--;
+ uint32_t a = fA;
+ while (len >= 4) {
+ a += *dataToAdd++;
+ a += (a << 10);
+ a ^= (a >> 6);
+ len -= 4;
}
+ a += (a << 3);
+ a ^= (a >> 11);
+ a += (a << 15);
+
+ fA = a;
}
}
@@ -175,34 +181,44 @@
return memcmp(fStackData, key.fStackData, fLength);
}
}
-
+
return (fLength - key.fLength);
}
- static bool
+ static bool
EQ(const Entry& entry, const GrBinHashKey<Entry, StackSize>& key) {
GrAssert(key.fIsValid);
return 0 == entry.compare(key);
}
-
- static bool
+
+ static bool
LT(const Entry& entry, const GrBinHashKey<Entry, StackSize>& key) {
GrAssert(key.fIsValid);
- return entry.compare(key) < 0;
+ return entry.compare(key) < 0;
}
uint32_t getHash() const {
GrAssert(fIsValid);
- return (fB << 16) | fA;
+ return fA;
}
private:
- // For computing the Adler-32 hash
- enum Constants {
- kBigPrime = 65521 // largest prime smaller than 2^16
- };
+ void copyFields(const GrBinHashKey<Entry, StackSize>& src) {
+ if (fUseHeap) {
+ GrFree(fHeapData);
+ }
+ // We do a field-by-field copy because this is a non-POD
+ // class, and therefore memcpy would be bad
+ fA = src.fA;
+ fLength = src.fLength;
+ memcpy(fStackData, src.fStackData, StackSize);
+ fHeapData = src.fHeapData;
+ fPhysicalSize = src.fPhysicalSize;
+ fUseHeap = src.fUseHeap;
+ fPass = src.fPass;
+ }
+
uint32_t fA;
- uint32_t fB;
// For accumulating the variable length binary key
size_t fLength; // length of data accumulated so far
diff --git a/gpu/src/GrClip.cpp b/gpu/src/GrClip.cpp
index 2d1680c..c2613bb 100644
--- a/gpu/src/GrClip.cpp
+++ b/gpu/src/GrClip.cpp
@@ -132,7 +132,7 @@
}
break;
case kPath_ClipType:
- e.fPath.resetFromIter(iter->getPathIter());
+ e.fPath = *iter->getPath();
if (tx || ty) {
e.fPath.offset(tx, ty);
}
diff --git a/gpu/src/GrContext.cpp b/gpu/src/GrContext.cpp
index 8cb932b..dae1cd1 100644
--- a/gpu/src/GrContext.cpp
+++ b/gpu/src/GrContext.cpp
@@ -19,14 +19,16 @@
#include "GrTextureCache.h"
#include "GrTextStrike.h"
#include "GrMemory.h"
-#include "GrPathIter.h"
#include "GrClipIterator.h"
#include "GrIndexBuffer.h"
#include "GrInOrderDrawBuffer.h"
#include "GrBufferAllocPool.h"
#include "GrPathRenderer.h"
-#define ENABLE_OFFSCREEN_AA 0
+// larger than this, and we don't AA. set to 0 for no AA
+#ifndef GR_MAX_OFFSCREEN_AA_DIM
+ #define GR_MAX_OFFSCREEN_AA_DIM 0
+#endif
#define DEFER_TEXT_RENDERING 1
@@ -107,6 +109,26 @@
////////////////////////////////////////////////////////////////////////////////
+int GrContext::PaintStageVertexLayoutBits(
+ const GrPaint& paint,
+ const bool hasTexCoords[GrPaint::kTotalStages]) {
+ int stageMask = paint.getActiveStageMask();
+ int layout = 0;
+ for (int i = 0; i < GrPaint::kTotalStages; ++i) {
+ if ((1 << i) & stageMask) {
+ if (NULL != hasTexCoords && hasTexCoords[i]) {
+ layout |= GrDrawTarget::StageTexCoordVertexLayoutBit(i, i);
+ } else {
+ layout |= GrDrawTarget::StagePosAsTexCoordVertexLayoutBit(i);
+ }
+ }
+ }
+ return layout;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+
enum {
kNPOTBit = 0x1,
kFilterBit = 0x2,
@@ -360,22 +382,7 @@
return fGpu->createPlatformSurface(desc);
}
-GrRenderTarget* GrContext::createPlatformRenderTarget(intptr_t platformRenderTarget,
- int stencilBits,
- bool isMultisampled,
- int width, int height) {
-#if GR_DEBUG
- GrPrintf("Using deprecated createPlatformRenderTarget API.");
-#endif
- return fGpu->createPlatformRenderTarget(platformRenderTarget,
- stencilBits, isMultisampled,
- width, height);
-}
-
GrRenderTarget* GrContext::createRenderTargetFrom3DApiState() {
-#if GR_DEBUG
- GrPrintf("Using deprecated createRenderTargetFrom3DApiState API.");
-#endif
return fGpu->createRenderTargetFrom3DApiState();
}
@@ -447,7 +454,7 @@
bool GrContext::doOffscreenAA(GrDrawTarget* target,
const GrPaint& paint,
bool isLines) const {
-#if !ENABLE_OFFSCREEN_AA
+#if GR_MAX_OFFSCREEN_AA_DIM==0
return false;
#else
if (!paint.fAntiAlias) {
@@ -477,7 +484,7 @@
bool requireStencil,
const GrIRect& boundRect,
OffscreenRecord* record) {
- GrAssert(ENABLE_OFFSCREEN_AA);
+ GrAssert(GR_MAX_OFFSCREEN_AA_DIM > 0);
GrAssert(NULL == record->fEntry0);
GrAssert(NULL == record->fEntry1);
@@ -577,6 +584,10 @@
GrTexture* src = record->fEntry0->texture();
int scale;
+ enum {
+ kOffscreenStage = GrPaint::kTotalStages,
+ };
+
if (OffscreenRecord::k4x4TwoPass_Downsample == record->fDownsample) {
GrAssert(NULL != record->fEntry1);
scale = 2;
@@ -606,11 +617,14 @@
}
// setup for draw back to main RT
+ int stageMask = paint.getActiveStageMask();
+
target->restoreDrawState(record->fSavedState);
- if (NULL != paint.getTexture()) {
+
+ if (stageMask) {
GrMatrix invVM;
if (target->getViewInverse(&invVM)) {
- target->preConcatSamplerMatrix(0, invVM);
+ target->preConcatSamplerMatrices(stageMask, invVM);
}
}
target->setViewMatrix(GrMatrix::I());
@@ -624,7 +638,7 @@
target->setSamplerState(kOffscreenStage, sampler);
GrRect dstRect;
- int stages = (1 << kOffscreenStage) | (NULL == paint.getTexture() ? 0 : 1);
+ int stages = (1 << kOffscreenStage) | stageMask;
dstRect.set(boundRect);
target->drawSimpleRect(dstRect, NULL, stages);
@@ -662,11 +676,14 @@
}
static GrColor getColorForMesh(const GrPaint& paint) {
- if (NULL == paint.getTexture()) {
- return paint.fColor;
- } else {
+ // FIXME: This was copied from SkGpuDevice, seems like
+ // we should have already smeared a in caller if that
+ // is what is desired.
+ if (paint.hasTexture()) {
unsigned a = GrColorUnpackA(paint.fColor);
return GrColorPackRGBA(a, a, a, a);
+ } else {
+ return paint.fColor;
}
}
@@ -742,10 +759,8 @@
const GrPaint& paint,
const GrRect& devRect) {
- GrVertexLayout layout = GrDrawTarget::kColor_VertexLayoutBit;
- if (NULL != paint.getTexture()) {
- layout |= GrDrawTarget::StagePosAsTexCoordVertexLayoutBit(0);
- }
+ GrVertexLayout layout = PaintStageVertexLayoutBits(paint, NULL) |
+ GrDrawTarget::kColor_VertexLayoutBit;
size_t vsize = GrDrawTarget::VertexSize(layout);
@@ -783,11 +798,8 @@
const GrScalar rx = GrMul(dx, GR_ScalarHalf);
const GrScalar ry = GrMul(dy, GR_ScalarHalf);
- GrVertexLayout layout = GrDrawTarget::kColor_VertexLayoutBit;
-
- if (NULL != paint.getTexture()) {
- layout |= GrDrawTarget::StagePosAsTexCoordVertexLayoutBit(0);
- }
+ GrVertexLayout layout = PaintStageVertexLayoutBits(paint, NULL) |
+ GrDrawTarget::kColor_VertexLayoutBit;
GrScalar spare;
{
@@ -903,9 +915,9 @@
GrScalar width,
const GrMatrix* matrix) {
- bool textured = NULL != paint.getTexture();
GrDrawTarget* target = this->prepareToDraw(paint, kUnbuffered_DrawCategory);
+ int stageMask = paint.getActiveStageMask();
GrRect devRect = rect;
GrMatrix combinedMatrix;
@@ -914,10 +926,10 @@
if (doAA) {
GrDrawTarget::AutoViewMatrixRestore avm(target);
- if (textured) {
+ if (stageMask) {
GrMatrix inv;
if (combinedMatrix.invert(&inv)) {
- target->preConcatSamplerMatrix(0, inv);
+ target->preConcatSamplerMatrices(stageMask, inv);
}
}
target->setViewMatrix(GrMatrix::I());
@@ -941,9 +953,8 @@
// TODO: consider making static vertex buffers for these cases.
// Hairline could be done by just adding closing vertex to
// unitSquareVertexBuffer()
- GrVertexLayout layout = textured ?
- GrDrawTarget::StagePosAsTexCoordVertexLayoutBit(0) :
- 0;
+ GrVertexLayout layout = PaintStageVertexLayoutBits(paint, NULL);
+
static const int worstCaseVertCount = 10;
GrDrawTarget::AutoReleaseGeometry geo(target, layout, worstCaseVertCount, 0);
@@ -974,17 +985,14 @@
if (NULL != matrix) {
avmr.set(target);
target->preConcatViewMatrix(*matrix);
- if (textured) {
- target->preConcatSamplerMatrix(0, *matrix);
- }
+ target->preConcatSamplerMatrices(stageMask, *matrix);
}
target->drawNonIndexed(primType, 0, vertCount);
} else {
#if GR_STATIC_RECT_VB
- GrVertexLayout layout = (textured) ?
- GrDrawTarget::StagePosAsTexCoordVertexLayoutBit(0) :
- 0;
+ GrVertexLayout layout = PaintStageVertexLayoutBits(paint, NULL);
+
target->setVertexSourceToBuffer(layout,
fGpu->getUnitSquareVertexBuffer());
GrDrawTarget::AutoViewMatrixRestore avmr(target);
@@ -998,13 +1006,11 @@
}
target->preConcatViewMatrix(m);
-
- if (textured) {
- target->preConcatSamplerMatrix(0, m);
- }
+ target->preConcatSamplerMatrices(stageMask, m);
+
target->drawNonIndexed(kTriangleFan_PrimitiveType, 0, 4);
#else
- target->drawSimpleRect(rect, matrix, textured ? 1 : 0);
+ target->drawSimpleRect(rect, matrix, stageMask);
#endif
}
}
@@ -1015,7 +1021,8 @@
const GrMatrix* dstMatrix,
const GrMatrix* srcMatrix) {
- if (NULL == paint.getTexture()) {
+ // srcRect refers to paint's first texture
+ if (NULL == paint.getTexture(0)) {
drawRect(paint, dstRect, -1, dstMatrix);
return;
}
@@ -1024,8 +1031,8 @@
#if GR_STATIC_RECT_VB
GrDrawTarget* target = this->prepareToDraw(paint, kUnbuffered_DrawCategory);
-
- GrVertexLayout layout = GrDrawTarget::StagePosAsTexCoordVertexLayoutBit(0);
+
+ GrVertexLayout layout = PaintStageVertexLayoutBits(paint, NULL);
GrDrawTarget::AutoViewMatrixRestore avmr(target);
GrMatrix m;
@@ -1038,13 +1045,20 @@
}
target->preConcatViewMatrix(m);
+ // srcRect refers to first stage
+ int otherStageMask = paint.getActiveStageMask() &
+ (~(1 << GrPaint::kFirstTextureStage));
+ if (otherStageMask) {
+ target->preConcatSamplerMatrices(otherStageMask, m);
+ }
+
m.setAll(srcRect.width(), 0, srcRect.fLeft,
0, srcRect.height(), srcRect.fTop,
0, 0, GrMatrix::I()[8]);
if (NULL != srcMatrix) {
m.postConcat(*srcMatrix);
}
- target->preConcatSamplerMatrix(0, m);
+ target->preConcatSamplerMatrix(GrPaint::kFirstTextureStage, m);
target->setVertexSourceToBuffer(layout, fGpu->getUnitSquareVertexBuffer());
target->drawNonIndexed(kTriangleFan_PrimitiveType, 0, 4);
@@ -1074,26 +1088,22 @@
const GrColor colors[],
const uint16_t indices[],
int indexCount) {
- GrVertexLayout layout = 0;
- int vertexSize = sizeof(GrPoint);
GrDrawTarget::AutoReleaseGeometry geo;
GrDrawTarget* target = this->prepareToDraw(paint, kUnbuffered_DrawCategory);
- if (NULL != paint.getTexture()) {
- if (NULL == texCoords) {
- layout |= GrDrawTarget::StagePosAsTexCoordVertexLayoutBit(0);
- } else {
- layout |= GrDrawTarget::StageTexCoordVertexLayoutBit(0,0);
- vertexSize += sizeof(GrPoint);
- }
- }
+ bool hasTexCoords[GrPaint::kTotalStages] = {
+ NULL != texCoords, // texCoordSrc provides explicit stage 0 coords
+ 0 // remaining stages use positions
+ };
+
+ GrVertexLayout layout = PaintStageVertexLayoutBits(paint, hasTexCoords);
if (NULL != colors) {
layout |= GrDrawTarget::kColor_VertexLayoutBit;
- vertexSize += sizeof(GrColor);
}
+ int vertexSize = GrDrawTarget::VertexSize(layout);
bool doAA = false;
OffscreenRecord record;
@@ -1106,9 +1116,9 @@
}
int texOffsets[GrDrawTarget::kMaxTexCoords];
int colorOffset;
- int vsize = GrDrawTarget::VertexSizeAndOffsetsByIdx(layout,
- texOffsets,
- &colorOffset);
+ GrDrawTarget::VertexSizeAndOffsetsByIdx(layout,
+ texOffsets,
+ &colorOffset);
void* curVertex = geo.vertices();
for (int i = 0; i < vertexCount; ++i) {
@@ -1120,7 +1130,7 @@
if (colorOffset > 0) {
*(GrColor*)((intptr_t)curVertex + colorOffset) = colors[i];
}
- curVertex = (void*)((intptr_t)curVertex + vsize);
+ curVertex = (void*)((intptr_t)curVertex + vertexSize);
}
} else {
// we don't do offscreen AA when we have per-vertex tex coords or colors
@@ -1155,10 +1165,8 @@
///////////////////////////////////////////////////////////////////////////////
-void GrContext::drawPath(const GrPaint& paint,
- GrPathIter* path,
- GrPathFill fill,
- const GrPoint* translate) {
+void GrContext::drawPath(const GrPaint& paint, const GrPath& path,
+ GrPathFill fill, const GrPoint* translate) {
GrDrawTarget* target = this->prepareToDraw(paint, kUnbuffered_DrawCategory);
GrPathRenderer* pr = this->getPathRenderer(target, path, fill);
@@ -1180,9 +1188,10 @@
return;
}
}
- GrRect pathBounds;
- if (path->getConservativeBounds(&pathBounds)) {
- GrIRect pathIBounds;
+
+ GrRect pathBounds = path.getBounds();
+ GrIRect pathIBounds;
+ if (!pathBounds.isEmpty()) {
target->getViewMatrix().mapRect(&pathBounds, pathBounds);
pathBounds.roundOut(&pathIBounds);
if (!bound.intersect(pathIBounds)) {
@@ -1190,29 +1199,27 @@
}
}
+ // for now, abort antialiasing if our bounds are too big, so we don't
+ // hit the FBO size limit
+ if (pathIBounds.width() > GR_MAX_OFFSCREEN_AA_DIM ||
+ pathIBounds.height() > GR_MAX_OFFSCREEN_AA_DIM) {
+ goto NO_AA;
+ }
+
if (this->setupOffscreenAAPass1(target, needsStencil, bound, &record)) {
pr->drawPath(target, 0, path, fill, translate);
this->offscreenAAPass2(target, paint, bound, &record);
return;
}
- }
- GrDrawTarget::StageBitfield enabledStages = 0;
- if (NULL != paint.getTexture()) {
- enabledStages |= 1;
}
+// we can fall out of the AA section for some reasons, and land here
+NO_AA:
+ GrDrawTarget::StageBitfield enabledStages = paint.getActiveStageMask();
+
pr->drawPath(target, enabledStages, path, fill, translate);
}
-void GrContext::drawPath(const GrPaint& paint,
- const GrPath& path,
- GrPathFill fill,
- const GrPoint* translate) {
- GrPath::Iter iter(path);
- this->drawPath(paint, &iter, fill, translate);
-}
-
-
////////////////////////////////////////////////////////////////////////////////
void GrContext::flush(int flagsBitfield) {
@@ -1320,8 +1327,21 @@
////////////////////////////////////////////////////////////////////////////////
void GrContext::SetPaint(const GrPaint& paint, GrDrawTarget* target) {
- target->setTexture(0, paint.getTexture());
- target->setSamplerState(0, paint.fSampler);
+
+ for (int i = 0; i < GrPaint::kMaxTextures; ++i) {
+ int s = i + GrPaint::kFirstTextureStage;
+ target->setTexture(s, paint.getTexture(i));
+ target->setSamplerState(s, *paint.getTextureSampler(i));
+ }
+
+ target->setFirstCoverageStage(GrPaint::kFirstMaskStage);
+
+ for (int i = 0; i < GrPaint::kMaxMasks; ++i) {
+ int s = i + GrPaint::kFirstMaskStage;
+ target->setTexture(s, paint.getMask(i));
+ target->setSamplerState(s, *paint.getMaskSampler(i));
+ }
+
target->setColor(paint.fColor);
if (paint.fDither) {
@@ -1483,7 +1503,7 @@
}
GrPathRenderer* GrContext::getPathRenderer(const GrDrawTarget* target,
- GrPathIter* path,
+ const GrPath& path,
GrPathFill fill) {
if (NULL != fCustomPathRenderer &&
fCustomPathRenderer->canDrawPath(target, path, fill)) {
diff --git a/gpu/src/GrDrawTarget.cpp b/gpu/src/GrDrawTarget.cpp
index 518b4ee..2848999 100644
--- a/gpu/src/GrDrawTarget.cpp
+++ b/gpu/src/GrDrawTarget.cpp
@@ -19,6 +19,8 @@
#include "GrGpuVertex.h"
#include "GrTexture.h"
+namespace {
+
// recursive helper for creating mask with all the tex coord bits set for
// one stage
template <int N>
@@ -26,16 +28,16 @@
return GrDrawTarget::StageTexCoordVertexLayoutBit(stage, N) |
stage_mask_recur<N+1>(stage);
}
-template<> // linux build doesn't like static on specializations
+template<>
int stage_mask_recur<GrDrawTarget::kNumStages>(int) { return 0; }
// mask of all tex coord indices for one stage
-static int stage_tex_coord_mask(int stage) {
+int stage_tex_coord_mask(int stage) {
return stage_mask_recur<0>(stage);
}
// mask of all bits relevant to one stage
-static int stage_mask(int stage) {
+int stage_mask(int stage) {
return stage_tex_coord_mask(stage) |
GrDrawTarget::StagePosAsTexCoordVertexLayoutBit(stage);
}
@@ -47,11 +49,11 @@
return GrDrawTarget::StageTexCoordVertexLayoutBit(N, texCoordIdx) |
tex_coord_mask_recur<N+1>(texCoordIdx);
}
-template<> // linux build doesn't like static on specializations
+template<>
int tex_coord_mask_recur<GrDrawTarget::kMaxTexCoords>(int) { return 0; }
// mask of all bits relevant to one texture coordinate index
-static int tex_coord_idx_mask(int texCoordIdx) {
+int tex_coord_idx_mask(int texCoordIdx) {
return tex_coord_mask_recur<0>(texCoordIdx);
}
@@ -66,6 +68,8 @@
return true;
}
+} //unnamed namespace
+
size_t GrDrawTarget::VertexSize(GrVertexLayout vertexLayout) {
GrAssert(check_layout(vertexLayout));
@@ -370,10 +374,34 @@
fCurrDrawState.fFlagBits &= ~(bits);
}
-void GrDrawTarget::setBlendFunc(GrBlendCoeff srcCoef,
- GrBlendCoeff dstCoef) {
- fCurrDrawState.fSrcBlend = srcCoef;
- fCurrDrawState.fDstBlend = dstCoef;
+void GrDrawTarget::setBlendFunc(GrBlendCoeff srcCoeff,
+ GrBlendCoeff dstCoeff) {
+ fCurrDrawState.fSrcBlend = srcCoeff;
+ fCurrDrawState.fDstBlend = dstCoeff;
+#if GR_DEBUG
+ switch (dstCoeff) {
+ case kDC_BlendCoeff:
+ case kIDC_BlendCoeff:
+ case kDA_BlendCoeff:
+ case kIDA_BlendCoeff:
+ GrPrintf("Unexpected dst blend coeff. Won't work correctly with"
+ "coverage stages.\n");
+ break;
+ default:
+ break;
+ }
+ switch (srcCoeff) {
+ case kSC_BlendCoeff:
+ case kISC_BlendCoeff:
+ case kSA_BlendCoeff:
+ case kISA_BlendCoeff:
+ GrPrintf("Unexpected src blend coeff. Won't work correctly with"
+ "coverage stages.\n");
+ break;
+ default:
+ break;
+ }
+#endif
}
void GrDrawTarget::setColor(GrColor c) {
@@ -478,10 +506,16 @@
///////////////////////////////////////////////////////////////////////////////
bool GrDrawTarget::canDisableBlend() const {
- // If we're using edge antialiasing, we can't force blend off.
- if (fCurrDrawState.fFlagBits & kEdgeAA_StateBit) {
+ // If we compute a coverage value (using edge AA or a coverage stage) then
+ // we can't force blending off.
+ if (fCurrDrawState.fEdgeAANumEdges > 0) {
return false;
}
+ for (int s = fCurrDrawState.fFirstCoverageStage; s < kNumStages; ++s) {
+ if (this->isStageEnabled(s)) {
+ return false;
+ }
+ }
if ((kOne_BlendCoeff == fCurrDrawState.fSrcBlend) &&
(kZero_BlendCoeff == fCurrDrawState.fDstBlend)) {
@@ -506,8 +540,8 @@
return false;
}
- // ...and there isn't a texture with an alpha channel...
- for (int s = 0; s < kNumStages; ++s) {
+ // ...and there isn't a texture stage with an alpha channel...
+ for (int s = 0; s < fCurrDrawState.fFirstCoverageStage; ++s) {
if (this->isStageEnabled(s)) {
GrAssert(NULL != fCurrDrawState.fTextures[s]);
@@ -531,8 +565,10 @@
}
///////////////////////////////////////////////////////////////////////////////
-void GrDrawTarget::setEdgeAAData(const float edges[18]) {
- memcpy(fCurrDrawState.fEdgeAAEdges, edges, sizeof(fCurrDrawState.fEdgeAAEdges));
+void GrDrawTarget::setEdgeAAData(const Edge* edges, int numEdges) {
+ GrAssert(numEdges <= kMaxEdges);
+ memcpy(fCurrDrawState.fEdgeAAEdges, edges, numEdges * sizeof(Edge));
+ fCurrDrawState.fEdgeAANumEdges = numEdges;
}
diff --git a/gpu/src/GrGLEffect.h b/gpu/src/GrGLEffect.h
deleted file mode 100644
index ef00df8..0000000
--- a/gpu/src/GrGLEffect.h
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- Copyright 2011 Google Inc.
-
- 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.
- */
-
-#ifndef GrGLEffect_DEFINED
-#define GrGLEffect_DEFINED
-
-#include "GrGLInterface.h"
-#include "GrStringBuilder.h"
-
-class GrEffect;
-
-struct ShaderCodeSegments {
- GrStringBuilder fVSUnis;
- GrStringBuilder fVSAttrs;
- GrStringBuilder fVaryings;
- GrStringBuilder fFSUnis;
- GrStringBuilder fVSCode;
- GrStringBuilder fFSCode;
-};
-
-/**
- * This class is currently a stub. This will be a base class for "effects",
- * which extend the data model of GrPaint and extend the capability of
- * GrGLProgram in a modular fashion.
- */
-class GrGLEffect {
-protected:
- GrGLEffect(GrEffect* effect) {}
-public:
- virtual ~GrGLEffect() {}
- static GrGLEffect* Create(GrEffect* effect) { return NULL; }
- void genShaderCode(ShaderCodeSegments* segments) {}
- bool doGLSetup(GrPrimitiveType type, GrGLint program) { return true; }
- bool doGLPost() { return true; }
- void buildKey(GrBinHashKeyBuilder& key) const {}
- GrGLEffect* nextEffect() { return NULL; }
-};
-
-#endif
diff --git a/gpu/src/GrGLInterface.cpp b/gpu/src/GrGLInterface.cpp
index 0825a3f..5ecf8eb 100644
--- a/gpu/src/GrGLInterface.cpp
+++ b/gpu/src/GrGLInterface.cpp
@@ -333,6 +333,15 @@
}
}
+ // Dual source blending
+ if (kDesktop_GrGLBinding == fBindingsExported &&
+ (has_gl_extension_from_string("GL_ARB_blend_func_extended", ext) ||
+ (3 < major) || (3 == major && 3 <= minor))) {
+ if (NULL == fBindFragDataLocationIndexed) {
+ return false;
+ }
+ }
+
return true;
}
diff --git a/gpu/src/GrGLProgram.cpp b/gpu/src/GrGLProgram.cpp
index 5d2d8b3..ecb4753 100644
--- a/gpu/src/GrGLProgram.cpp
+++ b/gpu/src/GrGLProgram.cpp
@@ -18,7 +18,6 @@
#include "GrBinHashKey.h"
#include "GrGLConfig.h"
-#include "GrGLEffect.h"
#include "GrMemory.h"
#include "SkXfermode.h"
@@ -86,6 +85,23 @@
return ALL[count];
}
+static inline const char* all_ones_vec(int count) {
+ static const char* ONESVEC[] = {"ERROR", "1.0", "vec2(1,1)",
+ "vec3(1,1,1)", "vec4(1,1,1,1)"};
+ GrAssert(count >= 1 && count < (int)GR_ARRAY_COUNT(ONESVEC));
+ return ONESVEC[count];
+}
+
+static inline const char* all_zeros_vec(int count) {
+ static const char* ZEROSVEC[] = {"ERROR", "0.0", "vec2(0,0)",
+ "vec3(0,0,0)", "vec4(0,0,0,0)"};
+ GrAssert(count >= 1 && count < (int)GR_ARRAY_COUNT(ZEROSVEC));
+ return ZEROSVEC[count];
+}
+
+static inline const char* declared_color_output_name() { return "fsColorOut"; }
+static inline const char* dual_source_output_name() { return "dualSourceOut"; }
+
static void tex_matrix_name(int stage, GrStringBuilder* s) {
#if GR_GL_ATTRIBUTE_MATRICES
*s = "aTexM";
@@ -120,113 +136,194 @@
s->appendS32(stage);
}
+static void tex_domain_name(int stage, GrStringBuilder* s) {
+ *s = "uTexDom";
+ s->appendS32(stage);
+}
+
GrGLProgram::GrGLProgram() {
- for(int stage = 0; stage < GrDrawTarget::kNumStages; ++stage) {
- fStageEffects[stage] = NULL;
- }
}
GrGLProgram::~GrGLProgram() {
}
+void GrGLProgram::overrideBlend(GrBlendCoeff* srcCoeff,
+ GrBlendCoeff* dstCoeff) const {
+ switch (fProgramDesc.fDualSrcOutput) {
+ case ProgramDesc::kNone_DualSrcOutput:
+ break;
+ // the prog will write a coverage value to the secondary
+ // output and the dst is blended by one minus that value.
+ case ProgramDesc::kCoverage_DualSrcOutput:
+ case ProgramDesc::kCoverageISA_DualSrcOutput:
+ case ProgramDesc::kCoverageISC_DualSrcOutput:
+ *dstCoeff = (GrBlendCoeff)GrGpu::kIS2C_BlendCoeff;
+ break;
+ default:
+ GrCrash("Unexpected dual source blend output");
+ break;
+ }
+}
+
void GrGLProgram::buildKey(GrBinHashKeyBuilder& key) const {
// Add stage configuration to the key
- key.keyData(reinterpret_cast<const uint8_t*>(&fProgramDesc), sizeof(ProgramDesc));
+ key.keyData(reinterpret_cast<const uint32_t*>(&fProgramDesc), sizeof(ProgramDesc));
+}
- for(int stage = 0; stage < GrDrawTarget::kNumStages; ++stage) {
- // First pass: count effects and write the count to the key.
- // This may seem like we are adding redundant data to the
- // key, but in ensures the one key cannot be a prefix of
- // another key, or identical to the key of a different program.
- GrGLEffect* currentEffect = fStageEffects[stage];
- uint8_t effectCount = 0;
- while (currentEffect) {
- GrAssert(effectCount < 255); // overflow detection
- ++effectCount;
- currentEffect = currentEffect->nextEffect();
- }
- key.keyData(reinterpret_cast<const uint8_t*>(&effectCount), sizeof(uint8_t));
+// assigns modulation of two vars to an output var
+// vars can be vec4s or floats (or one of each)
+// result is always vec4
+// if either var is "" then assign to the other var
+// if both are "" then assign all ones
+static inline void modulate_helper(const char* outputVar,
+ const char* var0,
+ const char* var1,
+ GrStringBuilder* code) {
+ GrAssert(NULL != outputVar);
+ GrAssert(NULL != var0);
+ GrAssert(NULL != var1);
+ GrAssert(NULL != code);
- // Second pass: continue building key using the effects
- currentEffect = fStageEffects[stage];
- while (currentEffect) {
- fStageEffects[stage]->buildKey(key);
- }
+ bool has0 = '\0' != *var0;
+ bool has1 = '\0' != *var1;
+
+ if (!has0 && !has1) {
+ code->appendf("\t%s = %s;\n", outputVar, all_ones_vec(4));
+ } else if (!has0) {
+ code->appendf("\t%s = vec4(%s);\n", outputVar, var1);
+ } else if (!has1) {
+ code->appendf("\t%s = vec4(%s);\n", outputVar, var0);
+ } else {
+ code->appendf("\t%s = vec4(%s * %s);\n", outputVar, var0, var1);
}
}
-bool GrGLProgram::doGLSetup(GrPrimitiveType type,
- GrGLProgram::CachedData* programData) const {
- for (int stage = 0; stage < GrDrawTarget::kNumStages; ++stage) {
- GrGLEffect* effect = fStageEffects[stage];
- if (effect) {
- if (!effect->doGLSetup(type, programData->fProgramID)) {
- return false;
- }
- }
- }
+// assigns addition of two vars to an output var
+// vars can be vec4s or floats (or one of each)
+// result is always vec4
+// if either var is "" then assign to the other var
+// if both are "" then assign all zeros
+static inline void add_helper(const char* outputVar,
+ const char* var0,
+ const char* var1,
+ GrStringBuilder* code) {
+ GrAssert(NULL != outputVar);
+ GrAssert(NULL != var0);
+ GrAssert(NULL != var1);
+ GrAssert(NULL != code);
- return true;
+ bool has0 = '\0' != *var0;
+ bool has1 = '\0' != *var1;
+
+ if (!has0 && !has1) {
+ code->appendf("\t%s = %s;\n", outputVar, all_zeros_vec(4));
+ } else if (!has0) {
+ code->appendf("\t%s = vec4(%s);\n", outputVar, var1);
+ } else if (!has1) {
+ code->appendf("\t%s = vec4(%s);\n", outputVar, var0);
+ } else {
+ code->appendf("\t%s = vec4(%s + %s);\n", outputVar, var0, var1);
+ }
}
-void GrGLProgram::doGLPost() const {
- for (int stage = 0; stage < GrDrawTarget::kNumStages; ++stage) {
- GrGLEffect* effect = fStageEffects[stage];
- if (effect) {
- effect->doGLPost();
- }
+// given two blend coeffecients determine whether the src
+// and/or dst computation can be omitted.
+static inline void needBlendInputs(SkXfermode::Coeff srcCoeff,
+ SkXfermode::Coeff dstCoeff,
+ bool* needSrcValue,
+ bool* needDstValue) {
+ if (SkXfermode::kZero_Coeff == srcCoeff) {
+ switch (dstCoeff) {
+ // these all read the src
+ case SkXfermode::kSC_Coeff:
+ case SkXfermode::kISC_Coeff:
+ case SkXfermode::kSA_Coeff:
+ case SkXfermode::kISA_Coeff:
+ *needSrcValue = true;
+ break;
+ default:
+ *needSrcValue = false;
+ break;
+ }
+ } else {
+ *needSrcValue = true;
+ }
+ if (SkXfermode::kZero_Coeff == dstCoeff) {
+ switch (srcCoeff) {
+ // these all read the dst
+ case SkXfermode::kDC_Coeff:
+ case SkXfermode::kIDC_Coeff:
+ case SkXfermode::kDA_Coeff:
+ case SkXfermode::kIDA_Coeff:
+ *needDstValue = true;
+ break;
+ default:
+ *needDstValue = false;
+ break;
+ }
+ } else {
+ *needDstValue = true;
}
}
/**
- * Create a text coefficient to be used in fragment shader code.
+ * Create a blend_coeff * value string to be used in shader code. Sets empty
+ * string if result is trivially zero.
*/
-static void coefficientString(GrStringBuilder* str, SkXfermode::Coeff coeff,
- const char* src, const char* dst) {
+static void blendTermString(GrStringBuilder* str, SkXfermode::Coeff coeff,
+ const char* src, const char* dst,
+ const char* value) {
switch (coeff) {
case SkXfermode::kZero_Coeff: /** 0 */
- *str = "0.0";
+ *str = "";
break;
case SkXfermode::kOne_Coeff: /** 1 */
- *str = "1.0";
- break;
- case SkXfermode::kSA_Coeff: /** src alpha */
- str->appendf("%s.a", src);
- break;
- case SkXfermode::kISA_Coeff: /** inverse src alpha (i.e. 1 - sa) */
- str->appendf("(1.0 - %s.a)", src);
- break;
- case SkXfermode::kDA_Coeff: /** dst alpha */
- str->appendf("%s.a", dst);
- break;
- case SkXfermode::kIDA_Coeff: /** inverse dst alpha (i.e. 1 - da) */
- str->appendf("(1.0 - %s.a)", dst);
+ *str = value;
break;
case SkXfermode::kSC_Coeff:
- str->append(src);
+ str->printf("(%s * %s)", src, value);
+ break;
+ case SkXfermode::kISC_Coeff:
+ str->printf("((%s - %s) * %s)", all_ones_vec(4), src, value);
+ break;
+ case SkXfermode::kDC_Coeff:
+ str->printf("(%s * %s)", dst, value);
+ break;
+ case SkXfermode::kIDC_Coeff:
+ str->printf("((%s - %s) * %s)", all_ones_vec(4), dst, value);
+ break;
+ case SkXfermode::kSA_Coeff: /** src alpha */
+ str->printf("(%s.a * %s)", src, value);
+ break;
+ case SkXfermode::kISA_Coeff: /** inverse src alpha (i.e. 1 - sa) */
+ str->printf("((1.0 - %s.a) * %s)", src, value);
+ break;
+ case SkXfermode::kDA_Coeff: /** dst alpha */
+ str->printf("(%s.a * %s)", dst, value);
+ break;
+ case SkXfermode::kIDA_Coeff: /** inverse dst alpha (i.e. 1 - da) */
+ str->printf("((1.0 - %s.a) * %s)", dst, value);
break;
default:
+ GrCrash("Unexpected xfer coeff.");
break;
}
}
-
/**
* Adds a line to the fragment shader code which modifies the color by
* the specified color filter.
*/
-static void addColorFilter(GrStringBuilder* FSCode, const char * outputVar,
- SkXfermode::Mode colorFilterXfermode, const char* dstColor) {
- SkXfermode::Coeff srcCoeff, dstCoeff;
- SkDEBUGCODE(bool success =)
- SkXfermode::ModeAsCoeff(colorFilterXfermode, &srcCoeff, &dstCoeff);
- // We currently do not handle modes that cannot be represented as
- // coefficients.
- GrAssert(success);
- GrStringBuilder srcCoeffStr, dstCoeffStr;
- coefficientString(&srcCoeffStr, srcCoeff, COL_FILTER_UNI_NAME, dstColor);
- coefficientString(&dstCoeffStr, dstCoeff, COL_FILTER_UNI_NAME, dstColor);
- FSCode->appendf("\t%s = %s*%s + %s*%s;\n", outputVar, srcCoeffStr.c_str(),
- COL_FILTER_UNI_NAME, dstCoeffStr.c_str(), dstColor);
+static void addColorFilter(GrStringBuilder* fsCode, const char * outputVar,
+ SkXfermode::Coeff uniformCoeff,
+ SkXfermode::Coeff colorCoeff,
+ const char* inColor) {
+ GrStringBuilder colorStr, constStr;
+ blendTermString(&colorStr, colorCoeff, COL_FILTER_UNI_NAME,
+ inColor, inColor);
+ blendTermString(&constStr, uniformCoeff, COL_FILTER_UNI_NAME,
+ inColor, COL_FILTER_UNI_NAME);
+
+ add_helper(outputVar, colorStr.c_str(), constStr.c_str(), fsCode);
}
bool GrGLProgram::genProgram(GrGLProgram::CachedData* programData) const {
@@ -236,6 +333,39 @@
programData->fUniLocations.reset();
+ SkXfermode::Coeff colorCoeff, uniformCoeff;
+ // The rest of transfer mode color filters have not been implemented
+ if (fProgramDesc.fColorFilterXfermode < SkXfermode::kCoeffModesCnt) {
+ GR_DEBUGCODE(bool success =)
+ SkXfermode::ModeAsCoeff(static_cast<SkXfermode::Mode>
+ (fProgramDesc.fColorFilterXfermode),
+ &uniformCoeff, &colorCoeff);
+ GR_DEBUGASSERT(success);
+ } else {
+ colorCoeff = SkXfermode::kOne_Coeff;
+ uniformCoeff = SkXfermode::kZero_Coeff;
+ }
+
+ bool needColorFilterUniform;
+ bool needComputedColor;
+ needBlendInputs(uniformCoeff, colorCoeff,
+ &needColorFilterUniform, &needComputedColor);
+
+ // the dual source output has no canonical var name, have to
+ // declare an output, which is incompatible with gl_FragColor/gl_FragData.
+ const char* fsColorOutput;
+ bool dualSourceOutputWritten = false;
+ bool usingDeclaredOutputs = ProgramDesc::kNone_DualSrcOutput !=
+ fProgramDesc.fDualSrcOutput;
+ if (usingDeclaredOutputs) {
+ GrAssert(0 == segments.fHeader.size());
+ segments.fHeader.printf("#version 150\n");
+ fsColorOutput = declared_color_output_name();
+ segments.fFSOutputs.appendf("out vec4 %s;\n", fsColorOutput);
+ } else {
+ fsColorOutput = "gl_FragColor";
+ }
+
#if GR_GL_ATTRIBUTE_MATRICES
segments.fVSAttrs += "attribute mat3 " VIEW_MATRIX_NAME ";\n";
programData->fUniLocations.fViewMatrixUni = kSetAsAttribute;
@@ -253,25 +383,23 @@
// incoming color to current stage being processed.
GrStringBuilder inColor;
- switch (fProgramDesc.fColorType) {
- case ProgramDesc::kAttribute_ColorType:
- segments.fVSAttrs.append( "attribute vec4 " COL_ATTR_NAME ";\n");
- segments.fVaryings.append("varying vec4 vColor;\n");
- segments.fVSCode.append( "\tvColor = " COL_ATTR_NAME ";\n");
- inColor = "vColor";
- break;
- case ProgramDesc::kUniform_ColorType:
- segments.fFSUnis.append( "uniform vec4 " COL_UNI_NAME ";\n");
- programData->fUniLocations.fColorUni = kUseUniform;
- inColor = COL_UNI_NAME;
- break;
- case ProgramDesc::kNone_ColorType:
- inColor = "";
- break;
- }
-
- if (fProgramDesc.fUsesEdgeAA) {
- segments.fFSUnis.append("uniform vec3 " EDGES_UNI_NAME "[6];\n");
+ if (needComputedColor) {
+ switch (fProgramDesc.fColorType) {
+ case ProgramDesc::kAttribute_ColorType:
+ segments.fVSAttrs.append( "attribute vec4 " COL_ATTR_NAME ";\n");
+ segments.fVaryings.append("varying vec4 vColor;\n");
+ segments.fVSCode.append( "\tvColor = " COL_ATTR_NAME ";\n");
+ inColor = "vColor";
+ break;
+ case ProgramDesc::kUniform_ColorType:
+ segments.fFSUnis.append( "uniform vec4 " COL_UNI_NAME ";\n");
+ programData->fUniLocations.fColorUni = kUseUniform;
+ inColor = COL_UNI_NAME;
+ break;
+ default:
+ GrAssert(ProgramDesc::kNone_ColorType == fProgramDesc.fColorType);
+ break;
+ }
}
if (fProgramDesc.fEmitsPointSize){
@@ -289,109 +417,204 @@
}
}
- bool useColorFilter =
- // The rest of transfer mode color filters have not been implemented
- fProgramDesc.fColorFilterXfermode <= SkXfermode::kMultiply_Mode
- // This mode has no effect.
- && fProgramDesc.fColorFilterXfermode != SkXfermode::kDst_Mode;
- bool onlyUseColorFilter = useColorFilter
- && (fProgramDesc.fColorFilterXfermode == SkXfermode::kClear_Mode
- || fProgramDesc.fColorFilterXfermode == SkXfermode::kSrc_Mode);
- if (useColorFilter) {
- // Set up a uniform for the color
- segments.fFSUnis.append( "uniform vec4 " COL_FILTER_UNI_NAME ";\n");
- programData->fUniLocations.fColorFilterUni = kUseUniform;
- }
+ ///////////////////////////////////////////////////////////////////////////
+ // compute the final color
- // for each enabled stage figure out what the input coordinates are
- // and count the number of stages in use.
- const char* stageInCoords[GrDrawTarget::kNumStages];
- int numActiveStages = 0;
+ // if we have color stages string them together, feeding the output color
+ // of each to the next and generating code for each stage.
+ if (needComputedColor) {
+ GrStringBuilder outColor;
+ for (int s = 0; s < fProgramDesc.fFirstCoverageStage; ++s) {
+ if (fProgramDesc.fStages[s].isEnabled()) {
+ // create var to hold stage result
+ outColor = "color";
+ outColor.appendS32(s);
+ segments.fFSCode.appendf("\tvec4 %s;\n", outColor.c_str());
- if (!onlyUseColorFilter) {
- for (int s = 0; s < GrDrawTarget::kNumStages; ++s) {
- if (fProgramDesc.fStages[s].fEnabled) {
- if (GrDrawTarget::StagePosAsTexCoordVertexLayoutBit(s) & layout) {
- stageInCoords[s] = POS_ATTR_NAME;
+ const char* inCoords;
+ // figure out what our input coords are
+ if (GrDrawTarget::StagePosAsTexCoordVertexLayoutBit(s) &
+ layout) {
+ inCoords = POS_ATTR_NAME;
} else {
int tcIdx = GrDrawTarget::VertexTexCoordsForStage(s, layout);
// we better have input tex coordinates if stage is enabled.
GrAssert(tcIdx >= 0);
GrAssert(texCoordAttrs[tcIdx].size());
- stageInCoords[s] = texCoordAttrs[tcIdx].c_str();
- }
- ++numActiveStages;
- }
- }
- }
-
- // if we have active stages string them together, feeding the output color
- // of each to the next and generating code for each stage.
- if (numActiveStages) {
- int currActiveStage = 0;
- GrStringBuilder outColor;
- for (int s = 0; s < GrDrawTarget::kNumStages; ++s) {
- if (fProgramDesc.fStages[s].fEnabled) {
- if (currActiveStage < (numActiveStages - 1) || useColorFilter) {
- outColor = "color";
- outColor.appendS32(currActiveStage);
- segments.fFSCode.appendf("\tvec4 %s;\n", outColor.c_str());
- } else {
- outColor = "gl_FragColor";
+ inCoords = texCoordAttrs[tcIdx].c_str();
}
genStageCode(s,
fProgramDesc.fStages[s],
inColor.size() ? inColor.c_str() : NULL,
outColor.c_str(),
- stageInCoords[s],
+ inCoords,
&segments,
&programData->fUniLocations.fStages[s]);
- ++currActiveStage;
inColor = outColor;
}
}
- if (useColorFilter) {
- addColorFilter(&segments.fFSCode, "gl_FragColor",
- fProgramDesc.fColorFilterXfermode, outColor.c_str());
+ }
+
+ // if have all ones for the "dst" input to the color filter then we can make
+ // additional optimizations.
+ if (needColorFilterUniform && !inColor.size() &&
+ (SkXfermode::kIDC_Coeff == uniformCoeff ||
+ SkXfermode::kIDA_Coeff == uniformCoeff)) {
+ uniformCoeff = SkXfermode::kZero_Coeff;
+ bool bogus;
+ needBlendInputs(SkXfermode::kZero_Coeff, colorCoeff,
+ &needColorFilterUniform, &bogus);
+ }
+ if (needColorFilterUniform) {
+ segments.fFSUnis.append( "uniform vec4 " COL_FILTER_UNI_NAME ";\n");
+ programData->fUniLocations.fColorFilterUni = kUseUniform;
+ }
+
+ bool wroteFragColorZero = false;
+ if (SkXfermode::kZero_Coeff == uniformCoeff &&
+ SkXfermode::kZero_Coeff == colorCoeff) {
+ segments.fFSCode.appendf("\t%s = %s;\n",
+ fsColorOutput,
+ all_zeros_vec(4));
+ wroteFragColorZero = true;
+ } else if (SkXfermode::kDst_Mode != fProgramDesc.fColorFilterXfermode) {
+ segments.fFSCode.appendf("\tvec4 filteredColor;\n");
+ const char* color = inColor.size() ? inColor.c_str() : all_ones_vec(4);
+ addColorFilter(&segments.fFSCode, "filteredColor", uniformCoeff,
+ colorCoeff, color);
+ inColor = "filteredColor";
+ }
+
+ ///////////////////////////////////////////////////////////////////////////
+ // compute the partial coverage (coverage stages and edge aa)
+
+ GrStringBuilder inCoverage;
+
+ // we don't need to compute coverage at all if we know the final shader
+ // output will be zero and we don't have a dual src blend output.
+ if (!wroteFragColorZero ||
+ ProgramDesc::kNone_DualSrcOutput != fProgramDesc.fDualSrcOutput) {
+ if (fProgramDesc.fEdgeAANumEdges > 0) {
+ segments.fFSUnis.append("uniform vec3 " EDGES_UNI_NAME "[");
+ segments.fFSUnis.appendS32(fProgramDesc.fEdgeAANumEdges);
+ segments.fFSUnis.append("];\n");
+ programData->fUniLocations.fEdgesUni = kUseUniform;
+ int count = fProgramDesc.fEdgeAANumEdges;
+ segments.fFSCode.append(
+ "\tvec3 pos = vec3(gl_FragCoord.xy, 1);\n");
+ for (int i = 0; i < count; i++) {
+ segments.fFSCode.append("\tfloat a");
+ segments.fFSCode.appendS32(i);
+ segments.fFSCode.append(" = clamp(dot(" EDGES_UNI_NAME "[");
+ segments.fFSCode.appendS32(i);
+ segments.fFSCode.append("], pos), 0.0, 1.0);\n");
+ }
+ segments.fFSCode.append("\tfloat edgeAlpha = ");
+ for (int i = 0; i < count - 1; i++) {
+ segments.fFSCode.append("min(a");
+ segments.fFSCode.appendS32(i);
+ segments.fFSCode.append(" * a");
+ segments.fFSCode.appendS32(i + 1);
+ segments.fFSCode.append(", ");
+ }
+ segments.fFSCode.append("a");
+ segments.fFSCode.appendS32(count - 1);
+ segments.fFSCode.append(" * a0");
+ for (int i = 0; i < count - 1; i++) {
+ segments.fFSCode.append(")");
+ }
+ segments.fFSCode.append(";\n");
+ inCoverage = "edgeAlpha";
}
- } else {
- if (fProgramDesc.fUsesEdgeAA) {
- // FIXME: put the a's in a loop
- segments.fFSCode.append(
- "\tvec3 pos = vec3(gl_FragCoord.xy, 1);\n"
- "\tfloat a0 = clamp(dot(uEdges[0], pos), 0.0, 1.0);\n"
- "\tfloat a1 = clamp(dot(uEdges[1], pos), 0.0, 1.0);\n"
- "\tfloat a2 = clamp(dot(uEdges[2], pos), 0.0, 1.0);\n"
- "\tfloat a3 = clamp(dot(uEdges[3], pos), 0.0, 1.0);\n"
- "\tfloat a4 = clamp(dot(uEdges[4], pos), 0.0, 1.0);\n"
- "\tfloat a5 = clamp(dot(uEdges[5], pos), 0.0, 1.0);\n"
- "\tfloat edgeAlpha = min(min(a0 * a1, a2 * a3), a4 * a5);\n");
- if (inColor.size()) {
- inColor.append(" * edgeAlpha");
- } else {
- inColor = "vec4(edgeAlpha)";
+ GrStringBuilder outCoverage;
+ const int& startStage = fProgramDesc.fFirstCoverageStage;
+ for (int s = startStage; s < GrDrawTarget::kNumStages; ++s) {
+ if (fProgramDesc.fStages[s].isEnabled()) {
+ // create var to hold stage output
+ outCoverage = "coverage";
+ outCoverage.appendS32(s);
+ segments.fFSCode.appendf("\tvec4 %s;\n", outCoverage.c_str());
+
+ const char* inCoords;
+ // figure out what our input coords are
+ if (GrDrawTarget::StagePosAsTexCoordVertexLayoutBit(s) & layout) {
+ inCoords = POS_ATTR_NAME;
+ } else {
+ int tcIdx = GrDrawTarget::VertexTexCoordsForStage(s, layout);
+ // we better have input tex coordinates if stage is enabled.
+ GrAssert(tcIdx >= 0);
+ GrAssert(texCoordAttrs[tcIdx].size());
+ inCoords = texCoordAttrs[tcIdx].c_str();
+ }
+
+ genStageCode(s,
+ fProgramDesc.fStages[s],
+ inCoverage.size() ? inCoverage.c_str() : NULL,
+ outCoverage.c_str(),
+ inCoords,
+ &segments,
+ &programData->fUniLocations.fStages[s]);
+ inCoverage = outCoverage;
}
}
- // we may not have any incoming color
- const char * incomingColor = (inColor.size() ? inColor.c_str()
- : "vec4(1,1,1,1)");
- if (useColorFilter) {
- addColorFilter(&segments.fFSCode, "gl_FragColor",
- fProgramDesc.fColorFilterXfermode, incomingColor);
- } else {
- segments.fFSCode.appendf("\tgl_FragColor = %s;\n", incomingColor);
+ if (ProgramDesc::kNone_DualSrcOutput != fProgramDesc.fDualSrcOutput) {
+ segments.fFSOutputs.appendf("out vec4 %s;\n",
+ dual_source_output_name());
+ bool outputIsZero = false;
+ GrStringBuilder coeff;
+ if (ProgramDesc::kCoverage_DualSrcOutput !=
+ fProgramDesc.fDualSrcOutput && !wroteFragColorZero) {
+ if (!inColor.size()) {
+ outputIsZero = true;
+ } else {
+ if (fProgramDesc.fDualSrcOutput ==
+ ProgramDesc::kCoverageISA_DualSrcOutput) {
+ coeff.printf("(1 - %s.a)", inColor.c_str());
+ } else {
+ coeff.printf("(vec4(1,1,1,1) - %s)", inColor.c_str());
+ }
+ }
+ }
+ if (outputIsZero) {
+ segments.fFSCode.appendf("\t%s = %s;\n",
+ dual_source_output_name(),
+ all_zeros_vec(4));
+ } else {
+ modulate_helper(dual_source_output_name(),
+ coeff.c_str(),
+ inCoverage.c_str(),
+ &segments.fFSCode);
+ }
+ dualSourceOutputWritten = true;
}
}
+
+ ///////////////////////////////////////////////////////////////////////////
+ // combine color and coverage as frag color
+
+ if (!wroteFragColorZero) {
+ modulate_helper(fsColorOutput,
+ inColor.c_str(),
+ inCoverage.c_str(),
+ &segments.fFSCode);
+ }
+
segments.fVSCode.append("}\n");
segments.fFSCode.append("}\n");
+ ///////////////////////////////////////////////////////////////////////////
+ // compile and setup attribs and unis
+
if (!CompileFSAndVS(segments, programData)) {
return false;
}
- if (!this->bindAttribsAndLinkProgram(texCoordAttrs, programData)) {
+ if (!this->bindOutputsAttribsAndLinkProgram(texCoordAttrs,
+ usingDeclaredOutputs,
+ dualSourceOutputWritten,
+ programData)) {
return false;
}
@@ -403,10 +626,16 @@
bool GrGLProgram::CompileFSAndVS(const ShaderCodeSegments& segments,
CachedData* programData) {
- const char* strings[4];
- int lengths[4];
+ static const int MAX_STRINGS = 6;
+ const char* strings[MAX_STRINGS];
+ int lengths[MAX_STRINGS];
int stringCnt = 0;
+ if (segments.fHeader.size()) {
+ strings[stringCnt] = segments.fHeader.c_str();
+ lengths[stringCnt] = segments.fHeader.size();
+ ++stringCnt;
+ }
if (segments.fVSUnis.size()) {
strings[stringCnt] = segments.fVSUnis.c_str();
lengths[stringCnt] = segments.fVSUnis.size();
@@ -429,12 +658,14 @@
++stringCnt;
#if PRINT_SHADERS
+ GrPrintf(segments.fHeader.c_str());
GrPrintf(segments.fVSUnis.c_str());
GrPrintf(segments.fVSAttrs.c_str());
GrPrintf(segments.fVaryings.c_str());
GrPrintf(segments.fVSCode.c_str());
GrPrintf("\n");
#endif
+ GrAssert(stringCnt <= MAX_STRINGS);
programData->fVShaderID = CompileShader(GR_GL_VERTEX_SHADER,
stringCnt,
strings,
@@ -446,6 +677,11 @@
stringCnt = 0;
+ if (segments.fHeader.size()) {
+ strings[stringCnt] = segments.fHeader.c_str();
+ lengths[stringCnt] = segments.fHeader.size();
+ ++stringCnt;
+ }
if (strlen(GrShaderPrecision()) > 1) {
strings[stringCnt] = GrShaderPrecision();
lengths[stringCnt] = strlen(GrShaderPrecision());
@@ -461,6 +697,11 @@
lengths[stringCnt] = segments.fVaryings.size();
++stringCnt;
}
+ if (segments.fFSOutputs.size()) {
+ strings[stringCnt] = segments.fFSOutputs.c_str();
+ lengths[stringCnt] = segments.fFSOutputs.size();
+ ++stringCnt;
+ }
GrAssert(segments.fFSCode.size());
strings[stringCnt] = segments.fFSCode.c_str();
@@ -468,12 +709,15 @@
++stringCnt;
#if PRINT_SHADERS
+ GrPrintf(segments.fHeader.c_str());
GrPrintf(GrShaderPrecision());
GrPrintf(segments.fFSUnis.c_str());
GrPrintf(segments.fVaryings.c_str());
+ GrPrintf(segments.fFSOutputs.c_str());
GrPrintf(segments.fFSCode.c_str());
GrPrintf("\n");
#endif
+ GrAssert(stringCnt <= MAX_STRINGS);
programData->fFShaderID = CompileShader(GR_GL_FRAGMENT_SHADER,
stringCnt,
strings,
@@ -482,6 +726,7 @@
if (!programData->fFShaderID) {
return false;
}
+
return true;
}
@@ -521,8 +766,11 @@
return shader;
}
-bool GrGLProgram::bindAttribsAndLinkProgram(GrStringBuilder texCoordAttrNames[],
- CachedData* programData) const {
+bool GrGLProgram::bindOutputsAttribsAndLinkProgram(
+ GrStringBuilder texCoordAttrNames[],
+ bool bindColorOut,
+ bool bindDualSrcOut,
+ CachedData* programData) const {
programData->fProgramID = GR_GL(CreateProgram());
if (!programData->fProgramID) {
return false;
@@ -532,6 +780,15 @@
GR_GL(AttachShader(progID, programData->fVShaderID));
GR_GL(AttachShader(progID, programData->fFShaderID));
+ if (bindColorOut) {
+ GR_GL(BindFragDataLocationIndexed(programData->fProgramID,
+ 0, 0, declared_color_output_name()));
+ }
+ if (bindDualSrcOut) {
+ GR_GL(BindFragDataLocationIndexed(programData->fProgramID,
+ 0, 1, dual_source_output_name()));
+ }
+
// Bind the attrib locations to same values for all shaders
GR_GL(BindAttribLocation(progID, PositionAttributeIdx(), POS_ATTR_NAME));
for (int t = 0; t < GrDrawTarget::kMaxTexCoords; ++t) {
@@ -542,7 +799,6 @@
}
}
-
if (kSetAsAttribute == programData->fUniLocations.fViewMatrixUni) {
GR_GL(BindAttribLocation(progID,
ViewMatrixAttributeIdx(),
@@ -560,7 +816,6 @@
}
}
-
GR_GL(BindAttribLocation(progID, ColorAttributeIdx(), COL_ATTR_NAME));
GR_GL(LinkProgram(progID));
@@ -595,18 +850,18 @@
GrAssert(kUnusedUniform != programData->fUniLocations.fViewMatrixUni);
}
if (kUseUniform == programData->fUniLocations.fColorUni) {
- programData->fUniLocations.fColorUni =
+ programData->fUniLocations.fColorUni =
GR_GL(GetUniformLocation(progID, COL_UNI_NAME));
GrAssert(kUnusedUniform != programData->fUniLocations.fColorUni);
}
if (kUseUniform == programData->fUniLocations.fColorFilterUni) {
- programData->fUniLocations.fColorFilterUni =
+ programData->fUniLocations.fColorFilterUni =
GR_GL(GetUniformLocation(progID, COL_FILTER_UNI_NAME));
GrAssert(kUnusedUniform != programData->fUniLocations.fColorFilterUni);
}
- if (fProgramDesc.fUsesEdgeAA) {
- programData->fUniLocations.fEdgesUni =
+ if (kUseUniform == programData->fUniLocations.fEdgesUni) {
+ programData->fUniLocations.fEdgesUni =
GR_GL(GetUniformLocation(progID, EDGES_UNI_NAME));
GrAssert(kUnusedUniform != programData->fUniLocations.fEdgesUni);
} else {
@@ -615,7 +870,7 @@
for (int s = 0; s < GrDrawTarget::kNumStages; ++s) {
StageUniLocations& locations = programData->fUniLocations.fStages[s];
- if (fProgramDesc.fStages[s].fEnabled) {
+ if (fProgramDesc.fStages[s].isEnabled()) {
if (kUseUniform == locations.fTextureMatrixUni) {
GrStringBuilder texMName;
tex_matrix_name(s, &texMName);
@@ -637,7 +892,7 @@
if (kUseUniform == locations.fNormalizedTexelSizeUni) {
GrStringBuilder texelSizeName;
normalized_texel_size_name(s, &texelSizeName);
- locations.fNormalizedTexelSizeUni =
+ locations.fNormalizedTexelSizeUni =
GR_GL(GetUniformLocation(progID, texelSizeName.c_str()));
GrAssert(kUnusedUniform != locations.fNormalizedTexelSizeUni);
}
@@ -650,6 +905,15 @@
radial2ParamName.c_str()));
GrAssert(kUnusedUniform != locations.fRadial2Uni);
}
+
+ if (kUseUniform == locations.fTexDomUni) {
+ GrStringBuilder texDomName;
+ tex_domain_name(s, &texDomName);
+ locations.fTexDomUni = GR_GL(GetUniformLocation(
+ progID,
+ texDomName.c_str()));
+ GrAssert(kUnusedUniform != locations.fTexDomUni);
+ }
}
}
GR_GL(UseProgram(progID));
@@ -726,7 +990,7 @@
segments->fFSUnis.appendf("uniform vec2 %s;\n", texelSizeName.c_str());
}
- segments->fVaryings.appendf("varying %s %s;\n",
+ segments->fVaryings.appendf("varying %s %s;\n",
float_vector_type(varyingDims), varyingName.c_str());
if (desc.fOptFlags & ProgramDesc::StageDesc::kIdentityMatrix_OptFlagBit) {
@@ -748,9 +1012,9 @@
if (ProgramDesc::StageDesc::kRadial2Gradient_CoordMapping == desc.fCoordMapping) {
- segments->fVSUnis.appendf("uniform %s float %s[6];\n",
+ segments->fVSUnis.appendf("uniform %s float %s[6];\n",
GrPrecision(), radial2ParamsName.c_str());
- segments->fFSUnis.appendf("uniform float %s[6];\n",
+ segments->fFSUnis.appendf("uniform float %s[6];\n",
radial2ParamsName.c_str());
locations->fRadial2Uni = kUseUniform;
@@ -869,6 +1133,24 @@
modulate.printf(" * %s", fsInColor);
}
+ if (desc.fOptFlags &
+ ProgramDesc::StageDesc::kCustomTextureDomain_OptFlagBit) {
+ GrStringBuilder texDomainName;
+ tex_domain_name(stageNum, &texDomainName);
+ segments->fFSUnis.appendf("uniform %s %s;\n",
+ float_vector_type(4),
+ texDomainName.c_str());
+ GrStringBuilder coordVar("clampCoord");
+ segments->fFSCode.appendf("\t%s %s = clamp(%s, %s.xy, %s.zw);\n",
+ float_vector_type(coordDims),
+ coordVar.c_str(),
+ sampleCoords.c_str(),
+ texDomainName.c_str(),
+ texDomainName.c_str());
+ sampleCoords = coordVar;
+ locations->fTexDomUni = kUseUniform;
+ }
+
if (ProgramDesc::StageDesc::k2x2_FetchMode == desc.fFetchMode) {
locations->fNormalizedTexelSizeUni = kUseUniform;
if (complexCoord) {
@@ -889,11 +1171,6 @@
segments->fFSCode.appendf("\t%s += %s(%s, %s + vec2(+%s.x,+%s.y))%s;\n", accumVar.c_str(), texFunc.c_str(), samplerName.c_str(), sampleCoords.c_str(), texelSizeName.c_str(), texelSizeName.c_str(), smear);
segments->fFSCode.appendf("\t%s = .25 * %s%s;\n", fsOutColor, accumVar.c_str(), modulate.c_str());
} else {
- segments->fFSCode.appendf("\t%s = %s(%s, %s)%s %s;\n", fsOutColor, texFunc.c_str(), samplerName.c_str(), sampleCoords.c_str(), smear, modulate.c_str());
- }
-
- if(fStageEffects[stageNum]) {
- fStageEffects[stageNum]->genShaderCode(segments);
+ segments->fFSCode.appendf("\t%s = %s(%s, %s)%s%s;\n", fsOutColor, texFunc.c_str(), samplerName.c_str(), sampleCoords.c_str(), smear, modulate.c_str());
}
}
-
diff --git a/gpu/src/GrGLProgram.h b/gpu/src/GrGLProgram.h
index 1611ca2..473bcb6 100644
--- a/gpu/src/GrGLProgram.h
+++ b/gpu/src/GrGLProgram.h
@@ -19,13 +19,22 @@
#include "GrGLInterface.h"
#include "GrStringBuilder.h"
-#include "GrDrawTarget.h"
+#include "GrGpu.h"
#include "SkXfermode.h"
class GrBinHashKeyBuilder;
-class GrGLEffect;
-struct ShaderCodeSegments;
+
+struct ShaderCodeSegments {
+ GrStringBuilder fHeader; // VS+FS, GLSL version, etc
+ GrStringBuilder fVSUnis;
+ GrStringBuilder fVSAttrs;
+ GrStringBuilder fVaryings;
+ GrStringBuilder fFSUnis;
+ GrStringBuilder fFSOutputs;
+ GrStringBuilder fVSCode;
+ GrStringBuilder fFSCode;
+};
/**
* This class manages a GPU program and records per-program information.
@@ -58,39 +67,29 @@
*/
bool genProgram(CachedData* programData) const;
- /**
- * Routine that is called before rendering. Sets-up all the state and
- * other initializations required for the Gpu Program to run.
- */
- bool doGLSetup(GrPrimitiveType type, CachedData* programData) const;
+ /**
+ * The shader may modify the blend coeffecients. Params are in/out
+ */
+ void overrideBlend(GrBlendCoeff* srcCoeff, GrBlendCoeff* dstCoeff) const;
/**
- * Routine that is called after rendering. Performs state restoration.
- * May perform secondary render passes.
+ * Attribute indices
*/
- void doGLPost() const;
-
- /**
- * Configures the GrGLProgram based on the state of a GrDrawTarget
- * object. This is the fast and light initialization. Retrieves all the
- * state that is required for performing the heavy init (i.e. genProgram),
- * or for retrieving heavy init results from cache.
- */
- void buildFromTarget(const GrDrawTarget* target);
-
static int PositionAttributeIdx() { return 0; }
static int TexCoordAttributeIdx(int tcIdx) { return 1 + tcIdx; }
static int ColorAttributeIdx() { return 1 + GrDrawTarget::kMaxTexCoords; }
- static int ViewMatrixAttributeIdx() {
- return 2 + GrDrawTarget::kMaxTexCoords;
+ static int ViewMatrixAttributeIdx() {
+ return 2 + GrDrawTarget::kMaxTexCoords;
}
- static int TextureMatrixAttributeIdx(int stage) {
- return 5 + GrDrawTarget::kMaxTexCoords + 3 * stage;
+ static int TextureMatrixAttributeIdx(int stage) {
+ return 5 + GrDrawTarget::kMaxTexCoords + 3 * stage;
}
private:
- //Parameters that affect code generation
+ // Parameters that affect code generation
+ // These structs should be kept compact; they are the input to an
+ // expensive hash key generator.
struct ProgramDesc {
ProgramDesc() {
// since we use this as part of a key we can't have any unitialized
@@ -98,46 +97,76 @@
memset(this, 0, sizeof(ProgramDesc));
}
- // stripped of bits that don't affect prog generation
- GrVertexLayout fVertexLayout;
-
- enum {
- kNone_ColorType = 0,
- kAttribute_ColorType = 1,
- kUniform_ColorType = 2,
- } fColorType;
-
- bool fEmitsPointSize;
- bool fUsesEdgeAA;
-
- SkXfermode::Mode fColorFilterXfermode;
-
struct StageDesc {
enum OptFlagBits {
- kNoPerspective_OptFlagBit = 0x1,
- kIdentityMatrix_OptFlagBit = 0x2
+ kNoPerspective_OptFlagBit = 1 << 0,
+ kIdentityMatrix_OptFlagBit = 1 << 1,
+ kCustomTextureDomain_OptFlagBit = 1 << 2,
+ kIsEnabled_OptFlagBit = 1 << 7
};
-
- unsigned fOptFlags;
- bool fEnabled;
-
enum Modulation {
kColor_Modulation,
kAlpha_Modulation
- } fModulation;
-
+ };
enum FetchMode {
kSingle_FetchMode,
k2x2_FetchMode
- } fFetchMode;
-
+ };
enum CoordMapping {
kIdentity_CoordMapping,
kRadialGradient_CoordMapping,
kSweepGradient_CoordMapping,
kRadial2Gradient_CoordMapping
- } fCoordMapping;
- } fStages[GrDrawTarget::kNumStages];
+ };
+
+ uint8_t fOptFlags;
+ uint8_t fModulation; // casts to enum Modulation
+ uint8_t fFetchMode; // casts to enum FetchMode
+ uint8_t fCoordMapping; // casts to enum CoordMapping
+
+ inline bool isEnabled() const {
+ return fOptFlags & kIsEnabled_OptFlagBit;
+ }
+ inline void setEnabled(bool newValue) {
+ if (newValue) {
+ fOptFlags |= kIsEnabled_OptFlagBit;
+ } else {
+ fOptFlags &= ~kIsEnabled_OptFlagBit;
+ }
+ }
+ };
+
+ enum ColorType {
+ kNone_ColorType = 0,
+ kAttribute_ColorType = 1,
+ kUniform_ColorType = 2,
+ };
+ // Dual-src blending makes use of a secondary output color that can be
+ // used as a per-pixel blend coeffecient. This controls whether a
+ // secondary source is output and what value it holds.
+ enum DualSrcOutput {
+ kNone_DualSrcOutput,
+ kCoverage_DualSrcOutput,
+ kCoverageISA_DualSrcOutput,
+ kCoverageISC_DualSrcOutput,
+ kDualSrcOutputCnt
+ };
+
+ // stripped of bits that don't affect prog generation
+ GrVertexLayout fVertexLayout;
+
+ StageDesc fStages[GrDrawTarget::kNumStages];
+
+ uint8_t fColorType; // casts to enum ColorType
+ uint8_t fDualSrcOutput; // casts to enum DualSrcOutput
+ int8_t fFirstCoverageStage;
+ SkBool8 fEmitsPointSize;
+
+ int8_t fEdgeAANumEdges;
+ uint8_t fColorFilterXfermode; // casts to enum SkXfermode::Mode
+
+ uint8_t fPadTo32bLengthMultiple [2];
+
} fProgramDesc;
const ProgramDesc& getDesc() { return fProgramDesc; }
@@ -153,11 +182,13 @@
GrGLint fNormalizedTexelSizeUni;
GrGLint fSamplerUni;
GrGLint fRadial2Uni;
+ GrGLint fTexDomUni;
void reset() {
fTextureMatrixUni = kUnusedUniform;
fNormalizedTexelSizeUni = kUnusedUniform;
fSamplerUni = kUnusedUniform;
fRadial2Uni = kUnusedUniform;
+ fTexDomUni = kUnusedUniform;
}
};
@@ -181,35 +212,13 @@
class CachedData : public ::GrNoncopyable {
public:
CachedData() {
- GR_DEBUGCODE(fEffectUniCount = 0;)
- fEffectUniLocationsExtended = NULL;
}
~CachedData() {
- GrFree(fEffectUniLocationsExtended);
}
void copyAndTakeOwnership(CachedData& other) {
memcpy(this, &other, sizeof(*this));
- other.fEffectUniLocationsExtended = NULL; // ownership transfer
- GR_DEBUGCODE(other.fEffectUniCount = 0;)
- }
-
- void setEffectUniformCount(size_t effectUniforms) {
- GR_DEBUGCODE(fEffectUniCount = effectUniforms;)
- GrFree(fEffectUniLocationsExtended);
- if (effectUniforms > kUniLocationPreAllocSize) {
- fEffectUniLocationsExtended = (GrGLint*)GrMalloc(sizeof(GrGLint)*(effectUniforms-kUniLocationPreAllocSize));
- } else {
- fEffectUniLocationsExtended = NULL;
- }
- }
-
- GrGLint& effectUniLocation(size_t index) {
- GrAssert(index < fEffectUniCount);
- return (index < kUniLocationPreAllocSize) ?
- fEffectUniLocations[index] :
- fEffectUniLocationsExtended[index - kUniLocationPreAllocSize];
}
public:
@@ -234,19 +243,15 @@
GrScalar fRadial2CenterX1[GrDrawTarget::kNumStages];
GrScalar fRadial2Radius0[GrDrawTarget::kNumStages];
bool fRadial2PosRoot[GrDrawTarget::kNumStages];
+ GrRect fTextureDomain[GrDrawTarget::kNumStages];
private:
enum Constants {
kUniLocationPreAllocSize = 8
};
- GrGLint fEffectUniLocations[kUniLocationPreAllocSize];
- GrGLint* fEffectUniLocationsExtended;
- GR_DEBUGCODE(size_t fEffectUniCount;)
}; // CachedData
- GrGLEffect* fStageEffects[GrDrawTarget::kNumStages];
-
private:
enum {
kUseUniform = 2000
@@ -273,8 +278,11 @@
// Creates a GL program ID, binds shader attributes to GL vertex attrs, and
// links the program
- bool bindAttribsAndLinkProgram(GrStringBuilder texCoordAttrNames[GrDrawTarget::kMaxTexCoords],
- CachedData* programData) const;
+ bool bindOutputsAttribsAndLinkProgram(
+ GrStringBuilder texCoordAttrNames[GrDrawTarget::kMaxTexCoords],
+ bool bindColorOut,
+ bool bindDualSrcOut,
+ CachedData* programData) const;
// Gets locations for all uniforms set to kUseUniform and initializes cache
// to invalid values.
diff --git a/gpu/src/GrGpu.cpp b/gpu/src/GrGpu.cpp
index 9950afd..4fe7ccc 100644
--- a/gpu/src/GrGpu.cpp
+++ b/gpu/src/GrGpu.cpp
@@ -142,17 +142,6 @@
return this->onCreateTexture(desc, srcData, rowBytes);
}
-GrRenderTarget* GrGpu::createPlatformRenderTarget(intptr_t platformRenderTarget,
- int stencilBits,
- bool isMultisampled,
- int width, int height) {
- this->handleDirtyContext();
- return this->onCreatePlatformRenderTarget(platformRenderTarget,
- stencilBits,
- isMultisampled,
- width, height);
-}
-
GrRenderTarget* GrGpu::createRenderTargetFrom3DApiState() {
this->handleDirtyContext();
return this->onCreateRenderTargetFrom3DApiState();
@@ -467,17 +456,16 @@
// resolve in/out status.
GrPathRenderer* pr = NULL;
- GrPath::Iter pathIter;
+ const GrPath* clipPath = NULL;
if (kRect_ClipType == clip.getElementType(c)) {
canRenderDirectToStencil = true;
fill = kEvenOdd_PathFill;
} else {
fill = clip.getPathFill(c);
- const GrPath& path = clip.getPath(c);
- pathIter.reset(path);
- pr = this->getClipPathRenderer(&pathIter, NonInvertedFill(fill));
+ clipPath = &clip.getPath(c);
+ pr = this->getClipPathRenderer(*clipPath, NonInvertedFill(fill));
canRenderDirectToStencil =
- !pr->requiresStencilPass(this, &pathIter,
+ !pr->requiresStencilPass(this, *clipPath,
NonInvertedFill(fill));
}
@@ -513,12 +501,10 @@
} else {
if (canRenderDirectToStencil) {
this->setStencil(gDrawToStencil);
- pr->drawPath(this, 0,
- &pathIter,
- NonInvertedFill(fill),
+ pr->drawPath(this, 0, *clipPath, NonInvertedFill(fill),
NULL);
} else {
- pr->drawPathToStencil(this, &pathIter,
+ pr->drawPathToStencil(this, *clipPath,
NonInvertedFill(fill),
NULL);
}
@@ -537,7 +523,7 @@
} else {
SET_RANDOM_COLOR
GrAssert(!IsFillInverted(fill));
- pr->drawPath(this, 0, &pathIter, fill, NULL);
+ pr->drawPath(this, 0, *clipPath, fill, NULL);
}
} else {
SET_RANDOM_COLOR
@@ -561,7 +547,7 @@
return true;
}
-GrPathRenderer* GrGpu::getClipPathRenderer(GrPathIter* path,
+GrPathRenderer* GrGpu::getClipPathRenderer(const GrPath& path,
GrPathFill fill) {
if (NULL != fClientPathRenderer &&
fClientPathRenderer->canDrawPath(this, path, fill)) {
diff --git a/gpu/src/GrGpuGL.cpp b/gpu/src/GrGpuGL.cpp
index e8c7afb..ff2d406 100644
--- a/gpu/src/GrGpuGL.cpp
+++ b/gpu/src/GrGpuGL.cpp
@@ -16,6 +16,7 @@
#include "GrGpuGL.h"
#include "GrMemory.h"
+#include "GrTypes.h"
static const GrGLuint GR_MAX_GLUINT = ~0;
static const GrGLint GR_INVAL_GLINT = ~0;
@@ -41,9 +42,15 @@
GR_GL_ONE_MINUS_CONSTANT_COLOR,
GR_GL_CONSTANT_ALPHA,
GR_GL_ONE_MINUS_CONSTANT_ALPHA,
+
+ // extended blend coeffs
+ GR_GL_SRC1_COLOR,
+ GR_GL_ONE_MINUS_SRC1_COLOR,
+ GR_GL_SRC1_ALPHA,
+ GR_GL_ONE_MINUS_SRC1_ALPHA,
};
-bool GrGpuGL::BlendCoefReferencesConstant(GrBlendCoeff coeff) {
+bool GrGpuGL::BlendCoeffReferencesConstant(GrBlendCoeff coeff) {
static const bool gCoeffReferencesBlendConst[] = {
false,
false,
@@ -59,28 +66,40 @@
true,
true,
true,
+
+ // extended blend coeffs
+ false,
+ false,
+ false,
+ false,
};
return gCoeffReferencesBlendConst[coeff];
- GR_STATIC_ASSERT(kBlendCoeffCount == GR_ARRAY_COUNT(gCoeffReferencesBlendConst));
+ GR_STATIC_ASSERT(kTotalBlendCoeffCount == GR_ARRAY_COUNT(gCoeffReferencesBlendConst));
+
+ GR_STATIC_ASSERT(0 == kZero_BlendCoeff);
+ GR_STATIC_ASSERT(1 == kOne_BlendCoeff);
+ GR_STATIC_ASSERT(2 == kSC_BlendCoeff);
+ GR_STATIC_ASSERT(3 == kISC_BlendCoeff);
+ GR_STATIC_ASSERT(4 == kDC_BlendCoeff);
+ GR_STATIC_ASSERT(5 == kIDC_BlendCoeff);
+ GR_STATIC_ASSERT(6 == kSA_BlendCoeff);
+ GR_STATIC_ASSERT(7 == kISA_BlendCoeff);
+ GR_STATIC_ASSERT(8 == kDA_BlendCoeff);
+ GR_STATIC_ASSERT(9 == kIDA_BlendCoeff);
+ GR_STATIC_ASSERT(10 == kConstC_BlendCoeff);
+ GR_STATIC_ASSERT(11 == kIConstC_BlendCoeff);
+ GR_STATIC_ASSERT(12 == kConstA_BlendCoeff);
+ GR_STATIC_ASSERT(13 == kIConstA_BlendCoeff);
+
+ GR_STATIC_ASSERT(14 == kS2C_BlendCoeff);
+ GR_STATIC_ASSERT(15 == kIS2C_BlendCoeff);
+ GR_STATIC_ASSERT(16 == kS2A_BlendCoeff);
+ GR_STATIC_ASSERT(17 == kIS2A_BlendCoeff);
+
+ // assertion for gXfermodeCoeff2Blend have to be in GrGpu scope
+ GR_STATIC_ASSERT(kTotalBlendCoeffCount == GR_ARRAY_COUNT(gXfermodeCoeff2Blend));
}
-GR_STATIC_ASSERT(0 == kZero_BlendCoeff);
-GR_STATIC_ASSERT(1 == kOne_BlendCoeff);
-GR_STATIC_ASSERT(2 == kSC_BlendCoeff);
-GR_STATIC_ASSERT(3 == kISC_BlendCoeff);
-GR_STATIC_ASSERT(4 == kDC_BlendCoeff);
-GR_STATIC_ASSERT(5 == kIDC_BlendCoeff);
-GR_STATIC_ASSERT(6 == kSA_BlendCoeff);
-GR_STATIC_ASSERT(7 == kISA_BlendCoeff);
-GR_STATIC_ASSERT(8 == kDA_BlendCoeff);
-GR_STATIC_ASSERT(9 == kIDA_BlendCoeff);
-GR_STATIC_ASSERT(10 == kConstC_BlendCoeff);
-GR_STATIC_ASSERT(11 == kIConstC_BlendCoeff);
-GR_STATIC_ASSERT(12 == kConstA_BlendCoeff);
-GR_STATIC_ASSERT(13 == kIConstA_BlendCoeff);
-
-GR_STATIC_ASSERT(kBlendCoeffCount == GR_ARRAY_COUNT(gXfermodeCoeff2Blend));
-
///////////////////////////////////////////////////////////////////////////////
void GrGpuGL::AdjustTextureMatrix(const GrGLTexture* texture,
@@ -201,6 +220,16 @@
GR_GL_GetIntegerv(GR_GL_MAX_TEXTURE_UNITS, &maxTextureUnits);
GrAssert(maxTextureUnits > kNumStages);
}
+ if (GR_GL_SUPPORT_ES2) {
+ GR_GL_GetIntegerv(GR_GL_MAX_FRAGMENT_UNIFORM_VECTORS,
+ &fMaxFragmentUniformVectors);
+ } else if (GR_GL_SUPPORT_DESKTOP) {
+ GrGLint max;
+ GR_GL_GetIntegerv(GR_GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, &max);
+ fMaxFragmentUniformVectors = max / 4;
+ } else {
+ fMaxFragmentUniformVectors = 16;
+ }
////////////////////////////////////////////////////////////////////////////
// Check for supported features.
@@ -604,32 +633,6 @@
}
}
-GrRenderTarget* GrGpuGL::onCreatePlatformRenderTarget(
- intptr_t platformRenderTarget,
- int stencilBits,
- bool isMultisampled,
- int width,
- int height) {
- GrGLRenderTarget::GLRenderTargetIDs rtIDs;
- rtIDs.fStencilRenderbufferID = 0;
- rtIDs.fMSColorRenderbufferID = 0;
- rtIDs.fTexFBOID = 0;
- rtIDs.fOwnIDs = false;
- GrGLIRect viewport;
-
- // viewport is in GL coords (top >= bottom)
- viewport.fLeft = 0;
- viewport.fBottom = 0;
- viewport.fWidth = width;
- viewport.fHeight = height;
-
- rtIDs.fRTFBOID = (GrGLuint)platformRenderTarget;
- rtIDs.fTexFBOID = (GrGLuint)platformRenderTarget;
-
- return new GrGLRenderTarget(this, rtIDs, NULL, stencilBits,
- isMultisampled, viewport, NULL);
-}
-
GrRenderTarget* GrGpuGL::onCreateRenderTargetFrom3DApiState() {
GrGLRenderTarget::GLRenderTargetIDs rtIDs;
@@ -1667,7 +1670,9 @@
}
}
-void GrGpuGL::flushBlend(GrPrimitiveType type) {
+void GrGpuGL::flushBlend(GrPrimitiveType type,
+ GrBlendCoeff srcCoeff,
+ GrBlendCoeff dstCoeff) {
if (GrIsPrimTypeLines(type) && useSmoothLines()) {
if (fHWBlendDisabled) {
GR_GL(Enable(GR_GL_BLEND));
@@ -1691,15 +1696,15 @@
fHWBlendDisabled = blendOff;
}
if (!blendOff) {
- if (fHWDrawState.fSrcBlend != fCurrDrawState.fSrcBlend ||
- fHWDrawState.fDstBlend != fCurrDrawState.fDstBlend) {
- GR_GL(BlendFunc(gXfermodeCoeff2Blend[fCurrDrawState.fSrcBlend],
- gXfermodeCoeff2Blend[fCurrDrawState.fDstBlend]));
- fHWDrawState.fSrcBlend = fCurrDrawState.fSrcBlend;
- fHWDrawState.fDstBlend = fCurrDrawState.fDstBlend;
+ if (fHWDrawState.fSrcBlend != srcCoeff ||
+ fHWDrawState.fDstBlend != dstCoeff) {
+ GR_GL(BlendFunc(gXfermodeCoeff2Blend[srcCoeff],
+ gXfermodeCoeff2Blend[dstCoeff]));
+ fHWDrawState.fSrcBlend = srcCoeff;
+ fHWDrawState.fDstBlend = dstCoeff;
}
- if ((BlendCoefReferencesConstant(fCurrDrawState.fSrcBlend) ||
- BlendCoefReferencesConstant(fCurrDrawState.fDstBlend)) &&
+ if ((BlendCoeffReferencesConstant(srcCoeff) ||
+ BlendCoeffReferencesConstant(dstCoeff)) &&
fHWDrawState.fBlendConstant != fCurrDrawState.fBlendConstant) {
float c[] = {
@@ -1802,7 +1807,6 @@
}
this->flushRenderTarget(rect);
this->flushAAState(type);
- this->flushBlend(type);
if ((fCurrDrawState.fFlagBits & kDither_StateBit) !=
(fHWDrawState.fFlagBits & kDither_StateBit)) {
@@ -2064,3 +2068,9 @@
}
}
}
+
+int GrGpuGL::getMaxEdges() const {
+ // FIXME: This is a pessimistic estimate based on how many other things
+ // want to add uniforms. This should be centralized somewhere.
+ return GR_CT_MIN(fMaxFragmentUniformVectors - 8, kMaxEdges);
+}
diff --git a/gpu/src/GrGpuGL.h b/gpu/src/GrGpuGL.h
index da955cf..696b72f 100644
--- a/gpu/src/GrGpuGL.h
+++ b/gpu/src/GrGpuGL.h
@@ -81,11 +81,6 @@
virtual GrIndexBuffer* onCreateIndexBuffer(uint32_t size,
bool dynamic);
virtual GrResource* onCreatePlatformSurface(const GrPlatformSurfaceDesc& desc);
- virtual GrRenderTarget* onCreatePlatformRenderTarget(
- intptr_t platformRenderTarget,
- int stencilBits,
- bool isMultisampled,
- int width, int height);
virtual GrRenderTarget* onCreateRenderTargetFrom3DApiState();
virtual void onClear(const GrIRect* rect, GrColor color);
@@ -107,6 +102,7 @@
virtual void flushScissor(const GrIRect* rect);
void clearStencil(uint32_t value, uint32_t mask);
virtual void clearStencilClip(const GrIRect& rect);
+ virtual int getMaxEdges() const;
// binds texture unit in GL
void setTextureUnit(int unitIdx);
@@ -120,13 +116,17 @@
// flushes state that is common to fixed and programmable GL
// dither
// line smoothing
- // blend func
// texture binding
// sampler state (filtering, tiling)
// FBO binding
// line width
bool flushGLStateCommon(GrPrimitiveType type);
+ // subclass should call this to flush the blend state
+ void flushBlend(GrPrimitiveType type,
+ GrBlendCoeff srcCoeff,
+ GrBlendCoeff dstCoeff);
+
// adjusts texture matrix to account for orientation, size, and npotness
static void AdjustTextureMatrix(const GrGLTexture* texture,
GrSamplerState::SampleMode mode,
@@ -138,7 +138,7 @@
static bool TextureMatrixIsIdentity(const GrGLTexture* texture,
const GrSamplerState& sampler);
- static bool BlendCoefReferencesConstant(GrBlendCoeff coeff);
+ static bool BlendCoeffReferencesConstant(GrBlendCoeff coeff);
private:
@@ -160,7 +160,6 @@
void flushRenderTarget(const GrIRect* bound);
void flushStencil();
void flushAAState(GrPrimitiveType type);
- void flushBlend(GrPrimitiveType type);
void resolveRenderTarget(GrGLRenderTarget* texture);
@@ -189,6 +188,9 @@
// Do we have stencil wrap ops.
bool fHasStencilWrap;
+ // The maximum number of fragment uniform vectors (GLES has min. 16).
+ int fMaxFragmentUniformVectors;
+
// ES requires an extension to support RGBA8 in RenderBufferStorage
bool fRGBA8Renderbuffer;
diff --git a/gpu/src/GrGpuGLFixed.cpp b/gpu/src/GrGpuGLFixed.cpp
index e197a82..65229dc 100644
--- a/gpu/src/GrGpuGLFixed.cpp
+++ b/gpu/src/GrGpuGLFixed.cpp
@@ -57,6 +57,7 @@
GrGpuGLFixed::GrGpuGLFixed() {
f4X4DownsampleFilterSupport = false;
+ fDualSourceBlendingSupport = false;
}
GrGpuGLFixed::~GrGpuGLFixed() {
@@ -136,8 +137,8 @@
}
if (GR_GL_SUPPORT_ES1) {
- if (BlendCoefReferencesConstant(fCurrDrawState.fSrcBlend) ||
- BlendCoefReferencesConstant(fCurrDrawState.fDstBlend)) {
+ if (BlendCoeffReferencesConstant(fCurrDrawState.fSrcBlend) ||
+ BlendCoeffReferencesConstant(fCurrDrawState.fDstBlend)) {
unimpl("ES1 doesn't support blend constant");
return false;
}
@@ -147,6 +148,8 @@
return false;
}
+ this->flushBlend(type, fCurrDrawState.fSrcBlend, fCurrDrawState.fDstBlend);
+
if (fDirtyFlags.fRenderTargetChanged) {
flushProjectionMatrix();
}
diff --git a/gpu/src/GrGpuGLFixed.h b/gpu/src/GrGpuGLFixed.h
index 077b6e2..487c09f 100644
--- a/gpu/src/GrGpuGLFixed.h
+++ b/gpu/src/GrGpuGLFixed.h
@@ -41,7 +41,7 @@
const GrMatrix& getHWSamplerMatrix(int stage) const {
return fHWDrawState.fSamplerStates[stage].getMatrix();
}
- const void recordHWSamplerMatrix(int stage, const GrMatrix& matrix) {
+ void recordHWSamplerMatrix(int stage, const GrMatrix& matrix) {
fHWDrawState.fSamplerStates[stage].setMatrix(matrix);
}
diff --git a/gpu/src/GrGpuGLShaders.cpp b/gpu/src/GrGpuGLShaders.cpp
index 8965b06..50be67f 100644
--- a/gpu/src/GrGpuGLShaders.cpp
+++ b/gpu/src/GrGpuGLShaders.cpp
@@ -15,7 +15,6 @@
*/
#include "GrBinHashKey.h"
-#include "GrGLEffect.h"
#include "GrGLProgram.h"
#include "GrGpuGLShaders.h"
#include "GrGpuVertex.h"
@@ -169,6 +168,14 @@
GrRandom random;
for (int t = 0; t < NUM_TESTS; ++t) {
+#if 0
+ GrPrintf("\nTest Program %d\n-------------\n", t);
+ static const int stop = -1;
+ if (t == stop) {
+ int breakpointhere = 9;
+ }
+#endif
+
pdesc.fVertexLayout = 0;
pdesc.fEmitsPointSize = random.nextF() > .5f;
float colorType = random.nextF();
@@ -179,6 +186,24 @@
} else {
pdesc.fColorType = GrGLProgram::ProgramDesc::kNone_ColorType;
}
+
+ int idx = (int)(random.nextF() * (SkXfermode::kCoeffModesCnt));
+ pdesc.fColorFilterXfermode = (SkXfermode::Mode)idx;
+
+ idx = (int)(random.nextF() * (kNumStages+1));
+ pdesc.fFirstCoverageStage = idx;
+
+ pdesc.fEdgeAANumEdges = (random.nextF() * (getMaxEdges() + 1));
+
+ if (fDualSourceBlendingSupport) {
+ pdesc.fDualSrcOutput =
+ (GrGLProgram::ProgramDesc::DualSrcOutput)
+ (int)(random.nextF() * GrGLProgram::ProgramDesc::kDualSrcOutputCnt);
+ } else {
+ pdesc.fDualSrcOutput =
+ GrGLProgram::ProgramDesc::kNone_DualSrcOutput;
+ }
+
for (int s = 0; s < kNumStages; ++s) {
// enable the stage?
if (random.nextF() > .5f) {
@@ -194,19 +219,15 @@
if (random.nextF() > .5f) {
pdesc.fVertexLayout |= kTextFormat_VertexLayoutBit;
}
- }
-
- for (int s = 0; s < kNumStages; ++s) {
- int x;
- pdesc.fStages[s].fEnabled = VertexUsesStage(s, pdesc.fVertexLayout);
- x = (int)(random.nextF() * GR_ARRAY_COUNT(STAGE_OPTS));
- pdesc.fStages[s].fOptFlags = STAGE_OPTS[x];
- x = (int)(random.nextF() * GR_ARRAY_COUNT(STAGE_MODULATES));
- pdesc.fStages[s].fModulation = STAGE_MODULATES[x];
- x = (int)(random.nextF() * GR_ARRAY_COUNT(STAGE_COORD_MAPPINGS));
- pdesc.fStages[s].fCoordMapping = STAGE_COORD_MAPPINGS[x];
- x = (int)(random.nextF() * GR_ARRAY_COUNT(FETCH_MODES));
- pdesc.fStages[s].fFetchMode = FETCH_MODES[x];
+ idx = (int)(random.nextF() * GR_ARRAY_COUNT(STAGE_OPTS));
+ pdesc.fStages[s].fOptFlags = STAGE_OPTS[idx];
+ idx = (int)(random.nextF() * GR_ARRAY_COUNT(STAGE_MODULATES));
+ pdesc.fStages[s].fModulation = STAGE_MODULATES[idx];
+ idx = (int)(random.nextF() * GR_ARRAY_COUNT(STAGE_COORD_MAPPINGS));
+ pdesc.fStages[s].fCoordMapping = STAGE_COORD_MAPPINGS[idx];
+ idx = (int)(random.nextF() * GR_ARRAY_COUNT(FETCH_MODES));
+ pdesc.fStages[s].fFetchMode = FETCH_MODES[idx];
+ pdesc.fStages[s].setEnabled(VertexUsesStage(s, pdesc.fVertexLayout));
}
GrGLProgram::CachedData cachedData;
program.genProgram(&cachedData);
@@ -219,11 +240,20 @@
}
}
-
GrGpuGLShaders::GrGpuGLShaders() {
resetContext();
+ int major, minor;
+ gl_version(&major, &minor);
+
f4X4DownsampleFilterSupport = true;
+ if (GR_GL_SUPPORT_DESKTOP) {
+ fDualSourceBlendingSupport =
+ major > 3 ||(3 == major && 3 <= minor) ||
+ has_gl_extension("GL_ARB_blend_func_extended");
+ } else {
+ fDualSourceBlendingSupport = false;
+ }
fProgramData = NULL;
fProgramCache = new ProgramCache();
@@ -283,16 +313,16 @@
// ES doesn't allow you to pass true to the transpose param,
// so do our own transpose
- GrScalar mt[] = {
- m[GrMatrix::kMScaleX],
- m[GrMatrix::kMSkewY],
- m[GrMatrix::kMPersp0],
- m[GrMatrix::kMSkewX],
- m[GrMatrix::kMScaleY],
- m[GrMatrix::kMPersp1],
- m[GrMatrix::kMTransX],
- m[GrMatrix::kMTransY],
- m[GrMatrix::kMPersp2]
+ GrGLfloat mt[] = {
+ GrScalarToFloat(m[GrMatrix::kMScaleX]),
+ GrScalarToFloat(m[GrMatrix::kMSkewY]),
+ GrScalarToFloat(m[GrMatrix::kMPersp0]),
+ GrScalarToFloat(m[GrMatrix::kMSkewX]),
+ GrScalarToFloat(m[GrMatrix::kMScaleY]),
+ GrScalarToFloat(m[GrMatrix::kMPersp1]),
+ GrScalarToFloat(m[GrMatrix::kMTransX]),
+ GrScalarToFloat(m[GrMatrix::kMTransY]),
+ GrScalarToFloat(m[GrMatrix::kMPersp2])
};
if (GrGLProgram::kSetAsAttribute ==
@@ -309,8 +339,48 @@
}
}
+void GrGpuGLShaders::flushTextureDomain(int s) {
+ const GrGLint& uni = fProgramData->fUniLocations.fStages[s].fTexDomUni;
+ if (GrGLProgram::kUnusedUniform != uni) {
+ const GrRect &texDom =
+ fCurrDrawState.fSamplerStates[s].getTextureDomain();
+
+ if (((1 << s) & fDirtyFlags.fTextureChangedMask) ||
+ fProgramData->fTextureDomain[s] != texDom) {
+
+ fProgramData->fTextureDomain[s] = texDom;
+
+ float values[4] = {
+ GrScalarToFloat(texDom.left()),
+ GrScalarToFloat(texDom.top()),
+ GrScalarToFloat(texDom.right()),
+ GrScalarToFloat(texDom.bottom())
+ };
+
+ GrGLTexture* texture = (GrGLTexture*) fCurrDrawState.fTextures[s];
+ GrGLTexture::Orientation orientation = texture->orientation();
+
+ // vertical flip if necessary
+ if (GrGLTexture::kBottomUp_Orientation == orientation) {
+ values[1] = 1.0f - values[1];
+ values[3] = 1.0f - values[3];
+ // The top and bottom were just flipped, so correct the ordering
+ // of elements so that values = (l, t, r, b).
+ SkTSwap(values[1], values[3]);
+ }
+
+ values[0] *= SkScalarToFloat(texture->contentScaleX());
+ values[2] *= SkScalarToFloat(texture->contentScaleX());
+ values[1] *= SkScalarToFloat(texture->contentScaleY());
+ values[3] *= SkScalarToFloat(texture->contentScaleY());
+
+ GR_GL(Uniform4fv(uni, 1, values));
+ }
+ }
+}
+
void GrGpuGLShaders::flushTextureMatrix(int s) {
- const int& uni = fProgramData->fUniLocations.fStages[s].fTextureMatrixUni;
+ const GrGLint& uni = fProgramData->fUniLocations.fStages[s].fTextureMatrixUni;
GrGLTexture* texture = (GrGLTexture*) fCurrDrawState.fTextures[s];
if (NULL != texture) {
if (GrGLProgram::kUnusedUniform != uni &&
@@ -328,17 +398,18 @@
// ES doesn't allow you to pass true to the transpose param,
// so do our own transpose
- GrScalar mt[] = {
- m[GrMatrix::kMScaleX],
- m[GrMatrix::kMSkewY],
- m[GrMatrix::kMPersp0],
- m[GrMatrix::kMSkewX],
- m[GrMatrix::kMScaleY],
- m[GrMatrix::kMPersp1],
- m[GrMatrix::kMTransX],
- m[GrMatrix::kMTransY],
- m[GrMatrix::kMPersp2]
+ GrGLfloat mt[] = {
+ GrScalarToFloat(m[GrMatrix::kMScaleX]),
+ GrScalarToFloat(m[GrMatrix::kMSkewY]),
+ GrScalarToFloat(m[GrMatrix::kMPersp0]),
+ GrScalarToFloat(m[GrMatrix::kMSkewX]),
+ GrScalarToFloat(m[GrMatrix::kMScaleY]),
+ GrScalarToFloat(m[GrMatrix::kMPersp1]),
+ GrScalarToFloat(m[GrMatrix::kMTransX]),
+ GrScalarToFloat(m[GrMatrix::kMTransY]),
+ GrScalarToFloat(m[GrMatrix::kMPersp2])
};
+
if (GrGLProgram::kSetAsAttribute ==
fProgramData->fUniLocations.fStages[s].fTextureMatrixUni) {
int baseIdx = GrGLProgram::TextureMatrixAttributeIdx(s);
@@ -399,16 +470,17 @@
void GrGpuGLShaders::flushEdgeAAData() {
const int& uni = fProgramData->fUniLocations.fEdgesUni;
if (GrGLProgram::kUnusedUniform != uni) {
- float edges[18];
- memcpy(edges, fCurrDrawState.fEdgeAAEdges, sizeof(edges));
+ int count = fCurrDrawState.fEdgeAANumEdges;
+ Edge edges[kMaxEdges];
// Flip the edges in Y
float height = fCurrDrawState.fRenderTarget->height();
- for (int i = 0; i < 6; ++i) {
- float b = edges[i * 3 + 1];
- edges[i * 3 + 1] = -b;
- edges[i * 3 + 2] += b * height;
+ for (int i = 0; i < count; ++i) {
+ edges[i] = fCurrDrawState.fEdgeAAEdges[i];
+ float b = edges[i].fY;
+ edges[i].fY = -b;
+ edges[i].fZ += b * height;
}
- GR_GL(Uniform3fv(uni, 6, edges));
+ GR_GL(Uniform3fv(uni, count, &edges[0].fX));
}
}
@@ -489,10 +561,11 @@
GR_GL(UseProgram(fProgramData->fProgramID));
fHWProgramID = fProgramData->fProgramID;
}
-
- if (!fCurrentProgram.doGLSetup(type, fProgramData)) {
- return false;
- }
+ GrBlendCoeff srcCoeff = fCurrDrawState.fSrcBlend;
+ GrBlendCoeff dstCoeff = fCurrDrawState.fDstBlend;
+
+ fCurrentProgram.overrideBlend(&srcCoeff, &dstCoeff);
+ this->flushBlend(type, srcCoeff, dstCoeff);
this->flushColor();
@@ -515,6 +588,8 @@
this->flushRadial2(s);
this->flushTexelSize(s);
+
+ this->flushTextureDomain(s);
}
this->flushEdgeAAData();
resetDirtyFlags();
@@ -522,7 +597,6 @@
}
void GrGpuGLShaders::postDraw() {
- fCurrentProgram.doGLPost();
}
void GrGpuGLShaders::setupGeometry(int* startVertex,
@@ -634,6 +708,8 @@
// existing program in the cache.
desc.fVertexLayout &= ~(kColor_VertexLayoutBit);
+ desc.fColorFilterXfermode = fCurrDrawState.fColorFilterXfermode;
+
#if GR_AGGRESSIVE_SHADER_OPTS
if (!requiresAttributeColors && (0xffffffff == fCurrDrawState.fColor)) {
desc.fColorType = GrGLProgram::ProgramDesc::kNone_ColorType;
@@ -649,24 +725,26 @@
desc.fColorType = GrGLProgram::ProgramDesc::kAttribute_ColorType;
}
- desc.fUsesEdgeAA = fCurrDrawState.fFlagBits & kEdgeAA_StateBit;
+ desc.fEdgeAANumEdges = fCurrDrawState.fEdgeAANumEdges;
+
+ int lastEnabledStage = -1;
for (int s = 0; s < kNumStages; ++s) {
GrGLProgram::ProgramDesc::StageDesc& stage = desc.fStages[s];
- stage.fEnabled = this->isStageEnabled(s);
+ stage.fOptFlags = 0;
+ stage.setEnabled(this->isStageEnabled(s));
- if (stage.fEnabled) {
+ if (stage.isEnabled()) {
+ lastEnabledStage = s;
GrGLTexture* texture = (GrGLTexture*) fCurrDrawState.fTextures[s];
GrAssert(NULL != texture);
// we matrix to invert when orientation is TopDown, so make sure
// we aren't in that case before flagging as identity.
if (TextureMatrixIsIdentity(texture, fCurrDrawState.fSamplerStates[s])) {
- stage.fOptFlags = GrGLProgram::ProgramDesc::StageDesc::kIdentityMatrix_OptFlagBit;
+ stage.fOptFlags |= GrGLProgram::ProgramDesc::StageDesc::kIdentityMatrix_OptFlagBit;
} else if (!getSamplerMatrix(s).hasPerspective()) {
- stage.fOptFlags = GrGLProgram::ProgramDesc::StageDesc::kNoPerspective_OptFlagBit;
- } else {
- stage.fOptFlags = 0;
+ stage.fOptFlags |= GrGLProgram::ProgramDesc::StageDesc::kNoPerspective_OptFlagBit;
}
switch (fCurrDrawState.fSamplerStates[s].getSampleMode()) {
case GrSamplerState::kNormal_SampleMode:
@@ -701,27 +779,62 @@
break;
}
+ if (fCurrDrawState.fSamplerStates[s].hasTextureDomain()) {
+ GrAssert(GrSamplerState::kClamp_WrapMode ==
+ fCurrDrawState.fSamplerStates[s].getWrapX() &&
+ GrSamplerState::kClamp_WrapMode ==
+ fCurrDrawState.fSamplerStates[s].getWrapY());
+ stage.fOptFlags |=
+ GrGLProgram::ProgramDesc::StageDesc::
+ kCustomTextureDomain_OptFlagBit;
+ }
+
if (GrPixelConfigIsAlphaOnly(texture->config())) {
stage.fModulation = GrGLProgram::ProgramDesc::StageDesc::kAlpha_Modulation;
} else {
stage.fModulation = GrGLProgram::ProgramDesc::StageDesc::kColor_Modulation;
}
-
- if (fCurrDrawState.fEffects[s]) {
- fCurrentProgram.fStageEffects[s] = GrGLEffect::Create(fCurrDrawState.fEffects[s]);
- } else {
- delete fCurrentProgram.fStageEffects[s];
- fCurrentProgram.fStageEffects[s] = NULL;
- }
} else {
stage.fOptFlags = 0;
stage.fCoordMapping = (GrGLProgram::ProgramDesc::StageDesc::CoordMapping)0;
stage.fModulation = (GrGLProgram::ProgramDesc::StageDesc::Modulation)0;
- fCurrentProgram.fStageEffects[s] = NULL;
}
}
- desc.fColorFilterXfermode = fCurrDrawState.fColorFilterXfermode;
+
+ desc.fDualSrcOutput = GrGLProgram::ProgramDesc::kNone_DualSrcOutput;
+ // use canonical value when coverage/color distinction won't affect
+ // generated code to prevent duplicate programs.
+ desc.fFirstCoverageStage = kNumStages;
+ if (fCurrDrawState.fFirstCoverageStage <= lastEnabledStage) {
+ // color filter is applied between color/coverage computation
+ if (SkXfermode::kDst_Mode != desc.fColorFilterXfermode) {
+ desc.fFirstCoverageStage = fCurrDrawState.fFirstCoverageStage;
+ }
+
+ // We could consider cases where the final color is solid (0xff alpha)
+ // and the dst coeff can correctly be set to a non-dualsrc gl value.
+ // (e.g. solid draw, and dst coeff is kZero. It's correct to make
+ // the dst coeff be kISA. Or solid draw with kSA can be tweaked to be
+ // kOne).
+ if (fDualSourceBlendingSupport) {
+ if (kZero_BlendCoeff == fCurrDrawState.fDstBlend) {
+ // write the coverage value to second color
+ desc.fDualSrcOutput =
+ GrGLProgram::ProgramDesc::kCoverage_DualSrcOutput;
+ desc.fFirstCoverageStage = fCurrDrawState.fFirstCoverageStage;
+ } else if (kSA_BlendCoeff == fCurrDrawState.fDstBlend) {
+ // SA dst coeff becomes 1-(1-SA)*coverage when dst is partially
+ // cover
+ desc.fDualSrcOutput =
+ GrGLProgram::ProgramDesc::kCoverageISA_DualSrcOutput;
+ desc.fFirstCoverageStage = fCurrDrawState.fFirstCoverageStage;
+ } else if (kSC_BlendCoeff == fCurrDrawState.fDstBlend) {
+ // SA dst coeff becomes 1-(1-SA)*coverage when dst is partially
+ // cover
+ desc.fDualSrcOutput =
+ GrGLProgram::ProgramDesc::kCoverageISC_DualSrcOutput;
+ desc.fFirstCoverageStage = fCurrDrawState.fFirstCoverageStage;
+ }
+ }
+ }
}
-
-
-
diff --git a/gpu/src/GrGpuGLShaders.h b/gpu/src/GrGpuGLShaders.h
index bb3024f..9392d1c 100644
--- a/gpu/src/GrGpuGLShaders.h
+++ b/gpu/src/GrGpuGLShaders.h
@@ -51,6 +51,9 @@
// sets the texture matrix uniform for currently bound program
void flushTextureMatrix(int stage);
+ // sets the texture domain uniform for currently bound program
+ void flushTextureDomain(int stage);
+
// sets the color specified by GrDrawTarget::setColor()
void flushColor();
diff --git a/gpu/src/GrPath.cpp b/gpu/src/GrPath.cpp
deleted file mode 100644
index aa89d37..0000000
--- a/gpu/src/GrPath.cpp
+++ /dev/null
@@ -1,523 +0,0 @@
-#include "GrPath.h"
-
-GrPath::GrPath() {
- fConvexHint = kNone_ConvexHint;
- fConservativeBounds.setLargestInverted();
-}
-
-GrPath::GrPath(const GrPath& src) : INHERITED() {
- GrPath::Iter iter(src);
- this->resetFromIter(&iter);
-}
-
-GrPath::GrPath(GrPathIter& iter) {
- this->resetFromIter(&iter);
-}
-
-GrPath::~GrPath() {
-}
-
-bool GrPath::operator ==(const GrPath& path) const {
- if (fCmds.count() != path.fCmds.count() ||
- fPts.count() != path.fPts.count()) {
- return false;
- }
-
- for (int v = 0; v < fCmds.count(); ++v) {
- if (fCmds[v] != path.fCmds[v]) {
- return false;
- }
- }
-
- for (int p = 0; p < fPts.count(); ++p) {
- if (fPts[p] != path.fPts[p]) {
- return false;
- }
- }
- return true;
-}
-
-void GrPath::ensureMoveTo() {
- if (fCmds.isEmpty() || this->wasLastVerb(kClose_PathCmd)) {
- *fCmds.append() = kMove_PathCmd;
- fPts.append()->set(0, 0);
- fConservativeBounds.growToInclude(0,0);
- }
-}
-
-void GrPath::moveTo(GrScalar x, GrScalar y) {
- if (this->wasLastVerb(kMove_PathCmd)) {
- // overwrite prev kMove value
- fPts[fPts.count() - 1].set(x, y);
- } else {
- *fCmds.append() = kMove_PathCmd;
- fPts.append()->set(x, y);
- }
- fConservativeBounds.growToInclude(x,y);
-}
-
-void GrPath::lineTo(GrScalar x, GrScalar y) {
- this->ensureMoveTo();
- *fCmds.append() = kLine_PathCmd;
- fPts.append()->set(x, y);
- fConservativeBounds.growToInclude(x,y);
-}
-
-void GrPath::quadTo(GrScalar x0, GrScalar y0, GrScalar x1, GrScalar y1) {
- this->ensureMoveTo();
- *fCmds.append() = kQuadratic_PathCmd;
- fPts.append()->set(x0, y0);
- fPts.append()->set(x1, y1);
- fConservativeBounds.growToInclude(x0,y0);
- fConservativeBounds.growToInclude(x1,y1);
-}
-
-void GrPath::cubicTo(GrScalar x0, GrScalar y0, GrScalar x1, GrScalar y1,
- GrScalar x2, GrScalar y2) {
- this->ensureMoveTo();
- *fCmds.append() = kCubic_PathCmd;
- fPts.append()->set(x0, y0);
- fPts.append()->set(x1, y1);
- fPts.append()->set(x2, y2);
- fConservativeBounds.growToInclude(x0,y0);
- fConservativeBounds.growToInclude(x1,y1);
- fConservativeBounds.growToInclude(x2,y2);
-}
-
-void GrPath::close() {
- if (!fCmds.isEmpty() && !this->wasLastVerb(kClose_PathCmd)) {
- // should we allow kMove followed by kClose?
- *fCmds.append() = kClose_PathCmd;
- }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-void GrPath::offset(GrScalar tx, GrScalar ty) {
- if (!tx && !ty) {
- return; // nothing to do
- }
-
- GrPoint* iter = fPts.begin();
- GrPoint* stop = fPts.end();
- while (iter < stop) {
- iter->offset(tx, ty);
- ++iter;
- }
- fConservativeBounds.offset(tx, ty);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-static bool check_two_vecs(const GrVec& prevVec,
- const GrVec& currVec,
- GrScalar turnDir,
- int* xDir,
- int* yDir,
- int* flipX,
- int* flipY) {
- if (currVec.fX * *xDir < 0) {
- ++*flipX;
- if (*flipX > 2) {
- return false;
- }
- *xDir = -*xDir;
- }
- if (currVec.fY * *yDir < 0) {
- ++*flipY;
- if (*flipY > 2) {
- return false;
- }
- *yDir = -*yDir;
- }
- GrScalar d = prevVec.cross(currVec);
- return (d * turnDir) >= 0;
-}
-
-static void init_from_two_vecs(const GrVec& firstVec,
- const GrVec& secondVec,
- GrScalar* turnDir,
- int* xDir, int* yDir) {
- *turnDir = firstVec.cross(secondVec);
- if (firstVec.fX > 0) {
- *xDir = 1;
- } else if (firstVec.fX < 0) {
- *xDir = -1;
- } else {
- *xDir = 0;
- }
- if (firstVec.fY > 0) {
- *yDir = 1;
- } else if (firstVec.fY < 0) {
- *yDir = -1;
- } else {
- *yDir = 0;
- }
-}
-
-void GrPath::resetFromIter(GrPathIter* iter) {
- fPts.reset();
- fCmds.reset();
- fConservativeBounds.setLargestInverted();
-
- fConvexHint = iter->convexHint();
-
- // first point of the subpath
- GrPoint firstPt = { 0, 0 };
- // first edge of the subpath
- GrVec firstVec = { 0, 0 };
- // vec of most recently processed edge, that wasn't degenerate
- GrVec previousVec = { 0, 0 };
- // most recently processed point
- GrPoint previousPt = { 0, 0 };
-
- // sign indicates whether we're bending left or right
- GrScalar turnDir = 0;
- // number of times the direction has flipped in x or y
-
- // we track which direction we are moving in x/y and the
- // number of times it changes.
- int xDir = 0;
- int yDir = 0;
- int flipX = 0;
- int flipY = 0;
-
- // counts number of sub path pts that didn't add a degenerate edge.
- int subPathPts = 0;
- bool subPathClosed = false;
-
- int numSubPaths = 0;
- iter->rewind();
- GrPathCmd cmd;
- GrPoint pts[4];
- do {
- cmd = iter->next(pts);
- // If the convexity test is ever updated to handle multiple subpaths
- // the loop has to be adjusted to handle moving to a new subpath without
- // closing the previous one. Currently the implicit closing vectors for a
- // filled path would never be examined.
- switch (cmd) {
- case kMove_PathCmd:
- this->moveTo(pts[0].fX, pts[0].fY);
- subPathPts = 0;
- subPathClosed = false;
- break;
- case kLine_PathCmd:
- this->lineTo(pts[1].fX, pts[1].fY);
- break;
- case kQuadratic_PathCmd:
- this->quadTo(pts[1].fX, pts[1].fY, pts[2].fX, pts[2].fY);
- break;
- case kCubic_PathCmd:
- this->cubicTo(pts[1].fX, pts[1].fY, pts[2].fX, pts[2].fY,
- pts[3].fX, pts[3].fY);
- break;
- case kClose_PathCmd:
- this->close();
- subPathClosed = true;
- break;
- case kEnd_PathCmd:
- break;
- }
- int n = NumPathCmdPoints(cmd);
- for (int i = 0; i < n; ++i) {
- fConservativeBounds.growToInclude(pts[i].fX, pts[i].fY);
- }
- if (0 == subPathPts && n > 0) {
- previousPt = pts[0];
- firstPt = previousPt;
- flipX = 0;
- flipY = 0;
- turnDir = 0;
- subPathPts = 1;
- ++numSubPaths;
- }
- // either we skip the first pt because it is redundant with
- // last point of the previous subpath cmd or we just ate it
- // in the above if.
- int consumed = 1;
- if (numSubPaths < 2 && kNone_ConvexHint == fConvexHint) {
- while (consumed < n) {
- GrAssert(pts[consumed-1] == previousPt);
- GrVec vec = pts[consumed] - previousPt;
-// vec.setBetween(previousPt, pts[consumed]);
- if (vec.fX || vec.fY) {
- if (subPathPts >= 2) {
- if (0 == turnDir) {
- firstVec = previousVec;
- init_from_two_vecs(firstVec, vec,
- &turnDir, &xDir, &yDir);
- // here we aren't checking whether the x/y dirs
- // change between the first and second edge. It
- // gets covered when the path is closed.
- } else {
- if (!check_two_vecs(previousVec, vec, turnDir,
- &xDir, &yDir,
- &flipX, &flipY)) {
- fConvexHint = kConcave_ConvexHint;
- break;
- }
- }
- }
- previousVec = vec;
- previousPt = pts[consumed];
- ++subPathPts;
- }
- ++consumed;
- }
- if (subPathPts > 2 && (kClose_PathCmd == cmd ||
- (!subPathClosed && kEnd_PathCmd == cmd ))) {
- // if an additional vector is needed to close the loop check
- // that it validates against the previous vector.
- GrVec vec = firstPt - previousPt;
-// vec.setBetween(previousPt, firstPt);
- if (vec.fX || vec.fY) {
- if (!check_two_vecs(previousVec, vec, turnDir,
- &xDir, &yDir, &flipX, &flipY)) {
- fConvexHint = kConcave_ConvexHint;
- break;
- }
- previousVec = vec;
- }
- // check that closing vector validates against the first vector.
- if (!check_two_vecs(previousVec, firstVec, turnDir,
- &xDir, &yDir, &flipX, &flipY)) {
- fConvexHint = kConcave_ConvexHint;
- break;
- }
- }
- }
- } while (cmd != kEnd_PathCmd);
- if (kNone_ConvexHint == fConvexHint && numSubPaths < 2) {
- fConvexHint = kConvex_ConvexHint;
- } else {
- bool recurse = false;
- if (recurse) {
- this->resetFromIter(iter);
- }
- }
-}
-
-void GrPath::ConvexUnitTest() {
- GrPath testPath;
- GrPath::Iter testIter;
-
- GrPath pt;
- pt.moveTo(0, 0);
- pt.close();
-
- testIter.reset(pt);
- testPath.resetFromIter(&testIter);
- GrAssert(kConvex_ConvexHint == testPath.getConvexHint());
-
- GrPath line;
- line.moveTo(GrIntToScalar(12), GrIntToScalar(20));
- line.lineTo(GrIntToScalar(-12), GrIntToScalar(-20));
- line.close();
-
- testIter.reset(line);
- testPath.resetFromIter(&testIter);
- GrAssert(kConvex_ConvexHint == testPath.getConvexHint());
-
- GrPath triLeft;
- triLeft.moveTo(0, 0);
- triLeft.lineTo(1, 0);
- triLeft.lineTo(1, 1);
- triLeft.close();
-
- testIter.reset(triLeft);
- testPath.resetFromIter(&testIter);
- GrAssert(kConvex_ConvexHint == testPath.getConvexHint());
-
- GrPath triRight;
- triRight.moveTo(0, 0);
- triRight.lineTo(-1, 0);
- triRight.lineTo(1, 1);
- triRight.close();
-
- testIter.reset(triRight);
- testPath.resetFromIter(&testIter);
- GrAssert(kConvex_ConvexHint == testPath.getConvexHint());
-
- GrPath square;
- square.moveTo(0, 0);
- square.lineTo(1, 0);
- square.lineTo(1, 1);
- square.lineTo(0, 1);
- square.close();
-
- testIter.reset(square);
- testPath.resetFromIter(&testIter);
- GrAssert(kConvex_ConvexHint == testPath.getConvexHint());
-
- GrPath redundantSquare;
- square.moveTo(0, 0);
- square.lineTo(0, 0);
- square.lineTo(0, 0);
- square.lineTo(1, 0);
- square.lineTo(1, 0);
- square.lineTo(1, 0);
- square.lineTo(1, 1);
- square.lineTo(1, 1);
- square.lineTo(1, 1);
- square.lineTo(0, 1);
- square.lineTo(0, 1);
- square.lineTo(0, 1);
- square.close();
-
- testIter.reset(redundantSquare);
- testPath.resetFromIter(&testIter);
- GrAssert(kConvex_ConvexHint == testPath.getConvexHint());
-
- GrPath bowTie;
- bowTie.moveTo(0, 0);
- bowTie.lineTo(0, 0);
- bowTie.lineTo(0, 0);
- bowTie.lineTo(1, 1);
- bowTie.lineTo(1, 1);
- bowTie.lineTo(1, 1);
- bowTie.lineTo(1, 0);
- bowTie.lineTo(1, 0);
- bowTie.lineTo(1, 0);
- bowTie.lineTo(0, 1);
- bowTie.lineTo(0, 1);
- bowTie.lineTo(0, 1);
- bowTie.close();
-
- testIter.reset(bowTie);
- testPath.resetFromIter(&testIter);
- GrAssert(kConcave_ConvexHint == testPath.getConvexHint());
-
- GrPath spiral;
- spiral.moveTo(0, 0);
- spiral.lineTo(1, 0);
- spiral.lineTo(1, 1);
- spiral.lineTo(0, 1);
- spiral.lineTo(0,.5);
- spiral.lineTo(.5,.5);
- spiral.lineTo(.5,.75);
- spiral.close();
-
- testIter.reset(spiral);
- testPath.resetFromIter(&testIter);
- GrAssert(kConcave_ConvexHint == testPath.getConvexHint());
-
- GrPath dent;
- dent.moveTo(0, 0);
- dent.lineTo(1, 1);
- dent.lineTo(0, 1);
- dent.lineTo(-.5,2);
- dent.lineTo(-2, 1);
- dent.close();
-
- testIter.reset(dent);
- testPath.resetFromIter(&testIter);
- GrAssert(kConcave_ConvexHint == testPath.getConvexHint());
-}
-///////////////////////////////////////////////////////////////////////////////
-
-GrPath::Iter::Iter() : fPath(NULL) {
-}
-
-GrPath::Iter::Iter(const GrPath& path) : fPath(&path) {
- this->rewind();
-}
-
-#ifdef SK_DEBUG
-static bool containsInclusive(const GrRect& rect, const GrPoint& point) {
- return point.fX >= rect.fLeft && point.fX <= rect.fRight &&
- point.fY >= rect.fTop && point.fY <= rect.fBottom;
-}
-#endif
-
-GrPathCmd GrPath::Iter::next(GrPoint points[]) {
- if (fCmdIndex == fPath->fCmds.count()) {
- GrAssert(fPtIndex == fPath->fPts.count());
- return kEnd_PathCmd;
- } else {
- GrAssert(fCmdIndex < fPath->fCmds.count());
- }
-
- GrPathCmd cmd = fPath->fCmds[fCmdIndex++];
- const GrPoint* srcPts = fPath->fPts.begin() + fPtIndex;
-
- switch (cmd) {
- case kMove_PathCmd:
- if (points) {
- points[0] = srcPts[0];
- }
- fLastPt = srcPts[0];
- GrAssert(fPtIndex <= fPath->fPts.count() + 1);
- GrAssert(containsInclusive(fPath->getConservativeBounds(), srcPts[0]));
- fPtIndex += 1;
- break;
- case kLine_PathCmd:
- if (points) {
- points[0] = fLastPt;
- points[1] = srcPts[0];
- }
- fLastPt = srcPts[0];
- GrAssert(fPtIndex <= fPath->fPts.count() + 1);
- GrAssert(containsInclusive(fPath->getConservativeBounds(), srcPts[0]));
- fPtIndex += 1;
- break;
- case kQuadratic_PathCmd:
- if (points) {
- points[0] = fLastPt;
- points[1] = srcPts[0];
- points[2] = srcPts[1];
- }
- fLastPt = srcPts[1];
- GrAssert(fPtIndex <= fPath->fPts.count() + 2);
- GrAssert(containsInclusive(fPath->getConservativeBounds(), srcPts[0]));
- GrAssert(containsInclusive(fPath->getConservativeBounds(), srcPts[1]));
- fPtIndex += 2;
- break;
- case kCubic_PathCmd:
- if (points) {
- points[0] = fLastPt;
- points[1] = srcPts[0];
- points[2] = srcPts[1];
- points[3] = srcPts[2];
- }
- fLastPt = srcPts[2];
- GrAssert(fPtIndex <= fPath->fPts.count() + 3);
- GrAssert(containsInclusive(fPath->getConservativeBounds(), srcPts[0]));
- GrAssert(containsInclusive(fPath->getConservativeBounds(), srcPts[1]));
- GrAssert(containsInclusive(fPath->getConservativeBounds(), srcPts[2]));
- fPtIndex += 3;
- break;
- case kClose_PathCmd:
- break;
- default:
- GrAssert(!"unknown grpath cmd");
- break;
- }
- return cmd;
-}
-
-GrConvexHint GrPath::Iter::convexHint() const {
- return fPath->getConvexHint();
-}
-
-GrPathCmd GrPath::Iter::next() {
- return this->next(NULL);
-}
-
-void GrPath::Iter::rewind() {
- this->reset(*fPath);
-}
-
-void GrPath::Iter::reset(const GrPath& path) {
- fPath = &path;
- fCmdIndex = fPtIndex = 0;
-}
-
-bool GrPath::Iter::getConservativeBounds(GrRect* rect) const {
- if (!fPath->getConservativeBounds().isEmpty()) {
- *rect = fPath->getConservativeBounds();
- return true;
- }
- return false;
-}
-
diff --git a/gpu/src/GrPathRenderer.cpp b/gpu/src/GrPathRenderer.cpp
index 317b7d3..58bb12e 100644
--- a/gpu/src/GrPathRenderer.cpp
+++ b/gpu/src/GrPathRenderer.cpp
@@ -2,7 +2,6 @@
#include "GrPoint.h"
#include "GrDrawTarget.h"
-#include "GrPathIter.h"
#include "GrPathUtils.h"
#include "GrMemory.h"
#include "GrTexture.h"
@@ -147,20 +146,24 @@
////////////////////////////////////////////////////////////////////////////////
// Helpers for drawPath
+static GrConvexHint getConvexHint(const SkPath& path) {
+ return path.isConvex() ? kConvex_ConvexHint : kConcave_ConvexHint;
+}
+
#define STENCIL_OFF 0 // Always disable stencil (even when needed)
static inline bool single_pass_path(const GrDrawTarget& target,
- const GrPathIter& path,
+ const GrPath& path,
GrPathFill fill) {
#if STENCIL_OFF
return true;
#else
if (kEvenOdd_PathFill == fill) {
- GrConvexHint hint = path.convexHint();
+ GrConvexHint hint = getConvexHint(path);
return hint == kConvex_ConvexHint ||
hint == kNonOverlappingConvexPieces_ConvexHint;
} else if (kWinding_PathFill == fill) {
- GrConvexHint hint = path.convexHint();
+ GrConvexHint hint = getConvexHint(path);
return hint == kConvex_ConvexHint ||
hint == kNonOverlappingConvexPieces_ConvexHint ||
(hint == kSameWindingConvexPieces_ConvexHint &&
@@ -172,14 +175,14 @@
}
bool GrDefaultPathRenderer::requiresStencilPass(const GrDrawTarget* target,
- GrPathIter* path,
+ const GrPath& path,
GrPathFill fill) const {
- return !single_pass_path(*target, *path, fill);
+ return !single_pass_path(*target, path, fill);
}
void GrDefaultPathRenderer::onDrawPath(GrDrawTarget* target,
GrDrawTarget::StageBitfield stages,
- GrPathIter* path,
+ const GrPath& path,
GrPathFill fill,
const GrPoint* translate,
bool stencilOnly) {
@@ -200,13 +203,10 @@
// TODO: deal with perspective in some better way.
tol /= 10;
} else {
- GrScalar sinv = GR_Scalar1 / stretch;
- tol = GrMul(tol, sinv);
+ tol = GrScalarDiv(tol, stretch);
}
GrScalar tolSqd = GrMul(tol, tol);
- path->rewind();
-
int subpathCnt;
int maxPts = GrPathUtils::worstCasePointCount(path, &subpathCnt, tol);
@@ -226,8 +226,6 @@
GrAutoSTMalloc<8, uint16_t> subpathVertCount(subpathCnt);
- path->rewind();
-
// TODO: use primitve restart if available rather than multiple draws
GrPrimitiveType type;
int passCount = 0;
@@ -248,7 +246,7 @@
drawFace[0] = GrDrawTarget::kBoth_DrawFace;
} else {
type = kTriangleFan_PrimitiveType;
- if (single_pass_path(*target, *path, fill)) {
+ if (single_pass_path(*target, path, fill)) {
passCount = 1;
if (stencilOnly) {
passes[0] = &gDirectToStencil;
@@ -329,8 +327,10 @@
bool first = true;
int subpath = 0;
+ SkPath::Iter iter(path, false);
+
for (;;) {
- GrPathCmd cmd = path->next(pts);
+ GrPathCmd cmd = (GrPathCmd)iter.next(pts);
switch (cmd) {
case kMove_PathCmd:
if (!first) {
@@ -431,14 +431,14 @@
void GrDefaultPathRenderer::drawPath(GrDrawTarget* target,
GrDrawTarget::StageBitfield stages,
- GrPathIter* path,
+ const GrPath& path,
GrPathFill fill,
const GrPoint* translate) {
this->onDrawPath(target, stages, path, fill, translate, false);
}
void GrDefaultPathRenderer::drawPathToStencil(GrDrawTarget* target,
- GrPathIter* path,
+ const GrPath& path,
GrPathFill fill,
const GrPoint* translate) {
GrAssert(kInverseEvenOdd_PathFill != fill);
diff --git a/gpu/src/GrPathUtils.cpp b/gpu/src/GrPathUtils.cpp
index 115b0f6..8a72ba8 100644
--- a/gpu/src/GrPathUtils.cpp
+++ b/gpu/src/GrPathUtils.cpp
@@ -15,8 +15,6 @@
*/
#include "GrPathUtils.h"
-
-#include "GrPathIter.h"
#include "GrPoint.h"
const GrScalar GrPathUtils::gTolerance = GR_Scalar1;
@@ -33,8 +31,8 @@
// subdivide x = log4(d/tol) times. x subdivisions creates 2^(x)
// points.
// 2^(log4(x)) = sqrt(x);
- d = ceilf(sqrtf(d/tol));
- return GrMin(GrNextPow2((uint32_t)d), MAX_POINTS_PER_CURVE);
+ int temp = SkScalarCeil(SkScalarSqrt(SkScalarDiv(d, tol)));
+ return GrMin(GrNextPow2(temp), MAX_POINTS_PER_CURVE);
}
}
@@ -67,12 +65,12 @@
GrScalar tol) {
GrScalar d = GrMax(points[1].distanceToLineSegmentBetweenSqd(points[0], points[3]),
points[2].distanceToLineSegmentBetweenSqd(points[0], points[3]));
- d = sqrtf(d);
+ d = SkScalarSqrt(d);
if (d < tol) {
return 1;
} else {
- d = ceilf(sqrtf(d/tol));
- return GrMin(GrNextPow2((uint32_t)d), MAX_POINTS_PER_CURVE);
+ int temp = SkScalarCeil(SkScalarSqrt(SkScalarDiv(d, tol)));
+ return GrMin(GrNextPow2(temp), MAX_POINTS_PER_CURVE);
}
}
@@ -106,18 +104,18 @@
return a + b;
}
-int GrPathUtils::worstCasePointCount(GrPathIter* path,
- int* subpaths,
- GrScalar tol) {
+int GrPathUtils::worstCasePointCount(const GrPath& path, int* subpaths,
+ GrScalar tol) {
int pointCount = 0;
*subpaths = 1;
bool first = true;
+ SkPath::Iter iter(path, true);
GrPathCmd cmd;
GrPoint pts[4];
- while ((cmd = path->next(pts)) != kEnd_PathCmd) {
+ while ((cmd = (GrPathCmd)iter.next(pts)) != kEnd_PathCmd) {
switch (cmd) {
case kLine_PathCmd:
diff --git a/gpu/src/GrPathUtils.h b/gpu/src/GrPathUtils.h
index af05682..2cd00cb 100644
--- a/gpu/src/GrPathUtils.h
+++ b/gpu/src/GrPathUtils.h
@@ -19,15 +19,14 @@
#include "GrNoncopyable.h"
#include "GrPoint.h"
-
-class GrPathIter;
+#include "GrPath.h"
/**
* Utilities for evaluating paths.
*/
class GrPathUtils : public GrNoncopyable {
public:
- static int worstCasePointCount(GrPathIter* path,
+ static int worstCasePointCount(const GrPath&,
int* subpaths,
GrScalar tol);
static uint32_t quadraticPointCount(const GrPoint points[], GrScalar tol);
diff --git a/gpu/src/GrStencil.cpp b/gpu/src/GrStencil.cpp
index a537e16..edf83fe 100644
--- a/gpu/src/GrStencil.cpp
+++ b/gpu/src/GrStencil.cpp
@@ -16,7 +16,14 @@
#include "GrStencil.h"
-const GrStencilSettings GrStencilSettings::gDisabled = {};
+const GrStencilSettings GrStencilSettings::gDisabled = {
+ kKeep_StencilOp, kKeep_StencilOp,
+ kKeep_StencilOp, kKeep_StencilOp,
+ kAlways_StencilFunc, kAlways_StencilFunc,
+ 0x0, 0x0,
+ 0x0, 0x0,
+ 0x0, 0x0
+};
GR_STATIC_ASSERT(0 == kKeep_StencilOp);
GR_STATIC_ASSERT(0 == kAlways_StencilFunc);
diff --git a/gpu/src/GrTesselatedPathRenderer.cpp b/gpu/src/GrTesselatedPathRenderer.cpp
index 3993adb..0e3389c 100644
--- a/gpu/src/GrTesselatedPathRenderer.cpp
+++ b/gpu/src/GrTesselatedPathRenderer.cpp
@@ -18,8 +18,10 @@
#include "GrMemory.h"
#include "GrPathUtils.h"
+#include "GrPoint.h"
+#include "GrTDArray.h"
-#include <internal_glu.h>
+#include <sk_glu.h>
struct PolygonData {
PolygonData(GrTDArray<GrPoint>* vertices, GrTDArray<short>* indices)
@@ -83,24 +85,12 @@
GrTesselatedPathRenderer::GrTesselatedPathRenderer() {
}
-class Edge {
- public:
- Edge() {}
- Edge(float x, float y, float z) : fX(x), fY(y), fZ(z) {}
- GrPoint intersect(const Edge& other) {
- return GrPoint::Make(
- (fY * other.fZ - other.fY * fZ) / (fX * other.fY - other.fX * fY),
- (fX * other.fZ - other.fX * fZ) / (other.fX * fY - fX * other.fY));
- }
- float fX, fY, fZ;
-};
+typedef GrTDArray<GrDrawTarget::Edge> EdgeArray;
-typedef GrTDArray<Edge> EdgeArray;
-
-bool isCCW(const GrPoint* v)
+bool isCCW(const GrPoint* pts)
{
- GrVec v1 = v[1] - v[0];
- GrVec v2 = v[2] - v[1];
+ GrVec v1 = pts[1] - pts[0];
+ GrVec v2 = pts[2] - pts[1];
return v1.cross(v2) < 0;
}
@@ -110,25 +100,24 @@
size_t numVertices,
EdgeArray* edges)
{
+ matrix.mapPoints(vertices, numVertices);
GrPoint p = vertices[numVertices - 1];
- matrix.mapPoints(&p, 1);
float sign = isCCW(vertices) ? -1.0f : 1.0f;
for (size_t i = 0; i < numVertices; ++i) {
GrPoint q = vertices[i];
- matrix.mapPoints(&q, 1);
if (p == q) continue;
GrVec tangent = GrVec::Make(p.fY - q.fY, q.fX - p.fX);
float scale = sign / tangent.length();
float cross2 = p.fX * q.fY - q.fX * p.fY;
- Edge edge(tangent.fX * scale,
+ GrDrawTarget::Edge edge(tangent.fX * scale,
tangent.fY * scale,
cross2 * scale + 0.5f);
*edges->append() = edge;
p = q;
}
- Edge prev_edge = *edges->back();
- for (size_t i = 0; i < edges->count(); ++i) {
- Edge edge = edges->at(i);
+ GrDrawTarget::Edge prev_edge = *edges->back();
+ for (int i = 0; i < edges->count(); ++i) {
+ GrDrawTarget::Edge edge = edges->at(i);
vertices[i] = prev_edge.intersect(edge);
inverse.mapPoints(&vertices[i], 1);
prev_edge = edge;
@@ -138,11 +127,10 @@
void GrTesselatedPathRenderer::drawPath(GrDrawTarget* target,
GrDrawTarget::StageBitfield stages,
- GrPathIter* path,
+ const GrPath& path,
GrPathFill fill,
const GrPoint* translate) {
GrDrawTarget::AutoStateRestore asr(target);
- bool colorWritesWereDisabled = target->isColorWriteDisabled();
// face culling doesn't make sense here
GrAssert(GrDrawTarget::kBoth_DrawFace == target->getDrawFace());
@@ -157,13 +145,10 @@
// TODO: deal with perspective in some better way.
tol /= 10;
} else {
- GrScalar sinv = GR_Scalar1 / stretch;
- tol = GrMul(tol, sinv);
+ tol = GrScalarDiv(tol, stretch);
}
GrScalar tolSqd = GrMul(tol, tol);
- path->rewind();
-
int subpathCnt;
int maxPts = GrPathUtils::worstCasePointCount(path, &subpathCnt, tol);
@@ -185,16 +170,14 @@
GrAutoSTMalloc<8, uint16_t> subpathVertCount(subpathCnt);
- path->rewind();
-
GrPoint pts[4];
+ SkPath::Iter iter(path, true);
bool first = true;
int subpath = 0;
for (;;) {
- GrPathCmd cmd = path->next(pts);
- switch (cmd) {
+ switch (iter.next(pts)) {
case kMove_PathCmd:
if (!first) {
subpathVertCount[subpath] = vert-subpathBase;
@@ -263,31 +246,32 @@
return;
}
- if (subpathCnt == 1 && !inverted && path->convexHint() == kConvex_ConvexHint) {
+ if (subpathCnt == 1 && !inverted && path.isConvex()) {
if (target->isAntialiasState()) {
- target->enableState(GrDrawTarget::kEdgeAA_StateBit);
EdgeArray edges;
GrMatrix inverse, matrix = target->getViewMatrix();
target->getViewInverse(&inverse);
count = computeEdgesAndOffsetVertices(matrix, inverse, base, count, &edges);
- GrPoint triangle[3];
- triangle[0] = base[0];
- Edge triangleEdges[6];
- triangleEdges[0] = *edges.back();
- triangleEdges[1] = edges[0];
- for (size_t i = 1; i < count - 1; i++) {
- triangle[1] = base[i];
- triangle[2] = base[i + 1];
- triangleEdges[2] = edges[i - 1];
- triangleEdges[3] = edges[i];
- triangleEdges[4] = edges[i];
- triangleEdges[5] = edges[i + 1];
- target->setVertexSourceToArray(layout, triangle, 3);
- target->setEdgeAAData(&triangleEdges[0].fX);
- target->drawNonIndexed(kTriangles_PrimitiveType, 0, 3);
+ size_t maxEdges = target->getMaxEdges();
+ if (count <= maxEdges) {
+ // All edges fit; upload all edges and draw all verts as a fan
+ target->setVertexSourceToArray(layout, base, count);
+ target->setEdgeAAData(&edges[0], count);
+ target->drawNonIndexed(kTriangleFan_PrimitiveType, 0, count);
+ } else {
+ // Upload "maxEdges" edges and verts at a time, and draw as
+ // separate fans
+ for (size_t i = 0; i < count - 2; i += maxEdges - 2) {
+ edges[i] = edges[0];
+ base[i] = base[0];
+ int size = GR_CT_MIN(count - i, maxEdges);
+ target->setVertexSourceToArray(layout, &base[i], size);
+ target->setEdgeAAData(&edges[i], size);
+ target->drawNonIndexed(kTriangleFan_PrimitiveType, 0, size);
+ }
}
- target->disableState(GrDrawTarget::kEdgeAA_StateBit);
+ target->setEdgeAAData(NULL, 0);
} else {
target->setVertexSourceToArray(layout, base, count);
target->drawNonIndexed(kTriangleFan_PrimitiveType, 0, count);
@@ -305,34 +289,34 @@
inVertices[i * 3 + 2] = 1.0;
}
- GLUtesselator* tess = internal_gluNewTess();
+ GLUtesselator* tess = Sk_gluNewTess();
unsigned windingRule = fill_type_to_glu_winding_rule(fill);
- internal_gluTessProperty(tess, GLU_TESS_WINDING_RULE, windingRule);
- internal_gluTessCallback(tess, GLU_TESS_BEGIN_DATA, (TESSCB) &beginData);
- internal_gluTessCallback(tess, GLU_TESS_VERTEX_DATA, (TESSCB) &vertexData);
- internal_gluTessCallback(tess, GLU_TESS_END_DATA, (TESSCB) &endData);
- internal_gluTessCallback(tess, GLU_TESS_EDGE_FLAG_DATA, (TESSCB) &edgeFlagData);
- internal_gluTessCallback(tess, GLU_TESS_COMBINE_DATA, (TESSCB) &combineData);
+ Sk_gluTessProperty(tess, GLU_TESS_WINDING_RULE, windingRule);
+ Sk_gluTessCallback(tess, GLU_TESS_BEGIN_DATA, (TESSCB) &beginData);
+ Sk_gluTessCallback(tess, GLU_TESS_VERTEX_DATA, (TESSCB) &vertexData);
+ Sk_gluTessCallback(tess, GLU_TESS_END_DATA, (TESSCB) &endData);
+ Sk_gluTessCallback(tess, GLU_TESS_EDGE_FLAG_DATA, (TESSCB) &edgeFlagData);
+ Sk_gluTessCallback(tess, GLU_TESS_COMBINE_DATA, (TESSCB) &combineData);
GrTDArray<short> indices;
GrTDArray<GrPoint> vertices;
PolygonData data(&vertices, &indices);
- internal_gluTessBeginPolygon(tess, &data);
+ Sk_gluTessBeginPolygon(tess, &data);
size_t i = 0;
for (int sp = 0; sp < subpathCnt; ++sp) {
- internal_gluTessBeginContour(tess);
+ Sk_gluTessBeginContour(tess);
int start = i;
- int end = start + subpathVertCount[sp];
+ size_t end = start + subpathVertCount[sp];
for (; i < end; ++i) {
double* inVertex = &inVertices[i * 3];
*vertices.append() = GrPoint::Make(inVertex[0], inVertex[1]);
- internal_gluTessVertex(tess, inVertex, reinterpret_cast<void*>(i));
+ Sk_gluTessVertex(tess, inVertex, reinterpret_cast<void*>(i));
}
- internal_gluTessEndContour(tess);
+ Sk_gluTessEndContour(tess);
}
- internal_gluTessEndPolygon(tess);
- internal_gluDeleteTess(tess);
+ Sk_gluTessEndPolygon(tess);
+ Sk_gluDeleteTess(tess);
if (indices.count() > 0) {
target->setVertexSourceToArray(layout, vertices.begin(), vertices.count());
@@ -348,25 +332,25 @@
}
bool GrTesselatedPathRenderer::canDrawPath(const GrDrawTarget* target,
- GrPathIter* path,
+ const SkPath& path,
GrPathFill fill) const {
return kHairLine_PathFill != fill;
}
void GrTesselatedPathRenderer::drawPathToStencil(GrDrawTarget* target,
- GrPathIter* path,
+ const SkPath& path,
GrPathFill fill,
const GrPoint* translate) {
GrAlwaysAssert(!"multipass stencil should not be needed");
}
bool GrTesselatedPathRenderer::supportsAA(GrDrawTarget* target,
- GrPathIter* path,
+ const SkPath& path,
GrPathFill fill) {
int subpathCnt = 0;
int tol = GrPathUtils::gTolerance;
GrPathUtils::worstCasePointCount(path, &subpathCnt, tol);
return (subpathCnt == 1 &&
!IsFillInverted(fill) &&
- path->convexHint() == kConvex_ConvexHint);
+ path.isConvex());
}
diff --git a/gpu/src/GrTextContext.cpp b/gpu/src/GrTextContext.cpp
index 0222042..2aacfa2 100644
--- a/gpu/src/GrTextContext.cpp
+++ b/gpu/src/GrTextContext.cpp
@@ -25,11 +25,9 @@
#include "GrGpuVertex.h"
#include "GrDrawTarget.h"
-static const int TEXT_STAGE = 1;
-
-static const GrVertexLayout BASE_VLAYOUT =
- GrDrawTarget::kTextFormat_VertexLayoutBit |
- GrDrawTarget::StageTexCoordVertexLayoutBit(TEXT_STAGE,0);
+enum {
+ kGlyphMaskStage = GrPaint::kTotalStages,
+};
void GrTextContext::flushGlyphs() {
if (fCurrVertex > 0) {
@@ -45,17 +43,17 @@
GrSamplerState sampler(GrSamplerState::kRepeat_WrapMode,
GrSamplerState::kRepeat_WrapMode,
filter);
- fDrawTarget->setSamplerState(TEXT_STAGE, sampler);
+ fDrawTarget->setSamplerState(kGlyphMaskStage, sampler);
GrAssert(GrIsALIGN4(fCurrVertex));
int nIndices = fCurrVertex + (fCurrVertex >> 1);
GrAssert(fCurrTexture);
- fDrawTarget->setTexture(TEXT_STAGE, fCurrTexture);
+ fDrawTarget->setTexture(kGlyphMaskStage, fCurrTexture);
if (!GrPixelConfigIsAlphaOnly(fCurrTexture->config())) {
if (kOne_BlendCoeff != fPaint.fSrcBlendCoeff ||
kISA_BlendCoeff != fPaint.fDstBlendCoeff ||
- NULL != fPaint.getTexture()) {
+ fPaint.hasTexture()) {
GrPrintf("LCD Text will not draw correctly.\n");
}
// setup blend so that we get mask * paintColor + (1-mask)*dstColor
@@ -117,18 +115,31 @@
fOrigViewMatrix = fContext->getMatrix();
fContext->setMatrix(fExtMatrix);
- fVertexLayout = BASE_VLAYOUT;
- if (NULL != paint.getTexture()) {
- fVertexLayout |= GrDrawTarget::StagePosAsTexCoordVertexLayoutBit(0);
- GrMatrix inverseViewMatrix;
- if (fOrigViewMatrix.invert(&inverseViewMatrix)) {
- fPaint.fSampler.preConcatMatrix(inverseViewMatrix);
- }
- }
+ fDrawTarget = fContext->getTextTarget(fPaint);
fVertices = NULL;
fMaxVertices = 0;
- fDrawTarget = fContext->getTextTarget(fPaint);
+
+ fVertexLayout =
+ GrDrawTarget::kTextFormat_VertexLayoutBit |
+ GrDrawTarget::StageTexCoordVertexLayoutBit(kGlyphMaskStage, 0);
+
+ int stageMask = paint.getActiveStageMask();
+ if (stageMask) {
+ GrMatrix inverseViewMatrix;
+ if (fOrigViewMatrix.invert(&inverseViewMatrix)) {
+ fDrawTarget->preConcatSamplerMatrices(stageMask,
+ inverseViewMatrix);
+ }
+ for (int i = 0; i < GrPaint::kTotalStages; ++i) {
+ if ((1 << i) & stageMask) {
+ fVertexLayout |=
+ GrDrawTarget::StagePosAsTexCoordVertexLayoutBit(i);
+ GrAssert(i != kGlyphMaskStage);
+ }
+ }
+ }
+
}
GrTextContext::~GrTextContext() {
@@ -201,11 +212,11 @@
}
glyph->fPath = path;
}
- GrPath::Iter iter(*glyph->fPath);
+
GrPoint translate;
translate.set(GrFixedToScalar(vx - GrIntToFixed(glyph->fBounds.fLeft)),
GrFixedToScalar(vy - GrIntToFixed(glyph->fBounds.fTop)));
- fContext->drawPath(fPaint, &iter, kWinding_PathFill,
+ fContext->drawPath(fPaint, *glyph->fPath, kWinding_PathFill,
&translate);
return;
}
diff --git a/gpu/src/gr_files.mk b/gpu/src/gr_files.mk
index fef9784..bd6f061 100644
--- a/gpu/src/gr_files.mk
+++ b/gpu/src/gr_files.mk
@@ -19,10 +19,10 @@
GrInOrderDrawBuffer.cpp \
GrMatrix.cpp \
GrMemory.cpp \
- GrPath.cpp \
GrPathUtils.cpp \
GrRectanizer_fifo.cpp \
GrResource.cpp \
+ GrTesselatedPathRenderer.cpp \
GrTexture.cpp \
GrTextureCache.cpp \
GrTextContext.cpp \
diff --git a/gpu/src/gr_unittests.cpp b/gpu/src/gr_unittests.cpp
index 320dd15..338f2cc 100644
--- a/gpu/src/gr_unittests.cpp
+++ b/gpu/src/gr_unittests.cpp
@@ -68,7 +68,7 @@
for (size_t n = 0; n < GR_ARRAY_COUNT(array); n++) {
for (size_t i = 0; i < n; i++) {
int index = GrTBSearch<int, int>(array, n, array[i]);
- GrAssert(index == i);
+ GrAssert(index == (int) i);
index = GrTBSearch<int, int>(array, n, -array[i]);
GrAssert(index < 0);
}
@@ -80,10 +80,10 @@
static void test_binHashKey()
{
- const char* testStringA = "abcdA";
- const char* testStringB = "abcdB";
+ const char* testStringA = "abcdABCD";
+ const char* testStringB = "abcdBBCD";
enum {
- kDataLenUsedForKey = 5
+ kDataLenUsedForKey = 8
};
typedef GrBinHashKey<BogusEntry, kDataLenUsedForKey> KeyType;
@@ -92,7 +92,7 @@
int passCnt = 0;
while (keyA.doPass()) {
++passCnt;
- keyA.keyData(reinterpret_cast<const uint8_t*>(testStringA), kDataLenUsedForKey);
+ keyA.keyData(reinterpret_cast<const uint32_t*>(testStringA), kDataLenUsedForKey);
}
GrAssert(passCnt == 1); //We expect the static allocation to suffice
GrBinHashKey<BogusEntry, kDataLenUsedForKey-1> keyBust;
@@ -100,7 +100,7 @@
while (keyBust.doPass()) {
++passCnt;
// Exceed static storage by 1
- keyBust.keyData(reinterpret_cast<const uint8_t*>(testStringA), kDataLenUsedForKey);
+ keyBust.keyData(reinterpret_cast<const uint32_t*>(testStringA), kDataLenUsedForKey);
}
GrAssert(passCnt == 2); //We expect dynamic allocation to be necessary
GrAssert(keyA.getHash() == keyBust.getHash());
@@ -109,14 +109,14 @@
// the same hash as with one chunk
KeyType keyA2;
while (keyA2.doPass()) {
- keyA2.keyData(reinterpret_cast<const uint8_t*>(testStringA), 2);
- keyA2.keyData(&reinterpret_cast<const uint8_t*>(testStringA)[2], kDataLenUsedForKey-2);
+ keyA2.keyData(reinterpret_cast<const uint32_t*>(testStringA), 4);
+ keyA2.keyData(&reinterpret_cast<const uint32_t*>(testStringA)[4], kDataLenUsedForKey-4);
}
GrAssert(keyA.getHash() == keyA2.getHash());
KeyType keyB;
while (keyB.doPass()){
- keyB.keyData(reinterpret_cast<const uint8_t*>(testStringB), kDataLenUsedForKey);
+ keyB.keyData(reinterpret_cast<const uint32_t*>(testStringB), kDataLenUsedForKey);
}
GrAssert(keyA.compare(keyB) < 0);
GrAssert(keyA.compare(keyA2) == 0);
@@ -148,13 +148,130 @@
GrAssert(keyBust3.compare(keyBust2) == 0);
}
+static void test_convex() {
+#if 0
+ GrPath testPath;
+ GrPath::Iter testIter;
+
+ GrPath pt;
+ pt.moveTo(0, 0);
+ pt.close();
+
+ testIter.reset(pt);
+ testPath.resetFromIter(&testIter);
+ GrAssert(kConvex_ConvexHint == testPath.getConvexHint());
+
+ GrPath line;
+ line.moveTo(GrIntToScalar(12), GrIntToScalar(20));
+ line.lineTo(GrIntToScalar(-12), GrIntToScalar(-20));
+ line.close();
+
+ testIter.reset(line);
+ testPath.resetFromIter(&testIter);
+ GrAssert(kConvex_ConvexHint == testPath.getConvexHint());
+
+ GrPath triLeft;
+ triLeft.moveTo(0, 0);
+ triLeft.lineTo(1, 0);
+ triLeft.lineTo(1, 1);
+ triLeft.close();
+
+ testIter.reset(triLeft);
+ testPath.resetFromIter(&testIter);
+ GrAssert(kConvex_ConvexHint == testPath.getConvexHint());
+
+ GrPath triRight;
+ triRight.moveTo(0, 0);
+ triRight.lineTo(-1, 0);
+ triRight.lineTo(1, 1);
+ triRight.close();
+
+ testIter.reset(triRight);
+ testPath.resetFromIter(&testIter);
+ GrAssert(kConvex_ConvexHint == testPath.getConvexHint());
+
+ GrPath square;
+ square.moveTo(0, 0);
+ square.lineTo(1, 0);
+ square.lineTo(1, 1);
+ square.lineTo(0, 1);
+ square.close();
+
+ testIter.reset(square);
+ testPath.resetFromIter(&testIter);
+ GrAssert(kConvex_ConvexHint == testPath.getConvexHint());
+
+ GrPath redundantSquare;
+ square.moveTo(0, 0);
+ square.lineTo(0, 0);
+ square.lineTo(0, 0);
+ square.lineTo(1, 0);
+ square.lineTo(1, 0);
+ square.lineTo(1, 0);
+ square.lineTo(1, 1);
+ square.lineTo(1, 1);
+ square.lineTo(1, 1);
+ square.lineTo(0, 1);
+ square.lineTo(0, 1);
+ square.lineTo(0, 1);
+ square.close();
+
+ testIter.reset(redundantSquare);
+ testPath.resetFromIter(&testIter);
+ GrAssert(kConvex_ConvexHint == testPath.getConvexHint());
+
+ GrPath bowTie;
+ bowTie.moveTo(0, 0);
+ bowTie.lineTo(0, 0);
+ bowTie.lineTo(0, 0);
+ bowTie.lineTo(1, 1);
+ bowTie.lineTo(1, 1);
+ bowTie.lineTo(1, 1);
+ bowTie.lineTo(1, 0);
+ bowTie.lineTo(1, 0);
+ bowTie.lineTo(1, 0);
+ bowTie.lineTo(0, 1);
+ bowTie.lineTo(0, 1);
+ bowTie.lineTo(0, 1);
+ bowTie.close();
+
+ testIter.reset(bowTie);
+ testPath.resetFromIter(&testIter);
+ GrAssert(kConcave_ConvexHint == testPath.getConvexHint());
+
+ GrPath spiral;
+ spiral.moveTo(0, 0);
+ spiral.lineTo(1, 0);
+ spiral.lineTo(1, 1);
+ spiral.lineTo(0, 1);
+ spiral.lineTo(0,.5);
+ spiral.lineTo(.5,.5);
+ spiral.lineTo(.5,.75);
+ spiral.close();
+
+ testIter.reset(spiral);
+ testPath.resetFromIter(&testIter);
+ GrAssert(kConcave_ConvexHint == testPath.getConvexHint());
+
+ GrPath dent;
+ dent.moveTo(0, 0);
+ dent.lineTo(1, 1);
+ dent.lineTo(0, 1);
+ dent.lineTo(-.5,2);
+ dent.lineTo(-2, 1);
+ dent.close();
+
+ testIter.reset(dent);
+ testPath.resetFromIter(&testIter);
+ GrAssert(kConcave_ConvexHint == testPath.getConvexHint());
+#endif
+}
+
void gr_run_unittests() {
test_tdarray();
test_bsearch();
test_binHashKey();
+ test_convex();
GrRedBlackTree<int>::UnitTest();
- GrPath::ConvexUnitTest();
GrDrawTarget::VertexLayoutUnitTest();
}
-
-
diff --git a/gpu/src/mac/GrGLDefaultInterface_mac.cpp b/gpu/src/mac/GrGLDefaultInterface_mac.cpp
index b9396fa..fb5b182 100644
--- a/gpu/src/mac/GrGLDefaultInterface_mac.cpp
+++ b/gpu/src/mac/GrGLDefaultInterface_mac.cpp
@@ -155,6 +155,8 @@
gDefaultInterface.fBlitFramebuffer = glBlitFramebufferEXT;
#endif
#endif
+ gDefaultInterface.fBindFragDataLocationIndexed = NULL;
+
gDefaultInterface.fBindingsExported = kDesktop_GrGLBinding;
gDefaultInterfaceInit = true;
diff --git a/gpu/src/mesa/GrGLDefaultInterface_mesa.cpp b/gpu/src/mesa/GrGLDefaultInterface_mesa.cpp
new file mode 100644
index 0000000..0350c30
--- /dev/null
+++ b/gpu/src/mesa/GrGLDefaultInterface_mesa.cpp
@@ -0,0 +1,184 @@
+/*
+ Copyright 2011 Google Inc.
+
+ 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.
+ */
+
+#include "GrGLInterface.h"
+
+#include "GL/osmesa.h"
+#include <GL/glext.h>
+#include <GL/glu.h>
+
+#define GR_GL_GET_PROC(F) gDefaultInterface.f ## F = (GrGL ## F ## Proc) \
+ OSMesaGetProcAddress("gl" #F);
+#define GR_GL_GET_PROC_SUFFIX(F, S) gDefaultInterface.f ## F = (GrGL ## F ## Proc) \
+ OSMesaGetProcAddress("gl" #F #S);
+
+void GrGLSetDefaultGLInterface() {
+ static GrGLInterface gDefaultInterface;
+ static bool gDefaultInterfaceInit;
+ if (!gDefaultInterfaceInit && NULL != OSMesaGetCurrentContext()) {
+ int major, minor;
+ const char* versionString = (const char*) glGetString(GL_VERSION);
+ const char* extString = (const char*) glGetString(GL_EXTENSIONS);
+ gl_version_from_string(&major, &minor, versionString);
+
+ if (major == 1 && minor < 5) {
+ // We must have array and element_array buffer objects.
+ return;
+ }
+
+ gDefaultInterface.fActiveTexture = glActiveTexture;
+ GR_GL_GET_PROC(AttachShader);
+ GR_GL_GET_PROC(BindAttribLocation);
+ GR_GL_GET_PROC(BindBuffer);
+ gDefaultInterface.fBindTexture = glBindTexture;
+ gDefaultInterface.fBlendColor = glBlendColor;
+ gDefaultInterface.fBlendFunc = glBlendFunc;
+ GR_GL_GET_PROC(BufferData);
+ GR_GL_GET_PROC(BufferSubData);
+ gDefaultInterface.fClear = glClear;
+ gDefaultInterface.fClearColor = glClearColor;
+ gDefaultInterface.fClearStencil = glClearStencil;
+ gDefaultInterface.fClientActiveTexture = glClientActiveTexture;
+ gDefaultInterface.fColorMask = glColorMask;
+ gDefaultInterface.fColorPointer = glColorPointer;
+ gDefaultInterface.fColor4ub = glColor4ub;
+ GR_GL_GET_PROC(CompileShader);
+ gDefaultInterface.fCompressedTexImage2D = glCompressedTexImage2D;
+ GR_GL_GET_PROC(CreateProgram);
+ GR_GL_GET_PROC(CreateShader);
+ gDefaultInterface.fCullFace = glCullFace;
+ GR_GL_GET_PROC(DeleteBuffers);
+ GR_GL_GET_PROC(DeleteProgram);
+ GR_GL_GET_PROC(DeleteShader);
+ gDefaultInterface.fDeleteTextures = glDeleteTextures;
+ gDefaultInterface.fDepthMask = glDepthMask;
+ gDefaultInterface.fDisable = glDisable;
+ gDefaultInterface.fDisableClientState = glDisableClientState;
+ GR_GL_GET_PROC(DisableVertexAttribArray);
+ gDefaultInterface.fDrawArrays = glDrawArrays;
+ gDefaultInterface.fDrawElements = glDrawElements;
+ gDefaultInterface.fEnable = glEnable;
+ gDefaultInterface.fEnableClientState = glEnableClientState;
+ GR_GL_GET_PROC(EnableVertexAttribArray);
+ gDefaultInterface.fFrontFace = glFrontFace;
+ GR_GL_GET_PROC(GenBuffers);
+ GR_GL_GET_PROC(GetBufferParameteriv);
+ gDefaultInterface.fGetError = glGetError;
+ gDefaultInterface.fGetIntegerv = glGetIntegerv;
+ GR_GL_GET_PROC(GetProgramInfoLog);
+ GR_GL_GET_PROC(GetProgramiv);
+ GR_GL_GET_PROC(GetShaderInfoLog);
+ GR_GL_GET_PROC(GetShaderiv);
+ gDefaultInterface.fGetString = glGetString;
+ gDefaultInterface.fGenTextures = glGenTextures;
+ GR_GL_GET_PROC(GetUniformLocation);
+ gDefaultInterface.fLineWidth = glLineWidth;
+ GR_GL_GET_PROC(LinkProgram);
+ gDefaultInterface.fLoadMatrixf = glLoadMatrixf;
+ GR_GL_GET_PROC(MapBuffer);
+ gDefaultInterface.fMatrixMode = glMatrixMode;
+ gDefaultInterface.fPointSize = glPointSize;
+ gDefaultInterface.fPixelStorei = glPixelStorei;
+ gDefaultInterface.fReadPixels = glReadPixels;
+ gDefaultInterface.fScissor = glScissor;
+ gDefaultInterface.fShadeModel = glShadeModel;
+ GR_GL_GET_PROC(ShaderSource);
+ gDefaultInterface.fStencilFunc = glStencilFunc;
+ GR_GL_GET_PROC(StencilFuncSeparate);
+ gDefaultInterface.fStencilMask = glStencilMask;
+ GR_GL_GET_PROC(StencilMaskSeparate);
+ gDefaultInterface.fStencilOp = glStencilOp;
+ GR_GL_GET_PROC(StencilOpSeparate);
+ gDefaultInterface.fTexCoordPointer = glTexCoordPointer;
+ gDefaultInterface.fTexEnvi = glTexEnvi;
+ //OSMesa on Mac's glTexImage2D takes a GLenum for internalFormat rather than a GLint.
+ gDefaultInterface.fTexImage2D = reinterpret_cast<GrGLTexImage2DProc>(glTexImage2D);
+ gDefaultInterface.fTexParameteri = glTexParameteri;
+ gDefaultInterface.fTexSubImage2D = glTexSubImage2D;
+ GR_GL_GET_PROC(Uniform1f);
+ GR_GL_GET_PROC(Uniform1i);
+ GR_GL_GET_PROC(Uniform1fv);
+ GR_GL_GET_PROC(Uniform1iv);
+ GR_GL_GET_PROC(Uniform2f);
+ GR_GL_GET_PROC(Uniform2i);
+ GR_GL_GET_PROC(Uniform2fv);
+ GR_GL_GET_PROC(Uniform2iv);
+ GR_GL_GET_PROC(Uniform3f);
+ GR_GL_GET_PROC(Uniform3i);
+ GR_GL_GET_PROC(Uniform3fv);
+ GR_GL_GET_PROC(Uniform3iv);
+ GR_GL_GET_PROC(Uniform4f);
+ GR_GL_GET_PROC(Uniform4i);
+ GR_GL_GET_PROC(Uniform4fv);
+ GR_GL_GET_PROC(Uniform4iv);
+ GR_GL_GET_PROC(UniformMatrix2fv);
+ GR_GL_GET_PROC(UniformMatrix3fv);
+ GR_GL_GET_PROC(UniformMatrix4fv);
+ GR_GL_GET_PROC(UnmapBuffer);
+ GR_GL_GET_PROC(UseProgram);
+ GR_GL_GET_PROC(VertexAttrib4fv);
+ GR_GL_GET_PROC(VertexAttribPointer);
+ gDefaultInterface.fVertexPointer = glVertexPointer;
+ gDefaultInterface.fViewport = glViewport;
+
+ // First look for GL3.0 FBO or GL_ARB_framebuffer_object (same since
+ // GL_ARB_framebuffer_object doesn't use ARB suffix.)
+ if (major >= 3 || has_gl_extension_from_string(
+ "GL_ARB_framebuffer_object", extString)) {
+ GR_GL_GET_PROC(GenFramebuffers);
+ GR_GL_GET_PROC(BindFramebuffer);
+ GR_GL_GET_PROC(FramebufferTexture2D);
+ GR_GL_GET_PROC(CheckFramebufferStatus);
+ GR_GL_GET_PROC(DeleteFramebuffers);
+ GR_GL_GET_PROC(RenderbufferStorage);
+ GR_GL_GET_PROC(GenRenderbuffers);
+ GR_GL_GET_PROC(DeleteRenderbuffers);
+ GR_GL_GET_PROC(FramebufferRenderbuffer);
+ GR_GL_GET_PROC(BindRenderbuffer);
+ GR_GL_GET_PROC(RenderbufferStorageMultisample);
+ GR_GL_GET_PROC(BlitFramebuffer);
+ } else if (has_gl_extension_from_string("GL_EXT_framebuffer_object",
+ extString)) {
+ GR_GL_GET_PROC_SUFFIX(GenFramebuffers, EXT);
+ GR_GL_GET_PROC_SUFFIX(BindFramebuffer, EXT);
+ GR_GL_GET_PROC_SUFFIX(FramebufferTexture2D, EXT);
+ GR_GL_GET_PROC_SUFFIX(CheckFramebufferStatus, EXT);
+ GR_GL_GET_PROC_SUFFIX(DeleteFramebuffers, EXT);
+ GR_GL_GET_PROC_SUFFIX(RenderbufferStorage, EXT);
+ GR_GL_GET_PROC_SUFFIX(GenRenderbuffers, EXT);
+ GR_GL_GET_PROC_SUFFIX(DeleteRenderbuffers, EXT);
+ GR_GL_GET_PROC_SUFFIX(FramebufferRenderbuffer, EXT);
+ GR_GL_GET_PROC_SUFFIX(BindRenderbuffer, EXT);
+ if (has_gl_extension_from_string("GL_EXT_framebuffer_multisample",
+ extString)) {
+ GR_GL_GET_PROC_SUFFIX(RenderbufferStorageMultisample, EXT);
+ }
+ if (has_gl_extension_from_string("GL_EXT_framebuffer_blit",
+ extString)) {
+ GR_GL_GET_PROC_SUFFIX(BlitFramebuffer, EXT);
+ }
+ } else {
+ // we must have FBOs
+ return;
+ }
+ GR_GL_GET_PROC(BindFragDataLocationIndexed);
+ gDefaultInterface.fBindingsExported = kDesktop_GrGLBinding;
+
+ gDefaultInterfaceInit = true;
+ }
+ if (gDefaultInterfaceInit)
+ GrGLSetGLInterface(&gDefaultInterface);
+}
diff --git a/gpu/src/unix/GrGLDefaultInterface_unix.cpp b/gpu/src/unix/GrGLDefaultInterface_unix.cpp
index ba67065..3e9b975 100644
--- a/gpu/src/unix/GrGLDefaultInterface_unix.cpp
+++ b/gpu/src/unix/GrGLDefaultInterface_unix.cpp
@@ -133,6 +133,7 @@
GR_GL_GET_PROC(VertexAttribPointer);
gDefaultInterface.fVertexPointer = glVertexPointer;
gDefaultInterface.fViewport = glViewport;
+ GR_GL_GET_PROC(BindFragDataLocationIndexed);
// First look for GL3.0 FBO or GL_ARB_framebuffer_object (same since
// GL_ARB_framebuffer_object doesn't use ARB suffix.)
diff --git a/gpu/src/win/GrGLDefaultInterface_win.cpp b/gpu/src/win/GrGLDefaultInterface_win.cpp
index 53fb26a..428abb1 100644
--- a/gpu/src/win/GrGLDefaultInterface_win.cpp
+++ b/gpu/src/win/GrGLDefaultInterface_win.cpp
@@ -139,6 +139,7 @@
GR_GL_GET_PROC(UseProgram);
GR_GL_GET_PROC(VertexAttrib4fv);
GR_GL_GET_PROC(VertexAttribPointer);
+ GR_GL_GET_PROC(BindFragDataLocationIndexed);
// First look for GL3.0 FBO or GL_ARB_framebuffer_object (same since
// GL_ARB_framebuffer_object doesn't use ARB suffix.)
diff --git a/gyp/common.gypi b/gyp/common.gypi
deleted file mode 100644
index aadaffb..0000000
--- a/gyp/common.gypi
+++ /dev/null
@@ -1,94 +0,0 @@
-# Copyright (C) 2011 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.
-{
- 'conditions' : [
- ['OS == "win"',
- {
- 'target_defaults': {
- 'msvs_cygwin_shell': 0,
- 'msvs_settings': {
- 'VCCLCompilerTool': {
- 'WarningLevel': '1',
- 'WarnAsError': 'false',
- 'DebugInformationFormat': '3',
- 'AdditionalOptions': '/MP',
- },
- },
- 'configurations': {
- 'Debug': {
- 'msvs_settings': {
- 'VCCLCompilerTool': {
- 'Optimization': '0', # 0 = /Od
- 'PreprocessorDefinitions': ['_DEBUG'],
- 'RuntimeLibrary': '3', # 3 = /MDd (debug DLL)
- },
- 'VCLinkerTool': {
- 'GenerateDebugInformation': 'true',
- },
- },
- },
- 'Release': {
- 'msvs_settings': {
- 'VCCLCompilerTool': {
- 'Optimization': '2', # 2 = /Os
- 'PreprocessorDefinitions': ['NDEBUG'],
- 'RuntimeLibrary': '2', # 2 = /MD (nondebug DLL)
- },
- 'VCLinkerTool': {
- 'GenerateDebugInformation': 'false',
- },
- },
- },
- },
- },
- },
- ],
- ['OS == "linux"',
- {
- 'target_defaults': {
- 'configurations': {
- 'Debug': {
- 'cflags': ['-g']
- },
- 'Release': {
- 'cflags': ['-O2']
- },
- },
- },
- },
- ],
- ['OS == "mac"',
- {
- 'target_defaults': {
- 'configurations': {
- 'Debug': {
- 'cflags': ['-g']
- },
- 'Release': {
- 'cflags': ['-O2']
- },
- },
- },
- 'xcode_settings': {
- 'SYMROOT': '<(DEPTH)/xcodebuild',
- },
- },
- ],
- ],
-}
-# Local Variables:
-# tab-width:2
-# indent-tabs-mode:nil
-# End:
-# vim: set expandtab tabstop=2 shiftwidth=2:
diff --git a/gyp/gyp_skia b/gyp/gyp_skia
deleted file mode 100755
index 72b4879..0000000
--- a/gyp/gyp_skia
+++ /dev/null
@@ -1,77 +0,0 @@
-#!/usr/bin/python
-#
-# Copyright (C) 2011 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.
-
-# This script is a wrapper which invokes gyp with the correct --depth argument,
-# and supports the automatic regeneration of build files if skia.gyp is
-# changed (Linux-only).
-
-import glob
-import os
-import shlex
-import sys
-
-script_dir = os.path.dirname(__file__)
-
-gyp_dir = os.path.normpath(os.path.join(script_dir, os.pardir, 'third_party'))
-
-sys.path.append(os.path.join(gyp_dir, 'gyp', 'pylib'))
-import gyp
-
-def additional_include_files(args=[]):
- # Determine the include files specified on the command line.
- # This doesn't cover all the different option formats you can use,
- # but it's mainly intended to avoid duplicating flags on the automatic
- # makefile regeneration which only uses this format.
- specified_includes = set()
- for arg in args:
- if arg.startswith('-I') and len(arg) > 2:
- specified_includes.add(os.path.realpath(arg[2:]))
-
- result = []
- def AddInclude(path):
- if os.path.realpath(path) not in specified_includes:
- result.append(path)
-
- # Always include common.gypi
- AddInclude(os.path.join(script_dir, 'common.gypi'))
-
- return result
-
-if __name__ == '__main__':
- args = sys.argv[1:]
-
- # This could give false positives since it doesn't actually do real option
- # parsing. Oh well.
- gyp_file_specified = False
- for arg in args:
- if arg.endswith('.gyp'):
- gyp_file_specified = True
- break
-
- # If we didn't get a file, then fall back to assuming 'skia.gyp' from the
- # same directory as the script.
- if not gyp_file_specified:
- args.append(os.path.join(script_dir, 'skia.gyp'))
-
- args.extend(['-I' + i for i in additional_include_files(args)])
-
- args.extend(['--depth'])
- args.extend([os.path.abspath(script_dir)])
- print 'Updating projects from gyp files...'
- sys.stdout.flush()
-
- # Off we go...
- sys.exit(gyp.main(args))
diff --git a/gyp/skia.gyp b/gyp/skia.gyp
deleted file mode 100644
index 7247828..0000000
--- a/gyp/skia.gyp
+++ /dev/null
@@ -1,1589 +0,0 @@
-{
- 'target_defaults': {
- 'configurations': {
- 'Debug': {
- 'defines': [
- 'SK_DEBUG',
- 'GR_DEBUG=1',
- ],
- },
- 'Release': {
- 'defines': [
- 'SK_RELEASE',
- 'GR_RELEASE=1',
- ],
- },
- },
- 'conditions': [
- [ 'OS == "linux" or OS == "freebsd" or OS == "openbsd" or OS == "solaris"', {
- 'include_dirs' : [
- '/usr/include/freetype2',
- ],
- }],
- [ 'OS == "mac"', {
- 'defines': [
- 'SK_BUILD_FOR_MAC',
- ],
- }],
- [ 'OS == "win"', {
- 'defines': [
- 'SK_BUILD_FOR_WIN32',
- 'SK_IGNORE_STDINT_DOT_H',
- ],
- }],
- [ 'OS == "linux"', {
- 'defines': [
- 'SK_SAMPLES_FOR_X',
- ],
- }],
- ],
- 'direct_dependent_settings': {
- 'conditions': [
- [ 'OS == "mac"', {
- 'defines': [
- 'SK_BUILD_FOR_MAC',
- ],
- }],
- [ 'OS == "win"', {
- 'defines': [
- 'SK_BUILD_FOR_WIN32',
- ],
- }],
- ],
- },
- },
- 'targets': [
- {
- 'target_name': 'skia',
- 'type': 'static_library',
- 'msvs_guid': 'B7760B5E-BFA8-486B-ACFD-49E3A6DE8E76',
- 'sources': [
- '../src/core/ARGB32_Clamp_Bilinear_BitmapShader.h',
- '../src/core/Sk64.cpp',
- '../src/core/SkAdvancedTypefaceMetrics.cpp',
- '../src/core/SkAlphaRuns.cpp',
- '../src/core/SkAntiRun.h',
- '../src/core/SkBitmap.cpp',
- '../src/core/SkBitmapProcShader.cpp',
- '../src/core/SkBitmapProcShader.h',
- '../src/core/SkBitmapProcState.cpp',
- '../src/core/SkBitmapProcState.h',
- '../src/core/SkBitmapProcState_matrix.h',
- '../src/core/SkBitmapProcState_matrixProcs.cpp',
- '../src/core/SkBitmapProcState_sample.h',
- '../src/core/SkBitmapSampler.cpp',
- '../src/core/SkBitmapSampler.h',
- '../src/core/SkBitmapSamplerTemplate.h',
- '../src/core/SkBitmapShader16BilerpTemplate.h',
- '../src/core/SkBitmapShaderTemplate.h',
- '../src/core/SkBitmap_scroll.cpp',
- '../src/core/SkBlitBWMaskTemplate.h',
- '../src/core/SkBlitRow_D16.cpp',
- '../src/core/SkBlitRow_D32.cpp',
- '../src/core/SkBlitRow_D4444.cpp',
- '../src/core/SkBlitter.cpp',
- '../src/core/SkBlitter_4444.cpp',
- '../src/core/SkBlitter_A1.cpp',
- '../src/core/SkBlitter_A8.cpp',
- '../src/core/SkBlitter_ARGB32.cpp',
- '../src/core/SkBlitter_RGB16.cpp',
- '../src/core/SkBlitter_Sprite.cpp',
- '../src/core/SkBuffer.cpp',
- '../src/core/SkCanvas.cpp',
- '../src/core/SkChunkAlloc.cpp',
- '../src/core/SkClampRange.cpp',
- '../src/core/SkClipStack.cpp',
- '../src/core/SkColor.cpp',
- '../src/core/SkColorFilter.cpp',
- '../src/core/SkColorTable.cpp',
- '../src/core/SkComposeShader.cpp',
- '../src/core/SkConcaveToTriangles.cpp',
- '../src/core/SkConcaveToTriangles.h',
- '../src/core/SkCordic.cpp',
- '../src/core/SkCordic.h',
- '../src/core/SkCoreBlitters.h',
- '../src/core/SkCubicClipper.cpp',
- '../src/core/SkCubicClipper.h',
- '../src/core/SkDebug.cpp',
- '../src/core/SkDeque.cpp',
- '../src/core/SkDevice.cpp',
- '../src/core/SkDither.cpp',
- '../src/core/SkDraw.cpp',
- '../src/core/SkDrawProcs.h',
- '../src/core/SkEdgeBuilder.cpp',
- '../src/core/SkEdgeClipper.cpp',
- '../src/core/SkEdge.cpp',
- '../src/core/SkEdge.h',
- '../src/core/SkFP.h',
- '../src/core/SkFilterProc.cpp',
- '../src/core/SkFilterProc.h',
- '../src/core/SkFlattenable.cpp',
- '../src/core/SkFloat.cpp',
- '../src/core/SkFloat.h',
- '../src/core/SkFloatBits.cpp',
- '../src/core/SkGeometry.cpp',
- '../src/core/SkGlobals.cpp',
- '../src/core/SkGlyphCache.cpp',
- '../src/core/SkGlyphCache.h',
- '../src/core/SkGraphics.cpp',
- '../src/core/SkLineClipper.cpp',
- '../src/core/SkMallocPixelRef.cpp',
- '../src/core/SkMask.cpp',
- '../src/core/SkMaskFilter.cpp',
- '../src/core/SkMath.cpp',
- '../src/core/SkMatrix.cpp',
- '../src/core/SkMetaData.cpp',
- '../src/core/SkPackBits.cpp',
- '../src/core/SkPaint.cpp',
- '../src/core/SkPath.cpp',
- '../src/core/SkPathEffect.cpp',
- '../src/core/SkPathHeap.cpp',
- '../src/core/SkPathHeap.h',
- '../src/core/SkPathMeasure.cpp',
- '../src/core/SkPicture.cpp',
- '../src/core/SkPictureFlat.cpp',
- '../src/core/SkPictureFlat.h',
- '../src/core/SkPicturePlayback.cpp',
- '../src/core/SkPicturePlayback.h',
- '../src/core/SkPictureRecord.cpp',
- '../src/core/SkPictureRecord.h',
- '../src/core/SkPixelRef.cpp',
- '../src/core/SkPoint.cpp',
- '../src/core/SkProcSpriteBlitter.cpp',
- '../src/core/SkPtrRecorder.cpp',
- '../src/core/SkQuadClipper.cpp',
- '../src/core/SkQuadClipper.h',
- '../src/core/SkRasterizer.cpp',
- '../src/core/SkRect.cpp',
- '../src/core/SkRefDict.cpp',
- '../src/core/SkRegion.cpp',
- '../src/core/SkRegionPriv.h',
- '../src/core/SkRegion_path.cpp',
- '../src/core/SkScalar.cpp',
- '../src/core/SkScalerContext.cpp',
- '../src/core/SkScan.cpp',
- '../src/core/SkScanPriv.h',
- '../src/core/SkScan_AntiPath.cpp',
- '../src/core/SkScan_Antihair.cpp',
- '../src/core/SkScan_Hairline.cpp',
- '../src/core/SkScan_Path.cpp',
- '../src/core/SkShader.cpp',
- '../src/core/SkShape.cpp',
- '../src/core/SkSpriteBlitter_ARGB32.cpp',
- '../src/core/SkSpriteBlitter_RGB16.cpp',
- '../src/core/SkSinTable.h',
- '../src/core/SkSpriteBlitter.h',
- '../src/core/SkSpriteBlitterTemplate.h',
- '../src/core/SkStream.cpp',
- '../src/core/SkString.cpp',
- '../src/core/SkStroke.cpp',
- '../src/core/SkStrokerPriv.cpp',
- '../src/core/SkStrokerPriv.h',
- '../src/core/SkTextFormatParams.h',
- '../src/core/SkTSearch.cpp',
- '../src/core/SkTSort.h',
- '../src/core/SkTemplatesPriv.h',
- '../src/core/SkTypeface.cpp',
- '../src/core/SkTypefaceCache.cpp',
- '../src/core/SkTypefaceCache.h',
- '../src/core/SkUnPreMultiply.cpp',
- '../src/core/SkUtils.cpp',
- '../src/core/SkWriter32.cpp',
- '../src/core/SkXfermode.cpp',
-
- '../src/opts/opts_check_SSE2.cpp',
-
- '../src/ports/SkDebug_stdio.cpp',
- '../src/ports/SkDebug_win.cpp',
-
- '../src/ports/SkFontHost_tables.cpp',
- '../src/ports/SkGlobals_global.cpp',
- '../src/ports/SkMemory_malloc.cpp',
- '../src/ports/SkOSFile_stdio.cpp',
- '../src/ports/SkTime_Unix.cpp',
- '../src/ports/SkXMLParser_empty.cpp',
- '../src/ports/sk_predefined_gamma.h',
-
- '../include/core/Sk64.h',
- '../include/core/SkAdvancedTypefaceMetrics.h',
- '../include/core/SkAutoKern.h',
- '../include/core/SkBitmap.h',
- '../include/core/SkBlitRow.h',
- '../include/core/SkBlitter.h',
- '../include/core/SkBounder.h',
- '../include/core/SkBuffer.h',
- '../include/core/SkCanvas.h',
- '../include/core/SkChunkAlloc.h',
- '../include/core/SkClampRange.h',
- '../include/core/SkClipStack.h',
- '../include/core/SkColor.h',
- '../include/core/SkColorFilter.h',
- '../include/core/SkColorPriv.h',
- '../include/core/SkColorShader.h',
- '../include/core/SkComposeShader.h',
- '../include/core/SkDeque.h',
- '../include/core/SkDescriptor.h',
- '../include/core/SkDevice.h',
- '../include/core/SkDither.h',
- '../include/core/SkDraw.h',
- '../include/core/SkDrawFilter.h',
- '../include/core/SkDrawLooper.h',
- '../include/core/SkEndian.h',
- '../include/core/SkFDot6.h',
- '../include/core/SkFixed.h',
- '../include/core/SkFlattenable.h',
- '../include/core/SkFloatBits.h',
- '../include/core/SkFloatingPoint.h',
- '../include/core/SkFontHost.h',
- '../include/core/SkGeometry.h',
- '../include/core/SkGlobals.h',
- '../include/core/SkGraphics.h',
- '../include/core/SkMallocPixelRef.h',
- '../include/core/SkMask.h',
- '../include/core/SkMaskFilter.h',
- '../include/core/SkMath.h',
- '../include/core/SkMatrix.h',
- '../include/core/SkMetaData.h',
- '../include/core/SkOSFile.h',
- '../include/core/SkPackBits.h',
- '../include/core/SkPaint.h',
- '../include/core/SkPath.h',
- '../include/core/SkPathEffect.h',
- '../include/core/SkPathMeasure.h',
- '../include/core/SkPerspIter.h',
- '../include/core/SkPicture.h',
- '../include/core/SkPixelRef.h',
- '../include/core/SkPoint.h',
- '../include/core/SkPtrRecorder.h',
- '../include/core/SkRandom.h',
- '../include/core/SkRasterizer.h',
- '../include/core/SkReader32.h',
- '../include/core/SkRect.h',
- '../include/core/SkRefCnt.h',
- '../include/core/SkRefDict.h',
- '../include/core/SkRegion.h',
- '../include/core/SkScalar.h',
- '../include/core/SkScalarCompare.h',
- '../include/core/SkScalerContext.h',
- '../include/core/SkScan.h',
- '../include/core/SkShader.h',
- '../include/core/SkStream.h',
- '../include/core/SkString.h',
- '../include/core/SkStroke.h',
- '../include/core/SkTDArray.h',
- '../include/core/SkTDStack.h',
- '../include/core/SkTDict.h',
- '../include/core/SkTRegistry.h',
- '../include/core/SkTScopedPtr.h',
- '../include/core/SkTSearch.h',
- '../include/core/SkTemplates.h',
- '../include/core/SkThread.h',
- '../include/core/SkThread_platform.h',
- '../include/core/SkTime.h',
- '../include/core/SkTypeface.h',
- '../include/core/SkTypes.h',
- '../include/core/SkUnPreMultiply.h',
- '../include/core/SkUnitMapper.h',
- '../include/core/SkUtils.h',
- '../include/core/SkWriter32.h',
- '../include/core/SkXfermode.h',
- ],
- 'include_dirs': [
- '../include/config',
- '../include/core',
- '../include/ports',
- '../include/xml',
- '../src/core',
- ],
- 'msvs_disabled_warnings': [4244, 4267,4345, 4390, 4554, 4800],
- 'conditions': [
- [ 'OS == "linux" or OS == "freebsd" or OS == "openbsd" or OS == "solaris"', {
- 'cflags': [
- '-Wno-unused',
- '-Wno-unused-function',
- ],
- 'sources': [
- '../include/core/SkMMapStream.h',
- '../src/core/SkMMapStream.cpp',
- '../src/core/SkBlitter_ARGB32_Subpixel.cpp',
- '../src/core/SkFontHost.cpp',
- '../src/ports/SkThread_pthread.cpp',
- '../src/ports/SkTime_Unix.cpp',
- '../src/ports/SkFontHost_FreeType_Subpixel.cpp',
- '../src/ports/SkFontHost_FreeType.cpp',
- '../src/ports/SkFontHost_gamma_none.cpp',
- '../src/ports/SkFontHost_linux.cpp',
- ],
- 'link_settings': {
- 'libraries': [
- '-lfreetype',
- '-lpthread',
- ],
- },
- }],
- [ 'OS == "mac"', {
- 'include_dirs': [
- '../include/utils/mac',
- ],
- 'sources': [
- '../include/core/SkMMapStream.h',
- '../include/utils/mac/SkCGUtils.h',
-
- '../src/core/SkMMapStream.cpp',
- '../src/ports/SkFontHost_mac_coretext.cpp',
-
- '../src/ports/SkThread_pthread.cpp',
- '../src/ports/SkTime_Unix.cpp',
-
- '../src/utils/mac/SkCreateCGImageRef.cpp',
- ],
- }],
- [ 'OS == "win"', {
- 'include_dirs': [
- 'config/win',
- ],
- 'sources': [
- '../src/ports/SkFontHost_win.cpp',
- '../src/ports/SkThread_win.cpp',
- ],
- 'sources!': [
- '../src/ports/SkDebug_stdio.cpp',
- ],
- }],
- [ 'OS != "win"', {
- 'sources!': [
- '../src/ports/SkDebug_win.cpp',
- ],
- }],
- ],
- 'direct_dependent_settings': {
- 'include_dirs': [
- 'config',
- '../include/config',
- '../include/core',
- 'ext',
- ],
- },
- 'dependencies': [
- 'skia_opts'
- ],
- },
-
- # Due to an unfortunate intersection of lameness between gcc and gyp,
- # we have to build the *_SSE2.cpp files in a separate target. The
- # gcc lameness is that, in order to compile SSE2 intrinsics code, it
- # must be passed the -msse2 flag. However, with this flag, it may
- # emit SSE2 instructions even for scalar code, such as the CPUID
- # test used to test for the presence of SSE2. So that, and all other
- # code must be compiled *without* -msse2. The gyp lameness is that it
- # does not allow file-specific CFLAGS, so we must create this extra
- # target for those files to be compiled with -msse2.
- #
- # This is actually only a problem on 32-bit Linux (all Intel Macs have
- # SSE2, Linux x86_64 has SSE2 by definition, and MSC will happily emit
- # SSE2 from instrinsics, while generating plain ol' 386 for everything
- # else). However, to keep the .gyp file simple and avoid platform-specific
- # build breakage, we do this on all platforms.
-
- # For about the same reason, we need to compile the ARM opts files
- # separately as well.
- {
- 'target_name': 'skia_opts',
- 'type': 'static_library',
- 'include_dirs': [
- '../include/config',
- '../include/core',
- '../src/core',
- ],
- 'conditions': [
- [ '(OS == "linux" or OS == "freebsd" or OS == "openbsd")', {
- 'cflags': [
- '-msse2',
- ],
- }],
- ],
- 'sources': [
- '../src/opts/SkBitmapProcState_opts_SSE2.cpp',
- '../src/opts/SkBlitRow_opts_SSE2.cpp',
- '../src/opts/SkUtils_opts_SSE2.cpp',
- ],
- },
- {
- 'target_name': 'effects',
- 'type': 'static_library',
- 'include_dirs': [
- '../include/config',
- '../include/core',
- '../include/effects',
- ],
- 'sources': [
- '../include/effects/Sk1DPathEffect.h',
- '../include/effects/Sk2DPathEffect.h',
- '../include/effects/SkAvoidXfermode.h',
- '../include/effects/SkBlurDrawLooper.h',
- '../include/effects/SkBlurMaskFilter.h',
- '../include/effects/SkColorMatrix.h',
- '../include/effects/SkColorMatrixFilter.h',
- '../include/effects/SkCornerPathEffect.h',
- '../include/effects/SkDashPathEffect.h',
- '../include/effects/SkDiscretePathEffect.h',
- '../include/effects/SkDrawExtraPathEffect.h',
- '../include/effects/SkEmbossMaskFilter.h',
- '../include/effects/SkGradientShader.h',
- '../include/effects/SkGroupShape.h',
- '../include/effects/SkKernel33MaskFilter.h',
- '../include/effects/SkLayerDrawLooper.h',
- '../include/effects/SkLayerRasterizer.h',
- '../include/effects/SkPaintFlagsDrawFilter.h',
- '../include/effects/SkPixelXorXfermode.h',
- '../include/effects/SkPorterDuff.h',
- '../include/effects/SkRectShape.h',
- '../include/effects/SkTableMaskFilter.h',
- '../include/effects/SkTransparentShader.h',
-
- '../src/effects/Sk1DPathEffect.cpp',
- '../src/effects/Sk2DPathEffect.cpp',
- '../src/effects/SkAvoidXfermode.cpp',
- '../src/effects/SkBitmapCache.cpp',
- '../src/effects/SkBitmapCache.h',
- '../src/effects/SkBlurDrawLooper.cpp',
- '../src/effects/SkBlurMask.cpp',
- '../src/effects/SkBlurMask.h',
- '../src/effects/SkBlurMaskFilter.cpp',
- '../src/effects/SkColorFilters.cpp',
- '../src/effects/SkColorMatrixFilter.cpp',
- '../src/effects/SkCornerPathEffect.cpp',
- '../src/effects/SkDashPathEffect.cpp',
- '../src/effects/SkDiscretePathEffect.cpp',
- '../src/effects/SkEmbossMask.cpp',
- '../src/effects/SkEmbossMask.h',
- '../src/effects/SkEmbossMask_Table.h',
- '../src/effects/SkEmbossMaskFilter.cpp',
- '../src/effects/SkGradientShader.cpp',
- '../src/effects/SkGroupShape.cpp',
- '../src/effects/SkKernel33MaskFilter.cpp',
- '../src/effects/SkLayerDrawLooper.cpp',
- '../src/effects/SkLayerRasterizer.cpp',
- '../src/effects/SkPaintFlagsDrawFilter.cpp',
- '../src/effects/SkPixelXorXfermode.cpp',
- '../src/effects/SkPorterDuff.cpp',
- '../src/effects/SkRadialGradient_Table.h',
- '../src/effects/SkRectShape.cpp',
- '../src/effects/SkTableMaskFilter.cpp',
- '../src/effects/SkTransparentShader.cpp',
- ],
- 'direct_dependent_settings': {
- 'include_dirs': [
- '../include/effects',
- ],
- },
- },
- {
- 'target_name': 'images',
- 'type': 'static_library',
- 'include_dirs': [
- '../include/config',
- '../include/core',
- '../include/images',
- ],
- 'sources': [
- '../include/images/SkFlipPixelRef.h',
- '../include/images/SkImageDecoder.h',
- '../include/images/SkImageEncoder.h',
- '../include/images/SkImageRef.h',
- '../include/images/SkImageRef_GlobalPool.h',
- '../include/images/SkJpegUtility.h',
- '../include/images/SkMovie.h',
- '../include/images/SkPageFlipper.h',
-
- '../src/images/bmpdecoderhelper.cpp',
- '../src/images/bmpdecoderhelper.h',
- '../src/images/SkBitmap_RLEPixels.h',
- '../src/images/SkCreateRLEPixelRef.cpp',
- '../src/images/SkFDStream.cpp',
- '../src/images/SkFlipPixelRef.cpp',
- '../src/images/SkImageDecoder.cpp',
- '../src/images/SkImageDecoder_Factory.cpp',
- '../src/images/SkImageDecoder_libbmp.cpp',
- '../src/images/SkImageDecoder_libgif.cpp',
- '../src/images/SkImageDecoder_libico.cpp',
- '../src/images/SkImageDecoder_libjpeg.cpp',
- '../src/images/SkImageDecoder_libpng.cpp',
- '../src/images/SkImageDecoder_libpvjpeg.c',
- '../src/images/SkImageDecoder_wbmp.cpp',
- '../src/images/SkImageEncoder.cpp',
- '../src/images/SkImageEncoder_Factory.cpp',
- '../src/images/SkImageRef.cpp',
- '../src/images/SkImageRefPool.cpp',
- '../src/images/SkImageRefPool.h',
- '../src/images/SkImageRef_GlobalPool.cpp',
- '../src/images/SkJpegUtility.cpp',
- '../src/images/SkMovie.cpp',
- '../src/images/SkMovie_gif.cpp',
- '../src/images/SkPageFlipper.cpp',
- '../src/images/SkScaledBitmapSampler.cpp',
- '../src/images/SkScaledBitmapSampler.h',
- ],
- 'conditions': [
- [ 'OS == "win"', {
- 'sources!': [
- '../include/images/SkJpegUtility.h',
-
- '../src/images/SkFDStream.cpp',
- '../src/images/SkImageDecoder_libgif.cpp',
- '../src/images/SkImageDecoder_libjpeg.cpp',
- '../src/images/SkImageDecoder_libpng.cpp',
- '../src/images/SkImageDecoder_libpvjpeg.c',
- '../src/images/SkJpegUtility.cpp',
- '../src/images/SkMovie_gif.cpp',
- ],
- }],
- [ 'OS == "mac"', {
- 'sources!': [
- '../include/images/SkJpegUtility.h',
-
- '../src/images/SkImageDecoder_libgif.cpp',
- '../src/images/SkImageDecoder_libjpeg.cpp',
- '../src/images/SkImageDecoder_libpng.cpp',
- '../src/images/SkImageDecoder_libpvjpeg.c',
- '../src/images/SkJpegUtility.cpp',
- '../src/images/SkMovie_gif.cpp',
- ],
- }],
- [ 'OS == "linux" or OS == "freebsd" or OS == "openbsd" or OS == "solaris"', {
- 'sources!': [
- '../include/images/SkJpegUtility.h',
-
- '../src/images/SkImageDecoder_libjpeg.cpp',
- '../src/images/SkImageDecoder_libgif.cpp',
- '../src/images/SkImageDecoder_libpvjpeg.c',
- '../src/images/SkJpegUtility.cpp',
- '../src/images/SkMovie_gif.cpp',
- ],
- }],
-
- ],
- 'direct_dependent_settings': {
- 'include_dirs': [
- '../include/images',
- ],
- },
- },
- {
- 'target_name': 'xml',
- 'type': 'static_library',
- 'include_dirs': [
- '../include/config',
- '../include/core',
- '../include/xml',
- '../include/utils',
- ],
- 'sources': [
- '../include/xml/SkBML_WXMLParser.h',
- '../include/xml/SkBML_XMLParser.h',
- '../include/xml/SkDOM.h',
- '../include/xml/SkJS.h',
- '../include/xml/SkXMLParser.h',
- '../include/xml/SkXMLWriter.h',
-
- '../src/xml/SkBML_Verbs.h',
- '../src/xml/SkBML_XMLParser.cpp',
- '../src/xml/SkDOM.cpp',
- '../src/xml/SkJS.cpp',
- '../src/xml/SkJSDisplayable.cpp',
- '../src/xml/SkXMLParser.cpp',
- '../src/xml/SkXMLPullParser.cpp',
- '../src/xml/SkXMLWriter.cpp',
- ],
- 'sources!': [
- '../src/xml/SkXMLPullParser.cpp', #if 0 around class decl in header
- ],
- 'conditions': [
- [ 'OS == "win" or OS == "mac" or OS == "linux" or OS == "openbsd" or OS == "solaris"', {
- 'sources!': [
- # no jsapi.h by default on system
- '../include/xml/SkJS.h',
- '../src/xml/SkJS.cpp',
- '../src/xml/SkJSDisplayable.cpp',
- ],
- }],
- ],
- 'direct_dependent_settings': {
- 'include_dirs': [
- '../include/xml',
- ],
- },
- },
- {
- 'target_name': 'pdf',
- 'type': 'static_library',
- 'include_dirs': [
- '../include/config',
- '../include/core',
- '../include/pdf',
- '../src/core', # needed to get SkGlyphCache.h and SkTextFormatParams.h
- ],
- 'sources': [
- '../include/pdf/SkPDFCatalog.h',
- '../include/pdf/SkPDFDevice.h',
- '../include/pdf/SkPDFDocument.h',
- '../include/pdf/SkPDFFont.h',
- '../include/pdf/SkPDFFormXObject.h',
- '../include/pdf/SkPDFGraphicState.h',
- '../include/pdf/SkPDFImage.h',
- '../include/pdf/SkPDFPage.h',
- '../include/pdf/SkPDFShader.h',
- '../include/pdf/SkPDFStream.h',
- '../include/pdf/SkPDFTypes.h',
- '../include/pdf/SkPDFUtils.h',
-
- '../src/pdf/SkPDFCatalog.cpp',
- '../src/pdf/SkPDFDevice.cpp',
- '../src/pdf/SkPDFDocument.cpp',
- '../src/pdf/SkPDFFont.cpp',
- '../src/pdf/SkPDFFormXObject.cpp',
- '../src/pdf/SkPDFGraphicState.cpp',
- '../src/pdf/SkPDFImage.cpp',
- '../src/pdf/SkPDFPage.cpp',
- '../src/pdf/SkPDFShader.cpp',
- '../src/pdf/SkPDFStream.cpp',
- '../src/pdf/SkPDFTypes.cpp',
- '../src/pdf/SkPDFUtils.cpp',
- ],
- 'direct_dependent_settings': {
- 'include_dirs': [
- '../include/pdf',
- ],
- },
- },
- {
- 'target_name': 'utils',
- 'type': 'static_library',
- 'include_dirs': [
- '../include/config',
- '../include/core',
- '../include/utils',
- '../include/views',
- '../include/effects',
- '../include/xml',
- ],
- 'sources': [
- '../include/utils/SkBoundaryPatch.h',
- '../include/utils/SkCamera.h',
- '../include/utils/SkCubicInterval.h',
- '../include/utils/SkCullPoints.h',
- '../include/utils/SkDumpCanvas.h',
- '../include/utils/SkEGLContext.h',
- '../include/utils/SkGLCanvas.h',
- '../include/utils/SkInterpolator.h',
- '../include/utils/SkLayer.h',
- '../include/utils/SkMeshUtils.h',
- '../include/utils/SkNinePatch.h',
- '../include/utils/SkNWayCanvas.h',
- '../include/utils/SkParse.h',
- '../include/utils/SkParsePaint.h',
- '../include/utils/SkParsePath.h',
- '../include/utils/SkProxyCanvas.h',
- '../include/utils/SkSfntUtils.h',
- '../include/utils/SkTextBox.h',
- '../include/utils/SkUnitMappers.h',
-
- '../src/utils/SkBoundaryPatch.cpp',
- '../src/utils/SkCamera.cpp',
- '../src/utils/SkColorMatrix.cpp',
- '../src/utils/SkCubicInterval.cpp',
- '../src/utils/SkCullPoints.cpp',
- '../src/utils/SkDumpCanvas.cpp',
- '../src/utils/SkEGLContext_none.cpp',
- '../src/utils/SkInterpolator.cpp',
- '../src/utils/SkLayer.cpp',
- '../src/utils/SkMeshUtils.cpp',
- '../src/utils/SkNinePatch.cpp',
- '../src/utils/SkNWayCanvas.cpp',
- '../src/utils/SkOSFile.cpp',
- '../src/utils/SkParse.cpp',
- '../src/utils/SkParseColor.cpp',
- '../src/utils/SkParsePath.cpp',
- '../src/utils/SkProxyCanvas.cpp',
- '../src/utils/SkSfntUtils.cpp',
- '../src/utils/SkUnitMappers.cpp',
- ],
- 'conditions': [
- [ 'OS == "mac"', {
- 'sources': [
- '../include/utils/SkCGUtils.h',
- '../src/utils/mac/SkCreateCGImageRef.cpp',
- '../src/utils/mac/SkEGLContext_mac.cpp',
- ],
- }],
- ],
- 'direct_dependent_settings': {
- 'include_dirs': [
- '../include/utils',
- ],
- },
- },
- {
- 'target_name': 'views',
- 'type': 'static_library',
- 'include_dirs': [
- '../include/config',
- '../include/core',
- '../include/views',
- '../include/xml',
- '../include/utils',
- '../include/images',
- '../include/animator',
- '../include/effects',
- ],
- 'sources': [
- '../include/views/SkApplication.h',
- '../include/views/SkBGViewArtist.h',
- '../include/views/SkBorderView.h',
- '../include/views/SkEvent.h',
- '../include/views/SkEventSink.h',
- '../include/views/SkImageView.h',
- '../include/views/SkKey.h',
- '../include/views/SkOSMenu.h',
- '../include/views/SkOSWindow_Mac.h',
- '../include/views/SkOSWindow_SDL.h',
- '../include/views/SkOSWindow_Unix.h',
- '../include/views/SkOSWindow_Win.h',
- #'../include/views/SkOSWindow_wxwidgets.h',
- '../include/views/SkProgressBarView.h',
- '../include/views/SkScrollBarView.h',
- '../include/views/SkStackViewLayout.h',
- '../include/views/SkSystemEventTypes.h',
- '../include/views/SkTouchGesture.h',
- '../include/views/SkView.h',
- '../include/views/SkViewInflate.h',
- '../include/views/SkWidget.h',
- '../include/views/SkWidgetViews.h',
- '../include/views/SkWindow.h',
-
- '../src/views/SkBGViewArtist.cpp',
- '../src/views/SkBorderView.cpp',
- '../src/views/SkEvent.cpp',
- '../src/views/SkEventSink.cpp',
- '../src/views/SkImageView.cpp',
- '../src/views/SkListView.cpp',
- '../src/views/SkListWidget.cpp',
- '../src/views/SkOSMenu.cpp',
- '../src/views/SkParsePaint.cpp',
- '../src/views/SkProgressBarView.cpp',
- '../src/views/SkProgressView.cpp',
- '../src/views/SkScrollBarView.cpp',
- '../src/views/SkStackViewLayout.cpp',
- '../src/views/SkStaticTextView.cpp',
- '../src/views/SkTagList.cpp',
- '../src/views/SkTagList.h',
- '../src/views/SkTextBox.cpp',
- '../src/views/SkTouchGesture.cpp',
- '../src/views/SkView.cpp',
- '../src/views/SkViewInflate.cpp',
- '../src/views/SkViewPriv.cpp',
- '../src/views/SkViewPriv.h',
- '../src/views/SkWidget.cpp',
- '../src/views/SkWidgets.cpp',
- '../src/views/SkWidgetViews.cpp',
- '../src/views/SkWindow.cpp',
- ],
- 'sources!' : [
- '../src/views/SkListView.cpp', #depends on missing SkListSource implementation
- '../src/views/SkListWidget.cpp', #depends on missing SkListSource implementation
- ],
- 'conditions': [
- [ 'OS == "win"', {
- 'sources': [
- '../src/utils/win/SkOSWindow_Win.cpp',
- '../src/utils/win/skia_win.cpp',
- ],
- }],
- [ 'OS == "mac"', {
- 'sources': [
- '../include/utils/SkCGUtils.h',
- #'../src/utils/mac/SkBitmap_Mac.cpp',
- '../src/utils/mac/SkCreateCGImageRef.cpp',
- '../src/utils/mac/SkEGLContext_mac.cpp',
- '../src/utils/mac/skia_mac.cpp',
- '../src/utils/mac/SkOSWindow_Mac.cpp',
- ],
- 'link_settings': {
- 'libraries': [
- '$(SDKROOT)/System/Library/Frameworks/Carbon.framework',
- '$(SDKROOT)/System/Library/Frameworks/AGL.framework',
- ],
- },
- }],
- [ 'OS == "linux" or OS == "freebsd" or OS == "openbsd" or OS == "solaris"', {
- 'include_dirs' : [
- '../include/utils/unix',
- ],
- 'sources': [
- '../src/utils/unix/keysym2ucs.c',
- '../src/utils/unix/SkOSWindow_Unix.cpp',
- '../unix_test_app/main.cpp',
- ],
- }],
- ],
- 'direct_dependent_settings': {
- 'include_dirs': [
- '../include/views',
- ],
- },
- },
- {
- 'target_name': 'skgr',
- 'type': 'static_library',
- 'include_dirs': [
- '../include/config',
- '../include/core',
- '../src/core',
- '../include/gpu',
- '../gpu/include',
- ],
- 'sources': [
- '../include/gpu/SkGpuCanvas.h',
- '../include/gpu/SkGpuDevice.h',
- '../include/gpu/SkGpuDeviceFactory.h',
- '../include/gpu/SkGr.h',
- '../include/gpu/SkGrTexturePixelRef.h',
-
- '../src/gpu/GrPrintf_skia.cpp',
- '../src/gpu/SkGpuCanvas.cpp',
- '../src/gpu/SkGpuDevice.cpp',
- '../src/gpu/SkGr.cpp',
- '../src/gpu/SkGrFontScaler.cpp',
- '../src/gpu/SkGrTexturePixelRef.cpp',
- ],
- 'conditions': [
- [ 'OS == "linux"', {
- 'defines': [
- 'GR_LINUX_BUILD=1',
- ],
- }],
- [ 'OS == "mac"', {
- 'defines': [
- 'GR_MAC_BUILD=1',
- ],
- }],
- [ 'OS == "win"', {
- 'defines': [
- 'GR_WIN32_BUILD=1',
- ],
- }],
- ],
- 'direct_dependent_settings': {
- 'conditions': [
- [ 'OS == "linux"', {
- 'defines': [
- 'GR_LINUX_BUILD=1',
- ],
- }],
- [ 'OS == "mac"', {
- 'defines': [
- 'GR_MAC_BUILD=1',
- ],
- }],
- [ 'OS == "win"', {
- 'defines': [
- 'GR_WIN32_BUILD=1',
- ],
- }],
- ],
- 'include_dirs': [
- '../include/gpu',
- ],
- },
- },
- {
- 'target_name': 'gr',
- 'type': 'static_library',
- 'include_dirs': [
- '../gpu/include',
- '../include/core',
- '../include/config',
- ],
- 'dependencies': [
- 'libtess',
- ],
- 'sources': [
- '../gpu/include/GrAllocator.h',
- '../gpu/include/GrAllocPool.h',
- '../gpu/include/GrAtlas.h',
- '../gpu/include/GrClip.h',
- '../gpu/include/GrClipIterator.h',
- '../gpu/include/GrColor.h',
- '../gpu/include/GrConfig.h',
- '../gpu/include/GrContext.h',
- '../gpu/include/GrContext_impl.h',
- '../gpu/include/GrDrawTarget.h',
- '../gpu/include/GrFontScaler.h',
- '../gpu/include/GrGeometryBuffer.h',
- '../gpu/include/GrGLConfig.h',
- '../gpu/include/GrGLConfig_chrome.h',
- '../gpu/include/GrGLIndexBuffer.h',
- '../gpu/include/GrGLInterface.h',
- '../gpu/include/GrGLIRect.h',
- '../gpu/include/GrGLTexture.h',
- '../gpu/include/GrGLVertexBuffer.h',
- '../gpu/include/GrGlyph.h',
- '../gpu/include/GrGpu.h',
- '../gpu/include/GrGpuVertex.h',
- '../gpu/include/GrIndexBuffer.h',
- '../gpu/include/GrInOrderDrawBuffer.h',
- '../gpu/include/GrInstanceCounter.h',
- '../gpu/include/GrIPoint.h',
- '../gpu/include/GrKey.h',
- '../gpu/include/GrMatrix.h',
- '../gpu/include/GrMemory.h',
- '../gpu/include/GrMesh.h',
- '../gpu/include/GrNoncopyable.h',
- '../gpu/include/GrPaint.h',
- '../gpu/include/GrPath.h',
- '../gpu/include/GrPathIter.h',
- '../gpu/include/GrPathRenderer.h',
- '../gpu/include/GrPathSink.h',
- '../gpu/include/GrPlotMgr.h',
- '../gpu/include/GrPoint.h',
- '../gpu/include/GrRandom.h',
- '../gpu/include/GrRect.h',
- '../gpu/include/GrRectanizer.h',
- '../gpu/include/GrRefCnt.h',
- '../gpu/include/GrResource.h',
- '../gpu/include/GrSamplerState.h',
- '../gpu/include/GrScalar.h',
- '../gpu/include/GrStencil.h',
- '../gpu/include/GrStopwatch.h',
- '../gpu/include/GrStringBuilder.h',
- '../gpu/include/GrTArray.h',
- '../gpu/include/GrTBSearch.h',
- '../gpu/include/GrTDArray.h',
- '../gpu/include/GrTesselatedPathRenderer.h',
- '../gpu/include/GrTextContext.h',
- '../gpu/include/GrTextStrike.h',
- '../gpu/include/GrTexture.h',
- '../gpu/include/GrTextureCache.h',
- '../gpu/include/GrTHashCache.h',
- '../gpu/include/GrTLList.h',
- '../gpu/include/GrTouchGesture.h',
- '../gpu/include/GrTypes.h',
- '../gpu/include/GrUserConfig.h',
- '../gpu/include/GrVertexBuffer.h',
-
- '../gpu/src/GrAllocPool.cpp',
- '../gpu/src/GrAtlas.cpp',
- '../gpu/src/GrBinHashKey.h',
- '../gpu/src/GrBufferAllocPool.cpp',
- '../gpu/src/GrBufferAllocPool.h',
- '../gpu/src/GrClip.cpp',
- '../gpu/src/GrContext.cpp',
- '../gpu/src/GrCreatePathRenderer_none.cpp',
- '../gpu/src/GrDrawTarget.cpp',
- '../gpu/src/GrGLEffect.h',
- '../gpu/src/GrGLDefaultInterface_none.cpp',
- '../gpu/src/GrGLIndexBuffer.cpp',
- '../gpu/src/GrGLInterface.cpp',
- '../gpu/src/GrGLProgram.cpp',
- '../gpu/src/GrGLProgram.h',
- '../gpu/src/GrGLTexture.cpp',
- '../gpu/src/GrGLUtil.cpp',
- '../gpu/src/GrGLVertexBuffer.cpp',
- '../gpu/src/GrGpu.cpp',
- '../gpu/src/GrGpuFactory.cpp',
- '../gpu/src/GrGpuGL.cpp',
- '../gpu/src/GrGpuGL.h',
- '../gpu/src/GrGpuGLFixed.cpp',
- '../gpu/src/GrGpuGLFixed.h',
- '../gpu/src/GrGpuGLShaders.cpp',
- '../gpu/src/GrGpuGLShaders.h',
- '../gpu/src/GrInOrderDrawBuffer.cpp',
- '../gpu/src/GrMatrix.cpp',
- '../gpu/src/GrMemory.cpp',
- '../gpu/src/GrPath.cpp',
- '../gpu/src/GrPathRenderer.cpp',
- '../gpu/src/GrPathUtils.cpp',
- '../gpu/src/GrPathUtils.h',
- '../gpu/src/GrRectanizer.cpp',
- '../gpu/src/GrRedBlackTree.h',
- '../gpu/src/GrResource.cpp',
- '../gpu/src/GrStencil.cpp',
- '../gpu/src/GrTesselatedPathRenderer.cpp',
- '../gpu/src/GrTextContext.cpp',
- '../gpu/src/GrTextStrike.cpp',
- '../gpu/src/GrTextStrike_impl.h',
- '../gpu/src/GrTexture.cpp',
- '../gpu/src/GrTextureCache.cpp',
- '../gpu/src/gr_unittests.cpp',
-
- '../gpu/src/mac/GrGLDefaultInterface_mac.cpp',
-
- '../gpu/src/win/GrGLDefaultInterface_win.cpp',
-
- '../gpu/src/unix/GrGLDefaultInterface_unix.cpp',
- ],
- 'defines': [
- 'GR_IMPLEMENTATION=1',
- ],
- 'conditions': [
- [ 'OS == "linux"', {
- 'defines': [
- 'GR_LINUX_BUILD=1',
- ],
- 'sources!': [
- '../gpu/src/GrGLDefaultInterface_none.cpp',
- ],
- 'link_settings': {
- 'libraries': [
- '-lGL',
- '-lX11',
- ],
- },
- }],
- [ 'OS == "mac"', {
- 'defines': [
- 'GR_MAC_BUILD=1',
- ],
- 'link_settings': {
- 'libraries': [
- '$(SDKROOT)/System/Library/Frameworks/OpenGL.framework',
- ],
- },
- 'sources!': [
- '../gpu/src/GrGLDefaultInterface_none.cpp',
- ],
- }],
- [ 'OS == "win"', {
- 'defines': [
- 'GR_WIN32_BUILD=1',
- 'GR_GL_FUNCTION_TYPE=__stdcall',
- ],
- 'sources!': [
- '../gpu/src/GrGLDefaultInterface_none.cpp',
- ],
- }],
- [ 'OS != "win"', {
- 'sources!': [
- '../gpu/src/win/GrGLDefaultInterface_win.cpp',
- ],
- }],
- [ 'OS != "mac"', {
- 'sources!': [
- '../gpu/src/mac/GrGLDefaultInterface_mac.cpp',
- ],
- }],
- [ 'OS != "linux"', {
- 'sources!': [
- '../gpu/src/unix/GrGLDefaultInterface_unix.cpp',
- ],
- }],
- ],
- 'direct_dependent_settings': {
- 'conditions': [
- [ 'OS == "linux"', {
- 'defines': [
- 'GR_LINUX_BUILD=1',
- ],
- }],
- [ 'OS == "mac"', {
- 'defines': [
- 'GR_MAC_BUILD=1',
- ],
- }],
- [ 'OS == "win"', {
- 'defines': [
- 'GR_WIN32_BUILD=1',
- 'GR_GL_FUNCTION_TYPE=__stdcall',
- ],
- }],
- ],
- 'include_dirs': [
- '../gpu/include',
- ],
- },
- },
- {
- 'target_name': 'animator',
- 'type': 'static_library',
- 'include_dirs': [
- '../include/config',
- '../include/core',
- '../include/effects',
- '../include/animator',
- '../include/views',
- '../include/xml',
- '../include/utils',
- '../include/images',
- ],
- 'sources': [
- '../include/animator/SkAnimator.h',
- '../include/animator/SkAnimatorView.h',
-
- '../src/animator/SkAnimate.h',
- '../src/animator/SkAnimateActive.cpp',
- '../src/animator/SkAnimateActive.h',
- '../src/animator/SkAnimateBase.cpp',
- '../src/animator/SkAnimateBase.h',
- '../src/animator/SkAnimateField.cpp',
- '../src/animator/SkAnimateMaker.cpp',
- '../src/animator/SkAnimateMaker.h',
- '../src/animator/SkAnimateProperties.h',
- '../src/animator/SkAnimateSet.cpp',
- '../src/animator/SkAnimateSet.h',
- '../src/animator/SkAnimator.cpp',
- '../src/animator/SkAnimatorScript.cpp',
- '../src/animator/SkAnimatorScript.h',
- #'../src/animator/SkAnimatorScript2.cpp', fails on windows
- #'../src/animator/SkAnimatorScript2.h',
- '../src/animator/SkBase64.cpp',
- '../src/animator/SkBase64.h',
- '../src/animator/SkBoundable.cpp',
- '../src/animator/SkBoundable.h',
- '../src/animator/SkBuildCondensedInfo.cpp',
- #'../src/animator/SkCondensedDebug.cpp', fails on windows
- #'../src/animator/SkCondensedRelease.cpp',
- '../src/animator/SkDisplayable.cpp',
- '../src/animator/SkDisplayable.h',
- '../src/animator/SkDisplayAdd.cpp',
- '../src/animator/SkDisplayAdd.h',
- '../src/animator/SkDisplayApply.cpp',
- '../src/animator/SkDisplayApply.h',
- '../src/animator/SkDisplayBounds.cpp',
- '../src/animator/SkDisplayBounds.h',
- '../src/animator/SkDisplayEvent.cpp',
- '../src/animator/SkDisplayEvent.h',
- '../src/animator/SkDisplayEvents.cpp',
- '../src/animator/SkDisplayEvents.h',
- '../src/animator/SkDisplayInclude.cpp',
- '../src/animator/SkDisplayInclude.h',
- '../src/animator/SkDisplayInput.cpp',
- '../src/animator/SkDisplayInput.h',
- '../src/animator/SkDisplayList.cpp',
- '../src/animator/SkDisplayList.h',
- '../src/animator/SkDisplayMath.cpp',
- '../src/animator/SkDisplayMath.h',
- '../src/animator/SkDisplayMovie.cpp',
- '../src/animator/SkDisplayMovie.h',
- '../src/animator/SkDisplayNumber.cpp',
- '../src/animator/SkDisplayNumber.h',
- '../src/animator/SkDisplayPost.cpp',
- '../src/animator/SkDisplayPost.h',
- '../src/animator/SkDisplayRandom.cpp',
- '../src/animator/SkDisplayRandom.h',
- '../src/animator/SkDisplayScreenplay.cpp',
- '../src/animator/SkDisplayScreenplay.h',
- '../src/animator/SkDisplayType.cpp',
- '../src/animator/SkDisplayType.h',
- '../src/animator/SkDisplayTypes.cpp',
- '../src/animator/SkDisplayTypes.h',
- '../src/animator/SkDisplayXMLParser.cpp',
- '../src/animator/SkDisplayXMLParser.h',
- '../src/animator/SkDraw3D.cpp',
- '../src/animator/SkDraw3D.h',
- '../src/animator/SkDrawable.cpp',
- '../src/animator/SkDrawable.h',
- '../src/animator/SkDrawBitmap.cpp',
- '../src/animator/SkDrawBitmap.h',
- '../src/animator/SkDrawBlur.cpp',
- '../src/animator/SkDrawBlur.h',
- '../src/animator/SkDrawClip.cpp',
- '../src/animator/SkDrawClip.h',
- '../src/animator/SkDrawColor.cpp',
- '../src/animator/SkDrawColor.h',
- '../src/animator/SkDrawDash.cpp',
- '../src/animator/SkDrawDash.h',
- '../src/animator/SkDrawDiscrete.cpp',
- '../src/animator/SkDrawDiscrete.h',
- '../src/animator/SkDrawEmboss.cpp',
- '../src/animator/SkDrawEmboss.h',
- '../src/animator/SkDrawExtraPathEffect.cpp',
- '../src/animator/SkDrawFull.cpp',
- '../src/animator/SkDrawFull.h',
- '../src/animator/SkDrawGradient.cpp',
- '../src/animator/SkDrawGradient.h',
- '../src/animator/SkDrawGroup.cpp',
- '../src/animator/SkDrawGroup.h',
- '../src/animator/SkDrawLine.cpp',
- '../src/animator/SkDrawLine.h',
- '../src/animator/SkDrawMatrix.cpp',
- '../src/animator/SkDrawMatrix.h',
- '../src/animator/SkDrawOval.cpp',
- '../src/animator/SkDrawOval.h',
- '../src/animator/SkDrawPaint.cpp',
- '../src/animator/SkDrawPaint.h',
- '../src/animator/SkDrawPath.cpp',
- '../src/animator/SkDrawPath.h',
- '../src/animator/SkDrawPoint.cpp',
- '../src/animator/SkDrawPoint.h',
- '../src/animator/SkDrawRectangle.cpp',
- '../src/animator/SkDrawRectangle.h',
- '../src/animator/SkDrawSaveLayer.cpp',
- '../src/animator/SkDrawSaveLayer.h',
- '../src/animator/SkDrawShader.cpp',
- '../src/animator/SkDrawShader.h',
- '../src/animator/SkDrawText.cpp',
- '../src/animator/SkDrawText.h',
- '../src/animator/SkDrawTextBox.cpp',
- '../src/animator/SkDrawTextBox.h',
- '../src/animator/SkDrawTo.cpp',
- '../src/animator/SkDrawTo.h',
- '../src/animator/SkDrawTransparentShader.cpp',
- '../src/animator/SkDrawTransparentShader.h',
- '../src/animator/SkDump.cpp',
- '../src/animator/SkDump.h',
- '../src/animator/SkExtras.h',
- '../src/animator/SkGetCondensedInfo.cpp',
- '../src/animator/SkHitClear.cpp',
- '../src/animator/SkHitClear.h',
- '../src/animator/SkHitTest.cpp',
- '../src/animator/SkHitTest.h',
- '../src/animator/SkIntArray.h',
- '../src/animator/SkMatrixParts.cpp',
- '../src/animator/SkMatrixParts.h',
- '../src/animator/SkMemberInfo.cpp',
- '../src/animator/SkMemberInfo.h',
- '../src/animator/SkOpArray.cpp',
- '../src/animator/SkOpArray.h',
- '../src/animator/SkOperand.h',
- '../src/animator/SkOperand2.h',
- '../src/animator/SkOperandInterpolator.h',
- '../src/animator/SkOperandIterpolator.cpp',
- '../src/animator/SkPaintParts.cpp',
- '../src/animator/SkPaintParts.h',
- '../src/animator/SkParseSVGPath.cpp',
- '../src/animator/SkPathParts.cpp',
- '../src/animator/SkPathParts.h',
- '../src/animator/SkPostParts.cpp',
- '../src/animator/SkPostParts.h',
- '../src/animator/SkScript.cpp',
- '../src/animator/SkScript.h',
- '../src/animator/SkScript2.h',
- '../src/animator/SkScriptCallBack.h',
- '../src/animator/SkScriptDecompile.cpp',
- '../src/animator/SkScriptRuntime.cpp',
- '../src/animator/SkScriptRuntime.h',
- '../src/animator/SkScriptTokenizer.cpp',
- '../src/animator/SkSnapshot.cpp',
- '../src/animator/SkSnapshot.h',
- '../src/animator/SkTDArray_Experimental.h',
- '../src/animator/SkTextOnPath.cpp',
- '../src/animator/SkTextOnPath.h',
- '../src/animator/SkTextToPath.cpp',
- '../src/animator/SkTextToPath.h',
- '../src/animator/SkTime.cpp',
- '../src/animator/SkTypedArray.cpp',
- '../src/animator/SkTypedArray.h',
- '../src/animator/SkXMLAnimatorWriter.cpp',
- '../src/animator/SkXMLAnimatorWriter.h',
- ],
- 'direct_dependent_settings': {
- 'include_dirs': [
- '../include/animator',
- ],
- },
- },
-
- {
- 'target_name': 'svg',
- 'type': 'static_library',
- 'include_dirs': [
- '../include/config',
- '../include/core',
- '../include/xml',
- '../include/utils',
- '../include/svg',
- ],
- 'sources': [
- '../include/svg/SkSVGAttribute.h',
- '../include/svg/SkSVGBase.h',
- '../include/svg/SkSVGPaintState.h',
- '../include/svg/SkSVGParser.h',
- '../include/svg/SkSVGTypes.h',
-
- '../src/svg/SkSVGCircle.cpp',
- '../src/svg/SkSVGCircle.h',
- '../src/svg/SkSVGClipPath.cpp',
- '../src/svg/SkSVGClipPath.h',
- '../src/svg/SkSVGDefs.cpp',
- '../src/svg/SkSVGDefs.h',
- '../src/svg/SkSVGElements.cpp',
- '../src/svg/SkSVGElements.h',
- '../src/svg/SkSVGEllipse.cpp',
- '../src/svg/SkSVGEllipse.h',
- '../src/svg/SkSVGFeColorMatrix.cpp',
- '../src/svg/SkSVGFeColorMatrix.h',
- '../src/svg/SkSVGFilter.cpp',
- '../src/svg/SkSVGFilter.h',
- '../src/svg/SkSVGG.cpp',
- '../src/svg/SkSVGG.h',
- '../src/svg/SkSVGGradient.cpp',
- '../src/svg/SkSVGGradient.h',
- '../src/svg/SkSVGGroup.cpp',
- '../src/svg/SkSVGGroup.h',
- '../src/svg/SkSVGImage.cpp',
- '../src/svg/SkSVGImage.h',
- '../src/svg/SkSVGLine.cpp',
- '../src/svg/SkSVGLine.h',
- '../src/svg/SkSVGLinearGradient.cpp',
- '../src/svg/SkSVGLinearGradient.h',
- '../src/svg/SkSVGMask.cpp',
- '../src/svg/SkSVGMask.h',
- '../src/svg/SkSVGMetadata.cpp',
- '../src/svg/SkSVGMetadata.h',
- '../src/svg/SkSVGPaintState.cpp',
- '../src/svg/SkSVGParser.cpp',
- '../src/svg/SkSVGPath.cpp',
- '../src/svg/SkSVGPath.h',
- '../src/svg/SkSVGPolygon.cpp',
- '../src/svg/SkSVGPolygon.h',
- '../src/svg/SkSVGPolyline.cpp',
- '../src/svg/SkSVGPolyline.h',
- '../src/svg/SkSVGRadialGradient.cpp',
- '../src/svg/SkSVGRadialGradient.h',
- '../src/svg/SkSVGRect.cpp',
- '../src/svg/SkSVGRect.h',
- '../src/svg/SkSVGStop.cpp',
- '../src/svg/SkSVGStop.h',
- '../src/svg/SkSVGSVG.cpp',
- '../src/svg/SkSVGSVG.h',
- '../src/svg/SkSVGSymbol.cpp',
- '../src/svg/SkSVGSymbol.h',
- '../src/svg/SkSVGText.cpp',
- '../src/svg/SkSVGText.h',
- '../src/svg/SkSVGUse.cpp',
- ],
- 'sources!' : [
- '../src/svg/SkSVG.cpp', # doesn't compile, maybe this is test code?
- ],
- 'direct_dependent_settings': {
- 'include_dirs': [
- '../include/svg',
- ],
- },
- },
-
- {
- 'target_name': 'experimental',
- 'type': 'static_library',
- 'include_dirs': [
- '../include/config',
- '../include/core',
- ],
- 'sources': [
- '../experimental/SkMatrix44.cpp',
- '../experimental/SkMatrix44.h',
- '../experimental/SkSetPoly3To3.cpp',
- '../experimental/SkSetPoly3To3_A.cpp',
- '../experimental/SkSetPoly3To3_D.cpp',
- ],
- 'sources!': [
- '../experimental/SkMatrix44.cpp', #doesn't compile
- '../experimental/SkMatrix44.h',
- ],
- 'direct_dependent_settings': {
- 'include_dirs': [
- '../experimental',
- ],
- },
- },
-
- {
- 'target_name': 'SampleApp',
- 'type': 'executable',
- 'mac_bundle' : 1,
- 'include_dirs' : [
- '../src/core', # needed to get SkConcaveToTriangle, maybe this should be moved to include dir?
- '../gm', # SampleGM.cpp pulls gm.h
- ],
- 'sources': [
- # gm files needed for SampleGM.cpp
- '../gm/bitmapfilters.cpp',
- '../gm/blurs.cpp',
- '../gm/complexclip.cpp',
- '../gm/filltypes.cpp',
- '../gm/gm.h',
- '../gm/gradients.cpp',
- '../gm/points.cpp',
- '../gm/poly2poly.cpp',
- '../gm/shadertext.cpp',
- '../gm/shadows.cpp',
- '../gm/shapes.cpp',
- '../gm/tilemodes.cpp',
- '../gm/xfermodes.cpp',
-
- '../samplecode/ClockFaceView.cpp',
- '../samplecode/OverView.cpp',
- '../samplecode/SampleAll.cpp',
- '../samplecode/SampleAnimator.cpp',
- '../samplecode/SampleApp.cpp',
- '../samplecode/SampleArc.cpp',
- '../samplecode/SampleAvoid.cpp',
- '../samplecode/SampleBigGradient.cpp',
- '../samplecode/SampleBitmapRect.cpp',
- '../samplecode/SampleBlur.cpp',
- '../samplecode/SampleCamera.cpp',
- '../samplecode/SampleCircle.cpp',
- '../samplecode/SampleCode.h',
- '../samplecode/SampleColorFilter.cpp',
- '../samplecode/SampleComplexClip.cpp',
- '../samplecode/SampleCull.cpp',
- '../samplecode/SampleDecode.cpp',
- '../samplecode/SampleDither.cpp',
- '../samplecode/SampleDitherBitmap.cpp',
- '../samplecode/SampleDrawLooper.cpp',
- '../samplecode/SampleEffects.cpp',
- '../samplecode/SampleEmboss.cpp',
- '../samplecode/SampleEncode.cpp',
- '../samplecode/SampleExtractAlpha.cpp',
- '../samplecode/SampleFillType.cpp',
- '../samplecode/SampleFilter.cpp',
- '../samplecode/SampleFilter2.cpp',
- '../samplecode/SampleFontCache.cpp',
- '../samplecode/SampleFontScalerTest.cpp',
- '../samplecode/SampleFuzz.cpp',
- '../samplecode/SampleGM.cpp',
- '../samplecode/SampleGradients.cpp',
- '../samplecode/SampleHairline.cpp',
- '../samplecode/SampleImage.cpp',
- '../samplecode/SampleImageDir.cpp',
- '../samplecode/SampleLayerMask.cpp',
- '../samplecode/SampleLayers.cpp',
- '../samplecode/SampleLCD.cpp',
- '../samplecode/SampleLineClipper.cpp',
- '../samplecode/SampleLines.cpp',
- '../samplecode/SampleMeasure.cpp',
- '../samplecode/SampleMipMap.cpp',
- '../samplecode/SampleMovie.cpp',
- '../samplecode/SampleNinePatch.cpp',
- '../samplecode/SampleOvalTest.cpp',
- '../samplecode/SampleOverflow.cpp',
- '../samplecode/SamplePageFlip.cpp',
- '../samplecode/SamplePatch.cpp',
- '../samplecode/SamplePath.cpp',
- '../samplecode/SamplePathClip.cpp',
- '../samplecode/SamplePathEffects.cpp',
- '../samplecode/SamplePicture.cpp',
- '../samplecode/SamplePoints.cpp',
- '../samplecode/SamplePolyToPoly.cpp',
- '../samplecode/SampleAARects.cpp',
- '../samplecode/SampleRegion.cpp',
- '../samplecode/SampleRepeatTile.cpp',
- '../samplecode/SampleShaders.cpp',
- '../samplecode/SampleShaderText.cpp',
- '../samplecode/SampleShapes.cpp',
- '../samplecode/SampleSkLayer.cpp',
- '../samplecode/SampleSlides.cpp',
- '../samplecode/SampleStrokePath.cpp',
- '../samplecode/SampleStrokeText.cpp',
- '../samplecode/SampleSVG.cpp',
- '../samplecode/SampleTests.cpp',
- '../samplecode/SampleText.cpp',
- '../samplecode/SampleTextAlpha.cpp',
- '../samplecode/SampleTextBox.cpp',
- '../samplecode/SampleTextEffects.cpp',
- '../samplecode/SampleTextOnPath.cpp',
- '../samplecode/SampleTiling.cpp',
- '../samplecode/SampleTinyBitmap.cpp',
- '../samplecode/SampleTriangles.cpp',
- '../samplecode/SampleTypeface.cpp',
- '../samplecode/SampleUnitMapper.cpp',
- '../samplecode/SampleVertices.cpp',
- '../samplecode/SampleXfermodes.cpp',
- ],
- 'sources!': [
- '../samplecode/SampleSkLayer.cpp', #relies on SkMatrix44 which doesn't compile
- '../samplecode/SampleTests.cpp', #includes unknown file SkShaderExtras.h
- '../samplecode/SampleWarp.cpp',
- '../samplecode/SampleFontCache.cpp',
- ],
- 'dependencies': [
- 'skia',
- 'effects',
- 'images',
- 'views',
- 'utils',
- 'animator',
- 'xml',
- 'svg',
- 'experimental',
- 'gr',
- 'skgr',
- ],
- 'conditions' : [
- [ 'OS == "linux" or OS == "freebsd" or OS == "openbsd" or OS == "solaris"', {
- 'sources!': [
- '../samplecode/SampleDecode.cpp',
- ],
- }],
- [ 'OS == "win"', {
- 'sources!': [
- # require UNIX functions
- '../samplecode/SampleEncode.cpp',
- '../samplecode/SamplePageFlip.cpp',
- ],
- }],
- [ 'OS == "mac"', {
- 'sources!': [
- '../samplecode/SampleDecode.cpp',
- ],
- }],
-
- ],
- 'msvs_settings': {
- 'VCLinkerTool': {
- 'SubSystem': '2',
- 'AdditionalDependencies': [
- 'OpenGL32.lib',
- 'usp10.lib',
- 'd3d9.lib',
- ],
- },
- },
- },
- {
- 'target_name': 'libtess',
- 'type': 'static_library',
- 'include_dirs': [
- '../third_party/glu',
- ],
- 'sources': [
- '../third_party/glu/internal_glu.h',
- '../third_party/glu/gluos.h',
- '../third_party/glu/libtess/dict-list.h',
- '../third_party/glu/libtess/dict.c',
- '../third_party/glu/libtess/dict.h',
- '../third_party/glu/libtess/geom.c',
- '../third_party/glu/libtess/geom.h',
- '../third_party/glu/libtess/memalloc.c',
- '../third_party/glu/libtess/memalloc.h',
- '../third_party/glu/libtess/mesh.c',
- '../third_party/glu/libtess/mesh.h',
- '../third_party/glu/libtess/normal.c',
- '../third_party/glu/libtess/normal.h',
- '../third_party/glu/libtess/priorityq-heap.h',
- '../third_party/glu/libtess/priorityq-sort.h',
- '../third_party/glu/libtess/priorityq.c',
- '../third_party/glu/libtess/priorityq.h',
- '../third_party/glu/libtess/render.c',
- '../third_party/glu/libtess/render.h',
- '../third_party/glu/libtess/sweep.c',
- '../third_party/glu/libtess/sweep.h',
- '../third_party/glu/libtess/tess.c',
- '../third_party/glu/libtess/tess.h',
- '../third_party/glu/libtess/tessmono.c',
- '../third_party/glu/libtess/tessmono.h',
- ],
- 'direct_dependent_settings': {
- 'include_dirs': [
- '../third_party/glu',
- ],
- },
- },
- ],
-}
-
-# Local Variables:
-# tab-width:2
-# indent-tabs-mode:nil
-# End:
-# vim: set expandtab tabstop=2 shiftwidth=2:
diff --git a/include/config/SkUserConfig.h b/include/config/SkUserConfig.h
index aa2e6cf..c56d8cf 100644
--- a/include/config/SkUserConfig.h
+++ b/include/config/SkUserConfig.h
@@ -54,7 +54,7 @@
/* Somewhat independent of how SkScalar is implemented, Skia also wants to know
if it can use floats at all. Naturally, if SK_SCALAR_IS_FLOAT is defined,
- then so muse SK_CAN_USE_FLOAT, but if scalars are fixed, SK_CAN_USE_FLOAT
+ SK_CAN_USE_FLOAT must be too; but if scalars are fixed, SK_CAN_USE_FLOAT
can go either way.
*/
//#define SK_CAN_USE_FLOAT
@@ -151,4 +151,3 @@
#endif
#endif
-
diff --git a/include/core/SkClipStack.h b/include/core/SkClipStack.h
index ae0b974..6e8da76 100644
--- a/include/core/SkClipStack.h
+++ b/include/core/SkClipStack.h
@@ -43,6 +43,7 @@
struct Clip {
friend bool operator==(const Clip& a, const Clip& b);
+ friend bool operator!=(const Clip& a, const Clip& b);
const SkRect* fRect; // if non-null, this is a rect clip
const SkPath* fPath; // if non-null, this is a path clip
SkRegion::Op fOp;
diff --git a/include/core/SkColorPriv.h b/include/core/SkColorPriv.h
index f9e02a2..6fa9df3 100644
--- a/include/core/SkColorPriv.h
+++ b/include/core/SkColorPriv.h
@@ -155,31 +155,13 @@
#define SkRGB16Add(a, b) ((a) + (b))
#endif
-/////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
#define SK_A32_BITS 8
#define SK_R32_BITS 8
#define SK_G32_BITS 8
#define SK_B32_BITS 8
-/* we check to see if the SHIFT value has already been defined (SkUserConfig.h)
- if not, we define it ourself to some default values. We default to OpenGL
- order (in memory: r,g,b,a)
-*/
-#ifndef SK_A32_SHIFT
- #ifdef SK_CPU_BENDIAN
- #define SK_R32_SHIFT 24
- #define SK_G32_SHIFT 16
- #define SK_B32_SHIFT 8
- #define SK_A32_SHIFT 0
- #else
- #define SK_R32_SHIFT 0
- #define SK_G32_SHIFT 8
- #define SK_B32_SHIFT 16
- #define SK_A32_SHIFT 24
- #endif
-#endif
-
#define SK_A32_MASK ((1 << SK_A32_BITS) - 1)
#define SK_R32_MASK ((1 << SK_R32_BITS) - 1)
#define SK_G32_MASK ((1 << SK_G32_BITS) - 1)
diff --git a/include/core/SkComposeShader.h b/include/core/SkComposeShader.h
index 0b198f6..ea37549 100644
--- a/include/core/SkComposeShader.h
+++ b/include/core/SkComposeShader.h
@@ -27,7 +27,7 @@
This subclass of shader returns the coposition of two other shaders, combined by
a xfermode.
*/
-class SkComposeShader : public SkShader {
+class SK_API SkComposeShader : public SkShader {
public:
/** Create a new compose shader, given shaders A, B, and a combining xfermode mode.
When the xfermode is called, it will be given the result from shader A as its
diff --git a/include/core/SkDevice.h b/include/core/SkDevice.h
index 46bcf1a..d9a4fde 100644
--- a/include/core/SkDevice.h
+++ b/include/core/SkDevice.h
@@ -155,31 +155,6 @@
virtual void setMatrixClip(const SkMatrix&, const SkRegion&,
const SkClipStack&);
- /**
- * Observer interface for listening to the calls to
- * SkDevice::setMatrixClip(...). Users of SkDevice instances should
- * implement matrixClipChanged(...) to receive notifications.
- */
- class SkMatrixClipObserver : public SkRefCnt {
- public:
- virtual void matrixClipChanged(const SkMatrix&, const SkRegion&,
- const SkClipStack&) = 0;
- };
-
- /** Assign the clip observer. Note that an extra reference is added to the
- * observer, and removed at SkDevice construction, or re-assignment of a
- * different observer.
- */
- void setMatrixClipObserver(SkMatrixClipObserver* observer);
-
- /** Return the device's associated SkMatrixClipObserver, or NULL.
- * If non-null is returned, the reference count of the object is not
- * modified.
- */
- SkMatrixClipObserver* getMatrixClipObserver() const {
- return fMatrixClipObserver;
- }
-
/** Called when this device gains focus (i.e becomes the current device
for drawing).
*/
@@ -306,8 +281,6 @@
SkIPoint fOrigin;
SkMetaData* fMetaData;
- SkMatrixClipObserver* fMatrixClipObserver;
-
SkDeviceFactory* fCachedDeviceFactory;
};
diff --git a/include/core/SkMath.h b/include/core/SkMath.h
index 3e72904..efe378a 100644
--- a/include/core/SkMath.h
+++ b/include/core/SkMath.h
@@ -115,7 +115,7 @@
///////////////////////////////////////////////////////////////////////////////
-#if defined(__arm__) && !defined(__thumb__)
+#if defined(__arm__)
#define SkCLZ(x) __builtin_clz(x)
#endif
diff --git a/include/core/SkMatrix.h b/include/core/SkMatrix.h
index 7c77902..480e077 100644
--- a/include/core/SkMatrix.h
+++ b/include/core/SkMatrix.h
@@ -438,6 +438,7 @@
*/
bool fixedStepInX(SkScalar y, SkFixed* stepX, SkFixed* stepY) const;
+#ifdef SK_SCALAR_IS_FIXED
friend bool operator==(const SkMatrix& a, const SkMatrix& b) {
return memcmp(a.fMat, b.fMat, sizeof(a.fMat)) == 0;
}
@@ -445,6 +446,12 @@
friend bool operator!=(const SkMatrix& a, const SkMatrix& b) {
return memcmp(a.fMat, b.fMat, sizeof(a.fMat)) != 0;
}
+#else
+ friend bool operator==(const SkMatrix& a, const SkMatrix& b);
+ friend bool operator!=(const SkMatrix& a, const SkMatrix& b) {
+ return !(a == b);
+ }
+#endif
enum {
// flatten/unflatten will never return a value larger than this
@@ -488,7 +495,12 @@
kRectStaysRect_Mask = 0x10,
kUnknown_Mask = 0x80,
-
+
+ kORableMasks = kTranslate_Mask |
+ kScale_Mask |
+ kAffine_Mask |
+ kPerspective_Mask,
+
kAllMasks = kTranslate_Mask |
kScale_Mask |
kAffine_Mask |
@@ -506,7 +518,12 @@
SkASSERT(kUnknown_Mask == mask || (mask & kAllMasks) == mask);
fTypeMask = SkToU8(mask);
}
-
+
+ void orTypeMask(int mask) {
+ SkASSERT((mask & kORableMasks) == mask);
+ fTypeMask = SkToU8(fTypeMask | mask);
+ }
+
void clearTypeMask(int mask) {
// only allow a valid mask
SkASSERT((mask & kAllMasks) == mask);
diff --git a/include/core/SkPaint.h b/include/core/SkPaint.h
index f4b325f..f336f5b 100644
--- a/include/core/SkPaint.h
+++ b/include/core/SkPaint.h
@@ -817,6 +817,7 @@
#ifdef ANDROID
const SkGlyph& getUnicharMetrics(SkUnichar);
+ const SkGlyph& getGlyphMetrics(uint16_t);
const void* findImage(const SkGlyph&);
uint32_t getGenerationID() const;
diff --git a/include/core/SkPath.h b/include/core/SkPath.h
index 18dcd11..7120d3f 100644
--- a/include/core/SkPath.h
+++ b/include/core/SkPath.h
@@ -88,9 +88,10 @@
/** Returns true if the filltype is one of the Inverse variants */
bool isInverseFillType() const { return (fFillType & 2) != 0; }
- /** Toggle between inverse and normal filltypes. This reverse the return
- value of isInverseFillType()
- */
+ /**
+ * Toggle between inverse and normal filltypes. This reverse the return
+ * value of isInverseFillType()
+ */
void toggleInverseFillType() {
fFillType ^= 2;
GEN_ID_INC;
@@ -103,14 +104,33 @@
};
/**
- * Return the path's convexity, as stored in the path.
+ * Return the path's convexity, as stored in the path. If it is currently
+ * unknown, and the computeIfUnknown bool is true, then this will first
+ * call ComputeConvexity() and then return that (cached) value.
*/
- Convexity getConvexity() const { return (Convexity)fConvexity; }
+ Convexity getConvexity() const {
+ if (kUnknown_Convexity == fConvexity) {
+ fConvexity = (uint8_t)ComputeConvexity(*this);
+ }
+ return (Convexity)fConvexity;
+ }
+
+ /**
+ * Return the currently cached value for convexity, even if that is set to
+ * kUnknown_Convexity. Note: getConvexity() will automatically call
+ * ComputeConvexity and cache its return value if the current setting is
+ * kUnknown.
+ */
+ Convexity getConvexityOrUnknown() const { return (Convexity)fConvexity; }
/**
* Store a convexity setting in the path. There is no automatic check to
* see if this value actually agress with the return value from
* ComputeConvexity().
+ *
+ * Note: even if this is set to a "known" value, if the path is later
+ * changed (e.g. lineTo(), addRect(), etc.) then the cached value will be
+ * reset to kUnknown_Convexity.
*/
void setConvexity(Convexity);
@@ -118,9 +138,11 @@
* Compute the convexity of the specified path. This does not look at the
* value stored in the path, but computes it directly from the path's data.
*
+ * This never returns kUnknown_Convexity.
+ *
* If there is more than one contour, this returns kConcave_Convexity.
- * If the contour is degenerate (i.e. all segements are colinear,
- * then this returns kUnknown_Convexity.
+ * If the contour is degenerate (e.g. there are fewer than 3 non-degenerate
+ * segments), then this returns kConvex_Convexity.
* The contour is treated as if it were closed, even if there is no kClose
* verb.
*/
@@ -635,7 +657,7 @@
mutable SkRect fBounds;
mutable uint8_t fBoundsIsDirty;
uint8_t fFillType;
- uint8_t fConvexity;
+ mutable uint8_t fConvexity;
#ifdef ANDROID
uint32_t fGenerationID;
#endif
diff --git a/include/core/SkPostConfig.h b/include/core/SkPostConfig.h
index 57cc368..23ce02b 100644
--- a/include/core/SkPostConfig.h
+++ b/include/core/SkPostConfig.h
@@ -132,6 +132,25 @@
#endif
#endif
+/*
+ * We check to see if the SHIFT value has already been defined.
+ * if not, we define it ourself to some default values. We default to OpenGL
+ * order (in memory: r,g,b,a)
+ */
+#ifndef SK_A32_SHIFT
+ #ifdef SK_CPU_BENDIAN
+ #define SK_R32_SHIFT 24
+ #define SK_G32_SHIFT 16
+ #define SK_B32_SHIFT 8
+ #define SK_A32_SHIFT 0
+ #else
+ #define SK_R32_SHIFT 0
+ #define SK_G32_SHIFT 8
+ #define SK_B32_SHIFT 16
+ #define SK_A32_SHIFT 24
+ #endif
+#endif
+
// stdlib macros
#if 0
diff --git a/include/core/SkPreConfig.h b/include/core/SkPreConfig.h
index 8d47d46..6ec73ce 100644
--- a/include/core/SkPreConfig.h
+++ b/include/core/SkPreConfig.h
@@ -41,14 +41,16 @@
#define SK_BUILD_FOR_UNIX
#elif TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR
#define SK_BUILD_FOR_IOS
- #elif defined(ANDROID_NDK)
- #define SK_BUILD_FOR_ANDROID_NDK
- #elif defined(ANROID)
- #define SK_BUILD_FOR_ANDROID
#else
#define SK_BUILD_FOR_MAC
#endif
+ #if defined(ANDROID)
+ #define SK_BUILD_FOR_ANDROID
+ #endif
+ #if defined(ANDROID_NDK)
+ #define SK_BUILD_FOR_ANDROID_NDK
+ #endif
#endif
//////////////////////////////////////////////////////////////////////
diff --git a/include/core/SkReader32.h b/include/core/SkReader32.h
index 03a34c7..654ebd5 100644
--- a/include/core/SkReader32.h
+++ b/include/core/SkReader32.h
@@ -101,7 +101,14 @@
uint16_t readU16() { return (uint16_t)this->readInt(); }
int32_t readS32() { return this->readInt(); }
uint32_t readU32() { return this->readInt(); }
-
+
+ /**
+ * Read the length of a string written by SkWriter32::writeString()
+ * (if len is not NULL) and return the null-ternimated address of the
+ * string.
+ */
+ const char* readString(size_t* len = NULL);
+
private:
// these are always 4-byte aligned
const char* fCurr; // current position within buffer
diff --git a/include/core/SkRect.h b/include/core/SkRect.h
index 550c5d1..19ee12a 100644
--- a/include/core/SkRect.h
+++ b/include/core/SkRect.h
@@ -290,7 +290,7 @@
void sort();
static const SkIRect& EmptyIRect() {
- static const SkIRect gEmpty = {0,0,0,0};
+ static const SkIRect gEmpty = { 0, 0, 0, 0 };
return gEmpty;
}
};
diff --git a/include/core/SkScalar.h b/include/core/SkScalar.h
index ebe621b..5dbf684 100644
--- a/include/core/SkScalar.h
+++ b/include/core/SkScalar.h
@@ -66,9 +66,47 @@
int exponent = bits << 1 >> 24;
return exponent != 0xFF;
}
+#ifdef SK_DEBUG
+ /** SkIntToScalar(n) returns its integer argument as an SkScalar
+ *
+ * If we're compiling in DEBUG mode, and can thus afford some extra runtime
+ * cycles, check to make sure that the parameter passed in has not already
+ * been converted to SkScalar. (A double conversion like this is harmless
+ * for SK_SCALAR_IS_FLOAT, but for SK_SCALAR_IS_FIXED this causes trouble.)
+ *
+ * Note that we need all of these method signatures to properly handle the
+ * various types that we pass into SkIntToScalar() to date:
+ * int, size_t, U8CPU, etc., even though what we really mean is "anything
+ * but a float".
+ */
+ static inline float SkIntToScalar(signed int param) {
+ return (float)param;
+ }
+ static inline float SkIntToScalar(unsigned int param) {
+ return (float)param;
+ }
+ static inline float SkIntToScalar(signed long param) {
+ return (float)param;
+ }
+ static inline float SkIntToScalar(unsigned long param) {
+ return (float)param;
+ }
+ static inline float SkIntToScalar(float param) {
+ /* If the parameter passed into SkIntToScalar is a float,
+ * one of two things has happened:
+ * 1. the parameter was an SkScalar (which is typedef'd to float)
+ * 2. the parameter was a float instead of an int
+ *
+ * Either way, it's not good.
+ */
+ SkASSERT(!"looks like you passed an SkScalar into SkIntToScalar");
+ return (float)0;
+ }
+#else // not SK_DEBUG
/** SkIntToScalar(n) returns its integer argument as an SkScalar
*/
#define SkIntToScalar(n) ((float)(n))
+#endif // not SK_DEBUG
/** SkFixedToScalar(n) returns its SkFixed argument as an SkScalar
*/
#define SkFixedToScalar(x) SkFixedToFloat(x)
@@ -282,4 +320,3 @@
const SkScalar values[], int length);
#endif
-
diff --git a/include/core/SkScalerContext.h b/include/core/SkScalerContext.h
index 55dfcef..3f818a3 100644
--- a/include/core/SkScalerContext.h
+++ b/include/core/SkScalerContext.h
@@ -179,6 +179,9 @@
kEmbolden_Flag = 0x80,
kSubpixelPositioning_Flag = 0x100,
kAutohinting_Flag = 0x200,
+ // these should only ever be set if fMaskFormat is LCD
+ kLCD_Vertical_Flag = 0x400, // else Horizontal
+ kLCD_BGROrder_Flag = 0x800, // else RGB order
};
private:
enum {
diff --git a/include/core/SkWriter32.h b/include/core/SkWriter32.h
index 8e133c2..c8ebb6a 100644
--- a/include/core/SkWriter32.h
+++ b/include/core/SkWriter32.h
@@ -100,7 +100,22 @@
}
void writePad(const void* src, size_t size);
-
+
+ /**
+ * Writes a string to the writer, which can be retrieved with
+ * SkReader32::readString().
+ * The length can be specified, or if -1 is passed, it will be computed by
+ * calling strlen(). The length must be < 0xFFFF
+ */
+ void writeString(const char* str, size_t len = (size_t)-1);
+
+ /**
+ * Computes the size (aligned to multiple of 4) need to write the string
+ * in a call to writeString(). If the length is not specified, it will be
+ * computed by calling strlen().
+ */
+ static size_t WriteStringSize(const char* str, size_t len = (size_t)-1);
+
// return the current offset (will always be a multiple of 4)
uint32_t size() const { return fSize; }
void reset();
diff --git a/include/core/SkXfermode.h b/include/core/SkXfermode.h
index 4d46bb9..6ab9d6d 100644
--- a/include/core/SkXfermode.h
+++ b/include/core/SkXfermode.h
@@ -103,11 +103,15 @@
kDstATop_Mode, //!< [Sa, Sa * Dc + Sc * (1 - Da)]
kXor_Mode, //!< [Sa + Da - 2 * Sa * Da, Sc * (1 - Da) + (1 - Sa) * Dc]
- // these modes are defined in the SVG Compositing standard
+ // all remaining modes are defined in the SVG Compositing standard
// http://www.w3.org/TR/2009/WD-SVGCompositing-20090430/
kPlus_Mode,
- kMultiply_Mode,
- kScreen_Mode,
+ kMultiply_Mode,
+
+ // all above modes can be expressed as pair of src/dst Coeffs
+ kCoeffModesCnt,
+
+ kScreen_Mode = kCoeffModesCnt,
kOverlay_Mode,
kDarken_Mode,
kLighten_Mode,
diff --git a/include/gpu/SkGpuDevice.h b/include/gpu/SkGpuDevice.h
index 15def87..601da09 100644
--- a/include/gpu/SkGpuDevice.h
+++ b/include/gpu/SkGpuDevice.h
@@ -163,17 +163,26 @@
// doesn't set the texture/sampler/matrix state
// caller needs to null out GrPaint's texture if
// non-textured drawing is desired.
+ // Set constantColor to true if a constant color
+ // will be used. This is an optimization, and can
+ // always be set to false. constantColor should
+ // never be true if justAlpha is true.
bool skPaint2GrPaintNoShader(const SkPaint& skPaint,
bool justAlpha,
- GrPaint* grPaint);
+ GrPaint* grPaint,
+ bool constantColor);
// uses the SkShader to setup paint, act used to
// hold lock on cached texture and free it when
// destroyed.
+ // If there is no shader, constantColor will
+ // be passed to skPaint2GrPaintNoShader. Otherwise
+ // it is ignored.
bool skPaint2GrPaintShader(const SkPaint& skPaint,
SkAutoCachedTexture* act,
const SkMatrix& ctm,
- GrPaint* grPaint);
+ GrPaint* grPaint,
+ bool constantColor);
SkDrawProcs* initDrawForText(GrTextContext*);
bool bindDeviceAsTexture(GrPaint* paint);
diff --git a/include/gpu/SkGr.h b/include/gpu/SkGr.h
index 75099b2..65565c9 100644
--- a/include/gpu/SkGr.h
+++ b/include/gpu/SkGr.h
@@ -24,8 +24,8 @@
#include "GrConfig.h"
#include "GrContext.h"
#include "GrFontScaler.h"
-#include "GrPathIter.h"
#include "GrClipIterator.h"
+#include "GrPath.h"
// skia headers
#include "SkBitmap.h"
@@ -130,29 +130,6 @@
////////////////////////////////////////////////////////////////////////////////
// Classes
-class SkGrPathIter : public GrPathIter {
-public:
- SkGrPathIter() { fPath = NULL; }
- SkGrPathIter(const SkPath& path) { reset(path); }
- virtual GrPathCmd next(GrPoint pts[]);
- virtual GrPathCmd next();
- virtual void rewind();
- virtual GrConvexHint convexHint() const;
- virtual bool getConservativeBounds(GrRect* rect) const;
-
- void reset(const SkPath& path) {
- fPath = &path;
- fIter.setPath(path, false);
- }
-private:
-
-#if !SK_SCALAR_IS_GR_SCALAR
- SkPoint fPoints[4];
-#endif
- SkPath::Iter fIter;
- const SkPath* fPath;
-};
-
class SkGrClipIterator : public GrClipIterator {
public:
SkGrClipIterator() { fClipStack = NULL; fCurr = NULL; }
@@ -176,9 +153,8 @@
}
}
- virtual GrPathIter* getPathIter() {
- fPathIter.reset(*fCurr->fPath);
- return &fPathIter;
+ virtual const GrPath* getPath() {
+ return fCurr->fPath;
}
virtual GrPathFill getPathFill() const;
@@ -186,7 +162,6 @@
private:
const SkClipStack* fClipStack;
SkClipStack::B2FIter fIter;
- SkGrPathIter fPathIter;
// SkClipStack's auto advances on each get
// so we store the current pos here.
const SkClipStack::B2FIter::Clip* fCurr;
@@ -218,7 +193,7 @@
rect->fBottom = GrIntToScalar(r.fBottom);
}
- virtual GrPathIter* getPathIter() {
+ virtual const GrPath* getPath() {
SkASSERT(0);
return NULL;
}
diff --git a/include/pdf/SkPDFCatalog.h b/include/pdf/SkPDFCatalog.h
new file mode 100644
index 0000000..e02ffa1
--- /dev/null
+++ b/include/pdf/SkPDFCatalog.h
@@ -0,0 +1,102 @@
+/*
+ * Copyright (C) 2010 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.
+ */
+
+#ifndef SkPDFCatalog_DEFINED
+#define SkPDFCatalog_DEFINED
+
+#include <sys/types.h>
+
+#include "SkPDFTypes.h"
+#include "SkRefCnt.h"
+#include "SkTDArray.h"
+
+/** \class SkPDFCatalog
+
+ The PDF catalog manages object numbers and file offsets. It is used
+ to create the PDF cross reference table.
+*/
+class SK_API SkPDFCatalog {
+public:
+ /** Create a PDF catalog.
+ */
+ SkPDFCatalog();
+ ~SkPDFCatalog();
+
+ /** Add the passed object to the catalog. Refs obj.
+ * @param obj The object to add.
+ * @param onFirstPage Is the object on the first page.
+ * @return The obj argument is returned.
+ */
+ SkPDFObject* addObject(SkPDFObject* obj, bool onFirstPage);
+
+ /** Inform the catalog of the object's position in the final stream.
+ * The object should already have been added to the catalog. Returns
+ * the object's size.
+ * @param obj The object to add.
+ * @param offset The byte offset in the output stream of this object.
+ */
+ size_t setFileOffset(SkPDFObject* obj, size_t offset);
+
+ /** Output the object number for the passed object.
+ * @param obj The object of interest.
+ * @param stream The writable output stream to send the output to.
+ */
+ void emitObjectNumber(SkWStream* stream, SkPDFObject* obj);
+
+ /** Return the number of bytes that would be emitted for the passed
+ * object's object number.
+ * @param obj The object of interest
+ */
+ size_t getObjectNumberSize(SkPDFObject* obj);
+
+ /** Output the cross reference table for objects in the catalog.
+ * Returns the total number of objects.
+ * @param stream The writable output stream to send the output to.
+ * @param firstPage If true, include first page objects only, otherwise
+ * include all objects not on the first page.
+ */
+ int32_t emitXrefTable(SkWStream* stream, bool firstPage);
+
+private:
+ struct Rec {
+ Rec(SkPDFObject* object, bool onFirstPage)
+ : fObject(object),
+ fFileOffset(0),
+ fObjNumAssigned(false),
+ fOnFirstPage(onFirstPage) {
+ }
+ SkPDFObject* fObject;
+ off_t fFileOffset;
+ bool fObjNumAssigned;
+ bool fOnFirstPage;
+ };
+
+ // TODO(vandebo) Make this a hash if it's a performance problem.
+ SkTDArray<struct Rec> fCatalog;
+
+ // Number of objects on the first page.
+ uint32_t fFirstPageCount;
+ // Next object number to assign (on page > 1).
+ uint32_t fNextObjNum;
+ // Next object number to assign on the first page.
+ uint32_t fNextFirstPageObjNum;
+
+ int findObjectIndex(SkPDFObject* obj) const;
+
+ int assignObjNum(SkPDFObject* obj);
+};
+
+#endif
diff --git a/include/pdf/SkPDFDevice.h b/include/pdf/SkPDFDevice.h
new file mode 100644
index 0000000..6e4d8db
--- /dev/null
+++ b/include/pdf/SkPDFDevice.h
@@ -0,0 +1,227 @@
+/*
+ * Copyright (C) 2011 Google Inc.
+ *
+ * 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.
+ */
+
+#ifndef SkPDFDevice_DEFINED
+#define SkPDFDevice_DEFINED
+
+#include "SkCanvas.h"
+#include "SkDevice.h"
+#include "SkPaint.h"
+#include "SkPath.h"
+#include "SkRefCnt.h"
+#include "SkStream.h"
+#include "SkTScopedPtr.h"
+
+class SkPDFArray;
+class SkPDFDevice;
+class SkPDFDict;
+class SkPDFFont;
+class SkPDFFormXObject;
+class SkPDFGraphicState;
+class SkPDFObject;
+class SkPDFShader;
+class SkPDFStream;
+
+// Private classes.
+struct ContentEntry;
+struct GraphicStateEntry;
+
+class SkPDFDeviceFactory : public SkDeviceFactory {
+public:
+ virtual SkDevice* newDevice(SkCanvas*, SkBitmap::Config, int width,
+ int height, bool isOpaque, bool isForLayer);
+};
+
+/** \class SkPDFDevice
+
+ The drawing context for the PDF backend.
+*/
+class SkPDFDevice : public SkDevice {
+public:
+ /** Create a PDF drawing context with the given width and height.
+ * 72 points/in means letter paper is 612x792.
+ * @param pageSize Page size in points.
+ * @param contentSize The content size of the page in points. This will be
+ * combined with the initial transform to determine the drawing area
+ * (as reported by the width and height methods). Anything outside
+ * of the drawing area will be clipped.
+ * @param initialTransform The initial transform to apply to the page.
+ * This may be useful to, for example, move the origin in and
+ * over a bit to account for a margin, scale the canvas,
+ * or apply a rotation. Note1: the SkPDFDevice also applies
+ * a scale+translate transform to move the origin from the
+ * bottom left (PDF default) to the top left. Note2: drawDevice
+ * (used by layer restore) draws the device after this initial
+ * transform is applied, so the PDF device factory does an
+ * inverse scale+translate to accommodate the one that SkPDFDevice
+ * always does.
+ */
+ // TODO(vandebo) The sizes should be SkSize and not SkISize.
+ SK_API SkPDFDevice(const SkISize& pageSize, const SkISize& contentSize,
+ const SkMatrix& initialTransform);
+ SK_API virtual ~SkPDFDevice();
+
+ virtual uint32_t getDeviceCapabilities() { return kVector_Capability; }
+
+ virtual void clear(SkColor color);
+
+ virtual bool readPixels(const SkIRect& srcRect, SkBitmap* bitmap) {
+ return false;
+ }
+
+ /** These are called inside the per-device-layer loop for each draw call.
+ When these are called, we have already applied any saveLayer operations,
+ and are handling any looping from the paint, and any effects from the
+ DrawFilter.
+ */
+ virtual void drawPaint(const SkDraw&, const SkPaint& paint);
+ virtual void drawPoints(const SkDraw&, SkCanvas::PointMode mode,
+ size_t count, const SkPoint[],
+ const SkPaint& paint);
+ virtual void drawRect(const SkDraw&, const SkRect& r, const SkPaint& paint);
+ virtual void drawPath(const SkDraw&, const SkPath& origpath,
+ const SkPaint& paint, const SkMatrix* prePathMatrix,
+ bool pathIsMutable);
+ virtual void drawBitmap(const SkDraw&, const SkBitmap& bitmap,
+ const SkIRect* srcRectOrNull,
+ const SkMatrix& matrix, const SkPaint& paint);
+ virtual void drawSprite(const SkDraw&, const SkBitmap& bitmap, int x, int y,
+ const SkPaint& paint);
+ virtual void drawText(const SkDraw&, const void* text, size_t len,
+ SkScalar x, SkScalar y, const SkPaint& paint);
+ virtual void drawPosText(const SkDraw&, const void* text, size_t len,
+ const SkScalar pos[], SkScalar constY,
+ int scalarsPerPos, const SkPaint& paint);
+ virtual void drawTextOnPath(const SkDraw&, const void* text, size_t len,
+ const SkPath& path, const SkMatrix* matrix,
+ const SkPaint& paint);
+ virtual void drawVertices(const SkDraw&, SkCanvas::VertexMode,
+ int vertexCount, const SkPoint verts[],
+ const SkPoint texs[], const SkColor colors[],
+ SkXfermode* xmode, const uint16_t indices[],
+ int indexCount, const SkPaint& paint);
+ virtual void drawDevice(const SkDraw&, SkDevice*, int x, int y,
+ const SkPaint&);
+
+ // PDF specific methods.
+
+ /** Returns a reference to the resource dictionary for this device.
+ */
+ SK_API const SkRefPtr<SkPDFDict>& getResourceDict();
+
+ /** Get the list of resources (PDF objects) used on this page.
+ * @param resourceList A list to append the resources to.
+ */
+ SK_API void getResources(SkTDArray<SkPDFObject*>* resourceList) const;
+
+ /** Get the fonts used on this device.
+ */
+ SK_API const SkTDArray<SkPDFFont*>& getFontResources() const;
+
+ /** Returns the media box for this device.
+ */
+ SK_API SkRefPtr<SkPDFArray> getMediaBox() const;
+
+ /** Returns a SkStream with the page contents. The caller is responsible
+ for a reference to the returned value.
+ */
+ SK_API SkStream* content() const;
+
+ SK_API const SkMatrix& initialTransform() const {
+ return fInitialTransform;
+ }
+
+protected:
+ // override
+ virtual SkDeviceFactory* onNewDeviceFactory();
+
+private:
+ friend class SkPDFDeviceFactory;
+ // TODO(vandebo) push most of SkPDFDevice's state into a core object in
+ // order to get the right access levels without using friend.
+ friend class ScopedContentEntry;
+
+ SkISize fPageSize;
+ SkISize fContentSize;
+ SkMatrix fInitialTransform;
+ SkClipStack fExistingClipStack;
+ SkRegion fExistingClipRegion;
+ SkRefPtr<SkPDFDict> fResourceDict;
+
+ SkTDArray<SkPDFGraphicState*> fGraphicStateResources;
+ SkTDArray<SkPDFObject*> fXObjectResources;
+ SkTDArray<SkPDFFont*> fFontResources;
+ SkTDArray<SkPDFShader*> fShaderResources;
+
+ SkTScopedPtr<ContentEntry> fContentEntries;
+ ContentEntry* fLastContentEntry;
+
+ // For use by the DeviceFactory.
+ SkPDFDevice(const SkISize& layerSize, const SkClipStack& existingClipStack,
+ const SkRegion& existingClipRegion);
+
+ void init();
+ void cleanUp();
+ void createFormXObjectFromDevice(SkRefPtr<SkPDFFormXObject>* xobject);
+
+ // Clear the passed clip from all existing content entries.
+ void clearClipFromContent(const SkClipStack* clipStack,
+ const SkRegion& clipRegion);
+ void drawFormXObjectWithClip(SkPDFFormXObject* form,
+ const SkClipStack* clipStack,
+ const SkRegion& clipRegion,
+ bool invertClip);
+
+ // If the paint or clip is such that we shouldn't draw anything, this
+ // returns NULL and does not create a content entry.
+ // setUpContentEntry and finishContentEntry can be used directly, but
+ // the preferred method is to use the ScopedContentEntry helper class.
+ ContentEntry* setUpContentEntry(const SkClipStack* clipStack,
+ const SkRegion& clipRegion,
+ const SkMatrix& matrix,
+ const SkPaint& paint,
+ bool hasText,
+ SkRefPtr<SkPDFFormXObject>* dst);
+ void finishContentEntry(SkXfermode::Mode xfermode,
+ SkPDFFormXObject* dst);
+ bool isContentEmpty();
+
+ void populateGraphicStateEntryFromPaint(const SkMatrix& matrix,
+ const SkClipStack& clipStack,
+ const SkRegion& clipRegion,
+ const SkPaint& paint,
+ bool hasText,
+ GraphicStateEntry* entry);
+ int addGraphicStateResource(SkPDFGraphicState* gs);
+
+ void updateFont(const SkPaint& paint, uint16_t glyphID,
+ ContentEntry* contentEntry);
+ int getFontResourceIndex(SkTypeface* typeface, uint16_t glyphID);
+
+ void internalDrawPaint(const SkPaint& paint, ContentEntry* contentEntry);
+ void internalDrawBitmap(const SkMatrix& matrix,
+ const SkClipStack* clipStack,
+ const SkRegion& clipRegion,
+ const SkBitmap& bitmap,
+ const SkIRect* srcRect,
+ const SkPaint& paint);
+
+ // Disable the default copy and assign implementation.
+ SkPDFDevice(const SkPDFDevice&);
+ void operator=(const SkPDFDevice&);
+};
+
+#endif
diff --git a/include/pdf/SkPDFDocument.h b/include/pdf/SkPDFDocument.h
new file mode 100644
index 0000000..0a76ea2
--- /dev/null
+++ b/include/pdf/SkPDFDocument.h
@@ -0,0 +1,84 @@
+/*
+ * Copyright (C) 2010 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.
+ */
+
+#ifndef SkPDFDocument_DEFINED
+#define SkPDFDocument_DEFINED
+
+#include "SkPDFCatalog.h"
+#include "SkPDFTypes.h"
+#include "SkRefCnt.h"
+#include "SkTDArray.h"
+
+class SkPDFDevice;
+class SkPDFPage;
+class SkWSteam;
+
+/** \class SkPDFDocument
+
+ A SkPDFDocument assembles pages together and generates the final PDF file.
+*/
+class SkPDFDocument {
+public:
+ /** Create a PDF document.
+ */
+ SK_API SkPDFDocument();
+ SK_API ~SkPDFDocument();
+
+ /** Output the PDF to the passed stream.
+ * @param stream The writable output stream to send the PDF to.
+ */
+ SK_API bool emitPDF(SkWStream* stream);
+
+ /** Append the passed pdf device to the document as a new page. Returns
+ * true if successful. Will fail if the document has already been emitted.
+ *
+ * @param pdfDevice The page to add to this document.
+ */
+ SK_API bool appendPage(const SkRefPtr<SkPDFDevice>& pdfDevice);
+
+ /** Get the list of pages in this document.
+ */
+ SK_API const SkTDArray<SkPDFPage*>& getPages();
+
+private:
+ SkPDFCatalog fCatalog;
+ int64_t fXRefFileOffset;
+
+ SkTDArray<SkPDFPage*> fPages;
+ SkTDArray<SkPDFDict*> fPageTree;
+ SkRefPtr<SkPDFDict> fDocCatalog;
+ SkTDArray<SkPDFObject*> fPageResources;
+ int fSecondPageFirstResourceIndex;
+
+ SkRefPtr<SkPDFDict> fTrailerDict;
+
+ /** Output the PDF header to the passed stream.
+ * @param stream The writable output stream to send the header to.
+ */
+ void emitHeader(SkWStream* stream);
+
+ /** Get the size of the header.
+ */
+ size_t headerSize();
+
+ /** Output the PDF footer to the passed stream.
+ * @param stream The writable output stream to send the footer to.
+ * @param objCount The number of objects in the PDF.
+ */
+ void emitFooter(SkWStream* stream, int64_t objCount);
+};
+
+#endif
diff --git a/include/pdf/SkPDFFont.h b/include/pdf/SkPDFFont.h
new file mode 100644
index 0000000..93a72f1
--- /dev/null
+++ b/include/pdf/SkPDFFont.h
@@ -0,0 +1,151 @@
+/*
+ * Copyright (C) 2011 Google Inc.
+ *
+ * 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.
+ */
+
+#ifndef SkPDFFont_DEFINED
+#define SkPDFFont_DEFINED
+
+#include "SkAdvancedTypefaceMetrics.h"
+#include "SkPDFTypes.h"
+#include "SkTDArray.h"
+#include "SkThread.h"
+
+class SkPaint;
+
+/** \class SkPDFFont
+ A PDF Object class representing a font. The font may have resources
+ attached to it in order to embed the font. SkPDFFonts are canonicalized
+ so that resource deduplication will only include one copy of a font.
+ This class uses the same pattern as SkPDFGraphicState, a static weak
+ reference to each instantiated class.
+*/
+class SkPDFFont : public SkPDFDict {
+public:
+ SK_API virtual ~SkPDFFont();
+
+ SK_API virtual void getResources(SkTDArray<SkPDFObject*>* resourceList);
+
+ /** Returns the typeface represented by this class. Returns NULL for the
+ * default typeface.
+ */
+ SK_API SkTypeface* typeface();
+
+ /** Returns the font type represented in this font. For Type0 fonts,
+ * returns the type of the decendant font.
+ */
+ SK_API SkAdvancedTypefaceMetrics::FontType getType();
+
+ /** Return true if this font has an encoding for the passed glyph id.
+ */
+ SK_API bool hasGlyph(uint16_t glyphID);
+
+ /** Returns true if this font encoding supports glyph IDs above 255.
+ */
+ SK_API bool multiByteGlyphs();
+
+ /** Convert (in place) the input glyph IDs into the font encoding. If the
+ * font has more glyphs than can be encoded (like a type 1 font with more
+ * than 255 glyphs) this method only converts up to the first out of range
+ * glyph ID.
+ * @param glyphIDs The input text as glyph IDs.
+ * @param numGlyphs The number of input glyphs.
+ * @return Returns the number of glyphs consumed.
+ */
+ SK_API size_t glyphsToPDFFontEncoding(uint16_t* glyphIDs, size_t numGlyphs);
+
+ /** Get the font resource for the passed typeface and glyphID. The
+ * reference count of the object is incremented and it is the caller's
+ * responsibility to unreference it when done. This is needed to
+ * accommodate the weak reference pattern used when the returned object
+ * is new and has no other references.
+ * @param typeface The typeface to find.
+ * @param glyphID Specify which section of a large font is of interest.
+ */
+ SK_API static SkPDFFont* getFontResource(SkTypeface* typeface,
+ uint16_t glyphID);
+
+private:
+ SkRefPtr<SkTypeface> fTypeface;
+ SkAdvancedTypefaceMetrics::FontType fType;
+#ifdef SK_DEBUG
+ bool fDescendant;
+#endif
+ bool fMultiByteGlyphs;
+
+ // The glyph IDs accessible with this font. For Type1 (non CID) fonts,
+ // this will be a subset if the font has more than 255 glyphs.
+ uint16_t fFirstGlyphID;
+ uint16_t fLastGlyphID;
+ // The font info is only kept around after construction for large
+ // Type1 (non CID) fonts that need multiple "fonts" to access all glyphs.
+ SkRefPtr<SkAdvancedTypefaceMetrics> fFontInfo;
+ SkTDArray<SkPDFObject*> fResources;
+ SkRefPtr<SkPDFDict> fDescriptor;
+
+ class FontRec {
+ public:
+ SkPDFFont* fFont;
+ uint32_t fFontID;
+ uint16_t fGlyphID;
+
+ // A fGlyphID of 0 with no fFont always matches.
+ bool operator==(const FontRec& b) const;
+ FontRec(SkPDFFont* font, uint32_t fontID, uint16_t fGlyphID);
+ };
+
+ // This should be made a hash table if performance is a problem.
+ static SkTDArray<FontRec>& canonicalFonts();
+ static SkMutex& canonicalFontsMutex();
+
+ /** Construct a new font dictionary and support objects.
+ * @param fontInfo Information about the to create.
+ * @param typeface The typeface for the font.
+ * @param glyphID The glyph ID the caller is interested in. This
+ * is important only for Type1 fonts, which have
+ * more than 255 glyphs.
+ * @param descendantFont If this is the descendant (true) or root
+ * (Type 0 font - false) font dictionary. Only True
+ * Type and CID encoded fonts will use a true value.
+ * @param fontDescriptor If the font descriptor has already have generated
+ * for this font, pass it in here, otherwise pass
+ * NULL.
+ */
+ SkPDFFont(class SkAdvancedTypefaceMetrics* fontInfo, SkTypeface* typeface,
+ uint16_t glyphID, bool descendantFont, SkPDFDict* fontDescriptor);
+
+ void populateType0Font();
+ void populateCIDFont();
+ bool populateType1Font(int16_t glyphID);
+
+ /** Populate the PDF font dictionary as Type3 font which includes glyph
+ * descriptions with instructions for painting the glyphs. This function
+ * doesn't use any fields from SkAdvancedTypefaceMetrics (fFontInfo). Font
+ * information including glyph paths are queried from the platform
+ * dependent SkGlyphCache.
+ */
+ void populateType3Font(int16_t glyphID);
+ bool addFontDescriptor(int16_t defaultWidth);
+ void populateToUnicodeTable();
+ void addWidthInfoFromRange(int16_t defaultWidth,
+ const SkAdvancedTypefaceMetrics::WidthRange* widthRangeEntry);
+ /** Set fFirstGlyphID and fLastGlyphID to span at most 255 glyphs,
+ * including the passed glyphID.
+ */
+ void adjustGlyphRangeForSingleByteEncoding(int16_t glyphID);
+
+ static bool find(uint32_t fontID, uint16_t glyphID, int* index);
+};
+
+#endif
diff --git a/include/pdf/SkPDFFormXObject.h b/include/pdf/SkPDFFormXObject.h
new file mode 100644
index 0000000..41719f0
--- /dev/null
+++ b/include/pdf/SkPDFFormXObject.h
@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 2010 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.
+ */
+
+#ifndef SkPDFFormXObject_DEFINED
+#define SkPDFFormXObject_DEFINED
+
+#include "SkPDFStream.h"
+#include "SkPDFTypes.h"
+#include "SkRefCnt.h"
+#include "SkString.h"
+
+class SkMatrix;
+class SkPDFDevice;
+class SkPDFCatalog;
+
+/** \class SkPDFFormXObject
+
+ A form XObject; a self contained description of graphics objects. A form
+ XObject is basically a page object with slightly different syntax, that
+ can be drawn onto a page.
+*/
+
+// The caller could keep track of the form XObjects it creates and
+// canonicalize them, but the Skia API doesn't provide enough context to
+// automatically do it (trivially).
+class SkPDFFormXObject : public SkPDFObject {
+public:
+ /** Create a PDF form XObject. Entries for the dictionary entries are
+ * automatically added.
+ * @param device The set of graphical elements on this form.
+ */
+ explicit SkPDFFormXObject(SkPDFDevice* device);
+ virtual ~SkPDFFormXObject();
+
+ // The SkPDFObject interface.
+ virtual void emitObject(SkWStream* stream, SkPDFCatalog* catalog,
+ bool indirect);
+ virtual size_t getOutputSize(SkPDFCatalog* catalog, bool indirect);
+ virtual void getResources(SkTDArray<SkPDFObject*>* resourceList);
+
+ /** Add the value to the stream dictionary with the given key. Refs value.
+ * @param key The key for this dictionary entry.
+ * @param value The value for this dictionary entry.
+ * @return The value argument is returned.
+ */
+ SkPDFObject* insert(SkPDFName* key, SkPDFObject* value);
+
+ /** Add the value to the stream dictionary with the given key. Refs value.
+ * @param key The text of the key for this dictionary entry.
+ * @param value The value for this dictionary entry.
+ * @return The value argument is returned.
+ */
+ SkPDFObject* insert(const char key[], SkPDFObject* value);
+
+private:
+ SkRefPtr<SkPDFStream> fStream;
+ SkTDArray<SkPDFObject*> fResources;
+};
+
+#endif
diff --git a/include/pdf/SkPDFGraphicState.h b/include/pdf/SkPDFGraphicState.h
new file mode 100644
index 0000000..49809a4
--- /dev/null
+++ b/include/pdf/SkPDFGraphicState.h
@@ -0,0 +1,106 @@
+/*
+ * Copyright (C) 2010 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.
+ */
+
+#ifndef SkPDFGraphicState_DEFINED
+#define SkPDFGraphicState_DEFINED
+
+#include "SkPaint.h"
+#include "SkPDFTypes.h"
+#include "SkTemplates.h"
+#include "SkThread.h"
+
+class SkPDFFormXObject;
+
+/** \class SkPDFGraphicState
+ SkPaint objects roughly correspond to graphic state dictionaries that can
+ be installed. So that a given dictionary is only output to the pdf file
+ once, we want to canonicalize them. Static methods in this class manage
+ a weakly referenced set of SkPDFGraphicState objects: when the last
+ reference to a SkPDFGraphicState is removed, it removes itself from the
+ static set of objects.
+
+*/
+class SkPDFGraphicState : public SkPDFDict {
+public:
+ virtual ~SkPDFGraphicState();
+
+ virtual void getResources(SkTDArray<SkPDFObject*>* resourceList);
+
+ // Override emitObject and getOutputSize so that we can populate
+ // the dictionary on demand.
+ virtual void emitObject(SkWStream* stream, SkPDFCatalog* catalog,
+ bool indirect);
+ virtual size_t getOutputSize(SkPDFCatalog* catalog, bool indirect);
+
+ /** Get the graphic state for the passed SkPaint. The reference count of
+ * the object is incremented and it is the caller's responsibility to
+ * unreference it when done. This is needed to accommodate the weak
+ * reference pattern used when the returned object is new and has no
+ * other references.
+ * @param paint The SkPaint to emulate.
+ */
+ static SkPDFGraphicState* getGraphicStateForPaint(const SkPaint& paint);
+
+ /** Make a graphic state that only sets the passed soft mask. The
+ * reference count of the object is incremented and it is the caller's
+ * responsibility to unreference it when done.
+ * @param sMask The form xobject to use as a soft mask.
+ * @param invert Indicates if the alpha of the sMask should be inverted.
+ */
+ static SkPDFGraphicState* getSMaskGraphicState(SkPDFFormXObject* sMask,
+ bool invert);
+
+ /** Get a graphic state that only unsets the soft mask. The reference
+ * count of the object is incremented and it is the caller's responsibility
+ * to unreference it when done. This is needed to accommodate the weak
+ * reference pattern used when the returned object is new and has no
+ * other references.
+ */
+ static SkPDFGraphicState* getNoSMaskGraphicState();
+
+private:
+ const SkPaint fPaint;
+ SkTDArray<SkPDFObject*> fResources;
+ bool fPopulated;
+ bool fSMask;
+
+ class GSCanonicalEntry {
+ public:
+ SkPDFGraphicState* fGraphicState;
+ const SkPaint* fPaint;
+
+ bool operator==(const GSCanonicalEntry& b) const;
+ explicit GSCanonicalEntry(SkPDFGraphicState* gs)
+ : fGraphicState(gs),
+ fPaint(&gs->fPaint) {}
+ explicit GSCanonicalEntry(const SkPaint* paint) : fPaint(paint) {}
+ };
+
+ // This should be made a hash table if performance is a problem.
+ static SkTDArray<GSCanonicalEntry>& canonicalPaints();
+ static SkMutex& canonicalPaintsMutex();
+
+ SkPDFGraphicState();
+ explicit SkPDFGraphicState(const SkPaint& paint);
+
+ void populateDict();
+
+ static SkPDFObject* GetInvertFunction();
+
+ static int find(const SkPaint& paint);
+};
+
+#endif
diff --git a/include/pdf/SkPDFImage.h b/include/pdf/SkPDFImage.h
new file mode 100644
index 0000000..945ff9e
--- /dev/null
+++ b/include/pdf/SkPDFImage.h
@@ -0,0 +1,95 @@
+/*
+ * Copyright (C) 2010 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.
+ */
+
+#ifndef SkPDFImage_DEFINED
+#define SkPDFImage_DEFINED
+
+#include "SkPDFStream.h"
+#include "SkPDFTypes.h"
+#include "SkRefCnt.h"
+
+class SkBitmap;
+class SkPaint;
+class SkPDFCatalog;
+struct SkIRect;
+
+/** \class SkPDFImage
+
+ An image XObject.
+*/
+
+// We could play the same trick here as is done in SkPDFGraphicState, storing
+// a copy of the Bitmap object (not the pixels), the pixel generation number,
+// and settings used from the paint to canonicalize image objects.
+class SkPDFImage : public SkPDFObject {
+public:
+ /** Create a new Image XObject to represent the passed bitmap.
+ * @param bitmap The image to encode.
+ * @param srcRect The rectangle to cut out of bitmap.
+ * @param paint Used to calculate alpha, masks, etc.
+ * @return The image XObject or NUll if there is nothing to draw for
+ * the given parameters.
+ */
+ static SkPDFImage* CreateImage(const SkBitmap& bitmap,
+ const SkIRect& srcRect,
+ const SkPaint& paint);
+
+ virtual ~SkPDFImage();
+
+ /** Add a Soft Mask (alpha or shape channel) to the image. Refs mask.
+ * @param mask A gray scale image representing the mask.
+ * @return The mask argument is returned.
+ */
+ SkPDFImage* addSMask(SkPDFImage* mask);
+
+ // The SkPDFObject interface.
+ virtual void emitObject(SkWStream* stream, SkPDFCatalog* catalog,
+ bool indirect);
+ virtual size_t getOutputSize(SkPDFCatalog* catalog, bool indirect);
+ virtual void getResources(SkTDArray<SkPDFObject*>* resourceList);
+
+private:
+ SkRefPtr<SkPDFStream> fStream;
+ SkTDArray<SkPDFObject*> fResources;
+
+ /** Create a PDF image XObject. Entries for the image properties are
+ * automatically added to the stream dictionary.
+ * @param imageData The final raw bits representing the image.
+ * @param bitmap The image parameters to use (Config, etc).
+ * @param srcRect The clipping applied to bitmap before generating
+ * imageData.
+ * @param alpha Is this the alpha channel of the bitmap.
+ * @param paint Used to calculate alpha, masks, etc.
+ */
+ SkPDFImage(SkStream* imageData, const SkBitmap& bitmap,
+ const SkIRect& srcRect, bool alpha, const SkPaint& paint);
+
+ /** Add the value to the stream dictionary with the given key. Refs value.
+ * @param key The key for this dictionary entry.
+ * @param value The value for this dictionary entry.
+ * @return The value argument is returned.
+ */
+ SkPDFObject* insert(SkPDFName* key, SkPDFObject* value);
+
+ /** Add the value to the stream dictionary with the given key. Refs value.
+ * @param key The text of the key for this dictionary entry.
+ * @param value The value for this dictionary entry.
+ * @return The value argument is returned.
+ */
+ SkPDFObject* insert(const char key[], SkPDFObject* value);
+};
+
+#endif
diff --git a/include/pdf/SkPDFPage.h b/include/pdf/SkPDFPage.h
new file mode 100644
index 0000000..0e30028
--- /dev/null
+++ b/include/pdf/SkPDFPage.h
@@ -0,0 +1,101 @@
+/*
+ * Copyright (C) 2010 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.
+ */
+
+#ifndef SkPDFPage_DEFINED
+#define SkPDFPage_DEFINED
+
+#include "SkPDFTypes.h"
+#include "SkPDFStream.h"
+#include "SkRefCnt.h"
+#include "SkTDArray.h"
+
+class SkPDFCatalog;
+class SkPDFDevice;
+class SkWStream;
+
+/** \class SkPDFPage
+
+ A SkPDFPage contains meta information about a page, is used in the page
+ tree and points to the content of the page.
+*/
+class SkPDFPage : public SkPDFDict {
+public:
+ /** Create a PDF page with the passed PDF device. The device need not
+ * have content on it yet.
+ * @param content The page content.
+ */
+ explicit SkPDFPage(const SkRefPtr<SkPDFDevice>& content);
+ ~SkPDFPage();
+
+ /** Before a page and its contents can be sized and emitted, it must
+ * be finalized. No changes to the PDFDevice will be honored after
+ * finalizePage has been called. This function adds the page content
+ * to the passed catalog, so it must be called for each document
+ * that the page is part of.
+ * @param catalog The catalog to add page content objects to.
+ * @param firstPage Indicate if this is the first page of a document.
+ * @param resourceObjects The resource objects used on the page are added
+ * to this array. This gives the caller a chance
+ * to deduplicate resources across pages.
+ */
+ void finalizePage(SkPDFCatalog* catalog, bool firstPage,
+ SkTDArray<SkPDFObject*>* resourceObjects);
+
+ /** Determine the size of the page content and store to the catalog
+ * the offsets of all nonresource-indirect objects that make up the page
+ * content. This must be called before emitPage(), but after finalizePage.
+ * @param catalog The catalog to add the object offsets to.
+ * @param fileOffset The file offset where the page content will be
+ * emitted.
+ */
+ off_t getPageSize(SkPDFCatalog* catalog, off_t fileOffset);
+
+ /** Output the page content to the passed stream.
+ * @param stream The writable output stream to send the content to.
+ * @param catalog The active object catalog.
+ */
+ void emitPage(SkWStream* stream, SkPDFCatalog* catalog);
+
+ /** Generate a page tree for the passed vector of pages. New objects are
+ * added to the catalog. The pageTree vector is populated with all of
+ * the 'Pages' dictionaries as well as the 'Page' objects. Page trees
+ * have both parent and children links, creating reference cycles, so
+ * it must be torn down explicitly. The first page is not added to
+ * the pageTree dictionary array so the caller can handle it specially.
+ * @param pages The ordered vector of page objects.
+ * @param catalog The catalog to add new objects into.
+ * @param pageTree An output vector with all of the internal and leaf
+ * nodes of the pageTree.
+ * @param rootNode An output parameter set to the root node.
+ */
+ static void generatePageTree(const SkTDArray<SkPDFPage*>& pages,
+ SkPDFCatalog* catalog,
+ SkTDArray<SkPDFDict*>* pageTree,
+ SkPDFDict** rootNode);
+
+ /** Get the fonts used on this page.
+ */
+ SK_API const SkTDArray<SkPDFFont*>& getFontResources() const;
+
+private:
+ // Multiple pages may reference the content.
+ SkRefPtr<SkPDFDevice> fDevice;
+
+ // Once the content is finalized, put it into a stream for output.
+ SkRefPtr<SkPDFStream> fContentStream;
+};
+
+#endif
diff --git a/include/pdf/SkPDFShader.h b/include/pdf/SkPDFShader.h
new file mode 100644
index 0000000..17f7f03
--- /dev/null
+++ b/include/pdf/SkPDFShader.h
@@ -0,0 +1,110 @@
+/*
+ * Copyright (C) 2011 Google Inc.
+ *
+ * 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.
+ */
+
+#ifndef SkPDFShader_DEFINED
+#define SkPDFShader_DEFINED
+
+#include "SkPDFStream.h"
+#include "SkPDFTypes.h"
+#include "SkMatrix.h"
+#include "SkRefCnt.h"
+#include "SkShader.h"
+
+class SkObjRef;
+class SkPDFCatalog;
+
+/** \class SkPDFShader
+
+ In PDF parlance, this is a pattern, used in place of a color when the
+ pattern color space is selected.
+*/
+
+class SkPDFShader : public SkPDFObject {
+public:
+ virtual ~SkPDFShader();
+
+ // The SkPDFObject interface.
+ virtual void emitObject(SkWStream* stream, SkPDFCatalog* catalog,
+ bool indirect);
+ virtual size_t getOutputSize(SkPDFCatalog* catalog, bool indirect);
+ virtual void getResources(SkTDArray<SkPDFObject*>* resourceList);
+
+ /** Get the PDF shader for the passed SkShader. If the SkShader is
+ * invalid in some way, returns NULL. The reference count of
+ * the object is incremented and it is the caller's responsibility to
+ * unreference it when done. This is needed to accommodate the weak
+ * reference pattern used when the returned object is new and has no
+ * other references.
+ * @param shader The SkShader to emulate.
+ * @param matrix The current transform. (PDF shaders are absolutely
+ * positioned, relative to where the page is drawn.)
+ * @param surfceBBox The bounding box of the drawing surface (with matrix
+ * already applied).
+ */
+ static SkPDFShader* getPDFShader(const SkShader& shader,
+ const SkMatrix& matrix,
+ const SkIRect& surfaceBBox);
+
+private:
+ class State {
+ public:
+ SkShader::GradientType fType;
+ SkShader::GradientInfo fInfo;
+ SkAutoFree fColorData;
+ SkMatrix fCanvasTransform;
+ SkMatrix fShaderTransform;
+ SkIRect fBBox;
+
+ SkBitmap fImage;
+ uint32_t fPixelGeneration;
+ SkShader::TileMode fImageTileModes[2];
+
+ explicit State(const SkShader& shader, const SkMatrix& canvasTransform,
+ const SkIRect& bbox);
+ bool operator==(const State& b) const;
+ };
+
+ SkRefPtr<SkPDFDict> fContent;
+ SkTDArray<SkPDFObject*> fResources;
+ SkAutoTDelete<const State> fState;
+
+ class ShaderCanonicalEntry {
+ public:
+ SkPDFShader* fPDFShader;
+ const State* fState;
+
+ bool operator==(const ShaderCanonicalEntry& b) const {
+ return fPDFShader == b.fPDFShader || *fState == *b.fState;
+ }
+ ShaderCanonicalEntry(SkPDFShader* pdfShader, const State* state)
+ : fPDFShader(pdfShader),
+ fState(state) {
+ }
+ };
+ // This should be made a hash table if performance is a problem.
+ static SkTDArray<ShaderCanonicalEntry>& canonicalShaders();
+ static SkMutex& canonicalShadersMutex();
+
+ static SkPDFObject* rangeObject();
+
+ SkPDFShader(State* state);
+
+ void doFunctionShader();
+ void doImageShader();
+ SkPDFStream* makePSFunction(const SkString& psCode, SkPDFArray* domain);
+};
+
+#endif
diff --git a/include/pdf/SkPDFStream.h b/include/pdf/SkPDFStream.h
new file mode 100644
index 0000000..a975ad6
--- /dev/null
+++ b/include/pdf/SkPDFStream.h
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2010 Google Inc.
+ *
+ * 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.
+ */
+
+#ifndef SkPDFStream_DEFINED
+#define SkPDFStream_DEFINED
+
+#include "SkPDFTypes.h"
+#include "SkRefCnt.h"
+#include "SkStream.h"
+#include "SkTemplates.h"
+
+class SkPDFCatalog;
+
+/** \class SkPDFStream
+
+ A stream object in a PDF. Note, all streams must be indirect objects (via
+ SkObjRef).
+*/
+class SkPDFStream : public SkPDFDict {
+public:
+ /** Create a PDF stream. A Length entry is automatically added to the
+ * stream dictionary.
+ * @param stream The data part of the stream.
+ */
+ explicit SkPDFStream(SkStream* stream);
+ virtual ~SkPDFStream();
+
+ // The SkPDFObject interface.
+ virtual void emitObject(SkWStream* stream, SkPDFCatalog* catalog,
+ bool indirect);
+ virtual size_t getOutputSize(SkPDFCatalog* catalog, bool indirect);
+
+private:
+ size_t fLength;
+ // Only one of the two streams will be valid.
+ SkRefPtr<SkStream> fPlainData;
+ SkDynamicMemoryWStream fCompressedData;
+
+ typedef SkPDFDict INHERITED;
+};
+
+#endif
diff --git a/include/pdf/SkPDFTypes.h b/include/pdf/SkPDFTypes.h
new file mode 100644
index 0000000..6b5146a
--- /dev/null
+++ b/include/pdf/SkPDFTypes.h
@@ -0,0 +1,332 @@
+/*
+ * Copyright (C) 2010 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.
+ */
+
+#ifndef SkPDFTypes_DEFINED
+#define SkPDFTypes_DEFINED
+
+#include "SkRefCnt.h"
+#include "SkScalar.h"
+#include "SkString.h"
+#include "SkTDArray.h"
+#include "SkTypes.h"
+
+class SkPDFCatalog;
+class SkWStream;
+
+/** \class SkPDFObject
+
+ A PDF Object is the base class for primitive elements in a PDF file. A
+ common subtype is used to ease the use of indirect object references,
+ which are common in the PDF format.
+*/
+class SkPDFObject : public SkRefCnt {
+public:
+ /** Create a PDF object.
+ */
+ SkPDFObject();
+ virtual ~SkPDFObject();
+
+ /** Subclasses must implement this method to print the object to the
+ * PDF file.
+ * @param catalog The object catalog to use.
+ * @param indirect If true, output an object identifier with the object.
+ * @param stream The writable output stream to send the output to.
+ */
+ virtual void emitObject(SkWStream* stream, SkPDFCatalog* catalog,
+ bool indirect) = 0;
+
+ /** Return the size (number of bytes) of this object in the final output
+ * file. Compound objects or objects that are computationally intensive
+ * to output should override this method.
+ * @param catalog The object catalog to use.
+ * @param indirect If true, output an object identifier with the object.
+ */
+ virtual size_t getOutputSize(SkPDFCatalog* catalog, bool indirect);
+
+ /** If this object explicitly depends on other objects, add them to the
+ * end of the list. This only applies to higher level object, where
+ * the depenency is explicit and introduced by the class. i.e. an
+ * SkPDFImage added to an SkPDFDevice, but not an SkPDFObjRef added to
+ * an SkPDFArray.
+ * @param resourceList The list to append dependant resources to.
+ */
+ virtual void getResources(SkTDArray<SkPDFObject*>* resourceList);
+
+ /** Helper function to output an indirect object.
+ * @param catalog The object catalog to use.
+ * @param stream The writable output stream to send the output to.
+ */
+ void emitIndirectObject(SkWStream* stream, SkPDFCatalog* catalog);
+
+ /** Helper function to find the size of an indirect object.
+ * @param catalog The object catalog to use.
+ */
+ size_t getIndirectOutputSize(SkPDFCatalog* catalog);
+};
+
+/** \class SkPDFObjRef
+
+ An indirect reference to a PDF object.
+*/
+class SkPDFObjRef : public SkPDFObject {
+public:
+ /** Create a reference to an existing SkPDFObject.
+ * @param obj The object to reference.
+ */
+ explicit SkPDFObjRef(SkPDFObject* obj);
+ virtual ~SkPDFObjRef();
+
+ // The SkPDFObject interface.
+ virtual void emitObject(SkWStream* stream, SkPDFCatalog* catalog,
+ bool indirect);
+ virtual size_t getOutputSize(SkPDFCatalog* catalog, bool indirect);
+
+private:
+ SkRefPtr<SkPDFObject> fObj;
+};
+
+/** \class SkPDFInt
+
+ An integer object in a PDF.
+*/
+class SkPDFInt : public SkPDFObject {
+public:
+ /** Create a PDF integer (usually for indirect reference purposes).
+ * @param value An integer value between 2^31 - 1 and -2^31.
+ */
+ explicit SkPDFInt(int32_t value);
+ virtual ~SkPDFInt();
+
+ // The SkPDFObject interface.
+ virtual void emitObject(SkWStream* stream, SkPDFCatalog* catalog,
+ bool indirect);
+
+private:
+ int32_t fValue;
+};
+
+/** \class SkPDFBool
+
+ An boolean value in a PDF.
+*/
+class SkPDFBool : public SkPDFObject {
+public:
+ /** Create a PDF boolean.
+ * @param value true or false.
+ */
+ explicit SkPDFBool(bool value);
+ virtual ~SkPDFBool();
+
+ // The SkPDFObject interface.
+ virtual void emitObject(SkWStream* stream, SkPDFCatalog* catalog,
+ bool indirect);
+ virtual size_t getOutputSize(SkPDFCatalog* catalog, bool indirect);
+
+private:
+ bool fValue;
+};
+
+/** \class SkPDFScalar
+
+ A real number object in a PDF.
+*/
+class SkPDFScalar : public SkPDFObject {
+public:
+ /** Create a PDF real number.
+ * @param value A real value.
+ */
+ explicit SkPDFScalar(SkScalar value);
+ virtual ~SkPDFScalar();
+
+ static void Append(SkScalar value, SkWStream* stream);
+
+ // The SkPDFObject interface.
+ virtual void emitObject(SkWStream* stream, SkPDFCatalog* catalog,
+ bool indirect);
+
+private:
+ SkScalar fValue;
+};
+
+/** \class SkPDFString
+
+ A string object in a PDF.
+*/
+class SkPDFString : public SkPDFObject {
+public:
+ /** Create a PDF string. Maximum length (in bytes) is 65,535.
+ * @param value A string value.
+ */
+ explicit SkPDFString(const char value[]);
+ explicit SkPDFString(const SkString& value);
+
+ /** Create a PDF string. Maximum length (in bytes) is 65,535.
+ * @param value A string value.
+ * @param len The length of value.
+ * @param wideChars Indicates if the top byte in value is significant and
+ * should be encoded (true) or not (false).
+ */
+ SkPDFString(const uint16_t* value, size_t len, bool wideChars);
+ virtual ~SkPDFString();
+
+ // The SkPDFObject interface.
+ virtual void emitObject(SkWStream* stream, SkPDFCatalog* catalog,
+ bool indirect);
+ virtual size_t getOutputSize(SkPDFCatalog* catalog, bool indirect);
+
+ static SkString formatString(const char* input, size_t len);
+ static SkString formatString(const uint16_t* input, size_t len,
+ bool wideChars);
+private:
+ static const size_t kMaxLen = 65535;
+
+ const SkString fValue;
+
+ static SkString doFormatString(const void* input, size_t len,
+ bool wideInput, bool wideOutput);
+};
+
+/** \class SkPDFName
+
+ A name object in a PDF.
+*/
+class SkPDFName : public SkPDFObject {
+public:
+ /** Create a PDF name object. Maximum length is 127 bytes.
+ * @param value The name.
+ */
+ explicit SkPDFName(const char name[]);
+ explicit SkPDFName(const SkString& name);
+ virtual ~SkPDFName();
+
+ // The SkPDFObject interface.
+ virtual void emitObject(SkWStream* stream, SkPDFCatalog* catalog,
+ bool indirect);
+ virtual size_t getOutputSize(SkPDFCatalog* catalog, bool indirect);
+
+private:
+ static const size_t kMaxLen = 127;
+
+ const SkString fValue;
+
+ static SkString formatName(const SkString& input);
+};
+
+/** \class SkPDFArray
+
+ An array object in a PDF.
+*/
+class SkPDFArray : public SkPDFObject {
+public:
+ /** Create a PDF array. Maximum length is 8191.
+ */
+ SkPDFArray();
+ virtual ~SkPDFArray();
+
+ // The SkPDFObject interface.
+ virtual void emitObject(SkWStream* stream, SkPDFCatalog* catalog,
+ bool indirect);
+ virtual size_t getOutputSize(SkPDFCatalog* catalog, bool indirect);
+
+ /** The size of the array.
+ */
+ int size() { return fValue.count(); }
+
+ /** Preallocate space for the given number of entries.
+ * @param length The number of array slots to preallocate.
+ */
+ void reserve(int length);
+
+ /** Returns the object at the given offset in the array.
+ * @param index The index into the array to retrieve.
+ */
+ SkPDFObject* getAt(int index) { return fValue[index]; }
+
+ /** Set the object at the given offset in the array. Ref's value.
+ * @param index The index into the array to set.
+ * @param value The value to add to the array.
+ * @return The value argument is returned.
+ */
+ SkPDFObject* setAt(int index, SkPDFObject* value);
+
+ /** Append the object to the end of the array and increments its ref count.
+ * @param value The value to add to the array.
+ * @return The value argument is returned.
+ */
+ SkPDFObject* append(SkPDFObject* value);
+
+private:
+ static const int kMaxLen = 8191;
+ SkTDArray<SkPDFObject*> fValue;
+};
+
+/** \class SkPDFDict
+
+ A dictionary object in a PDF.
+*/
+class SkPDFDict : public SkPDFObject {
+public:
+ /** Create a PDF dictionary. Maximum number of entries is 4095.
+ */
+ SkPDFDict();
+
+ /** Create a PDF dictionary with a Type entry.
+ * @param type The value of the Type entry.
+ */
+ explicit SkPDFDict(const char type[]);
+
+ virtual ~SkPDFDict();
+
+ // The SkPDFObject interface.
+ virtual void emitObject(SkWStream* stream, SkPDFCatalog* catalog,
+ bool indirect);
+ virtual size_t getOutputSize(SkPDFCatalog* catalog, bool indirect);
+
+ /** The size of the dictionary.
+ */
+ int size() { return fValue.count(); }
+
+ /** Add the value to the dictionary with the given key. Refs value.
+ * @param key The key for this dictionary entry.
+ * @param value The value for this dictionary entry.
+ * @return The value argument is returned.
+ */
+ SkPDFObject* insert(SkPDFName* key, SkPDFObject* value);
+
+ /** Add the value to the dictionary with the given key. Refs value. The
+ * method will create the SkPDFName object.
+ * @param key The text of the key for this dictionary entry.
+ * @param value The value for this dictionary entry.
+ * @return The value argument is returned.
+ */
+ SkPDFObject* insert(const char key[], SkPDFObject* value);
+
+ /** Remove all entries from the dictionary.
+ */
+ void clear();
+
+private:
+ static const int kMaxLen = 4095;
+
+ struct Rec {
+ SkPDFName* key;
+ SkPDFObject* value;
+ };
+
+ SkTDArray<struct Rec> fValue;
+};
+
+#endif
diff --git a/include/pdf/SkPDFUtils.h b/include/pdf/SkPDFUtils.h
new file mode 100644
index 0000000..50da28c
--- /dev/null
+++ b/include/pdf/SkPDFUtils.h
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2011 Google Inc.
+ *
+ * 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.
+ */
+
+#ifndef SkPDFUtils_DEFINED
+#define SkPDFUtils_DEFINED
+
+#include "SkPath.h"
+
+class SkMatrix;
+class SkPath;
+class SkPDFArray;
+struct SkRect;
+
+#if 0
+#define PRINT_NOT_IMPL(str) fprintf(stderr, str)
+#else
+#define PRINT_NOT_IMPL(str)
+#endif
+
+#define NOT_IMPLEMENTED(condition, assert) \
+ do { \
+ if (condition) { \
+ PRINT_NOT_IMPL("NOT_IMPLEMENTED: " #condition "\n"); \
+ SkDEBUGCODE(SkASSERT(!assert);) \
+ } \
+ } while(0)
+
+class SkPDFUtils {
+public:
+ static SkPDFArray* MatrixToArray(const SkMatrix& matrix);
+ static void AppendTransform(const SkMatrix& matrix, SkWStream* content);
+
+ static void MoveTo(SkScalar x, SkScalar y, SkWStream* content);
+ static void AppendLine(SkScalar x, SkScalar y, SkWStream* content);
+ static void AppendCubic(SkScalar ctl1X, SkScalar ctl1Y,
+ SkScalar ctl2X, SkScalar ctl2Y,
+ SkScalar dstX, SkScalar dstY, SkWStream* content);
+ static void AppendRectangle(const SkRect& rect, SkWStream* content);
+ static void EmitPath(const SkPath& path, SkWStream* content);
+ static void ClosePath(SkWStream* content);
+ static void PaintPath(SkPaint::Style style, SkPath::FillType fill,
+ SkWStream* content);
+ static void StrokePath(SkWStream* content);
+ static void DrawFormXObject(int objectIndex, SkWStream* content);
+ static void ApplyGraphicState(int objectIndex, SkWStream* content);
+};
+
+#endif
diff --git a/include/pipe/SkGPipe.h b/include/pipe/SkGPipe.h
new file mode 100644
index 0000000..897766f
--- /dev/null
+++ b/include/pipe/SkGPipe.h
@@ -0,0 +1,96 @@
+/*
+ Copyright 2011 Google Inc.
+
+ 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.
+ */
+
+
+#ifndef SkGPipe_DEFINED
+#define SkGPipe_DEFINED
+
+#include "SkWriter32.h"
+#include "SkFlattenable.h"
+
+class SkCanvas;
+
+class SkGPipeReader {
+public:
+ SkGPipeReader(SkCanvas* target);
+ ~SkGPipeReader();
+
+ enum Status {
+ kDone_Status, //!< no more data expected from reader
+ kEOF_Status, //!< need more data from reader
+ kError_Status //!< encountered error
+ };
+
+ // data must be 4-byte aligned
+ // length must be a multiple of 4
+ Status playback(const void* data, size_t length, size_t* bytesRead = NULL);
+
+private:
+ SkCanvas* fCanvas;
+ class SkGPipeState* fState;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+class SkGPipeController {
+public:
+ /**
+ * Called periodically by the writer, to get a working buffer of RAM to
+ * write into. The actual size of the block is also returned, and must be
+ * actual >= minRequest. If NULL is returned, then actual is ignored and
+ * writing will stop.
+ *
+ * The returned block must be 4-byte aligned, and actual must be a
+ * multiple of 4.
+ * minRequest will always be a multiple of 4.
+ */
+ virtual void* requestBlock(size_t minRequest, size_t* actual) = 0;
+
+ /**
+ * This is called each time some atomic portion of the data has been
+ * written to the block (most recently returned by requestBlock()).
+ * If bytes == 0, then the writer has finished.
+ *
+ * bytes will always be a multiple of 4.
+ */
+ virtual void notifyWritten(size_t bytes) = 0;
+};
+
+class SkGPipeWriter {
+public:
+ SkGPipeWriter();
+ ~SkGPipeWriter();
+
+ bool isRecording() const { return NULL != fCanvas; }
+
+ enum Flags {
+ kCrossProcess_Flag = 1 << 0,
+ };
+
+ SkCanvas* startRecording(SkGPipeController*, uint32_t flags = 0);
+
+ // called in destructor, but can be called sooner once you know there
+ // should be no more drawing calls made into the recording canvas.
+ void endRecording();
+
+private:
+ class SkGPipeCanvas* fCanvas;
+ SkGPipeController* fController;
+ SkFactorySet fFactorySet;
+ SkWriter32 fWriter;
+};
+
+#endif
diff --git a/include/utils/SkEGLContext.h b/include/utils/SkEGLContext.h
index 4b17be1..ced31a5 100644
--- a/include/utils/SkEGLContext.h
+++ b/include/utils/SkEGLContext.h
@@ -1,20 +1,53 @@
#ifndef SkEGLContext_DEFINED
#define SkEGLContext_DEFINED
-#include "SkTypes.h"
+#if defined(SK_MESA)
+ #include "GL/osmesa.h"
+#elif defined(SK_BUILD_FOR_MAC)
+ #include <AGL/agl.h>
+#elif defined(SK_BUILD_FOR_ANDROID)
+ #include "GLES2/gl2.h"
+ #include "EGL/egl.h"
+#elif defined(SK_BUILD_FOR_UNIX)
+ #include <X11/Xlib.h>
+ #include <GL/glx.h>
+#elif defined(SK_BUILD_FOR_WIN32)
+ #include <Windows.h>
+ #include <GL/GL.h>
+#else
+
+#endif
/**
* Create an offscreen opengl context
*/
class SkEGLContext {
public:
- SkEGLContext();
- ~SkEGLContext();
+ SkEGLContext();
+ ~SkEGLContext();
- bool init(int width, int height);
+ bool init(const int width, const int height);
private:
- void* fContext;
+#if defined(SK_MESA)
+ OSMesaContext context;
+ GLfloat *image;
+#elif defined(SK_BUILD_FOR_MAC)
+ AGLContext context;
+#elif defined(SK_BUILD_FOR_ANDROID)
+
+#elif defined(SK_BUILD_FOR_UNIX)
+ GLXContext context;
+ Display *display;
+ Pixmap pixmap;
+ GLXPixmap glxPixmap;
+#elif defined(SK_BUILD_FOR_WIN32)
+ HWND fWindow;
+ HDC fDeviceContext;
+ HGLRC fGlRenderContext;
+#else
+
+#endif
};
#endif
diff --git a/include/utils/android/AndroidKeyToSkKey.h b/include/utils/android/AndroidKeyToSkKey.h
new file mode 100644
index 0000000..7b0a035
--- /dev/null
+++ b/include/utils/android/AndroidKeyToSkKey.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2011 Skia
+ *
+ * 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.
+ */
+
+#ifndef _ANDROID_TO_SKIA_KEYCODES_H
+#define _ANDROID_TO_SKIA_KEYCODES_H
+
+#include "keycodes.h"
+#include "SkKey.h"
+
+// Convert an Android keycode to an SkKey. This is an incomplete list, only
+// including keys used by the sample app.
+SkKey AndroidKeycodeToSkKey(int keycode) {
+ switch (keycode) {
+ case AKEYCODE_DPAD_LEFT:
+ return kLeft_SkKey;
+ case AKEYCODE_DPAD_RIGHT:
+ return kRight_SkKey;
+ case AKEYCODE_DPAD_UP:
+ return kUp_SkKey;
+ case AKEYCODE_DPAD_DOWN:
+ return kDown_SkKey;
+ default:
+ return kNONE_SkKey;
+ }
+}
+
+#endif
diff --git a/include/utils/unix/XkeysToSkKeys.h b/include/utils/unix/XkeysToSkKeys.h
index 3d41a22..1852d99 100644
--- a/include/utils/unix/XkeysToSkKeys.h
+++ b/include/utils/unix/XkeysToSkKeys.h
@@ -8,6 +8,14 @@
SkKey XKeyToSkKey(KeySym keysym) {
switch (keysym) {
+ case XK_BackSpace:
+ return kBack_SkKey;
+ case XK_Return:
+ return kOK_SkKey;
+ case XK_Home:
+ return kHome_SkKey;
+ case XK_End:
+ return kEnd_SkKey;
case XK_Right:
return kRight_SkKey;
case XK_Left:
diff --git a/include/views/SkApplication.h b/include/views/SkApplication.h
new file mode 100644
index 0000000..4c4a4fb
--- /dev/null
+++ b/include/views/SkApplication.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2006 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.
+ */
+
+#ifndef SkApplication_DEFINED
+#define SkApplication_DEFINED
+
+class SkOSWindow;
+
+extern SkOSWindow* create_sk_window(void* hwnd);
+extern void application_init();
+extern void application_term();
+
+#endif // SkApplication_DEFINED
diff --git a/include/views/SkBGViewArtist.h b/include/views/SkBGViewArtist.h
new file mode 100644
index 0000000..1bca42f
--- /dev/null
+++ b/include/views/SkBGViewArtist.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2006 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.
+ */
+
+#ifndef SkBGViewArtist_DEFINED
+#define SkBGViewArtist_DEFINED
+
+#include "SkView.h"
+#include "SkPaint.h"
+
+class SkBGViewArtist : public SkView::Artist {
+public:
+ SkBGViewArtist(SkColor c = SK_ColorWHITE);
+ virtual ~SkBGViewArtist();
+
+ const SkPaint& paint() const { return fPaint; }
+ SkPaint& paint() { return fPaint; }
+
+protected:
+ // overrides
+ virtual void onDraw(SkView*, SkCanvas*);
+ virtual void onInflate(const SkDOM&, const SkDOM::Node*);
+
+private:
+ SkPaint fPaint;
+};
+
+#endif
+
diff --git a/include/views/SkBorderView.h b/include/views/SkBorderView.h
new file mode 100644
index 0000000..94ccc1f
--- /dev/null
+++ b/include/views/SkBorderView.h
@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2006 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.
+ */
+
+#ifndef SkBorderView_DEFINED
+#define SkBorderView_DEFINED
+
+#include "SkView.h"
+#include "SkWidgetViews.h"
+#include "SkAnimator.h"
+
+class SkBorderView : public SkWidgetView {
+public:
+ SkBorderView();
+ ~SkBorderView();
+ void setSkin(const char skin[]);
+ SkScalar getLeft() const { return fLeft; }
+ SkScalar getRight() const { return fRight; }
+ SkScalar getTop() const { return fTop; }
+ SkScalar getBottom() const { return fBottom; }
+protected:
+ //overrides
+ virtual void onInflate(const SkDOM& dom, const SkDOM::Node* node);
+ virtual void onSizeChange();
+ virtual void onDraw(SkCanvas* canvas);
+ virtual bool onEvent(const SkEvent& evt);
+private:
+ SkAnimator fAnim;
+ SkScalar fLeft, fRight, fTop, fBottom; //margin on each side
+ SkRect fMargin;
+
+ typedef SkWidgetView INHERITED;
+};
+
+#endif
+
diff --git a/include/views/SkEvent.h b/include/views/SkEvent.h
new file mode 100644
index 0000000..f6719d6
--- /dev/null
+++ b/include/views/SkEvent.h
@@ -0,0 +1,257 @@
+/*
+ * Copyright (C) 2006 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.
+ */
+
+#ifndef SkEvent_DEFINED
+#define SkEvent_DEFINED
+
+#include "SkDOM.h"
+#include "SkMetaData.h"
+#include "SkString.h"
+
+/** Unique 32bit id used to identify an instance of SkEventSink. When events are
+ posted, they are posted to a specific sinkID. When it is time to dispatch the
+ event, the sinkID is used to find the specific SkEventSink object. If it is found,
+ its doEvent() method is called with the event.
+*/
+typedef uint32_t SkEventSinkID;
+
+/** \class SkEvent
+
+ SkEvents are used to communicate type-safe information to SkEventSinks.
+ SkEventSinks (including SkViews) each have a unique ID, which is stored
+ in an event. This ID is used to target the event once it has been "posted".
+*/
+class SkEvent {
+public:
+ /** Default construct, creating an empty event.
+ */
+ SkEvent();
+ /** Construct a new event with the specified type.
+ */
+ explicit SkEvent(const SkString& type);
+ /** Construct a new event with the specified type.
+ */
+ explicit SkEvent(const char type[]);
+ /** Construct a new event by copying the fields from the src event.
+ */
+ SkEvent(const SkEvent& src);
+ ~SkEvent();
+
+// /** Return the event's type (will never be null) */
+// const char* getType() const;
+ /** Copy the event's type into the specified SkString parameter */
+ void getType(SkString* str) const;
+ /** Returns true if the event's type matches exactly the specified type (case sensitive) */
+ bool isType(const SkString& str) const;
+ /** Returns true if the event's type matches exactly the specified type (case sensitive) */
+ bool isType(const char type[], size_t len = 0) const;
+ /** Set the event's type to the specified string.
+ In XML, use the "type" attribute.
+ */
+ void setType(const SkString&);
+ /** Set the event's type to the specified string.
+ In XML, use the "type" attribute.
+ */
+ void setType(const char type[], size_t len = 0);
+
+ /** Return the event's unnamed 32bit field. Default value is 0 */
+ uint32_t getFast32() const { return f32; }
+ /** Set the event's unnamed 32bit field. In XML, use
+ the subelement <data fast32=... />
+ */
+ void setFast32(uint32_t x) { f32 = x; }
+
+ /** Return true if the event contains the named 32bit field, and return the field
+ in value (if value is non-null). If there is no matching named field, return false
+ and ignore the value parameter.
+ */
+ bool findS32(const char name[], int32_t* value = NULL) const { return fMeta.findS32(name, value); }
+ /** Return true if the event contains the named SkScalar field, and return the field
+ in value (if value is non-null). If there is no matching named field, return false
+ and ignore the value parameter.
+ */
+ bool findScalar(const char name[], SkScalar* value = NULL) const { return fMeta.findScalar(name, value); }
+ /** Return true if the event contains the named SkScalar field, and return the fields
+ in value[] (if value is non-null), and return the number of SkScalars in count (if count is non-null).
+ If there is no matching named field, return false and ignore the value and count parameters.
+ */
+ const SkScalar* findScalars(const char name[], int* count, SkScalar values[] = NULL) const { return fMeta.findScalars(name, count, values); }
+ /** Return the value of the named string field, or if no matching named field exists, return null.
+ */
+ const char* findString(const char name[]) const { return fMeta.findString(name); }
+ /** Return true if the event contains the named pointer field, and return the field
+ in value (if value is non-null). If there is no matching named field, return false
+ and ignore the value parameter.
+ */
+ bool findPtr(const char name[], void** value) const { return fMeta.findPtr(name, value); }
+ bool findBool(const char name[], bool* value) const { return fMeta.findBool(name, value); }
+ const void* findData(const char name[], size_t* byteCount = NULL) const {
+ return fMeta.findData(name, byteCount);
+ }
+
+ /** Returns true if ethe event contains the named 32bit field, and if it equals the specified value */
+ bool hasS32(const char name[], int32_t value) const { return fMeta.hasS32(name, value); }
+ /** Returns true if ethe event contains the named SkScalar field, and if it equals the specified value */
+ bool hasScalar(const char name[], SkScalar value) const { return fMeta.hasScalar(name, value); }
+ /** Returns true if ethe event contains the named string field, and if it equals (using strcmp) the specified value */
+ bool hasString(const char name[], const char value[]) const { return fMeta.hasString(name, value); }
+ /** Returns true if ethe event contains the named pointer field, and if it equals the specified value */
+ bool hasPtr(const char name[], void* value) const { return fMeta.hasPtr(name, value); }
+ bool hasBool(const char name[], bool value) const { return fMeta.hasBool(name, value); }
+ bool hasData(const char name[], const void* data, size_t byteCount) const {
+ return fMeta.hasData(name, data, byteCount);
+ }
+
+ /** Add/replace the named 32bit field to the event. In XML use the subelement <data name=... s32=... /> */
+ void setS32(const char name[], int32_t value) { fMeta.setS32(name, value); }
+ /** Add/replace the named SkScalar field to the event. In XML use the subelement <data name=... scalar=... /> */
+ void setScalar(const char name[], SkScalar value) { fMeta.setScalar(name, value); }
+ /** Add/replace the named SkScalar[] field to the event. */
+ SkScalar* setScalars(const char name[], int count, const SkScalar values[] = NULL) { return fMeta.setScalars(name, count, values); }
+ /** Add/replace the named string field to the event. In XML use the subelement <data name=... string=... */
+ void setString(const char name[], const SkString& value) { fMeta.setString(name, value.c_str()); }
+ /** Add/replace the named string field to the event. In XML use the subelement <data name=... string=... */
+ void setString(const char name[], const char value[]) { fMeta.setString(name, value); }
+ /** Add/replace the named pointer field to the event. There is no XML equivalent for this call */
+ void setPtr(const char name[], void* value) { fMeta.setPtr(name, value); }
+ void setBool(const char name[], bool value) { fMeta.setBool(name, value); }
+ void setData(const char name[], const void* data, size_t byteCount) {
+ fMeta.setData(name, data, byteCount);
+ }
+
+ /** Return the underlying metadata object */
+ SkMetaData& getMetaData() { return fMeta; }
+ /** Return the underlying metadata object */
+ const SkMetaData& getMetaData() const { return fMeta; }
+
+ void tron() { SkDEBUGCODE(fDebugTrace = true;) }
+ void troff() { SkDEBUGCODE(fDebugTrace = false;) }
+ bool isDebugTrace() const
+ {
+#ifdef SK_DEBUG
+ return fDebugTrace;
+#else
+ return false;
+#endif
+ }
+
+ /** Call this to initialize the event from the specified XML node */
+ void inflate(const SkDOM&, const SkDOM::Node*);
+
+ SkDEBUGCODE(void dump(const char title[] = NULL);)
+
+ /** Post the specified event to the event queue, targeting the specified eventsink, with an optional
+ delay. The event must be dynamically allocated for this. It cannot be a global or on the stack.
+ After this call, ownership is transfered to the system, so the caller must not retain
+ the event's ptr. Returns false if the event could not be posted (which means it will have been deleted).
+ */
+ static bool Post(SkEvent* evt, SkEventSinkID targetID, SkMSec delay = 0);
+ /** Post the specified event to the event queue, targeting the specified eventsink, to be delivered on/after the
+ specified millisecond time. The event must be dynamically allocated for this. It cannot be a global or on the stack.
+ After this call, ownership is transfered to the system, so the caller must not retain
+ the event's ptr. Returns false if the event could not be posted (which means it will have been deleted).
+ */
+ static bool PostTime(SkEvent* evt, SkEventSinkID targetID, SkMSec time);
+
+ /** Helper method for calling SkEvent::PostTime(this, ...), where the caller specifies a delay.
+ The real "time" will be computed automatically by sampling the clock and adding its value
+ to delay.
+ */
+ bool post(SkEventSinkID sinkID, SkMSec delay = 0)
+ {
+ return SkEvent::Post(this, sinkID, delay);
+ }
+
+ void postTime(SkEventSinkID sinkID, SkMSec time)
+ {
+ SkEvent::PostTime(this, sinkID, time);
+ }
+
+ ///////////////////////////////////////////////
+ /** Porting layer must call these functions **/
+ ///////////////////////////////////////////////
+
+ /** Global initialization function for the SkEvent system. Should be called exactly
+ once before any other event method is called, and should be called after the
+ call to SkGraphics::Init().
+ */
+ static void Init();
+ /** Global cleanup function for the SkEvent system. Should be called exactly once after
+ all event methods have been called, and should be called before calling SkGraphics::Term().
+ */
+ static void Term();
+
+ /** Call this to process one event from the queue. If it returns true, there are more events
+ to process.
+ */
+ static bool ProcessEvent();
+ /** Call this whenever the requested timer has expired (requested by a call to SetQueueTimer).
+ It will post any delayed events whose time as "expired" onto the event queue.
+ It may also call SignalQueueTimer() and SignalNonEmptyQueue().
+ */
+ static void ServiceQueueTimer();
+
+ /** Return the number of queued events. note that this value may be obsolete
+ upon return, since another thread may have called ProcessEvent() or
+ Post() after the count was made.
+ */
+ static int CountEventsOnQueue();
+
+ ////////////////////////////////////////////////////
+ /** Porting layer must implement these functions **/
+ ////////////////////////////////////////////////////
+
+ /** Called whenever an SkEvent is posted to an empty queue, so that the OS
+ can be told to later call Dequeue().
+ */
+ static void SignalNonEmptyQueue();
+ /** Called whenever the delay until the next delayed event changes. If zero is
+ passed, then there are no more queued delay events.
+ */
+ static void SignalQueueTimer(SkMSec delay);
+
+#ifndef SK_USE_WXWIDGETS
+#ifdef SK_BUILD_FOR_WIN
+ static bool WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
+#elif defined(SK_BUILD_FOR_UNIXx)
+ static uint32_t HandleTimer(uint32_t, void*);
+ static bool WndProc(Display*, Window, XEvent&);
+#endif
+#else
+ // Don't know yet what this will be
+ //static bool CustomEvent();
+#endif
+
+private:
+ SkMetaData fMeta;
+ mutable char* fType; // may be characters with low bit set to know that it is not a pointer
+ uint32_t f32;
+ SkDEBUGCODE(bool fDebugTrace;)
+
+ // these are for our implementation of the event queue
+ SkEventSinkID fTargetID;
+ SkMSec fTime;
+ SkEvent* fNextEvent; // either in the delay or normal event queue
+ void initialize(const char* type, size_t typeLen);
+
+ static bool Enqueue(SkEvent* evt);
+ static SkMSec EnqueueTime(SkEvent* evt, SkMSec time);
+ static SkEvent* Dequeue(SkEventSinkID* targetID);
+ static bool QHasEvents();
+};
+
+#endif
+
diff --git a/include/views/SkEventSink.h b/include/views/SkEventSink.h
new file mode 100644
index 0000000..27a6743
--- /dev/null
+++ b/include/views/SkEventSink.h
@@ -0,0 +1,103 @@
+/*
+ * Copyright (C) 2006 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.
+ */
+
+#ifndef SkEventSink_DEFINED
+#define SkEventSink_DEFINED
+
+#include "SkRefCnt.h"
+#include "SkEvent.h"
+
+struct SkTagList;
+
+/** \class SkEventSink
+
+ SkEventSink is the base class for all objects that receive SkEvents.
+*/
+class SkEventSink : public SkRefCnt {
+public:
+ SkEventSink();
+ virtual ~SkEventSink();
+
+ /** Returns this eventsink's unique ID. Use this to post SkEvents to
+ this eventsink.
+ */
+ SkEventSinkID getSinkID() const { return fID; }
+
+ /** Call this to pass an event to this object for processing. Returns true if the
+ event was handled.
+ */
+ bool doEvent(const SkEvent&);
+ /** Returns true if the sink (or one of its subclasses) understands the event as a query.
+ If so, the sink may modify the event to communicate its "answer".
+ */
+ bool doQuery(SkEvent* query);
+
+ /** Add sinkID to the list of listeners, to receive events from calls to sendToListeners()
+ and postToListeners(). If sinkID already exists in the listener list, no change is made.
+ */
+ void addListenerID(SkEventSinkID sinkID);
+ /** Copy listeners from one event sink to another, typically from parent to child.
+ @param from the event sink to copy the listeners from
+ */
+ void copyListeners(const SkEventSink& from);
+ /** Remove sinkID from the list of listeners. If sinkID does not appear in the list,
+ no change is made.
+ */
+ void removeListenerID(SkEventSinkID);
+ /** Returns true if there are 1 or more listeners attached to this eventsink
+ */
+ bool hasListeners() const;
+ /** Posts a copy of evt to each of the eventsinks in the lisener list.
+ */
+ void postToListeners(const SkEvent& evt, SkMSec delay = 0);
+
+ enum EventResult {
+ kHandled_EventResult, //!< the eventsink returned true from its doEvent method
+ kNotHandled_EventResult, //!< the eventsink returned false from its doEvent method
+ kSinkNotFound_EventResult //!< no matching eventsink was found for the event's getSink().
+ };
+ /** DoEvent handles searching for an eventsink object that matches the targetID.
+ If one is found, it calls the sink's doEvent method, returning
+ either kHandled_EventResult or kNotHandled_EventResult. If no matching
+ eventsink is found, kSinkNotFound_EventResult is returned.
+ */
+ static EventResult DoEvent(const SkEvent&, SkEventSinkID targetID);
+
+ /** Returns the matching eventsink, or null if not found
+ */
+ static SkEventSink* FindSink(SkEventSinkID);
+
+protected:
+ /** Override this to handle events in your subclass. Be sure to call the inherited version
+ for events that you don't handle.
+ */
+ virtual bool onEvent(const SkEvent&);
+ virtual bool onQuery(SkEvent*);
+
+ SkTagList* findTagList(U8CPU tag) const;
+ void addTagList(SkTagList*);
+ void removeTagList(U8CPU tag);
+
+private:
+ SkEventSinkID fID;
+ SkTagList* fTagHead;
+
+ // for our private link-list
+ SkEventSink* fNextSink;
+};
+
+#endif
+
diff --git a/include/views/SkImageView.h b/include/views/SkImageView.h
new file mode 100644
index 0000000..57215c9
--- /dev/null
+++ b/include/views/SkImageView.h
@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 2006 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.
+ */
+
+#ifndef SkImageView_DEFINED
+#define SkImageView_DEFINED
+
+#include "SkView.h"
+#include "SkString.h"
+
+class SkAnimator;
+class SkBitmap;
+class SkMatrix;
+
+class SkImageView : public SkView {
+public:
+ SkImageView();
+ virtual ~SkImageView();
+
+ void getUri(SkString*) const;
+ void setUri(const char []);
+ void setUri(const SkString&);
+
+
+ enum ScaleType {
+ kMatrix_ScaleType,
+ kFitXY_ScaleType,
+ kFitStart_ScaleType,
+ kFitCenter_ScaleType,
+ kFitEnd_ScaleType
+ };
+ ScaleType getScaleType() const { return (ScaleType)fScaleType; }
+ void setScaleType(ScaleType);
+
+ bool getImageMatrix(SkMatrix*) const;
+ void setImageMatrix(const SkMatrix*);
+
+protected:
+ // overrides
+ virtual bool onEvent(const SkEvent&);
+ virtual void onDraw(SkCanvas*);
+ virtual void onInflate(const SkDOM&, const SkDOMNode*);
+
+private:
+ SkString fUri;
+ SkMatrix* fMatrix; // null or copy of caller's matrix ,,,,,
+ union {
+ SkAnimator* fAnim;
+ SkBitmap* fBitmap;
+ } fData;
+ uint8_t fScaleType;
+ SkBool8 fDataIsAnim; // as opposed to bitmap
+ SkBool8 fUriIsValid;
+
+ void onUriChange();
+ bool getDataBounds(SkRect* bounds);
+ bool freeData();
+ bool ensureUriIsLoaded();
+
+ typedef SkView INHERITED;
+};
+
+#endif
diff --git a/include/views/SkKey.h b/include/views/SkKey.h
new file mode 100644
index 0000000..3fd5114
--- /dev/null
+++ b/include/views/SkKey.h
@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2006 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.
+ */
+
+#ifndef SkKey_DEFINED
+#define SkKey_DEFINED
+
+#include "SkTypes.h"
+
+enum SkKey {
+ //reordering these to match android.app.KeyEvent
+ kNONE_SkKey, //corresponds to android's UNKNOWN
+
+ kLeftSoftKey_SkKey,
+ kRightSoftKey_SkKey,
+
+ kHome_SkKey, //!< the home key - added to match android
+ kBack_SkKey, //!< (CLR)
+ kSend_SkKey, //!< the green (talk) key
+ kEnd_SkKey, //!< the red key
+
+ k0_SkKey,
+ k1_SkKey,
+ k2_SkKey,
+ k3_SkKey,
+ k4_SkKey,
+ k5_SkKey,
+ k6_SkKey,
+ k7_SkKey,
+ k8_SkKey,
+ k9_SkKey,
+ kStar_SkKey, //!< the * key
+ kHash_SkKey, //!< the # key
+
+ kUp_SkKey,
+ kDown_SkKey,
+ kLeft_SkKey,
+ kRight_SkKey,
+
+ kOK_SkKey, //!< the center key
+
+ kVolUp_SkKey, //!< volume up - match android
+ kVolDown_SkKey, //!< volume down - same
+ kPower_SkKey, //!< power button - same
+ kCamera_SkKey, //!< camera - same
+
+ kSkKeyCount
+};
+
+#endif
+
diff --git a/include/views/SkOSMenu.h b/include/views/SkOSMenu.h
new file mode 100644
index 0000000..433a601
--- /dev/null
+++ b/include/views/SkOSMenu.h
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2006 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.
+ */
+
+#ifndef SkOSMenu_DEFINED
+#define SkOSMenu_DEFINED
+
+#include "SkEvent.h"
+#include "SkTDArray.h"
+
+class SkOSMenu {
+public:
+ explicit SkOSMenu(const char title[]);
+ ~SkOSMenu();
+
+ const char* getTitle() const { return fTitle; }
+
+ void appendItem(const char title[], const char eventType[], int32_t eventData);
+
+ // called by SkOSWindow when it receives an OS menu event
+ int countItems() const;
+ const char* getItem(int index, uint32_t* cmdID) const;
+
+ SkEvent* createEvent(uint32_t os_cmd);
+
+private:
+ const char* fTitle;
+
+ struct Item {
+ const char* fTitle;
+ const char* fEventType;
+ uint32_t fEventData;
+ uint32_t fOSCmd; // internal
+ };
+ SkTDArray<Item> fItems;
+
+ // illegal
+ SkOSMenu(const SkOSMenu&);
+ SkOSMenu& operator=(const SkOSMenu&);
+};
+
+#endif
+
diff --git a/include/views/SkOSWindow_Android.h b/include/views/SkOSWindow_Android.h
new file mode 100644
index 0000000..38a4cf8
--- /dev/null
+++ b/include/views/SkOSWindow_Android.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2011 Skia
+ *
+ * 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.
+ */
+
+#ifndef SkOSWindow_Android_DEFINED
+#define SkOSWindow_Android_DEFINED
+
+#include "SkWindow.h"
+#include "SkEvent.h"
+
+class SkOSWindow : public SkWindow {
+public:
+ SkOSWindow(void*) {}
+ ~SkOSWindow() {}
+ bool attachGL() { return false; }
+ void detachGL() {}
+ void presentGL() {}
+
+protected:
+ // overrides from SkWindow
+ virtual void onHandleInval(const SkIRect&);
+ virtual void onSetTitle(const char title[]);
+
+private:
+ typedef SkWindow INHERITED;
+};
+
+#endif
+
diff --git a/include/views/SkOSWindow_Mac.h b/include/views/SkOSWindow_Mac.h
new file mode 100644
index 0000000..232a202
--- /dev/null
+++ b/include/views/SkOSWindow_Mac.h
@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2006 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.
+ */
+
+#ifndef SkOSWindow_Mac_DEFINED
+#define SkOSWindow_Mac_DEFINED
+
+#include <Carbon/Carbon.h>
+#include "SkWindow.h"
+
+class SkOSWindow : public SkWindow {
+public:
+ SkOSWindow(void* hwnd);
+
+ void* getHWND() const { return fHWND; }
+ void* getHVIEW() const { return fHVIEW; }
+ void updateSize();
+
+ static bool PostEvent(SkEvent* evt, SkEventSinkID, SkMSec delay);
+
+ static OSStatus EventHandler(EventHandlerCallRef inHandler,
+ EventRef inEvent, void* userData);
+
+ void doPaint(void* ctx);
+
+
+ bool attachGL();
+ void detachGL();
+ void presentGL();
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onEvent(const SkEvent& evt);
+ // overrides from SkWindow
+ virtual void onHandleInval(const SkIRect&);
+ // overrides from SkView
+ virtual void onAddMenu(const SkOSMenu*);
+ virtual void onSetTitle(const char[]);
+
+
+private:
+ void* fHWND;
+ void* fHVIEW;
+ void* fAGLCtx;
+
+ typedef SkWindow INHERITED;
+};
+
+#endif
+
diff --git a/include/views/SkOSWindow_SDL.h b/include/views/SkOSWindow_SDL.h
new file mode 100644
index 0000000..0ff24f3
--- /dev/null
+++ b/include/views/SkOSWindow_SDL.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2006 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.
+ */
+
+#ifndef SkOSWindow_SDL_DEFINED
+#define SkOSWindow_SDL_DEFINED
+
+#include "SDL.h"
+#include "SkWindow.h"
+
+class SkGLCanvas;
+
+class SkOSWindow : public SkWindow {
+public:
+ SkOSWindow(void* screen);
+ virtual ~SkOSWindow();
+
+ static bool PostEvent(SkEvent* evt, SkEventSinkID, SkMSec delay);
+
+ void handleSDLEvent(const SDL_Event& event);
+
+protected:
+ // overrides from SkWindow
+ virtual void onHandleInval(const SkIRect&);
+ // overrides from SkView
+ virtual void onAddMenu(const SkOSMenu*);
+ virtual void onSetTitle(const char[]);
+
+private:
+ SDL_Surface* fScreen;
+ SDL_Surface* fSurface;
+ SkGLCanvas* fGLCanvas;
+
+ void doDraw();
+
+ typedef SkWindow INHERITED;
+};
+
+#endif
+
diff --git a/include/views/SkOSWindow_Unix.h b/include/views/SkOSWindow_Unix.h
new file mode 100644
index 0000000..803ca13
--- /dev/null
+++ b/include/views/SkOSWindow_Unix.h
@@ -0,0 +1,79 @@
+/*
+ * Copyright (C) 2006 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.
+ */
+
+#ifndef SkOSWindow_Unix_DEFINED
+#define SkOSWindow_Unix_DEFINED
+
+#include "SkWindow.h"
+#include <X11/Xlib.h>
+#include <GL/glx.h>
+
+class SkBitmap;
+class SkEvent;
+
+struct SkUnixWindow {
+ Display* fDisplay;
+ Window fWin;
+ size_t fOSWin;
+ GC fGc;
+ GLXContext fGLContext;
+ bool fGLCreated;
+};
+
+class SkOSWindow : public SkWindow {
+public:
+ SkOSWindow(void*);
+ ~SkOSWindow();
+
+ void* getHWND() const { return (void*)fUnixWindow.fWin; }
+ void* getDisplay() const { return (void*)fUnixWindow.fDisplay; }
+ void* getUnixWindow() const { return (void*)&fUnixWindow; }
+ void loop();
+ void post_linuxevent();
+ bool attachGL();
+ void detachGL();
+ void presentGL();
+
+ //static bool PostEvent(SkEvent* evt, SkEventSinkID, SkMSec delay);
+
+ //static bool WndProc(SkUnixWindow* w, XEvent &e);
+
+protected:
+ // overrides from SkWindow
+ virtual bool onEvent(const SkEvent&);
+ virtual void onHandleInval(const SkIRect&);
+ virtual bool onHandleChar(SkUnichar);
+ virtual bool onHandleKey(SkKey);
+ virtual bool onHandleKeyUp(SkKey);
+ virtual void onSetTitle(const char title[]);
+
+private:
+ SkUnixWindow fUnixWindow;
+ bool fGLAttached;
+ bool fRestart;
+
+ // Needed for GL
+ XVisualInfo* fVi;
+
+ void doPaint();
+ void restartLoop();
+ void mapWindowAndWait();
+
+ typedef SkWindow INHERITED;
+};
+
+#endif
+
diff --git a/include/views/SkOSWindow_Win.h b/include/views/SkOSWindow_Win.h
new file mode 100644
index 0000000..4b3e916
--- /dev/null
+++ b/include/views/SkOSWindow_Win.h
@@ -0,0 +1,79 @@
+/*
+ * Copyright (C) 2006 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.
+ */
+
+#ifndef SkOSWindow_Win_DEFINED
+#define SkOSWindow_Win_DEFINED
+
+#include "SkWindow.h"
+
+class SkOSWindow : public SkWindow {
+public:
+ SkOSWindow(void* hwnd);
+ virtual ~SkOSWindow();
+
+ void* getHWND() const { return fHWND; }
+ void setSize(int width, int height);
+ void updateSize();
+
+ static bool PostEvent(SkEvent* evt, SkEventSinkID, SkMSec delay);
+
+ bool attachGL();
+ void detachGL();
+ void presentGL();
+
+ bool attachD3D9();
+ void detachD3D9();
+ void presentD3D9();
+
+ void* d3d9Device() { return fD3D9Device; }
+
+ bool wndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
+ static bool QuitOnDeactivate(HWND hWnd);
+
+ enum {
+ SK_WM_SkEvent = WM_APP + 1000,
+ SK_WM_SkTimerID = 0xFFFF // just need a non-zero value
+ };
+
+protected:
+ virtual bool quitOnDeactivate() { return true; }
+
+ // overrides from SkWindow
+ virtual void onHandleInval(const SkIRect&);
+ // overrides from SkView
+ virtual void onAddMenu(const SkOSMenu*);
+
+ virtual void onSetTitle(const char title[]);
+
+private:
+ void* fHWND;
+
+ void doPaint(void* ctx);
+
+ void* fHGLRC;
+
+ bool fGLAttached;
+
+ void* fD3D9Device;
+ bool fD3D9Attached;
+
+ HMENU fMBar;
+
+ typedef SkWindow INHERITED;
+};
+
+#endif
+
diff --git a/include/views/SkOSWindow_wxwidgets.h b/include/views/SkOSWindow_wxwidgets.h
new file mode 100644
index 0000000..c5dfc7c
--- /dev/null
+++ b/include/views/SkOSWindow_wxwidgets.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2006 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.
+ */
+
+/*
+ * SkOSWindow_wxwidgets.h
+ * wxwidgets
+ *
+ * Copyright 2005 __MyCompanyName__. All rights reserved.
+ *
+ */
+
+#ifndef SkOSWindow_wxwidgets_DEFINED
+#define SkOSWindow_wxwidgets_DEFINED
+
+#include "SkWindow.h"
+#include "wx/frame.h"
+
+class SkOSWindow: public SkWindow
+{
+public:
+ SkOSWindow();
+ SkOSWindow(const wxString& title, int x, int y, int width, int height);
+ ~SkOSWindow();
+
+ wxFrame* getWXFrame() const { return fFrame; }
+
+ void updateSize();
+
+protected:
+ virtual void onHandleInval(const SkIRect&);
+ virtual void onAddMenu(const SkOSMenu*);
+
+private:
+ wxFrame* fFrame;
+ typedef SkWindow INHERITED;
+
+};
+
+#endifpedef SkWindow INHERITED;
diff --git a/include/views/SkProgressBarView.h b/include/views/SkProgressBarView.h
new file mode 100644
index 0000000..6341fcb
--- /dev/null
+++ b/include/views/SkProgressBarView.h
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2006 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.
+ */
+
+#ifndef SkProgressBarView_DEFINED
+#define SkProgressBarView_DEFINED
+
+#include "SkView.h"
+#include "SkWidgetViews.h"
+#include "SkAnimator.h"
+
+class SkProgressBarView : public SkWidgetView {
+ public:
+ SkProgressBarView();
+ //SkProgressBarView(int max);
+
+ //inflate: "sk-progress"
+
+ void reset(); //reset progress to zero
+ void setProgress(int progress);
+ void changeProgress(int diff);
+ void setMax(int max);
+
+ int getProgress() const { return fProgress; }
+ int getMax() const { return fMax; }
+
+ protected:
+ //overrides
+ virtual void onInflate(const SkDOM& dom, const SkDOM::Node* node);
+ virtual void onSizeChange();
+ virtual void onDraw(SkCanvas* canvas);
+ virtual bool onEvent(const SkEvent& evt);
+
+ private:
+ SkAnimator fAnim;
+ int fProgress;
+ int fMax;
+
+ typedef SkWidgetView INHERITED;
+};
+
+
+
+
+#endif
diff --git a/include/views/SkScrollBarView.h b/include/views/SkScrollBarView.h
new file mode 100644
index 0000000..b8a5209
--- /dev/null
+++ b/include/views/SkScrollBarView.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2006 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.
+ */
+
+#ifndef SkScrollBarView_DEFINED
+#define SkScrollBarView_DEFINED
+
+#include "SkView.h"
+#include "SkWidgetViews.h"
+#include "SkAnimator.h"
+
+class SkScrollBarView : public SkWidgetView {
+public:
+ SkScrollBarView();
+
+ unsigned getStart() const { return fStartPoint; }
+ unsigned getShown() const { return fShownLength; }
+ unsigned getTotal() const { return fTotalLength; }
+
+ void setStart(unsigned start);
+ void setShown(unsigned shown);
+ void setTotal(unsigned total);
+
+protected:
+ //overrides
+ virtual void onInflate(const SkDOM& dom, const SkDOM::Node* node);
+ virtual void onSizeChange();
+ virtual void onDraw(SkCanvas* canvas);
+ virtual bool onEvent(const SkEvent& evt);
+
+private:
+ SkAnimator fAnim;
+ unsigned fTotalLength, fStartPoint, fShownLength;
+
+ void adjust();
+
+ typedef SkWidgetView INHERITED;
+};
+#endif
+
diff --git a/include/views/SkStackViewLayout.h b/include/views/SkStackViewLayout.h
new file mode 100644
index 0000000..8000319
--- /dev/null
+++ b/include/views/SkStackViewLayout.h
@@ -0,0 +1,96 @@
+/*
+ * Copyright (C) 2006 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.
+ */
+
+#ifndef SkStackViewLayout_DEFINED
+#define SkStackViewLayout_DEFINED
+
+#include "SkView.h"
+
+class SkStackViewLayout : public SkView::Layout {
+public:
+ SkStackViewLayout();
+
+ enum Orient {
+ kHorizontal_Orient,
+ kVertical_Orient,
+
+ kOrientCount
+ };
+ Orient getOrient() const { return (Orient)fOrient; }
+ void setOrient(Orient);
+
+ void getMargin(SkRect*) const;
+ void setMargin(const SkRect&);
+
+ SkScalar getSpacer() const { return fSpacer; }
+ void setSpacer(SkScalar);
+
+ /** Controls the posititioning in the same direction as the orientation
+ */
+ enum Pack {
+ kStart_Pack,
+ kCenter_Pack,
+ kEnd_Pack,
+
+ kPackCount
+ };
+ Pack getPack() const { return (Pack)fPack; }
+ void setPack(Pack);
+
+ /** Controls the posititioning at right angles to the orientation
+ */
+ enum Align {
+ kStart_Align,
+ kCenter_Align,
+ kEnd_Align,
+ kStretch_Align,
+
+ kAlignCount
+ };
+ Align getAlign() const { return (Align)fAlign; }
+ void setAlign(Align);
+
+ bool getRound() const { return SkToBool(fRound); }
+ void setRound(bool);
+
+protected:
+ virtual void onLayoutChildren(SkView* parent);
+ virtual void onInflate(const SkDOM&, const SkDOM::Node*);
+
+private:
+ SkRect fMargin;
+ SkScalar fSpacer;
+ uint8_t fOrient, fPack, fAlign, fRound;
+};
+
+class SkFillViewLayout : public SkView::Layout {
+public:
+ SkFillViewLayout();
+ void getMargin(SkRect*) const;
+ void setMargin(const SkRect&);
+
+protected:
+ // overrides;
+ virtual void onLayoutChildren(SkView* parent);
+ virtual void onInflate(const SkDOM& dom, const SkDOM::Node* node);
+
+private:
+ SkRect fMargin;
+ typedef SkView::Layout INHERITED;
+};
+
+#endif
+
diff --git a/include/views/SkSystemEventTypes.h b/include/views/SkSystemEventTypes.h
new file mode 100644
index 0000000..8dfe8be
--- /dev/null
+++ b/include/views/SkSystemEventTypes.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2006 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.
+ */
+
+#ifndef SkSystemEventTypes_DEFINED
+#define SkSystemEventTypes_DEFINED
+
+/*
+ The goal of these strings is two-fold:
+ 1) make funny strings (containing at least one char < 32) to avoid colliding with "user" strings
+ 2) keep them <= 4 bytes, so we can avoid an allocation in SkEvent::setType()
+*/
+#define SK_EventType_Delay "\xd" "lay"
+#define SK_EventType_Inval "nv" "\xa" "l"
+#define SK_EventType_Key "key" "\x1"
+#define SK_EventType_OnEnd "on" "\xe" "n"
+#define SK_EventType_Unichar "\xc" "har"
+#define SK_EventType_KeyUp "key" "\xf"
+
+#endif
diff --git a/include/views/SkTouchGesture.h b/include/views/SkTouchGesture.h
new file mode 100644
index 0000000..79d4e28
--- /dev/null
+++ b/include/views/SkTouchGesture.h
@@ -0,0 +1,72 @@
+#ifndef SkTouchGesture_DEFINED
+#define SkTouchGesture_DEFINED
+
+#include "SkTDArray.h"
+#include "SkMatrix.h"
+
+struct SkFlingState {
+ SkFlingState() : fActive(false) {}
+
+ bool isActive() const { return fActive; }
+ void stop() { fActive = false; }
+
+ void reset(float sx, float sy);
+ bool evaluateMatrix(SkMatrix* matrix);
+
+private:
+ SkPoint fDirection;
+ SkScalar fSpeed0;
+ double fTime0;
+ bool fActive;
+};
+
+class SkTouchGesture {
+public:
+ SkTouchGesture();
+ ~SkTouchGesture();
+
+ void touchBegin(void* owner, float x, float y);
+ void touchMoved(void* owner, float x, float y);
+ void touchEnd(void* owner);
+ void reset();
+
+ bool isActive() { return fFlinger.isActive(); }
+ void stop() { fFlinger.stop(); }
+
+ const SkMatrix& localM();
+ const SkMatrix& globalM() const { return fGlobalM; }
+
+private:
+ enum State {
+ kEmpty_State,
+ kTranslate_State,
+ kZoom_State,
+ };
+
+ struct Rec {
+ void* fOwner;
+ float fStartX, fStartY;
+ float fPrevX, fPrevY;
+ float fLastX, fLastY;
+ SkMSec fPrevT, fLastT;
+ };
+ SkTDArray<Rec> fTouches;
+
+ State fState;
+ SkMatrix fLocalM, fGlobalM;
+ SkFlingState fFlinger;
+ SkMSec fLastUpT;
+ SkPoint fLastUpP;
+
+
+ void flushLocalM();
+ int findRec(void* owner) const;
+ void appendNewRec(void* owner, float x, float y);
+ float computePinch(const Rec&, const Rec&);
+ float limitTotalZoom(float scale) const;
+ bool handleDblTap(float, float);
+};
+
+#endif
+
+
diff --git a/include/views/SkView.h b/include/views/SkView.h
new file mode 100644
index 0000000..d3633db
--- /dev/null
+++ b/include/views/SkView.h
@@ -0,0 +1,370 @@
+/*
+ * Copyright (C) 2006 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.
+ */
+
+#ifndef SkView_DEFINED
+#define SkView_DEFINED
+
+#include "SkEventSink.h"
+#include "SkRect.h"
+#include "SkDOM.h"
+#include "SkTDict.h"
+
+class SkCanvas;
+class SkLayerView;
+
+/** \class SkView
+
+ SkView is the base class for screen management. All widgets and controls inherit
+ from SkView.
+*/
+class SkView : public SkEventSink {
+public:
+ enum Flag_Shift {
+ kVisible_Shift,
+ kEnabled_Shift,
+ kFocusable_Shift,
+ kFlexH_Shift,
+ kFlexV_Shift,
+ kNoClip_Shift,
+
+ kFlagShiftCount
+ };
+ enum Flag_Mask {
+ kVisible_Mask = 1 << kVisible_Shift, //!< set if the view is visible
+ kEnabled_Mask = 1 << kEnabled_Shift, //!< set if the view is enabled
+ kFocusable_Mask = 1 << kFocusable_Shift, //!< set if the view can receive focus
+ kFlexH_Mask = 1 << kFlexH_Shift, //!< set if the view's width is stretchable
+ kFlexV_Mask = 1 << kFlexV_Shift, //!< set if the view's height is stretchable
+ kNoClip_Mask = 1 << kNoClip_Shift, //!< set if the view is not clipped to its bounds
+
+ kAllFlagMasks = (uint32_t)(0 - 1) >> (32 - kFlagShiftCount)
+ };
+
+ SkView(uint32_t flags = 0);
+ virtual ~SkView();
+
+ /** Return the flags associated with the view
+ */
+ uint32_t getFlags() const { return fFlags; }
+ /** Set the flags associated with the view
+ */
+ void setFlags(uint32_t flags);
+
+ /** Helper that returns non-zero if the kVisible_Mask bit is set in the view's flags
+ */
+ int isVisible() const { return fFlags & kVisible_Mask; }
+ int isEnabled() const { return fFlags & kEnabled_Mask; }
+ int isFocusable() const { return fFlags & kFocusable_Mask; }
+ int isClipToBounds() const { return !(fFlags & kNoClip_Mask); }
+ /** Helper to set/clear the view's kVisible_Mask flag */
+ void setVisibleP(bool);
+ void setEnabledP(bool);
+ void setFocusableP(bool);
+ void setClipToBounds(bool);
+
+ /** Return the view's width */
+ SkScalar width() const { return fWidth; }
+ /** Return the view's height */
+ SkScalar height() const { return fHeight; }
+ /** Set the view's width and height. These must both be >= 0. This does not affect the view's loc */
+ void setSize(SkScalar width, SkScalar height);
+ void setSize(const SkPoint& size) { this->setSize(size.fX, size.fY); }
+ void setWidth(SkScalar width) { this->setSize(width, fHeight); }
+ void setHeight(SkScalar height) { this->setSize(fWidth, height); }
+ /** Return a rectangle set to [0, 0, width, height] */
+ void getLocalBounds(SkRect* bounds) const;
+
+ /** Return the view's left edge */
+ SkScalar locX() const { return fLoc.fX; }
+ /** Return the view's top edge */
+ SkScalar locY() const { return fLoc.fY; }
+ /** Set the view's left and top edge. This does not affect the view's size */
+ void setLoc(SkScalar x, SkScalar y);
+ void setLoc(const SkPoint& loc) { this->setLoc(loc.fX, loc.fY); }
+ void setLocX(SkScalar x) { this->setLoc(x, fLoc.fY); }
+ void setLocY(SkScalar y) { this->setLoc(fLoc.fX, y); }
+ /** Offset (move) the view by the specified dx and dy. This does not affect the view's size */
+ void offset(SkScalar dx, SkScalar dy);
+
+ /** Call this to have the view draw into the specified canvas. */
+ virtual void draw(SkCanvas* canvas);
+
+ /** Call this to invalidate part of all of a view, requesting that the view's
+ draw method be called. The rectangle parameter specifies the part of the view
+ that should be redrawn. If it is null, it specifies the entire view bounds.
+ */
+ void inval(SkRect* rectOrNull);
+
+ // Focus management
+
+ SkView* getFocusView() const;
+ bool hasFocus() const;
+
+ enum FocusDirection {
+ kNext_FocusDirection,
+ kPrev_FocusDirection,
+
+ kFocusDirectionCount
+ };
+ bool acceptFocus();
+ SkView* moveFocus(FocusDirection);
+
+ // Click handling
+
+ class Click {
+ public:
+ Click(SkView* target);
+ virtual ~Click();
+
+ const char* getType() const { return fType; }
+ bool isType(const char type[]) const;
+ void setType(const char type[]); // does NOT make a copy of the string
+ void copyType(const char type[]); // makes a copy of the string
+
+ enum State {
+ kDown_State,
+ kMoved_State,
+ kUp_State
+ };
+ SkPoint fOrig, fPrev, fCurr;
+ SkIPoint fIOrig, fIPrev, fICurr;
+ State fState;
+ private:
+ SkEventSinkID fTargetID;
+ char* fType;
+ bool fWeOwnTheType;
+
+ void resetType();
+
+ friend class SkView;
+ };
+ Click* findClickHandler(SkScalar x, SkScalar y);
+
+ static void DoClickDown(Click*, int x, int y);
+ static void DoClickMoved(Click*, int x, int y);
+ static void DoClickUp(Click*, int x, int y);
+
+ /** Send the event to the view's parent, and its parent etc. until one of them
+ returns true from its onEvent call. This view is returned. If no parent handles
+ the event, null is returned.
+ */
+ SkView* sendEventToParents(const SkEvent&);
+ /** Send the query to the view's parent, and its parent etc. until one of them
+ returns true from its onQuery call. This view is returned. If no parent handles
+ the query, null is returned.
+ */
+ SkView* sendQueryToParents(SkEvent*);
+
+ /** Depricated helper function. Just call event->post(sinkID, delay);
+ */
+ bool postEvent(SkEvent* evt, SkEventSinkID sinkID, SkMSec delay) { return evt->post(sinkID, delay); }
+
+ // View hierarchy management
+
+ /** Return the view's parent, or null if it has none. This does not affect the parent's reference count. */
+ SkView* getParent() const { return fParent; }
+ SkView* attachChildToFront(SkView* child);
+ /** Attach the child view to this view, and increment the child's reference count. The child view is added
+ such that it will be drawn before all other child views.
+ The child view parameter is returned.
+ */
+ SkView* attachChildToBack(SkView* child);
+ /** If the view has a parent, detach the view from its parent and decrement the view's reference count.
+ If the parent was the only owner of the view, this will cause the view to be deleted.
+ */
+ void detachFromParent();
+ /** Attach the child view to this view, and increment the child's reference count. The child view is added
+ such that it will be drawn after all other child views.
+ The child view parameter is returned.
+ */
+ /** Detach all child views from this view. */
+ void detachAllChildren();
+
+ /** Convert the specified point from global coordinates into view-local coordinates
+ */
+ void globalToLocal(SkPoint* pt) const { if (pt) this->globalToLocal(pt->fX, pt->fY, pt); }
+ /** Convert the specified x,y from global coordinates into view-local coordinates, returning
+ the answer in the local parameter.
+ */
+ void globalToLocal(SkScalar globalX, SkScalar globalY, SkPoint* local) const;
+
+ /** \class F2BIter
+
+ Iterator that will return each of this view's children, in
+ front-to-back order (the order used for clicking). The first
+ call to next() returns the front-most child view. When
+ next() returns null, there are no more child views.
+ */
+ class F2BIter {
+ public:
+ F2BIter(const SkView* parent);
+ SkView* next();
+ private:
+ SkView* fFirstChild, *fChild;
+ };
+
+ /** \class B2FIter
+
+ Iterator that will return each of this view's children, in
+ back-to-front order (the order they are drawn). The first
+ call to next() returns the back-most child view. When
+ next() returns null, there are no more child views.
+ */
+ class B2FIter {
+ public:
+ B2FIter(const SkView* parent);
+ SkView* next();
+ private:
+ SkView* fFirstChild, *fChild;
+ };
+
+ /** \class Artist
+
+ Install a subclass of this in a view (calling setArtist()), and then the
+ default implementation of that view's onDraw() will invoke this object
+ automatically.
+ */
+ class Artist : public SkRefCnt {
+ public:
+ void draw(SkView*, SkCanvas*);
+ void inflate(const SkDOM&, const SkDOM::Node*);
+ protected:
+ virtual void onDraw(SkView*, SkCanvas*) = 0;
+ virtual void onInflate(const SkDOM&, const SkDOM::Node*);
+ };
+ /** Return the artist attached to this view (or null). The artist's reference
+ count is not affected.
+ */
+ Artist* getArtist() const;
+ /** Attach the specified artist (or null) to the view, replacing any existing
+ artist. If the new artist is not null, its reference count is incremented.
+ The artist parameter is returned.
+ */
+ Artist* setArtist(Artist* artist);
+
+ /** \class Layout
+
+ Install a subclass of this in a view (calling setLayout()), and then the
+ default implementation of that view's onLayoutChildren() will invoke
+ this object automatically.
+ */
+ class Layout : public SkRefCnt {
+ public:
+ void layoutChildren(SkView* parent);
+ void inflate(const SkDOM&, const SkDOM::Node*);
+ protected:
+ virtual void onLayoutChildren(SkView* parent) = 0;
+ virtual void onInflate(const SkDOM&, const SkDOM::Node*);
+ };
+
+ /** Return the layout attached to this view (or null). The layout's reference
+ count is not affected.
+ */
+ Layout* getLayout() const;
+ /** Attach the specified layout (or null) to the view, replacing any existing
+ layout. If the new layout is not null, its reference count is incremented.
+ The layout parameter is returned.
+ */
+ Layout* setLayout(Layout*, bool invokeLayoutNow = true);
+ /** If a layout is attached to this view, call its layoutChildren() method
+ */
+ void invokeLayout();
+
+ /** Call this to initialize this view based on the specified XML node
+ */
+ void inflate(const SkDOM& dom, const SkDOM::Node* node);
+ /** After a view hierarchy is inflated, this may be called with a dictionary
+ containing pairs of <name, view*>, where the name string was the view's
+ "id" attribute when it was inflated.
+
+ This will call the virtual onPostInflate for this view, and the recursively
+ call postInflate on all of the view's children.
+ */
+ void postInflate(const SkTDict<SkView*>& ids);
+
+ SkDEBUGCODE(void dump(bool recurse) const;)
+
+protected:
+ /** Override this to draw inside the view. Be sure to call the inherited version too */
+ virtual void onDraw(SkCanvas*);
+ /** Override this to be notified when the view's size changes. Be sure to call the inherited version too */
+ virtual void onSizeChange();
+ /** Override this if you want to handle an inval request from this view or one of its children.
+ Tyically this is only overridden by the by the "window". If your subclass does handle the
+ request, return true so the request will not continue to propogate to the parent.
+ */
+ virtual bool handleInval(const SkRect*);
+ //! called once before all of the children are drawn (or clipped/translated)
+ virtual SkCanvas* beforeChildren(SkCanvas* c) { return c; }
+ //! called once after all of the children are drawn (or clipped/translated)
+ virtual void afterChildren(SkCanvas* orig) {}
+
+ //! called right before this child's onDraw is called
+ virtual void beforeChild(SkView* child, SkCanvas* canvas) {}
+ //! called right after this child's onDraw is called
+ virtual void afterChild(SkView* child, SkCanvas* canvas) {}
+
+ /** Override this if you might handle the click
+ */
+ virtual Click* onFindClickHandler(SkScalar x, SkScalar y);
+ /** Override this to decide if your children are targets for a click.
+ The default returns true, in which case your children views will be
+ candidates for onFindClickHandler. Returning false wil skip the children
+ and just call your onFindClickHandler.
+ */
+ virtual bool onSendClickToChildren(SkScalar x, SkScalar y);
+ /** Override this to track clicks, returning true as long as you want to track
+ the pen/mouse.
+ */
+ virtual bool onClick(Click*);
+ /** Override this to initialize your subclass from the XML node. Be sure to call the inherited version too */
+ virtual void onInflate(const SkDOM& dom, const SkDOM::Node* node);
+ /** Override this if you want to perform post initialization work based on the ID dictionary built
+ during XML parsing. Be sure to call the inherited version too.
+ */
+ virtual void onPostInflate(const SkTDict<SkView*>&);
+
+public:
+ // default action is to inval the view
+ virtual void onFocusChange(bool gainFocusP);
+protected:
+
+ // override these if you're acting as a layer/host
+ virtual bool onGetFocusView(SkView**) const { return false; }
+ virtual bool onSetFocusView(SkView*) { return false; }
+
+private:
+ SkScalar fWidth, fHeight;
+ SkPoint fLoc;
+ SkView* fParent;
+ SkView* fFirstChild;
+ SkView* fNextSibling;
+ SkView* fPrevSibling;
+ uint8_t fFlags;
+ uint8_t fContainsFocus;
+
+ friend class B2FIter;
+ friend class F2BIter;
+
+ friend class SkLayerView;
+
+ bool setFocusView(SkView* fvOrNull);
+ SkView* acceptFocus(FocusDirection);
+ void detachFromParent_NoLayout();
+};
+
+#endif
+
diff --git a/include/views/SkViewInflate.h b/include/views/SkViewInflate.h
new file mode 100644
index 0000000..3ec65a6
--- /dev/null
+++ b/include/views/SkViewInflate.h
@@ -0,0 +1,79 @@
+/*
+ * Copyright (C) 2006 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.
+ */
+
+#ifndef SkViewInflate_DEFINED
+#define SkViewInflate_DEFINED
+
+#include "SkDOM.h"
+#include "SkTDict.h"
+#include "SkEvent.h"
+
+class SkView;
+
+class SkViewInflate {
+public:
+ SkViewInflate();
+ virtual ~SkViewInflate();
+
+ /** Return the tree of inflated views. If root is null, create the root element
+ as a view, otherwise assume root is that view, and just "inflate" it.
+
+ Returns null if the tree cannot be built.
+ */
+ SkView* inflate(const SkDOM& dom, const SkDOM::Node* node, SkView* root = NULL);
+ SkView* inflate(const char xml[], size_t len, SkView* root = NULL);
+
+ /** Given an id attribute value, return the corresponding view, or null
+ if no match is found.
+ */
+ SkView* findViewByID(const char id[]) const;
+
+ SkDEBUGCODE(void dump() const;)
+
+protected:
+ /* Override this in your subclass to handle instantiating views
+ Call the inherited version for nodes you don't recognize.
+
+ Do not call "inflate" on the view, just return it. This will
+ get called automatically after createView returns.
+ */
+ virtual SkView* createView(const SkDOM& dom, const SkDOM::Node* node);
+ /** Base implementation calls view->inflate(dom, node). Subclasses may override this
+ to perform additional initializations to view, either before or after calling
+ the inherited version.
+ */
+ virtual void inflateView(SkView* view, const SkDOM& dom, const SkDOM::Node* node);
+
+private:
+ enum {
+ kMinIDStrAlloc = 64
+ };
+ SkTDict<SkView*> fIDs;
+
+ struct IDStr {
+ SkView* fView;
+ char* fStr;
+ };
+ SkTDArray<IDStr> fListenTo, fBroadcastTo;
+ SkChunkAlloc fStrings;
+
+ void addIDStr(SkTDArray<IDStr>* list, SkView*, const char* str);
+
+ void rInflate(const SkDOM& dom, const SkDOM::Node* node, SkView* parent);
+};
+
+#endif
+
diff --git a/include/views/SkWidget.h b/include/views/SkWidget.h
new file mode 100644
index 0000000..db85f01
--- /dev/null
+++ b/include/views/SkWidget.h
@@ -0,0 +1,476 @@
+/*
+ * Copyright (C) 2006 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.
+ */
+
+#ifndef SkWidget_DEFINED
+#define SkWidget_DEFINED
+
+#include "SkView.h"
+#include "SkBitmap.h"
+#include "SkDOM.h"
+#include "SkPaint.h"
+#include "SkString.h"
+#include "SkTDArray.h"
+
+//////////////////////////////////////////////////////////////////////////////
+
+class SkWidget : public SkView {
+public:
+ SkWidget(uint32_t flags = 0) : SkView(flags | kFocusable_Mask | kEnabled_Mask) {}
+
+ /** Call this to post the widget's event to its listeners */
+ void postWidgetEvent();
+
+ static void Init();
+ static void Term();
+protected:
+ // override to add slots to an event before posting
+ virtual void prepareWidgetEvent(SkEvent*);
+ virtual void onEnabledChange();
+
+ // <event ...> to initialize the event from XML
+ virtual void onInflate(const SkDOM& dom, const SkDOM::Node* node);
+
+private:
+ SkEvent fEvent;
+ typedef SkView INHERITED;
+};
+
+class SkHasLabelWidget : public SkWidget {
+public:
+ SkHasLabelWidget(uint32_t flags = 0) : SkWidget(flags) {}
+
+ size_t getLabel(SkString* label = NULL) const;
+ size_t getLabel(char lable[] = NULL) const;
+ void setLabel(const SkString&);
+ void setLabel(const char label[]);
+ void setLabel(const char label[], size_t len);
+
+protected:
+ // called when the label changes
+ virtual void onLabelChange();
+
+ // overrides
+ virtual void onInflate(const SkDOM& dom, const SkDOM::Node*);
+
+private:
+ SkString fLabel;
+ typedef SkWidget INHERITED;
+};
+
+class SkButtonWidget : public SkHasLabelWidget {
+public:
+ SkButtonWidget(uint32_t flags = 0) : SkHasLabelWidget(flags), fState(kOff_State) {}
+
+ enum State {
+ kOff_State, //!< XML: buttonState="off"
+ kOn_State, //!< XML: buttonState="on"
+ kUnknown_State //!< XML: buttonState="unknown"
+ };
+ State getButtonState() const { return fState; }
+ void setButtonState(State);
+
+protected:
+ /** called when the label changes. default behavior is to inval the widget */
+ virtual void onButtonStateChange();
+
+ // overrides
+ virtual void onInflate(const SkDOM& dom, const SkDOM::Node*);
+
+private:
+ State fState;
+ typedef SkHasLabelWidget INHERITED;
+};
+
+class SkPushButtonWidget : public SkButtonWidget {
+public:
+ SkPushButtonWidget(uint32_t flags = 0) : SkButtonWidget(flags) {}
+
+protected:
+ virtual bool onEvent(const SkEvent&);
+ virtual void onDraw(SkCanvas*);
+ virtual Click* onFindClickHandler(SkScalar x, SkScalar y);
+ virtual bool onClick(Click* click);
+
+private:
+ typedef SkButtonWidget INHERITED;
+};
+
+class SkCheckBoxWidget : public SkButtonWidget {
+public:
+ SkCheckBoxWidget(uint32_t flags = 0);
+
+protected:
+ virtual bool onEvent(const SkEvent&);
+ virtual void onDraw(SkCanvas*);
+ virtual void onInflate(const SkDOM& dom, const SkDOM::Node*);
+
+private:
+ typedef SkButtonWidget INHERITED;
+};
+
+#include "SkTextBox.h"
+
+class SkStaticTextView : public SkView {
+public:
+ SkStaticTextView(uint32_t flags = 0);
+ virtual ~SkStaticTextView();
+
+ enum Mode {
+ kFixedSize_Mode,
+ kAutoWidth_Mode,
+ kAutoHeight_Mode,
+
+ kModeCount
+ };
+ Mode getMode() const { return (Mode)fMode; }
+ void setMode(Mode);
+
+ SkTextBox::SpacingAlign getSpacingAlign() const { return (SkTextBox::SpacingAlign)fSpacingAlign; }
+ void setSpacingAlign(SkTextBox::SpacingAlign);
+
+ void getMargin(SkPoint* margin) const;
+ void setMargin(SkScalar dx, SkScalar dy);
+
+ size_t getText(SkString* text = NULL) const;
+ size_t getText(char text[] = NULL) const;
+ void setText(const SkString&);
+ void setText(const char text[]);
+ void setText(const char text[], size_t len);
+
+ void getPaint(SkPaint*) const;
+ void setPaint(const SkPaint&);
+
+protected:
+ // overrides
+ virtual void onDraw(SkCanvas*);
+ virtual void onInflate(const SkDOM& dom, const SkDOM::Node*);
+
+private:
+ SkPoint fMargin;
+ SkString fText;
+ SkPaint fPaint;
+ uint8_t fMode;
+ uint8_t fSpacingAlign;
+
+ void computeSize();
+
+ typedef SkView INHERITED;
+};
+
+class SkBitmapView : public SkView {
+public:
+ SkBitmapView(uint32_t flags = 0);
+ virtual ~SkBitmapView();
+
+ bool getBitmap(SkBitmap*) const;
+ void setBitmap(const SkBitmap*, bool viewOwnsPixels);
+ bool loadBitmapFromFile(const char path[]);
+
+protected:
+ virtual void onDraw(SkCanvas*);
+ virtual void onInflate(const SkDOM&, const SkDOM::Node*);
+
+private:
+ SkBitmap fBitmap;
+ typedef SkView INHERITED;
+};
+
+/////////////////////////////////////////////////////////////////////////////
+
+class SkShader;
+class SkInterpolator;
+
+class SkWidgetView : public SkView {
+public:
+ SkWidgetView(uint32_t flags = 0);
+ virtual ~SkWidgetView();
+
+ static const char* GetEventType();
+};
+
+class SkSliderView : public SkWidgetView {
+public:
+ SkSliderView(uint32_t flags = 0);
+
+ uint16_t getValue() const { return fValue; }
+ uint16_t getMax() const { return fMax; }
+
+ void setMax(U16CPU max);
+ void setValue(U16CPU value);
+
+protected:
+ virtual void onDraw(SkCanvas*);
+ virtual Click* onFindClickHandler(SkScalar x, SkScalar y);
+ virtual bool onClick(Click*);
+
+private:
+ uint16_t fValue, fMax;
+
+ typedef SkWidgetView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+class SkHasLabelView : public SkView {
+public:
+ void getLabel(SkString*) const;
+ void setLabel(const SkString&);
+ void setLabel(const char label[]);
+
+protected:
+ SkString fLabel;
+
+ // called when the label changes
+ virtual void onLabelChange();
+
+ // overrides
+ virtual void onInflate(const SkDOM& dom, const SkDOM::Node*);
+};
+
+class SkPushButtonView : public SkHasLabelView {
+public:
+ SkPushButtonView(uint32_t flags = 0);
+
+protected:
+ virtual void onDraw(SkCanvas*);
+ virtual void onInflate(const SkDOM& dom, const SkDOM::Node*);
+};
+
+class SkCheckBoxView : public SkHasLabelView {
+public:
+ SkCheckBoxView(uint32_t flags = 0);
+
+ enum State {
+ kOff_State,
+ kOn_State,
+ kMaybe_State
+ };
+ State getState() const { return fState; }
+ void setState(State);
+
+protected:
+ virtual void onDraw(SkCanvas*);
+ virtual void onInflate(const SkDOM& dom, const SkDOM::Node*);
+
+private:
+ State fState;
+};
+
+class SkProgressView : public SkView {
+public:
+ SkProgressView(uint32_t flags = 0);
+ virtual ~SkProgressView();
+
+ uint16_t getValue() const { return fValue; }
+ uint16_t getMax() const { return fMax; }
+
+ void setMax(U16CPU max);
+ void setValue(U16CPU value);
+
+protected:
+ virtual void onDraw(SkCanvas*);
+ virtual void onInflate(const SkDOM& dom, const SkDOM::Node* node);
+
+private:
+ uint16_t fValue, fMax;
+ SkShader* fOnShader, *fOffShader;
+ SkInterpolator* fInterp;
+ bool fDoInterp;
+
+ typedef SkView INHERITED;
+};
+
+class SkTextView : public SkView {
+public:
+ SkTextView(uint32_t flags = 0);
+ virtual ~SkTextView();
+
+ enum AnimaDir {
+ kNeutral_AnimDir,
+ kForward_AnimDir,
+ kBackward_AnimDir,
+ kAnimDirCount
+ };
+
+ void getText(SkString*) const;
+ void setText(const SkString&, AnimaDir dir = kNeutral_AnimDir);
+ void setText(const char text[], AnimaDir dir = kNeutral_AnimDir);
+ void setText(const char text[], size_t len, AnimaDir dir = kNeutral_AnimDir);
+
+ void getMargin(SkPoint* margin) const;
+ void setMargin(const SkPoint&);
+
+ SkPaint& paint() { return fPaint; }
+
+protected:
+ virtual void onDraw(SkCanvas*);
+ virtual void onInflate(const SkDOM& dom, const SkDOM::Node* node);
+
+private:
+ SkString fText;
+ SkPaint fPaint;
+ SkPoint fMargin;
+
+ class Interp;
+ Interp* fInterp;
+ bool fDoInterp;
+ // called by the other setText methods. This guy does not check for !=
+ // before doing the assign, so the caller must check for us
+ void privSetText(const SkString&, AnimaDir dir);
+
+ typedef SkView INHERITED;
+};
+
+//////////////////////////////////////////////////////////
+
+class SkEvent;
+
+class SkListSource : public SkEventSink {
+public:
+ virtual int countRows() = 0;
+ virtual void getRow(int index, SkString* left, SkString* right) = 0;
+ virtual SkEvent* getEvent(int index);
+
+ static SkListSource* CreateFromDir(const char path[], const char suffix[],
+ const char targetPrefix[]);
+ static SkListSource* CreateFromDOM(const SkDOM& dom, const SkDOM::Node* node);
+};
+
+class SkListView : public SkWidgetView {
+public:
+ SkListView(uint32_t flags = 0);
+ virtual ~SkListView();
+
+ SkScalar getRowHeight() const { return fRowHeight; }
+ void setRowHeight(SkScalar);
+
+ /** Return the index of the selected row, or -1 if none
+ */
+ int getSelection() const { return fCurrIndex; }
+ /** Set the index of the selected row, or -1 for none
+ */
+ void setSelection(int);
+
+ void moveSelectionUp();
+ void moveSelectionDown();
+
+ enum Attr {
+ kBG_Attr,
+ kNormalText_Attr,
+ kHiliteText_Attr,
+ kHiliteCell_Attr,
+ kAttrCount
+ };
+ SkPaint& paint(Attr);
+
+ SkListSource* getListSource() const { return fSource; }
+ SkListSource* setListSource(SkListSource*);
+
+#if 0
+ enum Action {
+ kSelectionChange_Action,
+ kSelectionPicked_Action,
+ kActionCount
+ };
+ /** If event is not null, it is retained by the view, and a copy
+ of the event will be posted to its listeners when the specified
+ action occurs. If event is null, then no event will be posted for
+ the specified action.
+ */
+ void setActionEvent(Action, SkEvent* event);
+#endif
+
+protected:
+ virtual void onDraw(SkCanvas*);
+ virtual void onSizeChange();
+ virtual bool onEvent(const SkEvent&);
+ virtual void onInflate(const SkDOM& dom, const SkDOM::Node* node);
+
+private:
+ SkPaint fPaint[kAttrCount];
+ SkListSource* fSource;
+ SkScalar fRowHeight;
+ int fCurrIndex; // logical index
+ int fScrollIndex; // logical index of top-most visible row
+ int fVisibleRowCount;
+ SkString* fStrCache;
+
+ void dirtyStrCache();
+ void ensureStrCache(int visibleCount);
+
+ int logicalToVisualIndex(int index) const { return index - fScrollIndex; }
+ void invalSelection();
+ bool getRowRect(int index, SkRect*) const;
+ void ensureSelectionIsVisible();
+
+ typedef SkWidgetView INHERITED;
+};
+
+//////////////////////////////////////////////////////////
+
+class SkGridView : public SkWidgetView {
+public:
+ SkGridView(uint32_t flags = 0);
+ virtual ~SkGridView();
+
+ void getCellSize(SkPoint*) const;
+ void setCellSize(SkScalar x, SkScalar y);
+
+ /** Return the index of the selected item, or -1 if none
+ */
+ int getSelection() const { return fCurrIndex; }
+ /** Set the index of the selected row, or -1 for none
+ */
+ void setSelection(int);
+
+ void moveSelectionUp();
+ void moveSelectionDown();
+
+ enum Attr {
+ kBG_Attr,
+ kHiliteCell_Attr,
+ kAttrCount
+ };
+ SkPaint& paint(Attr);
+
+ SkListSource* getListSource() const { return fSource; }
+ SkListSource* setListSource(SkListSource*);
+
+protected:
+ virtual void onDraw(SkCanvas*);
+ virtual void onSizeChange();
+ virtual bool onEvent(const SkEvent&);
+ virtual void onInflate(const SkDOM& dom, const SkDOM::Node* node);
+
+private:
+ SkView* fScrollBar;
+ SkPaint fPaint[kAttrCount];
+ SkListSource* fSource;
+ int fCurrIndex; // logical index
+
+ SkPoint fCellSize;
+ SkIPoint fVisibleCount;
+
+ int logicalToVisualIndex(int index) const { return index; }
+ void invalSelection();
+ bool getCellRect(int index, SkRect*) const;
+ void ensureSelectionIsVisible();
+
+ typedef SkWidgetView INHERITED;
+};
+
+#endif
+
diff --git a/include/views/SkWidgetViews.h b/include/views/SkWidgetViews.h
new file mode 100644
index 0000000..9b3a816
--- /dev/null
+++ b/include/views/SkWidgetViews.h
@@ -0,0 +1,312 @@
+/*
+ * Copyright (C) 2006 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.
+ */
+
+#ifndef SkWidgetViews_DEFINED
+#define SkWidgetViews_DEFINED
+
+#include "SkView.h"
+
+
+enum SkWidgetEnum {
+ kBorder_WidgetEnum, //!< <sk-border>
+ kButton_WidgetEnum, //!< <sk-button>
+ kImage_WidgetEnum, //!< <sk-image>
+ kList_WidgetEnum, //!< <sk-list>
+ kProgress_WidgetEnum, //!< <sk-progress>
+ kScroll_WidgetEnum, //!< <sk-scroll>
+ kText_WidgetEnum, //!< <sk-text>
+
+ kWidgetEnumCount
+};
+
+//determines which skin to use
+enum SkinEnum {
+ kBorder_SkinEnum,
+ kButton_SkinEnum,
+ kProgress_SkinEnum,
+ kScroll_SkinEnum,
+ kStaticText_SkinEnum,
+
+ kSkinEnumCount
+};
+
+#include "SkAnimator.h"
+//used for inflates
+const char* get_skin_enum_path(SkinEnum se);
+void init_skin_anim(const char path[], SkAnimator* anim);
+void init_skin_anim(SkinEnum se, SkAnimator* anim);
+void init_skin_paint(SkinEnum se, SkPaint* paint);
+void inflate_paint(const SkDOM& dom, const SkDOM::Node* node, SkPaint* paint);
+
+/** Given an enum value, return an instance of the specified widget.
+ If the enum is out of range, returns null
+*/
+SkView* SkWidgetFactory(SkWidgetEnum);
+/** Given the inflate/element name of a widget, return an instance of
+ the specified widget, or null if name does not match any known
+ widget type.
+*/
+SkView* SkWidgetFactory(const char name[]);
+
+////////////////////////////////////////////////////////////////////////////////////////////////
+
+class SkWidgetView : public SkView {
+public:
+ SkWidgetView();
+
+ const char* getLabel() const;
+ void getLabel(SkString* label) const;
+
+ void setLabel(const char[]);
+ void setLabel(const char[], size_t len);
+ void setLabel(const SkString&);
+
+ SkEvent& event() { return fEvent; }
+ const SkEvent& event() const { return fEvent; }
+
+ /** Returns true if the widget can post its event to its listeners.
+ */
+ bool postWidgetEvent();
+
+ /** Returns the sinkID of the widgetview that posted the event, or 0
+ */
+ static SkEventSinkID GetWidgetEventSinkID(const SkEvent&);
+
+protected:
+ /** called when the label changes. override in subclasses. default action invals the view's bounds.
+ called with the old and new labels, before the label has actually changed.
+ */
+ virtual void onLabelChange(const char oldLabel[], const char newLabel[]);
+ /** called before posting the event to our listeners. Override to add slots to the event
+ before posting. Return true to proceed with posting, or false to not post the event to any
+ listener. Note: the event passed in may not be the same as calling this->event().
+ Be sure to call your INHERITED method as well, so that all classes in the hierarchy get a shot
+ at modifying the event (and possibly returning false to abort).
+ */
+ virtual bool onPrepareWidgetEvent(SkEvent* evt);
+
+ // overrides
+ virtual void onInflate(const SkDOM& dom, const SkDOM::Node*);
+
+private:
+ SkString fLabel;
+ SkEvent fEvent;
+
+ typedef SkView INHERITED;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////
+
+class SkButtonView : public SkWidgetView {
+public:
+ // inflate: "sk-button"
+
+protected:
+ // overrides
+ virtual bool onEvent(const SkEvent&);
+private:
+ typedef SkWidgetView INHERITED;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////
+
+class SkCheckButtonView : public SkWidgetView {
+public:
+ SkCheckButtonView();
+
+ // inflate: "sk-checkbutton"
+
+ enum CheckState {
+ kOff_CheckState, //!< inflate: check-state="off"
+ kOn_CheckState, //!< inflate: check-state="on"
+ kUnknown_CheckState //!< inflate: check-state="unknown"
+ };
+ CheckState getCheckState() const { return (CheckState)fCheckState; }
+ void setCheckState(CheckState);
+
+ /** use this to extract the CheckState from an event (i.e. one that as posted
+ by a SkCheckButtonView). Returns true if the proper slot was present in the event,
+ and sets state to that value. If no proper slot is found, returns false and does not
+ modify state.
+ */
+ static bool GetWidgetEventCheckState(const SkEvent&, CheckState* state);
+
+protected:
+ // called when the check-state is about to change, but before it actually has
+ virtual void onCheckStateChange(CheckState oldState, CheckState newState);
+
+ // overrides
+ virtual void onInflate(const SkDOM& dom, const SkDOM::Node*);
+ virtual bool onPrepareWidgetEvent(SkEvent* evt);
+
+private:
+ uint8_t fCheckState;
+
+ typedef SkWidgetView INHERITED;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////
+#include "SkTextBox.h"
+
+class SkStaticTextView : public SkView {
+public:
+ SkStaticTextView();
+ virtual ~SkStaticTextView();
+
+ enum Mode {
+ kFixedSize_Mode,
+ kAutoWidth_Mode,
+ kAutoHeight_Mode,
+
+ kModeCount
+ };
+ Mode getMode() const { return (Mode)fMode; }
+ void setMode(Mode);
+
+ SkTextBox::SpacingAlign getSpacingAlign() const { return (SkTextBox::SpacingAlign)fSpacingAlign; }
+ void setSpacingAlign(SkTextBox::SpacingAlign);
+
+ void getMargin(SkPoint* margin) const;
+ void setMargin(SkScalar dx, SkScalar dy);
+
+ size_t getText(SkString* text = NULL) const;
+ size_t getText(char text[] = NULL) const;
+ void setText(const SkString&);
+ void setText(const char text[]);
+ void setText(const char text[], size_t len);
+
+ void getPaint(SkPaint*) const;
+ void setPaint(const SkPaint&);
+
+protected:
+ // overrides
+ virtual void onDraw(SkCanvas*);
+ virtual void onInflate(const SkDOM& dom, const SkDOM::Node*);
+
+private:
+ SkPoint fMargin;
+ SkString fText;
+ SkPaint fPaint;
+ uint8_t fMode;
+ uint8_t fSpacingAlign;
+
+ void computeSize();
+
+ typedef SkView INHERITED;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////
+
+class SkAnimator;
+class SkListSource;
+class SkScrollBarView;
+
+class SkListView : public SkWidgetView {
+public:
+ SkListView();
+ virtual ~SkListView();
+
+ bool hasScrollBar() const { return fScrollBar != NULL; }
+ void setHasScrollBar(bool);
+
+ /** Return the number of visible rows
+ */
+ int getVisibleRowCount() const { return fVisibleRowCount; }
+ /** Return the index of the selected row, or -1 if none
+ */
+ int getSelection() const { return fCurrIndex; }
+ /** Set the index of the selected row, or -1 for none
+ */
+ void setSelection(int);
+ /** If possible, move the selection up and return true,
+ else do nothing and return false
+ If nothing is selected, select the last item (unless there are no items).
+ */
+ bool moveSelectionUp();
+ /** If possible, move the selection down and return true,
+ else do nothing and return false.
+ If nothing is selected, select the first item (unless there are no items).
+ */
+ bool moveSelectionDown();
+
+ SkListSource* getListSource() const { return fSource; }
+ SkListSource* setListSource(SkListSource*);
+
+ /** Call this in your event handler. If the specified event is from a SkListView,
+ then it returns the index of the selected item in this list, otherwise it
+ returns -1
+ */
+ static int GetWidgetEventListIndex(const SkEvent&);
+
+protected:
+ // overrides
+ virtual void onDraw(SkCanvas*);
+ virtual void onSizeChange();
+ virtual bool onEvent(const SkEvent&);
+ virtual void onInflate(const SkDOM& dom, const SkDOM::Node* node);
+ virtual bool onPrepareWidgetEvent(SkEvent*);
+
+private:
+ enum DirtyFlags {
+ kAnimCount_DirtyFlag = 0x01,
+ kAnimContent_DirtyFlag = 0x02
+ };
+ void dirtyCache(unsigned dirtyFlags);
+ bool ensureCache();
+
+ int logicalToVisualIndex(int index) const { return index - fScrollIndex; }
+ void invalSelection();
+ SkScalar getContentWidth() const;
+ bool getRowRect(int index, SkRect*) const;
+ void ensureSelectionIsVisible();
+ void ensureVisibleRowCount();
+
+ struct BindingRec;
+
+ enum Heights {
+ kNormal_Height,
+ kSelected_Height
+ };
+ SkListSource* fSource;
+ SkScrollBarView* fScrollBar;
+ SkAnimator* fAnims;
+ BindingRec* fBindings;
+ SkString fSkinName;
+ SkScalar fHeights[2];
+ int16_t fScrollIndex, fCurrIndex;
+ uint16_t fVisibleRowCount, fBindingCount;
+ SkBool8 fAnimContentDirty;
+ SkBool8 fAnimFocusDirty;
+
+ typedef SkWidgetView INHERITED;
+};
+
+class SkListSource : public SkRefCnt {
+public:
+ virtual int countFields();
+ virtual void getFieldName(int index, SkString* field);
+ /** Return the index of the named field, or -1 if not found */
+ virtual int findFieldIndex(const char field[]);
+
+ virtual int countRecords();
+ virtual void getRecord(int rowIndex, int fieldIndex, SkString* data);
+
+ virtual bool prepareWidgetEvent(SkEvent*, int rowIndex);
+
+ static SkListSource* Factory(const char name[]);
+};
+
+#endif
diff --git a/include/views/SkWindow.h b/include/views/SkWindow.h
new file mode 100644
index 0000000..fd4ce0a
--- /dev/null
+++ b/include/views/SkWindow.h
@@ -0,0 +1,125 @@
+/*
+ * Copyright (C) 2006 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.
+ */
+
+#ifndef SkWindow_DEFINED
+#define SkWindow_DEFINED
+
+#include "SkView.h"
+#include "SkBitmap.h"
+#include "SkMatrix.h"
+#include "SkRegion.h"
+#include "SkEvent.h"
+#include "SkKey.h"
+#include "SkTDArray.h"
+
+#ifdef SK_BUILD_FOR_WINCEx
+ #define SHOW_FPS
+#endif
+//#define USE_GX_SCREEN
+
+class SkCanvas;
+
+class SkOSMenu;
+
+class SkWindow : public SkView {
+public:
+ SkWindow();
+ virtual ~SkWindow();
+
+ const SkBitmap& getBitmap() const { return fBitmap; }
+
+ void setConfig(SkBitmap::Config);
+ void resize(int width, int height, SkBitmap::Config config = SkBitmap::kNo_Config);
+ void eraseARGB(U8CPU a, U8CPU r, U8CPU g, U8CPU b);
+ void eraseRGB(U8CPU r, U8CPU g, U8CPU b);
+
+ bool isDirty() const { return !fDirtyRgn.isEmpty(); }
+ bool update(SkIRect* updateArea, SkCanvas* = NULL);
+ // does not call through to onHandleInval(), but does force the fDirtyRgn
+ // to be wide open. Call before update() to ensure we redraw everything.
+ void forceInvalAll();
+ // return the bounds of the dirty/inval rgn, or [0,0,0,0] if none
+ const SkIRect& getDirtyBounds() const { return fDirtyRgn.getBounds(); }
+
+ bool handleClick(int x, int y, Click::State);
+ bool handleChar(SkUnichar);
+ bool handleKey(SkKey);
+ bool handleKeyUp(SkKey);
+ bool handleMenu(uint32_t os_cmd);
+
+ void addMenu(SkOSMenu*);
+
+ const char* getTitle() const { return fTitle.c_str(); }
+ void setTitle(const char title[]);
+
+ const SkMatrix& getMatrix() const { return fMatrix; }
+ void setMatrix(const SkMatrix&);
+ void preConcat(const SkMatrix&);
+ void postConcat(const SkMatrix&);
+
+protected:
+ virtual bool onEvent(const SkEvent&);
+ virtual bool onDispatchClick(int x, int y, Click::State);
+ // called if part of our bitmap is invalidated
+ virtual void onHandleInval(const SkIRect&);
+ virtual bool onHandleChar(SkUnichar);
+ virtual bool onHandleKey(SkKey);
+ virtual bool onHandleKeyUp(SkKey);
+ virtual void onAddMenu(const SkOSMenu*) {}
+ virtual void onSetTitle(const char title[]) {}
+
+ // overrides from SkView
+ virtual bool handleInval(const SkRect*);
+ virtual bool onGetFocusView(SkView** focus) const;
+ virtual bool onSetFocusView(SkView* focus);
+
+private:
+ SkBitmap::Config fConfig;
+ SkBitmap fBitmap;
+ SkRegion fDirtyRgn;
+ Click* fClick; // to track clicks
+
+ SkTDArray<SkOSMenu*> fMenus;
+
+ SkView* fFocusView;
+ bool fWaitingOnInval;
+
+ SkString fTitle;
+ SkMatrix fMatrix;
+
+ typedef SkView INHERITED;
+};
+
+///////////////////////////////////////////////////////////
+
+#ifdef SK_USE_WXWIDGETS
+ #include "SkOSWindow_wxwidgets.h"
+#elif defined(SK_BUILD_FOR_MAC)
+ #include "SkOSWindow_Mac.h"
+#elif defined(SK_BUILD_FOR_WIN)
+ #include "SkOSWindow_Win.h"
+#elif defined(ANDROID)
+ #include "SkOSWindow_Android.h"
+#elif defined(SK_BUILD_FOR_UNIX)
+ #include "SkOSWindow_Unix.h"
+#elif defined(SK_BUILD_FOR_SDL)
+ #include "SkOSWindow_SDL.h"
+#elif defined(SK_BUILD_FOR_IOS)
+ #include "SkOSWindow_iOS.h"
+#endif
+
+#endif
+
diff --git a/samplecode/ClockFaceView.cpp b/samplecode/ClockFaceView.cpp
new file mode 100644
index 0000000..c829b69
--- /dev/null
+++ b/samplecode/ClockFaceView.cpp
@@ -0,0 +1,255 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkGradientShader.h"
+#include "SkPath.h"
+#include "SkRegion.h"
+#include "SkShader.h"
+#include "SkUtils.h"
+#include "SkColorPriv.h"
+#include "SkColorFilter.h"
+#include "SkTypeface.h"
+#include "SkAvoidXfermode.h"
+
+static inline SkPMColor rgb2gray(SkPMColor c)
+{
+ unsigned r = SkGetPackedR32(c);
+ unsigned g = SkGetPackedG32(c);
+ unsigned b = SkGetPackedB32(c);
+
+ unsigned x = (r * 5 + g * 7 + b * 4) >> 4;
+
+ return SkPackARGB32(0, x, x, x) | (c & (SK_A32_MASK << SK_A32_SHIFT));
+}
+
+class SkGrayScaleColorFilter : public SkColorFilter {
+public:
+ virtual void filterSpan(const SkPMColor src[], int count, SkPMColor result[])
+ {
+ for (int i = 0; i < count; i++)
+ result[i] = rgb2gray(src[i]);
+ }
+};
+
+class SkChannelMaskColorFilter : public SkColorFilter {
+public:
+ SkChannelMaskColorFilter(U8CPU redMask, U8CPU greenMask, U8CPU blueMask)
+ {
+ fMask = SkPackARGB32(0xFF, redMask, greenMask, blueMask);
+ }
+
+ virtual void filterSpan(const SkPMColor src[], int count, SkPMColor result[])
+ {
+ SkPMColor mask = fMask;
+ for (int i = 0; i < count; i++)
+ result[i] = src[i] & mask;
+ }
+
+private:
+ SkPMColor fMask;
+};
+
+///////////////////////////////////////////////////////////
+
+#include "SkGradientShader.h"
+#include "SkLayerRasterizer.h"
+#include "SkBlurMaskFilter.h"
+
+#include "Sk2DPathEffect.h"
+
+class Dot2DPathEffect : public Sk2DPathEffect {
+public:
+ Dot2DPathEffect(SkScalar radius, const SkMatrix& matrix,
+ SkTDArray<SkPoint>* pts)
+ : Sk2DPathEffect(matrix), fRadius(radius), fPts(pts) {}
+
+ virtual void flatten(SkFlattenableWriteBuffer& buffer)
+ {
+ this->INHERITED::flatten(buffer);
+
+ buffer.writeScalar(fRadius);
+ }
+ virtual Factory getFactory() { return CreateProc; }
+
+protected:
+ virtual void begin(const SkIRect& uvBounds, SkPath* dst) {
+ if (fPts) {
+ fPts->reset();
+ }
+ this->INHERITED::begin(uvBounds, dst);
+ }
+// virtual void end(SkPath* dst) {}
+ virtual void next(const SkPoint& loc, int u, int v, SkPath* dst)
+ {
+ if (fPts) {
+ *fPts->append() = loc;
+ }
+ dst->addCircle(loc.fX, loc.fY, fRadius);
+ }
+
+ Dot2DPathEffect(SkFlattenableReadBuffer& buffer) : Sk2DPathEffect(buffer)
+ {
+ fRadius = buffer.readScalar();
+ fPts = NULL;
+ }
+private:
+ SkScalar fRadius;
+ SkTDArray<SkPoint>* fPts;
+
+ static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer)
+ {
+ return new Dot2DPathEffect(buffer);
+ }
+
+ typedef Sk2DPathEffect INHERITED;
+};
+
+class InverseFillPE : public SkPathEffect {
+public:
+ InverseFillPE() {}
+ virtual bool filterPath(SkPath* dst, const SkPath& src, SkScalar* width) {
+ *dst = src;
+ dst->setFillType(SkPath::kInverseWinding_FillType);
+ return true;
+ }
+ virtual Factory getFactory() { return Factory; }
+protected:
+// InverseFillPE(SkFlattenableReadBuffer& buffer) : INHERITED(buffer) {}
+private:
+ static SkFlattenable* Factory(SkFlattenableReadBuffer& buffer) {
+ return new InverseFillPE;
+ }
+ typedef SkPathEffect INHERITED;
+};
+
+static SkPathEffect* makepe(float interp, SkTDArray<SkPoint>* pts) {
+ SkMatrix lattice;
+ SkScalar rad = 3 + SkIntToScalar(4) * (1 - interp);
+ lattice.setScale(rad*2, rad*2, 0, 0);
+ lattice.postSkew(SK_Scalar1/3, 0, 0, 0);
+ return new Dot2DPathEffect(rad, lattice, pts);
+}
+
+static void r7(SkLayerRasterizer* rast, SkPaint& p, SkScalar interp) {
+ p.setPathEffect(makepe(interp, NULL))->unref();
+ rast->addLayer(p);
+#if 0
+ p.setPathEffect(new InverseFillPE())->unref();
+ p.setXfermodeMode(SkXfermode::kSrcIn_Mode);
+ p.setXfermodeMode(SkXfermode::kClear_Mode);
+ p.setAlpha((1 - interp) * 255);
+ rast->addLayer(p);
+#endif
+}
+
+typedef void (*raster_proc)(SkLayerRasterizer*, SkPaint&);
+
+#include "SkXfermode.h"
+
+static void apply_shader(SkPaint* paint, float scale)
+{
+ SkPaint p;
+ SkLayerRasterizer* rast = new SkLayerRasterizer;
+
+ p.setAntiAlias(true);
+ r7(rast, p, scale);
+ paint->setRasterizer(rast)->unref();
+
+ paint->setColor(SK_ColorBLUE);
+}
+
+class ClockFaceView : public SkView {
+ SkTypeface* fFace;
+ SkScalar fInterp;
+ SkScalar fDx;
+public:
+ ClockFaceView()
+ {
+ fFace = SkTypeface::CreateFromFile("/Users/reed/Downloads/p052024l.pfb");
+ fInterp = 0;
+ fDx = SK_Scalar1/64;
+ }
+
+ virtual ~ClockFaceView()
+ {
+ SkSafeUnref(fFace);
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt)
+ {
+ if (SampleCode::TitleQ(*evt))
+ {
+ SampleCode::TitleR(evt, "Text Effects");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ void drawBG(SkCanvas* canvas)
+ {
+// canvas->drawColor(0xFFDDDDDD);
+ canvas->drawColor(SK_ColorWHITE);
+ }
+
+ static void drawdots(SkCanvas* canvas, const SkPaint& orig) {
+ SkTDArray<SkPoint> pts;
+ SkPathEffect* pe = makepe(0, &pts);
+
+ SkScalar width = -1;
+ SkPath path, dstPath;
+ orig.getTextPath("9", 1, 0, 0, &path);
+ pe->filterPath(&dstPath, path, &width);
+
+ SkPaint p;
+ p.setAntiAlias(true);
+ p.setStrokeWidth(10);
+ p.setColor(SK_ColorRED);
+ canvas->drawPoints(SkCanvas::kPoints_PointMode, pts.count(), pts.begin(),
+ p);
+ }
+
+ virtual void onDraw(SkCanvas* canvas) {
+ this->drawBG(canvas);
+
+ SkScalar x = SkIntToScalar(20);
+ SkScalar y = SkIntToScalar(300);
+ SkPaint paint;
+
+ paint.setAntiAlias(true);
+ paint.setTextSize(SkIntToScalar(240));
+ paint.setTypeface(SkTypeface::CreateFromName("sans-serif",
+ SkTypeface::kBold));
+
+ SkString str("9");
+
+ paint.setTypeface(fFace);
+
+ apply_shader(&paint, fInterp);
+ canvas->drawText(str.c_str(), str.size(), x, y, paint);
+
+ // drawdots(canvas, paint);
+
+ if (false) {
+ fInterp += fDx;
+ if (fInterp > 1) {
+ fInterp = 1;
+ fDx = -fDx;
+ } else if (fInterp < 0) {
+ fInterp = 0;
+ fDx = -fDx;
+ }
+ this->inval(NULL);
+ }
+ }
+
+private:
+ typedef SkView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new ClockFaceView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/OverView.cpp b/samplecode/OverView.cpp
new file mode 100644
index 0000000..2ae2119
--- /dev/null
+++ b/samplecode/OverView.cpp
@@ -0,0 +1,94 @@
+#include "SampleCode.h"
+#include "SkCanvas.h"
+#include "SkView.h"
+
+static const int N = 8;
+const SkScalar W = SkIntToScalar(640);
+const SkScalar H = SkIntToScalar(480);
+
+class OverView : public SkView {
+public:
+ OverView(int count, const SkViewFactory factories[]);
+ virtual ~OverView();
+
+protected:
+ virtual bool onEvent(const SkEvent&);
+ virtual void onSizeChange();
+
+ virtual void onDraw(SkCanvas* canvas) {
+ canvas->drawColor(SK_ColorLTGRAY);
+ }
+
+ virtual SkCanvas* beforeChildren(SkCanvas*);
+
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "Overview");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ virtual bool onSendClickToChildren(SkScalar x, SkScalar y) {
+ return false;
+ }
+
+ virtual Click* onFindClickHandler(SkScalar x, SkScalar y) {
+ int ix = (int)(SkScalarDiv(x * N, W));
+ int iy = (int)(SkScalarDiv(y * N, H));
+ if (ix >= 0 && iy >= 0) {
+ SkEvent evt("set-curr-index");
+ evt.setFast32(iy * N + ix);
+ this->sendEventToParents(evt);
+ }
+ return NULL;
+ }
+
+private:
+ int fCount;
+ const SkViewFactory* fFactories;
+
+ typedef SkView INHERITED;
+};
+
+SkView* create_overview(int count, const SkViewFactory factories[]);
+SkView* create_overview(int count, const SkViewFactory factories[]) {
+ return SkNEW_ARGS(OverView, (count, factories));
+};
+
+OverView::OverView(int count, const SkViewFactory factories[]) {
+ fCount = count;
+ fFactories = factories;
+}
+
+OverView::~OverView() {
+}
+
+bool OverView::onEvent(const SkEvent& evt) {
+ return this->INHERITED::onEvent(evt);
+}
+
+void OverView::onSizeChange() {
+ this->detachAllChildren();
+
+ SkScalar locX = 0;
+ SkScalar locY = 0;
+ for (int i = 0; i < fCount; i++) {
+ SkView* view = fFactories[i]();
+ view->setVisibleP(true);
+ this->attachChildToBack(view)->unref();
+ view->setLoc(locX, locY);
+ view->setSize(W, H);
+ locX += W;
+ if ((i % N) == N - 1) {
+ locY += H;
+ locX = 0;
+ }
+ }
+}
+
+SkCanvas* OverView::beforeChildren(SkCanvas* canvas) {
+ canvas->scale(SK_Scalar1 / N, SK_Scalar1 / N);
+ return canvas;
+}
+
diff --git a/samplecode/SampleAARects.cpp b/samplecode/SampleAARects.cpp
new file mode 100644
index 0000000..34a33b0
--- /dev/null
+++ b/samplecode/SampleAARects.cpp
@@ -0,0 +1,191 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkDevice.h"
+#include "SkPaint.h"
+#include "SkShader.h"
+
+static SkBitmap createBitmap(int n) {
+ SkBitmap bitmap;
+ bitmap.setConfig(SkBitmap::kARGB_8888_Config, n, n);
+ bitmap.allocPixels();
+ bitmap.eraseColor(SK_ColorGREEN);
+
+ SkCanvas canvas(bitmap);
+ SkRect r;
+ r.set(0, 0, SkIntToScalar(n), SkIntToScalar(n));
+ SkPaint paint;
+ paint.setAntiAlias(true);
+
+ paint.setColor(SK_ColorRED);
+ canvas.drawOval(r, paint);
+ paint.setColor(SK_ColorBLUE);
+ paint.setStrokeWidth(SkIntToScalar(n)/15);
+ paint.setStyle(SkPaint::kStroke_Style);
+ canvas.drawLine(0, 0, r.fRight, r.fBottom, paint);
+ canvas.drawLine(0, r.fBottom, r.fRight, 0, paint);
+
+ return bitmap;
+}
+
+class AARectView : public SampleView {
+ SkBitmap fBitmap;
+ enum {
+ N = 64
+ };
+public:
+ AARectView() {
+ fBitmap = createBitmap(N);
+
+ fWidth = N;
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "AA Rects");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ canvas->translate(SkIntToScalar(10), SkIntToScalar(10));
+
+ SkPaint bluePaint;
+ bluePaint.setARGB(0xff, 0x0, 0x0, 0xff);
+ SkPaint bmpPaint;
+ SkShader* bmpShader = SkShader::CreateBitmapShader(fBitmap, SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode);
+ bmpPaint.setShader(bmpShader);
+ bmpShader->unref();
+
+ bluePaint.setStrokeWidth(3);
+ bmpPaint.setStrokeWidth(3);
+
+ SkPaint paints[] = { bluePaint, bmpPaint };
+
+ SkRect rect;
+
+ SkScalar dx = SkIntToScalar(80);
+ SkScalar dy = SkIntToScalar(100);
+ SkMatrix matrix;
+ for (size_t p = 0; p < SK_ARRAY_COUNT(paints); ++p) {
+ for (int stroke = 0; stroke < 2; ++stroke) {
+ paints[p].setStyle(stroke ? SkPaint::kStroke_Style : SkPaint::kFill_Style);
+ for (int a = 0; a < 3; ++ a) {
+ paints[p].setAntiAlias(a > 0);
+ paints[p].setAlpha(a > 1 ? 0x80 : 0xff);
+
+ canvas->save();
+ rect = SkRect::MakeLTRB(SkFloatToScalar(0.f),
+ SkFloatToScalar(0.f),
+ SkFloatToScalar(40.f),
+ SkFloatToScalar(40.f));
+ canvas->drawRect(rect, paints[p]);
+ canvas->translate(dx, 0);
+
+ rect = SkRect::MakeLTRB(SkFloatToScalar(0.5f),
+ SkFloatToScalar(0.5f),
+ SkFloatToScalar(40.5f),
+ SkFloatToScalar(40.5f));
+ canvas->drawRect(rect, paints[p]);
+ canvas->translate(dx, 0);
+
+ rect = SkRect::MakeLTRB(SkFloatToScalar(0.5f),
+ SkFloatToScalar(0.5f),
+ SkFloatToScalar(40.f),
+ SkFloatToScalar(40.f));
+ canvas->drawRect(rect, paints[p]);
+ canvas->translate(dx, 0);
+
+ rect = SkRect::MakeLTRB(SkFloatToScalar(0.75f),
+ SkFloatToScalar(0.75f),
+ SkFloatToScalar(40.75f),
+ SkFloatToScalar(40.75f));
+ canvas->drawRect(rect, paints[p]);
+ canvas->translate(dx, 0);
+
+ canvas->save();
+ canvas->translate(SkFloatToScalar(.33f), SkFloatToScalar(.67f));
+ rect = SkRect::MakeLTRB(SkFloatToScalar(0.0f),
+ SkFloatToScalar(0.0f),
+ SkFloatToScalar(40.0f),
+ SkFloatToScalar(40.0f));
+ canvas->drawRect(rect, paints[p]);
+ canvas->restore();
+ canvas->translate(dx, 0);
+
+ canvas->save();
+ matrix.setRotate(SkFloatToScalar(45.f));
+ canvas->concat(matrix);
+ canvas->translate(SkFloatToScalar(20.0f / sqrtf(2.f)),
+ SkFloatToScalar(20.0f / sqrtf(2.f)));
+ rect = SkRect::MakeLTRB(SkFloatToScalar(-20.0f),
+ SkFloatToScalar(-20.0f),
+ SkFloatToScalar(20.0f),
+ SkFloatToScalar(20.0f));
+ canvas->drawRect(rect, paints[p]);
+ canvas->restore();
+ canvas->translate(dx, 0);
+
+ canvas->save();
+ canvas->rotate(SkFloatToScalar(90.f));
+ rect = SkRect::MakeLTRB(SkFloatToScalar(0.0f),
+ SkFloatToScalar(0.0f),
+ SkFloatToScalar(40.0f),
+ SkFloatToScalar(-40.0f));
+ canvas->drawRect(rect, paints[p]);
+ canvas->restore();
+ canvas->translate(dx, 0);
+
+ canvas->save();
+ canvas->rotate(SkFloatToScalar(90.f));
+ rect = SkRect::MakeLTRB(SkFloatToScalar(0.5f),
+ SkFloatToScalar(0.5f),
+ SkFloatToScalar(40.5f),
+ SkFloatToScalar(-40.5f));
+ canvas->drawRect(rect, paints[p]);
+ canvas->restore();
+ canvas->translate(dx, 0);
+
+ canvas->save();
+ matrix.setScale(SkFloatToScalar(-1.f), SkFloatToScalar(-1.f));
+ canvas->concat(matrix);
+ rect = SkRect::MakeLTRB(SkFloatToScalar(0.5f),
+ SkFloatToScalar(0.5f),
+ SkFloatToScalar(-40.5f),
+ SkFloatToScalar(-40.5f));
+ canvas->drawRect(rect, paints[p]);
+ canvas->restore();
+ canvas->translate(dx, 0);
+
+ canvas->save();
+ matrix.setScale(SkFloatToScalar(2.1f), SkFloatToScalar(4.1f));
+ canvas->concat(matrix);
+ rect = SkRect::MakeLTRB(SkFloatToScalar(0.1f),
+ SkFloatToScalar(0.1f),
+ SkFloatToScalar(19.1f),
+ SkFloatToScalar(9.1f));
+ canvas->drawRect(rect, paints[p]);
+ canvas->restore();
+ canvas->translate(dx, 0);
+
+ canvas->restore();
+ canvas->translate(0, dy);
+ }
+ }
+ }
+ }
+
+private:
+ int fWidth;
+
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new AARectView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleAll.cpp b/samplecode/SampleAll.cpp
new file mode 100644
index 0000000..abbf8f9
--- /dev/null
+++ b/samplecode/SampleAll.cpp
@@ -0,0 +1,715 @@
+#include "SampleCode.h"
+#include "SkCanvas.h"
+#include "SkView.h"
+#include "Sk1DPathEffect.h"
+#include "Sk2DPathEffect.h"
+#include "SkAvoidXfermode.h"
+#include "SkBlurMaskFilter.h"
+#include "SkColorFilter.h"
+#include "SkColorPriv.h"
+#include "SkCornerPathEffect.h"
+#include "SkDashPathEffect.h"
+#include "SkDiscretePathEffect.h"
+#include "SkEmbossMaskFilter.h"
+#include "SkGradientShader.h"
+#include "SkImageDecoder.h"
+#include "SkLayerRasterizer.h"
+#include "SkMath.h"
+#include "SkPath.h"
+#include "SkRegion.h"
+#include "SkShader.h"
+#include "SkComposeShader.h"
+#include "SkCornerPathEffect.h"
+#include "SkPathMeasure.h"
+#include "SkPicture.h"
+#include "SkRandom.h"
+#include "SkTransparentShader.h"
+#include "SkTypeface.h"
+#include "SkUnitMappers.h"
+#include "SkUtils.h"
+#include "SkXfermode.h"
+
+#include <math.h>
+
+static inline SkPMColor rgb2gray(SkPMColor c) {
+ unsigned r = SkGetPackedR32(c);
+ unsigned g = SkGetPackedG32(c);
+ unsigned b = SkGetPackedB32(c);
+
+ unsigned x = (r * 5 + g * 7 + b * 4) >> 4;
+
+ return SkPackARGB32(0, x, x, x) | (c & (SK_A32_MASK << SK_A32_SHIFT));
+}
+
+class SkGrayScaleColorFilter : public SkColorFilter {
+public:
+ virtual void filterSpan(const SkPMColor src[], int count, SkPMColor result[]) {
+ for (int i = 0; i < count; i++)
+ result[i] = rgb2gray(src[i]);
+ }
+};
+
+class SkChannelMaskColorFilter : public SkColorFilter {
+public:
+ SkChannelMaskColorFilter(U8CPU redMask, U8CPU greenMask, U8CPU blueMask) {
+ fMask = SkPackARGB32(0xFF, redMask, greenMask, blueMask);
+ }
+
+ virtual void filterSpan(const SkPMColor src[], int count, SkPMColor result[]) {
+ SkPMColor mask = fMask;
+ for (int i = 0; i < count; i++) {
+ result[i] = src[i] & mask;
+ }
+ }
+
+private:
+ SkPMColor fMask;
+};
+
+///////////////////////////////////////////////////////////
+
+static void r0(SkLayerRasterizer* rast, SkPaint& p) {
+ p.setMaskFilter(SkBlurMaskFilter::Create(SkIntToScalar(3),
+ SkBlurMaskFilter::kNormal_BlurStyle))->unref();
+ rast->addLayer(p, SkIntToScalar(3), SkIntToScalar(3));
+
+ p.setMaskFilter(NULL);
+ p.setStyle(SkPaint::kStroke_Style);
+ p.setStrokeWidth(SK_Scalar1);
+ rast->addLayer(p);
+
+ p.setAlpha(0x11);
+ p.setStyle(SkPaint::kFill_Style);
+ p.setXfermodeMode(SkXfermode::kSrc_Mode);
+ rast->addLayer(p);
+}
+
+static void r1(SkLayerRasterizer* rast, SkPaint& p) {
+ rast->addLayer(p);
+
+ p.setAlpha(0x40);
+ p.setXfermodeMode(SkXfermode::kSrc_Mode);
+ p.setStyle(SkPaint::kStroke_Style);
+ p.setStrokeWidth(SK_Scalar1*2);
+ rast->addLayer(p);
+}
+
+static void r2(SkLayerRasterizer* rast, SkPaint& p) {
+ p.setStyle(SkPaint::kStrokeAndFill_Style);
+ p.setStrokeWidth(SK_Scalar1*4);
+ rast->addLayer(p);
+
+ p.setStyle(SkPaint::kStroke_Style);
+ p.setStrokeWidth(SK_Scalar1*3/2);
+ p.setXfermodeMode(SkXfermode::kClear_Mode);
+ rast->addLayer(p);
+}
+
+static void r3(SkLayerRasterizer* rast, SkPaint& p) {
+ p.setStyle(SkPaint::kStroke_Style);
+ p.setStrokeWidth(SK_Scalar1*3);
+ rast->addLayer(p);
+
+ p.setAlpha(0x20);
+ p.setStyle(SkPaint::kFill_Style);
+ p.setXfermodeMode(SkXfermode::kSrc_Mode);
+ rast->addLayer(p);
+}
+
+static void r4(SkLayerRasterizer* rast, SkPaint& p) {
+ p.setAlpha(0x60);
+ rast->addLayer(p, SkIntToScalar(3), SkIntToScalar(3));
+
+ p.setAlpha(0xFF);
+ p.setXfermodeMode(SkXfermode::kClear_Mode);
+ rast->addLayer(p, SK_Scalar1*3/2, SK_Scalar1*3/2);
+
+ p.setXfermode(NULL);
+ rast->addLayer(p);
+}
+
+static void r5(SkLayerRasterizer* rast, SkPaint& p) {
+ rast->addLayer(p);
+
+ p.setPathEffect(new SkDiscretePathEffect(SK_Scalar1*4, SK_Scalar1*3))->unref();
+ p.setXfermodeMode(SkXfermode::kSrcOut_Mode);
+ rast->addLayer(p);
+}
+
+static void r6(SkLayerRasterizer* rast, SkPaint& p) {
+ rast->addLayer(p);
+
+ p.setAntiAlias(false);
+ SkLayerRasterizer* rast2 = new SkLayerRasterizer;
+ r5(rast2, p);
+ p.setRasterizer(rast2)->unref();
+ p.setXfermodeMode(SkXfermode::kClear_Mode);
+ rast->addLayer(p);
+}
+
+class Dot2DPathEffect : public Sk2DPathEffect {
+public:
+ Dot2DPathEffect(SkScalar radius, const SkMatrix& matrix)
+ : Sk2DPathEffect(matrix), fRadius(radius) {}
+
+ virtual void flatten(SkFlattenableWriteBuffer& buffer) {
+ this->INHERITED::flatten(buffer);
+
+ buffer.writeScalar(fRadius);
+ }
+ virtual Factory getFactory() { return CreateProc; }
+
+protected:
+ virtual void next(const SkPoint& loc, int u, int v, SkPath* dst) {
+ dst->addCircle(loc.fX, loc.fY, fRadius);
+ }
+
+ Dot2DPathEffect(SkFlattenableReadBuffer& buffer) : Sk2DPathEffect(buffer) {
+ fRadius = buffer.readScalar();
+ }
+private:
+ SkScalar fRadius;
+
+ static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer) {
+ return new Dot2DPathEffect(buffer);
+ }
+
+ typedef Sk2DPathEffect INHERITED;
+};
+
+static void r7(SkLayerRasterizer* rast, SkPaint& p) {
+ SkMatrix lattice;
+ lattice.setScale(SK_Scalar1*6, SK_Scalar1*6, 0, 0);
+ lattice.postSkew(SK_Scalar1/3, 0, 0, 0);
+ p.setPathEffect(new Dot2DPathEffect(SK_Scalar1*4, lattice))->unref();
+ rast->addLayer(p);
+}
+
+static void r8(SkLayerRasterizer* rast, SkPaint& p) {
+ rast->addLayer(p);
+
+ SkMatrix lattice;
+ lattice.setScale(SK_Scalar1*6, SK_Scalar1*6, 0, 0);
+ lattice.postSkew(SK_Scalar1/3, 0, 0, 0);
+ p.setPathEffect(new Dot2DPathEffect(SK_Scalar1*2, lattice))->unref();
+ p.setXfermodeMode(SkXfermode::kClear_Mode);
+ rast->addLayer(p);
+
+ p.setPathEffect(NULL);
+ p.setXfermode(NULL);
+ p.setStyle(SkPaint::kStroke_Style);
+ p.setStrokeWidth(SK_Scalar1);
+ rast->addLayer(p);
+}
+
+class Line2DPathEffect : public Sk2DPathEffect {
+public:
+ Line2DPathEffect(SkScalar width, const SkMatrix& matrix)
+ : Sk2DPathEffect(matrix), fWidth(width) {}
+
+ virtual bool filterPath(SkPath* dst, const SkPath& src, SkScalar* width) {
+ if (this->INHERITED::filterPath(dst, src, width)) {
+ *width = fWidth;
+ return true;
+ }
+ return false;
+ }
+
+ virtual Factory getFactory() { return CreateProc; }
+ virtual void flatten(SkFlattenableWriteBuffer& buffer) {
+ this->INHERITED::flatten(buffer);
+ buffer.writeScalar(fWidth);
+ }
+protected:
+ virtual void nextSpan(int u, int v, int ucount, SkPath* dst) {
+ if (ucount > 1) {
+ SkPoint src[2], dstP[2];
+
+ src[0].set(SkIntToScalar(u) + SK_ScalarHalf,
+ SkIntToScalar(v) + SK_ScalarHalf);
+ src[1].set(SkIntToScalar(u+ucount) + SK_ScalarHalf,
+ SkIntToScalar(v) + SK_ScalarHalf);
+ this->getMatrix().mapPoints(dstP, src, 2);
+
+ dst->moveTo(dstP[0]);
+ dst->lineTo(dstP[1]);
+ }
+ }
+
+ Line2DPathEffect(SkFlattenableReadBuffer& buffer) : Sk2DPathEffect(buffer) {
+ fWidth = buffer.readScalar();
+ }
+
+private:
+ SkScalar fWidth;
+
+ static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer) { return new Line2DPathEffect(buffer); }
+
+ typedef Sk2DPathEffect INHERITED;
+};
+
+static void r9(SkLayerRasterizer* rast, SkPaint& p) {
+ rast->addLayer(p);
+
+ SkMatrix lattice;
+ lattice.setScale(SK_Scalar1, SK_Scalar1*6, 0, 0);
+ lattice.postRotate(SkIntToScalar(30), 0, 0);
+ p.setPathEffect(new Line2DPathEffect(SK_Scalar1*2, lattice))->unref();
+ p.setXfermodeMode(SkXfermode::kClear_Mode);
+ rast->addLayer(p);
+
+ p.setPathEffect(NULL);
+ p.setXfermode(NULL);
+ p.setStyle(SkPaint::kStroke_Style);
+ p.setStrokeWidth(SK_Scalar1);
+ rast->addLayer(p);
+}
+
+typedef void (*raster_proc)(SkLayerRasterizer*, SkPaint&);
+
+static const raster_proc gRastProcs[] = {
+ r0, r1, r2, r3, r4, r5, r6, r7, r8, r9
+};
+
+static const struct {
+ SkColor fMul, fAdd;
+} gLightingColors[] = {
+ { 0x808080, 0x800000 }, // general case
+ { 0x707070, 0x707070 }, // no-pin case
+ { 0xFFFFFF, 0x800000 }, // just-add case
+ { 0x808080, 0x000000 }, // just-mul case
+ { 0xFFFFFF, 0x000000 } // identity case
+};
+
+static unsigned color_dist16(uint16_t a, uint16_t b) {
+ unsigned dr = SkAbs32(SkPacked16ToR32(a) - SkPacked16ToR32(b));
+ unsigned dg = SkAbs32(SkPacked16ToG32(a) - SkPacked16ToG32(b));
+ unsigned db = SkAbs32(SkPacked16ToB32(a) - SkPacked16ToB32(b));
+
+ return SkMax32(dr, SkMax32(dg, db));
+}
+
+static unsigned scale_dist(unsigned dist, unsigned scale) {
+ dist >>= 6;
+ dist = (dist << 2) | dist;
+ dist = (dist << 4) | dist;
+ return dist;
+
+// return SkAlphaMul(dist, scale);
+}
+
+static void apply_shader(SkPaint* paint, int index) {
+ raster_proc proc = gRastProcs[index];
+ if (proc) {
+ SkPaint p;
+ SkLayerRasterizer* rast = new SkLayerRasterizer;
+
+ p.setAntiAlias(true);
+ proc(rast, p);
+ paint->setRasterizer(rast)->unref();
+ }
+
+#if 1
+ SkScalar dir[] = { SK_Scalar1, SK_Scalar1, SK_Scalar1 };
+ paint->setMaskFilter(SkBlurMaskFilter::CreateEmboss(dir, SK_Scalar1/4, SkIntToScalar(4), SkIntToScalar(3)))->unref();
+ paint->setColor(SK_ColorBLUE);
+#endif
+}
+
+class DemoView : public SampleView {
+public:
+ DemoView() {}
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "Demo");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ virtual bool onClick(Click* click) {
+ return this->INHERITED::onClick(click);
+ }
+
+ void makePath(SkPath& path) {
+ path.addCircle(SkIntToScalar(20), SkIntToScalar(20), SkIntToScalar(20),
+ SkPath::kCCW_Direction);
+ for (int index = 0; index < 10; index++) {
+ SkScalar x = SkFloatToScalar(cos(index / 10.0f * 2 * 3.1415925358f));
+ SkScalar y = SkFloatToScalar(sin(index / 10.0f * 2 * 3.1415925358f));
+ x *= index & 1 ? 7 : 14;
+ y *= index & 1 ? 7 : 14;
+ x += SkIntToScalar(20);
+ y += SkIntToScalar(20);
+ if (index == 0)
+ path.moveTo(x, y);
+ else
+ path.lineTo(x, y);
+ }
+ path.close();
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ canvas->save();
+ drawPicture(canvas, 0);
+ canvas->restore();
+
+ {
+ SkPicture picture;
+ SkCanvas* record = picture.beginRecording(320, 480);
+ drawPicture(record, 120);
+ canvas->translate(0, SkIntToScalar(120));
+
+ SkRect clip;
+ clip.set(0, 0, SkIntToScalar(160), SkIntToScalar(160));
+ do {
+ canvas->save();
+ canvas->clipRect(clip);
+ picture.draw(canvas);
+ canvas->restore();
+ if (clip.fRight < SkIntToScalar(320))
+ clip.offset(SkIntToScalar(160), 0);
+ else if (clip.fBottom < SkIntToScalar(480))
+ clip.offset(-SkIntToScalar(320), SkIntToScalar(160));
+ else
+ break;
+ } while (true);
+ }
+ }
+
+ void drawPicture(SkCanvas* canvas, int spriteOffset) {
+ SkMatrix matrix; matrix.reset();
+ SkPaint paint;
+ SkPath path;
+ SkPoint start = {0, 0};
+ SkPoint stop = { SkIntToScalar(40), SkIntToScalar(40) };
+ SkRect rect = {0, 0, SkIntToScalar(40), SkIntToScalar(40) };
+ SkRect rect2 = {0, 0, SkIntToScalar(65), SkIntToScalar(20) };
+ SkScalar left = 0, top = 0, x = 0, y = 0;
+ size_t index;
+
+ char ascii[] = "ascii...";
+ size_t asciiLength = sizeof(ascii) - 1;
+ char utf8[] = "utf8" "\xe2\x80\xa6";
+ short utf16[] = {'u', 't', 'f', '1', '6', 0x2026 };
+ short utf16simple[] = {'u', 't', 'f', '1', '6', '!' };
+
+ makePath(path);
+ SkTDArray<SkPoint>(pos);
+ pos.setCount(asciiLength);
+ for (index = 0; index < asciiLength; index++)
+ pos[index].set(SkIntToScalar(index * 10), SkIntToScalar(index * 2));
+ SkTDArray<SkPoint>(pos2);
+ pos2.setCount(asciiLength);
+ for (index = 0; index < asciiLength; index++)
+ pos2[index].set(SkIntToScalar(index * 10), SkIntToScalar(20));
+
+ // shaders
+ SkPoint linearPoints[] = { { 0, 0, }, { SkIntToScalar(40), SkIntToScalar(40) } };
+ SkColor linearColors[] = { SK_ColorRED, SK_ColorBLUE };
+ SkScalar* linearPos = NULL;
+ int linearCount = 2;
+ SkShader::TileMode linearMode = SkShader::kMirror_TileMode;
+ SkUnitMapper* linearMapper = new SkDiscreteMapper(3);
+ SkAutoUnref unmapLinearMapper(linearMapper);
+ SkShader* linear = SkGradientShader::CreateLinear(linearPoints,
+ linearColors, linearPos, linearCount, linearMode, linearMapper);
+
+ SkPoint radialCenter = { SkIntToScalar(25), SkIntToScalar(25) };
+ SkScalar radialRadius = SkIntToScalar(25);
+ SkColor radialColors[] = { SK_ColorGREEN, SK_ColorGRAY, SK_ColorRED };
+ SkScalar radialPos[] = { 0, SkIntToScalar(3) / 5, SkIntToScalar(1)};
+ int radialCount = 3;
+ SkShader::TileMode radialMode = SkShader::kRepeat_TileMode;
+ SkUnitMapper* radialMapper = new SkCosineMapper();
+ SkAutoUnref unmapRadialMapper(radialMapper);
+ SkShader* radial = SkGradientShader::CreateRadial(radialCenter,
+ radialRadius, radialColors, radialPos, radialCount,
+ radialMode, radialMapper);
+
+ SkTransparentShader* transparentShader = new SkTransparentShader();
+ SkEmbossMaskFilter::Light light;
+ light.fDirection[0] = SK_Scalar1/2;
+ light.fDirection[1] = SK_Scalar1/2;
+ light.fDirection[2] = SK_Scalar1/3;
+ light.fAmbient = 0x48;
+ light.fSpecular = 0x80;
+ SkScalar radius = SkIntToScalar(12)/5;
+ SkEmbossMaskFilter* embossFilter = new SkEmbossMaskFilter(light,
+ radius);
+
+ SkXfermode* xfermode = SkXfermode::Create(SkXfermode::kXor_Mode);
+ SkColorFilter* lightingFilter = SkColorFilter::CreateLightingFilter(
+ 0xff89bc45, 0xff112233);
+
+ canvas->save();
+ canvas->translate(SkIntToScalar(0), SkIntToScalar(5));
+ paint.setFlags(SkPaint::kAntiAlias_Flag | SkPaint::kFilterBitmap_Flag);
+ // !!! draw through a clip
+ paint.setColor(SK_ColorLTGRAY);
+ paint.setStyle(SkPaint::kFill_Style);
+ SkRect clip = {0, 0, SkIntToScalar(320), SkIntToScalar(120)};
+ canvas->clipRect(clip);
+ paint.setShader(SkShader::CreateBitmapShader(fTx,
+ SkShader::kMirror_TileMode, SkShader::kRepeat_TileMode))->unref();
+ canvas->drawPaint(paint);
+ canvas->save();
+
+ // line (exercises xfermode, colorShader, colorFilter, filterShader)
+ paint.setColor(SK_ColorGREEN);
+ paint.setStrokeWidth(SkIntToScalar(10));
+ paint.setStyle(SkPaint::kStroke_Style);
+ paint.setXfermode(xfermode)->unref();
+ paint.setColorFilter(lightingFilter)->unref();
+ canvas->drawLine(start.fX, start.fY, stop.fX, stop.fY, paint); // should not be green
+ paint.setXfermode(NULL);
+ paint.setColorFilter(NULL);
+
+ // rectangle
+ paint.setStyle(SkPaint::kFill_Style);
+ canvas->translate(SkIntToScalar(50), 0);
+ paint.setColor(SK_ColorYELLOW);
+ paint.setShader(linear)->unref();
+ paint.setPathEffect(pathEffectTest())->unref();
+ canvas->drawRect(rect, paint);
+ paint.setPathEffect(NULL);
+
+ // circle w/ emboss & transparent (exercises 3dshader)
+ canvas->translate(SkIntToScalar(50), 0);
+ paint.setMaskFilter(embossFilter)->unref();
+ canvas->drawOval(rect, paint);
+ canvas->translate(SkIntToScalar(10), SkIntToScalar(10));
+ paint.setShader(transparentShader)->unref();
+ canvas->drawOval(rect, paint);
+ canvas->translate(0, SkIntToScalar(-10));
+
+ // path
+ canvas->translate(SkIntToScalar(50), 0);
+ paint.setColor(SK_ColorRED);
+ paint.setStyle(SkPaint::kStroke_Style);
+ paint.setStrokeWidth(SkIntToScalar(5));
+ paint.setShader(radial)->unref();
+ paint.setMaskFilter(NULL);
+ canvas->drawPath(path, paint);
+
+ paint.setShader(NULL);
+ // bitmap, sprite
+ canvas->translate(SkIntToScalar(50), 0);
+ paint.setStyle(SkPaint::kFill_Style);
+ canvas->drawBitmap(fBug, left, top, &paint);
+ canvas->translate(SkIntToScalar(30), 0);
+ canvas->drawSprite(fTb,
+ SkScalarRound(canvas->getTotalMatrix().getTranslateX()),
+ spriteOffset + 10, &paint);
+
+ canvas->translate(-SkIntToScalar(30), SkIntToScalar(30));
+ paint.setShader(shaderTest())->unref(); // test compose shader
+ canvas->drawRect(rect2, paint);
+ paint.setShader(NULL);
+
+ canvas->restore();
+ // text
+ canvas->translate(0, SkIntToScalar(60));
+ canvas->save();
+ paint.setColor(SK_ColorGRAY);
+ canvas->drawPosText(ascii, asciiLength, pos.begin(), paint);
+ canvas->drawPosText(ascii, asciiLength, pos2.begin(), paint);
+
+ canvas->translate(SkIntToScalar(50), 0);
+ paint.setColor(SK_ColorCYAN);
+ canvas->drawText(utf8, sizeof(utf8) - 1, x, y, paint);
+
+ canvas->translate(SkIntToScalar(30), 0);
+ paint.setColor(SK_ColorMAGENTA);
+ paint.setTextEncoding(SkPaint::kUTF16_TextEncoding);
+ matrix.setTranslate(SkIntToScalar(10), SkIntToScalar(10));
+ canvas->drawTextOnPath((void*) utf16, sizeof(utf16), path, &matrix, paint);
+ canvas->translate(0, SkIntToScalar(20));
+ canvas->drawTextOnPath((void*) utf16simple, sizeof(utf16simple), path, &matrix, paint);
+ canvas->restore();
+
+ canvas->translate(0, SkIntToScalar(60));
+ paint.setTextEncoding(SkPaint::kUTF8_TextEncoding);
+ canvas->restore();
+ }
+
+ /*
+./SkColorFilter.h:25:class SkColorFilter : public SkFlattenable { -- abstract
+ static SkColorFilter* CreatXfermodeFilter() *** untested ***
+ static SkColorFilter* CreatePorterDuffFilter() *** untested ***
+ static SkColorFilter* CreateLightingFilter() -- tested
+./SkDrawLooper.h:9:class SkDrawLooper : public SkFlattenable { -- virtually abstract
+ ./SkBlurDrawLooper.h:9:class SkBlurDrawLooper : public SkDrawLooper { *** untested ***
+./SkMaskFilter.h:41:class SkMaskFilter : public SkFlattenable { -- abstract chmod +w .h
+ ./SkEmbossMaskFilter.h:27:class SkEmbossMaskFilter : public SkMaskFilter { -- tested
+./SkPathEffect.h:33:class SkPathEffect : public SkFlattenable { -- abstract
+ ./Sk1DPathEffect.h:27:class Sk1DPathEffect : public SkPathEffect { -- abstract
+ ./Sk1DPathEffect.h:48:class SkPath1DPathEffect : public Sk1DPathEffect { -- tested
+ ./Sk2DPathEffect.h:25:class Sk2DPathEffect : public SkPathEffect { *** untested ***
+ ./SkCornerPathEffect.h:28:class SkCornerPathEffect : public SkPathEffect { *** untested ***
+ ./SkDashPathEffect.h:27:class SkDashPathEffect : public SkPathEffect {
+ ./SkDiscretePathEffect.h:27:class SkDiscretePathEffect : public SkPathEffect {
+ ./SkPaint.h:760:class SkStrokePathEffect : public SkPathEffect {
+ ./SkPathEffect.h:58:class SkPairPathEffect : public SkPathEffect {
+ ./SkPathEffect.h:78:class SkComposePathEffect : public SkPairPathEffect {
+ ./SkPathEffect.h:114:class SkSumPathEffect : public SkPairPathEffect {
+./SkRasterizer.h:29:class SkRasterizer : public SkFlattenable {
+ ./SkLayerRasterizer.h:27:class SkLayerRasterizer : public SkRasterizer {
+./SkShader.h:36:class SkShader : public SkFlattenable {
+ ./SkColorFilter.h:59:class SkFilterShader : public SkShader {
+ ./SkColorShader.h:26:class SkColorShader : public SkShader {
+ ./SkShaderExtras.h:31:class SkComposeShader : public SkShader {
+ ./SkTransparentShader.h:23:class SkTransparentShader : public SkShader {
+./SkUnitMapper.h:24:class SkUnitMapper : public SkFlattenable {
+ ./SkUnitMapper.h:33:class SkDiscreteMapper : public SkUnitMapper {
+ ./SkUnitMapper.h:51:class SkFlipCosineMapper : public SkUnitMapper {
+./SkXfermode.h:32:class SkXfermode : public SkFlattenable {
+ ./SkAvoidXfermode.h:28:class SkAvoidXfermode : public SkXfermode { *** not done *** chmod +w .h .cpp
+ ./SkXfermode.h:54:class SkProcXfermode : public SkXfermode {
+ */
+
+ /*
+./SkBlurMaskFilter.h:25:class SkBlurMaskFilter {
+ chmod +w SkBlurMaskFilter.cpp
+./SkGradientShader.h:30:class SkGradientShader {
+ */
+ // save layer, bounder, looper
+ // matrix
+ // clip /path/region
+ // bitmap proc shader ?
+
+/* untested:
+SkCornerPathEffect.h:28:class SkCornerPathEffect : public SkPathEffect {
+*/
+
+ virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
+ fClickPt.set(x, y);
+ this->inval(NULL);
+ return this->INHERITED::onFindClickHandler(x, y);
+ }
+
+ SkPathEffect* pathEffectTest() {
+ static const int gXY[] = { 1, 0, 0, -1, 2, -1, 3, 0, 2, 1, 0, 1 };
+ SkScalar gPhase = 0;
+ SkPath path;
+ path.moveTo(SkIntToScalar(gXY[0]), SkIntToScalar(gXY[1]));
+ for (unsigned i = 2; i < SK_ARRAY_COUNT(gXY); i += 2)
+ path.lineTo(SkIntToScalar(gXY[i]), SkIntToScalar(gXY[i+1]));
+ path.close();
+ path.offset(SkIntToScalar(-6), 0);
+ SkPathEffect* outer = new SkPath1DPathEffect(path, SkIntToScalar(12),
+ gPhase, SkPath1DPathEffect::kRotate_Style);
+ SkPathEffect* inner = new SkDiscretePathEffect(SkIntToScalar(2),
+ SkIntToScalar(1)/10); // SkCornerPathEffect(SkIntToScalar(2));
+ SkPathEffect* result = new SkComposePathEffect(outer, inner);
+ outer->unref();
+ inner->unref();
+ return result;
+ }
+
+ SkPathEffect* pathEffectTest2() { // unsure this works (has no visible effect)
+ SkPathEffect* outer = new SkStrokePathEffect(SkIntToScalar(4),
+ SkPaint::kStroke_Style, SkPaint::kMiter_Join, SkPaint::kButt_Cap);
+ static const SkScalar intervals[] = {SkIntToScalar(1), SkIntToScalar(2),
+ SkIntToScalar(2), SkIntToScalar(1)};
+ SkPathEffect* inner = new SkDashPathEffect(intervals,
+ sizeof(intervals) / sizeof(intervals[0]), 0);
+ SkPathEffect* result = new SkSumPathEffect(outer, inner);
+ outer->unref();
+ inner->unref();
+ return result;
+ }
+
+ SkShader* shaderTest() {
+ SkPoint pts[] = { { 0, 0, }, { SkIntToScalar(100), 0 } };
+ SkColor colors[] = { SK_ColorRED, SK_ColorBLUE };
+ SkShader* shaderA = SkGradientShader::CreateLinear(pts, colors, NULL,
+ 2, SkShader::kClamp_TileMode);
+ pts[1].set(0, SkIntToScalar(100));
+ SkColor colors2[] = {SK_ColorBLACK, SkColorSetARGB(0x80, 0, 0, 0)};
+ SkShader* shaderB = SkGradientShader::CreateLinear(pts, colors2, NULL,
+ 2, SkShader::kClamp_TileMode);
+ SkXfermode* mode = SkXfermode::Create(SkXfermode::kDstIn_Mode);
+ SkShader* result = new SkComposeShader(shaderA, shaderB, mode);
+ shaderA->unref();
+ shaderB->unref();
+ mode->unref();
+ return result;
+ }
+
+ virtual void startTest() {
+ SkImageDecoder::DecodeFile("/Users/caryclark/Desktop/bugcirc.gif", &fBug);
+ SkImageDecoder::DecodeFile("/Users/caryclark/Desktop/tbcirc.gif", &fTb);
+ SkImageDecoder::DecodeFile("/Users/caryclark/Desktop/05psp04.gif", &fTx);
+ }
+
+ void drawRaster(SkCanvas* canvas) {
+ for (size_t index = 0; index < SK_ARRAY_COUNT(gRastProcs); index++)
+ drawOneRaster(canvas);
+ }
+
+ void drawOneRaster(SkCanvas* canvas) {
+ canvas->save();
+
+ SkScalar x = SkIntToScalar(20);
+ SkScalar y = SkIntToScalar(40);
+ SkPaint paint;
+
+ paint.setAntiAlias(true);
+ paint.setTextSize(SkIntToScalar(48));
+ paint.setTypeface(SkTypeface::CreateFromName("sans-serif",
+ SkTypeface::kBold));
+
+ SkString str("GOOGLE");
+
+ for (size_t i = 0; i < SK_ARRAY_COUNT(gRastProcs); i++) {
+ apply_shader(&paint, i);
+
+ // paint.setMaskFilter(NULL);
+ // paint.setColor(SK_ColorBLACK);
+
+#if 01
+ int index = i % SK_ARRAY_COUNT(gLightingColors);
+ paint.setColorFilter(SkColorFilter::CreateLightingFilter(
+ gLightingColors[index].fMul,
+ gLightingColors[index].fAdd))->unref();
+#endif
+
+ canvas->drawText(str.c_str(), str.size(), x, y, paint);
+ SkRect oval = { x, y - SkIntToScalar(40), x + SkIntToScalar(40), y };
+ paint.setStyle(SkPaint::kStroke_Style);
+ canvas->drawOval(oval, paint);
+ paint.setStyle(SkPaint::kFill_Style);
+
+ y += paint.getFontSpacing();
+ }
+
+ canvas->restore();
+
+ if (1) {
+ SkAvoidXfermode mode(SK_ColorWHITE, 0xFF,
+ SkAvoidXfermode::kTargetColor_Mode);
+ SkPaint paint;
+ x += SkIntToScalar(20);
+ SkRect r = { x, 0, x + SkIntToScalar(360), SkIntToScalar(700) };
+ paint.setXfermode(&mode);
+ paint.setColor(SK_ColorGREEN);
+ paint.setAntiAlias(true);
+ canvas->drawOval(r, paint);
+ }
+ }
+
+private:
+ SkPoint fClickPt;
+ SkBitmap fBug, fTb, fTx;
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new DemoView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleAnimatedGradient.cpp b/samplecode/SampleAnimatedGradient.cpp
new file mode 100644
index 0000000..a7b2a46
--- /dev/null
+++ b/samplecode/SampleAnimatedGradient.cpp
@@ -0,0 +1,90 @@
+#include "SampleCode.h"
+#include "SkCanvas.h"
+#include "SkGradientShader.h"
+
+class GradientView : public SampleView {
+public:
+ GradientView() {
+ this->setBGColor(0xFFDDDDDD);
+ }
+
+protected:
+ struct GradData {
+ int fCount;
+ const SkColor* fColors;
+ const SkScalar* fPos;
+ };
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "Gradients");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+ virtual void onDrawContent(SkCanvas* canvas) {
+ SkPaint paint;
+ paint.setAntiAlias(true);
+ paint.setStyle(SkPaint::kStroke_Style);
+ paint.setStrokeWidth(SkScalarHalf(SkIntToScalar(3)));
+ paint.setStyle(SkPaint::kFill_Style);
+
+ SkPoint p = SkPoint::Make(0,0);
+ SkPoint q = SkPoint::Make(100,100);
+ SkPoint pts[] = {p, q};
+
+ SkScalar t, temp, x, y;
+ SkColor gColors[] = {
+ SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorWHITE, SK_ColorBLACK
+ };
+ t = SampleCode::GetAnimScalar(SkIntToScalar(2), SkIntToScalar(20));
+ temp = SampleCode::GetAnimScalar(SkIntToScalar(1), SkIntToScalar(8));
+ SkScalar step = SK_ScalarPI / (10);
+ SkScalar angle = t * step;
+ x = SkScalarSinCos(angle, &y);
+ SkScalar colorPositions[] = { 0, 0.1 + x, 0.4 + y, 0.9 - x + y, 1.0};
+ GradData data = { 5, gColors, colorPositions };
+
+
+ SkRect r = { 0, 0, SkIntToScalar(200), SkIntToScalar(200) };
+ SkShader* shader1 = SkGradientShader::CreateLinear(
+ pts, data.fColors, data.fPos,data.fCount,
+ SkShader::kMirror_TileMode);
+ paint.setShader(shader1)->unref();
+
+ canvas->drawRect(r, paint);
+
+
+ SkPoint s = SkPoint::Make(100,100);
+ SkShader* shader2 = SkGradientShader::CreateRadial(
+ s, 100, data.fColors, data.fPos, data.fCount,
+ SkShader::kMirror_TileMode);
+ paint.setShader(shader2)->unref();
+ canvas->translate(250, 0);
+ canvas->drawRect(r, paint);
+
+ SkShader* shader3 = SkGradientShader::CreateTwoPointRadial(
+ p, 0, q, 100, data.fColors, data.fPos, data.fCount,
+ SkShader::kMirror_TileMode);
+ paint.setShader(shader3)->unref();
+ canvas->translate(0, 250);
+ canvas->drawRect(r, paint);
+
+ SkShader* shader4 = SkGradientShader::CreateSweep(
+ 100, 100, data.fColors, data.fPos, data.fCount);
+
+ paint.setShader(shader4)->unref();
+ canvas->translate(-250, 0);
+ canvas->drawRect(r, paint);
+
+ this->inval(NULL);
+ }
+
+private:
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new GradientView; }
+static SkViewRegister reg(MyFactory);
\ No newline at end of file
diff --git a/samplecode/SampleAnimator.cpp b/samplecode/SampleAnimator.cpp
new file mode 100644
index 0000000..99173fc
--- /dev/null
+++ b/samplecode/SampleAnimator.cpp
@@ -0,0 +1,159 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+
+#include "SkAnimator.h"
+#include "SkStream.h"
+#include "SkDOM.h"
+
+///////////////////////////////////////////////////////////////////////////////
+
+class SkAnimatorView : public SkView {
+public:
+ SkAnimatorView();
+ virtual ~SkAnimatorView();
+
+ void setURIBase(const char dir[]);
+
+ SkAnimator* getAnimator() const { return fAnimator; }
+
+ bool decodeFile(const char path[]);
+ bool decodeMemory(const void* buffer, size_t size);
+ bool decodeStream(SkStream* stream);
+
+protected:
+ // overrides
+ virtual void onDraw(SkCanvas*);
+
+private:
+ SkString fBaseURI;
+ SkAnimator* fAnimator;
+
+ typedef SkView INHERITED;
+};
+
+SkAnimatorView::SkAnimatorView() : fAnimator(NULL) {}
+
+SkAnimatorView::~SkAnimatorView() {
+ delete fAnimator;
+}
+
+void SkAnimatorView::setURIBase(const char dir[]) {
+ fBaseURI.set(dir);
+}
+
+bool SkAnimatorView::decodeFile(const char path[]) {
+ SkFILEStream* is = new SkFILEStream(path);
+ SkAutoUnref aur(is);
+ return is->isValid() && this->decodeStream(is);
+}
+
+bool SkAnimatorView::decodeMemory(const void* buffer, size_t size) {
+ SkMemoryStream* is = new SkMemoryStream(buffer, size);
+ SkAutoUnref aur(is);
+ return this->decodeStream(is);
+}
+
+static const SkDOMNode* find_nodeID(const SkDOM& dom,
+ const SkDOMNode* node, const char name[]) {
+ if (NULL == node) {
+ node = dom.getRootNode();
+ }
+ do {
+ const char* idval = dom.findAttr(node, "id");
+ if (idval && !strcmp(idval, name)) {
+ return node;
+ }
+ const SkDOMNode* child = dom.getFirstChild(node);
+ if (child) {
+ const SkDOMNode* found = find_nodeID(dom, child, name);
+ if (found) {
+ return found;
+ }
+ }
+ } while ((node = dom.getNextSibling(node)) != NULL);
+ return NULL;
+}
+
+bool SkAnimatorView::decodeStream(SkStream* stream) {
+ delete fAnimator;
+ fAnimator = new SkAnimator;
+ fAnimator->setURIBase(fBaseURI.c_str());
+#if 0
+ if (!fAnimator->decodeStream(stream)) {
+ delete fAnimator;
+ fAnimator = NULL;
+ return false;
+ }
+#else
+ size_t len = stream->getLength();
+ char* text = (char*)sk_malloc_throw(len);
+ stream->read(text, len);
+ SkDOM dom;
+ const SkDOM::Node* root = dom.build(text, len);
+ if (NULL == root) {
+ return false;
+ }
+ if (!fAnimator->decodeDOM(dom, root)) {
+ delete fAnimator;
+ fAnimator = NULL;
+ return false;
+ }
+ for (int i = 0; i <= 10; i++) {
+ SkString name("glyph");
+ name.appendS32(i);
+ const SkDOM::Node* node = find_nodeID(dom, NULL, name.c_str());
+ SkASSERT(node);
+ SkRect r;
+ dom.findScalar(node, "left", &r.fLeft);
+ dom.findScalar(node, "top", &r.fTop);
+ dom.findScalar(node, "width", &r.fRight); r.fRight += r.fLeft;
+ dom.findScalar(node, "height", &r.fBottom); r.fBottom += r.fTop;
+ SkDebugf("--- %s [%g %g %g %g]\n", name.c_str(),
+ r.fLeft, r.fTop, r.fRight, r.fBottom);
+ }
+#endif
+ return true;
+}
+
+#include "SkTime.h"
+
+void SkAnimatorView::onDraw(SkCanvas* canvas) {
+ if (fAnimator) {
+ canvas->drawColor(SK_ColorWHITE);
+ fAnimator->draw(canvas, 0);
+#if 0
+ canvas->save();
+ canvas->translate(120, 30);
+ canvas->scale(0.5, 0.5);
+ fAnimator->draw(canvas, 0);
+ canvas->restore();
+
+ canvas->save();
+ canvas->translate(190, 40);
+ canvas->scale(0.25, 0.25);
+ fAnimator->draw(canvas, 0);
+ canvas->restore();
+
+ this->inval(NULL);
+#endif
+ }
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() {
+ SkAnimatorView* av = new SkAnimatorView;
+// av->decodeFile("/skimages/test.xml");
+#if 0
+ av->setURIBase("/skia/trunk/animations/");
+ av->decodeFile("/skia/trunk/animations/checkbox.xml");
+#else
+ av->setURIBase("/");
+ av->decodeFile("/testanim.txt");
+#endif
+ return av;
+}
+
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleApp.cpp b/samplecode/SampleApp.cpp
new file mode 100644
index 0000000..3efffe6
--- /dev/null
+++ b/samplecode/SampleApp.cpp
@@ -0,0 +1,1647 @@
+#include "SkCanvas.h"
+#include "SkDevice.h"
+#include "SkGpuCanvas.h"
+#include "SkGraphics.h"
+#include "SkImageEncoder.h"
+#include "SkPaint.h"
+#include "SkPicture.h"
+#include "SkStream.h"
+#include "SkTime.h"
+#include "SkWindow.h"
+
+#include "SampleCode.h"
+#include "GrContext.h"
+#include "SkTouchGesture.h"
+#include "SkTypeface.h"
+
+#define TEST_GPIPEx
+
+#ifdef TEST_GPIPE
+#define PIPE_FILE
+#define FILE_PATH "/path/to/drawing.data"
+#endif
+
+#define USE_ARROWS_FOR_ZOOM true
+//#define DEFAULT_TO_GPU
+
+extern SkView* create_overview(int, const SkViewFactory[]);
+
+#define SK_SUPPORT_GL
+
+#define ANIMATING_EVENTTYPE "nextSample"
+#define ANIMATING_DELAY 750
+
+#ifdef SK_DEBUG
+ #define FPS_REPEAT_MULTIPLIER 1
+#else
+ #define FPS_REPEAT_MULTIPLIER 10
+#endif
+#define FPS_REPEAT_COUNT (10 * FPS_REPEAT_MULTIPLIER)
+
+#ifdef SK_SUPPORT_GL
+ #include "GrGLConfig.h"
+#endif
+
+///////////////
+static const char view_inval_msg[] = "view-inval-msg";
+
+static void postInvalDelay(SkEventSinkID sinkID) {
+ SkEvent* evt = new SkEvent(view_inval_msg);
+ evt->post(sinkID, 1);
+}
+
+static bool isInvalEvent(const SkEvent& evt) {
+ return evt.isType(view_inval_msg);
+}
+//////////////////
+
+SkViewRegister* SkViewRegister::gHead;
+SkViewRegister::SkViewRegister(SkViewFactory fact) : fFact(fact) {
+ static bool gOnce;
+ if (!gOnce) {
+ gHead = NULL;
+ gOnce = true;
+ }
+
+ fChain = gHead;
+ gHead = this;
+}
+
+#if defined(SK_SUPPORT_GL)
+ #define SK_USE_SHADERS
+#endif
+
+#ifdef SK_BUILD_FOR_MAC
+#include <CoreFoundation/CoreFoundation.h>
+#include <CoreFoundation/CFURLAccess.h>
+
+static void testpdf() {
+ CFStringRef path = CFStringCreateWithCString(NULL, "/test.pdf",
+ kCFStringEncodingUTF8);
+ CFURLRef url = CFURLCreateWithFileSystemPath(NULL, path,
+ kCFURLPOSIXPathStyle,
+ false);
+ CFRelease(path);
+ CGRect box = CGRectMake(0, 0, 8*72, 10*72);
+ CGContextRef cg = CGPDFContextCreateWithURL(url, &box, NULL);
+ CFRelease(url);
+
+ CGContextBeginPage(cg, &box);
+ CGRect r = CGRectMake(10, 10, 40 + 0.5, 50 + 0.5);
+ CGContextFillEllipseInRect(cg, r);
+ CGContextEndPage(cg);
+ CGContextRelease(cg);
+
+ if (false) {
+ SkBitmap bm;
+ bm.setConfig(SkBitmap::kA8_Config, 64, 64);
+ bm.allocPixels();
+ bm.eraseColor(0);
+
+ SkCanvas canvas(bm);
+
+ }
+}
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+
+enum FlipAxisEnum {
+ kFlipAxis_X = (1 << 0),
+ kFlipAxis_Y = (1 << 1)
+};
+
+enum SkTriState {
+ kFalse_SkTriState,
+ kTrue_SkTriState,
+ kUnknown_SkTriState,
+};
+
+static SkTriState cycle_tristate(SkTriState state) {
+ static const SkTriState gCycle[] = {
+ /* kFalse_SkTriState -> */ kUnknown_SkTriState,
+ /* kTrue_SkTriState -> */ kFalse_SkTriState,
+ /* kUnknown_SkTriState -> */ kTrue_SkTriState,
+ };
+ return gCycle[state];
+}
+
+#include "SkDrawFilter.h"
+
+class FlagsDrawFilter : public SkDrawFilter {
+public:
+ FlagsDrawFilter(SkTriState lcd, SkTriState aa, SkTriState filter,
+ SkTriState hinting) :
+ fLCDState(lcd), fAAState(aa), fFilterState(filter), fHintingState(hinting) {}
+
+ virtual void filter(SkPaint* paint, Type t) {
+ if (kText_Type == t && kUnknown_SkTriState != fLCDState) {
+ paint->setLCDRenderText(kTrue_SkTriState == fLCDState);
+ }
+ if (kUnknown_SkTriState != fAAState) {
+ paint->setAntiAlias(kTrue_SkTriState == fAAState);
+ }
+ if (kUnknown_SkTriState != fFilterState) {
+ paint->setFilterBitmap(kTrue_SkTriState == fFilterState);
+ }
+ if (kUnknown_SkTriState != fHintingState) {
+ paint->setHinting(kTrue_SkTriState == fHintingState ?
+ SkPaint::kNormal_Hinting :
+ SkPaint::kSlight_Hinting);
+ }
+ }
+
+private:
+ SkTriState fLCDState;
+ SkTriState fAAState;
+ SkTriState fFilterState;
+ SkTriState fHintingState;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+#define MAX_ZOOM_LEVEL 8
+#define MIN_ZOOM_LEVEL -8
+
+static const char gCharEvtName[] = "SampleCode_Char_Event";
+static const char gKeyEvtName[] = "SampleCode_Key_Event";
+static const char gTitleEvtName[] = "SampleCode_Title_Event";
+static const char gPrefSizeEvtName[] = "SampleCode_PrefSize_Event";
+static const char gFastTextEvtName[] = "SampleCode_FastText_Event";
+
+bool SampleCode::CharQ(const SkEvent& evt, SkUnichar* outUni) {
+ if (evt.isType(gCharEvtName, sizeof(gCharEvtName) - 1)) {
+ if (outUni) {
+ *outUni = evt.getFast32();
+ }
+ return true;
+ }
+ return false;
+}
+
+bool SampleCode::KeyQ(const SkEvent& evt, SkKey* outKey) {
+ if (evt.isType(gKeyEvtName, sizeof(gKeyEvtName) - 1)) {
+ if (outKey) {
+ *outKey = (SkKey)evt.getFast32();
+ }
+ return true;
+ }
+ return false;
+}
+
+bool SampleCode::TitleQ(const SkEvent& evt) {
+ return evt.isType(gTitleEvtName, sizeof(gTitleEvtName) - 1);
+}
+
+void SampleCode::TitleR(SkEvent* evt, const char title[]) {
+ SkASSERT(evt && TitleQ(*evt));
+ evt->setString(gTitleEvtName, title);
+}
+
+bool SampleCode::PrefSizeQ(const SkEvent& evt) {
+ return evt.isType(gPrefSizeEvtName, sizeof(gPrefSizeEvtName) - 1);
+}
+
+void SampleCode::PrefSizeR(SkEvent* evt, SkScalar width, SkScalar height) {
+ SkASSERT(evt && PrefSizeQ(*evt));
+ SkScalar size[2];
+ size[0] = width;
+ size[1] = height;
+ evt->setScalars(gPrefSizeEvtName, 2, size);
+}
+
+bool SampleCode::FastTextQ(const SkEvent& evt) {
+ return evt.isType(gFastTextEvtName, sizeof(gFastTextEvtName) - 1);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static SkMSec gAnimTime;
+static SkMSec gAnimTimePrev;
+
+SkMSec SampleCode::GetAnimTime() { return gAnimTime; }
+SkMSec SampleCode::GetAnimTimeDelta() { return gAnimTime - gAnimTimePrev; }
+SkScalar SampleCode::GetAnimSecondsDelta() {
+ return SkDoubleToScalar(GetAnimTimeDelta() / 1000.0);
+}
+
+SkScalar SampleCode::GetAnimScalar(SkScalar speed, SkScalar period) {
+ // since gAnimTime can be up to 32 bits, we can't convert it to a float
+ // or we'll lose the low bits. Hence we use doubles for the intermediate
+ // calculations
+ double seconds = (double)gAnimTime / 1000.0;
+ double value = SkScalarToDouble(speed) * seconds;
+ if (period) {
+ value = ::fmod(value, SkScalarToDouble(period));
+ }
+ return SkDoubleToScalar(value);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* curr_view(SkWindow* wind) {
+ SkView::F2BIter iter(wind);
+ return iter.next();
+}
+
+class SampleWindow : public SkOSWindow {
+ SkTDArray<SkViewFactory> fSamples;
+public:
+ SampleWindow(void* hwnd);
+ virtual ~SampleWindow();
+
+ virtual void draw(SkCanvas* canvas);
+
+protected:
+ virtual void onDraw(SkCanvas* canvas);
+ virtual bool onHandleKey(SkKey key);
+ virtual bool onHandleChar(SkUnichar);
+ virtual void onSizeChange();
+
+ virtual SkCanvas* beforeChildren(SkCanvas*);
+ virtual void afterChildren(SkCanvas*);
+ virtual void beforeChild(SkView* child, SkCanvas* canvas);
+ virtual void afterChild(SkView* child, SkCanvas* canvas);
+
+ virtual bool onEvent(const SkEvent& evt);
+ virtual bool onQuery(SkEvent* evt);
+
+ virtual bool onDispatchClick(int x, int y, Click::State);
+ virtual bool onClick(Click* click);
+ virtual Click* onFindClickHandler(SkScalar x, SkScalar y);
+
+#if 0
+ virtual bool handleChar(SkUnichar uni);
+ virtual bool handleEvent(const SkEvent& evt);
+ virtual bool handleKey(SkKey key);
+ virtual bool handleKeyUp(SkKey key);
+ virtual bool onHandleKeyUp(SkKey key);
+#endif
+
+private:
+ int fCurrIndex;
+
+ SkPicture* fPicture;
+ SkGpuCanvas* fGpuCanvas;
+ GrContext* fGrContext;
+ SkPath fClipPath;
+
+ SkTouchGesture fGesture;
+ int fZoomLevel;
+ SkScalar fZoomScale;
+
+ enum CanvasType {
+ kRaster_CanvasType,
+ kPicture_CanvasType,
+ kGPU_CanvasType
+ };
+ CanvasType fCanvasType;
+
+ bool fUseClip;
+ bool fNClip;
+ bool fRepeatDrawing;
+ bool fAnimating;
+ bool fRotate;
+ bool fScale;
+ bool fRequestGrabImage;
+ bool fUsePipe;
+ bool fMeasureFPS;
+ SkMSec fMeasureFPS_Time;
+
+ // The following are for the 'fatbits' drawing
+ // Latest position of the mouse.
+ int fMouseX, fMouseY;
+ int fFatBitsScale;
+ // Used by the text showing position and color values.
+ SkTypeface* fTypeface;
+ bool fShowZoomer;
+
+ SkTriState fLCDState;
+ SkTriState fAAState;
+ SkTriState fFilterState;
+ SkTriState fHintingState;
+ unsigned fFlipAxis;
+
+ int fScrollTestX, fScrollTestY;
+
+ bool make3DReady();
+ void changeZoomLevel(int delta);
+
+ void loadView(SkView*);
+ void updateTitle();
+ bool nextSample();
+
+ void toggleZoomer();
+ bool zoomIn();
+ bool zoomOut();
+ void updatePointer(int x, int y);
+ void showZoomer(SkCanvas* canvas);
+
+ void postAnimatingEvent() {
+ if (fAnimating) {
+ SkEvent* evt = new SkEvent(ANIMATING_EVENTTYPE);
+ evt->post(this->getSinkID(), ANIMATING_DELAY);
+ }
+ }
+
+
+ static CanvasType cycle_canvastype(CanvasType);
+
+ typedef SkOSWindow INHERITED;
+};
+
+bool SampleWindow::zoomIn()
+{
+ // Arbitrarily decided
+ if (fFatBitsScale == 25) return false;
+ fFatBitsScale++;
+ this->inval(NULL);
+ return true;
+}
+
+bool SampleWindow::zoomOut()
+{
+ if (fFatBitsScale == 1) return false;
+ fFatBitsScale--;
+ this->inval(NULL);
+ return true;
+}
+
+void SampleWindow::toggleZoomer()
+{
+ fShowZoomer = !fShowZoomer;
+ this->inval(NULL);
+}
+
+void SampleWindow::updatePointer(int x, int y)
+{
+ fMouseX = x;
+ fMouseY = y;
+ if (fShowZoomer) {
+ this->inval(NULL);
+ }
+}
+
+bool SampleWindow::make3DReady() {
+
+#if defined(SK_SUPPORT_GL)
+ if (attachGL()) {
+ if (NULL != fGrContext) {
+ // various gr lifecycle tests
+ #if 0
+ fGrContext->freeGpuResources();
+ #elif 0
+ // this will leak resources.
+ fGrContext->contextLost();
+ #elif 0
+ GrAssert(1 == fGrContext->refcnt());
+ fGrContext->unref();
+ fGrContext = NULL;
+ #endif
+ }
+
+ if (NULL == fGrContext) {
+ #if defined(SK_USE_SHADERS)
+ fGrContext = GrContext::Create(kOpenGL_Shaders_GrEngine, NULL);
+ #else
+ fGrContext = GrContext::Create(kOpenGL_Fixed_GrEngine, NULL);
+ #endif
+ SkDebugf("---- constructor\n");
+ }
+
+ if (NULL != fGrContext) {
+ return true;
+ } else {
+ detachGL();
+ }
+ }
+#endif
+ SkDebugf("Failed to setup 3D");
+ return false;
+}
+
+SampleWindow::CanvasType SampleWindow::cycle_canvastype(CanvasType ct) {
+ static const CanvasType gCT[] = {
+ kPicture_CanvasType,
+ kGPU_CanvasType,
+ kRaster_CanvasType
+ };
+ return gCT[ct];
+}
+
+SampleWindow::SampleWindow(void* hwnd) : INHERITED(hwnd) {
+#ifdef PIPE_FILE
+ //Clear existing file or create file if it doesn't exist
+ FILE* f = fopen(FILE_PATH, "wb");
+ fclose(f);
+#endif
+
+ fPicture = NULL;
+ fGpuCanvas = NULL;
+
+ fGrContext = NULL;
+
+#ifdef DEFAULT_TO_GPU
+ fCanvasType = kGPU_CanvasType;
+#else
+ fCanvasType = kRaster_CanvasType;
+#endif
+ fUseClip = false;
+ fNClip = false;
+ fRepeatDrawing = false;
+ fAnimating = false;
+ fRotate = false;
+ fScale = false;
+ fRequestGrabImage = false;
+ fUsePipe = false;
+ fMeasureFPS = false;
+ fLCDState = kUnknown_SkTriState;
+ fAAState = kUnknown_SkTriState;
+ fFilterState = kUnknown_SkTriState;
+ fHintingState = kUnknown_SkTriState;
+ fFlipAxis = 0;
+ fScrollTestX = fScrollTestY = 0;
+
+ fMouseX = fMouseY = 0;
+ fFatBitsScale = 8;
+ fTypeface = SkTypeface::CreateFromTypeface(NULL, SkTypeface::kBold);
+ fShowZoomer = false;
+
+ fZoomLevel = 0;
+ fZoomScale = SK_Scalar1;
+
+// this->setConfig(SkBitmap::kRGB_565_Config);
+ this->setConfig(SkBitmap::kARGB_8888_Config);
+ this->setVisibleP(true);
+ this->setClipToBounds(false);
+
+ {
+ const SkViewRegister* reg = SkViewRegister::Head();
+ while (reg) {
+ *fSamples.append() = reg->factory();
+ reg = reg->next();
+ }
+ }
+ fCurrIndex = 0;
+ this->loadView(fSamples[fCurrIndex]());
+
+#ifdef SK_BUILD_FOR_MAC
+ testpdf();
+#endif
+}
+
+SampleWindow::~SampleWindow() {
+ delete fPicture;
+ delete fGpuCanvas;
+ if (NULL != fGrContext) {
+ fGrContext->unref();
+ }
+ fTypeface->unref();
+}
+
+static SkBitmap capture_bitmap(SkCanvas* canvas) {
+ SkBitmap bm;
+ const SkBitmap& src = canvas->getDevice()->accessBitmap(false);
+ src.copyTo(&bm, src.config());
+ return bm;
+}
+
+static bool bitmap_diff(SkCanvas* canvas, const SkBitmap& orig,
+ SkBitmap* diff) {
+ const SkBitmap& src = canvas->getDevice()->accessBitmap(false);
+
+ SkAutoLockPixels alp0(src);
+ SkAutoLockPixels alp1(orig);
+ for (int y = 0; y < src.height(); y++) {
+ const void* srcP = src.getAddr(0, y);
+ const void* origP = orig.getAddr(0, y);
+ size_t bytes = src.width() * src.bytesPerPixel();
+ if (memcmp(srcP, origP, bytes)) {
+ SkDebugf("---------- difference on line %d\n", y);
+ return true;
+ }
+ }
+ return false;
+}
+
+static void drawText(SkCanvas* canvas, SkString string, SkScalar left, SkScalar top, SkPaint& paint)
+{
+ SkColor desiredColor = paint.getColor();
+ paint.setColor(SK_ColorWHITE);
+ const char* c_str = string.c_str();
+ size_t size = string.size();
+ SkRect bounds;
+ paint.measureText(c_str, size, &bounds);
+ bounds.offset(left, top);
+ SkScalar inset = SkIntToScalar(-2);
+ bounds.inset(inset, inset);
+ canvas->drawRect(bounds, paint);
+ if (desiredColor != SK_ColorBLACK) {
+ paint.setColor(SK_ColorBLACK);
+ canvas->drawText(c_str, size, left + SK_Scalar1, top + SK_Scalar1, paint);
+ }
+ paint.setColor(desiredColor);
+ canvas->drawText(c_str, size, left, top, paint);
+}
+
+#define XCLIP_N 8
+#define YCLIP_N 8
+
+void SampleWindow::draw(SkCanvas* canvas) {
+ // update the animation time
+ gAnimTimePrev = gAnimTime;
+ gAnimTime = SkTime::GetMSecs();
+
+ SkScalar cx = SkScalarHalf(this->width());
+ SkScalar cy = SkScalarHalf(this->height());
+
+ if (fZoomLevel) {
+ SkMatrix m;
+ SkPoint center;
+ m = canvas->getTotalMatrix();//.invert(&m);
+ m.mapXY(cx, cy, ¢er);
+ cx = center.fX;
+ cy = center.fY;
+
+ m.setTranslate(-cx, -cy);
+ m.postScale(fZoomScale, fZoomScale);
+ m.postTranslate(cx, cy);
+
+ canvas->concat(m);
+ }
+
+ if (fFlipAxis) {
+ SkMatrix m;
+ m.setTranslate(cx, cy);
+ if (fFlipAxis & kFlipAxis_X) {
+ m.preScale(-SK_Scalar1, SK_Scalar1);
+ }
+ if (fFlipAxis & kFlipAxis_Y) {
+ m.preScale(SK_Scalar1, -SK_Scalar1);
+ }
+ m.preTranslate(-cx, -cy);
+ canvas->concat(m);
+ }
+
+ // Apply any gesture matrix
+ if (true) {
+ const SkMatrix& localM = fGesture.localM();
+ if (localM.getType() & SkMatrix::kScale_Mask) {
+ canvas->setExternalMatrix(&localM);
+ }
+ canvas->concat(localM);
+ canvas->concat(fGesture.globalM());
+
+ if (fGesture.isActive()) {
+ this->inval(NULL);
+ }
+ }
+
+ if (fNClip) {
+ this->INHERITED::draw(canvas);
+ SkBitmap orig = capture_bitmap(canvas);
+
+ const SkScalar w = this->width();
+ const SkScalar h = this->height();
+ const SkScalar cw = w / XCLIP_N;
+ const SkScalar ch = h / YCLIP_N;
+ for (int y = 0; y < YCLIP_N; y++) {
+ SkRect r;
+ r.fTop = y * ch;
+ r.fBottom = (y + 1) * ch;
+ if (y == YCLIP_N - 1) {
+ r.fBottom = h;
+ }
+ for (int x = 0; x < XCLIP_N; x++) {
+ SkAutoCanvasRestore acr(canvas, true);
+ r.fLeft = x * cw;
+ r.fRight = (x + 1) * cw;
+ if (x == XCLIP_N - 1) {
+ r.fRight = w;
+ }
+ canvas->clipRect(r);
+ this->INHERITED::draw(canvas);
+ }
+ }
+
+ SkBitmap diff;
+ if (bitmap_diff(canvas, orig, &diff)) {
+ }
+ } else {
+ this->INHERITED::draw(canvas);
+ }
+ if (fShowZoomer && fCanvasType != kGPU_CanvasType) {
+ // In the GPU case, INHERITED::draw calls beforeChildren, which
+ // creates an SkGpuCanvas. All further draw calls are directed
+ // at that canvas, which is deleted in afterChildren (which is
+ // also called by draw), so we cannot show the zoomer here.
+ // Instead, we call it inside afterChildren.
+ showZoomer(canvas);
+ }
+}
+
+void SampleWindow::showZoomer(SkCanvas* canvas) {
+ int count = canvas->save();
+ canvas->resetMatrix();
+ // Ensure the mouse position is on screen.
+ int width = SkScalarRound(this->width());
+ int height = SkScalarRound(this->height());
+ if (fMouseX >= width) fMouseX = width - 1;
+ else if (fMouseX < 0) fMouseX = 0;
+ if (fMouseY >= height) fMouseY = height - 1;
+ else if (fMouseY < 0) fMouseY = 0;
+
+ SkBitmap bitmap = capture_bitmap(canvas);
+ bitmap.lockPixels();
+
+ // Find the size of the zoomed in view, forced to be odd, so the examined pixel is in the middle.
+ int zoomedWidth = (width >> 1) | 1;
+ int zoomedHeight = (height >> 1) | 1;
+ SkIRect src;
+ src.set(0, 0, zoomedWidth / fFatBitsScale, zoomedHeight / fFatBitsScale);
+ src.offset(fMouseX - (src.width()>>1), fMouseY - (src.height()>>1));
+ SkRect dest;
+ dest.set(0, 0, SkIntToScalar(zoomedWidth), SkIntToScalar(zoomedHeight));
+ dest.offset(SkIntToScalar(width - zoomedWidth), SkIntToScalar(height - zoomedHeight));
+ SkPaint paint;
+ // Clear the background behind our zoomed in view
+ paint.setColor(SK_ColorWHITE);
+ canvas->drawRect(dest, paint);
+ canvas->drawBitmapRect(bitmap, &src, dest);
+ paint.setColor(SK_ColorBLACK);
+ paint.setStyle(SkPaint::kStroke_Style);
+ // Draw a border around the pixel in the middle
+ SkRect originalPixel;
+ originalPixel.set(SkIntToScalar(fMouseX), SkIntToScalar(fMouseY), SkIntToScalar(fMouseX + 1), SkIntToScalar(fMouseY + 1));
+ SkMatrix matrix;
+ SkRect scalarSrc;
+ scalarSrc.set(src);
+ SkColor color = bitmap.getColor(fMouseX, fMouseY);
+ if (matrix.setRectToRect(scalarSrc, dest, SkMatrix::kFill_ScaleToFit)) {
+ SkRect pixel;
+ matrix.mapRect(&pixel, originalPixel);
+ // TODO Perhaps measure the values and make the outline white if it's "dark"
+ if (color == SK_ColorBLACK) {
+ paint.setColor(SK_ColorWHITE);
+ }
+ canvas->drawRect(pixel, paint);
+ }
+ paint.setColor(SK_ColorBLACK);
+ // Draw a border around the destination rectangle
+ canvas->drawRect(dest, paint);
+ paint.setStyle(SkPaint::kStrokeAndFill_Style);
+ // Identify the pixel and its color on screen
+ paint.setTypeface(fTypeface);
+ paint.setAntiAlias(true);
+ SkScalar lineHeight = paint.getFontMetrics(NULL);
+ SkString string;
+ string.appendf("(%i, %i)", fMouseX, fMouseY);
+ SkScalar left = dest.fLeft + SkIntToScalar(3);
+ SkScalar i = SK_Scalar1;
+ drawText(canvas, string, left, SkScalarMulAdd(lineHeight, i, dest.fTop), paint);
+ // Alpha
+ i += SK_Scalar1;
+ string.reset();
+ string.appendf("A: %X", SkColorGetA(color));
+ drawText(canvas, string, left, SkScalarMulAdd(lineHeight, i, dest.fTop), paint);
+ // Red
+ i += SK_Scalar1;
+ string.reset();
+ string.appendf("R: %X", SkColorGetR(color));
+ paint.setColor(SK_ColorRED);
+ drawText(canvas, string, left, SkScalarMulAdd(lineHeight, i, dest.fTop), paint);
+ // Green
+ i += SK_Scalar1;
+ string.reset();
+ string.appendf("G: %X", SkColorGetG(color));
+ paint.setColor(SK_ColorGREEN);
+ drawText(canvas, string, left, SkScalarMulAdd(lineHeight, i, dest.fTop), paint);
+ // Blue
+ i += SK_Scalar1;
+ string.reset();
+ string.appendf("B: %X", SkColorGetB(color));
+ paint.setColor(SK_ColorBLUE);
+ drawText(canvas, string, left, SkScalarMulAdd(lineHeight, i, dest.fTop), paint);
+ canvas->restoreToCount(count);
+}
+
+void SampleWindow::onDraw(SkCanvas* canvas) {
+ if (fRepeatDrawing) {
+ this->inval(NULL);
+ }
+}
+
+#include "SkColorPriv.h"
+
+static void reverseRedAndBlue(const SkBitmap& bm) {
+ SkASSERT(bm.config() == SkBitmap::kARGB_8888_Config);
+ uint8_t* p = (uint8_t*)bm.getPixels();
+ uint8_t* stop = p + bm.getSize();
+ while (p < stop) {
+ // swap red/blue (to go from ARGB(int) to RGBA(memory) and premultiply
+ unsigned scale = SkAlpha255To256(p[3]);
+ unsigned r = p[2];
+ unsigned b = p[0];
+ p[0] = SkAlphaMul(r, scale);
+ p[1] = SkAlphaMul(p[1], scale);
+ p[2] = SkAlphaMul(b, scale);
+ p += 4;
+ }
+}
+
+SkCanvas* SampleWindow::beforeChildren(SkCanvas* canvas) {
+ if (kGPU_CanvasType != fCanvasType) {
+#ifdef SK_SUPPORT_GL
+ detachGL();
+#endif
+ }
+
+ switch (fCanvasType) {
+ case kRaster_CanvasType:
+ canvas = this->INHERITED::beforeChildren(canvas);
+ break;
+ case kPicture_CanvasType:
+ fPicture = new SkPicture;
+ canvas = fPicture->beginRecording(9999, 9999);
+ break;
+ case kGPU_CanvasType: {
+ if (make3DReady()) {
+ SkDevice* device = canvas->getDevice();
+ const SkBitmap& bitmap = device->accessBitmap(true);
+
+ GrRenderTarget* renderTarget;
+ renderTarget = fGrContext->createRenderTargetFrom3DApiState();
+ fGpuCanvas = new SkGpuCanvas(fGrContext, renderTarget);
+ renderTarget->unref();
+
+ device = fGpuCanvas->createDevice(SkBitmap::kARGB_8888_Config,
+ bitmap.width(), bitmap.height(),
+ false, false);
+ fGpuCanvas->setDevice(device)->unref();
+
+ fGpuCanvas->concat(canvas->getTotalMatrix());
+ canvas = fGpuCanvas;
+
+ } else {
+ canvas = this->INHERITED::beforeChildren(canvas);
+ }
+ break;
+ }
+ }
+
+ if (fUseClip) {
+ canvas->drawColor(0xFFFF88FF);
+ canvas->clipPath(fClipPath);
+ }
+
+ return canvas;
+}
+
+static void paint_rgn(const SkBitmap& bm, const SkIRect& r,
+ const SkRegion& rgn) {
+ SkCanvas canvas(bm);
+ SkRegion inval(rgn);
+
+ inval.translate(r.fLeft, r.fTop);
+ canvas.clipRegion(inval);
+ canvas.drawColor(0xFFFF8080);
+}
+
+void SampleWindow::afterChildren(SkCanvas* orig) {
+ if (fRequestGrabImage) {
+ fRequestGrabImage = false;
+
+ SkCanvas* canvas = fGpuCanvas ? fGpuCanvas : orig;
+ SkDevice* device = canvas->getDevice();
+ SkBitmap bmp;
+ if (device->accessBitmap(false).copyTo(&bmp, SkBitmap::kARGB_8888_Config)) {
+ static int gSampleGrabCounter;
+ SkString name;
+ name.printf("sample_grab_%d", gSampleGrabCounter++);
+ SkImageEncoder::EncodeFile(name.c_str(), bmp,
+ SkImageEncoder::kPNG_Type, 100);
+ }
+ }
+
+ switch (fCanvasType) {
+ case kRaster_CanvasType:
+ break;
+ case kPicture_CanvasType:
+ if (true) {
+ SkPicture* pict = new SkPicture(*fPicture);
+ fPicture->unref();
+ orig->drawPicture(*pict);
+ pict->unref();
+ } else if (true) {
+ SkDynamicMemoryWStream ostream;
+ fPicture->serialize(&ostream);
+ fPicture->unref();
+
+ SkMemoryStream istream(ostream.getStream(), ostream.getOffset());
+ SkPicture pict(&istream);
+ orig->drawPicture(pict);
+ } else {
+ fPicture->draw(orig);
+ fPicture->unref();
+ }
+ fPicture = NULL;
+ break;
+#ifdef SK_SUPPORT_GL
+ case kGPU_CanvasType:
+ if (fShowZoomer) {
+ this->showZoomer(fGpuCanvas);
+ }
+ delete fGpuCanvas;
+ fGpuCanvas = NULL;
+ presentGL();
+ break;
+#endif
+ }
+
+ // Do this after presentGL and other finishing, rather than in afterChild
+ if (fMeasureFPS && fMeasureFPS_Time) {
+ fMeasureFPS_Time = SkTime::GetMSecs() - fMeasureFPS_Time;
+ this->updateTitle();
+ postInvalDelay(this->getSinkID());
+ }
+
+ // if ((fScrollTestX | fScrollTestY) != 0)
+ if (false) {
+ const SkBitmap& bm = orig->getDevice()->accessBitmap(true);
+ int dx = fScrollTestX * 7;
+ int dy = fScrollTestY * 7;
+ SkIRect r;
+ SkRegion inval;
+
+ r.set(50, 50, 50+100, 50+100);
+ bm.scrollRect(&r, dx, dy, &inval);
+ paint_rgn(bm, r, inval);
+ }
+}
+
+void SampleWindow::beforeChild(SkView* child, SkCanvas* canvas) {
+ if (fScale) {
+ SkScalar scale = SK_Scalar1 * 7 / 10;
+ SkScalar cx = this->width() / 2;
+ SkScalar cy = this->height() / 2;
+ canvas->translate(cx, cy);
+ canvas->scale(scale, scale);
+ canvas->translate(-cx, -cy);
+ }
+ if (fRotate) {
+ SkScalar cx = this->width() / 2;
+ SkScalar cy = this->height() / 2;
+ canvas->translate(cx, cy);
+ canvas->rotate(SkIntToScalar(30));
+ canvas->translate(-cx, -cy);
+ }
+
+ canvas->setDrawFilter(new FlagsDrawFilter(fLCDState, fAAState,
+ fFilterState, fHintingState))->unref();
+
+ if (fMeasureFPS) {
+ fMeasureFPS_Time = 0; // 0 means the child is not aware of repeat-draw
+ if (SampleView::SetRepeatDraw(child, FPS_REPEAT_COUNT)) {
+ fMeasureFPS_Time = SkTime::GetMSecs();
+ }
+ } else {
+ (void)SampleView::SetRepeatDraw(child, 1);
+ }
+ (void)SampleView::SetUsePipe(child, fUsePipe);
+}
+
+void SampleWindow::afterChild(SkView* child, SkCanvas* canvas) {
+ canvas->setDrawFilter(NULL);
+}
+
+static SkBitmap::Config gConfigCycle[] = {
+ SkBitmap::kNo_Config, // none -> none
+ SkBitmap::kNo_Config, // a1 -> none
+ SkBitmap::kNo_Config, // a8 -> none
+ SkBitmap::kNo_Config, // index8 -> none
+ SkBitmap::kARGB_4444_Config, // 565 -> 4444
+ SkBitmap::kARGB_8888_Config, // 4444 -> 8888
+ SkBitmap::kRGB_565_Config // 8888 -> 565
+};
+
+static SkBitmap::Config cycle_configs(SkBitmap::Config c) {
+ return gConfigCycle[c];
+}
+
+void SampleWindow::changeZoomLevel(int delta) {
+ fZoomLevel += delta;
+ if (fZoomLevel > 0) {
+ fZoomLevel = SkMin32(fZoomLevel, MAX_ZOOM_LEVEL);
+ fZoomScale = SkIntToScalar(fZoomLevel + 1);
+ } else if (fZoomLevel < 0) {
+ fZoomLevel = SkMax32(fZoomLevel, MIN_ZOOM_LEVEL);
+ fZoomScale = SK_Scalar1 / (1 - fZoomLevel);
+ } else {
+ fZoomScale = SK_Scalar1;
+ }
+
+ this->inval(NULL);
+}
+
+bool SampleWindow::nextSample() {
+ fCurrIndex = (fCurrIndex + 1) % fSamples.count();
+ this->loadView(fSamples[fCurrIndex]());
+ return true;
+}
+
+bool SampleWindow::onEvent(const SkEvent& evt) {
+ if (evt.isType(ANIMATING_EVENTTYPE)) {
+ if (fAnimating) {
+ this->nextSample();
+ this->postAnimatingEvent();
+ }
+ return true;
+ }
+ if (evt.isType("set-curr-index")) {
+ fCurrIndex = evt.getFast32() % fSamples.count();
+ this->loadView(fSamples[fCurrIndex]());
+ return true;
+ }
+ if (isInvalEvent(evt)) {
+ this->inval(NULL);
+ return true;
+ }
+ return this->INHERITED::onEvent(evt);
+}
+
+bool SampleWindow::onQuery(SkEvent* query) {
+ if (query->isType("get-slide-count")) {
+ query->setFast32(fSamples.count());
+ return true;
+ }
+ if (query->isType("get-slide-title")) {
+ SkView* view = fSamples[query->getFast32()]();
+ SkEvent evt(gTitleEvtName);
+ if (view->doQuery(&evt)) {
+ query->setString("title", evt.findString(gTitleEvtName));
+ }
+ SkSafeUnref(view);
+ return true;
+ }
+ if (query->isType("use-fast-text")) {
+ SkEvent evt(gFastTextEvtName);
+ return curr_view(this)->doQuery(&evt);
+ }
+ return this->INHERITED::onQuery(query);
+}
+
+static void cleanup_for_filename(SkString* name) {
+ char* str = name->writable_str();
+ for (size_t i = 0; i < name->size(); i++) {
+ switch (str[i]) {
+ case ':': str[i] = '-'; break;
+ case '/': str[i] = '-'; break;
+ case ' ': str[i] = '_'; break;
+ default: break;
+ }
+ }
+}
+
+bool SampleWindow::onHandleChar(SkUnichar uni) {
+ {
+ SkView* view = curr_view(this);
+ if (view) {
+ SkEvent evt(gCharEvtName);
+ evt.setFast32(uni);
+ if (view->doQuery(&evt)) {
+ return true;
+ }
+ }
+ }
+
+ int dx = 0xFF;
+ int dy = 0xFF;
+
+ switch (uni) {
+ case '5': dx = 0; dy = 0; break;
+ case '8': dx = 0; dy = -1; break;
+ case '6': dx = 1; dy = 0; break;
+ case '2': dx = 0; dy = 1; break;
+ case '4': dx = -1; dy = 0; break;
+ case '7': dx = -1; dy = -1; break;
+ case '9': dx = 1; dy = -1; break;
+ case '3': dx = 1; dy = 1; break;
+ case '1': dx = -1; dy = 1; break;
+
+ default:
+ break;
+ }
+
+ if (0xFF != dx && 0xFF != dy) {
+ if ((dx | dy) == 0) {
+ fScrollTestX = fScrollTestY = 0;
+ } else {
+ fScrollTestX += dx;
+ fScrollTestY += dy;
+ }
+ this->inval(NULL);
+ return true;
+ }
+
+ switch (uni) {
+ case 'a':
+ fAnimating = !fAnimating;
+ this->postAnimatingEvent();
+ this->updateTitle();
+ return true;
+ case 'b':
+ fAAState = cycle_tristate(fAAState);
+ this->updateTitle();
+ this->inval(NULL);
+ break;
+ case 'c':
+ fUseClip = !fUseClip;
+ this->inval(NULL);
+ this->updateTitle();
+ return true;
+ case 'd':
+ SkGraphics::SetFontCacheUsed(0);
+ return true;
+ case 'f':
+ fMeasureFPS = !fMeasureFPS;
+ this->inval(NULL);
+ break;
+ case 'g':
+ fRequestGrabImage = true;
+ this->inval(NULL);
+ break;
+ case 'h':
+ fHintingState = cycle_tristate(fHintingState);
+ this->updateTitle();
+ this->inval(NULL);
+ break;
+ case 'i':
+ this->zoomIn();
+ break;
+ case 'l':
+ fLCDState = cycle_tristate(fLCDState);
+ this->updateTitle();
+ this->inval(NULL);
+ break;
+ case 'n':
+ fFilterState = cycle_tristate(fFilterState);
+ this->updateTitle();
+ this->inval(NULL);
+ break;
+ case 'o':
+ this->zoomOut();
+ break;
+ case 'p':
+ fUsePipe = !fUsePipe;
+ this->updateTitle();
+ this->inval(NULL);
+ break;
+ case 'r':
+ fRotate = !fRotate;
+ this->inval(NULL);
+ this->updateTitle();
+ return true;
+ case 's':
+ fScale = !fScale;
+ this->inval(NULL);
+ this->updateTitle();
+ return true;
+ case 'x':
+ fFlipAxis ^= kFlipAxis_X;
+ this->updateTitle();
+ this->inval(NULL);
+ break;
+ case 'y':
+ fFlipAxis ^= kFlipAxis_Y;
+ this->updateTitle();
+ this->inval(NULL);
+ break;
+ case 'z':
+ this->toggleZoomer();
+ break;
+ default:
+ break;
+ }
+
+ return this->INHERITED::onHandleChar(uni);
+}
+
+#include "SkDumpCanvas.h"
+
+bool SampleWindow::onHandleKey(SkKey key) {
+ {
+ SkView* view = curr_view(this);
+ if (view) {
+ SkEvent evt(gKeyEvtName);
+ evt.setFast32(key);
+ if (view->doQuery(&evt)) {
+ return true;
+ }
+ }
+ }
+
+ switch (key) {
+ case kRight_SkKey:
+ if (this->nextSample()) {
+ return true;
+ }
+ break;
+ case kLeft_SkKey:
+ fCanvasType = cycle_canvastype(fCanvasType);
+ this->updateTitle();
+ this->inval(NULL);
+ return true;
+ case kUp_SkKey:
+ if (USE_ARROWS_FOR_ZOOM) {
+ this->changeZoomLevel(1);
+ } else {
+ fNClip = !fNClip;
+ this->inval(NULL);
+ }
+ this->updateTitle();
+ return true;
+ case kDown_SkKey:
+ if (USE_ARROWS_FOR_ZOOM) {
+ this->changeZoomLevel(-1);
+ } else {
+ this->setConfig(cycle_configs(this->getBitmap().config()));
+ }
+ this->updateTitle();
+ return true;
+ case kOK_SkKey:
+ if (false) {
+ SkDebugfDumper dumper;
+ SkDumpCanvas dc(&dumper);
+ this->draw(&dc);
+ } else {
+ fRepeatDrawing = !fRepeatDrawing;
+ if (fRepeatDrawing) {
+ this->inval(NULL);
+ }
+ }
+ return true;
+ case kBack_SkKey:
+ this->loadView(NULL);
+ return true;
+ default:
+ break;
+ }
+ return this->INHERITED::onHandleKey(key);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static const char gGestureClickType[] = "GestureClickType";
+
+bool SampleWindow::onDispatchClick(int x, int y, Click::State state) {
+ if (Click::kMoved_State == state) {
+ updatePointer(x, y);
+ }
+ int w = SkScalarRound(this->width());
+ int h = SkScalarRound(this->height());
+
+ // check for the resize-box
+ if (w - x < 16 && h - y < 16) {
+ return false; // let the OS handle the click
+ } else {
+ return this->INHERITED::onDispatchClick(x, y, state);
+ }
+}
+
+class GestureClick : public SkView::Click {
+public:
+ GestureClick(SkView* target) : SkView::Click(target) {
+ this->setType(gGestureClickType);
+ }
+
+ static bool IsGesture(Click* click) {
+ return click->isType(gGestureClickType);
+ }
+};
+
+SkView::Click* SampleWindow::onFindClickHandler(SkScalar x, SkScalar y) {
+ return new GestureClick(this);
+}
+
+bool SampleWindow::onClick(Click* click) {
+ if (GestureClick::IsGesture(click)) {
+ float x = SkScalarToFloat(click->fCurr.fX);
+ float y = SkScalarToFloat(click->fCurr.fY);
+ switch (click->fState) {
+ case SkView::Click::kDown_State:
+ fGesture.touchBegin(click, x, y);
+ break;
+ case SkView::Click::kMoved_State:
+ fGesture.touchMoved(click, x, y);
+ this->inval(NULL);
+ break;
+ case SkView::Click::kUp_State:
+ fGesture.touchEnd(click);
+ this->inval(NULL);
+ break;
+ }
+ return true;
+ }
+ return false;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void SampleWindow::loadView(SkView* view) {
+ SkView::F2BIter iter(this);
+ SkView* prev = iter.next();
+ if (prev) {
+ prev->detachFromParent();
+ }
+
+ if (NULL == view) {
+ view = create_overview(fSamples.count(), fSamples.begin());
+ }
+ view->setVisibleP(true);
+ view->setClipToBounds(false);
+ this->attachChildToFront(view)->unref();
+ view->setSize(this->width(), this->height());
+
+ this->updateTitle();
+}
+
+static const char* gConfigNames[] = {
+ "unknown config",
+ "A1",
+ "A8",
+ "Index8",
+ "565",
+ "4444",
+ "8888"
+};
+
+static const char* configToString(SkBitmap::Config c) {
+ return gConfigNames[c];
+}
+
+static const char* gCanvasTypePrefix[] = {
+ "raster: ",
+ "picture: ",
+ "opengl: "
+};
+
+static const char* trystate_str(SkTriState state,
+ const char trueStr[], const char falseStr[]) {
+ if (kTrue_SkTriState == state) {
+ return trueStr;
+ } else if (kFalse_SkTriState == state) {
+ return falseStr;
+ }
+ return NULL;
+}
+
+void SampleWindow::updateTitle() {
+ SkString title;
+
+ SkView::F2BIter iter(this);
+ SkView* view = iter.next();
+ SkEvent evt(gTitleEvtName);
+ if (view->doQuery(&evt)) {
+ title.set(evt.findString(gTitleEvtName));
+ }
+ if (title.size() == 0) {
+ title.set("<unknown>");
+ }
+
+ title.prepend(gCanvasTypePrefix[fCanvasType]);
+
+ title.prepend(" ");
+ title.prepend(configToString(this->getBitmap().config()));
+
+ if (fAnimating) {
+ title.prepend("<A> ");
+ }
+ if (fScale) {
+ title.prepend("<S> ");
+ }
+ if (fRotate) {
+ title.prepend("<R> ");
+ }
+ if (fNClip) {
+ title.prepend("<C> ");
+ }
+
+ title.prepend(trystate_str(fLCDState, "LCD ", "lcd "));
+ title.prepend(trystate_str(fAAState, "AA ", "aa "));
+ title.prepend(trystate_str(fFilterState, "H ", "h "));
+ title.prepend(fFlipAxis & kFlipAxis_X ? "X " : NULL);
+ title.prepend(fFlipAxis & kFlipAxis_Y ? "Y " : NULL);
+
+ if (fZoomLevel) {
+ title.prependf("{%d} ", fZoomLevel);
+ }
+
+ if (fMeasureFPS) {
+ title.appendf(" %6.1f ms", fMeasureFPS_Time / (float)FPS_REPEAT_MULTIPLIER);
+ }
+ if (fUsePipe && SampleView::IsSampleView(view)) {
+ title.prepend("<P> ");
+ }
+ if (SampleView::IsSampleView(view)) {
+ title.prepend("! ");
+ }
+
+ this->setTitle(title.c_str());
+}
+
+void SampleWindow::onSizeChange() {
+ this->INHERITED::onSizeChange();
+
+ SkView::F2BIter iter(this);
+ SkView* view = iter.next();
+ view->setSize(this->width(), this->height());
+
+ // rebuild our clippath
+ {
+ const SkScalar W = this->width();
+ const SkScalar H = this->height();
+
+ fClipPath.reset();
+#if 0
+ for (SkScalar y = SK_Scalar1; y < H; y += SkIntToScalar(32)) {
+ SkRect r;
+ r.set(SK_Scalar1, y, SkIntToScalar(30), y + SkIntToScalar(30));
+ for (; r.fLeft < W; r.offset(SkIntToScalar(32), 0))
+ fClipPath.addRect(r);
+ }
+#else
+ SkRect r;
+ r.set(0, 0, W, H);
+ fClipPath.addRect(r, SkPath::kCCW_Direction);
+ r.set(W/4, H/4, W*3/4, H*3/4);
+ fClipPath.addRect(r, SkPath::kCW_Direction);
+#endif
+ }
+
+ this->updateTitle(); // to refresh our config
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static const char is_sample_view_tag[] = "sample-is-sample-view";
+static const char repeat_count_tag[] = "sample-set-repeat-count";
+static const char set_use_pipe_tag[] = "sample-set-use-pipe";
+
+bool SampleView::IsSampleView(SkView* view) {
+ SkEvent evt(is_sample_view_tag);
+ return view->doQuery(&evt);
+}
+
+bool SampleView::SetRepeatDraw(SkView* view, int count) {
+ SkEvent evt(repeat_count_tag);
+ evt.setFast32(count);
+ return view->doEvent(evt);
+}
+
+bool SampleView::SetUsePipe(SkView* view, bool pred) {
+ SkEvent evt(set_use_pipe_tag);
+ evt.setFast32(pred);
+ return view->doEvent(evt);
+}
+
+bool SampleView::onEvent(const SkEvent& evt) {
+ if (evt.isType(repeat_count_tag)) {
+ fRepeatCount = evt.getFast32();
+ return true;
+ }
+ if (evt.isType(set_use_pipe_tag)) {
+ fUsePipe = !!evt.getFast32();
+ return true;
+ }
+ return this->INHERITED::onEvent(evt);
+}
+
+bool SampleView::onQuery(SkEvent* evt) {
+ if (evt->isType(is_sample_view_tag)) {
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+}
+
+#ifdef TEST_GPIPE
+ #include "SkGPipe.h"
+
+class SimplePC : public SkGPipeController {
+public:
+ SimplePC(SkCanvas* target);
+ ~SimplePC();
+
+ virtual void* requestBlock(size_t minRequest, size_t* actual);
+ virtual void notifyWritten(size_t bytes);
+
+private:
+ SkGPipeReader fReader;
+ void* fBlock;
+ size_t fBlockSize;
+ size_t fBytesWritten;
+ int fAtomsWritten;
+ SkGPipeReader::Status fStatus;
+
+ size_t fTotalWritten;
+};
+
+SimplePC::SimplePC(SkCanvas* target) : fReader(target) {
+ fBlock = NULL;
+ fBlockSize = fBytesWritten = 0;
+ fStatus = SkGPipeReader::kDone_Status;
+ fTotalWritten = 0;
+ fAtomsWritten = 0;
+}
+
+SimplePC::~SimplePC() {
+// SkASSERT(SkGPipeReader::kDone_Status == fStatus);
+ sk_free(fBlock);
+
+ if (fTotalWritten) {
+ SkDebugf("--- %d bytes %d atoms, status %d\n", fTotalWritten,
+ fAtomsWritten, fStatus);
+ }
+}
+
+void* SimplePC::requestBlock(size_t minRequest, size_t* actual) {
+ sk_free(fBlock);
+
+ fBlockSize = minRequest * 4;
+ fBlock = sk_malloc_throw(fBlockSize);
+ fBytesWritten = 0;
+ *actual = fBlockSize;
+ return fBlock;
+}
+
+void SimplePC::notifyWritten(size_t bytes) {
+ SkASSERT(fBytesWritten + bytes <= fBlockSize);
+
+#ifdef PIPE_FILE
+ //File is open in append mode
+ FILE* f = fopen(FILE_PATH, "ab");
+ SkASSERT(f != NULL);
+ fwrite((const char*)fBlock + fBytesWritten, 1, bytes, f);
+ fclose(f);
+#endif
+
+ fStatus = fReader.playback((const char*)fBlock + fBytesWritten, bytes);
+ SkASSERT(SkGPipeReader::kError_Status != fStatus);
+ fBytesWritten += bytes;
+ fTotalWritten += bytes;
+
+ fAtomsWritten += 1;
+}
+
+#endif
+
+
+void SampleView::onDraw(SkCanvas* canvas) {
+#ifdef TEST_GPIPE
+ SimplePC controller(canvas);
+ SkGPipeWriter writer;
+ if (fUsePipe) {
+ uint32_t flags = SkGPipeWriter::kCrossProcess_Flag;
+// flags = 0;
+ canvas = writer.startRecording(&controller, flags);
+ }
+#endif
+
+ this->onDrawBackground(canvas);
+
+ for (int i = 0; i < fRepeatCount; i++) {
+ SkAutoCanvasRestore acr(canvas, true);
+ this->onDrawContent(canvas);
+ }
+}
+
+void SampleView::onDrawBackground(SkCanvas* canvas) {
+ canvas->drawColor(fBGColor);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+template <typename T> void SkTBSort(T array[], int count) {
+ for (int i = 1; i < count - 1; i++) {
+ bool didSwap = false;
+ for (int j = count - 1; j > i; --j) {
+ if (array[j] < array[j-1]) {
+ T tmp(array[j-1]);
+ array[j-1] = array[j];
+ array[j] = tmp;
+ didSwap = true;
+ }
+ }
+ if (!didSwap) {
+ break;
+ }
+ }
+
+ for (int k = 0; k < count - 1; k++) {
+ SkASSERT(!(array[k+1] < array[k]));
+ }
+}
+
+#include "SkRandom.h"
+
+static void rand_rect(SkIRect* rect, SkRandom& rand) {
+ int bits = 8;
+ int shift = 32 - bits;
+ rect->set(rand.nextU() >> shift, rand.nextU() >> shift,
+ rand.nextU() >> shift, rand.nextU() >> shift);
+ rect->sort();
+}
+
+static void dumpRect(const SkIRect& r) {
+ SkDebugf(" { %d, %d, %d, %d },\n",
+ r.fLeft, r.fTop,
+ r.fRight, r.fBottom);
+}
+
+static void test_rects(const SkIRect rect[], int count) {
+ SkRegion rgn0, rgn1;
+
+ for (int i = 0; i < count; i++) {
+ rgn0.op(rect[i], SkRegion::kUnion_Op);
+ // dumpRect(rect[i]);
+ }
+ rgn1.setRects(rect, count);
+
+ if (rgn0 != rgn1) {
+ SkDebugf("\n");
+ for (int i = 0; i < count; i++) {
+ dumpRect(rect[i]);
+ }
+ SkDebugf("\n");
+ }
+}
+
+static void test() {
+ size_t i;
+
+ const SkIRect r0[] = {
+ { 0, 0, 1, 1 },
+ { 2, 2, 3, 3 },
+ };
+ const SkIRect r1[] = {
+ { 0, 0, 1, 3 },
+ { 1, 1, 2, 2 },
+ { 2, 0, 3, 3 },
+ };
+ const SkIRect r2[] = {
+ { 0, 0, 1, 2 },
+ { 2, 1, 3, 3 },
+ { 4, 0, 5, 1 },
+ { 6, 0, 7, 4 },
+ };
+
+ static const struct {
+ const SkIRect* fRects;
+ int fCount;
+ } gRecs[] = {
+ { r0, SK_ARRAY_COUNT(r0) },
+ { r1, SK_ARRAY_COUNT(r1) },
+ { r2, SK_ARRAY_COUNT(r2) },
+ };
+
+ for (i = 0; i < SK_ARRAY_COUNT(gRecs); i++) {
+ test_rects(gRecs[i].fRects, gRecs[i].fCount);
+ }
+
+ SkRandom rand;
+ for (i = 0; i < 10000; i++) {
+ SkRegion rgn0, rgn1;
+
+ const int N = 8;
+ SkIRect rect[N];
+ for (int j = 0; j < N; j++) {
+ rand_rect(&rect[j], rand);
+ }
+ test_rects(rect, N);
+ }
+}
+
+SkOSWindow* create_sk_window(void* hwnd) {
+// test();
+ return new SampleWindow(hwnd);
+}
+
+void get_preferred_size(int* x, int* y, int* width, int* height) {
+ *x = 10;
+ *y = 50;
+ *width = 640;
+ *height = 480;
+}
+
+void application_init() {
+// setenv("ANDROID_ROOT", "../../../data", 0);
+#ifdef SK_BUILD_FOR_MAC
+ setenv("ANDROID_ROOT", "/android/device/data", 0);
+#endif
+ SkGraphics::Init();
+ SkEvent::Init();
+}
+
+void application_term() {
+ SkEvent::Term();
+ SkGraphics::Term();
+}
diff --git a/samplecode/SampleArc.cpp b/samplecode/SampleArc.cpp
new file mode 100644
index 0000000..8e3ad88
--- /dev/null
+++ b/samplecode/SampleArc.cpp
@@ -0,0 +1,184 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkGradientShader.h"
+#include "SkPath.h"
+#include "SkRegion.h"
+#include "SkShader.h"
+#include "SkUtils.h"
+#include "SkComposeShader.h"
+#include "Sk1DPathEffect.h"
+#include "SkCornerPathEffect.h"
+#include "SkPathMeasure.h"
+#include "SkRandom.h"
+#include "SkColorPriv.h"
+#include "SkColorFilter.h"
+#include "SkLayerRasterizer.h"
+
+#include "SkParsePath.h"
+static void testparse() {
+ SkRect r;
+ r.set(0, 0, SkFloatToScalar(10), SkFloatToScalar(10.5));
+ SkPath p, p2;
+ SkString str, str2;
+
+ p.addRect(r);
+ SkParsePath::ToSVGString(p, &str);
+ SkParsePath::FromSVGString(str.c_str(), &p2);
+ SkParsePath::ToSVGString(p2, &str2);
+}
+
+class ArcsView : public SampleView {
+public:
+ ArcsView() {
+ testparse();
+ fSweep = SkIntToScalar(100);
+ this->setBGColor(0xFFDDDDDD);
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "Arcs");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ static void drawRectWithLines(SkCanvas* canvas, const SkRect& r, const SkPaint& p) {
+ canvas->drawRect(r, p);
+ canvas->drawLine(r.fLeft, r.fTop, r.fRight, r.fBottom, p);
+ canvas->drawLine(r.fLeft, r.fBottom, r.fRight, r.fTop, p);
+ canvas->drawLine(r.fLeft, r.centerY(), r.fRight, r.centerY(), p);
+ canvas->drawLine(r.centerX(), r.fTop, r.centerX(), r.fBottom, p);
+ }
+
+ static void draw_label(SkCanvas* canvas, const SkRect& rect,
+ int start, int sweep) {
+ SkPaint paint;
+
+ paint.setAntiAlias(true);
+ paint.setTextAlign(SkPaint::kCenter_Align);
+
+ SkString str;
+
+ str.appendS32(start);
+ str.append(", ");
+ str.appendS32(sweep);
+ canvas->drawText(str.c_str(), str.size(), rect.centerX(),
+ rect.fBottom + paint.getTextSize() * 5/4, paint);
+ }
+
+ static void drawArcs(SkCanvas* canvas) {
+ SkPaint paint;
+ SkRect r;
+ SkScalar w = SkIntToScalar(75);
+ SkScalar h = SkIntToScalar(50);
+
+ r.set(0, 0, w, h);
+ paint.setAntiAlias(true);
+ paint.setStyle(SkPaint::kStroke_Style);
+
+ canvas->save();
+ canvas->translate(SkIntToScalar(10), SkIntToScalar(300));
+
+ paint.setStrokeWidth(SkIntToScalar(1));
+
+ static const int gAngles[] = {
+ 0, 360,
+ 0, 45,
+ 0, -45,
+ 720, 135,
+ -90, 269,
+ -90, 270,
+ -90, 271,
+ -180, -270,
+ 225, 90
+ };
+
+ for (size_t i = 0; i < SK_ARRAY_COUNT(gAngles); i += 2) {
+ paint.setColor(SK_ColorBLACK);
+ drawRectWithLines(canvas, r, paint);
+
+ paint.setColor(SK_ColorRED);
+ canvas->drawArc(r, SkIntToScalar(gAngles[i]),
+ SkIntToScalar(gAngles[i+1]), false, paint);
+
+ draw_label(canvas, r, gAngles[i], gAngles[i+1]);
+
+ canvas->translate(w * 8 / 7, 0);
+ }
+
+ canvas->restore();
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ fSweep = SampleCode::GetAnimScalar(SkIntToScalar(360)/24,
+ SkIntToScalar(360));
+// fSweep = SkFloatToScalar(359.99f);
+
+ SkRect r;
+ SkPaint paint;
+
+ paint.setAntiAlias(true);
+ paint.setStrokeWidth(SkIntToScalar(2));
+ paint.setStyle(SkPaint::kStroke_Style);
+
+ r.set(0, 0, SkIntToScalar(200), SkIntToScalar(200));
+ r.offset(SkIntToScalar(20), SkIntToScalar(20));
+
+ if (false) {
+ const SkScalar d = SkIntToScalar(3);
+ const SkScalar rad[] = { d, d, d, d, d, d, d, d };
+ SkPath path;
+ path.addRoundRect(r, rad);
+ canvas->drawPath(path, paint);
+ return;
+ }
+
+ drawRectWithLines(canvas, r, paint);
+
+ // printf("----- sweep %g %X\n", SkScalarToFloat(fSweep), SkDegreesToRadians(fSweep));
+
+
+ paint.setStyle(SkPaint::kFill_Style);
+ paint.setColor(0x800000FF);
+ canvas->drawArc(r, 0, fSweep, true, paint);
+
+ paint.setColor(0x800FF000);
+ canvas->drawArc(r, 0, fSweep, false, paint);
+
+ paint.setStyle(SkPaint::kStroke_Style);
+ paint.setColor(SK_ColorRED);
+ canvas->drawArc(r, 0, fSweep, true, paint);
+
+ paint.setStrokeWidth(0);
+ paint.setColor(SK_ColorBLUE);
+ canvas->drawArc(r, 0, fSweep, false, paint);
+
+ drawArcs(canvas);
+ this->inval(NULL);
+ }
+
+ virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
+ // fSweep += SK_Scalar1;
+ this->inval(NULL);
+ return this->INHERITED::onFindClickHandler(x, y);
+ }
+
+ virtual bool onClick(Click* click) {
+ return this->INHERITED::onClick(click);
+ }
+
+private:
+ SkScalar fSweep;
+
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new ArcsView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleAvoid.cpp b/samplecode/SampleAvoid.cpp
new file mode 100644
index 0000000..868a67c
--- /dev/null
+++ b/samplecode/SampleAvoid.cpp
@@ -0,0 +1,99 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkGradientShader.h"
+#include "SkAvoidXfermode.h"
+
+///////////////////////////////////////////////////////////////////////////////
+
+class AvoidView : public SampleView {
+ SkShader* fShader;
+
+ enum {
+ W = 480,
+ H = 320
+ };
+public:
+ AvoidView() {
+ SkColor colors[] = { SK_ColorRED, SK_ColorYELLOW, SK_ColorGREEN, SK_ColorCYAN, SK_ColorBLUE };
+
+#if 0
+ SkPoint pts[] = { 0, 0, SkIntToScalar(100), SkIntToScalar(100) };
+ fShader = SkGradientShader::CreateLinear(pts, colors, NULL,
+ SK_ARRAY_COUNT(colors),
+ SkShader::kMirror_TileMode);
+#else
+ SkPoint pts[] = { { SkIntToScalar(W)/2, SkIntToScalar(H)/2 } };
+ fShader = SkGradientShader::CreateRadial(pts[0], SkIntToScalar(H)/5,
+ colors, NULL,
+ SK_ARRAY_COUNT(colors),
+ SkShader::kMirror_TileMode);
+#endif
+ }
+
+ virtual ~AvoidView() {
+ fShader->unref();
+ }
+
+protected:
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "AvoidXfermode");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ SkPaint paint;
+ SkRect r = { 0, 0, SkIntToScalar(W), SkIntToScalar(H) };
+
+ canvas->translate(r.width() / 6, r.height() / 6);
+
+ paint.setShader(fShader);
+ canvas->drawRect(r, paint);
+
+ static const struct {
+ int fTolerance;
+ SkAvoidXfermode::Mode fMode;
+ float fDX, fDY;
+ } gData[] = {
+ { 16, SkAvoidXfermode::kAvoidColor_Mode, 0, 0 },
+ { 255-16, SkAvoidXfermode::kAvoidColor_Mode, 1, 0 },
+ { 16, SkAvoidXfermode::kTargetColor_Mode, 0, 1 },
+ { 255-16, SkAvoidXfermode::kTargetColor_Mode, 1, 1 },
+ };
+
+ paint.setShader(NULL);
+ paint.setColor(SK_ColorMAGENTA);
+
+ SkPaint frameP;
+ frameP.setStyle(SkPaint::kStroke_Style);
+
+ for (size_t i = 0; i < SK_ARRAY_COUNT(gData); i++) {
+ SkAvoidXfermode mode(SK_ColorGREEN, gData[i].fTolerance,
+ gData[i].fMode);
+ paint.setXfermode(&mode);
+ int div = 3;
+ SkRect rr = { 0, 0, r.width()/div, r.height()/div };
+ rr.offset(r.width()/4 - rr.width()/2, r.height()/4 - rr.height()/2);
+ rr.offset(r.width() * gData[i].fDX/2, r.height() * gData[i].fDY/2);
+ canvas->drawRect(rr, paint);
+ paint.setXfermode(NULL);
+
+ canvas->drawRect(rr, frameP);
+ }
+ }
+
+private:
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() {
+ return new AvoidView;
+}
+
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleBigGradient.cpp b/samplecode/SampleBigGradient.cpp
new file mode 100644
index 0000000..5ebb516
--- /dev/null
+++ b/samplecode/SampleBigGradient.cpp
@@ -0,0 +1,43 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkGradientShader.h"
+
+static SkShader* make_grad(SkScalar w, SkScalar h) {
+ SkColor colors[] = { 0xFF000000, 0xFF333333 };
+ SkPoint pts[] = { { 0, 0 }, { w, h } };
+ return SkGradientShader::CreateLinear(pts, colors, NULL, 2,
+ SkShader::kClamp_TileMode);
+}
+
+class BigGradientView : public SampleView {
+public:
+ BigGradientView() {}
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "BigGradient");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ SkRect r;
+ r.set(0, 0, this->width(), this->height());
+ SkPaint p;
+ p.setShader(make_grad(this->width(), this->height()))->unref();
+ canvas->drawRect(r, p);
+ }
+
+private:
+ typedef SampleView INHERITED;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new BigGradientView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleBitmapRect.cpp b/samplecode/SampleBitmapRect.cpp
new file mode 100644
index 0000000..002b2b9
--- /dev/null
+++ b/samplecode/SampleBitmapRect.cpp
@@ -0,0 +1,92 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkGradientShader.h"
+#include "SkGraphics.h"
+#include "SkImageDecoder.h"
+#include "SkPath.h"
+#include "SkRegion.h"
+#include "SkShader.h"
+#include "SkUtils.h"
+#include "SkXfermode.h"
+#include "SkColorPriv.h"
+#include "SkColorFilter.h"
+#include "SkTime.h"
+#include "SkTypeface.h"
+
+#include "SkOSFile.h"
+#include "SkStream.h"
+
+static SkBitmap make_bitmap() {
+ SkBitmap bm;
+ bm.setConfig(SkBitmap::kARGB_8888_Config, 64, 64);
+ bm.allocPixels();
+ SkCanvas canvas(bm);
+ canvas.drawColor(SK_ColorRED);
+ SkPaint paint;
+ paint.setAntiAlias(true);
+ const SkPoint pts[] = { { 0, 0 }, { 64, 64 } };
+ const SkColor colors[] = { SK_ColorWHITE, SK_ColorBLUE };
+ paint.setShader(SkGradientShader::CreateLinear(pts, colors, NULL, 2,
+ SkShader::kClamp_TileMode))->unref();
+ canvas.drawCircle(32, 32, 32, paint);
+ return bm;
+}
+
+class BitmapRectView : public SampleView {
+public:
+ SkBitmap fBitmap;
+
+ BitmapRectView() {
+ fBitmap = make_bitmap();
+ this->setBGColor(SK_ColorGRAY);
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "BitmapRect");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ const SkIRect src[] = {
+ { 0, 0, 32, 32 },
+ { 0, 0, 80, 80 },
+ { 32, 32, 96, 96 },
+ { -32, -32, 32, 32, }
+ };
+
+ SkPaint paint;
+ paint.setStyle(SkPaint::kStroke_Style);
+ paint.setColor(SK_ColorGREEN);
+
+ SkRect dstR = { 0, 200, 128, 380 };
+
+ canvas->translate(16, 40);
+ for (size_t i = 0; i < SK_ARRAY_COUNT(src); i++) {
+ SkRect srcR;
+ srcR.set(src[i]);
+
+ canvas->drawBitmap(fBitmap, 0, 0, &paint);
+ canvas->drawBitmapRect(fBitmap, &src[i], dstR, &paint);
+
+ canvas->drawRect(dstR, paint);
+ canvas->drawRect(srcR, paint);
+
+ canvas->translate(160, 0);
+ }
+ }
+
+private:
+ typedef SkView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new BitmapRectView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleBlur.cpp b/samplecode/SampleBlur.cpp
new file mode 100644
index 0000000..d2ea2b0
--- /dev/null
+++ b/samplecode/SampleBlur.cpp
@@ -0,0 +1,131 @@
+#include "SampleCode.h"
+#include "SkBlurMaskFilter.h"
+#include "SkColorPriv.h"
+#include "SkGradientShader.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkUtils.h"
+
+static SkBitmap make_bitmap() {
+ SkBitmap bm;
+ SkColorTable* ctable = new SkColorTable(256);
+
+ SkPMColor* c = ctable->lockColors();
+ for (int i = 0; i < 256; i++) {
+ c[i] = SkPackARGB32(255 - i, 0, 0, 0);
+ }
+ ctable->unlockColors(true);
+ bm.setConfig(SkBitmap::kIndex8_Config, 256, 256);
+ bm.allocPixels(ctable);
+ ctable->unref();
+
+ bm.lockPixels();
+ const float cx = bm.width() * 0.5f;
+ const float cy = bm.height() * 0.5f;
+ for (int y = 0; y < bm.height(); y++) {
+ float dy = y - cy;
+ dy *= dy;
+ uint8_t* p = bm.getAddr8(0, y);
+ for (int x = 0; x < 256; x++) {
+ float dx = x - cx;
+ dx *= dx;
+ float d = (dx + dy) / (cx/2);
+ int id = (int)d;
+ if (id > 255) {
+ id = 255;
+ }
+ p[x] = id;
+ }
+ }
+ bm.unlockPixels();
+ return bm;
+}
+
+class BlurView : public SkView {
+ SkBitmap fBM;
+public:
+ BlurView() {
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "Blur");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ void drawBG(SkCanvas* canvas) {
+ canvas->drawColor(0xFFDDDDDD);
+ }
+
+ virtual void onDraw(SkCanvas* canvas) {
+ drawBG(canvas);
+
+ SkBlurMaskFilter::BlurStyle NONE = SkBlurMaskFilter::BlurStyle(-999);
+ static const struct {
+ SkBlurMaskFilter::BlurStyle fStyle;
+ int fCx, fCy;
+ } gRecs[] = {
+ { NONE, 0, 0 },
+ { SkBlurMaskFilter::kInner_BlurStyle, -1, 0 },
+ { SkBlurMaskFilter::kNormal_BlurStyle, 0, 1 },
+ { SkBlurMaskFilter::kSolid_BlurStyle, 0, -1 },
+ { SkBlurMaskFilter::kOuter_BlurStyle, 1, 0 },
+ };
+
+ SkPaint paint;
+ paint.setAntiAlias(true);
+ paint.setTextSize(25);
+ canvas->translate(-40, 0);
+
+ SkBlurMaskFilter::BlurFlags flags = SkBlurMaskFilter::kNone_BlurFlag;
+ for (int j = 0; j < 2; j++) {
+ canvas->save();
+ paint.setColor(SK_ColorBLUE);
+ for (size_t i = 0; i < SK_ARRAY_COUNT(gRecs); i++) {
+ if (gRecs[i].fStyle != NONE) {
+ SkMaskFilter* mf = SkBlurMaskFilter::Create(20,
+ gRecs[i].fStyle,
+ flags);
+ paint.setMaskFilter(mf)->unref();
+ } else {
+ paint.setMaskFilter(NULL);
+ }
+ canvas->drawCircle(200 + gRecs[i].fCx*100.f,
+ 200 + gRecs[i].fCy*100.f, 50, paint);
+ }
+ // draw text
+ {
+ SkMaskFilter* mf = SkBlurMaskFilter::Create(4,
+ SkBlurMaskFilter::kNormal_BlurStyle,
+ flags);
+ paint.setMaskFilter(mf)->unref();
+ SkScalar x = SkIntToScalar(70);
+ SkScalar y = SkIntToScalar(400);
+ paint.setColor(SK_ColorBLACK);
+ canvas->drawText("Hamburgefons Style", 18, x, y, paint);
+ canvas->drawText("Hamburgefons Style", 18, x, y + SkIntToScalar(50), paint);
+ paint.setMaskFilter(NULL);
+ paint.setColor(SK_ColorWHITE);
+ x -= SkIntToScalar(2);
+ y -= SkIntToScalar(2);
+ canvas->drawText("Hamburgefons Style", 18, x, y, paint);
+ }
+ canvas->restore();
+ flags = SkBlurMaskFilter::kHighQuality_BlurFlag;
+ canvas->translate(350, 0);
+ }
+ }
+
+private:
+ typedef SkView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new BlurView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleBox.cpp b/samplecode/SampleBox.cpp
new file mode 100644
index 0000000..d445df7
--- /dev/null
+++ b/samplecode/SampleBox.cpp
@@ -0,0 +1,48 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+
+class SimpleView : public SampleView {
+public:
+ SimpleView() {
+ this->setBGColor(0xFFDDDDDD);
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "Box Gradient");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ SkPaint paint;
+ paint.setAntiAlias(true);
+ paint.setStyle(SkPaint::kStroke_Style);
+ paint.setStrokeWidth(SkScalarHalf(SkIntToScalar(3)));
+ paint.setStyle(SkPaint::kFill_Style);
+
+ SkRect r;
+ SkScalar x,y;
+ x = 10;
+ y = 10;
+
+ r.set(x, y, x + SkIntToScalar(100), y + SkIntToScalar(100));
+ for (int i = 0; i < 256; ++i) {
+ canvas->translate(1, 1);
+ paint.setColor(0xFF000000 + i * 0x00010000);
+ canvas->drawRect(r, paint);
+ }
+ }
+
+private:
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new SimpleView; }
+static SkViewRegister reg(MyFactory);
\ No newline at end of file
diff --git a/samplecode/SampleCamera.cpp b/samplecode/SampleCamera.cpp
new file mode 100644
index 0000000..2db3968
--- /dev/null
+++ b/samplecode/SampleCamera.cpp
@@ -0,0 +1,99 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkCamera.h"
+#include "SkEmbossMaskFilter.h"
+#include "SkGradientShader.h"
+#include "SkPath.h"
+#include "SkRegion.h"
+#include "SkShader.h"
+#include "SkUtils.h"
+#include "SkRandom.h"
+#include "SkImageDecoder.h"
+
+class CameraView : public SampleView {
+ SkTDArray<SkShader*> fShaders;
+ int fShaderIndex;
+ bool fFrontFace;
+public:
+ CameraView() {
+ fRX = fRY = fRZ = 0;
+ fShaderIndex = 0;
+ fFrontFace = false;
+
+ for (int i = 0;; i++) {
+ SkString str;
+ str.printf("/skimages/elephant%d.jpeg", i);
+ SkBitmap bm;
+ if (SkImageDecoder::DecodeFile(str.c_str(), &bm)) {
+ SkShader* s = SkShader::CreateBitmapShader(bm,
+ SkShader::kClamp_TileMode,
+ SkShader::kClamp_TileMode);
+
+ SkRect src = { 0, 0, SkIntToScalar(bm.width()), SkIntToScalar(bm.height()) };
+ SkRect dst = { -150, -150, 150, 150 };
+ SkMatrix matrix;
+ matrix.setRectToRect(src, dst, SkMatrix::kFill_ScaleToFit);
+ s->setLocalMatrix(matrix);
+ *fShaders.append() = s;
+ } else {
+ break;
+ }
+ }
+ this->setBGColor(0xFFDDDDDD);
+ }
+
+ virtual ~CameraView() {
+ fShaders.unrefAll();
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt))
+ {
+ SampleCode::TitleR(evt, "Camera");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ canvas->translate(this->width()/2, this->height()/2);
+
+ Sk3DView view;
+ view.rotateX(fRX);
+ view.rotateY(fRY);
+ view.applyToCanvas(canvas);
+
+ SkPaint paint;
+ if (fShaders.count() > 0) {
+ bool frontFace = view.dotWithNormal(0, 0, SK_Scalar1) < 0;
+ if (frontFace != fFrontFace) {
+ fFrontFace = frontFace;
+ fShaderIndex = (fShaderIndex + 1) % fShaders.count();
+ }
+
+ paint.setAntiAlias(true);
+ paint.setShader(fShaders[fShaderIndex]);
+ SkRect r = { -150, -150, 150, 150 };
+ canvas->drawRoundRect(r, 30, 30, paint);
+ }
+
+ fRY += SampleCode::GetAnimSecondsDelta() * 90;
+ if (fRY >= SkIntToScalar(360)) {
+ fRY = 0;
+ }
+ this->inval(NULL);
+ }
+
+private:
+ SkScalar fRX, fRY, fRZ;
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new CameraView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleCircle.cpp b/samplecode/SampleCircle.cpp
new file mode 100644
index 0000000..2abc28d
--- /dev/null
+++ b/samplecode/SampleCircle.cpp
@@ -0,0 +1,126 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkDevice.h"
+#include "SkPaint.h"
+
+// ensure that we don't accidentally screw up the bounds when the oval is
+// fractional, and the impl computes the center and radii, and uses them to
+// reconstruct the edges of the circle.
+// see bug# 1504910
+static void test_circlebounds(SkCanvas* canvas) {
+#ifdef SK_SCALAR_IS_FLOAT
+ SkRect r = { 1.39999998f, 1, 21.3999996f, 21 };
+ SkPath p;
+ p.addOval(r);
+ SkASSERT(r == p.getBounds());
+#endif
+}
+
+class CircleView : public SampleView {
+public:
+ static const SkScalar ANIM_DX;
+ static const SkScalar ANIM_DY;
+ static const SkScalar ANIM_RAD;
+ SkScalar fDX, fDY, fRAD;
+
+ CircleView() {
+ fDX = fDY = fRAD = 0;
+ fN = 3;
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "Circles");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ void circle(SkCanvas* canvas, int width, bool aa) {
+ SkPaint paint;
+
+ paint.setAntiAlias(aa);
+ if (width < 0) {
+ paint.setStyle(SkPaint::kFill_Style);
+ } else {
+ paint.setStyle(SkPaint::kStroke_Style);
+ paint.setStrokeWidth(SkIntToScalar(width));
+ }
+ canvas->drawCircle(0, 0, SkIntToScalar(9) + fRAD, paint);
+ }
+
+ void drawSix(SkCanvas* canvas, SkScalar dx, SkScalar dy) {
+ for (int width = -1; width <= 1; width++) {
+ canvas->save();
+ circle(canvas, width, false);
+ canvas->translate(0, dy);
+ circle(canvas, width, true);
+ canvas->restore();
+ canvas->translate(dx, 0);
+ }
+ }
+
+ static void blowup(SkCanvas* canvas, const SkIRect& src, const SkRect& dst) {
+ SkDevice* device = canvas->getDevice();
+ const SkBitmap& bm = device->accessBitmap(false);
+ canvas->drawBitmapRect(bm, &src, dst, NULL);
+ }
+
+ static void make_poly(SkPath* path, int n) {
+ if (n <= 0) {
+ return;
+ }
+ path->incReserve(n + 1);
+ path->moveTo(SK_Scalar1, 0);
+ SkScalar step = SK_ScalarPI * 2 / n;
+ SkScalar angle = 0;
+ for (int i = 1; i < n; i++) {
+ angle += step;
+ SkScalar c, s = SkScalarSinCos(angle, &c);
+ path->lineTo(c, s);
+ }
+ path->close();
+ }
+
+ static void rotate(SkCanvas* canvas, SkScalar angle, SkScalar px, SkScalar py) {
+ canvas->translate(-px, -py);
+ canvas->rotate(angle);
+ canvas->translate(px, py);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ SkPaint paint;
+ paint.setAntiAlias(true);
+ paint.setStyle(SkPaint::kStroke_Style);
+// canvas->drawCircle(250, 250, 220, paint);
+ SkMatrix matrix;
+ matrix.setScale(SkIntToScalar(100), SkIntToScalar(100));
+ matrix.postTranslate(SkIntToScalar(200), SkIntToScalar(200));
+ canvas->concat(matrix);
+ for (int n = 3; n < 20; n++) {
+ SkPath path;
+ make_poly(&path, n);
+ SkAutoCanvasRestore acr(canvas, true);
+ canvas->rotate(SkIntToScalar(10) * (n - 3));
+ canvas->translate(-SK_Scalar1, 0);
+ canvas->drawPath(path, paint);
+ }
+ }
+
+private:
+ int fN;
+ typedef SampleView INHERITED;
+};
+
+const SkScalar CircleView::ANIM_DX(SK_Scalar1 / 67);
+const SkScalar CircleView::ANIM_DY(SK_Scalar1 / 29);
+const SkScalar CircleView::ANIM_RAD(SK_Scalar1 / 19);
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new CircleView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleClamp.cpp b/samplecode/SampleClamp.cpp
new file mode 100644
index 0000000..88c1b91
--- /dev/null
+++ b/samplecode/SampleClamp.cpp
@@ -0,0 +1,61 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkGraphics.h"
+#include "SkRandom.h"
+#include "SkGradientShader.h"
+#include "SkPicture.h"
+
+static SkShader* make_linear() {
+ SkPoint pts[] = { 0, 0, SK_Scalar1/500, SK_Scalar1/500 };
+ SkColor colors[] = { SK_ColorRED, SK_ColorBLUE };
+ return SkGradientShader::CreateLinear(pts, colors, NULL, 2,
+ SkShader::kClamp_TileMode);
+}
+
+class ClampView : public SampleView {
+ SkShader* fGrad;
+
+public:
+ ClampView() {
+ fGrad = make_linear();
+ }
+
+ virtual ~ClampView() {
+ fGrad->unref();
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "Clamp");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ SkPaint paint;
+ paint.setShader(fGrad);
+
+// canvas->translate(this->width()/2, this->height()/2);
+ canvas->translate(64, 64);
+ canvas->drawPaint(paint);
+
+ SkPicture pic;
+ SkCanvas* c = pic.beginRecording(100, 100, 0);
+ SkCanvas::LayerIter layerIterator(c, false);
+ layerIterator.next();
+ layerIterator.done();
+ }
+
+private:
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new ClampView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleCode.h b/samplecode/SampleCode.h
new file mode 100644
index 0000000..c42ee25
--- /dev/null
+++ b/samplecode/SampleCode.h
@@ -0,0 +1,81 @@
+#ifndef SampleCode_DEFINED
+#define SampleCode_DEFINED
+
+#include "SkColor.h"
+#include "SkEvent.h"
+#include "SkKey.h"
+#include "SkView.h"
+
+class SampleCode {
+public:
+ static bool KeyQ(const SkEvent&, SkKey* outKey);
+ static bool CharQ(const SkEvent&, SkUnichar* outUni);
+
+ static bool TitleQ(const SkEvent&);
+ static void TitleR(SkEvent*, const char title[]);
+
+ static bool PrefSizeQ(const SkEvent&);
+ static void PrefSizeR(SkEvent*, SkScalar width, SkScalar height);
+
+ static bool FastTextQ(const SkEvent&);
+
+ static SkMSec GetAnimTime();
+ static SkMSec GetAnimTimeDelta();
+ static SkScalar GetAnimSecondsDelta();
+ static SkScalar GetAnimScalar(SkScalar speedPerSec, SkScalar period = 0);
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+typedef SkView* (*SkViewFactory)();
+
+class SkViewRegister : SkNoncopyable {
+public:
+ explicit SkViewRegister(SkViewFactory);
+
+ static const SkViewRegister* Head() { return gHead; }
+
+ SkViewRegister* next() const { return fChain; }
+ SkViewFactory factory() const { return fFact; }
+
+private:
+ SkViewFactory fFact;
+ SkViewRegister* fChain;
+
+ static SkViewRegister* gHead;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+class SampleView : public SkView {
+public:
+ SampleView() : fRepeatCount(1), fBGColor(SK_ColorWHITE) {
+ fUsePipe = false;
+ }
+
+ void setBGColor(SkColor color) { fBGColor = color; }
+
+ static bool IsSampleView(SkView*);
+ static bool SetRepeatDraw(SkView*, int count);
+ static bool SetUsePipe(SkView*, bool);
+
+protected:
+ virtual void onDrawBackground(SkCanvas*);
+ virtual void onDrawContent(SkCanvas*) = 0;
+
+ // overrides
+ virtual bool onEvent(const SkEvent& evt);
+ virtual bool onQuery(SkEvent* evt);
+ virtual void onDraw(SkCanvas*);
+
+private:
+ int fRepeatCount;
+ SkColor fBGColor;
+
+ bool fUsePipe;
+
+ typedef SkView INHERITED;
+};
+
+#endif
+
diff --git a/samplecode/SampleColorFilter.cpp b/samplecode/SampleColorFilter.cpp
new file mode 100644
index 0000000..0e1fb11
--- /dev/null
+++ b/samplecode/SampleColorFilter.cpp
@@ -0,0 +1,210 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkColorFilter.h"
+#include "SkDevice.h"
+#include "SkPaint.h"
+#include "SkShader.h"
+
+static int inflate5To8(int x) {
+ return (x << 3) | (x >> 2);
+}
+
+static int trunc5(int x) {
+ return x >> 3;
+}
+
+#define SK_R16_BITS 5
+
+static int round5_slow(int x) {
+ int orig = x & 7;
+ int fake = x >> 5;
+ int trunc = x >> 3;
+
+ int diff = fake - orig;
+
+ int bias = 0;
+ if (diff > 4) {
+ bias = -1;
+ } else if (diff < -4) {
+ bias = 1;
+ }
+ return trunc + bias;
+}
+
+static int round5_fast(int x) {
+ int result = x + 3 - (x >> 5) + (x >> 7);
+ result >>= 3;
+
+ {
+ int r2 = round5_slow(x);
+ SkASSERT(r2 == result);
+ }
+ return result;
+}
+
+static void test_5bits() {
+ int e0 = 0;
+ int e1 = 0;
+ int e2 = 0;
+ int ae0 = 0;
+ int ae1 = 0;
+ int ae2 = 0;
+ for (int i = 0; i < 256; i++) {
+ int t0 = trunc5(i);
+ int t1 = round5_fast(i);
+ int t2 = trunc5(i);
+ int v0 = inflate5To8(t0);
+ int v1 = inflate5To8(t1);
+ int v2 = inflate5To8(t2);
+ int err0 = i - v0;
+ int err1 = i - v1;
+ int err2 = i - v2;
+ SkDebugf("--- %3d : trunc=%3d (%2d) round:%3d (%2d) \n"/*new:%d (%2d)\n"*/, i,
+ v0, err0, v1, err1, v2, err2);
+
+
+ e0 += err0;
+ e1 += err1;
+ e2 += err2;
+ ae0 += SkAbs32(err0);
+ ae1 += SkAbs32(err1);
+ ae2 += SkAbs32(err2);
+ }
+ SkDebugf("--- trunc: %d %d round: %d %d new: %d %d\n", e0, ae0, e1, ae1, e2, ae2);
+}
+
+static SkShader* createChecker() {
+ SkBitmap bm;
+ bm.setConfig(SkBitmap::kARGB_8888_Config, 2, 2);
+ bm.allocPixels();
+ bm.lockPixels();
+ *bm.getAddr32(0, 0) = *bm.getAddr32(1, 1) = SkPreMultiplyColor(0xFFFFFFFF);
+ *bm.getAddr32(0, 1) = *bm.getAddr32(1, 0) = SkPreMultiplyColor(0xFFCCCCCC);
+ SkShader* s = SkShader::CreateBitmapShader(bm, SkShader::kRepeat_TileMode,
+ SkShader::kRepeat_TileMode);
+
+ SkMatrix m;
+ m.setScale(12, 12);
+ s->setLocalMatrix(m);
+ return s;
+}
+
+static SkBitmap createBitmap(int n) {
+ SkBitmap bitmap;
+ bitmap.setConfig(SkBitmap::kARGB_8888_Config, n, n);
+ bitmap.allocPixels();
+ bitmap.eraseColor(0);
+
+ SkCanvas canvas(bitmap);
+ SkRect r;
+ r.set(0, 0, SkIntToScalar(n), SkIntToScalar(n));
+ r.inset(SK_Scalar1, SK_Scalar1);
+
+ SkPaint paint;
+ paint.setAntiAlias(true);
+
+ paint.setColor(SK_ColorRED);
+ canvas.drawOval(r, paint);
+
+ r.inset(SK_Scalar1*n/4, SK_Scalar1*n/4);
+ paint.setXfermodeMode(SkXfermode::kSrc_Mode);
+ paint.setColor(0x800000FF);
+ canvas.drawOval(r, paint);
+
+ return bitmap;
+}
+
+class ColorFilterView : public SampleView {
+ SkBitmap fBitmap;
+ SkShader* fShader;
+ enum {
+ N = 64
+ };
+public:
+ ColorFilterView() {
+ fBitmap = createBitmap(N);
+ fShader = createChecker();
+
+// test_5bits();
+ }
+
+ virtual ~ColorFilterView() {
+ fShader->unref();
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "ColorFilter");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ virtual void onDrawBackground(SkCanvas* canvas) {
+ SkPaint paint;
+ paint.setShader(fShader);
+ canvas->drawPaint(paint);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ if (false) {
+ SkPaint p;
+ p.setAntiAlias(true);
+ SkRect r = { 20.4f, 10, 20.6f, 20 };
+ canvas->drawRect(r, p);
+ r.set(30.9f, 10, 31.1f, 20);
+ canvas->drawRect(r, p);
+ return;
+ }
+
+ static const SkXfermode::Mode gModes[] = {
+ SkXfermode::kClear_Mode,
+ SkXfermode::kSrc_Mode,
+ SkXfermode::kDst_Mode,
+ SkXfermode::kSrcOver_Mode,
+ SkXfermode::kDstOver_Mode,
+ SkXfermode::kSrcIn_Mode,
+ SkXfermode::kDstIn_Mode,
+ SkXfermode::kSrcOut_Mode,
+ SkXfermode::kDstOut_Mode,
+ SkXfermode::kSrcATop_Mode,
+ SkXfermode::kDstATop_Mode,
+ SkXfermode::kXor_Mode,
+ SkXfermode::kPlus_Mode,
+ SkXfermode::kMultiply_Mode,
+ };
+
+ static const SkColor gColors[] = {
+ 0xFF000000,
+ 0x80000000,
+ 0xFF00FF00,
+ 0x8000FF00,
+ 0x00000000,
+ };
+
+ float scale = 1.5f;
+ SkPaint paint;
+ canvas->translate(N / 8, N / 8);
+
+ for (size_t y = 0; y < SK_ARRAY_COUNT(gColors); y++) {
+ for (size_t x = 0; x < SK_ARRAY_COUNT(gModes); x++) {
+ SkColorFilter* cf = SkColorFilter::CreateModeFilter(gColors[y], gModes[x]);
+ SkSafeUnref(paint.setColorFilter(cf));
+ canvas->drawBitmap(fBitmap, x * N * 1.25f, y * N * scale, &paint);
+ }
+ }
+
+ }
+
+private:
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new ColorFilterView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleComplexClip.cpp b/samplecode/SampleComplexClip.cpp
new file mode 100644
index 0000000..672d055
--- /dev/null
+++ b/samplecode/SampleComplexClip.cpp
@@ -0,0 +1,147 @@
+#include "SampleCode.h"
+#include "SkCanvas.h"
+#include "SkPath.h"
+#include "SkView.h"
+
+class ComplexClipView : public SampleView {
+public:
+ ComplexClipView() {
+ this->setBGColor(0xFFA0DDA0);
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "ComplexClip");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ SkPath path;
+ path.moveTo(SkIntToScalar(0), SkIntToScalar(50));
+ path.quadTo(SkIntToScalar(0), SkIntToScalar(0), SkIntToScalar(50), SkIntToScalar(0));
+ path.lineTo(SkIntToScalar(175), SkIntToScalar(0));
+ path.quadTo(SkIntToScalar(200), SkIntToScalar(0), SkIntToScalar(200), SkIntToScalar(25));
+ path.lineTo(SkIntToScalar(200), SkIntToScalar(150));
+ path.quadTo(SkIntToScalar(200), SkIntToScalar(200), SkIntToScalar(150), SkIntToScalar(200));
+ path.lineTo(SkIntToScalar(0), SkIntToScalar(200));
+ path.close();
+ path.moveTo(SkIntToScalar(50), SkIntToScalar(50));
+ path.lineTo(SkIntToScalar(150), SkIntToScalar(50));
+ path.lineTo(SkIntToScalar(150), SkIntToScalar(125));
+ path.quadTo(SkIntToScalar(150), SkIntToScalar(150), SkIntToScalar(125), SkIntToScalar(150));
+ path.lineTo(SkIntToScalar(50), SkIntToScalar(150));
+ path.close();
+ path.setFillType(SkPath::kEvenOdd_FillType);
+ SkColor pathColor = SK_ColorBLACK;
+ SkPaint pathPaint;
+ pathPaint.setAntiAlias(true);
+ pathPaint.setColor(pathColor);
+
+ SkPath clipA;
+ clipA.moveTo(SkIntToScalar(10), SkIntToScalar(20));
+ clipA.lineTo(SkIntToScalar(165), SkIntToScalar(22));
+ clipA.lineTo(SkIntToScalar(70), SkIntToScalar(105));
+ clipA.lineTo(SkIntToScalar(165), SkIntToScalar(177));
+ clipA.lineTo(SkIntToScalar(-5), SkIntToScalar(180));
+ clipA.close();
+ SkColor colorA = SK_ColorCYAN;
+
+ SkPath clipB;
+ clipB.moveTo(SkIntToScalar(40), SkIntToScalar(10));
+ clipB.lineTo(SkIntToScalar(190), SkIntToScalar(15));
+ clipB.lineTo(SkIntToScalar(195), SkIntToScalar(190));
+ clipB.lineTo(SkIntToScalar(40), SkIntToScalar(185));
+ clipB.lineTo(SkIntToScalar(155), SkIntToScalar(100));
+ clipB.close();
+ SkColor colorB = SK_ColorRED;
+
+ SkPaint paint;
+ paint.setAntiAlias(true);
+
+ paint.setStyle(SkPaint::kStroke_Style);
+ paint.setStrokeWidth(0);
+
+ canvas->translate(SkIntToScalar(10),SkIntToScalar(10));
+ canvas->drawPath(path, pathPaint);
+ paint.setColor(colorA);
+ canvas->drawPath(clipA, paint);
+ paint.setColor(colorB);
+ canvas->drawPath(clipB, paint);
+
+ static const struct {
+ SkRegion::Op fOp;
+ const char* fName;
+ } gOps[] = { //extra spaces in names for measureText
+ {SkRegion::kIntersect_Op, "Isect "},
+ {SkRegion::kDifference_Op, "Diff " },
+ {SkRegion::kUnion_Op, "Union "},
+ {SkRegion::kXOR_Op, "Xor " },
+ {SkRegion::kReverseDifference_Op, "RDiff "}
+ };
+
+ canvas->translate(0, SkIntToScalar(40));
+ canvas->scale(3 * SK_Scalar1 / 4, 3 * SK_Scalar1 / 4);
+ canvas->save();
+
+ for (int invA = 0; invA < 2; ++invA) {
+ for (size_t op = 0; op < SK_ARRAY_COUNT(gOps); ++op) {
+ int idx = invA * SK_ARRAY_COUNT(gOps) + op;
+ if (!(idx % 3)) {
+ canvas->restore();
+ canvas->translate(0, SkIntToScalar(250));
+ canvas->save();
+ }
+ canvas->save();
+ // set clip
+ clipA.setFillType(invA ? SkPath::kInverseEvenOdd_FillType :
+ SkPath::kEvenOdd_FillType);
+ canvas->clipPath(clipA);
+ canvas->clipPath(clipB, gOps[op].fOp);
+
+ // draw path clipped
+ canvas->drawPath(path, pathPaint);
+ canvas->restore();
+
+ // draw path in hairline
+ paint.setColor(pathColor);
+ canvas->drawPath(path, paint);
+
+ // draw clips in hair line
+ paint.setColor(colorA);
+ canvas->drawPath(clipA, paint);
+ paint.setColor(colorB);
+ canvas->drawPath(clipB, paint);
+
+ paint.setTextSize(SkIntToScalar(20));
+
+ SkScalar txtX = SkIntToScalar(55);
+ paint.setColor(colorA);
+ const char* aTxt = invA ? "InverseA " : "A ";
+ canvas->drawText(aTxt, strlen(aTxt), txtX, SkIntToScalar(220), paint);
+ txtX += paint.measureText(aTxt, strlen(aTxt));
+ paint.setColor(SK_ColorBLACK);
+ canvas->drawText(gOps[op].fName, strlen(gOps[op].fName),
+ txtX, SkIntToScalar(220), paint);
+ txtX += paint.measureText(gOps[op].fName, strlen(gOps[op].fName));
+ paint.setColor(colorB);
+ canvas->drawText("B", 1, txtX, SkIntToScalar(220), paint);
+
+ canvas->translate(SkIntToScalar(250),0);
+ }
+ }
+ canvas->restore();
+ }
+
+private:
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new ComplexClipView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleCull.cpp b/samplecode/SampleCull.cpp
new file mode 100644
index 0000000..7b4eab6
--- /dev/null
+++ b/samplecode/SampleCull.cpp
@@ -0,0 +1,189 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkCornerPathEffect.h"
+#include "SkCullPoints.h"
+#include "SkGradientShader.h"
+#include "SkPath.h"
+#include "SkRegion.h"
+#include "SkShader.h"
+#include "SkUtils.h"
+#include "SkRandom.h"
+
+static void addbump(SkPath* path, const SkPoint pts[2], SkScalar bump) {
+ SkVector tang;
+
+ tang.setLength(pts[1].fX - pts[0].fX, pts[1].fY - pts[0].fY, bump);
+
+ path->lineTo(SkScalarHalf(pts[0].fX + pts[1].fX) - tang.fY,
+ SkScalarHalf(pts[0].fY + pts[1].fY) + tang.fX);
+ path->lineTo(pts[1]);
+}
+
+static void subdivide(SkPath* path, SkScalar bump) {
+ SkPath::Iter iter(*path, false);
+ SkPoint pts[4];
+ SkPath tmp;
+
+ for (;;)
+ switch (iter.next(pts)) {
+ case SkPath::kMove_Verb:
+ tmp.moveTo(pts[0]);
+ break;
+ case SkPath::kLine_Verb:
+ addbump(&tmp, pts, bump);
+ bump = -bump;
+ break;
+ case SkPath::kDone_Verb:
+ goto FINISH;
+ default:
+ break;
+ }
+
+FINISH:
+ path->swap(tmp);
+}
+
+static SkIPoint* getpts(const SkPath& path, int* count) {
+ SkPoint pts[4];
+ int n = 1;
+ SkIPoint* array;
+
+ {
+ SkPath::Iter iter(path, false);
+ for (;;)
+ switch (iter.next(pts)) {
+ case SkPath::kLine_Verb:
+ n += 1;
+ break;
+ case SkPath::kDone_Verb:
+ goto FINISHED;
+ default:
+ break;
+ }
+ }
+
+FINISHED:
+ array = new SkIPoint[n];
+ n = 0;
+
+ {
+ SkPath::Iter iter(path, false);
+ for (;;)
+ switch (iter.next(pts)) {
+ case SkPath::kMove_Verb:
+ array[n++].set(SkScalarRound(pts[0].fX), SkScalarRound(pts[0].fY));
+ break;
+ case SkPath::kLine_Verb:
+ array[n++].set(SkScalarRound(pts[1].fX), SkScalarRound(pts[1].fY));
+ break;
+ case SkPath::kDone_Verb:
+ goto FINISHED2;
+ default:
+ break;
+ }
+ }
+
+FINISHED2:
+ *count = n;
+ return array;
+}
+
+static SkScalar nextScalarRange(SkRandom& rand, SkScalar min, SkScalar max) {
+ return min + SkScalarMul(rand.nextUScalar1(), max - min);
+}
+
+class CullView : public SampleView {
+public:
+ CullView() {
+ fClip.set(0, 0, SkIntToScalar(160), SkIntToScalar(160));
+
+ SkRandom rand;
+
+ for (int i = 0; i < 50; i++) {
+ SkScalar x = nextScalarRange(rand, -fClip.width()*1, fClip.width()*2);
+ SkScalar y = nextScalarRange(rand, -fClip.height()*1, fClip.height()*2);
+ if (i == 0)
+ fPath.moveTo(x, y);
+ else
+ fPath.lineTo(x, y);
+ }
+
+ SkScalar bump = fClip.width()/8;
+ subdivide(&fPath, bump);
+ subdivide(&fPath, bump);
+ subdivide(&fPath, bump);
+ fPoints = getpts(fPath, &fPtCount);
+
+ this->setBGColor(0xFFDDDDDD);
+ }
+
+ virtual ~CullView() {
+ delete[] fPoints;
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "Culling");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ SkAutoCanvasRestore ar(canvas, true);
+
+ canvas->translate( SkScalarHalf(this->width() - fClip.width()),
+ SkScalarHalf(this->height() - fClip.height()));
+
+ // canvas->scale(SK_Scalar1*3, SK_Scalar1*3, 0, 0);
+
+ SkPaint paint;
+
+ // paint.setAntiAliasOn(true);
+ paint.setStyle(SkPaint::kStroke_Style);
+
+ canvas->drawRect(fClip, paint);
+
+#if 1
+ paint.setColor(0xFF555555);
+ paint.setStrokeWidth(SkIntToScalar(2));
+// paint.setPathEffect(new SkCornerPathEffect(SkIntToScalar(30)))->unref();
+ canvas->drawPath(fPath, paint);
+// paint.setPathEffect(NULL);
+#endif
+
+ SkPath tmp;
+ SkIRect iclip;
+ fClip.round(&iclip);
+
+ SkCullPointsPath cpp(iclip, &tmp);
+
+ cpp.moveTo(fPoints[0].fX, fPoints[0].fY);
+ for (int i = 0; i < fPtCount; i++)
+ cpp.lineTo(fPoints[i].fX, fPoints[i].fY);
+
+ paint.setColor(SK_ColorRED);
+ paint.setStrokeWidth(SkIntToScalar(3));
+ paint.setStrokeJoin(SkPaint::kRound_Join);
+ canvas->drawPath(tmp, paint);
+
+ this->inval(NULL);
+ }
+
+private:
+ SkRect fClip;
+ SkIPoint* fPoints;
+ SkPath fPath;
+ int fPtCount;
+
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new CullView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleDash.cpp b/samplecode/SampleDash.cpp
new file mode 100644
index 0000000..4cef07f
--- /dev/null
+++ b/samplecode/SampleDash.cpp
@@ -0,0 +1,88 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkGraphics.h"
+#include "SkRandom.h"
+#include "SkDashPathEffect.h"
+#include "SkShader.h"
+
+static void setBitmapDash(SkPaint* paint, int width) {
+ SkColor c = paint->getColor();
+
+ SkBitmap bm;
+ bm.setConfig(SkBitmap::kARGB_8888_Config, 2, 1);
+ bm.allocPixels();
+ bm.lockPixels();
+ *bm.getAddr32(0, 0) = SkPreMultiplyARGB(0xFF, SkColorGetR(c),
+ SkColorGetG(c), SkColorGetB(c));
+ *bm.getAddr32(1, 0) = 0;
+ bm.unlockPixels();
+
+ SkMatrix matrix;
+ matrix.setScale(SkIntToScalar(width), SK_Scalar1);
+
+ SkShader* s = SkShader::CreateBitmapShader(bm, SkShader::kRepeat_TileMode,
+ SkShader::kClamp_TileMode);
+ s->setLocalMatrix(matrix);
+
+ paint->setShader(s)->unref();
+}
+
+class DashView : public SampleView {
+public:
+ DashView() {
+ this->setBGColor(0xFFDDDDDD);
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "Dash");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ static const char* gStr[] = {
+ "11",
+ "44",
+ "112233",
+ "411327463524",
+ };
+
+ SkPaint paint;
+ paint.setStrokeWidth(SkIntToScalar(1));
+
+ SkScalar x0 = SkIntToScalar(10);
+ SkScalar y0 = SkIntToScalar(10);
+ SkScalar x1 = x0 + SkIntToScalar(1000);
+ for (size_t i = 0; i < SK_ARRAY_COUNT(gStr); i++) {
+ SkScalar interval[12];
+ size_t len = SkMin32(strlen(gStr[i]), SK_ARRAY_COUNT(interval));
+ for (size_t j = 0; j < len; j++) {
+ interval[j] = SkIntToScalar(gStr[i][j] - '0');
+ }
+
+ SkDashPathEffect dash(interval, len, 0);
+ paint.setPathEffect(&dash);
+ canvas->drawLine(x0, y0, x1, y0, paint);
+ paint.setPathEffect(NULL);
+
+ y0 += paint.getStrokeWidth() * 3;
+ }
+
+ setBitmapDash(&paint, 3);
+ canvas->drawLine(x0, y0, x1, y0, paint);
+ }
+
+private:
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new DashView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleDecode.cpp b/samplecode/SampleDecode.cpp
new file mode 100644
index 0000000..b192c5d
--- /dev/null
+++ b/samplecode/SampleDecode.cpp
@@ -0,0 +1,69 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkImageDecoder.h"
+#include "SkStream.h"
+
+static const struct {
+ SkBitmap::Config fPrefConfig;
+ bool fDither;
+} gRec[] = {
+ { SkBitmap::kIndex8_Config, false },
+ { SkBitmap::kARGB_8888_Config, false },
+ { SkBitmap::kARGB_4444_Config, false },
+ { SkBitmap::kARGB_4444_Config, true },
+ { SkBitmap::kRGB_565_Config, false },
+ { SkBitmap::kRGB_565_Config, true },
+};
+
+class DecodeView : public SkView {
+public:
+ SkBitmap fBitmap[SK_ARRAY_COUNT(gRec)];
+
+ DecodeView() {
+ SkFILEStream stream("/skimages/index.png");
+ SkImageDecoder* codec = SkImageDecoder::Factory(&stream);
+ if (codec) {
+ for (size_t i = 0; i < SK_ARRAY_COUNT(gRec); i++) {
+ stream.rewind();
+ codec->setDitherImage(gRec[i].fDither);
+ codec->decode(&stream, &fBitmap[i], gRec[i].fPrefConfig,
+ SkImageDecoder::kDecodePixels_Mode);
+ }
+ }
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "ImageDecoder");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ void drawBG(SkCanvas* canvas) {
+ canvas->drawColor(0xFFDDDDDD);
+// canvas->drawColor(SK_ColorWHITE);
+ }
+
+ virtual void onDraw(SkCanvas* canvas) {
+ this->drawBG(canvas);
+
+ canvas->translate(SkIntToScalar(10), SkIntToScalar(20));
+
+ for (size_t i = 0; i < SK_ARRAY_COUNT(fBitmap); i++) {
+ canvas->drawBitmap(fBitmap[i], 0, 0);
+ canvas->translate(SkIntToScalar(fBitmap[i].width()), 0);
+ }
+ }
+private:
+ typedef SkView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new DecodeView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleDither.cpp b/samplecode/SampleDither.cpp
new file mode 100644
index 0000000..3e77a5d
--- /dev/null
+++ b/samplecode/SampleDither.cpp
@@ -0,0 +1,178 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkGradientShader.h"
+#include "SkPath.h"
+#include "SkRegion.h"
+#include "SkShader.h"
+#include "SkUtils.h"
+#include "Sk1DPathEffect.h"
+#include "SkCornerPathEffect.h"
+#include "SkPathMeasure.h"
+#include "SkRandom.h"
+#include "SkColorPriv.h"
+#include "SkColorFilter.h"
+#include "SkDither.h"
+
+static void draw_sweep(SkCanvas* c, int width, int height, SkScalar angle) {
+ SkRect r;
+ SkPaint p;
+
+ p.setAntiAlias(true);
+// p.setDither(true);
+ p.setStrokeWidth(SkIntToScalar(width/10));
+ p.setStyle(SkPaint::kStroke_Style);
+
+ r.set(0, 0, SkIntToScalar(width), SkIntToScalar(height));
+
+ // SkColor colors[] = { SK_ColorRED, SK_ColorBLUE, SK_ColorGREEN, SK_ColorCYAN };
+ SkColor colors[] = { 0x4c737373, 0x4c737373, 0xffffd300 };
+ SkShader* s = SkGradientShader::CreateSweep(r.centerX(), r.centerY(),
+ colors, NULL, SK_ARRAY_COUNT(colors));
+ p.setShader(s)->unref();
+
+ SkAutoCanvasRestore acr(c, true);
+
+ c->translate(r.centerX(), r.centerY());
+ c->rotate(angle);
+ c->translate(-r.centerX(), -r.centerY());
+
+ SkRect bounds = r;
+ r.inset(p.getStrokeWidth(), p.getStrokeWidth());
+ SkRect innerBounds = r;
+
+ if (true) {
+ c->drawOval(r, p);
+ } else {
+ SkScalar x = r.centerX();
+ SkScalar y = r.centerY();
+ SkScalar radius = r.width() / 2;
+ SkScalar thickness = p.getStrokeWidth();
+ SkScalar sweep = SkFloatToScalar(360.0f);
+ SkPath path;
+
+ path.moveTo(x + radius, y);
+ // outer top
+ path.lineTo(x + radius + thickness, y);
+ // outer arc
+ path.arcTo(bounds, 0, sweep, false);
+ // inner arc
+ path.arcTo(innerBounds, sweep, -sweep, false);
+ path.close();
+ }
+}
+
+static void make_bm(SkBitmap* bm) {
+ bm->setConfig(SkBitmap::kARGB_8888_Config, 100, 100);
+ bm->allocPixels();
+#if 0
+ bm->eraseColor(SK_ColorBLUE);
+ return;
+#else
+ bm->eraseColor(0);
+#endif
+
+ SkCanvas c(*bm);
+ draw_sweep(&c, bm->width(), bm->height(), 0);
+}
+
+static void pre_dither(const SkBitmap& bm) {
+ SkAutoLockPixels alp(bm);
+
+ for (int y = 0; y < bm.height(); y++) {
+ DITHER_4444_SCAN(y);
+
+ SkPMColor* p = bm.getAddr32(0, y);
+ for (int x = 0; x < bm.width(); x++) {
+ SkPMColor c = *p;
+
+ unsigned a = SkGetPackedA32(c);
+ unsigned r = SkGetPackedR32(c);
+ unsigned g = SkGetPackedG32(c);
+ unsigned b = SkGetPackedB32(c);
+
+ unsigned d = DITHER_VALUE(x);
+
+ a = SkDITHER_A32To4444(a, d);
+ r = SkDITHER_R32To4444(r, d);
+ g = SkDITHER_G32To4444(g, d);
+ b = SkDITHER_B32To4444(b, d);
+
+ a = SkA4444ToA32(a);
+ r = SkR4444ToR32(r);
+ g = SkG4444ToG32(g);
+ b = SkB4444ToB32(b);
+
+ *p++ = SkPackARGB32(a, r, g, b);
+ }
+ }
+}
+
+class DitherView : public SampleView {
+public:
+ SkBitmap fBM, fBMPreDither, fBM16;
+ SkScalar fAngle;
+
+ DitherView() {
+ make_bm(&fBM);
+ make_bm(&fBMPreDither);
+ pre_dither(fBMPreDither);
+ fBM.copyTo(&fBM16, SkBitmap::kARGB_4444_Config);
+
+ fAngle = 0;
+
+ this->setBGColor(0xFF181818);
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "Dither");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ SkPaint paint;
+ SkScalar x = SkIntToScalar(10);
+ SkScalar y = SkIntToScalar(10);
+ const SkScalar DX = SkIntToScalar(fBM.width() + 10);
+
+ paint.setAntiAlias(true);
+
+ if (true) {
+ canvas->drawBitmap(fBM, x, y, &paint);
+ x += DX;
+ paint.setDither(true);
+ canvas->drawBitmap(fBM, x, y, &paint);
+
+ x += DX;
+ paint.setDither(false);
+ canvas->drawBitmap(fBMPreDither, x, y, &paint);
+
+ x += DX;
+ canvas->drawBitmap(fBM16, x, y, &paint);
+ }
+
+ canvas->translate(DX, DX*2);
+ draw_sweep(canvas, fBM.width(), fBM.height(), fAngle);
+ canvas->translate(DX, 0);
+ draw_sweep(canvas, fBM.width()>>1, fBM.height()>>1, fAngle);
+ canvas->translate(DX, 0);
+ draw_sweep(canvas, fBM.width()>>2, fBM.height()>>2, fAngle);
+
+ fAngle += SK_Scalar1/2;
+ this->inval(NULL);
+ }
+
+private:
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new DitherView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleDitherBitmap.cpp b/samplecode/SampleDitherBitmap.cpp
new file mode 100644
index 0000000..0d62446
--- /dev/null
+++ b/samplecode/SampleDitherBitmap.cpp
@@ -0,0 +1,141 @@
+#include "SampleCode.h"
+#include "SkColorPriv.h"
+#include "SkGradientShader.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkUtils.h"
+
+static void draw_rect(SkCanvas* canvas, const SkRect& r, const SkPaint& p) {
+ canvas->drawRect(r, p);
+
+ SkPaint frame(p);
+ frame.setShader(NULL);
+ frame.setStyle(SkPaint::kStroke_Style);
+ canvas->drawRect(r, frame);
+}
+
+static void draw_gradient(SkCanvas* canvas) {
+ SkRect r = { 0, 0, SkIntToScalar(256), SkIntToScalar(32) };
+ SkPoint pts[] = { { r.fLeft, r.fTop }, { r.fRight, r.fTop } };
+ SkColor colors[] = { 0xFF000000, 0xFFFF0000 };
+ SkShader* s = SkGradientShader::CreateLinear(pts, colors, NULL, 2,
+ SkShader::kClamp_TileMode);
+
+ SkPaint p;
+ p.setShader(s)->unref();
+ draw_rect(canvas, r, p);
+
+ canvas->translate(0, SkIntToScalar(40));
+ p.setDither(true);
+ draw_rect(canvas, r, p);
+}
+
+static void test_pathregion() {
+ SkPath path;
+ SkRegion region;
+ path.moveTo(25071800.f, -141823808.f);
+ path.lineTo(25075500.f, -141824000.f);
+ path.lineTo(25075400.f, -141827712.f);
+ path.lineTo(25071810.f, -141827600.f);
+ path.close();
+
+ SkIRect bounds;
+ path.getBounds().round(&bounds);
+ SkRegion clip(bounds);
+ bool result = region.setPath(path, clip); // <-- !! DOWN !!
+ SkDebugf("----- result %d\n", result);
+}
+
+static SkBitmap make_bitmap() {
+ SkBitmap bm;
+ SkColorTable* ctable = new SkColorTable(256);
+
+ SkPMColor* c = ctable->lockColors();
+ for (int i = 0; i < 256; i++) {
+ c[i] = SkPackARGB32(0xFF, i, 0, 0);
+ }
+ ctable->unlockColors(true);
+ bm.setConfig(SkBitmap::kIndex8_Config, 256, 32);
+ bm.allocPixels(ctable);
+ ctable->unref();
+
+ bm.lockPixels();
+ for (int y = 0; y < bm.height(); y++) {
+ uint8_t* p = bm.getAddr8(0, y);
+ for (int x = 0; x < 256; x++) {
+ p[x] = x;
+ }
+ }
+ bm.unlockPixels();
+ return bm;
+}
+
+class DitherBitmapView : public SampleView {
+ SkBitmap fBM8;
+ SkBitmap fBM32;
+public:
+ DitherBitmapView() {
+ test_pathregion();
+ fBM8 = make_bitmap();
+ fBM8.copyTo(&fBM32, SkBitmap::kARGB_8888_Config);
+
+ this->setBGColor(0xFFDDDDDD);
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "DitherBitmap");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ static void setBitmapOpaque(SkBitmap* bm, bool isOpaque) {
+ SkAutoLockPixels alp(*bm); // needed for ctable
+ bm->setIsOpaque(isOpaque);
+ SkColorTable* ctable = bm->getColorTable();
+ if (ctable) {
+ ctable->setIsOpaque(isOpaque);
+ }
+ }
+
+ static void draw2(SkCanvas* canvas, const SkBitmap& bm) {
+ SkPaint paint;
+ SkBitmap bitmap(bm);
+
+ setBitmapOpaque(&bitmap, false);
+ paint.setDither(false);
+ canvas->drawBitmap(bitmap, 0, 0, &paint);
+ paint.setDither(true);
+ canvas->drawBitmap(bitmap, 0, SkIntToScalar(bm.height() + 10), &paint);
+
+ setBitmapOpaque(&bitmap, true);
+ SkScalar x = SkIntToScalar(bm.width() + 10);
+ paint.setDither(false);
+ canvas->drawBitmap(bitmap, x, 0, &paint);
+ paint.setDither(true);
+ canvas->drawBitmap(bitmap, x, SkIntToScalar(bm.height() + 10), &paint);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ canvas->translate(SkIntToScalar(20), SkIntToScalar(20));
+
+ draw2(canvas, fBM8);
+ canvas->translate(0, SkIntToScalar(fBM8.height() *3));
+ draw2(canvas, fBM32);
+
+ canvas->translate(0, SkIntToScalar(fBM8.height() *3));
+ draw_gradient(canvas);
+ }
+
+private:
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new DitherBitmapView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleDraw.cpp b/samplecode/SampleDraw.cpp
new file mode 100644
index 0000000..deb1fb2
--- /dev/null
+++ b/samplecode/SampleDraw.cpp
@@ -0,0 +1,373 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkGraphics.h"
+#include "SkRandom.h"
+
+static void test_clearonlayers(SkCanvas* canvas) {
+ SkCanvas& c = *canvas;
+
+ SkPaint paint;
+ paint.setColor(SK_ColorBLUE);
+ paint.setStyle(SkPaint::kStrokeAndFill_Style);
+ SkRect rect = SkRect::MakeXYWH(25, 25, 50, 50);
+ c.drawRect(rect, paint);
+
+ c.clipRect(rect);
+
+ c.saveLayer(NULL, NULL);
+ rect = SkRect::MakeXYWH(50, 10, 40, 80);
+ c.clipRect(rect, SkRegion::kUnion_Op);
+
+ rect = SkRect::MakeXYWH(50, 0, 50, 100);
+ // You might draw something here, but it's not necessary.
+ // paint.setColor(SK_ColorRED);
+ // c.drawRect(rect, paint);
+ paint.setXfermodeMode(SkXfermode::kClear_Mode);
+ c.drawRect(rect, paint);
+ c.restore();
+}
+
+static void test_strokerect(SkCanvas* canvas, const SkRect& r) {
+ SkPaint p;
+
+ p.setAntiAlias(true);
+ p.setStyle(SkPaint::kStroke_Style);
+ p.setStrokeWidth(4);
+
+ canvas->drawRect(r, p);
+
+ SkPath path;
+ SkRect r2(r);
+ r2.offset(18, 0);
+ path.addRect(r2);
+
+ canvas->drawPath(path, p);
+}
+
+static void test_strokerect(SkCanvas* canvas) {
+ canvas->drawColor(SK_ColorWHITE);
+
+ SkRect r;
+
+ r.set(10, 10, 14, 14);
+ r.offset(0.25f, 0.3333f);
+ test_strokerect(canvas, r);
+ canvas->translate(0, 20);
+
+ r.set(10, 10, 14.5f, 14.5f);
+ r.offset(0.25f, 0.3333f);
+ test_strokerect(canvas, r);
+ canvas->translate(0, 20);
+
+ r.set(10, 10, 14.5f, 20);
+ r.offset(0.25f, 0.3333f);
+ test_strokerect(canvas, r);
+ canvas->translate(0, 20);
+
+ r.set(10, 10, 20, 14.5f);
+ r.offset(0.25f, 0.3333f);
+ test_strokerect(canvas, r);
+ canvas->translate(0, 20);
+
+ r.set(10, 10, 20, 20);
+ r.offset(0.25f, 0.3333f);
+ test_strokerect(canvas, r);
+ canvas->translate(0, 20);
+
+}
+
+class Draw : public SkRefCnt {
+public:
+ Draw() : fFlags(0) {}
+
+ enum Flags {
+ kSelected_Flag = 1 << 0
+ };
+ int getFlags() const { return fFlags; }
+ void setFlags(int flags);
+
+ bool isSelected() const { return SkToBool(fFlags & kSelected_Flag); }
+ void setSelected(bool pred) {
+ if (pred) {
+ fFlags |= kSelected_Flag;
+ } else {
+ fFlags &= ~kSelected_Flag;
+ }
+ }
+
+ void draw(SkCanvas* canvas) {
+ int sc = canvas->save();
+ this->onDraw(canvas);
+ canvas->restoreToCount(sc);
+
+ if (this->isSelected()) {
+ this->drawSelection(canvas);
+ }
+ }
+
+ void drawSelection(SkCanvas* canvas) {
+ int sc = canvas->save();
+ this->onDrawSelection(canvas);
+ canvas->restoreToCount(sc);
+ }
+
+ void getBounds(SkRect* bounds) {
+ this->onGetBounds(bounds);
+ }
+
+ bool hitTest(SkScalar x, SkScalar y) {
+ return this->onHitTest(x, y);
+ }
+
+ void offset(SkScalar dx, SkScalar dy) {
+ if (dx || dy) {
+ this->onOffset(dx, dy);
+ }
+ }
+
+protected:
+ virtual void onDraw(SkCanvas*) = 0;
+ virtual void onGetBounds(SkRect*) = 0;
+ virtual void onOffset(SkScalar dx, SkScalar dy) = 0;
+ virtual void onDrawSelection(SkCanvas* canvas) {
+ SkRect r;
+ this->getBounds(&r);
+ SkPaint paint;
+ SkPoint pts[4];
+ r.toQuad(pts);
+ paint.setStrokeWidth(SkIntToScalar(10));
+ paint.setColor(0x80FF8844);
+ paint.setStrokeCap(SkPaint::kRound_Cap);
+ canvas->drawPoints(SkCanvas::kPoints_PointMode, 4, pts, paint);
+ }
+ virtual bool onHitTest(SkScalar x, SkScalar y) {
+ SkRect bounds;
+ this->getBounds(&bounds);
+ return bounds.contains(x, y);
+ }
+
+private:
+ int fFlags;
+};
+
+class RDraw : public Draw {
+public:
+ enum Style {
+ kRect_Style,
+ kOval_Style,
+ kRRect_Style,
+ kFrame_Style
+ };
+
+ RDraw(const SkRect& r, Style s) : fRect(r), fStyle(s) {}
+
+ void setRect(const SkRect& r) {
+ fRect = r;
+ }
+
+ void setPaint(const SkPaint& p) {
+ fPaint = p;
+ }
+
+protected:
+ virtual void onDraw(SkCanvas* canvas) {
+ switch (fStyle) {
+ case kRect_Style:
+ canvas->drawRect(fRect, fPaint);
+ break;
+ case kOval_Style:
+ canvas->drawOval(fRect, fPaint);
+ break;
+ case kRRect_Style: {
+ SkScalar rx = fRect.width() / 5;
+ SkScalar ry = fRect.height() / 5;
+ if (rx < ry) {
+ ry = rx;
+ } else {
+ rx = ry;
+ }
+ canvas->drawRoundRect(fRect, rx, ry, fPaint);
+ break;
+ }
+ case kFrame_Style: {
+ SkPath path;
+ path.addOval(fRect, SkPath::kCW_Direction);
+ SkRect r = fRect;
+ r.inset(fRect.width()/6, 0);
+ path.addOval(r, SkPath::kCCW_Direction);
+ canvas->drawPath(path, fPaint);
+ break;
+ }
+ }
+ }
+
+ virtual void onGetBounds(SkRect* bounds) {
+ *bounds = fRect;
+ }
+
+ virtual void onOffset(SkScalar dx, SkScalar dy) {
+ fRect.offset(dx, dy);
+ }
+
+private:
+ SkRect fRect;
+ SkPaint fPaint;
+ Style fStyle;
+};
+
+class DrawFactory {
+public:
+ DrawFactory() {
+ fPaint.setAntiAlias(true);
+ }
+
+ const SkPaint& getPaint() const { return fPaint; }
+
+ void setPaint(const SkPaint& p) {
+ fPaint = p;
+ }
+
+ virtual Draw* create(const SkPoint&, const SkPoint&) = 0;
+
+private:
+ SkPaint fPaint;
+};
+
+class RectFactory : public DrawFactory {
+public:
+ virtual Draw* create(const SkPoint& p0, const SkPoint& p1) {
+ SkRect r;
+ r.set(p0.x(), p0.y(), p1.x(), p1.y());
+ r.sort();
+
+// RDraw* d = new RDraw(r, RDraw::kRRect_Style);
+ RDraw* d = new RDraw(r, RDraw::kFrame_Style);
+ d->setPaint(this->getPaint());
+ return d;
+ }
+};
+
+class DrawView : public SkView {
+ Draw* fDraw;
+ DrawFactory* fFactory;
+ SkRandom fRand;
+ SkTDArray<Draw*> fList;
+
+public:
+ DrawView() : fDraw(NULL) {
+ fFactory = new RectFactory;
+ }
+
+ virtual ~DrawView() {
+ fList.unrefAll();
+ SkSafeUnref(fDraw);
+ delete fFactory;
+ }
+
+ Draw* setDraw(Draw* d) {
+ SkRefCnt_SafeAssign(fDraw, d);
+ return d;
+ }
+
+ SkColor randColor() {
+ return (SkColor)fRand.nextU() | 0xFF000000;
+ }
+
+ Draw* hitTestList(SkScalar x, SkScalar y) const {
+ Draw** first = fList.begin();
+ for (Draw** iter = fList.end(); iter > first;) {
+ --iter;
+ if ((*iter)->hitTest(x, y)) {
+ return *iter;
+ }
+ }
+ return NULL;
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "Draw");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ void drawBG(SkCanvas* canvas) {
+ canvas->drawColor(0xFFDDDDDD);
+// canvas->drawColor(SK_ColorWHITE);
+ }
+
+ virtual void onDraw(SkCanvas* canvas) {
+ this->drawBG(canvas);
+ test_clearonlayers(canvas); return;
+ // test_strokerect(canvas); return;
+
+ for (Draw** iter = fList.begin(); iter < fList.end(); iter++) {
+ (*iter)->draw(canvas);
+ }
+ if (fDraw) {
+ fDraw->draw(canvas);
+ }
+ }
+
+ virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
+ for (Draw** iter = fList.begin(); iter < fList.end(); iter++) {
+ (*iter)->setSelected(false);
+ }
+
+ Click* c = new Click(this);
+ Draw* d = this->hitTestList(x, y);
+ if (d) {
+ d->setSelected(true);
+ c->setType("dragger");
+ } else {
+ c->setType("maker");
+ }
+ return c;
+ }
+
+ virtual bool onClick(Click* click) {
+ if (Click::kUp_State == click->fState) {
+ if (click->isType("maker")) {
+ if (SkPoint::Distance(click->fOrig, click->fCurr) > SkIntToScalar(3)) {
+ *fList.append() = fDraw;
+ } else {
+ fDraw->unref();
+ }
+ fDraw = NULL;
+ }
+ return true;
+ }
+
+ if (Click::kDown_State == click->fState) {
+ SkPaint p = fFactory->getPaint();
+ p.setColor(this->randColor());
+ fFactory->setPaint(p);
+ }
+
+ if (click->isType("maker")) {
+ this->setDraw(fFactory->create(click->fOrig, click->fCurr))->unref();
+ } else if (click->isType("dragger")) {
+ for (Draw** iter = fList.begin(); iter < fList.end(); iter++) {
+ if ((*iter)->isSelected()) {
+ (*iter)->offset(click->fCurr.x() - click->fPrev.x(),
+ click->fCurr.y() - click->fPrev.y());
+ }
+ }
+ }
+ this->inval(NULL);
+ return true;
+ }
+
+private:
+ typedef SkView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new DrawView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleDrawLooper.cpp b/samplecode/SampleDrawLooper.cpp
new file mode 100644
index 0000000..30879f7
--- /dev/null
+++ b/samplecode/SampleDrawLooper.cpp
@@ -0,0 +1,92 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkGraphics.h"
+#include "SkRandom.h"
+#include "SkLayerDrawLooper.h"
+#include "SkBlurMaskFilter.h"
+
+#define WIDTH 200
+#define HEIGHT 200
+
+class LooperView : public SampleView {
+public:
+
+ SkLayerDrawLooper* fLooper;
+
+ LooperView() {
+ static const struct {
+ SkColor fColor;
+ SkPaint::Style fStyle;
+ SkScalar fWidth;
+ SkScalar fOffset;
+ int fBlur;
+ } gParams[] = {
+ { SK_ColorWHITE, SkPaint::kStroke_Style, SkIntToScalar(1)*3/4, 0, 0 },
+ { SK_ColorRED, SkPaint::kStroke_Style, SkIntToScalar(4), 0, 0 },
+ { SK_ColorBLUE, SkPaint::kFill_Style, 0, 0, 0 },
+ { 0x88000000, SkPaint::kFill_Style, 0, SkIntToScalar(10), 3 }
+ };
+
+ fLooper = new SkLayerDrawLooper;
+
+ SkLayerDrawLooper::LayerInfo info;
+ info.fFlagsMask = SkPaint::kAntiAlias_Flag;
+ info.fPaintBits = SkLayerDrawLooper::kStyle_Bit | SkLayerDrawLooper::kMaskFilter_Bit;
+ info.fColorMode = SkXfermode::kSrc_Mode;
+
+ for (size_t i = 0; i < SK_ARRAY_COUNT(gParams); i++) {
+ info.fOffset.set(gParams[i].fOffset, gParams[i].fOffset);
+ SkPaint* paint = fLooper->addLayer(info);
+ paint->setAntiAlias(true);
+ paint->setColor(gParams[i].fColor);
+ paint->setStyle(gParams[i].fStyle);
+ paint->setStrokeWidth(gParams[i].fWidth);
+ if (gParams[i].fBlur > 0) {
+ SkMaskFilter* mf = SkBlurMaskFilter::Create(SkIntToScalar(gParams[i].fBlur),
+ SkBlurMaskFilter::kNormal_BlurStyle);
+ paint->setMaskFilter(mf)->unref();
+ }
+ }
+
+ this->setBGColor(0xFFDDDDDD);
+ }
+
+ virtual ~LooperView() {
+ SkSafeUnref(fLooper);
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "DrawLooper");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ SkPaint paint;
+ paint.setTextSize(SkIntToScalar(72));
+ paint.setLooper(fLooper);
+
+ canvas->drawCircle(SkIntToScalar(50), SkIntToScalar(50),
+ SkIntToScalar(30), paint);
+
+ canvas->drawRectCoords(SkIntToScalar(150), SkIntToScalar(50),
+ SkIntToScalar(200), SkIntToScalar(100), paint);
+
+ canvas->drawText("Looper", 6, SkIntToScalar(230), SkIntToScalar(100),
+ paint);
+ }
+
+private:
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new LooperView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleEffects.cpp b/samplecode/SampleEffects.cpp
new file mode 100644
index 0000000..a63c08d
--- /dev/null
+++ b/samplecode/SampleEffects.cpp
@@ -0,0 +1,130 @@
+#include "SampleCode.h"
+#include "SkCanvas.h"
+#include "SkPaint.h"
+#include "SkView.h"
+
+#include "SkBlurMaskFilter.h"
+#include "SkColorMatrixFilter.h"
+#include "SkDiscretePathEffect.h"
+#include "SkGradientShader.h"
+
+#include "SkEdgeClipper.h"
+
+static void test_edgeclipper() {
+ SkPoint pts[] = {
+ { -8.38822452e+21f, -7.69721471e+19f },
+ { 1.57645875e+23f, 1.44634003e+21f },
+ { 1.61519691e+23f, 1.48208059e+21f },
+ { 3.13963584e+23f, 2.88057438e+21f }
+ };
+ SkRect clip = { 0, 0, 300, 200 };
+
+ SkEdgeClipper clipper;
+ clipper.clipCubic(pts, clip);
+}
+
+///////////
+
+//#define COLOR 0xFFFF8844
+#define COLOR 0xFF888888
+
+static void paint_proc0(SkPaint* paint) {
+}
+
+static void paint_proc1(SkPaint* paint) {
+ paint->setMaskFilter(SkBlurMaskFilter::Create(2,
+ SkBlurMaskFilter::kNormal_BlurStyle))->unref();
+}
+
+static void paint_proc2(SkPaint* paint) {
+ SkScalar dir[3] = { 1, 1, 1};
+ paint->setMaskFilter(
+ SkBlurMaskFilter::CreateEmboss(dir, 0.1f, 0.05f, 1))->unref();
+}
+
+static void paint_proc3(SkPaint* paint) {
+ SkColor colors[] = { SK_ColorRED, COLOR, SK_ColorBLUE };
+ SkPoint pts[] = { { 3, 0 }, { 7, 5 } };
+ paint->setShader(SkGradientShader::CreateLinear(pts, colors, NULL, SK_ARRAY_COUNT(colors),
+ SkShader::kMirror_TileMode))->unref();
+}
+
+static void paint_proc5(SkPaint* paint) {
+ paint_proc3(paint);
+ paint_proc2(paint);
+}
+
+typedef void (*PaintProc)(SkPaint*);
+const PaintProc gPaintProcs[] = {
+ paint_proc0,
+ paint_proc1,
+ paint_proc2,
+ paint_proc3,
+ paint_proc5,
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+class EffectsView : public SampleView {
+public:
+ SkPath fPath;
+ SkPaint fPaint[SK_ARRAY_COUNT(gPaintProcs)];
+
+ EffectsView() {
+ size_t i;
+ const float pts[] = {
+ 0, 0,
+ 10, 0,
+ 10, 5,
+ 20, -5,
+ 10, -15,
+ 10, -10,
+ 0, -10
+ };
+ fPath.moveTo(pts[0], pts[1]);
+ for (i = 2; i < SK_ARRAY_COUNT(pts); i += 2) {
+ fPath.lineTo(pts[i], pts[i+1]);
+ }
+
+ for (i = 0; i < SK_ARRAY_COUNT(gPaintProcs); i++) {
+ fPaint[i].setAntiAlias(true);
+ fPaint[i].setColor(COLOR);
+ gPaintProcs[i](&fPaint[i]);
+ }
+
+ test_edgeclipper();
+ SkColorMatrix cm;
+ cm.setRotate(SkColorMatrix::kG_Axis, 180);
+ cm.setIdentity();
+
+ this->setBGColor(0xFFDDDDDD);
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "Effects");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ canvas->scale(3, 3);
+ canvas->translate(10, 30);
+ for (size_t i = 0; i < SK_ARRAY_COUNT(fPaint); i++) {
+ canvas->drawPath(fPath, fPaint[i]);
+ canvas->translate(32, 0);
+ }
+ }
+
+private:
+ typedef SampleView INHERITED;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new EffectsView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleEmboss.cpp b/samplecode/SampleEmboss.cpp
new file mode 100644
index 0000000..8b3f194
--- /dev/null
+++ b/samplecode/SampleEmboss.cpp
@@ -0,0 +1,66 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "Sk64.h"
+#include "SkColorShader.h"
+#include "SkEmbossMaskFilter.h"
+#include "SkGradientShader.h"
+#include "SkGraphics.h"
+#include "SkImageDecoder.h"
+#include "SkKernel33MaskFilter.h"
+#include "SkPath.h"
+#include "SkRandom.h"
+#include "SkRegion.h"
+#include "SkShader.h"
+#include "SkUtils.h"
+#include "SkColorPriv.h"
+#include "SkColorFilter.h"
+#include "SkTime.h"
+#include "SkTypeface.h"
+#include "SkXfermode.h"
+
+class EmbossView : public SampleView {
+ SkEmbossMaskFilter::Light fLight;
+public:
+ EmbossView() {
+ fLight.fDirection[0] = SK_Scalar1;
+ fLight.fDirection[1] = SK_Scalar1;
+ fLight.fDirection[2] = SK_Scalar1;
+ fLight.fAmbient = 128;
+ fLight.fSpecular = 16*2;
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "Emboss");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ SkPaint paint;
+
+ paint.setAntiAlias(true);
+ paint.setStyle(SkPaint::kStroke_Style);
+ paint.setStrokeWidth(SkIntToScalar(10));
+ paint.setMaskFilter(new SkEmbossMaskFilter(fLight, SkIntToScalar(4)))->unref();
+ paint.setShader(new SkColorShader(SK_ColorBLUE))->unref();
+ paint.setDither(true);
+
+ canvas->drawCircle(SkIntToScalar(50), SkIntToScalar(50),
+ SkIntToScalar(30), paint);
+ }
+
+private:
+
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new EmbossView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleEncode.cpp b/samplecode/SampleEncode.cpp
new file mode 100644
index 0000000..f4ea195
--- /dev/null
+++ b/samplecode/SampleEncode.cpp
@@ -0,0 +1,224 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkGradientShader.h"
+#include "SkGraphics.h"
+#include "SkImageDecoder.h"
+#include "SkImageEncoder.h"
+#include "SkPath.h"
+#include "SkRegion.h"
+#include "SkShader.h"
+#include "SkUtils.h"
+#include "SkXfermode.h"
+#include "SkColorPriv.h"
+#include "SkColorFilter.h"
+#include "SkTime.h"
+#include "SkTypeface.h"
+
+#include "SkStream.h"
+
+static void make_image(SkBitmap* bm, SkBitmap::Config config, int configIndex) {
+ const int width = 98;
+ const int height = 100;
+ SkBitmap device;
+
+ device.setConfig(SkBitmap::kARGB_8888_Config, width, height);
+ device.allocPixels();
+
+ SkCanvas canvas(device);
+ SkPaint paint;
+
+ paint.setAntiAlias(true);
+ canvas.drawColor(SK_ColorRED);
+ paint.setColor(SK_ColorBLUE);
+ canvas.drawCircle(SkIntToScalar(width)/2, SkIntToScalar(height)/2,
+ SkIntToScalar(width)/2, paint);
+
+ bm->setConfig(config, width, height);
+ switch (config) {
+ case SkBitmap::kARGB_8888_Config:
+ bm->swap(device);
+ break;
+ case SkBitmap::kRGB_565_Config: {
+ bm->allocPixels();
+ for (int y = 0; y < height; y++) {
+ for (int x = 0; x < width; x++) {
+ *bm->getAddr16(x, y) = SkPixel32ToPixel16(*device.getAddr32(x, y));
+ }
+ }
+ break;
+ }
+ case SkBitmap::kIndex8_Config: {
+ SkPMColor colors[256];
+ for (int i = 0; i < 256; i++) {
+ if (configIndex & 1) {
+ colors[i] = SkPackARGB32(255-i, 0, 0, 255-i);
+ } else {
+ colors[i] = SkPackARGB32(0xFF, i, 0, 255-i);
+ }
+ }
+ SkColorTable* ctable = new SkColorTable(colors, 256);
+ bm->allocPixels(ctable);
+ ctable->unref();
+
+ for (int y = 0; y < height; y++) {
+ for (int x = 0; x < width; x++) {
+ *bm->getAddr8(x, y) = SkGetPackedR32(*device.getAddr32(x, y));
+ }
+ }
+ break;
+ }
+ default:
+ break;
+ }
+}
+
+// configs to build the original bitmap in. Can be at most these 3
+static const SkBitmap::Config gConfigs[] = {
+ SkBitmap::kARGB_8888_Config,
+ SkBitmap::kRGB_565_Config,
+ SkBitmap::kIndex8_Config, // opaque
+ SkBitmap::kIndex8_Config // alpha
+};
+
+static const char* const gConfigLabels[] = {
+ "8888", "565", "Index8", "Index8 alpha"
+};
+
+// types to encode into. Can be at most these 3. Must match up with gExt[]
+static const SkImageEncoder::Type gTypes[] = {
+ SkImageEncoder::kJPEG_Type,
+ SkImageEncoder::kPNG_Type
+};
+
+// must match up with gTypes[]
+static const char* const gExt[] = {
+ ".jpg", ".png"
+};
+
+static const char* gPath = "/encoded/";
+
+static void make_name(SkString* name, int config, int ext) {
+ name->set(gPath);
+ name->append(gConfigLabels[config]);
+ name->append(gExt[ext]);
+}
+
+#include <sys/stat.h>
+
+class EncodeView : public SampleView {
+public:
+ SkBitmap* fBitmaps;
+ size_t fBitmapCount;
+
+ EncodeView() {
+ #if 1
+ (void)mkdir(gPath, S_IRWXU | S_IRWXG | S_IRWXO);
+
+ fBitmapCount = SK_ARRAY_COUNT(gConfigs);
+ fBitmaps = new SkBitmap[fBitmapCount];
+ for (size_t i = 0; i < fBitmapCount; i++) {
+ make_image(&fBitmaps[i], gConfigs[i], i);
+
+ for (size_t j = 0; j < SK_ARRAY_COUNT(gExt); j++) {
+ SkString path;
+ make_name(&path, i, j);
+
+ // remove any previous run of this file
+ remove(path.c_str());
+
+ SkImageEncoder* codec = SkImageEncoder::Create(gTypes[j]);
+ if (NULL == codec ||
+ !codec->encodeFile(path.c_str(), fBitmaps[i], 100)) {
+ SkDebugf("------ failed to encode %s\n", path.c_str());
+ remove(path.c_str()); // remove any partial file
+ }
+ delete codec;
+ }
+ }
+ #else
+ fBitmaps = NULL;
+ fBitmapCount = 0;
+ #endif
+ this->setBGColor(0xFFDDDDDD);
+ }
+
+ virtual ~EncodeView() {
+ delete[] fBitmaps;
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "ImageEncoder");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ if (fBitmapCount == 0) {
+ return;
+ }
+
+ SkPaint paint;
+ paint.setAntiAlias(true);
+ paint.setTextAlign(SkPaint::kCenter_Align);
+
+ canvas->translate(SkIntToScalar(10), SkIntToScalar(20));
+
+ SkScalar x = 0, y = 0, maxX = 0;
+ const int SPACER = 10;
+
+ for (size_t i = 0; i < fBitmapCount; i++) {
+ canvas->drawText(gConfigLabels[i], strlen(gConfigLabels[i]),
+ x + SkIntToScalar(fBitmaps[i].width()) / 2, 0,
+ paint);
+ y = paint.getTextSize();
+
+ canvas->drawBitmap(fBitmaps[i], x, y);
+
+ SkScalar yy = y;
+ for (size_t j = 0; j < SK_ARRAY_COUNT(gExt); j++) {
+ yy += SkIntToScalar(fBitmaps[i].height() + 10);
+
+ SkBitmap bm;
+ SkString name;
+
+ make_name(&name, i, j);
+
+ SkImageDecoder::DecodeFile(name.c_str(), &bm);
+ canvas->drawBitmap(bm, x, yy);
+ }
+
+ x += SkIntToScalar(fBitmaps[i].width() + SPACER);
+ if (x > maxX) {
+ maxX = x;
+ }
+ }
+
+ y = (paint.getTextSize() + SkIntToScalar(fBitmaps[0].height())) * 3 / 2;
+ x = maxX + SkIntToScalar(10);
+ paint.setTextAlign(SkPaint::kLeft_Align);
+
+ for (size_t j = 0; j < SK_ARRAY_COUNT(gExt); j++) {
+ canvas->drawText(gExt[j], strlen(gExt[j]), x, y, paint);
+ y += SkIntToScalar(fBitmaps[0].height() + SPACER);
+ }
+ }
+
+ virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
+ this->inval(NULL);
+ return this->INHERITED::onFindClickHandler(x, y);
+ }
+
+private:
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new EncodeView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleExtractAlpha.cpp b/samplecode/SampleExtractAlpha.cpp
new file mode 100644
index 0000000..860272d
--- /dev/null
+++ b/samplecode/SampleExtractAlpha.cpp
@@ -0,0 +1,90 @@
+#include "SampleCode.h"
+#include "SkColorPriv.h"
+#include "SkGradientShader.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkUtils.h"
+
+static SkBitmap make_bitmap() {
+ SkBitmap bm;
+ SkColorTable* ctable = new SkColorTable(256);
+
+ SkPMColor* c = ctable->lockColors();
+ for (int i = 0; i < 256; i++) {
+ c[i] = SkPackARGB32(255 - i, 0, 0, 0);
+ }
+ ctable->unlockColors(true);
+ bm.setConfig(SkBitmap::kIndex8_Config, 256, 256);
+ bm.allocPixels(ctable);
+ ctable->unref();
+
+ bm.lockPixels();
+ const float cx = bm.width() * 0.5f;
+ const float cy = bm.height() * 0.5f;
+ for (int y = 0; y < bm.height(); y++) {
+ float dy = y - cy;
+ dy *= dy;
+ uint8_t* p = bm.getAddr8(0, y);
+ for (int x = 0; x < 256; x++) {
+ float dx = x - cx;
+ dx *= dx;
+ float d = (dx + dy) / (cx/2);
+ int id = (int)d;
+ if (id > 255) {
+ id = 255;
+ }
+ p[x] = id;
+ }
+ }
+ bm.unlockPixels();
+ return bm;
+}
+
+class ExtractAlphaView : public SampleView {
+ SkBitmap fBM8;
+ SkBitmap fBM32;
+ SkBitmap fBM4;
+public:
+ ExtractAlphaView() {
+ fBM8 = make_bitmap();
+ fBM8.copyTo(&fBM32, SkBitmap::kARGB_8888_Config);
+ fBM8.copyTo(&fBM4, SkBitmap::kARGB_4444_Config);
+
+ this->setBGColor(0xFFDDDDDD);
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "DitherBitmap");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ SkPaint paint;
+ paint.setAntiAlias(true);
+ paint.setStyle(SkPaint::kStroke_Style);
+
+ SkMatrix matrix;
+ matrix.setScale(3.55f, 80.f);
+ canvas->setMatrix(matrix);
+
+ paint.setStrokeWidth(0.0588f);
+ canvas->drawLine(10, 5, 30, 4.8f, paint);
+
+ paint.setStrokeWidth(0.06f);
+ canvas->drawLine(20, 5, 40, 4.8f, paint);
+ }
+
+private:
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new ExtractAlphaView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleFillType.cpp b/samplecode/SampleFillType.cpp
new file mode 100644
index 0000000..393c5f7
--- /dev/null
+++ b/samplecode/SampleFillType.cpp
@@ -0,0 +1,90 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkCornerPathEffect.h"
+#include "SkCullPoints.h"
+#include "SkGradientShader.h"
+#include "SkPath.h"
+#include "SkRegion.h"
+#include "SkShader.h"
+#include "SkUtils.h"
+
+class FillTypeView : public SampleView {
+ SkPath fPath;
+public:
+ FillTypeView() {
+ const SkScalar radius = SkIntToScalar(45);
+ fPath.addCircle(SkIntToScalar(50), SkIntToScalar(50), radius);
+ fPath.addCircle(SkIntToScalar(100), SkIntToScalar(100), radius);
+
+ this->setBGColor(0xFFDDDDDD);
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "FillType");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ void showPath(SkCanvas* canvas, int x, int y, SkPath::FillType ft,
+ SkScalar scale, const SkPaint& paint) {
+
+ const SkRect r = { 0, 0, SkIntToScalar(150), SkIntToScalar(150) };
+
+ canvas->save();
+ canvas->translate(SkIntToScalar(x), SkIntToScalar(y));
+ canvas->clipRect(r);
+ canvas->drawColor(SK_ColorWHITE);
+ fPath.setFillType(ft);
+ canvas->translate(r.centerX(), r.centerY());
+ canvas->scale(scale, scale);
+ canvas->translate(-r.centerX(), -r.centerY());
+ canvas->drawPath(fPath, paint);
+ canvas->restore();
+ }
+
+ void showFour(SkCanvas* canvas, SkScalar scale, const SkPaint& paint) {
+ showPath(canvas, 0, 0, SkPath::kWinding_FillType,
+ scale, paint);
+ showPath(canvas, 200, 0, SkPath::kEvenOdd_FillType,
+ scale, paint);
+ showPath(canvas, 00, 200, SkPath::kInverseWinding_FillType,
+ scale, paint);
+ showPath(canvas, 200, 200, SkPath::kInverseEvenOdd_FillType,
+ scale, paint);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ canvas->translate(SkIntToScalar(20), SkIntToScalar(20));
+
+ SkPaint paint;
+ const SkScalar scale = SkIntToScalar(5)/4;
+
+ paint.setAntiAlias(false);
+ paint.setColor(0x8000FF00);
+
+ showFour(canvas, SK_Scalar1, paint);
+ canvas->translate(SkIntToScalar(450), 0);
+ showFour(canvas, scale, paint);
+
+ paint.setAntiAlias(true);
+
+ canvas->translate(SkIntToScalar(-450), SkIntToScalar(450));
+ showFour(canvas, SK_Scalar1, paint);
+ canvas->translate(SkIntToScalar(450), 0);
+ showFour(canvas, scale, paint);
+ }
+
+private:
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new FillTypeView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleFilter.cpp b/samplecode/SampleFilter.cpp
new file mode 100644
index 0000000..a9089fa
--- /dev/null
+++ b/samplecode/SampleFilter.cpp
@@ -0,0 +1,138 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkGradientShader.h"
+#include "SkPath.h"
+#include "SkRegion.h"
+#include "SkShader.h"
+#include "SkUtils.h"
+#include "Sk1DPathEffect.h"
+#include "SkCornerPathEffect.h"
+#include "SkPathMeasure.h"
+#include "SkRandom.h"
+#include "SkColorPriv.h"
+#include "SkColorFilter.h"
+#include "SkDither.h"
+
+static void make_bm(SkBitmap* bm) {
+ const SkColor colors[] = {
+ SK_ColorRED, SK_ColorGREEN,
+ SK_ColorBLUE, SK_ColorWHITE
+ };
+ SkColorTable* ctable = new SkColorTable(colors, 4);
+ bm->setConfig(SkBitmap::kIndex8_Config, 2, 2);
+ bm->allocPixels(ctable);
+ ctable->unref();
+
+ *bm->getAddr8(0, 0) = 0;
+ *bm->getAddr8(1, 0) = 1;
+ *bm->getAddr8(0, 1) = 2;
+ *bm->getAddr8(1, 1) = 3;
+}
+
+static SkScalar draw_bm(SkCanvas* canvas, const SkBitmap& bm,
+ SkScalar x, SkScalar y, SkPaint* paint) {
+#if 1
+ canvas->drawBitmap(bm, x, y, paint);
+ return SkIntToScalar(bm.width()) * 5/4;
+#else
+ SkAutoCanvasRestore acr(canvas, true);
+ canvas->translate(x, y);
+
+ SkScalar w = SkIntToScalar(bm.width());
+ SkScalar h = SkIntToScalar(bm.height());
+ SkShader* s = SkShader::CreateBitmapShader(bm, SkShader::kRepeat_TileMode,
+ SkShader::kRepeat_TileMode);
+ paint->setShader(s)->unref();
+ canvas->drawRect(SkRect::MakeWH(w, h), *paint);
+ paint->setShader(NULL);
+ return w * 5/4;
+#endif
+}
+
+static SkScalar draw_set(SkCanvas* c, const SkBitmap& bm, SkScalar x, SkPaint* p) {
+ x += draw_bm(c, bm, x, 0, p);
+ p->setFilterBitmap(true);
+ x += draw_bm(c, bm, x, 0, p);
+ p->setDither(true);
+ return x + draw_bm(c, bm, x, 0, p);
+}
+
+static const char* gConfigNames[] = {
+ "unknown config",
+ "A1",
+ "A8",
+ "Index8",
+ "565",
+ "4444",
+ "8888"
+};
+
+static SkScalar draw_row(SkCanvas* canvas, const SkBitmap& bm) {
+ SkAutoCanvasRestore acr(canvas, true);
+
+ SkPaint paint;
+ SkScalar x = 0;
+ const int scale = 32;
+
+ paint.setAntiAlias(true);
+ const char* name = gConfigNames[bm.config()];
+ canvas->drawText(name, strlen(name), x, SkIntToScalar(bm.height())*scale*5/8,
+ paint);
+ canvas->translate(SkIntToScalar(48), 0);
+
+ canvas->scale(SkIntToScalar(scale), SkIntToScalar(scale));
+
+ x += draw_set(canvas, bm, 0, &paint);
+ paint.reset();
+ paint.setAlpha(0x80);
+ draw_set(canvas, bm, x, &paint);
+ return x * scale / 3;
+}
+
+class FilterView : public SampleView {
+public:
+ SkBitmap fBM8, fBM4444, fBM16, fBM32;
+
+ FilterView() {
+ make_bm(&fBM8);
+ fBM8.copyTo(&fBM4444, SkBitmap::kARGB_4444_Config);
+ fBM8.copyTo(&fBM16, SkBitmap::kRGB_565_Config);
+ fBM8.copyTo(&fBM32, SkBitmap::kARGB_8888_Config);
+
+ this->setBGColor(0xFFDDDDDD);
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "Filter");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ SkScalar x = SkIntToScalar(10);
+ SkScalar y = SkIntToScalar(10);
+
+ canvas->translate(x, y);
+ y = draw_row(canvas, fBM8);
+ canvas->translate(0, y);
+ y = draw_row(canvas, fBM4444);
+ canvas->translate(0, y);
+ y = draw_row(canvas, fBM16);
+ canvas->translate(0, y);
+ draw_row(canvas, fBM32);
+ }
+
+private:
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new FilterView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleFilter2.cpp b/samplecode/SampleFilter2.cpp
new file mode 100644
index 0000000..c1a16a8
--- /dev/null
+++ b/samplecode/SampleFilter2.cpp
@@ -0,0 +1,116 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkGradientShader.h"
+#include "SkGraphics.h"
+#include "SkImageDecoder.h"
+#include "SkPath.h"
+#include "SkRegion.h"
+#include "SkShader.h"
+#include "SkUtils.h"
+#include "SkXfermode.h"
+#include "SkColorPriv.h"
+#include "SkColorFilter.h"
+#include "SkTime.h"
+
+static const char* gNames[] = {
+ "/skimages/background_01.png"
+};
+
+class Filter2View : public SampleView {
+public:
+ SkBitmap* fBitmaps;
+ int fBitmapCount;
+ int fCurrIndex;
+
+ Filter2View() {
+ fBitmapCount = SK_ARRAY_COUNT(gNames)*2;
+ fBitmaps = new SkBitmap[fBitmapCount];
+
+ for (int i = 0; i < fBitmapCount/2; i++) {
+ SkImageDecoder::DecodeFile(gNames[i], &fBitmaps[i],
+ SkBitmap::kARGB_8888_Config,
+ SkImageDecoder::kDecodePixels_Mode, NULL);
+ }
+ for (int i = fBitmapCount/2; i < fBitmapCount; i++) {
+ SkImageDecoder::DecodeFile(gNames[i-fBitmapCount/2], &fBitmaps[i],
+ SkBitmap::kRGB_565_Config,
+ SkImageDecoder::kDecodePixels_Mode, NULL);
+ }
+ fCurrIndex = 0;
+
+ this->setBGColor(SK_ColorGRAY);
+ }
+
+ virtual ~Filter2View() {
+ delete[] fBitmaps;
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SkString str("Filter/Dither ");
+ str.append(gNames[fCurrIndex]);
+ SampleCode::TitleR(evt, str.c_str());
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ canvas->translate(SkIntToScalar(10), SkIntToScalar(50));
+
+ const SkScalar W = SkIntToScalar(fBitmaps[0].width() + 1);
+ const SkScalar H = SkIntToScalar(fBitmaps[0].height() + 1);
+ SkPaint paint;
+
+ const SkScalar scale = SkFloatToScalar(0.897917f);
+ canvas->scale(SK_Scalar1, scale);
+
+ for (int k = 0; k < 2; k++) {
+ paint.setFilterBitmap(k == 1);
+ for (int j = 0; j < 2; j++) {
+ paint.setDither(j == 1);
+ for (int i = 0; i < fBitmapCount; i++) {
+ SkScalar x = (k * fBitmapCount + j) * W;
+ SkScalar y = i * H;
+ x = SkIntToScalar(SkScalarRound(x));
+ y = SkIntToScalar(SkScalarRound(y));
+ canvas->drawBitmap(fBitmaps[i], x, y, &paint);
+ if (i == 0) {
+ SkPaint p;
+ p.setAntiAlias(true);
+ p.setTextAlign(SkPaint::kCenter_Align);
+ p.setTextSize(SkIntToScalar(18));
+ SkString s("dither=");
+ s.appendS32(paint.isDither());
+ s.append(" filter=");
+ s.appendS32(paint.isFilterBitmap());
+ canvas->drawText(s.c_str(), s.size(), x + W/2,
+ y - p.getTextSize(), p);
+ }
+ if (k+j == 2) {
+ SkPaint p;
+ p.setAntiAlias(true);
+ p.setTextSize(SkIntToScalar(18));
+ SkString s;
+ s.append(" depth=");
+ s.appendS32(fBitmaps[i].config() == SkBitmap::kRGB_565_Config ? 16 : 32);
+ canvas->drawText(s.c_str(), s.size(), x + W + SkIntToScalar(4),
+ y + H/2, p);
+ }
+ }
+ }
+ }
+ }
+
+private:
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new Filter2View; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleFontCache.cpp b/samplecode/SampleFontCache.cpp
new file mode 100644
index 0000000..0b8187a
--- /dev/null
+++ b/samplecode/SampleFontCache.cpp
@@ -0,0 +1,135 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkGraphics.h"
+#include "SkRandom.h"
+
+#include <pthread.h>
+
+static void call_measure() {
+ SkPaint paint;
+ uint16_t text[32];
+ SkRandom rand;
+
+ paint.setAntiAlias(true);
+ paint.setTextEncoding(SkPaint::kUTF16_TextEncoding);
+ for (int j = 0; j < SK_ARRAY_COUNT(text); j++)
+ text[j] = (uint16_t)((rand.nextU() & 0xFF) + 32);
+
+ for (int i = 9; i < 36; i++) {
+ SkPaint::FontMetrics m;
+
+ paint.setTextSize(SkIntToScalar(i));
+ paint.getFontMetrics(&m);
+ paint.measureText(text, sizeof(text));
+ }
+}
+
+static void call_draw(SkCanvas* canvas) {
+ SkPaint paint;
+ uint16_t text[32];
+ SkRandom rand;
+
+ paint.setAntiAlias(true);
+ paint.setTextEncoding(SkPaint::kUTF16_TextEncoding);
+ for (int j = 0; j < SK_ARRAY_COUNT(text); j++)
+ text[j] = (uint16_t)((rand.nextU() & 0xFF) + 32);
+
+ SkScalar x = SkIntToScalar(10);
+ SkScalar y = SkIntToScalar(20);
+
+ canvas->drawColor(SK_ColorWHITE);
+ for (int i = 9; i < 36; i++)
+ {
+ SkPaint::FontMetrics m;
+
+ paint.setTextSize(SkIntToScalar(i));
+ paint.getFontMetrics(&m);
+ canvas->drawText(text, sizeof(text), x, y, paint);
+ y += m.fDescent - m.fAscent;
+ }
+}
+
+static bool gDone;
+
+static void* measure_proc(void* context) {
+ while (!gDone) {
+ call_measure();
+ }
+ return NULL;
+}
+
+static void* draw_proc(void* context) {
+ SkBitmap* bm = (SkBitmap*)context;
+ SkCanvas canvas(*bm);
+
+ while (!gDone) {
+ call_draw(&canvas);
+ }
+ return NULL;
+}
+
+class FontCacheView : public SampleView {
+public:
+ enum { N = 4 };
+
+ pthread_t fMThreads[N];
+ pthread_t fDThreads[N];
+ SkBitmap fBitmaps[N];
+
+ FontCacheView() {
+ gDone = false;
+ for (int i = 0; i < N; i++) {
+ int status;
+
+ status = pthread_create(&fMThreads[i], NULL, measure_proc, NULL);
+ SkASSERT(0 == status);
+
+ fBitmaps[i].setConfig(SkBitmap::kRGB_565_Config, 320, 240);
+ fBitmaps[i].allocPixels();
+ status = pthread_create(&fDThreads[i], NULL, draw_proc, &fBitmaps[i]);
+ SkASSERT(0 == status);
+ }
+ this->setBGColor(0xFFDDDDDD);
+ }
+
+ virtual ~FontCacheView() {
+ gDone = true;
+ for (int i = 0; i < N; i++) {
+ void* ret;
+ int status = pthread_join(fMThreads[i], &ret);
+ SkASSERT(0 == status);
+ status = pthread_join(fDThreads[i], &ret);
+ SkASSERT(0 == status);
+ }
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "FontCache");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ SkScalar x = 0;
+ SkScalar y = 0;
+ for (int i = 0; i < N; i++) {
+ canvas->drawBitmap(fBitmaps[i], x, y);
+ x += SkIntToScalar(fBitmaps[i].width());
+ }
+ this->inval(NULL);
+ }
+
+private:
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new FontCacheView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleFontScalerTest.cpp b/samplecode/SampleFontScalerTest.cpp
new file mode 100644
index 0000000..0b0d349
--- /dev/null
+++ b/samplecode/SampleFontScalerTest.cpp
@@ -0,0 +1,117 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkTypeface.h"
+#include "SkPath.h"
+#include "SkRegion.h"
+#include "SkShader.h"
+#include "SkUtils.h"
+#include "Sk1DPathEffect.h"
+#include "SkCornerPathEffect.h"
+#include "SkPathMeasure.h"
+#include "SkRandom.h"
+#include "SkColorPriv.h"
+#include "SkColorFilter.h"
+#include "SkDither.h"
+
+static const struct {
+ const char* fName;
+ SkTypeface::Style fStyle;
+} gFaces[] = {
+ { NULL, SkTypeface::kNormal },
+ { NULL, SkTypeface::kBold },
+ { "serif", SkTypeface::kNormal },
+ { "serif", SkTypeface::kBold },
+ { "serif", SkTypeface::kItalic },
+ { "serif", SkTypeface::kBoldItalic },
+ { "monospace", SkTypeface::kNormal }
+};
+
+static const int gFaceCount = SK_ARRAY_COUNT(gFaces);
+
+class FontScalerTestView : public SampleView {
+ SkTypeface* fFaces[gFaceCount];
+
+public:
+ FontScalerTestView() {
+ for (int i = 0; i < gFaceCount; i++) {
+ fFaces[i] = SkTypeface::CreateFromName(gFaces[i].fName,
+ gFaces[i].fStyle);
+ }
+ this->setBGColor(0xFFDDDDDD);
+ }
+
+ virtual ~FontScalerTestView() {
+ for (int i = 0; i < gFaceCount; i++) {
+ SkSafeUnref(fFaces[i]);
+ }
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "FontScaler Test");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ SkPaint paint;
+
+ // test handling of obscene cubic values (currently broken)
+ if (false) {
+ SkPoint pts[4];
+ pts[0].set(1.61061274e+09f, 6291456);
+ pts[1].set(-7.18397061e+15f, -1.53091184e+13f);
+ pts[2].set(-1.30077315e+16f, -2.77196141e+13f);
+ pts[3].set(-1.30077315e+16f, -2.77196162e+13f);
+
+ SkPath path;
+ path.moveTo(pts[0]);
+ path.cubicTo(pts[1], pts[2], pts[3]);
+ canvas->drawPath(path, paint);
+ }
+
+ canvas->translate(200, 20);
+ canvas->rotate(30);
+
+ paint.setAntiAlias(true);
+ paint.setLCDRenderText(true);
+ SkSafeUnref(paint.setTypeface(SkTypeface::CreateFromName("Times Roman", SkTypeface::kNormal)));
+
+// const char* text = "abcdefghijklmnopqrstuvwxyz";
+ const char* text = "HnHnHnHnHnHnHnHnH";
+ size_t textLen = strlen(text);
+
+ SkScalar x = SkIntToScalar(10);
+ SkScalar y = SkIntToScalar(20);
+
+ {
+ SkPaint p;
+ p.setColor(SK_ColorRED);
+ SkRect r;
+ r.set(0, 0, x, y*20);
+ canvas->drawRect(r, p);
+ }
+
+ int index = 0;
+ for (int ps = 9; ps <= 24; ps++) {
+ textLen = strlen(text);
+ paint.setTextSize(SkIntToScalar(ps));
+ canvas->drawText(text, textLen, x, y, paint);
+ y += paint.getFontMetrics(NULL);
+ index += 1;
+ }
+ }
+
+private:
+ typedef SkView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new FontScalerTestView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleFuzz.cpp b/samplecode/SampleFuzz.cpp
new file mode 100644
index 0000000..5c41886
--- /dev/null
+++ b/samplecode/SampleFuzz.cpp
@@ -0,0 +1,363 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkBlurMaskFilter.h"
+#include "SkPaint.h"
+#include "SkPath.h"
+#include "SkXfermode.h"
+#include "SkMatrix.h"
+#include "SkColor.h"
+#include "SkRandom.h"
+
+static void set2x3(SkMatrix* m, float a, float b, float c, float d, float e, float f) {
+ m->reset();
+ m->set(0, a);
+ m->set(1, b);
+ m->set(2, c);
+ m->set(3, d);
+ m->set(4, e);
+ m->set(5, f);
+}
+
+static SkRandom gRand;
+static bool return_large;
+static bool return_undef;
+static bool quick;
+static bool scale_large;
+static int scval = 1;
+static float transval = 0;
+
+static int R(float x) {
+ return (int)floor(SkScalarToFloat(gRand.nextUScalar1()) * x);
+}
+
+static float huge() {
+ double d = 1e100;
+ float f = (float)d;
+ return f;
+}
+
+static float make_number() {
+ float v;
+ int sel;
+
+ if (return_large == true && R(3) == 1) sel = R(6); else sel = R(4);
+ if (return_undef == false && sel == 0) sel = 1;
+
+ if (R(2) == 1) v = (float)R(100); else
+
+ switch (sel) {
+ case 0: break;
+ case 1: v = 0; break;
+ case 2: v = 0.000001f; break;
+ case 3: v = 10000; break;
+ case 4: v = 2000000000; break;
+ case 5: v = huge(); break;
+ }
+
+ if (R(4) == 1) v = -v;
+ return v;
+}
+
+static SkColor make_color() {
+ if (R(2) == 1) return 0xFFC0F0A0; else return 0xFF000090;
+}
+
+
+static SkColor make_fill() {
+#if 0
+ int sel;
+
+ if (quick == true) sel = 0; else sel = R(6);
+
+ switch (sel) {
+
+ case 0:
+ case 1:
+ case 2:
+ return make_color();
+ break;
+
+ case 3:
+ var r = ctx.createLinearGradient(make_number(),make_number(),make_number(),make_number());
+ for (i=0;i<4;i++)
+ r.addColorStop(make_number(),make_color());
+ return r;
+ break;
+
+ case 4:
+ var r = ctx.createRadialGradient(make_number(),make_number(),make_number(),make_number(),make_number(),make_number());
+ for (i=0;i<4;i++)
+ r.addColorStop(make_number(),make_color());
+ return r;
+ break;
+
+ case 5:
+ var r = ctx.createPattern(imgObj,"repeat");
+ if (R(6) == 0)
+ r.addColorStop(make_number(),make_color());
+ return r;
+ break;
+ }
+#else
+ return make_color();
+#endif
+}
+
+
+static void do_fuzz(SkCanvas* canvas) {
+ SkPath path;
+ SkPaint paint;
+ paint.setAntiAlias(true);
+
+ for (int i=0;i<100;i++) {
+ switch (R(33)) {
+
+ case 0:
+ paint.setColor(make_fill());
+ break;
+
+ case 1:
+ paint.setAlpha(gRand.nextU() & 0xFF);
+ break;
+
+ case 2: {
+ SkXfermode::Mode mode;
+ switch (R(3)) {
+ case 0: mode = SkXfermode::kSrc_Mode; break;
+ case 1: mode = SkXfermode::kXor_Mode; break;
+ case 2: mode = SkXfermode::kSrcOver_Mode; break;
+ }
+ paint.setXfermodeMode(mode);
+ }
+ break;
+
+ case 3:
+ switch (R(2)) {
+ case 0: paint.setStrokeCap(SkPaint::kRound_Cap); break;
+ case 1: paint.setStrokeCap(SkPaint::kButt_Cap); break;
+ }
+ break;
+
+ case 4:
+ switch (R(2)) {
+ case 0: paint.setStrokeJoin(SkPaint::kRound_Join); break;
+ case 1: paint.setStrokeJoin(SkPaint::kMiter_Join); break;
+ }
+ break;
+
+ case 5:
+ paint.setStrokeWidth(make_number());
+ break;
+
+ case 6:
+ paint.setStrokeMiter(make_number());
+ break;
+
+ case 7:
+ if (quick == true) break;
+ SkSafeUnref(paint.setMaskFilter(SkBlurMaskFilter::Create(make_number(), SkBlurMaskFilter::kNormal_BlurStyle)));
+ break;
+
+ case 8:
+ if (quick == true) break;
+ //ctx.shadowColor = make_fill();
+ break;
+
+ case 9:
+ if (quick == true) break;
+ //ctx.shadowOffsetX = make_number();
+ //ctx.shadowOffsetY = make_number();
+ break;
+
+ case 10:
+ canvas->restore();
+ break;
+
+ case 11:
+ canvas->rotate(make_number());
+ break;
+
+ case 12:
+ canvas->save();
+ break;
+
+ case 13:
+ canvas->scale(-1,-1);
+ break;
+
+ case 14:
+
+ if (quick == true) break;
+
+ if (transval == 0) {
+ transval = make_number();
+ canvas->translate(transval,0);
+ } else {
+ canvas->translate(-transval,0);
+ transval = 0;
+ }
+
+ break;
+
+ case 15: {
+ SkRect r;
+ r.set(make_number(),make_number(),make_number(),make_number());
+ SkPaint::Style s = paint.getStyle();
+ paint.setStyle(SkPaint::kFill_Style);
+ canvas->drawRect(r, paint);
+ paint.setStyle(s);
+ // clearrect
+ } break;
+
+ case 16:
+ if (quick == true) break;
+// ctx.drawImage(imgObj,make_number(),make_number(),make_number(),make_number(),make_number(),make_number(),make_number(),make_number());
+ break;
+
+ case 17: {
+ SkRect r;
+ r.set(make_number(),make_number(),make_number(),make_number());
+ SkPaint::Style s = paint.getStyle();
+ paint.setStyle(SkPaint::kFill_Style);
+ canvas->drawRect(r, paint);
+ paint.setStyle(s);
+ } break;
+
+ case 18:
+ path.reset();
+ break;
+
+ case 19:
+ // ctx.clip() is evil.
+ break;
+
+ case 20:
+ path.close();
+ break;
+
+ case 21: {
+ SkPaint::Style s = paint.getStyle();
+ paint.setStyle(SkPaint::kFill_Style);
+ canvas->drawPath(path, paint);
+ paint.setStyle(s);
+ } break;
+
+ case 22: {
+ SkPaint::Style s = paint.getStyle();
+ paint.setStyle(SkPaint::kFill_Style);
+ canvas->drawPath(path, paint);
+ paint.setStyle(s);
+ } break;
+
+ case 23: {
+ SkRect r;
+ r.set(make_number(),make_number(),make_number(),make_number());
+ SkPaint::Style s = paint.getStyle();
+ paint.setStyle(SkPaint::kStroke_Style);
+ canvas->drawRect(r, paint);
+ paint.setStyle(s);
+ } break;
+
+ case 24:
+ if (quick == true) break;
+ //ctx.arc(make_number(),make_number(),make_number(),make_number(),make_number(),true);
+ break;
+
+ case 25:
+ if (quick == true) break;
+ //ctx.arcTo(make_number(),make_number(),make_number(),make_number(),make_number());
+ break;
+
+ case 26:
+ if (quick == true) break;
+ //ctx.bezierCurveTo(make_number(),make_number(),make_number(),make_number(),make_number(),make_number());
+ break;
+
+ case 27:
+ path.lineTo(make_number(),make_number());
+ break;
+
+ case 28:
+ path.moveTo(make_number(),make_number());
+ break;
+
+ case 29:
+ if (quick == true) break;
+ path.quadTo(make_number(),make_number(),make_number(),make_number());
+ break;
+
+ case 30: {
+ if (quick == true) break;
+ SkMatrix matrix;
+ set2x3(&matrix, make_number(),make_number(),make_number(),make_number(),make_number(),make_number());
+ canvas->concat(matrix);
+ } break;
+
+ case 31: {
+ if (quick == true) break;
+ SkMatrix matrix;
+ set2x3(&matrix, make_number(),make_number(),make_number(),make_number(),make_number(),make_number());
+ canvas->setMatrix(matrix);
+ } break;
+
+ case 32:
+
+ if (scale_large == true) {
+
+ switch (scval) {
+ case 0: canvas->scale(-1000000000,1);
+ canvas->scale(-1000000000,1);
+ scval = 1; break;
+ case 1: canvas->scale(-.000000001f,1); scval = 2; break;
+ case 2: canvas->scale(-.000000001f,1); scval = 0; break;
+ }
+
+ }
+
+ break;
+
+
+
+ }
+ }
+
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+class FuzzView : public SampleView {
+public:
+ FuzzView() {
+ this->setBGColor(0xFFDDDDDD);
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "Fuzzer");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ void drawBG(SkCanvas* canvas) {
+ canvas->drawColor(0xFFDDDDDD);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ SkIRect r = canvas->getTotalClip().getBounds();
+ do_fuzz(canvas);
+ this->inval(NULL);
+ }
+
+private:
+ typedef SkView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new FuzzView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleGM.cpp b/samplecode/SampleGM.cpp
new file mode 100644
index 0000000..ec5b22a
--- /dev/null
+++ b/samplecode/SampleGM.cpp
@@ -0,0 +1,114 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+
+#include "gm.h"
+
+using namespace skiagm;
+
+// need to explicitly declare this, or we get some weird infinite loop llist
+template GMRegistry* GMRegistry::gHead;
+
+class Iter {
+public:
+ Iter() {
+ fReg = GMRegistry::Head();
+ }
+
+ void reset() {
+ fReg = GMRegistry::Head();
+ }
+
+ GM* next() {
+ if (fReg) {
+ GMRegistry::Factory fact = fReg->factory();
+ fReg = fReg->next();
+ return fact(0);
+ }
+ return NULL;
+ }
+
+ static int Count() {
+ const GMRegistry* reg = GMRegistry::Head();
+ int count = 0;
+ while (reg) {
+ count += 1;
+ reg = reg->next();
+ }
+ return count;
+ }
+
+private:
+ const GMRegistry* fReg;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+class GMView : public SampleView {
+ Iter fIter;
+ GM* fGM;
+public:
+ GMView() {
+ fGM = fIter.next();
+ this->postNextGM();
+
+ this->setBGColor(0xFFDDDDDD);
+ }
+
+ virtual ~GMView() {
+ delete fGM;
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "GM");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ virtual bool onEvent(const SkEvent& evt) {
+ if (evt.isType("next-gm")) {
+ delete fGM;
+ if (!(fGM = fIter.next())) {
+ fIter.reset();
+ fGM = fIter.next();
+ }
+ this->inval(NULL);
+ this->postNextGM();
+ return true;
+ }
+ return this->INHERITED::onEvent(evt);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ fGM->draw(canvas);
+ }
+
+private:
+ void postNextGM() {
+ (new SkEvent("next-gm"))->post(this->getSinkID(), 1500);
+ }
+
+ typedef SampleView INHERITED;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new GMView; }
+static SkViewRegister reg(MyFactory);
+
+///////////////////////////////////////////////////////////////////////////////
+
+using namespace skiagm;
+
+GM::GM() {}
+GM::~GM() {}
+
+void GM::draw(SkCanvas* canvas) {
+ this->onDraw(canvas);
+}
+
+
diff --git a/samplecode/SampleGradients.cpp b/samplecode/SampleGradients.cpp
new file mode 100644
index 0000000..902b0bd
--- /dev/null
+++ b/samplecode/SampleGradients.cpp
@@ -0,0 +1,176 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkGradientShader.h"
+
+static SkShader* setgrad(const SkRect& r, SkColor c0, SkColor c1) {
+ SkColor colors[] = { c0, c1 };
+ SkPoint pts[] = { { r.fLeft, r.fTop }, { r.fRight, r.fTop } };
+ return SkGradientShader::CreateLinear(pts, colors, NULL, 2,
+ SkShader::kClamp_TileMode, NULL);
+}
+
+static void test_alphagradients(SkCanvas* canvas) {
+ SkRect r;
+ r.set(SkIntToScalar(10), SkIntToScalar(10),
+ SkIntToScalar(410), SkIntToScalar(30));
+ SkPaint p, p2;
+ p2.setStyle(SkPaint::kStroke_Style);
+
+ p.setShader(setgrad(r, 0xFF00FF00, 0x0000FF00))->unref();
+ canvas->drawRect(r, p);
+ canvas->drawRect(r, p2);
+
+ r.offset(0, r.height() + SkIntToScalar(4));
+ p.setShader(setgrad(r, 0xFF00FF00, 0x00000000))->unref();
+ canvas->drawRect(r, p);
+ canvas->drawRect(r, p2);
+
+ r.offset(0, r.height() + SkIntToScalar(4));
+ p.setShader(setgrad(r, 0xFF00FF00, 0x00FF0000))->unref();
+ canvas->drawRect(r, p);
+ canvas->drawRect(r, p2);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+struct GradData {
+ int fCount;
+ const SkColor* fColors;
+ const SkScalar* fPos;
+};
+
+static const SkColor gColors[] = {
+ SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorWHITE, SK_ColorBLACK
+};
+static const SkScalar gPos0[] = { 0, SK_Scalar1 };
+static const SkScalar gPos1[] = { SK_Scalar1/4, SK_Scalar1*3/4 };
+static const SkScalar gPos2[] = {
+ 0, SK_Scalar1/8, SK_Scalar1/2, SK_Scalar1*7/8, SK_Scalar1
+};
+
+static const GradData gGradData[] = {
+ { 2, gColors, NULL },
+ { 2, gColors, gPos0 },
+ { 2, gColors, gPos1 },
+ { 5, gColors, NULL },
+ { 5, gColors, gPos2 }
+};
+
+static SkShader* MakeLinear(const SkPoint pts[2], const GradData& data,
+ SkShader::TileMode tm, SkUnitMapper* mapper) {
+ return SkGradientShader::CreateLinear(pts, data.fColors, data.fPos,
+ data.fCount, tm, mapper);
+}
+
+static SkShader* MakeRadial(const SkPoint pts[2], const GradData& data,
+ SkShader::TileMode tm, SkUnitMapper* mapper) {
+ SkPoint center;
+ center.set(SkScalarAve(pts[0].fX, pts[1].fX),
+ SkScalarAve(pts[0].fY, pts[1].fY));
+ return SkGradientShader::CreateRadial(center, center.fX, data.fColors,
+ data.fPos, data.fCount, tm, mapper);
+}
+
+static SkShader* MakeSweep(const SkPoint pts[2], const GradData& data,
+ SkShader::TileMode tm, SkUnitMapper* mapper) {
+ SkPoint center;
+ center.set(SkScalarAve(pts[0].fX, pts[1].fX),
+ SkScalarAve(pts[0].fY, pts[1].fY));
+ return SkGradientShader::CreateSweep(center.fX, center.fY, data.fColors,
+ data.fPos, data.fCount, mapper);
+}
+
+static SkShader* Make2Radial(const SkPoint pts[2], const GradData& data,
+ SkShader::TileMode tm, SkUnitMapper* mapper) {
+ SkPoint center0, center1;
+ center0.set(SkScalarAve(pts[0].fX, pts[1].fX),
+ SkScalarAve(pts[0].fY, pts[1].fY));
+ center1.set(SkScalarInterp(pts[0].fX, pts[1].fX, SkIntToScalar(3)/5),
+ SkScalarInterp(pts[0].fY, pts[1].fY, SkIntToScalar(1)/4));
+ return SkGradientShader::CreateTwoPointRadial(
+ center1, (pts[1].fX - pts[0].fX) / 7,
+ center0, (pts[1].fX - pts[0].fX) / 2,
+ data.fColors, data.fPos, data.fCount, tm, mapper);
+}
+
+static SkShader* Make2RadialConcentric(const SkPoint pts[2], const GradData& data,
+ SkShader::TileMode tm, SkUnitMapper* mapper) {
+ SkPoint center;
+ center.set(SkScalarAve(pts[0].fX, pts[1].fX),
+ SkScalarAve(pts[0].fY, pts[1].fY));
+ return SkGradientShader::CreateTwoPointRadial(
+ center, (pts[1].fX - pts[0].fX) / 7,
+ center, (pts[1].fX - pts[0].fX) / 2,
+ data.fColors, data.fPos, data.fCount, tm, mapper);
+}
+
+typedef SkShader* (*GradMaker)(const SkPoint pts[2], const GradData& data,
+ SkShader::TileMode tm, SkUnitMapper* mapper);
+static const GradMaker gGradMakers[] = {
+ MakeLinear, MakeRadial, MakeSweep, Make2Radial, Make2RadialConcentric
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+class GradientsView : public SampleView {
+public:
+ GradientsView() {
+ this->setBGColor(0xFFDDDDDD);
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "Gradients");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ SkPoint pts[2] = {
+ { 0, 0 },
+ { SkIntToScalar(100), SkIntToScalar(100) }
+ };
+ SkRect r = { 0, 0, SkIntToScalar(100), SkIntToScalar(100) };
+ SkPaint paint;
+ paint.setDither(true);
+
+ canvas->save();
+ canvas->translate(SkIntToScalar(20), SkIntToScalar(10));
+
+ for (int tm = 0; tm < SkShader::kTileModeCount; ++tm) {
+ canvas->save();
+ for (size_t i = 0; i < SK_ARRAY_COUNT(gGradData); i++) {
+ canvas->save();
+ for (size_t j = 0; j < SK_ARRAY_COUNT(gGradMakers); j++) {
+ SkShader* shader;
+ shader = gGradMakers[j](pts, gGradData[i], (SkShader::TileMode)tm, NULL);
+ paint.setShader(shader)->unref();
+ canvas->drawRect(r, paint);
+ canvas->translate(0, SkIntToScalar(120));
+ }
+ canvas->restore();
+ canvas->translate(SkIntToScalar(120), 0);
+ }
+ canvas->restore();
+ canvas->translate(SK_ARRAY_COUNT(gGradData)*SkIntToScalar(120), 0);
+ }
+ canvas->restore();
+
+ canvas->translate(0, SkIntToScalar(370));
+ // test_alphagradients(canvas);
+ this->inval(NULL);
+ }
+
+private:
+ typedef SampleView INHERITED;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new GradientsView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleHairline.cpp b/samplecode/SampleHairline.cpp
new file mode 100644
index 0000000..8368f5b
--- /dev/null
+++ b/samplecode/SampleHairline.cpp
@@ -0,0 +1,272 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "Sk64.h"
+#include "SkCornerPathEffect.h"
+#include "SkGradientShader.h"
+#include "SkGraphics.h"
+#include "SkImageDecoder.h"
+#include "SkKernel33MaskFilter.h"
+#include "SkPath.h"
+#include "SkRandom.h"
+#include "SkRegion.h"
+#include "SkShader.h"
+#include "SkUtils.h"
+#include "SkColorPriv.h"
+#include "SkColorFilter.h"
+#include "SkTime.h"
+#include "SkTypeface.h"
+#include "SkXfermode.h"
+
+#include "SkStream.h"
+#include "SkXMLParser.h"
+#include "SkColorPriv.h"
+#include "SkImageDecoder.h"
+
+static SkRandom gRand;
+
+static void test_chromium_9005() {
+ SkBitmap bm;
+ bm.setConfig(SkBitmap::kARGB_8888_Config, 800, 600);
+ bm.allocPixels();
+
+ SkCanvas canvas(bm);
+
+ SkPoint pt0 = { SkFloatToScalar(799.33374f), SkFloatToScalar(1.2360189f) };
+ SkPoint pt1 = { SkFloatToScalar(808.49969f), SkFloatToScalar(-7.4338055f) };
+
+ SkPaint paint;
+ paint.setAntiAlias(true);
+ canvas.drawLine(pt0.fX, pt0.fY, pt1.fX, pt1.fY, paint);
+}
+
+static void generate_pts(SkPoint pts[], int count, int w, int h) {
+ for (int i = 0; i < count; i++) {
+ pts[i].set(gRand.nextUScalar1() * 3 * w - SkIntToScalar(w),
+ gRand.nextUScalar1() * 3 * h - SkIntToScalar(h));
+ }
+}
+
+static bool check_zeros(const SkPMColor pixels[], int count, int skip) {
+ for (int i = 0; i < count; i++) {
+ if (*pixels) {
+ return false;
+ }
+ pixels += skip;
+ }
+ return true;
+}
+
+static bool check_bitmap_margin(const SkBitmap& bm, int margin) {
+ size_t rb = bm.rowBytes();
+ for (int i = 0; i < margin; i++) {
+ if (!check_zeros(bm.getAddr32(0, i), bm.width(), 1)) {
+ return false;
+ }
+ int bottom = bm.height() - i - 1;
+ if (!check_zeros(bm.getAddr32(0, bottom), bm.width(), 1)) {
+ return false;
+ }
+ // left column
+ if (!check_zeros(bm.getAddr32(i, 0), bm.height(), rb >> 2)) {
+ return false;
+ }
+ int right = bm.width() - margin + i;
+ if (!check_zeros(bm.getAddr32(right, 0), bm.height(), rb >> 2)) {
+ return false;
+ }
+ }
+ return true;
+}
+
+#define WIDTH 620
+#define HEIGHT 460
+#define MARGIN 10
+
+static void line_proc(SkCanvas* canvas, const SkPaint& paint,
+ const SkBitmap& bm) {
+ const int N = 2;
+ SkPoint pts[N];
+ for (int i = 0; i < 400; i++) {
+ generate_pts(pts, N, WIDTH, HEIGHT);
+
+ canvas->drawLine(pts[0].fX, pts[0].fY, pts[1].fX, pts[1].fY, paint);
+ if (!check_bitmap_margin(bm, MARGIN)) {
+ SkDebugf("---- hairline failure (%g %g) (%g %g)\n",
+ pts[0].fX, pts[0].fY, pts[1].fX, pts[1].fY);
+ break;
+ }
+ }
+}
+
+static void poly_proc(SkCanvas* canvas, const SkPaint& paint,
+ const SkBitmap& bm) {
+ const int N = 8;
+ SkPoint pts[N];
+ for (int i = 0; i < 50; i++) {
+ generate_pts(pts, N, WIDTH, HEIGHT);
+
+ SkPath path;
+ path.moveTo(pts[0]);
+ for (int j = 1; j < N; j++) {
+ path.lineTo(pts[j]);
+ }
+ canvas->drawPath(path, paint);
+ }
+}
+
+static SkPoint ave(const SkPoint& a, const SkPoint& b) {
+ SkPoint c = a + b;
+ c.fX = SkScalarHalf(c.fX);
+ c.fY = SkScalarHalf(c.fY);
+ return c;
+}
+
+static void quad_proc(SkCanvas* canvas, const SkPaint& paint,
+ const SkBitmap& bm) {
+ const int N = 30;
+ SkPoint pts[N];
+ for (int i = 0; i < 10; i++) {
+ generate_pts(pts, N, WIDTH, HEIGHT);
+
+ SkPath path;
+ path.moveTo(pts[0]);
+ for (int j = 1; j < N - 2; j++) {
+ path.quadTo(pts[j], ave(pts[j], pts[j+1]));
+ }
+ path.quadTo(pts[N - 2], pts[N - 1]);
+
+ canvas->drawPath(path, paint);
+ }
+}
+
+static void add_cubic(SkPath* path, const SkPoint& mid, const SkPoint& end) {
+ SkPoint start;
+ path->getLastPt(&start);
+ path->cubicTo(ave(start, mid), ave(mid, end), end);
+}
+
+static void cube_proc(SkCanvas* canvas, const SkPaint& paint,
+ const SkBitmap& bm) {
+ const int N = 30;
+ SkPoint pts[N];
+ for (int i = 0; i < 10; i++) {
+ generate_pts(pts, N, WIDTH, HEIGHT);
+
+ SkPath path;
+ path.moveTo(pts[0]);
+ for (int j = 1; j < N - 2; j++) {
+ add_cubic(&path, pts[j], ave(pts[j], pts[j+1]));
+ }
+ add_cubic(&path, pts[N - 2], pts[N - 1]);
+
+ canvas->drawPath(path, paint);
+ }
+}
+
+typedef void (*HairProc)(SkCanvas*, const SkPaint&, const SkBitmap&);
+
+static const struct {
+ const char* fName;
+ HairProc fProc;
+} gProcs[] = {
+ { "line", line_proc },
+ { "poly", poly_proc },
+ { "quad", quad_proc },
+ { "cube", cube_proc },
+};
+
+static int cycle_hairproc_index(int index) {
+ return (index + 1) % SK_ARRAY_COUNT(gProcs);
+}
+
+class HairlineView : public SampleView {
+ SkMSec fNow;
+ int fProcIndex;
+ bool fDoAA;
+public:
+ HairlineView() {
+ fCounter = 0;
+ fProcIndex = 0;
+ fDoAA = true;
+ fNow = 0;
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SkString str;
+ str.printf("Hair-%s", gProcs[fProcIndex].fName);
+ SampleCode::TitleR(evt, str.c_str());
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ void show_bitmaps(SkCanvas* canvas, const SkBitmap& b0, const SkBitmap& b1,
+ const SkIRect& inset) {
+ canvas->drawBitmap(b0, 0, 0, NULL);
+ canvas->drawBitmap(b1, SkIntToScalar(b0.width()), 0, NULL);
+ }
+
+ int fCounter;
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ gRand.setSeed(fNow);
+
+ if (false) {
+ test_chromium_9005();
+ }
+
+ SkBitmap bm, bm2;
+ bm.setConfig(SkBitmap::kARGB_8888_Config,
+ WIDTH + MARGIN*2,
+ HEIGHT + MARGIN*2);
+ bm.allocPixels();
+ // this will erase our margin, which we want to always stay 0
+ bm.eraseColor(0);
+
+ bm2.setConfig(SkBitmap::kARGB_8888_Config, WIDTH, HEIGHT,
+ bm.rowBytes());
+ bm2.setPixels(bm.getAddr32(MARGIN, MARGIN));
+
+ SkCanvas c2(bm2);
+ SkPaint paint;
+ paint.setAntiAlias(fDoAA);
+ paint.setStyle(SkPaint::kStroke_Style);
+
+ bm2.eraseColor(0);
+ gProcs[fProcIndex].fProc(&c2, paint, bm);
+ canvas->drawBitmap(bm2, SkIntToScalar(10), SkIntToScalar(10), NULL);
+
+ SkMSec now = SampleCode::GetAnimTime();
+ if (fNow != now) {
+ fNow = now;
+ fCounter += 1;
+ fDoAA = !fDoAA;
+ if (fCounter > 50) {
+ fProcIndex = cycle_hairproc_index(fProcIndex);
+ // todo: signal that we want to rebuild our TITLE
+ fCounter = 0;
+ }
+ this->inval(NULL);
+ }
+ }
+
+ virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
+ fDoAA = !fDoAA;
+ this->inval(NULL);
+ return this->INHERITED::onFindClickHandler(x, y);
+ }
+
+
+private:
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new HairlineView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleImage.cpp b/samplecode/SampleImage.cpp
new file mode 100644
index 0000000..2944299
--- /dev/null
+++ b/samplecode/SampleImage.cpp
@@ -0,0 +1,156 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkGradientShader.h"
+#include "SkGraphics.h"
+#include "SkImageDecoder.h"
+#include "SkPath.h"
+#include "SkRegion.h"
+#include "SkShader.h"
+#include "SkUtils.h"
+#include "SkXfermode.h"
+#include "SkColorPriv.h"
+#include "SkColorFilter.h"
+#include "SkTime.h"
+#include "SkTypeface.h"
+
+#include "SkImageRef_GlobalPool.h"
+#include "SkStream.h"
+
+static const char* gNames[] = {
+ "1.bmp", "1.gif", "1.jpg", "1.png",
+ "2.bmp", "2.gif", "2.jpg", "2.png"
+};
+
+static bool SetImageRef(SkBitmap* bitmap, SkStream* stream,
+ SkBitmap::Config pref, const char name[] = NULL)
+{
+ if (SkImageDecoder::DecodeStream(stream, bitmap, pref,
+ SkImageDecoder::kDecodeBounds_Mode, NULL)) {
+ SkASSERT(bitmap->config() != SkBitmap::kNo_Config);
+
+ SkImageRef* ref = new SkImageRef_GlobalPool(stream, bitmap->config());
+ ref->setURI(name);
+ bitmap->setPixelRef(ref)->unref();
+ return true;
+ } else {
+ return false;
+ }
+}
+
+class ImageView : public SkView {
+public:
+ SkBitmap* fBitmaps;
+ SkShader* fShader;
+
+ ImageView() {
+ SkImageRef_GlobalPool::SetRAMBudget(32 * 1024);
+
+ int i, N = SK_ARRAY_COUNT(gNames);
+ fBitmaps = new SkBitmap[N];
+
+ for (i = 0; i < N; i++) {
+ SkString str("/skimages/");
+ str.append(gNames[i]);
+ SkFILEStream* stream = new SkFILEStream(str.c_str());
+
+ SetImageRef(&fBitmaps[i], stream, SkBitmap::kNo_Config, gNames[i]);
+ if (i & 1)
+ fBitmaps[i].buildMipMap();
+ stream->unref();
+ }
+
+ fShader = SkShader::CreateBitmapShader(fBitmaps[5],
+ SkShader::kRepeat_TileMode,
+ SkShader::kRepeat_TileMode);
+
+ if (true) {
+ SkMatrix m;
+
+ m.setRotate(SkIntToScalar(30));
+ fShader->setLocalMatrix(m);
+ }
+
+#if 0
+ SkImageRef::DumpPool();
+ for (i = 0; i < N; i++) {
+ SkBitmap& bm = fBitmaps[i];
+
+ SkDebugf("<%s> addr=%p", gNames[i], bm.getPixels());
+ bool success = bm.lockPixels();
+ SkDebugf(" addr=%d", bm.getPixels());
+ if (success)
+ bm.unlockPixels();
+ SkDebugf(" addr=%p", bm.getPixels());
+ success = bm.lockPixels();
+ SkDebugf(" addr=%d", bm.getPixels());
+ if (success)
+ bm.unlockPixels();
+ SkDebugf("\n");
+ }
+ SkImageRef::DumpPool();
+#endif
+ }
+
+ virtual ~ImageView() {
+ delete[] fBitmaps;
+ delete fShader;
+
+ SkImageRef_GlobalPool::DumpPool();
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "Image");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ void drawBG(SkCanvas* canvas) {
+ canvas->drawColor(0xFFDDDDDD);
+// canvas->drawColor(SK_ColorWHITE);
+ }
+
+ virtual void onDraw(SkCanvas* canvas) {
+ this->drawBG(canvas);
+
+ canvas->translate(SkIntToScalar(10), SkIntToScalar(10));
+
+ SkScalar x = 0, y = 0;
+
+ for (size_t i = 0; i < SK_ARRAY_COUNT(gNames); i++) {
+ canvas->drawBitmap(fBitmaps[i], x, y);
+ x += SkIntToScalar(fBitmaps[i].width() + 10);
+ }
+
+ canvas->translate(0, SkIntToScalar(120));
+
+ SkPaint paint;
+ paint.setShader(fShader);
+ paint.setFilterBitmap(true);
+ SkRect r = { 0, 0, SkIntToScalar(300), SkIntToScalar(100) };
+
+ canvas->drawRect(r, paint);
+ }
+
+ virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
+ this->inval(NULL);
+ return this->INHERITED::onFindClickHandler(x, y);
+ }
+
+ virtual bool onClick(Click* click) {
+ return this->INHERITED::onClick(click);
+ }
+
+private:
+ typedef SkView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new ImageView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleImageDir.cpp b/samplecode/SampleImageDir.cpp
new file mode 100644
index 0000000..8ef59ad
--- /dev/null
+++ b/samplecode/SampleImageDir.cpp
@@ -0,0 +1,310 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkGradientShader.h"
+#include "SkGraphics.h"
+#include "SkImageDecoder.h"
+#include "SkPath.h"
+#include "SkRegion.h"
+#include "SkShader.h"
+#include "SkUtils.h"
+#include "SkXfermode.h"
+#include "SkComposeShader.h"
+#include "SkColorPriv.h"
+#include "SkColorFilter.h"
+#include "SkTime.h"
+#include "SkTypeface.h"
+
+#include "SkImageRef_GlobalPool.h"
+#include "SkOSFile.h"
+#include "SkStream.h"
+
+#include "SkBlurDrawLooper.h"
+#include "SkColorMatrixFilter.h"
+
+static void drawmarshmallow(SkCanvas* canvas) {
+ SkBitmap bitmap;
+ SkPaint paint;
+ SkRect r;
+ SkMatrix m;
+
+ SkImageDecoder::DecodeFile("/Users/reed/Downloads/3elfs.jpg", &bitmap);
+ SkShader* s = SkShader::CreateBitmapShader(bitmap,
+ SkShader::kRepeat_TileMode,
+ SkShader::kRepeat_TileMode);
+ paint.setShader(s)->unref();
+ m.setTranslate(SkIntToScalar(250), SkIntToScalar(134));
+ s->setLocalMatrix(m);
+
+ r.set(SkIntToScalar(250),
+ SkIntToScalar(134),
+ SkIntToScalar(250 + 449),
+ SkIntToScalar(134 + 701));
+ paint.setFlags(2);
+
+ canvas->drawRect(r, paint);
+}
+
+static void DrawRoundRect(SkCanvas& canvas) {
+ bool ret = false;
+ SkPaint paint;
+ SkBitmap bitmap;
+ SkMatrix matrix;
+ matrix.reset();
+
+ bitmap.setConfig(SkBitmap::kARGB_8888_Config, 1370, 812);
+ bitmap.allocPixels();
+#if 0
+ SkCanvas canvas;
+ canvas.setBitmapDevice(bitmap);
+#endif
+
+ // set up clipper
+ SkRect skclip;
+ skclip.set(SkIntToFixed(284), SkIntToFixed(40), SkIntToFixed(1370), SkIntToFixed(708));
+
+// ret = canvas.clipRect(skclip);
+// SkASSERT(ret);
+
+ matrix.set(SkMatrix::kMTransX, SkFloatToFixed(-1153.28));
+ matrix.set(SkMatrix::kMTransY, SkFloatToFixed(1180.50));
+
+ matrix.set(SkMatrix::kMScaleX, SkFloatToFixed(0.177171));
+ matrix.set(SkMatrix::kMScaleY, SkFloatToFixed(0.177043));
+
+ matrix.set(SkMatrix::kMSkewX, SkFloatToFixed(0.126968));
+ matrix.set(SkMatrix::kMSkewY, SkFloatToFixed(-0.126876));
+
+ matrix.set(SkMatrix::kMPersp0, SkFloatToFixed(0.0));
+ matrix.set(SkMatrix::kMPersp1, SkFloatToFixed(0.0));
+
+ ret = canvas.concat(matrix);
+
+ paint.setAntiAlias(true);
+ paint.setColor(0xb2202020);
+ paint.setStyle(SkPaint::kStroke_Style);
+ paint.setStrokeWidth(SkFloatToFixed(68.13));
+
+ SkRect r;
+ r.set(SkFloatToFixed(-313.714417), SkFloatToFixed(-4.826389), SkFloatToFixed(18014.447266), SkFloatToFixed(1858.154541));
+ canvas.drawRoundRect(r, SkFloatToFixed(91.756363), SkFloatToFixed(91.756363), paint);
+}
+
+static bool SetImageRef(SkBitmap* bitmap, SkStream* stream,
+ SkBitmap::Config pref, const char name[] = NULL) {
+#if 0
+ // test buffer streams
+ SkStream* str = new SkBufferStream(stream, 717);
+ stream->unref();
+ stream = str;
+#endif
+
+ SkImageRef* ref = new SkImageRef_GlobalPool(stream, pref, 1);
+ ref->setURI(name);
+ if (!ref->getInfo(bitmap)) {
+ delete ref;
+ return false;
+ }
+ bitmap->setPixelRef(ref)->unref();
+ return true;
+}
+
+//#define SPECIFIC_IMAGE "/skimages/72.jpg"
+#define SPECIFIC_IMAGE "/Users/reed/Downloads/3elfs.jpg"
+
+#define IMAGE_DIR "/skimages/"
+#define IMAGE_SUFFIX ".gif"
+
+class ImageDirView : public SkView {
+public:
+ SkBitmap* fBitmaps;
+ SkString* fStrings;
+ int fBitmapCount;
+ int fCurrIndex;
+ SkScalar fSaturation;
+ SkScalar fAngle;
+
+ ImageDirView() {
+ SkImageRef_GlobalPool::SetRAMBudget(320 * 1024);
+
+#ifdef SPECIFIC_IMAGE
+ fBitmaps = new SkBitmap[3];
+ fStrings = new SkString[3];
+ fBitmapCount = 3;
+ const SkBitmap::Config configs[] = {
+ SkBitmap::kARGB_8888_Config,
+ SkBitmap::kRGB_565_Config,
+ SkBitmap::kARGB_4444_Config
+ };
+ for (int i = 0; i < fBitmapCount; i++) {
+#if 1
+ SkStream* stream = new SkFILEStream(SPECIFIC_IMAGE);
+ SetImageRef(&fBitmaps[i], stream, configs[i], SPECIFIC_IMAGE);
+ stream->unref();
+#else
+ SkImageDecoder::DecodeFile(SPECIFIC_IMAGE, &fBitmaps[i]);
+#endif
+ }
+#else
+ int i, N = 0;
+ SkOSFile::Iter iter(IMAGE_DIR, IMAGE_SUFFIX);
+ SkString name;
+ while (iter.next(&name)) {
+ N += 1;
+ }
+ fBitmaps = new SkBitmap[N];
+ fStrings = new SkString[N];
+ iter.reset(IMAGE_DIR, IMAGE_SUFFIX);
+ for (i = 0; i < N; i++) {
+ iter.next(&name);
+ SkString path(IMAGE_DIR);
+ path.append(name);
+ SkStream* stream = new SkFILEStream(path.c_str());
+
+ SetImageRef(&fBitmaps[i], stream, SkBitmap::kNo_Config,
+ name.c_str());
+ stream->unref();
+ fStrings[i] = name;
+ }
+ fBitmapCount = N;
+#endif
+ fCurrIndex = 0;
+ fDX = fDY = 0;
+
+ fSaturation = SK_Scalar1;
+ fAngle = 0;
+
+ fScale = SK_Scalar1;
+ }
+
+ virtual ~ImageDirView() {
+ delete[] fBitmaps;
+ delete[] fStrings;
+
+ SkImageRef_GlobalPool::DumpPool();
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SkString str("ImageDir: ");
+#ifdef SPECIFIC_IMAGE
+ str.append(SPECIFIC_IMAGE);
+#else
+ str.append(IMAGE_DIR);
+#endif
+ SampleCode::TitleR(evt, str.c_str());
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ void drawBG(SkCanvas* canvas) {
+// canvas->drawColor(0xFFDDDDDD);
+ canvas->drawColor(SK_ColorGRAY);
+ canvas->drawColor(SK_ColorWHITE);
+ }
+
+ SkScalar fScale;
+ virtual void onDraw(SkCanvas* canvas) {
+ this->drawBG(canvas);
+
+ if (true) {
+ canvas->scale(SkIntToScalar(2), SkIntToScalar(2));
+ drawmarshmallow(canvas);
+ return;
+ }
+
+ if (false) {
+ SkPaint p;
+ p.setStyle(SkPaint::kStroke_Style);
+ p.setStrokeWidth(SkIntToScalar(4));
+ canvas->drawCircle(SkIntToScalar(100), SkIntToScalar(100), SkIntToScalar(50), p);
+ p.setAntiAlias(true);
+ canvas->drawCircle(SkIntToScalar(300), SkIntToScalar(100), SkIntToScalar(50), p);
+ }
+ if (false) {
+ SkScalar cx = this->width()/2;
+ SkScalar cy = this->height()/2;
+ canvas->translate(cx, cy);
+ canvas->scale(fScale, fScale);
+ canvas->translate(-cx, -cy);
+ DrawRoundRect(*canvas);
+ return;
+ }
+
+ canvas->translate(SkIntToScalar(10), SkIntToScalar(10));
+
+ SkScalar x = SkIntToScalar(32), y = SkIntToScalar(32);
+ SkPaint paint;
+
+#if 0
+ for (int i = 0; i < fBitmapCount; i++) {
+ SkPaint p;
+
+#if 1
+ const SkScalar cm[] = {
+ SkIntToScalar(2), 0, 0, 0, SkIntToScalar(-255),
+ 0, SkIntToScalar(2), 0, 0, SkIntToScalar(-255),
+ 0, 0, SkIntToScalar(2), 0, SkIntToScalar(-255),
+ 0, 0, 0, SkIntToScalar(1), 0
+ };
+ SkColorFilter* cf = new SkColorMatrixFilter(cm);
+ p.setColorFilter(cf)->unref();
+#endif
+
+ canvas->drawBitmap(fBitmaps[i], x, y, &p);
+ x += SkIntToScalar(fBitmaps[i].width() + 10);
+ }
+ return;
+#endif
+
+ canvas->drawBitmap(fBitmaps[fCurrIndex], x, y, &paint);
+#ifndef SPECIFIC_IMAGE
+ if (true) {
+ fCurrIndex += 1;
+ if (fCurrIndex >= fBitmapCount) {
+ fCurrIndex = 0;
+ }
+ this->inval(NULL);
+ }
+#endif
+ }
+
+ virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
+ if (true) {
+ fCurrIndex += 1;
+ if (fCurrIndex >= fBitmapCount)
+ fCurrIndex = 0;
+ this->inval(NULL);
+ }
+ return new Click(this);
+ }
+
+ virtual bool onClick(Click* click) {
+ SkScalar center = this->width()/2;
+ fSaturation = SkScalarDiv(click->fCurr.fX - center, center/2);
+ center = this->height()/2;
+ fAngle = SkScalarDiv(click->fCurr.fY - center, center) * 180;
+
+ fDX += click->fCurr.fX - click->fPrev.fX;
+ fDY += click->fCurr.fY - click->fPrev.fY;
+
+ fScale = SkScalarDiv(click->fCurr.fX, this->width());
+
+ this->inval(NULL);
+ return true;
+ return this->INHERITED::onClick(click);
+ }
+
+private:
+ SkScalar fDX, fDY;
+ typedef SkView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new ImageDirView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleLCD.cpp b/samplecode/SampleLCD.cpp
new file mode 100644
index 0000000..098958f
--- /dev/null
+++ b/samplecode/SampleLCD.cpp
@@ -0,0 +1,61 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkDevice.h"
+#include "SkPaint.h"
+#include "SkShader.h"
+
+class LCDView : public SkView {
+public:
+ LCDView() {}
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "LCD Text");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ void drawBG(SkCanvas* canvas) {
+ canvas->drawColor(SK_ColorWHITE);
+ }
+
+ virtual void onDraw(SkCanvas* canvas) {
+ this->drawBG(canvas);
+
+ SkPaint paint;
+ paint.setAntiAlias(true);
+
+ SkScalar textSize = SkIntToScalar(6);
+ SkScalar delta = SK_Scalar1;
+ const char* text = "HHHamburgefonts iii";
+ size_t len = strlen(text);
+ SkScalar x0 = SkIntToScalar(10);
+ SkScalar x1 = SkIntToScalar(310);
+ SkScalar y = SkIntToScalar(20);
+
+ for (int i = 0; i < 20; i++) {
+ paint.setTextSize(textSize);
+ textSize += delta;
+
+ paint.setLCDRenderText(false);
+ canvas->drawText(text, len, x0, y, paint);
+ paint.setLCDRenderText(true);
+ canvas->drawText(text, len, x1, y, paint);
+
+ y += paint.getFontSpacing();
+ }
+ }
+
+private:
+ typedef SkView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new LCDView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleLayerMask.cpp b/samplecode/SampleLayerMask.cpp
new file mode 100644
index 0000000..9bd00ae
--- /dev/null
+++ b/samplecode/SampleLayerMask.cpp
@@ -0,0 +1,68 @@
+#include "SampleCode.h"
+#include "SkCanvas.h"
+#include "SkPaint.h"
+#include "SkView.h"
+
+///////////////////////////////////////////////////////////////////////////////
+
+class LayerMaskView : public SampleView {
+public:
+ LayerMaskView() {
+ this->setBGColor(0xFFDDDDDD);
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "LayerMask");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ void drawMask(SkCanvas* canvas, const SkRect& r) {
+ SkPaint paint;
+ paint.setAntiAlias(true);
+
+ if (true) {
+ SkBitmap mask;
+ int w = SkScalarRound(r.width());
+ int h = SkScalarRound(r.height());
+ mask.setConfig(SkBitmap::kARGB_8888_Config, w, h);
+ mask.allocPixels();
+ mask.eraseColor(0);
+ SkCanvas c(mask);
+ SkRect bounds = r;
+ bounds.offset(-bounds.fLeft, -bounds.fTop);
+ c.drawOval(bounds, paint);
+
+ paint.setXfermodeMode(SkXfermode::kDstIn_Mode);
+ canvas->drawBitmap(mask, r.fLeft, r.fTop, &paint);
+ } else {
+ SkPath p;
+ p.addOval(r);
+ p.setFillType(SkPath::kInverseWinding_FillType);
+ paint.setXfermodeMode(SkXfermode::kDstOut_Mode);
+ canvas->drawPath(p, paint);
+ }
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ SkRect r;
+ r.set(SkIntToScalar(20), SkIntToScalar(20), SkIntToScalar(120), SkIntToScalar(120));
+ canvas->saveLayer(&r, NULL, SkCanvas::kARGB_ClipLayer_SaveFlag);
+ canvas->drawColor(SK_ColorRED);
+ drawMask(canvas, r);
+ canvas->restore();
+ }
+
+private:
+ typedef SampleView INHERITED;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new LayerMaskView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleLayers.cpp b/samplecode/SampleLayers.cpp
new file mode 100644
index 0000000..6fc9c83
--- /dev/null
+++ b/samplecode/SampleLayers.cpp
@@ -0,0 +1,271 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkBlurMaskFilter.h"
+#include "SkCamera.h"
+#include "SkColorFilter.h"
+#include "SkColorPriv.h"
+#include "SkDevice.h"
+#include "SkGradientShader.h"
+#include "SkImageDecoder.h"
+#include "SkInterpolator.h"
+#include "SkMaskFilter.h"
+#include "SkPath.h"
+#include "SkRegion.h"
+#include "SkShader.h"
+#include "SkTime.h"
+#include "SkTypeface.h"
+#include "SkUtils.h"
+#include "SkKey.h"
+#include "SkXfermode.h"
+#include "SkDrawFilter.h"
+
+static void make_paint(SkPaint* paint) {
+ SkColor colors[] = { 0, SK_ColorWHITE };
+ SkPoint pts[] = { { 0, 0 }, { 0, SK_Scalar1*20 } };
+ SkShader* s = SkGradientShader::CreateLinear(pts, colors, NULL, 2, SkShader::kClamp_TileMode);
+
+ paint->setShader(s)->unref();
+ paint->setXfermodeMode(SkXfermode::kDstIn_Mode);
+}
+
+static void dump_layers(const char label[], SkCanvas* canvas) {
+ SkDebugf("Dump Layers(%s)\n", label);
+
+ SkCanvas::LayerIter iter(canvas, true);
+ int index = 0;
+ while (!iter.done()) {
+ const SkBitmap& bm = iter.device()->accessBitmap(false);
+ const SkIRect& clip = iter.clip().getBounds();
+ SkDebugf("Layer[%d] bitmap [%d %d] X=%d Y=%d clip=[%d %d %d %d] alpha=%d\n", index++,
+ bm.width(), bm.height(), iter.x(), iter.y(),
+ clip.fLeft, clip.fTop, clip.fRight, clip.fBottom,
+ iter.paint().getAlpha());
+ iter.next();
+ }
+}
+
+// test drawing with strips of fading gradient above and below
+static void test_fade(SkCanvas* canvas) {
+ SkAutoCanvasRestore ar(canvas, true);
+
+ SkRect r;
+
+ SkPaint p;
+ p.setAlpha(0x88);
+
+ SkAutoCanvasRestore(canvas, false);
+
+ // create the layers
+
+ r.set(0, 0, SkIntToScalar(100), SkIntToScalar(100));
+ canvas->clipRect(r);
+
+ r.fBottom = SkIntToScalar(20);
+ canvas->saveLayer(&r, NULL, (SkCanvas::SaveFlags)(SkCanvas::kHasAlphaLayer_SaveFlag | SkCanvas::kFullColorLayer_SaveFlag));
+
+ r.fTop = SkIntToScalar(80);
+ r.fBottom = SkIntToScalar(100);
+ canvas->saveLayer(&r, NULL, (SkCanvas::SaveFlags)(SkCanvas::kHasAlphaLayer_SaveFlag | SkCanvas::kFullColorLayer_SaveFlag));
+
+ // now draw the "content"
+
+ if (true) {
+ r.set(0, 0, SkIntToScalar(100), SkIntToScalar(100));
+
+ canvas->saveLayerAlpha(&r, 0x80);
+
+ SkPaint p;
+ p.setColor(SK_ColorRED);
+ p.setAntiAlias(true);
+ canvas->drawOval(r, p);
+
+ dump_layers("inside layer alpha", canvas);
+
+ canvas->restore();
+ } else {
+ r.set(0, 0, SkIntToScalar(100), SkIntToScalar(100));
+
+ SkPaint p;
+ p.setColor(SK_ColorRED);
+ p.setAntiAlias(true);
+ canvas->drawOval(r, p);
+ }
+
+// return;
+
+ dump_layers("outside layer alpha", canvas);
+
+ // now apply an effect
+
+ SkPaint paint;
+ make_paint(&paint);
+ r.set(0, 0, SkIntToScalar(100), SkIntToScalar(20));
+// SkDebugf("--------- draw top grad\n");
+ canvas->drawRect(r, paint);
+
+ SkMatrix m;
+ SkShader* s = paint.getShader();
+ m.setScale(SK_Scalar1, -SK_Scalar1);
+ m.postTranslate(0, SkIntToScalar(100));
+ s->setLocalMatrix(m);
+
+ r.fTop = SkIntToScalar(80);
+ r.fBottom = SkIntToScalar(100);
+// SkDebugf("--------- draw bot grad\n");
+ canvas->drawRect(r, paint);
+}
+
+class RedFilter : public SkDrawFilter {
+public:
+ virtual bool filter(SkCanvas*, SkPaint* p, SkDrawFilter::Type) {
+ fColor = p->getColor();
+ if (fColor == SK_ColorRED) {
+ p->setColor(SK_ColorGREEN);
+ }
+ return true;
+ }
+ virtual void restore(SkCanvas*, SkPaint* p, SkDrawFilter::Type) {
+ p->setColor(fColor);
+ }
+
+private:
+ SkColor fColor;
+};
+
+class LayersView : public SkView {
+public:
+ LayersView() {}
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "Layers");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ void drawBG(SkCanvas* canvas) {
+ canvas->drawColor(SK_ColorGRAY);
+ }
+
+ virtual void onDraw(SkCanvas* canvas) {
+ this->drawBG(canvas);
+
+ if (true) {
+ SkRect r;
+ r.set(SkIntToScalar(0), SkIntToScalar(0),
+ SkIntToScalar(220), SkIntToScalar(120));
+ SkPaint p;
+ canvas->saveLayer(&r, &p);
+ canvas->drawColor(0xFFFF0000);
+ p.setAlpha(0); // or 0
+ p.setXfermodeMode(SkXfermode::kSrc_Mode);
+ canvas->drawOval(r, p);
+ canvas->restore();
+ return;
+ }
+
+ if (false) {
+ SkRect r;
+ r.set(SkIntToScalar(0), SkIntToScalar(0),
+ SkIntToScalar(220), SkIntToScalar(120));
+ SkPaint p;
+ p.setAlpha(0x88);
+ p.setAntiAlias(true);
+
+ if (true) {
+ canvas->saveLayer(&r, &p);
+ p.setColor(0xFFFF0000);
+ canvas->drawOval(r, p);
+ canvas->restore();
+ }
+
+ p.setColor(0xFF0000FF);
+ r.offset(SkIntToScalar(20), SkIntToScalar(50));
+ canvas->drawOval(r, p);
+ }
+
+ if (false) {
+ SkPaint p;
+ p.setAlpha(0x88);
+ p.setAntiAlias(true);
+
+ canvas->translate(SkIntToScalar(300), 0);
+
+ SkRect r;
+ r.set(SkIntToScalar(0), SkIntToScalar(0),
+ SkIntToScalar(220), SkIntToScalar(60));
+
+ canvas->saveLayer(&r, &p, (SkCanvas::SaveFlags)(SkCanvas::kHasAlphaLayer_SaveFlag | SkCanvas::kFullColorLayer_SaveFlag));
+// canvas->clipRect(r, SkRegion::kDifference_Op);
+// canvas->clipRect(r, SkRegion::kIntersect_Op);
+
+ r.set(SkIntToScalar(0), SkIntToScalar(0),
+ SkIntToScalar(220), SkIntToScalar(120));
+ p.setColor(SK_ColorBLUE);
+ canvas->drawOval(r, p);
+ canvas->restore();
+ return;
+ }
+
+ //canvas->translate(SkIntToScalar(20), SkIntToScalar(20));
+ test_fade(canvas);
+ return;
+
+ // canvas->setDrawFilter(new RedFilter)->unref();
+
+ SkRect r;
+ SkPaint p;
+
+ canvas->translate(SkIntToScalar(220), SkIntToScalar(20));
+
+ p.setAntiAlias(true);
+ r.set(SkIntToScalar(20), SkIntToScalar(20),
+ SkIntToScalar(220), SkIntToScalar(120));
+
+ p.setColor(SK_ColorBLUE);
+ // p.setMaskFilter(SkBlurMaskFilter::Create(SkIntToScalar(8), SkBlurMaskFilter::kNormal_BlurStyle))->unref();
+ canvas->drawRect(r, p);
+ p.setMaskFilter(NULL);
+
+ SkRect bounds = r;
+ bounds.fBottom = bounds.centerY();
+ canvas->saveLayer(&bounds, NULL, SkCanvas::kARGB_NoClipLayer_SaveFlag);
+
+ p.setColor(SK_ColorRED);
+ canvas->drawOval(r, p);
+
+ p.setAlpha(0x80);
+ p.setXfermodeMode(SkXfermode::kDstIn_Mode);
+ canvas->drawRect(bounds, p);
+
+ canvas->restore();
+ }
+
+ virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
+ this->inval(NULL);
+
+ return this->INHERITED::onFindClickHandler(x, y);
+ }
+
+ virtual bool onClick(Click* click) {
+ return this->INHERITED::onClick(click);
+ }
+
+ virtual bool handleKey(SkKey key) {
+ this->inval(NULL);
+ return true;
+ }
+
+private:
+ typedef SkView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new LayersView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleLineClipper.cpp b/samplecode/SampleLineClipper.cpp
new file mode 100644
index 0000000..ac6b013
--- /dev/null
+++ b/samplecode/SampleLineClipper.cpp
@@ -0,0 +1,255 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkGradientShader.h"
+#include "SkGraphics.h"
+#include "SkImageDecoder.h"
+#include "SkPath.h"
+#include "SkRegion.h"
+#include "SkShader.h"
+#include "SkUtils.h"
+#include "SkXfermode.h"
+#include "SkColorPriv.h"
+#include "SkColorFilter.h"
+#include "SkTime.h"
+#include "SkRandom.h"
+
+#include "SkLineClipper.h"
+#include "SkEdgeClipper.h"
+
+#define AUTO_ANIMATE true
+
+static int test0(SkPoint pts[], SkRect* clip) {
+ pts[0].set(200000, 140);
+ pts[1].set(-740000, 483);
+ pts[2].set(1.00000102e-06f, 9.10000017e-05f);
+ clip->set(0, 0, 640, 480);
+ return 2;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static void drawQuad(SkCanvas* canvas, const SkPoint pts[3], const SkPaint& p) {
+ SkPath path;
+ path.moveTo(pts[0]);
+ path.quadTo(pts[1], pts[2]);
+ canvas->drawPath(path, p);
+}
+
+static void drawCubic(SkCanvas* canvas, const SkPoint pts[4], const SkPaint& p) {
+ SkPath path;
+ path.moveTo(pts[0]);
+ path.cubicTo(pts[1], pts[2], pts[3]);
+ canvas->drawPath(path, p);
+}
+
+typedef void (*clipper_proc)(const SkPoint src[], const SkRect& clip,
+ SkCanvas*, const SkPaint&, const SkPaint&);
+
+static void check_clipper(int count, const SkPoint pts[], const SkRect& clip) {
+ for (int i = 0; i < count; i++) {
+ SkASSERT(pts[i].fX >= clip.fLeft);
+ SkASSERT(pts[i].fX <= clip.fRight);
+ SkASSERT(pts[i].fY >= clip.fTop);
+ SkASSERT(pts[i].fY <= clip.fBottom);
+ }
+
+ if (count > 1) {
+ sk_assert_monotonic_y(pts, count);
+ }
+}
+
+static void line_intersector(const SkPoint src[], const SkRect& clip,
+ SkCanvas* canvas, const SkPaint& p0, const SkPaint& p1) {
+ canvas->drawPoints(SkCanvas::kLines_PointMode, 2, src, p1);
+
+ SkPoint dst[2];
+ if (SkLineClipper::IntersectLine(src, clip, dst)) {
+ check_clipper(2, dst, clip);
+ canvas->drawPoints(SkCanvas::kLines_PointMode, 2, dst, p0);
+ }
+}
+
+static void line_clipper(const SkPoint src[], const SkRect& clip,
+ SkCanvas* canvas, const SkPaint& p0, const SkPaint& p1) {
+ canvas->drawPoints(SkCanvas::kLines_PointMode, 2, src, p1);
+
+ SkPoint dst[SkLineClipper::kMaxPoints];
+ int count = SkLineClipper::ClipLine(src, clip, dst);
+ for (int i = 0; i < count; i++) {
+ check_clipper(2, &dst[i], clip);
+ canvas->drawPoints(SkCanvas::kLines_PointMode, 2, &dst[i], p0);
+ }
+}
+
+static void quad_clipper(const SkPoint src[], const SkRect& clip,
+ SkCanvas* canvas, const SkPaint& p0, const SkPaint& p1) {
+ drawQuad(canvas, src, p1);
+
+ SkEdgeClipper clipper;
+ if (clipper.clipQuad(src, clip)) {
+ SkPoint pts[4];
+ SkPath::Verb verb;
+ while ((verb = clipper.next(pts)) != SkPath::kDone_Verb) {
+ switch (verb) {
+ case SkPath::kLine_Verb:
+ check_clipper(2, pts, clip);
+ canvas->drawPoints(SkCanvas::kLines_PointMode, 2, pts, p0);
+ break;
+ case SkPath::kQuad_Verb:
+ check_clipper(3, pts, clip);
+ drawQuad(canvas, pts, p0);
+ break;
+ default:
+ SkASSERT(!"unexpected verb");
+ }
+ }
+ }
+}
+
+static void cubic_clipper(const SkPoint src[], const SkRect& clip,
+ SkCanvas* canvas, const SkPaint& p0, const SkPaint& p1) {
+ drawCubic(canvas, src, p1);
+
+ SkEdgeClipper clipper;
+ if (clipper.clipCubic(src, clip)) {
+ SkPoint pts[4];
+ SkPath::Verb verb;
+ while ((verb = clipper.next(pts)) != SkPath::kDone_Verb) {
+ switch (verb) {
+ case SkPath::kLine_Verb:
+ check_clipper(2, pts, clip);
+ canvas->drawPoints(SkCanvas::kLines_PointMode, 2, pts, p0);
+ break;
+ case SkPath::kCubic_Verb:
+ // check_clipper(4, pts, clip);
+ drawCubic(canvas, pts, p0);
+ break;
+ default:
+ SkASSERT(!"unexpected verb");
+ }
+ }
+ }
+}
+
+static const clipper_proc gProcs[] = {
+ line_intersector,
+ line_clipper,
+ quad_clipper,
+ cubic_clipper
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+enum {
+ W = 640/3,
+ H = 480/3
+};
+
+class LineClipperView : public SkView {
+ SkMSec fNow;
+ int fCounter;
+ int fProcIndex;
+ SkRect fClip;
+ SkRandom fRand;
+ SkPoint fPts[4];
+
+ void randPts() {
+ for (size_t i = 0; i < SK_ARRAY_COUNT(fPts); i++) {
+ fPts[i].set(fRand.nextUScalar1() * 640,
+ fRand.nextUScalar1() * 480);
+ }
+ fCounter += 1;
+ }
+
+public:
+ LineClipperView() {
+ fProcIndex = 0;
+ fCounter = 0;
+ fNow = 0;
+
+ int x = (640 - W)/2;
+ int y = (480 - H)/2;
+ fClip.set(SkIntToScalar(x), SkIntToScalar(y),
+ SkIntToScalar(x + W), SkIntToScalar(y + H));
+ this->randPts();
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "LineClipper");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ void drawBG(SkCanvas* canvas) {
+ canvas->drawColor(SK_ColorWHITE);
+ }
+
+ static void drawVLine(SkCanvas* canvas, SkScalar x, const SkPaint& paint) {
+ canvas->drawLine(x, -999, x, 999, paint);
+ }
+
+ static void drawHLine(SkCanvas* canvas, SkScalar y, const SkPaint& paint) {
+ canvas->drawLine(-999, y, 999, y, paint);
+ }
+
+ virtual void onDraw(SkCanvas* canvas) {
+ this->drawBG(canvas);
+
+ SkMSec now = SampleCode::GetAnimTime();
+ if (fNow != now) {
+ fNow = now;
+ this->randPts();
+ this->inval(NULL);
+ }
+
+ // fProcIndex = test0(fPts, &fClip);
+
+ SkPaint paint, paint1;
+
+ drawVLine(canvas, fClip.fLeft + SK_ScalarHalf, paint);
+ drawVLine(canvas, fClip.fRight - SK_ScalarHalf, paint);
+ drawHLine(canvas, fClip.fTop + SK_ScalarHalf, paint);
+ drawHLine(canvas, fClip.fBottom - SK_ScalarHalf, paint);
+
+ paint.setColor(SK_ColorLTGRAY);
+ canvas->drawRect(fClip, paint);
+
+ paint.setAntiAlias(true);
+ paint.setColor(SK_ColorBLUE);
+ paint.setStyle(SkPaint::kStroke_Style);
+ // paint.setStrokeWidth(SkIntToScalar(3));
+ paint.setStrokeCap(SkPaint::kRound_Cap);
+
+ paint1.setAntiAlias(true);
+ paint1.setColor(SK_ColorRED);
+ paint1.setStyle(SkPaint::kStroke_Style);
+ gProcs[fProcIndex](fPts, fClip, canvas, paint, paint1);
+ }
+
+ virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
+ // fProcIndex = (fProcIndex + 1) % SK_ARRAY_COUNT(gProcs);
+ if (x < 50 && y < 50) {
+ this->randPts();
+ }
+ this->inval(NULL);
+ return NULL;
+ }
+
+ virtual bool onClick(Click* click) {
+ return false;
+ }
+
+private:
+ typedef SkView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new LineClipperView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleLines.cpp b/samplecode/SampleLines.cpp
new file mode 100644
index 0000000..03dd30f
--- /dev/null
+++ b/samplecode/SampleLines.cpp
@@ -0,0 +1,109 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "Sk64.h"
+#include "SkCornerPathEffect.h"
+#include "SkGradientShader.h"
+#include "SkGraphics.h"
+#include "SkImageDecoder.h"
+#include "SkKernel33MaskFilter.h"
+#include "SkPath.h"
+#include "SkRandom.h"
+#include "SkRegion.h"
+#include "SkShader.h"
+#include "SkUtils.h"
+#include "SkColorPriv.h"
+#include "SkColorFilter.h"
+#include "SkTime.h"
+#include "SkTypeface.h"
+#include "SkXfermode.h"
+
+#include "SkStream.h"
+#include "SkXMLParser.h"
+#include "SkColorPriv.h"
+#include "SkImageDecoder.h"
+
+class LinesView : public SampleView {
+public:
+ LinesView() {}
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "Lines");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ /*
+ 0x1F * x + 0x1F * (32 - x)
+ */
+ void drawRings(SkCanvas* canvas) {
+ canvas->scale(SkIntToScalar(1)/2, SkIntToScalar(1)/2);
+
+ SkRect r;
+ SkScalar x = SkIntToScalar(10);
+ SkScalar y = SkIntToScalar(10);
+ r.set(x, y, x + SkIntToScalar(100), y + SkIntToScalar(100));
+
+ SkPaint paint;
+ // paint.setAntiAlias(true);
+ paint.setStyle(SkPaint::kStroke_Style);
+ paint.setStrokeWidth(SkScalarHalf(SkIntToScalar(3)));
+ paint.setColor(0xFFFF8800);
+ // paint.setColor(0xFFFFFFFF);
+ canvas->drawRect(r, paint);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ SkBitmap bm;
+ SkImageDecoder::DecodeFile("/kill.gif", &bm);
+ canvas->drawBitmap(bm, 0, 0, NULL);
+
+ this->drawRings(canvas);
+ return;
+
+ SkPaint paint;
+
+ // fAlpha = 0x80;
+ paint.setColor(SK_ColorWHITE);
+ paint.setAlpha(fAlpha & 0xFF);
+ SkRect r;
+
+ SkScalar x = SkIntToScalar(10);
+ SkScalar y = SkIntToScalar(10);
+ r.set(x, y, x + SkIntToScalar(100), y + SkIntToScalar(100));
+ canvas->drawRect(r, paint);
+ return;
+
+ paint.setColor(0xffffff00); // yellow
+ paint.setStyle(SkPaint::kStroke_Style);
+ paint.setStrokeWidth(SkIntToScalar(2));
+
+// y += SK_Scalar1/2;
+
+ canvas->drawLine(x, y, x + SkIntToScalar(90), y + SkIntToScalar(90), paint);
+
+ paint.setAntiAlias(true); // with anti-aliasing
+ y += SkIntToScalar(10);
+ canvas->drawLine(x, y, x + SkIntToScalar(90), y + SkIntToScalar(90), paint);
+ }
+
+ virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
+ fAlpha = SkScalarRound(y);
+ this->inval(NULL);
+ return NULL;
+ }
+private:
+
+ int fAlpha;
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new LinesView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleMeasure.cpp b/samplecode/SampleMeasure.cpp
new file mode 100644
index 0000000..8078e03
--- /dev/null
+++ b/samplecode/SampleMeasure.cpp
@@ -0,0 +1,115 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkGradientShader.h"
+#include "SkPath.h"
+#include "SkRegion.h"
+#include "SkShader.h"
+#include "SkUtils.h"
+#include "Sk1DPathEffect.h"
+#include "SkCornerPathEffect.h"
+#include "SkPathMeasure.h"
+#include "SkRandom.h"
+#include "SkColorPriv.h"
+#include "SkColorFilter.h"
+#include "SkDither.h"
+
+// exercise scale/linear/devkern
+struct Setting {
+ SkScalar fScale;
+ bool fLinearText;
+ bool fDevKernText;
+};
+
+static const SkScalar ONE = SkIntToScalar(9999)/10000;
+
+static const Setting gSettings[] = {
+ { 0, false, false },
+ { 0, false, true },
+ { 0, true, false },
+ { 0, true, true },
+ { ONE, false, false },
+ { ONE, false, true },
+ { ONE, true, false },
+ { ONE, true, true }
+};
+
+static void doMeasure(SkCanvas* canvas, const SkPaint& paint, const char text[]) {
+ SkScalar dy = paint.getFontMetrics(NULL);
+
+ size_t len = strlen(text);
+ SkAutoTMalloc<SkScalar> autoWidths(len);
+ SkScalar* widths = autoWidths.get();
+ SkAutoTMalloc<SkRect> autoRects(len);
+ SkRect* rects = autoRects.get();
+ SkRect bounds;
+
+ SkPaint p(paint);
+ for (size_t i = 0; i < SK_ARRAY_COUNT(gSettings); i++) {
+ p.setLinearText(gSettings[i].fLinearText);
+ p.setDevKernText(gSettings[i].fDevKernText);
+ SkScalar scale = gSettings[i].fScale;
+
+ int n = p.getTextWidths(text, len, widths, rects);
+ SkScalar w = p.measureText(text, len, &bounds, scale);
+
+ p.setStyle(SkPaint::kFill_Style);
+ p.setColor(0x8888FF88);
+ canvas->drawRect(bounds, p);
+ p.setColor(0xFF000000);
+ canvas->drawText(text, len, 0, 0, p);
+
+ p.setStyle(SkPaint::kStroke_Style);
+ p.setStrokeWidth(0);
+ p.setColor(0xFFFF0000);
+ SkScalar x = 0;
+ for (int j = 0; j < n; j++) {
+ SkRect r = rects[j];
+ r.offset(x, 0);
+ canvas->drawRect(r, p);
+ x += widths[j];
+ }
+
+ p.setColor(0xFF0000FF);
+ canvas->drawLine(0, 0, w, 0, p);
+ p.setStrokeWidth(SkIntToScalar(4));
+ canvas->drawPoint(x, 0, p);
+
+ canvas->translate(0, dy);
+ }
+}
+
+class MeasureView : public SampleView {
+public:
+ SkPaint fPaint;
+
+ MeasureView() {
+ fPaint.setAntiAlias(true);
+ fPaint.setTextSize(SkIntToScalar(64));
+ this->setBGColor(0xFFDDDDDD);
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "Measure");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ canvas->translate(fPaint.getTextSize(), fPaint.getTextSize());
+ doMeasure(canvas, fPaint, "Hamburgefons");
+ }
+
+private:
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new MeasureView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleMipMap.cpp b/samplecode/SampleMipMap.cpp
new file mode 100644
index 0000000..3d95156
--- /dev/null
+++ b/samplecode/SampleMipMap.cpp
@@ -0,0 +1,143 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkDevice.h"
+#include "SkPaint.h"
+#include "SkShader.h"
+
+static SkBitmap createBitmap(int n) {
+ SkBitmap bitmap;
+ bitmap.setConfig(SkBitmap::kARGB_8888_Config, n, n);
+ bitmap.allocPixels();
+ bitmap.eraseColor(0);
+
+ SkCanvas canvas(bitmap);
+ SkRect r;
+ r.set(0, 0, SkIntToScalar(n), SkIntToScalar(n));
+ SkPaint paint;
+ paint.setAntiAlias(true);
+
+ paint.setColor(SK_ColorRED);
+ canvas.drawOval(r, paint);
+ paint.setColor(SK_ColorBLUE);
+ paint.setStrokeWidth(SkIntToScalar(n)/15);
+ paint.setStyle(SkPaint::kStroke_Style);
+ canvas.drawLine(0, 0, r.fRight, r.fBottom, paint);
+ canvas.drawLine(0, r.fBottom, r.fRight, 0, paint);
+
+ return bitmap;
+}
+
+class MipMapView : public SampleView {
+ SkBitmap fBitmap;
+ enum {
+ N = 64
+ };
+public:
+ MipMapView() {
+ fBitmap = createBitmap(N);
+
+ fWidth = N;
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "MipMaps");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ void drawN(SkCanvas* canvas, const SkBitmap& bitmap) {
+ SkAutoCanvasRestore acr(canvas, true);
+ for (int i = N; i > 1; i >>= 1) {
+ canvas->drawBitmap(bitmap, 0, 0, NULL);
+ canvas->translate(SkIntToScalar(N + 8), 0);
+ canvas->scale(SK_ScalarHalf, SK_ScalarHalf);
+ }
+ }
+
+ void drawN2(SkCanvas* canvas, const SkBitmap& bitmap) {
+ SkBitmap bg;
+ bg.setConfig(SkBitmap::kARGB_8888_Config, N, N);
+ bg.allocPixels();
+
+ SkAutoCanvasRestore acr(canvas, true);
+ for (int i = 0; i < 6; i++) {
+ bg.eraseColor(0);
+ SkCanvas c(bg);
+ c.scale(SK_Scalar1 / (1 << i), SK_Scalar1 / (1 << i));
+ c.drawBitmap(bitmap, 0, 0, NULL);
+
+ canvas->save();
+ canvas->scale(SkIntToScalar(1 << i), SkIntToScalar(1 << i));
+ canvas->drawBitmap(bg, 0, 0, NULL);
+ canvas->restore();
+ canvas->translate(SkIntToScalar(N + 8), 0);
+ }
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ canvas->translate(SkIntToScalar(10), SkIntToScalar(10));
+
+ canvas->scale(1.00000001f, 0.9999999f);
+
+ drawN2(canvas, fBitmap);
+
+ canvas->translate(0, SkIntToScalar(N + 8));
+ SkBitmap bitmap(fBitmap);
+ bitmap.buildMipMap();
+ drawN2(canvas, bitmap);
+
+ SkScalar time = SampleCode::GetAnimScalar(SkIntToScalar(1)/4,
+ SkIntToScalar(2));
+ if (time >= SK_Scalar1) {
+ time = SkIntToScalar(2) - time;
+ }
+ fWidth = 8 + SkScalarRound(N * time);
+
+ SkRect dst;
+ dst.set(0, 0, SkIntToScalar(fWidth), SkIntToScalar(fWidth));
+
+ SkPaint paint;
+ paint.setFilterBitmap(true);
+ paint.setAntiAlias(true);
+
+ canvas->translate(0, SkIntToScalar(N + 8));
+ canvas->drawBitmapRect(fBitmap, NULL, dst, NULL);
+ canvas->translate(SkIntToScalar(N + 8), 0);
+ canvas->drawBitmapRect(fBitmap, NULL, dst, &paint);
+ canvas->translate(-SkIntToScalar(N + 8), SkIntToScalar(N + 8));
+ canvas->drawBitmapRect(bitmap, NULL, dst, NULL);
+ canvas->translate(SkIntToScalar(N + 8), 0);
+ canvas->drawBitmapRect(bitmap, NULL, dst, &paint);
+
+ SkShader* s = SkShader::CreateBitmapShader(bitmap,
+ SkShader::kRepeat_TileMode,
+ SkShader::kRepeat_TileMode);
+ paint.setShader(s)->unref();
+ SkMatrix m;
+ m.setScale(SkIntToScalar(fWidth) / N,
+ SkIntToScalar(fWidth) / N);
+ s->setLocalMatrix(m);
+ SkRect r;
+ r.set(0, 0, SkIntToScalar(4*N), SkIntToScalar(5*N/2));
+ r.offset(SkIntToScalar(N + 12), -SkIntToScalar(N + 4));
+ canvas->drawRect(r, paint);
+
+ this->inval(NULL);
+ }
+
+private:
+ int fWidth;
+
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new MipMapView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleMovie.cpp b/samplecode/SampleMovie.cpp
new file mode 100644
index 0000000..af34198
--- /dev/null
+++ b/samplecode/SampleMovie.cpp
@@ -0,0 +1,61 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkMovie.h"
+#include "SkTime.h"
+#include <new>
+
+class AnimGifView : public SkView {
+ SkMovie* fMovie;
+public:
+ AnimGifView() {
+ fMovie = SkMovie::DecodeFile("/skimages/dollarblk.gif");
+ }
+
+ virtual ~AnimGifView() {
+ SkSafeUnref(fMovie);
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "Animated Gif");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ void drawBG(SkCanvas* canvas) {
+ canvas->drawColor(0xFFDDDDDD);
+ }
+
+ virtual void onDraw(SkCanvas* canvas) {
+ this->drawBG(canvas);
+
+ if (fMovie) {
+ if (fMovie->duration()) {
+ fMovie->setTime(SkTime::GetMSecs() % fMovie->duration());
+ } else {
+ fMovie->setTime(0);
+ }
+ canvas->drawBitmap(fMovie->bitmap(), SkIntToScalar(20),
+ SkIntToScalar(20));
+ this->inval(NULL);
+ }
+ }
+
+private:
+ SkRect fClip;
+ SkIPoint* fPoints;
+ SkPath fPath;
+ int fPtCount;
+
+ typedef SkView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new AnimGifView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleNinePatch.cpp b/samplecode/SampleNinePatch.cpp
new file mode 100644
index 0000000..e158287
--- /dev/null
+++ b/samplecode/SampleNinePatch.cpp
@@ -0,0 +1,114 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkImageDecoder.h"
+#include "SkNinePatch.h"
+#include "SkPaint.h"
+#include "SkUnPreMultiply.h"
+
+class NinePatchView : public SampleView {
+public:
+ SkBitmap fBM;
+
+ NinePatchView() {
+ SkImageDecoder::DecodeFile("/skimages/btn_default_normal_disable.9.png", &fBM);
+
+ // trim off the edge guide-lines
+ SkBitmap tmp;
+ SkIRect r;
+ r.set(1, 1, fBM.width() - 1, fBM.height() - 1);
+ fBM.extractSubset(&tmp, r);
+ fBM.swap(tmp);
+
+ fX = SkIntToScalar(fBM.width());
+ fY = 0;
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "NinePatch");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ virtual void onDrawBackground(SkCanvas* canvas) {
+ SkPaint p;
+ p.setDither(true);
+ p.setColor(0xFF909090);
+ canvas->drawPaint(p);
+ }
+
+ static void test_rects(SkCanvas* canvas, const SkBitmap& bm, const SkPaint* paint) {
+ static const SkIRect src[] = {
+ { 0, 0, 18, 34 },
+ { 18, 0, 19, 34 },
+ { 19, 0, 36, 34 },
+ { 0, 34, 18, 35 },
+ { 18, 34, 19, 35 },
+ { 19, 34, 36, 35 },
+ { 0, 35, 18, 72 },
+ { 18, 35, 19, 72 },
+ { 19, 35, 36, 72 },
+ };
+ static const SkRect dst[] = {
+ { 0, 0, 18, 34 },
+ { 18, 0, 283, 34 },
+ { 283, 0, 300, 34 },
+ { 0, 34, 18, 163 },
+ { 18, 34, 283, 163 },
+ { 283, 34, 300, 163 },
+ { 0, 163, 18, 200 },
+ { 18, 163, 283, 200 },
+ { 283, 163, 300, 200 },
+ };
+ for (size_t i = 0; i < SK_ARRAY_COUNT(src); i++) {
+ canvas->drawBitmapRect(bm, &src[i], dst[i], paint);
+ }
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ canvas->drawBitmap(fBM, 0, 0);
+
+ SkIRect margins;
+ SkRect dst;
+ int d = 25;
+
+ margins.set(d, d, d, d);
+ margins.fLeft = fBM.width()/2 - 1;
+ margins.fTop = fBM.height()/2 - 1;
+ margins.fRight = fBM.width() - margins.fLeft - 1;
+ margins.fBottom = fBM.height() - margins.fTop - 1;
+
+ // canvas->translate(fX/5, fY/5);
+ canvas->translate(0, 76);
+
+ dst.set(0, 0, SkIntToScalar(200), SkIntToScalar(200));
+
+ SkPaint paint;
+ paint.setAntiAlias(false);
+ paint.setDither(true);
+ paint.setFilterBitmap(false);
+ // SkNinePatch::DrawNine(canvas, dst, fBM, margins, &paint);
+ test_rects(canvas, fBM, &paint);
+ }
+
+ virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
+ fX = x / 1.5f;
+ fY = y / 1.5f;
+ fX = x; fY = y;
+ this->inval(NULL);
+ return this->INHERITED::onFindClickHandler(x, y);
+ }
+private:
+ SkScalar fX, fY;
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new NinePatchView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleOvalTest.cpp b/samplecode/SampleOvalTest.cpp
new file mode 100644
index 0000000..f625529
--- /dev/null
+++ b/samplecode/SampleOvalTest.cpp
@@ -0,0 +1,110 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+
+static const int kILimit = 101;
+static const SkScalar kLimit = SK_Scalar1 * kILimit;
+
+class OvalTestView : public SampleView {
+public:
+ SkSize fSize;
+ SkPMColor fInsideColor; // signals an interior pixel that was not set
+ SkPMColor fOutsideColor; // signals an exterior pixels that was set
+ SkBitmap fBitmap;
+
+ OvalTestView() {
+ fSize.set(SK_Scalar1, SK_Scalar1);
+
+ fBitmap.setConfig(SkBitmap::kARGB_8888_Config, kILimit, kILimit);
+ fBitmap.allocPixels();
+
+ fInsideColor = SkPreMultiplyColor(SK_ColorRED);
+ fOutsideColor = SkPreMultiplyColor(SK_ColorGREEN);
+
+ this->setBGColor(0xFFDDDDDD);
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "OvalTest");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ void drawOval() {
+ SkCanvas canvas(fBitmap);
+ SkPaint p;
+
+ fBitmap.eraseColor(0);
+ canvas.drawOval(SkRect::MakeSize(fSize), p);
+ }
+
+ int checkOval(int* flatCount, int* buldgeCount) {
+ int flatc = 0;
+ int buldgec = 0;
+ const SkScalar rad = SkScalarHalf(fSize.width());
+ SkScalar cx = SkScalarHalf(fSize.width());
+ SkScalar cy = SkScalarHalf(fSize.height());
+ for (int y = 0; y < kILimit; y++) {
+ for (int x = 0; x < kILimit; x++) {
+ // measure from pixel centers
+ SkScalar px = SkIntToScalar(x) + SK_ScalarHalf;
+ SkScalar py = SkIntToScalar(y) + SK_ScalarHalf;
+
+ SkPMColor* ptr = fBitmap.getAddr32(x, y);
+ SkScalar dist = SkPoint::Length(px - cx, py - cy);
+ if (dist <= rad && !*ptr) {
+ flatc++;
+ *ptr = fInsideColor;
+ } else if (dist > rad && *ptr) {
+ buldgec++;
+ *ptr = fOutsideColor;
+ }
+ }
+ }
+ if (flatCount) *flatCount = flatc;
+ if (buldgeCount) *buldgeCount = buldgec;
+ return flatc + buldgec;
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ this->drawOval();
+ int flatCount, buldgeCount;
+ this->checkOval(&flatCount, &buldgeCount);
+ this->inval(NULL);
+
+ canvas->drawBitmap(fBitmap, SkIntToScalar(20), SkIntToScalar(20), NULL);
+
+
+ static int gFlatCount;
+ static int gBuldgeCount;
+ gFlatCount += flatCount;
+ gBuldgeCount += buldgeCount;
+
+ if (fSize.fWidth < kLimit) {
+ SkDebugf("--- width=%g, flat=%d buldge=%d total: flat=%d buldge=%d\n", fSize.fWidth,
+ flatCount, buldgeCount, gFlatCount, gBuldgeCount);
+ fSize.fWidth += SK_Scalar1;
+ fSize.fHeight += SK_Scalar1;
+ } else {
+ // fSize.set(SK_Scalar1, SK_Scalar1);
+ }
+ }
+
+ virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
+ this->inval(NULL);
+ return NULL;
+ }
+
+private:
+ typedef SampleView INHERITED;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new OvalTestView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleOverflow.cpp b/samplecode/SampleOverflow.cpp
new file mode 100644
index 0000000..d3ecff7
--- /dev/null
+++ b/samplecode/SampleOverflow.cpp
@@ -0,0 +1,100 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkDevice.h"
+#include "SkPaint.h"
+
+static void DrawRoundRect() {
+#ifdef SK_SCALAR_IS_FIXED
+ bool ret = false;
+ SkPaint paint;
+ SkBitmap bitmap;
+ SkCanvas canvas;
+ SkMatrix matrix;
+ matrix.reset();
+
+ bitmap.setConfig(SkBitmap::kARGB_8888_Config, 1370, 812);
+ bitmap.allocPixels();
+ canvas.setBitmapDevice(bitmap);
+
+ // set up clipper
+ SkRect skclip;
+ skclip.set(SkIntToFixed(284), SkIntToFixed(40), SkIntToFixed(1370), SkIntToFixed(708));
+
+ ret = canvas.clipRect(skclip);
+ SkASSERT(ret);
+
+ matrix.set(SkMatrix::kMTransX, SkFloatToFixed(-1153.28));
+ matrix.set(SkMatrix::kMTransY, SkFloatToFixed(1180.50));
+
+ matrix.set(SkMatrix::kMScaleX, SkFloatToFixed(0.177171));
+ matrix.set(SkMatrix::kMScaleY, SkFloatToFixed(0.177043));
+
+ matrix.set(SkMatrix::kMSkewX, SkFloatToFixed(0.126968));
+ matrix.set(SkMatrix::kMSkewY, SkFloatToFixed(-0.126876));
+
+ matrix.set(SkMatrix::kMPersp0, SkFloatToFixed(0.0));
+ matrix.set(SkMatrix::kMPersp1, SkFloatToFixed(0.0));
+
+ ret = canvas.concat(matrix);
+
+ paint.setAntiAlias(true);
+ paint.setColor(0xb2202020);
+ paint.setStyle(SkPaint::kStroke_Style);
+ paint.setStrokeWidth(SkFloatToFixed(68.13));
+
+ SkRect r;
+ r.set(SkFloatToFixed(-313.714417), SkFloatToFixed(-4.826389), SkFloatToFixed(18014.447266), SkFloatToFixed(1858.154541));
+ canvas.drawRoundRect(r, SkFloatToFixed(91.756363), SkFloatToFixed(91.756363), paint);
+#endif
+}
+
+static bool HitTestPath(const SkPath& path, SkScalar x, SkScalar y) {
+ SkRegion rgn, clip;
+
+ int ix = SkScalarFloor(x);
+ int iy = SkScalarFloor(y);
+
+ clip.setRect(ix, iy, ix + 1, iy + 1);
+
+ bool contains = rgn.setPath(path, clip);
+ return contains;
+}
+
+static void TestOverflowHitTest() {
+ SkPath path;
+
+#ifdef SK_SCALAR_IS_FLOATx
+ path.addCircle(0, 0, 70000, SkPath::kCCW_Direction);
+ SkASSERT(HitTestPath(path, 40000, 40000));
+#endif
+}
+
+class OverflowView : public SampleView {
+public:
+ OverflowView() {}
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "Circles");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ DrawRoundRect();
+ TestOverflowHitTest();
+ }
+
+private:
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new OverflowView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SamplePageFlip.cpp b/samplecode/SamplePageFlip.cpp
new file mode 100644
index 0000000..7c5bf48
--- /dev/null
+++ b/samplecode/SamplePageFlip.cpp
@@ -0,0 +1,167 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkGraphics.h"
+#include "SkRandom.h"
+#include "SkFlipPixelRef.h"
+#include "SkPageFlipper.h"
+
+#include <pthread.h>
+
+#define WIDTH 200
+#define HEIGHT 200
+
+static bool gDone;
+
+static void bounce(SkScalar* x, SkScalar* dx, const int max) {
+ *x += *dx;
+ if (*x < 0) {
+ *x = 0;
+ if (*dx < 0) {
+ *dx = -*dx;
+ }
+ } else if (*x > SkIntToScalar(max)) {
+ *x = SkIntToScalar(max);
+ if (*dx > 0) {
+ *dx = -*dx;
+ }
+ }
+}
+
+static void* draw_proc(void* context) {
+ const int OVALW = 32;
+ const int OVALH = 32;
+
+ const SkBitmap* bm = static_cast<const SkBitmap*>(context);
+ SkFlipPixelRef* ref = static_cast<SkFlipPixelRef*>(bm->pixelRef());
+
+ const int DSCALE = 1;
+ SkScalar dx = SkIntToScalar(7) / DSCALE;
+ SkScalar dy = SkIntToScalar(5) / DSCALE;
+ SkScalar x = 0;
+ SkScalar y = 0;
+
+ SkPaint paint;
+
+ paint.setAntiAlias(true);
+ paint.setColor(SK_ColorRED);
+
+ SkRect oval;
+ oval.setEmpty();
+
+ while (!gDone) {
+ ref->inval(oval, true);
+ oval.set(x, y, x + SkIntToScalar(OVALW), y + SkIntToScalar(OVALH));
+ ref->inval(oval, true);
+
+ SkAutoFlipUpdate update(ref);
+
+ if (!update.dirty().isEmpty()) {
+ // this must be local to the loop, since it needs to forget the pixels
+ // its writing to after each iteration, since we do the swap
+ SkCanvas canvas(update.bitmap());
+
+// SkDebugf("----- dirty [%d %d %d %d]\n", dirty.getBounds().fLeft, dirty.getBounds().fTop, dirty.getBounds().width(), dirty.getBounds().height());
+ canvas.clipRegion(update.dirty());
+
+ canvas.drawColor(0, SkXfermode::kClear_Mode);
+ canvas.drawOval(oval, paint);
+ }
+ bounce(&x, &dx, WIDTH-OVALW);
+ bounce(&y, &dy, HEIGHT-OVALH);
+
+#if 1
+ for (int i = 0; i < 1000; i++) {
+ for (int j = 0; j < 10000; j++) {
+ SkFixedMul(j, 10);
+ }
+ }
+#endif
+ }
+ return NULL;
+}
+
+static const SkBitmap::Config gConfigs[] = {
+ SkBitmap::kARGB_8888_Config,
+#if 1
+ SkBitmap::kRGB_565_Config,
+ SkBitmap::kARGB_4444_Config,
+ SkBitmap::kA8_Config
+#endif
+};
+
+class PageFlipView : public SampleView {
+public:
+
+ enum { N = SK_ARRAY_COUNT(gConfigs) };
+
+ pthread_t fThreads[N];
+ SkBitmap fBitmaps[N];
+
+ PageFlipView() {
+ gDone = false;
+ for (int i = 0; i < N; i++) {
+ int status;
+ pthread_attr_t attr;
+
+ status = pthread_attr_init(&attr);
+ SkASSERT(0 == status);
+
+ fBitmaps[i].setConfig(gConfigs[i], WIDTH, HEIGHT);
+ SkFlipPixelRef* pr = new SkFlipPixelRef(gConfigs[i], WIDTH, HEIGHT);
+ fBitmaps[i].setPixelRef(pr)->unref();
+ fBitmaps[i].eraseColor(0);
+
+ status = pthread_create(&fThreads[i], &attr, draw_proc, &fBitmaps[i]);
+ SkASSERT(0 == status);
+ }
+ this->setBGColor(0xFFDDDDDD);
+ }
+
+ virtual ~PageFlipView() {
+ gDone = true;
+ for (int i = 0; i < N; i++) {
+ void* ret;
+ int status = pthread_join(fThreads[i], &ret);
+ SkASSERT(0 == status);
+ }
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "PageFlip");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ SkScalar x = SkIntToScalar(10);
+ SkScalar y = SkIntToScalar(10);
+ for (int i = 0; i < N; i++) {
+ canvas->drawBitmap(fBitmaps[i], x, y);
+ x += SkIntToScalar(fBitmaps[i].width() + 20);
+ }
+ this->inval(NULL);
+ }
+
+ virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
+ this->inval(NULL);
+ return this->INHERITED::onFindClickHandler(x, y);
+ }
+
+ virtual bool onClick(Click* click) {
+ return this->INHERITED::onClick(click);
+ }
+
+private:
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new PageFlipView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SamplePatch.cpp b/samplecode/SamplePatch.cpp
new file mode 100644
index 0000000..ea365c7
--- /dev/null
+++ b/samplecode/SamplePatch.cpp
@@ -0,0 +1,342 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkGradientShader.h"
+#include "SkGraphics.h"
+#include "SkImageDecoder.h"
+#include "SkPath.h"
+#include "SkRandom.h"
+#include "SkRegion.h"
+#include "SkShader.h"
+#include "SkUtils.h"
+#include "SkXfermode.h"
+#include "SkColorPriv.h"
+#include "SkColorFilter.h"
+#include "SkTime.h"
+#include "SkTypeface.h"
+
+#include "SkOSFile.h"
+#include "SkStream.h"
+
+#include "SkGeometry.h" // private include :(
+
+static void drawtriangle(SkCanvas* canvas, const SkPaint& paint,
+ const SkPoint pts[3]) {
+ SkPath path;
+
+ path.moveTo(pts[0]);
+ path.lineTo(pts[1]);
+ path.lineTo(pts[2]);
+
+ canvas->drawPath(path, paint);
+}
+
+static SkShader* make_shader0(SkIPoint* size) {
+ SkBitmap bm;
+
+// SkImageDecoder::DecodeFile("/skimages/progressivejpg.jpg", &bm);
+ SkImageDecoder::DecodeFile("/skimages/logo.png", &bm);
+ size->set(bm.width(), bm.height());
+ return SkShader::CreateBitmapShader(bm, SkShader::kClamp_TileMode,
+ SkShader::kClamp_TileMode);
+}
+
+static SkShader* make_shader1(const SkIPoint& size) {
+ SkPoint pts[] = { { 0, 0, },
+ { SkIntToScalar(size.fX), SkIntToScalar(size.fY) } };
+ SkColor colors[] = { SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorRED };
+ return SkGradientShader::CreateLinear(pts, colors, NULL,
+ SK_ARRAY_COUNT(colors), SkShader::kMirror_TileMode, NULL);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+class Patch {
+public:
+ Patch() { sk_bzero(fPts, sizeof(fPts)); }
+ ~Patch() {}
+
+ void setPatch(const SkPoint pts[12]) {
+ memcpy(fPts, pts, 12 * sizeof(SkPoint));
+ fPts[12] = pts[0]; // the last shall be first
+ }
+ void setBounds(int w, int h) { fW = w; fH = h; }
+
+ void draw(SkCanvas*, const SkPaint&, int segsU, int segsV,
+ bool doTextures, bool doColors);
+
+private:
+ SkPoint fPts[13];
+ int fW, fH;
+};
+
+static void eval_patch_edge(const SkPoint cubic[], SkPoint samples[], int segs) {
+ SkScalar t = 0;
+ SkScalar dt = SK_Scalar1 / segs;
+
+ samples[0] = cubic[0];
+ for (int i = 1; i < segs; i++) {
+ t += dt;
+ SkEvalCubicAt(cubic, t, &samples[i], NULL, NULL);
+ }
+}
+
+static void eval_sheet(const SkPoint edge[], int nu, int nv, int iu, int iv,
+ SkPoint* pt) {
+ const int TL = 0;
+ const int TR = nu;
+ const int BR = TR + nv;
+ const int BL = BR + nu;
+
+ SkScalar u = SkIntToScalar(iu) / nu;
+ SkScalar v = SkIntToScalar(iv) / nv;
+
+ SkScalar uv = SkScalarMul(u, v);
+ SkScalar Uv = SkScalarMul(SK_Scalar1 - u, v);
+ SkScalar uV = SkScalarMul(u, SK_Scalar1 - v);
+ SkScalar UV = SkScalarMul(SK_Scalar1 - u, SK_Scalar1 - v);
+
+ SkScalar x0 = SkScalarMul(UV, edge[TL].fX) + SkScalarMul(uV, edge[TR].fX) +
+ SkScalarMul(Uv, edge[BL].fX) + SkScalarMul(uv, edge[BR].fX);
+ SkScalar y0 = SkScalarMul(UV, edge[TL].fY) + SkScalarMul(uV, edge[TR].fY) +
+ SkScalarMul(Uv, edge[BL].fY) + SkScalarMul(uv, edge[BR].fY);
+
+ SkScalar x = SkScalarMul(SK_Scalar1 - v, edge[TL+iu].fX) +
+ SkScalarMul(u, edge[TR+iv].fX) +
+ SkScalarMul(v, edge[BR+nu-iu].fX) +
+ SkScalarMul(SK_Scalar1 - u, edge[BL+nv-iv].fX) - x0;
+ SkScalar y = SkScalarMul(SK_Scalar1 - v, edge[TL+iu].fY) +
+ SkScalarMul(u, edge[TR+iv].fY) +
+ SkScalarMul(v, edge[BR+nu-iu].fY) +
+ SkScalarMul(SK_Scalar1 - u, edge[BL+nv-iv].fY) - y0;
+ pt->set(x, y);
+}
+
+static int ScalarTo255(SkScalar v) {
+ int scale = SkScalarToFixed(v) >> 8;
+ if (scale < 0) {
+ scale = 0;
+ } else if (scale > 255) {
+ scale = 255;
+ }
+ return scale;
+}
+
+static SkColor make_color(SkScalar s, SkScalar t) {
+ int cs = ScalarTo255(s);
+ int ct = ScalarTo255(t);
+ return SkColorSetARGB(0xFF, cs, 0, 0) + SkColorSetARGB(0, 0, ct, 0);
+}
+
+void Patch::draw(SkCanvas* canvas, const SkPaint& paint, int nu, int nv,
+ bool doTextures, bool doColors) {
+ if (nu < 1 || nv < 1) {
+ return;
+ }
+
+ int i, npts = (nu + nv) * 2;
+ SkAutoSTMalloc<16, SkPoint> storage(npts + 1);
+ SkPoint* edge0 = storage.get();
+ SkPoint* edge1 = edge0 + nu;
+ SkPoint* edge2 = edge1 + nv;
+ SkPoint* edge3 = edge2 + nu;
+
+ // evaluate the edge points
+ eval_patch_edge(fPts + 0, edge0, nu);
+ eval_patch_edge(fPts + 3, edge1, nv);
+ eval_patch_edge(fPts + 6, edge2, nu);
+ eval_patch_edge(fPts + 9, edge3, nv);
+ edge3[nv] = edge0[0]; // the last shall be first
+
+ for (i = 0; i < npts; i++) {
+// canvas->drawLine(edge0[i].fX, edge0[i].fY, edge0[i+1].fX, edge0[i+1].fY, paint);
+ }
+
+ int row, vertCount = (nu + 1) * (nv + 1);
+ SkAutoTMalloc<SkPoint> vertStorage(vertCount);
+ SkPoint* verts = vertStorage.get();
+
+ // first row
+ memcpy(verts, edge0, (nu + 1) * sizeof(SkPoint));
+ // rows
+ SkPoint* r = verts;
+ for (row = 1; row < nv; row++) {
+ r += nu + 1;
+ r[0] = edge3[nv - row];
+ for (int col = 1; col < nu; col++) {
+ eval_sheet(edge0, nu, nv, col, row, &r[col]);
+ }
+ r[nu] = edge1[row];
+ }
+ // last row
+ SkPoint* last = verts + nv * (nu + 1);
+ for (i = 0; i <= nu; i++) {
+ last[i] = edge2[nu - i];
+ }
+
+// canvas->drawPoints(verts, vertCount, paint);
+
+ int stripCount = (nu + 1) * 2;
+ SkAutoTMalloc<SkPoint> stripStorage(stripCount * 2);
+ SkAutoTMalloc<SkColor> colorStorage(stripCount);
+ SkPoint* strip = stripStorage.get();
+ SkPoint* tex = strip + stripCount;
+ SkColor* colors = colorStorage.get();
+ SkScalar t = 0;
+ const SkScalar ds = SK_Scalar1 * fW / nu;
+ const SkScalar dt = SK_Scalar1 * fH / nv;
+ r = verts;
+ for (row = 0; row < nv; row++) {
+ SkPoint* upper = r;
+ SkPoint* lower = r + nu + 1;
+ r = lower;
+ SkScalar s = 0;
+ for (i = 0; i <= nu; i++) {
+ strip[i*2 + 0] = *upper++;
+ strip[i*2 + 1] = *lower++;
+ tex[i*2 + 0].set(s, t);
+ tex[i*2 + 1].set(s, t + dt);
+ colors[i*2 + 0] = make_color(s/fW, t/fH);
+ colors[i*2 + 1] = make_color(s/fW, (t + dt)/fH);
+ s += ds;
+ }
+ t += dt;
+ canvas->drawVertices(SkCanvas::kTriangleStrip_VertexMode, stripCount,
+ strip, doTextures ? tex : NULL,
+ doColors ? colors : NULL, NULL,
+ NULL, 0, paint);
+ }
+}
+
+static void drawpatches(SkCanvas* canvas, const SkPaint& paint, int nu, int nv,
+ Patch* patch) {
+
+ SkAutoCanvasRestore ar(canvas, true);
+
+ patch->draw(canvas, paint, 10, 10, false, false);
+ canvas->translate(SkIntToScalar(180), 0);
+ patch->draw(canvas, paint, 10, 10, true, false);
+ canvas->translate(SkIntToScalar(180), 0);
+ patch->draw(canvas, paint, 10, 10, false, true);
+ canvas->translate(SkIntToScalar(180), 0);
+ patch->draw(canvas, paint, 10, 10, true, true);
+}
+
+class PatchView : public SampleView {
+ SkShader* fShader0;
+ SkShader* fShader1;
+ SkIPoint fSize0, fSize1;
+ SkPoint fPts[12];
+
+public:
+ PatchView() {
+ fShader0 = make_shader0(&fSize0);
+ fSize1 = fSize0;
+ if (fSize0.fX == 0 || fSize0.fY == 0) {
+ fSize1.set(2, 2);
+ }
+ fShader1 = make_shader1(fSize1);
+
+ const SkScalar S = SkIntToScalar(50);
+ const SkScalar T = SkIntToScalar(40);
+ fPts[0].set(S*0, T);
+ fPts[1].set(S*1, T);
+ fPts[2].set(S*2, T);
+ fPts[3].set(S*3, T);
+ fPts[4].set(S*3, T*2);
+ fPts[5].set(S*3, T*3);
+ fPts[6].set(S*3, T*4);
+ fPts[7].set(S*2, T*4);
+ fPts[8].set(S*1, T*4);
+ fPts[9].set(S*0, T*4);
+ fPts[10].set(S*0, T*3);
+ fPts[11].set(S*0, T*2);
+
+ this->setBGColor(SK_ColorGRAY);
+ }
+
+ virtual ~PatchView() {
+ SkSafeUnref(fShader0);
+ SkSafeUnref(fShader1);
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt))
+ {
+ SkString str("Patch");
+ SampleCode::TitleR(evt, str.c_str());
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ SkPaint paint;
+ paint.setDither(true);
+ paint.setFilterBitmap(true);
+
+ canvas->translate(SkIntToScalar(20), 0);
+
+ Patch patch;
+
+ paint.setShader(fShader0);
+ if (fSize0.fX == 0) {
+ fSize0.fX = 1;
+ }
+ if (fSize0.fY == 0) {
+ fSize0.fY = 1;
+ }
+ patch.setBounds(fSize0.fX, fSize0.fY);
+
+ patch.setPatch(fPts);
+ drawpatches(canvas, paint, 10, 10, &patch);
+
+ paint.setShader(NULL);
+ paint.setAntiAlias(true);
+ paint.setStrokeWidth(SkIntToScalar(5));
+ canvas->drawPoints(SkCanvas::kPoints_PointMode, SK_ARRAY_COUNT(fPts), fPts, paint);
+
+ canvas->translate(0, SkIntToScalar(300));
+
+ paint.setAntiAlias(false);
+ paint.setShader(fShader1);
+ patch.setBounds(fSize1.fX, fSize1.fY);
+ drawpatches(canvas, paint, 10, 10, &patch);
+ }
+
+ class PtClick : public Click {
+ public:
+ int fIndex;
+ PtClick(SkView* view, int index) : Click(view), fIndex(index) {}
+ };
+
+ static bool hittest(const SkPoint& pt, SkScalar x, SkScalar y) {
+ return SkPoint::Length(pt.fX - x, pt.fY - y) < SkIntToScalar(5);
+ }
+
+ virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
+ for (size_t i = 0; i < SK_ARRAY_COUNT(fPts); i++) {
+ if (hittest(fPts[i], x, y)) {
+ return new PtClick(this, i);
+ }
+ }
+ return this->INHERITED::onFindClickHandler(x, y);
+ }
+
+ virtual bool onClick(Click* click) {
+ fPts[((PtClick*)click)->fIndex].set(click->fCurr.fX, click->fCurr.fY);
+ this->inval(NULL);
+ return true;
+ }
+
+private:
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new PatchView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SamplePath.cpp b/samplecode/SamplePath.cpp
new file mode 100644
index 0000000..cd45ed9
--- /dev/null
+++ b/samplecode/SamplePath.cpp
@@ -0,0 +1,200 @@
+
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkGradientShader.h"
+#include "SkGraphics.h"
+#include "SkImageDecoder.h"
+#include "SkPath.h"
+#include "SkRegion.h"
+#include "SkShader.h"
+#include "SkUtils.h"
+#include "SkXfermode.h"
+#include "SkColorPriv.h"
+#include "SkColorFilter.h"
+#include "SkParsePath.h"
+#include "SkTime.h"
+#include "SkTypeface.h"
+
+#include "SkGeometry.h"
+
+// http://code.google.com/p/skia/issues/detail?id=32
+static void test_cubic() {
+ SkPoint src[4] = {
+ { 556.25000f, 523.03003f },
+ { 556.23999f, 522.96002f },
+ { 556.21997f, 522.89001f },
+ { 556.21997f, 522.82001f }
+ };
+ SkPoint dst[11];
+ dst[10].set(42, -42); // one past the end, that we don't clobber these
+ SkScalar tval[] = { 0.33333334f, 0.99999994f };
+
+ SkChopCubicAt(src, dst, tval, 2);
+
+#if 0
+ for (int i = 0; i < 11; i++) {
+ SkDebugf("--- %d [%g %g]\n", i, dst[i].fX, dst[i].fY);
+ }
+#endif
+}
+
+static void test_cubic2() {
+ const char* str = "M2242 -590088L-377758 9.94099e+07L-377758 9.94099e+07L2242 -590088Z";
+ SkPath path;
+ SkParsePath::FromSVGString(str, &path);
+
+ {
+#ifdef SK_BUILD_FOR_WIN
+ // windows doesn't have strtof
+ float x = (float)strtod("9.94099e+07", NULL);
+#else
+ float x = strtof("9.94099e+07", NULL);
+#endif
+ int ix = (int)x;
+ int fx = (int)(x * 65536);
+ int ffx = SkScalarToFixed(x);
+ printf("%g %x %x %x\n", x, ix, fx, ffx);
+
+ SkRect r = path.getBounds();
+ SkIRect ir;
+ r.round(&ir);
+ printf("[%g %g %g %g] [%x %x %x %x]\n",
+ r.fLeft, r.fTop, r.fRight, r.fBottom,
+ ir.fLeft, ir.fTop, ir.fRight, ir.fBottom);
+ }
+
+ SkBitmap bitmap;
+ bitmap.setConfig(SkBitmap::kARGB_8888_Config, 300, 200);
+ bitmap.allocPixels();
+
+ SkCanvas canvas(bitmap);
+ SkPaint paint;
+ paint.setAntiAlias(true);
+ canvas.drawPath(path, paint);
+}
+
+class PathView : public SampleView {
+public:
+ int fDStroke, fStroke, fMinStroke, fMaxStroke;
+ SkPath fPath[6];
+ bool fShowHairline;
+
+ PathView() {
+ test_cubic();
+ test_cubic2();
+
+ fShowHairline = false;
+
+ fDStroke = 1;
+ fStroke = 10;
+ fMinStroke = 10;
+ fMaxStroke = 180;
+
+ const int V = 85;
+
+ fPath[0].moveTo(SkIntToScalar(40), SkIntToScalar(70));
+ fPath[0].lineTo(SkIntToScalar(70), SkIntToScalar(70) + SK_Scalar1/1);
+ fPath[0].lineTo(SkIntToScalar(110), SkIntToScalar(70));
+
+ fPath[1].moveTo(SkIntToScalar(40), SkIntToScalar(70));
+ fPath[1].lineTo(SkIntToScalar(70), SkIntToScalar(70) - SK_Scalar1/1);
+ fPath[1].lineTo(SkIntToScalar(110), SkIntToScalar(70));
+
+ fPath[2].moveTo(SkIntToScalar(V), SkIntToScalar(V));
+ fPath[2].lineTo(SkIntToScalar(50), SkIntToScalar(V));
+ fPath[2].lineTo(SkIntToScalar(50), SkIntToScalar(50));
+
+ fPath[3].moveTo(SkIntToScalar(50), SkIntToScalar(50));
+ fPath[3].lineTo(SkIntToScalar(50), SkIntToScalar(V));
+ fPath[3].lineTo(SkIntToScalar(V), SkIntToScalar(V));
+
+ fPath[4].moveTo(SkIntToScalar(50), SkIntToScalar(50));
+ fPath[4].lineTo(SkIntToScalar(50), SkIntToScalar(V));
+ fPath[4].lineTo(SkIntToScalar(52), SkIntToScalar(50));
+
+ fPath[5].moveTo(SkIntToScalar(52), SkIntToScalar(50));
+ fPath[5].lineTo(SkIntToScalar(50), SkIntToScalar(V));
+ fPath[5].lineTo(SkIntToScalar(50), SkIntToScalar(50));
+
+ this->setBGColor(0xFFDDDDDD);
+ }
+
+ void nextStroke() {
+ fStroke += fDStroke;
+ if (fStroke > fMaxStroke || fStroke < fMinStroke)
+ fDStroke = -fDStroke;
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "Paths");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ void drawPath(SkCanvas* canvas, const SkPath& path, SkPaint::Join j) {
+ SkPaint paint;
+
+ paint.setAntiAlias(true);
+ paint.setStyle(SkPaint::kStroke_Style);
+ paint.setStrokeJoin(j);
+ paint.setStrokeWidth(SkIntToScalar(fStroke));
+
+ if (fShowHairline) {
+ SkPath fill;
+
+ paint.getFillPath(path, &fill);
+ paint.setStrokeWidth(0);
+ canvas->drawPath(fill, paint);
+ } else {
+ canvas->drawPath(path, paint);
+ }
+
+ paint.setColor(SK_ColorRED);
+ paint.setStrokeWidth(0);
+ canvas->drawPath(path, paint);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ canvas->translate(SkIntToScalar(50), SkIntToScalar(50));
+
+ static const SkPaint::Join gJoins[] = {
+ SkPaint::kBevel_Join,
+ SkPaint::kMiter_Join,
+ SkPaint::kRound_Join
+ };
+
+ for (size_t i = 0; i < SK_ARRAY_COUNT(gJoins); i++) {
+ canvas->save();
+ for (size_t j = 0; j < SK_ARRAY_COUNT(fPath); j++) {
+ this->drawPath(canvas, fPath[j], gJoins[i]);
+ canvas->translate(SkIntToScalar(200), 0);
+ }
+ canvas->restore();
+
+ canvas->translate(0, SkIntToScalar(200));
+ }
+
+ this->nextStroke();
+ this->inval(NULL);
+ }
+
+ virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
+ fShowHairline = !fShowHairline;
+ this->inval(NULL);
+ return this->INHERITED::onFindClickHandler(x, y);
+ }
+
+private:
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new PathView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SamplePathClip.cpp b/samplecode/SamplePathClip.cpp
new file mode 100644
index 0000000..8139171
--- /dev/null
+++ b/samplecode/SamplePathClip.cpp
@@ -0,0 +1,84 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkGradientShader.h"
+#include "SkGraphics.h"
+#include "SkImageDecoder.h"
+#include "SkPath.h"
+#include "SkRegion.h"
+#include "SkShader.h"
+#include "SkUtils.h"
+#include "SkXfermode.h"
+#include "SkColorPriv.h"
+#include "SkColorFilter.h"
+#include "SkTime.h"
+#include "SkTypeface.h"
+
+class PathClipView : public SampleView {
+public:
+ SkRect fOval;
+ SkPoint fCenter;
+
+ PathClipView() {
+ fOval.set(0, 0, SkIntToScalar(200), SkIntToScalar(50));
+ fCenter.set(SkIntToScalar(250), SkIntToScalar(250));
+
+// test_ats();
+ }
+
+ virtual ~PathClipView() {}
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "PathClip");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ SkRect oval = fOval;
+ oval.offset(fCenter.fX - oval.centerX(), fCenter.fY - oval.centerY());
+
+ SkPaint p;
+ p.setAntiAlias(true);
+
+ p.setStyle(SkPaint::kStroke_Style);
+ canvas->drawOval(oval, p);
+
+ SkRect r;
+ r.set(SkIntToScalar(200), SkIntToScalar(200),
+ SkIntToScalar(300), SkIntToScalar(300));
+ canvas->clipRect(r);
+
+ p.setStyle(SkPaint::kFill_Style);
+ p.setColor(SK_ColorRED);
+ canvas->drawRect(r, p);
+
+ p.setColor(0x800000FF);
+ r.set(SkIntToScalar(150), SkIntToScalar(10),
+ SkIntToScalar(250), SkIntToScalar(400));
+ canvas->drawOval(oval, p);
+ }
+
+ virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
+ return new Click(this);
+ }
+
+ virtual bool onClick(Click* click) {
+ fCenter.set(click->fCurr.fX, click->fCurr.fY);
+ this->inval(NULL);
+ return NULL;
+ }
+
+private:
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new PathClipView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SamplePathEffects.cpp b/samplecode/SamplePathEffects.cpp
new file mode 100644
index 0000000..75566b0
--- /dev/null
+++ b/samplecode/SamplePathEffects.cpp
@@ -0,0 +1,184 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkGradientShader.h"
+#include "SkPath.h"
+#include "SkRegion.h"
+#include "SkShader.h"
+#include "SkUtils.h"
+#include "Sk1DPathEffect.h"
+#include "SkCornerPathEffect.h"
+#include "SkPathMeasure.h"
+#include "SkRandom.h"
+#include "SkColorPriv.h"
+#include "SkPixelXorXfermode.h"
+
+#define CORNER_RADIUS 12
+static SkScalar gPhase;
+
+static const int gXY[] = {
+ 4, 0, 0, -4, 8, -4, 12, 0, 8, 4, 0, 4
+};
+
+static SkPathEffect* make_pe(int flags) {
+ if (flags == 1)
+ return new SkCornerPathEffect(SkIntToScalar(CORNER_RADIUS));
+
+ SkPath path;
+ path.moveTo(SkIntToScalar(gXY[0]), SkIntToScalar(gXY[1]));
+ for (unsigned i = 2; i < SK_ARRAY_COUNT(gXY); i += 2)
+ path.lineTo(SkIntToScalar(gXY[i]), SkIntToScalar(gXY[i+1]));
+ path.close();
+ path.offset(SkIntToScalar(-6), 0);
+
+ SkPathEffect* outer = new SkPath1DPathEffect(path, SkIntToScalar(12), gPhase, SkPath1DPathEffect::kRotate_Style);
+
+ if (flags == 2)
+ return outer;
+
+ SkPathEffect* inner = new SkCornerPathEffect(SkIntToScalar(CORNER_RADIUS));
+
+ SkPathEffect* pe = new SkComposePathEffect(outer, inner);
+ outer->unref();
+ inner->unref();
+ return pe;
+}
+
+static SkPathEffect* make_warp_pe() {
+ SkPath path;
+ path.moveTo(SkIntToScalar(gXY[0]), SkIntToScalar(gXY[1]));
+ for (unsigned i = 2; i < SK_ARRAY_COUNT(gXY); i += 2)
+ path.lineTo(SkIntToScalar(gXY[i]), SkIntToScalar(gXY[i+1]));
+ path.close();
+ path.offset(SkIntToScalar(-6), 0);
+
+ SkPathEffect* outer = new SkPath1DPathEffect(path, SkIntToScalar(12), gPhase, SkPath1DPathEffect::kMorph_Style);
+ SkPathEffect* inner = new SkCornerPathEffect(SkIntToScalar(CORNER_RADIUS));
+
+ SkPathEffect* pe = new SkComposePathEffect(outer, inner);
+ outer->unref();
+ inner->unref();
+ return pe;
+}
+
+///////////////////////////////////////////////////////////
+
+#include "SkColorFilter.h"
+#include "SkLayerRasterizer.h"
+
+class testrast : public SkLayerRasterizer {
+public:
+ testrast() {
+ SkPaint paint;
+ paint.setAntiAlias(true);
+
+#if 0
+ paint.setStyle(SkPaint::kStroke_Style);
+ paint.setStrokeWidth(SK_Scalar1*4);
+ this->addLayer(paint);
+
+ paint.setStrokeWidth(SK_Scalar1*1);
+ paint.setXfermode(SkXfermode::kClear_Mode);
+ this->addLayer(paint);
+#else
+ paint.setAlpha(0x66);
+ this->addLayer(paint, SkIntToScalar(4), SkIntToScalar(4));
+
+ paint.setAlpha(0xFF);
+ this->addLayer(paint);
+#endif
+ }
+};
+
+class PathEffectView : public SampleView {
+ SkPath fPath;
+ SkPoint fClickPt;
+public:
+ PathEffectView() {
+ SkRandom rand;
+ int steps = 20;
+ SkScalar dist = SkIntToScalar(400);
+ SkScalar x = SkIntToScalar(20);
+ SkScalar y = SkIntToScalar(50);
+
+ fPath.moveTo(x, y);
+ for (int i = 0; i < steps; i++) {
+ x += dist/steps;
+ SkScalar tmpY = y + SkIntToScalar(rand.nextS() % 25);
+ if (i == steps/2) {
+ fPath.moveTo(x, tmpY);
+ } else {
+ fPath.lineTo(x, tmpY);
+ }
+ }
+
+ {
+ SkRect oval;
+ oval.set(SkIntToScalar(20), SkIntToScalar(30),
+ SkIntToScalar(100), SkIntToScalar(60));
+ oval.offset(x, 0);
+ fPath.addRoundRect(oval, SkIntToScalar(8), SkIntToScalar(8));
+ }
+
+ fClickPt.set(SkIntToScalar(200), SkIntToScalar(200));
+
+ this->setBGColor(0xFFDDDDDD);
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "PathEffects");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ gPhase -= SampleCode::GetAnimSecondsDelta() * 40;
+ this->inval(NULL);
+
+ SkPaint paint;
+
+#if 0
+ paint.setAntiAlias(true);
+ paint.setStyle(SkPaint::kStroke_Style);
+ paint.setStrokeWidth(SkIntToScalar(5));
+ canvas->drawPath(fPath, paint);
+ paint.setStrokeWidth(0);
+
+ paint.setColor(SK_ColorWHITE);
+ paint.setPathEffect(make_pe(1))->unref();
+ canvas->drawPath(fPath, paint);
+#endif
+
+ canvas->translate(0, SkIntToScalar(50));
+
+ paint.setColor(SK_ColorBLUE);
+ paint.setPathEffect(make_pe(2))->unref();
+ canvas->drawPath(fPath, paint);
+
+ canvas->translate(0, SkIntToScalar(50));
+
+ paint.setARGB(0xFF, 0, 0xBB, 0);
+ paint.setPathEffect(make_pe(3))->unref();
+ canvas->drawPath(fPath, paint);
+
+ canvas->translate(0, SkIntToScalar(50));
+
+ paint.setARGB(0xFF, 0, 0, 0);
+ paint.setPathEffect(make_warp_pe())->unref();
+ paint.setRasterizer(new testrast)->unref();
+ canvas->drawPath(fPath, paint);
+ }
+
+private:
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new PathEffectView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SamplePathFill.cpp b/samplecode/SamplePathFill.cpp
new file mode 100644
index 0000000..845b7a8
--- /dev/null
+++ b/samplecode/SamplePathFill.cpp
@@ -0,0 +1,140 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkGraphics.h"
+#include "SkRandom.h"
+#include "SkBlurDrawLooper.h"
+#include "SkGradientShader.h"
+
+typedef SkScalar (*MakePathProc)(SkPath*);
+
+static SkScalar make_frame(SkPath* path) {
+ SkRect r = { 10, 10, 630, 470 };
+ path->addRoundRect(r, 15, 15);
+
+ SkPaint paint;
+ paint.setStyle(SkPaint::kStroke_Style);
+ paint.setStrokeWidth(5);
+ paint.getFillPath(*path, path);
+ return 15;
+}
+
+static SkScalar make_triangle(SkPath* path) {
+ static const int gCoord[] = {
+ 10, 20, 15, 5, 30, 30
+ };
+ path->moveTo(SkIntToScalar(gCoord[0]), SkIntToScalar(gCoord[1]));
+ path->lineTo(SkIntToScalar(gCoord[2]), SkIntToScalar(gCoord[3]));
+ path->lineTo(SkIntToScalar(gCoord[4]), SkIntToScalar(gCoord[5]));
+ path->close();
+ path->offset(10, 0);
+ return SkIntToScalar(30);
+}
+
+static SkScalar make_rect(SkPath* path) {
+ SkRect r = { 10, 10, 30, 30 };
+ path->addRect(r);
+ path->offset(10, 0);
+ return SkIntToScalar(30);
+}
+
+static SkScalar make_oval(SkPath* path) {
+ SkRect r = { 10, 10, 30, 30 };
+ path->addOval(r);
+ path->offset(10, 0);
+ return SkIntToScalar(30);
+}
+
+static SkScalar make_sawtooth(SkPath* path) {
+ SkScalar x = SkIntToScalar(20);
+ SkScalar y = SkIntToScalar(20);
+ const SkScalar x0 = x;
+ const SkScalar dx = SK_Scalar1 * 5;
+ const SkScalar dy = SK_Scalar1 * 10;
+
+ path->moveTo(x, y);
+ for (int i = 0; i < 32; i++) {
+ x += dx;
+ path->lineTo(x, y - dy);
+ x += dx;
+ path->lineTo(x, y + dy);
+ }
+ path->lineTo(x, y + 2 * dy);
+ path->lineTo(x0, y + 2 * dy);
+ path->close();
+ return SkIntToScalar(30);
+}
+
+static SkScalar make_star(SkPath* path, int n) {
+ const SkScalar c = SkIntToScalar(45);
+ const SkScalar r = SkIntToScalar(20);
+
+ SkScalar rad = -SK_ScalarPI / 2;
+ const SkScalar drad = (n >> 1) * SK_ScalarPI * 2 / n;
+
+ path->moveTo(c, c - r);
+ for (int i = 1; i < n; i++) {
+ rad += drad;
+ SkScalar cosV, sinV = SkScalarSinCos(rad, &cosV);
+ path->lineTo(c + SkScalarMul(cosV, r), c + SkScalarMul(sinV, r));
+ }
+ path->close();
+ return r * 2 * 6 / 5;
+}
+
+static SkScalar make_star_5(SkPath* path) { return make_star(path, 5); }
+static SkScalar make_star_13(SkPath* path) { return make_star(path, 13); }
+
+static const MakePathProc gProcs[] = {
+ make_frame,
+ make_triangle,
+ make_rect,
+ make_oval,
+ make_sawtooth,
+ make_star_5,
+ make_star_13
+};
+
+#define N SK_ARRAY_COUNT(gProcs)
+
+class PathFillView : public SampleView {
+ SkPath fPath[N];
+ SkScalar fDY[N];
+
+public:
+ PathFillView() {
+ for (size_t i = 0; i < N; i++) {
+ fDY[i] = gProcs[i](&fPath[i]);
+ }
+ this->setBGColor(0xFFDDDDDD);
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "PathFill");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ SkPaint paint;
+ paint.setAntiAlias(true);
+
+ for (size_t i = 0; i < N; i++) {
+ canvas->drawPath(fPath[i], paint);
+ canvas->translate(0, fDY[i]);
+ }
+ }
+
+private:
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new PathFillView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SamplePicture.cpp b/samplecode/SamplePicture.cpp
new file mode 100644
index 0000000..d7b6b22
--- /dev/null
+++ b/samplecode/SamplePicture.cpp
@@ -0,0 +1,254 @@
+#include "SampleCode.h"
+#include "SkDumpCanvas.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "Sk64.h"
+#include "SkGradientShader.h"
+#include "SkGraphics.h"
+#include "SkImageDecoder.h"
+#include "SkPath.h"
+#include "SkPicture.h"
+#include "SkRandom.h"
+#include "SkRegion.h"
+#include "SkShader.h"
+#include "SkUtils.h"
+#include "SkColorPriv.h"
+#include "SkColorFilter.h"
+#include "SkShape.h"
+#include "SkTime.h"
+#include "SkTypeface.h"
+#include "SkXfermode.h"
+
+#include "SkStream.h"
+#include "SkXMLParser.h"
+
+class SignalShape : public SkShape {
+public:
+ SignalShape() : fSignal(0) {}
+
+ SkShape* setSignal(int n) {
+ fSignal = n;
+ return this;
+ }
+
+protected:
+ virtual void onDraw(SkCanvas* canvas) {
+ // SkDebugf("---- sc %d\n", canvas->getSaveCount() - 1);
+ }
+
+private:
+ int fSignal;
+};
+
+static SkPMColor SignalProc(SkPMColor src, SkPMColor dst) {
+ return dst;
+}
+
+/* Picture playback will skip blocks of draw calls that follow a clip() call
+ that returns empty, and jump down to the corresponding restore() call.
+
+ This is a great preformance win for drawing very large/tall pictures with
+ a small visible window (think scrolling a long document). These tests make
+ sure that (a) we are performing the culling, and (b) we don't get confused
+ by nested save() calls, nor by calls to restoreToCount().
+ */
+static void test_saveRestoreCulling() {
+ SkPaint signalPaint;
+ SignalShape signalShape;
+
+ SkPicture pic;
+ SkRect r = SkRect::MakeWH(0, 0);
+ int n;
+ SkCanvas* canvas = pic.beginRecording(100, 100);
+ int startN = canvas->getSaveCount();
+ SkDebugf("---- start sc %d\n", startN);
+ canvas->drawShape(signalShape.setSignal(1));
+ canvas->save();
+ canvas->drawShape(signalShape.setSignal(2));
+ n = canvas->save();
+ canvas->drawShape(signalShape.setSignal(3));
+ canvas->save();
+ canvas->clipRect(r);
+ canvas->drawShape(signalShape.setSignal(4));
+ canvas->restoreToCount(n);
+ canvas->drawShape(signalShape.setSignal(5));
+ canvas->restore();
+ canvas->drawShape(signalShape.setSignal(6));
+ SkASSERT(canvas->getSaveCount() == startN);
+
+ SkBitmap bm;
+ bm.setConfig(SkBitmap::kARGB_8888_Config, 100, 100);
+ bm.allocPixels();
+ SkCanvas c(bm);
+ c.drawPicture(pic);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+#include "SkImageRef_GlobalPool.h"
+
+static SkBitmap load_bitmap() {
+ SkStream* stream = new SkFILEStream("/skimages/sesame_street_ensemble-hp.jpg");
+ SkAutoUnref aur(stream);
+
+ SkBitmap bm;
+ if (SkImageDecoder::DecodeStream(stream, &bm, SkBitmap::kNo_Config,
+ SkImageDecoder::kDecodeBounds_Mode)) {
+ SkPixelRef* pr = new SkImageRef_GlobalPool(stream, bm.config(), 1);
+ bm.setPixelRef(pr)->unref();
+ }
+ return bm;
+}
+
+static void drawCircle(SkCanvas* canvas, int r, SkColor color) {
+ SkPaint paint;
+ paint.setAntiAlias(true);
+ paint.setColor(color);
+
+ canvas->drawCircle(SkIntToScalar(r), SkIntToScalar(r), SkIntToScalar(r),
+ paint);
+}
+
+class PictureView : public SampleView {
+ SkBitmap fBitmap;
+public:
+ PictureView() {
+ SkImageRef_GlobalPool::SetRAMBudget(16 * 1024);
+
+ fBitmap = load_bitmap();
+
+ fPicture = new SkPicture;
+ SkCanvas* canvas = fPicture->beginRecording(100, 100);
+ SkPaint paint;
+ paint.setAntiAlias(true);
+
+ canvas->drawBitmap(fBitmap, 0, 0, NULL);
+
+ drawCircle(canvas, 50, SK_ColorBLACK);
+ fSubPicture = new SkPicture;
+ canvas->drawPicture(*fSubPicture);
+ canvas->translate(SkIntToScalar(50), 0);
+ canvas->drawPicture(*fSubPicture);
+ canvas->translate(0, SkIntToScalar(50));
+ canvas->drawPicture(*fSubPicture);
+ canvas->translate(SkIntToScalar(-50), 0);
+ canvas->drawPicture(*fSubPicture);
+ // fPicture now has (4) references to us. We can release ours, and just
+ // unref fPicture in our destructor, and it will in turn take care of
+ // the other references to fSubPicture
+ fSubPicture->unref();
+
+ test_saveRestoreCulling();
+ }
+
+ virtual ~PictureView() {
+ fPicture->unref();
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "Picture");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ void drawSomething(SkCanvas* canvas) {
+ SkPaint paint;
+
+ canvas->save();
+ canvas->scale(0.5f, 0.5f);
+ canvas->drawBitmap(fBitmap, 0, 0, NULL);
+ canvas->restore();
+
+ const char beforeStr[] = "before circle";
+ const char afterStr[] = "after circle";
+
+ paint.setAntiAlias(true);
+
+ paint.setColor(SK_ColorRED);
+ canvas->drawData(beforeStr, sizeof(beforeStr));
+ canvas->drawCircle(SkIntToScalar(50), SkIntToScalar(50),
+ SkIntToScalar(40), paint);
+ canvas->drawData(afterStr, sizeof(afterStr));
+ paint.setColor(SK_ColorBLACK);
+ paint.setTextSize(SkIntToScalar(40));
+ canvas->drawText("Picture", 7, SkIntToScalar(50), SkIntToScalar(62),
+ paint);
+
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ drawSomething(canvas);
+
+ SkPicture* pict = new SkPicture;
+ SkAutoUnref aur(pict);
+
+ drawSomething(pict->beginRecording(100, 100));
+ pict->endRecording();
+
+ canvas->save();
+ canvas->translate(SkIntToScalar(300), SkIntToScalar(50));
+ canvas->scale(-SK_Scalar1, -SK_Scalar1);
+ canvas->translate(-SkIntToScalar(100), -SkIntToScalar(50));
+ canvas->drawPicture(*pict);
+ canvas->restore();
+
+ canvas->save();
+ canvas->translate(SkIntToScalar(200), SkIntToScalar(150));
+ canvas->scale(SK_Scalar1, -SK_Scalar1);
+ canvas->translate(0, -SkIntToScalar(50));
+ canvas->drawPicture(*pict);
+ canvas->restore();
+
+ canvas->save();
+ canvas->translate(SkIntToScalar(100), SkIntToScalar(100));
+ canvas->scale(-SK_Scalar1, SK_Scalar1);
+ canvas->translate(-SkIntToScalar(100), 0);
+ canvas->drawPicture(*pict);
+ canvas->restore();
+
+ if (false) {
+ SkDebugfDumper dumper;
+ SkDumpCanvas dumpCanvas(&dumper);
+ dumpCanvas.drawPicture(*pict);
+ }
+
+ // test that we can re-record a subpicture, and see the results
+
+ SkRandom rand(SampleCode::GetAnimTime());
+ canvas->translate(SkIntToScalar(10), SkIntToScalar(250));
+ drawCircle(fSubPicture->beginRecording(50, 50), 25,
+ rand.nextU() | 0xFF000000);
+ canvas->drawPicture(*fPicture);
+ delayInval(500);
+ }
+
+private:
+ #define INVAL_ALL_TYPE "inval-all"
+
+ void delayInval(SkMSec delay) {
+ (new SkEvent(INVAL_ALL_TYPE))->post(this->getSinkID(), delay);
+ }
+
+ virtual bool onEvent(const SkEvent& evt) {
+ if (evt.isType(INVAL_ALL_TYPE)) {
+ this->inval(NULL);
+ return true;
+ }
+ return this->INHERITED::onEvent(evt);
+ }
+
+ SkPicture* fPicture;
+ SkPicture* fSubPicture;
+
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new PictureView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SamplePoints.cpp b/samplecode/SamplePoints.cpp
new file mode 100644
index 0000000..a2804b4
--- /dev/null
+++ b/samplecode/SamplePoints.cpp
@@ -0,0 +1,78 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "Sk64.h"
+#include "SkGradientShader.h"
+#include "SkGraphics.h"
+#include "SkImageDecoder.h"
+#include "SkKernel33MaskFilter.h"
+#include "SkPath.h"
+#include "SkRandom.h"
+#include "SkRegion.h"
+#include "SkShader.h"
+#include "SkUtils.h"
+#include "SkColorPriv.h"
+#include "SkColorFilter.h"
+#include "SkTime.h"
+#include "SkTypeface.h"
+#include "SkXfermode.h"
+
+#include "SkStream.h"
+#include "SkXMLParser.h"
+
+class PointsView : public SampleView {
+public:
+ PointsView() {}
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "Points");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ static void fill_pts(SkPoint pts[], size_t n, SkRandom* rand) {
+ for (size_t i = 0; i < n; i++)
+ pts[i].set(rand->nextUScalar1() * 640, rand->nextUScalar1() * 480);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ canvas->translate(SK_Scalar1, SK_Scalar1);
+
+ SkRandom rand;
+ SkPaint p0, p1, p2, p3;
+ const size_t n = 99;
+
+ p0.setColor(SK_ColorRED);
+ p1.setColor(SK_ColorGREEN);
+ p2.setColor(SK_ColorBLUE);
+ p3.setColor(SK_ColorWHITE);
+
+ p0.setStrokeWidth(SkIntToScalar(4));
+ p2.setStrokeCap(SkPaint::kRound_Cap);
+ p2.setStrokeWidth(SkIntToScalar(6));
+
+ SkPoint* pts = new SkPoint[n];
+ fill_pts(pts, n, &rand);
+
+ canvas->drawPoints(SkCanvas::kPolygon_PointMode, n, pts, p0);
+ canvas->drawPoints(SkCanvas::kLines_PointMode, n, pts, p1);
+ canvas->drawPoints(SkCanvas::kPoints_PointMode, n, pts, p2);
+ canvas->drawPoints(SkCanvas::kPoints_PointMode, n, pts, p3);
+
+ delete[] pts;
+ }
+
+private:
+
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new PointsView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SamplePolyToPoly.cpp b/samplecode/SamplePolyToPoly.cpp
new file mode 100644
index 0000000..aea0cb4
--- /dev/null
+++ b/samplecode/SamplePolyToPoly.cpp
@@ -0,0 +1,161 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkGraphics.h"
+#include "SkPath.h"
+#include "SkRandom.h"
+#include "SkTime.h"
+
+extern bool SkSetPoly3To3(SkMatrix* matrix, const SkPoint src[3], const SkPoint dst[3]);
+
+class PolyToPolyView : public SampleView {
+public:
+ PolyToPolyView() {
+ // tests
+ {
+ SkPoint src[] = { { 0, 0 },
+ { SK_Scalar1, 0 },
+ { 0, SK_Scalar1 } };
+ SkPoint dst[] = { { 0, 0 },
+ { 2*SK_Scalar1, 0 },
+ { 0, 2*SK_Scalar1 } };
+ SkMatrix m1, m2;
+ bool success;
+
+ success = m1.setPolyToPoly(src, dst, 3);
+
+ m2.reset();
+ m2.set(SkMatrix::kMScaleX, dst[1].fX - dst[0].fX);
+ m2.set(SkMatrix::kMSkewX, dst[2].fX - dst[0].fX);
+ m2.set(SkMatrix::kMTransX, dst[0].fX);
+ m2.set(SkMatrix::kMSkewY, dst[1].fY - dst[0].fY);
+ m2.set(SkMatrix::kMScaleY, dst[2].fY - dst[0].fY);
+ m2.set(SkMatrix::kMTransY, dst[0].fY);
+
+ m1.reset();
+
+ const SkScalar src1[] = {
+ 0, 0, 0, SkFloatToScalar(427), SkFloatToScalar(316), SkFloatToScalar(427), SkFloatToScalar(316), 0
+ };
+ const SkScalar dst1[] = {
+ SkFloatToScalar(158), SkFloatToScalar(177.5f), SkFloatToScalar(158), SkFloatToScalar(249.5f),
+ SkFloatToScalar(158), SkFloatToScalar(604.5f), SkFloatToScalar(158), SkFloatToScalar(-177.5f)
+ };
+
+ success = m2.setPolyToPoly((const SkPoint*)src1, (SkPoint*)dst1, 4);
+
+ {
+ const SkPoint src[] = {
+ { SkIntToScalar(1), SkIntToScalar(0) },
+ { SkIntToScalar(4), SkIntToScalar(7) },
+ { SkIntToScalar(10), SkIntToScalar(2) }
+ };
+ const SkPoint dst[] = {
+ { SkIntToScalar(4), SkIntToScalar(2) },
+ { SkIntToScalar(45), SkIntToScalar(26) },
+ { SkIntToScalar(32), SkIntToScalar(17) }
+ };
+
+ SkMatrix m0, m1;
+ m0.setPolyToPoly(src, dst, 3);
+ // SkSetPoly3To3(&m1, src, dst);
+ // m0.dump();
+ // m1.dump();
+ }
+ }
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SkString str("PolyToPolyView");
+ SampleCode::TitleR(evt, str.c_str());
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ static void doDraw(SkCanvas* canvas, SkPaint* paint, const int isrc[],
+ const int idst[], int count) {
+ SkMatrix matrix;
+ SkPoint src[4], dst[4];
+
+ for (int i = 0; i < count; i++) {
+ src[i].set(SkIntToScalar(isrc[2*i+0]), SkIntToScalar(isrc[2*i+1]));
+ dst[i].set(SkIntToScalar(idst[2*i+0]), SkIntToScalar(idst[2*i+1]));
+ }
+
+ canvas->save();
+ matrix.setPolyToPoly(src, dst, count);
+ canvas->concat(matrix);
+
+ paint->setColor(SK_ColorGRAY);
+ paint->setStyle(SkPaint::kStroke_Style);
+ const SkScalar D = SkIntToScalar(64);
+ canvas->drawRectCoords(0, 0, D, D, *paint);
+ canvas->drawLine(0, 0, D, D, *paint);
+ canvas->drawLine(0, D, D, 0, *paint);
+
+ SkPaint::FontMetrics fm;
+ paint->getFontMetrics(&fm);
+ paint->setColor(SK_ColorRED);
+ paint->setStyle(SkPaint::kFill_Style);
+ SkScalar x = D/2;
+ float y = D/2 - (fm.fAscent + fm.fDescent)/2;
+ SkString str;
+ str.appendS32(count);
+ canvas->drawText(str.c_str(), str.size(), x, y, *paint);
+
+ canvas->restore();
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ SkPaint paint;
+ paint.setAntiAlias(true);
+ paint.setStrokeWidth(SkIntToScalar(4));
+ paint.setTextSize(SkIntToScalar(40));
+ paint.setTextAlign(SkPaint::kCenter_Align);
+
+ canvas->save();
+ canvas->translate(SkIntToScalar(10), SkIntToScalar(10));
+ // translate (1 point)
+ const int src1[] = { 0, 0 };
+ const int dst1[] = { 5, 5 };
+ doDraw(canvas, &paint, src1, dst1, 1);
+ canvas->restore();
+
+ canvas->save();
+ canvas->translate(SkIntToScalar(160), SkIntToScalar(10));
+ // rotate/uniform-scale (2 points)
+ const int src2[] = { 32, 32, 64, 32 };
+ const int dst2[] = { 32, 32, 64, 48 };
+ doDraw(canvas, &paint, src2, dst2, 2);
+ canvas->restore();
+
+ canvas->save();
+ canvas->translate(SkIntToScalar(10), SkIntToScalar(110));
+ // rotate/skew (3 points)
+ const int src3[] = { 0, 0, 64, 0, 0, 64 };
+ const int dst3[] = { 0, 0, 96, 0, 24, 64 };
+ doDraw(canvas, &paint, src3, dst3, 3);
+ canvas->restore();
+
+ canvas->save();
+ canvas->translate(SkIntToScalar(160), SkIntToScalar(110));
+ // perspective (4 points)
+ const int src4[] = { 0, 0, 64, 0, 64, 64, 0, 64 };
+ const int dst4[] = { 0, 0, 96, 0, 64, 96, 0, 64 };
+ doDraw(canvas, &paint, src4, dst4, 4);
+ canvas->restore();
+ }
+
+private:
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new PolyToPolyView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleRegion.cpp b/samplecode/SampleRegion.cpp
new file mode 100644
index 0000000..822bd6f
--- /dev/null
+++ b/samplecode/SampleRegion.cpp
@@ -0,0 +1,273 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkGradientShader.h"
+#include "SkPath.h"
+#include "SkRegion.h"
+#include "SkShader.h"
+#include "SkUtils.h"
+#include "SkImageDecoder.h"
+
+#ifdef SK_BUILD_FOR_WIN
+// windows doesn't have roundf
+inline float roundf(float x) { return (x-floor(x))>0.5 ? ceil(x) : floor(x); }
+#endif
+
+#ifdef SK_DEBUG
+static void make_rgn(SkRegion* rgn, int left, int top, int right, int bottom,
+ size_t count, int32_t runs[]) {
+ SkIRect r;
+ r.set(left, top, right, bottom);
+
+ rgn->debugSetRuns(runs, count);
+ SkASSERT(rgn->getBounds() == r);
+}
+
+static void test_union_bug_1505668(SkRegion* ra, SkRegion* rb, SkRegion* rc) {
+ static int32_t dataA[] = {
+ 0x00000001, 0x000001dd,
+ 0x00000001, 0x0000000c, 0x0000000d, 0x00000025,
+ 0x7fffffff, 0x000001de, 0x00000001, 0x00000025,
+ 0x7fffffff, 0x000004b3, 0x00000001, 0x00000026,
+ 0x7fffffff, 0x000004b4, 0x0000000c, 0x00000026,
+ 0x7fffffff, 0x00000579, 0x00000000, 0x0000013a,
+ 0x7fffffff, 0x000005d8, 0x00000000, 0x0000013b,
+ 0x7fffffff, 0x7fffffff
+ };
+ make_rgn(ra, 0, 1, 315, 1496, SK_ARRAY_COUNT(dataA), dataA);
+
+ static int32_t dataB[] = {
+ 0x000000b6, 0x000000c4,
+ 0x000000a1, 0x000000f0, 0x7fffffff, 0x000000d6,
+ 0x7fffffff, 0x000000e4, 0x00000070, 0x00000079,
+ 0x000000a1, 0x000000b0, 0x7fffffff, 0x000000e6,
+ 0x7fffffff, 0x000000f4, 0x00000070, 0x00000079,
+ 0x000000a1, 0x000000b0, 0x7fffffff, 0x000000f6,
+ 0x7fffffff, 0x00000104, 0x000000a1, 0x000000b0,
+ 0x7fffffff, 0x7fffffff
+ };
+ make_rgn(rb, 112, 182, 240, 260, SK_ARRAY_COUNT(dataB), dataB);
+
+ rc->op(*ra, *rb, SkRegion::kUnion_Op);
+}
+#endif
+
+static void scale_rect(SkIRect* dst, const SkIRect& src, float scale) {
+ dst->fLeft = (int)::roundf(src.fLeft * scale);
+ dst->fTop = (int)::roundf(src.fTop * scale);
+ dst->fRight = (int)::roundf(src.fRight * scale);
+ dst->fBottom = (int)::roundf(src.fBottom * scale);
+}
+
+static void scale_rgn(SkRegion* dst, const SkRegion& src, float scale) {
+ SkRegion tmp;
+ SkRegion::Iterator iter(src);
+
+ for (; !iter.done(); iter.next()) {
+ SkIRect r;
+ scale_rect(&r, iter.rect(), scale);
+ tmp.op(r, SkRegion::kUnion_Op);
+ }
+ dst->swap(tmp);
+}
+
+static void paint_rgn(SkCanvas* canvas, const SkRegion& rgn,
+ const SkPaint& paint) {
+ SkRegion scaled;
+ scale_rgn(&scaled, rgn, 0.5f);
+
+ SkRegion::Iterator iter(rgn);
+
+ for (; !iter.done(); iter.next())
+ {
+ SkRect r;
+ r.set(iter.rect());
+ canvas->drawRect(r, paint);
+ }
+}
+
+class RegionView : public SampleView {
+public:
+ RegionView() {
+ fBase.set(100, 100, 150, 150);
+ fRect = fBase;
+ fRect.inset(5, 5);
+ fRect.offset(25, 25);
+ this->setBGColor(0xFFDDDDDD);
+ }
+
+ void build_rgn(SkRegion* rgn, SkRegion::Op op) {
+ rgn->setRect(fBase);
+ SkIRect r = fBase;
+ r.offset(75, 20);
+ rgn->op(r, SkRegion::kUnion_Op);
+ rgn->op(fRect, op);
+ }
+
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "Regions");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ void drawOrig(SkCanvas* canvas, bool bg) {
+ SkRect r;
+ SkPaint paint;
+
+ paint.setStyle(SkPaint::kStroke_Style);
+ if (bg)
+ paint.setColor(0xFFBBBBBB);
+
+ r.set(fBase);
+ canvas->drawRect(r, paint);
+ r.set(fRect);
+ canvas->drawRect(r, paint);
+ }
+
+ void drawRgnOped(SkCanvas* canvas, SkRegion::Op op, SkColor color) {
+ SkRegion rgn;
+
+ this->build_rgn(&rgn, op);
+
+ {
+ SkRegion tmp, tmp2(rgn);
+
+ tmp = tmp2;
+ tmp.translate(5, -3);
+
+ {
+ char buffer[1000];
+ size_t size = tmp.flatten(NULL);
+ SkASSERT(size <= sizeof(buffer));
+ size_t size2 = tmp.flatten(buffer);
+ SkASSERT(size == size2);
+
+ SkRegion tmp3;
+ size2 = tmp3.unflatten(buffer);
+ SkASSERT(size == size2);
+
+ SkASSERT(tmp3 == tmp);
+ }
+
+ rgn.translate(20, 30, &tmp);
+ SkASSERT(rgn.isEmpty() || tmp != rgn);
+ tmp.translate(-20, -30);
+ SkASSERT(tmp == rgn);
+ }
+
+ this->drawOrig(canvas, true);
+
+ SkPaint paint;
+ paint.setColor((color & ~(0xFF << 24)) | (0x44 << 24));
+ paint_rgn(canvas, rgn, paint);
+
+ paint.setStyle(SkPaint::kStroke_Style);
+ paint.setColor(color);
+ paint_rgn(canvas, rgn, paint);
+ }
+
+ void drawPathOped(SkCanvas* canvas, SkRegion::Op op, SkColor color) {
+ SkRegion rgn;
+ SkPath path;
+
+ this->build_rgn(&rgn, op);
+ rgn.getBoundaryPath(&path);
+
+ this->drawOrig(canvas, true);
+
+ SkPaint paint;
+
+ paint.setStyle(SkPaint::kFill_Style);
+ paint.setColor((color & ~(0xFF << 24)) | (0x44 << 24));
+ canvas->drawPath(path, paint);
+ paint.setColor(color);
+ paint.setStyle(SkPaint::kStroke_Style);
+ canvas->drawPath(path, paint);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+#ifdef SK_DEBUG
+ if (true) {
+ SkRegion a, b, c;
+ test_union_bug_1505668(&a, &b, &c);
+
+ if (false) { // draw the result of the test
+ SkPaint paint;
+
+ canvas->translate(SkIntToScalar(10), SkIntToScalar(10));
+ paint.setColor(SK_ColorRED);
+ paint_rgn(canvas, a, paint);
+ paint.setColor(0x800000FF);
+ paint_rgn(canvas, b, paint);
+ paint.setColor(SK_ColorBLACK);
+ paint.setStyle(SkPaint::kStroke_Style);
+ // paint_rgn(canvas, c, paint);
+ return;
+ }
+ }
+#endif
+
+ static const struct {
+ SkColor fColor;
+ const char* fName;
+ SkRegion::Op fOp;
+ } gOps[] = {
+ { SK_ColorBLACK, "Difference", SkRegion::kDifference_Op },
+ { SK_ColorRED, "Intersect", SkRegion::kIntersect_Op },
+ { 0xFF008800, "Union", SkRegion::kUnion_Op },
+ { SK_ColorBLUE, "XOR", SkRegion::kXOR_Op }
+ };
+
+ SkPaint textPaint;
+ textPaint.setAntiAlias(true);
+ textPaint.setTextSize(SK_Scalar1*24);
+
+ this->drawOrig(canvas, false);
+ canvas->save();
+ canvas->translate(SkIntToScalar(200), 0);
+ this->drawRgnOped(canvas, SkRegion::kUnion_Op, SK_ColorBLACK);
+ canvas->restore();
+
+ canvas->translate(0, SkIntToScalar(200));
+
+ for (size_t op = 0; op < SK_ARRAY_COUNT(gOps); op++) {
+ canvas->drawText(gOps[op].fName, strlen(gOps[op].fName), SkIntToScalar(75), SkIntToScalar(50), textPaint);
+
+ this->drawRgnOped(canvas, gOps[op].fOp, gOps[op].fColor);
+
+ canvas->save();
+ canvas->translate(0, SkIntToScalar(200));
+ this->drawPathOped(canvas, gOps[op].fOp, gOps[op].fColor);
+ canvas->restore();
+
+ canvas->translate(SkIntToScalar(200), 0);
+ }
+ }
+
+ virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
+ return fRect.contains(SkScalarRound(x), SkScalarRound(y)) ? new Click(this) : NULL;
+ }
+
+ virtual bool onClick(Click* click) {
+ fRect.offset(click->fICurr.fX - click->fIPrev.fX,
+ click->fICurr.fY - click->fIPrev.fY);
+ this->inval(NULL);
+ return true;
+ }
+
+private:
+ SkIRect fBase, fRect;
+
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new RegionView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleRepeatTile.cpp b/samplecode/SampleRepeatTile.cpp
new file mode 100644
index 0000000..9867074
--- /dev/null
+++ b/samplecode/SampleRepeatTile.cpp
@@ -0,0 +1,86 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkShader.h"
+#include "SkKey.h"
+
+static void make_bitmap(SkBitmap* bm) {
+ const int W = 100;
+ const int H = 100;
+ bm->setConfig(SkBitmap::kARGB_8888_Config, W, H);
+ bm->allocPixels();
+
+ SkPaint paint;
+ SkCanvas canvas(*bm);
+ canvas.drawColor(SK_ColorWHITE);
+
+ const SkColor colors[] = {
+ SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorWHITE
+ };
+
+ for (int ix = 0; ix < W; ix += 1) {
+ SkScalar x = SkIntToScalar(ix) + SK_ScalarHalf;
+ paint.setColor(colors[ix & 3]);
+ canvas.drawLine(x, 0, x, SkIntToScalar(H - 1), paint);
+ }
+ paint.setColor(SK_ColorGRAY);
+ canvas.drawLine(0, 0, SkIntToScalar(W), 0, paint);
+}
+
+static void make_paint(SkPaint* paint, SkShader::TileMode tm) {
+ SkBitmap bm;
+ make_bitmap(&bm);
+
+ SkShader* shader = SkShader::CreateBitmapShader(bm, tm, tm);
+ paint->setShader(shader)->unref();
+}
+
+class RepeatTileView : public SampleView {
+public:
+ RepeatTileView() {
+ this->setBGColor(SK_ColorGRAY);
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "RepeatTile");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ SkPaint paint;
+ make_paint(&paint, SkShader::kRepeat_TileMode);
+
+// canvas->scale(SK_Scalar1*2, SK_Scalar1);
+ canvas->translate(SkIntToScalar(100), SkIntToScalar(100));
+ canvas->drawPaint(paint);
+ }
+
+ virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
+ this->inval(NULL);
+
+ return this->INHERITED::onFindClickHandler(x, y);
+ }
+
+ virtual bool onClick(Click* click) {
+ return this->INHERITED::onClick(click);
+ }
+
+ virtual bool handleKey(SkKey key) {
+ this->inval(NULL);
+ return true;
+ }
+
+private:
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new RepeatTileView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleShaderText.cpp b/samplecode/SampleShaderText.cpp
new file mode 100644
index 0000000..2748b55
--- /dev/null
+++ b/samplecode/SampleShaderText.cpp
@@ -0,0 +1,195 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkGradientShader.h"
+#include "SkUnitMappers.h"
+
+static void makebm(SkBitmap* bm, SkBitmap::Config config, int w, int h) {
+ bm->setConfig(config, w, h);
+ bm->allocPixels();
+ bm->eraseColor(0);
+
+ SkCanvas canvas(*bm);
+ SkScalar s = SkIntToScalar(w < h ? w : h);
+ SkPoint pts[] = { { 0, 0 }, { s, s } };
+ SkColor colors[] = { SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE };
+ SkScalar pos[] = { 0, SK_Scalar1/2, SK_Scalar1 };
+ SkPaint paint;
+
+ SkUnitMapper* um = NULL;
+
+ um = new SkCosineMapper;
+
+ SkAutoUnref au(um);
+
+ paint.setDither(true);
+ paint.setShader(SkGradientShader::CreateLinear(pts, colors, pos,
+ SK_ARRAY_COUNT(colors), SkShader::kClamp_TileMode, um))->unref();
+ canvas.drawPaint(paint);
+}
+
+SkShader* MakeBitmapShader(SkShader::TileMode tx, SkShader::TileMode ty,
+ int w, int h) {
+ static SkBitmap bmp;
+ if (bmp.isNull()) {
+ makebm(&bmp, SkBitmap::kARGB_8888_Config, w/2, h/4);
+ }
+ return SkShader::CreateBitmapShader(bmp, tx, ty);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+struct GradData {
+ int fCount;
+ const SkColor* fColors;
+ const SkScalar* fPos;
+};
+
+static const SkColor gColors[] = {
+ SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorWHITE, SK_ColorBLACK
+};
+
+static const GradData gGradData[] = {
+ { 2, gColors, NULL },
+ { 5, gColors, NULL },
+};
+
+static SkShader* MakeLinear(const SkPoint pts[2], const GradData& data,
+ SkShader::TileMode tm, SkUnitMapper* mapper) {
+ return SkGradientShader::CreateLinear(pts, data.fColors, data.fPos,
+ data.fCount, tm, mapper);
+}
+
+static SkShader* MakeRadial(const SkPoint pts[2], const GradData& data,
+ SkShader::TileMode tm, SkUnitMapper* mapper) {
+ SkPoint center;
+ center.set(SkScalarAve(pts[0].fX, pts[1].fX),
+ SkScalarAve(pts[0].fY, pts[1].fY));
+ return SkGradientShader::CreateRadial(center, center.fX, data.fColors,
+ data.fPos, data.fCount, tm, mapper);
+}
+
+static SkShader* MakeSweep(const SkPoint pts[2], const GradData& data,
+ SkShader::TileMode tm, SkUnitMapper* mapper) {
+ SkPoint center;
+ center.set(SkScalarAve(pts[0].fX, pts[1].fX),
+ SkScalarAve(pts[0].fY, pts[1].fY));
+ return SkGradientShader::CreateSweep(center.fX, center.fY, data.fColors,
+ data.fPos, data.fCount, mapper);
+}
+
+static SkShader* Make2Radial(const SkPoint pts[2], const GradData& data,
+ SkShader::TileMode tm, SkUnitMapper* mapper) {
+ SkPoint center0, center1;
+ center0.set(SkScalarAve(pts[0].fX, pts[1].fX),
+ SkScalarAve(pts[0].fY, pts[1].fY));
+ center1.set(SkScalarInterp(pts[0].fX, pts[1].fX, SkIntToScalar(3)/5),
+ SkScalarInterp(pts[0].fY, pts[1].fY, SkIntToScalar(1)/4));
+ return SkGradientShader::CreateTwoPointRadial(
+ center1, (pts[1].fX - pts[0].fX) / 7,
+ center0, (pts[1].fX - pts[0].fX) / 2,
+ data.fColors, data.fPos, data.fCount, tm, mapper);
+}
+
+typedef SkShader* (*GradMaker)(const SkPoint pts[2], const GradData& data,
+ SkShader::TileMode tm, SkUnitMapper* mapper);
+static const GradMaker gGradMakers[] = {
+ MakeLinear, MakeRadial, MakeSweep, Make2Radial
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+class ShaderTextView : public SampleView {
+public:
+ ShaderTextView() {
+ this->setBGColor(0xFFDDDDDD);
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "Shader Text");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ const char text[] = "Shaded Text";
+ const int textLen = SK_ARRAY_COUNT(text) - 1;
+ static int pointSize = 48;
+
+ int w = pointSize * textLen;
+ int h = pointSize;
+
+ SkPoint pts[2] = {
+ { 0, 0 },
+ { SkIntToScalar(w), SkIntToScalar(h) }
+ };
+ SkScalar textBase = SkIntToScalar(h/2);
+
+ SkShader::TileMode tileModes[] = {
+ SkShader::kClamp_TileMode,
+ SkShader::kRepeat_TileMode,
+ SkShader::kMirror_TileMode
+ };
+
+ static const int gradCount = SK_ARRAY_COUNT(gGradData) *
+ SK_ARRAY_COUNT(gGradMakers);
+ static const int bmpCount = SK_ARRAY_COUNT(tileModes) *
+ SK_ARRAY_COUNT(tileModes);
+ SkShader* shaders[gradCount + bmpCount];
+
+ int shdIdx = 0;
+ for (size_t d = 0; d < SK_ARRAY_COUNT(gGradData); ++d) {
+ for (size_t m = 0; m < SK_ARRAY_COUNT(gGradMakers); ++m) {
+ shaders[shdIdx++] = gGradMakers[m](pts,
+ gGradData[d],
+ SkShader::kClamp_TileMode,
+ NULL);
+ }
+ }
+ for (size_t tx = 0; tx < SK_ARRAY_COUNT(tileModes); ++tx) {
+ for (size_t ty = 0; ty < SK_ARRAY_COUNT(tileModes); ++ty) {
+ shaders[shdIdx++] = MakeBitmapShader(tileModes[tx],
+ tileModes[ty],
+ w/8, h);
+ }
+ }
+
+ SkPaint paint;
+ paint.setDither(true);
+ paint.setAntiAlias(true);
+ paint.setTextSize(SkIntToScalar(pointSize));
+
+ canvas->save();
+ canvas->translate(SkIntToScalar(20), SkIntToScalar(10));
+
+ static const int testsPerCol = 8;
+ static const int rowHeight = 60;
+ static const int colWidth = 300;
+ canvas->save();
+ for (size_t s = 0; s < SK_ARRAY_COUNT(shaders); s++) {
+ canvas->save();
+ canvas->translate(SkIntToScalar((s / testsPerCol) * colWidth),
+ SkIntToScalar((s % testsPerCol) * rowHeight));
+ paint.setShader(shaders[s])->unref();
+ canvas->drawText(text, textLen, 0, textBase, paint);
+ canvas->restore();
+ }
+ canvas->restore();
+
+ canvas->translate(0, SkIntToScalar(370));
+ this->inval(NULL);
+ }
+
+private:
+ typedef SampleView INHERITED;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new ShaderTextView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleShaders.cpp b/samplecode/SampleShaders.cpp
new file mode 100644
index 0000000..c1bb0fd
--- /dev/null
+++ b/samplecode/SampleShaders.cpp
@@ -0,0 +1,134 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkGradientShader.h"
+#include "SkGraphics.h"
+#include "SkImageDecoder.h"
+#include "SkPath.h"
+#include "SkRegion.h"
+#include "SkShader.h"
+#include "SkUtils.h"
+#include "SkXfermode.h"
+#include "SkComposeShader.h"
+#include "SkColorPriv.h"
+#include "SkColorFilter.h"
+#include "SkTime.h"
+#include "SkTransparentShader.h"
+#include "SkTypeface.h"
+
+static SkShader* make_bitmapfade(const SkBitmap& bm)
+{
+ SkPoint pts[2];
+ SkColor colors[2];
+
+ pts[0].set(0, 0);
+ pts[1].set(0, SkIntToScalar(bm.height()));
+ colors[0] = SK_ColorBLACK;
+ colors[1] = SkColorSetARGB(0, 0, 0, 0);
+ SkShader* shaderA = SkGradientShader::CreateLinear(pts, colors, NULL, 2, SkShader::kClamp_TileMode);
+
+ SkShader* shaderB = SkShader::CreateBitmapShader(bm,
+ SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
+
+ SkXfermode* mode = SkXfermode::Create(SkXfermode::kDstIn_Mode);
+
+ SkShader* shader = new SkComposeShader(shaderB, shaderA, mode);
+ shaderA->unref();
+ shaderB->unref();
+ mode->unref();
+
+ return shader;
+}
+
+class ShaderView : public SampleView {
+public:
+ SkShader* fShader;
+ SkBitmap fBitmap;
+
+ ShaderView() {
+ SkImageDecoder::DecodeFile("/skimages/logo.gif", &fBitmap);
+
+ SkPoint pts[2];
+ SkColor colors[2];
+
+ pts[0].set(0, 0);
+ pts[1].set(SkIntToScalar(100), 0);
+ colors[0] = SK_ColorRED;
+ colors[1] = SK_ColorBLUE;
+ SkShader* shaderA = SkGradientShader::CreateLinear(pts, colors, NULL, 2, SkShader::kClamp_TileMode);
+
+ pts[0].set(0, 0);
+ pts[1].set(0, SkIntToScalar(100));
+ colors[0] = SK_ColorBLACK;
+ colors[1] = SkColorSetARGB(0x80, 0, 0, 0);
+ SkShader* shaderB = SkGradientShader::CreateLinear(pts, colors, NULL, 2, SkShader::kClamp_TileMode);
+
+ SkXfermode* mode = SkXfermode::Create(SkXfermode::kDstIn_Mode);
+
+ fShader = new SkComposeShader(shaderA, shaderB, mode);
+ shaderA->unref();
+ shaderB->unref();
+ mode->unref();
+ }
+ virtual ~ShaderView() {
+ SkSafeUnref(fShader);
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "Shaders");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ canvas->drawBitmap(fBitmap, 0, 0);
+
+ canvas->translate(SkIntToScalar(20), SkIntToScalar(120));
+
+ SkPaint paint;
+ SkRect r;
+
+ paint.setColor(SK_ColorGREEN);
+ canvas->drawRectCoords(0, 0, SkIntToScalar(100), SkIntToScalar(100), paint);
+ paint.setShader(fShader);
+ canvas->drawRectCoords(0, 0, SkIntToScalar(100), SkIntToScalar(100), paint);
+
+ canvas->translate(SkIntToScalar(110), 0);
+
+ int w = fBitmap.width();
+ int h = fBitmap.height();
+ w = 120;
+ h = 80;
+ r.set(0, 0, SkIntToScalar(w), SkIntToScalar(h));
+
+ paint.setShader(NULL);
+ canvas->drawRect(r, paint);
+ paint.setShader(make_bitmapfade(fBitmap))->unref();
+ canvas->drawRect(r, paint);
+
+ paint.setShader(new SkTransparentShader)->unref();
+ canvas->drawRect(r, paint);
+ }
+
+ virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
+ this->inval(NULL);
+ return this->INHERITED::onFindClickHandler(x, y);
+ }
+
+ virtual bool onClick(Click* click) {
+ return this->INHERITED::onClick(click);
+ }
+
+private:
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new ShaderView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleShapes.cpp b/samplecode/SampleShapes.cpp
new file mode 100644
index 0000000..dc10f1a
--- /dev/null
+++ b/samplecode/SampleShapes.cpp
@@ -0,0 +1,160 @@
+#include "SampleCode.h"
+#include "SkCanvas.h"
+#include "SkPaint.h"
+#include "SkPicture.h"
+#include "SkStream.h"
+#include "SkView.h"
+
+#define DO_AA true
+
+#include "SkRectShape.h"
+#include "SkGroupShape.h"
+
+static SkRect make_rect(int l, int t, int r, int b) {
+ SkRect rect;
+ rect.set(SkIntToScalar(l), SkIntToScalar(t),
+ SkIntToScalar(r), SkIntToScalar(b));
+ return rect;
+}
+
+static SkShape* make_shape0(bool red) {
+ SkRectShape* s = new SkRectShape;
+ s->setRect(make_rect(10, 10, 90, 90));
+ if (red) {
+ s->paint().setColor(SK_ColorRED);
+ }
+ s->paint().setAntiAlias(DO_AA);
+ return s;
+}
+
+static SkShape* make_shape1() {
+ SkRectShape* s = new SkRectShape;
+ s->setOval(make_rect(10, 10, 90, 90));
+ s->paint().setColor(SK_ColorBLUE);
+ s->paint().setAntiAlias(DO_AA);
+ return s;
+}
+
+static SkShape* make_shape2() {
+ SkRectShape* s = new SkRectShape;
+ s->setRRect(make_rect(10, 10, 90, 90),
+ SkIntToScalar(20), SkIntToScalar(20));
+ s->paint().setColor(SK_ColorGREEN);
+ s->paint().setAntiAlias(DO_AA);
+ return s;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+class ShapesView : public SampleView {
+ SkGroupShape fGroup;
+ SkMatrixRef* fMatrixRefs[4];
+public:
+ ShapesView() {
+ SkMatrix m;
+ fGroup.appendShape(make_shape0(false))->unref();
+ m.setRotate(SkIntToScalar(30), SkIntToScalar(50), SkIntToScalar(50));
+ m.postTranslate(0, SkIntToScalar(120));
+ fGroup.appendShape(make_shape0(true), m)->unref();
+
+ m.setTranslate(SkIntToScalar(120), 0);
+ fGroup.appendShape(make_shape1(), m)->unref();
+ m.postTranslate(0, SkIntToScalar(120));
+ fGroup.appendShape(make_shape2(), m)->unref();
+
+ for (size_t i = 0; i < SK_ARRAY_COUNT(fMatrixRefs); i++) {
+ SkSafeRef(fMatrixRefs[i] = fGroup.getShapeMatrixRef(i));
+ }
+
+ this->setBGColor(0xFFDDDDDD);
+ }
+
+ virtual ~ShapesView() {
+ for (size_t i = 0; i < SK_ARRAY_COUNT(fMatrixRefs); i++) {
+ SkSafeUnref(fMatrixRefs[i]);
+ }
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "Shapes");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ void drawpicture(SkCanvas* canvas, SkPicture& pict) {
+#if 0
+ SkDynamicMemoryWStream ostream;
+ pict.serialize(&ostream);
+
+ SkMemoryStream istream(ostream.getStream(), ostream.getOffset());
+ SkPicture* newPict = new SkPicture(&istream);
+ canvas->drawPicture(*newPict);
+ newPict->unref();
+#else
+ canvas->drawPicture(pict);
+#endif
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ SkScalar angle = SampleCode::GetAnimScalar(SkIntToScalar(180),
+ SkIntToScalar(360));
+
+ SkMatrix saveM = *fMatrixRefs[3];
+ SkScalar c = SkIntToScalar(50);
+ fMatrixRefs[3]->preRotate(angle, c, c);
+
+ const SkScalar dx = 350;
+ const SkScalar dy = 500;
+ const int N = 1;
+ for (int v = -N; v <= N; v++) {
+ for (int h = -N; h <= N; h++) {
+ SkAutoCanvasRestore acr(canvas, true);
+ canvas->translate(h * dx, v * dy);
+
+ SkMatrix matrix;
+
+ SkGroupShape* gs = new SkGroupShape;
+ SkAutoUnref aur(gs);
+ gs->appendShape(&fGroup);
+ matrix.setScale(-SK_Scalar1, SK_Scalar1);
+ matrix.postTranslate(SkIntToScalar(220), SkIntToScalar(240));
+ gs->appendShape(&fGroup, matrix);
+ matrix.setTranslate(SkIntToScalar(240), 0);
+ matrix.preScale(SK_Scalar1*2, SK_Scalar1*2);
+ gs->appendShape(&fGroup, matrix);
+
+#if 0
+ canvas->drawShape(gs);
+#else
+ SkPicture* pict = new SkPicture;
+ SkCanvas* cv = pict->beginRecording(1000, 1000);
+ cv->scale(SK_ScalarHalf, SK_ScalarHalf);
+ cv->drawShape(gs);
+ cv->translate(SkIntToScalar(680), SkIntToScalar(480));
+ cv->scale(-SK_Scalar1, SK_Scalar1);
+ cv->drawShape(gs);
+ pict->endRecording();
+
+ drawpicture(canvas, *pict);
+ pict->unref();
+#endif
+
+ }}
+
+ *fMatrixRefs[3] = saveM;
+ this->inval(NULL);
+}
+
+private:
+ typedef SampleView INHERITED;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new ShapesView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleSkLayer.cpp b/samplecode/SampleSkLayer.cpp
new file mode 100644
index 0000000..11976e9
--- /dev/null
+++ b/samplecode/SampleSkLayer.cpp
@@ -0,0 +1,239 @@
+#include "SampleCode.h"
+#include "SkCanvas.h"
+#include "SkPaint.h"
+#include "SkView.h"
+#include "SkLayer.h"
+
+#include "SkMatrix44.h"
+static void test_inv(const char label[], const SkMatrix44& mat) {
+ SkDebugf("%s\n", label);
+ mat.dump();
+
+ SkMatrix44 inv;
+ if (mat.invert(&inv)) {
+ inv.dump();
+ } else {
+ SkDebugf("--- invert failed\n");
+ }
+
+ SkMatrix44 a, b;
+ a.setConcat(mat, inv);
+ b.setConcat(inv, mat);
+ SkDebugf("concat mat with inverse pre=%d post=%d\n", a.isIdentity(), b.isIdentity());
+ if (!a.isIdentity()) {
+ a.dump();
+ }
+ if (!b.isIdentity()) {
+ b.dump();
+ }
+ SkDebugf("\n");
+}
+
+static void test_map(SkScalar x0, SkScalar y0, SkScalar z0,
+ const SkMatrix44& mat,
+ SkScalar x1, SkScalar y1, SkScalar z1) {
+ SkVector4 src, dst;
+ src.set(x0, y0, z0);
+ dst = mat * src;
+ SkDebugf("map: src: %g %g %g dst: %g %g %g (%g) expected: %g %g %g match: %d\n",
+ x0, y0, z0,
+ dst.fData[0], dst.fData[1], dst.fData[2], dst.fData[3],
+ x1, y1, z1,
+ dst.fData[0] == x1 && dst.fData[1] == y1 && dst.fData[2] == z1);
+}
+
+static void test_33(const SkMatrix44& mat,
+ SkScalar x0, SkScalar x1, SkScalar x2,
+ SkScalar y0, SkScalar y1, SkScalar y2) {
+ SkMatrix dst = mat;
+ if (dst[0] != x0 || dst[1] != x1 || dst[2] != x2 ||
+ dst[3] != y0 || dst[4] != y1 || dst[5] != y2) {
+ SkString str;
+ dst.toDumpString(&str);
+ SkDebugf("3x3: expected 3x3 [%g %g %g] [%g %g %g] bug got %s\n",
+ x0, x1, x2, y0, y1, y2, str.c_str());
+ }
+}
+
+static void test44() {
+ SkMatrix44 m0, m1, m2;
+
+ test_inv("identity", m0);
+ m0.setTranslate(2,3,4);
+ test_inv("translate", m0);
+ m0.setScale(2,3,4);
+ test_inv("scale", m0);
+ m0.postTranslate(5, 6, 7);
+ test_inv("postTranslate", m0);
+ m0.setScale(2,3,4);
+ m1.setTranslate(5, 6, 7);
+ m0.setConcat(m0, m1);
+ test_inv("postTranslate2", m0);
+ m0.setScale(2,3,4);
+ m0.preTranslate(5, 6, 7);
+ test_inv("preTranslate", m0);
+
+ m0.setScale(2, 4, 6);
+ m0.postScale(SkDoubleToMScalar(0.5));
+ test_inv("scale/postscale to 1,2,3", m0);
+
+ m0.reset();
+ test_map(1, 0, 0, m0, 1, 0, 0);
+ test_map(0, 1, 0, m0, 0, 1, 0);
+ test_map(0, 0, 1, m0, 0, 0, 1);
+ m0.setScale(2, 3, 4);
+ test_map(1, 0, 0, m0, 2, 0, 0);
+ test_map(0, 1, 0, m0, 0, 3, 0);
+ test_map(0, 0, 1, m0, 0, 0, 4);
+ m0.setTranslate(2, 3, 4);
+ test_map(0, 0, 0, m0, 2, 3, 4);
+ m0.preScale(5, 6, 7);
+ test_map(1, 0, 0, m0, 7, 3, 4);
+ test_map(0, 1, 0, m0, 2, 9, 4);
+ test_map(0, 0, 1, m0, 2, 3, 11);
+
+ SkMScalar deg = 45;
+ m0.setRotateDegreesAbout(0, 0, 1, deg);
+ test_map(1, 0, 0, m0, 0.707106769, -0.707106769, 0);
+
+ m0.reset();
+ test_33(m0, 1, 0, 0, 0, 1, 0);
+ m0.setTranslate(3, 4, 5);
+ test_33(m0, 1, 0, 3, 0, 1, 4);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static void dump_layers(const SkLayer* layer, int tab = 0) {
+ SkMatrix matrix;
+ SkString matrixStr;
+
+ layer->getLocalTransform(&matrix);
+ matrix.toDumpString(&matrixStr);
+
+ for (int j = 0; j < tab; j++) {
+ SkDebugf(" ");
+ }
+ SkDebugf("layer=%p parent=%p size=[%g %g] transform=%s\n",
+ layer, layer->getParent(), layer->getWidth(), layer->getHeight(),
+ matrixStr.c_str());
+ for (int i = 0; i < layer->countChildren(); i++) {
+ dump_layers(layer->getChild(i), tab + 4);
+ }
+}
+
+class TestLayer : public SkLayer {
+public:
+ TestLayer(SkColor c) : fColor(c) {}
+
+protected:
+ virtual void onDraw(SkCanvas* canvas, SkScalar opacity) {
+ SkRect r;
+ r.set(0, 0, this->getWidth(), this->getHeight());
+
+ SkPaint paint;
+ paint.setColor(fColor);
+ paint.setAlpha(SkScalarRound(opacity * 255));
+
+ canvas->drawRect(r, paint);
+ }
+
+private:
+ SkColor fColor;
+};
+
+class SkLayerView : public SkView {
+private:
+ SkLayer* fRootLayer;
+ SkLayer* fLastChild;
+public:
+ SkLayerView() {
+ test44();
+ static const int W = 600;
+ static const int H = 440;
+ static const struct {
+ int fWidth;
+ int fHeight;
+ SkColor fColor;
+ int fPosX;
+ int fPosY;
+ } gData[] = {
+ { 120, 80, SK_ColorRED, 0, 0 },
+ { 120, 80, SK_ColorGREEN, W - 120, 0 },
+ { 120, 80, SK_ColorBLUE, 0, H - 80 },
+ { 120, 80, SK_ColorMAGENTA, W - 120, H - 80 },
+ };
+
+ fRootLayer = new TestLayer(0xFFDDDDDD);
+ fRootLayer->setSize(W, H);
+ for (size_t i = 0; i < SK_ARRAY_COUNT(gData); i++) {
+ SkLayer* child = new TestLayer(gData[i].fColor);
+ child->setSize(gData[i].fWidth, gData[i].fHeight);
+ child->setPosition(gData[i].fPosX, gData[i].fPosY);
+ fRootLayer->addChild(child)->unref();
+ }
+
+ SkLayer* child = new TestLayer(0xFFDD8844);
+ child->setSize(120, 80);
+ child->setPosition(fRootLayer->getWidth()/2 - child->getWidth()/2,
+ fRootLayer->getHeight()/2 - child->getHeight()/2);
+ child->setAnchorPoint(SK_ScalarHalf, SK_ScalarHalf);
+ {
+ SkMatrix m;
+ m.setRotate(SkIntToScalar(30));
+ child->setMatrix(m);
+ }
+ fLastChild = child;
+ fRootLayer->addChild(child)->unref();
+
+ if (false) {
+ SkMatrix matrix;
+ matrix.setScale(0.5, 0.5);
+ fRootLayer->setMatrix(matrix);
+ }
+
+// dump_layers(fRootLayer);
+ }
+
+ virtual ~SkLayerView() {
+ SkSafeUnref(fRootLayer);
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "SkLayer");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ virtual void onDraw(SkCanvas* canvas) {
+ canvas->drawColor(SK_ColorWHITE);
+
+ canvas->translate(20, 20);
+ fRootLayer->draw(canvas);
+
+ // visual test of getLocalTransform
+ if (true) {
+ SkMatrix matrix;
+ fLastChild->localToGlobal(&matrix);
+ SkPaint paint;
+ paint.setStyle(SkPaint::kStroke_Style);
+ paint.setStrokeWidth(5);
+ paint.setColor(0x88FF0000);
+ canvas->concat(matrix);
+ canvas->drawRect(SkRect::MakeSize(fLastChild->getSize()), paint);
+ }
+ }
+
+private:
+ typedef SkView INHERITED;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new SkLayerView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleSlides.cpp b/samplecode/SampleSlides.cpp
new file mode 100644
index 0000000..3b7d05b
--- /dev/null
+++ b/samplecode/SampleSlides.cpp
@@ -0,0 +1,804 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkDevice.h"
+#include "SkPaint.h"
+
+#define BG_COLOR 0xFFDDDDDD
+
+typedef void (*SlideProc)(SkCanvas*);
+
+///////////////////////////////////////////////////////////////////////////////
+
+#include "Sk1DPathEffect.h"
+#include "Sk2DPathEffect.h"
+#include "SkCornerPathEffect.h"
+#include "SkDashPathEffect.h"
+#include "SkDiscretePathEffect.h"
+
+static void compose_pe(SkPaint* paint) {
+ SkPathEffect* pe = paint->getPathEffect();
+ SkPathEffect* corner = new SkCornerPathEffect(25);
+ SkPathEffect* compose;
+ if (pe) {
+ compose = new SkComposePathEffect(pe, corner);
+ corner->unref();
+ } else {
+ compose = corner;
+ }
+ paint->setPathEffect(compose)->unref();
+}
+
+static void hair_pe(SkPaint* paint) {
+ paint->setStrokeWidth(0);
+}
+
+static void hair2_pe(SkPaint* paint) {
+ paint->setStrokeWidth(0);
+ compose_pe(paint);
+}
+
+static void stroke_pe(SkPaint* paint) {
+ paint->setStrokeWidth(12);
+ compose_pe(paint);
+}
+
+static void dash_pe(SkPaint* paint) {
+ SkScalar inter[] = { 20, 10, 10, 10 };
+ paint->setStrokeWidth(12);
+ paint->setPathEffect(new SkDashPathEffect(inter, SK_ARRAY_COUNT(inter),
+ 0))->unref();
+ compose_pe(paint);
+}
+
+static const int gXY[] = {
+4, 0, 0, -4, 8, -4, 12, 0, 8, 4, 0, 4
+};
+
+static void scale(SkPath* path, SkScalar scale) {
+ SkMatrix m;
+ m.setScale(scale, scale);
+ path->transform(m);
+}
+
+static void one_d_pe(SkPaint* paint) {
+ SkPath path;
+ path.moveTo(SkIntToScalar(gXY[0]), SkIntToScalar(gXY[1]));
+ for (unsigned i = 2; i < SK_ARRAY_COUNT(gXY); i += 2)
+ path.lineTo(SkIntToScalar(gXY[i]), SkIntToScalar(gXY[i+1]));
+ path.close();
+ path.offset(SkIntToScalar(-6), 0);
+ scale(&path, 1.5);
+
+ paint->setPathEffect(new SkPath1DPathEffect(path, SkIntToScalar(21), 0,
+ SkPath1DPathEffect::kRotate_Style))->unref();
+ compose_pe(paint);
+}
+
+typedef void (*PE_Proc)(SkPaint*);
+static const PE_Proc gPE[] = { hair_pe, hair2_pe, stroke_pe, dash_pe, one_d_pe };
+
+static void fill_pe(SkPaint* paint) {
+ paint->setStyle(SkPaint::kFill_Style);
+ paint->setPathEffect(NULL);
+}
+
+static void discrete_pe(SkPaint* paint) {
+ paint->setPathEffect(new SkDiscretePathEffect(10, 4))->unref();
+}
+
+class TilePathEffect : public Sk2DPathEffect {
+ static SkMatrix make_mat() {
+ SkMatrix m;
+ m.setScale(12, 12);
+ return m;
+ }
+public:
+ TilePathEffect() : Sk2DPathEffect(make_mat()) {}
+
+protected:
+ virtual void next(const SkPoint& loc, int u, int v, SkPath* dst) {
+ dst->addCircle(loc.fX, loc.fY, 5);
+ }
+};
+
+static void tile_pe(SkPaint* paint) {
+ paint->setPathEffect(new TilePathEffect)->unref();
+}
+
+static const PE_Proc gPE2[] = { fill_pe, discrete_pe, tile_pe };
+
+static void patheffect_slide(SkCanvas* canvas) {
+ SkPaint paint;
+ paint.setAntiAlias(true);
+ paint.setStyle(SkPaint::kStroke_Style);
+
+ SkPath path;
+ path.moveTo(20, 20);
+ path.lineTo(70, 120);
+ path.lineTo(120, 30);
+ path.lineTo(170, 80);
+ path.lineTo(240, 50);
+
+ size_t i;
+ canvas->save();
+ for (i = 0; i < SK_ARRAY_COUNT(gPE); i++) {
+ gPE[i](&paint);
+ canvas->drawPath(path, paint);
+ canvas->translate(0, 75);
+ }
+ canvas->restore();
+
+ path.reset();
+ SkRect r = { 0, 0, 250, 120 };
+ path.addOval(r, SkPath::kCW_Direction);
+ r.inset(50, 50);
+ path.addRect(r, SkPath::kCCW_Direction);
+
+ canvas->translate(320, 20);
+ for (i = 0; i < SK_ARRAY_COUNT(gPE2); i++) {
+ gPE2[i](&paint);
+ canvas->drawPath(path, paint);
+ canvas->translate(0, 160);
+ }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+#include "SkGradientShader.h"
+
+struct GradData {
+ int fCount;
+ const SkColor* fColors;
+ const SkScalar* fPos;
+};
+
+static const SkColor gColors[] = {
+SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorWHITE, SK_ColorBLACK
+};
+static const SkScalar gPos0[] = { 0, SK_Scalar1 };
+static const SkScalar gPos1[] = { SK_Scalar1/4, SK_Scalar1*3/4 };
+static const SkScalar gPos2[] = {
+0, SK_Scalar1/8, SK_Scalar1/2, SK_Scalar1*7/8, SK_Scalar1
+};
+
+static const GradData gGradData[] = {
+{ 2, gColors, NULL },
+{ 2, gColors, gPos0 },
+{ 2, gColors, gPos1 },
+{ 5, gColors, NULL },
+{ 5, gColors, gPos2 }
+};
+
+static SkShader* MakeLinear(const SkPoint pts[2], const GradData& data,
+ SkShader::TileMode tm, SkUnitMapper* mapper) {
+ return SkGradientShader::CreateLinear(pts, data.fColors, data.fPos,
+ data.fCount, tm, mapper);
+}
+
+static SkShader* MakeRadial(const SkPoint pts[2], const GradData& data,
+ SkShader::TileMode tm, SkUnitMapper* mapper) {
+ SkPoint center;
+ center.set(SkScalarAve(pts[0].fX, pts[1].fX),
+ SkScalarAve(pts[0].fY, pts[1].fY));
+ return SkGradientShader::CreateRadial(center, center.fX, data.fColors,
+ data.fPos, data.fCount, tm, mapper);
+}
+
+static SkShader* MakeSweep(const SkPoint pts[2], const GradData& data,
+ SkShader::TileMode tm, SkUnitMapper* mapper) {
+ SkPoint center;
+ center.set(SkScalarAve(pts[0].fX, pts[1].fX),
+ SkScalarAve(pts[0].fY, pts[1].fY));
+ return SkGradientShader::CreateSweep(center.fX, center.fY, data.fColors,
+ data.fPos, data.fCount, mapper);
+}
+
+static SkShader* Make2Radial(const SkPoint pts[2], const GradData& data,
+ SkShader::TileMode tm, SkUnitMapper* mapper) {
+ SkPoint center0, center1;
+ center0.set(SkScalarAve(pts[0].fX, pts[1].fX),
+ SkScalarAve(pts[0].fY, pts[1].fY));
+ center1.set(SkScalarInterp(pts[0].fX, pts[1].fX, SkIntToScalar(3)/5),
+ SkScalarInterp(pts[0].fY, pts[1].fY, SkIntToScalar(1)/4));
+ return SkGradientShader::CreateTwoPointRadial(
+ center1, (pts[1].fX - pts[0].fX) / 7,
+ center0, (pts[1].fX - pts[0].fX) / 2,
+ data.fColors, data.fPos, data.fCount, tm, mapper);
+}
+
+typedef SkShader* (*GradMaker)(const SkPoint pts[2], const GradData& data,
+ SkShader::TileMode tm, SkUnitMapper* mapper);
+static const GradMaker gGradMakers[] = {
+ MakeLinear, MakeRadial, MakeSweep, Make2Radial
+};
+
+static void gradient_slide(SkCanvas* canvas) {
+ SkPoint pts[2] = {
+ { 0, 0 },
+ { SkIntToScalar(100), SkIntToScalar(100) }
+ };
+ SkShader::TileMode tm = SkShader::kClamp_TileMode;
+ SkRect r = { 0, 0, SkIntToScalar(100), SkIntToScalar(100) };
+ SkPaint paint;
+ paint.setAntiAlias(true);
+ paint.setDither(true);
+
+ canvas->translate(SkIntToScalar(20), SkIntToScalar(10));
+ for (size_t i = 0; i < SK_ARRAY_COUNT(gGradData); i++) {
+ canvas->save();
+ for (size_t j = 0; j < SK_ARRAY_COUNT(gGradMakers); j++) {
+ SkShader* shader = gGradMakers[j](pts, gGradData[i], tm, NULL);
+ paint.setShader(shader);
+ canvas->drawRect(r, paint);
+ shader->unref();
+ canvas->translate(0, SkIntToScalar(120));
+ }
+ canvas->restore();
+ canvas->translate(SkIntToScalar(120), 0);
+ }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+#include "SkPathMeasure.h"
+
+static SkScalar getpathlen(const SkPath& path) {
+ SkPathMeasure meas(path, false);
+ return meas.getLength();
+}
+
+static void textonpath_slide(SkCanvas* canvas) {
+ const char* text = "Displacement";
+ size_t len =strlen(text);
+ SkPath path;
+ path.moveTo(100, 300);
+ path.quadTo(300, 100, 500, 300);
+ path.offset(0, -100);
+
+ SkPaint paint;
+ paint.setAntiAlias(true);
+ paint.setTextSize(40);
+
+ paint.setStyle(SkPaint::kStroke_Style);
+ canvas->drawPath(path, paint);
+ paint.setStyle(SkPaint::kFill_Style);
+
+ SkScalar x = 50;
+ paint.setColor(0xFF008800);
+ canvas->drawTextOnPathHV(text, len, path,
+ x, paint.getTextSize()*2/3, paint);
+ paint.setColor(SK_ColorRED);
+ canvas->drawTextOnPathHV(text, len, path,
+ x + 60, 0, paint);
+ paint.setColor(SK_ColorBLUE);
+ canvas->drawTextOnPathHV(text, len, path,
+ x + 120, -paint.getTextSize()*2/3, paint);
+
+ path.offset(0, 200);
+ paint.setTextAlign(SkPaint::kRight_Align);
+
+ text = "Matrices";
+ len = strlen(text);
+ SkScalar pathLen = getpathlen(path);
+ SkMatrix matrix;
+
+ paint.setColor(SK_ColorBLACK);
+ paint.setStyle(SkPaint::kStroke_Style);
+ canvas->drawPath(path, paint);
+ paint.setStyle(SkPaint::kFill_Style);
+
+ paint.setTextSize(50);
+ canvas->drawTextOnPath(text, len, path, NULL, paint);
+
+ paint.setColor(SK_ColorRED);
+ matrix.setScale(-SK_Scalar1, SK_Scalar1);
+ matrix.postTranslate(pathLen, 0);
+ canvas->drawTextOnPath(text, len, path, &matrix, paint);
+
+ paint.setColor(SK_ColorBLUE);
+ matrix.setScale(SK_Scalar1, -SK_Scalar1);
+ canvas->drawTextOnPath(text, len, path, &matrix, paint);
+
+ paint.setColor(0xFF008800);
+ matrix.setScale(-SK_Scalar1, -SK_Scalar1);
+ matrix.postTranslate(pathLen, 0);
+ canvas->drawTextOnPath(text, len, path, &matrix, paint);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+#include "SkImageDecoder.h"
+#include "SkOSFile.h"
+#include "SkRandom.h"
+#include "SkStream.h"
+#include "SkNinePatch.h"
+
+static SkShader* make_shader0(SkIPoint* size) {
+ SkBitmap bm;
+
+ SkImageDecoder::DecodeFile("/skimages/logo.gif", &bm);
+ size->set(bm.width(), bm.height());
+ return SkShader::CreateBitmapShader(bm, SkShader::kClamp_TileMode,
+ SkShader::kClamp_TileMode);
+}
+
+static SkShader* make_shader1(const SkIPoint& size) {
+ SkPoint pts[] = { { 0, 0 },
+ { SkIntToScalar(size.fX), SkIntToScalar(size.fY) } };
+ SkColor colors[] = { SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorRED };
+ return SkGradientShader::CreateLinear(pts, colors, NULL,
+ SK_ARRAY_COUNT(colors), SkShader::kMirror_TileMode, NULL);
+}
+
+class Rec {
+public:
+ SkCanvas::VertexMode fMode;
+ int fCount;
+ SkPoint* fVerts;
+ SkPoint* fTexs;
+
+ Rec() : fCount(0), fVerts(NULL), fTexs(NULL) {}
+ ~Rec() { delete[] fVerts; delete[] fTexs; }
+};
+
+void make_tris(Rec* rec) {
+ int n = 10;
+ SkRandom rand;
+
+ rec->fMode = SkCanvas::kTriangles_VertexMode;
+ rec->fCount = n * 3;
+ rec->fVerts = new SkPoint[rec->fCount];
+
+ for (int i = 0; i < n; i++) {
+ SkPoint* v = &rec->fVerts[i*3];
+ for (int j = 0; j < 3; j++) {
+ v[j].set(rand.nextUScalar1() * 250, rand.nextUScalar1() * 250);
+ }
+ }
+}
+
+void make_fan(Rec* rec, int texWidth, int texHeight) {
+ const SkScalar tx = SkIntToScalar(texWidth);
+ const SkScalar ty = SkIntToScalar(texHeight);
+ const int n = 24;
+
+ rec->fMode = SkCanvas::kTriangleFan_VertexMode;
+ rec->fCount = n + 2;
+ rec->fVerts = new SkPoint[rec->fCount];
+ rec->fTexs = new SkPoint[rec->fCount];
+
+ SkPoint* v = rec->fVerts;
+ SkPoint* t = rec->fTexs;
+
+ v[0].set(0, 0);
+ t[0].set(0, 0);
+ for (int i = 0; i < n; i++) {
+ SkScalar cos;
+ SkScalar sin = SkScalarSinCos(SK_ScalarPI * 2 * i / n, &cos);
+ v[i+1].set(cos, sin);
+ t[i+1].set(i*tx/n, ty);
+ }
+ v[n+1] = v[1];
+ t[n+1].set(tx, ty);
+
+ SkMatrix m;
+ m.setScale(SkIntToScalar(100), SkIntToScalar(100));
+ m.postTranslate(SkIntToScalar(110), SkIntToScalar(110));
+ m.mapPoints(v, rec->fCount);
+}
+
+void make_strip(Rec* rec, int texWidth, int texHeight) {
+ const SkScalar tx = SkIntToScalar(texWidth);
+ const SkScalar ty = SkIntToScalar(texHeight);
+ const int n = 24;
+
+ rec->fMode = SkCanvas::kTriangleStrip_VertexMode;
+ rec->fCount = 2 * (n + 1);
+ rec->fVerts = new SkPoint[rec->fCount];
+ rec->fTexs = new SkPoint[rec->fCount];
+
+ SkPoint* v = rec->fVerts;
+ SkPoint* t = rec->fTexs;
+
+ for (int i = 0; i < n; i++) {
+ SkScalar cos;
+ SkScalar sin = SkScalarSinCos(SK_ScalarPI * 2 * i / n, &cos);
+ v[i*2 + 0].set(cos/2, sin/2);
+ v[i*2 + 1].set(cos, sin);
+
+ t[i*2 + 0].set(tx * i / n, ty);
+ t[i*2 + 1].set(tx * i / n, 0);
+ }
+ v[2*n + 0] = v[0];
+ v[2*n + 1] = v[1];
+
+ t[2*n + 0].set(tx, ty);
+ t[2*n + 1].set(tx, 0);
+
+ SkMatrix m;
+ m.setScale(SkIntToScalar(100), SkIntToScalar(100));
+ m.postTranslate(SkIntToScalar(110), SkIntToScalar(110));
+ m.mapPoints(v, rec->fCount);
+}
+
+static void mesh_slide(SkCanvas* canvas) {
+ Rec fRecs[3];
+ SkIPoint size;
+
+ SkShader* fShader0 = make_shader0(&size);
+ SkShader* fShader1 = make_shader1(size);
+
+ SkAutoUnref aur0(fShader0);
+ SkAutoUnref aur1(fShader1);
+
+ make_strip(&fRecs[0], size.fX, size.fY);
+ make_fan(&fRecs[1], size.fX, size.fY);
+ make_tris(&fRecs[2]);
+
+ SkPaint paint;
+ paint.setDither(true);
+ paint.setFilterBitmap(true);
+
+ for (size_t i = 0; i < SK_ARRAY_COUNT(fRecs); i++) {
+ canvas->save();
+
+ paint.setShader(NULL);
+ canvas->drawVertices(fRecs[i].fMode, fRecs[i].fCount,
+ fRecs[i].fVerts, fRecs[i].fTexs,
+ NULL, NULL, NULL, 0, paint);
+
+ canvas->translate(SkIntToScalar(210), 0);
+
+ paint.setShader(fShader0);
+ canvas->drawVertices(fRecs[i].fMode, fRecs[i].fCount,
+ fRecs[i].fVerts, fRecs[i].fTexs,
+ NULL, NULL, NULL, 0, paint);
+
+ canvas->translate(SkIntToScalar(210), 0);
+
+ paint.setShader(fShader1);
+ canvas->drawVertices(fRecs[i].fMode, fRecs[i].fCount,
+ fRecs[i].fVerts, fRecs[i].fTexs,
+ NULL, NULL, NULL, 0, paint);
+ canvas->restore();
+
+ canvas->translate(0, SkIntToScalar(250));
+ }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+#include "SkGradientShader.h"
+#include "SkLayerRasterizer.h"
+#include "SkBlurMaskFilter.h"
+
+static void r0(SkLayerRasterizer* rast, SkPaint& p)
+{
+ p.setMaskFilter(SkBlurMaskFilter::Create(SkIntToScalar(3),
+ SkBlurMaskFilter::kNormal_BlurStyle))->unref();
+ rast->addLayer(p, SkIntToScalar(3), SkIntToScalar(3));
+
+ p.setMaskFilter(NULL);
+ p.setStyle(SkPaint::kStroke_Style);
+ p.setStrokeWidth(SK_Scalar1);
+ rast->addLayer(p);
+
+ p.setAlpha(0x11);
+ p.setStyle(SkPaint::kFill_Style);
+ p.setXfermodeMode(SkXfermode::kSrc_Mode);
+ rast->addLayer(p);
+}
+
+static void r1(SkLayerRasterizer* rast, SkPaint& p)
+{
+ rast->addLayer(p);
+
+ p.setAlpha(0x40);
+ p.setXfermodeMode(SkXfermode::kSrc_Mode);
+ p.setStyle(SkPaint::kStroke_Style);
+ p.setStrokeWidth(SK_Scalar1*2);
+ rast->addLayer(p);
+}
+
+static void r2(SkLayerRasterizer* rast, SkPaint& p)
+{
+ p.setStyle(SkPaint::kStrokeAndFill_Style);
+ p.setStrokeWidth(SK_Scalar1*4);
+ rast->addLayer(p);
+
+ p.setStyle(SkPaint::kStroke_Style);
+ p.setStrokeWidth(SK_Scalar1*3/2);
+ p.setXfermodeMode(SkXfermode::kClear_Mode);
+ rast->addLayer(p);
+}
+
+static void r3(SkLayerRasterizer* rast, SkPaint& p)
+{
+ p.setStyle(SkPaint::kStroke_Style);
+ p.setStrokeWidth(SK_Scalar1*3);
+ rast->addLayer(p);
+
+ p.setAlpha(0x20);
+ p.setStyle(SkPaint::kFill_Style);
+ p.setXfermodeMode(SkXfermode::kSrc_Mode);
+ rast->addLayer(p);
+}
+
+static void r4(SkLayerRasterizer* rast, SkPaint& p)
+{
+ p.setAlpha(0x60);
+ rast->addLayer(p, SkIntToScalar(3), SkIntToScalar(3));
+
+ p.setAlpha(0xFF);
+ p.setXfermodeMode(SkXfermode::kClear_Mode);
+ rast->addLayer(p, SK_Scalar1*3/2, SK_Scalar1*3/2);
+
+ p.setXfermode(NULL);
+ rast->addLayer(p);
+}
+
+#include "SkDiscretePathEffect.h"
+
+static void r5(SkLayerRasterizer* rast, SkPaint& p)
+{
+ rast->addLayer(p);
+
+ p.setPathEffect(new SkDiscretePathEffect(SK_Scalar1*4, SK_Scalar1*3))->unref();
+ p.setXfermodeMode(SkXfermode::kSrcOut_Mode);
+ rast->addLayer(p);
+}
+
+static void r6(SkLayerRasterizer* rast, SkPaint& p)
+{
+ rast->addLayer(p);
+
+ p.setAntiAlias(false);
+ SkLayerRasterizer* rast2 = new SkLayerRasterizer;
+ r5(rast2, p);
+ p.setRasterizer(rast2)->unref();
+ p.setXfermodeMode(SkXfermode::kClear_Mode);
+ rast->addLayer(p);
+}
+
+#include "Sk2DPathEffect.h"
+
+class Dot2DPathEffect : public Sk2DPathEffect {
+public:
+ Dot2DPathEffect(SkScalar radius, const SkMatrix& matrix)
+ : Sk2DPathEffect(matrix), fRadius(radius) {}
+
+ virtual void flatten(SkFlattenableWriteBuffer& buffer)
+ {
+ this->INHERITED::flatten(buffer);
+
+ buffer.writeScalar(fRadius);
+ }
+ virtual Factory getFactory() { return CreateProc; }
+
+protected:
+ virtual void next(const SkPoint& loc, int u, int v, SkPath* dst)
+ {
+ dst->addCircle(loc.fX, loc.fY, fRadius);
+ }
+
+ Dot2DPathEffect(SkFlattenableReadBuffer& buffer) : Sk2DPathEffect(buffer)
+ {
+ fRadius = buffer.readScalar();
+ }
+private:
+ SkScalar fRadius;
+
+ static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer)
+ {
+ return new Dot2DPathEffect(buffer);
+ }
+
+ typedef Sk2DPathEffect INHERITED;
+};
+
+static void r7(SkLayerRasterizer* rast, SkPaint& p)
+{
+ SkMatrix lattice;
+ lattice.setScale(SK_Scalar1*6, SK_Scalar1*6, 0, 0);
+ lattice.postSkew(SK_Scalar1/3, 0, 0, 0);
+ p.setPathEffect(new Dot2DPathEffect(SK_Scalar1*4, lattice))->unref();
+ rast->addLayer(p);
+}
+
+static void r8(SkLayerRasterizer* rast, SkPaint& p)
+{
+ rast->addLayer(p);
+
+ SkMatrix lattice;
+ lattice.setScale(SK_Scalar1*6, SK_Scalar1*6, 0, 0);
+ lattice.postSkew(SK_Scalar1/3, 0, 0, 0);
+ p.setPathEffect(new Dot2DPathEffect(SK_Scalar1*2, lattice))->unref();
+ p.setXfermodeMode(SkXfermode::kClear_Mode);
+ rast->addLayer(p);
+
+ p.setPathEffect(NULL);
+ p.setXfermode(NULL);
+ p.setStyle(SkPaint::kStroke_Style);
+ p.setStrokeWidth(SK_Scalar1);
+ rast->addLayer(p);
+}
+
+class Line2DPathEffect : public Sk2DPathEffect {
+public:
+ Line2DPathEffect(SkScalar width, const SkMatrix& matrix)
+ : Sk2DPathEffect(matrix), fWidth(width) {}
+
+ virtual bool filterPath(SkPath* dst, const SkPath& src, SkScalar* width)
+ {
+ if (this->INHERITED::filterPath(dst, src, width))
+ {
+ *width = fWidth;
+ return true;
+ }
+ return false;
+ }
+
+ virtual Factory getFactory() { return CreateProc; }
+ virtual void flatten(SkFlattenableWriteBuffer& buffer)
+ {
+ this->INHERITED::flatten(buffer);
+ buffer.writeScalar(fWidth);
+ }
+protected:
+ virtual void nextSpan(int u, int v, int ucount, SkPath* dst)
+ {
+ if (ucount > 1)
+ {
+ SkPoint src[2], dstP[2];
+
+ src[0].set(SkIntToScalar(u) + SK_ScalarHalf,
+ SkIntToScalar(v) + SK_ScalarHalf);
+ src[1].set(SkIntToScalar(u+ucount) + SK_ScalarHalf,
+ SkIntToScalar(v) + SK_ScalarHalf);
+ this->getMatrix().mapPoints(dstP, src, 2);
+
+ dst->moveTo(dstP[0]);
+ dst->lineTo(dstP[1]);
+ }
+ }
+
+ Line2DPathEffect(SkFlattenableReadBuffer& buffer) : Sk2DPathEffect(buffer)
+ {
+ fWidth = buffer.readScalar();
+ }
+
+private:
+ SkScalar fWidth;
+
+ static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer)
+ {
+ return new Line2DPathEffect(buffer);
+ }
+
+ typedef Sk2DPathEffect INHERITED;
+};
+
+static void r9(SkLayerRasterizer* rast, SkPaint& p)
+{
+ rast->addLayer(p);
+
+ SkMatrix lattice;
+ lattice.setScale(SK_Scalar1, SK_Scalar1*6, 0, 0);
+ lattice.postRotate(SkIntToScalar(30), 0, 0);
+ p.setPathEffect(new Line2DPathEffect(SK_Scalar1*2, lattice))->unref();
+ p.setXfermodeMode(SkXfermode::kClear_Mode);
+ rast->addLayer(p);
+
+ p.setPathEffect(NULL);
+ p.setXfermode(NULL);
+ p.setStyle(SkPaint::kStroke_Style);
+ p.setStrokeWidth(SK_Scalar1);
+ rast->addLayer(p);
+}
+
+typedef void (*raster_proc)(SkLayerRasterizer*, SkPaint&);
+
+static const raster_proc gRastProcs[] = {
+ r0, r1, r2, r3, r4, r5, r6, r7, r8, r9
+};
+
+static void apply_shader(SkPaint* paint, int index) {
+ raster_proc proc = gRastProcs[index];
+ SkPaint p;
+ SkLayerRasterizer* rast = new SkLayerRasterizer;
+
+ p.setAntiAlias(true);
+ proc(rast, p);
+ paint->setRasterizer(rast)->unref();
+ paint->setColor(SK_ColorBLUE);
+}
+
+#include "SkTypeface.h"
+
+static void texteffect_slide(SkCanvas* canvas) {
+ const char* str = "Google";
+ size_t len = strlen(str);
+ SkScalar x = 20;
+ SkScalar y = 80;
+ SkPaint paint;
+ paint.setTypeface(SkTypeface::CreateFromName("Georgia", SkTypeface::kItalic));
+ paint.setTextSize(75);
+ paint.setAntiAlias(true);
+ paint.setColor(SK_ColorBLUE);
+ for (size_t i = 0; i < SK_ARRAY_COUNT(gRastProcs); i++) {
+ apply_shader(&paint, i);
+ canvas->drawText(str, len, x, y, paint);
+ y += 80;
+ if (i == 4) {
+ x += 320;
+ y = 80;
+ }
+ }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+#include "SkImageEncoder.h"
+
+static const SlideProc gProc[] = {
+ patheffect_slide,
+ gradient_slide,
+ textonpath_slide,
+ mesh_slide,
+ texteffect_slide
+};
+
+class SlideView : public SampleView {
+ int fIndex;
+public:
+ SlideView() {
+ fIndex = 0;
+
+ SkBitmap bm;
+ bm.setConfig(SkBitmap::kARGB_8888_Config, 1024, 768);
+ bm.allocPixels();
+ SkCanvas canvas(bm);
+ SkScalar s = SkIntToScalar(1024) / 640;
+ canvas.scale(s, s);
+ for (size_t i = 0; i < SK_ARRAY_COUNT(gProc); i++) {
+ canvas.save();
+ canvas.drawColor(BG_COLOR);
+ gProc[i](&canvas);
+ canvas.restore();
+ SkString str;
+ str.printf("/skimages/slide_%d.png", i);
+ SkImageEncoder::EncodeFile(str.c_str(), bm, SkImageEncoder::kPNG_Type, 100);
+ }
+ this->setBGColor(BG_COLOR);
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "Slides");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ gProc[fIndex](canvas);
+ }
+
+ virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
+ fIndex = (fIndex + 1) % SK_ARRAY_COUNT(gProc);
+ this->inval(NULL);
+ return NULL;
+ }
+
+private:
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new SlideView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleSpiral.cpp b/samplecode/SampleSpiral.cpp
new file mode 100644
index 0000000..1a41440
--- /dev/null
+++ b/samplecode/SampleSpiral.cpp
@@ -0,0 +1,56 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+
+class SpiralView : public SampleView {
+public:
+ SpiralView() {
+ this->setBGColor(0xFFDDDDDD);
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "Spiral");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ SkPaint paint;
+ paint.setAntiAlias(true);
+ paint.setStyle(SkPaint::kStroke_Style);
+ paint.setStrokeWidth(SkScalarHalf(SkIntToScalar(3)));
+ paint.setStyle(SkPaint::kFill_Style);
+
+ SkRect r;
+ SkScalar l,t,x,y;
+ l = SampleCode::GetAnimScalar(SkIntToScalar(10),
+ SkIntToScalar(400));
+ t = SampleCode::GetAnimScalar(SkIntToScalar(5),
+ SkIntToScalar(200));
+
+ canvas->translate(320,240);
+ for (int i = 0; i < 35; i++) {
+ paint.setColor(0xFFF00FF0 - i * 0x04000000);
+ SkScalar step = SK_ScalarPI / (55 - i);
+ SkScalar angle = t * step;
+ x = (20 + SkIntToScalar(i) * 5) * SkScalarSinCos(angle, &y);
+ y *= (20 + SkIntToScalar(i) * 5);
+ r.set(x, y, x + SkIntToScalar(10), y + SkIntToScalar(10));
+ canvas->drawRect(r, paint);
+ }
+
+ this->inval(NULL);
+ }
+
+private:
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new SpiralView; }
+static SkViewRegister reg(MyFactory);
\ No newline at end of file
diff --git a/samplecode/SampleStrokePath.cpp b/samplecode/SampleStrokePath.cpp
new file mode 100644
index 0000000..ae630ef
--- /dev/null
+++ b/samplecode/SampleStrokePath.cpp
@@ -0,0 +1,217 @@
+#include "SampleCode.h"
+#include "SkCanvas.h"
+#include "SkParsePath.h"
+#include "SkPath.h"
+#include "SkRandom.h"
+#include "SkView.h"
+
+#include "SkBlurMaskFilter.h"
+
+static void test_huge_stroke(SkCanvas* canvas) {
+ SkRect srcR = { 0, 0, 72000, 54000 };
+ SkRect dstR = { 0, 0, 640, 480 };
+
+ SkPath path;
+ path.moveTo(17600, 8000);
+ path.lineTo(52800, 8000);
+ path.lineTo(52800, 41600);
+ path.lineTo(17600, 41600);
+ path.close();
+
+ SkPaint paint;
+ paint.setAntiAlias(true);
+ paint.setStrokeWidth(8000);
+ paint.setStrokeMiter(10);
+ paint.setStrokeCap(SkPaint::kButt_Cap);
+ paint.setStrokeJoin(SkPaint::kRound_Join);
+ paint.setStyle(SkPaint::kStroke_Style);
+
+ SkMatrix matrix;
+ matrix.setRectToRect(srcR, dstR, SkMatrix::kCenter_ScaleToFit);
+ canvas->concat(matrix);
+
+ canvas->drawPath(path, paint);
+}
+
+#if 0
+#include "SkBlurMask.h"
+static void test_blur() {
+ uint8_t cell[9];
+ memset(cell, 0xFF, sizeof(cell));
+ SkMask src;
+ src.fImage = cell;
+ src.fFormat = SkMask::kA8_Format;
+ SkMask dst;
+
+ for (int y = 1; y <= 3; y++) {
+ for (int x = 1; x <= 3; x++) {
+ src.fBounds.set(0, 0, x, y);
+ src.fRowBytes = src.fBounds.width();
+
+ SkScalar radius = 1.f;
+
+ printf("src [%d %d %d %d] radius %g\n", src.fBounds.fLeft, src.fBounds.fTop,
+ src.fBounds.fRight, src.fBounds.fBottom, radius);
+
+ SkBlurMask::Blur(&dst, src, radius, SkBlurMask::kNormal_Style);
+ uint8_t* dstPtr = dst.fImage;
+
+ for (int y = 0; y < dst.fBounds.height(); y++) {
+ for (int x = 0; x < dst.fBounds.width(); x++) {
+ printf(" %02X", dstPtr[x]);
+ }
+ printf("\n");
+ dstPtr += dst.fRowBytes;
+ }
+ }
+ }
+}
+#endif
+
+static void scale_to_width(SkPath* path, SkScalar dstWidth) {
+ const SkRect& bounds = path->getBounds();
+ SkScalar scale = dstWidth / bounds.width();
+ SkMatrix matrix;
+
+ matrix.setScale(scale, scale);
+ path->transform(matrix);
+}
+
+static const struct {
+ SkPaint::Style fStyle;
+ SkPaint::Join fJoin;
+ int fStrokeWidth;
+} gRec[] = {
+ { SkPaint::kFill_Style, SkPaint::kMiter_Join, 0 },
+ { SkPaint::kStroke_Style, SkPaint::kMiter_Join, 0 },
+ { SkPaint::kStroke_Style, SkPaint::kMiter_Join, 10 },
+ { SkPaint::kStrokeAndFill_Style, SkPaint::kMiter_Join, 10 },
+};
+
+class StrokePathView : public SampleView {
+ SkScalar fWidth;
+ SkPath fPath;
+public:
+ StrokePathView() {
+// test_blur();
+ fWidth = SkIntToScalar(120);
+
+#if 0
+ const char str[] =
+ "M 0, 3"
+ "C 10, -10, 30, -10, 0, 28"
+ "C -30, -10, -10, -10, 0, 3"
+ "Z";
+ SkParsePath::FromSVGString(str, &fPath);
+#else
+ fPath.addCircle(0, 0, SkIntToScalar(50), SkPath::kCW_Direction);
+ fPath.addCircle(0, SkIntToScalar(-50), SkIntToScalar(30), SkPath::kCW_Direction);
+#endif
+
+ scale_to_width(&fPath, fWidth);
+ const SkRect& bounds = fPath.getBounds();
+ fPath.offset(-bounds.fLeft, -bounds.fTop);
+
+ this->setBGColor(0xFFDDDDDD);
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "StrokePath");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ SkRandom rand;
+
+ void drawSet(SkCanvas* canvas, SkPaint* paint) {
+ SkAutoCanvasRestore acr(canvas, true);
+
+ for (size_t i = 0; i < SK_ARRAY_COUNT(gRec); i++) {
+ paint->setStyle(gRec[i].fStyle);
+ paint->setStrokeJoin(gRec[i].fJoin);
+ paint->setStrokeWidth(SkIntToScalar(gRec[i].fStrokeWidth));
+ canvas->drawPath(fPath, *paint);
+ canvas->translate(fWidth * 5 / 4, 0);
+ }
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ test_huge_stroke(canvas); return;
+ canvas->translate(SkIntToScalar(10), SkIntToScalar(10));
+
+ SkPaint paint;
+ paint.setAntiAlias(true);
+
+ if (true) {
+ canvas->drawColor(SK_ColorBLACK);
+
+ paint.setTextSize(24);
+ paint.setColor(SK_ColorWHITE);
+ canvas->translate(10, 30);
+
+ static const SkBlurMaskFilter::BlurStyle gStyle[] = {
+ SkBlurMaskFilter::kNormal_BlurStyle,
+ SkBlurMaskFilter::kInner_BlurStyle,
+ SkBlurMaskFilter::kOuter_BlurStyle,
+ SkBlurMaskFilter::kSolid_BlurStyle,
+ };
+ for (int x = 0; x < 5; x++) {
+ SkMaskFilter* mf;
+ SkScalar radius = 4;
+ for (int y = 0; y < 10; y++) {
+ if (x) {
+ mf = SkBlurMaskFilter::Create(radius, gStyle[x - 1]);
+ paint.setMaskFilter(mf)->unref();
+ }
+ canvas->drawText("Title Bar", 9, x*SkIntToScalar(100), y*SkIntToScalar(30), paint);
+ radius *= 0.75f;
+ }
+
+ }
+ return;
+ }
+
+ paint.setColor(SK_ColorBLUE);
+
+#if 1
+ SkPath p;
+ float r = rand.nextUScalar1() + 0.5f;
+ SkScalar x = 0, y = 0;
+ p.moveTo(x, y);
+#if 0
+ p.cubicTo(x-75*r, y+75*r, x-40*r, y+125*r, x, y+85*r);
+ p.cubicTo(x+40*r, y+125*r, x+75*r, y+75*r, x, y);
+#else
+ p.cubicTo(x+75*r, y+75*r, x+40*r, y+125*r, x, y+85*r);
+ p.cubicTo(x-40*r, y+125*r, x-75*r, y+75*r, x, y);
+#endif
+ p.close();
+ fPath = p;
+ fPath.offset(100, 0);
+#endif
+
+ fPath.setFillType(SkPath::kWinding_FillType);
+ drawSet(canvas, &paint);
+
+ canvas->translate(0, fPath.getBounds().height() * 5 / 4);
+ fPath.setFillType(SkPath::kEvenOdd_FillType);
+ drawSet(canvas, &paint);
+ }
+
+ virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
+ this->inval(NULL);
+ return this->INHERITED::onFindClickHandler(x, y);
+ }
+private:
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new StrokePathView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleStrokeRect.cpp b/samplecode/SampleStrokeRect.cpp
new file mode 100644
index 0000000..20c9e2c
--- /dev/null
+++ b/samplecode/SampleStrokeRect.cpp
@@ -0,0 +1,69 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkDevice.h"
+#include "SkPaint.h"
+
+class StrokeRectSample : public SampleView {
+public:
+ StrokeRectSample() {}
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "Stroke Rects");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ SkPaint paint;
+ paint.setAntiAlias(true);
+ paint.setStyle(SkPaint::kStroke_Style);
+ paint.setStrokeWidth(SkIntToScalar(20));
+
+ SkPaint hair;
+ hair.setStyle(SkPaint::kStroke_Style);
+ hair.setColor(SK_ColorRED);
+
+ static const SkISize gSize[] = {
+ { 100, 50 },
+ { 100, 0 },
+ { 0, 50 },
+ { 0, 0 }
+ };
+
+ static const SkPaint::Join gJoin[] = {
+ SkPaint::kMiter_Join,
+ SkPaint::kRound_Join,
+ SkPaint::kBevel_Join
+ };
+
+ canvas->translate(paint.getStrokeWidth(), paint.getStrokeWidth());
+ for (size_t i = 0; i < SK_ARRAY_COUNT(gJoin); ++i) {
+ paint.setStrokeJoin(gJoin[i]);
+
+ canvas->save();
+ for (size_t j = 0; j < SK_ARRAY_COUNT(gSize); ++j) {
+ SkRect r = SkRect::MakeWH(SkIntToScalar(gSize[j].fWidth),
+ SkIntToScalar(gSize[j].fHeight));
+ canvas->drawRect(r, paint);
+ canvas->drawRect(r, hair);
+ canvas->translate(0, SkIntToScalar(100));
+ }
+ canvas->restore();
+ canvas->translate(SkIntToScalar(150), 0);
+ }
+ }
+
+private:
+ typedef SampleView INHERITED;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new StrokeRectSample; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleStrokeText.cpp b/samplecode/SampleStrokeText.cpp
new file mode 100644
index 0000000..bcb9e4f
--- /dev/null
+++ b/samplecode/SampleStrokeText.cpp
@@ -0,0 +1,140 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "Sk64.h"
+#include "SkGradientShader.h"
+#include "SkGraphics.h"
+#include "SkImageDecoder.h"
+#include "SkKernel33MaskFilter.h"
+#include "SkPath.h"
+#include "SkRandom.h"
+#include "SkRegion.h"
+#include "SkShader.h"
+#include "SkUtils.h"
+#include "SkColorPriv.h"
+#include "SkColorFilter.h"
+#include "SkTime.h"
+#include "SkTypeface.h"
+#include "SkXfermode.h"
+
+static void lettersToBitmap(SkBitmap* dst, const char chars[],
+ const SkPaint& original, SkBitmap::Config config) {
+ SkPath path;
+ SkScalar x = 0;
+ SkScalar width;
+ SkPath p;
+ for (size_t i = 0; i < strlen(chars); i++) {
+ original.getTextPath(&chars[i], 1, x, 0, &p);
+ path.addPath(p);
+ original.getTextWidths(&chars[i], 1, &width);
+ x += width;
+ }
+ SkRect bounds = path.getBounds();
+ SkScalar sw = -original.getStrokeWidth();
+ bounds.inset(sw, sw);
+ path.offset(-bounds.fLeft, -bounds.fTop);
+ bounds.offset(-bounds.fLeft, -bounds.fTop);
+
+ int w = SkScalarRound(bounds.width());
+ int h = SkScalarRound(bounds.height());
+ SkPaint paint(original);
+ SkBitmap src;
+ src.setConfig(config, w, h);
+ src.allocPixels();
+ src.eraseColor(0);
+ {
+ SkCanvas canvas(src);
+ paint.setAntiAlias(true);
+ paint.setColor(SK_ColorBLACK);
+ paint.setStyle(SkPaint::kFill_Style);
+ canvas.drawPath(path, paint);
+ }
+
+ dst->setConfig(config, w, h);
+ dst->allocPixels();
+ dst->eraseColor(SK_ColorWHITE);
+ {
+ SkCanvas canvas(*dst);
+ paint.setXfermodeMode(SkXfermode::kDstATop_Mode);
+ canvas.drawBitmap(src, 0, 0, &paint);
+ paint.setColor(original.getColor());
+ paint.setStyle(SkPaint::kStroke_Style);
+ canvas.drawPath(path, paint);
+ }
+}
+
+static void lettersToBitmap2(SkBitmap* dst, const char chars[],
+ const SkPaint& original, SkBitmap::Config config) {
+ SkPath path;
+ SkScalar x = 0;
+ SkScalar width;
+ SkPath p;
+ for (size_t i = 0; i < strlen(chars); i++) {
+ original.getTextPath(&chars[i], 1, x, 0, &p);
+ path.addPath(p);
+ original.getTextWidths(&chars[i], 1, &width);
+ x += width;
+ }
+ SkRect bounds = path.getBounds();
+ SkScalar sw = -original.getStrokeWidth();
+ bounds.inset(sw, sw);
+ path.offset(-bounds.fLeft, -bounds.fTop);
+ bounds.offset(-bounds.fLeft, -bounds.fTop);
+
+ int w = SkScalarRound(bounds.width());
+ int h = SkScalarRound(bounds.height());
+ SkPaint paint(original);
+
+ paint.setAntiAlias(true);
+ paint.setXfermodeMode(SkXfermode::kDstATop_Mode);
+ paint.setColor(original.getColor());
+ paint.setStyle(SkPaint::kStroke_Style);
+
+ dst->setConfig(config, w, h);
+ dst->allocPixels();
+ dst->eraseColor(SK_ColorWHITE);
+
+ SkCanvas canvas(*dst);
+ canvas.drawPath(path, paint);
+}
+
+class StrokeTextView : public SampleView {
+ bool fAA;
+public:
+ StrokeTextView() : fAA(false) {
+ this->setBGColor(0xFFCC8844);
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "StrokeText");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ SkBitmap bm;
+ SkPaint paint;
+
+ paint.setStrokeWidth(SkIntToScalar(6));
+ paint.setTextSize(SkIntToScalar(80));
+// paint.setTypeface(Typeface.DEFAULT_BOLD);
+
+ lettersToBitmap(&bm, "Test Case", paint, SkBitmap::kARGB_4444_Config);
+
+ canvas->drawBitmap(bm, 0, 0);
+ }
+
+private:
+
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new StrokeTextView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleTests.cpp b/samplecode/SampleTests.cpp
new file mode 100644
index 0000000..4ce8640
--- /dev/null
+++ b/samplecode/SampleTests.cpp
@@ -0,0 +1,111 @@
+utils#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+
+#include "test.h"
+
+namespace skiatest {
+
+class MyReporter : public Reporter {
+protected:
+ virtual void onStart(Test* test) {}
+ virtual void onReport(const char desc[], Reporter::Result result) {
+ SkASSERT(Reporter::kPassed == result);
+ }
+ virtual void onEnd(Test* test) {}
+};
+
+class Iter {
+public:
+ Iter(Reporter* r) : fReporter(r) {
+ r->ref();
+ fReg = TestRegistry::Head();
+ }
+
+ ~Iter() {
+ fReporter->unref();
+ }
+
+ Test* next() {
+ if (fReg) {
+ TestRegistry::Factory fact = fReg->factory();
+ fReg = fReg->next();
+ Test* test = fact(NULL);
+ test->setReporter(fReporter);
+ return test;
+ }
+ return NULL;
+ }
+
+ static int Count() {
+ const TestRegistry* reg = TestRegistry::Head();
+ int count = 0;
+ while (reg) {
+ count += 1;
+ reg = reg->next();
+ }
+ return count;
+ }
+
+private:
+ Reporter* fReporter;
+ const TestRegistry* fReg;
+};
+}
+
+class TestsView : public SkView {
+public:
+ TestsView() {}
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "Tests");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ void drawBG(SkCanvas* canvas) {
+ canvas->drawColor(SK_ColorWHITE);
+ }
+
+ virtual void onDraw(SkCanvas* canvas) {
+ this->drawBG(canvas);
+
+ skiatest::MyReporter reporter;
+ skiatest::Iter iter(&reporter);
+ skiatest::Test* test;
+
+ while ((test = iter.next()) != NULL) {
+ test->run();
+ SkDELETE(test);
+ }
+ }
+
+ virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
+ this->inval(NULL);
+
+ return this->INHERITED::onFindClickHandler(x, y);
+ }
+
+ virtual bool onClick(Click* click) {
+ this->inval(NULL);
+ return this->INHERITED::onClick(click);
+ }
+
+ virtual bool handleKey(SkKey key) {
+ this->inval(NULL);
+ return true;
+ }
+
+private:
+ typedef SkView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new TestsView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleText.cpp b/samplecode/SampleText.cpp
new file mode 100644
index 0000000..2676530
--- /dev/null
+++ b/samplecode/SampleText.cpp
@@ -0,0 +1,396 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "Sk64.h"
+#include "SkGradientShader.h"
+#include "SkGraphics.h"
+#include "SkImageDecoder.h"
+#include "SkKernel33MaskFilter.h"
+#include "SkPath.h"
+#include "SkRandom.h"
+#include "SkRegion.h"
+#include "SkShader.h"
+#include "SkUtils.h"
+#include "SkColorPriv.h"
+#include "SkColorFilter.h"
+#include "SkTime.h"
+#include "SkTypeface.h"
+#include "SkXfermode.h"
+
+#include "SkStream.h"
+#include "SkXMLParser.h"
+
+static const int gKernel[3][3] = {
+// { -1, -2, -1 }, { -2, 12, -2 }, { -1, -2, -1 }
+ { 1, 2, 1 }, { 2, 64-12, 2 }, { 1, 2, 1 }
+};
+static const int gShift = 6;
+
+class ReduceNoise : public SkKernel33ProcMaskFilter {
+public:
+ ReduceNoise(int percent256) : SkKernel33ProcMaskFilter(percent256) {}
+ virtual uint8_t computeValue(uint8_t* const* srcRows)
+ {
+ int c = srcRows[1][1];
+ int min = 255, max = 0;
+ for (int i = 0; i < 3; i++)
+ for (int j = 0; j < 3; j++)
+ if (i != 1 || j != 1)
+ {
+ int v = srcRows[i][j];
+ if (max < v)
+ max = v;
+ if (min > v)
+ min = v;
+ }
+ if (c > max) c = max;
+ // if (c < min) c = min;
+ return c;
+ }
+ virtual Factory getFactory() { return Create; }
+private:
+ ReduceNoise(SkFlattenableReadBuffer& rb) : SkKernel33ProcMaskFilter(rb) {}
+ static SkFlattenable* Create(SkFlattenableReadBuffer& rb) {
+ return new ReduceNoise(rb);
+ }
+};
+
+class Darken : public SkKernel33ProcMaskFilter {
+public:
+ Darken(int percent256) : SkKernel33ProcMaskFilter(percent256) {}
+ virtual uint8_t computeValue(uint8_t* const* srcRows)
+ {
+ int c = srcRows[1][1];
+ float f = c / 255.f;
+
+ if (c >= 0) {
+ f = sqrtf(f);
+ } else {
+ f *= f;
+ }
+ SkASSERT(f >= 0 && f <= 1);
+ return (int)(f * 255);
+ }
+ virtual Factory getFactory() { return Create; }
+private:
+ Darken(SkFlattenableReadBuffer& rb) : SkKernel33ProcMaskFilter(rb) {}
+ static SkFlattenable* Create(SkFlattenableReadBuffer& rb) {
+ return new Darken(rb);
+ }
+};
+
+static SkMaskFilter* makemf() { return new Darken(0x30); }
+
+static void test_breakText() {
+ SkPaint paint;
+ const char* text = "sdfkljAKLDFJKEWkldfjlk#$%&sdfs.dsj";
+ size_t length = strlen(text);
+ SkScalar width = paint.measureText(text, length);
+
+ SkScalar mm = 0;
+ SkScalar nn = 0;
+ for (SkScalar w = 0; w <= width; w += SK_Scalar1) {
+ SkScalar m;
+ size_t n = paint.breakText(text, length, w, &m,
+ SkPaint::kBackward_TextBufferDirection);
+
+ SkASSERT(n <= length);
+ SkASSERT(m <= width);
+
+ if (n == 0) {
+ SkASSERT(m == 0);
+ } else {
+ // now assert that we're monotonic
+ if (n == nn) {
+ SkASSERT(m == mm);
+ } else {
+ SkASSERT(n > nn);
+ SkASSERT(m > mm);
+ }
+ }
+ nn = SkIntToScalar(n);
+ mm = m;
+ }
+
+ SkDEBUGCODE(size_t length2 =) paint.breakText(text, length, width, &mm);
+ SkASSERT(length2 == length);
+ SkASSERT(mm == width);
+}
+
+static SkRandom gRand;
+
+class SkPowerMode : public SkXfermode {
+public:
+ SkPowerMode(SkScalar exponent) { this->init(exponent); }
+
+ virtual void xfer16(uint16_t dst[], const SkPMColor src[], int count,
+ const SkAlpha aa[]);
+
+ typedef SkFlattenable* (*Factory)(SkFlattenableReadBuffer&);
+
+ // overrides for SkFlattenable
+ virtual Factory getFactory() { return Create; }
+ virtual void flatten(SkFlattenableWriteBuffer& b) {
+ // this->INHERITED::flatten(b); How can we know if this is legal????
+ b.write32(SkScalarToFixed(fExp));
+ }
+
+private:
+ SkScalar fExp; // user's value
+ uint8_t fTable[256]; // cache
+
+ void init(SkScalar exponent);
+ SkPowerMode(SkFlattenableReadBuffer& b) : SkXfermode(b) {
+ // read the exponent
+ this->init(SkFixedToScalar(b.readS32()));
+ }
+ static SkFlattenable* Create(SkFlattenableReadBuffer& b) {
+ return SkNEW_ARGS(SkPowerMode, (b));
+ }
+
+ typedef SkXfermode INHERITED;
+};
+
+void SkPowerMode::init(SkScalar e) {
+ fExp = e;
+ float ee = SkScalarToFloat(e);
+
+ printf("------ %g\n", ee);
+ for (int i = 0; i < 256; i++) {
+ float x = i / 255.f;
+ // printf(" %d %g", i, x);
+ x = powf(x, ee);
+ // printf(" %g", x);
+ int xx = SkScalarRound(SkFloatToScalar(x * 255));
+ // printf(" %d\n", xx);
+ fTable[i] = SkToU8(xx);
+ }
+}
+
+void SkPowerMode::xfer16(uint16_t dst[], const SkPMColor src[], int count,
+ const SkAlpha aa[]) {
+ for (int i = 0; i < count; i++) {
+ SkPMColor c = src[i];
+ int r = SkGetPackedR32(c);
+ int g = SkGetPackedG32(c);
+ int b = SkGetPackedB32(c);
+ r = fTable[r];
+ g = fTable[g];
+ b = fTable[b];
+ dst[i] = SkPack888ToRGB16(r, g, b);
+ }
+}
+
+static const struct {
+ const char* fName;
+ uint32_t fFlags;
+ bool fFlushCache;
+} gHints[] = {
+ { "Linear", SkPaint::kLinearText_Flag, false },
+ { "Normal", 0, true },
+ { "Subpixel", SkPaint::kSubpixelText_Flag, true }
+};
+
+static int count_char_points(const SkPaint& paint, char c) {
+ SkPath path;
+
+ paint.getTextPath(&c, 1, 0, 0, &path);
+ return path.getPoints(NULL, 0);
+}
+
+static int gOld, gNew, gCount;
+
+static void dump(int c, int oldc, int newc) {
+ if (oldc != newc) {
+ gOld += oldc;
+ gNew += newc;
+ gCount += 1;
+ printf("char %c: old = %3d, new = %3d, reduction %g%%\n", c, oldc, newc, 100. * (oldc - newc) / oldc);
+ }
+}
+
+static void tab(int n) {
+// printf("[%d] ", n); return;
+ SkASSERT(n >= 0);
+ for (int i = 0; i < n; i++)
+ printf(" ");
+}
+
+static void draw_rgn(const SkRegion& rgn, SkCanvas* canvas, const SkPaint& paint) {
+ SkRect r;
+ SkRegion::Iterator iter(rgn);
+
+ for (; !iter.done(); iter.next()) {
+ r.set(iter.rect());
+ canvas->drawRect(r, paint);
+ }
+}
+
+static void test_break(SkCanvas* canvas, const char text[], size_t length,
+ SkScalar x, SkScalar y, const SkPaint& paint,
+ SkScalar clickX) {
+ SkPaint linePaint;
+
+ linePaint.setAntiAlias(true);
+
+ SkScalar measured;
+
+ if (paint.breakText(text, length, clickX - x, &measured,
+ SkPaint::kForward_TextBufferDirection)) {
+ linePaint.setColor(SK_ColorRED);
+ canvas->drawLine(x, y, x + measured, y, linePaint);
+ }
+
+ x += paint.measureText(text, length);
+ if (paint.breakText(text, length, x - clickX, &measured,
+ SkPaint::kBackward_TextBufferDirection)) {
+ linePaint.setColor(SK_ColorBLUE);
+ canvas->drawLine(x - measured, y, x, y, linePaint);
+ }
+}
+
+static void DrawTheText(SkCanvas* canvas, const char text[], size_t length,
+ SkScalar x, SkScalar y, const SkPaint& paint,
+ SkScalar clickX, SkMaskFilter* mf) {
+ SkPaint p(paint);
+
+#if 0
+ canvas->drawText(text, length, x, y, paint);
+#else
+ {
+ SkPoint pts[1000];
+ SkScalar xpos = x;
+ SkASSERT(length <= SK_ARRAY_COUNT(pts));
+ for (size_t i = 0; i < length; i++) {
+ pts[i].set(xpos, y), xpos += paint.getTextSize();
+ }
+ canvas->drawPosText(text, length, pts, paint);
+ }
+#endif
+
+ p.setSubpixelText(true);
+ x += SkIntToScalar(180);
+ canvas->drawText(text, length, x, y, p);
+
+#ifdef SK_DEBUG
+ if (true) {
+ // p.setMaskFilter(mf);
+ p.setSubpixelText(false);
+ p.setLinearText(true);
+ x += SkIntToScalar(180);
+ canvas->drawText(text, length, x, y, p);
+ }
+#endif
+}
+
+class TextSpeedView : public SampleView {
+public:
+ TextSpeedView() {
+ fMF = makemf();
+
+ fHints = 0;
+ fClickX = 0;
+
+ test_breakText();
+ }
+
+ virtual ~TextSpeedView() {
+ SkSafeUnref(fMF);
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "Text");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ static void make_textstrip(SkBitmap* bm) {
+ bm->setConfig(SkBitmap::kRGB_565_Config, 200, 18);
+ bm->allocPixels();
+ bm->eraseColor(SK_ColorWHITE);
+
+ SkCanvas canvas(*bm);
+ SkPaint paint;
+ const char* s = "Lorem ipsum dolor sit amet, consectetuer adipiscing elit";
+
+ paint.setFlags(paint.getFlags() | SkPaint::kAntiAlias_Flag
+ | SkPaint::kDevKernText_Flag);
+ paint.setTextSize(SkIntToScalar(14));
+ canvas.drawText(s, strlen(s), SkIntToScalar(8), SkIntToScalar(14), paint);
+ }
+
+ static void fill_pts(SkPoint pts[], size_t n, SkRandom* rand) {
+ for (size_t i = 0; i < n; i++)
+ pts[i].set(rand->nextUScalar1() * 640, rand->nextUScalar1() * 480);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ SkAutoCanvasRestore restore(canvas, false);
+ {
+ SkRect r;
+ r.set(0, 0, SkIntToScalar(1000), SkIntToScalar(20));
+ // canvas->saveLayer(&r, NULL, SkCanvas::kHasAlphaLayer_SaveFlag);
+ }
+
+ SkPaint paint;
+// const uint16_t glyphs[] = { 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19 };
+ int index = fHints % SK_ARRAY_COUNT(gHints);
+ index = 1;
+// const char* style = gHints[index].fName;
+
+// canvas->translate(0, SkIntToScalar(50));
+
+ // canvas->drawText(style, strlen(style), SkIntToScalar(20), SkIntToScalar(20), paint);
+
+ SkSafeUnref(paint.setTypeface(SkTypeface::CreateFromFile("/skimages/samplefont.ttf")));
+ paint.setAntiAlias(true);
+ paint.setFlags(paint.getFlags() | gHints[index].fFlags);
+
+ SkRect clip;
+ clip.set(SkIntToScalar(25), SkIntToScalar(34), SkIntToScalar(88), SkIntToScalar(155));
+
+ const char* text = "Hamburgefons";
+ size_t length = strlen(text);
+
+ SkScalar y = SkIntToScalar(0);
+ for (int i = 9; i <= 24; i++) {
+ paint.setTextSize(SkIntToScalar(i) /*+ (gRand.nextU() & 0xFFFF)*/);
+ for (SkScalar dx = 0; dx <= SkIntToScalar(3)/4;
+ dx += SkIntToScalar(1) /* /4 */) {
+ y += paint.getFontSpacing();
+ DrawTheText(canvas, text, length, SkIntToScalar(20) + dx, y,
+ paint, fClickX, fMF);
+ }
+ }
+ if (gHints[index].fFlushCache) {
+// SkGraphics::SetFontCacheUsed(0);
+ }
+ }
+
+ virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
+ fClickX = x;
+ this->inval(NULL);
+ return this->INHERITED::onFindClickHandler(x, y);
+ }
+
+ virtual bool onClick(Click* click) {
+ return this->INHERITED::onClick(click);
+ }
+
+private:
+ int fHints;
+ SkScalar fClickX;
+ SkMaskFilter* fMF;
+
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new TextSpeedView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleTextAlpha.cpp b/samplecode/SampleTextAlpha.cpp
new file mode 100644
index 0000000..ccfed68
--- /dev/null
+++ b/samplecode/SampleTextAlpha.cpp
@@ -0,0 +1,114 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkBlurMaskFilter.h"
+#include "SkCanvas.h"
+#include "SkGradientShader.h"
+#include "SkGraphics.h"
+#include "SkImageDecoder.h"
+#include "SkPath.h"
+#include "SkRandom.h"
+#include "SkRegion.h"
+#include "SkShader.h"
+#include "SkUtils.h"
+#include "SkXfermode.h"
+#include "SkColorPriv.h"
+#include "SkColorFilter.h"
+#include "SkTime.h"
+#include "SkTypeface.h"
+
+#include "SkOSFile.h"
+#include "SkStream.h"
+
+static void check_for_nonwhite(const SkBitmap& bm, int alpha) {
+ if (bm.config() != SkBitmap::kRGB_565_Config) {
+ return;
+ }
+
+ for (int y = 0; y < bm.height(); y++) {
+ for (int x = 0; x < bm.width(); x++) {
+ uint16_t c = *bm.getAddr16(x, y);
+ if (c != 0xFFFF) {
+ SkDebugf("------ nonwhite alpha=%x [%d %d] %x\n", alpha, x, y, c);
+ return;
+ }
+ }
+ }
+}
+
+class TextAlphaView : public SampleView {
+public:
+ TextAlphaView() {
+ fByte = 0xFF;
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SkString str("TextAlpha");
+ SampleCode::TitleR(evt, str.c_str());
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ const char* str = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+ SkPaint paint;
+ SkScalar x = SkIntToScalar(10);
+ SkScalar y = SkIntToScalar(20);
+
+ paint.setFlags(0x105);
+
+ paint.setARGB(fByte, 0xFF, 0xFF, 0xFF);
+
+ paint.setMaskFilter(SkBlurMaskFilter::Create(SkIntToScalar(3),
+ SkBlurMaskFilter::kNormal_BlurStyle));
+ paint.getMaskFilter()->unref();
+
+ SkRandom rand;
+
+ for (int ps = 6; ps <= 35; ps++) {
+ paint.setColor(rand.nextU() | (0xFF << 24));
+ paint.setTextSize(SkIntToScalar(ps));
+ paint.setTextSize(SkIntToScalar(24));
+ canvas->drawText(str, strlen(str), x, y, paint);
+ y += paint.getFontMetrics(NULL);
+ }
+ //check_for_nonwhite(canvas->getDevice()->accessBitmap(), fByte);
+ //SkDebugf("------ byte %x\n", fByte);
+
+ if (false) {
+ fByte += 1;
+ fByte &= 0xFF;
+ this->inval(NULL);
+ }
+ }
+
+ virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
+ return new Click(this);
+ }
+
+ virtual bool onClick(Click* click) {
+ int y = click->fICurr.fY;
+ if (y < 0) {
+ y = 0;
+ } else if (y > 255) {
+ y = 255;
+ }
+ fByte = y;
+ this->inval(NULL);
+ return true;
+ }
+
+private:
+ int fByte;
+
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new TextAlphaView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleTextBox.cpp b/samplecode/SampleTextBox.cpp
new file mode 100644
index 0000000..37a6be0
--- /dev/null
+++ b/samplecode/SampleTextBox.cpp
@@ -0,0 +1,91 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkBlurMaskFilter.h"
+#include "SkCanvas.h"
+#include "SkGradientShader.h"
+#include "SkGraphics.h"
+#include "SkImageDecoder.h"
+#include "SkPath.h"
+#include "SkRandom.h"
+#include "SkRegion.h"
+#include "SkShader.h"
+#include "SkUtils.h"
+#include "SkXfermode.h"
+#include "SkColorPriv.h"
+#include "SkColorFilter.h"
+#include "SkTime.h"
+#include "SkTypeface.h"
+#include "SkTextBox.h"
+#include "SkOSFile.h"
+#include "SkStream.h"
+#include "SkKey.h"
+
+#ifdef SK_BUILD_FOR_WIN
+extern SkTypeface* SkCreateTypefaceFromLOGFONT(const LOGFONT&);
+#endif
+
+static const char gText[] =
+ "When in the Course of human events it becomes necessary for one people "
+ "to dissolve the political bands which have connected them with another "
+ "and to assume among the powers of the earth, the separate and equal "
+ "station to which the Laws of Nature and of Nature's God entitle them, "
+ "a decent respect to the opinions of mankind requires that they should "
+ "declare the causes which impel them to the separation.";
+
+class TextBoxView : public SampleView {
+public:
+ TextBoxView() {
+#ifdef SK_BUILD_FOR_WIN
+ LOGFONT lf;
+ sk_bzero(&lf, sizeof(lf));
+ lf.lfHeight = 9;
+ SkTypeface* tf0 = SkCreateTypefaceFromLOGFONT(lf);
+ lf.lfHeight = 12;
+ SkTypeface* tf1 = SkCreateTypefaceFromLOGFONT(lf);
+ // we assert that different sizes should not affect which face we get
+ SkASSERT(tf0 == tf1);
+ tf0->unref();
+ tf1->unref();
+#endif
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SkString str("TextBox");
+ SampleCode::TitleR(evt, str.c_str());
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ SkScalar margin = 20;
+ SkTextBox tbox;
+ tbox.setMode(SkTextBox::kLineBreak_Mode);
+ tbox.setBox(margin, margin,
+ this->width() - margin, this->height() - margin);
+ tbox.setSpacing(SkIntToScalar(3)/3, 0);
+
+ SkPaint paint;
+ paint.setAntiAlias(true);
+ paint.setLCDRenderText(true);
+ tbox.setText(gText, strlen(gText), paint);
+
+ for (int i = 9; i < 24; i += 2) {
+ paint.setTextSize(SkIntToScalar(i));
+ tbox.draw(canvas);
+ canvas->translate(0, tbox.getTextHeight() + paint.getFontSpacing());
+ }
+ }
+
+private:
+ typedef SkView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new TextBoxView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleTextEffects.cpp b/samplecode/SampleTextEffects.cpp
new file mode 100644
index 0000000..f256b2e
--- /dev/null
+++ b/samplecode/SampleTextEffects.cpp
@@ -0,0 +1,397 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkGradientShader.h"
+#include "SkPath.h"
+#include "SkRegion.h"
+#include "SkShader.h"
+#include "SkUtils.h"
+#include "SkColorPriv.h"
+#include "SkColorFilter.h"
+#include "SkTypeface.h"
+#include "SkAvoidXfermode.h"
+
+static inline SkPMColor rgb2gray(SkPMColor c) {
+ unsigned r = SkGetPackedR32(c);
+ unsigned g = SkGetPackedG32(c);
+ unsigned b = SkGetPackedB32(c);
+
+ unsigned x = (r * 5 + g * 7 + b * 4) >> 4;
+
+ return SkPackARGB32(0, x, x, x) | (c & (SK_A32_MASK << SK_A32_SHIFT));
+}
+
+class SkGrayScaleColorFilter : public SkColorFilter {
+public:
+ virtual void filterSpan(const SkPMColor src[], int count,
+ SkPMColor result[]) {
+ for (int i = 0; i < count; i++) {
+ result[i] = rgb2gray(src[i]);
+ }
+ }
+};
+
+class SkChannelMaskColorFilter : public SkColorFilter {
+public:
+ SkChannelMaskColorFilter(U8CPU redMask, U8CPU greenMask, U8CPU blueMask) {
+ fMask = SkPackARGB32(0xFF, redMask, greenMask, blueMask);
+ }
+
+ virtual void filterSpan(const SkPMColor src[], int count,
+ SkPMColor result[]) {
+ SkPMColor mask = fMask;
+ for (int i = 0; i < count; i++) {
+ result[i] = src[i] & mask;
+ }
+ }
+
+private:
+ SkPMColor fMask;
+};
+
+///////////////////////////////////////////////////////////
+
+#include "SkGradientShader.h"
+#include "SkLayerRasterizer.h"
+#include "SkBlurMaskFilter.h"
+
+static void r0(SkLayerRasterizer* rast, SkPaint& p) {
+ p.setMaskFilter(SkBlurMaskFilter::Create(SkIntToScalar(3),
+ SkBlurMaskFilter::kNormal_BlurStyle))->unref();
+ rast->addLayer(p, SkIntToScalar(3), SkIntToScalar(3));
+
+ p.setMaskFilter(NULL);
+ p.setStyle(SkPaint::kStroke_Style);
+ p.setStrokeWidth(SK_Scalar1);
+ rast->addLayer(p);
+
+ p.setAlpha(0x11);
+ p.setStyle(SkPaint::kFill_Style);
+ p.setXfermodeMode(SkXfermode::kSrc_Mode);
+ rast->addLayer(p);
+}
+
+static void r1(SkLayerRasterizer* rast, SkPaint& p) {
+ rast->addLayer(p);
+
+ p.setAlpha(0x40);
+ p.setXfermodeMode(SkXfermode::kSrc_Mode);
+ p.setStyle(SkPaint::kStroke_Style);
+ p.setStrokeWidth(SK_Scalar1*2);
+ rast->addLayer(p);
+}
+
+static void r2(SkLayerRasterizer* rast, SkPaint& p) {
+ p.setStyle(SkPaint::kStrokeAndFill_Style);
+ p.setStrokeWidth(SK_Scalar1*4);
+ rast->addLayer(p);
+
+ p.setStyle(SkPaint::kStroke_Style);
+ p.setStrokeWidth(SK_Scalar1*3/2);
+ p.setXfermodeMode(SkXfermode::kClear_Mode);
+ rast->addLayer(p);
+}
+
+static void r3(SkLayerRasterizer* rast, SkPaint& p) {
+ p.setStyle(SkPaint::kStroke_Style);
+ p.setStrokeWidth(SK_Scalar1*3);
+ rast->addLayer(p);
+
+ p.setAlpha(0x20);
+ p.setStyle(SkPaint::kFill_Style);
+ p.setXfermodeMode(SkXfermode::kSrc_Mode);
+ rast->addLayer(p);
+}
+
+static void r4(SkLayerRasterizer* rast, SkPaint& p) {
+ p.setAlpha(0x60);
+ rast->addLayer(p, SkIntToScalar(3), SkIntToScalar(3));
+
+ p.setAlpha(0xFF);
+ p.setXfermodeMode(SkXfermode::kClear_Mode);
+ rast->addLayer(p, SK_Scalar1*3/2, SK_Scalar1*3/2);
+
+ p.setXfermode(NULL);
+ rast->addLayer(p);
+}
+
+#include "SkDiscretePathEffect.h"
+
+static void r5(SkLayerRasterizer* rast, SkPaint& p) {
+ rast->addLayer(p);
+
+ p.setPathEffect(new SkDiscretePathEffect(SK_Scalar1*4, SK_Scalar1*3))->unref();
+ p.setXfermodeMode(SkXfermode::kSrcOut_Mode);
+ rast->addLayer(p);
+}
+
+static void r6(SkLayerRasterizer* rast, SkPaint& p) {
+ rast->addLayer(p);
+
+ p.setAntiAlias(false);
+ SkLayerRasterizer* rast2 = new SkLayerRasterizer;
+ r5(rast2, p);
+ p.setRasterizer(rast2)->unref();
+ p.setXfermodeMode(SkXfermode::kClear_Mode);
+ rast->addLayer(p);
+}
+
+#include "Sk2DPathEffect.h"
+
+class Dot2DPathEffect : public Sk2DPathEffect {
+public:
+ Dot2DPathEffect(SkScalar radius, const SkMatrix& matrix)
+ : Sk2DPathEffect(matrix), fRadius(radius) {}
+
+ virtual void flatten(SkFlattenableWriteBuffer& buffer) {
+ this->INHERITED::flatten(buffer);
+
+ buffer.writeScalar(fRadius);
+ }
+ virtual Factory getFactory() { return CreateProc; }
+
+protected:
+ virtual void next(const SkPoint& loc, int u, int v, SkPath* dst) {
+ dst->addCircle(loc.fX, loc.fY, fRadius);
+ }
+
+ Dot2DPathEffect(SkFlattenableReadBuffer& buffer) : Sk2DPathEffect(buffer) {
+ fRadius = buffer.readScalar();
+ }
+private:
+ SkScalar fRadius;
+
+ static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer) {
+ return new Dot2DPathEffect(buffer);
+ }
+
+ typedef Sk2DPathEffect INHERITED;
+};
+
+static void r7(SkLayerRasterizer* rast, SkPaint& p) {
+ SkMatrix lattice;
+ lattice.setScale(SK_Scalar1*6, SK_Scalar1*6, 0, 0);
+ lattice.postSkew(SK_Scalar1/3, 0, 0, 0);
+ p.setPathEffect(new Dot2DPathEffect(SK_Scalar1*4, lattice))->unref();
+ rast->addLayer(p);
+}
+
+static void r8(SkLayerRasterizer* rast, SkPaint& p) {
+ rast->addLayer(p);
+
+ SkMatrix lattice;
+ lattice.setScale(SK_Scalar1*6, SK_Scalar1*6, 0, 0);
+ lattice.postSkew(SK_Scalar1/3, 0, 0, 0);
+ p.setPathEffect(new Dot2DPathEffect(SK_Scalar1*2, lattice))->unref();
+ p.setXfermodeMode(SkXfermode::kClear_Mode);
+ rast->addLayer(p);
+
+ p.setPathEffect(NULL);
+ p.setXfermode(NULL);
+ p.setStyle(SkPaint::kStroke_Style);
+ p.setStrokeWidth(SK_Scalar1);
+ rast->addLayer(p);
+}
+
+class Line2DPathEffect : public Sk2DPathEffect {
+public:
+ Line2DPathEffect(SkScalar width, const SkMatrix& matrix)
+ : Sk2DPathEffect(matrix), fWidth(width) {}
+
+ virtual bool filterPath(SkPath* dst, const SkPath& src, SkScalar* width) {
+ if (this->INHERITED::filterPath(dst, src, width)) {
+ *width = fWidth;
+ return true;
+ }
+ return false;
+ }
+
+ virtual Factory getFactory() { return CreateProc; }
+ virtual void flatten(SkFlattenableWriteBuffer& buffer) {
+ this->INHERITED::flatten(buffer);
+ buffer.writeScalar(fWidth);
+ }
+
+protected:
+ virtual void nextSpan(int u, int v, int ucount, SkPath* dst) {
+ if (ucount > 1) {
+ SkPoint src[2], dstP[2];
+
+ src[0].set(SkIntToScalar(u) + SK_ScalarHalf,
+ SkIntToScalar(v) + SK_ScalarHalf);
+ src[1].set(SkIntToScalar(u+ucount) + SK_ScalarHalf,
+ SkIntToScalar(v) + SK_ScalarHalf);
+ this->getMatrix().mapPoints(dstP, src, 2);
+
+ dst->moveTo(dstP[0]);
+ dst->lineTo(dstP[1]);
+ }
+ }
+
+ Line2DPathEffect(SkFlattenableReadBuffer& buffer) : Sk2DPathEffect(buffer) {
+ fWidth = buffer.readScalar();
+ }
+
+private:
+ SkScalar fWidth;
+
+ static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer) {
+ return new Line2DPathEffect(buffer);
+ }
+
+ typedef Sk2DPathEffect INHERITED;
+};
+
+static void r9(SkLayerRasterizer* rast, SkPaint& p) {
+ rast->addLayer(p);
+
+ SkMatrix lattice;
+ lattice.setScale(SK_Scalar1, SK_Scalar1*6, 0, 0);
+ lattice.postRotate(SkIntToScalar(30), 0, 0);
+ p.setPathEffect(new Line2DPathEffect(SK_Scalar1*2, lattice))->unref();
+ p.setXfermodeMode(SkXfermode::kClear_Mode);
+ rast->addLayer(p);
+
+ p.setPathEffect(NULL);
+ p.setXfermode(NULL);
+ p.setStyle(SkPaint::kStroke_Style);
+ p.setStrokeWidth(SK_Scalar1);
+ rast->addLayer(p);
+}
+
+typedef void (*raster_proc)(SkLayerRasterizer*, SkPaint&);
+
+static const raster_proc gRastProcs[] = {
+ r0, r1, r2, r3, r4, r5, r6, r7, r8, r9
+};
+
+static const struct {
+ SkColor fMul, fAdd;
+} gLightingColors[] = {
+ { 0x808080, 0x800000 }, // general case
+ { 0x707070, 0x707070 }, // no-pin case
+ { 0xFFFFFF, 0x800000 }, // just-add case
+ { 0x808080, 0x000000 }, // just-mul case
+ { 0xFFFFFF, 0x000000 } // identity case
+};
+
+#include "SkXfermode.h"
+
+static unsigned color_dist16(uint16_t a, uint16_t b) {
+ unsigned dr = SkAbs32(SkPacked16ToR32(a) - SkPacked16ToR32(b));
+ unsigned dg = SkAbs32(SkPacked16ToG32(a) - SkPacked16ToG32(b));
+ unsigned db = SkAbs32(SkPacked16ToB32(a) - SkPacked16ToB32(b));
+
+ return SkMax32(dr, SkMax32(dg, db));
+}
+
+static unsigned scale_dist(unsigned dist, unsigned scale) {
+ dist >>= 6;
+ dist = (dist << 2) | dist;
+ dist = (dist << 4) | dist;
+ return dist;
+
+// return SkAlphaMul(dist, scale);
+}
+
+static void apply_shader(SkPaint* paint, int index) {
+ raster_proc proc = gRastProcs[index];
+ if (proc)
+ {
+ SkPaint p;
+ SkLayerRasterizer* rast = new SkLayerRasterizer;
+
+ p.setAntiAlias(true);
+ proc(rast, p);
+ paint->setRasterizer(rast)->unref();
+ }
+
+#if 0
+ SkScalar dir[] = { SK_Scalar1, SK_Scalar1, SK_Scalar1 };
+ paint->setMaskFilter(SkBlurMaskFilter::CreateEmboss(dir, SK_Scalar1/4, SkIntToScalar(4), SkIntToScalar(3)))->unref();
+#endif
+ paint->setColor(SK_ColorBLUE);
+}
+
+static int gRastIndex;
+
+class TextEffectView : public SampleView {
+ SkTypeface* fFace;
+public:
+ TextEffectView() {
+ fFace = SkTypeface::CreateFromFile("/Users/reed/Downloads/p052024l.pfb");
+ }
+
+ virtual ~TextEffectView() {
+ SkSafeUnref(fFace);
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "Text Effects");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ canvas->save();
+// canvas->scale(SK_Scalar1*2, SK_Scalar1*2, 0, 0);
+
+ SkPaint paint;
+
+ paint.setAntiAlias(true);
+ paint.setTextSize(SkIntToScalar(56));
+ paint.setTypeface(SkTypeface::CreateFromName("sans-serif",
+ SkTypeface::kBold));
+
+ SkScalar x = SkIntToScalar(20);
+ SkScalar y = paint.getTextSize();
+
+ SkString str("TextEffects");
+
+ paint.setTypeface(fFace);
+
+ for (size_t i = 0; i < SK_ARRAY_COUNT(gRastProcs); i++) {
+ apply_shader(&paint, i);
+
+ // paint.setMaskFilter(NULL);
+ // paint.setColor(SK_ColorBLACK);
+
+#if 1
+ int index = i % SK_ARRAY_COUNT(gLightingColors);
+ paint.setColorFilter(SkColorFilter::CreateLightingFilter(
+ gLightingColors[index].fMul,
+ gLightingColors[index].fAdd))->unref();
+#endif
+
+ canvas->drawText(str.c_str(), str.size(), x, y, paint);
+
+ y += paint.getFontSpacing();
+ }
+
+ canvas->restore();
+ }
+
+ virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
+ gRastIndex = (gRastIndex + 1) % SK_ARRAY_COUNT(gRastProcs);
+ this->inval(NULL);
+
+ return this->INHERITED::onFindClickHandler(x, y);
+ }
+
+ virtual bool onClick(Click* click) {
+ return this->INHERITED::onClick(click);
+ }
+
+private:
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new TextEffectView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleTextOnPath.cpp b/samplecode/SampleTextOnPath.cpp
new file mode 100644
index 0000000..96e8c9a
--- /dev/null
+++ b/samplecode/SampleTextOnPath.cpp
@@ -0,0 +1,284 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkGradientShader.h"
+#include "SkGraphics.h"
+#include "SkImageDecoder.h"
+#include "SkPackBits.h"
+#include "SkPath.h"
+#include "SkPathMeasure.h"
+#include "SkRandom.h"
+#include "SkRegion.h"
+#include "SkShader.h"
+#include "SkUtils.h"
+#include "SkColorPriv.h"
+#include "SkColorFilter.h"
+#include "SkTypeface.h"
+#include "SkAvoidXfermode.h"
+
+#define REPEAT_COUNT 0
+
+static const char gText[] = "Hamburgefons";
+
+static bool gDevKern;
+
+static void rand_text(char text[], SkRandom& rand, size_t count) {
+ for (size_t i = 0; i < count; i++) {
+ text[i] = rand.nextU() & 0x7F;
+ }
+}
+
+static SkScalar sum_widths(const SkScalar widths[], int count) {
+ SkScalar w = 0;
+ for (int i = 0; i < count; i++) {
+ w += widths[i];
+ }
+ return w;
+}
+
+static void test_measure(const SkPaint& paint) {
+ char text[256];
+ SkScalar widths[256];
+ SkRect rects[256];
+ SkRect bounds;
+ int count = 256;
+
+ SkRandom rand;
+
+ for (int i = 0; i < 100; i++) {
+ rand_text(text, rand, 256);
+ paint.getTextWidths(text, count, widths, NULL);
+ SkDEBUGCODE(SkScalar tw0 = sum_widths(widths, count);)
+ paint.getTextWidths(text, count, widths, rects);
+ SkDEBUGCODE(SkScalar tw1 = sum_widths(widths, count);)
+ SkASSERT(tw0 == tw1);
+
+ SkDEBUGCODE(SkScalar w0 = paint.measureText(text, count, NULL);)
+ SkDEBUGCODE(SkScalar w1 = paint.measureText(text, count, &bounds);)
+ SkASSERT(w0 == w1);
+ SkASSERT(w0 == tw0);
+
+ SkRect r = rects[0];
+ SkScalar x = 0;
+ for (int j = 1; j < count; j++) {
+ x += widths[j-1];
+ rects[j].offset(x, 0);
+ r.join(rects[j]);
+ }
+ SkASSERT(r == bounds);
+
+ if (r != bounds) {
+ printf("flags=%x i=%d [%g %g %g %g] [%g %g %g %g]\n",
+ paint.getFlags(), i,
+ SkScalarToFloat(r.fLeft),
+ SkScalarToFloat(r.fTop),
+ SkScalarToFloat(r.fRight),
+ SkScalarToFloat(r.fBottom),
+ SkScalarToFloat(bounds.fLeft),
+ SkScalarToFloat(bounds.fTop),
+ SkScalarToFloat(bounds.fRight),
+ SkScalarToFloat(bounds.fBottom));
+ }
+ }
+}
+
+static void test_measure() {
+ SkPaint paint;
+
+ for (int i = 0; i <= SkPaint::kAllFlags; i++) {
+ paint.setFlags(i);
+ test_measure(paint);
+ }
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+static void test_textBounds(SkCanvas* canvas) {
+// canvas->scale(SK_Scalar1/2, SK_Scalar1/2);
+
+// canvas->rotate(SkIntToScalar(30));
+
+ gDevKern = !gDevKern;
+
+ SkScalar x = SkIntToScalar(50);
+ SkScalar y = SkIntToScalar(150);
+ SkScalar w[100];
+ SkRect r[100], bounds;
+
+ SkPaint paint;
+ paint.setTextSize(SkIntToScalar(64));
+ paint.setAntiAlias(true);
+ paint.setDevKernText(gDevKern);
+
+ (void)paint.measureText(gText, strlen(gText), &bounds, NULL);
+ paint.setColor(SK_ColorGREEN);
+ bounds.offset(x, y);
+ canvas->drawRect(bounds, paint);
+
+ int count = paint.getTextWidths(gText, strlen(gText), w, r);
+
+ paint.setColor(SK_ColorRED);
+ for (int i = 0; i < count; i++) {
+ r[i].offset(x, y);
+ canvas->drawRect(r[i], paint);
+ x += w[i];
+ }
+ x = SkIntToScalar(50);
+ paint.setColor(gDevKern ? SK_ColorDKGRAY : SK_ColorBLACK);
+ canvas->drawText(gText, strlen(gText), x, y, paint);
+}
+
+static void create_src(SkBitmap* bitmap, SkBitmap::Config config) {
+ bitmap->setConfig(config, 100, 100);
+ bitmap->allocPixels();
+ bitmap->eraseColor(0);
+
+ SkCanvas canvas(*bitmap);
+ SkPaint paint;
+
+ paint.setAntiAlias(true);
+ canvas.drawCircle(SkIntToScalar(50), SkIntToScalar(50),
+ SkIntToScalar(50), paint);
+}
+
+static void blur(SkBitmap* dst, const SkBitmap& src, SkScalar radius) {
+ *dst = src;
+}
+
+static void test_bitmap_blur(SkCanvas* canvas) {
+ SkBitmap src, dst;
+
+ create_src(&src, SkBitmap::kARGB_8888_Config);
+ blur(&dst, src, SkIntToScalar(4));
+
+ SkPaint paint;
+
+ paint.setColor(SK_ColorRED);
+
+ canvas->drawBitmap(dst, SkIntToScalar(30), SkIntToScalar(60), &paint);
+}
+
+static SkScalar getpathlen(const SkPath& path) {
+ SkPathMeasure meas(path, false);
+ return meas.getLength();
+}
+
+static void test_textpathmatrix(SkCanvas* canvas) {
+ SkPaint paint;
+ SkPath path;
+ SkMatrix matrix;
+
+ path.moveTo(SkIntToScalar(200), SkIntToScalar(300));
+ path.quadTo(SkIntToScalar(400), SkIntToScalar(100),
+ SkIntToScalar(600), SkIntToScalar(300));
+
+ paint.setAntiAlias(true);
+
+ paint.setStyle(SkPaint::kStroke_Style);
+ // canvas->drawPath(path, paint);
+ paint.setStyle(SkPaint::kFill_Style);
+ paint.setTextSize(SkIntToScalar(48));
+ paint.setTextAlign(SkPaint::kRight_Align);
+
+ const char* text = "Reflection";
+ size_t len = strlen(text);
+ SkScalar pathLen = getpathlen(path);
+
+ canvas->drawTextOnPath(text, len, path, NULL, paint);
+
+ paint.setColor(SK_ColorRED);
+ matrix.setScale(-SK_Scalar1, SK_Scalar1);
+ matrix.postTranslate(pathLen, 0);
+ canvas->drawTextOnPath(text, len, path, &matrix, paint);
+
+ paint.setColor(SK_ColorBLUE);
+ matrix.setScale(SK_Scalar1, -SK_Scalar1);
+ canvas->drawTextOnPath(text, len, path, &matrix, paint);
+
+ paint.setColor(SK_ColorGREEN);
+ matrix.setScale(-SK_Scalar1, -SK_Scalar1);
+ matrix.postTranslate(pathLen, 0);
+ canvas->drawTextOnPath(text, len, path, &matrix, paint);
+}
+
+class TextOnPathView : public SampleView {
+public:
+ SkPath fPath;
+ SkScalar fHOffset;
+
+ TextOnPathView() {
+ SkRect r;
+ r.set(SkIntToScalar(100), SkIntToScalar(100),
+ SkIntToScalar(300), SkIntToScalar(300));
+ fPath.addOval(r);
+ fPath.offset(SkIntToScalar(200), 0);
+
+ fHOffset = SkIntToScalar(50);
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "Text On Path");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ SkPaint paint;
+
+ paint.setAntiAlias(true);
+ paint.setTextSize(SkIntToScalar(50));
+
+ for (int j = 0; j < REPEAT_COUNT; j++) {
+ SkScalar x = fHOffset;
+
+ paint.setColor(SK_ColorBLACK);
+ canvas->drawTextOnPathHV(gText, sizeof(gText)-1, fPath,
+ x, paint.getTextSize()/2, paint);
+
+ paint.setColor(SK_ColorRED);
+ canvas->drawTextOnPathHV(gText, sizeof(gText)-1, fPath,
+ x + SkIntToScalar(50), 0, paint);
+
+ paint.setColor(SK_ColorBLUE);
+ canvas->drawTextOnPathHV(gText, sizeof(gText)-1, fPath,
+ x + SkIntToScalar(100), -paint.getTextSize()/2, paint);
+ }
+
+ paint.setColor(SK_ColorGREEN);
+ paint.setStyle(SkPaint::kStroke_Style);
+// canvas->drawPath(fPath, paint);
+
+ canvas->translate(0, SkIntToScalar(100));
+ test_textpathmatrix(canvas);
+
+ if (REPEAT_COUNT > 1)
+ this->inval(NULL);
+ }
+
+ virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
+ fHints += 1;
+ this->inval(NULL);
+ return this->INHERITED::onFindClickHandler(x, y);
+ }
+
+ virtual bool onClick(Click* click) {
+ return this->INHERITED::onClick(click);
+ }
+
+private:
+ int fHints;
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() {
+ return new TextOnPathView;
+}
+
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleTextureDomain.cpp b/samplecode/SampleTextureDomain.cpp
new file mode 100755
index 0000000..be000f9
--- /dev/null
+++ b/samplecode/SampleTextureDomain.cpp
@@ -0,0 +1,80 @@
+#include "SampleCode.h"
+#include "SkCanvas.h"
+#include "SkDevice.h"
+
+namespace {
+SkBitmap make_bitmap() {
+ SkBitmap bm;
+ bm.setConfig(SkBitmap::kARGB_8888_Config , 5, 5);
+ bm.allocPixels();
+
+ for (int y = 0; y < bm.height(); y++) {
+ uint32_t* p = bm.getAddr32(0, y);
+ for (int x = 0; x < bm.width(); x++) {
+ p[x] = ((x + y) & 1) ? SK_ColorWHITE : SK_ColorBLACK;
+ }
+ }
+ bm.unlockPixels();
+ return bm;
+}
+} // unnamed namespace
+
+class TextureDomainView : public SampleView {
+ SkBitmap fBM;
+
+public:
+ TextureDomainView(){
+ fBM = make_bitmap();
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "Texture Domian");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ SkIRect srcRect;
+ SkRect dstRect;
+ SkPaint paint;
+ paint.setFilterBitmap(true);
+
+ // Test that bitmap draws from malloc-backed bitmaps respect
+ // the constrained texture domain.
+ srcRect.setXYWH(1, 1, 3, 3);
+ dstRect.setXYWH(5.0f, 5.0f, 305.0f, 305.0f);
+ canvas->drawBitmapRect(fBM, &srcRect, dstRect, &paint);
+
+ // Test that bitmap draws across separate devices also respect
+ // the constrainted texture domain.
+ // Note: GPU-backed bitmaps follow a different rendering path
+ // when copying from one GPU device to another.
+ SkRefPtr<SkDevice> primaryDevice(canvas->getDevice());
+ SkRefPtr<SkDevice> secondDevice(canvas->createDevice(
+ SkBitmap::kARGB_8888_Config, 5, 5, true, true));
+ secondDevice->unref();
+ SkCanvas secondCanvas(secondDevice.get());
+
+ srcRect.setXYWH(1, 1, 3, 3);
+ dstRect.setXYWH(1.0f, 1.0f, 3.0f, 3.0f);
+ secondCanvas.drawBitmapRect(fBM, &srcRect, dstRect, &paint);
+
+ SkBitmap deviceBitmap = secondDevice->accessBitmap(false);
+
+ srcRect.setXYWH(1, 1, 3, 3);
+ dstRect.setXYWH(405.0f, 5.0f, 305.0f, 305.0f);
+ canvas->drawBitmapRect(deviceBitmap, &srcRect, dstRect, &paint);
+ }
+private:
+ typedef SkView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new TextureDomainView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleTiling.cpp b/samplecode/SampleTiling.cpp
new file mode 100644
index 0000000..4752ed1
--- /dev/null
+++ b/samplecode/SampleTiling.cpp
@@ -0,0 +1,162 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkPaint.h"
+#include "SkPath.h"
+#include "SkRegion.h"
+#include "SkShader.h"
+#include "SkUtils.h"
+#include "SkColorPriv.h"
+#include "SkColorFilter.h"
+#include "SkPicture.h"
+#include "SkTypeface.h"
+
+// effects
+#include "SkGradientShader.h"
+#include "SkUnitMappers.h"
+#include "SkBlurDrawLooper.h"
+
+static void makebm(SkBitmap* bm, SkBitmap::Config config, int w, int h) {
+ bm->setConfig(config, w, h);
+ bm->allocPixels();
+ bm->eraseColor(0);
+
+ SkCanvas canvas(*bm);
+ SkPoint pts[] = { { 0, 0 }, { SkIntToScalar(w), SkIntToScalar(h) } };
+ SkColor colors[] = { SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE };
+ SkScalar pos[] = { 0, SK_Scalar1/2, SK_Scalar1 };
+ SkPaint paint;
+
+ SkUnitMapper* um = NULL;
+
+ um = new SkCosineMapper;
+// um = new SkDiscreteMapper(12);
+
+ SkAutoUnref au(um);
+
+ paint.setDither(true);
+ paint.setShader(SkGradientShader::CreateLinear(pts, colors, pos,
+ SK_ARRAY_COUNT(colors), SkShader::kClamp_TileMode, um))->unref();
+ canvas.drawPaint(paint);
+}
+
+static void setup(SkPaint* paint, const SkBitmap& bm, bool filter,
+ SkShader::TileMode tmx, SkShader::TileMode tmy) {
+ SkShader* shader = SkShader::CreateBitmapShader(bm, tmx, tmy);
+ paint->setShader(shader)->unref();
+ paint->setFilterBitmap(filter);
+}
+
+static const SkBitmap::Config gConfigs[] = {
+ SkBitmap::kARGB_8888_Config,
+ SkBitmap::kRGB_565_Config,
+ SkBitmap::kARGB_4444_Config
+};
+static const int gWidth = 32;
+static const int gHeight = 32;
+
+class TilingView : public SampleView {
+ SkPicture fTextPicture;
+ SkBlurDrawLooper fLooper;
+public:
+ TilingView()
+ : fLooper(SkIntToScalar(1), SkIntToScalar(2), SkIntToScalar(2),
+ 0x88000000) {
+ for (size_t i = 0; i < SK_ARRAY_COUNT(gConfigs); i++) {
+ makebm(&fTexture[i], gConfigs[i], gWidth, gHeight);
+ }
+ }
+
+ SkBitmap fTexture[SK_ARRAY_COUNT(gConfigs)];
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "Tiling");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ SkRect r = { 0, 0, SkIntToScalar(gWidth*2), SkIntToScalar(gHeight*2) };
+
+ static const char* gConfigNames[] = { "8888", "565", "4444" };
+
+ static const bool gFilters[] = { false, true };
+ static const char* gFilterNames[] = { "point", "bilinear" };
+
+ static const SkShader::TileMode gModes[] = { SkShader::kClamp_TileMode, SkShader::kRepeat_TileMode, SkShader::kMirror_TileMode };
+ static const char* gModeNames[] = { "C", "R", "M" };
+
+ SkScalar y = SkIntToScalar(24);
+ SkScalar x = SkIntToScalar(10);
+
+ SkCanvas* textCanvas = NULL;
+ if (fTextPicture.width() == 0) {
+ textCanvas = fTextPicture.beginRecording(1000, 1000);
+ }
+
+ if (textCanvas) {
+ for (size_t kx = 0; kx < SK_ARRAY_COUNT(gModes); kx++) {
+ for (size_t ky = 0; ky < SK_ARRAY_COUNT(gModes); ky++) {
+ SkPaint p;
+ SkString str;
+ p.setAntiAlias(true);
+ p.setDither(true);
+ p.setLooper(&fLooper);
+ str.printf("[%s,%s]", gModeNames[kx], gModeNames[ky]);
+
+ p.setTextAlign(SkPaint::kCenter_Align);
+ textCanvas->drawText(str.c_str(), str.size(), x + r.width()/2, y, p);
+
+ x += r.width() * 4 / 3;
+ }
+ }
+ }
+
+ y += SkIntToScalar(16);
+
+ for (size_t i = 0; i < SK_ARRAY_COUNT(gConfigs); i++) {
+ for (size_t j = 0; j < SK_ARRAY_COUNT(gFilters); j++) {
+ x = SkIntToScalar(10);
+ for (size_t kx = 0; kx < SK_ARRAY_COUNT(gModes); kx++) {
+ for (size_t ky = 0; ky < SK_ARRAY_COUNT(gModes); ky++) {
+ SkPaint paint;
+ setup(&paint, fTexture[i], gFilters[j], gModes[kx], gModes[ky]);
+ paint.setDither(true);
+
+ canvas->save();
+ canvas->translate(x, y);
+ canvas->drawRect(r, paint);
+ canvas->restore();
+
+ x += r.width() * 4 / 3;
+ }
+ }
+ if (textCanvas) {
+ SkPaint p;
+ SkString str;
+ p.setAntiAlias(true);
+ p.setLooper(&fLooper);
+ str.printf("%s, %s", gConfigNames[i], gFilterNames[j]);
+ textCanvas->drawText(str.c_str(), str.size(), x, y + r.height() * 2 / 3, p);
+ }
+
+ y += r.height() * 4 / 3;
+ }
+ }
+
+ canvas->drawPicture(fTextPicture);
+ }
+
+private:
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new TilingView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleTinyBitmap.cpp b/samplecode/SampleTinyBitmap.cpp
new file mode 100644
index 0000000..0841474
--- /dev/null
+++ b/samplecode/SampleTinyBitmap.cpp
@@ -0,0 +1,76 @@
+#include "SampleCode.h"
+#include "SkColorPriv.h"
+#include "SkShader.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkUtils.h"
+
+static SkBitmap make_bitmap() {
+ SkBitmap bm;
+ const int N = 1;
+ SkColorTable* ctable = new SkColorTable(N);
+
+ SkPMColor* c = ctable->lockColors();
+ for (int i = 0; i < N; i++) {
+ c[i] = SkPackARGB32(0x80, 0x80, 0, 0);
+ }
+ ctable->unlockColors(true);
+ bm.setConfig(SkBitmap::kIndex8_Config, 1, 1);
+ bm.allocPixels(ctable);
+ ctable->unref();
+
+ bm.lockPixels();
+ for (int y = 0; y < bm.height(); y++) {
+ uint8_t* p = bm.getAddr8(0, y);
+ for (int x = 0; x < bm.width(); x++) {
+ p[x] = 0;
+ }
+ }
+ bm.unlockPixels();
+ return bm;
+}
+
+class TinyBitmapView : public SampleView {
+ SkBitmap fBM;
+public:
+ TinyBitmapView() {
+ fBM = make_bitmap();
+ this->setBGColor(0xFFDDDDDD);
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "TinyBitmap");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ static void setBitmapOpaque(SkBitmap* bm, bool isOpaque) {
+ SkAutoLockPixels alp(*bm); // needed for ctable
+ bm->setIsOpaque(isOpaque);
+ SkColorTable* ctable = bm->getColorTable();
+ if (ctable) {
+ ctable->setIsOpaque(isOpaque);
+ }
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ SkShader* s = SkShader::CreateBitmapShader(fBM, SkShader::kRepeat_TileMode,
+ SkShader::kMirror_TileMode);
+ SkPaint paint;
+ paint.setShader(s)->unref();
+ canvas->drawPaint(paint);
+ }
+
+private:
+ typedef SkView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new TinyBitmapView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleTriangles.cpp b/samplecode/SampleTriangles.cpp
new file mode 100644
index 0000000..be9da8f
--- /dev/null
+++ b/samplecode/SampleTriangles.cpp
@@ -0,0 +1,118 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkConcaveToTriangles.h"
+
+#define SIZE SkIntToScalar(150)
+
+typedef void (*PathProc)(SkPath*);
+
+static void make_path0(SkPath* path) {
+ SkRect r;
+ r.set(0, 0, SIZE, SIZE);
+ path->addRect(r);
+}
+
+static void make_path1(SkPath* path) {
+ SkRect r;
+ r.set(0, 0, SIZE, SIZE);
+ path->addRoundRect(r, SIZE/4, SIZE/4);
+}
+
+static void make_path2(SkPath* path) {
+ SkRect r;
+ r.set(0, 0, SIZE, SIZE);
+ path->addOval(r);
+}
+
+static const PathProc gProcs[] = {
+ make_path0,
+ make_path1,
+ make_path2,
+};
+
+#define COUNT_PROCS SK_ARRAY_COUNT(gProcs)
+
+class TriangleView : public SkView {
+public:
+ SkPath fPaths[COUNT_PROCS];
+
+ TriangleView() {
+ for (size_t i = 0; i < COUNT_PROCS; i++) {
+ gProcs[i](&fPaths[i]);
+ }
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "Triangles");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ void drawBG(SkCanvas* canvas) {
+ canvas->drawColor(SK_ColorGRAY);
+ }
+
+ static void draw_path(SkCanvas* canvas, const SkPaint& pathPaint,
+ const SkPath& path, const SkPaint& triPaint) {
+ canvas->drawPath(path, pathPaint);
+
+ int n = path.getPoints(NULL, 0);
+ SkPoint* pts = new SkPoint[n];
+ path.getPoints(pts, n);
+
+ SkTDArray<SkPoint> triangles;
+ if (SkConcaveToTriangles(n, pts, &triangles)) {
+ canvas->drawVertices(SkCanvas::kTriangles_VertexMode,
+ triangles.count(), triangles.begin(), NULL,
+ NULL, NULL, NULL, 0, triPaint);
+ }
+
+ SkPaint paint;
+ paint.setColor(SK_ColorGREEN);
+ paint.setStrokeWidth(SkIntToScalar(4));
+ canvas->drawPoints(SkCanvas::kPoints_PointMode, n, pts, paint);
+ delete[] pts;
+ }
+
+ virtual void onDraw(SkCanvas* canvas) {
+ this->drawBG(canvas);
+
+ canvas->translate(SIZE/2, SIZE/2);
+
+ SkPaint pathPaint, triPaint;
+
+ pathPaint.setColor(SK_ColorBLUE);
+ pathPaint.setStrokeWidth(SIZE / 12);
+
+ triPaint.setColor(SK_ColorRED);
+ triPaint.setStyle(SkPaint::kStroke_Style);
+
+ for (size_t i = 0; i < COUNT_PROCS; i++) {
+ pathPaint.setStyle(SkPaint::kFill_Style);
+ draw_path(canvas, pathPaint, fPaths[i], triPaint);
+
+ canvas->save();
+ canvas->translate(0, SIZE * 6 / 5);
+
+ pathPaint.setStyle(SkPaint::kStroke_Style);
+ draw_path(canvas, pathPaint, fPaths[i], triPaint);
+
+ canvas->restore();
+ canvas->translate(SIZE * 6 / 5, 0);
+ }
+ }
+
+private:
+ typedef SkView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new TriangleView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleTypeface.cpp b/samplecode/SampleTypeface.cpp
new file mode 100644
index 0000000..63f1d5a
--- /dev/null
+++ b/samplecode/SampleTypeface.cpp
@@ -0,0 +1,128 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkTypeface.h"
+#include "SkPath.h"
+#include "SkRegion.h"
+#include "SkShader.h"
+#include "SkUtils.h"
+#include "Sk1DPathEffect.h"
+#include "SkCornerPathEffect.h"
+#include "SkPathMeasure.h"
+#include "SkRandom.h"
+#include "SkColorPriv.h"
+#include "SkColorFilter.h"
+#include "SkDither.h"
+#include "SkTypefaceCache.h"
+
+static int dither_4444(int x) {
+ return ((x << 1) - ((x >> 4 << 4) | (x >> 4))) >> 4;
+}
+
+/** Ensure that the max of the original and dithered value (for alpha) is always
+ >= any other dithered value. We apply this "max" in colorpriv.h when we
+ predither down to 4444, to be sure that we stay in legal premultiplied form
+ */
+static void test_4444_dither() {
+ int buckets[16];
+ sk_bzero(buckets, sizeof(buckets));
+
+ for (int a = 0; a <= 0xFF; a++) {
+ int da = dither_4444(a);
+ int maxa = SkMax32(a >> 4, da);
+ // SkDebugf("--- %02X %X\n", a, da);
+ buckets[da] += 1;
+ for (int c = 0; c <= a; c++) {
+ int dc = dither_4444(c);
+ if (maxa < dc) {
+ SkDebugf("------------ error a=%d da=%d c=%d dc=%d\n", a, da,
+ c, dc);
+ }
+ }
+ }
+ for (int i = 0; i < 16; i++) {
+ // SkDebugf("[%d] = %d\n", i, buckets[i]);
+ }
+}
+
+static const struct {
+ const char* fName;
+ SkTypeface::Style fStyle;
+} gFaces[] = {
+ { "sans-serif", SkTypeface::kNormal },
+ { "sans-serif", SkTypeface::kBold },
+ { "sans-serif", SkTypeface::kItalic },
+ { "sans-serif", SkTypeface::kBoldItalic },
+ { "serif", SkTypeface::kNormal },
+ { "serif", SkTypeface::kBold },
+ { "serif", SkTypeface::kItalic },
+ { "serif", SkTypeface::kBoldItalic },
+ { "monospace", SkTypeface::kNormal },
+ { "monospace", SkTypeface::kBold },
+ { "monospace", SkTypeface::kItalic },
+ { "monospace", SkTypeface::kBoldItalic },
+};
+
+static const int gFaceCount = SK_ARRAY_COUNT(gFaces);
+
+class TypefaceView : public SampleView {
+ SkTypeface* fFaces[gFaceCount];
+
+public:
+ TypefaceView() {
+ test_4444_dither();
+ for (int i = 0; i < gFaceCount; i++) {
+ fFaces[i] = SkTypeface::CreateFromName(gFaces[i].fName,
+ gFaces[i].fStyle);
+ }
+
+ this->setBGColor(0xFFDDDDDD);
+ }
+
+ virtual ~TypefaceView() {
+ for (int i = 0; i < gFaceCount; i++) {
+ SkSafeUnref(fFaces[i]);
+ }
+
+ SkTypefaceCache::Dump();
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "Typefaces");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ SkPaint paint;
+ paint.setAntiAlias(true);
+ paint.setTextSize(SkIntToScalar(30));
+
+ const char* text = "Hamburgefons";
+ const size_t textLen = strlen(text);
+
+ SkScalar x = SkIntToScalar(10);
+ SkScalar dy = paint.getFontMetrics(NULL);
+ SkScalar y = dy;
+
+ paint.setLinearText(true);
+ for (int i = 0; i < gFaceCount; i++) {
+ paint.setTypeface(fFaces[i]);
+ canvas->drawText(text, textLen, x, y, paint);
+ y += dy;
+ }
+ }
+
+private:
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new TypefaceView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleUnitMapper.cpp b/samplecode/SampleUnitMapper.cpp
new file mode 100644
index 0000000..b20aece
--- /dev/null
+++ b/samplecode/SampleUnitMapper.cpp
@@ -0,0 +1,157 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkDevice.h"
+#include "SkPaint.h"
+#include "SkUnitMappers.h"
+#include "SkCubicInterval.h"
+
+#include "SkWidgetViews.h"
+
+static SkStaticTextView* make_textview(SkView* parent,
+ const SkRect& bounds,
+ const SkPaint& paint) {
+ SkStaticTextView* view = new SkStaticTextView;
+ view->setMode(SkStaticTextView::kFixedSize_Mode);
+ view->setPaint(paint);
+ view->setVisibleP(true);
+ view->setSize(bounds.width(), bounds.height());
+ view->setLoc(bounds.fLeft, bounds.fTop);
+ parent->attachChildToFront(view)->unref();
+ return view;
+}
+
+static void set_scalar(SkStaticTextView* view, SkScalar value) {
+ SkString str;
+ str.appendScalar(value);
+ view->setText(str);
+}
+
+class UnitMapperView : public SampleView {
+ SkPoint fPts[4];
+ SkMatrix fMatrix;
+ SkStaticTextView* fViews[4];
+
+ void setViews() {
+ set_scalar(fViews[0], fPts[1].fX);
+ set_scalar(fViews[1], fPts[1].fY);
+ set_scalar(fViews[2], fPts[2].fX);
+ set_scalar(fViews[3], fPts[2].fY);
+ }
+
+public:
+ UnitMapperView() {
+ fPts[0].set(0, 0);
+ fPts[1].set(SK_Scalar1 / 3, SK_Scalar1 / 3);
+ fPts[2].set(SK_Scalar1 * 2 / 3, SK_Scalar1 * 2 / 3);
+ fPts[3].set(SK_Scalar1, SK_Scalar1);
+
+ fMatrix.setScale(SK_Scalar1 * 200, -SK_Scalar1 * 200);
+ fMatrix.postTranslate(SkIntToScalar(100), SkIntToScalar(300));
+
+ SkRect r = {
+ SkIntToScalar(350), SkIntToScalar(100),
+ SkIntToScalar(500), SkIntToScalar(130)
+ };
+ SkPaint paint;
+ paint.setAntiAlias(true);
+ paint.setTextSize(SkIntToScalar(25));
+ for (int i = 0; i < 4; i++) {
+ fViews[i] = make_textview(this, r, paint);
+ r.offset(0, r.height());
+ }
+ this->setViews();
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "UnitMapper");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ SkPaint paint;
+ paint.setAntiAlias(true);
+ paint.setColor(0xFF8888FF);
+
+ SkRect r = { 0, 0, SK_Scalar1, SK_Scalar1 };
+
+ canvas->concat(fMatrix);
+ canvas->drawRect(r, paint);
+
+ paint.setColor(SK_ColorBLACK);
+ paint.setStyle(SkPaint::kStroke_Style);
+ paint.setStrokeWidth(0);
+ paint.setStrokeCap(SkPaint::kRound_Cap);
+
+ SkPath path;
+ path.moveTo(fPts[0]);
+ path.cubicTo(fPts[1], fPts[2], fPts[3]);
+ canvas->drawPath(path, paint);
+
+ paint.setColor(SK_ColorRED);
+ paint.setStrokeWidth(0);
+ canvas->drawLine(0, 0, SK_Scalar1, SK_Scalar1, paint);
+
+ paint.setColor(SK_ColorBLUE);
+ paint.setStrokeWidth(SK_Scalar1 / 60);
+ for (int i = 0; i < 50; i++) {
+ SkScalar x = i * SK_Scalar1 / 49;
+ canvas->drawPoint(x, SkEvalCubicInterval(&fPts[1], x), paint);
+ }
+
+ paint.setStrokeWidth(SK_Scalar1 / 20);
+ paint.setColor(SK_ColorGREEN);
+ canvas->drawPoints(SkCanvas::kPoints_PointMode, 2, &fPts[1], paint);
+ }
+
+ SkPoint invertPt(SkScalar x, SkScalar y) {
+ SkPoint pt;
+ SkMatrix m;
+ fMatrix.invert(&m);
+ m.mapXY(x, y, &pt);
+ return pt;
+ }
+
+ int hittest(SkScalar x, SkScalar y) {
+ SkPoint target = { x, y };
+ SkPoint pts[2] = { fPts[1], fPts[2] };
+ fMatrix.mapPoints(pts, 2);
+ for (int i = 0; i < 2; i++) {
+ if (SkPoint::Distance(pts[i], target) < SkIntToScalar(4)) {
+ return i + 1;
+ }
+ }
+ return -1;
+ }
+
+ virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
+ fDragIndex = hittest(x, y);
+ return fDragIndex >= 0 ? new Click(this) : NULL;
+ }
+
+ virtual bool onClick(Click* click) {
+ if (fDragIndex >= 0) {
+ fPts[fDragIndex] = invertPt(click->fCurr.fX, click->fCurr.fY);
+ this->setViews();
+ this->inval(NULL);
+ return true;
+ }
+ return false;
+ }
+
+private:
+ int fDragIndex;
+
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new UnitMapperView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleVertices.cpp b/samplecode/SampleVertices.cpp
new file mode 100644
index 0000000..74e757f
--- /dev/null
+++ b/samplecode/SampleVertices.cpp
@@ -0,0 +1,230 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkGradientShader.h"
+#include "SkGraphics.h"
+#include "SkImageDecoder.h"
+#include "SkPath.h"
+#include "SkRandom.h"
+#include "SkRegion.h"
+#include "SkShader.h"
+#include "SkUtils.h"
+#include "SkXfermode.h"
+#include "SkColorPriv.h"
+#include "SkColorFilter.h"
+#include "SkTime.h"
+#include "SkTypeface.h"
+
+#include "SkOSFile.h"
+#include "SkStream.h"
+#include "SkNinePatch.h"
+
+static SkShader* make_shader0(SkIPoint* size) {
+ SkBitmap bm;
+ size->set(2, 2);
+ bm.setConfig(SkBitmap::kARGB_8888_Config, size->fX, size->fY);
+ SkPMColor color0 = SkPreMultiplyARGB(0x80, 0x80, 0xff, 0x80);
+ SkPMColor color1 = SkPreMultiplyARGB(0x40, 0xff, 0x00, 0xff);
+ bm.allocPixels();
+ bm.eraseColor(color0);
+ bm.lockPixels();
+ uint32_t* pixels = (uint32_t*) bm.getPixels();
+ pixels[0] = pixels[2] = color0;
+ pixels[1] = pixels[3] = color1;
+ bm.unlockPixels();
+
+ return SkShader::CreateBitmapShader(bm, SkShader::kRepeat_TileMode,
+ SkShader::kRepeat_TileMode);
+}
+
+static SkShader* make_shader1(const SkIPoint& size) {
+ SkPoint pts[] = { { 0, 0 },
+ { SkIntToScalar(size.fX), SkIntToScalar(size.fY) } };
+ SkColor colors[] = { SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorRED };
+ return SkGradientShader::CreateLinear(pts, colors, NULL,
+ SK_ARRAY_COUNT(colors), SkShader::kMirror_TileMode, NULL);
+}
+
+class VerticesView : public SampleView {
+ SkShader* fShader0;
+ SkShader* fShader1;
+
+public:
+ VerticesView() {
+ SkIPoint size;
+
+ fShader0 = make_shader0(&size);
+ fShader1 = make_shader1(size);
+
+ make_strip(&fRecs[0], size.fX, size.fY);
+ make_fan(&fRecs[1], size.fX, size.fY);
+ make_tris(&fRecs[2]);
+
+ fScale = SK_Scalar1;
+
+ this->setBGColor(SK_ColorGRAY);
+ }
+
+ virtual ~VerticesView() {
+ SkSafeUnref(fShader0);
+ SkSafeUnref(fShader1);
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt))
+ {
+ SkString str("Vertices");
+ SampleCode::TitleR(evt, str.c_str());
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ SkScalar fScale;
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ SkPaint paint;
+ paint.setDither(true);
+ paint.setFilterBitmap(true);
+
+ for (size_t i = 0; i < SK_ARRAY_COUNT(fRecs); i++) {
+ canvas->save();
+
+ paint.setShader(NULL);
+ canvas->drawVertices(fRecs[i].fMode, fRecs[i].fCount,
+ fRecs[i].fVerts, fRecs[i].fTexs,
+ NULL, NULL, NULL, 0, paint);
+
+ canvas->translate(SkIntToScalar(250), 0);
+
+ paint.setShader(fShader0);
+ canvas->drawVertices(fRecs[i].fMode, fRecs[i].fCount,
+ fRecs[i].fVerts, fRecs[i].fTexs,
+ NULL, NULL, NULL, 0, paint);
+
+ canvas->translate(SkIntToScalar(250), 0);
+
+ paint.setShader(fShader1);
+ canvas->drawVertices(fRecs[i].fMode, fRecs[i].fCount,
+ fRecs[i].fVerts, fRecs[i].fTexs,
+ NULL, NULL, NULL, 0, paint);
+ canvas->restore();
+
+ canvas->translate(0, SkIntToScalar(250));
+ }
+ }
+
+ virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
+ return new Click(this);
+ }
+
+ virtual bool onClick(Click* click) {
+ // fCurrX = click->fICurr.fX;
+ // fCurrY = click->fICurr.fY;
+ this->inval(NULL);
+ return true;
+ }
+
+private:
+ struct Rec {
+ SkCanvas::VertexMode fMode;
+ int fCount;
+ SkPoint* fVerts;
+ SkPoint* fTexs;
+
+ Rec() : fCount(0), fVerts(NULL), fTexs(NULL) {}
+ ~Rec() { delete[] fVerts; delete[] fTexs; }
+ };
+
+ void make_tris(Rec* rec) {
+ int n = 10;
+ SkRandom rand;
+
+ rec->fMode = SkCanvas::kTriangles_VertexMode;
+ rec->fCount = n * 3;
+ rec->fVerts = new SkPoint[rec->fCount];
+
+ for (int i = 0; i < n; i++) {
+ SkPoint* v = &rec->fVerts[i*3];
+ for (int j = 0; j < 3; j++) {
+ v[j].set(rand.nextUScalar1() * 250, rand.nextUScalar1() * 250);
+ }
+ }
+ }
+
+ void make_fan(Rec* rec, int texWidth, int texHeight) {
+ const SkScalar tx = SkIntToScalar(texWidth);
+ const SkScalar ty = SkIntToScalar(texHeight);
+ const int n = 24;
+
+ rec->fMode = SkCanvas::kTriangleFan_VertexMode;
+ rec->fCount = n + 2;
+ rec->fVerts = new SkPoint[rec->fCount];
+ rec->fTexs = new SkPoint[rec->fCount];
+
+ SkPoint* v = rec->fVerts;
+ SkPoint* t = rec->fTexs;
+
+ v[0].set(0, 0);
+ t[0].set(0, 0);
+ for (int i = 0; i < n; i++) {
+ SkScalar cos;
+ SkScalar sin = SkScalarSinCos(SK_ScalarPI * 2 * i / n, &cos);
+ v[i+1].set(cos, sin);
+ t[i+1].set(i*tx/n, ty);
+ }
+ v[n+1] = v[1];
+ t[n+1].set(tx, ty);
+
+ SkMatrix m;
+ m.setScale(SkIntToScalar(100), SkIntToScalar(100));
+ m.postTranslate(SkIntToScalar(110), SkIntToScalar(110));
+ m.mapPoints(v, rec->fCount);
+ }
+
+ void make_strip(Rec* rec, int texWidth, int texHeight) {
+ const SkScalar tx = SkIntToScalar(texWidth);
+ const SkScalar ty = SkIntToScalar(texHeight);
+ const int n = 24;
+
+ rec->fMode = SkCanvas::kTriangleStrip_VertexMode;
+ rec->fCount = 2 * (n + 1);
+ rec->fVerts = new SkPoint[rec->fCount];
+ rec->fTexs = new SkPoint[rec->fCount];
+
+ SkPoint* v = rec->fVerts;
+ SkPoint* t = rec->fTexs;
+
+ for (int i = 0; i < n; i++) {
+ SkScalar cos;
+ SkScalar sin = SkScalarSinCos(SK_ScalarPI * 2 * i / n, &cos);
+ v[i*2 + 0].set(cos/2, sin/2);
+ v[i*2 + 1].set(cos, sin);
+
+ t[i*2 + 0].set(tx * i / n, ty);
+ t[i*2 + 1].set(tx * i / n, 0);
+ }
+ v[2*n + 0] = v[0];
+ v[2*n + 1] = v[1];
+
+ t[2*n + 0].set(tx, ty);
+ t[2*n + 1].set(tx, 0);
+
+ SkMatrix m;
+ m.setScale(SkIntToScalar(100), SkIntToScalar(100));
+ m.postTranslate(SkIntToScalar(110), SkIntToScalar(110));
+ m.mapPoints(v, rec->fCount);
+ }
+
+ Rec fRecs[3];
+
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new VerticesView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleWarp.cpp b/samplecode/SampleWarp.cpp
new file mode 100644
index 0000000..bf4ef0d
--- /dev/null
+++ b/samplecode/SampleWarp.cpp
@@ -0,0 +1,467 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkGradientShader.h"
+#include "SkPath.h"
+#include "SkRegion.h"
+#include "SkShader.h"
+#include "SkUtils.h"
+#include "SkImageDecoder.h"
+
+#include "SkBlurMaskFilter.h"
+#include "SkTableMaskFilter.h"
+
+#define kNearlyZero (SK_Scalar1 / 8092)
+
+static void test_bigblur(SkCanvas* canvas) {
+ canvas->drawColor(SK_ColorBLACK);
+
+ SkBitmap orig, mask;
+ SkImageDecoder::DecodeFile("/skimages/app_icon.png", &orig);
+
+ SkMaskFilter* mf = SkBlurMaskFilter::Create(8, SkBlurMaskFilter::kNormal_BlurStyle);
+ SkPaint paint;
+ paint.setMaskFilter(mf)->unref();
+ SkIPoint offset;
+ orig.extractAlpha(&mask, &paint, &offset);
+
+ paint.setColor(0xFFBB8800);
+ paint.setColor(SK_ColorWHITE);
+
+ int i;
+ canvas->save();
+ float gamma = 0.8;
+ for (i = 0; i < 5; i++) {
+ paint.setMaskFilter(SkTableMaskFilter::CreateGamma(gamma))->unref();
+ canvas->drawBitmap(mask, 0, 0, &paint);
+ paint.setMaskFilter(NULL);
+ canvas->drawBitmap(orig, -offset.fX, -offset.fY, &paint);
+ gamma -= 0.1;
+ canvas->translate(120, 0);
+ }
+ canvas->restore();
+ canvas->translate(0, 160);
+
+ for (i = 0; i < 5; i++) {
+ paint.setMaskFilter(SkTableMaskFilter::CreateClip(i*30, 255 - 20))->unref();
+ canvas->drawBitmap(mask, 0, 0, &paint);
+ paint.setMaskFilter(NULL);
+ canvas->drawBitmap(orig, -offset.fX, -offset.fY, &paint);
+ canvas->translate(120, 0);
+ }
+
+#if 0
+ paint.setColor(0xFFFFFFFF);
+ canvas->drawBitmap(mask, 0, 0, &paint);
+ paint.setMaskFilter(NULL);
+ canvas->drawBitmap(orig, -offset.fX, -offset.fY, &paint);
+
+ canvas->translate(120, 0);
+
+ canvas->drawBitmap(mask, 0, 0, &paint);
+ canvas->drawBitmap(mask, 0, 0, &paint);
+ canvas->drawBitmap(orig, -offset.fX, -offset.fY, &paint);
+
+ canvas->translate(120, 0);
+
+ canvas->drawBitmap(mask, 0, 0, &paint);
+ canvas->drawBitmap(mask, 0, 0, &paint);
+ canvas->drawBitmap(mask, 0, 0, &paint);
+ canvas->drawBitmap(orig, -offset.fX, -offset.fY, &paint);
+
+ canvas->translate(120, 0);
+
+ canvas->drawBitmap(mask, 0, 0, &paint);
+ canvas->drawBitmap(mask, 0, 0, &paint);
+ canvas->drawBitmap(mask, 0, 0, &paint);
+ canvas->drawBitmap(mask, 0, 0, &paint);
+ canvas->drawBitmap(orig, -offset.fX, -offset.fY, &paint);
+
+ canvas->translate(120, 0);
+
+ canvas->drawBitmap(mask, 0, 0, &paint);
+ canvas->drawBitmap(mask, 0, 0, &paint);
+ canvas->drawBitmap(mask, 0, 0, &paint);
+ canvas->drawBitmap(mask, 0, 0, &paint);
+ canvas->drawBitmap(mask, 0, 0, &paint);
+ canvas->drawBitmap(orig, -offset.fX, -offset.fY, &paint);
+#endif
+}
+
+#include "SkMeshUtils.h"
+
+static SkPoint SkMakePoint(SkScalar x, SkScalar y) {
+ SkPoint pt;
+ pt.set(x, y);
+ return pt;
+}
+
+static SkPoint SkPointInterp(const SkPoint& a, const SkPoint& b, SkScalar t) {
+ return SkMakePoint(SkScalarInterp(a.fX, b.fX, t),
+ SkScalarInterp(a.fY, b.fY, t));
+}
+
+#include "SkBoundaryPatch.h"
+
+static void set_cubic(SkPoint pts[4], SkScalar x0, SkScalar y0,
+ SkScalar x3, SkScalar y3, SkScalar scale = 1) {
+ SkPoint tmp, tmp2;
+
+ pts[0].set(x0, y0);
+ pts[3].set(x3, y3);
+
+ tmp = SkPointInterp(pts[0], pts[3], SK_Scalar1/3);
+ tmp2 = pts[0] - tmp;
+ tmp2.rotateCW();
+ tmp2.scale(scale);
+ pts[1] = tmp + tmp2;
+
+ tmp = SkPointInterp(pts[0], pts[3], 2*SK_Scalar1/3);
+ tmp2 = pts[3] - tmp;
+ tmp2.rotateCW();
+ tmp2.scale(scale);
+ pts[2] = tmp + tmp2;
+}
+
+static void test_patch(SkCanvas* canvas, const SkBitmap& bm, SkScalar scale) {
+ SkCubicBoundary cubic;
+ set_cubic(cubic.fPts + 0, 0, 0, 100, 0, scale);
+ set_cubic(cubic.fPts + 3, 100, 0, 100, 100, scale);
+ set_cubic(cubic.fPts + 6, 100, 100, 0, 100, -scale);
+ set_cubic(cubic.fPts + 9, 0, 100, 0, 0, 0);
+
+ SkBoundaryPatch patch;
+ patch.setBoundary(&cubic);
+
+ const int Rows = 16;
+ const int Cols = 16;
+ SkPoint pts[Rows * Cols];
+ patch.evalPatch(pts, Rows, Cols);
+
+ SkPaint paint;
+ paint.setAntiAlias(true);
+ paint.setFilterBitmap(true);
+ paint.setStrokeWidth(1);
+ paint.setStrokeCap(SkPaint::kRound_Cap);
+
+ canvas->translate(50, 50);
+ canvas->scale(3, 3);
+
+ SkMeshUtils::Draw(canvas, bm, Rows, Cols, pts, NULL, paint);
+}
+
+static void test_drag(SkCanvas* canvas, const SkBitmap& bm,
+ const SkPoint& p0, const SkPoint& p1) {
+ SkCubicBoundary cubic;
+ set_cubic(cubic.fPts + 0, 0, 0, 100, 0, 0);
+ set_cubic(cubic.fPts + 3, 100, 0, 100, 100, 0);
+ set_cubic(cubic.fPts + 6, 100, 100, 0, 100, 0);
+ set_cubic(cubic.fPts + 9, 0, 100, 0, 0, 0);
+
+#if 0
+ cubic.fPts[1] += p1 - p0;
+ cubic.fPts[2] += p1 - p0;
+#else
+ SkScalar dx = p1.fX - p0.fX;
+ if (dx > 0) dx = 0;
+ SkScalar dy = p1.fY - p0.fY;
+ if (dy > 0) dy = 0;
+
+ cubic.fPts[1].fY += dy;
+ cubic.fPts[2].fY += dy;
+ cubic.fPts[10].fX += dx;
+ cubic.fPts[11].fX += dx;
+#endif
+
+ SkBoundaryPatch patch;
+ patch.setBoundary(&cubic);
+
+ const int Rows = 16;
+ const int Cols = 16;
+ SkPoint pts[Rows * Cols];
+ patch.evalPatch(pts, Rows, Cols);
+
+ SkPaint paint;
+ paint.setAntiAlias(true);
+ paint.setFilterBitmap(true);
+ paint.setStrokeWidth(1);
+ paint.setStrokeCap(SkPaint::kRound_Cap);
+
+ canvas->translate(50, 50);
+ canvas->scale(3, 3);
+
+ SkAutoCanvasRestore acr(canvas, true);
+
+ SkRect r = { 0, 0, 100, 100 };
+ canvas->clipRect(r);
+ SkMeshUtils::Draw(canvas, bm, Rows, Cols, pts, NULL, paint);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+class Mesh {
+public:
+ Mesh();
+ ~Mesh();
+
+ Mesh& operator=(const Mesh& src);
+
+ void init(const SkRect& bounds, int rows, int cols,
+ const SkRect& texture);
+
+ const SkRect& bounds() const { return fBounds; }
+
+ int rows() const { return fRows; }
+ int cols() const { return fCols; }
+ SkPoint& pt(int row, int col) {
+ return fPts[row * (fRows + 1) + col];
+ }
+
+ void draw(SkCanvas*, const SkPaint&);
+ void drawWireframe(SkCanvas* canvas, const SkPaint& paint);
+
+private:
+ SkRect fBounds;
+ int fRows, fCols;
+ SkPoint* fPts;
+ SkPoint* fTex; // just points into fPts, not separately allocated
+ int fCount;
+ uint16_t* fIndices;
+ int fIndexCount;
+};
+
+Mesh::Mesh() : fPts(NULL), fCount(0), fIndices(NULL), fIndexCount(0) {}
+
+Mesh::~Mesh() {
+ delete[] fPts;
+ delete[] fIndices;
+}
+
+Mesh& Mesh::operator=(const Mesh& src) {
+ delete[] fPts;
+ delete[] fIndices;
+
+ fBounds = src.fBounds;
+ fRows = src.fRows;
+ fCols = src.fCols;
+
+ fCount = src.fCount;
+ fPts = new SkPoint[fCount * 2];
+ fTex = fPts + fCount;
+ memcpy(fPts, src.fPts, fCount * 2 * sizeof(SkPoint));
+
+ delete[] fIndices;
+ fIndexCount = src.fIndexCount;
+ fIndices = new uint16_t[fIndexCount];
+ memcpy(fIndices, src.fIndices, fIndexCount * sizeof(uint16_t));
+
+ return *this;
+}
+
+void Mesh::init(const SkRect& bounds, int rows, int cols,
+ const SkRect& texture) {
+ SkASSERT(rows > 0 && cols > 0);
+
+ fBounds = bounds;
+ fRows = rows;
+ fCols = cols;
+
+ delete[] fPts;
+ fCount = (rows + 1) * (cols + 1);
+ fPts = new SkPoint[fCount * 2];
+ fTex = fPts + fCount;
+
+ delete[] fIndices;
+ fIndexCount = rows * cols * 6;
+ fIndices = new uint16_t[fIndexCount];
+
+ SkPoint* pts = fPts;
+ const SkScalar dx = bounds.width() / rows;
+ const SkScalar dy = bounds.height() / cols;
+ SkPoint* tex = fTex;
+ const SkScalar dtx = texture.width() / rows;
+ const SkScalar dty = texture.height() / cols;
+ uint16_t* idx = fIndices;
+ int index = 0;
+ for (int y = 0; y <= cols; y++) {
+ for (int x = 0; x <= rows; x++) {
+ pts->set(bounds.fLeft + x*dx, bounds.fTop + y*dy);
+ pts += 1;
+ tex->set(texture.fLeft + x*dtx, texture.fTop + y*dty);
+ tex += 1;
+
+ if (y < cols && x < rows) {
+ *idx++ = index;
+ *idx++ = index + rows + 1;
+ *idx++ = index + 1;
+
+ *idx++ = index + 1;
+ *idx++ = index + rows + 1;
+ *idx++ = index + rows + 2;
+
+ index += 1;
+ }
+ }
+ index += 1;
+ }
+}
+
+void Mesh::draw(SkCanvas* canvas, const SkPaint& paint) {
+ canvas->drawVertices(SkCanvas::kTriangles_VertexMode, fCount,
+ fPts, fTex, NULL, NULL, fIndices, fIndexCount,
+ paint);
+}
+
+void Mesh::drawWireframe(SkCanvas* canvas, const SkPaint& paint) {
+ canvas->drawVertices(SkCanvas::kTriangles_VertexMode, fCount,
+ fPts, NULL, NULL, NULL, fIndices, fIndexCount,
+ paint);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+class WarpView : public SkView {
+ Mesh fMesh, fOrig;
+ SkBitmap fBitmap;
+ SkMatrix fMatrix, fInverse;
+public:
+ WarpView() {
+ SkBitmap bm;
+// SkImageDecoder::DecodeFile("/skimages/marker.png", &bm);
+ SkImageDecoder::DecodeFile("/skimages/logo.gif", &bm);
+ // SkImageDecoder::DecodeFile("/beach_shot.JPG", &bm);
+ fBitmap = bm;
+
+ SkRect bounds, texture;
+ texture.set(0, 0, SkIntToScalar(fBitmap.width()),
+ SkIntToScalar(fBitmap.height()));
+ bounds = texture;
+
+// fMesh.init(bounds, fBitmap.width() / 40, fBitmap.height() / 40, texture);
+ fMesh.init(bounds, fBitmap.width()/16, fBitmap.height()/16, texture);
+ fOrig = fMesh;
+
+ fP0.set(0, 0);
+ fP1 = fP0;
+
+ fMatrix.setScale(2, 2);
+ fMatrix.invert(&fInverse);
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "Warp");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ static SkPoint apply_warp(const SkVector& drag, SkScalar dragLength,
+ const SkPoint& dragStart, const SkPoint& dragCurr,
+ const SkPoint& orig) {
+ SkVector delta = orig - dragCurr;
+ SkScalar length = SkPoint::Normalize(&delta);
+ if (length <= kNearlyZero) {
+ return orig;
+ }
+
+ const SkScalar period = 20;
+ const SkScalar mag = dragLength / 3;
+
+ SkScalar d = length / (period);
+ d = mag * SkScalarSin(d) / d;
+ SkScalar dx = delta.fX * d;
+ SkScalar dy = delta.fY * d;
+ SkScalar px = orig.fX + dx;
+ SkScalar py = orig.fY + dy;
+ return SkPoint::Make(px, py);
+ }
+
+ static SkPoint apply_warp2(const SkVector& drag, SkScalar dragLength,
+ const SkPoint& dragStart, const SkPoint& dragCurr,
+ const SkPoint& orig) {
+ SkVector delta = orig - dragCurr;
+ SkScalar length = SkPoint::Normalize(&delta);
+ if (length <= kNearlyZero) {
+ return orig;
+ }
+
+ const SkScalar period = 10 + dragLength/4;
+ const SkScalar mag = dragLength / 3;
+
+ SkScalar d = length / (period);
+ if (d > SK_ScalarPI) {
+ d = SK_ScalarPI;
+ }
+
+ d = -mag * SkScalarSin(d);
+
+ SkScalar dx = delta.fX * d;
+ SkScalar dy = delta.fY * d;
+ SkScalar px = orig.fX + dx;
+ SkScalar py = orig.fY + dy;
+ return SkPoint::Make(px, py);
+ }
+
+ typedef SkPoint (*WarpProc)(const SkVector& drag, SkScalar dragLength,
+ const SkPoint& dragStart, const SkPoint& dragCurr,
+ const SkPoint& orig);
+
+ void warp(const SkPoint& p0, const SkPoint& p1) {
+ WarpProc proc = apply_warp2;
+ SkPoint delta = p1 - p0;
+ SkScalar length = SkPoint::Normalize(&delta);
+ for (int y = 0; y < fMesh.rows(); y++) {
+ for (int x = 0; x < fMesh.cols(); x++) {
+ fMesh.pt(x, y) = proc(delta, length, p0, p1, fOrig.pt(x, y));
+ }
+ }
+ fP0 = p0;
+ fP1 = p1;
+ }
+
+ virtual void onDraw(SkCanvas* canvas) {
+ canvas->drawColor(SK_ColorLTGRAY);
+ // test_bigblur(canvas); return;
+
+ canvas->concat(fMatrix);
+
+ SkPaint paint;
+ paint.setFilterBitmap(true);
+ paint.setShader(SkShader::CreateBitmapShader(fBitmap,
+ SkShader::kClamp_TileMode,
+ SkShader::kClamp_TileMode))->unref();
+ fMesh.draw(canvas, paint); //return;
+
+ paint.setShader(NULL);
+ paint.setColor(SK_ColorRED);
+ fMesh.draw(canvas, paint);
+
+ // test_drag(canvas, fBitmap, fP0, fP1);
+ }
+
+ virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
+ return new Click(this);
+ }
+
+ virtual bool onClick(Click* click) {
+ SkPoint pts[2] = { click->fOrig, click->fCurr };
+ fInverse.mapPoints(pts, 2);
+ this->warp(pts[0], pts[1]);
+ this->inval(NULL);
+ return true;
+ }
+
+private:
+ SkIRect fBase, fRect;
+ SkPoint fP0, fP1;
+ typedef SkView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new WarpView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleXfermodes.cpp b/samplecode/SampleXfermodes.cpp
new file mode 100644
index 0000000..0a3c4c7
--- /dev/null
+++ b/samplecode/SampleXfermodes.cpp
@@ -0,0 +1,250 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "Sk64.h"
+#include "SkCornerPathEffect.h"
+#include "SkGradientShader.h"
+#include "SkGraphics.h"
+#include "SkImageDecoder.h"
+#include "SkKernel33MaskFilter.h"
+#include "SkPath.h"
+#include "SkRandom.h"
+#include "SkRegion.h"
+#include "SkShader.h"
+#include "SkUtils.h"
+#include "SkColorPriv.h"
+#include "SkColorFilter.h"
+#include "SkTime.h"
+#include "SkTypeface.h"
+#include "SkXfermode.h"
+
+#include "SkStream.h"
+#include "SkXMLParser.h"
+#include "SkColorPriv.h"
+#include "SkImageDecoder.h"
+
+static void setNamedTypeface(SkPaint* paint, const char name[]) {
+ SkTypeface* face = SkTypeface::CreateFromName(name, SkTypeface::kNormal);
+ paint->setTypeface(face);
+ SkSafeUnref(face);
+}
+
+#if 0
+static int newscale(U8CPU a, U8CPU b, int shift) {
+ unsigned prod = a * b + (1 << (shift - 1));
+ return (prod + (prod >> shift)) >> shift;
+}
+
+static void test_srcover565(SkCanvas* canvas) {
+ const int width = 32;
+ SkBitmap bm1, bm2, bm3;
+ bm1.setConfig(SkBitmap::kRGB_565_Config, width, 256); bm1.allocPixels(NULL);
+ bm2.setConfig(SkBitmap::kRGB_565_Config, width, 256); bm2.allocPixels(NULL);
+ bm3.setConfig(SkBitmap::kRGB_565_Config, width, 256); bm3.allocPixels(NULL);
+
+ int rgb = 0x18;
+ int r = rgb >> 3;
+ int g = rgb >> 2;
+ uint16_t dst = SkPackRGB16(r, g, r);
+ for (int alpha = 0; alpha <= 255; alpha++) {
+ SkPMColor pm = SkPreMultiplyARGB(alpha, rgb, rgb, rgb);
+ uint16_t newdst = SkSrcOver32To16(pm, dst);
+ sk_memset16(bm1.getAddr16(0, alpha), newdst, bm1.width());
+
+ int ia = 255 - alpha;
+ int iscale = SkAlpha255To256(ia);
+ int dr = (SkGetPackedR32(pm) + (r * iscale >> 5)) >> 3;
+ int dg = (SkGetPackedG32(pm) + (g * iscale >> 6)) >> 2;
+
+ sk_memset16(bm2.getAddr16(0, alpha), SkPackRGB16(dr, dg, dr), bm2.width());
+
+ int dr2 = (SkMulDiv255Round(alpha, rgb) + newscale(r, ia, 5)) >> 3;
+ int dg2 = (SkMulDiv255Round(alpha, rgb) + newscale(g, ia, 6)) >> 2;
+
+ sk_memset16(bm3.getAddr16(0, alpha), SkPackRGB16(dr2, dg2, dr2), bm3.width());
+
+// if (mr != dr || mg != dg)
+ {
+// SkDebugf("[%d] macro [%d %d] inline [%d %d] new [%d %d]\n", alpha, mr, mg, dr, dg, dr2, dg2);
+ }
+ }
+
+ SkScalar dx = SkIntToScalar(width+4);
+
+ canvas->drawBitmap(bm1, 0, 0, NULL); canvas->translate(dx, 0);
+ canvas->drawBitmap(bm2, 0, 0, NULL); canvas->translate(dx, 0);
+ canvas->drawBitmap(bm3, 0, 0, NULL); canvas->translate(dx, 0);
+
+ SkRect rect = { 0, 0, SkIntToScalar(bm1.width()), SkIntToScalar(bm1.height()) };
+ SkPaint p;
+ p.setARGB(0xFF, rgb, rgb, rgb);
+ canvas->drawRect(rect, p);
+}
+#endif
+
+static void make_bitmaps(int w, int h, SkBitmap* src, SkBitmap* dst) {
+ src->setConfig(SkBitmap::kARGB_8888_Config, w, h);
+ src->allocPixels();
+ src->eraseColor(0);
+
+ SkCanvas c(*src);
+ SkPaint p;
+ SkRect r;
+ SkScalar ww = SkIntToScalar(w);
+ SkScalar hh = SkIntToScalar(h);
+
+ p.setAntiAlias(true);
+ p.setColor(0xFFFFCC44);
+ r.set(0, 0, ww*3/4, hh*3/4);
+ c.drawOval(r, p);
+
+ dst->setConfig(SkBitmap::kARGB_8888_Config, w, h);
+ dst->allocPixels();
+ dst->eraseColor(0);
+ c.setBitmapDevice(*dst);
+
+ p.setColor(0xFF66AAFF);
+ r.set(ww/3, hh/3, ww*19/20, hh*19/20);
+ c.drawRect(r, p);
+}
+
+static uint16_t gBG[] = { 0xFFFF, 0xCCCF, 0xCCCF, 0xFFFF };
+
+class XfermodesView : public SampleView {
+ SkBitmap fBG;
+ SkBitmap fSrcB, fDstB;
+
+ void draw_mode(SkCanvas* canvas, SkXfermode* mode, int alpha,
+ SkScalar x, SkScalar y) {
+ SkPaint p;
+
+ canvas->drawBitmap(fSrcB, x, y, &p);
+ p.setAlpha(alpha);
+ p.setXfermode(mode);
+ canvas->drawBitmap(fDstB, x, y, &p);
+ }
+
+public:
+ const static int W = 64;
+ const static int H = 64;
+ XfermodesView() {
+ const int W = 64;
+ const int H = 64;
+
+ fBG.setConfig(SkBitmap::kARGB_4444_Config, 2, 2, 4);
+ fBG.setPixels(gBG);
+ fBG.setIsOpaque(true);
+
+ make_bitmaps(W, H, &fSrcB, &fDstB);
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "Xfermodes");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ canvas->translate(SkIntToScalar(10), SkIntToScalar(20));
+
+ const struct {
+ SkXfermode::Mode fMode;
+ const char* fLabel;
+ } gModes[] = {
+ { SkXfermode::kClear_Mode, "Clear" },
+ { SkXfermode::kSrc_Mode, "Src" },
+ { SkXfermode::kDst_Mode, "Dst" },
+ { SkXfermode::kSrcOver_Mode, "SrcOver" },
+ { SkXfermode::kDstOver_Mode, "DstOver" },
+ { SkXfermode::kSrcIn_Mode, "SrcIn" },
+ { SkXfermode::kDstIn_Mode, "DstIn" },
+ { SkXfermode::kSrcOut_Mode, "SrcOut" },
+ { SkXfermode::kDstOut_Mode, "DstOut" },
+ { SkXfermode::kSrcATop_Mode, "SrcATop" },
+ { SkXfermode::kDstATop_Mode, "DstATop" },
+ { SkXfermode::kXor_Mode, "Xor" },
+
+ { SkXfermode::kPlus_Mode, "Plus" },
+ { SkXfermode::kMultiply_Mode, "Multiply" },
+ { SkXfermode::kScreen_Mode, "Screen" },
+ { SkXfermode::kOverlay_Mode, "Overlay" },
+ { SkXfermode::kDarken_Mode, "Darken" },
+ { SkXfermode::kLighten_Mode, "Lighten" },
+ { SkXfermode::kColorDodge_Mode, "ColorDodge" },
+ { SkXfermode::kColorBurn_Mode, "ColorBurn" },
+ { SkXfermode::kHardLight_Mode, "HardLight" },
+ { SkXfermode::kSoftLight_Mode, "SoftLight" },
+ { SkXfermode::kDifference_Mode, "Difference" },
+ { SkXfermode::kExclusion_Mode, "Exclusion" },
+ };
+
+ const SkScalar w = SkIntToScalar(W);
+ const SkScalar h = SkIntToScalar(H);
+ SkShader* s = SkShader::CreateBitmapShader(fBG,
+ SkShader::kRepeat_TileMode,
+ SkShader::kRepeat_TileMode);
+ SkMatrix m;
+ m.setScale(SkIntToScalar(6), SkIntToScalar(6));
+ s->setLocalMatrix(m);
+
+ SkPaint labelP;
+ labelP.setAntiAlias(true);
+ labelP.setLCDRenderText(true);
+ labelP.setTextAlign(SkPaint::kCenter_Align);
+ setNamedTypeface(&labelP, "Menlo Regular");
+// labelP.setTextSize(SkIntToScalar(11));
+
+ const int W = 5;
+
+ SkScalar x0 = 0;
+ for (int twice = 0; twice < 2; twice++) {
+ SkScalar x = x0, y = 0;
+ for (size_t i = 0; i < SK_ARRAY_COUNT(gModes); i++) {
+ SkXfermode* mode = SkXfermode::Create(gModes[i].fMode);
+ SkAutoUnref aur(mode);
+ SkRect r;
+ r.set(x, y, x+w, y+h);
+
+ SkPaint p;
+ p.setStyle(SkPaint::kFill_Style);
+ p.setShader(s);
+ canvas->drawRect(r, p);
+
+ canvas->saveLayer(&r, NULL, SkCanvas::kARGB_ClipLayer_SaveFlag);
+ // canvas->save();
+ draw_mode(canvas, mode, twice ? 0x88 : 0xFF, r.fLeft, r.fTop);
+ canvas->restore();
+
+ r.inset(-SK_ScalarHalf, -SK_ScalarHalf);
+ p.setStyle(SkPaint::kStroke_Style);
+ p.setShader(NULL);
+ canvas->drawRect(r, p);
+
+#if 1
+ canvas->drawText(gModes[i].fLabel, strlen(gModes[i].fLabel),
+ x + w/2, y - labelP.getTextSize()/2, labelP);
+#endif
+ x += w + SkIntToScalar(10);
+ if ((i % W) == W - 1) {
+ x = x0;
+ y += h + SkIntToScalar(30);
+ }
+ }
+ x0 += SkIntToScalar(400);
+ }
+ s->unref();
+ }
+
+private:
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new XfermodesView; }
+static SkViewRegister reg(MyFactory);
+
diff --git a/samplecode/SampleXfermodesBlur.cpp b/samplecode/SampleXfermodesBlur.cpp
new file mode 100644
index 0000000..166e4e5
--- /dev/null
+++ b/samplecode/SampleXfermodesBlur.cpp
@@ -0,0 +1,182 @@
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "Sk64.h"
+#include "SkCornerPathEffect.h"
+#include "SkGradientShader.h"
+#include "SkGraphics.h"
+#include "SkImageDecoder.h"
+#include "SkKernel33MaskFilter.h"
+#include "SkPath.h"
+#include "SkRandom.h"
+#include "SkRegion.h"
+#include "SkShader.h"
+#include "SkUtils.h"
+#include "SkColorPriv.h"
+#include "SkColorFilter.h"
+#include "SkTime.h"
+#include "SkTypeface.h"
+#include "SkXfermode.h"
+
+#include "SkStream.h"
+#include "SkXMLParser.h"
+#include "SkColorPriv.h"
+#include "SkImageDecoder.h"
+#include "SkBlurMaskFilter.h"
+
+static void setNamedTypeface(SkPaint* paint, const char name[]) {
+ SkTypeface* face = SkTypeface::CreateFromName(name, SkTypeface::kNormal);
+ paint->setTypeface(face);
+ SkSafeUnref(face);
+}
+
+static uint16_t gBG[] = { 0xFFFF, 0xCCCF, 0xCCCF, 0xFFFF };
+
+class XfermodesBlurView : public SampleView {
+ SkBitmap fBG;
+ SkBitmap fSrcB, fDstB;
+
+ void draw_mode(SkCanvas* canvas, SkXfermode* mode, int alpha,
+ SkScalar x, SkScalar y) {
+ SkPaint p;
+ SkMaskFilter* mf = SkBlurMaskFilter::Create(5, SkBlurMaskFilter::kNormal_BlurStyle, 0);
+ p.setMaskFilter(mf)->unref();
+
+ SkScalar ww = SkIntToScalar(W);
+ SkScalar hh = SkIntToScalar(H);
+
+ // draw a circle covering the upper
+ // left three quarters of the canvas
+ p.setColor(0xFFCC44FF);
+ SkRect r;
+ r.set(0, 0, ww*3/4, hh*3/4);
+ r.offset(x, y);
+ canvas->drawOval(r, p);
+
+ p.setXfermode(mode);
+
+ // draw a square overlapping the circle
+ // in the lower right of the canvas
+ p.setColor(0x00AA6633 | alpha << 24);
+ r.set(ww/3, hh/3, ww*19/20, hh*19/20);
+ r.offset(x, y);
+ canvas->drawRect(r, p);
+ }
+
+public:
+ const static int W = 64;
+ const static int H = 64;
+ XfermodesBlurView() {
+ const int W = 64;
+ const int H = 64;
+
+ fBG.setConfig(SkBitmap::kARGB_4444_Config, 2, 2, 4);
+ fBG.setPixels(gBG);
+ fBG.setIsOpaque(true);
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "XfermodesBlur");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ canvas->translate(SkIntToScalar(10), SkIntToScalar(20));
+
+ const struct {
+ SkXfermode::Mode fMode;
+ const char* fLabel;
+ } gModes[] = {
+ { SkXfermode::kClear_Mode, "Clear" },
+ { SkXfermode::kSrc_Mode, "Src" },
+ { SkXfermode::kDst_Mode, "Dst" },
+ { SkXfermode::kSrcOver_Mode, "SrcOver" },
+ { SkXfermode::kDstOver_Mode, "DstOver" },
+ { SkXfermode::kSrcIn_Mode, "SrcIn" },
+ { SkXfermode::kDstIn_Mode, "DstIn" },
+ { SkXfermode::kSrcOut_Mode, "SrcOut" },
+ { SkXfermode::kDstOut_Mode, "DstOut" },
+ { SkXfermode::kSrcATop_Mode, "SrcATop" },
+ { SkXfermode::kDstATop_Mode, "DstATop" },
+ { SkXfermode::kXor_Mode, "Xor" },
+
+ { SkXfermode::kPlus_Mode, "Plus" },
+ /*{ SkXfermode::kMultiply_Mode, "Multiply" },
+ { SkXfermode::kScreen_Mode, "Screen" },
+ { SkXfermode::kOverlay_Mode, "Overlay" },
+ { SkXfermode::kDarken_Mode, "Darken" },
+ { SkXfermode::kLighten_Mode, "Lighten" },
+ { SkXfermode::kColorDodge_Mode, "ColorDodge" },
+ { SkXfermode::kColorBurn_Mode, "ColorBurn" },
+ { SkXfermode::kHardLight_Mode, "HardLight" },
+ { SkXfermode::kSoftLight_Mode, "SoftLight" },
+ { SkXfermode::kDifference_Mode, "Difference" },
+ { SkXfermode::kExclusion_Mode, "Exclusion" },*/
+ };
+
+ const SkScalar w = SkIntToScalar(W);
+ const SkScalar h = SkIntToScalar(H);
+ SkShader* s = SkShader::CreateBitmapShader(fBG,
+ SkShader::kRepeat_TileMode,
+ SkShader::kRepeat_TileMode);
+ SkMatrix m;
+ m.setScale(SkIntToScalar(6), SkIntToScalar(6));
+ s->setLocalMatrix(m);
+
+ SkPaint labelP;
+ labelP.setAntiAlias(true);
+ labelP.setLCDRenderText(true);
+ labelP.setTextAlign(SkPaint::kCenter_Align);
+ setNamedTypeface(&labelP, "Menlo Regular");
+
+ const int W = 5;
+
+ SkScalar x0 = 0;
+ for (int twice = 0; twice < 2; twice++) {
+ SkScalar x = x0, y = 0;
+ for (size_t i = 0; i < SK_ARRAY_COUNT(gModes); i++) {
+ SkXfermode* mode = SkXfermode::Create(gModes[i].fMode);
+ SkAutoUnref aur(mode);
+ SkRect r;
+ r.set(x, y, x+w, y+h);
+
+ SkPaint p;
+ p.setStyle(SkPaint::kFill_Style);
+ p.setShader(s);
+ canvas->drawRect(r, p);
+
+ canvas->saveLayer(&r, NULL, SkCanvas::kARGB_ClipLayer_SaveFlag);
+ draw_mode(canvas, mode, twice ? 0x88 : 0xFF, r.fLeft, r.fTop);
+ canvas->restore();
+
+ r.inset(-SK_ScalarHalf, -SK_ScalarHalf);
+ p.setStyle(SkPaint::kStroke_Style);
+ p.setShader(NULL);
+ canvas->drawRect(r, p);
+
+ canvas->drawText(gModes[i].fLabel, strlen(gModes[i].fLabel),
+ x + w/2, y - labelP.getTextSize()/2, labelP);
+ x += w + SkIntToScalar(10);
+ if ((i % W) == W - 1) {
+ x = x0;
+ y += h + SkIntToScalar(30);
+ }
+ }
+ x0 += SkIntToScalar(400);
+ }
+ s->unref();
+ }
+
+private:
+ typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new XfermodesBlurView; }
+static SkViewRegister reg(MyFactory);
diff --git a/samplecode/samplecode_files.mk b/samplecode/samplecode_files.mk
new file mode 100644
index 0000000..4c660e5
--- /dev/null
+++ b/samplecode/samplecode_files.mk
@@ -0,0 +1,69 @@
+SOURCE := \
+ SampleBitmapRect.cpp \
+ SamplePathClip.cpp \
+ SampleComplexClip.cpp \
+ SampleNinePatch.cpp \
+ SampleAvoid.cpp \
+ SampleMeasure.cpp \
+ SampleArc.cpp \
+ SampleRepeatTile.cpp \
+ SampleApp.cpp \
+ vertexdump.cpp \
+ SampleShapes.cpp \
+ SampleMipMap.cpp \
+ SampleLCD.cpp \
+ SampleCamera.cpp \
+ SampleVertices.cpp \
+ SampleFontScalerTest.cpp \
+ SampleBigGradient.cpp \
+ SampleAll.cpp \
+ SampleShaderText.cpp \
+ SamplePolyToPoly.cpp \
+ SampleBlur.cpp \
+ SampleHairline.cpp \
+ SampleCircle.cpp \
+ SampleOvalTest.cpp \
+ SampleLines.cpp \
+ SampleOverflow.cpp \
+ SampleStrokePath.cpp \
+ SampleSlides.cpp \
+ SampleLayers.cpp \
+ SampleTiling.cpp \
+ SampleTinyBitmap.cpp \
+ SampleXfermodes.cpp \
+ SampleDrawLooper.cpp \
+ SampleTextEffects.cpp \
+ SampleTextOnPath.cpp \
+ SampleDitherBitmap.cpp \
+ SampleExtractAlpha.cpp \
+ SampleDither.cpp \
+ SampleEncode.cpp \
+ SampleFontCache.cpp \
+ SampleGradients.cpp \
+ SampleTypeface.cpp \
+ SampleFillType.cpp \
+ SamplePath.cpp \
+ SampleLayerMask.cpp \
+ SampleStrokeText.cpp \
+ SamplePathEffects.cpp \
+ SampleTextAlpha.cpp \
+ ClockFaceView.cpp \
+ SampleEmboss.cpp \
+ SamplePoints.cpp \
+ SampleFilter2.cpp \
+ SamplePatch.cpp \
+ SampleFilter.cpp \
+ OverView.cpp \
+ SampleFuzz.cpp \
+ SampleShaders.cpp \
+ SampleText.cpp \
+ SampleTextBox.cpp \
+ SampleImage.cpp \
+ SampleMovie.cpp \
+ SampleImageDir.cpp \
+ SampleWarp.cpp \
+ SamplePageFlip.cpp \
+ SamplePicture.cpp \
+ SampleLineClipper.cpp \
+ SampleRegion.cpp \
+ SampleDecode.cpp \ Crashes
diff --git a/samplecode/vertexdump.cpp b/samplecode/vertexdump.cpp
new file mode 100644
index 0000000..c124ad8
--- /dev/null
+++ b/samplecode/vertexdump.cpp
@@ -0,0 +1,88 @@
+#include "SkPoint.h"
+
+void setup_vertexbug(SkPoint verts[], SkPoint texs[], uint16_t index[]);
+
+void setup_vertexbug(SkPoint verts[], SkPoint texs[], uint16_t index[]) {
+ verts[0].set(SkFloatToScalar(107), SkFloatToScalar(189));
+ texs[0].set(SkFloatToScalar(0), SkFloatToScalar(0));
+ verts[1].set(SkFloatToScalar(116), SkFloatToScalar(189));
+ texs[1].set(SkFloatToScalar(9), SkFloatToScalar(0));
+ verts[2].set(SkFloatToScalar(203), SkFloatToScalar(189));
+ texs[2].set(SkFloatToScalar(35), SkFloatToScalar(0));
+ verts[3].set(SkFloatToScalar(212), SkFloatToScalar(189));
+ texs[3].set(SkFloatToScalar(44), SkFloatToScalar(0));
+ verts[4].set(SkFloatToScalar(107), SkFloatToScalar(198));
+ texs[4].set(SkFloatToScalar(0), SkFloatToScalar(9));
+ verts[5].set(SkFloatToScalar(116), SkFloatToScalar(198));
+ texs[5].set(SkFloatToScalar(9), SkFloatToScalar(9));
+ verts[6].set(SkFloatToScalar(203), SkFloatToScalar(198));
+ texs[6].set(SkFloatToScalar(35), SkFloatToScalar(9));
+ verts[7].set(SkFloatToScalar(212), SkFloatToScalar(198));
+ texs[7].set(SkFloatToScalar(44), SkFloatToScalar(9));
+ verts[8].set(SkFloatToScalar(107), SkFloatToScalar(224));
+ texs[8].set(SkFloatToScalar(0), SkFloatToScalar(39));
+ verts[9].set(SkFloatToScalar(116), SkFloatToScalar(224));
+ texs[9].set(SkFloatToScalar(9), SkFloatToScalar(39));
+ verts[10].set(SkFloatToScalar(203), SkFloatToScalar(224));
+ texs[10].set(SkFloatToScalar(35), SkFloatToScalar(39));
+ verts[11].set(SkFloatToScalar(212), SkFloatToScalar(224));
+ texs[11].set(SkFloatToScalar(44), SkFloatToScalar(39));
+ verts[12].set(SkFloatToScalar(107), SkFloatToScalar(233));
+ texs[12].set(SkFloatToScalar(0), SkFloatToScalar(48));
+ verts[13].set(SkFloatToScalar(116), SkFloatToScalar(233));
+ texs[13].set(SkFloatToScalar(9), SkFloatToScalar(48));
+ verts[14].set(SkFloatToScalar(203), SkFloatToScalar(233));
+ texs[14].set(SkFloatToScalar(35), SkFloatToScalar(48));
+ verts[15].set(SkFloatToScalar(212), SkFloatToScalar(233));
+ texs[15].set(SkFloatToScalar(44), SkFloatToScalar(48));
+ index[0] = 0; index[1] = 5; index[2] = 1;
+ index[3] = 0; index[4] = 4; index[5] = 5;
+#if 0
+ index[6] = 1; index[7] = 6; index[8] = 2;
+#else
+ index[6] = 6; index[7] = 2; index[8] = 1;
+#endif
+ index[9] = 1; index[10] = 5; index[11] = 6;
+ index[12] = 2;
+ index[13] = 7;
+ index[14] = 3;
+ index[15] = 2;
+ index[16] = 6;
+ index[17] = 7;
+ index[18] = 4;
+ index[19] = 9;
+ index[20] = 5;
+ index[21] = 4;
+ index[22] = 8;
+ index[23] = 9;
+ index[24] = 5;
+ index[25] = 10;
+ index[26] = 6;
+ index[27] = 5;
+ index[28] = 9;
+ index[29] = 10;
+ index[30] = 6;
+ index[31] = 11;
+ index[32] = 7;
+ index[33] = 6;
+ index[34] = 10;
+ index[35] = 11;
+ index[36] = 8;
+ index[37] = 13;
+ index[38] = 9;
+ index[39] = 8;
+ index[40] = 12;
+ index[41] = 13;
+ index[42] = 9;
+ index[43] = 14;
+ index[44] = 10;
+ index[45] = 9;
+ index[46] = 13;
+ index[47] = 14;
+ index[48] = 10;
+ index[49] = 15;
+ index[50] = 11;
+ index[51] = 10;
+ index[52] = 14;
+ index[53] = 15;
+}
diff --git a/src/animator/SkDisplayApply.cpp b/src/animator/SkDisplayApply.cpp
index b9e65f7..e456f26 100644
--- a/src/animator/SkDisplayApply.cpp
+++ b/src/animator/SkDisplayApply.cpp
@@ -294,7 +294,7 @@
if ((mode == kMode_immediate || mode == kMode_create) && scope == NULL)
return false; // !!! error?
bool enableMe = scope && (scope->hasEnable() || scope->isApply() || scope->isDrawable() == false);
- if (mode == kMode_immediate && enableMe || mode == kMode_create)
+ if ((mode == kMode_immediate && enableMe) || mode == kMode_create)
activate(maker); // for non-drawables like post, prime them here
if (mode == kMode_immediate && enableMe)
fActive->enable();
@@ -356,7 +356,7 @@
if (old < 0)
goto append;
else if (fContainsScope) {
- if ((*parentList)[old] != this || restore == true) {
+ if ((*parentList)[old] != this || restore) {
append:
if (parentGroup)
parentGroup->markCopySize(old);
@@ -479,7 +479,7 @@
} else {
SkScriptValue scriptValue;
bool success = target->getProperty(info->propertyIndex(), &scriptValue);
- SkASSERT(success = true);
+ SkASSERT(success == true);
last[0] = scriptValue.fOperand;
scriptValue.fOperand = fActive->fSaveRestore[activeIndex][0];
target->setProperty(info->propertyIndex(), scriptValue);
@@ -624,8 +624,8 @@
SkInterpolatorBase::Result interpResult = fActive->fInterpolators[inner]->timeToValues(
innerTime, values.get());
result |= (interpResult != SkInterpolatorBase::kFreezeEnd_Result);
- if ((transition != SkApply::kTransition_reverse && interpResult == SkInterpolatorBase::kFreezeEnd_Result ||
- transition == SkApply::kTransition_reverse && fLastTime == 0) && state.fUnpostedEndEvent) {
+ if (((transition != SkApply::kTransition_reverse && interpResult == SkInterpolatorBase::kFreezeEnd_Result) ||
+ (transition == SkApply::kTransition_reverse && fLastTime == 0)) && state.fUnpostedEndEvent) {
// SkDEBUGF(("interpolate: post on end\n"));
state.fUnpostedEndEvent = false;
maker.postOnEnd(animate, state.fBegin + state.fDuration);
diff --git a/src/animator/SkDisplayXMLParser.cpp b/src/animator/SkDisplayXMLParser.cpp
index a94b848..db6c838 100644
--- a/src/animator/SkDisplayXMLParser.cpp
+++ b/src/animator/SkDisplayXMLParser.cpp
@@ -304,8 +304,8 @@
}
return info;
next:
- if (type == SkType_Drawable || type == SkType_Displayable &&
- container->fDisplayable->isDrawable()) {
+ if (type == SkType_Drawable || (type == SkType_Displayable &&
+ container->fDisplayable->isDrawable())) {
rectNext:
if (fParents.count() > 1) {
Parent* parent = fParents.end() - 2;
diff --git a/src/animator/SkDump.cpp b/src/animator/SkDump.cpp
index eac956c..426a1e6 100644
--- a/src/animator/SkDump.cpp
+++ b/src/animator/SkDump.cpp
@@ -58,7 +58,7 @@
maker.fEvents.dump(maker);
if ((hasAttr |= (name.size() > 0)) == true)
maker.dump(name.c_str());
- if (displayList > 0 || displayList != 0 && hasAttr == false)
+ if (displayList > 0 || (displayList != 0 && hasAttr == false))
maker.fDisplayList.dump(&maker);
return true;
}
diff --git a/src/animator/SkScript.cpp b/src/animator/SkScript.cpp
index f81147d..96b73cd 100644
--- a/src/animator/SkScript.cpp
+++ b/src/animator/SkScript.cpp
@@ -305,8 +305,8 @@
} while (true);
signed char topPrecedence = gPrecedence[compare];
SkASSERT(topPrecedence != -1);
- if (topPrecedence > precedence || topPrecedence == precedence &&
- gOpAttributes[op].fLeftType == kNoType) {
+ if (topPrecedence > precedence || (topPrecedence == precedence &&
+ gOpAttributes[op].fLeftType == kNoType)) {
break;
}
if (processOp() == false)
@@ -1207,7 +1207,7 @@
} break;
case kElse:
flipSuppress:
- if (fSuppressStack.top().fElse == true)
+ if (fSuppressStack.top().fElse)
fSuppressStack.pop();
fSuppressStack.top().fElse = true;
fSuppressStack.top().fSuppress ^= true;
diff --git a/src/animator/SkScriptDecompile.cpp b/src/animator/SkScriptDecompile.cpp
index d582d33..98db1fb 100644
--- a/src/animator/SkScriptDecompile.cpp
+++ b/src/animator/SkScriptDecompile.cpp
@@ -114,7 +114,7 @@
// check to see that there are no missing or duplicate entries
void SkScriptEngine2::ValidateDecompileTable() {
SkScriptEngine2::TypeOp op = SkScriptEngine2::kNop;
- int index;
+ size_t index;
for (index = 0; index < gOpNamesSize; index++) {
SkASSERT(gOpNames[index].fOp == op);
op = (SkScriptEngine2::TypeOp) (op + 1);
@@ -132,9 +132,9 @@
SkASSERT(length > 0);
const unsigned char* opCode = start;
do {
- SkASSERT(opCode - start < length);
+ SkASSERT((size_t)(opCode - start) < length);
SkScriptEngine2::TypeOp op = (SkScriptEngine2::TypeOp) *opCode++;
- SkASSERT(op < gOpNamesSize);
+ SkASSERT((size_t)op < gOpNamesSize);
SkDebugf("%d: %s", opCode - start - 1, gOpNames[op].fName);
switch (op) {
case SkScriptEngine2::kCallback: {
@@ -184,7 +184,7 @@
SkOperand2::OpType type;
memcpy(&type, opCode, sizeof(type));
opCode += sizeof(type);
- int index = 0;
+ size_t index = 0;
if (type == 0)
SkDebugf(" type: %s", gOperandNames[index].fName);
else {
@@ -211,6 +211,8 @@
goto done;
case SkScriptEngine2::kNop:
SkASSERT(0);
+ default:
+ break;
}
SkDebugf("\n");
} while (true);
diff --git a/src/animator/SkScriptRuntime.cpp b/src/animator/SkScriptRuntime.cpp
index 6d8c208..1284198 100644
--- a/src/animator/SkScriptRuntime.cpp
+++ b/src/animator/SkScriptRuntime.cpp
@@ -304,6 +304,8 @@
goto done;
case SkScriptEngine2::kNop:
SkASSERT(0);
+ default:
+ break;
}
} while (true);
done:
diff --git a/src/animator/SkScriptTokenizer.cpp b/src/animator/SkScriptTokenizer.cpp
index efd1872..edcc2af 100644
--- a/src/animator/SkScriptTokenizer.cpp
+++ b/src/animator/SkScriptTokenizer.cpp
@@ -8,34 +8,34 @@
#include "SkOpArray.h"
const SkScriptEngine2::OperatorAttributes SkScriptEngine2::gOpAttributes[] = {
-{ SkOperand2::kNoType },
+{ SkOperand2::kNoType, SkOperand2::kNoType, kNoBias, kResultIsNotBoolean },
{ SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar | SkOperand2::kString),
- SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar | SkOperand2::kString), kTowardsString }, // kAdd
-{ SkOperand2::kS32, SkOperand2::kS32, kNoBias }, // kBitAnd
-{ SkOperand2::kNoType, SkOperand2::kS32, kNoBias }, // kBitNot
-{ SkOperand2::kS32, SkOperand2::kS32, kNoBias }, // kBitOr
+ SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar | SkOperand2::kString), kTowardsString, kResultIsNotBoolean }, // kAdd
+{ SkOperand2::kS32, SkOperand2::kS32, kNoBias, kResultIsNotBoolean }, // kBitAnd
+{ SkOperand2::kNoType, SkOperand2::kS32, kNoBias, kResultIsNotBoolean }, // kBitNot
+{ SkOperand2::kS32, SkOperand2::kS32, kNoBias, kResultIsNotBoolean }, // kBitOr
{ SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar),
- SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar), kNoBias }, // kDivide
+ SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar), kNoBias, kResultIsNotBoolean }, // kDivide
{ SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar | SkOperand2::kString),
SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar |SkOperand2:: kString), kTowardsNumber,
kResultIsBoolean }, // kEqual
-{ SkOperand2::kS32 }, // kFlipOps
+{ SkOperand2::kS32, SkOperand2::kNoType, kNoBias, kResultIsNotBoolean }, // kFlipOps
{ SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar | SkOperand2::kString),
SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar | SkOperand2::kString), kTowardsNumber,
kResultIsBoolean }, // kGreaterEqual
-{ SkOperand2::kNoType, SkOperand2::kS32, kNoBias }, // kLogicalAnd (really, ToBool)
-{ SkOperand2::kNoType, SkOperand2::kS32, kNoBias }, // kLogicalNot
-{ SkOperand2::kS32, SkOperand2::kS32, kNoBias }, // kLogicalOr
-{ SkOperand2::kNoType, SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar), kNoBias }, // kMinus
+{ SkOperand2::kNoType, SkOperand2::kS32, kNoBias, kResultIsNotBoolean }, // kLogicalAnd (really, ToBool)
+{ SkOperand2::kNoType, SkOperand2::kS32, kNoBias, kResultIsNotBoolean }, // kLogicalNot
+{ SkOperand2::kS32, SkOperand2::kS32, kNoBias, kResultIsNotBoolean }, // kLogicalOr
+{ SkOperand2::kNoType, SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar), kNoBias, kResultIsNotBoolean }, // kMinus
{ SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar),
- SkOperand2::OpType(SkOperand2::kS32 |SkOperand2:: kScalar), kNoBias }, // kModulo
+ SkOperand2::OpType(SkOperand2::kS32 |SkOperand2:: kScalar), kNoBias, kResultIsNotBoolean }, // kModulo
{ SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar),
- SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar), kNoBias }, // kMultiply
-{ SkOperand2::kS32, SkOperand2::kS32, kNoBias }, // kShiftLeft
-{ SkOperand2::kS32, SkOperand2::kS32, kNoBias }, // kShiftRight
+ SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar), kNoBias, kResultIsNotBoolean }, // kMultiply
+{ SkOperand2::kS32, SkOperand2::kS32, kNoBias, kResultIsNotBoolean }, // kShiftLeft
+{ SkOperand2::kS32, SkOperand2::kS32, kNoBias, kResultIsNotBoolean }, // kShiftRight
{ SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar),
- SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar), kNoBias }, // kSubtract
-{ SkOperand2::kS32, SkOperand2::kS32, kNoBias } // kXor
+ SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar), kNoBias, kResultIsNotBoolean }, // kSubtract
+{ SkOperand2::kS32, SkOperand2::kS32, kNoBias, kResultIsNotBoolean } // kXor
};
#define kBracketPrecedence 16
@@ -308,8 +308,8 @@
} while (true);
signed char topPrecedence = gPrecedence[compare];
SkASSERT(topPrecedence != -1);
- if (topPrecedence > precedence || topPrecedence == precedence &&
- gOpAttributes[op].fLeftType == SkOperand2::kNoType) {
+ if (topPrecedence > precedence || (topPrecedence == precedence &&
+ gOpAttributes[op].fLeftType == SkOperand2::kNoType)) {
break;
}
processOp();
@@ -1051,7 +1051,8 @@
fOpStack.pop(&op);
op = (Op) (op & ~kArtificialOp);
const OperatorAttributes* attributes = &gOpAttributes[op];
- SkScriptValue2 value1 = { 0 };
+ SkScriptValue2 value1;
+ memset(&value1, 0, sizeof(SkScriptValue2));
SkScriptValue2 value2;
fValueStack.pop(&value2);
value2.fIsWritten = SkScriptValue2::kUnwritten;
@@ -1230,7 +1231,7 @@
SkScalar SkScriptEngine2::IntToScalar(int32_t s32) {
SkScalar scalar;
- if (s32 == SK_NaN32)
+ if (s32 == (int32_t) SK_NaN32)
scalar = SK_ScalarNaN;
else if (SkAbs32(s32) == SK_MaxS32)
scalar = SkSign32(s32) * SK_ScalarMax;
@@ -1261,21 +1262,21 @@
#ifdef SK_DEBUG
-#define testInt(expression) { #expression, SkOperand2::kS32, expression }
+#define testInt(expression) { #expression, SkOperand2::kS32, expression, 0, NULL }
#ifdef SK_SCALAR_IS_FLOAT
-#define testScalar(expression) { #expression, SkOperand2::kScalar, 0, (float) expression }
-#define testRemainder(exp1, exp2) { #exp1 "%" #exp2, SkOperand2::kScalar, 0, fmodf(exp1, exp2) }
+#define testScalar(expression) { #expression, SkOperand2::kScalar, 0, (float) expression, NULL }
+#define testRemainder(exp1, exp2) { #exp1 "%" #exp2, SkOperand2::kScalar, 0, fmodf(exp1, exp2), NULL }
#else
#ifdef SK_CAN_USE_FLOAT
-#define testScalar(expression) { #expression, SkOperand2::kScalar, 0, (int) ((expression) * 65536.0f) }
-#define testRemainder(exp1, exp2) { #exp1 "%" #exp2, SkOperand2::kScalar, 0, (int) (fmod(exp1, exp2) * 65536.0f) }
+#define testScalar(expression) { #expression, SkOperand2::kScalar, 0, (int) ((expression) * 65536.0f), NULL }
+#define testRemainder(exp1, exp2) { #exp1 "%" #exp2, SkOperand2::kScalar, 0, (int) (fmod(exp1, exp2) * 65536.0f), NULL }
#endif
#endif
-#define testTrue(expression) { #expression, SkOperand2::kS32, 1 }
-#define testFalse(expression) { #expression, SkOperand2::kS32, 0 }
+#define testTrue(expression) { #expression, SkOperand2::kS32, 1, 0, NULL }
+#define testFalse(expression) { #expression, SkOperand2::kS32, 0, 0, NULL }
static const SkScriptNAnswer2 scriptTests[] = {
- testInt(1||0&&3),
+ testInt(1||(0&&3)),
#ifdef SK_CAN_USE_FLOAT
testScalar(- -5.5- -1.5),
testScalar(1.0+5),
@@ -1307,12 +1308,12 @@
{ "'123'+\"456\"", SkOperand2::kString, 0, 0, "123456" },
{ "123+\"456\"", SkOperand2::kString, 0, 0, "123456" },
{ "'123'+456", SkOperand2::kString, 0, 0, "123456" },
- { "'123'|\"456\"", SkOperand2::kS32, 123|456 },
- { "123|\"456\"", SkOperand2::kS32, 123|456 },
- { "'123'|456", SkOperand2::kS32, 123|456 },
- { "'2'<11", SkOperand2::kS32, 1 },
- { "2<'11'", SkOperand2::kS32, 1 },
- { "'2'<'11'", SkOperand2::kS32, 0 },
+ { "'123'|\"456\"", SkOperand2::kS32, 123|456, 0, NULL },
+ { "123|\"456\"", SkOperand2::kS32, 123|456, 0, NULL },
+ { "'123'|456", SkOperand2::kS32, 123|456, 0, NULL },
+ { "'2'<11", SkOperand2::kS32, 1, 0, NULL },
+ { "2<'11'", SkOperand2::kS32, 1, 0, NULL },
+ { "'2'<'11'", SkOperand2::kS32, 0, 0, NULL },
testInt(123),
testInt(-345),
testInt(+678),
@@ -1461,15 +1462,15 @@
// logic
testInt(1?2:3),
testInt(0?2:3),
- testInt(1&&2||3),
- testInt(1&&0||3),
- testInt(1&&0||0),
- testInt(1||0&&3),
- testInt(0||0&&3),
- testInt(0||1&&3),
+ testInt((1&&2)||3),
+ testInt((1&&0)||3),
+ testInt((1&&0)||0),
+ testInt(1||(0&&3)),
+ testInt(0||(0&&3)),
+ testInt(0||(1&&3)),
testInt(0&&1?2:3)
#ifdef SK_CAN_USE_FLOAT
- , { "123.5", SkOperand2::kScalar, 0, SkIntToScalar(123) + SK_Scalar1/2 }
+ , { "123.5", SkOperand2::kScalar, 0, SkIntToScalar(123) + SK_Scalar1/2, NULL }
#endif
};
diff --git a/src/core/SkAdvancedTypefaceMetrics.cpp b/src/core/SkAdvancedTypefaceMetrics.cpp
index 7e8a030..05d5c28 100644
--- a/src/core/SkAdvancedTypefaceMetrics.cpp
+++ b/src/core/SkAdvancedTypefaceMetrics.cpp
@@ -22,6 +22,10 @@
#include FT_FREETYPE_H
#endif
+#ifdef SK_BUILD_FOR_MAC
+#include <Carbon/Carbon.h>
+#endif
+
namespace skia_advanced_typeface_metrics_utils {
template <typename Data>
@@ -142,6 +146,11 @@
FT_Face face,
int num_glyphs,
bool (*getAdvance)(FT_Face face, int gId, int16_t* data));
+#elif defined(SK_BUILD_FOR_MAC)
+template SkAdvancedTypefaceMetrics::WidthRange* getAdvanceData(
+ CTFontRef ctFont,
+ int num_glyphs,
+ bool (*getAdvance)(CTFontRef ctFont, int gId, int16_t* data));
#endif
template void resetRange(
SkAdvancedTypefaceMetrics::WidthRange* range,
diff --git a/src/core/SkAlphaRuns.cpp b/src/core/SkAlphaRuns.cpp
index 4125b58..a5fc3c9 100644
--- a/src/core/SkAlphaRuns.cpp
+++ b/src/core/SkAlphaRuns.cpp
@@ -16,10 +16,14 @@
*/
#include "SkAntiRun.h"
+#include "SkUtils.h"
void SkAlphaRuns::reset(int width) {
SkASSERT(width > 0);
+#ifdef SK_DEBUG
+ sk_memset16((uint16_t*)fRuns, (uint16_t)(-42), width);
+#endif
fRuns[0] = SkToS16(width);
fRuns[width] = 0;
fAlpha[0] = 0;
@@ -75,13 +79,17 @@
}
}
-void SkAlphaRuns::add(int x, U8CPU startAlpha, int middleCount, U8CPU stopAlpha,
- U8CPU maxValue) {
+int SkAlphaRuns::add(int x, U8CPU startAlpha, int middleCount, U8CPU stopAlpha,
+ U8CPU maxValue, int offsetX) {
SkASSERT(middleCount >= 0);
SkASSERT(x >= 0 && x + (startAlpha != 0) + middleCount + (stopAlpha != 0) <= fWidth);
- int16_t* runs = fRuns;
- uint8_t* alpha = fAlpha;
+ SkASSERT(fRuns[offsetX] >= 0);
+
+ int16_t* runs = fRuns + offsetX;
+ uint8_t* alpha = fAlpha + offsetX;
+ uint8_t* lastAlpha = alpha;
+ x -= offsetX;
if (startAlpha) {
SkAlphaRuns::Break(runs, alpha, x, 1);
@@ -97,6 +105,7 @@
runs += x + 1;
alpha += x + 1;
x = 0;
+ lastAlpha += x; // we don't want the +1
SkDEBUGCODE(this->validate();)
}
@@ -114,13 +123,18 @@
middleCount -= n;
} while (middleCount > 0);
SkDEBUGCODE(this->validate();)
+ lastAlpha = alpha;
}
if (stopAlpha) {
SkAlphaRuns::Break(runs, alpha, x, 1);
- alpha[x] = SkToU8(alpha[x] + stopAlpha);
+ alpha += x;
+ alpha[0] = SkToU8(alpha[0] + stopAlpha);
SkDEBUGCODE(this->validate();)
+ lastAlpha = alpha;
}
+
+ return lastAlpha - fAlpha; // new offsetX
}
#ifdef SK_DEBUG
diff --git a/src/core/SkAntiRun.h b/src/core/SkAntiRun.h
index 89e5481..669e5d2 100644
--- a/src/core/SkAntiRun.h
+++ b/src/core/SkAntiRun.h
@@ -31,7 +31,15 @@
}
void reset(int width);
- void add(int x, U8CPU startAlpha, int middleCount, U8CPU stopAlpha, U8CPU maxValue);
+
+ /**
+ * Returns the offsetX value that should be passed on the next call,
+ * assuming we're on the same scanline. If the caller is switching
+ * scanlines, then offsetX should be 0 when this is called.
+ */
+ int add(int x, U8CPU startAlpha, int middleCount, U8CPU stopAlpha,
+ U8CPU maxValue, int offsetX);
+
SkDEBUGCODE(void assertValid(int y, int maxStep) const;)
SkDEBUGCODE(void dump() const;)
diff --git a/src/core/SkBitmapProcState_matrix.h b/src/core/SkBitmapProcState_matrix.h
index 9ae8b17..553bd89 100644
--- a/src/core/SkBitmapProcState_matrix.h
+++ b/src/core/SkBitmapProcState_matrix.h
@@ -1,3 +1,19 @@
+/*
+ Copyright 2011 Google Inc.
+
+ 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.
+ */
+
#define SCALE_NOFILTER_NAME MAKENAME(_nofilter_scale)
#define SCALE_FILTER_NAME MAKENAME(_filter_scale)
diff --git a/src/core/SkBitmapProcState_shaderproc.h b/src/core/SkBitmapProcState_shaderproc.h
index 15831b6..9a9e8c4 100644
--- a/src/core/SkBitmapProcState_shaderproc.h
+++ b/src/core/SkBitmapProcState_shaderproc.h
@@ -1,3 +1,20 @@
+/*
+ Copyright 2011 Google Inc.
+
+ 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.
+ */
+
+
#define SCALE_FILTER_NAME MAKENAME(_filter_DX_shaderproc)
static void SCALE_FILTER_NAME(const SkBitmapProcState& s, int x, int y,
diff --git a/src/core/SkClipStack.cpp b/src/core/SkClipStack.cpp
index 5ffa5b1..4ad4d41 100644
--- a/src/core/SkClipStack.cpp
+++ b/src/core/SkClipStack.cpp
@@ -188,6 +188,11 @@
((a.fPath == NULL && b.fPath == NULL) || *a.fPath == *b.fPath);
}
+bool operator!=(const SkClipStack::B2FIter::Clip& a,
+ const SkClipStack::B2FIter::Clip& b) {
+ return !(a == b);
+}
+
SkClipStack::B2FIter::B2FIter(const SkClipStack& stack) {
this->reset(stack);
}
diff --git a/src/core/SkDevice.cpp b/src/core/SkDevice.cpp
index 4a76936..aee5a5e 100644
--- a/src/core/SkDevice.cpp
+++ b/src/core/SkDevice.cpp
@@ -25,13 +25,13 @@
///////////////////////////////////////////////////////////////////////////////
-SkDevice::SkDevice(SkCanvas* canvas) : fCanvas(canvas), fMetaData(NULL), fMatrixClipObserver(NULL) {
+SkDevice::SkDevice(SkCanvas* canvas) : fCanvas(canvas), fMetaData(NULL) {
fOrigin.setZero();
fCachedDeviceFactory = NULL;
}
SkDevice::SkDevice(SkCanvas* canvas, const SkBitmap& bitmap, bool isForLayer)
- : fCanvas(canvas), fBitmap(bitmap), fMetaData(NULL), fMatrixClipObserver(NULL) {
+ : fCanvas(canvas), fBitmap(bitmap), fMetaData(NULL) {
fOrigin.setZero();
// auto-allocate if we're for offscreen drawing
if (isForLayer) {
@@ -48,7 +48,6 @@
SkDevice::~SkDevice() {
delete fMetaData;
SkSafeUnref(fCachedDeviceFactory);
- SkSafeUnref(fMatrixClipObserver);
}
SkDeviceFactory* SkDevice::onNewDeviceFactory() {
@@ -108,13 +107,6 @@
void SkDevice::setMatrixClip(const SkMatrix& matrix, const SkRegion& region,
const SkClipStack& clipStack) {
- if (fMatrixClipObserver) {
- fMatrixClipObserver->matrixClipChanged(matrix, region, clipStack);
- }
-}
-
-void SkDevice::setMatrixClipObserver(SkMatrixClipObserver* observer) {
- SkRefCnt_SafeAssign(fMatrixClipObserver, observer);
}
///////////////////////////////////////////////////////////////////////////////
diff --git a/src/core/SkMatrix.cpp b/src/core/SkMatrix.cpp
index 983c8d2..06bca1e 100644
--- a/src/core/SkMatrix.cpp
+++ b/src/core/SkMatrix.cpp
@@ -119,6 +119,21 @@
///////////////////////////////////////////////////////////////////////////////
+#ifdef SK_SCALAR_IS_FLOAT
+
+bool operator==(const SkMatrix& a, const SkMatrix& b) {
+ const SkScalar* SK_RESTRICT ma = a.fMat;
+ const SkScalar* SK_RESTRICT mb = b.fMat;
+
+ return ma[0] == mb[0] && ma[1] == mb[1] && ma[2] == mb[2] &&
+ ma[3] == mb[3] && ma[4] == mb[4] && ma[5] == mb[5] &&
+ ma[6] == mb[6] && ma[7] == mb[7] && ma[8] == mb[8];
+}
+
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+
void SkMatrix::setTranslate(SkScalar dx, SkScalar dy) {
if (SkScalarToCompareType(dx) || SkScalarToCompareType(dy)) {
fMat[kMTransX] = dx;
@@ -202,9 +217,27 @@
}
bool SkMatrix::preScale(SkScalar sx, SkScalar sy) {
+#ifdef SK_SCALAR_IS_FIXED
SkMatrix m;
m.setScale(sx, sy);
return this->preConcat(m);
+#else
+ // the assumption is that these multiplies are very cheap, and that
+ // a full concat and/or just computing the matrix type is more expensive.
+ // Also, the fixed-point case checks for overflow, but the float doesn't,
+ // so we can get away with these blind multiplies.
+
+ fMat[kMScaleX] = SkScalarMul(fMat[kMScaleX], sx);
+ fMat[kMSkewY] = SkScalarMul(fMat[kMSkewY], sx);
+ fMat[kMPersp0] = SkScalarMul(fMat[kMPersp0], sx);
+
+ fMat[kMSkewX] = SkScalarMul(fMat[kMSkewX], sy);
+ fMat[kMScaleY] = SkScalarMul(fMat[kMScaleY], sy);
+ fMat[kMPersp1] = SkScalarMul(fMat[kMPersp1], sy);
+
+ this->orTypeMask(kScale_Mask);
+ return true;
+#endif
}
bool SkMatrix::postScale(SkScalar sx, SkScalar sy, SkScalar px, SkScalar py) {
diff --git a/src/core/SkPaint.cpp b/src/core/SkPaint.cpp
index 14c0397..a607424 100644
--- a/src/core/SkPaint.cpp
+++ b/src/core/SkPaint.cpp
@@ -364,6 +364,16 @@
return glyph;
}
+const SkGlyph& SkPaint::getGlyphMetrics(uint16_t glyphId) {
+ SkGlyphCache* cache;
+ descriptorProc(NULL, DetachDescProc, &cache, true);
+
+ const SkGlyph& glyph = cache->getGlyphIDMetrics(glyphId);
+
+ SkGlyphCache::AttachCache(cache);
+ return glyph;
+}
+
const void* SkPaint::findImage(const SkGlyph& glyph) {
// See ::detachCache()
SkGlyphCache* cache;
@@ -1293,17 +1303,36 @@
}
rec->fMaskFormat = SkToU8(computeMaskFormat(paint));
- rec->fFlags = SkToU8(flags);
- rec->setHinting(computeHinting(paint));
+
+ if (SkMask::kLCD16_Format == rec->fMaskFormat) {
+ SkFontHost::LCDOrder order = SkFontHost::GetSubpixelOrder();
+ SkFontHost::LCDOrientation orient = SkFontHost::GetSubpixelOrientation();
+ if (SkFontHost::kNONE_LCDOrder == order) {
+ // eeek, can't support LCD
+ rec->fMaskFormat = SkMask::kA8_Format;
+ } else {
+ if (SkFontHost::kVertical_LCDOrientation == orient) {
+ flags |= SkScalerContext::kLCD_Vertical_Flag;
+ }
+ if (SkFontHost::kBGR_LCDOrder == order) {
+ flags |= SkScalerContext::kLCD_BGROrder_Flag;
+ }
+ }
+ }
+
if (paint.isEmbeddedBitmapText()) {
- rec->fFlags |= SkScalerContext::kEmbeddedBitmapText_Flag;
+ flags |= SkScalerContext::kEmbeddedBitmapText_Flag;
}
if (paint.isSubpixelText()) {
- rec->fFlags |= SkScalerContext::kSubpixelPositioning_Flag;
+ flags |= SkScalerContext::kSubpixelPositioning_Flag;
}
if (paint.isAutohinted()) {
- rec->fFlags |= SkScalerContext::kAutohinting_Flag;
+ flags |= SkScalerContext::kAutohinting_Flag;
}
+ rec->fFlags = SkToU16(flags);
+
+ // setHinting modifies fFlags, so do this last
+ rec->setHinting(computeHinting(paint));
/* Allow the fonthost to modify our rec before we use it as a key into the
cache. This way if we're asking for something that they will ignore,
diff --git a/src/core/SkPath.cpp b/src/core/SkPath.cpp
index 68eb35d..ca57237 100644
--- a/src/core/SkPath.cpp
+++ b/src/core/SkPath.cpp
@@ -254,6 +254,12 @@
//////////////////////////////////////////////////////////////////////////////
// Construction methods
+#define DIRTY_AFTER_EDIT \
+ do { \
+ fBoundsIsDirty = true; \
+ fConvexity = kUnknown_Convexity;\
+ } while (0)
+
void SkPath::incReserve(U16CPU inc) {
SkDEBUGCODE(this->validate();)
@@ -278,7 +284,7 @@
pt->set(x, y);
GEN_ID_INC;
- fBoundsIsDirty = true;
+ DIRTY_AFTER_EDIT;
}
void SkPath::rMoveTo(SkScalar x, SkScalar y) {
@@ -298,7 +304,7 @@
*fVerbs.append() = kLine_Verb;
GEN_ID_INC;
- fBoundsIsDirty = true;
+ DIRTY_AFTER_EDIT;
}
void SkPath::rLineTo(SkScalar x, SkScalar y) {
@@ -321,7 +327,7 @@
*fVerbs.append() = kQuad_Verb;
GEN_ID_INC;
- fBoundsIsDirty = true;
+ DIRTY_AFTER_EDIT;
}
void SkPath::rQuadTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2) {
@@ -345,7 +351,7 @@
*fVerbs.append() = kCubic_Verb;
GEN_ID_INC;
- fBoundsIsDirty = true;
+ DIRTY_AFTER_EDIT;
}
void SkPath::rCubicTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2,
@@ -1293,7 +1299,7 @@
buffer.read(fVerbs.begin(), fVerbs.count());
GEN_ID_INC;
- fBoundsIsDirty = true;
+ DIRTY_AFTER_EDIT;
SkDEBUGCODE(this->validate();)
}
@@ -1410,7 +1416,7 @@
// only valid for a single contour
struct Convexicator {
- Convexicator() : fPtCount(0), fConvexity(SkPath::kUnknown_Convexity) {
+ Convexicator() : fPtCount(0), fConvexity(SkPath::kConvex_Convexity) {
fSign = 0;
// warnings
fCurrPt.set(0, 0);
@@ -1472,9 +1478,7 @@
if (0 == fSign) {
fSign = sign;
} else if (sign) {
- if (fSign == sign) {
- fConvexity = SkPath::kConvex_Convexity;
- } else {
+ if (fSign != sign) {
fConvexity = SkPath::kConcave_Convexity;
}
}
diff --git a/src/core/SkPictureFlat.cpp b/src/core/SkPictureFlat.cpp
index 5c5ea0b..105df3c 100644
--- a/src/core/SkPictureFlat.cpp
+++ b/src/core/SkPictureFlat.cpp
@@ -28,9 +28,9 @@
}
SkFlatMatrix* SkFlatMatrix::Flatten(SkChunkAlloc* heap, const SkMatrix& matrix, int index) {
- int32_t size = sizeof(SkMatrix);
+ size_t size = matrix.flatten(NULL);
SkFlatMatrix* result = (SkFlatMatrix*) INHERITED::Alloc(heap, size, index);
- memcpy(&result->fMatrixData, &matrix, sizeof(SkMatrix));
+ matrix.flatten(&result->fMatrixData);
return result;
}
diff --git a/src/core/SkPictureFlat.h b/src/core/SkPictureFlat.h
index dae7b8a..697b399 100644
--- a/src/core/SkPictureFlat.h
+++ b/src/core/SkPictureFlat.h
@@ -147,7 +147,7 @@
static SkFlatMatrix* Flatten(SkChunkAlloc* heap, const SkMatrix& matrix, int index);
void unflatten(SkMatrix* result) const {
- memcpy(result, fMatrixData, sizeof(SkMatrix));
+ result->unflatten(fMatrixData);
}
#ifdef SK_DEBUG_DUMP
diff --git a/src/core/SkScan_AntiPath.cpp b/src/core/SkScan_AntiPath.cpp
index 5457b59..398f786 100644
--- a/src/core/SkScan_AntiPath.cpp
+++ b/src/core/SkScan_AntiPath.cpp
@@ -53,7 +53,7 @@
int fWidth, fLeft, fSuperLeft;
SkDEBUGCODE(int fCurrX;)
- SkDEBUGCODE(int fCurrY;)
+ int fCurrY;
};
BaseSuperBlitter::BaseSuperBlitter(SkBlitter* realBlitter, const SkIRect& ir,
@@ -69,7 +69,8 @@
fSuperLeft = left << SHIFT;
fWidth = right - left;
fCurrIY = -1;
- SkDEBUGCODE(fCurrX = -1; fCurrY = -1;)
+ fCurrY = -1;
+ SkDEBUGCODE(fCurrX = -1;)
}
class SuperBlitter : public BaseSuperBlitter {
@@ -89,6 +90,7 @@
private:
SkAlphaRuns fRuns;
+ int fOffsetX;
};
SuperBlitter::SuperBlitter(SkBlitter* realBlitter, const SkIRect& ir,
@@ -100,6 +102,8 @@
fRuns.fRuns = (int16_t*)sk_malloc_throw((width + 1 + (width + 2)/2) * sizeof(int16_t));
fRuns.fAlpha = (uint8_t*)(fRuns.fRuns + width + 1);
fRuns.reset(width);
+
+ fOffsetX = 0;
}
void SuperBlitter::flush() {
@@ -108,6 +112,7 @@
// SkDEBUGCODE(fRuns.dump();)
fRealBlitter->blitAntiH(fLeft, fCurrIY, fRuns.fAlpha, fRuns.fRuns);
fRuns.reset(fWidth);
+ fOffsetX = 0;
}
fCurrIY = -1;
SkDEBUGCODE(fCurrX = -1;)
@@ -134,11 +139,14 @@
}
#ifdef SK_DEBUG
- SkASSERT(y >= fCurrY);
SkASSERT(y != fCurrY || x >= fCurrX);
- fCurrY = y;
#endif
-
+ SkASSERT(y >= fCurrY);
+ if (fCurrY != y) {
+ fOffsetX = 0;
+ fCurrY = y;
+ }
+
if (iy != fCurrIY) { // new scanline
this->flush();
fCurrIY = iy;
@@ -148,36 +156,29 @@
// hit 256 as a summed max, but 255.
// int maxValue = (1 << (8 - SHIFT)) - (((y & MASK) + 1) >> SHIFT);
-#if 0
- SkAntiRun<SHIFT> arun;
- arun.set(x, x + width);
- fRuns.add(x >> SHIFT, arun.getStartAlpha(), arun.getMiddleCount(),
- arun.getStopAlpha(), maxValue);
-#else
- {
- int start = x;
- int stop = x + width;
+ int start = x;
+ int stop = x + width;
- SkASSERT(start >= 0 && stop > start);
- int fb = start & SUPER_Mask;
- int fe = stop & SUPER_Mask;
- int n = (stop >> SHIFT) - (start >> SHIFT) - 1;
+ SkASSERT(start >= 0 && stop > start);
+ int fb = start & SUPER_Mask;
+ int fe = stop & SUPER_Mask;
+ int n = (stop >> SHIFT) - (start >> SHIFT) - 1;
- if (n < 0) {
- fb = fe - fb;
- n = 0;
- fe = 0;
+ if (n < 0) {
+ fb = fe - fb;
+ n = 0;
+ fe = 0;
+ } else {
+ if (fb == 0) {
+ n += 1;
} else {
- if (fb == 0) {
- n += 1;
- } else {
- fb = (1 << SHIFT) - fb;
- }
+ fb = (1 << SHIFT) - fb;
}
- fRuns.add(x >> SHIFT, coverage_to_alpha(fb), n, coverage_to_alpha(fe),
- (1 << (8 - SHIFT)) - (((y & MASK) + 1) >> SHIFT));
}
-#endif
+
+ fOffsetX = fRuns.add(x >> SHIFT, coverage_to_alpha(fb), n, coverage_to_alpha(fe),
+ (1 << (8 - SHIFT)) - (((y & MASK) + 1) >> SHIFT),
+ fOffsetX);
#ifdef SK_DEBUG
fRuns.assertValid(y & MASK, (1 << (8 - SHIFT)));
diff --git a/src/core/SkScan_Antihair.cpp b/src/core/SkScan_Antihair.cpp
index b84c576..52f2a32 100644
--- a/src/core/SkScan_Antihair.cpp
+++ b/src/core/SkScan_Antihair.cpp
@@ -653,6 +653,8 @@
}
}
+#endif // SK_SCALAR_IS_FLOAT
+
///////////////////////////////////////////////////////////////////////////////
#define SkAlphaMulRound(a, b) SkMulDiv255Round(a, b)
@@ -811,7 +813,3 @@
innerstrokedot8(L, T, R, B, blitter);
}
}
-
-#endif
-
-
diff --git a/src/core/SkWriter32.cpp b/src/core/SkWriter32.cpp
index 141f751..9a60b8e 100644
--- a/src/core/SkWriter32.cpp
+++ b/src/core/SkWriter32.cpp
@@ -185,3 +185,72 @@
return true;
}
+///////////////////////////////////////////////////////////////////////////////
+
+#include "SkReader32.h"
+
+const char* SkReader32::readString(size_t* outLen) {
+ // we need to read at least 1-4 bytes
+ SkASSERT(this->isAvailable(4));
+ const uint8_t* base = (const uint8_t*)this->peek();
+ const uint8_t* ptr = base;
+
+ size_t len = *ptr++;
+ if (0xFF == len) {
+ len = (ptr[0] << 8) | ptr[1];
+ ptr += 2;
+ SkASSERT(len < 0xFFFF);
+ }
+
+ // skip what we've read, and 0..3 pad bytes
+ // add 1 for the terminating 0 that writeString() included
+ size_t alignedSize = SkAlign4(len + (ptr - base) + 1);
+ this->skip(alignedSize);
+
+ if (outLen) {
+ *outLen = len;
+ }
+ return (const char*)ptr;
+}
+
+void SkWriter32::writeString(const char str[], size_t len) {
+ if ((long)len < 0) {
+ SkASSERT(str);
+ len = strlen(str);
+ }
+ size_t lenBytes = 1;
+ if (len >= 0xFF) {
+ lenBytes = 3;
+ SkASSERT(len < 0xFFFF);
+ }
+ // add 1 since we also write a terminating 0
+ size_t alignedLen = SkAlign4(lenBytes + len + 1);
+ uint8_t* ptr = (uint8_t*)this->reserve(alignedLen);
+ if (1 == lenBytes) {
+ *ptr++ = SkToU8(len);
+ } else {
+ *ptr++ = 0xFF;
+ *ptr++ = SkToU8(len >> 8);
+ *ptr++ = len & 0xFF;
+ }
+ memcpy(ptr, str, len);
+ ptr[len] = 0;
+ // we may have left 0,1,2,3 bytes uninitialized, since we reserved align4
+ // number of bytes. That's ok, since the reader will know to skip those
+}
+
+size_t SkWriter32::WriteStringSize(const char* str, size_t len) {
+ if ((long)len < 0) {
+ SkASSERT(str);
+ len = strlen(str);
+ }
+ size_t lenBytes = 1;
+ if (len >= 0xFF) {
+ lenBytes = 3;
+ SkASSERT(len < 0xFFFF);
+ }
+ // add 1 since we also write a terminating 0
+ return SkAlign4(lenBytes + len + 1);
+}
+
+
diff --git a/src/effects/Sk2DPathEffect.cpp b/src/effects/Sk2DPathEffect.cpp
index 603deb7..1dfc24d 100644
--- a/src/effects/Sk2DPathEffect.cpp
+++ b/src/effects/Sk2DPathEffect.cpp
@@ -82,12 +82,19 @@
void Sk2DPathEffect::flatten(SkFlattenableWriteBuffer& buffer)
{
- buffer.writeMul4(&fMatrix, sizeof(fMatrix));
+ char storage[SkMatrix::kMaxFlattenSize];
+ uint32_t size = fMatrix.flatten(storage);
+ buffer.write32(size);
+ buffer.write(storage, size);
}
Sk2DPathEffect::Sk2DPathEffect(SkFlattenableReadBuffer& buffer)
{
- buffer.read(&fMatrix, sizeof(fMatrix));
+ char storage[SkMatrix::kMaxFlattenSize];
+ uint32_t size = buffer.readS32();
+ SkASSERT(size <= sizeof(storage));
+ buffer.read(storage, size);
+ fMatrix.unflatten(storage);
fMatrix.invert(&fInverse);
}
diff --git a/src/effects/SkLayerDrawLooper.cpp b/src/effects/SkLayerDrawLooper.cpp
index 3b21d49..5d0fdcf 100644
--- a/src/effects/SkLayerDrawLooper.cpp
+++ b/src/effects/SkLayerDrawLooper.cpp
@@ -189,6 +189,7 @@
Rec* rec = fRecs;
for (int i = 0; i < fCount; i++) {
+ buffer.writeInt(rec->fInfo.fFlagsMask);
buffer.writeInt(rec->fInfo.fPaintBits);
buffer.writeInt(rec->fInfo.fColorMode);
buffer.writeScalar(rec->fInfo.fOffset.fX);
@@ -208,6 +209,7 @@
for (int i = 0; i < count; i++) {
LayerInfo info;
+ info.fFlagsMask = buffer.readInt();
info.fPaintBits = buffer.readInt();
info.fColorMode = (SkXfermode::Mode)buffer.readInt();
info.fOffset.fX = buffer.readScalar();
diff --git a/src/effects/SkTransparentShader.cpp b/src/effects/SkTransparentShader.cpp
index c6caba3..6e68b5e 100644
--- a/src/effects/SkTransparentShader.cpp
+++ b/src/effects/SkTransparentShader.cpp
@@ -53,7 +53,10 @@
switch (fDevice->getConfig()) {
case SkBitmap::kARGB_8888_Config:
if (scale == 256) {
- memcpy(span, fDevice->getAddr32(x, y), count * sizeof(SkPMColor));
+ SkPMColor* src = fDevice->getAddr32(x, y);
+ if (src != span) {
+ memcpy(span, src, count * sizeof(SkPMColor));
+ }
} else {
const SkPMColor* src = fDevice->getAddr32(x, y);
for (int i = count - 1; i >= 0; --i) {
@@ -125,6 +128,9 @@
void SkTransparentShader::shadeSpan16(int x, int y, uint16_t span[], int count) {
SkASSERT(fDevice->getConfig() == SkBitmap::kRGB_565_Config);
- memcpy(span, fDevice->getAddr16(x, y), count << 1);
+ uint16_t* src = fDevice->getAddr16(x, y);
+ if (src != span) {
+ memcpy(span, src, count << 1);
+ }
}
diff --git a/src/gpu/GrPrintf_skia.cpp b/src/gpu/GrPrintf_skia.cpp
index fa8b6a7..6da8822 100644
--- a/src/gpu/GrPrintf_skia.cpp
+++ b/src/gpu/GrPrintf_skia.cpp
@@ -23,7 +23,7 @@
#include "SkTypes.h"
void GrPrintf(const char format[], ...) {
- const size_t MAX_BUFFER_SIZE = 512;
+ const size_t MAX_BUFFER_SIZE = 2048;
char buffer[MAX_BUFFER_SIZE + 1];
va_list args;
diff --git a/src/gpu/SkGpuDevice.cpp b/src/gpu/SkGpuDevice.cpp
index 5b4f529..7166a07 100644
--- a/src/gpu/SkGpuDevice.cpp
+++ b/src/gpu/SkGpuDevice.cpp
@@ -40,6 +40,13 @@
#define CHECK_SHOULD_DRAW(draw) this->prepareRenderTarget(draw)
#endif
+// we use the same texture slot on GrPaint for bitmaps and shaders
+// (since drawBitmap, drawSprite, and drawDevice ignore skia's shader)
+enum {
+ kBitmapTextureIdx = 0,
+ kShaderTextureIdx = 0
+};
+
///////////////////////////////////////////////////////////////////////////////
SkGpuDevice::SkAutoCachedTexture::
@@ -130,9 +137,9 @@
SkASSERT(NULL != fTexture->asRenderTarget());
}
#else
- const GrGpu::TextureDesc desc = {
- GrGpu::kRenderTarget_TextureFlag,
- GrGpu::kNone_AALevel,
+ const GrTextureDesc desc = {
+ kRenderTarget_GrTextureFlagBit,
+ kNone_GrAALevel,
this->width(),
this->height(),
SkGr::Bitmap2PixelConfig(bm)
@@ -316,7 +323,7 @@
bool SkGpuDevice::bindDeviceAsTexture(GrPaint* paint) {
if (NULL != fTexture) {
- paint->setTexture(fTexture);
+ paint->setTexture(kBitmapTextureIdx, fTexture);
return true;
}
return false;
@@ -342,7 +349,8 @@
bool SkGpuDevice::skPaint2GrPaintNoShader(const SkPaint& skPaint,
bool justAlpha,
- GrPaint* grPaint) {
+ GrPaint* grPaint,
+ bool constantColor) {
grPaint->fDither = skPaint.isDither();
grPaint->fAntiAlias = skPaint.isAntiAlias();
@@ -365,33 +373,44 @@
if (justAlpha) {
uint8_t alpha = skPaint.getAlpha();
grPaint->fColor = GrColorPackRGBA(alpha, alpha, alpha, alpha);
+ // justAlpha is currently set to true only if there is a texture,
+ // so constantColor should not also be true.
+ GrAssert(!constantColor);
} else {
grPaint->fColor = SkGr::SkColor2GrColor(skPaint.getColor());
- grPaint->setTexture(NULL);
+ grPaint->setTexture(kShaderTextureIdx, NULL);
}
SkColorFilter* colorFilter = skPaint.getColorFilter();
SkColor color;
SkXfermode::Mode filterMode;
if (colorFilter != NULL && colorFilter->asColorMode(&color, &filterMode)) {
- grPaint->fColorFilterColor = SkGr::SkColor2GrColor(color);
- grPaint->fColorFilterXfermode = filterMode;
- } else {
- grPaint->resetColorFilter();
+ if (!constantColor) {
+ grPaint->fColorFilterColor = SkGr::SkColor2GrColor(color);
+ grPaint->fColorFilterXfermode = filterMode;
+ return true;
+ }
+ SkColor filtered = colorFilter->filterColor(skPaint.getColor());
+ grPaint->fColor = SkGr::SkColor2GrColor(filtered);
}
+ grPaint->resetColorFilter();
return true;
}
bool SkGpuDevice::skPaint2GrPaintShader(const SkPaint& skPaint,
SkAutoCachedTexture* act,
const SkMatrix& ctm,
- GrPaint* grPaint) {
+ GrPaint* grPaint,
+ bool constantColor) {
SkASSERT(NULL != act);
SkShader* shader = skPaint.getShader();
if (NULL == shader) {
- return this->skPaint2GrPaintNoShader(skPaint, false, grPaint);
- } else if (!this->skPaint2GrPaintNoShader(skPaint, true, grPaint)) {
+ return this->skPaint2GrPaintNoShader(skPaint,
+ false,
+ grPaint,
+ constantColor);
+ } else if (!this->skPaint2GrPaintNoShader(skPaint, true, grPaint, false)) {
return false;
}
@@ -411,26 +430,27 @@
SkDebugf("shader->asABitmap() == kNone_BitmapType\n");
return false;
}
- grPaint->fSampler.setSampleMode(sampleMode);
+ GrSamplerState* sampler = grPaint->getTextureSampler(kShaderTextureIdx);
+ sampler->setSampleMode(sampleMode);
if (skPaint.isFilterBitmap()) {
- grPaint->fSampler.setFilter(GrSamplerState::kBilinear_Filter);
+ sampler->setFilter(GrSamplerState::kBilinear_Filter);
} else {
- grPaint->fSampler.setFilter(GrSamplerState::kNearest_Filter);
+ sampler->setFilter(GrSamplerState::kNearest_Filter);
}
- grPaint->fSampler.setWrapX(sk_tile_mode_to_grwrap(tileModes[0]));
- grPaint->fSampler.setWrapY(sk_tile_mode_to_grwrap(tileModes[1]));
+ sampler->setWrapX(sk_tile_mode_to_grwrap(tileModes[0]));
+ sampler->setWrapY(sk_tile_mode_to_grwrap(tileModes[1]));
if (GrSamplerState::kRadial2_SampleMode == sampleMode) {
- grPaint->fSampler.setRadial2Params(twoPointParams[0],
- twoPointParams[1],
- twoPointParams[2] < 0);
+ sampler->setRadial2Params(twoPointParams[0],
+ twoPointParams[1],
+ twoPointParams[2] < 0);
}
- GrTexture* texture = act->set(this, bitmap, grPaint->fSampler);
+ GrTexture* texture = act->set(this, bitmap, *sampler);
if (NULL == texture) {
SkDebugf("Couldn't convert bitmap to texture.\n");
return false;
}
- grPaint->setTexture(texture);
+ grPaint->setTexture(kShaderTextureIdx, texture);
// since our texture coords will be in local space, we wack the texture
// matrix to map them back into 0...1 before we load it
@@ -449,7 +469,7 @@
GrScalar s = GrFixedToScalar(GR_Fixed1 / bitmap.width());
matrix.postScale(s, s);
}
- grPaint->fSampler.setMatrix(matrix);
+ sampler->setMatrix(matrix);
return true;
}
@@ -595,7 +615,11 @@
GrPaint grPaint;
SkAutoCachedTexture act;
- if (!this->skPaint2GrPaintShader(paint, &act, *draw.fMatrix, &grPaint)) {
+ if (!this->skPaint2GrPaintShader(paint,
+ &act,
+ *draw.fMatrix,
+ &grPaint,
+ true)) {
return;
}
@@ -626,7 +650,11 @@
GrPaint grPaint;
SkAutoCachedTexture act;
- if (!this->skPaint2GrPaintShader(paint, &act, *draw.fMatrix, &grPaint)) {
+ if (!this->skPaint2GrPaintShader(paint,
+ &act,
+ *draw.fMatrix,
+ &grPaint,
+ true)) {
return;
}
@@ -665,6 +693,10 @@
if (paint.getMaskFilter()) {
usePath = true;
}
+ // until we aa rotated rects...
+ if (!usePath && paint.isAntiAlias() && !draw.fMatrix->rectStaysRect()) {
+ usePath = true;
+ }
if (usePath) {
SkPath path;
@@ -675,7 +707,11 @@
GrPaint grPaint;
SkAutoCachedTexture act;
- if (!this->skPaint2GrPaintShader(paint, &act, *draw.fMatrix, &grPaint)) {
+ if (!this->skPaint2GrPaintShader(paint,
+ &act,
+ *draw.fMatrix,
+ &grPaint,
+ true)) {
return;
}
fContext->drawRect(grPaint, rect, doStroke ? width : -1);
@@ -713,6 +749,9 @@
// we now have a device-aligned 8bit mask in dstM, ready to be drawn using
// the current clip (and identity matrix) and grpaint settings
+ // used to compute inverse view, if necessary
+ GrMatrix ivm = context->getMatrix();
+
GrAutoMatrix avm(context, GrMatrix::I());
const GrTextureDesc desc = {
@@ -729,18 +768,29 @@
return false;
}
- grp->setTexture(texture);
+ if (grp->hasTextureOrMask() && ivm.invert(&ivm)) {
+ grp->preConcatActiveSamplerMatrices(ivm);
+ }
+
+ static const int MASK_IDX = GrPaint::kMaxMasks - 1;
+ // we assume the last mask index is available for use
+ GrAssert(NULL == grp->getMask(MASK_IDX));
+ grp->setMask(MASK_IDX, texture);
texture->unref();
- grp->fSampler.setClampNoFilter();
+ grp->getMaskSampler(MASK_IDX)->setClampNoFilter();
GrRect d;
d.setLTRB(GrIntToScalar(dstM.fBounds.fLeft),
GrIntToScalar(dstM.fBounds.fTop),
GrIntToScalar(dstM.fBounds.fRight),
GrIntToScalar(dstM.fBounds.fBottom));
- GrRect s;
- s.setLTRB(0, 0, GR_Scalar1, GR_Scalar1);
- context->drawRectToRect(*grp, d, s);
+
+ GrMatrix m;
+ m.setTranslate(-dstM.fBounds.fLeft, -dstM.fBounds.fTop);
+ m.postIDiv(dstM.fBounds.width(), dstM.fBounds.height());
+ grp->getMaskSampler(MASK_IDX)->setMatrix(m);
+
+ context->drawRect(*grp, d);
return true;
}
@@ -751,7 +801,11 @@
GrPaint grPaint;
SkAutoCachedTexture act;
- if (!this->skPaint2GrPaintShader(paint, &act, *draw.fMatrix, &grPaint)) {
+ if (!this->skPaint2GrPaintShader(paint,
+ &act,
+ *draw.fMatrix,
+ &grPaint,
+ true)) {
return;
}
@@ -832,8 +886,7 @@
}
}
- SkGrPathIter iter(*pathPtr);
- fContext->drawPath(grPaint, &iter, fill);
+ fContext->drawPath(grPaint, *pathPtr, fill);
}
void SkGpuDevice::drawBitmap(const SkDraw& draw,
@@ -851,15 +904,15 @@
}
GrPaint grPaint;
- if (!this->skPaint2GrPaintNoShader(paint, true, &grPaint)) {
+ if (!this->skPaint2GrPaintNoShader(paint, true, &grPaint, false)) {
return;
}
+ GrSamplerState* sampler = grPaint.getTextureSampler(kBitmapTextureIdx);
if (paint.isFilterBitmap()) {
- grPaint.fSampler.setFilter(GrSamplerState::kBilinear_Filter);
+ sampler->setFilter(GrSamplerState::kBilinear_Filter);
} else {
- grPaint.fSampler.setFilter(GrSamplerState::kNearest_Filter);
+ sampler->setFilter(GrSamplerState::kNearest_Filter);
}
-
const int maxTextureDim = fContext->getMaxTextureDimension();
if (bitmap.getTexture() || (bitmap.width() <= maxTextureDim &&
@@ -941,27 +994,54 @@
return;
}
- grPaint->fSampler.setWrapX(GrSamplerState::kClamp_WrapMode);
- grPaint->fSampler.setWrapY(GrSamplerState::kClamp_WrapMode);
- grPaint->fSampler.setSampleMode(GrSamplerState::kNormal_SampleMode);
- grPaint->fSampler.setMatrix(GrMatrix::I());
+ GrSamplerState* sampler = grPaint->getTextureSampler(kBitmapTextureIdx);
+
+ sampler->setWrapX(GrSamplerState::kClamp_WrapMode);
+ sampler->setWrapY(GrSamplerState::kClamp_WrapMode);
+ sampler->setSampleMode(GrSamplerState::kNormal_SampleMode);
+ sampler->setMatrix(GrMatrix::I());
GrTexture* texture;
- SkAutoCachedTexture act(this, bitmap, grPaint->fSampler, &texture);
+ SkAutoCachedTexture act(this, bitmap, *sampler, &texture);
if (NULL == texture) {
return;
}
- grPaint->setTexture(texture);
+ grPaint->setTexture(kShaderTextureIdx, texture);
GrRect dstRect = SkRect::MakeWH(GrIntToScalar(srcRect.width()),
GrIntToScalar(srcRect.height()));
GrRect paintRect;
- paintRect.setLTRB(GrFixedToScalar((srcRect.fLeft << 16) / bitmap.width()),
- GrFixedToScalar((srcRect.fTop << 16) / bitmap.height()),
- GrFixedToScalar((srcRect.fRight << 16) / bitmap.width()),
+ paintRect.setLTRB(GrFixedToScalar((srcRect.fLeft << 16) / bitmap.width()),
+ GrFixedToScalar((srcRect.fTop << 16) / bitmap.height()),
+ GrFixedToScalar((srcRect.fRight << 16) / bitmap.width()),
GrFixedToScalar((srcRect.fBottom << 16) / bitmap.height()));
+ if (GrSamplerState::kNearest_Filter != sampler->getFilter() &&
+ (srcRect.width() < bitmap.width() ||
+ srcRect.height() < bitmap.height())) {
+ // If drawing a subrect of the bitmap and filtering is enabled,
+ // use a constrained texture domain to avoid color bleeding
+ GrScalar left, top, right, bottom;
+ if (srcRect.width() > 1) {
+ GrScalar border = GR_ScalarHalf / bitmap.width();
+ left = paintRect.left() + border;
+ right = paintRect.right() - border;
+ } else {
+ left = right = GrScalarHalf(paintRect.left() + paintRect.right());
+ }
+ if (srcRect.height() > 1) {
+ GrScalar border = GR_ScalarHalf / bitmap.height();
+ top = paintRect.top() + border;
+ bottom = paintRect.bottom() - border;
+ } else {
+ top = bottom = GrScalarHalf(paintRect.top() + paintRect.bottom());
+ }
+ GrRect textureDomain;
+ textureDomain.setLTRB(left, top, right, bottom);
+ sampler->setTextureDomain(textureDomain);
+ }
+
fContext->drawRectToRect(*grPaint, dstRect, paintRect, &m);
}
@@ -975,17 +1055,19 @@
}
GrPaint grPaint;
- if(!this->skPaint2GrPaintNoShader(paint, true, &grPaint)) {
+ if(!this->skPaint2GrPaintNoShader(paint, true, &grPaint, false)) {
return;
}
GrAutoMatrix avm(fContext, GrMatrix::I());
- GrTexture* texture;
- grPaint.fSampler.setClampNoFilter();
- SkAutoCachedTexture act(this, bitmap, grPaint.fSampler, &texture);
+ GrSamplerState* sampler = grPaint.getTextureSampler(kBitmapTextureIdx);
- grPaint.setTexture(texture);
+ GrTexture* texture;
+ sampler->setClampNoFilter();
+ SkAutoCachedTexture act(this, bitmap, *sampler, &texture);
+
+ grPaint.setTexture(kBitmapTextureIdx, texture);
fContext->drawRectToRect(grPaint,
GrRect::MakeXYWH(GrIntToScalar(left),
@@ -1001,11 +1083,11 @@
GrPaint grPaint;
if (!((SkGpuDevice*)dev)->bindDeviceAsTexture(&grPaint) ||
- !this->skPaint2GrPaintNoShader(paint, true, &grPaint)) {
+ !this->skPaint2GrPaintNoShader(paint, true, &grPaint, false)) {
return;
}
- SkASSERT(NULL != grPaint.getTexture());
+ SkASSERT(NULL != grPaint.getTexture(0));
const SkBitmap& bm = dev->accessBitmap(false);
int w = bm.width();
@@ -1013,7 +1095,7 @@
GrAutoMatrix avm(fContext, GrMatrix::I());
- grPaint.fSampler.setClampNoFilter();
+ grPaint.getTextureSampler(kBitmapTextureIdx)->setClampNoFilter();
fContext->drawRectToRect(grPaint,
GrRect::MakeXYWH(GrIntToScalar(x),
@@ -1044,13 +1126,17 @@
SkAutoCachedTexture act;
// we ignore the shader if texs is null.
if (NULL == texs) {
- if (!this->skPaint2GrPaintNoShader(paint, false, &grPaint)) {
+ if (!this->skPaint2GrPaintNoShader(paint,
+ false,
+ &grPaint,
+ NULL == colors)) {
return;
}
} else {
if (!this->skPaint2GrPaintShader(paint, &act,
*draw.fMatrix,
- &grPaint)) {
+ &grPaint,
+ NULL == colors)) {
return;
}
}
@@ -1167,7 +1253,11 @@
GrPaint grPaint;
SkAutoCachedTexture act;
- if (!this->skPaint2GrPaintShader(paint, &act, *draw.fMatrix, &grPaint)) {
+ if (!this->skPaint2GrPaintShader(paint,
+ &act,
+ *draw.fMatrix,
+ &grPaint,
+ true)) {
return;
}
GrTextContext context(fContext, grPaint, draw.fExtMatrix);
@@ -1191,7 +1281,11 @@
GrPaint grPaint;
SkAutoCachedTexture act;
- if (!this->skPaint2GrPaintShader(paint, &act, *draw.fMatrix, &grPaint)) {
+ if (!this->skPaint2GrPaintShader(paint,
+ &act,
+ *draw.fMatrix,
+ &grPaint,
+ true)) {
return;
}
diff --git a/src/gpu/SkGr.cpp b/src/gpu/SkGr.cpp
index f65cf1e..600c336 100644
--- a/src/gpu/SkGr.cpp
+++ b/src/gpu/SkGr.cpp
@@ -112,42 +112,6 @@
bitmap->rowBytes());
}
-////////////////////////////////////////////////////////////////////////////////
-
-
-GrPathCmd SkGrPathIter::next(GrPoint pts[]) {
- GrAssert(NULL != pts);
-#if SK_SCALAR_IS_GR_SCALAR
- return sk_path_verb_to_gr_path_command(fIter.next((SkPoint*)pts));
-#else
- Command cmd = sk_path_verb_to_gr_path_command(fIter.next(fPoints));
- int n = NumCommandPoints(cmd);
- for (int i = 0; i < n; ++i) {
- pts[i].fX = SkScalarToGrScalar(fPoints[i].fX);
- pts[i].fY = SkScalarToGrScalar(fPoints[i].fY);
- }
- return cmd;
-#endif
-}
-
-GrPathCmd SkGrPathIter::next() {
- return sk_path_verb_to_gr_path_command(fIter.next(NULL));
-}
-
-void SkGrPathIter::rewind() {
- fIter.setPath(*fPath, false);
-}
-
-GrConvexHint SkGrPathIter::convexHint() const {
- return fPath->isConvex() ? kConvex_ConvexHint :
- kNone_ConvexHint;
-}
-
-bool SkGrPathIter::getConservativeBounds(GrRect* rect) const {
- *rect = fPath->getBounds();
- return true;
-}
-
///////////////////////////////////////////////////////////////////////////////
void SkGrClipIterator::reset(const SkClipStack& clipStack) {
diff --git a/src/gpu/SkGrFontScaler.cpp b/src/gpu/SkGrFontScaler.cpp
index e58f035..eb260fb 100644
--- a/src/gpu/SkGrFontScaler.cpp
+++ b/src/gpu/SkGrFontScaler.cpp
@@ -163,13 +163,13 @@
return true;
}
+// we should just return const SkPath* (NULL means false)
bool SkGrFontScaler::getGlyphPath(uint16_t glyphID, GrPath* path) {
const SkGlyph& glyph = fStrike->getGlyphIDMetrics(glyphID);
const SkPath* skPath = fStrike->findPath(glyph);
if (skPath) {
- SkGrPathIter iter(*skPath);
- path->resetFromIter(&iter);
+ *path = *skPath;
return true;
}
return false;
diff --git a/src/images/SkImageDecoder_libwebp.cpp b/src/images/SkImageDecoder_libwebp.cpp
index 6fee747..4d79213 100644
--- a/src/images/SkImageDecoder_libwebp.cpp
+++ b/src/images/SkImageDecoder_libwebp.cpp
@@ -246,7 +246,7 @@
VP8kClip[(y) + (goff) - YUV_RANGE_MIN], \
VP8kClip[(y) + (boff) - YUV_RANGE_MIN])
-static void block_put(const VP8Io* io) {
+static int block_put(const VP8Io* io) {
WEBPImage *p = (WEBPImage*) io->opaque;
SkBitmap* decodedBitmap = p->image;
@@ -282,7 +282,7 @@
break;
default:
// Unsupported config
- return;
+ return 0;
}
for (j = 0; j < mb_h;) {
@@ -434,7 +434,7 @@
v += io->uv_stride;
}
- return;
+ return 1;
}
static int block_setup(VP8Io* io) {
diff --git a/src/pdf/SkPDFCatalog.cpp b/src/pdf/SkPDFCatalog.cpp
new file mode 100644
index 0000000..afa9d9a
--- /dev/null
+++ b/src/pdf/SkPDFCatalog.cpp
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2010 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.
+ */
+
+#include "SkPDFCatalog.h"
+#include "SkPDFTypes.h"
+#include "SkStream.h"
+#include "SkTypes.h"
+
+SkPDFCatalog::SkPDFCatalog()
+ : fFirstPageCount(0),
+ fNextObjNum(1),
+ fNextFirstPageObjNum(0) {
+}
+
+SkPDFCatalog::~SkPDFCatalog() {}
+
+SkPDFObject* SkPDFCatalog::addObject(SkPDFObject* obj, bool onFirstPage) {
+ SkASSERT(findObjectIndex(obj) == -1);
+ SkASSERT(fNextFirstPageObjNum == 0);
+ if (onFirstPage)
+ fFirstPageCount++;
+
+ struct Rec newEntry(obj, onFirstPage);
+ fCatalog.append(1, &newEntry);
+ return obj;
+}
+
+size_t SkPDFCatalog::setFileOffset(SkPDFObject* obj, size_t offset) {
+ int objIndex = assignObjNum(obj) - 1;
+ SkASSERT(fCatalog[objIndex].fObjNumAssigned);
+ SkASSERT(fCatalog[objIndex].fFileOffset == 0);
+ fCatalog[objIndex].fFileOffset = offset;
+
+ return obj->getOutputSize(this, true);
+}
+
+void SkPDFCatalog::emitObjectNumber(SkWStream* stream, SkPDFObject* obj) {
+ stream->writeDecAsText(assignObjNum(obj));
+ stream->writeText(" 0"); // Generation number is always 0.
+}
+
+size_t SkPDFCatalog::getObjectNumberSize(SkPDFObject* obj) {
+ SkDynamicMemoryWStream buffer;
+ emitObjectNumber(&buffer, obj);
+ return buffer.getOffset();
+}
+
+int SkPDFCatalog::findObjectIndex(SkPDFObject* obj) const {
+ for (int i = 0; i < fCatalog.count(); i++) {
+ if (fCatalog[i].fObject == obj)
+ return i;
+ }
+ return -1;
+}
+
+int SkPDFCatalog::assignObjNum(SkPDFObject* obj) {
+ int pos = findObjectIndex(obj);
+ // If this assert fails, it means you probably forgot to add an object
+ // to the resource list.
+ SkASSERT(pos >= 0);
+ uint32_t currentIndex = pos;
+ if (fCatalog[currentIndex].fObjNumAssigned)
+ return currentIndex + 1;
+
+ // First assignment.
+ if (fNextFirstPageObjNum == 0)
+ fNextFirstPageObjNum = fCatalog.count() - fFirstPageCount + 1;
+
+ uint32_t objNum;
+ if (fCatalog[currentIndex].fOnFirstPage) {
+ objNum = fNextFirstPageObjNum;
+ fNextFirstPageObjNum++;
+ } else {
+ objNum = fNextObjNum;
+ fNextObjNum++;
+ }
+
+ // When we assign an object an object number, we put it in that array
+ // offset (minus 1 because object number 0 is reserved).
+ SkASSERT(!fCatalog[objNum - 1].fObjNumAssigned);
+ if (objNum - 1 != currentIndex)
+ SkTSwap(fCatalog[objNum - 1], fCatalog[currentIndex]);
+ fCatalog[objNum - 1].fObjNumAssigned = true;
+ return objNum;
+}
+
+int32_t SkPDFCatalog::emitXrefTable(SkWStream* stream, bool firstPage) {
+ int first = -1;
+ int last = fCatalog.count() - 1;
+ // TODO(vandebo) support linearized format.
+ //int last = fCatalog.count() - fFirstPageCount - 1;
+ //if (firstPage) {
+ // first = fCatalog.count() - fFirstPageCount;
+ // last = fCatalog.count() - 1;
+ //}
+
+ stream->writeText("xref\n");
+ stream->writeDecAsText(first + 1);
+ stream->writeText(" ");
+ stream->writeDecAsText(last - first + 1);
+ stream->writeText("\n");
+
+ if (first == -1) {
+ stream->writeText("0000000000 65535 f \n");
+ first++;
+ }
+ for (int i = first; i <= last; i++) {
+ SkASSERT(fCatalog[i].fFileOffset > 0);
+ SkASSERT(fCatalog[i].fFileOffset <= 9999999999LL);
+ stream->writeBigDecAsText(fCatalog[i].fFileOffset, 10);
+ stream->writeText(" 00000 n \n");
+ }
+
+ return fCatalog.count() + 1;
+}
diff --git a/src/pdf/SkPDFDevice.cpp b/src/pdf/SkPDFDevice.cpp
new file mode 100644
index 0000000..c6ddf39
--- /dev/null
+++ b/src/pdf/SkPDFDevice.cpp
@@ -0,0 +1,1488 @@
+/*
+ * Copyright (C) 2011 Google Inc.
+ *
+ * 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.
+ */
+
+#include "SkPDFDevice.h"
+
+#include "SkColor.h"
+#include "SkClipStack.h"
+#include "SkDraw.h"
+#include "SkGlyphCache.h"
+#include "SkPaint.h"
+#include "SkPath.h"
+#include "SkPDFFont.h"
+#include "SkPDFFormXObject.h"
+#include "SkPDFGraphicState.h"
+#include "SkPDFImage.h"
+#include "SkPDFShader.h"
+#include "SkPDFStream.h"
+#include "SkPDFTypes.h"
+#include "SkPDFUtils.h"
+#include "SkRect.h"
+#include "SkString.h"
+#include "SkTextFormatParams.h"
+#include "SkTypeface.h"
+#include "SkTypes.h"
+
+// Utility functions
+
+static void emit_pdf_color(SkColor color, SkWStream* result) {
+ SkASSERT(SkColorGetA(color) == 0xFF); // We handle alpha elsewhere.
+ SkScalar colorMax = SkIntToScalar(0xFF);
+ SkPDFScalar::Append(
+ SkScalarDiv(SkIntToScalar(SkColorGetR(color)), colorMax), result);
+ result->writeText(" ");
+ SkPDFScalar::Append(
+ SkScalarDiv(SkIntToScalar(SkColorGetG(color)), colorMax), result);
+ result->writeText(" ");
+ SkPDFScalar::Append(
+ SkScalarDiv(SkIntToScalar(SkColorGetB(color)), colorMax), result);
+ result->writeText(" ");
+}
+
+static SkPaint calculate_text_paint(const SkPaint& paint) {
+ SkPaint result = paint;
+ if (result.isFakeBoldText()) {
+ SkScalar fakeBoldScale = SkScalarInterpFunc(result.getTextSize(),
+ kStdFakeBoldInterpKeys,
+ kStdFakeBoldInterpValues,
+ kStdFakeBoldInterpLength);
+ SkScalar width = SkScalarMul(result.getTextSize(), fakeBoldScale);
+ if (result.getStyle() == SkPaint::kFill_Style)
+ result.setStyle(SkPaint::kStrokeAndFill_Style);
+ else
+ width += result.getStrokeWidth();
+ result.setStrokeWidth(width);
+ }
+ return result;
+}
+
+// Stolen from measure_text in SkDraw.cpp and then tweaked.
+static void align_text(SkDrawCacheProc glyphCacheProc, const SkPaint& paint,
+ const uint16_t* glyphs, size_t len, SkScalar* x,
+ SkScalar* y, SkScalar* width) {
+ if (paint.getTextAlign() == SkPaint::kLeft_Align && width == NULL)
+ return;
+
+ SkMatrix ident;
+ ident.reset();
+ SkAutoGlyphCache autoCache(paint, &ident);
+ SkGlyphCache* cache = autoCache.getCache();
+
+ const char* start = (char*)glyphs;
+ const char* stop = (char*)(glyphs + len);
+ SkFixed xAdv = 0, yAdv = 0;
+
+ // TODO(vandebo) This probably needs to take kerning into account.
+ while (start < stop) {
+ const SkGlyph& glyph = glyphCacheProc(cache, &start, 0, 0);
+ xAdv += glyph.fAdvanceX;
+ yAdv += glyph.fAdvanceY;
+ };
+ if (width)
+ *width = SkFixedToScalar(xAdv);
+ if (paint.getTextAlign() == SkPaint::kLeft_Align)
+ return;
+
+ SkScalar xAdj = SkFixedToScalar(xAdv);
+ SkScalar yAdj = SkFixedToScalar(yAdv);
+ if (paint.getTextAlign() == SkPaint::kCenter_Align) {
+ xAdj = SkScalarHalf(xAdj);
+ yAdj = SkScalarHalf(yAdj);
+ }
+ *x = *x - xAdj;
+ *y = *y - yAdj;
+}
+
+static void set_text_transform(SkScalar x, SkScalar y, SkScalar textSkewX,
+ SkWStream* content) {
+ // Flip the text about the x-axis to account for origin swap and include
+ // the passed parameters.
+ content->writeText("1 0 ");
+ SkPDFScalar::Append(0 - textSkewX, content);
+ content->writeText(" -1 ");
+ SkPDFScalar::Append(x, content);
+ content->writeText(" ");
+ SkPDFScalar::Append(y, content);
+ content->writeText(" Tm\n");
+}
+
+// It is important to not confuse GraphicStateEntry with SkPDFGraphicState, the
+// later being our representation of an object in the PDF file.
+struct GraphicStateEntry {
+ GraphicStateEntry();
+
+ // Compare the fields we care about when setting up a new content entry.
+ bool compareInitialState(const GraphicStateEntry& b);
+
+ SkMatrix fMatrix;
+ // We can't do set operations on Paths, though PDF natively supports
+ // intersect. If the clip stack does anything other than intersect,
+ // we have to fall back to the region. Treat fClipStack as authoritative.
+ // See http://code.google.com/p/skia/issues/detail?id=221
+ SkClipStack fClipStack;
+ SkRegion fClipRegion;
+
+ // When emitting the content entry, we will ensure the graphic state
+ // is set to these values first.
+ SkColor fColor;
+ SkScalar fTextScaleX; // Zero means we don't care what the value is.
+ SkPaint::Style fTextFill; // Only if TextScaleX is non-zero.
+ int fShaderIndex;
+ int fGraphicStateIndex;
+
+ // We may change the font (i.e. for Type1 support) within a
+ // ContentEntry. This is the one currently in effect, or NULL if none.
+ SkPDFFont* fFont;
+ // In PDF, text size has no default value. It is only valid if fFont is
+ // not NULL.
+ SkScalar fTextSize;
+};
+
+GraphicStateEntry::GraphicStateEntry() : fColor(SK_ColorBLACK),
+ fTextScaleX(SK_Scalar1),
+ fTextFill(SkPaint::kFill_Style),
+ fShaderIndex(-1),
+ fGraphicStateIndex(-1),
+ fFont(NULL),
+ fTextSize(SK_ScalarNaN) {
+ fMatrix.reset();
+}
+
+bool GraphicStateEntry::compareInitialState(const GraphicStateEntry& b) {
+ return fColor == b.fColor &&
+ fShaderIndex == b.fShaderIndex &&
+ fGraphicStateIndex == b.fGraphicStateIndex &&
+ fMatrix == b.fMatrix &&
+ fClipStack == b.fClipStack &&
+ (fTextScaleX == 0 ||
+ b.fTextScaleX == 0 ||
+ (fTextScaleX == b.fTextScaleX && fTextFill == b.fTextFill));
+}
+
+class GraphicStackState {
+public:
+ GraphicStackState(const SkClipStack& existingClipStack,
+ const SkRegion& existingClipRegion,
+ SkWStream* contentStream)
+ : fStackDepth(0),
+ fContentStream(contentStream) {
+ fEntries[0].fClipStack = existingClipStack;
+ fEntries[0].fClipRegion = existingClipRegion;
+ }
+
+ void updateClip(const SkClipStack& clipStack, const SkRegion& clipRegion,
+ const SkIPoint& translation);
+ void updateMatrix(const SkMatrix& matrix);
+ void updateDrawingState(const GraphicStateEntry& state);
+
+ void drainStack();
+
+private:
+ void push();
+ void pop();
+ GraphicStateEntry* currentEntry() { return &fEntries[fStackDepth]; }
+
+ // Conservative limit on save depth, see impl. notes in PDF 1.4 spec.
+ static const int kMaxStackDepth = 12;
+ GraphicStateEntry fEntries[kMaxStackDepth + 1];
+ int fStackDepth;
+ SkWStream* fContentStream;
+};
+
+void GraphicStackState::drainStack() {
+ while (fStackDepth) {
+ pop();
+ }
+}
+
+void GraphicStackState::push() {
+ SkASSERT(fStackDepth < kMaxStackDepth);
+ fContentStream->writeText("q\n");
+ fStackDepth++;
+ fEntries[fStackDepth] = fEntries[fStackDepth - 1];
+}
+
+void GraphicStackState::pop() {
+ SkASSERT(fStackDepth > 0);
+ fContentStream->writeText("Q\n");
+ fStackDepth--;
+}
+
+// This function initializes iter to be an interator on the "stack" argument
+// and then skips over the leading entries as specified in prefix. It requires
+// and asserts that "prefix" will be a prefix to "stack."
+static void skip_clip_stack_prefix(const SkClipStack& prefix,
+ const SkClipStack& stack,
+ SkClipStack::B2FIter* iter) {
+ SkClipStack::B2FIter prefixIter(prefix);
+ iter->reset(stack);
+
+ const SkClipStack::B2FIter::Clip* prefixEntry;
+ const SkClipStack::B2FIter::Clip* iterEntry;
+
+ int count = 0;
+ for (prefixEntry = prefixIter.next(); prefixEntry;
+ prefixEntry = prefixIter.next(), count++) {
+ iterEntry = iter->next();
+ SkASSERT(iterEntry);
+ // Because of SkClipStack does internal intersection, the last clip
+ // entry may differ.
+ if(*prefixEntry != *iterEntry) {
+ SkASSERT(prefixEntry->fOp == SkRegion::kIntersect_Op);
+ SkASSERT(iterEntry->fOp == SkRegion::kIntersect_Op);
+ SkASSERT((iterEntry->fRect == NULL) ==
+ (prefixEntry->fRect == NULL));
+ SkASSERT((iterEntry->fPath == NULL) ==
+ (prefixEntry->fPath == NULL));
+ // We need to back up the iterator by one but don't have that
+ // function, so reset and go forward by one less.
+ iter->reset(stack);
+ for (int i = 0; i < count; i++) {
+ iter->next();
+ }
+ prefixEntry = prefixIter.next();
+ break;
+ }
+ }
+
+ SkASSERT(prefixEntry == NULL);
+}
+
+static void emit_clip(SkPath* clipPath, SkRect* clipRect,
+ SkWStream* contentStream) {
+ SkASSERT(clipPath || clipRect);
+
+ SkPath::FillType clipFill;
+ if (clipPath) {
+ SkPDFUtils::EmitPath(*clipPath, contentStream);
+ clipFill = clipPath->getFillType();
+ } else if (clipRect) {
+ SkPDFUtils::AppendRectangle(*clipRect, contentStream);
+ clipFill = SkPath::kWinding_FillType;
+ }
+
+ NOT_IMPLEMENTED(clipFill == SkPath::kInverseEvenOdd_FillType, false);
+ NOT_IMPLEMENTED(clipFill == SkPath::kInverseWinding_FillType, false);
+ if (clipFill == SkPath::kEvenOdd_FillType) {
+ contentStream->writeText("W* n\n");
+ } else {
+ contentStream->writeText("W n\n");
+ }
+}
+
+// TODO(vandebo) Take advantage of SkClipStack::getSaveCount(), the PDF
+// graphic state stack, and the fact that we can know all the clips used
+// on the page to optimize this.
+void GraphicStackState::updateClip(const SkClipStack& clipStack,
+ const SkRegion& clipRegion,
+ const SkIPoint& translation) {
+ if (clipStack == currentEntry()->fClipStack) {
+ return;
+ }
+
+ while (fStackDepth > 0) {
+ pop();
+ if (clipStack == currentEntry()->fClipStack) {
+ return;
+ }
+ }
+ push();
+
+ // gsState->initialEntry()->fClipStack/Region specifies the clip that has
+ // already been applied. (If this is a top level device, then it specifies
+ // a clip to the content area. If this is a layer, then it specifies
+ // the clip in effect when the layer was created.) There's no need to
+ // reapply that clip; SKCanvas's SkDrawIter will draw anything outside the
+ // initial clip on the parent layer. (This means there's a bug if the user
+ // expands the clip and then uses any xfer mode that uses dst:
+ // http://code.google.com/p/skia/issues/detail?id=228 )
+ SkClipStack::B2FIter iter;
+ skip_clip_stack_prefix(fEntries[0].fClipStack, clipStack, &iter);
+
+ // If the clip stack does anything other than intersect or if it uses
+ // an inverse fill type, we have to fall back to the clip region.
+ bool needRegion = false;
+ const SkClipStack::B2FIter::Clip* clipEntry;
+ for (clipEntry = iter.next(); clipEntry; clipEntry = iter.next()) {
+ if (clipEntry->fOp != SkRegion::kIntersect_Op ||
+ (clipEntry->fPath && clipEntry->fPath->isInverseFillType())) {
+ needRegion = true;
+ break;
+ }
+ }
+
+ if (needRegion) {
+ SkPath clipPath;
+ SkAssertResult(clipRegion.getBoundaryPath(&clipPath));
+ emit_clip(&clipPath, NULL, fContentStream);
+ } else {
+ skip_clip_stack_prefix(fEntries[0].fClipStack, clipStack, &iter);
+ SkMatrix transform;
+ transform.setTranslate(translation.fX, translation.fY);
+ const SkClipStack::B2FIter::Clip* clipEntry;
+ for (clipEntry = iter.next(); clipEntry; clipEntry = iter.next()) {
+ SkASSERT(clipEntry->fOp == SkRegion::kIntersect_Op);
+ if (clipEntry->fRect) {
+ SkRect translatedClip;
+ transform.mapRect(&translatedClip, *clipEntry->fRect);
+ emit_clip(NULL, &translatedClip, fContentStream);
+ } else if (clipEntry->fPath) {
+ SkPath translatedPath;
+ clipEntry->fPath->transform(transform, &translatedPath);
+ emit_clip(&translatedPath, NULL, fContentStream);
+ } else {
+ SkASSERT(false);
+ }
+ }
+ }
+ currentEntry()->fClipStack = clipStack;
+ currentEntry()->fClipRegion = clipRegion;
+}
+
+void GraphicStackState::updateMatrix(const SkMatrix& matrix) {
+ if (matrix == currentEntry()->fMatrix) {
+ return;
+ }
+
+ if (currentEntry()->fMatrix.getType() != SkMatrix::kIdentity_Mask) {
+ SkASSERT(fStackDepth > 0);
+ SkASSERT(fEntries[fStackDepth].fClipStack ==
+ fEntries[fStackDepth -1].fClipStack);
+ pop();
+
+ SkASSERT(currentEntry()->fMatrix.getType() == SkMatrix::kIdentity_Mask);
+ }
+ if (matrix.getType() == SkMatrix::kIdentity_Mask) {
+ return;
+ }
+
+ push();
+ SkPDFUtils::AppendTransform(matrix, fContentStream);
+ currentEntry()->fMatrix = matrix;
+}
+
+void GraphicStackState::updateDrawingState(const GraphicStateEntry& state) {
+ // PDF treats a shader as a color, so we only set one or the other.
+ if (state.fShaderIndex >= 0) {
+ if (state.fShaderIndex != currentEntry()->fShaderIndex) {
+ fContentStream->writeText("/Pattern CS /Pattern cs /P");
+ fContentStream->writeDecAsText(state.fShaderIndex);
+ fContentStream->writeText(" SCN /P");
+ fContentStream->writeDecAsText(state.fShaderIndex);
+ fContentStream->writeText(" scn\n");
+ currentEntry()->fShaderIndex = state.fShaderIndex;
+ }
+ } else {
+ if (state.fColor != currentEntry()->fColor ||
+ currentEntry()->fShaderIndex >= 0) {
+ emit_pdf_color(state.fColor, fContentStream);
+ fContentStream->writeText("RG ");
+ emit_pdf_color(state.fColor, fContentStream);
+ fContentStream->writeText("rg\n");
+ currentEntry()->fColor = state.fColor;
+ currentEntry()->fShaderIndex = -1;
+ }
+ }
+
+ if (state.fGraphicStateIndex != currentEntry()->fGraphicStateIndex) {
+ SkPDFUtils::ApplyGraphicState(state.fGraphicStateIndex, fContentStream);
+ currentEntry()->fGraphicStateIndex = state.fGraphicStateIndex;
+ }
+
+ if (state.fTextScaleX) {
+ if (state.fTextScaleX != currentEntry()->fTextScaleX) {
+ SkScalar pdfScale = SkScalarMul(state.fTextScaleX,
+ SkIntToScalar(100));
+ SkPDFScalar::Append(pdfScale, fContentStream);
+ fContentStream->writeText(" Tz\n");
+ currentEntry()->fTextScaleX = state.fTextScaleX;
+ }
+ if (state.fTextFill != currentEntry()->fTextFill) {
+ SK_COMPILE_ASSERT(SkPaint::kFill_Style == 0, enum_must_match_value);
+ SK_COMPILE_ASSERT(SkPaint::kStroke_Style == 1,
+ enum_must_match_value);
+ SK_COMPILE_ASSERT(SkPaint::kStrokeAndFill_Style == 2,
+ enum_must_match_value);
+ fContentStream->writeDecAsText(state.fTextFill);
+ fContentStream->writeText(" Tr\n");
+ currentEntry()->fTextFill = state.fTextFill;
+ }
+ }
+}
+
+struct ContentEntry {
+ GraphicStateEntry fState;
+ SkDynamicMemoryWStream fContent;
+ SkTScopedPtr<ContentEntry> fNext;
+};
+
+// A helper class to automatically finish a ContentEntry at the end of a
+// drawing method and maintain the state needed between set up and finish.
+class ScopedContentEntry {
+public:
+ ScopedContentEntry(SkPDFDevice* device, const SkDraw& draw,
+ const SkPaint& paint, bool hasText = false)
+ : fDevice(device),
+ fContentEntry(NULL),
+ fXfermode(SkXfermode::kSrcOver_Mode) {
+ init(draw.fClipStack, *draw.fClip, *draw.fMatrix, paint, hasText);
+ }
+ ScopedContentEntry(SkPDFDevice* device, const SkClipStack* clipStack,
+ const SkRegion& clipRegion, const SkMatrix& matrix,
+ const SkPaint& paint, bool hasText = false)
+ : fDevice(device),
+ fContentEntry(NULL),
+ fXfermode(SkXfermode::kSrcOver_Mode) {
+ init(clipStack, clipRegion, matrix, paint, hasText);
+ }
+
+ ~ScopedContentEntry() {
+ if (fContentEntry) {
+ fDevice->finishContentEntry(fXfermode, fDstFormXObject.get());
+ }
+ }
+
+ ContentEntry* entry() { return fContentEntry; }
+private:
+ SkPDFDevice* fDevice;
+ ContentEntry* fContentEntry;
+ SkXfermode::Mode fXfermode;
+ SkRefPtr<SkPDFFormXObject> fDstFormXObject;
+
+ void init(const SkClipStack* clipStack, const SkRegion& clipRegion,
+ const SkMatrix& matrix, const SkPaint& paint, bool hasText) {
+ if (paint.getXfermode()) {
+ paint.getXfermode()->asMode(&fXfermode);
+ }
+ fContentEntry = fDevice->setUpContentEntry(clipStack, clipRegion,
+ matrix, paint, hasText,
+ &fDstFormXObject);
+ }
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+SkDevice* SkPDFDeviceFactory::newDevice(SkCanvas* c, SkBitmap::Config config,
+ int width, int height, bool isOpaque,
+ bool isForLayer) {
+ SkMatrix initialTransform;
+ initialTransform.reset();
+ SkISize size = SkISize::Make(width, height);
+ if (isForLayer) {
+ return SkNEW_ARGS(SkPDFDevice, (size, c->getTotalClipStack(),
+ c->getTotalClip()));
+ } else {
+ return SkNEW_ARGS(SkPDFDevice, (size, size, initialTransform));
+ }
+}
+
+static inline SkBitmap makeContentBitmap(const SkISize& contentSize,
+ const SkMatrix* initialTransform) {
+ SkBitmap bitmap;
+ if (initialTransform) {
+ // Compute the size of the drawing area.
+ SkVector drawingSize;
+ SkMatrix inverse;
+ drawingSize.set(contentSize.fWidth, contentSize.fHeight);
+ initialTransform->invert(&inverse);
+ inverse.mapVectors(&drawingSize, 1);
+ SkISize size = SkSize::Make(drawingSize.fX, drawingSize.fY).toRound();
+ bitmap.setConfig(SkBitmap::kNo_Config, abs(size.fWidth),
+ abs(size.fHeight));
+ } else {
+ bitmap.setConfig(SkBitmap::kNo_Config, abs(contentSize.fWidth),
+ abs(contentSize.fHeight));
+ }
+
+ return bitmap;
+}
+
+SkPDFDevice::SkPDFDevice(const SkISize& pageSize, const SkISize& contentSize,
+ const SkMatrix& initialTransform)
+ : SkDevice(NULL, makeContentBitmap(contentSize, &initialTransform), false),
+ fPageSize(pageSize),
+ fContentSize(contentSize),
+ fLastContentEntry(NULL) {
+ // Skia generally uses the top left as the origin but PDF natively has the
+ // origin at the bottom left. This matrix corrects for that. But that only
+ // needs to be done once, we don't do it when layering.
+ fInitialTransform.setTranslate(0, pageSize.fHeight);
+ fInitialTransform.preScale(1, -1);
+ fInitialTransform.preConcat(initialTransform);
+
+ SkIRect existingClip = SkIRect::MakeWH(this->width(), this->height());
+ fExistingClipStack.clipDevRect(existingClip);
+ fExistingClipRegion.setRect(existingClip);
+
+ this->init();
+}
+
+SkPDFDevice::SkPDFDevice(const SkISize& layerSize,
+ const SkClipStack& existingClipStack,
+ const SkRegion& existingClipRegion)
+ : SkDevice(NULL, makeContentBitmap(layerSize, NULL), false),
+ fPageSize(layerSize),
+ fContentSize(layerSize),
+ fExistingClipStack(existingClipStack),
+ fExistingClipRegion(existingClipRegion),
+ fLastContentEntry(NULL) {
+ fInitialTransform.reset();
+ this->init();
+}
+
+SkPDFDevice::~SkPDFDevice() {
+ this->cleanUp();
+}
+
+void SkPDFDevice::init() {
+ fResourceDict = NULL;
+ fContentEntries.reset();
+ fLastContentEntry = NULL;
+}
+
+SkDeviceFactory* SkPDFDevice::onNewDeviceFactory() {
+ return SkNEW(SkPDFDeviceFactory);
+}
+
+void SkPDFDevice::cleanUp() {
+ fGraphicStateResources.unrefAll();
+ fXObjectResources.unrefAll();
+ fFontResources.unrefAll();
+ fShaderResources.unrefAll();
+}
+
+void SkPDFDevice::clear(SkColor color) {
+ this->cleanUp();
+ this->init();
+
+ SkPaint paint;
+ paint.setColor(color);
+ paint.setStyle(SkPaint::kFill_Style);
+ SkMatrix identity;
+ identity.reset();
+ ScopedContentEntry content(this, &fExistingClipStack, fExistingClipRegion,
+ identity, paint);
+ internalDrawPaint(paint, content.entry());
+}
+
+void SkPDFDevice::drawPaint(const SkDraw& d, const SkPaint& paint) {
+ SkPaint newPaint = paint;
+ newPaint.setStyle(SkPaint::kFill_Style);
+ ScopedContentEntry content(this, d, newPaint);
+ internalDrawPaint(newPaint, content.entry());
+}
+
+void SkPDFDevice::internalDrawPaint(const SkPaint& paint,
+ ContentEntry* contentEntry) {
+ if (!contentEntry) {
+ return;
+ }
+ SkRect bbox = SkRect::MakeWH(SkIntToScalar(this->width()),
+ SkIntToScalar(this->height()));
+ SkMatrix totalTransform = fInitialTransform;
+ totalTransform.preConcat(contentEntry->fState.fMatrix);
+ SkMatrix inverse;
+ inverse.reset();
+ totalTransform.invert(&inverse);
+ inverse.mapRect(&bbox);
+
+ SkPDFUtils::AppendRectangle(bbox, &contentEntry->fContent);
+ SkPDFUtils::PaintPath(paint.getStyle(), SkPath::kWinding_FillType,
+ &contentEntry->fContent);
+}
+
+void SkPDFDevice::drawPoints(const SkDraw& d, SkCanvas::PointMode mode,
+ size_t count, const SkPoint* points,
+ const SkPaint& passedPaint) {
+ if (count == 0) {
+ return;
+ }
+
+ // SkDraw::drawPoints converts to multiple calls to fDevice->drawPath.
+ // We only use this when there's a path effect because of the overhead
+ // of multiple calls to setUpContentEntry it causes.
+ if (passedPaint.getPathEffect()) {
+ if (d.fClip->isEmpty()) {
+ return;
+ }
+ SkDraw pointDraw(d);
+ pointDraw.fDevice = this;
+ pointDraw.drawPoints(mode, count, points, passedPaint, true);
+ return;
+ }
+
+ const SkPaint* paint = &passedPaint;
+ SkPaint modifiedPaint;
+
+ if (mode == SkCanvas::kPoints_PointMode &&
+ paint->getStrokeCap() != SkPaint::kRound_Cap) {
+ modifiedPaint = *paint;
+ paint = &modifiedPaint;
+ if (paint->getStrokeWidth()) {
+ // PDF won't draw a single point with square/butt caps because the
+ // orientation is ambiguous. Draw a rectangle instead.
+ modifiedPaint.setStyle(SkPaint::kFill_Style);
+ SkScalar strokeWidth = paint->getStrokeWidth();
+ SkScalar halfStroke = SkScalarHalf(strokeWidth);
+ for (size_t i = 0; i < count; i++) {
+ SkRect r = SkRect::MakeXYWH(points[i].fX, points[i].fY, 0, 0);
+ r.inset(-halfStroke, -halfStroke);
+ drawRect(d, r, modifiedPaint);
+ }
+ return;
+ } else {
+ modifiedPaint.setStrokeCap(SkPaint::kRound_Cap);
+ }
+ }
+
+ ScopedContentEntry content(this, d, *paint);
+ if (!content.entry()) {
+ return;
+ }
+
+ switch (mode) {
+ case SkCanvas::kPolygon_PointMode:
+ SkPDFUtils::MoveTo(points[0].fX, points[0].fY,
+ &content.entry()->fContent);
+ for (size_t i = 1; i < count; i++) {
+ SkPDFUtils::AppendLine(points[i].fX, points[i].fY,
+ &content.entry()->fContent);
+ }
+ SkPDFUtils::StrokePath(&content.entry()->fContent);
+ break;
+ case SkCanvas::kLines_PointMode:
+ for (size_t i = 0; i < count/2; i++) {
+ SkPDFUtils::MoveTo(points[i * 2].fX, points[i * 2].fY,
+ &content.entry()->fContent);
+ SkPDFUtils::AppendLine(points[i * 2 + 1].fX,
+ points[i * 2 + 1].fY,
+ &content.entry()->fContent);
+ SkPDFUtils::StrokePath(&content.entry()->fContent);
+ }
+ break;
+ case SkCanvas::kPoints_PointMode:
+ SkASSERT(paint->getStrokeCap() == SkPaint::kRound_Cap);
+ for (size_t i = 0; i < count; i++) {
+ SkPDFUtils::MoveTo(points[i].fX, points[i].fY,
+ &content.entry()->fContent);
+ SkPDFUtils::ClosePath(&content.entry()->fContent);
+ SkPDFUtils::StrokePath(&content.entry()->fContent);
+ }
+ break;
+ default:
+ SkASSERT(false);
+ }
+}
+
+void SkPDFDevice::drawRect(const SkDraw& d, const SkRect& r,
+ const SkPaint& paint) {
+ if (paint.getPathEffect()) {
+ if (d.fClip->isEmpty()) {
+ return;
+ }
+ SkPath path;
+ path.addRect(r);
+ drawPath(d, path, paint, NULL, true);
+ return;
+ }
+
+ ScopedContentEntry content(this, d, paint);
+ if (!content.entry()) {
+ return;
+ }
+ SkPDFUtils::AppendRectangle(r, &content.entry()->fContent);
+ SkPDFUtils::PaintPath(paint.getStyle(), SkPath::kWinding_FillType,
+ &content.entry()->fContent);
+}
+
+void SkPDFDevice::drawPath(const SkDraw& d, const SkPath& origPath,
+ const SkPaint& paint, const SkMatrix* prePathMatrix,
+ bool pathIsMutable) {
+ SkPath modifiedPath;
+ SkPath* pathPtr = const_cast<SkPath*>(&origPath);
+
+ SkMatrix matrix = *d.fMatrix;
+ if (prePathMatrix) {
+ if (paint.getPathEffect() || paint.getStyle() != SkPaint::kFill_Style) {
+ if (!pathIsMutable) {
+ pathPtr = &modifiedPath;
+ pathIsMutable = true;
+ }
+ origPath.transform(*prePathMatrix, pathPtr);
+ } else {
+ if (!matrix.preConcat(*prePathMatrix)) {
+ return;
+ }
+ }
+ }
+
+ if (paint.getPathEffect()) {
+ if (d.fClip->isEmpty()) {
+ return;
+ }
+ if (!pathIsMutable) {
+ pathPtr = &modifiedPath;
+ pathIsMutable = true;
+ }
+ bool fill = paint.getFillPath(origPath, pathPtr);
+
+ SkPaint noEffectPaint(paint);
+ noEffectPaint.setPathEffect(NULL);
+ if (fill) {
+ noEffectPaint.setStyle(SkPaint::kFill_Style);
+ } else {
+ noEffectPaint.setStyle(SkPaint::kStroke_Style);
+ noEffectPaint.setStrokeWidth(0);
+ }
+ drawPath(d, *pathPtr, noEffectPaint, NULL, true);
+ return;
+ }
+
+ ScopedContentEntry content(this, d, paint);
+ if (!content.entry()) {
+ return;
+ }
+ SkPDFUtils::EmitPath(*pathPtr, &content.entry()->fContent);
+ SkPDFUtils::PaintPath(paint.getStyle(), pathPtr->getFillType(),
+ &content.entry()->fContent);
+}
+
+void SkPDFDevice::drawBitmap(const SkDraw& d, const SkBitmap& bitmap,
+ const SkIRect* srcRect, const SkMatrix& matrix,
+ const SkPaint& paint) {
+ if (d.fClip->isEmpty()) {
+ return;
+ }
+
+ SkMatrix transform = matrix;
+ transform.postConcat(*d.fMatrix);
+ internalDrawBitmap(transform, d.fClipStack, *d.fClip, bitmap, srcRect,
+ paint);
+}
+
+void SkPDFDevice::drawSprite(const SkDraw& d, const SkBitmap& bitmap,
+ int x, int y, const SkPaint& paint) {
+ if (d.fClip->isEmpty()) {
+ return;
+ }
+
+ SkMatrix matrix;
+ matrix.setTranslate(SkIntToScalar(x), SkIntToScalar(y));
+ internalDrawBitmap(matrix, d.fClipStack, *d.fClip, bitmap, NULL, paint);
+}
+
+void SkPDFDevice::drawText(const SkDraw& d, const void* text, size_t len,
+ SkScalar x, SkScalar y, const SkPaint& paint) {
+ SkPaint textPaint = calculate_text_paint(paint);
+ ScopedContentEntry content(this, d, textPaint, true);
+ if (!content.entry()) {
+ return;
+ }
+
+ // We want the text in glyph id encoding and a writable buffer, so we end
+ // up making a copy either way.
+ size_t numGlyphs = paint.textToGlyphs(text, len, NULL);
+ uint16_t* glyphIDs =
+ (uint16_t*)sk_malloc_flags(numGlyphs * 2,
+ SK_MALLOC_TEMP | SK_MALLOC_THROW);
+ SkAutoFree autoFreeGlyphIDs(glyphIDs);
+ if (paint.getTextEncoding() != SkPaint::kGlyphID_TextEncoding) {
+ paint.textToGlyphs(text, len, glyphIDs);
+ textPaint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
+ } else {
+ SkASSERT((len & 1) == 0);
+ SkASSERT(len / 2 == numGlyphs);
+ memcpy(glyphIDs, text, len);
+ }
+
+ SkScalar width;
+ SkScalar* widthPtr = NULL;
+ if (textPaint.isUnderlineText() || textPaint.isStrikeThruText())
+ widthPtr = &width;
+
+ SkDrawCacheProc glyphCacheProc = textPaint.getDrawCacheProc();
+ align_text(glyphCacheProc, textPaint, glyphIDs, numGlyphs, &x, &y,
+ widthPtr);
+ content.entry()->fContent.writeText("BT\n");
+ set_text_transform(x, y, textPaint.getTextSkewX(),
+ &content.entry()->fContent);
+ size_t consumedGlyphCount = 0;
+ while (numGlyphs > consumedGlyphCount) {
+ updateFont(textPaint, glyphIDs[consumedGlyphCount], content.entry());
+ SkPDFFont* font = content.entry()->fState.fFont;
+ size_t availableGlyphs =
+ font->glyphsToPDFFontEncoding(glyphIDs + consumedGlyphCount,
+ numGlyphs - consumedGlyphCount);
+ SkString encodedString =
+ SkPDFString::formatString(glyphIDs + consumedGlyphCount,
+ availableGlyphs, font->multiByteGlyphs());
+ content.entry()->fContent.writeText(encodedString.c_str());
+ consumedGlyphCount += availableGlyphs;
+ content.entry()->fContent.writeText(" Tj\n");
+ }
+ content.entry()->fContent.writeText("ET\n");
+
+ // Draw underline and/or strikethrough if the paint has them.
+ // drawPosText() and drawTextOnPath() don't draw underline or strikethrough
+ // because the raster versions don't. Use paint instead of textPaint
+ // because we may have changed strokeWidth to do fakeBold text.
+ if (paint.isUnderlineText() || paint.isStrikeThruText()) {
+ SkScalar textSize = paint.getTextSize();
+ SkScalar height = SkScalarMul(textSize, kStdUnderline_Thickness);
+
+ if (paint.isUnderlineText()) {
+ SkScalar top = SkScalarMulAdd(textSize, kStdUnderline_Offset, y);
+ SkRect r = SkRect::MakeXYWH(x, top - height, width, height);
+ drawRect(d, r, paint);
+ }
+ if (paint.isStrikeThruText()) {
+ SkScalar top = SkScalarMulAdd(textSize, kStdStrikeThru_Offset, y);
+ SkRect r = SkRect::MakeXYWH(x, top - height, width, height);
+ drawRect(d, r, paint);
+ }
+ }
+}
+
+void SkPDFDevice::drawPosText(const SkDraw& d, const void* text, size_t len,
+ const SkScalar pos[], SkScalar constY,
+ int scalarsPerPos, const SkPaint& paint) {
+ SkASSERT(1 == scalarsPerPos || 2 == scalarsPerPos);
+ SkPaint textPaint = calculate_text_paint(paint);
+ ScopedContentEntry content(this, d, textPaint, true);
+ if (!content.entry()) {
+ return;
+ }
+
+ // Make sure we have a glyph id encoding.
+ SkAutoFree glyphStorage;
+ uint16_t* glyphIDs;
+ size_t numGlyphs;
+ if (paint.getTextEncoding() != SkPaint::kGlyphID_TextEncoding) {
+ numGlyphs = paint.textToGlyphs(text, len, NULL);
+ glyphIDs = (uint16_t*)sk_malloc_flags(numGlyphs * 2,
+ SK_MALLOC_TEMP | SK_MALLOC_THROW);
+ glyphStorage.set(glyphIDs);
+ paint.textToGlyphs(text, len, glyphIDs);
+ textPaint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
+ } else {
+ SkASSERT((len & 1) == 0);
+ numGlyphs = len / 2;
+ glyphIDs = (uint16_t*)text;
+ }
+
+ SkDrawCacheProc glyphCacheProc = textPaint.getDrawCacheProc();
+ content.entry()->fContent.writeText("BT\n");
+ updateFont(textPaint, glyphIDs[0], content.entry());
+ for (size_t i = 0; i < numGlyphs; i++) {
+ SkPDFFont* font = content.entry()->fState.fFont;
+ uint16_t encodedValue = glyphIDs[i];
+ if (font->glyphsToPDFFontEncoding(&encodedValue, 1) != 1) {
+ updateFont(textPaint, glyphIDs[i], content.entry());
+ i--;
+ continue;
+ }
+ SkScalar x = pos[i * scalarsPerPos];
+ SkScalar y = scalarsPerPos == 1 ? constY : pos[i * scalarsPerPos + 1];
+ align_text(glyphCacheProc, textPaint, glyphIDs + i, 1, &x, &y, NULL);
+ set_text_transform(x, y, textPaint.getTextSkewX(),
+ &content.entry()->fContent);
+ SkString encodedString =
+ SkPDFString::formatString(&encodedValue, 1,
+ font->multiByteGlyphs());
+ content.entry()->fContent.writeText(encodedString.c_str());
+ content.entry()->fContent.writeText(" Tj\n");
+ }
+ content.entry()->fContent.writeText("ET\n");
+}
+
+void SkPDFDevice::drawTextOnPath(const SkDraw& d, const void* text, size_t len,
+ const SkPath& path, const SkMatrix* matrix,
+ const SkPaint& paint) {
+ if (d.fClip->isEmpty()) {
+ return;
+ }
+ NOT_IMPLEMENTED("drawTextOnPath", true);
+}
+
+void SkPDFDevice::drawVertices(const SkDraw& d, SkCanvas::VertexMode,
+ int vertexCount, const SkPoint verts[],
+ const SkPoint texs[], const SkColor colors[],
+ SkXfermode* xmode, const uint16_t indices[],
+ int indexCount, const SkPaint& paint) {
+ if (d.fClip->isEmpty()) {
+ return;
+ }
+ NOT_IMPLEMENTED("drawVerticies", true);
+}
+
+void SkPDFDevice::drawDevice(const SkDraw& d, SkDevice* device, int x, int y,
+ const SkPaint& paint) {
+ if ((device->getDeviceCapabilities() & kVector_Capability) == 0) {
+ // If we somehow get a raster device, do what our parent would do.
+ SkDevice::drawDevice(d, device, x, y, paint);
+ return;
+ }
+
+ // Assume that a vector capable device means that it's a PDF Device.
+ SkPDFDevice* pdfDevice = static_cast<SkPDFDevice*>(device);
+ if (pdfDevice->isContentEmpty()) {
+ return;
+ }
+
+ SkMatrix matrix;
+ matrix.setTranslate(SkIntToScalar(x), SkIntToScalar(y));
+ ScopedContentEntry content(this, d.fClipStack, *d.fClip, matrix, paint);
+ if (!content.entry()) {
+ return;
+ }
+
+ SkPDFFormXObject* xobject = new SkPDFFormXObject(pdfDevice);
+ fXObjectResources.push(xobject); // Transfer reference.
+ SkPDFUtils::DrawFormXObject(fXObjectResources.count() - 1,
+ &content.entry()->fContent);
+}
+
+const SkRefPtr<SkPDFDict>& SkPDFDevice::getResourceDict() {
+ if (fResourceDict.get() == NULL) {
+ fResourceDict = new SkPDFDict;
+ fResourceDict->unref(); // SkRefPtr and new both took a reference.
+
+ if (fGraphicStateResources.count()) {
+ SkRefPtr<SkPDFDict> extGState = new SkPDFDict();
+ extGState->unref(); // SkRefPtr and new both took a reference.
+ for (int i = 0; i < fGraphicStateResources.count(); i++) {
+ SkString nameString("G");
+ nameString.appendS32(i);
+ extGState->insert(
+ nameString.c_str(),
+ new SkPDFObjRef(fGraphicStateResources[i]))->unref();
+ }
+ fResourceDict->insert("ExtGState", extGState.get());
+ }
+
+ if (fXObjectResources.count()) {
+ SkRefPtr<SkPDFDict> xObjects = new SkPDFDict();
+ xObjects->unref(); // SkRefPtr and new both took a reference.
+ for (int i = 0; i < fXObjectResources.count(); i++) {
+ SkString nameString("X");
+ nameString.appendS32(i);
+ xObjects->insert(
+ nameString.c_str(),
+ new SkPDFObjRef(fXObjectResources[i]))->unref();
+ }
+ fResourceDict->insert("XObject", xObjects.get());
+ }
+
+ if (fFontResources.count()) {
+ SkRefPtr<SkPDFDict> fonts = new SkPDFDict();
+ fonts->unref(); // SkRefPtr and new both took a reference.
+ for (int i = 0; i < fFontResources.count(); i++) {
+ SkString nameString("F");
+ nameString.appendS32(i);
+ fonts->insert(nameString.c_str(),
+ new SkPDFObjRef(fFontResources[i]))->unref();
+ }
+ fResourceDict->insert("Font", fonts.get());
+ }
+
+ if (fShaderResources.count()) {
+ SkRefPtr<SkPDFDict> patterns = new SkPDFDict();
+ patterns->unref(); // SkRefPtr and new both took a reference.
+ for (int i = 0; i < fShaderResources.count(); i++) {
+ SkString nameString("P");
+ nameString.appendS32(i);
+ patterns->insert(nameString.c_str(),
+ new SkPDFObjRef(fShaderResources[i]))->unref();
+ }
+ fResourceDict->insert("Pattern", patterns.get());
+ }
+
+ // For compatibility, add all proc sets (only used for output to PS
+ // devices).
+ const char procs[][7] = {"PDF", "Text", "ImageB", "ImageC", "ImageI"};
+ SkRefPtr<SkPDFArray> procSets = new SkPDFArray();
+ procSets->unref(); // SkRefPtr and new both took a reference.
+ procSets->reserve(SK_ARRAY_COUNT(procs));
+ for (size_t i = 0; i < SK_ARRAY_COUNT(procs); i++)
+ procSets->append(new SkPDFName(procs[i]))->unref();
+ fResourceDict->insert("ProcSet", procSets.get());
+ }
+ return fResourceDict;
+}
+
+void SkPDFDevice::getResources(SkTDArray<SkPDFObject*>* resourceList) const {
+ resourceList->setReserve(resourceList->count() +
+ fGraphicStateResources.count() +
+ fXObjectResources.count() +
+ fFontResources.count() +
+ fShaderResources.count());
+ for (int i = 0; i < fGraphicStateResources.count(); i++) {
+ resourceList->push(fGraphicStateResources[i]);
+ fGraphicStateResources[i]->ref();
+ fGraphicStateResources[i]->getResources(resourceList);
+ }
+ for (int i = 0; i < fXObjectResources.count(); i++) {
+ resourceList->push(fXObjectResources[i]);
+ fXObjectResources[i]->ref();
+ fXObjectResources[i]->getResources(resourceList);
+ }
+ for (int i = 0; i < fFontResources.count(); i++) {
+ resourceList->push(fFontResources[i]);
+ fFontResources[i]->ref();
+ fFontResources[i]->getResources(resourceList);
+ }
+ for (int i = 0; i < fShaderResources.count(); i++) {
+ resourceList->push(fShaderResources[i]);
+ fShaderResources[i]->ref();
+ fShaderResources[i]->getResources(resourceList);
+ }
+}
+
+const SkTDArray<SkPDFFont*>& SkPDFDevice::getFontResources() const {
+ return fFontResources;
+}
+
+SkRefPtr<SkPDFArray> SkPDFDevice::getMediaBox() const {
+ SkRefPtr<SkPDFInt> zero = new SkPDFInt(0);
+ zero->unref(); // SkRefPtr and new both took a reference.
+
+ SkRefPtr<SkPDFArray> mediaBox = new SkPDFArray();
+ mediaBox->unref(); // SkRefPtr and new both took a reference.
+ mediaBox->reserve(4);
+ mediaBox->append(zero.get());
+ mediaBox->append(zero.get());
+ mediaBox->append(new SkPDFInt(fPageSize.fWidth))->unref();
+ mediaBox->append(new SkPDFInt(fPageSize.fHeight))->unref();
+ return mediaBox;
+}
+
+SkStream* SkPDFDevice::content() const {
+ SkDynamicMemoryWStream data;
+ if (fInitialTransform.getType() != SkMatrix::kIdentity_Mask) {
+ SkPDFUtils::AppendTransform(fInitialTransform, &data);
+ }
+ // If the content area is the entire page, then we don't need to clip
+ // the content area (PDF area clips to the page size). Otherwise,
+ // we have to clip to the content area; we've already applied the
+ // initial transform, so just clip to the device size.
+ if (fPageSize != fContentSize) {
+ SkRect r = SkRect::MakeWH(this->width(), this->height());
+ emit_clip(NULL, &r, &data);
+ }
+
+ GraphicStackState gsState(fExistingClipStack, fExistingClipRegion, &data);
+ for (ContentEntry* entry = fContentEntries.get();
+ entry != NULL;
+ entry = entry->fNext.get()) {
+ SkIPoint translation = this->getOrigin();
+ translation.negate();
+ gsState.updateClip(entry->fState.fClipStack, entry->fState.fClipRegion,
+ translation);
+ gsState.updateMatrix(entry->fState.fMatrix);
+ gsState.updateDrawingState(entry->fState);
+ data.write(entry->fContent.getStream(), entry->fContent.getOffset());
+ }
+ gsState.drainStack();
+
+ SkMemoryStream* result = new SkMemoryStream;
+ result->setMemoryOwned(data.detach(), data.getOffset());
+ return result;
+}
+
+void SkPDFDevice::createFormXObjectFromDevice(
+ SkRefPtr<SkPDFFormXObject>* xobject) {
+ *xobject = new SkPDFFormXObject(this);
+ (*xobject)->unref(); // SkRefPtr and new both took a reference.
+ cleanUp(); // Reset this device to have no content.
+ init();
+}
+
+void SkPDFDevice::clearClipFromContent(const SkClipStack* clipStack,
+ const SkRegion& clipRegion) {
+ if (clipRegion.isEmpty() || isContentEmpty()) {
+ return;
+ }
+ SkRefPtr<SkPDFFormXObject> curContent;
+ createFormXObjectFromDevice(&curContent);
+
+ // Redraw what we already had, but with the clip as a mask.
+ drawFormXObjectWithClip(curContent.get(), clipStack, clipRegion, true);
+}
+
+void SkPDFDevice::drawFormXObjectWithClip(SkPDFFormXObject* xobject,
+ const SkClipStack* clipStack,
+ const SkRegion& clipRegion,
+ bool invertClip) {
+ if (clipRegion.isEmpty() && !invertClip) {
+ return;
+ }
+
+ // Create the mask.
+ SkMatrix identity;
+ identity.reset();
+ SkDraw draw;
+ draw.fMatrix = &identity;
+ draw.fClip = &clipRegion;
+ draw.fClipStack = clipStack;
+ SkPaint stockPaint;
+ this->drawPaint(draw, stockPaint);
+ SkRefPtr<SkPDFFormXObject> maskFormXObject;
+ createFormXObjectFromDevice(&maskFormXObject);
+ SkRefPtr<SkPDFGraphicState> sMaskGS =
+ SkPDFGraphicState::getSMaskGraphicState(maskFormXObject.get(),
+ invertClip);
+ sMaskGS->unref(); // SkRefPtr and getSMaskGraphicState both took a ref.
+
+ // Draw the xobject with the clip as a mask.
+ ScopedContentEntry content(this, &fExistingClipStack, fExistingClipRegion,
+ identity, stockPaint);
+ if (!content.entry()) {
+ return;
+ }
+ SkPDFUtils::ApplyGraphicState(addGraphicStateResource(sMaskGS.get()),
+ &content.entry()->fContent);
+ SkPDFUtils::DrawFormXObject(fXObjectResources.count(),
+ &content.entry()->fContent);
+ fXObjectResources.push(xobject);
+ xobject->ref();
+
+ sMaskGS = SkPDFGraphicState::getNoSMaskGraphicState();
+ sMaskGS->unref(); // SkRefPtr and getSMaskGraphicState both took a ref.
+ SkPDFUtils::ApplyGraphicState(addGraphicStateResource(sMaskGS.get()),
+ &content.entry()->fContent);
+}
+
+ContentEntry* SkPDFDevice::setUpContentEntry(const SkClipStack* clipStack,
+ const SkRegion& clipRegion,
+ const SkMatrix& matrix,
+ const SkPaint& paint,
+ bool hasText,
+ SkRefPtr<SkPDFFormXObject>* dst) {
+ if (clipRegion.isEmpty()) {
+ return NULL;
+ }
+
+ // The clip stack can come from an SkDraw where it is technically optional.
+ SkClipStack synthesizedClipStack;
+ if (clipStack == NULL) {
+ if (clipRegion == fExistingClipRegion) {
+ clipStack = &fExistingClipStack;
+ } else {
+ // GraphicStackState::updateClip expects the clip stack to have
+ // fExistingClip as a prefix, so start there, then set the clip
+ // to the passed region.
+ synthesizedClipStack = fExistingClipStack;
+ SkPath clipPath;
+ clipRegion.getBoundaryPath(&clipPath);
+ synthesizedClipStack.clipDevPath(clipPath, SkRegion::kReplace_Op);
+ clipStack = &synthesizedClipStack;
+ }
+ }
+
+ SkXfermode::Mode xfermode = SkXfermode::kSrcOver_Mode;
+ if (paint.getXfermode()) {
+ paint.getXfermode()->asMode(&xfermode);
+ }
+
+ if (xfermode == SkXfermode::kClear_Mode ||
+ xfermode == SkXfermode::kSrc_Mode) {
+ this->clearClipFromContent(clipStack, clipRegion);
+ } else if (xfermode == SkXfermode::kSrcIn_Mode ||
+ xfermode == SkXfermode::kDstIn_Mode ||
+ xfermode == SkXfermode::kSrcOut_Mode ||
+ xfermode == SkXfermode::kDstOut_Mode) {
+ // For the following modes, we use both source and destination, but
+ // we use one as a smask for the other, so we have to make form xobjects
+ // out of both of them: SrcIn, DstIn, SrcOut, DstOut.
+ if (isContentEmpty()) {
+ return NULL;
+ } else {
+ createFormXObjectFromDevice(dst);
+ }
+ }
+ // TODO(vandebo) Figure out how/if we can handle the following modes:
+ // SrcAtop, DestAtop, Xor, Plus.
+
+ // These xfer modes don't draw source at all.
+ if (xfermode == SkXfermode::kClear_Mode ||
+ xfermode == SkXfermode::kDst_Mode) {
+ return NULL;
+ }
+
+ ContentEntry* entry;
+ SkTScopedPtr<ContentEntry> newEntry;
+ if (fLastContentEntry && fLastContentEntry->fContent.getOffset() == 0) {
+ entry = fLastContentEntry;
+ } else {
+ newEntry.reset(new ContentEntry);
+ entry = newEntry.get();
+ }
+
+ populateGraphicStateEntryFromPaint(matrix, *clipStack, clipRegion, paint,
+ hasText, &entry->fState);
+ if (fLastContentEntry && xfermode != SkXfermode::kDstOver_Mode &&
+ entry->fState.compareInitialState(fLastContentEntry->fState)) {
+ return fLastContentEntry;
+ }
+
+ if (!fLastContentEntry) {
+ fContentEntries.reset(entry);
+ fLastContentEntry = entry;
+ } else if (xfermode == SkXfermode::kDstOver_Mode) {
+ entry->fNext.reset(fContentEntries.release());
+ fContentEntries.reset(entry);
+ } else {
+ fLastContentEntry->fNext.reset(entry);
+ fLastContentEntry = entry;
+ }
+ newEntry.release();
+ return entry;
+}
+
+void SkPDFDevice::finishContentEntry(const SkXfermode::Mode xfermode,
+ SkPDFFormXObject* dst) {
+ if (xfermode != SkXfermode::kSrcIn_Mode &&
+ xfermode != SkXfermode::kDstIn_Mode &&
+ xfermode != SkXfermode::kSrcOut_Mode &&
+ xfermode != SkXfermode::kDstOut_Mode) {
+ SkASSERT(!dst);
+ return;
+ }
+ SkASSERT(dst);
+ SkASSERT(!fContentEntries->fNext.get());
+
+ // We have to make a copy of these here because changing the current
+ // content into a form xobject will destroy them.
+ SkClipStack clipStack = fContentEntries->fState.fClipStack;
+ SkRegion clipRegion = fContentEntries->fState.fClipRegion;
+
+ SkRefPtr<SkPDFFormXObject> srcFormXObject;
+ if (!isContentEmpty()) {
+ createFormXObjectFromDevice(&srcFormXObject);
+ }
+
+ drawFormXObjectWithClip(dst, &clipStack, clipRegion, true);
+
+ // We've redrawn dst minus the clip area, if there's no src, we're done.
+ if (!srcFormXObject.get()) {
+ return;
+ }
+
+ SkMatrix identity;
+ identity.reset();
+ SkPaint stockPaint;
+ ScopedContentEntry inClipContentEntry(this, &fExistingClipStack,
+ fExistingClipRegion, identity,
+ stockPaint);
+ if (!inClipContentEntry.entry()) {
+ return;
+ }
+
+ SkRefPtr<SkPDFGraphicState> sMaskGS;
+ if (xfermode == SkXfermode::kSrcIn_Mode ||
+ xfermode == SkXfermode::kSrcOut_Mode) {
+ sMaskGS = SkPDFGraphicState::getSMaskGraphicState(
+ dst, xfermode == SkXfermode::kSrcOut_Mode);
+ fXObjectResources.push(srcFormXObject.get());
+ srcFormXObject->ref();
+ } else {
+ sMaskGS = SkPDFGraphicState::getSMaskGraphicState(
+ srcFormXObject.get(), xfermode == SkXfermode::kDstOut_Mode);
+ // dst already added to fXObjectResources in drawFormXObjectWithClip.
+ }
+ sMaskGS->unref(); // SkRefPtr and getSMaskGraphicState both took a ref.
+ SkPDFUtils::ApplyGraphicState(addGraphicStateResource(sMaskGS.get()),
+ &inClipContentEntry.entry()->fContent);
+
+ SkPDFUtils::DrawFormXObject(fXObjectResources.count() - 1,
+ &inClipContentEntry.entry()->fContent);
+
+ sMaskGS = SkPDFGraphicState::getNoSMaskGraphicState();
+ sMaskGS->unref(); // SkRefPtr and getSMaskGraphicState both took a ref.
+ SkPDFUtils::ApplyGraphicState(addGraphicStateResource(sMaskGS.get()),
+ &inClipContentEntry.entry()->fContent);
+}
+
+bool SkPDFDevice::isContentEmpty() {
+ if (!fContentEntries.get() || fContentEntries->fContent.getOffset() == 0) {
+ SkASSERT(!fContentEntries.get() || !fContentEntries->fNext.get());
+ return true;
+ }
+ return false;
+}
+
+
+void SkPDFDevice::populateGraphicStateEntryFromPaint(
+ const SkMatrix& matrix,
+ const SkClipStack& clipStack,
+ const SkRegion& clipRegion,
+ const SkPaint& paint,
+ bool hasText,
+ GraphicStateEntry* entry) {
+ SkASSERT(paint.getPathEffect() == NULL);
+
+ NOT_IMPLEMENTED(paint.getMaskFilter() != NULL, false);
+ NOT_IMPLEMENTED(paint.getColorFilter() != NULL, false);
+
+ entry->fMatrix = matrix;
+ entry->fClipStack = clipStack;
+ entry->fClipRegion = clipRegion;
+
+ // PDF treats a shader as a color, so we only set one or the other.
+ SkRefPtr<SkPDFShader> pdfShader;
+ const SkShader* shader = paint.getShader();
+ SkColor color = paint.getColor();
+ if (shader) {
+ // PDF positions patterns relative to the initial transform, so
+ // we need to apply the current transform to the shader parameters.
+ SkMatrix transform = matrix;
+ transform.postConcat(fInitialTransform);
+
+ // PDF doesn't support kClamp_TileMode, so we simulate it by making
+ // a pattern the size of the current clip.
+ SkIRect bounds = clipRegion.getBounds();
+ pdfShader = SkPDFShader::getPDFShader(*shader, transform, bounds);
+ SkSafeUnref(pdfShader.get()); // getShader and SkRefPtr both took a ref
+
+ // A color shader is treated as an invalid shader so we don't have
+ // to set a shader just for a color.
+ if (pdfShader.get() == NULL) {
+ entry->fColor = 0;
+ color = 0;
+
+ // Check for a color shader.
+ SkShader::GradientInfo gradientInfo;
+ SkColor gradientColor;
+ gradientInfo.fColors = &gradientColor;
+ gradientInfo.fColorOffsets = NULL;
+ gradientInfo.fColorCount = 1;
+ if (shader->asAGradient(&gradientInfo) ==
+ SkShader::kColor_GradientType) {
+ entry->fColor = SkColorSetA(gradientColor, 0xFF);
+ color = gradientColor;
+ }
+ }
+ }
+
+ if (pdfShader) {
+ // pdfShader has been canonicalized so we can directly compare
+ // pointers.
+ int resourceIndex = fShaderResources.find(pdfShader.get());
+ if (resourceIndex < 0) {
+ resourceIndex = fShaderResources.count();
+ fShaderResources.push(pdfShader.get());
+ pdfShader->ref();
+ }
+ entry->fShaderIndex = resourceIndex;
+ } else {
+ entry->fShaderIndex = -1;
+ entry->fColor = SkColorSetA(paint.getColor(), 0xFF);
+ color = paint.getColor();
+ }
+
+ SkRefPtr<SkPDFGraphicState> newGraphicState;
+ if (color == paint.getColor()) {
+ newGraphicState = SkPDFGraphicState::getGraphicStateForPaint(paint);
+ } else {
+ SkPaint newPaint = paint;
+ newPaint.setColor(color);
+ newGraphicState = SkPDFGraphicState::getGraphicStateForPaint(newPaint);
+ }
+ newGraphicState->unref(); // getGraphicState and SkRefPtr both took a ref.
+ int resourceIndex = addGraphicStateResource(newGraphicState.get());
+ entry->fGraphicStateIndex = resourceIndex;
+
+ if (hasText) {
+ entry->fTextScaleX = paint.getTextScaleX();
+ entry->fTextFill = paint.getStyle();
+ } else {
+ entry->fTextScaleX = 0;
+ }
+}
+
+int SkPDFDevice::addGraphicStateResource(SkPDFGraphicState* gs) {
+ // Assumes that gs has been canonicalized (so we can directly compare
+ // pointers).
+ int result = fGraphicStateResources.find(gs);
+ if (result < 0) {
+ result = fGraphicStateResources.count();
+ fGraphicStateResources.push(gs);
+ gs->ref();
+ }
+ return result;
+}
+
+void SkPDFDevice::updateFont(const SkPaint& paint, uint16_t glyphID,
+ ContentEntry* contentEntry) {
+ SkTypeface* typeface = paint.getTypeface();
+ if (contentEntry->fState.fFont == NULL ||
+ contentEntry->fState.fTextSize != paint.getTextSize() ||
+ !contentEntry->fState.fFont->hasGlyph(glyphID)) {
+ int fontIndex = getFontResourceIndex(typeface, glyphID);
+ contentEntry->fContent.writeText("/F");
+ contentEntry->fContent.writeDecAsText(fontIndex);
+ contentEntry->fContent.writeText(" ");
+ SkPDFScalar::Append(paint.getTextSize(), &contentEntry->fContent);
+ contentEntry->fContent.writeText(" Tf\n");
+ contentEntry->fState.fFont = fFontResources[fontIndex];
+ }
+}
+
+int SkPDFDevice::getFontResourceIndex(SkTypeface* typeface, uint16_t glyphID) {
+ SkRefPtr<SkPDFFont> newFont = SkPDFFont::getFontResource(typeface, glyphID);
+ newFont->unref(); // getFontResource and SkRefPtr both took a ref.
+ int resourceIndex = fFontResources.find(newFont.get());
+ if (resourceIndex < 0) {
+ resourceIndex = fFontResources.count();
+ fFontResources.push(newFont.get());
+ newFont->ref();
+ }
+ return resourceIndex;
+}
+
+void SkPDFDevice::internalDrawBitmap(const SkMatrix& matrix,
+ const SkClipStack* clipStack,
+ const SkRegion& clipRegion,
+ const SkBitmap& bitmap,
+ const SkIRect* srcRect,
+ const SkPaint& paint) {
+ SkMatrix scaled;
+ // Adjust for origin flip.
+ scaled.setScale(1, -1);
+ scaled.postTranslate(0, 1);
+ // Scale the image up from 1x1 to WxH.
+ SkIRect subset = SkIRect::MakeWH(bitmap.width(), bitmap.height());
+ scaled.postScale(SkIntToScalar(subset.width()),
+ SkIntToScalar(subset.height()));
+ scaled.postConcat(matrix);
+ ScopedContentEntry content(this, clipStack, clipRegion, scaled, paint);
+ if (!content.entry()) {
+ return;
+ }
+
+ if (srcRect && !subset.intersect(*srcRect)) {
+ return;
+ }
+
+ SkPDFImage* image = SkPDFImage::CreateImage(bitmap, subset, paint);
+ if (!image) {
+ return;
+ }
+
+ fXObjectResources.push(image); // Transfer reference.
+ SkPDFUtils::DrawFormXObject(fXObjectResources.count() - 1,
+ &content.entry()->fContent);
+}
diff --git a/src/pdf/SkPDFDocument.cpp b/src/pdf/SkPDFDocument.cpp
new file mode 100644
index 0000000..95370b4
--- /dev/null
+++ b/src/pdf/SkPDFDocument.cpp
@@ -0,0 +1,192 @@
+/*
+ * Copyright (C) 2011 Google Inc.
+ *
+ * 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.
+ */
+
+#include "SkPDFDevice.h"
+#include "SkPDFDocument.h"
+#include "SkPDFPage.h"
+#include "SkStream.h"
+
+// Add the resources, starting at firstIndex to the catalog, removing any dupes.
+// A hash table would be really nice here.
+void addResourcesToCatalog(int firstIndex, bool firstPage,
+ SkTDArray<SkPDFObject*>* resourceList,
+ SkPDFCatalog* catalog) {
+ for (int i = firstIndex; i < resourceList->count(); i++) {
+ int index = resourceList->find((*resourceList)[i]);
+ if (index != i) {
+ (*resourceList)[i]->unref();
+ resourceList->removeShuffle(i);
+ i--;
+ } else {
+ catalog->addObject((*resourceList)[i], firstPage);
+ }
+ }
+}
+
+SkPDFDocument::SkPDFDocument() : fXRefFileOffset(0) {
+ fDocCatalog = new SkPDFDict("Catalog");
+ fDocCatalog->unref(); // SkRefPtr and new both took a reference.
+ fCatalog.addObject(fDocCatalog.get(), true);
+}
+
+SkPDFDocument::~SkPDFDocument() {
+ fPages.safeUnrefAll();
+
+ // The page tree has both child and parent pointers, so it creates a
+ // reference cycle. We must clear that cycle to properly reclaim memory.
+ for (int i = 0; i < fPageTree.count(); i++)
+ fPageTree[i]->clear();
+ fPageTree.safeUnrefAll();
+ fPageResources.safeUnrefAll();
+}
+
+bool SkPDFDocument::emitPDF(SkWStream* stream) {
+ if (fPages.isEmpty())
+ return false;
+
+ // We haven't emitted the document before if fPageTree is empty.
+ if (fPageTree.count() == 0) {
+ SkPDFDict* pageTreeRoot;
+ SkPDFPage::generatePageTree(fPages, &fCatalog, &fPageTree,
+ &pageTreeRoot);
+ fDocCatalog->insert("Pages", new SkPDFObjRef(pageTreeRoot))->unref();
+
+ /* TODO(vandebo) output intent
+ SkRefPtr<SkPDFDict> outputIntent = new SkPDFDict("OutputIntent");
+ outputIntent->unref(); // SkRefPtr and new both took a reference.
+ outputIntent->insert("S", new SkPDFName("GTS_PDFA1"))->unref();
+ outputIntent->insert("OutputConditionIdentifier",
+ new SkPDFString("sRGB"))->unref();
+ SkRefPtr<SkPDFArray> intentArray = new SkPDFArray;
+ intentArray->unref(); // SkRefPtr and new both took a reference.
+ intentArray->append(outputIntent.get());
+ fDocCatalog->insert("OutputIntent", intentArray.get());
+ */
+
+ bool first_page = true;
+ for (int i = 0; i < fPages.count(); i++) {
+ int resourceCount = fPageResources.count();
+ fPages[i]->finalizePage(&fCatalog, first_page, &fPageResources);
+ addResourcesToCatalog(resourceCount, first_page, &fPageResources,
+ &fCatalog);
+ if (i == 0) {
+ first_page = false;
+ fSecondPageFirstResourceIndex = fPageResources.count();
+ }
+ }
+
+ // Figure out the size of things and inform the catalog of file offsets.
+ off_t fileOffset = headerSize();
+ fileOffset += fCatalog.setFileOffset(fDocCatalog.get(), fileOffset);
+ fileOffset += fCatalog.setFileOffset(fPages[0], fileOffset);
+ fileOffset += fPages[0]->getPageSize(&fCatalog, fileOffset);
+ for (int i = 0; i < fSecondPageFirstResourceIndex; i++)
+ fileOffset += fCatalog.setFileOffset(fPageResources[i], fileOffset);
+ if (fPages.count() > 1) {
+ // TODO(vandebo) For linearized format, save the start of the
+ // first page xref table and calculate the size.
+ }
+
+ for (int i = 0; i < fPageTree.count(); i++)
+ fileOffset += fCatalog.setFileOffset(fPageTree[i], fileOffset);
+
+ for (int i = 1; i < fPages.count(); i++)
+ fileOffset += fPages[i]->getPageSize(&fCatalog, fileOffset);
+
+ for (int i = fSecondPageFirstResourceIndex;
+ i < fPageResources.count();
+ i++)
+ fileOffset += fCatalog.setFileOffset(fPageResources[i], fileOffset);
+
+ fXRefFileOffset = fileOffset;
+ }
+
+ emitHeader(stream);
+ fDocCatalog->emitObject(stream, &fCatalog, true);
+ fPages[0]->emitObject(stream, &fCatalog, true);
+ fPages[0]->emitPage(stream, &fCatalog);
+ for (int i = 0; i < fSecondPageFirstResourceIndex; i++)
+ fPageResources[i]->emitObject(stream, &fCatalog, true);
+ // TODO(vandebo) support linearized format
+ //if (fPages.size() > 1) {
+ // // TODO(vandebo) save the file offset for the first page xref table.
+ // fCatalog.emitXrefTable(stream, true);
+ //}
+
+ for (int i = 0; i < fPageTree.count(); i++)
+ fPageTree[i]->emitObject(stream, &fCatalog, true);
+
+ for (int i = 1; i < fPages.count(); i++)
+ fPages[i]->emitPage(stream, &fCatalog);
+
+ for (int i = fSecondPageFirstResourceIndex; i < fPageResources.count(); i++)
+ fPageResources[i]->emitObject(stream, &fCatalog, true);
+
+ int64_t objCount = fCatalog.emitXrefTable(stream, fPages.count() > 1);
+ emitFooter(stream, objCount);
+ return true;
+}
+
+bool SkPDFDocument::appendPage(const SkRefPtr<SkPDFDevice>& pdfDevice) {
+ if (fPageTree.count() != 0)
+ return false;
+
+ SkPDFPage* page = new SkPDFPage(pdfDevice);
+ fPages.push(page); // Reference from new passed to fPages.
+ // The rest of the pages will be added to the catalog along with the rest
+ // of the page tree. But the first page has to be marked as such, so we
+ // handle it here.
+ if (fPages.count() == 1)
+ fCatalog.addObject(page, true);
+ return true;
+}
+
+const SkTDArray<SkPDFPage*>& SkPDFDocument::getPages() {
+ return fPages;
+}
+
+void SkPDFDocument::emitHeader(SkWStream* stream) {
+ stream->writeText("%PDF-1.4\n%");
+ // The PDF spec recommends including a comment with four bytes, all
+ // with their high bits set. This is "Skia" with the high bits set.
+ stream->write32(0xD3EBE9E1);
+ stream->writeText("\n");
+}
+
+size_t SkPDFDocument::headerSize() {
+ SkDynamicMemoryWStream buffer;
+ emitHeader(&buffer);
+ return buffer.getOffset();
+}
+
+void SkPDFDocument::emitFooter(SkWStream* stream, int64_t objCount) {
+ if (fTrailerDict.get() == NULL) {
+ fTrailerDict = new SkPDFDict();
+ fTrailerDict->unref(); // SkRefPtr and new both took a reference.
+
+ // TODO(vandebo) Linearized format will take a Prev entry too.
+ // TODO(vandebo) PDF/A requires an ID entry.
+ fTrailerDict->insert("Size", new SkPDFInt(objCount))->unref();
+ fTrailerDict->insert("Root",
+ new SkPDFObjRef(fDocCatalog.get()))->unref();
+ }
+
+ stream->writeText("trailer\n");
+ fTrailerDict->emitObject(stream, &fCatalog, false);
+ stream->writeText("\nstartxref\n");
+ stream->writeBigDecAsText(fXRefFileOffset);
+ stream->writeText("\n%%EOF");
+}
diff --git a/src/pdf/SkPDFFont.cpp b/src/pdf/SkPDFFont.cpp
new file mode 100755
index 0000000..277ed12
--- /dev/null
+++ b/src/pdf/SkPDFFont.cpp
@@ -0,0 +1,976 @@
+/*
+ * Copyright (C) 2011 Google Inc.
+ *
+ * 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.
+ */
+
+#include <ctype.h>
+
+#include "SkFontHost.h"
+#include "SkGlyphCache.h"
+#include "SkPaint.h"
+#include "SkPDFDevice.h"
+#include "SkPDFFont.h"
+#include "SkPDFStream.h"
+#include "SkPDFTypes.h"
+#include "SkPDFUtils.h"
+#include "SkRefCnt.h"
+#include "SkScalar.h"
+#include "SkStream.h"
+#include "SkTypeface.h"
+#include "SkTypes.h"
+#include "SkUtils.h"
+
+namespace {
+
+bool parsePFBSection(const uint8_t** src, size_t* len, int sectionType,
+ size_t* size) {
+ // PFB sections have a two or six bytes header. 0x80 and a one byte
+ // section type followed by a four byte section length. Type one is
+ // an ASCII section (includes a length), type two is a binary section
+ // (includes a length) and type three is an EOF marker with no length.
+ const uint8_t* buf = *src;
+ if (*len < 2 || buf[0] != 0x80 || buf[1] != sectionType)
+ return false;
+ if (buf[1] == 3)
+ return true;
+ if (*len < 6)
+ return false;
+
+ *size = buf[2] | (buf[3] << 8) | (buf[4] << 16) | (buf[5] << 24);
+ size_t consumed = *size + 6;
+ if (consumed > *len)
+ return false;
+ *src = *src + consumed;
+ *len = *len - consumed;
+ return true;
+}
+
+bool parsePFB(const uint8_t* src, size_t size, size_t* headerLen,
+ size_t* dataLen, size_t* trailerLen) {
+ const uint8_t* srcPtr = src;
+ size_t remaining = size;
+
+ return parsePFBSection(&srcPtr, &remaining, 1, headerLen) &&
+ parsePFBSection(&srcPtr, &remaining, 2, dataLen) &&
+ parsePFBSection(&srcPtr, &remaining, 1, trailerLen) &&
+ parsePFBSection(&srcPtr, &remaining, 3, NULL);
+}
+
+/* The sections of a PFA file are implicitly defined. The body starts
+ * after the line containing "eexec," and the trailer starts with 512
+ * literal 0's followed by "cleartomark" (plus arbitrary white space).
+ *
+ * This function assumes that src is NUL terminated, but the NUL
+ * termination is not included in size.
+ *
+ */
+bool parsePFA(const char* src, size_t size, size_t* headerLen,
+ size_t* hexDataLen, size_t* dataLen, size_t* trailerLen) {
+ const char* end = src + size;
+
+ const char* dataPos = strstr(src, "eexec");
+ if (!dataPos)
+ return false;
+ dataPos += strlen("eexec");
+ while ((*dataPos == '\n' || *dataPos == '\r' || *dataPos == ' ') &&
+ dataPos < end)
+ dataPos++;
+ *headerLen = dataPos - src;
+
+ const char* trailerPos = strstr(dataPos, "cleartomark");
+ if (!trailerPos)
+ return false;
+ int zeroCount = 0;
+ for (trailerPos--; trailerPos > dataPos && zeroCount < 512; trailerPos--) {
+ if (*trailerPos == '\n' || *trailerPos == '\r' || *trailerPos == ' ') {
+ continue;
+ } else if (*trailerPos == '0') {
+ zeroCount++;
+ } else {
+ return false;
+ }
+ }
+ if (zeroCount != 512)
+ return false;
+
+ *hexDataLen = trailerPos - src - *headerLen;
+ *trailerLen = size - *headerLen - *hexDataLen;
+
+ // Verify that the data section is hex encoded and count the bytes.
+ int nibbles = 0;
+ for (; dataPos < trailerPos; dataPos++) {
+ if (isspace(*dataPos))
+ continue;
+ if (!isxdigit(*dataPos))
+ return false;
+ nibbles++;
+ }
+ *dataLen = (nibbles + 1) / 2;
+
+ return true;
+}
+
+int8_t hexToBin(uint8_t c) {
+ if (!isxdigit(c))
+ return -1;
+ if (c <= '9') return c - '0';
+ if (c <= 'F') return c - 'A' + 10;
+ if (c <= 'f') return c - 'a' + 10;
+ return -1;
+}
+
+SkStream* handleType1Stream(SkStream* srcStream, size_t* headerLen,
+ size_t* dataLen, size_t* trailerLen) {
+ // srcStream may be backed by a file or a unseekable fd, so we may not be
+ // able to use skip(), rewind(), or getMemoryBase(). read()ing through
+ // the input only once is doable, but very ugly. Furthermore, it'd be nice
+ // if the data was NUL terminated so that we can use strstr() to search it.
+ // Make as few copies as possible given these constraints.
+ SkDynamicMemoryWStream dynamicStream;
+ SkRefPtr<SkMemoryStream> staticStream;
+ const uint8_t* src;
+ size_t srcLen;
+ if ((srcLen = srcStream->getLength()) > 0) {
+ staticStream = new SkMemoryStream(srcLen + 1);
+ staticStream->unref(); // new and SkRefPtr both took a ref.
+ src = (const uint8_t*)staticStream->getMemoryBase();
+ if (srcStream->getMemoryBase() != NULL) {
+ memcpy((void *)src, srcStream->getMemoryBase(), srcLen);
+ } else {
+ size_t read = 0;
+ while (read < srcLen) {
+ size_t got = srcStream->read((void *)staticStream->getAtPos(),
+ srcLen - read);
+ if (got == 0)
+ return NULL;
+ read += got;
+ staticStream->seek(read);
+ }
+ }
+ ((uint8_t *)src)[srcLen] = 0;
+ } else {
+ static const size_t bufSize = 4096;
+ uint8_t buf[bufSize];
+ size_t amount;
+ while ((amount = srcStream->read(buf, bufSize)) > 0)
+ dynamicStream.write(buf, amount);
+ amount = 0;
+ dynamicStream.write(&amount, 1); // NULL terminator.
+ // getStream makes another copy, but we couldn't do any better.
+ src = (const uint8_t*)dynamicStream.getStream();
+ srcLen = dynamicStream.getOffset() - 1;
+ }
+
+ if (parsePFB(src, srcLen, headerLen, dataLen, trailerLen)) {
+ SkMemoryStream* result =
+ new SkMemoryStream(*headerLen + *dataLen + *trailerLen);
+ memcpy((char*)result->getAtPos(), src + 6, *headerLen);
+ result->seek(*headerLen);
+ memcpy((char*)result->getAtPos(), src + 6 + *headerLen + 6, *dataLen);
+ result->seek(*headerLen + *dataLen);
+ memcpy((char*)result->getAtPos(), src + 6 + *headerLen + 6 + *dataLen,
+ *trailerLen);
+ result->rewind();
+ return result;
+ }
+
+ // A PFA has to be converted for PDF.
+ size_t hexDataLen;
+ if (parsePFA((const char*)src, srcLen, headerLen, &hexDataLen, dataLen,
+ trailerLen)) {
+ SkMemoryStream* result =
+ new SkMemoryStream(*headerLen + *dataLen + *trailerLen);
+ memcpy((char*)result->getAtPos(), src, *headerLen);
+ result->seek(*headerLen);
+
+ const uint8_t* hexData = src + *headerLen;
+ const uint8_t* trailer = hexData + hexDataLen;
+ size_t outputOffset = 0;
+ uint8_t dataByte = 0; // To hush compiler.
+ bool highNibble = true;
+ for (; hexData < trailer; hexData++) {
+ char curNibble = hexToBin(*hexData);
+ if (curNibble < 0)
+ continue;
+ if (highNibble) {
+ dataByte = curNibble << 4;
+ highNibble = false;
+ } else {
+ dataByte |= curNibble;
+ highNibble = true;
+ ((char *)result->getAtPos())[outputOffset++] = dataByte;
+ }
+ }
+ if (!highNibble)
+ ((char *)result->getAtPos())[outputOffset++] = dataByte;
+ SkASSERT(outputOffset == *dataLen);
+ result->seek(*headerLen + outputOffset);
+
+ memcpy((char *)result->getAtPos(), src + *headerLen + hexDataLen,
+ *trailerLen);
+ result->rewind();
+ return result;
+ }
+
+ return NULL;
+}
+
+// scale from em-units to base-1000, returning as a SkScalar
+SkScalar scaleFromFontUnits(int16_t val, uint16_t emSize) {
+ SkScalar scaled = SkIntToScalar(val);
+ if (emSize == 1000) {
+ return scaled;
+ } else {
+ return SkScalarMulDiv(scaled, 1000, emSize);
+ }
+}
+
+void setGlyphWidthAndBoundingBox(SkScalar width, SkIRect box,
+ SkWStream* content) {
+ // Specify width and bounding box for the glyph.
+ SkPDFScalar::Append(width, content);
+ content->writeText(" 0 ");
+ content->writeDecAsText(box.fLeft);
+ content->writeText(" ");
+ content->writeDecAsText(box.fTop);
+ content->writeText(" ");
+ content->writeDecAsText(box.fRight);
+ content->writeText(" ");
+ content->writeDecAsText(box.fBottom);
+ content->writeText(" d1\n");
+}
+
+SkPDFArray* makeFontBBox(SkIRect glyphBBox, uint16_t emSize) {
+ SkPDFArray* bbox = new SkPDFArray;
+ bbox->reserve(4);
+ bbox->append(new SkPDFScalar(scaleFromFontUnits(glyphBBox.fLeft,
+ emSize)))->unref();
+ bbox->append(new SkPDFScalar(scaleFromFontUnits(glyphBBox.fBottom,
+ emSize)))->unref();
+ bbox->append(new SkPDFScalar(scaleFromFontUnits(glyphBBox.fRight,
+ emSize)))->unref();
+ bbox->append(new SkPDFScalar(scaleFromFontUnits(glyphBBox.fTop,
+ emSize)))->unref();
+ return bbox;
+}
+
+SkPDFArray* appendWidth(const int16_t& width, uint16_t emSize,
+ SkPDFArray* array) {
+ array->append(new SkPDFScalar(scaleFromFontUnits(width, emSize)))->unref();
+ return array;
+}
+
+SkPDFArray* appendVerticalAdvance(
+ const SkAdvancedTypefaceMetrics::VerticalMetric& advance,
+ uint16_t emSize, SkPDFArray* array) {
+ appendWidth(advance.fVerticalAdvance, emSize, array);
+ appendWidth(advance.fOriginXDisp, emSize, array);
+ appendWidth(advance.fOriginYDisp, emSize, array);
+ return array;
+}
+
+template <typename Data>
+SkPDFArray* composeAdvanceData(
+ SkAdvancedTypefaceMetrics::AdvanceMetric<Data>* advanceInfo,
+ uint16_t emSize,
+ SkPDFArray* (*appendAdvance)(const Data& advance, uint16_t emSize,
+ SkPDFArray* array),
+ Data* defaultAdvance) {
+ SkPDFArray* result = new SkPDFArray();
+ for (; advanceInfo != NULL; advanceInfo = advanceInfo->fNext.get()) {
+ switch (advanceInfo->fType) {
+ case SkAdvancedTypefaceMetrics::WidthRange::kDefault: {
+ SkASSERT(advanceInfo->fAdvance.count() == 1);
+ *defaultAdvance = advanceInfo->fAdvance[0];
+ break;
+ }
+ case SkAdvancedTypefaceMetrics::WidthRange::kRange: {
+ SkRefPtr<SkPDFArray> advanceArray = new SkPDFArray();
+ advanceArray->unref(); // SkRefPtr and new both took a ref.
+ for (int j = 0; j < advanceInfo->fAdvance.count(); j++)
+ appendAdvance(advanceInfo->fAdvance[j], emSize,
+ advanceArray.get());
+ result->append(new SkPDFInt(advanceInfo->fStartId))->unref();
+ result->append(advanceArray.get());
+ break;
+ }
+ case SkAdvancedTypefaceMetrics::WidthRange::kRun: {
+ SkASSERT(advanceInfo->fAdvance.count() == 1);
+ result->append(new SkPDFInt(advanceInfo->fStartId))->unref();
+ result->append(new SkPDFInt(advanceInfo->fEndId))->unref();
+ appendAdvance(advanceInfo->fAdvance[0], emSize, result);
+ break;
+ }
+ }
+ }
+ return result;
+}
+
+} // namespace
+
+static void append_tounicode_header(SkDynamicMemoryWStream* cmap) {
+ // 12 dict begin: 12 is an Adobe-suggested value. Shall not change.
+ // It's there to prevent old version Adobe Readers from malfunctioning.
+ const char* kHeader =
+ "/CIDInit /ProcSet findresource begin\n"
+ "12 dict begin\n"
+ "begincmap\n";
+ cmap->writeText(kHeader);
+
+ // The /CIDSystemInfo must be consistent to the one in
+ // SkPDFFont::populateCIDFont().
+ // We can not pass over the system info object here because the format is
+ // different. This is not a reference object.
+ const char* kSysInfo =
+ "/CIDSystemInfo\n"
+ "<< /Registry (Adobe)\n"
+ "/Ordering (UCS)\n"
+ "/Supplement 0\n"
+ ">> def\n";
+ cmap->writeText(kSysInfo);
+
+ // The CMapName must be consistent to /CIDSystemInfo above.
+ // /CMapType 2 means ToUnicode.
+ // We specify codespacerange from 0x0000 to 0xFFFF because we convert our
+ // code table from unsigned short (16-bits). Codespace range just tells the
+ // PDF processor the valid range. It does not matter whether a complete
+ // mapping is provided or not.
+ const char* kTypeInfo =
+ "/CMapName /Adobe-Identity-UCS def\n"
+ "/CMapType 2 def\n"
+ "1 begincodespacerange\n"
+ "<0000> <FFFF>\n"
+ "endcodespacerange\n";
+ cmap->writeText(kTypeInfo);
+}
+
+static void append_cmap_bfchar_table(uint16_t* glyph_id, SkUnichar* unicode,
+ size_t count,
+ SkDynamicMemoryWStream* cmap) {
+ cmap->writeDecAsText(count);
+ cmap->writeText(" beginbfchar\n");
+ for (size_t i = 0; i < count; ++i) {
+ cmap->writeText("<");
+ cmap->writeHexAsText(glyph_id[i], 4);
+ cmap->writeText("> <");
+ cmap->writeHexAsText(unicode[i], 4);
+ cmap->writeText(">\n");
+ }
+ cmap->writeText("endbfchar\n");
+}
+
+static void append_cmap_footer(SkDynamicMemoryWStream* cmap) {
+ const char* kFooter =
+ "endcmap\n"
+ "CMapName currentdict /CMap defineresource pop\n"
+ "end\n"
+ "end";
+ cmap->writeText(kFooter);
+}
+
+// Generate <bfchar> table according to PDF spec 1.4 and Adobe Technote 5014.
+static void append_cmap_bfchar_sections(
+ const SkTDArray<SkUnichar>& glyphUnicode,
+ SkDynamicMemoryWStream* cmap) {
+ // PDF spec defines that every bf* list can have at most 100 entries.
+ const size_t kMaxEntries = 100;
+ uint16_t glyphId[kMaxEntries];
+ SkUnichar unicode[kMaxEntries];
+ size_t index = 0;
+ for (int i = 0; i < glyphUnicode.count(); i++) {
+ if (glyphUnicode[i]) {
+ glyphId[index] = i;
+ unicode[index] = glyphUnicode[i];
+ ++index;
+ }
+ if (index == kMaxEntries) {
+ append_cmap_bfchar_table(glyphId, unicode, index, cmap);
+ index = 0;
+ }
+ }
+
+ if (index) {
+ append_cmap_bfchar_table(glyphId, unicode, index, cmap);
+ }
+}
+
+/* Font subset design: It would be nice to be able to subset fonts
+ * (particularly type 3 fonts), but it's a lot of work and not a priority.
+ *
+ * Resources are canonicalized and uniqueified by pointer so there has to be
+ * some additional state indicating which subset of the font is used. It
+ * must be maintained at the page granularity and then combined at the document
+ * granularity. a) change SkPDFFont to fill in its state on demand, kind of
+ * like SkPDFGraphicState. b) maintain a per font glyph usage class in each
+ * page/pdf device. c) in the document, retrieve the per font glyph usage
+ * from each page and combine it and ask for a resource with that subset.
+ */
+
+SkPDFFont::~SkPDFFont() {
+ SkAutoMutexAcquire lock(canonicalFontsMutex());
+ int index;
+ if (find(SkTypeface::UniqueID(fTypeface.get()), fFirstGlyphID, &index)) {
+ canonicalFonts().removeShuffle(index);
+#ifdef SK_DEBUG
+ SkASSERT(!fDescendant);
+ } else {
+ SkASSERT(fDescendant);
+#endif
+ }
+ fResources.unrefAll();
+}
+
+void SkPDFFont::getResources(SkTDArray<SkPDFObject*>* resourceList) {
+ resourceList->setReserve(resourceList->count() + fResources.count());
+ for (int i = 0; i < fResources.count(); i++) {
+ resourceList->push(fResources[i]);
+ fResources[i]->ref();
+ fResources[i]->getResources(resourceList);
+ }
+}
+
+SkTypeface* SkPDFFont::typeface() {
+ return fTypeface.get();
+}
+
+SkAdvancedTypefaceMetrics::FontType SkPDFFont::getType() {
+ return fType;
+}
+
+bool SkPDFFont::hasGlyph(uint16_t id) {
+ return (id >= fFirstGlyphID && id <= fLastGlyphID) || id == 0;
+}
+
+bool SkPDFFont::multiByteGlyphs() {
+ return fMultiByteGlyphs;
+}
+
+size_t SkPDFFont::glyphsToPDFFontEncoding(uint16_t* glyphIDs,
+ size_t numGlyphs) {
+ // A font with multibyte glyphs will support all glyph IDs in a single font.
+ if (fMultiByteGlyphs) {
+ return numGlyphs;
+ }
+
+ for (size_t i = 0; i < numGlyphs; i++) {
+ if (glyphIDs[i] == 0) {
+ continue;
+ }
+ if (glyphIDs[i] < fFirstGlyphID || glyphIDs[i] > fLastGlyphID) {
+ return i;
+ }
+ glyphIDs[i] -= (fFirstGlyphID - 1);
+ }
+
+ return numGlyphs;
+}
+
+// static
+SkPDFFont* SkPDFFont::getFontResource(SkTypeface* typeface, uint16_t glyphID) {
+ SkAutoMutexAcquire lock(canonicalFontsMutex());
+ const uint32_t fontID = SkTypeface::UniqueID(typeface);
+ int index;
+ if (find(fontID, glyphID, &index)) {
+ canonicalFonts()[index].fFont->ref();
+ return canonicalFonts()[index].fFont;
+ }
+
+ SkRefPtr<SkAdvancedTypefaceMetrics> fontInfo;
+ SkPDFDict* fontDescriptor = NULL;
+ if (index >= 0) {
+ SkPDFFont* relatedFont = canonicalFonts()[index].fFont;
+ SkASSERT(relatedFont->fFontInfo.get());
+ fontInfo = relatedFont->fFontInfo;
+ fontDescriptor = relatedFont->fDescriptor.get();
+ } else {
+ SkAdvancedTypefaceMetrics::PerGlyphInfo info;
+ info = SkAdvancedTypefaceMetrics::kHAdvance_PerGlyphInfo;
+ info = SkTBitOr<SkAdvancedTypefaceMetrics::PerGlyphInfo>(
+ info, SkAdvancedTypefaceMetrics::kGlyphNames_PerGlyphInfo);
+ info = SkTBitOr<SkAdvancedTypefaceMetrics::PerGlyphInfo>(
+ info, SkAdvancedTypefaceMetrics::kToUnicode_PerGlyphInfo);
+ fontInfo = SkFontHost::GetAdvancedTypefaceMetrics(fontID, info);
+ SkSafeUnref(fontInfo.get()); // SkRefPtr and Get both took a reference.
+ }
+
+ SkPDFFont* font = new SkPDFFont(fontInfo.get(), typeface, glyphID, false,
+ fontDescriptor);
+ FontRec newEntry(font, fontID, font->fFirstGlyphID);
+ index = canonicalFonts().count();
+ canonicalFonts().push(newEntry);
+ return font; // Return the reference new SkPDFFont() created.
+}
+
+// static
+SkTDArray<SkPDFFont::FontRec>& SkPDFFont::canonicalFonts() {
+ // This initialization is only thread safe with gcc.
+ static SkTDArray<FontRec> gCanonicalFonts;
+ return gCanonicalFonts;
+}
+
+// static
+SkMutex& SkPDFFont::canonicalFontsMutex() {
+ // This initialization is only thread safe with gcc.
+ static SkMutex gCanonicalFontsMutex;
+ return gCanonicalFontsMutex;
+}
+
+// static
+bool SkPDFFont::find(uint32_t fontID, uint16_t glyphID, int* index) {
+ // TODO(vandebo) optimize this, do only one search?
+ FontRec search(NULL, fontID, glyphID);
+ *index = canonicalFonts().find(search);
+ if (*index >= 0)
+ return true;
+ search.fGlyphID = 0;
+ *index = canonicalFonts().find(search);
+ return false;
+}
+
+SkPDFFont::SkPDFFont(class SkAdvancedTypefaceMetrics* fontInfo,
+ SkTypeface* typeface,
+ uint16_t glyphID,
+ bool descendantFont,
+ SkPDFDict* fontDescriptor)
+ : SkPDFDict("Font"),
+ fTypeface(typeface),
+ fType(fontInfo ? fontInfo->fType :
+ SkAdvancedTypefaceMetrics::kNotEmbeddable_Font),
+#ifdef SK_DEBUG
+ fDescendant(descendantFont),
+#endif
+ fMultiByteGlyphs(false),
+ fFirstGlyphID(1),
+ fLastGlyphID(fontInfo ? fontInfo->fLastGlyphID : 0),
+ fFontInfo(fontInfo),
+ fDescriptor(fontDescriptor) {
+ if (fontInfo && fontInfo->fMultiMaster) {
+ NOT_IMPLEMENTED(true, true);
+ fType = SkAdvancedTypefaceMetrics::kOther_Font;
+ }
+ if (fType == SkAdvancedTypefaceMetrics::kType1CID_Font ||
+ fType == SkAdvancedTypefaceMetrics::kTrueType_Font) {
+ if (descendantFont) {
+ populateCIDFont();
+ } else {
+ populateType0Font();
+ }
+ // No need to hold onto the font info for fonts types that
+ // support multibyte glyphs.
+ fFontInfo = NULL;
+ return;
+ }
+
+ if (fType == SkAdvancedTypefaceMetrics::kType1_Font &&
+ populateType1Font(glyphID)) {
+ return;
+ }
+
+ SkASSERT(fType == SkAdvancedTypefaceMetrics::kType1_Font ||
+ fType == SkAdvancedTypefaceMetrics::kCFF_Font ||
+ fType == SkAdvancedTypefaceMetrics::kOther_Font ||
+ fType == SkAdvancedTypefaceMetrics::kNotEmbeddable_Font);
+ populateType3Font(glyphID);
+}
+
+void SkPDFFont::populateType0Font() {
+ fMultiByteGlyphs = true;
+
+ insert("Subtype", new SkPDFName("Type0"))->unref();
+ insert("BaseFont", new SkPDFName(fFontInfo->fFontName))->unref();
+ insert("Encoding", new SkPDFName("Identity-H"))->unref();
+
+ SkRefPtr<SkPDFArray> descendantFonts = new SkPDFArray();
+ descendantFonts->unref(); // SkRefPtr and new took a reference.
+
+ // Pass ref new created to fResources.
+ fResources.push(
+ new SkPDFFont(fFontInfo.get(), fTypeface.get(), 1, true, NULL));
+ descendantFonts->append(new SkPDFObjRef(fResources.top()))->unref();
+ insert("DescendantFonts", descendantFonts.get());
+
+ populateToUnicodeTable();
+}
+
+void SkPDFFont::populateToUnicodeTable() {
+ if (fFontInfo.get() == NULL ||
+ fFontInfo->fGlyphToUnicode.begin() == NULL) {
+ return;
+ }
+
+ SkDynamicMemoryWStream cmap;
+ append_tounicode_header(&cmap);
+ append_cmap_bfchar_sections(fFontInfo->fGlyphToUnicode, &cmap);
+ append_cmap_footer(&cmap);
+ SkRefPtr<SkMemoryStream> cmapStream = new SkMemoryStream();
+ cmapStream->unref(); // SkRefPtr and new took a reference.
+ cmapStream->setMemoryOwned(cmap.detach(), cmap.getOffset());
+ SkRefPtr<SkPDFStream> pdfCmap = new SkPDFStream(cmapStream.get());
+ fResources.push(pdfCmap.get()); // Pass reference from new.
+ insert("ToUnicode", new SkPDFObjRef(pdfCmap.get()))->unref();
+}
+
+void SkPDFFont::populateCIDFont() {
+ fMultiByteGlyphs = true;
+ insert("BaseFont", new SkPDFName(fFontInfo->fFontName))->unref();
+
+ if (fFontInfo->fType == SkAdvancedTypefaceMetrics::kType1CID_Font) {
+ insert("Subtype", new SkPDFName("CIDFontType0"))->unref();
+ } else if (fFontInfo->fType == SkAdvancedTypefaceMetrics::kTrueType_Font) {
+ insert("Subtype", new SkPDFName("CIDFontType2"))->unref();
+ insert("CIDToGIDMap", new SkPDFName("Identity"))->unref();
+ } else {
+ SkASSERT(false);
+ }
+
+ SkRefPtr<SkPDFDict> sysInfo = new SkPDFDict;
+ sysInfo->unref(); // SkRefPtr and new both took a reference.
+ sysInfo->insert("Registry", new SkPDFString("Adobe"))->unref();
+ sysInfo->insert("Ordering", new SkPDFString("Identity"))->unref();
+ sysInfo->insert("Supplement", new SkPDFInt(0))->unref();
+ insert("CIDSystemInfo", sysInfo.get());
+
+ addFontDescriptor(0);
+
+ if (fFontInfo->fGlyphWidths.get()) {
+ int16_t defaultWidth = 0;
+ SkRefPtr<SkPDFArray> widths =
+ composeAdvanceData(fFontInfo->fGlyphWidths.get(),
+ fFontInfo->fEmSize, &appendWidth, &defaultWidth);
+ widths->unref(); // SkRefPtr and compose both took a reference.
+ if (widths->size())
+ insert("W", widths.get());
+ if (defaultWidth != 0) {
+ insert("DW", new SkPDFScalar(scaleFromFontUnits(
+ defaultWidth, fFontInfo->fEmSize)))->unref();
+ }
+ }
+ if (fFontInfo->fVerticalMetrics.get()) {
+ struct SkAdvancedTypefaceMetrics::VerticalMetric defaultAdvance;
+ defaultAdvance.fVerticalAdvance = 0;
+ defaultAdvance.fOriginXDisp = 0;
+ defaultAdvance.fOriginYDisp = 0;
+ SkRefPtr<SkPDFArray> advances =
+ composeAdvanceData(fFontInfo->fVerticalMetrics.get(),
+ fFontInfo->fEmSize, &appendVerticalAdvance,
+ &defaultAdvance);
+ advances->unref(); // SkRefPtr and compose both took a ref.
+ if (advances->size())
+ insert("W2", advances.get());
+ if (defaultAdvance.fVerticalAdvance ||
+ defaultAdvance.fOriginXDisp ||
+ defaultAdvance.fOriginYDisp) {
+ insert("DW2", appendVerticalAdvance(defaultAdvance,
+ fFontInfo->fEmSize,
+ new SkPDFArray))->unref();
+ }
+ }
+}
+
+bool SkPDFFont::populateType1Font(int16_t glyphID) {
+ SkASSERT(!fFontInfo->fVerticalMetrics.get());
+ SkASSERT(fFontInfo->fGlyphWidths.get());
+
+ adjustGlyphRangeForSingleByteEncoding(glyphID);
+
+ int16_t defaultWidth = 0;
+ const SkAdvancedTypefaceMetrics::WidthRange* widthRangeEntry = NULL;
+ const SkAdvancedTypefaceMetrics::WidthRange* widthEntry;
+ for (widthEntry = fFontInfo.get()->fGlyphWidths.get();
+ widthEntry != NULL;
+ widthEntry = widthEntry->fNext.get()) {
+ switch (widthEntry->fType) {
+ case SkAdvancedTypefaceMetrics::WidthRange::kDefault:
+ defaultWidth = widthEntry->fAdvance[0];
+ break;
+ case SkAdvancedTypefaceMetrics::WidthRange::kRun:
+ SkASSERT(false);
+ break;
+ case SkAdvancedTypefaceMetrics::WidthRange::kRange:
+ SkASSERT(widthRangeEntry == NULL);
+ widthRangeEntry = widthEntry;
+ break;
+ }
+ }
+
+ if (!addFontDescriptor(defaultWidth))
+ return false;
+
+ insert("Subtype", new SkPDFName("Type1"))->unref();
+ insert("BaseFont", new SkPDFName(fFontInfo->fFontName))->unref();
+
+ addWidthInfoFromRange(defaultWidth, widthRangeEntry);
+
+ SkRefPtr<SkPDFDict> encoding = new SkPDFDict("Encoding");
+ encoding->unref(); // SkRefPtr and new both took a reference.
+ insert("Encoding", encoding.get());
+
+ SkRefPtr<SkPDFArray> encDiffs = new SkPDFArray;
+ encDiffs->unref(); // SkRefPtr and new both took a reference.
+ encoding->insert("Differences", encDiffs.get());
+
+ encDiffs->reserve(fLastGlyphID - fFirstGlyphID + 2);
+ encDiffs->append(new SkPDFInt(1))->unref();
+ for (int gID = fFirstGlyphID; gID <= fLastGlyphID; gID++) {
+ encDiffs->append(
+ new SkPDFName(fFontInfo->fGlyphNames->get()[gID]))->unref();
+ }
+
+ if (fFontInfo->fLastGlyphID <= 255)
+ fFontInfo = NULL;
+ return true;
+}
+
+void SkPDFFont::populateType3Font(int16_t glyphID) {
+ SkPaint paint;
+ paint.setTypeface(fTypeface.get());
+ paint.setTextSize(1000);
+ SkAutoGlyphCache autoCache(paint, NULL);
+ SkGlyphCache* cache = autoCache.getCache();
+ // If fLastGlyphID isn't set (because there is not fFontInfo), look it up.
+ if (fLastGlyphID == 0) {
+ fLastGlyphID = cache->getGlyphCount() - 1;
+ }
+
+ adjustGlyphRangeForSingleByteEncoding(glyphID);
+
+ insert("Subtype", new SkPDFName("Type3"))->unref();
+ // Flip about the x-axis and scale by 1/1000.
+ SkMatrix fontMatrix;
+ fontMatrix.setScale(SkScalarInvert(1000), -SkScalarInvert(1000));
+ insert("FontMatrix", SkPDFUtils::MatrixToArray(fontMatrix))->unref();
+
+ SkRefPtr<SkPDFDict> charProcs = new SkPDFDict;
+ charProcs->unref(); // SkRefPtr and new both took a reference.
+ insert("CharProcs", charProcs.get());
+
+ SkRefPtr<SkPDFDict> encoding = new SkPDFDict("Encoding");
+ encoding->unref(); // SkRefPtr and new both took a reference.
+ insert("Encoding", encoding.get());
+
+ SkRefPtr<SkPDFArray> encDiffs = new SkPDFArray;
+ encDiffs->unref(); // SkRefPtr and new both took a reference.
+ encoding->insert("Differences", encDiffs.get());
+ encDiffs->reserve(fLastGlyphID - fFirstGlyphID + 2);
+ encDiffs->append(new SkPDFInt(1))->unref();
+
+ SkRefPtr<SkPDFArray> widthArray = new SkPDFArray();
+ widthArray->unref(); // SkRefPtr and new both took a ref.
+
+ SkIRect bbox = SkIRect::MakeEmpty();
+ for (int gID = fFirstGlyphID; gID <= fLastGlyphID; gID++) {
+ SkString characterName;
+ characterName.printf("gid%d", gID);
+ encDiffs->append(new SkPDFName(characterName))->unref();
+
+ const SkGlyph& glyph = cache->getGlyphIDMetrics(gID);
+ widthArray->append(new SkPDFScalar(SkFixedToScalar(glyph.fAdvanceX)))->unref();
+ SkIRect glyphBBox = SkIRect::MakeXYWH(glyph.fLeft, glyph.fTop,
+ glyph.fWidth, glyph.fHeight);
+ bbox.join(glyphBBox);
+
+ SkDynamicMemoryWStream content;
+ setGlyphWidthAndBoundingBox(SkFixedToScalar(glyph.fAdvanceX), glyphBBox,
+ &content);
+ const SkPath* path = cache->findPath(glyph);
+ if (path) {
+ SkPDFUtils::EmitPath(*path, &content);
+ SkPDFUtils::PaintPath(paint.getStyle(), path->getFillType(),
+ &content);
+ }
+ SkRefPtr<SkMemoryStream> glyphStream = new SkMemoryStream();
+ glyphStream->unref(); // SkRefPtr and new both took a ref.
+ glyphStream->setMemoryOwned(content.detach(), content.getOffset());
+
+ SkRefPtr<SkPDFStream> glyphDescription =
+ new SkPDFStream(glyphStream.get());
+ // SkRefPtr and new both ref()'d charProcs, pass one.
+ fResources.push(glyphDescription.get());
+ charProcs->insert(characterName.c_str(),
+ new SkPDFObjRef(glyphDescription.get()))->unref();
+ }
+
+ insert("FontBBox", makeFontBBox(bbox, 1000))->unref();
+ insert("FirstChar", new SkPDFInt(fFirstGlyphID))->unref();
+ insert("LastChar", new SkPDFInt(fLastGlyphID))->unref();
+ insert("Widths", widthArray.get());
+ insert("CIDToGIDMap", new SkPDFName("Identity"))->unref();
+
+ if (fFontInfo && fFontInfo->fLastGlyphID <= 255)
+ fFontInfo = NULL;
+
+ populateToUnicodeTable();
+}
+
+bool SkPDFFont::addFontDescriptor(int16_t defaultWidth) {
+ if (fDescriptor.get() != NULL) {
+ fResources.push(fDescriptor.get());
+ fDescriptor->ref();
+ insert("FontDescriptor", new SkPDFObjRef(fDescriptor.get()))->unref();
+ return true;
+ }
+
+ fDescriptor = new SkPDFDict("FontDescriptor");
+ fDescriptor->unref(); // SkRefPtr and new both took a ref.
+
+ switch (fFontInfo->fType) {
+ case SkAdvancedTypefaceMetrics::kType1_Font: {
+ size_t header SK_INIT_TO_AVOID_WARNING;
+ size_t data SK_INIT_TO_AVOID_WARNING;
+ size_t trailer SK_INIT_TO_AVOID_WARNING;
+ SkRefPtr<SkStream> rawFontData =
+ SkFontHost::OpenStream(SkTypeface::UniqueID(fTypeface.get()));
+ rawFontData->unref(); // SkRefPtr and OpenStream both took a ref.
+ SkStream* fontData = handleType1Stream(rawFontData.get(), &header,
+ &data, &trailer);
+ if (fontData == NULL)
+ return false;
+ SkRefPtr<SkPDFStream> fontStream = new SkPDFStream(fontData);
+ // SkRefPtr and new both ref()'d fontStream, pass one.
+ fResources.push(fontStream.get());
+ fontStream->insert("Length1", new SkPDFInt(header))->unref();
+ fontStream->insert("Length2", new SkPDFInt(data))->unref();
+ fontStream->insert("Length3", new SkPDFInt(trailer))->unref();
+ fDescriptor->insert("FontFile",
+ new SkPDFObjRef(fontStream.get()))->unref();
+ break;
+ }
+ case SkAdvancedTypefaceMetrics::kTrueType_Font: {
+ SkRefPtr<SkStream> fontData =
+ SkFontHost::OpenStream(SkTypeface::UniqueID(fTypeface.get()));
+ fontData->unref(); // SkRefPtr and OpenStream both took a ref.
+ SkRefPtr<SkPDFStream> fontStream = new SkPDFStream(fontData.get());
+ // SkRefPtr and new both ref()'d fontStream, pass one.
+ fResources.push(fontStream.get());
+
+ fontStream->insert("Length1",
+ new SkPDFInt(fontData->getLength()))->unref();
+ fDescriptor->insert("FontFile2",
+ new SkPDFObjRef(fontStream.get()))->unref();
+ break;
+ }
+ case SkAdvancedTypefaceMetrics::kCFF_Font:
+ case SkAdvancedTypefaceMetrics::kType1CID_Font: {
+ SkRefPtr<SkStream> fontData =
+ SkFontHost::OpenStream(SkTypeface::UniqueID(fTypeface.get()));
+ fontData->unref(); // SkRefPtr and OpenStream both took a ref.
+ SkRefPtr<SkPDFStream> fontStream = new SkPDFStream(fontData.get());
+ // SkRefPtr and new both ref()'d fontStream, pass one.
+ fResources.push(fontStream.get());
+
+ if (fFontInfo->fType == SkAdvancedTypefaceMetrics::kCFF_Font) {
+ fontStream->insert("Subtype", new SkPDFName("Type1C"))->unref();
+ } else {
+ fontStream->insert("Subtype",
+ new SkPDFName("CIDFontType0c"))->unref();
+ }
+ fDescriptor->insert("FontFile3",
+ new SkPDFObjRef(fontStream.get()))->unref();
+ break;
+ }
+ default:
+ SkASSERT(false);
+ }
+
+ const uint16_t emSize = fFontInfo->fEmSize;
+ fResources.push(fDescriptor.get());
+ fDescriptor->ref();
+ insert("FontDescriptor", new SkPDFObjRef(fDescriptor.get()))->unref();
+
+ fDescriptor->insert("FontName", new SkPDFName(
+ fFontInfo->fFontName))->unref();
+ fDescriptor->insert("Flags", new SkPDFInt(fFontInfo->fStyle))->unref();
+ fDescriptor->insert("Ascent", new SkPDFScalar(
+ scaleFromFontUnits(fFontInfo->fAscent, emSize)))->unref();
+ fDescriptor->insert("Descent", new SkPDFScalar(
+ scaleFromFontUnits(fFontInfo->fDescent, emSize)))->unref();
+ fDescriptor->insert("StemV", new SkPDFScalar(
+ scaleFromFontUnits(fFontInfo->fStemV, emSize)))->unref();
+ fDescriptor->insert("CapHeight", new SkPDFScalar(
+ scaleFromFontUnits(fFontInfo->fCapHeight, emSize)))->unref();
+ fDescriptor->insert("ItalicAngle", new SkPDFInt(
+ fFontInfo->fItalicAngle))->unref();
+ fDescriptor->insert("FontBBox", makeFontBBox(fFontInfo->fBBox,
+ fFontInfo->fEmSize))->unref();
+
+ if (defaultWidth > 0) {
+ fDescriptor->insert("MissingWidth", new SkPDFScalar(
+ scaleFromFontUnits(defaultWidth, emSize)))->unref();
+ }
+ return true;
+}
+void SkPDFFont::addWidthInfoFromRange(
+ int16_t defaultWidth,
+ const SkAdvancedTypefaceMetrics::WidthRange* widthRangeEntry) {
+ SkRefPtr<SkPDFArray> widthArray = new SkPDFArray();
+ widthArray->unref(); // SkRefPtr and new both took a ref.
+ int firstChar = 0;
+ if (widthRangeEntry) {
+ const uint16_t emSize = fFontInfo->fEmSize;
+ int startIndex = fFirstGlyphID - widthRangeEntry->fStartId;
+ int endIndex = startIndex + fLastGlyphID - fFirstGlyphID + 1;
+ if (startIndex < 0)
+ startIndex = 0;
+ if (endIndex > widthRangeEntry->fAdvance.count())
+ endIndex = widthRangeEntry->fAdvance.count();
+ if (widthRangeEntry->fStartId == 0) {
+ appendWidth(widthRangeEntry->fAdvance[0], emSize, widthArray.get());
+ } else {
+ firstChar = startIndex + widthRangeEntry->fStartId;
+ }
+ for (int i = startIndex; i < endIndex; i++)
+ appendWidth(widthRangeEntry->fAdvance[i], emSize, widthArray.get());
+ } else {
+ appendWidth(defaultWidth, 1000, widthArray.get());
+ }
+ insert("FirstChar", new SkPDFInt(firstChar))->unref();
+ insert("LastChar",
+ new SkPDFInt(firstChar + widthArray->size() - 1))->unref();
+ insert("Widths", widthArray.get());
+}
+
+void SkPDFFont::adjustGlyphRangeForSingleByteEncoding(int16_t glyphID) {
+ // Single byte glyph encoding supports a max of 255 glyphs.
+ fFirstGlyphID = glyphID - (glyphID - 1) % 255;
+ if (fLastGlyphID > fFirstGlyphID + 255 - 1) {
+ fLastGlyphID = fFirstGlyphID + 255 - 1;
+ }
+}
+
+
+bool SkPDFFont::FontRec::operator==(const SkPDFFont::FontRec& b) const {
+ if (fFontID != b.fFontID)
+ return false;
+ if (fFont != NULL && b.fFont != NULL) {
+ return fFont->fFirstGlyphID == b.fFont->fFirstGlyphID &&
+ fFont->fLastGlyphID == b.fFont->fLastGlyphID;
+ }
+ if (fGlyphID == 0 || b.fGlyphID == 0)
+ return true;
+
+ if (fFont != NULL) {
+ return fFont->fFirstGlyphID <= b.fGlyphID &&
+ b.fGlyphID <= fFont->fLastGlyphID;
+ } else if (b.fFont != NULL) {
+ return b.fFont->fFirstGlyphID <= fGlyphID &&
+ fGlyphID <= b.fFont->fLastGlyphID;
+ }
+ return fGlyphID == b.fGlyphID;
+}
+
+SkPDFFont::FontRec::FontRec(SkPDFFont* font, uint32_t fontID, uint16_t glyphID)
+ : fFont(font),
+ fFontID(fontID),
+ fGlyphID(glyphID) {
+}
diff --git a/src/pdf/SkPDFFormXObject.cpp b/src/pdf/SkPDFFormXObject.cpp
new file mode 100644
index 0000000..40a5564
--- /dev/null
+++ b/src/pdf/SkPDFFormXObject.cpp
@@ -0,0 +1,94 @@
+/*
+ * Copyright (C) 2010 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.
+ */
+
+#include "SkPDFFormXObject.h"
+
+#include "SkMatrix.h"
+#include "SkPDFCatalog.h"
+#include "SkPDFDevice.h"
+#include "SkPDFUtils.h"
+#include "SkStream.h"
+#include "SkTypes.h"
+
+SkPDFFormXObject::SkPDFFormXObject(SkPDFDevice* device) {
+ // We don't want to keep around device because we'd have two copies
+ // of content, so reference or copy everything we need (content and
+ // resources).
+ device->getResources(&fResources);
+
+ SkRefPtr<SkStream> content = device->content();
+ content->unref(); // SkRefPtr and content() both took a reference.
+ fStream = new SkPDFStream(content.get());
+ fStream->unref(); // SkRefPtr and new both took a reference.
+
+ insert("Type", new SkPDFName("XObject"))->unref();
+ insert("Subtype", new SkPDFName("Form"))->unref();
+ insert("BBox", device->getMediaBox().get());
+ insert("Resources", device->getResourceDict().get());
+
+ // We invert the initial transform and apply that to the xobject so that
+ // it doesn't get applied twice. We can't just undo it because it's
+ // embedded in things like shaders and images.
+ if (!device->initialTransform().isIdentity()) {
+ SkMatrix inverse;
+ inverse.reset();
+ device->initialTransform().invert(&inverse);
+ insert("Matrix", SkPDFUtils::MatrixToArray(inverse))->unref();
+ }
+
+ // Right now SkPDFFormXObject is only used for saveLayer, which implies
+ // isolated blending. Do this conditionally if that changes.
+ SkRefPtr<SkPDFDict> group = new SkPDFDict("Group");
+ group->unref(); // SkRefPtr and new both took a reference.
+ group->insert("S", new SkPDFName("Transparency"))->unref();
+ group->insert("I", new SkPDFBool(true))->unref(); // Isolated.
+ insert("Group", group.get());
+}
+
+SkPDFFormXObject::~SkPDFFormXObject() {
+ fResources.unrefAll();
+}
+
+void SkPDFFormXObject::emitObject(SkWStream* stream, SkPDFCatalog* catalog,
+ bool indirect) {
+ if (indirect)
+ return emitIndirectObject(stream, catalog);
+
+ fStream->emitObject(stream, catalog, indirect);
+}
+
+size_t SkPDFFormXObject::getOutputSize(SkPDFCatalog* catalog, bool indirect) {
+ if (indirect)
+ return getIndirectOutputSize(catalog);
+
+ return fStream->getOutputSize(catalog, indirect);
+}
+
+void SkPDFFormXObject::getResources(SkTDArray<SkPDFObject*>* resourceList) {
+ resourceList->setReserve(resourceList->count() + fResources.count());
+ for (int i = 0; i < fResources.count(); i++) {
+ resourceList->push(fResources[i]);
+ fResources[i]->ref();
+ }
+}
+
+SkPDFObject* SkPDFFormXObject::insert(SkPDFName* key, SkPDFObject* value) {
+ return fStream->insert(key, value);
+}
+
+SkPDFObject* SkPDFFormXObject::insert(const char key[], SkPDFObject* value) {
+ return fStream->insert(key, value);
+}
diff --git a/src/pdf/SkPDFGraphicState.cpp b/src/pdf/SkPDFGraphicState.cpp
new file mode 100644
index 0000000..b08bf24
--- /dev/null
+++ b/src/pdf/SkPDFGraphicState.cpp
@@ -0,0 +1,294 @@
+/*
+ * Copyright (C) 2011 Google Inc.
+ *
+ * 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.
+ */
+
+#include "SkPDFFormXObject.h"
+#include "SkPDFGraphicState.h"
+#include "SkPDFUtils.h"
+#include "SkStream.h"
+#include "SkTypes.h"
+
+static const char* blend_mode_from_xfermode(SkXfermode::Mode mode) {
+ switch (mode) {
+ case SkXfermode::kSrcOver_Mode: return "Normal";
+ case SkXfermode::kMultiply_Mode: return "Multiply";
+ case SkXfermode::kScreen_Mode: return "Screen";
+ case SkXfermode::kOverlay_Mode: return "Overlay";
+ case SkXfermode::kDarken_Mode: return "Darken";
+ case SkXfermode::kLighten_Mode: return "Lighten";
+ case SkXfermode::kColorDodge_Mode: return "ColorDodge";
+ case SkXfermode::kColorBurn_Mode: return "ColorBurn";
+ case SkXfermode::kHardLight_Mode: return "HardLight";
+ case SkXfermode::kSoftLight_Mode: return "SoftLight";
+ case SkXfermode::kDifference_Mode: return "Difference";
+ case SkXfermode::kExclusion_Mode: return "Exclusion";
+
+ // These are handled in SkPDFDevice::setUpContentEntry.
+ case SkXfermode::kClear_Mode:
+ case SkXfermode::kSrc_Mode:
+ case SkXfermode::kDst_Mode:
+ case SkXfermode::kDstOver_Mode:
+ case SkXfermode::kSrcIn_Mode:
+ case SkXfermode::kDstIn_Mode:
+ case SkXfermode::kSrcOut_Mode:
+ case SkXfermode::kDstOut_Mode:
+ return "Normal";
+
+ // TODO(vandebo) Figure out if we can support more of these modes.
+ case SkXfermode::kSrcATop_Mode:
+ case SkXfermode::kDstATop_Mode:
+ case SkXfermode::kXor_Mode:
+ case SkXfermode::kPlus_Mode:
+ return NULL;
+ }
+ return NULL;
+}
+
+SkPDFGraphicState::~SkPDFGraphicState() {
+ SkAutoMutexAcquire lock(canonicalPaintsMutex());
+ if (!fSMask) {
+ int index = find(fPaint);
+ SkASSERT(index >= 0);
+ canonicalPaints().removeShuffle(index);
+ }
+ fResources.unrefAll();
+}
+
+void SkPDFGraphicState::getResources(SkTDArray<SkPDFObject*>* resourceList) {
+ resourceList->setReserve(resourceList->count() + fResources.count());
+ for (int i = 0; i < fResources.count(); i++) {
+ resourceList->push(fResources[i]);
+ fResources[i]->ref();
+ fResources[i]->getResources(resourceList);
+ }
+}
+
+void SkPDFGraphicState::emitObject(SkWStream* stream, SkPDFCatalog* catalog,
+ bool indirect) {
+ populateDict();
+ SkPDFDict::emitObject(stream, catalog, indirect);
+}
+
+// static
+size_t SkPDFGraphicState::getOutputSize(SkPDFCatalog* catalog, bool indirect) {
+ populateDict();
+ return SkPDFDict::getOutputSize(catalog, indirect);
+}
+
+// static
+SkTDArray<SkPDFGraphicState::GSCanonicalEntry>&
+SkPDFGraphicState::canonicalPaints() {
+ // This initialization is only thread safe with gcc.
+ static SkTDArray<SkPDFGraphicState::GSCanonicalEntry> gCanonicalPaints;
+ return gCanonicalPaints;
+}
+
+// static
+SkMutex& SkPDFGraphicState::canonicalPaintsMutex() {
+ // This initialization is only thread safe with gcc.
+ static SkMutex gCanonicalPaintsMutex;
+ return gCanonicalPaintsMutex;
+}
+
+// static
+SkPDFGraphicState* SkPDFGraphicState::getGraphicStateForPaint(
+ const SkPaint& paint) {
+ SkAutoMutexAcquire lock(canonicalPaintsMutex());
+ int index = find(paint);
+ if (index >= 0) {
+ canonicalPaints()[index].fGraphicState->ref();
+ return canonicalPaints()[index].fGraphicState;
+ }
+ GSCanonicalEntry newEntry(new SkPDFGraphicState(paint));
+ canonicalPaints().push(newEntry);
+ return newEntry.fGraphicState;
+}
+
+// static
+SkPDFObject* SkPDFGraphicState::GetInvertFunction() {
+ // This assumes that canonicalPaintsMutex is held.
+ static SkPDFStream* invertFunction = NULL;
+ if (!invertFunction) {
+ // Acrobat crashes if we use a type 0 function, kpdf crashes if we use
+ // a type 2 function, so we use a type 4 function.
+ SkRefPtr<SkPDFArray> domainAndRange = new SkPDFArray;
+ domainAndRange->unref(); // SkRefPtr and new both took a reference.
+ domainAndRange->reserve(2);
+ domainAndRange->append(new SkPDFInt(0))->unref();
+ domainAndRange->append(new SkPDFInt(1))->unref();
+
+ static const char psInvert[] = "{1 exch sub}";
+ SkRefPtr<SkMemoryStream> psInvertStream =
+ new SkMemoryStream(&psInvert, strlen(psInvert), true);
+ psInvertStream->unref(); // SkRefPtr and new both took a reference.
+
+ invertFunction = new SkPDFStream(psInvertStream.get());
+ invertFunction->insert("FunctionType", new SkPDFInt(4))->unref();
+ invertFunction->insert("Domain", domainAndRange.get());
+ invertFunction->insert("Range", domainAndRange.get());
+ }
+ return invertFunction;
+}
+
+// static
+SkPDFGraphicState* SkPDFGraphicState::getSMaskGraphicState(
+ SkPDFFormXObject* sMask, bool invert) {
+ // The practical chances of using the same mask more than once are unlikely
+ // enough that it's not worth canonicalizing.
+ SkAutoMutexAcquire lock(canonicalPaintsMutex());
+
+ SkRefPtr<SkPDFDict> sMaskDict = new SkPDFDict("Mask");
+ sMaskDict->unref(); // SkRefPtr and new both took a reference.
+ sMaskDict->insert("S", new SkPDFName("Alpha"))->unref();
+ sMaskDict->insert("G", new SkPDFObjRef(sMask))->unref();
+
+ SkPDFGraphicState* result = new SkPDFGraphicState;
+ result->fPopulated = true;
+ result->fSMask = true;
+ result->insert("Type", new SkPDFName("ExtGState"))->unref();
+ result->insert("SMask", sMaskDict.get());
+ result->fResources.push(sMask);
+ sMask->ref();
+
+ if (invert) {
+ SkPDFObject* invertFunction = GetInvertFunction();
+ result->fResources.push(invertFunction);
+ invertFunction->ref();
+ sMaskDict->insert("TR", new SkPDFObjRef(invertFunction))->unref();
+ }
+
+ return result;
+}
+
+// static
+SkPDFGraphicState* SkPDFGraphicState::getNoSMaskGraphicState() {
+ SkAutoMutexAcquire lock(canonicalPaintsMutex());
+ static SkPDFGraphicState* noSMaskGS = NULL;
+ if (!noSMaskGS) {
+ noSMaskGS = new SkPDFGraphicState;
+ noSMaskGS->fPopulated = true;
+ noSMaskGS->fSMask = true;
+ noSMaskGS->insert("Type", new SkPDFName("ExtGState"))->unref();
+ noSMaskGS->insert("SMask", new SkPDFName("None"))->unref();
+ }
+ noSMaskGS->ref();
+ return noSMaskGS;
+}
+
+// static
+int SkPDFGraphicState::find(const SkPaint& paint) {
+ GSCanonicalEntry search(&paint);
+ return canonicalPaints().find(search);
+}
+
+SkPDFGraphicState::SkPDFGraphicState()
+ : fPopulated(false),
+ fSMask(false) {
+}
+
+SkPDFGraphicState::SkPDFGraphicState(const SkPaint& paint)
+ : fPaint(paint),
+ fPopulated(false),
+ fSMask(false) {
+}
+
+// populateDict and operator== have to stay in sync with each other.
+void SkPDFGraphicState::populateDict() {
+ if (!fPopulated) {
+ fPopulated = true;
+ insert("Type", new SkPDFName("ExtGState"))->unref();
+
+ SkRefPtr<SkPDFScalar> alpha =
+ new SkPDFScalar(fPaint.getAlpha() * SkScalarInvert(0xFF));
+ alpha->unref(); // SkRefPtr and new both took a reference.
+ insert("CA", alpha.get());
+ insert("ca", alpha.get());
+
+ SK_COMPILE_ASSERT(SkPaint::kButt_Cap == 0, paint_cap_mismatch);
+ SK_COMPILE_ASSERT(SkPaint::kRound_Cap == 1, paint_cap_mismatch);
+ SK_COMPILE_ASSERT(SkPaint::kSquare_Cap == 2, paint_cap_mismatch);
+ SK_COMPILE_ASSERT(SkPaint::kCapCount == 3, paint_cap_mismatch);
+ SkASSERT(fPaint.getStrokeCap() >= 0 && fPaint.getStrokeCap() <= 2);
+ insert("LC", new SkPDFInt(fPaint.getStrokeCap()))->unref();
+
+ SK_COMPILE_ASSERT(SkPaint::kMiter_Join == 0, paint_join_mismatch);
+ SK_COMPILE_ASSERT(SkPaint::kRound_Join == 1, paint_join_mismatch);
+ SK_COMPILE_ASSERT(SkPaint::kBevel_Join == 2, paint_join_mismatch);
+ SK_COMPILE_ASSERT(SkPaint::kJoinCount == 3, paint_join_mismatch);
+ SkASSERT(fPaint.getStrokeJoin() >= 0 && fPaint.getStrokeJoin() <= 2);
+ insert("LJ", new SkPDFInt(fPaint.getStrokeJoin()))->unref();
+
+ insert("LW", new SkPDFScalar(fPaint.getStrokeWidth()))->unref();
+ insert("ML", new SkPDFScalar(fPaint.getStrokeMiter()))->unref();
+ insert("SA", new SkPDFBool(true))->unref(); // Auto stroke adjustment.
+
+ SkXfermode::Mode xfermode = SkXfermode::kSrcOver_Mode;
+ // If asMode fails, default to kSrcOver_Mode.
+ if (fPaint.getXfermode())
+ fPaint.getXfermode()->asMode(&xfermode);
+ // If we don't support the mode, just use kSrcOver_Mode.
+ if (xfermode < 0 || xfermode > SkXfermode::kLastMode ||
+ blend_mode_from_xfermode(xfermode) == NULL) {
+ xfermode = SkXfermode::kSrcOver_Mode;
+ NOT_IMPLEMENTED("unsupported xfermode", false);
+ }
+ insert("BM",
+ new SkPDFName(blend_mode_from_xfermode(xfermode)))->unref();
+ }
+}
+
+// We're only interested in some fields of the SkPaint, so we have a custom
+// operator== function.
+bool SkPDFGraphicState::GSCanonicalEntry::operator==(
+ const SkPDFGraphicState::GSCanonicalEntry& gs) const {
+ const SkPaint* a = fPaint;
+ const SkPaint* b = gs.fPaint;
+ SkASSERT(a != NULL);
+ SkASSERT(b != NULL);
+
+ if (SkColorGetA(a->getColor()) != SkColorGetA(b->getColor()) ||
+ a->getStrokeCap() != b->getStrokeCap() ||
+ a->getStrokeJoin() != b->getStrokeJoin() ||
+ a->getStrokeWidth() != b->getStrokeWidth() ||
+ a->getStrokeMiter() != b->getStrokeMiter()) {
+ return false;
+ }
+
+ SkXfermode::Mode aXfermodeName = SkXfermode::kSrcOver_Mode;
+ SkXfermode* aXfermode = a->getXfermode();
+ if (aXfermode) {
+ aXfermode->asMode(&aXfermodeName);
+ }
+ if (aXfermodeName < 0 || aXfermodeName > SkXfermode::kLastMode ||
+ blend_mode_from_xfermode(aXfermodeName) == NULL) {
+ aXfermodeName = SkXfermode::kSrcOver_Mode;
+ }
+ const char* aXfermodeString = blend_mode_from_xfermode(aXfermodeName);
+ SkASSERT(aXfermodeString != NULL);
+
+ SkXfermode::Mode bXfermodeName = SkXfermode::kSrcOver_Mode;
+ SkXfermode* bXfermode = b->getXfermode();
+ if (bXfermode) {
+ bXfermode->asMode(&bXfermodeName);
+ }
+ if (bXfermodeName < 0 || bXfermodeName > SkXfermode::kLastMode ||
+ blend_mode_from_xfermode(bXfermodeName) == NULL) {
+ bXfermodeName = SkXfermode::kSrcOver_Mode;
+ }
+ const char* bXfermodeString = blend_mode_from_xfermode(bXfermodeName);
+ SkASSERT(bXfermodeString != NULL);
+
+ return strcmp(aXfermodeString, bXfermodeString) == 0;
+}
diff --git a/src/pdf/SkPDFImage.cpp b/src/pdf/SkPDFImage.cpp
new file mode 100644
index 0000000..be69f7f
--- /dev/null
+++ b/src/pdf/SkPDFImage.cpp
@@ -0,0 +1,382 @@
+/*
+ * Copyright (C) 2010 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.
+ */
+
+#include "SkPDFImage.h"
+
+#include "SkBitmap.h"
+#include "SkColor.h"
+#include "SkColorPriv.h"
+#include "SkPaint.h"
+#include "SkPackBits.h"
+#include "SkPDFCatalog.h"
+#include "SkRect.h"
+#include "SkStream.h"
+#include "SkString.h"
+#include "SkUnPreMultiply.h"
+
+namespace {
+
+void extractImageData(const SkBitmap& bitmap, const SkIRect& srcRect,
+ SkStream** imageData, SkStream** alphaData) {
+ SkMemoryStream* image = NULL;
+ SkMemoryStream* alpha = NULL;
+ bool hasAlpha = false;
+ bool isTransparent = false;
+
+ bitmap.lockPixels();
+ switch (bitmap.getConfig()) {
+ case SkBitmap::kIndex8_Config: {
+ const int rowBytes = srcRect.width();
+ image = new SkMemoryStream(rowBytes * srcRect.height());
+ uint8_t* dst = (uint8_t*)image->getMemoryBase();
+ for (int y = srcRect.fTop; y < srcRect.fBottom; y++) {
+ memcpy(dst, bitmap.getAddr8(srcRect.fLeft, y), rowBytes);
+ dst += rowBytes;
+ }
+ break;
+ }
+ case SkBitmap::kRLE_Index8_Config: {
+ const int rowBytes = srcRect.width();
+ image = new SkMemoryStream(rowBytes * srcRect.height());
+ uint8_t* dst = (uint8_t*)image->getMemoryBase();
+ const SkBitmap::RLEPixels* rle =
+ (const SkBitmap::RLEPixels*)bitmap.getPixels();
+ for (int y = srcRect.fTop; y < srcRect.fBottom; y++) {
+ SkPackBits::Unpack8(dst, srcRect.fLeft, rowBytes,
+ rle->packedAtY(y));
+ dst += rowBytes;
+ }
+ break;
+ }
+ case SkBitmap::kARGB_4444_Config: {
+ isTransparent = true;
+ const int rowBytes = (srcRect.width() * 3 + 1) / 2;
+ const int alphaRowBytes = (srcRect.width() + 1) / 2;
+ image = new SkMemoryStream(rowBytes * srcRect.height());
+ alpha = new SkMemoryStream(alphaRowBytes * srcRect.height());
+ uint8_t* dst = (uint8_t*)image->getMemoryBase();
+ uint8_t* alphaDst = (uint8_t*)alpha->getMemoryBase();
+ for (int y = srcRect.fTop; y < srcRect.fBottom; y++) {
+ uint16_t* src = bitmap.getAddr16(0, y);
+ int x;
+ for (x = srcRect.fLeft; x + 1 < srcRect.fRight; x += 2) {
+ dst[0] = (SkGetPackedR4444(src[x]) << 4) |
+ SkGetPackedG4444(src[x]);
+ dst[1] = (SkGetPackedB4444(src[x]) << 4) |
+ SkGetPackedR4444(src[x + 1]);
+ dst[2] = (SkGetPackedG4444(src[x + 1]) << 4) |
+ SkGetPackedB4444(src[x + 1]);
+ dst += 3;
+ alphaDst[0] = (SkGetPackedA4444(src[x]) << 4) |
+ SkGetPackedA4444(src[x + 1]);
+ if (alphaDst[0] != 0xFF)
+ hasAlpha = true;
+ if (alphaDst[0])
+ isTransparent = false;
+ alphaDst++;
+ }
+ if (srcRect.width() & 1) {
+ dst[0] = (SkGetPackedR4444(src[x]) << 4) |
+ SkGetPackedG4444(src[x]);
+ dst[1] = (SkGetPackedB4444(src[x]) << 4);
+ dst += 2;
+ alphaDst[0] = (SkGetPackedA4444(src[x]) << 4);
+ if (alphaDst[0] != 0xF0)
+ hasAlpha = true;
+ if (alphaDst[0] & 0xF0)
+ isTransparent = false;
+ alphaDst++;
+ }
+ }
+ break;
+ }
+ case SkBitmap::kRGB_565_Config: {
+ const int rowBytes = srcRect.width() * 3;
+ image = new SkMemoryStream(rowBytes * srcRect.height());
+ uint8_t* dst = (uint8_t*)image->getMemoryBase();
+ for (int y = srcRect.fTop; y < srcRect.fBottom; y++) {
+ uint16_t* src = bitmap.getAddr16(0, y);
+ for (int x = srcRect.fLeft; x < srcRect.fRight; x++) {
+ dst[0] = SkGetPackedR16(src[x]);
+ dst[1] = SkGetPackedG16(src[x]);
+ dst[2] = SkGetPackedB16(src[x]);
+ dst += 3;
+ }
+ }
+ break;
+ }
+ case SkBitmap::kARGB_8888_Config: {
+ isTransparent = true;
+ const int rowBytes = srcRect.width() * 3;
+ image = new SkMemoryStream(rowBytes * srcRect.height());
+ alpha = new SkMemoryStream(srcRect.width() * srcRect.height());
+ uint8_t* dst = (uint8_t*)image->getMemoryBase();
+ uint8_t* alphaDst = (uint8_t*)alpha->getMemoryBase();
+ for (int y = srcRect.fTop; y < srcRect.fBottom; y++) {
+ uint32_t* src = bitmap.getAddr32(0, y);
+ for (int x = srcRect.fLeft; x < srcRect.fRight; x++) {
+ dst[0] = SkGetPackedR32(src[x]);
+ dst[1] = SkGetPackedG32(src[x]);
+ dst[2] = SkGetPackedB32(src[x]);
+ dst += 3;
+ alphaDst[0] = SkGetPackedA32(src[x]);
+ if (alphaDst[0] != 0xFF)
+ hasAlpha = true;
+ if (alphaDst[0])
+ isTransparent = false;
+ alphaDst++;
+ }
+ }
+ break;
+ }
+ case SkBitmap::kA1_Config: {
+ isTransparent = true;
+ image = new SkMemoryStream(1);
+ ((uint8_t*)image->getMemoryBase())[0] = 0;
+
+ const int alphaRowBytes = (srcRect.width() + 7) / 8;
+ alpha = new SkMemoryStream(alphaRowBytes * srcRect.height());
+ uint8_t* alphaDst = (uint8_t*)alpha->getMemoryBase();
+ int offset1 = srcRect.fLeft % 8;
+ int offset2 = 8 - offset1;
+ for (int y = srcRect.fTop; y < srcRect.fBottom; y++) {
+ uint8_t* src = bitmap.getAddr1(0, y);
+ // This may read up to one byte after src, but the potentially
+ // invalid bits are never used for computation.
+ for (int x = srcRect.fLeft; x < srcRect.fRight; x += 8) {
+ if (offset1) {
+ alphaDst[0] = src[x / 8] << offset1 |
+ src[x / 8 + 1] >> offset2;
+ } else {
+ alphaDst[0] = src[x / 8];
+ }
+ if (x + 7 < srcRect.fRight && alphaDst[0] != 0xFF)
+ hasAlpha = true;
+ if (x + 7 < srcRect.fRight && alphaDst[0])
+ isTransparent = false;
+ alphaDst++;
+ }
+ // Calculate the mask of bits we're interested in within the
+ // last byte of alphaDst.
+ // width mod 8 == 1 -> 0x80 ... width mod 8 == 7 -> 0xFE
+ uint8_t mask = ~((1 << (8 - (srcRect.width() % 8))) - 1);
+ if (srcRect.width() % 8 && (alphaDst[-1] & mask) != mask)
+ hasAlpha = true;
+ if (srcRect.width() % 8 && (alphaDst[-1] & mask))
+ isTransparent = false;
+ }
+ break;
+ }
+ case SkBitmap::kA8_Config: {
+ isTransparent = true;
+ image = new SkMemoryStream(1);
+ ((uint8_t*)image->getMemoryBase())[0] = 0;
+
+ const int alphaRowBytes = srcRect.width();
+ alpha = new SkMemoryStream(alphaRowBytes * srcRect.height());
+ uint8_t* alphaDst = (uint8_t*)alpha->getMemoryBase();
+ for (int y = srcRect.fTop; y < srcRect.fBottom; y++) {
+ uint8_t* src = bitmap.getAddr8(0, y);
+ for (int x = srcRect.fLeft; x < srcRect.fRight; x++) {
+ alphaDst[0] = src[x];
+ if (alphaDst[0] != 0xFF)
+ hasAlpha = true;
+ if (alphaDst[0])
+ isTransparent = false;
+ alphaDst++;
+ }
+ }
+ break;
+ }
+ default:
+ SkASSERT(false);
+ }
+ bitmap.unlockPixels();
+
+ if (isTransparent) {
+ SkSafeUnref(image);
+ } else {
+ *imageData = image;
+ }
+
+ if (isTransparent || !hasAlpha) {
+ SkSafeUnref(alpha);
+ } else {
+ *alphaData = alpha;
+ }
+}
+
+SkPDFArray* makeIndexedColorSpace(SkColorTable* table) {
+ SkPDFArray* result = new SkPDFArray();
+ result->reserve(4);
+ result->append(new SkPDFName("Indexed"))->unref();
+ result->append(new SkPDFName("DeviceRGB"))->unref();;
+ result->append(new SkPDFInt(table->count() - 1))->unref();
+
+ // Potentially, this could be represented in fewer bytes with a stream.
+ // Max size as a string is 1.5k.
+ SkString index;
+ for (int i = 0; i < table->count(); i++) {
+ char buf[3];
+ SkColor color = SkUnPreMultiply::PMColorToColor((*table)[i]);
+ buf[0] = SkGetPackedR32(color);
+ buf[1] = SkGetPackedG32(color);
+ buf[2] = SkGetPackedB32(color);
+ index.append(buf, 3);
+ }
+ result->append(new SkPDFString(index))->unref();
+ return result;
+}
+
+}; // namespace
+
+// static
+SkPDFImage* SkPDFImage::CreateImage(const SkBitmap& bitmap,
+ const SkIRect& srcRect,
+ const SkPaint& paint) {
+ if (bitmap.getConfig() == SkBitmap::kNo_Config)
+ return NULL;
+
+ SkStream* imageData = NULL;
+ SkStream* alphaData = NULL;
+ extractImageData(bitmap, srcRect, &imageData, &alphaData);
+ SkAutoUnref unrefImageData(imageData);
+ SkAutoUnref unrefAlphaData(alphaData);
+ if (!imageData) {
+ SkASSERT(!alphaData);
+ return NULL;
+ }
+
+ SkPDFImage* image =
+ new SkPDFImage(imageData, bitmap, srcRect, false, paint);
+
+ if (alphaData != NULL) {
+ image->addSMask(new SkPDFImage(alphaData, bitmap, srcRect, true,
+ paint))->unref();
+ }
+ return image;
+}
+
+SkPDFImage::~SkPDFImage() {
+ fResources.unrefAll();
+}
+
+SkPDFImage* SkPDFImage::addSMask(SkPDFImage* mask) {
+ fResources.push(mask);
+ mask->ref();
+ insert("SMask", new SkPDFObjRef(mask))->unref();
+ return mask;
+}
+
+void SkPDFImage::emitObject(SkWStream* stream, SkPDFCatalog* catalog,
+ bool indirect) {
+ if (indirect)
+ return emitIndirectObject(stream, catalog);
+
+ fStream->emitObject(stream, catalog, indirect);
+}
+
+size_t SkPDFImage::getOutputSize(SkPDFCatalog* catalog, bool indirect) {
+ if (indirect)
+ return getIndirectOutputSize(catalog);
+
+ return fStream->getOutputSize(catalog, indirect);
+}
+
+void SkPDFImage::getResources(SkTDArray<SkPDFObject*>* resourceList) {
+ if (fResources.count()) {
+ resourceList->setReserve(resourceList->count() + fResources.count());
+ for (int i = 0; i < fResources.count(); i++) {
+ resourceList->push(fResources[i]);
+ fResources[i]->ref();
+ fResources[i]->getResources(resourceList);
+ }
+ }
+}
+
+SkPDFImage::SkPDFImage(SkStream* imageData, const SkBitmap& bitmap,
+ const SkIRect& srcRect, bool doingAlpha,
+ const SkPaint& paint) {
+ fStream = new SkPDFStream(imageData);
+ fStream->unref(); // SkRefPtr and new both took a reference.
+
+ SkBitmap::Config config = bitmap.getConfig();
+ bool alphaOnly = (config == SkBitmap::kA1_Config ||
+ config == SkBitmap::kA8_Config);
+
+ insert("Type", new SkPDFName("XObject"))->unref();
+ insert("Subtype", new SkPDFName("Image"))->unref();
+
+ if (!doingAlpha && alphaOnly) {
+ // For alpha only images, we stretch a single pixel of black for
+ // the color/shape part.
+ SkRefPtr<SkPDFInt> one = new SkPDFInt(1);
+ one->unref(); // SkRefPtr and new both took a reference.
+ insert("Width", one.get());
+ insert("Height", one.get());
+ } else {
+ insert("Width", new SkPDFInt(srcRect.width()))->unref();
+ insert("Height", new SkPDFInt(srcRect.height()))->unref();
+ }
+
+ // if (!image mask) {
+ if (doingAlpha || alphaOnly) {
+ insert("ColorSpace", new SkPDFName("DeviceGray"))->unref();
+ } else if (config == SkBitmap::kIndex8_Config ||
+ config == SkBitmap::kRLE_Index8_Config) {
+ insert("ColorSpace",
+ makeIndexedColorSpace(bitmap.getColorTable()))->unref();
+ } else {
+ insert("ColorSpace", new SkPDFName("DeviceRGB"))->unref();
+ }
+ // }
+
+ int bitsPerComp = 8;
+ if (config == SkBitmap::kARGB_4444_Config)
+ bitsPerComp = 4;
+ else if (doingAlpha && config == SkBitmap::kA1_Config)
+ bitsPerComp = 1;
+ insert("BitsPerComponent", new SkPDFInt(bitsPerComp))->unref();
+
+ if (config == SkBitmap::kRGB_565_Config) {
+ SkRefPtr<SkPDFInt> zeroVal = new SkPDFInt(0);
+ zeroVal->unref(); // SkRefPtr and new both took a reference.
+ SkRefPtr<SkPDFScalar> scale5Val =
+ new SkPDFScalar(8.2258f); // 255/2^5-1
+ scale5Val->unref(); // SkRefPtr and new both took a reference.
+ SkRefPtr<SkPDFScalar> scale6Val =
+ new SkPDFScalar(4.0476f); // 255/2^6-1
+ scale6Val->unref(); // SkRefPtr and new both took a reference.
+ SkRefPtr<SkPDFArray> decodeValue = new SkPDFArray();
+ decodeValue->unref(); // SkRefPtr and new both took a reference.
+ decodeValue->reserve(6);
+ decodeValue->append(zeroVal.get());
+ decodeValue->append(scale5Val.get());
+ decodeValue->append(zeroVal.get());
+ decodeValue->append(scale6Val.get());
+ decodeValue->append(zeroVal.get());
+ decodeValue->append(scale5Val.get());
+ insert("Decode", decodeValue.get());
+ }
+}
+
+SkPDFObject* SkPDFImage::insert(SkPDFName* key, SkPDFObject* value) {
+ return fStream->insert(key, value);
+}
+
+SkPDFObject* SkPDFImage::insert(const char key[], SkPDFObject* value) {
+ return fStream->insert(key, value);
+}
diff --git a/src/pdf/SkPDFPage.cpp b/src/pdf/SkPDFPage.cpp
new file mode 100644
index 0000000..2a8183d
--- /dev/null
+++ b/src/pdf/SkPDFPage.cpp
@@ -0,0 +1,142 @@
+/*
+ * Copyright (C) 2010 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.
+ */
+
+#include "SkPDFCatalog.h"
+#include "SkPDFDevice.h"
+#include "SkPDFPage.h"
+#include "SkStream.h"
+
+SkPDFPage::SkPDFPage(const SkRefPtr<SkPDFDevice>& content)
+ : SkPDFDict("Page"),
+ fDevice(content) {
+}
+
+SkPDFPage::~SkPDFPage() {}
+
+void SkPDFPage::finalizePage(SkPDFCatalog* catalog, bool firstPage,
+ SkTDArray<SkPDFObject*>* resourceObjects) {
+ if (fContentStream.get() == NULL) {
+ insert("Resources", fDevice->getResourceDict().get());
+ insert("MediaBox", fDevice->getMediaBox().get());
+
+ SkRefPtr<SkStream> content = fDevice->content();
+ content->unref(); // SkRefPtr and content() both took a reference.
+ fContentStream = new SkPDFStream(content.get());
+ fContentStream->unref(); // SkRefPtr and new both took a reference.
+ insert("Contents", new SkPDFObjRef(fContentStream.get()))->unref();
+ }
+ catalog->addObject(fContentStream.get(), firstPage);
+ fDevice->getResources(resourceObjects);
+}
+
+off_t SkPDFPage::getPageSize(SkPDFCatalog* catalog, off_t fileOffset) {
+ SkASSERT(fContentStream.get() != NULL);
+ catalog->setFileOffset(fContentStream.get(), fileOffset);
+ return fContentStream->getOutputSize(catalog, true);
+}
+
+void SkPDFPage::emitPage(SkWStream* stream, SkPDFCatalog* catalog) {
+ SkASSERT(fContentStream.get() != NULL);
+ fContentStream->emitObject(stream, catalog, true);
+}
+
+// static
+void SkPDFPage::generatePageTree(const SkTDArray<SkPDFPage*>& pages,
+ SkPDFCatalog* catalog,
+ SkTDArray<SkPDFDict*>* pageTree,
+ SkPDFDict** rootNode) {
+ // PDF wants a tree describing all the pages in the document. We arbitrary
+ // choose 8 (kNodeSize) as the number of allowed children. The internal
+ // nodes have type "Pages" with an array of children, a parent pointer, and
+ // the number of leaves below the node as "Count." The leaves are passed
+ // into the method, have type "Page" and need a parent pointer. This method
+ // builds the tree bottom up, skipping internal nodes that would have only
+ // one child.
+ static const int kNodeSize = 8;
+
+ SkRefPtr<SkPDFName> kidsName = new SkPDFName("Kids");
+ kidsName->unref(); // SkRefPtr and new both took a reference.
+ SkRefPtr<SkPDFName> countName = new SkPDFName("Count");
+ countName->unref(); // SkRefPtr and new both took a reference.
+ SkRefPtr<SkPDFName> parentName = new SkPDFName("Parent");
+ parentName->unref(); // SkRefPtr and new both took a reference.
+
+ // curNodes takes a reference to its items, which it passes to pageTree.
+ SkTDArray<SkPDFDict*> curNodes;
+ curNodes.setReserve(pages.count());
+ for (int i = 0; i < pages.count(); i++) {
+ SkSafeRef(pages[i]);
+ curNodes.push(pages[i]);
+ }
+
+ // nextRoundNodes passes its references to nodes on to curNodes.
+ SkTDArray<SkPDFDict*> nextRoundNodes;
+ nextRoundNodes.setReserve((pages.count() + kNodeSize - 1)/kNodeSize);
+
+ int treeCapacity = kNodeSize;
+ do {
+ for (int i = 0; i < curNodes.count(); ) {
+ if (i > 0 && i + 1 == curNodes.count()) {
+ nextRoundNodes.push(curNodes[i]);
+ break;
+ }
+
+ SkPDFDict* newNode = new SkPDFDict("Pages");
+ SkRefPtr<SkPDFObjRef> newNodeRef = new SkPDFObjRef(newNode);
+ newNodeRef->unref(); // SkRefPtr and new both took a reference.
+
+ SkRefPtr<SkPDFArray> kids = new SkPDFArray;
+ kids->unref(); // SkRefPtr and new both took a reference.
+ kids->reserve(kNodeSize);
+
+ int count = 0;
+ for (; i < curNodes.count() && count < kNodeSize; i++, count++) {
+ curNodes[i]->insert(parentName.get(), newNodeRef.get());
+ kids->append(new SkPDFObjRef(curNodes[i]))->unref();
+
+ // TODO(vandebo) put the objects in strict access order.
+ // Probably doesn't matter because they are so small.
+ if (curNodes[i] != pages[0]) {
+ pageTree->push(curNodes[i]); // Transfer reference.
+ catalog->addObject(curNodes[i], false);
+ } else {
+ SkSafeUnref(curNodes[i]);
+ }
+ }
+
+ newNode->insert(kidsName.get(), kids.get());
+ int pageCount = treeCapacity;
+ if (count < kNodeSize) {
+ pageCount = pages.count() % treeCapacity;
+ }
+ newNode->insert(countName.get(), new SkPDFInt(pageCount))->unref();
+ nextRoundNodes.push(newNode); // Transfer reference.
+ }
+
+ curNodes = nextRoundNodes;
+ nextRoundNodes.rewind();
+ treeCapacity *= kNodeSize;
+ } while(curNodes.count() > 1);
+
+ pageTree->push(curNodes[0]); // Transfer reference.
+ catalog->addObject(curNodes[0], false);
+ if (rootNode)
+ *rootNode = curNodes[0];
+}
+
+const SkTDArray<SkPDFFont*>& SkPDFPage::getFontResources() const {
+ return fDevice->getFontResources();
+}
diff --git a/src/pdf/SkPDFShader.cpp b/src/pdf/SkPDFShader.cpp
new file mode 100644
index 0000000..6845e09
--- /dev/null
+++ b/src/pdf/SkPDFShader.cpp
@@ -0,0 +1,778 @@
+/*
+ * Copyright (C) 2011 Google Inc.
+ *
+ * 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.
+ */
+
+#include "SkPDFShader.h"
+
+#include "SkCanvas.h"
+#include "SkPDFCatalog.h"
+#include "SkPDFDevice.h"
+#include "SkPDFTypes.h"
+#include "SkPDFUtils.h"
+#include "SkScalar.h"
+#include "SkStream.h"
+#include "SkTemplates.h"
+#include "SkThread.h"
+#include "SkTypes.h"
+
+static void transformBBox(const SkMatrix& matrix, SkRect* bbox) {
+ SkMatrix inverse;
+ inverse.reset();
+ matrix.invert(&inverse);
+ inverse.mapRect(bbox);
+}
+
+static void unitToPointsMatrix(const SkPoint pts[2], SkMatrix* matrix) {
+ SkVector vec = pts[1] - pts[0];
+ SkScalar mag = vec.length();
+ SkScalar inv = mag ? SkScalarInvert(mag) : 0;
+
+ vec.scale(inv);
+ matrix->setSinCos(vec.fY, vec.fX);
+ matrix->preTranslate(pts[0].fX, pts[0].fY);
+ matrix->preScale(mag, mag);
+}
+
+/* Assumes t + startOffset is on the stack and does a linear interpolation on t
+ between startOffset and endOffset from prevColor to curColor (for each color
+ component), leaving the result in component order on the stack.
+ @param range endOffset - startOffset
+ @param curColor[components] The current color components.
+ @param prevColor[components] The previous color components.
+ @param result The result ps function.
+ */
+static void interpolateColorCode(SkScalar range, SkScalar* curColor,
+ SkScalar* prevColor, int components,
+ SkString* result) {
+ // Figure out how to scale each color component.
+ SkAutoSTMalloc<4, SkScalar> multiplierAlloc(components);
+ SkScalar *multiplier = multiplierAlloc.get();
+ for (int i = 0; i < components; i++) {
+ multiplier[i] = SkScalarDiv(curColor[i] - prevColor[i], range);
+ }
+
+ // Calculate when we no longer need to keep a copy of the input parameter t.
+ // If the last component to use t is i, then dupInput[0..i - 1] = true
+ // and dupInput[i .. components] = false.
+ SkAutoSTMalloc<4, bool> dupInputAlloc(components);
+ bool *dupInput = dupInputAlloc.get();
+ dupInput[components - 1] = false;
+ for (int i = components - 2; i >= 0; i--) {
+ dupInput[i] = dupInput[i + 1] || multiplier[i + 1] != 0;
+ }
+
+ if (!dupInput[0] && multiplier[0] == 0) {
+ result->append("pop ");
+ }
+
+ for (int i = 0; i < components; i++) {
+ // If the next components needs t, make a copy.
+ if (dupInput[i]) {
+ result->append("dup ");
+ }
+
+ if (multiplier[i] == 0) {
+ result->appendScalar(prevColor[i]);
+ result->append(" ");
+ } else {
+ if (multiplier[i] != 1) {
+ result->appendScalar(multiplier[i]);
+ result->append(" mul ");
+ }
+ if (prevColor[i] != 0) {
+ result->appendScalar(prevColor[i]);
+ result->append(" add ");
+ }
+ }
+
+ if (dupInput[i]) {
+ result->append("exch\n");
+ }
+ }
+}
+
+/* Generate Type 4 function code to map t=[0,1) to the passed gradient,
+ clamping at the edges of the range. The generated code will be of the form:
+ if (t < 0) {
+ return colorData[0][r,g,b];
+ } else {
+ if (t < info.fColorOffsets[1]) {
+ return linearinterpolation(colorData[0][r,g,b],
+ colorData[1][r,g,b]);
+ } else {
+ if (t < info.fColorOffsets[2]) {
+ return linearinterpolation(colorData[1][r,g,b],
+ colorData[2][r,g,b]);
+ } else {
+
+ ... } else {
+ return colorData[info.fColorCount - 1][r,g,b];
+ }
+ ...
+ }
+ }
+ */
+static void gradientFunctionCode(const SkShader::GradientInfo& info,
+ SkString* result) {
+ /* We want to linearly interpolate from the previous color to the next.
+ Scale the colors from 0..255 to 0..1 and determine the multipliers
+ for interpolation.
+ C{r,g,b}(t, section) = t - offset_(section-1) + t * Multiplier{r,g,b}.
+ */
+ static const int kColorComponents = 3;
+ typedef SkScalar ColorTuple[kColorComponents];
+ SkAutoSTMalloc<4, ColorTuple> colorDataAlloc(info.fColorCount);
+ ColorTuple *colorData = colorDataAlloc.get();
+ const SkScalar scale = SkScalarInvert(SkIntToScalar(255));
+ for (int i = 0; i < info.fColorCount; i++) {
+ colorData[i][0] = SkScalarMul(SkColorGetR(info.fColors[i]), scale);
+ colorData[i][1] = SkScalarMul(SkColorGetG(info.fColors[i]), scale);
+ colorData[i][2] = SkScalarMul(SkColorGetB(info.fColors[i]), scale);
+ }
+
+ // Clamp the initial color.
+ result->append("dup 0 le {pop ");
+ result->appendScalar(colorData[0][0]);
+ result->append(" ");
+ result->appendScalar(colorData[0][1]);
+ result->append(" ");
+ result->appendScalar(colorData[0][2]);
+ result->append(" }\n");
+
+ // The gradient colors.
+ for (int i = 1 ; i < info.fColorCount; i++) {
+ result->append("{dup ");
+ result->appendScalar(info.fColorOffsets[i]);
+ result->append(" le {");
+ if (info.fColorOffsets[i - 1] != 0) {
+ result->appendScalar(info.fColorOffsets[i - 1]);
+ result->append(" sub\n");
+ }
+
+ interpolateColorCode(info.fColorOffsets[i] - info.fColorOffsets[i - 1],
+ colorData[i], colorData[i - 1], kColorComponents,
+ result);
+ result->append("}\n");
+ }
+
+ // Clamp the final color.
+ result->append("{pop ");
+ result->appendScalar(colorData[info.fColorCount - 1][0]);
+ result->append(" ");
+ result->appendScalar(colorData[info.fColorCount - 1][1]);
+ result->append(" ");
+ result->appendScalar(colorData[info.fColorCount - 1][2]);
+
+ for (int i = 0 ; i < info.fColorCount; i++) {
+ result->append("} ifelse\n");
+ }
+}
+
+/* Map a value of t on the stack into [0, 1) for Repeat or Mirror tile mode. */
+static void tileModeCode(SkShader::TileMode mode, SkString* result) {
+ if (mode == SkShader::kRepeat_TileMode) {
+ result->append("dup truncate sub\n"); // Get the fractional part.
+ result->append("dup 0 le {1 add} if\n"); // Map (-1,0) => (0,1)
+ return;
+ }
+
+ if (mode == SkShader::kMirror_TileMode) {
+ // Map t mod 2 into [0, 1, 1, 0].
+ // Code Stack
+ result->append("abs " // Map negative to positive.
+ "dup " // t.s t.s
+ "truncate " // t.s t
+ "dup " // t.s t t
+ "cvi " // t.s t T
+ "2 mod " // t.s t (i mod 2)
+ "1 eq " // t.s t true|false
+ "3 1 roll " // true|false t.s t
+ "sub " // true|false 0.s
+ "exch " // 0.s true|false
+ "{1 exch sub} if\n"); // 1 - 0.s|0.s
+ }
+}
+
+static SkString linearCode(const SkShader::GradientInfo& info) {
+ SkString function("{pop\n"); // Just ditch the y value.
+ tileModeCode(info.fTileMode, &function);
+ gradientFunctionCode(info, &function);
+ function.append("}");
+ return function;
+}
+
+static SkString radialCode(const SkShader::GradientInfo& info) {
+ SkString function("{");
+ // Find the distance from the origin.
+ function.append("dup " // x y y
+ "mul " // x y^2
+ "exch " // y^2 x
+ "dup " // y^2 x x
+ "mul " // y^2 x^2
+ "add " // y^2+x^2
+ "sqrt\n"); // sqrt(y^2+x^2)
+
+ tileModeCode(info.fTileMode, &function);
+ gradientFunctionCode(info, &function);
+ function.append("}");
+ return function;
+}
+
+/* The math here is all based on the description in Two_Point_Radial_Gradient,
+ with one simplification, the coordinate space has been scaled so that
+ Dr = 1. This means we don't need to scale the entire equation by 1/Dr^2.
+ */
+static SkString twoPointRadialCode(const SkShader::GradientInfo& info) {
+ SkScalar dx = info.fPoint[0].fX - info.fPoint[1].fX;
+ SkScalar dy = info.fPoint[0].fY - info.fPoint[1].fY;
+ SkScalar sr = info.fRadius[0];
+ SkScalar a = SkScalarMul(dx, dx) + SkScalarMul(dy, dy) - SK_Scalar1;
+ bool posRoot = info.fRadius[1] > info.fRadius[0];
+
+ // We start with a stack of (x y), copy it and then consume one copy in
+ // order to calculate b and the other to calculate c.
+ SkString function("{");
+ function.append("2 copy ");
+
+ // Calculate -b and b^2.
+ function.appendScalar(dy);
+ function.append(" mul exch ");
+ function.appendScalar(dx);
+ function.append(" mul add ");
+ function.appendScalar(sr);
+ function.append(" sub 2 mul neg dup dup mul\n");
+
+ // Calculate c
+ function.append("4 2 roll dup mul exch dup mul add ");
+ function.appendScalar(SkScalarMul(sr, sr));
+ function.append(" sub\n");
+
+ // Calculate the determinate
+ function.appendScalar(SkScalarMul(SkIntToScalar(4), a));
+ function.append(" mul sub abs sqrt\n");
+
+ // And then the final value of t.
+ if (posRoot) {
+ function.append("sub ");
+ } else {
+ function.append("add ");
+ }
+ function.appendScalar(SkScalarMul(SkIntToScalar(2), a));
+ function.append(" div\n");
+
+ tileModeCode(info.fTileMode, &function);
+ gradientFunctionCode(info, &function);
+ function.append("}");
+ return function;
+}
+
+static SkString sweepCode(const SkShader::GradientInfo& info) {
+ SkString function("{exch atan 360 div\n");
+ tileModeCode(info.fTileMode, &function);
+ gradientFunctionCode(info, &function);
+ function.append("}");
+ return function;
+}
+
+SkPDFShader::~SkPDFShader() {
+ SkAutoMutexAcquire lock(canonicalShadersMutex());
+ ShaderCanonicalEntry entry(this, fState.get());
+ int index = canonicalShaders().find(entry);
+ SkASSERT(index >= 0);
+ canonicalShaders().removeShuffle(index);
+ fResources.unrefAll();
+}
+
+void SkPDFShader::emitObject(SkWStream* stream, SkPDFCatalog* catalog,
+ bool indirect) {
+ if (indirect)
+ return emitIndirectObject(stream, catalog);
+
+ fContent->emitObject(stream, catalog, indirect);
+}
+
+size_t SkPDFShader::getOutputSize(SkPDFCatalog* catalog, bool indirect) {
+ if (indirect)
+ return getIndirectOutputSize(catalog);
+
+ return fContent->getOutputSize(catalog, indirect);
+}
+
+void SkPDFShader::getResources(SkTDArray<SkPDFObject*>* resourceList) {
+ resourceList->setReserve(resourceList->count() + fResources.count());
+ for (int i = 0; i < fResources.count(); i++) {
+ resourceList->push(fResources[i]);
+ fResources[i]->ref();
+ }
+}
+
+// static
+SkPDFShader* SkPDFShader::getPDFShader(const SkShader& shader,
+ const SkMatrix& matrix,
+ const SkIRect& surfaceBBox) {
+ SkRefPtr<SkPDFShader> pdfShader;
+ SkAutoMutexAcquire lock(canonicalShadersMutex());
+ SkAutoTDelete<State> shaderState(new State(shader, matrix, surfaceBBox));
+
+ ShaderCanonicalEntry entry(NULL, shaderState.get());
+ int index = canonicalShaders().find(entry);
+ if (index >= 0) {
+ SkPDFShader* result = canonicalShaders()[index].fPDFShader;
+ result->ref();
+ return result;
+ }
+ // The PDFShader takes ownership of the shaderSate.
+ pdfShader = new SkPDFShader(shaderState.detach());
+ // Check for a valid shader.
+ if (pdfShader->fContent.get() == NULL) {
+ pdfShader->unref();
+ return NULL;
+ }
+ entry.fPDFShader = pdfShader.get();
+ canonicalShaders().push(entry);
+ return pdfShader.get(); // return the reference that came from new.
+}
+
+// static
+SkTDArray<SkPDFShader::ShaderCanonicalEntry>& SkPDFShader::canonicalShaders() {
+ // This initialization is only thread safe with gcc.
+ static SkTDArray<ShaderCanonicalEntry> gCanonicalShaders;
+ return gCanonicalShaders;
+}
+
+// static
+SkMutex& SkPDFShader::canonicalShadersMutex() {
+ // This initialization is only thread safe with gcc.
+ static SkMutex gCanonicalShadersMutex;
+ return gCanonicalShadersMutex;
+}
+
+// static
+SkPDFObject* SkPDFShader::rangeObject() {
+ // This initialization is only thread safe with gcc.
+ static SkPDFArray* range = NULL;
+ // This method is only used with canonicalShadersMutex, so it's safe to
+ // populate domain.
+ if (range == NULL) {
+ range = new SkPDFArray;
+ range->reserve(6);
+ range->append(new SkPDFInt(0))->unref();
+ range->append(new SkPDFInt(1))->unref();
+ range->append(new SkPDFInt(0))->unref();
+ range->append(new SkPDFInt(1))->unref();
+ range->append(new SkPDFInt(0))->unref();
+ range->append(new SkPDFInt(1))->unref();
+ }
+ return range;
+}
+
+SkPDFShader::SkPDFShader(State* state) : fState(state) {
+ if (fState.get()->fType == SkShader::kNone_GradientType) {
+ doImageShader();
+ } else {
+ doFunctionShader();
+ }
+}
+
+void SkPDFShader::doFunctionShader() {
+ SkString (*codeFunction)(const SkShader::GradientInfo& info) = NULL;
+ SkPoint transformPoints[2];
+
+ // Depending on the type of the gradient, we want to transform the
+ // coordinate space in different ways.
+ const SkShader::GradientInfo* info = &fState.get()->fInfo;
+ transformPoints[0] = info->fPoint[0];
+ transformPoints[1] = info->fPoint[1];
+ switch (fState.get()->fType) {
+ case SkShader::kLinear_GradientType:
+ codeFunction = &linearCode;
+ break;
+ case SkShader::kRadial_GradientType:
+ transformPoints[1] = transformPoints[0];
+ transformPoints[1].fX += info->fRadius[0];
+ codeFunction = &radialCode;
+ break;
+ case SkShader::kRadial2_GradientType: {
+ // Bail out if the radii are the same. Not setting fContent will
+ // cause the higher level code to detect the resulting object
+ // as invalid.
+ if (info->fRadius[0] == info->fRadius[1]) {
+ return;
+ }
+ transformPoints[1] = transformPoints[0];
+ SkScalar dr = info->fRadius[1] - info->fRadius[0];
+ transformPoints[1].fX += dr;
+ codeFunction = &twoPointRadialCode;
+ break;
+ }
+ case SkShader::kSweep_GradientType:
+ transformPoints[1] = transformPoints[0];
+ transformPoints[1].fX += 1;
+ codeFunction = &sweepCode;
+ break;
+ case SkShader::kColor_GradientType:
+ case SkShader::kNone_GradientType:
+ SkASSERT(false);
+ return;
+ }
+
+ // Move any scaling (assuming a unit gradient) or translation
+ // (and rotation for linear gradient), of the final gradient from
+ // info->fPoints to the matrix (updating bbox appropriately). Now
+ // the gradient can be drawn on on the unit segment.
+ SkMatrix mapperMatrix;
+ unitToPointsMatrix(transformPoints, &mapperMatrix);
+ SkMatrix finalMatrix = fState.get()->fCanvasTransform;
+ finalMatrix.preConcat(mapperMatrix);
+ finalMatrix.preConcat(fState.get()->fShaderTransform);
+ SkRect bbox;
+ bbox.set(fState.get()->fBBox);
+ transformBBox(finalMatrix, &bbox);
+
+ SkRefPtr<SkPDFArray> domain = new SkPDFArray;
+ domain->unref(); // SkRefPtr and new both took a reference.
+ domain->reserve(4);
+ domain->append(new SkPDFScalar(bbox.fLeft))->unref();
+ domain->append(new SkPDFScalar(bbox.fRight))->unref();
+ domain->append(new SkPDFScalar(bbox.fTop))->unref();
+ domain->append(new SkPDFScalar(bbox.fBottom))->unref();
+
+ SkString functionCode;
+ // The two point radial gradient further references fState.get()->fInfo
+ // in translating from x, y coordinates to the t parameter. So, we have
+ // to transform the points and radii according to the calculated matrix.
+ if (fState.get()->fType == SkShader::kRadial2_GradientType) {
+ SkShader::GradientInfo twoPointRadialInfo = *info;
+ SkMatrix inverseMapperMatrix;
+ mapperMatrix.invert(&inverseMapperMatrix);
+ inverseMapperMatrix.mapPoints(twoPointRadialInfo.fPoint, 2);
+ twoPointRadialInfo.fRadius[0] =
+ inverseMapperMatrix.mapRadius(info->fRadius[0]);
+ twoPointRadialInfo.fRadius[1] =
+ inverseMapperMatrix.mapRadius(info->fRadius[1]);
+ functionCode = codeFunction(twoPointRadialInfo);
+ } else {
+ functionCode = codeFunction(*info);
+ }
+
+ SkRefPtr<SkPDFStream> function = makePSFunction(functionCode, domain.get());
+ // Pass one reference to fResources, SkRefPtr and new both took a reference.
+ fResources.push(function.get());
+
+ SkRefPtr<SkPDFDict> pdfShader = new SkPDFDict;
+ pdfShader->unref(); // SkRefPtr and new both took a reference.
+ pdfShader->insert("ShadingType", new SkPDFInt(1))->unref();
+ pdfShader->insert("ColorSpace", new SkPDFName("DeviceRGB"))->unref();
+ pdfShader->insert("Domain", domain.get());
+ pdfShader->insert("Function", new SkPDFObjRef(function.get()))->unref();
+
+ fContent = new SkPDFDict("Pattern");
+ fContent->unref(); // SkRefPtr and new both took a reference.
+ fContent->insert("PatternType", new SkPDFInt(2))->unref();
+ fContent->insert("Matrix", SkPDFUtils::MatrixToArray(finalMatrix))->unref();
+ fContent->insert("Shading", pdfShader.get());
+}
+
+// SkShader* shader, SkMatrix matrix, const SkRect& surfaceBBox
+void SkPDFShader::doImageShader() {
+ fState.get()->fImage.lockPixels();
+
+ SkMatrix finalMatrix = fState.get()->fCanvasTransform;
+ finalMatrix.preConcat(fState.get()->fShaderTransform);
+ SkRect surfaceBBox;
+ surfaceBBox.set(fState.get()->fBBox);
+ transformBBox(finalMatrix, &surfaceBBox);
+
+ SkMatrix unflip;
+ unflip.setTranslate(0, SkScalarRound(surfaceBBox.height()));
+ unflip.preScale(1, -1);
+ SkISize size = SkISize::Make(SkScalarRound(surfaceBBox.width()),
+ SkScalarRound(surfaceBBox.height()));
+ SkPDFDevice pattern(size, size, unflip);
+ SkCanvas canvas(&pattern);
+ canvas.translate(-surfaceBBox.fLeft, -surfaceBBox.fTop);
+ finalMatrix.preTranslate(surfaceBBox.fLeft, surfaceBBox.fTop);
+
+ const SkBitmap* image = &fState.get()->fImage;
+ int width = image->width();
+ int height = image->height();
+ SkShader::TileMode tileModes[2];
+ tileModes[0] = fState.get()->fImageTileModes[0];
+ tileModes[1] = fState.get()->fImageTileModes[1];
+
+ canvas.drawBitmap(*image, 0, 0);
+ SkRect patternBBox = SkRect::MakeXYWH(-surfaceBBox.fLeft, -surfaceBBox.fTop,
+ width, height);
+
+ // Tiling is implied. First we handle mirroring.
+ if (tileModes[0] == SkShader::kMirror_TileMode) {
+ SkMatrix xMirror;
+ xMirror.setScale(-1, 1);
+ xMirror.postTranslate(2 * width, 0);
+ canvas.drawBitmapMatrix(*image, xMirror);
+ patternBBox.fRight += width;
+ }
+ if (tileModes[1] == SkShader::kMirror_TileMode) {
+ SkMatrix yMirror;
+ yMirror.setScale(1, -1);
+ yMirror.postTranslate(0, 2 * height);
+ canvas.drawBitmapMatrix(*image, yMirror);
+ patternBBox.fBottom += height;
+ }
+ if (tileModes[0] == SkShader::kMirror_TileMode &&
+ tileModes[1] == SkShader::kMirror_TileMode) {
+ SkMatrix mirror;
+ mirror.setScale(-1, -1);
+ mirror.postTranslate(2 * width, 2 * height);
+ canvas.drawBitmapMatrix(*image, mirror);
+ }
+
+ // Then handle Clamping, which requires expanding the pattern canvas to
+ // cover the entire surfaceBBox.
+
+ // If both x and y are in clamp mode, we start by filling in the corners.
+ // (Which are just a rectangles of the corner colors.)
+ if (tileModes[0] == SkShader::kClamp_TileMode &&
+ tileModes[1] == SkShader::kClamp_TileMode) {
+ SkPaint paint;
+ SkRect rect;
+ rect = SkRect::MakeLTRB(surfaceBBox.fLeft, surfaceBBox.fTop, 0, 0);
+ if (!rect.isEmpty()) {
+ paint.setColor(image->getColor(0, 0));
+ canvas.drawRect(rect, paint);
+ }
+
+ rect = SkRect::MakeLTRB(width, surfaceBBox.fTop, surfaceBBox.fRight, 0);
+ if (!rect.isEmpty()) {
+ paint.setColor(image->getColor(width - 1, 0));
+ canvas.drawRect(rect, paint);
+ }
+
+ rect = SkRect::MakeLTRB(width, height, surfaceBBox.fRight,
+ surfaceBBox.fBottom);
+ if (!rect.isEmpty()) {
+ paint.setColor(image->getColor(width - 1, height - 1));
+ canvas.drawRect(rect, paint);
+ }
+
+ rect = SkRect::MakeLTRB(surfaceBBox.fLeft, height, 0,
+ surfaceBBox.fBottom);
+ if (!rect.isEmpty()) {
+ paint.setColor(image->getColor(0, height - 1));
+ canvas.drawRect(rect, paint);
+ }
+ }
+
+ // Then expand the left, right, top, then bottom.
+ if (tileModes[0] == SkShader::kClamp_TileMode) {
+ SkIRect subset = SkIRect::MakeXYWH(0, 0, 1, height);
+ if (surfaceBBox.fLeft < 0) {
+ SkBitmap left;
+ SkAssertResult(image->extractSubset(&left, subset));
+
+ SkMatrix leftMatrix;
+ leftMatrix.setScale(-surfaceBBox.fLeft, 1);
+ leftMatrix.postTranslate(surfaceBBox.fLeft, 0);
+ canvas.drawBitmapMatrix(left, leftMatrix);
+
+ if (tileModes[1] == SkShader::kMirror_TileMode) {
+ leftMatrix.postScale(1, -1);
+ leftMatrix.postTranslate(0, 2 * height);
+ canvas.drawBitmapMatrix(left, leftMatrix);
+ }
+ patternBBox.fLeft = 0;
+ }
+
+ if (surfaceBBox.fRight > width) {
+ SkBitmap right;
+ subset.offset(width - 1, 0);
+ SkAssertResult(image->extractSubset(&right, subset));
+
+ SkMatrix rightMatrix;
+ rightMatrix.setScale(surfaceBBox.fRight - width, 1);
+ rightMatrix.postTranslate(width, 0);
+ canvas.drawBitmapMatrix(right, rightMatrix);
+
+ if (tileModes[1] == SkShader::kMirror_TileMode) {
+ rightMatrix.postScale(1, -1);
+ rightMatrix.postTranslate(0, 2 * height);
+ canvas.drawBitmapMatrix(right, rightMatrix);
+ }
+ patternBBox.fRight = surfaceBBox.width();
+ }
+ }
+
+ if (tileModes[1] == SkShader::kClamp_TileMode) {
+ SkIRect subset = SkIRect::MakeXYWH(0, 0, width, 1);
+ if (surfaceBBox.fTop < 0) {
+ SkBitmap top;
+ SkAssertResult(image->extractSubset(&top, subset));
+
+ SkMatrix topMatrix;
+ topMatrix.setScale(1, -surfaceBBox.fTop);
+ topMatrix.postTranslate(0, surfaceBBox.fTop);
+ canvas.drawBitmapMatrix(top, topMatrix);
+
+ if (tileModes[0] == SkShader::kMirror_TileMode) {
+ topMatrix.postScale(-1, 1);
+ topMatrix.postTranslate(2 * width, 0);
+ canvas.drawBitmapMatrix(top, topMatrix);
+ }
+ patternBBox.fTop = 0;
+ }
+
+ if (surfaceBBox.fBottom > height) {
+ SkBitmap bottom;
+ subset.offset(0, height - 1);
+ SkAssertResult(image->extractSubset(&bottom, subset));
+
+ SkMatrix bottomMatrix;
+ bottomMatrix.setScale(1, surfaceBBox.fBottom - height);
+ bottomMatrix.postTranslate(0, height);
+ canvas.drawBitmapMatrix(bottom, bottomMatrix);
+
+ if (tileModes[0] == SkShader::kMirror_TileMode) {
+ bottomMatrix.postScale(-1, 1);
+ bottomMatrix.postTranslate(2 * width, 0);
+ canvas.drawBitmapMatrix(bottom, bottomMatrix);
+ }
+ patternBBox.fBottom = surfaceBBox.height();
+ }
+ }
+
+ SkRefPtr<SkPDFArray> patternBBoxArray = new SkPDFArray;
+ patternBBoxArray->unref(); // SkRefPtr and new both took a reference.
+ patternBBoxArray->reserve(4);
+ patternBBoxArray->append(new SkPDFScalar(patternBBox.fLeft))->unref();
+ patternBBoxArray->append(new SkPDFScalar(patternBBox.fTop))->unref();
+ patternBBoxArray->append(new SkPDFScalar(patternBBox.fRight))->unref();
+ patternBBoxArray->append(new SkPDFScalar(patternBBox.fBottom))->unref();
+
+ // Put the canvas into the pattern stream (fContent).
+ SkRefPtr<SkStream> content = pattern.content();
+ content->unref(); // SkRefPtr and content() both took a reference.
+ pattern.getResources(&fResources);
+
+ fContent = new SkPDFStream(content.get());
+ fContent->unref(); // SkRefPtr and new both took a reference.
+ fContent->insert("Type", new SkPDFName("Pattern"))->unref();
+ fContent->insert("PatternType", new SkPDFInt(1))->unref();
+ fContent->insert("PaintType", new SkPDFInt(1))->unref();
+ fContent->insert("TilingType", new SkPDFInt(1))->unref();
+ fContent->insert("BBox", patternBBoxArray.get());
+ fContent->insert("XStep", new SkPDFScalar(patternBBox.width()))->unref();
+ fContent->insert("YStep", new SkPDFScalar(patternBBox.height()))->unref();
+ fContent->insert("Resources", pattern.getResourceDict().get());
+ fContent->insert("Matrix", SkPDFUtils::MatrixToArray(finalMatrix))->unref();
+
+ fState.get()->fImage.unlockPixels();
+}
+
+SkPDFStream* SkPDFShader::makePSFunction(const SkString& psCode,
+ SkPDFArray* domain) {
+ SkRefPtr<SkMemoryStream> funcStream =
+ new SkMemoryStream(psCode.c_str(), psCode.size(), true);
+ funcStream->unref(); // SkRefPtr and new both took a reference.
+
+ SkPDFStream* result = new SkPDFStream(funcStream.get());
+ result->insert("FunctionType", new SkPDFInt(4))->unref();
+ result->insert("Domain", domain);
+ result->insert("Range", rangeObject());
+ return result;
+}
+
+bool SkPDFShader::State::operator==(const SkPDFShader::State& b) const {
+ if (fType != b.fType ||
+ fCanvasTransform != b.fCanvasTransform ||
+ fShaderTransform != b.fShaderTransform ||
+ fBBox != b.fBBox) {
+ return false;
+ }
+
+ if (fType == SkShader::kNone_GradientType) {
+ if (fPixelGeneration != b.fPixelGeneration ||
+ fPixelGeneration == 0 ||
+ fImageTileModes[0] != b.fImageTileModes[0] ||
+ fImageTileModes[1] != b.fImageTileModes[1]) {
+ return false;
+ }
+ } else {
+ if (fInfo.fColorCount != b.fInfo.fColorCount ||
+ memcmp(fInfo.fColors, b.fInfo.fColors,
+ sizeof(SkColor) * fInfo.fColorCount) != 0 ||
+ memcmp(fInfo.fColorOffsets, b.fInfo.fColorOffsets,
+ sizeof(SkScalar) * fInfo.fColorCount) != 0 ||
+ fInfo.fPoint[0] != b.fInfo.fPoint[0] ||
+ fInfo.fTileMode != b.fInfo.fTileMode) {
+ return false;
+ }
+
+ switch (fType) {
+ case SkShader::kLinear_GradientType:
+ if (fInfo.fPoint[1] != b.fInfo.fPoint[1]) {
+ return false;
+ }
+ break;
+ case SkShader::kRadial_GradientType:
+ if (fInfo.fRadius[0] != b.fInfo.fRadius[0]) {
+ return false;
+ }
+ break;
+ case SkShader::kRadial2_GradientType:
+ if (fInfo.fPoint[1] != b.fInfo.fPoint[1] ||
+ fInfo.fRadius[0] != b.fInfo.fRadius[0] ||
+ fInfo.fRadius[1] != b.fInfo.fRadius[1]) {
+ return false;
+ }
+ break;
+ case SkShader::kSweep_GradientType:
+ case SkShader::kNone_GradientType:
+ case SkShader::kColor_GradientType:
+ break;
+ }
+ }
+ return true;
+}
+
+SkPDFShader::State::State(const SkShader& shader,
+ const SkMatrix& canvasTransform, const SkIRect& bbox)
+ : fCanvasTransform(canvasTransform),
+ fBBox(bbox) {
+
+ fInfo.fColorCount = 0;
+ fInfo.fColors = NULL;
+ fInfo.fColorOffsets = NULL;
+ shader.getLocalMatrix(&fShaderTransform);
+
+ fType = shader.asAGradient(&fInfo);
+
+ if (fType == SkShader::kNone_GradientType) {
+ SkShader::BitmapType bitmapType;
+ SkMatrix matrix;
+ bitmapType = shader.asABitmap(&fImage, &matrix, fImageTileModes, NULL);
+ if (bitmapType != SkShader::kDefault_BitmapType) {
+ fImage.reset();
+ return;
+ }
+ SkASSERT(matrix.isIdentity());
+ fPixelGeneration = fImage.getGenerationID();
+ } else {
+ fColorData.set(sk_malloc_throw(
+ fInfo.fColorCount * (sizeof(SkColor) + sizeof(SkScalar))));
+ fInfo.fColors = (SkColor*)fColorData.get();
+ fInfo.fColorOffsets = (SkScalar*)(fInfo.fColors + fInfo.fColorCount);
+ shader.asAGradient(&fInfo);
+ }
+}
diff --git a/src/pdf/SkPDFStream.cpp b/src/pdf/SkPDFStream.cpp
new file mode 100644
index 0000000..b1bd5ff
--- /dev/null
+++ b/src/pdf/SkPDFStream.cpp
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2010 Google Inc.
+ *
+ * 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.
+ */
+
+#include "SkFlate.h"
+#include "SkPDFCatalog.h"
+#include "SkPDFStream.h"
+#include "SkStream.h"
+
+SkPDFStream::SkPDFStream(SkStream* stream) {
+ if (SkFlate::HaveFlate())
+ SkAssertResult(SkFlate::Deflate(stream, &fCompressedData));
+
+ if (SkFlate::HaveFlate() &&
+ fCompressedData.getOffset() < stream->getLength()) {
+ fLength = fCompressedData.getOffset();
+ insert("Filter", new SkPDFName("FlateDecode"))->unref();
+ } else {
+ fCompressedData.reset();
+ fPlainData = stream;
+ fLength = fPlainData->getLength();
+ }
+ insert("Length", new SkPDFInt(fLength))->unref();
+}
+
+SkPDFStream::~SkPDFStream() {
+}
+
+void SkPDFStream::emitObject(SkWStream* stream, SkPDFCatalog* catalog,
+ bool indirect) {
+ if (indirect)
+ return emitIndirectObject(stream, catalog);
+
+ this->INHERITED::emitObject(stream, catalog, false);
+ stream->writeText(" stream\n");
+ if (fPlainData.get())
+ stream->write(fPlainData->getMemoryBase(), fLength);
+ else
+ stream->write(fCompressedData.getStream(), fLength);
+ stream->writeText("\nendstream");
+}
+
+size_t SkPDFStream::getOutputSize(SkPDFCatalog* catalog, bool indirect) {
+ if (indirect)
+ return getIndirectOutputSize(catalog);
+
+ return this->INHERITED::getOutputSize(catalog, false) +
+ strlen(" stream\n\nendstream") + fLength;
+}
diff --git a/src/pdf/SkPDFTypes.cpp b/src/pdf/SkPDFTypes.cpp
new file mode 100644
index 0000000..b9420eb
--- /dev/null
+++ b/src/pdf/SkPDFTypes.cpp
@@ -0,0 +1,392 @@
+/*
+ * Copyright (C) 2011 Google Inc.
+ *
+ * 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.
+ */
+
+#include "SkPDFCatalog.h"
+#include "SkPDFTypes.h"
+#include "SkStream.h"
+
+#ifdef SK_BUILD_FOR_WIN
+ #define SNPRINTF _snprintf
+#else
+ #define SNPRINTF snprintf
+#endif
+
+SkPDFObject::SkPDFObject() {}
+SkPDFObject::~SkPDFObject() {}
+
+size_t SkPDFObject::getOutputSize(SkPDFCatalog* catalog, bool indirect) {
+ SkDynamicMemoryWStream buffer;
+ emitObject(&buffer, catalog, indirect);
+ return buffer.getOffset();
+}
+
+void SkPDFObject::getResources(SkTDArray<SkPDFObject*>* resourceList) {}
+
+void SkPDFObject::emitIndirectObject(SkWStream* stream, SkPDFCatalog* catalog) {
+ catalog->emitObjectNumber(stream, this);
+ stream->writeText(" obj\n");
+ emitObject(stream, catalog, false);
+ stream->writeText("\nendobj\n");
+}
+
+SkPDFObjRef::SkPDFObjRef(SkPDFObject* obj) : fObj(obj) {}
+SkPDFObjRef::~SkPDFObjRef() {}
+
+size_t SkPDFObject::getIndirectOutputSize(SkPDFCatalog* catalog) {
+ return catalog->getObjectNumberSize(this) + strlen(" obj\n") +
+ this->getOutputSize(catalog, false) + strlen("\nendobj\n");
+}
+
+void SkPDFObjRef::emitObject(SkWStream* stream, SkPDFCatalog* catalog,
+ bool indirect) {
+ SkASSERT(!indirect);
+ catalog->emitObjectNumber(stream, fObj.get());
+ stream->writeText(" R");
+}
+
+size_t SkPDFObjRef::getOutputSize(SkPDFCatalog* catalog, bool indirect) {
+ SkASSERT(!indirect);
+ return catalog->getObjectNumberSize(fObj.get()) + strlen(" R");
+}
+
+SkPDFInt::SkPDFInt(int32_t value) : fValue(value) {}
+SkPDFInt::~SkPDFInt() {}
+
+void SkPDFInt::emitObject(SkWStream* stream, SkPDFCatalog* catalog,
+ bool indirect) {
+ if (indirect)
+ return emitIndirectObject(stream, catalog);
+ stream->writeDecAsText(fValue);
+}
+
+SkPDFBool::SkPDFBool(bool value) : fValue(value) {}
+SkPDFBool::~SkPDFBool() {}
+
+void SkPDFBool::emitObject(SkWStream* stream, SkPDFCatalog* catalog,
+ bool indirect) {
+ SkASSERT(!indirect);
+ if (fValue) {
+ stream->writeText("true");
+ } else {
+ stream->writeText("false");
+ }
+}
+
+size_t SkPDFBool::getOutputSize(SkPDFCatalog* catalog, bool indirect) {
+ SkASSERT(!indirect);
+ if (fValue)
+ return strlen("true");
+ return strlen("false");
+}
+
+SkPDFScalar::SkPDFScalar(SkScalar value) : fValue(value) {}
+SkPDFScalar::~SkPDFScalar() {}
+
+void SkPDFScalar::emitObject(SkWStream* stream, SkPDFCatalog* catalog,
+ bool indirect) {
+ if (indirect)
+ return emitIndirectObject(stream, catalog);
+
+ Append(fValue, stream);
+}
+
+// static
+void SkPDFScalar::Append(SkScalar value, SkWStream* stream) {
+ // The range of reals in PDF/A is the same as SkFixed: +/- 32,767 and
+ // +/- 1/65,536 (though integers can range from 2^31 - 1 to -2^31).
+ // When using floats that are outside the whole value range, we can use
+ // integers instead.
+
+
+#if defined(SK_SCALAR_IS_FIXED)
+ stream->writeScalarAsText(value);
+ return;
+#endif // SK_SCALAR_IS_FIXED
+
+#if !defined(SK_ALLOW_LARGE_PDF_SCALARS)
+ if (value > 32767 || value < -32767) {
+ stream->writeDecAsText(SkScalarRound(value));
+ return;
+ }
+
+ char buffer[SkStrAppendScalar_MaxSize];
+ char* end = SkStrAppendFixed(buffer, SkScalarToFixed(value));
+ stream->write(buffer, end - buffer);
+ return;
+#endif // !SK_ALLOW_LARGE_PDF_SCALARS
+
+#if defined(SK_SCALAR_IS_FLOAT) && defined(SK_ALLOW_LARGE_PDF_SCALARS)
+ // Floats have 24bits of significance, so anything outside that range is
+ // no more precise than an int. (Plus PDF doesn't support scientific
+ // notation, so this clamps to SK_Max/MinS32).
+ if (value > (1 << 24) || value < -(1 << 24)) {
+ stream->writeDecAsText(value);
+ return;
+ }
+ // Continue to enforce the PDF limits for small floats.
+ if (value < 1.0f/65536 && value > -1.0f/65536) {
+ stream->writeDecAsText(0);
+ return;
+ }
+ // SkStrAppendFloat might still use scientific notation, so use snprintf
+ // directly..
+ static const int kFloat_MaxSize = 19;
+ char buffer[kFloat_MaxSize];
+ int len = SNPRINTF(buffer, kFloat_MaxSize, "%#.8f", value);
+ // %f always prints trailing 0s, so strip them.
+ for (; buffer[len - 1] == '0' && len > 0; len--) {
+ buffer[len - 1] = '\0';
+ }
+ if (buffer[len - 1] == '.') {
+ buffer[len - 1] = '\0';
+ }
+ stream->writeText(buffer);
+ return;
+#endif // SK_SCALAR_IS_FLOAT && SK_ALLOW_LARGE_PDF_SCALARS
+}
+
+SkPDFString::SkPDFString(const char value[])
+ : fValue(formatString(value, strlen(value))) {
+}
+
+SkPDFString::SkPDFString(const SkString& value)
+ : fValue(formatString(value.c_str(), value.size())) {
+}
+
+SkPDFString::SkPDFString(const uint16_t* value, size_t len, bool wideChars)
+ : fValue(formatString(value, len, wideChars)) {
+}
+
+SkPDFString::~SkPDFString() {}
+
+void SkPDFString::emitObject(SkWStream* stream, SkPDFCatalog* catalog,
+ bool indirect) {
+ if (indirect)
+ return emitIndirectObject(stream, catalog);
+ stream->write(fValue.c_str(), fValue.size());
+}
+
+size_t SkPDFString::getOutputSize(SkPDFCatalog* catalog, bool indirect) {
+ if (indirect)
+ return getIndirectOutputSize(catalog);
+ return fValue.size();
+}
+
+// static
+SkString SkPDFString::formatString(const char* input, size_t len) {
+ return doFormatString(input, len, false, false);
+}
+
+SkString SkPDFString::formatString(const uint16_t* input, size_t len,
+ bool wideChars) {
+ return doFormatString(input, len, true, wideChars);
+}
+
+// static
+SkString SkPDFString::doFormatString(const void* input, size_t len,
+ bool wideInput, bool wideOutput) {
+ SkASSERT(len <= kMaxLen);
+ const uint16_t* win = (const uint16_t*) input;
+ const char* cin = (const char*) input;
+
+ if (wideOutput) {
+ SkASSERT(wideInput);
+ SkString result;
+ result.append("<");
+ for (size_t i = 0; i < len; i++)
+ result.appendHex(win[i], 4);
+ result.append(">");
+ return result;
+ }
+
+ // 7-bit clean is a heuristic to decide what string format to use;
+ // a 7-bit clean string should require little escaping.
+ bool sevenBitClean = true;
+ for (size_t i = 0; i < len; i++) {
+ SkASSERT(!wideInput || !(win[i] & ~0xFF));
+ char val = wideInput ? win[i] : cin[i];
+ if (val > '~' || val < ' ') {
+ sevenBitClean = false;
+ break;
+ }
+ }
+
+ SkString result;
+ if (sevenBitClean) {
+ result.append("(");
+ for (size_t i = 0; i < len; i++) {
+ SkASSERT(!wideInput || !(win[i] & ~0xFF));
+ char val = wideInput ? win[i] : cin[i];
+ if (val == '\\' || val == '(' || val == ')')
+ result.append("\\");
+ result.append(&val, 1);
+ }
+ result.append(")");
+ } else {
+ result.append("<");
+ for (size_t i = 0; i < len; i++) {
+ SkASSERT(!wideInput || !(win[i] & ~0xFF));
+ unsigned char val = wideInput ? win[i] : cin[i];
+ result.appendHex(val, 2);
+ }
+ result.append(">");
+ }
+
+ return result;
+}
+
+SkPDFName::SkPDFName(const char name[]) : fValue(formatName(SkString(name))) {}
+SkPDFName::SkPDFName(const SkString& name) : fValue(formatName(name)) {}
+SkPDFName::~SkPDFName() {}
+
+void SkPDFName::emitObject(SkWStream* stream, SkPDFCatalog* catalog,
+ bool indirect) {
+ SkASSERT(!indirect);
+ stream->write(fValue.c_str(), fValue.size());
+}
+
+size_t SkPDFName::getOutputSize(SkPDFCatalog* catalog, bool indirect) {
+ SkASSERT(!indirect);
+ return fValue.size();
+}
+
+// static
+SkString SkPDFName::formatName(const SkString& input) {
+ SkASSERT(input.size() <= kMaxLen);
+
+ SkString result("/");
+ for (size_t i = 0; i < input.size(); i++) {
+ if (input[i] & 0x80 || input[i] < '!' || input[i] == '#') {
+ result.append("#");
+ result.appendHex(input[i], 2);
+ } else {
+ result.append(input.c_str() + i, 1);
+ }
+ }
+
+ return result;
+}
+
+SkPDFArray::SkPDFArray() {}
+SkPDFArray::~SkPDFArray() {
+ fValue.safeUnrefAll();
+}
+
+void SkPDFArray::emitObject(SkWStream* stream, SkPDFCatalog* catalog,
+ bool indirect) {
+ if (indirect)
+ return emitIndirectObject(stream, catalog);
+
+ stream->writeText("[");
+ for (int i = 0; i < fValue.count(); i++) {
+ fValue[i]->emitObject(stream, catalog, false);
+ if (i + 1 < fValue.count())
+ stream->writeText(" ");
+ }
+ stream->writeText("]");
+}
+
+size_t SkPDFArray::getOutputSize(SkPDFCatalog* catalog, bool indirect) {
+ if (indirect)
+ return getIndirectOutputSize(catalog);
+
+ size_t result = strlen("[]");
+ if (fValue.count())
+ result += fValue.count() - 1;
+ for (int i = 0; i < fValue.count(); i++)
+ result += fValue[i]->getOutputSize(catalog, false);
+ return result;
+}
+
+void SkPDFArray::reserve(int length) {
+ SkASSERT(length <= kMaxLen);
+ fValue.setReserve(length);
+}
+
+SkPDFObject* SkPDFArray::setAt(int offset, SkPDFObject* value) {
+ SkASSERT(offset < fValue.count());
+ SkSafeUnref(fValue[offset]);
+ fValue[offset] = value;
+ SkSafeRef(fValue[offset]);
+ return value;
+}
+
+SkPDFObject* SkPDFArray::append(SkPDFObject* value) {
+ SkASSERT(fValue.count() < kMaxLen);
+ SkSafeRef(value);
+ fValue.push(value);
+ return value;
+}
+
+SkPDFDict::SkPDFDict() {}
+
+SkPDFDict::SkPDFDict(const char type[]) {
+ insert("Type", new SkPDFName(type))->unref();
+}
+
+SkPDFDict::~SkPDFDict() {
+ clear();
+}
+
+void SkPDFDict::emitObject(SkWStream* stream, SkPDFCatalog* catalog,
+ bool indirect) {
+ if (indirect)
+ return emitIndirectObject(stream, catalog);
+
+ stream->writeText("<<");
+ for (int i = 0; i < fValue.count(); i++) {
+ fValue[i].key->emitObject(stream, catalog, false);
+ stream->writeText(" ");
+ fValue[i].value->emitObject(stream, catalog, false);
+ stream->writeText("\n");
+ }
+ stream->writeText(">>");
+}
+
+size_t SkPDFDict::getOutputSize(SkPDFCatalog* catalog, bool indirect) {
+ if (indirect)
+ return getIndirectOutputSize(catalog);
+
+ size_t result = strlen("<<>>") + (fValue.count() * 2);
+ for (int i = 0; i < fValue.count(); i++) {
+ result += fValue[i].key->getOutputSize(catalog, false);
+ result += fValue[i].value->getOutputSize(catalog, false);
+ }
+ return result;
+}
+
+SkPDFObject* SkPDFDict::insert(SkPDFName* key, SkPDFObject* value) {
+ struct Rec* newEntry = fValue.append();
+ newEntry->key = key;
+ SkSafeRef(newEntry->key);
+ newEntry->value = value;
+ SkSafeRef(newEntry->value);
+ return value;
+}
+
+SkPDFObject* SkPDFDict::insert(const char key[], SkPDFObject* value) {
+ SkRefPtr<SkPDFName> keyName = new SkPDFName(key);
+ keyName->unref(); // SkRefPtr and new both took a reference.
+ return insert(keyName.get(), value);
+}
+
+void SkPDFDict::clear() {
+ for (int i = 0; i < fValue.count(); i++) {
+ SkSafeUnref(fValue[i].key);
+ SkSafeUnref(fValue[i].value);
+ }
+ fValue.reset();
+}
diff --git a/src/pdf/SkPDFUtils.cpp b/src/pdf/SkPDFUtils.cpp
new file mode 100644
index 0000000..a838427
--- /dev/null
+++ b/src/pdf/SkPDFUtils.cpp
@@ -0,0 +1,187 @@
+/*
+ * Copyright (C) 2011 Google Inc.
+ *
+ * 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.
+ */
+
+#include "SkPaint.h"
+#include "SkPath.h"
+#include "SkPDFUtils.h"
+#include "SkStream.h"
+#include "SkString.h"
+#include "SkPDFTypes.h"
+
+// static
+SkPDFArray* SkPDFUtils::MatrixToArray(const SkMatrix& matrix) {
+ SkScalar values[6];
+ SkAssertResult(matrix.pdfTransform(values));
+
+ SkPDFArray* result = new SkPDFArray;
+ result->reserve(6);
+ for (size_t i = 0; i < SK_ARRAY_COUNT(values); i++) {
+ result->append(new SkPDFScalar(values[i]))->unref();
+ }
+ return result;
+}
+
+// static
+void SkPDFUtils::AppendTransform(const SkMatrix& matrix, SkWStream* content) {
+ SkScalar values[6];
+ SkAssertResult(matrix.pdfTransform(values));
+ for (size_t i = 0; i < SK_ARRAY_COUNT(values); i++) {
+ SkPDFScalar::Append(values[i], content);
+ content->writeText(" ");
+ }
+ content->writeText("cm\n");
+}
+
+// static
+void SkPDFUtils::MoveTo(SkScalar x, SkScalar y, SkWStream* content) {
+ SkPDFScalar::Append(x, content);
+ content->writeText(" ");
+ SkPDFScalar::Append(y, content);
+ content->writeText(" m\n");
+}
+
+// static
+void SkPDFUtils::AppendLine(SkScalar x, SkScalar y, SkWStream* content) {
+ SkPDFScalar::Append(x, content);
+ content->writeText(" ");
+ SkPDFScalar::Append(y, content);
+ content->writeText(" l\n");
+}
+
+// static
+void SkPDFUtils::AppendCubic(SkScalar ctl1X, SkScalar ctl1Y,
+ SkScalar ctl2X, SkScalar ctl2Y,
+ SkScalar dstX, SkScalar dstY, SkWStream* content) {
+ SkString cmd("y\n");
+ SkPDFScalar::Append(ctl1X, content);
+ content->writeText(" ");
+ SkPDFScalar::Append(ctl1Y, content);
+ content->writeText(" ");
+ if (ctl2X != dstX || ctl2Y != dstY) {
+ cmd.set("c\n");
+ SkPDFScalar::Append(ctl2X, content);
+ content->writeText(" ");
+ SkPDFScalar::Append(ctl2Y, content);
+ content->writeText(" ");
+ }
+ SkPDFScalar::Append(dstX, content);
+ content->writeText(" ");
+ SkPDFScalar::Append(dstY, content);
+ content->writeText(" ");
+ content->writeText(cmd.c_str());
+}
+
+// static
+void SkPDFUtils::AppendRectangle(const SkRect& rect, SkWStream* content) {
+ // Skia has 0,0 at top left, pdf at bottom left. Do the right thing.
+ SkScalar bottom = SkMinScalar(rect.fBottom, rect.fTop);
+
+ SkPDFScalar::Append(rect.fLeft, content);
+ content->writeText(" ");
+ SkPDFScalar::Append(bottom, content);
+ content->writeText(" ");
+ SkPDFScalar::Append(rect.width(), content);
+ content->writeText(" ");
+ SkPDFScalar::Append(rect.height(), content);
+ content->writeText(" re\n");
+}
+
+// static
+void SkPDFUtils::EmitPath(const SkPath& path, SkWStream* content) {
+ SkPoint args[4];
+ SkPath::Iter iter(path, false);
+ for (SkPath::Verb verb = iter.next(args);
+ verb != SkPath::kDone_Verb;
+ verb = iter.next(args)) {
+ // args gets all the points, even the implicit first point.
+ switch (verb) {
+ case SkPath::kMove_Verb:
+ MoveTo(args[0].fX, args[0].fY, content);
+ break;
+ case SkPath::kLine_Verb:
+ AppendLine(args[1].fX, args[1].fY, content);
+ break;
+ case SkPath::kQuad_Verb: {
+ // Convert quad to cubic (degree elevation). http://goo.gl/vS4i
+ const SkScalar three = SkIntToScalar(3);
+ args[1].scale(SkIntToScalar(2));
+ SkScalar ctl1X = SkScalarDiv(args[0].fX + args[1].fX, three);
+ SkScalar ctl1Y = SkScalarDiv(args[0].fY + args[1].fY, three);
+ SkScalar ctl2X = SkScalarDiv(args[2].fX + args[1].fX, three);
+ SkScalar ctl2Y = SkScalarDiv(args[2].fY + args[1].fY, three);
+ AppendCubic(ctl1X, ctl1Y, ctl2X, ctl2Y, args[2].fX, args[2].fY,
+ content);
+ break;
+ }
+ case SkPath::kCubic_Verb:
+ AppendCubic(args[1].fX, args[1].fY, args[2].fX, args[2].fY,
+ args[3].fX, args[3].fY, content);
+ break;
+ case SkPath::kClose_Verb:
+ ClosePath(content);
+ break;
+ case SkPath::kDone_Verb:
+ break;
+ default:
+ SkASSERT(false);
+ break;
+ }
+ }
+}
+
+// static
+void SkPDFUtils::ClosePath(SkWStream* content) {
+ content->writeText("h\n");
+}
+
+// static
+void SkPDFUtils::PaintPath(SkPaint::Style style, SkPath::FillType fill,
+ SkWStream* content) {
+ if (style == SkPaint::kFill_Style)
+ content->writeText("f");
+ else if (style == SkPaint::kStrokeAndFill_Style)
+ content->writeText("B");
+ else if (style == SkPaint::kStroke_Style)
+ content->writeText("S");
+
+ if (style != SkPaint::kStroke_Style) {
+ NOT_IMPLEMENTED(fill == SkPath::kInverseEvenOdd_FillType, false);
+ NOT_IMPLEMENTED(fill == SkPath::kInverseWinding_FillType, false);
+ if (fill == SkPath::kEvenOdd_FillType)
+ content->writeText("*");
+ }
+ content->writeText("\n");
+}
+
+// static
+void SkPDFUtils::StrokePath(SkWStream* content) {
+ SkPDFUtils::PaintPath(
+ SkPaint::kStroke_Style, SkPath::kWinding_FillType, content);
+}
+
+// static
+void SkPDFUtils::DrawFormXObject(int objectIndex, SkWStream* content) {
+ content->writeText("/X");
+ content->writeDecAsText(objectIndex);
+ content->writeText(" Do\n");
+}
+
+// static
+void SkPDFUtils::ApplyGraphicState(int objectIndex, SkWStream* content) {
+ content->writeText("/G");
+ content->writeDecAsText(objectIndex);
+ content->writeText(" gs\n");
+}
diff --git a/src/pdf/pdf_files.mk b/src/pdf/pdf_files.mk
new file mode 100644
index 0000000..c9b4fb4
--- /dev/null
+++ b/src/pdf/pdf_files.mk
@@ -0,0 +1,13 @@
+SOURCE := \
+ SkPDFCatalog.cpp \
+ SkPDFDevice.cpp \
+ SkPDFDocument.cpp \
+ SkPDFFont.cpp \
+ SkPDFFormXObject.cpp \
+ SkPDFGraphicState.cpp \
+ SkPDFImage.cpp \
+ SkPDFPage.cpp \
+ SkPDFShader.cpp \
+ SkPDFStream.cpp \
+ SkPDFTypes.cpp \
+ SkPDFUtils.cpp
diff --git a/src/pipe/SkGPipePriv.h b/src/pipe/SkGPipePriv.h
new file mode 100644
index 0000000..fb15536
--- /dev/null
+++ b/src/pipe/SkGPipePriv.h
@@ -0,0 +1,213 @@
+/*
+ Copyright 2011 Google Inc.
+
+ 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.
+ */
+
+
+#ifndef SkGPipePriv_DEFINED
+#define SkGPipePriv_DEFINED
+
+#include "SkTypes.h"
+
+#define UNIMPLEMENTED
+
+// these must be contiguous, 0...N-1
+enum PaintFlats {
+ kColorFilter_PaintFlat,
+ kDrawLooper_PaintFlat,
+ kMaskFilter_PaintFlat,
+ kPathEffect_PaintFlat,
+ kRasterizer_PaintFlat,
+ kShader_PaintFlat,
+ kXfermode_PaintFlat,
+
+ kLast_PaintFlat = kXfermode_PaintFlat
+};
+#define kCount_PaintFlats (kLast_PaintFlat + 1)
+
+enum DrawOps {
+ kSkip_DrawOp, // skip an addition N bytes (N == data)
+
+ // these match Canvas apis
+ kClipPath_DrawOp,
+ kClipRegion_DrawOp,
+ kClipRect_DrawOp,
+ kConcat_DrawOp,
+ kDrawBitmap_DrawOp,
+ kDrawBitmapMatrix_DrawOp,
+ kDrawBitmapRect_DrawOp,
+ kDrawClear_DrawOp,
+ kDrawData_DrawOp,
+ kDrawPaint_DrawOp,
+ kDrawPath_DrawOp,
+ kDrawPicture_DrawOp,
+ kDrawPoints_DrawOp,
+ kDrawPosText_DrawOp,
+ kDrawPosTextH_DrawOp,
+ kDrawRect_DrawOp,
+ kDrawShape_DrawOp,
+ kDrawSprite_DrawOp,
+ kDrawText_DrawOp,
+ kDrawTextOnPath_DrawOp,
+ kDrawVertices_DrawOp,
+ kRestore_DrawOp,
+ kRotate_DrawOp,
+ kSave_DrawOp,
+ kSaveLayer_DrawOp,
+ kScale_DrawOp,
+ kSetMatrix_DrawOp,
+ kSkew_DrawOp,
+ kTranslate_DrawOp,
+
+ kPaintOp_DrawOp,
+
+ kDef_Typeface_DrawOp,
+ kDef_Flattenable_DrawOp,
+
+ kName_Flattenable_DrawOp, // index <--> name
+
+ // these are signals to playback, not drawing verbs
+ kDone_DrawOp,
+};
+
+/**
+ * DrawOp packs into a 32bit int as follows
+ *
+ * DrawOp:8 - Flags:4 - Data:20
+ *
+ * Flags and Data are called out separately, so we can reuse Data between
+ * different Ops that might have different Flags. e.g. Data might be a Paint
+ * index for both drawRect (no flags) and saveLayer (does have flags).
+ *
+ * All Ops that take a SkPaint use their Data field to store the index to
+ * the paint (previously defined with kPaintOp_DrawOp).
+ */
+
+#define DRAWOPS_OP_BITS 8
+#define DRAWOPS_FLAG_BITS 4
+#define DRAWOPS_DATA_BITS 20
+
+#define DRAWOPS_OP_MASK ((1 << DRAWOPS_OP_BITS) - 1)
+#define DRAWOPS_FLAG_MASK ((1 << DRAWOPS_FLAG_BITS) - 1)
+#define DRAWOPS_DATA_MASK ((1 << DRAWOPS_DATA_BITS) - 1)
+
+static unsigned DrawOp_unpackOp(uint32_t op32) {
+ return (op32 >> (DRAWOPS_FLAG_BITS + DRAWOPS_DATA_BITS));
+}
+
+static unsigned DrawOp_unpackFlags(uint32_t op32) {
+ return (op32 >> DRAWOPS_DATA_BITS) & DRAWOPS_FLAG_MASK;
+}
+
+static unsigned DrawOp_unpackData(uint32_t op32) {
+ return op32 & DRAWOPS_DATA_MASK;
+}
+
+static uint32_t DrawOp_packOpFlagData(DrawOps op, unsigned flags, unsigned data) {
+ SkASSERT(0 == (op & ~DRAWOPS_OP_MASK));
+ SkASSERT(0 == (flags & ~DRAWOPS_FLAG_MASK));
+ SkASSERT(0 == (data & ~DRAWOPS_DATA_MASK));
+
+ return (op << DRAWOPS_FLAG_BITS + DRAWOPS_DATA_BITS) |
+ (flags << DRAWOPS_DATA_BITS) |
+ data;
+}
+
+/** DrawOp specific flag bits
+ */
+
+enum {
+ kSaveLayer_HasBounds_DrawOpFlag = 1 << 0,
+ kSaveLayer_HasPaint_DrawOpFlag = 1 << 1,
+};
+enum {
+ kClear_HasColor_DrawOpFlag = 1 << 0
+};
+enum {
+ kDrawTextOnPath_HasMatrix_DrawOpFlag = 1 << 0
+};
+enum {
+ kDrawVertices_HasTexs_DrawOpFlag = 1 << 0,
+ kDrawVertices_HasColors_DrawOpFlag = 1 << 1,
+ kDrawVertices_HasIndices_DrawOpFlag = 1 << 2,
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+enum PaintOps {
+ kReset_PaintOp, // no arg
+
+ kFlags_PaintOp, // arg inline
+ kColor_PaintOp, // arg 32
+ kStyle_PaintOp, // arg inline
+ kJoin_PaintOp, // arg inline
+ kCap_PaintOp, // arg inline
+ kWidth_PaintOp, // arg scalar
+ kMiter_PaintOp,// arg scalar
+
+ kEncoding_PaintOp, // arg inline - text
+ kHinting_PaintOp, // arg inline - text
+ kAlign_PaintOp, // arg inline - text
+ kTextSize_PaintOp, // arg scalar - text
+ kTextScaleX_PaintOp,// arg scalar - text
+ kTextSkewX_PaintOp, // arg scalar - text
+ kTypeface_PaintOp, // arg inline (index) - text
+
+ kFlatIndex_PaintOp, // flags=paintflat, data=index
+};
+
+#define PAINTOPS_OP_BITS 8
+#define PAINTOPS_FLAG_BITS 4
+#define PAINTOPS_DATA_BITS 20
+
+#define PAINTOPS_OP_MASK ((1 << PAINTOPS_OP_BITS) - 1)
+#define PAINTOPS_FLAG_MASK ((1 << PAINTOPS_FLAG_BITS) - 1)
+#define PAINTOPS_DATA_MASK ((1 << PAINTOPS_DATA_BITS) - 1)
+
+static unsigned PaintOp_unpackOp(uint32_t op32) {
+ return (op32 >> (PAINTOPS_FLAG_BITS + PAINTOPS_DATA_BITS));
+}
+
+static unsigned PaintOp_unpackFlags(uint32_t op32) {
+ return (op32 >> PAINTOPS_DATA_BITS) & PAINTOPS_FLAG_MASK;
+}
+
+static unsigned PaintOp_unpackData(uint32_t op32) {
+ return op32 & PAINTOPS_DATA_MASK;
+}
+
+static uint32_t PaintOp_packOp(PaintOps op) {
+ SkASSERT(0 == (op & ~PAINTOPS_OP_MASK));
+
+ return (op << PAINTOPS_FLAG_BITS + PAINTOPS_DATA_BITS);
+}
+
+static uint32_t PaintOp_packOpData(PaintOps op, unsigned data) {
+ SkASSERT(0 == (op & ~PAINTOPS_OP_MASK));
+ SkASSERT(0 == (data & ~PAINTOPS_DATA_MASK));
+
+ return (op << PAINTOPS_FLAG_BITS + PAINTOPS_DATA_BITS) | data;
+}
+
+static uint32_t PaintOp_packOpFlagData(PaintOps op, unsigned flags, unsigned data) {
+ SkASSERT(0 == (op & ~PAINTOPS_OP_MASK));
+ SkASSERT(0 == (flags & ~PAINTOPS_FLAG_MASK));
+ SkASSERT(0 == (data & ~PAINTOPS_DATA_MASK));
+
+ return (op << PAINTOPS_FLAG_BITS + PAINTOPS_DATA_BITS) |
+ (flags << PAINTOPS_DATA_BITS) |
+ data;
+}
+
+#endif
diff --git a/src/pipe/SkGPipeRead.cpp b/src/pipe/SkGPipeRead.cpp
new file mode 100644
index 0000000..ecb19fd
--- /dev/null
+++ b/src/pipe/SkGPipeRead.cpp
@@ -0,0 +1,570 @@
+/*
+ Copyright 2011 Google Inc.
+
+ 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.
+ */
+
+
+#include "SkCanvas.h"
+#include "SkPaint.h"
+#include "SkGPipe.h"
+#include "SkGPipePriv.h"
+#include "SkReader32.h"
+#include "SkStream.h"
+
+#include "SkColorFilter.h"
+#include "SkDrawLooper.h"
+#include "SkMaskFilter.h"
+#include "SkPathEffect.h"
+#include "SkRasterizer.h"
+#include "SkShader.h"
+#include "SkTypeface.h"
+#include "SkXfermode.h"
+
+static void set_paintflat(SkPaint* paint, SkFlattenable* obj, unsigned paintFlat) {
+ SkASSERT(paintFlat < kCount_PaintFlats);
+ switch (paintFlat) {
+ case kColorFilter_PaintFlat:
+ paint->setColorFilter((SkColorFilter*)obj);
+ break;
+ case kDrawLooper_PaintFlat:
+ paint->setLooper((SkDrawLooper*)obj);
+ break;
+ case kMaskFilter_PaintFlat:
+ paint->setMaskFilter((SkMaskFilter*)obj);
+ break;
+ case kPathEffect_PaintFlat:
+ paint->setPathEffect((SkPathEffect*)obj);
+ break;
+ case kRasterizer_PaintFlat:
+ paint->setRasterizer((SkRasterizer*)obj);
+ break;
+ case kShader_PaintFlat:
+ paint->setShader((SkShader*)obj);
+ break;
+ case kXfermode_PaintFlat:
+ paint->setXfermode((SkXfermode*)obj);
+ break;
+ default:
+ SkASSERT(!"never gets here");
+ }
+}
+
+template <typename T> class SkRefCntTDArray : public SkTDArray<T> {
+public:
+ ~SkRefCntTDArray() { this->unrefAll(); }
+};
+
+class SkGPipeState {
+public:
+ SkGPipeState();
+ ~SkGPipeState();
+
+ void setReader(SkFlattenableReadBuffer* reader) {
+ fReader = reader;
+ fReader->setFactoryPlayback(fFactoryArray.begin(), fFactoryArray.count());
+ }
+
+ const SkPaint& paint() const { return fPaint; }
+ SkPaint* editPaint() { return &fPaint; }
+
+ SkFlattenable* getFlat(unsigned index) const {
+ if (0 == index) {
+ return NULL;
+ }
+ return fFlatArray[index - 1];
+ }
+
+ void defFlattenable(PaintFlats pf, unsigned index) {
+ SkASSERT(index == fFlatArray.count() + 1);
+ SkFlattenable* obj = fReader->readFlattenable();
+ *fFlatArray.append() = obj;
+ }
+
+ void nameFlattenable(PaintFlats pf, unsigned index) {
+ SkASSERT(index == fFactoryArray.count() + 1);
+ const char* name = fReader->readString();
+ SkFlattenable::Factory fact = SkFlattenable::NameToFactory(name);
+ *fFactoryArray.append() = fact;
+
+ // update this each time we grow the array
+ fReader->setFactoryPlayback(fFactoryArray.begin(), fFactoryArray.count());
+ }
+
+ void addTypeface() {
+ size_t size = fReader->readU32();
+ const void* data = fReader->skip(SkAlign4(size));
+ SkMemoryStream stream(data, size, false);
+ *fTypefaces.append() = SkTypeface::Deserialize(&stream);
+ }
+ void setTypeface(SkPaint* paint, unsigned id) {
+ paint->setTypeface(id ? fTypefaces[id - 1] : NULL);
+ }
+
+ SkFlattenableReadBuffer* fReader;
+
+private:
+ SkPaint fPaint;
+ SkTDArray<SkFlattenable*> fFlatArray;
+ SkTDArray<SkTypeface*> fTypefaces;
+ SkTDArray<SkFlattenable::Factory> fFactoryArray;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+template <typename T> const T* skip(SkReader32* reader, int count = 1) {
+ SkASSERT(count >= 0);
+ size_t size = sizeof(T) * count;
+ SkASSERT(SkAlign4(size) == size);
+ return reinterpret_cast<const T*>(reader->skip(size));
+}
+
+template <typename T> const T* skipAlign(SkReader32* reader, int count = 1) {
+ SkASSERT(count >= 0);
+ size_t size = SkAlign4(sizeof(T) * count);
+ return reinterpret_cast<const T*>(reader->skip(size));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+static void clipPath_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
+ SkGPipeState* state) {
+ SkPath path;
+ path.unflatten(*reader);
+ canvas->clipPath(path, (SkRegion::Op)DrawOp_unpackData(op32));
+}
+
+static void clipRegion_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
+ SkGPipeState* state) {
+ SkRegion rgn;
+ SkReadRegion(reader, &rgn);
+ canvas->clipRegion(rgn, (SkRegion::Op)DrawOp_unpackData(op32));
+}
+
+static void clipRect_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
+ SkGPipeState* state) {
+ canvas->clipRect(*skip<SkRect>(reader), (SkRegion::Op)DrawOp_unpackData(op32));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static void setMatrix_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
+ SkGPipeState* state) {
+ SkMatrix matrix;
+ SkReadMatrix(reader, &matrix);
+ canvas->setMatrix(matrix);
+}
+
+static void concat_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
+ SkGPipeState* state) {
+ SkMatrix matrix;
+ SkReadMatrix(reader, &matrix);
+ canvas->concat(matrix);
+}
+
+static void scale_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
+ SkGPipeState* state) {
+ const SkScalar* param = skip<SkScalar>(reader, 2);
+ canvas->scale(param[0], param[1]);
+}
+
+static void skew_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
+ SkGPipeState* state) {
+ const SkScalar* param = skip<SkScalar>(reader, 2);
+ canvas->skew(param[0], param[1]);
+}
+
+static void rotate_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
+ SkGPipeState* state) {
+ canvas->rotate(reader->readScalar());
+}
+
+static void translate_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
+ SkGPipeState* state) {
+ const SkScalar* param = skip<SkScalar>(reader, 2);
+ canvas->translate(param[0], param[1]);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static void save_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
+ SkGPipeState* state) {
+ canvas->save((SkCanvas::SaveFlags)DrawOp_unpackData(op32));
+}
+
+static void saveLayer_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
+ SkGPipeState* state) {
+ unsigned flags = DrawOp_unpackFlags(op32);
+ SkCanvas::SaveFlags saveFlags = (SkCanvas::SaveFlags)DrawOp_unpackData(op32);
+
+ const SkRect* bounds = NULL;
+ if (flags & kSaveLayer_HasBounds_DrawOpFlag) {
+ bounds = skip<SkRect>(reader);
+ }
+ const SkPaint* paint = NULL;
+ if (flags & kSaveLayer_HasPaint_DrawOpFlag) {
+ paint = &state->paint();
+ }
+ canvas->saveLayer(bounds, paint, saveFlags);
+}
+
+static void restore_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
+ SkGPipeState* state) {
+ canvas->restore();
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static void drawClear_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
+ SkGPipeState* state) {
+ SkColor color = 0;
+ if (DrawOp_unpackFlags(op32) & kClear_HasColor_DrawOpFlag) {
+ color = reader->readU32();
+ }
+ canvas->clear(color);
+}
+
+static void drawPaint_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
+ SkGPipeState* state) {
+ canvas->drawPaint(state->paint());
+}
+
+static void drawPoints_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
+ SkGPipeState* state) {
+ SkCanvas::PointMode mode = (SkCanvas::PointMode)DrawOp_unpackFlags(op32);
+ size_t count = reader->readU32();
+ const SkPoint* pts = skip<SkPoint>(reader, count);
+ canvas->drawPoints(mode, count, pts, state->paint());
+}
+
+static void drawRect_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
+ SkGPipeState* state) {
+ canvas->drawRect(*skip<SkRect>(reader), state->paint());
+}
+
+static void drawPath_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
+ SkGPipeState* state) {
+ SkPath path;
+ path.unflatten(*reader);
+ canvas->drawPath(path, state->paint());
+}
+
+static void drawVertices_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
+ SkGPipeState* state) {
+ unsigned flags = DrawOp_unpackFlags(op32);
+
+ SkCanvas::VertexMode mode = (SkCanvas::VertexMode)reader->readU32();
+ int vertexCount = reader->readU32();
+ const SkPoint* verts = skip<SkPoint>(reader, vertexCount);
+
+ const SkPoint* texs = NULL;
+ if (flags & kDrawVertices_HasTexs_DrawOpFlag) {
+ texs = skip<SkPoint>(reader, vertexCount);
+ }
+
+ const SkColor* colors = NULL;
+ if (flags & kDrawVertices_HasColors_DrawOpFlag) {
+ colors = skip<SkColor>(reader, vertexCount);
+ }
+
+ // TODO: flatten/unflatten xfermodes
+ SkXfermode* xfer = NULL;
+
+ int indexCount = 0;
+ const uint16_t* indices = NULL;
+ if (flags & kDrawVertices_HasIndices_DrawOpFlag) {
+ indexCount = reader->readU32();
+ indices = skipAlign<uint16_t>(reader, indexCount);
+ }
+
+ canvas->drawVertices(mode, vertexCount, verts, texs, colors, xfer,
+ indices, indexCount, state->paint());
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static void drawText_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
+ SkGPipeState* state) {
+ size_t len = reader->readU32();
+ const void* text = reader->skip(SkAlign4(len));
+ const SkScalar* xy = skip<SkScalar>(reader, 2);
+ canvas->drawText(text, len, xy[0], xy[1], state->paint());
+}
+
+static void drawPosText_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
+ SkGPipeState* state) {
+ size_t len = reader->readU32();
+ const void* text = reader->skip(SkAlign4(len));
+ size_t posCount = reader->readU32(); // compute by our writer
+ const SkPoint* pos = skip<SkPoint>(reader, posCount);
+ canvas->drawPosText(text, len, pos, state->paint());
+}
+
+static void drawPosTextH_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
+ SkGPipeState* state) {
+ size_t len = reader->readU32();
+ const void* text = reader->skip(SkAlign4(len));
+ size_t posCount = reader->readU32(); // compute by our writer
+ const SkScalar* xpos = skip<SkScalar>(reader, posCount);
+ SkScalar constY = reader->readScalar();
+ canvas->drawPosTextH(text, len, xpos, constY, state->paint());
+}
+
+static void drawTextOnPath_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
+ SkGPipeState* state) {
+ size_t len = reader->readU32();
+ const void* text = reader->skip(SkAlign4(len));
+
+ SkPath path;
+ path.unflatten(*reader);
+
+ SkMatrix matrixStorage;
+ const SkMatrix* matrix = NULL;
+ if (DrawOp_unpackFlags(op32) & kDrawTextOnPath_HasMatrix_DrawOpFlag) {
+ SkReadMatrix(reader, &matrixStorage);
+ matrix = &matrixStorage;
+ }
+
+ canvas->drawTextOnPath(text, len, path, matrix, state->paint());
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static void drawBitmap_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
+ SkGPipeState* state) {
+ UNIMPLEMENTED
+}
+
+static void drawBitmapMatrix_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
+ SkGPipeState* state) {
+ UNIMPLEMENTED
+}
+
+static void drawBitmapRect_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
+ SkGPipeState* state) {
+ UNIMPLEMENTED
+}
+
+static void drawSprite_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
+ SkGPipeState* state) {
+ UNIMPLEMENTED
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static void drawData_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
+ SkGPipeState* state) {
+ // since we don't have a paint, we can use data for our (small) sizes
+ size_t size = DrawOp_unpackData(op32);
+ if (0 == size) {
+ size = reader->readU32();
+ }
+ const void* data = reader->skip(SkAlign4(size));
+ canvas->drawData(data, size);
+}
+
+static void drawShape_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
+ SkGPipeState* state) {
+ UNIMPLEMENTED
+}
+
+static void drawPicture_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
+ SkGPipeState* state) {
+ UNIMPLEMENTED
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static void paintOp_rp(SkCanvas*, SkReader32* reader, uint32_t op32,
+ SkGPipeState* state) {
+ size_t offset = reader->offset();
+ size_t stop = offset + PaintOp_unpackData(op32);
+ SkPaint* p = state->editPaint();
+
+ do {
+ uint32_t p32 = reader->readU32();
+ unsigned op = PaintOp_unpackOp(p32);
+ unsigned data = PaintOp_unpackData(p32);
+
+// SkDebugf(" read %08X op=%d flags=%d data=%d\n", p32, op, done, data);
+
+ switch (op) {
+ case kReset_PaintOp: p->reset(); break;
+ case kFlags_PaintOp: p->setFlags(data); break;
+ case kColor_PaintOp: p->setColor(reader->readU32()); break;
+ case kStyle_PaintOp: p->setStyle((SkPaint::Style)data); break;
+ case kJoin_PaintOp: p->setStrokeJoin((SkPaint::Join)data); break;
+ case kCap_PaintOp: p->setStrokeCap((SkPaint::Cap)data); break;
+ case kWidth_PaintOp: p->setStrokeWidth(reader->readScalar()); break;
+ case kMiter_PaintOp: p->setStrokeMiter(reader->readScalar()); break;
+ case kEncoding_PaintOp:
+ p->setTextEncoding((SkPaint::TextEncoding)data);
+ break;
+ case kHinting_PaintOp: p->setHinting((SkPaint::Hinting)data); break;
+ case kAlign_PaintOp: p->setTextAlign((SkPaint::Align)data); break;
+ case kTextSize_PaintOp: p->setTextSize(reader->readScalar()); break;
+ case kTextScaleX_PaintOp: p->setTextScaleX(reader->readScalar()); break;
+ case kTextSkewX_PaintOp: p->setTextSkewX(reader->readScalar()); break;
+
+ case kFlatIndex_PaintOp: {
+ PaintFlats pf = (PaintFlats)PaintOp_unpackFlags(p32);
+ unsigned index = data;
+ set_paintflat(p, state->getFlat(index), pf);
+ break;
+ }
+
+ case kTypeface_PaintOp: state->setTypeface(p, data); break;
+ default: SkASSERT(!"bad paintop"); return;
+ }
+ SkASSERT(reader->offset() <= stop);
+ } while (reader->offset() < stop);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static void def_Typeface_rp(SkCanvas*, SkReader32*, uint32_t, SkGPipeState* state) {
+ state->addTypeface();
+}
+
+static void def_PaintFlat_rp(SkCanvas*, SkReader32*, uint32_t op32,
+ SkGPipeState* state) {
+ PaintFlats pf = (PaintFlats)DrawOp_unpackFlags(op32);
+ unsigned index = DrawOp_unpackData(op32);
+ state->defFlattenable(pf, index);
+}
+
+static void name_PaintFlat_rp(SkCanvas*, SkReader32*, uint32_t op32,
+ SkGPipeState* state) {
+ PaintFlats pf = (PaintFlats)DrawOp_unpackFlags(op32);
+ unsigned index = DrawOp_unpackData(op32);
+ state->nameFlattenable(pf, index);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static void skip_rp(SkCanvas*, SkReader32* reader, uint32_t op32, SkGPipeState*) {
+ size_t bytes = DrawOp_unpackData(op32);
+ (void)reader->skip(bytes);
+}
+
+static void done_rp(SkCanvas*, SkReader32*, uint32_t, SkGPipeState*) {}
+
+typedef void (*ReadProc)(SkCanvas*, SkReader32*, uint32_t op32, SkGPipeState*);
+
+static const ReadProc gReadTable[] = {
+ skip_rp,
+ clipPath_rp,
+ clipRegion_rp,
+ clipRect_rp,
+ concat_rp,
+ drawBitmap_rp,
+ drawBitmapMatrix_rp,
+ drawBitmapRect_rp,
+ drawClear_rp,
+ drawData_rp,
+ drawPaint_rp,
+ drawPath_rp,
+ drawPicture_rp,
+ drawPoints_rp,
+ drawPosText_rp,
+ drawPosTextH_rp,
+ drawRect_rp,
+ drawShape_rp,
+ drawSprite_rp,
+ drawText_rp,
+ drawTextOnPath_rp,
+ drawVertices_rp,
+ restore_rp,
+ rotate_rp,
+ save_rp,
+ saveLayer_rp,
+ scale_rp,
+ setMatrix_rp,
+ skew_rp,
+ translate_rp,
+
+ paintOp_rp,
+ def_Typeface_rp,
+ def_PaintFlat_rp,
+ name_PaintFlat_rp,
+
+ done_rp
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+SkGPipeState::SkGPipeState() {}
+
+SkGPipeState::~SkGPipeState() {
+ fTypefaces.unrefAll();
+ fFlatArray.unrefAll();
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+#include "SkGPipe.h"
+
+SkGPipeReader::SkGPipeReader(SkCanvas* target) {
+ SkSafeRef(target);
+ fCanvas = target;
+ fState = NULL;
+}
+
+SkGPipeReader::~SkGPipeReader() {
+ SkSafeUnref(fCanvas);
+ delete fState;
+}
+
+SkGPipeReader::Status SkGPipeReader::playback(const void* data, size_t length,
+ size_t* bytesRead) {
+ if (NULL == fCanvas) {
+ return kError_Status;
+ }
+
+ if (NULL == fState) {
+ fState = new SkGPipeState;
+ }
+
+ SkASSERT(SK_ARRAY_COUNT(gReadTable) == (kDone_DrawOp + 1));
+
+ const ReadProc* table = gReadTable;
+ SkFlattenableReadBuffer reader(data, length);
+ SkCanvas* canvas = fCanvas;
+ Status status = kEOF_Status;
+
+ fState->setReader(&reader);
+ while (!reader.eof()) {
+ uint32_t op32 = reader.readU32();
+ unsigned op = DrawOp_unpackOp(op32);
+ SkDEBUGCODE(DrawOps drawOp = (DrawOps)op;)
+
+ if (op >= SK_ARRAY_COUNT(gReadTable)) {
+ SkDebugf("---- bad op during GPipeState::playback\n");
+ status = kError_Status;
+ break;
+ }
+ if (kDone_DrawOp == op) {
+ status = kDone_Status;
+ break;
+ }
+ table[op](canvas, &reader, op32, fState);
+ }
+
+ if (bytesRead) {
+ *bytesRead = reader.offset();
+ }
+ return status;
+}
+
+
diff --git a/src/pipe/SkGPipeWrite.cpp b/src/pipe/SkGPipeWrite.cpp
new file mode 100644
index 0000000..428f864
--- /dev/null
+++ b/src/pipe/SkGPipeWrite.cpp
@@ -0,0 +1,813 @@
+/*
+ Copyright 2011 Google Inc.
+
+ 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.
+ */
+
+
+#include "SkCanvas.h"
+#include "SkDevice.h"
+#include "SkPaint.h"
+#include "SkGPipe.h"
+#include "SkGPipePriv.h"
+#include "SkStream.h"
+#include "SkTSearch.h"
+#include "SkTypeface.h"
+#include "SkWriter32.h"
+#include "SkColorFilter.h"
+#include "SkDrawLooper.h"
+#include "SkMaskFilter.h"
+#include "SkRasterizer.h"
+#include "SkShader.h"
+
+static SkFlattenable* get_paintflat(const SkPaint& paint, unsigned paintFlat) {
+ SkASSERT(paintFlat < kCount_PaintFlats);
+ switch (paintFlat) {
+ case kColorFilter_PaintFlat: return paint.getColorFilter();
+ case kDrawLooper_PaintFlat: return paint.getLooper();
+ case kMaskFilter_PaintFlat: return paint.getMaskFilter();
+ case kPathEffect_PaintFlat: return paint.getPathEffect();
+ case kRasterizer_PaintFlat: return paint.getRasterizer();
+ case kShader_PaintFlat: return paint.getShader();
+ case kXfermode_PaintFlat: return paint.getXfermode();
+ }
+ SkASSERT(!"never gets here");
+ return NULL;
+}
+
+static size_t estimateFlattenSize(const SkPath& path) {
+ int n = path.countPoints();
+ size_t bytes = 3 * sizeof(int32_t);
+ bytes += n * sizeof(SkPoint);
+ bytes += SkAlign4(n + 2); // verbs: add 2 for move/close extras
+
+#ifdef SK_DEBUG
+ {
+ SkWriter32 writer(1024);
+ path.flatten(writer);
+ SkASSERT(writer.size() <= bytes);
+ }
+#endif
+ return bytes;
+}
+
+static size_t writeTypeface(SkWriter32* writer, SkTypeface* typeface) {
+ SkASSERT(typeface);
+ SkDynamicMemoryWStream stream;
+ typeface->serialize(&stream);
+ size_t size = stream.getOffset();
+ if (writer) {
+ writer->write32(size);
+ writer->write(stream.getStream(), size);
+ }
+ return 4 + size;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+class SkGPipeCanvas : public SkCanvas {
+public:
+ SkGPipeCanvas(SkGPipeController*, SkWriter32*, SkFactorySet*);
+ virtual ~SkGPipeCanvas();
+
+ void finish() {
+ if (!fDone) {
+ this->writeOp(kDone_DrawOp);
+ this->doNotify();
+ fDone = true;
+ }
+ }
+
+ // overrides from SkCanvas
+ virtual int save(SaveFlags);
+ virtual int saveLayer(const SkRect* bounds, const SkPaint*, SaveFlags);
+ virtual void restore();
+ virtual bool translate(SkScalar dx, SkScalar dy);
+ virtual bool scale(SkScalar sx, SkScalar sy);
+ virtual bool rotate(SkScalar degrees);
+ virtual bool skew(SkScalar sx, SkScalar sy);
+ virtual bool concat(const SkMatrix& matrix);
+ virtual void setMatrix(const SkMatrix& matrix);
+ virtual bool clipRect(const SkRect& rect, SkRegion::Op op);
+ virtual bool clipPath(const SkPath& path, SkRegion::Op op);
+ virtual bool clipRegion(const SkRegion& region, SkRegion::Op op);
+ virtual void clear(SkColor);
+ virtual void drawPaint(const SkPaint& paint);
+ virtual void drawPoints(PointMode, size_t count, const SkPoint pts[],
+ const SkPaint&);
+ virtual void drawRect(const SkRect& rect, const SkPaint&);
+ virtual void drawPath(const SkPath& path, const SkPaint&);
+ virtual void drawBitmap(const SkBitmap&, SkScalar left, SkScalar top,
+ const SkPaint*);
+ virtual void drawBitmapRect(const SkBitmap&, const SkIRect* src,
+ const SkRect& dst, const SkPaint*);
+ virtual void drawBitmapMatrix(const SkBitmap&, const SkMatrix&,
+ const SkPaint*);
+ virtual void drawSprite(const SkBitmap&, int left, int top,
+ const SkPaint*);
+ virtual void drawText(const void* text, size_t byteLength, SkScalar x,
+ SkScalar y, const SkPaint&);
+ virtual void drawPosText(const void* text, size_t byteLength,
+ const SkPoint pos[], const SkPaint&);
+ virtual void drawPosTextH(const void* text, size_t byteLength,
+ const SkScalar xpos[], SkScalar constY, const SkPaint&);
+ virtual void drawTextOnPath(const void* text, size_t byteLength,
+ const SkPath& path, const SkMatrix* matrix,
+ const SkPaint&);
+ virtual void drawPicture(SkPicture& picture);
+ virtual void drawShape(SkShape*);
+ virtual void drawVertices(VertexMode, int vertexCount,
+ const SkPoint vertices[], const SkPoint texs[],
+ const SkColor colors[], SkXfermode*,
+ const uint16_t indices[], int indexCount,
+ const SkPaint&);
+ virtual void drawData(const void*, size_t);
+
+private:
+ SkFactorySet* fFactorySet; // optional, only used if cross-process
+ SkGPipeController* fController;
+ SkWriter32& fWriter;
+ size_t fBlockSize; // amount allocated for writer
+ size_t fBytesNotified;
+ bool fDone;
+
+ SkRefCntSet fTypefaceSet;
+
+ uint32_t getTypefaceID(SkTypeface*);
+
+ inline void writeOp(DrawOps op, unsigned flags, unsigned data) {
+ fWriter.write32(DrawOp_packOpFlagData(op, flags, data));
+ }
+
+ inline void writeOp(DrawOps op) {
+ fWriter.write32(DrawOp_packOpFlagData(op, 0, 0));
+ }
+
+ bool needOpBytes(size_t size = 0);
+
+ inline void doNotify() {
+ if (!fDone) {
+ size_t bytes = fWriter.size() - fBytesNotified;
+ fController->notifyWritten(bytes);
+ fBytesNotified += bytes;
+ }
+ }
+
+ struct FlatData {
+ uint32_t fIndex; // always > 0
+ uint32_t fSize;
+
+ void* data() { return (char*)this + sizeof(*this); }
+
+ static int Compare(const FlatData* a, const FlatData* b) {
+ return memcmp(&a->fSize, &b->fSize, a->fSize + sizeof(a->fSize));
+ }
+ };
+ SkTDArray<FlatData*> fFlatArray;
+ int fCurrFlatIndex[kCount_PaintFlats];
+ int flattenToIndex(SkFlattenable* obj, PaintFlats);
+
+ SkPaint fPaint;
+ void writePaint(const SkPaint&);
+
+ class AutoPipeNotify {
+ public:
+ AutoPipeNotify(SkGPipeCanvas* canvas) : fCanvas(canvas) {}
+ ~AutoPipeNotify() { fCanvas->doNotify(); }
+ private:
+ SkGPipeCanvas* fCanvas;
+ };
+ friend class AutoPipeNotify;
+
+ typedef SkCanvas INHERITED;
+};
+
+// return 0 for NULL (or unflattenable obj), or index-base-1
+int SkGPipeCanvas::flattenToIndex(SkFlattenable* obj, PaintFlats paintflat) {
+ if (NULL == obj) {
+ return 0;
+ }
+
+ SkFlattenable::Factory fact = obj->getFactory();
+ if (NULL == fact) {
+ return 0;
+ }
+
+ if (fFactorySet) {
+ uint32_t id = fFactorySet->find((void*)fact);
+ if (0 == id) {
+ const char* name = SkFlattenable::FactoryToName(fact);
+ if (NULL == name) {
+ return 0;
+ }
+ size_t len = strlen(name);
+ size_t size = SkWriter32::WriteStringSize(name, len);
+ if (!this->needOpBytes(size)) {
+ return 0;
+ }
+ unsigned id = fFactorySet->add(fact);
+ this->writeOp(kName_Flattenable_DrawOp, paintflat, id);
+ fWriter.writeString(name, len);
+ }
+ }
+
+ SkFlattenableWriteBuffer tmpWriter(1024);
+ tmpWriter.setFactoryRecorder(fFactorySet);
+
+ tmpWriter.writeFlattenable(obj);
+ size_t len = tmpWriter.size();
+ size_t allocSize = len + sizeof(FlatData);
+
+ SkAutoSMalloc<1024> storage(allocSize);
+ FlatData* flat = (FlatData*)storage.get();
+ flat->fSize = len;
+ tmpWriter.flatten(flat->data());
+
+ int index = SkTSearch<FlatData>((const FlatData**)fFlatArray.begin(),
+ fFlatArray.count(), flat, sizeof(flat),
+ &FlatData::Compare);
+ if (index < 0) {
+ index = ~index;
+ FlatData* copy = (FlatData*)sk_malloc_throw(allocSize);
+ memcpy(copy, flat, allocSize);
+ *fFlatArray.insert(index) = copy;
+ // call this after the insert, so that count() will have been grown
+ copy->fIndex = fFlatArray.count();
+// SkDebugf("--- add flattenable[%d] size=%d index=%d\n", paintflat, len, copy->fIndex);
+
+ if (this->needOpBytes(len)) {
+ this->writeOp(kDef_Flattenable_DrawOp, paintflat, copy->fIndex);
+ fWriter.write(copy->data(), len);
+ }
+ }
+ return fFlatArray[index]->fIndex;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+#define MIN_BLOCK_SIZE (16 * 1024)
+
+SkGPipeCanvas::SkGPipeCanvas(SkGPipeController* controller,
+ SkWriter32* writer, SkFactorySet* fset)
+ : fWriter(*writer), fFactorySet(fset) {
+ fController = controller;
+ fDone = false;
+ fBlockSize = 0; // need first block from controller
+ sk_bzero(fCurrFlatIndex, sizeof(fCurrFlatIndex));
+
+ // we need a device to limit our clip
+ // should the caller give us the bounds?
+ SkBitmap bitmap;
+ bitmap.setConfig(SkBitmap::kARGB_8888_Config, 32767, 32767);
+ SkDevice* device = SkNEW_ARGS(SkDevice, (this, bitmap, false));
+ this->setDevice(device)->unref();
+}
+
+SkGPipeCanvas::~SkGPipeCanvas() {
+ this->finish();
+
+ fFlatArray.freeAll();
+}
+
+bool SkGPipeCanvas::needOpBytes(size_t needed) {
+ if (fDone) {
+ return false;
+ }
+
+ needed += 4; // size of DrawOp atom
+ if (fWriter.size() + needed > fBlockSize) {
+ void* block = fController->requestBlock(MIN_BLOCK_SIZE, &fBlockSize);
+ if (NULL == block) {
+ fDone = true;
+ return false;
+ }
+ fWriter.reset(block, fBlockSize);
+ fBytesNotified = 0;
+ }
+ return true;
+}
+
+uint32_t SkGPipeCanvas::getTypefaceID(SkTypeface* face) {
+ uint32_t id = 0; // 0 means default/null typeface
+ if (face) {
+ id = fTypefaceSet.find(face);
+ if (0 == id) {
+ id = fTypefaceSet.add(face);
+ size_t size = writeTypeface(NULL, face);
+ if (this->needOpBytes(size)) {
+ this->writeOp(kDef_Typeface_DrawOp);
+ writeTypeface(&fWriter, face);
+ }
+ }
+ }
+ return id;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+#define NOTIFY_SETUP(canvas) \
+ AutoPipeNotify apn(canvas)
+
+int SkGPipeCanvas::save(SaveFlags flags) {
+ NOTIFY_SETUP(this);
+ if (this->needOpBytes()) {
+ this->writeOp(kSave_DrawOp, 0, flags);
+ }
+ return this->INHERITED::save(flags);
+}
+
+int SkGPipeCanvas::saveLayer(const SkRect* bounds, const SkPaint* paint,
+ SaveFlags saveFlags) {
+ NOTIFY_SETUP(this);
+ size_t size = 0;
+ unsigned opFlags = 0;
+
+ if (bounds) {
+ opFlags |= kSaveLayer_HasBounds_DrawOpFlag;
+ size += sizeof(SkRect);
+ }
+ if (paint) {
+ opFlags |= kSaveLayer_HasPaint_DrawOpFlag;
+ this->writePaint(*paint);
+ }
+
+ if (this->needOpBytes(size)) {
+ this->writeOp(kSaveLayer_DrawOp, opFlags, saveFlags);
+ if (bounds) {
+ fWriter.writeRect(*bounds);
+ }
+ }
+
+ // we just pass on the save, so we don't create a layer
+ return this->INHERITED::save(saveFlags);
+}
+
+void SkGPipeCanvas::restore() {
+ NOTIFY_SETUP(this);
+ if (this->needOpBytes()) {
+ this->writeOp(kRestore_DrawOp);
+ }
+ this->INHERITED::restore();
+}
+
+bool SkGPipeCanvas::translate(SkScalar dx, SkScalar dy) {
+ if (dx || dy) {
+ NOTIFY_SETUP(this);
+ if (this->needOpBytes(2 * sizeof(SkScalar))) {
+ this->writeOp(kTranslate_DrawOp);
+ fWriter.writeScalar(dx);
+ fWriter.writeScalar(dy);
+ }
+ }
+ return this->INHERITED::translate(dx, dy);
+}
+
+bool SkGPipeCanvas::scale(SkScalar sx, SkScalar sy) {
+ if (sx || sy) {
+ NOTIFY_SETUP(this);
+ if (this->needOpBytes(2 * sizeof(SkScalar))) {
+ this->writeOp(kScale_DrawOp);
+ fWriter.writeScalar(sx);
+ fWriter.writeScalar(sy);
+ }
+ }
+ return this->INHERITED::scale(sx, sy);
+}
+
+bool SkGPipeCanvas::rotate(SkScalar degrees) {
+ if (degrees) {
+ NOTIFY_SETUP(this);
+ if (this->needOpBytes(sizeof(SkScalar))) {
+ this->writeOp(kRotate_DrawOp);
+ fWriter.writeScalar(degrees);
+ }
+ }
+ return this->INHERITED::rotate(degrees);
+}
+
+bool SkGPipeCanvas::skew(SkScalar sx, SkScalar sy) {
+ if (sx || sy) {
+ NOTIFY_SETUP(this);
+ if (this->needOpBytes(2 * sizeof(SkScalar))) {
+ this->writeOp(kSkew_DrawOp);
+ fWriter.writeScalar(sx);
+ fWriter.writeScalar(sy);
+ }
+ }
+ return this->INHERITED::skew(sx, sy);
+}
+
+bool SkGPipeCanvas::concat(const SkMatrix& matrix) {
+ if (!matrix.isIdentity()) {
+ NOTIFY_SETUP(this);
+ if (this->needOpBytes(matrix.flatten(NULL))) {
+ this->writeOp(kConcat_DrawOp);
+ SkWriteMatrix(&fWriter, matrix);
+ }
+ }
+ return this->INHERITED::concat(matrix);
+}
+
+void SkGPipeCanvas::setMatrix(const SkMatrix& matrix) {
+ NOTIFY_SETUP(this);
+ if (this->needOpBytes(matrix.flatten(NULL))) {
+ this->writeOp(kSetMatrix_DrawOp);
+ SkWriteMatrix(&fWriter, matrix);
+ }
+ this->INHERITED::setMatrix(matrix);
+}
+
+bool SkGPipeCanvas::clipRect(const SkRect& rect, SkRegion::Op rgnOp) {
+ NOTIFY_SETUP(this);
+ if (this->needOpBytes(sizeof(SkRect))) {
+ this->writeOp(kClipRect_DrawOp, 0, rgnOp);
+ fWriter.writeRect(rect);
+ }
+ return this->INHERITED::clipRect(rect, rgnOp);
+}
+
+bool SkGPipeCanvas::clipPath(const SkPath& path, SkRegion::Op rgnOp) {
+ NOTIFY_SETUP(this);
+ if (this->needOpBytes(estimateFlattenSize(path))) {
+ this->writeOp(kClipPath_DrawOp, 0, rgnOp);
+ path.flatten(fWriter);
+ }
+ // we just pass on the bounds of the path
+ return this->INHERITED::clipRect(path.getBounds(), rgnOp);
+}
+
+bool SkGPipeCanvas::clipRegion(const SkRegion& region, SkRegion::Op rgnOp) {
+ NOTIFY_SETUP(this);
+ if (this->needOpBytes(region.flatten(NULL))) {
+ this->writeOp(kClipRegion_DrawOp, 0, rgnOp);
+ SkWriteRegion(&fWriter, region);
+ }
+ return this->INHERITED::clipRegion(region, rgnOp);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void SkGPipeCanvas::clear(SkColor color) {
+ NOTIFY_SETUP(this);
+ unsigned flags = 0;
+ if (color) {
+ flags |= kClear_HasColor_DrawOpFlag;
+ }
+ if (this->needOpBytes(sizeof(SkColor))) {
+ this->writeOp(kDrawClear_DrawOp, flags, 0);
+ if (color) {
+ fWriter.write32(color);
+ }
+ }
+}
+
+void SkGPipeCanvas::drawPaint(const SkPaint& paint) {
+ NOTIFY_SETUP(this);
+ this->writePaint(paint);
+ if (this->needOpBytes()) {
+ this->writeOp(kDrawPaint_DrawOp);
+ }
+}
+
+void SkGPipeCanvas::drawPoints(PointMode mode, size_t count,
+ const SkPoint pts[], const SkPaint& paint) {
+ if (count) {
+ NOTIFY_SETUP(this);
+ this->writePaint(paint);
+ if (this->needOpBytes(4 + count * sizeof(SkPoint))) {
+ this->writeOp(kDrawPoints_DrawOp, mode, 0);
+ fWriter.write32(count);
+ fWriter.write(pts, count * sizeof(SkPoint));
+ }
+ }
+}
+
+void SkGPipeCanvas::drawRect(const SkRect& rect, const SkPaint& paint) {
+ NOTIFY_SETUP(this);
+ this->writePaint(paint);
+ if (this->needOpBytes(sizeof(SkRect))) {
+ this->writeOp(kDrawRect_DrawOp);
+ fWriter.writeRect(rect);
+ }
+}
+
+void SkGPipeCanvas::drawPath(const SkPath& path, const SkPaint& paint) {
+ NOTIFY_SETUP(this);
+ this->writePaint(paint);
+ if (this->needOpBytes(estimateFlattenSize(path))) {
+ this->writeOp(kDrawPath_DrawOp);
+ path.flatten(fWriter);
+ }
+}
+
+void SkGPipeCanvas::drawBitmap(const SkBitmap&, SkScalar left, SkScalar top,
+ const SkPaint*) {
+ UNIMPLEMENTED
+}
+
+void SkGPipeCanvas::drawBitmapRect(const SkBitmap&, const SkIRect* src,
+ const SkRect& dst, const SkPaint*) {
+ UNIMPLEMENTED
+}
+
+void SkGPipeCanvas::drawBitmapMatrix(const SkBitmap&, const SkMatrix&,
+ const SkPaint*) {
+ UNIMPLEMENTED
+}
+
+void SkGPipeCanvas::drawSprite(const SkBitmap&, int left, int top,
+ const SkPaint*) {
+ UNIMPLEMENTED
+}
+
+void SkGPipeCanvas::drawText(const void* text, size_t byteLength, SkScalar x,
+ SkScalar y, const SkPaint& paint) {
+ if (byteLength) {
+ NOTIFY_SETUP(this);
+ this->writePaint(paint);
+ if (this->needOpBytes(4 + SkAlign4(byteLength) + 2 * sizeof(SkScalar))) {
+ this->writeOp(kDrawText_DrawOp);
+ fWriter.write32(byteLength);
+ fWriter.writePad(text, byteLength);
+ fWriter.writeScalar(x);
+ fWriter.writeScalar(y);
+ }
+ }
+}
+
+void SkGPipeCanvas::drawPosText(const void* text, size_t byteLength,
+ const SkPoint pos[], const SkPaint& paint) {
+ if (byteLength) {
+ NOTIFY_SETUP(this);
+ this->writePaint(paint);
+ int count = paint.textToGlyphs(text, byteLength, NULL);
+ if (this->needOpBytes(4 + SkAlign4(byteLength) + 4 + count * sizeof(SkPoint))) {
+ this->writeOp(kDrawPosText_DrawOp);
+ fWriter.write32(byteLength);
+ fWriter.writePad(text, byteLength);
+ fWriter.write32(count);
+ fWriter.write(pos, count * sizeof(SkPoint));
+ }
+ }
+}
+
+void SkGPipeCanvas::drawPosTextH(const void* text, size_t byteLength,
+ const SkScalar xpos[], SkScalar constY,
+ const SkPaint& paint) {
+ if (byteLength) {
+ NOTIFY_SETUP(this);
+ this->writePaint(paint);
+ int count = paint.textToGlyphs(text, byteLength, NULL);
+ if (this->needOpBytes(4 + SkAlign4(byteLength) + 4 + count * sizeof(SkScalar) + 4)) {
+ this->writeOp(kDrawPosTextH_DrawOp);
+ fWriter.write32(byteLength);
+ fWriter.writePad(text, byteLength);
+ fWriter.write32(count);
+ fWriter.write(xpos, count * sizeof(SkScalar));
+ fWriter.writeScalar(constY);
+ }
+ }
+}
+
+void SkGPipeCanvas::drawTextOnPath(const void* text, size_t byteLength,
+ const SkPath& path, const SkMatrix* matrix,
+ const SkPaint& paint) {
+ if (byteLength) {
+ NOTIFY_SETUP(this);
+ unsigned flags = 0;
+ size_t size = 4 + SkAlign4(byteLength) + estimateFlattenSize(path);
+ if (matrix) {
+ flags |= kDrawTextOnPath_HasMatrix_DrawOpFlag;
+ size += matrix->flatten(NULL);
+ }
+ this->writePaint(paint);
+ if (this->needOpBytes(size)) {
+ this->writeOp(kDrawTextOnPath_DrawOp, flags, 0);
+
+ fWriter.write32(byteLength);
+ fWriter.writePad(text, byteLength);
+
+ path.flatten(fWriter);
+ if (matrix) {
+ SkWriteMatrix(&fWriter, *matrix);
+ }
+ }
+ }
+}
+
+void SkGPipeCanvas::drawPicture(SkPicture& picture) {
+ // we want to playback the picture into individual draw calls
+ this->INHERITED::drawPicture(picture);
+}
+
+void SkGPipeCanvas::drawShape(SkShape* shape) {
+ UNIMPLEMENTED
+}
+
+void SkGPipeCanvas::drawVertices(VertexMode mode, int vertexCount,
+ const SkPoint vertices[], const SkPoint texs[],
+ const SkColor colors[], SkXfermode*,
+ const uint16_t indices[], int indexCount,
+ const SkPaint& paint) {
+ if (0 == vertexCount) {
+ return;
+ }
+
+ NOTIFY_SETUP(this);
+ size_t size = 4 + vertexCount * sizeof(SkPoint);
+ this->writePaint(paint);
+ unsigned flags = 0;
+ if (texs) {
+ flags |= kDrawVertices_HasTexs_DrawOpFlag;
+ size += vertexCount * sizeof(SkPoint);
+ }
+ if (colors) {
+ flags |= kDrawVertices_HasColors_DrawOpFlag;
+ size += vertexCount * sizeof(SkColor);
+ }
+ if (indices && indexCount > 0) {
+ flags |= kDrawVertices_HasIndices_DrawOpFlag;
+ size += 4 + SkAlign4(indexCount * sizeof(uint16_t));
+ }
+
+ if (this->needOpBytes(size)) {
+ this->writeOp(kDrawVertices_DrawOp, flags, 0);
+ fWriter.write32(mode);
+ fWriter.write32(vertexCount);
+ fWriter.write(vertices, vertexCount * sizeof(SkPoint));
+ if (texs) {
+ fWriter.write(texs, vertexCount * sizeof(SkPoint));
+ }
+ if (colors) {
+ fWriter.write(colors, vertexCount * sizeof(SkColor));
+ }
+
+ // TODO: flatten xfermode
+
+ if (indices && indexCount > 0) {
+ fWriter.write32(indexCount);
+ fWriter.writePad(indices, indexCount * sizeof(uint16_t));
+ }
+ }
+}
+
+void SkGPipeCanvas::drawData(const void* ptr, size_t size) {
+ if (size && ptr) {
+ NOTIFY_SETUP(this);
+ unsigned data = 0;
+ if (size < (1 << DRAWOPS_DATA_BITS)) {
+ data = (unsigned)size;
+ }
+ if (this->needOpBytes(4 + SkAlign4(size))) {
+ this->writeOp(kDrawData_DrawOp, 0, data);
+ if (0 == data) {
+ fWriter.write32(size);
+ }
+ fWriter.writePad(ptr, size);
+ }
+ }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+template <typename T> uint32_t castToU32(T value) {
+ union {
+ T fSrc;
+ uint32_t fDst;
+ } data;
+ data.fSrc = value;
+ return data.fDst;
+}
+
+void SkGPipeCanvas::writePaint(const SkPaint& paint) {
+ SkPaint& base = fPaint;
+ uint32_t storage[32];
+ uint32_t* ptr = storage;
+
+ if (base.getFlags() != paint.getFlags()) {
+ *ptr++ = PaintOp_packOpData(kFlags_PaintOp, paint.getFlags());
+ base.setFlags(paint.getFlags());
+ }
+ if (base.getColor() != paint.getColor()) {
+ *ptr++ = PaintOp_packOp(kColor_PaintOp);
+ *ptr++ = paint.getColor();
+ base.setColor(paint.getColor());
+ }
+ if (base.getStyle() != paint.getStyle()) {
+ *ptr++ = PaintOp_packOpData(kStyle_PaintOp, paint.getStyle());
+ base.setStyle(paint.getStyle());
+ }
+ if (base.getStrokeJoin() != paint.getStrokeJoin()) {
+ *ptr++ = PaintOp_packOpData(kJoin_PaintOp, paint.getStrokeJoin());
+ base.setStrokeJoin(paint.getStrokeJoin());
+ }
+ if (base.getStrokeCap() != paint.getStrokeCap()) {
+ *ptr++ = PaintOp_packOpData(kCap_PaintOp, paint.getStrokeCap());
+ base.setStrokeCap(paint.getStrokeCap());
+ }
+ if (base.getStrokeWidth() != paint.getStrokeWidth()) {
+ *ptr++ = PaintOp_packOp(kWidth_PaintOp);
+ *ptr++ = castToU32(paint.getStrokeWidth());
+ base.setStrokeWidth(paint.getStrokeWidth());
+ }
+ if (base.getStrokeMiter() != paint.getStrokeMiter()) {
+ *ptr++ = PaintOp_packOp(kMiter_PaintOp);
+ *ptr++ = castToU32(paint.getStrokeMiter());
+ base.setStrokeMiter(paint.getStrokeMiter());
+ }
+ if (base.getTextEncoding() != paint.getTextEncoding()) {
+ *ptr++ = PaintOp_packOpData(kEncoding_PaintOp, paint.getTextEncoding());
+ base.setTextEncoding(paint.getTextEncoding());
+ }
+ if (base.getHinting() != paint.getHinting()) {
+ *ptr++ = PaintOp_packOpData(kHinting_PaintOp, paint.getHinting());
+ base.setHinting(paint.getHinting());
+ }
+ if (base.getTextAlign() != paint.getTextAlign()) {
+ *ptr++ = PaintOp_packOpData(kAlign_PaintOp, paint.getTextAlign());
+ base.setTextAlign(paint.getTextAlign());
+ }
+ if (base.getTextSize() != paint.getTextSize()) {
+ *ptr++ = PaintOp_packOp(kTextSize_PaintOp);
+ *ptr++ = castToU32(paint.getTextSize());
+ base.setTextSize(paint.getTextSize());
+ }
+ if (base.getTextScaleX() != paint.getTextScaleX()) {
+ *ptr++ = PaintOp_packOp(kTextScaleX_PaintOp);
+ *ptr++ = castToU32(paint.getTextScaleX());
+ base.setTextScaleX(paint.getTextScaleX());
+ }
+ if (base.getTextSkewX() != paint.getTextSkewX()) {
+ *ptr++ = PaintOp_packOp(kTextSkewX_PaintOp);
+ *ptr++ = castToU32(paint.getTextSkewX());
+ base.setTextSkewX(paint.getTextSkewX());
+ }
+
+ if (!SkTypeface::Equal(base.getTypeface(), paint.getTypeface())) {
+ uint32_t id = this->getTypefaceID(paint.getTypeface());
+ *ptr++ = PaintOp_packOpData(kTypeface_PaintOp, id);
+ base.setTypeface(paint.getTypeface());
+ }
+
+ for (int i = 0; i < kCount_PaintFlats; i++) {
+ int index = this->flattenToIndex(get_paintflat(paint, i), (PaintFlats)i);
+ SkASSERT(index >= 0 && index <= fFlatArray.count());
+ if (index != fCurrFlatIndex[i]) {
+ *ptr++ = PaintOp_packOpFlagData(kFlatIndex_PaintOp, i, index);
+ fCurrFlatIndex[i] = index;
+ }
+ }
+
+ size_t size = (char*)ptr - (char*)storage;
+ if (size && this->needOpBytes(size)) {
+ this->writeOp(kPaintOp_DrawOp, 0, size);
+ fWriter.write(storage, size);
+ for (size_t i = 0; i < size/4; i++) {
+// SkDebugf("[%d] %08X\n", i, storage[i]);
+ }
+ }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+#include "SkGPipe.h"
+
+SkGPipeWriter::SkGPipeWriter() : fWriter(0) {
+ fCanvas = NULL;
+}
+
+SkGPipeWriter::~SkGPipeWriter() {
+ this->endRecording();
+ SkSafeUnref(fCanvas);
+}
+
+SkCanvas* SkGPipeWriter::startRecording(SkGPipeController* controller,
+ uint32_t flags) {
+ if (NULL == fCanvas) {
+ fWriter.reset(NULL, 0);
+ fFactorySet.reset();
+ fCanvas = SkNEW_ARGS(SkGPipeCanvas, (controller, &fWriter,
+ (flags & kCrossProcess_Flag) ?
+ &fFactorySet : NULL));
+ }
+ return fCanvas;
+}
+
+void SkGPipeWriter::endRecording() {
+ if (fCanvas) {
+ fCanvas->finish();
+ fCanvas->unref();
+ fCanvas = NULL;
+ }
+}
+
diff --git a/src/ports/SkFontHost_FreeType.cpp b/src/ports/SkFontHost_FreeType.cpp
index b3cc783..de1ce73 100644
--- a/src/ports/SkFontHost_FreeType.cpp
+++ b/src/ports/SkFontHost_FreeType.cpp
@@ -72,6 +72,14 @@
using namespace skia_advanced_typeface_metrics_utils;
+// SK_FREETYPE_LCD_LERP should be 0...256
+// 0 means no color reduction (e.g. just as returned from FreeType)
+// 256 means 100% color reduction (e.g. gray)
+//
+#ifndef SK_FREETYPE_LCD_LERP
+ #define SK_FREETYPE_LCD_LERP 96
+#endif
+
//////////////////////////////////////////////////////////////////////////
struct SkFaceRec;
@@ -906,7 +914,7 @@
}
switch ( fFace->glyph->format ) {
- case FT_GLYPH_FORMAT_OUTLINE:
+ case FT_GLYPH_FORMAT_OUTLINE: {
FT_BBox bbox;
if (fRec.fFlags & kEmbolden_Flag) {
@@ -934,6 +942,7 @@
glyph->fTop = -SkToS16(bbox.yMax >> 6);
glyph->fLeft = SkToS16(bbox.xMin >> 6);
break;
+ }
case FT_GLYPH_FORMAT_BITMAP:
if (fRec.fFlags & kEmbolden_Flag) {
@@ -979,6 +988,22 @@
using namespace skia_freetype_support;
#endif
+static int lerp(int start, int end) {
+ SkASSERT((unsigned)SK_FREETYPE_LCD_LERP <= 256);
+ return start + ((end - start) * (SK_FREETYPE_LCD_LERP) >> 8);
+}
+
+static uint16_t packTriple(unsigned r, unsigned g, unsigned b) {
+ if (SK_FREETYPE_LCD_LERP) {
+ // want (a+b+c)/3, but we approx to avoid the divide
+ unsigned ave = (5 * (r + g + b) + b) >> 4;
+ r = lerp(r, ave);
+ g = lerp(g, ave);
+ b = lerp(b, ave);
+ }
+ return SkPackRGB16(r >> 3, g >> 2, b >> 3);
+}
+
static void copyFT2LCD16(const SkGlyph& glyph, const FT_Bitmap& bitmap) {
SkASSERT(glyph.fWidth * 3 == bitmap.width - 6);
SkASSERT(glyph.fHeight == bitmap.rows);
@@ -991,7 +1016,7 @@
for (int y = 0; y < glyph.fHeight; y++) {
const uint8_t* triple = src;
for (int x = 0; x < width; x++) {
- dst[x] = SkPackRGB16(triple[0] >> 3, triple[1] >> 2, triple[2] >> 3);
+ dst[x] = packTriple(triple[0], triple[1], triple[2]);
triple += 3;
}
src += bitmap.pitch;
diff --git a/src/ports/SkFontHost_linux.cpp b/src/ports/SkFontHost_linux.cpp
index 9aabce7..37c2c35 100644
--- a/src/ports/SkFontHost_linux.cpp
+++ b/src/ports/SkFontHost_linux.cpp
@@ -391,7 +391,7 @@
static void load_system_fonts() {
// check if we've already be called
if (NULL != gDefaultNormal) {
- printf("---- default font %p\n", gDefaultNormal);
+// printf("---- default font %p\n", gDefaultNormal);
return;
}
diff --git a/src/ports/SkFontHost_mac_coretext.cpp b/src/ports/SkFontHost_mac_coretext.cpp
index e637877..ad57e16 100644
--- a/src/ports/SkFontHost_mac_coretext.cpp
+++ b/src/ports/SkFontHost_mac_coretext.cpp
@@ -18,13 +18,17 @@
#include "SkFontHost.h"
#include "SkDescriptor.h"
+#include "SkEndian.h"
#include "SkFloatingPoint.h"
#include "SkPaint.h"
#include "SkString.h"
+#include "SkStream.h"
#include "SkTypeface_mac.h"
#include "SkUtils.h"
#include "SkTypefaceCache.h"
+using namespace skia_advanced_typeface_metrics_utils;
+
static const size_t FONT_CACHE_MEMORY_BUDGET = 1024 * 1024;
static const char FONT_DEFAULT_NAME[] = "Lucida Sans";
@@ -400,6 +404,28 @@
}
}
+#if 1
+static inline int r32_to_16(int x) { return SkR32ToR16(x); }
+static inline int g32_to_16(int x) { return SkG32ToG16(x); }
+static inline int b32_to_16(int x) { return SkB32ToB16(x); }
+#else
+static inline int round8to5(int x) {
+ return (x + 3 - (x >> 5) + (x >> 7)) >> 3;
+}
+static inline int round8to6(int x) {
+ int xx = (x + 1 - (x >> 6) + (x >> 7)) >> 2;
+ SkASSERT((unsigned)xx <= 63);
+
+ int ix = x >> 2;
+ SkASSERT(SkAbs32(xx - ix) <= 1);
+ return xx;
+}
+
+static inline int r32_to_16(int x) { return round8to5(x); }
+static inline int g32_to_16(int x) { return round8to6(x); }
+static inline int b32_to_16(int x) { return round8to5(x); }
+#endif
+
static inline uint16_t rgb_to_lcd16(uint32_t rgb) {
int r = (rgb >> 16) & 0xFF;
int g = (rgb >> 8) & 0xFF;
@@ -411,7 +437,7 @@
g = 255 - g;
b = 255 - b;
- return SkPackRGB16(SkR32ToR16(r), SkG32ToG16(g), SkB32ToB16(b));
+ return SkPackRGB16(r32_to_16(r), g32_to_16(g), b32_to_16(b));
}
#define BITMAP_INFO_RGB (kCGImageAlphaNoneSkipFirst | kCGBitmapByteOrder32Host)
@@ -604,12 +630,141 @@
return SkFontHost::CreateTypeface(NULL, NULL, NULL, NULL, SkTypeface::kNormal);
}
+// Construct Glyph to Unicode table.
+// Unicode code points that require conjugate pairs in utf16 are not
+// supported.
+static void populate_glyph_to_unicode(CTFontRef ctFont,
+ const unsigned glyphCount, SkTDArray<SkUnichar>* glyphToUnicode) {
+ CFCharacterSetRef charSet = CTFontCopyCharacterSet(ctFont);
+ CFDataRef bitmap = CFCharacterSetCreateBitmapRepresentation(
+ kCFAllocatorDefault, charSet);
+ if (!bitmap) {
+ return;
+ }
+ CFIndex length = CFDataGetLength(bitmap);
+ if (!length) {
+ CFSafeRelease(bitmap);
+ return;
+ }
+ if (length > 8192) {
+ // TODO: Add support for Unicode above 0xFFFF
+ // Consider only the BMP portion of the Unicode character points.
+ // The bitmap may contain other planes, up to plane 16.
+ // See http://developer.apple.com/library/ios/#documentation/CoreFoundation/Reference/CFCharacterSetRef/Reference/reference.html
+ length = 8192;
+ }
+ const UInt8* bits = CFDataGetBytePtr(bitmap);
+ glyphToUnicode->setCount(glyphCount);
+ SkUnichar* out = glyphToUnicode->begin();
+ sk_bzero(out, glyphCount * sizeof(SkUnichar));
+ for (int i = 0; i < length; i++) {
+ int mask = bits[i];
+ if (!mask) {
+ continue;
+ }
+ for (int j = 0; j < 8; j++) {
+ CGGlyph glyph;
+ UniChar unichar = static_cast<UniChar>((i << 3) + j);
+ if (mask & (1 << j) && CTFontGetGlyphsForCharacters(ctFont,
+ &unichar, &glyph, 1)) {
+ out[glyph] = unichar;
+ }
+ }
+ }
+ CFSafeRelease(bitmap);
+}
+
+static bool getWidthAdvance(CTFontRef ctFont, int gId, int16_t* data) {
+ CGSize advance;
+ advance.width = 0;
+ CGGlyph glyph = gId;
+ CTFontGetAdvancesForGlyphs(ctFont, kCTFontHorizontalOrientation, &glyph,
+ &advance, 1);
+ *data = advance.width;
+ return true;
+}
+
// static
SkAdvancedTypefaceMetrics* SkFontHost::GetAdvancedTypefaceMetrics(
uint32_t fontID,
SkAdvancedTypefaceMetrics::PerGlyphInfo perGlyphInfo) {
- SkASSERT(!"SkFontHost::GetAdvancedTypefaceMetrics unimplemented");
- return NULL;
+ CTFontRef ctFont = GetFontRefFromFontID(fontID);
+ SkAdvancedTypefaceMetrics* info = new SkAdvancedTypefaceMetrics;
+ CFStringRef fontName = CTFontCopyPostScriptName(ctFont);
+ int length = CFStringGetMaximumSizeForEncoding(CFStringGetLength(fontName),
+ kCFStringEncodingUTF8);
+ info->fFontName.resize(length);
+ CFStringGetCString(fontName, info->fFontName.writable_str(), length,
+ kCFStringEncodingUTF8);
+ info->fMultiMaster = false;
+ CFIndex glyphCount = CTFontGetGlyphCount(ctFont);
+ info->fLastGlyphID = SkToU16(glyphCount - 1);
+ info->fEmSize = CTFontGetUnitsPerEm(ctFont);
+
+ if (perGlyphInfo & SkAdvancedTypefaceMetrics::kToUnicode_PerGlyphInfo) {
+ populate_glyph_to_unicode(ctFont, glyphCount, &info->fGlyphToUnicode);
+ }
+
+ // TODO: get font type, ala:
+ // CFTypeRef attr = CTFontCopyAttribute(ctFont, kCTFontFormatAttribute);
+ info->fType = SkAdvancedTypefaceMetrics::kTrueType_Font;
+ info->fStyle = 0;
+ CTFontSymbolicTraits symbolicTraits = CTFontGetSymbolicTraits(ctFont);
+ if (symbolicTraits & kCTFontMonoSpaceTrait) {
+ info->fStyle |= SkAdvancedTypefaceMetrics::kFixedPitch_Style;
+ }
+ if (symbolicTraits & kCTFontItalicTrait) {
+ info->fStyle |= SkAdvancedTypefaceMetrics::kItalic_Style;
+ }
+ CTFontStylisticClass stylisticClass = symbolicTraits &
+ kCTFontClassMaskTrait;
+ if (stylisticClass & kCTFontSymbolicClass) {
+ info->fStyle |= SkAdvancedTypefaceMetrics::kSymbolic_Style;
+ }
+ if (stylisticClass >= kCTFontOldStyleSerifsClass
+ && stylisticClass <= kCTFontSlabSerifsClass) {
+ info->fStyle |= SkAdvancedTypefaceMetrics::kSerif_Style;
+ } else if (stylisticClass & kCTFontScriptsClass) {
+ info->fStyle |= SkAdvancedTypefaceMetrics::kScript_Style;
+ }
+ info->fItalicAngle = CTFontGetSlantAngle(ctFont);
+ info->fAscent = CTFontGetAscent(ctFont);
+ info->fDescent = CTFontGetDescent(ctFont);
+ info->fCapHeight = CTFontGetCapHeight(ctFont);
+ CGRect bbox = CTFontGetBoundingBox(ctFont);
+ info->fBBox = SkIRect::MakeXYWH(bbox.origin.x, bbox.origin.y,
+ bbox.size.width, bbox.size.height);
+
+ // Figure out a good guess for StemV - Min width of i, I, !, 1.
+ // This probably isn't very good with an italic font.
+ int16_t min_width = SHRT_MAX;
+ info->fStemV = 0;
+ static const UniChar stem_chars[] = {'i', 'I', '!', '1'};
+ const size_t count = sizeof(stem_chars) / sizeof(stem_chars[0]);
+ CGGlyph glyphs[count];
+ CGRect boundingRects[count];
+ if (CTFontGetGlyphsForCharacters(ctFont, stem_chars, glyphs, count)) {
+ CTFontGetBoundingRectsForGlyphs(ctFont, kCTFontHorizontalOrientation,
+ glyphs, boundingRects, count);
+ for (size_t i = 0; i < count; i++) {
+ int16_t width = boundingRects[i].size.width;
+ if (width > 0 && width < min_width) {
+ min_width = width;
+ info->fStemV = min_width;
+ }
+ }
+ }
+
+ if (false) { // TODO: haven't figured out how to know if font is embeddable
+ // (information is in the OS/2 table)
+ info->fType = SkAdvancedTypefaceMetrics::kNotEmbeddable_Font;
+ } else if (perGlyphInfo &
+ SkAdvancedTypefaceMetrics::kHAdvance_PerGlyphInfo) {
+ info->fGlyphWidths.reset(
+ getAdvanceData(ctFont, glyphCount, &getWidthAdvance));
+ }
+
+ return info;
}
///////////////////////////////////////////////////////////////////////////////
@@ -618,9 +773,88 @@
return SkTypefaceCache::FindByID(fontID) != NULL;
}
+struct FontHeader {
+ SkFixed fVersion;
+ uint16_t fNumTables;
+ uint16_t fSearchRange;
+ uint16_t fEntrySelector;
+ uint16_t fRangeShift;
+};
+
+struct TableEntry {
+ uint32_t fTag;
+ uint32_t fCheckSum;
+ uint32_t fOffset;
+ uint32_t fLength;
+};
+
+static uint32 CalcTableCheckSum(uint32 *table, uint32 numberOfBytesInTable) {
+ uint32 sum = 0;
+ uint32 nLongs = (numberOfBytesInTable + 3) / 4;
+
+ while (nLongs-- > 0) {
+ sum += SkEndian_SwapBE32(*table++);
+ }
+ return sum;
+}
+
SkStream* SkFontHost::OpenStream(SkFontID uniqueID) {
- SkASSERT(!"SkFontHost::OpenStream unimplemented");
- return(NULL);
+ // get table tags
+ int tableCount = CountTables(uniqueID);
+ SkTDArray<SkFontTableTag> tableTags;
+ tableTags.setCount(tableCount);
+ GetTableTags(uniqueID, tableTags.begin());
+
+ // calc total size for font, save sizes
+ SkTDArray<size_t> tableSizes;
+ size_t totalSize = sizeof(FontHeader) + sizeof(TableEntry) * tableCount;
+ for (int index = 0; index < tableCount; ++index) {
+ size_t tableSize = GetTableSize(uniqueID, tableTags[index]);
+ totalSize += (tableSize + 3) & ~3;
+ *tableSizes.append() = tableSize;
+ }
+
+ // reserve memory for stream, and zero it (tables must be zero padded)
+ SkMemoryStream* stream = new SkMemoryStream(totalSize);
+ char* dataStart = (char*)stream->getMemoryBase();
+ sk_bzero(dataStart, totalSize);
+ char* dataPtr = dataStart;
+
+ // compute font header entries
+ uint16_t entrySelector = 0;
+ uint16_t searchRange = 1;
+ while (searchRange < tableCount >> 1) {
+ entrySelector++;
+ searchRange <<= 1;
+ }
+ searchRange <<= 4;
+ uint16_t rangeShift = (tableCount << 4) - searchRange;
+
+ // write font header (also called sfnt header, offset subtable)
+ FontHeader* offsetTable = (FontHeader*)dataPtr;
+ offsetTable->fVersion = SkEndian_SwapBE32(SK_Fixed1);
+ offsetTable->fNumTables = SkEndian_SwapBE16(tableCount);
+ offsetTable->fSearchRange = SkEndian_SwapBE16(searchRange);
+ offsetTable->fEntrySelector = SkEndian_SwapBE16(entrySelector);
+ offsetTable->fRangeShift = SkEndian_SwapBE16(rangeShift);
+ dataPtr += sizeof(FontHeader);
+
+ // write tables
+ TableEntry* entry = (TableEntry*)dataPtr;
+ dataPtr += sizeof(TableEntry) * tableCount;
+ for (int index = 0; index < tableCount; ++index) {
+ size_t tableSize = tableSizes[index];
+ GetTableData(uniqueID, tableTags[index], 0, tableSize, dataPtr);
+ entry->fTag = SkEndian_SwapBE32(tableTags[index]);
+ entry->fCheckSum = SkEndian_SwapBE32(CalcTableCheckSum(
+ (uint32*)dataPtr, tableSize));
+ entry->fOffset = SkEndian_SwapBE32(dataPtr - dataStart);
+ entry->fLength = SkEndian_SwapBE32(tableSize);
+ dataPtr += (tableSize + 3) & ~3;
+ ++entry;
+ }
+
+ return stream;
}
size_t SkFontHost::GetFileName(SkFontID fontID, char path[], size_t length,
diff --git a/src/ports/SkFontHost_win.cpp b/src/ports/SkFontHost_win.cpp
index d9404f3..f5d126e 100755
--- a/src/ports/SkFontHost_win.cpp
+++ b/src/ports/SkFontHost_win.cpp
@@ -83,7 +83,8 @@
static unsigned calculateGlyphCount(HDC hdc) {
// The 'maxp' table stores the number of glyphs at offset 4, in 2 bytes.
- const DWORD maxpTag = *(DWORD*) "maxp";
+ const DWORD maxpTag =
+ SkEndian_SwapBE32(SkSetFourByteTag('m', 'a', 'x', 'p'));
uint16_t glyphs;
if (GetFontData(hdc, maxpTag, 4, &glyphs, sizeof(glyphs)) != GDI_ERROR) {
return SkEndian_SwapBE16(glyphs);
@@ -271,6 +272,10 @@
HFONT fFont;
SCRIPT_CACHE fSC;
int fGlyphCount;
+
+ HFONT fHiResFont;
+ MAT2 fMat22Identity;
+ SkMatrix fHiResMatrix;
};
static float mul2float(SkScalar a, SkScalar b) {
@@ -283,6 +288,16 @@
static SkMutex gFTMutex;
+#define HIRES_TEXTSIZE 2048
+#define HIRES_SHIFT 11
+static inline SkFixed HiResToFixed(int value) {
+ return value << (16 - HIRES_SHIFT);
+}
+
+static bool needHiResMetrics(const SkScalar mat[2][2]) {
+ return mat[1][0] || mat[0][1];
+}
+
SkScalerContext_Windows::SkScalerContext_Windows(const SkDescriptor* desc)
: SkScalerContext(desc), fDDC(0), fFont(0), fSavefont(0), fSC(0)
, fGlyphCount(-1) {
@@ -303,6 +318,7 @@
fMat22.eM22 = float2FIXED(-fXform.eM22);
fDDC = ::CreateCompatibleDC(NULL);
+ SetGraphicsMode(fDDC, GM_ADVANCED);
SetBkMode(fDDC, TRANSPARENT);
// Scaling by the DPI is inconsistent with how Skia draws elsewhere
@@ -311,6 +327,21 @@
GetLogFontByID(fRec.fFontID, &lf);
lf.lfHeight = -gCanonicalTextSize;
fFont = CreateFontIndirect(&lf);
+
+ // if we're rotated, or want fractional widths, create a hires font
+ fHiResFont = 0;
+ if (needHiResMetrics(fRec.fPost2x2) || (fRec.fFlags & kSubpixelPositioning_Flag)) {
+ lf.lfHeight = -HIRES_TEXTSIZE;
+ fHiResFont = CreateFontIndirect(&lf);
+
+ fMat22Identity.eM11 = fMat22Identity.eM22 = SkFixedToFIXED(SK_Fixed1);
+ fMat22Identity.eM12 = fMat22Identity.eM21 = SkFixedToFIXED(0);
+
+ // construct a matrix to go from HIRES logical units to our device units
+ fRec.getSingleMatrix(&fHiResMatrix);
+ SkScalar scale = SkScalarInvert(SkIntToScalar(HIRES_TEXTSIZE));
+ fHiResMatrix.preScale(scale, scale);
+ }
fSavefont = (HFONT)SelectObject(fDDC, fFont);
}
@@ -322,6 +353,9 @@
if (fFont) {
::DeleteObject(fFont);
}
+ if (fHiResFont) {
+ ::DeleteObject(fHiResFont);
+ }
if (fSC) {
::ScriptFreeCache(&fSC);
}
@@ -368,7 +402,7 @@
SkASSERT(fDDC);
GLYPHMETRICS gm;
- memset(&gm, 0, sizeof(gm));
+ sk_bzero(&gm, sizeof(gm));
glyph->fRsbDelta = 0;
glyph->fLsbDelta = 0;
@@ -399,6 +433,19 @@
glyph->fTop -= 1;
glyph->fLeft -= 1;
}
+
+ if (fHiResFont) {
+ SelectObject(fDDC, fHiResFont);
+ sk_bzero(&gm, sizeof(gm));
+ ret = GetGlyphOutlineW(fDDC, glyph->getGlyphID(0), GGO_METRICS | GGO_GLYPH_INDEX, &gm, 0, NULL, &fMat22Identity);
+ if (GDI_ERROR != ret) {
+ SkPoint advance;
+ fHiResMatrix.mapXY(SkIntToScalar(gm.gmCellIncX), SkIntToScalar(gm.gmCellIncY), &advance);
+ glyph->fAdvanceX = SkScalarToFixed(advance.fX);
+ glyph->fAdvanceY = SkScalarToFixed(advance.fY);
+ }
+ SelectObject(fDDC, fFont);
+ }
} else {
glyph->fWidth = 0;
}
@@ -453,34 +500,53 @@
return SkPackRGB16(SkR32ToR16(r), SkG32ToG16(g), SkB32ToB16(b));
}
+static int alignTo32(int n) {
+ return (n + 31) & ~31;
+}
+
+struct MyBitmapInfo : public BITMAPINFO {
+ RGBQUAD fMoreSpaceForColors[1];
+};
+
void SkScalerContext_Windows::generateImage(const SkGlyph& glyph) {
SkAutoMutexAcquire ac(gFTMutex);
SkASSERT(fDDC);
- if (SkMask::kLCD16_Format == fRec.fMaskFormat) {
+ const bool isBW = SkMask::kBW_Format == fRec.fMaskFormat;
+ if ((SkMask::kLCD16_Format == fRec.fMaskFormat) || isBW) {
HDC dc = CreateCompatibleDC(0);
void* bits = 0;
- BITMAPINFO info;
+ int biWidth = isBW ? alignTo32(glyph.fWidth) : glyph.fWidth;
+ MyBitmapInfo info;
sk_bzero(&info, sizeof(info));
+ if (isBW) {
+ RGBQUAD blackQuad = { 0, 0, 0, 0 };
+ RGBQUAD whiteQuad = { 0xFF, 0xFF, 0xFF, 0 };
+ info.bmiColors[0] = blackQuad;
+ info.bmiColors[1] = whiteQuad;
+ }
info.bmiHeader.biSize = sizeof(info.bmiHeader);
- info.bmiHeader.biWidth = glyph.fWidth;
+ info.bmiHeader.biWidth = biWidth;
info.bmiHeader.biHeight = glyph.fHeight;
info.bmiHeader.biPlanes = 1;
- info.bmiHeader.biBitCount = 32;
+ info.bmiHeader.biBitCount = isBW ? 1 : 32;
info.bmiHeader.biCompression = BI_RGB;
+ if (isBW) {
+ info.bmiHeader.biClrUsed = 2;
+ }
HBITMAP bm = CreateDIBSection(dc, &info, DIB_RGB_COLORS, &bits, 0, 0);
SelectObject(dc, bm);
// erase to white
- size_t srcRB = glyph.fWidth << 2;
+ size_t srcRB = isBW ? (biWidth >> 3) : (glyph.fWidth << 2);
size_t size = glyph.fHeight * srcRB;
- memset(bits, 0xFF, size);
+ memset(bits, isBW ? 0 : 0xFF, size);
+ SetGraphicsMode(dc, GM_ADVANCED);
SetBkMode(dc, TRANSPARENT);
SetTextAlign(dc, TA_LEFT | TA_BASELINE);
- SetGraphicsMode(dc, GM_ADVANCED);
XFORM xform = fXform;
xform.eDx = (float)-glyph.fLeft;
@@ -488,7 +554,7 @@
SetWorldTransform(dc, &xform);
HGDIOBJ prevFont = SelectObject(dc, fFont);
- COLORREF color = SetTextColor(dc, 0); // black
+ COLORREF color = SetTextColor(dc, isBW ? 0xFFFFFF : 0);
SkASSERT(color != CLR_INVALID);
uint16_t glyphID = glyph.getGlyphID();
#if defined(UNICODE)
@@ -501,15 +567,26 @@
// downsample from rgba to rgb565
int width = glyph.fWidth;
size_t dstRB = glyph.rowBytes();
- const uint32_t* src = (const uint32_t*)bits;
- // gdi's bitmap is upside-down, so we reverse dst walking in Y
- uint16_t* dst = (uint16_t*)((char*)glyph.fImage + (glyph.fHeight - 1) * dstRB);
- for (int y = 0; y < glyph.fHeight; y++) {
- for (int i = 0; i < width; i++) {
- dst[i] = rgb_to_lcd16(src[i]);
+ if (isBW) {
+ const uint8_t* src = (const uint8_t*)bits;
+ // gdi's bitmap is upside-down, so we reverse dst walking in Y
+ uint8_t* dst = (uint8_t*)((char*)glyph.fImage + (glyph.fHeight - 1) * dstRB);
+ for (int y = 0; y < glyph.fHeight; y++) {
+ memcpy(dst, src, dstRB);
+ src += srcRB;
+ dst -= dstRB;
}
- src = (const uint32_t*)((const char*)src + srcRB);
- dst = (uint16_t*)((char*)dst - dstRB);
+ } else { // LCD16
+ const uint32_t* src = (const uint32_t*)bits;
+ // gdi's bitmap is upside-down, so we reverse dst walking in Y
+ uint16_t* dst = (uint16_t*)((char*)glyph.fImage + (glyph.fHeight - 1) * dstRB);
+ for (int y = 0; y < glyph.fHeight; y++) {
+ for (int i = 0; i < width; i++) {
+ dst[i] = rgb_to_lcd16(src[i]);
+ }
+ src = (const uint32_t*)((const char*)src + srcRB);
+ dst = (uint16_t*)((char*)dst - dstRB);
+ }
}
DeleteDC(dc);
@@ -790,7 +867,8 @@
}
SkStream* SkFontHost::OpenStream(SkFontID uniqueID) {
- const DWORD kTTCTag = *(DWORD*) "ttcf";
+ const DWORD kTTCTag =
+ SkEndian_SwapBE32(SkSetFourByteTag('t', 't', 'c', 'f'));
LOGFONT lf;
GetLogFontByID(uniqueID, &lf);
@@ -896,10 +974,6 @@
if (SkMask::kLCD16_Format == rec->fMaskFormat) {
return;
}
- // we never like BW format
- if (SkMask::kBW_Format == rec->fMaskFormat) {
- rec->fMaskFormat = SkMask::kA8_Format;
- }
if (SkMask::FormatIsLCD((SkMask::Format)rec->fMaskFormat)) {
rec->fMaskFormat = SkMask::kA8_Format;
diff --git a/src/svg/SkSVGParser.cpp b/src/svg/SkSVGParser.cpp
index df86178..f4ad198 100644
--- a/src/svg/SkSVGParser.cpp
+++ b/src/svg/SkSVGParser.cpp
@@ -76,8 +76,8 @@
int SkSVGParser::findAttribute(SkSVGBase* element, const char* attrValue,
size_t len, bool isPaint) {
const SkSVGAttribute* attributes;
- int count = element->getAttributes(&attributes);
- int result = 0;
+ size_t count = element->getAttributes(&attributes);
+ size_t result = 0;
while (result < count) {
if (strncmp(attributes->fName, attrValue, len) == 0 && strlen(attributes->fName) == len) {
SkASSERT(result == (attributes->fOffset -
@@ -200,7 +200,7 @@
} else if (fInSVG == false)
return false;
const char* nextColon = strchr(name, ':');
- if (nextColon && nextColon - name < len)
+ if (nextColon && (size_t)(nextColon - name) < len)
return false;
SkSVGTypes type = GetType(name, len);
// SkASSERT(type >= 0);
diff --git a/src/utils/SkEGLContext_none.cpp b/src/utils/SkEGLContext_none.cpp
index 1c55c95..cb08f40 100644
--- a/src/utils/SkEGLContext_none.cpp
+++ b/src/utils/SkEGLContext_none.cpp
@@ -1,6 +1,6 @@
#include "SkEGLContext.h"
-SkEGLContext::SkEGLContext() : fContext(NULL) {
+SkEGLContext::SkEGLContext() {
}
SkEGLContext::~SkEGLContext() {
diff --git a/src/utils/mac/SkBitmap_Mac.cpp b/src/utils/mac/SkBitmap_Mac.cpp
new file mode 100644
index 0000000..06c2b27
--- /dev/null
+++ b/src/utils/mac/SkBitmap_Mac.cpp
@@ -0,0 +1,142 @@
+#include "SkBitmap.h"
+#include "SkColorPriv.h"
+#include "SkMath.h"
+
+#if defined(SK_BUILD_FOR_MAC) && !defined(SK_USE_WXWIDGETS)
+
+#include <ApplicationServices/ApplicationServices.h>
+
+#ifndef __ppc__
+ #define SWAP_16BIT
+#endif
+
+static void convertGL32_to_Mac32(uint32_t dst[], const SkBitmap& bm) {
+ memcpy(dst, bm.getPixels(), bm.getSize());
+ return;
+
+ uint32_t* stop = dst + (bm.getSize() >> 2);
+ const uint8_t* src = (const uint8_t*)bm.getPixels();
+ while (dst < stop) {
+ *dst++ = src[2] << 24 | src[1] << 16 | src[0] << 8 | src[3] << 0;
+ src += sizeof(uint32_t);
+ }
+}
+
+static void convert565_to_32(uint32_t dst[], const SkBitmap& bm) {
+ for (int y = 0; y < bm.height(); y++) {
+ const uint16_t* src = bm.getAddr16(0, y);
+ const uint16_t* stop = src + bm.width();
+ while (src < stop) {
+ unsigned c = *src++;
+ unsigned r = SkPacked16ToR32(c);
+ unsigned g = SkPacked16ToG32(c);
+ unsigned b = SkPacked16ToB32(c);
+
+ *dst++ = (b << 24) | (g << 16) | (r << 8) | 0xFF;
+ }
+ }
+}
+
+static void convert4444_to_555(uint16_t dst[], const uint16_t src[], int count)
+{
+ const uint16_t* stop = src + count;
+
+ while (src < stop)
+ {
+ unsigned c = *src++;
+
+ unsigned r = SkGetPackedR4444(c);
+ unsigned g = SkGetPackedG4444(c);
+ unsigned b = SkGetPackedB4444(c);
+ // convert to 5 bits
+ r = (r << 1) | (r >> 3);
+ g = (g << 1) | (g >> 3);
+ b = (b << 1) | (b >> 3);
+ // build the 555
+ c = (r << 10) | (g << 5) | b;
+
+#ifdef SWAP_16BIT
+ c = (c >> 8) | (c << 8);
+#endif
+ *dst++ = c;
+ }
+}
+
+#include "SkTemplates.h"
+
+static CGImageRef bitmap2imageref(const SkBitmap& bm) {
+ size_t bitsPerComp;
+ size_t bitsPerPixel;
+ CGBitmapInfo info;
+ CGColorSpaceRef cs = CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB);
+ CGDataProviderRef data = CGDataProviderCreateWithData(NULL,
+ bm.getPixels(),
+ bm.getSize(),
+ NULL);
+ SkAutoTCallVProc<CGDataProvider, CGDataProviderRelease> acp(data);
+ SkAutoTCallVProc<CGColorSpace, CGColorSpaceRelease> acp2(cs);
+
+ switch (bm.config()) {
+ case SkBitmap::kARGB_8888_Config:
+ bitsPerComp = 8;
+ bitsPerPixel = 32;
+ info = kCGImageAlphaPremultipliedLast;
+ break;
+ case SkBitmap::kARGB_4444_Config:
+ bitsPerComp = 4;
+ bitsPerPixel = 16;
+ info = kCGImageAlphaPremultipliedLast | kCGBitmapByteOrder16Little;
+ break;
+#if 0 // not supported by quartz !!!
+ case SkBitmap::kRGB_565_Config:
+ bitsPerComp = 5;
+ bitsPerPixel = 16;
+ info = kCGImageAlphaNone | kCGBitmapByteOrder16Little;
+ break;
+#endif
+ default:
+ return NULL;
+ }
+
+ return CGImageCreate(bm.width(), bm.height(), bitsPerComp, bitsPerPixel,
+ bm.rowBytes(), cs, info, data,
+ NULL, false, kCGRenderingIntentDefault);
+}
+
+void SkBitmap::drawToPort(WindowRef wind, CGContextRef cg) const {
+ if (fPixels == NULL || fWidth == 0 || fHeight == 0) {
+ return;
+ }
+
+ bool useQD = false;
+ if (NULL == cg) {
+ SetPortWindowPort(wind);
+ QDBeginCGContext(GetWindowPort(wind), &cg);
+ useQD = true;
+ }
+
+ SkBitmap bm;
+ if (this->config() == kRGB_565_Config) {
+ this->copyTo(&bm, kARGB_8888_Config);
+ } else {
+ bm = *this;
+ }
+ bm.lockPixels();
+
+ CGImageRef image = bitmap2imageref(bm);
+ if (image) {
+ CGRect rect;
+ rect.origin.x = rect.origin.y = 0;
+ rect.size.width = bm.width();
+ rect.size.height = bm.height();
+
+ CGContextDrawImage(cg, rect, image);
+ CGImageRelease(image);
+ }
+
+ if (useQD) {
+ QDEndCGContext(GetWindowPort(wind), &cg);
+ }
+}
+
+#endif
diff --git a/src/utils/mac/SkCreateCGImageRef.cpp b/src/utils/mac/SkCreateCGImageRef.cpp
new file mode 100644
index 0000000..f4bda45
--- /dev/null
+++ b/src/utils/mac/SkCreateCGImageRef.cpp
@@ -0,0 +1,129 @@
+#include "SkCGUtils.h"
+#include "SkBitmap.h"
+#include "SkColorPriv.h"
+
+static void SkBitmap_ReleaseInfo(void* info, const void* pixelData, size_t size) {
+ SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(info);
+ delete bitmap;
+}
+
+#define HAS_ARGB_SHIFTS(a, r, g, b) \
+ (SK_A32_SHIFT == (a) && SK_R32_SHIFT == (r) \
+ && SK_G32_SHIFT == (g) && SK_B32_SHIFT == (b))
+
+static SkBitmap* prepareForImageRef(const SkBitmap& bm,
+ size_t* bitsPerComponent,
+ CGBitmapInfo* info) {
+ bool upscaleTo32 = false;
+
+ switch (bm.config()) {
+ case SkBitmap::kRGB_565_Config:
+ upscaleTo32 = true;
+ // fall through
+ case SkBitmap::kARGB_8888_Config:
+ *bitsPerComponent = 8;
+#if defined(SK_CPU_LENDIAN) && HAS_ARGB_SHIFTS(24, 0, 8, 16) \
+ || defined(SK_CPU_BENDIAN) && HAS_ARGB_SHIFTS(0, 24, 16, 8)
+ *info = kCGBitmapByteOrder32Big | kCGImageAlphaPremultipliedLast;
+#elif defined(SK_CPU_LENDIAN) && HAS_ARGB_SHIFTS(24, 16, 8, 0) \
+ || defined(SK_CPU_BENDIAN) && HAS_ARGB_SHIFTS(24, 16, 8, 0)
+ // Matches the CGBitmapInfo that Apple recommends for best
+ // performance, used by google chrome.
+ *info = kCGBitmapByteOrder32Little | kCGImageAlphaPremultipliedFirst;
+#else
+// ...add more formats as required...
+#warning Cannot convert SkBitmap to CGImageRef with these shiftmasks. \
+ This will probably not work.
+ // Legacy behavior. Perhaps turn this into an error at some
+ // point.
+ *info = kCGBitmapByteOrder32Big | kCGImageAlphaPremultipliedLast;
+#endif
+ break;
+#if 0
+ case SkBitmap::kRGB_565_Config:
+ // doesn't see quite right. Are they thinking 1555?
+ *bitsPerComponent = 5;
+ *info = kCGBitmapByteOrder16Little;
+ break;
+#endif
+ case SkBitmap::kARGB_4444_Config:
+ *bitsPerComponent = 4;
+ *info = kCGBitmapByteOrder16Little | kCGImageAlphaPremultipliedLast;
+ break;
+ default:
+ return NULL;
+ }
+
+ SkBitmap* copy;
+ if (upscaleTo32) {
+ copy = new SkBitmap;
+ // here we make a ceep copy of the pixels, since CG won't take our
+ // 565 directly
+ bm.copyTo(copy, SkBitmap::kARGB_8888_Config);
+ } else {
+ copy = new SkBitmap(bm);
+ }
+ return copy;
+}
+
+#undef HAS_ARGB_SHIFTS
+
+CGImageRef SkCreateCGImageRefWithColorspace(const SkBitmap& bm,
+ CGColorSpaceRef colorSpace) {
+ size_t bitsPerComponent SK_INIT_TO_AVOID_WARNING;
+ CGBitmapInfo info SK_INIT_TO_AVOID_WARNING;
+
+ SkBitmap* bitmap = prepareForImageRef(bm, &bitsPerComponent, &info);
+ if (NULL == bitmap) {
+ return NULL;
+ }
+
+ const int w = bitmap->width();
+ const int h = bitmap->height();
+ const size_t s = bitmap->getSize();
+
+ // our provider "owns" the bitmap*, and will take care of deleting it
+ // we initially lock it, so we can access the pixels. The bitmap will be deleted in the release
+ // proc, which will in turn unlock the pixels
+ bitmap->lockPixels();
+ CGDataProviderRef dataRef = CGDataProviderCreateWithData(bitmap, bitmap->getPixels(), s,
+ SkBitmap_ReleaseInfo);
+
+ bool releaseColorSpace = false;
+ if (NULL == colorSpace) {
+ colorSpace = CGColorSpaceCreateDeviceRGB();
+ releaseColorSpace = true;
+ }
+
+ CGImageRef ref = CGImageCreate(w, h, bitsPerComponent,
+ bitmap->bytesPerPixel() * 8,
+ bitmap->rowBytes(), colorSpace, info, dataRef,
+ NULL, false, kCGRenderingIntentDefault);
+
+ if (releaseColorSpace) {
+ CGColorSpaceRelease(colorSpace);
+ }
+ CGDataProviderRelease(dataRef);
+ return ref;
+}
+
+void SkCGDrawBitmap(CGContextRef cg, const SkBitmap& bm, float x, float y) {
+ CGImageRef img = SkCreateCGImageRef(bm);
+
+ if (img) {
+ CGRect r = CGRectMake(0, 0, bm.width(), bm.height());
+
+ CGContextSaveGState(cg);
+ CGContextTranslateCTM(cg, x, r.size.height + y);
+ CGContextScaleCTM(cg, 1, -1);
+
+ CGContextDrawImage(cg, r, img);
+
+ CGContextRestoreGState(cg);
+
+ CGImageRelease(img);
+ }
+}
+
+
+
diff --git a/src/utils/mac/SkEGLContext_mac.cpp b/src/utils/mac/SkEGLContext_mac.cpp
new file mode 100644
index 0000000..e601f35
--- /dev/null
+++ b/src/utils/mac/SkEGLContext_mac.cpp
@@ -0,0 +1,68 @@
+#include "SkEGLContext.h"
+//#include "SkTypes.h"
+#include <AGL/agl.h>
+
+SkEGLContext::SkEGLContext() : context(NULL) {
+}
+
+SkEGLContext::~SkEGLContext() {
+ if (this->context) {
+ aglDestroyContext(this->context);
+ }
+}
+
+bool SkEGLContext::init(int width, int height) {
+ GLint major, minor;
+ AGLContext ctx;
+
+ aglGetVersion(&major, &minor);
+ //SkDebugf("---- agl version %d %d\n", major, minor);
+
+ const GLint pixelAttrs[] = {
+ AGL_RGBA,
+ AGL_STENCIL_SIZE, 8,
+/*
+ AGL_SAMPLE_BUFFERS_ARB, 1,
+ AGL_MULTISAMPLE,
+ AGL_SAMPLES_ARB, 2,
+*/
+ AGL_ACCELERATED,
+ AGL_NONE
+ };
+ AGLPixelFormat format = aglChoosePixelFormat(NULL, 0, pixelAttrs);
+ //AGLPixelFormat format = aglCreatePixelFormat(pixelAttrs);
+ //SkDebugf("----- agl format %p\n", format);
+ ctx = aglCreateContext(format, NULL);
+ //SkDebugf("----- agl context %p\n", ctx);
+ aglDestroyPixelFormat(format);
+
+/*
+ static const GLint interval = 1;
+ aglSetInteger(ctx, AGL_SWAP_INTERVAL, &interval);
+*/
+
+ aglSetCurrentContext(ctx);
+ this->context = ctx;
+
+ // Now create our FBO render target
+
+ GLuint fboID;
+ GLuint cbID;
+ GLuint dsID;
+ glGenFramebuffersEXT(1, &fboID);
+ glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fboID);
+ glGenRenderbuffers(1, &cbID);
+ glBindRenderbuffer(GL_RENDERBUFFER, cbID);
+ glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA, width, height);
+ glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, cbID);
+ glGenRenderbuffers(1, &dsID);
+ glBindRenderbuffer(GL_RENDERBUFFER, dsID);
+ glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_STENCIL, width, height);
+ glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, dsID);
+ glViewport(0, 0, width, height);
+ glClearStencil(0);
+ glClear(GL_STENCIL_BUFFER_BIT);
+
+ GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
+ return GL_FRAMEBUFFER_COMPLETE == status;
+}
diff --git a/src/utils/mac/SkOSWindow_Mac.cpp b/src/utils/mac/SkOSWindow_Mac.cpp
new file mode 100644
index 0000000..f1a2926
--- /dev/null
+++ b/src/utils/mac/SkOSWindow_Mac.cpp
@@ -0,0 +1,534 @@
+#include "SkTypes.h"
+
+#if defined(SK_BUILD_FOR_MAC) && !defined(SK_USE_WXWIDGETS)
+
+#include <AGL/agl.h>
+
+#include <Carbon/Carbon.h>
+#include "SkCGUtils.h"
+
+#include "SkWindow.h"
+#include "SkCanvas.h"
+#include "SkOSMenu.h"
+#include "SkTime.h"
+
+#include "SkGraphics.h"
+#include <new.h>
+
+static void (*gPrevNewHandler)();
+
+extern "C" {
+ static void sk_new_handler()
+ {
+ if (SkGraphics::SetFontCacheUsed(0))
+ return;
+ if (gPrevNewHandler)
+ gPrevNewHandler();
+ else
+ sk_throw();
+ }
+}
+
+static SkOSWindow* gCurrOSWin;
+static EventTargetRef gEventTarget;
+static EventQueueRef gCurrEventQ;
+
+static OSStatus MyDrawEventHandler(EventHandlerCallRef myHandler,
+ EventRef event, void *userData) {
+ // NOTE: GState is save/restored by the HIView system doing the callback,
+ // so the draw handler doesn't need to do it
+
+ OSStatus status = noErr;
+ CGContextRef context;
+ HIRect bounds;
+
+ // Get the CGContextRef
+ status = GetEventParameter (event, kEventParamCGContextRef,
+ typeCGContextRef, NULL,
+ sizeof (CGContextRef),
+ NULL,
+ &context);
+
+ if (status != noErr) {
+ SkDebugf("Got error %d getting the context!\n", status);
+ return status;
+ }
+
+ // Get the bounding rectangle
+ HIViewGetBounds ((HIViewRef) userData, &bounds);
+
+ gCurrOSWin->doPaint(context);
+ return status;
+}
+
+#define SK_MacEventClass FOUR_CHAR_CODE('SKec')
+#define SK_MacEventKind FOUR_CHAR_CODE('SKek')
+#define SK_MacEventParamName FOUR_CHAR_CODE('SKev')
+#define SK_MacEventSinkIDParamName FOUR_CHAR_CODE('SKes')
+
+static void set_bindingside(HISideBinding* side, HIViewRef parent, HIBindingKind kind) {
+ side->toView = parent;
+ side->kind = kind;
+ side->offset = 0;
+}
+
+static void set_axisscale(HIAxisScale* axis, HIViewRef parent) {
+ axis->toView = parent;
+ axis->kind = kHILayoutScaleAbsolute;
+ axis->ratio = 1;
+}
+
+static void set_axisposition(HIAxisPosition* pos, HIViewRef parent, HIPositionKind kind) {
+ pos->toView = parent;
+ pos->kind = kind;
+ pos->offset = 0;
+}
+
+SkOSWindow::SkOSWindow(void* hWnd) : fHWND(hWnd), fAGLCtx(NULL)
+{
+ OSStatus result;
+ WindowRef wr = (WindowRef)hWnd;
+
+ HIViewRef imageView, parent;
+ HIViewRef rootView = HIViewGetRoot(wr);
+ HIViewFindByID(rootView, kHIViewWindowContentID, &parent);
+ result = HIImageViewCreate(NULL, &imageView);
+ SkASSERT(result == noErr);
+
+ result = HIViewAddSubview(parent, imageView);
+ SkASSERT(result == noErr);
+
+ fHVIEW = imageView;
+
+ HIViewSetVisible(imageView, true);
+ HIViewPlaceInSuperviewAt(imageView, 0, 0);
+
+ if (true) {
+ HILayoutInfo layout;
+ layout.version = kHILayoutInfoVersionZero;
+ set_bindingside(&layout.binding.left, parent, kHILayoutBindLeft);
+ set_bindingside(&layout.binding.top, parent, kHILayoutBindTop);
+ set_bindingside(&layout.binding.right, parent, kHILayoutBindRight);
+ set_bindingside(&layout.binding.bottom, parent, kHILayoutBindBottom);
+ set_axisscale(&layout.scale.x, parent);
+ set_axisscale(&layout.scale.y, parent);
+ set_axisposition(&layout.position.x, parent, kHILayoutPositionLeft);
+ set_axisposition(&layout.position.y, rootView, kHILayoutPositionTop);
+ HIViewSetLayoutInfo(imageView, &layout);
+ }
+
+ HIImageViewSetOpaque(imageView, true);
+ HIImageViewSetScaleToFit(imageView, false);
+
+ static const EventTypeSpec gTypes[] = {
+ { kEventClassKeyboard, kEventRawKeyDown },
+ { kEventClassKeyboard, kEventRawKeyUp },
+ { kEventClassMouse, kEventMouseDown },
+ { kEventClassMouse, kEventMouseDragged },
+ { kEventClassMouse, kEventMouseMoved },
+ { kEventClassMouse, kEventMouseUp },
+ { kEventClassTextInput, kEventTextInputUnicodeForKeyEvent },
+ { kEventClassWindow, kEventWindowBoundsChanged },
+// { kEventClassWindow, kEventWindowDrawContent },
+ { SK_MacEventClass, SK_MacEventKind }
+ };
+
+ EventHandlerUPP handlerUPP = NewEventHandlerUPP(SkOSWindow::EventHandler);
+ int count = SK_ARRAY_COUNT(gTypes);
+
+ result = InstallEventHandler(GetWindowEventTarget(wr), handlerUPP,
+ count, gTypes, this, nil);
+ SkASSERT(result == noErr);
+
+ gCurrOSWin = this;
+ gCurrEventQ = GetCurrentEventQueue();
+ gEventTarget = GetWindowEventTarget(wr);
+
+ static bool gOnce = true;
+ if (gOnce) {
+ gOnce = false;
+ gPrevNewHandler = set_new_handler(sk_new_handler);
+ }
+}
+
+void SkOSWindow::doPaint(void* ctx)
+{
+#if 0
+ this->update(NULL);
+
+ const SkBitmap& bm = this->getBitmap();
+ CGImageRef img = SkCreateCGImageRef(bm);
+
+ if (img) {
+ CGRect r = CGRectMake(0, 0, bm.width(), bm.height());
+
+ CGContextRef cg = reinterpret_cast<CGContextRef>(ctx);
+
+ CGContextSaveGState(cg);
+ CGContextTranslateCTM(cg, 0, r.size.height);
+ CGContextScaleCTM(cg, 1, -1);
+
+ CGContextDrawImage(cg, r, img);
+
+ CGContextRestoreGState(cg);
+
+ CGImageRelease(img);
+ }
+#endif
+}
+
+void SkOSWindow::updateSize()
+{
+ Rect r;
+
+ GetWindowBounds((WindowRef)fHWND, kWindowContentRgn, &r);
+ this->resize(r.right - r.left, r.bottom - r.top);
+
+#if 0
+ HIRect frame;
+ HIViewRef imageView = (HIViewRef)getHVIEW();
+ HIViewRef parent = HIViewGetSuperview(imageView);
+
+ HIViewGetBounds(imageView, &frame);
+ SkDebugf("------ %d bounds %g %g %g %g\n", r.right - r.left,
+ frame.origin.x, frame.origin.y, frame.size.width, frame.size.height);
+#endif
+}
+
+void SkOSWindow::onHandleInval(const SkIRect& r)
+{
+ SkEvent* evt = new SkEvent("inval-imageview");
+ evt->post(this->getSinkID());
+}
+
+bool SkOSWindow::onEvent(const SkEvent& evt) {
+ if (evt.isType("inval-imageview")) {
+ this->update(NULL);
+
+ const SkBitmap& bm = this->getBitmap();
+
+ CGImageRef img = SkCreateCGImageRef(bm);
+ HIImageViewSetImage((HIViewRef)getHVIEW(), img);
+ CGImageRelease(img);
+ return true;
+ }
+ return INHERITED::onEvent(evt);
+}
+
+void SkOSWindow::onSetTitle(const char title[])
+{
+ CFStringRef str = CFStringCreateWithCString(NULL, title, kCFStringEncodingUTF8);
+ SetWindowTitleWithCFString((WindowRef)fHWND, str);
+ CFRelease(str);
+}
+
+void SkOSWindow::onAddMenu(const SkOSMenu* sk_menu)
+{
+}
+
+static void getparam(EventRef inEvent, OSType name, OSType type, UInt32 size, void* data)
+{
+ EventParamType actualType;
+ UInt32 actualSize;
+ OSStatus status;
+
+ status = GetEventParameter(inEvent, name, type, &actualType, size, &actualSize, data);
+ SkASSERT(status == noErr);
+ SkASSERT(actualType == type);
+ SkASSERT(actualSize == size);
+}
+
+enum {
+ SK_MacReturnKey = 36,
+ SK_MacDeleteKey = 51,
+ SK_MacEndKey = 119,
+ SK_MacLeftKey = 123,
+ SK_MacRightKey = 124,
+ SK_MacDownKey = 125,
+ SK_MacUpKey = 126,
+
+ SK_Mac0Key = 0x52,
+ SK_Mac1Key = 0x53,
+ SK_Mac2Key = 0x54,
+ SK_Mac3Key = 0x55,
+ SK_Mac4Key = 0x56,
+ SK_Mac5Key = 0x57,
+ SK_Mac6Key = 0x58,
+ SK_Mac7Key = 0x59,
+ SK_Mac8Key = 0x5b,
+ SK_Mac9Key = 0x5c
+};
+
+static SkKey raw2key(UInt32 raw)
+{
+ static const struct {
+ UInt32 fRaw;
+ SkKey fKey;
+ } gKeys[] = {
+ { SK_MacUpKey, kUp_SkKey },
+ { SK_MacDownKey, kDown_SkKey },
+ { SK_MacLeftKey, kLeft_SkKey },
+ { SK_MacRightKey, kRight_SkKey },
+ { SK_MacReturnKey, kOK_SkKey },
+ { SK_MacDeleteKey, kBack_SkKey },
+ { SK_MacEndKey, kEnd_SkKey },
+ { SK_Mac0Key, k0_SkKey },
+ { SK_Mac1Key, k1_SkKey },
+ { SK_Mac2Key, k2_SkKey },
+ { SK_Mac3Key, k3_SkKey },
+ { SK_Mac4Key, k4_SkKey },
+ { SK_Mac5Key, k5_SkKey },
+ { SK_Mac6Key, k6_SkKey },
+ { SK_Mac7Key, k7_SkKey },
+ { SK_Mac8Key, k8_SkKey },
+ { SK_Mac9Key, k9_SkKey }
+ };
+
+ for (unsigned i = 0; i < SK_ARRAY_COUNT(gKeys); i++)
+ if (gKeys[i].fRaw == raw)
+ return gKeys[i].fKey;
+ return kNONE_SkKey;
+}
+
+static void post_skmacevent()
+{
+ EventRef ref;
+ OSStatus status = CreateEvent(nil, SK_MacEventClass, SK_MacEventKind, 0, 0, &ref);
+ SkASSERT(status == noErr);
+
+#if 0
+ status = SetEventParameter(ref, SK_MacEventParamName, SK_MacEventParamName, sizeof(evt), &evt);
+ SkASSERT(status == noErr);
+ status = SetEventParameter(ref, SK_MacEventSinkIDParamName, SK_MacEventSinkIDParamName, sizeof(sinkID), &sinkID);
+ SkASSERT(status == noErr);
+#endif
+
+ EventTargetRef target = gEventTarget;
+ SetEventParameter(ref, kEventParamPostTarget, typeEventTargetRef, sizeof(target), &target);
+ SkASSERT(status == noErr);
+
+ status = PostEventToQueue(gCurrEventQ, ref, kEventPriorityStandard);
+ SkASSERT(status == noErr);
+
+ ReleaseEvent(ref);
+}
+
+pascal OSStatus SkOSWindow::EventHandler( EventHandlerCallRef inHandler, EventRef inEvent, void* userData )
+{
+ SkOSWindow* win = (SkOSWindow*)userData;
+ OSStatus result = eventNotHandledErr;
+ UInt32 wClass = GetEventClass(inEvent);
+ UInt32 wKind = GetEventKind(inEvent);
+
+ gCurrOSWin = win; // will need to be in TLS. Set this so PostEvent will work
+
+ switch (wClass) {
+ case kEventClassMouse: {
+ Point pt;
+ getparam(inEvent, kEventParamMouseLocation, typeQDPoint, sizeof(pt), &pt);
+ SetPortWindowPort((WindowRef)win->getHWND());
+ GlobalToLocal(&pt);
+
+ switch (wKind) {
+ case kEventMouseDown:
+ if (win->handleClick(pt.h, pt.v, Click::kDown_State)) {
+ result = noErr;
+ }
+ break;
+ case kEventMouseMoved:
+ // fall through
+ case kEventMouseDragged:
+ (void)win->handleClick(pt.h, pt.v, Click::kMoved_State);
+ // result = noErr;
+ break;
+ case kEventMouseUp:
+ (void)win->handleClick(pt.h, pt.v, Click::kUp_State);
+ // result = noErr;
+ break;
+ default:
+ break;
+ }
+ break;
+ }
+ case kEventClassKeyboard:
+ if (wKind == kEventRawKeyDown) {
+ UInt32 raw;
+ getparam(inEvent, kEventParamKeyCode, typeUInt32, sizeof(raw), &raw);
+ SkKey key = raw2key(raw);
+ if (key != kNONE_SkKey)
+ (void)win->handleKey(key);
+ } else if (wKind == kEventRawKeyUp) {
+ UInt32 raw;
+ getparam(inEvent, kEventParamKeyCode, typeUInt32, sizeof(raw), &raw);
+ SkKey key = raw2key(raw);
+ if (key != kNONE_SkKey)
+ (void)win->handleKeyUp(key);
+ }
+ break;
+ case kEventClassTextInput:
+ if (wKind == kEventTextInputUnicodeForKeyEvent) {
+ UInt16 uni;
+ getparam(inEvent, kEventParamTextInputSendText, typeUnicodeText, sizeof(uni), &uni);
+ win->handleChar(uni);
+ }
+ break;
+ case kEventClassWindow:
+ switch (wKind) {
+ case kEventWindowBoundsChanged:
+ win->updateSize();
+ break;
+ case kEventWindowDrawContent: {
+ CGContextRef cg;
+ result = GetEventParameter(inEvent,
+ kEventParamCGContextRef,
+ typeCGContextRef,
+ NULL,
+ sizeof (CGContextRef),
+ NULL,
+ &cg);
+ if (result != 0) {
+ cg = NULL;
+ }
+ win->doPaint(cg);
+ break;
+ }
+ default:
+ break;
+ }
+ break;
+ case SK_MacEventClass: {
+ SkASSERT(wKind == SK_MacEventKind);
+ if (SkEvent::ProcessEvent()) {
+ post_skmacevent();
+ }
+ #if 0
+ SkEvent* evt;
+ SkEventSinkID sinkID;
+ getparam(inEvent, SK_MacEventParamName, SK_MacEventParamName, sizeof(evt), &evt);
+ getparam(inEvent, SK_MacEventSinkIDParamName, SK_MacEventSinkIDParamName, sizeof(sinkID), &sinkID);
+ #endif
+ result = noErr;
+ break;
+ }
+ default:
+ break;
+ }
+ if (result == eventNotHandledErr) {
+ result = CallNextEventHandler(inHandler, inEvent);
+ }
+ return result;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////
+
+void SkEvent::SignalNonEmptyQueue()
+{
+ post_skmacevent();
+// SkDebugf("signal nonempty\n");
+}
+
+static TMTask gTMTaskRec;
+static TMTask* gTMTaskPtr;
+
+static void sk_timer_proc(TMTask* rec)
+{
+ SkEvent::ServiceQueueTimer();
+// SkDebugf("timer task fired\n");
+}
+
+void SkEvent::SignalQueueTimer(SkMSec delay)
+{
+ if (gTMTaskPtr)
+ {
+ RemoveTimeTask((QElem*)gTMTaskPtr);
+ DisposeTimerUPP(gTMTaskPtr->tmAddr);
+ gTMTaskPtr = nil;
+ }
+ if (delay)
+ {
+ gTMTaskPtr = &gTMTaskRec;
+ memset(gTMTaskPtr, 0, sizeof(gTMTaskRec));
+ gTMTaskPtr->tmAddr = NewTimerUPP(sk_timer_proc);
+ OSErr err = InstallTimeTask((QElem*)gTMTaskPtr);
+// SkDebugf("installtimetask of %d returned %d\n", delay, err);
+ PrimeTimeTask((QElem*)gTMTaskPtr, delay);
+ }
+}
+
+#define USE_MSAA 0
+
+AGLContext create_gl(WindowRef wref)
+{
+ GLint major, minor;
+ AGLContext ctx;
+
+ aglGetVersion(&major, &minor);
+ SkDebugf("---- agl version %d %d\n", major, minor);
+
+ const GLint pixelAttrs[] = {
+ AGL_RGBA,
+ AGL_STENCIL_SIZE, 8,
+#if USE_MSAA
+ AGL_SAMPLE_BUFFERS_ARB, 1,
+ AGL_MULTISAMPLE,
+ AGL_SAMPLES_ARB, 8,
+#endif
+ AGL_ACCELERATED,
+ AGL_DOUBLEBUFFER,
+ AGL_NONE
+ };
+ AGLPixelFormat format = aglChoosePixelFormat(NULL, 0, pixelAttrs);
+ //AGLPixelFormat format = aglCreatePixelFormat(pixelAttrs);
+ SkDebugf("----- agl format %p\n", format);
+ ctx = aglCreateContext(format, NULL);
+ SkDebugf("----- agl context %p\n", ctx);
+ aglDestroyPixelFormat(format);
+
+ static const GLint interval = 1;
+ aglSetInteger(ctx, AGL_SWAP_INTERVAL, &interval);
+ aglSetCurrentContext(ctx);
+ return ctx;
+}
+
+bool SkOSWindow::attachGL()
+{
+ if (NULL == fAGLCtx) {
+ fAGLCtx = create_gl((WindowRef)fHWND);
+ if (NULL == fAGLCtx) {
+ return false;
+ }
+ }
+
+ GLboolean success = true;
+
+ int width, height;
+
+ success = aglSetWindowRef((AGLContext)fAGLCtx, (WindowRef)fHWND);
+ width = this->width();
+ height = this->height();
+
+ GLenum err = aglGetError();
+ if (err) {
+ SkDebugf("---- aglSetWindowRef %d %d %s [%d %d]\n", success, err,
+ aglErrorString(err), width, height);
+ }
+
+ if (success) {
+ glViewport(0, 0, width, height);
+ glClearColor(0, 0, 0, 0);
+ glClearStencil(0);
+ glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
+ }
+ return success;
+}
+
+void SkOSWindow::detachGL() {
+ aglSetWindowRef((AGLContext)fAGLCtx, NULL);
+}
+
+void SkOSWindow::presentGL() {
+ aglSwapBuffers((AGLContext)fAGLCtx);
+}
+
+#endif
+
diff --git a/src/utils/mac/skia_mac.cpp b/src/utils/mac/skia_mac.cpp
new file mode 100644
index 0000000..a1345cf
--- /dev/null
+++ b/src/utils/mac/skia_mac.cpp
@@ -0,0 +1,43 @@
+#include <Carbon/Carbon.h>
+#include "SkApplication.h"
+#include "SkWindow.h"
+
+int main(int argc, char* argv[])
+{
+ WindowRef window;
+ OSStatus err = noErr;
+
+ Rect bounds = {100, 100, 500, 500};
+ WindowAttributes attrs = kWindowStandardHandlerAttribute |
+ kWindowLiveResizeAttribute |
+ kWindowInWindowMenuAttribute |
+ kWindowCompositingAttribute |
+ kWindowAsyncDragAttribute |
+ kWindowFullZoomAttribute |
+ kWindowFrameworkScaledAttribute;
+ //kWindowDoesNotCycleAttribute;
+ CreateNewWindow(kDocumentWindowClass, attrs, &bounds, &window);
+
+ MenuRef menu;
+ CreateNewMenu(0, 0, &menu);
+
+ // if we get here, we can start our normal Skia sequence
+ {
+ application_init();
+ (void)create_sk_window(window);
+ SizeWindow(window, 640, 480, false);
+ }
+
+ // The window was created hidden so show it.
+ ShowWindow( window );
+
+ // Call the event loop
+ RunApplicationEventLoop();
+
+ application_term();
+
+CantCreateWindow:
+CantGetNibRef:
+ return err;
+}
+
diff --git a/src/utils/mesa/SkEGLContext_Mesa.cpp b/src/utils/mesa/SkEGLContext_Mesa.cpp
new file mode 100644
index 0000000..ed1b7cd
--- /dev/null
+++ b/src/utils/mesa/SkEGLContext_Mesa.cpp
@@ -0,0 +1,128 @@
+#include "SkEGLContext.h"
+#include "SkTypes.h"
+
+#include "GL/osmesa.h"
+#include "GL/glu.h"
+
+#define SK_GL_DECL_PROC(T, F) T F ## _func = NULL;
+#define SK_GL_GET_PROC(T, F) F ## _func = (T)OSMesaGetProcAddress(#F);
+#define SK_GL_GET_EXT_PROC(T, F) F ## _func = (T)OSMesaGetProcAddress(#F "EXT");
+
+SkEGLContext::SkEGLContext() : context(NULL), image(NULL) {
+}
+
+SkEGLContext::~SkEGLContext() {
+ if (this->image)
+ free(this->image);
+
+ if (this->context)
+ OSMesaDestroyContext(this->context);
+}
+
+#if SK_B32_SHIFT < SK_G32_SHIFT &&\
+ SK_G32_SHIFT < SK_R32_SHIFT &&\
+ SK_R32_SHIFT < SK_A32_SHIFT
+ #define SK_OSMESA_COLOR_ORDER OSMESA_BGRA
+#elif SK_R32_SHIFT < SK_G32_SHIFT &&\
+ SK_G32_SHIFT < SK_B32_SHIFT &&\
+ SK_B32_SHIFT < SK_A32_SHIFT
+ #define SK_OSMESA_COLOR_ORDER OSMESA_RGBA
+#elif SK_A32_SHIFT < SK_R32_SHIFT && \
+ SK_R32_SHIFT < SK_G32_SHIFT && \
+ SK_G32_SHIFT < SK_B32_SHIFT
+ #define SK_OSMESA_COLOR_ORDER OSMESA_ARGB
+#else
+ //Color order (rgba) SK_R32_SHIFT SK_G32_SHIFT SK_B32_SHIFT SK_A32_SHIFT
+ #define SK_OSMESA_COLOR_ORDER OSMESA_RGBA
+#endif
+
+bool SkEGLContext::init(const int width, const int height) {
+ /* Create an RGBA-mode context */
+#if OSMESA_MAJOR_VERSION * 100 + OSMESA_MINOR_VERSION >= 305
+ /* specify Z, stencil, accum sizes */
+ OSMesaContext ctx = OSMesaCreateContextExt(SK_OSMESA_COLOR_ORDER, 16, 0, 0, NULL);
+#else
+ OSMesaContext ctx = OSMesaCreateContext(SK_OSMESA_COLOR_ORDER, NULL);
+#endif
+ if (!ctx) {
+ SkDebugf("OSMesaCreateContext failed!\n");
+ return false;
+ }
+ this->context = ctx;
+
+ // Allocate the image buffer
+ GLfloat *buffer = (GLfloat *) malloc(width * height * 4 * sizeof(GLfloat));
+ if (!buffer) {
+ SkDebugf("Alloc image buffer failed!\n");
+ return false;
+ }
+ this->image = buffer;
+
+ // Bind the buffer to the context and make it current
+ if (!OSMesaMakeCurrent(ctx, buffer, GL_FLOAT, width, height)) {
+ SkDebugf("OSMesaMakeCurrent failed!\n");
+ return false;
+ }
+
+ //Setup the framebuffers
+ SK_GL_DECL_PROC(PFNGLGENFRAMEBUFFERSEXTPROC, glGenFramebuffers)
+ SK_GL_DECL_PROC(PFNGLBINDFRAMEBUFFEREXTPROC, glBindFramebuffer)
+ SK_GL_DECL_PROC(PFNGLGENRENDERBUFFERSPROC, glGenRenderbuffers)
+ SK_GL_DECL_PROC(PFNGLBINDRENDERBUFFERPROC, glBindRenderbuffer)
+ SK_GL_DECL_PROC(PFNGLRENDERBUFFERSTORAGEPROC, glRenderbufferStorage)
+ SK_GL_DECL_PROC(PFNGLFRAMEBUFFERRENDERBUFFERPROC, glFramebufferRenderbuffer)
+ SK_GL_DECL_PROC(PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC, glCheckFramebufferStatus)
+
+ const GLubyte* glExts = glGetString(GL_EXTENSIONS);
+ if (gluCheckExtension(
+ reinterpret_cast<const GLubyte*>("GL_ARB_framebuffer_object")
+ , glExts))
+ {
+ SK_GL_GET_PROC(PFNGLGENFRAMEBUFFERSEXTPROC, glGenFramebuffers)
+ SK_GL_GET_PROC(PFNGLBINDFRAMEBUFFEREXTPROC, glBindFramebuffer)
+ SK_GL_GET_PROC(PFNGLGENRENDERBUFFERSPROC, glGenRenderbuffers)
+ SK_GL_GET_PROC(PFNGLBINDRENDERBUFFERPROC, glBindRenderbuffer)
+ SK_GL_GET_PROC(PFNGLRENDERBUFFERSTORAGEPROC, glRenderbufferStorage)
+ SK_GL_GET_PROC(PFNGLFRAMEBUFFERRENDERBUFFERPROC, glFramebufferRenderbuffer)
+ SK_GL_GET_PROC(PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC, glCheckFramebufferStatus)
+
+ //osmesa on mac currently only supports EXT
+ } else if (gluCheckExtension(
+ reinterpret_cast<const GLubyte*>("GL_EXT_framebuffer_object")
+ , glExts))
+ {
+ SK_GL_GET_EXT_PROC(PFNGLGENFRAMEBUFFERSEXTPROC, glGenFramebuffers)
+ SK_GL_GET_EXT_PROC(PFNGLBINDFRAMEBUFFEREXTPROC, glBindFramebuffer)
+ SK_GL_GET_EXT_PROC(PFNGLGENRENDERBUFFERSPROC, glGenRenderbuffers)
+ SK_GL_GET_EXT_PROC(PFNGLBINDRENDERBUFFERPROC, glBindRenderbuffer)
+ SK_GL_GET_EXT_PROC(PFNGLRENDERBUFFERSTORAGEPROC, glRenderbufferStorage)
+ SK_GL_GET_EXT_PROC(PFNGLFRAMEBUFFERRENDERBUFFERPROC, glFramebufferRenderbuffer)
+ SK_GL_GET_EXT_PROC(PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC, glCheckFramebufferStatus)
+ } else {
+ SkDebugf("GL_ARB_framebuffer_object not found.\n");
+ return false;
+ }
+
+ GLuint fboID;
+ GLuint cbID;
+ GLuint dsID;
+ glGenFramebuffers_func(1, &fboID);
+ glBindFramebuffer_func(GL_FRAMEBUFFER, fboID);
+
+ glGenRenderbuffers_func(1, &cbID);
+ glBindRenderbuffer_func(GL_RENDERBUFFER, cbID);
+ glRenderbufferStorage_func(GL_RENDERBUFFER, OSMESA_RGBA, width, height);
+ glFramebufferRenderbuffer_func(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, cbID);
+
+ glGenRenderbuffers_func(1, &dsID);
+ glBindRenderbuffer_func(GL_RENDERBUFFER_EXT, dsID);
+ glRenderbufferStorage_func(GL_RENDERBUFFER, GL_STENCIL_INDEX8, width, height);
+ glFramebufferRenderbuffer_func(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, dsID);
+
+ glViewport(0, 0, width, height);
+ glClearStencil(0);
+ glClear(GL_STENCIL_BUFFER_BIT);
+
+ GLenum status = glCheckFramebufferStatus_func(GL_FRAMEBUFFER);
+ return GL_FRAMEBUFFER_COMPLETE == status;
+}
diff --git a/src/utils/unix/SkEGLContext_Unix.cpp b/src/utils/unix/SkEGLContext_Unix.cpp
new file mode 100644
index 0000000..7921b8a
--- /dev/null
+++ b/src/utils/unix/SkEGLContext_Unix.cpp
@@ -0,0 +1,264 @@
+#include "SkEGLContext.h"
+#include "SkTypes.h"
+
+#include <GL/gl.h>
+#include <GL/glext.h>
+#include <GL/glu.h>
+#include <GL/glx.h>
+#include <X11/Xlib.h>
+
+#define SK_GL_GET_PROC(T, F) T F = NULL; \
+ F = (T) glXGetProcAddressARB(reinterpret_cast<const GLubyte*>(#F));
+
+static bool ctxErrorOccurred = false;
+static int ctxErrorHandler(Display *dpy, XErrorEvent *ev) {
+ ctxErrorOccurred = true;
+ return 0;
+}
+
+SkEGLContext::SkEGLContext() : context(NULL), display(NULL), pixmap(0), glxPixmap(0) {
+}
+
+SkEGLContext::~SkEGLContext() {
+ if (this->display) {
+ glXMakeCurrent(this->display, 0, 0);
+
+ if (this->context)
+ glXDestroyContext(this->display, this->context);
+
+ if (this->glxPixmap)
+ glXDestroyGLXPixmap(this->display, this->glxPixmap);
+
+ if (this->pixmap)
+ XFreePixmap(this->display, this->pixmap);
+
+ XCloseDisplay(this->display);
+ }
+}
+
+bool SkEGLContext::init(const int width, const int height) {
+ Display *display = XOpenDisplay(0);
+ this->display = display;
+
+ if (!display) {
+ SkDebugf("Failed to open X display.\n");
+ return false;
+ }
+
+ // Get a matching FB config
+ static int visual_attribs[] = {
+ GLX_X_RENDERABLE , True,
+ GLX_DRAWABLE_TYPE , GLX_PIXMAP_BIT,
+ GLX_RENDER_TYPE , GLX_RGBA_BIT,
+ GLX_X_VISUAL_TYPE , GLX_TRUE_COLOR,
+ GLX_RED_SIZE , 8,
+ GLX_GREEN_SIZE , 8,
+ GLX_BLUE_SIZE , 8,
+ GLX_ALPHA_SIZE , 8,
+ GLX_DEPTH_SIZE , 24,
+ GLX_STENCIL_SIZE , 8,
+ GLX_DOUBLEBUFFER , True,
+ //GLX_SAMPLE_BUFFERS , 1,
+ //GLX_SAMPLES , 4,
+ None
+ };
+
+ int glx_major, glx_minor;
+
+ // FBConfigs were added in GLX version 1.3.
+ if (!glXQueryVersion( display, &glx_major, &glx_minor) ||
+ ( (glx_major == 1) && (glx_minor < 3) ) || (glx_major < 1))
+ {
+ SkDebugf("Invalid GLX version.");
+ return false;
+ }
+
+ //SkDebugf("Getting matching framebuffer configs.\n");
+ int fbcount;
+ GLXFBConfig *fbc = glXChooseFBConfig(display, DefaultScreen(display),
+ visual_attribs, &fbcount);
+ if (!fbc) {
+ SkDebugf("Failed to retrieve a framebuffer config.\n");
+ return false;
+ }
+ //SkDebugf("Found %d matching FB configs.\n", fbcount);
+
+ // Pick the FB config/visual with the most samples per pixel
+ //SkDebugf("Getting XVisualInfos.\n");
+ int best_fbc = -1, worst_fbc = -1, best_num_samp = -1, worst_num_samp = 999;
+
+ int i;
+ for (i = 0; i < fbcount; ++i) {
+ XVisualInfo *vi = glXGetVisualFromFBConfig(display, fbc[i]);
+ if (vi) {
+ int samp_buf, samples;
+ glXGetFBConfigAttrib(display, fbc[i], GLX_SAMPLE_BUFFERS, &samp_buf);
+ glXGetFBConfigAttrib(display, fbc[i], GLX_SAMPLES, &samples);
+
+ //SkDebugf(" Matching fbconfig %d, visual ID 0x%2x: SAMPLE_BUFFERS = %d,"
+ // " SAMPLES = %d\n",
+ // i, (unsigned int)vi->visualid, samp_buf, samples);
+
+ if (best_fbc < 0 || (samp_buf && samples > best_num_samp))
+ best_fbc = i, best_num_samp = samples;
+ if (worst_fbc < 0 || !samp_buf || samples < worst_num_samp)
+ worst_fbc = i, worst_num_samp = samples;
+ }
+ XFree(vi);
+ }
+
+ GLXFBConfig bestFbc = fbc[best_fbc];
+
+ // Be sure to free the FBConfig list allocated by glXChooseFBConfig()
+ XFree(fbc);
+
+ // Get a visual
+ XVisualInfo *vi = glXGetVisualFromFBConfig(display, bestFbc);
+ //SkDebugf("Chosen visual ID = 0x%x\n", (unsigned int)vi->visualid);
+
+ Pixmap pixmap = XCreatePixmap(
+ display, RootWindow(display, vi->screen), width, height, vi->depth
+ );
+
+ this->pixmap = pixmap;
+ if (!pixmap) {
+ SkDebugf("Failed to create pixmap.\n");
+ return false;
+ }
+
+ GLXPixmap glxPixmap = glXCreateGLXPixmap(display, vi, pixmap);
+ this->glxPixmap = glxPixmap;
+
+ // Done with the visual info data
+ XFree(vi);
+
+ // Create the context
+ GLXContext ctx = 0;
+
+ // Install an X error handler so the application won't exit if GL 3.0
+ // context allocation fails.
+ //
+ // Note this error handler is global.
+ // All display connections in all threads of a process use the same
+ // error handler, so be sure to guard against other threads issuing
+ // X commands while this code is running.
+ ctxErrorOccurred = false;
+ int (*oldHandler)(Display*, XErrorEvent*) =
+ XSetErrorHandler(&ctxErrorHandler);
+
+ // Get the default screen's GLX extension list
+ const char *glxExts = glXQueryExtensionsString(
+ display, DefaultScreen(display)
+ );
+ // Check for the GLX_ARB_create_context extension string and the function.
+ // If either is not present, use GLX 1.3 context creation method.
+ if (!gluCheckExtension(
+ reinterpret_cast<const GLubyte*>("GLX_ARB_create_context")
+ , reinterpret_cast<const GLubyte*>(glxExts)))
+ {
+ //SkDebugf("GLX_ARB_create_context not found."
+ // " Using old-style GLX context.\n");
+ ctx = glXCreateNewContext(display, bestFbc, GLX_RGBA_TYPE, 0, True);
+
+ } else {
+ //SkDebugf("Creating context.\n");
+
+ SK_GL_GET_PROC(PFNGLXCREATECONTEXTATTRIBSARBPROC, glXCreateContextAttribsARB)
+ int context_attribs[] = {
+ GLX_CONTEXT_MAJOR_VERSION_ARB, 3,
+ GLX_CONTEXT_MINOR_VERSION_ARB, 0,
+ //GLX_CONTEXT_FLAGS_ARB , GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB,
+ None
+ };
+ ctx = glXCreateContextAttribsARB(
+ display, bestFbc, 0, True, context_attribs
+ );
+
+ // Sync to ensure any errors generated are processed.
+ XSync(display, False);
+ if (!ctxErrorOccurred && ctx) {
+ //SkDebugf( "Created GL 3.0 context.\n" );
+ } else {
+ // Couldn't create GL 3.0 context.
+ // Fall back to old-style 2.x context.
+ // When a context version below 3.0 is requested,
+ // implementations will return the newest context version compatible
+ // with OpenGL versions less than version 3.0.
+
+ // GLX_CONTEXT_MAJOR_VERSION_ARB = 1
+ context_attribs[1] = 1;
+ // GLX_CONTEXT_MINOR_VERSION_ARB = 0
+ context_attribs[3] = 0;
+
+ ctxErrorOccurred = false;
+
+ //SkDebugf("Failed to create GL 3.0 context."
+ // " Using old-style GLX context.\n");
+ ctx = glXCreateContextAttribsARB(
+ display, bestFbc, 0, True, context_attribs
+ );
+ }
+ }
+
+ // Sync to ensure any errors generated are processed.
+ XSync(display, False);
+
+ // Restore the original error handler
+ XSetErrorHandler(oldHandler);
+
+ if (ctxErrorOccurred || !ctx) {
+ SkDebugf("Failed to create an OpenGL context.\n");
+ return false;
+ }
+ this->context = ctx;
+
+ // Verify that context is a direct context
+ if (!glXIsDirect(display, ctx)) {
+ //SkDebugf("Indirect GLX rendering context obtained.\n");
+ } else {
+ //SkDebugf("Direct GLX rendering context obtained.\n");
+ }
+
+ //SkDebugf("Making context current.\n");
+ if (!glXMakeCurrent(display, glxPixmap, ctx)) {
+ SkDebugf("Could not set the context.\n");
+ return false;
+ }
+
+ //Setup the framebuffers
+ const GLubyte* glExts = glGetString(GL_EXTENSIONS);
+ if (!gluCheckExtension(
+ reinterpret_cast<const GLubyte*>("GL_EXT_framebuffer_object")
+ , glExts))
+ {
+ SkDebugf("GL_EXT_framebuffer_object not found.\n");
+ return false;
+ }
+ SK_GL_GET_PROC(PFNGLGENFRAMEBUFFERSEXTPROC, glGenFramebuffersEXT)
+ SK_GL_GET_PROC(PFNGLBINDFRAMEBUFFEREXTPROC, glBindFramebufferEXT)
+ SK_GL_GET_PROC(PFNGLGENRENDERBUFFERSPROC, glGenRenderbuffersEXT)
+ SK_GL_GET_PROC(PFNGLBINDRENDERBUFFERPROC, glBindRenderbufferEXT)
+ SK_GL_GET_PROC(PFNGLRENDERBUFFERSTORAGEPROC, glRenderbufferStorageEXT)
+ SK_GL_GET_PROC(PFNGLFRAMEBUFFERRENDERBUFFERPROC, glFramebufferRenderbufferEXT)
+ SK_GL_GET_PROC(PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC, glCheckFramebufferStatusEXT)
+
+ GLuint fboID;
+ GLuint cbID;
+ GLuint dsID;
+ glGenFramebuffersEXT(1, &fboID);
+ glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fboID);
+ glGenRenderbuffersEXT(1, &cbID);
+ glBindRenderbufferEXT(GL_RENDERBUFFER, cbID);
+ glRenderbufferStorageEXT(GL_RENDERBUFFER, GL_RGBA, width, height);
+ glFramebufferRenderbufferEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, cbID);
+ glGenRenderbuffersEXT(1, &dsID);
+ glBindRenderbufferEXT(GL_RENDERBUFFER, dsID);
+ glRenderbufferStorageEXT(GL_RENDERBUFFER, GL_DEPTH_STENCIL, width, height);
+ glFramebufferRenderbufferEXT(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, dsID);
+ glViewport(0, 0, width, height);
+ glClearStencil(0);
+ glClear(GL_STENCIL_BUFFER_BIT);
+
+ GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER);
+ return GL_FRAMEBUFFER_COMPLETE == status;
+}
diff --git a/src/utils/unix/SkOSWindow_Unix.cpp b/src/utils/unix/SkOSWindow_Unix.cpp
index 4ec0c74..ae881d5 100644
--- a/src/utils/unix/SkOSWindow_Unix.cpp
+++ b/src/utils/unix/SkOSWindow_Unix.cpp
@@ -76,7 +76,7 @@
long event_mask = NoEventMask;
XClientMessageEvent event;
event.type = ClientMessage;
- Atom myAtom;
+ Atom myAtom(0);
event.message_type = myAtom;
event.format = 32;
event.data.l[0] = 0;
diff --git a/src/views/SkBGViewArtist.cpp b/src/views/SkBGViewArtist.cpp
new file mode 100644
index 0000000..07da123
--- /dev/null
+++ b/src/views/SkBGViewArtist.cpp
@@ -0,0 +1,24 @@
+#include "SkBGViewArtist.h"
+#include "SkCanvas.h"
+#include "SkParsePaint.h"
+
+SkBGViewArtist::SkBGViewArtist(SkColor c)
+{
+ fPaint.setColor(c);
+}
+
+SkBGViewArtist::~SkBGViewArtist()
+{
+}
+
+void SkBGViewArtist::onDraw(SkView*, SkCanvas* canvas)
+{
+ // only works for views that are clipped their bounds.
+ canvas->drawPaint(fPaint);
+}
+
+void SkBGViewArtist::onInflate(const SkDOM& dom, const SkDOM::Node* node)
+{
+ SkPaint_Inflate(&fPaint, dom, node);
+}
+
diff --git a/src/views/SkBorderView.cpp b/src/views/SkBorderView.cpp
new file mode 100644
index 0000000..74a2477
--- /dev/null
+++ b/src/views/SkBorderView.cpp
@@ -0,0 +1,89 @@
+#include "SkBorderView.h"
+#include "SkAnimator.h"
+#include "SkWidgetViews.h"
+#include "SkSystemEventTypes.h"
+#include "SkTime.h"
+#include "SkStackViewLayout.h"
+
+SkBorderView::SkBorderView() : fLeft(SkIntToScalar(0)),
+ fRight(SkIntToScalar(0)),
+ fTop(SkIntToScalar(0)),
+ fBottom(SkIntToScalar(0))
+{
+ fAnim.setHostEventSink(this);
+ init_skin_anim(kBorder_SkinEnum, &fAnim);
+}
+
+SkBorderView::~SkBorderView()
+{
+
+}
+
+void SkBorderView::setSkin(const char skin[])
+{
+ init_skin_anim(skin, &fAnim);
+}
+
+/* virtual */ void SkBorderView::onInflate(const SkDOM& dom, const SkDOM::Node* node)
+{
+ this->INHERITED::onInflate(dom, node);
+}
+
+/*virtual*/ void SkBorderView::onSizeChange()
+{
+ this->INHERITED::onSizeChange();
+ SkEvent evt("user");
+ evt.setString("id", "setDim");
+ evt.setScalar("dimX", this->width());
+ evt.setScalar("dimY", this->height());
+ fAnim.doUserEvent(evt);
+}
+
+/*virtual*/ void SkBorderView::onDraw(SkCanvas* canvas)
+{
+ SkPaint paint;
+ SkAnimator::DifferenceType diff = fAnim.draw(canvas, &paint, SkTime::GetMSecs());
+
+ if (diff == SkAnimator::kDifferent)
+ this->inval(NULL);
+ else if (diff == SkAnimator::kPartiallyDifferent)
+ {
+ SkRect bounds;
+ fAnim.getInvalBounds(&bounds);
+ this->inval(&bounds);
+ }
+}
+
+/*virtual*/ bool SkBorderView::onEvent(const SkEvent& evt)
+{
+ if (evt.isType(SK_EventType_Inval))
+ {
+ this->inval(NULL);
+ return true;
+ }
+ if (evt.isType("recommendDim"))
+ {
+ evt.findScalar("leftMargin", &fLeft);
+ evt.findScalar("rightMargin", &fRight);
+ evt.findScalar("topMargin", &fTop);
+ evt.findScalar("bottomMargin", &fBottom);
+
+ //setup_views.cpp uses SkView::Layout instead of SkStackViewLayout
+ //but that gives me an error
+ SkStackViewLayout* layout;
+ fMargin.set(fLeft, fTop, fRight, fBottom);
+ if (this->getLayout())
+ {
+ layout = (SkStackViewLayout*)this->getLayout();
+ layout->setMargin(fMargin);
+ }
+ else
+ {
+ layout = new SkStackViewLayout;
+ layout->setMargin(fMargin);
+ this->setLayout(layout)->unref();
+ }
+ this->invokeLayout();
+ }
+ return this->INHERITED::onEvent(evt);
+}
diff --git a/src/views/SkEvent.cpp b/src/views/SkEvent.cpp
new file mode 100644
index 0000000..ec4a7b4
--- /dev/null
+++ b/src/views/SkEvent.cpp
@@ -0,0 +1,580 @@
+/* libs/graphics/views/SkEvent.cpp
+**
+** Copyright 2006, 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.
+*/
+
+#include "SkEvent.h"
+
+void SkEvent::initialize(const char* type, size_t typeLen) {
+ fType = NULL;
+ setType(type, typeLen);
+ f32 = 0;
+#ifdef SK_DEBUG
+ fTargetID = 0;
+ fTime = 0;
+ fNextEvent = NULL;
+#endif
+ SkDEBUGCODE(fDebugTrace = false;)
+}
+
+SkEvent::SkEvent()
+{
+ initialize("", 0);
+}
+
+SkEvent::SkEvent(const SkEvent& src)
+{
+ *this = src;
+ if (((size_t) fType & 1) == 0)
+ setType(src.fType);
+}
+
+SkEvent::SkEvent(const SkString& type)
+{
+ initialize(type.c_str(), type.size());
+}
+
+SkEvent::SkEvent(const char type[])
+{
+ SkASSERT(type);
+ initialize(type, strlen(type));
+}
+
+SkEvent::~SkEvent()
+{
+ if (((size_t) fType & 1) == 0)
+ sk_free((void*) fType);
+}
+
+static size_t makeCharArray(char* buffer, size_t compact)
+{
+ size_t bits = (size_t) compact >> 1;
+ memcpy(buffer, &bits, sizeof(compact));
+ buffer[sizeof(compact)] = 0;
+ return strlen(buffer);
+}
+
+#if 0
+const char* SkEvent::getType() const
+{
+ if ((size_t) fType & 1) { // not a pointer
+ char chars[sizeof(size_t) + 1];
+ size_t len = makeCharArray(chars, (size_t) fType);
+ fType = (char*) sk_malloc_throw(len);
+ SkASSERT(((size_t) fType & 1) == 0);
+ memcpy(fType, chars, len);
+ }
+ return fType;
+}
+#endif
+
+void SkEvent::getType(SkString* str) const
+{
+ if (str)
+ {
+ if ((size_t) fType & 1) // not a pointer
+ {
+ char chars[sizeof(size_t) + 1];
+ size_t len = makeCharArray(chars, (size_t) fType);
+ str->set(chars, len);
+ }
+ else
+ str->set(fType);
+ }
+}
+
+bool SkEvent::isType(const SkString& str) const
+{
+ return this->isType(str.c_str(), str.size());
+}
+
+bool SkEvent::isType(const char type[], size_t typeLen) const
+{
+ if (typeLen == 0)
+ typeLen = strlen(type);
+ if ((size_t) fType & 1) { // not a pointer
+ char chars[sizeof(size_t) + 1];
+ size_t len = makeCharArray(chars, (size_t) fType);
+ return len == typeLen && strncmp(chars, type, typeLen) == 0;
+ }
+ return strncmp(fType, type, typeLen) == 0 && fType[typeLen] == 0;
+}
+
+void SkEvent::setType(const char type[], size_t typeLen)
+{
+ if (typeLen == 0)
+ typeLen = strlen(type);
+ if (typeLen <= sizeof(fType)) {
+ size_t slot = 0;
+ memcpy(&slot, type, typeLen);
+ if (slot << 1 >> 1 != slot)
+ goto useCharStar;
+ slot <<= 1;
+ slot |= 1;
+ fType = (char*) slot;
+ } else {
+useCharStar:
+ fType = (char*) sk_malloc_throw(typeLen + 1);
+ SkASSERT(((size_t) fType & 1) == 0);
+ memcpy(fType, type, typeLen);
+ fType[typeLen] = 0;
+ }
+}
+
+void SkEvent::setType(const SkString& type)
+{
+ setType(type.c_str());
+}
+
+////////////////////////////////////////////////////////////////////////////
+
+#include "SkParse.h"
+
+void SkEvent::inflate(const SkDOM& dom, const SkDOM::Node* node)
+{
+ const char* name = dom.findAttr(node, "type");
+ if (name)
+ this->setType(name);
+
+ const char* value;
+ if ((value = dom.findAttr(node, "fast32")) != NULL)
+ {
+ int32_t n;
+ if (SkParse::FindS32(value, &n))
+ this->setFast32(n);
+ }
+
+ for (node = dom.getFirstChild(node); node; node = dom.getNextSibling(node))
+ {
+ if (strcmp(dom.getName(node), "data"))
+ {
+ SkDEBUGCODE(SkDebugf("SkEvent::inflate unrecognized subelement <%s>\n", dom.getName(node));)
+ continue;
+ }
+
+ name = dom.findAttr(node, "name");
+ if (name == NULL)
+ {
+ SkDEBUGCODE(SkDebugf("SkEvent::inflate missing required \"name\" attribute in <data> subelement\n");)
+ continue;
+ }
+
+ if ((value = dom.findAttr(node, "s32")) != NULL)
+ {
+ int32_t n;
+ if (SkParse::FindS32(value, &n))
+ this->setS32(name, n);
+ }
+ else if ((value = dom.findAttr(node, "scalar")) != NULL)
+ {
+ SkScalar x;
+ if (SkParse::FindScalar(value, &x))
+ this->setScalar(name, x);
+ }
+ else if ((value = dom.findAttr(node, "string")) != NULL)
+ this->setString(name, value);
+#ifdef SK_DEBUG
+ else
+ {
+ SkDebugf("SkEvent::inflate <data name=\"%s\"> subelement missing required type attribute [S32 | scalar | string]\n", name);
+ }
+#endif
+ }
+}
+
+#ifdef SK_DEBUG
+
+ #ifndef SkScalarToFloat
+ #define SkScalarToFloat(x) ((x) / 65536.f)
+ #endif
+
+ void SkEvent::dump(const char title[])
+ {
+ if (title)
+ SkDebugf("%s ", title);
+
+ SkString etype;
+ this->getType(&etype);
+ SkDebugf("event<%s> fast32=%d", etype.c_str(), this->getFast32());
+
+ const SkMetaData& md = this->getMetaData();
+ SkMetaData::Iter iter(md);
+ SkMetaData::Type mtype;
+ int count;
+ const char* name;
+
+ while ((name = iter.next(&mtype, &count)) != NULL)
+ {
+ SkASSERT(count > 0);
+
+ SkDebugf(" <%s>=", name);
+ switch (mtype) {
+ case SkMetaData::kS32_Type: // vector version???
+ {
+ int32_t value;
+ md.findS32(name, &value);
+ SkDebugf("%d ", value);
+ }
+ break;
+ case SkMetaData::kScalar_Type:
+ {
+ const SkScalar* values = md.findScalars(name, &count, NULL);
+ SkDebugf("%f", SkScalarToFloat(values[0]));
+ for (int i = 1; i < count; i++)
+ SkDebugf(", %f", SkScalarToFloat(values[i]));
+ SkDebugf(" ");
+ }
+ break;
+ case SkMetaData::kString_Type:
+ {
+ const char* value = md.findString(name);
+ SkASSERT(value);
+ SkDebugf("<%s> ", value);
+ }
+ break;
+ case SkMetaData::kPtr_Type: // vector version???
+ {
+ void* value;
+ md.findPtr(name, &value);
+ SkDebugf("%p ", value);
+ }
+ break;
+ case SkMetaData::kBool_Type: // vector version???
+ {
+ bool value;
+ md.findBool(name, &value);
+ SkDebugf("%s ", value ? "true" : "false");
+ }
+ break;
+ default:
+ SkASSERT(!"unknown metadata type returned from iterator");
+ break;
+ }
+ }
+ SkDebugf("\n");
+ }
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef SK_DEBUG
+// #define SK_TRACE_EVENTSx
+#endif
+
+#ifdef SK_TRACE_EVENTS
+ static void event_log(const char s[])
+ {
+ SkDEBUGF(("%s\n", s));
+ }
+
+ #define EVENT_LOG(s) event_log(s)
+ #define EVENT_LOGN(s, n) do { SkString str(s); str.append(" "); str.appendS32(n); event_log(str.c_str()); } while (0)
+#else
+ #define EVENT_LOG(s)
+ #define EVENT_LOGN(s, n)
+#endif
+
+#include "SkGlobals.h"
+#include "SkThread.h"
+#include "SkTime.h"
+
+#define SK_Event_GlobalsTag SkSetFourByteTag('e', 'v', 'n', 't')
+
+class SkEvent_Globals : public SkGlobals::Rec {
+public:
+ SkMutex fEventMutex;
+ SkEvent* fEventQHead, *fEventQTail;
+ SkEvent* fDelayQHead;
+ SkDEBUGCODE(int fEventCounter;)
+};
+
+static SkGlobals::Rec* create_globals()
+{
+ SkEvent_Globals* rec = new SkEvent_Globals;
+ rec->fEventQHead = NULL;
+ rec->fEventQTail = NULL;
+ rec->fDelayQHead = NULL;
+ SkDEBUGCODE(rec->fEventCounter = 0;)
+ return rec;
+}
+
+bool SkEvent::Post(SkEvent* evt, SkEventSinkID sinkID, SkMSec delay)
+{
+ if (delay)
+ return SkEvent::PostTime(evt, sinkID, SkTime::GetMSecs() + delay);
+
+ SkEvent_Globals& globals = *(SkEvent_Globals*)SkGlobals::Find(SK_Event_GlobalsTag, create_globals);
+
+ evt->fTargetID = sinkID;
+
+#ifdef SK_TRACE_EVENTS
+ {
+ SkString str("SkEvent::Post(");
+ str.append(evt->getType());
+ str.append(", 0x");
+ str.appendHex(sinkID);
+ str.append(", ");
+ str.appendS32(delay);
+ str.append(")");
+ event_log(str.c_str());
+ }
+#endif
+
+ globals.fEventMutex.acquire();
+ bool wasEmpty = SkEvent::Enqueue(evt);
+ globals.fEventMutex.release();
+
+ // call outside of us holding the mutex
+ if (wasEmpty)
+ SkEvent::SignalNonEmptyQueue();
+ return true;
+}
+
+#if defined(SK_SIMULATE_FAILED_MALLOC) && defined(SK_FIND_MEMORY_LEAKS)
+SkMSec gMaxDrawTime;
+#endif
+
+bool SkEvent::PostTime(SkEvent* evt, SkEventSinkID sinkID, SkMSec time)
+{
+#if defined(SK_SIMULATE_FAILED_MALLOC) && defined(SK_FIND_MEMORY_LEAKS)
+ gMaxDrawTime = time;
+#endif
+ SkEvent_Globals& globals = *(SkEvent_Globals*)SkGlobals::Find(SK_Event_GlobalsTag, create_globals);
+
+ evt->fTargetID = sinkID;
+
+#ifdef SK_TRACE_EVENTS
+ {
+ SkString str("SkEvent::Post(");
+ str.append(evt->getType());
+ str.append(", 0x");
+ str.appendHex(sinkID);
+ str.append(", ");
+ str.appendS32(time);
+ str.append(")");
+ event_log(str.c_str());
+ }
+#endif
+
+ globals.fEventMutex.acquire();
+ SkMSec queueDelay = SkEvent::EnqueueTime(evt, time);
+ globals.fEventMutex.release();
+
+ // call outside of us holding the mutex
+ if ((int32_t)queueDelay != ~0)
+ SkEvent::SignalQueueTimer(queueDelay);
+ return true;
+}
+
+bool SkEvent::Enqueue(SkEvent* evt)
+{
+ SkEvent_Globals& globals = *(SkEvent_Globals*)SkGlobals::Find(SK_Event_GlobalsTag, create_globals);
+ // gEventMutex acquired by caller
+
+ SkASSERT(evt);
+
+ bool wasEmpty = globals.fEventQHead == NULL;
+
+ if (globals.fEventQTail)
+ globals.fEventQTail->fNextEvent = evt;
+ globals.fEventQTail = evt;
+ if (globals.fEventQHead == NULL)
+ globals.fEventQHead = evt;
+ evt->fNextEvent = NULL;
+
+ SkDEBUGCODE(++globals.fEventCounter);
+// SkDebugf("Enqueue: count=%d\n", gEventCounter);
+
+ return wasEmpty;
+}
+
+SkEvent* SkEvent::Dequeue(SkEventSinkID* sinkID)
+{
+ SkEvent_Globals& globals = *(SkEvent_Globals*)SkGlobals::Find(SK_Event_GlobalsTag, create_globals);
+ globals.fEventMutex.acquire();
+
+ SkEvent* evt = globals.fEventQHead;
+ if (evt)
+ {
+ SkDEBUGCODE(--globals.fEventCounter);
+
+ if (sinkID)
+ *sinkID = evt->fTargetID;
+
+ globals.fEventQHead = evt->fNextEvent;
+ if (globals.fEventQHead == NULL)
+ globals.fEventQTail = NULL;
+ }
+ globals.fEventMutex.release();
+
+// SkDebugf("Dequeue: count=%d\n", gEventCounter);
+
+ return evt;
+}
+
+bool SkEvent::QHasEvents()
+{
+ SkEvent_Globals& globals = *(SkEvent_Globals*)SkGlobals::Find(SK_Event_GlobalsTag, create_globals);
+
+ // this is not thread accurate, need a semaphore for that
+ return globals.fEventQHead != NULL;
+}
+
+#ifdef SK_TRACE_EVENTS
+ static int gDelayDepth;
+#endif
+
+SkMSec SkEvent::EnqueueTime(SkEvent* evt, SkMSec time)
+{
+#ifdef SK_TRACE_EVENTS
+ SkDebugf("enqueue-delay %s %d (%d)", evt->getType(), time, gDelayDepth);
+ const char* idStr = evt->findString("id");
+ if (idStr)
+ SkDebugf(" (%s)", idStr);
+ SkDebugf("\n");
+ ++gDelayDepth;
+#endif
+
+ SkEvent_Globals& globals = *(SkEvent_Globals*)SkGlobals::Find(SK_Event_GlobalsTag, create_globals);
+ // gEventMutex acquired by caller
+
+ SkEvent* curr = globals.fDelayQHead;
+ SkEvent* prev = NULL;
+
+ while (curr)
+ {
+ if (SkMSec_LT(time, curr->fTime))
+ break;
+ prev = curr;
+ curr = curr->fNextEvent;
+ }
+
+ evt->fTime = time;
+ evt->fNextEvent = curr;
+ if (prev == NULL)
+ globals.fDelayQHead = evt;
+ else
+ prev->fNextEvent = evt;
+
+ SkMSec delay = globals.fDelayQHead->fTime - SkTime::GetMSecs();
+ if ((int32_t)delay <= 0)
+ delay = 1;
+ return delay;
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+#include "SkEventSink.h"
+
+bool SkEvent::ProcessEvent()
+{
+ SkEventSinkID sinkID;
+ SkEvent* evt = SkEvent::Dequeue(&sinkID);
+ SkAutoTDelete<SkEvent> autoDelete(evt);
+ bool again = false;
+
+ EVENT_LOGN("ProcessEvent", (int32_t)evt);
+
+ if (evt)
+ {
+ (void)SkEventSink::DoEvent(*evt, sinkID);
+ again = SkEvent::QHasEvents();
+ }
+ return again;
+}
+
+void SkEvent::ServiceQueueTimer()
+{
+ SkEvent_Globals& globals = *(SkEvent_Globals*)SkGlobals::Find(SK_Event_GlobalsTag, create_globals);
+
+ globals.fEventMutex.acquire();
+
+ bool wasEmpty = false;
+ SkMSec now = SkTime::GetMSecs();
+ SkEvent* evt = globals.fDelayQHead;
+
+ while (evt)
+ {
+ if (SkMSec_LT(now, evt->fTime))
+ break;
+
+#ifdef SK_TRACE_EVENTS
+ --gDelayDepth;
+ SkDebugf("dequeue-delay %s (%d)", evt->getType(), gDelayDepth);
+ const char* idStr = evt->findString("id");
+ if (idStr)
+ SkDebugf(" (%s)", idStr);
+ SkDebugf("\n");
+#endif
+
+ SkEvent* next = evt->fNextEvent;
+ if (SkEvent::Enqueue(evt))
+ wasEmpty = true;
+ evt = next;
+ }
+ globals.fDelayQHead = evt;
+
+ SkMSec time = evt ? evt->fTime - now : 0;
+
+ globals.fEventMutex.release();
+
+ if (wasEmpty)
+ SkEvent::SignalNonEmptyQueue();
+
+ SkEvent::SignalQueueTimer(time);
+}
+
+int SkEvent::CountEventsOnQueue() {
+ SkEvent_Globals& globals = *(SkEvent_Globals*)SkGlobals::Find(SK_Event_GlobalsTag, create_globals);
+ globals.fEventMutex.acquire();
+
+ int count = 0;
+ const SkEvent* evt = globals.fEventQHead;
+ while (evt) {
+ count += 1;
+ evt = evt->fNextEvent;
+ }
+ globals.fEventMutex.release();
+
+ return count;
+}
+
+////////////////////////////////////////////////////////////////
+
+void SkEvent::Init()
+{
+}
+
+void SkEvent::Term()
+{
+ SkEvent_Globals& globals = *(SkEvent_Globals*)SkGlobals::Find(SK_Event_GlobalsTag, create_globals);
+
+ SkEvent* evt = globals.fEventQHead;
+ while (evt)
+ {
+ SkEvent* next = evt->fNextEvent;
+ delete evt;
+ evt = next;
+ }
+
+ evt = globals.fDelayQHead;
+ while (evt)
+ {
+ SkEvent* next = evt->fNextEvent;
+ delete evt;
+ evt = next;
+ }
+}
+
diff --git a/src/views/SkEventSink.cpp b/src/views/SkEventSink.cpp
new file mode 100644
index 0000000..c8fe35c
--- /dev/null
+++ b/src/views/SkEventSink.cpp
@@ -0,0 +1,345 @@
+/* libs/graphics/views/SkEventSink.cpp
+**
+** Copyright 2006, 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.
+*/
+
+#include "SkEventSink.h"
+#include "SkTagList.h"
+#include "SkThread.h"
+
+#include "SkGlobals.h"
+#include "SkThread.h"
+#include "SkTime.h"
+
+#define SK_EventSink_GlobalsTag SkSetFourByteTag('e', 'v', 's', 'k')
+
+class SkEventSink_Globals : public SkGlobals::Rec {
+public:
+ SkMutex fSinkMutex;
+ SkEventSinkID fNextSinkID;
+ SkEventSink* fSinkHead;
+};
+
+static SkGlobals::Rec* create_globals()
+{
+ SkEventSink_Globals* rec = new SkEventSink_Globals;
+ rec->fNextSinkID = 0;
+ rec->fSinkHead = NULL;
+ return rec;
+}
+
+SkEventSink::SkEventSink() : fTagHead(NULL)
+{
+ SkEventSink_Globals& globals = *(SkEventSink_Globals*)SkGlobals::Find(SK_EventSink_GlobalsTag, create_globals);
+
+ globals.fSinkMutex.acquire();
+
+ fID = ++globals.fNextSinkID;
+ fNextSink = globals.fSinkHead;
+ globals.fSinkHead = this;
+
+ globals.fSinkMutex.release();
+}
+
+SkEventSink::~SkEventSink()
+{
+ SkEventSink_Globals& globals = *(SkEventSink_Globals*)SkGlobals::Find(SK_EventSink_GlobalsTag, create_globals);
+
+ if (fTagHead)
+ SkTagList::DeleteAll(fTagHead);
+
+ globals.fSinkMutex.acquire();
+
+ SkEventSink* sink = globals.fSinkHead;
+ SkEventSink* prev = NULL;
+
+ for (;;)
+ {
+ SkEventSink* next = sink->fNextSink;
+ if (sink == this)
+ {
+ if (prev)
+ prev->fNextSink = next;
+ else
+ globals.fSinkHead = next;
+ break;
+ }
+ prev = sink;
+ sink = next;
+ }
+ globals.fSinkMutex.release();
+}
+
+bool SkEventSink::doEvent(const SkEvent& evt)
+{
+ return this->onEvent(evt);
+}
+
+bool SkEventSink::doQuery(SkEvent* evt)
+{
+ SkASSERT(evt);
+ return this->onQuery(evt);
+}
+
+bool SkEventSink::onEvent(const SkEvent&)
+{
+ return false;
+}
+
+bool SkEventSink::onQuery(SkEvent*)
+{
+ return false;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+SkTagList* SkEventSink::findTagList(U8CPU tag) const
+{
+ return fTagHead ? SkTagList::Find(fTagHead, tag) : NULL;
+}
+
+void SkEventSink::addTagList(SkTagList* rec)
+{
+ SkASSERT(rec);
+ SkASSERT(fTagHead == NULL || SkTagList::Find(fTagHead, rec->fTag) == NULL);
+
+ rec->fNext = fTagHead;
+ fTagHead = rec;
+}
+
+void SkEventSink::removeTagList(U8CPU tag)
+{
+ if (fTagHead)
+ SkTagList::DeleteTag(&fTagHead, tag);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+struct SkListenersTagList : SkTagList {
+ SkListenersTagList(U16CPU count) : SkTagList(kListeners_SkTagList)
+ {
+ fExtra16 = SkToU16(count);
+ fIDs = (SkEventSinkID*)sk_malloc_throw(count * sizeof(SkEventSinkID));
+ }
+ virtual ~SkListenersTagList()
+ {
+ sk_free(fIDs);
+ }
+
+ int countListners() const { return fExtra16; }
+
+ int find(SkEventSinkID id) const
+ {
+ const SkEventSinkID* idptr = fIDs;
+ for (int i = fExtra16 - 1; i >= 0; --i)
+ if (idptr[i] == id)
+ return i;
+ return -1;
+ }
+
+ SkEventSinkID* fIDs;
+};
+
+void SkEventSink::addListenerID(SkEventSinkID id)
+{
+ if (id == 0)
+ return;
+
+ SkListenersTagList* prev = (SkListenersTagList*)this->findTagList(kListeners_SkTagList);
+ int count = 0;
+
+ if (prev)
+ {
+ if (prev->find(id) >= 0)
+ return;
+ count = prev->countListners();
+ }
+
+ SkListenersTagList* next = SkNEW_ARGS(SkListenersTagList, (count + 1));
+
+ if (prev)
+ {
+ memcpy(next->fIDs, prev->fIDs, count * sizeof(SkEventSinkID));
+ this->removeTagList(kListeners_SkTagList);
+ }
+ next->fIDs[count] = id;
+ this->addTagList(next);
+}
+
+void SkEventSink::copyListeners(const SkEventSink& sink)
+{
+ SkListenersTagList* sinkList = (SkListenersTagList*)sink.findTagList(kListeners_SkTagList);
+ if (sinkList == NULL)
+ return;
+ SkASSERT(sinkList->countListners() > 0);
+ const SkEventSinkID* iter = sinkList->fIDs;
+ const SkEventSinkID* stop = iter + sinkList->countListners();
+ while (iter < stop)
+ addListenerID(*iter++);
+}
+
+void SkEventSink::removeListenerID(SkEventSinkID id)
+{
+ if (id == 0)
+ return;
+
+ SkListenersTagList* list = (SkListenersTagList*)this->findTagList(kListeners_SkTagList);
+
+ if (list == NULL)
+ return;
+
+ int index = list->find(id);
+ if (index >= 0)
+ {
+ int count = list->countListners();
+ SkASSERT(count > 0);
+ if (count == 1)
+ this->removeTagList(kListeners_SkTagList);
+ else
+ {
+ // overwrite without resize/reallocating our struct (for speed)
+ list->fIDs[index] = list->fIDs[count - 1];
+ list->fExtra16 = SkToU16(count - 1);
+ }
+ }
+}
+
+bool SkEventSink::hasListeners() const
+{
+ return this->findTagList(kListeners_SkTagList) != NULL;
+}
+
+void SkEventSink::postToListeners(const SkEvent& evt, SkMSec delay)
+{
+ SkListenersTagList* list = (SkListenersTagList*)this->findTagList(kListeners_SkTagList);
+ if (list)
+ {
+ SkASSERT(list->countListners() > 0);
+ const SkEventSinkID* iter = list->fIDs;
+ const SkEventSinkID* stop = iter + list->countListners();
+ while (iter < stop)
+ (SkNEW_ARGS(SkEvent, (evt)))->post(*iter++, delay);
+ }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+SkEventSink::EventResult SkEventSink::DoEvent(const SkEvent& evt, SkEventSinkID sinkID)
+{
+ SkEventSink* sink = SkEventSink::FindSink(sinkID);
+
+ if (sink)
+ {
+#ifdef SK_DEBUG
+ if (evt.isDebugTrace())
+ {
+ SkString etype;
+ evt.getType(&etype);
+ SkDebugf("SkEventTrace: dispatching event <%s> to 0x%x", etype.c_str(), sinkID);
+ const char* idStr = evt.findString("id");
+ if (idStr)
+ SkDebugf(" (%s)", idStr);
+ SkDebugf("\n");
+ }
+#endif
+ return sink->doEvent(evt) ? kHandled_EventResult : kNotHandled_EventResult;
+ }
+ else
+ {
+#ifdef SK_DEBUG
+ if (sinkID)
+ SkDebugf("DoEvent: Can't find sink for ID(%x)\n", sinkID);
+ else
+ SkDebugf("Event sent to 0 sinkID\n");
+
+ if (evt.isDebugTrace())
+ {
+ SkString etype;
+ evt.getType(&etype);
+ SkDebugf("SkEventTrace: eventsink not found <%s> for 0x%x\n", etype.c_str(), sinkID);
+ }
+#endif
+ return kSinkNotFound_EventResult;
+ }
+}
+
+SkEventSink* SkEventSink::FindSink(SkEventSinkID sinkID)
+{
+ if (sinkID == 0)
+ return 0;
+
+ SkEventSink_Globals& globals = *(SkEventSink_Globals*)SkGlobals::Find(SK_EventSink_GlobalsTag, create_globals);
+ SkAutoMutexAcquire ac(globals.fSinkMutex);
+ SkEventSink* sink = globals.fSinkHead;
+
+ while (sink)
+ {
+ if (sink->getSinkID() == sinkID)
+ return sink;
+ sink = sink->fNextSink;
+ }
+ return NULL;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////
+
+#if 0 // experimental, not tested
+
+#include "SkThread.h"
+#include "SkTDict.h"
+
+#define kMinStringBufferSize 128
+static SkMutex gNamedSinkMutex;
+static SkTDict<SkEventSinkID> gNamedSinkIDs(kMinStringBufferSize);
+
+/** Register a name/id pair with the system. If the name already exists,
+ replace its ID with the new id. This pair will persist until UnregisterNamedSink()
+ is called.
+*/
+void SkEventSink::RegisterNamedSinkID(const char name[], SkEventSinkID id)
+{
+ if (id && name && *name)
+ {
+ SkAutoMutexAcquire ac(gNamedSinkMutex);
+ gNamedSinkIDs.set(name, id);
+ }
+}
+
+/** Return the id that matches the specified name (from a previous call to
+ RegisterNamedSinkID(). If no match is found, return 0
+*/
+SkEventSinkID SkEventSink::FindNamedSinkID(const char name[])
+{
+ SkEventSinkID id = 0;
+
+ if (name && *name)
+ {
+ SkAutoMutexAcquire ac(gNamedSinkMutex);
+ (void)gNamedSinkIDs.find(name, &id);
+ }
+ return id;
+}
+
+/** Remove all name/id pairs from the system. This is call internally
+ on shutdown, to ensure no memory leaks. It should not be called
+ before shutdown.
+*/
+void SkEventSink::RemoveAllNamedSinkIDs()
+{
+ SkAutoMutexAcquire ac(gNamedSinkMutex);
+ (void)gNamedSinkIDs.reset();
+}
+#endif
diff --git a/src/views/SkImageView.cpp b/src/views/SkImageView.cpp
new file mode 100644
index 0000000..9c358c7
--- /dev/null
+++ b/src/views/SkImageView.cpp
@@ -0,0 +1,296 @@
+#include "SkImageView.h"
+#include "SkAnimator.h"
+#include "SkBitmap.h"
+#include "SkCanvas.h"
+#include "SkImageDecoder.h"
+#include "SkMatrix.h"
+#include "SkSystemEventTypes.h"
+#include "SkTime.h"
+
+SkImageView::SkImageView()
+{
+ fMatrix = NULL;
+ fScaleType = kMatrix_ScaleType;
+
+ fData.fAnim = NULL; // handles initializing the other union values
+ fDataIsAnim = true;
+
+ fUriIsValid = false; // an empty string is not valid
+}
+
+SkImageView::~SkImageView()
+{
+ if (fMatrix)
+ sk_free(fMatrix);
+
+ this->freeData();
+}
+
+void SkImageView::getUri(SkString* uri) const
+{
+ if (uri)
+ *uri = fUri;
+}
+
+void SkImageView::setUri(const char uri[])
+{
+ if (!fUri.equals(uri))
+ {
+ fUri.set(uri);
+ this->onUriChange();
+ }
+}
+
+void SkImageView::setUri(const SkString& uri)
+{
+ if (fUri != uri)
+ {
+ fUri = uri;
+ this->onUriChange();
+ }
+}
+
+void SkImageView::setScaleType(ScaleType st)
+{
+ SkASSERT((unsigned)st <= kFitEnd_ScaleType);
+
+ if ((ScaleType)fScaleType != st)
+ {
+ fScaleType = SkToU8(st);
+ if (fUriIsValid)
+ this->inval(NULL);
+ }
+}
+
+bool SkImageView::getImageMatrix(SkMatrix* matrix) const
+{
+ if (fMatrix)
+ {
+ SkASSERT(!fMatrix->isIdentity());
+ if (matrix)
+ *matrix = *fMatrix;
+ return true;
+ }
+ else
+ {
+ if (matrix)
+ matrix->reset();
+ return false;
+ }
+}
+
+void SkImageView::setImageMatrix(const SkMatrix* matrix)
+{
+ bool changed = false;
+
+ if (matrix && !matrix->isIdentity())
+ {
+ if (fMatrix == NULL)
+ fMatrix = (SkMatrix*)sk_malloc_throw(sizeof(SkMatrix));
+ *fMatrix = *matrix;
+ changed = true;
+ }
+ else // set us to identity
+ {
+ if (fMatrix)
+ {
+ SkASSERT(!fMatrix->isIdentity());
+ sk_free(fMatrix);
+ fMatrix = NULL;
+ changed = true;
+ }
+ }
+
+ // only redraw if we changed our matrix and we're not in scaleToFit mode
+ if (changed && this->getScaleType() == kMatrix_ScaleType && fUriIsValid)
+ this->inval(NULL);
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////
+
+bool SkImageView::onEvent(const SkEvent& evt)
+{
+ if (evt.isType(SK_EventType_Inval))
+ {
+ if (fUriIsValid)
+ this->inval(NULL);
+ return true;
+ }
+ return this->INHERITED::onEvent(evt);
+}
+
+static inline SkMatrix::ScaleToFit scaleTypeToScaleToFit(SkImageView::ScaleType st)
+{
+ SkASSERT(st != SkImageView::kMatrix_ScaleType);
+ SkASSERT((unsigned)st <= SkImageView::kFitEnd_ScaleType);
+
+ SkASSERT(SkImageView::kFitXY_ScaleType - 1 == SkMatrix::kFill_ScaleToFit);
+ SkASSERT(SkImageView::kFitStart_ScaleType - 1 == SkMatrix::kStart_ScaleToFit);
+ SkASSERT(SkImageView::kFitCenter_ScaleType - 1 == SkMatrix::kCenter_ScaleToFit);
+ SkASSERT(SkImageView::kFitEnd_ScaleType - 1 == SkMatrix::kEnd_ScaleToFit);
+
+ return (SkMatrix::ScaleToFit)(st - 1);
+}
+
+void SkImageView::onDraw(SkCanvas* canvas)
+{
+ SkRect src;
+ if (!this->getDataBounds(&src))
+ {
+ SkDEBUGCODE(canvas->drawColor(SK_ColorRED);)
+ return; // nothing to draw
+ }
+
+ SkAutoCanvasRestore restore(canvas, true);
+ SkMatrix matrix;
+
+ if (this->getScaleType() == kMatrix_ScaleType)
+ (void)this->getImageMatrix(&matrix);
+ else
+ {
+ SkRect dst;
+ dst.set(0, 0, this->width(), this->height());
+ matrix.setRectToRect(src, dst, scaleTypeToScaleToFit(this->getScaleType()));
+ }
+ canvas->concat(matrix);
+
+ SkPaint paint;
+
+ paint.setAntiAlias(true);
+
+ if (fDataIsAnim)
+ {
+ SkMSec now = SkTime::GetMSecs();
+
+ SkAnimator::DifferenceType diff = fData.fAnim->draw(canvas, &paint, now);
+
+SkDEBUGF(("SkImageView : now = %X[%12.3f], diff = %d\n", now, now/1000., diff));
+
+ if (diff == SkAnimator::kDifferent)
+ this->inval(NULL);
+ else if (diff == SkAnimator::kPartiallyDifferent)
+ {
+ SkRect bounds;
+ fData.fAnim->getInvalBounds(&bounds);
+ matrix.mapRect(&bounds); // get the bounds into view coordinates
+ this->inval(&bounds);
+ }
+ }
+ else
+ canvas->drawBitmap(*fData.fBitmap, 0, 0, &paint);
+}
+
+void SkImageView::onInflate(const SkDOM& dom, const SkDOMNode* node)
+{
+ this->INHERITED::onInflate(dom, node);
+
+ const char* src = dom.findAttr(node, "src");
+ if (src)
+ this->setUri(src);
+
+ int index = dom.findList(node, "scaleType", "matrix,fitXY,fitStart,fitCenter,fitEnd");
+ if (index >= 0)
+ this->setScaleType((ScaleType)index);
+
+ // need inflate syntax/reader for matrix
+}
+
+/////////////////////////////////////////////////////////////////////////////////////
+
+void SkImageView::onUriChange()
+{
+ if (this->freeData())
+ this->inval(NULL);
+ fUriIsValid = true; // give ensureUriIsLoaded() a shot at the new uri
+}
+
+bool SkImageView::freeData()
+{
+ if (fData.fAnim) // test is valid for all union values
+ {
+ if (fDataIsAnim)
+ delete fData.fAnim;
+ else
+ delete fData.fBitmap;
+
+ fData.fAnim = NULL; // valid for all union values
+ return true;
+ }
+ return false;
+}
+
+bool SkImageView::getDataBounds(SkRect* bounds)
+{
+ SkASSERT(bounds);
+
+ if (this->ensureUriIsLoaded())
+ {
+ SkScalar width, height;
+
+ if (fDataIsAnim)
+ {
+ if (SkScalarIsNaN(width = fData.fAnim->getScalar("dimensions", "x")) ||
+ SkScalarIsNaN(height = fData.fAnim->getScalar("dimensions", "y")))
+ {
+ // cons up fake bounds
+ width = this->width();
+ height = this->height();
+ }
+ }
+ else
+ {
+ width = SkIntToScalar(fData.fBitmap->width());
+ height = SkIntToScalar(fData.fBitmap->height());
+ }
+ bounds->set(0, 0, width, height);
+ return true;
+ }
+ return false;
+}
+
+bool SkImageView::ensureUriIsLoaded()
+{
+ if (fData.fAnim) // test is valid for all union values
+ {
+ SkASSERT(fUriIsValid);
+ return true;
+ }
+ if (!fUriIsValid)
+ return false;
+
+ // try to load the url
+ if (fUri.endsWith(".xml")) // assume it is screenplay
+ {
+ SkAnimator* anim = new SkAnimator;
+
+ if (!anim->decodeURI(fUri.c_str()))
+ {
+ delete anim;
+ fUriIsValid = false;
+ return false;
+ }
+ anim->setHostEventSink(this);
+
+ fData.fAnim = anim;
+ fDataIsAnim = true;
+ }
+ else // assume it is an image format
+ {
+ #if 0
+ SkBitmap* bitmap = new SkBitmap;
+
+ if (!SkImageDecoder::DecodeURL(fUri.c_str(), bitmap))
+ {
+ delete bitmap;
+ fUriIsValid = false;
+ return false;
+ }
+ fData.fBitmap = bitmap;
+ fDataIsAnim = false;
+ #else
+ return false;
+ #endif
+ }
+ return true;
+}
+
diff --git a/src/views/SkListView.cpp b/src/views/SkListView.cpp
new file mode 100644
index 0000000..ba4f02a
--- /dev/null
+++ b/src/views/SkListView.cpp
@@ -0,0 +1,895 @@
+#include "SkWidget.h"
+#include "SkCanvas.h"
+#include "SkEvent.h"
+#include "SkKey.h"
+#include "SkParsePaint.h"
+#include "SkSystemEventTypes.h"
+
+#if 0
+
+SkEvent* SkListSource::getEvent(int index)
+{
+ return NULL;
+}
+
+#include "SkOSFile.h"
+
+class SkDirListSource : public SkListSource {
+public:
+ SkDirListSource(const char path[], const char suffix[], const char target[])
+ : fPath(path), fSuffix(suffix), fTarget(target)
+ {
+ fCount = -1;
+ }
+ virtual int countRows()
+ {
+ if (fCount < 0)
+ {
+ fCount = 0;
+ fIter.reset(fPath.c_str(), fSuffix.c_str());
+ while (fIter.next(NULL))
+ fCount += 1;
+ fIter.reset(fPath.c_str(), fSuffix.c_str());
+ fIndex = 0;
+ }
+ return fCount;
+ }
+ virtual void getRow(int index, SkString* left, SkString* right)
+ {
+ (void)this->countRows();
+ SkASSERT((unsigned)index < (unsigned)fCount);
+
+ if (fIndex > index)
+ {
+ fIter.reset(fPath.c_str(), fSuffix.c_str());
+ fIndex = 0;
+ }
+
+ while (fIndex < index)
+ {
+ fIter.next(NULL);
+ fIndex += 1;
+ }
+
+ if (fIter.next(left))
+ {
+ if (left)
+ left->remove(left->size() - fSuffix.size(), fSuffix.size());
+ }
+ else
+ {
+ if (left)
+ left->reset();
+ }
+ if (right) // only set to ">" if we know we're on a sub-directory
+ right->reset();
+
+ fIndex += 1;
+ }
+ virtual SkEvent* getEvent(int index)
+ {
+ SkASSERT((unsigned)index < (unsigned)fCount);
+
+ SkEvent* evt = new SkEvent();
+ SkString label;
+
+ this->getRow(index, &label, NULL);
+ evt->setString("name", label.c_str());
+
+ int c = fPath.c_str()[fPath.size() - 1];
+ if (c != '/' && c != '\\')
+ label.prepend("/");
+ label.prepend(fPath);
+ label.append(fSuffix);
+ evt->setString("path", label.c_str());
+ evt->setS32("index", index);
+ evt->setS32("duration", 22);
+ evt->setType(fTarget);
+ return evt;
+ }
+
+private:
+ SkString fPath, fSuffix;
+ SkString fTarget;
+ SkOSFile::Iter fIter;
+ int fCount;
+ int fIndex;
+};
+
+SkListSource* SkListSource::CreateFromDir(const char path[], const char suffix[], const char target[])
+{
+ return new SkDirListSource(path, suffix, target);
+}
+
+//////////////////////////////////////////////////////////////////
+
+class SkDOMListSource : public SkListSource {
+public:
+ enum Type {
+ kUnknown_Type,
+ kDir_Type,
+ kToggle_Type
+ };
+ struct ItemRec {
+ SkString fLabel;
+ SkString fTail, fAltTail;
+ SkString fTarget;
+ Type fType;
+ };
+
+ SkDOMListSource(const SkDOM& dom, const SkDOM::Node* node) : fDirTail(">")
+ {
+ const SkDOM::Node* child = dom.getFirstChild(node, "item");
+ int count = 0;
+
+ while (child)
+ {
+ count += 1;
+ child = dom.getNextSibling(child, "item");
+ }
+
+ fCount = count;
+ fList = NULL;
+ if (count)
+ {
+ ItemRec* rec = fList = new ItemRec[count];
+
+ child = dom.getFirstChild(node, "item");
+ while (child)
+ {
+ rec->fLabel.set(dom.findAttr(child, "label"));
+ rec->fTail.set(dom.findAttr(child, "tail"));
+ rec->fAltTail.set(dom.findAttr(child, "alt-tail"));
+ rec->fTarget.set(dom.findAttr(child, "target"));
+ rec->fType = kUnknown_Type;
+
+ int index = dom.findList(child, "type", "dir,toggle");
+ if (index >= 0)
+ rec->fType = (Type)(index + 1);
+
+ child = dom.getNextSibling(child, "item");
+ rec += 1;
+ }
+ }
+ }
+ virtual ~SkDOMListSource()
+ {
+ delete[] fList;
+ }
+ virtual int countRows()
+ {
+ return fCount;
+ }
+ virtual void getRow(int index, SkString* left, SkString* right)
+ {
+ SkASSERT((unsigned)index < (unsigned)fCount);
+
+ if (left)
+ *left = fList[index].fLabel;
+ if (right)
+ *right = fList[index].fType == kDir_Type ? fDirTail : fList[index].fTail;
+ }
+ virtual SkEvent* getEvent(int index)
+ {
+ SkASSERT((unsigned)index < (unsigned)fCount);
+
+ if (fList[index].fType == kDir_Type)
+ {
+ SkEvent* evt = new SkEvent();
+ evt->setType(fList[index].fTarget);
+ evt->setFast32(index);
+ return evt;
+ }
+ if (fList[index].fType == kToggle_Type)
+ fList[index].fTail.swap(fList[index].fAltTail);
+
+ return NULL;
+ }
+
+private:
+ int fCount;
+ ItemRec* fList;
+ SkString fDirTail;
+};
+
+SkListSource* SkListSource::CreateFromDOM(const SkDOM& dom, const SkDOM::Node* node)
+{
+ return new SkDOMListSource(dom, node);
+}
+
+//////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////
+
+SkListView::SkListView(U32 flags) : SkWidgetView(flags)
+{
+ fSource = NULL;
+ fScrollIndex = 0;
+ fCurrIndex = -1;
+ fRowHeight = SkIntToScalar(16);
+ fVisibleRowCount = 0;
+ fStrCache = NULL;
+
+ fPaint[kBG_Attr].setColor(0);
+ fPaint[kNormalText_Attr].setTextSize(SkIntToScalar(14));
+ fPaint[kHiliteText_Attr].setTextSize(SkIntToScalar(14));
+ fPaint[kHiliteText_Attr].setColor(SK_ColorWHITE);
+ fPaint[kHiliteCell_Attr].setColor(SK_ColorBLUE);
+}
+
+SkListView::~SkListView()
+{
+ delete[] fStrCache;
+ fSource->safeUnref();
+}
+
+void SkListView::setRowHeight(SkScalar height)
+{
+ SkASSERT(height >= 0);
+
+ if (fRowHeight != height)
+ {
+ fRowHeight = height;
+ this->inval(NULL);
+ this->onSizeChange();
+ }
+}
+
+void SkListView::setSelection(int index)
+{
+ if (fCurrIndex != index)
+ {
+ this->invalSelection();
+ fCurrIndex = index;
+ this->invalSelection();
+ this->ensureSelectionIsVisible();
+
+ {
+ SkEvent evt;
+ evt.setType("listview-selection");
+ evt.setFast32(index);
+ this->sendEventToParents(evt);
+ }
+ }
+}
+
+void SkListView::moveSelectionUp()
+{
+ if (fSource)
+ {
+ int index = fCurrIndex;
+ if (index < 0) // no selection
+ index = fSource->countRows() - 1;
+ else
+ index = SkMax32(index - 1, 0);
+ this->setSelection(index);
+ }
+}
+
+void SkListView::moveSelectionDown()
+{
+ if (fSource)
+ {
+ int index = fCurrIndex;
+ if (index < 0) // no selection
+ index = 0;
+ else
+ index = SkMin32(index + 1, fSource->countRows() - 1);
+ this->setSelection(index);
+ }
+}
+
+void SkListView::invalSelection()
+{
+ SkRect r;
+ if (this->getRowRect(fCurrIndex, &r))
+ this->inval(&r);
+}
+
+void SkListView::ensureSelectionIsVisible()
+{
+ if (fSource == NULL)
+ return;
+
+ if ((unsigned)fCurrIndex < (unsigned)fSource->countRows())
+ {
+ int index = this->logicalToVisualIndex(fCurrIndex);
+
+ if ((unsigned)index >= (unsigned)fVisibleRowCount) // need to scroll
+ {
+ if (index < 0) // too high
+ fScrollIndex = fCurrIndex;
+ else
+ fScrollIndex = fCurrIndex - fVisibleRowCount + 1;
+ SkASSERT((unsigned)fScrollIndex < (unsigned)fSource->countRows());
+
+ this->dirtyStrCache();
+ this->inval(NULL);
+ }
+ }
+}
+
+bool SkListView::getRowRect(int index, SkRect* r) const
+{
+ SkASSERT(r);
+ index = this->logicalToVisualIndex(index);
+ if (index >= 0)
+ {
+ SkScalar top = index * fRowHeight;
+
+ if (top < this->height())
+ {
+ if (r)
+ r->set(0, top, this->width(), top + fRowHeight);
+ return true;
+ }
+ }
+ return false;
+}
+
+SkPaint& SkListView::paint(Attr attr)
+{
+ SkASSERT((unsigned)attr < kAttrCount);
+ return fPaint[attr];
+}
+
+SkListSource* SkListView::setListSource(SkListSource* src)
+{
+ if (fSource != src)
+ {
+ SkRefCnt_SafeAssign(fSource, src);
+ this->dirtyStrCache();
+ this->ensureSelectionIsVisible();
+ this->inval(NULL);
+ }
+ return src;
+}
+
+void SkListView::onDraw(SkCanvas* canvas)
+{
+ this->INHERITED::onDraw(canvas);
+
+ canvas->drawPaint(fPaint[kBG_Attr]);
+
+ int visibleCount = SkMin32(fVisibleRowCount, fSource->countRows() - fScrollIndex);
+ if (visibleCount == 0)
+ return;
+
+ this->ensureStrCache(visibleCount);
+ int currIndex = this->logicalToVisualIndex(fCurrIndex);
+
+ if ((unsigned)currIndex < (unsigned)visibleCount)
+ {
+ SkAutoCanvasRestore restore(canvas, true);
+ SkRect r;
+
+ canvas->translate(0, currIndex * fRowHeight);
+ (void)this->getRowRect(fScrollIndex, &r);
+ canvas->drawRect(r, fPaint[kHiliteCell_Attr]);
+ }
+
+ SkPaint* p;
+ SkScalar y, x = SkIntToScalar(6);
+ SkScalar rite = this->width() - x;
+
+ {
+ SkScalar ascent, descent;
+ fPaint[kNormalText_Attr].measureText(0, NULL, &ascent, &descent);
+ y = SkScalarHalf(fRowHeight - descent + ascent) - ascent;
+ }
+
+ for (int i = 0; i < visibleCount; i++)
+ {
+ if (i == currIndex)
+ p = &fPaint[kHiliteText_Attr];
+ else
+ p = &fPaint[kNormalText_Attr];
+
+ p->setTextAlign(SkPaint::kLeft_Align);
+ canvas->drawText(fStrCache[i].c_str(), fStrCache[i].size(), x, y, *p);
+ p->setTextAlign(SkPaint::kRight_Align);
+ canvas->drawText(fStrCache[i + visibleCount].c_str(), fStrCache[i + visibleCount].size(), rite, y, *p);
+ canvas->translate(0, fRowHeight);
+ }
+}
+
+void SkListView::onSizeChange()
+{
+ SkScalar count = SkScalarDiv(this->height(), fRowHeight);
+ int n = SkScalarFloor(count);
+
+ // only want to show rows that are mostly visible
+ if (n == 0 || count - SkIntToScalar(n) > SK_Scalar1*75/100)
+ n += 1;
+
+ if (fVisibleRowCount != n)
+ {
+ fVisibleRowCount = n;
+ this->ensureSelectionIsVisible();
+ this->dirtyStrCache();
+ }
+}
+
+void SkListView::dirtyStrCache()
+{
+ if (fStrCache)
+ {
+ delete[] fStrCache;
+ fStrCache = NULL;
+ }
+}
+
+void SkListView::ensureStrCache(int count)
+{
+ if (fStrCache == NULL)
+ {
+ fStrCache = new SkString[count << 1];
+
+ if (fSource)
+ for (int i = 0; i < count; i++)
+ fSource->getRow(i + fScrollIndex, &fStrCache[i], &fStrCache[i + count]);
+ }
+}
+
+bool SkListView::onEvent(const SkEvent& evt)
+{
+ if (evt.isType(SK_EventType_Key))
+ {
+ switch (evt.getFast32()) {
+ case kUp_SkKey:
+ this->moveSelectionUp();
+ return true;
+ case kDown_SkKey:
+ this->moveSelectionDown();
+ return true;
+ case kRight_SkKey:
+ case kOK_SkKey:
+ if (fSource && fCurrIndex >= 0)
+ {
+ SkEvent* evt = fSource->getEvent(fCurrIndex);
+ if (evt)
+ {
+ SkView* view = this->sendEventToParents(*evt);
+ delete evt;
+ return view != NULL;
+ }
+ else // hack to make toggle work
+ {
+ this->dirtyStrCache();
+ this->inval(NULL);
+ }
+ }
+ break;
+ }
+ }
+ return this->INHERITED::onEvent(evt);
+}
+
+void SkListView::onInflate(const SkDOM& dom, const SkDOM::Node* node)
+{
+ this->INHERITED::onInflate(dom, node);
+
+ SkScalar x;
+ const SkDOM::Node* child;
+
+ if (dom.findScalar(node, "row-height", &x))
+ this->setRowHeight(x);
+
+ if ((child = dom.getFirstChild(node, "hilite-paint")) != NULL)
+ SkPaint_Inflate(&this->paint(kHiliteCell_Attr), dom, child);
+
+ // look for a listsource
+ {
+ SkListSource* src = NULL;
+
+ if ((child = dom.getFirstChild(node, "file-listsource")) != NULL)
+ {
+ const char* path = dom.findAttr(child, "path");
+ if (path)
+ src = SkListSource::CreateFromDir( path,
+ dom.findAttr(child, "filter"),
+ dom.findAttr(child, "target"));
+ }
+ else if ((child = dom.getFirstChild(node, "xml-listsource")) != NULL)
+ {
+ src = SkListSource::CreateFromDOM(dom, child);
+ }
+
+ if (src)
+ {
+ this->setListSource(src)->unref();
+ this->setSelection(0);
+ }
+ }
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include "SkImageDecoder.h"
+#include "SkShader.h"
+
+class SkScrollBarView : public SkView {
+public:
+ SkScrollBarView(const char bg[], const char fg[])
+ {
+ fBGRef = SkBitmapRef::Decode(bg, true);
+ fFGRef = SkBitmapRef::Decode(fg, true);
+
+ if (fBGRef)
+ this->setWidth(SkIntToScalar(fBGRef->bitmap().width()));
+ }
+ ~SkScrollBarView()
+ {
+ delete fBGRef;
+ delete fFGRef;
+ }
+protected:
+ virtual void onDraw(SkCanvas* canvas)
+ {
+ if (fBGRef == NULL) return;
+
+ SkPaint paint;
+
+ SkShader* shader = SkShader::CreateBitmapShader(fBGRef->bitmap(), false, SkPaint::kNo_FilterType, SkShader::kClamp_TileMode);
+ paint.setShader(shader)->unref();
+
+ canvas->drawPaint(paint);
+ }
+private:
+ SkBitmapRef* fBGRef, *fFGRef;
+};
+
+SkGridView::SkGridView(U32 flags) : SkWidgetView(flags)
+{
+ fSource = NULL;
+ fCurrIndex = -1;
+ fVisibleCount.set(0, 0);
+
+ fPaint[kBG_Attr].setColor(SK_ColorWHITE);
+ fPaint[kHiliteCell_Attr].setColor(SK_ColorYELLOW);
+ fPaint[kHiliteCell_Attr].setStyle(SkPaint::kStroke_Style);
+ fPaint[kHiliteCell_Attr].setAntiAliasOn(true);
+ fPaint[kHiliteCell_Attr].setStrokeWidth(SK_Scalar1*3);
+
+ fScrollBar = new SkScrollBarView("icons/scrollbarGrey.jpg", "icons/scrollbarBlue.jpg");
+ this->attachChildToFront(fScrollBar)->unref();
+ fScrollBar->setVisibleP(true);
+}
+
+SkGridView::~SkGridView()
+{
+ fSource->safeUnref();
+}
+
+void SkGridView::getCellSize(SkPoint* size) const
+{
+ if (size)
+ *size = fCellSize;
+}
+
+void SkGridView::setCellSize(SkScalar x, SkScalar y)
+{
+ SkASSERT(x >= 0 && y >= 0);
+
+ if (!fCellSize.equals(x, y))
+ {
+ fCellSize.set(x, y);
+ this->inval(NULL);
+ }
+}
+
+void SkGridView::setSelection(int index)
+{
+ if (fCurrIndex != index)
+ {
+ this->invalSelection();
+ fCurrIndex = index;
+ this->invalSelection();
+ this->ensureSelectionIsVisible();
+
+ // this generates the click
+ {
+ SkEvent evt;
+ evt.setType("listview-selection");
+ evt.setFast32(index);
+ this->sendEventToParents(evt);
+ }
+ }
+}
+
+void SkGridView::moveSelectionUp()
+{
+ if (fSource)
+ {
+ int index = fCurrIndex;
+ if (index < 0) // no selection
+ index = fSource->countRows() - 1;
+ else
+ index = SkMax32(index - 1, 0);
+ this->setSelection(index);
+ }
+}
+
+void SkGridView::moveSelectionDown()
+{
+ if (fSource)
+ {
+ int index = fCurrIndex;
+ if (index < 0) // no selection
+ index = 0;
+ else
+ index = SkMin32(index + 1, fSource->countRows() - 1);
+ this->setSelection(index);
+ }
+}
+
+void SkGridView::invalSelection()
+{
+ SkRect r;
+ if (this->getCellRect(fCurrIndex, &r))
+ {
+ SkScalar inset = 0;
+ if (fPaint[kHiliteCell_Attr].getStyle() != SkPaint::kFill_Style)
+ inset += fPaint[kHiliteCell_Attr].getStrokeWidth() / 2;
+ if (fPaint[kHiliteCell_Attr].isAntiAliasOn())
+ inset += SK_Scalar1;
+ r.inset(-inset, -inset);
+ this->inval(&r);
+ }
+}
+
+void SkGridView::ensureSelectionIsVisible()
+{
+ if (fSource == NULL)
+ return;
+#if 0
+ if ((unsigned)fCurrIndex < (unsigned)fSource->countRows())
+ {
+ int index = this->logicalToVisualIndex(fCurrIndex);
+
+ if ((unsigned)index >= (unsigned)fVisibleRowCount) // need to scroll
+ {
+ if (index < 0) // too high
+ fScrollIndex = fCurrIndex;
+ else
+ fScrollIndex = fCurrIndex - fVisibleRowCount + 1;
+ SkASSERT((unsigned)fScrollIndex < (unsigned)fSource->countRows());
+
+ this->dirtyStrCache();
+ this->inval(NULL);
+ }
+ }
+#endif
+}
+
+bool SkGridView::getCellRect(int index, SkRect* r) const
+{
+ if (fVisibleCount.fY == 0)
+ return false;
+
+ index = this->logicalToVisualIndex(index);
+ if (index >= 0)
+ {
+ SkRect bounds;
+ int row = index / fVisibleCount.fY;
+ int col = index % fVisibleCount.fY;
+
+ bounds.set(0, 0, fCellSize.fX, fCellSize.fY);
+ bounds.offset(col * (fCellSize.fX + SkIntToScalar(col > 0)),
+ row * (fCellSize.fY + SkIntToScalar(row > 0)));
+
+ if (bounds.fTop < this->height())
+ {
+ if (r)
+ *r = bounds;
+ return true;
+ }
+ }
+ return false;
+}
+
+SkPaint& SkGridView::paint(Attr attr)
+{
+ SkASSERT((unsigned)attr < kAttrCount);
+ return fPaint[attr];
+}
+
+SkListSource* SkGridView::setListSource(SkListSource* src)
+{
+ if (fSource != src)
+ {
+ SkRefCnt_SafeAssign(fSource, src);
+ // this->dirtyStrCache();
+ this->ensureSelectionIsVisible();
+ this->inval(NULL);
+ }
+ return src;
+}
+
+#include "SkShader.h"
+
+static void copybits(SkCanvas* canvas, const SkBitmap& bm, const SkRect& dst, const SkPaint& paint)
+{
+ SkRect src;
+ SkMatrix matrix;
+
+ src.set(0, 0, SkIntToScalar(bm.width()), SkIntToScalar(bm.height()));
+ if (matrix.setRectToRect(src, dst))
+ {
+ SkPaint p(paint);
+ SkShader* shader = SkShader::CreateBitmapShader(bm, false, SkPaint::kNo_FilterType, SkShader::kClamp_TileMode);
+ p.setShader(shader)->unref();
+
+ shader->setLocalMatrix(matrix);
+ canvas->drawRect(dst, p);
+ }
+}
+
+#include "SkImageDecoder.h"
+
+void SkGridView::onDraw(SkCanvas* canvas)
+{
+ this->INHERITED::onDraw(canvas);
+
+ canvas->drawPaint(fPaint[kBG_Attr]);
+
+ if (fSource == NULL)
+ return;
+
+#if 0
+ int visibleCount = SkMin32(fVisibleRowCount, fSource->countRows() - fScrollIndex);
+ if (visibleCount == 0)
+ return;
+
+ this->ensureStrCache(visibleCount);
+ int currIndex = this->logicalToVisualIndex(fCurrIndex);
+#endif
+
+ SkPaint p;
+ for (int i = 0; i < fSource->countRows(); i++)
+ {
+ bool forced = false;
+ SkEvent* evt = fSource->getEvent(i);
+ SkASSERT(evt);
+ SkString path(evt->findString("path"));
+ delete evt;
+
+ SkBitmapRef* bmr = SkBitmapRef::Decode(path.c_str(), false);
+ if (bmr == NULL)
+ {
+ bmr = SkBitmapRef::Decode(path.c_str(), true);
+ if (bmr)
+ forced = true;
+ }
+
+ if (bmr)
+ {
+ SkAutoTDelete<SkBitmapRef> autoRef(bmr);
+ SkRect r;
+ if (!this->getCellRect(i, &r))
+ break;
+ copybits(canvas, bmr->bitmap(), r, p);
+ }
+ // only draw one forced bitmap at a time
+ if (forced)
+ {
+ this->inval(NULL); // could inval only the remaining visible cells...
+ break;
+ }
+ }
+
+ // draw the hilite
+ {
+ SkRect r;
+ if (fCurrIndex >= 0 && this->getCellRect(fCurrIndex, &r))
+ canvas->drawRect(r, fPaint[kHiliteCell_Attr]);
+ }
+}
+
+static int check_count(int n, SkScalar s)
+{
+ // only want to show cells that are mostly visible
+ if (n == 0 || s - SkIntToScalar(n) > SK_Scalar1*75/100)
+ n += 1;
+ return n;
+}
+
+void SkGridView::onSizeChange()
+{
+ fScrollBar->setHeight(this->height());
+ fScrollBar->setLoc(this->locX() + this->width() - fScrollBar->width(), 0);
+
+ if (fCellSize.equals(0, 0))
+ {
+ fVisibleCount.set(0, 0);
+ return;
+ }
+
+ SkScalar rows = SkScalarDiv(this->height(), fCellSize.fY);
+ SkScalar cols = SkScalarDiv(this->width(), fCellSize.fX);
+ int y = SkScalarFloor(rows);
+ int x = SkScalarFloor(cols);
+
+ y = check_count(y, rows);
+ x = check_count(x, cols);
+
+ if (!fVisibleCount.equals(x, y))
+ {
+ fVisibleCount.set(x, y);
+ this->ensureSelectionIsVisible();
+ // this->dirtyStrCache();
+ }
+}
+
+bool SkGridView::onEvent(const SkEvent& evt)
+{
+ if (evt.isType(SK_EventType_Key))
+ {
+ switch (evt.getFast32()) {
+ case kUp_SkKey:
+ this->moveSelectionUp();
+ return true;
+ case kDown_SkKey:
+ this->moveSelectionDown();
+ return true;
+ case kRight_SkKey:
+ case kOK_SkKey:
+ if (fSource && fCurrIndex >= 0)
+ {
+ SkEvent* evt = fSource->getEvent(fCurrIndex);
+ if (evt)
+ {
+ // augment the event with our local rect
+ (void)this->getCellRect(fCurrIndex, (SkRect*)evt->setScalars("local-rect", 4, NULL));
+
+ SkView* view = this->sendEventToParents(*evt);
+ delete evt;
+ return view != NULL;
+ }
+ }
+ break;
+ }
+ }
+ return this->INHERITED::onEvent(evt);
+}
+
+void SkGridView::onInflate(const SkDOM& dom, const SkDOM::Node* node)
+{
+ this->INHERITED::onInflate(dom, node);
+
+ SkScalar x[2];
+ const SkDOM::Node* child;
+
+ if (dom.findScalars(node, "cell-size", x, 2))
+ this->setCellSize(x[0], x[1]);
+
+ if ((child = dom.getFirstChild(node, "hilite-paint")) != NULL)
+ SkPaint_Inflate(&this->paint(kHiliteCell_Attr), dom, child);
+
+ // look for a listsource
+ {
+ SkListSource* src = NULL;
+
+ if ((child = dom.getFirstChild(node, "file-listsource")) != NULL)
+ {
+ const char* path = dom.findAttr(child, "path");
+ if (path)
+ src = SkListSource::CreateFromDir( path,
+ dom.findAttr(child, "filter"),
+ dom.findAttr(child, "target"));
+ }
+ else if ((child = dom.getFirstChild(node, "xml-listsource")) != NULL)
+ {
+ src = SkListSource::CreateFromDOM(dom, child);
+ }
+
+ if (src)
+ {
+ this->setListSource(src)->unref();
+ this->setSelection(0);
+ }
+ }
+ this->onSizeChange();
+}
+
+#endif
diff --git a/src/views/SkListWidget.cpp b/src/views/SkListWidget.cpp
new file mode 100644
index 0000000..89008e7
--- /dev/null
+++ b/src/views/SkListWidget.cpp
@@ -0,0 +1,623 @@
+#include "SkWidgetViews.h"
+
+#include "SkAnimator.h"
+#include "SkScrollBarView.h"
+
+extern void init_skin_anim(const char name[], SkAnimator*);
+
+struct SkListView::BindingRec {
+ SkString fSlotName;
+ int fFieldIndex;
+};
+
+SkListView::SkListView()
+{
+ fSource = NULL; // our list-source
+ fScrollBar = NULL;
+ fAnims = NULL; // array of animators[fVisibleRowCount]
+ fBindings = NULL; // our fields->slot array
+ fBindingCount = 0; // number of entries in fSlots array
+ fScrollIndex = 0; // number of cells to skip before first visible cell
+ fCurrIndex = -1; // index of "selected" cell
+ fVisibleRowCount = 0; // number of cells that can fit in our bounds
+ fAnimContentDirty = true; // true if fAnims[] have their correct content
+ fAnimFocusDirty = true;
+
+ fHeights[kNormal_Height] = SkIntToScalar(16);
+ fHeights[kSelected_Height] = SkIntToScalar(16);
+
+ this->setFlags(this->getFlags() | kFocusable_Mask);
+}
+
+SkListView::~SkListView()
+{
+ SkSafeUnref(fScrollBar);
+ SkSafeUnref(fSource);
+ delete[] fAnims;
+ delete[] fBindings;
+}
+
+void SkListView::setHasScrollBar(bool hasSB)
+{
+ if (hasSB != this->hasScrollBar())
+ {
+ if (hasSB)
+ {
+ SkASSERT(fScrollBar == NULL);
+ fScrollBar = (SkScrollBarView*)SkWidgetFactory(kScroll_WidgetEnum);
+ fScrollBar->setVisibleP(true);
+ this->attachChildToFront(fScrollBar);
+ fScrollBar->setHeight(this->height()); // assume it auto-sets its width
+ // fScrollBar->setLoc(this->getContentWidth(), 0);
+ fScrollBar->setLoc(this->width()-SkIntToScalar(10), 0);
+ }
+ else
+ {
+ SkASSERT(fScrollBar);
+ fScrollBar->detachFromParent();
+ fScrollBar->unref();
+ fScrollBar = NULL;
+ }
+ this->dirtyCache(kAnimContent_DirtyFlag);
+ }
+}
+
+void SkListView::setSelection(int index)
+{
+ if (fCurrIndex != index)
+ {
+ fAnimFocusDirty = true;
+ this->inval(NULL);
+
+ this->invalSelection();
+ fCurrIndex = index;
+ this->invalSelection();
+ this->ensureSelectionIsVisible();
+ }
+}
+
+bool SkListView::moveSelectionUp()
+{
+ if (fSource)
+ {
+ int index = fCurrIndex;
+ if (index < 0) // no selection
+ index = fSource->countRecords() - 1;
+ else
+ index = SkMax32(index - 1, 0);
+
+ if (fCurrIndex != index)
+ {
+ this->setSelection(index);
+ return true;
+ }
+ }
+ return false;
+}
+
+bool SkListView::moveSelectionDown()
+{
+ if (fSource)
+ {
+ int index = fCurrIndex;
+ if (index < 0) // no selection
+ index = 0;
+ else
+ index = SkMin32(index + 1, fSource->countRecords() - 1);
+
+ if (fCurrIndex != index)
+ {
+ this->setSelection(index);
+ return true;
+ }
+ }
+ return false;
+}
+
+void SkListView::invalSelection()
+{
+ SkRect r;
+ if (this->getRowRect(fCurrIndex, &r))
+ this->inval(&r);
+}
+
+void SkListView::ensureSelectionIsVisible()
+{
+ if (fSource && (unsigned)fCurrIndex < (unsigned)fSource->countRecords())
+ {
+ int index = this->logicalToVisualIndex(fCurrIndex);
+
+ if ((unsigned)index >= (unsigned)fVisibleRowCount) // need to scroll
+ {
+ int newIndex;
+
+ if (index < 0) // too high
+ newIndex = fCurrIndex;
+ else
+ newIndex = fCurrIndex - fVisibleRowCount + 1;
+ SkASSERT((unsigned)newIndex < (unsigned)fSource->countRecords());
+ this->inval(NULL);
+
+ if (fScrollIndex != newIndex)
+ {
+ fScrollIndex = newIndex;
+ if (fScrollBar)
+ fScrollBar->setStart(newIndex);
+ this->dirtyCache(kAnimContent_DirtyFlag);
+ }
+ }
+ }
+}
+
+SkScalar SkListView::getContentWidth() const
+{
+ SkScalar width = this->width();
+
+ if (fScrollBar)
+ {
+ width -= fScrollBar->width();
+ if (width < 0)
+ width = 0;
+ }
+ return width;
+}
+
+bool SkListView::getRowRect(int index, SkRect* r) const
+{
+ SkASSERT(r);
+
+ index = this->logicalToVisualIndex(index);
+ if (index >= 0)
+ {
+ int selection = this->logicalToVisualIndex(fCurrIndex);
+
+ SkScalar height = fHeights[index == selection ? kSelected_Height : kNormal_Height];
+ SkScalar top = index * fHeights[kNormal_Height];
+
+ if (index > selection && selection >= 0)
+ top += fHeights[kSelected_Height] - fHeights[kNormal_Height];
+
+ if (top < this->height())
+ {
+ if (r)
+ r->set(0, top, this->getContentWidth(), top + height);
+ return true;
+ }
+ }
+ return false;
+}
+
+SkListSource* SkListView::setListSource(SkListSource* src)
+{
+ if (fSource != src)
+ {
+ SkRefCnt_SafeAssign(fSource, src);
+ this->ensureSelectionIsVisible();
+ this->inval(NULL);
+
+ if (fScrollBar)
+ fScrollBar->setTotal(fSource->countRecords());
+ }
+ return src;
+}
+
+void SkListView::dirtyCache(unsigned dirtyFlags)
+{
+ if (dirtyFlags & kAnimCount_DirtyFlag)
+ {
+ delete fAnims;
+ fAnims = NULL;
+ fAnimContentDirty = true;
+ fAnimFocusDirty = true;
+ }
+ if (dirtyFlags & kAnimContent_DirtyFlag)
+ {
+ if (!fAnimContentDirty)
+ {
+ this->inval(NULL);
+ fAnimContentDirty = true;
+ }
+ fAnimFocusDirty = true;
+ }
+}
+
+bool SkListView::ensureCache()
+{
+ if (fSkinName.size() == 0)
+ return false;
+
+ if (fAnims == NULL)
+ {
+ int n = SkMax32(1, fVisibleRowCount);
+
+ SkASSERT(fAnimContentDirty);
+ fAnims = new SkAnimator[n];
+ for (int i = 0; i < n; i++)
+ {
+ fAnims[i].setHostEventSink(this);
+ init_skin_anim(fSkinName.c_str(), &fAnims[i]);
+ }
+
+ fHeights[kNormal_Height] = fAnims[0].getScalar("idleHeight", "value");
+ fHeights[kSelected_Height] = fAnims[0].getScalar("focusedHeight", "value");
+
+ fAnimFocusDirty = true;
+ }
+
+ if (fAnimContentDirty && fSource)
+ {
+ fAnimContentDirty = false;
+
+ SkString str;
+ SkEvent evt("user");
+ evt.setString("id", "setFields");
+ evt.setS32("rowCount", fVisibleRowCount);
+
+ SkEvent dimEvt("user");
+ dimEvt.setString("id", "setDim");
+ dimEvt.setScalar("dimX", this->getContentWidth());
+ dimEvt.setScalar("dimY", this->height());
+
+ for (int i = fScrollIndex; i < fScrollIndex + fVisibleRowCount; i++)
+ {
+ evt.setS32("relativeIndex", i - fScrollIndex);
+ for (int j = 0; j < fBindingCount; j++)
+ {
+ fSource->getRecord(i, fBindings[j].fFieldIndex, &str);
+//SkDEBUGF(("getRecord(%d,%d,%s) slot(%s)\n", i, fBindings[j].fFieldIndex, str.c_str(), fBindings[j].fSlotName.c_str()));
+ evt.setString(fBindings[j].fSlotName.c_str(), str.c_str());
+ }
+ (void)fAnims[i % fVisibleRowCount].doUserEvent(evt);
+ (void)fAnims[i % fVisibleRowCount].doUserEvent(dimEvt);
+ }
+ fAnimFocusDirty = true;
+ }
+
+ if (fAnimFocusDirty)
+ {
+//SkDEBUGF(("service fAnimFocusDirty\n"));
+ fAnimFocusDirty = false;
+
+ SkEvent focusEvt("user");
+ focusEvt.setString("id", "setFocus");
+
+ for (int i = fScrollIndex; i < fScrollIndex + fVisibleRowCount; i++)
+ {
+ focusEvt.setS32("FOCUS", i == fCurrIndex);
+ (void)fAnims[i % fVisibleRowCount].doUserEvent(focusEvt);
+ }
+ }
+
+ return true;
+}
+
+void SkListView::ensureVisibleRowCount()
+{
+ SkScalar height = this->height();
+ int n = 0;
+
+ if (height > 0)
+ {
+ n = 1;
+ height -= fHeights[kSelected_Height];
+ if (height > 0)
+ {
+ SkScalar count = SkScalarDiv(height, fHeights[kNormal_Height]);
+ n += SkScalarFloor(count);
+ if (count - SkIntToScalar(n) > SK_Scalar1*3/4)
+ n += 1;
+
+ // SkDebugf("count %g, n %d\n", count/65536., n);
+ }
+ }
+
+ if (fVisibleRowCount != n)
+ {
+ if (fScrollBar)
+ fScrollBar->setShown(n);
+
+ fVisibleRowCount = n;
+ this->ensureSelectionIsVisible();
+ this->dirtyCache(kAnimCount_DirtyFlag | kAnimContent_DirtyFlag);
+ }
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////
+
+#include "SkSystemEventTypes.h"
+#include "SkTime.h"
+
+void SkListView::onSizeChange()
+{
+ this->INHERITED::onSizeChange();
+
+ if (fScrollBar)
+ fScrollBar->setLoc(this->width()-SkIntToScalar(10), 0);
+
+ this->ensureVisibleRowCount();
+}
+
+void SkListView::onDraw(SkCanvas* canvas)
+{
+ this->INHERITED::onDraw(canvas);
+
+ this->ensureVisibleRowCount();
+
+ int visibleCount = SkMin32(fVisibleRowCount, fSource->countRecords() - fScrollIndex);
+ if (visibleCount == 0 || !this->ensureCache())
+ return;
+
+//SkDebugf("visibleCount %d scrollIndex %d currIndex %d\n", visibleCount, fScrollIndex, fCurrIndex);
+
+ SkAutoCanvasRestore ar(canvas, true);
+ SkMSec now = SkTime::GetMSecs();
+ SkRect bounds;
+
+ bounds.fLeft = 0;
+ bounds.fRight = this->getContentWidth();
+ bounds.fBottom = 0;
+ // assign bounds.fTop inside the loop
+
+ // hack to reveal our bounds for debugging
+ if (this->hasFocus())
+ canvas->drawARGB(0x11, 0, 0, 0xFF);
+ else
+ canvas->drawARGB(0x11, 0x88, 0x88, 0x88);
+
+ for (int i = fScrollIndex; i < fScrollIndex + visibleCount; i++)
+ {
+ SkPaint paint;
+ SkScalar height = fHeights[i == fCurrIndex ? kSelected_Height : kNormal_Height];
+
+ bounds.fTop = bounds.fBottom;
+ bounds.fBottom += height;
+
+ canvas->save();
+ if (fAnims[i % fVisibleRowCount].draw(canvas, &paint, now) != SkAnimator::kNotDifferent)
+ this->inval(&bounds);
+ canvas->restore();
+
+ canvas->translate(0, height);
+ }
+}
+
+bool SkListView::onEvent(const SkEvent& evt)
+{
+ if (evt.isType(SK_EventType_Key))
+ {
+ switch (evt.getFast32()) {
+ case kUp_SkKey:
+ return this->moveSelectionUp();
+ case kDown_SkKey:
+ return this->moveSelectionDown();
+ case kRight_SkKey:
+ case kOK_SkKey:
+ this->postWidgetEvent();
+ return true;
+ default:
+ break;
+ }
+ }
+ return this->INHERITED::onEvent(evt);
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////
+
+static const char gListViewEventSlot[] = "sk-listview-slot-name";
+
+/*virtual*/ bool SkListView::onPrepareWidgetEvent(SkEvent* evt)
+{
+ if (fSource && fCurrIndex >= 0 && this->INHERITED::onPrepareWidgetEvent(evt) &&
+ fSource->prepareWidgetEvent(evt, fCurrIndex))
+ {
+ evt->setS32(gListViewEventSlot, fCurrIndex);
+ return true;
+ }
+ return false;
+}
+
+int SkListView::GetWidgetEventListIndex(const SkEvent& evt)
+{
+ int32_t index;
+
+ return evt.findS32(gListViewEventSlot, &index) ? index : -1;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////
+
+void SkListView::onInflate(const SkDOM& dom, const SkDOM::Node* node)
+{
+ this->INHERITED::onInflate(dom, node);
+
+ {
+ bool hasScrollBar;
+ if (dom.findBool(node, "scrollBar", &hasScrollBar))
+ this->setHasScrollBar(hasScrollBar);
+ }
+
+ const SkDOM::Node* child;
+
+ if ((child = dom.getFirstChild(node, "bindings")) != NULL)
+ {
+ delete[] fBindings;
+ fBindings = NULL;
+ fBindingCount = 0;
+
+ SkListSource* listSrc = SkListSource::Factory(dom.findAttr(child, "data-fields"));
+ SkASSERT(listSrc);
+ fSkinName.set(dom.findAttr(child, "skin-slots"));
+ SkASSERT(fSkinName.size());
+
+ this->setListSource(listSrc)->unref();
+
+ int count = dom.countChildren(child, "bind");
+ if (count > 0)
+ {
+ fBindings = new BindingRec[count];
+ count = 0; // reuse this to count up to the number of valid bindings
+
+ child = dom.getFirstChild(child, "bind");
+ SkASSERT(child);
+ do {
+ const char* fieldName = dom.findAttr(child, "field");
+ const char* slotName = dom.findAttr(child, "slot");
+ if (fieldName && slotName)
+ {
+ fBindings[count].fFieldIndex = listSrc->findFieldIndex(fieldName);
+ if (fBindings[count].fFieldIndex >= 0)
+ fBindings[count++].fSlotName.set(slotName);
+ }
+ } while ((child = dom.getNextSibling(child, "bind")) != NULL);
+
+ fBindingCount = SkToU16(count);
+ if (count == 0)
+ {
+ SkDEBUGF(("SkListView::onInflate: no valid <bind> elements in <listsource>\n"));
+ delete[] fBindings;
+ }
+ }
+ this->dirtyCache(kAnimCount_DirtyFlag);
+ this->setSelection(0);
+ }
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////////////////////
+
+class SkXMLListSource : public SkListSource {
+public:
+ SkXMLListSource(const char doc[], size_t len);
+ virtual ~SkXMLListSource()
+ {
+ delete[] fFields;
+ delete[] fRecords;
+ }
+
+ virtual int countFields() { return fFieldCount; }
+ virtual void getFieldName(int index, SkString* field)
+ {
+ SkASSERT((unsigned)index < (unsigned)fFieldCount);
+ if (field)
+ *field = fFields[index];
+ }
+ virtual int findFieldIndex(const char field[])
+ {
+ for (int i = 0; i < fFieldCount; i++)
+ if (fFields[i].equals(field))
+ return i;
+ return -1;
+ }
+
+ virtual int countRecords() { return fRecordCount; }
+ virtual void getRecord(int rowIndex, int fieldIndex, SkString* data)
+ {
+ SkASSERT((unsigned)rowIndex < (unsigned)fRecordCount);
+ SkASSERT((unsigned)fieldIndex < (unsigned)fFieldCount);
+ if (data)
+ *data = fRecords[rowIndex * fFieldCount + fieldIndex];
+ }
+
+ virtual bool prepareWidgetEvent(SkEvent* evt, int rowIndex)
+ {
+ // hack, for testing right now. Need the xml to tell us what to jam in and where
+ SkString data;
+
+ this->getRecord(rowIndex, 0, &data);
+ evt->setString("xml-listsource", data.c_str());
+ return true;
+ }
+
+private:
+ SkString* fFields; // [fFieldCount]
+ SkString* fRecords; // [fRecordCount][fFieldCount]
+ int fFieldCount, fRecordCount;
+};
+
+#include "SkDOM.h"
+
+SkXMLListSource::SkXMLListSource(const char doc[], size_t len)
+{
+ fFieldCount = fRecordCount = 0;
+ fFields = fRecords = NULL;
+
+ SkDOM dom;
+
+ const SkDOM::Node* node = dom.build(doc, len);
+ SkASSERT(node);
+ const SkDOM::Node* child;
+
+ child = dom.getFirstChild(node, "fields");
+ if (child)
+ {
+ fFieldCount = dom.countChildren(child, "field");
+ fFields = new SkString[fFieldCount];
+
+ int n = 0;
+ child = dom.getFirstChild(child, "field");
+ while (child)
+ {
+ fFields[n].set(dom.findAttr(child, "name"));
+ child = dom.getNextSibling(child, "field");
+ n += 1;
+ }
+ SkASSERT(n == fFieldCount);
+ }
+
+ child = dom.getFirstChild(node, "records");
+ if (child)
+ {
+ fRecordCount = dom.countChildren(child, "record");
+ fRecords = new SkString[fRecordCount * fFieldCount];
+
+ int n = 0;
+ child = dom.getFirstChild(child, "record");
+ while (child)
+ {
+ for (int i = 0; i < fFieldCount; i++)
+ fRecords[n * fFieldCount + i].set(dom.findAttr(child, fFields[i].c_str()));
+ child = dom.getNextSibling(child, "record");
+ n += 1;
+ }
+ SkASSERT(n == fRecordCount);
+ }
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+
+SkListSource* SkListSource::Factory(const char name[])
+{
+ static const char gDoc[] =
+ "<db name='contacts.db'>"
+ "<fields>"
+ "<field name='name'/>"
+ "<field name='work-num'/>"
+ "<field name='home-num'/>"
+ "<field name='type'/>"
+ "</fields>"
+ "<records>"
+ "<record name='Andy McFadden' work-num='919 357-1234' home-num='919 123-4567' type='0'/>"
+ "<record name='Brian Swetland' work-num='919 123-1234' home-num='929 123-4567' type='1' />"
+ "<record name='Chris Desalvo' work-num='919 345-1234' home-num='949 123-4567' type='1' />"
+ "<record name='Chris White' work-num='919 234-1234' home-num='939 123-4567' type='2' />"
+ "<record name='Dan Bornstein' work-num='919 357-1234' home-num='919 123-4567' type='0' />"
+ "<record name='Don Cung' work-num='919 123-1234' home-num='929 123-4567' type='2' />"
+ "<record name='Eric Fischer' work-num='919 345-1234' home-num='949 123-4567' type='2' />"
+ "<record name='Ficus Kirkpatric' work-num='919 234-1234' home-num='939 123-4567' type='1' />"
+ "<record name='Jack Veenstra' work-num='919 234-1234' home-num='939 123-4567' type='2' />"
+ "<record name='Jeff Yaksick' work-num='919 234-1234' home-num='939 123-4567' type='0' />"
+ "<record name='Joe Onorato' work-num='919 234-1234' home-num='939 123-4567' type='0' />"
+ "<record name='Mathias Agopian' work-num='919 234-1234' home-num='939 123-4567' type='1' />"
+ "<record name='Mike Fleming' work-num='919 234-1234' home-num='939 123-4567' type='2' />"
+ "<record name='Nick Sears' work-num='919 234-1234' home-num='939 123-4567' type='1' />"
+ "<record name='Rich Miner' work-num='919 234-1234' home-num='939 123-4567' type='1' />"
+ "<record name='Tracey Cole' work-num='919 234-1234' home-num='939 123-4567' type='0' />"
+ "<record name='Wei Huang' work-num='919 234-1234' home-num='939 123-4567' type='0' />"
+ "</records>"
+ "</db>";
+
+//SkDebugf("doc size %d\n", sizeof(gDoc)-1);
+ return new SkXMLListSource(gDoc, sizeof(gDoc) - 1);
+}
+
+
+
diff --git a/src/views/SkOSMenu.cpp b/src/views/SkOSMenu.cpp
new file mode 100644
index 0000000..3760ddd
--- /dev/null
+++ b/src/views/SkOSMenu.cpp
@@ -0,0 +1,53 @@
+#include "SkOSMenu.h"
+
+static int gOSMenuCmd = 7000;
+
+SkOSMenu::SkOSMenu(const char title[])
+{
+ fTitle = title;
+}
+
+SkOSMenu::~SkOSMenu()
+{
+}
+
+int SkOSMenu::countItems() const
+{
+ return fItems.count();
+}
+
+void SkOSMenu::appendItem(const char title[], const char eventType[], int32_t eventData)
+{
+ Item* item = fItems.append();
+
+ item->fTitle = title;
+ item->fEventType = eventType;
+ item->fEventData = eventData;
+ item->fOSCmd = ++gOSMenuCmd;
+}
+
+SkEvent* SkOSMenu::createEvent(uint32_t os_cmd)
+{
+ const Item* iter = fItems.begin();
+ const Item* stop = fItems.end();
+
+ while (iter < stop)
+ {
+ if (iter->fOSCmd == os_cmd)
+ {
+ SkEvent* evt = new SkEvent(iter->fEventType);
+ evt->setFast32(iter->fEventData);
+ return evt;
+ }
+ iter++;
+ }
+ return NULL;
+}
+
+const char* SkOSMenu::getItem(int index, uint32_t* cmdID) const
+{
+ if (cmdID)
+ *cmdID = fItems[index].fOSCmd;
+ return fItems[index].fTitle;
+}
+
diff --git a/src/views/SkParsePaint.cpp b/src/views/SkParsePaint.cpp
new file mode 100644
index 0000000..a79f30c
--- /dev/null
+++ b/src/views/SkParsePaint.cpp
@@ -0,0 +1,103 @@
+#include "SkParsePaint.h"
+#include "SkTSearch.h"
+#include "SkParse.h"
+#include "SkImageDecoder.h"
+#include "SkGradientShader.h"
+
+static SkShader* inflate_shader(const SkDOM& dom, const SkDOM::Node* node)
+{
+ if ((node = dom.getFirstChild(node, "shader")) == NULL)
+ return NULL;
+
+ const char* str;
+
+ if (dom.hasAttr(node, "type", "linear-gradient"))
+ {
+ SkColor colors[2];
+ SkPoint pts[2];
+
+ colors[0] = colors[1] = SK_ColorBLACK; // need to initialized the alpha to opaque, since FindColor doesn't set it
+ if ((str = dom.findAttr(node, "c0")) != NULL &&
+ SkParse::FindColor(str, &colors[0]) &&
+ (str = dom.findAttr(node, "c1")) != NULL &&
+ SkParse::FindColor(str, &colors[1]) &&
+ dom.findScalars(node, "p0", &pts[0].fX, 2) &&
+ dom.findScalars(node, "p1", &pts[1].fX, 2))
+ {
+ SkShader::TileMode mode = SkShader::kClamp_TileMode;
+ int index;
+
+ if ((index = dom.findList(node, "tile-mode", "clamp,repeat,mirror")) >= 0)
+ mode = (SkShader::TileMode)index;
+ return SkGradientShader::CreateLinear(pts, colors, NULL, 2, mode);
+ }
+ }
+ else if (dom.hasAttr(node, "type", "bitmap"))
+ {
+ if ((str = dom.findAttr(node, "src")) == NULL)
+ return NULL;
+
+ SkBitmap bm;
+
+ if (SkImageDecoder::DecodeFile(str, &bm))
+ {
+ SkShader::TileMode mode = SkShader::kRepeat_TileMode;
+ int index;
+
+ if ((index = dom.findList(node, "tile-mode", "clamp,repeat,mirror")) >= 0)
+ mode = (SkShader::TileMode)index;
+
+ return SkShader::CreateBitmapShader(bm, mode, mode);
+ }
+ }
+ return NULL;
+}
+
+void SkPaint_Inflate(SkPaint* paint, const SkDOM& dom, const SkDOM::Node* node)
+{
+ SkASSERT(paint);
+ SkASSERT(&dom);
+ SkASSERT(node);
+
+ SkScalar x;
+
+ if (dom.findScalar(node, "stroke-width", &x))
+ paint->setStrokeWidth(x);
+ if (dom.findScalar(node, "text-size", &x))
+ paint->setTextSize(x);
+
+ bool b;
+
+ SkASSERT("legacy: use is-stroke" && !dom.findBool(node, "is-frame", &b));
+
+ if (dom.findBool(node, "is-stroke", &b))
+ paint->setStyle(b ? SkPaint::kStroke_Style : SkPaint::kFill_Style);
+ if (dom.findBool(node, "is-antialias", &b))
+ paint->setAntiAlias(b);
+ if (dom.findBool(node, "is-lineartext", &b))
+ paint->setLinearText(b);
+
+ const char* str = dom.findAttr(node, "color");
+ if (str)
+ {
+ SkColor c = paint->getColor();
+ if (SkParse::FindColor(str, &c))
+ paint->setColor(c);
+ }
+
+ // do this AFTER parsing for the color
+ if (dom.findScalar(node, "opacity", &x))
+ {
+ x = SkMaxScalar(0, SkMinScalar(x, SK_Scalar1));
+ paint->setAlpha(SkScalarRound(x * 255));
+ }
+
+ int index = dom.findList(node, "text-anchor", "left,center,right");
+ if (index >= 0)
+ paint->setTextAlign((SkPaint::Align)index);
+
+ SkShader* shader = inflate_shader(dom, node);
+ if (shader)
+ paint->setShader(shader)->unref();
+}
+
diff --git a/src/views/SkProgressBarView.cpp b/src/views/SkProgressBarView.cpp
new file mode 100644
index 0000000..a9fd516
--- /dev/null
+++ b/src/views/SkProgressBarView.cpp
@@ -0,0 +1,102 @@
+#include "SkProgressBarView.h"
+#include "SkAnimator.h"
+#include "SkWidgetViews.h"
+#include "SkTime.h"
+#include "SkSystemEventTypes.h"
+
+SkProgressBarView::SkProgressBarView()
+{
+ init_skin_anim(kProgress_SkinEnum, &fAnim);
+ fAnim.setHostEventSink(this);
+ fProgress = 0;
+ fMax = 100;
+
+}
+
+void SkProgressBarView::changeProgress(int diff)
+{
+ int newProg = fProgress + diff;
+ if (newProg > 0 && newProg < fMax)
+ this->setProgress(newProg);
+ //otherwise i'll just leave it as it is
+ //this implies that if a new max and progress are set, max must be set first
+}
+
+/*virtual*/ void SkProgressBarView::onDraw(SkCanvas* canvas)
+{
+ SkPaint paint;
+ SkAnimator::DifferenceType diff = fAnim.draw(canvas, &paint, SkTime::GetMSecs());
+
+ if (diff == SkAnimator::kDifferent)
+ this->inval(NULL);
+ else if (diff == SkAnimator::kPartiallyDifferent)
+ {
+ SkRect bounds;
+ fAnim.getInvalBounds(&bounds);
+ this->inval(&bounds);
+ }
+}
+
+/*virtual*/ bool SkProgressBarView::onEvent(const SkEvent& evt)
+{
+ if (evt.isType(SK_EventType_Inval))
+ {
+ this->inval(NULL);
+ return true;
+ }
+ if (evt.isType("recommendDim"))
+ {
+ SkScalar height;
+
+ if (evt.findScalar("y", &height))
+ this->setHeight(height);
+ return true;
+ }
+ return this->INHERITED::onEvent(evt);
+}
+
+/*virtual*/ void SkProgressBarView::onInflate(const SkDOM& dom, const SkDOM::Node* node)
+{
+ this->INHERITED::onInflate(dom, node);
+ int32_t temp;
+ if (dom.findS32(node, "max", &temp))
+ this->setMax(temp);
+ if (dom.findS32(node, "progress", &temp))
+ this->setProgress(temp);
+}
+
+/*virtual*/ void SkProgressBarView::onSizeChange()
+{
+ this->INHERITED::onSizeChange();
+ SkEvent evt("user");
+ evt.setString("id", "setDim");
+ evt.setScalar("dimX", this->width());
+ evt.setScalar("dimY", this->height());
+ fAnim.doUserEvent(evt);
+}
+
+void SkProgressBarView::reset()
+{
+ fProgress = 0;
+ SkEvent e("user");
+ e.setString("id", "reset");
+ fAnim.doUserEvent(e);
+}
+
+void SkProgressBarView::setMax(int max)
+{
+ fMax = max;
+ SkEvent e("user");
+ e.setString("id", "setMax");
+ e.setS32("newMax", max);
+ fAnim.doUserEvent(e);
+}
+
+void SkProgressBarView::setProgress(int progress)
+{
+ fProgress = progress;
+ SkEvent e("user");
+ e.setString("id", "setProgress");
+ e.setS32("newProgress", progress);
+ fAnim.doUserEvent(e);
+}
diff --git a/src/views/SkProgressView.cpp b/src/views/SkProgressView.cpp
new file mode 100644
index 0000000..0c81bcc
--- /dev/null
+++ b/src/views/SkProgressView.cpp
@@ -0,0 +1,125 @@
+#include "SkWidget.h"
+#include "SkCanvas.h"
+#include "SkShader.h"
+#include "SkInterpolator.h"
+#include "SkTime.h"
+
+SkProgressView::SkProgressView(uint32_t flags) : SkView(flags), fOnShader(NULL), fOffShader(NULL)
+{
+ fValue = 0;
+ fMax = 0;
+ fInterp = NULL;
+ fDoInterp = false;
+}
+
+SkProgressView::~SkProgressView()
+{
+ delete fInterp;
+ SkSafeUnref(fOnShader);
+ SkSafeUnref(fOffShader);
+}
+
+void SkProgressView::setMax(U16CPU max)
+{
+ if (fMax != max)
+ {
+ fMax = SkToU16(max);
+ if (fValue > 0)
+ this->inval(NULL);
+ }
+}
+
+void SkProgressView::setValue(U16CPU value)
+{
+ if (fValue != value)
+ {
+ if (fDoInterp)
+ {
+ if (fInterp)
+ delete fInterp;
+ fInterp = new SkInterpolator(1, 2);
+ SkScalar x = (SkScalar)(fValue << 8);
+ fInterp->setKeyFrame(0, SkTime::GetMSecs(), &x, 0);
+ x = (SkScalar)(value << 8);
+ fInterp->setKeyFrame(1, SkTime::GetMSecs() + 333, &x);
+ }
+ fValue = SkToU16(value);
+ this->inval(NULL);
+ }
+}
+
+void SkProgressView::onDraw(SkCanvas* canvas)
+{
+ if (fMax == 0)
+ return;
+
+ SkFixed percent;
+
+ if (fInterp)
+ {
+ SkScalar x;
+ if (fInterp->timeToValues(SkTime::GetMSecs(), &x) == SkInterpolator::kFreezeEnd_Result)
+ {
+ delete fInterp;
+ fInterp = NULL;
+ }
+ percent = (SkFixed)x; // now its 16.8
+ percent = SkMax32(0, SkMin32(percent, fMax << 8)); // now its pinned
+ percent = SkFixedDiv(percent, fMax << 8); // now its 0.16
+ this->inval(NULL);
+ }
+ else
+ {
+ U16CPU value = SkMax32(0, SkMin32(fValue, fMax));
+ percent = SkFixedDiv(value, fMax);
+ }
+
+
+ SkRect r;
+ SkPaint p;
+
+ r.set(0, 0, this->width(), this->height());
+ p.setAntiAlias(true);
+
+ r.fRight = r.fLeft + SkScalarMul(r.width(), SkFixedToScalar(percent));
+ p.setStyle(SkPaint::kFill_Style);
+
+ p.setColor(SK_ColorDKGRAY);
+ p.setShader(fOnShader);
+ canvas->drawRect(r, p);
+
+ p.setColor(SK_ColorWHITE);
+ p.setShader(fOffShader);
+ r.fLeft = r.fRight;
+ r.fRight = this->width() - SK_Scalar1;
+ if (r.width() > 0)
+ canvas->drawRect(r, p);
+}
+
+#include "SkImageDecoder.h"
+
+static SkShader* inflate_shader(const char file[])
+{
+ SkBitmap bm;
+
+ return SkImageDecoder::DecodeFile(file, &bm) ?
+ SkShader::CreateBitmapShader(bm, SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode) :
+ NULL;
+}
+
+void SkProgressView::onInflate(const SkDOM& dom, const SkDOM::Node* node)
+{
+ this->INHERITED::onInflate(dom, node);
+
+ const char* s;
+
+ SkASSERT(fOnShader == NULL);
+ SkASSERT(fOffShader == NULL);
+
+ if ((s = dom.findAttr(node, "src-on")) != NULL)
+ fOnShader = inflate_shader(s);
+ if ((s = dom.findAttr(node, "src-off")) != NULL)
+ fOffShader = inflate_shader(s);
+ (void)dom.findBool(node, "do-interp", &fDoInterp);
+}
+
diff --git a/src/views/SkScrollBarView.cpp b/src/views/SkScrollBarView.cpp
new file mode 100644
index 0000000..2e087bd
--- /dev/null
+++ b/src/views/SkScrollBarView.cpp
@@ -0,0 +1,139 @@
+#include "SkScrollBarView.h"
+#include "SkAnimator.h"
+#include "SkWidgetViews.h"
+#include "SkSystemEventTypes.h"
+#include "SkTime.h"
+
+//see SkProgressBarView.cpp
+//#include "SkWidgetViews.cpp"
+
+SkScrollBarView::SkScrollBarView()
+{
+ fAnim.setHostEventSink(this);
+ init_skin_anim(kScroll_SkinEnum, &fAnim);
+
+ fTotalLength = 0;
+ fStartPoint = 0;
+ fShownLength = 0;
+
+ this->adjust();
+}
+
+void SkScrollBarView::setStart(unsigned start)
+{
+ if ((int)start < 0)
+ start = 0;
+
+ if (fStartPoint != start)
+ {
+ fStartPoint = start;
+ this->adjust();
+ }
+}
+
+void SkScrollBarView::setShown(unsigned shown)
+{
+ if ((int)shown < 0)
+ shown = 0;
+
+ if (fShownLength != shown)
+ {
+ fShownLength = shown;
+ this->adjust();
+ }
+}
+
+void SkScrollBarView::setTotal(unsigned total)
+{
+ if ((int)total < 0)
+ total = 0;
+
+ if (fTotalLength != total)
+ {
+ fTotalLength = total;
+ this->adjust();
+ }
+}
+
+/* virtual */ void SkScrollBarView::onInflate(const SkDOM& dom, const SkDOM::Node* node)
+{
+ this->INHERITED::onInflate(dom, node);
+
+ int32_t value;
+ if (dom.findS32(node, "total", &value))
+ this->setTotal(value);
+ if (dom.findS32(node, "shown", &value))
+ this->setShown(value);
+}
+
+/*virtual*/ void SkScrollBarView::onSizeChange()
+{
+ this->INHERITED::onSizeChange();
+ SkEvent evt("user");
+ evt.setString("id", "setDim");
+ evt.setScalar("dimX", this->width());
+ evt.setScalar("dimY", this->height());
+ fAnim.doUserEvent(evt);
+}
+
+/*virtual*/ void SkScrollBarView::onDraw(SkCanvas* canvas)
+{
+ SkPaint paint;
+ SkAnimator::DifferenceType diff = fAnim.draw(canvas, &paint, SkTime::GetMSecs());
+
+ if (diff == SkAnimator::kDifferent)
+ this->inval(NULL);
+ else if (diff == SkAnimator::kPartiallyDifferent)
+ {
+ SkRect bounds;
+ fAnim.getInvalBounds(&bounds);
+ this->inval(&bounds);
+ }
+}
+
+/*virtual*/ bool SkScrollBarView::onEvent(const SkEvent& evt)
+{
+ if (evt.isType(SK_EventType_Inval))
+ {
+ this->inval(NULL);
+ return true;
+ }
+ if (evt.isType("recommendDim"))
+ {
+ SkScalar width;
+
+ if (evt.findScalar("x", &width))
+ this->setWidth(width);
+ return true;
+ }
+
+ return this->INHERITED::onEvent(evt);
+}
+
+void SkScrollBarView::adjust()
+{
+ int total = fTotalLength;
+ int start = fStartPoint;
+ int shown = fShownLength;
+ int hideBar = 0;
+
+ if (total <= 0 || shown <= 0 || shown >= total) // no bar to show
+ {
+ total = 1; // avoid divide-by-zero. should be done by skin/script
+ hideBar = 1; // signal we don't want a thumb
+ }
+ else
+ {
+ if (start + shown > total)
+ start = total - shown;
+ }
+
+ SkEvent e("user");
+ e.setString("id", "adjustScrollBar");
+ e.setScalar("_totalLength", SkIntToScalar(total));
+ e.setScalar("_startPoint", SkIntToScalar(start));
+ e.setScalar("_shownLength", SkIntToScalar(shown));
+// e.setS32("hideBar", hideBar);
+ fAnim.doUserEvent(e);
+}
+
diff --git a/src/views/SkStackViewLayout.cpp b/src/views/SkStackViewLayout.cpp
new file mode 100644
index 0000000..ae2e9e8
--- /dev/null
+++ b/src/views/SkStackViewLayout.cpp
@@ -0,0 +1,262 @@
+#include "SkStackViewLayout.h"
+
+SkStackViewLayout::SkStackViewLayout()
+{
+ fMargin.set(0, 0, 0, 0);
+ fSpacer = 0;
+ fOrient = kHorizontal_Orient;
+ fPack = kStart_Pack;
+ fAlign = kStart_Align;
+ fRound = false;
+}
+
+void SkStackViewLayout::setOrient(Orient ori)
+{
+ SkASSERT((unsigned)ori < kOrientCount);
+ fOrient = SkToU8(ori);
+}
+
+void SkStackViewLayout::getMargin(SkRect* margin) const
+{
+ if (margin)
+ *margin = fMargin;
+}
+
+void SkStackViewLayout::setMargin(const SkRect& margin)
+{
+ fMargin = margin;
+}
+
+void SkStackViewLayout::setSpacer(SkScalar spacer)
+{
+ fSpacer = spacer;
+}
+
+void SkStackViewLayout::setPack(Pack pack)
+{
+ SkASSERT((unsigned)pack < kPackCount);
+ fPack = SkToU8(pack);
+}
+
+void SkStackViewLayout::setAlign(Align align)
+{
+ SkASSERT((unsigned)align < kAlignCount);
+ fAlign = SkToU8(align);
+}
+
+void SkStackViewLayout::setRound(bool r)
+{
+ fRound = SkToU8(r);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+typedef SkScalar (*AlignProc)(SkScalar childLimit, SkScalar parentLimit);
+typedef SkScalar (SkView::*GetSizeProc)() const;
+typedef void (SkView::*SetLocProc)(SkScalar coord);
+typedef void (SkView::*SetSizeProc)(SkScalar coord);
+
+static SkScalar left_align_proc(SkScalar childLimit, SkScalar parentLimit) { return 0; }
+static SkScalar center_align_proc(SkScalar childLimit, SkScalar parentLimit) { return SkScalarHalf(parentLimit - childLimit); }
+static SkScalar right_align_proc(SkScalar childLimit, SkScalar parentLimit) { return parentLimit - childLimit; }
+static SkScalar fill_align_proc(SkScalar childLimit, SkScalar parentLimit) { return 0; }
+
+/* Measure the main-dimension for all the children. If a child is marked flex in that direction
+ ignore its current value but increment the counter for flexChildren
+*/
+static SkScalar compute_children_limit(SkView* parent, GetSizeProc sizeProc, int* count,
+ uint32_t flexMask, int* flexCount)
+{
+ SkView::B2FIter iter(parent);
+ SkView* child;
+ SkScalar limit = 0;
+ int n = 0, flex = 0;
+
+ while ((child = iter.next()) != NULL)
+ {
+ n += 1;
+ if (child->getFlags() & flexMask)
+ flex += 1;
+ else
+ limit += (child->*sizeProc)();
+ }
+ if (count)
+ *count = n;
+ if (flexCount)
+ *flexCount = flex;
+ return limit;
+}
+
+void SkStackViewLayout::onLayoutChildren(SkView* parent)
+{
+ static AlignProc gAlignProcs[] = {
+ left_align_proc,
+ center_align_proc,
+ right_align_proc,
+ fill_align_proc
+ };
+
+ SkScalar startM, endM, crossStartM, crossLimit;
+ GetSizeProc mainGetSizeP, crossGetSizeP;
+ SetLocProc mainLocP, crossLocP;
+ SetSizeProc mainSetSizeP, crossSetSizeP;
+ SkView::Flag_Mask flexMask;
+
+ if (fOrient == kHorizontal_Orient)
+ {
+ startM = fMargin.fLeft;
+ endM = fMargin.fRight;
+ crossStartM = fMargin.fTop;
+ crossLimit = -fMargin.fTop - fMargin.fBottom;
+
+ mainGetSizeP = &SkView::width;
+ crossGetSizeP = &SkView::height;
+ mainLocP = &SkView::setLocX;
+ crossLocP = &SkView::setLocY;
+
+ mainSetSizeP = &SkView::setWidth;
+ crossSetSizeP = &SkView::setHeight;
+
+ flexMask = SkView::kFlexH_Mask;
+ }
+ else
+ {
+ startM = fMargin.fTop;
+ endM = fMargin.fBottom;
+ crossStartM = fMargin.fLeft;
+ crossLimit = -fMargin.fLeft - fMargin.fRight;
+
+ mainGetSizeP = &SkView::height;
+ crossGetSizeP = &SkView::width;
+ mainLocP = &SkView::setLocY;
+ crossLocP = &SkView::setLocX;
+
+ mainSetSizeP = &SkView::setHeight;
+ crossSetSizeP = &SkView::setWidth;
+
+ flexMask = SkView::kFlexV_Mask;
+ }
+ crossLimit += (parent->*crossGetSizeP)();
+ if (fAlign != kStretch_Align)
+ crossSetSizeP = NULL;
+
+ int childCount, flexCount;
+ SkScalar childLimit = compute_children_limit(parent, mainGetSizeP, &childCount, flexMask, &flexCount);
+
+ if (childCount == 0)
+ return;
+
+ childLimit += (childCount - 1) * fSpacer;
+
+ SkScalar parentLimit = (parent->*mainGetSizeP)() - startM - endM;
+ SkScalar pos = startM + gAlignProcs[fPack](childLimit, parentLimit);
+ SkScalar flexAmount = 0;
+ SkView::B2FIter iter(parent);
+ SkView* child;
+
+ if (flexCount > 0 && parentLimit > childLimit)
+ flexAmount = (parentLimit - childLimit) / flexCount;
+
+ while ((child = iter.next()) != NULL)
+ {
+ if (fRound)
+ pos = SkIntToScalar(SkScalarRound(pos));
+ (child->*mainLocP)(pos);
+ SkScalar crossLoc = crossStartM + gAlignProcs[fAlign]((child->*crossGetSizeP)(), crossLimit);
+ if (fRound)
+ crossLoc = SkIntToScalar(SkScalarRound(crossLoc));
+ (child->*crossLocP)(crossLoc);
+
+ if (crossSetSizeP)
+ (child->*crossSetSizeP)(crossLimit);
+ if (child->getFlags() & flexMask)
+ (child->*mainSetSizeP)(flexAmount);
+ pos += (child->*mainGetSizeP)() + fSpacer;
+ }
+}
+
+//////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef SK_DEBUG
+ static void assert_no_attr(const SkDOM& dom, const SkDOM::Node* node, const char attr[])
+ {
+ const char* value = dom.findAttr(node, attr);
+ if (value)
+ SkDebugf("unknown attribute %s=\"%s\"\n", attr, value);
+ }
+#else
+ #define assert_no_attr(dom, node, attr)
+#endif
+
+void SkStackViewLayout::onInflate(const SkDOM& dom, const SkDOM::Node* node)
+{
+ int index;
+ SkScalar value[4];
+
+ if ((index = dom.findList(node, "orient", "horizontal,vertical")) >= 0)
+ this->setOrient((Orient)index);
+ else
+ assert_no_attr(dom, node, "orient");
+
+ if (dom.findScalars(node, "margin", value, 4))
+ {
+ SkRect margin;
+ margin.set(value[0], value[1], value[2], value[3]);
+ this->setMargin(margin);
+ }
+ else
+ assert_no_attr(dom, node, "margin");
+
+ if (dom.findScalar(node, "spacer", value))
+ this->setSpacer(value[0]);
+ else
+ assert_no_attr(dom, node, "spacer");
+
+ if ((index = dom.findList(node, "pack", "start,center,end")) >= 0)
+ this->setPack((Pack)index);
+ else
+ assert_no_attr(dom, node, "pack");
+
+ if ((index = dom.findList(node, "align", "start,center,end,stretch")) >= 0)
+ this->setAlign((Align)index);
+ else
+ assert_no_attr(dom, node, "align");
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+SkFillViewLayout::SkFillViewLayout()
+{
+ fMargin.setEmpty();
+}
+
+void SkFillViewLayout::getMargin(SkRect* r) const
+{
+ if (r)
+ *r = fMargin;
+}
+
+void SkFillViewLayout::setMargin(const SkRect& margin)
+{
+ fMargin = margin;
+}
+
+void SkFillViewLayout::onLayoutChildren(SkView* parent)
+{
+ SkView::B2FIter iter(parent);
+ SkView* child;
+
+ while ((child = iter.next()) != NULL)
+ {
+ child->setLoc(fMargin.fLeft, fMargin.fTop);
+ child->setSize( parent->width() - fMargin.fRight - fMargin.fLeft,
+ parent->height() - fMargin.fBottom - fMargin.fTop);
+ }
+}
+
+void SkFillViewLayout::onInflate(const SkDOM& dom, const SkDOM::Node* node)
+{
+ this->INHERITED::onInflate(dom, node);
+ (void)dom.findScalars(node, "margin", (SkScalar*)&fMargin, 4);
+}
+
diff --git a/src/views/SkStaticTextView.cpp b/src/views/SkStaticTextView.cpp
new file mode 100644
index 0000000..8fb8bc1
--- /dev/null
+++ b/src/views/SkStaticTextView.cpp
@@ -0,0 +1,177 @@
+#include "SkWidgetViews.h"
+#include "SkTextBox.h"
+
+#ifdef SK_DEBUG
+static void assert_no_attr(const SkDOM& dom, const SkDOM::Node* node, const char attr[])
+{
+ const char* value = dom.findAttr(node, attr);
+ if (value)
+ SkDebugf("unknown attribute %s=\"%s\"\n", attr, value);
+}
+#else
+ #define assert_no_attr(dom, node, attr)
+#endif
+
+SkStaticTextView::SkStaticTextView()
+{
+ fMargin.set(0, 0);
+ fMode = kFixedSize_Mode;
+ fSpacingAlign = SkTextBox::kStart_SpacingAlign;
+
+// init_skin_paint(kStaticText_SkinEnum, &fPaint);
+}
+
+SkStaticTextView::~SkStaticTextView()
+{
+}
+
+void SkStaticTextView::computeSize()
+{
+ if (fMode == kAutoWidth_Mode)
+ {
+ SkScalar width = fPaint.measureText(fText.c_str(), fText.size());
+ this->setWidth(width + fMargin.fX * 2);
+ }
+ else if (fMode == kAutoHeight_Mode)
+ {
+ SkScalar width = this->width() - fMargin.fX * 2;
+ int lines = width > 0 ? SkTextLineBreaker::CountLines(fText.c_str(), fText.size(), fPaint, width) : 0;
+
+ this->setHeight(lines * fPaint.getFontSpacing() + fMargin.fY * 2);
+ }
+}
+
+void SkStaticTextView::setMode(Mode mode)
+{
+ SkASSERT((unsigned)mode < kModeCount);
+
+ if (fMode != mode)
+ {
+ fMode = SkToU8(mode);
+ this->computeSize();
+ }
+}
+
+void SkStaticTextView::setSpacingAlign(SkTextBox::SpacingAlign align)
+{
+ fSpacingAlign = SkToU8(align);
+ this->inval(NULL);
+}
+
+void SkStaticTextView::getMargin(SkPoint* margin) const
+{
+ if (margin)
+ *margin = fMargin;
+}
+
+void SkStaticTextView::setMargin(SkScalar dx, SkScalar dy)
+{
+ if (fMargin.fX != dx || fMargin.fY != dy)
+ {
+ fMargin.set(dx, dy);
+ this->computeSize();
+ this->inval(NULL);
+ }
+}
+
+size_t SkStaticTextView::getText(SkString* text) const
+{
+ if (text)
+ *text = fText;
+ return fText.size();
+}
+
+size_t SkStaticTextView::getText(char text[]) const
+{
+ if (text)
+ memcpy(text, fText.c_str(), fText.size());
+ return fText.size();
+}
+
+void SkStaticTextView::setText(const SkString& text)
+{
+ this->setText(text.c_str(), text.size());
+}
+
+void SkStaticTextView::setText(const char text[])
+{
+ if (text == NULL)
+ text = "";
+ this->setText(text, strlen(text));
+}
+
+void SkStaticTextView::setText(const char text[], size_t len)
+{
+ if (!fText.equals(text, len))
+ {
+ fText.set(text, len);
+ this->computeSize();
+ this->inval(NULL);
+ }
+}
+
+void SkStaticTextView::getPaint(SkPaint* paint) const
+{
+ if (paint)
+ *paint = fPaint;
+}
+
+void SkStaticTextView::setPaint(const SkPaint& paint)
+{
+ if (fPaint != paint)
+ {
+ fPaint = paint;
+ this->computeSize();
+ this->inval(NULL);
+ }
+}
+
+void SkStaticTextView::onDraw(SkCanvas* canvas)
+{
+ this->INHERITED::onDraw(canvas);
+
+ if (fText.isEmpty())
+ return;
+
+ SkTextBox box;
+
+ box.setMode(fMode == kAutoWidth_Mode ? SkTextBox::kOneLine_Mode : SkTextBox::kLineBreak_Mode);
+ box.setSpacingAlign(this->getSpacingAlign());
+ box.setBox(fMargin.fX, fMargin.fY, this->width() - fMargin.fX, this->height() - fMargin.fY);
+ box.draw(canvas, fText.c_str(), fText.size(), fPaint);
+}
+
+void SkStaticTextView::onInflate(const SkDOM& dom, const SkDOM::Node* node)
+{
+#if 0
+ this->INHERITED::onInflate(dom, node);
+
+ int index;
+ if ((index = dom.findList(node, "mode", "fixed,auto-width,auto-height")) >= 0)
+ this->setMode((Mode)index);
+ else
+ assert_no_attr(dom, node, "mode");
+
+ if ((index = dom.findList(node, "spacing-align", "start,center,end")) >= 0)
+ this->setSpacingAlign((SkTextBox::SpacingAlign)index);
+ else
+ assert_no_attr(dom, node, "spacing-align");
+
+ SkScalar s[2];
+ if (dom.findScalars(node, "margin", s, 2))
+ this->setMargin(s[0], s[1]);
+ else
+ assert_no_attr(dom, node, "margin");
+
+ const char* text = dom.findAttr(node, "text");
+ if (text)
+ this->setText(text);
+
+ if ((node = dom.getFirstChild(node, "paint")) != NULL &&
+ (node = dom.getFirstChild(node, "screenplay")) != NULL)
+ {
+ inflate_paint(dom, node, &fPaint);
+ }
+#endif
+}
+
diff --git a/src/views/SkTagList.cpp b/src/views/SkTagList.cpp
new file mode 100644
index 0000000..4576ce6
--- /dev/null
+++ b/src/views/SkTagList.cpp
@@ -0,0 +1,71 @@
+/* libs/graphics/views/SkTagList.cpp
+**
+** Copyright 2006, 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.
+*/
+
+#include "SkTagList.h"
+
+SkTagList::~SkTagList()
+{
+}
+
+SkTagList* SkTagList::Find(SkTagList* rec, U8CPU tag)
+{
+ SkASSERT(tag < kSkTagListCount);
+
+ while (rec != NULL)
+ {
+ if (rec->fTag == tag)
+ break;
+ rec = rec->fNext;
+ }
+ return rec;
+}
+
+void SkTagList::DeleteTag(SkTagList** head, U8CPU tag)
+{
+ SkASSERT(tag < kSkTagListCount);
+
+ SkTagList* rec = *head;
+ SkTagList* prev = NULL;
+
+ while (rec != NULL)
+ {
+ SkTagList* next = rec->fNext;
+
+ if (rec->fTag == tag)
+ {
+ if (prev)
+ prev->fNext = next;
+ else
+ *head = next;
+ delete rec;
+ break;
+ }
+ prev = rec;
+ rec = next;
+ }
+}
+
+void SkTagList::DeleteAll(SkTagList* rec)
+{
+ while (rec)
+ {
+ SkTagList* next = rec->fNext;
+ delete rec;
+ rec = next;
+ }
+}
+
diff --git a/src/views/SkTagList.h b/src/views/SkTagList.h
new file mode 100644
index 0000000..5f428e4
--- /dev/null
+++ b/src/views/SkTagList.h
@@ -0,0 +1,51 @@
+/* libs/graphics/views/SkTagList.h
+**
+** Copyright 2006, 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.
+*/
+
+#ifndef SkTagList_DEFINED
+#define SkTagList_DEFINED
+
+#include "SkTypes.h"
+
+enum SkTagListEnum {
+ kListeners_SkTagList,
+ kViewLayout_SkTagList,
+ kViewArtist_SkTagList,
+
+ kSkTagListCount
+};
+
+struct SkTagList {
+ SkTagList* fNext;
+ uint16_t fExtra16;
+ uint8_t fExtra8;
+ uint8_t fTag;
+
+ SkTagList(U8CPU tag) : fTag(SkToU8(tag))
+ {
+ SkASSERT(tag < kSkTagListCount);
+ fNext = NULL;
+ fExtra16 = 0;
+ fExtra8 = 0;
+ }
+ virtual ~SkTagList();
+
+ static SkTagList* Find(SkTagList* head, U8CPU tag);
+ static void DeleteTag(SkTagList** headptr, U8CPU tag);
+ static void DeleteAll(SkTagList* head);
+};
+
+#endif
diff --git a/src/views/SkTextBox.cpp b/src/views/SkTextBox.cpp
new file mode 100644
index 0000000..0e31ac6
--- /dev/null
+++ b/src/views/SkTextBox.cpp
@@ -0,0 +1,237 @@
+/* libs/graphics/views/SkTextBox.cpp
+**
+** Copyright 2006, 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.
+*/
+
+#include "SkTextBox.h"
+#include "../core/SkGlyphCache.h"
+#include "SkUtils.h"
+#include "SkAutoKern.h"
+
+static inline int is_ws(int c)
+{
+ return !((c - 1) >> 5);
+}
+
+static size_t linebreak(const char text[], const char stop[], const SkPaint& paint, SkScalar margin)
+{
+ const char* start = text;
+
+ SkAutoGlyphCache ac(paint, NULL);
+ SkGlyphCache* cache = ac.getCache();
+ SkFixed w = 0;
+ SkFixed limit = SkScalarToFixed(margin);
+ SkAutoKern autokern;
+
+ const char* word_start = text;
+ int prevWS = true;
+
+ while (text < stop)
+ {
+ const char* prevText = text;
+ SkUnichar uni = SkUTF8_NextUnichar(&text);
+ int currWS = is_ws(uni);
+ const SkGlyph& glyph = cache->getUnicharMetrics(uni);
+
+ if (!currWS && prevWS)
+ word_start = prevText;
+ prevWS = currWS;
+
+ w += autokern.adjust(glyph) + glyph.fAdvanceX;
+ if (w > limit)
+ {
+ if (currWS) // eat the rest of the whitespace
+ {
+ while (text < stop && is_ws(SkUTF8_ToUnichar(text)))
+ text += SkUTF8_CountUTF8Bytes(text);
+ }
+ else // backup until a whitespace (or 1 char)
+ {
+ if (word_start == start)
+ {
+ if (prevText > start)
+ text = prevText;
+ }
+ else
+ text = word_start;
+ }
+ break;
+ }
+ }
+ return text - start;
+}
+
+int SkTextLineBreaker::CountLines(const char text[], size_t len, const SkPaint& paint, SkScalar width)
+{
+ const char* stop = text + len;
+ int count = 0;
+
+ if (width > 0)
+ {
+ do {
+ count += 1;
+ text += linebreak(text, stop, paint, width);
+ } while (text < stop);
+ }
+ return count;
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+SkTextBox::SkTextBox()
+{
+ fBox.setEmpty();
+ fSpacingMul = SK_Scalar1;
+ fSpacingAdd = 0;
+ fMode = kLineBreak_Mode;
+ fSpacingAlign = kStart_SpacingAlign;
+}
+
+void SkTextBox::setMode(Mode mode)
+{
+ SkASSERT((unsigned)mode < kModeCount);
+ fMode = SkToU8(mode);
+}
+
+void SkTextBox::setSpacingAlign(SpacingAlign align)
+{
+ SkASSERT((unsigned)align < kSpacingAlignCount);
+ fSpacingAlign = SkToU8(align);
+}
+
+void SkTextBox::getBox(SkRect* box) const
+{
+ if (box)
+ *box = fBox;
+}
+
+void SkTextBox::setBox(const SkRect& box)
+{
+ fBox = box;
+}
+
+void SkTextBox::setBox(SkScalar left, SkScalar top, SkScalar right, SkScalar bottom)
+{
+ fBox.set(left, top, right, bottom);
+}
+
+void SkTextBox::getSpacing(SkScalar* mul, SkScalar* add) const
+{
+ if (mul)
+ *mul = fSpacingMul;
+ if (add)
+ *add = fSpacingAdd;
+}
+
+void SkTextBox::setSpacing(SkScalar mul, SkScalar add)
+{
+ fSpacingMul = mul;
+ fSpacingAdd = add;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+
+void SkTextBox::draw(SkCanvas* canvas, const char text[], size_t len, const SkPaint& paint)
+{
+ SkASSERT(canvas && &paint && (text || len == 0));
+
+ SkScalar marginWidth = fBox.width();
+
+ if (marginWidth <= 0 || len == 0)
+ return;
+
+ const char* textStop = text + len;
+
+ SkScalar x, y, scaledSpacing, height, fontHeight;
+ SkPaint::FontMetrics metrics;
+
+ switch (paint.getTextAlign()) {
+ case SkPaint::kLeft_Align:
+ x = 0;
+ break;
+ case SkPaint::kCenter_Align:
+ x = SkScalarHalf(marginWidth);
+ break;
+ default:
+ x = marginWidth;
+ break;
+ }
+ x += fBox.fLeft;
+
+ fontHeight = paint.getFontMetrics(&metrics);
+ scaledSpacing = SkScalarMul(fontHeight, fSpacingMul) + fSpacingAdd;
+ height = fBox.height();
+
+ // compute Y position for first line
+ {
+ SkScalar textHeight = fontHeight;
+
+ if (fMode == kLineBreak_Mode && fSpacingAlign != kStart_SpacingAlign)
+ {
+ int count = SkTextLineBreaker::CountLines(text, textStop - text, paint, marginWidth);
+ SkASSERT(count > 0);
+ textHeight += scaledSpacing * (count - 1);
+ }
+
+ switch (fSpacingAlign) {
+ case kStart_SpacingAlign:
+ y = 0;
+ break;
+ case kCenter_SpacingAlign:
+ y = SkScalarHalf(height - textHeight);
+ break;
+ default:
+ SkASSERT(fSpacingAlign == kEnd_SpacingAlign);
+ y = height - textHeight;
+ break;
+ }
+ y += fBox.fTop - metrics.fAscent;
+ }
+
+ for (;;)
+ {
+ len = linebreak(text, textStop, paint, marginWidth);
+ if (y + metrics.fDescent + metrics.fLeading > 0)
+ canvas->drawText(text, len, x, y, paint);
+ text += len;
+ if (text >= textStop)
+ break;
+ y += scaledSpacing;
+ if (y + metrics.fAscent >= height)
+ break;
+ }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void SkTextBox::setText(const char text[], size_t len, const SkPaint& paint) {
+ fText = text;
+ fLen = len;
+ fPaint = &paint;
+}
+
+void SkTextBox::draw(SkCanvas* canvas) {
+ this->draw(canvas, fText, fLen, *fPaint);
+}
+
+int SkTextBox::countLines() const {
+ return SkTextLineBreaker::CountLines(fText, fLen, *fPaint, fBox.width());
+}
+
+SkScalar SkTextBox::getTextHeight() const {
+ SkScalar spacing = SkScalarMul(fPaint->getTextSize(), fSpacingMul) + fSpacingAdd;
+ return this->countLines() * spacing;
+}
+
diff --git a/src/views/SkTouchGesture.cpp b/src/views/SkTouchGesture.cpp
new file mode 100644
index 0000000..1732176
--- /dev/null
+++ b/src/views/SkTouchGesture.cpp
@@ -0,0 +1,336 @@
+/*
+ Copyright 2010 Google Inc.
+
+ 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.
+ */
+
+
+#include "SkTouchGesture.h"
+#include "SkMatrix.h"
+#include "SkTime.h"
+
+#define DISCRETIZE_TRANSLATE_TO_AVOID_FLICKER true
+
+static const float MAX_FLING_SPEED = 1500;
+
+static float pin_max_fling(float speed) {
+ if (speed > MAX_FLING_SPEED) {
+ speed = MAX_FLING_SPEED;
+ }
+ return speed;
+}
+
+static double getseconds() {
+ return SkTime::GetMSecs() * 0.001;
+}
+
+// returns +1 or -1, depending on the sign of x
+// returns +1 if x is zero
+static SkScalar SkScalarSign(SkScalar x) {
+ SkScalar sign = SK_Scalar1;
+ if (x < 0) {
+ sign = -sign;
+ }
+ return sign;
+}
+
+static void unit_axis_align(SkVector* unit) {
+ const SkScalar TOLERANCE = SkDoubleToScalar(0.15);
+ if (SkScalarAbs(unit->fX) < TOLERANCE) {
+ unit->fX = 0;
+ unit->fY = SkScalarSign(unit->fY);
+ } else if (SkScalarAbs(unit->fY) < TOLERANCE) {
+ unit->fX = SkScalarSign(unit->fX);
+ unit->fY = 0;
+ }
+}
+
+void SkFlingState::reset(float sx, float sy) {
+ fActive = true;
+ fDirection.set(sx, sy);
+ fSpeed0 = SkPoint::Normalize(&fDirection);
+ fSpeed0 = pin_max_fling(fSpeed0);
+ fTime0 = getseconds();
+
+ unit_axis_align(&fDirection);
+// printf("---- speed %g dir %g %g\n", fSpeed0, fDirection.fX, fDirection.fY);
+}
+
+bool SkFlingState::evaluateMatrix(SkMatrix* matrix) {
+ if (!fActive) {
+ return false;
+ }
+
+ const float t = (float)(getseconds() - fTime0);
+ const float MIN_SPEED = 2;
+ const float K0 = 5;
+ const float K1 = 0.02f;
+ const float speed = fSpeed0 * (sk_float_exp(- K0 * t) - K1);
+ if (speed <= MIN_SPEED) {
+ fActive = false;
+ return false;
+ }
+ float dist = (fSpeed0 - speed) / K0;
+
+// printf("---- time %g speed %g dist %g\n", t, speed, dist);
+ float tx = fDirection.fX * dist;
+ float ty = fDirection.fY * dist;
+ if (DISCRETIZE_TRANSLATE_TO_AVOID_FLICKER) {
+ tx = (float)sk_float_round2int(tx);
+ ty = (float)sk_float_round2int(ty);
+ }
+ matrix->setTranslate(tx, ty);
+// printf("---- evaluate (%g %g)\n", tx, ty);
+
+ return true;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static const SkMSec MAX_DBL_TAP_INTERVAL = 300;
+static const float MAX_DBL_TAP_DISTANCE = 100;
+static const float MAX_JITTER_RADIUS = 2;
+
+// if true, then ignore the touch-move, 'cause its probably just jitter
+static bool close_enough_for_jitter(float x0, float y0, float x1, float y1) {
+ return sk_float_abs(x0 - x1) <= MAX_JITTER_RADIUS &&
+ sk_float_abs(y0 - y1) <= MAX_JITTER_RADIUS;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+SkTouchGesture::SkTouchGesture() {
+ this->reset();
+}
+
+SkTouchGesture::~SkTouchGesture() {
+}
+
+void SkTouchGesture::reset() {
+ fTouches.reset();
+ fState = kEmpty_State;
+ fLocalM.reset();
+ fGlobalM.reset();
+
+ fLastUpT = SkTime::GetMSecs() - 2*MAX_DBL_TAP_INTERVAL;
+ fLastUpP.set(0, 0);
+}
+
+void SkTouchGesture::flushLocalM() {
+ fGlobalM.postConcat(fLocalM);
+ fLocalM.reset();
+}
+
+const SkMatrix& SkTouchGesture::localM() {
+ if (fFlinger.isActive()) {
+ if (!fFlinger.evaluateMatrix(&fLocalM)) {
+ this->flushLocalM();
+ }
+ }
+ return fLocalM;
+}
+
+void SkTouchGesture::appendNewRec(void* owner, float x, float y) {
+ Rec* rec = fTouches.append();
+ rec->fOwner = owner;
+ rec->fStartX = rec->fPrevX = rec->fLastX = x;
+ rec->fStartY = rec->fPrevY = rec->fLastY = y;
+ rec->fLastT = rec->fPrevT = SkTime::GetMSecs();
+}
+
+void SkTouchGesture::touchBegin(void* owner, float x, float y) {
+// GrPrintf("--- %d touchBegin %p %g %g\n", fTouches.count(), owner, x, y);
+
+ int index = this->findRec(owner);
+ if (index >= 0) {
+ this->flushLocalM();
+ fTouches.removeShuffle(index);
+ SkDebugf("---- already exists, removing\n");
+ }
+
+ if (fTouches.count() == 2) {
+ return;
+ }
+
+ this->flushLocalM();
+ fFlinger.stop();
+
+ this->appendNewRec(owner, x, y);
+
+ switch (fTouches.count()) {
+ case 1:
+ fState = kTranslate_State;
+ break;
+ case 2:
+ fState = kZoom_State;
+ break;
+ default:
+ break;
+ }
+}
+
+int SkTouchGesture::findRec(void* owner) const {
+ for (int i = 0; i < fTouches.count(); i++) {
+ if (owner == fTouches[i].fOwner) {
+ return i;
+ }
+ }
+ return -1;
+}
+
+static float center(float pos0, float pos1) {
+ return (pos0 + pos1) * 0.5f;
+}
+
+static const float MAX_ZOOM_SCALE = 4;
+static const float MIN_ZOOM_SCALE = 0.25f;
+
+float SkTouchGesture::limitTotalZoom(float scale) const {
+ // this query works 'cause we know that we're square-scale w/ no skew/rotation
+ const float curr = fGlobalM[0];
+
+ if (scale > 1 && curr * scale > MAX_ZOOM_SCALE) {
+ scale = MAX_ZOOM_SCALE / curr;
+ } else if (scale < 1 && curr * scale < MIN_ZOOM_SCALE) {
+ scale = MIN_ZOOM_SCALE / curr;
+ }
+ return scale;
+}
+
+void SkTouchGesture::touchMoved(void* owner, float x, float y) {
+// GrPrintf("--- %d touchMoved %p %g %g\n", fTouches.count(), owner, x, y);
+
+ SkASSERT(kEmpty_State != fState);
+
+ int index = this->findRec(owner);
+ if (index < 0) {
+ // not found, so I guess we should add it...
+ SkDebugf("---- add missing begin\n");
+ this->appendNewRec(owner, x, y);
+ index = fTouches.count() - 1;
+ }
+
+ Rec& rec = fTouches[index];
+
+ // not sure how valuable this is
+ if (fTouches.count() == 2) {
+ if (close_enough_for_jitter(rec.fLastX, rec.fLastY, x, y)) {
+// GrPrintf("--- drop touchMove, withing jitter tolerance %g %g\n", rec.fLastX - x, rec.fLastY - y);
+ return;
+ }
+ }
+
+ rec.fPrevX = rec.fLastX; rec.fLastX = x;
+ rec.fPrevY = rec.fLastY; rec.fLastY = y;
+ rec.fPrevT = rec.fLastT; rec.fLastT = SkTime::GetMSecs();
+
+ switch (fTouches.count()) {
+ case 1: {
+ float dx = rec.fLastX - rec.fStartX;
+ float dy = rec.fLastY - rec.fStartY;
+ dx = (float)sk_float_round2int(dx);
+ dy = (float)sk_float_round2int(dy);
+ fLocalM.setTranslate(dx, dy);
+ } break;
+ case 2: {
+ SkASSERT(kZoom_State == fState);
+ const Rec& rec0 = fTouches[0];
+ const Rec& rec1 = fTouches[1];
+
+ float scale = this->computePinch(rec0, rec1);
+ scale = this->limitTotalZoom(scale);
+
+ fLocalM.setTranslate(-center(rec0.fStartX, rec1.fStartX),
+ -center(rec0.fStartY, rec1.fStartY));
+ fLocalM.postScale(scale, scale);
+ fLocalM.postTranslate(center(rec0.fLastX, rec1.fLastX),
+ center(rec0.fLastY, rec1.fLastY));
+ } break;
+ default:
+ break;
+ }
+}
+
+void SkTouchGesture::touchEnd(void* owner) {
+// GrPrintf("--- %d touchEnd %p\n", fTouches.count(), owner);
+
+ int index = this->findRec(owner);
+ if (index < 0) {
+ SkDebugf("--- not found\n");
+ return;
+ }
+
+ const Rec& rec = fTouches[index];
+ if (this->handleDblTap(rec.fLastX, rec.fLastY)) {
+ return;
+ }
+
+ // count() reflects the number before we removed the owner
+ switch (fTouches.count()) {
+ case 1: {
+ this->flushLocalM();
+ float dx = rec.fLastX - rec.fPrevX;
+ float dy = rec.fLastY - rec.fPrevY;
+ float dur = (rec.fLastT - rec.fPrevT) * 0.001f;
+ if (dur > 0) {
+ fFlinger.reset(dx / dur, dy / dur);
+ }
+ fState = kEmpty_State;
+ } break;
+ case 2:
+ this->flushLocalM();
+ SkASSERT(kZoom_State == fState);
+ fState = kEmpty_State;
+ break;
+ default:
+ SkASSERT(kZoom_State == fState);
+ break;
+ }
+
+ fTouches.removeShuffle(index);
+}
+
+float SkTouchGesture::computePinch(const Rec& rec0, const Rec& rec1) {
+ double dx = rec0.fStartX - rec1.fStartX;
+ double dy = rec0.fStartY - rec1.fStartY;
+ double dist0 = sqrt(dx*dx + dy*dy);
+
+ dx = rec0.fLastX - rec1.fLastX;
+ dy = rec0.fLastY - rec1.fLastY;
+ double dist1 = sqrt(dx*dx + dy*dy);
+
+ double scale = dist1 / dist0;
+ return (float)scale;
+}
+
+bool SkTouchGesture::handleDblTap(float x, float y) {
+ bool found = false;
+ SkMSec now = SkTime::GetMSecs();
+ if (now - fLastUpT <= MAX_DBL_TAP_INTERVAL) {
+ if (SkPoint::Length(fLastUpP.fX - x,
+ fLastUpP.fY - y) <= MAX_DBL_TAP_DISTANCE) {
+ fFlinger.stop();
+ fLocalM.reset();
+ fGlobalM.reset();
+ fTouches.reset();
+ fState = kEmpty_State;
+ found = true;
+ }
+ }
+
+ fLastUpT = now;
+ fLastUpP.set(x, y);
+ return found;
+}
+
+
diff --git a/src/views/SkView.cpp b/src/views/SkView.cpp
new file mode 100644
index 0000000..1cd6339
--- /dev/null
+++ b/src/views/SkView.cpp
@@ -0,0 +1,793 @@
+#include "SkView.h"
+#include "SkCanvas.h"
+
+////////////////////////////////////////////////////////////////////////
+
+SkView::SkView(uint32_t flags) : fFlags(SkToU8(flags))
+{
+ fWidth = fHeight = 0;
+ fLoc.set(0, 0);
+ fParent = fFirstChild = fNextSibling = fPrevSibling = NULL;
+
+ fContainsFocus = 0;
+}
+
+SkView::~SkView()
+{
+ this->detachAllChildren();
+}
+
+void SkView::setFlags(uint32_t flags)
+{
+ SkASSERT((flags & ~kAllFlagMasks) == 0);
+
+ uint32_t diff = fFlags ^ flags;
+
+ if (diff & kVisible_Mask)
+ this->inval(NULL);
+
+ fFlags = SkToU8(flags);
+
+ if (diff & kVisible_Mask)
+ {
+ this->inval(NULL);
+ }
+}
+
+void SkView::setVisibleP(bool pred)
+{
+ this->setFlags(SkSetClearShift(fFlags, pred, kVisible_Shift));
+}
+
+void SkView::setEnabledP(bool pred)
+{
+ this->setFlags(SkSetClearShift(fFlags, pred, kEnabled_Shift));
+}
+
+void SkView::setFocusableP(bool pred)
+{
+ this->setFlags(SkSetClearShift(fFlags, pred, kFocusable_Shift));
+}
+
+void SkView::setClipToBounds(bool pred) {
+ this->setFlags(SkSetClearShift(fFlags, !pred, kNoClip_Shift));
+}
+
+void SkView::setSize(SkScalar width, SkScalar height)
+{
+ width = SkMaxScalar(0, width);
+ height = SkMaxScalar(0, height);
+
+ if (fWidth != width || fHeight != height)
+ {
+ this->inval(NULL);
+ fWidth = width;
+ fHeight = height;
+ this->inval(NULL);
+ this->onSizeChange();
+ this->invokeLayout();
+ }
+}
+
+void SkView::setLoc(SkScalar x, SkScalar y)
+{
+ if (fLoc.fX != x || fLoc.fY != y)
+ {
+ this->inval(NULL);
+ fLoc.set(x, y);
+ this->inval(NULL);
+ }
+}
+
+void SkView::offset(SkScalar dx, SkScalar dy)
+{
+ if (dx || dy)
+ this->setLoc(fLoc.fX + dx, fLoc.fY + dy);
+}
+
+void SkView::draw(SkCanvas* canvas)
+{
+ if (fWidth && fHeight && this->isVisible())
+ {
+ SkRect r;
+ r.set(fLoc.fX, fLoc.fY, fLoc.fX + fWidth, fLoc.fY + fHeight);
+ if (this->isClipToBounds() &&
+ canvas->quickReject(r, SkCanvas::kBW_EdgeType)) {
+ return;
+ }
+
+ SkAutoCanvasRestore as(canvas, true);
+
+ if (this->isClipToBounds()) {
+ canvas->clipRect(r);
+ }
+ canvas->translate(fLoc.fX, fLoc.fY);
+
+ if (fParent) {
+ fParent->beforeChild(this, canvas);
+ }
+
+ int sc = canvas->save();
+ this->onDraw(canvas);
+ canvas->restoreToCount(sc);
+
+ if (fParent) {
+ fParent->afterChild(this, canvas);
+ }
+
+ B2FIter iter(this);
+ SkView* child;
+
+ SkCanvas* childCanvas = this->beforeChildren(canvas);
+
+ while ((child = iter.next()) != NULL)
+ child->draw(childCanvas);
+
+ this->afterChildren(canvas);
+ }
+}
+
+void SkView::inval(SkRect* rect) {
+ SkView* view = this;
+ SkRect storage;
+
+ for (;;) {
+ if (!view->isVisible()) {
+ return;
+ }
+ if (view->isClipToBounds()) {
+ SkRect bounds;
+ view->getLocalBounds(&bounds);
+ if (rect && !bounds.intersect(*rect)) {
+ return;
+ }
+ storage = bounds;
+ rect = &storage;
+ }
+ if (view->handleInval(rect)) {
+ return;
+ }
+
+ SkView* parent = view->fParent;
+ if (parent == NULL) {
+ return;
+ }
+
+ if (rect) {
+ rect->offset(view->fLoc.fX, view->fLoc.fY);
+ }
+ view = parent;
+ }
+}
+
+////////////////////////////////////////////////////////////////////////////
+
+bool SkView::setFocusView(SkView* fv)
+{
+ SkView* view = this;
+
+ do {
+ if (view->onSetFocusView(fv))
+ return true;
+ } while ((view = view->fParent) != NULL);
+ return false;
+}
+
+SkView* SkView::getFocusView() const
+{
+ SkView* focus = NULL;
+ const SkView* view = this;
+ do {
+ if (view->onGetFocusView(&focus))
+ break;
+ } while ((view = view->fParent) != NULL);
+ return focus;
+}
+
+bool SkView::hasFocus() const
+{
+ return this == this->getFocusView();
+}
+
+bool SkView::acceptFocus()
+{
+ return this->isFocusable() && this->setFocusView(this);
+}
+
+/*
+ Try to give focus to this view, or its children
+*/
+SkView* SkView::acceptFocus(FocusDirection dir)
+{
+ if (dir == kNext_FocusDirection)
+ {
+ if (this->acceptFocus())
+ return this;
+
+ B2FIter iter(this);
+ SkView* child, *focus;
+ while ((child = iter.next()) != NULL)
+ if ((focus = child->acceptFocus(dir)) != NULL)
+ return focus;
+ }
+ else // prev
+ {
+ F2BIter iter(this);
+ SkView* child, *focus;
+ while ((child = iter.next()) != NULL)
+ if ((focus = child->acceptFocus(dir)) != NULL)
+ return focus;
+
+ if (this->acceptFocus())
+ return this;
+ }
+
+ return NULL;
+}
+
+SkView* SkView::moveFocus(FocusDirection dir)
+{
+ SkView* focus = this->getFocusView();
+
+ if (focus == NULL)
+ { // start with the root
+ focus = this;
+ while (focus->fParent)
+ focus = focus->fParent;
+ }
+
+ SkView* child, *parent;
+
+ if (dir == kNext_FocusDirection)
+ {
+ parent = focus;
+ child = focus->fFirstChild;
+ if (child)
+ goto FIRST_CHILD;
+ else
+ goto NEXT_SIB;
+
+ do {
+ while (child != parent->fFirstChild)
+ {
+ FIRST_CHILD:
+ if ((focus = child->acceptFocus(dir)) != NULL)
+ return focus;
+ child = child->fNextSibling;
+ }
+ NEXT_SIB:
+ child = parent->fNextSibling;
+ parent = parent->fParent;
+ } while (parent != NULL);
+ }
+ else // prevfocus
+ {
+ parent = focus->fParent;
+ if (parent == NULL) // we're the root
+ return focus->acceptFocus(dir);
+ else
+ {
+ child = focus;
+ while (parent)
+ {
+ while (child != parent->fFirstChild)
+ {
+ child = child->fPrevSibling;
+ if ((focus = child->acceptFocus(dir)) != NULL)
+ return focus;
+ }
+ if (parent->acceptFocus())
+ return parent;
+
+ child = parent;
+ parent = parent->fParent;
+ }
+ }
+ }
+ return NULL;
+}
+
+void SkView::onFocusChange(bool gainFocusP)
+{
+ this->inval(NULL);
+}
+
+////////////////////////////////////////////////////////////////////////////
+
+SkView::Click::Click(SkView* target)
+{
+ SkASSERT(target);
+ fTargetID = target->getSinkID();
+ fType = NULL;
+ fWeOwnTheType = false;
+}
+
+SkView::Click::~Click()
+{
+ this->resetType();
+}
+
+void SkView::Click::resetType()
+{
+ if (fWeOwnTheType)
+ {
+ sk_free(fType);
+ fWeOwnTheType = false;
+ }
+ fType = NULL;
+}
+
+bool SkView::Click::isType(const char type[]) const
+{
+ const char* t = fType;
+
+ if (type == t)
+ return true;
+
+ if (type == NULL)
+ type = "";
+ if (t == NULL)
+ t = "";
+ return !strcmp(t, type);
+}
+
+void SkView::Click::setType(const char type[])
+{
+ this->resetType();
+ fType = (char*)type;
+}
+
+void SkView::Click::copyType(const char type[])
+{
+ if (fType != type)
+ {
+ this->resetType();
+ if (type)
+ {
+ size_t len = strlen(type) + 1;
+ fType = (char*)sk_malloc_throw(len);
+ memcpy(fType, type, len);
+ fWeOwnTheType = true;
+ }
+ }
+}
+
+SkView::Click* SkView::findClickHandler(SkScalar x, SkScalar y)
+{
+ if (x < 0 || y < 0 || x >= fWidth || y >= fHeight) {
+ return false;
+ }
+
+ if (this->onSendClickToChildren(x, y)) {
+ F2BIter iter(this);
+ SkView* child;
+
+ while ((child = iter.next()) != NULL)
+ {
+ Click* click = child->findClickHandler(x - child->fLoc.fX,
+ y - child->fLoc.fY);
+ if (click) {
+ return click;
+ }
+ }
+ }
+ return this->onFindClickHandler(x, y);
+}
+
+void SkView::DoClickDown(Click* click, int x, int y)
+{
+ SkASSERT(click);
+
+ SkView* target = (SkView*)SkEventSink::FindSink(click->fTargetID);
+ if (target == NULL)
+ return;
+
+ click->fIOrig.set(x, y);
+ click->fICurr = click->fIPrev = click->fIOrig;
+
+ click->fOrig.iset(x, y);
+ target->globalToLocal(&click->fOrig);
+ click->fPrev = click->fCurr = click->fOrig;
+
+ click->fState = Click::kDown_State;
+ target->onClick(click);
+}
+
+void SkView::DoClickMoved(Click* click, int x, int y)
+{
+ SkASSERT(click);
+
+ SkView* target = (SkView*)SkEventSink::FindSink(click->fTargetID);
+ if (target == NULL)
+ return;
+
+ click->fIPrev = click->fICurr;
+ click->fICurr.set(x, y);
+
+ click->fPrev = click->fCurr;
+ click->fCurr.iset(x, y);
+ target->globalToLocal(&click->fCurr);
+
+ click->fState = Click::kMoved_State;
+ target->onClick(click);
+}
+
+void SkView::DoClickUp(Click* click, int x, int y)
+{
+ SkASSERT(click);
+
+ SkView* target = (SkView*)SkEventSink::FindSink(click->fTargetID);
+ if (target == NULL)
+ return;
+
+ click->fIPrev = click->fICurr;
+ click->fICurr.set(x, y);
+
+ click->fPrev = click->fCurr;
+ click->fCurr.iset(x, y);
+ target->globalToLocal(&click->fCurr);
+
+ click->fState = Click::kUp_State;
+ target->onClick(click);
+}
+
+//////////////////////////////////////////////////////////////////////
+
+void SkView::invokeLayout() {
+ SkView::Layout* layout = this->getLayout();
+
+ if (layout) {
+ layout->layoutChildren(this);
+ }
+}
+
+void SkView::onDraw(SkCanvas* canvas) {
+ Artist* artist = this->getArtist();
+
+ if (artist) {
+ artist->draw(this, canvas);
+ }
+}
+
+void SkView::onSizeChange() {}
+
+bool SkView::onSendClickToChildren(SkScalar x, SkScalar y) {
+ return true;
+}
+
+SkView::Click* SkView::onFindClickHandler(SkScalar x, SkScalar y) {
+ return NULL;
+}
+
+bool SkView::onClick(Click*) {
+ return false;
+}
+
+bool SkView::handleInval(const SkRect*) {
+ return false;
+}
+
+//////////////////////////////////////////////////////////////////////
+
+void SkView::getLocalBounds(SkRect* bounds) const
+{
+ if (bounds)
+ bounds->set(0, 0, fWidth, fHeight);
+}
+
+//////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////
+
+void SkView::detachFromParent_NoLayout()
+{
+ if (fParent == NULL)
+ return;
+
+ if (fContainsFocus)
+ (void)this->setFocusView(NULL);
+
+ this->inval(NULL);
+
+ SkView* next = NULL;
+
+ if (fNextSibling != this) // do we have any siblings
+ {
+ fNextSibling->fPrevSibling = fPrevSibling;
+ fPrevSibling->fNextSibling = fNextSibling;
+ next = fNextSibling;
+ }
+
+ if (fParent->fFirstChild == this)
+ fParent->fFirstChild = next;
+
+ fParent = fNextSibling = fPrevSibling = NULL;
+
+ this->unref();
+}
+
+void SkView::detachFromParent()
+{
+ SkView* parent = fParent;
+
+ if (parent)
+ {
+ this->detachFromParent_NoLayout();
+ parent->invokeLayout();
+ }
+}
+
+SkView* SkView::attachChildToBack(SkView* child)
+{
+ SkASSERT(child != this);
+
+ if (child == NULL || fFirstChild == child)
+ goto DONE;
+
+ child->ref();
+ child->detachFromParent_NoLayout();
+
+ if (fFirstChild == NULL)
+ {
+ child->fNextSibling = child;
+ child->fPrevSibling = child;
+ }
+ else
+ {
+ child->fNextSibling = fFirstChild;
+ child->fPrevSibling = fFirstChild->fPrevSibling;
+ fFirstChild->fPrevSibling->fNextSibling = child;
+ fFirstChild->fPrevSibling = child;
+ }
+
+ fFirstChild = child;
+ child->fParent = this;
+ child->inval(NULL);
+
+ this->invokeLayout();
+DONE:
+ return child;
+}
+
+SkView* SkView::attachChildToFront(SkView* child)
+{
+ SkASSERT(child != this);
+
+ if (child == NULL || (fFirstChild && fFirstChild->fPrevSibling == child))
+ goto DONE;
+
+ child->ref();
+ child->detachFromParent_NoLayout();
+
+ if (fFirstChild == NULL)
+ {
+ fFirstChild = child;
+ child->fNextSibling = child;
+ child->fPrevSibling = child;
+ }
+ else
+ {
+ child->fNextSibling = fFirstChild;
+ child->fPrevSibling = fFirstChild->fPrevSibling;
+ fFirstChild->fPrevSibling->fNextSibling = child;
+ fFirstChild->fPrevSibling = child;
+ }
+
+ child->fParent = this;
+ child->inval(NULL);
+
+ this->invokeLayout();
+DONE:
+ return child;
+}
+
+void SkView::detachAllChildren()
+{
+ while (fFirstChild)
+ fFirstChild->detachFromParent_NoLayout();
+}
+
+void SkView::globalToLocal(SkScalar x, SkScalar y, SkPoint* local) const
+{
+ SkASSERT(this);
+
+ if (local)
+ {
+ const SkView* view = this;
+ while (view)
+ {
+ x -= view->fLoc.fX;
+ y -= view->fLoc.fY;
+ view = view->fParent;
+ }
+ local->set(x, y);
+ }
+}
+
+//////////////////////////////////////////////////////////////////
+
+/* Even if the subclass overrides onInflate, they should always be
+ sure to call the inherited method, so that we get called.
+*/
+void SkView::onInflate(const SkDOM& dom, const SkDOM::Node* node)
+{
+ SkScalar x, y;
+
+ x = this->locX();
+ y = this->locY();
+ (void)dom.findScalar(node, "x", &x);
+ (void)dom.findScalar(node, "y", &y);
+ this->setLoc(x, y);
+
+ x = this->width();
+ y = this->height();
+ (void)dom.findScalar(node, "width", &x);
+ (void)dom.findScalar(node, "height", &y);
+ this->setSize(x, y);
+
+ // inflate the flags
+
+ static const char* gFlagNames[] = {
+ "visible", "enabled", "focusable", "flexH", "flexV"
+ };
+ SkASSERT(SK_ARRAY_COUNT(gFlagNames) == kFlagShiftCount);
+
+ bool b;
+ uint32_t flags = this->getFlags();
+ for (unsigned i = 0; i < SK_ARRAY_COUNT(gFlagNames); i++)
+ if (dom.findBool(node, gFlagNames[i], &b))
+ flags = SkSetClearShift(flags, b, i);
+ this->setFlags(flags);
+}
+
+void SkView::inflate(const SkDOM& dom, const SkDOM::Node* node)
+{
+ this->onInflate(dom, node);
+}
+
+void SkView::onPostInflate(const SkTDict<SkView*>&)
+{
+ // override in subclass as needed
+}
+
+void SkView::postInflate(const SkTDict<SkView*>& dict)
+{
+ this->onPostInflate(dict);
+
+ B2FIter iter(this);
+ SkView* child;
+ while ((child = iter.next()) != NULL)
+ child->postInflate(dict);
+}
+
+//////////////////////////////////////////////////////////////////
+
+SkView* SkView::sendEventToParents(const SkEvent& evt)
+{
+ SkView* parent = fParent;
+
+ while (parent)
+ {
+ if (parent->doEvent(evt))
+ return parent;
+ parent = parent->fParent;
+ }
+ return NULL;
+}
+
+SkView* SkView::sendQueryToParents(SkEvent* evt) {
+ SkView* parent = fParent;
+
+ while (parent) {
+ if (parent->doQuery(evt)) {
+ return parent;
+ }
+ parent = parent->fParent;
+ }
+ return NULL;
+}
+
+//////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////
+
+SkView::F2BIter::F2BIter(const SkView* parent)
+{
+ fFirstChild = parent ? parent->fFirstChild : NULL;
+ fChild = fFirstChild ? fFirstChild->fPrevSibling : NULL;
+}
+
+SkView* SkView::F2BIter::next()
+{
+ SkView* curr = fChild;
+
+ if (fChild)
+ {
+ if (fChild == fFirstChild)
+ fChild = NULL;
+ else
+ fChild = fChild->fPrevSibling;
+ }
+ return curr;
+}
+
+SkView::B2FIter::B2FIter(const SkView* parent)
+{
+ fFirstChild = parent ? parent->fFirstChild : NULL;
+ fChild = fFirstChild;
+}
+
+SkView* SkView::B2FIter::next()
+{
+ SkView* curr = fChild;
+
+ if (fChild)
+ {
+ SkView* next = fChild->fNextSibling;
+ if (next == fFirstChild)
+ next = NULL;
+ fChild = next;
+ }
+ return curr;
+}
+
+//////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////
+
+#ifdef SK_DEBUG
+
+static inline void show_if_nonzero(const char name[], SkScalar value)
+{
+ if (value)
+ SkDebugf("%s=\"%g\"", name, value/65536.);
+}
+
+static void tab(int level)
+{
+ for (int i = 0; i < level; i++)
+ SkDebugf(" ");
+}
+
+static void dumpview(const SkView* view, int level, bool recurse)
+{
+ tab(level);
+
+ SkDebugf("<view");
+ show_if_nonzero(" x", view->locX());
+ show_if_nonzero(" y", view->locY());
+ show_if_nonzero(" width", view->width());
+ show_if_nonzero(" height", view->height());
+
+ if (recurse)
+ {
+ SkView::B2FIter iter(view);
+ SkView* child;
+ bool noChildren = true;
+
+ while ((child = iter.next()) != NULL)
+ {
+ if (noChildren)
+ SkDebugf(">\n");
+ noChildren = false;
+ dumpview(child, level + 1, true);
+ }
+
+ if (!noChildren)
+ {
+ tab(level);
+ SkDebugf("</view>\n");
+ }
+ else
+ goto ONELINER;
+ }
+ else
+ {
+ ONELINER:
+ SkDebugf(" />\n");
+ }
+}
+
+void SkView::dump(bool recurse) const
+{
+ dumpview(this, 0, recurse);
+}
+
+#endif
diff --git a/src/views/SkViewInflate.cpp b/src/views/SkViewInflate.cpp
new file mode 100644
index 0000000..8f5489d
--- /dev/null
+++ b/src/views/SkViewInflate.cpp
@@ -0,0 +1,139 @@
+#include "SkViewInflate.h"
+#include "SkView.h"
+#include <stdio.h>
+
+SkViewInflate::SkViewInflate() : fIDs(kMinIDStrAlloc), fStrings(kMinIDStrAlloc)
+{
+}
+
+SkViewInflate::~SkViewInflate()
+{
+}
+
+void SkViewInflate::rInflate(const SkDOM& dom, const SkDOM::Node* node, SkView* parent)
+{
+ const char* str = dom.findAttr(node, "id");
+ if (str)
+ fIDs.set(str, parent);
+
+ const SkDOM::Node* child = dom.getFirstChild(node);
+ while (child)
+ {
+ SkView* view = this->createView(dom, child);
+ if (view)
+ {
+ this->rInflate(dom, child, view);
+ parent->attachChildToFront(view)->unref();
+ }
+ else
+ {
+ const char* name = dom.getName(child);
+ const char* target;
+
+ if (!strcmp(name, "listenTo") && (target = dom.findAttr(child, "target")) != NULL)
+ this->addIDStr(&fListenTo, parent, target);
+
+ if (!strcmp(name, "broadcastTo") && (target = dom.findAttr(child, "target")) != NULL)
+ this->addIDStr(&fBroadcastTo, parent, target);
+ }
+ child = dom.getNextSibling(child);
+ }
+
+ parent->setVisibleP(true);
+ this->inflateView(parent, dom, node);
+}
+
+void SkViewInflate::inflateView(SkView* view, const SkDOM& dom, const SkDOM::Node* node)
+{
+ // called after all of view's children have been instantiated.
+ // this may be overridden by a subclass, to load in layout or other helpers
+ // they should call through to us (INHERITED) before or after their patch
+ view->inflate(dom, node);
+}
+
+SkView* SkViewInflate::inflate(const SkDOM& dom, const SkDOM::Node* node, SkView* root)
+{
+ fIDs.reset();
+
+ if (root == NULL)
+ {
+ root = this->createView(dom, node);
+ if (root == NULL)
+ {
+ printf("createView returned NULL on <%s>\n", dom.getName(node));
+ return NULL;
+ }
+ }
+ this->rInflate(dom, node, root);
+
+ // resolve listeners and broadcasters
+ {
+ SkView* target;
+ const IDStr* iter = fListenTo.begin();
+ const IDStr* stop = fListenTo.end();
+ for (; iter < stop; iter++)
+ {
+ if (fIDs.find(iter->fStr, &target))
+ target->addListenerID(iter->fView->getSinkID());
+ }
+
+ iter = fBroadcastTo.begin();
+ stop = fBroadcastTo.end();
+ for (; iter < stop; iter++)
+ {
+ if (fIDs.find(iter->fStr, &target))
+ iter->fView->addListenerID(target->getSinkID());
+ }
+ }
+
+ // now that the tree is built, give everyone a shot at the ID dict
+ root->postInflate(fIDs);
+ return root;
+}
+
+SkView* SkViewInflate::inflate(const char xml[], size_t len, SkView* root)
+{
+ SkDOM dom;
+ const SkDOM::Node* node = dom.build(xml, len);
+
+ return node ? this->inflate(dom, node, root) : NULL;
+}
+
+SkView* SkViewInflate::findViewByID(const char id[]) const
+{
+ SkASSERT(id);
+ SkView* view;
+ return fIDs.find(id, &view) ? view : NULL;
+}
+
+SkView* SkViewInflate::createView(const SkDOM& dom, const SkDOM::Node* node)
+{
+ if (!strcmp(dom.getName(node), "view"))
+ return new SkView;
+ return NULL;
+}
+
+void SkViewInflate::addIDStr(SkTDArray<IDStr>* list, SkView* view, const char* str)
+{
+ size_t len = strlen(str) + 1;
+ IDStr* pair = list->append();
+ pair->fView = view;
+ pair->fStr = (char*)fStrings.alloc(len, SkChunkAlloc::kThrow_AllocFailType);
+ memcpy(pair->fStr, str, len);
+}
+
+#ifdef SK_DEBUG
+void SkViewInflate::dump() const
+{
+ const IDStr* iter = fListenTo.begin();
+ const IDStr* stop = fListenTo.end();
+ for (; iter < stop; iter++)
+ SkDebugf("inflate: listenTo(\"%s\")\n", iter->fStr);
+
+ iter = fBroadcastTo.begin();
+ stop = fBroadcastTo.end();
+ for (; iter < stop; iter++)
+ SkDebugf("inflate: broadcastFrom(\"%s\")\n", iter->fStr);
+}
+#endif
+
diff --git a/src/views/SkViewPriv.cpp b/src/views/SkViewPriv.cpp
new file mode 100644
index 0000000..b03ca8c
--- /dev/null
+++ b/src/views/SkViewPriv.cpp
@@ -0,0 +1,97 @@
+#include "SkViewPriv.h"
+
+//////////////////////////////////////////////////////////////////////
+
+void SkView::Artist::draw(SkView* view, SkCanvas* canvas)
+{
+ SkASSERT(view && canvas);
+ this->onDraw(view, canvas);
+}
+
+void SkView::Artist::inflate(const SkDOM& dom, const SkDOM::Node* node)
+{
+ SkASSERT(&dom && node);
+ this->onInflate(dom, node);
+}
+
+void SkView::Artist::onInflate(const SkDOM& dom, const SkDOM::Node* node)
+{
+ // subclass should override this as needed
+}
+
+SkView::Artist* SkView::getArtist() const
+{
+ Artist_SkTagList* rec = (Artist_SkTagList*)this->findTagList(kViewArtist_SkTagList);
+ SkASSERT(rec == NULL || rec->fArtist != NULL);
+
+ return rec ? rec->fArtist : NULL;
+}
+
+SkView::Artist* SkView::setArtist(Artist* obj)
+{
+ if (obj == NULL)
+ {
+ this->removeTagList(kViewArtist_SkTagList);
+ }
+ else // add/replace
+ {
+ Artist_SkTagList* rec = (Artist_SkTagList*)this->findTagList(kViewArtist_SkTagList);
+
+ if (rec)
+ SkRefCnt_SafeAssign(rec->fArtist, obj);
+ else
+ this->addTagList(new Artist_SkTagList(obj));
+ }
+ return obj;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+void SkView::Layout::layoutChildren(SkView* parent)
+{
+ SkASSERT(parent);
+ if (parent->width() > 0 && parent->height() > 0)
+ this->onLayoutChildren(parent);
+}
+
+void SkView::Layout::inflate(const SkDOM& dom, const SkDOM::Node* node)
+{
+ SkASSERT(&dom && node);
+ this->onInflate(dom, node);
+}
+
+void SkView::Layout::onInflate(const SkDOM& dom, const SkDOM::Node* node)
+{
+ // subclass should override this as needed
+}
+
+SkView::Layout* SkView::getLayout() const
+{
+ Layout_SkTagList* rec = (Layout_SkTagList*)this->findTagList(kViewLayout_SkTagList);
+ SkASSERT(rec == NULL || rec->fLayout != NULL);
+
+ return rec ? rec->fLayout : NULL;
+}
+
+SkView::Layout* SkView::setLayout(Layout* obj, bool invokeLayoutNow)
+{
+ if (obj == NULL)
+ {
+ this->removeTagList(kViewLayout_SkTagList);
+ }
+ else // add/replace
+ {
+ Layout_SkTagList* rec = (Layout_SkTagList*)this->findTagList(kViewLayout_SkTagList);
+
+ if (rec)
+ SkRefCnt_SafeAssign(rec->fLayout, obj);
+ else
+ this->addTagList(new Layout_SkTagList(obj));
+ }
+
+ if (invokeLayoutNow)
+ this->invokeLayout();
+
+ return obj;
+}
+
diff --git a/src/views/SkViewPriv.h b/src/views/SkViewPriv.h
new file mode 100644
index 0000000..06ce59b
--- /dev/null
+++ b/src/views/SkViewPriv.h
@@ -0,0 +1,38 @@
+#ifndef SkViewPriv_DEFINED
+#define SkViewPriv_DEFINED
+
+#include "SkView.h"
+#include "SkTagList.h"
+
+struct Layout_SkTagList : SkTagList {
+ SkView::Layout* fLayout;
+
+ Layout_SkTagList(SkView::Layout* layout)
+ : SkTagList(kViewLayout_SkTagList), fLayout(layout)
+ {
+ SkASSERT(layout);
+ layout->ref();
+ }
+ virtual ~Layout_SkTagList()
+ {
+ fLayout->unref();
+ }
+};
+
+struct Artist_SkTagList : SkTagList {
+ SkView::Artist* fArtist;
+
+ Artist_SkTagList(SkView::Artist* artist)
+ : SkTagList(kViewArtist_SkTagList), fArtist(artist)
+ {
+ SkASSERT(artist);
+ artist->ref();
+ }
+ virtual ~Artist_SkTagList()
+ {
+ fArtist->unref();
+ }
+};
+
+#endif
+
diff --git a/src/views/SkWidget.cpp b/src/views/SkWidget.cpp
new file mode 100644
index 0000000..4d055c4
--- /dev/null
+++ b/src/views/SkWidget.cpp
@@ -0,0 +1,323 @@
+#include "SkWidget.h"
+#include "SkCanvas.h"
+#include "SkInterpolator.h"
+#include "SkTime.h"
+#include "SkParsePaint.h"
+
+#if 0
+SkWidgetView::SkWidgetView(U32 flags) : SkView(flags)
+{
+}
+
+SkWidgetView::~SkWidgetView()
+{
+}
+
+const char* SkWidgetView::GetEventType()
+{
+ return "SkWidgetView";
+}
+
+/////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////
+
+class SkTextView::Interp {
+public:
+ Interp(const SkString& old, SkMSec now, SkMSec dur, AnimaDir dir) : fOldText(old), fInterp(1, 2)
+ {
+ SkScalar x = 0;
+ fInterp.setKeyFrame(0, now, &x, 0);
+ x = SK_Scalar1;
+ if (dir == kBackward_AnimDir)
+ x = -x;
+ fInterp.setKeyFrame(1, now + dur, &x);
+ }
+ bool draw(SkCanvas* canvas, const SkString& newText, SkScalar x, SkScalar y, SkPaint& paint)
+ {
+ SkScalar scale;
+
+ if (fInterp.timeToValues(SkTime::GetMSecs(), &scale) == SkInterpolator::kFreezeEnd_Result)
+ {
+ canvas->drawText(newText.c_str(), newText.size(), x, y, paint);
+ return false;
+ }
+ else
+ {
+ U8 alpha = paint.getAlpha();
+ SkScalar above, below;
+ (void)paint.measureText(NULL, 0, &above, &below);
+ SkScalar height = below - above;
+ SkScalar dy = SkScalarMul(height, scale);
+ if (scale < 0)
+ height = -height;
+
+ // draw the old
+ paint.setAlpha((U8)SkScalarMul(alpha, SK_Scalar1 - SkScalarAbs(scale)));
+ canvas->drawText(fOldText.c_str(), fOldText.size(), x, y - dy, paint);
+ // draw the new
+ paint.setAlpha((U8)SkScalarMul(alpha, SkScalarAbs(scale)));
+ canvas->drawText(newText.c_str(), newText.size(), x, y + height - dy, paint);
+ // restore the paint
+ paint.setAlpha(alpha);
+ return true;
+ }
+ }
+
+private:
+ SkString fOldText;
+ SkInterpolator fInterp;
+};
+
+SkTextView::SkTextView(U32 flags) : SkView(flags), fInterp(NULL), fDoInterp(false)
+{
+ fMargin.set(0, 0);
+}
+
+SkTextView::~SkTextView()
+{
+ delete fInterp;
+}
+
+void SkTextView::getText(SkString* str) const
+{
+ if (str)
+ str->set(fText);
+}
+
+void SkTextView::setText(const char text[], AnimaDir dir)
+{
+ if (!fText.equals(text))
+ {
+ SkString tmp(text);
+ this->privSetText(tmp, dir);
+ }
+}
+
+void SkTextView::setText(const char text[], size_t len, AnimaDir dir)
+{
+ if (!fText.equals(text))
+ {
+ SkString tmp(text, len);
+ this->privSetText(tmp, dir);
+ }
+}
+
+void SkTextView::setText(const SkString& src, AnimaDir dir)
+{
+ if (fText != src)
+ this->privSetText(src, dir);
+}
+
+void SkTextView::privSetText(const SkString& src, AnimaDir dir)
+{
+ SkASSERT(fText != src);
+
+ if (fDoInterp)
+ {
+ if (fInterp)
+ delete fInterp;
+ fInterp = new Interp(fText, SkTime::GetMSecs(), 500, dir);
+ }
+ fText = src;
+ this->inval(NULL);
+}
+
+/////////////////////////////////////////////////////////////////
+
+void SkTextView::getMargin(SkPoint* margin) const
+{
+ if (margin)
+ *margin = fMargin;
+}
+
+void SkTextView::setMargin(const SkPoint& margin)
+{
+ if (fMargin != margin)
+ {
+ fMargin = margin;
+ this->inval(NULL);
+ }
+}
+
+void SkTextView::onDraw(SkCanvas* canvas)
+{
+ this->INHERITED::onDraw(canvas);
+
+ if (fText.size() == 0)
+ return;
+
+ SkPaint::Align align = fPaint.getTextAlign();
+ SkScalar x, y;
+
+ switch (align) {
+ case SkPaint::kLeft_Align:
+ x = fMargin.fX;
+ break;
+ case SkPaint::kCenter_Align:
+ x = SkScalarHalf(this->width());
+ break;
+ default:
+ SkASSERT(align == SkPaint::kRight_Align);
+ x = this->width() - fMargin.fX;
+ break;
+ }
+
+ fPaint.measureText(NULL, 0, &y, NULL);
+ y = fMargin.fY - y;
+
+ if (fInterp)
+ {
+ if (fInterp->draw(canvas, fText, x, y, fPaint))
+ this->inval(NULL);
+ else
+ {
+ delete fInterp;
+ fInterp = NULL;
+ }
+ }
+ else
+ canvas->drawText(fText.c_str(), fText.size(), x, y, fPaint);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////
+
+void SkTextView::onInflate(const SkDOM& dom, const SkDOM::Node* node)
+{
+ this->INHERITED::onInflate(dom, node);
+
+ const char* text = dom.findAttr(node, "text");
+ if (text)
+ this->setText(text);
+
+ SkPoint margin;
+ if (dom.findScalars(node, "margin", (SkScalar*)&margin, 2))
+ this->setMargin(margin);
+ (void)dom.findBool(node, "do-interp", &fDoInterp);
+
+ SkPaint_Inflate(&fPaint, dom, node);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////
+
+SkSliderView::SkSliderView(U32 flags) : SkWidgetView(flags)
+{
+ fValue = 0;
+ fMax = 0;
+}
+
+static U16 actual_value(U16CPU value, U16CPU max)
+{
+ return SkToU16(SkMax32(0, SkMin32(value, max)));
+}
+
+void SkSliderView::setMax(U16CPU max)
+{
+ if (fMax != max)
+ {
+ fMax = SkToU16(max);
+ if (fValue > 0)
+ this->inval(NULL);
+ }
+}
+
+void SkSliderView::setValue(U16CPU value)
+{
+ if (fValue != value)
+ {
+ U16 prev = actual_value(fValue, fMax);
+ U16 next = actual_value(value, fMax);
+
+ fValue = SkToU16(value);
+ if (prev != next)
+ {
+ this->inval(NULL);
+
+ if (this->hasListeners())
+ {
+ SkEvent evt;
+
+ evt.setType(SkWidgetView::GetEventType());
+ evt.setFast32(this->getSinkID());
+ evt.setS32("sliderValue", next);
+ this->postToListeners(evt);
+ }
+ }
+ }
+}
+
+#include "SkGradientShader.h"
+
+static void setgrad(SkPaint* paint, const SkRect& r)
+{
+ SkPoint pts[2];
+ SkColor colors[2];
+
+#if 0
+ pts[0].set(r.fLeft, r.fTop);
+ pts[1].set(r.fLeft + r.height(), r.fBottom);
+#else
+ pts[0].set(r.fRight, r.fBottom);
+ pts[1].set(r.fRight - r.height(), r.fTop);
+#endif
+ colors[0] = SK_ColorBLUE;
+ colors[1] = SK_ColorWHITE;
+
+ paint->setShader(SkGradientShader::CreateLinear(pts, colors, NULL, 2, SkShader::kMirror_TileMode))->unref();
+}
+
+void SkSliderView::onDraw(SkCanvas* canvas)
+{
+ this->INHERITED::onDraw(canvas);
+
+ U16CPU value = SkMax32(0, SkMin32(fValue, fMax));
+
+ SkRect r;
+ SkPaint p;
+
+ r.set(0, 0, this->width(), this->height());
+
+ p.setAntiAliasOn(true);
+ p.setStyle(SkPaint::kStroke_Style);
+ p.setStrokeWidth(SK_Scalar1);
+ r.inset(SK_Scalar1/2, SK_Scalar1/2);
+ canvas->drawRect(r, p);
+
+ if (fMax)
+ {
+ SkFixed percent = SkFixedDiv(value, fMax);
+
+ r.inset(SK_Scalar1/2, SK_Scalar1/2);
+ r.fRight = r.fLeft + SkScalarMul(r.width(), SkFixedToScalar(percent));
+ p.setStyle(SkPaint::kFill_Style);
+ setgrad(&p, r);
+ canvas->drawRect(r, p);
+ }
+
+#if 0
+ r.set(0, 0, this->width(), this->height());
+ r.inset(SK_Scalar1, SK_Scalar1);
+ r.inset(r.width()/2, 0);
+ p.setColor(SK_ColorBLACK);
+ canvas->drawLine(*(SkPoint*)&r.fLeft, *(SkPoint*)&r.fRight, p);
+#endif
+}
+
+SkView::Click* SkSliderView::onFindClickHandler(SkScalar x, SkScalar y)
+{
+ return new Click(this);
+}
+
+bool SkSliderView::onClick(Click* click)
+{
+ if (fMax)
+ {
+ SkScalar percent = SkScalarDiv(click->fCurr.fX + SK_Scalar1, this->width() - SK_Scalar1*2);
+ percent = SkMaxScalar(0, SkMinScalar(percent, SK_Scalar1));
+ this->setValue(SkScalarRound(percent * fMax));
+ return true;
+ }
+ return false;
+}
+
+#endif
+
diff --git a/src/views/SkWidgetViews.cpp b/src/views/SkWidgetViews.cpp
new file mode 100644
index 0000000..2705307
--- /dev/null
+++ b/src/views/SkWidgetViews.cpp
@@ -0,0 +1,405 @@
+#include "SkWidgetViews.h"
+#include "SkAnimator.h"
+#include "SkCanvas.h"
+#include "SkPaint.h"
+#include "SkStream.h"
+#include "SkSystemEventTypes.h"
+
+#ifdef SK_DEBUG
+ static void assert_no_attr(const SkDOM& dom, const SkDOM::Node* node, const char attr[])
+ {
+ const char* value = dom.findAttr(node, attr);
+ if (value)
+ SkDebugf("unknown attribute %s=\"%s\"\n", attr, value);
+ }
+#else
+ #define assert_no_attr(dom, node, attr)
+#endif
+/*
+I have moved this to SkWidgetViews.h
+enum SkinEnum {
+ kButton_SkinEnum,
+ kProgress_SkinEnum,
+ kScroll_SkinEnum,
+ kStaticText_SkinEnum,
+
+ kSkinEnumCount
+};
+*/
+
+const char* get_skin_enum_path(SkinEnum se)
+{
+ SkASSERT((unsigned)se < kSkinEnumCount);
+
+ static const char* gSkinPaths[] = {
+ "common/default/default/skins/border3.xml",
+ "common/default/default/skins/button.xml",
+ "common/default/default/skins/progressBar.xml",
+ "common/default/default/skins/scrollBar.xml",
+ "common/default/default/skins/statictextpaint.xml"
+ };
+
+ return gSkinPaths[se];
+}
+
+void init_skin_anim(const char path[], SkAnimator* anim)
+{
+ SkASSERT(path && anim);
+
+ SkFILEStream stream(path);
+
+ if (!stream.isValid())
+ {
+ SkDEBUGF(("init_skin_anim: loading skin failed <%s>\n", path));
+ sk_throw();
+ }
+
+ if (!anim->decodeStream(&stream))
+ {
+ SkDEBUGF(("init_skin_anim: decoding skin failed <%s>\n", path));
+ sk_throw();
+ }
+}
+
+void init_skin_anim(SkinEnum se, SkAnimator* anim)
+{
+ init_skin_anim(get_skin_enum_path(se), anim);
+}
+
+void init_skin_paint(SkinEnum se, SkPaint* paint)
+{
+ SkASSERT(paint);
+
+ SkAnimator anim;
+ SkCanvas canvas;
+
+ init_skin_anim(se, &anim);
+ anim.draw(&canvas, paint, 0);
+}
+
+void inflate_paint(const SkDOM& dom, const SkDOM::Node* node, SkPaint* paint)
+{
+ SkASSERT(paint);
+
+ SkAnimator anim;
+ SkCanvas canvas;
+
+ if (!anim.decodeDOM(dom, node))
+ {
+ SkDEBUGF(("inflate_paint: decoding dom failed\n"));
+ SkDEBUGCODE(dom.dump(node);)
+ sk_throw();
+ }
+ anim.draw(&canvas, paint, 0);
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+
+SkWidgetView::SkWidgetView() : SkView(SkView::kFocusable_Mask | SkView::kEnabled_Mask)
+{
+}
+
+const char* SkWidgetView::getLabel() const
+{
+ return fLabel.c_str();
+}
+
+void SkWidgetView::getLabel(SkString* label) const
+{
+ if (label)
+ *label = fLabel;
+}
+
+void SkWidgetView::setLabel(const char label[])
+{
+ this->setLabel(label, label ? strlen(label) : 0);
+}
+
+void SkWidgetView::setLabel(const char label[], size_t len)
+{
+ if ((label == NULL && fLabel.size() != 0) || !fLabel.equals(label, len))
+ {
+ SkString tmp(label, len);
+
+ this->onLabelChange(fLabel.c_str(), tmp.c_str());
+ fLabel.swap(tmp);
+ }
+}
+
+void SkWidgetView::setLabel(const SkString& label)
+{
+ if (fLabel != label)
+ {
+ this->onLabelChange(fLabel.c_str(), label.c_str());
+ fLabel = label;
+ }
+}
+
+bool SkWidgetView::postWidgetEvent()
+{
+ if (!fEvent.isType(""))
+ {
+ SkEvent evt(fEvent); // make a copy since onPrepareWidgetEvent may edit the event
+
+ if (this->onPrepareWidgetEvent(&evt))
+ {
+ SkDEBUGCODE(evt.dump("SkWidgetView::postWidgetEvent");)
+
+ this->postToListeners(evt); // wonder if this should return true if there are > 0 listeners...
+ return true;
+ }
+ }
+ return false;
+}
+
+/*virtual*/ void SkWidgetView::onInflate(const SkDOM& dom, const SkDOM::Node* node)
+{
+ this->INHERITED::onInflate(dom, node);
+
+ const char* label = dom.findAttr(node, "label");
+ if (label)
+ this->setLabel(label);
+
+ if ((node = dom.getFirstChild(node, "event")) != NULL)
+ fEvent.inflate(dom, node);
+}
+
+/*virtual*/ void SkWidgetView::onLabelChange(const char oldLabel[], const char newLabel[])
+{
+ this->inval(NULL);
+}
+
+static const char gWidgetEventSinkIDSlotName[] = "sk-widget-sinkid-slot";
+
+/*virtual*/ bool SkWidgetView::onPrepareWidgetEvent(SkEvent* evt)
+{
+ evt->setS32(gWidgetEventSinkIDSlotName, this->getSinkID());
+ return true;
+}
+
+SkEventSinkID SkWidgetView::GetWidgetEventSinkID(const SkEvent& evt)
+{
+ int32_t sinkID;
+
+ return evt.findS32(gWidgetEventSinkIDSlotName, &sinkID) ? (SkEventSinkID)sinkID : 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+/*virtual*/ bool SkButtonView::onEvent(const SkEvent& evt)
+{
+ if (evt.isType(SK_EventType_Key) && evt.getFast32() == kOK_SkKey)
+ {
+ this->postWidgetEvent();
+ return true;
+ }
+ return this->INHERITED::onEvent(evt);
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+SkCheckButtonView::SkCheckButtonView() : fCheckState(kOff_CheckState)
+{
+}
+
+void SkCheckButtonView::setCheckState(CheckState state)
+{
+ SkASSERT((unsigned)state <= kUnknown_CheckState);
+
+ if (fCheckState != state)
+ {
+ this->onCheckStateChange(this->getCheckState(), state);
+ fCheckState = SkToU8(state);
+ }
+}
+
+/*virtual*/ void SkCheckButtonView::onCheckStateChange(CheckState oldState, CheckState newState)
+{
+ this->inval(NULL);
+}
+
+/*virtual*/ void SkCheckButtonView::onInflate(const SkDOM& dom, const SkDOM::Node* node)
+{
+ this->INHERITED::onInflate(dom, node);
+
+ int index = dom.findList(node, "check-state", "off,on,unknown");
+ if (index >= 0)
+ this->setCheckState((CheckState)index);
+}
+
+static const char gCheckStateSlotName[] = "sk-checkbutton-check-slot";
+
+/*virtual*/ bool SkCheckButtonView::onPrepareWidgetEvent(SkEvent* evt)
+{
+ // could check if we're "disabled", and return false...
+
+ evt->setS32(gCheckStateSlotName, this->getCheckState());
+ return true;
+}
+
+bool SkCheckButtonView::GetWidgetEventCheckState(const SkEvent& evt, CheckState* state)
+{
+ int32_t state32;
+
+ if (evt.findS32(gCheckStateSlotName, &state32))
+ {
+ if (state)
+ *state = (CheckState)state32;
+ return true;
+ }
+ return false;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include "SkTime.h"
+#include <stdio.h>
+
+class SkAnimButtonView : public SkButtonView {
+public:
+ SkAnimButtonView()
+ {
+ fAnim.setHostEventSink(this);
+ init_skin_anim(kButton_SkinEnum, &fAnim);
+ }
+
+protected:
+ virtual void onLabelChange(const char oldLabel[], const char newLabel[])
+ {
+ this->INHERITED::onLabelChange(oldLabel, newLabel);
+
+ SkEvent evt("user");
+ evt.setString("id", "setLabel");
+ evt.setString("LABEL", newLabel);
+ fAnim.doUserEvent(evt);
+ }
+
+ virtual void onFocusChange(bool gainFocus)
+ {
+ this->INHERITED::onFocusChange(gainFocus);
+
+ SkEvent evt("user");
+ evt.setString("id", "setFocus");
+ evt.setS32("FOCUS", gainFocus);
+ fAnim.doUserEvent(evt);
+ }
+
+ virtual void onSizeChange()
+ {
+ this->INHERITED::onSizeChange();
+
+ SkEvent evt("user");
+ evt.setString("id", "setDim");
+ evt.setScalar("dimX", this->width());
+ evt.setScalar("dimY", this->height());
+ fAnim.doUserEvent(evt);
+ }
+
+ virtual void onDraw(SkCanvas* canvas)
+ {
+ SkPaint paint;
+ SkAnimator::DifferenceType diff = fAnim.draw(canvas, &paint, SkTime::GetMSecs());
+
+ if (diff == SkAnimator::kDifferent)
+ this->inval(NULL);
+ else if (diff == SkAnimator::kPartiallyDifferent)
+ {
+ SkRect bounds;
+ fAnim.getInvalBounds(&bounds);
+ this->inval(&bounds);
+ }
+ }
+
+ virtual bool onEvent(const SkEvent& evt)
+ {
+ if (evt.isType(SK_EventType_Inval))
+ {
+ this->inval(NULL);
+ return true;
+ }
+ if (evt.isType("recommendDim"))
+ {
+ SkScalar height;
+
+ if (evt.findScalar("y", &height))
+ this->setHeight(height);
+ return true;
+ }
+ return this->INHERITED::onEvent(evt);
+ }
+
+ virtual bool onPrepareWidgetEvent(SkEvent* evt)
+ {
+ if (this->INHERITED::onPrepareWidgetEvent(evt))
+ {
+ SkEvent e("user");
+ e.setString("id", "handlePress");
+ (void)fAnim.doUserEvent(e);
+ return true;
+ }
+ return false;
+ }
+
+private:
+ SkAnimator fAnim;
+
+ typedef SkButtonView INHERITED;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////
+
+SkView* SkWidgetFactory(const char name[])
+{
+ if (name == NULL)
+ return NULL;
+
+ // must be in the same order as the SkSkinWidgetEnum is declared
+ static const char* gNames[] = {
+ "sk-border",
+ "sk-button",
+ "sk-image",
+ "sk-list",
+ "sk-progress",
+ "sk-scroll",
+ "sk-text"
+
+ };
+
+ for (size_t i = 0; i < SK_ARRAY_COUNT(gNames); i++)
+ if (!strcmp(gNames[i], name))
+ return SkWidgetFactory((SkWidgetEnum)i);
+
+ return NULL;
+}
+
+#include "SkImageView.h"
+#include "SkProgressBarView.h"
+#include "SkScrollBarView.h"
+#include "SkBorderView.h"
+
+SkView* SkWidgetFactory(SkWidgetEnum sw)
+{
+ switch (sw) {
+ case kBorder_WidgetEnum:
+ return new SkBorderView;
+ case kButton_WidgetEnum:
+ return new SkAnimButtonView;
+ case kImage_WidgetEnum:
+ return new SkImageView;
+ case kList_WidgetEnum:
+ return new SkListView;
+ case kProgress_WidgetEnum:
+ return new SkProgressBarView;
+ case kScroll_WidgetEnum:
+ return new SkScrollBarView;
+ case kText_WidgetEnum:
+ return new SkStaticTextView;
+ default:
+ SkASSERT(!"unknown enum passed to SkWidgetFactory");
+ break;
+ }
+ return NULL;
+}
diff --git a/src/views/SkWidgets.cpp b/src/views/SkWidgets.cpp
new file mode 100644
index 0000000..dba9ab3
--- /dev/null
+++ b/src/views/SkWidgets.cpp
@@ -0,0 +1,554 @@
+#include "SkWidget.h"
+#include "SkCanvas.h"
+#include "SkKey.h"
+#include "SkParsePaint.h"
+#include "SkSystemEventTypes.h"
+#include "SkTextBox.h"
+
+#if 0
+
+#ifdef SK_DEBUG
+ static void assert_no_attr(const SkDOM& dom, const SkDOM::Node* node, const char attr[])
+ {
+ const char* value = dom.findAttr(node, attr);
+ if (value)
+ SkDebugf("unknown attribute %s=\"%s\"\n", attr, value);
+ }
+#else
+ #define assert_no_attr(dom, node, attr)
+#endif
+
+#include "SkAnimator.h"
+#include "SkTime.h"
+
+///////////////////////////////////////////////////////////////////////////////
+
+enum SkinType {
+ kPushButton_SkinType,
+ kStaticText_SkinType,
+
+ kSkinTypeCount
+};
+
+struct SkinSuite {
+ SkinSuite();
+ ~SkinSuite()
+ {
+ for (int i = 0; i < kSkinTypeCount; i++)
+ delete fAnimators[i];
+ }
+
+ SkAnimator* get(SkinType);
+
+private:
+ SkAnimator* fAnimators[kSkinTypeCount];
+};
+
+SkinSuite::SkinSuite()
+{
+ static const char kSkinPath[] = "skins/";
+
+ static const char* gSkinNames[] = {
+ "pushbutton_skin.xml",
+ "statictext_skin.xml"
+ };
+
+ for (unsigned i = 0; i < SK_ARRAY_COUNT(gSkinNames); i++)
+ {
+ size_t len = strlen(gSkinNames[i]);
+ SkString path(sizeof(kSkinPath) - 1 + len);
+
+ memcpy(path.writable_str(), kSkinPath, sizeof(kSkinPath) - 1);
+ memcpy(path.writable_str() + sizeof(kSkinPath) - 1, gSkinNames[i], len);
+
+ fAnimators[i] = new SkAnimator;
+ if (!fAnimators[i]->decodeURI(path.c_str()))
+ {
+ delete fAnimators[i];
+ fAnimators[i] = NULL;
+ }
+ }
+}
+
+SkAnimator* SkinSuite::get(SkinType st)
+{
+ SkASSERT((unsigned)st < kSkinTypeCount);
+ return fAnimators[st];
+}
+
+static SkinSuite* gSkinSuite;
+
+static SkAnimator* get_skin_animator(SkinType st)
+{
+#if 0
+ if (gSkinSuite == NULL)
+ gSkinSuite = new SkinSuite;
+ return gSkinSuite->get(st);
+#else
+ return NULL;
+#endif
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void SkWidget::Init()
+{
+}
+
+void SkWidget::Term()
+{
+ delete gSkinSuite;
+}
+
+void SkWidget::onEnabledChange()
+{
+ this->inval(NULL);
+}
+
+void SkWidget::postWidgetEvent()
+{
+ if (!fEvent.isType("") && this->hasListeners())
+ {
+ this->prepareWidgetEvent(&fEvent);
+ this->postToListeners(fEvent);
+ }
+}
+
+void SkWidget::prepareWidgetEvent(SkEvent*)
+{
+ // override in subclass to add any additional fields before posting
+}
+
+void SkWidget::onInflate(const SkDOM& dom, const SkDOM::Node* node)
+{
+ this->INHERITED::onInflate(dom, node);
+
+ if ((node = dom.getFirstChild(node, "event")) != NULL)
+ fEvent.inflate(dom, node);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+size_t SkHasLabelWidget::getLabel(SkString* str) const
+{
+ if (str)
+ *str = fLabel;
+ return fLabel.size();
+}
+
+size_t SkHasLabelWidget::getLabel(char buffer[]) const
+{
+ if (buffer)
+ memcpy(buffer, fLabel.c_str(), fLabel.size());
+ return fLabel.size();
+}
+
+void SkHasLabelWidget::setLabel(const SkString& str)
+{
+ this->setLabel(str.c_str(), str.size());
+}
+
+void SkHasLabelWidget::setLabel(const char label[])
+{
+ this->setLabel(label, strlen(label));
+}
+
+void SkHasLabelWidget::setLabel(const char label[], size_t len)
+{
+ if (!fLabel.equals(label, len))
+ {
+ fLabel.set(label, len);
+ this->onLabelChange();
+ }
+}
+
+void SkHasLabelWidget::onLabelChange()
+{
+ // override in subclass
+}
+
+void SkHasLabelWidget::onInflate(const SkDOM& dom, const SkDOM::Node* node)
+{
+ this->INHERITED::onInflate(dom, node);
+
+ const char* text = dom.findAttr(node, "label");
+ if (text)
+ this->setLabel(text);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////
+
+void SkButtonWidget::setButtonState(State state)
+{
+ if (fState != state)
+ {
+ fState = state;
+ this->onButtonStateChange();
+ }
+}
+
+void SkButtonWidget::onButtonStateChange()
+{
+ this->inval(NULL);
+}
+
+void SkButtonWidget::onInflate(const SkDOM& dom, const SkDOM::Node* node)
+{
+ this->INHERITED::onInflate(dom, node);
+
+ int index;
+ if ((index = dom.findList(node, "buttonState", "off,on,unknown")) >= 0)
+ this->setButtonState((State)index);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////
+
+bool SkPushButtonWidget::onEvent(const SkEvent& evt)
+{
+ if (evt.isType(SK_EventType_Key) && evt.getFast32() == kOK_SkKey)
+ {
+ this->postWidgetEvent();
+ return true;
+ }
+ return this->INHERITED::onEvent(evt);
+}
+
+static const char* computeAnimatorState(int enabled, int focused, SkButtonWidget::State state)
+{
+ if (!enabled)
+ return "disabled";
+ if (state == SkButtonWidget::kOn_State)
+ {
+ SkASSERT(focused);
+ return "enabled-pressed";
+ }
+ if (focused)
+ return "enabled-focused";
+ return "enabled";
+}
+
+#include "SkBlurMaskFilter.h"
+#include "SkEmbossMaskFilter.h"
+
+static void create_emboss(SkPaint* paint, SkScalar radius, bool focus, bool pressed)
+{
+ SkEmbossMaskFilter::Light light;
+
+ light.fDirection[0] = SK_Scalar1/2;
+ light.fDirection[1] = SK_Scalar1/2;
+ light.fDirection[2] = SK_Scalar1/3;
+ light.fAmbient = 0x48;
+ light.fSpecular = 0x80;
+
+ if (pressed)
+ {
+ light.fDirection[0] = -light.fDirection[0];
+ light.fDirection[1] = -light.fDirection[1];
+ }
+ if (focus)
+ light.fDirection[2] += SK_Scalar1/4;
+
+ paint->setMaskFilter(new SkEmbossMaskFilter(light, radius))->unref();
+}
+
+void SkPushButtonWidget::onDraw(SkCanvas* canvas)
+{
+ this->INHERITED::onDraw(canvas);
+
+ SkString label;
+ this->getLabel(&label);
+
+ SkAnimator* anim = get_skin_animator(kPushButton_SkinType);
+
+ if (anim)
+ {
+ SkEvent evt("user");
+
+ evt.setString("id", "prime");
+ evt.setScalar("prime-width", this->width());
+ evt.setScalar("prime-height", this->height());
+ evt.setString("prime-text", label);
+ evt.setString("prime-state", computeAnimatorState(this->isEnabled(), this->hasFocus(), this->getButtonState()));
+
+ (void)anim->doUserEvent(evt);
+ SkPaint paint;
+ anim->draw(canvas, &paint, SkTime::GetMSecs());
+ }
+ else
+ {
+ SkRect r;
+ SkPaint p;
+
+ r.set(0, 0, this->width(), this->height());
+ p.setAntiAliasOn(true);
+ p.setColor(SK_ColorBLUE);
+ create_emboss(&p, SkIntToScalar(12)/5, this->hasFocus(), this->getButtonState() == kOn_State);
+ canvas->drawRoundRect(r, SkScalarHalf(this->height()), SkScalarHalf(this->height()), p);
+ p.setMaskFilter(NULL);
+
+ p.setTextAlign(SkPaint::kCenter_Align);
+
+ SkTextBox box;
+ box.setMode(SkTextBox::kOneLine_Mode);
+ box.setSpacingAlign(SkTextBox::kCenter_SpacingAlign);
+ box.setBox(0, 0, this->width(), this->height());
+
+// if (this->getButtonState() == kOn_State)
+// p.setColor(SK_ColorRED);
+// else
+ p.setColor(SK_ColorWHITE);
+
+ box.draw(canvas, label.c_str(), label.size(), p);
+ }
+}
+
+SkView::Click* SkPushButtonWidget::onFindClickHandler(SkScalar x, SkScalar y)
+{
+ this->acceptFocus();
+ return new Click(this);
+}
+
+bool SkPushButtonWidget::onClick(Click* click)
+{
+ SkRect r;
+ State state = kOff_State;
+
+ this->getLocalBounds(&r);
+ if (r.contains(click->fCurr))
+ {
+ if (click->fState == Click::kUp_State)
+ this->postWidgetEvent();
+ else
+ state = kOn_State;
+ }
+ this->setButtonState(state);
+ return true;
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+
+SkStaticTextView::SkStaticTextView(U32 flags) : SkView(flags)
+{
+ fMargin.set(0, 0);
+ fMode = kFixedSize_Mode;
+ fSpacingAlign = SkTextBox::kStart_SpacingAlign;
+}
+
+SkStaticTextView::~SkStaticTextView()
+{
+}
+
+void SkStaticTextView::computeSize()
+{
+ if (fMode == kAutoWidth_Mode)
+ {
+ SkScalar width = fPaint.measureText(fText.c_str(), fText.size(), NULL, NULL);
+ this->setWidth(width + fMargin.fX * 2);
+ }
+ else if (fMode == kAutoHeight_Mode)
+ {
+ SkScalar width = this->width() - fMargin.fX * 2;
+ int lines = width > 0 ? SkTextLineBreaker::CountLines(fText.c_str(), fText.size(), fPaint, width) : 0;
+
+ SkScalar before, after;
+ (void)fPaint.measureText(0, NULL, &before, &after);
+
+ this->setHeight(lines * (after - before) + fMargin.fY * 2);
+ }
+}
+
+void SkStaticTextView::setMode(Mode mode)
+{
+ SkASSERT((unsigned)mode < kModeCount);
+
+ if (fMode != mode)
+ {
+ fMode = SkToU8(mode);
+ this->computeSize();
+ }
+}
+
+void SkStaticTextView::setSpacingAlign(SkTextBox::SpacingAlign align)
+{
+ fSpacingAlign = SkToU8(align);
+ this->inval(NULL);
+}
+
+void SkStaticTextView::getMargin(SkPoint* margin) const
+{
+ if (margin)
+ *margin = fMargin;
+}
+
+void SkStaticTextView::setMargin(SkScalar dx, SkScalar dy)
+{
+ if (fMargin.fX != dx || fMargin.fY != dy)
+ {
+ fMargin.set(dx, dy);
+ this->computeSize();
+ this->inval(NULL);
+ }
+}
+
+size_t SkStaticTextView::getText(SkString* text) const
+{
+ if (text)
+ *text = fText;
+ return fText.size();
+}
+
+size_t SkStaticTextView::getText(char text[]) const
+{
+ if (text)
+ memcpy(text, fText.c_str(), fText.size());
+ return fText.size();
+}
+
+void SkStaticTextView::setText(const SkString& text)
+{
+ this->setText(text.c_str(), text.size());
+}
+
+void SkStaticTextView::setText(const char text[])
+{
+ this->setText(text, strlen(text));
+}
+
+void SkStaticTextView::setText(const char text[], size_t len)
+{
+ if (!fText.equals(text, len))
+ {
+ fText.set(text, len);
+ this->computeSize();
+ this->inval(NULL);
+ }
+}
+
+void SkStaticTextView::getPaint(SkPaint* paint) const
+{
+ if (paint)
+ *paint = fPaint;
+}
+
+void SkStaticTextView::setPaint(const SkPaint& paint)
+{
+ if (fPaint != paint)
+ {
+ fPaint = paint;
+ this->computeSize();
+ this->inval(NULL);
+ }
+}
+
+void SkStaticTextView::onDraw(SkCanvas* canvas)
+{
+ this->INHERITED::onDraw(canvas);
+
+ if (fText.isEmpty())
+ return;
+
+ SkTextBox box;
+
+ box.setMode(fMode == kAutoWidth_Mode ? SkTextBox::kOneLine_Mode : SkTextBox::kLineBreak_Mode);
+ box.setSpacingAlign(this->getSpacingAlign());
+ box.setBox(fMargin.fX, fMargin.fY, this->width() - fMargin.fX, this->height() - fMargin.fY);
+ box.draw(canvas, fText.c_str(), fText.size(), fPaint);
+}
+
+void SkStaticTextView::onInflate(const SkDOM& dom, const SkDOM::Node* node)
+{
+ this->INHERITED::onInflate(dom, node);
+
+ int index;
+ if ((index = dom.findList(node, "mode", "fixed,auto-width,auto-height")) >= 0)
+ this->setMode((Mode)index);
+ else
+ assert_no_attr(dom, node, "mode");
+
+ if ((index = dom.findList(node, "spacing-align", "start,center,end")) >= 0)
+ this->setSpacingAlign((SkTextBox::SpacingAlign)index);
+ else
+ assert_no_attr(dom, node, "mode");
+
+ SkScalar s[2];
+ if (dom.findScalars(node, "margin", s, 2))
+ this->setMargin(s[0], s[1]);
+ else
+ assert_no_attr(dom, node, "margin");
+
+ const char* text = dom.findAttr(node, "text");
+ if (text)
+ this->setText(text);
+
+ if ((node = dom.getFirstChild(node, "paint")) != NULL)
+ SkPaint_Inflate(&fPaint, dom, node);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include "SkImageDecoder.h"
+
+SkBitmapView::SkBitmapView(U32 flags) : SkView(flags)
+{
+}
+
+SkBitmapView::~SkBitmapView()
+{
+}
+
+bool SkBitmapView::getBitmap(SkBitmap* bitmap) const
+{
+ if (bitmap)
+ *bitmap = fBitmap;
+ return fBitmap.getConfig() != SkBitmap::kNo_Config;
+}
+
+void SkBitmapView::setBitmap(const SkBitmap* bitmap, bool viewOwnsPixels)
+{
+ if (bitmap)
+ {
+ fBitmap = *bitmap;
+ fBitmap.setOwnsPixels(viewOwnsPixels);
+ }
+}
+
+bool SkBitmapView::loadBitmapFromFile(const char path[])
+{
+ SkBitmap bitmap;
+
+ if (SkImageDecoder::DecodeFile(path, &bitmap))
+ {
+ this->setBitmap(&bitmap, true);
+ bitmap.setOwnsPixels(false);
+ return true;
+ }
+ return false;
+}
+
+void SkBitmapView::onDraw(SkCanvas* canvas)
+{
+ if (fBitmap.getConfig() != SkBitmap::kNo_Config &&
+ fBitmap.width() && fBitmap.height())
+ {
+ SkAutoCanvasRestore restore(canvas, true);
+ SkPaint p;
+
+ p.setFilterType(SkPaint::kBilinear_FilterType);
+ canvas->scale( this->width() / fBitmap.width(),
+ this->height() / fBitmap.height(),
+ 0, 0);
+ canvas->drawBitmap(fBitmap, 0, 0, p);
+ }
+}
+
+void SkBitmapView::onInflate(const SkDOM& dom, const SkDOM::Node* node)
+{
+ this->INHERITED::onInflate(dom, node);
+
+ const char* src = dom.findAttr(node, "src");
+ if (src)
+ (void)this->loadBitmapFromFile(src);
+}
+
+#endif
+
diff --git a/src/views/SkWindow.cpp b/src/views/SkWindow.cpp
new file mode 100644
index 0000000..db4faee
--- /dev/null
+++ b/src/views/SkWindow.cpp
@@ -0,0 +1,412 @@
+#include "SkWindow.h"
+#include "SkCanvas.h"
+#include "SkDevice.h"
+#include "SkOSMenu.h"
+#include "SkSystemEventTypes.h"
+#include "SkTime.h"
+
+#define SK_EventDelayInval "\xd" "n" "\xa" "l"
+
+#define TEST_BOUNDERx
+
+#include "SkBounder.h"
+class test_bounder : public SkBounder {
+public:
+ test_bounder(const SkBitmap& bm) : fCanvas(bm) {}
+protected:
+ virtual bool onIRect(const SkIRect& r)
+ {
+ SkRect rr;
+
+ rr.set(SkIntToScalar(r.fLeft), SkIntToScalar(r.fTop),
+ SkIntToScalar(r.fRight), SkIntToScalar(r.fBottom));
+
+ SkPaint p;
+
+ p.setStyle(SkPaint::kStroke_Style);
+ p.setColor(SK_ColorYELLOW);
+
+#if 0
+ rr.inset(SK_ScalarHalf, SK_ScalarHalf);
+#else
+ rr.inset(-SK_ScalarHalf, -SK_ScalarHalf);
+#endif
+
+ fCanvas.drawRect(rr, p);
+ return true;
+ }
+private:
+ SkCanvas fCanvas;
+};
+
+SkWindow::SkWindow() : fFocusView(NULL)
+{
+ fClick = NULL;
+ fWaitingOnInval = false;
+
+#ifdef SK_BUILD_FOR_WINCE
+ fConfig = SkBitmap::kRGB_565_Config;
+#else
+ fConfig = SkBitmap::kARGB_8888_Config;
+#endif
+
+ fMatrix.reset();
+}
+
+SkWindow::~SkWindow()
+{
+ delete fClick;
+
+ fMenus.deleteAll();
+}
+
+void SkWindow::setMatrix(const SkMatrix& matrix) {
+ if (fMatrix != matrix) {
+ fMatrix = matrix;
+ this->inval(NULL);
+ }
+}
+
+void SkWindow::preConcat(const SkMatrix& matrix) {
+ SkMatrix m;
+ m.setConcat(fMatrix, matrix);
+ this->setMatrix(m);
+}
+
+void SkWindow::postConcat(const SkMatrix& matrix) {
+ SkMatrix m;
+ m.setConcat(matrix, fMatrix);
+ this->setMatrix(m);
+}
+
+void SkWindow::setConfig(SkBitmap::Config config)
+{
+ this->resize(fBitmap.width(), fBitmap.height(), config);
+}
+
+void SkWindow::resize(int width, int height, SkBitmap::Config config)
+{
+ if (config == SkBitmap::kNo_Config)
+ config = fConfig;
+
+ if (width != fBitmap.width() || height != fBitmap.height() || config != fConfig)
+ {
+ fConfig = config;
+ fBitmap.setConfig(config, width, height);
+ fBitmap.allocPixels();
+ fBitmap.setIsOpaque(true);
+
+ this->setSize(SkIntToScalar(width), SkIntToScalar(height));
+ this->inval(NULL);
+ }
+}
+
+void SkWindow::eraseARGB(U8CPU a, U8CPU r, U8CPU g, U8CPU b)
+{
+ fBitmap.eraseARGB(a, r, g, b);
+}
+
+void SkWindow::eraseRGB(U8CPU r, U8CPU g, U8CPU b)
+{
+ fBitmap.eraseRGB(r, g, b);
+}
+
+bool SkWindow::handleInval(const SkRect* localR)
+{
+ SkIRect ir;
+
+ if (localR) {
+ SkRect devR;
+ SkMatrix inverse;
+ if (!fMatrix.invert(&inverse)) {
+ return false;
+ }
+ fMatrix.mapRect(&devR, *localR);
+ devR.round(&ir);
+ } else {
+ ir.set(0, 0,
+ SkScalarRound(this->width()),
+ SkScalarRound(this->height()));
+ }
+ fDirtyRgn.op(ir, SkRegion::kUnion_Op);
+
+ this->onHandleInval(ir);
+ return true;
+}
+
+void SkWindow::forceInvalAll() {
+ fDirtyRgn.setRect(0, 0,
+ SkScalarCeil(this->width()),
+ SkScalarCeil(this->height()));
+}
+
+#if defined(SK_BUILD_FOR_WINCE) && defined(USE_GX_SCREEN)
+ #include <windows.h>
+ #include <gx.h>
+ extern GXDisplayProperties gDisplayProps;
+#endif
+
+#ifdef SK_SIMULATE_FAILED_MALLOC
+extern bool gEnableControlledThrow;
+#endif
+
+bool SkWindow::update(SkIRect* updateArea, SkCanvas* canvas)
+{
+ if (!fDirtyRgn.isEmpty())
+ {
+ SkBitmap bm = this->getBitmap();
+
+#if defined(SK_BUILD_FOR_WINCE) && defined(USE_GX_SCREEN)
+ char* buffer = (char*)GXBeginDraw();
+ SkASSERT(buffer);
+
+ RECT rect;
+ GetWindowRect((HWND)((SkOSWindow*)this)->getHWND(), &rect);
+ buffer += rect.top * gDisplayProps.cbyPitch + rect.left * gDisplayProps.cbxPitch;
+
+ bm.setPixels(buffer);
+#endif
+
+ SkCanvas rasterCanvas;
+ SkDevice* device;
+
+ if (NULL == canvas) {
+ canvas = &rasterCanvas;
+ device = new SkDevice(canvas, bm, false);
+ canvas->setDevice(device)->unref();
+ } else {
+ canvas->setBitmapDevice(bm);
+ }
+
+ canvas->clipRegion(fDirtyRgn);
+ if (updateArea)
+ *updateArea = fDirtyRgn.getBounds();
+
+ SkAutoCanvasRestore acr(canvas, true);
+ canvas->concat(fMatrix);
+
+ // empty this now, so we can correctly record any inval calls that
+ // might be made during the draw call.
+ fDirtyRgn.setEmpty();
+
+#ifdef TEST_BOUNDER
+ test_bounder b(bm);
+ canvas->setBounder(&b);
+#endif
+#ifdef SK_SIMULATE_FAILED_MALLOC
+ gEnableControlledThrow = true;
+#endif
+#ifdef SK_BUILD_FOR_WIN32
+ //try {
+ this->draw(canvas);
+ //}
+ //catch (...) {
+ //}
+#else
+ this->draw(canvas);
+#endif
+#ifdef SK_SIMULATE_FAILED_MALLOC
+ gEnableControlledThrow = false;
+#endif
+#ifdef TEST_BOUNDER
+ canvas->setBounder(NULL);
+#endif
+
+#if defined(SK_BUILD_FOR_WINCE) && defined(USE_GX_SCREEN)
+ GXEndDraw();
+#endif
+
+ return true;
+ }
+ return false;
+}
+
+bool SkWindow::handleChar(SkUnichar uni)
+{
+ if (this->onHandleChar(uni))
+ return true;
+
+ SkView* focus = this->getFocusView();
+ if (focus == NULL)
+ focus = this;
+
+ SkEvent evt(SK_EventType_Unichar);
+ evt.setFast32(uni);
+ return focus->doEvent(evt);
+}
+
+bool SkWindow::handleKey(SkKey key)
+{
+ if (key == kNONE_SkKey)
+ return false;
+
+ if (this->onHandleKey(key))
+ return true;
+
+ // send an event to the focus-view
+ {
+ SkView* focus = this->getFocusView();
+ if (focus == NULL)
+ focus = this;
+
+ SkEvent evt(SK_EventType_Key);
+ evt.setFast32(key);
+ if (focus->doEvent(evt))
+ return true;
+ }
+
+ if (key == kUp_SkKey || key == kDown_SkKey)
+ {
+ if (this->moveFocus(key == kUp_SkKey ? kPrev_FocusDirection : kNext_FocusDirection) == NULL)
+ this->onSetFocusView(NULL);
+ return true;
+ }
+ return false;
+}
+
+bool SkWindow::handleKeyUp(SkKey key)
+{
+ if (key == kNONE_SkKey)
+ return false;
+
+ if (this->onHandleKeyUp(key))
+ return true;
+
+ //send an event to the focus-view
+ {
+ SkView* focus = this->getFocusView();
+ if (focus == NULL)
+ focus = this;
+
+ //should this one be the same?
+ SkEvent evt(SK_EventType_KeyUp);
+ evt.setFast32(key);
+ if (focus->doEvent(evt))
+ return true;
+ }
+ return false;
+}
+
+void SkWindow::addMenu(SkOSMenu* menu)
+{
+ *fMenus.append() = menu;
+ this->onAddMenu(menu);
+}
+
+void SkWindow::setTitle(const char title[]) {
+ if (NULL == title) {
+ title = "";
+ }
+ fTitle.set(title);
+ this->onSetTitle(title);
+}
+
+bool SkWindow::handleMenu(uint32_t cmd)
+{
+ for (int i = 0; i < fMenus.count(); i++)
+ {
+ SkEvent* evt = fMenus[i]->createEvent(cmd);
+ if (evt)
+ {
+ evt->post(this->getSinkID());
+ return true;
+ }
+ }
+ return false;
+}
+
+//////////////////////////////////////////////////////////////////////
+
+bool SkWindow::onEvent(const SkEvent& evt)
+{
+ if (evt.isType(SK_EventDelayInval))
+ {
+ SkRegion::Iterator iter(fDirtyRgn);
+
+ for (; !iter.done(); iter.next())
+ this->onHandleInval(iter.rect());
+ fWaitingOnInval = false;
+ return true;
+ }
+ return this->INHERITED::onEvent(evt);
+}
+
+bool SkWindow::onGetFocusView(SkView** focus) const
+{
+ if (focus)
+ *focus = fFocusView;
+ return true;
+}
+
+bool SkWindow::onSetFocusView(SkView* focus)
+{
+ if (fFocusView != focus)
+ {
+ if (fFocusView)
+ fFocusView->onFocusChange(false);
+ fFocusView = focus;
+ if (focus)
+ focus->onFocusChange(true);
+ }
+ return true;
+}
+
+//////////////////////////////////////////////////////////////////////
+
+void SkWindow::onHandleInval(const SkIRect&)
+{
+}
+
+bool SkWindow::onHandleChar(SkUnichar)
+{
+ return false;
+}
+
+bool SkWindow::onHandleKey(SkKey key)
+{
+ return false;
+}
+
+bool SkWindow::onHandleKeyUp(SkKey key)
+{
+ return false;
+}
+
+bool SkWindow::handleClick(int x, int y, Click::State state) {
+ return this->onDispatchClick(x, y, state);
+}
+
+bool SkWindow::onDispatchClick(int x, int y, Click::State state) {
+ bool handled = false;
+
+ switch (state) {
+ case Click::kDown_State:
+ if (fClick)
+ delete fClick;
+ fClick = this->findClickHandler(SkIntToScalar(x), SkIntToScalar(y));
+ if (fClick)
+ {
+ SkView::DoClickDown(fClick, x, y);
+ handled = true;
+ }
+ break;
+ case Click::kMoved_State:
+ if (fClick)
+ {
+ SkView::DoClickMoved(fClick, x, y);
+ handled = true;
+ }
+ break;
+ case Click::kUp_State:
+ if (fClick)
+ {
+ SkView::DoClickUp(fClick, x, y);
+ delete fClick;
+ fClick = NULL;
+ handled = true;
+ }
+ break;
+ }
+ return handled;
+}
+
diff --git a/src/views/views_files.mk b/src/views/views_files.mk
new file mode 100644
index 0000000..9c5e9e0
--- /dev/null
+++ b/src/views/views_files.mk
@@ -0,0 +1,26 @@
+SOURCE := \
+ SkEvent.cpp \
+ SkEventSink.cpp \
+ SkOSMenu.cpp \
+ SkTagList.cpp \
+ SkView.cpp \
+ SkViewPriv.cpp \
+ SkWindow.cpp \
+ SkTouchGesture.cpp
+# SkBGViewArtist.cpp \
+ SkMetaData.cpp \
+ SkListView.cpp \
+ SkListWidget.cpp \
+ SkParsePaint.cpp \
+ SkProgressBarView.cpp \
+ SkProgressView.cpp \
+ SkScrollBarView.cpp \
+ SkStackViewLayout.cpp \
+ SkStaticTextView.cpp \
+ SkTextBox.cpp \
+ SkViewInflate.cpp \
+ SkWidget.cpp \
+ SkWidgetViews.cpp \
+ SkWidgets.cpp \
+# SkBorderView.cpp \
+# SkImageView.cpp \
diff --git a/src/xml/xml_files.mk b/src/xml/xml_files.mk
new file mode 100644
index 0000000..d4342dd
--- /dev/null
+++ b/src/xml/xml_files.mk
@@ -0,0 +1,3 @@
+SOURCE := \
+ SkDOM.cpp \
+ SkXMLParser.cpp
diff --git a/tests/Android.mk b/tests/Android.mk
index 09c7739..5823b0e 100644
--- a/tests/Android.mk
+++ b/tests/Android.mk
@@ -26,6 +26,7 @@
ParsePathTest.cpp \
PathMeasureTest.cpp \
PathTest.cpp \
+ Reader32Test.cpp \
RefDictTest.cpp \
RegionTest.cpp \
Sk64Test.cpp \
@@ -36,6 +37,7 @@
Test.cpp \
TestSize.cpp \
UtilsTest.cpp \
+ Writer32Test.cpp \
XfermodeTest.cpp
# The name of the file with a main function must
diff --git a/tests/ClipStackTest.cpp b/tests/ClipStackTest.cpp
index 4ef33ff..eafdd69 100644
--- a/tests/ClipStackTest.cpp
+++ b/tests/ClipStackTest.cpp
@@ -107,7 +107,8 @@
// all of the above rects should have been intersected, leaving only 1 rect
SkClipStack::B2FIter iter(stack);
const SkClipStack::B2FIter::Clip* clip = iter.next();
- const SkRect answer = { 25, 25, 75, 75 };
+ SkRect answer;
+ answer.iset(25, 25, 75, 75);
REPORTER_ASSERT(reporter, clip);
REPORTER_ASSERT(reporter, clip->fRect);
diff --git a/tests/MatrixTest.cpp b/tests/MatrixTest.cpp
index 49a98c2..4125f9f 100644
--- a/tests/MatrixTest.cpp
+++ b/tests/MatrixTest.cpp
@@ -2,10 +2,12 @@
#include "SkMatrix.h"
static bool nearly_equal_scalar(SkScalar a, SkScalar b) {
+ // Note that we get more compounded error for multiple operations when
+ // SK_SCALAR_IS_FIXED.
#ifdef SK_SCALAR_IS_FLOAT
- const float tolerance = 0.000005f;
+ const SkScalar tolerance = SK_Scalar1 / 200000;
#else
- const int32_t tolerance = 8;
+ const SkScalar tolerance = SK_Scalar1 / 1024;
#endif
return SkScalarAbs(a - b) <= tolerance;
diff --git a/tests/PDFPrimitivesTest.cpp b/tests/PDFPrimitivesTest.cpp
index 6feab51..9a58fa6 100644
--- a/tests/PDFPrimitivesTest.cpp
+++ b/tests/PDFPrimitivesTest.cpp
@@ -122,15 +122,14 @@
realHalf->unref(); // SkRefPtr and new both took a reference.
CheckObjectOutput(reporter, realHalf.get(), "0.5", true);
+#if defined(SK_SCALAR_IS_FLOAT)
SkRefPtr<SkPDFScalar> bigScalar = new SkPDFScalar(110999.75);
bigScalar->unref(); // SkRefPtr and new both took a reference.
-#if defined(SK_SCALAR_IS_FIXED) || !defined(SK_ALLOW_LARGE_PDF_SCALARS)
+#if !defined(SK_ALLOW_LARGE_PDF_SCALARS)
CheckObjectOutput(reporter, bigScalar.get(), "111000", true);
#else
CheckObjectOutput(reporter, bigScalar.get(), "110999.75", true);
-#endif
-#if defined(SK_SCALAR_IS_FLOAT) && defined(SK_ALLOW_LARGE_PDF_SCALARS)
SkRefPtr<SkPDFScalar> biggerScalar = new SkPDFScalar(50000000.1);
biggerScalar->unref(); // SkRefPtr and new both took a reference.
CheckObjectOutput(reporter, biggerScalar.get(), "50000000", true);
@@ -139,6 +138,7 @@
smallestScalar->unref(); // SkRefPtr and new both took a reference.
CheckObjectOutput(reporter, smallestScalar.get(), "0.00001526", true);
#endif
+#endif
SkRefPtr<SkPDFString> stringSimple = new SkPDFString("test ) string ( foo");
stringSimple->unref(); // SkRefPtr and new both took a reference.
diff --git a/tests/PathTest.cpp b/tests/PathTest.cpp
index 3884308..7e4e6bc 100644
--- a/tests/PathTest.cpp
+++ b/tests/PathTest.cpp
@@ -13,15 +13,13 @@
SkPath pt;
pt.moveTo(0, 0);
pt.close();
-// check_convexity(reporter, pt, SkPath::kConvex_Convexity);
- check_convexity(reporter, pt, SkPath::kUnknown_Convexity);
+ check_convexity(reporter, pt, SkPath::kConvex_Convexity);
SkPath line;
line.moveTo(12, 20);
line.lineTo(-12, -20);
line.close();
- // check_convexity(reporter, pt, SkPath::kConvex_Convexity);
- check_convexity(reporter, pt, SkPath::kUnknown_Convexity);
+ check_convexity(reporter, pt, SkPath::kConvex_Convexity);
SkPath triLeft;
triLeft.moveTo(0, 0);
@@ -79,21 +77,21 @@
SkPath spiral;
spiral.moveTo(0, 0);
- spiral.lineTo(1, 0);
- spiral.lineTo(1, 1);
- spiral.lineTo(0, 1);
- spiral.lineTo(0,.5);
- spiral.lineTo(.5,.5);
- spiral.lineTo(.5,.75);
+ spiral.lineTo(100, 0);
+ spiral.lineTo(100, 100);
+ spiral.lineTo(0, 100);
+ spiral.lineTo(0, 50);
+ spiral.lineTo(50, 50);
+ spiral.lineTo(50, 75);
spiral.close();
check_convexity(reporter, spiral, SkPath::kConcave_Convexity);
SkPath dent;
- dent.moveTo(0, 0);
- dent.lineTo(1, 1);
- dent.lineTo(0, 1);
- dent.lineTo(-.5,2);
- dent.lineTo(-2, 1);
+ dent.moveTo(SkIntToScalar(0), SkIntToScalar(0));
+ dent.lineTo(SkIntToScalar(100), SkIntToScalar(100));
+ dent.lineTo(SkIntToScalar(0), SkIntToScalar(100));
+ dent.lineTo(SkIntToScalar(-50), SkIntToScalar(200));
+ dent.lineTo(SkIntToScalar(-200), SkIntToScalar(100));
dent.close();
check_convexity(reporter, dent, SkPath::kConcave_Convexity);
}
@@ -133,13 +131,12 @@
}
static void test_convexity(skiatest::Reporter* reporter) {
- static const SkPath::Convexity U = SkPath::kUnknown_Convexity;
static const SkPath::Convexity C = SkPath::kConcave_Convexity;
static const SkPath::Convexity V = SkPath::kConvex_Convexity;
SkPath path;
- REPORTER_ASSERT(reporter, U == SkPath::ComputeConvexity(path));
+ REPORTER_ASSERT(reporter, V == SkPath::ComputeConvexity(path));
path.addCircle(0, 0, 10);
REPORTER_ASSERT(reporter, V == SkPath::ComputeConvexity(path));
path.addCircle(0, 0, 10); // 2nd circle
@@ -155,8 +152,9 @@
const char* fPathStr;
SkPath::Convexity fExpectedConvexity;
} gRec[] = {
- { "0 0", SkPath::kUnknown_Convexity },
- { "0 0 10 10", SkPath::kUnknown_Convexity },
+ { "", SkPath::kConvex_Convexity },
+ { "0 0", SkPath::kConvex_Convexity },
+ { "0 0 10 10", SkPath::kConvex_Convexity },
{ "0 0 10 10 20 20 0 0 10 10", SkPath::kConcave_Convexity },
{ "0 0 10 10 10 20", SkPath::kConvex_Convexity },
{ "0 0 10 10 10 0", SkPath::kConvex_Convexity },
@@ -188,7 +186,7 @@
SkRect bounds, bounds2;
REPORTER_ASSERT(reporter, p.isEmpty());
- REPORTER_ASSERT(reporter, !p.isConvex());
+ REPORTER_ASSERT(reporter, p.isConvex());
REPORTER_ASSERT(reporter, p.getFillType() == SkPath::kWinding_FillType);
REPORTER_ASSERT(reporter, !p.isInverseFillType());
REPORTER_ASSERT(reporter, p == p2);
@@ -198,17 +196,14 @@
bounds.set(0, 0, SK_Scalar1, SK_Scalar1);
- p.setIsConvex(false);
p.addRoundRect(bounds, SK_Scalar1, SK_Scalar1);
check_convex_bounds(reporter, p, bounds);
p.reset();
- p.setIsConvex(false);
p.addOval(bounds);
check_convex_bounds(reporter, p, bounds);
p.reset();
- p.setIsConvex(false);
p.addRect(bounds);
check_convex_bounds(reporter, p, bounds);
@@ -245,18 +240,6 @@
p.getLastPt(&pt);
REPORTER_ASSERT(reporter, pt.fX == SK_Scalar1);
- // check that reset and rewind clear the convex hint back to false
- p.setIsConvex(false);
- REPORTER_ASSERT(reporter, !p.isConvex());
- p.setIsConvex(true);
- REPORTER_ASSERT(reporter, p.isConvex());
- p.reset();
- REPORTER_ASSERT(reporter, !p.isConvex());
- p.setIsConvex(true);
- REPORTER_ASSERT(reporter, p.isConvex());
- p.rewind();
- REPORTER_ASSERT(reporter, !p.isConvex());
-
test_convexity(reporter);
test_convexity2(reporter);
}
diff --git a/tests/Reader32Test.cpp b/tests/Reader32Test.cpp
new file mode 100644
index 0000000..c752b0f
--- /dev/null
+++ b/tests/Reader32Test.cpp
@@ -0,0 +1,93 @@
+/*
+ Copyright 2011 Google Inc.
+
+ 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.
+ */
+
+
+#include "SkReader32.h"
+#include "Test.h"
+
+static void assert_eof(skiatest::Reporter* reporter, const SkReader32& reader) {
+ REPORTER_ASSERT(reporter, reader.eof());
+ REPORTER_ASSERT(reporter, reader.size() == reader.offset());
+ REPORTER_ASSERT(reporter, (const char*)reader.peek() ==
+ (const char*)reader.base() + reader.size());
+}
+
+static void assert_start(skiatest::Reporter* reporter, const SkReader32& reader) {
+ REPORTER_ASSERT(reporter, 0 == reader.offset());
+ REPORTER_ASSERT(reporter, reader.size() == reader.available());
+ REPORTER_ASSERT(reporter, reader.isAvailable(reader.size()));
+ REPORTER_ASSERT(reporter, !reader.isAvailable(reader.size() + 1));
+ REPORTER_ASSERT(reporter, reader.peek() == reader.base());
+}
+
+static void assert_empty(skiatest::Reporter* reporter, const SkReader32& reader) {
+ REPORTER_ASSERT(reporter, 0 == reader.size());
+ REPORTER_ASSERT(reporter, 0 == reader.offset());
+ REPORTER_ASSERT(reporter, 0 == reader.available());
+ REPORTER_ASSERT(reporter, !reader.isAvailable(1));
+ assert_eof(reporter, reader);
+ assert_start(reporter, reader);
+}
+
+static void Tests(skiatest::Reporter* reporter) {
+ SkReader32 reader;
+ assert_empty(reporter, reader);
+ REPORTER_ASSERT(reporter, NULL == reader.base());
+ REPORTER_ASSERT(reporter, NULL == reader.peek());
+
+ size_t i;
+
+ const int32_t data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+ const SkScalar data2[] = { 0, SK_Scalar1, -SK_Scalar1, SK_Scalar1/2 };
+ char buffer[SkMax32(sizeof(data), sizeof(data2))];
+
+ reader.setMemory(data, sizeof(data));
+ for (i = 0; i < SK_ARRAY_COUNT(data); ++i) {
+ REPORTER_ASSERT(reporter, sizeof(data) == reader.size());
+ REPORTER_ASSERT(reporter, i*4 == reader.offset());
+ REPORTER_ASSERT(reporter, (const void*)data == reader.base());
+ REPORTER_ASSERT(reporter, (const void*)&data[i] == reader.peek());
+ REPORTER_ASSERT(reporter, data[i] == reader.readInt());
+ }
+ assert_eof(reporter, reader);
+ reader.rewind();
+ assert_start(reporter, reader);
+ reader.read(buffer, sizeof(data));
+ REPORTER_ASSERT(reporter, !memcmp(data, buffer, sizeof(data)));
+
+ reader.setMemory(data2, sizeof(data2));
+ for (i = 0; i < SK_ARRAY_COUNT(data2); ++i) {
+ REPORTER_ASSERT(reporter, sizeof(data2) == reader.size());
+ REPORTER_ASSERT(reporter, i*4 == reader.offset());
+ REPORTER_ASSERT(reporter, (const void*)data2 == reader.base());
+ REPORTER_ASSERT(reporter, (const void*)&data2[i] == reader.peek());
+ REPORTER_ASSERT(reporter, data2[i] == reader.readScalar());
+ }
+ assert_eof(reporter, reader);
+ reader.rewind();
+ assert_start(reporter, reader);
+ reader.read(buffer, sizeof(data2));
+ REPORTER_ASSERT(reporter, !memcmp(data2, buffer, sizeof(data2)));
+
+ reader.setMemory(NULL, 0);
+ assert_empty(reporter, reader);
+ REPORTER_ASSERT(reporter, NULL == reader.base());
+ REPORTER_ASSERT(reporter, NULL == reader.peek());
+}
+
+#include "TestClassDef.h"
+DEFINE_TESTCLASS("Reader32", Reader32Class, Tests)
+
diff --git a/tests/UtilsTest.cpp b/tests/UtilsTest.cpp
index a051af2..4f36afe 100644
--- a/tests/UtilsTest.cpp
+++ b/tests/UtilsTest.cpp
@@ -64,7 +64,7 @@
REPORTER_ASSERT(reporter, 1 == obj.getRefCnt());
}
-//////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////
#define kSEARCH_COUNT 91
diff --git a/tests/Writer32Test.cpp b/tests/Writer32Test.cpp
new file mode 100644
index 0000000..63b1209
--- /dev/null
+++ b/tests/Writer32Test.cpp
@@ -0,0 +1,90 @@
+/*
+ Copyright 2011 Google Inc.
+
+ 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.
+ */
+
+
+#include "SkReader32.h"
+#include "SkWriter32.h"
+#include "Test.h"
+
+static void test1(skiatest::Reporter* reporter, SkWriter32* writer) {
+ const uint32_t data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+ for (size_t i = 0; i < SK_ARRAY_COUNT(data); ++i) {
+ REPORTER_ASSERT(reporter, i*4 == writer->size());
+ writer->write32(data[i]);
+ uint32_t* addr = writer->peek32(i * 4);
+ REPORTER_ASSERT(reporter, data[i] == *addr);
+ }
+
+ char buffer[sizeof(data)];
+ REPORTER_ASSERT(reporter, sizeof(buffer) == writer->size());
+ writer->flatten(buffer);
+ REPORTER_ASSERT(reporter, !memcmp(data, buffer, sizeof(buffer)));
+}
+
+static void test2(skiatest::Reporter* reporter, SkWriter32* writer) {
+ static const char gStr[] = "abcdefghimjklmnopqrstuvwxyz";
+ size_t i;
+
+ size_t len = 0;
+ for (i = 0; i <= 26; ++i) {
+ len += SkWriter32::WriteStringSize(gStr, i);
+ writer->writeString(gStr, i);
+ }
+ REPORTER_ASSERT(reporter, writer->size() == len);
+
+ SkAutoMalloc storage(len);
+ writer->flatten(storage.get());
+
+ SkReader32 reader;
+ reader.setMemory(storage.get(), len);
+ for (i = 0; i <= 26; ++i) {
+ REPORTER_ASSERT(reporter, !reader.eof());
+ const char* str = reader.readString(&len);
+ REPORTER_ASSERT(reporter, i == len);
+ REPORTER_ASSERT(reporter, strlen(str) == len);
+ REPORTER_ASSERT(reporter, !memcmp(str, gStr, len));
+ }
+ REPORTER_ASSERT(reporter, reader.eof());
+}
+
+static void Tests(skiatest::Reporter* reporter) {
+ // dynamic allocator
+ {
+ SkWriter32 writer(256 * 4);
+ REPORTER_ASSERT(reporter, NULL == writer.getSingleBlock());
+ test1(reporter, &writer);
+
+ writer.reset();
+ test2(reporter, &writer);
+ }
+
+ // single-block
+ {
+ SkWriter32 writer(0);
+ uint32_t storage[256];
+ REPORTER_ASSERT(reporter, NULL == writer.getSingleBlock());
+ writer.reset(storage, sizeof(storage));
+ REPORTER_ASSERT(reporter, (void*)storage == writer.getSingleBlock());
+ test1(reporter, &writer);
+
+ writer.reset(storage, sizeof(storage));
+ test2(reporter, &writer);
+ }
+}
+
+#include "TestClassDef.h"
+DEFINE_TESTCLASS("Writer32", Writer32Class, Tests)
+
diff --git a/tests/tests_files.mk b/tests/tests_files.mk
index 28d5fe7..9b90179 100644
--- a/tests/tests_files.mk
+++ b/tests/tests_files.mk
@@ -22,6 +22,7 @@
ParsePathTest.cpp \
PathMeasureTest.cpp \
PathTest.cpp \
+ Reader32Test.cpp \
RefDictTest.cpp \
RegionTest.cpp \
Sk64Test.cpp \
@@ -33,4 +34,5 @@
Test.cpp \
TestSize.cpp \
UtilsTest.cpp \
+ Writer32Test.cpp \
XfermodeTest.cpp
