a:8:{s:4:"name";s:13:"jcb_columnize";s:7:"version";s:3:"0.5";s:6:"author";s:10:"Jim Benton";s:10:"author_uri";s:27:"http://infiniteexpanse.net/";s:11:"description";s:73:"Divides elements into multiple divs for display in a column-based format.";s:4:"help";s:5382:"
	<h1>About</h1>

	<p>This plugin will content passed to it into multiple divs, the goal of which is to provide the appropriate markup for a multiple-column based layout.</p>

	<h1>Use</h1>

	<p>To use this plugin, surround what you want to be columnized with the tag <strong>txp:jcb_columnize</strong>.</p>

	<h1>Modes of operation</h1>

	<p>There are three ways to tell the plugin where to end one column and begin another. The mode you wish to use should be passed in as the argument <strong>mode</strong></p>

	<h2>Split by Tag</h2>

	<p>This is the default mode for the plugin. To use, set <strong>mode</strong> = &#8216;tag&#8217;. Arguments for this mode are:</p>

	<blockquote>
		<p><strong>arg</strong> What tag(s) to use as breaking points for the columns. Defaults to &#8216;p&#8217;. Do not include any angle brackets- only the name of the tag. You can indicate multiple tags by separating them with a &#8217;|&#8217; (pipe), like so: <strong>arg</strong> = &#8220;p|ul|dl&#8221;.</p>
	</blockquote>

	<blockquote>
		<p><strong>columns</strong> The number of columns to generate. Two or three seem to work best with shorter articles. Defaults to 2.</p>
	</blockquote>

	<h2>Split by String</h2>

	<p>This mode allows for creating column divisions wherever a selected string occurs. To use, set <strong>mode</strong> = &#8216;string&#8217;. Arguments for this mode are:</p>

	<blockquote>
		<p><strong>arg</strong> The string to use as a split point. I suggest something like &#8217;+++++&#8217;.</p>
	</blockquote>

	<p><strong>Note:</strong> to use this mode, place the string to split by in its own paragraph, as show in the following. <strong>splitonstring</strong> would be set to &#8217;+++++&#8217; in this example.</p>

	<blockquote>
		<p>If one examines surrealism, one is faced with a choice: either accept postdialectic discourse or conclude that reality is capable of significance. The subject is interpolated into a surrealism that includes language as a reality. Therefore, the example of postdialectic discourse depicted in Stone&#8217;s Heaven and Earth emerges again in Platoon.<br />
<em>empty line</em><br />
+++++<br />
<em>empty line</em><br />
The characteristic theme of the works of Stone is the role of the poet as observer. However, Debord suggests the use of postdialectic discourse to challenge and modify class.</p>
	</blockquote>

	<h2>Smart Mode</h2>

	<p>This mode, currently still in development, will take mixed-tag content (paragraphs, unordered lists, headings) and intelligently arrange it in the number of columns specified by <strong>columns</strong>. Set <strong>mode</strong> = &#8216;smart&#8217;.</p>

	<h2>Split After Words</h2>

	<p>This mode will allow for splitting after a set number of words. It is not yet implemented.</p>

	<h1>Global arguments</h1>

	<p>The following arguments are available globally to control the plugin&#8217;s operation:</p>

	<blockquote>
		<p><strong>classes</strong> There are two possible values for this argument: &#8216;unique&#8217; creates unique classes for each div (&#8216;columnized1&#8217;, &#8216;columnized2&#8217;, etc), always based on the <strong>classname</strong> with an added digit. &#8216;uniform&#8217; creates all divs with the same class &#8211; just the <strong>classname</strong>. Defaults to &#8216;unique&#8217;.</p>
	</blockquote>

	<blockquote>
		<p><strong>classname</strong> The name to use for classes as set by <strong>classes</strong>. Defaults to &#8216;columnized&#8217;.</p>
	</blockquote>

	<h1>Example css</h1>

	<h2>Unique classes</h2>

	<p>Example CSS using <strong>class</strong>=&#8217;unique&#8217;, courtesy of <a href="http://nodeo.net/">davidm</a>:</p>

	<h4>Two column example</h4>

	<blockquote>
		<p>.columnized1 {float: left; width: 225px; padding: 5px;}.columnized2 {margin-left: 250px; width: 225px; padding: 5px;}</p>
	</blockquote>

	<h4>Three columns example</h4>

	<blockquote>
		<p>.columnized1 {float: left; width: 225px; padding: 5px;}<br />
.columnized2 {float: left; width: 225px; padding: 5px;}<br />
.columnized3 {margin-left: 600px; width: 225px; padding: 5px;}</p>
	</blockquote>

	<h1>Uniform classes</h1>

	<p>This is how I usually use the plugin, where all columns are simply floated to one side.</p>

	<h4>Universal example</h4>

	<blockquote>
		<p>.columnized {float: left; width: 225px; padding: 5px;}</p>
	</blockquote>

	<p>Please note that you may have issues with this method unless the following elements contain a style like so:</p>

	<blockquote>
		<p>.aftercolumns {clear: left;}</p>
	</blockquote>

	<p>Where <em>left</em> is the direction the columns were floated, and <em>aftercolumns</em> is a class applied to the following elements. Alternatively, the same thing is possible using adjacent sibling selectors:</p>

	<blockquote>
		<p>.columnized + p {clear: left;}</p>
	</blockquote>

	<p>Where <em>columnized</em> is the class name being generated for the last column, and p is the following element. There may be browser rendering issues with this technique.</p>

	<h1>Notes</h1>

	<p>Many thanks to <a href="http://www.agitprop.gr/">Etz Haim</a> for contributing code that allowed for distributing any type of elements into multiple divs.</p>

	<p>Also, thanks to those involved in <a href="http://forum.textpattern.com/viewtopic.php?id=8333">the discussion</a> of this plugin and its development.</p>


 ";s:4:"code";s:6410:"
//
//		Just a few helper functions first
//		TXP seems to use the author prefix as a sort of namespace so I'm adhering to that
//

function jcb_e ($stuff) {
	echo '<p>' . $stuff . '</p';
}

function jcb_p ($stuff) {
	echo '<pre>';
	print_r($stuff);
	echo '</pre>';
}

function jcb_killTags($html) {
	$result = preg_replace('|<[\.^>]+>|', '', $html);
	return $result;
}

function jcb_columnize($atts, $thing='') {

	//
	// 	PUT BOOTS ON
	//

	// toggle debug display
	define('JCBDBG', false);

	// check for passed attributes
	if(isset($atts)) extract($atts);

	// assign defaults for variables if not set by user
	if(!isset($columns)) $columns = 2;
	if(!isset($classes)) $classes = "unique";
	if(!isset($classname)) $classname = "columnized";
	if (!isset($mode)) $mode = 'tag';
	if (!isset($arg)) $arg = 'p';

	// retrieve html to be processed
	$body = parse($thing);

	// this holds the content nodes
	$nodes = Array();

	// this holds the columns (actualy references to elements of $nodes to avoid duplication)
	$cols = Array();

	// a few more for good measure
	$matches = Array();
	$totalWords = '';
	$totalChars = '';
	$output = '';

	//
	//		LOAD CONTENT NODES
	//

	// figure out how we are splitting: by tag/string, or number of words
		switch ($mode) {

			case 'tag':
				// splitting based on tag - use tag to define split points
				$pattern = '/<(' . $arg . ')[\s]*([^>]*)>(.*?)<\/\1>/s';
				break;

			case 'string':
				// splitting based on string - use tag to define split points
				// this is still being done the old way FYI
				$numBreaks = substr_count($body, $arg);

				// replace the paragraph tags added by txp around splitting string
				$breakString = '<p>' . $arg . '</p>';

				if ($classes == "unique") {
					$output = '<div class="' . $classname . '1">';
				} else {
					$output = '<div class="' . $classname .'">';
				}

				for ($i = 1; $i <= $numBreaks; $i++) {
					$nextBreak = strpos($body, $breakString);

					// build html to replace splitonstring
					$filler = '</div>' . n;
					if ($classes == "unique") {
						$filler .= '<div class="' . $classname . ($i + 1) . '">';
					} else {
						$filler .= '<div class="' . $classname .'">';
					}
					$body = substr_replace($body, $filler, $nextBreak, strlen($breakString));
				}

				$output .= $body;
				$output .= n . '</div>' . n;

				// return results
				return $output;

				break;

			case 'smart':
				// *SMART* splitting- we'll see how this goes
				// this looks for p, ul, and heading tags and uses them to form nodes
				$pattern = '%<(p|ul|h[1-8]{1})[\s]*([^>]*)>(.*?)</\1>%s';
				break;
		}

		// do matching
		preg_match_all($pattern, $body, $matches, PREG_SET_ORDER);

		// get total number of matches
		$numMatches = sizeof($matches);
		if (JCBDBG) jcb_e('Found ' . $numMatches . ' matches.');

		// no matches; let's get out of here
		if ($numMatches == 0) return $body;

		// loop through matches, moving needed info into $nodes
		foreach ($matches as $match) {

			$numWords = substr_count(jcb_killTags($match[3]), ' ') + 1;
			$numChars = strlen(jcb_killTags($match[3])) - $numWords;
			$nodes[] = Array('tag' => $match[1],
								  'atts' => $match[2],
			 					  'content' => $match[3],
								  'chars' => $numChars - $numWords,
								  'words' => $numWords
								 );

			$totalWords += $numWords;
			$totalChars += $numChars - $numWords;
		}

		// get total number of nodes
		$numNodes = sizeof($nodes);

		if (JCBDBG) jcb_e('Working on ' . $numNodes . ' nodes.');
		if (JCBDBG) jcb_p($nodes);

		//
		//		DIVIDE NODES INTO COLUMNS
		//

		// some of this math is for features looking forward
		// this calculates an average length based on number of words
		$avgWordLength = $totalChars / $totalWords;
		$avgWords = $totalWords / $numNodes;

		/*
		$charErrorMargin = 0;
		$wordErrorMargin = 0;

		foreach ($nodes as $node) {
			$charErrorMargin += $node['chars'] - ($avgWordLength * $node['words']);
			$wordErrorMargin += $node['words'] - ($avgWordLength * $node['words']);
		}

		$avgCharError = $charErrorMargin / sizeof($nodes);

		foreach ($nodes as $node) {
			echo 'c: ' . $node['chars'] . ', ' . ($avgWordLength * $node['words'] + $avgCharError) . '<br />';
			echo 'w: ' . $node['words'] . ', ' . $avgWords . '<br />';
		}
		*/

		// determine average length of column in characters
		$avgColLength = $totalChars / $columns;

		if (JCBDBG) jcb_e('Average column length is ' . floor($avgColLength) . ' characters.');
		if (JCBDBG) jcb_e('STARTING UP THE COLUMNIZER');

		$nextNode = 0;

		for ($i=0; $i <= $columns -1; $i++) {
			if ($nextNode <= $numNodes -1) {
				$colLength = 0;
				$cols[$i] = Array();

				// the following conditional can use some testing/tweaking- it controls when columns end
				while (	$nextNode <= $numNodes -1
							&& ($colLength + $nodes[$nextNode]['chars'] <= $avgColLength * 1.1 || $colLength == 0)
						) {
					//if (JCBDBG) jcb_e('node number ' . $nextNode . ':');
					$cols[$i][] = $nextNode;
					$colLength += $nodes[$nextNode]['chars'];
					//if (JCBDBG) jcb_e($nodes[$nextNode]['chars'] . ' ' . 'colLength: ' . $colLength);
					$nextNode++;
				}

				//
				//		PERFORM SANITY CHECKS ON COLUMN
				//

				// make sure a heading is never the last thing in a column
				foreach ($cols as $col) {
					$lastCol = sizeof($col)-1;
					if (substr($nodes[$col[$lastCol]]['tag'], 1, 1) == 'h') {
						// drop node from last column
						array_pop($cols[$col]);
						// add to next column
						array_splice($cols[$col], 0, 0, $lastCol);
					}
				}

				if (JCBDBG) jcb_e('Final length for column ' . $i . ': ' . $colLength);

			} else {
				// We're out of nodes- end loop
				break;
			}
		}

		//
		//		CREATE COLUMN HTML
		//

		for ($i =0; $i<= sizeof($cols) -1; $i++) {

			$col = $cols[$i];

			if ($classes == "unique") {
				$output .= '<div class="' . $classname . ($i + 1)  . '">' . n;
			} else {
				$output .= '<div class="' . $classname .'">' . n;
			}

			foreach ($col as $nodeRef) {
				$node = $nodes[$nodeRef];
				if ($mode = 'tag' || $mode == 'smart') {
					$output .= '<' . $node['tag'];
					if (!empty($node['atts'])) $output .= ' ' . $node['atts'];
					$output .= '>';
				}
				$output .= $node['content'];
				if ($mode = 'tag' || $mode == 'smart') {
					$output .= '</' . $node['tag'] . '>' . n;
				}
			}

			$output .= '</div>' . n;
		}

		//
		//		TAH-DAH
		//

		return $output;

}
";s:3:"md5";s:32:"db01f8c6f97343361c4ebc1b9638a579";}