| // Copyright (c) 2011 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. |
| |
| #import "chrome/browser/ui/cocoa/new_tab_button.h" |
| |
| #include "base/mac/foundation_util.h" |
| #include "base/mac/sdk_forward_declarations.h" |
| #import "chrome/browser/ui/cocoa/image_button_cell.h" |
| #include "chrome/browser/ui/cocoa/tabs/tab_view.h" |
| #include "grit/theme_resources.h" |
| #include "ui/base/cocoa/nsgraphics_context_additions.h" |
| #include "ui/base/material_design/material_design_controller.h" |
| #include "ui/base/resource/resource_bundle.h" |
| #include "ui/base/theme_provider.h" |
| |
| @class NewTabButtonCell; |
| |
| namespace { |
| |
| enum class RenderingOption { |
| NORMAL, |
| OVERLAY_LIGHTEN, |
| OVERLAY_LIGHTEN_INCOGNITO, |
| OVERLAY_DARKEN, |
| INLAY_LIGHTEN, |
| }; |
| |
| NSImage* GetMaskImageFromCell(NewTabButtonCell* aCell) { |
| if (!ui::MaterialDesignController::IsModeMaterial()) { |
| ui::ResourceBundle& bundle = ui::ResourceBundle::GetSharedInstance(); |
| return bundle.GetNativeImageNamed(IDR_NEWTAB_BUTTON_MASK).ToNSImage(); |
| } |
| return [aCell imageForState:image_button_cell::kDefaultState view:nil]; |
| } |
| |
| // Creates an NSImage with size |size| and bitmap image representations for both |
| // 1x and 2x scale factors. |drawingHandler| is called once for every scale |
| // factor. This is similar to -[NSImage imageWithSize:flipped:drawingHandler:], |
| // but this function always evaluates drawingHandler eagerly, and it works on |
| // 10.6 and 10.7. |
| NSImage* CreateImageWithSize(NSSize size, |
| void (^drawingHandler)(NSSize)) { |
| base::scoped_nsobject<NSImage> result([[NSImage alloc] initWithSize:size]); |
| [NSGraphicsContext saveGraphicsState]; |
| for (ui::ScaleFactor scale_factor : ui::GetSupportedScaleFactors()) { |
| float scale = GetScaleForScaleFactor(scale_factor); |
| NSBitmapImageRep *bmpImageRep = [[[NSBitmapImageRep alloc] |
| initWithBitmapDataPlanes:NULL |
| pixelsWide:size.width * scale |
| pixelsHigh:size.height * scale |
| bitsPerSample:8 |
| samplesPerPixel:4 |
| hasAlpha:YES |
| isPlanar:NO |
| colorSpaceName:NSDeviceRGBColorSpace |
| bytesPerRow:0 |
| bitsPerPixel:0] autorelease]; |
| [bmpImageRep setSize:size]; |
| [NSGraphicsContext setCurrentContext: |
| [NSGraphicsContext graphicsContextWithBitmapImageRep:bmpImageRep]]; |
| drawingHandler(size); |
| [result addRepresentation:bmpImageRep]; |
| } |
| [NSGraphicsContext restoreGraphicsState]; |
| |
| return result.release(); |
| } |
| |
| // Takes a normal bitmap and a mask image and returns an image the size of the |
| // mask that has pixels from |image| but alpha information from |mask|. |
| NSImage* ApplyMask(NSImage* image, NSImage* mask) { |
| return [CreateImageWithSize([mask size], ^(NSSize size) { |
| // Skip a few pixels from the top of the tab background gradient, because |
| // the new tab button is not drawn at the very top of the browser window. |
| const int kYOffset = 10; |
| CGFloat width = size.width; |
| CGFloat height = size.height; |
| |
| // In some themes, the tab background image is narrower than the |
| // new tab button, so tile the background image. |
| CGFloat x = 0; |
| // The floor() is to make sure images with odd widths don't draw to the |
| // same pixel twice on retina displays. (Using NSDrawThreePartImage() |
| // caused a startup perf regression, so that cannot be used.) |
| CGFloat tileWidth = floor(std::min(width, [image size].width)); |
| while (x < width) { |
| [image drawAtPoint:NSMakePoint(x, 0) |
| fromRect:NSMakeRect(0, |
| [image size].height - height - kYOffset, |
| tileWidth, |
| height) |
| operation:NSCompositeCopy |
| fraction:1.0]; |
| x += tileWidth; |
| } |
| |
| [mask drawAtPoint:NSZeroPoint |
| fromRect:NSMakeRect(0, 0, width, height) |
| operation:NSCompositeDestinationIn |
| fraction:1.0]; |
| }) autorelease]; |
| } |
| |
| // Paints |overlay| on top of |ground|. |
| NSImage* Overlay(NSImage* ground, NSImage* overlay, CGFloat alpha) { |
| DCHECK_EQ([ground size].width, [overlay size].width); |
| DCHECK_EQ([ground size].height, [overlay size].height); |
| |
| return [CreateImageWithSize([ground size], ^(NSSize size) { |
| CGFloat width = size.width; |
| CGFloat height = size.height; |
| [ground drawAtPoint:NSZeroPoint |
| fromRect:NSMakeRect(0, 0, width, height) |
| operation:NSCompositeCopy |
| fraction:1.0]; |
| [overlay drawAtPoint:NSZeroPoint |
| fromRect:NSMakeRect(0, 0, width, height) |
| operation:NSCompositeSourceOver |
| fraction:alpha]; |
| }) autorelease]; |
| } |
| |
| CGFloat LineWidthFromContext(CGContextRef context) { |
| CGRect unitRect = CGRectMake(0.0, 0.0, 1.0, 1.0); |
| CGRect deviceRect = CGContextConvertRectToDeviceSpace(context, unitRect); |
| return 1.0 / deviceRect.size.height; |
| } |
| |
| } // namespace |
| |
| @interface NewTabButtonCustomImageRep : NSCustomImageRep |
| @property (assign, nonatomic) NSView* destView; |
| @property (copy, nonatomic) NSColor* fillColor; |
| @property (assign, nonatomic) NSPoint patternPhasePosition; |
| @property (assign, nonatomic) RenderingOption renderingOption; |
| @end |
| |
| @implementation NewTabButtonCustomImageRep |
| |
| @synthesize destView = destView_; |
| @synthesize fillColor = fillColor_; |
| @synthesize patternPhasePosition = patternPhasePosition_; |
| @synthesize renderingOption = renderingOption_; |
| |
| - (void)dealloc { |
| [fillColor_ release]; |
| [super dealloc]; |
| } |
| |
| @end |
| |
| // A simple override of the ImageButtonCell to disable handling of |
| // -mouseEntered. |
| @interface NewTabButtonCell : ImageButtonCell |
| |
| - (void)mouseEntered:(NSEvent*)theEvent; |
| |
| @end |
| |
| @implementation NewTabButtonCell |
| |
| - (void)mouseEntered:(NSEvent*)theEvent { |
| // Ignore this since the NTB enter is handled by the TabStripController. |
| } |
| |
| - (void)drawFocusRingMaskWithFrame:(NSRect)cellFrame inView:(NSView*)view { |
| // Match the button's shape. |
| [self drawImage:GetMaskImageFromCell(self) withFrame:cellFrame inView:view]; |
| } |
| |
| @end |
| |
| |
| @implementation NewTabButton |
| |
| + (Class)cellClass { |
| return [NewTabButtonCell class]; |
| } |
| |
| - (BOOL)pointIsOverButton:(NSPoint)point { |
| NSPoint localPoint = [self convertPoint:point fromView:[self superview]]; |
| NSRect pointRect = NSMakeRect(localPoint.x, localPoint.y, 1, 1); |
| NSImage* buttonMask = GetMaskImageFromCell([self cell]); |
| NSRect bounds = self.bounds; |
| NSSize buttonMaskSize = [buttonMask size]; |
| NSRect destinationRect = NSMakeRect( |
| (NSWidth(bounds) - buttonMaskSize.width) / 2, |
| (NSHeight(bounds) - buttonMaskSize.height) / 2, |
| buttonMaskSize.width, buttonMaskSize.height); |
| return [buttonMask hitTestRect:pointRect |
| withImageDestinationRect:destinationRect |
| context:nil |
| hints:nil |
| flipped:YES]; |
| } |
| |
| // Override to only accept clicks within the bounds of the defined path, not |
| // the entire bounding box. |aPoint| is in the superview's coordinate system. |
| - (NSView*)hitTest:(NSPoint)aPoint { |
| if ([self pointIsOverButton:aPoint]) |
| return [super hitTest:aPoint]; |
| return nil; |
| } |
| |
| // ThemedWindowDrawing implementation. |
| |
| - (void)windowDidChangeTheme { |
| [self setNeedsDisplay:YES]; |
| } |
| |
| - (void)windowDidChangeActive { |
| [self setNeedsDisplay:YES]; |
| } |
| |
| - (void)viewDidMoveToWindow { |
| NewTabButtonCell* cell = base::mac::ObjCCast<NewTabButtonCell>([self cell]); |
| |
| if ([self window] && |
| ![cell imageForState:image_button_cell::kDefaultState view:self]) { |
| [self setImages]; |
| } |
| } |
| |
| - (void)setImages { |
| const ui::ThemeProvider* theme = [[self window] themeProvider]; |
| if (!theme) { |
| return; |
| } |
| |
| // The old way of doing things. |
| if (!ui::MaterialDesignController::IsModeMaterial()) { |
| ResourceBundle& rb = ResourceBundle::GetSharedInstance(); |
| NSImage* mask = rb.GetNativeImageNamed(IDR_NEWTAB_BUTTON_MASK).ToNSImage(); |
| NSImage* normal = rb.GetNativeImageNamed(IDR_NEWTAB_BUTTON).ToNSImage(); |
| NSImage* hover = rb.GetNativeImageNamed(IDR_NEWTAB_BUTTON_H).ToNSImage(); |
| NSImage* pressed = rb.GetNativeImageNamed(IDR_NEWTAB_BUTTON_P).ToNSImage(); |
| |
| NSImage* foreground = ApplyMask( |
| theme->GetNSImageNamed(IDR_THEME_TAB_BACKGROUND), mask); |
| |
| [[self cell] setImage:Overlay(foreground, normal, 1.0) |
| forButtonState:image_button_cell::kDefaultState]; |
| [[self cell] setImage:Overlay(foreground, hover, 1.0) |
| forButtonState:image_button_cell::kHoverState]; |
| [[self cell] setImage:Overlay(foreground, pressed, 1.0) |
| forButtonState:image_button_cell::kPressedState]; |
| |
| // IDR_THEME_TAB_BACKGROUND_INACTIVE is only used with the default theme. |
| if (theme->UsingSystemTheme()) { |
| const CGFloat alpha = tabs::kImageNoFocusAlpha; |
| NSImage* background = ApplyMask( |
| theme->GetNSImageNamed(IDR_THEME_TAB_BACKGROUND_INACTIVE), mask); |
| [[self cell] setImage:Overlay(background, normal, alpha) |
| forButtonState: |
| image_button_cell::kDefaultStateBackground]; |
| [[self cell] setImage:Overlay(background, hover, alpha) |
| forButtonState:image_button_cell::kHoverStateBackground]; |
| } else { |
| [[self cell] setImage:nil |
| forButtonState: |
| image_button_cell::kDefaultStateBackground]; |
| [[self cell] setImage:nil |
| forButtonState:image_button_cell::kHoverStateBackground]; |
| } |
| return; |
| } |
| |
| NSImage* mask = [self imageWithFillColor:[NSColor whiteColor]]; |
| NSImage* normal = |
| [self imageForState:image_button_cell::kDefaultState theme:theme]; |
| NSImage* hover = |
| [self imageForState:image_button_cell::kHoverState theme:theme]; |
| NSImage* pressed = |
| [self imageForState:image_button_cell::kPressedState theme:theme]; |
| NSImage* normalBackground = nil; |
| NSImage* hoverBackground = nil; |
| |
| // If using a custom theme, overlay the default image with the theme's custom |
| // tab background image. |
| if (!theme->UsingSystemTheme()) { |
| NSImage* foreground = |
| ApplyMask(theme->GetNSImageNamed(IDR_THEME_TAB_BACKGROUND), mask); |
| normal = Overlay(foreground, normal, 1.0); |
| hover = Overlay(foreground, hover, 1.0); |
| pressed = Overlay(foreground, pressed, 1.0); |
| |
| NSImage* background = ApplyMask( |
| theme->GetNSImageNamed(IDR_THEME_TAB_BACKGROUND_INACTIVE), mask); |
| normalBackground = Overlay(background, normal, tabs::kImageNoFocusAlpha); |
| hoverBackground = Overlay(background, hover, tabs::kImageNoFocusAlpha); |
| } |
| |
| NewTabButtonCell* cell = base::mac::ObjCCast<NewTabButtonCell>([self cell]); |
| [cell setImage:normal forButtonState:image_button_cell::kDefaultState]; |
| [cell setImage:hover forButtonState:image_button_cell::kHoverState]; |
| [cell setImage:pressed forButtonState:image_button_cell::kPressedState]; |
| [cell setImage:normalBackground |
| forButtonState:image_button_cell::kDefaultStateBackground]; |
| [cell setImage:hoverBackground |
| forButtonState:image_button_cell::kHoverStateBackground]; |
| } |
| |
| - (NSImage*)imageForState:(image_button_cell::ButtonState)state |
| theme:(const ui::ThemeProvider*)theme { |
| NSColor* fillColor = nil; |
| RenderingOption renderingOption = RenderingOption::NORMAL; |
| |
| switch (state) { |
| case image_button_cell::kDefaultState: |
| fillColor = theme->GetNSImageColorNamed(IDR_THEME_TAB_BACKGROUND); |
| break; |
| |
| case image_button_cell::kHoverState: |
| fillColor = theme->GetNSImageColorNamed(IDR_THEME_TAB_BACKGROUND); |
| // When a custom theme highlight the entire area, otherwise only |
| // highlight the interior and not the border. |
| if (theme->HasCustomImage(IDR_THEME_TAB_BACKGROUND)) { |
| renderingOption = RenderingOption::OVERLAY_LIGHTEN; |
| } else if (theme->InIncognitoMode()) { |
| renderingOption = RenderingOption::OVERLAY_LIGHTEN_INCOGNITO; |
| } else { |
| renderingOption = RenderingOption::INLAY_LIGHTEN; |
| } |
| |
| break; |
| |
| case image_button_cell::kPressedState: |
| fillColor = theme->GetNSImageColorNamed(IDR_THEME_TAB_BACKGROUND); |
| break; |
| |
| case image_button_cell::kDefaultStateBackground: |
| case image_button_cell::kHoverStateBackground: |
| fillColor = |
| theme->GetNSImageColorNamed(IDR_THEME_TAB_BACKGROUND_INACTIVE); |
| break; |
| |
| default: |
| fillColor = [NSColor redColor]; |
| // All states should be accounted for above. |
| NOTREACHED(); |
| } |
| |
| base::scoped_nsobject<NewTabButtonCustomImageRep> imageRep = |
| [[NewTabButtonCustomImageRep alloc] |
| initWithDrawSelector:@selector(drawNewTabButtonImage:) |
| delegate:[NewTabButton class]]; |
| [imageRep setDestView:self]; |
| [imageRep setFillColor:fillColor]; |
| [imageRep setPatternPhasePosition: |
| [[self window] |
| themeImagePositionForAlignment:THEME_IMAGE_ALIGN_WITH_TAB_STRIP]]; |
| [imageRep setRenderingOption:renderingOption]; |
| |
| NSImage* newTabButtonImage = |
| [[[NSImage alloc] initWithSize:NSMakeSize(34, 17)] autorelease]; |
| [newTabButtonImage setCacheMode:NSImageCacheAlways]; |
| [newTabButtonImage addRepresentation:imageRep]; |
| |
| return newTabButtonImage; |
| } |
| |
| + (NSBezierPath*)newTabButtonBezierPathWithInset:(int)inset |
| lineWidth:(CGFloat)lineWidth { |
| NSBezierPath* bezierPath = [NSBezierPath bezierPath]; |
| |
| // Bottom edge. |
| [bezierPath moveToPoint:NSMakePoint(19 - inset, 1.2825 + inset)]; |
| [bezierPath lineToPoint:NSMakePoint(10.45 + inset, 1.2825 + inset)]; |
| |
| // Lower-left corner. |
| [bezierPath curveToPoint:NSMakePoint(6.08 + inset, 2.85 + inset) |
| controlPoint1:NSMakePoint(10.1664 + inset, 1.3965 + inset) |
| controlPoint2:NSMakePoint(7.89222 + inset, 0.787708 + inset)]; |
| |
| // Left side. |
| [bezierPath lineToPoint:NSMakePoint(0.7125 + inset, 14.25 - inset)]; |
| |
| // Upper-left corner. |
| const float topEdgeY = 16.2688; |
| [bezierPath curveToPoint:NSMakePoint(1.71 + inset, topEdgeY - inset) |
| controlPoint1:NSMakePoint(0.246496 + inset, 15.2613 - inset) |
| controlPoint2:NSMakePoint(0.916972 + inset, 16.3489 - inset)]; |
| |
| // Top edge. |
| [bezierPath lineToPoint:NSMakePoint(23.275 - inset, topEdgeY - inset)]; |
| |
| // Upper right corner. |
| [bezierPath curveToPoint:NSMakePoint(27.645 - inset, 14.7012 - inset) |
| controlPoint1:NSMakePoint(26.4376 - inset, 16.3305 - inset) |
| controlPoint2:NSMakePoint(26.9257 - inset, 15.8059 - inset)]; |
| |
| // Right side. |
| [bezierPath lineToPoint:NSMakePoint(32.9543 - inset, 3.62561 + inset)]; |
| |
| // Lower right corner. |
| [bezierPath curveToPoint:NSMakePoint(32.015 - inset, 1.2825 + inset) |
| controlPoint1:NSMakePoint(34.069 - inset, 1.45303 + inset) |
| controlPoint2:NSMakePoint(31.0348 - inset, 1.31455 + inset)]; |
| |
| [bezierPath closePath]; |
| |
| // On non-Retina machines, adjust the path so that the top line rests along |
| // a pixel line (to get a crisp line on the display). |
| if (lineWidth == 1) { |
| NSAffineTransform* translateTransform = [NSAffineTransform transform]; |
| [translateTransform translateXBy:0 |
| yBy:0.5 - (topEdgeY - trunc(topEdgeY))]; |
| [bezierPath transformUsingAffineTransform:translateTransform]; |
| } |
| |
| [bezierPath setLineWidth:lineWidth]; |
| |
| return bezierPath; |
| } |
| |
| + (void)drawNewTabButtonImage:(NewTabButtonCustomImageRep*)imageRep { |
| [[NSGraphicsContext currentContext] |
| cr_setPatternPhase:[imageRep patternPhasePosition] |
| forView:[imageRep destView]]; |
| |
| CGContextRef context = static_cast<CGContextRef>( |
| [[NSGraphicsContext currentContext] graphicsPort]); |
| CGFloat lineWidth = LineWidthFromContext(context); |
| NSBezierPath* bezierPath = [self newTabButtonBezierPathWithInset:0 |
| lineWidth:lineWidth]; |
| |
| if ([imageRep fillColor]) { |
| [[imageRep fillColor] set]; |
| [bezierPath fill]; |
| } |
| |
| static NSColor* strokeColor = |
| [[NSColor colorWithCalibratedWhite:0 alpha:0.4] retain]; |
| [strokeColor set]; |
| [bezierPath stroke]; |
| |
| // Bottom edge. |
| bezierPath = [NSBezierPath bezierPath]; |
| [bezierPath moveToPoint:NSMakePoint(31, 1.2825)]; |
| [bezierPath lineToPoint:NSMakePoint(9, 1.2825)]; |
| static NSColor* bottomEdgeColor = |
| [[NSColor colorWithCalibratedWhite:0.25 alpha:0.3] retain]; |
| [bottomEdgeColor set]; |
| [bezierPath setLineWidth:lineWidth]; |
| [bezierPath setLineCapStyle:NSRoundLineCapStyle]; |
| [bezierPath stroke]; |
| |
| // Shadow beneath the bottom edge. |
| NSAffineTransform* translateTransform = [NSAffineTransform transform]; |
| [translateTransform translateXBy:0 yBy:-lineWidth]; |
| [bezierPath transformUsingAffineTransform:translateTransform]; |
| static NSColor* shadowColor = |
| [[NSColor colorWithCalibratedWhite:0.5 alpha:0.3] retain]; |
| [shadowColor set]; |
| [bezierPath stroke]; |
| |
| static NSColor* lightColor = |
| [[NSColor colorWithCalibratedWhite:1 alpha:0.35] retain]; |
| static NSColor* lightIncognitoColor = |
| [[NSColor colorWithCalibratedWhite:1 alpha:0.15] retain]; |
| static NSColor* darkColor = |
| [[NSColor colorWithCalibratedWhite:0 alpha:0.08] retain]; |
| |
| CGFloat inset = -1; |
| switch ([imageRep renderingOption]) { |
| case RenderingOption::OVERLAY_LIGHTEN: |
| [lightColor set]; |
| inset = 0; |
| break; |
| |
| case RenderingOption::OVERLAY_LIGHTEN_INCOGNITO: |
| [lightIncognitoColor set]; |
| inset = 0; |
| break; |
| |
| case RenderingOption::OVERLAY_DARKEN: |
| [darkColor set]; |
| NSRectFillUsingOperation(NSMakeRect(0, 0, 34, 17), NSCompositeSourceAtop); |
| break; |
| |
| case RenderingOption::INLAY_LIGHTEN: |
| [lightColor set]; |
| inset = 1; |
| break; |
| |
| case RenderingOption::NORMAL: |
| break; |
| } |
| if (inset != -1) { |
| bezierPath = [self newTabButtonBezierPathWithInset:inset |
| lineWidth:lineWidth]; |
| [bezierPath fill]; |
| } |
| } |
| |
| - (NSImage*)imageWithFillColor:(NSColor*)fillColor { |
| NSImage* image = |
| [[[NSImage alloc] initWithSize:NSMakeSize(34, 17)] autorelease]; |
| |
| [image lockFocus]; |
| [fillColor set]; |
| CGContextRef context = static_cast<CGContextRef>( |
| [[NSGraphicsContext currentContext] graphicsPort]); |
| CGFloat lineWidth = LineWidthFromContext(context); |
| [[NewTabButton newTabButtonBezierPathWithInset:0 lineWidth:lineWidth] fill]; |
| [image unlockFocus]; |
| return image; |
| } |
| |
| @end |
