Using the HTML disabled attribute won’t work:

   $this -> widgetSchema['created_group']->setAttribute(‘disabled’,'disable’);

as this will show the select field as blurred and thus show the content, but the selected option won’t be sent on a form submit: Symfony will mark that field as missing and will save it as NULL in the database, or generate a database error if the field cannot be NULL. The more complicated solution would be to also make Symfony skip that field in updates / creation.

The simpler solution is to create a custom widget type that just shows the Select’s option text and adds a hidden field with the Select’s option value. This way the users sees the text and Symfony gets the correct value upon update. This solution assumes that you trust that the user won’t tamper the hidden field with things like Firebug, so keep in mind that it’s not a secure option to make that field read-only and to make sure that the user cannot change it. It’s more of a cosmetic option.

You must create a custom widget class. The class’s code is the following:

<?php
class sfReadonlySelect extends sfWidgetFormDoctrineChoice
{
public function render($name, $value = null, $attributes = array(), $errors = array())
{
$choices = $this->getChoices();
$string = $choices[$value];
$string.= ‘<input type=”hidden” name=”‘.escape_once($name).’” value=”‘.escape_once($value).’”/>’;
return $string;
}
}

all you need to do is to save that in a file called sfReadonlySelect.class.php in the /lib/widget/ directory of your installation.

Then in your /lib/form/doctrine/myForm.php class (where myForm is the name of the object to which your Select field belongs) you initialize  the field as following:

$this -> setWidget ( ‘created_group’, new sfReadonlySelect (array(‘model’ => $this->getRelatedModelName(‘GroupCreated’), ‘add_empty’ => true)) );

It’s a simple solution to a fairly simple problem, but I haven’t found a better one on the web so here it is! Please leave your comments/questions below.

However, other browser like Chrome and IE don’t allow this: the style rule (display:none) is applied to the element but does not work, and the elements stay visible. I’ve found out a quick workaround for this problem.

Basically, all you need to do is to

1. disable all the options within the optgroup (and deselect them if they are selected)
2. move the optgroup to the end of the select’s optgroups, so that it does not get in the way

If you want to reinstate that optgroup (make it selectable again), you must do the opposite:

1. enable all the options within the optgroup
2. move the optgroup to the beginning of the select’soptgroups, so that it is visibile again.

I’ve created a couple of custom jquery functions for the purpose:

$.fn.hideOptionGroup = function() {
 $(this).hide();
 $(this).children().each(function(){
 $(this).attr("disabled", "disabled").removeAttr("selected");
 });
 $(this).appendTo($(this).parent());

}

$.fn.showOptionGroup = function() {
 $(this).show();    
 $(this).children().each(function(){
 $(this).removeAttr("disabled" );
 });
 $(this).prependTo($(this).parent());
 $(this).parent().animate({scrollTop:0},0);
}

You apply the function to the optgroup as follows:

$("#myOptgroupId").showOptionGroup();
$("#myOptgroupId").hideOptionGroup();

What this functions do is:

1. hide/show the element in Firefox directly.
2. then, it disables/enables all of the optgroup’s options.
3. and moves it to the end/beginning of the select’s optgroups.
4. scrolls the select to the top, so that the first optgroup is shown even if the user had scrolled down and selected something else (only for the show function).

This has been tested with Chrome, will test it with Explorer soon. Hope this helps. Comments and suggestions are welcome.

Click on the preview to see the full strip

Sardinien Camping
Sardinien Campingplatz
one of the two has already entered Google.de’s top ten. Let’s see what will happen in the following months…

The new strip of our official company comic, HCE Crowd, is online: Excellent Memory.
Good reading!

However if you want Title Case there’s no way to do it internally, since there’s no function in MySQL for producing Title Case. One could think, “And if I split the string in word chunks and capitalize each word by using SUBSTRING()??”. Well, that is no solution either, since there is no MySQL function for splitting strings, either. There are some solutions for splitting a string and getting the first, second, third chunk here. But none of this would work for capitalizing each word, as you cannot loop through the words.

You can do this using MySQL by creating a User Defined Function in C or C++. Which is quite complicated, and if you don’t have full access to your MySQL server it is out of the question.

Otherwise ( correct me if I’m wrong) you must do this operation by querying the database with a programming language and updating each row, one by one. Here’s a sample script in PHP.


$conn = mysql_connect($server, $username, $pass);

mysql_select_db ( $dbname );


$sql = ' SELECT `ID_item`, `name` FROM `items` WHERE (`name` REGEXP BINARY "^[a-z0-9 ]+$" OR `name` REGEXP BINARY "^[A-Z0-9 ]+$" ) ';
$result = mysql_query($sql, $conn);
echo '<table><thead><tr><td>Id</td>
<td>Old Name</td>
<td>New Name</td>
</tr>
</thead>
<tbody>';
while($row = mysql_fetch_array($result)){
$ID = $row["ID_item"];
$name = stripslashes($row["name"]);$newName = mb_convert_case($name, MB_CASE_TITLE, "utf-8");
echo "
<tr>
<td>$ID</td>
<td>$name</td>
<td>$newName</td>
</tr>
";
$sql2 = "UPDATE `items` SET `name` = '".addslashes($newName)."' WHERE `ID_item` = $ID ";
$result2 = mysql_query($sql2, $conn);
}
echo '</tbody>
</table>
';

The code above will select all fields in table “items” in which field “name”  is all lower case or upper case (this reduces the number of results you have to work on large tables). If you need to check for more irregular patterns, like mixed CASE or MIXed casE, you can change the regular expressions, or simply act on all rows of the table.

The rest of the code loops through the results, outputs a table with item ID, old name and corrected name (so you can see your results directly) and updates the field. The code assumes that your database is in UTF-8.

We’ve written this post mostly to let you know that there’s no MySQL solution for converting to Title Case, obviously the PHP method is very simple and you might write better code than this. As always, your mileage may vary, feel free to write us with any corrections and integrations!!

HCE Web Design launches a new website, HCE Crowd. It will be dedicated to the publication of a series of web strips, for now on a fortnightly basis, all set in the office of a fictional Information Technology company in North-Eastern Italy. Any references to historical events, real people, or real locales are used fictitiously. Other names, characters, places, and incidents are the product of the authors’ imagination, and any resemblance to actual events or locales or persons, living or dead, is entirely coincidental. Each strip is the work of all HCE editorial staff: fasten your RSS feeds, ready, steady, go!

A first way of disciplining access to a variable or a method of a class could be obtained adopting an appropriate naming convention. For example it is quite common using an underscore as a prefix for the class members that implement the internals of a software component. This obviously doesn’t really deny access to those resources, but helps a careful programmer not to inadvertently breaking application consistency.

The most interesting part from the programmer’s point of view is however understanding how we can use a pair of peculiarity of the language to obtain a real class member access control:

1. Lexical (static) function scope (vs. dynamic) (function scope is the one at definition time, regardless of when and where function is executed).
2. The opportunity to treat functions as other values, storing them in variables or returning them from functions.

Let’s try to clarify with an example:

function getFx () {
  var a = "Hello!";
  return function () { alert ( a ); }
}

var fx = getFx();
fx();

Here we define ‘getFx()’, a function which returns a function. We store the result of the execution into the variable ‘fx’. Static function scope grants us that the function stored in ‘fx’ has access to all the members available at its definition time and not at execution time. Calling ‘fx()’ we will obtain ‘Hello!’, despite the function ‘getFx()’ has already returned (those of you used to dynamic function scope could expect that ‘a’ would have been already garbage collected…).

Do you notice anything interesting? We have just realized a kind of encapsulation, having a variable ‘a’ whose content is not directly accessible, but can only be accessed through the function stored in ‘fx’. The function definition together with the scope chain at the moment of defining gets the name of closure (with  scope chain we mean the scope of the function together with the one of the function enclosing it and so on until global scope).

As you have guessed, the concept of closure can be successfully applied to our problem, let’s see how:

var Counter = function () {

  // Private variables
  var self = this;
  var value = 0;

  // Private methods
  var setValue = function ( val ) {
    value = val;
  };

  // Privileged methods
  this.get = function () {
    alert( value );
  }

  this.reset = function () {
    value = 0;
  }

  // constructor
  setInterval(
    function () { value++; },
    1000
  );

}

Here the variable ‘value’ cannot be modified without using one of the methods that have been exposed outside being declared with ‘this.x = function () {}’. Methods and variables defined with ‘var x = function () {}’ are no more available once the constructor function has returned.

Another thing to point out in this example is that the closure has been used in the ‘setInterval()’ call as well. Normally this function accepts as first argument a string which contains the code to be executed in the global scope; but in this case, passing an anonymous funcion defined on the fly, we have the opportunity of reaching variable ‘value’ even after the constructor returned, because ‘value’ is available in the closure of the function.

When should we use the namespacing approach and when the closures one? Although the first solution may appear naive, it has the advantage of not interfering with extensibility of the object (using closures private method cannot be easily accessed in an inherited object) and generaly speaking could need less memory, since the prefixed pseudo private members can be included in the prototype of objects.

If you found this post interesting, you will probably find useful reading this book as well, and of course you could stay tuned on this blog for more articles on this topic.

Andrea Casaccia
HCE Web Design