1: <?php
  2: /**
  3:  * Magento
  4:  *
  5:  * NOTICE OF LICENSE
  6:  *
  7:  * This source file is subject to the Open Software License (OSL 3.0)
  8:  * that is bundled with this package in the file LICENSE.txt.
  9:  * It is also available through the world-wide-web at this URL:
 10:  * http://opensource.org/licenses/osl-3.0.php
 11:  * If you did not receive a copy of the license and are unable to
 12:  * obtain it through the world-wide-web, please send an email
 13:  * to license@magentocommerce.com so we can send you a copy immediately.
 14:  *
 15:  * DISCLAIMER
 16:  *
 17:  * Do not edit or add to this file if you wish to upgrade Magento to newer
 18:  * versions in the future. If you wish to customize Magento for your
 19:  * needs please refer to http://www.magentocommerce.com for more information.
 20:  *
 21:  * @category    Mage
 22:  * @package     Mage_Core
 23:  * @copyright   Copyright (c) 2012 Magento Inc. (http://www.magentocommerce.com)
 24:  * @license     http://opensource.org/licenses/osl-3.0.php  Open Software License (OSL 3.0)
 25:  */
 26: 
 27: 
 28: /**
 29:  * Layout model
 30:  *
 31:  * @category   Mage
 32:  * @package    Mage_Core
 33:  */
 34: class Mage_Core_Model_Layout extends Varien_Simplexml_Config
 35: {
 36: 
 37:     /**
 38:      * Layout Update module
 39:      *
 40:      * @var Mage_Core_Model_Layout_Update
 41:      */
 42:     protected $_update;
 43: 
 44:     /**
 45:      * Blocks registry
 46:      *
 47:      * @var array
 48:      */
 49:     protected $_blocks = array();
 50: 
 51:     /**
 52:      * Cache of block callbacks to output during rendering
 53:      *
 54:      * @var array
 55:      */
 56:     protected $_output = array();
 57: 
 58:     /**
 59:      * Layout area (f.e. admin, frontend)
 60:      *
 61:      * @var string
 62:      */
 63:     protected $_area;
 64: 
 65:     /**
 66:      * Helper blocks cache for this layout
 67:      *
 68:      * @var array
 69:      */
 70:     protected $_helpers = array();
 71: 
 72:     /**
 73:      * Flag to have blocks' output go directly to browser as oppose to return result
 74:      *
 75:      * @var boolean
 76:      */
 77:     protected $_directOutput = false;
 78: 
 79:     /**
 80:      * Class constructor
 81:      *
 82:      * @param array $data
 83:      */
 84:     public function __construct($data=array())
 85:     {
 86:         $this->_elementClass = Mage::getConfig()->getModelClassName('core/layout_element');
 87:         $this->setXml(simplexml_load_string('<layout/>', $this->_elementClass));
 88:         $this->_update = Mage::getModel('core/layout_update');
 89:         parent::__construct($data);
 90:     }
 91: 
 92:     /**
 93:      * Layout update instance
 94:      *
 95:      * @return Mage_Core_Model_Layout_Update
 96:      */
 97:     public function getUpdate()
 98:     {
 99:         return $this->_update;
100:     }
101: 
102:     /**
103:      * Set layout area
104:      *
105:      * @param   string $area
106:      * @return  Mage_Core_Model_Layout
107:      */
108:     public function setArea($area)
109:     {
110:         $this->_area = $area;
111:         return $this;
112:     }
113: 
114:     /**
115:      * Retrieve layout area
116:      *
117:      * @return string
118:      */
119:     public function getArea()
120:     {
121:         return $this->_area;
122:     }
123: 
124:     /**
125:      * Declaring layout direct output flag
126:      *
127:      * @param   bool $flag
128:      * @return  Mage_Core_Model_Layout
129:      */
130:     public function setDirectOutput($flag)
131:     {
132:         $this->_directOutput = $flag;
133:         return $this;
134:     }
135: 
136:     /**
137:      * Retrieve derect output flag
138:      *
139:      * @return bool
140:      */
141:     public function getDirectOutput()
142:     {
143:         return $this->_directOutput;
144:     }
145: 
146:     /**
147:      * Loyout xml generation
148:      *
149:      * @return Mage_Core_Model_Layout
150:      */
151:     public function generateXml()
152:     {
153:         $xml = $this->getUpdate()->asSimplexml();
154:         $removeInstructions = $xml->xpath("//remove");
155:         if (is_array($removeInstructions)) {
156:             foreach ($removeInstructions as $infoNode) {
157:                 $attributes = $infoNode->attributes();
158:                 $blockName = (string)$attributes->name;
159:                 if ($blockName) {
160:                     $ignoreNodes = $xml->xpath("//block[@name='".$blockName."']");
161:                     if (!is_array($ignoreNodes)) {
162:                         continue;
163:                     }
164:                     $ignoreReferences = $xml->xpath("//reference[@name='".$blockName."']");
165:                     if (is_array($ignoreReferences)) {
166:                         $ignoreNodes = array_merge($ignoreNodes, $ignoreReferences);
167:                     }
168: 
169:                     foreach ($ignoreNodes as $block) {
170:                         if ($block->getAttribute('ignore') !== null) {
171:                             continue;
172:                         }
173:                         $acl = (string)$attributes->acl;
174:                         if ($acl && Mage::getSingleton('admin/session')->isAllowed($acl)) {
175:                             continue;
176:                         }
177:                         if (!isset($block->attributes()->ignore)) {
178:                             $block->addAttribute('ignore', true);
179:                         }
180:                     }
181:                 }
182:             }
183:         }
184:         $this->setXml($xml);
185:         return $this;
186:     }
187: 
188:     /**
189:      * Create layout blocks hierarchy from layout xml configuration
190:      *
191:      * @param Mage_Core_Layout_Element|null $parent
192:      */
193:     public function generateBlocks($parent=null)
194:     {
195:         if (empty($parent)) {
196:             $parent = $this->getNode();
197:         }
198:         foreach ($parent as $node) {
199:             $attributes = $node->attributes();
200:             if ((bool)$attributes->ignore) {
201:                 continue;
202:             }
203:             switch ($node->getName()) {
204:                 case 'block':
205:                     $this->_generateBlock($node, $parent);
206:                     $this->generateBlocks($node);
207:                     break;
208: 
209:                 case 'reference':
210:                     $this->generateBlocks($node);
211:                     break;
212: 
213:                 case 'action':
214:                     $this->_generateAction($node, $parent);
215:                     break;
216:             }
217:         }
218:     }
219: 
220:     /**
221:      * Add block object to layout based on xml node data
222:      *
223:      * @param Varien_Simplexml_Element $node
224:      * @param Varien_Simplexml_Element $parent
225:      * @return Mage_Core_Model_Layout
226:      */
227:     protected function _generateBlock($node, $parent)
228:     {
229:         if (!empty($node['class'])) {
230:             $className = (string)$node['class'];
231:         } else {
232:             $className = (string)$node['type'];
233:         }
234: 
235:         $blockName = (string)$node['name'];
236:         $_profilerKey = 'BLOCK: '.$blockName;
237:         Varien_Profiler::start($_profilerKey);
238: 
239:         $block = $this->addBlock($className, $blockName);
240:         if (!$block) {
241:             return $this;
242:         }
243: 
244:         if (!empty($node['parent'])) {
245:             $parentBlock = $this->getBlock((string)$node['parent']);
246:         } else {
247:             $parentName = $parent->getBlockName();
248:             if (!empty($parentName)) {
249:                 $parentBlock = $this->getBlock($parentName);
250:             }
251:         }
252:         if (!empty($parentBlock)) {
253:             $alias = isset($node['as']) ? (string)$node['as'] : '';
254:             if (isset($node['before'])) {
255:                 $sibling = (string)$node['before'];
256:                 if ('-'===$sibling) {
257:                     $sibling = '';
258:                 }
259:                 $parentBlock->insert($block, $sibling, false, $alias);
260:             } elseif (isset($node['after'])) {
261:                 $sibling = (string)$node['after'];
262:                 if ('-'===$sibling) {
263:                     $sibling = '';
264:                 }
265:                 $parentBlock->insert($block, $sibling, true, $alias);
266:             } else {
267:                 $parentBlock->append($block, $alias);
268:             }
269:         }
270:         if (!empty($node['template'])) {
271:             $block->setTemplate((string)$node['template']);
272:         }
273: 
274:         if (!empty($node['output'])) {
275:             $method = (string)$node['output'];
276:             $this->addOutputBlock($blockName, $method);
277:         }
278:         Varien_Profiler::stop($_profilerKey);
279: 
280:         return $this;
281:     }
282: 
283:     /**
284:      * Enter description here...
285:      *
286:      * @param Varien_Simplexml_Element $node
287:      * @param Varien_Simplexml_Element $parent
288:      * @return Mage_Core_Model_Layout
289:      */
290:     protected function _generateAction($node, $parent)
291:     {
292:         if (isset($node['ifconfig']) && ($configPath = (string)$node['ifconfig'])) {
293:             if (!Mage::getStoreConfigFlag($configPath)) {
294:                 return $this;
295:             }
296:         }
297: 
298:         $method = (string)$node['method'];
299:         if (!empty($node['block'])) {
300:             $parentName = (string)$node['block'];
301:         } else {
302:             $parentName = $parent->getBlockName();
303:         }
304: 
305:         $_profilerKey = 'BLOCK ACTION: '.$parentName.' -> '.$method;
306:         Varien_Profiler::start($_profilerKey);
307: 
308:         if (!empty($parentName)) {
309:             $block = $this->getBlock($parentName);
310:         }
311:         if (!empty($block)) {
312: 
313:             $args = (array)$node->children();
314:             unset($args['@attributes']);
315: 
316:             foreach ($args as $key => $arg) {
317:                 if (($arg instanceof Mage_Core_Model_Layout_Element)) {
318:                     if (isset($arg['helper'])) {
319:                         $helperName = explode('/', (string)$arg['helper']);
320:                         $helperMethod = array_pop($helperName);
321:                         $helperName = implode('/', $helperName);
322:                         $arg = $arg->asArray();
323:                         unset($arg['@']);
324:                         $args[$key] = call_user_func_array(array(Mage::helper($helperName), $helperMethod), $arg);
325:                     } else {
326:                         /**
327:                          * if there is no helper we hope that this is assoc array
328:                          */
329:                         $arr = array();
330:                         foreach($arg as $subkey => $value) {
331:                             $arr[(string)$subkey] = $value->asArray();
332:                         }
333:                         if (!empty($arr)) {
334:                             $args[$key] = $arr;
335:                         }
336:                     }
337:                 }
338:             }
339: 
340:             if (isset($node['json'])) {
341:                 $json = explode(' ', (string)$node['json']);
342:                 foreach ($json as $arg) {
343:                     $args[$arg] = Mage::helper('core')->jsonDecode($args[$arg]);
344:                 }
345:             }
346: 
347:             $this->_translateLayoutNode($node, $args);
348:             call_user_func_array(array($block, $method), $args);
349:         }
350: 
351:         Varien_Profiler::stop($_profilerKey);
352: 
353:         return $this;
354:     }
355: 
356:     /**
357:      * Translate layout node
358:      *
359:      * @param Varien_Simplexml_Element $node
360:      * @param array $args
361:      **/
362:     protected function _translateLayoutNode($node, &$args)
363:     {
364:         if (isset($node['translate'])) {
365:             // Translate value by core module if module attribute was not set
366:             $moduleName = (isset($node['module'])) ? (string)$node['module'] : 'core';
367: 
368:             // Handle translations in arrays if needed
369:             $translatableArguments = explode(' ', (string)$node['translate']);
370:             foreach ($translatableArguments as $translatableArgumentName) {
371:                 /*
372:                  * .(dot) character is used as a path separator in nodes hierarchy
373:                  * e.g. info.title means that Magento needs to translate value of <title> node
374:                  * that is a child of <info> node
375:                  */
376:                 // @var $argumentHierarhy array - path to translatable item in $args array
377:                 $argumentHierarchy = explode('.', $translatableArgumentName);
378:                 $argumentStack = &$args;
379:                 $canTranslate = true;
380:                 while (is_array($argumentStack) && count($argumentStack) > 0) {
381:                     $argumentName = array_shift($argumentHierarchy);
382:                     if (isset($argumentStack[$argumentName])) {
383:                         /*
384:                          * Move to the next element in arguments hieracrhy
385:                          * in order to find target translatable argument
386:                          */
387:                         $argumentStack = &$argumentStack[$argumentName];
388:                     } else {
389:                         // Target argument cannot be found
390:                         $canTranslate = false;
391:                         break;
392:                     }
393:                 }
394:                 if ($canTranslate && is_string($argumentStack)) {
395:                     // $argumentStack is now a reference to target translatable argument so it can be translated
396:                     $argumentStack = Mage::helper($moduleName)->__($argumentStack);
397:                 }
398:             }
399:         }
400:     }
401: 
402:     /**
403:      * Save block in blocks registry
404:      *
405:      * @param string $name
406:      * @param Mage_Core_Model_Layout $block
407:      */
408:     public function setBlock($name, $block)
409:     {
410:         $this->_blocks[$name] = $block;
411:         return $this;
412:     }
413: 
414:     /**
415:      * Remove block from registry
416:      *
417:      * @param string $name
418:      */
419:     public function unsetBlock($name)
420:     {
421:         $this->_blocks[$name] = null;
422:         unset($this->_blocks[$name]);
423:         return $this;
424:     }
425: 
426:     /**
427:      * Block Factory
428:      *
429:      * @param     string $type
430:      * @param     string $name
431:      * @param     array $attributes
432:      * @return    Mage_Core_Block_Abstract
433:      */
434:     public function createBlock($type, $name='', array $attributes = array())
435:     {
436:         try {
437:             $block = $this->_getBlockInstance($type, $attributes);
438:         } catch (Exception $e) {
439:             Mage::logException($e);
440:             return false;
441:         }
442: 
443:         if (empty($name) || '.'===$name{0}) {
444:             $block->setIsAnonymous(true);
445:             if (!empty($name)) {
446:                 $block->setAnonSuffix(substr($name, 1));
447:             }
448:             $name = 'ANONYMOUS_'.sizeof($this->_blocks);
449:         } elseif (isset($this->_blocks[$name]) && Mage::getIsDeveloperMode()) {
450:             //Mage::throwException(Mage::helper('core')->__('Block with name "%s" already exists', $name));
451:         }
452: 
453:         $block->setType($type);
454:         $block->setNameInLayout($name);
455:         $block->addData($attributes);
456:         $block->setLayout($this);
457: 
458:         $this->_blocks[$name] = $block;
459:         Mage::dispatchEvent('core_layout_block_create_after', array('block'=>$block));
460:         return $this->_blocks[$name];
461:     }
462: 
463:     /**
464:      * Add a block to registry, create new object if needed
465:      *
466:      * @param string|Mage_Core_Block_Abstract $blockClass
467:      * @param string $blockName
468:      * @return Mage_Core_Block_Abstract
469:      */
470:     public function addBlock($block, $blockName)
471:     {
472:         return $this->createBlock($block, $blockName);
473:     }
474: 
475:     /**
476:      * Create block object instance based on block type
477:      *
478:      * @param string $block
479:      * @param array $attributes
480:      * @return Mage_Core_Block_Abstract
481:      */
482:     protected function _getBlockInstance($block, array $attributes=array())
483:     {
484:         if (is_string($block)) {
485:             if (strpos($block, '/')!==false) {
486:                 if (!$block = Mage::getConfig()->getBlockClassName($block)) {
487:                     Mage::throwException(Mage::helper('core')->__('Invalid block type: %s', $block));
488:                 }
489:             }
490:             if (class_exists($block, false) || mageFindClassFile($block)) {
491:                 $block = new $block($attributes);
492:             }
493:         }
494:         if (!$block instanceof Mage_Core_Block_Abstract) {
495:             Mage::throwException(Mage::helper('core')->__('Invalid block type: %s', $block));
496:         }
497:         return $block;
498:     }
499: 
500: 
501:     /**
502:      * Retrieve all blocks from registry as array
503:      *
504:      * @return array
505:      */
506:     public function getAllBlocks()
507:     {
508:         return $this->_blocks;
509:     }
510: 
511:     /**
512:      * Get block object by name
513:      *
514:      * @param string $name
515:      * @return Mage_Core_Block_Abstract
516:      */
517:     public function getBlock($name)
518:     {
519:         if (isset($this->_blocks[$name])) {
520:             return $this->_blocks[$name];
521:         } else {
522:             return false;
523:         }
524:     }
525: 
526:     /**
527:      * Add a block to output
528:      *
529:      * @param string $blockName
530:      * @param string $method
531:      */
532:     public function addOutputBlock($blockName, $method='toHtml')
533:     {
534:         //$this->_output[] = array($blockName, $method);
535:         $this->_output[$blockName] = array($blockName, $method);
536:         return $this;
537:     }
538: 
539:     public function removeOutputBlock($blockName)
540:     {
541:         unset($this->_output[$blockName]);
542:         return $this;
543:     }
544: 
545:     /**
546:      * Get all blocks marked for output
547:      *
548:      * @return string
549:      */
550:     public function getOutput()
551:     {
552:         $out = '';
553:         if (!empty($this->_output)) {
554:             foreach ($this->_output as $callback) {
555:                 $out .= $this->getBlock($callback[0])->$callback[1]();
556:             }
557:         }
558: 
559:         return $out;
560:     }
561: 
562:     /**
563:      * Retrieve messages block
564:      *
565:      * @return Mage_Core_Block_Messages
566:      */
567:     public function getMessagesBlock()
568:     {
569:         $block = $this->getBlock('messages');
570:         if ($block) {
571:             return $block;
572:         }
573:         return $this->createBlock('core/messages', 'messages');
574:     }
575: 
576:     /**
577:      * Enter description here...
578:      *
579:      * @param string $type
580:      * @return Mage_Core_Helper_Abstract
581:      */
582:     public function getBlockSingleton($type)
583:     {
584:         if (!isset($this->_helpers[$type])) {
585:             $className = Mage::getConfig()->getBlockClassName($type);
586:             if (!$className) {
587:                 Mage::throwException(Mage::helper('core')->__('Invalid block type: %s', $type));
588:             }
589: 
590:             $helper = new $className();
591:             if ($helper) {
592:                 if ($helper instanceof Mage_Core_Block_Abstract) {
593:                     $helper->setLayout($this);
594:                 }
595:                 $this->_helpers[$type] = $helper;
596:             }
597:         }
598:         return $this->_helpers[$type];
599:     }
600: 
601:     /**
602:      * Retrieve helper object
603:      *
604:      * @param   string $name
605:      * @return  Mage_Core_Helper_Abstract
606:      */
607:     public function helper($name)
608:     {
609:         $helper = Mage::helper($name);
610:         if (!$helper) {
611:             return false;
612:         }
613:         return $helper->setLayout($this);
614:     }
615: 
616:     /**
617:      * Lookup module name for translation from current specified layout node
618:      *
619:      * Priorities:
620:      * 1) "module" attribute in the element
621:      * 2) "module" attribute in any ancestor element
622:      * 3) layout handle name - first 1 or 2 parts (namespace is determined automatically)
623:      *
624:      * @param Varien_Simplexml_Element $node
625:      * @return string
626:      */
627:     public static function findTranslationModuleName(Varien_Simplexml_Element $node)
628:     {
629:         $result = $node->getAttribute('module');
630:         if ($result) {
631:             return (string)$result;
632:         }
633:         foreach (array_reverse($node->xpath('ancestor::*[@module]')) as $element) {
634:             $result = $element->getAttribute('module');
635:             if ($result) {
636:                 return (string)$result;
637:             }
638:         }
639:         foreach ($node->xpath('ancestor-or-self::*[last()-1]') as $handle) {
640:             $name = Mage::getConfig()->determineOmittedNamespace($handle->getName());
641:             if ($name) {
642:                 return $name;
643:             }
644:         }
645:         return 'core';
646:     }
647: }
648: