qt-everywhere-src-5.14.1/qtbase/src/3rdparty/android/extract.h - orbit - Git at Google

 /*
  * 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 <cstdint>
 #include <cstring>
 // 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<int32_t*>(reinterpret_cast<uintptr_t>(this) + xDivsOffset);
     }
     inline int32_t* getYDivs() const {
         return reinterpret_cast<int32_t*>(reinterpret_cast<uintptr_t>(this) + yDivsOffset);
     }
     inline uint32_t* getColors() const {
         return reinterpret_cast<uint32_t*>(reinterpret_cast<uintptr_t>(this) + colorsOffset);
     }

 } __attribute__((packed));

 #endif
	/*
	* 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 <cstdint>
	#include <cstring>
	// 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<int32_t*>(reinterpret_cast<uintptr_t>(this) + xDivsOffset);
	}
	inline int32_t* getYDivs() const {
	return reinterpret_cast<int32_t*>(reinterpret_cast<uintptr_t>(this) + yDivsOffset);
	}
	inline uint32_t* getColors() const {
	return reinterpret_cast<uint32_t*>(reinterpret_cast<uintptr_t>(this) + colorsOffset);
	}

	} __attribute__((packed));

	#endif