Adds the corner of Polygon.

@param x The x-coordinate of a new added corner.
@param y The y-coordinate of a new added corner.
6516
public void vertex(double x, double y) {
        MODE = LINES;
        this.cornerX.add(x);
        this.cornerY.add(y);
        this.cornerZ.add(0d);
        setNumberOfCorner(this.cornerX.size());
        calcG();
    }
788488
public static UnsignedInteger32 add(UnsignedInteger32 x, UnsignedInteger32 y) {
		return new UnsignedInteger32(x.longValue() + y.longValue());
	}
241319
public void setLastPoint(double x, double y, double z) {
		if (this.numCoords>=3) {
			this.coords[this.numCoords-3] = x;
			this.coords[this.numCoords-2] = y;
			this.coords[this.numCoords-1] = z;
			this.graphicalBounds = null;
			this.logicalBounds = null;
		}
	}
1019913
@ExportConstructor
	public static org.geomajas.geometry.Coordinate constructor(double x, double y) {
		return new org.geomajas.geometry.Coordinate(x, y);
	}
988467
public void vertex(double x, double y, double z) {
        MODE = LINES_3D;
        this.cornerX.add(x);
        this.cornerY.add(y);
        this.cornerZ.add(z);
        setNumberOfCorner(this.cornerX.size());
        calcG();
    }
1002737
public void addObject (int x, int y, Object object)
    {
        Record record = new Record(x, y, object);

        // if this is the very first element, we have to insert it
        // straight away because our binary search algorithm doesn't work
        // on empty arrays
        if (_size == 0) {
            _records[_size++] = record;
            return;
        }

        // figure out where to insert it
        int ipoint = binarySearch(x);

        // expand the records array if necessary
        if (_size >= _records.length) {
            int nsize = _size*2;
            Record[] records = new Record[nsize];
            System.arraycopy(_records, 0, records, 0, _size);
            _records = records;
        }

        // shift everything down
        if (ipoint < _size) {
            System.arraycopy(_records, ipoint, _records, ipoint+1,
                             _size-ipoint);
        }

        // insert the record
        _records[ipoint] = record;
        _size++;
    }
984405
public void setPosition(int x,int y) {
		int cx = (xoffset.getMin() + xoffset.getMax()) / 2;
		int cy = (yoffset.getMin() + yoffset.getMax()) / 2;
		
		int dx = x - cx;
		int dy = y - cy;
		
		xoffset.setMin(xoffset.getMin() + dx);
		xoffset.setMax(xoffset.getMax() + dx);
		yoffset.setMin(yoffset.getMin() + dy);
		yoffset.setMax(yoffset.getMax() + dy);
		
		xoffset.fireUpdated(null);
		yoffset.fireUpdated(null);
	}
1304643
public void setPolygon(java.util.Collection<Point> polygon) {
        if (polygon == null) {
            this.polygon = null;
            return;
        }

        this.polygon = new java.util.ArrayList<Point>(polygon);
    }
401587
public void startPath(double x, double y) {
		Point2D endPoint = new Point2D();
		endPoint.x = x;
		endPoint.y = y;
		startPath(endPoint);
	}
299818
public void setX(float x) {
    	if (x != this.x) {
    		float dx = x - this.x;
	        this.x = x;
	        
	        if ((points == null) || (center == null)) {
	        	checkPoints();
	        }
	        // update the points in the special case
    		for (int i=0;i<points.length/2;i++) {
    			points[i*2] += dx;
    		}
    		center[0] += dx;
    		x += dx;
    		maxX += dx;
    		minX += dx;
	        trianglesDirty = true;
    	}
    }
514622
public void add(double x, double y, int k)
    {
        sx +=x*k;
        sy +=y*k;
        sxy += x*y*k;
        sx2 += x*x*k;
        n+=k;
        if (n < 1)
        {
            throw new IllegalArgumentException("negative count");
        }
    }
792229
public void add (int px, int py) {
        int x1 = Math.min(x, px);
        int x2 = Math.max(x + width, px);
        int y1 = Math.min(y, py);
        int y2 = Math.max(y + height, py);
        setBounds(x1, y1, x2 - x1, y2 - y1);
    }
745891
@Override
	protected void addCoordinateToGeometry(Coordinate newCoordinate) {
		boolean geometryHasCoordinates = geometry.getCoordinates() != null;

		// determine length and coordinates
		int length = geometryHasCoordinates ? geometry.getCoordinates().length : 0;
		Coordinate[] oldCoords = geometryHasCoordinates ? geometry.getCoordinates() : null;
		Coordinate[] newCoords = new Coordinate[length + 1];
		if (geometryHasCoordinates) {
			System.arraycopy(oldCoords, 0, newCoords, 0, length);
		}

		// put new coordinate in right position
		if (newCoords.length < 2) {
			newCoords[length] = newCoordinate;
		} else {
			newCoords[length] = newCoords[length - 1];
			newCoords[length - 1] = newCoordinate;
		}

		// create new geometry
		LinearRing linearRing = factory.createLinearRing(newCoords);
		geometry = factory.createPolygon(linearRing, null);

		// update drawing
		updateTempLineAfterClick();
	}
43062
@Override
	public void setSecondAxis(double x, double y, double z) {
		setSecondAxis(x, y, z, getSecondAxisExtent());
	}
555682
public Vector2i add(int x, int y, Vector2i dest) {
        dest.x = this.x + x;
        dest.y = this.y + y;
        return dest;
    }
1358467
public void addNode (int x, int y, int dir)
    {
        _nodes.add(new PathNode(x, y, dir));
    }
712669
public void set(int x, int y) {
    int offset = y * rowSize + (x / 32);
    bits[offset] |= 1 << (x & 0x1f);
  }