The view script is used in conjunction with a layout, which we will not discuss here. The only thing we will mention here is that the layout script contains the following code in the head section:

// jQuery
echo $this->jQuery() . PHP_EOL;
 
// Links
echo $this->headLink() . PHP_EOL;

This uses the jQuery and headLink view helpers to:

• Render the appropriate tags for including the core jQuery files
• Render the link tags used to include the stylesheet.

The latter point is of relevance, as the first lines of the view script are:

// Append the login page stylesheet
$this->headLink()->appendStylesheet($this->baseUrl('/css/login.css'));

The stylesheet file appended here needs to be rendered, and the echo $this->headLink() statement in the layout script does just that.

The styles in the file are as follows:

#login_title
{
	text-align: center;	
}
 
#login_error
{
	text-align: center;
}
 
#login_form
{
	margin-left: auto;
	margin-right: auto;
	position: relative;
	width: 400px;
}
 
#login_form dl
{
	float: left;
	width: 400px;
	padding: 20px 0 20px 0;
	background: #d3d3d3;
	border: 1px solid gray;
}
 
#login_form dt
{
	clear: left;
	float: left;
	width: 120px;
	margin: 0;
	padding: 5px;
	text-align: right;
	font-weight: bold;
}
 
#login_form dd
{
	float: left;
	width: 240px;
	margin: 0;
	padding: 5px;
	text-align: left;
}

The form is rendered as a definition list (dl), so the main task of the above styling is to ensure that the label (dt) and input control (dd) are on the same line. This rendering is the default behaviour of Zend_Form.

The jQuery include is necessary, as the script makes use of it to give focus the appropriate field in the form.

The script first enables jQuery, then includes a general purpose JavaScript file, used to give focus to fields on a form.

// Add the form JavaScript file
ZendX_JQuery::enableView($this);
$this->jQuery()->addJavascriptFile($this->baseUrl('/js/form.js'));

The form.js JavaScript file contains the following script:

var Form = function()
{
	Form.prototype.FirstFieldFocus = function(form_id)
	{
		$("#" + form_id + " :input:visible:enabled:first").focus();
	};
 
	Form.prototype.ErrorFieldFocus = function(field_id)
	{
		$("#" + field_id).focus();
	};
};
 
var theForm = new Form();

The above provides two basic functions:

• Select the first field on a form
• Select a specific field on a form

The first requires an elaborate jQuery selector, which detemines the first input field on the form which is visible and enabled.

The script now moves on to render the page title:

// Display the page title
echo '<h3 id="login_title">Login</h3>' . PHP_EOL;

Finally, the script renders the form and any error messages. In addition to the form itself, the script also create the appropriate JavaScript to invoke the functions defined in form.js in order to either select the error field, if there was an error when the form was submitted, or the first field of the form, if the form has not yet been submitted.

// Display any error messages and set focus to the appropriate form field
if (isset($this->errorMessage))
{
	printf('<div id="login_error" class="error">%s</div>' . 
PHP_EOL, $this->errorMessage);
	$script = sprintf('theForm.ErrorFieldFocus("%s");', 
$this->errorField);
	$this->jQuery()->addOnload($script);
}
else
{
	$script = sprintf('theForm.FirstFieldFocus("%s");', 
$this->form->getAttrib('id'));
	$this->jQuery()->addOnload($script);
}
 
// Render login form
$this->form->setAction($this->baseUrl('/login'));
echo $this->form;

Note the use of $this->jQuery()->addOnload(). The script is not rendered directly to the page in the view script, but rather in the layout script, by the echo $this->jQuery() statement. It is wrapped inside a jQuery ready event, so that it is only executed when the whole page is loaded.

Lightbox is a simple, unobtrusive script used to overlay images on the current page. It’s a snap to setup and works on all modern browsers.

I decided to add the script to the GM-RAM website in order to allow visitors to view full-sized versions of the screen shots there without having to navigate to a separate page.

I downloaded the Lightbox JavaScript, style sheet and images that need to be placed in the publically-accessible part of the website. The JavaScript files were stored under /js/lightbox/, the style sheet at /css/lightbox.css and the images under /img/lightbox.

The first challenge arose from the fact that the site already uses jQuery, while Lightbox is based on Prototype and Scriptaculous. As both use the dollar ($) symbol, it was necessary to put jQuery into no conflict mode. Fortunately, as I was using ZendX_JQuery, there is a built-in mechanism for handling this.

In order to make sure that you use the correct jQuery “handler” character ($ or something else), you should dynamically determine what this is. An example of this is from the view handler I wrote to create the JavaScript used to load the results of an AJAX request into a block on the page:

class Application_View_Helper_LoadScript extends Zend_View_Helper_Abstract
{
  public function loadScript($id, $url)
  {
    $jqHandler = ZendX_JQuery_View_Helper_JQuery::getJQueryHandler();
    $script = sprintf($jqHandler . '("#%s").html("Loading..."); ' . 
      $jqHandler . '("#%s").load("%s");', $id, $id, $url);
    return $this->view->jQuery()->addOnload($script);
  }
}

Lightbox works unobtrusively by looking for links with the rel attribute set to either just lightbox or lightbox[group-name], where group-name is set to the same value for a series of images that the user should be able to view by navigating forwards and backwards. The links are wrapped around an image.

I changed the attributes of the images in line with this on the relevant pages. I then created a common script to be included in all the pages, which would set up Lightbox on them. The script is called lightbox.phtml and is located in /application/views/scripts. It is added to the pages’ view scripts by the following line:

<?php echo $this->render('lightbox.phtml'); ?>

The lightbox.phtml script starts by activating jQuery no conflict mode; as noted before, this is because Lightbox uses Prototype and Scriptaculous.

ZendX_JQuery_View_Helper_JQuery::enableNoConflictMode();

The script then adds the Lightbox JavaScript files. It is possible to do this here, as the view script is rendered before the layout, and therefore when echo $this->headScript() is used in the layout script to finally generate the list of script tags in the header, these are included in the output generated.

$this->headScript()->appendFile(
  $this->baseUrl('/js/lightbox/prototype.js'));
$this->headScript()->appendFile(
  $this->baseUrl('/js/lightbox/scriptaculous.js?load=effects,builder'));
$this->headScript()->appendFile(
  $this->baseUrl('/js/lightbox/lightbox.js'));

Because the implementation of Lightbox assumes locations for its images that are not always correct, we need to add some JavaScript to change them. The script we generate is added using the same mechanism as for the basic script files, although here we are using inline script that we have generated.

$this->headScript()->appendScript(
  'LightboxOptions.fileLoadingImage = "' . 
  $this->baseUrl('/img/lightbox/loading.gif') . '";');
$this->headScript()->appendScript(
  'LightboxOptions.fileBottomNavCloseImage = "' . 
  $this->baseUrl('/img/lightbox/closelabel.gif') . '";');

Then we add the Lightbox style sheet using a similar mechanism, this time using the headLink helper. This helper is called via echo $this->headLink() in the layout script, which renders this link along with the others added there.

$this->headLink()->appendStylesheet($this->baseUrl('/css/lightbox.css'));

Finally, we need to override some of the styling, which relates to the location of images. We used the headStyle helper for this; as with the headScript and headLink helpers, this relies on the layout script making a call to the helper, this time via echo $this->headStyle(). Note that this call to headStyle should come after the call to headLink in the header to ensure the overriding of the styling.

$this->headStyle()->captureStart();
?>
#prevLink:hover, #prevLink:visited:hover
{
  background: url(<?php echo $this->baseUrl('/img/lightbox/prevlabel.gif'); ?>) 
left 15% no-repeat;
}
 
#nextLink:hover, #nextLink:visited:hover
{
  background: url(<?php echo $this->baseUrl('/img/lightbox/nextlabel.gif'); ?>) 
right 15% no-repeat;
}
<?php
$this->headStyle()->captureEnd();

Note the use of the captureStart and captureEnd methods to allow the CSS to be rendered inline.

Regarding the calls to headScript, headLink and headStyle, the relevant section of the layout script is as follows:

// Scripts
echo $this->headScript() . PHP_EOL;
 
// Links
$this->headLink()->prependStylesheet($this->baseUrl('/css/default.css'));
$this->headLink(array('rel' => 'shortcut icon', 
  'href' => $this->baseUrl('/img/favicon.ico'), 'type' => 'image/x-icon'));
echo $this->headLink() . PHP_EOL;
 
// Styles
echo $this->headStyle() . PHP_EOL;

Now the Lightbox effect should be applied to all the tagged images on the page.

Here is the basic skeleton of the new feed controller:

class FeedController extends Zend_Controller_Action
{
  public function digestAction()
  {
    // TODO: Insert digest action handling code here
  }
 
  // TODO: Insert any additional member functions here
}

The controller contains one action handler, for the digest action.

The implementation of the action handler starts by disabling the standard layout, as it is an AJAX request:

    $this->_helper->layout->disableLayout();

It then tries to get the blog ID. If it cannot, it reports an error; if it can, it then tries to fetch the digest for the log.

    // Get the blog ID
    $id = $this->getRequest()->getParam('id');
 
    if (isset($id))
    {
      try
      {
        // TODO: Insert code to fetch blog digest and pass it to the view here
      }
      catch (Exception $e)
      {
        // Log the error
        $log = $this->getInvokeArg('bootstrap')->getResource('log');
        $log->err('Error retrieving feed - ' . $e->getMessage());
 
        // Report the error
        $this->view->errorMessage = 'Error retrieving feed';
      }
    }
    else
    {
      $this->view->errorMessage = 'Blog ID not specified';
    }

Note that the process of fetching the digest is wrapped in a try/catch block to handle any errors; these are logged in detail.

Now we go through a two stage process:

1. First we check whether the digest for the specified blog ID is in the cache; if it is, we use that
2. However, if it it not, we retrieve the feed URL from the database, then fetch the digest from the feed

In both cases, either the digest is passed to the view script, or an error message, should an error occur.

The implementation of this is given below.

        // See if we can get the feed info from the cache
        $cache = $this->_getCache();
 
        if (!$this->view->digest = $cache->load('feed_' . $id))
        {
          // Get the blog information from the database
          $dbTableBlog = new Application_Model_DbTable_Blog();
          $select = $dbTableBlog->select()->where('id = ?', $id);
          $row = $dbTableBlog->fetchRow($select);
 
          if (isset($row))
          {
            // Get the blog digest from the feed and cache it
            $this->view->digest = $this->view->feedDigest($row['feed']);
            $cache->save($this->view->digest, 'feed_' . $id);
          }
          else
          {
            $this->view->errorMessage = 'Blog ID not found in database';
          }
        }

The cache object is created by a call to the following private member function of the controller’s class:

  private function _getCache()
  {
    // Set the cache frontend and backend options
    $frontendOptions = array(
      'lifetime' => 7200, // Cache lifetime of 2 hours
      'automatic_serialization' => true
    );
 
    $backendOptions = array(
      'cache_dir' => APPLICATION_PATH . '/cache/' 
        // Directory where to put the cache files
    );
 
    // Get a Zend_Cache_Core object
    $cache = Zend_Cache::factory('Core', 'File', 
      $frontendOptions, $backendOptions);
 
    return $cache;
  }

Note that we need to configure a front end and back end for the cache. The former is concerned with things like the lifetime of the cache, the latter with where the cached data is stored.

The view script is as follows:

<?php
if (isset($this->errorMessage))
{
  if (APPLICATION_ENV == 'development')
  {
    printf('<p class="error">%s</p>', $this->errorMessage);
  }
  else
  {
    echo '<p>No posts found</p>' . PHP_EOL;
  }
}
else
{
  if (strlen($this->digest) > 0)
  {
    echo $this->digest . PHP_EOL;
  }
  else
  {
    echo '<p>No posts found</p>' . PHP_EOL;
  }
}

Note that the script is set to render a more descriptive error message in development mode, to assist with debugging. Otherwise, the script should be self-explanatory.

Zend_Paginator works as follows:

1. The paginator is passed either an actual set of data, or a database query that can be used to retrieve the data.
2. The paginator will by default retrieve the first page and 10 items on that page; the page and the items per page can be set at this point if necessary.
3. The paginator can be used to render a navigator, by retrieving the current page and the number of pages.
4. The paginator can be used to render the current page, by iterating over the paginator to retrieve each item in order.

I shall give a concrete example of how this can be implemented below, based on an application I am currently developing.

First, let us start with the controller. In this instance, the controller is user and the action is index. The skeleton for this code is as follows:

class UserController extends Zend_Controller_Action
{
  public function indexAction()
  {
    // Insert implementation here
  }
}

The current page will be passed via the URL as a parameter. The first task in the action handler is therefore to retrieve the page number. If it is not specified, it will default to 1.

    // Get the current page
    $page = $this->getRequest()->getParam('page', 1);

The next step is to construct a Zend_Db_Select object that represents the database query. To do this we need a database adapter; below, we assume that this has been created during the bootstrapping process and can be retrieved via the bootstrap object. The query simply retrieves all records from the user table, ordering them by the user’s display name.

    // Get the boostrap object
    $bootstrap = $this->getInvokeArg('bootstrap');
 
    // Get the database adapter
    $dbAdapter = $bootstrap->getResource('db');
 
    // Create the selection object
    $select = $dbAdapter->select()->from('user')->order('name');

Now we have the select object, we can use it to create the paginator object.

    // Get a Paginator object using Zend_Paginator's built-in factory
    $paginator = Zend_Paginator::factory($select);

We can then set the number of items per page and the current page.

    // Set the number of items to show per page
    $paginator->setItemCountPerPage(5);
 
    // Select the requested page
    $paginator->setCurrentPageNumber($page);

Finally, we should pass the paginator object to the view script.

    $this->view->paginator = $paginator;

The view script used is given below. Note that the application uses Zend_Layout, so only the unique content of the page needs to be generated here.

<h3>User Management</h3>
 
<?php
// Display pagination control
echo $this->paginationControl($this->paginator, 'Elastic', 'paginator.phtml');
?>
<table>
  <thead>
    <tr>
      <th width="25%">Username</th>
      <th width="25%">Role</th>
      <th width="50%">Name</th>
    </tr>
  </thead>
  <tbody>
    <?php
    // Render each item for the current page in a table row
    foreach ($this->paginator as $item)
    {
    ?>
    <tr>
      <td><?php echo $this->escape($item['username']); ?></td>
      <td><?php echo $this->escape(ucfirst($item['role'])); ?></td>
      <td><?php echo $this->escape($item['name']); ?></td>
    </tr>
    <?php
    }
    ?>
  </tbody>
</table>

The script uses the PaginationControl view helper to render the navigator. The view script for the navigator markup is specified as one of the parameters as paginator.phtml; this script is found in the /application/views/scripts directory. The following standard script is used:

<?php if ($this->pageCount): ?>
<div class="paginator">
 
<!-- First page link -->
<?php if (isset($this->previous)): ?>
  <a href="<?php echo $this->url(array('page' => $this->first)); ?>">
    First
  </a> |
<?php else: ?>
  <span class="disabled">First</span> |
<?php endif; ?>
 
<!-- Previous page link -->
<?php if (isset($this->previous)): ?>
  <a href="<?php echo $this->url(array('page' => $this->previous)); ?>">
    < Previous
  </a> |
<?php else: ?>
  <span class="disabled">< Previous</span> |
<?php endif; ?>
 
<!-- Next page link -->
<?php if (isset($this->next)): ?>
  <a href="<?php echo $this->url(array('page' => $this->next)); ?>">
    Next >
  </a> |
<?php else: ?>
  <span class="disabled">Next ></span> |
<?php endif; ?>
 
<!-- Last page link -->
<?php if (isset($this->next)): ?>
  <a href="<?php echo $this->url(array('page' => $this->last)); ?>">
    Last
  </a>
<?php else: ?>
  <span class="disabled">Last</span>
<?php endif; ?>
 
</div>
<?php endif; ?>

The section used to render the current page as a table makes use of the fact that the paginator object can be iterated over to retrieve each item on the current page in turn.

The following styling is applied to the navigator:

.paginator { padding: 5px; }

The following styling is applied to the table:

table { width: 100%; }
 
th, td { padding: 5px; }
 
th { background-color: #4E7DD1; color: #FFFFFF; }

The feed digest class is named Default_View_Helper_FeedDigest and stored in the /application/views/helpers directory in a file called FeedDigest.php.

The basic skeleton of the class is as follows:

class Default_View_Helper_FeedDigest extends Zend_View_Helper_Abstract
{
  public function feedDigest($uri, $maxItems = 5)
  {
    // Implementation of view helper
    ...
  }
}

The Zend Framework documentation recommends that the helper either extends the class Zend_View_Helper_Abstract or implements the interface Zend_View_Helper_Interface. This is to provide support for the setView method, which will be called to give the helper automatic access to the view object.

The class returns the HTML that should be used to render the digest. The code that fetches the digest information and turns it into an unordered HTML list is wrapped in a try/catch block; this allows any feed errors to be caught.

    try
    {
      // Fetch feed digest
      ...
    }
    catch (Exception $e)
    {
      // Feed import failed
      $html = '';
    }
 
    return $html;

The first step is to perform the feed import, using the URI supplied:

      // Import feed
      $feed = Zend_Feed::import($uri);

The next step is to check the number of elements returned; if there are none, we need to render an appropriate meesage:

      // Generate digest of feed
      if ($feed->count() > 0)
      {
        // Render contents of feed
        ..
      }
      else
      {
        $html = '';
      }

If there are feed entries, these need to be converted into a list of links, with the appropriate URL and text; the number of entries returned is limited by the $maxItems parameter passed to the helper:

        $items = array();
        $count = 0;
 
        foreach ($feed as $item)
        {
          // Add the item to the list
          $pubDate = date('d M Y', strtotime($item->pubDate));
          $items[] = sprintf('<a href="%s" rel="nofollow">%s - %s</a>', 
            $item->link, $pubDate, $item->title);
 
          // Check whether the maximum item limit has been reached
          $count++;
 
          if ($count >= $maxItems)
          {
            break;
          }
        }

Finally the array is rendered as an unordered list:

        $html = $this->view->htmlList($items, false, null, false);

Because Zend_View_Helper_Abstract supports setView, and the helper is derived from that class, it can access other helpers via $this->view.

The second parameter passed to the HtmlList helper (false) indicates an unordered list; true would indicate an ordered list.

The fourth parameter is set to false, to indicate that the text in each array element should not be escaped; this is essential as they contain HTML links that should be rendered verbatim.

if (isset($this->errorMessage))
{
  if (APPLICATION_ENV == 'development')
  {
    printf('<p class="error">%s</p>', $this->errorMessage);
  }
  else
  {
    echo '<p><strong>Recent Posts:</strong> None found</p>' . PHP_EOL;
  }
}
else
{
  $digest = $this->feedDigest($this->blog->feed);
 
  if (strlen($digest) > 0)
  {
    echo '<p><strong>Recent Posts:</strong></p>' . PHP_EOL;
    echo  $digest . PHP_EOL;
  }
  else
  {
    echo '<p><strong>Recent Posts:</strong> None found</p>' . PHP_EOL;
  }
}

The view helper used to generate the digest will be examined in the next post.

The class is named Default_View_Helper_AjaxFeedDigest. Note that

• The prefix used is that declared in the application.ini file
• The location of the implementation file is also as declared there
• The name of the file is the name of the class without the prefix

The class is implemented as follows:

class Default_View_Helper_AjaxFeedDigest 
 extends Zend_View_Helper_Abstract
{
  public function ajaxFeedDigest($id)
  {
    $divId = sprintf('blog_%s', $id);
 
    $script = sprintf('$(document).ready(function() 
     { $("#%s").load("/feed/digest/id/%s"); });', $divId, $id);
 
    $html = sprintf('<div id="%s"></div>' . PHP_EOL, $divId) . 
      $this->view->inlineScript()->setScript($script);
 
    return $html;
  }
}

The class renders two blocks of HTML:

1. A container for the information returned by the AJAX request
2. A script used to make the AJAX request

The container is given a unique ID, based on the ID of the blog from the database. This is to allow the request to be made for mutliple blogs.

The script makes use of the standard jQuery call $(document).ready(…) to pass a function which needs to be executed when the document has been loaded fully. This function makes the AJAX request for the blog digest, and the response is displayed in the container.

The script contains the following code:

$this->tabPane(
  'tabs',
  $this->render('index/blogs/our-blogs.phtml'),
  array('title' => 'Our Blogs')
);
 
foreach ($this->blogs as $blog)
{
  $this->tabPane(
    'tabs',
    $this->partial('index/blogs/blog-partial.phtml',
      array(
        'name' => $blog->name,
        'href' => $blog->href,
        'description' => $blog->description,
        'id' => $blog->id
      )
    ),
    array('title' => $blog->name)
  );
}
 
echo $this->tabContainer('tabs');

The page makes use of the partial view helper to render the markup for each blog page’s tab. The partial helper takes two parameters; the first indicates the file containing the partial view script, the second the variable parameters used to fill out this script. The partial view script used here contains the following:

<h1><a href="<?php echo $this->href; ?>">
  <?php echo $this->name; ?></a></h1>
 
<p>
  <strong>URL: </strong> 
    <a href="<?php echo $this->href; ?>" rel="nofollow">
    <?php echo $this->href; ?></a>
</p>
 
<p>
  <strong>Description:</strong> 
    <?php echo $this->description; ?>
</p>
 
<?php
echo $this->ajaxFeedDigest($this->id) . PHP_EOL;

The parameters passed to the partial view script are the blog name and description, its URL, and its ID. The last is passed to the AjaxFeedDigest view helper.

We shall look at the implementation of the AjaxFeedDigest view helper in the next post. It is used to render a list of the most recent five posts on the specified blog, using the blog’s feed to fetch the information. The decision to use an AJAX approach to rendering this list was because sometime it can take a little time to fetch this information. If the site had to wait for it before rendering the rest of the page, the user can often be faced with an unacceptable wait staring at a blank browser tab. However, if the rest of the page is rendered first, then the user can at least view that; the information for each blog feed can then be filled in as soon as it is available.

In this next series of posts, I shall look at how the page is implemented. The blog digest is not fetched before the bulk of the page is rendered, as there may be a noticeable delay before it is fetched and therefore before the visitor receives a response. Instead, the page renders each blog tab with a placeholder section, into which the digest feed is loaded using AJAX techniques.

The posts will deal with the following aspects of the implementation:

1. The index/blogs action handler
2. The index/blogs view script
3. The AJAX feed digest helper
4. The feed/digest action handler
5. The feed/digest view script
6. The feed digest helper

The script contains the following code:

<?php
$this->tabPane(
  'tabs',
  $this->render('index/contact/contact-us.phtml'),
  array('title' => 'Contact Us')
);
 
echo $this->tabContainer('tabs');

The contents of the tab are rendered by the contact-us.phtml script in the contact sub-directory. This starts by rendering the tab heading:

<h1>Contact Us</h1>

Then it determines whether an error has occurred; if it has, the amount of information displayed depends on whether the site is deployed in a development environment:

<?php
if (isset($this->errorMessage))
{
  if (APPLICATION_ENV == 'development')
  {
    printf('<p class="error">%s</p>', $this->errorMessage) . 
PHP_EOL;
  }
  else
  {
    printf('<p class="error">There was a problem sending 
your message; please phone us on %s, or try again later.
</p>' . PHP_EOL,
    $this->placeholder('phoneNumber'));
  }
}

If an error has not occurred, the script tests whether the message sent flag is set; if it has, it displays an appropriate message for the user:

else if (isset($this->sent))
{
  echo '<p>Thank you for contacting GM-RAM! We will attempt 
to respond to you as soon as possible.</p>' . PHP_EOL;
}

If the message sent flag is not sent, the script will render the contact form instructions and the form itself; if the form has been submitted, but failed validation, any errors will be displayed here and the appropriate form selected.

The script starts with the instructions:

else
{
  echo '<p>Please fill in the following form and click on the 
<strong>Send</strong> button.</p>' . PHP_EOL;

Then it tests for a validation error and displays the error message:

  if (isset($this->error))
  {
    // Display the error message
    printf('<p class="error">%s</p>' . 
PHP_EOL, $this->error['message']);

It also selects the error field using jQuery:

    // Select the error field
    $script = sprintf('$("#%s").focus()', $this->error['field']);
    $this->jQuery()->addOnload($script);
  }

Note that the script dynamically creates a jQuery selector which refers to the field id, e.g. $(“#name”) for the name field. Also note that it uses the ZendX_JQuery helper to add this code to the functions executed when the page has loaded; this makes sure that the field is selected properly.

If there is no error, a similar mechanism is used to select the first form field:

  else
  {
    // Select the first field
    $script = sprintf(
      '$("#%s :input:visible:enabled:first").focus()', 
      $this->form->getAttrib('id')); 
    $this->jQuery()->addOnload($script);
  }

Note the special jQuery selection code applied to the form to select the first field; this doesn’t depend on the field ID staying the same (or indeed on the form ID staying the same, as the script fetches that dynamically).

Finally, the script sets the form action and renders it:

  $this->form->setAction($this->url());
  echo $this->form . PHP_EOL;
}

We have already looked at the implementation of the action handler. In my next post I shall look at the classes used to implement the form.