#pragma TextEncoding="UTF-8"
#pragma rtGlobals=3
#pragma IgorVersion=7

// feedback? ideas? tony.withers@uwo.ca

// This file should be saved in the Igor Procedures folder (look in the 
// Help menu for "Show Igor Pro User Files"). 

// If you want Igor to automatically reload updated files, choose 
// Misc->Miscellaneous Settings, click Text Editing in the left pane, 
// click the External Editor tab, and select Reload Automatically, As 
// Soon as Modification is Detected. 

// If you're an end-user of packages that can be updated this way, that's
// all you need to do.

// ------------------------------------------------------------------------

// If you're developing a package and wish to use this updater: 

// 1. Copy and paste this block of pragma statements and constants to the procedure file you 
// want to keep updated. Edit values to match your package - the values here are for this file.

#pragma version=2.08 // Edit version number - must be same as release version on IgorExchange
#pragma moduleName=updater // Edit regular module name
static constant kCHECK_FOR_UPDATES=1  // set to 1 to check for updates on init
static strconstant ksSHORTNAME="Updater" // Must correspond to shortname of IgorExchange release
									// (ksSHORTNAME isn't needed if moduleName matches project shortname)

// 2. Insert this code in your procedure file (without //):

//static function CheckForUpdates()
//	if(kCHECK_FOR_UPDATES)
//		#if (exists("Updater#UpdateCheck")==6)
//			return Updater#UpdateCheck("fileloc:"+FunctionPath(""))
//		#endif
//	endif
//	return 0
//end

// 3. Add this to your package initialization function:

//	if (CheckForUpdates())
//		return 0 // this file has been updated; quit to allow user to reload
//	endif

// ---------------------------------------------------------------------------

// Details
// Updater is close to being able to handle zip archives. If the project 
// release is a zip archive, Updater downloads the archive to the 
// desktop, inflates archive to a temporary location (also on the 
// desktop), and moves all of the contents to the same location as the ipf
// file to be updated. For this to work, the zip archive had better have 
// a straightforward structure. If the master procedure file is buried in
// a subfolder, or if the orginal installation spread the package 
// contents into other unrelated folders, running the update will cause 
// problems. Caveat emptor!

// On Windows, Andrew Nelson's zip XOP is required: 
// http://www.igorexchange.com/project/ZIP


// Wishlist

// See install() function in this file for a prototype package installer.

// Easy to unzip on a mac. On a PC, need 3rd party utility. Or this XOP:
// http://www.igorexchange.com/project/ZIP
// Unfortunately it looks like a file handle isn't being closed properly 
// by zip.xop, preventing Igor from moving the extracted files. For now, 
// workaround is to move files to install location, leaving the folder
// for the user to delete

// Would like to know current status of Misc settings for reloading 
// updated files.

// Provide a way to rollback to earlier releases, or give a list of 
// releases for the user to choose from.

// Deal with XOPs

// -----------------------------------------------------------------------------

// code for use in independent modules:

//static function CheckForUpdates()
//	
//	if (kCHECK_FOR_UPDATES==0)
//		return 0
//	endif
//	
//	string keyStr=""
//	keyStr=ReplaceStringByKey("fileloc", keyStr, FunctionPath(""))
//	
//// find out whether Updater is installed
//	#if (exists("Updater#UpdateCheck")==6) // this will be 0 if running as an independent module	
//		return Updater#UpdateCheck(keyStr)
//	#endif
//
//	if(stringmatch(GetIndependentModuleName(), "ProcGlobal"))
//		return 0
//	endif
//	
//// Running as independent module, so will have to use execute.	
//// Find out whether procedures are compiled:
//
//	variable /G V_updated=0
//	variable isUpdated=0
//	string cmd, infoStr=FunctionInfo("ProcGlobal#updater#UpdateCheck", "Updater.ipf")
//
//	if (stringmatch(StringByKey("MODULE", infoStr), "updater"))	// updater is available AND compiled
//		sprintf cmd, "V_updated=ProcGlobal#Updater#UpdateCheck(\"%s\")", keyStr
//		execute cmd
//		isUpdated=V_updated
//	endif
//	
//	killvariables /Z V_updated
//
//	return isUpdated 
//end

// ------------------------------------------------------------------------------------------------------------

static constant kFREQUENCY=604800 // do not check more frequently than this. weekly=604800.
// you can override this setting by adding a copy of the above line to your procedure file and editing the value
// you can also override the default location for updates by adding something like this to your procedure:
// static strconstant ksLOCATION="http://www.igorexchange.com/node/8197/release" 

// ------------------------------------------------------------------------------------------------------------


menu "Help"
	"Updater: Check for new releases", /Q, updater#UpdateAll()
end

// We'll keep a very small binary file in the updater preferences folder to
// store the last update for each project that works with updater
static structure LastUpdateStructure
	uint32	 version		// Preferences structure version number. 100 means 1.00.
	uint32 lastUpdate	// 32 bits should be good for another 20 years or so...
	uint32 reserved[8]	// Reserved for future use
endStructure


// Wrapper function for update()
// This function is called from the file to be checked
static function UpdateCheck(keyList)
	string keyList
	
	variable updated=0
	
	NVAR /Z v_updater=v_updater // if this exists we want to check all open procedures for possible updates
	if (!NVAR_Exists(v_updater)) // avoid repeatedly checking this file
		// first find out whether this file needs updating
		string keyListThisFile=""
		keyListThisFile=ReplaceStringByKey("fileloc", keyListThisFile, FunctionPath(""))
		updated+=update(keyListThisFile)
	endif
	// now check the calling procedure file
	updated+=update(keyList)

	return updated
end


// Looks for procedure windows with defined modules that contain the 
// static CheckForUpdates function, and executes that function wherever 
// it is found. Only works for procedure files in which a regular module 
// name is defined.
static function UpdateAll()
	
	// Use a global variable to let UpdateCheck() function in this 
	// procedure know that we want to ignore the frequency setting and 
	// check now for updates to all files that use updater and have 
	// kCheckForUpdates set.
	variable /g v_updater=0
	
	string procList="", IMlist="", moduleList="", moduleStr="", IMstr="", cmd=""
	variable i,j, imax, jmax
	
	execute "SetIgorOption IndependentModuleDev=1" // would be good to record current status before setting this
	procList=winlist("*",";","WIN:128")
	execute "SetIgorOption IndependentModuleDev=0"
	IMlist=IndependentModuleList(";")	
	
	// loop through procedure windows
	imax=itemsinlist(procList)
	for(i=0; i<imax; i+=1)
		IMstr=""
		moduleStr=FunctionInfo("CheckForUpdates", stringfromlist(i,procList))
		moduleStr=StringByKey("MODULE", moduleStr)
		if(strlen(moduleStr)==0) // didn't find CheckForUpdates function
			// check to see if it's an independent module
			jmax=itemsinlist(IMlist)
			for(j=0;j<jmax;j+=1)
				IMstr=stringfromlist(j,IMlist)
				moduleStr=FunctionInfo(IMstr+"#CheckForUpdates", stringfromlist(i,procList))
				IMstr=StringByKey("INDEPENDENTMODULE", moduleStr)
				moduleStr=StringByKey("MODULE", moduleStr)
				if (strlen(IMstr))
					break
				endif
				IMstr=""
			endfor
		endif
		
		if (strlen(moduleStr))
			moduleStr+="#"
		endif
		if (strlen(IMstr))
			IMstr+="#"
		endif
		
		if (strlen(moduleStr)|| strlen(IMstr))
			moduleList=addlistitem(IMstr+moduleStr,moduleList)
		endif
	endfor

	// remove this procedure from the list
	moduleList=removefromlist("updater#",moduleList)
	
	// check this file first
	update("fileloc:"+FunctionPath(""))
	
	// now check other files
	imax=itemsinlist(moduleList)
	for(i=0; i<imax; i+=1)
		// make sure that we can execute the function within target procedure window
		v_updater=0
		sprintf cmd "v_updater=(exists(\"%sCheckForUpdates\")==6)", stringfromlist(i,moduleList)
		execute cmd
		if(v_updater)
			sprintf cmd "%sCheckForUpdates()", stringfromlist(i,moduleList)
			execute cmd
		endif
	endfor
	
	killvariables /Z v_updater
	return 1	
end

// Minimum amount of information required in file to be updated by this function:
// # pragma version
// static strconstant ksSHORTNAME (or #pragma moduleName corresponding to IgorExchange project shortname).
static function update(keyList)	
	string keyList
	
	// for now, these settings revert to default values when this file is updated, 
	// so don't rely on them sticking if you reset
	variable testing=0, archiveOldFile=0, chatty=0 // set to 1 for a lot of dialog 
	variable autoloadOption=1 // 1 will prompt user to create Igor Procedures alias

	variable releaseVersion, releaseIgorVersion, checkFrequency, err
	variable localVersion=0, selStart=-1, selEnd=-1
	variable currentIgorVersion=str2num(StringByKey("IGORFILEVERSION", igorinfo(3)))
	variable isZip
	
	string procPathStr="", shortName="", url="", webPageText="", cmd=""
	string prefsFile="", projectName="", system="", fileType="", downloadPathStr=""
	
	system=selectString(stringmatch(StringByKey("OS", igorinfo(3))[0,2],"Mac"), "Windows", "Macintosh")
	variable isWin=stringmatch(system[0,2],"Win")
	procPathStr=stringByKey("fileloc", keyList)
	if (strlen(procPathStr)==0)
		return 0
	endif
	
	// how frequently to run check
	Grep /Q/E="(?i)^[\s]*static[\s]*constant[\s]*kFREQUENCY[\s]*=" /LIST/Z procPathStr
	s_value=lowerStr(trimString(s_value, 1))
	sscanf s_value, "static constant kfrequency = %d", checkFrequency
	if(V_flag==0)
		checkFrequency=kFREQUENCY // default to value in THIS file
	endif
	
	NVAR /Z v_updater=v_updater // if this exists we want to check all open procedures for possible updates
	if (NVAR_Exists(v_updater))
		checkFrequency=0 // check now regardless of frequency setting 
	endif
	
	// find project shortname
	shortName=getUpdaterStringConst("ksSHORTNAME", procPathStr)
	if (strlen(shortName)==0)
		Grep /Q/E="(?i)#pragma[\s]*moduleName[\s]*=" /LIST/Z procPathStr
		if (strlen(s_value)==0)
			Grep /Q/E="(?i)#pragma[\s]*IndependentModule[\s]*=" /LIST/Z procPathStr
			if (strlen(s_value)==0)
				printf "Updater: No module name defined in %s\r" procPathStr
				return 0
			endif
		endif
		s_value=removeending(s_value,";")
		selStart=strsearch(s_value, "=", 0)+1
		selEnd=strsearch(s_value, "//", 0)
		selEnd = selEnd==-1 ? strlen(s_value)-1 : selEnd-1
		shortName=trimstring(s_value[selStart,selEnd])
	endif
	
	prefsFile=shortName+"LastUpdate.bin"
	
	// check for time of last update check
	STRUCT LastUpdateStructure s
	LoadPackagePreferences "updater", prefsFile, 1, s
	if (V_flag!=0 || V_bytesRead==0)
		s.version=200
		s.lastUpdate=0
		SavePackagePreferences "updater", prefsFile, 1, s		
	endif
	
	if ((datetime-s.lastUpdate)<checkFrequency && !testing)
		return 0 // silently give up
	endif	
	
	// where do we look for updates?
	// first check whether specified in file
	url=getUpdaterStringConst("ksLOCATION", procPathStr)
	if (strlen(url)==0)
		// check the project page on IgorExchange
		sprintf url, "https://www.wavemetrics.com/project/%s", shortName
		webPageText=FetchURL(url); err = GetRTError(1)
		if (err != 0)
			printf "Updater could not load %s\r", url
			return 0
		endif
		// find the link to the 'all releases' page for this project
		selEnd=strsearch(webPageText, ">View all releases</a>", 0, 2)
		selStart=strsearch(webPageText, "href=", selEnd, 3)
		if (selEnd==-1 || selStart==-1)
			return 0
		endif
		url="https://www.wavemetrics.com"+webPageText[selStart+6,selEnd-2]
	endif
	
	// version number of local file	
	Grep /Q/E="(?i)^#pragma[\s]*version[\s]*=" /LIST/Z procPathStr
	s_value=lowerStr(trimString(s_value, 1))
	sscanf s_value, "#pragma version = %f", localVersion
	if (V_flag!=1 || localVersion<=0)
		printf "Could not find version pragma in %s\r", parseFilePath(0, procPathStr, ":", 1, 0)
		return 0
	endif
	
	if(chatty)
		sprintf cmd, "Check for updates to %s?", shortName
		doalert 1, cmd
		if (v_flag==2)
			return 0
		endif
	endif
	printf "%s: Checking for updates... ", shortName
	
	s.lastUpdate=datetime // will be rounded to 32 bit integer
	SavePackagePreferences "updater", prefsFile, 1, s

	webPageText = FetchURL(url); err = GetRTError(1)
	if (err != 0)
		sprintf cmd, "Could not load %s", url
		print cmd
		if(chatty)
			doalert 0, cmd
		endif
		return 0
	endif
	
	// Look for new releases. If the web page location is not IgorExchange, 
	// ParseReleases will have to be changed to take into account the format 
	// of the web page.
	make /free/n=(0,4)/T w_releases
	if(ParseReleases(webPageText, w_releases)==0)
		sprintf cmd, "Could not find packages at %s.\r", url
		cmd+="\tPlease check for new versions at https://www.wavemetrics.com/projects"
		if (chatty)
			doalert 0, cmd
		endif
		print cmd
		return 0
	endif	
	
	variable i
	url=""
	for(i=0;i<dimsize(w_releases, 0);i+=1)
		projectName = w_releases[i][0]
		sscanf w_releases[i][1], "%f.x-%f", releaseIgorVersion, releaseVersion
		if(i==0 && localVersion>=releaseVersion)
			sprintf cmd, "Current version (%g) is the most recent release\r", localVersion
			if (chatty)
				doalert 0, cmd
			endif
			print cmd
			return 0
		endif
		
		if(releaseVersion>localVersion)
			if(currentIgorVersion<releaseIgorVersion)
				printf "%s %g requires Igor Pro version >= %g\r", projectName, releaseVersion, releaseIgorVersion
			elseif(FindListItem(system, w_releases[i][3])==-1)
				printf "%s %g not available for %s\r", projectName, releaseVersion, system
			else
				url=w_releases[i][2]
				break
			endif
		endif	
	endfor
	
	if (strlen(url)==0)
		return 0
	endif
	
	fileType=parseFilePath(4, url,":", 0, 0)
	isZip=stringMatch(fileType, "zip")
	
	if(cmpstr(fileType, "ipf") && cmpstr(fileType, "zip")) 
		printf "New version of %s released\r", projectName
		printf "Updater couldn't find a useable file at %s\r", url
		return 0
	endif
	
	if (chatty)
		sprintf cmd, "%s: Found version %g. Download now?", projectName, releaseVersion
		doalert 1, cmd
		if (v_flag==2) // print file location for manual download
			printf "New version of %s available at %s\r", projectName, url
			return 0
		endif
	endif
		
	if(testing)
		// for testing, don't hit server pointlessly
		printf "testing: substituting local file for %s\r", url
		url="file://C:/Users/tony/Desktop/archive.zip"
		url="file:///Users/tony/Desktop/archive.zip"
		isZip=1
	endif
	
	// download the package file
	webPageText=FetchURL(url); err = GetRTError(1)
	if (err != 0)
		sprintf cmd, "Updater couldn't load %s", url
		print cmd
		if(chatty)
			doalert 0, cmd
		endif
		return 0
	endif	

	printf "Downloaded %s version %g from %s\r", projectName, releaseVersion, url
	
	if(archiveOldFile) // this will archive just the ipf file
		string oldFileprocPathStr
		sprintf oldFileprocPathStr, "%s%s%g.%s", SpecialDirPath("Desktop",0,0,0), parseFilePath(3, procPathStr, ":", 0, 0), localVersion, parseFilePath(4, procPathStr, ":", 0, 0) 
		
		variable flagI=0
		getFileFolderInfo /Q/Z oldFileprocPathStr
		if(v_flag==0) // file already exists in archive location
			flagI=2 // check before overwriting
		endif
		
		movefile /O/S="Archive current file"/I=(flagI)/Z  procPathStr as oldFileprocPathStr
		if(v_flag==0)
			printf "Saved copy of %s version %g to %s\r", projectName, localVersion, s_path
		endif
	endif
	
	// make sure we have somewhere to write our download
	if(isZip)
		downloadPathStr=SpecialDirPath("Desktop",0,0,0)+parseFilePath(0, url,"/", 1, 0)
	else
		downloadPathStr=procPathStr
	endif
	
	getFileFolderInfo /Q/Z downloadPathStr	
	if (v_flag==0)
		cmd=""
		if (!chatty)
			sprintf cmd, "New update found for %s\r", projectName
		endif
		// Aways ask before overwriting file
		if (isZip)
			sprintf cmd, "%sOverwrite %s?", cmd, parseFilePath(0, downloadPathStr, ":", 1, 0)
		else
			sprintf cmd, "%sOverwrite %s with %s version %g?", cmd, parseFilePath(0, downloadPathStr, ":", 1, 0), projectName, releaseVersion
		endif
		doalert 1, cmd
		if(v_flag==2)
			printf "%s: update cancelled\r", projectName
			return 0
		endif	
	endif
	
	// write download to target ipf file or to zip file on desktop
	variable refNum=0
	open /Z refNum as downloadPathStr
	if(refNum==0)
		return 0
	endif
	FBinWrite refNum, webPageText
	close refNum
	
	if(isZip) // assume that contents of zip file go into same folder as current ipf file
		downloadPathStr=unzipPackage(shortName, downloadPathStr, packagePathStr=ParseFilePath(1, procPathStr, ":", 1, 0))
		if (strlen(downloadPathStr)==0)
			return 0
		endif
	endif
	
	printf "Updated %s to version %g\r", projectName, releaseVersion
		
	string IgorProcPathStr=SpecialDirPath("Igor Pro User Files",0,0,0)+"Igor Procedures:"

	if(autoloadOption==1 && strlen(FindAlias(IgorProcPathStr, procPathStr))==0)
		sprintf cmd "Create %s in Igor Procedure to autoload %s?", selectstring(isWin, "alias", "shortcut"), projectName
		doAlert 1, cmd
		if (v_flag==1)
			createAliasShortcut procPathStr as IgorProcPathStr+ParseFilePath(3, procPathStr, ":", 0, 0)+selectstring(isWin, "Alias", "Shortcut") 
		endif			 
	endif
	
	return 1
end


// Parse html in s_web to find releases. 
static function ParseReleases(WebPageText, w_releases)
	string WebPageText
	wave /T w_releases
		
	variable selStart=-1, selEnd=-1, blockStart, blockEnd, selFound
	string url="", projectName="", releaseText="", platform=""
	variable i=0
	
	do
		// find start and end of project release fields
		selStart= strsearch(WebPageText, "<div class=\"project-release-info\">", selStart, 2)
		if(selStart==-1)
			break
		endif
		blockStart=selStart
		selEnd=strsearch(WebPageText, "<div class=\"project-release-footer\">", selStart, 2)
		if(selEnd==-1)
			break
		endif
		blockEnd=selEnd
		
		selStart=strsearch(WebPageText, "<h2>", blockStart, 2)
		selEnd=strsearch(WebPageText, "IGOR.", selStart, 0)
		projectName=trimstring(WebPageText[selStart+4, selEnd-1])
		
		selStart=selEnd+5
		selEnd=strsearch(WebPageText, "</h2>", selStart, 2)
		releaseText=WebPageText[selStart, selEnd-1]
		
		selStart=strsearch(WebPageText, "<span class=\"field-paragraph-file\">", selEnd, 2)
		selStart=strsearch(WebPageText, "<a href=\"", selStart, 2)
		selStart+=9
		selEnd=strsearch(WebPageText, "\"", selStart, 2)
		if(selStart<blockStart || selEnd>blockEnd)
			break
		endif
		url=WebPageText[selStart, selEnd-1]
				
		platform=""
		selFound=strsearch(WebPageText, "<span class=\"entity-reference\">Windows</span>", blockStart, 2)
		if(selFound>blockStart && selFound<blockEnd)
			platform+="Windows;"
		endif
		selFound=strsearch(WebPageText, "<span class=\"entity-reference\">Mac-", blockStart, 2)
		if(selFound>blockStart && selFound<blockEnd)
			platform+="Macintosh;"
		endif		
		if(strlen(projectName)==0 || strlen(releaseText)==0 || strlen(url)==0)
			break
		endif
		w_releases[dimsize(w_releases,0)][]={{projectName},{releaseText},{url},{platform}}
		selStart=blockEnd
		i+=1
	while (i<1000)
	return dimsize(w_releases,0)	
end

// Parse html in s_web to find releases. 
static function oldParseReleases(WebPageText, w_releases)
	string WebPageText
	wave /T w_releases
		
	variable selStart=-1, selEnd=-1, blockStart, selFound
	string url="", projectName="", releaseText="", platform=""
	variable i=0
	
	do
		selStart= strsearch(WebPageText, "<div class=\"node project_release\">", selStart, 2)
		if(selStart==-1)
			break
		endif
		blockStart=selStart
		selStart=strsearch(WebPageText, "<a href=", selStart, 2)
		selStart=strsearch(WebPageText, ">", selStart, 2)
		selEnd=strsearch(WebPageText, "IGOR.", selStart, 0)
		projectName=trimstring(WebPageText[selStart+1, selEnd-1])
		selStart=selEnd+5
		selEnd=strsearch(WebPageText, "</a>", selStart, 2)
		releaseText=WebPageText[selStart, selEnd-1]
		selStart=strsearch(WebPageText, "<div class=\"project-release\">", selEnd, 2)
		selStart=strsearch(WebPageText, "Download: ", selStart, 2)
		selStart=strsearch(WebPageText, "\"", selStart, 2)
		selEnd=strsearch(WebPageText, "\"", selStart+1, 2)
		url=WebPageText[selStart+1, selEnd-1]
		platform=""
		selFound=strsearch(WebPageText, "Supported on Windows", blockStart, 2)
		if(selFound>blockStart && selFound<selEnd)
			platform+="Windows;"
		endif
		selFound=strsearch(WebPageText, "Supported on the Macintosh", blockStart, 2)
		if(selFound>blockStart && selFound<selEnd)
			platform+="Macintosh;"
		endif		
		if(strlen(projectName)==0 || strlen(releaseText)==0 || strlen(url)==0)
			break
		endif
		w_releases[dimsize(w_releases,0)][]={{projectName},{releaseText},{url},{platform}}
		selStart=selEnd
		i+=1
	while (i<1000)
	return dimsize(w_releases,0)	
end

// extract a static string constant from a procedure file by reading from disk
static function /T getUpdaterStringConst(constantNameStr, pathToFile)
	string constantNameStr, pathToFile
	
	string s_exp="", s_out=""
	sprintf s_exp, "(?i)^[\s]*static[\s]*strconstant[\s]*%s[\s]*=", constantNameStr	
	Grep /Q/E=s_exp/LIST/Z pathToFile
	variable start, stop
	start=strsearch(s_value, "\"", 0)
	stop=strsearch(s_value, "\"", start+1)
	if (start<0 || stop<0)
		return ""
	endif
	return s_value[start+1,stop-1]
end


// ----------------------- prototype installer code -----------------------

// install a package hosted on IgorExchange.com
// packageName is the project short name
// Looks for install.itx within package folder and executes if found.
// install.itx should create shortcuts for help files and XOPs as needed.
// Use installWindows.itx or installMacintosh.itx for OS specific installations.

// install("foo") installs IgorExchange package with shortname foo in a 
// location within the Igor User Files folder chosen by the user. 

// install("foo;bar;", location=SpecialDirPath("Igor Pro User 
// Files",0,0,0)+"User Procedures:") installs packages foo and bar in the
// User Procedures folder.

// if location is supplied for zip archive(s), subfolders are not created!
function install(packageList, [location])
	string packageList, location

	variable testing=0, autoloadOption=1 // 1 will prompt user if it looks like autoload can be set up
	
	string url, webPageText, projectName, cmd
	string IncludeProcStr="", packagePathStr="", packageName=""
	variable selStart, selEnd, releaseIgorVersion, releaseVersion, refNum, err
	variable i, ListIndex=0
	
	variable currentIgorVersion=str2num(StringByKey("IGORFILEVERSION", igorinfo(3)))
	string system=selectString(stringmatch(StringByKey("OS", igorinfo(3))[0,2],"Mac"), "Windows", "Macintosh")
	variable isWin=stringmatch(system[0,2],"Win")
			
	do
		packageName=stringfromlist(ListIndex, packageList)
		if(strlen(packageName)==0)
			break
		endif
	
		// check the project page on IgorExchange
		sprintf url, "https://www.wavemetrics.com/project/%s", packageName
		webPageText=FetchURL(url); err = GetRTError(1)
		if (err != 0)
			printf "Installer could not load %s\r", url
			continue
		endif
		printf "Found %s at %s\r", packageName, url
		
		// find the link to the 'all releases' page for this project
		selEnd=strsearch(webPageText, ">View all releases</a>", 0, 2)
		selStart=strsearch(webPageText, "href=", selEnd, 3)
		if (selEnd==-1 || selStart==-1)
			printf "Installer could not find releases at %s\r", url
			continue
		endif
		url="https://www.wavemetrics.com"+webPageText[selStart+6,selEnd-2]
		
		// try to download 'all releases' page
		webPageText = FetchURL(url); err = GetRTError(1)
		if (err != 0)
			printf "Could not load %s", url
			continue
		endif
		printf "Looking for releases at %s\r", url
		
		// parse page to populate w_releases
		make /free/n=(0,4)/T w_releases
		if(ParseReleases(webPageText, w_releases)==0)
			printf "Could not find packages at %s.\r", url
			continue
		endif	
		
		// find most recent OS- and version-compatible release
		url=""
		for(i=0;i<dimsize(w_releases, 0);i+=1)
			projectName = w_releases[i][0]
			sscanf w_releases[i][1], "%f.x-%f", releaseIgorVersion, releaseVersion
	
			if(currentIgorVersion<releaseIgorVersion)
				printf "%s %g requires Igor Pro version >= %g\r", projectName, releaseVersion, releaseIgorVersion
			elseif(FindListItem(system, w_releases[i][3])==-1)
				printf "%s %g not available for %s\r", projectName, releaseVersion, system
			else
				url=w_releases[i][2]
				break
			endif
		endfor
		if (strlen(url)==0)
			continue
		endif
						
		if(testing)
			// for testing, don't hit server pointlessly
			printf "testing: substituting local file for %s\r", url
			url="file://C:/Users/tony/Desktop/archive.zip"
			url="file:///Users/tony/Desktop/archive.zip"	
		endif
		
		// download package
		webPageText=FetchURL(url); err = GetRTError(1)
		if (err != 0)
			printf "Could not load %s", url
			continue
		endif
		printf "Downloaded %s\r", url
		
		// where to save the downloaded file - a temporary location
		// safe to edit this, but will overwrite!
		string downloadPathStr
	
		downloadPathStr=SpecialDirPath("Desktop",0,0,0)+"IgorPackageInstallerTemp:"
		newpath /C/O/Q downloadPathTemp, downloadPathStr
		killpath /z downloadPathTemp
			
		// save file to disk
		open /Z refNum as downloadPathStr+parseFilePath(0, url,"/", 1, 0)
		if(refNum==0)
			continue
		endif
		FBinWrite refNum, webPageText
		close refNum // S_fileName created by open
		printf "Saved temporary file %s\r", S_fileName
						
		// consider only two possibilities: an uncompressed ipf file or a zip archive
		if (stringmatch(parseFilePath(4, S_fileName,":", 0, 0), "zip"))
			if(paramisdefault(location))	
				// unzipPackage will prompt user for install path
				// package folder will be created if necessary
				packagePathStr=unzipPackage(packageName, S_fileName)
			else
				getfileFolderInfo /Q/Z location
				if(v_flag!=0 || V_isFolder==0)
					printf "Install path not found: %s\r", location
					continue
				endif
				packagePathStr=unzipPackage(packageName, S_fileName, packagePathStr=location)
			endif
			if (strlen(packagePathStr)==0)
				continue
			endif
			
			string ipfList="", ipfStr=""
			newpath /C/O/Q packagePathTemp, packagePathStr
			i=0
			do
				ipfStr=IndexedFile(packagePathTemp, i, ".ipf")
				if(!strlen(ipfStr))
					break
				endif
				ipfStr=removeending(ipfStr, ".ipf")
				ipfList=AddListItem(ipfStr, ipfList)
				i+=1
			while(1)
			killpath /z packagePathTemp
			if(i==1) // only one procedure file at top level of package folder
				IncludeProcStr=StringFromList(0, ipfList)
			elseif(i>1 && (WhichListItem(packageName, ipfList)!=-1) )
				// package folder includes a procedure with project name
				IncludeProcStr=packageName
			endif
			// if there's an XOP in the package, don't try to open any procedure file
			if(strlen(FindFile(packagePathStr,"*.xop")))
				IncludeProcStr=""
			endif
				
			// Look for and run itx-format installation script. Script will run
			// from within the package folder saved in location of user's 
			// choice within Igor Pro User Files folder. 
			string msg
			string pathToScriptStr=""
			getFileFolderInfo /Q/Z packagePathStr+"install.itx"
			if (V_Flag==0) // s_path has been reset by getFileFolderInfo
				pathToScriptStr=s_path
			else
				getFileFolderInfo /Q/Z packagePathStr+"install"+system+".itx"
				if (V_Flag==0) // s_path has been reset by getFileFolderInfo
					pathToScriptStr=s_path
				endif
			endif
			if(strLen(pathToScriptStr)) // script could do naughty things, so ask before allowing it to run
				sprintf msg, "Run installation script?\r%s was downloaded from %s", ParseFilePath(0, pathToScriptStr, ":", 1, 0), url 
				doAlert 1, msg
				if (v_flag==1)
					sprintf cmd, "Loadwave /T \"%s\"", s_path
					execute cmd // will be printed to history
				endif
			endif
			
		elseif(stringmatch(parseFilePath(4, S_fileName,":", 0, 0), "ipf"))
			if(paramisdefault(location))	
				packagePathStr=ChooseInstallLocation(packageName)
			else
				getfileFolderInfo /Q/Z location
				if(v_flag==0)
					printf "Install path not found: %s\r", location
					continue
				endif
				packagePathStr=location
			endif
			getFileFolderInfo /Q/Z packagePathStr+packageName+".ipf"
			if (v_flag==0) // already exists
				doalert 1, "overwrite "+packageName+".ipf?"
				if (v_flag==2)
					continue
				endif
			endif
			// S_filename still set by open
			movefile /O/Z 	S_fileName as packagePathStr+packageName+".ipf"
			if(V_flag!=0)
				continue
			endif
			IncludeProcStr=packageName
			printf "Saved %s in %s\r", packageName+".ipf", packagePathStr
		endif
		
		if (strlen(IncludeProcStr)) // found a 'master' procedure file
			
			if(autoloadOption==1)
				// find out whether an alias already exists
				string IgorProcPathStr=SpecialDirPath("Igor Pro User Files",0,0,0)+"Igor Procedures:"
				string targetPathStr=packagePathStr+IncludeProcStr+".ipf"
				autoloadOption=(strlen(FindAlias(IgorProcPathStr, targetPathStr))==0)
				// make sure target isn't in Igor Procedures folder
				if(autoloadOption && stringmatch(targetPathStr, IgorProcPathStr+"*")==0)
					string aliasName=ParseFilePath(3, targetPathStr, ":", 0, 0)+selectstring(isWin, " Alias", " Shortcut")
					sprintf cmd "Create %s alias in Igor Procedures to autoload %s?", ParseFilePath(0, targetPathStr, ":", 1, 0), packageName
					doAlert 1, cmd
					if (v_flag==1)
						createAliasShortcut targetPathStr as IgorProcPathStr+aliasName
						printf "Created %s in %s\r", aliasName, IgorProcPathStr
					endif 
				endif
			endif
			
			// find out if procedure is already loaded
			wave /T w_loadedProcs=ListToTextWave(winlist("*",";","WIN:128,INDEPENDENTMODULE:1"),";")
			w_loadedProcs=extractFilename(w_loadedProcs)
			FindValue /TEXT=IncludeProcStr/TXOP=4 /Z w_loadedProcs
			
			if(V_Value==-1)
				// load the procedure
				sprintf cmd, "INSERTINCLUDE \"%s\"", IncludeProcStr
				Execute/P/Q/Z cmd
				Execute/P/Q/Z "COMPILEPROCEDURES "
				printf "Included %s in current experiment\r", IncludeProcStr
			endif
						
		endif
		
		ListIndex+=1
	while(1)
	
	return 1	
end

// strip trailing stuff in the output from winlist
static function /S extractFilename(s)
	string s
	
	SplitString/E=".*\.ipf" s // remove module names
	return removeending(s_value, ".ipf")
end

// Inflates zip archive to a temporary folder, moves temporary folder to 
// destination in Igor Pro User Files.
static function /S unzipPackage(shortName, archivePathStr, [packagePathStr])
	string shortName, archivePathStr, packagePathStr
	
	GetFileFolderInfo /Q/Z archivePathStr
	if(V_Flag || V_isFile==0)
		return ""
	endif
	
	variable CreatePackageFolder=0
	
	if(paramIsDefault(packagePathStr))
		CreatePackageFolder=1
		packagePathStr=ChooseInstallLocation(shortName)
		// find out whether user has chosen an existing subfolder with the name of the project
		if(stringmatch(ParseFilePath(0, packagePathStr, ":", 1, 0), shortName)==1)
			CreatePackageFolder=0
		endif
	endif
	
	if (strlen(packagePathStr)==0)
		return ""
	endif
	
	string system=selectString(stringmatch(StringByKey("OS", igorinfo(3))[0,2],"Mac"), "Windows", "Macintosh")
	variable isWin=stringmatch(system[0,2],"Win")
	
	//string tmpPathStr=SpecialDirPath("Temporary",0,0,0), tmpDirStr=""
	string tmpPathStr=SpecialDirPath("Desktop",0,0,0)+"IgorPackageInstallerTemp:", tmpDirStr=""
	newpath /C/O/Q unzipPath, tmpPathStr // make sure folder exists on disk
	
	variable i=0
	do
		sprintf tmpDirStr,"InstallerTemp%d", i
		GetFileFolderInfo /Q/Z tmpPathStr+tmpDirStr
		i+=1
	while(V_Flag==0)
	
	string unzipPathStr=tmpPathStr+tmpDirStr+":"
	
	// create a temporary directory for the uncompressed files
	newpath /C/O/Q unzipPath, unzipPathStr
	
	// inflate archive
	if(isWin)
		#if(exists("ZIPfile")==4)
			ZIPfile /O/X unzipPathStr, archivePathStr // this creates a folder that cannot be moved!
			// maybe a problem with the ZIP xop (I tested with Windows 10, Igor64).			
		#else
			print "please install ZIP64 XOP from http://www.igorexchange.com/project/ZIP"
			return ""
		#endif
	else
		unzipArchive(archivePathStr, unzipPathStr)
	endif
	
	printf "Inflated %s to %s\r", ParseFilePath(0, archivePathStr, ":", 1, 0), unzipPathStr
	
	string fileList=IndexedFile(unzipPath, -1, "????")
	string folderList=IndexedDir(unzipPath, -1, 0)
	killpath /Z unzipPath
	
	// ignore pesky __MACOSX folder
	i=0
	do
		if(stringmatch(StringFromList(i, folderList), "__MACOSX"))
			folderList=removeListItem(i, folderList)
		else
			i+=1
		endif		
	while (i<itemsinlist(folderList))
	
	if (itemsinlist(fileList)==0 && itemsinlist(folderList)==1)
		// inflated files are inside a subfolder of unzipPathStr
		unzipPathStr+=stringfromlist(0, folderList)+":"
	endif
	
	if (itemsinlist(fileList)==1 && itemsinlist(folderList)==0) 
		// archive contains just one file - don't create a subfolder
		getFileFolderInfo /Q/Z packagePathStr+stringfromlist(0,fileList)
		if (v_flag==0) // already exists
			doalert 1, "Overwrite "+stringfromlist(0,fileList)+"?"
			if (v_flag==2)
				return ""
			endif
		endif
		unzipPathStr+=stringfromlist(0,fileList)
		MoveFile /O/Z unzipPathStr as packagePathStr+stringfromlist(0,fileList)
	else
		if(CreatePackageFolder)
			packagePathStr+=shortName+":"
		endif
		if(isWin) // zip64 xop locks folder, so move files and subfolders one by one
			newpath /C/O/Q installPathTemp, packagePathStr
			killPath /Z installPathTemp
			for(i=0;i<itemsinlist(folderList);i+=1)
				moveFolder /O/Z unzipPathStr+stringfromlist(i,folderList) as packagePathStr+stringfromlist(i,folderList)		
			endfor
			for(i=0;i<itemsinlist(fileList);i+=1)
						
				// No warning for overwrite?
				
				moveFile /O/Z unzipPathStr+stringfromlist(i,fileList) as packagePathStr+stringfromlist(i,fileList)
			endfor			
		else
			// move inflated files to packagePathStr folder: will overwrite (with a warning)!
			moveFolder /O/Z removeEnding(unzipPathStr,":") as removeEnding(packagePathStr,":")
		endif
	endif
	
	// need to consider case of package that includes an XOP.
	
	if(strlen(s_path)==0) // s_path set by moveFile or moveFolder
		return ""
	endif
	
	printf "Moved %s to %s\r", unzipPathStr, packagePathStr		
	
	// need to figure out how to clean up 
	printf "Please remove these files manually to clean up after installation:\r   %s\r   %s\r", tmpPathStr, archivePathStr
	
	return packagePathStr
end


// returns a path to a subfolder of Igor Pro User Files selected by user
static function /S ChooseInstallLocation(packageName)
	string packageName
		
	variable success
	string cmd
	if(strlen(packageName))
		packageName=" "+packageName
	endif
	sprintf cmd, "Where would you like to install%s?", packageName
	do
		success=1
		NewPath /O/Q/Z TempInstallPath SpecialDirPath("Igor Pro User Files",0,0,0)+"User Procedures:"
		pathinfo /S TempInstallPath
		NewPath /M=cmd /O/Q/Z TempInstallPath
		if(v_flag)
			return ""
		endif
		pathinfo /S TempInstallPath
		if(stringmatch(S_path, SpecialDirPath("Igor Pro User Files",0,0,0)+"*")==0)
			doalert 0, "Please select a location within the Igor Pro User Files folder\r(usually in the User Procedures folder)"
			success=0
		endif
		if(stringmatch(S_path, SpecialDirPath("Igor Pro User Files",0,0,0)))
			doalert 0, "Please select a subfolder within the Igor Pro User Files folder\r(usually in the User Procedures folder)"
			success=0
		endif
	while(!success)
	killpath /Z TempInstallPath
	return S_path
end	

// For mac. On Windows, use Andrew Nelson's ZIP XOP.
// http://www.igorexchange.com/project/ZIP
function unzipArchive(archivePathStr, unzippedPathStr)
	string archivePathStr, unzippedPathStr
		
	string validExtensions="zip;" // set to "" to skip check
	variable verbose=1 // choose whether to print output from executescripttext
	string msg, unixCmd, igorCmd
	
	if(stringmatch(StringByKey("OS", igorinfo(3))[0,2],"Win"))
		return 0
	endif
		
	GetFileFolderInfo /Q/Z archivePathStr

	if(V_Flag || V_isFile==0)
		printf "Could not find file %s\r", archivePathStr
		return 0
	endif

	if(itemsInList(validExtensions) && findlistItem(ParseFilePath(4, archivePathStr, ":", 0, 0), validExtensions, ";", 0, 0)==-1)
		printf "%s doesn't appear to be a zip archive\r", ParseFilePath(0, archivePathStr, ":", 1, 0)
		return 0
	endif
	
	if(strlen(unzippedPathStr)==0)
		unzippedPathStr=SpecialDirPath("Desktop",0,0,0)+ParseFilePath(3, archivePathStr, ":", 0, 0)
		sprintf msg, "Unzip to %s:%s?", ParseFilePath(0, unzippedPathStr, ":", 1, 1), ParseFilePath(0, unzippedPathStr, ":", 1, 0)
		doALert 1, msg
		if (v_flag==2)
			return 0
		endif
	else
		GetFileFolderInfo /Q/Z unzippedPathStr
		if(V_Flag || V_isFolder==0)
			sprintf msg, "Could not find unzippedPathStr folder\rCreate %s?", unzippedPathStr
			doalert 1, msg
			if (v_flag==2)
				return 0
			endif
		endif	
	endif
	
	// make sure unzippedPathStr folder exists
	newpath /C/O/Q acw_tmpPath, unzippedPathStr
	killpath /Z acw_tmpPath
	
	sprintf unixCmd, "unzip %s -d %s", ParseFilePath(5, archivePathStr, "/", 0,0), ParseFilePath(5, unzippedPathStr, "/", 0,0)
	sprintf igorCmd, "do shell script \"%s\"", unixCmd
	
	executescripttext /UNQ/Z igorCmd
	if(verbose)
		print S_value // output from executescripttext
	endif
	
	return (v_flag==0)
end

// returns full path to alias if found, otherwise ""
static function /T FindAlias(folderPathStr, targetPathStr)
	String folderPathStr, targetPathStr
	
	variable maxLevels=5 // quit after recursion through this many sublevels
	variable folderLimit=20 // quit after looking in this many folders.
	Variable folderIndex, fileIndex, subfolderIndex, folderCount=1, sublevels=0
	string folderList

	if (strlen(folderPathStr)==0 || strlen(targetPathStr)==0)
		return ""
	endif
		
	make /free/T/n=0 w_folders, w_subfolders
	w_folders={folderPathStr}

	do
		for(folderIndex=0;folderIndex<numpnts(w_folders);folderIndex+=1)
			// check files at current level
			newPath /O/Q/Z tempPath, w_folders[folderIndex]
			fileindex=0
			do
				getFileFolderInfo /P=tempPath/Q/Z IndexedFile(tempPath, fileindex, "????")
				if(V_isFile==0)
					break
				endif
				if(V_isAliasShortcut && stringmatch(S_aliasPath, targetPathStr))
					killpath /Z tempPath
					return s_path // set by getFileFolderInfo
				endif
				fileindex+=1
			while(1)
			// make a list of subfolders in current folder
			folderList=IndexedDir(tempPath, -1, 0)
			for (subfolderIndex=0;subfolderIndex<itemsinList(folderList);subfolderIndex+=1)
				w_subfolders[numpnts(w_subfolders)]={w_folders[folderIndex]+stringfromlist(subfolderIndex,folderList)+":"}				
				folderCount+=1
			endfor			
		endfor
		duplicate /T/O/free w_subfolders, w_folders
		redimension /N=0 w_subfolders
		sublevels+=1
		
		if(numpnts(w_folders)==0)
			break
		endif
		
		if(sublevels>maxLevels || (folderCount-folderIndex)>folderLimit)
			break
		endif

	while(1)
	killpath /Z tempPath
	return ""
end

// Search recursively for s_file within folder described by folderPathStr.
// Don't expect this to be quick.
// Returns path to file. Wildcards okay.
static function /T FindFile(folderPathStr, fileName)
	String folderPathStr, fileName
	
	variable maxLevels=10 // quit after recursion through this many sublevels
	variable folderLimit=5000 // quit after looking in this many folders.
	Variable folderIndex, fileIndex, subfolderIndex, folderCount=1, sublevels=0
	string folderList, indexFileName

	if (strlen(folderPathStr)==0)
		// it would be nice to default to the current save location, but I couldn't find a way to do that
		folderPathStr=SpecialDirPath("Documents", 0, 0, 0)
	endif
		
	make /free/T/n=0 w_folders, w_subfolders
	w_folders={folderPathStr}

	do
		for(folderIndex=0;folderIndex<numpnts(w_folders);folderIndex+=1)
			// check files at current level
			newPath /O/Q/Z tempPathFF, w_folders[folderIndex]

			fileindex=0
			do	
				indexFileName=IndexedFile(tempPathFF, fileindex, "????")
				if(stringmatch(indexFileName, fileName))
					killpath /Z tempPathFF
					return w_folders[folderIndex]+indexFileName
				endif
				fileindex+=1
			while(strlen(indexFileName))
			// make a list of subfolders in current folder
			folderList=IndexedDir(tempPathFF, -1, 0)
			for (subfolderIndex=0;subfolderIndex<itemsinList(folderList);subfolderIndex+=1)
				w_subfolders[numpnts(w_subfolders)]={w_folders[folderIndex]+stringfromlist(subfolderIndex,folderList)+":"}				
				folderCount+=1
			endfor			
		endfor
		duplicate /T/O/free w_subfolders, w_folders
		redimension /N=0 w_subfolders
		sublevels+=1
		
		if(numpnts(w_folders)==0)
			break
		endif
		
		if(sublevels>maxLevels || (folderCount-folderIndex)>folderLimit)
			break
		endif

	while(1)
	killpath /Z tempPathFF
	return ""
end


// search recursively in folderPathStr for files matching fileName.
// returns list of complete paths to files
static function /T RecursiveFileList(folderPathStr, fileName)
	String folderPathStr, fileName
	
	variable maxLevels=5 // quit after recursion through this many sublevels
	variable folderLimit=500 // quit after looking in this many folders.
	Variable folderIndex, fileIndex, subfolderIndex, folderCount=1, sublevels=0
	string folderList, indexFileName
	string fileList=""

	if (strlen(folderPathStr)==0)
		return ""
	endif
		
	make /free/T/n=0 w_folders, w_subfolders
	w_folders={folderPathStr}

	do
		for(folderIndex=0;folderIndex<numpnts(w_folders);folderIndex+=1)
			// check files at current level
			newPath /O/Q/Z tempPathFF, w_folders[folderIndex]

			fileindex=0
			do	
				indexFileName=IndexedFile(tempPathFF, fileindex, "????")
				if(stringmatch(indexFileName, fileName))
					fileList=AddListItem(w_folders[folderIndex]+indexFileName, fileList)
				endif
				fileindex+=1
			while(strlen(indexFileName))
			// make a list of subfolders in current folder
			folderList=IndexedDir(tempPathFF, -1, 0)
			for (subfolderIndex=0;subfolderIndex<itemsinList(folderList);subfolderIndex+=1)
				w_subfolders[numpnts(w_subfolders)]={w_folders[folderIndex]+stringfromlist(subfolderIndex,folderList)+":"}				
				folderCount+=1
			endfor			
		endfor
		duplicate /T/O/free w_subfolders, w_folders
		redimension /N=0 w_subfolders
		sublevels+=1
		
		if(numpnts(w_folders)==0)
			break
		endif
		
		if(sublevels>maxLevels || (folderCount-folderIndex)>folderLimit)
			break
		endif

	while(1)
	killpath /Z tempPathFF
	return fileList
end