static SkShader* make_shader() {
int a = 0x99;
int b = 0xBB;
SkPoint pts[] = { { 0, 0 }, { W, H } };
SkColor colors[] = { SkColorSetRGB(a, a, a), SkColorSetRGB(b, b, b) };
return SkGradientShader::CreateLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode);
}
int tool_main(int argc, char** argv) {
SkCommandLineFlags::SetUsage("Creates a simple .skp file for testing.");
SkCommandLineFlags::Parse(argc, argv);
// Validate flags.
if ((FLAGS_blue < 0) || (FLAGS_blue > 255)) {
SkDebugf("--blue must be within range [0,255]\n");
exit(-1);
}
if ((FLAGS_green < 0) || (FLAGS_green > 255)) {
SkDebugf("--green must be within range [0,255]\n");
exit(-1);
}
if (FLAGS_height <= 0) {
SkDebugf("--height must be >0\n");
exit(-1);
}
if ((FLAGS_red < 0) || (FLAGS_red > 255)) {
SkDebugf("--red must be within range [0,255]\n");
exit(-1);
}
if (FLAGS_width <= 0) {
SkDebugf("--width must be >0\n");
exit(-1);
}
if (FLAGS_writePath.isEmpty()) {
SkDebugf("--writePath must be nonempty\n");
exit(-1);
}
SkColor color = SkColorSetRGB(FLAGS_red, FLAGS_green, FLAGS_blue);
skpmaker(FLAGS_width, FLAGS_height, FLAGS_border, color, FLAGS_writePath[0]);
return 0;
}
void
_DC::SetTextColor(COLORREF crText){
if( !context_ ) return;
if (_canvas)
_skPaintText.setColor(SkColorSetRGB(_GetRValue(crText), _GetGValue(crText), _GetBValue(crText)));
::SetTextColor(context_, crText);
}
virtual void onDraw(SkCanvas* canvas) {
SkPaint rectPaint;
rectPaint.setStyle(SkPaint::kStroke_Style);
rectPaint.setStrokeWidth(-1);
SkPaint fillPaint;
fillPaint.setColor(SkColorSetRGB(0xA0,0xDD,0xA0));
for (int i = 0; i < kRows; ++i) {
for (int j = 0; j < kCols; ++j) {
canvas->save();
canvas->translate(kPadX * SK_Scalar1 + (fWidth + kPadX * SK_Scalar1)*j,
kPadY * SK_Scalar1 + (fHeight + kPadY * SK_Scalar1)*i);
// draw the original shapes first so we can see the
// antialiasing on the clipped draw
for (int k = 0; k < 5; ++k) {
rectPaint.setColor(fRectColors[k]);
switch (fClip) {
case kRect_Clip:
canvas->drawRect(fRects[k], rectPaint);
break;
case kRRect_Clip:
canvas->drawRRect(fRRects[k], rectPaint);
break;
case kPath_Clip:
canvas->drawPath(fPaths[k], rectPaint);
break;
}
}
for (int k = 0; k < 5; ++k) {
switch (fClip) {
case kRect_Clip:
canvas->clipRect(fRects[k],
fOps[j*kRows+i][k],
fAntiAlias);
break;
case kRRect_Clip:
canvas->clipRRect(fRRects[k],
fOps[j*kRows+i][k],
fAntiAlias);
break;
case kPath_Clip:
canvas->clipPath(fPaths[k],
fOps[j*kRows+i][k],
fAntiAlias);
break;
}
}
canvas->drawRect(SkRect::MakeWH(fWidth, fHeight), fillPaint);
canvas->restore();
}
}
}
static void ToColor_S4444_Opaque(SkColor dst[], const void* src, int width,
SkColorTable*) {
SkASSERT(width > 0);
const SkPMColor* s = (const SkPMColor*)src;
do {
SkPMColor c = SkPixel4444ToPixel32(*s++);
*dst++ = SkColorSetRGB(SkGetPackedR32(c), SkGetPackedG32(c),
SkGetPackedB32(c));
} while (--width != 0);
}
static void ToColor_S565(SkColor dst[], const void* src, int width,
SkColorTable*) {
SkASSERT(width > 0);
const uint16_t* s = (const uint16_t*)src;
do {
uint16_t c = *s++;
*dst++ = SkColorSetRGB(SkPacked16ToR32(c), SkPacked16ToG32(c),
SkPacked16ToB32(c));
} while (--width != 0);
}
LightingView() {
SkString diffusePath = GetResourcePath("brickwork-texture.jpg");
SkImageDecoder::DecodeFile(diffusePath.c_str(), &fDiffuseBitmap);
SkString normalPath = GetResourcePath("brickwork_normal-map.jpg");
SkImageDecoder::DecodeFile(normalPath.c_str(), &fNormalBitmap);
fLightAngle = 0.0f;
fColorFactor = 0;
LightingShader::Light light;
light.fColor = SkColorSetRGB(0xff, 0xff, 0xff);
light.fDirection.fX = SkScalarSin(fLightAngle)*SkScalarSin(SK_ScalarPI*0.25f);
light.fDirection.fY = SkScalarCos(fLightAngle)*SkScalarSin(SK_ScalarPI*0.25f);
light.fDirection.fZ = SkScalarCos(SK_ScalarPI*0.25f);
SkColor ambient = SkColorSetRGB(0x1f, 0x1f, 0x1f);
fShader.reset(SkNEW_ARGS(LightingShader, (fDiffuseBitmap, fNormalBitmap, light, ambient)));
}
static void ToColor_SI8_Opaque(SkColor dst[], const void* src, int width,
SkColorTable* ctable) {
SkASSERT(width > 0);
const uint8_t* s = (const uint8_t*)src;
const SkPMColor* colors = ctable->lockColors();
do {
SkPMColor c = colors[*s++];
*dst++ = SkColorSetRGB(SkGetPackedR32(c), SkGetPackedG32(c),
SkGetPackedB32(c));
} while (--width != 0);
ctable->unlockColors(false);
}
static void draw(SkCanvas* canvas, SkRect& target, int x, int y) {
SkPaint borderPaint;
borderPaint.setColor(SkColorSetRGB(0x0, 0xDD, 0x0));
borderPaint.setAntiAlias(true);
SkPaint backgroundPaint;
backgroundPaint.setColor(SkColorSetRGB(0xDD, 0x0, 0x0));
backgroundPaint.setAntiAlias(true);
SkPaint foregroundPaint;
foregroundPaint.setColor(SkColorSetRGB(0x0, 0x0, 0xDD));
foregroundPaint.setAntiAlias(true);
canvas->save();
canvas->translate(SkIntToScalar(x), SkIntToScalar(y));
target.inset(SkIntToScalar(-2), SkIntToScalar(-2));
canvas->drawRect(target, borderPaint);
target.inset(SkIntToScalar(2), SkIntToScalar(2));
canvas->drawRect(target, backgroundPaint);
canvas->clipRect(target, SkRegion::kIntersect_Op, true);
target.inset(SkIntToScalar(-4), SkIntToScalar(-4));
canvas->drawRect(target, foregroundPaint);
canvas->restore();
}
static void create_gradient(SkBitmap* bm) {
SkASSERT(1 == bm->width());
const int height = bm->height();
float deltaB = 255.0f / height;
float blue = 255.0f;
SkAutoLockPixels lock(*bm);
for (int y = 0; y < height; y++) {
*bm->getAddr32(0, y) = SkColorSetRGB(0, 0, (U8CPU) blue);
blue -= deltaB;
}
}
void Font::drawComplexText(GraphicsContext* graphicsContext,
const TextRun& run,
const FloatPoint& point,
int from,
int to) const
{
PlatformGraphicsContext* context = graphicsContext->platformContext();
UniscribeHelperTextRun state(run, *this);
SkColor color = graphicsContext->platformContext()->effectiveFillColor();
unsigned char alpha = SkColorGetA(color);
// Skip 100% transparent text; no need to draw anything.
if (!alpha && graphicsContext->platformContext()->getStrokeStyle() == NoStroke)
return;
#if USE(SKIA_TEXT)
HDC hdc = 0;
#else
TransparencyAwareUniscribePainter painter(graphicsContext, this, run, from, to, point);
HDC hdc = painter.hdc();
if (windowsCanHandleTextDrawing(graphicsContext) && !hdc)
return;
// TODO(maruel): http://b/700464 SetTextColor doesn't support transparency.
// Enforce non-transparent color.
color = SkColorSetRGB(SkColorGetR(color), SkColorGetG(color), SkColorGetB(color));
if (hdc) {
SetTextColor(hdc, skia::SkColorToCOLORREF(color));
SetBkMode(hdc, TRANSPARENT);
}
// If there is a non-blur shadow and both the fill color and shadow color
// are opaque, handle without skia.
FloatSize shadowOffset;
float shadowBlur;
Color shadowColor;
ColorSpace shadowColorSpace;
if (graphicsContext->getShadow(shadowOffset, shadowBlur, shadowColor, shadowColorSpace) && windowsCanHandleDrawTextShadow(graphicsContext)) {
COLORREF textColor = skia::SkColorToCOLORREF(SkColorSetARGB(255, shadowColor.red(), shadowColor.green(), shadowColor.blue()));
COLORREF savedTextColor = GetTextColor(hdc);
SetTextColor(hdc, textColor);
state.draw(graphicsContext, hdc, static_cast<int>(point.x()) + shadowOffset.width(),
static_cast<int>(point.y() - fontMetrics().ascent()) + shadowOffset.height(), from, to);
SetTextColor(hdc, savedTextColor);
}
#endif
// Uniscribe counts the coordinates from the upper left, while WebKit uses
// the baseline, so we have to subtract off the ascent.
state.draw(graphicsContext, hdc, lroundf(point.x()), lroundf(point.y() - fontMetrics().ascent()), from, to);
}
static void draw_rotated_image(SkCanvas* canvas, const SkImage* image) {
sk_tool_utils::draw_checkerboard(canvas, SkColorSetRGB(156, 154, 156),
SK_ColorWHITE, 12);
if (!image) {
return;
}
SkRect rect = SkRect::MakeLTRB(-68.0f, -68.0f, 68.0f, 68.0f);
SkPaint paint;
paint.setColor(SkColorSetRGB(49, 48, 49));
SkScalar scale = SkTMin(128.0f / image->width(),
128.0f / image->height());
SkScalar point[2] = {-0.5f * image->width(), -0.5f * image->height()};
for (int j = 0; j < 4; ++j) {
for (int i = 0; i < 4; ++i) {
SkAutoCanvasRestore autoCanvasRestore(canvas, true);
canvas->translate(96.0f + 192.0f * i, 96.0f + 192.0f * j);
canvas->rotate(18.0f * (i + 4 * j));
canvas->drawRect(rect, paint);
canvas->scale(scale, scale);
canvas->drawImage(image, point[0], point[1]);
}
}
}
void DemoLabel::CreateDemoView(view::View* container)
{
link_ = new view::Link(L"Click me!");
link_->set_listener(this);
link_custom_ = new view::Link(L"Click me!");
link_custom_->set_listener(this);
link_custom_->SetFont(ui::ResourceBundle::GetSharedInstance().GetFont(
ui::ResourceBundle::BoldFont));
link_custom_->SetNormalColor(SK_ColorMAGENTA);
link_custom_->SetHighlightedColor(SK_ColorGREEN);
link_disable_ = new view::Link(L"Click me! Oops, I'm disabled!");
link_disable_->SetEnabled(false);
link_disable_->set_listener(this);
link_disable_custom_ = new view::Link(L"Click me! Oops, I'm disabled!");
link_disable_custom_->SetEnabled(false);
link_disable_custom_->SetDisabledColor(SK_ColorGRAY);
link_disable_custom_->set_listener(this);
separator_ = new view::Separator();
label_ = new view::Label(L"I'm a Label!");
label_->SetColor(SkColorSetRGB(142, 233, 233));
label_->SetFont(ui::ResourceBundle::GetSharedInstance().GetFont(
ui::ResourceBundle::LargeFont));
label_align_left_ = new view::Label(L"I'm a Label!");
label_align_left_->SetHorizontalAlignment(view::Label::ALIGN_LEFT);
label_align_right_ = new view::Label(L"I'm a Label!");
label_align_right_->SetHorizontalAlignment(view::Label::ALIGN_RIGHT);
label_multi_line_ = new view::Label(L"I'm a Label! \nTihs's the second line.");
label_multi_line_->SetMultiLine(true);
label_multi_line_->SizeToFit(label_multi_line_->width());
label_multi_line_->SetTooltipText(L"¶àÐбêÇ©");
container->SetLayoutManager(new view::BoxLayout(
view::BoxLayout::kVertical, 5, 5, 5));
container->AddChildView(link_);
container->AddChildView(link_custom_);
container->AddChildView(link_disable_);
container->AddChildView(link_disable_custom_);
container->AddChildView(separator_);
container->AddChildView(label_);
container->AddChildView(label_align_left_);
container->AddChildView(label_align_right_);
container->AddChildView(label_multi_line_);
}
bool SkSVGAttributeParser::parseRGBColorToken(SkColor* c) {
return this->parseParenthesized("rgb", [this](SkColor* c) -> bool {
int32_t r, g, b;
if (this->parseColorComponentToken(&r) &&
this->parseSepToken() &&
this->parseColorComponentToken(&g) &&
this->parseSepToken() &&
this->parseColorComponentToken(&b)) {
*c = SkColorSetRGB(static_cast<uint8_t>(r),
static_cast<uint8_t>(g),
static_cast<uint8_t>(b));
return true;
}
return false;
}, c);
}
bool SkGradientShaderBase::onAsLuminanceColor(SkColor* lum) const {
// we just compute an average color.
// possibly we could weight this based on the proportional width for each color
// assuming they are not evenly distributed in the fPos array.
int r = 0;
int g = 0;
int b = 0;
const int n = fColorCount;
for (int i = 0; i < n; ++i) {
SkColor c = fOrigColors[i];
r += SkColorGetR(c);
g += SkColorGetG(c);
b += SkColorGetB(c);
}
*lum = SkColorSetRGB(rounded_divide(r, n), rounded_divide(g, n), rounded_divide(b, n));
return true;
}
int
_DC::FillSolidRect(RECTDef* pRect, COLORREF crFillColor){
if( !context_ ) return 0;
int nRet = 0;
if (_canvas) {
SkPaint paint;
paint.setColor(SkColorSetRGB(_GetRValue(crFillColor), _GetGValue(crFillColor), _GetBValue(crFillColor)));
SkRect rect;
// Invert rect cords for windows memory bitmap.
if (this->image_) {
int height = _canvas->imageInfo().fHeight;
rect.setLTRB(SkIntToScalar(pRect->left),
SkIntToScalar(height - pRect->top),
SkIntToScalar(pRect->right),
SkIntToScalar(height - pRect->bottom));
}
else {
rect.setLTRB(SkIntToScalar(pRect->left),
SkIntToScalar(pRect->top),
SkIntToScalar(pRect->right),
SkIntToScalar(pRect->bottom));
}
_canvas->drawRect(rect, paint);
/*
SkImageInfo imageInfo;
imageInfo.fAlphaType = SkAlphaType::kOpaque_SkAlphaType;
imageInfo.fColorType = SkColorType::kN32_SkColorType;
imageInfo.fHeight = 5;
imageInfo.fWidth = 5;
SkBitmap bm;
bm.setInfo(imageInfo);
_canvas->readPixels(&bm, 0, 0);*/
}
else {
HBRUSH hBrush = CreateSolidBrush(crFillColor);
nRet = ::FillRect(context_, pRect, hBrush);
::DeleteObject(hBrush);
}
return nRet;
}
SkColor GrTextContext::ComputeCanonicalColor(const SkPaint& paint, bool lcd) {
SkColor canonicalColor = SkPaintPriv::ComputeLuminanceColor(paint);
if (lcd) {
// This is the correct computation, but there are tons of cases where LCD can be overridden.
// For now we just regenerate if any run in a textblob has LCD.
// TODO figure out where all of these overrides are and see if we can incorporate that logic
// at a higher level *OR* use sRGB
SkASSERT(false);
//canonicalColor = SkMaskGamma::CanonicalColor(canonicalColor);
} else {
// A8, though can have mixed BMP text but it shouldn't matter because BMP text won't have
// gamma corrected masks anyways, nor color
U8CPU lum = SkComputeLuminance(SkColorGetR(canonicalColor),
SkColorGetG(canonicalColor),
SkColorGetB(canonicalColor));
// reduce to our finite number of bits
canonicalColor = SkMaskGamma::CanonicalColor(SkColorSetRGB(lum, lum, lum));
}
return canonicalColor;
}
#include "SkShader.h"
#include "ui_gfx/canvas_skia.h"
#include "view/widget/widget.h"
#include "view/widget/native_widget_win.h"
#include "native_view_photobooth.h"
static const int kTransparentAlpha = 200;
static const int kOpaqueAlpha = 255;
static const int kDragFrameBorderSize = 2;
static const int kTwiceDragFrameBorderSize = 2 * kDragFrameBorderSize;
static const float kScalingFactor = 0.5;
static const SkColor kDraggedTabBorderColor = SkColorSetRGB(103, 129, 162);
////////////////////////////////////////////////////////////////////////////////
// DraggedTabView, public:
DraggedTabView::DraggedTabView(const std::vector<view::View*>& renderers,
const std::vector<gfx::Rect>& renderer_bounds,
const gfx::Point& mouse_tab_offset,
const gfx::Size& contents_size,
NativeViewPhotobooth* photobooth)
: renderers_(renderers),
renderer_bounds_(renderer_bounds),
show_contents_on_drag_(true),
mouse_tab_offset_(mouse_tab_offset),
photobooth_(photobooth),
contents_size_(contents_size)
PassOwnPtr<DragImage> DragImage::create(const KURL& url, const String& inLabel, const FontDescription& systemFont, float deviceScaleFactor)
{
const Font labelFont = deriveDragLabelFont(kDragLinkLabelFontSize, FontWeightBold, systemFont);
const Font urlFont = deriveDragLabelFont(kDragLinkUrlFontSize, FontWeightNormal, systemFont);
FontCachePurgePreventer fontCachePurgePreventer;
bool drawURLString = true;
bool clipURLString = false;
bool clipLabelString = false;
String urlString = url.string();
String label = inLabel.stripWhiteSpace();
if (label.isEmpty()) {
drawURLString = false;
label = urlString;
}
// First step is drawing the link drag image width.
TextRun labelRun(label.impl());
TextRun urlRun(urlString.impl());
IntSize labelSize(labelFont.width(labelRun), labelFont.fontMetrics().ascent() + labelFont.fontMetrics().descent());
if (labelSize.width() > kMaxDragLabelStringWidth) {
labelSize.setWidth(kMaxDragLabelStringWidth);
clipLabelString = true;
}
IntSize urlStringSize;
IntSize imageSize(labelSize.width() + kDragLabelBorderX * 2, labelSize.height() + kDragLabelBorderY * 2);
if (drawURLString) {
urlStringSize.setWidth(urlFont.width(urlRun));
urlStringSize.setHeight(urlFont.fontMetrics().ascent() + urlFont.fontMetrics().descent());
imageSize.setHeight(imageSize.height() + urlStringSize.height());
if (urlStringSize.width() > kMaxDragLabelStringWidth) {
imageSize.setWidth(kMaxDragLabelWidth);
clipURLString = true;
} else
imageSize.setWidth(std::max(labelSize.width(), urlStringSize.width()) + kDragLabelBorderX * 2);
}
// We now know how big the image needs to be, so we create and
// fill the background
IntSize scaledImageSize = imageSize;
scaledImageSize.scale(deviceScaleFactor);
OwnPtr<ImageBuffer> buffer(ImageBuffer::create(scaledImageSize));
if (!buffer)
return nullptr;
buffer->canvas()->scale(deviceScaleFactor, deviceScaleFactor);
const float DragLabelRadius = 5;
IntRect rect(IntPoint(), imageSize);
SkPaint backgroundPaint;
backgroundPaint.setColor(SkColorSetRGB(140, 140, 140));
SkRRect rrect;
rrect.setRectXY(SkRect::MakeWH(imageSize.width(), imageSize.height()), DragLabelRadius, DragLabelRadius);
buffer->canvas()->drawRRect(rrect, backgroundPaint);
// Draw the text
SkPaint textPaint;
if (drawURLString) {
if (clipURLString)
urlString = StringTruncator::centerTruncate(urlString, imageSize.width() - (kDragLabelBorderX * 2.0f), urlFont);
IntPoint textPos(kDragLabelBorderX, imageSize.height() - (kLabelBorderYOffset + urlFont.fontMetrics().descent()));
TextRun textRun(urlString);
urlFont.drawText(buffer->canvas(), TextRunPaintInfo(textRun), textPos, deviceScaleFactor, textPaint);
}
if (clipLabelString)
label = StringTruncator::rightTruncate(label, imageSize.width() - (kDragLabelBorderX * 2.0f), labelFont);
bool hasStrongDirectionality;
TextRun textRun = textRunWithDirectionality(label, &hasStrongDirectionality);
IntPoint textPos(kDragLabelBorderX, kDragLabelBorderY + labelFont.fontDescription().computedPixelSize());
if (hasStrongDirectionality && textRun.direction() == RTL) {
float textWidth = labelFont.width(textRun);
int availableWidth = imageSize.width() - kDragLabelBorderX * 2;
textPos.setX(availableWidth - ceilf(textWidth));
}
labelFont.drawBidiText(buffer->canvas(), TextRunPaintInfo(textRun), FloatPoint(textPos), Font::DoNotPaintIfFontNotReady, deviceScaleFactor, textPaint);
RefPtr<Image> image = buffer->newImageSnapshot();
return DragImage::create(image.get(), DoNotRespectImageOrientation, deviceScaleFactor);
}
bool SkDifferentPixelsMetric::diff(SkBitmap* baseline, SkBitmap* test,
const BitmapsToCreate& bitmapsToCreate,
Result* result) const {
double startTime = get_seconds();
// Ensure the images are comparable
if (baseline->width() != test->width() || baseline->height() != test->height() ||
baseline->width() <= 0 || baseline->height() <= 0 ||
baseline->colorType() != test->colorType()) {
SkASSERT(baseline->width() == test->width());
SkASSERT(baseline->height() == test->height());
SkASSERT(baseline->width() > 0);
SkASSERT(baseline->height() > 0);
SkASSERT(baseline->colorType() == test->colorType());
return false;
}
int width = baseline->width();
int height = baseline->height();
int maxRedDiff = 0;
int maxGreenDiff = 0;
int maxBlueDiff = 0;
// Prepare any bitmaps we will be filling in
if (bitmapsToCreate.alphaMask) {
result->poiAlphaMask.allocPixels(SkImageInfo::MakeA8(width, height));
result->poiAlphaMask.eraseARGB(SK_AlphaOPAQUE, 0, 0, 0);
}
if (bitmapsToCreate.rgbDiff) {
result->rgbDiffBitmap.allocPixels(SkImageInfo::Make(width, height, baseline->colorType(),
kPremul_SkAlphaType));
result->rgbDiffBitmap.eraseARGB(SK_AlphaTRANSPARENT, 0, 0, 0);
}
if (bitmapsToCreate.whiteDiff) {
result->whiteDiffBitmap.allocPixels(SkImageInfo::MakeN32Premul(width, height));
result->whiteDiffBitmap.eraseARGB(SK_AlphaOPAQUE, 0, 0, 0);
}
// Prepare the pixels for comparison
result->poiCount = 0;
baseline->lockPixels();
test->lockPixels();
for (int y = 0; y < height; y++) {
// Grab a row from each image for easy comparison
// TODO(epoger): The code below already assumes 4 bytes per pixel, so I think
// we could just call getAddr32() to save a little time.
// OR, if we want to play it safe, call ComputeBytesPerPixel instead
// of assuming 4 bytes per pixel.
uint32_t* baselineRow = static_cast<uint32_t *>(baseline->getAddr(0, y));
uint32_t* testRow = static_cast<uint32_t *>(test->getAddr(0, y));
for (int x = 0; x < width; x++) {
// Compare one pixel at a time so each differing pixel can be noted
// TODO(epoger): This loop looks like a good place to work on performance,
// but we should run the code through a profiler to be sure.
uint32_t baselinePixel = baselineRow[x];
uint32_t testPixel = testRow[x];
if (baselinePixel != testPixel) {
result->poiCount++;
int redDiff = SkTAbs(static_cast<int>(SkColorGetR(baselinePixel) -
SkColorGetR(testPixel)));
if (redDiff > maxRedDiff) {maxRedDiff = redDiff;}
int greenDiff = SkTAbs(static_cast<int>(SkColorGetG(baselinePixel) -
SkColorGetG(testPixel)));
if (greenDiff > maxGreenDiff) {maxGreenDiff = greenDiff;}
int blueDiff = SkTAbs(static_cast<int>(SkColorGetB(baselinePixel) -
SkColorGetB(testPixel)));
if (blueDiff > maxBlueDiff) {maxBlueDiff = blueDiff;}
if (bitmapsToCreate.alphaMask) {
*result->poiAlphaMask.getAddr8(x,y) = SK_AlphaTRANSPARENT;
}
if (bitmapsToCreate.rgbDiff) {
*result->rgbDiffBitmap.getAddr32(x,y) =
SkColorSetRGB(redDiff, greenDiff, blueDiff);
}
if (bitmapsToCreate.whiteDiff) {
*result->whiteDiffBitmap.getAddr32(x,y) = SK_ColorWHITE;
}
}
}
}
test->unlockPixels();
baseline->unlockPixels();
result->maxRedDiff = maxRedDiff;
result->maxGreenDiff = maxGreenDiff;
result->maxBlueDiff = maxBlueDiff;
if (bitmapsToCreate.alphaMask) {
result->poiAlphaMask.unlockPixels();
}
if (bitmapsToCreate.rgbDiff) {
result->rgbDiffBitmap.unlockPixels();
}
if (bitmapsToCreate.whiteDiff) {
result->whiteDiffBitmap.unlockPixels();
}
// Calculates the percentage of identical pixels
result->result = 1.0 - ((double)result->poiCount / (width * height));
result->timeElapsed = get_seconds() - startTime;
return true;
}
void CCTiledLayerImpl::appendQuads(CCQuadSink& quadSink, CCAppendQuadsData& appendQuadsData)
{
const IntRect& contentRect = visibleContentRect();
if (!m_tiler || m_tiler->hasEmptyBounds() || contentRect.isEmpty())
return;
CCSharedQuadState* sharedQuadState = quadSink.useSharedQuadState(createSharedQuadState());
appendDebugBorderQuad(quadSink, sharedQuadState, appendQuadsData);
int left, top, right, bottom;
m_tiler->contentRectToTileIndices(contentRect, left, top, right, bottom);
if (hasDebugBorders()) {
for (int j = top; j <= bottom; ++j) {
for (int i = left; i <= right; ++i) {
DrawableTile* tile = tileAt(i, j);
IntRect tileRect = m_tiler->tileBounds(i, j);
SkColor borderColor;
if (m_skipsDraw || !tile || !tile->resourceId())
borderColor = SkColorSetARGB(debugTileBorderAlpha, debugTileBorderMissingTileColorRed, debugTileBorderMissingTileColorGreen, debugTileBorderMissingTileColorBlue);
else
borderColor = SkColorSetARGB(debugTileBorderAlpha, debugTileBorderColorRed, debugTileBorderColorGreen, debugTileBorderColorBlue);
quadSink.append(CCDebugBorderDrawQuad::create(sharedQuadState, tileRect, borderColor, debugTileBorderWidth).PassAs<CCDrawQuad>(), appendQuadsData);
}
}
}
if (m_skipsDraw)
return;
for (int j = top; j <= bottom; ++j) {
for (int i = left; i <= right; ++i) {
DrawableTile* tile = tileAt(i, j);
IntRect tileRect = m_tiler->tileBounds(i, j);
IntRect displayRect = tileRect;
tileRect.intersect(contentRect);
// Skip empty tiles.
if (tileRect.isEmpty())
continue;
if (!tile || !tile->resourceId()) {
if (drawCheckerboardForMissingTiles()) {
SkColor defaultColor = SkColorSetRGB(defaultCheckerboardColorRed, defaultCheckerboardColorGreen, defaultCheckerboardColorBlue);
SkColor evictedColor = SkColorSetRGB(debugTileEvictedCheckerboardColorRed, debugTileEvictedCheckerboardColorGreen, debugTileEvictedCheckerboardColorBlue);
SkColor invalidatedColor = SkColorSetRGB(debugTileInvalidatedCheckerboardColorRed, debugTileEvictedCheckerboardColorGreen, debugTileEvictedCheckerboardColorBlue);
SkColor checkerColor;
if (hasDebugBorders())
checkerColor = tile ? invalidatedColor : evictedColor;
else
checkerColor = defaultColor;
appendQuadsData.hadMissingTiles |= quadSink.append(CCCheckerboardDrawQuad::create(sharedQuadState, tileRect, checkerColor).PassAs<CCDrawQuad>(), appendQuadsData);
} else
appendQuadsData.hadMissingTiles |= quadSink.append(CCSolidColorDrawQuad::create(sharedQuadState, tileRect, backgroundColor()).PassAs<CCDrawQuad>(), appendQuadsData);
continue;
}
IntRect tileOpaqueRect = tile->opaqueRect();
tileOpaqueRect.intersect(contentRect);
// Keep track of how the top left has moved, so the texture can be
// offset the same amount.
IntSize displayOffset = tileRect.minXMinYCorner() - displayRect.minXMinYCorner();
IntPoint textureOffset = m_tiler->textureOffset(i, j) + displayOffset;
float tileWidth = static_cast<float>(m_tiler->tileSize().width());
float tileHeight = static_cast<float>(m_tiler->tileSize().height());
IntSize textureSize(tileWidth, tileHeight);
bool clipped = false;
FloatQuad visibleContentInTargetQuad = CCMathUtil::mapQuad(drawTransform(), FloatQuad(visibleContentRect()), clipped);
bool isAxisAlignedInTarget = !clipped && visibleContentInTargetQuad.isRectilinear();
bool useAA = m_tiler->hasBorderTexels() && !isAxisAlignedInTarget;
bool leftEdgeAA = !i && useAA;
bool topEdgeAA = !j && useAA;
bool rightEdgeAA = i == m_tiler->numTilesX() - 1 && useAA;
bool bottomEdgeAA = j == m_tiler->numTilesY() - 1 && useAA;
const GC3Dint textureFilter = m_tiler->hasBorderTexels() ? GraphicsContext3D::LINEAR : GraphicsContext3D::NEAREST;
quadSink.append(CCTileDrawQuad::create(sharedQuadState, tileRect, tileOpaqueRect, tile->resourceId(), textureOffset, textureSize, textureFilter, contentsSwizzled(), leftEdgeAA, topEdgeAA, rightEdgeAA, bottomEdgeAA).PassAs<CCDrawQuad>(), appendQuadsData);
}
}
}
void SkPixelXorXfermode::flatten(SkWriteBuffer& wb) const {
wb.writeColor(SkColorSetRGB(SkGetPackedR32(fOpColor),
SkGetPackedG32(fOpColor),
SkGetPackedB32(fOpColor)));
}
namespace WebTestRunner {
static const SkColor edgeColor = SK_ColorBLACK;
static const SkColor readOnlyColor = SkColorSetRGB(0xe9, 0xc2, 0xa6);
static const SkColor bgColors[] = {
SkColorSetRGB(0xc9, 0xc9, 0xc9), // Disabled
SkColorSetRGB(0x43, 0xf9, 0xff), // Hover (Win's "Hot")
SkColorSetRGB(0x89, 0xc4, 0xff), // Normal
SkColorSetRGB(0xa9, 0xff, 0x12), // Pressed
SkColorSetRGB(0x00, 0xf3, 0xac), // Focused
SkColorSetRGB(0xf3, 0xe0, 0xd0), // Readonly
};
blink::WebSize WebTestThemeEngineMock::getSize(WebThemeEngine::Part part)
{
// FIXME: We use this constant to indicate we are being asked for the size of
// a part that we don't expect to be asked about. We return a garbage value
// rather than just asserting because this code doesn't have access to either
// WTF or base to raise an assertion or do any logging :(.
const blink::WebSize invalidPartSize = blink::WebSize(100, 100);
switch (part) {
case WebThemeEngine::PartScrollbarLeftArrow:
return blink::WebSize(17, 15);
case WebThemeEngine::PartScrollbarRightArrow:
return invalidPartSize;
case WebThemeEngine::PartScrollbarUpArrow:
return blink::WebSize(15, 17);
case WebThemeEngine::PartScrollbarDownArrow:
return invalidPartSize;
case WebThemeEngine::PartScrollbarHorizontalThumb:
return blink::WebSize(15, 15);
case WebThemeEngine::PartScrollbarVerticalThumb:
return blink::WebSize(15, 15);
case WebThemeEngine::PartScrollbarHorizontalTrack:
return blink::WebSize(0, 15);
case WebThemeEngine::PartScrollbarVerticalTrack:
return blink::WebSize(15, 0);
case WebThemeEngine::PartCheckbox:
case WebThemeEngine::PartRadio:
return blink::WebSize(13, 13);
case WebThemeEngine::PartSliderThumb:
return blink::WebSize(11, 21);
case WebThemeEngine::PartInnerSpinButton:
return blink::WebSize(15, 8);
default:
return invalidPartSize;
}
}
static SkIRect webRectToSkIRect(const WebRect& webRect)
{
SkIRect irect;
irect.set(webRect.x, webRect.y,
webRect.x + webRect.width - 1, webRect.y + webRect.height - 1);
return irect;
}
static SkIRect validate(const SkIRect& rect, WebThemeEngine::Part part)
{
switch (part) {
case WebThemeEngine::PartCheckbox:
case WebThemeEngine::PartRadio: {
SkIRect retval = rect;
// The maximum width and height is 13.
// Center the square in the passed rectangle.
const int maxControlSize = 13;
int controlSize = std::min(rect.width(), rect.height());
controlSize = std::min(controlSize, maxControlSize);
retval.fLeft = rect.fLeft + (rect.width() / 2) - (controlSize / 2);
retval.fRight = retval.fLeft + controlSize - 1;
retval.fTop = rect.fTop + (rect.height() / 2) - (controlSize / 2);
retval.fBottom = retval.fTop + controlSize - 1;
return retval;
}
default:
return rect;
}
}
void box(SkCanvas *canvas, const SkIRect& rect, SkColor fillColor)
{
SkPaint paint;
paint.setStyle(SkPaint::kFill_Style);
paint.setColor(fillColor);
canvas->drawIRect(rect, paint);
paint.setColor(edgeColor);
paint.setStyle(SkPaint::kStroke_Style);
canvas->drawIRect(rect, paint);
}
void line(SkCanvas *canvas, int x0, int y0, int x1, int y1, SkColor color)
{
SkPaint paint;
paint.setColor(color);
canvas->drawLine(SkIntToScalar(x0), SkIntToScalar(y0),
SkIntToScalar(x1), SkIntToScalar(y1), paint);
}
void triangle(SkCanvas *canvas,
int x0, int y0,
int x1, int y1,
int x2, int y2,
SkColor color)
{
SkPath path;
SkPaint paint;
paint.setColor(color);
paint.setStyle(SkPaint::kFill_Style);
path.incReserve(4);
path.moveTo(SkIntToScalar(x0), SkIntToScalar(y0));
path.lineTo(SkIntToScalar(x1), SkIntToScalar(y1));
path.lineTo(SkIntToScalar(x2), SkIntToScalar(y2));
path.close();
canvas->drawPath(path, paint);
paint.setColor(edgeColor);
paint.setStyle(SkPaint::kStroke_Style);
canvas->drawPath(path, paint);
}
void roundRect(SkCanvas *canvas, SkIRect irect, SkColor color)
{
SkRect rect;
SkScalar radius = SkIntToScalar(5);
SkPaint paint;
rect.set(irect);
paint.setColor(color);
paint.setStyle(SkPaint::kFill_Style);
canvas->drawRoundRect(rect, radius, radius, paint);
paint.setColor(edgeColor);
paint.setStyle(SkPaint::kStroke_Style);
canvas->drawRoundRect(rect, radius, radius, paint);
}
void oval(SkCanvas* canvas, SkIRect irect, SkColor color)
{
SkRect rect;
SkPaint paint;
rect.set(irect);
paint.setColor(color);
paint.setStyle(SkPaint::kFill_Style);
canvas->drawOval(rect, paint);
paint.setColor(edgeColor);
paint.setStyle(SkPaint::kStroke_Style);
canvas->drawOval(rect, paint);
}
void circle(SkCanvas *canvas, SkIRect irect, SkScalar radius, SkColor color)
{
int left = irect.fLeft;
int width = irect.width();
int height = irect.height();
int top = irect.fTop;
SkScalar cy = SkIntToScalar(top + height / 2);
SkScalar cx = SkIntToScalar(left + width / 2);
SkPaint paint;
paint.setColor(color);
paint.setStyle(SkPaint::kFill_Style);
canvas->drawCircle(cx, cy, radius, paint);
paint.setColor(edgeColor);
paint.setStyle(SkPaint::kStroke_Style);
canvas->drawCircle(cx, cy, radius, paint);
}
void nestedBoxes(SkCanvas *canvas,
SkIRect irect,
int indentLeft,
int indentTop,
int indentRight,
int indentBottom,
SkColor outerColor,
SkColor innerColor)
{
SkIRect lirect;
box(canvas, irect, outerColor);
lirect.set(irect.fLeft + indentLeft,
irect.fTop + indentTop,
irect.fRight - indentRight,
irect.fBottom - indentBottom);
box(canvas, lirect, innerColor);
}
void markState(SkCanvas *canvas, SkIRect irect, WebThemeEngine::State state)
{
int left = irect.fLeft;
int right = irect.fRight;
int top = irect.fTop;
int bottom = irect.fBottom;
// The length of a triangle side for the corner marks.
const int triangleSize = 5;
switch (state) {
case WebThemeEngine::StateDisabled:
case WebThemeEngine::StateNormal:
// Don't visually mark these states (color is enough).
break;
case WebThemeEngine::StateReadonly: {
// The horizontal lines in a read only control are spaced by this amount.
const int readOnlyLineOffset = 5;
// Drawing lines across the control.
for (int i = top + readOnlyLineOffset; i < bottom; i += readOnlyLineOffset)
line(canvas, left + 1, i, right - 1, i, readOnlyColor);
break;
}
case WebThemeEngine::StateHover:
// Draw a triangle in the upper left corner of the control. (Win's "hot")
triangle(canvas,
left, top,
left + triangleSize, top,
left, top + triangleSize,
edgeColor);
break;
case WebThemeEngine::StateFocused:
// Draw a triangle in the bottom right corner of the control.
triangle(canvas,
right, bottom,
right - triangleSize, bottom,
right, bottom - triangleSize,
edgeColor);
break;
case WebThemeEngine::StatePressed:
// Draw a triangle in the bottom left corner of the control.
triangle(canvas,
left, bottom,
left, bottom - triangleSize,
left + triangleSize, bottom,
edgeColor);
break;
default:
// FIXME: Should we do something here to indicate that we got an invalid state?
// Unfortunately, we can't assert because we don't have access to WTF or base.
break;
}
}
void WebTestThemeEngineMock::paint(
blink::WebCanvas* canvas,
WebThemeEngine::Part part,
WebThemeEngine::State state,
const blink::WebRect& rect,
const WebThemeEngine::ExtraParams* extraParams)
{
SkIRect irect = webRectToSkIRect(rect);
SkPaint paint;
// Indent amounts for the check in a checkbox or radio button.
const int checkIndent = 3;
// Indent amounts for short and long sides of the scrollbar notches.
const int notchLongOffset = 1;
const int notchShortOffset = 4;
const int noOffset = 0;
// Indent amounts for the short and long sides of a scroll thumb box.
const int thumbLongIndent = 0;
const int thumbShortIndent = 2;
// Indents for the crosshatch on a scroll grip.
const int gripLongIndent = 3;
const int gripShortIndent = 5;
// Indents for the the slider track.
const int sliderIndent = 2;
int halfHeight = irect.height() / 2;
int halfWidth = irect.width() / 2;
int quarterHeight = irect.height() / 4;
int quarterWidth = irect.width() / 4;
int left = irect.fLeft;
int right = irect.fRight;
int top = irect.fTop;
int bottom = irect.fBottom;
switch (part) {
case WebThemeEngine::PartScrollbarDownArrow:
box(canvas, irect, bgColors[state]);
triangle(canvas,
left + quarterWidth, top + quarterHeight,
right - quarterWidth, top + quarterHeight,
left + halfWidth, bottom - quarterHeight,
edgeColor);
markState(canvas, irect, state);
break;
case WebThemeEngine::PartScrollbarLeftArrow:
box(canvas, irect, bgColors[state]);
triangle(canvas,
right - quarterWidth, top + quarterHeight,
right - quarterWidth, bottom - quarterHeight,
left + quarterWidth, top + halfHeight,
edgeColor);
break;
case WebThemeEngine::PartScrollbarRightArrow:
box(canvas, irect, bgColors[state]);
triangle(canvas,
left + quarterWidth, top + quarterHeight,
right - quarterWidth, top + halfHeight,
left + quarterWidth, bottom - quarterHeight,
edgeColor);
break;
case WebThemeEngine::PartScrollbarUpArrow:
box(canvas, irect, bgColors[state]);
triangle(canvas,
left + quarterWidth, bottom - quarterHeight,
left + halfWidth, top + quarterHeight,
right - quarterWidth, bottom - quarterHeight,
edgeColor);
markState(canvas, irect, state);
break;
case WebThemeEngine::PartScrollbarHorizontalThumb: {
// Draw a narrower box on top of the outside box.
nestedBoxes(canvas, irect, thumbLongIndent, thumbShortIndent,
thumbLongIndent, thumbShortIndent,
bgColors[state], bgColors[state]);
// Draw a horizontal crosshatch for the grip.
int longOffset = halfWidth - gripLongIndent;
line(canvas,
left + gripLongIndent, top + halfHeight,
right - gripLongIndent, top + halfHeight,
edgeColor);
line(canvas,
left + longOffset, top + gripShortIndent,
left + longOffset, bottom - gripShortIndent,
edgeColor);
line(canvas,
right - longOffset, top + gripShortIndent,
right - longOffset, bottom - gripShortIndent,
edgeColor);
markState(canvas, irect, state);
break;
}
case WebThemeEngine::PartScrollbarVerticalThumb: {
// Draw a shorter box on top of the outside box.
nestedBoxes(canvas, irect, thumbShortIndent, thumbLongIndent,
thumbShortIndent, thumbLongIndent,
bgColors[state], bgColors[state]);
// Draw a vertical crosshatch for the grip.
int longOffset = halfHeight - gripLongIndent;
line(canvas,
left + halfWidth, top + gripLongIndent,
left + halfWidth, bottom - gripLongIndent,
edgeColor);
line(canvas,
left + gripShortIndent, top + longOffset,
right - gripShortIndent, top + longOffset,
edgeColor);
line(canvas,
left + gripShortIndent, bottom - longOffset,
right - gripShortIndent, bottom - longOffset,
edgeColor);
markState(canvas, irect, state);
break;
}
case WebThemeEngine::PartScrollbarHorizontalTrack: {
int longOffset = halfHeight - notchLongOffset;
int shortOffset = irect.width() - notchShortOffset;
if (extraParams->scrollbarTrack.isBack) {
// back, notch on left
nestedBoxes(canvas, irect, noOffset, longOffset, shortOffset,
longOffset, bgColors[state], edgeColor);
} else {
// forward, notch on right
nestedBoxes(canvas, irect, shortOffset, longOffset, noOffset,
longOffset, bgColors[state], edgeColor);
}
markState(canvas, irect, state);
break;
}
case WebThemeEngine::PartScrollbarVerticalTrack: {
int longOffset = halfWidth - notchLongOffset;
int shortOffset = irect.height() - notchShortOffset;
if (extraParams->scrollbarTrack.isBack) {
// back, notch at top
nestedBoxes(canvas, irect, longOffset, noOffset, longOffset,
shortOffset, bgColors[state], edgeColor);
} else {
// forward, notch at bottom
nestedBoxes(canvas, irect, longOffset, shortOffset, longOffset,
noOffset, bgColors[state], edgeColor);
}
markState(canvas, irect, state);
break;
}
case WebThemeEngine::PartCheckbox:
if (extraParams->button.indeterminate) {
nestedBoxes(canvas, irect,
checkIndent, halfHeight,
checkIndent, halfHeight,
bgColors[state], edgeColor);
} else if (extraParams->button.checked) {
irect = validate(irect, part);
nestedBoxes(canvas, irect,
checkIndent, checkIndent,
checkIndent, checkIndent,
bgColors[state], edgeColor);
} else {
irect = validate(irect, part);
box(canvas, irect, bgColors[state]);
}
break;
case WebThemeEngine::PartRadio:
irect = validate(irect, part);
halfHeight = irect.height() / 2;
if (extraParams->button.checked) {
circle(canvas, irect, SkIntToScalar(halfHeight), bgColors[state]);
circle(canvas, irect, SkIntToScalar(halfHeight - checkIndent), edgeColor);
} else {
circle(canvas, irect, SkIntToScalar(halfHeight), bgColors[state]);
}
break;
case WebThemeEngine::PartButton:
roundRect(canvas, irect, bgColors[state]);
markState(canvas, irect, state);
break;
case WebThemeEngine::PartTextField:
paint.setColor(extraParams->textField.backgroundColor);
paint.setStyle(SkPaint::kFill_Style);
canvas->drawIRect(irect, paint);
paint.setColor(edgeColor);
paint.setStyle(SkPaint::kStroke_Style);
canvas->drawIRect(irect, paint);
markState(canvas, irect, state);
break;
case WebThemeEngine::PartMenuList:
if (extraParams->menuList.fillContentArea) {
box(canvas, irect, extraParams->menuList.backgroundColor);
} else {
SkPaint paint;
paint.setColor(edgeColor);
paint.setStyle(SkPaint::kStroke_Style);
canvas->drawIRect(irect, paint);
}
// clip the drop-down arrow to be inside the select box
if (extraParams->menuList.arrowX - 4 > irect.fLeft)
irect.fLeft = extraParams->menuList.arrowX - 4;
if (extraParams->menuList.arrowX + 12 < irect.fRight)
irect.fRight = extraParams->menuList.arrowX + 12;
irect.fTop = extraParams->menuList.arrowY - (extraParams->menuList.arrowHeight) / 2;
irect.fBottom = extraParams->menuList.arrowY + (extraParams->menuList.arrowHeight - 1) / 2;
halfWidth = irect.width() / 2;
quarterWidth = irect.width() / 4;
if (state == WebThemeEngine::StateFocused) // FIXME: draw differenty?
state = WebThemeEngine::StateNormal;
box(canvas, irect, bgColors[state]);
triangle(canvas,
irect.fLeft + quarterWidth, irect.fTop,
irect.fRight - quarterWidth, irect.fTop,
irect.fLeft + halfWidth, irect.fBottom,
edgeColor);
break;
case WebThemeEngine::PartSliderTrack: {
SkIRect lirect = irect;
// Draw a narrow rect for the track plus box hatches on the ends.
if (state == WebThemeEngine::StateFocused) // FIXME: draw differently?
state = WebThemeEngine::StateNormal;
if (extraParams->slider.vertical) {
lirect.inset(halfWidth - sliderIndent, noOffset);
box(canvas, lirect, bgColors[state]);
line(canvas, left, top, right, top, edgeColor);
line(canvas, left, bottom, right, bottom, edgeColor);
} else {
lirect.inset(noOffset, halfHeight - sliderIndent);
box(canvas, lirect, bgColors[state]);
line(canvas, left, top, left, bottom, edgeColor);
line(canvas, right, top, right, bottom, edgeColor);
}
break;
}
case WebThemeEngine::PartSliderThumb:
if (state == WebThemeEngine::StateFocused) // FIXME: draw differently?
state = WebThemeEngine::StateNormal;
oval(canvas, irect, bgColors[state]);
break;
case WebThemeEngine::PartInnerSpinButton: {
// stack half-height up and down arrows on top of each other
SkIRect lirect;
int halfHeight = rect.height / 2;
if (extraParams->innerSpin.readOnly)
state = blink::WebThemeEngine::StateDisabled;
lirect.set(rect.x, rect.y, rect.x + rect.width - 1, rect.y + halfHeight - 1);
box(canvas, lirect, bgColors[state]);
bottom = lirect.fBottom;
quarterHeight = lirect.height() / 4;
triangle(canvas,
left + quarterWidth, bottom - quarterHeight,
right - quarterWidth, bottom - quarterHeight,
left + halfWidth, top + quarterHeight,
edgeColor);
lirect.set(rect.x, rect.y + halfHeight, rect.x + rect.width - 1,
rect.y + 2 * halfHeight - 1);
top = lirect.fTop;
bottom = lirect.fBottom;
quarterHeight = lirect.height() / 4;
box(canvas, lirect, bgColors[state]);
triangle(canvas,
left + quarterWidth, top + quarterHeight,
right - quarterWidth, top + quarterHeight,
left + halfWidth, bottom - quarterHeight,
edgeColor);
markState(canvas, irect, state);
break;
}
case WebThemeEngine::PartProgressBar: {
paint.setColor(bgColors[state]);
paint.setStyle(SkPaint::kFill_Style);
canvas->drawIRect(irect, paint);
// Emulate clipping
SkIRect tofill = irect;
if (extraParams->progressBar.determinate) {
tofill.set(extraParams->progressBar.valueRectX,
extraParams->progressBar.valueRectY,
extraParams->progressBar.valueRectX +
extraParams->progressBar.valueRectWidth - 1,
extraParams->progressBar.valueRectY +
extraParams->progressBar.valueRectHeight);
}
tofill.intersect(irect, tofill);
paint.setColor(edgeColor);
paint.setStyle(SkPaint::kFill_Style);
canvas->drawIRect(tofill, paint);
markState(canvas, irect, state);
break;
}
default:
// FIXME: Should we do something here to indicate that we got an invalid part?
// Unfortunately, we can't assert because we don't have access to WTF or base.
break;
}
}
} // namespace WebTestRunner
void NativeTabbedPaneWin::CreateNativeControl()
{
// Create the tab control.
//
// Note that we don't follow the common convention for NativeControl
// subclasses and we don't pass the value returned from
// NativeControl::GetAdditionalExStyle() as the dwExStyle parameter. Here is
// why: on RTL locales, if we pass NativeControl::GetAdditionalExStyle() when
// we basically tell Windows to create our HWND with the WS_EX_LAYOUTRTL. If
// we do that, then the HWND we create for |content_window_| below will
// inherit the WS_EX_LAYOUTRTL property and this will result in the contents
// being flipped, which is not what we want (because we handle mirroring in
// views without the use of Windows' support for mirroring). Therefore,
// we initially create our HWND without WS_EX_LAYOUTRTL and we explicitly set
// this property our child is created. This way, on RTL locales, our tabs
// will be nicely rendered from right to left (by virtue of Windows doing the
// right thing with the TabbedPane HWND) and each tab contents will use an
// RTL layout correctly (by virtue of the mirroring infrastructure in views
// doing the right thing with each View we put in the tab).
DWORD style = WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE | WS_CLIPCHILDREN;
HWND tab_control = ::CreateWindowEx(0,
WC_TABCONTROL,
L"",
style,
0, 0, width(), height(),
GetWidget()->GetNativeView(), NULL, NULL,
NULL);
ui::CheckWindowCreated(tab_control);
HFONT font = ui::ResourceBundle::GetSharedInstance().
GetFont(ui::ResourceBundle::BaseFont).GetNativeFont();
SendMessage(tab_control, WM_SETFONT, reinterpret_cast<WPARAM>(font), FALSE);
// Create the view container which is a child of the TabControl.
content_window_ = new Widget;
Widget::InitParams params(Widget::InitParams::TYPE_CONTROL);
params.parent = tab_control;
content_window_->Init(params);
// Explicitly setting the WS_EX_LAYOUTRTL property for the HWND (see above
// for why we waited until |content_window_| is created before we set this
// property for the tabbed pane's HWND).
if(base::i18n::IsRTL())
{
ui::HWNDSetRTLLayout(tab_control);
}
View* root_view = content_window_->GetRootView();
tab_layout_manager_ = new TabLayout();
root_view->SetLayoutManager(tab_layout_manager_);
DWORD sys_color = ::GetSysColor(COLOR_3DHILIGHT);
SkColor color = SkColorSetRGB(GetRValue(sys_color), GetGValue(sys_color),
GetBValue(sys_color));
root_view->set_background(Background::CreateSolidBackground(color));
content_window_->SetFocusTraversableParentView(this);
NativeControlCreated(tab_control);
// Add tabs that are already added if any.
if(!tab_views_.empty())
{
InitializeTabs();
if(selected_index_ >= 0)
{
DoSelectTabAt(selected_index_, false);
}
}
ResizeContents();
}
bool RenderThemeChromiumSkia::paintMediaSliderTrack(RenderObject* object, const RenderObject::PaintInfo& paintInfo, const IntRect& rect)
{
#if ENABLE(VIDEO)
HTMLMediaElement* mediaElement = mediaElementParent(object->node());
if (!mediaElement)
return false;
SkCanvas* canvas = paintInfo.context->platformContext()->canvas();
SkRect backgroundRect;
backgroundRect.set(rect.x(), rect.y(), rect.x() + rect.width(), rect.y() + rect.height());
SkPaint paint;
paint.setAntiAlias(true);
// Draw the border of the time bar. The border only has one single color,
// width and radius. So use the property of the left border.
SkColor borderColor = object->style()->borderLeftColor().rgb();
int borderWidth = object->style()->borderLeftWidth();
IntSize borderRadius = object->style()->borderTopLeftRadius();
paint.setStyle(SkPaint::kStroke_Style);
paint.setStrokeWidth(borderWidth);
paint.setColor(borderColor);
canvas->drawRoundRect(backgroundRect, borderRadius.width(), borderRadius.height(), paint);
// Draw the background of the time bar.
SkColor backgroundColor = object->style()->backgroundColor().rgb();
paint.setStyle(SkPaint::kFill_Style);
paint.setColor(backgroundColor);
canvas->drawRoundRect(backgroundRect, borderRadius.width(), borderRadius.height(), paint);
if (backgroundRect.width() >= 3 && backgroundRect.height() >= 3)
{
// Draw the buffered ranges.
// FIXME: Draw multiple ranges if there are multiple buffered ranges.
SkRect bufferedRect;
bufferedRect.set(backgroundRect.fLeft + 2, backgroundRect.fTop + 2,
backgroundRect.fRight - 1, backgroundRect.fBottom - 1);
int width = static_cast<int>(bufferedRect.width() * mediaElement->percentLoaded());
bufferedRect.fRight = bufferedRect.fLeft + width;
SkPoint points[2] = { { 0, bufferedRect.fTop }, { 0, bufferedRect.fBottom } };
SkColor startColor = object->style()->color().rgb();
SkColor endColor = SkColorSetRGB(SkColorGetR(startColor) / 2,
SkColorGetG(startColor) / 2,
SkColorGetB(startColor) / 2);
SkColor colors[2] = { startColor, endColor };
SkShader* gradient = SkGradientShader::CreateLinear(points, colors, 0,
sizeof(points) / sizeof(points[0]),
SkShader::kMirror_TileMode, 0);
paint.reset();
paint.setShader(gradient);
paint.setAntiAlias(true);
// Check for round rect with zero width or height, otherwise Skia will assert
if (bufferedRect.width() > 0 && bufferedRect.height() > 0)
canvas->drawRoundRect(bufferedRect, borderRadius.width(), borderRadius.height(), paint);
gradient->unref();
}
return true;
#else
UNUSED_PARAM(object);
UNUSED_PARAM(paintInfo);
UNUSED_PARAM(rect);
return false;
#endif
}
