- changeText
{
	[self calcWidthHeight];
	[self fillGPathParams];
	gpath->bbox[2] = gpath->bbox[0] + width;
	gpath->bbox[3] = gpath->bbox[1] + height; 
	return self;
}

- changePos
{
	NXPoint delta;

	[self fillGPathParams];
	switch(pathKind){
		case RECT_NODETYPE:
			delta.x = gpath->params[0] - gpath->bbox[0];
			delta.y = gpath->params[1] - gpath->bbox[1];
			break;
		case ROUNDRECT_NODETYPE:
			delta.x = gpath->params[14] - gpath->bbox[0];
			delta.y = gpath->params[15] - gpath->bbox[1];
			break;
		case ELLIPSE_NODETYPE:
			delta.x = gpath->params[10] - gpath->bbox[0];
			delta.y = gpath->params[5] - gpath->bbox[1];
			break;
		case RHOMB_NODETYPE:
			delta.x = gpath->params[0] - gpath->bbox[0] - width / 2;
			delta.y = gpath->params[1] - gpath->bbox[1];
			break;
		case HEXAGON_NODETYPE:
			delta.x = gpath->params[0] - gpath->bbox[0] - placer.hexagon[0];
			delta.y = gpath->params[1] - gpath->bbox[1];
			break;
		default:
			break;	
	}
	gpath->bbox[0] += delta.x;
   	gpath->bbox[1] += delta.y;
    gpath->bbox[2] += delta.x;
    gpath->bbox[3] += delta.y;
	return self;
}

- calcWidthHeight
{
	NXCoord v1,v2;
	NXSize textSize;

	[textCell calcCellSize:&textSize];
	switch(pathKind){
		case RECT_NODETYPE:
			width = textSize.width + 2 * placer.rect[0];
			height = textSize.height + 2 * placer.rect[1];
			break;
		case ROUNDRECT_NODETYPE:
			width = textSize.width + 2 * placer.roundRect[0];
			height = textSize.height + 2 * placer.roundRect[1];
			break;
		case ELLIPSE_NODETYPE:
			height = textSize.height + 2 * placer.ellipse[0];
			v1 = placer.ellipse[0] - placer.ellipse[1];
			v2 = placer.ellipse[0] + height + placer.ellipse[1];
			width = (textSize.width / 2 + placer.ellipse[1]) * height / sqrt(v1 * v2);
			break;
		case RHOMB_NODETYPE:
			height = textSize.height + 2 * placer.rhomb[0];
			v1 = placer.rhomb[0] - placer.rhomb[1];
			width = (textSize.width / 2 + placer.rhomb[1]) * height / v1;
			break;
		case HEXAGON_NODETYPE:
			width = textSize.width + 2 * placer.hexagon[0];
			height = textSize.height + 2 * placer.hexagon[1];
			break;
		default:
			break;
	}
	deltaText.x = (width - textSize.width) / 2;
	deltaText.y = (height - textSize.height) / 2;
	deltaLink.x = width / 2;
	deltaLink.y = height / 2;
	NXSetRect(&textCellFrame, 0, 0, textSize.width, textSize.height);
	return self;
}


static BOOL straddles(const NXPoint *p1, const NXPoint *p2, const NXPoint *p3, const NXPoint *p4)
{
	float crossP1, crossP2;
	
	crossP1 = (p3->x - p1->x) * (p2->y - p1->y) - (p2->x - p1->x) * (p3->y - p1->y); 
	crossP2 = (p4->x - p1->x) * (p2->y - p1->y) - (p2->x - p1->x) * (p4->y - p1->y);
	if((crossP1 > 0 && crossP2 < 0) || (crossP1 < 0 && crossP2 > 0)){
		crossP1 = (p1->x - p3->x) * (p4->y - p3->y) - (p4->x - p3->x) * (p1->y - p3->y); 
		crossP2 = (p2->x - p3->x) * (p4->y - p3->y) - (p4->x - p3->x) * (p2->y - p3->y);
		if((crossP1 > 0 && crossP2 < 0) || (crossP1 < 0 && crossP2 > 0))
			return YES;
		else
			return NO;
	} else
		return NO;
} 

- calcIntersection:(NXPoint *)ip angle:(float *)alpha toPoint:(const NXPoint *)aPoint
{
	NXPoint middle,l1,l2;
	float s,xm,ym,x0,y0,r,ausdruck,a,b;
	
	middle.x = pos.x + width / 2;
	middle.y = pos.y + height / 2;
	if(aPoint->y == middle.y){
		*alpha = 0;
		ip->y = middle.y;
		if(aPoint->x > middle.x)
			ip->x = pos.x + width;
		else
			ip->x = pos.x;
		return self;
	}
	if(aPoint->x == middle.x){
		ip->x = middle.x;
		if(aPoint->y > middle.y){
			ip->y = pos.y + height;
			*alpha = -90;
		} else {
			ip->y = pos.y;
			*alpha = 90;
		}
		return self;
	}
	s = (aPoint->y - middle.y) / (aPoint->x - middle.x);
	*alpha = 57.29577951 * atan(s);
	if(aPoint->y > middle.y){
		if(aPoint->x > middle.x){ 						// 4. quadrant
			switch(pathKind){
				case RECT_NODETYPE:
					l1.x = middle.x;
					l1.y = l2.y = pos.y + height;
					l2.x = pos.x + width;
					if(straddles(&l1, &l2, &middle, aPoint)){
						ip->y = l1.y;
						ip->x = middle.x + (ip->y - middle.y) / s;
					} else {
						ip->x = l2.x;
						ip->y = middle.y + s * (ip->x - middle.x);
					}
				break;
				case ROUNDRECT_NODETYPE:
					l1.x = middle.x;
					l1.y = pos.y + height;
					l2.x = pos.x + width - height / 3;
					l2.y = pos.y + height;
					if(straddles(&l1, &l2, &middle, aPoint)){
						ip->y = l1.y;
						ip->x = middle.x + (ip->y - middle.y) / s;
					} else {
						l1.x = l2.x = pos.x + width;
						l1.y = middle.y;
						l2.y = pos.y + height - height / 3;
						if(straddles(&l1, &l2, &middle, aPoint)){
							ip->x = l2.x;
							ip->y = middle.y + s * (ip->x - middle.x);	
						} else {
							r = height / 3;
							x0 = middle.x;
							y0 = middle.y;
							xm = pos.x + width - r;
							ym = pos.y + height - r;
							ausdruck = (pow(r,2) + pow(r,2)*pow(s,2) - pow(s,2)*pow(xm,2) + 
          								2*pow(s,2)*xm*x0 - pow(s,2)*pow(x0,2) + 2*s*xm*ym - 2*s*x0*ym - 
          								pow(ym,2) - 2*s*xm*y0 + 2*s*x0*y0 + 2*ym*y0 - pow(y0,2));
							ip->x = (xm + pow(s,2)*x0 + s*ym - s*y0 + sqrt(ausdruck))/(1 + pow(s,2));
							ip->y = (s*xm - s*x0 + pow(s,2)*ym + y0 + s*sqrt(ausdruck))/(1 + pow(s,2));
							if(ip->y < ym){
								ip->x = (xm + pow(s,2)*x0 + s*ym - s*y0 - sqrt(ausdruck))/(1 + pow(s,2));
								ip->y = (s*xm - s*x0 + pow(s,2)*ym + y0 - s*sqrt(ausdruck))/(1 + pow(s,2));
							}
						}
					}	 
				break;
				case ELLIPSE_NODETYPE:
					x0 = middle.x;
					y0 = middle.y;
					a = width / 2;
					b = height / 2;
					ip->x = a*b/sqrt(pow(b,2) + pow(a,2)*pow(s,2)) + x0;
					ip->y = (2*a*b*s/sqrt(pow(b,2) + pow(a,2)*pow(s,2)) + 2*y0)/2;
					if(ip->y < y0){
						ip->x = -(a*b/sqrt(pow(b,2) + pow(a,2)*pow(s,2))) + x0;
						ip->y = (-2*a*b*s/sqrt(pow(b,2) + pow(a,2)*pow(s,2)) + 2*y0)/2;
					}
				break;
				case RHOMB_NODETYPE:
					l1.x = middle.x;
					l1.y = pos.y + height;
					l2.x = pos.x + width;
					l2.y = middle.y;
					ausdruck = (l2.y - l1.y) / (l2.x - l1.x);
					ip->x = (middle.y + ausdruck * l1.x - s * middle.x - l1.y) / (ausdruck - s);
					ip->y = middle.y + s * (ip->x - middle.x);
				break;
				case HEXAGON_NODETYPE:
					l1.x = middle.x;
					l1.y = l2.y = pos.y + height;
					l2.x = pos.x + width - placer.hexagon[0];
					if(straddles(&l1, &l2, &middle, aPoint)){
						ip->y = l1.y;
						ip->x = middle.x + (ip->y - middle.y) / s;
					} else {
						l1.x = pos.x + width;
						l1.y = middle.y;
						ausdruck = (l2.y - l1.y) / (l2.x - l1.x);
						ip->x = (middle.y + ausdruck * l1.x - s * middle.x - l1.y) / (ausdruck - s);
						ip->y = middle.y + s * (ip->x - middle.x);
					}
				break;
				default:
				break;
			}
		} else { 										// 3. quadrant
			switch(pathKind){
				case RECT_NODETYPE:
					l1.x = middle.x;
					l1.y = l2.y = pos.y + height;
					l2.x = pos.x;
					if(straddles(&l1, &l2, &middle, aPoint)){
						ip->y = l1.y;
						ip->x = middle.x + (ip->y - middle.y) / s;
					} else {
						ip->x = l2.x;
						ip->y = middle.y + s * (ip->x - middle.x);
					}
				break;
				case ROUNDRECT_NODETYPE:
					l1.x = middle.x;
					l1.y = pos.y + height;
					l2.x = pos.x + height / 3;
					l2.y = pos.y + height;
					if(straddles(&l1, &l2, &middle, aPoint)){
						ip->y = l1.y;
						ip->x = middle.x + (ip->y - middle.y) / s;
					} else {
						l1.x = l2.x = pos.x;
						l1.y = middle.y;
						l2.y = pos.y + height - height / 3;
						if(straddles(&l1, &l2, &middle, aPoint)){
							ip->x = l2.x;
							ip->y = middle.y + s * (ip->x - middle.x);	
						} else {
							r = height / 3;
							x0 = middle.x;
							y0 = middle.y;
							xm = pos.x + r;
							ym = pos.y + height - r;
							ausdruck = (pow(r,2) + pow(r,2)*pow(s,2) - pow(s,2)*pow(xm,2) + 
          								2*pow(s,2)*xm*x0 - pow(s,2)*pow(x0,2) + 2*s*xm*ym - 2*s*x0*ym - 
          								pow(ym,2) - 2*s*xm*y0 + 2*s*x0*y0 + 2*ym*y0 - pow(y0,2));
							ip->x = (xm + pow(s,2)*x0 + s*ym - s*y0 + sqrt(ausdruck))/(1 + pow(s,2));
							ip->y = (s*xm - s*x0 + pow(s,2)*ym + y0 + s*sqrt(ausdruck))/(1 + pow(s,2));
							if(ip->y < ym){
								ip->x = (xm + pow(s,2)*x0 + s*ym - s*y0 - sqrt(ausdruck))/(1 + pow(s,2));
								ip->y = (s*xm - s*x0 + pow(s,2)*ym + y0 - s*sqrt(ausdruck))/(1 + pow(s,2));
							}
						}
					}
				break;
				case ELLIPSE_NODETYPE:
					x0 = middle.x;
					y0 = middle.y;
					a = width / 2;
					b = height / 2;
					ip->x = a*b/sqrt(pow(b,2) + pow(a,2)*pow(s,2)) + x0;
					ip->y = (2*a*b*s/sqrt(pow(b,2) + pow(a,2)*pow(s,2)) + 2*y0)/2;
					if(ip->y < y0){
						ip->x = -(a*b/sqrt(pow(b,2) + pow(a,2)*pow(s,2))) + x0;
						ip->y = (-2*a*b*s/sqrt(pow(b,2) + pow(a,2)*pow(s,2)) + 2*y0)/2;
					}
				break;
				case RHOMB_NODETYPE:
					l1.x = middle.x;
					l1.y = pos.y + height;
					l2.x = pos.x;
					l2.y = middle.y;
					ausdruck = (l2.y - l1.y) / (l2.x - l1.x);
					ip->x = (middle.y + ausdruck * l1.x - s * middle.x - l1.y) / (ausdruck - s);
					ip->y = middle.y + s * (ip->x - middle.x);
				break;
				case HEXAGON_NODETYPE:
					l1.x = middle.x;
					l1.y = l2.y = pos.y + height;
					l2.x = pos.x + placer.hexagon[0];
					if(straddles(&l1, &l2, &middle, aPoint)){
						ip->y = l1.y;
						ip->x = middle.x + (ip->y - middle.y) / s;
					} else {
						l1.x = pos.x;
						l1.y = middle.y;
						ausdruck = (l2.y - l1.y) / (l2.x - l1.x);
						ip->x = (middle.y + ausdruck * l1.x - s * middle.x - l1.y) / (ausdruck - s);
						ip->y = middle.y + s * (ip->x - middle.x);
					}
				break;
				default:
				break;
			}
		}
	} else {
		if(aPoint->x > middle.x){ 						// 1. quadrant
			switch(pathKind){
				case RECT_NODETYPE:
					l1.x = middle.x;
					l1.y = l2.y = pos.y;
					l2.x = pos.x + width;
					if(straddles(&l1, &l2, &middle, aPoint)){
						ip->y = l1.y;
						ip->x = middle.x + (ip->y - middle.y) / s;
					} else {
						ip->x = l2.x;
						ip->y = middle.y + s * (ip->x - middle.x);
					}
				break;
				case ROUNDRECT_NODETYPE:
					l1.x = middle.x;
					l1.y = pos.y;
					l2.x = pos.x + width - height / 3;
					l2.y = pos.y;
					if(straddles(&l1, &l2, &middle, aPoint)){
						ip->y = l1.y;
						ip->x = middle.x + (ip->y - middle.y) / s;
					} else {
						l1.x = l2.x = pos.x + width;
						l1.y = middle.y;
						l2.y = pos.y + height / 3;
						if(straddles(&l1, &l2, &middle, aPoint)){
							ip->x = l2.x;
							ip->y = middle.y + s * (ip->x - middle.x);	
						} else {
							r = height / 3;
							x0 = middle.x;
							y0 = middle.y;
							xm = pos.x + width - r;
							ym = pos.y + r;
							ausdruck = (pow(r,2) + pow(r,2)*pow(s,2) - pow(s,2)*pow(xm,2) + 
          								2*pow(s,2)*xm*x0 - pow(s,2)*pow(x0,2) + 2*s*xm*ym - 2*s*x0*ym - 
          								pow(ym,2) - 2*s*xm*y0 + 2*s*x0*y0 + 2*ym*y0 - pow(y0,2));
							ip->x = (xm + pow(s,2)*x0 + s*ym - s*y0 + sqrt(ausdruck))/(1 + pow(s,2));
							ip->y = (s*xm - s*x0 + pow(s,2)*ym + y0 + s*sqrt(ausdruck))/(1 + pow(s,2));
							if(ip->y > ym){
								ip->x = (xm + pow(s,2)*x0 + s*ym - s*y0 - sqrt(ausdruck))/(1 + pow(s,2));
								ip->y = (s*xm - s*x0 + pow(s,2)*ym + y0 - s*sqrt(ausdruck))/(1 + pow(s,2));
							}
						}
					}
				break;
				case ELLIPSE_NODETYPE:
					x0 = middle.x;
					y0 = middle.y;
					a = width / 2;
					b = height / 2;
					ip->x = a*b/sqrt(pow(b,2) + pow(a,2)*pow(s,2)) + x0;
					ip->y = (2*a*b*s/sqrt(pow(b,2) + pow(a,2)*pow(s,2)) + 2*y0)/2;
					if(ip->y > y0){
						ip->x = -(a*b/sqrt(pow(b,2) + pow(a,2)*pow(s,2))) + x0;
						ip->y = (-2*a*b*s/sqrt(pow(b,2) + pow(a,2)*pow(s,2)) + 2*y0)/2;
					}
				break;
				case RHOMB_NODETYPE:
					l1.x = middle.x;
					l1.y = pos.y;
					l2.x = pos.x + width;
					l2.y = middle.y;
					ausdruck = (l2.y - l1.y) / (l2.x - l1.x);
					ip->x = (middle.y + ausdruck * l1.x - s * middle.x - l1.y) / (ausdruck - s);
					ip->y = middle.y + s * (ip->x - middle.x);
				break;
				case HEXAGON_NODETYPE:
					l1.x = middle.x;
					l1.y = l2.y = pos.y;
					l2.x = pos.x + width - placer.hexagon[0];
					if(straddles(&l1, &l2, &middle, aPoint)){
						ip->y = l1.y;
						ip->x = middle.x + (ip->y - middle.y) / s;
					} else {
						l1.x = pos.x + width;
						l1.y = middle.y;
						ausdruck = (l2.y - l1.y) / (l2.x - l1.x);
						ip->x = (middle.y + ausdruck * l1.x - s * middle.x - l1.y) / (ausdruck - s);
						ip->y = middle.y + s * (ip->x - middle.x);
					}
				break;
				default:
				break;
			}
		} else { 										// 2. quadrant
			switch(pathKind){
				case RECT_NODETYPE:
					l1.x = middle.x;
					l1.y = l2.y = pos.y;
					l2.x = pos.x;
					if(straddles(&l1, &l2, &middle, aPoint)){
						ip->y = l1.y;
						ip->x = middle.x + (ip->y - middle.y) / s;
					} else {
						ip->x = l2.x;
						ip->y = middle.y + s * (ip->x - middle.x);
					}
				break;
				case ROUNDRECT_NODETYPE:
					l1.x = middle.x;
					l1.y = pos.y;
					l2.x = pos.x + height / 3;
					l2.y = pos.y;
					if(straddles(&l1, &l2, &middle, aPoint)){
						ip->y = l1.y;
						ip->x = middle.x + (ip->y - middle.y) / s;
					} else {
						l1.x = l2.x = pos.x;
						l1.y = middle.y;
						l2.y = pos.y + height / 3;
						if(straddles(&l1, &l2, &middle, aPoint)){
							ip->x = l2.x;
							ip->y = middle.y + s * (ip->x - middle.x);	
						} else {
							r = height / 3;
							x0 = middle.x;
							y0 = middle.y;
							xm = pos.x + r;
							ym = pos.y + r;
							ausdruck = (pow(r,2) + pow(r,2)*pow(s,2) - pow(s,2)*pow(xm,2) + 
          								2*pow(s,2)*xm*x0 - pow(s,2)*pow(x0,2) + 2*s*xm*ym - 2*s*x0*ym - 
          								pow(ym,2) - 2*s*xm*y0 + 2*s*x0*y0 + 2*ym*y0 - pow(y0,2));
							ip->x = (xm + pow(s,2)*x0 + s*ym - s*y0 + sqrt(ausdruck))/(1 + pow(s,2));
							ip->y = (s*xm - s*x0 + pow(s,2)*ym + y0 + s*sqrt(ausdruck))/(1 + pow(s,2));
							if(ip->y > ym){
								ip->x = (xm + pow(s,2)*x0 + s*ym - s*y0 - sqrt(ausdruck))/(1 + pow(s,2));
								ip->y = (s*xm - s*x0 + pow(s,2)*ym + y0 - s*sqrt(ausdruck))/(1 + pow(s,2));
							}
						}
					}
				break;
				case ELLIPSE_NODETYPE:
					x0 = middle.x;
					y0 = middle.y;
					a = width / 2;
					b = height / 2;
					ip->x = a*b/sqrt(pow(b,2) + pow(a,2)*pow(s,2)) + x0;
					ip->y = (2*a*b*s/sqrt(pow(b,2) + pow(a,2)*pow(s,2)) + 2*y0)/2;
					if(ip->y > y0){
						ip->x = -(a*b/sqrt(pow(b,2) + pow(a,2)*pow(s,2))) + x0;
						ip->y = (-2*a*b*s/sqrt(pow(b,2) + pow(a,2)*pow(s,2)) + 2*y0)/2;
					}
				break;
				case RHOMB_NODETYPE:
					l1.x = middle.x;
					l1.y = pos.y;
					l2.x = pos.x;
					l2.y = middle.y;
					ausdruck = (l2.y - l1.y) / (l2.x - l1.x);
					ip->x = (middle.y + ausdruck * l1.x - s * middle.x - l1.y) / (ausdruck - s);
					ip->y = middle.y + s * (ip->x - middle.x);
				break;
				case HEXAGON_NODETYPE:
					l1.x = middle.x;
					l1.y = l2.y = pos.y;
					l2.x = pos.x + placer.hexagon[0];
					if(straddles(&l1, &l2, &middle, aPoint)){
						ip->y = l1.y;
						ip->x = middle.x + (ip->y - middle.y) / s;
					} else {
						l1.x = pos.x;
						l1.y = middle.y;
						ausdruck = (l2.y - l1.y) / (l2.x - l1.x);
						ip->x = (middle.y + ausdruck * l1.x - s * middle.x - l1.y) / (ausdruck - s);
						ip->y = middle.y + s * (ip->x - middle.x);
					}
				break;
				default:
				break;
			}
		}
	}
	return self;
}

- (void)_internalMakePathOnPos:(NSPoint)pos
{
	float width, height;
	
	//-----------> calc outer bounds and inner pos from pos and inner size
	switch(shape){
		case RECTANGLE_SHAPE:
			[self moveto:pos.x :pos.y];
			[self rlineto:width :0.0];
			[self rlineto:0.0 :height];
			[self rlineto:-width :0.0];
			[self rlineto:0.0 :-height];
			break;
		case ROUNDED_RECT_SHAPE:
			[self moveto:(pos.x + height / 3)  :pos.y];
			[self arct:(pos.x + width) :pos.y :(pos.x + width) :(pos.y + height) :height / 3];
			[self arct:(pos.x + width) :(pos.y + height) :pos.x :(pos.y + height) :height / 3];
			[self arct:pos.x :(pos.y + height) :pos.x :pos.y : height / 3];
			[self arct:pos.x :pos.y :(pos.x + width) :pos.y :height / 3];
			break;
		case CIRCLE_SHAPE:
			[self moveto:(pos.x + width) :(pos.y + height / 2)];
			[self curveto:(pos.x + width) :(pos.y + height / 2 * 0.445)
						:(pos.x + width / 2 * 1.555)  :pos.y
						:(pos.x + width / 2) :pos.y];
			[self curveto:(pos.x + width / 2 * 0.445) :pos.y
						:pos.x :(pos.y + height / 2 * 0.445)
						:pos.x :(pos.y + height / 2)];
			[self curveto:pos.x :(pos.y + height /2 * 1.555)
						:(pos.x + width / 2 * 0.445) :(pos.y + height)
						:(pos.x + width / 2) :(pos.y + height)];
			[self curveto:(pos.x + width / 2 * 1.555) :(pos.y + height)
						:(pos.x + width) :(pos.y + height / 2 * 1.555)
						:(pos.x + width) :(pos.y + height / 2)];
			break;
		case DIAMOND_SHAPE:
			[self moveto:pos.x + width / 2 :pos.y];
			[self rlineto:width / 2 :height / 2];
			[self rlineto:-width / 2 :height / 2];
			[self rlineto:-width / 2 :-height / 2];
			[self rlineto:width / 2 :-height / 2];
			break;
		case HEXAGON_SHAPE:
			[self moveto:pos.x + placer.hexagon[0] :pos.y];
			[self rlineto:(width - 2 * placer.hexagon[0]) :0];
			[self rlineto:placer.hexagon[0] :height /2];
			[self rlineto:-placer.hexagon[0] :height /2];
			[self rlineto:(- width + 2 * placer.hexagon[0]) :0];
			[self rlineto:-placer.hexagon[0] :-height / 2];
			[self rlineto:placer.hexagon[0] :-height / 2];
			break;
		default:
			break;	
	} 
}

- (void)_internalFillParamsOnPos:(NSPoint)pos
{
	float width, height;
	
	//-----------> calc outer bounds and inner pos from pos and inner size
	// donĀt forget to update bbox
	switch(pathKind){
		case RECTANGLE_SHAPE:
			params[0] = pos.x;
			params[1] = pos.y;
			params[2] = width;
			params[3] = 0.0;
			params[4] = 0.0;
			params[5] = height;
			params[6] = -width;
			params[7] = 0.0;
			params[8] = 0.0;
			params[9] = -height;
			break;
		case ROUNDED_RECT_SHAPE:
			params[0] = pos.x + height / 3;
			params[1] = pos.y;
			params[2] = pos.x + width;
			params[3] = pos.y;
			params[4] = pos.x + width;
			params[5] = pos.y + height;
			params[6] = height / 3;
			params[7] = pos.x + width;
			params[8] = pos.y + height;
			params[9] = pos.x;
			params[10] = pos.y + height;
			params[11] = height / 3;
			params[12] = pos.x;
			params[13] = pos.y + height;
			params[14] = pos.x;
			params[15] = pos.y;
			params[16] = height / 3;
			params[17] = pos.x;
			params[18] = pos.y;
			params[19] = pos.x + width;
			params[20] = pos.y;
			params[21] = height / 3;
			break;
		case CIRCLE_SHAPE:
			params[0] = pos.x + width;
			params[1] = pos.y + height / 2;
			params[2] = pos.x + width;
			params[3] = pos.y + height / 2 * 0.445;
			params[4] = pos.x + width / 2 * 1.555;
			params[5] = pos.y;
			params[6] = pos.x + width / 2; 
			params[7] = pos.y;
			params[8] = pos.x + width / 2 * 0.445;
			params[9] = pos.y;
			params[10] = pos.x;
			params[11] = pos.y + height / 2 * 0.445;
			params[12] = pos.x;
			params[13] = pos.y + height / 2;
			params[14] = pos.x;
			params[15] = pos.y + height /2 * 1.555;
			params[16] = pos.x + width / 2 * 0.445;
			params[17] = pos.y + height;
			params[18] = pos.x + width / 2;
			params[19] = pos.y + height;
			params[20] = pos.x + width / 2 * 1.555;
			params[21] = pos.y + height;
			params[22] = pos.x + width;
			params[23] = pos.y + height / 2 * 1.555;
			params[24] = pos.x + width;
			params[25] = pos.y + height / 2;
			break;
		case DIAMOND_SHAPE:
			params[0] = pos.x + width / 2;
			params[1] = pos.y;
			params[2] = width / 2;
			params[3] = height / 2;
			params[4] = -width / 2;
			params[5] = height / 2;
			params[6] = -width / 2;
			params[7] = -height / 2;
			params[8] =width / 2;
			params[9] = -height / 2;
			break;
		case HEXAGON_SHAPE:
			params[0] = pos.x + placer.hexagon[0];
			params[1] = pos.y;
			params[2] = width - 2 * placer.hexagon[0];
			params[3] = 0;
			params[4] = placer.hexagon[0];
			params[5] = height / 2;
			params[6] = -placer.hexagon[0];
			params[7] = height / 2;
			params[8] =-width + 2 * placer.hexagon[0];
			params[9] = 0;
			params[10] =-placer.hexagon[0];
			params[11] = -height / 2;
			params[12] = placer.hexagon[0];
			params[13] = -height / 2;
			break;
		default:
			break;	
	}
}