| /* |
| * Copyright (C) 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved. |
| * Copyright (C) 2008, 2009 Google, Inc. |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Library General Public |
| * License as published by the Free Software Foundation; either |
| * version 2 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Library General Public License for more details. |
| * |
| * You should have received a copy of the GNU Library General Public License |
| * along with this library; see the file COPYING.LIB. If not, write to |
| * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, |
| * Boston, MA 02110-1301, USA. |
| */ |
| |
| #import "core/paint/ThemePainterMac.h" |
| |
| #import "core/frame/FrameView.h" |
| #import "core/layout/LayoutProgress.h" |
| #import "core/layout/LayoutThemeMac.h" |
| #import "core/layout/LayoutView.h" |
| #import "core/paint/PaintInfo.h" |
| #import "platform/geometry/FloatRoundedRect.h" |
| #import "platform/graphics/BitmapImage.h" |
| #import "platform/graphics/GraphicsContextStateSaver.h" |
| #import "platform/graphics/Image.h" |
| #import "platform/graphics/ImageBuffer.h" |
| #import "platform/mac/BlockExceptions.h" |
| #import "platform/mac/ColorMac.h" |
| #import "platform/mac/LocalCurrentGraphicsContext.h" |
| #import "platform/mac/ThemeMac.h" |
| #import "platform/mac/WebCoreNSCellExtras.h" |
| #import <AvailabilityMacros.h> |
| #import <Carbon/Carbon.h> |
| #import <Cocoa/Cocoa.h> |
| #import <math.h> |
| |
| // The methods in this file are specific to the Mac OS X platform. |
| |
| // Forward declare Mac SPIs. |
| extern "C" { |
| void _NSDrawCarbonThemeBezel(NSRect frame, BOOL enabled, BOOL flipped); |
| // Request for public API: rdar://13787640 |
| void _NSDrawCarbonThemeListBox(NSRect frame, |
| BOOL enabled, |
| BOOL flipped, |
| BOOL always_yes); |
| } |
| |
| namespace blink { |
| |
| ThemePainterMac::ThemePainterMac(LayoutThemeMac& layoutTheme) |
| : ThemePainter(), m_layoutTheme(layoutTheme) {} |
| |
| bool ThemePainterMac::paintTextField(const LayoutObject& o, |
| const PaintInfo& paintInfo, |
| const IntRect& r) { |
| LocalCurrentGraphicsContext localContext(paintInfo.context, r); |
| |
| bool useNSTextFieldCell = o.styleRef().hasAppearance() && |
| o.styleRef().visitedDependentColor( |
| CSSPropertyBackgroundColor) == Color::white && |
| !o.styleRef().hasBackgroundImage(); |
| |
| // We do not use NSTextFieldCell to draw styled text fields since it induces a |
| // behavior change while remaining a fragile solution. |
| // https://bugs.chromium.org/p/chromium/issues/detail?id=658085#c3 |
| if (!useNSTextFieldCell) { |
| _NSDrawCarbonThemeBezel( |
| r, LayoutTheme::isEnabled(o) && !LayoutTheme::isReadOnlyControl(o), |
| YES); |
| return false; |
| } |
| |
| NSTextFieldCell* textField = m_layoutTheme.textField(); |
| |
| GraphicsContextStateSaver stateSaver(paintInfo.context); |
| |
| [textField setEnabled:(LayoutTheme::isEnabled(o) && |
| !LayoutTheme::isReadOnlyControl(o))]; |
| [textField drawWithFrame:NSRect(r) inView:m_layoutTheme.documentViewFor(o)]; |
| |
| [textField setControlView:nil]; |
| |
| return false; |
| } |
| |
| bool ThemePainterMac::paintCapsLockIndicator(const LayoutObject& o, |
| const PaintInfo& paintInfo, |
| const IntRect& r) { |
| // This draws the caps lock indicator as it was done by |
| // WKDrawCapsLockIndicator. |
| LocalCurrentGraphicsContext localContext(paintInfo.context, r); |
| CGContextRef c = localContext.cgContext(); |
| CGMutablePathRef shape = CGPathCreateMutable(); |
| |
| // To draw the caps lock indicator, draw the shape into a small |
| // square that is then scaled to the size of r. |
| const CGFloat kSquareSize = 17; |
| |
| // Create a rounted square shape. |
| CGPathMoveToPoint(shape, NULL, 16.5, 4.5); |
| CGPathAddArc(shape, NULL, 12.5, 12.5, 4, 0, M_PI_2, false); |
| CGPathAddArc(shape, NULL, 4.5, 12.5, 4, M_PI_2, M_PI, false); |
| CGPathAddArc(shape, NULL, 4.5, 4.5, 4, M_PI, 3 * M_PI / 2, false); |
| CGPathAddArc(shape, NULL, 12.5, 4.5, 4, 3 * M_PI / 2, 0, false); |
| |
| // Draw the arrow - note this is drawing in a flipped coordinate system, so |
| // the arrow is pointing down. |
| CGPathMoveToPoint(shape, NULL, 8.5, 2); // Tip point. |
| CGPathAddLineToPoint(shape, NULL, 4, 7); |
| CGPathAddLineToPoint(shape, NULL, 6.25, 7); |
| CGPathAddLineToPoint(shape, NULL, 6.25, 10.25); |
| CGPathAddLineToPoint(shape, NULL, 10.75, 10.25); |
| CGPathAddLineToPoint(shape, NULL, 10.75, 7); |
| CGPathAddLineToPoint(shape, NULL, 13, 7); |
| CGPathAddLineToPoint(shape, NULL, 8.5, 2); |
| |
| // Draw the rectangle that underneath (or above in the flipped system) the |
| // arrow. |
| CGPathAddLineToPoint(shape, NULL, 10.75, 12); |
| CGPathAddLineToPoint(shape, NULL, 6.25, 12); |
| CGPathAddLineToPoint(shape, NULL, 6.25, 14.25); |
| CGPathAddLineToPoint(shape, NULL, 10.75, 14.25); |
| CGPathAddLineToPoint(shape, NULL, 10.75, 12); |
| |
| // Scale and translate the shape. |
| CGRect cgr = r; |
| CGFloat maxX = CGRectGetMaxX(cgr); |
| CGFloat minX = CGRectGetMinX(cgr); |
| CGFloat minY = CGRectGetMinY(cgr); |
| CGFloat heightScale = r.height() / kSquareSize; |
| const bool isRTL = o.styleRef().direction() == TextDirection::Rtl; |
| CGAffineTransform transform = |
| CGAffineTransformMake(heightScale, 0, // A B |
| 0, heightScale, // C D |
| isRTL ? minX : maxX - r.height(), minY); // Tx Ty |
| |
| CGMutablePathRef paintPath = CGPathCreateMutable(); |
| CGPathAddPath(paintPath, &transform, shape); |
| CGPathRelease(shape); |
| |
| CGContextSetRGBFillColor(c, 0, 0, 0, 0.4); |
| CGContextBeginPath(c); |
| CGContextAddPath(c, paintPath); |
| CGContextFillPath(c); |
| CGPathRelease(paintPath); |
| |
| return false; |
| } |
| |
| bool ThemePainterMac::paintTextArea(const LayoutObject& o, |
| const PaintInfo& paintInfo, |
| const IntRect& r) { |
| LocalCurrentGraphicsContext localContext(paintInfo.context, r); |
| _NSDrawCarbonThemeListBox( |
| r, LayoutTheme::isEnabled(o) && !LayoutTheme::isReadOnlyControl(o), YES, |
| YES); |
| return false; |
| } |
| |
| bool ThemePainterMac::paintMenuList(const LayoutObject& o, |
| const PaintInfo& paintInfo, |
| const IntRect& r) { |
| m_layoutTheme.setPopupButtonCellState(o, r); |
| |
| NSPopUpButtonCell* popupButton = m_layoutTheme.popupButton(); |
| |
| float zoomLevel = o.styleRef().effectiveZoom(); |
| IntSize size = m_layoutTheme.popupButtonSizes()[[popupButton controlSize]]; |
| size.setHeight(size.height() * zoomLevel); |
| size.setWidth(r.width()); |
| |
| // Now inflate it to account for the shadow. |
| IntRect inflatedRect = r; |
| if (r.width() >= m_layoutTheme.minimumMenuListSize(o.styleRef())) |
| inflatedRect = ThemeMac::inflateRect( |
| inflatedRect, size, m_layoutTheme.popupButtonMargins(), zoomLevel); |
| |
| LocalCurrentGraphicsContext localContext( |
| paintInfo.context, ThemeMac::inflateRectForFocusRing(inflatedRect)); |
| |
| if (zoomLevel != 1.0f) { |
| inflatedRect.setWidth(inflatedRect.width() / zoomLevel); |
| inflatedRect.setHeight(inflatedRect.height() / zoomLevel); |
| paintInfo.context.translate(inflatedRect.x(), inflatedRect.y()); |
| paintInfo.context.scale(zoomLevel, zoomLevel); |
| paintInfo.context.translate(-inflatedRect.x(), -inflatedRect.y()); |
| } |
| |
| NSView* view = m_layoutTheme.documentViewFor(o); |
| [popupButton drawWithFrame:inflatedRect inView:view]; |
| if (LayoutTheme::isFocused(o) && o.styleRef().outlineStyleIsAuto()) |
| [popupButton cr_drawFocusRingWithFrame:inflatedRect inView:view]; |
| [popupButton setControlView:nil]; |
| |
| return false; |
| } |
| |
| bool ThemePainterMac::paintProgressBar(const LayoutObject& layoutObject, |
| const PaintInfo& paintInfo, |
| const IntRect& rect) { |
| if (!layoutObject.isProgress()) |
| return true; |
| |
| const LayoutProgress& layoutProgress = toLayoutProgress(layoutObject); |
| HIThemeTrackDrawInfo trackInfo; |
| trackInfo.version = 0; |
| NSControlSize controlSize = |
| m_layoutTheme.controlSizeForFont(layoutObject.styleRef()); |
| if (controlSize == NSRegularControlSize) |
| trackInfo.kind = layoutProgress.position() < 0 ? kThemeLargeIndeterminateBar |
| : kThemeLargeProgressBar; |
| else |
| trackInfo.kind = layoutProgress.position() < 0 |
| ? kThemeMediumIndeterminateBar |
| : kThemeMediumProgressBar; |
| |
| trackInfo.bounds = IntRect(IntPoint(), rect.size()); |
| trackInfo.min = 0; |
| trackInfo.max = std::numeric_limits<SInt32>::max(); |
| trackInfo.value = |
| lround(layoutProgress.position() * nextafter(trackInfo.max, 0)); |
| trackInfo.trackInfo.progress.phase = |
| lround(layoutProgress.animationProgress() * |
| nextafter(LayoutThemeMac::progressAnimationNumFrames, 0)); |
| trackInfo.attributes = kThemeTrackHorizontal; |
| trackInfo.enableState = LayoutTheme::isActive(layoutObject) |
| ? kThemeTrackActive |
| : kThemeTrackInactive; |
| trackInfo.reserved = 0; |
| trackInfo.filler1 = 0; |
| |
| std::unique_ptr<ImageBuffer> imageBuffer = ImageBuffer::create(rect.size()); |
| if (!imageBuffer) |
| return true; |
| |
| IntRect clipRect = IntRect(IntPoint(), rect.size()); |
| LocalCurrentGraphicsContext localContext(imageBuffer->canvas(), 1, clipRect); |
| CGContextRef cgContext = localContext.cgContext(); |
| HIThemeDrawTrack(&trackInfo, 0, cgContext, kHIThemeOrientationNormal); |
| |
| GraphicsContextStateSaver stateSaver(paintInfo.context); |
| |
| if (!layoutProgress.styleRef().isLeftToRightDirection()) { |
| paintInfo.context.translate(2 * rect.x() + rect.width(), 0); |
| paintInfo.context.scale(-1, 1); |
| } |
| |
| if (!paintInfo.context.contextDisabled()) |
| imageBuffer->draw( |
| paintInfo.context, |
| FloatRect(rect.location(), FloatSize(imageBuffer->size())), nullptr, |
| SkBlendMode::kSrcOver); |
| return false; |
| } |
| |
| bool ThemePainterMac::paintMenuListButton(const LayoutObject& o, |
| const PaintInfo& paintInfo, |
| const IntRect& r) { |
| IntRect bounds = IntRect(r.x() + o.styleRef().borderLeftWidth(), |
| r.y() + o.styleRef().borderTopWidth(), |
| r.width() - o.styleRef().borderLeftWidth() - |
| o.styleRef().borderRightWidth(), |
| r.height() - o.styleRef().borderTopWidth() - |
| o.styleRef().borderBottomWidth()); |
| // Since we actually know the size of the control here, we restrict the font |
| // scale to make sure the arrows will fit vertically in the bounds |
| float fontScale = std::min( |
| o.styleRef().fontSize() / LayoutThemeMac::baseFontSize, |
| bounds.height() / (LayoutThemeMac::menuListBaseArrowHeight * 2 + |
| LayoutThemeMac::menuListBaseSpaceBetweenArrows)); |
| float centerY = bounds.y() + bounds.height() / 2.0f; |
| float arrowHeight = LayoutThemeMac::menuListBaseArrowHeight * fontScale; |
| float arrowWidth = LayoutThemeMac::menuListBaseArrowWidth * fontScale; |
| float spaceBetweenArrows = |
| LayoutThemeMac::menuListBaseSpaceBetweenArrows * fontScale; |
| float scaledPaddingEnd = |
| LayoutThemeMac::menuListArrowPaddingEnd * o.styleRef().effectiveZoom(); |
| float leftEdge; |
| if (o.styleRef().direction() == TextDirection::Ltr) { |
| leftEdge = bounds.maxX() - scaledPaddingEnd - arrowWidth; |
| } else { |
| leftEdge = bounds.x() + scaledPaddingEnd; |
| } |
| if (bounds.width() < arrowWidth + scaledPaddingEnd) |
| return false; |
| |
| Color color = o.styleRef().visitedDependentColor(CSSPropertyColor); |
| SkPaint paint = paintInfo.context.fillPaint(); |
| paint.setAntiAlias(true); |
| paint.setColor(color.rgb()); |
| |
| SkPath arrow1; |
| arrow1.moveTo(leftEdge, centerY - spaceBetweenArrows / 2.0f); |
| arrow1.lineTo(leftEdge + arrowWidth, centerY - spaceBetweenArrows / 2.0f); |
| arrow1.lineTo(leftEdge + arrowWidth / 2.0f, |
| centerY - spaceBetweenArrows / 2.0f - arrowHeight); |
| |
| // Draw the top arrow. |
| paintInfo.context.drawPath(arrow1, paint); |
| |
| SkPath arrow2; |
| arrow2.moveTo(leftEdge, centerY + spaceBetweenArrows / 2.0f); |
| arrow2.lineTo(leftEdge + arrowWidth, centerY + spaceBetweenArrows / 2.0f); |
| arrow2.lineTo(leftEdge + arrowWidth / 2.0f, |
| centerY + spaceBetweenArrows / 2.0f + arrowHeight); |
| |
| // Draw the bottom arrow. |
| paintInfo.context.drawPath(arrow2, paint); |
| return false; |
| } |
| |
| bool ThemePainterMac::paintSliderTrack(const LayoutObject& o, |
| const PaintInfo& paintInfo, |
| const IntRect& r) { |
| paintSliderTicks(o, paintInfo, r); |
| |
| float zoomLevel = o.styleRef().effectiveZoom(); |
| FloatRect unzoomedRect = r; |
| |
| if (o.styleRef().appearance() == SliderHorizontalPart || |
| o.styleRef().appearance() == MediaSliderPart) { |
| unzoomedRect.setY(ceilf(unzoomedRect.y() + unzoomedRect.height() / 2 - |
| zoomLevel * LayoutThemeMac::sliderTrackWidth / 2)); |
| unzoomedRect.setHeight(zoomLevel * LayoutThemeMac::sliderTrackWidth); |
| } else if (o.styleRef().appearance() == SliderVerticalPart) { |
| unzoomedRect.setX(ceilf(unzoomedRect.x() + unzoomedRect.width() / 2 - |
| zoomLevel * LayoutThemeMac::sliderTrackWidth / 2)); |
| unzoomedRect.setWidth(zoomLevel * LayoutThemeMac::sliderTrackWidth); |
| } |
| |
| if (zoomLevel != 1) { |
| unzoomedRect.setWidth(unzoomedRect.width() / zoomLevel); |
| unzoomedRect.setHeight(unzoomedRect.height() / zoomLevel); |
| } |
| |
| GraphicsContextStateSaver stateSaver(paintInfo.context); |
| if (zoomLevel != 1) { |
| paintInfo.context.translate(unzoomedRect.x(), unzoomedRect.y()); |
| paintInfo.context.scale(zoomLevel, zoomLevel); |
| paintInfo.context.translate(-unzoomedRect.x(), -unzoomedRect.y()); |
| } |
| |
| Color fillColor(205, 205, 205); |
| Color borderGradientTopColor(109, 109, 109); |
| Color borderGradientBottomColor(181, 181, 181); |
| Color shadowColor(0, 0, 0, 118); |
| |
| if (!LayoutTheme::isEnabled(o)) { |
| Color tintColor(255, 255, 255, 128); |
| fillColor = fillColor.blend(tintColor); |
| borderGradientTopColor = borderGradientTopColor.blend(tintColor); |
| borderGradientBottomColor = borderGradientBottomColor.blend(tintColor); |
| shadowColor = shadowColor.blend(tintColor); |
| } |
| |
| Color tintColor; |
| if (!LayoutTheme::isEnabled(o)) |
| tintColor = Color(255, 255, 255, 128); |
| |
| bool isVerticalSlider = o.styleRef().appearance() == SliderVerticalPart; |
| |
| float fillRadiusSize = (LayoutThemeMac::sliderTrackWidth - |
| LayoutThemeMac::sliderTrackBorderWidth) / |
| 2; |
| FloatSize fillRadius(fillRadiusSize, fillRadiusSize); |
| FloatRect fillBounds(enclosedIntRect(unzoomedRect)); |
| FloatRoundedRect fillRect(fillBounds, fillRadius, fillRadius, fillRadius, |
| fillRadius); |
| paintInfo.context.fillRoundedRect(fillRect, fillColor); |
| |
| FloatSize shadowOffset(isVerticalSlider ? 1 : 0, isVerticalSlider ? 0 : 1); |
| float shadowBlur = 3; |
| float shadowSpread = 0; |
| paintInfo.context.save(); |
| paintInfo.context.drawInnerShadow(fillRect, shadowColor, shadowOffset, |
| shadowBlur, shadowSpread); |
| paintInfo.context.restore(); |
| |
| RefPtr<Gradient> borderGradient = |
| Gradient::create(fillBounds.minXMinYCorner(), |
| isVerticalSlider ? fillBounds.maxXMinYCorner() |
| : fillBounds.minXMaxYCorner()); |
| borderGradient->addColorStop(0.0, borderGradientTopColor); |
| borderGradient->addColorStop(1.0, borderGradientBottomColor); |
| |
| FloatRect borderRect(unzoomedRect); |
| borderRect.inflate(-LayoutThemeMac::sliderTrackBorderWidth / 2.0); |
| float borderRadiusSize = |
| (isVerticalSlider ? borderRect.width() : borderRect.height()) / 2; |
| FloatSize borderRadius(borderRadiusSize, borderRadiusSize); |
| FloatRoundedRect borderRRect(borderRect, borderRadius, borderRadius, |
| borderRadius, borderRadius); |
| paintInfo.context.setStrokeThickness(LayoutThemeMac::sliderTrackBorderWidth); |
| SkPaint borderPaint(paintInfo.context.strokePaint()); |
| borderGradient->applyToPaint(borderPaint, SkMatrix::I()); |
| paintInfo.context.drawRRect(borderRRect, borderPaint); |
| |
| return false; |
| } |
| |
| bool ThemePainterMac::paintSliderThumb(const LayoutObject& o, |
| const PaintInfo& paintInfo, |
| const IntRect& r) { |
| GraphicsContextStateSaver stateSaver(paintInfo.context); |
| float zoomLevel = o.styleRef().effectiveZoom(); |
| |
| FloatRect unzoomedRect(r.x(), r.y(), LayoutThemeMac::sliderThumbWidth, |
| LayoutThemeMac::sliderThumbHeight); |
| if (zoomLevel != 1.0f) { |
| paintInfo.context.translate(unzoomedRect.x(), unzoomedRect.y()); |
| paintInfo.context.scale(zoomLevel, zoomLevel); |
| paintInfo.context.translate(-unzoomedRect.x(), -unzoomedRect.y()); |
| } |
| |
| Color fillGradientTopColor(250, 250, 250); |
| Color fillGradientUpperMiddleColor(244, 244, 244); |
| Color fillGradientLowerMiddleColor(236, 236, 236); |
| Color fillGradientBottomColor(238, 238, 238); |
| Color borderGradientTopColor(151, 151, 151); |
| Color borderGradientBottomColor(128, 128, 128); |
| Color shadowColor(0, 0, 0, 36); |
| |
| if (!LayoutTheme::isEnabled(o)) { |
| Color tintColor(255, 255, 255, 128); |
| fillGradientTopColor = fillGradientTopColor.blend(tintColor); |
| fillGradientUpperMiddleColor = |
| fillGradientUpperMiddleColor.blend(tintColor); |
| fillGradientLowerMiddleColor = |
| fillGradientLowerMiddleColor.blend(tintColor); |
| fillGradientBottomColor = fillGradientBottomColor.blend(tintColor); |
| borderGradientTopColor = borderGradientTopColor.blend(tintColor); |
| borderGradientBottomColor = borderGradientBottomColor.blend(tintColor); |
| shadowColor = shadowColor.blend(tintColor); |
| } else if (LayoutTheme::isPressed(o)) { |
| Color tintColor(0, 0, 0, 32); |
| fillGradientTopColor = fillGradientTopColor.blend(tintColor); |
| fillGradientUpperMiddleColor = |
| fillGradientUpperMiddleColor.blend(tintColor); |
| fillGradientLowerMiddleColor = |
| fillGradientLowerMiddleColor.blend(tintColor); |
| fillGradientBottomColor = fillGradientBottomColor.blend(tintColor); |
| borderGradientTopColor = borderGradientTopColor.blend(tintColor); |
| borderGradientBottomColor = borderGradientBottomColor.blend(tintColor); |
| shadowColor = shadowColor.blend(tintColor); |
| } |
| |
| FloatRect borderBounds = unzoomedRect; |
| borderBounds.inflate(LayoutThemeMac::sliderThumbBorderWidth / 2.0); |
| |
| borderBounds.inflate(-LayoutThemeMac::sliderThumbBorderWidth); |
| FloatSize shadowOffset(0, 1); |
| paintInfo.context.setShadow( |
| shadowOffset, LayoutThemeMac::sliderThumbShadowBlur, shadowColor); |
| paintInfo.context.setFillColor(Color::black); |
| paintInfo.context.fillEllipse(borderBounds); |
| paintInfo.context.setDrawLooper(nullptr); |
| |
| IntRect fillBounds = enclosedIntRect(unzoomedRect); |
| RefPtr<Gradient> fillGradient = Gradient::create(fillBounds.minXMinYCorner(), |
| fillBounds.minXMaxYCorner()); |
| fillGradient->addColorStop(0.0, fillGradientTopColor); |
| fillGradient->addColorStop(0.52, fillGradientUpperMiddleColor); |
| fillGradient->addColorStop(0.52, fillGradientLowerMiddleColor); |
| fillGradient->addColorStop(1.0, fillGradientBottomColor); |
| SkPaint fillPaint(paintInfo.context.fillPaint()); |
| fillGradient->applyToPaint(fillPaint, SkMatrix::I()); |
| paintInfo.context.drawOval(borderBounds, fillPaint); |
| |
| RefPtr<Gradient> borderGradient = Gradient::create( |
| fillBounds.minXMinYCorner(), fillBounds.minXMaxYCorner()); |
| borderGradient->addColorStop(0.0, borderGradientTopColor); |
| borderGradient->addColorStop(1.0, borderGradientBottomColor); |
| paintInfo.context.setStrokeThickness(LayoutThemeMac::sliderThumbBorderWidth); |
| SkPaint borderPaint(paintInfo.context.strokePaint()); |
| borderGradient->applyToPaint(borderPaint, SkMatrix::I()); |
| paintInfo.context.drawOval(borderBounds, borderPaint); |
| |
| if (LayoutTheme::isFocused(o)) { |
| Path borderPath; |
| borderPath.addEllipse(borderBounds); |
| paintInfo.context.drawFocusRing(borderPath, 5, -2, |
| m_layoutTheme.focusRingColor()); |
| } |
| |
| return false; |
| } |
| |
| // We don't use controlSizeForFont() for search field decorations because it |
| // needs to fit into the search field. The font size will already be modified by |
| // setFontFromControlSize() called on the search field. |
| static NSControlSize searchFieldControlSizeForFont(const ComputedStyle& style) { |
| int fontSize = style.fontSize(); |
| if (fontSize >= 13) |
| return NSRegularControlSize; |
| if (fontSize >= 11) |
| return NSSmallControlSize; |
| return NSMiniControlSize; |
| } |
| |
| bool ThemePainterMac::paintSearchField(const LayoutObject& o, |
| const PaintInfo& paintInfo, |
| const IntRect& r) { |
| LocalCurrentGraphicsContext localContext(paintInfo.context, r); |
| |
| NSSearchFieldCell* search = m_layoutTheme.search(); |
| m_layoutTheme.setSearchCellState(o, r); |
| [search setControlSize:searchFieldControlSizeForFont(o.styleRef())]; |
| |
| GraphicsContextStateSaver stateSaver(paintInfo.context); |
| |
| float zoomLevel = o.styleRef().effectiveZoom(); |
| |
| IntRect unzoomedRect = r; |
| |
| if (zoomLevel != 1.0f) { |
| unzoomedRect.setWidth(unzoomedRect.width() / zoomLevel); |
| unzoomedRect.setHeight(unzoomedRect.height() / zoomLevel); |
| paintInfo.context.translate(unzoomedRect.x(), unzoomedRect.y()); |
| paintInfo.context.scale(zoomLevel, zoomLevel); |
| paintInfo.context.translate(-unzoomedRect.x(), -unzoomedRect.y()); |
| } |
| |
| // Set the search button to nil before drawing. Then reset it so we can |
| // draw it later. |
| [search setSearchButtonCell:nil]; |
| |
| [search drawWithFrame:NSRect(unzoomedRect) |
| inView:m_layoutTheme.documentViewFor(o)]; |
| |
| [search setControlView:nil]; |
| [search resetSearchButtonCell]; |
| |
| return false; |
| } |
| |
| bool ThemePainterMac::paintSearchFieldCancelButton(const LayoutObject& o, |
| const PaintInfo& paintInfo, |
| const IntRect& r) { |
| if (!o.node()) |
| return false; |
| Element* input = o.node()->ownerShadowHost(); |
| if (!input) |
| input = toElement(o.node()); |
| |
| if (!input->layoutObject()->isBox()) |
| return false; |
| |
| GraphicsContextStateSaver stateSaver(paintInfo.context); |
| |
| float zoomLevel = o.styleRef().effectiveZoom(); |
| FloatRect unzoomedRect(r); |
| if (zoomLevel != 1.0f) { |
| unzoomedRect.setWidth(unzoomedRect.width() / zoomLevel); |
| unzoomedRect.setHeight(unzoomedRect.height() / zoomLevel); |
| paintInfo.context.translate(unzoomedRect.x(), unzoomedRect.y()); |
| paintInfo.context.scale(zoomLevel, zoomLevel); |
| paintInfo.context.translate(-unzoomedRect.x(), -unzoomedRect.y()); |
| } |
| |
| Color fillColor(200, 200, 200); |
| |
| if (LayoutTheme::isPressed(o)) { |
| Color tintColor(0, 0, 0, 32); |
| fillColor = fillColor.blend(tintColor); |
| } |
| |
| float centerX = unzoomedRect.x() + unzoomedRect.width() / 2; |
| float centerY = unzoomedRect.y() + unzoomedRect.height() / 2; |
| // The line width is 3px on a regular sized, high DPI NSCancelButtonCell |
| // (which is 28px wide). |
| float lineWidth = unzoomedRect.width() * 3 / 28; |
| // The line length is 16px on a regular sized, high DPI NSCancelButtonCell. |
| float lineLength = unzoomedRect.width() * 16 / 28; |
| |
| Path xPath; |
| FloatSize lineRectRadius(lineWidth / 2, lineWidth / 2); |
| xPath.addRoundedRect( |
| FloatRect(-lineLength / 2, -lineWidth / 2, lineLength, lineWidth), |
| lineRectRadius, lineRectRadius, lineRectRadius, lineRectRadius); |
| xPath.addRoundedRect( |
| FloatRect(-lineWidth / 2, -lineLength / 2, lineWidth, lineLength), |
| lineRectRadius, lineRectRadius, lineRectRadius, lineRectRadius); |
| |
| paintInfo.context.translate(centerX, centerY); |
| paintInfo.context.rotate(deg2rad(45.0)); |
| paintInfo.context.clipOut(xPath); |
| paintInfo.context.rotate(deg2rad(-45.0)); |
| paintInfo.context.translate(-centerX, -centerY); |
| |
| paintInfo.context.setFillColor(fillColor); |
| paintInfo.context.fillEllipse(unzoomedRect); |
| |
| return false; |
| } |
| |
| // FIXME: Share more code with radio buttons. |
| bool ThemePainterMac::paintCheckbox(const LayoutObject& object, |
| const PaintInfo& paintInfo, |
| const IntRect& zoomedRect) { |
| BEGIN_BLOCK_OBJC_EXCEPTIONS |
| |
| ControlStates states = LayoutTheme::controlStatesForLayoutObject(object); |
| float zoomFactor = object.styleRef().effectiveZoom(); |
| |
| // Determine the width and height needed for the control and prepare the cell |
| // for painting. |
| NSButtonCell* checkboxCell = |
| ThemeMac::checkbox(states, zoomedRect, zoomFactor); |
| GraphicsContextStateSaver stateSaver(paintInfo.context); |
| |
| NSControlSize controlSize = [checkboxCell controlSize]; |
| IntSize zoomedSize = ThemeMac::checkboxSizes()[controlSize]; |
| zoomedSize.setWidth(zoomedSize.width() * zoomFactor); |
| zoomedSize.setHeight(zoomedSize.height() * zoomFactor); |
| IntRect inflatedRect = |
| ThemeMac::inflateRect(zoomedRect, zoomedSize, |
| ThemeMac::checkboxMargins(controlSize), zoomFactor); |
| |
| if (zoomFactor != 1.0f) { |
| inflatedRect.setWidth(inflatedRect.width() / zoomFactor); |
| inflatedRect.setHeight(inflatedRect.height() / zoomFactor); |
| paintInfo.context.translate(inflatedRect.x(), inflatedRect.y()); |
| paintInfo.context.scale(zoomFactor, zoomFactor); |
| paintInfo.context.translate(-inflatedRect.x(), -inflatedRect.y()); |
| } |
| |
| LocalCurrentGraphicsContext localContext( |
| paintInfo.context, ThemeMac::inflateRectForFocusRing(inflatedRect)); |
| NSView* view = ThemeMac::ensuredView(object.view()->frameView()); |
| [checkboxCell drawWithFrame:NSRect(inflatedRect) inView:view]; |
| if (states & FocusControlState) |
| [checkboxCell cr_drawFocusRingWithFrame:NSRect(inflatedRect) inView:view]; |
| [checkboxCell setControlView:nil]; |
| |
| END_BLOCK_OBJC_EXCEPTIONS |
| return false; |
| } |
| |
| bool ThemePainterMac::paintRadio(const LayoutObject& object, |
| const PaintInfo& paintInfo, |
| const IntRect& zoomedRect) { |
| ControlStates states = LayoutTheme::controlStatesForLayoutObject(object); |
| float zoomFactor = object.styleRef().effectiveZoom(); |
| |
| // Determine the width and height needed for the control and prepare the cell |
| // for painting. |
| NSButtonCell* radioCell = ThemeMac::radio(states, zoomedRect, zoomFactor); |
| GraphicsContextStateSaver stateSaver(paintInfo.context); |
| |
| NSControlSize controlSize = [radioCell controlSize]; |
| IntSize zoomedSize = ThemeMac::radioSizes()[controlSize]; |
| zoomedSize.setWidth(zoomedSize.width() * zoomFactor); |
| zoomedSize.setHeight(zoomedSize.height() * zoomFactor); |
| IntRect inflatedRect = ThemeMac::inflateRect( |
| zoomedRect, zoomedSize, ThemeMac::radioMargins(controlSize), zoomFactor); |
| |
| if (zoomFactor != 1.0f) { |
| inflatedRect.setWidth(inflatedRect.width() / zoomFactor); |
| inflatedRect.setHeight(inflatedRect.height() / zoomFactor); |
| paintInfo.context.translate(inflatedRect.x(), inflatedRect.y()); |
| paintInfo.context.scale(zoomFactor, zoomFactor); |
| paintInfo.context.translate(-inflatedRect.x(), -inflatedRect.y()); |
| } |
| |
| LocalCurrentGraphicsContext localContext( |
| paintInfo.context, ThemeMac::inflateRectForFocusRing(inflatedRect)); |
| BEGIN_BLOCK_OBJC_EXCEPTIONS |
| NSView* view = ThemeMac::ensuredView(object.view()->frameView()); |
| [radioCell drawWithFrame:NSRect(inflatedRect) inView:view]; |
| if (states & FocusControlState) |
| [radioCell cr_drawFocusRingWithFrame:NSRect(inflatedRect) inView:view]; |
| [radioCell setControlView:nil]; |
| END_BLOCK_OBJC_EXCEPTIONS |
| |
| return false; |
| } |
| |
| bool ThemePainterMac::paintButton(const LayoutObject& object, |
| const PaintInfo& paintInfo, |
| const IntRect& zoomedRect) { |
| BEGIN_BLOCK_OBJC_EXCEPTIONS |
| |
| ControlStates states = LayoutTheme::controlStatesForLayoutObject(object); |
| float zoomFactor = object.styleRef().effectiveZoom(); |
| |
| // Determine the width and height needed for the control and prepare the cell |
| // for painting. |
| NSButtonCell* buttonCell = ThemeMac::button(object.styleRef().appearance(), |
| states, zoomedRect, zoomFactor); |
| GraphicsContextStateSaver stateSaver(paintInfo.context); |
| |
| NSControlSize controlSize = [buttonCell controlSize]; |
| IntSize zoomedSize = ThemeMac::buttonSizes()[controlSize]; |
| // Buttons don't ever constrain width, so the zoomed width can just be |
| // honored. |
| zoomedSize.setWidth(zoomedRect.width()); |
| zoomedSize.setHeight(zoomedSize.height() * zoomFactor); |
| IntRect inflatedRect = zoomedRect; |
| if ([buttonCell bezelStyle] == NSRoundedBezelStyle) { |
| // Center the button within the available space. |
| if (inflatedRect.height() > zoomedSize.height()) { |
| inflatedRect.setY(inflatedRect.y() + |
| (inflatedRect.height() - zoomedSize.height()) / 2); |
| inflatedRect.setHeight(zoomedSize.height()); |
| } |
| |
| // Now inflate it to account for the shadow. |
| inflatedRect = |
| ThemeMac::inflateRect(inflatedRect, zoomedSize, |
| ThemeMac::buttonMargins(controlSize), zoomFactor); |
| |
| if (zoomFactor != 1.0f) { |
| inflatedRect.setWidth(inflatedRect.width() / zoomFactor); |
| inflatedRect.setHeight(inflatedRect.height() / zoomFactor); |
| paintInfo.context.translate(inflatedRect.x(), inflatedRect.y()); |
| paintInfo.context.scale(zoomFactor, zoomFactor); |
| paintInfo.context.translate(-inflatedRect.x(), -inflatedRect.y()); |
| } |
| } |
| |
| LocalCurrentGraphicsContext localContext( |
| paintInfo.context, ThemeMac::inflateRectForFocusRing(inflatedRect)); |
| NSView* view = ThemeMac::ensuredView(object.view()->frameView()); |
| |
| [buttonCell drawWithFrame:NSRect(inflatedRect) inView:view]; |
| if (states & FocusControlState) |
| [buttonCell cr_drawFocusRingWithFrame:NSRect(inflatedRect) inView:view]; |
| [buttonCell setControlView:nil]; |
| |
| END_BLOCK_OBJC_EXCEPTIONS |
| return false; |
| } |
| |
| static ThemeDrawState convertControlStatesToThemeDrawState( |
| ThemeButtonKind kind, |
| ControlStates states) { |
| if (states & ReadOnlyControlState) |
| return kThemeStateUnavailableInactive; |
| if (!(states & EnabledControlState)) |
| return kThemeStateUnavailableInactive; |
| |
| // Do not process PressedState if !EnabledControlState or |
| // ReadOnlyControlState. |
| if (states & PressedControlState) { |
| if (kind == kThemeIncDecButton || kind == kThemeIncDecButtonSmall || |
| kind == kThemeIncDecButtonMini) |
| return states & SpinUpControlState ? kThemeStatePressedUp |
| : kThemeStatePressedDown; |
| return kThemeStatePressed; |
| } |
| return kThemeStateActive; |
| } |
| |
| bool ThemePainterMac::paintInnerSpinButton(const LayoutObject& object, |
| const PaintInfo& paintInfo, |
| const IntRect& zoomedRect) { |
| ControlStates states = LayoutTheme::controlStatesForLayoutObject(object); |
| float zoomFactor = object.styleRef().effectiveZoom(); |
| |
| // We don't use NSStepperCell because there are no ways to draw an |
| // NSStepperCell with the up button highlighted. |
| |
| HIThemeButtonDrawInfo drawInfo; |
| drawInfo.version = 0; |
| drawInfo.state = |
| convertControlStatesToThemeDrawState(kThemeIncDecButton, states); |
| drawInfo.adornment = kThemeAdornmentDefault; |
| ControlSize controlSize = ThemeMac::controlSizeFromPixelSize( |
| ThemeMac::stepperSizes(), zoomedRect.size(), zoomFactor); |
| if (controlSize == NSSmallControlSize) |
| drawInfo.kind = kThemeIncDecButtonSmall; |
| else if (controlSize == NSMiniControlSize) |
| drawInfo.kind = kThemeIncDecButtonMini; |
| else |
| drawInfo.kind = kThemeIncDecButton; |
| |
| IntRect rect(zoomedRect); |
| GraphicsContextStateSaver stateSaver(paintInfo.context); |
| if (zoomFactor != 1.0f) { |
| rect.setWidth(rect.width() / zoomFactor); |
| rect.setHeight(rect.height() / zoomFactor); |
| paintInfo.context.translate(rect.x(), rect.y()); |
| paintInfo.context.scale(zoomFactor, zoomFactor); |
| paintInfo.context.translate(-rect.x(), -rect.y()); |
| } |
| CGRect bounds(rect); |
| CGRect backgroundBounds; |
| HIThemeGetButtonBackgroundBounds(&bounds, &drawInfo, &backgroundBounds); |
| // Center the stepper rectangle in the specified area. |
| backgroundBounds.origin.x = |
| bounds.origin.x + (bounds.size.width - backgroundBounds.size.width) / 2; |
| if (backgroundBounds.size.height < bounds.size.height) { |
| int heightDiff = |
| clampTo<int>(bounds.size.height - backgroundBounds.size.height); |
| backgroundBounds.origin.y = bounds.origin.y + (heightDiff / 2) + 1; |
| } |
| |
| LocalCurrentGraphicsContext localContext(paintInfo.context, rect); |
| HIThemeDrawButton(&backgroundBounds, &drawInfo, localContext.cgContext(), |
| kHIThemeOrientationNormal, 0); |
| return false; |
| } |
| |
| } // namespace blink |
