content: /*
   * Copyright (C) 2006 The Android Open Source Project
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package android.graphics;
  
  import android.annotation.UnsupportedAppUsage;
  
  /**
   * The NinePatch class permits drawing a bitmap in nine or more sections.
   * Essentially, it allows the creation of custom graphics that will scale the
   * way that you define, when content added within the image exceeds the normal
   * bounds of the graphic. For a thorough explanation of a NinePatch image, 
   * read the discussion in the 
   * <a href="{@docRoot}guide/topics/graphics/2d-graphics.html#nine-patch">2D
   * Graphics</a> document.
   * <p>
   * The <a href="{@docRoot}guide/developing/tools/draw9patch.html">Draw 9-Patch</a> 
   * tool offers an extremely handy way to create your NinePatch images,
   * using a WYSIWYG graphics editor.
   * </p>
   */
  public class NinePatch {
      /**
       * Struct of inset information attached to a 9 patch bitmap.
       *
       * Present on a 9 patch bitmap if it optical insets were manually included,
       * or if outline insets were automatically included by aapt.
       *
       * @hide
       */
      public static class InsetStruct {
          @SuppressWarnings({"UnusedDeclaration"}) // called from JNI
          @UnsupportedAppUsage
          InsetStruct(int opticalLeft, int opticalTop, int opticalRight, int opticalBottom,
                  int outlineLeft, int outlineTop, int outlineRight, int outlineBottom,
                  float outlineRadius, int outlineAlpha, float decodeScale) {
              opticalRect = new Rect(opticalLeft, opticalTop, opticalRight, opticalBottom);
              opticalRect.scale(decodeScale);
  
              outlineRect = scaleInsets(outlineLeft, outlineTop,
                      outlineRight, outlineBottom, decodeScale);
  
              this.outlineRadius = outlineRadius * decodeScale;
              this.outlineAlpha = outlineAlpha / 255.0f;
          }
  
          public final Rect opticalRect;
          public final Rect outlineRect;
          public final float outlineRadius;
          public final float outlineAlpha;
  
          /**
           * Scales up the rect by the given scale, ceiling values, so actual outline Rect
           * grows toward the inside.
           */
          public static Rect scaleInsets(int left, int top, int right, int bottom, float scale) {
              if (scale == 1.0f) {
                  return new Rect(left, top, right, bottom);
              }
  
              Rect result = new Rect();
              result.left = (int) Math.ceil(left * scale);
              result.top = (int) Math.ceil(top * scale);
              result.right = (int) Math.ceil(right * scale);
              result.bottom = (int) Math.ceil(bottom * scale);
              return  result;
          }
      }
  
      @UnsupportedAppUsage
      private final Bitmap mBitmap;
  
      /**
       * Used by native code. This pointer is an instance of Res_png_9patch*.
       *
       * @hide
       */
      @UnsupportedAppUsage
      public long mNativeChunk;
  
      private Paint mPaint;
      private String mSrcName;
  
      /**
       * Create a drawable projection from a bitmap to nine patches.
       *
       * @param bitmap The bitmap describing the patches.
       * @param chunk The 9-patch data chunk describing how the underlying bitmap
       *              is split apart and drawn.
       */
      public NinePatch(Bitmap bitmap, byte[] chunk) {
          this(bitmap, chunk, null);
      }
  
      /** 
       * Create a drawable projection from a bitmap to nine patches.
       *
       * @param bitmap The bitmap describing the patches.
       * @param chunk The 9-patch data chunk describing how the underlying
       *              bitmap is split apart and drawn.
       * @param srcName The name of the source for the bitmap. Might be null.
       */
      public NinePatch(Bitmap bitmap, byte[] chunk, String srcName) {
          mBitmap = bitmap;
          mSrcName = srcName;
          mNativeChunk = validateNinePatchChunk(chunk);
      }
  
      /**
       * @hide
       */
      public NinePatch(NinePatch patch) {
          mBitmap = patch.mBitmap;
          mSrcName = patch.mSrcName;
          if (patch.mPaint != null) {
              mPaint = new Paint(patch.mPaint);
          }
          // No need to validate the 9patch chunk again, it was done by
          // the instance we're copying from
          mNativeChunk = patch.mNativeChunk;
      }
  
      @Override
      protected void finalize() throws Throwable {
          try {
              if (mNativeChunk != 0) {
                  // only attempt to destroy correctly initilized chunks
                  nativeFinalize(mNativeChunk);
                  mNativeChunk = 0;
              }
          } finally {
              super.finalize();
          }
      }
  
      /**
       * Returns the name of this NinePatch object if one was specified
       * when calling the constructor.
       */
      public String getName() {
          return mSrcName;
      }
  
      /**
       * Returns the paint used to draw this NinePatch. The paint can be null.
       *
       * @see #setPaint(Paint)
       * @see #draw(Canvas, Rect)
       * @see #draw(Canvas, RectF)
       */
      public Paint getPaint() {
          return mPaint;
      }
  
      /**
       * Sets the paint to use when drawing the NinePatch.
       *
       * @param p The paint that will be used to draw this NinePatch.
       *
       * @see #getPaint()
       * @see #draw(Canvas, Rect)
       * @see #draw(Canvas, RectF)
       */
      public void setPaint(Paint p) {
          mPaint = p;
      }
  
      /**
       * Returns the bitmap used to draw this NinePatch.
       */
      public Bitmap getBitmap() {
          return mBitmap;
      }
      
      /** 
       * Draws the NinePatch. This method will use the paint returned by {@link #getPaint()}.
       *
       * @param canvas A container for the current matrix and clip used to draw the NinePatch.
       * @param location Where to draw the NinePatch.
       */
      public void draw(Canvas canvas, RectF location) {
          canvas.drawPatch(this, location, mPaint);
      }
  
      /** 
       * Draws the NinePatch. This method will use the paint returned by {@link #getPaint()}.
       *
       * @param canvas A container for the current matrix and clip used to draw the NinePatch.
       * @param location Where to draw the NinePatch.
       */
      public void draw(Canvas canvas, Rect location) {
          canvas.drawPatch(this, location, mPaint);
      }
  
      /** 
       * Draws the NinePatch. This method will ignore the paint returned
       * by {@link #getPaint()} and use the specified paint instead.
       *
       * @param canvas A container for the current matrix and clip used to draw the NinePatch.
       * @param location Where to draw the NinePatch.
       * @param paint The Paint to draw through.
       */
      public void draw(Canvas canvas, Rect location, Paint paint) {
          canvas.drawPatch(this, location, paint);
      }
  
      /**
       * Return the underlying bitmap's density, as per
       * {@link Bitmap#getDensity() Bitmap.getDensity()}.
       */
      public int getDensity() {
          return mBitmap.mDensity;
      }
  
      /**
       * Returns the intrinsic width, in pixels, of this NinePatch. This is equivalent
       * to querying the width of the underlying bitmap returned by {@link #getBitmap()}.
       */
      public int getWidth() {
          return mBitmap.getWidth();
      }
  
      /**
       * Returns the intrinsic height, in pixels, of this NinePatch. This is equivalent
       * to querying the height of the underlying bitmap returned by {@link #getBitmap()}.
       */
      public int getHeight() {
          return mBitmap.getHeight();
      }
  
      /**
       * Indicates whether this NinePatch contains transparent or translucent pixels.
       * This is equivalent to calling <code>getBitmap().hasAlpha()</code> on this
       * NinePatch.
       */
      public final boolean hasAlpha() {
          return mBitmap.hasAlpha();
      }
  
      /**
       * Returns a {@link Region} representing the parts of the NinePatch that are
       * completely transparent.
       *
       * @param bounds The location and size of the NinePatch.
       *
       * @return null if the NinePatch has no transparent region to
       * report, else a {@link Region} holding the parts of the specified bounds
       * that are transparent.
       */
      public final Region getTransparentRegion(Rect bounds) {
          long r = nativeGetTransparentRegion(mBitmap.getNativeInstance(),
                  mNativeChunk, bounds);
          return r != 0 ? new Region(r) : null;
      }
  
      /**
       * Verifies that the specified byte array is a valid 9-patch data chunk.
       *
       * @param chunk A byte array representing a 9-patch data chunk.
       *
       * @return True if the specified byte array represents a 9-patch data chunk,
       *         false otherwise.
       */
      public native static boolean isNinePatchChunk(byte[] chunk);
  
      /**
       * Validates the 9-patch chunk and throws an exception if the chunk is invalid.
       * If validation is successful, this method returns a native Res_png_9patch*
       * object used by the renderers.
       */
      private static native long validateNinePatchChunk(byte[] chunk);
      private static native void nativeFinalize(long chunk);
      private static native long nativeGetTransparentRegion(long bitmapHandle, long chunk,
          Rect location);
  }
  