diff --git a/airtime_mvc/application/controllers/LibraryController.php b/airtime_mvc/application/controllers/LibraryController.php
index 606e1606f..acbba568d 100644
--- a/airtime_mvc/application/controllers/LibraryController.php
+++ b/airtime_mvc/application/controllers/LibraryController.php
@@ -33,12 +33,15 @@ class LibraryController extends Zend_Controller_Action
         $this->view->headScript()->appendFile($baseUrl.'/js/datatables/plugin/dataTables.pluginAPI.js','text/javascript');
         $this->view->headScript()->appendFile($baseUrl.'/js/datatables/plugin/dataTables.fnSetFilteringDelay.js','text/javascript');
         $this->view->headScript()->appendFile($baseUrl.'/js/datatables/plugin/dataTables.ColVis.js','text/javascript');
+        $this->view->headScript()->appendFile($baseUrl.'/js/datatables/plugin/dataTables.ColReorder.js','text/javascript');
+        $this->view->headScript()->appendFile($baseUrl.'/js/datatables/plugin/dataTables.FixedColumns.js','text/javascript');
         $this->view->headScript()->appendFile($baseUrl.'/js/airtime/library/library.js','text/javascript');
         $this->view->headScript()->appendFile($baseUrl.'/js/airtime/library/advancedsearch.js','text/javascript');
 
         $this->view->headLink()->appendStylesheet($baseUrl.'/css/media_library.css');
         $this->view->headLink()->appendStylesheet($baseUrl.'/css/contextmenu.css');
         $this->view->headLink()->appendStylesheet($baseUrl.'/css/datatables/css/ColVis.css');
+        $this->view->headLink()->appendStylesheet($baseUrl.'/css/datatables/css/ColReorder.css');
 
         $this->_helper->layout->setLayout('library');
         $this->_helper->viewRenderer->setResponseSegment('library');
diff --git a/airtime_mvc/public/css/datatables/css/ColReorder.css b/airtime_mvc/public/css/datatables/css/ColReorder.css
new file mode 100644
index 000000000..6bb55e22c
--- /dev/null
+++ b/airtime_mvc/public/css/datatables/css/ColReorder.css
@@ -0,0 +1,14 @@
+/*
+ * Namespace DTCR - "DataTables ColReorder" plug-in
+ */
+
+table.DTCR_clonedTable {
+	background-color: white;
+	z-index: 998;
+}
+
+div.DTCR_pointer {
+	width: 1px;
+	background-color: #5B5B5B;
+	z-index: 997;
+}
\ No newline at end of file
diff --git a/airtime_mvc/public/css/styles.css b/airtime_mvc/public/css/styles.css
index 6bf53511c..e2acc5daa 100644
--- a/airtime_mvc/public/css/styles.css
+++ b/airtime_mvc/public/css/styles.css
@@ -622,10 +622,22 @@ dl.inline-list dd {
     padding: 2px 2px 2px 0;
     vertical-align: top;
 }
+#library_display thead th, #library_display tbody td {
+    cursor: pointer;
+}
+#library_display thead th.library_checkbox,
+#library_display thead th.library_id,
+#library_display thead th.library_title {
+    cursor: default;
+}
 
 .ColVis.TableTools .ui-button {
     height: 21px;
 }
+button.ColVis_Button.ColVis_ShowAll {
+    text-align: center;
+    margin-top: 10px;
+}
 .library_toolbar .ui-button, .ColVis.TableTools .ui-button {
     float: right;
     text-align:center;
diff --git a/airtime_mvc/public/js/airtime/library/library.js b/airtime_mvc/public/js/airtime/library/library.js
index 57d3aea41..0bd77535a 100644
--- a/airtime_mvc/public/js/airtime/library/library.js
+++ b/airtime_mvc/public/js/airtime/library/library.js
@@ -1,5 +1,6 @@
 var dTable;
 var checkedCount = 0;
+var checkedPLCount = 0;
 
 //used by jjmenu
 function getId() {
@@ -319,6 +320,12 @@ function getNumEntriesPreference(data) {
 }
 
 function groupAdd() {
+    if (checkedPLCount > 0) {
+        alert("Can't add playlist to another playlist");
+        return;
+    }
+    disableGroupBtn('library_group_add');
+    
     var ids = new Array();
     var addGroupUrl = '/Playlist/add-group';
     var newSPLUrl = '/Playlist/new/format/json';
@@ -354,6 +361,8 @@ function groupAdd() {
 }
 
 function groupDelete() {
+    disableGroupBtn('library_group_delete');
+    
     var auIds = new Array();
     var plIds = new Array();
     var auUrl = '/Library/delete-group';
@@ -387,10 +396,18 @@ function groupDelete() {
 function toggleAll() {
     var checked = $(this).attr("checked");
     $('#library_display tr').each(function() {
+        var idSplit = $(this).attr('id').split("_");
+        var type = idSplit[0];
         $(this).find(":checkbox").attr("checked", checked);
         if (checked) {
+            if (type == "pl") {
+                checkedPLCount++;
+            }
             $(this).addClass('selected');
         } else {
+            if (type == "pl") {
+                checkedPLCount--;
+            }
             $(this).removeClass('selected');
         }
     });
@@ -401,6 +418,7 @@ function toggleAll() {
         enableGroupBtn('library_group_delete', confirmDeleteGroup);
     } else {
         checkedCount = 0;
+        checkedPLCount = 0;
         disableGroupBtn('library_group_add');
         disableGroupBtn('library_group_delete');
     }
@@ -427,10 +445,15 @@ function checkBoxChanged() {
     var cbAllChecked = cbAll.attr("checked");
     var checked = $(this).attr("checked");
     var size = $('#library_display tbody tr').size();
+    var idSplit = $(this).parent().parent().attr('id').split("_");
+    var type = idSplit[0];
     if (checked) {
        if (checkedCount < size) {
            checkedCount++;
        }
+       if (type == "pl" && checkedPLCount < size) {
+           checkedPLCount++;
+       }
        enableGroupBtn('library_group_add', groupAdd);
        enableGroupBtn('library_group_delete', confirmDeleteGroup);
        $(this).parent().parent().addClass('selected');
@@ -438,6 +461,9 @@ function checkBoxChanged() {
         if (checkedCount > 0) {
             checkedCount--;
         }
+        if (type == "pl" && checkedPLCount > 0) {
+           checkedPLCount--;
+        }
         if (checkedCount == 0) {
             disableGroupBtn('library_group_add');
             disableGroupBtn('library_group_delete');
@@ -491,17 +517,17 @@ function createDataTable(data) {
 		"fnRowCallback": dtRowCallback,
 		"fnDrawCallback": dtDrawCallback,
 		"aoColumns": [
-		    /* Checkbox */  { "sTitle": "<input type='checkbox' name='cb_all'>", "bSortable": false, "bSearchable": false, "mDataProp": "checkbox", "sWidth": "25px", "sClass": "library_checkbox"},
-			/* Id */		{ "sName": "id", "bSearchable": false, "bVisible": false, "mDataProp": "id", "sClass": "library_id"},
-			/* Title */		{ "sTitle": "Title", "sName": "track_title", "mDataProp": "track_title", "sClass": "library_title"},
-			/* Creator */	{ "sTitle": "Creator", "sName": "artist_name", "mDataProp": "artist_name", "sClass": "library_creator"},
-			/* Album */		 { "sTitle": "Album", "sName": "album_title", "mDataProp": "album_title", "sClass": "library_album"},
-			/* Genre */		{ "sTitle": "Genre", "sName": "genre", "mDataProp": "genre", "sWidth": "10%", "sClass": "library_genre"},
-			/* Year */	{ "sTitle": "Year", "sName": "year", "mDataProp": "year", "sWidth": "8%", "sClass": "library_year"},
-			/* Length */	{ "sTitle": "Length", "sName": "length", "mDataProp": "length", "sWidth": "16%", "sClass": "library_length"},
-                        /* Type */		{ "sTitle": "Type", "sName": "ftype", "bSearchable": false, "mDataProp": "ftype", "sWidth": "9%", "sClass": "library_type"},
-                        /* Upload Time */	{ "sTitle": "Upload Time", "sName": "upload_time", "mDataProp": "upload_time", "sClass": "library_upload_time"},
-		],
+                    /* Checkbox */      {"sTitle": "<input type='checkbox' name='cb_all'>", "bSortable": false, "bSearchable": false, "mDataProp": "checkbox", "sWidth": "25px", "sClass": "library_checkbox"},
+                    /* Id */            {"sName": "id", "bSearchable": false, "bVisible": false, "mDataProp": "id", "sClass": "library_id"},
+                    /* Title */         {"sTitle": "Title", "sName": "track_title", "mDataProp": "track_title", "sClass": "library_title"},
+                    /* Creator */       {"sTitle": "Creator", "sName": "artist_name", "mDataProp": "artist_name", "sClass": "library_creator"},
+                    /* Album */         {"sTitle": "Album", "sName": "album_title", "mDataProp": "album_title", "sClass": "library_album"},
+                    /* Genre */         {"sTitle": "Genre", "sName": "genre", "mDataProp": "genre", "sWidth": "10%", "sClass": "library_genre"},
+                    /* Year */          {"sTitle": "Year", "sName": "year", "mDataProp": "year", "sWidth": "8%", "sClass": "library_year"},
+                    /* Length */        {"sTitle": "Length", "sName": "length", "mDataProp": "length", "sWidth": "16%", "sClass": "library_length"},
+                    /* Type */          {"sTitle": "Type", "sName": "ftype", "bSearchable": false, "mDataProp": "ftype", "sWidth": "9%", "sClass": "library_type"},
+                    /* Upload Time */   {"sTitle": "Upload Time", "sName": "upload_time", "mDataProp": "upload_time", "sClass": "library_upload_time"},
+                ],
 		"aaSorting": [[2,'asc']],
 		"sPaginationType": "full_numbers",
 		"bJQueryUI": true,
@@ -511,18 +537,30 @@ function createDataTable(data) {
                 },
                 "iDisplayLength": getNumEntriesPreference(data),
                 "bStateSave": true,
-                "sDom": 'lfr<"H"C<"library_toolbar">>t<"F"ip>',
+                // R = ColReorder, C = ColVis, see datatables doc for others
+                "sDom": 'Rlfr<"H"C<"library_toolbar">>t<"F"ip>',
                 "oColVis": {
-			"sAlign": "right",
-                        "aiExclude": [0, 1, 2],
-                        "sSize": "css"
+                    "buttonText": "Show/Hide Columns",
+                    "sAlign": "right",
+                    "aiExclude": [0, 1, 2],
+                    "sSize": "css",
+                    "bShowAll": true
+		},
+                "oColReorder": {
+                    "aiOrder": [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ] /* code this */,
+                    "iFixedColumns": 3
 		}
     });
     dTable.fnSetFilteringDelay(350);
     
-    
-    $("div.library_toolbar").html('<span class="fg-button ui-button ui-state-default ui-state-disabled" id="library_group_delete">Delete</span>' + 
+    $("div.library_toolbar").html('<span class="fg-button ui-button ui-state-default" id="library_order_reset">Reset Order</span>' + 
+        '<span class="fg-button ui-button ui-state-default ui-state-disabled" id="library_group_delete">Delete</span>' + 
         '<span class="fg-button ui-button ui-state-default ui-state-disabled" id="library_group_add">Add</span>');
+    
+    $('#library_order_reset').click(function() {
+        ColReorder.fnReset( dTable );
+        return false;
+    });
 }
 
 $(document).ready(function() {
diff --git a/airtime_mvc/public/js/datatables/plugin/dataTables.ColReorder.js b/airtime_mvc/public/js/datatables/plugin/dataTables.ColReorder.js
new file mode 100644
index 000000000..95c39fcec
--- /dev/null
+++ b/airtime_mvc/public/js/datatables/plugin/dataTables.ColReorder.js
@@ -0,0 +1,987 @@
+/*
+ * File:        ColReorder.js
+ * Version:     1.0.4
+ * CVS:         $Id$
+ * Description: Controls for column visiblity in DataTables
+ * Author:      Allan Jardine (www.sprymedia.co.uk)
+ * Created:     Wed Sep 15 18:23:29 BST 2010
+ * Modified:    $Date$ by $Author$
+ * Language:    Javascript
+ * License:     GPL v2 or BSD 3 point style
+ * Project:     DataTables
+ * Contact:     www.sprymedia.co.uk/contact
+ * 
+ * Copyright 2010-2011 Allan Jardine, all rights reserved.
+ *
+ * This source file is free software, under either the GPL v2 license or a
+ * BSD style license, available at:
+ *   http://datatables.net/license_gpl2
+ *   http://datatables.net/license_bsd
+ *
+ */
+
+
+(function($, window, document) {
+
+
+/**
+ * Switch the key value pairing of an index array to be value key (i.e. the old value is now the
+ * key). For example consider [ 2, 0, 1 ] this would be returned as [ 1, 2, 0 ].
+ *  @method  fnInvertKeyValues
+ *  @param   array aIn Array to switch around
+ *  @returns array
+ */
+function fnInvertKeyValues( aIn )
+{
+	var aRet=[];
+	for ( var i=0, iLen=aIn.length ; i<iLen ; i++ )
+	{
+		aRet[ aIn[i] ] = i;
+	}
+	return aRet;
+}
+
+
+/**
+ * Modify an array by switching the position of two elements
+ *  @method  fnArraySwitch
+ *  @param   array aArray Array to consider, will be modified by reference (i.e. no return)
+ *  @param   int iFrom From point
+ *  @param   int iTo Insert point
+ *  @returns void
+ */
+function fnArraySwitch( aArray, iFrom, iTo )
+{
+	var mStore = aArray.splice( iFrom, 1 )[0];
+	aArray.splice( iTo, 0, mStore );
+}
+
+
+/**
+ * Switch the positions of nodes in a parent node (note this is specifically designed for 
+ * table rows). Note this function considers all element nodes under the parent!
+ *  @method  fnDomSwitch
+ *  @param   string sTag Tag to consider
+ *  @param   int iFrom Element to move
+ *  @param   int Point to element the element to (before this point), can be null for append
+ *  @returns void
+ */
+function fnDomSwitch( nParent, iFrom, iTo )
+{
+	var anTags = [];
+	for ( var i=0, iLen=nParent.childNodes.length ; i<iLen ; i++ )
+	{
+		if ( nParent.childNodes[i].nodeType == 1 )
+		{
+			anTags.push( nParent.childNodes[i] );
+		}
+	}
+	var nStore = anTags[ iFrom ];
+	
+	if ( iTo !== null )
+	{
+		nParent.insertBefore( nStore, anTags[iTo] );
+	}
+	else
+	{
+		nParent.appendChild( nStore );
+	}
+}
+
+
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * DataTables plug-in API functions
+ *
+ * This are required by ColReorder in order to perform the tasks required, and also keep this
+ * code portable, to be used for other column reordering projects with DataTables, if needed.
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+
+/**
+ * Plug-in for DataTables which will reorder the internal column structure by taking the column
+ * from one position (iFrom) and insert it into a given point (iTo).
+ *  @method  $.fn.dataTableExt.oApi.fnColReorder
+ *  @param   object oSettings DataTables settings object - automatically added by DataTables! 
+ *  @param   int iFrom Take the column to be repositioned from this point
+ *  @param   int iTo and insert it into this point
+ *  @returns void
+ */
+$.fn.dataTableExt.oApi.fnColReorder = function ( oSettings, iFrom, iTo )
+{
+	var i, iLen, j, jLen, iCols=oSettings.aoColumns.length, nTrs, oCol;
+	
+	/* Sanity check in the input */
+	if ( iFrom == iTo )
+	{
+		/* Pointless reorder */
+		return;
+	}
+	
+	if ( iFrom < 0 || iFrom >= iCols )
+	{
+		this.oApi._fnLog( oSettings, 1, "ColReorder 'from' index is out of bounds: "+iFrom );
+		return;
+	}
+	
+	if ( iTo < 0 || iTo >= iCols )
+	{
+		this.oApi._fnLog( oSettings, 1, "ColReorder 'to' index is out of bounds: "+iTo );
+		return;
+	}
+	
+	/*
+	 * Calculate the new column array index, so we have a mapping between the old and new
+	 */
+	var aiMapping = [];
+	for ( i=0, iLen=iCols ; i<iLen ; i++ )
+	{
+		aiMapping[i] = i;
+	}
+	fnArraySwitch( aiMapping, iFrom, iTo );
+	var aiInvertMapping = fnInvertKeyValues( aiMapping );
+	
+	
+	/*
+	 * Convert all internal indexing to the new column order indexes
+	 */
+	/* Sorting */
+	for ( i=0, iLen=oSettings.aaSorting.length ; i<iLen ; i++ )
+	{
+		oSettings.aaSorting[i][0] = aiInvertMapping[ oSettings.aaSorting[i][0] ];
+	}
+	
+	/* Fixed sorting */
+	if ( oSettings.aaSortingFixed !== null )
+	{
+		for ( i=0, iLen=oSettings.aaSortingFixed.length ; i<iLen ; i++ )
+		{
+			oSettings.aaSortingFixed[i][0] = aiInvertMapping[ oSettings.aaSortingFixed[i][0] ];
+		}
+	}
+	
+	/* Data column sorting (the column which the sort for a given column should take place on) */
+	for ( i=0, iLen=iCols ; i<iLen ; i++ )
+	{
+		oSettings.aoColumns[i].iDataSort = aiInvertMapping[ oSettings.aoColumns[i].iDataSort ];
+	}
+	
+	/* Update the Get and Set functions for each column */
+	for ( i=0, iLen=iCols ; i<iLen ; i++ )
+	{
+		oCol = oSettings.aoColumns[i];
+		if ( typeof oCol.mDataProp == 'number' ) {
+			oCol.mDataProp = aiInvertMapping[ oCol.mDataProp ];
+			oCol.fnGetData = oSettings.oApi._fnGetObjectDataFn( oCol.mDataProp );
+			oCol.fnSetData = oSettings.oApi._fnSetObjectDataFn( oCol.mDataProp );
+		}
+	}
+	
+	
+	/*
+	 * Move the DOM elements
+	 */
+	if ( oSettings.aoColumns[iFrom].bVisible )
+	{
+		/* Calculate the current visible index and the point to insert the node before. The insert
+		 * before needs to take into account that there might not be an element to insert before,
+		 * in which case it will be null, and an appendChild should be used
+		 */
+		var iVisibleIndex = this.oApi._fnColumnIndexToVisible( oSettings, iFrom );
+		var iInsertBeforeIndex = null;
+		
+		i = iTo < iFrom ? iTo : iTo + 1;
+		while ( iInsertBeforeIndex === null && i < iCols )
+		{
+			iInsertBeforeIndex = this.oApi._fnColumnIndexToVisible( oSettings, i );
+			i++;
+		}
+		
+		/* Header */
+		nTrs = oSettings.nTHead.getElementsByTagName('tr');
+		for ( i=0, iLen=nTrs.length ; i<iLen ; i++ )
+		{
+			fnDomSwitch( nTrs[i], iVisibleIndex, iInsertBeforeIndex );
+		}
+		
+		/* Footer */
+		if ( oSettings.nTFoot !== null )
+		{
+			nTrs = oSettings.nTFoot.getElementsByTagName('tr');
+			for ( i=0, iLen=nTrs.length ; i<iLen ; i++ )
+			{
+				fnDomSwitch( nTrs[i], iVisibleIndex, iInsertBeforeIndex );
+			}
+		}
+		
+		/* Body */
+		for ( i=0, iLen=oSettings.aoData.length ; i<iLen ; i++ )
+		{
+			if ( oSettings.aoData[i].nTr !== null )
+			{
+				fnDomSwitch( oSettings.aoData[i].nTr, iVisibleIndex, iInsertBeforeIndex );
+			}
+		}
+	}
+	
+	
+	/* 
+	 * Move the internal array elements
+	 */
+	/* Columns */
+	fnArraySwitch( oSettings.aoColumns, iFrom, iTo );
+	
+	/* Search columns */
+	fnArraySwitch( oSettings.aoPreSearchCols, iFrom, iTo );
+	
+	/* Array array - internal data anodes cache */
+	for ( i=0, iLen=oSettings.aoData.length ; i<iLen ; i++ )
+	{
+		if ( $.isArray( oSettings.aoData[i]._aData ) ) {
+		  fnArraySwitch( oSettings.aoData[i]._aData, iFrom, iTo );
+		}
+		fnArraySwitch( oSettings.aoData[i]._anHidden, iFrom, iTo );
+	}
+	
+	/* Reposition the header elements in the header layout array */
+	for ( i=0, iLen=oSettings.aoHeader.length ; i<iLen ; i++ )
+	{
+		fnArraySwitch( oSettings.aoHeader[i], iFrom, iTo );
+	}
+	
+	if ( oSettings.aoFooter !== null )
+	{
+		for ( i=0, iLen=oSettings.aoFooter.length ; i<iLen ; i++ )
+		{
+			fnArraySwitch( oSettings.aoFooter[i], iFrom, iTo );
+		}
+	}
+	
+	
+	/*
+	 * Update DataTables' event handlers
+	 */
+	
+	/* Sort listener */
+	for ( i=0, iLen=iCols ; i<iLen ; i++ )
+	{
+		$(oSettings.aoColumns[i].nTh).unbind('click');
+		this.oApi._fnSortAttachListener( oSettings, oSettings.aoColumns[i].nTh, i );
+	}
+	
+	
+	/*
+	 * Any extra operations for the other plug-ins
+	 */
+	if ( typeof ColVis != 'undefined' )
+	{
+		ColVis.fnRebuild( oSettings.oInstance );
+	}
+	
+	if ( typeof oSettings.oInstance._oPluginFixedHeader != 'undefined' )
+	{
+		oSettings.oInstance._oPluginFixedHeader.fnUpdate();
+	}
+};
+
+
+
+
+/** 
+ * ColReorder provides column visiblity control for DataTables
+ * @class ColReorder
+ * @constructor
+ * @param {object} DataTables object
+ * @param {object} ColReorder options
+ */
+ColReorder = function( oTable, oOpts )
+{
+	/* Santiy check that we are a new instance */
+	if ( !this.CLASS || this.CLASS != "ColReorder" )
+	{
+		alert( "Warning: ColReorder must be initialised with the keyword 'new'" );
+	}
+	
+	if ( typeof oOpts == 'undefined' )
+	{
+		oOpts = {};
+	}
+	
+	
+	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+	 * Public class variables
+	 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+	
+	/**
+	 * @namespace Settings object which contains customisable information for ColReorder instance
+	 */
+	this.s = {
+		/**
+		 * DataTables settings object
+		 *  @property dt
+		 *  @type     Object
+		 *  @default  null
+		 */
+		"dt": null,
+		
+		/**
+		 * Initialisation object used for this instance
+		 *  @property init
+		 *  @type     object
+		 *  @default  {}
+		 */
+		"init": oOpts,
+		
+		/**
+		 * Number of columns to fix (not allow to be reordered)
+		 *  @property fixed
+		 *  @type     int
+		 *  @default  0
+		 */
+		"fixed": 0,
+		
+		/**
+		 * Callback function for once the reorder has been done
+		 *  @property dropcallback
+		 *  @type     function
+		 *  @default  null
+		 */
+		"dropCallback": null,
+		
+		/**
+		 * @namespace Information used for the mouse drag
+		 */
+		"mouse": {
+			"startX": -1,
+			"startY": -1,
+			"offsetX": -1,
+			"offsetY": -1,
+			"target": -1,
+			"targetIndex": -1,
+			"fromIndex": -1
+		},
+		
+		/**
+		 * Information which is used for positioning the insert cusor and knowing where to do the
+		 * insert. Array of objects with the properties:
+		 *   x: x-axis position
+		 *   to: insert point
+		 *  @property aoTargets
+		 *  @type     array
+		 *  @default  []
+		 */
+		"aoTargets": []
+	};
+	
+	
+	/**
+	 * @namespace Common and useful DOM elements for the class instance
+	 */
+	this.dom = {
+		/**
+		 * Dragging element (the one the mouse is moving)
+		 *  @property drag
+		 *  @type     element
+		 *  @default  null
+		 */
+		"drag": null,
+		
+		/**
+		 * The insert cursor
+		 *  @property pointer
+		 *  @type     element
+		 *  @default  null
+		 */
+		"pointer": null
+	};
+	
+	
+	/* Constructor logic */
+	this.s.dt = oTable.fnSettings();
+	this._fnConstruct();
+	
+	/* Store the instance for later use */
+	ColReorder.aoInstances.push( this );
+	return this;
+};
+
+
+
+ColReorder.prototype = {
+	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+	 * Public methods
+	 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+	
+	"fnReset": function ()
+	{
+		var a = [];
+		for ( var i=0, iLen=this.s.dt.aoColumns.length ; i<iLen ; i++ )
+		{
+			a.push( this.s.dt.aoColumns[i]._ColReorder_iOrigCol );
+		}
+		
+		this._fnOrderColumns( a );
+	},
+	
+	
+	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+	 * Private methods (they are of course public in JS, but recommended as private)
+	 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+	
+	/**
+	 * Constructor logic
+	 *  @method  _fnConstruct
+	 *  @returns void
+	 *  @private 
+	 */
+	"_fnConstruct": function ()
+	{
+		var that = this;
+		var i, iLen;
+		
+		/* Columns discounted from reordering - counting left to right */
+		if ( typeof this.s.init.iFixedColumns != 'undefined' )
+		{
+			this.s.fixed = this.s.init.iFixedColumns;
+		}
+		
+		/* Drop callback initialisation option */
+		if ( typeof this.s.init.fnReorderCallback != 'undefined' )
+		{
+			this.s.dropCallback = this.s.init.fnReorderCallback;
+		}
+		
+		/* Add event handlers for the drag and drop, and also mark the original column order */
+		for ( i=0, iLen=this.s.dt.aoColumns.length ; i<iLen ; i++ )
+		{
+			if ( i > this.s.fixed-1 )
+			{
+				this._fnMouseListener( i, this.s.dt.aoColumns[i].nTh );
+			}
+			
+			/* Mark the original column order for later reference */
+			this.s.dt.aoColumns[i]._ColReorder_iOrigCol = i;
+		}
+		
+		/* State saving */
+		this.s.dt.aoStateSave.push( {
+			"fn": function (oS, sVal) {
+				return that._fnStateSave.call( that, sVal );
+			},
+			"sName": "ColReorder_State"
+		} );
+		
+		/* An initial column order has been specified */
+		var aiOrder = null;
+		if ( typeof this.s.init.aiOrder != 'undefined' )
+		{
+			aiOrder = this.s.init.aiOrder.slice();
+		}
+		
+		/* State loading, overrides the column order given */
+		if ( this.s.dt.oLoadedState && typeof this.s.dt.oLoadedState.ColReorder != 'undefined' &&
+		  this.s.dt.oLoadedState.ColReorder.length == this.s.dt.aoColumns.length )
+		{
+			aiOrder = this.s.dt.oLoadedState.ColReorder;
+		}
+		
+		/* If we have an order to apply - do so */
+		if ( aiOrder )
+		{
+			/* We might be called during or after the DataTables initialisation. If before, then we need
+			 * to wait until the draw is done, if after, then do what we need to do right away
+			 */
+			if ( !that.s.dt._bInitComplete )
+			{
+				var bDone = false;
+				this.s.dt.aoDrawCallback.push( {
+					"fn": function () {
+						if ( !that.s.dt._bInitComplete && !bDone )
+						{
+							bDone = true;
+							var resort = fnInvertKeyValues( aiOrder );
+							that._fnOrderColumns.call( that, resort );
+						}
+					},
+					"sName": "ColReorder_Pre"
+				} );
+			}
+			else
+			{
+				var resort = fnInvertKeyValues( aiOrder );
+				that._fnOrderColumns.call( that, resort );
+			}
+		}
+	},
+	
+	
+	/**
+	 * Set the column order from an array
+	 *  @method  _fnOrderColumns
+	 *  @param   array a An array of integers which dictate the column order that should be applied
+	 *  @returns void
+	 *  @private 
+	 */
+	"_fnOrderColumns": function ( a )
+	{
+		if ( a.length != this.s.dt.aoColumns.length )
+		{
+			this.s.dt.oInstance.oApi._fnLog( oDTSettings, 1, "ColReorder - array reorder does not "+
+			 	"match known number of columns. Skipping." );
+			return;
+		}
+		
+		for ( var i=0, iLen=a.length ; i<iLen ; i++ )
+		{
+			var currIndex = $.inArray( i, a );
+			if ( i != currIndex )
+			{
+				/* Reorder our switching array */
+				fnArraySwitch( a, currIndex, i );
+				
+				/* Do the column reorder in the table */
+				this.s.dt.oInstance.fnColReorder( currIndex, i );
+			}
+		}
+		
+		/* When scrolling we need to recalculate the column sizes to allow for the shift */
+		if ( this.s.dt.oScroll.sX !== "" || this.s.dt.oScroll.sY !== "" )
+		{
+			this.s.dt.oInstance.fnAdjustColumnSizing();
+		}
+			
+		/* Save the state */
+		this.s.dt.oInstance.oApi._fnSaveState( this.s.dt );
+	},
+	
+	
+	/**
+	 * This function effectively replaces the state saving function in DataTables (this is needed
+	 * because otherwise DataTables would state save the columns in their reordered state, not the
+	 * original which is needed on first draw). This is sensitive to any changes in the DataTables
+	 * state saving method!
+	 *  @method  _fnStateSave
+	 *  @param   string sCurrentVal 
+	 *  @returns string JSON encoded cookie string for DataTables
+	 *  @private 
+	 */
+	"_fnStateSave": function ( sCurrentVal )
+	{
+		var i, iLen, sTmp;
+		var sValue = sCurrentVal.split('"aaSorting"')[0];
+		var a = [];
+		var oSettings = this.s.dt;
+		
+		/* Sorting */
+		sValue += '"aaSorting":[ ';
+		for ( i=0 ; i<oSettings.aaSorting.length ; i++ )
+		{
+			sValue += '['+oSettings.aoColumns[ oSettings.aaSorting[i][0] ]._ColReorder_iOrigCol+
+				',"'+oSettings.aaSorting[i][1]+'"],';
+		}
+		sValue = sValue.substring(0, sValue.length-1);
+		sValue += "],";
+		
+		/* Column filter */
+		for ( i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ )
+		{
+			a[ oSettings.aoColumns[i]._ColReorder_iOrigCol ] = {
+				"sSearch": encodeURIComponent(oSettings.aoPreSearchCols[i].sSearch),
+				"bRegex": !oSettings.aoPreSearchCols[i].bRegex
+			};
+		}
+		
+		sValue += '"aaSearchCols":[ ';
+		for ( i=0 ; i<a.length ; i++ )
+		{
+			sValue += '["'+a[i].sSearch+'",'+a[i].bRegex+'],';
+		}
+		sValue = sValue.substring(0, sValue.length-1);
+		sValue += "],";
+		
+		/* Visibility */
+		a = [];
+		for ( i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ )
+		{
+			a[ oSettings.aoColumns[i]._ColReorder_iOrigCol ] = oSettings.aoColumns[i].bVisible;
+		}
+		
+		sValue += '"abVisCols":[ ';
+		for ( i=0 ; i<a.length ; i++ )
+		{
+			sValue += a[i]+",";
+		}
+		sValue = sValue.substring(0, sValue.length-1);
+		sValue += "],";
+		
+		/* Column reordering */
+		a = [];
+		for ( i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ ) {
+			a.push( oSettings.aoColumns[i]._ColReorder_iOrigCol );
+		}
+		sValue += '"ColReorder":['+a.join(',')+']';
+		
+		return sValue;
+	},
+	
+	
+	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+	 * Mouse drop and drag
+	 */
+	
+	/**
+	 * Add a mouse down listener to a particluar TH element
+	 *  @method  _fnMouseListener
+	 *  @param   int i Column index
+	 *  @param   element nTh TH element clicked on
+	 *  @returns void
+	 *  @private 
+	 */
+	"_fnMouseListener": function ( i, nTh )
+	{
+		var that = this;
+		$(nTh).bind( 'mousedown.ColReorder', function (e) {
+			that._fnMouseDown.call( that, e, nTh );
+			return false;
+		} );
+	},
+	
+	
+	/**
+	 * Mouse down on a TH element in the table header
+	 *  @method  _fnMouseDown
+	 *  @param   event e Mouse event
+	 *  @param   element nTh TH element to be dragged
+	 *  @returns void
+	 *  @private 
+	 */
+	"_fnMouseDown": function ( e, nTh )
+	{
+		var
+			that = this,
+			aoColumns = this.s.dt.aoColumns;
+		
+		/* Store information about the mouse position */
+		var nThTarget = e.target.nodeName == "TH" ? e.target : $(e.target).parents('TH')[0];
+		var offset = $(nThTarget).offset();
+		this.s.mouse.startX = e.pageX;
+		this.s.mouse.startY = e.pageY;
+		this.s.mouse.offsetX = e.pageX - offset.left;
+		this.s.mouse.offsetY = e.pageY - offset.top;
+		this.s.mouse.target = nTh;
+		this.s.mouse.targetIndex = $('th', nTh.parentNode).index( nTh );
+		this.s.mouse.fromIndex = this.s.dt.oInstance.oApi._fnVisibleToColumnIndex( this.s.dt, 
+			this.s.mouse.targetIndex );
+		
+		/* Calculate a cached array with the points of the column inserts, and the 'to' points */
+		this.s.aoTargets.splice( 0, this.s.aoTargets.length );
+		
+		this.s.aoTargets.push( {
+			"x":  $(this.s.dt.nTable).offset().left,
+			"to": 0
+		} );
+		
+		var iToPoint = 0;
+		for ( var i=0, iLen=aoColumns.length ; i<iLen ; i++ )
+		{
+			/* For the column / header in question, we want it's position to remain the same if the 
+			 * position is just to it's immediate left or right, so we only incremement the counter for
+			 * other columns
+			 */
+			if ( i != this.s.mouse.fromIndex )
+			{
+				iToPoint++;
+			}
+			
+			if ( aoColumns[i].bVisible )
+			{
+				this.s.aoTargets.push( {
+					"x":  $(aoColumns[i].nTh).offset().left + $(aoColumns[i].nTh).outerWidth(),
+					"to": iToPoint
+				} );
+			}
+		}
+		
+		/* Disallow columns for being reordered by drag and drop, counting left to right */
+		if ( this.s.fixed !== 0 )
+		{
+			this.s.aoTargets.splice( 0, this.s.fixed );
+		}
+		
+		/* Add event handlers to the document */
+		$(document).bind( 'mousemove.ColReorder', function (e) {
+			that._fnMouseMove.call( that, e );
+		} );
+		
+		$(document).bind( 'mouseup.ColReorder', function (e) {
+			that._fnMouseUp.call( that, e );
+		} );
+	},
+	
+	
+	/**
+	 * Deal with a mouse move event while dragging a node
+	 *  @method  _fnMouseMove
+	 *  @param   event e Mouse event
+	 *  @returns void
+	 *  @private 
+	 */
+	"_fnMouseMove": function ( e )
+	{
+		var that = this;
+		
+		if ( this.dom.drag === null )
+		{
+			/* Only create the drag element if the mouse has moved a specific distance from the start
+			 * point - this allows the user to make small mouse movements when sorting and not have a
+			 * possibly confusing drag element showing up
+			 */
+			if ( Math.pow(
+				Math.pow(e.pageX - this.s.mouse.startX, 2) + 
+				Math.pow(e.pageY - this.s.mouse.startY, 2), 0.5 ) < 5 )
+			{
+				return;
+			}
+			this._fnCreateDragNode();
+		}
+		
+		/* Position the element - we respect where in the element the click occured */
+		this.dom.drag.style.left = (e.pageX - this.s.mouse.offsetX) + "px";
+		this.dom.drag.style.top = (e.pageY - this.s.mouse.offsetY) + "px";
+		
+		/* Based on the current mouse position, calculate where the insert should go */
+		var bSet = false;
+		for ( var i=1, iLen=this.s.aoTargets.length ; i<iLen ; i++ )
+		{
+			if ( e.pageX < this.s.aoTargets[i-1].x + ((this.s.aoTargets[i].x-this.s.aoTargets[i-1].x)/2) )
+			{
+				this.dom.pointer.style.left = this.s.aoTargets[i-1].x +"px";
+				this.s.mouse.toIndex = this.s.aoTargets[i-1].to;
+				bSet = true;
+				break;
+			}
+		}
+		
+		/* The insert element wasn't positioned in the array (less than operator), so we put it at 
+		 * the end
+		 */
+		if ( !bSet )
+		{
+			this.dom.pointer.style.left = this.s.aoTargets[this.s.aoTargets.length-1].x +"px";
+			this.s.mouse.toIndex = this.s.aoTargets[this.s.aoTargets.length-1].to;
+		}
+	},
+	
+	
+	/**
+	 * Finish off the mouse drag and insert the column where needed
+	 *  @method  _fnMouseUp
+	 *  @param   event e Mouse event
+	 *  @returns void
+	 *  @private 
+	 */
+	"_fnMouseUp": function ( e )
+	{
+		var that = this;
+		
+		$(document).unbind( 'mousemove.ColReorder' );
+		$(document).unbind( 'mouseup.ColReorder' );
+		
+		if ( this.dom.drag !== null )
+		{
+			/* Remove the guide elements */
+			document.body.removeChild( this.dom.drag );
+			document.body.removeChild( this.dom.pointer );
+			this.dom.drag = null;
+			this.dom.pointer = null;
+			
+			/* Actually do the reorder */
+			this.s.dt.oInstance.fnColReorder( this.s.mouse.fromIndex, this.s.mouse.toIndex );
+			
+			/* When scrolling we need to recalculate the column sizes to allow for the shift */
+			if ( this.s.dt.oScroll.sX !== "" || this.s.dt.oScroll.sY !== "" )
+			{
+				this.s.dt.oInstance.fnAdjustColumnSizing();
+			}
+			
+			if ( this.s.dropCallback !== null )
+			{
+				this.s.dropCallback.call( this );
+			}
+			
+			/* Save the state */
+			this.s.dt.oInstance.oApi._fnSaveState( this.s.dt );
+		}
+	},
+	
+	
+	/**
+	 * Copy the TH element that is being drags so the user has the idea that they are actually 
+	 * moving it around the page.
+	 *  @method  _fnCreateDragNode
+	 *  @returns void
+	 *  @private 
+	 */
+	"_fnCreateDragNode": function ()
+	{
+		var that = this;
+		
+		this.dom.drag = $(this.s.dt.nTHead.parentNode).clone(true)[0];
+		this.dom.drag.className += " DTCR_clonedTable";
+		while ( this.dom.drag.getElementsByTagName('caption').length > 0 )
+		{
+			this.dom.drag.removeChild( this.dom.drag.getElementsByTagName('caption')[0] );
+		}
+		while ( this.dom.drag.getElementsByTagName('tbody').length > 0 )
+		{
+			this.dom.drag.removeChild( this.dom.drag.getElementsByTagName('tbody')[0] );
+		}
+		while ( this.dom.drag.getElementsByTagName('tfoot').length > 0 )
+		{
+			this.dom.drag.removeChild( this.dom.drag.getElementsByTagName('tfoot')[0] );
+		}
+		
+		$('thead tr:eq(0)', this.dom.drag).each( function () {
+			$('th:not(:eq('+that.s.mouse.targetIndex+'))', this).remove();
+		} );
+		$('tr', this.dom.drag).height( $('tr:eq(0)', that.s.dt.nTHead).height() );
+		
+		$('thead tr:gt(0)', this.dom.drag).remove();
+		
+		$('thead th:eq(0)', this.dom.drag).each( function (i) {
+			this.style.width = $('th:eq('+that.s.mouse.targetIndex+')', that.s.dt.nTHead).width()+"px";
+		} );
+		
+		this.dom.drag.style.position = "absolute";
+		this.dom.drag.style.top = "0px";
+		this.dom.drag.style.left = "0px";
+		this.dom.drag.style.width = $('th:eq('+that.s.mouse.targetIndex+')', that.s.dt.nTHead).outerWidth()+"px";
+		
+		
+		this.dom.pointer = document.createElement( 'div' );
+		this.dom.pointer.className = "DTCR_pointer";
+		this.dom.pointer.style.position = "absolute";
+		
+		if ( this.s.dt.oScroll.sX === "" && this.s.dt.oScroll.sY === "" )
+		{
+			this.dom.pointer.style.top = $(this.s.dt.nTable).offset().top+"px";
+			this.dom.pointer.style.height = $(this.s.dt.nTable).height()+"px";
+		}
+		else
+		{
+			this.dom.pointer.style.top = $('div.dataTables_scroll', this.s.dt.nTableWrapper).offset().top+"px";
+			this.dom.pointer.style.height = $('div.dataTables_scroll', this.s.dt.nTableWrapper).height()+"px";
+		}
+	
+		document.body.appendChild( this.dom.pointer );
+		document.body.appendChild( this.dom.drag );
+	}
+};
+
+
+
+
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Static parameters
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+/**
+ * Array of all ColReorder instances for later reference
+ *  @property ColReorder.aoInstances
+ *  @type     array
+ *  @default  []
+ *  @static
+ */
+ColReorder.aoInstances = [];
+
+
+
+
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Static functions
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+/**
+ * Reset the column ordering for a DataTables instance
+ *  @method  ColReorder.fnReset
+ *  @param   object oTable DataTables instance to consider
+ *  @returns void
+ *  @static
+ */
+ColReorder.fnReset = function ( oTable )
+{
+	for ( var i=0, iLen=ColReorder.aoInstances.length ; i<iLen ; i++ )
+	{
+		if ( ColReorder.aoInstances[i].s.dt.oInstance == oTable )
+		{
+			ColReorder.aoInstances[i].fnReset();
+		}
+	}
+};
+
+
+
+
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Constants
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+/**
+ * Name of this class
+ *  @constant CLASS
+ *  @type     String
+ *  @default  ColReorder
+ */
+ColReorder.prototype.CLASS = "ColReorder";
+
+
+/**
+ * ColReorder version
+ *  @constant  VERSION
+ *  @type      String
+ *  @default   As code
+ */
+ColReorder.VERSION = "1.0.4";
+ColReorder.prototype.VERSION = ColReorder.VERSION;
+
+
+
+
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Initialisation
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+/*
+ * Register a new feature with DataTables
+ */
+if ( typeof $.fn.dataTable == "function" &&
+     typeof $.fn.dataTableExt.fnVersionCheck == "function" &&
+     $.fn.dataTableExt.fnVersionCheck('1.8.0') )
+{
+	$.fn.dataTableExt.aoFeatures.push( {
+		"fnInit": function( oDTSettings ) {
+			var oTable = oDTSettings.oInstance;
+			if ( typeof oTable._oPluginColReorder == 'undefined' ) {
+				var opts = typeof oDTSettings.oInit.oColReorder != 'undefined' ? 
+					oDTSettings.oInit.oColReorder : {};
+				oTable._oPluginColReorder = new ColReorder( oDTSettings.oInstance, opts );
+			} else {
+				oTable.oApi._fnLog( oDTSettings, 1, "ColReorder attempted to initialise twice. Ignoring second" );
+			}
+			
+			return null; /* No node to insert */
+		},
+		"cFeature": "R",
+		"sFeature": "ColReorder"
+	} );
+}
+else
+{
+	alert( "Warning: ColReorder requires DataTables 1.8.0 or greater - www.datatables.net/download");
+}
+
+})(jQuery, window, document);
\ No newline at end of file
diff --git a/airtime_mvc/public/js/datatables/plugin/dataTables.FixedColumns.js b/airtime_mvc/public/js/datatables/plugin/dataTables.FixedColumns.js
new file mode 100644
index 000000000..7b9298f73
--- /dev/null
+++ b/airtime_mvc/public/js/datatables/plugin/dataTables.FixedColumns.js
@@ -0,0 +1,1185 @@
+/**
+ * @summary     FixedColumns
+ * @description Freeze columns in place on a scrolling DataTable
+ * @file        FixedColumns.js
+ * @version     2.0.1
+ * @author      Allan Jardine (www.sprymedia.co.uk)
+ * @license     GPL v2 or BSD 3 point style
+ * @contact     www.sprymedia.co.uk/contact
+ *
+ * @copyright Copyright 2010-2011 Allan Jardine, all rights reserved.
+ *
+ * This source file is free software, under either the GPL v2 license or a
+ * BSD style license, available at:
+ *   http://datatables.net/license_gpl2
+ *   http://datatables.net/license_bsd
+ */
+
+
+/* Global scope for FixedColumns */
+var FixedColumns;
+
+(function($, window, document) {
+
+
+/** 
+ * When making use of DataTables' x-axis scrolling feature, you may wish to 
+ * fix the left most column in place. This plug-in for DataTables provides 
+ * exactly this option (note for non-scrolling tables, please use the  
+ * FixedHeader plug-in, which can fix headers, footers and columns). Key 
+ * features include:
+ *   <ul class="limit_length">
+ *     <li>Freezes the left or right most columns to the side of the table</li>
+ *     <li>Option to freeze two or more columns</li>
+ *     <li>Full integration with DataTables' scrolling options</li>
+ *     <li>Speed - FixedColumns is fast in its operation</li>
+ *   </ul>
+ *
+ *  @class
+ *  @constructor
+ *  @param {object} oDT DataTables instance
+ *  @param {object} [oInit={}] Configuration object for FixedColumns. Options are defined by {@link FixedColumns.defaults}
+ * 
+ *  @requires jQuery 1.3+
+ *  @requires DataTables 1.8.0.dev+
+ * 
+ *  @example
+ *  	var oTable = $('#example').dataTable( {
+ *  		"sScrollX": "100%"
+ *  	} );
+ *  	new FixedColumns( oTable );
+ */
+FixedColumns = function ( oDT, oInit ) {
+	/* Sanity check - you just know it will happen */
+	if ( ! this instanceof FixedColumns )
+	{
+		alert( "FixedColumns warning: FixedColumns must be initialised with the 'new' keyword." );
+		return;
+	}
+	
+	if ( typeof oInit == 'undefined' )
+	{
+		oInit = {};
+	}
+	
+	/**
+	 * Settings object which contains customisable information for FixedColumns instance
+	 * @namespace
+	 * @extends FixedColumns.defaults
+	 */
+	this.s = {
+		/** 
+		 * DataTables settings objects
+		 *  @type     object
+		 *  @default  Obtained from DataTables instance
+		 */
+		"dt": oDT.fnSettings(),
+		
+		/** 
+		 * Number of columns in the DataTable - stored for quick access
+		 *  @type     int
+		 *  @default  Obtained from DataTables instance
+		 */
+		"iTableColumns": oDT.fnSettings().aoColumns.length,
+		
+		/** 
+		 * Original widths of the columns as rendered by DataTables
+		 *  @type     array.<int>
+		 *  @default  []
+		 */
+		"aiWidths": [],
+		
+		/** 
+		 * Flag to indicate if we are dealing with IE6/7 as these browsers need a little hack
+		 * in the odd place
+		 *  @type     boolean
+		 *  @default  Automatically calculated
+		 *  @readonly
+		 */
+		"bOldIE": ($.browser.msie && ($.browser.version == "6.0" || $.browser.version == "7.0"))
+	};
+	
+	
+	/**
+	 * DOM elements used by the class instance
+	 * @namespace
+	 * 
+	 */
+	this.dom = {
+		/**
+		 * DataTables scrolling element
+		 *  @type     node
+		 *  @default  null
+		 */
+		"scroller": null,
+		
+		/**
+		 * DataTables header table
+		 *  @type     node
+		 *  @default  null
+		 */
+		"header": null,
+		
+		/**
+		 * DataTables body table
+		 *  @type     node
+		 *  @default  null
+		 */
+		"body": null,
+		
+		/**
+		 * DataTables footer table
+		 *  @type     node
+		 *  @default  null
+		 */
+		"footer": null,
+
+		/**
+		 * Display grid elements
+		 * @namespace
+		 */
+		"grid": {
+			/**
+			 * Grid wrapper. This is the container element for the 3x3 grid
+			 *  @type     node
+			 *  @default  null
+			 */
+			"wrapper": null,
+
+			/**
+			 * DataTables scrolling element. This element is the DataTables
+			 * component in the display grid (making up the main table - i.e.
+			 * not the fixed columns).
+			 *  @type     node
+			 *  @default  null
+			 */
+			"dt": null,
+
+			/**
+			 * Left fixed column grid components
+			 * @namespace
+			 */
+			"left": {
+				"wrapper": null,
+				"head": null,
+				"body": null,
+				"foot": null
+			},
+
+			/**
+			 * Right fixed column grid components
+			 * @namespace
+			 */
+			"right": {
+				"wrapper": null,
+				"head": null,
+				"body": null,
+				"foot": null
+			}
+		},
+		
+		/**
+		 * Cloned table nodes
+		 * @namespace
+		 */
+		"clone": {
+			/**
+			 * Left column cloned table nodes
+			 * @namespace
+			 */
+			"left": {
+				/**
+				 * Cloned header table
+				 *  @type     node
+				 *  @default  null
+				 */
+				"header": null,
+		  	
+				/**
+				 * Cloned body table
+				 *  @type     node
+				 *  @default  null
+				 */
+				"body": null,
+		  	
+				/**
+				 * Cloned footer table
+				 *  @type     node
+				 *  @default  null
+				 */
+				"footer": null
+			},
+			
+			/**
+			 * Right column cloned table nodes
+			 * @namespace
+			 */
+			"right": {
+				/**
+				 * Cloned header table
+				 *  @type     node
+				 *  @default  null
+				 */
+				"header": null,
+		  	
+				/**
+				 * Cloned body table
+				 *  @type     node
+				 *  @default  null
+				 */
+				"body": null,
+		  	
+				/**
+				 * Cloned footer table
+				 *  @type     node
+				 *  @default  null
+				 */
+				"footer": null
+			}
+		}
+	};
+
+	/* Attach the instance to the DataTables instance so it can be accessed easily */
+	this.s.dt.oFixedColumns = this;
+	
+	/* Let's do it */
+	this._fnConstruct( oInit );
+};
+
+
+
+FixedColumns.prototype = {
+	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+	 * Public methods
+	 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+	
+	/**
+	 * Update the fixed columns - including headers and footers. Note that FixedColumns will
+	 * automatically update the display whenever the host DataTable redraws.
+	 *  @returns {void}
+	 *  @example
+	 *  	var oTable = $('#example').dataTable( {
+	 *  		"sScrollX": "100%"
+	 *  	} );
+	 *  	var oFC = new FixedColumns( oTable );
+	 *  	
+	 *  	// at some later point when the table has been manipulated....
+	 *  	oFC.fnUpdate();
+	 */
+	"fnUpdate": function ()
+	{
+		this._fnDraw( true );
+	},
+	
+	
+	/**
+	 * Recalculate the resizes of the 3x3 grid that FixedColumns uses for display of the table.
+	 * This is useful if you update the width of the table container. Note that FixedColumns will
+	 * perform this function automatically when the window.resize event is fired.
+	 *  @returns {void}
+	 *  @example
+	 *  	var oTable = $('#example').dataTable( {
+	 *  		"sScrollX": "100%"
+	 *  	} );
+	 *  	var oFC = new FixedColumns( oTable );
+	 *  	
+	 *  	// Resize the table container and then have FixedColumns adjust its layout....
+	 *      $('#content').width( 1200 );
+	 *  	oFC.fnRedrawLayout();
+	 */
+	"fnRedrawLayout": function ()
+	{
+		this.__fnGridLayout();
+	},
+	
+	
+	/**
+	 * Mark a row such that it's height should be recalculated when using 'semiauto' row
+	 * height matching. This function will have no effect when 'none' or 'auto' row height
+	 * matching is used.
+	 *  @param   {Node} nTr TR element that should have it's height recalculated
+	 *  @returns {void}
+	 *  @example
+	 *  	var oTable = $('#example').dataTable( {
+	 *  		"sScrollX": "100%"
+	 *  	} );
+	 *  	var oFC = new FixedColumns( oTable );
+	 *  	
+	 *  	// manipulate the table - mark the row as needing an update then update the table
+	 *  	// this allows the redraw performed by DataTables fnUpdate to recalculate the row
+	 *  	// height
+	 *  	oFC.fnRecalculateHeight();
+	 *  	oTable.fnUpdate( $('#example tbody tr:eq(0)')[0], ["insert date", 1, 2, 3 ... ]);
+	 */
+	"fnRecalculateHeight": function ( nTr )
+	{
+		nTr._DTTC_iHeight = null;
+		nTr.style.height = 'auto';
+	},
+	
+	
+	/**
+	 * Set the height of a given row - provides cross browser compatibility
+	 *  @param   {Node} nTarget TR element that should have it's height recalculated
+	 *  @param   {int} iHeight Height in pixels to set
+	 *  @returns {void}
+	 *  @example
+	 *  	var oTable = $('#example').dataTable( {
+	 *  		"sScrollX": "100%"
+	 *  	} );
+	 *  	var oFC = new FixedColumns( oTable );
+	 *  	
+	 *  	// You may want to do this after manipulating a row in the fixed column
+	 *  	oFC.fnSetRowHeight( $('#example tbody tr:eq(0)')[0], 50 );
+	 */
+	"fnSetRowHeight": function ( nTarget, iHeight )
+	{
+		var jqBoxHack = $(nTarget).children(':first');
+		var iBoxHack = jqBoxHack.outerHeight() - jqBoxHack.height();
+
+		/* Can we use some kind of object detection here?! This is very nasty - damn browsers */
+		if ( $.browser.mozilla || $.browser.opera )
+		{
+			nTarget.style.height = iHeight+"px";
+		}
+		else
+		{
+			$(nTarget).children().height( iHeight-iBoxHack );
+		}
+	},
+	
+	
+	
+	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+	 * Private methods (they are of course public in JS, but recommended as private)
+	 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+	
+	/**
+	 * Initialisation for FixedColumns
+	 *  @param   {Object} oInit User settings for initialisation
+	 *  @returns {void}
+	 *  @private
+	 */
+	"_fnConstruct": function ( oInit )
+	{
+		var i, iLen, iWidth,
+			that = this;
+		
+		/* Sanity checking */
+		if ( typeof this.s.dt.oInstance.fnVersionCheck != 'function' ||
+		     this.s.dt.oInstance.fnVersionCheck( '1.8.0' ) !== true )
+		{
+			alert( "FixedColumns "+FixedColumns.VERSION+" required DataTables 1.8.0 or later. "+
+				"Please upgrade your DataTables installation" );
+			return;
+		}
+		
+		if ( this.s.dt.oScroll.sX === "" )
+		{
+			this.s.dt.oInstance.oApi._fnLog( this.s.dt, 1, "FixedColumns is not needed (no "+
+				"x-scrolling in DataTables enabled), so no action will be taken. Use 'FixedHeader' for "+
+				"column fixing when scrolling is not enabled" );
+			return;
+		}
+		
+		/* Apply the settings from the user / defaults */
+		this.s = $.extend( true, this.s, FixedColumns.defaults, oInit );
+
+		/* Set up the DOM as we need it and cache nodes */
+		this.dom.grid.dt = $(this.s.dt.nTable).parents('div.dataTables_scroll')[0];
+		this.dom.scroller = $('div.dataTables_scrollBody', this.dom.grid.dt )[0];
+
+		var iScrollWidth = $(this.dom.grid.dt).width();
+		var iLeftWidth = 0;
+		var iRightWidth = 0;
+
+		$('tbody>tr:eq(0)>td', this.s.dt.nTable).each( function (i) {
+			iWidth = $(this).outerWidth();
+			that.s.aiWidths.push( iWidth );
+			if ( i < that.s.iLeftColumns )
+			{
+				iLeftWidth += iWidth;
+			}
+			if ( that.s.iTableColumns-that.s.iRightColumns <= i )
+			{
+				iRightWidth += iWidth;
+			}
+		} );
+
+		if ( this.s.iLeftWidth === null )
+		{
+			this.s.iLeftWidth = this.s.sLeftWidth == 'fixed' ?
+				iLeftWidth : (iLeftWidth/iScrollWidth) * 100; 
+		}
+		
+		if ( this.s.iRightWidth === null )
+		{
+			this.s.iRightWidth = this.s.sRightWidth == 'fixed' ?
+				iRightWidth : (iRightWidth/iScrollWidth) * 100;
+		}
+		
+		/* Set up the DOM that we want for the fixed column layout grid */
+		this._fnGridSetup();
+
+		/* Use the DataTables API method fnSetColumnVis to hide the columns we are going to fix */
+		for ( i=0 ; i<this.s.iLeftColumns ; i++ )
+		{
+			this.s.dt.oInstance.fnSetColumnVis( i, false );
+		}
+		for ( i=this.s.iTableColumns - this.s.iRightColumns ; i<this.s.iTableColumns ; i++ )
+		{
+			this.s.dt.oInstance.fnSetColumnVis( i, false );
+		}
+
+		/* Event handlers */
+		$(this.dom.scroller).scroll( function () {
+			that.dom.grid.left.body.scrollTop = that.dom.scroller.scrollTop;
+			if ( that.s.iRightColumns > 0 )
+			{
+				that.dom.grid.right.body.scrollTop = that.dom.scroller.scrollTop;
+			}
+		} );
+
+		$(window).resize( function () {
+			that._fnGridLayout.call( that );
+		} );
+		
+		var bFirstDraw = true;
+		this.s.dt.aoDrawCallback = [ {
+			"fn": function () {
+				that._fnDraw.call( that, bFirstDraw );
+				that._fnGridHeight( that );
+				bFirstDraw = false;
+			},
+			"sName": "FixedColumns"
+		} ].concat( this.s.dt.aoDrawCallback );
+		
+		/* Get things right to start with - note that due to adjusting the columns, there must be
+		 * another redraw of the main table. It doesn't need to be a full redraw however.
+		 */
+		this._fnGridLayout();
+		this._fnGridHeight();
+		this.s.dt.oInstance.fnDraw(false);
+	},
+	
+	
+	/**
+	 * Set up the DOM for the fixed column. The way the layout works is to create a 1x3 grid
+	 * for the left column, the DataTable (for which we just reuse the scrolling element DataTable
+	 * puts into the DOM) and the right column. In each of he two fixed column elements there is a
+	 * grouping wrapper element and then a head, body and footer wrapper. In each of these we then
+	 * place the cloned header, body or footer tables. This effectively gives as 3x3 grid structure.
+	 *  @returns {void}
+	 *  @private
+	 */
+	"_fnGridSetup": function ()
+	{
+		var that = this;
+
+		this.dom.body = this.s.dt.nTable;
+		this.dom.header = this.s.dt.nTHead.parentNode;
+		this.dom.header.parentNode.parentNode.style.position = "relative";
+		
+		var nSWrapper = 
+			$('<div class="DTFC_ScrollWrapper" style="position:relative; clear:both;">'+
+				'<div class="DTFC_LeftWrapper" style="position:absolute; top:0; left:0;">'+
+					'<div class="DTFC_LeftHeadWrapper" style="position:relative; top:0; left:0; overflow:hidden;"></div>'+
+					'<div class="DTFC_LeftBodyWrapper" style="position:relative; top:0; left:0; overflow:hidden;"></div>'+
+					'<div class="DTFC_LeftFootWrapper" style="position:relative; top:0; left:0; overflow:hidden;"></div>'+
+			  	'</div>'+
+				'<div class="DTFC_RightWrapper" style="position:absolute; top:0; left:0;">'+
+					'<div class="DTFC_RightHeadWrapper" style="position:relative; top:0; left:0; overflow:hidden;"></div>'+
+					'<div class="DTFC_RightBodyWrapper" style="position:relative; top:0; left:0; overflow:hidden;"></div>'+
+					'<div class="DTFC_RightFootWrapper" style="position:relative; top:0; left:0; overflow:hidden;"></div>'+
+			  	'</div>'+
+			  '</div>')[0];
+		nLeft = nSWrapper.childNodes[0];
+		nRight = nSWrapper.childNodes[1];
+
+		this.dom.grid.wrapper = nSWrapper;
+		this.dom.grid.left.wrapper = nLeft;
+		this.dom.grid.left.head = nLeft.childNodes[0];
+		this.dom.grid.left.body = nLeft.childNodes[1];
+
+		if ( this.s.iRightColumns > 0 )
+		{
+			this.dom.grid.right.wrapper = nRight;
+			this.dom.grid.right.head = nRight.childNodes[0];
+			this.dom.grid.right.body = nRight.childNodes[1];
+		}
+		
+		if ( this.s.dt.nTFoot )
+		{
+			this.dom.footer = this.s.dt.nTFoot.parentNode;
+			this.dom.grid.left.foot = nLeft.childNodes[2];
+			if ( this.s.iRightColumns > 0 )
+			{
+				this.dom.grid.right.foot = nRight.childNodes[2];
+			}
+		}
+
+		nSWrapper.appendChild( nLeft );
+		this.dom.grid.dt.parentNode.insertBefore( nSWrapper, this.dom.grid.dt );
+		nSWrapper.appendChild( this.dom.grid.dt );
+
+		this.dom.grid.dt.style.position = "absolute";
+		this.dom.grid.dt.style.top = "0px";
+		this.dom.grid.dt.style.left = this.s.iLeftWidth+"px";
+		this.dom.grid.dt.style.width = ($(this.dom.grid.dt).width()-this.s.iLeftWidth-this.s.iRightWidth)+"px";
+	},
+	
+	
+	/**
+	 * Style and position the grid used for the FixedColumns layout based on the instance settings.
+	 * Specifically sLeftWidth ('fixed' or 'absolute'), iLeftWidth (px if fixed, % if absolute) and
+	 * there 'right' counterparts.
+	 *  @returns {void}
+	 *  @private
+	 */
+	"_fnGridLayout": function ()
+	{
+		var oGrid = this.dom.grid;
+		var iTotal = $(oGrid.wrapper).width();
+		var iLeft = 0, iRight = 0, iRemainder = 0;
+
+		if ( this.s.sLeftWidth == 'fixed' )
+		{
+			iLeft = this.s.iLeftWidth;
+		}
+		else
+		{
+			iLeft = ( this.s.iLeftWidth / 100 ) * iTotal;
+		}
+
+		if ( this.s.sRightWidth == 'fixed' )
+		{
+			iRight = this.s.iRightWidth;
+		}
+		else
+		{
+			iRight = ( this.s.iRightWidth / 100 ) * iTotal;
+		}
+
+		iRemainder = iTotal - iLeft - iRight;
+
+		oGrid.left.wrapper.style.width = iLeft+"px";
+		oGrid.dt.style.width = iRemainder+"px";
+		oGrid.dt.style.left = iLeft+"px";
+
+		if ( this.s.iRightColumns > 0 )
+		{
+			oGrid.right.wrapper.style.width = iRight+"px";
+			oGrid.right.wrapper.style.left = (iTotal-iRight)+"px";
+		}
+	},
+	
+	
+	/**
+	 * Recalculate and set the height of the grid components used for positioning of the 
+	 * FixedColumn display grid.
+	 *  @returns {void}
+	 *  @private
+	 */
+	"_fnGridHeight": function ()
+	{
+		var oGrid = this.dom.grid;
+		var iHeight = $(this.dom.grid.dt).height();
+
+		oGrid.wrapper.style.height = iHeight+"px";
+		oGrid.left.body.style.height = $(this.dom.scroller).height()+"px";
+		oGrid.left.wrapper.style.height = iHeight+"px";
+		
+		if ( this.s.iRightColumns > 0 )
+		{
+			oGrid.right.wrapper.style.height = iHeight+"px";
+			oGrid.right.body.style.height = $(this.dom.scroller).height()+"px";
+		}
+	},
+	
+	
+	/**
+	 * Clone and position the fixed columns
+	 *  @returns {void}
+	 *  @param   {Boolean} bAll Indicate if the header and footer should be updated as well (true)
+	 *  @private
+	 */
+	"_fnDraw": function ( bAll )
+	{
+		this._fnCloneLeft( bAll );
+		this._fnCloneRight( bAll );
+
+		/* Draw callback function */
+		if ( this.s.fnDrawCallback !== null )
+		{
+			this.s.fnDrawCallback.call( this, this.dom.clone.left, this.dom.clone.right );
+		}
+
+		/* Event triggering */
+		$(this).trigger( 'draw', { 
+			"leftClone": this.dom.clone.left,
+			"rightClone": this.dom.clone.right
+		} );
+	},
+	
+	
+	/**
+	 * Clone the right columns
+	 *  @returns {void}
+	 *  @param   {Boolean} bAll Indicate if the header and footer should be updated as well (true)
+	 *  @private
+	 */
+	"_fnCloneRight": function ( bAll )
+	{
+		if ( this.s.iRightColumns <= 0 )
+		{
+			return;
+		}
+		
+		var that = this,
+			i, jq,
+			aiColumns = [];
+
+		for ( i=this.s.iTableColumns-this.s.iRightColumns ; i<this.s.iTableColumns ; i++ )
+		{
+			aiColumns.push( i );
+		}
+
+		this._fnClone( this.dom.clone.right, this.dom.grid.right, aiColumns, bAll );
+	},
+	
+	
+	/**
+	 * Clone the left columns
+	 *  @returns {void}
+	 *  @param   {Boolean} bAll Indicate if the header and footer should be updated as well (true)
+	 *  @private
+	 */
+	"_fnCloneLeft": function ( bAll )
+	{
+		if ( this.s.iLeftColumns <= 0 )
+		{
+			return;
+		}
+		
+		var that = this,
+			i, jq,
+			aiColumns = [];
+		
+		for ( i=0 ; i<this.s.iLeftColumns ; i++ )
+		{
+			aiColumns.push( i );
+		}
+
+		this._fnClone( this.dom.clone.left, this.dom.grid.left, aiColumns, bAll );
+	},
+	
+	
+	/**
+	 * Make a copy of the layout object for a header or footer element from DataTables. Note that
+	 * this method will clone the nodes in the layout object.
+	 *  @returns {Array} Copy of the layout array
+	 *  @param   {Object} aoOriginal Layout array from DataTables (aoHeader or aoFooter)
+	 *  @param   {Object} aiColumns Columns to copy
+	 *  @private
+	 */
+	"_fnCopyLayout": function ( aoOriginal, aiColumns )
+	{
+		var aReturn = [];
+		var aClones = [];
+		var aCloned = [];
+
+		for ( var i=0, iLen=aoOriginal.length ; i<iLen ; i++ )
+		{
+			var aRow = [];
+			aRow.nTr = $(aoOriginal[i].nTr).clone(true)[0];
+
+			for ( var j=0, jLen=this.s.iTableColumns ; j<jLen ; j++ )
+			{
+				if ( $.inArray( j, aiColumns ) === -1 )
+				{
+					continue;
+				}
+
+				var iCloned = $.inArray( aoOriginal[i][j].cell, aCloned );
+				if ( iCloned === -1 )
+				{
+					var nClone = $(aoOriginal[i][j].cell).clone(true)[0];
+					aClones.push( nClone );
+					aCloned.push( aoOriginal[i][j].cell );
+
+					aRow.push( {
+						"cell": nClone,
+						"unique": aoOriginal[i][j].unique
+					} );
+				}
+				else
+				{
+					aRow.push( {
+						"cell": aClones[ iCloned ],
+						"unique": aoOriginal[i][j].unique
+					} );
+				}
+			}
+			
+			aReturn.push( aRow );
+		}
+
+		return aReturn;
+	},
+	
+	
+	/**
+	 * Clone the DataTable nodes and place them in the DOM (sized correctly)
+	 *  @returns {void}
+	 *  @param   {Object} oClone Object containing the header, footer and body cloned DOM elements
+	 *  @param   {Object} oGrid Grid object containing the display grid elements for the cloned 
+	 *                    column (left or right)
+	 *  @param   {Array} aiColumns Column indexes which should be operated on from the DataTable
+	 *  @param   {Boolean} bAll Indicate if the header and footer should be updated as well (true)
+	 *  @private
+	 */
+	"_fnClone": function ( oClone, oGrid, aiColumns, bAll )
+	{
+		var that = this,
+			i, iLen, jq, nTarget, iColumn, nClone, iIndex;
+
+		/* 
+		 * Header
+		 */
+		if ( bAll )
+		{
+			if ( oClone.header !== null )
+			{
+				oClone.header.parentNode.removeChild( oClone.header );
+			}
+			oClone.header = $(this.dom.header).clone(true)[0];
+			oClone.header.className += " DTFC_Cloned";
+			oClone.header.style.width = "100%";
+			oGrid.head.appendChild( oClone.header );
+			
+			/* Copy the DataTables layout cache for the header for our floating column */
+			var aoCloneLayout = this._fnCopyLayout( this.s.dt.aoHeader, aiColumns );
+			var jqCloneThead = $('>thead', oClone.header);
+			jqCloneThead.empty();
+
+			/* Add the created cloned TR elements to the table */
+			for ( i=0, iLen=aoCloneLayout.length ; i<iLen ; i++ )
+			{
+				jqCloneThead[0].appendChild( aoCloneLayout[i].nTr );
+			}
+
+			/* Use the handy _fnDrawHead function in DataTables to do the rowspan/colspan
+			 * calculations for us
+			 */
+			this.s.dt.oApi._fnDrawHead( this.s.dt, aoCloneLayout, true );
+		}
+		else
+		{
+			for ( iIndex=0 ; iIndex<aiColumns.length ; iIndex++ )
+			{
+				$('>thead th:eq('+iIndex+')', oClone.header)[0].className =
+					this.s.dt.aoColumns[ aiColumns[iIndex] ].nTh.className;
+				
+				$('>thead th:eq('+iIndex+') span.DataTables_sort_icon', oClone.header).each( function (i) {
+					this.className = $('span.DataTables_sort_icon', that.s.dt.aoColumns[ aiColumns[iIndex] ].nTh)[i].className;
+				} );
+			}
+		}
+		this._fnEqualiseHeights( 'thead', this.dom.header, oClone.header );
+		
+		/* 
+		 * Body
+		 */
+		if ( this.s.sHeightMatch == 'auto' )
+		{
+			/* Remove any heights which have been applied already and let the browser figure it out */
+			$('>tbody>tr', that.dom.body).css('height', 'auto');
+		}
+		
+		if ( oClone.body !== null )
+		{
+			oClone.body.parentNode.removeChild( oClone.body );
+			oClone.body = null;
+		}
+		
+		oClone.body = $(this.dom.body).clone(true)[0];
+		oClone.body.className += " DTFC_Cloned";
+		oClone.body.style.paddingBottom = this.s.dt.oScroll.iBarWidth+"px";
+		oClone.body.style.marginBottom = (this.s.dt.oScroll.iBarWidth*2)+"px"; /* For IE */
+		if ( oClone.body.getAttribute('id') !== null )
+		{
+			oClone.body.removeAttribute('id');
+		}
+		
+		$('>thead>tr', oClone.body).empty();
+		$('>tfoot', oClone.body).empty();
+		
+		var nBody = $('tbody', oClone.body)[0];
+		$(nBody).empty();
+		if ( this.s.dt.aiDisplay.length > 0 )
+		{
+			$('>tbody>tr', that.dom.body).each( function (z) {
+				var n = this.cloneNode(false);
+				var i = that.s.dt.oFeatures.bServerSide===false ?
+					that.s.dt.aiDisplay[ that.s.dt._iDisplayStart+z ] : z;
+				for ( iIndex=0 ; iIndex<aiColumns.length ; iIndex++ )
+				{
+					iColumn = aiColumns[iIndex];
+					if ( typeof that.s.dt.aoData[i]._anHidden[iColumn] != 'undefined' )
+					{
+						nClone = $(that.s.dt.aoData[i]._anHidden[iColumn]).clone(true)[0];
+						nClone.style.width = that.s.aiWidths[iColumn]+"px";
+						n.appendChild( nClone );
+					}
+				}
+				nBody.appendChild( n );
+			} );
+		}
+		else
+		{
+			$('>tbody>tr', that.dom.body).each( function (z) {
+				nClone = this.cloneNode(true);
+				nClone.className += ' DTFC_NoData';
+				$('td', nClone).html('');
+				nBody.appendChild( nClone );
+			} );
+		}
+		
+		oClone.body.style.width = "100%";
+		oGrid.body.appendChild( oClone.body );
+
+		this._fnEqualiseHeights( 'tbody', that.dom.body, oClone.body );
+		
+		/*
+		 * Footer
+		 */
+		if ( this.s.dt.nTFoot !== null )
+		{
+			if ( bAll )
+			{
+				if ( oClone.footer !== null )
+				{
+					oClone.footer.parentNode.removeChild( oClone.footer );
+				}
+				oClone.footer = $(this.dom.footer).clone(true)[0];
+				oClone.footer.className += " DTFC_Cloned";
+				oClone.footer.style.width = "100%";
+				oGrid.foot.appendChild( oClone.footer );
+
+				/* Copy the footer just like we do for the header */
+				var aoCloneLayout = this._fnCopyLayout( this.s.dt.aoFooter, aiColumns );
+				var jqCloneTfoot = $('>tfoot', oClone.footer);
+				jqCloneTfoot.empty();
+	
+				for ( i=0, iLen=aoCloneLayout.length ; i<iLen ; i++ )
+				{
+					jqCloneTfoot[0].appendChild( aoCloneLayout[i].nTr );
+				}
+				this.s.dt.oApi._fnDrawHead( this.s.dt, aoCloneLayout, true );
+			}
+			else
+			{
+				for ( iIndex=0 ; iIndex<aiColumns.length ; iIndex++ )
+				{
+					$('>tfoot th:eq('+iIndex+')', oClone.footer)[0].className =
+						this.s.dt.aoColumns[ aiColumns[iIndex] ].nTf.className;
+				}
+			}
+			this._fnEqualiseHeights( 'tfoot', this.dom.footer, oClone.footer );
+		}
+
+		/* Equalise the column widths between the header footer and body - body get's priority */
+		var jqBody = $('>tbody>tr:eq(0)', oClone.body);
+		var jqHead = $('>thead>tr:eq(0)', oClone.header);
+		if ( this.s.dt.nTFoot !== null )
+		{
+			var jqFoot = $('>tfoot>tr:eq(0)', oClone.footer);
+		}
+
+		jqBody.children().each( function (i) {
+			var iWidth = $(this).width();
+
+			jqHead.children(':eq('+i+')').width( iWidth );
+			if ( that.s.dt.nTFoot !== null )
+			{
+				jqFoot.children(':eq('+i+')').width( iWidth );
+			}
+		} );
+	},
+	
+	
+	/**
+	 * From a given table node (THEAD etc), get a list of TR direct child elements
+	 *  @param   {Node} nIn Table element to search for TR elements (THEAD, TBODY or TFOOT element)
+	 *  @returns {Array} List of TR elements found
+	 *  @private
+	 */
+	"_fnGetTrNodes": function ( nIn )
+	{
+		var aOut = [];
+		for ( var i=0, iLen=nIn.childNodes.length ; i<iLen ; i++ )
+		{
+			if ( nIn.childNodes[i].nodeName.toUpperCase() == "TR" )
+			{
+				aOut.push( nIn.childNodes[i] );
+			}
+		}
+		return aOut;
+	},
+
+	
+	/**
+	 * Equalise the heights of the rows in a given table node in a cross browser way
+	 *  @returns {void}
+	 *  @param   {String} nodeName Node type - thead, tbody or tfoot
+	 *  @param   {Node} original Original node to take the heights from
+	 *  @param   {Node} clone Copy the heights to
+	 *  @private
+	 */
+	"_fnEqualiseHeights": function ( nodeName, original, clone )
+	{
+		if ( this.s.sHeightMatch == 'none' )
+		{
+			return;
+		}
+		
+		var that = this,
+			i, iLen, iHeight, iHeight2, iHeightOriginal, iHeightClone,
+			rootOriginal = original.getElementsByTagName(nodeName)[0],
+			rootClone    = clone.getElementsByTagName(nodeName)[0],
+			jqBoxHack    = $('>'+nodeName+'>tr:eq(0)', original).children(':first'),
+			iBoxHack     = jqBoxHack.outerHeight() - jqBoxHack.height(),
+			anOriginal   = this._fnGetTrNodes( rootOriginal ),
+		 	anClone      = this._fnGetTrNodes( rootClone );
+		
+		for ( i=0, iLen=anClone.length ; i<iLen ; i++ )
+		{
+			if ( this.s.sHeightMatch == 'semiauto' && typeof anOriginal[i]._DTTC_iHeight != 'undefined' && 
+				anOriginal[i]._DTTC_iHeight !== null )
+			{
+				/* Oddly enough, IE / Chrome seem not to copy the style height - Mozilla and Opera keep it */
+				if ( $.browser.msie )
+				{
+					$(anClone[i]).children().height( anOriginal[i]._DTTC_iHeight-iBoxHack );
+				}
+				continue;
+			}
+			
+			iHeightOriginal = anOriginal[i].offsetHeight;
+			iHeightClone = anClone[i].offsetHeight;
+			iHeight = iHeightClone > iHeightOriginal ? iHeightClone : iHeightOriginal;
+			
+			if ( this.s.sHeightMatch == 'semiauto' )
+			{
+				anOriginal[i]._DTTC_iHeight = iHeight;
+			}
+			
+			/* Can we use some kind of object detection here?! This is very nasty - damn browsers */
+			if ( $.browser.msie )
+			{
+				$(anClone[i]).children().height( iHeight-iBoxHack );
+				$(anOriginal[i]).children().height( iHeight-iBoxHack );	
+			}
+			else
+			{
+				anClone[i].style.height = iHeight+"px";
+				anOriginal[i].style.height = iHeight+"px";
+			}
+		}
+	}
+};
+
+
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Statics
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+
+/**
+ * FixedColumns default settings for initialisation
+ *  @namespace
+ *  @static
+ */
+FixedColumns.defaults = {
+	/** 
+	 * Number of left hand columns to fix in position
+	 *  @type     int
+	 *  @default  1
+	 *  @static
+	 *  @example
+	 *  	var oTable = $('#example').dataTable( {
+	 *  		"sScrollX": "100%"
+	 *  	} );
+	 *  	new FixedColumns( oTable, {
+	 *  		"iLeftColumns": 2
+	 *  	} );
+	 */
+	"iLeftColumns": 1,
+	
+	/** 
+	 * Number of right hand columns to fix in position
+	 *  @type     int
+	 *  @default  0
+	 *  @static
+	 *  @example
+	 *  	var oTable = $('#example').dataTable( {
+	 *  		"sScrollX": "100%"
+	 *  	} );
+	 *  	new FixedColumns( oTable, {
+	 *  		"iRightColumns": 1
+	 *  	} );
+	 */
+	"iRightColumns": 0,
+	
+	/** 
+	 * Draw callback function which is called when FixedColumns has redrawn the fixed assets
+	 *  @type     function(object, object):void
+	 *  @default  null
+	 *  @static
+	 *  @example
+	 *  	var oTable = $('#example').dataTable( {
+	 *  		"sScrollX": "100%"
+	 *  	} );
+	 *  	new FixedColumns( oTable, {
+	 *  		"fnDrawCallback": function () {
+	 *				alert( "FixedColumns redraw" );
+	 *			}
+	 *  	} );
+	 */
+	"fnDrawCallback": null,
+	
+	/** 
+	 * Type of left column size calculation. Can take the values of "fixed", whereby the iLeftWidth
+	 * value will be treated as a pixel value, or "relative" for which case iLeftWidth will be
+	 * treated as a percentage value.
+	 *  @type     string
+	 *  @default  fixed
+	 *  @static
+	 *  @example
+	 *  	var oTable = $('#example').dataTable( {
+	 *  		"sScrollX": "100%"
+	 *  	} );
+	 *  	new FixedColumns( oTable, {
+	 *  		"sLeftWidth": "relative",
+	 *  		"iLeftWidth": 10 // percentage
+	 *  	} );
+	 */
+	"sLeftWidth": "fixed",
+	
+	/** 
+	 * Width to set for the width of the left fixed column(s) - note that the behaviour of this
+	 * property is directly effected by the sLeftWidth property. If not defined then this property
+	 * is calculated automatically from what has been assigned by DataTables.
+	 *  @type     int
+	 *  @default  null
+	 *  @static
+	 *  @example
+	 *  	var oTable = $('#example').dataTable( {
+	 *  		"sScrollX": "100%"
+	 *  	} );
+	 *  	new FixedColumns( oTable, {
+	 *  		"iLeftWidth": 100 // pixels
+	 *  	} );
+	 */
+	"iLeftWidth": null,
+	
+	/** 
+	 * Type of right column size calculation. Can take the values of "fixed", whereby the 
+	 * iRightWidth value will be treated as a pixel value, or "relative" for which case 
+	 * iRightWidth will be treated as a percentage value.
+	 *  @type     string
+	 *  @default  fixed
+	 *  @static
+	 *  @example
+	 *  	var oTable = $('#example').dataTable( {
+	 *  		"sScrollX": "100%"
+	 *  	} );
+	 *  	new FixedColumns( oTable, {
+	 *  		"sRightWidth": "relative",
+	 *  		"iRightWidth": 10 // percentage
+	 *  	} );
+	 */
+	"sRightWidth": "fixed",
+	
+	/**
+	 * Width to set for the width of the right fixed column(s) - note that the behaviour of this
+	 * property is directly effected by the sRightWidth property. If not defined then this property
+	 * is calculated automatically from what has been assigned by DataTables.
+	 *  @type     int
+	 *  @default  null
+	 *  @static
+	 *  @example
+	 *  	var oTable = $('#example').dataTable( {
+	 *  		"sScrollX": "100%"
+	 *  	} );
+	 *  	new FixedColumns( oTable, {
+	 *  		"iRightWidth": 200 // pixels
+	 *  	} );
+	 */
+	"iRightWidth": null,
+	
+	/** 
+	 * Height matching algorthim to use. This can be "none" which will result in no height
+	 * matching being applied by FixedColumns (height matching could be forced by CSS in this
+	 * case), "semiauto" whereby the height calculation will be performed once, and the result
+	 * cached to be used again (fnRecalculateHeight can be used to force recalculation), or
+	 * "auto" when height matching is performed on every draw (slowest but must accurate)
+	 *  @type     string
+	 *  @default  semiauto
+	 *  @static
+	 *  @example
+	 *  	var oTable = $('#example').dataTable( {
+	 *  		"sScrollX": "100%"
+	 *  	} );
+	 *  	new FixedColumns( oTable, {
+	 *  		"sHeightMatch": "auto"
+	 *  	} );
+	 */
+	"sHeightMatch": "semiauto"
+};
+
+
+
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Constants
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+
+/**
+ * Name of this class
+ *  @constant CLASS
+ *  @type     String
+ *  @default  FixedColumns
+ */
+FixedColumns.prototype.CLASS = "FixedColumns";
+
+
+/**
+ * FixedColumns version
+ *  @constant  FixedColumns.VERSION
+ *  @type      String
+ *  @default   See code
+ *  @static
+ */
+FixedColumns.VERSION = "2.0.1";
+
+
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Fired events (for documentation)
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+
+/**
+ * Event fired whenever FixedColumns redraws the fixed columns (i.e. clones the table elements from the main DataTable). This will occur whenever the DataTable that the FixedColumns instance is attached does its own draw.
+ * @name FixedColumns#draw
+ * @event
+ * @param {event} e jQuery event object
+ * @param {object} o Event parameters from FixedColumns
+ * @param {object} o.leftClone Instance's object dom.clone.left for easy reference. This object contains references to the left fixed clumn column's nodes
+ * @param {object} o.rightClone Instance's object dom.clone.right for easy reference. This object contains references to the right fixed clumn column's nodes
+ */
+
+})(jQuery, window, document);