Резиновая сетка



Размер 350×350 мм
Толщина: 20, 30 мм
Материал: 90% резиновая крошка 10% полиуретан
Температура использования: +60 °С… -50 °С
Плотность: 850 кг/м³ — стандарт. Возможно изготовление более плотной плитки
Морозоустойчивость: Нет изменений 20 циклов — 27 °С
Химическая устойчивость: Бензин — нет повреждений. Масло — нет повреждений. Стойкость к кратковременным воздействиям кислот и щелочей
Водопроницаемость: Плитка водопроницаема
Цветовая гамма: Терракотовый, зеленый, желтый, темно-синий, синий, оранжевый, коричневый, черный, серый
Сферы применения: Используется резиновая плитка для улицы, помещений и поверхностей, где требуются нескользкие, эластичные звуко-, шумопоглощающие покрытия. Тренажерные залы, коммерческие помещения, выставки и экспозиции, остановки, причалы и т.д.
Прочность: Длительный срок использования до 10 лет, высокая стойкость к истираемости, стойкость к механическим повреждениям, высокий уровень допустимых нагрузок.
Установка покрытия: При использовании на твердом основании плитка приклеивается с помощью полиуретанового связующего
Рекомендуемое основание: Рекомендуется использование на твердом основании
Место использования: Улица, помещения
Содержание, обслуживание, уход: Покрытие можно убирать с использованием обычных средств и инструментов для уборки. Внутри помещения возможна сухая и влажная уборка или пылесос. При уборке на улице используются метлы, шланги для полива, пневмомашины для сдувания листьев. В зимнее время рекомендуется чистка пластиковыми и деревянными лопатами.
Ремонт: Ремонтопригодная, возможна легкая замена испорченной плитки на новую.

Источник: www.ecospline.ru

Адаптивный дизайн – это процесс распределения шаблона таким образом, чтобы вся информация первой важности оказалась в первую очередь видна пользователям, которые используют устройства с маленькими экранами. Большинство дизайнеров выбирают сеточные шаблоны, так как этим видом шаблонов довольно просто управлять на многих устройствах.

Вы сами выбираете между фиксированным или гибким шаблоном. В нашем сегодняшнем руководстве мы хотим заострить внимание на гибких сетках и их важности в адаптивном дизайне.

Что такое гибкие сетки?

Важно узнать о предназначении гибких сеток до того, как начать думать о дизайнах. Вряд ли можно найти лучшее объяснение слову fluid (гибкий), чем написано на Wikipedia.

«Флюид (от лат. fluidis — «текучий») — вещество, поведение которого при деформации может быть описано законами механики жидкостей»


Итак, давайте мы постараемся объяснить выше описанное простыми практическими терминами. В веб-дизайне, это текучее вещество будет представлять собой наш дизайн или шаблон, и будет адаптироваться к размеру экрана наших пользователей. Независимо от того, каков размер устройства нашего пользователя, компоненты гибкого дизайна будут располагаться на экране так, чтобы пользователю было комфортно ими пользоваться.

Важность гибких сеток

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

Мобильные устройства становятся все меньше и меньше в размере, и люди предпочитают использовать их в повседневной работы. С другой стороны, настольные мониторы становятся больше, и разрешения отображения повышаются. Так что, разрабатывая адаптивный дизайн, мы не можем планировать его только для маленьких устройств. Преимущество гибких сеток заключается в том, что мы можем выставить параметр max-width, и тогда шаблон будет отлично отображаться даже на большом экране, так как здесь все указывается в процентном соотношении.

Как работают гибкие сетки

Мы привыкли разрабатывать дизайн при помощи фиксированных сеток и 960-пиксельной сеточной системы. Затем шаблоны стали адаптивными, в которых мы используем разное количество пикселей при разных размерах экрана. Все было основано на пиксельных шаблонах дизайна. Теперь пришло время создавать дизайны на базе процентных соотношений, и такие дизайны называются гибкими.


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

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

Генераторы и системы гибких сеток

Не так-то просто создать гибкую сетку с нуля, так это на это требуется довольно много времени и усилий. Следовательно, гораздо лучше будет воспользоваться CSS Grid Framework или Grid Generator в качестве основы нашего шаблона. Предлагаем вашему внимаю несколько бесплатных CSS сеточных систем и генераторов.

* tiny fluid grid
* Variable Grid System
* Fluid Grids Calculator — ресурс исчез
* Fluid Grid от Bootstrap

Большинство CSS сеточных платформ предоставляются с расширенными свойствами, и многие из них были протестированы во всех современных браузерах. Цель данного руководства заключается в том, чтобы вы полностью поняли, что такое гибкие сетки. Итак, вам следовало бы сгенерировать гибкую сетку, которая позволит вам изучить основы гибких сеток.


Мы воспользуемся Variable Grid System для генерации гибких сеток по собственным требованиям. Откройте эту ссылку, и введите туда значения переменных. Мы использовали следующие значения.

— Ширина колонки – 60
— Число колонок – 12
— Ширина канавок – 20

* Демо

Затем скачайте гибкую версию CSS-файла. Теперь откройте его в вашем любимом текстовом редакторе или осуществите поиск Grid >> 12 Columns. Нижеприведенный код отображает контент раздела Grid >> 12 Columns.

.container_12 .grid_1 {
width:6.333%;
}

.container_12 .grid_2 {
width:14.667%;
}

.container_12 .grid_3 {
width:23.0%;
}

.container_12 .grid_4 {
width:31.333%;
}

.container_12 .grid_5 {
width:39.667%;
}

.container_12 .grid_6 {
width:48.0%;
}

.container_12 .grid_7 {
width:56.333%;
}

.container_12 .grid_8 {
width:64.667%;
}

.container_12 .grid_9 {
width:73.0%;
}

.container_12 .grid_10 {
width:81.333%;
}

.container_12 .grid_11 {
width:89.667%;
}

.container_12 .grid_12 {
width:98.0%;
}

Как видно, container_12 – это основной контейнер. Каждый ваш элемент в дизайне должен быть внутри контейнера с классом container_12. Затем ширина в процентном соотношении задается классам .grid_1 , .grid_2 … .grid_n. Гибкие сетки создаются при помощи колонок, которые расцениваются как гибкие колонки. Когда размер экрана изменяется, ширина этих колонок также пропорционально изменяется в соответствии с родительским контейнером.

В нашей сетке есть 12 гибких колонок. Итак, давайте взглянем на то, как колонки расположены в нашем шаблоне.

Код для верхнего раздела приведен ниже. Вы можете проверить скачанные файлы, если вам нужно больше информации.

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
<title>Fluid Grid with Fluid Columns</title>
<link type="text/css" rel="stylesheet" href="style.css" />
</head>
<body>
<div id="single-columns" class="container_12">
<div class="grid_1"><span>1</span></div>
<div class="grid_1"><span>1</span></div>
<div class=.
gt;1</span></div>
<div class="grid_1"><span>1</span></div>
<div class="grid_1"><span>1</span></div>
<div class="grid_1"><span>1</span></div>
</div>

<div id="double-columns" class="container_12">
<div class="grid_2"><span>2</span></div>
<div class="grid_2"><span>2</span></div>
<div class="grid_2"><span>2</span></div>
<div class="grid_2"><span>2</span></div>
<div class="grid_2"><span>2</span></div>
<div class="grid_2"><span>2</span></div>

</div>
</body>
</html>

Каждый набор компонентов содержится внутри элемента с классом container_12. Внутри контейнера мы можем использовать класс grid_n для создания гибких колонок с указанной шириной. Используя grid_1 мы можем задать 1/12 от исходной ширины сетки, а grid_2 даст нам 2/12 от исходной ширины.


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

Вложенные гибкие колонки

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

* Демо

Шаблон, представленный выше, содержит 2 ряда. Первый ряд разделен на 2 раздела, состоящих из 6 колонок, и каждый раздел будет снова разделен на 4 раздела из 3 колонок.

Подобно этому, вторая строка будет разделена на 3 раздела из 4 колонок, и каждый раздел снова будет разделен на 3 отдела из 4 колонок. Таким образом мы создаем вложенные колонки в сетках. Давайте посмотрим, как разработать код для вышеприведенного шаблона.

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
<title>Nested Fluid Columns</title>.
;</div>
<div class="grid_3"><span>3</span></div>
</div>
</div>
<div class="grid_6">
<div class="container_12">
<div class="grid_3"><span>3</span></div>
<div class="grid_3"><span>3</span></div>
<div class="grid_3"><span>3</span></div>
<div class="grid_3"><span>3</span></div>
</div>
</div>
</div>

<div class="container_12">
<div class="grid_4">
<div class="container_12">
<div class="grid_4"><span>4</span></div>
<div class="grid_4"><span>4</span></div>
<div class="grid_4"><span>4</span></div>
</div>
</.
lt;span>4</span></div>
<div class="grid_4"><span>4</span></div>
<div class="grid_4"><span>4</span></div>
</div>
</div>
</div>
</body>
</html>

Сначала мы создаем основные контейнеры, как мы делали это в предыдущем разделе. Внутри колонки нам нужно создать еще один контейнер с классом container_12 для вложенных колонок. Теперь нам нужно еще 12 колонок внутри 6 основных колонок. Затем 12 под-колонок можно разделить так, как потребуется. Теперь вы должны понимать, как создавать гибкие сетки и как работать с вложенными колонками. Давайте перейдем к дальнейшему изучению гибких сеток.

Дизайн поверх гибких сеток

Многие дизайнеры, которые только начинают, думают, что применение адаптивной CSS-платформы сделает их дизайн адаптивным. К сожалению, адаптивный дизайн – это не так просто. Гибкие сетки адаптируются к изменениям в размере окна браузера или устройства. Пока вы тщательно не продумаете дизайн, у пользователей будут проблемы при просмотре вашего контента на меньших по размеру устройствах, если вы будете использовать гибкие сетки.

Посмотрите на изображение, приведенное ниже.

Так шаблон на гибкой сетке, о чем говорилось в предыдущих частях руководства, будет отображаться на маленьких экранах. Здесь у нас просто сеточные колонки без нужных данных. Даже в этом случае номер 1 не отображается так, как нужно. Когда дело дойдет до реального контента, у нас получится сплошное месиво. В данном сценарии нам нужно выставить ширину колонок для того, чтобы предоставить лучший опыт взаимодействия с пользователями.

Вы можете использовать CSS media queries для настройки ширины колонок для разных экранов. В вышеприведенном сценарии вы можете удвоить ширину колонки и оставить 6 колонок вместо 12, чтобы пользователям было легче читать контент. Так что постарайтесь не зависеть всецело от гибкой сетки в адаптивном дизайне.

Тестирование гибких сеток

Теперь, когда мы рассказали вам об основах гибких сеток, мы можем перейти к разработке простого демо с jQuery для того, чтобы протестировать нашу гибкую сетку на разных размерах экрана. Сначала нам нужно создать шаблон страницы и навигацию, как показано ниже.

* Демо

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
<title>Fluid Grid Tester</title>
<script type="text/javascript" src="jquery.min.js" ></script>
</head>
<body>
<div id="device_navigation">
<div id='device_panel'>
<a href="javascript:void(0);" onclick="changeGrid('desktop');">Desktop</a>
<a href="javascript:void(0);" onclick="changeGrid('tab_lan');">Tablet Landscape</a>
<a href="javascript:void(0);" onclick="changeGrid('tab_pot');">Tablet Portrait</a>
<a href="javascript:void(0);" onclick="changeGrid('mob_lan');">Mobile Landscape</a>
<a href="javascript:void(0);" onclick="changeGrid('mob_pot');">Mobile Portrait</a>
</div>
<div style="clear:both"></div>
</div>
<div class='main_wrapper'>
<iframe class="wrapper" src="media_query.html"></iframe>
</div>
</body>
</html>

Наша тестовая страница будет иметь базовый HTML-шаблон с jQuery. Элемент с id device_panel будет содержать навигацию для стандартных устройств вроде настольных ПК, мобильных и планшетов. Как только по ссылке будет произведен клик, запустится функция changeGrid, с типом устройства в качестве параметра.

В нижнем разделе у нас будет iframe, который будет использоваться для загрузки нашей гибкой сетки. Гибкая сетка будет содержаться в файле media_query.html. Теперь давайте взглянем на функцию changeGrid.

function changeGrid(device){
if(device == "desktop"){
$(".wrapper").css("width","960px");
}
if(device == "tab_lan"){
$(".wrapper").css("width","768px");
}
if(device == "tab_pot"){
$(".wrapper").css("width","600px");
}
if(device == "mob_lan"){
$(".wrapper").css("width","480px");
}
if(device == "mob_pot"){
$(".wrapper").css("width","320px");
}
}

Как только функция будет запущена, она проверит устройство при помощи введенного параметра. Затем она изменит ширину .wrapper (IFRAME) на стандартную ширину устройства. Далее у нас будет возможность увидеть работу гибких сеток на маленьких экранах.

Гибкая сетка, использованная внутри файла media_query.html, будет похожа на примеры, которые мы обсуждали ранее. Вы можете использовать файлы из демо для оформления кодов. У вас должно получиться нечто похожее на то, что на изображении.

* Скачать

Подытожим

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

Источник: www.coolwebmasters.com

Проблема

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

Проблема очень похожа в обоих случаях, так что выберем любое свойство из двух, например, text-align: center. А так же воспользуемся маркированным списком.

<ul>  	<li>Пункт 1</li>  	<li>Пункт 2</li>  	<li>Пункт 3</li>  	<li>Пункт 4</li>  	<li>Пункт 5</li>  	<li>Пункт 6</li>  	<li>Пункт 7</li>  	<li>Пункт 8</li>  </ul>  
ul {  	font: 14px Verdana, Geneva, sans-serif;  	text-align: center;  }    	ul li {  		display : inline-block;  		width : 80px;  		height: 80px;  		margin-bottom: 10px;  		background: #E76D13;  		vertical-align: top;  		text-align: center;  		line-height: normal;    		/* эмуляция inline-block для IE6-7*/  		//display : inline;  		//zoom : 1;  	}  

Ничего необычного в коде нет. Обычный список, всё те же старые добрые элементы строчно-блочного (display : inline-block) уровня. Самое пожалуй интересное, что стоит выделить, это text-align: center, благодаря которому и происходит наше горизонтальное выравнивание.
Пока пункты занимают единственную строку, всё выглядит так.

Резиновая сетка

Но, как только на поле появляется последняя строка, кол-во блоков в которой меньше, чем в предыдущих строках, то получается следующее.

Резиновая сетка

Вроде бы тоже неплохо, всё происходит так, как и должно происходить. Последняя строка так же, как и предыдущие — выравнивается по середине. Но, именно это выравнивание и создаёт нам проблему. Блоки находятся по середине, создавая по бокам много ненужного и пустого пространства. Если бы, например, в последней строке остался всего один блок, то этого бы пространства стало ещё больше, а сам блок болтался бы в середине, как изгой на пустыре.

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

Резиновая сетка

Как видно из рисунка, два элемента в последней строке прижались к левому краю, не смотря на то, что строка по ширине явно больше, чем общая ширина её блоков. Это видно по правому, свободному пространству, которое составляет две трети наших элементов. Именно такое поведение блоков нам и нужно получить в итоге. Т.е. по сути сделать так, чтобы выравнивание элементов было красивым, строящимся ровно по сетке (даже по резиновой), не взирая на своё количество и лишнее пустое пространство в последней строке. Говоря другими словами, нам нужно каким либо образом повлиять на поведение последней строки, заставив её подчиняться нашим правилам.

Как это работает?

Перед тем, как перейти непосредственно к решению задачи, давайте для начала разберём алготитм работы таких свойств, как text-align: center и justify. Это поможет нам лучше понять, что происходит в нашей сетке, её поведение, и то, как выполняется работа этих свойств в последней строке.

text-align: center

Начнём пожалуй с text-align: center. В нем можно выделить три основных этапа.

Первый этап
В начале берётся строка. Высчитывается общая ширина слов или неразрывных блоков (inline-block, img, и т.д) в строке. Причём если между этими блоками есть фактические пробелы или же отступы, которые сделаны с помощью таких средств, как word-spacing и прочих, то эти расстояния так же добавляются к общей сумме ширины блоков.

Второй этап
На этом этапе всё ещё проще. Вычисляется оставшееся ширина строки, т.е. всё свободное пространство, которое не вошло в сумму общей ширины слов с их межсловным расстоянием.

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

Резиновая сетка

Перед нами рисунок, на котором изображён контейнер, с двумя строками, ширина которых составляет 500px.
Так же мы можем видеть, что сумма всех блоков в первой строке с их интервалами равна 370px. Значит на третьем этапе наш алгоритм вычел из первого второе (500-370), что дало результат 130. Далее, как я уже говорил, поделил эту сумму ровно на два раза (130/2) и отодвинул самый первый блок вправо, на полученный результат (65px). Таким образом наши блоки оказались точно по середине, с отступы по бокам стали абсолютно одинаковыми. Если бы в первой строке не хватило места, то самый крайний справа блок перешёл бы на второю строку и алгоритм снова включился бы в дело.

Тоже самое касается и второй строки. В ней алгоритм работает точно так же, мало того, можно увидеть, что боковые отступы в ней составляют дробное число (132.5px), так как text-align: center делит общую ширину блоков с их интервалами ровно на 2, как я и говорил.

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

text-align: justify

Механизм text-align: justify, я уже описывал в одной из своих статей. Повторяться не имеет смысла, поэтому я вам, настоятельно рекомендую пройти по ссылке и внимательно перечитать там всё, что касается алгоритма и этапов работы text-align: justify.
Единственное, что я хочу упомянуть здесь, это то, что…

Последняя же строка не попадает в поле зрения justify, так как он работает только для целиком заполненных строк, а в последней строке пробелы всегда остаются своего обычного размера.

Да, именно так. text-align: justify в отличии от text-align: center вообще отказывается работать с последней строкой, и поэтому выравнивания по ширине в ней не происходит.
Так что это тоже входит в наши обязанности, а именно заставить неработающий алгоритм действовать, и в завершающей строчке.

Решение

Сразу забегу вперёд и скажу, что решение для обоих случаев абсолютно идентично, поэтому нет смысла разбирать каждое из них в отдельности. Так что давайте поразмыслим, что у нас есть на данный момент.
Значит, по сути, у нас есть два свойства text-align: justify и center, каждый из которых выравнивает строки по собственному алгоритму. А так же мы уже понимаем, что text-align: center работает с последней строкой, а вот text-align: justify — нет. Но зато мы точно знаем, что если строка, за которой идёт следующая (допустим последняя) будет полностью заполнена, то эти свойства будут выравнивать нашу сетку по нашим правилам. И даже при резиновой ширине контейнера такие заполненные строки будут вести себя так, как нам хотелось бы.

Какой же вывод можно из этого сделать? И как можно связать эти вещи с последней строкой, в которой может быть всего один блок? Ответ прост. Нам нужно придумать, как можно заполнить последнюю строку так, чтобы, оставшееся от общей ширины блоков пространство, было чем-то заполнено, и мало того, чтобы это "чем-то" могло переходить на следующую строку, для того, чтобы наши свойства работали безукоризненно.

Итак, для заполнения последней строки, мы будем использовать псевдоэлемент, сгенерированный при помощи :after. Это хороший вариант, так как он поможет решить нам нашу задачу и избавит от лишнего мусора в разметке. По умолчанию псевдоэлементы генерируют строчный блок, а значит именно то, что нам и нужно. Так как inline-block будет представлять из себя одну большую, неразрывную букву и не сможет разбиться на несколько "кирпичей", что не приведёт ни к чему путному. Ну, а block сразу же займёт отдельную строку, и так же, как и inline-block — не принесёт результатов. При этих значениях наша ситуация будет выглядеть примерно так.

ul:after {  	content: 'display: block, мало контента';  	display: block;  	background: #E76D13;  }  

Резиновая сетка

Как видно, из скриншота, вспомогательный блок сразу же занял новую строку, оставив прежнюю (последнюю по факту) подчиняться правилам алгоритма. Каких-то положительных результатов такими средствами добиться невозможно, как бы вы не пытались, так что отбрасываем эти вещи и переходим к настоящему решению…

Из всего вышесказанного можно понять одно, что в нашей ситуации нам может помочь элемент, именно строчного (inline) уровня, т.е. обычный display : inline + строка текста, с пробелами между слов.

ul:after {  	content: 'Обычный строковый элемент, обычный строковый элемент, обычный строковый элемент';  	background: #E76D13;  }  

Резиновая сетка

Да, очень похоже. Из скриншота ясно, строчный блок, мало того, что смог повлиять на последнюю строку, так ещё и перенёсся на следующую не полностью, оставив на предыдущей строчке неразрывное слово. По этому слову видно, что по своей ширине оно немного не дотягивает до ширины блоков (100px), а если бы дотягивало, то, возможно, у нас и вышло бы что-то путное.

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

ul {  	font: 14px Verdana, Geneva, sans-serif;  	text-align: center;  	margin: 0px 0 10px;  }  	ul:after {  		content: ' i i i i i i i i ';  		word-spacing: 97px;  		padding-left: 97px;  		/* visibility: hidden; Скрыл это свойство, ради демонстрации процесса*/  	}  		ul li {    			display : inline-block;  			width : 100px;  			height: 100px;  			margin: 0px 0 20px;  			background: #E76D13;  			vertical-align: top;  			text-align: center;    			/* эмуляция inline-block для IE6-7*/  			//display : inline;  			//zoom : 1;  		}  

Резиновая сетка

Здорово! Наша сетка выровнена так, как нам надо. Сразу же скажу, что такое выравнивание получается при любой ширине экрана, что не может не радовать. А теперь сама суть.

Значит у нас есть строка "i i i i i i i i"  , состоящая из букв и пробелов, но это не простые буковки и пробелы, как может показаться на первый взгляд. Во-первых сама буква i выбрана не случайно. Дело в том, что буква i сама по себе узкая, за счёт чего ей легко управлять и подгонять нужную ширину. Во-вторых сами пробелы состоят не только из символа пробела, но и из word-spacing, т.е. его значение плюсуется к пробелу, что в сумме даёт нужную нам ширину. Да, и конечно же, нужно учитывать, что связка "пробел + word-spacing" работает только тогда, когда в конце неё идёт другой символ, отличный от пробельного. Так как пробелы имеют свойство "схлопывания", то буквы i, идущие после word-spacing не дают им этого сделать.

Так что, по сути, мы имеем неразрывные псевдоблоки, в виде "буквы + padding-left" вначале псевдоэлемента, а далее в виде связки "пробел + word-spacing + буква", и так до конца строки. Ну, а на следующей строчке всё повторяется заново, только первый псевдоблок состоит теперь из одной буквы. Но эта строка нас уже не волнует, нас интересуют только те "добавочные блоки", которые дополняют последнюю строку с нормальными блоками в сетке.
Кстати, букв должно хватить, чтобы гарантировано заполнить последнюю строку до конца в худшем случае. Т.е. их число должно быть равно максимальному кол-ву блоков в строке.
Да, и, конечно же, с text-align: justify этот метод работает точно так же.

Но это были плюсы, а как же минусы? Минусы у этого варианта таковы:
Во-первых, в нестабильной работе в Opera, блоки в которой, временами имеют нечёткое выравнивание по сетке. Причём это касается только последней и предпоследней строк. Не понятно, из-за чего это происходит, к сожалению мне так и не удалось это выяснить. Возможно проблема кроется в том, что крайняя буква прилипает к блоку, не чувствуя между ними пробела. В любом случае, очень надеюсь на то, что в комментах кто нибудь сможет дать пояснение этой загвоздки. Но, в целом, это не выглядит безобразно, т.е. работает, но просто немного нестабильно.

Во-вторых, из-за создания дополнительных элементов снизу образовывается неприятный отступ, который происходит за счёт его размера шрифта и межстрочного интервала. Лекарство в виде обнуления шрифта + межстрочного интервала у родителя и восстановлением их в нормальное состояние у потомков — не приносит результата, так как нужная нам строка в псевдоэлементе становится невидимая, и наша сетка перестаёт её чувствовать и поддаваться дрессировке.
Но есть всё же "почти" выход из ситуации, это нижний отрицательный margin, который может подтянуть часть своего "хвоста", позволяя следующим за ним элементам налезать на него. Подробнее об этом можно почитать тут. Я сказал "почти", потому что этот способ выручает отчасти, я бы сказал, на половину, может чуть больше. Так как в момент создания, уже двух-строчного хвоста, из букв, подтянуть обе строки, уже не представляется возможности.

Во-третьих, чтобы заставить этот метод работать в IE6-7, нам потребуется заменить наш псевдоэлемент дополнительным блоком-помощником, который будет вставлен в конце списка. Плюс к этому придётся воспользоваться такими средствами, как text-justify, text-align-last (их поведение я уже описывал в этой статье), восстановлением свойства zoom в начальное состояние, у дополнительного блока и прочими "радостями", благодаря которым, в этих браузерах наш способ будет работать так же. В конце статьи я обязательно приведу разные варианты этой задачи, чтобы вы могли выбрать нужный.

Резюме

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

Да, и конечно же, хочется выразить огромную благодарность Илье Стрельцыну (@SelenIT2) за его идеи и невероятную помощь в материалах. Без него бы этой статьи не было.

Все решения воедино

Обновление от 30.03.2017: Современное решение этой задачи на Grid Layout (без хаков и лишнего кода)

Источник: css-live.ru

Обратили внимание, что в этом случае гораздо легче делать расчеты? Всё верно: это треть ширины сетки в каждой контрольной точке.

.grid-item {
width: 33.3333%;
padding-right: 10px;
padding-left: 10px;
float: left;
}

Вот CodePen, что бы вы могли поиграть:

Прежде чем мы двинемся дальше, я хочу вас предостеречь, если вы используете разделенный padding. Если вы взглянете на разметку в CodePen, то увидите, что я добавил дополнительный <div> внутри .grid-item. Этот дополнительный <div> важен, если компонент содержит фон или рамки.

Всё потому, что фон отображается в границах padding. Надеюсь, эта картинка поможет вам разобраться, показав связь между background и другими свойствами.

Фон отображается на padding.

Что бы использовал я?

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

В то время, я любил простоту настроек отступов с одной стороны колонки. Это было проще потому, что я не так хорош в математике. От дополнительных рассчётовотступы / 2 я быстро вырубался.

Я рад, что я пошёл этим путем. Хоть CSS и выглядит более сложным, чем для разделенных отступов, я был вынужден изучить селектор nth-child. Я также понял важность написания CSS сначала для мобильных. Насколько я могу судить, это до сих пор является главным препятствием и для молодых, и для опытных разработчиков.

Так или иначе, если вы попросите меня выбрать сейчас, я выберу разделенные отступы вместо односторонних, потому что CSS для них более простой. Также, я рекомендую использовать margin вместо padding, потому что разметка получается чище. Но padding легче рассчитать, поэтому я продолжу статью с ним.

Шаг 6: создание отладочной сетки

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

На сегодня, мне известен лишь кривой способ создания отладочной сетки. Нужно создать HTML-разметку и добавить к ней немного CSS. Вот так примерно выглядит HTML:

<div class="fixed-gutter-grid">
<div class="column"></div>
<div class="column"></div>
<div class="column"></div>
<div class="column"></div>
<div class="column"></div>
<div class="column"></div>
<div class="column"></div>
<div class="column"></div>
<div class="column"></div>
<div class="column"></div>
<div class="column"></div>
<div class="column"></div>
</div>

CSS для отладочной сетки выглядит следующим образом. Я использую разделенные внешние отступы для упрощения разметки отладочной сетки:

.column {
width: calc((100% - 20px * 12) / 12);
height: 80px;
margin-right: 10px;
margin-left: 10px;
background: rgba(0, 0, 255, 0.25);
float: left;
}

Ремарка: Сьюзан Мириам и Собрал Робсон работают над фоновым SVG изображением отладочной сетки для Susy v3. Это очень захватывающе, так как вы можете использовать простую функцию для создания вашей отладочной сетки!

Шаг 7: внесите изменения в раскладку

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

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

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

Разметка для раскладки этой гостевой статьи может быть такой:

div class="l-guest-article">
<div class="l-guest">
<!-- Профиль гостя -->
</div>
<div class="l-main">
<!-- Главная статья -->
</div>
<div class="l-sidebar">
<!-- Боковые виджеты -->
</div>
</div>

Итак, сейчас у нас есть 12 колонок. Ширина одной колонки 8,333% (100 / 12).

Ширина .l-guest равна двум колонкам. Поэтому вам нужно умножить 8,333% на два. Достаточно просто. Проделайте тоже самое для остальных элементов.

Здесь я предлагаю использовать препроцессор типа Sass, который позволит вам рассчитывать ширину колонок легче, используя функцию percentage, вместо расчетов вручную:

.l-guest-article {
@include clearfix;
.l-guest {
// Хм, читается лучше, чем 16.666% 🙂
width: percentage(2/12);
padding-left: 10px;
padding-right: 10px;
float: left;
}
 .l-main {
width: percentage(7/12);
padding-right: 10px;
padding-left: 10px;
float: left;
}
 .l-sidebar {
width: percentage(3/12);
padding-right: 10px;
padding-left: 10px;
float: left;
}
}

Должно быть вы заметили, что сейчас часть кода повторяется. Мы можем это исправить, вынеся общие части кода в отдельный селектор .grid-item.

.grid-item {
padding-left: 10px;
padding-right: 10px;
float: left;
}
.l-guest-article {
.l-guest {
width: percentage(2/12);
}
.l-main {
width: percentage(7/12);
}
.l-sidebar {
width: percentage(3/12);
}
}

Ну вот, теперь гораздо лучше 🙂

Шаг 8: создание вариаций раскладки

Последний шаг — сделать вашу раскладку адаптивной. Давайте предположим, что раскладка нашей гостевой статьи ведет себя следующим образом:

Разметка нашей гостевой статьи не должна меняться. То, что у нас есть — это самая доступная раскладка из возможных. Так что, изменения должны быть полностью в CSS.

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

Вот код:

.l-guest-article {
.l-guest {
/* Здесь пусто */
}
.l-main {
margin-top: 20px;
}
.l-sidebar {
margin-top: 20px;
}
}

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

Далее двигаемся к планшетной раскладке.

Давайте предположим, что для этой раскладки мы установим контрольную точку в 700 px.l-guest должен занимать 4 из 12 колонок, а .l-main и .l-sidebar по 8 колонок каждый.

Здесь нам надо удалить свойство margin-top у .l-main, потому что он должен быть на одной линии с .l-guest.

Также, если мы установим .l-sidebar ширину 8 колонок, он автоматически перейдет во второй ряд — в первом ряду не хватит места. Поскольку он находится во втором ряду, нам тоже нужно добавить внешний отступ слева у .l-sidebar, чтобы протолкнуть его на позицию. В качестве альтернативы, мы можем сделать его обтекаемым справа — я так и сделаю, это не требует лишних расчётов.

И поскольку мы сделали наши грид-элементы обтекаемыми, грид-контейнер должен включать клиар-фикс, чтобы очистить обтекание у дочерних элементов:

.l-guest-article {
@include clearfix;
.l-guest {
@media (min-width: 700px) {
width: percentage(4/12);
float: left;
}
}
.l-main {
margin-top: 20px;
@media (min-width: 700px) {
width: percentage(8/12);
margin-top: 0;
float: left;
}
}
.l-sidebar {
margin-top: 20px;
@media (min-width: 700px) {
width: percentage(8/12);
float: right;
}
}
}

Наконец, давайте перейдем к десктопной раскладке.

Допустим, для этой раскладки мы установим контрольную точку в 1200 px.l-guest будет занимать 2 из 12 колонок,.l-main — 7 из 12 и .l-sidebar — 3 из 12.

Для этого мы создаем новое медиавыражение в рамках каждого элемента сетки и изменяем ширину по необходимости. Обратите внимание, что мы также должны удалить верхний отступ у .l-sidebar

.l-guest-article {
@include clearfix;
.l-guest {
@media (min-width: 700px) {
width: percentage(4/12);
float: left;
}
 @media (min-width: 1200px) {
width: percentage(2/12);
}
}
.l-main {
margin-top: 20px;
@media (min-width: 700px) {
width: percentage(8/12);
margin-top: 0;
float: left;
}
@media (min-width: 1200px) {
width: percentage(7/12);
}
}
.l-sidebar {
margin-top: 20px;
@media (min-width: 700px) {
width: percentage(8/12);
float: right;
}
@media (min-width: 1200px) {
width: percentage(3/12);
margin-top: 0;
}
}
}

Вот CodePen с финальной раскладкой, которую мы создали:

О, кстати, вы можете добиться таких же результатов со Susy. Только не забудьте выставить gutter-position в inside-static.

Подводя итог

Ого. Длинная получилась статья. Я думал, трижды помру, пока писал её. Спасибо, что дочитали до конца. Надеюсь, вы не померли трижды, пока читали! 😛

Как вы могли заметить, в этой статье шаги для создания адаптивной сетки относительно простые. Большинство путается на шагах 5 (определение положения отступов) и 8 (адаптация раскладки).

5-й шаг прост, когда вы учитываете все возможные способы, и мы разобрали их вместе. 8-й шаг проходится легче, если у вас достаточно опыта в написании CSS сначала для мобильных.

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

До скорого!

Источник: medium.com


Categories: Сеть

Добавить комментарий

Ваш e-mail не будет опубликован. Обязательные поля помечены *

Этот сайт использует Akismet для борьбы со спамом. Узнайте как обрабатываются ваши данные комментариев.