//=============================================================================
//
//  Parameters
//
//-----------------------------------------------------------------------------
//  Installed system parameters
//=============================================================================


var _pf_secure 			= false;		//<SECURE>
var _pf_rebranded 		= false;
var _pf_signup 			= 1;



//=============================================================================
//
//  Public Functions
//
//-----------------------------------------------------------------------------
//  Functions to be used by user, to embed form/report, or customize
//=============================================================================


//-----------------------------------------------------------------------------
//  Embed a form/report
//-----------------------------------------------------------------------------

var _pf_embeded = false;

function pf_embed(url, id, params, width, height, mode) {
	if (mode==undefined) {
		mode = "window";
	}
	params = params + "&" + pf_getStandardFlashVars();
	document.write('<object classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000" codebase="http://fpdownload.macromedia.com/get/flashplayer/current/swflash.cab" width="'+width+'" height="'+height+'" id="'+id+'"><param name="movie" value="'+url+'"></param><param name="wmode" value="' + mode + '"></param><param name="flashVars" value="'+params+'"></param><param name="allowScriptAccess" value="always"></param><embed src="'+url+'" type="application/x-shockwave-flash" wmode="'+mode+'" width="'+width+'" height="'+height+'" flashVars ="'+params+'" name="'+id+'" allowScriptAccess="always"></embed></object>');
	_pf_embeded = true;
}

// Back compatibility
function createFlashMovie(url, id, params, width, height) {
	pf_embed(url, id, params, width, height)
}

//-----------------------------------------------------------------------------
//  Embed a preloader to a form/report
//-----------------------------------------------------------------------------

function pf_preload(url, id, params)
{
	id = id + "_";
	document.write('<object classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000" codebase="http://fpdownload.macromedia.com/get/flashplayer/current/swflash.cab" width="1" height="1" id="'+id+'"><param name="movie" value="'+url+'"></param><param name="wmode" value="transparent"></param><param name="flashVars" value="'+params+'"></param><param name="allowScriptAccess" value="always"></param><embed src="'+url+'" type="application/x-shockwave-flash" wmode="transparent" width="1" height="1" flashVars ="'+params+'" name="'+id+'" allowScriptAccess="always"></embed></object>');
}

// Back compatibility
function preloadFlashMovie(url, id, params) {
	pf_preload(url, id, params)
}

//-----------------------------------------------------------------------------
//  Make a call to an embeded form/report (triggers form's External Call event)
//-----------------------------------------------------------------------------

function pf_call(id, params) {

	var app = getFlexApplication(id);
	if (app) {
		app.externalCall(params);
	}
}

//-----------------------------------------------------------------------------
//  Embed the main application
//-----------------------------------------------------------------------------

function pf_main(width, height, swf, params) {

	// All params
	if (params==undefined) {
		params = pf_getStandardFlashVars();
	}
	else {
		params = params + "&" + pf_getStandardFlashVars();
	}
	
	// Version check for running PF application
	var hasRequestedVersion = DetectFlashVer(9, 0, 115);

	// Version check for the Flash Player that has the ability to start Player Product Install (6.0r65)
	var hasProductInstall = DetectFlashVer(6, 0, 65);
		
	// Check to see if a player with Flash Product Install is available and the version does not meet the requirements for playback
	if ( hasProductInstall && !hasRequestedVersion ) {
		// MMdoctitle is the stored document.title value used by the installation process to close the window that started the process
		// This is necessary in order to close browser windows that are still utilizing the older version of the player after installation has completed
		// DO NOT MODIFY THE FOLLOWING FOUR LINES
		// Location visited after installation is complete if installation is required
		var MMPlayerType = (isIE == true) ? "ActiveX" : "PlugIn";
		var MMredirectURL = window.location;
	    document.title = document.title.slice(0, 47) + " - Flash Player Installation";
	    var MMdoctitle = document.title;
	
		AC_FL_RunContent(
			"src", "playerProductInstall.swf",
			"FlashVars", "MMredirectURL="+MMredirectURL+'&MMplayerType='+MMPlayerType+'&MMdoctitle='+MMdoctitle+"",
			"width", width,
			"height", height,
			"align", "middle",
			"id", "flexApplication",
			"quality", "high",
			"bgcolor", "ffffff",
			"name", "flexApplication",
			"allowScriptAccess","always",
			"type", "application/x-shockwave-flash",
			"pluginspage", "http://www.adobe.com/go/getflashplayer"
		);
	} 
	else if (hasRequestedVersion) 
	{
		// if we've detected an acceptable version
		// embed the Flash Content SWF when all tests are passed
		AC_FL_RunContent(
				"src", swf,
				"width", width,
				"height", height,
				"align", "middle",
				"id", "__pf_app",
				"quality", "high",
				"bgcolor", "ffffff",
				"name", "__pf_app",
				"allowScriptAccess","always",
				"type", "application/x-shockwave-flash",
				"pluginspage", "http://www.adobe.com/go/getflashplayer",
				"FlashVars", params 
		);
	} 
	else 
	{  // flash is too old or we can't detect the plugin
	    var alternateContent = 'Alternate HTML content should be placed here. '
	  	+ 'This content requires the Adobe Flash Player. '
	   	+ '<a href=http://www.adobe.com/go/getflash/>Get Flash</a>';
	    document.write(alternateContent);  // insert non-flash content
	 }
}

//-----------------------------------------------------------------------------
//  List of flashvars which are always passed to app/player
//-----------------------------------------------------------------------------

function pf_getStandardFlashVars() {
	return 		"x=" + _pf_secure 
			+  "&b=" + _pf_rebranded
			+  "&q=" + _pf_signup;
}



//=============================================================================
//
//  Browser Close
//
//=============================================================================

//-----------------------------------------------------------------------------
// Make sure pop-up windows is closed, and Flex app is informed
//-----------------------------------------------------------------------------

window.onbeforeunload = function () 
{	

	// --- Make sure all pop-ups are closed ---
	
	try
	{
		// Is upload popup opened?
		if ( popupWindow != undefined ) 
		{
			try{
				// close popup
				popupWindow.close();	
			} catch (err) {
			}	
		}	
	
		// Is image import view popup opened?
		if ( popupImageImport != undefined ) {
			try {
				popupImageImport.close();
			} catch (err) {
			}
		}
	}
	catch (e) {
	}	


	// -- Handle Closure ---
	
	try 
	{
		// Get flash object
		var app = getFlexApplication();		

		if (app!=null)
		{
			if (app["browserUnload"]!=null) 
			{
				// Tell flex application, user wants to close
				app.browserUnload();
			}

			if (app["allowClose"]!=null)
			{
				// Ask flex app, if it is ok to close
			  	var warningMessage = app.allowClose();
				if (warningMessage!=null)
			   	{
			   		// No! Show warning dialog
					return warningMessage;
				}
			}
		}
	} 
	catch (e) {} // flexApplication is not defined and comparitions will crash
	return;
}



//=============================================================================
//
//  Flex App Interface
//
//-----------------------------------------------------------------------------
//  Functions to be called from Flex App
//=============================================================================


//-----------------------------------------------------------------------------
//  Close the browser window
//-----------------------------------------------------------------------------

function _pf_closeBrowser()
{
	window.close();
}

//-----------------------------------------------------------------------------
//  Pop-up a "minimal" style browser window
//-----------------------------------------------------------------------------

function _pf_openWindow(url,width,height) {
	window.open(url,"popup","status=0,toolbar=0,location=0,directories=0,menubar=0,resizable=0,scrollbars=0,width="+width+",height="+height);
}


//-----------------------------------------------------------------------------
//  Sets the title of the Browser window
//-----------------------------------------------------------------------------

function _pf_setPageTitle(str) {
	if (!_pf_embeded) {
		document.title = str;
	}
}


//-----------------------------------------------------------------------------
//  Find out if Browser is of IE variety
//-----------------------------------------------------------------------------

function _pf_isBrowserIE() {
	return navigator.appName.indexOf("Microsoft") != -1;
}


//-----------------------------------------------------------------------------
//  Scroll Browser to top of page
//-----------------------------------------------------------------------------

function _pf_scrollBrowserToTop(id) {

	app = getFlexApplication(id);
	if (app)
	{
		cy = _pf_findPosY(app);
		
		if (navigator.userAgent.indexOf("Gecko")!=-1)
		{
			cy = cy - currentObject.height + 15;
		}
		
		//Current Position
		var sty = 0;
		if (document.body.scrollTop)
			sty = document.body.scrollTop;
		if (window.pageYOffset)
			sty = window.pageYOffset;
		if (sty > 0)
		{  
			if (sty > cy)
			{
				window.scrollTo(0, cy);
			}
		}
	}
}

//-----------------------------------------------------------------------------
//  Scroll Browser to top of page
//-----------------------------------------------------------------------------

function _pf_getVisibleArea(id) {

	var app = getFlexApplication(id);
	if (app)
	{
		var x = _pf_findPosX(app);
		var y = _pf_findPosY(app);

		var scrollX = 0, scrollY = 0;
	    if( typeof( window.pageYOffset ) == 'number' )
	    {
	        scrollX = window.pageXOffset;
	        scrollY = window.pageYOffset;
	    } 
	    else if( document.body && ( document.body.scrollLeft || document.body.scrollTop ) ) 
	    {
	        scrollX = document.body.scrollLeft;
	        scrollY = document.body.scrollTop;
	    } 
	    else if( document.documentElement && ( document.documentElement.scrollLeft || document.documentElement.scrollTop ) ) 
	    {
	        scrollX = document.documentElement.scrollLeft;
	        scrollY = document.documentElement.scrollTop;
		}
		
		var w, h;
		if (typeof window.innerWidth != 'undefined')
		 {
		      w = window.innerWidth,
		      h = window.innerHeight
		 }
		 else if (typeof document.documentElement != 'undefined'
		     && typeof document.documentElement.clientWidth !=
		     'undefined' && document.documentElement.clientWidth != 0)
		 {
		       w = document.documentElement.clientWidth,
		       h = document.documentElement.clientHeight
		 }
		 else
		 {
		       w = document.getElementsByTagName('body')[0].clientWidth,
		       h = document.getElementsByTagName('body')[0].clientHeight
		 }


		return (scrollX-x) + "|" + (scrollY-y) + "|" + w + "|" + h;
	}
	
	return null;
}



// Little helper for above: Returns page coordinate of an object
function _pf_findPosX(obj)
{
	var result = 0;
	if(obj.offsetParent)
	{
		while(1)
		{
			result += obj.offsetLeft;
			if(!obj.offsetParent)
				break;
			obj = obj.offsetParent;
		}
	}
	else if(obj.x)
	{
		result += obj.x;
	}
	return result;
}

// Little helper for above: Returns page coordinate of an object
function _pf_findPosY(obj)
{
	var result = 0;
	if(obj.offsetParent)
	{
		while(1)
		{
			result += obj.offsetTop;
			if(!obj.offsetParent)
				break;
			obj = obj.offsetParent;
		}
	}
	else if(obj.y)
	{
		result += obj.y;
	}
	return result;
}


//=============================================================================
//
//  Image Aquisition
//
//=============================================================================


var versionNo="1.0.0.25";
var activeXClass="JetstreamImageAcquisition.COMAquisitor";
var setupPath="http://devel.perfectforms.com/ImageCapture/ImageAquisitionSetup1025.msi";
var popupImageImport;


function messageAppStatus()
{
	var sts=getAppStatus();

	if(sts=="match")
	{
		return true;
	}
	else
	{
		return false;
	}
	
}


function getAppStatus()
{
	var x=isSetupInstalled();
	if(x)
	{
		var y=getVersionNo();
		if(y==versionNo)
		{ return "match"}
		else
		{ return y;}
	}
	else
	{
	return "not installed";
	}
}


function isSetupInstalled()
{
	try { 
		var obj = new ActiveXObject(activeXClass);
	} catch(e) {
		alert("Error: " + e.description);
	} 
	
	return obj != null;
}


function getVersionNo()
{
	var obj = new ActiveXObject(activeXClass) ;
	return obj.VersionNo( );
}


function getFlexApplication(appId) 
{
    // Try with Id first
    if (appId!="undefined")
    {
		var app = getFlashMovie(appId);
		if (app)
		{
			return app;
		}
	}
		
	// Now, try without Id
	return getFlashMovie("__pf_app");
}


function getFlashMovie(movieName) 
{
 	if (navigator.appName.indexOf("Microsoft") != -1) {
 		var flashObject = window[movieName];
 		
 		if ( flashObject == undefined )
 		{
 			flashObject = window.document[movieName];	
 		}
 		if ( flashObject == undefined )
 		{
 			flashObject = document[movieName];	
 		}
 		if ( flashObject == undefined )
 		{
 			flashObject = document.getElementById(movieName);	
 		}
 		if ( flashObject == undefined )
 		{
 			flashObject = document.getElementsByName(movieName)[0];	
 		}
 	
        return flashObject;
    }
    else {
        return document[movieName];
    }
}


function runAquireImage(token,url,size,extra,appId)
{
	// Use a setTimeout to solve Flex 15 seconds timeout script execution
	setTimeout("runAquireImageStarter('"+token+"','"+url+"','"+size+"','"+extra+"','"+appId+"')",100);
}


function runAquireImageStarter(token,url,size,extra,appId)
{
	if(messageAppStatus() == false)
	{
		// Call ActionScript
		try {
 			var isIE = navigator.appName.indexOf("Microsoft") != -1;
			if ( isIE )		
				getFlexApplication(appId).activexCallbackVersion(setupPath);
			else	
				getFlexApplication(appId).activexCallbackNonIE(setupPath);
		} catch(e){ 
			//alert("Image Acquisition communication error!"); 
		}
		return;
	}	
	
	var objDownload = new ActiveXObject(activeXClass);
	try
	{
		var xml=objDownload.AcquireToWebService(token,url,size,extra);
		if(xml)
		{
			// Call ActionScript
			var callResult = getFlexApplication(appId).activexCallback(xml);
			return;
			
		}
		else
		{
			//alert("No image aquired");
			return;
		}
		
	}
	catch(exception) 
	{
		alert("Error: " + exception.description);
	}
}


function installActiveX()
{
	document.getElementById('_activex').src = setupPath;
//	var newWin = window.open(setupPath,"downloadActiveX","");	
//	newWin.document.location.replace(setupPath);
}


function viewAttachmentInBrowser(url)
{
	// Use a setTimeout to solve Flex 15 seconds timeout script execution
	setTimeout("viewAttachmentInBrowserStarter('"+url+"')",100);
}


function viewAttachmentInBrowserStarter(url)
{
	// Is popup opened already?
	if ( popupImageImport != undefined ) {
		try {
			popupImageImport.close();
		} catch (err) {
		}
	}
	
	// Open popup	
	popupImageImport = window.open(url,"downloadActiveX","location=no,status=no,scrollbars=no,menubar=no,toolbar=no,resizable=yes");	
}


function runViewImage(url)
{
	// Use a setTimeout to solve Flex 15 seconds timeout script execution
	setTimeout("runViewImageStarter('"+url+"')",100);
}


function runViewImageStarter(url)
{
	var objDownload = new ActiveXObject(activeXClass);
	objDownload.ViewOnline(url);
}



//=============================================================================
//
//  Alternative Upload Mechanism 
//
//=============================================================================


//-----------------------------------------------------------------------------
//  Global Variables
//-----------------------------------------------------------------------------

var token = ""
var uploadServiceUrl = "";
var appUrl = "";
var formId = "";
var type = "";
var fileMode = "";
var mimeType = "";
var flexObjectId = "";
var op = "";
var response = "";
var timer = 0;
var popupCreated = false;
var	labelSelectFile = "";
var	labelAssetName = "";
var	labelUpload = "Upload";
var	labelClose = "Close";
var labelTitle = "";
var labelUploading = "Uploading...";
var labelSuccess = "Success";
var labelError = "Error";
var labelFileTypeNotAllowed = "You can only upload file of type";
var fileTypesAllowed = "";
var isPopup=false;
var popupWindow;
var gatewayService = false;
var servicesFolder = "services/";


//-----------------------------------------------------------------------------
// Triggers when user starts an AssetUpload, FormImport, FileAttachment
//-----------------------------------------------------------------------------

function pfCreateUploadForm(pToken, pUrl, pAppUrl, pFormId, pType, pFileMode, 
							pFlexObjectId, pOperation, 
							lblTitle, lblSelectFile, 
							lblAssetName, lblUploading, 
							lblSuccess, lblError, lblClose, 
							lblUpload, lblFileTypeNotAllowed)
{
	// Is popup already created?
	if ( popupWindow != undefined ) 
	{
		try{
			// close popup
			popupWindow.close();	
		} catch (err) {
		}	
	}	
		
	// Store parameters
	token = pToken;
	uploadServiceUrl = getServiceUrl(pUrl, gatewayService, servicesFolder);
	appUrl = pAppUrl;
	formId = pFormId;
	type = pType;
	fileMode = pFileMode;
	op = pOperation;
	
	flexObjectId = pFlexObjectId;
	
	labelSelectFile = lblSelectFile;
	labelAssetName = lblAssetName;
	labelTitle = lblTitle;
	labelUpload = lblUpload;
	labelClose = lblClose;
	labelUploading = lblUploading;
	labelSuccess = lblSuccess;
	labelError = lblError;
	labelFileTypeNotAllowed = lblFileTypeNotAllowed;

	var popupWidth = 350;
	var popupHeight = 260;
	
	var strHtml = '<html><head><title>PerfectForms</title><script type="text/javascript" src="'+appUrl+'utils.js"></script><link href="'+appUrl+'style.css" rel="stylesheet" type="text/css" /></head><body onload="onPerfectFormsUploaderPopupLoad();">';
	strHtml += '<div id="pfUploadDiv" style="position:absolute;padding:15px;width:'+popupWidth+'px;height:'+popupHeight+'px;background-color:#E2E2E2;border:1px solid #CCCCCC;">';
	strHtml += '<span class="htmlUploadTitle" id="pfUploadTitle" style="width:100%;"></span><br><form name="pfUploadForm" method="POST" action="" target="pfUploadIframe" enctype="multipart/form-data"><div style="background-color:#FFFFFF;padding:10px;">';
	strHtml += '<div id="pfElements">';
	strHtml += '<span id="pfUploadFileLabel" class="htmlUploadLabel"></span><br><input type="file" name="Filedata" id="Filedata" onChange="pfHandleFileChange()" style="width:325px;visibility:visible;" /><br>';
	strHtml += '<span id="pfUploadFileName">&nbsp;</span>';
	strHtml += '</div>';
	strHtml += '<br><span id="pfUploadMessage" class="htmlUploadMessage" value="&nbsp;"></span><br><br><hr>';
	strHtml += '<input type="button" id="pfUploadButton" name="pfUploadButton" onClick="pfHandleUpload()" disabled="true" class="htmlUploadButton">&nbsp;';
	strHtml += '<input type="button" id="pfCloseButton" name="pfCloseButton" onClick="pfHandleClose()" class="htmlUploadButton">';
	strHtml += '<input type="hidden" name="token" id="token" value="" />';
	strHtml += '<span id="pfUploadHiddens">&nbsp;</span>';
	strHtml += '<iframe id="pfUploadIframe" name="pfUploadIframe" src="#" style="width:0;height:0;border:0px solid #ffffff;"></iframe>';
	strHtml += '</div></form>';
	strHtml += '</body></html>';
	
	// Open uploader popup
	popupWindow = openUploaderPopup((gatewayService==true?"popupUpload.aspx":strHtml), popupWidth+25, popupHeight+20);
	
	// Set popupCreated flag
	popupCreated = true;
}


//-----------------------------------------------------------------------------
// Triggers when user selects another file from dialog
//-----------------------------------------------------------------------------

function pfHandleFileChange()
{
	// Is file selected?
	if ( document.getElementById("Filedata").value == "" )
	{
		// Disable upload button
		document.getElementById("pfUploadButton").disabled = true;
	}
	else
	{
		// Enable upload button
		document.getElementById("pfUploadButton").disabled = false;
	}
}


//-----------------------------------------------------------------------------
// Triggers when Close button of popup is pressed
//-----------------------------------------------------------------------------

function pfHandleClose()
{
	if ( isPopup == true ) {
		// Close uploader popup
		window.close();
		
		// Reset popupCreated flag
		popupCreated = false;
	} else {
		try{
			// Store new token
			popupWindow.close();
		} catch (err) {
		}
	}	
}


//-----------------------------------------------------------------------------
// Triggers when Upload button of popup is pressed
//-----------------------------------------------------------------------------

function pfHandleUpload()
{
	// Is file attachment or asset upload?
	if ( op != "Import" ) {
		try {
			// Yes. Set mimeType parameter
			document.getElementById("mimeType").value = getMimeType(document.getElementById("Filedata").value);
		} catch (err) {
		}	
	}
	
	// Get file type (extension)
	var fileExt =  getFileExtension(document.getElementById("Filedata").value);
	
	// Is allowed file type?
	if ( !pfFileTypeAllowed(fileExt, op) ) {
		// Set message
		pfSetUploadMessage(labelFileTypeNotAllowed + " " + fileTypesAllowed, token, true);
		return;			
	}
	
	// Set message
	pfSetUploadMessage(labelUploading, token, true);
	
	// Disable upload button
	document.getElementById("pfUploadButton").disabled = true;
	
	// Hide file input elements
	hideElements();

	// Submit form
	document.pfUploadForm.submit();
}


//-----------------------------------------------------------------------------
// Triggers when Server return a response for UPLOAD
//-----------------------------------------------------------------------------

function pfUploadCallback(xml)
{
	window.opener.pfUploadCallbackOpener(xml, getFileName());
}


//-----------------------------------------------------------------------------
// Triggers when popup upload window initiate callback to FLEX.
//-----------------------------------------------------------------------------

function pfUploadCallbackOpener(xml, filename)
{
	if(xml)
	{
		try{
			// Call ActionScript
			getFlexApplication(flexObjectId).htmlUploadCallback(filename, xml);

			return;

		}catch (error){
			try {
				pfSetUploadMessage(labelError, token, true);
			} catch (err) {
			}	
		}	
	}
	else
	{
		pfSetUploadMessage(labelError, token, true);
		return;
	}
}


//-----------------------------------------------------------------------------
// Displays a message in the popup window
//-----------------------------------------------------------------------------

function pfSetUploadMessage(message, pToken, visible)
{
	if ( isPopup == true ) {
		// Store new token
		token = pToken;
		document.getElementById("pfUploadMessage").style.visibility = (visible==false)?"hidden":"visible";
		document.getElementById("pfUploadMessage").innerHTML = replaceHTMLFontTag("b", message);
	} else {
		try{
			// Store new token
			popupWindow.document.token = pToken;
			popupWindow.document.getElementById("pfUploadMessage").style.visibility = (visible==false)?"hidden":"visible";
			popupWindow.document.getElementById("pfUploadMessage").innerHTML = replaceHTMLFontTag("b", message);
		
			// Set focus on popup
			popupWindow.focus();
		} catch (err) {
		}
	}	
}


//-----------------------------------------------------------------------------
// Replaces one HTML "font" tag with another one
//-----------------------------------------------------------------------------

function replaceHTMLFontTag(destTag, htmlStr)
{
	var resultHtmlStr = htmlStr;
	
	try
	{
		resultHtmlStr = resultHtmlStr.replace(/<font/gi,'<'+destTag);
		resultHtmlStr = resultHtmlStr.replace(/<\/font/gi,'<\/'+destTag);
	}
	catch(err)
	{}
	
	return resultHtmlStr;	
}


//-----------------------------------------------------------------------------
// Gets the name of the selected file (without extension)
//-----------------------------------------------------------------------------

function getFileName()
{
	var fileName = "";
	
	// Is file name text input defined?
	if ( op != "FileAttachment" )
	{
		try {
			fileName = document.getElementById("pfFileName").value;
		} catch (err) {
		}	
	}	
	
	// Is fileName defined?
	if ( fileName == "" )
	{
		// Get file name with full path
		fileName = document.getElementById("Filedata").value;
		
		var startIndex = fileName.lastIndexOf("\\")+1;
		var endIndex = (op=="FileAttachment"?fileName.length:fileName.lastIndexOf("."));
		
		// Remove folder path
		fileName = fileName.substring(startIndex,endIndex);
	}
	
	return fileName;
}


//-----------------------------------------------------------------------------
// Gets the file extension of a specified file
//-----------------------------------------------------------------------------

function getFileExtension(fileName)
{
	if ( fileName == null )
		return "";
	
	var fileExtension = "";
	var lastIndex = fileName.lastIndexOf(".");
	
	if ( lastIndex > -1 && lastIndex < fileName.length )
		fileExtension = fileName.substring(lastIndex + 1);
		
	return 	fileExtension;
}


//-----------------------------------------------------------------------------
// Gets the mimeType of the selected file
//-----------------------------------------------------------------------------

function getMimeType(fileName)
{
	if ( fileName == null )
		return "";
	
	var fileExtension;
	var lastIndex = fileName.lastIndexOf(".");
	
	if ( lastIndex > -1 && lastIndex < fileName.length )
		fileExtension = fileName.substring(lastIndex + 1);
	
	if ( fileExtension != null && fileExtension != "" )
	{
		switch ( fileExtension.toLowerCase() )
		{
			case "jpg":
			case "jpeg":
				return "image/jpeg";
			case "gif":
				return "image/gif";
			case "png":
				return "image/png";
			case "mp3":
				return "audio/mpeg";
			case "wav":
				return "audio/x-wav";
			case "swf":
				return "application/x-shockwave-flash";
			case "flv":
				return "application/x-shockwave-flash";
			case "doc":
				return "application/msword";
			case "docx":
				return "application/xml";
			case "pdf":
				return "application/pdf";
			case "xls":
				return "application/msexcel";
			case "txt":
				return "text/plain";
			case "zip":
				return "application/x-zip-compressed";
				
			
			default:
				return fileExtension.toLowerCase();	
		}
	}
	
	return null;
}


//-----------------------------------------------------------------------------
// Hides elements when upload starts
//-----------------------------------------------------------------------------

function hideElements() {
	// Hide top elements
	document.getElementById("pfElements").style.visibility = "hidden";
}


//-----------------------------------------------------------------------------
// Gets the left position of the new popup
//-----------------------------------------------------------------------------

function getPopupLeft(popupW) {
	var windowWidth = 0;
	var popupLeft = 0;
	
	if( typeof( window.innerWidth ) == 'number' ) {
    	//Non-IE
	    windowWidth = window.innerWidth;
  	} else if( document.documentElement && ( document.documentElement.clientWidth || document.documentElement.clientHeight ) ) {
    	//IE 6+ in 'standards compliant mode'
	    windowWidth = document.documentElement.clientWidth;
	} else if( document.body && ( document.body.clientWidth || document.body.clientHeight ) ) {
    	//IE 4 compatible
		windowWidth = document.body.clientWidth;
  	}
  	
  	popupLeft = (windowWidth - popupW)/2;
  	
  	if ( popupLeft < 0 )
  		popupLeft = 100;
  		
  	return popupLeft;
}


//-----------------------------------------------------------------------------
// Gets the top position of the new popup
//-----------------------------------------------------------------------------

function getPopupTop(popupH) {
	var windowHeight = 0;
	var popupTop = 0;
	
	if( typeof( window.innerWidth ) == 'number' ) {
    	//Non-IE
	    windowHeight = window.innerHeight;
	} else if( document.documentElement && ( document.documentElement.clientWidth || document.documentElement.clientHeight ) ) {
	    //IE 6+ in 'standards compliant mode'
	    windowHeight = document.documentElement.clientHeight;
	} else if( document.body && ( document.body.clientWidth || document.body.clientHeight ) ) {
	    //IE 4 compatible
	    windowHeight = document.body.clientHeight;
	}
	
	popupTop = (windowHeight - popupH)/2;
	
	if ( popupTop < 0 )
		popupTop = 100;
		
	return popupTop;
}


//-----------------------------------------------------------------------------
// Creates a new popup window and displays it
//-----------------------------------------------------------------------------

function openUploaderPopup(content,w,h) {
	

	var newWin;
	
	if ( gatewayService == true )
	{
		newWin = window.open(content, "PerfectFormsUploader", "width="+w+",height="+h+",top="+getPopupTop(h)+",left="+getPopupLeft(w)+",status=1,resizable=1");
	}
	else
	{
		newWin = window.open("about:blank", "PerfectFormsUploader", "width="+w+",height="+h+",top="+getPopupTop(h)+",left="+getPopupLeft(w)+",status=1,resizable=1");
		newWin.document.open();
		newWin.document.write(content);
		newWin.document.close();
	}	

	newWin.focus();
	
	return newWin;
}


//-----------------------------------------------------------------------------
// Triggers when popup window has been loaded
//-----------------------------------------------------------------------------

function onPerfectFormsUploaderPopupLoad() {
	// Set properties
	isPopup = true;
	
	// Get properties from opener
	op = window.opener.op;
	token = window.opener.token;
	uploadServiceUrl = window.opener.uploadServiceUrl;
	formId = window.opener.formId;
	type = window.opener.type;
	fileMode = window.opener.fileMode;
	mimeType = window.opener.mimeType;
	labelSelectFile = window.opener.labelSelectFile;
	labelAssetName = window.opener.labelAssetName;
	labelTitle = window.opener.labelTitle;
	labelUpload = window.opener.labelUpload;
	labelClose = window.opener.labelClose;
	labelUploading = window.opener.labelUploading;
	labelSuccess = window.opener.labelSuccess;
	labelError = window.opener.labelError;
	labelFileTypeNotAllowed = window.opener.labelFileTypeNotAllowed;


	//**********************
	// Update html display	
	//**********************

	// Set popup title
	document.getElementById("pfUploadTitle").innerHTML = labelTitle;
	document.getElementById("pfUploadFileLabel").innerHTML = labelSelectFile;
	document.getElementById("pfUploadButton").value = labelUpload;
	document.getElementById("pfCloseButton").value = labelClose;

	// Is file attachment?
	if ( op != "FileAttachment" )
	{
		// No. Add file name text input
		document.getElementById("pfUploadFileName").innerHTML = '<br><span id="pfUploadFileNameLabel" class="htmlUploadLabel">'+labelAssetName+'</span><br><input type="text" name="name" id="pfFileName" style="width:325px;" /><br />';
	}
	
	var strHtml = "";

	// Is operation defined?
	if ( op != "Import" )
	{
		// No. Add assets upload specific parameters
		strHtml = '<input type="hidden" name="mimeType" id="mimeType" value="' + mimeType + '" />';
		strHtml += '<input type="hidden" name="fileMode" id="fileMode" value="' + fileMode + '" />';
		strHtml += '<input type="hidden" name="formId" id="formId" value="" />';
	}
	else 
	{
		// Yes. Add form import specific parameters
		strHtml = '<input type="hidden" name="op" id="op" value="' + op + '" />';
		strHtml += '<input type="hidden" name="type" id="type" value="' + type + '" />';
		strHtml += '<input type="hidden" name="id" id="id" value="" />';
	}

	// Display specific components	
	document.getElementById("pfUploadHiddens").innerHTML = strHtml;
	
	// Is import version?
	if ( type.indexOf("version")> -1 )
	{
		// Yes. Hide file name
		document.getElementById("pfUploadFileName").style.visibility = "hidden";
	}
	
	// Set values into html form elements
	document.pfUploadForm.action = uploadServiceUrl;
	document.getElementById("token").value = token;

	// Is import operation?
	if ( op != "Import" )
	{
		// No
		document.getElementById("formId").value = formId;
	}
	else	
	{
		// Yes
		document.getElementById("id").value = formId;
	}
	
	// Set unload action
	window.onbeforeunload = function () {	
		window.opener.popupCreated = false;
	}
}


//-----------------------------------------------------------------------------
// Returns true if file type is allowed for upload
//-----------------------------------------------------------------------------

function pfFileTypeAllowed(fileExt, uploadType) {

	if ( fileExt == "" ) {
		return false;
	}
	
	if ( uploadType == "Import" ) {
		if ( fileExt == "pf" ) {
			return true;
		} else {
			fileTypesAllowed = ".pf";
		}
		
	} else if ( uploadType == "AssetUpload" ) {
		
		// Convert fileExt to lowerCase
		fileExt = fileExt.toLowerCase();
		
		if ( fileExt == "jpg" || 
				fileExt == "jpeg" || 
				fileExt == "gif" || 
				fileExt == "png" || 
				fileExt == "tiff" || 
				fileExt == "wav" || 
				fileExt == "mp3" || 
				fileExt == "swf" || 
				fileExt == "flv"
				) {

			return true;
		} else {
			fileTypesAllowed = ".jpg, .jpeg, .gif, .png, .tiff, .wav, .mp3, .swf, .flv";
		}		
	} else if ( uploadType == "FileAttachment" ) {
		return true;
	}

	return false;
}


//-----------------------------------------------------------------------------
// Returns the service URL (with or without Gateway)
//-----------------------------------------------------------------------------

function getServiceUrl(serviceUrl, gatewayService, servicesFolder) {
	
	// Is gateway used?
	if ( gatewayService == true )
	{
		// Yes.
		return serviceUrl.substring(serviceUrl.indexOf(servicesFolder));	
		
	}
	else
	{
		// No.
		return serviceUrl; 
	}
}


//=============================================================================
//
//  Flash Player Version Detection - Rev 1.5
//  Detect Client Browser type
//
//  Copyright(c) 2005-2006 Adobe Macromedia Software, LLC. All rights reserved.
//
//=============================================================================


var isIE  = (navigator.appVersion.indexOf("MSIE") != -1) ? true : false;
var isWin = (navigator.appVersion.toLowerCase().indexOf("win") != -1) ? true : false;
var isOpera = (navigator.userAgent.indexOf("Opera") != -1) ? true : false;

function ControlVersion()
{
	var version;
	var axo;
	var e;

	// NOTE : new ActiveXObject(strFoo) throws an exception if strFoo isn't in the registry

	try {
		// version will be set for 7.X or greater players
		axo = new ActiveXObject("ShockwaveFlash.ShockwaveFlash.7");
		version = axo.GetVariable("$version");
	} catch (e) {
	}

	if (!version)
	{
		try {
			// version will be set for 6.X players only
			axo = new ActiveXObject("ShockwaveFlash.ShockwaveFlash.6");
			
			// installed player is some revision of 6.0
			// GetVariable("$version") crashes for versions 6.0.22 through 6.0.29,
			// so we have to be careful. 
			
			// default to the first public version
			version = "WIN 6,0,21,0";

			// throws if AllowScripAccess does not exist (introduced in 6.0r47)		
			axo.AllowScriptAccess = "always";

			// safe to call for 6.0r47 or greater
			version = axo.GetVariable("$version");

		} catch (e) {
		}
	}

	if (!version)
	{
		try {
			// version will be set for 4.X or 5.X player
			axo = new ActiveXObject("ShockwaveFlash.ShockwaveFlash.3");
			version = axo.GetVariable("$version");
		} catch (e) {
		}
	}

	if (!version)
	{
		try {
			// version will be set for 3.X player
			axo = new ActiveXObject("ShockwaveFlash.ShockwaveFlash.3");
			version = "WIN 3,0,18,0";
		} catch (e) {
		}
	}

	if (!version)
	{
		try {
			// version will be set for 2.X player
			axo = new ActiveXObject("ShockwaveFlash.ShockwaveFlash");
			version = "WIN 2,0,0,11";
		} catch (e) {
			version = -1;
		}
	}
	
	return version;
}

// JavaScript helper required to detect Flash Player PlugIn version information
function GetSwfVer(){
	// NS/Opera version >= 3 check for Flash plugin in plugin array
	var flashVer = -1;
	
	if (navigator.plugins != null && navigator.plugins.length > 0) {
		if (navigator.plugins["Shockwave Flash 2.0"] || navigator.plugins["Shockwave Flash"]) {
			var swVer2 = navigator.plugins["Shockwave Flash 2.0"] ? " 2.0" : "";
			var flashDescription = navigator.plugins["Shockwave Flash" + swVer2].description;			
			var descArray = flashDescription.split(" ");
			var tempArrayMajor = descArray[2].split(".");
			var versionMajor = tempArrayMajor[0];
			var versionMinor = tempArrayMajor[1];
			if ( descArray[3] != "" ) {
				tempArrayMinor = descArray[3].split("r");
			} else {
				tempArrayMinor = descArray[4].split("r");
			}
			var versionRevision = tempArrayMinor[1] > 0 ? tempArrayMinor[1] : 0;
			var flashVer = versionMajor + "." + versionMinor + "." + versionRevision;
		}
	}
	// MSN/WebTV 2.6 supports Flash 4
	else if (navigator.userAgent.toLowerCase().indexOf("webtv/2.6") != -1) flashVer = 4;
	// WebTV 2.5 supports Flash 3
	else if (navigator.userAgent.toLowerCase().indexOf("webtv/2.5") != -1) flashVer = 3;
	// older WebTV supports Flash 2
	else if (navigator.userAgent.toLowerCase().indexOf("webtv") != -1) flashVer = 2;
	else if ( isIE && isWin && !isOpera ) {
		flashVer = ControlVersion();
	}	
	return flashVer;
}

// When called with reqMajorVer, reqMinorVer, reqRevision returns true if that version or greater is available
function DetectFlashVer(reqMajorVer, reqMinorVer, reqRevision)
{
	versionStr = GetSwfVer();
	if (versionStr == -1 ) {
		return false;
	} else if (versionStr != 0) {
		if(isIE && isWin && !isOpera) {
			// Given "WIN 2,0,0,11"
			tempArray         = versionStr.split(" "); 	// ["WIN", "2,0,0,11"]
			tempString        = tempArray[1];			// "2,0,0,11"
			versionArray      = tempString.split(",");	// ['2', '0', '0', '11']
		} else {
			versionArray      = versionStr.split(".");
		}
		var versionMajor      = versionArray[0];
		var versionMinor      = versionArray[1];
		var versionRevision   = versionArray[2];

        	// is the major.revision >= requested major.revision AND the minor version >= requested minor
		if (versionMajor > parseFloat(reqMajorVer)) {
			return true;
		} else if (versionMajor == parseFloat(reqMajorVer)) {
			if (versionMinor > parseFloat(reqMinorVer))
				return true;
			else if (versionMinor == parseFloat(reqMinorVer)) {
				if (versionRevision >= parseFloat(reqRevision))
					return true;
			}
		}
		return false;
	}
}

function AC_AddExtension(src, ext)
{
  if (src.indexOf('?') != -1)
    return src.replace(/\?/, ext+'?'); 
  else
    return src + ext;
}

function AC_Generateobj(objAttrs, params, embedAttrs) 
{ 
    var str = '';
    if (isIE && isWin && !isOpera)
    {
  		str += '<object ';
  		for (var i in objAttrs)
  			str += i + '="' + objAttrs[i] + '" ';
  		for (var i in params)
  			str += '><param name="' + i + '" value="' + params[i] + '" /> ';
  		str += '></object>';
    } else {
  		str += '<embed ';
  		for (var i in embedAttrs)
  			str += i + '="' + embedAttrs[i] + '" ';
  		str += '> </embed>';
    }

    document.write(str);
}

function AC_FL_RunContent() {
  var ret = 
    AC_GetArgs
    (  arguments, "movie", "clsid:d27cdb6e-ae6d-11cf-96b8-444553540000"
     , "application/x-shockwave-flash"
    );
  AC_Generateobj(ret.objAttrs, ret.params, ret.embedAttrs);
}

function AC_GetArgs(args, srcParamName, classid, mimeType) {
  var ret = new Object();
  ret.embedAttrs = new Object();
  ret.params = new Object();
  ret.objAttrs = new Object();
  for (var i=0; i < args.length; i=i+2){
    var currArg = args[i].toLowerCase();    

    switch (currArg){	
      case "classid":
        break;
      case "pluginspage":
        ret.embedAttrs[args[i]] = args[i+1];
        break;
      case "src":
      case "movie":	
        // args[i+1] = AC_AddExtension(args[i+1], ext);
        ret.embedAttrs["src"] = args[i+1];
        ret.params[srcParamName] = args[i+1];
        break;
      case "onafterupdate":
      case "onbeforeupdate":
      case "onblur":
      case "oncellchange":
      case "onclick":
      case "ondblClick":
      case "ondrag":
      case "ondragend":
      case "ondragenter":
      case "ondragleave":
      case "ondragover":
      case "ondrop":
      case "onfinish":
      case "onfocus":
      case "onhelp":
      case "onmousedown":
      case "onmouseup":
      case "onmouseover":
      case "onmousemove":
      case "onmouseout":
      case "onkeypress":
      case "onkeydown":
      case "onkeyup":
      case "onload":
      case "onlosecapture":
      case "onpropertychange":
      case "onreadystatechange":
      case "onrowsdelete":
      case "onrowenter":
      case "onrowexit":
      case "onrowsinserted":
      case "onstart":
      case "onscroll":
      case "onbeforeeditfocus":
      case "onactivate":
      case "onbeforedeactivate":
      case "ondeactivate":
      case "type":
      case "codebase":
        ret.objAttrs[args[i]] = args[i+1];
        break;
      case "id":
      case "width":
      case "height":
      case "align":
      case "vspace": 
      case "hspace":
      case "class":
      case "title":
      case "accesskey":
      case "name":
      case "tabindex":
        ret.embedAttrs[args[i]] = ret.objAttrs[args[i]] = args[i+1];
        break;
      default:
        ret.embedAttrs[args[i]] = ret.params[args[i]] = args[i+1];
    }
  }
  ret.objAttrs["classid"] = classid;
  if (mimeType) ret.embedAttrs["type"] = mimeType;
  return ret;
}