| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2014 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/website_settings/split_block_button.h" | |
| 6 | |
| 7 #include <cmath> | |
| 8 | |
| 9 #include "base/logging.h" | |
| 10 #include "base/mac/scoped_nsobject.h" | |
| 11 #include "chrome/grit/generated_resources.h" | |
| 12 #include "skia/ext/skia_utils_mac.h" | |
| 13 #import "ui/base/cocoa/menu_controller.h" | |
| 14 #include "ui/base/l10n/l10n_util_mac.h" | |
| 15 #include "ui/base/models/simple_menu_model.h" | |
| 16 | |
| 17 namespace { | |
| 18 | |
| 19 enum MouseLocation { | |
| 20 kInsideLeftCell, | |
| 21 kInsideRightCell, | |
| 22 kNotInside, | |
| 23 }; | |
| 24 | |
| 25 enum CornerType { | |
| 26 kRounded, | |
| 27 kAngled, | |
| 28 }; | |
| 29 | |
| 30 NSBezierPath* PathWithCornerStyles(NSRect frame, | |
| 31 CornerType leftCornerStyle, | |
| 32 CornerType rightCornerStyle) { | |
| 33 base::scoped_nsobject<NSBezierPath> path([[NSBezierPath bezierPath] retain]); | |
| 34 const CGFloat x0 = NSMinX(frame); | |
| 35 const CGFloat x1 = NSMaxX(frame); | |
| 36 const CGFloat y0 = NSMinY(frame); | |
| 37 const CGFloat y1 = NSMaxY(frame); | |
| 38 const CGFloat radius = 2; | |
| 39 | |
| 40 // Start at the center bottom. Draw left and up, including both left corners. | |
| 41 [path moveToPoint:NSMakePoint(std::floor((x1 - x0) * .5), y0)]; | |
| 42 if (leftCornerStyle == kAngled) { | |
| 43 [path lineToPoint:NSMakePoint(x0, y0)]; | |
| 44 [path lineToPoint:NSMakePoint(x0, y1)]; | |
| 45 } else { | |
| 46 [path appendBezierPathWithArcFromPoint:NSMakePoint(x0, y0) | |
| 47 toPoint:NSMakePoint(x0, y0 + radius) | |
| 48 radius:radius]; | |
| 49 [path appendBezierPathWithArcFromPoint:NSMakePoint(x0, y1) | |
| 50 toPoint:NSMakePoint(x0 + radius, y1) | |
| 51 radius:radius]; | |
| 52 } | |
| 53 // Draw through the upper right-hand and lower-right-hand corners. | |
| 54 if (rightCornerStyle == kAngled) { | |
| 55 [path lineToPoint:NSMakePoint(x1, y1)]; | |
| 56 [path lineToPoint:NSMakePoint(x1, y0)]; | |
| 57 } else { | |
| 58 [path appendBezierPathWithArcFromPoint:NSMakePoint(x1, y1) | |
| 59 toPoint:NSMakePoint(x1, y1 - radius) | |
| 60 radius:radius]; | |
| 61 [path appendBezierPathWithArcFromPoint:NSMakePoint(x1, y0) | |
| 62 toPoint:NSMakePoint(x1 - radius, y0) | |
| 63 radius:radius]; | |
| 64 } | |
| 65 return path.autorelease(); | |
| 66 } | |
| 67 | |
| 68 void DrawBezel(id<ConstrainedWindowButtonDrawableCell>cell, | |
| 69 CornerType leftCorners, | |
| 70 CornerType rightCorners, | |
| 71 NSRect frame, | |
| 72 NSView* view) { | |
| 73 if ([cell isMouseInside]) { | |
| 74 base::scoped_nsobject<NSBezierPath> path( | |
| 75 [PathWithCornerStyles(frame, leftCorners, rightCorners) retain]); | |
| 76 [ConstrainedWindowButton DrawBackgroundAndShadowForPath:path | |
| 77 withCell:cell | |
| 78 inView:view]; | |
| 79 [ConstrainedWindowButton DrawInnerHighlightForPath:path | |
| 80 withCell:cell | |
| 81 inView:view]; | |
| 82 } | |
| 83 } | |
| 84 | |
| 85 } // namespace | |
| 86 | |
| 87 // A button cell used by SplitBlockButton, containing the title. | |
| 88 @interface SplitButtonTitleCell : ConstrainedWindowButtonCell | |
| 89 - (NSRect)rect; | |
| 90 @end | |
| 91 | |
| 92 // A button cell used by SplitBlockButton, containing the popup menu. | |
| 93 @interface SplitButtonPopUpCell : | |
| 94 NSPopUpButtonCell<ConstrainedWindowButtonDrawableCell> { | |
| 95 @private | |
| 96 BOOL isMouseInside_; | |
| 97 base::scoped_nsobject<MenuController> menuController_; | |
| 98 std::unique_ptr<ui::SimpleMenuModel> menuModel_; | |
| 99 } | |
| 100 | |
| 101 // Designated initializer. | |
| 102 - (id)initWithMenuDelegate:(ui::SimpleMenuModel::Delegate*)menuDelegate; | |
| 103 | |
| 104 - (NSRect)rect; | |
| 105 | |
| 106 @end | |
| 107 | |
| 108 @implementation SplitBlockButton | |
| 109 | |
| 110 - (id)initWithMenuDelegate:(ui::SimpleMenuModel::Delegate*)menuDelegate { | |
| 111 if (self = [super initWithFrame:NSZeroRect]) { | |
| 112 leftCell_.reset([[SplitButtonTitleCell alloc] init]); | |
| 113 rightCell_.reset([[SplitButtonPopUpCell alloc] | |
| 114 initWithMenuDelegate:menuDelegate]); | |
| 115 [leftCell_ setTitle:l10n_util::GetNSString(IDS_PERMISSION_DENY)]; | |
| 116 [leftCell_ setEnabled:YES]; | |
| 117 [rightCell_ setEnabled:YES]; | |
| 118 } | |
| 119 return self; | |
| 120 } | |
| 121 | |
| 122 + (Class)cellClass { | |
| 123 return nil; | |
| 124 } | |
| 125 | |
| 126 - (NSString*)title { | |
| 127 return [leftCell_ title]; | |
| 128 } | |
| 129 | |
| 130 - (void)setAction:(SEL)action { | |
| 131 [leftCell_ setAction:action]; | |
| 132 } | |
| 133 | |
| 134 - (void)setTarget:(id)target { | |
| 135 [leftCell_ setTarget:target]; | |
| 136 } | |
| 137 | |
| 138 - (void)drawRect:(NSRect)rect { | |
| 139 // Copy the base class: inset to leave room for the shadow. | |
| 140 --rect.size.height; | |
| 141 | |
| 142 // This function assumes that |rect| is always the same as [self frame]. | |
| 143 // If that changes, the drawing functions will need to be adjusted. | |
| 144 const CGFloat radius = 2; | |
| 145 NSBezierPath* path = [NSBezierPath bezierPathWithRoundedRect:rect | |
| 146 xRadius:radius | |
| 147 yRadius:radius]; | |
| 148 [ConstrainedWindowButton DrawBackgroundAndShadowForPath:path | |
| 149 withCell:nil | |
| 150 inView:self]; | |
| 151 | |
| 152 // Use intersection rects for the cell drawing, to ensure the height | |
| 153 // adjustment is honored. | |
| 154 [leftCell_ setControlView:self]; | |
| 155 [leftCell_ drawWithFrame:NSIntersectionRect(rect, [self leftCellRect]) | |
| 156 inView:self]; | |
| 157 | |
| 158 [rightCell_ setControlView:self]; | |
| 159 [rightCell_ drawWithFrame:NSIntersectionRect(rect, [self rightCellRect]) | |
| 160 inView:self]; | |
| 161 | |
| 162 // Draw the border. | |
| 163 path = [NSBezierPath bezierPathWithRoundedRect:NSInsetRect(rect, 0.5, 0.5) | |
| 164 xRadius:radius | |
| 165 yRadius:radius]; | |
| 166 [ConstrainedWindowButton DrawBorderForPath:path | |
| 167 withCell:nil | |
| 168 inView:self]; | |
| 169 } | |
| 170 | |
| 171 - (void)updateTrackingAreas { | |
| 172 [self updateTrackingArea:&leftTrackingArea_ | |
| 173 forCell:leftCell_ | |
| 174 withRect:[self leftCellRect]]; | |
| 175 | |
| 176 [self updateTrackingArea:&rightTrackingArea_ | |
| 177 forCell:rightCell_ | |
| 178 withRect:[self rightCellRect]]; | |
| 179 } | |
| 180 | |
| 181 - (void)updateTrackingArea:(ui::ScopedCrTrackingArea*)trackingArea | |
| 182 forCell:(id<ConstrainedWindowButtonDrawableCell>)cell | |
| 183 withRect:(NSRect)rect { | |
| 184 DCHECK(trackingArea); | |
| 185 NSTrackingAreaOptions options = NSTrackingMouseEnteredAndExited | | |
| 186 NSTrackingActiveInActiveApp; | |
| 187 [self removeTrackingArea:trackingArea->get()]; | |
| 188 trackingArea->reset([[CrTrackingArea alloc] initWithRect:rect | |
| 189 options:options | |
| 190 owner:self | |
| 191 userInfo:nil]); | |
| 192 [self addTrackingArea:trackingArea->get()]; | |
| 193 } | |
| 194 | |
| 195 - (void)mouseEntered:(NSEvent*)theEvent { | |
| 196 [self mouseMoved:theEvent]; | |
| 197 } | |
| 198 | |
| 199 - (void)mouseExited:(NSEvent*)theEvent { | |
| 200 [self mouseMoved:theEvent]; | |
| 201 } | |
| 202 | |
| 203 - (void)mouseMoved:(NSEvent*)theEvent { | |
| 204 MouseLocation location = [self mouseLocationForEvent:theEvent]; | |
| 205 [rightCell_ setIsMouseInside:NO]; | |
| 206 [leftCell_ setIsMouseInside:NO]; | |
| 207 if (location == kInsideLeftCell) | |
| 208 [leftCell_ setIsMouseInside:YES]; | |
| 209 else if (location == kInsideRightCell) | |
| 210 [rightCell_ setIsMouseInside:YES]; | |
| 211 [self setNeedsDisplay:YES]; | |
| 212 } | |
| 213 | |
| 214 - (void)mouseDown:(NSEvent*)theEvent { | |
| 215 MouseLocation downLocation = [self mouseLocationForEvent:theEvent]; | |
| 216 NSCell* focusCell = nil; | |
| 217 NSRect rect; | |
| 218 if (downLocation == kInsideLeftCell) { | |
| 219 focusCell = leftCell_.get(); | |
| 220 rect = [self leftCellRect]; | |
| 221 } else if (downLocation == kInsideRightCell) { | |
| 222 focusCell = rightCell_.get(); | |
| 223 rect = [self rightCellRect]; | |
| 224 } | |
| 225 | |
| 226 do { | |
| 227 MouseLocation location = [self mouseLocationForEvent:theEvent]; | |
| 228 if (location != kNotInside) { | |
| 229 [focusCell setHighlighted:YES]; | |
| 230 [self setNeedsDisplay:YES]; | |
| 231 | |
| 232 if ([focusCell trackMouse:theEvent | |
| 233 inRect:rect | |
| 234 ofView:self | |
| 235 untilMouseUp:NO]) { | |
| 236 [focusCell setState:![focusCell state]]; | |
| 237 [self setNeedsDisplay:YES]; | |
| 238 break; | |
| 239 } else { | |
| 240 // The above -trackMouse call returned NO, so we know that | |
| 241 // the mouse left the cell before a mouse up event occurred. | |
| 242 [focusCell setHighlighted:NO]; | |
| 243 [self setNeedsDisplay:YES]; | |
| 244 } | |
| 245 } | |
| 246 const NSUInteger mask = NSLeftMouseUpMask | NSLeftMouseDraggedMask; | |
| 247 theEvent = [[self window] nextEventMatchingMask:mask]; | |
| 248 } while ([theEvent type] != NSLeftMouseUp); | |
| 249 } | |
| 250 | |
| 251 - (MouseLocation)mouseLocationForEvent:(NSEvent*)theEvent { | |
| 252 MouseLocation location = kNotInside; | |
| 253 NSPoint mousePoint = [self convertPoint:[theEvent locationInWindow] | |
| 254 fromView:nil]; | |
| 255 if ([self mouse:mousePoint inRect:[leftCell_ rect]]) | |
| 256 location = kInsideLeftCell; | |
| 257 else if ([self mouse:mousePoint inRect:[self rightCellRect]]) | |
| 258 location = kInsideRightCell; | |
| 259 return location; | |
| 260 } | |
| 261 | |
| 262 - (void)sizeToFit { | |
| 263 NSSize leftSize = [leftCell_ cellSize]; | |
| 264 NSSize rightSize = [rightCell_ cellSize]; | |
| 265 NSSize size = NSMakeSize( | |
| 266 std::ceil(std::max(leftSize.width + rightSize.width, | |
| 267 constrained_window_button::kButtonMinWidth)), | |
| 268 std::ceil(std::max(leftSize.height, rightSize.height))); | |
| 269 [self setFrameSize:size]; | |
| 270 } | |
| 271 | |
| 272 - (NSRect)leftCellRect { | |
| 273 return [leftCell_ rect]; | |
| 274 } | |
| 275 | |
| 276 - (NSRect)rightCellRect { | |
| 277 NSRect leftFrame, rightFrame; | |
| 278 NSDivideRect([self bounds], &leftFrame, &rightFrame, | |
| 279 NSWidth([self leftCellRect]), NSMinXEdge); | |
| 280 return rightFrame; | |
| 281 } | |
| 282 | |
| 283 // Accessor for Testing. | |
| 284 - (NSMenu*)menu { | |
| 285 return [rightCell_ menu]; | |
| 286 } | |
| 287 | |
| 288 @end | |
| 289 | |
| 290 @implementation SplitButtonTitleCell | |
| 291 | |
| 292 - (void)drawBezelWithFrame:(NSRect)frame inView:(NSView *)controlView { | |
| 293 DrawBezel(self, kRounded, kAngled, frame, controlView); | |
| 294 } | |
| 295 | |
| 296 - (NSRect)rect { | |
| 297 NSSize size = [self cellSize]; | |
| 298 return NSMakeRect(0, 0, std::ceil(size.width), std::ceil(size.height)); | |
| 299 } | |
| 300 | |
| 301 @end | |
| 302 | |
| 303 @implementation SplitButtonPopUpCell | |
| 304 | |
| 305 @synthesize isMouseInside = isMouseInside_; | |
| 306 | |
| 307 - (id)initWithMenuDelegate:(ui::SimpleMenuModel::Delegate*)menuDelegate { | |
| 308 if (self = [super initTextCell:@"" pullsDown:YES]) { | |
| 309 [self setControlSize:NSSmallControlSize]; | |
| 310 [self setArrowPosition:NSPopUpArrowAtCenter]; | |
| 311 [self setBordered:NO]; | |
| 312 [self setBackgroundColor:[NSColor clearColor]]; | |
| 313 menuModel_.reset(new ui::SimpleMenuModel(menuDelegate)); | |
| 314 menuModel_->AddItemWithStringId(0, IDS_PERMISSION_CUSTOMIZE); | |
| 315 menuController_.reset( | |
| 316 [[MenuController alloc] initWithModel:menuModel_.get() | |
| 317 useWithPopUpButtonCell:NO]); | |
| 318 [self setMenu:[menuController_ menu]]; | |
| 319 [self setUsesItemFromMenu:NO]; | |
| 320 } | |
| 321 return self; | |
| 322 } | |
| 323 | |
| 324 - (void)drawBorderAndBackgroundWithFrame:(NSRect)frame | |
| 325 inView:(NSView*)controlView { | |
| 326 // The arrow, which is what should be drawn by the base class, is drawn | |
| 327 // during -drawBezelWithFrame. The only way to draw our own border with | |
| 328 // the default arrow is to make the cell unbordered, and draw the border | |
| 329 // from -drawBorderAndBackgroundWithFrame, rather than simply overriding | |
| 330 // -drawBezelWithFrame. | |
| 331 DrawBezel(self, kAngled, kRounded, frame, controlView); | |
| 332 [super drawBorderAndBackgroundWithFrame:NSOffsetRect(frame, -4, 0) | |
| 333 inView:controlView]; | |
| 334 } | |
| 335 | |
| 336 - (NSRect)rect { | |
| 337 NSSize size = [self cellSize]; | |
| 338 return NSMakeRect(0, 0, std::ceil(size.width), std::ceil(size.height)); | |
| 339 } | |
| 340 | |
| 341 @end | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2741933003:
Move Cocoa Page Info UI code to its own folder. (Closed)
