chrome/browser/ui/cocoa/draggable_button_mixin.mm

   1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #import "chrome/browser/ui/cocoa/draggable_button.h"
   6
   7 #include <cmath>
   8
   9 #include "base/logging.h"
  10
  11 // Code taken from <http://codereview.chromium.org/180036/diff/3001/3004>.
  12 // TODO(viettrungluu): Do we want common, standard code for drag hysteresis?
  13 const CGFloat kWebDragStartHysteresisX = 5.0;
  14 const CGFloat kWebDragStartHysteresisY = 5.0;
  15 const CGFloat kDragExpirationTimeout = 0.45;
  16
  17 // Private /////////////////////////////////////////////////////////////////////
  18
  19 @interface DraggableButtonImpl (Private)
  20
  21 - (BOOL)deltaIndicatesDragStartWithXDelta:(float)xDelta
  22                                    yDelta:(float)yDelta
  23                               xHysteresis:(float)xHysteresis
  24                               yHysteresis:(float)yHysteresis;
  25 - (BOOL)deltaIndicatesConclusionReachedWithXDelta:(float)xDelta
  26                                            yDelta:(float)yDelta
  27                                       xHysteresis:(float)xHysteresis
  28                                       yHysteresis:(float)yHysteresis;
  29 - (void)performMouseDownAction:(NSEvent*)theEvent;
  30 - (void)endDrag;
  31 - (BOOL)dragShouldBeginFromMouseDown:(NSEvent*)mouseDownEvent
  32                       withExpiration:(NSDate*)expiration;
  33 - (BOOL)dragShouldBeginFromMouseDown:(NSEvent*)mouseDownEvent
  34                       withExpiration:(NSDate*)expiration
  35                          xHysteresis:(float)xHysteresis
  36                          yHysteresis:(float)yHysteresis;
  37
  38 @end
  39
  40 // Implementation //////////////////////////////////////////////////////////////
  41
  42 @implementation DraggableButtonImpl
  43
  44 @synthesize draggable = draggable_;
  45 @synthesize actsOnMouseDown = actsOnMouseDown_;
  46 @synthesize durationMouseWasDown = durationMouseWasDown_;
  47 @synthesize actionHasFired = actionHasFired_;
  48 @synthesize whenMouseDown = whenMouseDown_;
  49
  50 - (id)initWithButton:(NSButton<DraggableButtonMixin>*)button {
  51   if ((self = [super init])) {
  52     button_ = button;
  53     draggable_ = YES;
  54     actsOnMouseDown_ = NO;
  55     actionHasFired_ = NO;
  56   }
  57   return self;
  58 }
  59
  60 // NSButton/NSResponder Implementations ////////////////////////////////////////
  61
  62 - (DraggableButtonResult)mouseUpImpl:(NSEvent*)theEvent {
  63   durationMouseWasDown_ = [theEvent timestamp] - whenMouseDown_;
  64
  65   if (actionHasFired_)
  66     return kDraggableButtonImplDidWork;
  67
  68   if (!draggable_)
  69     return kDraggableButtonMixinCallSuper;
  70
  71   // There are non-drag cases where a |-mouseUp:| may happen (e.g. mouse-down,
  72   // cmd-tab to another application, move mouse, mouse-up), so check.
  73   NSPoint viewLocal = [button_ convertPoint:[theEvent locationInWindow]
  74                                    fromView:[[button_ window] contentView]];
  75   if (NSPointInRect(viewLocal, [button_ bounds]))
  76     [button_ performClick:self];
  77
  78   return kDraggableButtonImplDidWork;
  79 }
  80
  81 // Mimic "begin a click" operation visually.  Do NOT follow through with normal
  82 // button event handling.
  83 - (DraggableButtonResult)mouseDownImpl:(NSEvent*)theEvent {
  84   [[NSCursor arrowCursor] set];
  85
  86   whenMouseDown_ = [theEvent timestamp];
  87   actionHasFired_ = NO;
  88
  89   if (draggable_) {
  90     NSDate* date = [NSDate dateWithTimeIntervalSinceNow:kDragExpirationTimeout];
  91     if ([self dragShouldBeginFromMouseDown:theEvent
  92                             withExpiration:date]) {
  93       [button_ beginDrag:theEvent];
  94       [self endDrag];
  95     } else {
  96       if (actsOnMouseDown_) {
  97         [self performMouseDownAction:theEvent];
  98         return kDraggableButtonImplDidWork;
  99       } else {
 100         return kDraggableButtonMixinCallSuper;
 101       }
 102     }
 103   } else {
 104     if (actsOnMouseDown_) {
 105       [self performMouseDownAction:theEvent];
 106       return kDraggableButtonImplDidWork;
 107     } else {
 108       return kDraggableButtonMixinCallSuper;
 109     }
 110   }
 111
 112   return kDraggableButtonImplDidWork;
 113 }
 114
 115 // Idempotent Helpers //////////////////////////////////////////////////////////
 116
 117 - (BOOL)deltaIndicatesDragStartWithXDelta:(float)xDelta
 118                                    yDelta:(float)yDelta
 119                               xHysteresis:(float)xHysteresis
 120                               yHysteresis:(float)yHysteresis {
 121   if ([button_ respondsToSelector:@selector(deltaIndicatesDragStartWithXDelta:
 122                                             yDelta:
 123                                             xHysteresis:
 124                                             yHysteresis:
 125                                             indicates:)]) {
 126     BOOL indicates = NO;
 127     DraggableButtonResult result = [button_
 128         deltaIndicatesDragStartWithXDelta:xDelta
 129         yDelta:yDelta
 130         xHysteresis:xHysteresis
 131         yHysteresis:yHysteresis
 132         indicates:&indicates];
 133     if (result != kDraggableButtonImplUseBase)
 134       return indicates;
 135   }
 136   return (std::abs(xDelta) >= xHysteresis) || (std::abs(yDelta) >= yHysteresis);
 137 }
 138
 139 - (BOOL)deltaIndicatesConclusionReachedWithXDelta:(float)xDelta
 140                                            yDelta:(float)yDelta
 141                                       xHysteresis:(float)xHysteresis
 142                                       yHysteresis:(float)yHysteresis {
 143   if ([button_ respondsToSelector:
 144           @selector(deltaIndicatesConclusionReachedWithXDelta:
 145                     yDelta:
 146                     xHysteresis:
 147                     yHysteresis:
 148                     indicates:)]) {
 149     BOOL indicates = NO;
 150     DraggableButtonResult result = [button_
 151         deltaIndicatesConclusionReachedWithXDelta:xDelta
 152         yDelta:yDelta
 153         xHysteresis:xHysteresis
 154         yHysteresis:yHysteresis
 155         indicates:&indicates];
 156     if (result != kDraggableButtonImplUseBase)
 157       return indicates;
 158   }
 159   return (std::abs(xDelta) >= xHysteresis) || (std::abs(yDelta) >= yHysteresis);
 160 }
 161
 162 - (BOOL)dragShouldBeginFromMouseDown:(NSEvent*)mouseDownEvent
 163                       withExpiration:(NSDate*)expiration {
 164   return [self dragShouldBeginFromMouseDown:mouseDownEvent
 165                              withExpiration:expiration
 166                                 xHysteresis:kWebDragStartHysteresisX
 167                                 yHysteresis:kWebDragStartHysteresisY];
 168 }
 169
 170 // Implementation Details //////////////////////////////////////////////////////
 171
 172 // Determine whether a mouse down should turn into a drag; started as copy of
 173 // NSTableView code.
 174 - (BOOL)dragShouldBeginFromMouseDown:(NSEvent*)mouseDownEvent
 175                       withExpiration:(NSDate*)expiration
 176                          xHysteresis:(float)xHysteresis
 177                          yHysteresis:(float)yHysteresis {
 178   if ([mouseDownEvent type] != NSLeftMouseDown) {
 179     return NO;
 180   }
 181
 182   NSEvent* nextEvent = nil;
 183   NSEvent* firstEvent = nil;
 184   NSEvent* dragEvent = nil;
 185   NSEvent* mouseUp = nil;
 186   BOOL dragIt = NO;
 187
 188   while ((nextEvent = [[button_ window]
 189       nextEventMatchingMask:NSLeftMouseUpMask | NSLeftMouseDraggedMask
 190                   untilDate:expiration
 191                      inMode:NSEventTrackingRunLoopMode
 192                     dequeue:YES]) != nil) {
 193     if (firstEvent == nil) {
 194       firstEvent = nextEvent;
 195     }
 196     if ([nextEvent type] == NSLeftMouseDragged) {
 197       float deltax = [nextEvent locationInWindow].x -
 198           [mouseDownEvent locationInWindow].x;
 199       float deltay = [nextEvent locationInWindow].y -
 200           [mouseDownEvent locationInWindow].y;
 201       dragEvent = nextEvent;
 202       if ([self deltaIndicatesConclusionReachedWithXDelta:deltax
 203                                                    yDelta:deltay
 204                                               xHysteresis:xHysteresis
 205                                               yHysteresis:yHysteresis]) {
 206         dragIt = [self deltaIndicatesDragStartWithXDelta:deltax
 207                                                   yDelta:deltay
 208                                              xHysteresis:xHysteresis
 209                                              yHysteresis:yHysteresis];
 210         break;
 211       }
 212     } else if ([nextEvent type] == NSLeftMouseUp) {
 213       mouseUp = nextEvent;
 214       break;
 215     }
 216   }
 217
 218   // Since we've been dequeuing the events (If we don't, we'll never see
 219   // the mouse up...), we need to push some of the events back on.
 220   // It makes sense to put the first and last drag events and the mouse
 221   // up if there was one.
 222   if (mouseUp != nil) {
 223     [NSApp postEvent:mouseUp atStart:YES];
 224   }
 225   if (dragEvent != nil) {
 226     [NSApp postEvent:dragEvent atStart:YES];
 227   }
 228   if (firstEvent != mouseUp && firstEvent != dragEvent) {
 229     [NSApp postEvent:firstEvent atStart:YES];
 230   }
 231
 232   return dragIt;
 233 }
 234
 235 - (void)secondaryMouseUpAction:(BOOL)wasInside {
 236   if ([button_ respondsToSelector:_cmd])
 237     [button_ secondaryMouseUpAction:wasInside];
 238
 239   // No actual implementation yet.
 240 }
 241
 242 - (void)performMouseDownAction:(NSEvent*)event {
 243   if ([button_ respondsToSelector:_cmd] &&
 244       [button_ performMouseDownAction:event] != kDraggableButtonImplUseBase) {
 245       return;
 246   }
 247
 248   int eventMask = NSLeftMouseUpMask;
 249
 250   [[button_ target] performSelector:[button_ action] withObject:self];
 251   actionHasFired_ = YES;
 252
 253   while (1) {
 254     event = [[button_ window] nextEventMatchingMask:eventMask];
 255     if (!event)
 256       continue;
 257     NSPoint mouseLoc = [button_ convertPoint:[event locationInWindow]
 258                                     fromView:nil];
 259     BOOL isInside = [button_ mouse:mouseLoc inRect:[button_ bounds]];
 260     [button_ highlight:isInside];
 261
 262     switch ([event type]) {
 263       case NSLeftMouseUp:
 264         durationMouseWasDown_ = [event timestamp] - whenMouseDown_;
 265         [self secondaryMouseUpAction:isInside];
 266         break;
 267       default:
 268         // Ignore any other kind of event.
 269         break;
 270     }
 271   }
 272
 273   [button_ highlight:NO];
 274 }
 275
 276 - (void)endDrag {
 277   if ([button_ respondsToSelector:_cmd] &&
 278       [button_ endDrag] != kDraggableButtonImplUseBase) {
 279     return;
 280   }
 281   [button_ highlight:NO];
 282 }
 283
 284 @end