diff --git a/core/java/android/view/GLES20Canvas.java b/core/java/android/view/GLES20Canvas.java
index eb077cb..5c24058 100644
--- a/core/java/android/view/GLES20Canvas.java
+++ b/core/java/android/view/GLES20Canvas.java
@@ -193,9 +193,11 @@
 
     @Override
     public boolean quickReject(float left, float top, float right, float bottom, EdgeType type) {
-        // TODO: Implement
-        return false;
+        return nQuickReject(mRenderer, left, top, right, bottom, type.nativeInt);
     }
+    
+    private native boolean nQuickReject(int renderer, float left, float top,
+            float right, float bottom, int edge);
 
     @Override
     public boolean quickReject(Path path, EdgeType type) {
@@ -480,17 +482,20 @@
 
     @Override
     public void drawRect(float left, float top, float right, float bottom, Paint paint) {
-        // TODO: Implement
+        nDrawRect(mRenderer, left, top, right, bottom, paint.mNativePaint);
     }
 
+    private native void nDrawRect(int renderer, float left, float top, float right, float bottom,
+            int paint);
+
     @Override
     public void drawRect(Rect r, Paint paint) {
-        // TODO: Implement
+        drawRect(r.left, r.top, r.right, r.bottom, paint);
     }
 
     @Override
-    public void drawRect(RectF rect, Paint paint) {
-        // TODO: Implement
+    public void drawRect(RectF r, Paint paint) {
+        drawRect(r.left, r.top, r.right, r.bottom, paint);
     }
 
     @Override
diff --git a/core/jni/android_view_GLES20Canvas.cpp b/core/jni/android_view_GLES20Canvas.cpp
index 95476eb..aca63e8 100644
--- a/core/jni/android_view_GLES20Canvas.cpp
+++ b/core/jni/android_view_GLES20Canvas.cpp
@@ -18,7 +18,9 @@
 #include <nativehelper/JNIHelp.h>
 #include <android_runtime/AndroidRuntime.h>
 
+#include <SkCanvas.h>
 #include <SkMatrix.h>
+#include <SkPaint.h>
 #include <SkXfermode.h>
 
 #include <OpenGLRenderer.h>
@@ -93,6 +95,12 @@
 // Clipping
 // ----------------------------------------------------------------------------
 
+static bool android_view_GLES20Renderer_quickReject(JNIEnv* env, jobject canvas,
+        OpenGLRenderer* renderer, jfloat left, jfloat top, jfloat right, jfloat bottom,
+        SkCanvas::EdgeType edge) {
+    return renderer->quickReject(left, top, right, bottom);
+}
+
 static bool android_view_GLES20Renderer_clipRectF(JNIEnv* env, jobject canvas,
         OpenGLRenderer* renderer, jfloat left, jfloat top, jfloat right, jfloat bottom) {
     return renderer->clipRect(left, top, right, bottom);
@@ -157,6 +165,12 @@
     renderer->drawColor(color, (SkXfermode::Mode) mode);
 }
 
+static void android_view_GLES20Renderer_drawRect(JNIEnv* env, jobject canvas,
+        OpenGLRenderer* renderer, jfloat left, jfloat top, jfloat right, jfloat bottom,
+        SkPaint* paint) {
+    renderer->drawRect(left, top, right, bottom, paint);
+}
+
 // ----------------------------------------------------------------------------
 // JNI Glue
 // ----------------------------------------------------------------------------
@@ -164,31 +178,33 @@
 const char* const kClassPathName = "android/view/GLES20Canvas";
 
 static JNINativeMethod gMethods[] = {
-    {   "nCreateRenderer",    "()I",      (void*) android_view_GLES20Renderer_createRenderer },
-    {   "nDestroyRenderer",   "(I)V",     (void*) android_view_GLES20Renderer_destroyRenderer },
-    {   "nSetViewport",       "(III)V",   (void*) android_view_GLES20Renderer_setViewport },
-    {   "nPrepare",           "(I)V",     (void*) android_view_GLES20Renderer_prepare },
+    {   "nCreateRenderer",    "()I",       (void*) android_view_GLES20Renderer_createRenderer },
+    {   "nDestroyRenderer",   "(I)V",      (void*) android_view_GLES20Renderer_destroyRenderer },
+    {   "nSetViewport",       "(III)V",    (void*) android_view_GLES20Renderer_setViewport },
+    {   "nPrepare",           "(I)V",      (void*) android_view_GLES20Renderer_prepare },
 
-    {   "nSave",              "(II)I",    (void*) android_view_GLES20Renderer_save },
-    {   "nRestore",           "(I)V",     (void*) android_view_GLES20Renderer_restore },
-    {   "nRestoreToCount",    "(II)V",    (void*) android_view_GLES20Renderer_restoreToCount },
-    {   "nGetSaveCount",      "(I)I",     (void*) android_view_GLES20Renderer_getSaveCount },
+    {   "nSave",              "(II)I",     (void*) android_view_GLES20Renderer_save },
+    {   "nRestore",           "(I)V",      (void*) android_view_GLES20Renderer_restore },
+    {   "nRestoreToCount",    "(II)V",     (void*) android_view_GLES20Renderer_restoreToCount },
+    {   "nGetSaveCount",      "(I)I",      (void*) android_view_GLES20Renderer_getSaveCount },
 
-    {   "nClipRect",          "(IFFFF)Z", (void*) android_view_GLES20Renderer_clipRectF },
-    {   "nClipRect",          "(IIIII)Z", (void*) android_view_GLES20Renderer_clipRect },
+    {   "nQuickReject",       "(IFFFFI)Z", (void*) android_view_GLES20Renderer_quickReject },
+    {   "nClipRect",          "(IFFFF)Z",  (void*) android_view_GLES20Renderer_clipRectF },
+    {   "nClipRect",          "(IIIII)Z",  (void*) android_view_GLES20Renderer_clipRect },
+
+    {   "nTranslate",         "(IFF)V",    (void*) android_view_GLES20Renderer_translate },
+    {   "nRotate",            "(IF)V",     (void*) android_view_GLES20Renderer_rotate },
+    {   "nScale",             "(IFF)V",    (void*) android_view_GLES20Renderer_scale },
+
+    {   "nSetMatrix",         "(II)V",     (void*) android_view_GLES20Renderer_setMatrix },
+    {   "nGetMatrix",         "(II)V",     (void*) android_view_GLES20Renderer_getMatrix },
+    {   "nConcatMatrix",      "(II)V",     (void*) android_view_GLES20Renderer_concatMatrix },
+
+    {   "nDrawColor",         "(III)V",    (void*) android_view_GLES20Renderer_drawColor },
+    {   "nDrawRect",          "(IFFFFI)V", (void*) android_view_GLES20Renderer_drawRect },
 
     {   "nGetClipBounds",     "(ILandroid/graphics/Rect;)Z",
-    		(void*) android_view_GLES20Renderer_getClipBounds },
-
-    {   "nTranslate",         "(IFF)V",   (void*) android_view_GLES20Renderer_translate },
-    {   "nRotate",            "(IF)V",    (void*) android_view_GLES20Renderer_rotate },
-    {   "nScale",             "(IFF)V",   (void*) android_view_GLES20Renderer_scale },
-
-    {   "nSetMatrix",         "(II)V",    (void*) android_view_GLES20Renderer_setMatrix },
-    {   "nGetMatrix",         "(II)V",    (void*) android_view_GLES20Renderer_getMatrix },
-    {   "nConcatMatrix",      "(II)V",    (void*) android_view_GLES20Renderer_concatMatrix },
-
-    {   "nDrawColor",         "(III)V",   (void*) android_view_GLES20Renderer_drawColor },
+            (void*) android_view_GLES20Renderer_getClipBounds },
 };
 
 #define FIND_CLASS(var, className) \
diff --git a/graphics/java/android/graphics/Canvas.java b/graphics/java/android/graphics/Canvas.java
index e556350..3a0c18c 100644
--- a/graphics/java/android/graphics/Canvas.java
+++ b/graphics/java/android/graphics/Canvas.java
@@ -653,7 +653,11 @@
         EdgeType(int nativeInt) {
             this.nativeInt = nativeInt;
         }
-        final int nativeInt;
+
+        /**
+         * @hide
+         */
+        public final int nativeInt;
     }
 
     /**
diff --git a/graphics/java/android/graphics/Paint.java b/graphics/java/android/graphics/Paint.java
index 862a2ec..88ff0e6 100644
--- a/graphics/java/android/graphics/Paint.java
+++ b/graphics/java/android/graphics/Paint.java
@@ -27,7 +27,11 @@
  */
 public class Paint {
 
-    /*package*/ int     mNativePaint;
+    /**
+     * @hide
+     */
+    public int mNativePaint;
+
     private ColorFilter mColorFilter;
     private MaskFilter  mMaskFilter;
     private PathEffect  mPathEffect;
diff --git a/libs/hwui/Matrix.cpp b/libs/hwui/Matrix.cpp
index c097d7f..59b7fef 100644
--- a/libs/hwui/Matrix.cpp
+++ b/libs/hwui/Matrix.cpp
@@ -30,95 +30,95 @@
 namespace uirenderer {
 
 void Matrix4::loadIdentity() {
-	mMat[0]  = 1.0f;
-	mMat[1]  = 0.0f;
-	mMat[2]  = 0.0f;
-	mMat[3]  = 0.0f;
+	data[0]  = 1.0f;
+	data[1]  = 0.0f;
+	data[2]  = 0.0f;
+	data[3]  = 0.0f;
 
-	mMat[4]  = 0.0f;
-	mMat[5]  = 1.0f;
-	mMat[6]  = 0.0f;
-	mMat[7]  = 0.0f;
+	data[4]  = 0.0f;
+	data[5]  = 1.0f;
+	data[6]  = 0.0f;
+	data[7]  = 0.0f;
 
-	mMat[8]  = 0.0f;
-	mMat[9]  = 0.0f;
-	mMat[10] = 1.0f;
-	mMat[11] = 0.0f;
+	data[8]  = 0.0f;
+	data[9]  = 0.0f;
+	data[10] = 1.0f;
+	data[11] = 0.0f;
 
-	mMat[12] = 0.0f;
-	mMat[13] = 0.0f;
-	mMat[14] = 0.0f;
-	mMat[15] = 1.0f;
+	data[12] = 0.0f;
+	data[13] = 0.0f;
+	data[14] = 0.0f;
+	data[15] = 1.0f;
 }
 
 void Matrix4::load(const float* v) {
-	memcpy(mMat, v, sizeof(mMat));
+	memcpy(data, v, sizeof(data));
 }
 
 void Matrix4::load(const Matrix4& v) {
-	memcpy(mMat, v.mMat, sizeof(mMat));
+	memcpy(data, v.data, sizeof(data));
 }
 
 void Matrix4::load(const SkMatrix& v) {
-	memset(mMat, 0, sizeof(mMat));
+	memset(data, 0, sizeof(data));
 
-	mMat[0]  = v[SkMatrix::kMScaleX];
-	mMat[4]  = v[SkMatrix::kMSkewX];
-	mMat[12] = v[SkMatrix::kMTransX];
+	data[0]  = v[SkMatrix::kMScaleX];
+	data[4]  = v[SkMatrix::kMSkewX];
+	data[12] = v[SkMatrix::kMTransX];
 
-	mMat[1]  = v[SkMatrix::kMSkewY];
-	mMat[5]  = v[SkMatrix::kMScaleY];
-	mMat[13] = v[SkMatrix::kMTransY];
+	data[1]  = v[SkMatrix::kMSkewY];
+	data[5]  = v[SkMatrix::kMScaleY];
+	data[13] = v[SkMatrix::kMTransY];
 
-	mMat[3]  = v[SkMatrix::kMPersp0];
-	mMat[7]  = v[SkMatrix::kMPersp1];
-	mMat[15] = v[SkMatrix::kMPersp2];
+	data[3]  = v[SkMatrix::kMPersp0];
+	data[7]  = v[SkMatrix::kMPersp1];
+	data[15] = v[SkMatrix::kMPersp2];
 
-	mMat[10] = 1.0f;
+	data[10] = 1.0f;
 }
 
 void Matrix4::copyTo(SkMatrix& v) const {
 	v.reset();
 
-	v.set(SkMatrix::kMScaleX, mMat[0]);
-	v.set(SkMatrix::kMSkewX,  mMat[4]);
-	v.set(SkMatrix::kMTransX, mMat[12]);
+	v.set(SkMatrix::kMScaleX, data[0]);
+	v.set(SkMatrix::kMSkewX,  data[4]);
+	v.set(SkMatrix::kMTransX, data[12]);
 
-	v.set(SkMatrix::kMSkewY,  mMat[1]);
-	v.set(SkMatrix::kMScaleY, mMat[5]);
-	v.set(SkMatrix::kMTransY, mMat[13]);
+	v.set(SkMatrix::kMSkewY,  data[1]);
+	v.set(SkMatrix::kMScaleY, data[5]);
+	v.set(SkMatrix::kMTransY, data[13]);
 
-	v.set(SkMatrix::kMPersp0, mMat[3]);
-	v.set(SkMatrix::kMPersp1, mMat[7]);
-	v.set(SkMatrix::kMPersp2, mMat[15]);
+	v.set(SkMatrix::kMPersp0, data[3]);
+	v.set(SkMatrix::kMPersp1, data[7]);
+	v.set(SkMatrix::kMPersp2, data[15]);
 }
 
 void Matrix4::copyTo(float* v) const {
-	memcpy(v, mMat, sizeof(mMat));
+	memcpy(v, data, sizeof(data));
 }
 
 void Matrix4::loadTranslate(float x, float y, float z) {
 	loadIdentity();
-	mMat[12] = x;
-	mMat[13] = y;
-	mMat[14] = z;
+	data[12] = x;
+	data[13] = y;
+	data[14] = z;
 }
 
 void Matrix4::loadScale(float sx, float sy, float sz) {
 	loadIdentity();
-	mMat[0]  = sx;
-	mMat[5]  = sy;
-	mMat[10] = sz;
+	data[0]  = sx;
+	data[5]  = sy;
+	data[10] = sz;
 }
 
 void Matrix4::loadRotate(float angle, float x, float y, float z) {
-	mMat[3]  = 0.0f;
-	mMat[7]  = 0.0f;
-	mMat[11] = 0.0f;
-	mMat[12] = 0.0f;
-	mMat[13] = 0.0f;
-	mMat[14] = 0.0f;
-	mMat[15] = 1.0f;
+	data[3]  = 0.0f;
+	data[7]  = 0.0f;
+	data[11] = 0.0f;
+	data[12] = 0.0f;
+	data[13] = 0.0f;
+	data[14] = 0.0f;
+	data[15] = 1.0f;
 
 	angle *= float(M_PI / 180.0f);
 	float c = cosf(angle);
@@ -133,15 +133,15 @@
 	const float ys = y * s;
 	const float zs = z * s;
 
-	mMat[0]  = x * x * nc +  c;
-	mMat[4]  =    xy * nc - zs;
-	mMat[8]  =    zx * nc + ys;
-	mMat[1]  =    xy * nc + zs;
-	mMat[5]  = y * y * nc +  c;
-	mMat[9]  =    yz * nc - xs;
-	mMat[2]  =    zx * nc - ys;
-	mMat[6]  =    yz * nc + xs;
-	mMat[10] = z * z * nc +  c;
+	data[0]  = x * x * nc +  c;
+	data[4]  =    xy * nc - zs;
+	data[8]  =    zx * nc + ys;
+	data[1]  =    xy * nc + zs;
+	data[5]  = y * y * nc +  c;
+	data[9]  =    yz * nc - xs;
+	data[2]  =    zx * nc - ys;
+	data[6]  =    yz * nc + xs;
+	data[10] = z * z * nc +  c;
 }
 
 void Matrix4::loadMultiply(const Matrix4& u, const Matrix4& v) {
@@ -152,7 +152,7 @@
         float w = 0;
 
         for (int j = 0 ; j < 4 ; j++) {
-            const float e = v.get(i,j);
+            const float e = v.get(i, j);
             x += u.get(j, 0) * e;
             y += u.get(j, 1) * e;
             z += u.get(j, 2) * e;
@@ -168,22 +168,22 @@
 
 void Matrix4::loadOrtho(float left, float right, float bottom, float top, float near, float far) {
     loadIdentity();
-    mMat[0]  = 2.0f / (right - left);
-    mMat[5]  = 2.0f / (top - bottom);
-    mMat[10] = -2.0f / (far - near);
-    mMat[12] = -(right + left) / (right - left);
-    mMat[13] = -(top + bottom) / (top - bottom);
-    mMat[14] = -(far + near) / (far - near);
+    data[0]  = 2.0f / (right - left);
+    data[5]  = 2.0f / (top - bottom);
+    data[10] = -2.0f / (far - near);
+    data[12] = -(right + left) / (right - left);
+    data[13] = -(top + bottom) / (top - bottom);
+    data[14] = -(far + near) / (far - near);
 }
 
 #define MUL_ADD_STORE(a, b, c) a = (a) * (b) + (c)
 
 void Matrix4::mapRect(Rect& r) const {
-	const float sx = mMat[0];
-	const float sy = mMat[5];
+	const float sx = data[0];
+	const float sy = data[5];
 
-	const float tx = mMat[12];
-	const float ty = mMat[13];
+	const float tx = data[12];
+	const float ty = data[13];
 
 	MUL_ADD_STORE(r.left, sx, tx);
 	MUL_ADD_STORE(r.right, sx, tx);
@@ -193,10 +193,10 @@
 
 void Matrix4::dump() const {
 	LOGD("Matrix4[");
-	LOGD("  %f %f %f %f", mMat[0], mMat[4], mMat[ 8], mMat[12]);
-	LOGD("  %f %f %f %f", mMat[1], mMat[5], mMat[ 9], mMat[13]);
-	LOGD("  %f %f %f %f", mMat[2], mMat[6], mMat[10], mMat[14]);
-	LOGD("  %f %f %f %f", mMat[3], mMat[7], mMat[11], mMat[15]);
+	LOGD("  %f %f %f %f", data[0], data[4], data[ 8], data[12]);
+	LOGD("  %f %f %f %f", data[1], data[5], data[ 9], data[13]);
+	LOGD("  %f %f %f %f", data[2], data[6], data[10], data[14]);
+	LOGD("  %f %f %f %f", data[3], data[7], data[11], data[15]);
 	LOGD("]");
 }
 
diff --git a/libs/hwui/Matrix.h b/libs/hwui/Matrix.h
index 9bd289f..8fa5e4d 100644
--- a/libs/hwui/Matrix.h
+++ b/libs/hwui/Matrix.h
@@ -30,6 +30,8 @@
 
 class Matrix4 {
 public:
+	float data[16];
+
 	Matrix4() {
 		loadIdentity();
 	}
@@ -92,14 +94,12 @@
 
 private:
     inline float get(int i, int j) const {
-        return mMat[i * 4 + j];
+        return data[i * 4 + j];
     }
 
     inline void set(int i, int j, float v) {
-    	mMat[i * 4 + j] = v;
+    	data[i * 4 + j] = v;
     }
-
-	float mMat[16];
 }; // class Matrix4
 
 ///////////////////////////////////////////////////////////////////////////////
diff --git a/libs/hwui/OpenGLRenderer.cpp b/libs/hwui/OpenGLRenderer.cpp
index 575bc20..2ebd7cd 100644
--- a/libs/hwui/OpenGLRenderer.cpp
+++ b/libs/hwui/OpenGLRenderer.cpp
@@ -27,6 +27,7 @@
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 
+#include <SkPaint.h>
 #include <SkXfermode.h>
 
 #include "OpenGLRenderer.h"
@@ -39,20 +40,20 @@
 // Defines
 ///////////////////////////////////////////////////////////////////////////////
 
-#define SOLID_WHITE { 1.0f, 1.0f, 1.0f, 1.0f }
-
-#define P(x, y) { x, y }
+#define V(x, y) { { x, y } }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Globals
 ///////////////////////////////////////////////////////////////////////////////
 
-const Vertex gDrawColorVertices[] = {
-		{ P(0.0f, 0.0f), SOLID_WHITE },
-		{ P(1.0f, 0.0f), SOLID_WHITE },
-		{ P(0.0f, 1.0f), SOLID_WHITE },
-		{ P(1.0f, 1.0f), SOLID_WHITE }
+const SimpleVertex gDrawColorVertices[] = {
+		V(0.0f, 0.0f),
+		V(1.0f, 0.0f),
+		V(0.0f, 1.0f),
+		V(1.0f, 1.0f)
 };
+const GLsizei gDrawColorVertexStride = sizeof(SimpleVertex);
+const GLsizei gDrawColorVertexCount = 4;
 
 ///////////////////////////////////////////////////////////////////////////////
 // Shaders
@@ -142,6 +143,15 @@
 	color = addAttrib("color");
 	projection = addUniform("projection");
 	modelView = addUniform("modelView");
+	transform = addUniform("transform");
+}
+
+void DrawColorProgram::use(const GLfloat* projectionMatrix, const GLfloat* modelViewMatrix,
+        const GLfloat* transformMatrix) {
+	Program::use();
+	glUniformMatrix4fv(projection, 1, GL_FALSE, projectionMatrix);
+	glUniformMatrix4fv(modelView, 1, GL_FALSE, modelViewMatrix);
+	glUniformMatrix4fv(transform, 1, GL_FALSE, transformMatrix);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -179,7 +189,7 @@
     glViewport(0, 0, width, height);
 
     mat4 ortho;
-    ortho.loadOrtho(0, width, height, 0, 0, 1);
+    ortho.loadOrtho(0, width, height, 0, -1, 1);
     ortho.copyTo(mOrthoMatrix);
 
     mWidth = width;
@@ -196,6 +206,7 @@
     glClear(GL_COLOR_BUFFER_BIT);
 
     glEnable(GL_SCISSOR_TEST);
+    glScissor(0, 0, mWidth, mHeight);
 
     mSnapshot->clipRect.set(0.0f, 0.0f, mWidth, mHeight);
 }
@@ -291,13 +302,31 @@
 
 void OpenGLRenderer::setScissorFromClip() {
 	const Rect& clip = mSnapshot->getMappedClip();
-	glScissor(clip.left, clip.top, clip.getWidth(), clip.getHeight());
+	glScissor(clip.left, mHeight - clip.bottom, clip.getWidth(), clip.getHeight());
 }
 
 const Rect& OpenGLRenderer::getClipBounds() {
 	return mSnapshot->clipRect;
 }
 
+bool OpenGLRenderer::quickReject(float left, float top, float right, float bottom) {
+    /*
+     * The documentation of quickReject() indicates that the specified rect
+     * is transformed before being compared to the clip rect. However, the
+     * clip rect is not stored transformed in the snapshot and can thus be
+     * compared directly
+     *
+     * The following code can be used instead to performed a mapped comparison:
+     *
+     *     mSnapshot->transform.mapRect(r);
+     *     const Rect& clip = mSnapshot->getMappedClip();
+     *     return !clip.intersects(r);
+     */
+
+    Rect r(left, top, right, bottom);
+    return !mSnapshot->clipRect.intersects(r);
+}
+
 bool OpenGLRenderer::clipRect(float left, float top, float right, float bottom) {
 	bool clipped = mSnapshot->clipRect.intersect(left, top, right, bottom);
 	if (clipped) {
@@ -312,40 +341,38 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 void OpenGLRenderer::drawColor(int color, SkXfermode::Mode mode) {
-	GLfloat a = ((color >> 24) & 0xFF) / 255.0f;
-	GLfloat r = ((color >> 16) & 0xFF) / 255.0f;
-	GLfloat g = ((color >>  8) & 0xFF) / 255.0f;
-	GLfloat b = ((color      ) & 0xFF) / 255.0f;
+    // TODO: Set the transfer mode
+    const Rect& clip = mSnapshot->clipRect;
+    drawColorRect(clip.left, clip.top, clip.right, clip.bottom, color);
+}
 
-	// TODO Optimize this section
-	const Rect& clip = mSnapshot->getMappedClip();
+void OpenGLRenderer::drawRect(float left, float top, float right, float bottom, SkPaint* paint) {
+    // TODO Support more than  just color
+    // TODO: Set the transfer mode
+    drawColorRect(left, top, right, bottom, paint->getColor());
+}
 
-	mat4 modelView;
-	modelView.loadScale(clip.getWidth(), clip.getHeight(), 1.0f);
-	modelView.translate(clip.left, clip.top, 0.0f);
+void OpenGLRenderer::drawColorRect(float left, float top, float right, float bottom, int color) {
+    GLfloat a = ((color >> 24) & 0xFF) / 255.0f;
+    GLfloat r = ((color >> 16) & 0xFF) / 255.0f;
+    GLfloat g = ((color >>  8) & 0xFF) / 255.0f;
+    GLfloat b = ((color      ) & 0xFF) / 255.0f;
 
-	float matrix[16];
-	modelView.copyTo(matrix);
-	// TODO Optimize this section
+    mModelView.loadTranslate(left, top, 0.0f);
+    mModelView.scale(right - left, bottom - top, 1.0f);
 
-	mDrawColorShader->use();
+    mDrawColorShader->use(&mOrthoMatrix[0], &mModelView.data[0], &mSnapshot->transform.data[0]);
 
-	glUniformMatrix4fv(mDrawColorShader->projection, 1, GL_FALSE, &mOrthoMatrix[0]);
-	glUniformMatrix4fv(mDrawColorShader->modelView, 1, GL_FALSE, &matrix[0]);
+    const GLvoid* p = &gDrawColorVertices[0].position[0];
 
-	glEnableVertexAttribArray(mDrawColorShader->position);
+    glEnableVertexAttribArray(mDrawColorShader->position);
+    glVertexAttribPointer(mDrawColorShader->position, 2, GL_FLOAT, GL_FALSE,
+            gDrawColorVertexStride, p);
+    glVertexAttrib4f(mDrawColorShader->color, r, g, b, a);
 
-	GLsizei stride = sizeof(Vertex);
-	const GLvoid* p = &gDrawColorVertices[0].position[0];
+    glDrawArrays(GL_TRIANGLE_STRIP, 0, gDrawColorVertexCount);
 
-	glVertexAttribPointer(mDrawColorShader->position, 2, GL_FLOAT, GL_FALSE, stride, p);
-	glVertexAttrib4f(mDrawColorShader->color, r, g, b, a);
-
-	GLsizei vertexCount = sizeof(gDrawColorVertices) / sizeof(Vertex);
-	glDrawArrays(GL_TRIANGLE_STRIP, 0, vertexCount);
-
-	glDisableVertexAttribArray(mDrawColorShader->position);
-	glDisableVertexAttribArray(mDrawColorShader->color);
+    glDisableVertexAttribArray(mDrawColorShader->position);
 }
 
 }; // namespace uirenderer
diff --git a/libs/hwui/OpenGLRenderer.h b/libs/hwui/OpenGLRenderer.h
index 88cbc1c..bef4193 100644
--- a/libs/hwui/OpenGLRenderer.h
+++ b/libs/hwui/OpenGLRenderer.h
@@ -72,10 +72,9 @@
 	Rect mappedClip;
 }; // class Snapshot
 
-struct Vertex {
+struct SimpleVertex {
 	float position[2];
-	float color[4];
-}; // struct Vertex
+}; // struct SimpleVertex
 
 typedef char* shader;
 
@@ -112,11 +111,15 @@
 public:
 	DrawColorProgram();
 
+	void use(const GLfloat* projectionMatrix, const GLfloat* modelViewMatrix,
+	         const GLfloat* transformMatrix);
+
 	int position;
 	int color;
 
 	int projection;
 	int modelView;
+	int transform;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -145,9 +148,11 @@
     void concatMatrix(SkMatrix* matrix);
 
     const Rect& getClipBounds();
+    bool quickReject(float left, float top, float right, float bottom);
     bool clipRect(float left, float top, float right, float bottom);
 
     void drawColor(int color, SkXfermode::Mode mode);
+    void drawRect(float left, float top, float right, float bottom, SkPaint* paint);
 
 private:
     int saveSnapshot();
@@ -155,12 +160,17 @@
 
     void setScissorFromClip();
 
+    void drawColorRect(float left, float top, float right, float bottom, int color);
+
     // Dimensions of the drawing surface
     int mWidth, mHeight;
 
     // Matrix used for ortho projection in shaders
     float mOrthoMatrix[16];
 
+    // Model-view matrix used to position/size objects
+    mat4 mModelView;
+
     // Number of saved states
     int mSaveCount;
     // Base state
diff --git a/libs/hwui/shaders/drawColor.vert b/libs/hwui/shaders/drawColor.vert
index fd3cb45..4b7f883 100644
--- a/libs/hwui/shaders/drawColor.vert
+++ b/libs/hwui/shaders/drawColor.vert
@@ -5,12 +5,13 @@
 
 uniform mat4 projection;
 uniform mat4 modelView;
+uniform mat4 transform;
 
 varying vec4 outColor;
 
 void main(void) {
 	outColor = color;
-	gl_Position = projection * modelView * position;
+	gl_Position = projection * transform * modelView * position;
 }
 
 );
diff --git a/tests/HwAccelerationTest/src/com/google/android/test/hwui/HwUiActivity.java b/tests/HwAccelerationTest/src/com/google/android/test/hwui/HwUiActivity.java
index 81b9357..14154a8 100644
--- a/tests/HwAccelerationTest/src/com/google/android/test/hwui/HwUiActivity.java
+++ b/tests/HwAccelerationTest/src/com/google/android/test/hwui/HwUiActivity.java
@@ -60,20 +60,32 @@
             canvas.save();
             canvas.clipRect(20.0f, 0.0f, 40.0f, 20.0f);
             Log.d(LOG_TAG, "clipRect = " + canvas.getClipBounds());
+            Log.d(LOG_TAG, "rejected = " + canvas.quickReject(100.0f, 100.0f, 110.0f, 110.0f,
+                    Canvas.EdgeType.BW));
+            Log.d(LOG_TAG, "rejected = " + canvas.quickReject(25.0f, 5.0f, 30.0f, 10.0f,
+                    Canvas.EdgeType.BW));
             canvas.restore();
             
             canvas.save();
             canvas.scale(2.0f, 2.0f);
             canvas.clipRect(20.0f, 0.0f, 40.0f, 20.0f);
             Log.d(LOG_TAG, "clipRect = " + canvas.getClipBounds());
+            Log.d(LOG_TAG, "rejected = " + canvas.quickReject(50.0f, 50.0f, 60.0f, 60.0f,
+                    Canvas.EdgeType.BW));
+            Log.d(LOG_TAG, "rejected = " + canvas.quickReject(25.0f, 5.0f, 30.0f, 10.0f,
+                    Canvas.EdgeType.BW));
             canvas.restore();
 
             canvas.save();
             canvas.translate(20.0f, 20.0f);
             canvas.clipRect(20.0f, 0.0f, 40.0f, 20.0f);
             Log.d(LOG_TAG, "clipRect = " + canvas.getClipBounds());
+            Log.d(LOG_TAG, "rejected = " + canvas.quickReject(80.0f, 80.0f, 90.0f, 90.0f,
+                    Canvas.EdgeType.BW));
+            Log.d(LOG_TAG, "rejected = " + canvas.quickReject(25.0f, 5.0f, 30.0f, 10.0f,
+                    Canvas.EdgeType.BW));
             canvas.restore();
-            
+
             canvas.scale(2.0f, 2.0f);            
             canvas.clipRect(20.0f, 0.0f, 40.0f, 20.0f);