#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.10 // 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
// If the project release is a zip archive, Updater downloads the archive
// to a temporary location on the desktop, and moves all of the contents 
// to a location in the User Procedures folder based on the location of 
// the ipf file to be updated. For this to work, the zip archive had 
// better have a straightforward structure. Caveat emptor!

// 	-- Wishlist
// 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.
// On a computer running some kind of communication blocking software the
// code could stall at the FetchURL lines. Maybe switching to URLRequest 
// would help? I don't have an easy way to test. 

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

// -- 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="https://www.wavemetrics.com/project-releases/1234" 

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


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=0 // 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, refNum=0
	
	string procPathStr="", shortName="", url="", webPageText="", cmd=""
	string prefsFile="", projectName="", system="", fileType=""
	string downloadPathStr="", ipfName="", packagePathStr="", archiveName="", archivePathStr=""
	
	system=selectString(stringmatch(StringByKey("OS", igorinfo(3))[0,2],"Mac"), "Windows", "Macintosh")
	variable isWin=stringmatch(system[0,2],"Win")
	procPathStr=stringByKey("fileloc", keyList) // path to procedure file to be updated
	if (strlen(procPathStr)==0)
		return 0
	endif
	ipfName=parseFilePath(0, procPathStr, ":", 1, 0) // name of procedure file to be updated
	packagePathStr=parseFilePath(1, procPathStr, ":", 1, 0) // path to folder containing procedure file
	
	// 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", ipfName
		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.
	
	wave /T w_releases=ParseReleases(webPageText)
	if (dimsize(w_releases,0)==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])[5,inf], "%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][5])==-1)
				printf "%s %g not available for %s\r", projectName, releaseVersion, system
			else
				url=w_releases[i][4]
				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)+"ACW_PackageInstallerTemp:"
		// create the temporary folder
		newpath /C/O/Q downloadPathTemp, downloadPathStr
		killpath /z downloadPathTemp
		
		// write download to zip file
		open /Z refNum as downloadPathStr+parseFilePath(0, url,"/", 1, 0)
		if(refNum==0)
			return 0
		endif
		FBinWrite refNum, webPageText
		close refNum
		archivePathStr=S_fileName // path to zip file
		archiveName=ParseFilePath(0, S_fileName, ":", 1, 0)
		printf "Saved temporary file %s\r", archiveName
		
		// create a temporary directory for the uncompressed files
		string unzipPathStr=""
		i=0
		do
			sprintf unzipPathStr,"%sInstallerTemp%d:", downloadPathStr, i
			GetFileFolderInfo /Q/Z unzipPathStr
			i+=1
		while(V_Flag==0)			
		newpath /C/O/Q unzipPath, unzipPathStr
		
		// inflate archive
		variable success = unzipArchive(archivePathStr, unzipPathStr)
		if (success==0)
			printf "unzipArchive failed to expand %s\r", S_fileName
			return 0
		endif
		
		printf "Inflated %s to %s\r", archiveName, unzipPathStr
		
		string fileList, folderList
		fileList=IndexedFile(unzipPath, -1, "????")
		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)+":"
			newpath /O/Q unzipPath, unzipPathStr
			fileList=IndexedFile(unzipPath, -1, "????")
			folderList=IndexedDir(unzipPath, -1, 0)
			killpath /Z unzipPath
		endif
		
		if (itemsinlist(fileList)==1 && itemsinlist(folderList)==0) // archive contains just one file	
			// check that this is the file we need
			if(cmpstr(ipfName,stringfromlist(0,fileList)))
				printf "Downloaded file (%s) has different name to target file (%s) - aborting update\r", stringfromlist(0,fileList), ipfName
				deleteFolder /M="OK to delete temporary installation files?"/Z removeEnding(downloadPathStr,":")
				return 0
			endif
			// Aways ask before overwriting file		
			sprintf cmd, "%sOverwrite %s with %s version %g?", cmd, ipfName, projectName, releaseVersion	
			doalert 1, cmd
			if(v_flag==2)
				printf "%s: update cancelled\r", projectName
				deleteFolder /M="OK to delete temporary installation files?"/Z removeEnding(downloadPathStr,":")
				return 0
			endif
			
			// move file to destination
			MoveFile /O/Z unzipPathStr+ipfName as packagePathStr+stringfromlist(0,fileList)
		else
			// we have multiple files/folders
			// look for the file that replaces the target procedure file
			string unzippedIPFpathStr=FindFile(unzipPathStr, ipfName)
			if(strlen(unzippedIPFpathStr)==0)
				printf "Could not find %s in %s\r", ipfName, archiveName
				deleteFolder /M="OK to delete temporary installation files?"/Z removeEnding(downloadPathStr,":")
				return 0
			endif
			
			// figure out local path from unzipPathStr to replacement procedure file
			unzippedIPFpathStr=unzippedIPFpathStr[strlen(unzipPathStr),inf]
			variable subfolders=itemsinlist(unzippedIPFpathStr, ":")-1
			
			// move up directory structure at destination
			string destPathStr=ParseFilePath(1, procPathStr, ":", 1, 0)
			for(i=0;i<subfolders;i+=1)
				destPathStr=ParseFilePath(1, destPathStr, ":", 1, 0)
			endfor
			
			variable badDir=0
			badDir=(cmpstr(ParseFilePath(0, destPathStr, ":", 1, 0),ParseFilePath(0, procPathStr, ":", 1, subfolders+1)))
			// target directory doesn't match folder in archive
			badDir=badDir || (strlen(destPathStr)<strlen(SpecialDirPath("Igor Pro User Files",0,0,0)+"User Procedures:"))
			// target directory is above user procedures folder
			
			if(badDir)
				// target directory doesn't match folder in archive
				printf "Could not match directory structure in %s to %s\r", archiveName, packagePathStr
				deleteFolder /M="OK to delete temporary installation files?"/Z removeEnding(downloadPathStr,":")
				return 0
			endif			
			
			moveFolder /O/Z removeEnding(unzipPathStr,":") as removeEnding(destPathStr,":")			
		endif	
		deleteFolder /M="OK to delete temporary installation files?"/Z removeEnding(downloadPathStr,":")
	else // an ipf file - overwrite destination procedure file with downloaded file
		cmd=""
		if (!chatty)
			sprintf cmd, "New update found for %s\r", projectName
		endif
		// Aways ask before overwriting file		
		sprintf cmd, "%sOverwrite %s with %s version %g?", cmd, ipfName, projectName, releaseVersion	
		doalert 1, cmd
		if(v_flag==2)
			printf "%s: update cancelled\r", projectName
			return 0
		endif	

		// write download to target ipf file
		open /Z refNum as procPathStr
		if(refNum==0)
			printf "Could not open %s for writing\r", ipfName
			return 0
		endif
		FBinWrite refNum, webPageText
		close refNum	
	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. 
// currently we extract the info we need from columns 0, 1, 4 and 5
static function /WAVE ParseReleases(WebPageText)
	string WebPageText
	
	make /T/Free/N=(0,5) w_releases
		
	variable selStart=-1, selEnd=-1, blockStart, blockEnd, selFound
	string projectName="", requiredVersion="", releaseMajor="", releaseMinor="", url="", platform=""
	variable i=0
	
	// locate project name
	selStart=strsearch(WebPageText, "<h1 class=\"page-title\" title=\"Releases for ", blockStart, 2)
	selStart+=43
	selEnd=strsearch(WebPageText, "\"", selStart, 2)
	if(selStart<0 || selEnd>selStart+150)
		return w_releases
	endif
	projectName=WebPageText[selStart, selEnd-1]

	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
		
		// locate version info
		selStart=strsearch(WebPageText, "\"field-paragraph-version\">", blockStart, 2)
		selStart+=26
		selEnd=strsearch(WebPageText, "<", selStart, 2)
		if(selStart<blockStart || selEnd>blockEnd)
			break
		endif
		requiredVersion=WebPageText[selStart, selEnd-1]	
		
		selStart=strsearch(WebPageText, "\"field-paragraph-version-major\">", blockStart, 2)
		selStart+=32
		selEnd=strsearch(WebPageText, "<", selStart, 2)
		if(selStart<blockStart || selEnd>blockEnd)
			break
		endif
		releaseMajor=WebPageText[selStart, selEnd-1]
		
		selStart=strsearch(WebPageText, "\"field-paragraph-version-patch\">", blockStart, 2)
		selStart+=32
		selEnd=strsearch(WebPageText, "<", selStart, 2)
		if(selStart<blockStart || selEnd>blockEnd)
			break
		endif
		releaseMinor=WebPageText[selStart, selEnd-1]
		
		// find download link
		selStart=strsearch(WebPageText, "\"field-paragraph-file\"", blockStart, 2)
		selStart=strsearch(WebPageText, "<a href=\"", selStart, 2)
		selStart+=9
		selEnd=strsearch(WebPageText, "\"", selStart, 2)
		if(selEnd<0 || 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(releaseMajor)==0 || strlen(releaseMinor)==0 ||strlen(url)==0)
			break
		endif
		w_releases[dimsize(w_releases,0)][]={{projectName},{requiredVersion},{releaseMajor},{releaseMinor},{url},{platform}}
		selStart=blockEnd
		i+=1
	while (i<1000)
	return w_releases	
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

// 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
 
// utility function, inflates a zip archive
static function unzipArchive(archivePathStr, unzipPathStr)
	string archivePathStr, unzipPathStr
		
	string validExtensions="zip;" // set to "" to skip check
	variable verbose=1 // choose whether to print output from executescripttext
	string msg, unixCmd, cmd
		
	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(unzipPathStr)==0)
		unzipPathStr=SpecialDirPath("Desktop",0,0,0)+ParseFilePath(3, archivePathStr, ":", 0, 0)
		sprintf msg, "Unzip to %s:%s?", ParseFilePath(0, unzipPathStr, ":", 1, 1), ParseFilePath(0, unzipPathStr, ":", 1, 0)
		doALert 1, msg
		if (v_flag==2)
			return 0
		endif
	else
		GetFileFolderInfo /Q/Z unzipPathStr
		if(V_Flag || V_isFolder==0)
			sprintf msg, "Could not find unzipPathStr folder\rCreate %s?", unzipPathStr
			doalert 1, msg
			if (v_flag==2)
				return 0
			endif
		endif	
	endif
	
	// make sure unzipPathStr folder exists - necessary for mac
	newpath /C/O/Q acw_tmpPath, unzipPathStr
	killpath /Z acw_tmpPath

	if(stringmatch(StringByKey("OS", igorinfo(3))[0,2],"Win")) // Windows
		// The following works with .Net 4.5, which is available in Windows 8 and up.
		// current versions of Windows with Powershell 5 can use the more succinct PS command 
		// 'Expand-Archive -LiteralPath C:\archive.zip -DestinationPath C:\Dest'
		string strVersion=StringByKey("OSVERSION", igorinfo(3))
		variable WinVersion=str2num(strVersion) // turns "10.1.2.3" into 10.1
		if (WinVersion<8)
			print "unzipArchive requires Windows 8 or later"
			return 0
		endif
		
		archivePathStr=parseFilePath(5, archivePathStr, "\\", 0, 0)
		unzipPathStr=parseFilePath(5, unzipPathStr, "\\", 0, 0)
		cmd="powershell.exe -nologo -noprofile -command \"& { Add-Type -A 'System.IO.Compression.FileSystem';"
		sprintf cmd "%s [IO.Compression.ZipFile]::ExtractToDirectory('%s', '%s'); }\"", cmd, archivePathStr, unzipPathStr
	else // Mac
		sprintf unixCmd, "unzip %s -d %s", ParseFilePath(5, archivePathStr, "/", 0,0), ParseFilePath(5, unzipPathStr, "/", 0,0)
		sprintf cmd, "do shell script \"%s\"", unixCmd
	endif
	
	executescripttext /B/UNQ/Z cmd
	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 fileName 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(((maxlevels && sublevels>maxLevels) || (folderLimit && (folderCount-folderIndex)>folderLimit)))
			break
		endif

	while(1)
	killpath /Z tempPathFF
	return fileList
end


// ------------------------- Project Installer ---------------------

// install a package hosted on IgorExchange.com
// packageList is a list of project short names.
// The package URL can be used in place of the 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 may or may not 
// not be created, depending on the structure of the archive. 

// uses parseReleases, unzipArchive, findFile, findAlias, extractFilename 
// functions from Updater code.

function install(packageList, [location])
	string packageList, location
	
	// where to save downloaded files - a temporary location
	// safe to edit this, but stuff in this location will be overwritten or deleted!
	string downloadPathStr=SpecialDirPath("Desktop",0,0,0)+"ACW_PackageInstallerTemp:"
	variable testing=0, autoloadOption=0 
	// autoloadOption=1 will prompt user to create an alias in Igor Procedures folder.
	
	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")
	variable nameIsURL=0
	
	for(ListIndex=0;ListIndex<itemsinList(packageList);ListIndex+=1)
		packageName=stringfromlist(ListIndex, packageList)
		
		// packageName can be package shortname or package URL
		if (stringmatch(packageName, "https://www.wavemetrics.com/*"))
			nameIsURL=1
			url=packageName
		else
			sprintf url, "https://www.wavemetrics.com/project/%s", packageName
		endif
		
		// check the project page on IgorExchange
		webPageText=FetchURL(url); err = GetRTError(1)
		if (err != 0)
			printf "Installer could not load %s\r", url
			continue
		endif
		
		if(nameIsURL)
			selStart=strsearch(webPageText, "<link rel=\"canonical\" href=\"", 0, 0)
			selStart+=28
			selEnd=strsearch(webPageText, "\"", selStart, 0)
			if (selEnd==-1 || selStart==-1)
				printf "Installer could not find releases at %s\r", url
				continue
			endif
			url=webPageText[selStart,selEnd-1]
			packageName=parseFilePath(0, url, "/", 1, 0)
		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
		wave /T w_releases=ParseReleases(webPageText)
		if (dimsize(w_releases,0)==0)
			sprintf cmd, "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])[5,inf], "%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][5])==-1)
				printf "%s %g not available for %s\r", projectName, releaseVersion, system
			else
				url=w_releases[i][4]
				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
		
		// create the temporary folder
		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)
			printf "Could not save to %s", downloadPathStr+parseFilePath(0, url,"/", 1, 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)
				if (strlen(packagePathStr)==0)
					continue
				endif	
			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)
				sprintf cmd "Do you want to open %s now?", IncludeProcStr
				doAlert 1, cmd
				if(v_flag==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
						
		endif
	endfor
	
	deleteFolder /M="OK to delete temporary installation files?"/Z downloadPathStr
	
	return 1	
end


// Inflates zip archive to a temporary folder, moves inflated archive 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, success=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 tmpPathStr=parseFilePath(1, archivePathStr, ":", 1, 0)
	string 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
	success = unzipArchive(archivePathStr, unzipPathStr)
	if (success==0)
		printf "unzipArchive failed to expand %s\r", archivePathStr
		killpath /Z unzipPath
		return ""
	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)
				deleteFolder /Z tmpPathStr
				return ""
			endif
		endif
		unzipPathStr+=stringfromlist(0,fileList)
		MoveFile /O/Z unzipPathStr as packagePathStr+stringfromlist(0,fileList)
	else
		if(CreatePackageFolder)
			packagePathStr+=shortName+":"
		endif
		// move inflated files to packagePathStr folder: will overwrite (with a warning)!
		moveFolder /O/Z removeEnding(unzipPathStr,":") as removeEnding(packagePathStr,":")
	endif
	
	if(strlen(s_path)==0) // s_path set by moveFile or moveFolder
		printf "failed to move %s to %s\r", unzipPathStr, packagePathStr
		return ""
	endif
	
	printf "Moved %s to %s\r", unzipPathStr, packagePathStr			
	
	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)
			printf "Install cancelled\r"
			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	



// -------------------- a GUI for installing user projects ------------

menu "Macros"
	"Install user project...", /Q, updater#makeInstallerPanel()
end


// get a list of user contributed projects from Wavemetrics.com
static function /WAVE GetProjects()
	
	// get project name, author, and URL for each user contribution
	make /free/T/N=(0,3) w_ProjectsList
	setDimLabel 1, 0, name, w_ProjectsList
	setDimLabel 1, 1, author, w_ProjectsList
	setDimLabel 1, 2, projectURL, w_ProjectsList
	
	string baseURL, projectsURL, URL, listPageText, projectPageText
	baseURL="https://www.wavemetrics.com"
	projectsURL="/projects?os_compatibility=All&project_type=All&field_supported_version_target_id=All&page="
	variable pageNum, projectNum, success
	
	variable pStart, pEnd, selStart, selEnd=0, err
	string strAuthor, strName, strShortName, strProjectURL
	
	// loop through listPages
	for(pageNum=0;pageNum<100;pageNum+=1)
		sprintf URL "%s%s%d", baseURL, projectsURL, pageNum
		
		listPageText=FetchURL(URL); err = GetRTError(1)
		if (err != 0)
			printf "Installer could not load %s\r", URL
			return w_ProjectsList
		endif
			
		pStart=strsearch(listPageText, "<section class=\"project-teaser-wrapper\">", 0, 0)
		if (pStart==-1)
			break // no more projects
		endif
		pEnd=0
		
		// loop through projects on listPage
		for (projectNum=0;projectNum<50; projectNum+=1)
		
			pStart=strsearch(listPageText, "<section class=\"project-teaser-wrapper\">", pEnd, 0)	
			pEnd=strsearch(listPageText, "<div class=\"project-teaser-footer\">", pStart, 0)
			if (pEnd==-1 || pStart==-1)
				break // no more projects on this listPage
			endif
			
			selStart=strsearch(listPageText, "<span class=\"username-wrapper\">", pEnd, 3)
			if(selStart<pStart)
				continue
			endif
		
			selStart=strsearch(listPageText, "\">", selStart, 0)
			selStart+=2
			selEnd=strsearch(listPageText, "</span>", selStart, 0)		
			strAuthor=listPageText[selStart,selEnd-1]
					
			selStart=strsearch(listPageText, "<a href=\"", selEnd, 0)
			selStart+=9
			selEnd=strsearch(listPageText, "\"><h2>", selStart, 0)
			strProjectURL=baseURL+listPageText[selStart,selEnd-1]
			
			selStart=selEnd+6
			selEnd=strsearch(listPageText, "</h2></a>", selStart, 0)
			strName=listPageText[selStart,selEnd-1]
			
			if (strLen(strName)==0)
				continue
			endif

// Don't try to get project details at this point: too many pages to download			
			
//			projectPageText=FetchURL(strProjectURL); err = GetRTError(1)
//			if (err != 0)
//				continue
//			endif
//			selStart=strsearch(projectPageText, "<link rel=\"canonical\" href=\"", 0, 0)
//			selStart+=28
//			selEnd=strsearch(projectPageText, "\"", selStart, 0)
//			strProjectURL=projectPageText[selStart,selEnd-1]
//			strShortName=parseFilePath(0, strProjectURL, "/", 1, 0)
//			
//			success=(strlen(strShortName)&&strlen(strProjectURL))
//			if(!success)
//				continue
//			endif
			
			InsertPoints /M=0 DimSize(w_ProjectsList, 0), 1, w_ProjectsList
			w_ProjectsList[inf][%author]=strAuthor
			w_ProjectsList[inf][%name]=strName
			w_ProjectsList[inf][%ProjectURL]=strProjectURL
		endfor	
	endfor

	return w_ProjectsList	
end

static function makeInstallerPanel()
	
	dowindow /k InstallerPanel
	
	NewDataFolder /O root:Packages
	NewDataFolder /O root:Packages:Installer
	DFREF dfr = root:Packages:Installer
	variable /G dfr:stubLen=0
	
	make /o/n=1/T dfr:displayList /WAVE=displayList, dfr:helpList /WAVE=helpList
	displayList="retrieving list..."
	
	// make a control panel GUI	
	NewPanel /K=1/W=(100,50,450,360)/N=InstallerPanel as "Install User Project"
	
	NewNotebook /F=1 /N=nb0 /HOST=InstallerPanel /W=(25,20,325,65) /OPTS=3
	notebook InstallerPanel#nb0 fSize=16, showRuler=0
	SetWindow InstallerPanel#nb0, activeChildFrame=0
	
	ListBox listbox0, win=InstallerPanel, pos={25,80},size={300, 200}, listwave=displayList
	ListBox listbox0, win=InstallerPanel, mode=1, proc=Updater#InstallerListBoxProc, selRow=-1
	ListBox listbox0, win=InstallerPanel, helpWave=helpList
	
	Button button0, win=InstallerPanel,pos={260,287},size={60,20},proc=Updater#InstallerButtonProc,title="Install"
	Button button0, win=InstallerPanel,help={"Install selected user project"}, disable=2
	
	doupdate /W=InstallerPanel
	
	SetWindow InstallerPanel hook(hInstallerHook)=updater#InstallerPanelHook	

	wave /T w=GetProjects()
	duplicate /O w dfr:fullList /WAVE=fullList, dfr:matchList	
	UpdateListboxWave("")
	
end

static function InstallerButtonProc(s)
	STRUCT WMButtonAction &s
	
	if(s.eventCode!=2)
		return 0
	endif
	
	DFREF dfr = root:Packages:Installer
	wave /SDFR=dfr/T  matchList 
	
	GetSelection notebook, InstallerPanel#nb0, 1 // get current position in notebook
	Notebook InstallerPanel#nb0 selection={startOfFile,endOfFile}
	GetSelection notebook, InstallerPanel#nb0, 2
	Notebook InstallerPanel#nb0 selection={(0,V_startPos),(0,V_endPos)}
	
	findValue /RMD=[][0,0]/TEXT=s_selection /TXOP=4/Z matchList
	if(v_value>-1) 
		print "install(\""+matchList[v_value][%projectURL]+"\")"
		install(matchList[v_value][%projectURL])
	endif
	return 0
end

static function InstallerListBoxProc(s)
	STRUCT WMListboxAction &s
	
	if(s.eventCode==4 || s.eventCode==5) // a list item is selected
		if(s.row>=numpnts(s.listwave))
			return 0
		endif
		
		// insert text into notebook subwindow	
		Notebook InstallerPanel#nb0 selection={startOfFile,endOfFile}, textRGB=(0,0,0), text=s.listwave[s.row]
		NVAR stubLen=root:Packages:Installer:stubLen
		stubLen=strlen(s.listwave[s.row])
		Button button0, win=InstallerPanel, disable=0
	endif
	return 0
end

// update listbox wave based on string s
static function UpdateListboxWave(s)
	string s
	
	DFREF dfr = root:Packages:Installer
	wave /SDFR=dfr/T  fullList, matchList //, authorList/
	
	variable i
	string regEx="(?i)"	
	
	ControlInfo /W=InstallerPanel popup0
	if(V_Value==1)
		regEx+="^"
	endif
		
	if(v_value==3)
		for(i=0;i<strlen(s);i+=1)
			regEx+="(.*?)"+s[i]
		endfor
	else
		regEx+=s		
	endif	
	grep /Z/E=regEx fullList as matchList
	duplicate /T/O/R=[][0] matchList, dfr:displayList
	duplicate /T/O/R=[][1] matchList, dfr:helpList
	duplicate /T/O/R=[][2] matchList, dfr:urlList
	ListBox listbox0, win=InstallerPanel, selRow=-1
	
	FindValue /TEXT=s/TXOP=4 dfr:displayList
	Button button0, win=InstallerPanel, disable=2*(v_value<0)
end

// intercept and deal with keyboard events in notebook subwindow
static function InstallerPanelHook(s)
	STRUCT WMWinHookStruct &s
	
	DFREF dfr = root:Packages:Installer
	
	if(s.eventcode==2)
		killDataFolder /Z dfr
		return 0
	endif
	
	GetWindow $s.winName activeSW
	if (CmpStr(S_value,"InstallerPanel#nb0") != 0)
		return 0
	endif
	
	NVAR stubLen=dfr:stubLen

	if(s.eventcode==5) // mouseup 	
		GetSelection notebook, InstallerPanel#nb0, 1 // get current position in notebook
		V_endPos=min(stubLen,V_endPos)
		V_startPos=min(stubLen,V_startPos)
		Notebook InstallerPanel#nb0 selection={(0,V_startPos),(0,V_endPos)}
		return 1
	endif
	
	if(s.eventcode==10) // menu 
		strswitch(s.menuItem)
			case "Paste":
				GetSelection notebook, InstallerPanel#nb0, 1 // get current position in notebook		
				string strScrap=getscrapText()
				strScrap=replacestring("\r", strScrap, "")
				strScrap=replacestring("\n", strScrap, "")
				strScrap=replacestring("\t", strScrap, "")
				Notebook InstallerPanel#nb0 selection={(0,V_startPos),(0,V_endPos)}, text=strScrap
				stubLen+=strlen(strScrap)-abs(V_endPos-V_startPos)
				s.eventcode=11 
				// pretend this was a keyboard event to allow execution to continue
				break
			case "Cut":
				GetSelection notebook, InstallerPanel#nb0, 3 // get current position in notebook
				putscrapText s_selection
				Notebook InstallerPanel#nb0 selection={(0,V_startPos),(0,V_endPos)}, text=""
				stubLen-=strlen(s_selection)
				s.eventcode=11 
				break
			case "Clear":
				GetSelection notebook, InstallerPanel#nb0, 3 // get current position in notebook
				Notebook InstallerPanel#nb0 selection={(0,V_startPos),(0,V_endPos)}, text="" // clear text
				stubLen-=strlen(s_selection)
				s.eventcode=11 
				break
		endswitch
	endif
		
	if(s.eventcode!=11)
		return 0
	endif
	
	// deal with some non-printing characters
	switch(s.keycode)
		case 9:	// tab: jump to end
		case 3:
		case 13: // enter or return: jump to end
			notebook InstallerPanel#nb0 selection={startOfFile,endofFile}, textRGB=(0,0,0)
			notebook InstallerPanel#nb0 selection={endOfFile,endofFile}
			GetSelection notebook, InstallerPanel#nb0, 1 // get current position in notebook
			stubLen=V_endPos
			break
		case 28: // left arrow
			return 0
		case 29: // right arrow
			GetSelection notebook, InstallerPanel#nb0, 1
			if(V_endPos>=stubLen)
				if(s.eventMod&2) // shift key
					Notebook InstallerPanel#nb0 selection={(0,V_startPos),(0,stubLen)}
				else
					Notebook InstallerPanel#nb0 selection={(0,stubLen),(0,stubLen)}
				endif
				return 1
			endif
			return 0
		case 8:
		case 127: // delete or forward delete
			GetSelection notebook, InstallerPanel#nb0, 1
			if(V_startPos==V_endPos)
				V_startPos += (s.keycode==8) ? -1 : 1
			endif
			V_startPos=min(stubLen,V_startPos); V_endPos=min(stubLen,V_endPos)
			V_startPos=max(0, V_startPos); V_endPos=max(0, V_endPos)
			Notebook InstallerPanel#nb0 selection={(0,V_startPos),(0,V_endPos)}, text=""
			stubLen-=abs(V_endPos-V_startPos)
			break			
	endswitch
		
	// find and save current position	
	GetSelection notebook, InstallerPanel#nb0, 1
	variable selEnd=V_endPos
		
	if(strlen(s.keyText)==1) // a one-byte printing character
		// insert character into current selection
		Notebook InstallerPanel#nb0 text=s.keyText, textRGB=(0,0,0)
		stubLen+=1-abs(V_endPos-V_startPos)
		// find out where we want to leave cursor
		GetSelection notebook, InstallerPanel#nb0, 1 
		selEnd=V_endPos
	endif	
	
	string strStub="", strInsert="", strEnding=""
		
	// do auto-completion based on stubLen characters
	wave /T  fullList=dfr:fullList
	// select and format stub
	Notebook InstallerPanel#nb0 selection={startOfFile,(0,stubLen)}, textRGB=(0,0,0)	
	// get stub text
	GetSelection notebook, InstallerPanel#nb0, 3
	strStub=s_selection
	
	if(s.keycode==30 || s.keycode==31) // up or down arrow
		Notebook InstallerPanel#nb0 selection={(0,stubLen),endOfFile}
		GetSelection notebook, InstallerPanel#nb0, 3
		strEnding=s_selection
		strInsert=arrowKey(strStub, strEnding, 1-2*(s.keycode==30), fullList)
	else
		strInsert=completeStr(strStub, fullList)
	endif
	// insert completion text in grey	
	Notebook InstallerPanel#nb0 selection={(0,stubLen),endOfFile}, textRGB=(40000,40000,40000), text=strInsert	

	Notebook InstallerPanel#nb0 selection={(0,selEnd),(0,selEnd)}, findText={"",1}
	UpdateListboxWave(strStub)
	return 1 // tell Igor we've handled all keyboard events
end

// returns completion text for first match of string s in text wave w
static function /T completeStr(s, w)
	string s
	wave /T w
	
	if (strlen(s)==0)
		return ""
	endif
	
	string stub=s[0,strlen(s)-1]
	variable stubLen=strlen(stub)
	if (stubLen==0)
		return ""
	endif
	
	make /free/T/N=0 w_out
	grep /Z/E="(?i)^"+stub w as w_out
	if(numpnts(w_out)==0)
		return ""
	endif
	return (w_out[0])[stubLen,inf]	
end

// find next or previous matching entry in wList and return completion text
static function /T arrowKey(stub, ending, increment, wList)
	string stub, ending
	variable increment
	wave /T wList
	
	if (strlen(stub)==0)
		return ""
	endif
	
	variable stubLen=strlen(stub)
	if (stubLen==0)
		return ""
	endif
	
	make /free/T/N=0 w_out
	grep /Z/E="(?i)^"+stub/DCOL={0} wList as w_out
	if(numpnts(w_out)==0)
		return ""
	endif
	
	findValue /RMD=[][0,0]/TEXT=stub+ending /TXOP=4/Z w_out
	if(v_value>-1)
		v_value+=increment
		v_value = V_value<0 ? DimSize(w_out,0)-1 : v_value
		v_value = V_value>=DimSize(w_out,0) ? 0 : v_value
	else
		return (w_out[0])[stubLen,inf]
	endif
	return (w_out[v_value])[stubLen,inf]	
end

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