What is the default width of an HTML table cell <td>? - css

I haven't been able to find the answer to this question: Where in the spec or in UA documentation is the default width of a <td> defined?
I've searched the HTML Living Standard, the HTML5 Recommendation, and various other sources.
My understanding (based on usage and observation) is that a table cell will, by default, occupy the full width of the column in which it lives. And the cell cannot be given a different width than the column if other cells exist in the column.
I'm looking for official confirmation of this behavior, preferably in W3C or user agent documentation. But any authoritative reference is acceptable.

The physical/visual width of a table cell is defined not by HTML, but by CSS. The CSS 2.1 specification has an entire section dedicated to table layout that complements HTML's description of tabular data.
Furthermore, CSS itself does not fully define how the width of a cell is calculated. It does with the fixed table layout algorithm:
In the fixed table layout algorithm, the width of each column is determined as follows:
A column element with a value other than 'auto' for the 'width' property sets the width for that column.
Otherwise, a cell in the first row with a value other than 'auto' for the 'width' property determines the width for that column. If the cell spans more than one column, the width is divided over the columns.
Any remaining columns equally divide the remaining horizontal table space (minus borders or cell spacing).
The width of the table is then the greater of the value of the 'width' property for the table element and the sum of the column widths (plus cell spacing or borders). If the table is wider than the columns, the extra space should be distributed over the columns.
but it doesn't give anything beyond a rough guideline for auto table layout, which user agents are free to follow or deviate from (it lists a step-by-step procedure not unlike that of fixed table layout, but that entire list is non-normative). Generally you can expect consistent behavior from UAs in the most common scenarios — as you observe, an auto-sized table cell generally takes up as much space as required by its content, and no more. But dig into edge cases, and you'll find all sorts of crazy.

Here's the W3C standards on calculating the width of table columns. Basically it is left up to the implementing browser/agent.
If an author specifies no width information for a column, a user agent
may not be able to incrementally format the table since it must wait
for the entire column of data to arrive in order to allot an
appropriate width.
If column widths prove to be too narrow for the contents of a
particular table cell, user agents may choose to reflow the table.
Source: http://www.w3.org/TR/html401/struct/tables.html#h-11.2.4.4
Note: this is HTML4 docs.

A table cell's minimum width is 0 or the size of the largest word or image within that cell.
Table Sizing Algorithm
The default sizing algorithm requires two passes through the table data. In the first pass, word wrapping is disabled, and the user agent keeps track of the minimum and maximum width of each cell. The maximum width is given by the widest line. As word wrap has been disabled, paragraphs are treated as long lines unless broken by elements. The minimum width is given by the widest word or image etc. taking into account leading indents and list bullets etc. In other words, if you were to format the cell's content in a window of its own, determine the minimum width you could make the window before things begin to be clipped.
The minimum and maximum cell widths are then used to determine the corresponding minimum and maximum widths for the columns. These in turn, are used to find the minimum and maximum width for the table. Note that cells can contain nested tables, but this doesn't complicate the code significantly. The next step is to assign column widths according to the current window size (more accurately - the width between the left and right margins).
The table borders and intercell margins need to be included in the assignment step. There are three cases:
The minimum table width is equal to or wider than the available space. In this case, assign the minimum widths and allow the user to scroll horizontally. For conversion to braille, it will be necessary to replace the cells by references to notes containing their full content. By convention these appear before the table.
The maximum table width fits within the available space. In this case, set the columns to their maximum widths.
The maximum width of the table is greater than the available space, but the minimum table width is smaller. In this case, find the difference between the available space and the minimum table width, lets call it W. Lets also call D the difference between maximum and minimum width of the table.
For each column, let d be the the difference between maximum and minimum width of that column. Now set the column's width to the minimum width plus d times W over D. This makes columns with lots of text wider than columns with smaller amounts.
This assignment step is then repeated for nested tables. In this case, the width of the enclosing table's cell plays the role of the current window size in the above description. This process is repeated recursively for all nested tables.
If the COLSPEC attribute specifies the column widths explicitly, the user agent can attempt to use these values. If subsequently, one of the cells overflows its column width, the two pass mechanism may be invoked to redraw the table with more appropriate widths. If the attribute specifies relative widths, then the two pass model is always needed.
The column width assignment algorithm is then modified:
Explicit widths from the COLSPEC attribute should be used when given, provided they are greater than the minimum column width, otherwise the latter should be used.
For relative widths, the surplus space W, as defined above, is divided up between the columns appropriately, ensuring that each column is given at least its minimum width. If W is zero or negative, column widths should be increased over the minimum width to meet the relative width requirements.
If the table width is specified with the WIDTH attribute, the user agent attempts to set column widths to match. The WIDTH attribute should be disregarded if this results in columns having less than their minimum widths.

Related

CSS table text-align not working on some values in column

I have two columns, one of values for a variable and another of rankings of those values. The rankings column works fine; it is aligned left and 70% of the size of the values column. However, in the values column, all values in the column align right (as I want them to) except for the last value. The issue seems to be related to the number of characters in the value.
Here are the two columns
Any ideas?
It seems the last value is still aligning-right, but as you mentioned with the increased values in the left column it is pushing them together. If you are able, increasing the overall size of the column to account for increased values. (e.g. increase column padding and/or width).

For CSS grid, is specifying grid-row-start the same number as grid-row-end the same as differing by 1? [duplicate]

This question already has answers here:
Understanding grid negative values
(2 answers)
Closed 3 years ago.
And this applies to columns as well. In the same CSS code, I sometimes see the grid-row-start and grid-row-end differing by 1, but sometimes differing by 0. And they seem to mean the same thing: span 1.
For example, this CSS code being linked specified box01 column start end of 1, 3, and for box02, a column start end of 2, 2:
.box01 {grid-area: 1 / 1 / 2 / 3;}
.box02 {grid-area: 1 / 2 / 3 / 2;}
Then why would we sometimes specify the same and sometimes differing by 1? Are they identical in every way? (is it supported by the specs?)
From the specification there is some special rules to handle some particular cases:
If the placement for a grid item contains two lines, and the start line is further end-ward than the end line, swap the two lines. If the start line is equal to the end line, remove the end line.
If the placement contains two spans, remove the one contributed by the end grid-placement property.
If the placement contains only a span for a named line, replace it with a span of 1.
Basically, if the end line is the same as the start line, it's not valid so the browser will remove the end line and it will fall to auto
Then you can read:
grid position
The grid item’s location in the grid in each axis. A grid position can be either definite (explicitly specified) or automatic (determined by auto-placement).
grid span
How many grid tracks the grid item occupies in each axis. A grid item’s grid span is always definite, defaulting to 1 in each axis if it can’t be otherwise determined for that axis.
And also
auto
The property contributes nothing to the grid item’s placement, indicating auto-placement or a default span of one. (See § 8 Placing Grid Items, above.)
So if you define grid-column:1/1 it means you defined grid-column-start = grid-column-end = 1. We remove the end and it's like you only have grid-column-start:1 and by default the span is 1 so visually you will have the same result as doing grid-column:1/2
We can say both are the same but the first one (defining the same number) will be considered as invalid and the Grid Placement Conflict Handling will make it behave as the second one which is the correct way to do.
Pay attention as this is not the same when dealing with negative values. See this related question: Understanding grid negative values
There is propably other particular cases but you should avoid using the same number because it's not logical and you will rely on the browser to correct your mistake.

How to make a table with flexible width columns in CSS

All:
Right now, I want to make a table which has spec like:
I. Table has table header and body. Table width is fixed to 800px; height is 500px; Each row is 20px high. 100% width; The header is fixed position, the body can scroll if overflow. The whole table is mapped to an array of objects, each object has a field called "name" and several attrs(all 4 digits number).
II. The first column from left is called "name", rest columns are sub attributes of the object with that name. The number of columns is dynamic depends on the object. All columns have text-flow:ellipsis to crop overlong text
III. The layout rule is(It actually requires very complex rule, but I think if anyone could just help me with the most basic, then I probably can figure out rest myself):
[1]. When show the attributes name. Make the attribute name not be cropped as possible as we can. But must guarantee the "name" column must no smaller than 300px(the name column can be cropped too); If the attribute name has to be cropped, try to make all columns same width;
[2] If no attribute name and name cropped, and there is still space, assign the space to name column.
I am thinking using div and css to build this rather than table tr td(cos I think it could be harder to me to understand and control)
Thanks

Tkinter Grid Columnspan ignored

Consider the following python script
#!/usr/bin/env python
from Tkinter import Tk, Label
width = SOME_VALUE_HERE
root = Tk()
label1 = Label(root, text='1 columns wide')
label2 = Label(root, text='%i columns wide' % width)
label1.grid()
label2.grid(row=0,column=1,columnspan=width)
root.mainloop()
When I run this, no matter what value is set for 'SOME_VALUE_HERE', both labels take up half the window, regardless of whether or not Grid.columnconfigure is called, or the sticky parameter is used in grid().
Unless I've overlooked something, I would have thought that setting the columnspan would force the second label to be 'SOME_VALUE_HERE' times as wide as the first.
Have I misunderstood how grid works? How would I go about achieving this behavior?
By default, empty grid column are zero width, so you described the following table. Grid geometry manager will by default try to optimize the screen real estate used by your application. It will integrate all the constraint and produce the fittest layout.
+---------------+---------------++++
| 0 | 1 |||| <-- 2,3,4 empty, 0 width
+---------------+---------------++++
| 1 column wide | 4 column wide |
+---------------+---------------++++
To provide strict proportional column width, you have to use the uniform option of columnconfigure. uniform takes an arbitrary value to designate the group of the column that share these proportions, and the weight argument is used to properly handle widget resizing.
label1.grid(row=0, column=0)
label2.grid(row=0,column=1, columnspan=width)
for i in range(width+1):
root.grid_columnconfigure(i, weight=1, uniform="foo")
Note that with only these two labels, you could achieve the same layout by adjusting the width of column 1. Differences will occur still while you populate column 2,3,4...
label2.grid(row=0,column=1) #no columnspan
root.grid_columnconfigure(0, weight=1, uniform="foo")
root.grid_columnconfigure(1, weight=width, uniform="foo")
When you put something in column 1 with a columnspan of two (or more) that means it will be in column 1 and column 2 (etc). However, if there is nothing controlling the width of a column, that column will have a width of zero. You need to force column 2 to have a widtheither by putting something in there, giving it a minsize, or forcing uniform columns.
When I look at your code, I can't guess how wide you think column 2 should be, and neither can the computer.
I had a similar problem only to discover that the elements are limited by the widest widget. We can safely say that Tkinter is configured to make your app uniform in that it should be a regular repeating square/triangular structure. Solution to override default options.
With the Tkinter's automatic optimization in mind, play with the width and height of largest widget (grid box) and relate the other boxes to it proportionally.
Using the above method use columnspan to adjust the width.
Configure the widths by use of columnconfigure()

How to stop Grid, GridRow, GridItem from assigning proportional column widths

In Flex4 we use Grid, GridRow and GridItem to layout the components of our screens. Most screens look OK, but quite a few appear with large amounts of space between the label and field. This mainly happens when we want to have something like the following scenario...
Name [____________]
Age [__]
Gender [_]
Details
[__________________________________________]
[__________________________________________]
[__________________________________________]
|<col 1>|<------------ col 2 ------------->|
|<---------- grid and row width ---------->|
...where the Labels are in the first column, the top three fields are in the second column, and the bottom three fields span across both columns. Above is how we would like it appear, but Flex renders it like this...
Name [____________]
Age [__]
Gender [_]
Details
[__________________________________________]
[__________________________________________]
[__________________________________________]
|<--- col 1 --->|<-------- col 2 --------->|
|<---------- grid and row width ---------->|
We don't have the ability to set individual column widths in each screen as a) there are thousands of screens and b) the labels and components can be internationalised.
I can't quite work out the algorithm they use to assign each column its width, but I think it looks for the widest component in each column and then uses these to assign each column an appropriate proportional width.
All we want is for each column to be as thin as possible so it just contains just its widest component (ignoring those that span of course), and doesn't have any extra whitespace. Does anyone know how to achieve this result?

Resources