wuggy/Dactyloidae
wuggy/Dactyloidae
1
0
Fork 0
mirror of https://repo.dactyloidae.xyz/Dactyloidae/UXP.git synced 2026-09-05 23:38:38 +09:00
Code Issues Projects Releases Packages Wiki Activity

Issue #1053 - Remove android-only skia-npapi

Browse source
This commit is contained in:
Matt A. Tobin 2020-02-28 17:19:05 -05:00 • committed by Roy Tam
commit 3f4ebb1c7c
6 changed files with 0 additions and 734 deletions
Download patch file Download diff file Expand all files Collapse all files

199
other-licenses/skia-npapi/ANPCanvas.cpp
View file

@ -1,199 +0,0 @@
/*
* Copyright 2008, The Android Open Source Project
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
// must include config.h first for webkit to fiddle with new/delete
#include "SkANP.h"
#include "SkRect.h"
static ANPCanvas* anp_newCanvas(const ANPBitmap* bitmap) {
SkBitmap bm;
return new ANPCanvas(*SkANP::SetBitmap(&bm, *bitmap));
}
static void anp_deleteCanvas(ANPCanvas* canvas) {
delete canvas;
}
static void anp_save(ANPCanvas* canvas) {
canvas->skcanvas->save();
}
static void anp_restore(ANPCanvas* canvas) {
canvas->skcanvas->restore();
}
static void anp_translate(ANPCanvas* canvas, float tx, float ty) {
canvas->skcanvas->translate(SkFloatToScalar(tx), SkFloatToScalar(ty));
}
static void anp_scale(ANPCanvas* canvas, float sx, float sy) {
canvas->skcanvas->scale(SkFloatToScalar(sx), SkFloatToScalar(sy));
}
static void anp_rotate(ANPCanvas* canvas, float degrees) {
canvas->skcanvas->rotate(SkFloatToScalar(degrees));
}
static void anp_skew(ANPCanvas* canvas, float kx, float ky) {
canvas->skcanvas->skew(SkFloatToScalar(kx), SkFloatToScalar(ky));
}
static void anp_clipRect(ANPCanvas* canvas, const ANPRectF* rect) {
SkRect r;
canvas->skcanvas->clipRect(*SkANP::SetRect(&r, *rect));
}
static void anp_clipPath(ANPCanvas* canvas, const ANPPath* path) {
canvas->skcanvas->clipPath(*path);
}
static void anp_concat(ANPCanvas* canvas, const ANPMatrix* matrix) {
canvas->skcanvas->concat(*matrix);
}
static void anp_getTotalMatrix(ANPCanvas* canvas, ANPMatrix* matrix) {
const SkMatrix& src = canvas->skcanvas->getTotalMatrix();
*matrix = *reinterpret_cast<const ANPMatrix*>(&src);
}
static bool anp_getLocalClipBounds(ANPCanvas* canvas, ANPRectF* r,
bool antialias) {
SkRect bounds;
if (canvas->skcanvas->getClipBounds(&bounds)) {
SkANP::SetRect(r, bounds);
return true;
}
return false;
}
static bool anp_getDeviceClipBounds(ANPCanvas* canvas, ANPRectI* r) {
SkIRect bounds;
if (canvas->skcanvas->getClipDeviceBounds(&bounds)) {
SkANP::SetRect(r, bounds);
return true;
}
return false;
}
static void anp_drawColor(ANPCanvas* canvas, ANPColor color) {
canvas->skcanvas->drawColor(color);
}
static void anp_drawPaint(ANPCanvas* canvas, const ANPPaint* paint) {
canvas->skcanvas->drawPaint(*paint);
}
static void anp_drawLine(ANPCanvas* canvas, float x0, float y0,
float x1, float y1, const ANPPaint* paint) {
canvas->skcanvas->drawLine(SkFloatToScalar(x0), SkFloatToScalar(y0),
SkFloatToScalar(x1), SkFloatToScalar(y1), *paint);
}
static void anp_drawRect(ANPCanvas* canvas, const ANPRectF* rect,
const ANPPaint* paint) {
SkRect r;
canvas->skcanvas->drawRect(*SkANP::SetRect(&r, *rect), *paint);
}
static void anp_drawOval(ANPCanvas* canvas, const ANPRectF* rect,
const ANPPaint* paint) {
SkRect r;
canvas->skcanvas->drawOval(*SkANP::SetRect(&r, *rect), *paint);
}
static void anp_drawPath(ANPCanvas* canvas, const ANPPath* path,
const ANPPaint* paint) {
canvas->skcanvas->drawPath(*path, *paint);
}
static void anp_drawText(ANPCanvas* canvas, const void* text, uint32_t length,
float x, float y, const ANPPaint* paint) {
canvas->skcanvas->drawText(text, length,
SkFloatToScalar(x), SkFloatToScalar(y),
*paint);
}
static void anp_drawPosText(ANPCanvas* canvas, const void* text,
uint32_t byteLength, const float xy[], const ANPPaint* paint) {
canvas->skcanvas->drawPosText(text, byteLength,
reinterpret_cast<const SkPoint*>(xy), *paint);
}
static void anp_drawBitmap(ANPCanvas* canvas, const ANPBitmap* bitmap,
float x, float y, const ANPPaint* paint) {
SkBitmap bm;
canvas->skcanvas->drawBitmap(*SkANP::SetBitmap(&bm, *bitmap),
SkFloatToScalar(x), SkFloatToScalar(y),
paint);
}
static void anp_drawBitmapRect(ANPCanvas* canvas, const ANPBitmap* bitmap,
const ANPRectI* src, const ANPRectF* dst,
const ANPPaint* paint) {
SkBitmap bm;
SkRect dstR;
SkIRect srcR;
if (src) {
canvas->skcanvas->drawBitmapRect(*SkANP::SetBitmap(&bm, *bitmap),
*SkANP::SetRect(&srcR, *src),
*SkANP::SetRect(&dstR, *dst),
paint);
} else {
canvas->skcanvas->drawBitmapRect(*SkANP::SetBitmap(&bm, *bitmap),
*SkANP::SetRect(&dstR, *dst),
paint);
}
}
///////////////////////////////////////////////////////////////////////////////
#define ASSIGN(obj, name) (obj)->name = anp_##name
void InitCanvasInterface(ANPCanvasInterfaceV0* i) {
ASSIGN(i, newCanvas);
ASSIGN(i, deleteCanvas);
ASSIGN(i, save);
ASSIGN(i, restore);
ASSIGN(i, translate);
ASSIGN(i, scale);
ASSIGN(i, rotate);
ASSIGN(i, skew);
ASSIGN(i, clipRect);
ASSIGN(i, clipPath);
ASSIGN(i, concat);
ASSIGN(i, getTotalMatrix);
ASSIGN(i, getLocalClipBounds);
ASSIGN(i, getDeviceClipBounds);
ASSIGN(i, drawColor);
ASSIGN(i, drawPaint);
ASSIGN(i, drawLine);
ASSIGN(i, drawRect);
ASSIGN(i, drawOval);
ASSIGN(i, drawPath);
ASSIGN(i, drawText);
ASSIGN(i, drawPosText);
ASSIGN(i, drawBitmap);
ASSIGN(i, drawBitmapRect);
}

208
other-licenses/skia-npapi/ANPPaint.cpp
View file

@ -1,208 +0,0 @@
/*
* Copyright 2008, The Android Open Source Project
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
// must include config.h first for webkit to fiddle with new/delete
#include "SkANP.h"
static ANPPaint* anp_newPaint() {
return new ANPPaint;
}
static void anp_deletePaint(ANPPaint* paint) {
delete paint;
}
static ANPPaintFlags anp_getFlags(const ANPPaint* paint) {
return paint->getFlags();
}
static void anp_setFlags(ANPPaint* paint, ANPPaintFlags flags) {
paint->setFlags(flags);
}
static ANPColor anp_getColor(const ANPPaint* paint) {
return paint->getColor();
}
static void anp_setColor(ANPPaint* paint, ANPColor color) {
paint->setColor(color);
}
static ANPPaintStyle anp_getStyle(const ANPPaint* paint) {
return paint->getStyle();
}
static void anp_setStyle(ANPPaint* paint, ANPPaintStyle style) {
paint->setStyle(static_cast<SkPaint::Style>(style));
}
static float anp_getStrokeWidth(const ANPPaint* paint) {
return SkScalarToFloat(paint->getStrokeWidth());
}
static float anp_getStrokeMiter(const ANPPaint* paint) {
return SkScalarToFloat(paint->getStrokeMiter());
}
static ANPPaintCap anp_getStrokeCap(const ANPPaint* paint) {
return paint->getStrokeCap();
}
static ANPPaintJoin anp_getStrokeJoin(const ANPPaint* paint) {
return paint->getStrokeJoin();
}
static void anp_setStrokeWidth(ANPPaint* paint, float width) {
paint->setStrokeWidth(SkFloatToScalar(width));
}
static void anp_setStrokeMiter(ANPPaint* paint, float miter) {
paint->setStrokeMiter(SkFloatToScalar(miter));
}
static void anp_setStrokeCap(ANPPaint* paint, ANPPaintCap cap) {
paint->setStrokeCap(static_cast<SkPaint::Cap>(cap));
}
static void anp_setStrokeJoin(ANPPaint* paint, ANPPaintJoin join) {
paint->setStrokeJoin(static_cast<SkPaint::Join>(join));
}
static ANPTextEncoding anp_getTextEncoding(const ANPPaint* paint) {
return paint->getTextEncoding();
}
static ANPPaintAlign anp_getTextAlign(const ANPPaint* paint) {
return paint->getTextAlign();
}
static float anp_getTextSize(const ANPPaint* paint) {
return SkScalarToFloat(paint->getTextSize());
}
static float anp_getTextScaleX(const ANPPaint* paint) {
return SkScalarToFloat(paint->getTextScaleX());
}
static float anp_getTextSkewX(const ANPPaint* paint) {
return SkScalarToFloat(paint->getTextSkewX());
}
static ANPTypeface* anp_getTypeface(const ANPPaint* paint) {
return reinterpret_cast<ANPTypeface*>(paint->getTypeface());
}
static void anp_setTextEncoding(ANPPaint* paint, ANPTextEncoding encoding) {
paint->setTextEncoding(static_cast<SkPaint::TextEncoding>(encoding));
}
static void anp_setTextAlign(ANPPaint* paint, ANPPaintAlign align) {
paint->setTextAlign(static_cast<SkPaint::Align>(align));
}
static void anp_setTextSize(ANPPaint* paint, float textSize) {
paint->setTextSize(SkFloatToScalar(textSize));
}
static void anp_setTextScaleX(ANPPaint* paint, float scaleX) {
paint->setTextScaleX(SkFloatToScalar(scaleX));
}
static void anp_setTextSkewX(ANPPaint* paint, float skewX) {
paint->setTextSkewX(SkFloatToScalar(skewX));
}
static void anp_setTypeface(ANPPaint* paint, ANPTypeface* tf) {
paint->setTypeface(sk_ref_sp(tf));
}
static float anp_measureText(ANPPaint* paint, const void* text,
uint32_t byteLength, ANPRectF* bounds) {
SkScalar w = paint->measureText(text, byteLength,
reinterpret_cast<SkRect*>(bounds));
return SkScalarToFloat(w);
}
/** Return the number of unichars specifed by the text.
If widths is not null, returns the array of advance widths for each
unichar.
If bounds is not null, returns the array of bounds for each unichar.
*/
static int anp_getTextWidths(ANPPaint* paint, const void* text,
uint32_t byteLength, float widths[], ANPRectF bounds[]) {
return paint->getTextWidths(text, byteLength, widths,
reinterpret_cast<SkRect*>(bounds));
}
static float anp_getFontMetrics(ANPPaint* paint, ANPFontMetrics* metrics) {
SkPaint::FontMetrics fm;
SkScalar spacing = paint->getFontMetrics(&fm);
if (metrics) {
metrics->fTop = SkScalarToFloat(fm.fTop);
metrics->fAscent = SkScalarToFloat(fm.fAscent);
metrics->fDescent = SkScalarToFloat(fm.fDescent);
metrics->fBottom = SkScalarToFloat(fm.fBottom);
metrics->fLeading = SkScalarToFloat(fm.fLeading);
}
return SkScalarToFloat(spacing);
}
///////////////////////////////////////////////////////////////////////////////
#define ASSIGN(obj, name) (obj)->name = anp_##name
void InitPaintInterface(ANPPaintInterfaceV0* i) {
ASSIGN(i, newPaint);
ASSIGN(i, deletePaint);
ASSIGN(i, getFlags);
ASSIGN(i, setFlags);
ASSIGN(i, getColor);
ASSIGN(i, setColor);
ASSIGN(i, getStyle);
ASSIGN(i, setStyle);
ASSIGN(i, getStrokeWidth);
ASSIGN(i, getStrokeMiter);
ASSIGN(i, getStrokeCap);
ASSIGN(i, getStrokeJoin);
ASSIGN(i, setStrokeWidth);
ASSIGN(i, setStrokeMiter);
ASSIGN(i, setStrokeCap);
ASSIGN(i, setStrokeJoin);
ASSIGN(i, getTextEncoding);
ASSIGN(i, getTextAlign);
ASSIGN(i, getTextSize);
ASSIGN(i, getTextScaleX);
ASSIGN(i, getTextSkewX);
ASSIGN(i, getTypeface);
ASSIGN(i, setTextEncoding);
ASSIGN(i, setTextAlign);
ASSIGN(i, setTextSize);
ASSIGN(i, setTextScaleX);
ASSIGN(i, setTextSkewX);
ASSIGN(i, setTypeface);
ASSIGN(i, measureText);
ASSIGN(i, getTextWidths);
ASSIGN(i, getFontMetrics);
}

110
other-licenses/skia-npapi/ANPTypeface.cpp
View file

@ -1,110 +0,0 @@
/*
* Copyright 2008, The Android Open Source Project
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
// must include config.h first for webkit to fiddle with new/delete
#include "SkANP.h"
#include "SkStream.h"
#include <stdlib.h>
static ANPTypeface* anp_createFromName(const char name[], ANPTypefaceStyle s) {
sk_sp<SkTypeface> tf = SkTypeface::MakeFromName(name,
SkFontStyle::FromOldStyle(s));
return reinterpret_cast<ANPTypeface*>(tf.release());
}
static ANPTypeface* anp_createFromTypeface(const ANPTypeface* family,
ANPTypefaceStyle s) {
sk_sp<SkTypeface> tf = SkTypeface::MakeFromTypeface(const_cast<ANPTypeface*>(family),
static_cast<SkTypeface::Style>(s));
return reinterpret_cast<ANPTypeface*>(tf.release());
}
static int32_t anp_getRefCount(const ANPTypeface* tf) {
return tf ? tf->getRefCnt() : 0;
}
static void anp_ref(ANPTypeface* tf) {
SkSafeRef(tf);
}
static void anp_unref(ANPTypeface* tf) {
SkSafeUnref(tf);
}
static ANPTypefaceStyle anp_getStyle(const ANPTypeface* tf) {
SkTypeface::Style s = tf ? tf->style() : SkTypeface::kNormal;
return static_cast<ANPTypefaceStyle>(s);
}
static int32_t anp_getFontPath(const ANPTypeface* tf, char fileName[],
int32_t length, int32_t* index) {
return 0;
/*
SkStream* stream = tf->openStream(index);
if (stream->getFileName()) {
strcpy(fileName, stream->getFileName());
} else {
return 0;
}
return strlen(fileName);
*/
}
static const char* gFontDir;
#define FONT_DIR_SUFFIX "/fonts/"
static const char* anp_getFontDirectoryPath() {
if (NULL == gFontDir) {
const char* root = getenv("ANDROID_ROOT");
size_t len = strlen(root);
char* storage = (char*)malloc(len + sizeof(FONT_DIR_SUFFIX));
if (NULL == storage) {
return NULL;
}
memcpy(storage, root, len);
memcpy(storage + len, FONT_DIR_SUFFIX, sizeof(FONT_DIR_SUFFIX));
// save this assignment for last, so that if multiple threads call us
// (which should never happen), we never return an incomplete global.
// At worst, we would allocate storage for the path twice.
gFontDir = storage;
}
return gFontDir;
}
///////////////////////////////////////////////////////////////////////////////
#define ASSIGN(obj, name) (obj)->name = anp_##name
void InitTypeFaceInterface(ANPTypefaceInterfaceV0* i) {
ASSIGN(i, createFromName);
ASSIGN(i, createFromTypeface);
ASSIGN(i, getRefCount);
ASSIGN(i, ref);
ASSIGN(i, unref);
ASSIGN(i, getStyle);
ASSIGN(i, getFontPath);
ASSIGN(i, getFontDirectoryPath);
}

107
other-licenses/skia-npapi/SkANP.cpp
View file

@ -1,107 +0,0 @@
/*
* Copyright 2008, The Android Open Source Project
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
// must include config.h first for webkit to fiddle with new/delete
#include "SkANP.h"
SkRect* SkANP::SetRect(SkRect* dst, const ANPRectF& src) {
dst->set(SkFloatToScalar(src.left),
SkFloatToScalar(src.top),
SkFloatToScalar(src.right),
SkFloatToScalar(src.bottom));
return dst;
}
SkIRect* SkANP::SetRect(SkIRect* dst, const ANPRectI& src) {
dst->set(src.left, src.top, src.right, src.bottom);
return dst;
}
ANPRectI* SkANP::SetRect(ANPRectI* dst, const SkIRect& src) {
dst->left = src.fLeft;
dst->top = src.fTop;
dst->right = src.fRight;
dst->bottom = src.fBottom;
return dst;
}
ANPRectF* SkANP::SetRect(ANPRectF* dst, const SkRect& src) {
dst->left = SkScalarToFloat(src.fLeft);
dst->top = SkScalarToFloat(src.fTop);
dst->right = SkScalarToFloat(src.fRight);
dst->bottom = SkScalarToFloat(src.fBottom);
return dst;
}
SkBitmap* SkANP::SetBitmap(SkBitmap* dst, const ANPBitmap& src) {
SkColorType colorType = kUnknown_SkColorType;
switch (src.format) {
case kRGBA_8888_ANPBitmapFormat:
// Let Skia choose the correct colour type for us based on its
// endianness. This should be correct.
colorType = kN32_SkColorType;
break;
case kRGB_565_ANPBitmapFormat:
colorType = kRGB_565_SkColorType;
break;
default:
break;
}
SkImageInfo info = SkImageInfo::Make(src.width, src.height, colorType, kPremul_SkAlphaType);
dst->setInfo(info, src.rowBytes);
dst->setPixels(src.baseAddr);
return dst;
}
bool SkANP::SetBitmap(ANPBitmap* dst, const SkBitmap& src) {
if (!(dst->baseAddr = src.getPixels())) {
SkDebugf("SkANP::SetBitmap - getPixels() returned null\n");
return false;
}
switch (src.colorType()) {
case SkColorType::kRGBA_8888_SkColorType:
dst->format = kRGBA_8888_ANPBitmapFormat;
break;
case SkColorType::kRGB_565_SkColorType:
dst->format = kRGB_565_ANPBitmapFormat;
break;
default:
SkDebugf("SkANP::SetBitmap - unsupported src.colorType %d\n", src.colorType());
return false;
}
dst->width = src.width();
dst->height = src.height();
dst->rowBytes = src.rowBytes();
return true;
}
void SkANP::InitEvent(ANPEvent* event, ANPEventType et) {
event->inSize = sizeof(ANPEvent);
event->eventType = et;
}

79
other-licenses/skia-npapi/SkANP.h
View file

@ -1,79 +0,0 @@
/*
* Copyright 2008, The Android Open Source Project
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef SkANP_DEFINED
#define SkANP_DEFINED
#include "android_npapi.h"
#include "SkCanvas.h"
#include "SkMatrix.h"
#include "SkPaint.h"
#include "SkPath.h"
#include "SkTypeface.h"
struct ANPMatrix : SkMatrix {
};
struct ANPPath : SkPath {
};
struct ANPPaint : SkPaint {
};
struct ANPTypeface : SkTypeface {
};
struct ANPCanvas {
SkCanvas* skcanvas;
// draw into the specified bitmap
explicit ANPCanvas(const SkBitmap& bm) {
skcanvas = new SkCanvas(bm);
}
// redirect all drawing to the specific SkCanvas
explicit ANPCanvas(SkCanvas* other) {
skcanvas = other;
skcanvas->ref();
}
~ANPCanvas() {
skcanvas->unref();
}
};
class SkANP {
public:
static SkRect* SetRect(SkRect* dst, const ANPRectF& src);
static SkIRect* SetRect(SkIRect* dst, const ANPRectI& src);
static ANPRectI* SetRect(ANPRectI* dst, const SkIRect& src);
static ANPRectF* SetRect(ANPRectF* dst, const SkRect& src);
static SkBitmap* SetBitmap(SkBitmap* dst, const ANPBitmap& src);
static bool SetBitmap(ANPBitmap* dst, const SkBitmap& src);
static void InitEvent(ANPEvent* event, ANPEventType et);
};
#endif

31
other-licenses/skia-npapi/moz.build
View file

@ -1,31 +0,0 @@
# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
# vim: set filetype=python:
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
EXPORTS += [
'SkANP.h',
]
UNIFIED_SOURCES += [
'ANPCanvas.cpp',
'ANPPaint.cpp',
'ANPTypeface.cpp',
'SkANP.cpp',
]
# We allow warnings for third-party code that can be updated from upstream.
ALLOW_COMPILER_WARNINGS = True
FINAL_LIBRARY = 'xul'
DEFINES['SK_BUILD_FOR_ANDROID_NDK'] = True
LOCAL_INCLUDES += [
'/dom/plugins/base',
'/dom/plugins/base/android',
'/gfx/gl',
'/gfx/skia/skia/include/config',
'/gfx/skia/skia/include/core',
]