2019-10-03 15:22:08 +00:00
|
|
|
/*
|
|
|
|
* Copyright 2019 Google LLC
|
|
|
|
*
|
|
|
|
* Use of this source code is governed by a BSD-style license that can be
|
|
|
|
* found in the LICENSE file.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "include/core/SkColor.h"
|
2019-10-21 14:50:26 +00:00
|
|
|
#include "include/core/SkFontStyle.h"
|
2019-10-03 15:22:08 +00:00
|
|
|
#include "include/core/SkString.h"
|
|
|
|
|
|
|
|
#include "modules/skparagraph/include/DartTypes.h"
|
|
|
|
#include "modules/skparagraph/include/Paragraph.h"
|
|
|
|
#include "modules/skparagraph/include/ParagraphBuilder.h"
|
|
|
|
#include "modules/skparagraph/include/TextStyle.h"
|
|
|
|
#include "modules/skparagraph/src/ParagraphBuilderImpl.h"
|
|
|
|
#include "modules/skparagraph/src/ParagraphImpl.h"
|
|
|
|
|
|
|
|
#include <string>
|
|
|
|
#include <vector>
|
|
|
|
|
|
|
|
#include <emscripten.h>
|
|
|
|
#include <emscripten/bind.h>
|
2020-03-24 13:08:37 +00:00
|
|
|
#include "modules/canvaskit/WasmCommon.h"
|
2019-10-03 15:22:08 +00:00
|
|
|
|
|
|
|
using namespace emscripten;
|
|
|
|
|
|
|
|
namespace para = skia::textlayout;
|
|
|
|
|
2019-10-21 14:50:26 +00:00
|
|
|
struct SimpleFontStyle {
|
|
|
|
SkFontStyle::Slant slant;
|
|
|
|
SkFontStyle::Weight weight;
|
|
|
|
SkFontStyle::Width width;
|
|
|
|
};
|
|
|
|
|
2019-10-03 15:22:08 +00:00
|
|
|
struct SimpleTextStyle {
|
2020-03-24 13:08:37 +00:00
|
|
|
SimpleColor4f backgroundColor;
|
|
|
|
SimpleColor4f color;
|
2019-10-03 15:22:08 +00:00
|
|
|
uint8_t decoration;
|
|
|
|
SkScalar decorationThickness;
|
2019-10-21 14:50:26 +00:00
|
|
|
SkScalar fontSize;
|
|
|
|
SimpleFontStyle fontStyle;
|
2020-03-24 13:08:37 +00:00
|
|
|
SimpleColor4f foregroundColor;
|
2019-10-21 14:50:26 +00:00
|
|
|
|
2019-10-03 15:22:08 +00:00
|
|
|
uintptr_t /* const char** */ fontFamilies;
|
|
|
|
int numFontFamilies;
|
|
|
|
};
|
|
|
|
|
|
|
|
para::TextStyle toTextStyle(const SimpleTextStyle& s) {
|
|
|
|
para::TextStyle ts;
|
|
|
|
|
2020-03-24 13:08:37 +00:00
|
|
|
// textstype doesn't support a 4f color
|
|
|
|
//SkColor4f({s.color.r, s.color.g, s.color.b, s.color.a}
|
|
|
|
ts.setColor(s.color.toSkColor());
|
2019-10-03 15:22:08 +00:00
|
|
|
|
2020-03-24 13:08:37 +00:00
|
|
|
// TODO(nifong): when color was a uint, these were left unset if the color was white, was that
|
|
|
|
// important?
|
|
|
|
SkPaint p1;
|
|
|
|
p1.setColor4f(s.foregroundColor.toSkColor4f());
|
|
|
|
ts.setForegroundColor(p1);
|
|
|
|
|
|
|
|
SkPaint p2;
|
|
|
|
p2.setColor4f(s.backgroundColor.toSkColor4f());
|
|
|
|
ts.setBackgroundColor(p2);
|
2019-10-03 15:22:08 +00:00
|
|
|
|
|
|
|
if (s.fontSize != 0) {
|
|
|
|
ts.setFontSize(s.fontSize);
|
|
|
|
}
|
|
|
|
|
|
|
|
ts.setDecoration(para::TextDecoration(s.decoration));
|
|
|
|
if (s.decorationThickness != 0) {
|
|
|
|
ts.setDecorationThicknessMultiplier(s.decorationThickness);
|
|
|
|
}
|
|
|
|
|
|
|
|
const char** fontFamilies = reinterpret_cast<const char**>(s.fontFamilies);
|
|
|
|
if (s.numFontFamilies > 0 && fontFamilies != nullptr) {
|
|
|
|
std::vector<SkString> ff;
|
|
|
|
for (int i = 0; i< s.numFontFamilies; i++) {
|
|
|
|
ff.emplace_back(fontFamilies[i]);
|
|
|
|
}
|
|
|
|
ts.setFontFamilies(ff);
|
|
|
|
}
|
|
|
|
|
2019-10-21 14:50:26 +00:00
|
|
|
SkFontStyle fs(s.fontStyle.weight, s.fontStyle.width, s.fontStyle.slant);
|
|
|
|
ts.setFontStyle(fs);
|
|
|
|
|
2019-10-03 15:22:08 +00:00
|
|
|
return ts;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct SimpleParagraphStyle {
|
2019-10-21 14:50:26 +00:00
|
|
|
bool disableHinting;
|
|
|
|
uintptr_t /* const char* */ ellipsisPtr;
|
|
|
|
size_t ellipsisLen;
|
2019-10-03 15:22:08 +00:00
|
|
|
SkScalar heightMultiplier;
|
|
|
|
size_t maxLines;
|
2019-10-21 14:50:26 +00:00
|
|
|
para::TextAlign textAlign;
|
|
|
|
para::TextDirection textDirection;
|
|
|
|
SimpleTextStyle textStyle;
|
2019-10-03 15:22:08 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
para::ParagraphStyle toParagraphStyle(const SimpleParagraphStyle& s) {
|
|
|
|
para::ParagraphStyle ps;
|
2019-10-21 14:50:26 +00:00
|
|
|
if (s.disableHinting) {
|
|
|
|
ps.turnHintingOff();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (s.ellipsisLen > 0) {
|
|
|
|
const char* ellipsisPtr = reinterpret_cast<const char*>(s.ellipsisPtr);
|
|
|
|
SkString eStr(ellipsisPtr, s.ellipsisLen);
|
|
|
|
ps.setEllipsis(eStr);
|
|
|
|
}
|
|
|
|
ps.setTextAlign(s.textAlign);
|
|
|
|
ps.setTextDirection(s.textDirection);
|
2019-10-03 15:22:08 +00:00
|
|
|
auto ts = toTextStyle(s.textStyle);
|
|
|
|
ps.setTextStyle(ts);
|
|
|
|
if (s.heightMultiplier != 0) {
|
|
|
|
ps.setHeight(s.heightMultiplier);
|
|
|
|
}
|
|
|
|
if (s.maxLines != 0) {
|
|
|
|
ps.setMaxLines(s.maxLines);
|
|
|
|
}
|
|
|
|
return ps;
|
|
|
|
}
|
|
|
|
|
2019-11-20 13:27:10 +00:00
|
|
|
struct SimpleTextBox {
|
|
|
|
SkRect rect;
|
|
|
|
// This isn't the most efficient way to represent this, but it is much easier to keep
|
|
|
|
// everything as floats when unpacking on the JS side.
|
|
|
|
// 0.0 = RTL, 1.0 = LTr
|
|
|
|
SkScalar direction;
|
|
|
|
};
|
|
|
|
|
2019-10-03 15:22:08 +00:00
|
|
|
Float32Array GetRectsForRange(para::ParagraphImpl& self, unsigned start, unsigned end,
|
|
|
|
para::RectHeightStyle heightStyle, para::RectWidthStyle widthStyle) {
|
|
|
|
std::vector<para::TextBox> boxes = self.getRectsForRange(start, end, heightStyle, widthStyle);
|
2019-11-20 13:27:10 +00:00
|
|
|
// Pack these text boxes into an array of n groups of 5 SkScalar (floats)
|
2019-10-03 15:22:08 +00:00
|
|
|
if (!boxes.size()) {
|
|
|
|
return emscripten::val::null();
|
|
|
|
}
|
2019-11-20 13:27:10 +00:00
|
|
|
SimpleTextBox* rects = new SimpleTextBox[boxes.size()];
|
2019-10-03 15:22:08 +00:00
|
|
|
for (int i = 0; i< boxes.size(); i++) {
|
2019-11-20 13:27:10 +00:00
|
|
|
rects[i].rect = boxes[i].rect;
|
|
|
|
if (boxes[i].direction == para::TextDirection::kRtl) {
|
|
|
|
rects[i].direction = 0;
|
|
|
|
} else {
|
|
|
|
rects[i].direction = 1;
|
|
|
|
}
|
2019-10-03 15:22:08 +00:00
|
|
|
}
|
|
|
|
float* fPtr = reinterpret_cast<float*>(rects);
|
|
|
|
// Of note: now that we have cast rects to float*, emscripten is smart enough to wrap this
|
|
|
|
// into a Float32Array for us.
|
2019-11-20 13:27:10 +00:00
|
|
|
return Float32Array(typed_memory_view(boxes.size()*5, fPtr));
|
2019-10-03 15:22:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
EMSCRIPTEN_BINDINGS(Paragraph) {
|
|
|
|
|
|
|
|
class_<para::Paragraph>("Paragraph");
|
|
|
|
|
|
|
|
// This "base<>" tells Emscripten that ParagraphImpl is a Paragraph and can get substituted
|
|
|
|
// in properly in drawParagraph. However, Emscripten will not let us bind pure virtual methods
|
2019-11-15 19:48:55 +00:00
|
|
|
// so we have to "expose" the ParagraphImpl in those cases.
|
2019-10-03 15:22:08 +00:00
|
|
|
class_<para::ParagraphImpl, base<para::Paragraph>>("ParagraphImpl")
|
2019-11-15 19:48:55 +00:00
|
|
|
.function("didExceedMaxLines", ¶::Paragraph::didExceedMaxLines)
|
|
|
|
.function("getAlphabeticBaseline", ¶::Paragraph::getAlphabeticBaseline)
|
2019-10-03 15:22:08 +00:00
|
|
|
.function("getGlyphPositionAtCoordinate", ¶::ParagraphImpl::getGlyphPositionAtCoordinate)
|
2019-11-15 19:48:55 +00:00
|
|
|
.function("getHeight", ¶::Paragraph::getHeight)
|
|
|
|
.function("getIdeographicBaseline", ¶::Paragraph::getIdeographicBaseline)
|
|
|
|
.function("getLongestLine", ¶::Paragraph::getLongestLine)
|
|
|
|
.function("getMaxIntrinsicWidth", ¶::Paragraph::getMaxIntrinsicWidth)
|
|
|
|
.function("getMaxWidth", ¶::Paragraph::getMaxWidth)
|
|
|
|
.function("getMinIntrinsicWidth", ¶::Paragraph::getMinIntrinsicWidth)
|
|
|
|
.function("_getRectsForRange", &GetRectsForRange)
|
|
|
|
.function("getWordBoundary", ¶::ParagraphImpl::getWordBoundary)
|
2019-10-03 15:22:08 +00:00
|
|
|
.function("layout", ¶::ParagraphImpl::layout);
|
|
|
|
|
|
|
|
class_<para::ParagraphBuilderImpl>("ParagraphBuilder")
|
|
|
|
.class_function("Make", optional_override([](SimpleParagraphStyle style,
|
|
|
|
sk_sp<SkFontMgr> fontMgr)-> para::ParagraphBuilderImpl {
|
|
|
|
auto fc = sk_make_sp<para::FontCollection>();
|
|
|
|
fc->setDefaultFontManager(fontMgr);
|
|
|
|
auto ps = toParagraphStyle(style);
|
|
|
|
para::ParagraphBuilderImpl pbi(ps, fc);
|
|
|
|
return pbi;
|
|
|
|
}), allow_raw_pointers())
|
|
|
|
.function("addText", optional_override([](para::ParagraphBuilderImpl& self, std::string text) {
|
|
|
|
return self.addText(text.c_str(), text.length());
|
|
|
|
}))
|
|
|
|
.function("build", ¶::ParagraphBuilderImpl::Build, allow_raw_pointers())
|
|
|
|
.function("pop", ¶::ParagraphBuilderImpl::pop)
|
|
|
|
.function("pushStyle", optional_override([](para::ParagraphBuilderImpl& self,
|
|
|
|
SimpleTextStyle textStyle) {
|
|
|
|
auto ts = toTextStyle(textStyle);
|
|
|
|
self.pushStyle(ts);
|
|
|
|
}));
|
|
|
|
|
|
|
|
|
|
|
|
enum_<para::Affinity>("Affinity")
|
|
|
|
.value("Upstream", para::Affinity::kUpstream)
|
|
|
|
.value("Downstream", para::Affinity::kDownstream);
|
|
|
|
|
2019-10-21 14:50:26 +00:00
|
|
|
enum_<SkFontStyle::Slant>("FontSlant")
|
|
|
|
.value("Upright", SkFontStyle::Slant::kUpright_Slant)
|
|
|
|
.value("Italic", SkFontStyle::Slant::kItalic_Slant)
|
|
|
|
.value("Oblique", SkFontStyle::Slant::kOblique_Slant);
|
|
|
|
|
|
|
|
enum_<SkFontStyle::Weight>("FontWeight")
|
|
|
|
.value("Invisible", SkFontStyle::Weight::kInvisible_Weight)
|
|
|
|
.value("Thin", SkFontStyle::Weight::kThin_Weight)
|
|
|
|
.value("ExtraLight", SkFontStyle::Weight::kExtraLight_Weight)
|
|
|
|
.value("Light", SkFontStyle::Weight::kLight_Weight)
|
|
|
|
.value("Normal", SkFontStyle::Weight::kNormal_Weight)
|
|
|
|
.value("Medium", SkFontStyle::Weight::kMedium_Weight)
|
|
|
|
.value("SemiBold", SkFontStyle::Weight::kSemiBold_Weight)
|
|
|
|
.value("Bold", SkFontStyle::Weight::kBold_Weight)
|
|
|
|
.value("ExtraBold", SkFontStyle::Weight::kExtraBold_Weight)
|
|
|
|
.value("Black" , SkFontStyle::Weight::kBlack_Weight)
|
|
|
|
.value("ExtraBlack", SkFontStyle::Weight::kExtraBlack_Weight);
|
|
|
|
|
|
|
|
enum_<SkFontStyle::Width>("FontWidth")
|
|
|
|
.value("UltraCondensed", SkFontStyle::Width::kUltraCondensed_Width)
|
|
|
|
.value("ExtraCondensed", SkFontStyle::Width::kExtraCondensed_Width)
|
|
|
|
.value("Condensed", SkFontStyle::Width::kCondensed_Width)
|
|
|
|
.value("SemiCondensed", SkFontStyle::Width::kSemiCondensed_Width)
|
|
|
|
.value("Normal", SkFontStyle::Width::kNormal_Width)
|
|
|
|
.value("SemiExpanded", SkFontStyle::Width::kSemiExpanded_Width)
|
|
|
|
.value("Expanded", SkFontStyle::Width::kExpanded_Width)
|
|
|
|
.value("ExtraExpanded", SkFontStyle::Width::kExtraExpanded_Width)
|
|
|
|
.value("UltraExpanded", SkFontStyle::Width::kUltraExpanded_Width);
|
|
|
|
|
2019-10-03 15:22:08 +00:00
|
|
|
enum_<para::RectHeightStyle>("RectHeightStyle")
|
2019-11-20 13:27:10 +00:00
|
|
|
.value("Tight", para::RectHeightStyle::kTight)
|
|
|
|
.value("Max", para::RectHeightStyle::kMax)
|
|
|
|
.value("IncludeLineSpacingMiddle", para::RectHeightStyle::kIncludeLineSpacingMiddle)
|
|
|
|
.value("IncludeLineSpacingTop", para::RectHeightStyle::kIncludeLineSpacingTop)
|
|
|
|
.value("IncludeLineSpacingBottom", para::RectHeightStyle::kIncludeLineSpacingBottom);
|
2019-10-03 15:22:08 +00:00
|
|
|
|
|
|
|
enum_<para::RectWidthStyle>("RectWidthStyle")
|
|
|
|
.value("Tight", para::RectWidthStyle::kTight)
|
|
|
|
.value("Max", para::RectWidthStyle::kMax);
|
|
|
|
|
|
|
|
enum_<para::TextAlign>("TextAlign")
|
|
|
|
.value("Left", para::TextAlign::kLeft)
|
|
|
|
.value("Right", para::TextAlign::kRight)
|
|
|
|
.value("Center", para::TextAlign::kCenter)
|
|
|
|
.value("Justify", para::TextAlign::kJustify)
|
|
|
|
.value("Start", para::TextAlign::kStart)
|
|
|
|
.value("End", para::TextAlign::kEnd);
|
|
|
|
|
2019-10-21 14:50:26 +00:00
|
|
|
enum_<para::TextDirection>("TextDirection")
|
|
|
|
.value("LTR", para::TextDirection::kLtr)
|
|
|
|
.value("RTL", para::TextDirection::kRtl);
|
|
|
|
|
2019-10-03 15:22:08 +00:00
|
|
|
|
|
|
|
value_object<para::PositionWithAffinity>("PositionWithAffinity")
|
|
|
|
.field("pos", ¶::PositionWithAffinity::position)
|
|
|
|
.field("affinity", ¶::PositionWithAffinity::affinity);
|
|
|
|
|
2019-11-15 19:48:55 +00:00
|
|
|
value_object<SimpleFontStyle>("FontStyle")
|
2019-10-21 14:50:26 +00:00
|
|
|
.field("slant", &SimpleFontStyle::slant)
|
|
|
|
.field("weight", &SimpleFontStyle::weight)
|
|
|
|
.field("width", &SimpleFontStyle::width);
|
|
|
|
|
2019-10-03 15:22:08 +00:00
|
|
|
value_object<SimpleParagraphStyle>("ParagraphStyle")
|
2019-10-21 14:50:26 +00:00
|
|
|
.field("disableHinting", &SimpleParagraphStyle::disableHinting)
|
|
|
|
.field("_ellipsisPtr", &SimpleParagraphStyle::ellipsisPtr)
|
|
|
|
.field("_ellipsisLen", &SimpleParagraphStyle::ellipsisLen)
|
2019-10-03 15:22:08 +00:00
|
|
|
.field("heightMultiplier", &SimpleParagraphStyle::heightMultiplier)
|
|
|
|
.field("maxLines", &SimpleParagraphStyle::maxLines)
|
|
|
|
.field("textAlign", &SimpleParagraphStyle::textAlign)
|
2019-10-21 14:50:26 +00:00
|
|
|
.field("textDirection", &SimpleParagraphStyle::textDirection)
|
2019-10-03 15:22:08 +00:00
|
|
|
.field("textStyle", &SimpleParagraphStyle::textStyle);
|
|
|
|
|
|
|
|
value_object<SimpleTextStyle>("TextStyle")
|
|
|
|
.field("backgroundColor", &SimpleTextStyle::backgroundColor)
|
|
|
|
.field("color", &SimpleTextStyle::color)
|
|
|
|
.field("decoration", &SimpleTextStyle::decoration)
|
|
|
|
.field("decorationThickness", &SimpleTextStyle::decorationThickness)
|
|
|
|
.field("_fontFamilies", &SimpleTextStyle::fontFamilies)
|
|
|
|
.field("fontSize", &SimpleTextStyle::fontSize)
|
2019-10-21 14:50:26 +00:00
|
|
|
.field("fontStyle", &SimpleTextStyle::fontStyle)
|
2019-10-03 15:22:08 +00:00
|
|
|
.field("foregroundColor", &SimpleTextStyle::foregroundColor)
|
|
|
|
.field("_numFontFamilies", &SimpleTextStyle::numFontFamilies);
|
|
|
|
|
2019-11-15 19:48:55 +00:00
|
|
|
// The U stands for unsigned - we can't bind a generic/template object, so we have to specify it
|
|
|
|
// with the type we are using.
|
|
|
|
value_object<para::SkRange<size_t>>("URange")
|
|
|
|
.field("start", ¶::SkRange<size_t>::start)
|
|
|
|
.field("end", ¶::SkRange<size_t>::end);
|
|
|
|
|
2019-10-03 15:22:08 +00:00
|
|
|
// TextDecoration should be a const because they can be combined
|
|
|
|
constant("NoDecoration", int(para::TextDecoration::kNoDecoration));
|
|
|
|
constant("UnderlineDecoration", int(para::TextDecoration::kUnderline));
|
|
|
|
constant("OverlineDecoration", int(para::TextDecoration::kOverline));
|
|
|
|
constant("LineThroughDecoration", int(para::TextDecoration::kLineThrough));
|
|
|
|
}
|