Wie setze ich einen Rahmen um eine Android-Textansicht?

Ist es möglich, einen Rand um eine Textansicht zu zeichnen?

Sie können eine zeichnbare Form (ein Rechteck) als Hintergrund für die Ansicht festlegen.

<TextView android:text="Some text" android:background="@drawable/back"/>

Und Rechteck drawable back.xml (in den Ordner res / drawable legen):

<shape xmlns:android="http://schemas.android.com/apk/res/android" android:shape="rectangle" >
   <solid android:color="@android:color/white" />
   <stroke android:width="1dip" android:color="#4fa5d5"/>
</shape>

Sie können @android:color/transparentfür die Volltonfarbe einen transparenten Hintergrund verwenden. Sie können auch Auffüllen verwenden, um den Text vom Rand zu trennen. Weitere Informationen finden Sie unter: http://developer.android.com/guide/topics/resources/drawable-resource.html

Lassen Sie mich einige verschiedene (nicht programmatische) Methoden zusammenfassen.

Mit einer Form zeichnbar

Speichern Sie Folgendes als XML-Datei in Ihrem Zeichenordner (z. B. my_border.xml):

<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android"
    android:shape="rectangle" >

    <!-- View background color -->
    <solid
        android:color="@color/background_color" >
    </solid>

    <!-- View border color and width -->
    <stroke
        android:width="1dp"
        android:color="@color/border_color" >
    </stroke>

    <!-- The radius makes the corners rounded -->
    <corners
        android:radius="2dp"   >
    </corners>

</shape>

Legen Sie es dann einfach als Hintergrund für Ihre Textansicht fest:

<TextView
    android:id="@+id/textview1"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:background="@drawable/my_border" />

Mehr Hilfe:

• Form zeichnbar (Android-Dokumente)
• Tipps und Tricks für Android-Entwickler: XML Drawables (Teil I)

Verwenden eines 9-Patches

Ein 9-Patch ist ein dehnbares Hintergrundbild. Wenn Sie ein Bild mit einem Rahmen erstellen, erhält Ihre Textansicht einen Rahmen. Alles, was Sie tun müssen, ist, das Bild zu erstellen und es dann in Ihrer Textansicht auf den Hintergrund zu setzen.

<TextView
    android:id="@+id/textview1"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:background="@drawable/my_ninepatch_image" />

Hier sind einige Links, die zeigen, wie ein 9-Patch-Bild erstellt wird:

• Zeichne 9 Patches
• Einfacher Neun-Patch-Generator
• Eine einfache Anleitung zum 9-Patch für die Android-Benutzeroberfläche
• Erstellen und Verwenden von 9-Patch-Bildern in Android

Was ist, wenn ich nur den oberen Rand will?

Verwenden einer Ebenenliste

Sie können eine Ebenenliste verwenden, um zwei Rechtecke übereinander zu stapeln. Indem Sie das zweite Rechteck etwas kleiner als das erste Rechteck machen, können Sie einen Randeffekt erzielen. Das erste (untere) Rechteck ist die Rahmenfarbe und das zweite Rechteck ist die Hintergrundfarbe.

<?xml version="1.0" encoding="utf-8"?>
<layer-list xmlns:android="http://schemas.android.com/apk/res/android">

    <!-- Lower rectangle (border color) -->
    <item>
        <shape android:shape="rectangle">
            <solid android:color="@color/border_color" />
        </shape>
    </item>

    <!-- Upper rectangle (background color) -->
    <item android:top="2dp">
        <shape android:shape="rectangle">
            <solid android:color="@color/background_color" />
        </shape>
    </item>
</layer-list>

Durch das Einstellen wird android:top="2dp"die Oberseite um 2 Pence versetzt (verkleinert sie). Dadurch kann das erste (untere) Rechteck durchscheinen und einen Randeffekt erzielen. Sie können dies auf den TextView-Hintergrund auf dieselbe Weise shapeanwenden wie oben.

Hier sind einige weitere Links zu Ebenenlisten:

• Grundlegendes zur <Layer-Liste> von Android
• Wie erstelle ich einen unteren Rand in einer XML-Auswahl mit zeichnbarer Form?
• Rahmen auf einer Android-Ansicht in zeichnbarer XML auf 3 Seiten erstellen?

Verwenden eines 9-Patches

Sie können einfach ein 9-Patch-Bild mit einem einzigen Rand erstellen. Alles andere ist das gleiche wie oben beschrieben.

Verwenden einer Ansicht

Dies ist eine Art Trick, funktioniert aber gut, wenn Sie einer einzelnen Textansicht einen Trenner zwischen zwei Ansichten oder einen Rahmen hinzufügen müssen.

<LinearLayout
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical" >

    <TextView
        android:id="@+id/textview1"
        android:layout_width="match_parent"
        android:layout_height="wrap_content" />

    <!-- This adds a border between the TextViews -->
    <View
        android:layout_width="match_parent"
        android:layout_height="2dp"
        android:background="@android:color/black" />

    <TextView
        android:id="@+id/textview2"
        android:layout_width="match_parent"
        android:layout_height="wrap_content" />

</LinearLayout>

Hier noch ein paar Links:

• Wie zeichnet man eine Linie in Android
• So setzen Sie eine horizontale Trennlinie zwischen Bearbeitungstexten in einer Aktivität
• Wie füge ich eine horizontale 1px-Linie über der Bildansicht in einem relativen Layout hinzu?

Die einfache Möglichkeit besteht darin, eine Ansicht für Ihre Textansicht hinzuzufügen. Beispiel für die untere Grenzlinie:

<LinearLayout android:orientation="vertical"
              android:layout_width="fill_parent"
              android:layout_height="fill_parent">
    <TextView
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:layout_marginTop="10dp"
        android:layout_marginLeft="10dp"
        android:text="@string/title"
        android:id="@+id/title_label"
        android:gravity="center_vertical"/>
    <View
        android:layout_width="fill_parent"
        android:layout_height="0.2dp"
        android:id="@+id/separator"
        android:visibility="visible"
        android:background="@android:color/darker_gray"/>

</LinearLayout>

Passen Sie für die anderen Richtungsränder die Position der Trennansicht an.

Ich habe dieses Problem gelöst, indem ich die Textansicht erweitert und manuell einen Rahmen gezeichnet habe. Ich habe sogar hinzugefügt, damit Sie auswählen können, ob ein Rand gepunktet oder gestrichelt ist.

public class BorderedTextView extends TextView {
        private Paint paint = new Paint();
        public static final int BORDER_TOP = 0x00000001;
        public static final int BORDER_RIGHT = 0x00000002;
        public static final int BORDER_BOTTOM = 0x00000004;
        public static final int BORDER_LEFT = 0x00000008;

        private Border[] borders;

        public BorderedTextView(Context context, AttributeSet attrs, int defStyle) {
            super(context, attrs, defStyle);
            init();
        }

        public BorderedTextView(Context context, AttributeSet attrs) {
            super(context, attrs);
            init();
        }

        public BorderedTextView(Context context) {
            super(context);
            init();
        }
        private void init(){
            paint.setStyle(Paint.Style.STROKE);
            paint.setColor(Color.BLACK);
            paint.setStrokeWidth(4);        
        }
        @Override
        protected void onDraw(Canvas canvas) {
            super.onDraw(canvas);
            if(borders == null) return;

            for(Border border : borders){
                paint.setColor(border.getColor());
                paint.setStrokeWidth(border.getWidth());

                if(border.getStyle() == BORDER_TOP){
                    canvas.drawLine(0, 0, getWidth(), 0, paint);                
                } else
                if(border.getStyle() == BORDER_RIGHT){
                    canvas.drawLine(getWidth(), 0, getWidth(), getHeight(), paint);
                } else
                if(border.getStyle() == BORDER_BOTTOM){
                    canvas.drawLine(0, getHeight(), getWidth(), getHeight(), paint);
                } else
                if(border.getStyle() == BORDER_LEFT){
                    canvas.drawLine(0, 0, 0, getHeight(), paint);
                }
            }
        }

        public Border[] getBorders() {
            return borders;
        }

        public void setBorders(Border[] borders) {
            this.borders = borders;
        }
}

Und die Grenzklasse:

public class Border {
    private int orientation;
    private int width;
    private int color = Color.BLACK;
    private int style;
    public int getWidth() {
        return width;
    }
    public void setWidth(int width) {
        this.width = width;
    }
    public int getColor() {
        return color;
    }
    public void setColor(int color) {
        this.color = color;
    }
    public int getStyle() {
        return style;
    }
    public void setStyle(int style) {
        this.style = style;
    }
    public int getOrientation() {
        return orientation;
    }
    public void setOrientation(int orientation) {
        this.orientation = orientation;
    }
    public Border(int Style) {
        this.style = Style;
    }
}

Hoffe das hilft jemandem :)

Ich habe mir gerade eine ähnliche Antwort angesehen - sie kann mit einem Strich und der folgenden Überschreibung ausgeführt werden:

@Override
public void draw(Canvas canvas, MapView mapView, boolean shadow) {

Paint strokePaint = new Paint();
strokePaint.setARGB(255, 0, 0, 0);
strokePaint.setTextAlign(Paint.Align.CENTER);
strokePaint.setTextSize(16);
strokePaint.setTypeface(Typeface.DEFAULT_BOLD);
strokePaint.setStyle(Paint.Style.STROKE);
strokePaint.setStrokeWidth(2);

Paint textPaint = new Paint();
textPaint.setARGB(255, 255, 255, 255);
textPaint.setTextAlign(Paint.Align.CENTER);
textPaint.setTextSize(16);
textPaint.setTypeface(Typeface.DEFAULT_BOLD);

canvas.drawText("Some Text", 100, 100, strokePaint);
canvas.drawText("Some Text", 100, 100, textPaint);

super.draw(canvas, mapView, shadow); 
}

Sie können den Rahmen auf zwei Arten festlegen. Einer ist durch Zeichnen und der zweite ist programmatisch.

Verwenden von Drawable

<shape>
    <solid android:color="@color/txt_white"/>
    <stroke android:width="1dip" android:color="@color/border_gray"/>
    <corners android:bottomLeftRadius="10dp"
             android:bottomRightRadius="0dp"
             android:topLeftRadius="10dp"
             android:topRightRadius="0dp"/>
    <padding android:bottom="0dip"
             android:left="0dip"
             android:right="0dip"
             android:top="0dip"/>
</shape>

Programmatisch

public static GradientDrawable backgroundWithoutBorder(int color) {

    GradientDrawable gdDefault = new GradientDrawable();
    gdDefault.setColor(color);
    gdDefault.setCornerRadii(new float[] { radius, radius, 0, 0, 0, 0,
                                           radius, radius });
    return gdDefault;
}

Die einfachste Lösung, die ich gefunden habe (und die tatsächlich funktioniert):

<TextView
    ...
    android:background="@android:drawable/editbox_background" />

Ich habe einen besseren Weg gefunden, um eine Textansicht mit einem Rahmen zu versehen.

Verwenden Sie ein Bild mit neun Patches als Hintergrund. Es ist ziemlich einfach, das SDK wird mit einem Tool zum Erstellen des 9-Patch-Images geliefert und beinhaltet absolut keine Codierung.

Der Link lautet http://developer.android.com/guide/topics/graphics/2d-graphics.html#nine-patch .

Sie können Ihrem Code Folgendes hinzufügen:

<shape xmlns:android="http://schemas.android.com/apk/res/android"
       android:shape="rectangle" >
    <solid android:color="#ffffff" />
    <stroke android:width="1dip" android:color="#4fa5d5"/>
</shape>

Überprüfen Sie den Link unten, um abgerundete Ecken zu erstellen. Http://androidcookbook.com/Recipe.seam?recipeId=2318

Der zeichnbare Ordner unter res in einem Android-Projekt ist nicht auf Bitmaps (PNG- oder JPG-Dateien) beschränkt, sondern kann auch Formen enthalten, die in XML-Dateien definiert sind.

Diese Formen können dann im Projekt wiederverwendet werden. Eine Form kann verwendet werden, um einen Rahmen um ein Layout zu setzen. Dieses Beispiel zeigt einen rechteckigen Rand mit gekrümmten Ecken. Eine neue Datei mit dem Namen customborder.xml wird im zeichnbaren Ordner erstellt (in Eclipse verwenden Sie das Menü Datei und wählen Sie Neu und dann Datei, wobei der gezeichnete Ordner im Dateinamen ausgewählt ist und klicken Sie auf Fertig stellen).

Das XML, das die Rahmenform definiert, wird eingegeben:

<?xml version="1.0" encoding="UTF-8"?>
    <shape xmlns:android="http://schemas.android.com/apk/res/android" android:shape="rectangle">
    <corners android:radius="20dp"/>
    <padding android:left="10dp" android:right="10dp" android:top="10dp" android:bottom="10dp"/>
    <solid android:color="#CCCCCC"/>
</shape>

Das Attribut android:shapeist auf Rechteck festgelegt (Formdateien unterstützen auch Oval, Linie und Ring). Rechteck ist der Standardwert, daher kann dieses Attribut weggelassen werden, wenn ein Rechteck definiert wird. Ausführliche Informationen zu einer Formdatei finden Sie in der Android-Dokumentation zu Formen unter http://developer.android.com/guide/topics/resources/drawable-resource.html#Shape .

Mit den Elementecken werden die abgerundeten Rechteckecken festgelegt. Es ist möglich, an jeder Ecke einen anderen Radius festzulegen (siehe Android-Referenz).

Die Füllattribute werden verwendet, um den Inhalt der Ansicht zu verschieben, auf die die Form angewendet wird, um zu verhindern, dass der Inhalt den Rand überlappt.

Die Rahmenfarbe wird hier auf Hellgrau gesetzt (CCCCCC hexadezimaler RGB-Wert).

Formen unterstützen auch Farbverläufe, aber das wird hier nicht verwendet. Weitere Informationen zum Definieren eines Verlaufs finden Sie in den Android-Ressourcen. Die Form wird mit auf das Laypout angewendet android:background="@drawable/customborder".

Innerhalb des Layouts können wie gewohnt andere Ansichten hinzugefügt werden. In diesem Beispiel wurde eine einzelne Textansicht hinzugefügt, und der Text ist weiß (FFFFFF hexadezimales RGB). Der Hintergrund ist auf Blau eingestellt, plus etwas Transparenz, um die Helligkeit zu verringern (hexadezimaler Alpha-RGB-Wert A00000FF). Schließlich wird das Layout von der Bildschirmkante versetzt, indem es mit etwas Polsterung in ein anderes Layout eingefügt wird. Die vollständige Layoutdatei lautet somit:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
              android:orientation="vertical"
              android:layout_width="fill_parent"
              android:layout_height="fill_parent"
              android:padding="5dp">
    <LinearLayout android:orientation="vertical"
                  android:layout_width="fill_parent"
                  android:layout_height="fill_parent"
                  android:background="@drawable/customborder">
        <TextView android:layout_width="fill_parent"
                android:layout_height="fill_parent"
                android:text="Text View"
                android:textSize="20dp"
                android:textColor="#FFFFFF"
                android:gravity="center_horizontal"
                android:background="#A00000FF" />
    </LinearLayout>
</LinearLayout>

Ich habe eine Möglichkeit, es sehr einfach zu machen, und ich möchte es teilen.

Wenn ich mi TextViews quadrieren möchte, füge ich sie einfach in ein LinearLayout ein. Ich lege die Hintergrundfarbe meines LinearLayout fest und füge meiner Textansicht einen Rand hinzu. Das Ergebnis ist genau so, als würden Sie die Textansicht quadrieren.

Konstantin Burov Antwort ändern, weil in meinem Fall nicht funktioniert:

<?xml version="1.0" encoding="utf-8"?>
<selector xmlns:android="http://schemas.android.com/apk/res/android">
    <item>
        <shape android:shape="rectangle">
            <solid android:color="@android:color/white" />
            <stroke android:width="2dip" android:color="#4fa5d5"/>
            <corners android:radius="7dp"/>
        </shape>
    </item>
</selector>

compileSdkVersion 26 (Android 8.0), minSdkVersion 21 (Android 5.0), targetSdkVersion 26, Implementierung 'com.android.support:appcompat-v7:26.1.0', Gradle: 4.1

Sie können einen benutzerdefinierten Hintergrund für Ihre Textansicht erstellen. Schritte 1. Gehen Sie zu Ihrem Projekt. 2. Gehen Sie zu Ressourcen und klicken Sie mit der rechten Maustaste auf Zeichnen. 3. Klicken Sie auf Neu -> Zeichnungsressourcendatei. 4. Geben Sie Ihrer Datei einen Namen. 5. Fügen Sie den folgenden Code in die Datei ein

<shape xmlns:android="http://schemas.android.com/apk/res/android">
<stroke android:width="1dp" android:color="@color/colorBlack" />
<padding android:left="1dp"
    android:top="1dp"
    android:right="1dp"
    android:bottom="1dp" />
<corners android:radius="6dp" />
<solid android:color="#ffffffff" />

6. Für Ihre Textansicht, in der Sie sie als Hintergrund verwenden möchten,

   android: background = "@ drawable / your_fileName"

Hier ist meine 'einfache' Hilfsklasse, die eine ImageView mit dem Rand zurückgibt. Legen Sie dies einfach in Ihrem utils-Ordner ab und nennen Sie es so:

ImageView selectionBorder = BorderDrawer.generateBorderImageView(context, borderWidth, borderHeight, thickness, Color.Blue);

Hier ist der Code.

/**
 * Because creating a border is Rocket Science in Android.
 */
public class BorderDrawer
{
    public static ImageView generateBorderImageView(Context context, int borderWidth, int borderHeight, int borderThickness, int color)
    {
        ImageView mask = new ImageView(context);

        // Create the square to serve as the mask
        Bitmap squareMask = Bitmap.createBitmap(borderWidth - (borderThickness*2), borderHeight - (borderThickness*2), Bitmap.Config.ARGB_8888);
        Canvas canvas = new Canvas(squareMask);

        Paint paint = new Paint();
        paint.setStyle(Paint.Style.FILL);
        paint.setColor(color);
        canvas.drawRect(0.0f, 0.0f, (float)borderWidth, (float)borderHeight, paint);

        // Create the darkness bitmap
        Bitmap solidColor = Bitmap.createBitmap(borderWidth, borderHeight, Bitmap.Config.ARGB_8888);
        canvas = new Canvas(solidColor);

        paint.setStyle(Paint.Style.FILL);
        paint.setColor(color);
        canvas.drawRect(0.0f, 0.0f, borderWidth, borderHeight, paint);

        // Create the masked version of the darknessView
        Bitmap borderBitmap = Bitmap.createBitmap(borderWidth, borderHeight, Bitmap.Config.ARGB_8888);
        canvas = new Canvas(borderBitmap);

        Paint clearPaint = new Paint();
        clearPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.CLEAR));

        canvas.drawBitmap(solidColor, 0, 0, null);
        canvas.drawBitmap(squareMask, borderThickness, borderThickness, clearPaint);

        clearPaint.setXfermode(null);

        ImageView borderView = new ImageView(context);
        borderView.setImageBitmap(borderBitmap);

        return borderView;
    }
}

Dies kann Ihnen helfen.

<RelativeLayout
    android:id="@+id/textbox"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:layout_centerHorizontal="true"
    android:layout_centerVertical="true"
    android:background="@android:color/darker_gray" >

    <TextView
        android:id="@+id/text"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_centerHorizontal="true"
        android:layout_centerVertical="true"
        android:layout_margin="3dp"
        android:background="@android:color/white"
        android:gravity="center"
        android:text="@string/app_name"
        android:textSize="20dp" />

</RelativeLayout

Erstellen Sie eine Rahmenansicht mit der Hintergrundfarbe als Rahmenfarbe und Größe Ihrer Textansicht. Legen Sie das Auffüllen der Rahmenansicht als Breite des Rahmens fest. Legen Sie die Hintergrundfarbe der Textansicht als die gewünschte Farbe für die Textansicht fest. Fügen Sie nun Ihre Textansicht in die Rahmenansicht ein.

Versuche dies:

<shape>
    <solid android:color="@color/txt_white"/>
    <stroke android:width="1dip" android:color="@color/border_black"/>
</shape>

Es gibt viele Möglichkeiten, einer Textansicht einen Rahmen hinzuzufügen. Am einfachsten ist es, ein benutzerdefiniertes Zeichenelement zu erstellen und es wie android:background="@drawable/textview_bg"für Ihre Textansicht festzulegen.

Die textview_bg.xml wird unter Drawables angezeigt und kann ungefähr so ​​aussehen. Sie können einen solidoder einen gradientHintergrund haben (oder nichts, wenn nicht erforderlich), cornersum einen Eckenradius strokehinzuzufügen und einen Rand hinzuzufügen.

textview_bg.xml

<?xml version="1.0" encoding="utf-8"?>
    <shape xmlns:android="http://schemas.android.com/apk/res/android"
        android:shape="rectangle">

        <corners
            android:radius="@dimen/dp_10"/>

        <gradient
            android:angle="225"
            android:endColor="#FFFFFF"
            android:startColor="#E0E0E0" />

        <stroke
            android:width="2dp"
            android:color="#000000"/>

    </shape>

  <View
    android:layout_width="match_parent"
    android:layout_height="2dp"
    android:background="@android:color/black" />

Mit diesem Code können Sie ihn beliebig platzieren

setBackground in Ihrer XML-Textansicht,

Fügen Sie die Datei round_textview.xml zu Ihrem Zeichenverzeichnis hinzu.

<shape xmlns:android="http://schemas.android.com/apk/res/android" android:shape="rectangle" >
   <solid android:color="@android:color/white" />
   <stroke android:width="2dip" android:color="#4f5g52"/>
</shape>

Legen Sie die zeichnbare Datei im textView-Hintergrund fest.

Eigentlich ist es sehr einfach. Wenn Sie ein einfaches schwarzes Rechteck hinter der Textansicht wünschen, fügen Sie es einfach android:background="@android:color/black"in die TextView-Tags ein. So was:

<TextView
    android:textSize="15pt" android:textColor="#ffa7ff04"
    android:layout_alignBottom="@+id/webView1"
    android:layout_alignParentRight="true"
    android:layout_alignParentEnd="true"
    android:background="@android:color/black"/>