Android linearlayout gravity center vertical

LinearLayout

Общая информация

В студии макет LinearLayout представлен двумя вариантами — Horizontal и Vertical. Макет LinearLayout выравнивает все дочерние объекты в одном направлении — вертикально или горизонтально. Направление задается при помощи атрибута ориентации android:orientation:

Все дочерние элементы помещаются в стек один за другим, так что вертикальный список компонентов будет иметь только один дочерний элемент в ряду независимо от того, насколько широким он является. Горизонтальное расположение списка будет размещать элементы в одну строку с высотой, равной высоте самого высокого дочернего элемента списка.

В этом примере используются два способа размещения элементов TextView: по горизонтали и по вертикали.

У разметки LinearLayout есть интересный атрибут android:layout_weight, который назначает индивидуальный вес для дочернего элемента. Этот атрибут определяет «важность» представления и позволяет этому элементу расширяться, чтобы заполнить любое оставшееся пространство в родительском представлении. Заданный по умолчанию вес является нулевым.

Например, если есть три текстовых поля, и двум из них объявлен вес со значением 1, в то время как другому не даётся никакого веса (0), третье текстовое поле без веса не будет расширяться и займёт область, определяемую размером текста, отображаемого этим полем. Другие два расширятся одинаково, чтобы заполнить остаток пространства, не занятого третьим полем. Если третьему полю присвоить вес 2 (вместо 0), это поле будет объявлено как «более важное», чем два других, так что третье поле получит 50% общего пространства, в то время как первые два получат по 25% общего пространства.

Также можно указать атрибут android:weightSum. Если атрибуту присвоить значение 100, то можно указывать вес дочерних элементов в удобном виде, как в процентах. Такой способ широко используется веб-мастерами при вёрстке.

Создадим простейшую разметку таким образом, чтобы дочерний элемент занимал половину родительского контейнера:

Примеры

Рассмотрим возможности LinearLayout на примерах.

Создадим 7 текстовых меток и присвоим им цвета радуги. Расположим их друг за другом. Получим следующий результат

Отцентрируем текст в TextView при помощи свойства Gravity, установив значение Center. Аналогично поступим и с LinearLayout, чтобы выровнять по центру текстовые метки.

Цветные полоски получились слишком узкими. Расширим их за счет увеличения размера шрифта (TextSize) у текстовых меток.

Стало чуть лучше, но все равно пропадает много свободного пространства. Совсем не хочется видеть чёрный цвет сверху и снизу. Здесь нам придёт на помощь свойство Layout weight. Так как число 7 не совсем удобное для деления, то поступим следующим образом. Пяти элементам присвоим вес 0.14, а двум — 0.15, что в сумме даст 1.0. Теперь элементы равномерно заполнят весь экран.

Если мы хотим сделать плавное увеличение высоты полоски, то вес нужно распределить таким образом: 0.08, 0.10, 0.12, 0.14, 0.16, 0.18, 0.22.

Чем хорош этот способ? Мы не привязываемся к точным размерам, а позволяем системе самой расчитывать равномерное распределение элементов по экрану. Если в Eclipse вы выберите режим Landscape, то экран будет выводиться в альбомном режиме и при этом элементы по-прежнему будет равномерно распределены.

Градиентный фон

Если вам нужен градиентный фон для LinearLayout, то создайте в папке res/drawable xml-файл, например, gradient.xml:

Далее остаётся только прописать файл в свойстве Background:

Меняем фон программно

Чтобы программно сменить фоновый цвет у LinearLayout, нужно вызвать метод setBackgroundColor(). Пример изменения фона можно найти в статье Android::Класс android.graphics.Color.

Программная анимация компоновки

Хочу показать один пример программной анимации. Не знаю, имеет ли пример практическую ценность, но для общего развития не помешает. Добавьте в шаблон LinearLayout несколько кнопок, текстовых полей и других элементов на ваше усмотрение. Далее пишем код для обработчика щелчка кнопки и вспомогательный класс для анимации:

Когда вы щелкните на кнопке, то LinearLayout будет плавно увеличиваться в размерах. Данный приём можно использовать не только к компоновке, но и к любому объекту View.

Отключаем выравнивание по базовой линии

Допустим, у вас есть следующая разметка:

Если посмотрим, что получилось, то увидим, что средняя кнопка опустилась вниз.

Строго говоря, разметка составлена не совсем правильно, используя жёстко установленные величины. Но будем считать, что такой код достался от другого программиста и заказчик не хочет его кардинально менять. Причина такого поведения кнопки в том, что по умолчанию Android пытается выравнивать элементы по некой базовой линии. А средняя кнопка имеет слишком длинный текст и она вот таким причудливым образом сместилась вниз. Можно попробовать использовать свойства gravity, но можно поступить проще. Добавьте атрибут android:baselineAligned=»false» к LinearLayout и все три кнопки будут аккуратно находиться на одной линии. Имейте в виду, может пригодится.

Разделители

Начиная с API 11, у LinearLayout появился новый атрибут android:divider, позволяющий задать графический разделитель между кнопками. Также нужно явно включить использование разделителей через атрибут android:showDividers, в котором можно указать, каким образом использовать разделители — только в середине, в начале, в конце — можно комбинировать эти значения.

Создадим в папке res/drawable файл separator.xml:

Разметка для активности:

Разделители могут оказаться полезными. В статье Grid Spacing on Android показан хороший пример на эту тему.

Допустим, мы хотим вывести в ряд три кнопки под каким-то компонентом, например, логотипом компании. Разметка может быть следующей.

Вместо @dimen/spacing_medium можете подставить 8dp, а цвета придумать свои, если будете проверять пример самостоятельно.

Видно, что напрашивается дизайн в виде сетки. Отсутствие пространства между кнопками может создать неудобства у пользователя. Добавим их. У контейнера @id/buttons_container добавим android:layout_marginTop=»@dimen/spacing_medium», а у первой и второй кнопки добавим android:layout_marginRight=»@dimen/spacing_medium» (напомню, можно использовать 8dp)

Всё отлично работает до того момента, если нам понадобится программно убрать с экрана третью кнопку. Сделать это можно через View.GONE. И что мы увидим?

Теперь вторая кнопка не выровнена по правому краю. Некрасиво. Очень плохим решением станет программный пересчёт всех величин, чтобы выровнять компоненты. Как вариант, использовать другой тип разметки, например, GridLayout. Но у него есть свои проблемы с отступами и вам будет тяжело добиться нужного результата.

Проблема красиво решается с помощью упомянутых выше разделителей. Создадим в папке res/drawable файл spacer_medium.xml:

Теперь кнопки всегда будут аккуратно выравнены по краям, независимо от их количества — две или три.

Программное создание разметки LinearLayout

В некоторых случаях может понадобиться создать LinearLayout программным способом. Сначала создаётся объект LayoutParams, на его основе создаётся LinearLayout, а позже в него добавляются дочерние компоненты.

Также программно можно управлять настройками LinearLayout через тот же объект LayoutParams. Разместите кнопку с обработчиком щелчка.

Каждый щелчок на кнопке будет увеличивать отступ на пять единиц и кнопка будет смещаться в сторону. Интересно, что если убрать TextView, то кнопка перестаёт двигаться. Причина мне неизвестна.

Источник

Основы верстки для нативных андроид приложений

( пользоваться не рекомендуется, deprecated )
AbsoluteLayout — означает что каждый элемент верстки будет иметь абсолютную позицию относительно верхнего левого угла экрана задаваемую с помощью координат x и y. Т.е. верхнийлевый угол экрана при AbsoluteLayout имеет координаты x = 0, y = 0.
Позиция указывается в атрибутах элемента android:layout_x и android:layout_y.
Пример кода:

FrameLayout

FrameLayout — тип верстки внутри которого может отображаться только один элемент в строке. Т.е. если внутри FrameLayout вы поместите несколько элементов, то следующий будет отображаться поверх предыдущего.
Пример кода:

LinearLayout

LinearLayout — тип верстки при котором область верстки делится на строки и в каждую строку помещается один элемент. Разбиение может быть вертикальное или горизонтальное, тип разбиения указывается в атрибуте LinearLayout android:orientation. Внутри верстки возможно комбинировать вертикальную и горизонтальную разбивки, а кроме того, возможна комбинация нескольких разных типов верстки например использование LinearLayout внутри FrameLayout.

Пример вертикальной разбивки LinearLayout:

Пример горизонтальной разбивки LinearLayout:

Комбинация нескольких LinearLayout:

RelativeLayout

RelativeLayout — тип верстки при котором позиционирование элементов происходит относительно друг друга и относительно главного контейнера.
За то, каким образом будут позиционироваться элементы отвечают следующие атрибуты:
Атрибуты позиционирования относительно контейнера

• android:layout_alignParentBottom – Низ элемента находится внизу контейнера
• android:layout_alignParentLeft – Левая часть элемента прилегает к левой части контейнера
• android:layout_alignParentRight – Правая часть элемента прилегает к правой части контейнера
• android:layout_alignParentTop – Элемент находится в верхней части контейнера
• android:layout_centerHorizontal – Элемент позиционируется по центру относительно горизонтального размера контейнера
• android:layout_centerInParent – Элемент позиционируется по центру относительно горизонтального и вертикального размеров размера контейнера
• android:layout_centerVertical – Элемент позиционируется по центру относительно вертикального размера контейнера

Атрибуты позиционирования относительно других элементов.
В качестве значений этих атрибутов ставятся id элемента относительно которого будет производится позиционирование.

android:layout_above – Распологает элемент над указанным
android:layout_below – Распологает элемент под указанным
android:layout_toLeftOf – Распологает элемент слева от указанного
android:layout_toRightOf – Распологает элемент справа от указанного

Выравнивание относительно других элементов.

android:layout_alignBaseline – Выравнивает baseline элемента с baseline указаннго элемента
android:layout_alignBottom – Выравнивает низ элемента по низу указанного элемента
android:layout_alignLeft – Выравнивает левый край элемента с левым краем указанного элемента
android:layout_alignRight – Выравнивает правый край элемента с правым краем указанного элемента
android:layout_alignTop – Выравнивает верхнюю часть элемента в соответствие с верхней частью указанного элемента

TableLayout

TableLayout — табличная верстка.
Организует элементы в строки и столбцы таблицы.
Для организации строк служит таг

Alternate Layouts

Alternate Layouts — альтернативная верстка. Позволяет использовать различную верстку для различных ориентаций экрана.
XML для альтернативной верстки помещается в папки проекта:

res/layout-land – альтернативная верстка для landscape UI
res/layout-port –альтернативная верстка для portrait UI
res/lauout-square – альтернативная верстка для square UI

и перед тем как получить макет из res/lauout система проверяет наличие файлов в этих папках.

И в завершении немного о стилях.

Стили

Во первых стили элемента могут быть описаны в атрибутах самого элемента.
Например:

Кроме того стили можно вынести в отдельный xml файл и сохранить его в папке res/values/
Напимер:

Если мы вынесем стили в отдельный файл, то для описания стилей элемента будем использовать атрибут style.

Источник

Гравитация и layout_gravity на Android

Я знаю, что мы можем установить следующие значения для свойств android:gravity and android:layout_gravity :

1. center
2. center_vertical
3. center_horizontal и т. Д.

Но я смущен в отношении обоих.

В чем разница между использованием android:gravity и android:layout_gravity ?

Их имена должны помочь вам:

• android:gravity задает тяжесть содержимого вида, в котором он используется.
• android:layout_gravity устанавливает серьезность представления или Layout в его родительском android:layout_gravity .

android:layout_gravity – это внешняя гравитация вида. Это означает, что нужно указать направление, в котором вид должен касаться границы его родителя.

android:gravity – это внутренняя гравитация этого вида. Это означает, что в этом направлении содержимое должно совпадать.

Эквиваленты HTML / CSS:

android:layout_gravity = float в CSS

android:gravity = text-align в CSS

Легкий трюк, который нужно запомнить: возьмите «макет-гравитацию» как «Lay-outside-gravity»

Внутри снаружи

• gravity упорядочивает содержимое внутри представления.
• lay out _gravity устраивает позицию взгляда вне себя.

Иногда это помогает увидеть и картинку. Зеленые и синие – это TextViews а два других цвета фона – LinearLayouts .

Заметки

• Функция layout_gravity не работает для представлений в RelativeLayout . Используйте его для просмотра в LinearLayout или FrameLayout . Дополнительную информацию см. В моем дополнительном ответе .
• Ширина представления (или высота) должна быть больше, чем его содержимое. В противном случае gravity не будет иметь никакого эффекта. Таким образом, wrap_content и gravity имеют смысла вместе.
• Ширина представления (или высота) должна быть меньше, чем у родителя. В противном случае layout_gravity не будет иметь никакого эффекта. Таким образом, match_parent и layout_gravity имеют смысла вместе.
• Центр layout_gravity=center выглядит так же, как layout_gravity=center_horizontal потому что они находятся в вертикальном линейном макете. Вы не можете layout_gravity=center вертикально в этом случае, поэтому layout_gravity=center только центрируется по горизонтали.
• Этот ответ касался только установки gravity и layout_gravity на представлениях в макете. Чтобы узнать, что произойдет, когда вы установите gravity самого родительского макета, ознакомьтесь с дополнительным ответом, о котором я говорил выше. (Резюме: gravity не работает на RelativeLayout но может быть полезна с LinearLayout .)

Поэтому помните, что макет _gravity упорядочивает представление в своем макете . Гравитация упорядочивает содержимое внутри представления.

Вот xml для приведенного выше изображения для вашей справки:

Связанный

• Разница между запасом и маркой View
• Match_parent vs wrap_content
• Как настроить гравитацию и плотность размещения LinearLayout программно

Короткий ответ: используйте android:gravity или setGravity() чтобы контролировать гравитацию всех видов ребенка в контейнере; Используйте android:layout_gravity или setLayoutParams() для управления гравитацией отдельного вида в контейнере.

Длинная история: для управления гравитацией в линейном контейнере макета, таком как LinearLayout или RadioGroup , существует два подхода:

1) Чтобы контролировать гравитацию всех дочерних видов контейнера LinearLayout (как и в вашей книге), используйте метод android:gravity (не android:layout_gravity ) в формате XML-файла или setGravity() в коде.

2) Чтобы контролировать гравитацию детского вида в контейнере, используйте атрибут android:layout_gravity XML. В коде нужно получить LinearLayout.LayoutParams представления и установить его силу тяжести. Вот пример кода, который устанавливает кнопку внизу в горизонтально ориентированном контейнере:

Для горизонтального контейнера LinearLayout горизонтальная гравитация его дочернего вида выравнивается по левому краю один за другим и не может быть изменена. Установка android:layout_gravity в center_horizontal не влияет. Вертикальная гравитация по умолчанию – центральная (или центральная) и может быть изменена на верхнюю или нижнюю. Фактически значение layout_gravity по умолчанию layout_gravity -1 но Android ставит его вертикально по центру.

Чтобы изменить горизонтальные положения дочерних видов в горизонтальном линейном контейнере, можно использовать layout_weight , margin и padding дочернего представления.

Аналогично, для вертикального контейнера View Group вертикальная гравитация его дочернего представления выравнивается по высоте одна под другой и не может быть изменена. По умолчанию горизонтальная гравитация является центральной (или center_horizontal ) center_horizontal и может быть изменена влево или вправо.

Фактически, дочерний вид, такой как кнопка, также имеет атрибут android:gravity XML и метод setGravity() для управления его дочерними представлениями – текст в нем. Button.setGravity(int) связан с этой записью developer.android.com .

Из того, что я могу собрать, layout_gravity – это серьезность этого представления внутри его родителя, а гравитация – это сила тяжести детей внутри этой точки зрения.

Я думаю, что это правильно, но лучший способ узнать – это поиграть.

Посмотрите на изображение, чтобы быть понятным о гравитации

Хотя вопрос уже ответил, у меня есть несколько примеров, демонстрирующих использование силы тяжести, layout_gravity и layout_weight.

Я создал файлы в Eclipse, удалил подпапки .svn и включил стили, строки, цвета и т. Д. Файлы макетов являются основной темой демонстраций. Поскольку я являюсь разработчиком Java и Android, можно найти Java неэффективным. Файлы могут быть скопированы в проект Eclipse или я также использовал их в Netbeans с плагином разработки Android, доступным для этой среды разработки.

Если мы хотим установить серьезность содержимого внутри представления, мы будем использовать «android: gravity», и если мы хотим установить серьезность этого представления (в целом) в его родительском представлении, мы будем использовать «android: layout_gravity».

Просто подумал, что я добавлю свое объяснение здесь – исходя из фона на iOS, вот как я усвоил эти два термина iOS: «Макет Gravity» влияет на вашу позицию в супервизии. «Гравитация» влияет на положение ваших подзонов внутри вас. С другой стороны, Layout Gravity позиционирует вас самостоятельно, в то время как гравитация позиционирует ваших детей.

Что-то, что я видел в блоге Сандипа, которое я почти пропустил, исправил мою проблему. Он сказал, что layout_gravity не работает с LinearLayout .

Если вы используете LinearLayout а настройки гравитации приводят вас в орехи (как и я), переключитесь на что-то еще.

Я фактически переключился на RelativeLayout затем использовал layout_alignParentLeft и layout_alignParentRight на 2 содержащихся TextView s, чтобы получить их на одной строке, чтобы идти далеко влево и вправо.

Существует много различий в gravity и layout-gravity . Я собираюсь объяснить свой опыт в отношении этих двух концепций ( вся информация, полученная из-за моего наблюдения и некоторых веб-сайтов ).

Использование гравитации и макета гравитации в FrameLayout …..

Заметка:-

Гравитация используется внутри Просмотр содержимого, так как у некоторых пользователей есть ответ, и он одинаковый для всех ViewGroup Layout .

Layout-gravity используется с родительским представлением, поскольку у некоторых пользователей есть ответ.

Gravity and Layout-gravity – это более полезная работа с FrameLayout . We can’t use Gravity and Layout-gravity в теге FrameLayout ….

Мы можем установить Child View в любом месте в FrameLayout используя layout-gravity .

Мы можем использовать каждое значение гравитации внутри FrameLayout (например: – center_vertical , center_horizontal , center , top и т. Д.), Но это невозможно с другими макетами ViewGroup.

FrameLayout полностью работает над Layout-gravity . Пример: – Если вы работаете с FrameLayout вам не нужно менять весь макет для добавления нового представления. Вы просто добавляете View как последний в FrameLayout и даете ему Layout-gravity со значением. ( Это преимущества макета-гравитации с помощью FrameLayout ).

Использование гравитации и макета гравитации в LinearLayout …..

Gravity работающая так же, как и выше, но здесь отличается тем, что мы можем использовать Gravity внутри LinearLayout View и RelativeLayout View что невозможно в представлении FrameLayout View .

LinearLayout с ориентацией по вертикали ….

Примечание. Здесь мы можем установить только 3 значения layout_gravity которые ( left | right | center (также называемые center_horizontal )).

LinearLayout с горизонтальной ориентацией ….

Примечание: – Здесь мы также можем установить 3 значения layout_gravity которые ( top | bottom | center (также называемый center_vertical )).

Примечание. – Мы не можем использовать layout_gravity в RelativeLayout Views но мы можем использовать gravity чтобы установить RelativeLayout childs в ту же позицию ….

android:gravity используется, чтобы указать, как разместить содержимое объекта внутри самого объекта. Другими словами, андроид: гравитация используется для определения тяжести содержимого представления.

android:layout_gravity – это атрибуция, которую ребенок может предоставить своему родителю, чтобы определить серьезность представления внутри своих родителей.

Более подробную информацию вы можете посетить

Основное различие между ними состоит в том,

Android: гравитация используется для дочерних элементов представления.

Android: layout_gravity используется для этого элемента относительно родительского представления.

Легкий трюк, чтобы помнить об этом – сила тяжести относится к нам внутри Земли. Итак, android:gravity для внутреннего зрения.

Вспомните, как вы выложите _gravity, который поможет вам запомнить этот android:layout_gravity будет ссылаться на внешний вид

Гравитация используется для установки выравнивания текста в представлениях, но layout_gravity используется для установки собственных представлений. Давайте возьмем пример, если вы хотите выровнять текст, написанный в editText, затем использовать гравитацию, и вы хотите выровнять этот editText или любую кнопку или любое представление, а затем использовать layout_gravity, поэтому его очень просто.

Используется для настройки содержимого представления относительно его заданной позиции (выделенной области). android:gravity=»left» ничего не сделает, если layout_width равно «wrap_content»

Используется для представления относительно родительского или файла макета.

Gravity: используется для простых представлений, таких как textview, edittext и т. Д.

Layout_gravity : используется для родительских представлений, таких как линейный макет, чтобы сделать вид в центре его родителей.

android:gravity -> Устанавливает гравитацию содержимого вида, в котором он используется.

android:layout_gravity -> Устанавливает серьезность представления родителя или макета

Источник