blob: 7a953c76b8f4c5adc24b8d263b457265ab68e6f3 [file] [log] [blame]
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/browser/ui/cocoa/gradient_button_cell.h"
#include <cmath>
#include "base/logging.h"
#import "base/mac/scoped_nsobject.h"
#import "chrome/browser/themes/theme_properties.h"
#import "chrome/browser/themes/theme_service.h"
#import "chrome/browser/ui/cocoa/rect_path_utils.h"
#import "chrome/browser/ui/cocoa/themed_window.h"
#include "chrome/grit/theme_resources.h"
#import "third_party/google_toolbox_for_mac/src/AppKit/GTMNSColor+Luminance.h"
#import "ui/base/cocoa/nsgraphics_context_additions.h"
#import "ui/base/cocoa/nsview_additions.h"
#include "ui/gfx/scoped_ns_graphics_context_save_gstate_mac.h"
@interface GradientButtonCell (Private)
- (void)sharedInit;
// Get drawing parameters for a given cell frame in a given view. The inner
// frame is the one required by |-drawInteriorWithFrame:inView:|. The inner and
// outer paths are the ones required by |-drawBorderAndFillForTheme:...|. The
// outer path also gives the area in which to clip. Any of the |return...|
// arguments may be NULL (in which case the given parameter won't be returned).
// If |returnInnerPath| or |returnOuterPath|, |*returnInnerPath| or
// |*returnOuterPath| should be nil, respectively.
- (void)getDrawParamsForFrame:(NSRect)cellFrame
inView:(NSView*)controlView
innerFrame:(NSRect*)returnInnerFrame
innerPath:(NSBezierPath**)returnInnerPath
clipPath:(NSBezierPath**)returnClipPath;
- (void)updateTrackingAreas;
@end
static const NSTimeInterval kAnimationShowDuration = 0.2;
// Note: due to a bug (?), drawWithFrame:inView: does not call
// drawBorderAndFillForTheme::::: unless the mouse is inside. The net
// effect is that our "fade out" when the mouse leaves becaumes
// instantaneous. When I "fixed" it things looked horrible; the
// hover-overed bookmark button would stay highlit for 0.4 seconds
// which felt like latency/lag. I'm leaving the "bug" in place for
// now so we don't suck. -jrg
static const NSTimeInterval kAnimationHideDuration = 0.4;
@implementation GradientButtonCell
@synthesize hoverAlpha = hoverAlpha_;
+ (CGFloat)insetInView:(NSView*)view {
return [view cr_lineWidth];
}
// For nib instantiations
- (id)initWithCoder:(NSCoder*)decoder {
if ((self = [super initWithCoder:decoder])) {
[self sharedInit];
}
return self;
}
// For programmatic instantiations
- (id)initTextCell:(NSString*)string {
if ((self = [super initTextCell:string])) {
[self sharedInit];
}
return self;
}
- (void)dealloc {
if (trackingArea_) {
[[self controlView] removeTrackingArea:trackingArea_];
trackingArea_.reset();
}
[super dealloc];
}
// Return YES if we are pulsing (towards another state or continuously).
- (BOOL)pulsing {
if ((pulseState_ == gradient_button_cell::kPulsingOn) ||
(pulseState_ == gradient_button_cell::kPulsingOff))
return YES;
return NO;
}
// Perform one pulse step when animating a pulse.
- (void)performOnePulseStep {
NSTimeInterval thisUpdate = [NSDate timeIntervalSinceReferenceDate];
NSTimeInterval elapsed = thisUpdate - lastHoverUpdate_;
CGFloat opacity = [self hoverAlpha];
// Update opacity based on state.
// Adjust state if we have finished.
switch (pulseState_) {
case gradient_button_cell::kPulsingOn:
opacity += elapsed / kAnimationShowDuration;
if (opacity > 1.0) {
[self setPulseState:gradient_button_cell::kPulsedOn];
return;
}
break;
case gradient_button_cell::kPulsingOff:
opacity -= elapsed / kAnimationHideDuration;
if (opacity < 0.0) {
[self setPulseState:gradient_button_cell::kPulsedOff];
return;
}
break;
case gradient_button_cell::kPulsingStuckOn:
outerStrokeAlphaMult_ = 1.0;
break;
default:
NOTREACHED() << "unknown pulse state";
}
// Update our control.
lastHoverUpdate_ = thisUpdate;
[self setHoverAlpha:opacity];
[[self controlView] setNeedsDisplay:YES];
// If our state needs it, keep going.
if ([self pulsing]) {
[self performSelector:_cmd withObject:nil afterDelay:0.02];
}
}
- (gradient_button_cell::PulseState)pulseState {
return pulseState_;
}
// Set the pulsing state. This can either set the pulse to on or off
// immediately (e.g. kPulsedOn, kPulsedOff) or initiate an animated
// state change.
- (void)setPulseState:(gradient_button_cell::PulseState)pstate {
pulseState_ = pstate;
[NSObject cancelPreviousPerformRequestsWithTarget:self];
lastHoverUpdate_ = [NSDate timeIntervalSinceReferenceDate];
switch (pstate) {
case gradient_button_cell::kPulsedOn:
case gradient_button_cell::kPulsedOff:
outerStrokeAlphaMult_ = 1.0;
[self setHoverAlpha:((pulseState_ == gradient_button_cell::kPulsedOn) ?
1.0 : 0.0)];
[[self controlView] setNeedsDisplay:YES];
break;
case gradient_button_cell::kPulsingOn:
case gradient_button_cell::kPulsingOff:
outerStrokeAlphaMult_ = 1.0;
// Set initial value then engage timer.
[self setHoverAlpha:((pulseState_ == gradient_button_cell::kPulsingOn) ?
0.0 : 1.0)];
[self performOnePulseStep];
break;
case gradient_button_cell::kPulsingStuckOn:
// Semantics of continuous pulsing are that we pulse independent
// of mouse position.
[self performOnePulseStep];
break;
default:
CHECK(0);
break;
}
}
- (void)safelyStopPulsing {
[NSObject cancelPreviousPerformRequestsWithTarget:self];
}
- (void)setPulseIsStuckOn:(BOOL)on {
if (!on && pulseState_ != gradient_button_cell::kPulsingStuckOn)
return;
if (on) {
[self setPulseState:gradient_button_cell::kPulsingStuckOn];
} else {
[self setPulseState:(isMouseInside_ ? gradient_button_cell::kPulsedOn :
gradient_button_cell::kPulsedOff)];
}
}
- (BOOL)isPulseStuckOn {
return (pulseState_ == gradient_button_cell::kPulsingStuckOn) ?
YES : NO;
}
#if 1
// If we are not continuously pulsing, perform a pulse animation to
// reflect our new state.
- (void)setMouseInside:(BOOL)flag animate:(BOOL)animated {
isMouseInside_ = flag;
if (pulseState_ != gradient_button_cell::kPulsingStuckOn) {
if (animated) {
// In Material Design, if the button is already fully on, don't pulse it
// on again if the mouse is within its bounds.
if ([self tag] == [self isMaterialDesignButtonType] &&
isMouseInside_ && pulseState_ == gradient_button_cell::kPulsedOn) {
return;
}
[self setPulseState:(isMouseInside_ ? gradient_button_cell::kPulsingOn :
gradient_button_cell::kPulsingOff)];
} else {
[self setPulseState:(isMouseInside_ ? gradient_button_cell::kPulsedOn :
gradient_button_cell::kPulsedOff)];
}
}
}
#else
- (void)adjustHoverValue {
NSTimeInterval thisUpdate = [NSDate timeIntervalSinceReferenceDate];
NSTimeInterval elapsed = thisUpdate - lastHoverUpdate_;
CGFloat opacity = [self hoverAlpha];
if (isMouseInside_) {
opacity += elapsed / kAnimationShowDuration;
} else {
opacity -= elapsed / kAnimationHideDuration;
}
if (!isMouseInside_ && opacity < 0) {
opacity = 0;
} else if (isMouseInside_ && opacity > 1) {
opacity = 1;
} else {
[self performSelector:_cmd withObject:nil afterDelay:0.02];
}
lastHoverUpdate_ = thisUpdate;
[self setHoverAlpha:opacity];
[[self controlView] setNeedsDisplay:YES];
}
- (void)setMouseInside:(BOOL)flag animate:(BOOL)animated {
isMouseInside_ = flag;
if (animated) {
lastHoverUpdate_ = [NSDate timeIntervalSinceReferenceDate];
[self adjustHoverValue];
} else {
[NSObject cancelPreviousPerformRequestsWithTarget:self];
[self setHoverAlpha:flag ? 1.0 : 0.0];
}
[[self controlView] setNeedsDisplay:YES];
}
#endif
- (NSGradient*)gradientForHoverAlpha:(CGFloat)hoverAlpha
isThemed:(BOOL)themed {
CGFloat startAlpha = 0.6 + 0.3 * hoverAlpha;
CGFloat endAlpha = 0.333 * hoverAlpha;
if (themed) {
startAlpha = 0.2 + 0.35 * hoverAlpha;
endAlpha = 0.333 * hoverAlpha;
}
NSColor* startColor =
[NSColor colorWithCalibratedWhite:1.0
alpha:startAlpha];
NSColor* endColor =
[NSColor colorWithCalibratedWhite:1.0 - 0.15 * hoverAlpha
alpha:endAlpha];
NSGradient* gradient = [[NSGradient alloc] initWithColorsAndLocations:
startColor, hoverAlpha * 0.33,
endColor, 1.0, nil];
return [gradient autorelease];
}
- (void)sharedInit {
shouldTheme_ = YES;
pulseState_ = gradient_button_cell::kPulsedOff;
outerStrokeAlphaMult_ = 1.0;
gradient_.reset([[self gradientForHoverAlpha:0.0 isThemed:NO] retain]);
}
- (void)setShouldTheme:(BOOL)shouldTheme {
shouldTheme_ = shouldTheme;
}
- (NSBackgroundStyle)interiorBackgroundStyle {
// Never lower the interior, since that just leads to a weird shadow which can
// often interact badly with the theme.
return NSBackgroundStyleRaised;
}
- (void)mouseEntered:(NSEvent*)theEvent {
[self setMouseInside:YES animate:YES];
}
- (void)mouseExited:(NSEvent*)theEvent {
[self setMouseInside:NO animate:YES];
}
- (BOOL)isMouseInside {
return trackingArea_ && isMouseInside_;
}
- (BOOL)startTrackingAt:(NSPoint)startPoint inView:(NSView *)controlView {
if ([self isMaterialDesignButtonType]) {
// The user has just clicked down in the button. In Material Design, set the
// pulsed (hover) state to off now so that if the user keeps the mouse held
// down while dragging it out of the button's bounds, the button will draw
// itself in its normal state. This is unrelated to dragging the button
// in the button bar, which takes a different path through the code.
[self setPulseState:gradient_button_cell::kPulsedOff];
}
return [super startTrackingAt:startPoint inView:controlView];
}
// Since we have our own drawWithFrame:, we need to also have our own
// logic for determining when the mouse is inside for honoring this
// request.
- (void)setShowsBorderOnlyWhileMouseInside:(BOOL)showOnly {
[super setShowsBorderOnlyWhileMouseInside:showOnly];
if (showOnly) {
[self updateTrackingAreas];
} else {
if (trackingArea_) {
[[self controlView] removeTrackingArea:trackingArea_];
trackingArea_.reset(nil);
if (isMouseInside_) {
isMouseInside_ = NO;
[[self controlView] setNeedsDisplay:YES];
}
}
}
}
// TODO(viettrungluu): clean up/reorganize.
- (void)drawBorderAndFillForTheme:(const ui::ThemeProvider*)themeProvider
controlView:(NSView*)controlView
innerPath:(NSBezierPath*)innerPath
showClickedGradient:(BOOL)showClickedGradient
showHighlightGradient:(BOOL)showHighlightGradient
hoverAlpha:(CGFloat)hoverAlpha
active:(BOOL)active
cellFrame:(NSRect)cellFrame
defaultGradient:(NSGradient*)defaultGradient {
// For Material Design, draw a solid rounded rect behind the button, based on
// the hover and pressed states.
if ([self isMaterialDesignButtonType]) {
const CGFloat kEightPercentAlpha = 0.08;
const CGFloat kFourPercentAlpha = 0.04;
// The alpha is always at least 8%. Default the color to black.
CGFloat alpha = kEightPercentAlpha;
CGFloat color = 0.0;
// If a dark theme, increase the opacity slightly and use white.
if ([[controlView window] hasDarkTheme]) {
alpha += kFourPercentAlpha;
color = 1.0;
}
// If clicked or highlighted, the background is slightly more opaque. If not
// clicked or highlighted, adjust the alpha by the animation fade in
// percentage.
if (showClickedGradient || showHighlightGradient) {
alpha += kFourPercentAlpha;
} else {
alpha *= hoverAlpha;
}
// Fill the path.
[[NSColor colorWithCalibratedWhite:color alpha:alpha] set];
[innerPath fill];
return;
}
BOOL isFlatButton = [self showsBorderOnlyWhileMouseInside];
// For flat (unbordered when not hovered) buttons, never use the toolbar
// button background image, but the modest gradient used for themed buttons.
// To make things even more modest, scale the hover alpha down by 40 percent
// unless clicked.
NSColor* backgroundImageColor;
BOOL useThemeGradient;
if (isFlatButton) {
backgroundImageColor = nil;
useThemeGradient = YES;
if (!showClickedGradient)
hoverAlpha *= 0.6;
} else {
backgroundImageColor = nil;
if (themeProvider &&
themeProvider->HasCustomImage(IDR_THEME_BUTTON_BACKGROUND)) {
backgroundImageColor =
themeProvider->GetNSImageColorNamed(IDR_THEME_BUTTON_BACKGROUND);
}
useThemeGradient = backgroundImageColor ? YES : NO;
}
// The basic gradient shown inside; see above.
NSGradient* gradient;
if (hoverAlpha == 0 && !useThemeGradient) {
gradient = defaultGradient ? defaultGradient : gradient_.get();
} else {
gradient = [self gradientForHoverAlpha:hoverAlpha
isThemed:useThemeGradient];
}
// If we're drawing a background image, show that; else possibly show the
// clicked gradient.
if (backgroundImageColor) {
[backgroundImageColor set];
// Set the phase to match window.
NSRect trueRect = [controlView convertRect:cellFrame toView:nil];
[[NSGraphicsContext currentContext]
cr_setPatternPhase:NSMakePoint(NSMinX(trueRect), NSMaxY(trueRect))
forView:controlView];
[innerPath fill];
} else {
if (showClickedGradient) {
NSGradient* clickedGradient = nil;
if (isFlatButton &&
[self tag] == kStandardButtonTypeWithLimitedClickFeedback) {
clickedGradient = gradient;
} else {
clickedGradient = themeProvider ? themeProvider->GetNSGradient(
active ?
ThemeProperties::GRADIENT_TOOLBAR_BUTTON_PRESSED :
ThemeProperties::GRADIENT_TOOLBAR_BUTTON_PRESSED_INACTIVE) :
nil;
}
[clickedGradient drawInBezierPath:innerPath angle:90.0];
}
}
// Visually indicate unclicked, enabled buttons.
if (!showClickedGradient && [self isEnabled]) {
gfx::ScopedNSGraphicsContextSaveGState scopedGState;
[innerPath addClip];
// Draw the inner glow.
if (hoverAlpha > 0) {
[innerPath setLineWidth:2];
[[NSColor colorWithCalibratedWhite:1.0 alpha:0.2 * hoverAlpha] setStroke];
[innerPath stroke];
}
// Draw the top inner highlight.
NSAffineTransform* highlightTransform = [NSAffineTransform transform];
[highlightTransform translateXBy:1 yBy:1];
base::scoped_nsobject<NSBezierPath> highlightPath([innerPath copy]);
[highlightPath transformUsingAffineTransform:highlightTransform];
[[NSColor colorWithCalibratedWhite:1.0 alpha:0.2] setStroke];
[highlightPath stroke];
// Draw the gradient inside.
[gradient drawInBezierPath:innerPath angle:90.0];
}
// Don't draw anything else for disabled flat buttons.
if (isFlatButton && ![self isEnabled])
return;
// Draw the outer stroke.
NSColor* strokeColor = nil;
if (showClickedGradient) {
strokeColor = [NSColor
colorWithCalibratedWhite:0.0
alpha:0.3 * outerStrokeAlphaMult_];
} else {
strokeColor = themeProvider ? themeProvider->GetNSColor(
active ? ThemeProperties::COLOR_TOOLBAR_BUTTON_STROKE :
ThemeProperties::COLOR_TOOLBAR_BUTTON_STROKE_INACTIVE) :
[NSColor colorWithCalibratedWhite:0.0
alpha:0.3 * outerStrokeAlphaMult_];
}
[strokeColor setStroke];
[innerPath setLineWidth:1];
[innerPath stroke];
}
// TODO(viettrungluu): clean this up.
// (Private)
- (void)getDrawParamsForFrame:(NSRect)cellFrame
inView:(NSView*)controlView
innerFrame:(NSRect*)returnInnerFrame
innerPath:(NSBezierPath**)returnInnerPath
clipPath:(NSBezierPath**)returnClipPath {
const CGFloat lineWidth = [[self class] insetInView:controlView];
const CGFloat halfLineWidth = lineWidth / 2.0;
NSRect drawFrame = NSZeroRect;
NSRect innerFrame = NSZeroRect;
CGFloat cornerRadius = 2;
if (![self isMaterialDesignButtonType]) {
drawFrame = NSInsetRect(cellFrame, 1.5 * lineWidth, 1.5 * lineWidth);
innerFrame = NSInsetRect(cellFrame, lineWidth, lineWidth);
cornerRadius = 3;
} else {
drawFrame = cellFrame;
// Hover and click paths are always 20pt tall, regardless of the button's
// height.
drawFrame.size.height = 20;
innerFrame = NSInsetRect(drawFrame, lineWidth, lineWidth);
}
ButtonType type = [[(NSControl*)controlView cell] tag];
switch (type) {
case kMiddleButtonType:
drawFrame.size.width += 20;
innerFrame.size.width += 2;
// Fallthrough
case kRightButtonType:
drawFrame.origin.x -= 20;
innerFrame.origin.x -= 2;
// Fallthrough
case kLeftButtonType:
case kLeftButtonWithShadowType:
drawFrame.size.width += 20;
innerFrame.size.width += 2;
default:
break;
}
if (type == kLeftButtonWithShadowType)
innerFrame.size.width -= 1.0;
// Return results if |return...| not null.
if (returnInnerFrame)
*returnInnerFrame = innerFrame;
if (returnInnerPath) {
DCHECK(*returnInnerPath == nil);
drawFrame.origin.y +=
[self hoverBackgroundVerticalOffsetInControlView:controlView];
if ([self tag] == kMaterialMenuButtonTypeWithLimitedClickFeedback) {
*returnInnerPath = [NSBezierPath bezierPathWithRect:drawFrame];
} else {
*returnInnerPath = [NSBezierPath bezierPathWithRoundedRect:drawFrame
xRadius:cornerRadius
yRadius:cornerRadius];
}
[*returnInnerPath setLineWidth:lineWidth];
}
if (returnClipPath) {
DCHECK(*returnClipPath == nil);
NSRect clipPathRect =
NSInsetRect(drawFrame, -halfLineWidth, -halfLineWidth);
*returnClipPath =
[NSBezierPath bezierPathWithRoundedRect:clipPathRect
xRadius:cornerRadius + halfLineWidth
yRadius:cornerRadius + halfLineWidth];
}
}
// TODO(viettrungluu): clean this up.
- (void)drawWithFrame:(NSRect)cellFrame inView:(NSView*)controlView {
NSRect innerFrame;
NSBezierPath* innerPath = nil;
[self getDrawParamsForFrame:cellFrame
inView:controlView
innerFrame:&innerFrame
innerPath:&innerPath
clipPath:NULL];
BOOL enabled = [((NSControl*)[self controlView]) isEnabled];
BOOL pressed = enabled && [self isHighlighted];
NSWindow* window = [controlView window];
const ui::ThemeProvider* themeProvider = [window themeProvider];
BOOL active = [window isKeyWindow] || [window isMainWindow];
// Stroke the borders and appropriate fill gradient. If we're borderless, the
// only time we want to draw the inner gradient is if we're highlighted or if
// we're drawing the focus ring manually. In Material Design, the "border" is
// actually a highlight, which should be drawn if
// |showsBorderOnlyWhileMouseInside| is true.
BOOL hasMaterialHighlight =
[self isMaterialDesignButtonType] &&
![self showsBorderOnlyWhileMouseInside] &&
enabled;
if (([self isBordered] && ![self showsBorderOnlyWhileMouseInside]) ||
pressed || [self isMouseInside] || [self isPulseStuckOn] ||
hasMaterialHighlight) {
// When pulsing we want the bookmark to stand out a little more.
BOOL showClickedGradient = pressed ||
(pulseState_ == gradient_button_cell::kPulsingStuckOn);
BOOL showHighlightGradient = [self isHighlighted] || hasMaterialHighlight;
[self drawBorderAndFillForTheme:themeProvider
controlView:controlView
innerPath:innerPath
showClickedGradient:showClickedGradient
showHighlightGradient:showHighlightGradient
hoverAlpha:[self hoverAlpha]
active:active
cellFrame:cellFrame
defaultGradient:nil];
}
// If this is the left side of a segmented button, draw a slight shadow.
ButtonType type = [[(NSControl*)controlView cell] tag];
if (type == kLeftButtonWithShadowType) {
const CGFloat lineWidth = [controlView cr_lineWidth];
NSRect borderRect, contentRect;
NSDivideRect(cellFrame, &borderRect, &contentRect, lineWidth, NSMaxXEdge);
NSColor* stroke = themeProvider ? themeProvider->GetNSColor(
active ? ThemeProperties::COLOR_TOOLBAR_BUTTON_STROKE :
ThemeProperties::COLOR_TOOLBAR_BUTTON_STROKE_INACTIVE) :
[NSColor blackColor];
[[stroke colorWithAlphaComponent:0.2] set];
NSRectFillUsingOperation(NSInsetRect(borderRect, 0, 2),
NSCompositeSourceOver);
}
[self drawInteriorWithFrame:innerFrame inView:controlView];
}
- (CGFloat)textStartXOffset {
// 11 is the magic number needed to make this match the native
// NSButtonCell's label display.
return [[self image] size].width + 11;
}
- (void)drawInteriorWithFrame:(NSRect)cellFrame inView:(NSView*)controlView {
const CGFloat lineWidth = [controlView cr_lineWidth];
if (shouldTheme_) {
BOOL isTemplate = [[self image] isTemplate];
gfx::ScopedNSGraphicsContextSaveGState scopedGState;
CGContextRef context =
(CGContextRef)([[NSGraphicsContext currentContext] graphicsPort]);
const ui::ThemeProvider* themeProvider =
[[controlView window] themeProvider];
NSColor* color = themeProvider ?
themeProvider->GetNSColorTint(ThemeProperties::TINT_BUTTONS) :
[NSColor blackColor];
if (isTemplate && themeProvider && themeProvider->UsingSystemTheme()) {
base::scoped_nsobject<NSShadow> shadow([[NSShadow alloc] init]);
[shadow.get() setShadowColor:themeProvider->GetNSColor(
ThemeProperties::COLOR_TOOLBAR_BEZEL)];
[shadow.get() setShadowOffset:NSMakeSize(0.0, -lineWidth)];
[shadow setShadowBlurRadius:lineWidth];
[shadow set];
}
CGContextBeginTransparencyLayer(context, 0);
NSRect imageRect = NSZeroRect;
imageRect.size = [[self image] size];
NSRect drawRect = [self imageRectForBounds:cellFrame];
[[self image] drawInRect:drawRect
fromRect:imageRect
operation:NSCompositeSourceOver
fraction:[self isEnabled] ? 1.0 : 0.5
respectFlipped:YES
hints:nil];
if (isTemplate && color) {
[color set];
NSRectFillUsingOperation(cellFrame, NSCompositeSourceAtop);
}
CGContextEndTransparencyLayer(context);
} else {
// NSCell draws these off-center for some reason, probably because of the
// positioning of the control in the xib.
[super drawInteriorWithFrame:NSOffsetRect(cellFrame, 0, lineWidth)
inView:controlView];
}
}
- (int)verticalTextOffset {
return 1;
}
- (CGFloat)hoverBackgroundVerticalOffsetInControlView:(NSView*)controlView {
return 0.0;
}
- (BOOL)isMaterialDesignButtonType {
return [self tag] == kMaterialStandardButtonTypeWithLimitedClickFeedback ||
[self tag] == kMaterialMenuButtonTypeWithLimitedClickFeedback;
}
// Overriden from NSButtonCell so we can display a nice fadeout effect for
// button titles that overflow.
// This method is copied in the most part from GTMFadeTruncatingTextFieldCell,
// the only difference is that here we draw the text ourselves rather than
// calling the super to do the work.
// We can't use GTMFadeTruncatingTextFieldCell because there's no easy way to
// get it to work with NSButtonCell.
// TODO(jeremy): Move this to GTM.
- (NSRect)drawTitle:(NSAttributedString*)title
withFrame:(NSRect)cellFrame
inView:(NSView*)controlView {
NSSize size = [title size];
// Empirically, Cocoa will draw an extra 2 pixels past NSWidth(cellFrame)
// before it clips the text.
const CGFloat kOverflowBeforeClip = 2;
BOOL isModeMaterial = [self isMaterialDesignButtonType];
// For Material Design we don't want to clip the text. For all other button
// cell modes, we do.
BOOL shouldClipTheTitle = !isModeMaterial;
if (std::floor(size.width) <= (NSWidth(cellFrame) + kOverflowBeforeClip)) {
cellFrame.origin.y += ([self verticalTextOffset] - 1);
shouldClipTheTitle = NO;
}
// Gradient is about twice our line height long.
CGFloat gradientWidth = MIN(size.height * 2, NSWidth(cellFrame) / 4);
NSRect solidPart, gradientPart;
NSDivideRect(cellFrame, &gradientPart, &solidPart, gradientWidth, NSMaxXEdge);
// Draw non-gradient part without transparency layer, as light text on a dark
// background looks bad with a gradient layer.
NSPoint textOffset = NSZeroPoint;
{
gfx::ScopedNSGraphicsContextSaveGState scopedGState;
if (shouldClipTheTitle)
[NSBezierPath clipRect:solidPart];
// For some reason, the height of cellFrame as passed in is totally bogus.
// For vertical centering purposes, we need the bounds of the containing
// view.
NSRect buttonFrame = [[self controlView] frame];
// Call the vertical offset to match native NSButtonCell's version.
textOffset = NSMakePoint(
NSMinX(cellFrame),
(NSHeight(buttonFrame) - size.height) / 2 + [self verticalTextOffset]);
// WIth Material Design we want an ellipsis if the title is too long to fit,
// so have to use drawInRect: instead of drawAtPoint:.
if (isModeMaterial) {
NSRect textFrame = NSMakeRect(textOffset.x, textOffset.y,
NSWidth(cellFrame), NSHeight(buttonFrame));
[title drawInRect:textFrame];
} else {
[title drawAtPoint:textOffset];
}
}
if (!shouldClipTheTitle)
return cellFrame;
// Draw the gradient part with a transparency layer. This makes the text look
// suboptimal, but since it fades out, that's ok.
gfx::ScopedNSGraphicsContextSaveGState scopedGState;
[NSBezierPath clipRect:gradientPart];
CGContextRef context = static_cast<CGContextRef>(
[[NSGraphicsContext currentContext] graphicsPort]);
CGContextBeginTransparencyLayerWithRect(context,
NSRectToCGRect(gradientPart), 0);
[title drawAtPoint:textOffset];
NSColor *color = [NSColor textColor];
NSColor *alphaColor = [color colorWithAlphaComponent:0.0];
NSGradient *mask = [[NSGradient alloc] initWithStartingColor:color
endingColor:alphaColor];
// Draw the gradient mask
CGContextSetBlendMode(context, kCGBlendModeDestinationIn);
[mask drawFromPoint:NSMakePoint(NSMaxX(cellFrame) - gradientWidth,
NSMinY(cellFrame))
toPoint:NSMakePoint(NSMaxX(cellFrame),
NSMinY(cellFrame))
options:NSGradientDrawsBeforeStartingLocation];
[mask release];
CGContextEndTransparencyLayer(context);
return cellFrame;
}
- (NSBezierPath*)clipPathForFrame:(NSRect)cellFrame
inView:(NSView*)controlView {
NSBezierPath* boundingPath = nil;
[self getDrawParamsForFrame:cellFrame
inView:controlView
innerFrame:NULL
innerPath:NULL
clipPath:&boundingPath];
return boundingPath;
}
- (void)resetCursorRect:(NSRect)cellFrame inView:(NSView*)controlView {
[super resetCursorRect:cellFrame inView:controlView];
if (trackingArea_)
[self updateTrackingAreas];
}
- (BOOL)isMouseReallyInside {
BOOL mouseInView = NO;
NSView* controlView = [self controlView];
NSWindow* window = [controlView window];
NSRect bounds = [controlView bounds];
if (window) {
NSPoint mousePoint = [window mouseLocationOutsideOfEventStream];
mousePoint = [controlView convertPoint:mousePoint fromView:nil];
mouseInView = [controlView mouse:mousePoint inRect:bounds];
}
return mouseInView;
}
- (void)updateTrackingAreas {
NSView* controlView = [self controlView];
BOOL mouseInView = [self isMouseReallyInside];
if (trackingArea_.get())
[controlView removeTrackingArea:trackingArea_];
NSTrackingAreaOptions options = NSTrackingMouseEnteredAndExited |
NSTrackingActiveInActiveApp;
if (mouseInView)
options |= NSTrackingAssumeInside;
trackingArea_.reset([[NSTrackingArea alloc]
initWithRect:[controlView bounds]
options:options
owner:self
userInfo:nil]);
if (isMouseInside_ != mouseInView) {
[self setMouseInside:mouseInView animate:NO];
[controlView setNeedsDisplay:YES];
}
}
@end