Behandeln von Klickereignissen auf einem Zeichenobjekt in einem EditText

238

Ich habe ein Bild rechts vom Text in einem EditTextWidget mit der folgenden XML-Datei hinzugefügt :

<EditText
  android:id="@+id/txtsearch"
  ...
  android:layout_gravity="center_vertical"
  android:background="@layout/shape"
  android:hint="Enter place,city,state"
  android:drawableRight="@drawable/cross" />

Aber ich möchte das löschen, EditTextwenn auf das eingebettete Bild geklickt wird. Wie kann ich das machen?

Manikandan
quelle
Mögliches Duplikat von stackoverflow.com/questions/13135447/…
Hardik4560

Antworten:

358

Eigentlich müssen Sie keine Klasse erweitern. Angenommen, ich habe ein EditText editComment mit einem drawableRight

editComment.setOnTouchListener(new OnTouchListener() {
    @Override
    public boolean onTouch(View v, MotionEvent event) {
        final int DRAWABLE_LEFT = 0;
        final int DRAWABLE_TOP = 1;
        final int DRAWABLE_RIGHT = 2;
        final int DRAWABLE_BOTTOM = 3;

        if(event.getAction() == MotionEvent.ACTION_UP) {
            if(event.getRawX() >= (editComment.getRight() - editComment.getCompoundDrawables()[DRAWABLE_RIGHT].getBounds().width())) {
                // your action here

                return true;
            }
        }
        return false;
    }
});

wir, getRawX()weil wir die tatsächliche Position der Berührung auf dem Bildschirm erhalten möchten, nicht relativ zum Elternteil.

Um auf die linke Seite zu gelangen, klicken Sie

if(event.getRawX() <= (editComment.getCompoundDrawables()[DRAWABLE_LEFT].getBounds().width())) 
aristo_sh
quelle
2
@ user2848783 Wie setze ich das in meinem linken Drawable?
Qadir Hussain
10
Arbeiten nach geändert event.getRawX()statt event.getX()@AngeloS
Pratik Butani
4
Ein Hinweis: Ersetzen Sie "return false;" zu "return true"; Andernfalls wird nach ACTION_DOWN -> ACTION_UP nicht ausgelöst.
Tomurka
9
Wenn Sie eine Polsterung hinzufügen, müssen Sie diese zusammenzählen und getRight()das Recht auf die Textansicht erhalten, die bei Polsterung nicht das Recht des Zeichens ist. Das Hinzufügen - editComment.getPaddingRight()am Ende Ihrer ifAussage sollte funktionieren.
Kassim
21
Dies funktioniert nicht, wenn das übergeordnete Element des EditText nicht an der linken Seite des Bildschirms ausgerichtet ist. Sie sollten event.getX () anstelle von event.getRawX () verwenden und editText.getWidth () anstelle von editText.getRight () verwenden
Fletcher Johns
85

Sehr, sehr gut, danke an alle, die zu dieser Diskussion beigetragen haben. Wenn Sie sich also nicht mit den Unannehmlichkeiten beim Erweitern der Klasse befassen möchten, können Sie Folgendes tun (nur für die richtige Zeichnung implementiert).

this.keyword = (AutoCompleteTextView) findViewById(R.id.search);
this.keyword.setOnTouchListener(new RightDrawableOnTouchListener(keyword) {
        @Override
        public boolean onDrawableTouch(final MotionEvent event) {
            return onClickSearch(keyword,event);
        }
    });

private boolean onClickSearch(final View view, MotionEvent event) {
    // do something
    event.setAction(MotionEvent.ACTION_CANCEL);
    return false;
}

Und hier ist die Implementierung des Bare-Bone-Listeners basierend auf der Antwort von @ Mark

public abstract class RightDrawableOnTouchListener implements OnTouchListener {
    Drawable drawable;
    private int fuzz = 10;

    /**
     * @param keyword
     */
    public RightDrawableOnTouchListener(TextView view) {
        super();
        final Drawable[] drawables = view.getCompoundDrawables();
        if (drawables != null && drawables.length == 4)
            this.drawable = drawables[2];
    }

    /*
     * (non-Javadoc)
     * 
     * @see android.view.View.OnTouchListener#onTouch(android.view.View, android.view.MotionEvent)
     */
    @Override
    public boolean onTouch(final View v, final MotionEvent event) {
        if (event.getAction() == MotionEvent.ACTION_DOWN && drawable != null) {
            final int x = (int) event.getX();
            final int y = (int) event.getY();
            final Rect bounds = drawable.getBounds();
            if (x >= (v.getRight() - bounds.width() - fuzz) && x <= (v.getRight() - v.getPaddingRight() + fuzz)
                    && y >= (v.getPaddingTop() - fuzz) && y <= (v.getHeight() - v.getPaddingBottom()) + fuzz) {
                return onDrawableTouch(event);
            }
        }
        return false;
    }

    public abstract boolean onDrawableTouch(final MotionEvent event);

}
Bostone
quelle
3
Sie sollten v.getLeft () zu x und v.getTop () zu y hinzufügen, um die richtige Position zu erhalten.
André
3
Eigentlich solltest du v.getRight()durch ersetzen v.getWidth().
Schneller
2
Beachten Sie, dass Ihr Fuzz-Faktor mit der DPI skaliert werden sollte. 10px in ldpi ist etwas völlig anderes als 10px in xxhdpi.
RaB
4
Wofür ist Fuzz? Bitte klären Sie.
11рій Мазуревич
1
Es sieht so fuzzaus, als würde der tippbare Bereich effektiv etwas größer, was das Tippen auf den kleinen Zeichenbereich erleichtert.
Ban-Geoengineering
28

Folgendes berücksichtigen. Es ist nicht die eleganteste Lösung, aber es funktioniert, ich habe es gerade getestet.

  1. Erstellen Sie eine benutzerdefinierte EditTextKlasse CustomEditText.java:

    import android.content.Context;
    import android.graphics.Rect;
    import android.graphics.drawable.Drawable;
    import android.util.AttributeSet;
    import android.view.MotionEvent;
    import android.widget.EditText;
    
    public class CustomEditText extends EditText
    {
      private Drawable dRight;
      private Rect rBounds;
    
      public CustomEditText(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
      }
      public CustomEditText(Context context, AttributeSet attrs) {
        super(context, attrs);
      }
      public CustomEditText(Context context) {
        super(context);
      }
    
      @Override
      public void setCompoundDrawables(Drawable left, Drawable top,
          Drawable right, Drawable bottom)
      {
        if(right !=null)
        {
          dRight = right;
        }
        super.setCompoundDrawables(left, top, right, bottom);
      }
    
      @Override
      public boolean onTouchEvent(MotionEvent event)
      {
    
        if(event.getAction() == MotionEvent.ACTION_UP && dRight!=null)
        {
          rBounds = dRight.getBounds();
          final int x = (int)event.getX();
          final int y = (int)event.getY();
          //System.out.println("x:/y: "+x+"/"+y);
          //System.out.println("bounds: "+bounds.left+"/"+bounds.right+"/"+bounds.top+"/"+bounds.bottom);
          //check to make sure the touch event was within the bounds of the drawable
          if(x>=(this.getRight()-rBounds.width()) && x<=(this.getRight()-this.getPaddingRight())
              && y>=this.getPaddingTop() && y<=(this.getHeight()-this.getPaddingBottom()))
          {
            //System.out.println("touch");
            this.setText("");
            event.setAction(MotionEvent.ACTION_CANCEL);//use this to prevent the keyboard from coming up
          }
        }
        return super.onTouchEvent(event);
      }
    
      @Override
      protected void finalize() throws Throwable
      {
        dRight = null;
        rBounds = null;
        super.finalize();
      }
    }
  2. Ändern Sie Ihr Layout-XML in dieses (wo com.exampleist Ihr tatsächlicher Projektpaketname):

    <com.example.CustomEditText
        android:id="@+id/txtsearch"android:layout_gravity="center_vertical"
        android:background="@layout/shape"
        android:hint="Enter place,city,state"
        android:drawableRight="@drawable/cross" 
    />
  3. Fügen Sie abschließend Folgendes (oder etwas Ähnliches) zu Ihrer Aktivität hinzu:

    
    CustomEditText et = (CustomEditText) this.findViewById(R.id.txtsearch);
    

Ich bin vielleicht ein bisschen daneben bei der Berechnung der Berührungsgrenzen für das verschachtelte Drawable, aber Sie haben die Idee.

Ich hoffe das hilft.

RyanM
quelle
Eigentlich habe ich gehört, dass das Ändern des MotionEvent von der Praxis abgeraten wird, was zu undefiniertem Verhalten führt, das wahrscheinlich auf verschiedenen Plattformen brechen würde. Eine bessere Lösung könnte also stackoverflow.com/a/6235602
Giulio Piancastelli
@ RyanM, ich habe TextViewstatt verwendet EditText. Ich habe den Code genommen und wenn ich auf TextView(nicht auf das Symbol, sondern auf ein Leerzeichen auf TextView) klicke, wird die Methode onTouchEvent(MotionEvent event)aufgerufen. So kann ich OnClickListenerfür eine übliche TextViewohne zusätzliche Klassen wieCustomEditText
Maksim Dmitriev
@ RyanM, anstatt zu verwenden, this.getRight()-rBounds.width()warum nicht verwenden this.getMeasuredWidth() - this.getCompoundPaddingRight()? Würde es sich nicht um die Polsterung des Drawables kümmern und auch die Bindung des Drawables loswerden?
Vino
@ RyanM Wie ändere ich das Bild bei Berührung mit einem Kreuzklick?
Qadir Hussain
Benutzerdefinierte Versionen von EditTextunterstützen keine ordnungsgemäße Tönung von Widgets, wenn Appcompat auf Pre-Lollipop-Geräten verwendet wird. Verwenden Sie AppCompatEditTextals übergeordnete Klasse Ihres benutzerdefinierten EditText
Tomask
24

Ich habe eine nützliche abstrakte Klasse DrawableClickListener erstellt, die OnTouchListener implementiert .

Zusätzlich zur DrawableClickListener- Klasse habe ich 4 zusätzliche abstrakte Klassen erstellt, die die DrawableClickListener- Klasse erweitern und das Klicken auf den Zeichenbereich für den richtigen Quadranten behandeln.

  • LeftDrawableClickListener
  • TopDrawableClickListener
  • RightDrawableClickListener
  • BottomDrawableClickListener

Zu berücksichtigender Punkt

Eine zu berücksichtigende Sache ist, dass die Größe der Bilder auf diese Weise nicht geändert wird. Daher müssen die Bilder korrekt skaliert werden, bevor sie in den res / drawable- Ordner gelegt werden.

Wenn Sie ein LinearLayout definieren, das eine ImageView und eine TextView enthält , ist es viel einfacher, die Größe des angezeigten Bildes zu ändern.


activity_my.xml

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent" >

    <TextView
        android:id="@+id/myTextView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="replace this with a variable"
        android:textSize="30sp"
        android:drawableLeft="@drawable/my_left_image"
        android:drawableRight="@drawable/my_right_image"
        android:drawablePadding="9dp" />

</RelativeLayout>

MyActivity.java

package com.company.project.core;

import android.app.Activity;
import android.os.Bundle;
import android.widget.TextView;

public class MyActivity extends Activity
{

    @Override
    protected void onCreate( Bundle savedInstanceState )
    {
        super.onCreate( savedInstanceState );
        setContentView( R.layout.activity_my );

        final TextView myTextView = (TextView) this.findViewById( R.id.myTextView );
        myTextView.setOnTouchListener( new DrawableClickListener.LeftDrawableClickListener(myTextView)
        {
            @Override
            public boolean onDrawableClick()
            {
                // TODO : insert code to perform on clicking of the LEFT drawable image...

                return true;
            }
        } );
        myTextView.setOnTouchListener( new DrawableClickListener.RightDrawableClickListener(myTextView)
        {
            @Override
            public boolean onDrawableClick()
            {
                // TODO : insert code to perform on clicking of the RIGHT drawable image...

                return true;
            }
        } );
    }

}

DrawableClickListener.java

package com.company.project.core;

import android.graphics.Rect;
import android.graphics.drawable.Drawable;
import android.view.MotionEvent;
import android.view.View;
import android.view.View.OnTouchListener;
import android.widget.TextView;

/**
 * This class can be used to define a listener for a compound drawable.
 * 
 * @author Matthew Weiler
 * */
public abstract class DrawableClickListener implements OnTouchListener
{

    /* PUBLIC CONSTANTS */
    /**
     * This represents the left drawable.
     * */
    public static final int DRAWABLE_INDEX_LEFT = 0;
    /**
     * This represents the top drawable.
     * */
    public static final int DRAWABLE_INDEX_TOP = 1;
    /**
     * This represents the right drawable.
     * */
    public static final int DRAWABLE_INDEX_RIGHT = 2;
    /**
     * This represents the bottom drawable.
     * */
    public static final int DRAWABLE_INDEX_BOTTOM = 3;
    /**
     * This stores the default value to be used for the
     * {@link DrawableClickListener#fuzz}.
     * */
    public static final int DEFAULT_FUZZ = 10;

    /* PRIVATE VARIABLES */
    /**
     * This stores the number of pixels of &quot;fuzz&quot; that should be
     * included to account for the size of a finger.
     * */
    private final int fuzz;
    /**
     * This will store a reference to the {@link Drawable}.
     * */
    private Drawable drawable = null;

    /* CONSTRUCTORS */
    /**
     * This will create a new instance of a {@link DrawableClickListener}
     * object.
     * 
     * @param view
     *            The {@link TextView} that this {@link DrawableClickListener}
     *            is associated with.
     * @param drawableIndex
     *            The index of the drawable that this
     *            {@link DrawableClickListener} pertains to.
     *            <br />
     *            <i>use one of the values:
     *            <b>DrawableOnTouchListener.DRAWABLE_INDEX_*</b></i>
     */
    public DrawableClickListener( final TextView view, final int drawableIndex )
    {
        this( view, drawableIndex, DrawableClickListener.DEFAULT_FUZZ );
    }

    /**
     * This will create a new instance of a {@link DrawableClickListener}
     * object.
     * 
     * @param view
     *            The {@link TextView} that this {@link DrawableClickListener}
     *            is associated with.
     * @param drawableIndex
     *            The index of the drawable that this
     *            {@link DrawableClickListener} pertains to.
     *            <br />
     *            <i>use one of the values:
     *            <b>DrawableOnTouchListener.DRAWABLE_INDEX_*</b></i>
     * @param fuzzOverride
     *            The number of pixels of &quot;fuzz&quot; that should be
     *            included to account for the size of a finger.
     */
    public DrawableClickListener( final TextView view, final int drawableIndex, final int fuzz )
    {
        super();
        this.fuzz = fuzz;
        final Drawable[] drawables = view.getCompoundDrawables();
        if ( drawables != null && drawables.length == 4 )
        {
            this.drawable = drawables[drawableIndex];
        }
    }

    /* OVERRIDDEN PUBLIC METHODS */
    @Override
    public boolean onTouch( final View v, final MotionEvent event )
    {
        if ( event.getAction() == MotionEvent.ACTION_DOWN && drawable != null )
        {
            final int x = (int) event.getX();
            final int y = (int) event.getY();
            final Rect bounds = drawable.getBounds();
            if ( this.isClickOnDrawable( x, y, v, bounds, this.fuzz ) )
            {
                return this.onDrawableClick();
            }
        }
        return false;
    }

    /* PUBLIC METHODS */
    /**
     * 
     * */
    public abstract boolean isClickOnDrawable( final int x, final int y, final View view, final Rect drawableBounds, final int fuzz );

    /**
     * This method will be fired when the drawable is touched/clicked.
     * 
     * @return
     *         <code>true</code> if the listener has consumed the event;
     *         <code>false</code> otherwise.
     * */
    public abstract boolean onDrawableClick();

    /* PUBLIC CLASSES */
    /**
     * This class can be used to define a listener for a <b>LEFT</b> compound
     * drawable.
     * */
    public static abstract class LeftDrawableClickListener extends DrawableClickListener
    {

        /* CONSTRUCTORS */
        /**
         * This will create a new instance of a
         * {@link LeftDrawableClickListener} object.
         * 
         * @param view
         *            The {@link TextView} that this
         *            {@link LeftDrawableClickListener} is associated with.
         */
        public LeftDrawableClickListener( final TextView view )
        {
            super( view, DrawableClickListener.DRAWABLE_INDEX_LEFT );
        }

        /**
         * This will create a new instance of a
         * {@link LeftDrawableClickListener} object.
         * 
         * @param view
         *            The {@link TextView} that this
         *            {@link LeftDrawableClickListener} is associated with.
         * @param fuzzOverride
         *            The number of pixels of &quot;fuzz&quot; that should be
         *            included to account for the size of a finger.
         */
        public LeftDrawableClickListener( final TextView view, final int fuzz )
        {
            super( view, DrawableClickListener.DRAWABLE_INDEX_LEFT, fuzz );
        }

        /* PUBLIC METHODS */
        public boolean isClickOnDrawable( final int x, final int y, final View view, final Rect drawableBounds, final int fuzz )
        {
            if ( x >= ( view.getPaddingLeft() - fuzz ) )
            {
                if ( x <= ( view.getPaddingLeft() + drawableBounds.width() + fuzz ) )
                {
                    if ( y >= ( view.getPaddingTop() - fuzz ) )
                    {
                        if ( y <= ( view.getHeight() - view.getPaddingBottom() + fuzz ) )
                        {
                            return true;
                        }
                    }
                }
            }
            return false;
        }

    }

    /**
     * This class can be used to define a listener for a <b>TOP</b> compound
     * drawable.
     * */
    public static abstract class TopDrawableClickListener extends DrawableClickListener
    {

        /* CONSTRUCTORS */
        /**
         * This will create a new instance of a {@link TopDrawableClickListener}
         * object.
         * 
         * @param view
         *            The {@link TextView} that this
         *            {@link TopDrawableClickListener} is associated with.
         */
        public TopDrawableClickListener( final TextView view )
        {
            super( view, DrawableClickListener.DRAWABLE_INDEX_TOP );
        }

        /**
         * This will create a new instance of a {@link TopDrawableClickListener}
         * object.
         * 
         * @param view
         *            The {@link TextView} that this
         *            {@link TopDrawableClickListener} is associated with.
         * @param fuzzOverride
         *            The number of pixels of &quot;fuzz&quot; that should be
         *            included to account for the size of a finger.
         */
        public TopDrawableClickListener( final TextView view, final int fuzz )
        {
            super( view, DrawableClickListener.DRAWABLE_INDEX_TOP, fuzz );
        }

        /* PUBLIC METHODS */
        public boolean isClickOnDrawable( final int x, final int y, final View view, final Rect drawableBounds, final int fuzz )
        {
            if ( x >= ( view.getPaddingLeft() - fuzz ) )
            {
                if ( x <= ( view.getWidth() - view.getPaddingRight() + fuzz ) )
                {
                    if ( y >= ( view.getPaddingTop() - fuzz ) )
                    {
                        if ( y <= ( view.getPaddingTop() + drawableBounds.height() + fuzz ) )
                        {
                            return true;
                        }
                    }
                }
            }
            return false;
        }

    }

    /**
     * This class can be used to define a listener for a <b>RIGHT</b> compound
     * drawable.
     * */
    public static abstract class RightDrawableClickListener extends DrawableClickListener
    {

        /* CONSTRUCTORS */
        /**
         * This will create a new instance of a
         * {@link RightDrawableClickListener} object.
         * 
         * @param view
         *            The {@link TextView} that this
         *            {@link RightDrawableClickListener} is associated with.
         */
        public RightDrawableClickListener( final TextView view )
        {
            super( view, DrawableClickListener.DRAWABLE_INDEX_RIGHT );
        }

        /**
         * This will create a new instance of a
         * {@link RightDrawableClickListener} object.
         * 
         * @param view
         *            The {@link TextView} that this
         *            {@link RightDrawableClickListener} is associated with.
         * @param fuzzOverride
         *            The number of pixels of &quot;fuzz&quot; that should be
         *            included to account for the size of a finger.
         */
        public RightDrawableClickListener( final TextView view, final int fuzz )
        {
            super( view, DrawableClickListener.DRAWABLE_INDEX_RIGHT, fuzz );
        }

        /* PUBLIC METHODS */
        public boolean isClickOnDrawable( final int x, final int y, final View view, final Rect drawableBounds, final int fuzz )
        {
            if ( x >= ( view.getWidth() - view.getPaddingRight() - drawableBounds.width() - fuzz ) )
            {
                if ( x <= ( view.getWidth() - view.getPaddingRight() + fuzz ) )
                {
                    if ( y >= ( view.getPaddingTop() - fuzz ) )
                    {
                        if ( y <= ( view.getHeight() - view.getPaddingBottom() + fuzz ) )
                        {
                            return true;
                        }
                    }
                }
            }
            return false;
        }

    }

    /**
     * This class can be used to define a listener for a <b>BOTTOM</b> compound
     * drawable.
     * */
    public static abstract class BottomDrawableClickListener extends DrawableClickListener
    {

        /* CONSTRUCTORS */
        /**
         * This will create a new instance of a
         * {@link BottomDrawableClickListener} object.
         * 
         * @param view
         *            The {@link TextView} that this
         *            {@link BottomDrawableClickListener} is associated with.
         */
        public BottomDrawableClickListener( final TextView view )
        {
            super( view, DrawableClickListener.DRAWABLE_INDEX_BOTTOM );
        }

        /**
         * This will create a new instance of a
         * {@link BottomDrawableClickListener} object.
         * 
         * @param view
         *            The {@link TextView} that this
         *            {@link BottomDrawableClickListener} is associated with.
         * @param fuzzOverride
         *            The number of pixels of &quot;fuzz&quot; that should be
         *            included to account for the size of a finger.
         */
        public BottomDrawableClickListener( final TextView view, final int fuzz )
        {
            super( view, DrawableClickListener.DRAWABLE_INDEX_BOTTOM, fuzz );
        }

        /* PUBLIC METHODS */
        public boolean isClickOnDrawable( final int x, final int y, final View view, final Rect drawableBounds, final int fuzz )
        {
            if ( x >= ( view.getPaddingLeft() - fuzz ) )
            {
                if ( x <= ( view.getWidth() - view.getPaddingRight() + fuzz ) )
                {
                    if ( y >= ( view.getHeight() - view.getPaddingBottom() - drawableBounds.height() - fuzz ) )
                    {
                        if ( y <= ( view.getHeight() - view.getPaddingBottom() + fuzz ) )
                        {
                            return true;
                        }
                    }
                }
            }
            return false;
        }

    }

}
MattWeiler
quelle
14

Es ist sehr einfach. Nehmen wir an, Sie haben auf der linken Seite Ihres EditText 'txtsearch' ein Zeichen. Das Folgende wird den Trick machen.

EditText txtsearch = (EditText) findViewById(R.id.txtsearch);
txtsearch.setOnTouchListener(new OnTouchListener() {
    @Override
    public boolean onTouch(View v, MotionEvent event) {
        if(event.getAction() == MotionEvent.ACTION_UP) {
            if(event.getRawX() <= txtsearch.getTotalPaddingLeft()) {
                // your action for drawable click event

             return true;
            }
        }
        return false;
    }
});

Wenn Sie eine richtige Zeichnung wünschen, ändern Sie die if-Anweisung in:

if(event.getRawX() >= txtsearch.getRight() - txtsearch.getTotalPaddingRight())

Ebenso können Sie dies für alle zusammengesetzten Zeichen tun.

txtsearch.getTotalPaddingTop()
txtsearch.getTotalPaddingBottom()

Dieser Methodenaufruf gibt alle Auffüllungen auf dieser Seite einschließlich aller Drawables zurück. Sie können dies sogar für TextView, Button usw. verwenden.

Klicken Sie hier als Referenz von der Android-Entwickler-Website.

Vishnuvathsan
quelle
1
Ich denke, dies ist eine gute Antwort, außer dem Teil, in dem true überall zurückgegeben wird. Ich würde vorschlagen, true nur dann zurückzugeben, wenn das Ereignis verbraucht werden muss (die Berührungsgeste wurde im richtigen Bereich ausgeführt).
Bianca Daniciuc
12

Die Verwendung des letzten Beitrags contains(x,y)funktioniert nicht direkt mit dem Ergebnis von getBounds()(außer zufällig, wenn "linke" Zeichen verwendet werden). Die getBoundsMethode liefert nur die RectDefinitionspunkte des zeichnbaren Elements, die mit dem Ursprung bei 0,0 normalisiert sind. Sie müssen also tatsächlich die Berechnung des ursprünglichen Beitrags durchführen, um herauszufinden, ob sich der Klick im Kontext des zeichnbaren Elements im Kontext des befindet Enthält die Abmessungen von EditText, ändert sie jedoch für oben, rechts, links usw. Alternativ können Sie eine beschreiben Rect, deren Koordinaten tatsächlich relativ zu ihrer Position im EditTextContainer sind, und sie verwendencontains() , obwohl Sie am Ende die gleiche Berechnung durchführen.

Wenn Sie beide kombinieren, erhalten Sie eine ziemlich vollständige Lösung. Ich habe nur ein Instanzattribut hinzugefügt consumesEvent, mit dem der API-Benutzer entscheiden kann, ob das Klickereignis weitergeleitet werden soll oder nicht, indem er das Ergebnis zum Festlegen verwendetACTION_CANCEL oder nicht.

Ich kann auch nicht verstehen , warum das boundsund actionX,actionY Werte Instanzattribute sind und nicht nur lokal auf dem Stapel.

Hier ist ein Ausschnitt aus einer Implementierung, die auf den oben genannten basiert, die ich zusammengestellt habe. Es behebt ein Problem, bei dem false zurückgegeben werden muss, um das Ereignis ordnungsgemäß zu nutzen. Es fügt einen "Fuzz" -Faktor hinzu. In meinem Anwendungsfall eines Sprachsteuerungssymbols in einem EditTextFeld fiel mir das Klicken schwer, sodass der Flaum die effektiven Grenzen erhöht, die als Klicken auf das Zeichenelement gelten. Für mich 15hat gut funktioniert. Ich brauchte nur, drawableRightdamit ich die Mathematik nicht in die anderen steckte, um etwas Platz zu sparen, aber Sie sehen die Idee.

package com.example.android;

import android.content.Context;
import android.graphics.drawable.Drawable;
import android.util.AttributeSet;
import android.util.Log;
import android.view.MotionEvent;
import android.widget.EditText;
import android.graphics.Rect;

import com.example.android.DrawableClickListener;

public class ClickableButtonEditText extends EditText {
  public static final String LOG_TAG = "ClickableButtonEditText";

  private Drawable drawableRight;
  private Drawable drawableLeft;
  private Drawable drawableTop;
  private Drawable drawableBottom;
  private boolean consumeEvent = false;
  private int fuzz = 0;

  private DrawableClickListener clickListener;

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

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

  public ClickableButtonEditText(Context context) {
    super(context);
  }

  public void consumeEvent() {
    this.setConsumeEvent(true);
  }

  public void setConsumeEvent(boolean b) {
    this.consumeEvent = b;
  }

  public void setFuzz(int z) {
    this.fuzz = z;
  }

  public int getFuzz() {
    return fuzz;
  }

  @Override
  public void setCompoundDrawables(Drawable left, Drawable top, Drawable right, Drawable bottom) {
    if (right != null) {
      drawableRight = right;
    }

    if (left != null) {
      drawableLeft = left;
    }
    super.setCompoundDrawables(left, top, right, bottom);
  }

  @Override
  public boolean onTouchEvent(MotionEvent event) {
    if (event.getAction() == MotionEvent.ACTION_DOWN) {
      int x, y;
      Rect bounds;
      x = (int) event.getX();
      y = (int) event.getY();
      // this works for left since container shares 0,0 origin with bounds
      if (drawableLeft != null) {
        bounds = drawableLeft.getBounds();
        if (bounds.contains(x - fuzz, y - fuzz)) {
          clickListener.onClick(DrawableClickListener.DrawablePosition.LEFT);
          if (consumeEvent) {
            event.setAction(MotionEvent.ACTION_CANCEL);
            return false;
          }
        }
      } else if (drawableRight != null) {
        bounds = drawableRight.getBounds();
        if (x >= (this.getRight() - bounds.width() - fuzz) && x <= (this.getRight() - this.getPaddingRight() + fuzz) 
              && y >= (this.getPaddingTop() - fuzz) && y <= (this.getHeight() - this.getPaddingBottom()) + fuzz) {

          clickListener.onClick(DrawableClickListener.DrawablePosition.RIGHT);
          if (consumeEvent) {
            event.setAction(MotionEvent.ACTION_CANCEL);
            return false;
          }
        }
      } else if (drawableTop != null) {
        // not impl reader exercise :)
      } else if (drawableBottom != null) {
        // not impl reader exercise :)
      }
    }

    return super.onTouchEvent(event);
  }

  @Override
  protected void finalize() throws Throwable {
    drawableRight = null;
    drawableBottom = null;
    drawableLeft = null;
    drawableTop = null;
    super.finalize();
  }

  public void setDrawableClickListener(DrawableClickListener listener) {
    this.clickListener = listener;
  }
}
Kennzeichen
quelle
11

Ich denke, es ist viel einfacher, wenn wir ein paar Tricks anwenden :)

  1. Erstellen Sie eine Bildschaltfläche mit Ihrem Symbol und stellen Sie die Hintergrundfarbe transparent ein .
  2. Setzen Sie die Bildschaltfläche auf den EditText und auf die rechte Seite
  3. Implementieren Sie den Onclick-Listener der Schaltfläche, um Ihre Funktion auszuführen

Getan

Bär
quelle
1
Wird verwendet RelativeLayout, um eine korrekte Positionierung zu erreichen. Es scheint nur weniger kompliziert als andere Lösungen zu sein und weitaus weniger Code zu warten.
C0D3LIC1OU5
8

Kotlin ist eine großartige Sprache, in der jede Klasse mit neuen Methoden erweitert werden kann. Lassen Sie uns eine neue Methode für die EditText-Klasse einführen, mit der Klicks nach rechts gezeichnet werden können.

fun EditText.onRightDrawableClicked(onClicked: (view: EditText) -> Unit) {
this.setOnTouchListener { v, event ->
    var hasConsumed = false
    if (v is EditText) {
        if (event.x >= v.width - v.totalPaddingRight) {
            if (event.action == MotionEvent.ACTION_UP) {
                onClicked(this)
            }
            hasConsumed = true
        }
    }
    hasConsumed
}
}

Sie können sehen, dass die Rückruffunktion als Argument verwendet wird, das aufgerufen wird, wenn der Benutzer auf rechts zeichnbar klickt.

val username = findViewById<EditText>(R.id.username_text)
    username.onRightDrawableClicked {
        it.text.clear()
    }
Bhojaviya Sagar
quelle
7

Ausgehend von der Idee von RyanM habe ich eine flexiblere Version erstellt, die alle Zeichentypen (oben, unten, links, rechts) unterstützt. Während der folgende Code TextView erweitert, ist das Anpassen für einen EditText nur ein Fall des Austauschs von "Erweitert TextView" gegen "Erweitert EditText". Instanziierung des Widgets aus XML ist identisch wie im Beispiel von RyanM, abgesehen vom Widget-Namen.


import android.content.Context;
import android.graphics.drawable.Drawable;
import android.util.AttributeSet;
import android.util.Log;
import android.view.MotionEvent;
import android.widget.TextView;

import com.example.DrawableClickListener.DrawablePosition;

public class ButtonTextView extends TextView {

private Drawable    drawableRight;
private Drawable    drawableLeft;
private Drawable    drawableTop;
private Drawable    drawableBottom;

private int     actionX, actionY;

private DrawableClickListener clickListener;

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

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

public ButtonTextView(Context context) {
    super(context);
}

@Override
public void setCompoundDrawables(Drawable left, Drawable top, Drawable right, Drawable bottom) {
    if (right != null) {
        drawableRight = right;
    }

    if (left != null) {
        drawableLeft = left;
    }

    if (top != null) {
        drawableTop = top;
    }

    if (bottom != null) {
        drawableBottom = bottom;
    }

    super.setCompoundDrawables(left, top, right, bottom);
}

@Override
public boolean onTouchEvent(MotionEvent event) {

    if (event.getAction() == MotionEvent.ACTION_DOWN) {
        actionX = (int) event.getX();
        actionY = (int) event.getY();

        if (drawableBottom != null && drawableBottom.getBounds().contains(actionX, actionY)) {
            clickListener.onClick(DrawablePosition.BOTTOM);
            return super.onTouchEvent(event);
        }

        if (drawableTop != null && drawableTop.getBounds().contains(actionX, actionY)) {
            clickListener.onClick(DrawablePosition.TOP);
            return super.onTouchEvent(event);
        }

        if (drawableLeft != null && drawableLeft.getBounds().contains(actionX, actionY)) {
            clickListener.onClick(DrawablePosition.LEFT);
            return super.onTouchEvent(event);
        }

        if (drawableRight != null && drawableRight.getBounds().contains(actionX, actionY)) {
            clickListener.onClick(DrawablePosition.RIGHT);
            return super.onTouchEvent(event);
        }
    }


    return super.onTouchEvent(event);
}

@Override
protected void finalize() throws Throwable {
    drawableRight = null;
    drawableBottom = null;
    drawableLeft = null;
    drawableTop = null;
    super.finalize();
}

public void setDrawableClickListener(DrawableClickListener listener) {
    this.clickListener = listener;
}}

Der DrawableClickListener ist so einfach:

public interface DrawableClickListener {

public static enum DrawablePosition { TOP, BOTTOM, LEFT, RIGHT };
public void onClick(DrawablePosition target); }

Und dann die eigentliche Umsetzung:

class example implements DrawableClickListener {
public void onClick(DrawablePosition target) {
    switch (target) {
        case LEFT:
            doSomethingA();
            break;

        case RIGHT:
            doSomethingB();
            break;

        case BOTTOM:
            doSomethingC();
            break;

        case TOP:
            doSomethingD();
            break;

        default:
            break;
    }
}}

ps: Wenn Sie den Listener nicht einstellen, führt das Berühren der Textansicht zu einer NullPointerException. Vielleicht möchten Sie dem Code noch etwas Paranoia hinzufügen.

ptashek
quelle
Es scheint, dass Ihr Code nicht funktioniert. Ich habe ihn gerade getestet und nichts passiert, wenn ich die Zeichenfläche berühre.
Thiago
7

es funktioniert für mich,

mEditTextSearch.addTextChangedListener(new TextWatcher() {

        @Override
        public void onTextChanged(CharSequence s, int start, int before, int count) {
            if(s.length()>0){
                mEditTextSearch.setCompoundDrawablesWithIntrinsicBounds(null, null, getResources().getDrawable(android.R.drawable.ic_delete), null);
            }else{
                mEditTextSearch.setCompoundDrawablesWithIntrinsicBounds(null, null, getResources().getDrawable(R.drawable.abc_ic_search), null);
            }
        }
        @Override
        public void beforeTextChanged(CharSequence s, int start, int count, int after) {
        }
        @Override
        public void afterTextChanged(Editable s) {
        }
    });
    mEditTextSearch.setOnTouchListener(new OnTouchListener() {
        @SuppressLint("ClickableViewAccessibility")
        @Override
        public boolean onTouch(View v, MotionEvent event) {
            if(event.getAction() == MotionEvent.ACTION_UP) {
                if(mEditTextSearch.getCompoundDrawables()[2]!=null){
                    if(event.getX() >= (mEditTextSearch.getRight()- mEditTextSearch.getLeft() - mEditTextSearch.getCompoundDrawables()[2].getBounds().width())) {
                        mEditTextSearch.setText("");
                    }
                }
            }
            return false;
        }
    });
varotariya vajsi
quelle
Muss bei Bedarf den rechten Abstand zum Bearbeiten von Text abziehen, wenn der Beginn des Trefferrechtecks ​​bestimmt wird.
farid_z
4

Ich weiß, dass dies ziemlich alt ist, aber ich musste kürzlich etwas Ähnliches tun ... Nachdem ich gesehen hatte, wie schwierig das ist, habe ich eine viel einfachere Lösung gefunden:

  1. Erstellen Sie ein XML-Layout, das den EditText und das Bild enthält
  2. Unterklasse FrameLayout und das XML-Layout aufblasen
  3. Fügen Sie Code für den Klick-Listener und jedes andere gewünschte Verhalten hinzu

In meinem Fall brauchte ich einen EditText, mit dem der Text mit einer Schaltfläche gelöscht werden konnte. Ich wollte, dass es wie SearchView aussieht, aber aus mehreren Gründen wollte ich diese Klasse nicht verwenden. Das folgende Beispiel zeigt, wie ich dies erreicht habe. Auch wenn es nicht mit einer Änderung des Fokus zu tun hat, sind die Prinzipien dieselben und ich dachte, es wäre vorteilhafter, tatsächlichen Arbeitscode zu veröffentlichen, als ein Beispiel zusammenzustellen, das möglicherweise nicht genau so funktioniert, wie ich es beabsichtigt hatte:

Hier ist mein Layout: clearable_edit_text.xml

<merge
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="wrap_content">

    <EditText
        android:id="@+id/edit_text_field"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"/>

    <!-- NOTE: Visibility cannot be set to "gone" or the padding won't get set properly in code -->
    <ImageButton
        android:id="@+id/edit_text_clear"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_gravity="right|center_vertical"
        android:background="@drawable/ic_cancel_x"
        android:visibility="invisible"/>
</merge>

Und hier ist die Klasse, die dieses Layout aufbläst: ClearableEditText.java

public class ClearableEditText extends FrameLayout {
    private boolean mPaddingSet = false;

    /**
     * Creates a new instance of this class.
     * @param context The context used to create the instance
     */
    public ClearableEditText (final Context context) {
        this(context, null, 0);
    }

    /**
     * Creates a new instance of this class.
     * @param context The context used to create the instance
     * @param attrs The attribute set used to customize this instance
     */
    public ClearableEditText (final Context context, final AttributeSet attrs) {
        this(context, attrs, 0);
    }

    /**
     * Creates a new instance of this class.
     * @param context The context used to create the instance
     * @param attrs The attribute set used to customize this instance
     * @param defStyle The default style to be applied to this instance
     */
    public ClearableEditText (final Context context, final AttributeSet attrs, final int defStyle) {
        super(context, attrs, defStyle);

        final LayoutInflater inflater = LayoutInflater.from(context);
        inflater.inflate(R.layout.clearable_edit_text, this, true);
    }

    @Override
    protected void onFinishInflate () {
        super.onFinishInflate();

        final EditText editField = (EditText) findViewById(R.id.edit_text_field);
        final ImageButton clearButton = (ImageButton) findViewById(R.id.edit_text_clear);

        //Set text listener so we can show/hide the close button based on whether or not it has text
        editField.addTextChangedListener(new TextWatcher() {
            @Override
            public void beforeTextChanged (final CharSequence charSequence, final int i, final int i2, final int i3) {
                //Do nothing here
            }

            @Override
            public void onTextChanged (final CharSequence charSequence, final int i, final int i2, final int i3) {
                //Do nothing here
            }

            @Override
            public void afterTextChanged (final Editable editable) {
                clearButton.setVisibility(editable.length() > 0 ? View.VISIBLE : View.INVISIBLE);
            }
        });

        //Set the click listener for the button to clear the text. The act of clearing the text will hide this button because of the
        //text listener
        clearButton.setOnClickListener(new OnClickListener() {
            @Override
            public void onClick (final View view) {
                editField.setText("");
            }
        });
    }

    @Override
    protected void onLayout (final boolean changed, final int left, final int top, final int right, final int bottom) {
        super.onLayout(changed, left, top, right, bottom);

        //Set padding here in the code so the text doesn't run into the close button. This could be done in the XML layout, but then if
        //the size of the image changes then we constantly need to tweak the padding when the image changes. This way it happens automatically
        if (!mPaddingSet) {
            final EditText editField = (EditText) findViewById(R.id.edit_text_field);
            final ImageButton clearButton = (ImageButton) findViewById(R.id.edit_text_clear);

            editField.setPadding(editField.getPaddingLeft(), editField.getPaddingTop(), clearButton.getWidth(), editField.getPaddingBottom());
            mPaddingSet = true;
        }
    }
}

Um diese Antwort besser an die Frage anzupassen, sollten die folgenden Schritte unternommen werden:

  1. Ändern Sie die zeichnbare Ressource nach Ihren Wünschen ... In meinem Fall war es ein graues X.
  2. Fügen Sie dem Bearbeitungstext einen Listener für Fokusänderungen hinzu ...
Justin
quelle
3

und wenn links zeichnbar ist, hilft dir das. (für diejenigen, die mit RTL-Layout arbeiten)

 editComment.setOnTouchListener(new OnTouchListener() {
        @Override
        public boolean onTouch(View v, MotionEvent event) {
            final int DRAWABLE_LEFT = 0;
            final int DRAWABLE_TOP = 1;
            final int DRAWABLE_RIGHT = 2;
            final int DRAWABLE_BOTTOM = 3;

            if(event.getAction() == MotionEvent.ACTION_UP) {
                if (event.getRawX() <= (searchbox.getLeft() + searchbox.getCompoundDrawables()[DRAWABLE_LEFT].getBounds().width())) {
                                     // your action here

                 return true;
                }
            }
            return false;
        }
    });
Ali Ziaee
quelle
Dies ist das Mischen der absoluten Positionen "getRawX" mit den relativen Positionen "getRight". Wenn Sie im editText einen rechten oder linken Rand festlegen, sehen Sie, wie dies unterbrochen wird, wenn der Klick auf falsche Koordinaten ausgelöst wird.
Sotti
3

Kopieren Sie einfach den folgenden Code und es macht den Trick.

editMsg.setOnTouchListener(new View.OnTouchListener() {
        @Override
        public boolean onTouch(View v, MotionEvent event) {
            final int DRAWABLE_LEFT = 0;
            final int DRAWABLE_TOP = 1;
            final int DRAWABLE_RIGHT = 2;
            final int DRAWABLE_BOTTOM = 3;

            if(event.getAction() == MotionEvent.ACTION_UP) {
                if(event.getRawX() >= (editMsg.getRight() - editMsg.getCompoundDrawables()[DRAWABLE_RIGHT].getBounds().width())) {
                    // your action here

                    Toast.makeText(ChatActivity.this, "Message Sent", Toast.LENGTH_SHORT).show();
                    return true;
                }
            }
            return false;
        }
    });
Prashant Paliwal
quelle
1
Das hat bei mir funktioniert, aber ich musste getX () anstelle von getRawX () verwenden. Ich denke, getRawX () funktioniert nur, wenn sich die Ansicht am linken Bildschirmrand befindet.
Glenn
1
Die Berechnung der Positionen ist falsch. Mischt absolute Koordinaten "getRawX ()" mit relativen wie "getRight ()"
Sotti
3

Keine der vorherigen Lösungen funktionierte für mich in Xamarin Android . Ich konnte den richtigen zeichnbaren Klick-Listener wie folgt zum Laufen bringen:

Erstellen Sie den folgenden OnEditTextTouchEreignis-Listener:

  private void OnEditTextTouch(object sender, View.TouchEventArgs e)
    {
        var rightDrawable = _autoCompleteTextViewSearch.GetCompoundDrawables()[2];

        if (rightDrawable == null || e.Event.Action != MotionEventActions.Up)
        {
            e.Handled = false;

            return;
        }

        if (e.Event.GetX() >= _autoCompleteTextViewSearch.Width - _autoCompleteTextViewSearch.TotalPaddingRight)
        {
            // Invoke your desired action here.

            e.Handled = true;
        }

        // Forward the event along to the sender (crucial for default behaviour)
        (sender as AutoCompleteTextView)?.OnTouchEvent(e.Event);
    }

Abonnieren Sie das Touch-Event:

_autoCompleteTextViewSearch.Touch += OnEditTextTouch;
Masterwok
quelle
2

Es ist alles großartig, aber warum nicht wirklich einfach machen?

Ich habe mich auch vor nicht allzu langer Zeit damit auseinandergesetzt ... und Android Touchlistiner funktioniert großartig, gibt aber Einschränkungen bei der Verwendung ... und ich bin zu einer anderen Lösung gekommen und hoffe, dass dies Ihnen helfen wird:

    <LinearLayout
    android:orientation="vertical"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:id="@+id/zero_row">
    <LinearLayout
        android:orientation="horizontal"
        android:layout_width="match_parent"
        android:layout_height="match_parent">
        <LinearLayout
            android:orientation="horizontal"
            android:layout_width="wrap_content"
            android:layout_height="match_parent">
            <ProgressBar
                android:id="@+id/loadingProgressBar"
                android:layout_gravity="center"
                android:layout_width="28dp"
                android:layout_height="28dp" />
        </LinearLayout>
        <LinearLayout
            android:orientation="horizontal"
            android:layout_width="match_parent"
            android:background="@drawable/edittext_round_corners"
            android:layout_height="match_parent"
            android:layout_marginLeft="5dp">
            <ImageView
                android:layout_width="28dp"
                android:layout_height="28dp"
                app:srcCompat="@android:drawable/ic_menu_search"
                android:id="@+id/imageView2"
                android:layout_weight="0.15"
                android:layout_gravity="center|right"
                android:onClick="OnDatabaseSearchEvent" />
            <EditText
                android:minHeight="40dp"
                android:layout_marginLeft="10dp"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:background="@drawable/edittext_round_corners"
                android:inputType="textPersonName"
                android:hint="Search.."
                android:textColorHint="@color/AndroidWhite"
                android:textColor="@color/AndroidWhite"
                android:ems="10"
                android:id="@+id/e_d_search"
                android:textCursorDrawable="@color/AndroidWhite"
                android:layout_weight="1" />
            <ImageView
                android:layout_width="28dp"
                android:layout_height="28dp"
                app:srcCompat="@drawable/ic_oculi_remove2"
                android:id="@+id/imageView3"
                android:layout_gravity="center|left"
                android:layout_weight="0.15"
                android:onClick="onSearchEditTextCancel" />
        </LinearLayout>

        <!--android:drawableLeft="@android:drawable/ic_menu_search"-->
        <!--android:drawableRight="@drawable/ic_oculi_remove2"-->

    </LinearLayout>

</LinearLayout>

Geben Sie hier die Bildbeschreibung ein Jetzt können Sie einen ImageClick-Listener oder ein Ereignis erstellen und mit Text tun, was immer Sie wollen. Diese Datei edittext_round_corners.xml

<item android:state_pressed="false" android:state_focused="false">
    <shape>
        <gradient
            android:centerY="0.2"
            android:startColor="@color/colorAccent"
            android:centerColor="@color/colorAccent"
            android:endColor="@color/colorAccent"
            android:angle="270"
            />
        <stroke
            android:width="0.7dp"
            android:color="@color/colorAccent" />
        <corners
            android:radius="5dp" />
    </shape>
</item>

Jevgenij Kononov
quelle
Das Problem bei diesem Ansatz besteht darin, dass er auseinanderfällt, sobald Sie die Textgröße im EditText ändern. Sie könnten denken, dass dies nur auf der Entwicklerseite liegt, aber es ist nicht so weit, dass die Geräte in den Einstellungen eine Textgröße haben. Sie können dies vermeiden, indem Sie dp anstelle von sp im EditText verwenden, aber es macht die Sache nur noch schlimmer. Die anderen Probleme sind Dinge wie der Umgang mit mehrzeiligen EditTexts.
Sotti
Ich habe das noch nie für die mehrzeilige Suche verwendet. Es tut mir leid, ich hätte nie gedacht, dass dieses Problem auftreten könnte. Wahrscheinlich hilft das Blockieren für mehrere Leitungen. Können Sie einen Screenshot der App oder eine Ansicht anhängen, um zu sehen, was passiert? Und ich werde versuchen, das zu lösen und Ihnen und diesem Code vielleicht helfen (diesen Code reparieren) und für die zukünftige Verwendung. Vielen Dank.
Jevgenij Kononov
Es ist sehr einfach zu replizieren, es passiert sogar in der Layoutvorschau, sobald Sie 2 Zeilen hinzufügen.
Sotti
Ein Hintergrund für EditTextsollte sein android:background="@android:color/transparent".
CoolMind
1

Es ist besser, den ImageButton rechts neben dem Text zu bearbeiten und einen negativen Layoutrand anzugeben, der sich mit dem Bearbeitungstext überschneidet. Stellen Sie den Listener auf ImageButton ein und führen Sie Operationen aus.

Ramanand Singh
quelle
1
@Override
    public boolean onTouch(View v, MotionEvent event) {

        Drawable drawableObj = getResources().getDrawable(R.drawable.search_btn);
        int drawableWidth = drawableObj.getIntrinsicWidth();

        int x = (int) event.getX();
        int y = (int) event.getY();

        if (event != null && event.getAction() == MotionEvent.ACTION_UP) {
            if (x >= (searchPanel_search.getWidth() - drawableWidth - searchPanel_search.getPaddingRight())
                    && x <= (searchPanel_search.getWidth() - searchPanel_search.getPaddingRight())

                    && y >= searchPanel_search.getPaddingTop() && y <= (searchPanel_search.getHeight() - searchPanel_search.getPaddingBottom())) {

                getSearchData();
            }

            else {
                InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
                imm.showSoftInput(searchPanel_search, InputMethodManager.SHOW_FORCED);
            }
        }
        return super.onTouchEvent(event);

    }
Zahid Naqvi
quelle
1
<FrameLayout
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:padding="5dp" >

            <EditText
                android:id="@+id/edt_status_text"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_marginBottom="10dp"
                android:background="@drawable/txt_box_blank"
                android:ems="10"
                android:hint="@string/statusnote"
                android:paddingLeft="5dp"
                android:paddingRight="10dp"
                android:textColor="@android:color/black" />

            <Button
                android:id="@+id/note_del"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_gravity="right"
                android:layout_marginRight="1dp"
                android:layout_marginTop="5dp"
                android:background="@android:drawable/ic_delete" />
        </FrameLayout>
PNR
quelle
Das Problem bei diesem Ansatz besteht darin, dass er auseinanderfällt, sobald Sie die Textgröße im EditText ändern. Sie könnten denken, dass dies nur auf der Entwicklerseite liegt, aber es ist nicht so weit, dass die Geräte in den Einstellungen eine Textgröße haben. Sie können dies vermeiden, indem Sie dp anstelle von sp im EditText verwenden, aber es macht die Sache nur noch schlimmer. Die anderen Probleme sind Dinge wie die Behandlung von mehrzeiligen EditTexts
Sotti
1

für links zeichnbaren Klick Listener

txt.setOnTouchListener(new View.OnTouchListener() {
        @Override
        public boolean onTouch(View v, MotionEvent event) {
            final int DRAWABLE_LEFT = 0;

            if (event.getAction() == MotionEvent.ACTION_UP) {
                if (event.getRawX() <= (txt
                        .getCompoundDrawables()[DRAWABLE_LEFT].getBounds().width() +
                        txt.getPaddingLeft() +
                        txt.getLeft())) {

                          //TODO do code here
                    }
                    return true;
                }
            }
            return false;
        }
    });
Harish Gyanani
quelle
Dies ist das Mischen der absoluten Positionen "getRawX" mit den relativen Positionen "getRight". Wenn Sie im editText einen rechten oder linken Rand festlegen, sehen Sie, wie dies unterbrochen wird, wenn der Klick auf falsche Koordinaten ausgelöst wird.
Sotti
1

Zusammengesetzte Drawables dürfen nicht anklickbar sein. Es ist sauberer, separate Ansichten in einem horizontalen LinearLayout zu verwenden und einen Klick-Handler darauf zu verwenden.

<LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginTop="15dp"
        android:background="@color/white"
        android:layout_marginLeft="20dp"
        android:layout_marginStart="20dp"
        android:layout_marginRight="20dp"
        android:layout_marginEnd="20dp"
        android:layout_gravity="center_horizontal"
        android:orientation="horizontal"
        android:translationZ="4dp">

        <ImageView
            android:layout_width="wrap_content"
            android:layout_height="match_parent"
            android:background="@color/white"
            android:minWidth="40dp"
            android:scaleType="center"
            app:srcCompat="@drawable/ic_search_map"/>

        <android.support.design.widget.TextInputEditText
            android:id="@+id/search_edit"
            style="@style/EditText.Registration.Map"
            android:layout_width="0dp"
            android:layout_weight="1"
            android:layout_height="wrap_content"
            android:hint="@string/hint_location_search"
            android:imeOptions="actionSearch"
            android:inputType="textPostalAddress"
            android:maxLines="1"
            android:minHeight="40dp" />

        <ImageView
            android:id="@+id/location_gps_refresh"
            android:layout_width="wrap_content"
            android:layout_height="match_parent"
            android:background="@color/white"
            android:minWidth="40dp"
            android:scaleType="center"
            app:srcCompat="@drawable/selector_ic_gps"/>
</LinearLayout>
ckohlwag
quelle
Das Problem bei diesem Ansatz besteht darin, dass er auseinanderfällt, sobald Sie die Textgröße im EditText ändern. Sie könnten denken, dass dies nur auf der Entwicklerseite liegt, aber es ist nicht so weit, dass die Geräte in den Einstellungen eine Textgröße haben. Sie können dies vermeiden, indem Sie dp anstelle von sp im EditText verwenden, aber es macht die Sache nur noch schlimmer. Die anderen Probleme sind Dinge wie der Umgang mit mehrzeiligen EditTexts.
Sotti
1

Für alle, die das monströse Klick-Handling nicht implementieren möchten. Sie können das gleiche mit einem erreichen RelativeLayout. Damit haben Sie sogar freie Hand bei der Positionierung des Drawables.

  <RelativeLayout
     android:layout_width="match_parent"
     android:layout_height="wrap_content">

   <android.support.design.widget.TextInputLayout
      android:layout_width="match_parent"
      android:layout_height="wrap_content">

     <android.support.design.widget.TextInputEditText
       android:layout_width="match_parent"
       android:layout_height="wrap_content"
      />
     </android.support.design.widget.TextInputLayout>
     <ImageView
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       android:layout_alignParentEnd="true"
       android:layout_centerInParent="true"
       android:src="@drawable/ic_undo"/>
    </RelativeLayout>

Die ImageViewPosition ist die gleiche, die Sie verwenden würden drawableEnd- und Sie benötigen nicht die gesamte Handhabung des Touch Listeners. Nur ein Klick Listener für die ImageViewund Sie können loslegen.

Murat Karagöz
quelle
Das Problem bei diesem Ansatz besteht darin, dass er auseinanderfällt, sobald Sie die Textgröße im EditText ändern. Sie könnten denken, dass dies nur auf der Entwicklerseite liegt, aber es ist nicht so weit, dass die Geräte in den Einstellungen eine Textgröße haben. Sie können dies vermeiden, indem Sie dp anstelle von sp im EditText verwenden, aber es macht die Sache nur noch schlimmer. Die anderen Probleme sind Dinge wie die Behandlung von mehrzeiligen EditTexts
Sotti
1

Das funktioniert für mich :) möge das auch dir helfen

edit_account_name.setOnTouchListener(new View.OnTouchListener() {
        @Override
        public boolean onTouch(View v, MotionEvent event) {
            if (event.getAction() == MotionEvent.ACTION_DOWN) {
                if (event.getRawX() >= (edit_account_name.getRight())) {
                    //clicked
                   return true;
                }
            }
            return false;
        }
    });
zohaib khaliq
quelle
Dies ist das Mischen der absoluten Positionen "getRawX" mit den relativen Positionen "getRight". Wenn Sie im editText einen rechten oder linken Rand festlegen, sehen Sie, wie dies unterbrochen wird, wenn der Klick auf falsche Koordinaten ausgelöst wird.
Sotti
Ich habe den rechten Rand zum Bearbeiten von Text hinzugefügt, mein Code funktioniert immer noch perfekt
zohaib khaliq
1

Ich habe mehrere Lösungen gesehen, aber keine hat mich überzeugt. Entweder sehr kompliziert oder zu einfach (nicht wiederverwendbar).

Dies ist momentan mein Lieblingsansatz:

mEditText.setOnTouchListener(
        new OnEditTextRightDrawableTouchListener(mEditText) {
          @Override
          public void OnDrawableClick() {
            // The right drawable was clicked. Your action goes here.
          }
        });

Und dies ist der wiederverwendbare Touch-Listener:

import android.graphics.drawable.Drawable;
import android.support.annotation.NonNull;
import android.view.MotionEvent;
import android.view.View;
import android.view.View.OnTouchListener;
import android.widget.EditText;

public abstract class OnEditTextRightDrawableTouchListener implements OnTouchListener {

  private final EditText mEditText;

  public OnEditTextRightDrawableTouchListener(@NonNull final EditText editText) {
    mEditText = editText;
  }

  @Override
  public boolean onTouch(View view, MotionEvent motionEvent) {
    if (motionEvent.getAction() == MotionEvent.ACTION_UP) {
      final int DRAWABLE_RIGHT_POSITION = 2;
      final Drawable drawable = mEditText.getCompoundDrawables()[DRAWABLE_RIGHT_POSITION];
      if (drawable != null) {
        final float touchEventX = motionEvent.getX();
        final int touchAreaRight = mEditText.getRight();
        final int touchAreaLeft = touchAreaRight - drawable.getBounds().width();
        if (touchEventX >= touchAreaLeft && touchEventX <= touchAreaRight) {
          view.performClick();
          OnDrawableClick();
        }
        return true;
      }
    }
    return false;
  }

  public abstract void OnDrawableClick();
}

Sie können sich das Wesentliche hier ansehen.

Sotti
quelle
1

Befolgen Sie den folgenden Code, um nach rechts, links, oben und unten zu zeichnen:

edittextview_confirmpassword.setOnTouchListener(new View.OnTouchListener() {
    @Override        public boolean onTouch(View v, MotionEvent event) {
        final int DRAWABLE_LEFT = 0;
        final int DRAWABLE_TOP = 1;
        final int DRAWABLE_RIGHT = 2;
        final int DRAWABLE_BOTTOM = 3;

        if(event.getAction() == MotionEvent.ACTION_UP) {
            if(event.getRawX() >= (edittextview_confirmpassword.getRight() - edittextview_confirmpassword.getCompoundDrawables()[DRAWABLE_RIGHT].getBounds().width())) {
                // your action here                    edittextview_confirmpassword.setInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_PASSWORD);
                return true;
            }
        }else{
            edittextview_confirmpassword.setInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_FLAG_NO_SUGGESTIONS);

        }
        return false;
    }
});

}}

Rohan Lodhi
quelle
1

Ich habe in Kotlin implementiert

edPassword.setOnTouchListener { _, event ->
            val DRAWABLE_RIGHT = 2
            val DRAWABLE_LEFT = 0
            val DRAWABLE_TOP = 1
            val DRAWABLE_BOTTOM = 3
            if (event.action == MotionEvent.ACTION_UP) {
                if (event.rawX >= (edPassword.right - edPassword.compoundDrawables[DRAWABLE_RIGHT].bounds.width())) {
                    edPassword.setText("")
                    true
                }
            }
            false
        }
Siddhpura Amit
quelle
0

Hier ist meine einfache Lösung, sondern wird einfach ImageButtonüber EditText:

<RelativeLayout
  android:layout_width="match_parent"
  android:layout_height="wrap_content">

  <EditText android:id="@+id/editTextName"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:imeOptions="actionSearch"
    android:inputType="text"/>

  <ImageButton android:id="@+id/imageViewSearch"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:src="@drawable/ic_action_search"
    android:layout_alignParentRight="true"
    android:layout_centerVertical="true"/>

</RelativeLayout>
almisoft
quelle
0

Ich möchte einen Weg für zeichnbares Links vorschlagen! Ich habe diesen Code ausprobiert und funktioniert.

txtsearch.setOnTouchListener(new View.OnTouchListener() {
        @Override
        public boolean onTouch(View view, MotionEvent event) {
            final int DRAWABLE_LEFT = 0;
            int start=txtsearch.getSelectionStart();
            int end=txtsearch.getSelectionEnd();
            if(event.getAction() == MotionEvent.ACTION_UP) {
                if(event.getRawX() <= (txtsearch.getLeft() + txtsearch.getCompoundDrawables()[DRAWABLE_LEFT].getBounds().width())) {
                    //Do your action here
                    return true;
                }

            }
            return false;
        }
    });
}
Tirthankar Kundu
quelle
Dies ist das Mischen der absoluten Positionen "getRawX" mit den relativen Positionen "getRight". Wenn Sie im editText einen rechten oder linken Rand festlegen, sehen Sie, wie dies unterbrochen wird, wenn der Klick auf falsche Koordinaten ausgelöst wird.
Sotti
0

Ich habe die Antwort @aristo_sh in Mono.Droid (Xamarin) implementiert, da es sich um eine anonyme Delegatenmethode handelt, die Sie nicht als wahr oder falsch zurückgeben können. Sie müssen e.Event.Handled übernehmen. Ich verstecke auch die Tastatur beim Klicken

editText.Touch += (sender, e) => {
                    e.Handled = false;
                    if (e.Event.Action == MotionEventActions.Up)
                    {
                        if (e.Event.RawX >= (bibEditText.Right - (bibEditText.GetCompoundDrawables()[2]).Bounds.Width()))
                        {
                            SearchRunner();
                            InputMethodManager manager = (InputMethodManager)GetSystemService(InputMethodService);
                            manager.HideSoftInputFromWindow(editText.WindowToken, 0);
                            e.Handled = true;
                        }
                    }
                };
Yohan Dahmani
quelle
0

Teilen meiner allgemeinen Lösung für die Verarbeitung von zusammensetzbaren ClickV- und Touch-Ereignissen mit zusammengesetzter TextView-Zeichnung.

Zuerst brauchen wir einen Touch Event Handler:

/**
 * Handles compound drawable touch events.
 * Will intercept every event that happened inside (calculated) compound drawable bounds, extended by fuzz.
 * @see TextView#getCompoundDrawables()
 * @see TextView#setCompoundDrawablesRelativeWithIntrinsicBounds(int, int, int, int)
 */
public abstract class CompoundDrawableTouchListener implements View.OnTouchListener {

    private final String LOG_TAG = "CmpDrawableTouch";

    private final int fuzz;

    public static final int LEFT = 0;
    public static final int TOP = 1;
    public static final int RIGHT = 2;
    public static final int BOTTOM = 3;
    private static final int[] DRAWABLE_INDEXES = {LEFT, TOP, RIGHT, BOTTOM};

    /**
     * Default constructor
     */
    public CompoundDrawableTouchListener() {
        this(0);
    }

    /**
     * Constructor with fuzz
     * @param fuzz desired fuzz in px
     */
    public CompoundDrawableTouchListener(int fuzz) {
        this.fuzz = fuzz;
    }

    @Override
    public boolean onTouch(View view, MotionEvent event) {
        if (!(view instanceof TextView)) {
            Log.e(LOG_TAG, "attached view is not instance of TextView");
            return false;
        }

        TextView textView = (TextView) view;
        Drawable[] drawables = textView.getCompoundDrawables();
        int x = (int) event.getX();
        int y = (int) event.getY();

        for (int i : DRAWABLE_INDEXES) {
            if (drawables[i] == null) continue;
            Rect bounds = getRelativeBounds(i, drawables[i], textView);
            Rect fuzzedBounds = addFuzz(bounds);

            if (fuzzedBounds.contains(x, y)) {
                MotionEvent relativeEvent = MotionEvent.obtain(
                    event.getDownTime(),
                    event.getEventTime(),
                    event.getAction(),
                    event.getX() - bounds.left,
                    event.getY() - bounds.top,
                    event.getMetaState());
                return onDrawableTouch(view, i, bounds, relativeEvent);
            }
        }

        return false;
    }

    /**
     * Calculates compound drawable bounds relative to wrapping view
     * @param index compound drawable index
     * @param drawable the drawable
     * @param view wrapping view
     * @return {@link Rect} with relative bounds
     */
    private Rect getRelativeBounds(int index, @NonNull Drawable drawable, View view) {
        Rect drawableBounds = drawable.getBounds();
        Rect bounds = new Rect();

        switch (index) {
            case LEFT:
                bounds.offsetTo(view.getPaddingLeft(),
                    view.getHeight() / 2 - bounds.height() / 2);
                break;

            case TOP:
                bounds.offsetTo(view.getWidth() / 2 - bounds.width() / 2,
                    view.getPaddingTop());
                break;

            case RIGHT:
                bounds.offsetTo(view.getWidth() - view.getPaddingRight() - bounds.width(),
                    view.getHeight() / 2 - bounds.height() / 2);
                break;

            case BOTTOM:
                bounds.offsetTo(view.getWidth() / 2 - bounds.width() / 2,
                    view.getHeight() - view.getPaddingBottom() - bounds.height());
                break;
        }

        return bounds;
    }

    /**
     * Expands {@link Rect} by given value in every direction relative to its center
     * @param source given {@link Rect}
     * @return result {@link Rect}
     */
    private Rect addFuzz(Rect source) {
        Rect result = new Rect();
        result.left = source.left - fuzz;
        result.right = source.right + fuzz;
        result.top = source.top - fuzz;
        result.bottom = source.bottom + fuzz;
        return result;
    }

    /**
     * Compound drawable touch-event handler
     * @param v wrapping view
     * @param drawableIndex index of compound drawable which recicved the event
     * @param drawableBounds {@link Rect} with compound drawable bounds relative to wrapping view.
     * Fuzz not included
     * @param event event with coordinated relative to wrapping view - i.e. within {@code drawableBounds}.
     * If using fuzz, may return negative coordinates.
     */
    protected abstract boolean onDrawableTouch(View v, int drawableIndex, Rect drawableBounds, MotionEvent event);
}

Jetzt können Sie beliebige Berührungsereignisse auf einer beliebigen Verbindung verarbeiten, die in einer beliebigen Textansicht gezeichnet werden kann:

textView1.setOnTouchListener(new CompoundDrawableTouchListener() {
            @Override
            protected void onDrawableTouch(View v, int drawableIndex, Rect drawableBounds, MotionEvent event) {
                switch(v.getId()) {
                    case R.id.textView1:
                        switch(drawableIndex) {
                            case CompoundDrawableTouchListener.RIGHT:
                                doStuff();
                                break;
                        }
                        break;
                }
            }
        });

Nur an Klicks interessiert? Filtern Sie einfach nach MotionEvent-Aktion aus:

/**
 * Handles compound drawable click events.
 * @see TextView#getCompoundDrawables()
 * @see TextView#setCompoundDrawablesRelativeWithIntrinsicBounds(int, int, int, int)
 * @see CompoundDrawableTouchListener
 */
public abstract class CompoundDrawableClickListener extends CompoundDrawableTouchListener {

    /**
     * Default constructor
     */
    public CompoundDrawableClickListener() {
        super();
    }

     /**
     * Constructor with fuzz
     * @param fuzz desired fuzz in px
     */
    public CompoundDrawableClickListener(int fuzz) {
        super(fuzz);
    }

    @Override
    protected void onDrawableTouch(View v, int drawableIndex, Rect drawableBounds, MotionEvent event) {
        if (event.getAction() == MotionEvent.ACTION_UP) onDrawableClick(v, drawableIndex);
        return true;
    }

    /**
     * Compound drawable touch-event handler
     * @param v wrapping view
     * @param drawableIndex index of compound drawable which recicved the event
     */
    protected abstract void onDrawableClick(View v, int drawableIndex);
}

Auch hier können wir problemlos Klicks auf jede zusammengesetzte Zeichnung von TextView verarbeiten:

textView1.setOnTouchListener(new CompoundDrawableClickListener() {
            @Override
            protected void onDrawableClick(View v, int drawableIndex) {
                switch(v.getId()) {
                    case R.id.textView1:
                        switch(drawableIndex) {
                            case CompoundDrawableTouchListener.RIGHT:
                                doStuff();
                                break;
                        }
                        break;
                }
            }
        });

Hoffe es hat euch gefallen wie mir. Ich werde versuchen, es hier und in verwandten Abschnitten auf dem neuesten Stand zu halten, wenn sich etwas ändert.

Amaksoft
quelle
0

Ich habe eine einfache benutzerdefinierte Touch-Listener-Klasse anstelle eines benutzerdefinierten EditText erstellt

public class MyTouchListener implements View.OnTouchListener {
private EditText editText;

public MyTouchListener(EditText editText) {
    this.editText = editText;

    setupDrawable(this.editText);
}

private void setupDrawable(final EditText editText) {
    editText.addTextChangedListener(new TextWatcher() {
        @Override
        public void beforeTextChanged(CharSequence s, int start, int count, int after) {

        }

        @Override
        public void onTextChanged(CharSequence s, int start, int before, int count) {
            if(s.length()>0)
                editText.setCompoundDrawablesWithIntrinsicBounds(0,0, R.drawable.clearicon,0);
            else
                editText.setCompoundDrawablesWithIntrinsicBounds(0,0, 0,0);

        }

        @Override
        public void afterTextChanged(Editable s) {

        }
    });
}

@Override
public boolean onTouch(View v, MotionEvent event) {
    if(event.getAction() == MotionEvent.ACTION_UP) {
        if(editText.getCompoundDrawables()[2]!=null){
            if(event.getX() >= (editText.getRight()- editText.getLeft() - editText.getCompoundDrawables()[2].getBounds().width())) {
                editText.setText("");
            }
        }
    }
    return false;

}

}}

Wenn der EditText leer ist, kann nicht gezeichnet werden. Ein Zeichen wird angezeigt, wenn wir mit der Bearbeitung begonnen haben, um den EditText zu löschen.

Sie können einfach den Touch Listener einstellen

mEditText.setOnTouchListener (neuer MyTouchListener (mEditText));

Sreenadh
quelle
Es ist ein bisschen verwirrend, dass s TouchListener die zeichnbare Sichtbarkeit und die klare Aktion selbst handhabt. Das ist keine Verantwortung des Touch Listeners und der Name der Klasse ist irreführend. Während Sie relative Positionen berechnen, ist es nicht erforderlich, Ränder aus der Gleichung zu entfernen. getRight - width wird es tun.
Sotti