Textpattern CMS support forum
You are not logged in. Register | Login | Help
- Topics: Active | Unanswered
[Archived] stw_category_tree
ARCHIVED PLUGIN: this can be acheived with a combination of native tags
==============================
Name: stw_category_tree
Author: Sandor Weisz
Created: 2004-06-14
Modified: 2006-11-21
Version: 1.0.1
Download: stw_category_tree
<?php
$plugin='a:8:{s:4:"name";s:17:"stw_category_tree";s:7:"version";s:5:"1.0.1";s:6:"author";s:12:"Sandor Weisz";s:10:"author_uri";s:23:"http://www.santheo.com/";s:11:"description";s:129:"Displays links to categories in a hierarchical structure, along with content count. Includes scads of hiding and showing options.";s:4:"help";s:8406:"
	<p><style><br />
td {padding:2px;}<br />
</style></p>

	<p>This works like the category_list tag, but instead of listing the categories linearly, it creates a hierarchical structure (by default, through unordered lists). It allows for depth control, pruning, content count totals, and some CSS properties.</p>

	<p><strong>NEW IN 1.0.1</strong>:</p>
	<ul>
	<li>Supports clean category URLs as defined by the <a href="http://textpattern.org/plugins/209/sgb_url_handler">sgb_url_handler plugin</a>. Such links must be in the format of section/category (as defined by default).</li>
	</ul>

	<p><strong>NEW IN 1.0</strong>:</p>
	<ul>
	<li>Support for <code>wraptag</code> and <code>break</code> properties.</li>
		<li>The <code>killempties</code> property restricts the plugin to only display categories that have one more more items in them, or that have sub-categories that have one or more items in them.</li>
		<li>New property: <code>localized</code>. Set <code>localized</code> to &#8220;y&#8221; to make the plugin show only categories that are part of the current section.</li>
		<li>New property: <code>time</code>. Each category article count is now, by default, only counting articles dated in the past. Set <code>time</code> to &#8220;future&#8221; or &#8220;all&#8221; to alter that.</li>
		<li>New property: <code>subtotal</code>. To make the item count show the sum of the items in the category as well as its sub-categories, set <code>subtotal</code> to &#8220;y&#8221;.</li>
		<li>Tested in TXP v. 4.0.4.</li>
	</ul>

	<p>It accepts the following attributes:</p>

	<table>
		<tr>
			<td style="vertical-align:top;"><strong><code>start</code></strong></td>
			<td>If you&#8217;d like the category tree to start at a node deeper than the root, set this attribute to the name of that cateogry. All categories underneath specified node will be displayed. If unspecified, tree starts at root. If set to *, it&#8217;ll be set to the current category. If set to *s, it&#8217;ll be set to the current <i>section</i>, in case you prefer to hack the system that way.</td>
		</tr>
		<tr>
			<td style="vertical-align:top;"><strong><code>maxlevel</code></strong></td>
			<td>The deepest level you&#8217;d like displayed. If unassigned, there is no maximum.</td>
		</tr>
		<tr>
			<td style="vertical-align:top;"><strong><code>minlevel</code></strong></td>
			<td>The shallowest level you&#8217;d like displayed. If unassigned, there is no minimum.</td>
		</tr>
		<tr>
			<td style="vertical-align:top;"><strong><code>prune</code></strong></td>
			<td>When set to &#8220;y&#8221;, the tree will prune away any categories that are not either a) ancestors of the current category, b) the current category, c) children of the current category, or d) siblings of {a} and {b}. Is false by default.</td>
		</tr>
		<tr>
			<td style="vertical-align:top;"><strong><code>cat</code></strong></td>
			<td>Works in combination with <code>prune</code> or <code>onclass</code> (below). Setting the value of this attribute to a category overrides the current category when pruning is turned on. It&#8217;ll also affect the assignment of the class=&#8221;...&#8221;, if <code>onclass</code> is set to something.</td>
		</tr>
		<tr>
			<td style="vertical-align:top;"><strong><code>section</code></strong></td>
			<td>If you&#8217;d like all category links to go to a specific section, set this to the preferred section. If you&#8217;d like to use the current section, whatever it is, set this to &#8221;*&#8221;. If unspecified, no section will be specified. (Note that in TXP, if you require a category link to specify both a category and a section, the link will always be messy&#8212;i.e. in the format /path/to/site/SECTION/?c=CATEGORY.)</td>
		</tr>
		<tr>
			<td style="vertical-align:top;"><strong><code>cssid</code></strong></td>
			<td>The value you&#8217;d like assigned to the <code>id</code> property of the top-level <code>ul</code> tag. If unassigned, the attribute is omitted.</td>
		</tr>
		<tr>
			<td style="vertical-align:top;"><strong><code>onclass</code></strong></td>
			<td>The value you&#8217;d like assigned to the <code>class</code> property of the current cateogry and all of its ancestors. Note: if this is assigned to anything other than an empty string, <code>id</code> attributes will also be assigned to <i>all</i> <code>li</code> tags with the value set to that <code>li</code>&#8217;s category. If unassigned, no <code>class</code> or <code>id</code> attributes will be assigned.</td>
		</tr>
		<tr>
			<td style="vertical-align:top;"><strong><code>type</code></strong></td>
			<td>Defines which type of categories to generate: &#8216;article&#8217;, &#8216;image&#8217; or &#8216;link&#8217;. Is set to &#8216;article&#8217; by default.</td>
		</tr>
		<tr>
			<td style="vertical-align:top;"><strong><code>count</code></strong></td>
			<td>When set to &#8220;y&#8221;, each category link will be followed by the number of live items within that category, set inside parentheses. If you&#8217;d like the number to be set inside a different pair of characters, set <code>count</code> to those characters. For example, to make it output &#8220;CategoryName {3}&#8221;, set <code>count</code> to &#8221;{}&#8221;. Is false by default. New in version 0.6: If you&#8217;d like the count to appear only when it&#8217;s greater than 0, set the third character of the attribute to &#8217;!&#8217;. For example, &#8221;{}!&#8221; will appent &#8221; {#}&#8221; to the end of the category name only with that category has one or more items in it.</td>
		</tr>
		<tr>
			<td style="vertical-align:top;"><strong><code>killempties</code></strong></td>
			<td>(Changed in 1.0) When set to &#8220;y&#8221;, it will restrict the plugin to only display categories that have one more more items in them, or that have sub-categories that have one or more items in them.</td>
		</tr>
		<tr>
			<td style="vertical-align:top;"><strong><code>localized</code></strong></td>
			<td>(New in 1.0) When set to &#8220;y&#8221;, it will restrict the plugin to only display categories the plugin show only categories that are part of the current section.</td>
		</tr>
		<tr>
			<td style="vertical-align:top;"><strong><code>time</code></strong></td>
			<td>(New in 1.0) The article count now only includes articles written in the past. To include future categories, set this property to &#8220;all&#8221;. To show only future categories, set this property to &#8220;future&#8221;.</td>
		</tr>
		<tr>
			<td style="vertical-align:top;"><strong><code>subtotal</code></strong></td>
			<td>(New in 1.0) When set to &#8220;y&#8221;, each category&#8217;s item count will be th sum of the items within itself plus the number within all its sub-categories.</td>
		</tr>
		<tr>
			<td style="vertical-align:top;"><strong><code>label</code>, <code>labeltag</code></strong></td>
			<td>Works like all other TXP tags. When at least the former is set, prefixes your output with a line of the format <code>&lt;labeltag&gt;label&lt;/labeltag&gt;</code>.</td>
		</tr>
		<tr>
			<td style="vertical-align:top;"><strong><code>wraptag</code>, <code>break</code></strong></td>
			<td>(New in 1.0) Works like all other TXP tags. Wraps each category link in the <code>break</code> tag, and wraps each level of <code>break</code>s with the <code>wraptag</code>. If <code>break</code> is set to &#8220;hr&#8221; or &#8220;br&#8221;, it&#8217;ll append the tag to the end of the link instead of surround it. Set either to a space (&#8221; &#8221;) to use remove the tag. Is set to &#8220;ul&#8221; and &#8220;li&#8221; by default.</td>
		</tr>
	</table>

	<p>Try it out and see. Best understood by trial and error. Please report any hinkiness by posting in the <a href="http://forum.textpattern.com/viewtopic.php?pid=14263">TXP forum</a>.</p>

	<p>(Note: I had to create some adjunct functions to work with this tag, so while I haven&#8217;t included documenation for <code>stw_get_lineage</code> and <code>stw_get_parent</code> [and others], they&#8217;re there and free to be played with. Noodle around and try them out, if you&#8217;d like.)</p>

	<p><hr /></p>

	<p>Thanks to <a href="mailto:tonda@kaf.cz">Pin007</a> for his implementation of the <code>type</code> property.<br />
Thanks to <a href="http://www.tinyfly.com/">Tinyfly</a> for the assistance in making <code>stw_get_live_count</code> work with links and images.</p>



 ";s:4:"code";s:7668:"
function stw_category_tree ($atts) {
	global $pretext;
	extract($pretext);

	if (is_array($atts)) extract($atts);
	$start         =  (empty($start))       ?  "root"        :  $start;
	$css_id        =  (empty($cssid))       ?  ""            :  $cssid;
	$css_on_class  =  (empty($onclass))     ?  ""            :  $onclass;
	$minlevel      =  (empty($minlevel))    ?  1             :  $minlevel;
	$maxlevel      =  (empty($maxlevel))    ?  -1            :  $maxlevel;
	$section       =  (empty($section))     ?  ""			 :  $section;
	$prune         =  (empty($prune))       ?  false         :  $prune;
	$type          =  (empty($type))        ?  "article"     :  $type;
	$count         =  (empty($count))       ?  false         :  $count;
	$killempties   =  (empty($killempties)) ?  false         :  $killempties;
	$localized     =  (empty($localized))   ?  false         :  $localized;
	$time          =  (empty($time))        ?  "past"        :  $time;
	$subtotal      =  (empty($subtotal))    ?  false         :  $subtotal;

	$label         =  (empty($label))       ?  ""            :  $label;
	$labeltag      =  (empty($labeltag))    ?  ""            :  $labeltag;
	$wraptag       =  (empty($wraptag))     ?  "ul"          :  $wraptag;
	$break         =  (empty($break))       ?  "li"          :  $break;

	if ($start == "*") $start = $c ? $c : "root";
	if ($start == "*s") $start = $GLOBALS['s'];
	if ($section == "*") $section = $GLOBALS['s'];
	if ($localized) $localized = $GLOBALS['s'];
	if ($wraptag == " ") $wraptag = "";
	if ($break == " ") $break = "";

	$out = '';
	$lastlevel = 0;
	$thiscat = (empty($cat)) ? ($c ? $c : $start) : $cat;
	$count = ($count == "true") ? "()" : $count;
	$lineage = stw_get_lineage($thiscat, $type);

	$vars = compact("start","css_id","css_on_class","minlevel","maxlevel","section","prune","type","count","killempties","label","labeltag","localized","time","subtotal","wraptag","break","thiscat","lineage");

	$cs = stw_get_cat_list($start,$type);

	if ($cs) {
		array_shift($cs);
		list ($tree) = stw_make_tree($cs,$vars);
		return doLabel($label, $labeltag)."\n".$tree;
	}
	return "";
}

function stw_make_tree ($rs,$vars) {
	$out = "";
	while ($cat = array_shift($rs)) {
		extract($cat);

		$lastlevel = $level;

		// IF THIS ITEM IS OUT OF OUR RANGE, SKIP IT
		$parent_in_tree = $vars['prune'] ? in_array($parent,$vars['lineage']) : true;
		if (($level > $vars['maxlevel'] && $vars['maxlevel'] != -1) || $level < $vars['minlevel'] || !$parent_in_tree) continue;

		// BUILD THE PROPERTIES OF THE CATEGORY ITEMS TAG
		$tag_class = $vars['css_on_class'] && in_array($name,$vars['lineage']) ? $vars['css_on_class'] : '';
		$tag_atts = $vars['css_on_class'] ? ' id="cat-'.stw_css_encode($name).'"' : '';

		// IF THE CATEGORY HAS CHILDREN, CREATE THE SUB-LIST. IF THE SUB-LIST IS EMPTY, SET IT TO AN EMPTY STRING
		$me_in_tree = $vars['prune'] ? in_array($name,$vars['lineage']) : true;
		$children_tree = "";
		$sub_count = 0;
		if ($children && $level!=$vars['maxlevel'] && $me_in_tree)
			list($children_tree,$sub_count) = stw_make_tree(array_splice($rs,0,$children),$vars);
		$children_tree = preg_replace("/\t*<".$vars['wraptag'].">\n\t*<\/".$vars['wraptag'].">/","",$children_tree);

		// BUILD THE TEXT OF THE CATEGORY LINK
		$title = (empty($title)) ? $name : $title;
		$count = stw_get_live_count($name,$type,$vars['localized'],$vars['time']) + ($vars['subtotal'] ? $sub_count : 0);
		$count_subtotal += $count;
		$link = stw_cat_link($name,$vars['section'],$title).($vars['count'] && ($vars['count']{2}!="!" || $count) ? " ".$vars['count']{0}.$count.$vars['count']{1} : "");

		// IF THIS ITEM IS HAS NO ITEMS (OR CHILDREN WITH ITEMS), AND KILLEMPTIES IS ON, SKIP IT
		if ($vars['killempties'] && !$count && $children_tree=="") continue;

		// GENERATE THE CATEGORY LINK, SURROUNDED BY THE NECESSARY TAG
		$break = $vars['break'];
		if ($break == "br" || $break == "hr") {
			$link = stw_tabs($level).join(doTag("",$break),array($link,$children_tree));
		} else {
			$link = stw_tabs($level).doWrap(array($link,$children_tree),$break,"",$tag_class,"",$tag_atts);
		}
		$out .= substr_replace($link,"",strrpos($link,"\n"),1)."\n";
	}
	$level = $lastlevel;
	$out = str_replace("></".$vars['wraptag'],">\n".stw_tabs($level)."</".$vars['wraptag'],$out);
	return array(stw_tabs($level-1).doWrap(array("\n".$out),$vars['wraptag'],"","","",($vars['css_id'] && $level==1) ? ' id="'.$vars['css_id'].'"' : ""),$count_subtotal);
}

function stw_tabs ($level) {
	return str_repeat("\t",max($level,0));
}

// stw_cat_link: returns a link to the passed category. Supports clean links as defined by the default setting of the sgb_url_handler plugin
// - - - - - -
function stw_cat_link ($cat,$sec,$title) {
	global $sgb_url_handler_cfg;

	$cat_link = pagelinkurl(array('c'=>$cat, 's'=>$sec));
	if ($sgb_url_handler_cfg && !empty($sec) && $sec!='default' && $permlink_mode!='messy') {
		$cleanurl = sgb_url_handler_config();
		if ($cleanurl['schemes']['section_category'] == "%section%/%category%")
			$cat_link = hu.urlencode($sec)."/".urlencode($cat);
	}
	return tag(htmlspecialchars($title),'a',' href="'.$cat_link.'" title="'.htmlspecialchars($title).'"');
}

function stw_css_encode ($txt) {
	return str_replace("+","-",urlencode($txt));
}

// stw_get_parent: returns the parent of the passed category
// - - - - - -
function stw_get_parent ($child, $type = 'article') {
	$row = safe_row("parent", "txp_category", "name='$child' and type='$type'");
	if ($row) return $row['parent'];
	return "";
}

// stw_get_lineage: returns an array of the passed category's ancestors, from its parent up to the root
// - - - - - -
function stw_get_lineage ($child, $type = 'article') {
	$parent = stw_get_parent($child, $type);
	if (!$parent) {
		return array("root");
	} else {
		$arr = stw_get_lineage($parent, $type);
		$arr[] = $child;
	}
	return $arr;
}

// stw_get_ancestor: returns a particular ancestory of the passed category. Not currently used.
// - - - - - -
function stw_get_ancestor ($atts) {
	if (is_array($atts)) extract($atts);
	$child = (empty($child)) ? gps("c") : $child;
	$level = (empty($level)) ? 1 : $level;
	$type = (empty($type)) ? "article" : $type;
	$lineage = stw_get_lineage($child, $type);
	$ancestor = ($level>0) ? $lineage[$level] : "";
	return $ancestor;
}

function stw_get_live_count ($cat,$type,$section,$time) {
	$sect_predicate = $section ? " AND Section='".$section."'" : "";
	$time_predicate = " AND Posted < now()";
    if ($time=="future") $time_predicate = " AND Posted > now()";
    elseif ($time == "all") $time_predicate = "";

	if ($type=="link") {
		$q = safe_count("txp_link","category='".$cat."'");
	} elseif ($type=="image") {
		$q = safe_count("txp_image","category='".$cat."'");
	} elseif ($type=="file") {
		$q = safe_count("txp_file","category='".$cat."'");
	} else {
		$q = safe_count("textpattern","(Category1='".$cat."' OR Category2='".$cat."') AND Status='4'".$sect_predicate.$time_predicate);
	}
	return $q;
}

function stw_get_cat_list($root, $type) {
	$root = doSlash($root);

	extract(safe_row(
		"lft as l, rgt as r",
		"txp_category",
		"name='$root' and type = '$type'"
	));

	$right = array();

	$rs = safe_rows_start(
		"name, lft, rgt, parent, title",
		"txp_category",
		"lft between $l and $r and type = '$type' order by lft asc"
	);

	while ($row = nextRow($rs)) {
		extract($row);
		while (count($right) > 0 && $right[count($right)-1] < $rgt) {
			array_pop($right);
		}

		$out[] = array(
			'name' => $name,
			'title' => $title,
			'level' => count($right),
			'parent' => $parent,
			'children' => ($rgt - $lft - 1) / 2
		);

		$right[] = $rgt;
	}
	return($out);
}
";s:3:"md5";s:32:"db51e652cd6271810273d107bfb9f835";}'
?>Update: Starting with version 0.7, you should be using TXP 4.0.3 or later. I haven’t tested it with any earlier version, so caveat emptor. If you’d like to use an earlier version download version 0.5 or version 0.6.1.
———
This works like the category_list tag, but instead of listing the categories linearly, it creates a hierarchical structure (by default, through unordered lists). It allows for depth control, pruning, content count totals, and some CSS properties.
NEW IN 1.0.1:- Supports clean category URLs as defined by the sgb_url_handler plugin, if you have that plug-in installed. Such links must be in the format of section/category (as defined by default).
- Support for
wraptagandbreakproperties. - The
killemptiesproperty restricts the plugin to only display categories that have one more more items in them, or that have sub-categories that have one or more items in them. - New property:
localized. Setlocalizedto “y” to make the plugin show only categories that are part of the current section. - New property:
time. Each category article count is now, by default, only counting articles dated in the past. Settimeto “future” or “all” to alter that. - New property:
subtotal. To make the item count show the sum of the items in the category as well as its sub-categories, setsubtotalto “y”. - Tested in TXP v. 4.0.3.
It accepts the following attributes:
| @start@ | If you’d like the category tree to start at a node deeper than the root, set this attribute to the name of that cateogry. All categories underneath specified node will be displayed. If unspecified, tree starts at root. If set to *, it’ll be set to the current category. If set to *s, it’ll be set to the current <i>section</i>, in case you prefer to hack the system that way. |
| @maxlevel@ | The deepest level you’d like displayed. If unassigned, there is no maximum. |
| @minlevel@ | The shallowest level you’d like displayed. If unassigned, there is no minimum. |
| @prune@ | When set to “y”, the tree will prune away any categories that are not either a) ancestors of the current category, b) the current category, c) children of the current category, or d) siblings of {a} and {b}. Is false by default. |
| @cat@ | Works in combination with prune or onclass (below). Setting the value of this attribute to a category overrides the current category when pruning is turned on. It’ll also affect the assignment of the class=”…”, if onclass is set to something. |
| @section@ | If you’d like all category links to go to a specific section, set this to the preferred section. If you’d like to use the current section, whatever it is, set this to “*”. If unspecified, no section will be specified. (Note that in TXP, if you require a category link to specify both a category and a section, the link will always be messy — i.e. in the format /path/to/site/SECTION/?c=CATEGORY.) |
| @cssid@ | The value you’d like assigned to the id property of the top-level ul tag. If unassigned, the attribute is omitted. |
| @onclass@ | The value you’d like assigned to the class property of the current cateogry and all of its ancestors. Note: if this is assigned to anything other than an empty string, id attributes will also be assigned to <i>all</i> li tags with the value set to that li’s category. If unassigned, no class or id attributes will be assigned. |
| @type@ | Defines which type of categories to generate: ‘article’, ‘image’ or ‘link’. Is set to ‘article’ by default. |
| @count@ | When set to “y”, each category link will be followed by the number of live items within that category, set inside parentheses. If you’d like the number to be set inside a different pair of characters, set count to those characters. For example, to make it output “CategoryName {3}”, set count to “{}”. Is false by default. New in version 0.6: If you’d like the count to appear only when it’s greater than 0, set the third character of the attribute to ‘!’. For example, “{}!” will appent “ {#}” to the end of the category name only with that category has one or more items in it. |
| @killempties@ | (Changed in 1.0) When set to “y”, it will restrict the plugin to only display categories that have one more more items in them, or that have sub-categories that have one or more items in them. |
| @localized@ | (New in 1.0) When set to “y”, it will restrict the plugin to only display categories the plugin show only categories that are part of the current section. |
| @time@ | (New in 1.0) The article count now only includes articles written in the past. To include future categories, set this property to “all”. To show only future categories, set this property to “future”. |
| @subtotal@ | (New in 1.0) When set to “y”, each category’s item count will be th sum of the items within itself plus the number within all its sub-categories. |
@label@, labeltag |
Works like all other TXP tags. When at least the former is set, prefixes your output with a line of the format <labeltag>label</labeltag>. |
@wraptag@, break |
(New in 1.0) Works like all other TXP tags. Wraps each category link in the break tag, and wraps each level of breaks with the wraptag. If break is set to “hr” or “br”, it’ll append the tag to the end of the link instead of surround it. Set either to a space (” “) to use remove the tag. Is set to “ul” and “li” by default. |
Try it out and see. Best understood by trial and error. Please report any hinkiness by posting in the TXP forum.
(Note: I had to create some adjunct functions to work with this tag, so while I haven’t included documenation for stw_get_lineage and stw_get_parent [and others], they’re there and free to be played with. Noodle around and try them out, if you’d like.)
———
Thanks to Pin007 for his implementation of the type property.
Thanks to Tinyfly for the assistance in making stw_get_live_count work with links and images.
Last edited by santheo (2006-11-21 17:04:13)
Offline
Re: [Archived] stw_category_tree
Meant to say: this plugin was inspired by Dean’s Article by Category plugin and would not exist but for the slick code I copped from within that plugin. Which code made understanding the architecture of TXP so much easier.
Offline
Re: [Archived] stw_category_tree
Great plugin, santheo. Seems to work really nicely.
-Alan
Offline
Re: [Archived] stw_category_tree
Love the plugin, it does exactly what I want, with one exception: I would use it twice on the same page, to list two different set of sub-categories, but it only displays the first instance.
Any idea if it is possible to use in that way, and how?
Offline
Re: [Archived] stw_category_tree
Love the plugin, it does exactly what I want, with one exception: I would use it twice on the same page, to list two different set of sub-categories, but it only displays the first instance.
I’ve tested this situation out on my install, and it seems to work fine. My only guess at this point is that you’re misspelling the name of the category you’re putting in the start attribute.
Can you post or email me the tags you’re using, and, if possible, your category tree? That’ll make it easier to debug.
Offline
Re: [Archived] stw_category_tree
The tags I am using are:
txp:stw_category_tree start=“English” prune=“true”
and
txp:stw_category_tree start=“Fran
Offline
Re: [Archived] stw_category_tree
Figured it out. It wasn’t the
Last edited by santheo (2004-06-15 15:44:29)
Offline
Re: [Archived] stw_category_tree
Tried a number of combination, including the one I’d mentioned above, and still get the same problem.
If you go check http://blog-cafe.com (don’t mind the mess, it’s very much under construction), you’ll see what gets output when using the tag
txp:stw_category_tree start=
Last edited by Benoit (2004-06-15 17:49:56)
Offline
Re: [Archived] stw_category_tree
Benoit-
From looking at your source code, I can actually see the TXP tag, which means it’s not being picked up by the TXP interpreter. Not sure how that happened, but you’ll need to fix that first.
One suggestion: add a trailing slash to the tag. So instead of this:
<code><txp:stw_category_tree start=
Offline
Re: [Archived] stw_category_tree
OK. I’ll try that. And I’ll do some additional checking on the CSS side. Got a feeling that may be part of the problem too. Have to get back to work now, but will get back to you with what I find. Thanks again for all the help!
Offline
Re: [Archived] stw_category_tree
OK, problem fixed. :)
Using ONE instance of the plugin without trailing slash works fine, but with two instances of the plugin on the same page, it required the trailing slash for both of them to show up.
Many many thanks for all your help, Santheo, and thanks again for the great plugin!
Offline
Re: [Archived] stw_category_tree
Santheo, Beno
Offline