merged multitouch branch

Author: codeanticode

build.xml

@@ -75,12 +75,14 @@
 	  description="Create AndroidMode.zip and AndroidMode.txt">
     <mkdir dir="release" />
 
+<!--  	
     <copy todir="mode">
       <fileset dir="core/library">
 	    <include name="*.jar" />
       </fileset>
     </copy>
-
+-->
+  	
     <zip destfile="${mode.dist.path}">
       <zipfileset dir="." prefix="AndroidMode">
 	      <include name="android-core.zip" />

core/.classpath

@@ -3,6 +3,6 @@
 	<classpathentry kind="src" path="src"/>
 	<classpathentry kind="var" path="ANDROID_LIB"/>
 	<classpathentry kind="lib" path="library/android-support-v4.jar"/>
-	<classpathentry kind="lib" path="library/wearable-1.4.0.jar"/>
+	<classpathentry kind="lib" path="library/wearable-2.0.0.jar"/>
 	<classpathentry kind="output" path="bin"/>
 </classpath>

core/build.gradle

@@ -11,7 +11,7 @@ buildscript {
 dependencies {
     compile name: 'android'
     compile name: 'android-support-v4'
-    compile name: 'wearable-1.4.0'
+    compile name: 'wearable-2.0.0'
 }
 
 sourceSets {

core/build.xml

@@ -13,7 +13,7 @@
   <property name="android.platform" value="android-23" />
 
   <!-- Wear version to build the core library -->
-  <property name="wear.version" value="1.4.0" />	
+  <property name="wear.version" value="2.0.0" />	
 
   <!-- oh ant, you're so cute and convoluted -->
   <target name="build" depends="sdk_chatter,actual_build" />

core/library/wearable-1.4.0.jar

@@ -66,9 +66,12 @@ public class PGraphicsAndroid2D extends PGraphics {
   float[] curveDrawX;
   float[] curveDrawY;
 
-//  int transformCount;
-//  Matrix[] transformStack;
-  float[] transform;
+  static protected final int MATRIX_STACK_DEPTH = 32;
+  protected float[][] transformStack;
+  public PMatrix2D transform;
+  protected Matrix tmpMatrix;
+  protected float[] tmpArray;
+  int transformCount;
 
 //  Line2D.Float line = new Line2D.Float();
 //  Ellipse2D.Float ellipse = new Ellipse2D.Float();
@@ -107,9 +110,10 @@ public class PGraphicsAndroid2D extends PGraphics {
 
 
   public PGraphicsAndroid2D() {
-//    transformStack = new Matrix[MATRIX_STACK_DEPTH];
-//    transform = new float[6];
-    transform = new float[9];
+    transformStack = new float[MATRIX_STACK_DEPTH][6];
+    transform = new PMatrix2D();
+    tmpMatrix = new Matrix();
+    tmpArray = new float[9];
 
     path = new Path();
     rect = new RectF();
@@ -167,7 +171,7 @@ public void dispose() {
 
 
   @Override
-  public PSurface createSurface(AppComponent component, SurfaceHolder holder) {  // ignore
+  public PSurface createSurface(AppComponent component, SurfaceHolder holder, boolean reset) {  // ignore
     return new PSurfaceAndroid2D(this, component, holder);
   }
 
@@ -228,7 +232,7 @@ public void endDraw() {
 //    }
 
     if (primaryGraphics) {
-      SurfaceHolder holder = parent.getSurfaceHolder();
+      SurfaceHolder holder = parent.surface.getSurfaceHolder();
       if (holder != null) {
         Canvas screen = null;
         try {
@@ -238,7 +242,10 @@ public void endDraw() {
           }
         } finally {
           if (screen != null) {
-            parent.getSurfaceHolder().unlockCanvasAndPost(screen);
+            try {
+              holder.unlockCanvasAndPost(screen);
+            } catch (IllegalStateException ex) {
+            }
           }
         }
       }
@@ -505,6 +512,24 @@ public void endShape(int mode) {
   }
 
 
+  //////////////////////////////////////////////////////////////
+
+  // CLIPPING
+
+
+  @Override
+  protected void clipImpl(float x1, float y1, float x2, float y2) {
+//    canvas.save(Canvas.CLIP_SAVE_FLAG);
+    canvas.clipRect(x1, y1, x2, y2);
+  }
+
+
+  @Override
+  public void noClip() {
+    canvas.clipRect(0, 0, width, height, Region.Op.REPLACE);
+//    canvas.restore();
+  }
+
 
   //////////////////////////////////////////////////////////////
 
@@ -1221,10 +1246,16 @@ public PShape loadShape(String filename) {
   public void textFont(PFont which) {
     super.textFont(which);
     fillPaint.setTypeface((Typeface) which.getNative());
+    fillPaint.setTextSize(which.getDefaultSize());
   }
 
 
-  //public void textFont(PFont which, float size)
+  @Override
+  public void textFont(PFont which, float size) {
+    super.textFont(which, size);
+    fillPaint.setTypeface((Typeface) which.getNative());
+    fillPaint.setTextSize(size);
+  }
 
 
   //public void textLeading(float leading)
@@ -1256,14 +1287,7 @@ public void textSize(float size) {
       fillPaint.setTextSize(size);
     }
 
-    // take care of setting the textSize and textLeading vars
-    // this has to happen second, because it calls textAscent()
-    // (which requires the native font metrics to be set)
-    textSize = size;
-//    PApplet.println("P2D textSize textAscent -> " + textAscent());
-//    PApplet.println("P2D textSize textDescent -> " + textDescent());
-    textLeading = (textAscent() + textDescent()) * 1.275f;
-//    PApplet.println("P2D textSize textLeading = " + textLeading);
+    handleTextSize(size);
   }
 
 
@@ -1384,45 +1408,45 @@ protected void textLineImpl(char buffer[], int start, int stop,
 
   @Override
   public void pushMatrix() {
-//    if (transformCount == transformStack.length) {
-//      throw new RuntimeException("pushMatrix() cannot use push more than " +
-//                                 transformStack.length + " times");
-//    }
-//    transformStack[transformCount] = canvas.getMatrix();
-//    transformCount++;
-    canvas.save(Canvas.MATRIX_SAVE_FLAG);
+    if (transformCount == transformStack.length) {
+      throw new RuntimeException("pushMatrix() cannot use push more than " +
+                                 transformStack.length + " times");
+    }
+    transform.get(transformStack[transformCount]);
+    transformCount++;
+//    canvas.save(Canvas.MATRIX_SAVE_FLAG);
   }
 
 
   @Override
   public void popMatrix() {
-//    if (transformCount == 0) {
-//      throw new RuntimeException("missing a popMatrix() " +
-//                                 "to go with that pushMatrix()");
-//    }
-//    transformCount--;
-//    canvas.setMatrix(transformStack[transformCount]);
-    canvas.restore();
+    if (transformCount == 0) {
+      throw new RuntimeException("missing a popMatrix() " +
+                                 "to go with that pushMatrix()");
+    }
+    transformCount--;
+    transform.set(transformStack[transformCount]);
+    updateTmpMatrix();
+    canvas.setMatrix(tmpMatrix);
+//    canvas.restore();
   }
 
 
-
   //////////////////////////////////////////////////////////////
 
   // MATRIX TRANSFORMS
 
 
   @Override
   public void translate(float tx, float ty) {
+    transform.translate(tx, ty);
     canvas.translate(tx, ty);
   }
 
 
-  //public void translate(float tx, float ty, float tz)
-
-
   @Override
   public void rotate(float angle) {
+    transform.rotate(angle * RAD_TO_DEG);
     canvas.rotate(angle * RAD_TO_DEG);
   }
 
@@ -1453,12 +1477,14 @@ public void rotate(float angle, float vx, float vy, float vz) {
 
   @Override
   public void scale(float s) {
+    transform.scale(s, s);
     canvas.scale(s, s);
   }
 
 
   @Override
   public void scale(float sx, float sy) {
+    transform.scale(sx, sy);
     canvas.scale(sx, sy);
   }
 
@@ -1471,26 +1497,29 @@ public void scale(float sx, float sy, float sz) {
 
   @Override
   public void shearX(float angle) {
-    canvas.skew((float) Math.tan(angle), 0);
+    float t = (float) Math.tan(angle);
+    transform.apply(1, t, 0, 0, 1, 0);
+    canvas.skew(t, 0);
   }
 
 
   @Override
   public void shearY(float angle) {
-    canvas.skew(0, (float) Math.tan(angle));
+    float t = (float) Math.tan(angle);
+    transform.apply(1, 0, 0, t, 1, 0);
+    canvas.skew(0, t);
   }
 
 
-
   //////////////////////////////////////////////////////////////
 
   // MATRIX MORE
 
 
   @Override
   public void resetMatrix() {
-//    canvas.setTransform(new AffineTransform());
-    canvas.setMatrix(new Matrix());
+    transform.reset();
+    canvas.setMatrix(null);
   }
 
 
@@ -1500,15 +1529,9 @@ public void resetMatrix() {
   @Override
   public void applyMatrix(float n00, float n01, float n02,
                           float n10, float n11, float n12) {
-//    canvas.transform(new AffineTransform(n00, n10, n01, n11, n02, n12));
-    // TODO optimize
-    Matrix m = new Matrix();
-    m.setValues(new float[] {
-      n00, n01, n02,
-      n10, n11, n12,
-      0,   0,   1
-    });
-    canvas.concat(m);
+    transform.apply(n00, n01, n02, n10, n11, n12);
+    updateTmpMatrix();
+    canvas.concat(tmpMatrix);
   }
 
 
@@ -1541,15 +1564,7 @@ public PMatrix2D getMatrix(PMatrix2D target) {
     if (target == null) {
       target = new PMatrix2D();
     }
-//    canvas.getTransform().getMatrix(transform);
-//    Matrix m = new Matrix();
-//    canvas.getMatrix(m);
-    Matrix m = getMatrixImp();
-    m.getValues(transform);
-//    target.set((float) transform[0], (float) transform[2], (float) transform[4],
-//               (float) transform[1], (float) transform[3], (float) transform[5]);
-    target.set((float) transform[0], (float) transform[1], (float) transform[2],
-               (float) transform[3], (float) transform[4], (float) transform[5]);
+    target.set(transform);
     return target;
   }
 
@@ -1566,16 +1581,9 @@ public PMatrix3D getMatrix(PMatrix3D target) {
 
   @Override
   public void setMatrix(PMatrix2D source) {
-//    canvas.setTransform(new AffineTransform(source.m00, source.m10,
-//                                            source.m01, source.m11,
-//                                            source.m02, source.m12));
-    Matrix matrix = new Matrix();
-    matrix.setValues(new float[] {
-      source.m00, source.m01, source.m02,
-      source.m10, source.m11, source.m12,
-      0, 0, 1
-    });
-    canvas.setMatrix(matrix);
+    transform.set(source);
+    updateTmpMatrix();
+    canvas.setMatrix(tmpMatrix);
   }
 
 
@@ -1592,11 +1600,27 @@ public void printMatrix() {
 
 
   protected Matrix getMatrixImp() {
-    return parent.getSurfaceView().getMatrix();
+    Matrix m = new Matrix();
+    updateTmpMatrix();
+    m.set(tmpMatrix);
+    return m;
 //    return canvas.getMatrix();
   }
 
 
+  protected void updateTmpMatrix() {
+    tmpArray[0] = transform.m00;
+    tmpArray[1] = transform.m01;
+    tmpArray[2] = transform.m02;
+    tmpArray[3] = transform.m10;
+    tmpArray[4] = transform.m11;
+    tmpArray[5] = transform.m12;
+    tmpArray[6] = 0;
+    tmpArray[7] = 0;
+    tmpArray[8] = 1;
+    tmpMatrix.setValues(tmpArray);
+  }
+
 
   //////////////////////////////////////////////////////////////
 
@@ -2106,10 +2130,12 @@ public void set(int x, int y, PImage src) {
       src.setModified(false);
     }
     // set() happens in screen coordinates, so need to clear the ctm
-    canvas.save(Canvas.MATRIX_SAVE_FLAG);
+//    canvas.save(Canvas.MATRIX_SAVE_FLAG);
+    pushMatrix();
     canvas.setMatrix(null);  // set to identity
     canvas.drawBitmap(bitmap, x, y, null);
-    canvas.restore();
+    popMatrix();
+//    canvas.restore();
   }
 
 

core/library/wearable-2.0.0.jar

@@ -46,13 +46,13 @@ public PSurfaceAndroid2D(PGraphics graphics, AppComponent component, SurfaceHold
     if (component.getKind() == AppComponent.FRAGMENT) {
       PFragment frag = (PFragment)component;
       activity = frag.getActivity();
-      surface = new SketchSurfaceView(activity, null);
+      surfaceView = new SketchSurfaceView(activity, null);
     } else if (component.getKind() == AppComponent.WALLPAPER) {
       wallpaper = (WallpaperService)component;
-      surface = new SketchSurfaceView(wallpaper, holder);
+      surfaceView = new SketchSurfaceView(wallpaper, holder);
     } else if (component.getKind() == AppComponent.WATCHFACE) {
       watchface = (CanvasWatchFaceService)component;
-      surface = null;
+      surfaceView = null;
     }
   }