Web Developer

[PHP Script] Multi-level Comments

2011-06-05T19:22:00.000-07:00

No specific knowledge of PHP require
Easy to adapt in any existing homepage
Fully customizable
UI is fully controlled via CSS
Admin module to accpet and delete comments
Is compatible with php 4 and 5
All browsers support
Light weight
Clean Coded
Included Original PSD of bubble comments

Demo http://codecanyon.net/item/multilevel-comments/109293

Download

[PHP Script] Multi-level Comments

http://www.mediafire.com/file/0dmsd1kxphgmgu1/wdeveloper.blogspot.com_Multi-level%20Comments.rar

[PHP Script] Vivvo CMS v4.5.1 Business

2011-05-16T19:22:00.000-07:00

Link: http://www.vivvo.net/whatsnew/

Version: 4.5.1 (last version)

Download :

[PHP Script] Vivvo CMS v4.5.1 Business

http://www.mediafire.com/file/6daimdo1p9o3gro/wdeveloper.blogspot.com_Vivvo%20CMS%20v4.5.1%20Business.rar

Live Demo:

http://www.chinese.myvivvo.com

http://www.arabic.myvivvo.com

http://www.myvivvo.com

[PHP Script] Advanced PHP Protection

2011-05-16T18:40:00.000-07:00

Download

[PHP Script] Advanced PHP Protection

http://www.mediafire.com/file/i6jc52d64yq11t2/wdeveloper.blogspot.com_advanced-php-protection-source.zip

Key Features:
Works with any .php file.
Custom password and brute force warning pages.
Well documented functions.
Can easily be integrated into a database set up with multiple users.
Single line mode, protect any page by simply including the file.
Passwords can be set as either a md5 of sha1 hash or plain text if you prefer.
Server side brute force protection, with options to change the maximum number of attempts and the block duration.
No database or installation required.
Email support provided.
Light weight.

[JQuery Plugin] li JQuery Slider/Image Rotator

2011-05-12T11:20:00.000-07:00

Live Demo:
http://codecanyon.net/item/li-jquery-sliderimage-rotator/full_screen_preview/153638

Features

Easy to Use and Modify – it is extremely easy to use powerful slider/banner image rotator. The slider size has to be defined only on ONE PLACE and to set the options and the images. Tweaking the skins gives you full control over the layout.
Multiple Sliders / Banners – you can have many slider/image rotators on single HTML page.
104 unique transitions – with more than 104 transitions and additional options per transition you can achieve amazing results. Also you can define the following transitions behavior: Regular, Regular-Custom, Random-Custom, Regular-Exception, Random-Exception.
Skinable – 12 different skins – each skin has its own folder and is extremely well commented, so any modifications to the buttons images, position and etc. is extremely simplified.
LightBox Support – with this options enabled when a slides has been clicked you can load bigger picture in modal mode. You only need to include link to .jpg/.png/.gif and LightBox enabled and the linked image will be displayed in Lightbox modal window activated.
PrettyPhoto Support - when a link is included and the link points to YouTube, Vimeo, an image or QuickTime move, li-slider automatically will recognize what is the link type and will display it in a modal window.
Youtube Support – through prettyPhoto modal dialog.
Vimeo Support – through prettyPhoto modal dialog.
QuickTime Support – through prettyPhoto modal dialog.
Repeat Slides / Continues Sliding – with this options you can tell the slider to repeat the slides infinitely, to play all slides once and stop or to repeat all the slides given number of times.
Define Transition per Slide – you can tell the slider to play certain slide with specific transition. Every time when that slide will be displayed with the transition defined by you.
Define Transition duration per Slide – you can define different display time for each slide.
Define single slide display time – you can define different display time for each slide.
GoToSlideOnStart Option – the banner will start rotating at the given starting slide.
Timer – shows how much has remained until the next slide is displayed. The position of the timer can be controlled through an option.
Pause onMouseOver – if the slider is in play mode and you move the mouse over the slider, this option if "true" pauses the slider.
Tooltip – when you hover the small slide buttons, a thumbnail will popup. If you use image the thumbnail will be automatically generated so you do not need to create the thumbnails. If set to text, use the alt property of the image to include the tooltip text. The alt tag supports HTML tags as well.
Tooltip Size – defines the tooltip width size in percents of the slider from 0 to 100. If you use text tooltip and have more text than the width allows, the tooltip will expand upward (this is changeable through the skins CSS )
Autoplay – on start.
Shuffle – randomize the slides order so every time a random slide will be displayed when the page is loaded.
Delay - how long each slide to be displayed/visible.
Transition Period - how long transition to last.
Vertical Sectors - how many columns one transition has.
Squares - how many rows one transition has.
Hyperlinks – this is global option for the links and it could be turned on or off. The links allows you to use property target="_blank" to open the link in new tab/window.
Buttons Visibility – an option which allows you easily to hide all buttons.
Play/Pause buttons visibility – show or hide Play and Pause buttons.
Next/Previous buttons visibility – show or hide Next and Previous buttons through a single option.
Auto Hide – auto hide the buttons after certain amount of time if the mouse is not over the slider.
Buttons Hiding/Displaying Timing- with these four options you can control very precisely how fats or slow the navigation buttons will hide or show.
5 Public Methods – so you can control the slider from outside.
CSS Driven – the entire interface is purely CSS driven. This means that if you need to change the slider you do not need to tweak the JavaScript code.
iPhone/Smart Phone compatible – We’ve tested it. We’ve optimized slider. We made it versatile, so you know your content will be delivered to all devices and platforms.
Cross Browser Compatible – support all major browsers.
9 different animated GIF Slider Preloaders – There is nothing better than to aware the visitor that something will show up soon. The preloader will be visible until all the images included in the banner are loaded.
Unlimited number of images each with individual and adjustable tooltip, display duration, transition, transition duration and hyperlink.

Download

[JQuery Plugin] li JQuery Slider/Image Rotator

http://www.mediafire.com/file/c4l62cd066x6ts6/wdeveloper.blogspot.com_li%20JQuery%20SliderImage%20Rotator.rar

[Jquery Plugin] Lightbox evolution nonwp

2011-05-03T10:52:00.000-07:00

Link demo : http://codecanyon.net/item/jquery-lightbox-evolution/full_screen_preview/115655
Download jquery plugin Lightbox evolution nonwp
http://www.mediafire.com/file/bgm1198wpncg7ge/wdeveloper.blogspot.com-lightbox-evolution-nonwp.zip

[TUT] A Deeper Look at Advanced Select Queries

2011-04-15T10:33:00.000-07:00

A Deeper Look at Advanced Select Queries
By: John Cox
http://net.tutsplus.com/tutorials/databases/a-deeper-look-at-advanced-select-queries-new-premium-tutorial
To the SQL novice, joins can be intimidating and somewhat frustrating. Even when you think you have the query nailed, along comes an unexpected result which make you throw up your arms in surrender to the SQL gods. In this tutorial, we are going to build upon the excellent quick tip of working with MySQL and INNER JOIN recently posted and crack open the real power of a SELECT statement.

Tutorial Details

Program: MySQL
Difficulty: Moderate
Estimated Completion Time: 20 Minutes

Introduction

Think back to your earliest days of school where you were learning to group items, or learning basic math skills, or even how to spell. If your days of school were anything like mine, there were tons of exercises where there were pictures of things and you grouped those things together. It might have been ducks and cows, where you had to count each. It might have been word searches where you were given a block of seemingly random letters from which you had to find a list of words. You might remember "Which one of these are not like the other" game.

These basic games that everyone learns in their earliest days of school is exactly the same skills that you use when you are working with SELECTs. We just have a different syntax that we have to use. Every time we use a SELECT command we are simply grouping a data set. Using JOINs we are simply grouping multiple data sets. We are finding ducks and cows that are either similar or different and pushing that off into an array that we can work with in our logic layer. It's the syntax that is confounding, but what we are doing is the same thing that we did in our very earliest days of school.

"Every time we use a SELECT command we are simply grouping a data set. Using JOINs we are simply grouping multiple data sets. We are finding ducks and cows that are either similar or different and pushing that off into an array that we can work with in our logic layer. It's the syntax that is confounding..."

I am going to cover a few things in this tutorial, but none are extremely difficult to put into practice. I am using MySQL as my database, but for the most part I will be using simple SELECT syntax that should at least be familiar regardless of your flavor of SQL. For my query tool, I am using Sequel Pro for Mac which is relatively fast and descriptive for my purposes today. I am using a very simple table structure of animal types, farms, and wild. For those playing along at home, the table structure looks something like this:

--  
-- Table structure for table `animal_types`  
--  
  
CREATE TABLE `animal_types` (  
  `animal_type_id` int(11) NOT NULL AUTO_INCREMENT,  
  `animal_type_description` varchar(255) NOT NULL,  
  PRIMARY KEY (`animal_type_id`)  
) ENGINE=MyISAM  DEFAULT CHARSET=utf8 AUTO_INCREMENT=7 ;  
  
--  
-- Dumping data for table `animal_types`  
--  
  
INSERT INTO `animal_types` VALUES(1, 'duck');  
INSERT INTO `animal_types` VALUES(2, 'cow');  
INSERT INTO `animal_types` VALUES(3, 'goose');  
INSERT INTO `animal_types` VALUES(4, 'cat');  
INSERT INTO `animal_types` VALUES(5, 'sheep');  
INSERT INTO `animal_types` VALUES(6, 'horse');  
  
--  
-- Table structure for table `farm`  
--  
  
CREATE TABLE `farm` (  
  `animal_id` int(11) NOT NULL AUTO_INCREMENT,  
  `animal_type` int(11) NOT NULL,  
  `animal_description` varchar(255) NOT NULL,  
  `animal_name` varchar(255) NOT NULL,  
  PRIMARY KEY (`animal_id`)  
) ENGINE=MyISAM  DEFAULT CHARSET=utf8 AUTO_INCREMENT=5 ;  
  
--  
-- Dumping data for table `farm`  
--  
  
INSERT INTO `farm` VALUES(1, 2, 'spotted', 'Mal');  
INSERT INTO `farm` VALUES(2, 4, 'spotted', 'Zoe');  
INSERT INTO `farm` VALUES(3, 1, 'solid color', 'Wash');  
INSERT INTO `farm` VALUES(4, 2, 'solid color', 'Inara');  
  
--  
-- Table structure for table `wild`  
--  
  
CREATE TABLE `wild` (  
  `animal_id` int(11) NOT NULL AUTO_INCREMENT,  
  `animal_type` int(11) NOT NULL,  
  `animal_description` varchar(255) NOT NULL,  
  `animal_name` varchar(255) NOT NULL,  
  PRIMARY KEY (`animal_id`)  
) ENGINE=MyISAM  DEFAULT CHARSET=utf8 AUTO_INCREMENT=6 ;  
  
--  
-- Dumping data for table `wild`  
--  
  
INSERT INTO `wild` (`animal_id`, `animal_type`, `animal_description`, `animal_name`) VALUES(1, 2, 'spotted', 'Jayne');  
INSERT INTO `wild` (`animal_id`, `animal_type`, `animal_description`, `animal_name`) VALUES(2, 6, 'solid color', 'Kaylee');  
INSERT INTO `wild` (`animal_id`, `animal_type`, `animal_description`, `animal_name`) VALUES(3, 1, 'spotted', 'Simon');  
INSERT INTO `wild` (`animal_id`, `animal_type`, `animal_description`, `animal_name`) VALUES(4, 3, 'solid color', 'River');  
INSERT INTO `wild` (`animal_id`, `animal_type`, `animal_description`, `animal_name`) VALUES(5, 5, 'solid color', 'Sheppard');  

Back to Basics: Breaking the Shortcut Habit

Since it is the syntax, and not necessarily the concepts that are difficult, we should take a couple of steps back and remember some of the basics. There are many different shortcuts that you can take in writing a SELECT, but many times those shortcuts will cause trouble down the line. I tend to write my queries out, so that I don't have ambiguous column names, and I can see exactly what I am expecting to get.

Let's first start with my animal_types table which has a few animal types entered in. If I wanted to select everything in that table, I could write my select like so:

SELECT *  
FROM animal_types  

Which would give me a data set of:

The problem with using the " * " selector is that a year from now I probably will not remember what I am expecting from this SELECT. Furthermore, when I am joining tables, I will probably have ambiguous column names, meaning there are multiple columns that have the same name, thus SQL has no way of setting the results apart. Instead, let's be specific, which takes just a little more typing, but corrects some of these problems with taking shortcuts:

SELECT animal_type_id,  
       animal_type_description  
  
FROM animal_types

Which gives the exact data set back, but I see exactly what I should be getting back:

Even though we are explicitly naming our column names, we can go just a little bit further, and that is explicitly saying these columns belong to this table. This is another shortcut that we take all the time, which adds just a little more time to writing queries, but ends up saving the debugging time later when you are joining other tables. Instead of our last query, let's instead explicitly prefix our columns with a table prefix:

SELECT att.animal_type_id,  
       att.animal_type_description  
 
FROM animal_types att  

We have added the prefix on the table animal_types of att, which tells SQL, when you see the prefix of u, realize that it belongs to the table named animal_types. Our data set looks exactly the same again:

Let's also tell SQL what to name our columns when it gives us our results. Many times when you are working with JOINs or other advanced queries, two columns will have the same name, which makes it difficult to distinguish in your logic layer. I like to explicitly tell SQL to deliver my column names in the manner that I want, and not necessarily as they are named. To do this, we are going to use the AS keyword:

SELECT att.animal_type_id AS animal_type_id,  
       att.animal_type_description AS animal_type_description  
  
FROM animal_types att  

Which again gives us the exact same data set but we have again been even more explicit in our query:

There is one more way to be sure that I am telling SQL to SELECT exactly what I want, and from where I want, and that is to add the database prefix onto my table. Programming languages and different tools make it very easy for the database name to be implied, but there are times where you might call a different database in a query. When you add the database prefix you take the implication of working with a single database out of the mix.

SELECT att.animal_type_id AS animal_type_id,
       att.animal_type_description AS animal_type_description

FROM tutorial.animal_types att

Again, exact same data set:

Except now we are telling SQL to explicitly look in the database "tutorial" for the table "animal_types". Again, this comes in handy when we are pulling information from multiple databases into a single select.

Sub-Selects: Multiple Selects Bundled Together

MySQL 4.1 added the ability to use Sub-Selects. A word of caution on Sub-Selects before we get too deep into them, use them wisely. The execution plan for Sub-Selects may well be much different than you would imagine, and thus when you believe that you are using an INDEX, you are really working with a full table scan. In my experience, you can optimize your Sub-Selects to be just as performance friendly as a natural join, but when you are dealing with optimization you will want to pay close attention to the EXPLAIN results on your query. For more information, take a look at a recent MySQL optimization tutorial which gives you insight on the query execution plans.

What a Sub-Select is basically executing a SELECT statement within a SELECT statement. Let's take a look at a very common use:

SELECT f.animal_id AS animal_id,  
       f.animal_type AS animal_type,  
       f.animal_description AS animal_description,  
       f.animal_name AS animal_name  
  
FROM tutorial.farm f  
  
WHERE f.animal_type IN (SELECT att.animal_type_id FROM tutorial.animal_types att where att.animal_type_id = 2)  

Which gives us a data set of:

In this case we are saying to return all farm animals that have are of an animal type 2. Let's build on this just a bit, and instead look for animal type 1 or 2.

SELECT f.animal_id AS animal_id,  
       f.animal_type AS animal_type,  
       f.animal_description AS animal_description,  
       f.animal_name AS animal_name  
  
FROM tutorial.farm f  
  
WHERE f.animal_type IN (SELECT att.animal_type_id FROM tutorial.animal_types att where att.animal_type_id = 2 OR att.animal_type_id = 1)  

Which now gives us a result of:

We are using the IN keyword to tell SQL to look at the results from our Sub-Select. In this case, we could easily rewrite this to not use a Sub-Select and get the same results:

SELECT f.animal_id AS animal_id,  
       f.animal_type AS animal_type,  
       f.animal_description AS animal_description,  
       f.animal_name AS animal_name  
  
FROM tutorial.farm f  
  
WHERE f.animal_type IN (1, 2) 

Exact same results as before:

However, when we change our Sub-Select to be something like:

SELECT f.animal_id AS animal_id,  
       f.animal_type AS animal_type,  
       f.animal_description AS animal_description,  
       f.animal_name AS animal_name  
  
FROM tutorial.farm f  
  
WHERE f.animal_type IN (SELECT att.animal_type_id FROM tutorial.animal_types att where att.animal_type_description LIKE "%duck%" OR att.animal_type_description LIKE "%cow%")  

We begin to see the power:

We can use a Sub-Select to search and give us a data set to limit our farm results. We can take this just a bit further by also using a Sub-Select in our query SELECT. Say for instance that we want to get the animal_type_description as a Sub-Select in our main query:

SELECT f.animal_id AS animal_id,  
       f.animal_type AS animal_type,  
       f.animal_description AS animal_description,  
       f.animal_name AS animal_name,  
       (SELECT att.animal_type_description FROM tutorial.animal_types att where att.animal_type_id = f.animal_type) AS description  
  
FROM tutorial.farm f  
  
WHERE f.animal_type IN (SELECT att.animal_type_id FROM tutorial.animal_types att where att.animal_type_description LIKE "%duck%" OR att.animal_type_description LIKE "%cow%")  

Which returns:

In this query we are placing a condition on our Sub-Select to return the animal_type_description when it matches the f.animal_id. This condition will last for this pass, and will be reset on the next data set. Basically, we have joined our tables together by simply using a Sub-Select. Again, re-read the caution from the beginning of this section on the performance, but as you can see you can use a Sub-Select to quickly join a table based on a condition performed in the Sub-Select.

INNER JOINS: The Exclusive Club

With Sub-Selects out of the way, let's get to an INNER JOIN. I have always seen joins taught with nice looking circles which show where the JOIN is selecting. I would rather think of joins in a more natural learning way which I learned in grade school of grouping pictures. I always visualize what I am wanting to get from my query before I write it. When I visualize an exclusive relationship, that's when I use an INNER JOIN.

For instance, let's say that I want to see the animal type description for my farm animals, but only when an animal type id exists. I could write an INNER JOIN that would return this result:

SELECT f.animal_id AS farm_animal_id,  
       f.animal_type AS farm_animal_type,  
       f.animal_description AS farm_animal_description,  
       f.animal_name AS farm_animal_name,  
       att.animal_type_description AS description  
  
FROM tutorial.farm f  
  
INNER JOIN tutorial.animal_types att  
ON f.animal_type = att.animal_type_id;  

Which returns:

Awesome. That said, this example does not show the exclusivity that we get from our INNER JOIN. Let's do something that happens every day with our data structure and delete an entry from our definition look up table, animal types. I am going to delete the "cat" description:

DELETE FROM animal_types  
WHERE animal_type_description = "cat"  

And now I want to re-run my original query:

SELECT f.animal_id AS farm_animal_id,  
       f.animal_type AS farm_animal_type,  
       f.animal_description AS farm_animal_description,  
       f.animal_name AS farm_animal_name,  
       att.animal_type_description AS description  
  
FROM tutorial.farm f  
  
INNER JOIN tutorial.animal_types att  
ON f.animal_type = att.animal_type_id;  

Which now only returns three results:

All I have done is removed an attribute from my look-up table, and "Zoe" is still in my farm animals table:

SELECT f.animal_name as name
FROM tutorial.farm f

But since there is not a match in my animal types table, I will not get a result from my farm animals.

Let's play the matching game with our wild animals table to test the concept a little more:

SELECT w.animal_id AS wild_animal_id,  
       w.animal_type AS wild_animal_type,  
       w.animal_description AS wild_animal_description,  
       w.animal_name AS wild_animal_name,  
       att.animal_type_description AS description  
  
FROM tutorial.wild w  
  
INNER JOIN tutorial.animal_types att  
ON w.animal_type = att.animal_type_id  

Which gives us a result of:

Again, always remember an INNER JOIN is going to return data from two tables where there is a match in both of the tables. When you compare two pictures and make a single picture from the two, you will only be drawing the matches.

OUTER JOINS: The Descriptive Club

INNER JOINs are easy to use, but can be limiting. There are two types of joins with MySQL which do not have the exclusivity rules, and they are LEFT OUTER JOIN and RIGHT OUTER JOIN. Other SQL databases also have a FULL OUTER JOIN, which you can simulate in MySQL with a UNION. I tend to exclusively use LEFT OUTER JOINs, as I think of my OUTER JOINS as adding description to my SELECT statements.

When you are using a LEFT OUTER JOIN you are basically saying, get me everything from the LEFT table and join anything that matches the condition from the RIGHT table non-exclusively:

SELECT f.animal_id AS farm_animal_id,  
       f.animal_type AS farm_animal_type,  
       f.animal_description AS farm_animal_description,  
       f.animal_name AS farm_animal_name,  
       att.animal_type_description AS description  
  
FROM tutorial.farm f  
  
LEFT OUTER JOIN tutorial.animal_types att  
ON f.animal_type = att.animal_type_id  

Gives us a result of:

Our farm table is our LEFT table as that is where my natural selection comes from, and it will always return a result from the LEFT table, even when there is nothing that matches from our RIGHT table. Let's take a look at an example of a RIGHT OUTER JOIN using the same basic SELECT:

SELECT f.animal_id AS farm_animal_id,  
       f.animal_type AS farm_animal_type,  
       f.animal_description AS farm_animal_description,  
       f.animal_name AS farm_animal_name,  
       att.animal_type_description AS description  
  
FROM tutorial.farm f  
  
RIGHT OUTER JOIN tutorial.animal_types att  
ON f.animal_type = att.animal_type_id 

Which gives us a result of:

Which in my mind is not nearly as useful as a data set, because I end up will NULL entries in my LEFT data set. When I write a query, I generally want to know everything in my LEFT without those nasty NULL entries to deal with. Where OUTER JOINS really come in handy is when we are joining multiple tables together to build upon the information. Lets add a new look up table to the mix for our descriptions of whether the animal is striped, spotted or solid:

--  
-- Table structure for table `animal_descriptions`  
--  
  
CREATE TABLE `animal_descriptions` (  
  `animal_description_id` int(11) NOT NULL AUTO_INCREMENT,  
  `animal_description` varchar(255) NOT NULL,  
  PRIMARY KEY (`animal_description_id`)  
) ENGINE=MyISAM  DEFAULT CHARSET=utf8 AUTO_INCREMENT=4 ;  
  
--  
-- Dumping data for table `animal_descriptions`  
--  
  
INSERT INTO `animal_descriptions` VALUES(1, 'Spotted');  
INSERT INTO `animal_descriptions` VALUES(2, 'Striped');  
INSERT INTO `animal_descriptions` VALUES(3, 'Solid Color');  

And after I change the values in my farm and wild tables to integers to match my description ids, I can then make multiple OUTER joins on my original query:

SELECT f.animal_id AS farm_animal_id,  
       f.animal_type AS farm_animal_type,  
       d.animal_description AS farm_animal_description,  
       f.animal_name AS farm_animal_name,  
       att.animal_type_description AS description  
  
FROM tutorial.farm f  
  
LEFT OUTER JOIN tutorial.animal_types att  
ON f.animal_type = att.animal_type_id  
  
LEFT OUTER JOIN tutorial.animal_descriptions d  
on f.animal_description = d.animal_description_id  

We are saying give me all farm animal names, and while you are at it, give me the type of animal it is, as well as the description of the animal, even when there might not be a match for the farm animal in the RIGHT tables:

Bam! We have what we are after. The only limit to a join is your imagination and the performance of your database server. The more that you normalize, the more that you will probably have the need to add non-exclusive description to you results.

Combining JOINS: Mix and Match

There are times where you need exclusivity on a join, but want description from another join. There is no law (except in Iceland, parts of Nova Scotia, and Eastern Kentucky) that states that you can not use both INNER joins and OUTER joins in the same SELECT. Let's take a look at our wild animals for a moment:

We have one animal that is striped. Let's remove striped from our new animal description table, and then just use LEFT OUTER JOINs to simulate our last example from the wild side:

DELETE FROM tutorial.animal_descriptions where animal_description_id = '1'  

And to select from our wild animals just as we did our farm animals:

SELECT w.animal_id AS wild_animal_id,  
       w.animal_type AS wild_animal_type,  
       d.animal_description AS farm_animal_description,  
       w.animal_name AS wild_animal_name,  
       att.animal_type_description AS description  
  
FROM tutorial.wild w  
  
LEFT OUTER JOIN tutorial.animal_types att  
ON w.animal_type = att.animal_type_id  
  
LEFT OUTER JOIN tutorial.animal_descriptions d  
on w.animal_description = d.animal_description_id  

Which gives us a NULL value where our Striped animal description used to be:

That's all well and good, until you realize that your data structure is no longer intact because of that NULL value. Let's combine our OUTER join description with the exclusivity of an INNER JOIN on our description:

SELECT w.animal_id AS wild_animal_id,  
       w.animal_type AS wild_animal_type,  
       d.animal_description AS farm_animal_description,  
       w.animal_name AS wild_animal_name,  
       att.animal_type_description AS description  
  
FROM tutorial.wild w  
  
LEFT OUTER JOIN tutorial.animal_types att  
ON w.animal_type = att.animal_type_id  
  
INNER JOIN tutorial.animal_descriptions d  
on w.animal_description = d.animal_description_id  

Which gets rid of that NULL value, which might be the difference of a bug in your application because of a data integrity issue, and peace and quiet on the weekend:

We can also self join a table which comes in handy from time to time. What we are doing when joining tables together is getting information from table.a and combining it table.b. SQL doesn't really care if table.b is the same table as table.a. Here's an example:

SELECT w.animal_id AS wild_animal_id,  
       w.animal_type AS wild_animal_type,  
       d.animal_description AS farm_animal_description,  
       same.animal_name AS wild_animal_name_from_same_table,  
       att.animal_type_description AS description  
  
FROM tutorial.wild w  
  
LEFT OUTER JOIN tutorial.animal_types att  
ON w.animal_type = att.animal_type_id  
  
INNER JOIN tutorial.animal_descriptions d  
on w.animal_description = d.animal_description_id  
  
LEFT OUTER JOIN tutorial.wild same  
ON w.animal_id = same.animal_id  

In this example, we are combining the same wild table to itself on animal id to get restate it's name:

While the result might not be that interesting in this example, think about how many times in your applications that you have created multiple tables to express a parent to child relationship. You could easily cut out the multiple table structure by joining a table on itself to change the meaning of the relationship.

Unions: A Different Way to Join

Even with INNER, OUTER, Sub-Selects tools at our disposal, we find ourselves needing even further tools to get the right data set at times. Sometimes we need to get information about wild animals as well as our farm animals. We have basically three pictures of ducks and cows that need to be combined into a single picture. Enter a UNION.

A UNION is the combination of multiple queries which combine our data sets into one. Let's take the situation where we want a description of all animals, whether farm or wild. We can simply express that using a UNION:

view plaincopy to clipboardprint?
SELECT f.animal_id AS animal_id,  
       f.animal_type AS animal_type,  
       d.animal_description AS animal_description,  
       f.animal_name AS animal_name,  
       'Farm' AS domain,  
       att.animal_type_description AS description  
  
FROM tutorial.farm f  
  
LEFT OUTER JOIN tutorial.animal_types att  
ON f.animal_type = att.animal_type_id  
  
LEFT OUTER JOIN tutorial.animal_descriptions d  
ON f.animal_description = d.animal_description_id  
  
UNION ALL  
  
SELECT w.animal_id AS animal_id,  
       w.animal_type AS animal_type,  
       d.animal_description AS animal_description,  
       w.animal_name AS animal_name,  
       'Wild' AS domain,  
       att.animal_type_description AS description  
  
FROM tutorial.wild w  
  
LEFT OUTER JOIN tutorial.animal_types att  
ON w.animal_type = att.animal_type_id  
  
LEFT OUTER JOIN tutorial.animal_descriptions d  
ON w.animal_description = d.animal_description_id  

In this UNION the one thing that I have not explained is the explicit column "domain". I am merely saying either give me "Farm" or "Wild" depending on when you are running. I am also using UNION ALL instead of UNION as I want all results and not just distinct values. Our complex query gives us the expected data set that we were hoping for:

We can also use a Sub-Select in our UNION:

SELECT f.animal_id AS animal_id,  
       f.animal_type AS animal_type,  
       d.animal_description AS animal_description,  
       f.animal_name AS animal_name,  
       'Farm' AS domain,  
       att.animal_type_description AS description  
  
FROM tutorial.farm f  
  
LEFT OUTER JOIN tutorial.animal_types att  
ON f.animal_type = att.animal_type_id  
  
LEFT OUTER JOIN tutorial.animal_descriptions d  
ON f.animal_description = d.animal_description_id  
  
UNION ALL  
  
SELECT w.animal_id AS animal_id,  
       w.animal_type AS animal_type,  
       d.animal_description AS animal_description,  
       w.animal_name AS animal_name,  
       'Wild' AS domain,  
       att.animal_type_description AS description  
  
FROM tutorial.wild w  
  
LEFT OUTER JOIN tutorial.animal_types att  
ON w.animal_type = att.animal_type_id  
  
LEFT OUTER JOIN tutorial.animal_descriptions d  
ON w.animal_description = d.animal_description_id  
  
WHERE w.animal_id IN (SELECT animal_id FROM wild WHERE animal_id <= 3)  

Basically saying give me a union of the two queries, but only give me the results in the wild side that have an animal id less than or equal to 3. The produced data set is just as expected:

Unions are very easy to use, but a couple of notes. The first side of the UNION will determine the name of the column. In addition, both sides of the UNION must have the identical column numbers. You can't have one query with 4 columns of data with the other query with 3.

Simulating a FULL OUTER JOIN: Practical Use

We can tie up everything that we have learned by simulating a FULL OUTER JOIN which as I stated above MySQL does not support by using a simple UNION statement. Let's use the original query from the beginning of the tutorial:

SELECT f.animal_id AS farm_animal_id,  
       f.animal_type AS farm_animal_type,  
       d.animal_description AS farm_animal_description,  
       f.animal_name AS farm_animal_name,  
       att.animal_type_description AS description  
  
FROM tutorial.farm f  
  
LEFT OUTER JOIN tutorial.animal_types att  
ON f.animal_type = att.animal_type_id  
  
LEFT OUTER JOIN tutorial.animal_descriptions d  
on f.animal_description = d.animal_description_id  
  
UNION  
  
SELECT f.animal_id AS farm_animal_id,  
       f.animal_type AS farm_animal_type,  
       d.animal_description AS farm_animal_description,  
       f.animal_name AS farm_animal_name,  
       att.animal_type_description AS description  
  
FROM tutorial.farm f  
  
RIGHT OUTER JOIN tutorial.animal_types att  
ON f.animal_type = att.animal_type_id  
  
RIGHT OUTER JOIN tutorial.animal_descriptions d  
on f.animal_description = d.animal_description_id  

In this case I am using a UNION statement instead of the UNION ALL statement as I just want distinct values. Here's my result set:

Conclusion

Even with my fingers getting callouses from the amount of typing to explain advanced queries, I really have really only scratched the surface. I have done my best to explain joins without the same illustrations of circles showing the affective areas. Those illustrations work, but I think if you lean on your grade school experiences and think "Which one of these is not like the other" you are putting a little more context on the idea of joining data sets and tables. If you visualize your SELECT statements it becomes so much easier to get that result that you have in mind. If I have missed anything, just let me know in the comment section.

[TUT] Building an Advanced "Poll" jQuery Plugin

2011-04-14T03:00:00.000-07:00

Building an Advanced "Poll" jQuery Plugin
By: Dan Wellman
http://net.tutsplus.com/articles/news/plus-tutorial-build-an-advanced-poll-jquery-plugin-and-a-giveaway/
In this tutorial we’re going to be creating a jQuery plugin from start to finish; this plugin will allow us (or other developers) to easily add a simple poll widget to a web page or blog. By poll widget, I mean an area in which a question is posed which visitors are encouraged to answer. Once they have answered the question the results of the poll will then be displayed.

Final Product
The following screenshot shows what we’ll be working towards:

The plugin will use jQuery goodness to generate the DOM structure of the widget, as well as capture the answer to the question and pass it to the server for storage. We’ll use a little basic PHP to add the newest vote to a MySQL database and then echo back the new results in a JSON object. jQuery will then be used to process the response and display the results (as shown above) in the widget.

Although installing and configuring a web server, PHP and MySQL is beyond the scope of this tutorial, we will be looking at all of the steps needed including setting up the database. All in all, we’ll be working with CSS, HTML, jQuery, PHP, MySQL and JSON during the course of this tutorial.

Prep Work

We should set up our development area first of all. To run this example on a desktop computer (for development, testing etc) we’ll need to run the example files from a directory our web server can serve content from. I use Apache and have a folder setup on my C drive called apache site. This is the content-serving directory for my localhost. Within this folder (or the equivalent folder on your system) we should create a new folder called poll. This is where all of our example files will be stored.

To create a jQuery plugin, we’re also going to need a copy of jQuery itself; the latest version is 1.31.js and can be found at http://jquery.com. Download it to the poll directory we just created. So far the folder should look like this in Explorer (or equivalent file explorer application):

Next we can set up the database that will be used to store the poll results; we can do this easily enough using the MySQL Command Line Interface(CLI) easily enough, although database front-end GUIs can also be used. Open up the MySQL CLI and create a new database called poll using the following command:

CREATE DATABASE poll;

The CREATE DATABASE command does exactly what it says on the tin and creates a new database with the specified name. Once we have a database we’ll need to create a new table in which to store the poll results. Before we can do this we need to select the new database; the USE command will do this:

USE poll;

To create a new table we use the CREATE TABLE command, specifying the names for the columns within the table:

CREATE TABLE results(choices VARCHAR(20), votes INT);
If we were deploying this on a site we’d start off with an empty table, but so that we can see some results without answering the question ourselves repeatedly, we can enter some dummy data into the table. The quickest and easiest way to do this for small sets of data (just 5 rows in this example) is to do it manually, which we can do with the following series of commands:

INSERT INTO results VALUES(‘choice0’, 100);
INSERT INTO results VALUES(‘choice1’, 67);
INSERT INTO results VALUES(‘choice2’, 11);
INSERT INTO results VALUES(‘choice3’, 51);
INSERT INTO results VALUES(‘choice4’, 38);

The command should be straight-forward enough, just remember to hit enter after each line. The only point worthy of note is that the first row is choice0 instead of choice1 which is done to make working with the JSON object in our script easier. At this point your CLI should appear something like the following screenshot:

We’re done with the CLI now so we can exit it and move on to our next task – creating the plugin.

Building the Plugin

We have a number of tasks to complete with the plugin code; we need to create the DOM structure for the widget, add a handler that listens for submission of the selection, pass the results to the server and process the response, as well as displaying the results once processed. We can also add some sugar in the form of error messages and animated results.

It’s going to take a few lines of code for sure, but it should be worth it as we’ll get to see how easy it is to make a robust, functional and advanced plugin that provides interactivity and adds value to the page. Let’s make a start; in a new file in your text editor add the following code:

(function($) { })(jquery)

All of our plugin code will be encapsulated within this self-executing anonymous function. It’s the additional braces after the function that makes it self-executing, and these also allow us to pass arguments into our plugin. In this example, we’re passing the jQuery object into our plugin so that we can make use of all of jQuery’s amazing functionality. The function receives jqueryas the $ alias which is how we can work with the library from within our plugin. Now within the function add the following code

//define jPoll object with some default properties
$.jPoll = {
  defaults: {
    ajaxOpts: {
      url: "poll.php"
    },
    groupName: "choices",
    groupIDs: ["choice0", "choice1", "choice2", "choice3", "choice4"],
    pollHeading: "Please choose your favourite:",
    rowClass: "row",
    errors: true
  }
};

This code adds a new object to jQuery called jPoll. Within this object is another object called defaults which contains a number of different properties. Each property will be a configurable option for our plugin that implementers can change according to their requirements. It’s useful to provide as many configurable properties as possible to give the plugin flexibility and robustness.

The first property we set is the ajaxOpts property, the value of which is another object. This object will be used to make the request to the server. We make the URL of the back-end script file a configurable property so that developers can specify their own server-side file to take the result and pass it into the database if required.

Because the values in each property are simply defaults to fall back on if implementers don’t specify them explicitly, we should try to make them as generic as possible, so, for example, thegroupName property, which will be applied to the radio buttons we’ll be creating later, is given the value choices. The groupIDs property accepts an array of values; the array items will be used as labels for the radio buttons and indicate to the visitor the options they have when making a choice.

The rowClass property is used to add a class name to the row elements which will act as containers for the radio buttons and results. The errors property is set to the boolean value true. This allows implementers to switch off the automatic error message if they wish. Flexibility is the key when deciding which features of a plugin should be configurable.

Let’s continue by adding the following code directly after our default configuration object:

//extend jquery with the plugin $.fn.extend({ jPoll:function(config) { } });

The jQuery fn.extend method is a special construct provided by jQuery for the creation of plugins; it allows us to add additional methods to jQuery, so our plugin actually becomes part of the library. The method accepts an object which in this example contains a single property – our plugin.

All of our plugin code will be placed within the anonymous function that is specified as the value of the property. This function accepts a single argument and is how implementers supply their own configuration object to alter the default options we added earlier.

Now we can add the code for our plugin that will create the initial DOM structure and render the widget. Within the anonymous function we just created add the following code:

//use defaults or properties supplied by user config = $.extend({}, $.jPoll.defaults, config);

The extend jQuery method takes the object supplied to our plugin (if it’s provided by the implementer) and applies it to our default configuration object. Any properties supplied by the developer will overwrite the defaults. The method works in a similar way to the fn.extend method although on a smaller scale. Now we can start creating elements:

//init widget $("&lt;h2&gt;").text(config.pollHeading).appendTo($(this)); $("&lt;form&gt;").attr({ id: "pollForm", action: config.ajaxOpts.url, method: config.ajaxOpts.type }).appendTo($(this));

First we create a heading which can be used to display the question at the top of the widget. We can then create a form element and append it to the widget using jQuery’s appendTomethod. We can also set some of the form’s attributes.

Within the context of this part of the plugin, the $(this) object refers to the element that our plugin is called on; the HTML page on which it is used will need a container element for the widget to be rendered into and the plugin will be called on the container. Therefore $(this) will refer to the container element. Next we can add the radio buttons and labels that will form the choices a visitor can make:

for(var x = 0; x &lt; config.groupIDs.length; x++) { $("&lt;div&gt;").addClass(config.rowClass).appendTo($(this).find("form")); $("&lt;input type='radio' name='" + config.groupName + "' id='" + config.groupIDs[x] + "'&gt;").addClass("choice").appendTo($(this).find("form").children(":last")).click(function() { ($(".error").length != 0) ? $(".error").slideUp("slow") : null ; }); $("&lt;label&gt;").text(config.groupIDs[x]).attr("for", config.groupIDs[x]).appendTo($(this).find("form").children(":last")); }

The number of choices the visitor can make is dictated by the number of items in the groupIDs array, which by default is five. We loop through the array, which we can access via the config object. On each iteration we create a container element and give it the class name specified by the rowClass property before appending it to the form.

We then create a radio button and append it to the container we added a moment ago. You might be wondering why we specify the attributes for the radio button in-line with its constructor instead of using jQuery’s attr method as we do with other elements. The reason is simply because of a bug in IE that prevents the use of dynamic radio buttons. The structure of these elements will be as highlighted in the following Firebug screenshot:

Additional Elements

We also add a click handler for each radio which is trigged when it is selected by the visitor; all the function does is check whether there is one or more elements with the class name error and if so, hides them using the slideUp jQuery animation. We don’t need to worry about checking whether the implementer has disabled the error property at this stage because if no errors are detected, the function will just return false.

Next we add a label for the radio button indicating which choice it refers to. For accessibility we add a for attribute so that the label is associated with the radio that it shares the container div with. Both the label and the radio are attached to the container div using the find and children methods.

To make the plugin as least restrictive as possible we want to refer to as few things as possible using a set ID so using find to return the first form (which will be the one we added ourselves) within the element in the context of $(this), and then selecting the last child allows us to add the elements to the correct container without needing an ID. After the for loop we still need to add a couple more elements:

$("div").attr("id", "buttonRow").addClass(config.rowClass).appendTo($(this).find("form"));

We add a final container to the widget which will be used to hold the submit button for the form. We’ll add the button a little later on. Save what we’ve done so far as jquery.jpoll.js into the poll directory. At this stage, we can move on to create the HTML page which the widget will be added to, as well as a little basic styling. We added quite a bit of code already and so far I’ve said things like ‘add this code within the function’ etc. The following screenshot shows how the code should appear at this point:

Some Basic HTML and CSS

In a new page in your text editor, create the following very basic page:

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
  <head>
    <<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
    <title>Poll Test</title>
    <link rel="stylesheet" type="text/css" href="poll.css">
  </head>
  <body>
    <div id="pollContainer"></div>
    <script type="text/javascript" src="jquery-1.3.1.min.js"></script>
    <script type="text/javascript" src="jquery.jpoll.js"></script>
    <script type="text/javascript">
      $("#pollContainer").jPoll();
    </script>
  </body>
</html>

Save this as pollTest.html in the poll folder we created earlier. That’s pretty much it as far as the HTML is concerned but it’s all we need. It’s totally minimal, basically a template file that links to an external stylesheet, the jQuery library, and our plugin file. The body of the page has just the required container element present, and in a custom script block we call the jPoll method that we’ve added to jQuery.

The CSS we’ll be using in the example is also pretty basic and is intended to present the widget in a simple skin that highlights its features. None of the CSS is required to control how the widget behaves so you can pretty much use whatever CSS you need to. The following code shows the skin used in this example:

#pollContainer { width:250px; border:1px solid #000000; margin:0; text-align:center; background-color:#3a3737; position:relative; padding-bottom:10px; } #pollContainer form, #results { text-align:left; margin:0 0 0 30px; } #pollContainer h2, #pollContainer p { font-family:Verdana; font-size:11px; margin:5px 0; color:#ffffff; font-weight:bold; } #pollContainer .error { margin:5px auto 0; background:url(images/warn.gif) no-repeat 0 0; padding-left:10px; width:182px; } #pollContainer input { margin:0 10px 0 0; } #pollContainer label { font-family:Verdana; font-size:10px; font-weight:bold; position:relative; top:-3px; color:#ffffff; } #pollContainer button { margin:5px 0 0; } #results { width:200px; margin:5px auto 0; border-top:2px solid #ffffff; border-bottom:2px solid #ffffff; } .row { width:200px; overflow:hidden; } #results label { width:93px; font-family:Verdana; font-size:11px; font-weight:bold; color:#ffffff; text-align:right; border-right:2px solid #ffffff; padding:5px 5px 10px 0; float:left; clear:both; height:10px; top:0; } .result { background-color:#079d67; width:0; float:left; height:21px; margin:2px 2px 2px 0; } #pollContainer #thanks { margin:0; position:relative; width:100%; text-align:center; clear:both; top:4px; }

Save this file as poll.css in the poll project folder. There’s nothing interesting or difficult here really, it’s all just presentation. I’ve added an image to give the error message more weight. It’s included in the accompanying code download for this tutorial and should be placed into a folder called images within our poll directory. The JavaScript, HTML and CSS that we’ve added so far should go together to form something like the following screenshot when run in a browser:

Continuing with the Plugin

The first stage of the plugin is complete; the widget renders and the (very generic) question to the visitors is posed. Now we need to capture their response and do something with it. Injquery.jpoll.js add the following code directly after the code we added to create the buttonRow container:

$("&lt;button type='submit'&gt;").text("Vote!").appendTo("#buttonRow").click(function(e) { e.preventDefault(); //record which radio was selected var selected; $(".choice").each(function() { ($(this).attr("checked") == true) ? selected = $(this).attr("id") : null ; }); //print message if no radio selected and errors enabled if (config.errors == true) { (selected == null &amp;&amp; $(".error").length == 0) ? $("&lt;p&gt;").addClass("error").text("Please make a selection!").css({display:"none"}).insertAfter("form#pollForm").slideDown("slow") : null ; }

We add a submit button to the final container within the form and set a click handling function on it. This will be quite a large function so we’ll look at it in small chunks. The first thing we do is prevent the default behaviour of the submit button, which would be to submit the form resulting in a page reload – definitely something we want to avoid in an AJAX scenario.

Then we set a new variable called selected which will be used to hold the ID of the radio button that was chosen. We loop through each radio button with jQuery’s each method to see whether the radio has the checked attribute. If no radios were selected the variable will be set to null.

Next we check that the value of the variable isn’t set to null. If it is, then we can add the error message after the form and show it with a nice little animation. We check that the message isn’t already being displayed to prevent multiple messages being added if the button is repeatedly clicked. The error message should display something like this:

Now that we’re inside the click handling function for the button, the $(this) object will no longer refer to our widget container, instead it refers to the button, so at this point we have to start referring to the form using the ID attribute we gave it earlier on.

Once we’re satisfied that a choice has been made we can think about sending the details of the choice to the server. We’ll need to configure the AJAX request first which we can do with the following code:

//add additional request options var addOpts = { type: "post", data: "&amp;choice=" + selected, dataType:"json", success: function(data) {

We create a new object to hold the additional properties required for the AJAX request. We set the type to POST as we’ll be sending data to the server and configure the data that we’ll be sending. The format of the server’s response will be in JSON so the dataType property is set to json. Finally we add a success handler to be executed when the request returns successfully. Within this anonymous function we should add the following code:

//add all votes to get total var total = 0; for (var x = 0; x &lt; data.length; x++) { total += parseInt(data[x].votes); }

First we work out the total number of choices that have been made so far by iterating through the response object and adding the number of votes for each choice. We use the standard JavaScript parseInt function to convert the JSON string into an integer.

//change h2 $("div#pollContainer").find("h2").text("Results, out of " + total + " votes:"); //remove form $("form#pollForm").slideUp("slow");

We then change the heading element so that it indicates that the widget will now show the results. For good measure we can also show how many votes have been cast so far. We then animate the form away to make space for the results.

//create results container $("&lt;div&gt;").attr("id", "results").css({ display:"none" }).insertAfter("#pollForm"); //create results for (var x = 0; x &lt; data.length; x++) { //create row elment $("&lt;div&gt;").addClass("row").attr("id", "row" + x).appendTo("#results"); //create label and resuls $("&lt;label&gt;").text(config.groupIDs[x]).appendTo("#row" + x); $("&lt;div&gt;").attr("title", Math.round(data[x].votes / total * 100) + "%").addClass("result").css({ display:"none" }).appendTo("#row" + x); }

This segment of code creates a container div for the results then in the same way that we created containers and form elements earlier on, we create container elements and results. Each row in the results container will have a label, which uses the config.groupIDs property to set the text of the labels. Each result will be a div element as well and we work out the percentage of votes for each choice and add this as the title attribute. The results container and each result div are initially hidden from view. This is so that we can show them using smart animations:

//show results container $("#results").slideDown("slow", function() { //animate each result $(".result").each(function(i) { $(this).animate({ width: Math.round(data[i].votes / total * 100) }, "slow"); }); //create and show thanks message $("&lt;p&gt;").attr("id", "thanks").text("Thanks for voting!").css({ display:"none" }).insertAfter("#results").fadeIn("slow"); }); } };

Finally, we can slide the results container into view with jQuery’s slideDown method, and then show each result with a custom animation that sets the width of the result div to reflect the percentage of votes for each choice. We can also add a thanks message to thank the visitor for taking part and fade this into view.

We use JavaScript’s Math.round function to set the number as an integer, which is cleaner in this situation. We also work out the number of votes as a percentage (again using the total variable). I think for this kind of widget using a percentage is better because it will prevent the results div getting too big for the widget.

Remember however, all of this code resides within the success handler for our AJAX request – we still need to actually make the request. Directly after the above code, add the following:

//merge ajaxOpts widget properties and additional options objects ajaxOpts = $.extend({}, addOpts, config.ajaxOpts); //make request if radio selected return (selected == null) ? false : $.ajax(ajaxOpts) ; }); //return the jquery object for chaining return this;

In the final section of code for our plugin we use jQuery’s extend method once more to combine the configurable AJAX property from the developer-supplied configuration object (or the config object) with the additional options we set a little while ago.

Provided a radio button was selected we then make the request using jQuery’s ajax method, supplying our newly merged ajaxOpts object as an argument. The final part of the plugin is very important; we should return this (which will now once again refer to the object representing our widget’s main container div as we are outside of any inner functions) so that additional jQuery methods can be chained onto our method.

Again, here’s a screenshot to show how the end of the plugin file should be looking at this point:

This is now all of the code required for our plugin. We can next look at an example of the kind of PHP code needed to handle the request made by our plugin. There are many different ways in which we could achieve the same end using different techniques or server-side script languages. I’ve used PHP in this example because I like it, but other languages may be equally as effective.

A Little PHP

The PHP needed for this example is relatively straight-forward, we’ll see all of the code needed and then look at what each bit does. In a new file add the following code:

<?php //db connection details $host = "localhost"; $user = "root"; $password = your_password_here; $database = "poll"; //make connection $server = mysql_connect($host, $user, $password); $connection = mysql_select_db($database, $server); //get post data $selected = $_POST['choice']; //update table mysql_query("UPDATE results SET votes = votes + 1 WHERE choices = '$selected'"); //query the database $query = mysql_query("SELECT * FROM results"); //loop through and return results for ($x = 0, $numrows = mysql_num_rows($query); $x &lt; $numrows; $x++) { $row = mysql_fetch_assoc($query); //make array $json[$x] = array("choice" =&gt; $row["choices"], "votes" => $row["votes"]); } //echo results echo json_encode($json); //close connection mysql_close($server); ?>
Save this in the poll folder as poll.php. The first thing we do in the PHP is define the credentials needed to access and work with the MySQL database that we created at the start of this tutorial. The host and username will depend upon how MySQL is configured on your system and the password should be whatever password you enter when signing into the MySQL CLI. The information needed is stored in the $connection variable for easy access later in the script.

Once we have the necessary connection information we can then get the data passed to the script by our plugin, which will be accessible from the $_POST superglobal. Next we can update the table in our database with the new choice made by the visitor. This is really easy and simply involves looping through each row of the table until we find a row where the data in thechoices column matches the data obtained from the superglobal. We then increment the value of the integer in the votes column by one.

Once the table has been updated we then query the table to get the new totals. We select all of the table data using the SELECT * FROM syntax and store this in the $query variable. Using a for loop we then loop through each row of data and create a new associative array item for each row containing the data from the choices and votes columns in the table.

Once we’ve built our multidimensional associative array (which sounds much more complex than it actually is!) we can then use PHP’s native json_encode function build a proper JSON structured object from the array and then echo this back to our plugin. Finally we close the MySQL connection as it’s no longer needed and we don’t want to keep it open unnecessarily.

About the JSON

Let’s take a little look at the structure of the JSON object that is returned to the plugin – it is a key part of how the plugin works. Once we’ve made a choice and hit the vote button, we can then use the Dom tab of Firebug to have a look at the data that’s returned:

This screenshot tells us everything we need to know about the properties and values within our object. Because the object is a standard JavaScript object pretty much like any other, we already know how we can access the different parts of it. Like a standard array and object like this will have a length property and can be access using standard bracket notation, e.g.data[x]. To access the first property of the first item in the object we just use data[x].choice which returns the value of the property. To access the second property, we just godata[x].votes.

This simplicity is what makes JSON so incredible, and that’s without JSONP. JSONP, which we haven’t covered in this tutorial, is quite simply, total JavaScript nirvana; letting us access remote data, completely cross-domain if necessary, and processing it directly in the browser. It’s no wonder than JSON is quicker and easier to work with even than the very flexible XML.

Playing with the Plugin

We’ve gotten to the stage now where we can see the plugin in action. Our project folder should now contain all of the required files:

If you go in your browser of choice now and type the following URL in the address bar you should see the initial widget:

http://localhost/poll/pollTest.html

Once we’ve made a choice and hit the vote button, we should then see the results page and each result as it is animated into existence. It should appear something like in the screenshot at the start of the tutorial.

Configuring the Widget

In the final part of the tutorial we can see how the widget can be configured using the options we specified in the defaults object. Our plugin is called in the final script block in the HTML page; change this line of code so that it is as follows:

$("#pollContainer").jPoll({ groupIDs: ["Firefox", "Chrome", "IE", "Safari", "Opera"], pollHeading: "Which Browser is Your Faviouite?" });

Now when the page is run, the widget should appear like this instead:

Summary

This brings us to the end of the tutorial; I hope it’s shown you how easy it is to build even an advanced plugin when we have jQuery at our side. The library provides everything we need, all our plugins will be limited only by our imaginations, never through a lack of the appropriate mechanisms for doing what we want to do.

Our plugin is as flexible as it needs to be; changing the question and the labels makes no difference to how the widget interacts with the PHP file; you could have more choices if you wanted and these two files, thanks to the generality we built in, will still work seamlessly together. The only thing we can’t make generic is the MySQL database; this must be set up in the way we have specified, and if more or less choices are desired, the appropriate number of rows would need to be added or removed from the table.

Download source code:
http://www.mediafire.com/file/xf313eshptn9yxb/wdeveloper.blogspot.com_NT_PLUS_Advanced_jquery.rar

[TUT] A Beginner's Guide to Mootools

2011-04-13T22:01:00.000-07:00

A Beginner's Guide to Mootools

By: Matt Vicker

http://net.tutsplus.com/articles/news/the-ultimate-guide-for-learning-mootools-new-plus-tutorial

Getting started with any type of framework can be an intimidating experience. To help, this week we have an in depth tutorial and long screencast to provide a crash-course for this popular JavaScript library. With so much focus on jQuery, it's easy to forget that Mootools is an equally powerful library with a huge following.

After the initial move to Mootools I was frustrated with the lack of community support and ended up moving back to Prototype immediately. After I was more comfortable with working with frameworks I moved back to Mootools and haven't looked back.

With this tutorial, I'm going to try to make sure that you have a great beginning to the Mootools framework. I'm going to walk you through getting everything downloaded and setup as well as some of the basic elements of Mootools. After that I'm going to spend some time walking you through how to use the Mootools Docs, which is a site that you'll be visiting very often during the use of Mootools.

All right, enough stories, lets get our hands dirty.

Some Requirements

The nice thing about working purely with javascript is we don't need to run the files on a web or local server. All you need for this tutorial is:
A text editor/IDE
A browser
Some time.

For this tutorial I will be using Firefox and Firebug to show you some debugging tips, so I recommend that you use firefox as well as Firebug. Firebug will make working with Mootools, or any framework, 100x easier.

You can download firebug here

Downloading the Framework

Head over to www.Mootools.net/download

For now we are going to include both the Core and More libraries. This is just to make sure we aren't missing anything. When you become more comfortable with Mootools you will realize that not all the components are needed for specific applications, so you can custom build Mootools libraries to fit your need and keep the file sizes small.

Download the Mootools 1.2.3 YUI compressed file and save it to your desktop.

Move over to the more builder, select every option and download the YUI compressed file.

Setting up the Framework

Let's create a new folder called Moo and inside that folder lets create another folder called inc. Just to make things easier, create one more file inside our inc folder called js and toss both Mootools files inside that folder.

Inside our Moo folder, create a new file called index.html and open that sucker up.

Is it open? Good, now open it in Firefox as well. You should see a blank page. Switch back to your index.html file in your editor.

To include Mootools into our script, we need to add 2 lines of code to your HTML file. If you've ever included a javascript file into a script before this will be very familiar to you.

<script type="text/javascript" src="inc/js/Mootools-1.2.3-core-yc.js"></script>
  <script type="text/javascript" src="inc/js/Mootools-1.2.3.1-more.js"></script>

We are now setup and ready to go!

Making Mootools talk to elements

To get Mootools to talk to elements on our page we use the $() function to get an element by it's ID.

Let's create a new div, give it an ID and some text and then make Mootools talk to it.

<div id="box"><p>Hey Guys!</p></div>

  After that lets put some javascript tags so we can start writing some Mootools.

  <script type="text/javascript">

   //I hold the javascript

  </script>

We've created out div and gave it an ID of "box". We inserted some text inside of it and created some script tags so we can start entering in some Mootools goodness.
If we use the $ function and pass the id of our box, we can see that Mootools is not getting all the attributes of our "box" div. Our variable element now holds all that data.

var element = $('box');

If we refresh the page, we can't visibly see that anything is happening, but we know things are going on in the background. This is where console.log() and Firebug come into play.

If you open up Firebug, you should see a blank console. Using console.log() we can pass information to Firebug to display for us. This is extremely useful when debugging a script because you can use it to display information in various steps of your script to see where things are failing.

console.log('Oh, Hi Everyone!');

We can also use it to display information that otherwise wouldn't be displayed in our browser.

Lets use console.log() to display some information about our "box" div.

console.log(element);

So we've learned that we can use $() to get an element but what if we want to get the information of many elements. We don't want to use 100 instances of $() that will just get messy. This is where the $() comes into play!

Who needs to get one, lets get many!

Lets add 5 links to our page.

<p><a href="http://linkone.com">I'm the first link</a></p>
  <p><a href="http://linktwo.com">I'm the second link</a></p>
  <p><a href="http://linkthree.com">I'm the third link</a></p>
  <p><a href="http://linkfour.com">I'm the fourth link</a></p>
  <p><a href="http://linkfive.com">I'm the fifth link</a></p>

  ...
  javascript tags
  ...

  var links = $$('a');

  console.log(links);

Our links variable now holds an array of all our links.

All right, so we've created our elements and now we've got Mootools talking to them, but this isn't any fun. The front end user isn't seeing any changes, so lets move away from this boring backend stuff and move onto something a little more fun!

Getters and Setters

We've just covered getting the elements using our getter functions. We can get a single element using $() and the elements ID. We've also covered getting multiple elements using $() and the element type.

When using $() we can either pass the HTML tag name or use CSS class selectors to grab group of elements. A quick example of grabbing class names would look like this.

var elements = $$('.myclass');

That would return an array of all elements on the page with the css class of "myclass".

Theory is dry as a bone and that's what the docs are for but you came here to get your hands dirty, so lets get dirty.

Now that we are getting our elements, lets use the setter functions to manipulate the elements on screen.

Our "box" div is looking kinda plain so lets add some color to it. We've already set our element into our element variable.

element.set('styles',{
   'color':'red'
  });

We use our element variable and we attach the set() function by using element.set().

There are many arguments we can use to change our element, but for now we are going to use styles. Next we pass some options to our styles argument. We are passing the color option and setting our text to red. Styles can use all available css options. Let's change the background color while we are here. Feel free to play around with the styles and see how colorful you can make our box element.

element.set('styles',{
   'color':'red',
   'background':'yellow'
  });

Our "box" element is not looking a little less plain. If we wanted to apply many styles to our box element it could end up being a lot of unnecessary code. Luckily, we can use CSS styles and another set argument to cut down on out code. Go ahead and delete out element.set() code. We are going to add some css styles using inline css.

Note: To make things easier we are going to write our CSS inside the file, but when creating an actual website it is good practice to have all your CSS and Javascript in separate file.

Above your "box" div lets add some style tags and create a class of .myclass.

We can now use set('style') to add our new style to our element.

element.set('class','myclass');

A few other argument we can use with set are HTML and text. Some basic examples of this are:

element.set('html','<p><b>Hey Guys, now I am bold</b></p>');
  element.set('text','Hey guys, no html here');

Which argument you use will depend on what you need to use it for. If you do not need to pass HTML values, you'd use text and vise-versa if you needed to pass HTML values.

We've used set() to add some styles to our "box" div, but we could've just added the class to the div using HTML. We don't really need to use Mootools to add the style if we are just changing it before the user even sees the change. This is where events come in handy.

We are hosting an event and everyone is invited!

Lets go ahead and delete all those links we created and clear our javascript tags.

Your index.html file should now include only this code:

<style type="text/css">

   .myclass{
    font-family: Helvetica;
    font-size: 1.4em;
    color: red;
    background: #e1e1e1;
    border-bottom: 2px solid #999;
    padding: 4px 0 0 15px;
    margin: 0;
   }

  </style>

  <div id="box"><p>Hey Guys!</p></div>

  <script type="text/javascript">

   var element = $('box');

  </script>

Create a new link and give it an ID of button right under out "box" div.

<p><a href="" id="button">Click me please!</a></p>

Now we are going to add an event to this button so we can execute some code when a user clicks the link. We use addEvent() to do this.

$('button').addEvent('click',function(e){

  });

We are using the familiar $() function to tell Mootools we want to talk to the link with an ID of button. Next we attach the addEvent() and pass 2 arguments. The first argument is the event that we want to capture which is when a user clicks the link. The second argument is a function with a variable of e. This function is going to execute when the user clicks the link and the variable of e passes the event. You'll understand why we pass a variable with the function in this next step.

...
  inside addEvent
  ...

  e.stop();

We assign the stop() function to our variable of e to stop the browser for send the link action. Usually when you click the link, the page will refresh and all your changes will be lost. e.stop() stops the browser from refreshing the page so we can do some Mootools magic!

Now we have Mootools capture the click event so lets make Mootools add our class of .myclass to our "box" div when the link is clicked.

...
  inside addEvent()
  ...

  element.set('class','myclass');

Save this, refresh the page and click your link. On clicking the link, the div should now have some styling to it. We did all that without having to refresh the page. This is where Mootools starts to get very interesting.

Quick little refresher before we continue. We've learned how to use getter functions ($ and $) to allow Mootools to talk to elements on our page. Then we learned that we could use setter functions to manipulate those elements. Events allow use to capture user interaction so that we can manipulate elements in realtime without having to refresh the page to reflect each change.

Creating elements are a snap!

Mootools will also allow you to create new elements on the fly so we can let the user customize the page. To do this we are going to be using the new Element() and inject() functions.

Lets start with a fresh HTML file. Either delete everything from index.html or create a new file.

In our file we are going to create a div and 2 links. Go ahead and create those now!

<div id="result">

  </div>

  <p><a href="" id="grey_box">Add a Grey Box</a></p>
  <p><a href="" id="blue_box">Add a Blue Box</a></p>

  <script type="text/javascript">


  </script>

We are going to use the $() to add an event to both of our links on the page. We are going to capture the click event and then create a new element. Lastly we are going to inject our new element into our "result" div.

$$('a').addEvent('click',function(e){

   e.stop();

  });

We use $('a') to grab all the links and then attach the addEvent() to each link. We do this because it cuts down on coding so we don't have to find each ID of the links and create addEvents for them. We are going to use the ID of each link to determine which style we need to add. Lets whip up some quick css for the boxes we are going to create.

<style type="text/css">

   .grey_box{
    height: 50px;
    width: 50px;
    float: left;
    clear: none;
    background: grey;
   }

   .blue_box{
    height: 50px;
    width: 50px;
    float: left;
    clear: none;
    background: blue;
   }

  </style>

Now it's time to create our elements and inject them into the page.

var class = this.id;

  var box = new Element('div',{'class':class});

  box.inject($('result'));

First we are creating a variable called "class" the hold the ID of the link that was clicked. Our next line takes care of creating the element. We do this by using new Element() and then passing some arguments. The first argument is the type of element we want to create. We want to create a div, so we pass a value of div. The second set is our options. We want to assign a different class depending on which link was clicked. We do this by first telling the function that we want to set the "class" option, then we pass our variable of class which will return either"blue_box" or "grey_box".

The last line is taking our new element, which we placed into a "box" variable and is injecting it into our "result" div. Mootools knows to inject it into "result" because we are passing the"result" div using a getter method as the main option.

Now if we refresh the page and start clicking our links you should see that little boxes are being created on the fly and are being added to the page.

I have that effect on people

At this point in the tutorial you should be fairly comfortable with using getter and setter functions to get Mootools to talk to our elements.

For the last part of this tutorial I'm going to touch on some of the animation and effects functions that Mootools offers.

Lets create another new file. Inside that file create a div with some text inside of it and a link.

<div id="box">
   <p>Hey Guys!</p>
  </div>

  <p><a href="" id="button">Click Me</a></p>

  <script type="text/javascript">


  </script>

I've added ID's to each element so we can get Mootools talking to them.

To start, lets attach an event to the link. This should look very familiar by now.

$('button').addEvent('click',function(e){

   e.stop();

  });

Now that we have Mootools capturing the click event, lets make our "box" div fade in and out on each click.

$('box').fade('toggle');

Now, when we click our link the box div should fade away. If we click the link again it will reappear.

Fading is cool and all, but lets add some style to the box and see if we can make it grow!

<style type="text/css">

   #box{
    width: 100px;
    background: yellow;
   }

</style>

We are going to use the tween() function to animate some attributes of our "box" div.
Inside our click event lets remove out fade() function and replace it with tween().

//$('box').fade('toggle');
  $('box').tween('height', '200');

Now if we click the link, our box should grow taller.
The tween function takes 2 arguments. The first is the attribute we want to manipulate and the second is a value. We want to change the height of the box and we want it to animate to 200px.
What if we wanted the box to grow by 10px every time we clicked the link. First we would have to get the current height of the box. I think we can do that with our $() getter function.

var box = $('box');
  var height = box.getHeight();
  var new_height = height + 10;

  box.tween('height', new_height);

First we assign our "box" div to a variable of box. Next we use a built in function of Mootools called getHeight() to get the current height of our "box" div. We want the box to grow by 10px each time the link is clicked so we create a new variable called new_height and assign it a value of height + 10. This is taking the current height and increasing it by 10. Finally we attach the tween() function to our box variable, tell it we want to animate the height and pass it the value of new_height.

If you click the link, the box should grow. If you click it again it will continue to grow with each mouse click.

We should document this!

Mootools has an extensive document section on their website. http://Mootools.net/docs/core

If you plan on using Mootools you will become very familiar with this section of their site. It is broken up into the different available classes and functions that Mootools has to offer.

The section that you will be visiting the most will be the Element section. This is the section that has all the information on how Mootools communicates and manipulates the elements on the page.

I've given your broad strokes to help you get used to how Mootools functions and if you would like to continue learning I suggest you read over a few of the pages in the Mootools docs.

Link download source code :

http://www.mediafire.com/file/dz5sk66dh47ybqw/wdeveloper.blogspot.com_beginners_guide_to_mootools.zip

[TUT] OOP Advance: All About the 'Static' Keyword

2011-04-13T21:48:00.000-07:00

All About the 'Static' Keyword

By: Burak Guzel

http://net.tutsplus.com/articles/news/new-premium-tutorial-all-about-the-%E2%80%9Cstatic%E2%80%9D-keyword

Today we are going to learn how to use the 'static' keyword in PHP. We are going go over the basics and build some examples. It is time to add this interesting language feature to your web development bag of tricks.

Tutorial Details

Language: PHP
Version: 5+
Difficulty: Intermediate
Estimated Completion Time: 1 hour

1 A Quick Example

Let's stay with a quick example first, to see the effect of using the static keyword.

Imagine writing a function that remembers how many times total it has been called. If you are not familiar with the 'static' keyword, you may resort to using some global variable:

view plaincopy to clipboardprint?
$call_me_count = 0;  
  
function call_me() {  
  
    global $call_me_count;  
  
    $call_me_count++;  
  
    echo "You called me $call_me_count times <br>\n";  
  
}  
  
// output => You called me 1 times  
call_me();  
  
// output => You called me 2 times  
call_me();  
  
// output => You called me 3 times  
call_me();  
  
// output => You called me 4 times  
call_me();  

Just because this works does not mean you should write code this way. Generally speaking, global variables are frowned upon. It's not a good idea to have global variables floating around, that some function only utilize privately.

Now enter the 'static' keyword. Same code can be rewritten like this:

view plaincopy to clipboardprint?
function call_me() {  
  
    // a static variable  
    static $call_me_count = 0;  
  
    $call_me_count++;  
  
    echo "You called me $call_me_count times <br>\n";  
  
}  
  
// output => You called me 1 times  
call_me();  
  
// output => You called me 2 times  
call_me();  
  
// output => You called me 3 times  
call_me();  
  
// output => You called me 4 times  
call_me();  

Same result, no more global variables. But how does this work exactly?

Normally, all local variables inside of a function get destroyed once the function returns. The 'static' keywords lets PHP know to keep the variable alive. So, the next time the function is called, the value inside the variable is retained.

2 Valid Initial Values

As seen the previous example, when we assigned the value of 0 to the variable, it actually did not execute an assignment statement. It only set the initial value for the variable. That may sound like the same thing, but there is a slight difference. The variable can only be initialized to a fixed value, and not an expression.

Let's see some examples of valid and invalid initial values. First, let's look at numbers:

view plaincopy to clipboardprint?
function foo() {  
  
    // valid  
    static $a = 9;  
  
    // causes parse error  
    static $a = sqrt(81);  
  
    // valid  
    static $a = 3.14;  
  
    // causes parse error  
    static $a = pi();  
  
    // causes parse error  
    static $a = 1 + 3;  
  
}  

As you can see, not even basic math operations are allowed. All you can assign is fixed numbers.

We can also assign strings:

view plaincopy to clipboardprint?
function foo() {  
  
    // valid  
    static $a = '';  
  
    // valid  
    static $a = 'hello';  
  
    // causes parse error  
    static $a = strtoupper('hello');  
  
    // causes parse error  
    static $a = 'hello' . 'world';  
  
}  

Again, it has to be fixed strings, and not even basic concatenation is allowed.

Booleans, Arrays and Constants will work too:

view plaincopy to clipboardprint?
define("SOME_CONSTANT", 789);  
  
function foo() {  
  
    // valid  
    static $a = array(1,2,3);  
  
    // valid  
    static $a = SOME_CONSTANT;  
  
    // valid  
    static $a = array(1,2,'three',  
        array (  
            'foo' => 'bar'  
        )  
    );  
  
    // valid  
    static $a = true;  
  
}  

3 Building an Alternate() Function

Now that we know how static variables inside functions work, let's build something useful with it.

Here is a simple HTML page with a simple table in it:

view plaincopy to clipboardprint?
    <title>My Table</title>  
    <meta charset="UTF-8">  
  
  
  
<table>  
    <thead>  
        <tr>  
            <th>ID</th>  
            <th>Name</th>  
            <th>Category</th>  
        </tr>  
    </thead>  
  
    <tbody>  
        <tr>  
            <td>1</td>  
            <td>Apple</td>  
            <td>Fruit</td>  
        </tr>  
        <tr>  
            <td>2</td>  
            <td>Carrot</td>  
            <td>Vegetable</td>  
        </tr>  
        <tr>  
            <td>3</td>  
            <td>Dog</td>  
            <td>Animal</td>  
        </tr>  
        <tr>  
            <td>4</td>  
            <td>Oven</td>  
            <td>Appliance</td>  
        </tr>  
    </tbody>  
</table>  

The result is:

Now let's add some css, and make the rows alternate color:

view plaincopy to clipboardprint?
    <title>My Table</title>  
    <meta charset="UTF-8">  
    <style>  
        table {  
            width: 300px;  
        }  
        tr.odd {  
            background-color: #DDD;  
        }  
        tr.even {  
            background-color: #BBB;  
        }  
        body {  
            font-family: Arial;  
        }  
    </style>  
  
  
  
<table>  
    <thead>  
        <tr>  
            <th>ID</th>  
            <th>Name</th>  
            <th>Category</th>  
        </tr>  
    </thead>  
  
    <tbody>  
        <tr class="odd">  
            <td>1</td>  
            <td>Apple</td>  
            <td>Fruit</td>  
        </tr>  
        <tr class="even">  
            <td>2</td>  
            <td>Carrot</td>  
            <td>Vegetable</td>  
        </tr>  
        <tr class="odd">  
            <td>3</td>  
            <td>Dog</td>  
            <td>Animal</td>  
        </tr>  
        <tr class="even">  
            <td>4</td>  
            <td>Oven</td>  
            <td>Appliance</td>  
        </tr>  
    </tbody>  
</table>  

Now it looks like this:

If the data was coming from a database, and the table rows were output within a loop, you would need to add some code to be able to set those alternating CSS classes to each row. Most people would just go ahead and create a variable within that loop, add a conditional or ternary statement to keep alternating its value.

However, we are going to build a more elegant and reusable solution. We are going to create a function named alternate() that utilizes the concept of static variables.

view plaincopy to clipboardprint?
function alternate($a, $b) {  
  
    static $alt = false;  
  
    // reverse the value of alt (true <=> false)  
    $alt = !$alt;  
  
    if ($alt) {  
        return $a; // return first value  
    } else {  
        return $b; // return second value  
    }  
  
}  
  
  
// Example Usage:  
  
// output: odd  
echo alternate('odd', 'even');  
  
// output: even  
echo alternate('odd', 'even');  
  
// output: odd  
echo alternate('odd', 'even');  

We call the function with two arguments. Every time it is called, it returns back one of the arguments in an alternating fashion. It accomplishes this by keeping a boolean value in a static variable called $alt. Every time it flips this variables value, to determine which one of the two arguments to return.

So, let's use that in our page, by putting it all together:

view plaincopy to clipboardprint?
<!--?php  
function alternate($a, $b) {  
  
    static $alt = false;  
  
    // reverse the value of alt (true <=--> false)  
    $alt = !$alt;  
  
    if ($alt) {  
        return $a; // return first value  
    } else {  
        return $b; // return second value  
    }  
  
}  
  
  
  
$rows = array(  
    array(1, 'Apple', 'Fruit'),  
    array(2, 'Carrot', 'Vegetable'),  
    array(3, 'Dog', 'Animal'),  
    array(4, 'Oven', 'Appliance')  
);  
  
?>  
  
  
  
    <title>My Table</title>  
    <meta charset="UTF-8">  
    <style>  
        table {  
            width: 300px;  
        }  
        tr.odd {  
            background-color: #DDD;  
        }  
        tr.even {  
            background-color: #BBB;  
        }  
        body {  
            font-family: Arial;  
        }  
    </style>  
  
  
<table>  
  
    <thead>  
        <tr>  
            <th>ID</th>  
            <th>Name</th>  
            <th>Category</th>  
        </tr>  
    </thead>  
    <tbody>  
        <!--?php foreach ($rows as $row): ?-->  
            <tr class="<?php echo alternate('odd','even'); ?>">  
                <td><!--?php echo implode('</td--></td><td>', $row); ?></td>  
            </tr>  
        <!--?php endforeach; ?-->  
    </tbody>  
  
  
</table>  

And the final result is the same:

4 Improving Our Alternate() Function

The function we created works well, if we use it only in one spot in our scripts. There is a small problem with it, however. If we use it in multiple places, or in nested loops, it may not return the values in the order we intended. Let's look this code to demonstrate this issue:

view plaincopy to clipboardprint?
// a  
echo alternate('a','b') . "<br>\n";  
// b  
echo alternate('a','b') . "<br>\n";  
// a  
echo alternate('a','b') . "<br>\n";  
  
  
// even  
// (the second value is returned first!)  
echo alternate('odd','even') . "<br>\n";  
// odd  
echo alternate('odd','even') . "<br>\n";  
  
  
// bar  
// (same problem)  
echo alternate('foo','bar') . "<br>\n";  
  
  
// a  
// (last time it was 'a' too)  
echo alternate('a','b') . "<br>\n";  

Our function needs to be aware that it is being called from different places, and make sure to return the values accordingly. We can accomplish this by adding an optional last parameter, to assign an ID number. And we pass a unique ID from each different place we call it from, to avoid these conflicts:

view plaincopy to clipboardprint?
function alternate($a, $b, $id = 0) {  
  
    static $alt = array();  
  
    if (!isset($alt[$id])) {  
        $alt[$id] = false;  
    }  
  
    $alt[$id] = !$alt[$id];  
  
    if ($alt[$id]) {  
        return $a;  
    } else {  
        return $b;  
    }  
  
}  
  
  
// a  
echo alternate('a','b', 1) . "<br>\n";  
// b  
echo alternate('a','b', 1) . "<br>\n";  
// a  
echo alternate('a','b', 1) . "<br>\n";  
  
  
// odd  
echo alternate('odd','even', 2) . "<br>\n";  
// even  
echo alternate('odd','even', 2) . "<br>\n";  
  
  
// foo  
echo alternate('foo','bar', 3) . "<br>\n";  
  
  
// b  
echo alternate('a','b', 1) . "<br>\n";  

This time we are utilizing an array as a static variable. It will carry a unique boolean value for each different ID number that was passed. This allows it to return the values in correct order.

5 Static Class Members

The 'static' keyword is not only used inside functions. It is actually quite common in object oriented programming. There can be static members, and methods. First we are going to look at how static members work.

Here is the syntax:

view plaincopy to clipboardprint?
class Foo {  
  
    // a static member  
    public static $a = 0;  
  
    // a normal member  
    public $b = 0;  
  
  
    public function bar() {  
  
        // accessing the static member  
        self::$a;  
        self::$a++;  
        self::$a = 3;  
  
        // normal member:  
        $this->b;  
        $this->b++;  
        $this->b = 3;  
  
    }  
  
  
}  
  
// accessing the static member  
// from outside  
Foo::$a;  
Foo::$a++;  
Foo::$a = 3;  
  
  
$obj = new Foo();  
// accessing the normal member  
$obj->b;  
$obj->b++;  
$obj->b = 3;  

Note how we used the 'self::' keyword in front of the static variable for accessing it within the class, rather than '$this'. Also, when used in the outer scope, we do not need to create an instance of the object before we can access the static variables. However, normal class members can only be accessed after we created an instance of them.

6 A Class That Counts Itself

Remember our first example where we had a function that kept a count on how many times it was called? Now let's apply the same principle to object oriented programming.

This class will have the ability to count how many times total it has been created:

view plaincopy to clipboardprint?
class Foo {  
  
    // our instance counter  
    public static $counter = 0;  
  
    // to work as an autoincrement ID  
    public $id = 0;  
  
    // the constructor function  
    public function __construct() {  
  
        // increment counter  
        self::$counter++;  
  
        // save the same number  
        // as the id of this object  
        $this->id = self::$counter;  
  
    }  
  
  
}  
  
// output: 0  
echo Foo::$counter . "\n<br>";  
  
  
$a = new Foo();  
// output: 1  
echo Foo::$counter . "\n<br>";  
  
  
$b = new Foo();  
// output: 2  
echo Foo::$counter . "\n<br>";  
  
  
$c = new Foo();  
// output: 3  
echo Foo::$counter . "\n<br>";  
  
  
// output: 2  
echo $b->id;  

Every time a new object is created, the constructor function is called by default. This function contains code for setting the counter and the id number for that instance of the object. So, if an object was created for the third time, that object will have an id of 3, which is specific only to that object. The counter will keep going up as more objects keep getting created.

Note that regular class members exist separately on each object. However, the static members only exist once globally.

7 Static Class Methods

Not just members, but also methods of a Class can be made 'static'.

view plaincopy to clipboardprint?
class Foo {  
  
    // note the static keyword  
    public static function hello() {  
        echo "Hello World";  
    }  
  
}  

And this is how you can call them:

view plaincopy to clipboardprint?
Foo::hello();  
// prints Hello World  

Note how the syntax is similar to accessing static members, by using double colon (::).

Inside of a static method, a class can refer to itself using the 'self' keyword, and access static members this way:

view plaincopy to clipboardprint?
class Foo {  
  
    public static $call_me_count = 0;  
  
    public static function call_me() {  
  
        self::$call_me_count++;  
  
        echo "You called me ".self::$call_me_count." times <br>\n";  
    }  
  
}  
// output => You called me 1 times  
Foo::call_me();  
  
// output => You called me 2 times  
Foo::call_me();  
  
// output => You called me 3 times  
Foo::call_me();  
  
// output => You called me 4 times  
Foo::call_me();  

8 The Singleton Pattern

A 'Singleton' is a class that can have only exist as a single object instance. It also contains a static reference to this instance.

It might become more clear by looking at the code:

view plaincopy to clipboardprint?
class Foo {  
  
    // to contain an instance of Foo  
    private static $instance;  
  
    // making constructor private, so it can't be called from outside  
    private function __construct() {}  
  
  
    // the singleton method  
    public static function getInstance() {  
  
        // if the instance doesn't exist yet, create it  
        if (!isset(self::$instance)) {  
            $c = __CLASS__;  
            self::$instance = new $c;  
        }  
  
        // return the only instance  
        return self::$instance;  
    }  
  
  
    // cloning is not allowed  
    public function __clone() {  
        trigger_error('Cloning is not allowed.', E_USER_ERROR);  
    }  
  
}  

This is the skeleton structure. You can of course add more methods and member, or simply extend the class.

When we call the getInstance() method, two things happen.

view plaincopy to clipboardprint?
$var = Foo::getInstance();  

First, if there is no Foo object, one is created and assigned to Foo::$instance. Then, once there is that object, it is returned, so $var becomes that object. If you call it multiple times, every time you will get the same exact object; a new instance will not be created.

view plaincopy to clipboardprint?
$var = Foo::getInstance();  
$var2 = Foo::getInstance();  
  
// $var and $var2 reference the same exact object  

Since we made the __construct() method private, we can not create new instances of this object.

view plaincopy to clipboardprint?
// this will throw an error  
$var = new Foo();  

9 A Singleton CurrentUser Class

Now it's time to build a more concrete example with the Singleton Pattern.

Imagine that you have a User class with various methods:

view plaincopy to clipboardprint?
class User {  
  
    public $id;  
    public $name;  
    public $email;  
  
    public function load_user($id) {  
  
        // fetch from db  
        // ...  
  
    }  
  
    public function update_user($info) {  
  
        // update db with given $info array  
        // ...  
  
    }  
  
    public function comment_count() {  
  
        // calculate the number of comments  
        // ...  
  
    }  
  
}

We have one method for fetching a user by id from the database. So it could be used like this:

view plaincopy to clipboardprint?
$user = new User();  
$user->load_user($user_id);  
  
// now I can see the name, and other things  
echo $user->name;  
echo $user->comment_count();  

Now imagine that once a user is logged in, you store their id in the session. And next time they load a page, you need to look up that id, and create the related $user object for that user again, if you wish to access the members and methods of that object.

But due to variable scope issues, you will either need to make the $user object global, or keep initializing it from different functions/methods within your script. Here is where a singleton class can come in handy:

view plaincopy to clipboardprint?
class CurrentUser extends User {  
  
    private static $instance;  
  
    private function __construct() {  
        // make sure to call parent constructor  
        parent::__construct();  
    }  
  
    public static function getInstance() {  
  
        // initialize  
        if (!isset(self::$instance)) {  
  
            // does session exist?  
            if (!$_SESSION['user_id']) {  
                return false;  
            }  
  
            $c = __CLASS__;  
            self::$instance = new $c;  
            self::$instance->load_user($_SESSION['user_id']);  
        }  
  
        return self::$instance;  
    }  
  
  
    public function __clone() {  
        trigger_error('Cloning is not allowed.', E_USER_ERROR);  
    }  
  
}  

Now we can access the CurrentUser class from everywhere in our application:

view plaincopy to clipboardprint?
$user = CurrentUser::getInstance();  
  
if (!$user) {  
    echo "You are not logged in!";  
} else {  
    echo Welcome back $user->name";  
}  

So, in our code we did not need to worry about dealing with session. We can simply attempt to get the instance of the CurrentUser object and use it just like any User object, as it extends its functionality.

Conclusion

I hope you enjoyed this tutorial and learned from it. See you next time!

[JQuery Plugin] ImgSlider

2011-04-13T20:53:00.000-07:00

ImgSlider

Live Demo: http://codecanyon.net/item/imgslider...preview/128727

Features

Cross-browser compatible. Works in IE 6 , 7, 8, Firefox, Safari, Chrome, Opera
Degrades gracefully when JavaScript is disabled. Images and CSS styling remain viewable
Easily add to any existing website or dynamically generated content
Very easy to customize
Semantic, valid XHTML and CSS
Powered by the ever popular jQuery JavaScript library
Includes detailed documentation
Less than 2kb in size
Compatible with jQuery Easing Plugin

Download imgslider

http://www.mediafire.com/file/l6i2858ju3n42zc/wdeveloper.blogspot.com_ImgSlider.zip

[Templates] Music Templates

2011-04-13T20:14:00.000-07:00

Music Templates

PSD,HTML,CSS | 60.3 Mb

Download Music Templates

http://www.mediafire.com/file/yehgsslgv9w5uf3/wdeveloper.blopspot.com_Music%20Templates.rar

[Templates] Left Handed – Obox Design Premium WordPress Theme

2011-04-13T11:48:00.000-07:00

Left Handed

Creative bloggers will enjoy the quirky detail of this 2-column hand-drawn theme. Left Handed brings together custom-made fonts, chalky lines and subtle texturing, and turns them into a template suited to any creative theme - including music, art and design.Live demo: http://www.obox-design.com/demo-theme.cfm?theme=left-handed

Download Left Handed

http://www.mediafire.com/file/yrah5banvy8n0e7/wdeveloper.blogspot.com_w_left-handed.rar

[PHP Script] PHP + ffmpeg video converter

2011-04-13T11:28:00.000-07:00

PHP + ffmpeg video converter

Description:this script is used for converting videos to severeal diferent video formats and audio mp3 format.
Features:
1. converts input video to several video formats including audio format mp3
2. calculate video duration in next format 00:00:00 (hh:mm:ss)
3. takes picture from video
4. prevents uploading unsuported files before uploading is startet
5. user have an option to set quality of video/audio file
6.suported files:
input:3gp, avi, mpg, mpeg, mpe4, mov, m4a, mj2, flv, wmv, mp3, ogg, webm
output: .flv, mp4, avi, wmv, mp3, ogg, webm
Usage:
1. start step_1.php
2. choose your video file and follow instructions
3. only extensions for videos are enabled for upload – if you choose some non-suported extesnion you will get alert window BEFORE upload is started
4. Choose output video type and quality settings

5. wait until conversion is over – new video duration is displayed
6. image for video is created
7. preview your video / or download link is shown
8. log file is created for every video conversion and image creation
Info:
all uploaded videos are renamed to a name based on a microtime stamp like 0342731001282903919.avi this will make easier for ffmpeg to read uploaded file before converting (preventing video names with special characters)

log file of every conversion is created with a same name like converted video
Image from video is taken based on total video duration, php splits total video duration time by 2 and at that point picture is taken from video

Download PHP + ffmpeg video converter

http://www.mediafire.com/file/lcak2xanicp25fl/wdeveloper.blogspot.com_php-ffmpeg-video-converter.zip

[PHP Script] CMS pro! - Lightweight Content Management System

2011-04-13T11:19:00.000-07:00

CMS pro! Version: 1.5.3 (last)

Live Demo:
Admin area http://wojoscripts.com/cmspro/admin/
Demo http://wojoscripts.com/cmspro/
Username: admin
Password: admin

Description:
CMS Pro! is the most intuitive CMS (Content Management System) that a web agency can implement for their customers. It’s perfect for small business websites and is really easy to use and to implement.
The value of CMS Pro! is in its intuitiveness. With CMS Pro!, content management becomes as easy as desktop publishing .

The real value to the customer does not come from hundreds of features that she can’t or won’t ever use. Real value comes from making it really simple to use some great power features that get the job done.

That’s exactly what CMS Pro! delivers. CMS Pro! allows small business owners manage their entire site, or change their web site design in seconds.
Some of the features include:
Modular design – Creating a module(side box) takes only few clicks
Dynamic layout – Easy drag and drop of modules(sidebars) for each individual page
Unique page layout – Each page can have up to 4 module positions top/bottom/left/right
Dynamic menu creation – add as many menu items as you like, unlimited menu levels, easy drag.
Multiple posts per page – you can add multiple posts per page.
Dedicated contact and home page.
7 professional modules included jQuery slider, News Slider, Event Manager, jQuery Tabs, Poll, Vertical Menu and Recent Twitts
Built in gallery module
Built in commenting system
Powerful file manager
Database backup/restore
SEO Optimized
User permissions
Built in Installation wizard
and many more…

Download CMS pro!

http://www.mediafire.com/file/y6qirrtaybru6cd/wdeveloper.blopspot.com_cms-pro.rar

[JQuery Plugin] Dab News Slider

2011-04-13T11:12:00.000-07:00

Dab News Slider is a mootools based slider which rotates the news in a very nice way.It is very customizable so you can theme it yourself as you want,can change the time for which a news will appear,the time in which the news change.You can use images,text,video etc. or say anything you want in your news.
Live demo: http://codecanyon.net/item/dab-news-...preview/132308

Features

6 Themes
Auto slide
Adjustable width and height
Limit number of news items to play
Limit intro text characters
News scroll function build in
Fade , Scroll , Scroll-Fade transition choices
Vertical , horizontal slides
CSS and XHTML valid
Cross browser compatible
IE6 PNG fix build in

Download Dab News Slider
http://www.mediafire.com/file/ryog4d9u4y1srfo/wdeveloper.blogspot.com_dabsilder.zip

[JQuery Plugin] Two Tier Sliding Menu

2011-04-13T07:32:00.000-07:00

Two Tier Sliding Menu is a jQuery plugin that creates a two tier sliding menu out of an unordered list. It supports only two levels of nested HTML lists (in other words, one main list and one child list for each main item, the most). It allows to initially open the menu at a ceratin item and, optionally, have it close all the other opened items upon opening an item.

Download JQuery Two Tier Sliding Menu Plugin

http://www.mediafire.com/file/peqlb45i37w3pyb/wdeveloper.blogspot.com_jquery-two-tier-sliding-menu-plugin.zip

[PHP Script] EZ POLL

2011-04-13T07:12:00.000-07:00

EZ POLL: A SIMPLE BUT POWERFUL AND CUSTOMIZABLE POLLING MANAGEMENT SYSTEM.

Cross-browser compatible
Multi-option polls
Time sensitive polls (start and end both optional)
Javascript and non-javascript display options
Custom color coded bars
Limiting votes per day, per poll lifetime per user (IP based)
and more!

JS Enabled Demo: http://dtimagery.com/ezpoll/ezpoll_demo_js.php

JS Disabled Demo: http://dtimagery.com/ezpoll/ezpoll_demo.php

Backend Demo: http://dtimagery.com/ezpoll/ezpoll

Username: admin Password: admin

Download EZ POLL

http://www.mediafire.com/file/8ue9plkc9ocx99t/wdeveloper.blogspot.com_ez-poll-source.zip

[Ajax] AJAX AutoSuggest

2011-04-13T06:56:00.000-07:00

AJAX AutoSuggest helps web developers in making web sites more usable and user friendly.
With the help of this plugin a search text box within a web page could be easily converted into an smart suggestion box that would list out all related search entries. User can choose from suggestion list using keyboard or mouse.

AJAX AutoSuggest is built using
PHP 5
MySQL 5
Javascript
The plugin offers variety of features that could help the web developers in enhancing their websites.

Features
Full support to keyboard
Full support to mouse
Customizable colors to match your web site theme
Auto adjusting width to precisely match the search text box
Extremely simple configuration
Compatible to all major browsers

Live Demo: http://www.capjo.com/envato/codecanyon/aas

Download AJAX AutoSuggest

http://www.mediafire.com/file/ukzifo6rf8ao6q1/wdeveloper.blogspot.com_ajax-autosuggest.rar

[PHP Script] Wallpaper script

2011-04-13T06:47:00.000-07:00

Wallpaper script

Script Info:
Wallpaper Script is a complete image gallery solution that lets you collect, organize and
share your wallpapers with friends and family. You can upload and access your images at any time
from any computer with an Internet connection. Wallpaper Script sets the bar when it comes to
wallpaper gallery software, and no other competitor offers as many features as you'll find in Wallpaper Script.
Wallpaper Script is the premium wallpaper gallery solution used by hundreds of people just like you to share
and show off their images to the world. Features include bulk wallpaper uploading, comments, tags,
powerful search, multiple user accounts, unlimited photos, unlimited galleries, automatic thumbnail creation,
sorting, gallery statistics and user registration.

Live Demo: http://wallpaperscript.com/demo

Download Wallpaper script

http://www.mediafire.com/file/k8v8ze1y292n4vx/wdeveloper.blogspot.com_Wallpaper_Script.rar

[PHP Script] Canny Comment System

2011-04-13T06:34:00.000-07:00

Canny Comment System

Features:

Ajax-Powered – Snappy jQuery-driven
100% CSS UI – No images!
Intuitive Admin Panel – Manage comments your way, no config file hassles
Comment ratings – Let users rate each comment (IP Address Restriction)
Admin approval
- Approve comments before making them live
- Receive emails of pending comments
Client and server side validation – Ajax and PHP front-end validation
Global Avatars – Gravatar.com
Fully sanitized data – Safe from MySQL attacks
Spam Protection
Bad word filtering
Parses links automatically
Refined jQuery animations – Impress your audience
Inline-labels for comment forms – user-friendliness always wins
Admin approve, deny, delete buttons
Sort comments ascending or descending
New – Multi-page support
Excellent for any site without comments, CMS sites, blogs. Even let Canny Comment take over your current commenting.

Live Demo: http://www.illustratut.com/canny_comment_demo

Download Canny Comment System
http://www.mediafire.com/file/1ihsmzhs1re0e67/wdeveloper.blogspot.com_CannyCommentSystem.rar

[JQuery Plugin] SexySlider 1.4

2011-04-13T06:29:00.000-07:00

SexySlider is a JQuery plugin that lets you easily create powerful javascript Sliders with very nice transition effects. Enhance your website by adding a unique and attractive slider!

Visit the Live Preview to see the effects.

Demo:

Download SexySlider 1.4

http://www.mediafire.com/file/a2l249xilso07oh/wdeveloper.blogspot.com_sexy-slider-source.zip

[PHP Script] QuickShop

2011-04-13T05:43:00.000-07:00

QuickShop
Simple and easy engine online store, very useful for smaller sales. There is a control panel, system templates (Smarty), the logic is separated from the presentation. Manage categories, products, orders, etc. Open your own online shop with QuickShop
Demo:

Download QuickShop

http://www.mediafire.com/file/8w4i4l1x3iiubkd/wdeveloper.blogspot.com_quickshop-source.zip

[PHP Script] CSS3 Mega Drop Down Menu

2011-04-13T05:36:00.000-07:00

CSS3 Mega Drop Down Menu

Bộ menu giống với game.zing.vn cho các bạn tham khảo.

This Mega Drop Down Menu is now more flexible and can contain even more content using the new Full Width feature.

This Mega Drop Down Menu is perfect for creating unique menus easily. It’s CSS / XHTML only, there is absolutely NO javascript.

The content can be organized in 1, 2, 3, 4 or 5 columns based on the 960 grid system.
This item comes with 9 color variants and a detailed documentation to help you start with your brand new menu.

CSS classes allow you to create lists, paragraphs with (or without) images, make your menu stick to the left or the right side, and create your own color schemes quickly.

Demo:

Download CSS3 Mega Drop Down Menu

http://www.mediafire.com/file/533132e7247b5ov/wdeveloper.blogspot.com_css3-mega-drop-down-menu.zip

[PHP Script] PHP Event Calendar

2011-04-13T05:29:00.000-07:00

PHP Event Calendar

PHP Event Calendar is a MySQL Database driven script that displays events on your website quickly and easily through a traditional calendar UI. It can be integrated into any existing PHP page within minutes using a simple file include.
It features a simple yet advanced Administration Panel with secure login sessions, from within this you have full control over your calendar events and gives the ability to Add Events, Search & Edit Events, Delete Events from your calendar and so forth.
View our Live Demo!
Main Features
Several theme colours included! (Grey, Green, Red and Blue)
Cross-Browser Compatible (IE6+, FF, Safari)
Simple MySQL Database Backend
Calendar uses 1 CSS Style
jQuery Lightbox for Day Event
Integrated Secure Login Script
Admin Control Panel
Add Events in seconds
Displays upcoming events
Search Events feature
Edit Previous Events Easily
Delete a previous event
Online Documentation
You can view the installation guide and FAQ ’s by following this link:http://www.jigowatt.co.uk/themeforest/calendar/
Live Demo
You can view a demo of both the main installation and admin panel by following this link:http://www.jigowatt.co.uk/themeforest/calendar/
Server Requirements
Supports PHP 4 .x or later
Supports MySQL 4.x or later (Requires 1 Database)
Can be tweaked or modified once purchased if you know the PHP language.
Support
Please contact with any questions you may have, full online documentation and support FAQ ’s included with the file for simple integration in your existing website or as a stand-alone product.

Demo:

Download PHP Event Calendar

http://www.mediafire.com/file/7c57v7ck45980gt/wdeveloper.blogspot.com_php_Event_Calendar_1_5.zip

[PHP Script] User - Member Manager

2011-04-13T05:22:00.000-07:00

User - Member Manager

User Manager provides a simple method of integrating a member system into a new or existing site. The script features a CMS / admin panel to manage users & site settings as well as a collection of scripts that show you how to add login, registration, logout, password recovery and user access restrictions to your existing site.
If you want to play around with User Manager then I suggest you check out the live demos below.
Features / What you get

Users can login using their Facebook account
Easy to extend and manipulate data stored in the CMS using built-in API
Users can edit their profiles
Users have profile pages
Robust password recovery for users
Intuitive install process for CMS
Full database & file backup
Easily manage which groups of users (Members, Administrators) can access which areas of your site
Simple and intuitive examples to help you make changes to better suit your specific needs
Straightforward API for more advanced users
Demonstration

For this particular script I’ve decided to include just one example, which includes all the functionality you would expect to see in a user management system including login, forgot password, logout, register and access restrictions based on a user’s access level. I could talk about the user manager all day but as they say, the proof is in the pudding; so why not take a look at the demo links below: The admin email and password is admin@mattlowden.com / adminadmin.
Admin panel
Register for account
Login
Forgot password
Log out
Edit profile
Member list
Who is this script for?

User Manager is ideal for anyone wanting to give users the opportunity to register with their site. Using the examples you can either build a new site around the User Manager or integrate it with an existing site.
Installation

User Manager is built with Mokoala CMS, the Mokoala installation guide covers how to install this script.
Facebook Integration

In order to enable Facebook logins you will need a Facebook API key.
Documentation

All of the guides that you need are located in the Mokoala guides section.

Demo:

Download User - Member Managerhttp://www.mediafire.com/file/phe4fb6bxm2kwxo/wdeveloper.blogspot.com-user-member-manager.zip

Web Developer

[PHP Script] Multi-level Comments

Download [PHP Script] Multi-level Comments

[PHP Script] Vivvo CMS v4.5.1 Business

[PHP Script] Vivvo CMS v4.5.1 Business

[PHP Script] Advanced PHP Protection

[PHP Script] Advanced PHP Protection

[JQuery Plugin] li JQuery Slider/Image Rotator

[JQuery Plugin] li JQuery Slider/Image Rotator

[Jquery Plugin] Lightbox evolution nonwp

[TUT] A Deeper Look at Advanced Select Queries

Tutorial Details

Introduction

Back to Basics: Breaking the Shortcut Habit

Sub-Selects: Multiple Selects Bundled Together

INNER JOINS: The Exclusive Club

OUTER JOINS: The Descriptive Club

Combining JOINS: Mix and Match

Unions: A Different Way to Join

Simulating a FULL OUTER JOIN: Practical Use

Conclusion

[TUT] Building an Advanced "Poll" jQuery Plugin

Prep Work

Building the Plugin

Additional Elements

Some Basic HTML and CSS

Continuing with the Plugin

A Little PHP

About the JSON

Playing with the Plugin

Configuring the Widget

Summary

[TUT] A Beginner's Guide to Mootools

A Beginner's Guide to Mootools

Some Requirements

Downloading the Framework

Setting up the Framework

Making Mootools talk to elements

Getters and Setters

We are hosting an event and everyone is invited!

Creating elements are a snap!

I have that effect on people

We should document this!

[TUT] OOP Advance: All About the 'Static' Keyword

All About the 'Static' Keyword

By: Burak Guzel

1 A Quick Example

2 Valid Initial Values

3 Building an Alternate() Function

4 Improving Our Alternate() Function

5 Static Class Members

6 A Class That Counts Itself

7 Static Class Methods

8 The Singleton Pattern

9 A Singleton CurrentUser Class

Conclusion

[JQuery Plugin] ImgSlider

[Templates] Music Templates

[Templates] Left Handed – Obox Design Premium WordPress Theme

[PHP Script] PHP + ffmpeg video converter

[PHP Script] CMS pro! - Lightweight Content Management System

[JQuery Plugin] Dab News Slider

[JQuery Plugin] Two Tier Sliding Menu

[PHP Script] EZ POLL

[Ajax] AJAX AutoSuggest

[PHP Script] Wallpaper script

[PHP Script] Canny Comment System

[JQuery Plugin] SexySlider 1.4

[PHP Script] QuickShop

[PHP Script] CSS3 Mega Drop Down Menu

[PHP Script] PHP Event Calendar

[PHP Script] User - Member Manager

Download

[PHP Script] Multi-level Comments