tools/ninepatch/src/com/android/ninepatch/NinePatch.java - platform/development - Git at Google

 /*
  * Copyright (C) 2008 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 com.android.ninepatch;

 import java.awt.Graphics2D;
 import java.awt.Rectangle;
 import java.awt.RenderingHints;
 import java.awt.image.BufferedImage;
 import java.io.IOException;
 import java.net.MalformedURLException;
 import java.net.URL;
 import java.util.ArrayList;
 import java.util.List;

 /**
  * Represents a 9-Patch bitmap.
  */
 public class NinePatch {
     public static final String EXTENSION_9PATCH = ".9.png";

     private BufferedImage mImage;

     private int mMinWidth;
     private int mMinHeight;

     private int[] row;
     private int[] column;

     private boolean mVerticalStartWithPatch;
     private boolean mHorizontalStartWithPatch;

     private List<Rectangle> mFixed;
     private List<Rectangle> mPatches;
     private List<Rectangle> mHorizontalPatches;
     private List<Rectangle> mVerticalPatches;

     private Pair<Integer> mHorizontalPadding;
     private Pair<Integer> mVerticalPadding;

     private float mHorizontalPatchesSum;
     private float mVerticalPatchesSum;

     private int mRemainderHorizontal;

     private int mRemainderVertical;

     private final URL mFileUrl;

     /**
      * Loads a 9 patch or regular bitmap.
      * @param fileUrl the URL of the file to load.
      * @param convert if <code>true</code>, non 9-patch bitmpa will be converted into a 9 patch.
      * If <code>false</code> and the bitmap is not a 9 patch, the method will return
      * <code>null</code>.
      * @return a {@link NinePatch} or <code>null</code>.
      * @throws IOException
      */
     public static NinePatch load(URL fileUrl, boolean convert) throws IOException {
         BufferedImage image = null;
         try {
             image  = GraphicsUtilities.loadCompatibleImage(fileUrl);
         } catch (MalformedURLException e) {
             // really this shouldn't be happening since we're not creating the URL manually.
             return null;
         }

         boolean is9Patch = fileUrl.getPath().toLowerCase().endsWith(EXTENSION_9PATCH);

         if (is9Patch == false) {
             if (convert) {
                 image = convertTo9Patch(image);
             } else {
                 return null;
             }
         } else {
             ensure9Patch(image);
         }


         return new NinePatch(fileUrl, image);
     }

     public int getWidth() {
         return mImage.getWidth() - 2;
     }

     public int getHeight() {
         return mImage.getHeight() - 2;
     }

     /**
      *
      * @param padding array of left, top, right, bottom padding
      * @return
      */
     public boolean getPadding(int[] padding) {
         padding[0] = mHorizontalPadding.mFirst; // left
         padding[2] = mHorizontalPadding.mSecond; // right
         padding[1] = mVerticalPadding.mFirst; // top
         padding[3] = mVerticalPadding.mSecond; // bottom
         return true;
     }


     public void draw(Graphics2D graphics2D, int x, int y, int scaledWidth, int scaledHeight) {
         if (scaledWidth <= 1 || scaledHeight <= 1) {
             return;
         }

         Graphics2D g = (Graphics2D)graphics2D.create();
         g.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
                 RenderingHints.VALUE_INTERPOLATION_BILINEAR);


         try {
             if (mPatches.size() == 0) {
                 g.drawImage(mImage, x, y, scaledWidth, scaledHeight, null);
                 return;
             }

             g.translate(x, y);
             x = y = 0;

             computePatches(scaledWidth, scaledHeight);

             int fixedIndex = 0;
             int horizontalIndex = 0;
             int verticalIndex = 0;
             int patchIndex = 0;

             boolean hStretch;
             boolean vStretch;

             float vWeightSum = 1.0f;
             float vRemainder = mRemainderVertical;

             vStretch = mVerticalStartWithPatch;
             while (y < scaledHeight - 1) {
                 hStretch = mHorizontalStartWithPatch;

                 int height = 0;
                 float vExtra = 0.0f;

                 float hWeightSum = 1.0f;
                 float hRemainder = mRemainderHorizontal;

                 while (x < scaledWidth - 1) {
                     Rectangle r;
                     if (!vStretch) {
                         if (hStretch) {
                             r = mHorizontalPatches.get(horizontalIndex++);
                             float extra = r.width / mHorizontalPatchesSum;
                             int width = (int) (extra * hRemainder / hWeightSum);
                             hWeightSum -= extra;
                             hRemainder -= width;
                             g.drawImage(mImage, x, y, x + width, y + r.height, r.x, r.y,
                                     r.x + r.width, r.y + r.height, null);
                             x += width;
                         } else {
                             r = mFixed.get(fixedIndex++);
                             g.drawImage(mImage, x, y, x + r.width, y + r.height, r.x, r.y,
                                     r.x + r.width, r.y + r.height, null);
                             x += r.width;
                         }
                         height = r.height;
                     } else {
                         if (hStretch) {
                             r = mPatches.get(patchIndex++);
                             vExtra = r.height / mVerticalPatchesSum;
                             height = (int) (vExtra * vRemainder / vWeightSum);
                             float extra = r.width / mHorizontalPatchesSum;
                             int width = (int) (extra * hRemainder / hWeightSum);
                             hWeightSum -= extra;
                             hRemainder -= width;
                             g.drawImage(mImage, x, y, x + width, y + height, r.x, r.y,
                                     r.x + r.width, r.y + r.height, null);
                             x += width;
                         } else {
                             r = mVerticalPatches.get(verticalIndex++);
                             vExtra = r.height / mVerticalPatchesSum;
                             height = (int) (vExtra * vRemainder / vWeightSum);
                             g.drawImage(mImage, x, y, x + r.width, y + height, r.x, r.y,
                                     r.x + r.width, r.y + r.height, null);
                             x += r.width;
                         }

                     }
                     hStretch = !hStretch;
                 }
                 x = 0;
                 y += height;
                 if (vStretch) {
                     vWeightSum -= vExtra;
                     vRemainder -= height;
                 }
                 vStretch = !vStretch;
             }

         } finally {
             g.dispose();
         }
     }

     void computePatches(int scaledWidth, int scaledHeight) {
         boolean measuredWidth = false;
         boolean endRow = true;

         int remainderHorizontal = 0;
         int remainderVertical = 0;

         if (mFixed.size() > 0) {
             int start = mFixed.get(0).y;
             for (Rectangle rect : mFixed) {
                 if (rect.y > start) {
                     endRow = true;
                     measuredWidth = true;
                 }
                 if (!measuredWidth) {
                     remainderHorizontal += rect.width;
                 }
                 if (endRow) {
                     remainderVertical += rect.height;
                     endRow = false;
                     start = rect.y;
                 }
             }
         }

         mRemainderHorizontal = scaledWidth - remainderHorizontal;

         mRemainderVertical = scaledHeight - remainderVertical;

         mHorizontalPatchesSum = 0;
         if (mHorizontalPatches.size() > 0) {
             int start = -1;
             for (Rectangle rect : mHorizontalPatches) {
                 if (rect.x > start) {
                     mHorizontalPatchesSum += rect.width;
                     start = rect.x;
                 }
             }
         } else {
             int start = -1;
             for (Rectangle rect : mPatches) {
                 if (rect.x > start) {
                     mHorizontalPatchesSum += rect.width;
                     start = rect.x;
                 }
             }
         }

         mVerticalPatchesSum = 0;
         if (mVerticalPatches.size() > 0) {
             int start = -1;
             for (Rectangle rect : mVerticalPatches) {
                 if (rect.y > start) {
                     mVerticalPatchesSum += rect.height;
                     start = rect.y;
                 }
             }
         } else {
             int start = -1;
             for (Rectangle rect : mPatches) {
                 if (rect.y > start) {
                     mVerticalPatchesSum += rect.height;
                     start = rect.y;
                 }
             }
         }
     }


     private NinePatch(URL fileUrl, BufferedImage image) {
         mFileUrl = fileUrl;
         mImage = image;

         findPatches();
     }

     private void findPatches() {
         int width = mImage.getWidth();
         int height = mImage.getHeight();

         row = GraphicsUtilities.getPixels(mImage, 0, 0, width, 1, row);
         column = GraphicsUtilities.getPixels(mImage, 0, 0, 1, height, column);

         boolean[] result = new boolean[1];
         Pair<List<Pair<Integer>>> left = getPatches(column, result);
         mVerticalStartWithPatch = result[0];

         result = new boolean[1];
         Pair<List<Pair<Integer>>> top = getPatches(row, result);
         mHorizontalStartWithPatch = result[0];

         mFixed = getRectangles(left.mFirst, top.mFirst);
         mPatches = getRectangles(left.mSecond, top.mSecond);

         if (mFixed.size() > 0) {
             mHorizontalPatches = getRectangles(left.mFirst, top.mSecond);
             mVerticalPatches = getRectangles(left.mSecond, top.mFirst);
         } else {
             if (top.mFirst.size() > 0) {
                 mHorizontalPatches = new ArrayList<Rectangle>(0);
                 mVerticalPatches = getVerticalRectangles(top.mFirst);
             } else if (left.mFirst.size() > 0) {
                 mHorizontalPatches = getHorizontalRectangles(left.mFirst);
                 mVerticalPatches = new ArrayList<Rectangle>(0);
             } else {
                 mHorizontalPatches = mVerticalPatches = new ArrayList<Rectangle>(0);
             }
         }

         row = GraphicsUtilities.getPixels(mImage, 0, height - 1, width, 1, row);
         column = GraphicsUtilities.getPixels(mImage, width - 1, 0, 1, height, column);

         top = getPatches(row, result);
         mHorizontalPadding = getPadding(top.mFirst);

         left = getPatches(column, result);
         mVerticalPadding = getPadding(left.mFirst);
     }

     private List<Rectangle> getVerticalRectangles(List<Pair<Integer>> topPairs) {
         List<Rectangle> rectangles = new ArrayList<Rectangle>();
         for (Pair<Integer> top : topPairs) {
             int x = top.mFirst;
             int width = top.mSecond - top.mFirst;

             rectangles.add(new Rectangle(x, 1, width, mImage.getHeight() - 2));
         }
         return rectangles;
     }

     private List<Rectangle> getHorizontalRectangles(List<Pair<Integer>> leftPairs) {
         List<Rectangle> rectangles = new ArrayList<Rectangle>();
         for (Pair<Integer> left : leftPairs) {
             int y = left.mFirst;
             int height = left.mSecond - left.mFirst;

             rectangles.add(new Rectangle(1, y, mImage.getWidth() - 2, height));
         }
         return rectangles;
     }

     private Pair<Integer> getPadding(List<Pair<Integer>> pairs) {
         if (pairs.size() == 0) {
             return new Pair<Integer>(0, 0);
         } else if (pairs.size() == 1) {
             if (pairs.get(0).mFirst == 1) {
                 return new Pair<Integer>(pairs.get(0).mSecond - pairs.get(0).mFirst, 0);
             } else {
                 return new Pair<Integer>(0, pairs.get(0).mSecond - pairs.get(0).mFirst);
             }
         } else {
             int index = pairs.size() - 1;
             return new Pair<Integer>(pairs.get(0).mSecond - pairs.get(0).mFirst,
                     pairs.get(index).mSecond - pairs.get(index).mFirst);
         }
     }

     private List<Rectangle> getRectangles(List<Pair<Integer>> leftPairs,
             List<Pair<Integer>> topPairs) {
         List<Rectangle> rectangles = new ArrayList<Rectangle>();
         for (Pair<Integer> left : leftPairs) {
             int y = left.mFirst;
             int height = left.mSecond - left.mFirst;
             for (Pair<Integer> top : topPairs) {
                 int x = top.mFirst;
                 int width = top.mSecond - top.mFirst;

                 rectangles.add(new Rectangle(x, y, width, height));
             }
         }
         return rectangles;
     }

     private Pair<List<Pair<Integer>>> getPatches(int[] pixels, boolean[] startWithPatch) {
         int lastIndex = 1;
         int lastPixel = pixels[1];
         boolean first = true;

         List<Pair<Integer>> fixed = new ArrayList<Pair<Integer>>();
         List<Pair<Integer>> patches = new ArrayList<Pair<Integer>>();

         for (int i = 1; i < pixels.length - 1; i++) {
             int pixel = pixels[i];
             if (pixel != lastPixel) {
                 if (lastPixel == 0xFF000000) {
                     if (first) startWithPatch[0] = true;
                     patches.add(new Pair<Integer>(lastIndex, i));
                 } else {
                     fixed.add(new Pair<Integer>(lastIndex, i));
                 }
                 first = false;

                 lastIndex = i;
                 lastPixel = pixel;
             }
         }
         if (lastPixel == 0xFF000000) {
             if (first) startWithPatch[0] = true;
             patches.add(new Pair<Integer>(lastIndex, pixels.length - 1));
         } else {
             fixed.add(new Pair<Integer>(lastIndex, pixels.length - 1));
         }

         if (patches.size() == 0) {
             patches.add(new Pair<Integer>(1, pixels.length - 1));
             startWithPatch[0] = true;
             fixed.clear();
         }

         return new Pair<List<Pair<Integer>>>(fixed, patches);
     }

     private static void ensure9Patch(BufferedImage image) {
         int width = image.getWidth();
         int height = image.getHeight();
         for (int i = 0; i < width; i++) {
             int pixel = image.getRGB(i, 0);
             if (pixel != 0 && pixel != 0xFF000000) {
                 image.setRGB(i, 0, 0);
             }
             pixel = image.getRGB(i, height - 1);
             if (pixel != 0 && pixel != 0xFF000000) {
                 image.setRGB(i, height - 1, 0);
             }
         }
         for (int i = 0; i < height; i++) {
             int pixel = image.getRGB(0, i);
             if (pixel != 0 && pixel != 0xFF000000) {
                 image.setRGB(0, i, 0);
             }
             pixel = image.getRGB(width - 1, i);
             if (pixel != 0 && pixel != 0xFF000000) {
                 image.setRGB(width - 1, i, 0);
             }
         }
     }

     private static BufferedImage convertTo9Patch(BufferedImage image) {
         BufferedImage buffer = GraphicsUtilities.createTranslucentCompatibleImage(
                 image.getWidth() + 2, image.getHeight() + 2);

         Graphics2D g2 = buffer.createGraphics();
         g2.drawImage(image, 1, 1, null);
         g2.dispose();

         return buffer;
     }

     static class Pair<E> {
         E mFirst;
         E mSecond;

         Pair(E first, E second) {
             mFirst = first;
             mSecond = second;
         }

         @Override
         public String toString() {
             return "Pair[" + mFirst + ", " + mSecond + "]";
         }
     }
 }
	/*
	* Copyright (C) 2008 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 com.android.ninepatch;

	import java.awt.Graphics2D;
	import java.awt.Rectangle;
	import java.awt.RenderingHints;
	import java.awt.image.BufferedImage;
	import java.io.IOException;
	import java.net.MalformedURLException;
	import java.net.URL;
	import java.util.ArrayList;
	import java.util.List;

	/**
	* Represents a 9-Patch bitmap.
	*/
	public class NinePatch {
	public static final String EXTENSION_9PATCH = ".9.png";

	private BufferedImage mImage;

	private int mMinWidth;
	private int mMinHeight;

	private int[] row;
	private int[] column;

	private boolean mVerticalStartWithPatch;
	private boolean mHorizontalStartWithPatch;

	private List<Rectangle> mFixed;
	private List<Rectangle> mPatches;
	private List<Rectangle> mHorizontalPatches;
	private List<Rectangle> mVerticalPatches;

	private Pair<Integer> mHorizontalPadding;
	private Pair<Integer> mVerticalPadding;

	private float mHorizontalPatchesSum;
	private float mVerticalPatchesSum;

	private int mRemainderHorizontal;

	private int mRemainderVertical;

	private final URL mFileUrl;

	/**
	* Loads a 9 patch or regular bitmap.
	* @param fileUrl the URL of the file to load.
	* @param convert if <code>true</code>, non 9-patch bitmpa will be converted into a 9 patch.
	* If <code>false</code> and the bitmap is not a 9 patch, the method will return
	* <code>null</code>.
	* @return a {@link NinePatch} or <code>null</code>.
	* @throws IOException
	*/
	public static NinePatch load(URL fileUrl, boolean convert) throws IOException {
	BufferedImage image = null;
	try {
	image = GraphicsUtilities.loadCompatibleImage(fileUrl);
	} catch (MalformedURLException e) {
	// really this shouldn't be happening since we're not creating the URL manually.
	return null;
	}

	boolean is9Patch = fileUrl.getPath().toLowerCase().endsWith(EXTENSION_9PATCH);

	if (is9Patch == false) {
	if (convert) {
	image = convertTo9Patch(image);
	} else {
	return null;
	}
	} else {
	ensure9Patch(image);
	}


	return new NinePatch(fileUrl, image);
	}

	public int getWidth() {
	return mImage.getWidth() - 2;
	}

	public int getHeight() {
	return mImage.getHeight() - 2;
	}

	/**
	*
	* @param padding array of left, top, right, bottom padding
	* @return
	*/
	public boolean getPadding(int[] padding) {
	padding[0] = mHorizontalPadding.mFirst; // left
	padding[2] = mHorizontalPadding.mSecond; // right
	padding[1] = mVerticalPadding.mFirst; // top
	padding[3] = mVerticalPadding.mSecond; // bottom
	return true;
	}


	public void draw(Graphics2D graphics2D, int x, int y, int scaledWidth, int scaledHeight) {
	if (scaledWidth <= 1 \|\| scaledHeight <= 1) {
	return;
	}

	Graphics2D g = (Graphics2D)graphics2D.create();
	g.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
	RenderingHints.VALUE_INTERPOLATION_BILINEAR);


	try {
	if (mPatches.size() == 0) {
	g.drawImage(mImage, x, y, scaledWidth, scaledHeight, null);
	return;
	}

	g.translate(x, y);
	x = y = 0;

	computePatches(scaledWidth, scaledHeight);

	int fixedIndex = 0;
	int horizontalIndex = 0;
	int verticalIndex = 0;
	int patchIndex = 0;

	boolean hStretch;
	boolean vStretch;

	float vWeightSum = 1.0f;
	float vRemainder = mRemainderVertical;

	vStretch = mVerticalStartWithPatch;
	while (y < scaledHeight - 1) {
	hStretch = mHorizontalStartWithPatch;

	int height = 0;
	float vExtra = 0.0f;

	float hWeightSum = 1.0f;
	float hRemainder = mRemainderHorizontal;

	while (x < scaledWidth - 1) {
	Rectangle r;
	if (!vStretch) {
	if (hStretch) {
	r = mHorizontalPatches.get(horizontalIndex++);
	float extra = r.width / mHorizontalPatchesSum;
	int width = (int) (extra * hRemainder / hWeightSum);
	hWeightSum -= extra;
	hRemainder -= width;
	g.drawImage(mImage, x, y, x + width, y + r.height, r.x, r.y,
	r.x + r.width, r.y + r.height, null);
	x += width;
	} else {
	r = mFixed.get(fixedIndex++);
	g.drawImage(mImage, x, y, x + r.width, y + r.height, r.x, r.y,
	r.x + r.width, r.y + r.height, null);
	x += r.width;
	}
	height = r.height;
	} else {
	if (hStretch) {
	r = mPatches.get(patchIndex++);
	vExtra = r.height / mVerticalPatchesSum;
	height = (int) (vExtra * vRemainder / vWeightSum);
	float extra = r.width / mHorizontalPatchesSum;
	int width = (int) (extra * hRemainder / hWeightSum);
	hWeightSum -= extra;
	hRemainder -= width;
	g.drawImage(mImage, x, y, x + width, y + height, r.x, r.y,
	r.x + r.width, r.y + r.height, null);
	x += width;
	} else {
	r = mVerticalPatches.get(verticalIndex++);
	vExtra = r.height / mVerticalPatchesSum;
	height = (int) (vExtra * vRemainder / vWeightSum);
	g.drawImage(mImage, x, y, x + r.width, y + height, r.x, r.y,
	r.x + r.width, r.y + r.height, null);
	x += r.width;
	}

	}
	hStretch = !hStretch;
	}
	x = 0;
	y += height;
	if (vStretch) {
	vWeightSum -= vExtra;
	vRemainder -= height;
	}
	vStretch = !vStretch;
	}

	} finally {
	g.dispose();
	}
	}

	void computePatches(int scaledWidth, int scaledHeight) {
	boolean measuredWidth = false;
	boolean endRow = true;

	int remainderHorizontal = 0;
	int remainderVertical = 0;

	if (mFixed.size() > 0) {
	int start = mFixed.get(0).y;
	for (Rectangle rect : mFixed) {
	if (rect.y > start) {
	endRow = true;
	measuredWidth = true;
	}
	if (!measuredWidth) {
	remainderHorizontal += rect.width;
	}
	if (endRow) {
	remainderVertical += rect.height;
	endRow = false;
	start = rect.y;
	}
	}
	}

	mRemainderHorizontal = scaledWidth - remainderHorizontal;

	mRemainderVertical = scaledHeight - remainderVertical;

	mHorizontalPatchesSum = 0;
	if (mHorizontalPatches.size() > 0) {
	int start = -1;
	for (Rectangle rect : mHorizontalPatches) {
	if (rect.x > start) {
	mHorizontalPatchesSum += rect.width;
	start = rect.x;
	}
	}
	} else {
	int start = -1;
	for (Rectangle rect : mPatches) {
	if (rect.x > start) {
	mHorizontalPatchesSum += rect.width;
	start = rect.x;
	}
	}
	}

	mVerticalPatchesSum = 0;
	if (mVerticalPatches.size() > 0) {
	int start = -1;
	for (Rectangle rect : mVerticalPatches) {
	if (rect.y > start) {
	mVerticalPatchesSum += rect.height;
	start = rect.y;
	}
	}
	} else {
	int start = -1;
	for (Rectangle rect : mPatches) {
	if (rect.y > start) {
	mVerticalPatchesSum += rect.height;
	start = rect.y;
	}
	}
	}
	}


	private NinePatch(URL fileUrl, BufferedImage image) {
	mFileUrl = fileUrl;
	mImage = image;

	findPatches();
	}

	private void findPatches() {
	int width = mImage.getWidth();
	int height = mImage.getHeight();

	row = GraphicsUtilities.getPixels(mImage, 0, 0, width, 1, row);
	column = GraphicsUtilities.getPixels(mImage, 0, 0, 1, height, column);

	boolean[] result = new boolean[1];
	Pair<List<Pair<Integer>>> left = getPatches(column, result);
	mVerticalStartWithPatch = result[0];

	result = new boolean[1];
	Pair<List<Pair<Integer>>> top = getPatches(row, result);
	mHorizontalStartWithPatch = result[0];

	mFixed = getRectangles(left.mFirst, top.mFirst);
	mPatches = getRectangles(left.mSecond, top.mSecond);

	if (mFixed.size() > 0) {
	mHorizontalPatches = getRectangles(left.mFirst, top.mSecond);
	mVerticalPatches = getRectangles(left.mSecond, top.mFirst);
	} else {
	if (top.mFirst.size() > 0) {
	mHorizontalPatches = new ArrayList<Rectangle>(0);
	mVerticalPatches = getVerticalRectangles(top.mFirst);
	} else if (left.mFirst.size() > 0) {
	mHorizontalPatches = getHorizontalRectangles(left.mFirst);
	mVerticalPatches = new ArrayList<Rectangle>(0);
	} else {
	mHorizontalPatches = mVerticalPatches = new ArrayList<Rectangle>(0);
	}
	}

	row = GraphicsUtilities.getPixels(mImage, 0, height - 1, width, 1, row);
	column = GraphicsUtilities.getPixels(mImage, width - 1, 0, 1, height, column);

	top = getPatches(row, result);
	mHorizontalPadding = getPadding(top.mFirst);

	left = getPatches(column, result);
	mVerticalPadding = getPadding(left.mFirst);
	}

	private List<Rectangle> getVerticalRectangles(List<Pair<Integer>> topPairs) {
	List<Rectangle> rectangles = new ArrayList<Rectangle>();
	for (Pair<Integer> top : topPairs) {
	int x = top.mFirst;
	int width = top.mSecond - top.mFirst;

	rectangles.add(new Rectangle(x, 1, width, mImage.getHeight() - 2));
	}
	return rectangles;
	}

	private List<Rectangle> getHorizontalRectangles(List<Pair<Integer>> leftPairs) {
	List<Rectangle> rectangles = new ArrayList<Rectangle>();
	for (Pair<Integer> left : leftPairs) {
	int y = left.mFirst;
	int height = left.mSecond - left.mFirst;

	rectangles.add(new Rectangle(1, y, mImage.getWidth() - 2, height));
	}
	return rectangles;
	}

	private Pair<Integer> getPadding(List<Pair<Integer>> pairs) {
	if (pairs.size() == 0) {
	return new Pair<Integer>(0, 0);
	} else if (pairs.size() == 1) {
	if (pairs.get(0).mFirst == 1) {
	return new Pair<Integer>(pairs.get(0).mSecond - pairs.get(0).mFirst, 0);
	} else {
	return new Pair<Integer>(0, pairs.get(0).mSecond - pairs.get(0).mFirst);
	}
	} else {
	int index = pairs.size() - 1;
	return new Pair<Integer>(pairs.get(0).mSecond - pairs.get(0).mFirst,
	pairs.get(index).mSecond - pairs.get(index).mFirst);
	}
	}

	private List<Rectangle> getRectangles(List<Pair<Integer>> leftPairs,
	List<Pair<Integer>> topPairs) {
	List<Rectangle> rectangles = new ArrayList<Rectangle>();
	for (Pair<Integer> left : leftPairs) {
	int y = left.mFirst;
	int height = left.mSecond - left.mFirst;
	for (Pair<Integer> top : topPairs) {
	int x = top.mFirst;
	int width = top.mSecond - top.mFirst;

	rectangles.add(new Rectangle(x, y, width, height));
	}
	}
	return rectangles;
	}

	private Pair<List<Pair<Integer>>> getPatches(int[] pixels, boolean[] startWithPatch) {
	int lastIndex = 1;
	int lastPixel = pixels[1];
	boolean first = true;

	List<Pair<Integer>> fixed = new ArrayList<Pair<Integer>>();
	List<Pair<Integer>> patches = new ArrayList<Pair<Integer>>();

	for (int i = 1; i < pixels.length - 1; i++) {
	int pixel = pixels[i];
	if (pixel != lastPixel) {
	if (lastPixel == 0xFF000000) {
	if (first) startWithPatch[0] = true;
	patches.add(new Pair<Integer>(lastIndex, i));
	} else {
	fixed.add(new Pair<Integer>(lastIndex, i));
	}
	first = false;

	lastIndex = i;
	lastPixel = pixel;
	}
	}
	if (lastPixel == 0xFF000000) {
	if (first) startWithPatch[0] = true;
	patches.add(new Pair<Integer>(lastIndex, pixels.length - 1));
	} else {
	fixed.add(new Pair<Integer>(lastIndex, pixels.length - 1));
	}

	if (patches.size() == 0) {
	patches.add(new Pair<Integer>(1, pixels.length - 1));
	startWithPatch[0] = true;
	fixed.clear();
	}

	return new Pair<List<Pair<Integer>>>(fixed, patches);
	}

	private static void ensure9Patch(BufferedImage image) {
	int width = image.getWidth();
	int height = image.getHeight();
	for (int i = 0; i < width; i++) {
	int pixel = image.getRGB(i, 0);
	if (pixel != 0 && pixel != 0xFF000000) {
	image.setRGB(i, 0, 0);
	}
	pixel = image.getRGB(i, height - 1);
	if (pixel != 0 && pixel != 0xFF000000) {
	image.setRGB(i, height - 1, 0);
	}
	}
	for (int i = 0; i < height; i++) {
	int pixel = image.getRGB(0, i);
	if (pixel != 0 && pixel != 0xFF000000) {
	image.setRGB(0, i, 0);
	}
	pixel = image.getRGB(width - 1, i);
	if (pixel != 0 && pixel != 0xFF000000) {
	image.setRGB(width - 1, i, 0);
	}
	}
	}

	private static BufferedImage convertTo9Patch(BufferedImage image) {
	BufferedImage buffer = GraphicsUtilities.createTranslucentCompatibleImage(
	image.getWidth() + 2, image.getHeight() + 2);

	Graphics2D g2 = buffer.createGraphics();
	g2.drawImage(image, 1, 1, null);
	g2.dispose();

	return buffer;
	}

	static class Pair<E> {
	E mFirst;
	E mSecond;

	Pair(E first, E second) {
	mFirst = first;
	mSecond = second;
	}

	@Override
	public String toString() {
	return "Pair[" + mFirst + ", " + mSecond + "]";
	}
	}
	}