void POSCALL nos_regDelSysKey(NOSREGTYPE_t type, NOSGENERICHANDLE_t handle,
REGELEM_t re)
{
REGELEM_t rl = REEUNKNOWN;
posSemaGet(reglist_sema_g);
if (re == NULL)
{
for (re = reglist_syselem_g[type], rl = NULL;
re != NULL; rl = re, re = re->next)
{
if (!IS_DELETED(re) && (re->handle.generic == handle))
break;
}
}
if (re != NULL)
{
if (!IS_DELETED(re))
{
MARK_DELETED(re);
n_remove(re, rl, type);
}
}
posSemaSignal(reglist_sema_g);
}
VAR_t POSCALL nosRegDel(const char *keyname)
{
REGELEM_t re, rl;
VAR_t i;
posSemaGet(reglist_sema_g);
for (re = reglist_syselem_g[REGTYPE_USER], rl = NULL;
re != NULL; rl = re, re = re->next)
{
if (!IS_DELETED(re))
{
for (i=0; i<NOS_MAX_REGKEYLEN; ++i)
{
if (re->name[i] != keyname[i])
break;
if ((keyname[i] == 0) || (i == NOS_MAX_REGKEYLEN-1))
{
MARK_DELETED(re);
n_remove(re, rl, REGTYPE_USER);
posSemaSignal(reglist_sema_g);
return E_OK;
}
}
}
}
posSemaSignal(reglist_sema_g);
return -E_FAIL;
}
static cairo_bool_t
_cairo_contour_simplify_chain (cairo_contour_t *contour, const double tolerance,
const cairo_contour_iter_t *first,
const cairo_contour_iter_t *last)
{
cairo_contour_iter_t iter, furthest;
uint64_t max_error;
int x0, y0;
int nx, ny;
int count;
iter = *first;
iter_next (&iter);
if (iter_equal (&iter, last))
return FALSE;
x0 = first->point->x;
y0 = first->point->y;
nx = last->point->y - y0;
ny = x0 - last->point->x;
count = 0;
max_error = 0;
do {
cairo_point_t *p = iter.point;
if (! DELETED(p)) {
uint64_t d = (uint64_t)nx * (x0 - p->x) + (uint64_t)ny * (y0 - p->y);
if (d * d > max_error) {
max_error = d * d;
furthest = iter;
}
count++;
}
iter_next (&iter);
} while (! iter_equal (&iter, last));
if (count == 0)
return FALSE;
if (max_error > tolerance * ((uint64_t)nx * nx + (uint64_t)ny * ny)) {
cairo_bool_t simplified;
simplified = FALSE;
simplified |= _cairo_contour_simplify_chain (contour, tolerance,
first, &furthest);
simplified |= _cairo_contour_simplify_chain (contour, tolerance,
&furthest, last);
return simplified;
} else {
iter = *first;
iter_next (&iter);
do {
MARK_DELETED (iter.point);
iter_next (&iter);
} while (! iter_equal (&iter, last));
return TRUE;
}
}
void
_cairo_contour_simplify (cairo_contour_t *contour, double tolerance)
{
cairo_contour_chain_t *chain;
cairo_point_t *last = NULL;
cairo_contour_iter_t iter, furthest;
cairo_bool_t simplified;
uint64_t max = 0;
int i;
if (contour->chain.num_points <= 2)
return;
tolerance = tolerance * CAIRO_FIXED_ONE;
tolerance *= tolerance;
/* stage 1: vertex reduction */
for (chain = &contour->chain; chain; chain = chain->next) {
for (i = 0; i < chain->num_points; i++) {
if (last == NULL ||
point_distance_sq (last, &chain->points[i]) > tolerance) {
last = &chain->points[i];
} else {
MARK_DELETED (&chain->points[i]);
}
}
}
/* stage2: polygon simplification using Douglas-Peucker */
simplified = FALSE;
do {
last = &contour->chain.points[0];
iter_init (&furthest, contour);
max = 0;
for (chain = &contour->chain; chain; chain = chain->next) {
for (i = 0; i < chain->num_points; i++) {
uint64_t d;
if (DELETED (&chain->points[i]))
continue;
d = point_distance_sq (last, &chain->points[i]);
if (d > max) {
furthest.chain = chain;
furthest.point = &chain->points[i];
max = d;
}
}
}
assert (max);
simplified = FALSE;
iter_init (&iter, contour);
simplified |= _cairo_contour_simplify_chain (contour, tolerance,
&iter, &furthest);
iter_init_last (&iter, contour);
if (! iter_equal (&furthest, &iter))
simplified |= _cairo_contour_simplify_chain (contour, tolerance,
&furthest, &iter);
} while (simplified);
iter_init (&iter, contour);
for (chain = &contour->chain; chain; chain = chain->next) {
int num_points = chain->num_points;
chain->num_points = 0;
for (i = 0; i < num_points; i++) {
if (! DELETED(&chain->points[i])) {
if (iter.point != &chain->points[i])
*iter.point = chain->points[i];
iter.chain->num_points++;
iter_next (&iter);
}
}
}
if (iter.chain) {
cairo_contour_chain_t *next;
for (chain = iter.chain->next; chain; chain = next) {
next = chain->next;
free (chain);
}
iter.chain->next = NULL;
contour->tail = iter.chain;
}
}