' Program to edit spike events
const chUnit%:=1;
var memchEvent%,memchInstantRate%,memchForWaveMark%;
var chUnitEvent%;
var vh%,hWave1%,hWave2%;
var WaveMarkDataPoint%,WaveMarkPreTrig%;
var ScreenWidth:=0.1;
var TrigLevel:=0.5;
var MinimumTimeBetweenTriggers:=0.7; 'in ms
var kIF%:=0;
var hcINC:=0.033333333333333;
var wave1n%:=1;
var wave2n%:=0;
var wave2X[10000000];
var wave2Y[10000000];
var wave1chancounter%:=0;
var wave1sTlist[256];
var wave1channr%:=1;
var displwave1channr%:=1;
var UnitSamplingInterval;
var Overlapsetting:=0;
'var TrigMode%:=8;
var SpikesTlist[256];
var pointer001%:=1;
var pointer255%:=255;
var pointermid%:=0;
'var pointerlast%:=0;
var HighlightChanNum%:=256;
var NumberOfSpike%:=0;
var KeepCursorCenter%:=0;

ArrConst(wave1sTlist[],-1);
ArrConst(SpikesTlist[],-1);

ToolbarClear();
ToolbarText("S P I K E   E D I T O R"); 'This avoids flickering
DoToolbar();

proc DoToolbar()
ToolbarSet(1,"Quit",Quit%);										'Set up toolbar buttons
ToolbarSet(2,"Open", Open%);
ToolbarSet(3,"&Delete", Delete%);
ToolbarSet(4,"&Add", Add%);
ToolbarSet(5,"Save",Save%);
ToolbarSet(6,"&Fetch cursor 0",Fetch%);
ToolbarSet(7,"Screen",ScreenRes%);
'ToolbarSet(8,"Set trigger",Trig%);
ToolbarSet(8,"&Take ALL",TakeAll%);
ToolbarSet(9,"Tab:Adv|0x09",Advance%);
ToolbarSet(10,"BkSp:Back|0x08",Back%);
ToolbarSet(11,"Show IF",InsFreq%);
ToolbarSet(12,"Set MTBT",SetInt%);
ToolbarSet(13,"hcUP|0x26",hcUP%);
ToolbarSet(14,"hcDOWN|0x28",hcDOWN%);
ToolbarSet(15,"Set Overlap",OverLapSet%);
ToolbarSet(16,"&Next",Wave1Next%);
ToolbarSet(17,"&Prev",Wave1Prev%);
ToolbarSet(18,"Keep Cursor Centered",CtrCsr%);


Toolbar("S P I K E   E D I T O R", 1023);
end;

func CtrCsr%()
KeepCursorCenter%:=1;
ToolbarSet(18,"Don't Keep Cursor Centered",NoCtrCsr%);
return 1;
end;

func NoCtrCsr%()
KeepCursorCenter%:=0;
ToolbarSet(18,"Keep Cursor Centered",CtrCsr%);
return 1;
end;


func AllSpikeDeleted%()
var mmm%,nnn%;

for nnn%:=0 to Len(SpikesTlist[])-1 do
	if SpikesTlist[nnn%]<>-1 then mmm%:=mmm%+1;endif;
Next;

if mmm%=0 then
	Message("All spikes were deleted...");
	return 0;
else
	return 1;
endif;

end;


func HowManySpikesDisplayed%()
var nnn%,mmm%,msgw$;
for nnn%:=pointer001% to pointer255% do
	if SpikesTlist[nnn%] <> -1 then
   	mmm%:=mmm%+1;
	endif;
Next;
View(hWave1%);msgw$:=Str$(mmm%) + " last accepted spikes shown. Total # spike that has been accepted is " + Str$(NumberOfSpike%);WindowTitle$(msgw$);View(vh%);
return mmm%;
end;

func FindItem%(Data[],theValue,deltavalue)
' output is the index of the array
' put very small value as Delta
var nnn%;
for nnn%:=0 to Len(Data[])-1 do
	if (Data[nnn%] >= (theValue-deltavalue)) and (Data[nnn%] <= (theValue+deltavalue)) then
		return nnn%;
	endif;
Next;
return -1; 'not found
end;


func UpdateSpkDisplay%();
var sT,eT,nn%;
var WaveData[WaveMarkDataPoint%+10],WaveDataX[WaveMarkDataPoint%+10];

for nn%:=0 to WaveMarkDataPoint%+9 do
	WaveDataX[nn%]:=nn% * UnitSamplingInterval;
next;

sT:=MaxTime();
ArrConst(SpikesTlist[],-1); ' init with -1

View(hWave1%);
for nn%:=1 to 255 do
	XYDelete(nn%);
Next;
if NumberOfSpike% > 0 then
	if NumberOfSpike% >= 255 then
		for nn%:=255 to 1 step -1 do
			View(vh%);
			sT:=LastTime(memchEvent%,sT);
			SpikesTlist[nn%]:=sT;
			eT:=sT + ((WaveMarkDataPoint%-1)*UnitSamplingInterval);
			ChanData(chUnit%,WaveData[],sT-(10*UnitSamplingInterval),eT);
			View(hWave1%);
			XYSetChan(nn%,0,0,1);XYDrawMode(nn%,2,0);
			XYAddData(nn%,WaveDataX[],WaveData[]);
			Optimise(-1);
		Next;
		pointer001%:=1;
		pointer255%:=255;
		pointermid%:=255;
	else
		for nn%:=NumberOfSpike% to 1 step -1 do
			View(vh%);
			sT:=LastTime(memchEvent%,sT);
			SpikesTlist[nn%]:=sT;
			eT:=sT + ((WaveMarkDataPoint%-1)*UnitSamplingInterval);
			ChanData(chUnit%,WaveData[],sT-(10*UnitSamplingInterval),eT);
			View(hWave1%);
			XYSetChan(nn%,0,0,1);XYDrawMode(nn%,2,0);
			XYAddData(nn%,WaveDataX[],WaveData[]);
			Optimise(-1);
		Next;
		pointer001%:=1;
		pointer255%:=NumberOfSpike%;
		pointermid%:=NumberOfSpike%;
	endif;
else
	pointer001%:=1;
	pointer255%:=255;
	pointermid%:=0;
endif;
View(vh%);
return 1;
end;

func HighLight%(whichone%)
var WaveData[WaveMarkDataPoint%+10],WaveDataX[WaveMarkDataPoint%+10],nnn%;
for nnn%:=0 to WaveMarkDataPoint%+9 do
	WaveDataX[nnn%]:=nnn% * UnitSamplingInterval;
next;
' set highlight to last spike
View(vh%);
Cursor(0,SpikesTlist[whichone%]);
ChanData(chUnit%,WaveData[],SpikesTlist[pointermid%]-(10*UnitSamplingInterval),SpikesTlist[pointermid%]+((WaveMarkDataPoint%-1)*UnitSamplingInterval));
View(hWave1%);
XYDelete(HighlightChanNum%);
XYAddData(HighlightChanNum%,WaveDataX[],WaveData[]);XYColour(HighlightChanNum%,16);
View(vh%);
return 1;
end

func Wave1Next%()
if pointermid% >= pointer255% then return 1; endif
var tempx[WaveMarkDataPoint%+10],tempy[WaveMarkDataPoint%+10];
while 1 do
	if (pointermid% >= pointer255%) and (pointermid% <= pointer001%) then return 1; endif
	pointermid%:=pointermid%+1; if pointermid% > pointer255% then pointermid%:=pointer255%;endif; 'can't be larger that pointer255%
	if spikesTlist[pointermid%] <> -1 then
		'Debug
		printlog("%d, %d, %d \n",pointer001%,pointer255%,pointermid%);
		View(vh%); Cursor(0,spikesTlist[pointermid%]);
		if KeepCursorCenter%=1 then
			if (spikesTlist[pointermid%]+(ScreenWidth/2) <= MaxTime()) then
				XRange(spikesTlist[pointermid%]-(ScreenWidth/2),spikesTlist[pointermid%]+(ScreenWidth/2));
			'if XHigh() <= spikesTlist[pointermid%] then
			else
				XRange(MaxTime()-ScreenWidth,MaxTime());
			endif;
		endif;
		View(hWave1%);
		XYGetData(pointermid%-pointer001%+1,tempx[],tempy[]);
		XYDelete(HighlightChanNum%);
		XYAddData(HighlightChanNum%,tempx[],tempy[]);XYColour(HighlightChanNum%,16);
		View(vh%);
		return 1;
	else
		pointermid%:=pointermid%-1;
		return 1;
	endif;
wend;
'View(vh%);
'return 1;
end;

func Wave1Prev%()
if pointermid% <= pointer001% then return 1; endif
var tempx[WaveMarkDataPoint%+10],tempy[WaveMarkDataPoint%+10];
while 1 do
	if (pointermid% >= pointer255%) and (pointermid% <= pointer001%) then return 1; endif
	pointermid%:=pointermid%-1;if pointermid% < pointer001% then pointermid%:=pointer001%;endif; 'can't be smaller that pointer001%
	if spikesTlist[pointermid%] <> -1 then
		'Debug
		printlog("%d, %d, %d \n",pointer001%,pointer255%,pointermid%);
		View(vh%); Cursor(0,spikesTlist[pointermid%]);
		if KeepCursorCenter%=1 then
			if (spikesTlist[pointermid%] <= (XLow()+(ScreenWidth/2))) then
				if (spikesTlist[pointermid%]-(ScreenWidth/2) >= 0) then
					XRange(spikesTlist[pointermid%]-(ScreenWidth/2),spikesTlist[pointermid%]+(ScreenWidth/2));
				'if XLow() >= spikesTlist[pointermid%] then
				else
					XRange(0, ScreenWidth);
				endif;
			endif;
		endif;
		View(hWave1%);
		XYGetData(pointermid%-pointer001%+1,tempx[],tempy[]);
		XYDelete(HighlightChanNum%);
		XYAddData(HighlightChanNum%,tempx[],tempy[]);XYColour(HighlightChanNum%,16);
		View(vh%);
		return 1;
	else
		pointermid%:=pointermid%+1;
		return 1;
	endif;
wend;
'View(vh%);
'return 1;
end;


func OverLapSet%()
Overlapsetting:= 0.001 * Input("Enter length of overlap region for advance and back (ms)",Overlapsetting*1000,0,50);
return 1;
end;

func hcUP%()
TrigLevel := HCursor(1);
TrigLevel := TrigLevel + hcINC;
HCursor(1,TrigLevel);
return 1;
end;

func hcDOWN%()
TrigLevel := HCursor(1);
TrigLevel := TrigLevel - hcINC;
HCursor(1,TrigLevel);
return 1;
end;

func SetInt%()
'for setting minimum time between triggers
MinimumTimeBetweenTriggers:=Input("Enter minimum time between 2 triggers (ms)",MinimumTimeBetweenTriggers,0.1,100);
return 1;
end;


func TakeAll%()
var eT,sT,junk,code%[4],NrEventAdded%,TM%,pp$,data[WaveMarkDataPoint%],WaveData[WaveMarkDataPoint%+10],WaveDataX[WaveMarkDataPoint%+10],TStep,nn%;


ArrConst(wave1sTlist[],-1);
wave1chancounter%:=0;
wave1channr%:=1;displwave1channr%:=1;
wave1n%:=1;
code%[0]:=4;
TStep:=BinSize(chUnit%);

for nn%:=0 to WaveMarkDataPoint%+9 do
	WaveDataX[nn%]:=nn% * TStep;
next;

TrigLevel:=HCursor(1);
if TrigLevel < 0 then
	TM%:=3;
else
	TM%:=2;
endif;

NrEventAdded%:=MemImport(memchForWaveMark%,chUnit%,XLow(),XHigh(),TM%,MinimumTimeBetweenTriggers/1000,TrigLevel);
NumberOfSpike%:=NumberOfSpike% + NrEventAdded%;

if NrEventAdded% > 0 then
	sT:=XLow();
	for nn%:=1 to NrEventAdded% do
	
		sT:=NextTime(memchForWaveMark%,sT);
		eT:=sT + ((WaveMarkDataPoint%-1)*TStep);
		ChanData(chUnit%,data[],sT,eT);
		MemSetItem(memchEvent%,0,sT,code%[],data[]);
		MemSetItem(memchInstantRate%,0,sT);

	Next;
	
	UpdateSpkDisplay%();
	HighLight%(pointermid%);
	HowManySpikesDisplayed%();

	'Debug
	printlog("%d, %d, %d \n",pointer001%,pointer255%,pointermid%);
	'var msgw$;View(hWave1%);msgw$:="ACCEPTED Action Potential = " + Str$(wave1channr%);WindowTitle$(msgw$);View(vh%);
	'displwave1channr%:=wave1channr%;
	'MemImport(memchEvent%,1,XLow(),XHigh(),memchForWaveMark%);
	
	'fix instant rate
	'MemImport(memchInstantRate%,memchForWaveMark%,XLow(),XHigh());
	DrawMode(memchInstantRate%,2,1); DrawMode(memchInstantRate%,7,3);' recompute instant freq
endif;

pp$:=Str$(NrEventAdded%)+" spikes was added.";
ToolbarText(pp$);
ToolbarEnable(16,1);
ToolbarEnable(17,1);
return 1;
end;

'func Trig%()
'Interact("Set a new trigger level, please.",1023,0,"&OK");
'TrigLevel:=HCursor(1);
'if TrigLevel < 0 then
'	TrigMode%:=8;
'else
'	TrigMode%:=7;
'endif;
'return 1;
'end;

func Open%()
var WavemarkNrPoint%, tempChan%, channellist%[64], nnn%, unitsplrate%, splmsg$;
var chan10check%:=0;
var mmm%:=0;

vh% := FileOpen("",0,1);
if vh% < 0 then
	Message("Error opening file, halt...");
	halt;
else
	View(vh%);
	FrontView(vh%);
	WindowVisible(1);Window(0,0,100,72);
	XRange(0,ScreenWidth);
	'CursorNew(1);CursorNew(2);CursorLabelPos(1,100);CursorLabelPos(2,100);
	CursorVisible(-1,0);
	Cursor(0,0.0001);CursorVisible(0,1);CursorLabelPos(0,100);CursorLabel(0,0);
endif;

UnitSamplingInterval := BinSize(chUnit%);

' check whether channel 30 exists 'BOB
ChanList(channellist%[]);
for nnn%:=1 to channellist%[0] do
	if channellist%[nnn%] = 30 then
		chan10check% := 1;
	endif;
next;

if chan10check% = 1 then
	Message("Channel #30 exists");'BOB
	chUnitEvent%:=30; 'BOB
else
	Message("Channel #30 for storing spike wavemark does not exist, you are creating one now"); 'BOB
	unitsplrate% := 1/UnitSamplingInterval;
	splmsg$ := Print$("How many points do you need to capture from the action potential (%d samples/s)?",unitsplrate%);
	WavemarkNrPoint% := Input(splmsg$,10,10,2000);
	tempChan% := MemChan(6,WavemarkNrPoint%,BinSize(chUnit%),10);
	chUnitEvent%:=30; 'BOB
	MemSave(tempChan%,chUnitEvent%,6,1);
	ChanDelete(tempChan%);
endif;

ChanHide(-1);
ChanShow(1,chUnitEvent%);
ChanTitle$(chUnitEvent%,"Saved Events");
WaveMarkDataPoint%:=MarkInfo(chUnitEvent%,WaveMarkPreTrig%);

' create deletable memory channel
memchEvent%:=MemChan(6,WaveMarkDataPoint%,BinSize(chUnitEvent%),WaveMarkPreTrig%);ChanScale(memchEvent%,ChanScale(1));
wave2n% := MemImport(memchEvent%,chUnitEvent%,0,MaxTime(chUnit%)); 'copy spikes to deletable channel
'DrawMode(memchEvent%,1,3);
ChanShow(memchEvent%);
ChanTitle$(memchEvent%,"Deletable");

memchForWaveMark%:=MemChan(3);ChanHide(memchForWaveMark%);

' Create instant frequency channel
memchInstantRate% := MemChan(3,0,BinSize(1)); ' 103
MemImport(memchInstantRate%,chUnitEvent%,0,MaxTime(chUnit%));
DrawMode(memchInstantRate%,7,3); ' Dot size 3
ChanTitle$(memchInstantRate%,"Instant Freq"); ChanUnits$(memchInstantRate%,"Hz");
'ChanShow(memchInstantRate%); 
YRange(memchInstantRate%,0,1800);

HCursorDelete(-1);
HCursorNew(1,TrigLevel);
HCursorLabel(0,1); ' no label

CursorActive(0,14,memchEvent%,0,"","",0,0,0);
ToolbarEnable(2,0);

hWave1%:=FileNew(12,1);View(hWave1%);FrontView(hWave1%);Window(0,72,50,100);
WindowTitle$("ACCEPTED Action Potential, 255 spike max");
'prepare all 256 channels
for nnn%:=1 to 256 do
	XYSetChan(0,0,0,1);
Next;
'last channel for highlight is 256
XYDrawMode(HighlightChanNum%,2,0);XYDrawMode(HighlightChanNum%,3,0);XYDrawMode(HighlightChanNum%,4,2);XYJoin(HighlightChanNum%,1);
XYDelete(HighlightChanNum%);
XRange(0,UnitSamplingInterval*(WaveMarkDataPoint%+10));

hWave2%:=FileNew(12,1);View(hWave2%);FrontView(hWave2%);Window(50,72,100,100);
WindowTitle$("SAVED Action Potential");
XRange(0,UnitSamplingInterval*(WaveMarkDataPoint%+10));

View(vh%);FrontView(vh%);

if wave2n% > 0 then
	var WaveX[WaveMarkDataPoint%+10],sT,eT,msgw$,lastloc;
	var kk%:=0;
	sT:=0;
	for nnn%:= 0 to WaveMarkDataPoint%+9 do
		WaveX[nnn%]:=nnn% * UnitSamplingInterval;
	next;
	while sT >= 0 do
		sT:=NextTime(chUnitEvent%,sT);
		eT:=sT + ((WaveMarkDataPoint%-1)*UnitSamplingInterval);
		if sT > 0 then
			ChanData(chUnit%,Wave2Y[kk% * (WaveMarkDataPoint%+10):(WaveMarkDataPoint%+10)],sT-10*UnitSamplingInterval,eT);
			ArrConst(Wave2X[kk% * (WaveMarkDataPoint%+10):(WaveMarkDataPoint%+10)],WaveX[]);
			kk%:=kk%+1;
			lastloc:=sT;
		endif;
	wend;

	View(hWave2%);
		XYSetChan(1,0,0,0); XYDrawMode(1,2,1);
		XYAddData(1,Wave2X[:(kk%*(WaveMarkDataPoint%+10))-1],Wave2Y[:(kk%*(WaveMarkDataPoint%+10))-1]);
		Optimise(-1);
		msgw$:="SAVED Action Potential, n = " + Str$(kk%);
		WindowTitle$(msgw$);
	View(vh%);
	' bring to last accepted spike
	XRange(lastloc-0.5*ScreenWidth,lastloc+0.5*ScreenWidth); 
	Cursor(0,(XLow()+XHigh())/2); ' put cursor 0 at the center
endif;
NumberOfSpike%:=wave2n%;

UpdateSpkDisplay%();
HighLight%(pointermid%);
HowManySpikesDisplayed%();

'ToolbarEnable(16,0);
'ToolbarEnable(17,0);
return 1;
end;

func Delete%()
var Cursor0Time,NewCursor0Time,NrDeletedItem%,pointerlocal%,whereinXY%;
var StringCursor0Time$, StringNrDeletedItem$, StringToolbar$;
Cursor0Time:=Cursor(0);
NrDeletedItem%:=MemDeleteTime(memchEvent%,0,Cursor0Time,0.001);
if NrDeletedItem%<=0 then
	Message("Nothing deleted??");
	return 1;
endif;

MemDeleteTime(memchInstantRate%,0,Cursor0Time,0.001);DrawMode(memchInstantRate%,2,1);DrawMode(memchInstantRate%,7,3); 'recompute instant freq
StringCursor0Time$:=Str$(Cursor0Time,12,6);
StringNrDeletedItem$:=Str$(NrDeletedItem%);
StringToolbar$:=StringNrDeletedItem$+" spike was deleted at time: "+StringCursor0Time$;
ToolbarText(StringToolbar$);

pointerlocal%:=FindItem%(SpikesTlist[],Cursor0Time,0.00001); ' is it displayed in wave 1, no = -1

if pointerlocal% <> -1 then
	' yes
	NumberofSpike%:=NumberOfSpike%-1;
	if pointerlocal% > 1 then NewCursor0Time:=SpikesTlist[pointerlocal%-1];
	else if SpikesTlist[2] <> -1 then  NewCursor0Time:=SpikesTlist[2]; else NewCursor0Time:=0; endif;endif;
	
	UpdateSpkDisplay%();
	if NewCursor0Time <> 0 then
		pointermid%:=FindItem%(SpikesTlist[],NewCursor0Time,0.00001);
	endif;
		'debug
		printlog("%d, %d, %d \n",pointer001%,pointer255%,pointermid%);
	HighLight%(pointermid%);
	HowManySpikesDisplayed%();
	Cursor(0,NewCursor0Time);
else
	' the deleted spike is not in the wave 1 display
	NumberofSpike%:=NumberOfSpike%-1;
endif;

return 1
end;

func Add%()
var nn%, bt%, cur1t,pp$,data[WaveMarkDataPoint%],TStep,eT,code%[4], TrigMode% ,WaveData[WaveMarkDataPoint%+10],WaveDataX[WaveMarkDataPoint%+10];
var idxaddedspk%;
'code%[0]:=2; ' 4:red 2:green 1:blue
TStep:=BinSize(chUnit%);

TrigLevel:=HCursor(1);
if TrigLevel < 0 then
	TrigMode%:=8;
else
	TrigMode%:=7;
endif;
FrontView(vh%);
'Cursor(1,XLow()+0.01); CursorVisible(1,1);CursorVisible(0,0);
CursorActive(0,TrigMode%,1,0,"","",TrigLevel,0,0);
Cursor(0,(XLow()+XHigh())/2.0);
bt%:=Interact("Place Cursor 0 at where you want a spike added.",1023,0,"&Add(RED)","Add&1(BLUE)","Add&2(GREEN)","&Cancel");

if bt%=1 then
	code%[0]:=4;
	cur1t:=Cursor(0);
	
	eT:=cur1t + ((WaveMarkDataPoint%-1)*TStep);
	ChanData(1,data[],cur1t,eT);
	MemSetItem(memchEvent%,0,cur1t,code%[],data[]);
	'fix instant rate
	MemSetItem(memchInstantRate%,0,cur1t);
	DrawMode(memchInstantRate%,2,1); DrawMode(memchInstantRate%,7,3);' recompute instant freq
	pp$:="One spike was placed at time: " + Str$(cur1t,12,6);
	ToolbarText(pp$);
endif;

if bt%=2 then
	code%[0]:=1;
	cur1t:=Cursor(0);
	
	eT:=cur1t + ((WaveMarkDataPoint%-1)*TStep);
	ChanData(1,data[],cur1t,eT);
	MemSetItem(memchEvent%,0,cur1t,code%[],data[]);
	'fix instant rate
	MemSetItem(memchInstantRate%,0,cur1t);
	DrawMode(memchInstantRate%,2,1); DrawMode(memchInstantRate%,7,3);' recompute instant freq
	pp$:="One spike was placed at time: " + Str$(cur1t,12,6);
	ToolbarText(pp$);
endif;

if bt%=3 then
	code%[0]:=2;
	cur1t:=Cursor(0);
	
	eT:=cur1t + ((WaveMarkDataPoint%-1)*TStep);
	ChanData(1,data[],cur1t,eT);
	MemSetItem(memchEvent%,0,cur1t,code%[],data[]);
	'fix instant rate
	MemSetItem(memchInstantRate%,0,cur1t);
	DrawMode(memchInstantRate%,2,1); DrawMode(memchInstantRate%,7,3);' recompute instant freq
	pp$:="One spike was placed at time: " + Str$(cur1t,12,6);
	ToolbarText(pp$);
endif;

if bt% < 4 then
	'return cursor 0 mode to before function call
	CursorActive(0,14,memchEvent%,0,"","",0,0,0);
	
	NumberOfSpike%:=NumberOfSpike%+1;
	UpdateSpkDisplay%();
	HighLight%(pointermid%);
	HowManySpikesDisplayed%();
	
	'debug
	printlog("%d, %d, %d \n",pointer001%,pointer255%,pointermid%);

	return 1;
endif;

'CursorVisible(0,1);
'CursorVisible(1,0);

'return cursor 0 mode to before function call
CursorActive(0,14,memchEvent%,0,"","",0,0,0);

return 1;
end;

func Save%()
ChanDelete(chUnitEvent%);
MemSave(memchEvent%,chUnitEvent%,0);
ChanShow(chUnitEvent%);
ChanTitle$(chUnitEvent%,"Saved Events");

' Plot saved wavemarks
	var WaveX[WaveMarkDataPoint%+10],sT,eT,nnn%,msgw$;
	var kk%:=0;
	sT:=0;
	for nnn%:= 0 to WaveMarkDataPoint%+9 do
		WaveX[nnn%]:=nnn% * UnitSamplingInterval;
	next;
	while sT >= 0 do
		sT:=NextTime(chUnitEvent%,sT);
		eT:=sT + ((WaveMarkDataPoint%-1)*UnitSamplingInterval);
		if sT > 0 then
			ChanData(chUnit%,Wave2Y[kk% * (WaveMarkDataPoint%+10):(WaveMarkDataPoint%+10)],sT-10*UnitSamplingInterval,eT);
			ArrConst(Wave2X[kk% * (WaveMarkDataPoint%+10):(WaveMarkDataPoint%+10)],WaveX[]);
			kk%:=kk%+1;
		endif;
	wend;

	View(hWave2%);
		XYDelete(1);
		XYSetChan(1,0,0,0); XYDrawMode(1,2,1);
		XYAddData(1,Wave2X[:(kk%*(WaveMarkDataPoint%+10))-1],Wave2Y[:(kk%*(WaveMarkDataPoint%+10))-1]);
		Optimise(-1);
		msgw$:="SAVED Action Potential, n = " + Str$(kk%);
		WindowTitle$(msgw$);
	View(vh%);
'=======================

return 1;
end;

func Quit%()
FileClose(-1,-1);
halt;
end;

func Fetch%()
Cursor(0,(XLow()+XHigh())/2); ' put cursor 0 at the center
CursorVisible(0,1);
return 1;
end;

func ScreenRes%()
ScreenWidth:=Input("Enter new screen width in second",ScreenWidth,0.001,1000);
XRange(XLow(),XLow()+ScreenWidth);
return 1;
end;

func Advance%()
XRange(XHigh()-Overlapsetting,XHigh()+ScreenWidth-Overlapsetting); '20 ms hysterisis
Cursor(0,(XLow()+XHigh())/2); ' put cursor 0 at the center
return 1;
end;

func Back%()
XRange(XLow()-ScreenWidth+Overlapsetting,XLow()+Overlapsetting); '20 ms hysterisis
Cursor(0,(XLow()+XHigh())/2); ' put cursor 0 at the center
return 1;
end;

func InsFreq%()
if kIF%=0 then
	ChanShow(memchInstantRate%); 
	kIF%:=1;
	ToolbarSet(11,"Hide IF",InsFreq%);
else
	ChanHide(memchInstantRate%); 
	kIF%:=0;
	ToolbarSet(11,"Show IF",InsFreq%);
endif;
return 1;
end;

func FindSamplingRate%(St,chn%)
var t1,t2;
t1:=NextTime(chn%,St);
t2:=NextTime(chn%,t1);
return round(1/(t2-t1));
end;


func FindSamplingInterval(St,chn%)
var t1,t2;
t1:=NextTime(chn%,St);
t2:=NextTime(chn%,t1);
return t2-t1;
end;