SkString* SkObjectParser::PointsToString(const SkPoint pts[], size_t count) {
SkString* mPoints = new SkString("SkPoints pts[]: ");
for (unsigned int i = 0; i < count; i++) {
mPoints->append("(");
mPoints->appendScalar(pts[i].fX);
mPoints->append(",");
mPoints->appendScalar(pts[i].fY);
mPoints->append(")");
}
return mPoints;
}
SkString* SkObjectParser::RectToString(const SkRect& rect, const char* title) {
SkString* mRect = new SkString;
if (nullptr == title) {
mRect->append("SkRect: ");
} else {
mRect->append(title);
}
mRect->append("(");
mRect->appendScalar(rect.left());
mRect->append(", ");
mRect->appendScalar(rect.top());
mRect->append(", ");
mRect->appendScalar(rect.right());
mRect->append(", ");
mRect->appendScalar(rect.bottom());
mRect->append(")");
return mRect;
}
void SkSVGSVG::translate(SkSVGParser& parser, bool defState) {
SkScalar height, width;
SkScalar viewBox[4];
const char* hSuffix = SkParse::FindScalar(f_height.c_str(), &height);
if (strcmp(hSuffix, "pt") == 0)
height = SkScalarMulDiv(height, SK_Scalar1 * 72, SK_Scalar1 * 96);
const char* wSuffix = SkParse::FindScalar(f_width.c_str(), &width);
if (strcmp(wSuffix, "pt") == 0)
width = SkScalarMulDiv(width, SK_Scalar1 * 72, SK_Scalar1 * 96);
SkParse::FindScalars(f_viewBox.c_str(), viewBox, 4);
SkRect box;
box.fLeft = SkScalarDiv(viewBox[0], width);
box.fTop = SkScalarDiv(viewBox[1], height);
box.fRight = SkScalarDiv(viewBox[2], width);
box.fBottom = SkScalarDiv(viewBox[3], height);
if (box.fLeft == 0 && box.fTop == 0 &&
box.fRight == SK_Scalar1 && box.fBottom == SK_Scalar1)
return;
parser._startElement("matrix");
if (box.fLeft != 0) {
SkString x;
x.appendScalar(box.fLeft);
parser._addAttributeLen("translateX", x.c_str(), x.size());
}
if (box.fTop != 0) {
SkString y;
y.appendScalar(box.fTop);
parser._addAttributeLen("translateY", y.c_str(), y.size());
}
if (box.fRight != SK_Scalar1) {
SkString x;
x.appendScalar(box.fRight);
parser._addAttributeLen("scaleX", x.c_str(), x.size());
}
if (box.fBottom != SK_Scalar1) {
SkString y;
y.appendScalar(box.fBottom);
parser._addAttributeLen("scaleY", y.c_str(), y.size());
}
parser._endElement();
}
static void show_k_text(SkCanvas* canvas, SkScalar x, SkScalar y, const SkScalar k[]) {
SkPaint paint;
paint.setTextSize(SkIntToScalar(24));
paint.setAntiAlias(true);
for (int i = 0; i < 4; ++i) {
SkString str;
str.appendScalar(k[i]);
SkScalar width = paint.measureText(str.c_str(), str.size());
canvas->drawText(str.c_str(), str.size(), x, y + paint.getTextSize(), paint);
x += width + SkIntToScalar(10);
}
}
/**
* Returns PS function code that applies inverse perspective
* to a x, y point.
* The function assumes that the stack has at least two elements,
* and that the top 2 elements are numeric values.
* After executing this code on a PS stack, the last 2 elements are updated
* while the rest of the stack is preserved intact.
* inversePerspectiveMatrix is the inverse perspective matrix.
*/
static SkString apply_perspective_to_coordinates(
const SkMatrix& inversePerspectiveMatrix) {
SkString code;
if (!inversePerspectiveMatrix.hasPerspective()) {
return code;
}
// Perspective matrix should be:
// 1 0 0
// 0 1 0
// p0 p1 p2
const SkScalar p0 = inversePerspectiveMatrix[SkMatrix::kMPersp0];
const SkScalar p1 = inversePerspectiveMatrix[SkMatrix::kMPersp1];
const SkScalar p2 = inversePerspectiveMatrix[SkMatrix::kMPersp2];
// y = y / (p2 + p0 x + p1 y)
// x = x / (p2 + p0 x + p1 y)
// Input on stack: x y
code.append(" dup "); // x y y
code.appendScalar(p1); // x y y p1
code.append(" mul " // x y y*p1
" 2 index "); // x y y*p1 x
code.appendScalar(p0); // x y y p1 x p0
code.append(" mul "); // x y y*p1 x*p0
code.appendScalar(p2); // x y y p1 x*p0 p2
code.append(" add " // x y y*p1 x*p0+p2
"add " // x y y*p1+x*p0+p2
"3 1 roll " // y*p1+x*p0+p2 x y
"2 index " // z x y y*p1+x*p0+p2
"div " // y*p1+x*p0+p2 x y/(y*p1+x*p0+p2)
"3 1 roll " // y/(y*p1+x*p0+p2) y*p1+x*p0+p2 x
"exch " // y/(y*p1+x*p0+p2) x y*p1+x*p0+p2
"div " // y/(y*p1+x*p0+p2) x/(y*p1+x*p0+p2)
"exch\n"); // x/(y*p1+x*p0+p2) y/(y*p1+x*p0+p2)
return code;
}
void onDrawContent(SkCanvas* canvas) override {
fCell.set(this->height() / 2, this->height() / 2);
SkScalar trans[2];
fTrans.timeToValues(fCurrTime, trans);
for (int y = 0; y < 2; ++y) {
for (int x = 0; x < 2; ++x) {
int index = y * 2 + x;
SkAutoCanvasRestore acr(canvas, true);
canvas->translate(fCell.width() * x, fCell.height() * y);
SkRect r = SkRect::MakeWH(fCell.width(), fCell.height());
r.inset(4, 4);
canvas->clipRect(r);
this->drawHere(canvas, SkFilterQuality(index), trans[0], trans[1]);
}
}
this->drawBorders(canvas);
const SkScalar textX = fCell.width() * 2 + 30;
SkPaint paint;
paint.setAntiAlias(true);
paint.setTextSize(36);
SkString str;
str.appendScalar(fScale);
canvas->drawText(str.c_str(), str.size(), textX, 100, paint);
str.reset(); str.appendScalar(fAngle);
canvas->drawText(str.c_str(), str.size(), textX, 150, paint);
str.reset(); str.appendScalar(trans[0]);
canvas->drawText(str.c_str(), str.size(), textX, 200, paint);
str.reset(); str.appendScalar(trans[1]);
canvas->drawText(str.c_str(), str.size(), textX, 250, paint);
}
void draw(SkCanvas* canvas) {
SkMatrix m;
m.setIdentity();
m.set(SkMatrix::kMPersp0, -0.004f);
SkAutoCanvasRestore autoRestore(canvas, true);
canvas->translate(22, 144);
SkPaint black;
black.setAntiAlias(true);
black.setTextSize(24);
SkPaint gray = black;
gray.setColor(0xFF9f9f9f);
SkString string;
string.appendScalar(m.getPerspX());
canvas->drawString(string, 0, -72, gray);
canvas->concat(m);
canvas->drawString(string, 0, 0, black);
}
void onDrawContent(SkCanvas* canvas) override {
SkASSERT(fParent);
SkScalar x = fSliderRange * (*fOutput - fMin) / (fMax - fMin);
fSlider.offsetTo(SkScalarPin(x, 0.0f, fSliderRange), fSlider.fTop);
SkString valueStr;
valueStr.appendScalar(*fOutput);
this->drawLabel(canvas, valueStr);
SkPaint sliderPaint;
sliderPaint.setColor(0xFFF3F3F3);
canvas->drawRect(fSlider, sliderPaint);
SkPaint ctrlRegionPaint;
ctrlRegionPaint.setColor(0xFFFFFFFF);
ctrlRegionPaint.setStyle(SkPaint::kStroke_Style);
ctrlRegionPaint.setStrokeWidth(2.0f);
canvas->drawRect(fCtrlRegion, ctrlRegionPaint);
}
SkString* SkObjectParser::RRectToString(const SkRRect& rrect, const char* title) {
SkString* mRRect = new SkString;
if (nullptr == title) {
mRRect->append("SkRRect (");
if (rrect.isEmpty()) {
mRRect->append("empty");
} else if (rrect.isRect()) {
mRRect->append("rect");
} else if (rrect.isOval()) {
mRRect->append("oval");
} else if (rrect.isSimple()) {
mRRect->append("simple");
} else if (rrect.isNinePatch()) {
mRRect->append("nine-patch");
} else {
SkASSERT(rrect.isComplex());
mRRect->append("complex");
}
mRRect->append("): ");
} else {
mRRect->append(title);
}
mRRect->append("(");
mRRect->appendScalar(rrect.rect().left());
mRRect->append(", ");
mRRect->appendScalar(rrect.rect().top());
mRRect->append(", ");
mRRect->appendScalar(rrect.rect().right());
mRRect->append(", ");
mRRect->appendScalar(rrect.rect().bottom());
mRRect->append(") radii: (");
for (int i = 0; i < 4; ++i) {
const SkVector& radii = rrect.radii((SkRRect::Corner) i);
mRRect->appendScalar(radii.fX);
mRRect->append(", ");
mRRect->appendScalar(radii.fY);
if (i < 3) {
mRRect->append(", ");
}
}
mRRect->append(")");
return mRRect;
}
bool SkWStream::writeScalarAsText(SkScalar value)
{
SkString tmp;
tmp.appendScalar(value);
return this->write(tmp.c_str(), tmp.size());
}
void SkDebugger::getOverviewText(const SkTDArray<double>* typeTimes,
double totTime,
SkString* overview,
int numRuns) {
const SkTDArray<SkDrawCommand*>& commands = this->getDrawCommands();
SkTDArray<int> counts;
counts.setCount(LAST_DRAWTYPE_ENUM+1);
for (int i = 0; i < LAST_DRAWTYPE_ENUM+1; ++i) {
counts[i] = 0;
}
for (int i = 0; i < commands.count(); i++) {
counts[commands[i]->getType()]++;
}
overview->reset();
int total = 0;
#ifdef SK_DEBUG
double totPercent = 0, tempSum = 0;
#endif
for (int i = 0; i < LAST_DRAWTYPE_ENUM+1; ++i) {
if (0 == counts[i]) {
// if there were no commands of this type then they should've consumed no time
SkASSERT(NULL == typeTimes || 0.0 == (*typeTimes)[i]);
continue;
}
overview->append(SkDrawCommand::GetCommandString((DrawType) i));
overview->append(": ");
overview->appendS32(counts[i]);
if (NULL != typeTimes && totTime >= 0.0) {
overview->append(" - ");
overview->appendf("%.2f", (*typeTimes)[i]/(float)numRuns);
overview->append("ms");
overview->append(" - ");
double percent = 100.0*(*typeTimes)[i]/totTime;
overview->appendf("%.2f", percent);
overview->append("%");
#ifdef SK_DEBUG
totPercent += percent;
tempSum += (*typeTimes)[i];
#endif
}
overview->append("<br/>");
total += counts[i];
}
#ifdef SK_DEBUG
if (NULL != typeTimes) {
SkASSERT(SkScalarNearlyEqual(SkDoubleToScalar(totPercent),
SkDoubleToScalar(100.0)));
SkASSERT(SkScalarNearlyEqual(SkDoubleToScalar(tempSum),
SkDoubleToScalar(totTime)));
}
#endif
if (totTime > 0.0) {
overview->append("Total Time: ");
overview->appendf("%.2f", totTime/(float)numRuns);
overview->append("ms");
#ifdef SK_DEBUG
overview->append(" ");
overview->appendScalar(SkDoubleToScalar(totPercent));
overview->append("% ");
#endif
overview->append("<br/>");
}
SkString totalStr;
totalStr.append("Total Draw Commands: ");
totalStr.appendScalar(SkDoubleToScalar(total));
totalStr.append("<br/>");
overview->insert(0, totalStr);
overview->append("<br/>");
overview->append("SkPicture Width: ");
overview->appendS32(pictureWidth());
overview->append("px<br/>");
overview->append("SkPicture Height: ");
overview->appendS32(pictureHeight());
overview->append("px");
}
void SkXMLWriter::addScalarAttribute(const char name[], SkScalar value)
{
SkString tmp;
tmp.appendScalar(value);
this->addAttribute(name, tmp.c_str());
}
SkString* SkObjectParser::PathToString(const SkPath& path) {
SkString* mPath = new SkString("Path (");
static const char* gFillStrings[] = {
"Winding", "EvenOdd", "InverseWinding", "InverseEvenOdd"
};
mPath->append(gFillStrings[path.getFillType()]);
mPath->append(", ");
static const char* gConvexityStrings[] = {
"Unknown", "Convex", "Concave"
};
SkASSERT(SkPath::kConcave_Convexity == 2);
mPath->append(gConvexityStrings[path.getConvexity()]);
mPath->append(", ");
if (path.isRect(nullptr)) {
mPath->append("isRect, ");
} else {
mPath->append("isNotRect, ");
}
mPath->appendS32(path.countVerbs());
mPath->append("V, ");
mPath->appendS32(path.countPoints());
mPath->append("P): ");
static const char* gVerbStrings[] = {
"Move", "Line", "Quad", "Conic", "Cubic", "Close", "Done"
};
static const int gPtsPerVerb[] = { 1, 1, 2, 2, 3, 0, 0 };
static const int gPtOffsetPerVerb[] = { 0, 1, 1, 1, 1, 0, 0 };
SkASSERT(SkPath::kDone_Verb == 6);
SkPath::Iter iter(const_cast<SkPath&>(path), false);
SkPath::Verb verb;
SkPoint points[4];
for(verb = iter.next(points, false);
verb != SkPath::kDone_Verb;
verb = iter.next(points, false)) {
mPath->append(gVerbStrings[verb]);
mPath->append(" ");
for (int i = 0; i < gPtsPerVerb[verb]; ++i) {
mPath->append("(");
mPath->appendScalar(points[gPtOffsetPerVerb[verb]+i].fX);
mPath->append(", ");
mPath->appendScalar(points[gPtOffsetPerVerb[verb]+i].fY);
mPath->append(")");
}
if (SkPath::kConic_Verb == verb) {
mPath->append("(");
mPath->appendScalar(iter.conicWeight());
mPath->append(")");
}
mPath->append(" ");
}
SkString* boundStr = SkObjectParser::RectToString(path.getBounds(), " Bound: ");
if (boundStr) {
mPath->append(*boundStr);
delete boundStr;
}
return mPath;
}
static void TestString(skiatest::Reporter* reporter) {
SkString a;
SkString b((size_t)0);
SkString c("");
SkString d(NULL, 0);
REPORTER_ASSERT(reporter, a.isEmpty());
REPORTER_ASSERT(reporter, a == b && a == c && a == d);
a.set("hello");
b.set("hellox", 5);
c.set(a);
d.resize(5);
memcpy(d.writable_str(), "helloz", 5);
REPORTER_ASSERT(reporter, !a.isEmpty());
REPORTER_ASSERT(reporter, a.size() == 5);
REPORTER_ASSERT(reporter, a == b && a == c && a == d);
REPORTER_ASSERT(reporter, a.equals("hello", 5));
REPORTER_ASSERT(reporter, a.equals("hello"));
REPORTER_ASSERT(reporter, !a.equals("help"));
SkString e(a);
SkString f("hello");
SkString g("helloz", 5);
REPORTER_ASSERT(reporter, a == e && a == f && a == g);
b.set("world");
c = b;
REPORTER_ASSERT(reporter, a != b && a != c && b == c);
a.append(" world");
e.append("worldz", 5);
e.insert(5, " ");
f.set("world");
f.prepend("hello ");
REPORTER_ASSERT(reporter, a.equals("hello world") && a == e && a == f);
a.reset();
b.resize(0);
REPORTER_ASSERT(reporter, a.isEmpty() && b.isEmpty() && a == b);
a.set("a");
a.set("ab");
a.set("abc");
a.set("abcd");
a.set("");
a.appendS64(72036854775808LL, 0);
REPORTER_ASSERT(reporter, a.equals("72036854775808"));
a.set("");
a.appendS64(-1844674407370LL, 0);
REPORTER_ASSERT(reporter, a.equals("-1844674407370"));
a.set("");
a.appendS64(73709551616LL, 15);
REPORTER_ASSERT(reporter, a.equals("000073709551616"));
a.set("");
a.appendS64(-429496729612LL, 15);
REPORTER_ASSERT(reporter, a.equals("-000429496729612"));
static const struct {
SkScalar fValue;
const char* fString;
} gRec[] = {
{ 0, "0" },
{ SK_Scalar1, "1" },
{ -SK_Scalar1, "-1" },
{ SK_Scalar1/2, "0.5" },
#ifdef SK_SCALAR_IS_FLOAT
{ 3.4028234e38f, "3.4028235e+38" },
{ -3.4028234e38f, "-3.4028235e+38" },
#endif
};
for (size_t i = 0; i < SK_ARRAY_COUNT(gRec); i++) {
a.reset();
a.appendScalar(gRec[i].fValue);
REPORTER_ASSERT(reporter, a.size() <= SkStrAppendScalar_MaxSize);
// SkDebugf(" received <%s> expected <%s>\n", a.c_str(), gRec[i].fString);
REPORTER_ASSERT(reporter, a.equals(gRec[i].fString));
}
}
SkString* SkObjectParser::ScalarToString(SkScalar x, const char* text) {
SkString* mScalar = new SkString(text);
mScalar->append(" ");
mScalar->appendScalar(x);
return mScalar;
}
bool SkScriptRuntime::executeTokens(unsigned char* opCode) {
SkOperand2 operand[2]; // 1=accumulator and 2=operand
SkScriptEngine2::TypeOp op;
size_t ref;
int index, size;
int registerLoad;
SkScriptCallBack* callBack SK_INIT_TO_AVOID_WARNING;
do {
switch ((op = (SkScriptEngine2::TypeOp) *opCode++)) {
case SkScriptEngine2::kArrayToken: // create an array
operand[0].fArray = new SkOpArray(SkOperand2::kNoType /*fReturnType*/);
break;
case SkScriptEngine2::kArrayIndex: // array accessor
index = operand[1].fS32;
if (index >= operand[0].fArray->count()) {
fError = kArrayIndexOutOfBounds;
return false;
}
operand[0] = operand[0].fArray->begin()[index];
break;
case SkScriptEngine2::kArrayParam: // array initializer, or function param
*operand[0].fArray->append() = operand[1];
break;
case SkScriptEngine2::kCallback:
memcpy(&index, opCode, sizeof(index));
opCode += sizeof(index);
callBack = fCallBackArray[index];
break;
case SkScriptEngine2::kFunctionCall: {
memcpy(&ref, opCode, sizeof(ref));
opCode += sizeof(ref);
SkScriptCallBackFunction* callBackFunction = (SkScriptCallBackFunction*) callBack;
if (callBackFunction->invoke(ref, operand[0].fArray, /* params */
&operand[0] /* result */) == false) {
fError = kFunctionCallFailed;
return false;
}
}
break;
case SkScriptEngine2::kMemberOp: {
memcpy(&ref, opCode, sizeof(ref));
opCode += sizeof(ref);
SkScriptCallBackMember* callBackMember = (SkScriptCallBackMember*) callBack;
if (callBackMember->invoke(ref, operand[0].fObject, &operand[0]) == false) {
fError = kMemberOpFailed;
return false;
}
}
break;
case SkScriptEngine2::kPropertyOp: {
memcpy(&ref, opCode, sizeof(ref));
opCode += sizeof(ref);
SkScriptCallBackProperty* callBackProperty = (SkScriptCallBackProperty*) callBack;
if (callBackProperty->getResult(ref, &operand[0])== false) {
fError = kPropertyOpFailed;
return false;
}
}
break;
case SkScriptEngine2::kAccumulatorPop:
fRunStack.pop(&operand[0]);
break;
case SkScriptEngine2::kAccumulatorPush:
*fRunStack.push() = operand[0];
break;
case SkScriptEngine2::kIntegerAccumulator:
case SkScriptEngine2::kIntegerOperand:
registerLoad = op - SkScriptEngine2::kIntegerAccumulator;
memcpy(&operand[registerLoad].fS32, opCode, sizeof(int32_t));
opCode += sizeof(int32_t);
break;
case SkScriptEngine2::kScalarAccumulator:
case SkScriptEngine2::kScalarOperand:
registerLoad = op - SkScriptEngine2::kScalarAccumulator;
memcpy(&operand[registerLoad].fScalar, opCode, sizeof(SkScalar));
opCode += sizeof(SkScalar);
break;
case SkScriptEngine2::kStringAccumulator:
case SkScriptEngine2::kStringOperand: {
SkString* strPtr = new SkString();
track(strPtr);
registerLoad = op - SkScriptEngine2::kStringAccumulator;
memcpy(&size, opCode, sizeof(size));
opCode += sizeof(size);
strPtr->set((char*) opCode, size);
opCode += size;
operand[registerLoad].fString = strPtr;
}
break;
case SkScriptEngine2::kStringTrack: // call after kObjectToValue
track(operand[0].fString);
break;
case SkScriptEngine2::kBoxToken: {
SkOperand2::OpType type;
memcpy(&type, opCode, sizeof(type));
opCode += sizeof(type);
SkScriptCallBackConvert* callBackBox = (SkScriptCallBackConvert*) callBack;
if (callBackBox->convert(type, &operand[0]) == false)
return false;
}
break;
case SkScriptEngine2::kUnboxToken:
case SkScriptEngine2::kUnboxToken2: {
SkScriptCallBackConvert* callBackUnbox = (SkScriptCallBackConvert*) callBack;
if (callBackUnbox->convert(SkOperand2::kObject, &operand[0]) == false)
return false;
}
break;
case SkScriptEngine2::kIfOp:
case SkScriptEngine2::kLogicalAndInt:
memcpy(&size, opCode, sizeof(size));
opCode += sizeof(size);
if (operand[0].fS32 == 0)
opCode += size; // skip to else (or end of if predicate)
break;
case SkScriptEngine2::kElseOp:
memcpy(&size, opCode, sizeof(size));
opCode += sizeof(size);
opCode += size; // if true: after predicate, always skip to end of else
break;
case SkScriptEngine2::kLogicalOrInt:
memcpy(&size, opCode, sizeof(size));
opCode += sizeof(size);
if (operand[0].fS32 != 0)
opCode += size; // skip to kToBool opcode after || predicate
break;
// arithmetic conversion ops
case SkScriptEngine2::kFlipOpsOp:
SkTSwap(operand[0], operand[1]);
break;
case SkScriptEngine2::kIntToString:
case SkScriptEngine2::kIntToString2:
case SkScriptEngine2::kScalarToString:
case SkScriptEngine2::kScalarToString2: {
SkString* strPtr = new SkString();
track(strPtr);
if (op == SkScriptEngine2::kIntToString || op == SkScriptEngine2::kIntToString2)
strPtr->appendS32(operand[op - SkScriptEngine2::kIntToString].fS32);
else
strPtr->appendScalar(operand[op - SkScriptEngine2::kScalarToString].fScalar);
operand[0].fString = strPtr;
}
break;
case SkScriptEngine2::kIntToScalar:
case SkScriptEngine2::kIntToScalar2:
operand[0].fScalar = SkScriptEngine2::IntToScalar(operand[op - SkScriptEngine2::kIntToScalar].fS32);
break;
case SkScriptEngine2::kStringToInt:
if (SkParse::FindS32(operand[0].fString->c_str(), &operand[0].fS32) == NULL)
return false;
break;
case SkScriptEngine2::kStringToScalar:
case SkScriptEngine2::kStringToScalar2:
if (SkParse::FindScalar(operand[0].fString->c_str(),
&operand[op - SkScriptEngine2::kStringToScalar].fScalar) == NULL)
return false;
break;
case SkScriptEngine2::kScalarToInt:
operand[0].fS32 = SkScalarFloorToInt(operand[0].fScalar);
break;
// arithmetic ops
case SkScriptEngine2::kAddInt:
operand[0].fS32 += operand[1].fS32;
break;
case SkScriptEngine2::kAddScalar:
operand[0].fScalar += operand[1].fScalar;
break;
case SkScriptEngine2::kAddString:
// if (fTrackString.find(operand[1].fString) < 0) {
// operand[1].fString = SkNEW_ARGS(SkString, (*operand[1].fString));
// track(operand[1].fString);
// }
operand[0].fString->append(*operand[1].fString);
break;
case SkScriptEngine2::kBitAndInt:
operand[0].fS32 &= operand[1].fS32;
break;
case SkScriptEngine2::kBitNotInt:
operand[0].fS32 = ~operand[0].fS32;
break;
case SkScriptEngine2::kBitOrInt:
operand[0].fS32 |= operand[1].fS32;
break;
case SkScriptEngine2::kDivideInt:
SkASSERT(operand[1].fS32 != 0);
if (operand[1].fS32 == 0)
operand[0].fS32 = operand[0].fS32 == 0 ? SK_NaN32 :
operand[0].fS32 > 0 ? SK_MaxS32 : -SK_MaxS32;
else if (operand[1].fS32 != 0) // throw error on divide by zero?
operand[0].fS32 /= operand[1].fS32;
break;
case SkScriptEngine2::kDivideScalar:
if (operand[1].fScalar == 0)
operand[0].fScalar = operand[0].fScalar == 0 ? SK_ScalarNaN :
operand[0].fScalar > 0 ? SK_ScalarMax : -SK_ScalarMax;
else
operand[0].fScalar = SkScalarDiv(operand[0].fScalar, operand[1].fScalar);
break;
case SkScriptEngine2::kEqualInt:
operand[0].fS32 = operand[0].fS32 == operand[1].fS32;
break;
case SkScriptEngine2::kEqualScalar:
operand[0].fS32 = operand[0].fScalar == operand[1].fScalar;
break;
case SkScriptEngine2::kEqualString:
operand[0].fS32 = *operand[0].fString == *operand[1].fString;
break;
case SkScriptEngine2::kGreaterEqualInt:
operand[0].fS32 = operand[0].fS32 >= operand[1].fS32;
break;
case SkScriptEngine2::kGreaterEqualScalar:
operand[0].fS32 = operand[0].fScalar >= operand[1].fScalar;
break;
case SkScriptEngine2::kGreaterEqualString:
operand[0].fS32 = strcmp(operand[0].fString->c_str(), operand[1].fString->c_str()) >= 0;
break;
case SkScriptEngine2::kToBool:
operand[0].fS32 = !! operand[0].fS32;
break;
case SkScriptEngine2::kLogicalNotInt:
operand[0].fS32 = ! operand[0].fS32;
break;
case SkScriptEngine2::kMinusInt:
operand[0].fS32 = -operand[0].fS32;
break;
case SkScriptEngine2::kMinusScalar:
operand[0].fScalar = -operand[0].fScalar;
break;
case SkScriptEngine2::kModuloInt:
operand[0].fS32 %= operand[1].fS32;
break;
case SkScriptEngine2::kModuloScalar:
operand[0].fScalar = SkScalarMod(operand[0].fScalar, operand[1].fScalar);
break;
case SkScriptEngine2::kMultiplyInt:
operand[0].fS32 *= operand[1].fS32;
break;
case SkScriptEngine2::kMultiplyScalar:
operand[0].fScalar = SkScalarMul(operand[0].fScalar, operand[1].fScalar);
break;
case SkScriptEngine2::kShiftLeftInt:
operand[0].fS32 <<= operand[1].fS32;
break;
case SkScriptEngine2::kShiftRightInt:
operand[0].fS32 >>= operand[1].fS32;
break;
case SkScriptEngine2::kSubtractInt:
operand[0].fS32 -= operand[1].fS32;
break;
case SkScriptEngine2::kSubtractScalar:
operand[0].fScalar -= operand[1].fScalar;
break;
case SkScriptEngine2::kXorInt:
operand[0].fS32 ^= operand[1].fS32;
break;
case SkScriptEngine2::kEnd:
goto done;
case SkScriptEngine2::kNop:
SkASSERT(0);
default:
break;
}
} while (true);
done:
fRunStack.push(operand[0]);
return true;
}
static void set_scalar(SkStaticTextView* view, SkScalar value) {
SkString str;
str.appendScalar(value);
view->setText(str);
}
SkString* SkObjectParser::IntToString(int x, const char* text) {
SkString* mInt = new SkString(text);
mInt->append(" ");
mInt->appendScalar(SkIntToScalar(x));
return mInt;
}
void SkSVGPaint::setSave(SkSVGParser& parser) {
SkTDArray<SkString*> clips;
SkSVGPaint* walking = parser.fHead;
int index;
SkMatrix sum;
sum.reset();
while (walking != NULL) {
for (index = kInitial + 1; index < kTerminal; index++) {
SkString* lastAttr = (*walking)[index];
if (lastAttr->size() == 0)
continue;
if (index == kTransform) {
const char* str = lastAttr->c_str();
SkASSERT(strncmp(str, "matrix(", 7) == 0);
str += 6;
const char* strEnd = strrchr(str, ')');
SkASSERT(strEnd != NULL);
SkString mat(str, strEnd - str);
SkSVGParser::ConvertToArray(mat);
SkScalar values[6];
SkParse::FindScalars(mat.c_str() + 1, values, 6);
SkMatrix matrix;
matrix.reset();
matrix.setScaleX(values[0]);
matrix.setSkewY(values[1]);
matrix.setSkewX(values[2]);
matrix.setScaleY(values[3]);
matrix.setTranslateX(values[4]);
matrix.setTranslateY(values[5]);
sum.setConcat(matrix, sum);
continue;
}
if ( index == kClipPath)
*clips.insert(0) = lastAttr;
}
walking = walking->fNext;
}
if ((sum == parser.fLastTransform) == false) {
SkMatrix inverse;
bool success = parser.fLastTransform.invert(&inverse);
SkASSERT(success == true);
SkMatrix output;
output.setConcat(inverse, sum);
parser.fLastTransform = sum;
SkString outputStr;
outputStr.appendUnichar('[');
outputStr.appendScalar(output.getScaleX());
outputStr.appendUnichar(',');
outputStr.appendScalar(output.getSkewX());
outputStr.appendUnichar(',');
outputStr.appendScalar(output.getTranslateX());
outputStr.appendUnichar(',');
outputStr.appendScalar(output.getSkewY());
outputStr.appendUnichar(',');
outputStr.appendScalar(output.getScaleY());
outputStr.appendUnichar(',');
outputStr.appendScalar(output.getTranslateY());
outputStr.appendUnichar(',');
outputStr.appendScalar(output.getPerspX());
outputStr.appendUnichar(',');
outputStr.appendScalar(output.getPerspY());
outputStr.append(",1]");
parser._startElement("matrix");
parser._addAttributeLen("matrix", outputStr.c_str(), outputStr.size());
parser._endElement();
}
#if 0 // incomplete
if (parser.fTransformClips.size() > 0) {
// need to reset the clip when the 'g' scope is ended
parser._startElement("add");
const char* start = strchr(current->f_clipPath.c_str(), '#') + 1;
SkASSERT(start);
parser._addAttributeLen("use", start, strlen(start) - 1);
parser._endElement(); // clip
}
#endif
}
