/* * Copyright (C) 2005 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. */ #ifndef EXTRACT_H #define EXTRACT_H #include #include // shamelessly stolen from ResourceTypes.h Android's sources /** * This chunk specifies how to split an image into segments for * scaling. * * There are J horizontal and K vertical segments. These segments divide * the image into J*K regions as follows (where J=4 and K=3): * * F0 S0 F1 S1 * +-----+----+------+-------+ * S2| 0 | 1 | 2 | 3 | * +-----+----+------+-------+ * | | | | | * | | | | | * F2| 4 | 5 | 6 | 7 | * | | | | | * | | | | | * +-----+----+------+-------+ * S3| 8 | 9 | 10 | 11 | * +-----+----+------+-------+ * * Each horizontal and vertical segment is considered to by either * stretchable (marked by the Sx labels) or fixed (marked by the Fy * labels), in the horizontal or vertical axis, respectively. In the * above example, the first is horizontal segment (F0) is fixed, the * next is stretchable and then they continue to alternate. Note that * the segment list for each axis can begin or end with a stretchable * or fixed segment. * * The relative sizes of the stretchy segments indicates the relative * amount of stretchiness of the regions bordered by the segments. For * example, regions 3, 7 and 11 above will take up more horizontal space * than regions 1, 5 and 9 since the horizontal segment associated with * the first set of regions is larger than the other set of regions. The * ratios of the amount of horizontal (or vertical) space taken by any * two stretchable slices is exactly the ratio of their corresponding * segment lengths. * * xDivs and yDivs point to arrays of horizontal and vertical pixel * indices. The first pair of Divs (in either array) indicate the * starting and ending points of the first stretchable segment in that * axis. The next pair specifies the next stretchable segment, etc. So * in the above example xDiv[0] and xDiv[1] specify the horizontal * coordinates for the regions labeled 1, 5 and 9. xDiv[2] and * xDiv[3] specify the coordinates for regions 3, 7 and 11. Note that * the leftmost slices always start at x=0 and the rightmost slices * always end at the end of the image. So, for example, the regions 0, * 4 and 8 (which are fixed along the X axis) start at x value 0 and * go to xDiv[0] and slices 2, 6 and 10 start at xDiv[1] and end at * xDiv[2]. * * The array pointed to by the colors field lists contains hints for * each of the regions. They are ordered according left-to-right and * top-to-bottom as indicated above. For each segment that is a solid * color the array entry will contain that color value; otherwise it * will contain NO_COLOR. Segments that are completely transparent * will always have the value TRANSPARENT_COLOR. * * The PNG chunk type is "npTc". */ struct Res_png_9patch { Res_png_9patch() : wasDeserialized(false), xDivs(NULL), yDivs(NULL), colors(NULL) { } int8_t wasDeserialized; int8_t numXDivs; int8_t numYDivs; int8_t numColors; // These tell where the next section of a patch starts. // For example, the first patch includes the pixels from // 0 to xDivs[0]-1 and the second patch includes the pixels // from xDivs[0] to xDivs[1]-1. // Note: allocation/free of these pointers is left to the caller. int32_t* xDivs; int32_t* yDivs; int32_t paddingLeft, paddingRight; int32_t paddingTop, paddingBottom; enum { // The 9 patch segment is not a solid color. NO_COLOR = 0x00000001, // The 9 patch segment is completely transparent. TRANSPARENT_COLOR = 0x00000000 }; // Note: allocation/free of this pointer is left to the caller. uint32_t* colors; // Deserialize/Unmarshall the patch data static Res_png_9patch* deserialize(const void* data); }; struct Res_png_9patch20 { Res_png_9patch20() : wasDeserialized(false), numXDivs(0), numYDivs(0), numColors(0), xDivsOffset(0), yDivsOffset(0),paddingLeft(0), paddingRight(0), paddingTop(0), paddingBottom(0), colorsOffset(0) { } int8_t wasDeserialized; int8_t numXDivs; int8_t numYDivs; int8_t numColors; // The offset (from the start of this structure) to the xDivs & yDivs // array for this 9patch. To get a pointer to this array, call // getXDivs or getYDivs. Note that the serialized form for 9patches places // the xDivs, yDivs and colors arrays immediately after the location // of the Res_png_9patch struct. uint32_t xDivsOffset; uint32_t yDivsOffset; int32_t paddingLeft, paddingRight; int32_t paddingTop, paddingBottom; enum { // The 9 patch segment is not a solid color. NO_COLOR = 0x00000001, // The 9 patch segment is completely transparent. TRANSPARENT_COLOR = 0x00000000 }; // The offset (from the start of this structure) to the colors array // for this 9patch. uint32_t colorsOffset; // Deserialize/Unmarshall the patch data static Res_png_9patch20* deserialize(void* data); // These tell where the next section of a patch starts. // For example, the first patch includes the pixels from // 0 to xDivs[0]-1 and the second patch includes the pixels // from xDivs[0] to xDivs[1]-1. inline int32_t* getXDivs() const { return reinterpret_cast(reinterpret_cast(this) + xDivsOffset); } inline int32_t* getYDivs() const { return reinterpret_cast(reinterpret_cast(this) + yDivsOffset); } inline uint32_t* getColors() const { return reinterpret_cast(reinterpret_cast(this) + colorsOffset); } } __attribute__((packed)); #endif