LinearLayout Breite von rechts oder links erhöhen

Question

Ich habe ein LinearLayout, das auf dem Bildschirm zentriert ist. Es hat eine Breite weniger als die Bildschirmbreite. Es gibt zwei Schaltflächen: Rechts-Pfeil und Links-Pfeil. Wenn der Benutzer die entsprechende Schaltfläche drückt, sollte das Layout seine Breite von der relevanten Seite erhöhen. Die andere Seite sollte ihre Position dort behalten.

Gerade jetzt die Einstellung der Breite erhöht das Layout von beiden Seiten gleichermaßen. Das Layout muss anfangs zentriert sein und muss von beiden Seiten durch Benutzereingaben erweitert werden. (Anwendungsfall ist es, die Breite des relevanten Teils eines Bildes zu finden, dessen rechte und linke Seiten ungleiche Ränder haben, so dass der Benutzer sie mit meiner Technik markieren muss).

Ich benutze folgende um die Breite zu erhöhen, aber es hat das oben beschriebene Verhalten.

PS: Diese Funktionalität wurde in Tasker App seit seinen frühen Tagen implementiert; so ist es möglich.

EDIT: Hier ist das Layout.

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

<LinearLayout 
    android:layout_width="match_parent" 
    android:layout_height="0dp" 
    android:layout_weight="1" 
    android:orientation="vertical"> 

    <FrameLayout 
     android:layout_width="match_parent" 
     android:layout_height="match_parent"> 

     <ImageView 
      android:gravity="top" 
      android:layout_gravity="top" 
      android:id="@+id/iv" 
      android:layout_width="match_parent" 
      android:layout_height="wrap_content" 
      android:visibility="visible" /> 

     <LinearLayout 
      android:id="@+id/llRightLeft" 
      android:layout_width="wrap_content" 
      android:layout_height="wrap_content" 
      android:layout_gravity="center"> 

      <Button 
       android:id="@+id/bLeft" 
       android:layout_width="wrap_content" 
       android:layout_height="wrap_content" 
       android:text="LEFT" /> 

      <Button 
       android:id="@+id/bRight" 
       android:layout_width="wrap_content" 
       android:layout_height="wrap_content" 
       android:text="RIGHT" /> 
     </LinearLayout> 


     <LinearLayout 
      android:layout_gravity="center_horizontal" 
      android:id="@+id/llCropOverlay" 
      android:layout_width="match_parent" 
      android:layout_height="70dp" 
      android:background="@color/colorCropOverlay" 
      android:orientation="vertical" /> 
    </FrameLayout> 
</LinearLayout> 

Die letzte Linearlayout (llCropOverlay) angepasst werden soll. Beachten Sie, dass ich die Breite programmatisch auf 300 ändere, bevor ich die Größe der Schaltflächen ändere, um zu testen, ob die Schaltflächen funktionieren.

Answer 1

Ich habe eine fast perfekte Lösung gefunden (es gibt manchmal ein Problem mit einem Pixel, das nervt - alle Vorschläge werden geschätzt).

Dafür brauchen wir einige Variablen eingerichtet. Zuerst muss das LinearLayout llCropOverlay gefunden und identifiziert werden. Hier ist seine xml:

 <LinearLayout 
      android:layout_gravity="center_horizontal" 
      android:id="@+id/llCropOverlay" 
      android:layout_width="200dp" 
      android:layout_height="150dp" 
      android:background="@color/colorCropOverlay" 
      android:orientation="vertical" /> 

Nun, bevor erlaubt Benutzer zu interagieren wir die ursprüngliche Position des llCropOverlay finden müssen. So verwenden Sie diese in OnCreate():

llCropOverlay.post(new Runnable() { 
      @Override 
      public void run() { 
       orgX = llCropOverlay.getX(); 
      } 
     }); 

nun alle Tasten einrichten und stellen eine setOnTouchListener() auf diesen Tasten. Wenn der Listener dann aufgerufen wird, übergeben Sie den berührten Button mit der folgenden Methode. Verwenden Sie einen Handler und postDelayed(), um diese Methode aufzurufen, bis die Schaltfläche gedrückt wird. Oder rufen Sie es einmal auf, um die Größe um eine Pixelzeile/Spalte zu ändern.

void handleTouchOrClick(View view) { 
    ViewGroup.MarginLayoutParams params = (ViewGroup.MarginLayoutParams) 
       llCropOverlay.getLayoutParams(); 

    switch (view.getId()) { 
     case R.id.bUp: 
      params.height = params.height - 1; 
      break; 
     case R.id.bDown: 
      params.height = params.height + 1; 
      break; 
     case R.id.bRight: 
      params.width = params.width + 1; 
      llCropOverlay.post(new Runnable() { 
       @Override 
       public void run() { 
        llCropOverlay.setX(orgX); 
       } 
      }); 
      break; 
     case R.id.bRightContract: 
      params.width = params.width - 1; 
      llCropOverlay.post(new Runnable() { 
       @Override 
       public void run() { 
        llCropOverlay.setX(orgX); 
       } 
      }); 
      break; 
     case R.id.bLeft: 
      params.width = params.width + 1; 
      orgX--; 
      llCropOverlay.post(new Runnable() { 
       @Override 
       public void run() { 
        llCropOverlay.setX(orgX); 
       } 
      }); 
      break; 
     case R.id.bLeftContract: 
      params.width = params.width - 1; 
      orgX++; 
      llCropOverlay.post(new Runnable() { 
       @Override 
       public void run() { 
        llCropOverlay.setX(orgX); 
       } 
      }); 
      break; 
    } 
    llCropOverlay.setLayoutParams(params); 
} 

Jetzt ist hier, wie wir das Bild tatsächlich die Größe: Zur Erleichterung des Benutzers ich es in zwei Schritten bin beschneiden.

Crop von Seiten:

  ViewGroup.MarginLayoutParams params = 
    (ViewGroup.MarginLayoutParams) llCropOverlay.getLayoutParams(); 

        float eventX = params.width; 
        float eventY = 0; 
        float[] eventXY = new float[]{eventX, eventY}; 

        Matrix invertMatrix = new Matrix(); 
        imageView.getImageMatrix().invert(invertMatrix); 

        invertMatrix.mapPoints(eventXY); 
        int x = Integer.valueOf((int) eventXY[0]); 
        int y = Integer.valueOf((int) eventXY[1]); 

        int height = params.height; 
        while (height * 3 > originalBitmap.getHeight()) { 
         height = height - 10; 
        } 
        croppedBitmapByWidth = Bitmap.createBitmap(originalBitmap, (int) orgX, 0, 
          x, height); 
        imageView.setImageBitmap(croppedBitmapByWidth);  

Ernte von unten:

    float eventX2 = 0; 
        float eventY2 = params.height; 
        float[] eventXY2 = new float[]{eventX2, eventY2}; 

        Matrix invertMatrix2 = new Matrix(); 
        imageView.getImageMatrix().invert(invertMatrix2); 

        invertMatrix2.mapPoints(eventXY2); 
        int x2 = Integer.valueOf((int) eventXY2[0]); 
        int y2 = Integer.valueOf((int) eventXY2[1]); 

        croppedBitmapByHeight = Bitmap.createBitmap(croppedBitmapByWidth, 0, 0, 
           croppedBitmapByWidth.getWidth(), y2); 
        imageView.setImageBitmap(croppedBitmapByHeight);