' => _('Heading 1'), '

' => _('Heading 2'), '

' => _('Heading 3'), '

' => _('Heading 4'), '

' => _('Heading 5'), '

' => _('Heading 6'), '

' => _('Normal'), '

' => _('Preformatted'),
			'
' => _('Quotation'));
		$fonts = array('' => _('Font'),
			'cursive' => _('Cursive'),
			'fantasy' => _('Fantasy'),
			'monospace' => _('Monospace'),
			'sans-serif' => _('Sans serif'),
			'serif' => _('Serif'));
		$sizes = array('' => _('Size'),
			1 => 1, 2 => 2, 3 => 3, 4 => 4, 5 => 5, 6 => 6, 7 => 7);
		$format = array('bold' => _('Bold'),
			'italic' => _('Italic'),
			'underline' => _('Underline'),
			'strikethrough' => _('Strikethrough'),
			'subscript' => _('Subscript'),
			'superscript' => _('Superscript'),
			'remove-format' => _('Remove format'),
			'justify-left' => _('Align left'),
			'justify-center' => _('Center'),
			'justify-right' => _('Align right'),
			'justify-fill' => _('Justify'),
			'numbering' => _('Numbering'),
			'bullets' => _('Bullets'),
			'unindent' => _('Unindent'),
			'indent' => _('Indent'));

		$toolbar = $this->_htmleditToolbar($actions);
		$this->renderElement($toolbar);
		//format
		$toolbar = $this->_htmleditToolbar($format);
		//size
		$toolbar->prepend($this->_htmleditSelector('fontsize', $sizes));
		//font
		$toolbar->prepend($this->_htmleditSelector('fontname', $fonts));
		//style
		$toolbar->prepend($this->_htmleditSelector('formatblock',
					$styles));
		$this->renderElement($toolbar);
		$this->renderTabs();
		$this->tagOpen('iframe', $class, FALSE, array(
				'width' => '100%', 'height' => '400px'));
		$this->tagClose('iframe');
	}

	private function _htmleditSelector($class, $values = array())
	{
		$combobox = new PageElement('combobox', array(
				'class' => $class));

		foreach($values as $v => $t)
			$combobox->append('label', array('value' => $v,
					'text' => $t));
		return $combobox;
	}

	private function _htmleditToolbar($actions = array())
	{
		$toolbar = new PageElement('toolbar', array(
				'class' => 'editor'));

		foreach($actions as $a => $t)
		{
			$button = new PageElement('button', array('class' => $a,
				'stock' => $a, 'tooltip' => $t));
			$toolbar->append($button);
		}
		return $toolbar;
	}


	protected function renderHtmlview(PageElement $e)
	{
		$filter_class = static::$filter_class;
		$class = $e->get('class');
		$class = $e->getType().(($class !== FALSE) ? ' '.$class : '');
		$text = $e->get('text');

		if(!is_string($text))
			return;
		$this->tagOpen('div', $class, $e->get('id'), FALSE);
		if($e->get('trusted') === TRUE)
			print($text);
		else
			print($filter_class::filter($this->engine, $text));
		$this->tagClose('div');
	}


	protected function renderIconview(PageElement $e)
	{
		$e->set('view', 'icons');
		if(($columns = $e->get('columns')) === FALSE)
		{
			$columns = array('icon' => 'Icon', 'label' => 'Label');
			$e->set('columns', $columns);
		}
		$this->renderTreeview($e);
	}


	protected function renderImage(PageElement $e)
	{
		$size = 48;
		$class = FALSE;
		$attributes = array('alt' => $e->get('text'));
		$standalone = $this->get('standalone');

		if(($title = $e->get('title')) !== FALSE)
			$attributes['title'] = $title;
		if(($stock = $e->get('stock')) !== FALSE)
		{
			if(($s = $e->get('size')) !== FALSE && is_numeric($s))
				$size = $s;
			$class = "stock$size $stock";
			//XXX to display the "alt" text only when relevant
			$attributes['src'] = 'icons/generic/'.$size.'x'.$size
				.'/stock.png';
			$filename = '../data/'.$attributes['src'];
			if($standalone && ($img = file_get_contents($filename))
					!== FALSE)
				//FIXME use the actual icon
				$attributes['src'] = 'data:image/png'
					.';base64,'.base64_encode($img);
			$attributes['width'] = 0;
			$attributes['height'] = 0;
		}
		else if(($r = $e->get('request')) !== FALSE)
			$attributes['src'] = $this->engine->getURL($r, FALSE);
		else
			$attributes['src'] = $e->get('source');
		$this->tag('img', $class, $e->get('id'), $attributes);
	}


	protected function renderInline(PageElement $e)
	{
		$text = $e->get('text');

		if($e->getType() !== FALSE)
		{
			$this->tagOpen('span', $e->getType(), $e->get('id'),
					FALSE, $text);
			$this->renderChildren($e);
			$this->tagClose('span');
		}
		else if($text !== FALSE)
			print($this->escapeText($text));
	}


	protected function renderLabel(PageElement $e)
	{
		$tag = 'span';
		$class = 'label';
		$attributes = array();

		if(($c = $e->get('class')) !== FALSE)
			//FIXME apply to the respective parent and children
			$class = 'label '.$c;
		if(($for = $e->get('for')) !== FALSE)
		{
			$tag = 'label';
			$attributes['for'] = $for;
		}
		$this->tagOpen($tag, $class, $e->get('id'), $attributes,
				$e->get('text'));
		$this->tagClose($tag);
		$this->renderChildren($e);
	}


	protected function renderLink(PageElement $e)
	{
		$standalone = $this->get('standalone');
		$url = FALSE;

		$attributes = array();
		if(($a = $e->get('name')) !== FALSE)
			$attributes['name'] = $a;
		if(($r = $e->get('request')) !== FALSE)
		{
			$url = $this->engine->getURL($r, $standalone);
			$attributes['href'] = $url;
		}
		else if(($url = $e->get('url')) !== FALSE)
			$attributes['href'] = $url;
		if(($title = $e->get('title')) !== FALSE)
			$attributes['title'] = $title;
		$this->tagOpen('a', FALSE, $e->get('id'), $attributes);
		if(($stock = $e->get('stock')) !== FALSE)
			$this->tag('img', 'stock16 '.$stock, FALSE,
					array('alt' => ''));
		if(($text = $e->get('text')) === FALSE)
			$text = $url;
		if($text !== FALSE)
			print($this->escapeText($text));
		$this->renderChildren($e);
		$this->tagClose('a');
	}


	protected function renderMenu(PageElement $e, $class = FALSE)
	{
		//FIXME really implement
		if(($children = $e->getChildren()) === FALSE
				|| count($children) == 0)
			return;
		$this->tagOpen('ul', $class);
		foreach($children as $c)
			if($c->getType() == 'menuitem')
				$this->renderMenuitem($c);
		$this->renderTabs(-1);
		$this->tagClose('ul');
	}


	protected function renderMenubar(PageElement $e)
	{
		$this->renderTabs();
		$this->renderMenu($e, 'menubar');
	}


	protected function renderMenuitem(PageElement $e)
	{
		$this->renderTabs();
		$this->tagOpen('li', 'menuitem');
		if(($text = $e->get('text')) !== FALSE)
		{
			$class = $e->get('class');
			$attributes = array();
			if(($a = $e->get('name')) !== FALSE)
				$attributes['name'] = $a;
			if($e->get('important') !== FALSE)
				$class = is_string($class) ? $class.' important'
					: 'important';
			if(($r = $e->get('request')) !== FALSE)
				$attributes['href'] = $this->engine->getURL($r,
						FALSE);
			else if(($u = $e->get('url')) !== FALSE)
				$attributes['href'] = $u;
			if(count($attributes))
				$this->tagOpen('a', $class, $e->get('id'),
						$attributes);
			print($this->escapeText($text));
			if(count($attributes))
				$this->tagClose('a');
		}
		$this->renderMenu($e);
		$this->tagClose('li');
	}


	protected function renderMeta($header, $value)
	{
		$this->renderTabs();
		$this->tag('meta', FALSE, FALSE, array('http-equiv' => $header,
					'content' => $value));
	}


	protected function renderMetaCharset($charset)
	{
		$this->renderMeta('Content-Type', 'text/html; charset='
				.$charset);
	}


	protected function renderPage(PageElement $e)
	{
		$this->renderChildren($e);
	}


	protected function renderProgress(PageElement $e)
	{
		//XXX render something nicer
		$this->renderInline($e);
	}


	protected function renderRadioButton(PageElement $e)
	{
		$args = array('type' => 'radio');
		$value = $e->get('value');

		if(($children = $e->getChildren()) === FALSE)
			return;
		if(($name = $e->get('name')) !== FALSE)
			$args['name'] = $name;
		foreach($children as $c)
		{
			$a = $args;
			$class = $c->get('class');
			$id = $c->get('id');
			if(($v = $c->get('value')) !== FALSE)
			{
				$a['value'] = $v;
				if($v == $value)
					$a['checked'] = 'checked';
			}
			$this->renderTabs();
			$this->tag('input', $class, $id, $a);
			$this->renderElement($c);
		}
	}


	protected function renderStatusbar(PageElement $e)
	{
		$class = 'statusbar';

		$this->renderTabs();
		if(($c = $e->get('class')) !== FALSE)
			$class .= ' '.$c;
		$this->tagOpen('div', $class, $e->get('id'), FALSE,
				$e->get('text'));
		$this->renderChildren($e);
		$this->tagClose('div');
	}


	protected function renderTabs($more = 0)
	{
		print("\n");
		for($i = 0; $i < count($this->tags) + $more; $i++)
			print("\t");
	}


	protected function renderTextview(PageElement $e)
	{
		$this->renderTabs();
		$this->tagOpen('div', $e->getType());
		if(($text = $e->get('text')) !== FALSE)
		{
			$l = new PageElement('label', array('text' => $text));
			$this->renderElement($l);
		}
		$value = $e->get('value');
		$args = array();
		if(($name = $e->get('name')) !== FALSE)
			$args['name'] = $name;
		//text has to be escaped without any tags
		$this->tagOpen('textarea', $e->get('class'), $e->get('id'),
				$args);
		if($value !== FALSE)
			print($this->escape($value));
		$this->tagClose('textarea');
		$this->tagClose('div');
	}


	protected function renderTitle(PageElement $e)
	{
		$hcnt = count($this->titles);
		$tcnt = count($this->tags);
		$level = 1;

		/* XXX this algorithm is a bit ugly but seems to work */
		if($hcnt == 0) /* no title set */
			$this->titles[$level - 1] = $tcnt;
		else if($this->titles[$hcnt - 1] < $tcnt) //deeper level
		{
			$this->titles[$hcnt] = $tcnt;
			$level = $hcnt;
		}
		else if($this->titles[$hcnt - 1] == $tcnt) //same level
			$level = $hcnt - 1;
		else
		{
			for(; $hcnt > 0; $hcnt = count($this->titles))
			{
				$h = $this->titles[$hcnt - 1];
				if($h <= $tcnt)
					break;
				unset($this->titles[$hcnt - 1]);
			}
			$level = $hcnt - 1;
		}
		$tag = "h$level";
		if(($class = $e->get('class')) === FALSE)
			$class = '';
		if(($stock = $e->get('stock')) !== FALSE)
			switch($level)
			{
				case 1: $class = "stock48 $stock $class"; break;
				case 2: $class = "stock32 $stock $class"; break;
				case 3: $class = "stock24 $stock $class"; break;
				case 4:
				default:$class = "stock16 $stock $class"; break;
			}
		$class = rtrim($class);
		$this->renderTabs();
		$this->tagOpen($tag, $class, $e->get('id'), FALSE,
				$e->get('text'));
		$this->renderChildren($e);
		$this->tagClose($tag);
	}


	protected function renderToolbar(PageElement $e)
	{
		return $this->renderBlock($e);
	}


	protected function renderTreeview(PageElement $e)
	{
		$auth = $this->engine->getAuth();

		switch(($view = $e->get('view')))
		{
			case 'details':
			case 'preview':
				break;
			case 'icons':
			case 'list':
				if(($c = $e->get('columns')) !== FALSE)
					break;
				$c = array('icon' => '', 'label' => '');
				$e->set('columns', $c);
				break;
			case 'thumbnails':
				if(($c = $e->get('columns')) !== FALSE)
					break;
				$c = array('thumbnail' => '', 'label' => '');
				$e->set('columns', $c);
				break;
			default:
				$view = 'details';
				break;
		}
		$r = $e->get('request');
		$tag = ($r !== FALSE) ? 'form' : 'div';
		$class = "treeview $view";
		if($e->get('alternate'))
			$class .= ' alternate';
		if(($c = $e->get('class')) !== FALSE && strlen($c))
			$class .= " $c";
		$args = FALSE;
		if($r !== FALSE)
		{
			$method = $e->get('idempotent') ? 'get' : 'post';
			$args = array('action' => 'index.php',
				'method' => $method);
		}
		$this->renderTabs();
		$this->tagOpen($tag, $class, $e->get('id'), $args);
		if($r !== FALSE && $method === 'post')
		{
			$token = sha1(uniqid(php_uname(), TRUE));
			if(($tokens = $auth->getVariable($this->engine,
						'tokens')) === FALSE)
				$tokens = array();
			$tokens[$token] = time() + 3600;
			$auth->setVariable($this->engine, 'tokens', $tokens);
			$this->_renderTreeviewHidden('_token', $token);
		}
		if($r !== FALSE)
		{
			//FIXME copied from renderForm()
			$this->_renderTreeviewHidden('_module', $r->getModule());
			$this->_renderTreeviewHidden('_action', $r->getAction());
			$this->_renderTreeviewHidden('_id', $r->getID());
			$this->_renderTreeviewHidden('_title', $r->getTitle());
			if(($parameters = $r->getParameters()) !== FALSE)
				foreach($r->getParameters() as $k => $v)
					$this->_renderTreeviewHidden($k, $v);
		}
		$this->_renderTreeviewToolbar($e);
		$columns = $e->get('columns');
		if(!is_array($columns) || count($columns) == 0)
			$columns = array('title' => 'Title');
		$this->renderTabs();
		$this->tagOpen('div', 'table');
		$this->_renderTreeviewHeaders($e, $columns);
		//render rows
		$this->_renderTreeviewRows($e, $columns);
		$this->renderTabs(-1);
		$this->tagClose('div');
		$this->renderTabs(-1);
		//render the (optional) controls
		$this->_renderTreeviewControls($e);
		$this->tagClose($tag);
	}

	private function _renderTreeviewControls(PageElement $e)
	{
		if(($children = $e->getChildren()) === FALSE)
			return;
		foreach($children as $c)
			switch($c->getType())
			{
				case 'row':
				case 'toolbar':
					break;
				default:
					$this->renderElement($c);
					break;
			}
	}

	private function _renderTreeviewHeaders(PageElement $e, $columns)
	{
		$this->renderTabs();
		$this->tagOpen('div', 'header');
		if($e->get('request') !== FALSE)
			$this->tag('span', 'detail', FALSE, FALSE, '');
		foreach($columns as $c => $v)
			$this->tag('span', "detail $c", FALSE, FALSE, $v);
		$this->tagClose('div');
	}

	private function _renderTreeviewHidden($name, $value = FALSE)
	{
		//FIXME copied from _formHidden()
		if($value === FALSE)
			return;
		$this->renderTabs();
		$this->tag('input', FALSE, FALSE, array('type' => 'hidden',
					'name' => $name, 'value' => $value));
	}

	private function _renderTreeviewRows(PageElement $e, $columns)
	{
		$id = 1;

		$this->_renderTreeviewRowsDo($e, $columns, $id);
	}

	private function _renderTreeviewRowsDo(PageElement $e, $columns, &$id,
			$level = 0)
	{
		$class = 'row';
		$request = $e->get('request');

		if(($children = $e->getChildren()) === FALSE)
			return;
		if($level > 0)
			$class .= ' level level'.$level;
		foreach($children as $c)
		{
			$this->renderTabs();
			if($c->getType() != 'row')
				continue;
			$cl = $class;
			if(($p = $c->get('class')) !== FALSE)
				$cl .= ' '.$p;
			$this->tagOpen('div', $cl);
			if($request !== FALSE)
			{
				$this->tagOpen('span', 'detail');
				$name = $c->get('id');
				$args = array('type' => 'checkbox',
					'name' => $name);
				if($c->get('value'))
					$args['checked'] = 'checked';
				$this->tag('input', FALSE, '_check_'.$id,
						$args);
				$this->tagClose('span');
			}
			foreach($columns as $k => $v)
			{
				if(($v = $c->get($k)) === FALSE)
					$v = '';
				$this->tagOpen('span', "detail $k");
				if($v instanceof PageElement)
					$this->renderElement($v);
				else if(is_scalar($v))
					$this->tag('label', FALSE, FALSE,
							array('for' => '_check_'
								.$id), $v);
				$this->tagClose('span');
			}
			$this->tagClose('div');
			$id++;
			$this->_renderTreeviewRowsDo($c, $columns, $id,
					$level + 1);
		}
	}

	private function _renderTreeviewToolbar(PageElement $e)
	{
		if(($children = $e->getChildren()) === FALSE)
			return;
		foreach($children as $c)
			if($c->getType() == 'toolbar')
				$this->renderToolbar($c);
	}


	protected function renderVbox(PageElement $e)
	{
		$this->renderBox($e, $e->getType());
	}


	//tagging
	protected function tag($name, $class = FALSE, $id = FALSE,
			$attributes = FALSE, $content = FALSE)
	{
		$tag = '<'.$this->escapeAttribute($name);

		if($class !== FALSE)
			$tag .= ' class="'.$this->escapeAttribute($class).'"';
		if($id !== FALSE)
		{
			if(isset($ids[$id]))
				$this->engine->log(LOG_DEBUG, 'HTML ID '.$id
						.' is already defined');
			$ids[$id] = TRUE;
			$tag .= ' id="'.$this->escapeAttribute($id).'"';
		}
		if(is_array($attributes))
			foreach($attributes as $k => $v)
				$tag .= ' '.$this->escapeAttribute($k).'="'
					.$this->escapeAttribute($v).'"';
		if($content !== FALSE)
			$tag .= '>'.$this->escapeText($content)
				.'escapeAttribute($name).'>';
		else
			$tag .= '/>';
		print($tag);
	}


	protected function tagClose($name)
	{
		print('escapeAttribute($name).'>');
		if(array_pop($this->tags) != $name)
			$this->engine->log(LOG_DEBUG, 'Invalid tag sequence');
	}


	protected function tagOpen($name, $class = FALSE, $id = FALSE,
			$attributes = FALSE, $content = FALSE)
	{
		array_push($this->tags, $name);
		//FIXME automatically output tabs
		$tag = '<'.$this->escapeAttribute($name);
		if($class !== FALSE && strlen($class) > 0)
			$tag .= ' class="'.$this->escapeAttribute($class).'"';
		if($id !== FALSE)
		{
			if(isset($ids[$id]))
				$this->engine->log(LOG_DEBUG, 'HTML ID '.$id
						.' is already defined');
			$ids[$id] = TRUE;
			$tag .= ' id="'.$this->escapeAttribute($id).'"';
		}
		if(is_array($attributes))
			foreach($attributes as $k => $v)
				$tag .= ' '.$this->escapeAttribute($k).'="'
					.$this->escapeAttribute($v).'"';
		$tag.='>';
		print($tag);
		if($content !== FALSE)
			print($this->escapeText($content));
	}


	//private
	//properties
	private $engine = FALSE;
	private $ids;
	private $javascript = FALSE;
	private $tags;
	private $titles;
}

?>