'
' This program was written with BLIde
' Application: Auto Tidy PlugIn for BLIde
' Author: Manel Ib摙ez	
' License: GPL
'

SuperStrict
Import blide.plugins
Global PlugInEngine:BPPMainEngine = New BPPMainEngine
PlugInEngine.StartEngine("Auto Tidy",0,1,"Manel Ibanez")
PlugInEngine.SelectionActions.SelectAllText()
PlugInEngine.InOutActions.Trace("Getting code...")
PlugInEngine.GetSelectedText()
PlugInEngine.InOutActions.MsgBox("This PlugIn will arrange the TABs in your source code")
PlugInEngine.InOutActions.Trace("Calculating identation")

Local TabCounter:Int = 0
For Local i:blide.plugins.TCodeLine  = EachIn PlugInEngine.Code
	
	i.Contens = Trim(i.Contens)
	While Left(i.Contens,1) = Chr(9)
		i.Contens = Mid(i.Contens,2)
		i.Contens = Trim(i.Contens)
	Wend
	Local strip:String = i.Contens
	If begins(strip,"next ") = True or i.Contens.ToLower() = "next" Then tabcounter:-1
	If begins(strip,"wend ") = True or i.Contens.ToLower() = "wend" Then tabcounter:-1
	If begins(strip,"EndType ") = True or strip.ToLower() = "endtype" Then 	tabcounter:-1
	If begins(strip,"End Type ") = True or strip.ToLower() = "end type" Then tabcounter:-1
	If begins(strip,"EndSelect ") = True or strip.ToLower() = "endselect" Then 	tabcounter:-1
	If begins(strip,"End Select ") = True or strip.ToLower() = "end select" Then tabcounter:-1
	If begins(strip,"EndMethod ") = True or strip.ToLower() = "endmethod" Then 	tabcounter:-1
	If begins(strip,"End Method ") = True or strip.ToLower() = "end method" Then tabcounter:-1
	If begins(strip,"EndFunction ") = True or strip.ToLower() = "endfunction" Then 	tabcounter:-1
	If begins(strip,"End Function ") = True or strip.ToLower() = "end function" Then tabcounter:-1
	If tabcounter>0 Then
	For Local c:Int = 1 To tabcounter
		i.Contens = Chr(9) + i.Contens
	Next
	End If
	
	If begins(strip,"for ") = True or begins(strip,"Type ")Then	tabcounter:+1
	If begins(strip,"while ") = True or begins(strip,"Select ")Then	tabcounter:+1
	If begins(strip,"method ") = True or begins(strip,"function ")Then	tabcounter:+1
Next

PlugInEngine.SetSelectedText
PlugInEngine.InOutActions.MsgBox("Done!")

Function begins:Int(text:String, Begining:String)
	If Left(text.ToLower(),Len(begining.ToLower())) = begining.ToLower() Then
		Return True
	Else
		Return False
	End If
End Function

'First of all, we create and start the PlugIn engine:
Global PlugInEngine:BPPMainEngine = New BPPMainEngine 
PlugInEngine.StartEngine

'Now we inform in the BLIde console that the PlugIn has been initialized:
PlugInEngine.Trace("Plug In started") 

'Now we force the PlugIn engine to retrieve all currently selected text in the BLIde editor.
PlugInEngine.GetSelectedText()

For Local L:TCodeLine = EachIn PlugInEngine.Code  
	'We write the code line in the BLIde console
	PlugInEngine.Trace( l.Contens ) 
Next             

'We inform with the BLIde message box that the PlugIn has ended
PlugInEngine.MsgBox("Done!")

end

'------------------------------------------------------------------------------------------------------------------
'Application: ++ and -- processor
'Author: Manel Ib摙ez
'------------------------------------------------------------------------------------------------------------------

Strict

'-------------------------------------------------------------------------------------
'This is the framework declaration needed by this Plug-In
Framework brl.basic
'-------------------------------------------------------------------------------------
'Needed to use the BPP protocol from BlitzMax:
Import "BLIdeBPP.bmx"

'Well, we begin the process. All the Plug-In have to start the BPP engine.
'We start the BPP engine this way:
BPP.initialize()
BPP.Trace "Initializing Plug-in"  'We inform in the BLIde console that we're initializing the Plug-In.

'We create a CodeManipulator object. This object retrieves all the source code to pluinize when it's created.
local Code:CodeManipulator = new CodeManipulator
flushmem	'when getting all the source, some elements are stored in the garbage collector.

'PROCESS THE SOURCE
'Now we have all the source code to pluginize.
BPP.trace "Processing data..." 'We inform, in the BLIde console, we're processing the text.

'First of all, we go to the first line of code:
Code.MoveFirst()
'And after that, we check alllines:
While code.CurrentLine() <> Null	'CurrentLine gets NULL when it raises the end of the code.
	code.CurrentLine().ReplaceInCode("++",":+1")
	code.CurrentLine().ReplaceInCode("--",":-1")
	code.nextline 'We move to next line of code.
	flushmem
wend
bpp.trace "Returning processed data to BLIde"

code.ReturnText
flushmem
	

'We inform the user that the Plug-in has ended:
Bpp.Trace "Plug-in applied. All ++ and -- have been changed to :+1 and :-1"
'The program ENDs. There's no need to tell BLIde the plug-in has ended, BLIde will detect it automaticaly.
End

Strict

'-------------------------------------------------------------------------------------------------------------
'This is the framework declaration needed by the BPP (BLIde Plug-In protocol), and this Plug-In:
Framework brl.basic
Import brl.system
'-------------------------------------------------------------------------------------------------------------

'Needed to use the BPP protocol from BlitzMax:
Import "BLIdeBPP.bmx"

'Well, we begin the process. All the Plug-In have to start the BPP engine.
'We start the BPP engine this way:
BPP.initialize()

'first of all, we display a message informing
'that this is the first Plug-In developed with the BPP engine:
BPP.DisplayMessage("This is the First Plug-in developed in BlitzMax for BLIde")

'Now we ask the BLIde user, if he/she wants to apply the plug-in or not.
Local ProcessPlugIn:Int 
ProcessPlugIn = BPP.YesOrNot("Do you want to apply the Plugin?")


if ProcessPlugIn = true then
	'We read all the text that has to be "pluginized", and store it in a String Array.
	local GetArray:String[] = BPP.GetText()
	flushmem	'when getting all the source, some elements are stored in the garbage collector.


	'We have all the text stored in the array GetArray.
	'We inform the user of the number of lines to process:
	bpp.displaymessage("The number of lines to process is: " + len(getarray))

	'PROCESS THE SOURCE
	'PUT YOUR PROCESS CODE HERE


	'After processing the code, we return the result to BLIde:
	bpp.ReturnText(getarray)
	flushmem
	
	'We inform the user that the Plug-in has ended:
	BPP.DisplayMessage("Plugin applied")



else
	'If the user has selected NOT to process the Plug-in, 
	'we inform that the plug-in won't be appied:
	BPP.DisplayMessage("Plugin not applied")
endif

'The program ENDs. There's no need to tell BLIde the plug-in has ended, BLIde will detect it automaticaly.
End