| // Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file |
| // for details. All rights reserved. Use of this source code is governed by a |
| // BSD-style license that can be found in the LICENSE file. |
| |
| #include "embedders/openglui/common/canvas_state.h" |
| |
| #include <ctype.h> |
| #include <string.h> |
| |
| #include "embedders/openglui/common/support.h" |
| |
| // Float parser. Does not handle exponents. This is |
| // used to parse font sizes so it doesn't need to be full-blown. |
| float ParseFloat(const char* s, int& pos) { |
| int len = strlen(s); |
| float rtn = 0.0; |
| while (pos < len && s[pos] != '.' && !isdigit(s[pos])) { |
| ++pos; |
| } |
| while (pos < len && isdigit(s[pos])) { |
| rtn = rtn * 10.0 + s[pos] - '0'; |
| ++pos; |
| } |
| if (pos < len && s[pos] == '.') { |
| pos++; |
| float div = 1.0; |
| while (pos < len && isdigit(s[pos])) { |
| rtn = rtn * 10.0 + s[pos] - '0'; |
| ++pos; |
| div *= 10.0; |
| } |
| rtn /= div; |
| } |
| return rtn; |
| } |
| |
| int ParseInt(const char* s, int& pos) { |
| int len = strlen(s); |
| int rtn = 0; |
| while (pos < len && !isdigit(s[pos])) { |
| ++pos; |
| } |
| while (pos < len && isdigit(s[pos])) { |
| rtn = rtn * 10 + s[pos] - '0'; |
| ++pos; |
| } |
| return rtn; |
| } |
| |
| void CanvasState::setLineCap(const char* lc) { |
| if (strcmp(lc, "round") == 0) { |
| paint_.setStrokeCap(SkPaint::kRound_Cap); |
| } else if (strcmp(lc, "square") == 0) { |
| paint_.setStrokeCap(SkPaint::kSquare_Cap); |
| } else { |
| paint_.setStrokeCap(SkPaint::kButt_Cap); |
| } |
| } |
| |
| void CanvasState::setLineJoin(const char* lj) { |
| if (strcmp(lj, "round") == 0) { |
| paint_.setStrokeJoin(SkPaint::kRound_Join); |
| } else if (strcmp(lj, "bevel") == 0) { |
| paint_.setStrokeJoin(SkPaint::kBevel_Join); |
| } else { |
| paint_.setStrokeJoin(SkPaint::kMiter_Join); |
| } |
| } |
| |
| const char* CanvasState::setFont(const char*name, float size) { |
| // Font names have the form "<modifier> <size> <family>". |
| // Modifiers are "normal", "italic", "bold". |
| // Sizes have magnitude and units; e.g. "10pt", "20px". |
| const char* rtn = name; |
| if (size < 0) { |
| int pos = 0; |
| // TODO(gram): need to handle these modifiers. |
| if (strncmp(name, "normal", 6) == 0) { |
| pos = 6; |
| } else if (strncmp(name, "italic", 6) == 0) { |
| pos = 6; |
| } else if (strncmp(name, "bold", 4) == 0) { |
| pos = 4; |
| } |
| size = ParseFloat(name, pos); |
| // Font size units: px, etc. For now just px. |
| // TODO(gram): Handle other units. |
| if (strncmp(name + pos, "px", 2) == 0) { |
| pos += 2; |
| } |
| int len = strlen(name); |
| while (pos < len && isspace(name[pos])) { |
| ++pos; |
| } |
| name = name + pos; |
| } |
| SkTypeface *pTypeface = SkTypeface::CreateFromName(name, SkTypeface::kNormal); |
| paint_.setTypeface(pTypeface); |
| paint_.setTextSize(size); |
| pTypeface->unref(); |
| // TODO(gram): Must return a normalized font name incorporating size, so |
| // callers can set the Dart canvas font name to an appropriate value. |
| // Actually this may not be necessary in which case we can change this |
| // method to return void. |
| return rtn; |
| } |
| |
| const char* CanvasState::setTextAlign(const char* align) { |
| // TODO(gram): What about "start" and "end"? |
| // I don't see any an analogs in Skia. |
| if (strcmp(align, "left") == 0) { |
| paint_.setTextAlign(SkPaint::kLeft_Align); |
| } else if (strcmp(align, "right") == 0) { |
| paint_.setTextAlign(SkPaint::kRight_Align); |
| } else { |
| paint_.setTextAlign(SkPaint::kCenter_Align); |
| } |
| return align; |
| } |
| |
| const char* CanvasState::setTextBaseline(const char* baseline) { |
| // TODO(gram): Does skia support this? It doesn't seem like |
| // it. Right now we don't use the textBaseline value, but we |
| // may have to implement this ourselves, by adjusting the y |
| // values passed to StrokeText/FillText using the font metrics. |
| if (strcmp(baseline, "top") == 0) { |
| } else if (strcmp(baseline, "middle") == 0) { |
| } else if (strcmp(baseline, "bottom") == 0) { |
| } else if (strcmp(baseline, "hanging") == 0) { |
| } else if (strcmp(baseline, "alphabetic") == 0) { |
| } else if (strcmp(baseline, "ideographic") == 0) { |
| } |
| return baseline; |
| } |
| |
| const char* CanvasState::setTextDirection(const char* direction) { |
| // TODO(gram): Add support for this if Skia does. |
| return direction; |
| } |
| |
| void CanvasState::setGlobalCompositeOperation(const char* op) { |
| SkXfermode::Mode mode; |
| if (strcmp(op, "source-atop") == 0) { |
| mode = SkXfermode::kSrcATop_Mode; |
| } else if (strcmp(op, "source-in") == 0) { |
| mode = SkXfermode::kSrcIn_Mode; |
| } else if (strcmp(op, "source-out") == 0) { |
| mode = SkXfermode::kSrcOut_Mode; |
| } else if (strcmp(op, "source-over") == 0) { |
| mode = SkXfermode::kSrcOver_Mode; // Default. |
| } else if (strcmp(op, "destination-atop") == 0) { |
| mode = SkXfermode::kDstATop_Mode; |
| } else if (strcmp(op, "destination-in") == 0) { |
| mode = SkXfermode::kDstIn_Mode; |
| } else if (strcmp(op, "destination-out") == 0) { |
| mode = SkXfermode::kDstOut_Mode; |
| } else if (strcmp(op, "destination-over") == 0) { |
| mode = SkXfermode::kDstOver_Mode; |
| } else if (strcmp(op, "lighter") == 0) { |
| mode = SkXfermode::kLighten_Mode; |
| } else if (strcmp(op, "darker") == 0) { |
| mode = SkXfermode::kDarken_Mode; |
| } else if (strcmp(op, "xor") == 0) { |
| mode = SkXfermode::kXor_Mode; |
| } else if (strcmp(op, "copy") == 0) { |
| mode = SkXfermode::kSrc_Mode; |
| } |
| SkXfermode* m = SkXfermode::Create(mode); |
| // It seems we don't need unref() here. Including it causes |
| // a crash. Maybe Skia has a preallocated long-lived set of |
| // instances. |
| paint_.setXfermode(m); |
| } |
| |
| void CanvasState::Arc(float x, float y, float radius, |
| float startAngle, float endAngle, |
| bool antiClockwise) { |
| SkRect rect; |
| rect.set(x - radius, y - radius, x + radius, y + radius); |
| bool doCircle = false; |
| |
| static float twoPi = 2 * M_PI; |
| |
| float sweep = endAngle - startAngle; |
| if (sweep >= twoPi || sweep <= -twoPi) { |
| doCircle = true; |
| } |
| |
| if (!antiClockwise && endAngle <= startAngle) { |
| endAngle += 2 * M_PI; |
| } else if (antiClockwise && startAngle <= endAngle) { |
| startAngle += 2 * M_PI; |
| } |
| sweep = endAngle - startAngle; |
| |
| startAngle = fmodf(startAngle, twoPi); |
| float sa = Radians2Degrees(startAngle); |
| float ea = Radians2Degrees(sweep); |
| path_->arcTo(rect, sa, ea, false); |
| if (doCircle) { |
| SkPath tmp; |
| tmp.addOval(rect); |
| tmp.addPath(*path_); |
| path_->swap(tmp); |
| } |
| } |
| |
| int hexDigit(char c) { |
| if (c >= '0' && c <= '9') return c - '0'; |
| if (c <= 'Z') return c - 'A' + 10; |
| return c - 'a' + 10; |
| } |
| |
| // Color parser. |
| // See http://www.w3.org/TR/CSS21/syndata.html#color-units. |
| // There is also another format: hsl(240,100%,100%) (and hsla) |
| // TODO(gram): We probably eventually want to use a table rather |
| // than a big if statement. |
| ColorRGBA CanvasState::GetColor(const char* color) { |
| if (color[0] == '#') { |
| int r, g, b; |
| if (strlen(color) == 7) { |
| r = hexDigit(color[1]) * 16 + hexDigit(color[2]); |
| g = hexDigit(color[3]) * 16 + hexDigit(color[4]); |
| b = hexDigit(color[5]) * 16 + hexDigit(color[6]); |
| } else if (strlen(color) == 4) { |
| r = hexDigit(color[1]) * 16 + hexDigit(color[1]); |
| g = hexDigit(color[2]) * 16 + hexDigit(color[2]); |
| b = hexDigit(color[3]) * 16 + hexDigit(color[3]); |
| } |
| return ColorRGBA(r, g, b); |
| } else if (strcmp(color, "maroon") == 0) { |
| return ColorRGBA(0x80, 0x00, 0x00); |
| } else if (strcmp(color, "red") == 0) { |
| return ColorRGBA(0xFF, 0x00, 0x00); |
| } else if (strcmp(color, "orange") == 0) { |
| return ColorRGBA(0xFF, 0xA5, 0x00); |
| } else if (strcmp(color, "yellow") == 0) { |
| return ColorRGBA(0xFF, 0xFF, 0x00); |
| } else if (strcmp(color, "olive") == 0) { |
| return ColorRGBA(0x80, 0x80, 0x00); |
| } else if (strcmp(color, "purple") == 0) { |
| return ColorRGBA(0x80, 0x00, 0x80); |
| } else if (strcmp(color, "fuschia") == 0) { |
| return ColorRGBA(0xFF, 0x00, 0xFF); |
| } else if (strcmp(color, "white") == 0) { |
| return ColorRGBA(0xFF, 0xFF, 0xFF); |
| } else if (strcmp(color, "lime") == 0) { |
| return ColorRGBA(0x00, 0xFF, 0x00); |
| } else if (strcmp(color, "green") == 0) { |
| return ColorRGBA(0x00, 0x80, 0x00); |
| } else if (strcmp(color, "navy") == 0) { |
| return ColorRGBA(0x00, 0x00, 0x80); |
| } else if (strcmp(color, "blue") == 0) { |
| return ColorRGBA(0x00, 0x00, 0xFF); |
| } else if (strcmp(color, "aqua") == 0) { |
| return ColorRGBA(0x00, 0xFF, 0xFF); |
| } else if (strcmp(color, "teal") == 0) { |
| return ColorRGBA(0x00, 0x80, 0x80); |
| } else if (strcmp(color, "silver") == 0) { |
| return ColorRGBA(0xC0, 0xC0, 0xC0); |
| } else if (strcmp(color, "gray") == 0) { |
| return ColorRGBA(0x80, 0x80, 0x80); |
| } else if (strncmp(color, "rgb(", 4) == 0) { |
| int pos = 4; |
| int r = ParseInt(color, pos); |
| ++pos; |
| int g = ParseInt(color, pos); |
| ++pos; |
| int b = ParseInt(color, pos); |
| return ColorRGBA(r, g, b); |
| } else if (strncmp(color, "rgba(", 5) == 0) { |
| int pos = 5; |
| int r = ParseInt(color, pos); |
| ++pos; |
| int g = ParseInt(color, pos); |
| ++pos; |
| int b = ParseInt(color, pos); |
| ++pos; |
| float a = ParseFloat(color, pos); |
| return ColorRGBA(r, g, b, static_cast<int>(a * 255.0)); |
| } |
| // Default to black. |
| return ColorRGBA(0x00, 0x00, 0x00); |
| } |
| |
| void CanvasState::DrawImage(const SkBitmap& bm, |
| int sx, int sy, int sw, int sh, |
| int dx, int dy, int dw, int dh) { |
| if (sw < 0) sw = bm.width(); |
| if (dw < 0) dw = bm.width(); |
| if (sh < 0) sh = bm.height(); |
| if (dh < 0) dh = bm.height(); |
| SkIRect src = SkIRect::MakeXYWH(sx, sy, sw, sh); |
| SkRect dst = SkRect::MakeXYWH(dx, dy, dw, dh); |
| LOGI("DrawImage(_,%d,%d,%d,%d,%d,%d,%d,%d)", sx, sy, sw, sh, dx, dy, dw, dh); |
| canvas_->drawBitmapRect(bm, &src, dst); |
| } |
| |