it-swarm.com.de

Android-Kachel-Bitmap

Ich versuche, eine Bitmap in Android zu laden, die ich kacheln möchte. Ich verwende derzeit in meiner Ansicht Folgendes, um eine Bitmap anzuzeigen:

canvas.drawBitmap(bitmap, srcRect, destRect, null)

Ich möchte diese Bitmap grundsätzlich als Hintergrundbild in meiner App verwenden und möchte die Bitmap sowohl in X- als auch in Y-Richtung wiederholen.

Ich habe die TileMode.REPEAT-Konstante für die BitmapShader-Klasse gesehen, aber ich bin nicht sicher, ob dies zum Wiederholen der eigentlichen Bitmap oder zum Anwenden eines Filters auf die Bitmap verwendet wird.

45
Rich Lawrence

Sie würden dies in der XML-Datei anstelle des Java-Codes tun. Ich habe es selbst nicht versucht, aber ich habe dieses Beispiel gefunden.

<xml version="1.0" encoding="utf-8"?>
<LinearLayout
Android:id="@+id/MainLayout"
xmlns:Android="http://schemas.Android.com/apk/res/Android"
Android:layout_width="fill_parent"
Android:layout_height="fill_parent"
Android:orientation="vertical"
Android:background="@drawable/backrepeat"
>

dann in einer xml namens backrepeat.xml

<bitmap xmlns:Android="http://schemas.Android.com/apk/res/Android"
    Android:src="@drawable/back" 
    Android:tileMode="repeat" />

Referenz

125
branchgabriel

Die Codeversion herausgefunden:

  BitmapDrawable TileMe = new BitmapDrawable(MyBitmap);
  TileMe.setTileModeX(Shader.TileMode.REPEAT);
  TileMe.setTileModeY(Shader.TileMode.REPEAT);

  ImageView Item = new ImageView(this);
  Item.setBackgroundDrawable(TileMe);

Wenn Sie über eine zu zeichnende Kachel verfügen, kann dies stattdessen verwendet werden, um BitmapDrawable zu erstellen:

  BitmapDrawable TileMe = new BitmapDrawable(BitmapFactory.decodeResource(getResources(), R.drawable.tile));
36
Izkata

Die obige Datei backrepeat.xml ist fehlerhaft

<bitmap
    xmlns:Android="http://schemas.Android.com/apk/res/Android"
    Android:src="@drawable/tile"
    Android:tileMode="repeat"
    Android:dither="true" />
16
Bo.

Es scheint, dass einige Leute daran interessiert sind, dies in einer Ansicht der onDraw-Methode zu tun. Der folgende Code hat für mich funktioniert:

bgTile = BitmapFactory.decodeResource(context.getResources(), R.drawable.bg_tile);

float left = 0, top = 0;
float bgTileWidth = bgTile.getWidth();
float bgTileHeight = bgTile.getHeight();

while (left < screenWidth) {
    while (top < screenHeight) {
        canvas.drawBitmap(bgTile, left, top, null);
        top += bgTileHeight;
    }
    left += bgTileWidth;
    top = 0;
}
6
kgiannakakis
<xml version="1.0" encoding="utf-8"?>
<LinearLayout
    Android:id="@+id/MainLayout"
    xmlns:Android="http://schemas.Android.com/apk/res/Android"
    Android:layout_width="fill_parent"
    Android:layout_height="fill_parent"
    Android:orientation="vertical"
    Android:background="@drawable/back"
    Android:tileMode="repeat"
>

Das hat gut für mich funktioniert. Die Bitmap musste nicht separat erstellt werden. Ich habe das tileMode-Attribut im Layout verwendet.

4
navi

Fügen Sie einfach diese Codezeile in onCreate () ein: -

 final Bitmap bmp = BitmapFactory.decodeResource(getResources(),R.drawable.actionbar_bg);
 final BitmapDrawable bitmapDrawable = new BitmapDrawable(bmp);
 bitmapDrawable.setTileModeXY(Shader.TileMode.REPEAT, Shader.TileMode.REPEAT);
 final ActionBar bar = getSupportActionBar();
 bar.setBackgroundDrawable(bitmapDrawable);
1
Amit Jayaswal
/* Tiled Layer Bitmap*/


public class TiledLayer {
private int cellWidth;
private int cellHeight;
private int yPosition = 0, xPosition = 0;
private int[][] grid;
private Image image;
private int[] tileXPositions;
private int[] tileYPositions;
private ArrayList animatedTiles;
private int numberOfTiles;
private int numberOfColumns;
private int numberOfRows;
private int gridColumns;
private int gridRows, width, height;

public TiledLayer(Image image, int columns, int rows, int tileWidth,
        int tileHeight, int width, int height) {
    this.grid = new int[columns][rows];
    this.gridColumns = columns;
    this.gridRows = rows;
    this.width = columns * tileWidth;
    this.height = rows * tileHeight;
    this.animatedTiles = new ArrayList();
    setStaticTileSet(image, tileWidth, tileHeight);
}

public void setStaticTileSet(Image image, int tileWidth, int tileHeight) {
    this.image = image;
    this.cellWidth = tileWidth;
    this.cellHeight = tileHeight;
    int columns = 64;//image.getWidth() / tileWidth;
    int rows =40;// image.getHeight() / tileHeight;
    this.tileXPositions = new int[columns];
    int pos = 0;
    for (int i = 0; i < columns; i++) {
        this.tileXPositions[i] = pos;
        pos += tileWidth;
    }
    this.tileYPositions = new int[rows];
    pos = 0;
    for (int i = 0; i < rows; i++) {
        this.tileYPositions[i] = pos;
        pos += tileHeight;
    }

    if (columns * rows < this.numberOfTiles) {
        // clear the grid, when there are not as many tiles as in the
        // previous set:
        for (int i = 0; i < this.grid.length; i++) {
            for (int j = 0; j < this.grid[i].length; j++) {
                this.grid[i][j] = 0;
            }
        }
    }
    this.numberOfTiles = columns * rows;
    this.numberOfColumns = columns;
    this.numberOfRows = rows;
}

public int createAnimatedTile(int staticTileIndex) {
    if (staticTileIndex >= this.numberOfTiles) {

        throw new IllegalArgumentException("invalid static tile index: "
                + staticTileIndex + " (there are only ["
                + this.numberOfTiles + "] tiles available.");

    }
    this.animatedTiles.add(new Integer(staticTileIndex));
    return -1 * (this.animatedTiles.size() - 1);
}

public void setAnimatedTile(int animatedTileIndex, int staticTileIndex) {
    if (staticTileIndex >= this.numberOfTiles) {

    }
    int animatedIndex = (-1 * animatedTileIndex) - 1;
    this.animatedTiles.set(animatedIndex, new Integer(staticTileIndex));
 }

 public int getAnimatedTile(int animatedTileIndex) {
    int animatedIndex = (-1 * animatedTileIndex) - 1;
    Integer animatedTile = (Integer) this.animatedTiles.get(animatedIndex);
    return animatedTile.intValue();
 }
 public void setCell(int col, int row, int tileIndex) {
    if (tileIndex >= this.numberOfTiles) {

        throw new IllegalArgumentException("invalid static tile index: "
                + tileIndex + " (there are only [" + this.numberOfTiles
                + "] tiles available.");

    }
    this.grid[col][row] = tileIndex;
}

 public int getCell(int col, int row) {
    return this.grid[col][row];
 }

 public void fillCells(int col, int row, int numCols, int numRows,
        int tileIndex) {
    if (tileIndex >= this.numberOfTiles) {

        throw new IllegalArgumentException("invalid static tile index: "
                + tileIndex + " (there are only [" + this.numberOfTiles
                + "] tiles available.");

    }
    int endCols = col + numCols;
    int endRows = row + numRows;
    for (int i = col; i < endCols; i++) {
        for (int j = row; j < endRows; j++) {
            this.grid[i][j] = tileIndex;
        }
    }
 }

    public final int getCellWidth() {
    return this.cellWidth;
 }

    public final int getCellHeight() {
    return this.cellHeight;
 }

 public final int getColumns() {
    return this.gridColumns;
 }

public final int getRows() {
    return this.gridRows;
}

public final void Paint(Graphics g) {
    int clipX = 0;// g.getClipX();
    int clipY = 0;// g.getClipY();
    int clipWidth = width;// g.getClipWidth();
    int clipHeight = height;// g.getClipHeight();

    // jmt restore clip to previous state

    int x = this.xPosition;
    int y = this.yPosition;
    int[][] gridTable = this.grid;
    for (int i = 0; i < this.gridColumns; i++) {
        int[] gridRow = gridTable[i];
        for (int j = 0; j < gridRow.length; j++) {
            int cellIndex = gridRow[j];
            if (cellIndex != 0) {
                // okay this cell needs to be rendered:
                int tileIndex;
                if (cellIndex < 0) {
                    Integer tile = (Integer) this.animatedTiles
                            .get((-1 * cellIndex) - 1);
                    tileIndex = tile.intValue() - 1;
                } else {
                    tileIndex = cellIndex - 1;
                }
                // now draw the tile:
                g.save(Canvas.CLIP_SAVE_FLAG);
                // jmt: clear the screen
                Rect r = new Rect(0, 0, cellWidth, cellHeight);
                g.clipRect(r);
                g.setClip(x, y, this.cellWidth, this.cellHeight);
                int column = tileIndex % this.numberOfColumns;
                int row = tileIndex / this.numberOfColumns;
                int tileX = x - this.tileXPositions[column];
                int tileY = y - this.tileYPositions[row];

                g.drawImage(this.image, tileX, tileY);
                g.restore();
            }
            y += this.cellHeight;
        } // for each row
        y = this.yPosition;
        x += this.cellWidth;
    } // for each column

        // reset original clip:
        g.setClip(clipX, clipY, clipWidth, clipHeight);
     }
}
0

Wenn Sie den Hintergrund nur vertikal wiederholen möchten, können Sie die Breite Ihres Layouts auf "wrap_content" setzen. Wenn Sie den Hintergrund so einstellen möchten, dass er horizontal wiederholt wird, setzen Sie die Höhe auf "wrap_content". Wenn sowohl Höhe als auch Breite auf "fill_parent" eingestellt sind, werden sie in X- und Y-Richtung kacheln.

Beispielsweise wird der folgende Code den Hintergrund vertikal wiederholen:

<LinearLayout xmlns:Android="http://schemas.Android.com/apk/res/Android"
    Android:layout_width="wrap_content"
    Android:layout_height="fill_parent"
    Android:background="@drawable/news_detail_activity_bg">
</LinearLayout>