Bogdan Lungu

SWFIR (swf Image Replacement), it is a great way to add some style to images inside a web page escaping from the limitations imposed by the HTML but respecting the standard design concepts. This is done using JavaScript and Flash. Using swfir is simple and you don't need any advanced knowledge about Flash or JavaScript. Just download the swfir_v1.zip and unzip it, then upload the 2 files (swfir.js and swfir.swf) from it to the same directory in your website. To make it work all you need to do is include the JavaScript file and then to choose the images that will be styled and features applied to them.
The .js file need to be included in the "head" of the document:

I will use some styling features to the following image:

To call swfIR at work you have to use something like:

The code above need to be situated inside the "body" section. I used some parameters (there are more that can be used/tested) to style my "pic2" image.
The result is something like this:

It works fine in Firefox 2.0 and IE 6.0, unfortunately on some cumputers with SP2 failed to run in IE 6.0, nut sure why but you can write to the SWFIR team.

I see some errors in my blog caused by the code inserted in some examples, I have to find a way to fix this, maybe using a wordpress plugin to deal with the "plain text" code. Also it will help visitors to distinguish easier the post's text from the code examples.

In this post a I will show an example of a simple contact form which sends an email to a specified address, done using CakePHP.
The form has 3 fields: name, email address and message.
Firs of all let's see the "view" for the form displaying. It looks like this (app/views/controller_name/contact.thtml):

Now we need a small component to verify the email address to be a valid one and also to contain the code necessary for the email sending. The component (app/controllers/components/email.php) is looking like this:

And now becomes the logic part, the controller (app/controllers/controller_name.php):

One of the most “productive” way to attract visitors to your website / webblog relying on your content is to use a technique called linkbaiting.
Everything you need to do, to be able to use this feature, is to ensure that you wrote a good (unique) content on your website, a content that people will like and their attention will be caught in such manner that they will post a link towards your website.
This content you have is also called a possible “hook” for the visitor that will point a link to you. Through time there were some attempts to categorize this “hooks”, most encountered are:
- Informational Hooks – described as a content full with good information that can be usefull
- News Hooks – content related with fresh informations about some domains
- Hummor Hooks – funny content including jokes, pictures, movies
- Evil Hooks – means writing some bad things about a well known product / blogger / website, that sometimes can attract a lot of audience.
- Tool Hooks – creating a useful online tool that people will link to it.

A powerful feature in Cake is the relational data association provided by the model definition. There are four types of associations:
- hasOne
- hasMany
- belongsTo
- hasAndbelongsToMany

After we define the association between 2 models Cake will automatically fetch the data between the “glued” models. For example if the Car model is related to the Image model and is using a hasOne association type when we will retrieve the data using findAll for example in a controller there will be retrived both Car and Image records: $this->Car->findAll()
To use this types of relations correctly is indicated to use naming conventions like:

- Foreign Keys: singular-model-name_id. For example, a foreign key in the "images" table pointing back to the Car a given Image belongs to would be named "car_id".
- Tables name should be at plural
- Model names should be singular form of the tables names.

Example of association and querying data with hasOne between two models Car model and Image model in this cases:

Location: app/models/car.php

When we will retrieve data using find() or findAll() calls upon Car model we should see our associated Image model data as well.

To save in your model using CakePHP you only have to supply that data to a specific model using the save() method.
The data needs to be in the following form:

To post data in this form to a controller for example is very easy using HTML helpers that are implemented in Cake. Everything we need to care about is that form elements are looking like: data[Modelname][fieldname] .

For example to acces a certain variable in a controller we will use;

The input form in the view will look something like this:

In a form construction using helpers is best to respect the model structure using to give names to form elements the same names like fields we want to fill in the database.
Using this convention data sent from forms will be formatted automatically and will look putted in $this->data within you controller, so saving data becomes very easy.

Example of saving data:

In the example above we are saving data in the Car model.
If you want to validate your data you can easily do this using your model.
Example:

Cake will check variables: name, model and year not to be empty.
In on of the next posts I will describe how easy is to save data in multiple related models.

A function to retrieve data in CakePHP is the findAll() model function.
It has the following syntax:

For example to retrive all the data from a table you will use following:

With the “set function” the $var value will be send to the view. In the case above all the fields of the table will be retrieve.

Examples using findAll()

To sort the data by a certain field we can use:

For ascending:

Descending:

Only first 10 results:

The second results page:

Putting some conditions in the query:

Elements are small blocks of code that can be reused in different pages of a layout.
Elements need to be uploaded in /app/views/elements/ directory and have the .thtml extension.
By default elements haven't acces to any data, if you want to give it access to any data you have to send it as a parameter in an array.

Example without parameters:

Example of calling an element with parameters:

This pieces of code need to be inserted in your view.

If you want to change the default welcome layout of the CakePHP framework you have to overidde it, you can do this by creating a default.thtml file in the app/views/layouts directory. Once you have done that you have only to specify to Cake to insert the controller view code in to the right place (our default layout in this case). You can to this by including the $content_for_layout and optionally $title_for_layout variables.

You can customize as you want your template by uploading images and styles in the webroot directory app/webroot which becomes your site root from now on.

Example:

After this is done you will see that cake changed the default layout with the one of yours and also the content of the page is cake successfully installation text. Now we have to insert in the new layout our own content. A quick way to do this is creating a controller in app/controllers named as we want but according to cake rules it has to be a plural, for example sites_controller.php . Inside of the controller we will have following code:

var $uses = array(); I use this because I don’t want Cake engine to look for a model regarding this controller. If you omit this line you will get a “missing model” error.

Browsing the http://example.com/sites/index it should reveal a page having your layout applied but with an error of ”missing view”. To get rid of that error you have to create a file called index.thtml in the app/views/sites/ (you have to create the directory also) file that will be the view for your index action of your Sites controller.
If you want visitors to point directly to a certain action of a controller when they enter your website you can do that using “Route Configuration”. Routing is like a mod_rewrite with the help of which you can map URLs to controllers actions and params and back. Routes are configured in app/config/routes.php .
You can find more information about this at the Chapter Configuration on Cake’s Manual.

In our case our routing rule should look like this:

‘/’ – represents the URL we want to map, the domain itself in this case;
‘sites’ – is the controller we wish to invoke
‘index’ – the action we wish to invoke

Now when we point on http://example.com/ Cake engine should display the following page http://example.com/sites/index (sites controller with the index action).

I've started again learning CakePHP framework and I decided to write as I learn some practical examples of using this development tool. If you know something about Cake, I invite you to read this following posts. I know they are not with a solid documentation behind but maybe you can use some things from here.