static jboolean clipRect_IIII(JNIEnv* env, jobject jcanvas, jint left,
jint top, jint right, jint bottom) {
NPE_CHECK_RETURN_ZERO(env, jcanvas);
SkRect r;
r.set(SkIntToScalar(left), SkIntToScalar(top),
SkIntToScalar(right), SkIntToScalar(bottom));
return GraphicsJNI::getNativeCanvas(env, jcanvas)->clipRect(r);
}
static jfloat measureText_StringII(JNIEnv* env, jobject jpaint, jstring text, int start, int end) {
NPE_CHECK_RETURN_ZERO(env, jpaint);
NPE_CHECK_RETURN_ZERO(env, text);
SkPaint* paint = GraphicsJNI::getNativePaint(env, jpaint);
const jchar* textArray = env->GetStringChars(text, NULL);
size_t textLength = env->GetStringLength(text);
int count = end - start;
if ((start | count) < 0 || (size_t)count > textLength) {
doThrow(env, "java/lang/IndexOutOfBoundsException");
return 0;
}
jfloat width = SkScalarToFloat(paint->measureText(textArray + start, count << 1));
env->ReleaseStringChars(text, textArray);
return width;
}
static jboolean clipRect_FFFF(JNIEnv* env, jobject jcanvas, jfloat left,
jfloat top, jfloat right, jfloat bottom) {
NPE_CHECK_RETURN_ZERO(env, jcanvas);
SkRect r;
r.set(SkFloatToScalar(left), SkFloatToScalar(top),
SkFloatToScalar(right), SkFloatToScalar(bottom));
SkCanvas* c = GraphicsJNI::getNativeCanvas(env, jcanvas);
return c->clipRect(r);
}
static jfloat measureText_CII(JNIEnv* env, jobject jpaint, jcharArray text, int index, int count) {
NPE_CHECK_RETURN_ZERO(env, jpaint);
NPE_CHECK_RETURN_ZERO(env, text);
size_t textLength = env->GetArrayLength(text);
if ((index | count) < 0 || (size_t)(index + count) > textLength) {
doThrow(env, "java/lang/ArrayIndexOutOfBoundsException");
return 0;
}
const SkPaint* paint = GraphicsJNI::getNativePaint(env, jpaint);
const jchar* textArray = env->GetCharArrayElements(text, NULL);
// we double count, since measureText wants a byteLength
SkScalar width = paint->measureText(textArray + index, count << 1);
env->ReleaseCharArrayElements(text, const_cast<jchar*>(textArray),
JNI_ABORT);
return SkScalarToFloat(width);
}
static jobject movie_decodeStream(JNIEnv* env, jobject clazz, jobject istream) {
NPE_CHECK_RETURN_ZERO(env, istream);
// what is the lifetime of the array? Can the skstream hold onto it?
jbyteArray byteArray = env->NewByteArray(16*1024);
SkStream* strm = CreateJavaInputStreamAdaptor(env, istream, byteArray);
if (NULL == strm) {
return 0;
}
SkMovie* moov = SkMovie::DecodeStream(strm);
strm->unref();
return create_jmovie(env, moov);
}
static jfloat getFontMetrics(JNIEnv* env, jobject paint, jobject metricsObj) {
NPE_CHECK_RETURN_ZERO(env, paint);
SkPaint::FontMetrics metrics;
SkScalar spacing = GraphicsJNI::getNativePaint(env, paint)->getFontMetrics(&metrics);
if (metricsObj) {
SkASSERT(env->IsInstanceOf(metricsObj, gFontMetrics_class));
env->SetFloatField(metricsObj, gFontMetrics_fieldID.top, SkScalarToFloat(metrics.fTop));
env->SetFloatField(metricsObj, gFontMetrics_fieldID.ascent, SkScalarToFloat(metrics.fAscent));
env->SetFloatField(metricsObj, gFontMetrics_fieldID.descent, SkScalarToFloat(metrics.fDescent));
env->SetFloatField(metricsObj, gFontMetrics_fieldID.bottom, SkScalarToFloat(metrics.fBottom));
env->SetFloatField(metricsObj, gFontMetrics_fieldID.leading, SkScalarToFloat(metrics.fLeading));
}
return SkScalarToFloat(spacing);
}
static jobject movie_decodeByteArray(JNIEnv* env, jobject clazz,
jbyteArray byteArray,
jint offset, jint length) {
NPE_CHECK_RETURN_ZERO(env, byteArray);
int totalLength = env->GetArrayLength(byteArray);
if ((offset | length) < 0 || offset + length > totalLength) {
doThrowAIOOBE(env);
return 0;
}
AutoJavaByteArray ar(env, byteArray);
SkMovie* moov = SkMovie::DecodeMemory(ar.ptr() + offset, length);
return create_jmovie(env, moov);
}
static jint getFontMetricsInt(JNIEnv* env, jobject paint, jobject metricsObj) {
NPE_CHECK_RETURN_ZERO(env, paint);
SkPaint::FontMetrics metrics;
GraphicsJNI::getNativePaint(env, paint)->getFontMetrics(&metrics);
int ascent = SkScalarRound(metrics.fAscent);
int descent = SkScalarRound(metrics.fDescent);
int leading = SkScalarRound(metrics.fLeading);
if (metricsObj) {
SkASSERT(env->IsInstanceOf(metricsObj, gFontMetricsInt_class));
env->SetIntField(metricsObj, gFontMetricsInt_fieldID.top, SkScalarFloor(metrics.fTop));
env->SetIntField(metricsObj, gFontMetricsInt_fieldID.ascent, ascent);
env->SetIntField(metricsObj, gFontMetricsInt_fieldID.descent, descent);
env->SetIntField(metricsObj, gFontMetricsInt_fieldID.bottom, SkScalarCeil(metrics.fBottom));
env->SetIntField(metricsObj, gFontMetricsInt_fieldID.leading, leading);
}
return descent - ascent + leading;
}
static jboolean isOpaque(JNIEnv* env, jobject jcanvas) {
NPE_CHECK_RETURN_ZERO(env, jcanvas);
SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas);
/*
Currently we cannot support transparency in GL-based canvas' at
the view level. Therefore we cannot base our answer on the device's
bitmap, but need to hard-code the answer. If we relax this
limitation in views, we can simplify the following code as well.
Use the getViewport() call to find out if we're gl-based...
*/
if (canvas->getViewport(NULL)) {
return true;
}
// normal technique, rely on the device's bitmap for the answer
return canvas->getDevice()->accessBitmap(false).isOpaque();
}
static jobject movie_gifFrameBitmap(JNIEnv* env, jobject movie, int frameIndex) {
NPE_CHECK_RETURN_ZERO(env, movie);
SkMovie* m = J2Movie(env, movie);
int averTimePoint = 0;
int frameDuration = 0;
int frameCount = m->getGifTotalFrameCount();
if (frameIndex < 0 && frameIndex >= frameCount )
return NULL;
m->setCurrFrame(frameIndex);
//then we get frameIndex Bitmap (the current frame of movie is frameIndex now)
SkBitmap *createdBitmap = m->createGifFrameBitmap();
if (createdBitmap != NULL)
{
return GraphicsJNI::createBitmap(env, createdBitmap, false, NULL);
}
else
{
return NULL;
}
}
static jobject movie_decodeStream(JNIEnv* env, jobject clazz, jobject istream) {
NPE_CHECK_RETURN_ZERO(env, istream);
jbyteArray byteArray = env->NewByteArray(16*1024);
ScopedLocalRef<jbyteArray> scoper(env, byteArray);
SkStream* strm = CreateJavaInputStreamAdaptor(env, istream, byteArray);
if (NULL == strm) {
return 0;
}
// Need to buffer enough input to be able to rewind as much as might be read by a decoder
// trying to determine the stream's format. The only decoder for movies is GIF, which
// will only read 6.
// FIXME: Get this number from SkImageDecoder
SkAutoTUnref<SkStreamRewindable> bufferedStream(SkFrontBufferedStream::Create(strm, 6));
SkASSERT(bufferedStream.get() != NULL);
SkMovie* moov = SkMovie::DecodeStream(bufferedStream);
strm->unref();
return create_jmovie(env, moov);
}
static jboolean movie_setTime(JNIEnv* env, jobject movie, jint ms) {
NPE_CHECK_RETURN_ZERO(env, movie);
return J2Movie(env, movie)->setTime(ms) ? JNI_TRUE : JNI_FALSE;
}
static int movie_duration(JNIEnv* env, jobject movie) {
NPE_CHECK_RETURN_ZERO(env, movie);
return J2Movie(env, movie)->duration();
}
static jboolean movie_isOpaque(JNIEnv* env, jobject movie) {
NPE_CHECK_RETURN_ZERO(env, movie);
return J2Movie(env, movie)->isOpaque() ? JNI_TRUE : JNI_FALSE;
}
static jint movie_duration(JNIEnv* env, jobject movie) {
NPE_CHECK_RETURN_ZERO(env, movie);
return static_cast<jint>(J2Movie(env, movie)->duration());
}
static jint getWidth(JNIEnv* env, jobject jpic) {
NPE_CHECK_RETURN_ZERO(env, jpic);
int width = GraphicsJNI::getNativePicture(env, jpic)->width();
return static_cast<jint>(width);
}
static jfloat getTextSkewX(JNIEnv* env, jobject paint) {
NPE_CHECK_RETURN_ZERO(env, paint);
return SkScalarToFloat(GraphicsJNI::getNativePaint(env, paint)->getTextSkewX());
}
static jint getFlags(JNIEnv* env, jobject paint) {
NPE_CHECK_RETURN_ZERO(env, paint);
return GraphicsJNI::getNativePaint(env, paint)->getFlags();
}
static int getSaveCount(JNIEnv* env, jobject jcanvas) {
NPE_CHECK_RETURN_ZERO(env, jcanvas);
return GraphicsJNI::getNativeCanvas(env, jcanvas)->getSaveCount();
}
static int saveAll(JNIEnv* env, jobject jcanvas) {
NPE_CHECK_RETURN_ZERO(env, jcanvas);
return GraphicsJNI::getNativeCanvas(env, jcanvas)->save();
}
static int movie_height(JNIEnv* env, jobject movie) {
NPE_CHECK_RETURN_ZERO(env, movie);
return J2Movie(env, movie)->height();
}
static int movie_width(JNIEnv* env, jobject movie) {
NPE_CHECK_RETURN_ZERO(env, movie);
return J2Movie(env, movie)->width();
}
static int save(JNIEnv* env, jobject jcanvas, SkCanvas::SaveFlags flags) {
NPE_CHECK_RETURN_ZERO(env, jcanvas);
return GraphicsJNI::getNativeCanvas(env, jcanvas)->save(flags);
}
static jboolean movie_setTime(JNIEnv* env, jobject movie, int ms) {
NPE_CHECK_RETURN_ZERO(env, movie);
return J2Movie(env, movie)->setTime(ms);
}
static int movie_gifFrameDuration(JNIEnv* env, jobject movie, int frameIndex) {
NPE_CHECK_RETURN_ZERO(env, movie);
SkMovie* m = J2Movie(env, movie);
//LOGE("Movie:movie_gifFrameDuration: frame number %d, duration is %d", frameIndex,m->getGifFrameDuration(frameIndex));
return m->getGifFrameDuration(frameIndex);
}
static int movie_gifTotalFrameCount(JNIEnv* env, jobject movie) {
NPE_CHECK_RETURN_ZERO(env, movie);
SkMovie* m = J2Movie(env, movie);
//LOGE("Movie:movie_gifTotalFrameCount: frame count %d", m->getGifTotalFrameCount());
return m->getGifTotalFrameCount();
}
static int getHeight(JNIEnv* env, jobject jcanvas) {
NPE_CHECK_RETURN_ZERO(env, jcanvas);
SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas);
return canvas->getDevice()->accessBitmap(false).height();
}
static jint movie_height(JNIEnv* env, jobject movie) {
NPE_CHECK_RETURN_ZERO(env, movie);
return static_cast<jint>(J2Movie(env, movie)->height());
}
static jint getHeight(JNIEnv* env, jobject jpic) {
NPE_CHECK_RETURN_ZERO(env, jpic);
int height = GraphicsJNI::getNativePicture(env, jpic)->height();
return static_cast<jint>(height);
}
static jfloat descent(JNIEnv* env, jobject paint) {
NPE_CHECK_RETURN_ZERO(env, paint);
SkPaint::FontMetrics metrics;
(void)GraphicsJNI::getNativePaint(env, paint)->getFontMetrics(&metrics);
return SkScalarToFloat(metrics.fDescent);
}
