Inverser le sens d'un LinearLayout

Comment puis-je inverser le sens d'un linéaire de mise en page?

par exemple, si ma mise en page est [vue1, vue2, vue3] je veux créer [vue3, vue2, vue1]. Mon but est de gonfler un à gauche et un à droite, a remis des instances à partir d'un XML de mise en page.

OriginalL'auteur ZeroEric | 2012-12-16

10

En général, je dirais que vous ne pouvez pas faire cela en utilisant le SDK standard. Vous pouvez toutefois créer une méthode qui obtient tous les sous-vues de la LinearLayout, supprime de la LinearLayout, et ajoute ensuite les remettre dans l'ordre inverse.
```
LinearLayout ll = //inflate
ArrayList<View> views = new ArrayList<View>();
for(int x = 0; x < ll.getChildCount(); x++) {
    views.add(ll.getChildAt(x));
}
ll.removeAllViews();
for(int x = views.size() - 1; x >= 0; x--) {
    ll.addView(views.get(x));
}
```
c'est une bonne solution si, il fonctionne de manière dynamique. mais il sait le point de vue de la r du même type, alors ma solution est la meilleure. de toute façon, +1 pour cette. 🙂
Une petite correction, j'ai changé le "<=" dans la deuxième boucle for pour ">=". Il a parfaitement fonctionné! Merci.
bonne prise. fixe.

OriginalL'auteur mtmurdock

Vous pouvez contrôler la direction de la mise en page directement par le biais de la layoutDirection. Dans ce code, nous détecter si la direction naturelle est RTL, et inverser le sens, évidemment, on peut appliquer votre propre logique de l'inversion:

LinearLayout buttonsContainer = (LinearLayout) findViewById(R.id.buttonsContainer);          
buttonsContainer.setLayoutDirection(isRTL() ? LinearLayout.LAYOUT_DIRECTION_LTR : 
                                    LinearLayout.LAYOUT_DIRECTION_RTL)

public static boolean isRTL() {
        return isRTL(Locale.getDefault());
}

public static boolean isRTL(Locale locale) {
    final int directionality = Character.getDirectionality(locale.getDisplayName().charAt(0));
    return directionality == Character.DIRECTIONALITY_RIGHT_TO_LEFT ||
            directionality == Character.DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC;
}

Ou via XML dans le cas où vous souhaitez remplacer la direction naturels constamment:

<LinearLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="horizontal"
        android:layoutDirection="ltr"
        >
...
</LinearLayout>

De détection de RTL est prise à partir de cette question: Identifyng RTL langue dans Android

Il super cool solution si vous minSdkVersion est de 17

OriginalL'auteur ohad serfaty

c'est l'approche la plus simple 🙂

for(int k = ll.getChildCount()-1 ; k >= 0 ; k--)
{
    View item = ll.getChildAt(k);
    ll.removeViewAt(k);
    ll.addView(item);
}

à droite, c'est la plus simple et la meilleure réponse !

OriginalL'auteur mahdi_m

Moyen Simple d'essayer cette

LinearLayout ll = (LinearLayout)findViewById(R.id.ll1);
    View v0 = ll.getChildAt(0);
    View v1 = ll.getChildAt(1);
    View v2 = ll.getChildAt(2);

    ll.removeAllViews();

    ll.addView(v2);
    ll.addView(v1);
    ll.addView(v0);

OriginalL'auteur Ali Imran

0
```
<LinearLayout
    android:id="@+id/parent"
    ...... 
    ......>
  view1
  view2
  view2
<LinearLayout/>
```
Maintenant, vous pouvez essayer ce
```
LinearLayout parent = (LinearLayout)findViewById(R.id.parent);
View view1 = (View)parent.getChildAt(0);  //it will give first view
View view3 = (View)parent.getChildAt(2);  //it will give you third view
```
Ici par Vue , il peut être TextView,Bouton....etc.

C'est une bonne solution, mais ne fonctionnera que si tous les trois (ou au moins la première et la dernière) vues sont du même type. Que faire si ils sont de types différents ou ont des propriétés différentes? Votre solution ne serait pas inverser ces.
dans ce cas, il doit utiliser un if-else selon sa logique.
Si-sinon vous ne pouvez pas modifier le type d'un objet. Ce que vous proposez ne change pas l'ordre, il change juste les données stockées dans chaque vue donnant l'apparence d'une modification de l'ordre.
u n'a pas l'obtenir itwhat je voulais dire.de toute façon, tout dépend du sens de la question.

OriginalL'auteur Android Killer
0

Comment puis-je inverser le sens d'un linéaire de mise en page?

Qui n'est pas pris en charge, désolé.

Mon but est de gonfler un à gauche et un à droite, a remis des instances à partir d'un XML de mise en page.

Vous êtes les bienvenus pour les gonfler à la fois à partir d'un XML de mise en page, mais vous devrez alors supprimer tous les enfants de l'un et de l'inverse de leur ordre dans le code Java. Peut-être que c'est plus simple que de maintenir les deux fichiers de mise en page, mais ce n'est certainement pas automatique.

Ou, vous êtes invités à créer votre propre sous-classe de LinearLayout (ou peut-être le clone LinearLayout) qui offre cette fonctionnalité.

Android 4.2 et supérieur offre RTL soutien pour LinearLayout, mais qui est lié à des paramètres régionaux et s'appliquerait à tous les LinearLayout conteneurs dans votre application.

OriginalL'auteur CommonsWare
0

avis pour le prev réponses, si vous souhaitez conserver la largeur/hauteur de vues, calculé par la passe directe (c'est à dire remplir parent/wrap de contenu), vous devez définir explicitement:
```
for (int i = views.size() - 1; i >= 0; i--)
{
    View v = views.get(i);
    linearLayoutHor.addView(v, v.getWidth(), v.getHeight());
}
```
peut-être, vous devrez utiliser la poste à vue pour être sûr tailles de vues sont calculés. et ajouter un gestionnaire pour les changements d'orientation de l'avoir des tailles recalculées correctement.

OriginalL'auteur
0

Vous pouvez essayer ViewCompat.setLayoutDirection(view, direction)

OriginalL'auteur joecizac
0

Il suffit d'ajouter le code suivant à LinearLayout:
```
android:layoutDirection="rtl"
```
Mais définitivement inverse l'ordre - et pas seulement pour RTL de paramètres régionaux 🙁

OriginalL'auteur Dmitry

Vous devez vous connecter pour publier un commentaire.