<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
 <head>
  <title>CSS Multi-column Layout Test: nested multicolumn and nested margin-top</title>
  <link rel="author" title="Opera Software ASA" href="http://www.opera.com/" />
  <link rel="reviewer" title="Gérard Talbot" href="http://www.gtalbot.org/BrowserBugsSection/css21testsuite/" /> <!--  2013-08-14  -->
  <link rel="help" href="http://www.w3.org/TR/css3-multicol/#the-multi-column-model" title="2. The multi-column model" />
  <link rel="match" href="multicol-nested-margin-004-ref.xht" />
  <meta name="flags" content="ahem" />
  <meta name="assert" content="This test checks that due to a top margin only set on the first child element of a nested multicol element that will not collapse with the margins of the multicol element, then the height of an multi-column element can make its other inner multi-column (with a zero margin-top) element break into its own column boxes." />
  <style type="text/css"><![CDATA[
  body > div
  {
  font: 1.25em/1 Ahem;
  margin: 1em;
  width: 41em;
  /*
  This test requires a viewport width of 860px
  */
  }

  div
  {
  background: yellow;
  color: black;
  margin: 1em;
  orphans: 1;
  widows: 1;

  column-count: 3;
  column-gap: 1em;
  }

  div div {margin: 0 1em;}

  div div:first-child {margin: 1em 1em 0;}

  /*

  N == 3;

  43em - 2em (horizontal margins) == available-width

  W == max(0, (available-width - ((N - 1) * column-gap)) / N);
  W == max(0, (41em - ((3 - 1) * 1em)) / 3);
  W == max(0, (41em - (2 * 1em)) / 3);
  W == max(0, (41em - 2em) / 3);
  W == max(0, 39em / 3);
  W == max(0, 13em);
  W == 13em;

    13em : width of each outer column box
   -
     2em : horizontal margin of each div inside
   =======
    11em : width of each inner multi-column elements

  N == 3;

  W == max(0, (available-width - ((N - 1) * column-gap)) / N);
  W == max(0, (11em - ((3 - 1) * 1em)) / 3);
  W == max(0, (11em - (2 * 1em)) / 3);
  W == max(0, (11em - 2em) / 3);
  W == max(0, 9em / 3);
  W == max(0, 3em);
  W == 3em;

  */

  div div:nth-child(2) {color: pink;}

  div div:nth-child(3) {color: blue;}
  ]]></style>
 </head>

 <body>

  <div>
	<div>
		bl ac
		bl ac
		bl ac
		bl ac
	</div>
	<div>
		Pi nk
		Pi nk
		Pi nk
		Pi nk
	</div>
	<div>
		bl ue
		bl ue
		bl ue
		bl ue
	</div>
  </div>

 </body>
</html>
