diff options
18 files changed, 112 insertions, 77 deletions
diff --git a/core/java/android/view/RenderNode.java b/core/java/android/view/RenderNode.java index e9ec565..eee4973 100644 --- a/core/java/android/view/RenderNode.java +++ b/core/java/android/view/RenderNode.java @@ -355,9 +355,10 @@ public class RenderNode { return nSetOutlineEmpty(mNativeRenderNode); } else if (outline.mRect != null) { return nSetOutlineRoundRect(mNativeRenderNode, outline.mRect.left, outline.mRect.top, - outline.mRect.right, outline.mRect.bottom, outline.mRadius); + outline.mRect.right, outline.mRect.bottom, outline.mRadius, outline.mAlpha); } else if (outline.mPath != null) { - return nSetOutlineConvexPath(mNativeRenderNode, outline.mPath.mNativePath); + return nSetOutlineConvexPath(mNativeRenderNode, outline.mPath.mNativePath, + outline.mAlpha); } throw new IllegalArgumentException("Unrecognized outline?"); } @@ -849,8 +850,9 @@ public class RenderNode { private static native boolean nSetProjectBackwards(long renderNode, boolean shouldProject); private static native boolean nSetProjectionReceiver(long renderNode, boolean shouldRecieve); private static native boolean nSetOutlineRoundRect(long renderNode, int left, int top, - int right, int bottom, float radius); - private static native boolean nSetOutlineConvexPath(long renderNode, long nativePath); + int right, int bottom, float radius, float alpha); + private static native boolean nSetOutlineConvexPath(long renderNode, long nativePath, + float alpha); private static native boolean nSetOutlineEmpty(long renderNode); private static native boolean nSetOutlineNone(long renderNode); private static native boolean nSetClipToOutline(long renderNode, boolean clipToOutline); diff --git a/core/java/android/view/ViewOutlineProvider.java b/core/java/android/view/ViewOutlineProvider.java index 64624ae..4054031 100644 --- a/core/java/android/view/ViewOutlineProvider.java +++ b/core/java/android/view/ViewOutlineProvider.java @@ -25,7 +25,8 @@ import android.graphics.drawable.Drawable; public abstract class ViewOutlineProvider { /** * Default outline provider for Views, which queries the Outline from the View's background, - * or returns <code>false</code> if the View does not have a background. + * or generates a 0 alpha, rectangular Outline the size of the View if a background + * isn't present. * * @see Drawable#getOutline(Outline) */ @@ -35,6 +36,10 @@ public abstract class ViewOutlineProvider { Drawable background = view.getBackground(); if (background != null) { background.getOutline(outline); + } else { + + outline.setRect(0, 0, view.getWidth(), view.getHeight()); + outline.setAlpha(0.0f); } } }; diff --git a/core/java/com/android/internal/widget/ActionBarContainer.java b/core/java/com/android/internal/widget/ActionBarContainer.java index 790b611..9e24844 100644 --- a/core/java/com/android/internal/widget/ActionBarContainer.java +++ b/core/java/com/android/internal/widget/ActionBarContainer.java @@ -16,10 +16,12 @@ package com.android.internal.widget; +import android.annotation.NonNull; import android.content.Context; import android.content.res.TypedArray; import android.graphics.Canvas; import android.graphics.ColorFilter; +import android.graphics.Outline; import android.graphics.drawable.Drawable; import android.util.AttributeSet; import android.view.ActionMode; @@ -324,18 +326,36 @@ public class ActionBarContainer extends FrameLayout { * projection surfaces. */ private class ActionBarBackgroundDrawable extends Drawable { - @Override - public void draw(Canvas canvas) { + private Drawable getDrawable() { if (mIsSplit) { - if (mSplitBackground != null) mSplitBackground.draw(canvas); + if (mSplitBackground != null) { + return mSplitBackground; + } } else { if (mBackground != null) { - mBackground.draw(canvas); + return mBackground; } if (mStackedBackground != null && mIsStacked) { - mStackedBackground.draw(canvas); + return mStackedBackground; } } + return null; + } + + @Override + public void draw(Canvas canvas) { + final Drawable drawable = getDrawable(); + if (drawable != null) { + drawable.draw(canvas); + } + } + + @Override + public void getOutline(@NonNull Outline outline) { + final Drawable drawable = getDrawable(); + if (drawable != null) { + drawable.getOutline(outline); + } } @Override diff --git a/core/jni/android/graphics/BitmapFactory.cpp b/core/jni/android/graphics/BitmapFactory.cpp index a890eb4..2ce1b15 100644 --- a/core/jni/android/graphics/BitmapFactory.cpp +++ b/core/jni/android/graphics/BitmapFactory.cpp @@ -353,7 +353,7 @@ static jobject doDecode(JNIEnv* env, SkStreamRewindable* stream, jobject padding ninePatchInsets = env->NewObject(gInsetStruct_class, gInsetStruct_constructorMethodID, peeker.mOpticalInsets[0], peeker.mOpticalInsets[1], peeker.mOpticalInsets[2], peeker.mOpticalInsets[3], peeker.mOutlineInsets[0], peeker.mOutlineInsets[1], peeker.mOutlineInsets[2], peeker.mOutlineInsets[3], - peeker.mOutlineRadius, peeker.mOutlineFilled, scale); + peeker.mOutlineRadius, peeker.mOutlineAlpha, scale); if (javaBitmap != NULL) { env->SetObjectField(javaBitmap, gBitmap_ninePatchInsetsFieldID, ninePatchInsets); } @@ -589,7 +589,7 @@ int register_android_graphics_BitmapFactory(JNIEnv* env) { "Landroid/graphics/NinePatch$InsetStruct;"); gInsetStruct_class = (jclass) env->NewGlobalRef(env->FindClass("android/graphics/NinePatch$InsetStruct")); - gInsetStruct_constructorMethodID = env->GetMethodID(gInsetStruct_class, "<init>", "(IIIIIIIIFZF)V"); + gInsetStruct_constructorMethodID = env->GetMethodID(gInsetStruct_class, "<init>", "(IIIIIIIIFIF)V"); int ret = AndroidRuntime::registerNativeMethods(env, "android/graphics/BitmapFactory$Options", diff --git a/core/jni/android/graphics/NinePatchPeeker.cpp b/core/jni/android/graphics/NinePatchPeeker.cpp index ea5193b..1dafa1b 100644 --- a/core/jni/android/graphics/NinePatchPeeker.cpp +++ b/core/jni/android/graphics/NinePatchPeeker.cpp @@ -48,11 +48,11 @@ bool NinePatchPeeker::peek(const char tag[], const void* data, size_t length) { } else if (!strcmp("npLb", tag) && length == sizeof(int32_t) * 4) { mHasInsets = true; memcpy(&mOpticalInsets, data, sizeof(int32_t) * 4); - } else if (!strcmp("npOl", tag) && length == 24) { // 4 int32_ts, 1 float, 1 int32_t sized bool + } else if (!strcmp("npOl", tag) && length == 24) { // 4 int32_ts, 1 float, 1 int32_t sized byte mHasInsets = true; memcpy(&mOutlineInsets, data, sizeof(int32_t) * 4); mOutlineRadius = ((const float*)data)[4]; - mOutlineFilled = ((const int32_t*)data)[5] & 0x01; + mOutlineAlpha = ((const int32_t*)data)[5] & 0xff; } return true; // keep on decoding } diff --git a/core/jni/android/graphics/NinePatchPeeker.h b/core/jni/android/graphics/NinePatchPeeker.h index 8d3e6cf..7c18b2d 100644 --- a/core/jni/android/graphics/NinePatchPeeker.h +++ b/core/jni/android/graphics/NinePatchPeeker.h @@ -33,7 +33,7 @@ public: , mPatchSize(0) , mHasInsets(false) , mOutlineRadius(0) - , mOutlineFilled(false) { + , mOutlineAlpha(0) { memset(mOpticalInsets, 0, 4 * sizeof(int32_t)); memset(mOutlineInsets, 0, 4 * sizeof(int32_t)); } @@ -50,7 +50,7 @@ public: int32_t mOpticalInsets[4]; int32_t mOutlineInsets[4]; float mOutlineRadius; - bool mOutlineFilled; + uint8_t mOutlineAlpha; }; #endif // NinePatchPeeker_h diff --git a/core/jni/android_view_RenderNode.cpp b/core/jni/android_view_RenderNode.cpp index ff54fb9..1e9d722 100644 --- a/core/jni/android_view_RenderNode.cpp +++ b/core/jni/android_view_RenderNode.cpp @@ -140,18 +140,19 @@ static jboolean android_view_RenderNode_setProjectionReceiver(JNIEnv* env, static jboolean android_view_RenderNode_setOutlineRoundRect(JNIEnv* env, jobject clazz, jlong renderNodePtr, jint left, jint top, - jint right, jint bottom, jfloat radius) { + jint right, jint bottom, jfloat radius, jfloat alpha) { RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); - renderNode->mutateStagingProperties().mutableOutline().setRoundRect(left, top, right, bottom, radius); + renderNode->mutateStagingProperties().mutableOutline().setRoundRect(left, top, right, bottom, + radius, alpha); renderNode->setPropertyFieldsDirty(RenderNode::GENERIC); return true; } static jboolean android_view_RenderNode_setOutlineConvexPath(JNIEnv* env, - jobject clazz, jlong renderNodePtr, jlong outlinePathPtr) { + jobject clazz, jlong renderNodePtr, jlong outlinePathPtr, jfloat alpha) { RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); SkPath* outlinePath = reinterpret_cast<SkPath*>(outlinePathPtr); - renderNode->mutateStagingProperties().mutableOutline().setConvexPath(outlinePath); + renderNode->mutateStagingProperties().mutableOutline().setConvexPath(outlinePath, alpha); renderNode->setPropertyFieldsDirty(RenderNode::GENERIC); return true; } @@ -480,8 +481,8 @@ static JNINativeMethod gMethods[] = { { "nSetProjectBackwards", "(JZ)Z", (void*) android_view_RenderNode_setProjectBackwards }, { "nSetProjectionReceiver","(JZ)Z", (void*) android_view_RenderNode_setProjectionReceiver }, - { "nSetOutlineRoundRect", "(JIIIIF)Z", (void*) android_view_RenderNode_setOutlineRoundRect }, - { "nSetOutlineConvexPath", "(JJ)Z", (void*) android_view_RenderNode_setOutlineConvexPath }, + { "nSetOutlineRoundRect", "(JIIIIFF)Z", (void*) android_view_RenderNode_setOutlineRoundRect }, + { "nSetOutlineConvexPath", "(JJF)Z", (void*) android_view_RenderNode_setOutlineConvexPath }, { "nSetOutlineEmpty", "(J)Z", (void*) android_view_RenderNode_setOutlineEmpty }, { "nSetOutlineNone", "(J)Z", (void*) android_view_RenderNode_setOutlineNone }, { "nSetClipToOutline", "(JZ)Z", (void*) android_view_RenderNode_setClipToOutline }, diff --git a/graphics/java/android/graphics/NinePatch.java b/graphics/java/android/graphics/NinePatch.java index 335bce0..3bccf08 100644 --- a/graphics/java/android/graphics/NinePatch.java +++ b/graphics/java/android/graphics/NinePatch.java @@ -43,7 +43,7 @@ public class NinePatch { @SuppressWarnings({"UnusedDeclaration"}) // called from JNI InsetStruct(int opticalLeft, int opticalTop, int opticalRight, int opticalBottom, int outlineLeft, int outlineTop, int outlineRight, int outlineBottom, - float outlineRadius, boolean outlineFilled, float decodeScale) { + float outlineRadius, int outlineAlpha, float decodeScale) { opticalRect = new Rect(opticalLeft, opticalTop, opticalRight, opticalBottom); outlineRect = new Rect(outlineLeft, outlineTop, outlineRight, outlineBottom); @@ -55,13 +55,13 @@ public class NinePatch { outlineRect.scaleRoundIn(decodeScale); } this.outlineRadius = outlineRadius * decodeScale; - this.outlineFilled = outlineFilled; + this.outlineAlpha = outlineAlpha / 255.0f; } public final Rect opticalRect; public final Rect outlineRect; public final float outlineRadius; - public final boolean outlineFilled; + public final float outlineAlpha; } private final Bitmap mBitmap; diff --git a/graphics/java/android/graphics/Outline.java b/graphics/java/android/graphics/Outline.java index 3a4c2a7..1cf5f37 100644 --- a/graphics/java/android/graphics/Outline.java +++ b/graphics/java/android/graphics/Outline.java @@ -37,9 +37,8 @@ public final class Outline { public Rect mRect; /** @hide */ public float mRadius; - /** @hide */ - public boolean mIsFilled; + public float mAlpha; /** * Constructs an empty Outline. Call one of the setter methods to make @@ -63,7 +62,6 @@ public final class Outline { mPath = null; mRect = null; mRadius = 0; - mIsFilled = true; } /** @@ -92,24 +90,24 @@ public final class Outline { } /** - * Sets whether the outline represents a fully opaque area. + * Sets the alpha represented by the Outline. * - * A filled outline is assumed, by the drawing system, to fully cover content beneath it, - * meaning content beneath may be optimized away. + * Content producing a fully opaque (alpha = 1.0f) outline is assumed, by the drawing system, + * to fully cover content beneath it, meaning content beneath may be optimized away. * * @hide */ - public void setFilled(boolean isFilled) { - mIsFilled = isFilled; + public void setAlpha(float alpha) { + mAlpha = alpha; } /** - * Returns whether the outline represents a fully opaque area. + * Sets the alpha represented by the Outline. * * @hide */ - public boolean isFilled() { - return !isEmpty() && mIsFilled; + public float getAlpha() { + return mAlpha; } /** @@ -132,7 +130,7 @@ public final class Outline { mRect.set(src.mRect); } mRadius = src.mRadius; - mIsFilled = src.mIsFilled; + mAlpha = src.mAlpha; } /** @@ -164,7 +162,6 @@ public final class Outline { mRect.set(left, top, right, bottom); mRadius = radius; mPath = null; - mIsFilled = true; } /** @@ -193,7 +190,6 @@ public final class Outline { mPath.reset(); mPath.addOval(left, top, right, bottom, Path.Direction.CW); mRect = null; - mIsFilled = true; } /** @@ -220,6 +216,5 @@ public final class Outline { mPath.set(convexPath); mRect = null; mRadius = -1.0f; - mIsFilled = true; } } diff --git a/graphics/java/android/graphics/drawable/Drawable.java b/graphics/java/android/graphics/drawable/Drawable.java index acb34c2..df9f3c3 100644 --- a/graphics/java/android/graphics/drawable/Drawable.java +++ b/graphics/java/android/graphics/drawable/Drawable.java @@ -861,16 +861,14 @@ public abstract class Drawable { * This method is called by the default {@link android.view.ViewOutlineProvider} to define * the outline of the View. * <p> - * The default behavior defines the outline to be the bounding rectangle. Subclasses that wish - * to convey a different shape must override this method. - * - * @return true if this drawable actually has an outline, else false. The outline must be - * populated by the drawable if true is returned. + * The default behavior defines the outline to be the bounding rectangle of 0 alpha. + * Subclasses that wish to convey a different shape or alpha value must override this method. * * @see android.view.View#setOutlineProvider(android.view.ViewOutlineProvider) */ public void getOutline(@NonNull Outline outline) { outline.setRect(getBounds()); + outline.setAlpha(getAlpha() / 255.0f); } /** diff --git a/graphics/java/android/graphics/drawable/GradientDrawable.java b/graphics/java/android/graphics/drawable/GradientDrawable.java index 4815586..a383aab 100644 --- a/graphics/java/android/graphics/drawable/GradientDrawable.java +++ b/graphics/java/android/graphics/drawable/GradientDrawable.java @@ -1413,6 +1413,7 @@ public class GradientDrawable extends Drawable { public void getOutline(Outline outline) { final GradientState st = mGradientState; final Rect bounds = getBounds(); + outline.setAlpha(mAlpha / 255.0f); switch (st.mShape) { case RECTANGLE: diff --git a/graphics/java/android/graphics/drawable/LayerDrawable.java b/graphics/java/android/graphics/drawable/LayerDrawable.java index 073100a..d094ce4 100644 --- a/graphics/java/android/graphics/drawable/LayerDrawable.java +++ b/graphics/java/android/graphics/drawable/LayerDrawable.java @@ -595,12 +595,9 @@ public class LayerDrawable extends Drawable implements Drawable.Callback { } /** - * Populates <code>outline</code> with the first available layer outline. - * Returns <code>true</code> if an outline is available, <code>false</code> - * otherwise. + * Populates <code>outline</code> with the first available (non-empty) layer outline. * * @param outline Outline in which to place the first available layer outline - * @return <code>true</code> if an outline is available */ @Override public void getOutline(@NonNull Outline outline) { diff --git a/graphics/java/android/graphics/drawable/NinePatchDrawable.java b/graphics/java/android/graphics/drawable/NinePatchDrawable.java index 6afce41..3397e94 100644 --- a/graphics/java/android/graphics/drawable/NinePatchDrawable.java +++ b/graphics/java/android/graphics/drawable/NinePatchDrawable.java @@ -296,7 +296,7 @@ public class NinePatchDrawable extends Drawable { bounds.right - outlineInsets.right, bounds.bottom - outlineInsets.bottom, insets.outlineRadius); - outline.setFilled(insets.outlineFilled); + outline.setAlpha(insets.outlineAlpha * (getAlpha() / 255.0f)); return; } } diff --git a/graphics/java/android/graphics/drawable/RippleDrawable.java b/graphics/java/android/graphics/drawable/RippleDrawable.java index eb7291c..cf675ed 100644 --- a/graphics/java/android/graphics/drawable/RippleDrawable.java +++ b/graphics/java/android/graphics/drawable/RippleDrawable.java @@ -585,11 +585,9 @@ public class RippleDrawable extends LayerDrawable { /** * Populates <code>outline</code> with the first available layer outline, - * excluding the mask layer. Returns <code>true</code> if an outline is - * available, <code>false</code> otherwise. + * excluding the mask layer. * * @param outline Outline in which to place the first available layer outline - * @return <code>true</code> if an outline is available */ @Override public void getOutline(@NonNull Outline outline) { diff --git a/graphics/java/android/graphics/drawable/ShapeDrawable.java b/graphics/java/android/graphics/drawable/ShapeDrawable.java index 2bed3b0..394f584 100644 --- a/graphics/java/android/graphics/drawable/ShapeDrawable.java +++ b/graphics/java/android/graphics/drawable/ShapeDrawable.java @@ -470,6 +470,7 @@ public class ShapeDrawable extends Drawable { public void getOutline(Outline outline) { if (mShapeState.mShape != null) { mShapeState.mShape.getOutline(outline); + outline.setAlpha(getAlpha() / 255.0f); } } diff --git a/libs/hwui/Outline.h b/libs/hwui/Outline.h index 83426e8..6dacd5e 100644 --- a/libs/hwui/Outline.h +++ b/libs/hwui/Outline.h @@ -28,18 +28,20 @@ public: Outline() : mShouldClip(false) , mType(kOutlineType_None) - , mRadius(0) {} + , mRadius(0) + , mAlpha(0.0f) {} - void setRoundRect(int left, int top, int right, int bottom, float radius) { + void setRoundRect(int left, int top, int right, int bottom, float radius, float alpha) { mType = kOutlineType_RoundRect; mBounds.set(left, top, right, bottom); mRadius = radius; mPath.reset(); mPath.addRoundRect(SkRect::MakeLTRB(left, top, right, bottom), radius, radius); + mAlpha = alpha; } - void setConvexPath(const SkPath* outline) { + void setConvexPath(const SkPath* outline, float alpha) { if (!outline) { setEmpty(); return; @@ -47,22 +49,29 @@ public: mType = kOutlineType_ConvexPath; mPath = *outline; mBounds.set(outline->getBounds()); + mAlpha = alpha; } void setEmpty() { mType = kOutlineType_Empty; mPath.reset(); + mAlpha = 0.0f; } void setNone() { mType = kOutlineType_None; mPath.reset(); + mAlpha = 0.0f; } bool isEmpty() const { return mType == kOutlineType_Empty; } + float getAlpha() const { + return mAlpha; + } + void setShouldClip(bool clip) { mShouldClip = clip; } @@ -103,6 +112,7 @@ private: OutlineType mType; Rect mBounds; float mRadius; + float mAlpha; SkPath mPath; }; diff --git a/libs/hwui/RenderNode.cpp b/libs/hwui/RenderNode.cpp index 0662ca2..fa1b21d 100644 --- a/libs/hwui/RenderNode.cpp +++ b/libs/hwui/RenderNode.cpp @@ -594,7 +594,12 @@ void RenderNode::buildZSortedChildList(Vector<ZDrawRenderNodeOpPair>& zTranslate template <class T> void RenderNode::issueDrawShadowOperation(const Matrix4& transformFromParent, T& handler) { - if (properties().getAlpha() <= 0.0f || !properties().getOutline().getPath()) return; + if (properties().getAlpha() <= 0.0f + || properties().getOutline().getAlpha() <= 0.0f + || !properties().getOutline().getPath()) { + // no shadow to draw + return; + } mat4 shadowMatrixXY(transformFromParent); applyViewPropertyTransforms(shadowMatrixXY); @@ -607,8 +612,9 @@ void RenderNode::issueDrawShadowOperation(const Matrix4& transformFromParent, T& const SkPath* revealClipPath = properties().getRevealClip().getPath(); if (revealClipPath && revealClipPath->isEmpty()) return; + float casterAlpha = properties().getAlpha() * properties().getOutline().getAlpha(); DisplayListOp* shadowOp = new (handler.allocator()) DrawShadowOp( - shadowMatrixXY, shadowMatrixZ, properties().getAlpha(), + shadowMatrixXY, shadowMatrixZ, casterAlpha, outlinePath, revealClipPath); handler(shadowOp, PROPERTY_SAVECOUNT, properties().getClipToBounds()); } diff --git a/tools/aapt/Images.cpp b/tools/aapt/Images.cpp index 28de933..cf3dd0a 100644 --- a/tools/aapt/Images.cpp +++ b/tools/aapt/Images.cpp @@ -83,7 +83,7 @@ struct image_info int32_t outlineInsetsRight; int32_t outlineInsetsBottom; float outlineRadius; - bool outlineFilled; + uint8_t outlineAlpha; png_uint_32 allocHeight; png_bytepp allocRows; @@ -410,12 +410,12 @@ static void find_max_opacity(png_byte** rows, int* out_inset) { bool opaque_within_inset = true; - unsigned char max_opacity = 0; + uint8_t max_opacity = 0; int inset = 0; *out_inset = 0; for (int x = startX, y = startY; x != endX && y != endY; x += dX, y += dY, inset++) { png_byte* color = rows[y] + x * 4; - unsigned char opacity = color[3]; + uint8_t opacity = color[3]; if (opacity > max_opacity) { max_opacity = opacity; *out_inset = inset; @@ -424,22 +424,24 @@ static void find_max_opacity(png_byte** rows, } } -static bool is_opaque_over_row(png_byte* row, int startX, int endX) +static uint8_t max_alpha_over_row(png_byte* row, int startX, int endX) { + uint8_t max_alpha = 0; for (int x = startX; x < endX; x++) { - png_byte* color = row + x * 4; - if (color[3] != 0xff) return false; + uint8_t alpha = (row + x * 4)[3]; + if (alpha > max_alpha) max_alpha = alpha; } - return true; + return max_alpha; } -static bool is_opaque_over_col(png_byte** rows, int offsetX, int startY, int endY) +static uint8_t max_alpha_over_col(png_byte** rows, int offsetX, int startY, int endY) { + uint8_t max_alpha = 0; for (int y = startY; y < endY; y++) { - png_byte* color = rows[y] + offsetX * 4; - if (color[3] != 0xff) return false; + uint8_t alpha = (rows[y] + offsetX * 4)[3]; + if (alpha > max_alpha) max_alpha = alpha; } - return true; + return max_alpha; } static void get_outline(image_info* image) @@ -476,8 +478,8 @@ static void get_outline(image_info* image) // assuming the image is a round rect, compute the radius by marching // diagonally from the top left corner towards the center - image->outlineFilled = is_opaque_over_row(image->rows[innerMidY], innerStartX, innerEndX) - && is_opaque_over_col(image->rows, innerMidX, innerStartY, innerStartY); + image->outlineAlpha = max(max_alpha_over_row(image->rows[innerMidY], innerStartX, innerEndX), + max_alpha_over_col(image->rows, innerMidX, innerStartY, innerStartY)); int diagonalInset = 0; find_max_opacity(image->rows, innerStartX, innerStartY, innerMidX, innerMidY, 1, 1, @@ -487,14 +489,13 @@ static void get_outline(image_info* image) // radius = 1 / (sqrt(2) - 1) * inset image->outlineRadius = 2.4142f * diagonalInset; - NOISY(printf("outline insets %d %d %d %d, rad %f, filled %d\n", - image->outlineFilled, + NOISY(printf("outline insets %d %d %d %d, rad %f, alpha %x\n", image->outlineInsetsLeft, image->outlineInsetsTop, image->outlineInsetsRight, image->outlineInsetsBottom, image->outlineRadius, - image->outlineFilled)); + image->outlineAlpha)); } @@ -691,8 +692,8 @@ static status_t do_9patch(const char* imageName, image_info* image) } NOISY(printf("Size ticks for %s: x0=%d, x1=%d, y0=%d, y1=%d\n", imageName, - image->info9Patch.xDivs[0], image->info9Patch.xDivs[1], - image->info9Patch.yDivs[0], image->info9Patch.yDivs[1])); + xDivs[0], xDivs[1], + yDivs[0], yDivs[1])); NOISY(printf("padding ticks for %s: l=%d, r=%d, t=%d, b=%d\n", imageName, image->info9Patch.paddingLeft, image->info9Patch.paddingRight, image->info9Patch.paddingTop, image->info9Patch.paddingBottom)); @@ -1167,7 +1168,7 @@ static void write_png(const char* imageName, png_byte outputData[chunk_size]; memcpy(&outputData, &imageInfo.outlineInsetsLeft, 4 * sizeof(png_uint_32)); ((float*) outputData)[4] = imageInfo.outlineRadius; - ((png_uint_32*) outputData)[5] = imageInfo.outlineFilled ? 1 : 0; + ((png_uint_32*) outputData)[5] = imageInfo.outlineAlpha; memcpy(unknowns[o_index].data, &outputData, chunk_size); unknowns[o_index].size = chunk_size; |