/**

 * 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 */