min-width isn't preferred strongly enough when child is a table - css

My previous question got an answer using min-width to set the width of a containing block but allow it to grow when its children are too big.
This worked fine with some kinds of children (simple divs with their own min-width and max-width specified explicitly). Now I'm looking at a more complex variation in which the children are tables. (Legitimate tables with semantically meaningful rows and columns, not page-layout tables.)
There is no manually-specified min-width or max-width on these tables, but tables have an inherent maximum and minimum width, corresponding to the width that the table would have if rendered with no line breaks in any of the cells (maximum) and the width that it would have with line breaks inserted insertion of all possible line breaks (minimum).
In the existing page layout which I'm trying to replace, the outermost container is a table (the bad kind of table) with a single cell in a single row, and a CSS width (not min-width) set to the preferred width. When the children are tables, they try really hard to fit into the container's width. A wide table will be rendered with line breaks to make it fit, and the container will expand only if the child still doesn't fit after all line breaks are inserted.
In other words, the parent's width property is treated as a minimum, but it is also a strongly preferred width, which has a higher priority than the child's preferred (i.e. maximum) width.
By contrast, when the parent is a plain div with display:inline-block and a specified min-width, the parent's min-width is not strongly preferred. The child prefers to be wider, so the parent expands, even if the child is capable of being rendered with a smaller width.
Here's a snippet, much like the one in the previous question, which demonstrates all of this. The goal is to make the second container act like the first one in some way that is more "proper" than using display:table for layout.
(Note: the table widths at the heart of this question are very sensitive to choice of font. I hope the Courier New comes through and everybody sees the same widths in the snippet.)
var containers = document.querySelectorAll(".container");
for(var i = 0; i < containers.length; ++i) {
(function() {
var c = containers[i],
b = c.nextElementSibling;
b.addEventListener("click", function(ev) {
big = c.querySelector(".bigchild");
medium = c.querySelector(".mediumchild");
small = c.querySelector(".smallchild");
if(big.style.display != "block" &&
medium.style.display != "block" &&
small.style.display != "block") {
big.style.display = "block";
} else if(big.style.display == "block") {
big.style.display = "none";
medium.style.display = "block";
} else if(medium.style.display == "block") {
medium.style.display = "none";
small.style.display = "block";
} else {
small.style.display = "none";
}
});
})();
}
body {
background-color: #ccc;
text-align: center;
font-size: 14px;
font-family: "Courier New";
}
table {
border-collapse: collapse;
}
td {
border: 1px solid black;
padding: 5px;
}
.container {
background-color: white;
min-height: 250px;
margin-left: auto;
margin-right: auto;
}
.bigchild, .mediumchild, .smallchild {
display: none;
}
button {
display: block;
margin: 10px auto 20px;
}
#container1 {
display: table;
width: 400px;
}
#container2 {
display: inline-block;
min-width: 400px;
}
<div class="container" id="container1">
<table class="bigchild">
<tr>
<td>Lots of</td>
<td>columns</td>
<td>make this</td>
<td>a very</td>
<td>wide</td>
<td>table</td>
<td>that won't</td>
<td>fit</td>
<td>even with</td>
<td>added</td>
<td>line breaks</td>
</tr>
</table>
<table class="mediumchild">
<tr>
<td>This table</td>
<td>is smaller</td>
<td>and</td>
<td>it fits</td>
<td>but</td>
<td>only with</td>
<td>added</td>
<td>line breaks</td>
</tr>
</table>
<table class="smallchild">
<tr>
<td>very</td>
<td>small</td>
</tr>
</table>
</div>
<button>Next</button>
<div class="container" id="container2">
<table class="bigchild">
<tr>
<td>Lots of</td>
<td>columns</td>
<td>make this</td>
<td>a very</td>
<td>wide</td>
<td>table</td>
<td>that won't</td>
<td>fit</td>
<td>even with</td>
<td>added</td>
<td>line breaks</td>
</tr>
</table>
<table class="mediumchild">
<tr>
<td>This table</td>
<td>is smaller</td>
<td>and</td>
<td>it fits</td>
<td>but</td>
<td>only with</td>
<td>added</td>
<td>line breaks</td>
</tr>
</table>
<table class="smallchild">
<tr>
<td>very</td>
<td>small</td>
</tr>
</table>
</div>
<button>Next</button>

I think .container {min-width: 400px;width: min-content;}, modulo vendor prefixes, is what you want.

Related

Set precedence in text wrapping on different characters in CSS

I'd like to display the path of a file in a column of a table, e.g.
some_random_folder/my_long_filename.txt
such that when I need to wrap it, it will first wrap at slashes, then at underscores, e.g. showing the column width with "|":
|some_random_folder/ |
|my_long_filename.txt |
instead of
|some_random_folder/my_long_ |
|filename.txt |
Of course, if the column is too narrow, it still wraps at underscores:
|some_random_ |
|folder/ |
|my_long_ |
|filename.txt |
This is fine too:
|some_random_ |
|folder/my_long_ |
|filename.txt |
I know that I can add <wbr/> to suggest places to wrap, but that seems to have just one level of priority.
Is that possible with pure CSS? (It's fine if IE/Edge is unsupported.)
This can't be done purely in css, so I would suggest using a javascript function for this.
Here is an example using the special html entity ​ to do a line break that will cut the text if needed. If the line break is not needed it will not create a visible whitespace.
This is just a basic example that adds line break after the first "/"-character, you can extend it with all the other logic you might need adding more line breaks if you want:
var spans = document.getElementsByClassName("cutme");
for (var i = 0; i < spans.length; i++) {
var span = spans[i];
var index = span.innerText.indexOf("/");
var text = span.innerText;
span.innerHTML = text.substring(0, index + 1) + "​" + text.substring(index + 1);
}
table {
width: 200px;
}
td {
border-bottom: solid 2px black;
}
<table>
<tbody>
<tr>
<td class="cutme">
some_random_folder/my_long_filename.txt
</td>
</tr>
<tr>
<td class="cutme">
folder/filename.txt
</td>
</tr>
<tr>
<td class="cutme">
some_random_folder/my_long_filename.txt
</td>
</tr>
</tbody>
</table>
If the length of the "some_random_folder/" part is known, #media all and max-width can be hacked to wrap white-space (added after underscores as <wbr />) below a certain window width. 10em works on my browser in the example below. (It even wraps at character level when the width is under 7em.) I change the colour to show when it starts wrapping.
.wrap { white-space:nowrap; font-family:monospace; }
#media all and (max-width:10em) {
.wrap { white-space:normal; color:blue; }
}
#media all and (max-width:7em) {
.wrap { word-break:break-all; word-wrap:break-word; color:red; }
}
<span class="wrap">some_<wbr />random_<wbr />folder/</span><wbr /><span class="wrap">my_<wbr />long_<wbr />filename.txt</span>

Zebra striping a table with hidden rows [duplicate]

I've got a table
<table id="mytable">
<tr style="display: none;"><td> </td></tr>
<tr><td> </td></tr>
<tr style="display: none;"><td> </td></tr>
<tr><td> </td></tr>
<tr><td> </td></tr>
<tr><td> </td></tr>
</table>
I'm trying to set the table striping to use nth-child selectors but just can't seem to crack it.
table #mytable tr[#display=block]:nth-child(odd) {
background-color: #000;
}
table #mytable tr[#display=block]:nth-child(odd) {
background-color: #FFF;
}
I'm pretty sure I'm close ... can't quite seem to crack it.
anyone pass along a clue?
Here's as close as you're going to get. Note that you can't make the nth-child count only displayed rows; nth-child will take the nth child element no matter what, not the nth child that matches a given selector. If you want some rows to be missing and not affect the zebra-striping, you will have to remove them from the table entirely, either through the DOM or on the server side.
#mytable tr:nth-child(odd) {
background-color: #000;
}
#mytable tr:nth-child(even) {
background-color: #FFF;
}
<table id="mytable">
<tr><td> </td></tr>
<tr><td> </td></tr>
<tr><td> </td></tr>
<tr><td> </td></tr>
<tr><td> </td></tr>
<tr><td> </td></tr>
</table>
Here are the fixes that I made:
table #mytable tr[#display=block]:nth-child(odd) {
background-color: #000;
}
There's no need to specify an ancestor selector for an id based selector; there is only ever one element that will match #table, so you're just adding extra code by adding the table in.
#mytable tr[#display=block]:nth-child(odd) {
background-color: #000;
}
Now, [#display=block] would match elements which had an attribute display set to block, such as <tr display=block>. Display isn't a valid HTML attribute; what you seem to be trying to do is to have the selector match on the style of the element, but you can't do that in CSS, since the browser needs to apply the styles from the CSS before it can figure that out, which it's in the process of doing when it's applying this selector. So, you won't be able to select on whether table rows are displayed. Since nth-child can only take the nth child no matter what, not nth with some attribute, we're going to have to give up on this part of the CSS. There is also nth-of-type, which selects the nth child of the same element type, but that's all you can do.
#mytable tr:nth-child(odd) {
background-color: #000;
}
And there you have it.
If you are using JQuery to change the visibility of rows you can apply the following function to the table to add an .odd class where appropriate. Call it each time the rows visible is different.
function updateStriping(jquerySelector){
$(jquerySelector).each(function(index, row){
$(row).removeClass('odd');
if (index%2==1){ //odd row
$(row).addClass('odd');
}
});
}
And for the css simply do
table#tableid tr.visible.odd{
background-color: #EFF3FE;
}
While you can't Zebra stripe a table with hidden rows using CSS3 you can do it with JavaScript. Here is how:
var table = document.getElementById("mytable");
var k = 0;
for (var j = 0, row; row = table.rows[j]; j++) {
if (!(row.style.display === "none")) {
if (k % 2) {
row.style.backgroundColor = "rgba(242,252,244,0.4)";
} else {
row.style.backgroundColor = "rgba(0,0,0,0.0)";
}
k++;
}
}
For a jquery way, you could use this function which iterates through the rows in your table, checking the visbility of the row and (re)setting a class for visible odd rows.
function updateStriping(jquerySelector) {
var count = 0;
$(jquerySelector).each(function (index, row) {
$(row).removeClass('odd');
if ($(row).is(":visible")) {
if (count % 2 == 1) { //odd row
$(row).addClass('odd');
}
count++;
}
});
}
Use css to set a background for odd rows.
#mytable tr.odd { background: rgba(0,0,0,.1); }
Then you can call this zebra-striper whenever by using:
updateStriping("#mytable tr");
I came up with a sort of solution but it's reliant on the fact that the table can only ever have a maximum number of hidden rows and comes with the downside of requiring 2 additional CSS rules for each possible hidden row. The principle is that, after each hidden row, you switch the background-color of the odd and even rows around.
Here's a quick example with just 3 hidden rows and the necessary CSS for up to 4 of them. You can already see how unwieldy the CSS can become but, still, someone may find some use for it:
table{
background:#fff;
border:1px solid #000;
border-spacing:1px;
width:100%;
}
td{
padding:20px;
}
tr:nth-child(odd)>td{
background:#999;
}
tr:nth-child(even)>td{
background:#000;
}
tr[data-hidden=true]{
display:none;
}
tr[data-hidden=true]~tr:nth-child(odd)>td{
background:#000;
}
tr[data-hidden=true]~tr:nth-child(even)>td{
background:#999;
}
tr[data-hidden=true]~tr[data-hidden=true]~tr:nth-child(odd)>td{
background:#999;
}
tr[data-hidden=true]~tr[data-hidden=true]~tr:nth-child(even)>td{
background:#000;
}
tr[data-hidden=true]~tr[data-hidden=true]~tr[data-hidden=true]~tr:nth-child(odd)>td{
background:#000;
}
tr[data-hidden=true]~tr[data-hidden=true]~tr[data-hidden=true]~tr:nth-child(even)>td{
background:#999;
}
tr[data-hidden=true]~tr[data-hidden=true]~tr[data-hidden=true]~tr[data-hidden=true]~tr:nth-child(odd)>td{
background:#999;
}
tr[data-hidden=true]~tr[data-hidden=true]~tr[data-hidden=true]~tr[data-hidden=true]~tr:nth-child(even)>td{
background:#000;
}
<table>
<tbody>
<tr><td></td><td></td></tr>
<tr><td></td><td></td></tr>
<tr data-hidden="true"><td></td><td></td></tr>
<tr><td></td><td></td></tr>
<tr><td></td><td></td></tr>
<tr><td></td><td></td></tr>
<tr><td></td><td></td></tr>
<tr data-hidden="true"><td></td><td></td></tr>
<tr data-hidden="true"><td></td><td></td></tr>
<tr><td></td><td></td></tr>
<tr><td></td><td></td></tr>
<tr><td></td><td></td></tr>
<tr><td></td><td></td></tr>
<tr><td></td><td></td></tr>
<tr><td></td><td></td></tr>
<tr><td></td><td></td></tr>
</tbody>
</table>
in jquery ..
var odd = true;
$('table tr:visible').each(function() {
$(this).removeClass('odd even').addClass(odd?'odd':'even');
odd=!odd
});
You can easily fake the zebra stripes if you apply a vertically repeating gradient on the parent table, positioned exactly to match the rows' height (the rows would have to be transparent). That way the table won't care if anything's hidden, it will repeat no matter what.
If anyone tries to do something like me, where I have alternating hidden and visible rows, you can do this:
.table-striped tbody tr:nth-child(4n + 1) {
background-color: rgba(0,0,0,.05);
}
This will get every 4th element starting with the 1st one, and allows you to maintain striping with hidden rows between each visible row.
Here is a 2022 version of a javascript version
let cnt = 0;
document.querySelectorAll("#mytable tbody tr").forEach(tr => {
cnt += tr.hidden ? 0 : 1;
tr.classList.toggle("odd",cnt%2===0);
});
.odd { background-color: grey; }
<table id="mytable">
<thead><tr><th>Num</th></tr></thead>
<tbody>
<tr><td>1</td></tr>
<tr><td>2</td></tr>
<tr><td>3</td></tr>
<tr hidden><td></td></tr>
<tr><td>5</td></tr>
<tr><td>6</td></tr>
</tbody>
</table>
I add in css:
tr[style="display: table-row;"]:nth-child(even) {
background-color: #f3f6fa;
}
and on create tr add in tag
style="display: table-row;"
Jquery codes for zebra color in html table
$("#mytabletr:odd").addClass('oddRow');
$("#mytabletr:even").addClass('evenEven');
And CSS you can do
.oddRow{background:#E3E5E6;color:black}
.evenRow{background:#FFFFFF;color:black}

Bootstrap Same Height on Table Alert Divs?

had some trouble researching this, maybe I'm just not thinking clearly. I am using Bootstrap 3 and have a table to pull in data and I am highlighting certain data with their Alert styled divs.
The problem I have is that depending on the data they all have differing heights and I want them to all be the same. I've seen other examples but they weren't utilizing a table structure.
Is there a way to do this or is my only option to ditch the tables and do individual bootstrap columns?
Attached is an example of a table row.
I've updated your fiddle. I'm assuming that you have alerts throughout each of your rows, therefore we're iterating through each <tr> and finding the .alert divs, then determining which alert has the most "height". Then we add this height CSS to every .alert in the row.
The HTML structure has changed, I've added <thead> and <tbody>
<table class="table">
<thead>
<tr>
<th>Address</th>
<th>Super Permits</th>
<th>Active?</th>
</tr>
</thead>
<tbody>
....
....
$('.table').find('tbody tr').each(function (e) {
var heights = $(".alert").map(function ()
{
return $(this).outerHeight();
}).get(),
maxHeight = Math.max.apply(null, heights);
$(this).find('.alert').css('height', maxHeight);
});
Just add custom css for the "alert" class, and it will apply to all alert types, like:
.alert {
height: 90px
}
https://jsfiddle.net/W3AVE/4j72mfeo/
HTML
<table>
<tr class='same-height'>
<td><div><span>text</span></div></td>
<td><div><span>some long text here</span></div></td>
<td><div><span>text medium</span></div></td>
</tr>
</table>
CSS
div {
border: 1px solid black;
}
span {
text-align: center;
display: block;
position: relative;
top: 50%;
transform: translate(0, -50%)
}
JS
(function($){
var $el = $(".same-height"),
h = $el.height();
$el.find("div").each(function()
{
var $self = $(this);
$self.css({"height": h});
});
}(jQuery));

Hide table row when cell is empty

I'm having an issue where I can't seem to find an answer to, but I can't imagine it's not possible.
I have a table with two columns: the left column contains a label, the right side contains a value. However, the value can be empty. The label is fixed text.
What I want is to hide the entire row if the right cell of the row (the value) is empty.
For example:
<table>
<tr>
<td class="label">number of users:</td>
<td class="value">8</td>
</tr>
<tr>
<td class="label">total number of people:</td>
<td class="value"></td>
</tr>
</table>
Since the last row does not contain a value, I want the entire row to be hidden.
I can hide the cell using td:empty, but that's not enough. I tried to work around this by setting the height of the row to 0px and make it expand when the 'value'-cell is shown, but I can't get that to work either since the label cell already expands the row.
Anyone knows how I can tackle this problem using just HTML/CSS?
There's no parent selector in css, so you can't do this with css.
You may use jQuery:
$('td').each(function(){
if($(this).is(:empty)){
$(this).closest('tr').hide();
}
});
Or in shorter form,
$('tr:has("td:empty")').hide();
See the docs: :empty, :has,closest and each
While JavaScript is necessary to solve this problem, jQuery is, by no means, a requirement. Using the DOM, one can achieve this with the following:
function hideParentsOf(cssSelector) {
var elems = document.querySelectorAll(cssSelector);
if (elems.length) {
Array.prototype.forEach.call(elems, function (el) {
el.parentNode.style.display = 'none';
});
}
}
hideParentsOf('td:empty');
function hideParentsOf(cssSelector) {
// cssSelector: String,
// a string representing a CSS selector,
// such as 'td:empty' in this case.
// retrieving a NodeList of elements matching the supplied selector:
var elems = document.querySelectorAll(cssSelector);
// if any elements were found:
if (elems.length) {
// iterating over the array-like NodeList with Array.forEach():
Array.prototype.forEach.call(elems, function(el) {
// el is the current array-element (or NodeList-element in
// this instance).
// here we find the parentNode, and set its 'display' to 'none':
el.parentNode.style.display = 'none';
});
}
}
hideParentsOf('td:empty');
<table>
<tr>
<td class="label">number of users:</td>
<td class="value">8</td>
</tr>
<tr>
<td class="label">total number of people:</td>
<td class="value"></td>
</tr>
</table>
References:
CSS:
:empty pseudo-class.
JavaScript:
Array.prototype.forEach().
document.querySelectorAll().
Function.prototype.call().
Node.parentNode.
HTMLElement.style.
An HTML/CSS solution exists if you don't mind throwing out <table> <tr> and <td>. You can get the same end result with CSS - including still rendering like a table:
CSS:
/* hide if empty */
.hideIfEmpty:empty { display: none; }
/* label style */
.hideIfEmpty::before { font-weight:bold; }
/* labels */
.l_numberofusers::before { content:"Number of users: "; }
.l_numberofpeople::before { content: "Number of people:"; }
.l_numberofdogs::before { content: "Number of dogs:" }
/* table like rows/cells */
.table { display: table; }
.row { display: table-row; }
.cell { display: table-cell; }
HTML
<!-- if the div.hideIfEmpty is empty, it'll be hidden;
labels come from CSS -->
<div class="table">
<div class="row hideIfEmpty l_numberofusers"><span class="cell">8</span></div>
<div class="row hideIfEmpty l_numberofpeople"><span class="cell">12</span></div>
<div class="row hideIfEmpty l_numberofdogs"></div>
</div>
The caveat is that your <div> has to be empty to hide the row, and values in the <div> must have a class .cell applied to them.
Result:
Number of users: 8
Number of people: 12
This will make your CSS very long if you have many labels/rows since you have to have one rule for every row to populate the label.

How to set column width to be as small as possible?

I'm trying to set the last three columns to be as small as possible since they're just holding icons/links for actions.
I'd also want to the large text columns to have as much of the remaining width as possible.
Here's what I was able to find, but didn't work for me:
Two columns table : one as small as possible, the other takes the rest
This solution doesn't work for me because I have multiple columns that I want to take up as much space as possible, so I can't set any of them to width = 100%.
force column size to smallest possible
I tried using relative lengths (width="*"), but it doesn't seem to have any effect. Maybe it's because I didn't set any widths prior so there's no 'remaining width' to distribute out?
HTML:
<table>
<colgroup class='data' span='5'>
<col class='date' span='1'/>
<col class='id' span='1'/>
<col class='title' span='1'/>
<col class='status' span='1'/>
<col class='description' span='1'/>
</colgroup>
<colgroup class='action' span='3'>
<col class='show' span='1'/>
<col class='edit' span='1'/>
<col class='delete' span='1'/>
</colgroup>
<tr>
<th>Date</th>
<th>ID</th>
<th>Title</th>
<th>Status</th>
<th>Description</th>
<th colspan='3'></th>
</tr>
<tr>
<td class='date'>medium</td>
<td class='id'>medium</td>
<td class='title'>large</td>
<td class='status'>medium</td>
<td class='description'>large</td>
<td class='show'>small</td>
<td class='edit'>small</td>
<td class='delete'>small</td>
</tr>
</table>
CSS:
table {
width: 100%;
}
table td.title, td.description {
text-align: left;
}
table td.date, td.id, td.status {
text-align: center;
}
table td.show, td.edit, td.delete {
}
table colgroup.action col {
width:"1*";
}
table colgroup.data col {
width:"*";
}
So in the order of priority:
table spans entire width of parent container
the last three icon/action columns to be as small as possible without any cutoff
the columns with 'large' data (class title and description) should take up as much of the remaining space as possible
the columns with 'medium' data should be the size of their content with some margin on both sides (I don't mind just throwing in a fixed width if it's too difficult to accomplish this)
I don't need the colgroup and col tags, but I just left them in here in case they can be useful. I've tried different permutations of using and not using them, but still can't seem to get it to work. I also thought about using percents for the data columns, but I'd want the browser to determine the widths based on the actual content rather than me imposing predefined rules that might not be optimal.
For the columns you want to shrink, set the width to 1 px:
table {
width: 100%;
}
th, td {
border: 1px solid #eee;
}
td.title, td.description {
text-align: left;
}
td.date, td.id, td.status {
padding: 0 10px;
text-align: center;
width: 1px;
}
td.show, td.edit, td.delete {
width: 1px;
}
Then you can get rid of the colgroups altogether.
See demo here.
By the way, you might consider using CSS flexible boxes instead.
To answer one of your requests:
the last three icon/action columns to be as small as possible without
any cutoff
To do this, I would float the tds or set them to display:inline-block;
If you know the size of the icons you are using, you can then set the width on the th above the icons (which I would call class="icons").
If you don't know the width, you could calculate using some jQuery.
var a = $('td.show').width();
var b = $('td.edit').width();
var c = $('td.delete').width();
$('.icons').css('width', a+b+c+6+"px");
Example: http://jsfiddle.net/KQs2K/1/
Extra 6px needed to pad out the border bits I threw in the example
Note: these tds will stack when the screen size gets real small.

Resources