diff --git a/samplecode/SampleFatBits.cpp b/samplecode/SampleFatBits.cpp
index 8159cc5..10ec8e5 100644
--- a/samplecode/SampleFatBits.cpp
+++ b/samplecode/SampleFatBits.cpp
@@ -20,6 +20,17 @@
 #define WIRE_FRAME_COLOR    0xFFFF0000  /*0xFF00FFFF*/
 #define WIRE_FRAME_SIZE     1.5f
 
+static SkScalar apply_grid(SkScalar x) {
+    const SkScalar grid = 2;
+    return SkScalarRoundToScalar(x * grid) / grid;
+}
+
+static void apply_grid(SkPoint pts[], int count) {
+    for (int i = 0; i < count; ++i) {
+        pts[i].set(apply_grid(pts[i].fX), apply_grid(pts[i].fY));
+    }
+}
+
 static void erase(SkSurface* surface) {
     surface->getCanvas()->clear(SK_ColorTRANSPARENT);
 }
@@ -52,6 +63,7 @@
         fUseGPU = false;
         fUseClip = false;
         fRectAsOval = false;
+        fUseTriangle = false;
 
         fClipRect.set(2, 2, 11, 8 );
     }
@@ -69,7 +81,10 @@
 
     bool getUseGPU() const { return fUseGPU; }
     void setUseGPU(bool ug) { fUseGPU = ug; }
-
+    
+    bool getTriangle() const { return fUseTriangle; }
+    void setTriangle(bool ut) { fUseTriangle = ut; }
+    
     void toggleRectAsOval() { fRectAsOval = !fRectAsOval; }
 
     bool getUseClip() const { return fUseClip; }
@@ -91,19 +106,23 @@
         fInverse.setScale(SK_Scalar1 / zoom, SK_Scalar1 / zoom);
         fShader->setLocalMatrix(fMatrix);
 
-        fMinSurface.reset(SkSurface::NewRasterPMColor(width, height));
-        width *= zoom;
-        height *= zoom;
-        fMaxSurface.reset(SkSurface::NewRasterPMColor(width, height));
+        SkImage::Info info = {
+            width, height, SkImage::kPMColor_ColorType, SkImage::kPremul_AlphaType
+        };
+        fMinSurface.reset(SkSurface::NewRaster(info));
+        info.fWidth *= zoom;
+        info.fHeight *= zoom;
+        fMaxSurface.reset(SkSurface::NewRaster(info));
     }
 
     void drawBG(SkCanvas*);
     void drawFG(SkCanvas*);
     void drawLine(SkCanvas*, SkPoint pts[2]);
     void drawRect(SkCanvas* canvas, SkPoint pts[2]);
+    void drawTriangle(SkCanvas* canvas, SkPoint pts[3]);
 
 private:
-    bool fAA, fGrid, fShowSkeleton, fUseGPU, fUseClip, fRectAsOval;
+    bool fAA, fGrid, fShowSkeleton, fUseGPU, fUseClip, fRectAsOval, fUseTriangle;
     Style fStyle;
     int fW, fH, fZoom;
     SkMatrix fMatrix, fInverse;
@@ -132,6 +151,7 @@
         paint->setAntiAlias(true);
     }
 
+    void drawTriangleSkeleton(SkCanvas* max, const SkPoint pts[]);
     void drawLineSkeleton(SkCanvas* max, const SkPoint pts[]);
     void drawRectSkeleton(SkCanvas* max, const SkRect& r) {
         SkPaint paint;
@@ -264,11 +284,7 @@
     fInverse.mapPoints(pts, 2);
 
     if (fGrid) {
-        SkScalar dd = 0;//SK_Scalar1 / 50;
-        pts[0].set(SkScalarRoundToScalar(pts[0].fX) + dd,
-                   SkScalarRoundToScalar(pts[0].fY) + dd);
-        pts[1].set(SkScalarRoundToScalar(pts[1].fX) + dd,
-                   SkScalarRoundToScalar(pts[1].fY) + dd);
+        apply_grid(pts, 2);
     }
 
     erase(fMinSurface);
@@ -300,8 +316,7 @@
     fInverse.mapPoints(pts, 2);
 
     if (fGrid) {
-        pts[0].set(SkScalarRoundToScalar(pts[0].fX), SkScalarRoundToScalar(pts[0].fY));
-        pts[1].set(SkScalarRoundToScalar(pts[1].fX), SkScalarRoundToScalar(pts[1].fY));
+        apply_grid(pts, 2);
     }
 
     SkRect r;
@@ -325,6 +340,48 @@
     fMaxSurface->draw(canvas, 0, 0, NULL);
 }
 
+void FatBits::drawTriangleSkeleton(SkCanvas* max, const SkPoint pts[]) {
+    SkPaint paint;
+    this->setupSkeletonPaint(&paint);
+    
+    SkPath path;
+    path.moveTo(pts[0]);
+    path.lineTo(pts[1]);
+    path.lineTo(pts[2]);
+    path.close();
+    
+    max->drawPath(path, paint);
+}
+
+void FatBits::drawTriangle(SkCanvas* canvas, SkPoint pts[3]) {
+    SkPaint paint;
+    
+    fInverse.mapPoints(pts, 3);
+    
+    if (fGrid) {
+        apply_grid(pts, 3);
+    }
+    
+    SkPath path;
+    path.moveTo(pts[0]);
+    path.lineTo(pts[1]);
+    path.lineTo(pts[2]);
+    path.close();
+    
+    erase(fMinSurface);
+    this->setupPaint(&paint);
+    paint.setColor(FAT_PIXEL_COLOR);
+    fMinSurface->getCanvas()->drawPath(path, paint);
+    this->copyMinToMax();
+    
+    SkCanvas* max = fMaxSurface->getCanvas();
+    
+    fMatrix.mapPoints(pts, 3);
+    this->drawTriangleSkeleton(max, pts);
+    
+    fMaxSurface->draw(canvas, 0, 0, NULL);
+}
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 class IndexClick : public SkView::Click {
@@ -339,13 +396,14 @@
 
 class DrawLineView : public SampleView {
     FatBits fFB;
-    SkPoint fPts[2];
+    SkPoint fPts[3];
     bool    fIsRect;
 public:
     DrawLineView() {
         fFB.setWHZ(24, 16, 48);
         fPts[0].set(48, 48);
         fPts[1].set(48 * 5, 48 * 4);
+        fPts[2].set(48 * 2, 48 * 6);
         fIsRect = false;
     }
 
@@ -398,6 +456,10 @@
                     fFB.setUseGPU(!fFB.getUseGPU());
                     this->inval(NULL);
                     return true;
+                case 't':
+                    fFB.setTriangle(!fFB.getTriangle());
+                    this->inval(NULL);
+                    return true;
             }
         }
         return this->INHERITED::onQuery(evt);
@@ -405,7 +467,10 @@
 
     virtual void onDrawContent(SkCanvas* canvas) {
         fFB.drawBG(canvas);
-        if (fIsRect) {
+        if (fFB.getTriangle()) {
+            fFB.drawTriangle(canvas, fPts);
+        }
+        else if (fIsRect) {
             fFB.drawRect(canvas, fPts);
         } else {
             fFB.drawLine(canvas, fPts);
@@ -431,24 +496,28 @@
                                               unsigned modi) SK_OVERRIDE {
         SkPoint pt = { x, y };
         int index = -1;
+        int count = fFB.getTriangle() ? 3 : 2;
         SkScalar tol = 12;
-        if (fPts[0].equalsWithinTolerance(pt, tol)) {
-            index = 0;
-        } else if (fPts[1].equalsWithinTolerance(pt, tol)) {
-            index = 1;
+        
+        for (int i = 0; i < count; ++i) {
+            if (fPts[i].equalsWithinTolerance(pt, tol)) {
+                index = i;
+                break;
+            }
         }
         return new IndexClick(this, index);
     }
 
     virtual bool onClick(Click* click) SK_OVERRIDE {
         int index = IndexClick::GetIndex(click);
-        if (index >= 0 && index <= 1) {
+        if (index >= 0 && index <= 2) {
             fPts[index] = click->fCurr;
         } else {
             SkScalar dx = click->fCurr.fX - click->fPrev.fX;
             SkScalar dy = click->fCurr.fY - click->fPrev.fY;
             fPts[0].offset(dx, dy);
             fPts[1].offset(dx, dy);
+            fPts[2].offset(dx, dy);
         }
         this->inval(NULL);
         return true;