Building Desktop Applications in PHP

So, you’re a hotshot PHP developer. You’ve written a lot of code powering some pretty cool websites; maybe you’ve even written some public / open source scripts that other developers are using. You’ve been through it all with the web, from basic database hacks to battling with inconsistent browser rendering, and now you want to have a go at something different.

Of course, the standard destination would be desktop application development. But how can you get into desktop application development without leaving behind all your existing PHP skills? In this article, I’ll examine the techniques and systems you can use to build desktop applications, from GTK libraries to native Windows API calls.

Now, desktop application development is an entirely different cup of tea. It’s not what you’re used to: you’re used to being input-driven, but desktop apps are event driven (Delphi for PHP is the best of both worlds). As a result, before you start developing desktop applications, you’ll have to step back for a moment and examine the differences.

As a web developer, you’re familiar with the basics of web scripting. Client makes request to server, server runs your PHP code through PHP compiler/interpreter, output is sent to client etc. etc. Your entire request has finished very quickly; possibly in less than a second. The user didn’t do anything in between; the data for the request (cookie data, get / post values, server and environment variables etc.) was all set once before your code was run. When executing your script, PHP went from top to bottom, ending at the last line of code in your PHP file. Once it’s finished, the request is gone; the process finished, possibly even the thread killed.

Desktop applications, on the other hand, are nothing like this. Now that we have full-on JS-heavy web applications, you should have a basic understanding of how desktop application development works – think of it like a web application written entirely in JavaScript. It’s heavily event driven, with functions for different events such as a button click or a mouse move, and it keeps going without executing any code. In desktop applications, you first draw the window using some basic UI code, and then wait – just wait. You have to give up a bit of control to the operating system – for example, if you want a menu, you (typically) tell the operating system to draw a menu and to bind some of your functions to the menu items, then let it take care of the rest. It takes quite a while to get used to, but soon enough you’ll get the hang of it, and be building fantastic desktop applications in no time.

Of course, as your applications are written in PHP, you can also reuse all your existing PHP code - well, almost all (HTML output won't exactly help). As a result, once you understand the basics of desktop development, you can be building powerful desktop applications in no time - you could even integrate with your existing web application!

There are a number of benefits to desktop development, from technical advantages to fundamental benefits. Here are some reasons why you should be developing desktop applications.

Technical advantages

There are a number of basic technical advantages to desktop-based applications. They can interact with the local filesystem, allowing settings to be saved on the user’s computer, files to be retrieved and manipulated, databases to be stored and so on. They generally integrate with the GUI toolkit of the operating system, providing a UI style that the user is familiar with – users are still getting used to the web application interfaces of our web 2.0 applications. And finally, they use consistent interfaces, unlike the hope-for-the-best approach to writing HTML, allowing for complex UI elements.

Fundamental advantages

However, perhaps most importantly, they are geared to user-driven applications, especially where the user has content to share. Web applications can easily bring users together, for effective sharing of information. Desktop applications, on the other hand, can easily work with the user and manage information, especially when there is no need to share that information.

Gaming is an excellent example; interface and graphics issues aside, games are built around the user, and as a result work very well on the desktop. Image editing is another; despite the availability of online Photoshop alternatives, everything at the higher end of image editing is still squarely on the desktop. Sure, there's Flickr, but Flickr is more geared towards the sharing of photos and basic editing.

As a result, if you're considering building an application that fits into one of these categories, and you've currently got a web application in mind, a desktop application is definitely worth considering.

To demonstrate basic application development in PHP, we'll take a look at the PHP-GTK extension. PHP-GTK offers GTK bindings for PHP, allowing you to build scripts that create windows using the GTK graphics toolkit.

The desktop approach

As you can imagine, building a desktop application when coming from a web background is a whole new ballgame. Consider that, when you run a PHP script on the web, it goes from top to bottom. When you run a desktop application, you open it, and wait. And wait. And wait. It doesn't matter how long you wait for - you are waiting, and the application is not doing anything. Of course, the moment you click a button or open a menu, it springs into action again. At what point in the execution of a standard PHP script is absolutely nothing happening? (Besides in sleep()) .

Now, the only real way to achieve this in PHP is an infinite loop, with a check for some sort of change or input on every iteration. Which is exactly how the various most of the PHP-desktop systems available function. Of course, it would be impractical for you to code this loop manually, as there's a lot of code all over the place. Instead, you tell the interface system to draw your interface and bind your functions/methods to the interface elements. Drawing your interface involves telling it what interface elements to create - such as buttons and input boxes - and where to put them. Binding allows you to link your functions/methods to certain events for these elements. For example, you could create a button, and have one of your functions called when the button is clicked.

That's where the fundamentals end and the various differences in systems come into play. So, let's take a look at some code to create a basic desktop application.

PHP-GTK

PHP-GTK is one of the standard approaches for creating desktop-based PHP applications. As it only requires GTK for interface bindings, it's cross-platform - you can write your application on a Mac, test it on a Linux machine and deploy it to a Windows box, and with no code adjustments it will look (almost) exactly the same on each.

Before continuing, if you want to try out the code samples, you'll need a copy of PHP-GTK. You can download it from gtk.php.net; there are windows binaries, but for everything else you may have to use CVS. Installation instructions are available on the download page; you might find these instructions for Ubuntu useful as well.

Now, let's take a look at a basic PHP-GTK script from the manual. Here's the full code:

<?php
// Code snippet from the PHP-GTK manual.
if (!class_exists('gtk')) die("Please load the php-gtk2 module in your php.ini");

$window = new GtkWindow();
$window->set_title('Our PHP-GTK window');
$window->connect_simple('destroy', array('gtk', 'main_quit'));

$label1 = new GtkLabel("Hello world!");
$window->add($label1);

$window->show_all();
Gtk::main();
?>

As you can see, it's perfectly normal PHP code. However, it's relatively short; it ends with a call to this mysterious Gtk::main(). Remember that infinite loop I mentioned? When you finish creating your window and drawing it, your scripts hand over to the GTK library that handles that same loop. Still, it's new territory, so let's step through the code and review it.

if (!class_exists('gtk')) die("Please load the php-gtk2 module in your php.ini");

Pretty standard stuff: we check that the 'gtk' class is available. Without it, you won't be able to render your windows with the GTK toolkit. As PHP isn't really designed for desktop applications, there is still the potential for deployment quirks such as lack of the GTK module, so we carefully check it here.

$wnd = new GtkWindow();
$wnd->set_title('Our PHP-GTK window');

The GtkWindow class is, as it's name suggest, a GTK window. Working with GTK in PHP is heavily object oriented; you'll have objects for your windows, the interface elements on those windows, GTK itself and more. The set_title() method sets the title, similar to using a <title> tag in HTML, with the exception that what really goes in the title bar is no longer at the mercy of the end-user environment.

$window->connect_simple('destroy', array('gtk', 'main_quit'));

This is where we start binding to the interface. When the user clicks the close button on our application, it doesn't just magically clean up after itself and quit. The operating system can't simply kill our application; chances are we want to tie up some loose ends and clear out data we've stored. As a result, we have to link the 'destroy' signal to the gtk::main_quit() method. This method essentially ends our application so that we can cleanly exit.

$label1 = new GtkLabel("Hello world!");
$window->add($label1);

Now we start creating our interface. We'll start with a simple label. In desktop applications, if you want to cleanly position text (and you do, as opposed to running it all from the top-left corner of the form) it needs to be in some sort of container, and a label is the common term for a basic text container in a window.

You can position your label, give it some additional properties and so on, but for now we'll just give it the text "Hello world!". By calling the add() method of our GtkWindow object $window, we tell GTK to put our new label on our window. Without this, the label can't really appear anywhere. Interestingly, this approach of not scoping an interface element within a particular form makes element reuse simple and effective.

$window->show_all();
Gtk::main();

This is the interesting part. First of all, our window won't actually appear until we call the show_all() method on our window's object. This call tells GTK to show the window on the screen. However, that infinite loop I mentioned before? Now that we've finished drawing our window, we're ready to roll. We call Gtk::main(), and away we go...

Your first PHP-GTK application!

If you're trying to run this application, I presume you're running it from the command line with PHP-CLI. To check that everything's in order, click the 'x' button in the top-right. Your PHP-GTK application should close, and your console window should indicate that the program has finished and take you back to the prompt.

With PHP-GTK, you have all the power of the GTK toolkit, allowing you to create complex interfaces and high-end applications. Check out the PHP-GTK manual for some more complex tutorials. There are also some good tutorials elsewhere online.

So, we've examined the fundamentals of desktop application development, and taken a look at the PHP-GTK library. We've seen a very basic desktop application written in PHP, and examined the systems under the hood to keep everything running smoothly. The PHP-GTK documentation contains some fatnastic tutorials, so for further reading it should certainly be your first destination. Here are some useful resources you can use to further investigate desktop application development in PHP:

• Official manual for PHP-GTK 2
• Advanced Hello World tutorial, including a login form
• Using Glade, a WYSIWYG UI designer, to design your forms
• Tutorial on using the GtkTreeView widget