| 1 |
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */ |
| 2 |
/* vim: set ts=2 et sw=2 tw=80: */ |
| 3 |
|
| 4 |
/************************************************************* |
| 5 |
* |
| 6 |
* MathJax/jax/output/HTML-CSS/autoload/mtable.js |
| 7 |
* |
| 8 |
* Implements the HTML-CSS output for <mtable> elements. |
| 9 |
* |
| 10 |
* --------------------------------------------------------------------- |
| 11 |
* |
| 12 |
* Copyright (c) 2010-2020 The MathJax Consortium |
| 13 |
* |
| 14 |
* Licensed under the Apache License, Version 2.0 (the "License"); |
| 15 |
* you may not use this file except in compliance with the License. |
| 16 |
* You may obtain a copy of the License at |
| 17 |
* |
| 18 |
* http://www.apache.org/licenses/LICENSE-2.0 |
| 19 |
* |
| 20 |
* Unless required by applicable law or agreed to in writing, software |
| 21 |
* distributed under the License is distributed on an "AS IS" BASIS, |
| 22 |
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 23 |
* See the License for the specific language governing permissions and |
| 24 |
* limitations under the License. |
| 25 |
*/ |
| 26 |
|
| 27 |
MathJax.Hub.Register.StartupHook("HTML-CSS Jax Ready",function () { |
| 28 |
var VERSION = "2.7.9"; |
| 29 |
var MML = MathJax.ElementJax.mml, |
| 30 |
HTMLCSS = MathJax.OutputJax["HTML-CSS"]; |
| 31 |
|
| 32 |
MML.mtable.Augment({ |
| 33 |
toHTML: function (span) { |
| 34 |
span = this.HTMLcreateSpan(span); |
| 35 |
if (this.data.length === 0) {return span} |
| 36 |
var values = this.getValues("columnalign","rowalign","columnspacing","rowspacing", |
| 37 |
"columnwidth","equalcolumns","equalrows", |
| 38 |
"columnlines","rowlines","frame","framespacing", |
| 39 |
"align","useHeight","width","side","minlabelspacing"); |
| 40 |
var hasRelativeWidth = values.width.match(/%$/); |
| 41 |
var stack = HTMLCSS.createStack(span); |
| 42 |
var scale = this.HTMLgetScale(), mu = this.HTMLgetMu(span), LABEL = -1; |
| 43 |
|
| 44 |
var H = [], D = [], W = [], A = [], C = [], i, j, J = -1, |
| 45 |
m, M, s, row, cell, mo, entries = [], HD; |
| 46 |
var LH = HTMLCSS.FONTDATA.lineH * scale * values.useHeight, |
| 47 |
LD = HTMLCSS.FONTDATA.lineD * scale * values.useHeight; |
| 48 |
|
| 49 |
// |
| 50 |
// Create cells and measure columns and rows |
| 51 |
// |
| 52 |
for (i = 0, m = this.data.length; i < m; i++) { |
| 53 |
row = this.data[i]; s = (row.type === "mlabeledtr" ? LABEL : 0); |
| 54 |
A[i] = []; H[i] = LH; D[i] = LD; |
| 55 |
for (j = s, M = row.data.length + s; j < M; j++) { |
| 56 |
if (W[j] == null) { |
| 57 |
if (j > J) {J = j} |
| 58 |
C[j] = HTMLCSS.createStack(HTMLCSS.createBox(stack)); |
| 59 |
W[j] = -HTMLCSS.BIGDIMEN; |
| 60 |
} |
| 61 |
A[i][j] = HTMLCSS.createBox(C[j]); |
| 62 |
entries.push(row.data[j-s].toHTML(A[i][j])); |
| 63 |
} |
| 64 |
} |
| 65 |
HTMLCSS.MeasureSpans(entries); |
| 66 |
for (i = 0, m = this.data.length; i < m; i++) { |
| 67 |
row = this.data[i]; s = (row.type === "mlabeledtr" ? LABEL : 0); |
| 68 |
for (j = s, M = row.data.length + s; j < M; j++) { |
| 69 |
cell = row.data[j-s]; |
| 70 |
if (cell.isMultiline) {A[i][j].style.width = "100%"} |
| 71 |
if (cell.isEmbellished()) { |
| 72 |
mo = cell.CoreMO(); |
| 73 |
var min = mo.Get("minsize",true); |
| 74 |
if (min) { |
| 75 |
var bbox = mo.HTMLspanElement().bbox; |
| 76 |
if (mo.HTMLcanStretch("Vertical")) { |
| 77 |
HD = bbox.h + bbox.d; |
| 78 |
if (HD) { |
| 79 |
min = HTMLCSS.length2em(min,mu,HD); |
| 80 |
if (min*bbox.h/HD > H[i]) {H[i] = min*bbox.h/HD} |
| 81 |
if (min*bbox.d/HD > D[i]) {D[i] = min*bbox.d/HD} |
| 82 |
} |
| 83 |
} else if (mo.HTMLcanStretch("Horizontal")) { |
| 84 |
min = HTMLCSS.length2em(min,mu,bbox.w); |
| 85 |
if (min > W[j]) {W[j] = min} |
| 86 |
} |
| 87 |
} |
| 88 |
} |
| 89 |
if (A[i][j].bbox.h > H[i]) {H[i] = A[i][j].bbox.h} |
| 90 |
if (A[i][j].bbox.d > D[i]) {D[i] = A[i][j].bbox.d} |
| 91 |
if (A[i][j].bbox.w > W[j]) {W[j] = A[i][j].bbox.w} |
| 92 |
} |
| 93 |
} |
| 94 |
|
| 95 |
// |
| 96 |
// Determine spacing and alignment |
| 97 |
// |
| 98 |
var SPLIT = MathJax.Hub.SplitList; |
| 99 |
var CSPACE = SPLIT(values.columnspacing), |
| 100 |
RSPACE = SPLIT(values.rowspacing), |
| 101 |
CALIGN = SPLIT(values.columnalign), |
| 102 |
RALIGN = SPLIT(values.rowalign), |
| 103 |
CLINES = SPLIT(values.columnlines), |
| 104 |
RLINES = SPLIT(values.rowlines), |
| 105 |
CWIDTH = SPLIT(values.columnwidth), |
| 106 |
RCALIGN = []; |
| 107 |
for (i = 0, m = CSPACE.length; i < m; i++) {CSPACE[i] = HTMLCSS.length2em(CSPACE[i],mu)} |
| 108 |
for (i = 0, m = RSPACE.length; i < m; i++) {RSPACE[i] = HTMLCSS.length2em(RSPACE[i],mu)} |
| 109 |
while (CSPACE.length < J) {CSPACE.push(CSPACE[CSPACE.length-1])} |
| 110 |
while (CALIGN.length <= J) {CALIGN.push(CALIGN[CALIGN.length-1])} |
| 111 |
while (CLINES.length < J) {CLINES.push(CLINES[CLINES.length-1])} |
| 112 |
while (CWIDTH.length <= J) {CWIDTH.push(CWIDTH[CWIDTH.length-1])} |
| 113 |
while (RSPACE.length < A.length) {RSPACE.push(RSPACE[RSPACE.length-1])} |
| 114 |
while (RALIGN.length <= A.length) {RALIGN.push(RALIGN[RALIGN.length-1])} |
| 115 |
while (RLINES.length < A.length) {RLINES.push(RLINES[RLINES.length-1])} |
| 116 |
if (C[LABEL]) { |
| 117 |
CALIGN[LABEL] = (values.side.substr(0,1) === "l" ? "left" : "right"); |
| 118 |
CSPACE[LABEL] = -W[LABEL]; |
| 119 |
} |
| 120 |
// |
| 121 |
// Override row data |
| 122 |
// |
| 123 |
for (i = 0, m = A.length; i < m; i++) { |
| 124 |
row = this.data[i]; RCALIGN[i] = []; |
| 125 |
if (row.rowalign) {RALIGN[i] = row.rowalign} |
| 126 |
if (row.columnalign) { |
| 127 |
RCALIGN[i] = SPLIT(row.columnalign); |
| 128 |
while (RCALIGN[i].length <= J) {RCALIGN[i].push(RCALIGN[i][RCALIGN[i].length-1])} |
| 129 |
} |
| 130 |
} |
| 131 |
|
| 132 |
// |
| 133 |
// Handle equal heights |
| 134 |
// |
| 135 |
if (values.equalrows) { |
| 136 |
// FIXME: should really be based on row align (below is for baseline) |
| 137 |
var Hm = Math.max.apply(Math,H), Dm = Math.max.apply(Math,D); |
| 138 |
for (i = 0, m = A.length; i < m; i++) |
| 139 |
{s = ((Hm + Dm) - (H[i] + D[i])) / 2; H[i] += s; D[i] += s} |
| 140 |
} |
| 141 |
|
| 142 |
// FIXME: do background colors for entire cell (include half the intercolumn space?) |
| 143 |
|
| 144 |
// |
| 145 |
// Determine array total height |
| 146 |
// |
| 147 |
HD = H[0] + D[A.length-1]; |
| 148 |
for (i = 0, m = A.length-1; i < m; i++) {HD += Math.max(0,D[i]+H[i+1]+RSPACE[i])} |
| 149 |
// |
| 150 |
// Determine frame and line sizes |
| 151 |
// |
| 152 |
var fx = 0, fy = 0, fW, fH = HD; |
| 153 |
if (values.frame !== "none" || |
| 154 |
(values.columnlines+values.rowlines).match(/solid|dashed/)) { |
| 155 |
var frameSpacing = SPLIT(values.framespacing); |
| 156 |
if (frameSpacing.length != 2) { |
| 157 |
// invalid attribute value: use the default. |
| 158 |
frameSpacing = SPLIT(this.defaults.framespacing); |
| 159 |
} |
| 160 |
fx = HTMLCSS.length2em(frameSpacing[0],mu); |
| 161 |
fy = HTMLCSS.length2em(frameSpacing[1],mu); |
| 162 |
fH = HD + 2*fy; // fW waits until stack.bbox.w is determined |
| 163 |
} |
| 164 |
// |
| 165 |
// Compute alignment |
| 166 |
// |
| 167 |
var Y, fY, n = ""; |
| 168 |
if (typeof(values.align) !== "string") {values.align = String(values.align)} |
| 169 |
if (values.align.match(/(top|bottom|center|baseline|axis)( +(-?\d+))?/)) |
| 170 |
{n = RegExp.$3||""; values.align = RegExp.$1} else {values.align = this.defaults.align} |
| 171 |
if (n !== "") { |
| 172 |
// |
| 173 |
// Find the height of the given row |
| 174 |
// |
| 175 |
n = parseInt(n); |
| 176 |
if (n < 0) {n = A.length + 1 + n} |
| 177 |
if (n < 1) {n = 1} else if (n > A.length) {n = A.length} |
| 178 |
Y = 0; fY = -(HD + fy) + H[0]; |
| 179 |
for (i = 0, m = n-1; i < m; i++) { |
| 180 |
// FIXME: Should handle values.align for final row |
| 181 |
var dY = Math.max(0,D[i]+H[i+1]+RSPACE[i]); |
| 182 |
Y += dY; fY += dY; |
| 183 |
} |
| 184 |
} else { |
| 185 |
Y = ({ |
| 186 |
top: -(H[0] + fy), |
| 187 |
bottom: HD + fy - H[0], |
| 188 |
center: HD/2 - H[0], |
| 189 |
baseline: HD/2 - H[0], |
| 190 |
axis: HD/2 + HTMLCSS.TeX.axis_height*scale - H[0] |
| 191 |
})[values.align]; |
| 192 |
fY = ({ |
| 193 |
top: -(HD + 2*fy), |
| 194 |
bottom: 0, |
| 195 |
center: -(HD/2 + fy), |
| 196 |
baseline: -(HD/2 + fy), |
| 197 |
axis: HTMLCSS.TeX.axis_height*scale - HD/2 - fy |
| 198 |
})[values.align]; |
| 199 |
} |
| 200 |
|
| 201 |
var WW, WP = 0, Wt = 0, Wp = 0, p = 0, f = 0, P = [], F = [], Wf = 1; |
| 202 |
// |
| 203 |
if (values.equalcolumns && values.width !== "auto") { |
| 204 |
// |
| 205 |
// Handle equalcolumns for percent-width and fixed-width tables |
| 206 |
// |
| 207 |
if (hasRelativeWidth) { |
| 208 |
// Set widths to percentages |
| 209 |
WW = (100/(J+1)).toFixed(2).replace(/\.?0+$/,"")+"%"; |
| 210 |
for (i = 0, m = Math.min(J+1,CWIDTH.length); i < m; i++) {CWIDTH[i] = WW} |
| 211 |
// Get total column spacing |
| 212 |
WW = 0; WP = 1; f = J+1; |
| 213 |
for (i = 0, m = Math.min(J+1,CSPACE.length); i < m; i++) {WW += CSPACE[i]} |
| 214 |
} else { |
| 215 |
// Get total width minus column spacing |
| 216 |
WW = HTMLCSS.length2em(values.width,mu); |
| 217 |
for (i = 0, m = Math.min(J,CSPACE.length); i < m; i++) {WW -= CSPACE[i]} |
| 218 |
// Determine individual column widths |
| 219 |
WW /= J; |
| 220 |
for (i = 0, m = Math.min(J+1,CWIDTH.length); i < m; i++) {W[i] = WW} |
| 221 |
} |
| 222 |
} else { |
| 223 |
// |
| 224 |
// Get column widths for fit and percentage columns |
| 225 |
// |
| 226 |
// Calculate the natural widths and percentage widths, |
| 227 |
// while keeping track of the fit and percentage columns |
| 228 |
for(i = 0, m = Math.min(J+1,CWIDTH.length); i < m; i++) { |
| 229 |
if (CWIDTH[i] === "auto") {Wt += W[i]} |
| 230 |
else if (CWIDTH[i] === "fit") {F[f] = i; f++; Wt += W[i]} |
| 231 |
else if (CWIDTH[i].match(/%$/)) |
| 232 |
{P[p] = i; p++; Wp += W[i]; WP += HTMLCSS.length2em(CWIDTH[i],mu,1)} |
| 233 |
else {W[i] = HTMLCSS.length2em(CWIDTH[i],mu); Wt += W[i]} |
| 234 |
} |
| 235 |
if (hasRelativeWidth) { |
| 236 |
// Get separation width and check percentages |
| 237 |
WW = 0; for (i = 0, m = Math.min(J,CSPACE.length); i < m; i++) {WW += CSPACE[i]} |
| 238 |
if (WP > .98) {Wf = .98/WP; WP = .98} |
| 239 |
} else { |
| 240 |
// Get the full width (excluding inter-column spacing) |
| 241 |
if (values.width === "auto") { |
| 242 |
if (WP > .98) {Wf = Wp/(Wt+Wp); WW = Wt + Wp} else {WW = Wt / (1-WP)} |
| 243 |
} else { |
| 244 |
WW = HTMLCSS.length2em(values.width,mu); |
| 245 |
for (i = 0, m = Math.min(J,CSPACE.length); i < m; i++) {WW -= CSPACE[i]} |
| 246 |
} |
| 247 |
// Determine the relative column widths |
| 248 |
for (i = 0, m = P.length; i < m; i++) { |
| 249 |
W[P[i]] = HTMLCSS.length2em(CWIDTH[P[i]],mu,WW*Wf); Wt += W[P[i]]; |
| 250 |
} |
| 251 |
// Stretch fit columns, if any, otherwise stretch (or shrink) everything |
| 252 |
if (Math.abs(WW - Wt) > .01) { |
| 253 |
if (f && WW > Wt) { |
| 254 |
WW = (WW - Wt) / f; for (i = 0, m = F.length; i < m; i++) {W[F[i]] += WW} |
| 255 |
} else {WW = WW/Wt; for (j = 0; j <= J; j++) {W[j] *= WW}} |
| 256 |
} |
| 257 |
// |
| 258 |
// Handle equal columns |
| 259 |
// |
| 260 |
if (values.equalcolumns) { |
| 261 |
var Wm = Math.max.apply(Math,W); |
| 262 |
for (j = 0; j <= J; j++) {W[j] = Wm} |
| 263 |
} |
| 264 |
} |
| 265 |
} |
| 266 |
|
| 267 |
// |
| 268 |
// Lay out array columns |
| 269 |
// |
| 270 |
var y = Y, dy, line, align; s = (C[LABEL] ? LABEL : 0); |
| 271 |
for (j = s; j <= J; j++) { |
| 272 |
for (i = 0, m = A.length; i < m; i++) { |
| 273 |
if (A[i][j]) { |
| 274 |
s = (this.data[i].type === "mlabeledtr" ? LABEL : 0); |
| 275 |
cell = this.data[i].data[j-s]; |
| 276 |
if (cell.HTMLcanStretch("Horizontal")) { |
| 277 |
A[i][j].bbox = cell.HTMLstretchH(C[j],W[j]).bbox; |
| 278 |
} else if (cell.HTMLcanStretch("Vertical")) { |
| 279 |
mo = cell.CoreMO(); |
| 280 |
var symmetric = mo.symmetric; mo.symmetric = false; |
| 281 |
A[i][j].bbox = cell.HTMLstretchV(C[j],H[i],D[i]).bbox; A[i][j].HH = null; |
| 282 |
if (A[i][j].bbox.h > H[i]) {A[i][j].bbox.H = A[i][j].bbox.h; A[i][j].bbox.h = H[i]} |
| 283 |
if (A[i][j].bbox.d > D[i]) {A[i][j].bbox.D = A[i][j].bbox.d; A[i][j].bbox.d = D[i]} |
| 284 |
mo.symmetric = symmetric; |
| 285 |
} |
| 286 |
align = cell.rowalign||this.data[i].rowalign||RALIGN[i]; |
| 287 |
dy = ({top: H[i] - A[i][j].bbox.h, |
| 288 |
bottom: A[i][j].bbox.d - D[i], |
| 289 |
center: ((H[i]-D[i]) - (A[i][j].bbox.h-A[i][j].bbox.d))/2, |
| 290 |
baseline: 0, axis: 0})[align] || 0; // FIXME: handle axis better? |
| 291 |
align = (cell.columnalign||RCALIGN[i][j]||CALIGN[j]); |
| 292 |
HTMLCSS.alignBox(A[i][j],align,y+dy); |
| 293 |
} |
| 294 |
if (i < A.length-1) {y -= Math.max(0,D[i]+H[i+1]+RSPACE[i])} |
| 295 |
} |
| 296 |
y = Y; |
| 297 |
} |
| 298 |
|
| 299 |
// |
| 300 |
// Set column widths and placement |
| 301 |
// |
| 302 |
if (hasRelativeWidth) { |
| 303 |
// |
| 304 |
// Remove column spacing to get width available for columns |
| 305 |
// |
| 306 |
var box = HTMLCSS.createBox(stack); box.style.left = box.style.top = 0; |
| 307 |
box.style.right = HTMLCSS.Em(WW+2*fx); box.style.display = "inline-block"; |
| 308 |
box.style.height = "0px"; |
| 309 |
if (HTMLCSS.msieRelativeWidthBug) { |
| 310 |
box = HTMLCSS.createBox(box); box.style.position = "relative"; |
| 311 |
box.style.height = "1em"; box.style.width = "100%"; box.bbox = stack.bbox; |
| 312 |
} |
| 313 |
// |
| 314 |
// wp = remaining width (%) divided by the number of columns it is split over |
| 315 |
// wm = remaining width (fixed) divided by the number of columns it is split over |
| 316 |
// |
| 317 |
var xp = 0, xf = fx, wp, wm; |
| 318 |
if (f) {wp = 100*(1-WP)/f, wm = Wt/f} else {wp = 100*(1-WP)/(J+1); wm = Wt/(J+1)} |
| 319 |
for (j = 0; j <= J; j++) { |
| 320 |
HTMLCSS.placeBox(C[j].parentNode,0,0); // sets the bbox |
| 321 |
// |
| 322 |
// Convert original column to the innermost span in the mobile column |
| 323 |
// |
| 324 |
C[j].style.position = "relative"; |
| 325 |
C[j].style.left = HTMLCSS.Em(xf); |
| 326 |
C[j].style.width = "100%"; |
| 327 |
C[j].parentNode.parentNode.removeChild(C[j].parentNode); |
| 328 |
var Cj = HTMLCSS.createBox(box); HTMLCSS.addBox(Cj,C[j]); C[j] = Cj; |
| 329 |
var CjStyle = Cj.style; CjStyle.display = "inline-block"; CjStyle.left = xp + "%"; |
| 330 |
// |
| 331 |
// Set width/position based on the type of column |
| 332 |
// |
| 333 |
if (CWIDTH[j].match(/%$/)) { |
| 334 |
var pp = parseFloat(CWIDTH[j]) * Wf; |
| 335 |
if (f === 0) { |
| 336 |
CjStyle.width = (wp + pp) + "%"; xp += wp + pp; |
| 337 |
Cj = HTMLCSS.createBox(Cj); HTMLCSS.addBox(Cj,C[j].firstChild); |
| 338 |
Cj.style.left = 0; Cj.style.right = HTMLCSS.Em(wm); xf -= wm; |
| 339 |
} else { |
| 340 |
CjStyle.width = pp + "%"; xp += pp; |
| 341 |
} |
| 342 |
} else if (CWIDTH[j] === "fit" || f === 0) { |
| 343 |
CjStyle.width = wp + "%"; |
| 344 |
Cj = HTMLCSS.createBox(Cj); HTMLCSS.addBox(Cj,C[j].firstChild); |
| 345 |
Cj.style.left = 0; Cj.style.right = HTMLCSS.Em(wm-W[j]); |
| 346 |
xf += W[j] - wm; xp += wp; |
| 347 |
} else { |
| 348 |
CjStyle.width = HTMLCSS.Em(W[j]); xf += W[j]; |
| 349 |
} |
| 350 |
if (HTMLCSS.msieRelativeWidthBug) { |
| 351 |
HTMLCSS.addText(Cj.firstChild,HTMLCSS.NBSP); // gets correct baseline |
| 352 |
Cj.firstChild.style.position = "relative"; |
| 353 |
} |
| 354 |
xf += CSPACE[j]; |
| 355 |
// |
| 356 |
// Add column lines |
| 357 |
// |
| 358 |
if (CLINES[j] !== "none" && j < J && j !== LABEL) { |
| 359 |
line = HTMLCSS.createBox(box); line.style.left = xp+"%"; |
| 360 |
line = HTMLCSS.createRule(line,fH,0,1.25/HTMLCSS.em); line.style.position = "absolute"; |
| 361 |
line.bbox = {h:fH, d:0, w:0, rw:1.25/HTMLCSS.em, lw:0}; |
| 362 |
line.parentNode.bbox = stack.bbox; // make sure stack size is updated |
| 363 |
HTMLCSS.placeBox(line,xf-CSPACE[j]/2,fY,true); line.style.borderStyle = CLINES[j]; |
| 364 |
} |
| 365 |
} |
| 366 |
} else { |
| 367 |
// |
| 368 |
// Set the column box widths and place them |
| 369 |
// |
| 370 |
var x = fx; |
| 371 |
for (j = 0; j <= J; j++) { |
| 372 |
if (!C[j].bbox.width) {HTMLCSS.setStackWidth(C[j],W[j])} |
| 373 |
if (CWIDTH[j] !== "auto" && CWIDTH[j] !== "fit") |
| 374 |
{C[j].bbox.width = W[j]; C[j].bbox.isFixed = true} |
| 375 |
HTMLCSS.placeBox(C[j].parentNode,x,0); x += W[j] + CSPACE[j]; |
| 376 |
// |
| 377 |
// Add column lines |
| 378 |
// |
| 379 |
if (CLINES[j] !== "none" && j < J && j !== LABEL) { |
| 380 |
line = HTMLCSS.createRule(stack,fH,0,1.25/HTMLCSS.em); HTMLCSS.addBox(stack,line); |
| 381 |
line.bbox = {h:fH, d:0, w:0, rw:1.25/HTMLCSS.em, lw:0}; |
| 382 |
HTMLCSS.placeBox(line,x-CSPACE[j]/2,fY,true); line.style.borderStyle = CLINES[j]; |
| 383 |
} |
| 384 |
} |
| 385 |
} |
| 386 |
stack.bbox.d = -fY; stack.bbox.h = fH+fY; |
| 387 |
HTMLCSS.setStackWidth(stack,stack.bbox.w + fx); |
| 388 |
|
| 389 |
// |
| 390 |
// Add frame |
| 391 |
// |
| 392 |
fW = stack.bbox.w; var frame; |
| 393 |
if (values.frame !== "none") { |
| 394 |
frame = HTMLCSS.createFrame(stack,fH,0,fW,1.25/HTMLCSS.em,values.frame); |
| 395 |
HTMLCSS.addBox(stack,frame); HTMLCSS.placeBox(frame,0,fY,true); |
| 396 |
if (hasRelativeWidth) {frame.style.width = "100%"} |
| 397 |
} |
| 398 |
// |
| 399 |
// Add row lines |
| 400 |
// |
| 401 |
y = Y; |
| 402 |
for (i = 0, m = A.length-1; i < m; i++) { |
| 403 |
dy = Math.max(0,D[i]+H[i+1]+RSPACE[i]); |
| 404 |
if (RLINES[i] !== MML.LINES.NONE && RLINES[i] !== "") { |
| 405 |
line = HTMLCSS.createRule(stack,1.25/HTMLCSS.em,0,fW); HTMLCSS.addBox(stack,line); |
| 406 |
line.bbox = {h:1.25/HTMLCSS.em, d:0, w:fW, rw:fW, lw:0}; |
| 407 |
HTMLCSS.placeBox(line,0,y - D[i] - (dy-D[i]-H[i+1])/2,true); |
| 408 |
if (RLINES[i] === MML.LINES.DASHED) line.style.borderTopStyle = "dashed"; |
| 409 |
if (hasRelativeWidth) line.style.width = "100%" |
| 410 |
} |
| 411 |
y -= dy; |
| 412 |
} |
| 413 |
// |
| 414 |
// Set relative width |
| 415 |
// |
| 416 |
if (hasRelativeWidth) {span.bbox.width = values.width; stack.style.width = "100%"} |
| 417 |
// |
| 418 |
// Place the labels, if any |
| 419 |
// |
| 420 |
if (C[LABEL]) { |
| 421 |
var mw = stack.bbox.w; |
| 422 |
var indent = this.getValues("indentalignfirst","indentshiftfirst","indentalign","indentshift"); |
| 423 |
if (indent.indentalignfirst !== MML.INDENTALIGN.INDENTALIGN) {indent.indentalign = indent.indentalignfirst} |
| 424 |
if (indent.indentalign === MML.INDENTALIGN.AUTO) {indent.indentalign = this.displayAlign} |
| 425 |
if (indent.indentshiftfirst !== MML.INDENTSHIFT.INDENTSHIFT) {indent.indentshift = indent.indentshiftfirst} |
| 426 |
if (indent.indentshift === "auto") {indent.indentshift = "0"} |
| 427 |
var shift = HTMLCSS.length2em(indent.indentshift,mu,HTMLCSS.cwidth); |
| 428 |
var labelspace = HTMLCSS.length2em(values.minlabelspacing,mu,HTMLCSS.cwidth); |
| 429 |
var labelW = labelspace + C[LABEL].bbox.w, labelshift = 0, tw = mw; |
| 430 |
var dIndent = HTMLCSS.length2em(this.displayIndent,mu,HTMLCSS.cwidth); |
| 431 |
s = (CALIGN[LABEL] === MML.INDENTALIGN.RIGHT ? -1 : 1); |
| 432 |
if (indent.indentalign === MML.INDENTALIGN.CENTER) { |
| 433 |
tw += 2 * (labelW - s*(shift + dIndent)); |
| 434 |
shift += dIndent; |
| 435 |
} else if (CALIGN[LABEL] === indent.indentalign) { |
| 436 |
if (dIndent < 0) {labelshift = s*dIndent; dIndent = 0} |
| 437 |
shift += s*dIndent; if (labelW > s*shift) shift = s*labelW; shift += labelshift; |
| 438 |
tw += s*shift; |
| 439 |
} else { |
| 440 |
tw += labelW - s*shift + dIndent; |
| 441 |
shift -= s*dIndent; |
| 442 |
} |
| 443 |
var eqn = HTMLCSS.createStack(span,false,"100%"); |
| 444 |
HTMLCSS.addBox(eqn,stack); HTMLCSS.alignBox(stack,indent.indentalign,0,shift); |
| 445 |
C[LABEL].parentNode.parentNode.removeChild(C[LABEL].parentNode); |
| 446 |
HTMLCSS.addBox(eqn,C[LABEL]); HTMLCSS.alignBox(C[LABEL],CALIGN[LABEL],0); |
| 447 |
if (HTMLCSS.msieRelativeWidthBug) {stack.style.top = C[LABEL].style.top = ""} |
| 448 |
if (hasRelativeWidth) {stack.style.width = values.width; span.bbox.width = "100%"} |
| 449 |
C[LABEL].style[s === 1 ? "marginLeft" : "marginRight"] = HTMLCSS.Em(s*labelshift); |
| 450 |
span.bbox.tw = tw; |
| 451 |
span.style.minWidth = span.bbox.minWidth = HTMLCSS.Em(tw); |
| 452 |
eqn.style.minWidth = eqn.bbox.minWidth = HTMLCSS.Em(tw/scale); |
| 453 |
} |
| 454 |
// |
| 455 |
// Finish the table |
| 456 |
// |
| 457 |
if (!hasRelativeWidth) {this.HTMLhandleSpace(span)} |
| 458 |
var color = this.HTMLhandleColor(span); |
| 459 |
// |
| 460 |
// Handle relative-sized background color |
| 461 |
// |
| 462 |
if (color && hasRelativeWidth) { |
| 463 |
if (!frame) { |
| 464 |
frame = HTMLCSS.createFrame(stack,fH,0,fW,0,"none"); |
| 465 |
HTMLCSS.addBox(stack,frame); HTMLCSS.placeBox(frame,0,fY,true); |
| 466 |
frame.style.width = "100%"; |
| 467 |
} |
| 468 |
frame.style.backgroundColor = color.style.backgroundColor; |
| 469 |
frame.parentNode.insertBefore(frame,frame.parentNode.firstChild); |
| 470 |
color.parentNode.removeChild(color); |
| 471 |
} |
| 472 |
return span; |
| 473 |
}, |
| 474 |
HTMLhandleSpace: function (span) { |
| 475 |
span.bbox.keepPadding = true; span.bbox.exact = true; |
| 476 |
if (!this.hasFrame && span.bbox.width == null) { |
| 477 |
span.firstChild.style.marginLeft = span.firstChild.style.marginRight = HTMLCSS.Em(1/6); |
| 478 |
span.bbox.w += 1/3; span.bbox.rw += 1/3; span.bbox.lw += 1/6; |
| 479 |
} |
| 480 |
this.SUPER(arguments).HTMLhandleSpace.call(this,span); |
| 481 |
} |
| 482 |
}); |
| 483 |
|
| 484 |
MML.mtd.Augment({ |
| 485 |
toHTML: function (span,HW,D) { |
| 486 |
span = this.HTMLcreateSpan(span); |
| 487 |
if (this.data[0]) { |
| 488 |
var box = this.data[0].toHTML(span); |
| 489 |
if (D != null) {box = this.data[0].HTMLstretchV(span,HW,D)} |
| 490 |
else if (HW != null) {box = this.data[0].HTMLstretchH(span,HW)} |
| 491 |
span.bbox = box.bbox; |
| 492 |
} |
| 493 |
this.HTMLhandleSpace(span); |
| 494 |
this.HTMLhandleColor(span); |
| 495 |
return span; |
| 496 |
}, |
| 497 |
HTMLstretchH: MML.mbase.HTMLstretchH, |
| 498 |
HTMLstretchV: MML.mbase.HTMLstretchV |
| 499 |
}); |
| 500 |
|
| 501 |
MathJax.Hub.Startup.signal.Post("HTML-CSS mtable Ready"); |
| 502 |
MathJax.Ajax.loadComplete(HTMLCSS.autoloadDir+"/mtable.js"); |
| 503 |
|
| 504 |
}); |
| 505 |
|