@Implementation // todo: this sucks, it's all just so we can detect 9-patches
  public static Drawable createFromResourceStream(
      Resources res, TypedValue value, InputStream is, String srcName, BitmapFactory.Options opts) {
    if (is == null) {
      return null;
    }
    Rect pad = new Rect();
    if (opts == null) opts = new BitmapFactory.Options();
    opts.inScreenDensity = DisplayMetrics.DENSITY_DEFAULT;

    Bitmap bm = BitmapFactory.decodeResourceStream(res, value, is, pad, opts);
    if (bm != null) {
      boolean isNinePatch = srcName != null && srcName.contains(".9.");
      if (isNinePatch) {
        ReflectionHelpers.callInstanceMethod(
            bm, "setNinePatchChunk", ClassParameter.from(byte[].class, new byte[0]));
      }
      byte[] np = bm.getNinePatchChunk();
      if (np == null || !NinePatch.isNinePatchChunk(np)) {
        np = null;
        pad = null;
      }

      if (np != null) {
        // todo: wrong
        return new NinePatchDrawable(res, bm, np, pad, srcName);
      }

      return new BitmapDrawable(res, bm);
    }
    return null;
  }
 @Override
 protected void onDraw(Canvas canvas) {
   if (getContext().getResources().getConfiguration().orientation
       == Configuration.ORIENTATION_LANDSCAPE) {
     // use topY
     if (indicatorBitmap != null) {
       // canvas.drawBitmap(indicatorBitmap, 0, topY, null);
       ninePatch.draw(canvas, rectD);
     }
   } else {
     // use topX
     if (indicatorBitmap != null) {
       ninePatch.draw(canvas, rectD);
       // canvas.drawBitmap(indicatorBitmap, new Rect(0,0,indicatorBitmap.getWidth(),
       // indicatorBitmap.getHeight()), new Rect(leftX, 0, leftX+lp.width, lp.height),  null);
     }
   }
 }
Exemple #3
0
  public static Drawable getDraw9(final InitPackageResourcesParam resparam, final String nama) {

    Bitmap bitmap = BitmapFactory.decodeFile(S.DEFAULT_ICON_DIR + "/" + nama + ".png");
    final byte[] chunk = bitmap.getNinePatchChunk();
    if (NinePatch.isNinePatchChunk(chunk))
      return new NinePatchDrawable(
          resparam.res, bitmap, chunk, Npatch.deserialize(chunk).mPaddings, null);
    else return Drawable.createFromPath(S.DEFAULT_ICON_DIR + "/" + nama + ".png");
  }
Exemple #4
0
  private static Drawable getNinePathDrawable(InitPackageResourcesParam resparam, String str) {
    Bitmap bitmap = BitmapFactory.decodeFile(str);
    final byte[] chunk = bitmap.getNinePatchChunk();
    Drawable d;
    if (NinePatch.isNinePatchChunk(chunk)) {
      d =
          new NinePatchDrawable(
              resparam.res, bitmap, chunk, Npatch.deserialize(chunk).mPaddings, null);
    } else {
      d = Drawable.createFromPath(str);
    }

    return d;
  }
 private void computeBitmapSize() {
   final int sdensity = mNinePatch.getDensity();
   final int tdensity = mTargetDensity;
   if (sdensity == tdensity) {
     mBitmapWidth = mNinePatch.getWidth();
     mBitmapHeight = mNinePatch.getHeight();
     mOpticalInsets = mNinePatchState.mOpticalInsets;
   } else {
     mBitmapWidth = Bitmap.scaleFromDensity(mNinePatch.getWidth(), sdensity, tdensity);
     mBitmapHeight = Bitmap.scaleFromDensity(mNinePatch.getHeight(), sdensity, tdensity);
     if (mNinePatchState.mPadding != null && mPadding != null) {
       Rect dest = mPadding;
       Rect src = mNinePatchState.mPadding;
       if (dest == src) {
         mPadding = dest = new Rect(src);
       }
       dest.left = Bitmap.scaleFromDensity(src.left, sdensity, tdensity);
       dest.top = Bitmap.scaleFromDensity(src.top, sdensity, tdensity);
       dest.right = Bitmap.scaleFromDensity(src.right, sdensity, tdensity);
       dest.bottom = Bitmap.scaleFromDensity(src.bottom, sdensity, tdensity);
     }
     mOpticalInsets = scaleFromDensity(mNinePatchState.mOpticalInsets, sdensity, tdensity);
   }
 }
Exemple #6
0
  /**
   * Create a drawable from an inputstream, using the given resources and value to determine density
   * information.
   */
  public static Drawable createFromResourceStream(
      Resources res, TypedValue value, InputStream is, String srcName, BitmapFactory.Options opts) {
    if (is == null) {
      return null;
    }

    /*  ugh. The decodeStream contract is that we have already allocated
        the pad rect, but if the bitmap does not had a ninepatch chunk,
        then the pad will be ignored. If we could change this to lazily
        alloc/assign the rect, we could avoid the GC churn of making new
        Rects only to drop them on the floor.
    */
    Rect pad = new Rect();

    // Special stuff for compatibility mode: if the target density is not
    // the same as the display density, but the resource -is- the same as
    // the display density, then don't scale it down to the target density.
    // This allows us to load the system's density-correct resources into
    // an application in compatibility mode, without scaling those down
    // to the compatibility density only to have them scaled back up when
    // drawn to the screen.
    if (opts == null) opts = new BitmapFactory.Options();
    opts.inScreenDensity =
        res != null ? res.getDisplayMetrics().noncompatDensityDpi : DisplayMetrics.DENSITY_DEVICE;
    Bitmap bm = BitmapFactory.decodeResourceStream(res, value, is, pad, opts);
    if (bm != null) {
      byte[] np = bm.getNinePatchChunk();
      if (np == null || !NinePatch.isNinePatchChunk(np)) {
        np = null;
        pad = null;
      }

      final Rect opticalInsets = new Rect();
      bm.getOpticalInsets(opticalInsets);
      return drawableFromBitmap(res, bm, np, pad, opticalInsets, srcName);
    }
    return null;
  }
  @Override
  public void draw(Canvas canvas) {
    final Rect bounds = getBounds();

    final boolean clearColorFilter;
    if (mTintFilter != null && getPaint().getColorFilter() == null) {
      mPaint.setColorFilter(mTintFilter);
      clearColorFilter = true;
    } else {
      clearColorFilter = false;
    }

    final boolean needsMirroring = needsMirroring();
    if (needsMirroring) {
      // Mirror the 9patch
      canvas.translate(bounds.right - bounds.left, 0);
      canvas.scale(-1.0f, 1.0f);
    }

    final int restoreAlpha;
    if (mNinePatchState.mBaseAlpha != 1.0f) {
      restoreAlpha = mPaint.getAlpha();
      mPaint.setAlpha((int) (restoreAlpha * mNinePatchState.mBaseAlpha + 0.5f));
    } else {
      restoreAlpha = -1;
    }

    mNinePatch.draw(canvas, bounds, mPaint);

    if (clearColorFilter) {
      mPaint.setColorFilter(null);
    }

    if (restoreAlpha >= 0) {
      mPaint.setAlpha(restoreAlpha);
    }
  }
 public void drawNinepath(Canvas c, Rect r1) {
   NinePatch patch = new NinePatch(bmp, bmp.getNinePatchChunk(), null);
   patch.draw(c, r1);
 }
Exemple #9
0
 /**
  * 手动绘制.9.png图片
  *
  * @param canvas
  * @param resId
  * @param rect
  */
 private void drawNinepath(Canvas canvas, int resId, Rect rect) {
   Bitmap bmp = BitmapFactory.decodeResource(getResources(), resId);
   NinePatch patch = new NinePatch(bmp, bmp.getNinePatchChunk(), null);
   patch.draw(canvas, rect);
 }
 @Override
 public Bitmap getBitmap() {
   return mNinePatch.getBitmap();
 }
 @Override
 public Region getTransparentRegion() {
   return mNinePatch.getTransparentRegion(getBounds());
 }
 /**
  * Returns a {@link android.graphics.PixelFormat graphics.PixelFormat} value of OPAQUE or
  * TRANSLUCENT.
  */
 @Override
 public int getOpacity() {
   return mNinePatch.hasAlpha() || (mPaint != null && mPaint.getAlpha() < 255)
       ? PixelFormat.TRANSLUCENT
       : PixelFormat.OPAQUE;
 }