//////////////////////////////////////////////////////////////////////////////
function OnInit(initData) {
	initData.name = "Column.Folder: MusicFolder";
	initData.desc = "Columns for music folders (coverart dimension/playtime etc.)";
	initData.copyright = "tbone";
	initData.min_version = "11.5.5";
	initData.version = "0.1";
	initData.default_enable = true;


	var col;
	col = initData.AddColumn();
	col.name = "MusicFolder.Playtime";
	col.label = "Playtime";
	col.method = "Column_Playtime_Discs_Sampler_Artist_Album_Year_Genre";
	col.multicol = true;
	col.autogroup = true;
	col.autorefresh = true;
	col.justify = "right";

	var col;
	col = initData.AddColumn();
	col.name = "MusicFolder.Discs";
	col.label = "Discs";
	col.method = "Column_Playtime_Discs_Sampler_Artist_Album_Year_Genre";
	col.multicol = true;
	col.autogroup = true;
	col.autorefresh = true;
	col.justify = "right";

	var col;
	col = initData.AddColumn();
	col.name = "MusicFolder.Sampler";
	col.label = "Sampler";
	col.method = "Column_Playtime_Discs_Sampler_Artist_Album_Year_Genre";
	col.multicol = true;
	col.autogroup = true;
	col.autorefresh = true;
	col.justify = "right";

	var col;
	col = initData.AddColumn();
	col.name = "MusicFolder.Artist";
	col.label = "Artist";
	col.method = "Column_Playtime_Discs_Sampler_Artist_Album_Year_Genre";
	col.multicol = true;
	col.autogroup = true;
	col.autorefresh = true;
	col.justify = "left";

	var col;
	col = initData.AddColumn();
	col.name = "MusicFolder.Album";
	col.label = "Album";
	col.method = "Column_Playtime_Discs_Sampler_Artist_Album_Year_Genre";
	col.multicol = true;
	col.autogroup = true;
	col.autorefresh = true;
	col.justify = "left";

	var col;
	col = initData.AddColumn();
	col.name = "MusicFolder.Year";
	col.label = "Year";
	col.method = "Column_Playtime_Discs_Sampler_Artist_Album_Year_Genre";
	col.multicol = true;
	col.autogroup = true;
	col.autorefresh = true;
	col.justify = "right";

	var col;
	col = initData.AddColumn();
	col.name = "MusicFolder.Genre";
	col.label = "Genre";
	col.method = "Column_Playtime_Discs_Sampler_Artist_Album_Year_Genre";
	col.multicol = true;
	col.autogroup = true;
	col.autorefresh = true;
	col.justify = "left";

	var col;
	col = initData.AddColumn();
	col.name = "MusicFolder.CoverDimensions.do";
	col.method = "Column_CoverArt_DO";
	col.label = "Cover WxH (do)";
	col.autogroup = true;
	col.autorefresh = true;
	col.justify = "right";

	var col;
	col = initData.AddColumn();
	col.name = "MusicFolder.CoverDimensions.js";
	col.method = "Column_CoverArt_JS";
	col.label = "Cover WxH (js)";
	col.autogroup = true;
	col.autorefresh = true;
	col.justify = "right";

	initData.config.CoverArtImages = DOpus.NewVector('folder.jpg', 'cover.jpg', 'coverart.jpg');
}
//////////////////////////////////////////////////////////////////////////////
function Column_Playtime_Discs_Sampler_Artist_Album_Year_Genre(data) {
	if(!data.item.is_dir){
		data.value="";
		return false;
	}

	var itemsEnum = ReadFolder(data.item.realpath, true, false);
	if (!itemsEnum) return;

	var fileCount = 0;
	var discCount = 0;
	var songLengthTotal = 0;
	var isSampler = false;
	var artistNames = { tagName:"mp3artist", store:new Array(), storeIndexed:new Array(), countDistinct:0 ,topKey:""};
	var albumNames = { tagName:"mp3album", store:new Array(), storeIndexed:new Array(), countDistinct:0 ,topKey:""};
	var yearEntries = { tagName:"mp3year", store:new Array(), storeIndexed:new Array(), countDistinct:0 ,topKey:""};
	var genreEntries = { tagName:"mp3genre", store:new Array(), storeIndexed:new Array(), countDistinct:0 ,topKey:""};

	while(!itemsEnum.Complete){
		var item = itemsEnum.Next();
		///////////////////////////////////////////////////////////////////////
		if(item.is_dir){
			var discNumberMatch = new String(item.name).match(/(\d+|I)/);
			if(discNumberMatch)
				discCount++;
			continue;
		}
		///////////////////////////////////////////////////////////////////////
		var audio = item.metadata.audio;
		var ext = item.ext.toLowerCase();
		if (ext!=".mp3" && ext!=".wma") continue;
		//DOpus.Output("Sfx-Item: " + item.name);
		fileCount++;
		///////////////////////////////////////////////////////////////////////
		if (audio.mp3songlength)
			songLengthTotal += audio.mp3songlength;
		///////////////////////////////////////////////////////////////////////
		CollectDistinctTagData(audio, artistNames);
		CollectDistinctTagData(audio, albumNames);
		CollectDistinctTagData(audio, yearEntries);
		CollectDistinctTagData(audio, genreEntries);
 	}
	//////////////////////////////////////////////////////////////////////////
	data.columns("MusicFolder.Playtime").value = SecondsToTime(songLengthTotal, 'hh:mm:ss'); //'d:hh:mm:ss'
	data.columns("MusicFolder.Playtime").sort = songLengthTotal;
	//////////////////////////////////////////////////////////////////////////
	data.columns("MusicFolder.Discs").value = ( discCount==0 ? 1 : discCount);
	//////////////////////////////////////////////////////////////////////////
	if ((artistNames.countDistinct/fileCount) > 0.25)
		isSampler = true;
	data.columns("MusicFolder.Sampler").value = ( isSampler ? "Sampler" : "");
	//////////////////////////////////////////////////////////////////////////
	if (isSampler)
		data.columns("MusicFolder.Artist").value = artistNames.storeIndexed.join(", ");
	else
		data.columns("MusicFolder.Artist").value = artistNames.topKey;
	//////////////////////////////////////////////////////////////////////////
	data.columns("MusicFolder.Album").value = albumNames.topKey;
	data.columns("MusicFolder.Year").value = yearEntries.topKey;
	data.columns("MusicFolder.Genre").value = genreEntries.topKey;
}

//////////////////////////////////////////////////////////////////////////////
function CollectTagData_Unused( audio, tagObj){
	//DOpus.Output("    Collect():");
	//DOpus.Output("        tagName : " + tagObj.tagName);
	//DOpus.Output("        tagValue: " + audio[tagObj.tagName]);
	var tagValue = audio[tagObj.tagName];
	if (tagValue && tagValue!="" && !tagObj.store[tagValue]){
		tagObj.store[tagObj.store.length] = tagValue;
	}
}
//////////////////////////////////////////////////////////////////////////////
function CollectDistinctTagData( audio, tagObj){
	//DOpus.Output("    CollectDistinct():");
	//DOpus.Output("        tagName : " + tagObj.tagName);
	//DOpus.Output("        tagValue: " + audio[tagObj.tagName]);

	var tagValue = audio[tagObj.tagName];

	if (!tagObj.store[tagValue]){
		tagObj.store[tagValue] = 1;
		tagObj.storeIndexed[tagObj.storeIndexed.length] = tagValue;
		tagObj.countDistinct++;
	} else {
		tagObj.store[tagValue]++;
		if (tagObj.topKey=="")
			tagObj.topKey = tagValue;
		else {
			if (tagObj.store[tagValue] > tagObj.store[tagObj.topKey]){
				tagObj.topKey = tagValue;
			}
		}
	}
}
//////////////////////////////////////////////////////////////////////////////
function SecondsToTime( s, f) { // seconds, format
	var d = h = m = 0;
	switch (true) {
	case (s > 86400):
		d = Math.floor(s / 86400);
		s %= 86400;
	case (s > 3600):
		h = Math.floor(s / 3600);
		s %= 3600;
	case (s > 60):
		m = Math.floor(s / 60);
		s %= 60;
	}
	if (f != null) {
		var f = f.replace('dd', (d < 10) ? "0" + d : d);
		f = f.replace('d', d);
		f = f.replace('hh', (h < 10) ? "0" + h : h);
		f = f.replace('h', h);
		f = f.replace('mm', (m < 10) ? "0" + m : m);
		f = f.replace('m', m);
		f = f.replace('ss', (s < 10) ? "0" + s : s);
		f = f.replace('s', s);
	} else {
		f = d + ':' + h + ':' + m + ':' + s;
	}
	return f; // :) omg...
}
//////////////////////////////////////////////////////////////////////////////
function Column_CoverArt_DO(data) {
	return Column_CoverArt( data, "DO");
}
//////////////////////////////////////////////////////////////////////////////
function Column_CoverArt_JS(data) {
	return Column_CoverArt( data, "JS");
}
//////////////////////////////////////////////////////////////////////////////
function Column_CoverArt(data, how) {
	var dims = null;
	if (!data.item.is_dir){
		var coverFile = ""+data.item.realpath;
	} else {
		var coverFile = GetCoverFilepath(data.item, Script.config.CoverArtImages);
	}

	if (!coverFile){
		data.value = ""; return false;
	}

	if (how=="DO") data.value = GetCoverDimensions_DO(coverFile);
	if (how=="JS") data.value = GetCoverDimensions_JS(coverFile);
	data.sort = data.value;
	return true;
}
//////////////////////////////////////////////////////////////////////////////
function GetCoverFilepath(folderItem, imageNames) {
	for (var i=0;i<imageNames.count;i++) {
		var imageFullname = folderItem.realpath+"\\"+imageNames(i);
		if (DOpus.FSUtil.Exists(imageFullname))
			return imageFullname;
	}
	return null;
}
///////////////////////////////////////////////////////////////////////////////
function ReadFolder( path, recurse, exception){
	if (recurse == undefined) recurse=false;
	if (exception == undefined) exception=true;
	var fEnum = DOpus.FSUtil.ReadDir( path, recurse);
	if (fEnum.error==0 || fEnum.error==18 )// 18 = empty folder
		return fEnum;
	var error = "ReadFolder(): Error reading folder ["+path+"], code ["+fEnum.error+"].";
	DOpus.Output(error);
	if (exception) throw error;
	return null;
}
//////////////////////////////////////////////////////////////////////////////
function GetCoverDimensions_DO(coverFile){
	var coverExtension = coverFile.split(".").pop();
	if (".gif.jpg.png.bmp".indexOf(coverExtension.toLowerCase())==-1){
		return "";
	}
	var coverItem = DOpus.FSUtil.GetItem(coverFile);
	if (!coverItem || coverItem.Metadata!="image"){
		return "";
	}
	return coverItem.Metadata.image.picwidth+" x "+coverItem.Metadata.image.picheight;
}
//////////////////////////////////////////////////////////////////////////////
function GetCoverDimensions_JS(coverFile){
	var coverExtension = coverFile.split(".").pop();
	if (".gif.jpg.png.bmp".indexOf(coverExtension.toLowerCase())==-1){
		return "";
	}

	if(1){
		var file=DOpus.FSUtil.OpenFile(coverFile);
		if (!file) return "";
		var blob=file.Read(file.size);
	} else {
		//var fso = new ActiveXObject("Scripting.FileSystemObject");
		DOpus.Output("Bevor BinaryFile(): ");
		var file = new BinaryFile(coverFile); // = fso.OpenTextFile(coverFile, 1 /* ForReading */);
		DOpus.Output("After BinaryFile(): ");

		if (!file) return "";
		var blob=file.ReadAll();
		DOpus.Output("After ReadAll(): ");
	}

	if (blob){
		var stream = new BlobStream(blob);
		//return "99 x 991";
		var size = ImageSizeStream(stream);
		return size.width+" x "+size.height;
	}
	return "";
}
///////////////////////////////////////////////////////////////////////////////

function MakeLong(lo,hi){
  return (lo|(hi<<16));
}
function MakeWord(lo,hi){
  return (((lo<<16)>>16)|((hi<<16)>>8));
}

function GetByte2(Value,ByteToGet){
  return (Value & (0xFF<<(ByteToGet*8)))>>>(ByteToGet*8);
}

function SwapHiLo(w){
  return MakeWord(GetByte2(w,1),GetByte2(w,0));
}

// Simplifies using a Blob by making it behave more like a file.
var soBeginning=0;
var soCurrent=1;
var soEnd=2;

function BlobStream(blob){
  this.blob=blob;
  this.position=0;
  this.size=0;
  this.type="blob";
  if (this.blob){
	  if (this.blob["size"]!=undefined){
		  this.size=this.blob.size;
	  }
	  if (this.blob.length!=undefined){
		  this.size=this.blob.length;
		  this.type="array";
	  }
	//DOpus.Output("Blobsize: "+this.size);
	//DOpus.Output("Blobtype: "+this.type);
  }
}

BlobStream.prototype.Seek=function(offset,mode){
  switch(mode){
    case soBeginning: {
      this.position=offset;
      return this.position;
    }
    case soCurrent: {
      this.position=this.position+offset;
      return this.position;
    }
    case soEnd:{
      this.position=blob.size-offset;
      return this.position;
    }
    default: return -1;
  }
};

BlobStream.prototype.ReadByte=function(){
  if (this.type=="array")  return this.blob[this.position++];
  if (this.type=="blob")  return this.blob(this.position++);
};

BlobStream.prototype.ReadWord=function(){
  return MakeWord(this.ReadByte(),this.ReadByte());
};

BlobStream.prototype.ReadLong=function(){
  return MakeLong(MakeWord(this.ReadByte(),this.ReadByte()),MakeWord(this.ReadByte(),this.ReadByte()));
};

BlobStream.prototype.ReadBytes=function(numbytes){
  var retval=[];
  for (var i=0;i<numbytes;i++){
    retval[i]=this.ReadByte();
  }
  return retval;
};

BlobStream.prototype.ReadString=function(len){
  var retval="";
  var b,i=0;
  if (len==0) return retval;
  do{
    b=this.ReadByte();
    retval=retval+String.fromCharCode(b);
    i++;
  }while((this.position<this.size)&&(i<len));
  return retval;
};

BlobStream.prototype.CanRead=function(numbytes){
  if ((this.position+numbytes-1)<this.size) return true;
  return false;
};

BlobStream.prototype.WriteByte=function(b){
  this.blob(this.position)=b;
  this.position++;
};

BlobStream.prototype.WriteWord=function(word){
  this.WriteByte(GetByte2(word,0));
  this.WriteByte(GetByte2(word,1));
};

BlobStream.prototype.WriteLong=function(along){
  this.WriteByte(GetByte2(along,0));
  this.WriteByte(GetByte2(along,1));
  this.WriteByte(GetByte2(along,2));
  this.WriteByte(GetByte2(along,3));
};

BlobStream.prototype.WriteString=function(s){
  for (var i=0;i<s.length;i++){
    this.WriteByte(s.charCodeAt(i));
  }
};

BlobStream.prototype.Resize=function(size){
  this.blob.Resize(size);
  this.size=this.blob.size;
};

BlobStream.prototype.ToArray=function(){
  var vbarr=new VBArray(this.blob.ToVBArray());
  if (vbarr){
    return vbarr.toArray();
  }
  return null;
};

function JPGSizeStream(stream){
  if(!stream) return null;
  var iHeight,iWidth,iBitdepth;
  var n,b,w;
  var pos;
  var newpos;
  n=stream.size-8;
  if (n<=0) return null;
  stream.Seek(0,soBeginning);

  if (stream.ReadWord()!=0xD8FF){
    DOpus.Output('Not a valid JPEG file');
    return null;
  }
  b=stream.ReadByte();
  while ((stream.position<n)&&(b==0xff)){
    b=stream.ReadByte();
    switch(b){
      case 0xc0:
      case 0xc1:
      case 0xc2:
      case 0xc3:
      {
        stream.Seek(3,soCurrent);//skip 3 unneeded bytes
        w=stream.ReadWord();
        iHeight=SwapHiLo(w);
        w=stream.ReadWord();
        iWidth=SwapHiLo(w);
        b=stream.ReadByte();
        iBitdepth=b*8;
        return {width:iWidth,height:iHeight,bitdepth:iBitdepth};
      }
      case 0xff: {
        // Not really tested
        DOpus.Output('Was 0xff');
        b=stream.ReadByte();
        break;
      }
      case 0xD0:
      case 0xD1:
      case 0xD2:
      case 0xD3:
      case 0xD4:
      case 0xD5:
      case 0xD6:
      case 0xD7:
      case 0xD8:
      case 0xD9:
      case 0x01:{
        DOpus.Output("D0..D9,01");
        stream.Seek(1,soCurrent);
        b=stream.ReadByte();
        break;
      }
      default:{
        w=stream.ReadWord();
        pos=stream.Seek(SwapHiLo(w) - 2,soCurrent);
        b=stream.ReadByte();
        break;
      }
    }
  }
  return null;
}

function PNGSizeStream(stream){
  var validsig=[137, 80, 78, 71, 13, 10, 26, 10];
  var sb;
  var iWidth,iHeight;
  if(!stream) return null;
  stream.Seek(0,soBeginning);
  for (var i=0;i<validsig.length;i++){
    sb=stream.ReadByte();
    if (validsig[i]!=sb){
      DOpus.Output('Not a valid PNG file');
      return null;
    }
  }
  stream.Seek(18,soBeginning);
  iWidth=SwapHiLo(stream.ReadWord());
  stream.Seek(22,soBeginning);
  iHeight=SwapHiLo(stream.ReadWord());
  return {width:iWidth,height:iHeight};
}

function GIFSizeStream(stream){
  var iWidth,iHeight;
  var bFound;
  var c;
  if(!stream) return null;
  stream.Seek(0, soBeginning);
  var GIFHeader={
    Sig: stream.ReadString(6),
    ScreenWidth: stream.ReadWord(),
    ScreenHeight: stream.ReadWord(),
    Flags: stream.ReadByte(),
    Background: stream.ReadByte(),
    Aspect: stream.ReadByte()
  };

  if (GIFHeader.Sig.substr(0,3)!="GIF"){
    DOpus.Output('Not a valid GIF file');
    return null;
  }

  if ((GIFHeader.Flags & 0x80)>0){
    var x = 3 * (1 << ((GIFHeader.Flags & 7) + 1));
    stream.Seek(x,soBeginning);
  }
  bFound=false;
  while(stream.position<stream.size){
    c=stream.ReadByte();
    switch(c){
      case 0x2c:{
        var ImageBlock={
          Left:stream.ReadWord(),
          Top:stream.ReadWord(),
          Width:stream.ReadWord(),
          Height:stream.ReadWord(),
          Flags:stream.ReadByte()
        };
        iWidth=ImageBlock.Width;
        iHeight=ImageBlock.Height;
        return {width:iWidth,height:iHeight};
      }
      case 0xff:{
        break;
      }
    }
  }
  return null;
}

function BMPSizeStream(stream){
  var iWidth,iHeight;
  var bFound;
  var c;
  if(!stream) return null;
  stream.Seek(0, soBeginning);
  var BitmapFileHeader={
    bfType: stream.ReadWord(),
    bfSize: stream.ReadLong(),
    bfReserved1: stream.ReadWord(),
    bfReserved2: stream.ReadWord(),
    bfOffBits: stream.ReadLong()
  };
  if (BitmapFileHeader.bfType ==0x4D42){
    // Get the size of the header.
    var hdrsize=stream.ReadLong();
    if (hdrsize<40){
      //We have a BITMAPCOREHEADER
      var BitmapCoreHeader={
        bcWidth: stream.ReadWord(),
        bcHeight: stream.ReadWord(),
        bcPlanes: stream.ReadWord(),
        bcBitCount: stream.ReadWord()
      };
      return {width:BitmapCoreHeader.bcWidth,height:BitmapCoreHeader.bcHeight};
    } else{
      //We have a BITMAPINFOHEADER
      var BitmapInfoHeader={
        biWidth: stream.ReadLong(),
        biHeight: stream.ReadLong(),
        biPlanes: stream.ReadWord(),
        biBitCount: stream.ReadWord()
      };
      return {width:BitmapInfoHeader.biWidth,height:BitmapInfoHeader.biHeight};
    }
  } else DOpus.Output('Not a valid BMP file');
  return null;
}

function ImageSizeStream(stream){
  if (!stream) return null;
  stream.Seek(0,soBeginning);
  var sig=stream.ReadWord();
  switch (sig){
    case 0x5089: return PNGSizeStream(stream);
    case 0xD8FF: return JPGSizeStream(stream);
    case 0x4947: return GIFSizeStream(stream);
    case 0x4D42: return BMPSizeStream(stream);
    default: return {width:0,height:0};
  }
}

/** This is a fairly well optimized object which alows
  * access to binary files from JScript on a Windows
  * operating system.
  *
  * A the end of the file is small set of tests to show how it
  * is used.  You will require ADODB 2.5 or higher installed.
  * this will be so on most 2000 machines and all XP or higher
  * machines.
  *
  * CopyRight: Dr Alexander J Turner - all rights reserved.
  * Please feel free to use this code in any way you like
  * as long as you place a reference in the comments that
  * I wrote it.
  */
function BinaryFile(name)
{
    var adTypeBinary = 1
    var adTypeText   = 2
    var adSaveCreateOverWrite = 2
    // The trick - this is the 'old fassioned' not translation page
    // It lest javascript use strings to act like raw octets
    var codePage='437';

    this.path=name;

    var forward  = new Array();
    var backward = new Array();

    // Note - for better performance I should preconvert these hex
    // definitions to decimal - at some point :-) - AJT
    forward['80'] = '00C7';
    forward['81'] = '00FC';
    forward['82'] = '00E9';
    forward['83'] = '00E2';
    forward['84'] = '00E4';
    forward['85'] = '00E0';
    forward['86'] = '00E5';
    forward['87'] = '00E7';
    forward['88'] = '00EA';
    forward['89'] = '00EB';
    forward['8A'] = '00E8';
    forward['8B'] = '00EF';
    forward['8C'] = '00EE';
    forward['8D'] = '00EC';
    forward['8E'] = '00C4';
    forward['8F'] = '00C5';
    forward['90'] = '00C9';
    forward['91'] = '00E6';
    forward['92'] = '00C6';
    forward['93'] = '00F4';
    forward['94'] = '00F6';
    forward['95'] = '00F2';
    forward['96'] = '00FB';
    forward['97'] = '00F9';
    forward['98'] = '00FF';
    forward['99'] = '00D6';
    forward['9A'] = '00DC';
    forward['9B'] = '00A2';
    forward['9C'] = '00A3';
    forward['9D'] = '00A5';
    forward['9E'] = '20A7';
    forward['9F'] = '0192';
    forward['A0'] = '00E1';
    forward['A1'] = '00ED';
    forward['A2'] = '00F3';
    forward['A3'] = '00FA';
    forward['A4'] = '00F1';
    forward['A5'] = '00D1';
    forward['A6'] = '00AA';
    forward['A7'] = '00BA';
    forward['A8'] = '00BF';
    forward['A9'] = '2310';
    forward['AA'] = '00AC';
    forward['AB'] = '00BD';
    forward['AC'] = '00BC';
    forward['AD'] = '00A1';
    forward['AE'] = '00AB';
    forward['AF'] = '00BB';
    forward['B0'] = '2591';
    forward['B1'] = '2592';
    forward['B2'] = '2593';
    forward['B3'] = '2502';
    forward['B4'] = '2524';
    forward['B5'] = '2561';
    forward['B6'] = '2562';
    forward['B7'] = '2556';
    forward['B8'] = '2555';
    forward['B9'] = '2563';
    forward['BA'] = '2551';
    forward['BB'] = '2557';
    forward['BC'] = '255D';
    forward['BD'] = '255C';
    forward['BE'] = '255B';
    forward['BF'] = '2510';
    forward['C0'] = '2514';
    forward['C1'] = '2534';
    forward['C2'] = '252C';
    forward['C3'] = '251C';
    forward['C4'] = '2500';
    forward['C5'] = '253C';
    forward['C6'] = '255E';
    forward['C7'] = '255F';
    forward['C8'] = '255A';
    forward['C9'] = '2554';
    forward['CA'] = '2569';
    forward['CB'] = '2566';
    forward['CC'] = '2560';
    forward['CD'] = '2550';
    forward['CE'] = '256C';
    forward['CF'] = '2567';
    forward['D0'] = '2568';
    forward['D1'] = '2564';
    forward['D2'] = '2565';
    forward['D3'] = '2559';
    forward['D4'] = '2558';
    forward['D5'] = '2552';
    forward['D6'] = '2553';
    forward['D7'] = '256B';
    forward['D8'] = '256A';
    forward['D9'] = '2518';
    forward['DA'] = '250C';
    forward['DB'] = '2588';
    forward['DC'] = '2584';
    forward['DD'] = '258C';
    forward['DE'] = '2590';
    forward['DF'] = '2580';
    forward['E0'] = '03B1';
    forward['E1'] = '00DF';
    forward['E2'] = '0393';
    forward['E3'] = '03C0';
    forward['E4'] = '03A3';
    forward['E5'] = '03C3';
    forward['E6'] = '00B5';
    forward['E7'] = '03C4';
    forward['E8'] = '03A6';
    forward['E9'] = '0398';
    forward['EA'] = '03A9';
    forward['EB'] = '03B4';
    forward['EC'] = '221E';
    forward['ED'] = '03C6';
    forward['EE'] = '03B5';
    forward['EF'] = '2229';
    forward['F0'] = '2261';
    forward['F1'] = '00B1';
    forward['F2'] = '2265';
    forward['F3'] = '2264';
    forward['F4'] = '2320';
    forward['F5'] = '2321';
    forward['F6'] = '00F7';
    forward['F7'] = '2248';
    forward['F8'] = '00B0';
    forward['F9'] = '2219';
    forward['FA'] = '00B7';
    forward['FB'] = '221A';
    forward['FC'] = '207F';
    forward['FD'] = '00B2';
    forward['FE'] = '25A0';
    forward['FF'] = '00A0';
    backward['C7']   = '80';
    backward['FC']   = '81';
    backward['E9']   = '82';
    backward['E2']   = '83';
    backward['E4']   = '84';
    backward['E0']   = '85';
    backward['E5']   = '86';
    backward['E7']   = '87';
    backward['EA']   = '88';
    backward['EB']   = '89';
    backward['E8']   = '8A';
    backward['EF']   = '8B';
    backward['EE']   = '8C';
    backward['EC']   = '8D';
    backward['C4']   = '8E';
    backward['C5']   = '8F';
    backward['C9']   = '90';
    backward['E6']   = '91';
    backward['C6']   = '92';
    backward['F4']   = '93';
    backward['F6']   = '94';
    backward['F2']   = '95';
    backward['FB']   = '96';
    backward['F9']   = '97';
    backward['FF']   = '98';
    backward['D6']   = '99';
    backward['DC']   = '9A';
    backward['A2']   = '9B';
    backward['A3']   = '9C';
    backward['A5']   = '9D';
    backward['20A7'] = '9E';
    backward['192']  = '9F';
    backward['E1']   = 'A0';
    backward['ED']   = 'A1';
    backward['F3']   = 'A2';
    backward['FA']   = 'A3';
    backward['F1']   = 'A4';
    backward['D1']   = 'A5';
    backward['AA']   = 'A6';
    backward['BA']   = 'A7';
    backward['BF']   = 'A8';
    backward['2310'] = 'A9';
    backward['AC']   = 'AA';
    backward['BD']   = 'AB';
    backward['BC']   = 'AC';
    backward['A1']   = 'AD';
    backward['AB']   = 'AE';
    backward['BB']   = 'AF';
    backward['2591'] = 'B0';
    backward['2592'] = 'B1';
    backward['2593'] = 'B2';
    backward['2502'] = 'B3';
    backward['2524'] = 'B4';
    backward['2561'] = 'B5';
    backward['2562'] = 'B6';
    backward['2556'] = 'B7';
    backward['2555'] = 'B8';
    backward['2563'] = 'B9';
    backward['2551'] = 'BA';
    backward['2557'] = 'BB';
    backward['255D'] = 'BC';
    backward['255C'] = 'BD';
    backward['255B'] = 'BE';
    backward['2510'] = 'BF';
    backward['2514'] = 'C0';
    backward['2534'] = 'C1';
    backward['252C'] = 'C2';
    backward['251C'] = 'C3';
    backward['2500'] = 'C4';
    backward['253C'] = 'C5';
    backward['255E'] = 'C6';
    backward['255F'] = 'C7';
    backward['255A'] = 'C8';
    backward['2554'] = 'C9';
    backward['2569'] = 'CA';
    backward['2566'] = 'CB';
    backward['2560'] = 'CC';
    backward['2550'] = 'CD';
    backward['256C'] = 'CE';
    backward['2567'] = 'CF';
    backward['2568'] = 'D0';
    backward['2564'] = 'D1';
    backward['2565'] = 'D2';
    backward['2559'] = 'D3';
    backward['2558'] = 'D4';
    backward['2552'] = 'D5';
    backward['2553'] = 'D6';
    backward['256B'] = 'D7';
    backward['256A'] = 'D8';
    backward['2518'] = 'D9';
    backward['250C'] = 'DA';
    backward['2588'] = 'DB';
    backward['2584'] = 'DC';
    backward['258C'] = 'DD';
    backward['2590'] = 'DE';
    backward['2580'] = 'DF';
    backward['3B1']  = 'E0';
    backward['DF']   = 'E1';
    backward['393']  = 'E2';
    backward['3C0']  = 'E3';
    backward['3A3']  = 'E4';
    backward['3C3']  = 'E5';
    backward['B5']   = 'E6';
    backward['3C4']  = 'E7';
    backward['3A6']  = 'E8';
    backward['398']  = 'E9';
    backward['3A9']  = 'EA';
    backward['3B4']  = 'EB';
    backward['221E'] = 'EC';
    backward['3C6']  = 'ED';
    backward['3B5']  = 'EE';
    backward['2229'] = 'EF';
    backward['2261'] = 'F0';
    backward['B1']   = 'F1';
    backward['2265'] = 'F2';
    backward['2264'] = 'F3';
    backward['2320'] = 'F4';
    backward['2321'] = 'F5';
    backward['F7']   = 'F6';
    backward['2248'] = 'F7';
    backward['B0']   = 'F8';
    backward['2219'] = 'F9';
    backward['B7']   = 'FA';
    backward['221A'] = 'FB';
    backward['207F'] = 'FC';
    backward['B2']   = 'FD';
    backward['25A0'] = 'FE';
    backward['A0']   = 'FF';

    var hD="0123456789ABCDEF";
    this.d2h = function(d)
    {
        var h = hD.substr(d&15,1);
        while(d>15) {d>>=4;h=hD.substr(d&15,1)+h;}
        return h;
    }

    this.h2d = function(h)
    {
        return parseInt(h,16);
    }

    this.WriteAll = function(what)
    {
        //Create Stream object
        var BinaryStream = new ActiveXObject("ADODB.Stream");
        //Specify stream type - we cheat and get string but 'like' binary
        BinaryStream.Type = adTypeText;
        BinaryStream.CharSet = '437';
        //Open the stream
        BinaryStream.Open();
        // Write to the stream
        BinaryStream.WriteText(this.Forward437(what));
        // Write the string to the disk
        BinaryStream.SaveToFile(this.path, adSaveCreateOverWrite);

        // Clearn up
        BinaryStream.Close();
    }

    this.ReadAll  = function()
    {
        //Create Stream object - needs ADO 2.5 or heigher
        var BinaryStream = new ActiveXObject("ADODB.Stream");
        //Specify stream type - we cheat and get string but 'like' binary
        BinaryStream.Type = adTypeText;
        BinaryStream.CharSet = codePage;
        //Open the stream
        BinaryStream.Open();
        //Load the file data from disk To stream object
        BinaryStream.LoadFromFile(this.path);
        //Open the stream And get binary 'string' from the object
        var what = BinaryStream.ReadText;
        // Clean up
        BinaryStream.Close();
        return what;
		return this.Backward437(what);
    }

    /* Convert a octet number to a code page 437 char code */
    this.Forward437 = function(inString)
    {
        var encArray = new Array();
        var tmp='';
        var i=0;
        var c=0;
        var l=inString.length;
        var cc;
        var h;
        for(;i<l;++i)
        {
            c++;
            if(c==128)
            {
                encArray.push(tmp);
                tmp='';
                c=0;
            }
            cc=inString.charCodeAt(i);
            if(cc<128)
            {
                tmp+=String.fromCharCode(cc);
            }
            else
            {
                h=this.d2h(cc);
                h=forward[''+h];
                tmp+=String.fromCharCode(this.h2d(h));
            }
        }
        if(tmp!='')
        {
            encArray.push(tmp);
        }

        // this loop progressive concatonates the
        // array elements entil there is only one
        var ar2=new Array();
        for(;encArray.length>1;)
        {
            var l=encArray.length;
            for(var c=0;c<l;c+=2)
            {
                if(c+1==l)
                {
                    ar2.push(encArray[c]);
                }
                else
                {
                    ar2.push(''+encArray[c]+encArray[c+1]);
                }
            }
            encArray=ar2;
            ar2=new Array();
        }
        return encArray[0];
    }
    /* Convert a code page 437 char code to a octet number*/
    this.Backward437 = function(inString)
    {
        var encArray = new Array();
        var tmp='';
        var i=0;
        var c=0;
        var l=inString.length;
        var cc;
        var h;
        for(;i<l;++i)
        {
            c++;
            if(c==128)
            {
                encArray.push(tmp);
                tmp='';
                c=0;
            }
            cc=inString.charCodeAt(i);
            if(cc<128)
            {
                tmp+=String.fromCharCode(cc);
            }
            else
            {
                h=this.d2h(cc);
                h=backward[''+h];
                tmp+=String.fromCharCode(this.h2d(h));
            }
        }
        if(tmp!='')
        {
            encArray.push(tmp);
        }

        // this loop progressive concatonates the
        // array elements entil there is only one
        var ar2=new Array();
        for(;encArray.length>1;)
        {
            var l=encArray.length;
            for(var c=0;c<l;c+=2)
            {
                if(c+1==l)
                {
                    ar2.push(encArray[c]);
                }
                else
                {
                    ar2.push(''+encArray[c]+encArray[c+1]);
                }
            }
            encArray=ar2;
            ar2=new Array();
        }
        return encArray[0];
    }

}