Step 1: Include the code of the tableless renderer.

require_once 'HTML/QuickForm/Renderer/Tableless.php';

Step 2: Create a new class that extends from the HTML_QuickForm_Action_Display class, and overload the _renderForm() method. This method basically does the same as the code examples for the single page forms do. The only difference is the usage of $page instead of $form (a page in QFC extends the HTML_QuickForm class).

class Tableless_Display extends HTML_QuickForm_Action_Display
{
    function _renderForm(&$page)
    {
        $renderer =& new HTML_QuickForm_Renderer_Tableless();
        $page->accept($renderer);
        echo $renderer->toHtml();
    }
}

Step 3: Tell QFC to use the new class instead of the default HTML_QuickForm_Action_Display class for displaying the form. ($wizard is a HTML_QuickForm_Controller instance in this example.)

$wizard->addAction('display', new Tableless_Display());

After these three steps, you should have a tableless layout together with DHTML rules.

1. a small typo (“exsist” instead of “exist”)
2. the log isn’t displayed in WP’s admin area (at least not with Firefox 2.0)

Here are my solutions to these problems:

1. Replace the word “exsist” with the word “exist” in line 49.
2. Replace “overflow:auto;” with “padding-top: 30px;” at the end of line 81.

• tableless layout (no <table> tags, very good accessibility)
• DHTMLRules (form elements errors are shown on top of each element)
• more than one page

To achieve such forms, four PEAR package are needed:

• HTML_QuickForm
• HTML_QuickForm_Controller
• HTML_QuickForm_Renderer_Tableless
• HTML_QuickForm_DHTMLRulesTableless

Information about building forms with HTML_QuickForm, about building multiple page forms with HTML_QuickForm_Controller, about using the tableless renderer, and about using the DHTMLRulesTableless class on forms built with HTML_QuickForms can be found in the PEAR manual. The only thing that I’ll explain here is the usage of DHTMLRulesTableless class with HTML_QuickForm_Controller.

In general, a form page is added like in the following code snippet:

class Page1 extends HTML_QuickForm_Page
{
    // ...
}
$form =& new HTML_QuickForm_Controller();
$page1 =& new Page1('page1');
$form->addPage($page1);

To use now the DHTMLRulesTableless class, you need to add and to change one line:

require_once 'HTML/QuickForm/PageDHTMLRulesTableless.php';
class Page1 extends HTML_QuickForm_PageDHTMLRulesTableless
{
    // ...
}
$form =& new HTML_QuickForm_Controller();
$page1 =& new Page1('page1');
$form->addPage($page1);

That means that you only need to do two things:

• you need to include HTML/QuickForm/PageDHTMLRulesTableless.php
• instead of extending from HTML_QuickForm_Page, your page classes need to extend from HTML_QuickForm_PageDHTMLRulesTableless

The new HTML_QuickForm_PageDHTMLRulesTableless class is mostly a simple copy of the HTML_QuickForm_DHTMLRulesTableless class, but it extends HTML_QuickForm_Page and not HTML_QuickForm. This code duplication couldn’t be avoided because of a bad design of the Page class of HTML_QuickForm_Controller. After HTML_QuickForm2 is ready, a new Controller package is planned, and Alexey Borzov already announced that his new package will have a better design to avoid the need of such code duplications.

This class generates code required as an interface to an existing database by reverse engineering the database. It generates a DB_Table subclass definition for each table, and a script that instantiates one instance of each DB_Table subclass, and a parent DB_Table_Database object. See the documentation block for the new class for usage instructions, and the tests/generator/tests.php script for an example.

So what’s new in release 1.5.0? The changelog says:

• New DB_Table_Database class added to package. The new class provides a model of foreign key relationships between tables in a database, and features that depend on knowledge of these relationships. User documentation for this class is provided in docs/database/manual.html.
• Added auto-increment feature to DB_Table insert() method. The value of a new $auto_inc_col property is the name of an auto-increment column (if any) or null.
• Added toXML() method to DB_Table, which emits the table schema in the MDB2 XML DTD, with an extension to describe foreign key references. This method is called by the toXML() method of DB_Table_Database, which emits an XML schema string for an entire database.

All existing users of DB_Table (and also interested people, of course) are encouraged to install the new release by pear install DB_Table-beta and to report via the bug tracker any occuring problem. But as we have a lot of unit tests for the new features, we hope that only very minor problems will occur.

Finally, a short comment on the near future of DB_Table: We are planning to work on two things in the next weeks and months. The first and most important thing is to convert the documentation from Paul M. Jones’ wiki into the PEAR manual and to update all pages to reflect the functionality of the current release. This will need a lot of work and help is always welcome. (Contact me for more details if you’re interested.) The second task is two write a script that generates a DB_Table class file from an existing table. This will make things a lot easier for both new and existing users of DB_Table. David already started to work on such a generator.

On August 31th, 2006, I have passed the PHP 4 examination. While the exam itself was rather easy, I was pretty annoyed after the exam. I had chosen to do the exam in German language on the VUE registration form. This wasn’t a good idea of mine: The translation was very bad. On one of the questions I couldn’t even guess what the original English question might have been. And there was also a real error in the exam: I don’t remember the exact question, but I was a question about the understanding of regular expressions. Unfortunately, all possible answers were wrong (they all matched only one character, but the string from the question). My solution was then do chose the answer that seemed to be meant as the right answer (because the other answers had additional “errors”).

After writing to Zend Germany about these issues, they wrote me that they will take my comments into account for the new PHP 5 certification. Although the PHP 4 certification ends on the 31th of March 2007, I’d like to warn all German speaking people to not choose to take the PHP 4 exam in German–you would regret it maybe.

About four months later, on the 5th of January 2007, I’ve got my framed certificate from Zend (it was sent out on December 28th from Cupertino, California). The envelope also contained a short letter with an “advertisement” for free business cards (BTW: the login information provided in the letter was invalid), and a sticker with the ZCE logo.

Now back to the PHP 5 exam. I’ve used php|architect’s Zend PHP 5 Certification Study Guide written by Davey Shafik together with Ben Ramsey, and also the mock testing offer on phparch.com.

My preparation was rather short: I’ve read the book once (starting on Saturday), did the mock test (on Sunday evening), signed up for the exam (on Monday; BTW: only the English language exam is currently available, so no surprises with translations are possible currently), and passed the exam two days later (on Wednesday). The mock test had two surprises: It contained only 65 instead of the announced 70 questions, while the test time was still 90 minutes. I’m not sure, but I remember a similar “surprise” from the real PHP 4 exam. The second surprise were a lot of small errors (mostly typos). But the questions and answer options were still readable. Nethertheless, one question was really wrong. I don’t remember neither the exact question nor the topic, but I was able to pass the mock test with many “Excellent” results and one “Good” result for one of the sub-topics.

Another “surprise” was the Study Guide. It contains a lot of errors, mostly typos and duplicated words like “each each”, but at least also two really wrong things. The frequency of errors seems to get higher in the second half of the chapters. I wouldn’t have expected that much errors, especially because the covers claims that the book was “reviewed by core PHP developer Derick Rethans“. This is not meant as an attack against Derick, but both he and the authors of the book should have recognized a least some of the errors. Many of them are really obvious. Nethertheless, the structure and the contents helped me to get an idea of the topics of the real exam.

The real exam itself was more challenging than the PHP 4 exam. It contained some more topics, and also some more “tricky” questions (i.e. questions that can’t be answered without thinking more than 30 or more seconds). Zend seems to have taken Tobias Schlitt’s complaints about the PHP 4 exams into account (he is also now a member of the Education Advisory Board). Apart from two or three minor typos (like “folowing”), there was again a real error (surprise!). I won’t go into details about the question itself, but to choose the two right answers out of four answer options, I had to select one wrong and one right answer. The problem was “function_construct” in the answer. I guess that Zend didn’t want to do the two typos here, as the other two possible options did not really make sense.

Almost finally for this entry, an interesting comparison on the pricing. Zend Germany currently wants to have EUR 148,75 for the exam (including 19% German VAT). With manipulating the URL or by changing the preferred language in my browser to English, I saw the price in US dollar: USD 148,75 (again including the 19% VAT). This results in EUR 115,76 (including another 1% for non-EUR transaction from my credit card company). The same thing applies to the mock testing fee: It’s available for both EUR 11,90 and USD 11,90 (both incl. VAT). The USD price corresponds to EUR 9,25 (incl. 1% non-EUR charge). It should be obvious whether I have paid in EUR or USD …

To sum this post up: Zend has taken the criticism about the old exam into account and provides a not too easy and not too difficult exam to test people about their PHP 5 knowledge. Both ways of preparation, the Study Guide and the mock testing offer, are nice possibilities for preparation. Good luck for everybody who wants to take the exam in the future!

Update July 3th 2007: Today, about six months after the exam, I got a letter from Zend. This time the certificate wasn’t framed. A short letter and a sticker were also included in the envelope. The business card offer seem to have been skipped (it isn’t advertised in the new letter, and the old credentials still don’t work).

To be able to add another text to an element, we will use a rather unknown feature of HTML_QuickForm. QuickForm supports multiple labels for elements. Instead of using a string of the $label parameter, one can specify an array of strings with labels. For example, instead of

$form->addElement('text', 'email', 'Your email:');

we can also write

$form->addElement('text', 'email',
    array('Your email:',
          'Please check your email address twice.'));

The second step is to modify the template for form elements. The default element template is defined as follows:

$elementTemplate =
"\n\t\t\t<li><label class=\"element\"><!-- BEGIN required
--><span class=\"required\">*</span><!-- END required -->
{label}</label><div class=\"element<!-- BEGIN error -->
error<!-- END error -->\"><!-- BEGIN error --><span
class=\"error\">{error}</span><br /><!-- END error -->
{element}</div></li>";

By adding

<!-- BEGIN label_2 --><br /><span style=\"font-size: 80%;\">
{label_2}</span><!-- END label_2 -->

after {element} we will now make the second label visible. Our new element template is now defined as follows:

$elementTemplateTwoLabel =
"\n\t\t\t<li><label class=\"element\"><!-- BEGIN required
--><span class=\"required\">*</span><!-- END required -->
{label}</label><div class=\"element<!-- BEGIN error -->
error<!-- END error -->\"><!-- BEGIN error --><span
class=\"error\">{error}</span><br /><!-- END error -->
{element}<!-- BEGIN label_2 --><br /><span style=
\"font-size: 80%;\">{label_2}</span><!-- END label_2 -->
</div></li>";

The third and last step is to change the element template in the renderer:

$renderer->setElementTemplate($elementTemplateTwoLabel);

If you need the second label only for a single element, you can also specify the element name as the second parameter:

$renderer->setElementTemplate($elementTemplateTwoLabel,
                              'elementName');

After reloading your modified script, you should get a similar output to the screensheet shown above.

Note: All linebreaks in the code snippets shown above are not required (in the templates they are even discouraged), they are just used to make the code readable.

The new major feature of the new release is streaming support. Until this release, it was impossible to use Structures_DataGrid for converting a huge database table into, for example, a CSV file. We offer now the possibility to fetch the data in chunks of, by default, 500 records from the database and to write these records into the CSV file, followed by the next chunk of 500 records, and so on.

Streaming can be enabled by calling $datagrid->enableStreaming(); and it is supported by all database DataSource drivers and the CSV and XML renderers. Support for the XML DataSource driver and maybe also other renderers is planned.

Another new feature is the format() method of the column object that offers some auto-formatters for columns in order to avoid that each and every user of Structures_DataGrid needs to implement basic formatter functions themselves. Please note that this new format() method is experimental and might be changed in the future.

Here are some examples of the usage:

// Format UNIX timestamps as english dates:
$column->format('dateFromTimestamp', 'm/d/y');

// Format numbers with 3 decimals and no thousands
// separator:
$column->format('number', 3, '.', '');

// Format an HTML link using a printf expression with
// url-encoding:
$column->format('printfURL',
  '<a href="edit.php?key=%s">Edit</a>');

For the future of Structures_DataGrid we are planning two new DataSource drivers (for PDO and Doctrine, after its code was PEARified and accepted), two new Renderers (HTMLEditForm and HTMLFilterForm), and also some new features for the core package.

In the tableless renderer I have removed the “height: 1px;” style from the “form fieldset li” block in the stylesheet to achieve layout compatibility with Windows Internet Explorer 7. This breaks layout compatibility with Firefox 1.x browsers, while Firefox 2.0 still works as expected. The FAQ in the PEAR manual contains solutions for getting Firefox 1.x compatibility back.

Besides two small changes, namely the adoption of the stylesheet changes from the renderer and changed escaping of the <script> tag for better compatibility with older browsers, the DHTMLRulesTableless got some bigger changes on the error style assignment and error message displaying.

In some cases the error style (i.e. the red border in the default stylesheet) and the error message were still shown even if the element was made valid; this was due to a bad concept for the lines of code that should decide whether the error style and message can be removed or not.

The last releases showed for every row of the form only the last error message. But, for groups of elements, there can be more than one error message at a time; now, all of these messages will be shown.

Static form elements like ‘header’, ‘static’, ‘submit’ or ‘reset’ can now easily be added to forms generated by DB_Table: you just need define an array called $frm in your extended class (let’s assume that you have instantiated this class in $obj), create a form object (e.g. via $form =& $obj->getForm(), ...) and then call $obj->addStaticFormElements($form);.

The $frm array has a very similar format like the column definition format. The key is the field name and the value is an array with details about the element. There is a special key called ‘before’ in the details array. If it is not given, or is empty (or null) the element will be appended at the end. If it is given, the element is added before the element specified via ‘before’. An example how the $frm array could look like:

var $frm = array(
    'headline' => array(
        'before'        => 'name',
        'qf_type'       => 'header',
        'qf_setvalue'   => 'Headline'),
    'submit'   => array(
        'before'        => null,
        'qf_type'       => 'submit',
        'qf_setvalue'   => 'Save data')
);

This example assumes that there is an element called ‘name’ in the form. The header element will be placed before this ‘name’ element, and the submit button will be placed at the end of the form.

For columns with 'qf_type' == 'file' there were some optimizations: If the column is marked as required, the ‘uploadedfile’ QF rule is now set instead of the ‘required’ QF rule. In addition, the ‘numeric’ and ‘maxlength’ QF rules are not set anymore (of course, the corresponding checks will still be done before inserting/updating data into the database).

Finally, I have added support for ‘hierselect’ and ‘jscalendar’ QuickForm elements.