* is created if necessary. The implementation of this interface may     * choose to return the same array or a new one, depending on what is more     * efficient. Therefore, the data array in <tt>blk</tt> prior to the     * method call should not be considered to contain the returned data, a     * new array may have been created. Instead, get the array from     * <tt>blk</tt> after the method has returned.     *     * <P>The returned data may have its 'progressive' attribute set. In this     * case the returned data is only an approximation of the "final" data.     *     * @param blk Its coordinates and dimensions specify the area to return,     * relative to the current tile. Some fields in this object are modified     * to return the data.     *     * @param c The index of the component from which to get the data.     *     * @return The requested DataBlk     *     * @see #getCompData     * */    public final DataBlk getInternCompData(DataBlk blk, int c) {        // Check that block is inside tile        if (blk.ulx < 0 || blk.uly < 0 ||             blk.ulx+blk.w > bw[c] || blk.uly+blk.h > bh[c]) {            throw new IllegalArgumentException("Block is outside the tile");        }        // Translate to the sources coordinates        blk.ulx += iulx[c];        blk.uly += iuly[c];        blk = src.getInternCompData(blk,c);        // Translate back to the tiled coordinates        blk.ulx -= iulx[c];        blk.uly -= iuly[c];	return blk;    }    /**     * Returns, in the blk argument, a block of image data containing the     * specifed rectangular area, in the specified component. The data is     * returned, as a copy of the internal data, therefore the returned data     * can be modified "in place".     *     * <P>The rectangular area to return is specified by the 'ulx', 'uly', 'w'     * and 'h' members of the 'blk' argument, relative to the current     * tile. These members are not modified by this method. The 'offset' of     * the returned data is 0, and the 'scanw' is the same as the block's     * width. See the 'DataBlk' class.     *     * <P>This method, in general, is less efficient than the     * 'getInternCompData()' method since, in general, it copies the     * data. However if the array of returned data is to be modified by the     * caller then this method is preferable.     *     * <P>If the data array in 'blk' is 'null', then a new one is created. If     * the data array is not 'null' then it is reused, and it must be large     * enough to contain the block's data. Otherwise an 'ArrayStoreException'     * or an 'IndexOutOfBoundsException' is thrown by the Java system.     *     * <P>The returned data may have its 'progressive' attribute set. In this     * case the returned data is only an approximation of the "final" data.     *     * @param blk Its coordinates and dimensions specify the area to return,     * relative to the current tile. If it contains a non-null data array,     * then it must be large enough. If it contains a null data array a new     * one is created. Some fields in this object are modified to return the     * data.     *     * @param n The index of the component from which to get the data.     *     * @return The requested DataBlk     *     * @see #getInternCompData     * */    public final DataBlk getCompData(DataBlk blk, int n) {        // Check that block is inside tile        if (blk.ulx < 0 || blk.uly < 0 ||             blk.ulx+blk.w > bw[n] || blk.uly+blk.h > bh[n]) {            throw new IllegalArgumentException("Block is outside the tile");        }        // Translate to the source's coordinates        blk.ulx += iulx[n];        blk.uly += iuly[n];        blk = src.getCompData(blk,n);        // Translate back to the tiled coordinates        blk.ulx -= iulx[n];        blk.uly -= iuly[n];	return blk;    }    /**     * Changes the current tile, given the new tile indexes. An     * IllegalArgumentException is thrown if the coordinates do not correspond     * to a valid tile.     *     * @param x The horizontal index of the tile.     *     * @param y The vertical index of the new tile.     * */    public final void setTile(int x, int y) {        int i;          // counter        int ctox,ctoy;  // new current tile origin in the reference grid        int tonx;       // x of the origin of the next tile in the X direction        int tony;       // y of the origin of the next tile in the Y direction        // Check tile indexes        if (x < 0 || y < 0 || x >= nht || y >= nvt) {            throw new IllegalArgumentException("Tile's indexes out of bounds");        }        // Set new current tile        tx = x;        ty = y;        // Calculate tile origins        ctox = (x != 0) ? px+x*nw : ax;        ctoy = (y != 0) ? py+y*nh : ay;        tonx = (x != nht-1) ? px+(x+1)*nw : ax+src.getImgWidth();        tony = (y != nvt-1) ? py+(y+1)*nh : ay+src.getImgHeight();        // Set general variables        cw = tonx - ctox;        ch = tony - ctoy;        // Set component specific variables        for (i = src.getNumComps()-1; i >= 0 ; i--) {	    bw[i] = (tonx+src.getCompSubsX(i)-1)/src.getCompSubsX(i) -                (ctox+src.getCompSubsX(i)-1)/src.getCompSubsX(i);	    bh[i] = (tony+src.getCompSubsY(i)-1)/src.getCompSubsY(i) -                (ctoy+src.getCompSubsY(i)-1)/src.getCompSubsY(i);            offX[i] = (px+x*nw+src.getCompSubsX(i)-1)/src.getCompSubsX(i);            offY[i] = (py+y*nh+src.getCompSubsY(i)-1)/src.getCompSubsY(i);            iulx[i] = (ctox+src.getCompSubsX(i)-1)/src.getCompSubsX(i)-                (ax+src.getCompSubsX(i)-1)/src.getCompSubsX(i);            iuly[i] = (ctoy+src.getCompSubsY(i)-1)/src.getCompSubsY(i)-                (ay+src.getCompSubsY(i)-1)/src.getCompSubsY(i);        }    }    /**     * Advances to the next tile, in standard scan-line order (by rows then     * columns). An NoNextElementException is thrown if the current tile is     * the last one (i.e. there is no next tile).     * */    public final void nextTile() {        if (tx == nht-1 && ty == nvt-1) { // Already at last tile            throw new NoNextElementException();        }        else if (tx < nht-1) { // If not at end of current tile line            setTile(tx+1,ty);        }        else { // First tile at next line            setTile(0,ty+1);        }    }    /**     * Returns the horizontal and vertical indexes of the current tile.     *     * @param co If not null this object is used to return the     * information. If null a new one is created and returned.     *     * @return The current tile's horizontal and vertical indexes..     * */    public final Coord getTile(Coord co) {        if (co != null) {            co.x = tx;            co.y = ty;            return co;        }        else {            return new Coord(tx,ty);        }    }    /**     * Returns the index of the current tile, relative to a standard scan-line     * order.     *     * @return The current tile's index (starts at 0).     * */    public final int getTileIdx() {        return ty*nht+tx;    }    /**     * Returns the horizontal and vertical offset of the upper-left corner of     * the current tile, in the specified component, relative to the canvas     * origin, in the component coordinates (not in the reference grid     * coordinates). These are the coordinates of the current tile's (not     * active tile) upper-left corner relative to the canvas.     *     * @param co If not null the object is used to return the values,     * if null a new one is created and returned.     *     * @param c The index of the component (between 0 and N-1).     *     * @return The horizontal and vertical offsets of the upper-left corner of     * the current tile, for the specified component, relative to the canvas     * origin, in the component coordinates.     * */    public final Coord getTileOff(Coord co, int c) {        if (co != null) {            co.x = offX[c];            co.y = offY[c];            return co;        }        else {            return new Coord(offX[c],offY[c]);        }    }    /**     * Returns the horizontal coordinate of the upper-left corner of the     * active tile, with respect to the canvas origin, in the component     * coordinates, for the specified component.     *     * @param c The index of the component (between 0 and N-1)     *     * @return The horizontal coordinate of the upper-left corner of the     * active tile, with respect to the canvas origin, for component 'c', in     * the component coordinates.     * */    public final int getULX(int c) {        return iulx[c]+(ax+src.getCompSubsX(c)-1)/src.getCompSubsX(c);    }    /**     * Returns the vertical coordinate of the upper-left corner of the active     * tile, with respect to the canvas origin, in the component coordinates,     * for the specified component.     *     * @param c The index of the component (between 0 and N-1)     *     * @return The vertical coordinate of the upper-left corner of the active     * tile, with respect to the canvas origin, for component 'c', in the     * component coordinates.     * */    public final int getULY(int c) {        return iuly[c]+(ay+src.getCompSubsY(c)-1)/src.getCompSubsY(c);    }    /**     * Returns the horizontal coordinate of the image origin, the top-left     * corner, in the canvas system, on the reference grid.     *     * @return The horizontal coordinate of the image origin in the canvas     * system, on the reference grid.     * */    public final int getImgULX() {        return ax;    }    /**     * Returns the vertical coordinate of the image origin, the top-left     * corner, in the canvas system, on the reference grid.     *     * @return The vertical coordinate of the image origin in the canvas     * system, on the reference grid.     * */    public final int getImgULY() {        return ay;    }    /**     * Returns the number of tiles in the horizontal and vertical directions.     *     * @param co If not null this object is used to return the information. If     * null a new one is created and returned.     *     * @return The number of tiles in the horizontal (Coord.x) and vertical     * (Coord.y) directions.     * */    public final Coord getNumTiles(Coord co) {        if (co != null) {            co.x = nht;            co.y = nvt;            return co;        }        else {            return new Coord(nht,nvt);        }    }    /**     * Returns the total number of tiles in the image.     *     * @return The total number of tiles in the image.     * */    public final int getNumTiles() {        return nht*nvt;    }    /**     * Returns the nominal width of the tiles in the reference grid.     *     * @return The nominal tile width, in the reference grid.     * */    public final int getNomTileWidth(){        return nw;    }    /**     * Returns the nominal width of the tiles in the reference grid.     *     * @return The nominal tile width, in the reference grid.     * */    public final int getNomTileHeight(){        return nh;    }    /**     * Returns the tiling origin, refferred to as '(Px,Py)' in the 'ImgData'     * interface.     *     * @param co If not null this object is used to return the information. If     * null a new one is created and returned.     *     * @return The coordinate of the tiling origin, in the canvas system, on     * the reference grid.     *     * @see ImgData     * */    public final Coord getTilingOrigin(Coord co) {        if (co != null) {            co.x = px;            co.y = py;            return co;        }        else {            return new Coord(px,py);        }    }    /**     * Returns a String object representing Tiler's informations     *     * @return Tiler's infos in a string     * */    public String toString(){	return 	    "Tiler: source= "+src+	    "\n"+getNumTiles()+" tile(s), nominal width= "+nw+	    ", nominal height= "+nh;    }}