267 lines
7.6 KiB
C
267 lines
7.6 KiB
C
/*
|
|
* Licensed to the Apache Software Foundation (ASF) under one
|
|
* or more contributor license agreements. See the NOTICE file
|
|
* distributed with this work for additional information
|
|
* regarding copyright ownership. The ASF licenses this file
|
|
* to you 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.
|
|
*/
|
|
|
|
#include "config.h"
|
|
#include "common/rect.h"
|
|
|
|
void guac_common_rect_init(guac_common_rect* rect, int x, int y, int width, int height) {
|
|
rect->x = x;
|
|
rect->y = y;
|
|
rect->width = width;
|
|
rect->height = height;
|
|
}
|
|
|
|
void guac_common_rect_extend(guac_common_rect* rect, const guac_common_rect* min) {
|
|
|
|
/* Calculate extents of existing dirty rect */
|
|
int left = rect->x;
|
|
int top = rect->y;
|
|
int right = left + rect->width;
|
|
int bottom = top + rect->height;
|
|
|
|
/* Calculate missing extents of given new rect */
|
|
int min_left = min->x;
|
|
int min_top = min->y;
|
|
int min_right = min_left + min->width;
|
|
int min_bottom = min_top + min->height;
|
|
|
|
/* Update minimums */
|
|
if (min_left < left) left = min_left;
|
|
if (min_top < top) top = min_top;
|
|
if (min_right > right) right = min_right;
|
|
if (min_bottom > bottom) bottom = min_bottom;
|
|
|
|
/* Commit rect */
|
|
guac_common_rect_init(rect, left, top, right - left, bottom - top);
|
|
|
|
}
|
|
|
|
void guac_common_rect_constrain(guac_common_rect* rect, const guac_common_rect* max) {
|
|
|
|
/* Calculate extents of existing dirty rect */
|
|
int left = rect->x;
|
|
int top = rect->y;
|
|
int right = left + rect->width;
|
|
int bottom = top + rect->height;
|
|
|
|
/* Calculate missing extents of given new rect */
|
|
int max_left = max->x;
|
|
int max_top = max->y;
|
|
int max_right = max_left + max->width;
|
|
int max_bottom = max_top + max->height;
|
|
|
|
/* Update maximums */
|
|
if (max_left > left) left = max_left;
|
|
if (max_top > top) top = max_top;
|
|
if (max_right < right) right = max_right;
|
|
if (max_bottom < bottom) bottom = max_bottom;
|
|
|
|
/* Commit rect */
|
|
guac_common_rect_init(rect, left, top, right - left, bottom - top);
|
|
|
|
}
|
|
|
|
int guac_common_rect_expand_to_grid(int cell_size, guac_common_rect* rect,
|
|
const guac_common_rect* max_rect) {
|
|
|
|
/* Invalid cell_size received */
|
|
if (cell_size <= 0)
|
|
return -1;
|
|
|
|
/* Nothing to do */
|
|
if (cell_size == 1)
|
|
return 0;
|
|
|
|
/* Calculate how much the rectangle must be adjusted to fit within the
|
|
* given cell size. */
|
|
int dw = cell_size - rect->width % cell_size;
|
|
int dh = cell_size - rect->height % cell_size;
|
|
|
|
int dx = dw / 2;
|
|
int dy = dh / 2;
|
|
|
|
/* Set initial extents of adjusted rectangle. */
|
|
int top = rect->y - dy;
|
|
int left = rect->x - dx;
|
|
int bottom = top + rect->height + dh;
|
|
int right = left + rect->width + dw;
|
|
|
|
/* The max rectangle */
|
|
int max_left = max_rect->x;
|
|
int max_top = max_rect->y;
|
|
int max_right = max_left + max_rect->width;
|
|
int max_bottom = max_top + max_rect->height;
|
|
|
|
/* If the adjusted rectangle has sides beyond the max rectangle, or is larger
|
|
* in any direction; shift or adjust the rectangle while trying to fit in
|
|
* the grid */
|
|
|
|
/* Adjust left/right */
|
|
if (right > max_right) {
|
|
|
|
/* shift to left */
|
|
dw = right - max_right;
|
|
right -= dw;
|
|
left -= dw;
|
|
|
|
/* clamp left if too far */
|
|
if (left < max_left) {
|
|
left = max_left;
|
|
}
|
|
}
|
|
else if (left < max_left) {
|
|
|
|
/* shift to right */
|
|
dw = max_left - left;
|
|
left += dw;
|
|
right += dw;
|
|
|
|
/* clamp right if too far */
|
|
if (right > max_right) {
|
|
right = max_right;
|
|
}
|
|
}
|
|
|
|
/* Adjust top/bottom */
|
|
if (bottom > max_bottom) {
|
|
|
|
/* shift up */
|
|
dh = bottom - max_bottom;
|
|
bottom -= dh;
|
|
top -= dh;
|
|
|
|
/* clamp top if too far */
|
|
if (top < max_top) {
|
|
top = max_top;
|
|
}
|
|
}
|
|
else if (top < max_top) {
|
|
|
|
/* shift down */
|
|
dh = max_top - top;
|
|
top += dh;
|
|
bottom += dh;
|
|
|
|
/* clamp bottom if too far */
|
|
if (bottom > max_bottom) {
|
|
bottom = max_bottom;
|
|
}
|
|
}
|
|
|
|
/* Commit rect */
|
|
guac_common_rect_init(rect, left, top, right - left, bottom - top);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
int guac_common_rect_intersects(const guac_common_rect* rect,
|
|
const guac_common_rect* other) {
|
|
|
|
/* Empty (no intersection) */
|
|
if (other->x + other->width < rect->x || rect->x + rect->width < other->x ||
|
|
other->y + other->height < rect->y || rect->y + rect->height < other->y) {
|
|
return 0;
|
|
}
|
|
/* Complete */
|
|
else if (other->x <= rect->x && (other->x + other->width) >= (rect->x + rect->width) &&
|
|
other->y <= rect->y && (other->y + other->height) >= (rect->y + rect->height)) {
|
|
return 2;
|
|
}
|
|
/* Partial intersection */
|
|
return 1;
|
|
|
|
}
|
|
|
|
int guac_common_rect_clip_and_split(guac_common_rect* rect,
|
|
const guac_common_rect* hole, guac_common_rect* split_rect) {
|
|
|
|
/* Only continue if the rectangles intersects */
|
|
if (!guac_common_rect_intersects(rect, hole))
|
|
return 0;
|
|
|
|
int top, left, bottom, right;
|
|
|
|
/* Clip and split top */
|
|
if (rect->y < hole->y) {
|
|
top = rect->y;
|
|
left = rect->x;
|
|
bottom = hole->y;
|
|
right = rect->x + rect->width;
|
|
guac_common_rect_init(split_rect, left, top, right - left, bottom - top);
|
|
|
|
/* Re-initialize original rect */
|
|
top = hole->y;
|
|
bottom = rect->y + rect->height;
|
|
guac_common_rect_init(rect, left, top, right - left, bottom - top);
|
|
|
|
return 1;
|
|
}
|
|
|
|
/* Clip and split left */
|
|
else if (rect->x < hole->x) {
|
|
top = rect->y;
|
|
left = rect->x;
|
|
bottom = rect->y + rect->height;
|
|
right = hole->x;
|
|
guac_common_rect_init(split_rect, left, top, right - left, bottom - top);
|
|
|
|
/* Re-initialize original rect */
|
|
left = hole->x;
|
|
right = rect->x + rect->width;
|
|
guac_common_rect_init(rect, left, top, right - left, bottom - top);
|
|
|
|
return 1;
|
|
}
|
|
|
|
/* Clip and split bottom */
|
|
else if (rect->y + rect->height > hole->y + hole->height) {
|
|
top = hole->y + hole->height;
|
|
left = rect->x;
|
|
bottom = rect->y + rect->height;
|
|
right = rect->x + rect->width;
|
|
guac_common_rect_init(split_rect, left, top, right - left, bottom - top);
|
|
|
|
/* Re-initialize original rect */
|
|
top = rect->y;
|
|
bottom = hole->y + hole->height;
|
|
guac_common_rect_init(rect, left, top, right - left, bottom - top);
|
|
|
|
return 1;
|
|
}
|
|
|
|
/* Clip and split right */
|
|
else if (rect->x + rect->width > hole->x + hole->width) {
|
|
top = rect->y;
|
|
left = hole->x + hole->width;
|
|
bottom = rect->y + rect->height;
|
|
right = rect->x + rect->width;
|
|
guac_common_rect_init(split_rect, left, top, right - left, bottom - top);
|
|
|
|
/* Re-initialize original rect */
|
|
left = rect->x;
|
|
right = hole->x + hole->width;
|
|
guac_common_rect_init(rect, left, top, right - left, bottom - top);
|
|
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|