android - मैं एंड्रॉइड टेक्स्टव्यू के आस-पास सीमा कैसे लगा सकता हूं?




android-layout textview (10)

आप अपने कोड में ऐसा कुछ जोड़ सकते हैं:

<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>

क्या टेक्स्टव्यू के चारों ओर एक सीमा खींचना संभव है?


आप दृश्य के लिए पृष्ठभूमि के रूप में एक आरेखण योग्य (आयताकार) सेट कर सकते हैं।

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

और आयत खींचने योग्य back.xml (res / drawable फ़ोल्डर में डाल दिया):

<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>

आप पारदर्शी पृष्ठभूमि के लिए ठोस रंग के लिए @android:color/transparent उपयोग कर सकते हैं। आप सीमा से पाठ को अलग करने के लिए पैडिंग का भी उपयोग कर सकते हैं। अधिक जानकारी के लिए देखें: http://developer.android.com/guide/topics/resources/drawable-resource.html


गोलाकार कोनों बनाने के लिए नीचे दिए गए लिंक को देखें http://androidcookbook.com/Recipe.seam?recipeId=2318

एक एंड्रॉइड प्रोजेक्ट में res के तहत ड्रॉइंग फ़ोल्डर बिटमैप्स (पीएनजी या जेपीजी फाइल) तक ही सीमित नहीं है, लेकिन यह एक्सएमएल फाइलों में परिभाषित आकार भी रख सकता है।

फिर इन आकारों को परियोजना में पुन: उपयोग किया जा सकता है। एक लेआउट के चारों ओर एक सीमा लगाने के लिए एक आकार का उपयोग किया जा सकता है। यह उदाहरण घुमावदार कोनों के साथ एक आयताकार सीमा दिखाता है। Customborder.xml नामक एक नई फ़ाइल ड्रॉबल फ़ोल्डर में बनाई गई है (ग्रहण में फ़ाइल मेनू का उपयोग करें और फ़ाइल के नाम में चयनित फ़ोल्डर के साथ फ़ाइल के बाद नई फ़ाइल का चयन करें और समाप्त क्लिक करें)।

सीमा आकार को परिभाषित करने वाला एक्सएमएल दर्ज किया गया है:

<?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>

विशेषता android:shape आयताकार पर सेट है (आकार फाइलें अंडाकार, रेखा, और अंगूठी का भी समर्थन करती हैं)। आयताकार डिफ़ॉल्ट मान है, इसलिए यह विशेषता तब छोड़ी जा सकती है जब यह एक आयताकार परिभाषित किया जा रहा हो। एक आकार फ़ाइल पर विस्तृत जानकारी के लिए http://developer.android.com/guide/topics/resources/drawable-resource.html#Shape पर आकारों पर एंड्रॉइड दस्तावेज़ देखें।

तत्व कोनों में आयताकार कोनों को गोलाकार करने के लिए सेट किया जाता है। प्रत्येक कोने पर एक अलग त्रिज्या सेट करना संभव है (एंड्रॉइड संदर्भ देखें)।

सीमा को ओवरलैप करने वाली सामग्री को रोकने के लिए, पैडिंग विशेषताओं का उपयोग उस दृश्य की सामग्री को स्थानांतरित करने के लिए किया जाता है, जिस पर आकार लागू होता है।

यहां सीमा रंग एक हल्के भूरे रंग (सीसीसीसीसीसी हेक्साडेसिमल आरजीबी मूल्य) पर सेट है।

आकार भी ग्रेडियेंट का समर्थन करते हैं, लेकिन इसका उपयोग यहां नहीं किया जा रहा है। फिर, एंड्रॉइड संसाधनों को देखने के लिए देखें कि ढाल कैसे परिभाषित किया गया है। आकार एंड्रॉइड का उपयोग कर लेपआउट पर लागू होता है android:background="@drawable/customborder"

लेआउट के भीतर अन्य विचार सामान्य के रूप में जोड़ा जा सकता है। इस उदाहरण में, एक टेक्स्ट व्यू जोड़ा गया है, और पाठ सफेद है (एफएफएफएफएफएफ हेक्साडेसिमल आरजीबी)। पृष्ठभूमि नीली, और चमक को कम करने के लिए कुछ पारदर्शिता (A00000FF हेक्साडेसिमल अल्फा आरजीबी मान) पर सेट है। अंत में लेआउट को स्क्रीन किनारे से ऑफसेट करके इसे एक और लेआउट में पैडिंग के साथ ऑफसेट करके ऑफसेट किया जाता है। इस प्रकार पूर्ण लेआउट फ़ाइल है:

<?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>

दरअसल, यह बहुत आसान है। यदि आप टेक्स्टव्यू के पीछे एक साधारण काला आयताकार चाहते हैं, तो टेक्स्टव्यू टैग के भीतर बस android:background="@android:color/black" । इस कदर:

<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"/>

मुझे कुछ अलग (गैर-प्रोग्रामेटिक) विधियों को सारांशित करने दें।

खींचने योग्य आकार का उपयोग करना

अपने ड्रॉइंग फ़ोल्डर में उदाहरण के लिए एक XML फ़ाइल के रूप में सहेजें (उदाहरण के लिए, 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>

फिर इसे अपने टेक्स्ट व्यू में पृष्ठभूमि के रूप में सेट करें:

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

और अधिक सहायता:

9-पैच का उपयोग करना

एक 9-पैच एक खिंचाव पृष्ठभूमि छवि है। यदि आप सीमा के साथ एक छवि बनाते हैं तो यह आपके टेक्स्ट व्यू को एक सीमा देगा। आपको बस इतना करना है कि छवि बनाएं और फिर इसे अपने टेक्स्ट व्यू में पृष्ठभूमि में सेट करें।

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

यहां कुछ लिंक दिए गए हैं जो दिखाएंगे कि 9-पैच छवि कैसे बनाएं:

अगर मैं सिर्फ शीर्ष सीमा चाहता हूं तो क्या होगा?

एक परत सूची का उपयोग करना

आप एक दूसरे के शीर्ष पर दो आयताकारों को ढेर करने के लिए एक परत सूची का उपयोग कर सकते हैं। दूसरे आयताकार को पहले आयत से थोड़ा छोटा बनाकर, आप सीमा प्रभाव बना सकते हैं। पहला (निचला) आयत सीमा रंग है और दूसरा आयत पृष्ठभूमि रंग है।

<?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>

android:top="2dp" सेट करना android:top="2dp" शीर्ष पर ऑफसेट करता है (इसे छोटा बनाता है) 2 डीपी द्वारा। यह सीमा (प्रभाव) देने के पहले (निचले) आयत को दिखाने के लिए अनुमति देता है। आप टेक्स्टव्यू पृष्ठभूमि पर इसे उसी तरह लागू कर सकते हैं जिस तरह shape खींचने योग्य किया गया था।

लेयर सूचियों के बारे में कुछ और लिंक यहां दिए गए हैं:

9-पैच का उपयोग करना

आप केवल एक ही सीमा के साथ 9-पैच छवि बना सकते हैं। उपरोक्त चर्चा के अनुसार बाकी सब कुछ वही है।

एक दृश्य का उपयोग करना

यह एक तरह की चाल है लेकिन यह अच्छी तरह से काम करता है अगर आपको दो दृश्यों या सीमा के बीच एक सिंगर टेक्स्ट व्यू में एक सेपरेटर जोड़ने की आवश्यकता है।

<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>

यहां कुछ और लिंक दिए गए हैं:


मुझे टेक्स्टव्यू के चारों ओर सीमा लगाने का बेहतर तरीका मिला।

पृष्ठभूमि के लिए नौ पैच छवि का प्रयोग करें। यह बहुत आसान है, एसडीके 9-पैच छवि बनाने के लिए एक उपकरण के साथ आता है, और इसमें बिल्कुल कोई कोडिंग शामिल नहीं है

लिंक http://developer.android.com/guide/topics/graphics/2d-graphics.html#nine-patch


मैं बस एक समान जवाब देख रहा था - यह स्ट्रोक और निम्नलिखित ओवरराइड के साथ किया जा सकता है:

@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); 
}

मैंने टेक्स्टव्यू को विस्तारित करके और सीमा को मैन्युअल रूप से चित्रित करके इस समस्या को हल किया है। मैंने यह भी जोड़ा है कि आप चुन सकते हैं कि सीमा को बिंदीदार या डैश किया गया है या नहीं।

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;
        }
}

और सीमा वर्ग:

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;
    }
}

उम्मीद है कि यह किसी की मदद करता है :)


यह आपकी मदद कर सकता है।

<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

यहां मेरी 'सरल' सहायक वर्ग है जो सीमा के साथ एक छवि दृश्य देता है। बस इसे अपने यूटिल फ़ोल्डर में छोड़ दें, और इसे इस तरह कॉल करें:

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

कोड यहाँ है।

/**
 * 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;
    }
}




android-textview