Subversion Repositories SmartDukaan

<?php

/**

 *

 *

 * CakePHP(tm) : Rapid Development Framework (http://cakephp.org)

 * Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)

 *

 * Licensed under The MIT License

 * For full copyright and license information, please see the LICENSE.txt

 * Redistributions of files must retain the above copyright notice.

 *

 * @copyright     Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)

 * @link          http://cakephp.org CakePHP(tm) Project

 * @since         CakePHP(tm) v2.1

 * @license       http://www.opensource.org/licenses/mit-license.php MIT License

 */

/**

 * ViewBlock implements the concept of Blocks or Slots in the View layer.

 * Slots or blocks are combined with extending views and layouts to afford slots

 * of content that are present in a layout or parent view, but are defined by the child

 * view or elements used in the view.

 *

 * @package Cake.View

 */

class ViewBlock {

/**

 * Append content

 *

 * @constant APPEND

 */

	const APPEND = 'append';

/**

 * Prepend content

 *

 * @constant PREPEND

 */

	const PREPEND = 'prepend';

/**

 * Block content. An array of blocks indexed by name.

 *

 * @var array

 */

	protected $_blocks = array();

/**

 * The active blocks being captured.

 *

 * @var array

 */

	protected $_active = array();

/**

 * Should the currently captured content be discarded on ViewBlock::end()

 *

 * @var boolean

 * @see ViewBlock::end()

 * @see ViewBlock::startIfEmpty()

 */

	protected $_discardActiveBufferOnEnd = false;

/**

 * Start capturing output for a 'block'

 *

 * Blocks allow you to create slots or blocks of dynamic content in the layout.

 * view files can implement some or all of a layout's slots.

 *

 * You can end capturing blocks using View::end(). Blocks can be output

 * using View::get();

 *

 * @param string $name The name of the block to capture for.

 * @throws CakeException When starting a block twice

 * @return void

 */

	public function start($name) {

		if (in_array($name, $this->_active)) {

			throw new CakeException(__("A view block with the name '%s' is already/still open.", $name));

		}

		$this->_active[] = $name;

		ob_start();

	}

/**

 * Start capturing output for a 'block' if it is empty

 *

 * Blocks allow you to create slots or blocks of dynamic content in the layout.

 * view files can implement some or all of a layout's slots.

 *

 * You can end capturing blocks using View::end(). Blocks can be output

 * using View::get();

 *

 * @param string $name The name of the block to capture for.

 * @return void

 */

	public function startIfEmpty($name) {

		if (empty($this->_blocks[$name])) {

			return $this->start($name);

		}

		$this->_discardActiveBufferOnEnd = true;

		ob_start();

	}

/**

 * End a capturing block. The compliment to ViewBlock::start()

 *

 * @return void

 * @see ViewBlock::start()

 */

	public function end() {

		if ($this->_discardActiveBufferOnEnd) {

			$this->_discardActiveBufferOnEnd = false;

			ob_end_clean();

			return;

		}

		if (!empty($this->_active)) {

			$active = end($this->_active);

			$content = ob_get_clean();

			if (!isset($this->_blocks[$active])) {

				$this->_blocks[$active] = '';

			}

			$this->_blocks[$active] .= $content;

			array_pop($this->_active);

		}

	}

/**

 * Concat content to an existing or new block.

 * Concating to a new block will create the block.

 *

 * Calling concat() without a value will create a new capturing

 * block that needs to be finished with View::end(). The content

 * of the new capturing context will be added to the existing block context.

 *

 * @param string $name Name of the block

 * @param mixed $value The content for the block

 * @param string $mode If ViewBlock::APPEND content will be appended to existing content.

 *   If ViewBlock::PREPEND it will be prepended.

 * @return void

 */

	public function concat($name, $value = null, $mode = ViewBlock::APPEND) {

		if (isset($value)) {

			if (!isset($this->_blocks[$name])) {

				$this->_blocks[$name] = '';

			}

			if ($mode === ViewBlock::PREPEND) {

				$this->_blocks[$name] = $value . $this->_blocks[$name];

			} else {

				$this->_blocks[$name] .= $value;

			}

		} else {

			$this->start($name);

		}

	}

/**

 * Append to an existing or new block. Appending to a new

 * block will create the block.

 *

 * Calling append() without a value will create a new capturing

 * block that needs to be finished with View::end(). The content

 * of the new capturing context will be added to the existing block context.

 *

 * @param string $name Name of the block

 * @param string $value The content for the block.

 * @return void

 * @deprecated As of 2.3 use ViewBlock::concat() instead.

 */

	public function append($name, $value = null) {

		$this->concat($name, $value);

	}

/**

 * Set the content for a block. This will overwrite any

 * existing content.

 *

 * @param string $name Name of the block

 * @param mixed $value The content for the block.

 * @return void

 */

	public function set($name, $value) {

		$this->_blocks[$name] = (string)$value;

	}

/**

 * Get the content for a block.

 *

 * @param string $name Name of the block

 * @param string $default Default string

 * @return string The block content or $default if the block does not exist.

 */

	public function get($name, $default = '') {

		if (!isset($this->_blocks[$name])) {

			return $default;

		}

		return $this->_blocks[$name];

	}

/**

 * Get the names of all the existing blocks.

 *

 * @return array An array containing the blocks.

 */

	public function keys() {

		return array_keys($this->_blocks);

	}

/**

 * Get the name of the currently open block.

 *

 * @return mixed Either null or the name of the last open block.

 */

	public function active() {

		return end($this->_active);

	}

/**

 * Get the names of the unclosed/active blocks.

 *

 * @return array An array of unclosed blocks.

 */

	public function unclosed() {

		return $this->_active;

	}

}