ThinkTank

Google Code Blog: Introducing Powerful Visualizations for your server-side data

sky.dodiya@gmail.com (SKY) — Thu, 06 Nov 2008 03:18:00 +0000

Google Code Blog: Introducing Powerful Visualizations for your server-side data

Today, we're publicly documenting the Google Visualization API's open-wire protocol, thus dramatically expanding the capabilities of this API beyond what had been available since we first launched in March of this year. Organizations can now expose their server-side data, such as in SQL databases and even in Excel spreadsheets, and display this data through visualizations from our growing directory. This flexibility makes it possible to connect easily almost any data source to a wealth of 40+ visualizations, including standard pie and line charts and complex heat maps and motion charts.

To make it even easier for developers to get started, we have documented an open-source Python library that enables any Python developer to quickly start using the API. What we find particularly cool about this library is that it also runs on Google's AppEngine. You don't even need to be an owner of your own servers to expose your data: You can place it on AppEngine and use the Visualization API to expose your data in meaningful, insightful ways in dashboards and reports. Expect to see additional server-side tools for the Visualization API in the near future.

Moreover, this week at the Dreamforce conference, Salesforce announced they've created tools, including code snippets and API harnesses, to make the Google Visualization API even easier to use. Salesforce customers can now quickly and easily add dashboards and custom reporting applications over their Salesforce data and publish these on any webpage. ISVs and BI firms such as Panorama and Conceptual Clarity, who are already marketing their powerful reporting tools over Google Spreadsheets using the Visualization API, now have access to Salesforce customers. The icing on the cake: since they use the Visualization API, they can address this new market without adding new code to their existing applications.

To learn more about how to implement your data store as a Visualization API data source, by checking out our documentation.

Official Gmail Blog: Tip: Your email, wherever you are on the web, with Toolbar

sky.dodiya@gmail.com (SKY) — Thu, 06 Nov 2008 01:49:00 +0000

Official Gmail Blog: Tip: Your email, wherever you are on the web, with Toolbar

Boost Traffic

sky.dodiya@gmail.com (SKY) — Wed, 05 Nov 2008 14:29:00 +0000

HOW TO: Boost Your Blog Traffic

Nov 03, 2005 in How To's, Internet
Many first time bloggers automatically assume that once their blog is setup and they put a few posts on it, they will get some hits and regular readers. This is quite untrue. You won’t get any traffic if no one knows about your website. In this article I hope to tackle these problems and discuss some of the common ways bloggers and webmasters drive more traffic to their site by understanding the user. I have received many emails from aspiring bloggers asking me what they can do to get more traffic, so hopefully this will help out at least those people. Don’t forget to checkout the prequel,How To: Start Blogging, that covers the technical side of setting up a blog.

Get Page Rank 10 - SEO Experiment

SlideShow Viewer

sky.dodiya@gmail.com (SKY) — Tue, 12 Aug 2008 03:52:00 +0000

Stylish gallery script with a 'lightbox' effect. Intuitive interface, it provides basic slideshow functionalities.
The current image in the viewer has a nice flow effect applied.

The viewer is free to use in personal or commercial web pages, provided that the script is not sold or exchanged for profit.
An unbranded version of the slideshow, suitable also for resale, may be purchased for a one-time per-site license fee.
Too bad is not free.

Play with this script by changing the html bellow. Submit your changes by clicking on this bar. Refresh the page to reset changes.

<html>
<head>
<base href="http://www.ajaxdaddy.com/web20/slideshow-viewer/">
<style type="text/css">
body {color: white;background: #52616F;}
a { color: white; }
</style>

<style>

</style>

</head>
<body>

<script type="text/javascript" src="javascript/slide.js"></script>
<script type="text/javascript">
</script>

<center>
<a onclick="return viewer.show(0)" href="images/img1.jpg">
<img width="70" height="70" alt="" src="images/img1_t.jpg" border="0"/> </a>
<a onclick="return viewer.show(1)" href="images/img2.jpg">
<img width="70" height="70" alt="" src="images/img2_t.jpg" border="0"/> </a>
<a onclick="return viewer.show(2)" href="images/img3.jpg">
<img width="70" height="70" alt="" src="images/img3.jpg" border="0"/> </a>
<a href="javascript:void(viewer.show(0))">Slideshow</a>
</center>

</body></html>

Read more and download "SlideShow Viewer"

PHP / Ajax upload example

While the upload via XMLHttpRequest is not possible are there many examples and tutorials to upload file via some "virtual IFRAME".

In this quick tutorial we will show how-to create such an Ajax upload form using the jQuery Form plug-in and our easy upload class. There is also a upload demo page available if you like to have a quick view on how it works. Okay let's start...

The system is very simple, build your upload form just like normal. In place of posting the form to the script you use some JavaScript code to post the data to some PHP script in the background.

Requirements

* A LAMP server with PHP5 and Imagemagicks enabled (optional)
* the Easy Upload PHP class
* the jQuery Javascript Library
* and the jQuery Form Plugin

Download the required files and place the JavaScript files into the same directory as your HTML document and place the following JavaScript code into the HTML header.

Next create a PHP script named "upload4jquery.php" and place it in the same directory where other files are located. Place this code into that new file:

<?php
include($_SERVER['DOCUMENT_ROOT'].'/classes/upload/foto_upload_script.php');

$foto_upload = new Foto_upload;

$json['size'] = $_POST['MAX_FILE_SIZE'];
$json['img'] = '';

$foto_upload->upload_dir = $_SERVER['DOCUMENT_ROOT']."/upload/";
$foto_upload->foto_folder = $_SERVER['DOCUMENT_ROOT']."/upload/";
$foto_upload->thumb_folder = $_SERVER['DOCUMENT_ROOT']."/upload/thumb/";
$foto_upload->extensions = array(".jpg", ".gif", ".png");
$foto_upload->language = "en";
$foto_upload->x_max_size = 480;
$foto_upload->y_max_size = 360;
$foto_upload->x_max_thumb_size = 120;
$foto_upload->y_max_thumb_size = 120;

$foto_upload->the_temp_file = $_FILES['fileToUpload']['tmp_name'];
$foto_upload->the_file = $_FILES['fileToUpload']['name'];
$foto_upload->http_error = $_FILES['fileToUpload']['error'];
$foto_upload->rename_file = true;

if ($foto_upload->upload()) {
$foto_upload->process_image(false, true, true, 80);
$json['img'] = $foto_upload->file_copy;
}

$json['error'] = strip_tags($foto_upload->show_error_string());
echo json_encode($json);
?>

This tutorial or guide is not about how to use the easy upload class. If you never used the class before try the example files first and than start with this Ajax upload form.

Paths and upload directories
You need to create some upload directories (2 one for the upload and one for the thumbs) and check the permission (chmod the upload directory with 777). If you use the same structure as suggested in the class file you don't need to change the include at the top from the PHP script.

Now we need the form HTML and some other containers where the response data is placed.

<form id="Form1" name="Form1" method="post" action="">
<input type="hidden" name="MAX_FILE_SIZE" value="<?php echo $max_size; ?>" />
<p>Select an image from your hard disk:</p>
<div>
<input type="file" name="fileToUpload" id="fileToUpload" size="18" />
<input type="Submit" value="Submit" id="buttonForm" />
</div>
</form>
<p><img id="loading" src="loading.gif" style="display:none;" /></p>
<p id="message"></p>
<p id="result"></p>

The file loading.gif is the upload indicator image, pick the I used on the demo page or check Google for more stylish images or image generators.

Some final note, the code works as it is. Don't change name or if attributes if you not sure if you use them inside the JavaScript code.

Ajax autosuggest/autocomplete from database

sky.dodiya@gmail.com (SKY) — Mon, 04 Aug 2008 08:17:00 +0000

Since google introduced the autosuggest or autocomplete search form on their toolbar everyone started looking for this piece of code to put on their websites. It's not new in the Ajax world but it's not seen as often as it should if you ask me. Why? It's hard to find good examples or examples that match everyone's needs. An Ajax autosuggest script is supposed to help the visitor and present in real time (as they type) some possible results based on their entered words/characters. In my opinion, this is a great feature to enhance the user experience. It's not hard to build an autocomplete search form. In fact, it's very easy. Our application will use script.aculo.us which is a rich Javascript library for the Ajax effect, an index page that will hold the search form and a response page that will perform the search based on the $_POST parameter received from our index and display some possible matches/results/suggestions. Since it's very easy to follow the demos and examples from the scriptaculous website we will focus more on the response page and the way that it will select the results and display them. Using what's explained in the PHP search engine tutorial I managed to build a nice response page in order to display my suggestions using Ajax. The response page will check the post data, stem it (plurals to singulars etc.), clean it (for common words, too short words etc.) and perform an sql search do display the entries that might match our words.

<?php

require_once('db.php');
include('classes/stem.php');
include('classes/cleaner.php');

if( !empty ( $_POST['search'] ) ):

$string = $_POST['search'];
$main_url = 'http://www.roscripts.com/';

$stemmer = new PorterStemmer;
$stemmed_string = $stemmer->stem ( $string );

$clean_string = new jSearchString();
$stemmed_string = $clean_string->parseString ( $stemmed_string );

$new_string = '';
foreach ( array_unique ( split ( " ",$stemmed_string ) ) as $array => $value )
{
if(strlen($value) >= 3)
{
$new_string .= ''.$value.' ';
}
}

$new_string = substr ( $new_string,0, ( strLen ( $new_string ) -1 ) );

if ( strlen ( $new_string ) > 3 ):

$split_stemmed = split ( " ",$new_string );

mysql_select_db($database);
$sql = "SELECT DISTINCT COUNT(*) as occurences, title, subtitle FROM articles WHERE (";

while ( list ( $key,$val ) = each ( $split_stemmed ) )
{
if( $val!='' && strlen ( $val ) > 0 )
{
$sql .= "((title LIKE '%".$val."%' OR subtitle LIKE '%".$val."%' OR content LIKE '%".$val."%')) OR";
}
}

$sql=substr ( $sql,0, ( strLen ( $sql )-3 ) );//this will eat the last OR
$sql .= ") GROUP BY title ORDER BY occurences DESC LIMIT 10";

$query = mysql_query($sql) or die ( mysql_error () );
$row_sql = mysql_fetch_assoc ( $query );
$total = mysql_num_rows ( $query );

if($total>0):

echo ' <div class="entry">'."n";
echo ' <ul>'."n";
while ( $row = mysql_fetch_assoc ( $query ) )
{
echo ' <li>'."n";
echo ' <a href="'.$main_url.'articles/show/'.$row['id'].'">'.$row['title'].''."n";
echo ' <em>'.$row['subtitle'].'</em>'."n";
echo ' <span>Added on 2007-06-03 by roScripts</span></a>'."n";
echo ' </li>'."n";
}

echo ' </ul>'."n";
echo ' </div>'."n";
endif;
endif;
endif;
?>

It's more like a complex code and I encourage you to read and understand the PHP search engine tutorial, you can delete everything that is above and enter an sql query that you built in case you don't want to use this method of searching. As a short overview of the code engine I must say that no results will be shown if the string's length (after it will be stemmed and cleaned for common words/stop words) will be smaller than 3 characters:

if ( strlen ( $new_string ) > 3 ):

and that the result (if any) must be an unordered list (ul).
Here's a demo with our application (download link lower on the page). Have fun!

PHP Examples

sky.dodiya@gmail.com (SKY) — Sat, 05 Jul 2008 14:29:00 +0000

Paging in PHP

A Example Script of Paging in PHP

<?php
// =====================================================
// FILE: Paging.php
//
// =====================================================
class Paging {

var $int_num_result; // Number of result to show per page (decided by user)
var $int_nbr_row; // Total number of items (SQL count from db)
var $int_cur_position;// Current position in recordset
var $str_ext_argv; // Extra argv of query string

// ------------------------------------------------------------------------ Constructor
//
function Paging( $int_nbr_row, $int_cur_position, $int_num_result, $str_ext_argv = "" ){
$this->int_nbr_row = $int_nbr_row;
$this->int_num_result = $int_num_result;
$this->int_cur_position = $int_cur_position;
$this->str_ext_argv = urldecode( $str_ext_argv );
} // End constructor

// ------------------------------------------------------------------- getNumberOfPage()
// This function returns the total number of page to display.
function getNumberOfPage(){
$int_nbr_page = $this->int_nbr_row / $this->int_num_result;
return $int_nbr_page;
} // end function

// -------------------------------------------------------------------- getCurrentPage()
// This function returns the current page number.
function getCurrentPage(){
$int_cur_page = ( $this->int_cur_position * $this->getNumberOfPage() ) / $this->int_nbr_row;
return number_format( $int_cur_page, 0 );
} // end function

// ----------------------------------------------------------------------- getPagingArray()
// This function print the paging to the screen.
// This function returns an array:
// $array_paging['lower'] lower limit of where we are in result set
// $array_paging['upper'] upper limit of where we are in result set
// $array_paging['total'] total number of result
// $array_paging['previous_link'] href tag for previous link
// $array_paging['next_link'] href tag for next link
function getPagingArray(){
global $PHP_SELF;

$array_paging['lower'] = ( $this->int_cur_position + 1 );

if( $this->int_cur_position + $this->int_num_result >= $this->int_nbr_row ){
$array_paging['upper'] = $this->int_nbr_row;
}else{
$array_paging['upper'] = ( $this->int_cur_position + $this->int_num_result );
}

$array_paging['total'] = $this->int_nbr_row;

if ( $this->int_cur_position != 0 ){
$array_paging['previous_link'] = "int_cur_position - $this->int_num_result ).$this->str_ext_argv ."\">";
}

if( ( $this->int_nbr_row - $this->int_cur_position ) > $this->int_num_result ){
$int_new_position = $this->int_cur_position + $this->int_num_result;
$array_paging['next_link'] = "str_ext_argv ."\">";
}
return $array_paging;
} // end function

// ----------------------------------------------------------------------- getPagingRowArray()
// This function returns an array of string (href link with the page number)
function getPagingRowArray(){
global $PHP_SELF;

for( $i=0; $i<$this->getNumberOfPage(); $i++ ){
// if current page, do not make a link
if( $i == $this->getCurrentPage() ){
$array_all_page[$i] = "". ($i+1) ."";
}else{
$int_new_position = ( $i * $this->int_num_result );
$array_all_page[$i] = "str_ext_argv\">". ($i+1) ."";
}
}
return $array_all_page;
} // end function
}; // End Class

// ==========================================
// Exemple Usage
// Note: I make 2 query to the database for this exemple, it
// could (and should) be made with only one query...
// ==========================================

include( "db_mysql.php" );

// New instance of database object, from phplib (http://phplib.sourceforge.net/)
$db = new db_data();

// If current position is not set, set it to zero
if( !isset( $int_cur_position ) || $int_cur_position == 0 ){
$int_cur_position = 0;
}

// Number of result to display on the page, will be in the LIMIT of the sql query also
$int_num_result = 20;
$extargv = "&argv1=1&argv2=2"; // extra argv here (could be anything depending on your page)

// Get the total number of result from db
$sql1 = "Select count( key ) as nbr FROM table";

if ( !$db->query( $sql1 )){ print "\n

ERREUR $sql1"; exit; }
$db->next_record();
$result_from_sql1 = $db->f("nbr");

// New instance of the Paging class, you can modify the color and the width of the html table
$p = new Paging( $result_from_sql1, $int_cur_position, $int_num_result, $extargv );

// Load up the 2 array in order to display result
$array_paging = $p->getPagingArray();
$array_row_paging = $p->getPagingRowArray();

// Display the result as you like...
print "Results ". $array_paging['lower'];
print " to ". $array_paging['upper'];
print " of ". $array_paging['total'];
print " ". $array_paging['previous_link'] ."<<< " ; for( $i=0; $i>>";

// The above exemple print somethings like:
// Results 1 to 20 of 597 <<<>>>
// Of course you can now play with array_row_paging in order to print
// only the results you would like...

// Now go on with the rest of you page...
// Select only fields needed according to paging
$sql2 = "Select * FROM my_table ORDER BY id "
."LIMIT $int_cur_position, $int_num_result";
?>

PHP Examples

sky.dodiya@gmail.com (SKY) — Fri, 04 Jul 2008 04:24:00 +0000

PHP Session
Session support in PHP consists of a way to preserve certain data across subsequent accesses. This enables you to build more customized applications and increase the appeal of your web site.
A visitor accessing your web site is assigned a unique id, the session id. This is either stored in a cookie on the user side or is propagated in the URL or can be stored in database.
A normal HTML website will not pass data from one page to another. In other words, all information is forgotten when a new page is loaded. This makes it quite a problem for tasks like a shopping cart, which requires data (the user’s selected product) to be remembered from one page to the next.
Sometimes we store id, name and other information about user in PHP Sessions. A PHP session solves this problem by allowing you to store user information on the server for later use (i.e. username, shopping cart items, etc). However, this session information is temporary and is usually deleted very quickly after the user has left the website that uses sessions.
Sessions work by creating a unique identification (UID) number for each visitor and storing variables based on this ID. This helps to prevent two users’ data from getting confused with one another when visiting the same web page.
We can start, call or retrieve and use or destroy session or session data.

Starting a PHP Session

Before you can begin storing user information in your PHP session, you must first start the session. When you start a session, it must be at the very beginning of your code, before any HTML or text is sent.
Below is a simple script that you should place at the beginning of your PHP code to start up a PHP session.

<?php
session_start();
// start up your PHP session!
// this code must be at the top of web page.
?>

Storing A Session Variable

<?php
session_start();
$_SESSION['downloads'] = 1; // store session data
echo "Downloads = ". $_SESSION['donloads']; //retrieve data
?>

Using PHP issetFunction

<?php
session_start();
if(isset($_SESSION['views']))
$_SESSION['views'] = $_SESSION['views']+ 1;
else
$_SESSION['views'] = 1;
echo "views = ". $_SESSION['views'];
?>

Destroying Sessions

<?php
session_start();
session_destroy();
// By this all the session data will be erased and session will be reset, free and empty.
?>

<?php
session_start();
session_destroy();
$_SESSION=array();
?>

Selectively Destroying Session Data

<?php
session_start();
unset($_SESSION['downloads']);
unset($_SESSION['userName']);
// session_destroy();
// $_SESSION=array();
// By this all the session data will not be lost. Just downloads and userName will be destroyed from session and if other data is ther, it will stay there.
?>

PHP Email

PHP: Send plain text email

<?php
function send_email($from, $to, $cc, $bcc, $subject, $message){
$headers = "From: ".$from."rn";
$headers .= "Reply-To: ".$from."rn";
$headers .= "Return-Path: ".$from."rn";
$headers .= "CC: ".$cc."rn";
$headers .= "BCC: ".$to."rn";

if (mail($to,$subject,$message,$headers) ) {
echo "email sent";
} else {
echo "email could not be sent";
}
}

$subject = "Hello!";
$message = "Hello! How are you today?";
send_email("youraddress@domain.com", "recpeient@domain.com",
"someone@domain.com", "hidden_email@domain.com",
$subject ,
$message);
?>

In our send_email function we set the appropriate headers. Reply-To and Return-Path points to the email you want the recipient to reply to. Some server requires the use of Return-Path, so it's good to leave it in there.
Next we call the send_email function which sends out the email.

PHP: Send HTML email

<?php
function send_email($from, $to, $subject, $message){
$headers = "From: ".$from."rn";
$headers .= "Reply-To: ".$from."rn";
$headers .= "Return-Path: ".$from."rn";
$headers .= "Content-type: text/htmlrn";

if (mail($to,$subject,$message,$headers) ) {
echo "email sent";
} else {
echo "email couldn't be sent";
}
}

$subject = "Helloooo!";
$message .= "<html><body>";
$message .= "<b>Hey! How are you today?</b>";
$message .= "<br>Regards";
$message .= "</body></html>";
send_email("youraddress@domain.com", "recpeient@domain.com",
$subject ,
$message);
?>

In our send_email function we set the content type headers to text/html. It is important to do so because it tells the email server that the email contains html code and to format and display the email correctly when it is opened.

Export MySql Data to CSV file
This function will export all data in the Mysql table. It will place the fieldnames on the first row of the CSV file.
The function will export all Mysql data to a file called ‘export.csv’ by default.
You can change this by adding an extra parameter to the exportMysqlToCsv: exportMysqlToCsv($tablename,$filename).
When the export finishes all your data will be inserted into the csv file and the file will be presented as a download.

PHP Examples

sky.dodiya@gmail.com (SKY) — Thu, 03 Jul 2008 05:20:00 +0000

Setting and Retrieving a cookie- PHP

<?
$check = "test";
$check .= $filename;
if ($test == $check)
{
print("<HTML><BODY>You have already voted. Thank you.</BODY></HTML>");
}
else
{
$rated = "test";
$rated .= $filename;
setcookie(test, $rated, time()+86400);
print("<HTML><BODY><br>You haven't voted before so I recorded your vote</BODY></HTML>");
}
?>

Generating a random number from 0 to 9 - PHP

<?
srand(time());
$random = (rand()%9);
print("Random number between 0 and 9 is: $random");
?>

Random text link advertising using predefined arrays- PHP

<?
$random_url = array("http://www.tdscripts.com/linkorg.html",
"http://www.tdscripts.com/keno.html",
"http://www.tdscripts.com/ezibill.shtml",
"http://www.tdscripts.com/tdforum.shtml",
"http://www.tdscripts.com/picofday.html",
"http://www.tdscripts.com/gutsorglory.html");

$url_title = array("Link Organizer",
"TD Keno",
"eziBill *Free Promotion!",
"TD Forum",
"TD Pic of Day PHP",
"Guts or Glory Poker PHP");
$url_desc = array("- A comprehensive link list organizer",
"- Offer your site visitors an engaging Keno game without the monetary risk",
"- Sell access to and protect your membership area using iBill and our eziBill script",
"- An unthreaded messageboard script to exchange ideas with your site visitors",
"- Run your own picture of the day script from any site anywhere with this handy script",
"- A casino-style card game written entirely in PHP");
srand(time());
$sizeof = count($random_url);
$random = (rand()%$sizeof);
print("<center><a href="$random_url[$random]">$url_title[$random]</a> $url_desc[$random]</center>");
?>

Displaying Date and Time- PHP

1- <?php date("Y-m-d"); ?>
2- <?php date("D M j G:i:s T Y"); ?>
3- <?php date("H:i:s"); ?>
4- <?php date("F j, Y, g:i a"); ?>

Your output will be:
1- 2006-09-09
2- Sat Sep 9 4:13:18 CDT 2006
3- 04:13:18
4- September 9, 2006, 4:13 am

Automatic Page Refresh- PHP

Functions like this are used in big portals to automatically refresh the home page (or subpages) in order
to give always updated news.

<?php
header("Refresh: 120;");
?>

In this exmaple the current page is automatically reloaded after 2 minutes, note that time is expressed in seconds so to have 2 minutes between 2 refreshed you need to type 120
You can use this php line also to redirect (with the preselected delay) to another page of your site, or external to your site.

This will send the visitor to the forums (assuming you have the forums running under the folder "forums" as ours) after 6 seconds.

<?php
header("Refresh: 6; url=/forums/");
?>

This will send the visitor to www.php.net after 10 seconds.

<?php
header("Refresh: 10; url=http://www.php.net");
?>

Remember that using the PHP header function you always have to put it at the very beginning of your page, just after the <html> tag. Any other header sent before our header function will make it cause an error.

More Examples : See PHP exmaples

PHP Examples

sky.dodiya@gmail.com (SKY) — Wed, 02 Jul 2008 05:41:00 +0000

PHP - Files
Manipulating files is a basic necessity for serious programmers and PHP gives you a great deal of tools for creating, uploading, and editing files.

PHP - How to Create a File
The fopen function needs two important pieces of information to operate correctly. First, we must supply it with the name of the file that we want it to open. Secondly, we must tell the function what we plan on doing with that file (i.e. read from the file, write information, etc).

Since we want to create a file, we must supply a file name and tell PHP that we want to write to the file. Note: We have to tell PHP we are writing to the file, otherwise it will not create a new file.

PHP Code:

$fileName = "testfile.txt";
$fileHandle = fopen($fileName, 'w') or die("can't open file");
fclose($fileHandle);

The file "testFile.txt" should be created in the same directory where this PHP code resides. PHP will see that "testFile.txt" does not exist and will create it after running this code. There's a lot of information in those three lines of code, let's make sure you understand it.

1. $fileName = "testfile.txt";

Here we create the name of our file, "testfile.txt" and store it into a PHP String variable $fileName.
2. $fileHandle = fopen($fileName, 'w') or die("can't open file");

This bit of code actually has two parts. First we use the function fopen and give it two arguments: our file name and we inform PHP that we want to write by passing the character "w".

Second, the fopen function returns what is called a file handle, which will allow us to manipulate the file. We save the file handle into the $fileHandle variable. We will talk more about file handles later on.
3. fclose($fileHandle);

We close the file that was opened. fclose takes the file handle that is to be closed. We will talk more about this more in the file closing lesson
___________________________________________________________________
PHP - Permissions
If you are trying to get this program to run and you are having errors, you might want to check that you have granted your PHP file access to write information to the hard drive. Setting permissions is most often done with the use of an FTP program to execute a command called CHMOD. Use CHMOD to allow the PHP file to write to disk, thus allowing it to create a file.

In the near future Tizag.com will have a more in-depth tutorial on how to use CHMOD to set file permissions.

* Read: 'r'

Open a file for read only use. The file pointer begins at the front of the file.

* Write: 'w'

Open a file for write only use. In addition, the data in the file is erased and you will begin writing data at the beginning of the file. This is also called truncating a file, which we will talk about more in a later lesson. The file pointer begins at the start of the file.

* Append: 'a'

Open a file for write only use. However, the data in the file is preserved and you begin will writing data at the end of the file. The file pointer begins at the end of the file.

* Read/Write: 'r+'

Opens a file so that it can be read from and written to. The file pointer is at the beginning of the file.

* Write/Read: 'w+'

This is exactly the same as r+, except that it deletes all information in the file when the file is opened.

* Append: 'a+'

This is exactly the same as r+, except that the file pointer is at the end of the file.
A file pointer is PHP's way of remembering its location in a file. When you open a file for reading, the file pointer begins at the start of the file. This makes sense because you will usually be reading data from the front of the file.

However, when you open a file for appending, the file pointer is at the end of the file, as you most likely will be appending data at the end of the file. When you use reading or writing functions they begin at the location specified by the file pointer.

Code example

$fileName = "testfile.txt";
$fh = fopen($fileName, 'X') or die("Can't open file");
fclose($fh);

____________________________________________________________________
PHP - File Close
In a previous tutorial, we had a call to the function fclose to close down a file after we were done with it. Here we will repeat that example and discuss the importance of closing a file.

PHP Code:

$ourFileName = "testFile.txt";
$ourFileHandle = fopen($ourFileName, 'w') or die("can't open file");
fclose($ourFileHandle);

The function fclose requires the file handle that we want to close down. In our example we set our variable "$fileHandle" equal to the file handle returned by the fopen function.

After a file has been closed down with fclose it is impossible to read, write or append to that file unless it is once more opened up with the fopen function.
____________________________________________________________________
PHP - File Write
Now that you know how to open and close a file, lets get on to the most useful part of file manipulation, writing! There is really only one main function that is used to write and it's logically called fwrite

PHP - File Write: fwrite Function
We can use php to write to a text file. The fwrite function allows data to be written to any type of file. Fwrite's first parameter is the file handle and its second parameter is the string of data that is to be written. Just give the function those two bits of information and you're good to go!

Below we are writing a couple of names into our test file testFile.txt and separating them with a carriaged return.

PHP Code:

$myFile = "testFile.txt";
$fh = fopen($myFile, 'w') or die("can't open file");
$stringData = "Bobby Bopper\n";
fwrite($fh, $stringData);
$stringData = "Tracy Tanner\n";
fwrite($fh, $stringData);
fclose($fh);

The $fh variable contains the file handle for testFile.txt. The file handle knows the current file pointer, which for writing, starts out at the beginning of the file.

We wrote to the file testFile.txt twice. Each time we wrote to the file we sent the string $stringData that first contained Bobby Bopper and second contained Tracy Tanner. After we finished writing we closed the file using the fclose function.

If you were to open the testFile.txt file in NOTEPAD it would look like this:

Contents of the testFile.txt File:
Bobby Bopper
Tracy Tanner

PHP - File Write: Overwriting
Now that testFile.txt contains some data we can demonstrate what happens when you open an existing file for writing. All the data contained in the file is wiped clean and you start with an empty file. In this example we open our existing file testFile.txt and write some new data into it.
PHP Code:

$myFile = "testFile.txt";
$fh = fopen($myFile, 'w') or die("can't open file");
$stringData = "Floppy Jalopy\n";
fwrite($fh, $stringData);
$stringData = "Pointy Pinto\n";
fwrite($fh, $stringData);
fclose($fh);

If you now open the testFile.txt file you will see that Bobby and Tracy have both vanished, as we expected, and only the data we just wrote is present.

Contents of the testFile.txt File:
Floppy Jalopy
Pointy Pinto

In the next lesson we will show you how to get information out of a file by using PHP's read data functions!
____________________________________________________________________
PHP - File Read

My apologies for taking so long to actually get to the point where you get information from files. In this lesson we will teach you how to read data from a file using various PHP functions.

PHP - File Read: fread Function

The fread function is the staple for getting data out of a file. The function requires a file handle, which we have, and an integer to tell the function how much data, in bytes, it is supposed to read.

One character is equal to one byte. If you wanted to read the first five characters then you would use five as the integer.

PHP Code:
<

$myFile = "testFile.txt";
$fh = fopen($myFile, 'r');
$theData = fread($fh, 5);
fclose($fh);
echo $theData;

Display:
Flopp

The first five characters from the testFile.txt file are now stored inside $theData. You could echo this string, $theData, or write it to another file.

If you wanted to read all the data from the file, then you need to get the size of the file. The filesize function returns the length of a file, in bytes, which is just what we need! The filesize function requires the name of the file that is to be sized up.

PHP Code:

$myFile = "testFile.txt";
$fh = fopen($myFile, 'r');
$theData = fread($fh, filesize($myFile));
fclose($fh);
echo $theData;

Display:
Floppy Jalopy Pointy Pinto

Note: It is all on one line because our "testFile.txt" file did not have a
tag to create an HTML line break. Now the entire contents of the testFile.txt file is stored in the string variable $theData.

PHP - File Read: gets Function

PHP also lets you read a line of data at a time from a file with the gets function. This can or cannot be useful to you, the programmer. If you had separated your data with new lines then you could read in one segment of data at a time with the gets function.

Lucky for us our "testFile.txt" file is separated by new lines and we can utilize this function.

PHP Code:
<

$myFile = "testFile.txt";
$fh = fopen($myFile, 'r');
$theData = fgets($fh);
fclose($fh);
echo $theData;

testFile.txt Contents:
Floppy Jalopy

The fgets function searches for the first occurrence of "\n" the newline character. If you did not write newline characters to your file as we have done in File Write, then this function might not work the way you expect it to.
____________________________________________________________________
PHP - File Delete

You know how to create a file. You know how to open a file in an assortment of different ways. You even know how to read and write data from a file!

PHP - Unlink Function

Remember from the PHP File Create lesson that we created a file named testFile.txt.

PHP Code:

$myFile = "testFile.txt";
$fh = fopen($myFile, 'w') or die("can't open file");
fclose($fh);

Now to delete testFile.txt we simply run a PHP script that is located in the same directory. Unlink just needs to know the name of the file to start working its destructive magic.
PHP Code:

$myFile = "testFile.txt";
unlink($myFile);

The testFile.txt should now be removed.
____________________________________________________________________
PHP - File Append

So far we have learned how to open, close, read, and write to a file. However, the ways in which we have written to a file so far have caused the data that was stored in the file to be deleted. If you want to append to a file, that is, add on to the existing data, then you need to open the file in append mode.

PHP - File Write: Appending Data

Using the testFile.txt file we created in the File Write lesson , we are going to append on some more data.

PHP Code:

$myFile = "testFile.txt";
$fh = fopen($myFile, 'a') or die("can't open file");
$stringData = "New Stuff 1\n";
fwrite($fh, $stringData);
$stringData = "New Stuff 2\n";
fwrite($fh, $stringData);
fclose($fh);

You should noticed that the way we write data to the file is exactly the same as in the Write lesson. The only thing that is different is that the file pointer is placed at the end of the file in append mode, so all data is added to the end of the file.

The contents of the file testFile.txt would now look like this:
Contents of the testFile.txt File:
Floppy Jalopy
Pointy Pinto
New Stuff 1
New Stuff 2
____________________________________________________________________
PHP - File Truncate

As we have mentioned before, when you open a file for writing with the paramater 'w' it completely wipes all data from that file. This action is also referred to as "truncating" a file. Truncate literally means to shorten.

PHP - File Open: Truncate

To erase all the data from our testFile.txt file we need to open the file for normal writing. All existing data within testFile.txt will be lost.

PHP Code:

$myFile = "testFile.txt";
$fh = fopen($myFile, 'w');
fclose($fh);

____________________________________________________________________
PHP - File Upload

A very useful aspect of PHP is its ability to manage file uploads to your server. Allowing users to upload a file to your server opens a whole can of worms, so please be careful when enabling file uploads.

PHP - File Upload: HTML Form

Before you can use PHP to manage your uploads, you must first build an HTML form that lets users select a file to upload. See our HTML Form lesson for a more in-depth look at forms.

HTML Code:

<form enctype="multipart/form-data" action="uploader.php" method="POST">
<input type="hidden" name="MAX_FILE_SIZE" value="100000" />
Choose a file to upload: <input name="uploadedfile" type="file" /><br />
<input type="submit" value="Upload File" />
</form>

Here is a brief description of the important parts of the above code:

* enctype="multipart/form-data" - Necessary for our to-be-created PHP file to function properly.
* action="uploader.php" - The name of our PHP page that will be created, shortly.
* method="POST" - Informs the browser that we want to send information to the server using POST.
* input type="hidden" name="MA... - Sets the maximum allowable file size, in bytes, that can be uploaded. This safety mechanism is easily bypassed and we will show a solid backup solution in PHP. We have set the max file size to 100KB in this example.
* input name="uploadedfile" - uploadedfile is how we will access the file in our PHP script.

PHP - File Upload: uploader.php

When the uploader.php file is executed, the uploaded file exists in a temporary storage area on the server. If the file is not moved to a different location it will be destroyed! To save our precious file we are going to need to make use of the $_FILES associative array.

The $_FILES array is where PHP stores all the information about files. There are two elements of this array that we will need to understand for this example.

* uploadedfile - uploadedfile is the reference we assigned in our HTML form. We will need this to tell the $_FILES array which file we want to play around with.
* $_FILES['uploadedfile']['name'] - name contains the original path of the user uploaded file.
* $_FILES['uploadedfile']['tmp_name'] - tmp_name contains the path to the temporary file that resides on the server. The file should exist on the server in a temporary directory with a temporary name.

Now we can finally start to write a basic PHP upload manager script! Here is how we would get the temporary file name, choose a permanent name, and choose a place to store the file.

PHP Code:

// Where the file is going to be placed
$target_path = "uploads/";

/* Add the original filename to our target path.
Result is "uploads/filename.extension" */
$target_path = $target_path . basename( $_FILES['uploadedfile']['name']);
$_FILES['uploadedfile']['tmp_name'];

NOTE: You will need to create a new directory in the directory where uploader.php resides, called "uploads", as we are going to be saving files there.

We now have all we need to successfully save our file to the server. $target_path contains the path where we want to save our file to.

PHP - File Upload: move_uploaded_file Function

Now all we have to do is call the move_uploaded_file function and let PHP do its magic. The move_uploaded_file function needs to know 1) The path of the temporary file (check!) 2) The path where it is to be moved to (check!).

PHP Code:

$target_path = "uploads/";

$target_path = $target_path . basename( $_FILES['uploadedfile']['name']);

if(move_uploaded_file($_FILES['uploadedfile']['tmp_name'], $target_path)) {
echo "The file ". basename( $_FILES['uploadedfile']['name']).
" has been uploaded";
} else{
echo "There was an error uploading the file, please try again!";
}

If the upload is successful, then you will see the text "The file filename has been uploaded". This is because $move_uploaded_file returns true if the file was moved, and false if it had a problem.

If there was a problem then the error message "There was an error uploading the file, please try again!" would be displayed.
____________________________________________________________________
PHP: Export Database Schema as XML

Sometimes it can be useful to have a dump of the current database schema. The script below reads the schema from a MySQL database and outputs XML that describes the schema.

At first we connect to a MySQL database and use the SHOW TABLES command to return all the tables in the database. Next, we iterate over each table and return the fields for each table using the SHOW FIELDS command. Finally, we put all of the returned information into XML.

Have a look at the code:
<

<?php
// database constants
// make sure the information is correct
define("DB_SERVER", "localhost");
define("DB_USER", "root");
define("DB_PASS", "password");
define("DB_NAME", "tutorials");

// connection to the database
$dbhandle = mysql_connect(DB_SERVER, DB_USER, DB_PASS)
or die("Unable to connect to MySQL");

// select a database to work with
$selected = mysql_select_db(DB_NAME, $dbhandle)
or die("Could not select examples");

// return all available tables
$result_tbl = mysql_query( "SHOW TABLES FROM ".DB_NAME, $dbhandle );

$tables = array();
while ($row = mysql_fetch_row($result_tbl)) {
$tables[] = $row[0];
}

$output = "<?xml version="1.0" ?>n";
$output .= "<schema>";

// iterate over each table and return the fields for each table
foreach ( $tables as $table ) {
$output .= "<table name="$table">";
$result_fld = mysql_query( "SHOW FIELDS FROM ".$table, $dbhandle );

while( $row1 = mysql_fetch_row($result_fld) ) {
$output .= "<field name="$row1[0]" type="$row1[1]"";
$output .= ($row1[3] == "PRI") ? " primary_key="yes" />" : " />";
}

$output .= "</table>";
}

$output .= "</schema>";

// tell the browser what kind of file is come in
header("Content-type: text/xml");
// print out XML that describes the schema
echo $output;

// close the connection
mysql_close($dbhandle);
?>

You should note that this code is specific to MySQL database. The commands such as SHOW TABLES and SHOW FIELDS are also available for other databases but are specified slightly differently.
____________________________________________________________________
Google Page Rank Script - PHP
The following script allows you to retrieve the google page position for your site for a given search phrase. The script performs the search, and automatically pages through the results until it finds your domain.

A few things to note about this script:

The URLs are extracted by searching for a specific font tag combination which Google currently uses to display the URL name on the search results page. This tag may change in future.

The script current asks for the results in batches of 10 hits per page. You can easily modify it to ask for more - ie 100, which will speed the whole process up. However, you will get different rankings. The more hits you ask for per page, the more Google will "expand" internal domain results or display similar results within the same site, thus dropping your site down the virtual rankings.

The script also counts two ranking types - the physical position of your site in the search results, plus the "site" position. The "site" position is how your site is ranked once the internal domain results / similar results are removed ( remember, a single site can postential occupy two result spaces ).

php code:
<?php
// $searchquery is the value to search for.
// The script replaces the spaces and ampersands and
// converts them to values that google is expecting.

// $searchurl is the url to find - ie www.web-max.ca
// Do not pass http:// - you don't need it.

// $searchquery = "ontario inns";
// $searchurl = "www.selectontarioinns.com";

if(!empty($searchquery) && !empty($searchurl))
{
$query = str_replace(" ","+",$searchquery);
$query = str_replace("%26","&",$query);

// How many results to search through.
$total_to_search = 100;

// The number of hits per page.
$hits_per_page = 10;

// Obviously, the total pages / queries we will be doing is
// $total_to_search / $hits_per_page

// This will be our rank
$position = 0;

// This is the rank minus the duplicates
$real_position = 0;
$found = NULL;
$lastURL = NULL;

for($i=0;$i<$total_to_search && empty($found);$i+=$hits_per_page)
{
// Open the search page.
// We are filling in certain variables -
// $query,$hits_per_page and $start.

$filename = "http://www.google.com/search?as_q=$query".
"&num=$hits_per_page&hl=en&ie=UTF-8&btnG=Google+Search".
"&as_epq=&as_oq=&as_eq=&lr=&as_ft=i&as_filetype=".
"&as_qdr=all&as_nlo=&as_nhi=&as_occt=any&as_dt=i".
"&as_sitesearch=&safe=images&start=$i";

$file = fopen($filename, "r");
if (!$file)
{
echo "<p>Unable to open remote file $filename.n";
}
else
{

// Now load the file into a variable line at a time
while (!feof($file))
{
$var = fgets($file, 1024);
// Try and find the font tag google uses to show the site URL
if(eregi("<font color=#008000>(.*)</font><nobr>",$var,$out))
{
// If we find it take out any <B> </B> tags - google does
// highlight search terms within URLS
$out[1] = strtolower(strip_tags($out[1]));
// Get the domain name by looking for the first /
$x = strpos($out[1],"/");
// and get the URL
$url = substr($out[1],0,$x);
$position++;
// If you want to see the hits, set $trace to something
if($trace)print($url."<br>");
// If the last result process is the same as this one, it
// is a nest or internal domain result, so don't count it
// on $real_position
if(strcmp($lastURL,$url)<>0)$real_position++;
$lastURL = $url;
// Else if the sites match we have found it!!!
if(strcmp($searchurl,$url)==0)
{
$found = $position;

// We quit out, we don't need to go any further.

break;
}
}
}
}
fclose($file);
}
if($found)
{
print("The URL $searchurl is at position $found ".
"( $real_position ) for the term $searchquery");
}
}
?>

Reference : www.tizag.com/phpT/examples

Microsoft

sky.dodiya@gmail.com (SKY) — Tue, 01 Jul 2008 03:54:00 +0000

Damn, Bill, you have come a LONG way. Look at you there back in '82, you handsome devil. As part of our tribute, let's take a quick look back at the top ten greatest (and not so great) products created on Bill-time, shall we? Don't worry, it'll only sting a little.
HITS
Internet Explorer (IE)
Introduced 1995

It's really easy to simply remember "Internet Exploder" as the standards-breaking, web-forking, buggy, monopoly-causing app that helped shape Bill's old image as the evilest baron of all technology companies. But it's also the app that led to the creation Ajax-based web apps through the XMLHttpRequest spec, and the kludgey early popularization of CSS. Love it or hate it, IE's gotten more people on the web over the years than any browser, and that's definitely got to count for something.

Media Center
Introduced 2002
Despite TiVo's DVR dominance and competitors that came and went over the years, Media Center has always been an underrated standout product. Even Bill admits that the company's long struggled with usability, but Media Center is a beacon of hope not only for 10-foot UIs everywhere, but also for the company's ability to create powerful, advanced, user-friendy products. Between its online integration, extensible plugin architecture, ability to stream shows to nodes around the house, and now CableCARD support, the only real downside to Media Center is the fact that you still need a full-blown PC to run it.
MS-DOS
Introduced 1981, discontinued 2000
It was arcane and nigh-unusable to mere mortals -- but the early cash-cow was one of Bill's most strategic moves, and helped Microsoft define the concept of software licensing. It also helped launched Mossberg's career as crusader of user-friendly technology. But most importantly, MS-DOS was still the OS an entire generation grew up learning, so del crticsm.* for a second because our autoexec.bat and config.sys were so very well crafted, and extensively tweaking Memmaker for a few extra KB of usable RAM definitely ranks amongst our top most formative geek moments.
Office
Introduced 1989 (on Mac), 1990 (on PC)
Word, Excel and PowerPoint certainly did well enough on their own, but when Microsoft combined 'em into the tidy (and pricey) package that is Office -- first on the Mac in 1989, interestingly -- it had a selling point that would prove irresistible to many a productivity-obsessed middle manager even today. The addition of Outlook and its support for the (for some) nigh-indispensable Exchange only further solidified its foothold in the corporate computing world, and that's where Bill knew the real money was. That's certainly not to say that it hasn't been without its share of problems and annoyances, though -- we're looking at you, Clippy.
Peripherals
Introduced 1982
Microsoft has always been a software company first, but it's been cranking out high-quality peripherals for over 25 years -- long before the Xbox and Zune were even a twinkle in Bill's eye. Not only that, but it's been a reliable innovator in the field, with a string of devices that were first, early, or just simply popularized technologies like the wheel mouse, force-feedback joysticks and controllers, the modern optical mouse, and the ergo-keyboard. The division has gone through some bumpy times -- the SideWinder line was killed off for a while there, and there've been some questionable designs along the way -- but it's been riding high as of late, and it doesn't show any signs of slowing down soon.
Windows 3.1 / NT 3.5
Introduced 1992 and 1994
It took a few versions to come into its own, but by the time Windows hit 3.1, Microsoft finally had a product that was able to pull PC users away from the command line (for some of the time, at least) and give them a real taste of things to come. Windows NT may not have had quite the same appeal with the average consumer, but it did bring the operating system into the 32-bit world and pave the way for enterprise desktop computing as we know it today. (Plus, it had the NT file system (NTFS), which to this day continues to carry on the legacy in its own little way.) We really wish they'd made a sequel to the Pirates of Silicon Valley, because we'd love to have seen the dramatization of Bill overseeing the first popularized verions of Windows -- especially '95, which came out just a couple of years later.
Windows 2000 and XP
Introduced 2000
When thinking of Microsoft and the new millennium, few people are able to keep the crinkles out of their nose. Thankfully, Windows ME wasn't the only thing that arrived in late Y2K, as Windows 2000 rushed in to rock the socks off of suits everywhere. The whole Win2K thing went over so well that Gates and company decided to base its next consumer OS, XP, off of it. Some may argue that the resulting product still stands as the last great OS to ship out of Redmond.
Windows CE / Mobile
Introduced 1996
As two of the most ubiquitous projects to come out from under Bill's command, both Windows CE and Windows Mobile are almost impossible to avoid when it comes to handhelds or phones. What began as a mishmash of small components has grown into the adaptable -- though sometimes maddening -- mobile OS that resides on just about every kind of device you can think of. Really, we mean every kind of device, from PMPs to enterprise-level stock-keeping systems. The slimmed down and restructured micro-Windows is at the very least one of the more flexible offerings the company has ever produced. Say what you will about its usability, there's no denying the massive impact it's had on portability and convergence.
Xbox and Xbox 360
Introduced 2001 and 2005
Back in 1999, Bill was all about multimedia convergence, and he said that a new gaming / multimedia device would be Microsoft's trojan horse into the world's living rooms with something coined the "DirectX-box." In 2001, the original Xbox entered gaming territory dominated by Sony's PlayStation with Nintendo's N64. But the clunky machine brought with it the first easy to use multiplayer console service, Xbox Live, as well as a developer-centric model that helped turn the tables. Of course, things look quite a bit different today: the Xbox 360 leads the former market leader's PlayStation 3 in spend and attach rate, and with the relative success of media and content sales on Xbox Live, it seems Bill's dream of dominating the living room wasn't just a pipe-dream after all.
Visual Basic
Introduced 1991, discontinued 1998
It's hard to underestimate the impact of Visual Basic. While the average user might have never heard of the original VB that Microsoft released way back when, the simplicity of the language and its graphical toolset made just about any power user a potential app developer, powering the flood of third party application development Microsoft operating systems enjoyed throughout the 90's. Sadly, Visual Basic met its demise at the hands of more modern languages and toolsets, but with a legacy of making programming accessible to the masses, its place in the history books and in Bill's pocketbook is undoubtedly secure.

Runners-up: DirectX, Flight Sim, Portable Media Center, Solitaire and Minesweeper

MISSIES
Auto PC
Introduced 1998, discontinued 2001*
Riding high on its previously-introduced sister products -- the Handheld PC and Palm PC platforms, now dead and transformed into Windows Mobile, respectively -- Microsoft's Auto PC initiative was promised to herald a revolution for in-car entertainment and productivity. There's no question it was well ahead of its time; in fact, many of the features debuted in Auto PC have gone on to become standard fare in today's cars. Problem was, when it launched your ride was already pimped with a mere CD player. In-car navigation, voice recognition, and MP3 support were still the stuff of science fiction in those dark days (particularly at the four-digit asking price), and the whole thing was doomed to a geeky, spendy niche. Though products were initially expected from several manufacturers, Clarion ended up being the only one to actually produce a head unit.

*The Auto PC lived on in spirit as Clarion's Joyride, but Microsoft's heart was no longer in the project and Clarion had switched to a generic Windows CE-based core to build the product.
Microsoft Bob
Introduced 1995, discontinued 1996
Poor Bob. No one ever gave him a chance. Maybe it had to do with the fact that he was really annoying. And as it turns out, Bill was dating Melinda French, Bob's program manager. Which isn't to say there was any nepotism involved -- Bob suffered an early death in 1996 due to general hatred for the little bastard. Bill offered this to a column in January, 1997, "Unfortunately, [Bob] demanded more performance than typical computer hardware could deliver at the time and there wasn't an adequately large market. Bob died." Thankfully, Billinda's blossoming relationship lived on. Oh, did you hear? They're like the world's greatest philanthropists now.
Cairo
Introduced 1991 (but never released)
Ask folks to pick one word to describe Microsoft's technology roadmap in the 1990s and you'll commonly get "Cairo" in response. Announced before Windows NT 3.1 was even released, Cairo was occasionally an operating system, occasionally a collection of new technologies -- it depended entirely upon who and when you asked -- but at its core, it was intended to guide Microsoft on the path beyond the architecture introduced by NT. After throwing countless dollars and man-hours at the ambitious project, Cairo was ultimately canned (though mentions of the storied buzzword continued even into this decade). Although Windows 2000 eventually became NT's heir apparent, the fruits of Microsoft's labor weren't entirely for naught, as various Cairo features found themselves implanted into various versions of Windows throughout the years. Even the WinFS file system can trace its roots back to the project -- fitting, because it too has become such an albatross.

MSN Music and URGE
Introduced 2004 and 2006, both fully discontinued 2008
When MSN Music -- Microsoft's effort to build its own PlaysForSure-based subscription music based store -- imploded, headstrong Bill did what he usually does: rebrand, and launch again. When he got up at CES 2006 and announced MSN Music would become URGE with MTV, we were all a little skeptical -- after all, the problem wasn't really the service, it was the overbearing DRM and the fact that consumers simply weren't ready for subscription music. Of course, eventually URGE died as well, and MTV shunted customers to Rhapsody America; naturally, Microsoft had a third PlaysForSure-based store waiting in the wings with Zune, which doesn't appear to be going anywhere any time soon.

Origami / UMPC
Introduced 2006
UMPCs... what can we say? Sure, Scoble liked them, but even from day one we never saw the market potential. Fueled by an early and too-successful hype-generating viral campaign of Microsoft's own making, there was no way that these first generation Origami devices would achieve their promise. Overpriced, underpowered, desk OS-laden (with Microsoft's Touch Pack add-on), and poor battery life would ensure that UMPCs would need quite some time to live up to the wave of "ultramobile lifestyle PC"-hysteria they rode to market. And as UMPCs begin to fade, the shrinking niche between smartphones and laptops now looks toward to the sweet release of MIDs -- though that's already been two years... and counting.
Windows ME
Introduced September 2000
It's not exactly clear what the point of Windows Millennium Edition was -- our guess is that Microsoft needed to keep up with that year-based product naming scheme it had going at the time, and cranked out this half-baked update to '98 in order to capitalize on the turn-of-the-millenium frenzy. Unlike the NT-based Windows 2000 released at the same time, Windows ME retained its MS-DOS-based core, while managing to somehow get even more slow and unstable than its predecessors 95 and 98. And to add insult to injury, it restricted access to shell mode, rendering many MS-DOS apps incompatible. Thankfully, Windows ME was only inflicted upon consumers for little over a year; it was replaced by indomitable Windows XP in 2001

OS/2
Dates: introduced 1987, discontinued 2006
What began as a collaboration between Microsoft and then-partner IBM blossomed into what looked like -- for a time at least -- the logical successor to the DOS / Windows empire. The advanced OS showed early signs of greatness with it's incorporation of the HPFS file system, improved networking capabilities, and a sophisticated UI. But cracks in the relationship between the two powerhouse corporations would ultimately lead to its downfall. With Windows 3 a sudden success, IBM's reluctance to go hardware neutral, and Microsoft's increasing displeasure with code which it called "bloated" (ahem!), the project was eventually swept aside by Gates and the gang to make way for what would become the omnipresent operating system you know and love and/or hate today.

SPOT watches and MSN Direct
Introduced 2004, discontinued 2008
When the concept of an information-enabled watch that automagically received content over unused FM radio subcarriers was first conjured up by Microsoft in the early part of the decade, it seemed like a fabulous idea. So much so, in fact, Bill personally took the project under his wing. But by the time it had launched, it was already doomed by a perfect storm of problems: the devices were uglier than sin and comically oversized, the bizarre ad campaign featured frighteningly hairy cartoon arms, and -- as the mobile web was just starting to pick up steam at that time -- virtually anyone who would've been interested in that kind of product had already discovered ways to get the same information from their phone. The underlying data network Microsoft built out to support the watches, MSN Direct, lives on to this day and sees plenty of use in Garmin's nüvi line, but will it ever be used to beam weather, news, and MSFT stock reports to wrists other than Bill's? Not bloody likely.

Windows Activation
Introduced 2001
Depending on who you talk to, Windows Product Activation is a serious privacy violation, a headache, minimal protection against piracy, or all of the above. Lucky for us, Microsoft is finally seeing (some of) the folly of its overbearing ways, and has gone with a more permissive nagware method with Vista SP1. This as opposed to the regular method of routinely locking users out of their systems, which, wouldn't you know it, tended to hurt legitimate users more than pirates. Perhaps the best example of Windows Activation's legacy was the great WGA outage of 2007, which left 12,000 systems out in the cold due to a few downed servers at Microsoft. It didn't take long for the servers to bounce back, but any shred of reputation the service had at that point went out the window with the uptime.

Windows Vista
Introduced 2007
Vista doesn't suck. Let's just get that off our chests. In fact, it's a quite capable, secure and sexy OS when you get right down to it. Unfortunately, its problems just loomed too large for many folks to overlook. A multitude of delays and a rapidly diminishing feature list soured people right out of the gate, and once the dust settled people just weren't happy with the minor improvements they were getting in exchange for their hard-earned monies and fairly mandatory RAM upgrades. Mix that in with the standard driver incompatibilities of any Microsoft OS upgrade, and you've got a whole bunch of disgruntled downgraders on your hands -- and plenty of bad press to fill in any remaining gaps. Sadly, improvements to Media Center, aesthetics and even that quirky little sidebar got overlooked in the process. Microsoft's already scrambling to get Windows 7 together to capture the multitude of users that've decided to skip Vista altogether, let's just hope it's not too late.

Runners-up: Actimates, Pocket IE, Games for Windows - Live, Xenix (yeah, Microsoft actually did a Unix at one time!)

Ajax

sky.dodiya@gmail.com (SKY) — Tue, 01 Jul 2008 03:10:00 +0000

AJAX = Asynchronous JavaScript And XML

AJAX is an acronym for Asynchronous JavaScript And XML.

AJAX is not a new programming language, but simply a new technique for creating better, faster, and more interactive web applications.

AJAX uses JavaScript to send and receive data between a web browser and a web server.

The AJAX technique makes web pages more responsive by exchanging data with the web server behind the scenes, instead of reloading an entire web page each time a user makes a change.

AJAX Is Based On Open Standards

AJAX is based on the following open standards:

* JavaScript
* XML
* HTML
* CSS

The open standards used in AJAX are well defined, and supported by all major browsers. AJAX applications are browser and platform independent. (Cross-Platform, Cross-Browser technology)

AJAX Is About Better Internet Applications

Web applications have many benefits over desktop applications:

* they can reach a larger audience
* they are easier to install and support
* they are easier to develop

However, Internet applications are not always as “rich” and user-friendly as traditional desktop applications.

With AJAX, Internet applications can be made richer (smaller, faster, and easier to use).

You Can Start Using AJAX Today

There is nothing new to learn.

AJAX is based on open standards. These standards have been used by most developers for several years.

Most existing web applications can be rewritten to use AJAX technology instead of traditional HTML forms.

AJAX Uses XML And HTTP Requests

A traditional web application will submit input (using an HTML form) to a web server. After the web server has processed the data, it will return a completely new web page to the user.

Because the server returns a new web page each time the user submits input, traditional web applications often run slowly and tend to be less user friendly.

With AJAX, web applications can send and retrieve data without reloading the whole web page. This is done by sending HTTP requests to the server (behind the scenes), and by modifying only parts of the web page using JavaScript when the server returns data.

XML is commonly used as the format for receiving server data, although any format, including plain text, can be used.

You will learn more about how this is done in the next chapters of this tutorial.

The XMLHttpRequest

The XMLHttpRequest object is the key to AJAX.

It has been available ever since Internet Explorer 5.5 was released in July 2000, but not fully discovered before people started to talk about AJAX and Web 2.0 in 2005.

Creating An XMLHttpRequest Object

Different browsers use different methods to create an XMLHttpRequest object.

Internet Explorer uses an ActiveXObject.

Other browsers uses a built in JavaScript object called XMLHttpRequest.

Here is the simplest code you can use to overcome this problem:

var XMLHttp=null
if (window.XMLHttpRequest)
{
XMLHttp=new XMLHttpRequest()
}
else if (window.ActiveXObject)
{
XMLHttp=new ActiveXObject(”Microsoft.XMLHTTP”)
}

Example above explained:

1. First create a variable XMLHttp to use as your XMLHttpRequest object. Set the value to null.
2. Then test if the object window.XMLHttpRequest is available. This object is available in newer versions of Firefox, Mozilla, Opera, and Safari.
3. If it’s available, use it to create a new object: XMLHttp=new XMLHttpRequest()
4. If it’s not available, test if an object window.ActiveXObject is available. This object is available in Internet Explorer version 5.5 and later.
5. If it is available, use it to create a new object: XMLHttp=new ActiveXObject()

A Better Example?

Some programmers will prefer to use the newest and fastest version of the XMLHttpRequest object.

The example below tries to load Microsoft’s latest version “Msxml2.XMLHTTP”, available in Internet Explorer 6, before it falls back to “Microsoft.XMLHTTP”, available in Internet Explorer 5.5 and later.

function GetXmlHttpObject()
{
var xmlHttp=null;

try
{
// Firefox, Opera 8.0+, Safari
xmlHttp=new XMLHttpRequest();
}
catch (e)
{
// Internet Explorer
try
{
xmlHttp=new ActiveXObject(”Msxml2.XMLHTTP”);
}
catch (e)
{
xmlHttp=new ActiveXObject(”Microsoft.XMLHTTP”);
}
}
return xmlHttp;
}

Example above explained:

1. First create a variable XMLHttp to use as your XMLHttpRequest object. Set the value to null.
2. Try to create the object the according to web standards (Mozilla, Opera and Safari):XMLHttp=new XMLHttpRequest()
3. Try to create the object the Microsoft way, available in Internet Explorer 6 and later:XMLHttp=new ActiveXObject(”Msxml2.XMLHTTP”)
4. If this catches an error, try the older (Internet Explorer 5.5) way: XMLHttp=new ActiveXObject(”Microsoft.XMLHTTP”)

PHP and AJAX

There is no such thing as an AJAX server.

AJAX is a technology that runs in your browser. It uses asynchronous data transfer (HTTP requests) between the browser and the web server, allowing web pages to request small bits of information from the server instead of whole pages.

AJAX is a web browser technology independent of web server software.

However, in this tutorial we will focus more on actual examples running on a PHP server, and less on how AJAX works.
AJAX Suggest

In the AJAX example below we will demonstrate how a web page can communicate with a web server online as a user enters data into a web form.

Type a Name in the Box Below

First Name: Suggestions:

This example consists of three pages:

* a simple HTML form
* a JavaScript
* a PHP page

The HTML Form

This is the HTML page. It contains a simple HTML form and a link to a JavaScript:

<html>
<head>
<script src=”clienthint.js”></script>
</head>
<body>
<form>
First Name:
<input type=”text” id=”txt1″
onkeyup=”showHint(this.value)”>
</form>
<p>Suggestions: <span id=”txtHint”></span></p>
</body>
</html>

Example Explained - The HTML Form

As you can see, the HTML page above contains a simple HTML form with an input field called “txt1″.

The form works like this:

1. An event is triggered when the user presses, and releases a key in the input field
2. When the event is triggered, a function called showHint() is executed.
3. Below the form is a called “txtHint”. This is used as a placeholder for the return data of the showHint() function

The JavaScript

The JavaScript code is stored in “clienthint.js” and linked to the HTML document:

var xmlHttp

function showHint(str)
{
if (str.length==0)
{
document.getElementById(”txtHint”).innerHTML=”"
return
}
xmlHttp=GetXmlHttpObject()
if (xmlHttp==null)
{
alert (”Browser does not support HTTP Request”)
return
}
var url=”gethint.php”
url=url+”?q=”+str
url=url+”&sid=”+Math.random()
xmlHttp.onreadystatechange=stateChanged
xmlHttp.open(”GET”,url,true)
xmlHttp.send(null)
}

function stateChanged()
{
if (xmlHttp.readyState==4 || xmlHttp.readyState==”complete”)
{
document.getElementById(”txtHint”).innerHTML=xmlHttp.responseText
}
}

function GetXmlHttpObject()
{
var xmlHttp=null;
try
{
// Firefox, Opera 8.0+, Safari
xmlHttp=new XMLHttpRequest();
}
catch (e)
{
// Internet Explorer
try
{
xmlHttp=new ActiveXObject(”Msxml2.XMLHTTP”);
}
catch (e)
{
xmlHttp=new ActiveXObject(”Microsoft.XMLHTTP”);
}
}
return xmlHttp;

Example Explained

The showHint() Function

This function executes every time a character is entered in the input field.

If there is some input in the text field (str.length > 0) the function executes the following:

1. Defines the url (filename) to send to the server
2. Adds a parameter (q) to the url with the content of the input field
3. Adds a random number to prevent the server from using a cached file
4. Calls on the GetXmlHttpObject function to create an XMLHTTP object, and tells the object to execute a function called stateChanged when a change is triggered
5. Opens the XMLHTTP object with the given url.
6. Sends an HTTP request to the server

If the input field is empty, the function simply clears the content of the txtHint placeholder.

The stateChanged() Function

This function executes every time the state of the XMLHTTP object changes.

When the state changes to 4 (or to “complete”), the content of the txtHint placeholder is filled with the response text.

The GetXmlHttpObject() Function

AJAX applications can only run in web browsers with complete XML support.

The code above called a function called GetXmlHttpObject().

The purpose of the function is to solve the problem of creating different XMLHTTP objects for different browsers.

This is explained in the previous chapter.

The PHP Page

The server page called by the JavaScript code is a simple PHP file called “gethint.php”.

The code in the “gethint.php” checks an array of names and returns the corresponding names to the client:

<?php
// Fill up array with names
$a[]=”Anna”;
$a[]=”Brittany”;
$a[]=”Cinderella”;
$a[]=”Diana”;
$a[]=”Eva”;
$a[]=”Fiona”;
$a[]=”Gunda”;
$a[]=”Hege”;
$a[]=”Inga”;
$a[]=”Johanna”;
$a[]=”Kitty”;
$a[]=”Linda”;
$a[]=”Nina”;
$a[]=”Ophelia”;
$a[]=”Petunia”;
$a[]=”Amanda”;
$a[]=”Raquel”;
$a[]=”Cindy”;
$a[]=”Doris”;
$a[]=”Eve”;
$a[]=”Evita”;
$a[]=”Sunniva”;
$a[]=”Tove”;
$a[]=”Unni”;
$a[]=”Violet”;
$a[]=”Liza”;
$a[]=”Elizabeth”;
$a[]=”Ellen”;
$a[]=”Wenche”;
$a[]=”Vicky”;

//get the q parameter from URL
$q=$_GET["q"];

//lookup all hints from array if length of q>0
if (strlen($q) > 0)
{
$hint=”";
for($i=0; $i<count($a); $i++)
{
if (strtolower($q)==strtolower(substr($a[$i],0,strlen($q))))
{
if ($hint==””)
{
$hint=$a[$i];
}
else
{
$hint=$hint.” , “.$a[$i];
}
}
}
}

//Set output to “no suggestion” if no hint were found
//or to the correct values
if ($hint == “”)
{
$response=”no suggestion”;
}
else
{
$response=$hint;
}

//output the response
echo $response;
?>

If there is any text sent from the JavaScript (strlen($q) > 0) the following happens:

1. Find a name matching the characters sent from the JavaScript
2. If more than one name is found, include all names in the response string
3. If no matching names were found, set response to “no suggestion”
4. If one or more matching names were found, set response to these names
5. The response is sent to the “txtHint” placeholder

}

HTML 5

sky.dodiya@gmail.com (SKY) — Thu, 26 Jun 2008 02:29:00 +0000

HTML 5 differences from HTML 4

Abstract

HTML 5 defines the fifth major revision of the core language of the World Wide Web, HTML. "HTML 5 differences from HTML 4" describes the differences between HTML 4 and HTML 5 and provides some of the rationale for the changes. This document may not provide accurate information as the HTML 5 specification is still actively in development. When in doubt, always check the HTML 5 specification itself. [HTML5]

Status of this Document

This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of this technical report can be found in the W3C technical reports index at http://www.w3.org/TR/.

This is a Working Draft produced by the HTML Working Group, part of the HTML Activity. The Working Group intends to publish this document as a Working Group Note to accompany the HTML 5 specification. The appropriate forum for comments is public-html-comments@w3.org, a mailing list with a public archive.

Publication as a Working Draft does not imply endorsement by the W3C Membership. This is a draft document and may be updated, replaced or obsoleted by other documents at any time. It is inappropriate to cite this document as other than work in progress.

This document was produced by a group operating under the 5 February 2004 W3C Patent Policy. W3C maintains a public list of any patent disclosures made in connection with the deliverables of the group; that page also includes instructions for disclosing a patent. An individual who has actual knowledge of a patent which the individual believes contains Essential Claim(s) must disclose the information in accordance with section 6 of the W3C Patent Policy.

1. Introduction

HTML has been in continuous evolution since it was introduced to the Internet in the early 1990's. Some features were introduced in specifications; others were introduced in software releases. In some respects, implementations and author practices have converged with each other and with specifications and standards, but in other ways, they continue to diverge.

HTML 4 became a W3C Recommendation in 1997. While it continues to serve as a rough guide to many of the core features of HTML, it does not provide enough information to build implementations that interoperate with each other and, more importantly, with a critical mass of deployed content. The same goes for XHTML1, which defines an XML serialization for HTML 4, and DOM Level 2 HTML, which defines JavaScript APIs for both HTML and XHTML. [HTML4] [XHTML1] [DOM2HTML]

The HTML 5 draft reflects an effort, started in 2004, to study contemporary HTML implementations and deployed content. The draft:

Defines a single language called HTML 5 which can be written in a "custom" HTML syntax and in XML syntax.
Defines detailed processing models to foster interoperable implementations.
Improves markup for documents.
Introduces markup and APIs for emerging idioms, such as Web applications.
HTML 4 and HTML 5 structure left T0 right

1.1 Open Issues

HTML 5 is still a draft. The contents of HTML 5, as well as the contents of this document which depend on HTML 5, are still being discussed on the HTML Working Group and WHATWG mailing lists. Some of the open issues include (this list is not exhaustive):

De facto semantic definitions for some formerly presentational elements.
Details of accessibility and media-independence features, such as the longdesc, alt and summary attributes.
The repetition model.

1.2 Backwards Compatible

HTML 5 is defined in a way that it is backwards compatible with the way user agents handle deployed content. To keep the authoring language relatively simple for authors several elements and attributes are not included as outlined in the other sections of this document, such as presentational elements that are better dealt with using CSS.

User agents, however, will always have to support these older elements and this is why the specification clearly separates requirements for authors and user agents. This means that authors can not use the isindex or plaintext element, but user agents are required to support them in a way that is compatible with how these elements behaved previously.

Since HTML 5 has separate conformance requirements for authors and user agents there is no longer a need for marking things "deprecated".

1.3 Development Model

The HTML 5 specification will not be considered finished before there are at least two complete implementations of the specification. This is a different approach than previous versions of HTML had. The goal is to ensure that the specification is implementable and usable by designers and developers once it is finished.

1.4 Impact on Web Architecture

The following areas / features defined in HTML 5 are believed to impact the Web architecture:

The use of the DOM as a basis for defining the language.
The concept of browsing contexts.
The distinction between user agent requirements and authoring requirements.
The use of imperative definitions rather than abstract definitions with the requirement of black-box equivalence in implementations.
The new content model concepts (replacing HTML 4's block and inline concepts).
The focus on accessibility as a built-in concept for new features (such as the irrelevant attribute, the progress element, et cetera) instead of an add-on (like the alt attribute).
The focus on defining the semantics in detail (e.g. the outline algorithm, replacing the vague semantics in HTML 4).
The server-sent events feature (the event-source element).
The datagrid element.
The menu and command elements.
The origin concept.
Offline Web application caches.
The definition of the browsing context "navigation" algorithm and the related session history traversal algorithms.
The content-type sniffing and character encoding sniffing.
The very explicit definition of a parser.
The two structured storage features.
The contentEditable feature and the UndoManager feature.
The Drag and Drop and Copy and Paste architecture.
The cross-document messaging feature (the postMessage API).
The new sandboxing features for iframe.

2. Syntax

The HTML 5 language has a "custom" HTML syntax that is compatible with HTML 4 and XHTML1 documents published on the Web, but is not compatible with the more esoteric SGML features of HTML 4, such as . Documents using this "custom" syntax must be served with the text/html MIME type.

HTML 5 also defines detailed parsing rules (including "error handling") for this syntax which are largely compatible with popular implementations. User agents will follow these rules for resources that have the text/html MIME type. Here is an example document that conforms to the HTML syntax:

<!doctype html>
<html>
<head>
<meta charset="UTF-8">
<title>Example document</title>
</head>
<body>
<p>Example paragraph</p>
</body>
</html>

The other syntax that can be used for HTML 5 is XML. This syntax is compatible with XHTML1 documents and implementations. Documents using this syntax need to be served with an XML MIME type and elements need to be put in the http://www.w3.org/1999/xhtml namespace following the rules set forth by the XML specifications. [XML]

Below is an example document that conforms to the XML syntax of HTML 5. Note that XML documents must have an XML MIME type such as application/xhtml+xml or application/xml.

<?xml version="1.0" encoding="UTF-8"?>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>Example document</title>
</head>
<body>
<p>Example paragraph</p>
</body>
</html>

2.1 Character Encoding

For the HTML syntax of HTML 5 authors have three means of setting the character encoding:

At the transport level. By using the HTTP Content-Type header for instance.
Using a Unicode Byte Order Mark (BOM) character at the start of the file. This character provides a signature for the encoding used.
Using a meta element with a charset attribute that specifies the encoding as the first element child of the head element.<meta charset="UTF-8"> could be used to specify the UTF-8 encoding. This replaces the need for <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

For the XML syntax authors have to use the rules as set forth in the XML specifications to set the character encoding.

2.2 The `DOCTYPE`

The HTML syntax of HTML 5 requires a DOCTYPE to be specified to ensure that the browser renders the page in standards mode. The DOCTYPE has no other purpose and is therefore optional for XML. Documents with an XML MIME type are always handled in standards mode. [DOCTYPE]

The DOCTYPE declaration is<!DOCTYPE html> and is case-insensitive in the HTML syntax. DOCTYPEs from earlier versions of HTML were longer because the HTML language was SGML based and therefore required a reference to a DTD. With HTML 5 this is no longer the case and the DOCTYPE is only needed to enable standards mode for documents written using the HTML syntax. Browsers already do this for <!DOCTYPE html>.

2.3 Miscellaneous

There are a few other syntax changes worthy of mentioning:

HTML now has native support for IRIs. In HTML 4 this was only handled as error handling.
The lang attribute takes the empty string in addition to a valid language identifier, just like xml:lang does in XML.

3. Language

This section is split up in several subsections to more clearly illustrate the various differences there are between HTML 4 and HTML 5.

3.1 New Elements

The following elements have been introduced for better structure:

section represents a generic document or application section. It can be used together with h1-h6 to indicate the document structure.
article represents an independent piece of content of a document, such as a blog entry or newspaper article.
aside represents a piece of content that is only slightly related to the rest of the page.
header represents the header of a section.
footer represents a footer for a section and can contain information about the author, copyright information, et cetera.
nav represents a section of the document intended for navigation.
dialog can be used to mark up a conversation like this:
<dialog> <dt> Costello <dd> Look, you gotta first baseman? <dt> Abbott <dd> Certainly. <dt> Costello <dd> Who's playing first? <dt> Abbott <dd> That's right. <dt> Costello <dd> When you pay off the first baseman every month, who gets the money? <dt> Abbott <dd> Every dollar of it. </dialog>figure can be used to associate a caption together with some embedded content, such as a graphic or video:

figure can be used to associate a caption together with

some embedded content, such as a graphic or video:

<figure>

<video src=ogg>…</video>

<legend>Example</legend>

</figure>

Then there are several other new elements:

audio and video for multimedia content. Both provide an API so application authors can script their own user interface, but there is also a way to trigger a user interface provided by the user agent. source elements are used together with these elements if there are multiple streams available of different types.
embed is used for plugin content.
mark represents a run of marked text.
meter represents a measurement, such as disk usage.
time represents a date and/or time.
canvas is used for rendering dynamic bitmap graphics on the fly, such as graphs, games, et cetera.
command represents a command the user can invoke.
datagrid represents an interactive representation of a tree list or tabular data.
details represents additional information or controls which the user can obtain on demand.
datalist together with the a new list attribute for input is used to make comboboxes:
<input list=browsers>
<datalist id=browsers>
<option value="Safari">
<option value="Internet Explorer">
<option value="Opera">
<option value="Firefox">
</datalist>
The datatemplate, rule and nest elements provide a templating mechanism for HTML.
event-source is used to "catch" server sent events.
output represents some type of output, such as from a calculation done through scripting.
progress represents a completion of a task, such as downloading or when performing a series of expensive operations.
The ruby, rt and rb elements allow for marking up ruby annotations.

The input element's type attribute now has the following new values:

datetime
datetime-local
date
month
week
time
number
range
email
url

The idea of these new types is that the user agent can provide the user interface, such as a calendar date picker or integration with the user's address book and submit a defined format to the server. It gives the user a better experience as his input is checked before sending it to the server meaning there is less time to wait for feedback.

3.2 New Attributes

HTML 5 has introduced several new attributes to various elements that were already part of HTML 4:

The a and area elements now have a media attribute for consistency with the link element. It is purely advisory.
The a and area elements have a new attribute called ping that specifies a space separated list of URIs which have to be pinged when the hyperlink is followed. Currently user tracking is mostly done through redirects. This attribute allows the user agent to inform users which URIs are going to be pinged as well as giving privacy-conscious users a way to turn it off.
The area element, for consistency, now has the hreflang and rel attributes.
The base element can now have a target attribute as well mainly for consistency with the a element and because it was already widely supported. Also, the target attribute for the a and area elements is no longer deprecated, as it is useful in Web applications, for example in conjunction with iframe.
The value attribute for the li element is no longer deprecated as it is not presentational. The same goes for the start attribute of the ol element.
The meta element has a charset attribute now as this was already supported and provides a nicer way to specify the character encoding for the document.
A new autofocus attribute can be specified on the input (except when the type attribute is hidden), select, textarea and button elements. It provides a declarative way to focus a form control during page load. Using this feature should enhance the user experience as the user can turn it off if he does not like it, for instance.
The new form attribute for input, output, select, textarea, button and fieldset elements allows for controls to be associated with more than a single form.
The input, button and form elements have a new replace attribute which affects what will be done with the document after a form has been submitted.
The form and select elements (as well as the datalist element) have a data attribute that allows for automatically prefilling of form controls, in case of form, or the form control, in case of select and datalist, with data from the server.
The new required attribute applies to input (except when the type attribute is hidden, image or some button type such as submit) and textarea. It indicates that the user has to fill in a value in order to submit the form.
The input and textarea elements have a new attribute called inputmode which gives a hint to the user interface as to what kind of input is expected.
You can now disable an entire fieldset by using the disabled attribute on it. This was not possible before.
The input element has several new attributes to specify constraints: autocomplete, min, max, pattern and step. As mentioned before it also has a new list attribute which can be used together with the datalist and select element.
input and button also have a new template attribute which can be used for repetition templates.
The menu element has three new attributes: type, label and autosubmit. They allow the element to transform into a menu as found in typical user interfaces as well as providing for context menus in conjunction with the global contextmenu attribute.
The style element has a new scoped attribute which can be used to enable scoped style sheets. Style rules within such a style element only apply to the local tree.
The script element has a new attribute called async that influences script loading and execution.
The html element has a new attribute called manifest that points to an application cache manifest used in conjunction with the API for offline Web applications.
The link element has a new attribute called sizes. It can be used in conjunction with the icon relationship (set through the rel attribute) to indicate the size of the referenced icon.
The ol element has a new attribute called reversed to indicate that the list order is descending when present.
The iframe element has two new attributes called seamless and sandbox which allow for sandboxing content, e.g. blog comments.

Several attributes from HTML 4 now apply to all elements. These are called global attributes: class, dir, id, lang, style, tabindex and title.

There are also several new global attributes:

The contenteditable attribute indicates that the element is an editable area. The user can change the contents of the element and manipulate the markup.
The contextmenu attribute can be used to point to a context menu provided by the author.
The draggable attribute can be used together with the new drag & drop API.
The irrelevant attribute indicates that an element is not yet, or is no longer, relevant.
The ref, registrationmark and template global attributes complement the data template feature.
The data-* collection of author defined attributes. Authors can define any attribute they want as long as they prefix it with data- to avoid clashes with future versions of HTML. The only requirement on these attributes is that they are not used for user agent extensions.

The following are the attributes for the repetition model. These are global attributes and as such may be used on all HTML elements, or on any element in any other namespace, with the attributes being in the http://www.w3.org/1999/xhtml namespace.:

repeat
repeat-start
repeat-min
repeat-max

HTML 5 also makes all event handler attributes from HTML 4 that take the form onevent-name global attributes and adds several new event handler attributes for new events it defines, such as the onmessage attribute which can be used together with the new event-source element and the cross-document messaging API.

3.3 Changed Elements

These elements have slightly modified meanings in HTML 5 to better reflect how they are used on the Web or to make them more useful:

The a element without an href attribute now represents a "placeholder link".
The address element is now scoped by the new concept of sectioning.
The b element now represents a span of text to be stylistically offset from the normal prose without conveying any extra importance, such as key words in a document abstract, product names in a review, or other spans of text whose typical typographic presentation is emboldened.
The hr element now represents a paragraph-level thematic break.
The i element now represents a span of text in an alternate voice or mood, or otherwise offset from the normal prose, such as a taxonomic designation, a technical term, an idiomatic phrase from another language, a thought, a ship name, or some other prose whose typical typographic presentation is italicized. Usage varies widely by language.
For the label element the browser should no longer move focus from the label to the control unless such behaviour is standard for the underlying platform user interface.
The menu element is redefined to be useful for actual menus.
The small element now represents small print (for side comments and legal print).
The strong element now represents importance rather than strong emphasis.
Quotation marks for the q element are now to be provided by the author rather than the user agent.

3.4 Absent Elements

The elements in this section are not to be used by authors. User agents will still have to support them and HTML 5 will get a rendering section in due course that says exactly how. (The isindex element for instance is already supported by the parser.)

The following elements are not in HTML 5 because their effect is purely presentational and therefore better handled by CSS:

basefont
big
center
font
s
strike
tt
u

The following elements are not in HTML 5 because their usage affected usability and accessibility for the end user in a negative way:

frame
frameset
noframes

The following elements are not included because they have not been used often, created confusion or can be handled by other elements:

acronym is not included because it has created lots of confusion. Authors are to use abbr for abbreviations.
applet has been obsoleted in favor of object.
isindex usage can be replaced by usage of form controls.
dir has been obsoleted in favor of ul.

Finally the noscript is only conforming in the HTML syntax. It is not included in the XML syntax as its usage relies on an HTML parser.

3.5 Absent Attributes

Some attributes from HTML 4 are no longer allowed in HTML 5. If they need to have any impact on user agents for compatibility reasons it is defined how they should work in those scenarios.

accesskey attribute on a, area, button, input, label, legend and textarea.
rev and charset attributes on link and a.
shape and coords attributes on a.
longdesc attribute on img and iframe.
target attribute on link.
nohref attribute on area.
profile attribute on head.
version attribute on html.
name attribute on img, form and a (use id instead).
scheme attribute on meta.
archive, classid, codebase, codetype, declare and standby attributes on object.
valuetype and type attributes on param.
language attribute on script.
summary attribute on table.
axis and abbr attributes on td and th.
scope attribute on td.
headers attribute on th.

In addition, HTML 5 has none of the presentational attributes that were in HTML 4 as they are better handled by CSS:

align attribute on caption, iframe, img, input, object, legend, table, hr, div, h1, h2, h3, h4, h5, h6, p, col, colgroup, tbody, td, tfoot, th, thead and tr.
alink, link, text and vlink attributes on body.
background attribute on body.
bgcolor attribute on table, tr, td, th and body.
border attribute on table, img and object.
cellpadding and cellspacing attributes on table.
char and charoff attributes on col, colgroup, tbody, td, tfoot, th, thead and tr.
clear attribute on br.
compact attribute on dl, menu, ol and ul.
frame attribute on table.
frameborder attribute on iframe.
height attribute on td and th.
hspace and vspace attributes on img and object.
marginheight and marginwidth attributes on iframe.
noshade attribute on hr.
nowrap attribute on td and th.
rules attribute on table.
scrolling attribute on iframe.
size attribute on hr, input and select.
type attribute on li, ol and ul.
valign attribute on col, colgroup, tbody, td, tfoot, th, thead and tr.
width attribute on hr, table, td, th, col, colgroup and pre.

4. APIs

HTML 5 introduces a number of APIs that help in creating Web applications. These can be used together with the new elements introduced for applications:

2D drawing API which can be used with the new canvas element.
API for playing of video and audio which can be used with the new video and audio elements.
Persistent storage. Both key / value and a SQL database are supported.
An API that enables offline Web applications.
An API that allows a Web application to register itself for certain protocols or MIME types.
Editing API in combination with a new global contenteditable attribute.
Drag & drop API in combination with a draggable attribute.
Network API.
API that exposes the history and allows pages to add to it to prevent breaking the back button. (This API has the necessary security restrictions in place.)
Cross-document messaging.
Server-sent events in combination with the new event-source element.
Notification API to alert the user to new information, such as new e-mail messages in an e-mail application.

4.1 Extensions to `HTMLDocument`

HTML 5 has extended the HTMLDocument interface from DOM Level 2 HTML in a number of ways. The interface is now implemented on all objects implementing the Document interface so it stays meaningful in a compound document context. It also has several noteworthy new members:

getElementsByClassName() to select elements by their class name. The way this method is defined it will allow it to work for any content with class attributes and a Document object such as SVG and MathML.
innerHTML as an easy way to parse and serialize an HTML or XML document. This attribute was previously only available on HTMLElement in Web browsers and not part of any standard.
activeElement and hasFocus to determine which element is currently focused and whether the Document has focus respectively.
getSelection() which returns an object that represents the current selection(s).
designMode and execCommand() which are mostly used for editing of documents.

4.2 Extensions to `HTMLElement`

The HTMLElement interface has also gained several extensions in HTML 5:

getElementsByClassName() which is basically a scoped version of the one found on HTMLDocument.
innerHTML as found in Web browsers today. It is also defined to work in XML context (when it is used in an XML document).
classList is a convenient accessor for className. The object it returns exposes methods, such as has(), add(), remove() and toggle() for manipulating the element's classes. The a, area and link elements have a similar attribute called relList that provides the same functionality for the rel attribute.

5. HTML 5 Changelog

Below is a rough list of changes that have been made to the HTML 5 specification since the initial publication of the HTML 5 Working Draft. This changelog only indicates what has been changed. For more detailed discussion please use the public-html@w3.org and whatwg@whatwg.org mailing list archives. Changes that affect this document have been incorperated throughout.

Implementation and authoring details around the ping attribute have changed.
is now a conforming way to set the character encoding.
API for the canvas element has been cleaned up. Text support has been added.
globalStorage is now restricted to the same-origin policy and renamed to localStorage. Related event dispatching has been clarified.
postMessage() API changed. Only the origin of the message is exposed, no longer the URI. It also requires a second argument that indicates the origin of the target document.
Drag and drop API has got clarification. The dataTransfer object now has a types attribute indicating the type of data being transferred.
The m element is now called mark.
Server-sent events has changed and gotten clarification. It uses a new format so that older implementations are not broken.
The figure element no longer requires a caption.
The ol element has a new reversed attribute.
Character encoding detection has changed in response to feedback.
Various changes have been made to the HTML parser section in response to implementation feedback.
Various changes to the editing section have been made, including adding queryCommandEnabled() and related methods.
The headers attribute has been added for td elements.
The table element has a new createTBody() method.
MathML support has been added to the HTML parser section. (SVG support is still awaiting input from the SVG WG.)
Author defined attributes have been added. Authors can add attributes to elements in the form of data-name and can access these through the DOM using dataset[name] on the element in question.
The q element has changed to require punctation inside rather than having the browser render it.
The target attribute can now have the value _blank.
The showModalDialog API has been added.
The document.domain API has been defined.
The source element now has a new pixelratio attribute useful for videos that have some kind encoding error.
bufferedBytes, totalBytes and bufferingThrottled DOM attributes have been added to the video element.
Media begin event has been renamed to loadstart for consistency with the Progress Events specification.
charset attribute has been added to script.
The iframe element has gained the sandbox and seamless attributes which provide sandboxing functionality.
The ruby, rt and rp elements have been added to support ruby annotation.
A showNotification() method has been added to show notification messages to the user.
Support for beforeprint and afterprint events has been added.

Firefox 4

sky.dodiya@gmail.com (SKY) — Wed, 25 Jun 2008 06:19:00 +0000

Firefox 4 will push out the edges of the browser
By Rafe Needleman – March 27, 2008 3:45 PM PDT 25 comments

Chris Beard, VP Labs, Mozilla
(Credit: Rafe Needleman / CNET)

This post has been corrected from the original: Mozilla has no plan to ship Firefox 4 this year; references to that effect have been removed.

After the product road map roundtable I live-blogged Wednesday, I had a talk with Chris Beard, VP of Labs for Mozilla. Beard is working on the things you won\'t see in Firefox 3, but will, if he has his way, surface in Firefox 4.

Beard\'s philosophy is this: The browser needs to evolve. Beard believes the browser concept hasn\'t fundamentally changed in 10 years. It\'s still an isolated piece of software, he says. Mozilla Lab\'s push is to blur the edges of the browser, to make it both more tightly integrated with the computer it\'s running on, and also more hooked into Web services. So extended, the browser becomes an even more powerful and pervasive platform for all kinds of applications.

At the moment, these are two separate projects Mozilla is running to push out the edges of the browser: Prism and Weave.

Prism

Prism is Mozilla\'s shot at busting apps out of the browser. Part of the Prism project is making the browsing core available to apps developers so they can build products like Zimbra Desktop (review) that are essentially Web apps, but that don\'t look like it.

The dream is to be able to take any Web site or app and turn it into an app that can run directly from the desktop. A very big part of this initiative is to make sites/apps work when they are not connected to the Internet. HTML 5 (the next version of the basic standard for the encoding of Web sites) includes explicit support for local, offline resources.

HTML 5 and Prism will, Mozilla execs say, render Google Gears obsolete. Not to mention other important, and proprietary, Web app platforms that are already in production, like Adobe AIR and Microsoft Silverlight (What is Silverlight?).

Weave

Weave extends the browser in the other direction: Not toward the desktop, but instead into the Internet. Mozilla wants an individual\'s browsing experience to stay with them no matter what machine they are on. That means synchronizing bookmarks, home pages, favorites, and passwords to an online service that the user can attach to when he or she fires up the browser. As more people move between browsing machines (their laptop and their mobile phone, for example, or between different PCs), this will become more important.

Firefox 3 is laying the groundwork for this. It has a new transactional database that stores user preferences and favorites. However, it won\'t be used for cross-browser syncing in version3; Beard hopes this extension to the database is rolled out in Firefox 4.

Firefox 3 users will, though, experience some online services being fed into their browser. For example, Mozilla will update all running browsers every 30 minutes with malware signatures, to stave off drive-by downloads and phishing scams.

Beard wants the new online/offline, browser/service to be more intelligent on behalf of its users. Early examples of this intelligence include the \"awesome bar,\" which is what Mozilla calls the new smart address bar in Firefox 3. It offers users smart URL suggestions as they type based on Web searches and their prior Web browsing history. He\'s looking to extend on this with a \"linguistic user interface\" that lets users type plain English commands into the browser bar. Beard pointed me towards Quicksilver and Enso as products he\'s cribbing from.

Beard said the Labs are playing with other \"crazy ideas,\" but that Prism and Weave technologies are are being targeted at the next version of Firefox.

Further reading: See Labs.mozilla.com.

Windows Vienna

sky.dodiya@gmail.com (SKY) — Mon, 23 Jun 2008 04:35:00 +0000

Windows 7 (formerly known as Blackcomb and Vienna) is the working name for the next major version of Microsoft Windows as the successor of Windows Vista. Microsoft has announced that it is "scoping Windows 7 development to a three-year timeframe", and that "the specific release date will ultimately be determined by meeting the quality bar." Windows 7 is expected to be released sometime in 2010. The client versions of Windows 7 will ship in both 32-bit and 64-bit versions. A server variant, codenamed Windows Server 7, is also under development.

Microsoft is maintaining a policy of silence concerning discussion of plans and aspirations for Windows 7 as they focus on the release and marketing of Windows Vista, though some early details of various core operating system features have emerged. As a result, little is known about the feature set, though public presentations from company officials have disseminated information about some features. Leaked information from people to whom Milestone 1 (M1) of Windows 7 was shipped also provides some insight into the feature set.

- Wallpapers -

Video

Watch the latest videos on YouTube.com

Java Persistence API

sky.dodiya@gmail.com (SKY) — Sun, 22 Jun 2008 04:12:00 +0000

Java Persistence API Example

Entity classes
hi everyone, i have started learning JPA 2 months ago.although i know hibernate very well but its bit difficult to work
with JPA in starting Phase.i have never work with j2EE full aspects application before so its quite new thing for me.
There are many thing is new for me in JPA example -Annotation.

There is some few example classes that i want to show you as i have make during my assignment.

Example CustEntity.java

/**
*
* @author sky
*/
@Entity
@NamedQueries({
@NamedQuery(name = "findAllCustomers", query = "SELECT c FROM CustEntity c"),
@NamedQuery(name = "findByCustomerid", query = "SELECT c FROM CustEntity c WHERE c.id = :id"),
@NamedQuery(name = "findByUsername", query = "SELECT c FROM CustEntity c WHERE c.username = :username"),
@NamedQuery(name = "findByName", query = "SELECT c FROM CustEntity c WHERE c.firstname = :firstname AND c.surname = :surname")
})
@Table(name = "CUSTOMER")
public class CustEntity implements Serializable {

private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
@Column(name = "ID", nullable = false)
private Long id;
@Column(name = "FIRSTNAME", nullable = false)
private String firstname;
@Column(name = "SURNAME", nullable = false)
private String surname;
@Column(name = "PASSWORD", nullable = false)
private String password;
@Column(name = "USERNAME", nullable = false)
private String username;
@Column(name = "BIRTHDATE")
private Integer birthdate;
@Column(name = "PHONE")
private Integer phone;
@Column(name = "EMAIL")
private String email;
@Column(name = "Gender")
private String gender;
@Column(name = "PHONENO")
private Long phoneno;
@Column(name = "DOB")
@Temporal(value = TemporalType.DATE)
private Date dob;
@OneToOne(optional = false, cascade = CascadeType.PERSIST)
@JoinColumn(name = "ADDRESSID", referencedColumnName = "ADDRESSID")
private Address address;

public String getGender() {
return gender;
}

public void setGender(String gender) {
this.gender = gender;
}

public CustEntity() {
}

public Date getDob() {
return dob;
}

public void setDob(Date dob) {
this.dob = dob;
}

public Long getPhoneno() {
return phoneno;
}

public void setPhoneno(Long phoneno) {
this.phoneno = phoneno;
}

public CustEntity(String username, String password) {
setUsername(username);
setPassword(password);
}

public CustEntity(String username, String password, String firstname, String surname, String email, Long phoneno, Date dob, String gender) {
this();
setUsername(username);
setPassword(password);
setFirstname(firstname);
setSurname(surname);
setPhoneno(phoneno);
setEmail(email);
setDob(dob);
this.setGender(gender);

}

public Long getId() {
return id;
}

public void setId(Long id) {
this.id = id;
}

@Override
public int hashCode() {
int hash = 0;
hash += (id != null ? id.hashCode() : 0);
return hash;
}

@Override
public boolean equals(Object object) {
// TODO: Warning - this method won't work in the case the id fields are not set
if (!(object instanceof CustEntity)) {
return false;
}
CustEntity other = (CustEntity) object;
if ((this.id == null && other.id != null) || (this.id != null && !this.id.equals(other.id))) {
return false;
}
return true;
}

@Override
public String toString() {
return "au.edu.swin.app.CustomerEntity[id=" + id + "]";
}

public String getFirstname() {
return firstname;
}

public void setFirstname(String firstname) {
this.firstname = firstname;
}

public String getSurname() {
return this.surname;
}

public void setSurname(String surname) {
this.surname = surname;
}

public String getPassword() {
return this.password;
}

public void setPassword(String password) {
this.password = password;
}

public String getUsername() {
return this.username;
}

public void setUsername(String username) {
this.username = username;
}

public Integer getBirthdate() {
return birthdate;
}
public void setBirthdate(Integer birthdate) {
this.birthdate = birthdate;
}
public Integer getPhone() {
return phone;
}
public void setPhone(Integer phone) {
this.phone = phone;
}
public String getEmail() {
return email;
}

public void setEmail(String email) {
this.email = email;
}

public Address getAddress() {
return address;
}

public void setAddress(Address address) {
this.address = address;
}

// Transfer Object Methods
public CustTo getData() {
CustTo to = new CustTo(id, firstname, surname);
return to;
}

public CustDetailedTo getDetailedData() {
CustDetailedTo to = new CustDetailedTo(id, firstname, surname, username, password, email, phoneno, dob, gender);
return to;
}
// note that only the LoginCustDetailedTo can be
// used to update the state of the vehicle entity
public void setData(CustDetailedTo to) {
setId(to.getId());
setFirstname(to.getFirstname());
setSurname(to.getSurname());
setUsername(to.getUsername());
setPassword(to.getPassword());
setEmail(to.getEmail());
setDob(to.getDob());
setPhoneno(to.getPhoneno());
this.setGender(to.getGender());

}
}

Example : Address.java

@Entity
@Table(name = "ADDRESS")
@NamedQueries({@NamedQuery(name = "Address.findByAddressid", query = "SELECT a FROM Address a WHERE a.addressid = :addressid"), @NamedQuery(name = "Address.findByStreetnumber", query = "SELECT a FROM Address a WHERE a.streetnumber = :streetnumber"), @NamedQuery(name = "Address.findByStreet", query = "SELECT a FROM Address a WHERE a.street = :street"), @NamedQuery(name = "Address.findByCity", query = "SELECT a FROM Address a WHERE a.city = :city"), @NamedQuery(name = "Address.findByState", query = "SELECT a FROM Address a WHERE a.state = :state"), @NamedQuery(name = "Address.findByPostcode", query = "SELECT a FROM Address a WHERE a.postcode = :postcode"), @NamedQuery(name = "Address.findAllAddress", query = "SELECT a FROM Address a")})
public class Address implements Serializable {

private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
@Column(name = "ADDRESSID", nullable = false)
private Long addressid;
@Column(name = "STREETNUMBER", nullable = false)
private int streetnumber;
@Column(name = "STREET", nullable = false)
private String street;
@Column(name = "CITY", nullable = false)
private String city;
@Column(name = "STATE", nullable = false)
private String state;
@Column(name = "POSTCODE", nullable = false)
private int postcode;

public Address() {
}

public Address(int streetnumber, String street, String city, String state, int postcode) {
this();
this.setCity(city);
this.setStreetnumber(streetnumber);
this.setStreet(street);
this.setState(state);
this.setPostcode(postcode);

}

public Long getAddressid() {
return addressid;
}

public void setAddressid(Long addressid) {
this.addressid = addressid;
}

public int getStreetnumber() {
return streetnumber;
}

public void setStreetnumber(int streetnumber) {
this.streetnumber = streetnumber;
}

public String getStreet() {
return street;
}

public void setStreet(String street) {
this.street = street;
}

public String getCity() {
return city;
}

public void setCity(String city) {
this.city = city;
}

public String getState() {
return state;
}

public void setState(String state) {
this.state = state;
}

public int getPostcode() {
return postcode;
}

public void setPostcode(int postcode) {
this.postcode = postcode;
}

// Transfer Object Methods
public AddressTO getData() {
AddressTO to = new AddressTO(addressid,streetnumber, street, city, state, postcode);
return to;
}

public void setData(AddressTO to) {
setAddressid(to.getAddressid());
setStreet(to.getStreet());
setCity(to.getCity());
setPostcode(to.getPostcode());
setState(to.getState());
setStreetnumber(to.getStreetnumber());
}

/* @Override
/* public int hashCode() {
int hash = 0;
hash += (addressid != null ? addressid.hashCode() : 0);
return hash;
}
@Override
public boolean equals(Object object) {
// TODO: Warning - this method won't work in the case the id fields are not set
if (!(object instanceof Address)) {
return false;
}
Address other = (Address) object;
if ((this.addressid == null && other.addressid != null) || (this.addressid != null && !this.addressid.equals(other.addressid))) {
return false;
}
return true;
}
@Override
public String toString() {
return "au.swin.Entity.Address[addressid=" + addressid + "]";
}*/

}

This is two example of my entity classes. i like to inroduce some Anonotation i used

@Entity - Use this annotation to designate a plain old Java object (POJO) class as an entity so that you can use it with JPA services.

@NamedQuerys - set of Named Querys

@NamedQuery - Use these annotations to pre-define queries and manage their result sets.

@Table(name = "CUSTOMER") - Use these annotations to override this default behavior and fine-tune the relationship between your object model and data model - will create table CUSTOMER in database.

@Id - Specify this is primary column in database.

@@GeneratedValue(strategy = GenerationType.AUTO) - primary key generation policy

@Column(name = "ID", nullable = false) - Specify in database column name woould be.

@OneToOne - Use these annotations to specify the type and characteristics of entity relationships to fine-tune how your database implements these relationships.

@JoinColumn - To specify the join columns that are being mapped to the persistent attribute

more reference : http://www.oracle.com/technology/products/ias/toplink/jpa/resources/toplink-jpa-annotations.html

PHP - MYSQL EXAMPLES

sky.dodiya@gmail.com (SKY) — Thu, 19 Jun 2008 03:13:00 +0000

Connect to MySQL Database

There is a very easy steps to follow to connect MySQL database from PHP.
just see the example below.

<?php
$dbhost = 'localhost';
$dbuser = 'root';
$dbpass = 'password';

$conn = mysql_connect($dbhost, $dbuser, $dbpass) or die ('Error connecting to mysql');

$dbname = 'petstore';
mysql_select_db($dbname);
?>

$dbhost is the name of MySQL server. When your webserver is on the same machine with the MySQL server you can use localhost or 127.0.0.1 as the value of $dbhost. The $dbuser and $dbpass are valid MySQL user name and password

Don't forget to select a database using mysql_select_db() after connecting to mysql. If no database selected your query to select or update a table will not work.

Sometimes a web host will require you to specify the MySQL server name and port number. For example if the MySQL server name is db.database.com and the port number is 3306 (the default port number for MySQL) then you you can modify the above code to :

<?php
$dbhost = 'db.database.com:3306';
$dbuser = 'root';
$dbpass = 'password';

$conn = mysql_connect($dbhost, $dbuser, $dbpass) or die ('Error connecting to mysql');

$dbname = 'petstore';
mysql_select_db($dbname);
?>

It's a common practice to place the routine of opening a database connection in a separate file. Then everytime you want to open a connection just include the file. Usually the host, user, password and database name are also separated in a configuration file.

t's a common practice to place the routine of opening a database connection in a separate file. Then everytime you want to open a connection just include the file. Usually the host, user, password and database name are also separated in a configuration file.

An example of config.php that stores the connection configuration and opendb.php that opens the connection are :

<?php
// This is an example of config.php
$dbhost = 'localhost';
$dbuser = 'root';
$dbpass = 'password';
$dbname = 'phpcake';
?>

<?php
// This is an example opendb.php
$conn = mysql_connect($dbhost, $dbuser, $dbpass) or die ('Error connecting to mysql');
mysql_select_db($dbname);
?>

So now you can open a connection to mysql like this:

<?php
include 'config.php';
include 'opendb.php';

// ... do something like insert or select, etc

?>

Closing the Connection

The connection opened in a script will be closed as soon as the execution of the script ends. But it's better if you close it explicitly by calling mysql_close() function. You could also put this function call in a file named closedb.php.

<?php
// an example of closedb.php
// it does nothing but closing
// a mysql database connection

mysql_close($conn);
?>

Now that you have put the database configuration, opening and closing routines in separate files your PHP script that uses mysql would look something like this :

<?php
include 'config.php';
include 'opendb.php';

// ... do something like insert or select, etc

include 'closedb.php';
?>

Insert Data To MySQL Database

inserting data to MySQL is done by using mysql_query() to execute INSERT query. Note that the query string should not end with a semicolon. Below is an example of adding a new MySQL user by inserting a new row into table user in database mysql :

Example : insert.php

<?php
include 'library/config.php';
include 'library/opendb.php';

mysql_select_db($mysql);
$query = "INSERT INTO user (host, user, password, select_priv, insert_priv, update_ priv) VALUES ('localhost', 'phpcake', PASSWORD('mypass'), 'Y', 'Y', 'Y')";

mysql_query($query) or die('Error, insert query failed');

$query = "FLUSH PRIVILEGES";
mysql_query($query) or die('Error, insert query failed');

include 'library/closedb.php';
?>

In the above example mysql_query() was followed by die(). If the query fail the error message will be printed and the script's execution is terminated. Actually you can use die() with any function that might not execute properly. That way you can be sure that the script won't continue to run when an error occured.

In a real application the values of an INSERT statement will be form values. As a safe precaution always escape the values using addslashes() if get_magic_quotes_gpc() returns false. Below is an example of using form values with INSERT. It's the same as above except that the new username and password are taken from $_POST :

Example : adduser.php

<html>
<head>
<title>Add New MySQL User</title>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
</head>

<body>
<?php
if(isset($_POST['add']))
{
include 'library/config.php';
include 'library/opendb.php';

$username = $_POST['username'];
$password = $_POST['password'];

$query = "INSERT INTO user (host, user, password, select_priv, insert_priv, update_ priv) VALUES ('localhost', '$username', PASSWORD('$password'), 'Y', 'Y', 'Y')";
mysql_query($query) or die('Error, insert query failed');

$query = "FLUSH PRIVILEGES";
mysql_query($query) or die('Error, insert query failed');

include 'library/closedb.php';
echo "New MySQL user added";
}
else
{
?>
<form method="post">
<table width="400" border="0" cellspacing="1" cellpadding="2">
<tr>
<td width="100">Username</td>
<td><input name="username" type="text" id="username"></td>
</tr>
<tr>
<td width="100">Password</td>
<td><input name="password" type="text" id="password"></td>
</tr>
<tr>
<td width="100"> </td>
<td> </td>
</tr>
<tr>
<td width="100"> </td>
<td><input name="add" type="submit" id="add" value="Add New User"></td>
</tr>
</table>
</form>
<?php
}
?>
</body>
</html>

Get Data From MySQL Database

Using PHP you can run a MySQL SELECT query to fetch the data out of the database. You have several options in fetching information from MySQL. PHP provide several functions for this. The first one is mysql_fetch_array()which fetch a result row as an associative array, a numeric array, or both.

Below is an example of fetching data from MySQL, the table contact have three columns, name, subject and message.

Example : select.php

<?php
include 'config.php';
include 'opendb.php';

$query = "SELECT name, subject, message FROM contact";
$result = mysql_query($query);

while($row = mysql_fetch_array($result, MYSQL_ASSOC))
{
echo "Name :{$row['name']} <br>" .
"Subject : {$row['subject']} <br>" .
"Message : {$row['message']} <br><br>";
}

include 'closedb.php';
?>

The while() loop will keep fetching new rows until mysql_fetch_array() returns FALSE, which means there are no more rows to fetch. The content of the rows are assigned to the variable $row and the values in row are then printed. Always remember to put curly brackets when you want to insert an array value directly into a string.

In above example I use the constant MYSQL_ASSOC as the second argument to mysql_fetch_array(), so that it returns the row as an associative array. With an associative array you can access the field by using their name instead of using the index . Personally I think it's more informative to use $row['subject'] instead of $row[1].

PHP also provide a function called mysql_fetch_assoc() which also return the row as an associative array.

<?php
include 'config.php';
include 'opendb.php';

$query = "SELECT name, subject, message FROM contact";
$result = mysql_query($query);

while($row = mysql_fetch_assoc($result))
{
echo "Name :{$row['name']} <br>" .
"Subject : {$row['subject']} <br>" .
"Message : {$row['message']} <br><br>";
}

include 'closedb.php';
?>

You can also use the constant MYSQL_NUM, as the second argument to mysql_fetch_array(). This will cause the function to return an array with numeric index.

<?php
include 'config.php';
include 'opendb.php';

$query = "SELECT name, subject, message FROM contact";
$result = mysql_query($query);

while($row = mysql_fetch_array($result, MYSQL_NUM))
{
echo "Name :{$row[0]} <br>" .
"Subject : {$row[0]} <br>" .
"Message : {$row[0]} <br><br>";
}

include 'closedb.php';
?>

Using the constant MYSQL_NUM with mysql_fetch_array() gives the same result as the function mysql_fetch_row().

There is another method for you to get the values from a row. You can use list(), to assign a list of variables in one operation.

<?php
include 'config.php';
include 'opendb.php';

$query = "SELECT name, subject, message FROM contact";
$result = mysql_query($query);

while(list($name,$subject,$message)= mysql_fetch_row($result))
{
echo "Name :$name <br>" .
"Subject : $subject <br>" .
"Message : $row <br><br>";
}

include 'closedb.php';
?>

In above example, list() assign the values in the array returned by mysql_fetch_row() into the variable $name, $subject and $message.

Of course you can also do it like this

<?php
include 'config.php';
include 'opendb.php';

$query = "SELECT name, subject, message FROM contact";
$result = mysql_query($query);

while($row = mysql_fetch_row($result))
{
$name = $row[0];
$subject = $row[1];
$message = $row[2];

echo "Name :$name <br>" .
"Subject : $subject <br>" .
"Message : $row <br><br>";
}

include 'closedb.php';
?>

So you see you have lots of choices in fetching information from a database. Just choose the one appropriate for your program

Freeing the memory ?

In some cases a query can return large result sets. As this results are stored in memory there's a concern about memory usage. However you do not need to worry that you will have to call this function in all your script to prevent memory congestion. In PHP all results memory is automatically freed at the end of the script's execution.

But you are really concerned about how much memory is being used for queries that return large result sets you can use mysql_free_result(). Calling this function will free all memory associated with the result identifier ( $result ).

Using the above example you can call mysql_free_result() like this :

Convert MySQL Query Result To Excel

Using PHP to convert MySQL query result to Excel format is also common especially in web based finance applications. The finance data stored in database are downloaded as Excel file for easy viewing. There is no special functions in PHP to do the job. But you can do it easily by formatting the query result as tab separated values or put the value in an HTML table. After that set the content type to application/vnd.ms-excel

Example : convert.php

<?php
include 'library/config.php';
include 'library/opendb.php';

$query = "SELECT fname, lname FROM students";
$result = mysql_query($query) or die('Error, query failed');

$tsv = array();
$html = array();
while($row = mysql_fetch_array($result, MYSQL_NUM))
{
$tsv[] = implode("t", $row);
$html[] = "<tr><td>" .implode("</td><td>", $row) . "</td></tr>";
}

$tsv = implode("rn", $tsv);
$html = "<table>" . implode("rn", $html) . "</table>";

$fileName = 'mysql-to-excel.xls';
header("Content-type: application/vnd.ms-excel");
header("Content-Disposition: attachment; filename=$fileName");

echo $tsv;
//echo $html;

include 'library/closedb.php';
?>

In the above example $tsv is a string containing tab separated values and $html contain an HTML table. I use implode() to join the values of $row with tab to create a tab separated string.

After the while loop implode() is used once again to join the rows using newline characters. The headers are set and the value of $tsv is then printed. This will force the browser to save the file as mysql-to-excel.xsl

Try running the script in your own computer then try commenting echo $tsv and uncomment echo $html to see the difference.

Shopping Cart Tutorial

Sony Ericssion

sky.dodiya@gmail.com (SKY) — Wed, 18 Jun 2008 06:11:00 +0000

Sony Ericsson PSP Phone Concept

Mobile phones with camera, mp3 player, mobile TV station, and GPS receiver can be found nowadays, all features mentioned also available in Sony Ericsson cell phone. What about mobile gaming ? Sony Ericsson is recently filling patent about Sony Ericsson PSP Phone concept. After all, who’s better positioned to create a perfect mobile gaming platform than Sony ?

Sony Ericsson Phone : Wearable Around The Neck

Compact mobile phone designed for Sony Ericsson. This mobile phone is a personal, friendly object which is wearable around the neck. The user can use the three buttons (Busy, Accept, Reject) to handle the calls. The ‘Accept’ and ‘Reject’ buttons work in the regular fashion while the ‘Busy’ button allows the user to record a message such as ‘I am in a meeting right now’. When the button pressed during an incoming call, the phone plays the message for the caller. The concept of “call priority” is also introduced here. This is a feature which allows callers to set a priority for the call, such as emergency, normal, fun, etc. In return, the peeking display of the device glows with a certain color for certain priority levels when ringing. Will we see it in the future ? Let’s wait for Sony Ericsson answer …

Sony Rolly Egg-Shaped Sound Entertainment Gadget

With innovative size and shape being designed for music players, Sony Rolly is one refreshing design. Design wise it is of the shape of a cylinder, which comes with 1 GB internal flash memory. It also has Bluetooth connectivity for receiving and streaming music. It also has a USB connection for transferring music and charging the batteries. The audio format supported being MP3, ATRAC and AAC up to 330 kbps.

The battery used is the rechargeable 3.7V, which has a battery life of 5 hours for music playback, while the same gives 4.5 hours on Bluetooth connection. It has dimensions 104 x 65 x 65 and weighs about 300 grams. With a price tag of $360, it sure leaves one hole in the pocket.

XPERIA X1 Slider-Phone from Sony Ericsson

XPERIA X1 marks the launch of a new brand for Sony Ericsson company, this product is hoped can gain attention from slider phone lovers. Featuring 3 inch wide VGA display, 3.2 mega-pixel camera, slider-design body, touch screen, and full wide-pitch QWERTY keyboard. This probably the next iphone rival. No one mention about any price just yet, we can hope to see XPERIA X1 in the market around second half of 2008. Let’s hope so !

Nokia

sky.dodiya@gmail.com (SKY) — Mon, 16 Jun 2008 14:02:00 +0000

The Morph concept

Launched alongside The Museum of Modern Art “Design and The Elastic Mind” exhibition, the Morph concept device is a bridge between highly advanced technologies and their potential benefits to end-users. This device concept showcases some revolutionary leaps being explored by Nokia Research Center (NRC) in collaboration with the Cambridge Nanoscience Centre (United Kingdom) – nanoscale technologies that will potentially create a world of radically different devices that open up an entirely new spectrum of possibilities.

Morph concept technologies might create fantastic opportunities for mobile devices:

Newly-enabled flexible and transparent materials blend more seamlessly with the way we live
Devices become self-cleaning and self-preserving
Transparent electronics offering an entirely new aesthetic dimension
Built-in solar absorption might charge a device, whilst batteries become smaller, longer lasting and faster to charge
Integrated sensors might allow us to learn more about the environment around us, empowering us to make better choices

In addition to the advances above, the integrated electronics shown in the Morph concept could cost less and include more functionality in a much smaller space, even as interfaces are simplified and usability is enhanced. All of these new capabilities will unleash new applications and services that will allow us to communicate and interact in unprecedented ways.

Flexible & Changing Design

Nanotechnology enables materials and components that are flexible, stretchable, transparent and remarkably strong. Fibril proteins are woven into a three dimensional mesh that reinforces thin elastic structures. Using the same principle behind spider silk, this elasticity enables the device to literally change shapes and configure itself to adapt to the task at hand.

A folded design would fit easily in a pocket and could lend itself ergonomically to being used as a traditional handset. An unfolded larger design could display more detailed information, and incorporate input devices such as keyboards and touch pads.

Even integrated electronics, from interconnects to sensors, could share these flexible properties. Further, utilization of biodegradable materials might make production and recycling of devices easier and ecologically friendly.

Self-Cleaning
Nanotechnology also can be leveraged to create self-cleaning surfaces on mobile devices, ultimately reducing corrosion, wear and improving longevity. Nanostructured surfaces, such as “Nanoflowers” naturally repel water, dirt, and even fingerprints utilizing effects also seen in natural systems.

Advanced Power Sources

Nanotechnology holds out the possibility that the surface of a device will become a natural source of energy via a covering of “Nanograss” structures that harvest solar power. At the same time new high energy density storage materials allow batteries to become smaller and thinner, while also quicker to recharge and able to endure more charging cycles.

Sensing The Environment

Nanosensors would empower users to examine the environment around them in completely new ways, from analyzing air pollution, to gaining insight into bio-chemical traces and processes. New capabilities might be as complex as helping us monitor evolving conditions in the quality of our surroundings, or as simple as knowing if the fruit we are about to enjoy should be washed before we eat it. Our ability to tune into our environment in these ways can help us make key decisions that guide our daily actions and ultimately can enhance our health.

Press Material

Other resources

To learn more about the “Design and The Elastic Mind” exhibition at The Museum of Modern Art visit MoMA webpage

To learn more about the Cambridge Nanoscience Centre visit http://www.nanoscience.cam.ac.uk/

Provoke 2012 Phone Concept

Provoke Design is Nokia’s main Design contractor and they have come up with future headset design of Nokia. They have created three concepts, Express, Share and Feel. The look of the Express design can be changes as per your preferences and tastes. The Feel handset is basically designed for couples as this pair helps in deep communication with touch replication. The share concept enables the cults to interact in a personalized code formed within their sub-groups. Like other products this one is also facing new challenges, but it will surely achieve its goal.

How To Get Your Symbian Applications Signed For Free [ Mobile]

Its been a long time I wrote about Mobiles. So here is a useful post for you all.

Sometimes when you try to install any Symbian application you get an error like this " ...............cannot be installed ".

This is because your application is not signed. To get it signed, here is the solution.

Visit this link to get your Symbian Applications Signed.

Here the tutorial on How to sign an unsigned Application.

Note : You can get all Symbian application signed. So visit and enjoy :)

Video

Watch the latest videos on YouTube.com

Reference : NOKIA

Java Server Faces

sky.dodiya@gmail.com (SKY) — Sun, 15 Jun 2008 08:26:00 +0000

JavaServer Faces (JSF) is a standardized specification for building User Interfaces (UI) for server-side applications. Before JavaServer Faces, developers who built web applications often relied on building HTML user interface components with servlets or JavaServer Pages (JSP pages). This is mainly because HTML user interface components are the lowest common denominator that web browsers support. The implication, of course, is that such web applications do not have rich user interfaces, compared with standalone fat clients, and therefore less functionality and/or poor usability. While applets can be used to develop rich user interfaces, web application developers don't always know what clients will be accessing the application and/or they may have no access to the client device.

In addition, if you have taken part in developing a large-scale web system, you may have come across technical challenges, such as how to implement custom components like a query builder or a table viewer for building database queries. Building such custom components requires expertise and a significant amount of time to build and test the new libraries. In an ideal environment, developers would be able to use pre-built, tested, and highly configurable components to integrate into their application development environment.

JavaServer Faces (JSF) is a server-side technology for developing web applications with rich user interfaces. With JSF, you can resolve such technical challenges as creating custom user interface components. This is because JSF technology is a user interface framework for building Java-based web applications that run on the server side, and render the user interface back to the client. That's right! The user interface code runs on the server, responding to events generated on the client.

Rich user interfaces consist of a set of rich components. There are a number of options out there today for building rich server-side user interfaces, such as Flash, Swinglets, and Jade. However, these solutions are proprietary; the tools and runtimes that support their development are usually only available through a single vendor. JSF is, above all, a standard, which means that the developer does not get locked into a single vendor. The specification expert group is actually made up of representatives from all the major tool vendors in the Java community. Thus, developers will have no shortage of choices for tools, and probably will be able to use an updated version of a tool they are using today. While the tool vendors are cooperating on the specification, they will compete with each other in their implementations. This will benefit the developer community in terms of features and in the choice of custom components each vendor makes available. Tool Vendors provide an Integrated Development Environment (IDE) to help you build and deploy your JSF applications. The following vendors offer tools to support JSF development.

Component Vendors provide reusable building blocks for application development and integration into JSF-based tools. Components cover a wide range of uses including reporting, charts and graphs, fields, and navigational components. Here are some of the vendors who offer components that support the JavaServer Faces specification.

JavaServer Faces technology is based on the Model View Controller (MVC) architecture for separating logic from presentation, so if you have been practicing this, you'll feel at home with JSF.

This article provides a fast-track, code-intensive tutorial to get you started with JSF. The article also:

Provides an introduction to JSF
Describes the benefits of JSF
Describes the internals of JSF
Describes the genesis of JSF applications
Gives you a taste of the effort involved in developing JSF applications
Provides sample code that you can adapt for your own applications
Discuss the JSF support in the Sun Java Studio Creator IDE

If you are looking for more advanced topics, please see Chapters 17 - 21 of the J2EE 1.4 Tutorial.

Overview of JavaServer Faces

JavaServer Faces (JSF) is a technology that is being led by Sun Microsystems as JSR 127 under the Java Community Process (JCP). The objective is to create a standard framework for user interface components for web applications. As mentioned earlier, JSF lets you build web applications that run on a Java server and render the user interface back to the client. This technology provides web application lifecycle management through a controller servlet, and a rich component model with event handling and component rendering.

To get started using JavaServer Faces, the first thing you should do is download a JavaServer Faces compatible implementation. All of the tool vendors listed above provide a JavaServer Faces compatible development and runtime environment. You can get a FREE JavaServer Faces Compatible runtime environment by downloading the J2EE 1.4 SDK, which includes support for JavaServer Faces. you can also get a copy of Java Studio Creator from Sun as part of your subscription to the Sun Developer Network.

Note that as a minimum requirement, JSF runs on Servlet 2.3 and JSP 1.2. Figure 1 depicts the high-level architecture of JSF.

The JSF technology consists of two main components:

Java APIs to represent UI components, manage state, handle events, and validate input. The API has support for internationalization and accessibility.
Two JSP custom tag libraries for expressing user interface (UI) components within a JSP page, and for wiring components to server-side objects. Page authors can easily add UI components to their pages.

Figure 2 shows the relationship between the client, the server, and JSF.

Here, the JSP page represents the user interface components using the JSF custom tag library, rather than hard coding them with a markup language. The UI for the application manages the objects rendered by the JSP page.

Several types of users can benefit from this technology, including:

Page authors who use markup languages, such as HTML, will use the JSP tag library for expressing JavaServer Faces rich user interface components.
Application developers who write the model objects and event handlers.
Component developers who will create custom components based on the JSF components.
Tools vendors who will provide tools that incorporate JSF technology into a new generation of tools that simplify the development of multi tier, web-based applications.
Application Server vendors who provide a runtime environment that incorporates JSF technology into a new generation of Application Servers that can deploy multi tier, web-based applications that use JSF technology.

This technology also opens up the market for reusable web user interface components. Developers and vendors can use JSF as the building blocks for developing custom faces.

One of the advantages of JSF is that it is based on the Model View Controller (MVC) architecture, to offer a clean separation between presentation and logic. This may ring a bell for those who are using existing web frameworks such as Struts. However, note that JSF and Struts are not competing technologies, and in fact, they interoperate together. JSF, however, does have some advantages over Struts. For example, in Struts there is only one way to render an element, while JSF provides several mechanisms for rendering an individual element. It is up to the page designer to pick the desired representation, and the application developer doesn't need to know which mechanism was used to render a component. (Here's a link for more information on the integration of JSF and Struts.) Readers may notice that the author of Struts, Craig McClanahan, is also the co-specification lead for JSF, as well as an employee of Sun Microsystems.

Genesis of a JSF Application

A JSF application is just like any other Java technology-based web application; it runs in a Java servlet container, and contains:

JavaBeans components (or model objects) containing application-specific functionality and data
Event listeners
JSP pages
Server-side helper classes
A custom tag library for rendering UI components
A custom tag library for representing event handlers and validators
UI components represented as stateful objects on the server
Validators, event handlers, and navigation handlers. (Validators are used to validate data on individual components before the server-side data is updated.)
Application configuration resource file for configuring application resources

Here is a simple example using the tag libraries. For a list of component tags support and other information on JSF, please refer to the JavaServer Faces specification and Chapter 17 - 21 of the J2EE 1.4 Tutorial

<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h" %>
<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f" %>
<body bgcolor="white">
<f:view>

<h:form id="helloform">
<h2>What is your name?</h2>
<h:inputText id="username" value="#{UserNameBean.userName}"
    validator="#{UserNameBean.validate}"/>
<h:commandButton id="submit" action="success" value="Submit"/>
</h:form>
</f:view>

The JSF component architecture is designed in such a way that the component classes maintain a component's state. A renderkit defines how component classes map to component tags appropriate for a particular client. The JSF reference implementation, which is discussed later, includes a standard RenderKit for rendering to an HTML client. Each JSP component in the HTML RenderKit is composed of the component functionality defined by the UIComponent class, and the rendering attributes defined by the Renderer. For example, the tags commandButton and commandHyperlink both represent a UIComponent, but they are rendered in two different ways. The button component is rendered as a button and the hyperlink is rendered as a hyperlink.

When a JSP page is created using JSF components, a component tree or a view is built into memory on the server with each component tag corresponding to a UIComponent instance in the tree. The component tree is used by the JSF framework to handle your application request and create a rendered response. When an event is generated (for example, user clicks on a button), the JSF lifecycle handles the event and generates an appropriate response. Note that the entry point into the JSF framework is the FacesServlet. It acts as the front controller and handles request processing lifecycle.

The JSF reference implementation 1.1 comes with the following:

html_basic.tld: A JSP custom tag library for building JSF applications that render to an HTML client
jsf_core.tld: A JSP custom tag library for representing core actions independent of a particular render kit
APIs that provide user interface components, model object management, pluggable rendering, server-side validation, data conversion, event processing, page flow management, and custom extensibility for all of these features
A set of demos located in the samples directory of the installation

The JSF Reference Implementation 1.1 can be downloaded here. When you unzip the archive, you'll get a directory structure like this (under Windows):

c:\jsf-1_1>
\docs
\javadocs
\lib
\metadata
\renderkitdocs
\samples
\tlddocs
some-other-files

The example directory contains WAR and source files for sample applications. The lib directory contains the JAR files that JSF depends on. The JAR files are:

commons-beanutils.jar: Utilities for defining and accessing JavaBeans component properties
commons-collections.jar: Extensions of the J2SE Collections Framework
commons-digester.jar: For processing XML documents
commons-logging.jar: A general purpose, flexible logging facility to allow developers to instrument their code with logging statements
jsf-api.jar: Contains the javax.faces.* API classes
jsf-impl.jar: Contains the implementation classes of the JSF Reference Implementation

Note that the JSF framework uses the JavaServer Pages Standard Tag Library (JSTL), and therefore it is assumed that the web container you use provides the necessary JAR files for JSTL.

The JSF RI can be easily set up to be used with virtually any web container. The RI comes with installations instructions on how to use it with Apache Tomcat, Java WSDP 1.3, and Sun Java System Application Server Platform Edition 8. The installation process is usually a matter of copying some JAR files, such as jsf-api.jar and jsf-impl.jar from the lib directory of the JSF RI to your web container's lib directory. For this article, however, the Sun Java Application Server Platform Edition 8 that comes with the Sun Java Studio Creator was used. The Sun Java Application Server Edition 8 can be downloaded from here and this already includes support for JSF.

If you are using the Sun Java Application Server Edition 8, you can easily get started by deploying the sample applications that come with the JSF RI by following these two simple steps:

Start the application server
Deploy the .war files from the samples directory of your JSF RI onto the application server. This can be done using the deploytool or by running asant deploy, but the easiest way is to copy the .war files to the autodeploy directory (on my machine, this directory is C:\Sun-Studio-Creator\SunAppServer8\domains\creator\autodeploy.

Now, you can start your favorite web browser and enter a URL to run a sample JSF application: http://localhost:18080/jsf-guessNumber or any other sample application that starts with jsf-. Here is a sample output:

Understanding JavaServer Faces

This section describes a sample application, a guessing number game, that comes with the JSF RI. The application, as shown in Figure 3 above, asks you to guess a number between 0 and 10, inclusive. If you enter the wrong number, you'll see something similar to Figure 4, and when you finally enter the right number, you'll see something similar to Figure 5. This application will give you a taste of the effort involved in developing web applications using the JSF technology.

A JSF application consists of the following files:

JSP pages with JSF components representing the UI
JavaBeans to hold the model data
Application configuration files specifying the JSF controller servlet, managed beans, and navigation handles

The JSP Pages

In the guess number sample application, three JSP pages are used: index.jsp, greeting.jsp, and response.jsp. Let's start with the index.jsp page.

The index.jsp page: This page is shown in Code Sample 1.

Code Sample 1: index.jsp

<html>
<head>
</head>
 <body>
   <jsp:forward page="guess/greeting.jsp" />
 </body>
</html>

As you can see, this page simply forwards the user to the main page, greeting.jsp, and therefore in your application you can do without it.

The greeting.jsp page: This is the main page presented to the user, which is shown in Figure 3 above. Code Sample 2 shows the content of this page.

Code Sample 2: greeting.jsp

<html>
<head><title>Hello</title></head>
<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h" %>
<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f" %>
<body bgcolor="white">
<f:view>
<h:form id="helloForm" >
<h2>Hi. My name is Duke.  I'm thinking of a number from
<h:outputText value="#{UserNumberBean.minimum}"/> to
<h:outputText value="#{UserNumberBean.maximum}"/>.
  Can you guess it?</h2>
<h:graphicImage id="waveImg" url="/wave.med.gif" />
<h:inputText id="userNo" value="#{UserNumberBean.userNumber}"
          validator="#{UserNumberBean.validate}"/>     
<h:commandButton id="submit" action="success"
 value="Submit" />
<p>
<h:message style="color: red; font-family: 'New Century Schoolbook',
  serif; font-style: oblique; text-decoration: overline"
   id="errors1" for="userNo"/>
</h:form>
</f:view>
</body>
</html>

The greeting.jsp page demonstrates several features that you will use in most of your JSF applications. These are:

In order to use JSF tags, you need to include the taglib directives to the html and core tag libraries that refer to the standard HTML renderkit tag library, and the JSF core tag library, respectively.
A page containing JSF tags is represented by a tree of components whose root is the UIViewRoot, which is represented by the view tag. All component tags must be enclosed in the view tag. Other content such as HTML and other JSP pages can be enclosed within that tag.
A typical JSP page includes a form, which is submitted when a button is clicked. The tags representing the form components (such as textfields and buttons) must be nested inside the form tag.
The outputText tag represents a label. The greeting.jsp page has two such tags that display the numbers 0 and 10. The value attribute of the tag gets the values from the minimum and maximum properties of a bean class, UserNumberBean, using value-binding expressions that have the syntax #{bean-managed-property}
The graphicImage tag is used to reference an image.
The inputText tag represents an input text field component. The id attribute represents the ID of the component object represented by this tag, and if it is missing, then the implementation will generate one. The validator attribute refers to a method-binding expression pointing to a backing bean method that performs validation on the component's data.
The commandButton tag represents the button used to submit the data entered in the text field. The action attribute helps the navigation mechanism to decide which page to open next.
The message tag displays an error message if the data entered is not valid. The for attribute refers to the component whose value failed validation.

The response.jsp page: This page, which is similar to Figure 4 and 4 above, is displayed as a response to the user's clicking the Submit button. Code Sample 3 shows the content of this page whose tags have already been explained.

Code Sample 3: response.jsp

<html>
<head> <title>Guess The Number</title></head>
<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h" %>
<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f" %>
<body bgcolor="white">
<f:view>
<h:form id="responseForm" >
<h:graphicImage id="waveImg" url="/wave.med.gif" />
<h2><h:outputText id="result"
value="#{UserNumberBean.response}"/></h2>
<h:commandButton id="back" value="Back" action="success"/><p>
</h:form>
</f:view>
</body>
</html>

The Model Object

A typical JSF application uses a bean with each page in the application. The bean defines the properties and methods associated with the UI components used on the page. A bean can also define a set of methods that perform functions, such as validating the component's data, for the component. The model object bean is like any other JavaBeans component: it has a set of accessor methods. Code Sample 4 shows a sample JavaBean component, which is referenced in the greeting.jsp and response.jsp pages.

Code Sample 4: UserNumberBean.java

package guessNumber;
import javax.faces.component.UIComponent;
import javax.faces.context.FacesContext;
import javax.faces.validator.LongRangeValidator;
import javax.faces.validator.Validator;
import javax.faces.validator.ValidatorException;
import java.util.Random;
public class UserNumberBean {
Integer userNumber = null;
Integer randomInt = null;
String response = null;
public UserNumberBean() {
   Random randomGR = new Random();
   randomInt = new Integer(randomGR.nextInt(10));
   System.out.println("Duke's number: " + randomInt);
}
public void setUserNumber(Integer user_number) {
   userNumber = user_number;
   System.out.println("Set userNumber " + userNumber);
}
public Integer getUserNumber() {
   System.out.println("get userNumber " + userNumber);
   return userNumber;
}
public String getResponse() {
   if (userNumber != null && userNumber.compareTo(randomInt) == 0) {
       return "Yay! You got it!";
   } else {
       return "Sorry, " + userNumber + " is incorrect.";
   }
}
protected String[] status = null;
public String[] getStatus() {
   return status;
}
public void setStatus(String[] newStatus) {
   status = newStatus;
}
private int maximum = 0;
private boolean maximumSet = false;
public int getMaximum() {
   return (this.maximum);
}
public void setMaximum(int maximum) {
   this.maximum = maximum;
   this.maximumSet = true;
}
private int minimum = 0;
private boolean minimumSet = false;
public int getMinimum() {
   return (this.minimum);
}
public void setMinimum(int minimum) {
   this.minimum = minimum;
   this.minimumSet = true;
}
public void validate(FacesContext context,
                    UIComponent component,
                    Object value) throws ValidatorException {
   if ((context == null) || (component == null)) {
       throw new NullPointerException();
   }
   if (value != null) {
       try {
           int converted = intValue(value);
           if (maximumSet &&
               (converted > maximum)) {
               if (minimumSet) {
                   throw new ValidatorException(
                       MessageFactory.getMessage
                       (context, component,
                        Validator.NOT_IN_RANGE_MESSAGE_ID,
                        new Object[]{
                            new Integer(minimum),
                            new Integer(maximum)
                        }));
               } else {
                   throw new ValidatorException(
                       MessageFactory.getMessage
                       (context, component,
                        LongRangeValidator.MAXIMUM_MESSAGE_ID,
                        new Object[]{
                            new Integer(maximum)
                        }));
               }
           }
           if (minimumSet &&
               (converted <>Application Configuration Resource File 
  An application configuration resource file, faces-config.xml, is used to define your managed beans, validators, converters, and navigation rules. Code Sample 5 shows the faces-config.xml file for the guess number application that defines navigation rules and the mapping of managed beans.
  Code Sample 5: faces-config.xml
<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE faces-config PUBLIC
"-//Sun Microsystems, Inc.//DTD JSF Config 1.1//EN"
"http://java.sun.com/dtd/web-facesconfig_1_1.dtd">
<faces-config>
<application>
<locale-config>
 <default-locale>en</default-locale>
 <supported-locale>de</supported-locale>
 <supported-locale>fr</supported-locale>
 <supported-locale>es</supported-locale>
</locale-config>
</application>
<navigation-rule>
<description>

   The decision rule used by the NavigationHandler to
   determine which view must be displayed after the
   current view, greeting.jsp is processed.

</description>
<from-view-id>/greeting.jsp</from-view-id>
<navigation-case>
   <description>

       Indicates to the NavigationHandler that the response.jsp
       view must be displayed if the Action referenced by a
       UICommand component on the greeting.jsp view returns
       the outcome "success".

   </description>
 <from-outcome>success</from-outcome>
 <to-view-id>/response.jsp</to-view-id>
</navigation-case>
</navigation-rule>
<navigation-rule>
<description>

   The decision rules used by the NavigationHandler to
   determine which view must be displayed after the
   current view, response.jsp is processed.

</description>
<from-view-id>/response.jsp</from-view-id>
<navigation-case>
   <description>

       Indicates to the NavigationHandler that the greeting.jsp
       view must be displayed if the Action referenced by a
       UICommand component on the response.jsp view returns
       the outcome "success".

   </description>
   <from-outcome>success</from-outcome>
 <to-view-id>/greeting.jsp</to-view-id>
</navigation-case>
</navigation-rule>
<managed-bean>
<description>
 The "backing file" bean that backs up the guessNumber webapp
</description>
<managed-bean-name>UserNumberBean</managed-bean-name>
<managed-bean-class>guessNumber.UserNumberBean</managed-bean-class>
<managed-bean-scope>session</managed-bean-scope>
<managed-property>
 <property-name>minimum</property-name>
 <property-class>int</property-class>
 <value>0</value>
</managed-property>
<managed-property>
 <property-name>maximum</property-name>
 <property-class>int</property-class>
 <value>10</value>
</managed-property>
</managed-bean>
</faces-config>

The task of defining navigation rules involves defining which page is to be displayed after the user clicks on a button or a hyperlink. Each  element defines how to get from one page as defined by the  to the other pages of the application. A  element can contain any number of  elements that define the page to open next using the  based on a logical outcome defined by the . This outcome is defined by the action attribute of the component that submits the form (such as the commandButton in Code Samples 2 and 3).
  In addition, the beans need to be configured in the faces-config.xml file so that the implementation can automatically create new instances of the beans as needed. The  element is used to create a mapping between a bean name and class. The first time the UserNumberBean is referenced, the object is created and stored in the appropriate scope.
  Finally, in order to use the JSF framework in your web applications, you need to define the FaceServlet and its mapping in your deployment descript file, web.xml. This servlet acts as the front controller and handles all JSF-related requests. Code Sample 6 shows the web.xml file for the guess number application. An important thing to note is the javax.faces.STATE_SAVING_METHOD paramter, which is used to specify where the state should be saved (the client in this case). If you want to save the state on the server (this is the default in the JavaServer Faces reference implementation), then specify server instead of client in the param-value. Note that if the state is saved on the client, the state of the entire view is rendered to a hidden field on the page.
  Code Sample 6: web.xml
<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE web-app PUBLIC
"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd">
<web-app>
<display-name>JSF Guess Number Sample Application</display-name>
<description>
    JSF Guess Number Sample Application
</description>
<context-param>
    <param-name>javax.faces.STATE_SAVING_METHOD</param-name>
    <param-value>client</param-value>
</context-param>
<context-param>
    <param-name>com.sun.faces.validateXml</param-name>
    <param-value>true</param-value>
    <description>

        Set this flag to true if you want the JSF
        Reference Implementation to validate the XML in your
        faces-config.xml resources against the DTD.  Default
        value is false.

    </description>
</context-param>
<context-param>
    <param-name>com.sun.faces.verifyObjects</param-name>
    <param-value>true</param-value>
    <description>

        Set this flag to true if you want the JSF
        Reference Implementation to verify that all of the application
        objects you have configured (components, converters,
        renderers, and validators) can be successfully created.
        Default value is false.

    </description>
</context-param>
<!-- Faces Servlet -->
<servlet>
    <servlet-name>Faces Servlet</servlet-name>
    <servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
    <load-on-startup> 1 </load-on-startup>
</servlet>
<!-- Faces Servlet Mapping -->
<servlet-mapping>
    <servlet-name>Faces Servlet</servlet-name>
    <url-pattern>/guess/*</url-pattern>
</servlet-mapping>
<security-constraint>
 <!-- This security constraint illustrates how JSP pages
         with JSF components can be protected from
         being accessed without going through the Faces Servlet.
         The security constraint ensures that the Faces Servlet will
         be used or the pages will not be processed. -->

<display-name>Restrict access to JSP pages</display-name>
<web-resource-collection>
        <web-resource-name>
    Restrict access to JSP pages
        </web-resource-name>
    <url-pattern>/greeting.jsp</url-pattern>
    <url-pattern>/response.jsp</url-pattern>
</web-resource-collection>
<auth-constraint>
    <description>
    With no roles defined, no access granted
    </description>
</auth-constraint>
</security-constraint>
</web-app>
Creating Your Own Applications 
  The easiest way to start creating your own JSF applications is by adapting some of the file from the guess number application. Here is how to get started: 
 Create the following directory (for example, MyApp) and its structure under the samples directory of your JSF RI:       c:\jsf-1_1\samples\MyApp
                 \src
                    YourBeans.java
                 \web
                    YourJSP-pages.jsp
                    AnyImages.gif
                 \WEB-INF
                    web.xml
                    faces-config.xml
  
 
 
  
 
 Create the JSP pages and the model objects (beans).
Modify the web.xml and faces-config.xml as needed for your application.
Copy the file build.properties.sample to build.properties. This file is located in the samples directory, then set the tomcat.home property to the location of the application server installation. And finally, set the other self-explanatory properties as described in the file.
To build and package your application, create a build.xml file such as the one in Code Sample 7, and place it in your directory (for example, MyApp)
Code Sample 7: build.xml 
<project name="MyFirst" default="build.war" basedir=".">
<property file="../build.properties"/>
<!-- Configure the context path for this application -->
<property name="context.path" value="/jsf-MyFirst"/>
<property name="example" value="jsf-MyFirst" />
<property name="build"  value="${basedir}/build" />
<path id="classpath">
<pathelement location="${commons-beanutils.jar}"/>
<pathelement location="${commons-collections.jar}"/>
<pathelement location="${commons-digester.jar}"/>
<pathelement location="${commons-logging.jar}"/>
<pathelement location="${jsf-api.jar}"/>
<pathelement location="${jsf-impl.jar}"/>
<pathelement location="${jstl.jar}"/>
<pathelement location="${build}/${example}/WEB-INF/classes"/>
<pathelement location="${servlet.jar}"/>
</path>
<target name="clean" >
<delete dir="${build}" />
<delete dir="${context.path}" />
</target>
<target name="prepare" description="Create build directories.">
<mkdir dir="${build}/${example}" />
<mkdir dir="${build}/${example}/WEB-INF" />
<mkdir dir="${build}/${example}/WEB-INF/classes" />
<mkdir dir="${build}/${example}/WEB-INF/lib" />
</target>
<!-- Executable Targets -->
<target name="build" depends="prepare,deploy.copyJars"
 description="Compile Java files and copy static files." >
<javac srcdir="src" destdir="${build}/${example}/WEB-INF/classes">
    <include name="**/*.java" />
 <classpath refid="classpath"/>
</javac>
<copy todir="${build}/${example}/WEB-INF">
    <fileset dir="web/WEB-INF">
    <include name="*.xml" />
  </fileset>
</copy>
 <copy todir="${build}/${example}/">
  <fileset dir="web">
    <include name="*.html" />
    <include name="*.gif" />
    <include name="*.jpg" />
    <include name="*.jsp" />
    <include name="*.xml" />
  </fileset>
</copy>
<copy todir="${build}/${example}/WEB-INF/classes/${example}" >
  <fileset dir="web" >
     <include name="*properties"/>
  </fileset>
</copy>
</target>
<target name="deploy.copyJars" if="build.standalone">
<copy todir="${build}/${example}/WEB-INF/lib" file="${commons-beanutils.jar}" />
<copy todir="${build}/${example}/WEB-INF/lib" file="${commons-collections.jar}" />
<copy todir="${build}/${example}/WEB-INF/lib" file="${commons-logging.jar}" />
<copy todir="${build}/${example}/WEB-INF/lib" file="${commons-digester.jar}" />
<copy todir="${build}/${example}/WEB-INF/lib" file="${jsf-api.jar}" />
<copy todir="${build}/${example}/WEB-INF/lib" file="${jsf-impl.jar}" />
<copy todir="${build}/${example}/WEB-INF/lib" file="${jstl.jar}" />
<copy todir="${build}/${example}/WEB-INF/lib" file="${standard.jar}" />
</target>
<target name="build.war" depends="build">
<!-- create a war file for distribution -->
<jar jarfile="${example}.war" basedir="${build}/${example}"/>
<copy todir=".." file="${example}.war" />
<delete file="${example}.war" />
</target>
</project>
Modify the build.xml shown in Code Sample 6 to suit your needs.
Go to the MyApp directory and run the command asant. Your application will be built and a .war (for example, jsf-MyFirst.war) file will be created in the samples directory.
To deploy the application, ensure that the application server is running, copy the .war file to the autodeploy directory of your Sun Java Application Server 8 (such as C:\Sun-Studio-Creator\SunAppServer8\domains\creator\autodeploy). 
Now, your can test your application using the URL: httpL://localhost:18080/jsf-MyFirst.

Conclusion

JavaServer Faces (JSF) is a user interface framework for building web applications that run on the server side and render the user interface back to the client. It lets you develop tools that simplify coding web-based Java applications. Sun and other members of the JSF expert group -- which includes Borland, IBM, Macromedia, and Oracle, along with many other companies and individuals -- are evaluating ways to incorporate JSF technology into a new generation of tools that simplify the development of multi tier web-based applications. One of these tools is Sun's Java Studio Creator.

Users of your JSF-based web applications will appreciate the wide range of user actions made available by JSF controls. You can offer more features, more conveniently than you can with a standard HTML front end. And remember, JSF requires little more effort than an ordinary JSP configuration -- but with many more benefits.

Reference : http://java.sun.com

PHP SYMFONY

sky.dodiya@gmail.com (SKY) — Sun, 15 Jun 2008 02:32:00 +0000

Open-source web PHP-Framework

Symfony is a full-stack framework, a library of cohesive classes written in PHP5.

It provides an architecture, components and tools for developers to build complex web applications faster. Choosing symfony allows you to release your applications earlier, host and scale them without problem, and maintain them over time with no surprise.

Symfony is based on experience. It does not reinvent the wheel: it uses most of the best practices of web development and integrates some great third-party libraries.

Overview

Symfony has Ajax helpers that make programming an elaborate interface a piece of cake. This tutorial will show you step-by-step how to create an Ajax-powered symfony application in minutes.

Introduction

Real lazy folks that can't stand reading long documentation are advised to watch the online screencast that demonstrates exactly what is written below.

Adding items to a shopping cart in common e-commerce applications isn't very close to the actual "add to cart" metaphor, since it requires clicking an "add to cart" button, watch a new page (the shopping cart), and then go back to the shop or checkout with buttons.

Ajax allows to get closer to the cart metaphor, by enabling drag-and-drop interactions and giving immediate visual feedback, without leaving the shop.

The target application of this tutorial will be a symfony ported version of the shopping cart demo published by script.aculo.us in Rails. It uses the prototype JavaScript framework (bundled with symfony) and some script.aculo.us JavaScript that is the core of the JavaScript helpers.

Application Setup

First, create a sfdemo project, an app application and a cart module:

$ cd /home/steve

$ mkdir sfdemo

$ cd sfdemo

$ symfony init-project sfdemo

$ symfony init-app app

$ symfony init-module app cart

Setup your web server to be able to access this new application (whether using a virtual host or an alias, as described in the web server setup chapter of the documentation). For this example, let's assume that this module is accessible via a localhost:

http://localhost/cart/

Congratulations, it says.

Your app must have access to the symfony JavaScript libraries. If your app doesn't work, check you can access these libraries within your browser (test http://localhost/sf/prototype/js/prototype.js for example). If not, you have 3 different ways to fix this problem:

· configure Apache with the following Alias:

·                Alias /sf /$data_dir/symfony/web/sf

· create a sf symbolic link in your web directory:

·                $ cd /home/steve/sfdemo/web

·                $ ln -sf /$data_dir/symfony/web/sf sf

· copy the JavaScript files in web/js directory:

·                $ cd /home/steve/sfdemo/web

·                $ mkdir -p sf/js

·                $ cp /$data_dir/symfony/web/sf/prototype/js/*.js sf/js/

The Main Page

First, you need to create a list of items to be purchased. To keep the project simple, the element list is accessed via a simple getProducts() method of the cart actions class. The shopping cart is a simple parameter of the sfUser object, set with the Attribute parameter holder. Modify the sfdemo/apps/app/modules/cart/actions/actions.class.php to:

class cartActions extends sfActions{

  public function executeIndex(){

    $this->getUser()->setAttribute('cart', array());

    $this->products = $this->getProducts();

}

   private function getProducts(){

    return array('iPod black', 'iMac', 'iMac RC', 'iPod');

}

}

The main page of the cart module will contain a list of items, and a zone to drag items to. This zone is the shopping cart. So open the template sfdemo/apps/app/modules/cart/templates/indexSuccess.php and write in:

<h1>symfony Apple store demo</h1>

<div id="shopping_cart">
<h2>Products:</h2>
<div id="product_list">
<?php foreach ($products as $id => $title): ?>
<?php echo image_tag('product'.$id, array(
'id' => 'product_'.$id,
'class' => 'products'
)) ?>
<?php endforeach; ?>
</div>
<h2>Cart:</h2>
<div id="cart" class="cart">
</div>
</div>

You can see that products are shown as images. Use the images available in this

archive, and put them in the sfdemo/web/images/ directory. In addition, part of the styling was done for you, so it is recommended that you upload this

stylesheet to the sfdemo/web/css/ directory and add a view.yml in the sfdemo/apps/app/modules/cart/config/ directory with the following content:

all:

  stylesheets:  [cart]

Now watch the chop and cart backdrop by requesting again:

http://localhost/cart/

Focus on the Cart

The cart content will change as you drag items to it. This means that the content of the cart in the template must be in an independent file. Use the include_partial() helper for that. The items in the shopping cart will be stored in divs with float:left style, so a clearing div is necessary after the container. So change the end of the indexSuccess.php template to:

The include_partial() helper will include a _cart.php file, and look for this file in the sfdemo/apps/app/modules/cart/templates/ directory. Create it with the following content:

<?php foreach ($sf_user->getAttribute('cart') as $product_id => $quantity): ?>
<div>
<?php for ($i = 1; $i <= $quantity; $i++): ?>
<?php echo image_tag('product'.$product_id, array(
'class' => 'cart-items',
'id' => 'item_'.$product_id.'_'.$i,
'style' => 'position:relative'
)) ?>
<?php endfor; ?>
(<?php echo $quantity ?> <?php echo $products[$product_id] ?>)
</div>
<?php endforeach; ?>

<?php if (!$sf_user->getAttribute('cart')): ?>
nothing yet in your shopping cart.
<?php endif; ?>

If the cart contains items, they appear as images, as many times as they are added; the quantity is be displayed after each series.

Now watch again the shopping cart at:

http://localhost/cart/

Well, there is not much change, it is still very empty... It's time to make things AJAX.

Add JavaScript Behaviors

Edit the indexSuccess.php template to require the JavaScript helper:

<?php use_helper('Javascript') ?>

Make the images draggable by adding the following call to the draggable_element JavaScript helper:

<?php foreach ($products as $id => $title): ?>
<?php echo image_tag('product'.$id, array(
'id' => 'product_'.$id,
'class' => 'products'
)) ?>
<?php echo draggable_element('product_'.$id, array('revert' => true)) ?>
<?php endforeach; ?>

This adds a 'draggable' behavior to each of the images of the list of products. The revert option will make images go back to their origin position when released (unless received by a receiving element).

Now, define the cart as a receiving element. You just need to define which part of the template will have to be updated when the event occurs, which action will be called for its content, and which type of draggable elements can be dragged into it. Use the drop_receiving_elements JavaScript helper for that:

<?php echo drop_receiving_element('cart', array(
'update' => 'items',
'url' => 'cart/add',
'accept' => 'products',
)) ?>

Now try again, and move the products to the cart: it works. When a draggable item is dragged to the receiving element, an XMLHTTPRequest is sent to the add action, and the result is displayed in the items div. The thing is, the add action of the cart module is not defined yet...

Define the Updating Action

Edit the sfdemo/apps/app/modules/cart/actions/actions.class.php to add an add action:

public function executeAdd()

  $tmp = split('_', $this->getRequestParameter('id', ''));

  $product_id = $tmp[1];

  $cart = $this->getUser()->getAttribute('cart');

  if (!isset($cart[$product_id]))

    $cart[$product_id] = 1;

  else

    ++$cart[$product_id];

  $this->getUser()->setAttribute('cart', $cart);

  $this->products = $this->getProducts();

This action looks for the parameter sent by the JavaScript (the id of the dragged item) and adds it to the cart.

The result of the add action will be the addSuccess.php template. It is a simple inclusion of the _cart.php partial, but this time it is necessary to pass the products as a parameter :

<?php include_partial('cart', array('products' => $products)) ?>

This template must not use the global layout, so edit the view.yml in the sfdemo/apps/app/modules/cart/config/ directory, and write in:

addSuccess:

  has_layout:   off

all:

  has_layout:   on

  stylesheets:  [cart]

Try it on: you can now add items to the cart by dragging them.

Focus on Usability

You could stop now, but this shopping cart has a big default: while the cart is updated, the interface doesn't change and the user might be disoriented. This is a general issue of asynchronous requests: an indicator zone has to be added to show that the request is being processed. In addition, nothing tells the user when the dragged item is considered accepted by the cart, so the hover style of the cart div also has to be defined.

To do that, edit the indexSuccess.php template and write in:

<div style="height:20px">
<p id="indicator" style="display:none">
<?php echo image_tag('indicator.gif') ?> updating cart...
</p>

</div>

Save the 'indicator.gif' image file to your sfdemo/web/images/ directory.

Now, modify the drop_receiving_element() JavaScript helper call in the same template to show this new indicator while requests are processed and declare the hover style:

<?php echo drop_receiving_element('cart', array(
'update' => 'items',
'url' => 'cart/add',
'accept' => 'products',
'script' => 'true',
'hoverclass' => 'cart-active',
'loading' => "Element.show('indicator')",
'complete' => "Element.hide('indicator')"
)) ?>

Conclusion

The complete source of the demo can be downloaded and is available online. You will notice a few minor differences with the code described in this tutorial (including a trash box), but the core behaviors are the same.

Until the full documentation of the JavaScript helpers is released, you can find more information about them in the script.aculo.us documentation.

Download and Install

You can choose between several alternatives to install symfony, from the simplest to the most advanced one. If you need a step-by-step guide, refer to the installation chapter of the symfony book.

The sandbox

The sandbox is an empty symfony project where all the required libraries are already included, and where the basic configuration is already done. It is made for symfony beginners, who want to play with the framework or try the tutorials without installing anything.

You can download a sandbox sf_sandbox.tgz. Unpack it in your root web directory. Refer to the included readme file for more information.

After downloading the sandbox, you might want to follow the My first project tutorial to discover the basics of symfony development.

Source Download

If you want to customize your own installation, or if you want to browse the symfony source without installing it, you might prefer a simple download. Beware that you will have to create shortcuts to the symfony libraries and binaries if you want to use it for a project. Refer to the installation chapter for more details.

Download a .tgz archive

http://www.symfony-project.org/get/symfony-stable.tgz

Checkout from the Subversion repository

To check out the 1.0 stable release, type in a command line:

$ svn co http://svn.symfony-project.com/branches/1.0

Use svn:externals

If your project is already under version control with SVN, you might want to use symfony as a svn:externals dependency. To do so, browse to the root of the project where you want to put symfony in, and type:

$ svn propedit svn:externals lib/vendor



// your favorite text editor then opens, and you must then type

symfony http://svn.symfony-project.com/branches/1.0

Browse the source online

Head to the source browser of the symfony trac.

PEAR installation

The PEAR installation is for those who want to run several symfony-based projects, with an easy way to upgrade. It requires PEAR version 1.4.0 or higher, which is bundled in most PHP distributions.

Type in the command line:

$ pear channel-discover pear.symfony-project.com

Then, to install the latest stable release:

$ pear install symfony/symfony

or to install the nightly release:

$ pear install symfony/symfony-beta

PEAR also provides an easy way to upgrade symfony, for instance to get the latest beta version:

$ pear upgrade symfony/symfony-beta

Linux installation

Some Linux distributions have symfony packages. As of now, packages have been created for Debian like distributions and SUSE.

Debian/Ubuntu package:

Add to your /etc/apt/sources.list:

  deb http://www.symfony-project.org/get debian/

Run as root:
```
  $ apt-get update
```
Install it:
```
  $ apt-get install php5-symfony
```

SUSE package is available in the server:php:applications repository:



http://software.opensuse.org/download/server:/php:/applications/

User-contributed guides

The symfony wiki contains a few articles describing step-by-step installations on various platforms.

The forum has a dedicated section where many installation issues have already been solved, and where you will find a symfony user willing to help you in minutes if you have a new problem

Documentation

You want to learn more about symfony? We have plenty of documentation for you.

The Definitive Guide to symfony

Also known as "The Book", this is the online version of a 490p book published by Apress and written by the symfony core team. Complete, didactic and practical, the definitive reference.

Read

The API Documentation

Every class, method and function in symfony has PHPDoc comments explaining the way it works. The best way to check the parameters of a function or the nature of the returned value is there.

Read Browse

The Cookbook

Recipies for everyday meals.

Read

Tutorials

My First Project

Discover the basics of symfony with this one-hour tutorial, covering installation, page creation, model modification, the admin generator, and much more...

Read Read for Doctrine Download

The Admin Generator

Discover the power of the administration generator. You will never code a backend application by hand after seeing this!

Watch Read Download

Askeet

24 tutorials of 1 hour each, that's all it takes to build up a complete and effective application from scratch. Definitely the best way to become a good symfony developer!

Read

Test Browse Download

Easy Ajax

Create a drag and drop shopping cart in minutes with symfony.

Watch Read Test Download

Reference : http://www.symfony-project.org

PHP technology video

Watch the latest videos on YouTube.com

PHP SMARTY

sky.dodiya@gmail.com (SKY) — Sat, 14 Jun 2008 04:28:00 +0000

PHP Smarty
Smarty is a web template system written in PHP. Smarty is primarily promoted as a tool for separation of concerns, which is a common design strategy for certain kinds of applications. Smarty generates web content by the placement of special Smarty tags within a document. These tags are processed and substituted with other code.

Tags are directives for Smarty that are enclosed by template delimiters. These directives can be variables, denoted by a dollar sign ($), functions, or logical or control flow statements. Smarty allows PHP programmers to define functions that can be accessed using Smarty tags.

Smarty is intended to simplify compartmentalization, allowing the presentation of a web page to change separately from the back-end. Ideally, this eases the costs and efforts associated with software maintenance. Under successful application of this development strategy, designers are shielded from the back-end coding, and PHP programmers are shielded from the presentation coding.

Smarty supports several high-level template programming features, including:

* Control flow statements, foreach
* if, elseif, else
* variable modifiers - For example {$variable|nl2br}
* user created functions
* mathematical evaluation within the template

along with other features. There are other template engines that also support these features. Smarty templates are often incorporated into existing PHP web applications to some extent. More often it is used where a web application or a website has a theme system built into it, where the templates can be changed from theme to theme.
Code example

Since Smarty separates PHP from HTML, you have two files:

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.1//EN”
“http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd”>
<html>
<head>
<title>{$title_text}</title>
<meta http-equiv=”content-type” content=”text/html; charset=iso-8859-1″ />
</head>
<body> {* This is a little comment that won’t be visible in the HTML source *}
<p>{$body_text}</p>
</body><!– this is a little comment that will be seen in the HTML source –>
</html>

In the business logic code you can configure Smarty to use this template:

define(’SMARTY_DIR’, ’smarty-2.6.9/’ );
require_once(SMARTY_DIR . ‘Smarty.class.php’);

$smarty = new Smarty();
$smarty->template_dir = ‘./templates/’;
$smarty->compile_dir = ‘./templates/compile/’;
$smarty->cache_dir = ‘./templates/cache/’;
$smarty->caching = false;
$smarty->error_reporting = E_ALL; // LEAVE E_ALL DURING DEVELOPMENT

$smarty->debugging = true;
$smarty->assign(’title_text’, ‘TITLE: This is the Smarty basic example …’);
$smarty->assign(’body_text’, ‘BODY: This is the message set using assign()’);
$smarty->display(’index.tpl’);

Notes and references

Smarty separates PHP code, (often represented as business logic) from HTML, (often represented as presentation logic).

Crash Course
For those of you who have used PHP template engines, the basic concepts
of Smarty should look quite familiar. In your PHP application you
assign variables for use in the template, then you display it.

index.php

include('Smarty.class.php');

// create object
$smarty = new Smarty;

// assign some content. This would typically come from
// a database or other source, but we'll use static
// values for the purpose of this example.
$smarty->assign('name', 'george smith');
$smarty->assign('address', '45th & Harris');

// display it
$smarty->display('index.tpl');

The template file then contains the output interspersed with tags that

Smarty replaces with assigned content.
index.tpl

<html>
<head>
<title>User Info</title>
</head>
<body>

User Information:<p>

Name: {$name}<br>
Address: {$address}<br>

</body>
</html>

Output

<html>
<head>
<title>User Info</title>
</head>
<body>

User Information:<p>

Name: george smith<br>
Address: 45th & Harris<br>

</body>
</html>

As you can see, Smarty cleanly separates your presentation elements
(HTML, CSS, etc.) from your application code. However, it does not
necessarily separate logic entirely from your templates. With respect
to Smarty's design principles, so long as the logic in the templates is
for presentation only, it is permissible to use it. For instance,
looping over table row colors or including one template from another
would be considered presentation logic. This is something the
application should not need to accomodate (it just supplies an array of
data.) The idea is to keep the template designer role and application
programming role separated. You should be able to completely tear down
the templates and rebuild them without touching the code base, all
while retaining full control of the presentation. With this comes an
important point: there is nothing stopping you from putting application
logic in the template. Smarty has more than enough power to let you
shoot yourself in the foot, so you must have some self discipline in
this respect. Don't worry though, with a little bit of practice it
becomes quite self-evident what logic belongs where.
Smarty has some nice features that take advantage of this design
principle, as you'll see in the next example. One prominant feature of
Smarty is variable modifiers. These are used to alter the output of
assigned variables from within the template. In our example, we would
like to display George's name capitalized, and we would like to
properly HTML escape the amphersand (&) symbol in the address. We also
show how to display the current date with a custom formatting.

index.tpl

<html>
<head>
<title>User Info</title>
</head>
<body>

User Information:<p>

Name: {$name|capitalize}<br>
Addr: {$address|escape}<br>
Date: {$smarty.now|date_format:"%Y-%m-%d"}<br>

</body>
</html>

Output

<html>
<head>
<title>User Info</title>
</head>
<body>

User Information:<p>

Name: George Smith<br>
Addr: 45th & Harris<br>
Date: 2003-12-19<br>

</body>
</html>

Using modifiers, we have just handed formatting control of the assigned
content over to the template and out of the application logic. Now we
can assign the raw data straight to the template (no mods necessary for
presentation purposes!) You can chain any number of modifiers together
on one variable, making this feature quite flexible. There are many
more modifiers that come with Smarty, or you can make your own with its
easy to use plugin architecture. Drop your new modifier into the plugin
directory, then mention it in the template!
Smarty also has what are known as template functions. Template
functions carry out tasks in the template that may or may not display
content. For example, you can include other templates from within a
template with the include function. Let's say you have many templates
with the same header and footer information. You can manage these as
separate templates and include them.

header.tpl

<html>
<head>
<title>{$title|default:"no title"}</title>
</head>
<body>

footer.tpl

</body>
</html>

index.tpl

{include file="header.tpl" title="User Info"}
User Information:

Name: {$name|capitalize}
Address: {$address|escape}
{include file="footer.tpl"}

Output

<html> <head> <title>User Info</title>
</head> <body>
User Information:<p>
Name: George Smith<br>
Address: 45th & Harris<br>
</body> </html>

One feature of the include function is locally scoped variables. Notice
that $title is a template variable not assigned directly to the
template, but assigned by passing it as an attribute to the include
function. This way the $title variable is only available within the
scope of the header template, and can be dynamically changed any time
the header.tpl file is included. Also, notice we used the default
modifier on $title so in the case $title is empty, the text "no title"
will show up instead of displaying nothing.
There are some nice functions that automate tasks such as html dropdown
boxes. One is html_options. You assign the arrays of data to the
template, then this function does all the work to generate the HTML
output for it.

index.php

include('Smarty.class.php');

// create object
$smarty = new Smarty;

// assign options arrays
$smarty->assign('id', array(1,2,3,4,5));
$smarty->assign('names', array('bob','jim','joe','jerry','fred'));

// display it
$smarty->display('index.tpl');

index.tpl

<select name=user>
{html_options values=$id output=$names selected="5"}
</select>

output

<select name=user>
<option label="bob"

value="1">bob</option>
<option label="jim"

value="2">jim</option>
<option label="joe"

value="3">joe</option>
<option label="jerry"

value="4">jerry</option>
<option label="fred" value="5"

selected="selected">fred</option>
</select>

Smarty facilitates a convenient way to loop over arrays of data with
the section function. Here's an example of that, and we also threw in
alternating row colors via the cycle function, and we use the strip
function to strip out newlines and white space.

index.php

include('Smarty.class.php');

// create object
$smarty = new Smarty;

// assign an array of data
$smarty->assign('name', array('bob','jim','joe','jerry','fred'));

// assign an associative array of data
$smarty->assign('users', array(
array('name' => 'bob', 'phone' => '555-3425'),
array('name' => 'jim', 'phone' => '555-4364'),
array('name' => 'joe', 'phone' => '555-3422'),
array('name' => 'jerry', 'phone' => '555-4973'),
array('name' => 'fred', 'phone' => '555-3235')
));

// display it
$smarty->display('index.tpl');

index.tpl

<table>
{section name=mysec loop=$name}
{strip}
<tr bgcolor="{cycle

values="#eeeeee,#dddddd"}">
<td>{$name[mysec]}</td>
</tr>
{/strip}
{/section}
</table>

<table>
{section name=mysec loop=$users}
{strip}
<tr bgcolor="{cycle

values="#aaaaaa,#bbbbbb"}">
<td>{$users[mysec].name}</td>
<td>{$users[mysec].phone}</td>
</tr>
{/strip}
{/section}
</table>

output

<table>
<tr
bgcolor="#eeeeee"><td>bob</td></tr>
<tr
bgcolor="#dddddd"><td>jim</td></tr>
<tr
bgcolor="#eeeeee"><td>joe</td></tr>
<tr
bgcolor="#dddddd"><td>jerry</td></tr>
<tr
bgcolor="#eeeeee"><td>fred</td></tr>
</table>
<table>
<tr
bgcolor="#aaaaaa"><td>bob</td><td>555-34
25</td></tr>
<tr
bgcolor="#bbbbbb"><td>jim</td><td>555-43
64</td></tr>
<tr
bgcolor="#aaaaaa"><td>joe</td><td>555-34
22</td></tr>
<tr
bgcolor="#bbbbbb"><td>jerry</td><td>555-
4973</td></tr>
<tr
bgcolor="#aaaaaa"><td>fred</td><td>555-3
235</td></tr>
</table>

Smarty also has built-in caching capabilities to help speed up the page
rendering. A copy of the template output is stored in a text file, then
that is displayed upon subsequent calls to the request instead of
dynamically rendering the page each time. This can speedup page
rendering substantially, especially if there is a lot of processing
involved to create the page such as database calls and variable
assignments.

index.php

include('Smarty.class.php');

// create object
$smarty = new Smarty;
$smarty->caching = true;

// see if the page is already cached
if(!$smarty->is_cached('index.tpl')) {

// not cached, so you might do some database queries here,
// then assign the returned content. We just use static
// values for this example.
$smarty->assign('name', 'george smith');
$smarty->assign('address', '45th & Harris');
}

// display it
$smarty->display('index.tpl');

You can also have multiple cached versions of a single page by passing
a unique cache id to the display() function, check out the docs on that
one!

There are many more builtin and custom functions that come with Smarty,
or you can make your own, again with the easy to use plugin
architecture.

Again, we'll take note that all of the functionality of Smarty
(modifiers, functions, etc.) deal exclusively with the presentation of
content. This is the design principle Smarty was built upon.

iPhone

sky.dodiya@gmail.com (SKY) — Tue, 10 Jun 2008 09:20:00 +0000

iPhone 3G

Watch the latest videos on YouTube.com

THE next-generation 3G Apple iPhone will be available in Australia on prepay plans without a contract when it is released here next month.

Both Optus and Vodafone – the first carriers to announce an iPhone offering – today confirmed they would offer the handset on a prepay plan, a key concern among the phone's target demographic.

Vodafone spokesman Greg Spears said customers would be able to buy an iPhone outright and purchase credit without being locked into a contract.

Features such as applications downloads, online synchronisation and email would be available on certain prepay plans, he said.

Both carriers have begun allowing customers to pre-register for an iPhone online and in retail stories.

Apple launched its new 3G iPhone this morning and slashed the cost to almost half the price of the existing model during the Worldwide Developer's Conference in San Francisco.

Chief executive officer Steve Jobs said the new phone would be smaller and faster and would appeal to the 56 per cent of people – Apple says – who want an iPhone but have not bought one because of the price.

The new version will be released in Australia on July 11th. Specific contract and pricing details for Australia have not yet been released.

In the US, the new 3G iPhone will cost from $US199 ($209.32) for the 8GB model to $US299 ($314.50) for 16GB.

Despite selling 6 million iPhones in one year, Apple said its research showed the cost of the previous model had put off would-be buyers.

The new model has 3G speeds faster than the Nokia N95 and Treo 750, according to Apple, and is almost on par with WiFi speeds.

It has better battery life, with almost 5 hours of 3G talk time, and sports a slimmer form. Some of the phone's more innovative features stem from Apple's software development program.

Apple is internationally launching a new App Store that will make applications available for download onto the iPhone. Games, office tools and even learning aids will be available for free, or around $US9.99 ($10.50), according to demonstrations.

Third-party developers will keep 70 per cent of revenue for applications sold through the App Store, which will add FairPlay digital rights management (DRM) to the files.

The company also announced MobileMe today, an online synchronisation tool that unifies data between computers and the iPhone using a web-based interface. This feature, which includes iDisk integration for online file storage and sending, will replace Apple's existing .mac service.

The iPhone 3G will be released with version 2.0 software, which includes support for Office and iWork documents, live contact search, bulk message delete, image saving, scientific calculator, language support and parental controls.

Mr Jobs' keynote address at the Worldwide Developer's Conference did not mention the iPhone's camera – which was expected to be upgraded from the existing 2 megapixel configuration – or video chat.

The next-generation model will be released in 22 countries on July 11th and will eventually reach 70 countries in total.

ThinkTank

Google Code Blog: Introducing Powerful Visualizations for your server-side data

Official Gmail Blog: Tip: Your email, wherever you are on the web, with Toolbar

Boost Traffic

HOW TO: Boost Your Blog Traffic

Blog Usability

Content

Technorati is Your Best Friend

Final Thoughts

SlideShow Viewer

Ajax autosuggest/autocomplete from database

PHP Examples

PHP Examples

PHP Examples

PHP Examples

Microsoft

Ajax

HTML 5

HTML 5 differences from HTML 4

Abstract

Status of this Document

Table of Contents

1. Introduction

1.1 Open Issues

1.2 Backwards Compatible

1.3 Development Model

1.4 Impact on Web Architecture

2. Syntax

2.1 Character Encoding

2.2 The DOCTYPE

2.3 Miscellaneous

3. Language

3.1 New Elements

3.2 New Attributes

3.3 Changed Elements

3.4 Absent Elements

3.5 Absent Attributes

4. APIs

4.1 Extensions to HTMLDocument

4.2 Extensions to HTMLElement

5. HTML 5 Changelog

Firefox 4

Windows Vienna

Java Persistence API

PHP - MYSQL EXAMPLES

Closing the Connection

Freeing the memory ?

Convert MySQL Query Result To Excel

Sony Ericssion

Nokia

Java Server Faces

PHP SYMFONY

Overview

Introduction

Application Setup

The Main Page

Focus on the Cart

Add JavaScript Behaviors

Define the Updating Action

Focus on Usability

Conclusion

The sandbox

Source Download

PEAR installation

Linux installation

User-contributed guides

The Definitive Guide to symfony

The API Documentation

The Cookbook

My First Project

The Admin Generator

Askeet

Easy Ajax

PHP SMARTY

iPhone

2.2 The `DOCTYPE`

4.1 Extensions to `HTMLDocument`

4.2 Extensions to `HTMLElement`