Question

Can someone please explain this?

Let me tell you what i know. If the first three points are good, please explain the 4 point.

1. Request come to controller.
2. In Controller Action we initiate Models.
3. Models collects or generates all the information needed by connecting to database etc.

What happens after that?

1. How do models transfer data to Blocks, or do Blocks get data from models?

2. Templates get the prepared data and show on the screen

   • Also, does the request ever goes back to controller again?

Please explain. I’m confused at several places.

Answer 1

Nothing transfers data to the blocks. After a controller action has done its model interacting, it’s responsible for

1. Loading a layout object (which, indirectly, loads and creates block objects)

2. Tell that layout object to render a page.

Most Magento controller actions do this with two calls at the end of a controller action.

$this->loadLayout();
$this->renderLayout();

In Magento, nothing sets data on the view. Instead, the view (that is, the block objects) ask the system for data. You can see an example of this in the Mage_Tag_Block_Customer_View block class.

#File: app/code/core/Mage/Tag/Block/Customer/View.php    
...
public function getTagInfo()
{
    if (is_null($this->_tagInfo)) {
        $this->_tagInfo = Mage::getModel('tag/tag')
            ->load($this->getTagId());
    }
    return $this->_tagInfo;
}    
...

Here, this block’s getTagInfo method asks the model directly for its information. This way, the front-end template developer has access to a

$this->getTagInfo();

method. I also have it on good authority that a block’s _prepareLayout method is the perfect place to put most, if not all, of your data fetching code in a block.

A second pattern you’ll see used is the Magento registry pattern. This is a Magento system that lets you set a system-wide (but not PHP) global variable.

Mage::register('foo', 'some value');
echo Mage::registry('foo');

Sometimes a Magento developer will use the registry to set a variable up in a controller action, and then grab is back out in the blocks. For example, in the admin console’s invoice controller.

#File: app/code/core/Mage/Adminhtml/controllers/Sales/Order/InvoiceController.php
protected function _initInvoice()
{
    ...
    $invoice = Mage::register('current_invoice', $invoice);
    return $invoice;
}    

and then a Block will reference it later.

#File: app/code/core/Mage/Sales/Block/Order/Print/Invoice.php
public function getInvoice()
{
    return Mage::registry('current_invoice');
}

I’m not wild about the registry pattern, but it’s used by the core team, so it’s probably kosher.

Finally, if you’re looking to emulate the “dumb view” pattern used in most PHP MVC frameworks, try something like this

$this->loadLayout();
$block = $this->getLayout()->getBlock('block_name');
$block->setSomeData('My Data');
$block->setData('alternate_syntax', 'Some other data');
$this->renderLayout();

and then in the block and/or template file.

echo $this->getSomeData();
echo $this->getData('some_data');

echo $this->getAlternateSyntax();
echo $this->getData('alternate_syntax');

After you call loadLayout, Magento will have created all the block objects. What you’re doing above is getting reference to a specific block object, and then setting its data.

Per Vinai’s comments below, there’s also a block’s assign method to consider.

Similar to setData, after calling loadLayout (or from a block’s _prepareLayout) method, you can do something like

$this->loadLayout();
$block = $this->getLayout()->getBlock('block_name');
$block->assign('my_view_var','Something for the view');
$this->renderLayout();

and then in your block’s phtml file, you’d be able to output that view variable

echo $my_view_var;