[go: nahoru, domu]
Google Git
Sign in
chromium / chromium / src / 137d237f941001695681ed5628a20dec84cd3b86 / . / gfx / native_theme_linux.cc
blob: b2087fe4a806e7a94f8e0667ec24b6b6c0756ee9 [file] [log] [blame]
// Copyright (c) 2010 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 "gfx/native_theme_linux.h"
#include <limits>
#include "base/logging.h"
#include "gfx/codec/png_codec.h"
#include "gfx/color_utils.h"
#include "gfx/gfx_module.h"
#include "gfx/size.h"
#include "gfx/rect.h"
#include "grit/gfx_resources.h"
#include "third_party/skia/include/effects/SkGradientShader.h"
namespace gfx {
unsigned int NativeThemeLinux::button_length_ = 14;
unsigned int NativeThemeLinux::scrollbar_width_ = 15;
unsigned int NativeThemeLinux::thumb_inactive_color_ = 0xeaeaea;
unsigned int NativeThemeLinux::thumb_active_color_ = 0xf4f4f4;
unsigned int NativeThemeLinux::track_color_ = 0xd3d3d3;
// These are the default dimensions of radio buttons and checkboxes.
static const int kCheckboxAndRadioWidth = 13;
static const int kCheckboxAndRadioHeight = 13;
// These sizes match the sizes in Chromium Win.
static const int kSliderThumbWidth = 11;
static const int kSliderThumbHeight = 21;
static const SkColor kSliderTrackBackgroundColor =
SkColorSetRGB(0xe3, 0xdd, 0xd8);
static const SkColor kSliderThumbLightGrey = SkColorSetRGB(0xf4, 0xf2, 0xef);
static const SkColor kSliderThumbDarkGrey = SkColorSetRGB(0xea, 0xe5, 0xe0);
static const SkColor kSliderThumbBorderDarkGrey =
SkColorSetRGB(0x9d, 0x96, 0x8e);
#if !defined(OS_CHROMEOS)
// Chromeos has a different look.
// static
NativeThemeLinux* NativeThemeLinux::instance() {
// The global NativeThemeLinux instance.
static NativeThemeLinux s_native_theme;
return &s_native_theme;
}
#endif
// Get lightness adjusted color.
static SkColor BrightenColor(const color_utils::HSL& hsl, SkAlpha alpha,
double lightness_amount) {
color_utils::HSL adjusted = hsl;
adjusted.l += lightness_amount;
if (adjusted.l > 1.0)
adjusted.l = 1.0;
if (adjusted.l < 0.0)
adjusted.l = 0.0;
return color_utils::HSLToSkColor(adjusted, alpha);
}
static SkBitmap* GfxGetBitmapNamed(int key) {
base::StringPiece data = GfxModule::GetResource(key);
if (!data.size()) {
NOTREACHED() << "Unable to load image resource " << key;
return NULL;
}
SkBitmap bitmap;
if (!gfx::PNGCodec::Decode(
reinterpret_cast<const unsigned char*>(data.data()),
data.size(), &bitmap)) {
NOTREACHED() << "Unable to decode image resource " << key;
return NULL;
}
return new SkBitmap(bitmap);
}
NativeThemeLinux::NativeThemeLinux() {
}
NativeThemeLinux::~NativeThemeLinux() {
}
gfx::Size NativeThemeLinux::GetPartSize(Part part) const {
switch (part) {
case kScrollbarDownArrow:
case kScrollbarUpArrow:
return gfx::Size(scrollbar_width_, button_length_);
case kScrollbarLeftArrow:
case kScrollbarRightArrow:
return gfx::Size(button_length_, scrollbar_width_);
case kScrollbarHorizontalThumb:
// This matches Firefox on Linux.
return gfx::Size(2 * scrollbar_width_, scrollbar_width_);
case kScrollbarVerticalThumb:
// This matches Firefox on Linux.
return gfx::Size(scrollbar_width_, 2 * scrollbar_width_);
break;
case kScrollbarHorizontalTrack:
return gfx::Size(0, scrollbar_width_);
case kScrollbarVerticalTrack:
return gfx::Size(scrollbar_width_, 0);
case kCheckbox:
case kRadio:
return gfx::Size(kCheckboxAndRadioWidth, kCheckboxAndRadioHeight);
case kSliderThumb:
// These sizes match the sizes in Chromium Win.
return gfx::Size(kSliderThumbWidth, kSliderThumbHeight);
case kInnerSpinButton:
return gfx::Size(scrollbar_width_, 0);
case kPushButton:
case kTextField:
case kMenuList:
case kSliderTrack:
case kProgressBar:
return gfx::Size(); // No default size.
}
return gfx::Size();
}
void NativeThemeLinux::PaintArrowButton(
skia::PlatformCanvas* canvas,
const gfx::Rect& rect, Part direction, State state) {
int widthMiddle, lengthMiddle;
SkPaint paint;
if (direction == kScrollbarUpArrow || direction == kScrollbarDownArrow) {
widthMiddle = rect.width() / 2 + 1;
lengthMiddle = rect.height() / 2 + 1;
} else {
lengthMiddle = rect.width() / 2 + 1;
widthMiddle = rect.height() / 2 + 1;
}
// Calculate button color.
SkScalar trackHSV[3];
SkColorToHSV(track_color_, trackHSV);
SkColor buttonColor = SaturateAndBrighten(trackHSV, 0, 0.2);
SkColor backgroundColor = buttonColor;
if (state == kPressed) {
SkScalar buttonHSV[3];
SkColorToHSV(buttonColor, buttonHSV);
buttonColor = SaturateAndBrighten(buttonHSV, 0, -0.1);
} else if (state == kHovered) {
SkScalar buttonHSV[3];
SkColorToHSV(buttonColor, buttonHSV);
buttonColor = SaturateAndBrighten(buttonHSV, 0, 0.05);
}
SkIRect skrect;
skrect.set(rect.x(), rect.y(), rect.x() + rect.width(), rect.y()
+ rect.height());
// Paint the background (the area visible behind the rounded corners).
paint.setColor(backgroundColor);
canvas->drawIRect(skrect, paint);
// Paint the button's outline and fill the middle
SkPath outline;
switch (direction) {
case kScrollbarUpArrow:
outline.moveTo(rect.x() + 0.5, rect.y() + rect.height() + 0.5);
outline.rLineTo(0, -(rect.height() - 2));
outline.rLineTo(2, -2);
outline.rLineTo(rect.width() - 5, 0);
outline.rLineTo(2, 2);
outline.rLineTo(0, rect.height() - 2);
break;
case kScrollbarDownArrow:
outline.moveTo(rect.x() + 0.5, rect.y() - 0.5);
outline.rLineTo(0, rect.height() - 2);
outline.rLineTo(2, 2);
outline.rLineTo(rect.width() - 5, 0);
outline.rLineTo(2, -2);
outline.rLineTo(0, -(rect.height() - 2));
break;
case kScrollbarRightArrow:
outline.moveTo(rect.x() - 0.5, rect.y() + 0.5);
outline.rLineTo(rect.width() - 2, 0);
outline.rLineTo(2, 2);
outline.rLineTo(0, rect.height() - 5);
outline.rLineTo(-2, 2);
outline.rLineTo(-(rect.width() - 2), 0);
break;
case kScrollbarLeftArrow:
outline.moveTo(rect.x() + rect.width() + 0.5, rect.y() + 0.5);
outline.rLineTo(-(rect.width() - 2), 0);
outline.rLineTo(-2, 2);
outline.rLineTo(0, rect.height() - 5);
outline.rLineTo(2, 2);
outline.rLineTo(rect.width() - 2, 0);
break;
default:
break;
}
outline.close();
paint.setStyle(SkPaint::kFill_Style);
paint.setColor(buttonColor);
canvas->drawPath(outline, paint);
paint.setAntiAlias(true);
paint.setStyle(SkPaint::kStroke_Style);
SkScalar thumbHSV[3];
SkColorToHSV(thumb_inactive_color_, thumbHSV);
paint.setColor(OutlineColor(trackHSV, thumbHSV));
canvas->drawPath(outline, paint);
// If the button is disabled or read-only, the arrow is drawn with the
// outline color.
if (state != kDisabled)
paint.setColor(SK_ColorBLACK);
paint.setAntiAlias(false);
paint.setStyle(SkPaint::kFill_Style);
SkPath path;
// The constants in this block of code are hand-tailored to produce good
// looking arrows without anti-aliasing.
switch (direction) {
case kScrollbarUpArrow:
path.moveTo(rect.x() + widthMiddle - 4, rect.y() + lengthMiddle + 2);
path.rLineTo(7, 0);
path.rLineTo(-4, -4);
break;
case kScrollbarDownArrow:
path.moveTo(rect.x() + widthMiddle - 4, rect.y() + lengthMiddle - 3);
path.rLineTo(7, 0);
path.rLineTo(-4, 4);
break;
case kScrollbarRightArrow:
path.moveTo(rect.x() + lengthMiddle - 3, rect.y() + widthMiddle - 4);
path.rLineTo(0, 7);
path.rLineTo(4, -4);
break;
case kScrollbarLeftArrow:
path.moveTo(rect.x() + lengthMiddle + 1, rect.y() + widthMiddle - 5);
path.rLineTo(0, 9);
path.rLineTo(-4, -4);
break;
default:
break;
}
path.close();
canvas->drawPath(path, paint);
}
void NativeThemeLinux::Paint(skia::PlatformCanvas* canvas,
Part part,
State state,
const gfx::Rect& rect,
const ExtraParams& extra) {
switch (part) {
case kScrollbarDownArrow:
case kScrollbarUpArrow:
case kScrollbarLeftArrow:
case kScrollbarRightArrow:
PaintArrowButton(canvas, rect, part, state);
break;
case kScrollbarHorizontalThumb:
case kScrollbarVerticalThumb:
PaintScrollbarThumb(canvas, part, state, rect);
break;
case kScrollbarHorizontalTrack:
case kScrollbarVerticalTrack:
PaintScrollbarTrack(canvas, part, state, extra.scrollbar_track, rect);
break;
case kCheckbox:
PaintCheckbox(canvas, state, rect, extra.button);
break;
case kRadio:
PaintRadio(canvas, state, rect, extra.button);
break;
case kPushButton:
PaintButton(canvas, state, rect, extra.button);
break;
case kTextField:
PaintTextField(canvas, state, rect, extra.text_field);
break;
case kMenuList:
PaintMenuList(canvas, state, rect, extra.menu_list);
break;
case kSliderTrack:
PaintSliderTrack(canvas, state, rect, extra.slider);
break;
case kSliderThumb:
PaintSliderThumb(canvas, state, rect, extra.slider);
break;
case kInnerSpinButton:
PaintInnerSpinButton(canvas, state, rect, extra.inner_spin);
break;
case kProgressBar:
PaintProgressBar(canvas, state, rect, extra.progress_bar);
break;
}
}
void NativeThemeLinux::PaintScrollbarTrack(skia::PlatformCanvas* canvas,
Part part,
State state,
const ScrollbarTrackExtraParams& extra_params,
const gfx::Rect& rect) {
SkPaint paint;
SkIRect skrect;
skrect.set(rect.x(), rect.y(), rect.right(), rect.bottom());
SkScalar track_hsv[3];
SkColorToHSV(track_color_, track_hsv);
paint.setColor(SaturateAndBrighten(track_hsv, 0, 0));
canvas->drawIRect(skrect, paint);
SkScalar thumb_hsv[3];
SkColorToHSV(thumb_inactive_color_, thumb_hsv);
paint.setColor(OutlineColor(track_hsv, thumb_hsv));
DrawBox(canvas, rect, paint);
}
void NativeThemeLinux::PaintScrollbarThumb(skia::PlatformCanvas* canvas,
Part part,
State state,
const gfx::Rect& rect) {
const bool hovered = state == kHovered;
const int midx = rect.x() + rect.width() / 2;
const int midy = rect.y() + rect.height() / 2;
const bool vertical = part == kScrollbarVerticalThumb;
SkScalar thumb[3];
SkColorToHSV(hovered ? thumb_active_color_ : thumb_inactive_color_, thumb);
SkPaint paint;
paint.setColor(SaturateAndBrighten(thumb, 0, 0.02));
SkIRect skrect;
if (vertical)
skrect.set(rect.x(), rect.y(), midx + 1, rect.y() + rect.height());
else
skrect.set(rect.x(), rect.y(), rect.x() + rect.width(), midy + 1);
canvas->drawIRect(skrect, paint);
paint.setColor(SaturateAndBrighten(thumb, 0, -0.02));
if (vertical) {
skrect.set(
midx + 1, rect.y(), rect.x() + rect.width(), rect.y() + rect.height());
} else {
skrect.set(
rect.x(), midy + 1, rect.x() + rect.width(), rect.y() + rect.height());
}
canvas->drawIRect(skrect, paint);
SkScalar track[3];
SkColorToHSV(track_color_, track);
paint.setColor(OutlineColor(track, thumb));
DrawBox(canvas, rect, paint);
if (rect.height() > 10 && rect.width() > 10) {
const int grippy_half_width = 2;
const int inter_grippy_offset = 3;
if (vertical) {
DrawHorizLine(canvas,
midx - grippy_half_width,
midx + grippy_half_width,
midy - inter_grippy_offset,
paint);
DrawHorizLine(canvas,
midx - grippy_half_width,
midx + grippy_half_width,
midy,
paint);
DrawHorizLine(canvas,
midx - grippy_half_width,
midx + grippy_half_width,
midy + inter_grippy_offset,
paint);
} else {
DrawVertLine(canvas,
midx - inter_grippy_offset,
midy - grippy_half_width,
midy + grippy_half_width,
paint);
DrawVertLine(canvas,
midx,
midy - grippy_half_width,
midy + grippy_half_width,
paint);
DrawVertLine(canvas,
midx + inter_grippy_offset,
midy - grippy_half_width,
midy + grippy_half_width,
paint);
}
}
}
void NativeThemeLinux::PaintCheckbox(skia::PlatformCanvas* canvas,
State state,
const gfx::Rect& rect,
const ButtonExtraParams& button) {
static SkBitmap* image_disabled_indeterminate = GfxGetBitmapNamed(
IDR_LINUX_CHECKBOX_DISABLED_INDETERMINATE);
static SkBitmap* image_indeterminate = GfxGetBitmapNamed(
IDR_LINUX_CHECKBOX_INDETERMINATE);
static SkBitmap* image_disabled_on = GfxGetBitmapNamed(
IDR_LINUX_CHECKBOX_DISABLED_ON);
static SkBitmap* image_on = GfxGetBitmapNamed(IDR_LINUX_CHECKBOX_ON);
static SkBitmap* image_disabled_off = GfxGetBitmapNamed(
IDR_LINUX_CHECKBOX_DISABLED_OFF);
static SkBitmap* image_off = GfxGetBitmapNamed(IDR_LINUX_CHECKBOX_OFF);
SkBitmap* image = NULL;
if (button.indeterminate) {
image = state == kDisabled ? image_disabled_indeterminate
: image_indeterminate;
} else if (button.checked) {
image = state == kDisabled ? image_disabled_on : image_on;
} else {
image = state == kDisabled ? image_disabled_off : image_off;
}
gfx::Rect bounds = rect.Center(gfx::Size(image->width(), image->height()));
DrawBitmapInt(canvas, *image, 0, 0, image->width(), image->height(),
bounds.x(), bounds.y(), bounds.width(), bounds.height());
}
void NativeThemeLinux::PaintRadio(skia::PlatformCanvas* canvas,
State state,
const gfx::Rect& rect,
const ButtonExtraParams& button) {
static SkBitmap* image_disabled_on = GfxGetBitmapNamed(
IDR_LINUX_RADIO_DISABLED_ON);
static SkBitmap* image_on = GfxGetBitmapNamed(IDR_LINUX_RADIO_ON);
static SkBitmap* image_disabled_off = GfxGetBitmapNamed(
IDR_LINUX_RADIO_DISABLED_OFF);
static SkBitmap* image_off = GfxGetBitmapNamed(IDR_LINUX_RADIO_OFF);
SkBitmap* image = NULL;
if (state == kDisabled)
image = button.checked ? image_disabled_on : image_disabled_off;
else
image = button.checked ? image_on : image_off;
gfx::Rect bounds = rect.Center(gfx::Size(image->width(), image->height()));
DrawBitmapInt(canvas, *image, 0, 0, image->width(), image->height(),
bounds.x(), bounds.y(), bounds.width(), bounds.height());
}
void NativeThemeLinux::PaintButton(skia::PlatformCanvas* canvas,
State state,
const gfx::Rect& rect,
const ButtonExtraParams& button) {
SkPaint paint;
SkRect skrect;
const int kRight = rect.right();
const int kBottom = rect.bottom();
SkColor base_color = button.background_color;
color_utils::HSL base_hsl;
color_utils::SkColorToHSL(base_color, &base_hsl);
// Our standard gradient is from 0xdd to 0xf8. This is the amount of
// increased luminance between those values.
SkColor light_color(BrightenColor(base_hsl, SkColorGetA(base_color), 0.105));
// If the button is too small, fallback to drawing a single, solid color
if (rect.width() < 5 || rect.height() < 5) {
paint.setColor(base_color);
skrect.set(rect.x(), rect.y(), kRight, kBottom);
canvas->drawRect(skrect, paint);
return;
}
const int kBorderAlpha = state == kHovered ? 0x80 : 0x55;
paint.setARGB(kBorderAlpha, 0, 0, 0);
canvas->drawLine(rect.x() + 1, rect.y(), kRight - 1, rect.y(), paint);
canvas->drawLine(kRight - 1, rect.y() + 1, kRight - 1, kBottom - 1, paint);
canvas->drawLine(rect.x() + 1, kBottom - 1, kRight - 1, kBottom - 1, paint);
canvas->drawLine(rect.x(), rect.y() + 1, rect.x(), kBottom - 1, paint);
paint.setColor(SK_ColorBLACK);
const int kLightEnd = state == kPressed ? 1 : 0;
const int kDarkEnd = !kLightEnd;
SkPoint gradient_bounds[2];
gradient_bounds[kLightEnd].set(SkIntToScalar(rect.x()),
SkIntToScalar(rect.y()));
gradient_bounds[kDarkEnd].set(SkIntToScalar(rect.x()),
SkIntToScalar(kBottom - 1));
SkColor colors[2];
colors[0] = light_color;
colors[1] = base_color;
SkShader* shader = SkGradientShader::CreateLinear(
gradient_bounds, colors, NULL, 2, SkShader::kClamp_TileMode, NULL);
paint.setStyle(SkPaint::kFill_Style);
paint.setShader(shader);
shader->unref();
skrect.set(rect.x() + 1, rect.y() + 1, kRight - 1, kBottom - 1);
canvas->drawRect(skrect, paint);
paint.setShader(NULL);
paint.setColor(BrightenColor(base_hsl, SkColorGetA(base_color), -0.0588));
canvas->drawPoint(rect.x() + 1, rect.y() + 1, paint);
canvas->drawPoint(kRight - 2, rect.y() + 1, paint);
canvas->drawPoint(rect.x() + 1, kBottom - 2, paint);
canvas->drawPoint(kRight - 2, kBottom - 2, paint);
}
void NativeThemeLinux::PaintTextField(skia::PlatformCanvas* canvas,
State state,
const gfx::Rect& rect,
const TextFieldExtraParams& text) {
// The following drawing code simulates the user-agent css border for
// text area and text input so that we do not break layout tests. Once we
// have decided the desired looks, we should update the code here and
// the layout test expectations.
SkRect bounds;
bounds.set(rect.x(), rect.y(), rect.right() - 1, rect.bottom() - 1);
SkPaint fill_paint;
fill_paint.setStyle(SkPaint::kFill_Style);
fill_paint.setColor(text.background_color);
canvas->drawRect(bounds, fill_paint);
if (text.is_text_area) {
// Draw text area border: 1px solid black
SkPaint stroke_paint;
fill_paint.setStyle(SkPaint::kStroke_Style);
fill_paint.setColor(SK_ColorBLACK);
canvas->drawRect(bounds, fill_paint);
} else {
// Draw text input and listbox inset border
// Text Input: 2px inset #eee
// Listbox: 1px inset #808080
const SkColor kLightColor = text.is_listbox ?
SkColorSetRGB(0x80, 0x80, 0x80) : SkColorSetRGB(0xee, 0xee, 0xee);
const SkColor kDarkColor = text.is_listbox ?
SkColorSetRGB(0x2c, 0x2c, 0x2c) : SkColorSetRGB(0x9a, 0x9a, 0x9a);
const int kBorderWidth = text.is_listbox ? 1 : 2;
SkPaint dark_paint;
dark_paint.setAntiAlias(true);
dark_paint.setStyle(SkPaint::kFill_Style);
dark_paint.setColor(kDarkColor);
SkPaint light_paint;
light_paint.setAntiAlias(true);
light_paint.setStyle(SkPaint::kFill_Style);
light_paint.setColor(kLightColor);
int left = rect.x();
int top = rect.y();
int right = rect.right();
int bottom = rect.bottom();
SkPath path;
path.incReserve(4);
// Top
path.moveTo(SkIntToScalar(left), SkIntToScalar(top));
path.lineTo(SkIntToScalar(left + kBorderWidth),
SkIntToScalar(top + kBorderWidth));
path.lineTo(SkIntToScalar(right - kBorderWidth),
SkIntToScalar(top + kBorderWidth));
path.lineTo(SkIntToScalar(right), SkIntToScalar(top));
canvas->drawPath(path, dark_paint);
// Bottom
path.reset();
path.moveTo(SkIntToScalar(left + kBorderWidth),
SkIntToScalar(bottom - kBorderWidth));
path.lineTo(SkIntToScalar(left), SkIntToScalar(bottom));
path.lineTo(SkIntToScalar(right), SkIntToScalar(bottom));
path.lineTo(SkIntToScalar(right - kBorderWidth),
SkIntToScalar(bottom - kBorderWidth));
canvas->drawPath(path, light_paint);
// Left
path.reset();
path.moveTo(SkIntToScalar(left), SkIntToScalar(top));
path.lineTo(SkIntToScalar(left), SkIntToScalar(bottom));
path.lineTo(SkIntToScalar(left + kBorderWidth),
SkIntToScalar(bottom - kBorderWidth));
path.lineTo(SkIntToScalar(left + kBorderWidth),
SkIntToScalar(top + kBorderWidth));
canvas->drawPath(path, dark_paint);
// Right
path.reset();
path.moveTo(SkIntToScalar(right - kBorderWidth),
SkIntToScalar(top + kBorderWidth));
path.lineTo(SkIntToScalar(right - kBorderWidth), SkIntToScalar(bottom));
path.lineTo(SkIntToScalar(right), SkIntToScalar(bottom));
path.lineTo(SkIntToScalar(right), SkIntToScalar(top));
canvas->drawPath(path, light_paint);
}
}
void NativeThemeLinux::PaintMenuList(skia::PlatformCanvas* canvas,
State state,
const gfx::Rect& rect,
const MenuListExtraParams& menu_list) {
ButtonExtraParams button = { 0 };
button.background_color = menu_list.background_color;
PaintButton(canvas, state, rect, button);
SkPaint paint;
paint.setColor(SK_ColorBLACK);
paint.setAntiAlias(true);
paint.setStyle(SkPaint::kFill_Style);
SkPath path;
path.moveTo(menu_list.arrow_x, menu_list.arrow_y - 3);
path.rLineTo(6, 0);
path.rLineTo(-3, 6);
path.close();
canvas->drawPath(path, paint);
}
void NativeThemeLinux::PaintSliderTrack(skia::PlatformCanvas* canvas,
State state,
const gfx::Rect& rect,
const SliderExtraParams& slider) {
const int kMidX = rect.x() + rect.width() / 2;
const int kMidY = rect.y() + rect.height() / 2;
SkPaint paint;
paint.setColor(kSliderTrackBackgroundColor);
SkRect skrect;
if (slider.vertical) {
skrect.set(std::max(rect.x(), kMidX - 2),
rect.y(),
std::min(rect.right(), kMidX + 2),
rect.bottom());
} else {
skrect.set(rect.x(),
std::max(rect.y(), kMidY - 2),
rect.right(),
std::min(rect.bottom(), kMidY + 2));
}
canvas->drawRect(skrect, paint);
}
void NativeThemeLinux::PaintSliderThumb(skia::PlatformCanvas* canvas,
State state,
const gfx::Rect& rect,
const SliderExtraParams& slider) {
const bool hovered = (state == kHovered) || slider.in_drag;
const int kMidX = rect.x() + rect.width() / 2;
const int kMidY = rect.y() + rect.height() / 2;
SkPaint paint;
paint.setColor(hovered ? SK_ColorWHITE : kSliderThumbLightGrey);
SkIRect skrect;
if (slider.vertical)
skrect.set(rect.x(), rect.y(), kMidX + 1, rect.bottom());
else
skrect.set(rect.x(), rect.y(), rect.right(), kMidY + 1);
canvas->drawIRect(skrect, paint);
paint.setColor(hovered ? kSliderThumbLightGrey : kSliderThumbDarkGrey);
if (slider.vertical)
skrect.set(kMidX + 1, rect.y(), rect.right(), rect.bottom());
else
skrect.set(rect.x(), kMidY + 1, rect.right(), rect.bottom());
canvas->drawIRect(skrect, paint);
paint.setColor(kSliderThumbBorderDarkGrey);
DrawBox(canvas, rect, paint);
if (rect.height() > 10 && rect.width() > 10) {
DrawHorizLine(canvas, kMidX - 2, kMidX + 2, kMidY, paint);
DrawHorizLine(canvas, kMidX - 2, kMidX + 2, kMidY - 3, paint);
DrawHorizLine(canvas, kMidX - 2, kMidX + 2, kMidY + 3, paint);
}
}
void NativeThemeLinux::PaintInnerSpinButton(skia::PlatformCanvas* canvas,
State state,
const gfx::Rect& rect,
const InnerSpinButtonExtraParams& spin_button) {
if (spin_button.read_only)
state = kDisabled;
State north_state = state;
State south_state = state;
if (spin_button.spin_up)
south_state = south_state != kDisabled ? kNormal : kDisabled;
else
north_state = north_state != kDisabled ? kNormal : kDisabled;
gfx::Rect half = rect;
half.set_height(rect.height() / 2);
PaintArrowButton(canvas, half, kScrollbarUpArrow, north_state);
half.set_y(rect.y() + rect.height() / 2);
PaintArrowButton(canvas, half, kScrollbarDownArrow, south_state);
}
void NativeThemeLinux::PaintProgressBar(skia::PlatformCanvas* canvas,
State state,
const gfx::Rect& rect,
const ProgressBarExtraParams& progress_bar) {
static SkBitmap* bar_image = GfxGetBitmapNamed(IDR_PROGRESS_BAR);
static SkBitmap* value_image = GfxGetBitmapNamed(IDR_PROGRESS_VALUE);
static SkBitmap* left_border_image = GfxGetBitmapNamed(
IDR_PROGRESS_BORDER_LEFT);
static SkBitmap* right_border_image = GfxGetBitmapNamed(
IDR_PROGRESS_BORDER_RIGHT);
double tile_scale = static_cast<double>(rect.height()) /
bar_image->height();
int new_tile_width = static_cast<int>(bar_image->width() * tile_scale);
double tile_scale_x = static_cast<double>(new_tile_width) /
bar_image->width();
DrawTiledImage(canvas, *bar_image, 0, 0, tile_scale_x, tile_scale,
rect.x(), rect.y(), rect.width(), rect.height());
if (progress_bar.value_rect_width) {
new_tile_width = static_cast<int>(value_image->width() * tile_scale);
tile_scale_x = static_cast<double>(new_tile_width) /
value_image->width();
DrawTiledImage(canvas, *value_image, 0, 0, tile_scale_x, tile_scale,
progress_bar.value_rect_x,
progress_bar.value_rect_y,
progress_bar.value_rect_width,
progress_bar.value_rect_height);
}
int dest_left_border_width = static_cast<int>(left_border_image->width() *
tile_scale);
SkRect dest_rect = {
SkIntToScalar(rect.x()),
SkIntToScalar(rect.y()),
SkIntToScalar(rect.x() + dest_left_border_width),
SkIntToScalar(rect.bottom())
};
canvas->drawBitmapRect(*left_border_image, NULL, dest_rect);
int dest_right_border_width = static_cast<int>(right_border_image->width() *
tile_scale);
dest_rect.set(SkIntToScalar(rect.right() - dest_right_border_width),
SkIntToScalar(rect.y()),
SkIntToScalar(rect.right()),
SkIntToScalar(rect.bottom()));
canvas->drawBitmapRect(*right_border_image, NULL, dest_rect);
}
bool NativeThemeLinux::IntersectsClipRectInt(
skia::PlatformCanvas* canvas, int x, int y, int w, int h) {
SkRect clip;
return canvas->getClipBounds(&clip) &&
clip.intersect(SkIntToScalar(x), SkIntToScalar(y), SkIntToScalar(x + w),
SkIntToScalar(y + h));
}
void NativeThemeLinux::DrawVertLine(SkCanvas* canvas,
int x,
int y1,
int y2,
const SkPaint& paint) const {
SkIRect skrect;
skrect.set(x, y1, x + 1, y2 + 1);
canvas->drawIRect(skrect, paint);
}
void NativeThemeLinux::DrawHorizLine(SkCanvas* canvas,
int x1,
int x2,
int y,
const SkPaint& paint) const {
SkIRect skrect;
skrect.set(x1, y, x2 + 1, y + 1);
canvas->drawIRect(skrect, paint);
}
void NativeThemeLinux::DrawBox(SkCanvas* canvas,
const gfx::Rect& rect,
const SkPaint& paint) const {
const int right = rect.x() + rect.width() - 1;
const int bottom = rect.y() + rect.height() - 1;
DrawHorizLine(canvas, rect.x(), right, rect.y(), paint);
DrawVertLine(canvas, right, rect.y(), bottom, paint);
DrawHorizLine(canvas, rect.x(), right, bottom, paint);
DrawVertLine(canvas, rect.x(), rect.y(), bottom, paint);
}
void NativeThemeLinux::DrawBitmapInt(
skia::PlatformCanvas* canvas, const SkBitmap& bitmap,
int src_x, int src_y, int src_w, int src_h,
int dest_x, int dest_y, int dest_w, int dest_h) {
DLOG_ASSERT(src_x + src_w < std::numeric_limits<int16_t>::max() &&
src_y + src_h < std::numeric_limits<int16_t>::max());
if (src_w <= 0 || src_h <= 0 || dest_w <= 0 || dest_h <= 0) {
NOTREACHED() << "Attempting to draw bitmap to/from an empty rect!";
return;
}
if (!IntersectsClipRectInt(canvas, dest_x, dest_y, dest_w, dest_h))
return;
SkRect dest_rect = { SkIntToScalar(dest_x),
SkIntToScalar(dest_y),
SkIntToScalar(dest_x + dest_w),
SkIntToScalar(dest_y + dest_h) };
if (src_w == dest_w && src_h == dest_h) {
// Workaround for apparent bug in Skia that causes image to occasionally
// shift.
SkIRect src_rect = { src_x, src_y, src_x + src_w, src_y + src_h };
canvas->drawBitmapRect(bitmap, &src_rect, dest_rect);
return;
}
// Make a bitmap shader that contains the bitmap we want to draw. This is
// basically what SkCanvas.drawBitmap does internally, but it gives us
// more control over quality and will use the mipmap in the source image if
// it has one, whereas drawBitmap won't.
SkShader* shader = SkShader::CreateBitmapShader(bitmap,
SkShader::kRepeat_TileMode,
SkShader::kRepeat_TileMode);
SkMatrix shader_scale;
shader_scale.setScale(SkFloatToScalar(static_cast<float>(dest_w) / src_w),
SkFloatToScalar(static_cast<float>(dest_h) / src_h));
shader_scale.preTranslate(SkIntToScalar(-src_x), SkIntToScalar(-src_y));
shader_scale.postTranslate(SkIntToScalar(dest_x), SkIntToScalar(dest_y));
shader->setLocalMatrix(shader_scale);
// The rect will be filled by the bitmap.
SkPaint p;
p.setFilterBitmap(true);
p.setShader(shader);
shader->unref();
canvas->drawRect(dest_rect, p);
}
void NativeThemeLinux::DrawTiledImage(SkCanvas* canvas,
const SkBitmap& bitmap,
int src_x, int src_y, double tile_scale_x, double tile_scale_y,
int dest_x, int dest_y, int w, int h) const {
SkShader* shader = SkShader::CreateBitmapShader(bitmap,
SkShader::kRepeat_TileMode,
SkShader::kRepeat_TileMode);
if (tile_scale_x != 1.0 || tile_scale_y != 1.0) {
SkMatrix shader_scale;
shader_scale.setScale(SkDoubleToScalar(tile_scale_x),
SkDoubleToScalar(tile_scale_y));
shader->setLocalMatrix(shader_scale);
}
SkPaint paint;
paint.setShader(shader);
paint.setXfermodeMode(SkXfermode::kSrcOver_Mode);
// CreateBitmapShader returns a Shader with a reference count of one, we
// need to unref after paint takes ownership of the shader.
shader->unref();
canvas->save();
canvas->translate(SkIntToScalar(dest_x - src_x),
SkIntToScalar(dest_y - src_y));
canvas->clipRect(SkRect::MakeXYWH(src_x, src_y, w, h));
canvas->drawPaint(paint);
canvas->restore();
}
SkScalar NativeThemeLinux::Clamp(SkScalar value,
SkScalar min,
SkScalar max) const {
return std::min(std::max(value, min), max);
}
SkColor NativeThemeLinux::SaturateAndBrighten(SkScalar* hsv,
SkScalar saturate_amount,
SkScalar brighten_amount) const {
SkScalar color[3];
color[0] = hsv[0];
color[1] = Clamp(hsv[1] + saturate_amount, 0.0, 1.0);
color[2] = Clamp(hsv[2] + brighten_amount, 0.0, 1.0);
return SkHSVToColor(color);
}
SkColor NativeThemeLinux::OutlineColor(SkScalar* hsv1, SkScalar* hsv2) const {
// GTK Theme engines have way too much control over the layout of
// the scrollbar. We might be able to more closely approximate its
// look-and-feel, if we sent whole images instead of just colors
// from the browser to the renderer. But even then, some themes
// would just break.
//
// So, instead, we don't even try to 100% replicate the look of
// the native scrollbar. We render our own version, but we make
// sure to pick colors that blend in nicely with the system GTK
// theme. In most cases, we can just sample a couple of pixels
// from the system scrollbar and use those colors to draw our
// scrollbar.
//
// This works fine for the track color and the overall thumb
// color. But it fails spectacularly for the outline color used
// around the thumb piece. Not all themes have a clearly defined
// outline. For some of them it is partially transparent, and for
// others the thickness is very unpredictable.
//
// So, instead of trying to approximate the system theme, we
// instead try to compute a reasonable looking choice based on the
// known color of the track and the thumb piece. This is difficult
// when trying to deal both with high- and low-contrast themes,
// and both with positive and inverted themes.
//
// The following code has been tested to look OK with all of the
// default GTK themes.
SkScalar min_diff = Clamp((hsv1[1] + hsv2[1]) * 1.2, 0.28, 0.5);
SkScalar diff = Clamp(fabs(hsv1[2] - hsv2[2]) / 2, min_diff, 0.5);
if (hsv1[2] + hsv2[2] > 1.0)
diff = -diff;
return SaturateAndBrighten(hsv2, -0.2, diff);
}
void NativeThemeLinux::SetScrollbarColors(unsigned inactive_color,
unsigned active_color,
unsigned track_color) const {
thumb_inactive_color_ = inactive_color;
thumb_active_color_ = active_color;
track_color_ = track_color;
}
} // namespace gfx