diff --git a/include/views/SkKey.h b/include/views/SkKey.h
index a019c28..65fac71 100644
--- a/include/views/SkKey.h
+++ b/include/views/SkKey.h
@@ -52,5 +52,12 @@
     kSkKeyCount
 };
 
+enum SkModifierKeys {
+    kShift_SkModifierKey    = 1 << 0,
+    kControl_SkModifierKey  = 1 << 1,
+    kOption_SkModifierKey   = 1 << 2,   // same as ALT
+    kCommand_SkModifierKey  = 1 << 3,
+};
+
 #endif
 
diff --git a/include/views/SkOSWindow_Mac.h b/include/views/SkOSWindow_Mac.h
index d195cf1..aa52021 100644
--- a/include/views/SkOSWindow_Mac.h
+++ b/include/views/SkOSWindow_Mac.h
@@ -18,7 +18,7 @@
     void*   getHWND() const { return fHWND; }
 
     virtual bool onDispatchClick(int x, int y, Click::State state,
-                                 void* owner);
+                                 void* owner, unsigned modi);
     enum SkBackEndTypes {
         kNone_BackEndType,
 #if SK_SUPPORT_GPU
diff --git a/include/views/SkOSWindow_iOS.h b/include/views/SkOSWindow_iOS.h
index eda7c5f..4422d28 100755
--- a/include/views/SkOSWindow_iOS.h
+++ b/include/views/SkOSWindow_iOS.h
@@ -17,7 +17,7 @@
     void*   getHWND() const { return fHWND; }
 
     virtual bool onDispatchClick(int x, int y, Click::State state,
-                                 void* owner);
+                                 void* owner, unsigned modi);
 
     enum SkBackEndTypes {
         kNone_BackEndType,
diff --git a/include/views/SkView.h b/include/views/SkView.h
index 00c1356..698c8c7 100644
--- a/include/views/SkView.h
+++ b/include/views/SkView.h
@@ -156,6 +156,7 @@
         SkIPoint    fIOrig, fIPrev, fICurr;
         State       fState;
         void*       fOwner;
+        unsigned    fModifierKeys;
 
         SkMetaData  fMeta;
     private:
@@ -167,11 +168,11 @@
 
         friend class SkView;
     };
-    Click*  findClickHandler(SkScalar x, SkScalar y);
+    Click*  findClickHandler(SkScalar x, SkScalar y, unsigned modifierKeys);
 
-    static void DoClickDown(Click*, int x, int y);
-    static void DoClickMoved(Click*, int x, int y);
-    static void DoClickUp(Click*, int x, int y);
+    static void DoClickDown(Click*, int x, int y, unsigned modi);
+    static void DoClickMoved(Click*, int x, int y, unsigned modi);
+    static void DoClickUp(Click*, int x, int y, unsigned modi);
 
     /** 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
@@ -345,13 +346,13 @@
 
     /** Override this if you might handle the click
     */
-    virtual Click* onFindClickHandler(SkScalar x, SkScalar y);
+    virtual Click* onFindClickHandler(SkScalar x, SkScalar y, unsigned modi);
     /** 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);
+    virtual bool onSendClickToChildren(SkScalar x, SkScalar y, unsigned modi);
     /** Override this to track clicks, returning true as long as you want to track
         the pen/mouse.
     */
diff --git a/include/views/SkWindow.h b/include/views/SkWindow.h
index ca48e27..ca68e75 100644
--- a/include/views/SkWindow.h
+++ b/include/views/SkWindow.h
@@ -45,7 +45,7 @@
     // 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, void* owner = NULL);
+    bool    handleClick(int x, int y, Click::State, void* owner, unsigned modi = 0);
     bool    handleChar(SkUnichar);
     bool    handleKey(SkKey);
     bool    handleKeyUp(SkKey);
@@ -67,7 +67,7 @@
         const char path[]) {}
 protected:
     virtual bool onEvent(const SkEvent&);
-    virtual bool onDispatchClick(int x, int y, Click::State, void* owner);
+    virtual bool onDispatchClick(int x, int y, Click::State, void* owner, unsigned modi);
     // called if part of our bitmap is invalidated
     virtual void onHandleInval(const SkIRect&);
     virtual bool onHandleChar(SkUnichar);
diff --git a/samplecode/SampleAll.cpp b/samplecode/SampleAll.cpp
index 662d561..e783d3d 100644
--- a/samplecode/SampleAll.cpp
+++ b/samplecode/SampleAll.cpp
@@ -530,10 +530,10 @@
 SkCornerPathEffect.h:28:class SkCornerPathEffect : public SkPathEffect {
 */
 
-    virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
+    virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y, unsigned modi) {
         fClickPt.set(x, y);
         this->inval(NULL);
-        return this->INHERITED::onFindClickHandler(x, y);
+        return this->INHERITED::onFindClickHandler(x, y, modi);
     }
 
     SkPathEffect* pathEffectTest() {
diff --git a/samplecode/SampleApp.cpp b/samplecode/SampleApp.cpp
index 716998f..b2789bc 100644
--- a/samplecode/SampleApp.cpp
+++ b/samplecode/SampleApp.cpp
@@ -1955,7 +1955,7 @@
 static const char gGestureClickType[] = "GestureClickType";
 
 bool SampleWindow::onDispatchClick(int x, int y, Click::State state,
-        void* owner) {
+        void* owner, unsigned modi) {
     if (Click::kMoved_State == state) {
         updatePointer(x, y);
     }
@@ -1970,9 +1970,19 @@
         //it's only necessary to update the drawing if there's a click
         this->inval(NULL);
         return false; //prevent dragging while magnify is enabled
-    }
-    else {
-        return this->INHERITED::onDispatchClick(x, y, state, owner);
+    } else {
+        // capture control+option, and trigger debugger
+        if ((modi & kControl_SkModifierKey) && (modi & kOption_SkModifierKey)) {
+            if (Click::kDown_State == state) {
+                SkEvent evt("debug-hit-test");
+                evt.setS32("debug-hit-test-x", x);
+                evt.setS32("debug-hit-test-y", y);
+                curr_view(this)->doEvent(evt);
+            }
+            return true;
+        } else {
+            return this->INHERITED::onDispatchClick(x, y, state, owner, modi);
+        }
     }
 }
 
@@ -1987,7 +1997,8 @@
     }
 };
 
-SkView::Click* SampleWindow::onFindClickHandler(SkScalar x, SkScalar y) {
+SkView::Click* SampleWindow::onFindClickHandler(SkScalar x, SkScalar y,
+                                                unsigned modi) {
     return new GestureClick(this);
 }
 
@@ -2234,11 +2245,21 @@
         fRepeatCount = evt.getFast32();
         return true;
     }
+
     int32_t pipeHolder;
     if (evt.findS32(set_use_pipe_tag, &pipeHolder)) {
         fPipeState = static_cast<SkOSMenu::TriState>(pipeHolder);
         return true;
     }
+
+    if (evt.isType("debug-hit-test")) {
+        fDebugHitTest = true;
+        evt.findS32("debug-hit-test-x", &fDebugHitTestLoc.fX);
+        evt.findS32("debug-hit-test-y", &fDebugHitTestLoc.fY);
+        this->inval(NULL);
+        return true;
+    }
+
     return this->INHERITED::onEvent(evt);
 }
 
@@ -2347,13 +2368,46 @@
         writer.endRecording();
     }
 }
+
+#include "SkBounder.h"
+
+class DebugHitTestBounder : public SkBounder {
+public:
+    DebugHitTestBounder(int x, int y) {
+        fLoc.set(x, y);
+    }
+
+    virtual bool onIRect(const SkIRect& bounds) SK_OVERRIDE {
+        if (bounds.contains(fLoc.x(), fLoc.y())) {
+            //
+            // Set a break-point here to see what was being drawn under
+            // the click point (just needed a line of code to stop the debugger)
+            //
+            bounds.centerX();
+        }
+        return true;
+    }
+
+private:
+    SkIPoint fLoc;
+    typedef SkBounder INHERITED;
+};
+
 void SampleView::onDraw(SkCanvas* canvas) {
     this->onDrawBackground(canvas);
 
+    DebugHitTestBounder bounder(fDebugHitTestLoc.x(), fDebugHitTestLoc.y());
+    if (fDebugHitTest) {
+        canvas->setBounder(&bounder);
+    }
+
     for (int i = 0; i < fRepeatCount; i++) {
         SkAutoCanvasRestore acr(canvas, true);
         this->onDrawContent(canvas);
     }
+
+    fDebugHitTest = false;
+    canvas->setBounder(NULL);
 }
 
 void SampleView::onDrawBackground(SkCanvas* canvas) {
diff --git a/samplecode/SampleApp.h b/samplecode/SampleApp.h
index 2308a12..ecf552c 100644
--- a/samplecode/SampleApp.h
+++ b/samplecode/SampleApp.h
@@ -119,22 +119,24 @@
     DeviceType getDeviceType() const { return fDeviceType; }
 
 protected:
-    virtual void onDraw(SkCanvas* canvas);
-    virtual bool onHandleKey(SkKey key);
-    virtual bool onHandleChar(SkUnichar);
-    virtual void onSizeChange();
+    virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE;
+    virtual bool onHandleKey(SkKey key) SK_OVERRIDE;
+    virtual bool onHandleChar(SkUnichar) SK_OVERRIDE;
+    virtual void onSizeChange() SK_OVERRIDE;
 
-    virtual SkCanvas* beforeChildren(SkCanvas*);
-    virtual void afterChildren(SkCanvas*);
-    virtual void beforeChild(SkView* child, SkCanvas* canvas);
-    virtual void afterChild(SkView* child, SkCanvas* canvas);
+    virtual SkCanvas* beforeChildren(SkCanvas*) SK_OVERRIDE;
+    virtual void afterChildren(SkCanvas*) SK_OVERRIDE;
+    virtual void beforeChild(SkView* child, SkCanvas* canvas) SK_OVERRIDE;
+    virtual void afterChild(SkView* child, SkCanvas* canvas) SK_OVERRIDE;
 
-    virtual bool onEvent(const SkEvent& evt);
-    virtual bool onQuery(SkEvent* evt);
+    virtual bool onEvent(const SkEvent& evt) SK_OVERRIDE;
+    virtual bool onQuery(SkEvent* evt) SK_OVERRIDE;
 
-    virtual bool onDispatchClick(int x, int y, Click::State, void* owner);
-    virtual bool onClick(Click* click);
-    virtual Click* onFindClickHandler(SkScalar x, SkScalar y);
+    virtual bool onDispatchClick(int x, int y, Click::State, void* owner,
+                                 unsigned modi) SK_OVERRIDE;
+    virtual bool onClick(Click* click) SK_OVERRIDE;
+    virtual Click* onFindClickHandler(SkScalar x, SkScalar y,
+                                      unsigned modi) SK_OVERRIDE;
 
     void registerPictFileSamples(char** argv, int argc);
     void registerPictFileSample(char** argv, int argc);
diff --git a/samplecode/SampleArc.cpp b/samplecode/SampleArc.cpp
index a87d280..3b6c8e9 100644
--- a/samplecode/SampleArc.cpp
+++ b/samplecode/SampleArc.cpp
@@ -168,10 +168,11 @@
         this->inval(NULL);
     }
 
-    virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
+    virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y,
+                                              unsigned modi) {
      //   fSweep += SK_Scalar1;
         this->inval(NULL);
-        return this->INHERITED::onFindClickHandler(x, y);
+        return this->INHERITED::onFindClickHandler(x, y, modi);
     }
 
     virtual bool onClick(Click* click) {
diff --git a/samplecode/SampleCode.h b/samplecode/SampleCode.h
index 8bd5fbd..b526787 100644
--- a/samplecode/SampleCode.h
+++ b/samplecode/SampleCode.h
@@ -107,8 +107,11 @@
 
 class SampleView : public SkView {
 public:
-    SampleView() : fPipeState(SkOSMenu::kOffState),
-            fBGColor(SK_ColorWHITE), fRepeatCount(1) {
+    SampleView()
+        : fPipeState(SkOSMenu::kOffState)
+        , fBGColor(SK_ColorWHITE)
+        , fRepeatCount(1)
+        , fDebugHitTest(false) {
     }
 
     void setBGColor(SkColor color) { fBGColor = color; }
@@ -142,6 +145,9 @@
 private:
     int fRepeatCount;
 
+    bool fDebugHitTest;
+    SkIPoint fDebugHitTestLoc;
+
     typedef SkView INHERITED;
 };
 
diff --git a/samplecode/SampleConcavePaths.cpp b/samplecode/SampleConcavePaths.cpp
index 549e9e2..4677dbc 100644
--- a/samplecode/SampleConcavePaths.cpp
+++ b/samplecode/SampleConcavePaths.cpp
@@ -137,9 +137,10 @@
         }
     }
 
-    virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
+    virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y,
+                                              unsigned modi) {
         this->inval(NULL);
-        return this->INHERITED::onFindClickHandler(x, y);
+        return this->INHERITED::onFindClickHandler(x, y, modi);
     }
 
 private:
diff --git a/samplecode/SampleEncode.cpp b/samplecode/SampleEncode.cpp
index afcde03..003c47a 100644
--- a/samplecode/SampleEncode.cpp
+++ b/samplecode/SampleEncode.cpp
@@ -215,9 +215,10 @@
         }
     }
 
-    virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
+    virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y,
+                                              unsigned modi) {
         this->inval(NULL);
-        return this->INHERITED::onFindClickHandler(x, y);
+        return this->INHERITED::onFindClickHandler(x, y, modi);
     }
 
 private:
diff --git a/samplecode/SampleHairline.cpp b/samplecode/SampleHairline.cpp
index 28ed68f..1b16504 100644
--- a/samplecode/SampleHairline.cpp
+++ b/samplecode/SampleHairline.cpp
@@ -261,10 +261,11 @@
         }
     }
 
-    virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
+    virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y,
+                                              unsigned modi) {
         fDoAA = !fDoAA;
         this->inval(NULL);
-        return this->INHERITED::onFindClickHandler(x, y);
+        return this->INHERITED::onFindClickHandler(x, y, modi);
     }
 
 
diff --git a/samplecode/SampleLayers.cpp b/samplecode/SampleLayers.cpp
index cf6b009..03aa9fc 100644
--- a/samplecode/SampleLayers.cpp
+++ b/samplecode/SampleLayers.cpp
@@ -249,10 +249,11 @@
         canvas->restore();
     }
 
-    virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
+    virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y,
+                                              unsigned modi) SK_OVERRIDE {
         this->inval(NULL);
 
-        return this->INHERITED::onFindClickHandler(x, y);
+        return this->INHERITED::onFindClickHandler(x, y, modi);
     }
 
     virtual bool onClick(Click* click) {
diff --git a/samplecode/SamplePatch.cpp b/samplecode/SamplePatch.cpp
index 90aaf4c..c656d7d 100644
--- a/samplecode/SamplePatch.cpp
+++ b/samplecode/SamplePatch.cpp
@@ -310,13 +310,14 @@
         return SkPoint::Length(pt.fX - x, pt.fY - y) < SkIntToScalar(5);
     }
 
-    virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
+    virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y,
+                                              unsigned modi) SK_OVERRIDE {
         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);
+        return this->INHERITED::onFindClickHandler(x, y, modi);
     }
 
     virtual bool onClick(Click* click) {
diff --git a/samplecode/SamplePath.cpp b/samplecode/SamplePath.cpp
index b07307a..80e307b 100644
--- a/samplecode/SamplePath.cpp
+++ b/samplecode/SamplePath.cpp
@@ -202,10 +202,10 @@
         this->inval(NULL);
     }
 
-    virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
+    virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y, unsigned modi) SK_OVERRIDE {
         fShowHairline = !fShowHairline;
         this->inval(NULL);
-        return this->INHERITED::onFindClickHandler(x, y);
+        return this->INHERITED::onFindClickHandler(x, y, modi);
     }
 
 private:
diff --git a/samplecode/SampleRepeatTile.cpp b/samplecode/SampleRepeatTile.cpp
index 54c79ef..357ab63 100644
--- a/samplecode/SampleRepeatTile.cpp
+++ b/samplecode/SampleRepeatTile.cpp
@@ -67,10 +67,10 @@
         canvas->drawPaint(paint);
     }
 
-    virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
+    virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y, unsigned modi) SK_OVERRIDE {
         this->inval(NULL);
 
-        return this->INHERITED::onFindClickHandler(x, y);
+        return this->INHERITED::onFindClickHandler(x, y, modi);
     }
 
     virtual bool onClick(Click* click) {
diff --git a/samplecode/SampleRotateCircles.cpp b/samplecode/SampleRotateCircles.cpp
index 5bac6cf..d16d07f 100644
--- a/samplecode/SampleRotateCircles.cpp
+++ b/samplecode/SampleRotateCircles.cpp
@@ -329,13 +329,14 @@
         MyClick(SkView* target, int index) : Click(target), fIndex(index) {}
     };
 
-    virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
+    virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y,
+                                              unsigned modi) SK_OVERRIDE {
         for (size_t i = 0; i < SK_ARRAY_COUNT(fPts); ++i) {
             if (hittest(fPts[i], x, y)) {
                 return new MyClick(this, i);
             }
         }
-        return this->INHERITED::onFindClickHandler(x, y);
+        return this->INHERITED::onFindClickHandler(x, y, modi);
     }
 
     virtual bool onClick(Click* click) {
diff --git a/samplecode/SampleShaders.cpp b/samplecode/SampleShaders.cpp
index 78b63a3..5c28fd5 100644
--- a/samplecode/SampleShaders.cpp
+++ b/samplecode/SampleShaders.cpp
@@ -121,9 +121,10 @@
         canvas->drawRect(r, paint);
     }
 
-    virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
+    virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y,
+                                              unsigned modi) SK_OVERRIDE {
         this->inval(NULL);
-        return this->INHERITED::onFindClickHandler(x, y);
+        return this->INHERITED::onFindClickHandler(x, y, modi);
     }
 
     virtual bool onClick(Click* click) {
diff --git a/samplecode/SampleStrokePath.cpp b/samplecode/SampleStrokePath.cpp
index ca5135d..3bc0a12 100644
--- a/samplecode/SampleStrokePath.cpp
+++ b/samplecode/SampleStrokePath.cpp
@@ -209,9 +209,10 @@
         drawSet(canvas, &paint);
     }
 
-    virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
+    virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y,
+                                              unsigned modi) SK_OVERRIDE {
         this->inval(NULL);
-        return this->INHERITED::onFindClickHandler(x, y);
+        return this->INHERITED::onFindClickHandler(x, y, modi);
     }
 private:
     typedef SampleView INHERITED;
diff --git a/samplecode/SampleText.cpp b/samplecode/SampleText.cpp
index 26c122d..20673ee 100644
--- a/samplecode/SampleText.cpp
+++ b/samplecode/SampleText.cpp
@@ -305,10 +305,11 @@
         }
     }
 
-    virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
+    virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y,
+                                              unsigned modi) SK_OVERRIDE {
         fClickX = x;
         this->inval(NULL);
-        return this->INHERITED::onFindClickHandler(x, y);
+        return this->INHERITED::onFindClickHandler(x, y, modi);
     }
 
     virtual bool onClick(Click* click) {
diff --git a/samplecode/SampleTextOnPath.cpp b/samplecode/SampleTextOnPath.cpp
index 976f3c8..2337a08 100644
--- a/samplecode/SampleTextOnPath.cpp
+++ b/samplecode/SampleTextOnPath.cpp
@@ -150,10 +150,10 @@
             this->inval(NULL);
     }
 
-    virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
+    virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y, unsigned modi) SK_OVERRIDE {
         fHints += 1;
         this->inval(NULL);
-        return this->INHERITED::onFindClickHandler(x, y);
+        return this->INHERITED::onFindClickHandler(x, y, modi);
     }
 
     virtual bool onClick(Click* click) {
diff --git a/src/views/SkView.cpp b/src/views/SkView.cpp
index 94eb490..0c6c0de 100644
--- a/src/views/SkView.cpp
+++ b/src/views/SkView.cpp
@@ -372,13 +372,12 @@
     }
 }
 
-SkView::Click* SkView::findClickHandler(SkScalar x, SkScalar y)
-{
+SkView::Click* SkView::findClickHandler(SkScalar x, SkScalar y, unsigned modi) {
     if (x < 0 || y < 0 || x >= fWidth || y >= fHeight) {
         return NULL;
     }
 
-    if (this->onSendClickToChildren(x, y)) {
+    if (this->onSendClickToChildren(x, y, modi)) {
         F2BIter    iter(this);
         SkView*    child;
 
@@ -389,7 +388,7 @@
                 continue;
             }
 
-            Click* click = child->findClickHandler(p.fX, p.fY);
+            Click* click = child->findClickHandler(p.fX, p.fY, modi);
 
             if (click) {
                 return click;
@@ -397,10 +396,10 @@
         }
     }
 
-    return this->onFindClickHandler(x, y);
+    return this->onFindClickHandler(x, y, modi);
 }
 
-void SkView::DoClickDown(Click* click, int x, int y)
+void SkView::DoClickDown(Click* click, int x, int y, unsigned modi)
 {
     SkASSERT(click);
 
@@ -420,10 +419,11 @@
     click->fPrev = click->fCurr = click->fOrig;
 
     click->fState = Click::kDown_State;
+    click->fModifierKeys = modi;
     target->onClick(click);
 }
 
-void SkView::DoClickMoved(Click* click, int x, int y)
+void SkView::DoClickMoved(Click* click, int x, int y, unsigned modi)
 {
     SkASSERT(click);
 
@@ -443,10 +443,11 @@
     }
 
     click->fState = Click::kMoved_State;
+    click->fModifierKeys = modi;
     target->onClick(click);
 }
 
-void SkView::DoClickUp(Click* click, int x, int y)
+void SkView::DoClickUp(Click* click, int x, int y, unsigned modi)
 {
     SkASSERT(click);
 
@@ -466,6 +467,7 @@
     }
 
     click->fState = Click::kUp_State;
+    click->fModifierKeys = modi;
     target->onClick(click);
 }
 
@@ -489,11 +491,11 @@
 
 void SkView::onSizeChange() {}
 
-bool SkView::onSendClickToChildren(SkScalar x, SkScalar y) {
+bool SkView::onSendClickToChildren(SkScalar x, SkScalar y, unsigned modi) {
     return true;
 }
 
-SkView::Click* SkView::onFindClickHandler(SkScalar x, SkScalar y) {
+SkView::Click* SkView::onFindClickHandler(SkScalar x, SkScalar y, unsigned modi) {
     return NULL;
 }
 
diff --git a/src/views/SkWindow.cpp b/src/views/SkWindow.cpp
index b02631d..0f0d9c1 100644
--- a/src/views/SkWindow.cpp
+++ b/src/views/SkWindow.cpp
@@ -358,12 +358,13 @@
     return false;
 }
 
-bool SkWindow::handleClick(int x, int y, Click::State state, void *owner) {
-    return this->onDispatchClick(x, y, state, owner);
+bool SkWindow::handleClick(int x, int y, Click::State state, void *owner,
+                           unsigned modifierKeys) {
+    return this->onDispatchClick(x, y, state, owner, modifierKeys);
 }
 
 bool SkWindow::onDispatchClick(int x, int y, Click::State state,
-        void* owner) {
+                               void* owner, unsigned modifierKeys) {
     bool handled = false;
 
     // First, attempt to find an existing click with this owner.
@@ -382,25 +383,25 @@
                 fClicks.remove(index);
             }
             Click* click = this->findClickHandler(SkIntToScalar(x),
-                    SkIntToScalar(y));
+                                                  SkIntToScalar(y), modifierKeys);
 
             if (click) {
                 click->fOwner = owner;
                 *fClicks.append() = click;
-                SkView::DoClickDown(click, x, y);
+                SkView::DoClickDown(click, x, y, modifierKeys);
                 handled = true;
             }
             break;
         }
         case Click::kMoved_State:
             if (index != -1) {
-                SkView::DoClickMoved(fClicks[index], x, y);
+                SkView::DoClickMoved(fClicks[index], x, y, modifierKeys);
                 handled = true;
             }
             break;
         case Click::kUp_State:
             if (index != -1) {
-                SkView::DoClickUp(fClicks[index], x, y);
+                SkView::DoClickUp(fClicks[index], x, y, modifierKeys);
                 delete fClicks[index];
                 fClicks.remove(index);
                 handled = true;
diff --git a/src/views/mac/SkNSView.mm b/src/views/mac/SkNSView.mm
index ffa9d7c..fc82ac4 100644
--- a/src/views/mac/SkNSView.mm
+++ b/src/views/mac/SkNSView.mm
@@ -192,35 +192,68 @@
  //     unichar c = [[event characters] characterAtIndex:0];
 }
 
+static const struct {
+    unsigned    fNSModifierMask;
+    unsigned    fSkModifierMask;
+} gModifierMasks[] = {
+    { NSAlphaShiftKeyMask,  kShift_SkModifierKey },
+    { NSShiftKeyMask,       kShift_SkModifierKey },
+    { NSControlKeyMask,     kControl_SkModifierKey },
+    { NSAlternateKeyMask,   kOption_SkModifierKey },
+    { NSCommandKeyMask,     kCommand_SkModifierKey },
+};
+
+static unsigned convertNSModifiersToSk(NSUInteger nsModi) {
+    unsigned skModi = 0;
+    for (size_t i = 0; i < SK_ARRAY_COUNT(gModifierMasks); ++i) {
+        if (nsModi & gModifierMasks[i].fNSModifierMask) {
+            skModi |= gModifierMasks[i].fSkModifierMask;
+        }
+    }
+    return skModi;
+}
+
 - (void)mouseDown:(NSEvent *)event {
     NSPoint p = [event locationInWindow];
+    unsigned modi = convertNSModifiersToSk([event modifierFlags]);
+
     if ([self mouse:p inRect:[self bounds]] && NULL != fWind) {
         NSPoint loc = [self convertPoint:p fromView:nil];
-        fWind->handleClick((int) loc.x, (int) loc.y, SkView::Click::kDown_State, self);
+        fWind->handleClick((int) loc.x, (int) loc.y,
+                           SkView::Click::kDown_State, self, modi);
     }
 }
 
 - (void)mouseDragged:(NSEvent *)event {
     NSPoint p = [event locationInWindow];
+    unsigned modi = convertNSModifiersToSk([event modifierFlags]);
+
     if ([self mouse:p inRect:[self bounds]] && NULL != fWind) {
         NSPoint loc = [self convertPoint:p fromView:nil];
-        fWind->handleClick((int) loc.x, (int) loc.y, SkView::Click::kMoved_State, self);
+        fWind->handleClick((int) loc.x, (int) loc.y,
+                           SkView::Click::kMoved_State, self, modi);
     }
 }
 
 - (void)mouseMoved:(NSEvent *)event {
     NSPoint p = [event locationInWindow];
+    unsigned modi = convertNSModifiersToSk([event modifierFlags]);
+    
     if ([self mouse:p inRect:[self bounds]] && NULL != fWind) {
         NSPoint loc = [self convertPoint:p fromView:nil];
-        fWind->handleClick((int) loc.x, (int) loc.y, SkView::Click::kMoved_State, self);
+        fWind->handleClick((int) loc.x, (int) loc.y,
+                           SkView::Click::kMoved_State, self, modi);
     }
 }
 
 - (void)mouseUp:(NSEvent *)event {
     NSPoint p = [event locationInWindow];
+    unsigned modi = convertNSModifiersToSk([event modifierFlags]);
+    
     if ([self mouse:p inRect:[self bounds]] && NULL != fWind) {
         NSPoint loc = [self convertPoint:p fromView:nil];
-        fWind->handleClick((int) loc.x, (int) loc.y, SkView::Click::kUp_State, self);
+        fWind->handleClick((int) loc.x, (int) loc.y,
+                           SkView::Click::kUp_State, self, modi);
     }
 }
 
diff --git a/src/views/mac/SkOSWindow_Mac.mm b/src/views/mac/SkOSWindow_Mac.mm
index a288ae3..01c8677 100644
--- a/src/views/mac/SkOSWindow_Mac.mm
+++ b/src/views/mac/SkOSWindow_Mac.mm
@@ -48,8 +48,9 @@
     return this->INHERITED::onEvent(evt);
 }
 
-bool SkOSWindow::onDispatchClick(int x, int y, Click::State state, void* owner) {
-    return this->INHERITED::onDispatchClick(x, y, state, owner);
+bool SkOSWindow::onDispatchClick(int x, int y, Click::State state, void* owner,
+                                 unsigned modi) {
+    return this->INHERITED::onDispatchClick(x, y, state, owner, modi);
 }
 
 void SkOSWindow::onSetTitle(const char title[]) {
diff --git a/src/views/unix/SkOSWindow_Unix.cpp b/src/views/unix/SkOSWindow_Unix.cpp
index 46a2b3d..6c973e0 100644
--- a/src/views/unix/SkOSWindow_Unix.cpp
+++ b/src/views/unix/SkOSWindow_Unix.cpp
@@ -150,6 +150,11 @@
     XFlush(fUnixWindow.fDisplay);
 }
 
+static unsigned getModifierKeys(const XEvent& evt) {
+//    unsigned xmod = evt.xkey.state;
+    return 0;   // TODO
+}
+
 void SkOSWindow::loop() {
     Display* dsp = fUnixWindow.fDisplay;
     if (NULL == dsp) {
@@ -171,14 +176,17 @@
                 break;
             case ButtonPress:
                 if (evt.xbutton.button == Button1)
-                    this->handleClick(evt.xbutton.x, evt.xbutton.y, SkView::Click::kDown_State);
+                    this->handleClick(evt.xbutton.x, evt.xbutton.y,
+                              SkView::Click::kDown_State, getModifierKeys(evt));
                 break;
             case ButtonRelease:
                 if (evt.xbutton.button == Button1)
-                    this->handleClick(evt.xbutton.x, evt.xbutton.y, SkView::Click::kUp_State);
+                    this->handleClick(evt.xbutton.x, evt.xbutton.y,
+                                  SkView::Click::kUp_State, getModifierKeys(evt));
                 break;
             case MotionNotify:
-                this->handleClick(evt.xmotion.x, evt.xmotion.y, SkView::Click::kMoved_State);
+                this->handleClick(evt.xmotion.x, evt.xmotion.y,
+                              SkView::Click::kMoved_State, getModifierKeys(evt));
                 break;
             case KeyPress: {
                 KeySym keysym = XkbKeycodeToKeysym(dsp, evt.xkey.keycode, 0, 0);
diff --git a/src/views/win/SkOSWindow_win.cpp b/src/views/win/SkOSWindow_win.cpp
index 150be6a..5ae00cb 100644
--- a/src/views/win/SkOSWindow_win.cpp
+++ b/src/views/win/SkOSWindow_win.cpp
@@ -103,6 +103,10 @@
     return kNONE_SkKey;
 }
 
+static unsigned getModifiers(UINT message) {
+    return 0;   // TODO
+}
+
 bool SkOSWindow::wndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) {
     switch (message) {
         case WM_KEYDOWN: {
@@ -146,15 +150,18 @@
         } break;
 
         case WM_LBUTTONDOWN:
-            this->handleClick(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam), Click::kDown_State);
+            this->handleClick(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam),
+                              Click::kDown_State, getModifiers(message));
             return true;
 
         case WM_MOUSEMOVE:
-            this->handleClick(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam), Click::kMoved_State);
+            this->handleClick(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam),
+                              Click::kMoved_State, getModifiers(message));
             return true;
 
         case WM_LBUTTONUP:
-            this->handleClick(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam), Click::kUp_State);
+            this->handleClick(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam),
+                              Click::kUp_State, getModifiers(message));
             return true;
 
         case WM_EVENT_CALLBACK: