Inside DealTakerviews » Inside DealTaker http://www.dealtaker.com/our-blog Just another DealTaker.com site Fri, 10 Feb 2012 14:56:55 +0000 en hourly 1 http://wordpress.org/?v= Kohana PHP 3.0 (KO3) Tutorial Part 2 http://www.dealtaker.com/our-blog/2009/12/07/kohana-php-3-0-ko3-tutorial-part-2/ http://www.dealtaker.com/our-blog/2009/12/07/kohana-php-3-0-ko3-tutorial-part-2/#comments Mon, 07 Dec 2009 10:47:54 +0000 ellisgl http://www.dealtaker.com/blog/?p=1835 Welcome to the second part in this series on how to develop with Kohana PHP V3 (KO3). If you haven’t read the first part, I would read it before going on. In this tutorial we will be going over how to develop views.

Before we get into views, we’ll want to update the KO3 code base, So point your browser to http://dev.kohanaphp.com/projects/kohana3/files, download it, open it and extract everything inside the “kohana” folder to “mykohana3″. Once you have done that, delete or rename the “install.php” in your “mykohana3″ folder. Next, open up the “bootstrap.php” file in the “application” folder and change the following line:
[php]Kohana::init(array(‘base_url’ => ‘/kohana/’));[/php]
to
[php]Kohana::init(array(‘base_url’ => ‘/mykohana3/’,
‘index_file’ => ”));[/php]
Now that we are updated to the latest and greatest, lets get right in to developing a view. Create a new folder within the “application” folder named “views” and inside the “views” folder, create another folder named “pages”. Now open up a new document in your editor and put the following in it:
[php]<html>
<head>
<title>Hello!</title>
</head>
<body>
<h1>This is my first view</h1>
</body>
</html>[/php]
Now save that in your “application/views/pages” as “ko3.php”. As you can tell, it’s a pretty simple HTML page with some PHP mixed in. Lets open the “ko3″ controller (“application/classes/controller/ko3.php”). Replace the “action_index” class with the following:
[php] public function action_index()
{
$this->request->response = View::factory(‘pages/ko3′);
}[/php]
Save it, and load up “http://yourserver/myfirstkohana3/” in your browser. You should see “This is my first view”. The code above is pretty simple, we use the “Facotry” method of the view class to load the file “application/views/pages/ko3.php”, renders it and outputs it. Not very exciting, so let go back to the view (“application/views/pages/ko3.php”) and add:
[php] <?php echo $content;?>[/php]
After the “h1″ tags. Your view should look like this:
[php]<html>
<head>
<title>Hello!</title>
</head>
<body>
<h1>This is my first view</h1>
<?php echo $content;?>
</body>
</html>[/php]
If we were to refresh the browser, we would seen an exception error about an undefined variable. So let’s go ahead and fix that, by relating data to the view variable in our controller. So, change up “Action_Index” controller to look like this:
[php] public function action_index()
{
$view = View::factory(‘pages/ko3′);
$view->content = ‘We have data!’;
$this->request->response = $view->render();
}[/php]
Now if we refresh the browser, we should see “This is my first view” and under that “We have data!”. Lets explain the the code line by line.
[php]$view = View::factory(‘pages/ko3′);[/php]
This load our view file (“application/views/pages/ko3.php”) into the view controller.
[php]$view->content = ‘We have data!’;[/php]
This assigns a variable for use by the view called “content” and we also assign data to that, in this case it’s “We have data!”
[php]$this->request->response = $view->render();[/php]
This renders the view and outputs it.

Simple enough, but there is another way of doing the above. We could have also done the following:
[php] public function action_index()
{
$data['content'] = ‘We have data!’;
$view = View::factory(‘pages/ko3′, $data);
$this->request->response = $view->render();
}[/php]
Basically the above use an array with element keys as the template variable names to assign the data. We are not done yet! There’s 2 more ways we can do the above.
[php] public function action_index()
{
$view = View::factory(‘pages/ko3′)
->set(‘content’, ‘We have data!’);

$this->request->response = $view->render();
}[/php]
The above used the set method of the view class, which you can use method chaining to set all your template variables. And now for forth way:
[php] public function action_index()
{
$content = ‘We have data!’;
$view = View::factory(‘pages/ko3′)
->bind(‘content’, $content);
$this->request->response = $view->render();
}[/php]
Now the above is using the bind method of the view class. Once again, this you can do method chaining here. This is a little bit different from the set method, since it will create a reference to a variable. So $content might equal ‘We have data!’ when we bound the variable to the template variable, but could change later on, since we are referencing the variable $content in our controller, instead of assigning data to the template variable.

If we were to do the following:
[php] public function action_index()
{
$content = ‘We have data!’;
$view = View::factory(‘pages/ko3′)
->bind(‘content’, $content);
$content = ‘Our data changed’;
$this->request->response = $view->render();
}[/php]
Instead of “We have data!” showing on our screen, we would have “Our data changed”.

Now lets do a view with in a view! Create a new folder in your “application/views/” named “blocks”. Lets create another view file named “ko3_inner.php” and put this in it:
[php] <h3>This is an inner view</h3>[/php]
Save that in your “application/views/blocks/” directory. Now lets edit the “ko3″ view (“application/views/pages/ko3.php”) and add the following:
[php] <?php echo View::factory(‘blocks/ko3_inner’)->render(); ?>[/php]
You view should like this:
[php]<html>
<head>
<title>Hello!</title>
</head>
<body>
<h1>This is my first view</h1>
<?php echo $content;?>
<?php echo View::factory(‘blocks/ko3_inner’)->render(); ?>
</body>
</html>[/php]
So if we run it we should see what we had before, then “This is an inner view”. This would be useful for static content, but we won’t be able to use variables directly to that view. So let fix this. Lets go back to our controller (“application/classes/controllers/ko3.php”) and edit the “Action_Index” method to look like this:
[php] public function action_index()
{
$ko3_inner['content'] = ‘We have more data’;
$ko3['content'] = ‘We have data’;
$ko3['ko3_inner'] = View::factory(‘blocks/ko3_inner’, $ko3_inner)
->render();
$view = View::factory(‘pages/ko3′, $ko3);
$this->request->response = $view->render();
}[/php]
This will render the view to a array that then is rendered by the main view. If you noticed I did the inner stuff first and went back to using array template variable setting style. Next we will need to edit the main view (“application/views/pages/ko3.php”). The line we put in before, we will change it to:
[php] <?php echo $ko3_inner; ?>[/php]
The view should look like this:
[php]<html>
<head>
<title>Hello!</title>
</head>
<body>
<h1>This is my first view</h1>
<?php echo $content;?>
<?php echo $ko3_inner; ?>
</body>
</html>[/php]
And the last change we need to make is to the inner view (“application/views/blocks/ko3_inner.php”). Make it look like this:
[php] <h3>This is an inner view</h3>
<?php echo $content;?>[/php]
If you refresh the browser after saving, you should now see the following:
[php]This is my first view

We have data

This is an inner view

We have more data[/php]
Pretty cool, now you can make your views more modular and reusable. Now lets get into making variables globally available to your views. Back to your controller (“applications/classes/controllers/ko3.php”) and edit the “Action_Index” method so the following is at the top of the method:
[php] View::set_global(‘x’, ‘This is a global variable’);[/php]
So now the method should look like this:
[php] public function action_index()
{
View::set_global(‘x’, ‘This is a global variable’);

$ko3_inner['content'] = ‘We have more data’;
$ko3['content'] = ‘We have data’;
$ko3['ko3_inner'] = View::factory(‘blocks/ko3_inner’, $ko3_inner)
->render();
$view = View::factory(‘pages/ko3′, $ko3);
$this->request->response = $view->render();
}[/php]
Now if you were to edit your views and add in:
[php] <br/><?php echo $x;?>[/php]
You should now see “This is a global variable” two times on the page. As you can see this could be very handy. Basically, we are using the static method of “set” from the view class, so it ends up being available to all view object instances. You can also use the static method of “bind” to reference variables. This could be handy for dry things “DRY” and could be used in other place, like a contruct.

Untill next time, when I go over “templates” (advanced views and controller stuff), happy coding!
Sources used: Unofficial Kohana 3 Wiki

Part 1 | Part 3

]]> http://www.dealtaker.com/our-blog/2009/12/07/kohana-php-3-0-ko3-tutorial-part-2/feed/ 37 Kohana PHP 2.3.x Tutorial Part II http://www.dealtaker.com/our-blog/2009/05/21/kohana-php-23x-tutorial-part-ii/ http://www.dealtaker.com/our-blog/2009/05/21/kohana-php-23x-tutorial-part-ii/#comments Thu, 21 May 2009 09:51:27 +0000 ellisgl http://www.dealtaker.com/blog/?p=633 Welcome to the second tutorial in this series on how to develop with Kohana PHP. If you haven’t read the first part, I would read Part 1 before going on. In this tutorial we will be going over views, wonderful views, glorious views.

Let’s just dive straight into building our first picturesque view.
Create the file “myfirstkohana/application/views/hello.php” and put the following into it:

<html>
 <head>
  <title>Hello!</title>
 </head>
 <body>
  <h1>This is my first view</h1>
  <?php echo $content;?>
 </body>
</html>

Looking at the above, it’s pretty straight forward and simple HTML file with some simple PHP code thrown in.

Just because we put a view with the same name as our controller, it’s not going to be shown until we say so. Let’s go back to our wonderful controller “myfirstkohana/application/controllers/hello.php” and edit the index method to look like the following:

public function index()
 {
  $view          = new View('hello');
  $view->content = 'Hello World!';
  $view->render(TRUE);
 }

Let go through this line by line. The first line:

$view = new View('hello');

tells the framework to create a new “view” object and load the file :myfirstkohana/application/views/hello.php” into it. The next line:

$view->content = 'Hello World!';

creates a new property called “content” in the object that has the value “Hello World!”. The last line

$view->render(TRUE);

compiles the template with our assigned values and outputs it to the screen. What we should get when we load “http://youserver/myfirstkohana/hello” is “This is my first view” and below that should read “Hello World!”.

This might the simplist view you’ll see. Of course, I don’t think we’ll be wanting something so simple, so lets knock it up notch and create views with nested views.

Create the file “myfirstkohana/application/views/default_template.php” and put this in it:

<?php echo $header; ?>
<?php echo $content; ?>
<?php echo $footer; ?>

The above code is just a master template, or the template of templates if you will. Next lets create “myfirstkohana/application/views/default_header.php” and put the following into it:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" >
 <head>
  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
  <title><?php echo $pageTitle;?></title>
 </head>

and then “myfirstkohana/application/views/default_content.php”:

 <body>
  <h1>This is my second view</h1>
  <?php echo $content;?>

finally “myfirstkohana/application/views/default_footer.php”:

 </body>
</html>

Above we taken a basic HTML page and split it up “logically” into a header, footer and a content section. Let open our controller to build out our more complex view. Edit “myfirstkohana/application/controllers/hello.php” to make the index method look like this:

  public function index()
   {
    $view                    = new View('default_template');
    $view->header            = new View('default_header');
    $view->content           = new View('default_content');
    $view->footer            = new View('default_footer');
    $view->header->pageTitle = 'I am on the top';
    $view->content->content  = 'Hello World!';

    $view->render(TRUE);
   }

That wasn’t too hard was it? Basically we load our first view, which is the main template. Then we populate our properties with objects of our inner templates. It’s like working with multi-demential arrays in a sense.

With the ability to nest views/templates inside each other, things are a lot nicer to deal with. There is a problem thou. Each method (action) that needs to have a templated view, you need to do what we did to our index action to each one. Kohana does have an answer.

The Template_Controller allows to give a default view to actions, which if you have a lot of actions for a controller, it can really cut down on development and debugging time. Let go ahead and re-work out the hello controller (“myfirstkohana/application/controllers/hello.php”).

<?php
defined('SYSPATH') or die('No direct access allowed.');

class Hello_Controller extends Template_Controller
 {
    public $template    = 'default_template'; // Default template (view) to use
    public $auto_render = TRUE;               // Auto render template after controller is done

    public function __call($method, $arguments)
     {
        $this->name($method);
     }

    public function __construct()
     {
        parent::__construct(); // Has to be here!

        // Load the inner templates
        $this->template->header            = new View('default_header');
        $this->template->content           = new View('default_content');
        $this->template->footer            = new View('default_footer');
        $this->template->header->pageTitle = 'My first Kohana App';
     }

    public function index()
     {
        // Put something useful in our variables.
        $this->template->header->pageTitle .= ' ::: I am on the top';
        $this->template->content->content   = 'Hello World!';
     }

    public function america()
     {
        $this->template->content->content = 'Hello America!';
     }

    public function name($name)
     {
        $this->template->content->content = 'Hello ',$name,'!';
     }
 }

Here we have defaulted our main template, so now we didn’t have to declare it in each method. Also in our constructor method, we loaded the sub templates in and gave a default value to one of the template variable that used in the title tag. In our index method we added on to the title tag (think SEO) and put some generic content in place.

Stay tuned for the third part of our series and find out about models and working with external data!

]]> http://www.dealtaker.com/our-blog/2009/05/21/kohana-php-23x-tutorial-part-ii/feed/ 12