In Google Chrome (and almost every other browser) you have the ability to define a user stylesheet that will be applied to every page by default. By adding a style that forces every element in the email to conform to the same font family and size, you will consistent looking emails in your browser without a massive overhead.

1. First, locate your user stylesheet file.
   • On Mac OS X, this can be found at ~/Library/Application Support/Google/Chrome/Default/User StyleSheets/Custom.css.
   • On Windows 7, it can be found at C:\Users\Username\AppData\Local\Google\Chrome\User Data\Default\User StyleSheets\Custom.css.
2. Open this file, and paste the following text into it:

   .aao .nH .ii, .aao .nH .ii * {
        font-size: 12px ! important;
        font-family: monospace ! important;
   }

3. Save the file, open Google Chrome, log in to your Gmail account, and open any message.

Of course, the font family and size can be replaced with whatever values you prefer. I hope this helps save you some time and frustration!

UPDATE: A small snapshot of the leaked data has been attached. There has been no action from the government or the media. I hope this article can build awareness that results in better protection of citizens data.

A couple of months ago I discovered an issue on a website operated by the government of Saint Lucia. I have contact the authorities, but to date, there has been no response. For the security of the current and former residents of Saint Lucia, I think that it is necessary to draw some attention to this issue, without revealing the actual leak and exploits.

The issue exposes personally identifiable information, such as the individual’s full name, where they live, their occupation and their registration number. What is the most alarming is that registration number is also a portion of their national id card number.

Please see below for a sampling of one of the emails directed to the Saint Lucian government:

It appears that extremely minimal security exists on the electoral.gov.lc domain …By far the most obvious and gaping security hole is the exposure of what should be sensitive PDF files containing personally identifiable information. This is in violation of your own privacy policy (www.electoral.gov.lc/privacy.htm), and for commonwealth citizens living in your country, most likely CariCom and Commonwealth information security policies. While this information is posted for a time publicly around the island (which in itself is questionable), having it freely available to world at large on the internet presents a whole new series of dangers. A small sample of these PDF files are listed below:

• http://www.electoral.gov.lc/voterslists%5C2009_supp%5CSecondHalf%5CA1-Voters%20List.pdf
• http://www.electoral.gov.lc/voterslists%5Crevised_2010%5CA1_Voters%20List.pdf
• http://www.electoral.gov.lc/voterslists%5C2009_supp%5CSecondHalf%5CA2-Voters%20List.pdf
• http://www.electoral.gov.lc/voterslists%5Crevised_2010%5CA2_Voters%20List.pdf
• http://www.electoral.gov.lc/voterslists%5C2009_supp%5CSecondHalf%5CA3-Voters%20List.pdf
• http://www.electoral.gov.lc/voterslists%5Crevised_2010%5CA3_Voters%20List.pdf
• http://www.electoral.gov.lc/voterslists%5C2009_supp%5CSecondHalf%5CB1-Voters%20List.pdf
• http://www.electoral.gov.lc/voterslists%5Crevised_2010%5CB1_Voters%20List.pdf
• http://www.electoral.gov.lc/voterslists%5C2009_supp%5CSecondHalf%5CB2-Voters%20List.pdf
• http://www.electoral.gov.lc/voterslists%5Crevised_2010%5CB2_Voters%20List.pdf
• http://www.electoral.gov.lc/voterslists%5C2009_supp%5CSecondHalf%5CB3-Voters%20List.pdf
• http://www.electoral.gov.lc/voterslists%5Crevised_2010%5CAB3_Voters%20List.pdf

…Additionally, I have used publicly exposed information to perform a basic security audit of the electoral.gov.lc domain. It appears that you are running a Windows 2000 server with IIS 5.0 web server. It has Frontpage Extensions are turned on and in use. Also, it appears that MySQL is being used as database software on this server as well, and default ports are open. I have not attempted any connections beyond using default username and password combinations, which at the very least seem to have been changed, but this configuration alone is extremely vulnerable to attack using widely publicized exploits, simply because it is out of date (IIS 5.0), using an unsupported database in Microsoft’s eyes (MySQL; they do not release patches for this configuration), and is an insecure (Frontpage Extensions) configuration. Generally this would be an issue in itself, but there does not appear to be an adequate firewall protecting sensitive ports.

Finding this information is surprisingly easy: Simply conduct this Google search.

Why would this be an issue? Well, suppose a thief wanted to steal a large sum of money. A list with every single resident of the country and their occupation would certainly help narrow down wealthy potential targets. Through the use of public phonebooks and social networks much more information could be gathered, because the individuals location and full name make them personally identifiable. Additionally, calling a bank and asking for a money transfer will generally result in security confirmation questions being asked. Many times, what do these involve? Relatives (available on the list), location (made possible by the list and the public phonebook), telephone number (made possible by the list and the public phonebook), and identification numbers (available on the list).

The servers hosting this information are also running severely outdated software. Using publicly available exploits to gain access to the server would allow free access these databases. This also presents a national security risk.

This is clearly an issue for individual Saint Lucians and the Saint Lucian government. Regarding foreign nationals who at one time lived in Saint Lucia, the Saint Lucian government could also be liable, and could possibly risk it’s compliance with CARICOM and Commonwealth information security policies.

I have noticed that more than 20% of visitors to this site do not have browser language set to English. Many of you manually cut and paste the page you are looking for into Google Translate. In order to make translation easier, I have added the Google Translator tool to the top-right of every page in this site :) I would love to know if this has been of benefit to you!

Ich habe bemerkt, dass mehr als 20% der Besucher dieser Website nicht über Browser-Sprache auf Englisch eingestellt. Viele von Ihnen manuell Ausschneiden und Einfügen der Seite Sie suchen in Google Translate. Um Übersetzung einfacher, ich habe die Google Translator Tool, um die rechts oben auf jeder Seite hat in dieser Site :) Ich würde gerne wissen, ob dies von Vorteil für Sie wurde!

J’ai remarqué que plus de 20% des visiteurs de ce site n’ont pas la langue du navigateur mis à l’anglais. Beaucoup d’entre vous manuellement copier et coller la page que vous recherchez dans Google Translate. Afin de faciliter la traduction, j’ai ajouté l’outil Google Translator à la partie supérieure droite de chaque page de ce site :) J’aimerais savoir si cela a été bénéfique pour vous!

我注意到，20％以上的遊客到這個網站沒有瀏覽器的語言設置為英語。許多您手動剪切和粘貼網頁您正在尋找到谷歌翻譯。為了使譯文更容易，我已經加入了谷歌翻譯工具右上角的每一頁在這個網站：）我很想知道這一直是你的好處！

Ho notato che oltre il 20% dei visitatori di questo sito non hanno la lingua del browser impostata su inglese. Molti di voi manualmente tagliare e incollare la pagina che stai cercando in Google Translate. Al fine di rendere la traduzione più semplice, ho aggiunto lo strumento di Google Translator in alto a destra di ogni pagina di questo sito :) Mi piacerebbe sapere se questo è stato di beneficio per voi!

One the most requested features in Google Apps for companies switching from Microsoft Exchange is the ability to provide access to public folders in Outlook. Fortunately, just about all of the features available in public folders can be made available online and in Outlook with a bit of ingenuity.

If you truly need public folders exactly the same as Microsoft Exchange, an excellent solution has been provided by CodeTwo, with their Public Folders product. Rather than requiring the purchase, configuration, and maintenance of a Microsoft Exchange server, all you need is an instance of Outlook with the CodeTwo Public Folders server installed on the local network. Everything else you need is provided by Google Apps. There are two main drawbacks to this approach: public folders are not available on the Google web interface, and CodeTwo Public Folders costs $160, plus ~$40 per user.

However, it is possible to replicate almost all of public folder’s features quiet nicely with Google Apps and a few productivity tools. Lets start by examining each feature of public folders according to Microsoft, and how it can be provided in Google Apps.

Share files

You may be aware that you can upload any type of file to Google Docs, not just documents. However, the problem with Google Docs is the rather irritating process of uploading and sharing files, especially if your clients are used to accessing these files in public folders.

There are 2 tools that make this process far easier: InSync for OS integration, and Harmon.ie for Outlook integration. If you have ever used Dropbox, InSync will be extremely familiar. It sets up a folder/drive (depending on your operating system) which give you direct access to all the files stored in Google Docs. It allows you to drag and drop files in and out of you Google Docs, and access these files in all your native applications. Harmon.ie allows a user to access all of their Google Docs from within Outlook itself and has a ton of great features that, in my opinion, add a lot more functionality that native public folders anway.

Share calendars, contacts, and tasks

This process is extremely easy, as Google has provided the Google Apps Sync for Microsoft Outlook plug-in, which configures calendar, contact, and task sharing automatically. However, there is one minor caveat when it comes to syncing notes, tasks, and journals: the data will be stored on Google’s servers, but will not appear on the web interface. Please read the Google Apps Sync for Microsoft Outlook support page for more information.

Centralize shared information

The methods we have discussed describe how to access the information, but it doesn’t tell us how to sharestore it. There is one easy way to centralize all the information that you want to share: add a new user called public. When you configure Outlook for the first time, use Google Apps Sync to configure the user’s account first, and then configure the public account second. When configuring InSync/Harmon.ie for file sharing and access within Outlook, simply configure public account here as well. If there is an email that a user feels should be shared with the organization, they can drag a copy of it from their own mailbox into the public folder, and everyone will have access to it.

Track and archive information

The Outlook public folders page describes this functionality:

Using the By Conversation Topic view of public folders, you can track responses to posts and the frequency of those responses. When a post becomes dated, you can archive the information using the AutoArchive feature in Microsoft Outlook.

The exact same functionality will be available both within Outlook and the Google Apps web interface. In my opinion, the Google Apps web interface is actually superior when it comes to grouping conversations. Of course, the archive feature in Google Apps web interface is also just as slick.

Help protect information

This approach lacks any real support for access right and permissions within the organization. If you need internal access control, one possible approach you could take is creating separate folders for each group of users: for example, you might add a user called managers, another called accounts, and another called staff, and only configure these for the relevant Outlook users.

Conduct online discussions

This is another area this approach lacks any real support. That said, online discussions are poorly implemented Microsoft Exchange as well. For real online discussions, perhaps consider Google Groups, and some of Google Apps other messaging applications. Google Wave was an excellent collaboration tool, but unfortunately it is no longer available in Google apps.

Final thoughts

For small to medium sized organizations, Google apps has the potential to save a lot of money, and removes all the headaches involved with maintaining an email server like Microsoft Exchange. In the case of this second approach, tools like Harmony can actually improve the way users work. If you need public folders, and you want to save money, then this is an excellent approach. If you have been through this process before and found your own solutions, then please let everyone know in the comments

XULRunner is a project that has been around since the inception of Firefox, and predates Adobe AIR by quiet a margin. For those who have not really looked into it too much, XULRunner has a lot of similarities to Adobe AIR – it is a cross platform runtime that allows you to run code written in XUL – an XML derivative very similar to HTML.

A little more information: XUL elements add certain features that are required to add things like menus, menu items, toolbars, toolbar buttons and the like into your application, and can be mixed and matched with HTML. XULRunner also exposes extra functions to JavaScript, allowing you to access files on the host computer, read and write from SQLite databases, and do a lot of things that AIR does in this regard.

I haven’t played with XUL a whole lot since AIR came out, as documentation has always fallen behind AIR’s. And performing some advanced functions, like populating a tree component with SQLite results, or manipulating an image, are a little more involved than with AIR.

However, XULRunner has been really branching out to a lot of platform – Windows, Mac OS and Linux support was all there before AIR even came on the scene. There is also SkyOS support, and today the first “pre-alpha” of XULRunner is available for Windows Mobile (codenamed “Fennec”). There are also lightweight ports available for mobile Linux distros, and for Symbian S60.

This really opens a lot of doors for developers – your desktop applications and mobile applications can all share the same codebase. XUL itself is actually quiet nice to write in, and I was always impressed by how it always took advantage of native OS components libraries.

Anyway, I think the XULRunner team deserves very high praise for what they have accomplished – they have always been ahead of the game when with their platform independent runtime, and they are continuing to push support to an impressive array of platforms.

• XULRunner Documentation
• XUL Documentation
• Doug’s announcement of Fennec for Windows Mobile
• Mark’s announcement of XULRunner 1.9.0.6

I have been writing some applications in AIR that for the first time make extensive use of SQLite. I hit a few roadblocks along the way, so here are a few things that may come in handy if you are using SQLite in AIR for the first time.

Reuse SQLStatement Instances

Rather than creating a new SQLStatement object for each query you want to run, it is recommended that you reuse an existing instance, and just alter the parameters associated with the object. You will reap three benefits from doing this:

• The query will be cached, so the SQLite connection will not have to compile a new statement every time you want to run the query
• You will get automatic type conversion when assigning values like strings, integers, dates and so on
• You will improve data integrity within the database because as the automatic type conversion also acts as a kind of filter

For queries that get used across an entire application, I have found that putting the SQLConnection object and wrapper functions for the SQLStatement objects inside a singleton class seems to work very well.

NOTE: Every time you change the text property, the query will get recompiled. The trick is in using the parameters.

The following example demonstrates this:

package
{
	import flash.data.SQLConnection;
	import flash.data.SQLStatement;

	public class SQLConnectionWrapper
	{
		private static const SINGLETON_INSTANCE:SQLConnectionWrapper = new SQLConnectionWrapper(SingletonLock);

		public var connection:SQLConnection;

		private var selectRecord:SQLStatement;

		public static function get instance():SQLConnectionWrapper
		{
			return SINGLETON_INSTANCE;
		}

		public function SQLConnectionWrapper(lock:Class)
		{
			// This ensures that only once instance of this class may be created and accessed
			if(lock != SingletonLock){
				throw new Error("Class Cannot Be Instantiated: Use SQLConnectionWrapper.instance");
			}

			createDatabase();
		}

		private function createDatabase():void
		{
			// This creates an SQLConnection object , which can be accessed publicly so that event listeners can be defined for it
			connection = new SQLConnection();

			var databaseFile:File = File.applicationStorageDirectory.resolvePath("database.db");
			connection.openAsync(databaseFile);
		}

		public function getRecord(recordId:int):SQLStatement
		{
			// If selectRecord has not been instantiated, then create the instance with all the data that it needs
			// If it has been instantiated, then we can skip over this part and take advantage of the fact that it has now been cached
			if(!(selectRecord is SQLStatement)){
				selectRecord= new SQLStatement();
				selectRecord.sqlConnection = connection;
				selectRecord.text =
				"SELECT record_id, description, is_active " +
				"FROM record_tbl " +
				"WHERE record_id = :recordId";
			}
			// This simply changes the one parameter that needs to be changed
			// Because recordId has already been declared as an int, this will be converted into an SQLite recognized integer
			selectRecord.parameters[":recordId"] = recordId;

			return selectRecord;
		}
	}
}

// This little class exists to stop extra instances on the singleton being created
class SingletonLock{}

Use Responders

One major problem that caught me off guard when trying to reuse instances was event handling. If I were to use SQLConnectionWrapper.instance.getRecord() in multiple places across my application, and attach event listeners to them, I will encounter a problem where all three event listeners get triggered. Even when each event listener is removed, errors still occur due to the fact that the SQLStatement object still thinks that it is executing. Not pretty.

Using Responder objects allows to avoid the pain that come s from constantly adding and removing event listeners, and prevent the race condition that occurs with the SQLStatement objects. The Responder object allows you to define event handlers for both SQLEvent.RESULT and SQLErrorEvent.ERROR events. And rather than attaching itself to the SQLStatement object, it will only handle events generated for each particular call to SQLStatement.execute().

NOTE: After a successful query, the handler will be passed an SQLResult object as the first argument, and not an SQLEvent object.

NOTE: After a failed query, the handler will be passed an SQLError object as the first argument, and not an SQLErrorEvent object.

Here is an example:

package
{
	import SQLConnectionWrapper;

	import flash.net.Responder;
	import flash.data.SQLResult;

	public class SampleApplication
	{
		// Create the responder object once, so that it can be reused again and again
		private var responder:Responder = new Responder(handleSuccess, handleFailure);

		public function SampleApplication():void
		{
			// This opens the database - obviously
			SQLConnectionWrapper.instance.connection.addEventListener(SQLEvent.OPEN, executeQuery);
			SQLConnectionWrapper.instance.connection.open();
		}

		private function executeQuery():void
		{
			// This statement essentially creates a reference to the SQLStatement object that is created once for all time within the SQLConnectionWrapper singleton
			var statement:SQLStatement = SQLConnectionWrapper.instance.getRecord(1);
			statement.execute(-1, responder);
		}

		private function handleSuccess(result:SQLResult):void
		{
			trace("Record ID: " + result.data[0].record_id + ", Description: " + result.data[0].description + ", Is Active: " + result.data[0].is_active);
		}

		private function handleFailure(error:SQLError):void
		{
			trace("Epic Fail: " + error.message);
		}
	}
}

Boolean Objects

When returning results from a SELECT query, any SQLite Boolean objects will be correctly converted into ActionScript Boolean objects. However, when executing an INSERT or UPDATE query, an integer is actually required. This quick and nasty workaround demonstrates what has to take place:

This would need to be part of SQLConnectionWrapper

		private function setRecord(description:String, isActive:Boolean):void
		{
			if(!(insertRecord is SQLStatement)){
				insertRecord = new SQLStatement();
				insertRecord.sqlConnection = connection;
				insertRecord.text = "INSERT INTO record_tbl (description, is_active) VALUES (:description, :isActive)";
			}
			insertRecord.parameters[":description"] = description;
			// This is pretty straightforward, but it simply converts the ActionScript Boolean into an int, so that SQLite can accurately create it's own boolean in the database
			insertRecord.parameters[":isActive"] = isActive ? 1 : 0;

			return insertRecord;
		}

Date Objects

When executing an INSERT or UPDATE query, dates will be inserted into the database as expected (well, kind of – if you really want to know more about that then just ask about it). In the case of Date objects, though, the troubles occur when trying to return Date objects from a SELECT query. I won’t try and explain this one, because there is already a great explanation of what is happening here.

What I will do is provide some code that demonstrates the quickest way of getting a usable Date object from an SQLite database:

NOTE: The String object that gets returned is formatted so that it can be passed to the constructor of a Date object without having to jump through any additional hoops.

This would need to be part of SQLConnectionWrapper

		public function getAllBookings():SQLStatement
		{
			if(!(selectBookings is SQLStatement)){
				selectBookings = new SQLStatement();
				selectBookings.sqlConnection = connection;
				// This statement will return the date as a MM/DD/YYYY formatted string
				selectBookings.text =
				"SELECT booking_id, record_id, STRFTIME('%m/%d/%Y', checkout_date) AS checkout_date, STRFTIME('%m/%d/%Y', checkin_date) AS checkin_date " +
				"FROM booking_tbl";
			}

			return selectBookings;
		}

UPDATE: Paul Robertson has posted an update about this. Apparently setting the column type to DATE, rather than DATETIME, will allow you to use Flex Date objects natively. You can see this alluded to in the LiveDocs.

Blobs and Bitmaps

Do you want to store images in your database? Do you want to pull them out as DisplayObjects, ready to do with as you wish? Well, here is some code that demonstrates the entire process of loading an image from a file, storing it in your SQLite database, retrieving the image data, and converting it back into a DisplayObject:

NOTE: ByteArray objects do not need any special attention when being either SELECTed from or INSERTed into the database.

This would need to be part of the application code

		import flash.display.Bitmap;
		import flash.display.Loader;
		import flash.filesystem.File;
		import flash.net.URLLoader;
		import flash.utils.ByteArray;
		import mx.graphics.codec.PNGEncoder;

		private function selectPicture():void
		{
			// This little section here creates a file object, and then launches the file browser so that you can select your image
			var file:File = File.documentsDirectory;
			file.addEventListener(Event.SELECT, handleSelectPicture);
			file.browseForOpen("Select Picture");
		}

		private function handleSelectPicture(event:Event):void
		{
			// Once the image file has been selected, we now have to load it
			var loader:Loader = new Loader();
			loader.contentLoaderInfo.addEventListener(Event.COMPLETE, handleLoadPicture);
			loader.load(new URLRequest(event.target.url));
		}

		private function handleLoadPicture(event:Event):void
		{
			// The first thing that we do is create a Loader object (which is a subclass od DisplayObject)
			var loader:Loader = Loader(event.target.loader);
			// Next, we cast the loader as a Bitmpa object, as the Bitmap object has function to return a BitmapData object based on the image
			var image:Bitmap = Bitmap(loader.content);
			var encoder:PNGEncoder = new PNGEncoder();
			// The PNGEncoder allows you to convert BitmapData object into a ByteArray, ready for storage in an SQLite blob field
			var byteArray:ByteArray = encoder.encode(image.bitmapData);

			var statement:SQLStatement = SQLConnectionWrapper.instance.setPicture(1, byteArray);
			statement.execute(-1, responder);
		}

This would need to be part of SQLConnectionWrapper

		private function setPicture(recordId:String, byteArray:ByteArray):void
		{
			if(!(insertRecord is SQLStatement)){
				insertRecord = new SQLStatement();
				insertRecord.sqlConnection = connection;
				insertRecord.text = "INSERT INTO picture_tbl (record_id, data) VALUES (:recordId, :byteArray)";
			}
			insertRecord.parameters[":recordId"] = recordId;
			// The ByteArray should be added as a parameter; this makes the whole process of storing the image in the blob field very easy
			insertRecord.parameters[":byteArray"] = byteArray;

			return insertRecord;
		}

This would need to be part of the application code

		import mx.controls.Image;

		// This function would be defined in a Responder object that handles a successful query of picture_tbl
		private function handleSuccess(result:SQLResult):void
		{
			var image:Image = new Image();
			image.addEventListener(Event.COMPLETE, handleLoadPicture);
			image.load(result.data[0].picture);
		}

		private function handleLoadPicture(event:Event):void
		{
			var picture:DisplayObject = DisplayObject(event.target.content);
		}

Sorry, I was started to get a bit tired of writing towards the end of this article If you want me to elaborate on anything, just leave a comment. Hopefully the examples are enough to get you up and running with SQLite, whilst avoiding most of the gotchas that come along with it

Now that the new stable is available for download, I would imagine that a new release build isn’t too far off…

You can download the latest version of the SDK here: http://opensource.adobe.com/wiki/display/flexsdk/Download+Flex+3

From what I can tell, it mostly comprises of bug fixes – no fancy new functionality seems to have been added. But I guess you will have to find out for yourself by trawling through the nightly release notes (joy :S)… If you find anything noteworthy, let me know, I only noticed a few changes in some of the utility classes.

• There is a cool writeup about Konductor on O’Reilly’s InsideRIA blog (Even though it reads a bit like a blogvertisement in parts, it is very thorough)

• There a bunch of new videos about Konductor on our Youtube channel – if you want visual and aural updates of Konductor’s progress, then subscribe
• This one has been blogged to death already, but I am loving Big Spaceship’s Pretty Loaded – I hope they can keep adding new content

It has been a little barren on the blog lately, but I have a few posts I really want to write up about some really cool stuff we are doing with Dreamweaver extension development, so subscribe to the RSS feed and keep your eye open for it if you are into that kind of thing.

Also, FYI, if you are subscribed using RSS, the feed URL has been changed to http://feeds.feedburner.com/andrewodri. All of your orignal feed links should now be redirecting, however.

Also, I am on an Adobe Developer Connection video. I am the guy who say profound things like “awesome” and “Flash Catalyst”:

http://ca.youtube.com/watch?v=a0qMe7Z3EYg&fmt=18