Sorry your browser is not supported!

// Project: Temp 
// Created: 2016-08-26

// set window properties
SetWindowTitle( "Temp" )
SetWindowSize( 1024, 768, 0 )

// set display properties
SetVirtualResolution( 1024, 768 )
SetOrientationAllowed( 1, 1, 1, 1 )

SetSyncRate(0,0)


selectFile("",20,20,500,500)

function selectFile(startFolder$, x,y,width,height)

	local drive as String
	local currentFolder as string 
	local selectedFolder as string 
	local arrFolder as String[]
	local arrFile as string []
	local ret as integer

	local backdrop as integer

	local txtFolder as integer[]

	backdrop = CreateSprite(0)
	setspritesize(backdrop,width, height)
	SetSpritePosition(backdrop,x,y)
	SetSpriteDepth(backdrop, 11)
	SetSpriteColorAlpha(backdrop,64)

	drive = left(GetDocumentsPath(), 3)
	currentfolder = GetFolder()
	selectedFolder = drive
	getFolders(arrFolder, selectedFolder)
		
	while ret = 0
		
		txtFolder.length = arrFolder.length
		for i = 0 to arrFolder.length
			txtFolder[i] = CreateText(arrFolder[i])
			SetTextSize(txtFolder[i], 20)
			SetTextPosition(txtFolder[i], (x + 5), (y + 5)  + (i * 25))
			SetTextScissor(txtFolder[i],x,y,x+width, y+height)
		next i
		
		do
			sync()
			scroll = GetRawMouseWheelDelta()
			if scroll <> 0
				for i = 0 to txtFolder.length
					SetTextPosition(txtFolder[i], GetTextX(txtFolder[i]), gettextY(txtFolder[i]) + scroll)
				next i
			endif
		loop
		
	endwhile
	
endfunction


function getFolders(arrFolder ref as string[], selectedFolder as string)
	
	local f as string 
	
	SetFolder("")
	SetRawWritePath(selectedFolder)
	arrFolder.length = 0
	f = GetFirstFolder()
	arrfolder.length = GetFolderCount()
	
	for i = 1 to arrFolder.length
		arrFolder[i] = f
		f = GetNextFolder()
	next i
	arrFolder[0] = ".."
	
	arrFolder.sort()
	
endfunction

// Project: Temp 
// Created: 2016-08-26

// set window properties
SetWindowTitle( "Temp" )
SetWindowSize( 1024, 768, 0 )

// set display properties
SetVirtualResolution( 1024, 768 )
SetOrientationAllowed( 1, 1, 1, 1 )

SetSyncRate(0,0)
SetPrintSize(16)


selectFile("",50,50,500,500)

function selectFile(startFolder$, x,y,width,height)

	#constant cFONTSIZE = 20
	#constant cLINESPACE = 3

	local drive as String
	local currentFolder as string 
	local selectedFolder as string 
	local arrFolder as String[]
	local arrFile as string []
	local ret as integer

	local backdrop as integer

	local txtFolder as integer[]

	backdrop = CreateSprite(0)
	setspritesize(backdrop,width, height)
	SetSpritePosition(backdrop,x,y)
	SetSpriteDepth(backdrop, 11)
	SetSpriteColorAlpha(backdrop,64)

	drive = left(GetDocumentsPath(), 3)
	currentfolder = GetFolder()
	selectedFolder = drive
	getFolders(arrFolder, selectedFolder)
		
	while ret = 0
		
		displayFolders(txtFolder, arrFolder,x,y,width,height)
		
		do
			
			// **** SCROLLING
			scroll = GetRawMouseWheelDelta()
			if scroll <> 0
				if scroll < 0 then mult = -1 else mult = 1
				for i = 0 to txtFolder.length
					SetTextPosition(txtFolder[i], GetTextX(txtFolder[i]), gettextY(txtFolder[i]) + ((cFONTSIZE + cLINESPACE) * mult))
				next i
			endif
			
			// SELECTING FOLDER
			if GetPointerReleased() = 1
				for i = 0 to txtFolder.length
					hit = GetTextHitTest(txtFolder[i], GetPointerX(), GetPointerY())
					if hit = 1
						selectedFolder = selectedFolder + "\" + GetTextString(txtFolder[i])
						selectedFolder = ReplaceString(selectedFolder,"\\", "\",-1)
						getFolders(arrFolder, selectedFolder)
						displayFolders(txtFolder, arrFolder,x,y,width,height)
					endif
				next i
			endif
			
			print(selectedfolder)
			sync()

		loop
		
	endwhile
	
endfunction


function getFolders(arrFolder ref as string[], selectedFolder as string)
	
	local f as string 
	
	SetFolder("")
	SetRawWritePath(selectedFolder)
	arrFolder.length = 0
	f = GetFirstFolder()
	arrfolder.length = GetFolderCount()
	
	for i = 1 to arrFolder.length
		arrFolder[i] = f
		f = GetNextFolder()
	next i
	arrFolder[0] = ".."
	
	arrFolder.sort()
	
	
endfunction

function displayFolders(txtFolder ref as integer[], arrFolder ref as string[], x,y,width,height)
	
		for i = 0 to txtFolder.length
			if GetTextExists(txtFolder[i])
				DeleteText(txtFolder[i])
			endif
		next i

		txtFolder.length = arrFolder.length
		for i = 0 to arrFolder.length
			txtFolder[i] = CreateText(arrFolder[i])
			SetTextSize(txtFolder[i], cFONTSIZE)
			SetTextPosition(txtFolder[i], (x + 5), (y + cLINESPACE)  + (i * (cFONTSIZE + cLINESPACE)))
			SetTextScissor(txtFolder[i],x +2,y+2,x+width-2, y+height-2)
		next i

	
endfunction

				p$ = w.curPath + w.folders[w.selectedFolderId+1]
				`SetFolder("")
				SetRawWritePath(p$)
				
				w.files.length = 0
				w.files.length = getFileCount()
				w.files[1] = getFirstFile()
				for i = 2 to w.files.length
					w.files[i] = getNextFile()
				next i
				w.files.sort()

Function GetDriveExists(drive As String)
	result As Integer = 1
	
	temp As String[]
	GetFolders(drive, temp)
	If temp.length < 0 Then result = 0
EndFunction result

Function GetPathExists(path As String)
	If Len(path) < 2 Then ExitFunction 0
	If Len(path) <= 3 Then ExitFunction GetDriveExists(path)
	
	lastFolder As String
	lastFolder = Mid(path, FindStringReverse(path, "/")+1, -1)
	
	path = path + "/.."
	folders As String[]
	GetFolders(path, folders)
	
	i As Integer
	For i = 0 To folders.length
		If folders[i] = lastFolder Then ExitFunction 1
	Next
EndFunction 0

Function GetFolders(path As String, container Ref As String[])
	container.length = -1
	
	folder As String
	folder = GetFolder()
	SetFolder("")

	writeP As String
	writeP = GetWritePath()
	
	root_folders As String[]
	GetFolderArray("q:/$~invalid_path~$", root_folders)
	GetFolderArray(path, container)
	
	// remove folders from root
	If root_folders.length < container.length
		rcsize As Integer
		rcsize = root_folders.length
		
		i As Integer
		For i = 0 To rcsize
			If container[container.length-(rcsize-i)] = root_folders[i]
				container.remove(container.length-(rcsize-i))
			EndIf
		Next
	Else
		container.length = -1
	EndIf
	
	SetFolder(folder)
	SetRawWritePath(writeP)
EndFunction

Function GetFolderArray(path As String, container Ref As String[])
	SetRawWritePath(path)
	
	container.length = GetFolderCount()-1
	container[0] = GetFirstFolder()
	i As Integer
	For i = 1 To container.length
		container[i] = GetNextFolder()
	Next
EndFunction container.length


Function GetFiles(path As String, container Ref As String[])
	container.length = -1
	
	folder As String
	folder = GetFolder()
	SetFolder("")

	writeP As String
	writeP = GetWritePath()
	
	root_files As String[]
	GetFileArray("q:$~invalidpath~$", root_files)
	
	GetFileArray(path, container)
	
	// remove files from root
	If root_files.length < container.length
		rcsize As Integer
		rcsize = root_files.length
		
		i As Integer
		For i = 0 To rcsize
			If container[container.length-(rcsize-i)] = root_files[i]
				container.remove(container.length-(rcsize-i))
			EndIf
		Next
	Else
		container.length = -1
	EndIf
		
	SetFolder(folder)
	SetRawWritePath(writeP)	
EndFunction 

Function GetFileArray(path As String, container Ref As String[])
	SetRawWritePath(path)
	
	container.length = GetFileCount()-1
	container[0] = GetFirstFile()
	i As Integer
	For i = 1 To container.length
		container[i] = GetNextFile()
	Next	
EndFunction container.length

Function GetSystemDrives(drive Ref As String[])
	drive.length = -1
	
	drv As String
	i As Integer
	For i = 0 To 25
		drv = Chr(65+i)
		drv = drv + ":"
		
		If GetDriveExists(drv) > 0 Then drive.insert(drv)
	Next
EndFunction 

// Project: File Selection Utility
// Created: 2017-02-15 by Ranietz
// AGK Version 2.0.22

// show all errors
SetErrorMode(2)

// set window properties
SetWindowTitle( "File Selection Utility" )
SetWindowSize( 1024, 768, 0 )

// set display properties
SetVirtualResolution( 1024, 768 )
SetOrientationAllowed( 1, 1, 1, 1 )
SetClearColor( 64, 64, 64 )
SetSyncRate( 60, 0 )
SetPrintSize( 16 )
UseNewDefaultFonts( 0 )	// new fonts are not monospaced so don't use them in this project

// variable that holds the filename with full path
filePath as string

// main loop
do

	// space key
	if GetRawKeyPressed(32) then filePath = FSU_MAIN_GetFilePath( GetDocumentsPath() )

	// print debug stuff
	Print( "Press spacekey to select file" )
	PrintC( "File: " ) : Print( filePath )

	// update screen
	Sync()

loop

// types

type FSU_TYPE_content
	dir as integer	// 0 = file, 1 = folder, 2 = up one folder
	txt as string
endtype

// functions

// FSU_MAIN_GetFilePath:
// Main function of the File Selection Utility
// INPUT:	path 	- a string containing a path to a folder on the hard drive
// OUTPUT:	path 	- a string containing a filename with full path
function FSU_MAIN_GetFilePath( path as string )

	// variables for the background sprite
	boxWidth as integer
	boxHeight as integer
	boxPosX as integer
	boxPosY as integer
	boxSpriteId as integer

	boxWidth = 800
	boxHeight = 640
	boxPosX = ( (GetVirtualWidth()  - boxWidth)  / 2 )
	boxPosY = ( (GetVirtualHeight() - boxHeight) / 2 )

	// split up the path and store it in an array
	pathArray as string[]
	for i = 1 to CountStringTokens( path, "/\")
		pathArray.insert( GetStringToken( path, "/\", i ) + "/" )
	next i

	// write from the array back to the path string to make sure it uses "/" instead of "\"
	path = FSU_UpdatePath( pathArray )

	// store the current write path and folder
	defaultWritePath as string
	defaultFolder as string
	defaultWritePath = GetWritePath()
	defaultFolder = GetFolder()

	// set the write path to be equal the read path to find files and folders to ignore
	SetFolder( "" )
	SetRawWritePath( GetReadPath() )
	foldersToIgnore	as integer
	filesToIgnore as integer
	foldersToIgnore	= GetFolderCount()
	filesToIgnore = GetFileCount()

	// find all drives on the system and create a text object for each one
	drive as integer[]
	for i = 67 to 90	// letters C to Z
		SetRawWritePath( Chr(i) + ":/" )
		// the drive exists if the number of folders or files differ from the read path
		if GetFolderCount() > foldersToIgnore or GetFileCount() > filesToIgnore
			drive.insert( CreateText( Chr(i) + ":/" ) )
			SetTextSize( drive[drive.length], 16)
			SetTextPosition( drive[drive.length], boxPosX + 16, boxPosY + 48 + 16 * drive.length )
		endif
	next i

	// array to hold the folder and file data
	content as FSU_TYPE_content[]

	// get content of the current folder
	SetRawWritePath( path )
	FSU_UpdateFileArray( content, foldersToIgnore, filesToIgnore )

	// create background sprite
	boxSpriteId = CreateSprite( 0 )
	SetSpriteColor( boxSpriteId, 0, 0, 0, 255 )
	SetSpriteSize( boxSpriteId, boxWidth, boxHeight )
	SetSpritePosition( boxSpriteId, boxPosX, boxPosY )

	// create text object for the top line (the current path)
	txtPath as integer
	txtPath = CreateText( path )
	SetTextSize( txtPath, 16 )
	SetTextPosition( txtPath, boxPosX + 16, boxPosY + 16 )
	SetTextScissor( txtPath, GetTextX(txtPath), GetTextY(txtPath), GetTextX(txtPath) + boxWidth - 32, GetTextY(txtPath) + 16 )

	// create text object for the cancel button
	txtCancel as integer
	txtCancel = CreateText( "Cancel" )
	SetTextSize( txtCancel, 16 )
	SetTextPosition( txtCancel, boxPosX + 64, boxPosY + boxHeight - 32 )

	// create text object for the ok button
	txtOk as integer
	txtOk = CreateText( "Ok" )
	SetTextSize( txtOk, 16 )
	SetTextPosition( txtOk, boxPosX + 256, boxPosY + boxHeight - 32 )

	// create text objects for the folder content
	txtId as integer[]
	for i = 0 to 33
		txtId.insert( createText( "" ) )
		SetTextSize( txtId[i], 16 )
		SetTextPosition( txtId[i], boxPosX + 64, boxPosY + 48 + i * 16 )
		SetTextScissor( txtId[i], GetTextX(txtId[i]), GetTextY(txtId[i]), GetTextX(txtId[i]) + boxWidth - 80, GetTextY(txtId[i]) + 16 )
	next i

	// used for text scrolling
	textOffset as integer = 0
	// used for the mouse pointer
	px as integer
	py as integer
	// used to end the function
	done as integer = 0
	// used when selecting files
	currentFile as string = ""
	pathComplete as integer = 0

	// write text from the content array to the text objects
	FSU_UpdateTextArray( txtId, content, textOffset )

	do

		// mouse scroll wheel
		if GetRawMouseWheelDelta() < 0.0
			if content.length - txtId.length > textOffset
				inc textOffset
				FSU_UpdateTextArray( txtId, content, textOffset )
			endif
		elseif GetRawMouseWheelDelta() > 0.0
			if textOffset > 0
				dec textOffset
				FSU_UpdateTextArray( txtId, content, textOffset )
			endif
		endif

		px = GetPointerX()
		py = GetPointerY()

		// if click on drive letters
		for i = 0 to drive.length
			if GetTextHitTest( drive[i], px, py )
				SetTextColor( drive[i], 255, 127, 127, 255 )
				if GetPointerPressed()
					currentFile = ""
					pathComplete = 0
					path = GetTextString( drive[i] )
					pathArray.length = 0
					pathArray[0] = path
					SetRawWritePath( path )
					SetTextString( txtPath, path )
					FSU_UpdateFileArray( content, foldersToIgnore, filesToIgnore )
					FSU_UpdateTextArray( txtId, content, textOffset )
				endif
			else
				SetTextColor( drive[i], 255, 255, 255, 255 )
			endif
		next i

		// if click on folders or files
		for i = 0 to txtId.length
			if GetTextHitTest( txtId[i], px, py )
				SetTextColor( txtId[i], 255, 127, 127, 255 )
				if GetPointerPressed()
					if i + textOffset <= content.length
						if content[i + textOffset].dir = 1	// folder
							currentFile = ""
							pathComplete = 0
							pathArray.insert( content[i + textOffset].txt + "/" )
							textOffset = 0
							path = FSU_UpdatePath( pathArray )
							SetRawWritePath( path )
							SetTextString( txtPath, path )
							FSU_UpdateFileArray( content, foldersToIgnore, filesToIgnore )
							FSU_UpdateTextArray( txtId, content, textOffset )
						elseif content[i + textOffset].dir = 2 // up one folder
							currentFile = ""
							pathComplete = 0
							textOffset = 0
							if pathArray.length > 0 then pathArray.remove()
							path = FSU_UpdatePath( pathArray )
							SetRawWritePath( path )
							SetTextString( txtPath, path )
							FSU_UpdateFileArray( content, foldersToIgnore, filesToIgnore )
							FSU_UpdateTextArray( txtId, content, textOffset )
						elseif content[i + textOffset].dir = 0	// file
							currentFile = content[i + textOffset].txt
							pathComplete = 1
							SetTextString( txtPath, path + currentFile )
						endif
					endif
				endif
			else
				SetTextColor( txtId[i], 255, 255, 255, 255 )
			endif
		next i

		// return empty string if cancel is clicked
		if GetTextHitTest( txtCancel, px, py )
			SetTextColor( txtCancel, 255, 127, 127, 255 )
			if GetPointerPressed()
				path = ""
				done = 1
			endif
		else
			SetTextColor( txtCancel, 255, 255, 255, 255 )
		endif

		// return string with full path and filename if ok is clicked
		if pathComplete
			if GetTextHitTest( txtOk, px, py )
				SetTextColor( txtOk, 255, 127, 127, 255 )
				if GetPointerPressed()
					path = path + currentFile
					done = 1
				endif
			else
				SetTextColor( txtOk, 255, 255, 255, 255 )
			endif
		else
			SetTextColor( txtOk, 127, 127, 127, 255 )
		endif

		// set the write path back to the default to avoid the window_position.dat file
		// beeing written to the current write path if the app window is moved, minimized etc.
		SetRawWritePath( defaultWritePath )

		// Draw some lines to make the GUI a little bit nicer
		DrawBox( boxPosX + 8, boxPosY + 8, boxPosX + boxWidth - 8, boxPosY + boxHeight - 40, MakeColor(0,0,255), MakeColor(0,0,255), MakeColor(0,0,255), MakeColor(0,0,255), 0 )
		DrawLine( boxPosX + 8, boxPosY + 40, boxPosX + boxWidth - 8, boxPosY + 40, MakeColor(0,0,255), MakeColor(0,0,255) )
		DrawLine( boxPosX + 56, boxPosY + 40, boxPosX + 56, boxPosY + boxHeight - 40, MakeColor(0,0,255), MakeColor(0,0,255) )

		// end the function
		if done = 1 then exit

		// update screen
		sync()

	loop

	// delete text objects
	for i = 0 to txtId.length
		if GetTextExists( txtId[i] ) then DeleteText( txtId[i] )
	next i

	for i = 0 to drive.length
		if GetTextExists( drive[i] ) then DeleteText( drive[i] )
	next i

	if GetTextExists( txtPath ) then DeleteText( txtPath )
	if GetTextExists( txtCancel ) then DeleteText( txtCancel )
	if GetTextExists( txtOk ) then DeleteText( txtOk )

	// delete background sprite
	if GetSpriteExists( boxSpriteId ) then DeleteSprite( boxSpriteId )

	// set folder back to where it was before this function
	SetFolder( defaultFolder )

endfunction path

// FSU_UpdateFileArray:
// INPUT: 	content 		- an array that will store the content of a folder on the hard drive
//			foldersToRemove - folders to remove from the content array (the folders from the read path)
//			filesToRemove	- files to remove from the content array (the files from the read path)
// OUTPUT: 	None
function FSU_UpdateFileArray( content ref as FSU_TYPE_content[], foldersToRemove as integer, filesToRemove as integer )

	s as string

	content.length = 0
	content[0].dir = 2		// move up one folder
	content[0].txt = ".."

	s = GetFirstFolder()
	if s <> ""
		content.length = content.length + 1
		content[content.length].dir = 1		// folder
		content[content.length].txt = s
		s = GetNextFolder()
		while s <> ""
			content.length = content.length + 1
			content[content.length].dir = 1	// folder
			content[content.length].txt = s
			s = GetNextFolder()
		endwhile
	endif

	// remove folders from the read path
	for i = 1 to foldersToRemove
		content.remove()
	next i

	s = GetFirstFile()
	if s <> ""
		content.length = content.length + 1
		content[content.length].dir = 0		// file
		content[content.length].txt = s
		s = GetNextFile()
		while s <> ""
			content.length = content.length + 1
			content[content.length].dir = 0	// file
			content[content.length].txt = s
			s = GetNextFile()
		endwhile
	endif

	// remove files from the read path
	for i = 1 to filesToRemove
		content.remove()
	next i

	// sort content acording to the dir value
	// files first, then folders, last ".."
	content.sort()
	// reverse everything so the ".." comes first etc...
	content.reverse()

endfunction

// FSU_UpdateTextArray:
// Input:	txtId	- an array with id numbers of a series of text objects
//			content - an array with folder and file names
//			offset	- how much should the text in the textId be offset from the content array
// OUTPUT:	None
function FSU_UpdateTextArray( txtId ref as integer[], content ref as FSU_TYPE_content[], offset as integer )

	for i = 0 to txtId.length
		if i + offset <= content.length
			if content[i + offset].dir > 0
				SetTextString( txtId[i], "<DIR> " + content[i + offset].txt )
			else
				SetTextString( txtId[i], "      " + content[i + offset].txt )
			endif
		else
			SetTextString( txtId[i], "" )
		endif
	next i

endfunction

// FSU_UpdatePath
// INPUT:	p    - an array of folder names
// OUTPUT:	path - all the folder names put together
function FSU_UpdatePath( p ref as string[] )

	path as string

	for i = 0 to p.length
		path = path + p[i]
	next i

endfunction path

	for i = 0 to 25
		d$ = chr(i+65)+":\"
		PrintC(d$)
		
		SetFolder("")
		SetRawWritePath(d$)
		count = getFolderCount()
		if count > 0 then printc(" "+getFirstFile())
		print("")
	next i

drives as string[]
getDrives(drives)


function getDrives(drives ref as string[])
	
	local _ghostFiles as string[]

	// Get ghost files (files that appear everywhere, even non-existent drives)
	SetFolder("")
	SetRawWritePath("(0)(0)")
	getCurrentFileArray(_ghostFiles)
	_ghostFiles.sort()

	// Drive letters A through Z
	for i = 0 to 25
		d$ = chr(i+65)+":\"

		SetFolder("")
		SetRawWritePath(d$)
		
		count = getFileCount()

		// If file count of this drive is same as the fake drive, compare (sorted) files
		if count = _ghostFiles.length
			temp as string[]
			getCurrentFileArray(temp)
			// If file arrays don't match, then this drive contains other legit files. It is valid
			if matchStringArray(_ghostFiles, temp) = 0
				drives.insert(d$)
			else
				if getFolderCount() > 0 and getFirstFolder() <> "media" then drives.insert(d$)
			endif
		// File count differs from fake drive, assume valid
		elseif count > 0
			drives.insert(d$)
		endif
	next i
endfunction


function matchStringArray(a as string[], b as string[])
	if a.length <> b.length then exitfunction 0
	for i = 1 to a.length
		if a[i] <> b[i] then exitfunction 0
	next i
endfunction 1


function getCurrentFileArray(f ref as string[])
	f.length = -1
	f.length = getFileCount()
	f[1] = getFirstFile()
	for i = 2 to f.length
		f[i] = getNextFile()
	next i
	f.sort()
endfunction

// Project: file selector 
// Created: 2017-02-14

// show all errors
SetErrorMode(2)

// set window properties
SetWindowTitle( "file selector" )
SetWindowSize( 1024, 768, 0 )

// set display properties
SetVirtualResolution( 1024, 768 )
SetOrientationAllowed( 1, 1, 1, 1 )
SetSyncRate( 30, 0 ) // 30fps instead of 60 to save battery
UseNewDefaultFonts( 1 ) // since version 2.0.20 we can use nicer default fonts






if getFileExists("wallpaper.jpg") = 1
	createSprite(loadImage("wallpaper.jpg"))
else
	http = createHTTPConnection()
	ret = setHTTPHost(http, "powellong.com", 0)
	getHTTPFile(http, "data/wallpapers/12/WDF_606421.jpg", "wallpaper.jpg", "")

	while getHTTPFileComplete(http) = 0
	endwhile
	
	if getHTTPResponseReady(http) = 1 then createSprite(loadImage("wallpaper.jpg"))
	
	CloseHTTPConnection(http)
	DeleteHTTPConnection(http)
endif







global shadow



mem = makeMemblockImage(600, 400, E2DC_ARGB(128,0,0,0))

mem2 = makeMemblockImage(600, 400, 0)
mem_rounded_box(mem2, 10, 10, 590, 390, 0, E2DC_ARGB(128,0,0,0), 1, 0)




img2 = createImageFromMemblock(mem2)



shadow = createSprite(img2)


// Shader code from CJB
if getFileExists("blur.ps") = 0
	f = openToWrite("blur.ps")
	
	writeLine(f, "uniform sampler2D texture0;varying vec2 posVarying;varying vec2 uvVarying;uniform vec2 agk_resolution;uniform float BlurSize;")
	writeLine(f,"float blurSizeH = BlurSize / agk_resolution.x;float blurSizeV = BlurSize / agk_resolution.y;")
	writeLine(f,"void main(){")
	writeLine(f,"vec4 sum = vec4(0.0);for (float x = -4.0; x <= 4.0; x++)for (float y = -4.0; y <= 4.0; y++)")
	writeLine(f,"sum += texture2D(texture0,vec2(uvVarying.x + x * blurSizeH, uvVarying.y + y * blurSizeV))/ 81.0;gl_FragColor = sum;}")
	closeFile(f)
endif


BlurShaderID=LoadSpriteShader("blur.ps")
SetSpriteShader(shadow, BlurShaderID)
setShaderConstantByName(BlurShaderID, "BlurSize",4,0,0,0)






color = makeColor(212,212,212)


Type ThumbObject
	spr as integer
	height as integer
	percent as float
	maxScroll as integer
	yPos as float
EndType

Type WindowObject
	spr as integer[4]
	guides as integer[6]
	x as integer
	y as integer
	width as integer
	height as integer
	borderThickness as integer
	pad as integer
	folders as string[]
	files as integer[]
	text as integer[]
	viewOffset as float
	maxScroll as integer
	textSize as integer
	thumb as ThumbObject
	folderViewHeight as integer
	folderViewportHeight as integer
	curPath as string
	selectedFolderId as integer
	maxFileWidth as integer
EndType


w as WindowObject
w.borderThickness = 1
w.width = 600
w.height = 400
w.pad = 4
w.textSize = 16

w.thumb.spr = createSprite(0)
setSpriteSize(w.thumb.spr, 5, 100)

// main body
w.spr[1] = createSprite(0)
setSpriteColor(w.spr[1], 25,50,83,228)
setSpriteSize(w.spr[1], 600,400)



// title bar
m = makeMemblockImage(224, 32, 0)

for i = 1 to 31
	mem_line(m, 1+(31-i), i, 224-(31-i), i, makeColor(25,50,83), 0)
next i

mem_line(m, 1, 31, 31, 1, makeColor(44,92,154), 1)
mem_line(m, 224, 31, 194, 1, makeColor(44,92,154), 1)
mem_line(m, 31, 1, 194, 1, makeColor(44,92,154), 1)

w.spr[4] = createSprite(createImageFromMemblock(m)) : deleteMemblock(m)
setSpriteColorAlpha(w.spr[4], 228)


// resize icon
m = makeMemblockImage(32, 32, 0)
mem_line(m, 1,31,31,1,makeColor(255,255,255), 0)
mem_line(m, 10,31,31,10,makeColor(255,255,255), 0)
mem_line(m, 20,31,31,20,makeColor(255,255,255), 0)

w.spr[2] = createSprite(createImageFromMemblock(m)) : deleteMemblock(m)
setSpritePosition(w.spr[2], 100,100)
setSpriteColor(w.spr[2],44,92,154,228)

// folder selection highlight
w.spr[3] = createSprite(0)
setSpriteSize(w.spr[3], 150, w.textSize)
setSpriteColor(w.spr[3], 39,122,229,128)



w.guides[1] = createSprite(0) : setSpriteColor(w.guides[1], 44,92,154,228) : setSpriteSize(w.guides[1], w.width+w.borderThickness*2, w.borderThickness)
w.guides[2] = cloneSprite(w.guides[1]) 
w.guides[3] = cloneSprite(w.guides[1]) : setSpriteSize(w.guides[3], w.borderThickness, w.height)
w.guides[4] = cloneSprite(w.guides[3])
w.guides[5] = cloneSprite(w.guides[3])
w.guides[6] = cloneSprite(w.guides[3])






positionWindow(w, 50, 75)
resizeWindow(w, 600, 400)





drives as string[]
getDrives(drives)


setFolderView(w, "c:\")


	
do



    
    if getRawMouseLeftPressed() = 1
		x = getRawMouseX()
		y = getRawMouseY()
		x1 = w.x+w.width
		y1 = w.y+w.height
		
		// resize 
		if x > x1-30 and x < x1 and y > y1-30 and y < y1 and resizeFlag = 0
			ox = x1 - x
			oy = y1 - y
			resizeFlag = 1
		endif
		
		// folder selection
		if x > w.x and x < w.x+150 and y > w.y+w.pad and y < w.y+w.height-w.pad		
			w.selectedFolderId = ((y+w.viewOffset) - w.y) / w.textSize - 1
			
			sy = w.selectedFolderId*w.textSize + w.y + w.pad - w.viewOffset
			setSpritePosition(w.spr[3], w.x, sy)
			
				p$ = w.curPath + w.folders[w.selectedFolderId+1]
				`SetFolder("")
				SetRawWritePath(p$)
				getFileObjects(w.files, w)
				/*
				w.files.length = 0
				w.files.length = getFileCount()
				`w.files[1] = getFirstFile()
				w.files[1] = createText(getFirstFile())
				setTextSize(w.files[1], w.textSize)
				for i = 2 to w.files.length
					w.files[i] = createText(getNextFile())
					setTextSize(w.files[i], w.textSize)
				next i
				w.files.sort()
			*/
		endif
		
		
		// grab title bar
		if x > w.x+50 and x < w.x+274 and y < w.y and y > w.y-32
			ox = w.x - x
			oy = w.y - y
			moveFlag = 1
		endif
	endif
    
   `print(p$) 
        
    
    if GetRawMouseLeftState() = 1
		x = getRawMouseX()
		y = getRawMouseY()
		if resizeFlag = 1
			resizeWindow(w, x-w.x+ox, y-w.y+oy)
		endif
		if moveFlag = 1
			positionWindow(w, x+ox, y+oy)
		endif
	else
		resizeFlag = 0
		moveFlag = 0
	endif
    
    


	// mouse wheel scrolling
	
	scroll = GetRawMouseWheelDelta()

	if scroll <> 0 then amount# = amount# + 5
	if amount# > 18 then amount# = 18
	if scroll > 0
		d = -1
	elseif scroll < 0
		d = 1
	endif
	
	
	
	if amount# > 0
		w.thumb.yPos = w.thumb.yPos + amount#*d
		if w.thumb.yPos < 0 then w.thumb.yPos = 0
		if w.thumb.yPos > w.thumb.maxScroll then w.thumb.yPos = w.thumb.maxScroll
		
		// avoid division by zero
		if w.thumb.maxScroll > 0
			w.thumb.percent = (w.thumb.yPos / w.thumb.maxScroll)
		else
			w.thumb.percent = 0
		endif
	
		w.viewOffset = (w.folderViewHeight - w.folderViewportHeight) * w.thumb.percent

		dec amount#, 1
		positionWindow(w, w.x, w.y)
	endif



	print(w.maxFileWidth)


    Sync()
loop


				
function getFileObjects(files ref as integer[], w ref as WindowObject)

	local temp as string[]
	temp.length = getFileCount()
	
	temp[0] = getFirstFile()
	for i = 1 to temp.length
		temp[i] = getNextFile()
	next i
	temp.sort()
	
	
	w.maxFileWidth = 0

	for i = 0 to temp.length-1
		if i <= files.length
			setTextString(files[i], temp[i])
		else
			files.insert(createText(temp[i]))
			setTextSize(files[i], w.textSize)
		endif
		width = getTextTotalWidth(files[i])
		if width > w.maxFileWidth then w.maxFileWidth = width
	next i

	if temp.length <> files.length
		for i = temp.length to files.length

		next i
	endif

	temp.length = -1
endfunction



function getDrives(drives ref as string[])
	
	local _ghostFiles as string[]

	// Get ghost files (files that appear everywhere, even non-existent drives)
	SetFolder("")
	SetRawWritePath("(0)(0)")
	getCurrentFileArray(_ghostFiles)
	_ghostFiles.sort()

	// Drive letters A through Z
	for i = 0 to 25
		d$ = chr(i+65)+":\"

		SetFolder("")
		SetRawWritePath(d$)
		
		count = getFileCount()

		// If file count of this drive is same as the fake drive, compare (sorted) files
		if count = _ghostFiles.length
			temp as string[]
			getCurrentFileArray(temp)
			// If file arrays don't match, then this drive contains other legit files. It is valid
			if matchStringArray(_ghostFiles, temp) = 0
				drives.insert(d$)
			else
				if getFolderCount() > 0 and getFirstFolder() <> "media" then drives.insert(d$)
			endif
		// File count differs from fake drive, assume valid
		elseif count > 0
			drives.insert(d$)
		endif
	next i
endfunction

    

function matchStringArray(a as string[], b as string[])
	if a.length <> b.length then exitfunction 0
	for i = 1 to a.length
		if a[i] <> b[i] then exitfunction 0
	next i
endfunction 1


function getCurrentFileArray(f ref as string[])
	f.length = -1
	f.length = getFileCount()
	f[1] = getFirstFile()
	for i = 2 to f.length
		f[i] = getNextFile()
	next i
	f.sort()
endfunction








function setFolderView(w ref as WindowObject, path as string)
	
	w.curPath = path
	SetFolder("")
	SetRawWritePath(path)

	w.folders.length = getFolderCount()
	w.text.length = w.folders.length
	
	w.folders[1] = getFirstFolder()
	for i = 2 to w.folders.length
		w.folders[i] = getNextFolder()
	next i
	w.folders.sort()

	for i = 1 to w.folders.length
		w.text[i] = createText(w.folders[i])
		setTextSize(w.text[i], w.textSize)
		setTextColor(w.text[i],235,248,251,255)
	next i
	
	// to refactor the scroll bar size
	resizeWindow(w, w.width, w.height)
	
endfunction



function resizeWindow(w ref as WindowObject, width as integer, height as integer)
	w.width = width
	w.height = height
	setSpriteSize(w.spr[1], w.width, w.height)
	setSpriteSize(shadow, w.width+24, w.height+24)


	// window borders
	setSpriteSize(w.guides[1], w.width+w.borderThickness*2, w.borderThickness)
	setSpriteSize(w.guides[2], w.width+w.borderThickness*2, w.borderThickness)
	setSpriteSize(w.guides[3], w.borderThickness, w.height)
	setSpriteSize(w.guides[4], w.borderThickness, w.height)
	
	// scroll tracks
	setSpriteSize(w.guides[5], w.borderThickness, w.height)
	setSpriteSize(w.guides[6], w.borderThickness, w.height)

	// max scroll amount for left-side folder list
	w.folderViewHeight = w.text.length*w.textSize
	w.folderViewportHeight = w.height - w.pad*2
	

	
	// calc thumb size
	v# = w.folders.length*w.textSize
	f# = w.height / v#

	if f# > 1 then f# = 1
	w.thumb.height = w.height*f#
	w.thumb.maxScroll = w.height - w.thumb.height
	if w.thumb.maxScroll < 0 then w.thumb.maxScroll = 0
	
	setSpriteSize(w.thumb.spr, 5, w.thumb.height)
	
	// avoid division by zero
	if w.thumb.maxScroll > 0
		w.thumb.percent = (w.thumb.yPos / w.thumb.maxScroll)
	else
		w.thumb.percent = 0
	endif
	
	// keep thumb size updated while resizing window
	if w.thumb.yPos < 0 then w.thumb.yPos = 0
	if w.thumb.yPos > w.thumb.maxScroll then w.thumb.yPos = w.thumb.maxScroll
		
	w.viewOffset = (w.folderViewHeight - w.folderViewportHeight) * w.thumb.percent

	// positioning window also refactors certain elements
	positionWindow(w, w.x, w.y)
	

endfunction




function positionWindow(w ref as WindowObject, x as integer, y as integer)
	w.x = x
	w.y = y
	
	setSpritePosition(shadow, x-12, y-12)
	
	// main window
	setSpritePosition(w.spr[1], x, y)
	// resize icon
	setSpritePosition(w.spr[2], x+w.width-31, y+w.height-31)
	// title bar
	setSpritePosition(w.spr[4], w.x+50, w.y-32)

	
	// window borders
	setSpritePosition(w.guides[1], w.x-w.borderThickness, w.y-w.borderThickness)
	setSpritePosition(w.guides[2], w.x-w.borderThickness, w.y+w.height)
	setSpritePosition(w.guides[3], w.x-w.borderThickness, w.y)
	setSpritePosition(w.guides[4], w.x+w.width, w.y)
	
	// tracks
	setSpritePosition(w.guides[5], w.x+150, w.y)
	setSpritePosition(w.guides[6], w.x+156, w.y)

	
	// folder list
	for i = 1 to w.text.length
		y = (w.y+w.pad+(i-1)*w.textSize) - w.viewOffset
		setTextPosition(w.text[i], w.x+w.pad, y)
		setTextScissor(w.text[i], w.x, w.y+w.pad, w.x+150-w.pad, w.y+w.height-w.pad)
	next i
	
	// scroll thumb
	setSpritePosition(w.thumb.spr, w.x+151, w.y+w.thumb.yPos)
	
	
	
	// folder highlight
	sy = w.selectedFolderId*w.textSize + w.y + w.pad - w.viewOffset
	setSpritePosition(w.spr[3], w.x, sy)
	
	setSpriteScissor(w.spr[3], w.x, w.y+w.pad, w.x+150, w.y+w.height-w.pad)
	
	
	tw# = w.height-w.pad-32
	maxRows = tw# / w.textSize - 2
	c = 0
	r = 0
	// file list
	for i = 1 to w.files.length
		setTextPosition(w.files[i], w.x+155+w.pad+c*(w.maxFileWidth+w.pad), w.y+w.pad+r*w.textSize)
		setTextScissor(w.files[i], w.x+155+w.pad, w.y+w.pad, w.x+w.width-w.pad, w.y+w.height-32)
		inc r, 1
		if r > maxRows
			r = 0
			inc c
		endif
	next i
	
	
endfunction




REM *****************************************************************
REM
REM Creates a memblock with a 32-bit image structure.
REM 
REM 
REM        -= Parameters =-
REM  mem                - memblock number to create
REM  width              - Width of image
REM  height             - height of image
REM  color              - Fill color (0 to leave blank/transparent)
REM *****************************************************************
function makeMemblockImage(width, height, color)
	size = width*height*4+12
	mem = createMemblock(size)
	
	setMemblockInt(mem, 0, width)
	setMemblockInt(mem, 4, height)
	setMemblockInt(mem, 8, 32)
	
	
	if color <> 0
		for y = 0 to height-1
			for x = 0 to width-1
				pos = (y*width + x)*4 + 12
				setMemblockInt(mem, pos, color)
			next x
		next y
	endif
endfunction mem
 
 

 
REM *****************************************************************
REM
REM Draws an AA line using Xialon Wu's algorithm
REM 
REM 
REM        -= Parameters =-
REM  mem                - memblock number to draw to
REM  [x1,y1]            - Starting coordinate of line
REM  [x2,y2]            - Ending coordinate of line
REM  color              - Color of circle
REM  preserveBackground - TRUE keeps current memblock pixels, 
REM                           using alpha-compositing to draw on top of them
REM                     - FALSE replaces current memblock pixels.
REM *****************************************************************
function mem_line(mem, x1, y1, x2, y2, color, preserveBackground)
    local dx as float
    local dy as float
    local xend as float
    local yend as float
    local xgap as float
    local ygap as float
    local xpxl1 as float
    local ypxl1 as float
    local xpxl2 as float
    local ypxl2 as float
    local intery as float
    local interx as float
     
    width  = getMemblockInt(mem, 0)
    height = getMemblockInt(mem, 4)
         
    red   = rgbr(color)
    green = rgbg(color)
    blue  = rgbb(color)
     
    dx = x2-x1
    dy = y2-y1
         
    if abs(dx) > abs(dy)
        rem handle horizontal lines
        if x2 < x1
            ax = x1                 
            x1 = x2
            x2 = ax
            ay = y1
            y1 = y2
            y2 = ay
        endif
        gradient# = dy / dx
                 
        rem handle first endpoint
        xend = ceil(x1)
        yend = y1 + gradient# * (xend-x1)
        xgap = 1.0 - fract#(x1 + 0.5)
        xpxl1 = xend : `used in main loop
        ypxl1 = trunc(yend)
        f# = 1-fract#(yend)*xgap : `brightness
        alpha = 255*f#
        c = E2DC_ARGB(alpha, red, green, blue)
        mem_dot(mem, xpxl1, ypxl1, c, preserveBackground)
        rem brightness: fract#(yend)*xgap
        f# = fract#(yend)*xgap : `brightness
        alpha = 255*f#
        c = E2DC_ARGB(alpha, red, green, blue)
        mem_dot(mem, xpxl1, ypxl1+1, c, preserveBackground)
        intery = yend + gradient# : `first y-intersection for main loop
 
        rem handle second endpoint
        xend = ceil(x2)
        yend = y2 + gradient# * (xend-x2)
        xgap = 1.0 - fract#(x2 + 0.5)
        xpxl2 = xend : `used in main loop
        ypxl2 = trunc(yend)
        f# = 1-fract#(yend)*xgap : `brightness
        alpha = 255*f#
        c = E2DC_ARGB(alpha, red, green, blue)
        mem_dot(mem, xpxl2, ypxl2, c, preserveBackground)
        f# = fract#(yend)*xgap : `brightness
        alpha = 255*f#
        c = E2DC_ARGB(alpha, red, green, blue)
        mem_dot(mem, xpxl2, ypxl2+1, c, preserveBackground)
         
        rem main loop
        a = xpxl1+1
        b = xpxl2-1
        for x = a to b
            f# = 1-fract#(intery) : `brightness
            alpha = 255*f#
            c = E2DC_ARGB(alpha, red, green, blue)
            mem_dot(mem, x, intery, c, preserveBackground)
            f# = fract#(intery) : `brightness
            alpha = 255*f#
            c = E2DC_ARGB(alpha, red, green, blue)
            mem_dot(mem, x, intery+1, c, preserveBackground)
            intery = intery + gradient#
        next x
                 
    else
        rem handle vertical lines
        if y2 < y1
            ax = x1
            x1 = x2
            x2 = ax
            ay = y1
            y1 = y2
            y2 = ay
        endif
         
        gradient# = dx / dy
         
        rem handle first endpoint
        yend = ceil(y1)
        xend = x1 + gradient# * (yend-y1)
        ygap = 1.0 - fract#(y1 + 0.5)
        xpxl1 = trunc(xend)
        ypxl1 = yend            
        f# = 1-fract#(xend)*ygap : `brightness
        alpha = 255*f#
        c = E2DC_ARGB(alpha, red, green, blue)
        mem_dot(mem, xpxl1, ypxl1, c, preserveBackground)
        intery = intery + gradient#
        f# = fract#(xend)*ygap : `brightness
        alpha = 255*f#
        c = E2DC_ARGB(alpha, red, green, blue)
        mem_dot(mem, xpxl1, ypxl1+1, c, preserveBackground)
        interx = xend + gradient# : `first y-intersection for main loop
 
        rem handle second endpoint
        yend = ceil(y2)
        xend = x2 + gradient# * (yend-y2)
        ygap = fract#(y2 + 0.5)
        xpxl2 = trunc(xend)
        ypxl2 = yend
        f# = 1-fract#(xend)*ygap : `brightness
        alpha = 255*f#
        c = E2DC_ARGB(alpha, red, green, blue)
        mem_dot(mem, xpxl2, ypxl2, c, preserveBackground)
        f# = fract#(xend)*ygap : `brightness
        alpha = 255*f#
        c = E2DC_ARGB(alpha, red, green, blue)
        mem_dot(mem, xpxl2, ypxl2+1, c, preserveBackground)
         
        rem main loop
        a = ypxl1+1
        b = ypxl2-1
        for y = a to b                  
            f# = 1-fract#(interx) : `brightness
            alpha = 255*f#
            c = E2DC_ARGB(alpha, red, green, blue)
            mem_dot(mem, interx, y, c, preserveBackground)
            f# = fract#(interx) : `brightness
            alpha = 255*f#
            c = E2DC_ARGB(alpha, red, green, blue)
            mem_dot(mem, interx+1, y, c, preserveBackground)
            interx = interx + gradient#
        next y
    endif
endfunction
 
 

 
REM *****************************************************************
REM
REM Draws a box with rounded corners
REM 
REM 
REM        -= Parameters =-
REM  mem                - memblock number to draw to
REM  [x1,y1]            - upper-left coordinates of box
REM  [x2,y2]            - lower-right coordinates of box
REM  radius             - radius of corners
REM  color              - Box color
REM  solid              - TRUE filled-in box, FALSE outline
REM  preserveBackground - TRUE keeps current memblock pixels, 
REM                           using alpha-compositing to draw on top of them
REM                     - FALSE replaces current memblock pixels.
REM *****************************************************************
function mem_rounded_box(mem, x1, y1, x2, y2, radius, color, solid, preserveBackground)
      mem_line(mem, x1+radius+2, y1, x2-radius-2, y1, color, preserveBackground)
      if solid = 0
            mem_line(mem, x1+radius+2, y2, x2-radius-2, y2, color, preserveBackground)
            mem_line(mem, x1, y1+radius+2, x1, y2-radius-2, color, preserveBackground)
            mem_line(mem, x2, y1+radius+2, x2, y2-radius-2, color, preserveBackground)
      else
            mem_box(mem, x1, y1+radius, x2, y2-radius, color, 1, preserveBackground)
            `mem_line(mem, x1+radius, y1, x2-radius, y1, color, preserveBackground)
            mem_line(mem, x1+radius, y2, x2-radius, y2, color, preserveBackground)
      endif
       
 
      local alpha1
      local alpha2
       
      red = rgbr(color)
      green = rgbg(color)
      blue = rgbb(color)
       
      h = y2 - y1
      w = x2 - x1
      cx = x1
      cy = y1
 
      x = radius
      y = -1
      t# = 0
      r = radius
       
      while x > y
            inc y
            cur_dist# = E2DC_Distance#(r, y)
            if cur_dist# < t# then dec x
             
             
            if x <> y
                  rem anti-aliased pixels inside the circle
                  c = 127*cur_dist#       : alpha1 = E2DC_ARGB(c, red, green, blue)
                  rem anit-aliased pixels outside the circle
                  c = 127 - c             : alpha2 = E2DC_ARGB(c, red, green, blue)      
                   
                  rem Either fill in the middle or draw inside AA pixels
                  if solid = 1
                        mem_box(mem, cx-y+r,   cy-x+1+r, cx+y+w-r,   cy-x+1+r, color, 1, preserveBackground)
                        mem_box(mem, cx-x+1+r, cy-y+r,   cx+x-1+w-r, cy-y+r,   color, 1, preserveBackground)
                        mem_box(mem, cx-x+1+r+1, cy+y+h-r-1, cx+x-1+w-r-1, cy+y+h-r-1, color, 1, preserveBackground)
                        mem_box(mem, cx-y+r+1,   cy+x+h-r-1, cx+y+w-r-1,   cy+x+h-r-1, color, 1, preserveBackground)
                  else
                        mem_dot(mem, cx-y+r,   cy-x+1+r,   alpha1, preserveBackground)
                        mem_dot(mem, cx-x+1+r, cy-y+r,     alpha1, preserveBackground)
                        mem_dot(mem, cx-x+1+r, cy+y+h-r,   alpha1, preserveBackground)
                        mem_dot(mem, cx-y+r,   cy+x-1+h-r, alpha1, preserveBackground)
                         
                        mem_dot(mem, cx+y+w-r,   cy+x-1+h-r, alpha1, preserveBackground)
                        mem_dot(mem, cx+x-1+w-r, cy+y+h-r,   alpha1, preserveBackground)
                        mem_dot(mem, cx+x-1+w-r, cy-y+r,     alpha1, preserveBackground)
                        mem_dot(mem, cx+y+w-r,   cy-x+1+r,   alpha1, preserveBackground)
                         
                  endif
                   
                  rem octant 1
                  mem_dot(mem, cx-y+r+1,   cy-x+r+1,   color,  preserveBackground)
                  mem_dot(mem, cx-y+r+1,   cy-x-1+r+1, alpha2, preserveBackground)
                  rem octant 2
                  mem_dot(mem, cx-x+r+1,   cy-y+r+1, color,  preserveBackground)
                  mem_dot(mem, cx-x-1+r+1, cy-y+r+1, alpha2, preserveBackground)
                   
                  rem octant 3
                  mem_dot(mem, cx-x+r+1,   (cy+y+h-r)-1, color,  preserveBackground)
                  mem_dot(mem, cx-x-1+r+1, (cy+y+h-r)-1, alpha2, preserveBackground)
                  rem octant 4
                  mem_dot(mem, cx-y+r+1,   (cy+x+h-r)-1,   color,  preserveBackground)
                  mem_dot(mem, cx-y+r+1,   (cy+x+1+h-r)-1, alpha2, preserveBackground)
                  rem octant 5
                  mem_dot(mem, cx+y+w-r-1,   cy+x+h-r-1,   color,  preserveBackground)
                  mem_dot(mem, cx+y+w-r-1,   cy+x+1+h-r-1, alpha2, preserveBackground)
                  rem octant 6
                  mem_dot(mem, cx+x+w-r-1,   cy+y+h-r-1, color,  preserveBackground)
                  mem_dot(mem, cx+x+1+w-r-1, cy+y+h-r-1, alpha2, preserveBackground)
                  rem octant 7
                  mem_dot(mem, cx+x+w-r-1,   cy-y+r+1, color,  preserveBackground)
                  mem_dot(mem, cx+x+1+w-r-1, cy-y+r+1, alpha2, preserveBackground)
                  rem octant 8
                  mem_dot(mem, cx+y+w-r-1,   cy-x+r+1,   color,  preserveBackground)
                  mem_dot(mem, cx+y+w-r-1,   cy-x-1+r+1, alpha2, preserveBackground)
                   
            endif     
            t# = cur_dist#
      endwhile
endfunction
 
 
 
REM *****************************************************************
REM
REM Draws a box
REM 
REM 
REM        -= Parameters =-
REM  mem                - memblock number to draw to
REM  [x1,y1]            - upper-left coordinates of box
REM  [x2,y2]            - lower-right coordinates of box
REM  color              - Box color
REM  solid              - TRUE filled-in box, FALSE outline
REM  preserveBackground - TRUE keeps current memblock pixels, 
REM                           using alpha-compositing to draw on top of them
REM                     - FALSE replaces current memblock pixels.
REM *****************************************************************
function mem_box(mem, x1, y1, x2, y2, color, solid, preserveBackground)
      if solid = 0
            for x = x1 to x2
                  mem_dot(mem, x, y1, color, preserveBackground)
                  mem_dot(mem, x, y2, color, preserveBackground)
            next x
            for y = y1 to y2
                  mem_dot(mem, x1, y, color, preserveBackground)
                  mem_dot(mem, x2, y, color, preserveBackground)
            next y
      else
            for y = y1 to y2
                  for x = x1 to x2
                        mem_dot(mem, x, y, color, preserveBackground)
                  next x
            next y
      endif
endfunction
 


 
REM *****************************************************************
REM
REM Draws a dot to the memblock image
REM 
REM 
REM        -= Parameters =-
REM  mem                - memblock number to draw to
REM  [x,y]              - Coordinates of dot
REM  color              - Color of dot
REM  preserveBackground - TRUE keeps current memblock pixels, 
REM                           using alpha-compositing to draw on top of them
REM                     - FALSE replaces current memblock pixels.
REM *****************************************************************
function mem_dot(mem, x, y, color, preserveBackground)
	pos = ((y-1)*getMemblockInt(mem, 0) + (x-1))*4 + 12
	if preserveBackground
		c = getMemblockInt(mem, pos)

		if c >> 24 > 0 then color = getAlphaComposite(c, color)
	endif
	setMemblockInt(mem, pos, color)
endfunction




REM **************************************************
REM Truncates the integer part of a float and returns
REM just the decimal value
REM **************************************************
function fract#(x as float)
    a# = x - trunc(x)
endfunction a#
 
 

REM **************************************************
REM Returns a color with an alpha value
REM **************************************************
function E2DC_ARGB(a,r,g,b)
    c = (a*16777216)+(b*65536)+(g*256)+r
endfunction c
 
 
 
REM **************************************************
REM Returns fractional part of distance
REM   * Needed for Xiaolin Wu functions
REM **************************************************
function E2DC_Distance#(a, b)
    real# = sqrt(a^2 - b^2)
    d# = ceil(real#) - real#
endfunction d#



REM *****************************************************************
REM
REM Returns new color using alpha compositing
REM 
REM 
REM    -= Parameters =-
REM  base   - Color of base layer
REM  above  - Color above base layer 
REM           (what you're trying to merge on top of the base)
REM *****************************************************************
function getAlphaComposite(base, above)

      ab = base >> 24
      rb = rgbr(base)
      gb = rgbg(base)
      bb = rgbb(base)
      ab# = ab / 255.0
       
      aa = above >> 24
      ra = rgbr(above)
      ga = rgbg(above)
      ba = rgbb(above)
      aa# = aa / 255.0
       
      red   = ra*aa# + rb*ab#*(1-aa#)
      green = ga*aa# + gb*ab#*(1-aa#)
      blue  = ba*aa# + bb*ab#*(1-aa#)
      alpha = (aa# + ab#*(1-aa#)) * 255
       
      c = E2DC_ARGB(alpha, red, green, blue)
       
endfunction c
 
 
 


function rgbr(c)
	c = c && 255
endfunction c

function rgbg(c)
	c = (c >> 8) && 255
endfunction c

function rgbb(c)
	c = (c >> 16) && 255
endfunction c

#constant xMax=800
#constant yMax=600
#constant Bg=1000

// show all errors
SetErrorMode(2)

// set window properties
SetWindowTitle( "Demo" )
SetWindowSize( xMax, yMax, 0 )

// set display properties
SetVirtualResolution( xMax, yMax )
SetOrientationAllowed( 1, 1, 1, 1 )
SetSyncRate( 30, 0 ) // 30fps instead of 60 to save battery
UseNewDefaultFonts( 1 ) // since version 2.0.22 we can use nicer default fonts

rem for circle
type textSpr
	id as integer
	angle as integer
	img as integer
endtype 

rem for sinewave
type myText
	id as integer		:rem id of sprite
	PointX as integer	:rem makes it move
	centreX as integer  :rem centre of sine wave x axis
	yPosition as integer:rem yPosition on y-axis
	amplitude as integer:rem the heaight of the wave
	speedX# as float	:rem how fast sine travels on x-axis
	WaveWidth as integer:rem how wide the sinewave is
	frequency# as float	:rem speed sprite should move up and down (0.0 to 6.0)
	img as integer		:rem holds the image number for the sprite
endtype


SetClearColor(0,0,0)

rem the circle text
text$=invertText("2017 Scrolling Mega Demo by fubarpk using AGK "):strlen=len(text$)	
global dim spr[strlen] as textSpr
Rem Move a sprite around a circle
Rem Create a white squared sprite by using image 0
for num = 0 to strlen
	spr[num].id=num+1:rem the id to rotate
	spr[num].img=num+1:rem holds the image
	spr[num].angle=num*8:rem the angle of the rotation(0 - 360)/A point around the circumference(the circle)
	createTextImage(Mid(text$,num+1,1),spr[num].img)
	CreateSprite(spr[num].id,spr[num].img)
	SetSpriteColor(spr[num].id, Random(1,255),Random(1,255), Random(1,255), 255 ) 
	SetSpriteTransparency(spr[num].id,1)
next num

rem sine text
text$=invertText("Just another sine scrolling text"):strlen2=len(text$)
global dim spr2[strlen2] as myText
for num=1 to strlen2 
	spr2[num].id=num+100:spr2[num].img=num+100
	spr2[num].centreX=xMax/2
	spr2[num].yPosition=yMax/2
	spr2[num].amplitude=20
	spr2[num].speedX#=.51
	spr2[num].WaveWidth=xMax
	spr2[num].frequency#=1.4
	spr2[num].PointX=90-(num*3)
	createTextImage(Mid(text$,num,1),spr2[num].img)
	createSprite(spr2[num].id,spr2[num].img)
	SetSpriteColor(spr2[num].id, Random(1,255),Random(1,255), Random(1,255), 255 ) 
	SetSpriteTransparency(spr2[num].id,1)
	SetSpriteDepth(spr2[num].id,10)
	//SetSpritePhysicsOn(spr2[num].id,1)
next num 




Rem set up the variables. Variables is used here for explanation and reuseability
rem the diameter of the circle (the width or height)
` using the same value for diameterX and DiameterY will create a circle
` using different values will create an oval
diameterX = 200
diameterY = 200
rem The x Value of the centre of the circle
centreX = xMax/2
 rem The Y Value of the centre of the circle
centreY = yMax/2
Rem Steps is how fast the sprite should move (a Value of 1 draws the sprite at every point around the circle)
steps = 1



yFlag=1
global flag=1
do
    
	// circle scroller
	if yFlag=1 
		dec diameterY
		if diameterY <=-200 then yFlag=0
	elseif yFlag=0
		inc diameterY
		if diameterY >=200 then yFlag=1
	endif
	
	rem Position the sprite using the math commands Sin and Cos (Sin for x and Cos for y)
	for num = 0 to strlen 
		//setspritePosition(spr[num].id,Sin(spr[num].angle)*diameterX+centreX,Cos(Sin(spr[num].angle)*diameterY+centreY))
		setspritePosition(spr[num].id,Sin(spr[num].angle)*diameterX+centreX,Cos(spr[num].angle)*diameterY+centreY)
		rem check if the sprite has moved full circle (360 degrees) then set it back to zero if it has.
		` Use greater than -360 ( > -360 ) and subtract before steps ( angle - steps ) to move opposite direction
		` It is possible to skip the check for 360 (full circle) and only decreas/increase the angle
		` but then the angle value will decrease or increase forever
		if spr[num].angle < 360
			spr[num].angle = spr[num].angle + steps
		else
			spr[num].angle = 0
		endif
	next num
	
	//sine scroller
	circleScroll(strlen2)

 Sync()
loop
function createTextImage (myString as string,imgNum as integer)
CreateSprite(bg,0)
SetSpriteSize(bg,150,150)
SetSpriteColor(bg,0,0,0,255)
clearscreen()
CreateText(100,myString)
SetTextSize(100,50)
SetTextPosition(100,0,0)
//drawSprite(100)
//if myString <> 
Render():If GetImageExists(imgNum) then DeleteImage(imgNum)
GetImage(imgNum,0,0,50,50):ClearScreen()
SetImageTransparentColor( imgNum,0,0,0 )
DrawSprite(bg)
ClearScreen()
DeleteText(100):deleteSprite(bg)
endfunction

function invertText(myString as string)
	resultString as string
	for num =len(myString) to 1 step -1
		resultString=resultString+Mid(myString,num,1)
	next num	
endfunction resultString

function circleScroll(strlen as integer)
//if delay# > .05 
for num = 1 to strlen
	xWave=Sin(spr2[num].PointX)*(spr2[num].wavewidth/2)+spr2[num].centreX
	yWave=sin(xWave*spr2[num].frequency#)*(spr2[num].amplitude)+spr2[num].yposition
	SetSpritePosition(spr2[num].id,xWave,yWave)
  
	if spr2[num].PointX >-90
		spr2[num].PointX = spr2[num].PointX - spr2[num].speedX#
		if spr2[num].amplitude>=20 and flag=1  
			spr2[num].amplitude=spr2[num].amplitude+2
			if spr2[num].amplitude>=180 then flag=0
		endif
		if spr2[num].amplitude >0 and flag=0 
			spr2[num].amplitude=spr2[num].amplitude-2
			if spr2[num].amplitude<=20 then flag=1
		endif
	else
		spr2[num].PointX = 90
	endif
	
		
	If GetSpriteX(spr2[num].id)<xMax/2 
		SetSpriteDepth(spr2[num].id,15)
	else 
		SetSpriteDepth(spr2[num].id,5)
	endif
next num
endfunction