bool AttrList_setItem(AttrList l, String key, int v){
bool retVal = false;
int idx = -1;
size_t i;
String tmpKey;
idx = getIndex(l);
if(idx >= 0){
if(!keyExists(l, key)){
if(attrListPool[idx].length == (attrListPool[idx].size - 1)){
growList(idx, (attrListPool[idx].size * 2));
}
for(i = 0; i < attrListPool[idx].size; ++i){
if(attrListPool[idx].keys[i] == INVALID_STRING){
break;
}
}
tmpKey = new_String(NULL);
if(tmpKey != INVALID_STRING && String_copyString(tmpKey, key)){
attrListPool[idx].keys[i] = tmpKey;
attrListPool[idx].data[i] = v;
attrListPool[idx].length++;
retVal = true;
}
}
}
return retVal;
}
/*
* Insert an item to the list at a specified position. We insert before "index".
*/
int ejsInsertItemAtPos(MprCtx ctx, EjsList *lp, int index, cvoid *item)
{
void **items;
int i;
mprAssert(lp);
mprAssert(lp->length >= 0);
if (lp->length >= CAPACITY(lp->items)) {
if (growList(ctx, lp, 1) < 0) {
return MPR_ERR_TOO_MANY;
}
}
/*
* Copy up items to make room to insert
*/
items = lp->items;
for (i = lp->length; i > index; i--) {
items[i] = items[i - 1];
}
lp->items[index] = (void*) item;
lp->length++;
return index;
}
/*
=======================================================================================
=======================================================================================
*/
PixelChain& PixelChain::operator=(PixelChain &rhs)
{
if (this != &rhs) {
if (_pt) {
delete [] _pt;
_pt = NULL;
}
_maxPoints = 0;
_numPoints = 0;
if (rhs._numPoints > 0) {
if (growList(rhs._numPoints)) {
memcpy(_pt, rhs._pt, rhs._numPoints * sizeof(_pt[0]));
_numPoints = rhs._numPoints;
}
}
_maxFeretAngle = rhs._maxFeretAngle;
_maxFeretDiameter = rhs._maxFeretDiameter;
_boundingRect = rhs._boundingRect;
}
return *this;
}
void LinePath::createHeadLines() {
m_HeadList.clear();
QCanvas * canvas = getCanvas();
switch( getAssocType() ) {
case Uml::at_Activity:
case Uml::at_State:
case Uml::at_Dependency:
case Uml::at_UniAssociation:
case Uml::at_Relationship:
growList(m_HeadList, 2);
break;
case Uml::at_Generalization:
case Uml::at_Realization:
growList(m_HeadList, 3);
m_pClearPoly = new QCanvasPolygon( canvas );
m_pClearPoly -> setVisible( true );
m_pClearPoly -> setBrush( QBrush( Qt::white ) );
m_pClearPoly -> setZ( -1 );
break;
case Uml::at_Composition:
case Uml::at_Aggregation:
growList(m_HeadList, 4);
m_pClearPoly = new QCanvasPolygon( canvas );
m_pClearPoly -> setVisible( true );
if( getAssocType() == Uml::at_Aggregation )
m_pClearPoly -> setBrush( QBrush( Qt::white ) );
else
m_pClearPoly -> setBrush( QBrush( getLineColor() ) );
m_pClearPoly -> setZ( -1 );
break;
case Uml::at_Containment:
growList(m_HeadList, 1);
if (!m_pCircle) {
m_pCircle = new Circle( canvas, 6 );
m_pCircle->show();
m_pCircle->setPen( QPen( getLineColor(), getLineWidth() ) );
}
break;
default:
break;
}
m_bHeadCreated = true;
}
/*
=======================================================================================
=======================================================================================
*/
bool PixelChain::load(double max_feret_angle, double max_feret_diameter,
int left, int right, int top, int bottom,
int num_points, long *chain_id, long *x, long *y)
{
_numPoints = 0;
if (num_points < 1) {
return true;
}
if (!chain_id || !x || !y) {
return false;
}
// we only care about the outer chain, chain_id == 1
for (_numPoints = 0; _numPoints < num_points; _numPoints++) {
if (chain_id[_numPoints] != 1) {
break;
}
}
if (_numPoints == 0) {
// should never happen
return false;
}
if (_numPoints > _maxPoints) {
if (!growList(_numPoints)) {
return false;
}
}
for (int i = 0; i < _numPoints; i++) {
_pt[i].x = x[i];
_pt[i].y = y[i];
}
_maxFeretAngle = max_feret_angle;
_maxFeretDiameter = max_feret_diameter;
_boundingRect.left = left;
_boundingRect.right = right;
_boundingRect.top = top;
_boundingRect.bottom = bottom;
return true;
}
/*
* Add an item to the list and return the item index.
*/
int ejsAddItem(MprCtx ctx, EjsList *lp, cvoid *item)
{
int index, capacity;
mprAssert(lp);
mprAssert(lp->length >= 0);
capacity = CAPACITY(lp->items);
mprAssert(capacity >= 0);
if (lp->items == 0 || lp->length >= capacity) {
if (growList(ctx, lp, 1) < 0) {
return MPR_ERR_TOO_MANY;
}
}
index = lp->length++;
lp->items[index] = (void*) item;
return index;
}
/*
* Change the item in the list at index. Return the old item.
*/
void *ejsSetItem(MprCtx ctx, EjsList *lp, int index, cvoid *item)
{
void *old;
mprAssert(lp);
mprAssert(lp->length >= 0);
if (index >= lp->length) {
lp->length = index + 1;
}
capacity = CAPACITY(lp->items);
if (lp->length > capacity) {
if (growList(ctx, lp, lp->length - capacity) < 0) {
return 0;
}
}
old = lp->items[index];
lp->items[index] = (void*) item;
return old;
}
/*
* Store the list of segments for a single level in the SEXP
* list that will be returned to the user
*/
static
int addContourLines(double *x, int nx, double *y, int ny,
double *z, double zc, double atom,
SEGP* segmentDB, int nlines, SEXP container)
{
double xend, yend;
int i, ii, j, jj, ns, dir, nc;
SEGP seglist, seg, s, start, end;
SEXP ctr, level, xsxp, ysxp, names;
/* Begin following contours. */
/* 1. Grab a segment */
/* 2. Follow its tail */
/* 3. Follow its head */
/* 4. Save the contour */
for (i = 0; i < nx - 1; i++)
for (j = 0; j < ny - 1; j++) {
while ((seglist = segmentDB[i + j * nx])) {
ii = i; jj = j;
start = end = seglist;
segmentDB[i + j * nx] = seglist->next;
xend = seglist->x1;
yend = seglist->y1;
while ((dir = ctr_segdir(xend, yend, x, y,
&ii, &jj, nx, ny))) {
segmentDB[ii + jj * nx]
= ctr_segupdate(xend, yend, dir, TRUE,/* = tail */
segmentDB[ii + jj * nx], &seg);
if (!seg) break;
end->next = seg;
end = seg;
xend = end->x1;
yend = end->y1;
}
end->next = nullptr; /* <<< new for 1.2.3 */
ii = i; jj = j;
xend = seglist->x0;
yend = seglist->y0;
while ((dir = ctr_segdir(xend, yend, x, y,
&ii, &jj, nx, ny))) {
segmentDB[ii + jj * nx]
= ctr_segupdate(xend, yend, dir, FALSE,/* ie. head */
segmentDB[ii+jj*nx], &seg);
if (!seg) break;
seg->next = start;
start = seg;
xend = start->x0;
yend = start->y0;
}
/* ns := #{segments of polyline} -- need to allocate */
s = start;
ns = 0;
/* max_contour_segments: prevent inf.loop (shouldn't be needed) */
while (s && ns < CXXRCONSTRUCT(int, max_contour_segments)) {
ns++;
s = s->next;
}
if(ns == CXXRCONSTRUCT(int, max_contour_segments))
warning(_("contour(): circular/long seglist -- set %s > %d?"),
"options(\"max.contour.segments\")", max_contour_segments);
/*
* "write" the contour locations into the list of contours
*/
ctr = PROTECT(allocVector(VECSXP, 3));
level = PROTECT(allocVector(REALSXP, 1));
xsxp = PROTECT(allocVector(REALSXP, ns + 1));
ysxp = PROTECT(allocVector(REALSXP, ns + 1));
REAL(level)[0] = zc;
SET_VECTOR_ELT(ctr, CONTOUR_LIST_LEVEL, level);
s = start;
REAL(xsxp)[0] = s->x0;
REAL(ysxp)[0] = s->y0;
ns = 1;
while (s->next && ns < CXXRCONSTRUCT(int, max_contour_segments)) {
s = s->next;
REAL(xsxp)[ns] = s->x0;
REAL(ysxp)[ns++] = s->y0;
}
REAL(xsxp)[ns] = s->x1;
REAL(ysxp)[ns] = s->y1;
SET_VECTOR_ELT(ctr, CONTOUR_LIST_X, xsxp);
SET_VECTOR_ELT(ctr, CONTOUR_LIST_Y, ysxp);
/*
* Set the names attribute for the contour
* So that users can extract components using
* meaningful names
*/
PROTECT(names = allocVector(STRSXP, 3));
SET_STRING_ELT(names, 0, mkChar("level"));
SET_STRING_ELT(names, 1, mkChar("x"));
SET_STRING_ELT(names, 2, mkChar("y"));
setAttrib(ctr, R_NamesSymbol, names);
/*
* We're about to add another line to the list ...
*/
nlines += 1;
nc = LENGTH(VECTOR_ELT(container, 0));
if (nlines == nc)
/* Where does this get UNPROTECTed? */
SET_VECTOR_ELT(container, 0,
growList(VECTOR_ELT(container, 0)));
SET_VECTOR_ELT(VECTOR_ELT(container, 0), nlines - 1, ctr);
UNPROTECT(5);
}
}
return nlines;
}
void LinePath::setupParallelLine() {
m_ParallelList.clear();
growList(m_ParallelList, 3);
m_bParallelLineCreated = true;
}
