/**

 * Copyright © 2014 Thincast Technologies GmbH

 * Copyright © 2014 Hardening <contact@hardening-consulting.com>

 *

 * Permission to use, copy, modify, distribute, and sell this software and

 * its documentation for any purpose is hereby granted without fee, provided

 * that the above copyright notice appear in all copies and that both that

 * copyright notice and this permission notice appear in supporting

 * documentation, and that the name of the copyright holders not be used in

 * advertising or publicity pertaining to distribution of the software

 * without specific, written prior permission.  The copyright holders make

 * no representations about the suitability of this software for any

 * purpose.  It is provided "as is" without express or implied warranty.

 *

 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS

 * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND

 * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY

 * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER

 * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF

 * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN

 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

 */

#ifndef FREERDP_CODEC_REGION_H

#define FREERDP_CODEC_REGION_H

#include <freerdp/api.h>

#include <freerdp/types.h>

#ifdef __cplusplus

extern "C"

{

#endif

	struct _REGION16_DATA;

	typedef struct _REGION16_DATA REGION16_DATA;

	/**

	 * @brief

	 */

	struct _REGION16

	{

		RECTANGLE_16 extents;

		REGION16_DATA* data;

	};

	typedef struct _REGION16 REGION16;

	/** computes if two rectangles are equal

	 * @param r1 first rectangle

	 * @param r2 second rectangle

	 * @return if the two rectangles are equal

	 */

	FREERDP_API BOOL rectangles_equal(const RECTANGLE_16* r1, const RECTANGLE_16* r2);

	/** computes if two rectangles intersect

	 * @param r1 first rectangle

	 * @param r2 second rectangle

	 * @return if the two rectangles intersect

	 */

	FREERDP_API BOOL rectangles_intersects(const RECTANGLE_16* r1, const RECTANGLE_16* r2);

	/** computes the intersection of two rectangles

	 * @param r1 first rectangle

	 * @param r2 second rectangle

	 * @param dst resulting intersection

	 * @return if the two rectangles intersect

	 */

	FREERDP_API BOOL rectangles_intersection(const RECTANGLE_16* r1, const RECTANGLE_16* r2,

	                                         RECTANGLE_16* dst);

	/** initialize a region16

	 * @param region the region to initialise

	 */

	FREERDP_API void region16_init(REGION16* region);

	/** @return the number of rectangles of this region16 */

	FREERDP_API int region16_n_rects(const REGION16* region);

	/** returns a pointer to rectangles and the number of rectangles in this region.

	 * nbRects can be set to NULL if not interested in the number of rectangles.

	 * @param region the input region

	 * @param nbRects if non-NULL returns the number of rectangles

	 * @return a pointer on the rectangles

	 */

	FREERDP_API const RECTANGLE_16* region16_rects(const REGION16* region, UINT32* nbRects);

	/** @return the extents rectangle of this region */

	FREERDP_API const RECTANGLE_16* region16_extents(const REGION16* region);

	/** returns if the rectangle is empty

	 * @param rect

	 * @return if the rectangle is empty

	 */

	FREERDP_API BOOL rectangle_is_empty(const RECTANGLE_16* rect);

	/** returns if the region is empty

	 * @param region

	 * @return if the region is empty

	 */

	FREERDP_API BOOL region16_is_empty(const REGION16* region);

	/** clears the region, the region is resetted to a (0,0,0,0) region

	 * @param region

	 */

	FREERDP_API void region16_clear(REGION16* region);

	/** dumps the region on stderr

	 * @param region the region to dump

	 */

	FREERDP_API void region16_print(const REGION16* region);

	/** copies the region to another region

	 * @param dst destination region

	 * @param src source region

	 * @return if the operation was successful (false meaning out-of-memory)

	 */

	FREERDP_API BOOL region16_copy(REGION16* dst, const REGION16* src);

	/** adds a rectangle in src and stores the resulting region in dst

	 * @param dst destination region

	 * @param src source region

	 * @param rect the rectangle to add

	 * @return if the operation was successful (false meaning out-of-memory)

	 */

	FREERDP_API BOOL region16_union_rect(REGION16* dst, const REGION16* src,

	                                     const RECTANGLE_16* rect);

	/** returns if a rectangle intersects the region

	 * @param src the region

	 * @param arg2 the rectangle

	 * @return if region and rectangle intersect

	 */

	FREERDP_API BOOL region16_intersects_rect(const REGION16* src, const RECTANGLE_16* arg2);

	/** computes the intersection between a region and a rectangle

	 * @param dst destination region

	 * @param src the source region

	 * @param arg2 the rectangle that intersects

	 * @return if the operation was successful (false meaning out-of-memory)

	 */

	FREERDP_API BOOL region16_intersect_rect(REGION16* dst, const REGION16* src,

	                                         const RECTANGLE_16* arg2);

	/** release internal data associated with this region

	 * @param region the region to release

	 */

	FREERDP_API void region16_uninit(REGION16* region);

#ifdef __cplusplus

}

#endif

#endif /* FREERDP_CODEC_REGION_H */