How to meet the common requirement of changing the number of columns on a grid based on the device in Semantic UI
<ui grid>
<div class="ui eight columns for computer">
<div class="ui four columns for mobile"> <!-- just imaginating -->
Related
I am trying to make something like this in React. I have a dynamic array of locations and want to make it responsive. If the number of locations can't fit in one row then display show more with the number of remaining locations. If I change browser width it should display a responsive array.
<section class="thumbnails">
<span>Home</span>
<span>Blog</span>
<span>News</span>
<span>Portfolio</span>
<span>Team</span>
<span>Mission</span>
<span>Location</span>
<span>Forum</span>
<div class="thumbnails__count">
<p class="thumbnails__count-text">
+<span class="thumbnails__count-value"></span> more items
</p>
</div>
</section>
Thank you
I'm new in Angular and Bootsrap 4, and I'm having trouble setting up the layout for a dashboard I'm currently working on. I have a series of cards that need to be arranged in a particular way, as follows:
I have a row, in which I have put a col-12 div, and inside I have placed all the cards (1,2 and 3 are static content, the others are loaded with a ngFor, from a list that comes from the database).
The problem with this is that since card 1's has double height relative to all the others, cols for 2 and 3 are the same height as the col for card one. The result is as follows:
Is there a way to fix this using my approach, say, having the extra empty space in the colums for the cards 2 and 3 taken away, and place the other cards in there? Or should I use a completely different approach?
edit: Here's the code I've used.
<div class="col-lg-12">
<div class="row">
<div class="double-card-col">
<app-tool-card-double-1></app-tool-card-double-1>
</div>
<div class="cards">
<tool-card-2></tool-card-2>
<tool-card-3></tool-card-3>
</div>
<ng-container *ngFor="let tool of tools; trackBy: trackBy">
<tool-card></tool-card>
</ng-container>
</div>
I tried to put a "#columnCount: 24;" in src/site/globals/site.variables and execute "gulp build" but it turns out there is nothing changed.
Another doubt is even if this works, can I use something like "twenty wide column" for my page elements?
Directly from the Semantic UI website :
All grid systems use an arbitrary column count. Semantic's default theme assumes 16 columns. This number can be adjusted in your project by adjust the #columnCount value in site.variables.
The #columnCount variable can only go up to 16.
Since Semantic-UI was built with a 16 column default, all the other related variables and calculations are based off that. In order to go higher than 16 columns you'll have to find the appropriate places and add the necessary variables, calculations, and classes in order to make it work.
However, there are a couple of easier ways that I think you could accomplish what you're looking for.
First, rather than adding in more columns, you might be able to accomplish what you're looking for by changing the margins and paddings of the appropriate elements or possibly by using the "relaxed" or "very relaxed" classes.
But if you absolutely need that many columns, then try using nested grids.
Something like this perhaps:
<div class="ui two column grid">
<div class="column">
<div class="ui ten column grid">
</div>
</div>
<div class="column">
<div class="ui ten column grid">
</div>
</div>
</div>
I've got a form tool with two lists and a set of tools between them that is laid out in three columns on larger screens like so...
<div class="row">
<div class="col-md-5">
AVAILABLE LIST (1)
</div>
<div class="col-md-2">
MOVEMENT BUTTONS (2)
</div>
<div class="col-md-5">
SELECTED LIST (3)
</div>
</div>
... as you can see, for the xs and sm viewports, the layout should switch to a full width stacked list. What I would like to do is to swap the positions of the MOVEMENT BUTTONS and SELECTED LIST columns on those smaller view ports so that the tools are the last row (1-2-3 => 1-3-2).
The problem I'm having is that when I add classes like col-xs-pull-* col-sm-pull-* to the SELECTED LIST, and col-xs-push-* col-sm-push-* to the MOVEMENT BUTTONS columns, the buttons column dissapears and the selected list is out of alignment. I've tried corresponding col-*-push/pull values of 1 (because anything should swap them when they're full width, shouldn't they?) and 12 (just in case), both have the same unintended result.
How can I apply push/pull modifier classes to the two columns in question to achieve reordered stacking on xs and sm viewports?
One important thing to realize about Twitter Bootstrap is that they take a mobile-first design mindset. This means that classes that apply to extra-small screens will apply all the way up to large screens unless you overload them.
This is also true for the push and pull classes. So what you need to do is layout the buttons the way you intend for them to be in a small screen and then push/pull them in larger screens to where you want them.
In other words, put the buttons in your HTML where you want them in small screens and use the push/pull medium classes to move them in larger screens.
Edit
I've created a Bootply demonstrating the concept of pushing and pulling. See if that makes sense.
The gist of it is this:
<div class="col-md-5">
AVAILABLE LIST (1)
</div>
<div class="col-md-5 col-md-push-2">
SELECTED LIST (3)
</div>
<div class="col-md-2 col-md-pull-5">
MOVEMENT BUTTONS (2)
</div>
A push class moves an element to the right a number of columns and the pull class moves an element to the left a number of columns. For example, if you want to switch two elements, the first of size 3 and the second of size 6, you will need to push the first 6 columns and pull the second 3 columns, effectively switching their positions.
The new Bootstrap three documentation explains the grid behaviour as "Horizontal at all times" for extra small devices. What does this mean? Surely on a small device all columns would be stacked vertically upon one another? What's failing me here is my (lack of) understanding of what a grid is.
I'm coming from a non-designers perspective, and trying to iterate over a number of products into a responsive grid. The number of columns within each row will change dependant on whether an odd or even number of products is being displayed. <-- Bootstrap, and alike seems simple with static content over dynamic pages. For example, must we insert empty <div class="col-xs*"></div> to make it up to 12?
What "Horizontal at all times" means is that there is no breakpoint at which col-xs-* will change from being floated to stacked. For example:
<div class="col-xs-6"></div>
<div class="col-xs-6"></div>
In this example, there will always be two columns of equal size, whether you are on a phone, tablet, or desktop. For contrast:
<div class="col-sm-6"></div>
<div class="col-sm-6"></div>
In this example, the columns will be stacked until the viewport of the device is >=768, at which point it will switch to two columns of equal size.
The question you might be asking yourself is "Why all of these variations?" Well, what these options give us is the ability to customize the layout on various devices without having to get our hands dirty in CSS. For example, if I wanted two equal columns on a phone, but a 75/25 split on tablets and up, I would do the following:
<div class="col-xs-6 col-sm-8"></div>
<div class="col-xs-6 col-sm-4"></div>
If you wanted stacked on phones, equal on tablet, and 75/25 on desktop, then do this:
<div class="col-sm-6 col-md-8"></div>
<div class="col-sm-6 col-md-4"></div>
Because you are not explicitly specifying a grid for the phone, it is going to revert to stacked.
To get a solid feel, throw some simple grids together, and then start resizing your browser. You should be able to see how it changes much more easily than in the docs themselves.
EDIT
Thought of one other example that might be of interest: two equal columns at both phone and tablet, then 75/25 and desktop. The code:
<div class="col-xs-6 col-md-8"></div>
<div class="col-xs-6 col-md-4"></div>
This is actually a great illustration of "Horizontal at all times." Because we are not specifying a col-sm, col-xs continues to be enforced until we hit the desktop breakpoint, which is set at >=992.