By far, the best new feature is PHP support, which adds a whole new dimension to Titanium development. It will also facilitate the porting of existing codebases and frameworks to Titanium apps, potentially increasing the market substantially.

Another great new feature is the introduction of native social APIs. You will be able to connect to Yahoo YQL, Facebook Connect and Twitter all from directly in a Titanium application.

There are a quite a few smaller changes, and while I have yet to confirm it, I have it on good authority that Titanium 0.7 also now supports native drag and drop functionality.

Things are really looking good and Titanium seems to be maturing nicely.

Related posts:

1. Anyone interested in a Titanium Webinar? I got contacted a few days ago by the Appcelerator...
2. Appcelerator launces App U for Titanium In some exciting news from Appcelerator, they have launched Appcelerator...
3. Adobe Air 2.0 coming early next year I saw this morning on Inside RIA that Adobe Air...

Related posts brought to you by Yet Another Related Posts Plugin.

They provide all the materials you need, as well as extras like t-shirts and pennants. And don’t worry if you don’t know what to talk about, they also provide prepared presentations for you to use.

If anyone is interested in hosting or attending an event, or if anyone in the Cape Town area would like me to host such an event, please leave some comments. I would love to hear your views.

Related posts:

1. Anyone interested in a Titanium Webinar? I got contacted a few days ago by the Appcelerator...
2. It is not only IT projects that end up late and overbudget! As a programmer, I am no stranger to projects that...
3. Titanium 0.7 is now out with some great new features Titanium 0.7 has just been released, and some of the...

Related posts brought to you by Yet Another Related Posts Plugin.

I would like to encourage anyone who is interested to leave a comment with when would suit you to hold it, and any topics which you would like to discus. I will then let Appcelerator know, and then we can organise it.

Hope to hear from all of you….

Related posts:

1. Appcelerator launces App U for Titanium In some exciting news from Appcelerator, they have launched Appcelerator...
2. Titanium 0.7 is now out with some great new features Titanium 0.7 has just been released, and some of the...
3. CMIS 1.0 specification now available for comment CMIS 1.0 was released for public comment recently, and is...

Related posts brought to you by Yet Another Related Posts Plugin.

For a normal web browser, before the browser can display a Flash object, the Flash player needs to be installed as a plugin on the computer first. Titanium, however, has got the Flash player included already, which means that when working with Flash, you never need worry about showing a message asking the user to install the plugin before they can view the site. It just always works.

There are two ways in which a Flash object can be embedded into a page. It can either be done with an <object> tag, or using the Javascript swfobject object.

Using the HTML tag:

   <object classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000"
         width="780" height="420">
      <param name="src" value="media/sample.swf" />
      <object type="application/x-shockwave-flash" data="media/sample.swf"
            width="780" height="420">
       </object>
   </object>

In the above example, the classid of the object must always be set to the value in the sample code. The movie parameter is also the only required parameter, and points to URL of the Flash object you want to display

Here is some sample code of including a Flash object using Javascript:

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

   <p id="sampleFlash">Flash will go here</p>
   <script type="text/javascript">
      var flashvars = {
         var1: 'Hello World',
         anotherVar: '7'
      };

      swfobject.embedSWF(
         'media/sample.swf', // path to the widget
         'sampleFlash', //id of HTML element to replace
         '200', // width of the widget
         '200', // height of the widget
         '8', //Flash version
         null, //express install path - not needed since Flash installed
         flashvars, //Variables to pass to Flash object
         {scale: 'noscale', wmode: 'transparent'} //parameters to pass
      );
   </script>

The first thing to notice here is the the swfobject.js file, which can be obtained from the swfobject project site, needs to be included on the page, as this contains the necessary Javascript for the swfobject object.

Then you need to add an HTML element on the page which will be replaced by the Flash object.

Finally, we need to add the Javascript code to add the object to the page. We embed the Flash object with the swfobject.embedSWF() function.

Titanium also allows the Flash object to be either a local file or a remote file, thus using Flash in Titanium is pretty much limitless.

Visit the swfobject project site for more information on using the swfobject object.

Related posts:

1. Cufon brings any font to a browser near you I stumbled upon a rather useful Javascript library the other...
2. Adobe Air 2.0 and Flash Player 10.1 betas have been launched Ah, the sheer programming bliss. I have been eagerly awaiting...
3. Creating a basic map using the Google Maps API The first thing you need to be able to use...

Related posts brought to you by Yet Another Related Posts Plugin.

A Titanium app can load a file into a window using either the HTTP or the APP protocol. The APP protocol is a Titanium specific protocol which tells Titanium to reference the local resource folder for the page to display.

The crucial difference here is that a page loaded using APP is allowed to access the Titanium API and make calls to it freely. Pages loaded via HTTP cannot.

This means that if you have an HTML page sitting on a webserver somewhere, and it contains a call to the Titanium API, it will not work if you load that page into a Titanium window. The page will work normally if there are no Titanium calls.

So, what do you do when you want to have code sitting on a remote server that you want to be able to run in Titanium?

There is a very easy way in which to accomplish this.

The first step is to put any Javascript you want to run on the remote server into a JS file rather than directly in the HTML page.

Now, there is no way to get around having a local HTML page, so you would need to create a local HTML page, and then you can reference the remote JS file. For example:

<html>
   <head>
      <script src="http://www.someserver.com/test.js" language="Javascript">
      </script>
   </head>
</html>

The page will then load the Javascript, running it as if the page was loaded locally, while having (almost) all the code on the server.

This works very well for an application where the HTML page is used mainly as a frame for the Javascript which renders all the page elements.

Related posts:

1. How browser incompatibility can waste my day I got struck by a curious problem the other day....
2. A possible replacement for HTTP in the works If the good old rumour mill of the internet is...
3. Transferring files using SFTP in C# C# does not have native capabilities to use SFTP, but...

Related posts brought to you by Yet Another Related Posts Plugin.

Thanks to to mrobinson on the Titanium for pointing out the needed function in the API. I wasted several hours looking in the wrong place for how to do this.

The functionality to get the directory listing is found in the File object.

The example listed in the Titanium API is as follows:

   var win = Titanium.UI.getCurrentWindow();

   win.openFolderChooserDialog(function(folderResponse) {
      var file = Titanium.Filesystem.getFile(folderResponse[0]);
      var listing = file.getDirectoryListing();
      for (var i = 0; i < listing.length; i++) {
         alert('Name: ' + listing[i].name() +
            ',isDirectory: ' + listing[i].isDirectory() +
            ',isHidden: ' + listing[i].isHidden());
      }
   });

First we show a Folder Chooser dialog, which works very similarly to the File Chooser dialog which I covered in a previous blog post. The file chooser calls a callback function and asses an array as the parameter. If a folder is selected, it will be contained in the first element in the array.

Next, we get a reference to the file Titanium.Filesystem.getFile()with the folder path as the parameter.

The crucial step then, is to call file.getDirectoryListing() which gets an array of file objects representing the files and folders in the selected folder.

You can then loop through this array and process the results in whichever way your application needs.

Some useful functions are listing[i].name() which lists the name of the file or folder without the full path, listing[i].isDirectory() which returns whether it is a folder or file, and listing[i].nativePath() which returns the full path of the file.

You can view the Titanium API Documentation for more details.

Related posts:

1. Obtaining the contents of a folder in C# Getting the list of files in a folder in C3...
2. Anyone interested in a Titanium Webinar? I got contacted a few days ago by the Appcelerator...
3. Titanium 0.7 is now out with some great new features Titanium 0.7 has just been released, and some of the...

Related posts brought to you by Yet Another Related Posts Plugin.

To open a SaveAs dialog box, we first set up the options object, and then call the function to open the dialog, passing it the callback function to call once it is closed.

  var options = {
     title: "Save file as...",
     types: ['*'],
     typesDescription: "All files",
     path: Titanium.Filesystem.getUserDirectory()
  }

  Titanium.UI.openSaveAsDialog(callbackFunc, options);

In types we put the file types filter, for example ['doc', 'txt]. The path is the default path to point the dialog to.

Next in the callback function, we can reference the filename which is returned as an array, which when saving a file is always going to be one element, but may be multiple filenames for an Open dialog.

   callbackFunc = function(filenames){
      var fileSelected = filenames[0];
   }

Creating a file chooser dialog is very similar. This dialog allows multiple files to be selected.

   var options = {
      multiple: true,
      title: "Select files to open...",
      types: ['doc', 'txt'],
      typesDescription: "Documents",
      path: Titanium.Filesystem.getUserDirectory()
   }
   Titanium.UI.openFileChooserDialog(callbackFunc, options);

In the callback function, the only difference is that the array of filenames may have more than 1 filenames in it.

   callbackFunc = function(filenames) {
      var firstFileSelected = filenames[0];
      var secondFileSelected = filenames[1];
   }

That is all there is to showing and processing file dialogs.

I would point you to the Titanium API documention at this point, but have found no reference to the dialogs in the 0.4 documentation.

Related posts:

1. Anyone interested in a Titanium Webinar? I got contacted a few days ago by the Appcelerator...

Related posts brought to you by Yet Another Related Posts Plugin.

The basics of opening up a new window in Titanium is as follows:

   var currentWindow = Titanium.UI.getCurrentWindow();
   var newWindow = currentWindow.createWindow('http://www.google.com');
   newWindow.setWidth(400);
   newWindow.setHeight(300);
   newWindow.open();

First, we need to get the current window we want to work with, from which we are going to open the new window. This window will become the new window’s parent.

The new window is created with the .createWindow() method. The parameter is an optional parameter, but can be either a url, or an object containing the parameters for the new window. The url can be either an external url, which is signified by using http:// in the url, or else it can be a url pointing to an internal location in the application, which is prefixed by app:// and then the path to the html page to display.

Next we set a few attributes of the window. There is large amount of attributes that can be changed, which can be found in the documentation.

The last step now is to actually open the window, which is done with newWindow.open().

Closing a window is very easy, and all it entails is calling newWindow.close().

Useful properties of Titanium.UI are Titanium.UI.mainWindow which is a reference to the main application reference, andTitanium.UI.windows, which is a list of all the windows in the application. The first element in the list (element 0) is the main window, and all user windows are then after that, ie. from 1 upwards. As an example, getting the width of the first window created by the application looks as follows:

   Titanium.UI.windows[1].getWidth();

The parent window can also be accessed very easily from the child window using the getParent() method, which returns a reference to the parent window object. For example, to get the title of the parent window we can write:

   newWindow.getParent().getTitle();

The UserWindow object makes it easy to work with almost any aspect of a window, and the full listing of available methods can be found at the Titanium API Documentation.

Related posts:

1. Anyone interested in a Titanium Webinar? I got contacted a few days ago by the Appcelerator...

Related posts brought to you by Yet Another Related Posts Plugin.

File access in Titanium is very similar to how it is done in other languages like PHP or C#. The objects used are the File and FileStream objects, and the Titanium.Filesystem namespace.

So, to write some data to a file, the code is as follows:

   var contents = "Some contents to write";
   var filename = 'test.txt';
   var userDir = Titanium.Filesystem.getUserDirectory();
   var writeFile = Titanium.Filesystem.getFile(userDir, filename);
   var writeStream = Titanium.Filesystem.getFileStream(writeFile);
   writeStream.open(Titanium.Filesystem.MODE_WRITE);
   writeStream.write(contents);
   writeStream.close();

Titanium.Filesystem.getUserDirectory() gets the user directory of the currently logged in user. Other useful options here are getDocumentsDirectory(), getApplicationDirectory() and getDesktopDirectory(). The directory can also be a string representing any folder on the user’s machine but these functions provide a cross-platform method of obtaining the most common directories needed.

We then get the full file path as a string, using the directory (in this case the user directory) and the filename, after which we create an instance of the file stream, using the file path as a parameter.

Once we have created the file stream, we need to open the stream. For write access, we set the parameter to Titanium.Filesystem.MODE_WRITE.

All we need to do to write data to the file is call writeStream.write(contents) where contents is any arbitrary variable. To write data line by line we can use .writeLine().

Once we are done writing, we need to close the stream.

If the file we are trying to write to does not exist, then a new file will be created. If the file already exists then the original file will be overwritten. If you need to preserve the original file you can use Titanium.Filesystem.MODE_APPEND as the parameter when opening the stream, which will allow you to add data to the end of an existing file.

To read data from a file is just as easy:

   var readContents;
   var filename = 'test.txt';
   var userDir = Titanium.Filesystem.getUserDirectory();
   var readFile = Titanium.Filesystem.getFile(userDir, filename);
   if (readFile.exists()){
      var readStream = Titanium.Filesystem.getFileStream(readFile);
      readStream.open(Titanium.Filesystem.MODE_READ);
      readContents = readStream.read();
      readStream.close();
   }

The main differences to the code for writing compared to reading files, is that before we can open the file stream, we need to make sure the file exists first.

If the file exists we can create the instance of the stream, and then open the stream in read mode.

Once that is open we can call readStream.read() to read the contents of the file, which we can then store in a variable. We can also use .readLine() if wewant to read the data line by line, instead of as one large chunk.

For more information on the file access objects in Titanium, you can refer to the Titanium API Documentation.

Related posts:

1. Compression using C# You would have thought that .NET, with its vast libraries...

Related posts brought to you by Yet Another Related Posts Plugin.

Using the SQLite database is a simple affair, and makes use of theTitanium.Database namespace and the DB and ResultSet objects.

So, the first step is to connect to a database:

   var db = Titanium.Database.open('session_db');

The parameter is the name of the database to open.

Next, we execute a sql command on the database:

   var rs = db.execute('SELECT [value] FROM [session]
        WHERE [key] = \'' + val + '\'');
   if(rs.isValidRow()){
      val = rs.field(0);
   }
   rs.close();

The result set from the database call is returned, and then we can extract the data out of the resultset. If a command does not return a result set, such as a DELETE or an INSERT command, then the .execute() method can be called without assigning the result to anything. Once the result set has been used, it can be closed.

Once we are done with the database, we can then close it:

   db.close();

More information on the DB object can be found in the Titanium API Documentation.

Related posts:

1. Using MySQL from Visual Studio.NET Visual Studio.NET is very geared to being paired up with...

Related posts brought to you by Yet Another Related Posts Plugin.