web-dev-qa-db-fra.com

Quelle est la différence entre gravity et layout_gravity dans Android?

Je sais que nous pouvons définir les valeurs suivantes sur les propriétés Android:gravity et Android:layout_gravity :=:

  1. center
  2. _center_vertical_
  3. _center_horizontal_, etc.

Mais je suis confus en ce qui concerne les deux.

Quelle est la différence entre l'utilisation de _Android:gravity_ et de _Android:layout_gravity_?

androidandroid-layoutandroid-gravity
1262
Paresh Mayani

Leurs noms devraient vous aider:

  • Android:gravity définit la gravité du contenu (c'est-à-dire ses sous-vues) de la View sur laquelle il est utilisé.
  • Android:layout_gravity définit la gravité de View ou Layout par rapport à son parent.

Et un exemple est ici .

1292
Sephy

intérieur - extérieur

  • gravity organise le contenu à l'intérieur de la vue.
  • layout_gravity arrange la position de la vue en dehors de d'elle-même.

Parfois, il est également utile de voir une photo. Le vert et le bleu sont TextViews et les deux autres couleurs d'arrière-plan sont LinearLayouts.

enter image description here

Remarques

  • Le layout_gravity ne fonctionne pas pour les vues dans un RelativeLayout. Utilisez-le pour les vues dans un LinearLayout ou FrameLayout. Voir mon réponse supplémentaire pour plus de détails.
  • La largeur (ou hauteur) de la vue doit être supérieure à son contenu. Sinon, gravity n'aura aucun effet. Ainsi, wrap_content et gravity n'ont pas de sens ensemble.
  • La largeur (ou hauteur) de la vue doit être inférieure à celle du parent. Sinon, layout_gravity n'aura aucun effet. Ainsi, match_parent et layout_gravity n'ont pas de sens ensemble.
  • Le layout_gravity=center a le même aspect que layout_gravity=center_horizontal ici car ils sont disposés verticalement. Dans ce cas, vous ne pouvez pas centrer verticalement, donc layout_gravity=center ne se centre que horizontalement.
  • Cette réponse concernait uniquement le réglage de gravity et layout_gravity sur les vues d'une présentation. Pour voir ce qui se passe lorsque vous définissez la gravity de la présentation parent elle-même, consultez le réponse supplémentaire auquel j'ai fait référence ci-dessus. (Résumé: gravity ne fonctionne pas bien sur un RelativeLayout mais peut être utile avec un LinearLayout.)

Alors rappelez-vous, layout _ la gravité organise une vue dans son layout . Gravity organise le contenu dans la vue.

xml

Voici le XML pour l'image ci-dessus pour votre référence:

<?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:background="#e3e2ad"
        Android:orientation="vertical" >

        <TextView
            Android:layout_width="wrap_content"
            Android:layout_height="wrap_content"
            Android:layout_gravity="center_horizontal"
            Android:textSize="24sp"
            Android:text="gravity=" />

        <TextView
            Android:layout_width="200dp"
            Android:layout_height="40dp"
            Android:background="#bcf5b1"
            Android:gravity="left"
            Android:text="left" />

        <TextView
            Android:layout_width="200dp"
            Android:layout_height="40dp"
            Android:background="#aacaff"
            Android:gravity="center_horizontal"
            Android:text="center_horizontal" />

        <TextView
            Android:layout_width="200dp"
            Android:layout_height="40dp"
            Android:background="#bcf5b1"
            Android:gravity="right"
            Android:text="right" />

        <TextView
            Android:layout_width="200dp"
            Android:layout_height="40dp"
            Android:background="#aacaff"
            Android:gravity="center"
            Android:text="center" />

    </LinearLayout>

    <LinearLayout
        Android:layout_width="match_parent"
        Android:layout_height="0dp"
        Android:layout_weight="1"
        Android:background="#d6c6cd"
        Android:orientation="vertical" >

        <TextView
            Android:layout_width="wrap_content"
            Android:layout_height="wrap_content"
            Android:layout_gravity="center_horizontal"
            Android:textSize="24sp"
            Android:text="layout_gravity=" />

        <TextView
            Android:layout_width="200dp"
            Android:layout_height="40dp"
            Android:layout_gravity="left"
            Android:background="#bcf5b1"
            Android:text="left" />

        <TextView
            Android:layout_width="200dp"
            Android:layout_height="40dp"
            Android:layout_gravity="center_horizontal"
            Android:background="#aacaff"
            Android:text="center_horizontal" />

        <TextView
            Android:layout_width="200dp"
            Android:layout_height="40dp"
            Android:layout_gravity="right"
            Android:background="#bcf5b1"
            Android:text="right" />

        <TextView
            Android:layout_width="200dp"
            Android:layout_height="40dp"
            Android:layout_gravity="center"
            Android:background="#aacaff"
            Android:text="center" />

    </LinearLayout>

</LinearLayout>

Apparenté, relié, connexe

490
Suragch

La différence

Android:layout_gravity est la gravité extérieure de la vue. Spécifie la direction dans laquelle la vue doit toucher la bordure de son parent.

Android:gravity est la gravité À l'intérieur de cette vue. Spécifie dans quelle direction son contenu doit s'aligner.

Équivalents HTML/CSS

Android                 | CSS
————————————————————————+————————————
Android:layout_gravity  | float
Android:gravity         | text-align

Truc facile pour vous aider à vous souvenir

Prenez layout-gravity comme "Lay-hors-gravité".

455
Vishnu Haridas

Réponse courte: utilisez Android:gravity ou setGravity() pour contrôler la gravité de toutes les vues enfant d'un conteneur; utilisez Android:layout_gravity ou setLayoutParams() pour contrôler la gravité d'une vue individuelle dans un conteneur.

Histoire longue: pour contrôler la gravité dans un conteneur à structure linéaire tel que LinearLayout ou RadioGroup, il existe deux approches:

1) Pour contrôler la gravité de TOUTES les vues enfants d'un conteneur LinearLayout (comme vous l'avez fait dans votre livre), utilisez Android:gravity (pas Android:layout_gravity) dans le fichier XML de présentation ou la méthode setGravity() dans le code. .

2) Pour contrôler la gravité d'une vue enfant dans son conteneur, utilisez l'attribut XML Android:layout_gravity XML. En code, il faut obtenir le LinearLayout.LayoutParams de la vue et définir sa gravité. Voici un exemple de code qui définit un bouton en bas dans un conteneur orienté horizontalement:

import Android.widget.LinearLayout.LayoutParams;
import Android.view.Gravity;
...

Button button = (Button) findViewById(R.id.MyButtonId);
// need to cast to LinearLayout.LayoutParams to access the gravity field
LayoutParams params = (LayoutParams)button.getLayoutParams(); 
params.gravity = Gravity.BOTTOM;
button.setLayoutParams(params);

Pour un conteneur LinearLayout horizontal, la gravité horizontale de sa vue enfant est alignée à gauche et ne peut pas être modifiée. Le réglage de Android:layout_gravity sur center_horizontal n'a aucun effet. La gravité verticale par défaut est center (ou center_vertical) et peut être modifiée en haut ou en bas. En réalité, la valeur par défaut de layout_gravity est -1, mais Android l'a mise au centre verticalement.

Pour modifier les positions horizontales des vues enfant dans un conteneur linéaire horizontal, vous pouvez utiliser layout_weight, la marge et le remplissage de la vue enfant.

De même, pour le conteneur Groupe de vues verticales, la gravité verticale de sa vue enfant est alignée vers le haut, l'une en dessous de l'autre, et ne peut pas être modifiée. La gravité horizontale par défaut est le centre (ou center_horizontal) et peut être modifiée à gauche ou à droite.

En fait, une vue enfant telle qu'un bouton possède également l'attribut XML Android:gravity et la méthode setGravity() pour contrôler ses vues enfant - le texte qu'elle contient. La Button.setGravity(int) est liée à ceci entrée developer.Android.com .

38
Ying

D'après ce que je peux comprendre layout_gravity est la gravité de cette vue à l'intérieur de son parent, et gravité est la gravité des enfants à l'intérieur de cette vue.

Je pense que c'est vrai, mais la meilleure façon de le savoir est de jouer.

35
matto1990

Regardez l'image pour bien comprendre la gravité

25
Akshay Paliwal

Bien que la question soit déjà résolue, j'ai quelques exemples démontrant l'utilisation de la gravité, de layout_gravity et de layout_weight.

Vous pouvez trouver les exemples sur http://juanpickselov.com/LayoutExamples.Zip

J'ai créé les fichiers dans Eclipse, supprimé les sous-dossiers .svn et ajouté des styles, des chaînes, des couleurs, etc. Les fichiers de mise en page sont le point principal des démonstrations. Étant donné que je suis un débutant en développement Java et Android, on peut trouver le inefficace Java. Les fichiers peuvent être copiés dans un projet Eclipse ou je les ai également utilisés dans Netbeans avec le plug-in de développement Android disponible pour cet IDE.

13
user244298

Si nous voulons définir la gravité du contenu dans une vue, nous utiliserons "Android: gravité", et si nous voulons définir la gravité de cette vue (dans son ensemble) dans sa vue parente, nous utiliserons "Android: layout_gravity ".

11
Abhishek Tamta

Je pensais que j'ajouterais ma propre explication ici - venant d'un contexte sur iOS, voici comment j'ai intériorisé les deux en termes iOS: "Layout Gravity" affecte votre position dans la vue d'ensemble. "Gravity" affecte la position de vos sous-vues en vous. Dit autrement, Layout Gravity vous positionne vous-même tandis que la gravité positionne vos enfants.

7
mszaro

Il y a beaucoup de différence dans les variables gravity et layout-gravity. Je vais expliquer mon expérience de ces 2 concepts ( Toutes les informations que j'ai obtenues en raison de mon observation et de certains sites Web ).

Utilisation de Gravity et de Layout-gravity dans FrameLayout .....

Remarque: -

  1. La gravité est utilisée à l'intérieur du Voir le contenu comme un utilisateur a la réponse et le est identique pour tous ViewGroup Layout.

  2. Layout-gravity est utilisé avec la vue parente en réponse à la demande de certains utilisateurs.

  3. Gravity and Layout-gravity est un travail plus utile avec les enfants FrameLayout. We can't use Gravity and Layout-gravity dans la balise de FrameLayout ....

  4. Nous pouvons définir la vue enfant n'importe où dans la FrameLayout en utilisant layout-gravity.

  5. Nous pouvons utiliser chaque valeur de gravité dans FrameLayout (par exemple: - center_vertical, center_horizontal, center, top, etc.), mais ce n'est pas possible avec d'autres ViewGroup. Layouts.

  6. FrameLayout travaille entièrement sur Layout-gravity. Exemple: - Si vous travaillez sur FrameLayout alors vous n'avez pas besoin de changer toute la mise en page pour ajouter une nouvelle vue. Vous venez d'ajouter View en dernier dans la FrameLayout et lui donnez Layout-gravity avec une valeur. ( Ceci est un avantage de la mise en page avec FrameLayout ).

ai regarder exemple ......

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

    <TextView
        Android:layout_width="match_parent"
        Android:layout_height="100dp"
        Android:textSize="25dp"
        Android:background="#000"
        Android:textColor="#264bd1"
        Android:gravity="center"
        Android:layout_gravity="center"
        Android:text="Center Layout Gravity"/>

    <TextView
        Android:layout_width="wrap_content"
        Android:layout_height="80dp"
        Android:textSize="25dp"
        Android:background="#000"
        Android:textColor="#1b64b9"
        Android:gravity="bottom"
        Android:layout_gravity="bottom|center"
        Android:text="Bottom Layout Gravity" />

    <TextView
        Android:layout_width="wrap_content"
        Android:layout_height="80dp"
        Android:textSize="25dp"
        Android:background="#000"
        Android:textColor="#d75d1c"
        Android:gravity="top"
        Android:layout_gravity="top|center"
        Android:text="Top Layout Gravity"/>

    <TextView
        Android:layout_width="wrap_content"
        Android:layout_height="80dp"
        Android:textSize="25dp"
        Android:background="#000"
        Android:layout_marginTop="100dp"
        Android:textColor="#d71f1c"
        Android:gravity="top|right"
        Android:layout_gravity="top|right"
        Android:text="Top Right Layout Gravity"/>


    <TextView
        Android:layout_width="wrap_content"
        Android:layout_height="80dp"
        Android:textSize="25dp"
        Android:background="#000"
        Android:layout_marginBottom="100dp"
        Android:textColor="#d71cb2"
        Android:layout_gravity="bottom"
        Android:gravity="bottom"
        Android:text="Top Left Layout Gravity"/>

</FrameLayout>

Sortie:-

g1

Utilisation de Gravity et Layout-gravity dans LinearLayout .....

Gravity fonctionne comme ci-dessus mais la différence ici est que nous pouvons utiliser Gravity à l'intérieur du LinearLayout View et RelativeLayout View, ce qui n'est pas possible dans FrameLayout View.

LinearLayout avec orientation verticale ....

Remarque: - Nous ne pouvons définir ici que 3 valeurs de layout_gravity c'est-à-dire (left | right | center (également appelé center_horizontal)).

regardez par exemple: -

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

    <TextView
        Android:layout_width="wrap_content"
        Android:layout_height="100dp"
        Android:textSize="25dp"
        Android:background="#000"
        Android:textColor="#264bd1"
        Android:gravity="center"
        Android:layout_gravity="center_horizontal"
        Android:text="Center Layout Gravity \nor \nCenter_Horizontal"/>

    <TextView
        Android:layout_width="wrap_content"
        Android:layout_height="80dp"
        Android:textSize="25dp"
        Android:background="#000"
        Android:layout_marginTop="20dp"
        Android:textColor="#d75d1c"
        Android:layout_gravity="right"
        Android:text="Right Layout Gravity"/>


    <TextView
        Android:layout_width="wrap_content"
        Android:layout_height="80dp"
        Android:textSize="25dp"
        Android:background="#000"
        Android:layout_marginBottom="100dp"
        Android:textColor="#d71cb2"
        Android:layout_gravity="left"
        Android:layout_marginTop="20dp"
        Android:gravity="bottom"
        Android:text="Left Layout Gravity"/>

</LinearLayout>

Sortie:-

g2

LinearLayout avec orientation horizontale ....

Remarque: - Nous pouvons également définir 3 valeurs de layout_gravity c'est-à-dire (top | bottom | center (également appelé center_vertical)).

regardez par exemple: -

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

    <TextView
        Android:layout_width="120dp"
        Android:layout_height="100dp"
        Android:textSize="25dp"
        Android:background="#000"
        Android:textColor="#264bd1"
        Android:gravity="center"
        Android:layout_gravity="bottom"
        Android:text="Bottom \nLayout \nGravity"/>

    <TextView
        Android:layout_width="120dp"
        Android:layout_height="100dp"
        Android:textSize="25dp"
        Android:background="#000"
        Android:layout_marginTop="20dp"
        Android:textColor="#d75d1c"
        Android:layout_gravity="center"
        Android:text="Center \nLayout \nGravity"/>


    <TextView
        Android:layout_width="150dp"
        Android:layout_height="100dp"
        Android:textSize="25dp"
        Android:background="#000"
        Android:layout_marginBottom="100dp"
        Android:textColor="#d71cb2"
        Android:layout_gravity="left"
        Android:layout_marginTop="20dp"
        Android:text="Left \nLayout \nGravity"/>

</LinearLayout>

sortie:-

g3

Remarque: - Nous ne pouvons pas utiliser layout_gravity dans le RelativeLayout Views, mais nous pouvons utiliser gravity pour définir RelativeLayout enfants à la même position. ...

6
sushildlh

Une astuce facile à retenir est que la gravité s’applique à nous à l’intérieur de la Terre. Donc, Android:gravity est pour à l'intérieur la vue.

Souvenez-vous du out in lay out _ gravité qui vous aiderait à vous rappeler que Android:layout_gravity ferait référence à extérieur la vue

4
Mahendra Liya

Quelque chose que j'ai presque raté sur le blog de Sandip a résolu mon problème. Il a dit que layout_gravity NE FONCTIONNE PAS AVEC LinearLayout.

Si vous utilisez un LinearLayout et que les paramètres de gravité vous rendent fous (comme moi), passez à autre chose.

En fait, je suis passé à RelativeLayout, puis j’ai utilisé layout_alignParentLeft et layout_alignParentRight sur les 2 contenus TextViews pour les obtenir sur une seule ligne pour aller très à gauche et à droite.

4
JustSomeGuy

Gravity: Permet de déplacer le contenu dans un conteneur. (Comment les sous-vues seront placées).

Important: (Déplacez-vous le long de l’axe X ou de l’axe Y dans l’espace disponible).

Exemple: Supposons que si vous utilisiez LinearLayout (Height: match_parent, Width: match_parent) en tant qu'élément de niveau racine, vous disposerez alors d'un espace de trame complet. et les vues enfants indiquent 2 TextViews (Height: wrap_content, Width: wrap_content) à l'intérieur de LinearLayout peuvent être déplacés le long de l'axe x/y en utilisant les valeurs correspondantes de gravité sur le parent.

Layout_Gravity: Vous permet de remplacer le comportement de gravité parent UNIQUEMENT le long de l'axe des x.

Important: (MOVE [override] le long de l'axe des X dans l'espace disponible).

Exemple: Si vous gardez à l'esprit l'exemple précédent, nous savons que la gravité nous a permis de nous déplacer le long des axes x/y, c'est-à-dire; la place TextViews dans LinearLayout. Disons simplement que LinearLayout spécifie la gravité: center; Cela signifie que chaque TextView doit être centré verticalement et horizontalement. Maintenant, si nous voulons que l'un des TextView aille à gauche/à droite, nous pouvons remplacer le comportement de gravité spécifié en utilisant layout_gravity sur le TextView.

Bonus: Si vous creusez plus profondément, vous découvrirez que le texte dans TextView agit comme une vue secondaire; ainsi, si vous appliquez la gravité sur TextView, le texte à l'intérieur de TextView se déplacera. (le concept entier s'applique ici aussi)

2
Ali Raza

Android:gravity est utilisé pour spécifier comment placer le contenu de l'objet dans l'objet même. Dans un autre mot, Android: la gravité est utilisée pour spécifier la gravité du contenu de la vue.

Android:layout_gravity est une attribution que l'enfant peut fournir à son parent, afin de spécifier la gravité de la vue dans ses parents.

Pour plus de détails, vous pouvez visiter

http://developer.Android.com/reference/Android/widget/LinearLayout.LayoutParams.html

2
IntelliJ Amiya

La différence fondamentale entre les deux est que-

Android: gravity est utilisé pour les éléments enfants de la vue.

Android: layout_gravity est utilisé pour cet élément par rapport à la vue parent.

2
Abhishek Tandon

La gravité est utilisée pour définir l'alignement du texte dans les vues, mais layout_gravity est utilisée pour définir les vues elle-même. Prenons un exemple si vous souhaitez aligner le texte écrit dans editText, puis utilisez la gravité et vous souhaitez aligner ce editText ou n'importe quel bouton ou n'importe quelle vue, puis utilisez layout_gravity. C'est donc très simple.

1
Praveen Gaur

gravité: est utilisé pour des vues simples comme textview, edittext etc.

layout_gravity: est utilisé pour la gravure de la vue actuelle uniquement dans le contexte de sa vue parente relative, telle que Layout linéaire ou FrameLayout, pour rendre la vue au centre ou toute autre gravité de son parent.

1
Mayank Garg

gravité - s'applique à sa propre vue.

layout-gravity --- S'applique à la vue associée à son parent.

0
nidhi

Android:gravity -> Définit la gravité du contenu de la vue utilisée.

Android:layout_gravity -> Définit la gravité de la vue ou de la disposition de son parent

0
Vamsi
Android:gravity

est utilisé pour ajuster le contenu de la vue par rapport à sa position spécifiée (zone allouée). Android:gravity="left" ne ferait rien si layout_width est égal au "wrap_content"

Android:layout_gravity

est utilisé pour la vue elle-même par rapport au fichier parent ou au fichier de mise en page.

0
Tulsi