#include "sierrachart.h"
#include "scstudyfunctions.h"

/*==========================================================================*/
SCSFExport scsf_DoubleStochastic(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_Bressert   = sc.Subgraph[0];
	SCSubgraphRef Subgraph_UpperLine  = sc.Subgraph[1];
	SCSubgraphRef Subgraph_LowerLine  = sc.Subgraph[2];
	SCSubgraphRef Subgraph_DSTrigger = sc.Subgraph[3];

	SCInputRef Input_HighLowPeriodLength = sc.Input[0];
	SCInputRef Input_EmaLength           = sc.Input[1];
	SCInputRef Input_UpperLineValue      = sc.Input[2];
	SCInputRef Input_LowerLineValue      = sc.Input[3];
	SCInputRef Input_Version             = sc.Input[4];
	SCInputRef Input_SmoothingLength     = sc.Input[5];

	if (sc.SetDefaults)
	{
		// Set the configuration and defaults

		sc.GraphName = "Double Stochastic - Bressert";
		sc.StudyDescription = "";

		sc.GraphRegion = 2;
		sc.AutoLoop = 1;

		Subgraph_Bressert.Name = "DS";
		Subgraph_Bressert.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_Bressert.PrimaryColor = RGB(0,255,0);
		Subgraph_Bressert.DrawZeros = false;

		Subgraph_DSTrigger.Name = "DS Trigger";
		Subgraph_DSTrigger.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_DSTrigger.PrimaryColor = RGB(255,0,255);
		Subgraph_DSTrigger.DrawZeros = false;

		Subgraph_UpperLine.Name = "Upper Line";
		Subgraph_UpperLine.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_UpperLine.PrimaryColor = RGB(255,255,0);
		Subgraph_UpperLine.DrawZeros = false;
		
		Subgraph_LowerLine.Name = "Lower Line";
		Subgraph_LowerLine.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_LowerLine.PrimaryColor = RGB(255,127,0);
		Subgraph_LowerLine.DrawZeros = false;


		Input_HighLowPeriodLength.Name = "High & Low Period Length";
		Input_HighLowPeriodLength.SetInt(15);
		Input_HighLowPeriodLength.SetIntLimits(1, MAX_STUDY_LENGTH);
		Input_HighLowPeriodLength.DisplayOrder = 1;

		Input_EmaLength.Name = "Stochastic Exponential Mov Avg Length";
		Input_EmaLength.SetInt(18);
		Input_EmaLength.SetIntLimits(1, MAX_STUDY_LENGTH);
		Input_EmaLength.DisplayOrder = 2;

		Input_SmoothingLength.Name = "Smoothing Length";
		Input_SmoothingLength.SetInt(3);
		Input_SmoothingLength.SetIntLimits(1, MAX_STUDY_LENGTH);
		Input_SmoothingLength.DisplayOrder = 3;

		Input_UpperLineValue.Name = "Upper Line Value";
		Input_UpperLineValue.SetFloat(80.0f);
		Input_UpperLineValue.DisplayOrder = 4;

		Input_LowerLineValue.Name = "Lower Line Value";
		Input_LowerLineValue.SetFloat(20.0f);
		Input_LowerLineValue.DisplayOrder = 5;

		Input_Version.SetInt(1);

		return;
	}

	if (Input_Version.GetInt() < 1)
	{
		Input_Version.SetInt(1);
		Input_SmoothingLength.SetInt(3);
	}

	// Do data processing

	int Index = sc.Index;
	Subgraph_UpperLine[Index] = Input_UpperLineValue.GetFloat();
	Subgraph_LowerLine[Index] = Input_LowerLineValue.GetFloat();


	int HighLowPeriod =  Input_HighLowPeriodLength.GetInt();

	float High = sc.GetHighest(sc.High, HighLowPeriod);
	float Low = sc.GetLowest(sc.Low, HighLowPeriod);
	if (High - Low != 0.0f)
		Subgraph_Bressert.Arrays[0][Index] = ((sc.Close[Index] - Low) / (High - Low)) * 100.0f;
	else
		Subgraph_Bressert.Arrays[0][Index] = 0.0f;

	sc.ExponentialMovAvg(Subgraph_Bressert.Arrays[0], Subgraph_DSTrigger, Input_EmaLength.GetInt());

	float TriggerHigh = sc.GetHighest(Subgraph_DSTrigger, HighLowPeriod);
	float TriggerLow = sc.GetLowest(Subgraph_DSTrigger, HighLowPeriod);
	if (TriggerHigh - TriggerLow != 0.0f)
		Subgraph_Bressert.Arrays[1][Index] = ((Subgraph_DSTrigger[Index] - TriggerLow) / (TriggerHigh - TriggerLow)) * 100.0f;
	else
		Subgraph_Bressert.Arrays[1][Index] = 0.0f;

	sc.ExponentialMovAvg(Subgraph_Bressert.Arrays[1], Subgraph_Bressert.Arrays[2], Input_EmaLength.GetInt());
	sc.ExponentialMovAvg(Subgraph_Bressert.Arrays[2], Subgraph_Bressert, Input_SmoothingLength.GetInt());
}

/*==========================================================================*/
SCSFExport scsf_PreviousBarClose(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_PrevClose = sc.Subgraph[0];

	SCInputRef Input_InputData= sc.Input[0];
	SCInputRef Input_Version = sc.Input[1];

	if (sc.SetDefaults)
	{
		// Set the configuration and defaults

		sc.GraphName = "Previous Bar Close";
		sc.AutoLoop = 1;

		Subgraph_PrevClose.DrawStyle = DRAWSTYLE_STAIR_STEP;
		Subgraph_PrevClose.Name = "PB Close";
		Subgraph_PrevClose.LineLabel  |= (LL_DISPLAY_VALUE | LL_VALUE_ALIGN_VALUES_SCALE);
		Subgraph_PrevClose.PrimaryColor = RGB(0,255,0);

		sc.GraphRegion = 0;
		
		Input_InputData.Name = "Input Data";
		Input_InputData.SetInputDataIndex(SC_LAST);
		
		Input_Version.SetInt(1);
		
		return;
	}

	if (Input_Version.GetInt() < 1)
	{
		Input_InputData.SetInputDataIndex(SC_LAST);
		Input_Version.SetInt(1);
	}
	
	uint32_t InputDataIndex = Input_InputData.GetInputDataIndex();
	
	// Do data processing
	Subgraph_PrevClose[sc.Index] = sc.BaseData[InputDataIndex][sc.Index - 1];
}

/*==========================================================================*/
SCSFExport scsf_ChangeForDay(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_Change = sc.Subgraph[0];
	SCInputRef Input_TickSize = sc.Input[0];

	if (sc.SetDefaults)
	{
		// Set the configuration and defaults

		sc.GraphName = "Change For Day";

		sc.GraphRegion = 1;	

		Subgraph_Change.Name = "Change";
		Subgraph_Change.DrawStyle = DRAWSTYLE_DASH;
		Subgraph_Change.SecondaryColorUsed = 1;
		Subgraph_Change.SecondaryColor = RGB(255,0,0);

		Input_TickSize.Name = "Tick Size";
		Input_TickSize.SetFloat(0.25f);

		return;
	}

	// Do data processing
	Subgraph_Change[sc.Index] = sc.Close[sc.ArraySize - 1];

	int OpeningIndex = sc.GetNearestMatchForSCDateTime(sc.ChartNumber, sc.BaseDateTimeIn.DateAt(sc.ArraySize-1));

	if (sc.BaseDateTimeIn.DateAt(OpeningIndex) != sc.BaseDateTimeIn.DateAt(sc.ArraySize-1))
		OpeningIndex++;

	float ChangeForDay = sc.Close[sc.ArraySize-1] - sc.Open[OpeningIndex];

	for (int i = OpeningIndex; i < sc.ArraySize; i++)
	{
		Subgraph_Change[i] = ChangeForDay/Input_TickSize.GetFloat();
		if (Subgraph_Change[i] >= 0)
			Subgraph_Change.DataColor[i] = Subgraph_Change.PrimaryColor;
		else
			Subgraph_Change.DataColor[i] = Subgraph_Change.SecondaryColor ;

	}
}

/*==========================================================================*/
SCSFExport scsf_JimBergsVolatilitySystem(SCStudyInterfaceRef sc) // scsf_Name
{   
	SCSubgraphRef Subgraph_StopL = sc.Subgraph[0];
	SCSubgraphRef Subgraph_StopS = sc.Subgraph[1];

	SCSubgraphRef Subgraph_LLV = sc.Subgraph[6];
	SCSubgraphRef Subgraph_HHV = sc.Subgraph[7];
	SCSubgraphRef Subgraph_LongTrigger = sc.Subgraph[8];
	SCSubgraphRef Subgraph_ShortTrigger = sc.Subgraph[9];
	SCSubgraphRef Subgraph_ATR = sc.Subgraph[11];
	SCSubgraphRef Subgraph_Temp12 = sc.Subgraph[12];
	SCSubgraphRef Subgraph_Temp13 = sc.Subgraph[13];
	SCSubgraphRef Subgraph_LongStopValue = sc.Subgraph[14];
	SCSubgraphRef Subgraph_ShortStopValue = sc.Subgraph[15];

	// Configuration
	if (sc.SetDefaults)
	{   
		sc.GraphName = "Jim Berg's Volatility System"; // study name shown in F6 menu and on the chart
		sc.GraphRegion = 0;    // zero based region number
		
		Subgraph_StopL.Name = "Stop L";
		Subgraph_StopL.DrawStyle = DRAWSTYLE_STAIR_STEP;
		Subgraph_StopL.PrimaryColor = RGB(0,185,47); // green
		
		
		Subgraph_StopS.Name = "Stop S";
		Subgraph_StopS.DrawStyle = DRAWSTYLE_STAIR_STEP;
		Subgraph_StopS.PrimaryColor = RGB(255,0,128); // red
		

		sc.AutoLoop = 1;
		
		return;
	}   
	
	// Data processing

	// LongSignal  = C > ( LLV( L, 20 ) + 2 * ATR( 10 ) ); // ATR with Wilder's MA
	// ShortSignal = C < ( HHV( H, 20 ) - 2 * ATR( 10 ) );

	// LongStopValue    = HHV( C - 2 * ATR(10), 15 );
	// ShortStopValue   = LLV( C + 2 * ATR(10), 15 );

	sc.DataStartIndex = 21; // start drawing subgraph at bar #21 (zero based)
	
	// LLV(L,20): subgraph #6
	sc.Lowest(sc.Low, Subgraph_LLV, sc.Index, 20);
	
	// HHV(H,20): subgraph#7
	sc.Highest(sc.High, Subgraph_HHV, sc.Index, 20);
	
	// ATR(10, Wilder's MA): subgraph #11. Intermediate TR: subgraph #10 (not plotted)
	sc.ATR(sc.BaseDataIn, Subgraph_ATR, sc.Index, 10, MOVAVGTYPE_WILDERS);
		
	Subgraph_LongTrigger[sc.Index] = Subgraph_LLV[sc.Index] + 2 * Subgraph_ATR[sc.Index]; // Long  Signal trigger
	Subgraph_ShortTrigger[sc.Index] = Subgraph_HHV[sc.Index] - 2 * Subgraph_ATR[sc.Index]; // Short Signal trigger
	Subgraph_Temp12[sc.Index] = sc.Close[sc.Index] - 2 * Subgraph_ATR[sc.Index];
	Subgraph_Temp13[sc.Index] = sc.Close[sc.Index] + 2 * Subgraph_ATR[sc.Index];
	
	// LongStopValue: subgraph #14
	sc.Highest(Subgraph_Temp12, Subgraph_LongStopValue, 15);
	
	// ShortStopValue: subgraph #15
	sc.Lowest(Subgraph_Temp13, Subgraph_ShortStopValue, 15);
	
	// If LongSignal=true, plot LongStopValue in Subgraph #0, otherwise plot zero
	if (sc.Close[sc.Index] > Subgraph_LongTrigger[sc.Index])
		Subgraph_StopL[sc.Index] = Subgraph_LongStopValue[sc.Index];
	else
		Subgraph_StopL[sc.Index] = 0;
		
	// If ShortSignal=true, plot ShortStopValue in Subgraph #1, otherwise plot zero
	if (sc.Close[sc.Index] < Subgraph_ShortTrigger[sc.Index])
		Subgraph_StopS[sc.Index] = Subgraph_ShortStopValue[sc.Index];
	else
		Subgraph_StopS[sc.Index] = 0;
}  


/*==========================================================================*/
SCSFExport scsf_VolumeWeightedMovingAverage(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_VWMA = sc.Subgraph[0];

	SCInputRef Input_InputData = sc.Input[0];
	SCInputRef Input_Length = sc.Input[1];

	// Configuration
	if (sc.SetDefaults)
	{
		sc.GraphName = "Moving Average - Volume Weighted"; 
		sc.StudyDescription = "Volume Weighted Moving Average"; 
		sc.GraphRegion = 0;    // zero based region number

		Subgraph_VWMA.Name = "VWMA";
		Subgraph_VWMA.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_VWMA.PrimaryColor = RGB(0,185,47); // green

		Input_InputData.Name = "Input Data";
		Input_InputData.SetInputDataIndex(SC_LAST); 

		Input_Length.Name = "Length";
		Input_Length.SetInt(5);     
		Input_Length.SetIntLimits(1,MAX_STUDY_LENGTH); 

		sc.ValueFormat = 3;

		sc.AutoLoop = 1;

		return;
	}

	// Data processing

	sc.DataStartIndex = Input_Length.GetInt();    
	sc.VolumeWeightedMovingAverage(sc.BaseData[Input_InputData.GetInputDataIndex()], sc.Volume, Subgraph_VWMA, Input_Length.GetInt());
}


/*==========================================================================*/
SCSFExport scsf_InsideOrEqualsBar(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_IB = sc.Subgraph[0];

	// Set configuration variables

	if (sc.SetDefaults)
	{
		// Set the configuration and defaults

		sc.GraphName = "Inside Or Equals Bar";

		sc.StudyDescription = "";

		sc.GraphRegion = 0;

		Subgraph_IB.Name = "IB";
		Subgraph_IB.DrawStyle = DRAWSTYLE_COLOR_BAR;
		Subgraph_IB.PrimaryColor = RGB(0, 0, 255);
		Subgraph_IB.DrawZeros = false;

		sc.AutoLoop = 1;

		return;
	}


	// Do data processing

	if (sc.Index < 1)
		return;

	// Array references
	SCFloatArrayRef High = sc.High;
	SCFloatArrayRef Low = sc.Low;

	if (High[sc.Index] <= High[sc.Index - 1] && Low[sc.Index] >= Low[sc.Index - 1])
		Subgraph_IB[sc.Index] = High[sc.Index];
	else
		Subgraph_IB[sc.Index] = 0;
}

/*==========================================================================*/
SCSFExport scsf_AroonOscillator(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_AroonOscillator = sc.Subgraph[0];
	SCSubgraphRef Subgraph_AroonCalculations = sc.Subgraph[1];

	SCInputRef Input_InputDataHigh = sc.Input[0];
	SCInputRef Input_Length = sc.Input[1];
	SCInputRef Input_InputDataLow = sc.Input[2];

	if (sc.SetDefaults)
	{
		// Set the configuration and defaults

		sc.GraphName = "Aroon Oscillator";
		sc.AutoLoop = 1;
		sc.GraphRegion = 1;

		Subgraph_AroonOscillator.Name = "Aroon Oscillator";
		Subgraph_AroonOscillator.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_AroonOscillator.PrimaryColor = RGB(0,255,0);
		Subgraph_AroonOscillator.DrawZeros = true;

		Input_InputDataHigh.Name = "Input Data High";
		Input_InputDataHigh.SetInputDataIndex(SC_HIGH);

		Input_Length.Name = "Length";
		Input_Length.SetInt(5);           
		Input_Length.SetIntLimits(1,MAX_STUDY_LENGTH);

		Input_InputDataLow.Name = "Input Data Low";
		Input_InputDataLow.SetInputDataIndex(SC_LOW); 

		return;
	}


	// Do data processing


	sc.AroonIndicator(sc.BaseDataIn[Input_InputDataHigh.GetInputDataIndex()], sc.BaseDataIn[Input_InputDataLow.GetInputDataIndex()], Subgraph_AroonCalculations, Input_Length.GetInt());

	Subgraph_AroonOscillator[sc.Index] = Subgraph_AroonCalculations.Arrays[1][sc.Index];
}

/*==========================================================================*/
SCSFExport scsf_AroonIndicator(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_AroonUp = sc.Subgraph[0];
	SCSubgraphRef Subgraph_AroonDown = sc.Subgraph[1];


	SCInputRef Input_InputDataHigh = sc.Input[0];
	SCInputRef Input_Length = sc.Input[1];
	SCInputRef Input_InputDataLow = sc.Input[2];


	if (sc.SetDefaults)
	{
		// Set the configuration and defaults

		sc.GraphName = "Aroon Indicator";
		sc.AutoLoop = 1;
		sc.GraphRegion = 1;	

		Subgraph_AroonUp.Name = "Aroon Up";
		Subgraph_AroonUp.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_AroonUp.PrimaryColor = RGB(0,255,0);
		Subgraph_AroonUp.DrawZeros = true;

		Subgraph_AroonDown.Name = "Aroon Down";
		Subgraph_AroonDown.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_AroonDown.PrimaryColor = RGB(255,0,255);
		Subgraph_AroonDown.DrawZeros = true;

		Input_InputDataHigh.Name = "Input Data High";
		Input_InputDataHigh.SetInputDataIndex(SC_HIGH); // default data field

		Input_Length.Name = "Length";
		Input_Length.SetInt(5);            // default integer value
		Input_Length.SetIntLimits(1,MAX_STUDY_LENGTH); // min-max value

		Input_InputDataLow.Name = "Input Data Low";
		Input_InputDataLow.SetInputDataIndex(SC_LOW); // default data field 

		return;
	}




	sc.AroonIndicator(sc.BaseDataIn[Input_InputDataHigh.GetInputDataIndex()], sc.BaseDataIn[Input_InputDataLow.GetInputDataIndex()], Subgraph_AroonUp, Input_Length.GetInt());

	Subgraph_AroonDown[sc.Index] = Subgraph_AroonUp.Arrays[0][sc.Index];
}

/*============================================================================
Study function for Welles Wilder's Plus and Minus Directional Indicators
+DI and -DI.
----------------------------------------------------------------------------*/
SCSFExport scsf_DMI(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_DIPlus = sc.Subgraph[0];
	SCSubgraphRef Subgraph_DIMinus = sc.Subgraph[1];

	SCInputRef Input_Length = sc.Input[3];

	if (sc.SetDefaults)
	{
		// Set the configuration and defaults

		sc.GraphName = "Directional Movement Index";

		sc.StudyDescription = "Welles Wilder's Plus and Minus Directional Indicators +DI and -DI.";

		sc.AutoLoop = 1;  // true

		Subgraph_DIPlus.Name = "DI+";
		Subgraph_DIPlus.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_DIPlus.PrimaryColor = RGB(0,255,0);
		Subgraph_DIPlus.DrawZeros = true;

		Subgraph_DIMinus.Name = "DI-";
		Subgraph_DIMinus.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_DIMinus.PrimaryColor = RGB(255,0,255);
		Subgraph_DIMinus.DrawZeros = true;

		Input_Length.Name = "Length";
		Input_Length.SetInt(14);
		Input_Length.SetIntLimits(1, INT_MAX);

		return;
	}


	// Do data processing

	sc.DataStartIndex = Input_Length.GetInt();
	
	sc.DMI(
		sc.BaseData,
		Subgraph_DIPlus,  // DMI+
		Subgraph_DIMinus,  // DMI-
		Input_Length.GetInt());

	//sc.CrossOver(DIPlus.Data, DIMinus.Data);
}

/*============================================================================
----------------------------------------------------------------------------*/
SCSFExport scsf_DMIOscillator(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_DMIDiff = sc.Subgraph[0];
	SCSubgraphRef Subgraph_Line = sc.Subgraph[1];

	SCInputRef Input_Length = sc.Input[3];
	SCInputRef Input_ShowAbsValues = sc.Input[4];

	if (sc.SetDefaults)
	{
		// Set the configuration and defaults

		sc.GraphName = "Directional Movement Oscillator";

		sc.StudyDescription = "Calculates the difference between the Directional Indicators -DI and the +DI.";

		sc.AutoLoop = 1;  // true

		Subgraph_DMIDiff.Name = "DMI Diff";
		Subgraph_DMIDiff.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_DMIDiff.PrimaryColor = RGB(0,255,0);
		Subgraph_DMIDiff.DrawZeros = true;

		Subgraph_Line.Name = "Line";
		Subgraph_Line.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_Line.PrimaryColor = RGB(255,0,255);
		Subgraph_Line.DrawZeros = true;

		Input_Length.Name = "Length";
		Input_Length.SetInt(14);
		Input_Length.SetIntLimits(1, INT_MAX);

		Input_ShowAbsValues.Name = "Show Absolute Values";
		Input_ShowAbsValues.SetYesNo(0);

		return;
	}

	// Do data processing

	sc.DataStartIndex = Input_Length.GetInt() - 1;

	sc.DMIDiff(sc.BaseData, Subgraph_DMIDiff, sc.Index, Input_Length.GetInt());  // DMI Diff

	if(Input_ShowAbsValues.GetYesNo())
		Subgraph_DMIDiff[sc.Index] = fabs(Subgraph_DMIDiff[sc.Index]);
}

/*============================================================================
Average Directional Movement Index study.  This is calculated according
to the Welles Wilder formulas.
----------------------------------------------------------------------------*/
SCSFExport scsf_ADX(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_ADX = sc.Subgraph[0];

	SCInputRef Input_DXLength = sc.Input[3];
	SCInputRef Input_DXMALength = sc.Input[4];

	if (sc.SetDefaults)
	{
		// Set the configuration and defaults

		sc.GraphName = "ADX";

		sc.StudyDescription = "Average Directional Movement Index.  This is calculated according to the Welles Wilder formulas.";

		sc.AutoLoop = 1;  // true
		sc.GraphRegion = 1;

		Subgraph_ADX.Name = "ADX";
		Subgraph_ADX.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_ADX.PrimaryColor = RGB(0,255,0);
		Subgraph_ADX.DrawZeros = true;

		Input_DXLength.Name = "DX Length";
		Input_DXLength.SetInt(14);
		Input_DXLength.SetIntLimits(1, INT_MAX);

		Input_DXMALength.Name = "DX Mov Avg Length";
		Input_DXMALength.SetInt(14);
		Input_DXMALength.SetIntLimits(1, INT_MAX);

		return;
	}


	// Do data processing

	sc.DataStartIndex = Input_DXLength.GetInt() + Input_DXMALength.GetInt() - 1;

	sc.ADX(
		sc.BaseData,
		Subgraph_ADX,
		Input_DXLength.GetInt(),
		Input_DXMALength.GetInt());
}

/*============================================================================
Average Directional Movement Index Rating study.  This is calculated
according to the Welles Wilder formulas.
----------------------------------------------------------------------------*/
SCSFExport scsf_ADXR(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_ADXR = sc.Subgraph[0];

	SCInputRef Input_DXLength = sc.Input[3];
	SCInputRef Input_DXMALength = sc.Input[4];
	SCInputRef Input_ADXRInterval = sc.Input[5];

	if (sc.SetDefaults)
	{
		// Set the configuration and defaults

		sc.GraphName = "ADXR";

		sc.StudyDescription = "Average Directional Movement Index Rating.  This is calculated according to the Welles Wilder formulas.";

		sc.AutoLoop = 1;  // true
		sc.GraphRegion = 1;

		Subgraph_ADXR.Name = "ADXR";
		Subgraph_ADXR.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_ADXR.PrimaryColor = RGB(0,255,0);
		Subgraph_ADXR.DrawZeros = true;

		Input_DXLength.Name = "DX Length";
		Input_DXLength.SetInt(14);
		Input_DXLength.SetIntLimits(1, INT_MAX);

		Input_DXMALength.Name = "DX Mov Avg Length";
		Input_DXMALength.SetInt(14);
		Input_DXMALength.SetIntLimits(1, INT_MAX);

		Input_ADXRInterval.Name = "ADXR Interval";
		Input_ADXRInterval.SetInt(14);
		Input_ADXRInterval.SetIntLimits(1, INT_MAX);

		return;
	}


	// Do data processing

	sc.DataStartIndex = Input_DXLength.GetInt() + Input_DXMALength.GetInt() + Input_ADXRInterval.GetInt() - 2;

	sc.ADXR(
		sc.BaseData,
		Subgraph_ADXR,
		Input_DXLength.GetInt(),
		Input_DXMALength.GetInt(),
		Input_ADXRInterval.GetInt());
}


/*============================================================================
This example code calculates a smoothed moving average (5 period by
default).
----------------------------------------------------------------------------*/
SCSFExport scsf_SmoothedMovingAverage(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_SMMA = sc.Subgraph[0];
	SCInputRef Input_InputData = sc.Input[0];
	SCInputRef Input_Length = sc.Input[1];

	// Set configuration variables	
	if (sc.SetDefaults)
	{
		// Set the configuration and defaults

		sc.GraphName = "Moving Average - Smoothed";

		sc.StudyDescription = "Function for calculating a Wilders Smooth Moving Average (SMMA).";

		// Set the region to draw the graph in.  Region zero is the main
		// price graph region.
		sc.GraphRegion = 0;


		// Set the name of the first subgraph
		Subgraph_SMMA.Name = "SMMA";
		// Set the color and style of the graph line.  If these are not set the default will be used.
		Subgraph_SMMA.PrimaryColor = RGB(255, 0, 0);  // Red
		Subgraph_SMMA.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_SMMA.DrawZeros = false;

		Input_InputData.Name = "Input Data";
		Input_InputData.SetInputDataIndex(SC_LAST); // default data field		

		// Make the Length input and default it to 5
		Input_Length.Name = "Length";
		Input_Length.SetInt(5);
		Input_Length.SetIntLimits(2, MAX_STUDY_LENGTH);

		sc.AutoLoop = 1;

		// Must return before doing any data processing if sc.SetDefaults is set
		return;
	}

	// Do data processing		

	sc.DataStartIndex = Input_Length.GetInt() - 1;

	sc.SmoothedMovingAverage(sc.BaseDataIn[Input_InputData.GetInputDataIndex()], Subgraph_SMMA, sc.Index, Input_Length.GetInt());
}

/*==========================================================================*/
SCSFExport scsf_PercentagePriceOscillator(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_PPO = sc.Subgraph[0];
	SCSubgraphRef Subgraph_ShortMA = sc.Subgraph[1];
	SCSubgraphRef Subgraph_LongMA = sc.Subgraph[2];

	SCInputRef Input_LongMALength = sc.Input[0];
	SCInputRef Input_ShortMALength = sc.Input[1];
	SCInputRef Input_MAType = sc.Input[2];
	SCInputRef Input_InputData = sc.Input[3];

	if (sc.SetDefaults)
	{
		// Set the configuration and defaults

		sc.GraphName = "Percentage Price Oscillator";

		Subgraph_PPO.Name = "PPO";
		Subgraph_PPO.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_PPO.PrimaryColor = RGB(0,255,0);
		Subgraph_PPO.DrawZeros = true;

		Input_LongMALength.Name = "Long Mov Avg Length";
		Input_LongMALength.SetInt(30);
		Input_LongMALength.SetIntLimits(1, INT_MAX);

		Input_ShortMALength.Name = "Short Mov Avg Length";
		Input_ShortMALength.SetInt(10);
		Input_ShortMALength.SetIntLimits(1, INT_MAX);

		Input_MAType.Name = "Moving Average Type";
		Input_MAType.SetMovAvgType(MOVAVGTYPE_EXPONENTIAL);

		Input_InputData.Name = "Input Data";
		Input_InputData.SetInputDataIndex(SC_LAST);

		sc.AutoLoop = 1;

		return;
	}

	sc.MovingAverage(sc.BaseData[Input_InputData.GetInputDataIndex()], Subgraph_LongMA, Input_MAType.GetMovAvgType(),Input_LongMALength.GetInt());

	sc.MovingAverage(sc.BaseData[Input_InputData.GetInputDataIndex()], Subgraph_ShortMA, Input_MAType.GetMovAvgType(),Input_ShortMALength.GetInt());

	if (Subgraph_LongMA[sc.Index] == 0)
		Subgraph_PPO[sc.Index] = Subgraph_PPO[sc.Index - 1];
	else
		Subgraph_PPO[sc.Index] = (  (Subgraph_ShortMA[sc.Index] - Subgraph_LongMA[sc.Index]) / Subgraph_LongMA[sc.Index]) * 100;
}
/*==========================================================================*/


SCSFExport scsf_HerrickPayoffIndex(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_HPI = sc.Subgraph[0];
	SCSubgraphRef Subgraph_Zero = sc.Subgraph[1];

	SCInputRef Input_ValueOfMove = sc.Input[0];
	SCInputRef Input_SmoothingMult = sc.Input[1];
	SCInputRef Input_MaximumOrMinimum = sc.Input[2];
	SCInputRef Input_Divisor = sc.Input[3];

	if (sc.SetDefaults)
	{
		// Set the configuration and defaults

		sc.GraphName = "Herrick Payoff Index";

		Subgraph_HPI.Name = "HPI";
		Subgraph_HPI.PrimaryColor = RGB(0, 255, 0);  // Red
		Subgraph_HPI.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_HPI.DrawZeros = true;

		Subgraph_Zero.Name = "Zero";
		Subgraph_Zero.PrimaryColor = RGB(255, 255, 0);  // Red
		Subgraph_Zero.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_Zero.DrawZeros = true;

		Input_ValueOfMove.Name = "Value of a .01 Move";
		Input_ValueOfMove.SetFloat(0.5f);
		
		Input_SmoothingMult.Name = "Smoothing multiplier";
		Input_SmoothingMult.SetFloat(0.1f);
		
		Input_MaximumOrMinimum.Name = "Maximum or Minimum Open Interest: 1= maximum, 2= minimum";
		Input_MaximumOrMinimum.SetInt(1);
		Input_MaximumOrMinimum.SetIntLimits(1, 2);

		Input_Divisor.Name = "Divisor";
		Input_Divisor.SetFloat(100000.0f);
		

		sc.AutoLoop = 1;

		return;
	}

	if (sc.Index == 0)
		return;
	
		float CurrentVolume = sc.Volume[sc.Index];

		// current and previous mean price (high + low) / 2
		float AveragePrice = sc.HLAvg[sc.Index];	
		float PriorAveragePrice = sc.HLAvg[sc.Index - 1];   

		
		float CurrentOpenInterest = sc.OpenInterest[sc.Index];	
		float PriorOpenInterest = sc.OpenInterest[sc.Index-1];	

		if (CurrentOpenInterest<=0.0f)
		{
			CurrentOpenInterest = PriorOpenInterest;
		}

		// Determine sign for calculations
		float sign = ( AveragePrice > PriorAveragePrice ) ? 1.0f : -1.0f;

		// the absolute value of the difference between current open interest and
		// prior open interest
		float PositiveOpenInterest = fabs(CurrentOpenInterest - PriorOpenInterest);

		
		float MaximumOrMinimumOpenInterest = (Input_MaximumOrMinimum.GetInt()==1) ? max(CurrentOpenInterest, PriorOpenInterest) : min(CurrentOpenInterest, PriorOpenInterest);

		float PriorHerrickPayoffIndex = Subgraph_HPI[sc.Index - 1];

		if (MaximumOrMinimumOpenInterest>0.0f)
		{
			float CalculationResult = Input_ValueOfMove.GetFloat() * CurrentVolume * (AveragePrice - PriorAveragePrice) * (1 + sign*2*PositiveOpenInterest/MaximumOrMinimumOpenInterest)/Input_Divisor.GetFloat();

			if(sc.Index>1)
			{	
				Subgraph_HPI[sc.Index] = PriorHerrickPayoffIndex + (CalculationResult-PriorHerrickPayoffIndex)*Input_SmoothingMult.GetFloat();
			}
			else
			{
				Subgraph_HPI[sc.Index] = CalculationResult;
			}
		}
		else
		{
			Subgraph_HPI[sc.Index] = PriorHerrickPayoffIndex;
		}
	
	
}

/*==========================================================================*/
SCSFExport scsf_TRIX(SCStudyInterfaceRef sc)
{	
	SCSubgraphRef Subgraph_TRIX = sc.Subgraph[0];

	SCInputRef Input_InputData = sc.Input[0];
	SCInputRef Input_Length = sc.Input[2];

	if (sc.SetDefaults)
	{
		sc.GraphName = "TRIX";

		Subgraph_TRIX.Name = "TRIX";
		Subgraph_TRIX.DrawStyle = DRAWSTYLE_BAR;
		Subgraph_TRIX.PrimaryColor = RGB(0,255,0);

		Input_InputData.Name = "Input Data";
		Input_InputData.SetInputDataIndex(SC_LAST); // default data field		

		// Make the Length input and default it to 3
		Input_Length.Name = "Length";
		Input_Length.SetInt(3);
		Input_Length.SetIntLimits(1,MAX_STUDY_LENGTH);

		sc.AutoLoop = 1;

		return;
	}

	// Data start and update start
	sc.DataStartIndex = (Input_Length.GetInt() - 1) * 3 + 1;
	
	sc.TRIX(sc.BaseData[Input_InputData.GetInputDataIndex()], Subgraph_TRIX, Input_Length.GetInt());
}

/*==========================================================================
* Method			- Momentum Gauging
* Description	- 
* Price = Close
* Length = 20
* 
* Histo = LinearRegression[Length] (price - ((Highest[Length](High) + Lowest[Length](Low))/2 + ExponentialAverage[Length](close))/2 )
* 
* RETURN Histo as "Histogramme"[/color][/color]
*
==========================================================================*/
SCSFExport scsf_MomentumGauging(SCStudyInterfaceRef sc)
{
	const int INDEX_EMA = 1;
	const int INDEX_LREG_SRC = 2;

	SCSubgraphRef Subgraph_Momentum = sc.Subgraph[0];
	SCSubgraphRef Subgraph_EMA = sc.Subgraph[1];
	SCSubgraphRef Subgraph_LREG_SRC = sc.Subgraph[2];

	SCInputRef Input_InputData = sc.Input[0];
	SCInputRef Input_Length = sc.Input[2];

	if (sc.SetDefaults)
	{
		sc.GraphName = "Momentum Gauging";

		Subgraph_Momentum.Name = "Momentum";
		Subgraph_Momentum.DrawStyle = DRAWSTYLE_BAR;
		Subgraph_Momentum.PrimaryColor = RGB(0,255,0);
		//Momentum.SecondaryColorUsed = 1;
		Subgraph_Momentum.SecondaryColor = RGB(255,0,0);
		

		Input_InputData.Name = "Input Data";
		Input_InputData.SetInputDataIndex(SC_LAST); // default data field		

		// Make the Length input and default it to 3
		Input_Length.Name = "Length";
		Input_Length.SetInt(3);
		Input_Length.SetIntLimits(1,MAX_STUDY_LENGTH);

		sc.AutoLoop = 1;

		return;
	}

	// First output elements are not valid
	sc.DataStartIndex = Input_Length.GetInt();

	sc.ExponentialMovAvg(sc.Close, Subgraph_EMA, sc.Index, Input_Length.GetInt());  // Note: EMA returns close when index is < Length.GetInt()

	float hlh = sc.GetHighest(sc.High, sc.Index, Input_Length.GetInt());
	float lll = sc.GetLowest(sc.Low, sc.Index, Input_Length.GetInt());

	SCFloatArrayRef price = sc.BaseData[Input_InputData.GetInputDataIndex()];

	// populate the source data for linear regression
	Subgraph_LREG_SRC[sc.Index] = price[sc.Index] - ((hlh + lll)/2.0f + Subgraph_EMA[sc.Index])/2.0f;

	sc.LinearRegressionIndicator(Subgraph_LREG_SRC, Subgraph_Momentum, sc.Index, Input_Length.GetInt());

	/*if (Momentum[sc.Index] >= 0)
		Momentum.DataColor[sc.Index] = Momentum.PrimaryColor;
	else
		Momentum.DataColor[sc.Index] = Momentum.SecondaryColor ;*/

}

/*==========================================================================

function main(nInputLength) 
{
var vC = close(0);
var vPH = high(-1);
var vPL = low(-1);

if(vC == null || vPH == null || vPL == null) return;

if (vC > vPH) {
setPriceBarColor(Color.lime);
} else if(vC < vPL) {
setPriceBarColor(Color.red);
}

return;	
}
==========================================================================*/
SCSFExport scsf_HHLLCandles(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_HH = sc.Subgraph[0];
	SCSubgraphRef Subgraph_LL = sc.Subgraph[1];
	SCSubgraphRef Subgraph_N = sc.Subgraph[2];

	if (sc.SetDefaults)
	{
		sc.GraphName = "HH LL Bars";
		sc.StudyDescription = "";

		sc.GraphRegion = 0;

		Subgraph_HH.Name = "HH";
		Subgraph_HH.DrawStyle = DRAWSTYLE_COLOR_BAR_CANDLE_FILL;
		Subgraph_HH.PrimaryColor = RGB(0, 255, 0);
		Subgraph_HH.SecondaryColor = RGB(0, 0, 0);
		Subgraph_HH.SecondaryColorUsed = 1;
		Subgraph_HH.DrawZeros = false;

		Subgraph_LL.Name = "LL";
		Subgraph_LL.DrawStyle = DRAWSTYLE_COLOR_BAR_CANDLE_FILL;
		Subgraph_LL.PrimaryColor = RGB(255, 0, 0);
		Subgraph_LL.SecondaryColor = RGB(0, 0, 0);
		Subgraph_LL.SecondaryColorUsed = 1;
		Subgraph_LL.DrawZeros = false;

		Subgraph_N.Name = "N";
		Subgraph_N.DrawStyle = DRAWSTYLE_COLOR_BAR;
		Subgraph_N.PrimaryColor = RGB(50, 50, 190);
		Subgraph_N.DrawZeros = false;

		sc.AutoLoop = 1;

		return;
	}
	
	sc.ValueFormat = sc.BaseGraphValueFormat;
	
	sc.DataStartIndex = 1;
	if (sc.Index<1)
		return;

	float priorHigh = sc.High[sc.Index - 1];
	float priorLow = sc.Low[sc.Index - 1];

	float currentClose = sc.Close[sc.Index];

	Subgraph_HH[sc.Index] = 0;
	Subgraph_LL[sc.Index] = 0;
	Subgraph_N[sc.Index] = 0;

	if (sc.FormattedEvaluate(currentClose, sc.BaseGraphValueFormat, GREATER_OPERATOR, priorHigh, sc.BaseGraphValueFormat))
	{
		Subgraph_HH[sc.Index] = 1;
		//We need to set these to 0 because conditions can change on the last bar during real-time updating.
		Subgraph_N[sc.Index] = 0;
		Subgraph_LL[sc.Index] = 0;
	}
	else if (sc.FormattedEvaluate(currentClose, sc.BaseGraphValueFormat, LESS_OPERATOR, priorLow, sc.BaseGraphValueFormat))
	{
		Subgraph_LL[sc.Index] = 1;
		Subgraph_N[sc.Index] = 0;
		Subgraph_HH[sc.Index] = 0;
	}
	else
	{
		Subgraph_N[sc.Index] = 1;
		Subgraph_HH[sc.Index] = 0;
		Subgraph_LL[sc.Index] = 0;
	}

}

/*==========================================================================*/
SCSFExport scsf_RahulMohindarOscillator(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_ST1 = sc.Subgraph[0];
	SCSubgraphRef Subgraph_ST2 = sc.Subgraph[1];
	SCSubgraphRef Subgraph_ST3 = sc.Subgraph[2];
	SCSubgraphRef Subgraph_RMO = sc.Subgraph[3];
	SCSubgraphRef Subgraph_Refline = sc.Subgraph[4];
	SCSubgraphRef Subgraph_Buy = sc.Subgraph[5];
	SCSubgraphRef Subgraph_Sell = sc.Subgraph[6];

	SCFloatArrayRef Array_MATemp3 = sc.Subgraph[0].Arrays[0];
	SCFloatArrayRef Array_MATemp4 = sc.Subgraph[0].Arrays[1];
	SCFloatArrayRef Array_MATemp5 = sc.Subgraph[0].Arrays[2];
	SCFloatArrayRef Array_MATemp6 = sc.Subgraph[0].Arrays[3];
	SCFloatArrayRef Array_MATemp7 = sc.Subgraph[0].Arrays[4];
	SCFloatArrayRef Array_MATemp8 = sc.Subgraph[0].Arrays[5];
	SCFloatArrayRef Array_MATemp9 = sc.Subgraph[0].Arrays[6];
	SCFloatArrayRef Array_MATemp10 = sc.Subgraph[0].Arrays[7];
	SCFloatArrayRef Array_MATemp11 = sc.Subgraph[0].Arrays[8];
	SCFloatArrayRef Array_MATemp12 = sc.Subgraph[0].Arrays[9];
	SCFloatArrayRef Array_Highest = sc.Subgraph[0].Arrays[10];
	SCFloatArrayRef Array_Lowest = sc.Subgraph[0].Arrays[11];

	SCInputRef Input_Len1 = sc.Input[0];
	SCInputRef Input_Len2 = sc.Input[1];
	SCInputRef Input_Len3 = sc.Input[2];
	SCInputRef Input_Len4 = sc.Input[3];
	SCInputRef Input_OffsetPercent = sc.Input[4];
	SCInputRef Input_InputData = sc.Input[5];
	SCInputRef Input_Version = sc.Input[6];

	if (sc.SetDefaults)
	{
		sc.GraphName = "Rahul Mohindar Oscillator";

		Subgraph_ST1.Name = "Swing Trade 1";
		Subgraph_ST1.DrawStyle = DRAWSTYLE_IGNORE;
		Subgraph_ST1.PrimaryColor = RGB(0, 255, 0);

		Subgraph_ST2.Name = "Swing Trade 2";
		Subgraph_ST2.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_ST2.PrimaryColor = RGB(255, 0, 255);

		Subgraph_ST3.Name = "Swing Trade 3";
		Subgraph_ST3.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_ST3.PrimaryColor = RGB(255, 255, 0);

		Subgraph_RMO.Name = "Rahul Mohindar Oscillator";
		Subgraph_RMO.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_RMO.PrimaryColor = RGB(0, 0, 255);

		Subgraph_Refline.Name = "Reference Line";
		Subgraph_Refline.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_Refline.DrawZeros = true;
		Subgraph_Refline.PrimaryColor = RGB(255, 255, 255);

		Subgraph_Buy.Name = "Buy";
		Subgraph_Buy.PrimaryColor = RGB(0, 255, 0);	// green
		Subgraph_Buy.DrawStyle = DRAWSTYLE_ARROW_UP;
		Subgraph_Buy.LineWidth = 2;	//Width of arrow
		Subgraph_Buy.DrawZeros = 0;

		Subgraph_Sell.Name = "Sell";
		Subgraph_Sell.DrawStyle = DRAWSTYLE_ARROW_DOWN;
		Subgraph_Sell.PrimaryColor = RGB(255, 0, 0);	// red
		Subgraph_Sell.LineWidth = 2; //Width of arrow
		Subgraph_Sell.DrawZeros = 0;

		Input_Len1.Name = "Length 1";
		Input_Len1.SetInt(2);

		Input_Len2.Name = "Length 2";
		Input_Len2.SetInt(10);

		Input_Len3.Name = "Length 3";
		Input_Len3.SetInt(30);

		Input_Len4.Name = "Length 4";
		Input_Len4.SetInt(81);

		Input_OffsetPercent.Name = "Arrow Offset Percentage";
		Input_OffsetPercent.SetInt(8);

		Input_InputData.Name = "Input Data";
		Input_InputData.SetInputDataIndex(SC_LAST);

		Input_Version.SetInt(1);

		sc.AutoLoop = 1;

		return;
	}

	if (Input_Version.GetInt() < 1)
	{
		Input_InputData.SetInputDataIndex(SC_LAST);

		Input_Version.SetInt(1);
	}

	sc.DataStartIndex = max(Input_Len1.GetInt(), max(Input_Len2.GetInt(), max(Input_Len3.GetInt(), Input_Len4.GetInt())));

	SCFloatArrayRef BaseDataArray = sc.BaseData[Input_InputData.GetInputDataIndex()];

	sc.SimpleMovAvg(BaseDataArray, Array_MATemp3, Input_Len1.GetInt());
	sc.SimpleMovAvg(Array_MATemp3, Array_MATemp4, Input_Len1.GetInt());
	sc.SimpleMovAvg(Array_MATemp4, Array_MATemp5, Input_Len1.GetInt());
	sc.SimpleMovAvg(Array_MATemp5, Array_MATemp6, Input_Len1.GetInt());
	sc.SimpleMovAvg(Array_MATemp6, Array_MATemp7, Input_Len1.GetInt());
	sc.SimpleMovAvg(Array_MATemp7, Array_MATemp8, Input_Len1.GetInt());
	sc.SimpleMovAvg(Array_MATemp8, Array_MATemp9, Input_Len1.GetInt());
	sc.SimpleMovAvg(Array_MATemp9, Array_MATemp10, Input_Len1.GetInt());
	sc.SimpleMovAvg(Array_MATemp10, Array_MATemp11, Input_Len1.GetInt());
	sc.SimpleMovAvg(Array_MATemp11, Array_MATemp12, Input_Len1.GetInt());
	sc.Highest(BaseDataArray, Array_Highest, Input_Len2.GetInt());
	sc.Lowest(BaseDataArray, Array_Lowest, Input_Len2.GetInt());

	float  Range = Array_Highest[sc.Index] - Array_Lowest[sc.Index];

	if (Range != 0)
	{
		Subgraph_ST1[sc.Index] =
			100 * (BaseDataArray[sc.Index]
				- (Array_MATemp3[sc.Index]
					+ Array_MATemp4[sc.Index]
					+ Array_MATemp5[sc.Index]
					+ Array_MATemp6[sc.Index]
					+ Array_MATemp7[sc.Index]
					+ Array_MATemp8[sc.Index]
					+ Array_MATemp9[sc.Index] + Array_MATemp10[sc.Index]
					+ Array_MATemp11[sc.Index]
					+ Array_MATemp12[sc.Index]) / 10) / Range;
	}


	sc.ExponentialMovAvg(Subgraph_ST1, Subgraph_ST2, Input_Len3.GetInt());
	sc.ExponentialMovAvg(Subgraph_ST2, Subgraph_ST3, Input_Len3.GetInt());
	sc.ExponentialMovAvg(Subgraph_ST1, Subgraph_RMO, Input_Len4.GetInt());
	Subgraph_Refline[sc.Index] = 0;

	float OffsetPercent = Input_OffsetPercent.GetFloat() * 0.01f;

	if (sc.CrossOver(Subgraph_ST3, Subgraph_ST2) == CROSS_FROM_BOTTOM)
	{

		Subgraph_Buy[sc.Index] = Subgraph_ST3[sc.Index] - OffsetPercent * Subgraph_ST3[sc.Index];
		Subgraph_Sell[sc.Index] = 0;
	}
	else if (sc.CrossOver(Subgraph_ST3, Subgraph_ST2) == CROSS_FROM_TOP)
	{
		Subgraph_Sell[sc.Index] = Subgraph_ST3[sc.Index] + OffsetPercent * Subgraph_ST3[sc.Index];
		Subgraph_Buy[sc.Index] = 0;
	}
	else
	{
		Subgraph_Buy[sc.Index] = 0;
		Subgraph_Sell[sc.Index] = 0;
	}
}

/* ****************************************************************
*
* Calculation:
* The value of the DeMarker for the "i" interval is calculated as follows:
*	The DeMax(i) is calculated: 
*
* If high(i) > high(i-1) , then DeMax(i) = high(i)-high(i-1), otherwise DeMax(i) = 0
*	The DeMin(i) is calculated: 
*
* If low(i) < low(i-1), then DeMin(i) = low(i-1)-low(i), otherwise DeMin(i) = 0
*	The value of the DeMarker is calculated as: 
*
* DMark(i) = SMA(DeMax, N)/(SMA(DeMax, N)+SMA(DeMin, N))
*
******************************************************************/
SCSFExport scsf_Demarker(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_Demarker = sc.Subgraph[0];
	SCSubgraphRef Subgraph_Demax = sc.Subgraph[1];
	SCSubgraphRef Subgraph_SMA_Demax = sc.Subgraph[2];
	SCSubgraphRef Subgraph_Demin = sc.Subgraph[3];
	SCSubgraphRef Subgraph_SMA_Demin = sc.Subgraph[4];

	if (sc.SetDefaults)
	{
		sc.GraphName="Demarker";
		sc.StudyDescription="Demarker";

		Subgraph_Demarker.Name="Demarker";
		Subgraph_Demarker.DrawStyle=DRAWSTYLE_LINE;
		Subgraph_Demarker.PrimaryColor = RGB(0,255,0);

		sc.Input[0].Name="Length";
		sc.Input[0].SetInt(13);
		sc.Input[0].SetIntLimits(1,MAX_STUDY_LENGTH);

		sc.AutoLoop = 1;

		return;
	}

	int length = sc.Input[0].GetInt();

	sc.DataStartIndex = length;

	if (sc.Index > 0)
	{
		// If high(i) > high(i-1) , then DeMax(i) = high(i)-high(i-1), otherwise DeMax(i) = 0

		float high = sc.High[sc.Index];
		float highOld = sc.High[sc.Index-1];

		if (high > highOld)
		{
			Subgraph_Demax[sc.Index] = high - highOld;
		}
		else
		{
			Subgraph_Demax[sc.Index] = 0.0f;
		}

		// If low(i) < low(i-1), then DeMin(i) = low(i-1)-low(i), otherwise DeMin(i) = 0

		float low = sc.Low[sc.Index];
		float lowOld = sc.Low[sc.Index-1];

		if (low < lowOld)
		{
			Subgraph_Demin[sc.Index] = lowOld - low;
		}
		else
		{
			Subgraph_Demin[sc.Index] = 0.0f;
		}
	}
	else
	{
		Subgraph_Demax[sc.Index] = 0.0f;
		Subgraph_Demin[sc.Index] = 0.0f;
	}

	// DMark(i) = SMA(DeMax, N)/(SMA(DeMax, N)+SMA(DeMin, N))

	sc.SimpleMovAvg(Subgraph_Demax, Subgraph_SMA_Demax, length);
	sc.SimpleMovAvg(Subgraph_Demin, Subgraph_SMA_Demin,  length);

	float summ = Subgraph_SMA_Demax[sc.Index] + Subgraph_SMA_Demin[sc.Index];
	if (summ != 0.0f)
	{        
		Subgraph_Demarker[sc.Index] = Subgraph_SMA_Demax[sc.Index] / summ;
	}
	else
	{
		Subgraph_Demarker[sc.Index] = Subgraph_Demarker[sc.Index-1];
	}
}


/*==========================================================================*/
SCSFExport scsf_StochasticRSI(SCStudyInterfaceRef sc)
{

	SCSubgraphRef Subgraph_StochasticRSI = sc.Subgraph[0];
	SCSubgraphRef Subgraph_RSI = sc.Subgraph[1];

	SCInputRef Input_RSILength = sc.Input[0];
	SCInputRef Input_RSIAvgType = sc.Input[1];
	SCInputRef Input_RSIHighestLowestLength = sc.Input[2];

	if(sc.SetDefaults)
	{
		sc.GraphName="Stochastic RSI";

		Subgraph_StochasticRSI.Name="Stochastic RSI";
		Subgraph_StochasticRSI.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_StochasticRSI.PrimaryColor = RGB(0,255,0);
		Subgraph_StochasticRSI.DrawZeros = true;

		Input_RSILength.Name="RSI Length";
		Input_RSILength.SetInt(14);
		Input_RSILength.SetIntLimits(1, MAX_STUDY_LENGTH);

		Input_RSIAvgType.Name="RSI Average Type";
		Input_RSIAvgType.SetMovAvgType(MOVAVGTYPE_SIMPLE);

		Input_RSIHighestLowestLength.Name = "RSI Highest Lowest Length";
		Input_RSIHighestLowestLength.SetInt(14);
		Input_RSIHighestLowestLength.SetIntLimits(1, MAX_STUDY_LENGTH);
		
		sc.AutoLoop = 1;

		return;
	}

	sc.DataStartIndex = Input_RSILength.GetInt() + Input_RSIHighestLowestLength.GetInt() - 1; 

	if (Input_RSIHighestLowestLength.GetInt() == 1)
		Input_RSIHighestLowestLength.SetInt(Input_RSILength.GetInt());

	if (sc.Index<1)
	{
		return;
	}

	sc.RSI(sc.Close, Subgraph_RSI, Input_RSIAvgType.GetMovAvgType(), Input_RSILength.GetInt());

	// computing Stochastic of RSI
	float MaximumRSI = sc.GetHighest(Subgraph_RSI, sc.Index, Input_RSIHighestLowestLength.GetInt());
	float MinimumRSI = sc.GetLowest(Subgraph_RSI, sc.Index, Input_RSIHighestLowestLength.GetInt());

	if (MaximumRSI-MinimumRSI != 0.0f)
	{
		Subgraph_StochasticRSI[sc.Index] = (Subgraph_RSI[sc.Index]-MinimumRSI)/(MaximumRSI - MinimumRSI);
	}
	else
	{
		Subgraph_StochasticRSI[sc.Index] = Subgraph_StochasticRSI[sc.Index-1];
	}
}
/*==========================================================================*/
SCSFExport scsf_MinerDTOscillator(SCStudyInterfaceRef sc)
{
	SCSubgraphRef SK        = sc.Subgraph[0];
	SCSubgraphRef SD        = sc.Subgraph[1];
	SCSubgraphRef UpperLine = sc.Subgraph[2];
	SCSubgraphRef ZeroLine  = sc.Subgraph[3];
	SCSubgraphRef LowerLine = sc.Subgraph[4];

	SCFloatArrayRef RSI                 = SK.Arrays[0];
	SCFloatArrayRef RsiUpSums           = SK.Arrays[1];
	SCFloatArrayRef RsiDownSums         = SK.Arrays[2];
	SCFloatArrayRef RsiSmoothedUpSums   = SK.Arrays[3];
	SCFloatArrayRef RsiSmoothedDownSums = SK.Arrays[4];
	SCFloatArrayRef StochRSI            = SK.Arrays[5];

	SCInputRef RSILength   = sc.Input[0];
	SCInputRef RSIAvgType  = sc.Input[1];
	SCInputRef StochLength = sc.Input[2];
	SCInputRef SKLength    = sc.Input[3];
	SCInputRef SKAvgType   = sc.Input[4];
	SCInputRef SDLength    = sc.Input[5];
	SCInputRef SDAvgType   = sc.Input[6];
	SCInputRef UpperValue  = sc.Input[7];
	SCInputRef LowerValue  = sc.Input[8];

	if(sc.SetDefaults)
	{
		sc.GraphName="DT Oscillator";
		sc.StudyDescription="DT Oscillator - Robert Miner"; 

		SK.Name="DT Osc SK";
		SK.DrawStyle = DRAWSTYLE_LINE;
		SK.PrimaryColor = COLOR_RED;
		SK.DrawZeros = true;

		SD.Name="DT Osc SD";
		SD.DrawStyle = DRAWSTYLE_LINE;
		SD.PrimaryColor = COLOR_GREEN;
		SD.DrawZeros = true;

		UpperLine.Name="Upper";
		UpperLine.DrawStyle = DRAWSTYLE_LINE;
		UpperLine.LineStyle = LINESTYLE_DOT;
		UpperLine.PrimaryColor = COLOR_GRAY;
		UpperLine.DisplayNameValueInWindowsFlags = 0;
		UpperLine.DrawZeros = true;

		ZeroLine.Name="Zero";
		ZeroLine.DrawStyle = DRAWSTYLE_IGNORE;
		ZeroLine.LineStyle = LINESTYLE_DOT;
		ZeroLine.PrimaryColor = COLOR_GRAY;
		ZeroLine.DisplayNameValueInWindowsFlags = 0;
		ZeroLine.DrawZeros = true;

		LowerLine.Name="Lower";
		LowerLine.DrawStyle = DRAWSTYLE_LINE;
		LowerLine.LineStyle = LINESTYLE_DOT;
		LowerLine.PrimaryColor = COLOR_GRAY;
		LowerLine.DisplayNameValueInWindowsFlags = 0;
		LowerLine.DrawZeros = true;

		RSILength.Name="RSI Length";
		RSILength.SetInt(13);

		RSIAvgType.Name="RSI Average Type";
		RSIAvgType.SetMovAvgType(MOVAVGTYPE_SIMPLE);

		StochLength.Name="Stochastic Length";
		StochLength.SetInt(8);

		SKLength.Name="SK Length";
		SKLength.SetInt(5);

		SKAvgType.Name="SK Average Type";
		SKAvgType.SetMovAvgType(MOVAVGTYPE_SIMPLE);

		SDLength.Name="SD Length";
		SDLength.SetInt(3);

		SDAvgType.Name="SD Average Type";
		SDAvgType.SetMovAvgType(MOVAVGTYPE_SIMPLE);

		UpperValue.Name="Upper Line Value";
		UpperValue.SetFloat(75.0f);

		LowerValue.Name="Lower Line Value";
		LowerValue.SetFloat(25.0f);

		sc.AutoLoop = 1;

		return;
	}

	sc.DataStartIndex = RSILength.GetInt(); 

	UpperLine[sc.Index] = UpperValue.GetFloat();
	ZeroLine[sc.Index]  = 0;
	LowerLine[sc.Index] = LowerValue.GetFloat();

	if (sc.Index<1)
	{
		return;
	}

	sc.RSI(sc.Close, RSI, RsiUpSums, RsiDownSums, RsiSmoothedUpSums, RsiSmoothedDownSums, RSIAvgType.GetMovAvgType(), RSILength.GetInt());

	// computing Stochastic of RSI
	float maxRSI = sc.GetHighest(RSI, sc.Index, StochLength.GetInt());
	float minRSI = sc.GetLowest(RSI, sc.Index, StochLength.GetInt());

	if (maxRSI-minRSI != 0.0f)
	{
		StochRSI[sc.Index] = 100.0f * (RSI[sc.Index]-minRSI)/(maxRSI - minRSI);
	}
	else
	{
		StochRSI[sc.Index] = StochRSI[sc.Index-1];
	}

	sc.MovingAverage(StochRSI, SK, SKAvgType.GetMovAvgType(), SKLength.GetInt());
	sc.MovingAverage(SK, SD, SDAvgType.GetMovAvgType(), SDLength.GetInt());
}

/*==========================================================================*/
SCSFExport scsf_VerticalTimeLine(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_TimeLine = sc.Subgraph[0];
	SCSubgraphRef Subgraph_TimeLineBottom = sc.Subgraph[1];
	SCSubgraphRef Subgraph_CustomLabel = sc.Subgraph[2];

	SCInputRef Input_TimeOfLine = sc.Input[0];
	SCInputRef Input_DisplayCustomLabel = sc.Input[1];
	SCInputRef Input_VerticalPositionPercent = sc.Input[2];
	SCInputRef Input_Version = sc.Input[3];
	SCInputRef Input_ForwardProject = sc.Input[4];
	SCInputRef Input_AllowedRangeForMatchInMinutes = sc.Input[5];
	SCInputRef Input_MatchingMethod = sc.Input[6];
	SCInputRef Input_DayOfWeek = sc.Input[7];


	if(sc.SetDefaults)
	{
		sc.GraphName="Time Line";
		sc.StudyDescription="Draws a vertical line at the time specified with the Time of Line Input.";

		sc.AutoLoop = 0;//Manual looping
		sc.GraphRegion = 0;
		sc.ScaleRangeType = SCALE_USERDEFINED;
		sc.ScaleRangeTop = 2;
		sc.ScaleRangeBottom = 1;

		Subgraph_TimeLine.Name = "TimeLine";
		Subgraph_TimeLine.DrawStyle = DRAWSTYLE_BAR_TOP;
		Subgraph_TimeLine.PrimaryColor = RGB(127,127,127);
		Subgraph_TimeLine.DrawZeros = false;
		Subgraph_TimeLine.LineWidth = 1;

		Subgraph_TimeLineBottom.Name = "TimeLine";
		Subgraph_TimeLineBottom.DrawStyle = DRAWSTYLE_BAR_BOTTOM;
		Subgraph_TimeLineBottom.PrimaryColor = RGB(127,127,127);
		Subgraph_TimeLineBottom.DrawZeros =  false;
		Subgraph_TimeLineBottom.LineWidth = 1;

		Subgraph_CustomLabel.Name = "Custom Label Color and Text Size";
		Subgraph_CustomLabel.DrawStyle=DRAWSTYLE_CUSTOM_TEXT;
		Subgraph_CustomLabel.PrimaryColor = RGB(127,127,127);
		Subgraph_CustomLabel.LineWidth =  0;

		Input_TimeOfLine.Name = "Time of Line";
		Input_TimeOfLine.SetTime(HMS_TIME(12, 00, 0));

		Input_DisplayCustomLabel.Name = "Display Custom Label";
		Input_DisplayCustomLabel.SetYesNo(false);

		Input_VerticalPositionPercent.Name = "Label Vertical Position %.";
		Input_VerticalPositionPercent.SetInt(5);
		Input_VerticalPositionPercent.SetIntLimits(0,100);

		sc.TextInputName = "Custom Label Text";

		Input_ForwardProject.Name = "Display in Forward Projection Area";
		Input_ForwardProject.SetYesNo(false);

		Input_AllowedRangeForMatchInMinutes.Name = "Allowed Range for Match in Minutes";
		Input_AllowedRangeForMatchInMinutes.SetInt(10);

		Input_MatchingMethod.Name = "Matching Method";
		Input_MatchingMethod.SetCustomInputStrings("Nearest;Containing");
		Input_MatchingMethod.SetCustomInputIndex(0);

		Input_DayOfWeek.Name = "Allowed Day of Week";
		Input_DayOfWeek.SetCustomInputStrings("All Days;Monday;Tuesday;Wednesday;Thursday;Friday;Saturday;Sunday");
		Input_DayOfWeek.SetCustomInputIndex(0);

		Input_Version.SetInt(3);

		return;
	}

	if (Input_Version.GetInt() < 2)
	{
		Subgraph_TimeLine.DrawStyle = DRAWSTYLE_BAR_TOP;
		Subgraph_TimeLineBottom.DrawStyle = DRAWSTYLE_BAR_BOTTOM;
		Input_Version.SetInt(3);
	}

	if (Input_Version.GetInt() < 3)
	{
		Input_AllowedRangeForMatchInMinutes.SetInt(10);
		Input_Version.SetInt(3);
	}

	int NumberForwardBars = 0;
	if(Input_ForwardProject.GetYesNo())
	{
		//Subtracting 1 since the study references one bar ahead
		NumberForwardBars = sc.NumberOfForwardColumns-1;
		Subgraph_TimeLine.ExtendedArrayElementsToGraph = NumberForwardBars;
		Subgraph_TimeLineBottom.ExtendedArrayElementsToGraph = NumberForwardBars;
	}

	const int AllowedDayOfWeek = Input_DayOfWeek.GetIndex() - 1;

	int NearestDateTimeIndex = -1;

	for (int BarIndex = sc.UpdateStartIndex; BarIndex < (sc.ArraySize + NumberForwardBars); BarIndex++)
	{
		if (AllowedDayOfWeek >= 0)
		{
			if (sc.BaseDateTimeIn[BarIndex].GetDayOfWeekMondayBased() != AllowedDayOfWeek)
				continue;
		}

		const SCDateTimeMS TimeLineDateTime(sc.BaseDateTimeIn[BarIndex].GetDate(), Input_TimeOfLine.GetTime());

		if(sc.BaseDateTimeIn[BarIndex - 1].GetDate() != sc.BaseDateTimeIn[BarIndex].GetDate())
			NearestDateTimeIndex = -1;

		if(NearestDateTimeIndex == -1)
		{
			if (Input_MatchingMethod.GetIndex() == 0)
			{
				NearestDateTimeIndex
					= sc.GetNearestMatchForSCDateTimeExtended(sc.ChartNumber, TimeLineDateTime);
			}
			else
			{
				if (TimeLineDateTime > sc.BaseDateTimeIn[BarIndex - 1]
					&& TimeLineDateTime <= sc.BaseDateTimeIn[BarIndex])
				{
					NearestDateTimeIndex = BarIndex;
				}
			}
		}

		SCDateTimeMS TimeMargin;
		TimeMargin.SetTimeHMS(0, Input_AllowedRangeForMatchInMinutes.GetInt(), 0);
		SCDateTimeMS EarlierTime = TimeLineDateTime - TimeMargin;
		SCDateTimeMS LaterTime = TimeLineDateTime + TimeMargin;

		if (BarIndex == NearestDateTimeIndex
			&& sc.BaseDateTimeIn[BarIndex] >= EarlierTime
			&& sc.BaseDateTimeIn[BarIndex] <= LaterTime)
		{
			Subgraph_TimeLine[BarIndex] = 100;
			Subgraph_TimeLineBottom[BarIndex] = -100;
		}
		else
		{
			Subgraph_TimeLine[BarIndex] = 0;
			Subgraph_TimeLineBottom[BarIndex] = 0;
		}

		if (Subgraph_TimeLine[BarIndex] == 0)
			continue;


		if(Input_DisplayCustomLabel.GetYesNo() 
			&& !sc.HideStudy
			&& BarIndex < sc.ArraySize)
		{
			int &r_LastUsedBarIndex = sc.GetPersistentInt(1);
			int &r_RememberedLineNumber = sc.GetPersistentInt(2);

			if(sc.IsFullRecalculation)
			{
				r_LastUsedBarIndex = -1;
				r_RememberedLineNumber = 0;
			}

			if(BarIndex == r_LastUsedBarIndex)
				continue;

			//If there still is a timeline at r_LastUsedBarIndex, then we need to not reuse the prior line number because this is a new one.  If got to this point in the code, then we are at an index after r_LastUsedBarIndex.
			if (r_LastUsedBarIndex != -1 && Subgraph_TimeLine[r_LastUsedBarIndex] != 0)
				r_RememberedLineNumber = 0;


			r_LastUsedBarIndex = BarIndex;

			s_UseTool Tool;
			Tool.ChartNumber = sc.ChartNumber;
			Tool.DrawingType = DRAWING_TEXT;
			Tool.Region = sc.GraphRegion;

			Tool.BeginIndex = BarIndex;
			Tool.UseRelativeVerticalValues = true;
			Tool.BeginValue = static_cast<float>(Input_VerticalPositionPercent.GetInt());
			Tool.Text = sc.TextInput;

			Tool.Color = Subgraph_CustomLabel.PrimaryColor;
			Tool.FontBold = true;
			Tool.FontSize = Subgraph_CustomLabel.LineWidth;
			if (r_RememberedLineNumber != 0)
			{
				Tool.LineNumber = r_RememberedLineNumber;
			}

			Tool.AddMethod = UTAM_ADD_OR_ADJUST;

			sc.UseTool(Tool);
			r_RememberedLineNumber = Tool.LineNumber;

		}
	}

	return;
}


/*==========================================================================*/
SCSFExport scsf_VerticalDateTimeLine(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_TimeLine = sc.Subgraph[0];
	SCSubgraphRef Subgraph_TimeLineBottom = sc.Subgraph[1];
	SCSubgraphRef Subgraph_CustomLabel = sc.Subgraph[2];

	SCInputRef Input_DateTimeOfLine = sc.Input[0];
	SCInputRef Input_DisplayCustomLabel = sc.Input[1];
	SCInputRef Input_VerticalPositionPercent = sc.Input[2];
	SCInputRef Input_Version = sc.Input[3];
	SCInputRef Input_ForwardProject = sc.Input[4];
	SCInputRef Input_AllowedRangeForMatchInMinutes = sc.Input[5];
	SCInputRef Input_MatchingMethod = sc.Input[6];


	if(sc.SetDefaults)
	{
		sc.GraphName="Date-Time Line";
		sc.StudyDescription="Draws a vertical line at the date-time specified with the Date-Time of Line input.";

		sc.AutoLoop = 0;//Manual looping
		sc.GraphRegion = 0;
		sc.ScaleRangeType = SCALE_USERDEFINED;
		sc.ScaleRangeTop = 2;
		sc.ScaleRangeBottom = 1;

		Subgraph_TimeLine.Name = "TimeLine";
		Subgraph_TimeLine.DrawStyle = DRAWSTYLE_BAR_TOP;
		Subgraph_TimeLine.PrimaryColor = RGB(127,127,127);
		Subgraph_TimeLine.DrawZeros = false;
		Subgraph_TimeLine.LineWidth = 1;

		Subgraph_TimeLineBottom.Name = "TimeLine";
		Subgraph_TimeLineBottom.DrawStyle = DRAWSTYLE_BAR_BOTTOM;
		Subgraph_TimeLineBottom.PrimaryColor = RGB(127,127,127);
		Subgraph_TimeLineBottom.DrawZeros =  false;
		Subgraph_TimeLineBottom.LineWidth = 1;

		Subgraph_CustomLabel.Name = "Custom Label Color and Text Size";
		Subgraph_CustomLabel.DrawStyle=DRAWSTYLE_CUSTOM_TEXT;
		Subgraph_CustomLabel.PrimaryColor = RGB(127,127,127);
		Subgraph_CustomLabel.LineWidth =  0;

		Input_DateTimeOfLine.Name = "Date-Time of Line";
		Input_DateTimeOfLine.SetDateTime(sc.CurrentSystemDateTime);

		Input_DisplayCustomLabel.Name = "Display Custom Label";
		Input_DisplayCustomLabel.SetYesNo(false);

		Input_VerticalPositionPercent.Name = "Label Vertical Position %.";
		Input_VerticalPositionPercent.SetInt(5);
		Input_VerticalPositionPercent.SetIntLimits(0,100);

		sc.TextInputName = "Custom Label Text";

		Input_ForwardProject.Name = "Display in Forward Projection Area";
		Input_ForwardProject.SetYesNo(false);

		Input_AllowedRangeForMatchInMinutes.Name = "Allowed Range for Match in Minutes";
		Input_AllowedRangeForMatchInMinutes.SetInt(10);

		Input_MatchingMethod.Name = "Matching Method";
		Input_MatchingMethod.SetCustomInputStrings("Nearest;Containing");
		Input_MatchingMethod.SetCustomInputIndex(0);

		Input_Version.SetInt(1);

		return;
	}


	int NumberForwardBars = 0;
	if(Input_ForwardProject.GetYesNo())
	{
		// Subtracting 1 since the study references one bar ahead
		NumberForwardBars = sc.NumberOfForwardColumns -1;

		Subgraph_TimeLine.ExtendedArrayElementsToGraph = NumberForwardBars;
		Subgraph_TimeLineBottom.ExtendedArrayElementsToGraph = NumberForwardBars;
	}

	int& ChartDrawingLastUsedIndex = sc.GetPersistentInt(1);

	if(sc.UpdateStartIndex == 0)
		ChartDrawingLastUsedIndex = -1;

	int NearestDateTimeIndex = -1;

	for (int Index = sc.UpdateStartIndex; Index < (sc.ArraySize + NumberForwardBars); Index++)
	{

		SCDateTime TimeLineDateTime(Input_DateTimeOfLine.GetDateTime());


		if(NearestDateTimeIndex == -1)
		{
			if (Input_MatchingMethod.GetIndex() == 0)
				NearestDateTimeIndex = sc.GetNearestMatchForSCDateTimeExtended(sc.ChartNumber, TimeLineDateTime);
			else
			{

				if (TimeLineDateTime > sc.BaseDateTimeIn[Index - 1]
				&& TimeLineDateTime <= sc.BaseDateTimeIn[Index])
					NearestDateTimeIndex = Index;
			}
		}

		SCDateTime TimeMargin;
		TimeMargin.SetTimeHMS(0, Input_AllowedRangeForMatchInMinutes.GetInt(), 0);
		SCDateTime EarlierTime = TimeLineDateTime - TimeMargin;
		SCDateTime LaterTime = TimeLineDateTime + TimeMargin;

		if (Index == NearestDateTimeIndex
			&& sc.BaseDateTimeIn[Index] >= EarlierTime
			&& sc.BaseDateTimeIn[Index] <= LaterTime)
		{
			Subgraph_TimeLine[Index] = 100;
			Subgraph_TimeLineBottom[Index] = -100;
		}
		else
		{
			Subgraph_TimeLine[Index] = 0;
			Subgraph_TimeLineBottom[Index] = 0;
		}

		if (Subgraph_TimeLine[Index] == 0)
			continue;


		if(Input_DisplayCustomLabel.GetYesNo() && !sc.HideStudy )
		{
			if(Index == ChartDrawingLastUsedIndex)
				continue;

			ChartDrawingLastUsedIndex = Index;

			s_UseTool Tool;
			Tool.ChartNumber = sc.ChartNumber;
			Tool.DrawingType = DRAWING_TEXT;
			Tool.Region = sc.GraphRegion;
			//Tool.LineNumber //Automatically set
			Tool.AddMethod = UTAM_ADD_OR_ADJUST;

			Tool.BeginIndex = Index;
			Tool.UseRelativeVerticalValues = true;
			Tool.BeginValue = static_cast<float>(Input_VerticalPositionPercent.GetInt());
			Tool.Text = sc.TextInput;

			Tool.Color = Subgraph_CustomLabel.PrimaryColor;
			Tool.FontBold = true;
			Tool.FontSize = Subgraph_CustomLabel.LineWidth;
			sc.UseTool(Tool);

		}
	}

	return;
}

/*==========================================================================*/
SCSFExport scsf_RSITradestation(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_RSIT = sc.Subgraph[0];
	SCSubgraphRef Subgraph_LineUpperLimit = sc.Subgraph[1];
	SCSubgraphRef Subgraph_LineLowerLimit = sc.Subgraph[2];
	SCSubgraphRef Subgraph_RSIAvg = sc.Subgraph[3];
	SCSubgraphRef Subgraph_NetChangeAvg = sc.Subgraph[4];
	SCSubgraphRef Subgraph_TotalChangeAvg = sc.Subgraph[5];

	SCInputRef Input_InputData = sc.Input[0];
	SCInputRef Input_RSILength = sc.Input[1];
	SCInputRef Input_Line1 = sc.Input[3];
	SCInputRef Input_Line2 = sc.Input[4];
	SCInputRef Input_RSIMovAvgLength = sc.Input[5];

	if(sc.SetDefaults)
	{
		sc.GraphName="RSI-TS";
		sc.StudyDescription="RSI implemented as in TradeStation";

		// Outputs
		Subgraph_RSIT.Name="RSI-T";
		Subgraph_RSIT.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_RSIT.PrimaryColor = RGB(0,255,0);
		Subgraph_RSIT.DrawZeros = false;

		Subgraph_LineUpperLimit.Name = "Line1";
		Subgraph_LineUpperLimit.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_LineUpperLimit.PrimaryColor = RGB(255,0,255);
		Subgraph_LineUpperLimit.DrawZeros = false;

		Subgraph_LineLowerLimit.Name = "Line2";
		Subgraph_LineLowerLimit.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_LineLowerLimit.PrimaryColor = RGB(255,255,0);
		Subgraph_LineLowerLimit.DrawZeros = false;

		Subgraph_RSIAvg.Name = "RSI Avg";
		Subgraph_RSIAvg.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_RSIAvg.PrimaryColor = RGB(255,127,0);
		Subgraph_RSIAvg.DrawZeros = false;

		// Inputs
		Input_InputData.Name = "Input Data";
		Input_InputData.SetInputDataIndex(SC_LAST);

		Input_RSILength.Name="RSI Length";
		Input_RSILength.SetInt(10);

		Input_Line1.Name="Line 1";
		Input_Line1.SetFloat(70);
		Input_Line1.SetFloatLimits(50, 100);

		Input_Line2.Name="Line 2";
		Input_Line2.SetFloat(30);
		Input_Line2.SetFloatLimits(0, 50);

		Input_RSIMovAvgLength.Name = "RSI Mov Avg Length";
		Input_RSIMovAvgLength.SetInt(3);
		Input_RSIMovAvgLength.SetIntLimits(1, MAX_STUDY_LENGTH);

		sc.AutoLoop = 1;

		return;
	}

	// start charting after Length of elements is available
	sc.DataStartIndex = Input_RSILength.GetInt(); 
	if (sc.Index<Input_RSILength.GetInt())
		return;

	SCFloatArrayRef  price = sc.BaseData[Input_InputData.GetInputDataIndex()];

	// smoothing factor
	float smoothingFactor = 1.0f / Input_RSILength.GetInt();

	if (sc.Index<Input_RSILength.GetInt())
		return;

	// compute net and total changes

	float totalChange;
	float netChange;

	if (sc.Index==Input_RSILength.GetInt())
	{
		// NetChgAvg = (Price - Price[Length] ) / Length
		netChange = (price[sc.Index] - price[sc.Index - Input_RSILength.GetInt()]) / Input_RSILength.GetInt();

		// TotChgAvg = Average( AbsValue( Price - Price[1] ), Length )
		float average = 0.0;
		for (int i=1; i<=sc.Index; i++)
		{
			average += abs(price[i] - price[i - 1]);
		}       
		totalChange = average / Input_RSILength.GetInt();
	}
	else
	{
		// Change = Price - Price[1]
		float change = price[sc.Index] - price[sc.Index - 1];

		// NetChgAvg = NetChgAvg[1] + SF * ( Change - NetChgAvg[1] )
		float previousNetChange = Subgraph_NetChangeAvg[sc.Index - 1];
		netChange =  previousNetChange + smoothingFactor * ( change - previousNetChange );

		// TotChgAvg = TotChgAvg[1] + SF * ( AbsValue(Change) - TotChgAvg[1] )
		float previousTotalChangeAverage = Subgraph_TotalChangeAvg[sc.Index - 1];
		totalChange = previousTotalChangeAverage + smoothingFactor * ( abs(change) - previousTotalChangeAverage );
	}

	Subgraph_TotalChangeAvg[sc.Index] = totalChange;
	Subgraph_NetChangeAvg[sc.Index] = netChange;

	// compute the RSI value
	float changeRatio = 0;
	if (totalChange!=0.0f)
	{
		changeRatio = netChange / totalChange;
	}
	else
	{
		changeRatio = 0.0f;
	}

	// RSI = 50 * ( ChgRatio + 1)
	Subgraph_RSIT[sc.Index] = 50 * (changeRatio + 1.0f);

	// Draw overbought / oversold indicators
	Subgraph_LineUpperLimit[sc.Index] = Input_Line1.GetFloat();
	Subgraph_LineLowerLimit[sc.Index] = Input_Line2.GetFloat();

	if (sc.Index >= Input_RSIMovAvgLength.GetInt() + Input_RSILength.GetInt())
	{
		// Draw smoothed RSI
		sc.MovingAverage(Subgraph_RSIT, Subgraph_RSIAvg, MOVAVGTYPE_SIMPLE, sc.Index, Input_RSIMovAvgLength.GetInt());
	}
}

/*==========================================================================*/
/*
Triple Exponential Moving Average, by Patrick Mulloy and published in January 1994 
in the Stocks & Commodities magazine

Algorithm is also described in http://www.visualchart.com/enxx/strategies/indicators/ayuda.asp?Id=2857
*/
SCSFExport scsf_MovingAverageTEMA(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_TEMA = sc.Subgraph[0];

	SCInputRef Input_InputData = sc.Input[0];
	SCInputRef Input_Length = sc.Input[1];

	if(sc.SetDefaults)
	{
		sc.GraphName="Moving Average - Triple Exp";
		sc.StudyDescription="Triple Exponential Moving Average";

		sc.GraphRegion = 0;

		Subgraph_TEMA.Name = "TEMA";
		Subgraph_TEMA.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_TEMA.PrimaryColor = RGB(255, 0, 0);
		Subgraph_TEMA.DrawZeros = false;

		Input_InputData.Name = "Input Data";
		Input_InputData.SetInputDataIndex(SC_LAST);

		Input_Length.Name = "Length";
		Input_Length.SetIntLimits(1,MAX_STUDY_LENGTH);
		Input_Length.SetInt(5);

		sc.AutoLoop = 1;

		return;
	}

	sc.DataStartIndex = Input_Length.GetInt();

	SCFloatArrayRef data = sc.BaseData[Input_InputData.GetInputDataIndex()];
	sc.TEMA(data,Subgraph_TEMA,sc.Index,Input_Length.GetInt());
}

/*==========================================================================*/

// http://www.danielstrading.com/education/technical-analysis/historic-volatility.php


SCSFExport scsf_HistoricVolatilityStudy(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_Volatility = sc.Subgraph[0];
	SCSubgraphRef Subgraph_LogPriceChange = sc.Subgraph[1];
	SCSubgraphRef Subgraph_SMALog = sc.Subgraph[2];

	SCInputRef Input_InputData = sc.Input[0];
	SCInputRef Input_AlgorithmType = sc.Input[1];
	SCInputRef Input_Length = sc.Input[2];
	SCInputRef Input_NumberBarsPerYear = sc.Input[3];

	if(sc.SetDefaults)
	{
		sc.GraphName="Volatility - Historical";

		Subgraph_Volatility.Name = "Volatility";
		Subgraph_Volatility.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_Volatility.PrimaryColor = RGB(0, 255,0);
		Subgraph_Volatility.DrawZeros = false;

		Input_InputData.Name = "Input Data";
		Input_InputData.SetInputDataIndex(SC_LAST);


		Input_Length.Name = "Length";
		Input_Length.SetIntLimits(2,MAX_STUDY_LENGTH);
		Input_Length.SetInt(20);

		Input_NumberBarsPerYear.Name = "Number of Bars Per Year";
		Input_NumberBarsPerYear.SetInt(262);

		sc.AutoLoop = 1;
		sc.ValueFormat = 2;

		return;
	}

	sc.DataStartIndex = Input_Length.GetInt();


	// calculate the logarithm of the price change    
	Subgraph_LogPriceChange[sc.Index] = log(sc.BaseData[Input_InputData.GetInputDataIndex()][sc.Index] / sc.BaseData[Input_InputData.GetInputDataIndex()][sc.Index - 1]);

	// calculate the average of the logs
	sc.SimpleMovAvg(Subgraph_LogPriceChange, Subgraph_SMALog, sc.Index, Input_Length.GetInt());

	// sum the squares of the difference between the individual logarithms for each period and the average logarithm
	float SumSquareOfDifference = 0;
	for (int SumIndex = max(0, sc.Index - Input_Length.GetInt() + 1); SumIndex <= sc.Index; SumIndex++)
	{
		float diff = Subgraph_LogPriceChange[SumIndex] - Subgraph_SMALog[sc.Index];
		SumSquareOfDifference += diff * diff;
	}

	// Final volatility calculation
	Subgraph_Volatility[sc.Index] = sqrt(SumSquareOfDifference / float(Input_Length.GetInt() - 1)) * sqrt(float(Input_NumberBarsPerYear.GetInt())) * 100;


}


/******************************************************************************

Synthetic VIX indicator as described in the December 2007 issue of 
"Active Trader" magazine.  The indicator is also named the "Williams VIX Fix" 
since Larry Williams is credited with the formula's discovery.

Formula:

SynthVIX = (Highest(Close,22) - Low) / (Highest(Close,22)) * 100;

*******************************************************************************/
SCSFExport scsf_SyntheticVIX(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_SynthVIX = sc.Subgraph[0];

	SCInputRef Input_Length = sc.Input[0];

	if(sc.SetDefaults)
	{
		sc.GraphName="Synthetic VIX";
		sc.StudyDescription="Synthetic VIX";

		Subgraph_SynthVIX.Name = "SynthVIX";
		Subgraph_SynthVIX.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_SynthVIX.PrimaryColor = RGB(255, 255, 0);
		Subgraph_SynthVIX.DrawZeros = false;

		Input_Length.Name = "Length";
		Input_Length.SetIntLimits(1,MAX_STUDY_LENGTH);
		Input_Length.SetInt(22);
		
		sc.AutoLoop = 1;

		return;
	}

	float HighestClose = sc.GetHighest(sc.Close, sc.Index, Input_Length.GetInt());

	Subgraph_SynthVIX[sc.Index] = 100.0f * (HighestClose - sc.Low[sc.Index]) / HighestClose;
}

/*==========================================================================*/
void PassingSCStrutureExampleFunction(SCStudyInterfaceRef sc)
{
	//The "sc" structure can be used anywhere within this function.
}

/*============================================================================
	"An example of calling a function that receives the Sierra Chart ACSIL structure (sc)."
----------------------------------------------------------------------------*/
SCSFExport scsf_PassingSCStructureExample(SCStudyInterfaceRef sc)
{
	if (sc.SetDefaults)
	{
		// Set the configuration and defaults
		
		sc.GraphName = "Passing sc Structure Example Function";
		
		sc.StudyDescription = "An example of calling a function that receives the Sierra Chart ACSIL structure (sc).";

		return;
	}
	
	// Do data processing

	// The definition of the function called below must be above this function.
	PassingSCStrutureExampleFunction(sc);
}

/*==========================================================================*/
SCSFExport scsf_InvertStudy(SCStudyInterfaceRef sc)
{


	SCSubgraphRef Subgraph_Open = sc.Subgraph[SC_OPEN];
	SCSubgraphRef Subgraph_High = sc.Subgraph[SC_HIGH];
	SCSubgraphRef Subgraph_Low = sc.Subgraph[SC_LOW];
	SCSubgraphRef Subgraph_Last = sc.Subgraph[SC_LAST];
	SCSubgraphRef Subgraph_Volume = sc.Subgraph[SC_VOLUME];
	SCSubgraphRef Subgraph_OHLCAvg = sc.Subgraph[SC_OHLC_AVG];
	SCSubgraphRef Subgraph_HLCAvg = sc.Subgraph[SC_HLC_AVG];
	SCSubgraphRef Subgraph_HLAvg = sc.Subgraph[SC_HL_AVG];
	
	SCSubgraphRef Subgraph_NumTrades = sc.Subgraph[SC_NUM_TRADES];
	SCSubgraphRef Subgraph_BidVol = sc.Subgraph[ SC_BIDVOL];
	SCSubgraphRef Subgraph_AskVol = sc.Subgraph[SC_ASKVOL];


	if(sc.SetDefaults)
	{
		sc.GraphName="Multiply Bars By -1";
		
		sc.ValueFormat = VALUEFORMAT_INHERITED;
		sc.AutoLoop = 1;
		sc.GraphDrawType = GDT_OHLCBAR;
		sc.StandardChartHeader = true;
		sc.GraphUsesChartColors = true;

		return;
	}

	if (sc.IsFullRecalculation && sc.Index == 0)
	{
		sc.GraphName.Format("%s Inverted", sc.GetStudyName(0).GetChars());

		for (int SubgraphIndex = 0; SubgraphIndex <= SC_ASKVOL; ++SubgraphIndex)
		{
			sc.Subgraph[SubgraphIndex].Name = sc.GetStudySubgraphName(0, SubgraphIndex);
			sc.Subgraph[SubgraphIndex].DrawZeros = false;
			if(SubgraphIndex < SC_VOLUME)
				sc.Subgraph[SubgraphIndex].DrawStyle = DRAWSTYLE_LINE;
			else
				sc.Subgraph[SubgraphIndex].DrawStyle = DRAWSTYLE_IGNORE;
		}
	}

	Subgraph_Open[sc.Index] = sc.Open[sc.Index] * -1.0f;
	Subgraph_Last[sc.Index] = sc.Close[sc.Index] * -1.0f;
	Subgraph_High[sc.Index] = sc.High[sc.Index] * -1.0f;
	Subgraph_Low[sc.Index] = sc.Low[sc.Index] * -1.0f;
	Subgraph_OHLCAvg[sc.Index] = sc.OHLCAvg[sc.Index] * -1.0f;
	Subgraph_HLCAvg[sc.Index] = sc.HLCAvg[sc.Index] * -1.0f;
	Subgraph_HLAvg[sc.Index] = sc.HLAvg[sc.Index] * -1.0f;

	Subgraph_Volume[sc.Index] = sc.Volume[sc.Index];
	Subgraph_NumTrades[sc.Index] = sc.NumberOfTrades[sc.Index];
	Subgraph_BidVol[sc.Index] = sc.BidVolume[sc.Index];
	Subgraph_AskVol[sc.Index] = sc.AskVolume[sc.Index];	
}

/*==========================================================================*/
SCSFExport scsf_BarsInTicks(SCStudyInterfaceRef sc)
{
	if (sc.SetDefaults)
	{
		sc.GraphName = "Bars in Ticks";
		//sc.GraphRegion = 0;
		sc.ValueFormat = VALUEFORMAT_WHOLE_NUMBER;
		sc.AutoLoop = 0;
		sc.GraphDrawType = GDT_OHLCBAR;
		sc.StandardChartHeader = true;
		sc.GraphUsesChartColors = true;

		return;
	}

	n_ACSIL::s_BarPeriod BarPeriod;
	sc.GetBarPeriodParameters(BarPeriod);
	int RenkoTicksPerBar = BarPeriod.IntradayChartBarPeriodParameter1;


	if (sc.IsFullRecalculation && sc.UpdateStartIndex == 0)
	{
		sc.GraphName.Format("%s in Ticks", sc.GetStudyName(0).GetChars());

		for (int SubgraphIndex = 0; SubgraphIndex <= NUM_BASE_GRAPH_ARRAYS; ++SubgraphIndex)
		{
			sc.Subgraph[SubgraphIndex].Name = sc.GetStudySubgraphName(0, SubgraphIndex);
		}

	}

	for(int BarIndex = sc.UpdateStartIndex; BarIndex < sc.ArraySize; BarIndex++)
	{
		for (int SubGraph = 0; SubGraph <= NUM_BASE_GRAPH_ARRAYS; SubGraph++)
		{
			if (SubGraph == SC_VOLUME || SubGraph == SC_NUM_TRADES || SubGraph == SC_BIDVOL || SubGraph == SC_ASKVOL)
				sc.Subgraph[SubGraph][BarIndex] = sc.BaseDataIn[SubGraph][BarIndex];
			else
			{

				if (RenkoTicksPerBar != 0 && SubGraph == SC_OPEN)
					sc.Subgraph[SubGraph][BarIndex] = sc.BaseDataIn[SC_RENKO_OPEN][BarIndex] / sc.TickSize;
				else if (RenkoTicksPerBar != 0 && SubGraph == SC_LAST)
					sc.Subgraph[SubGraph][BarIndex] = sc.BaseDataIn[SC_RENKO_CLOSE][BarIndex] / sc.TickSize;
				else
					sc.Subgraph[SubGraph][BarIndex] = sc.BaseDataIn[SubGraph][BarIndex] / sc.TickSize;
			}
		}
	}
}

/*==========================================================================*/

SCSFExport scsf_StudySubgraphInTicks(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_Result = sc.Subgraph[0];

	SCInputRef Input_InputData = sc.Input[0];

	if (sc.SetDefaults)
	{
		sc.GraphName = "Study Subgraph in Ticks";
		sc.GraphRegion = 1;
		sc.ValueFormat = VALUEFORMAT_WHOLE_NUMBER;
		sc.GraphDrawType = GDT_CUSTOM;

		sc.AutoLoop = 0;

		Subgraph_Result.Name = "Ticks";
		Subgraph_Result.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_Result.PrimaryColor = RGB( 255, 165, 0);

		Input_InputData.Name = "Input Data";
		Input_InputData.SetInputDataIndex(0);

		return;
	}


	int CalculationStartIndex = sc.GetCalculationStartIndexForStudy();

	for (int Index = CalculationStartIndex; Index < sc.ArraySize; Index++)
	{

		Subgraph_Result[Index] = static_cast<float>(sc.Round(sc.BaseData[Input_InputData.GetInputDataIndex()][Index] / sc.TickSize));
	}

	sc.EarliestUpdateSubgraphDataArrayIndex = CalculationStartIndex;


}


/*==========================================================================*/

SCSFExport scsf_StudySubgraphAsCurrencyValue(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_Result = sc.Subgraph[0];

	SCInputRef Input_InputData = sc.Input[0];

	if (sc.SetDefaults)
	{
		sc.GraphName = "Study Subgraph as Currency Value";
		sc.GraphRegion = 1;
		sc.ValueFormat = VALUEFORMAT_2_DIGITS;
		sc.GraphDrawType = GDT_CUSTOM;

		sc.AutoLoop = 0;

		Subgraph_Result.Name = "Currency Value";
		Subgraph_Result.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_Result.PrimaryColor = RGB(255, 165, 0);

		Input_InputData.Name = "Input Data";
		Input_InputData.SetInputDataIndex(0);

		return;
	}


	int CalculationStartIndex = sc.GetCalculationStartIndexForStudy();

	for (int Index = CalculationStartIndex; Index < sc.ArraySize; Index++)
	{

		Subgraph_Result[Index] = static_cast<float>(sc.Round(sc.BaseData[Input_InputData.GetInputDataIndex()][Index] / sc.TickSize)* sc.CurrencyValuePerTick);
	}

	sc.EarliestUpdateSubgraphDataArrayIndex = CalculationStartIndex;


}

/*==========================================================================*/
SCSFExport scsf_ChandeMomentumOscillator(SCStudyInterfaceRef sc)
{
	enum InputIndexes
	{
		INPUT_DATA= 0,
		INPUT_CMO_LENGTH,
		INPUT_LINE_LEVEL2,
		INPUT_LINE_LEVEL1,
		INPUT_LINE_LEVEL3
	};

	SCSubgraphRef Subgraph_CMO = sc.Subgraph[0];
	SCSubgraphRef Subgraph_Line2 = sc.Subgraph[1];
	SCSubgraphRef Subgraph_Line1 = sc.Subgraph[2];
	SCSubgraphRef Subgraph_Line3 = sc.Subgraph[3];

	SCInputRef Input_InputData = sc.Input[0];
	SCInputRef Input_CMOLength = sc.Input[1];
	SCInputRef Input_Line1Level = sc.Input[2];
	SCInputRef Input_Line2Level = sc.Input[3];
	SCInputRef Input_Line3Level = sc.Input[4];

	if(sc.SetDefaults)
	{
		sc.GraphName="Chande Momentum Oscillator";
		sc.StudyDescription="Chande Momentum Oscillator";


		Subgraph_CMO.Name="CMO";
		Subgraph_CMO.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_CMO.PrimaryColor = RGB(0,255,0);
		Subgraph_CMO.DrawZeros = true;

		Subgraph_Line2.Name="Line 2";
		Subgraph_Line2.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_Line2.PrimaryColor = RGB(255,0,0);
		Subgraph_Line2.DrawZeros = true;

		Subgraph_Line1.Name="Line 1";
		Subgraph_Line1.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_Line1.PrimaryColor = RGB(255,0,0);
		Subgraph_Line1.DrawZeros = true;

		Subgraph_Line3.Name="Line 3";
		Subgraph_Line3.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_Line3.PrimaryColor = RGB(255,0,0);
		Subgraph_Line3.DrawZeros = true;

		Input_InputData.Name="Input Data";
		Input_InputData.SetInputDataIndex(SC_LAST);

		Input_CMOLength.Name="CMO Length";
		Input_CMOLength.SetInt(14);

		Input_Line1Level.Name="Line 1 level";
		Input_Line1Level.SetFloat(50.0f);

		Input_Line2Level.Name="Line 2 level";
		Input_Line2Level.SetFloat(0.0f);

		Input_Line3Level.Name="Line 3 level";
		Input_Line3Level.SetFloat(-50.0f);

		sc.AutoLoop = 1;

		return;
	}
	sc.DataStartIndex = Input_CMOLength.GetInt();

	if (sc.Index < Input_CMOLength.GetInt()-1)
		return;

	float sum_up = 0;
	float sum_down = 0;
	for (int j = (sc.Index-Input_CMOLength.GetInt()+1);j<=sc.Index;j++)
	{
		if (sc.BaseData[Input_InputData.GetInputDataIndex()][j]<sc.BaseData[Input_InputData.GetInputDataIndex()][j-1])
		{
			sum_down += sc.BaseData[Input_InputData.GetInputDataIndex()][j-1] - sc.BaseData[Input_InputData.GetInputDataIndex()][j];
		}
		else if (sc.BaseData[Input_InputData.GetInputDataIndex()][j]>sc.BaseData[Input_InputData.GetInputDataIndex()][j-1])
		{
			sum_up += sc.BaseData[Input_InputData.GetInputDataIndex()][j] - sc.BaseData[Input_InputData.GetInputDataIndex()][j-1];
		}
	}
	//CMO(t) = 100 * ((SumUp(t) - SumDown(t)) / (SumUp(t) + SumDown(t)))
	float fCMO;

	if(sum_up+sum_down == 0)
		fCMO = Subgraph_CMO[sc.Index-1];
	else
		fCMO = 100.0f*((sum_up-sum_down)/(sum_up+sum_down));

	Subgraph_CMO[sc.Index] = fCMO;
	Subgraph_Line2[sc.Index] = Input_Line2Level.GetFloat();
	Subgraph_Line1[sc.Index] = Input_Line1Level.GetFloat();
	Subgraph_Line3[sc.Index] = Input_Line3Level.GetFloat();
}

/*==========================================================================*/
SCSFExport scsf_ZeroLagEMA(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_ZeroLagEMA = sc.Subgraph[0];
	SCFloatArrayRef Array_DataLagDifference = sc.Subgraph[0].Arrays[0];

	SCInputRef Input_Period = sc.Input[0];
	SCInputRef Input_InputData = sc.Input[1];

	if(sc.SetDefaults)
	{
		sc.GraphName="Moving Average - Zero Lag Exponential";

		sc.AutoLoop = 1;
		sc.GraphRegion = 0;

		Subgraph_ZeroLagEMA.Name="Zero Lag EMA";
		Subgraph_ZeroLagEMA.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_ZeroLagEMA.PrimaryColor = RGB(0,255,0);
		Subgraph_ZeroLagEMA.DrawZeros = false;

		Input_Period.Name="Zero Lag EMA Length";
		Input_Period.SetInt(10);
		Input_Period.SetIntLimits(1,MAX_STUDY_LENGTH);

		Input_InputData.Name = "Input Data";
		Input_InputData.SetInputDataIndex(SC_LAST);

		return;
	}

	sc.ZeroLagEMA(sc.BaseDataIn[Input_InputData.GetInputDataIndex()], Subgraph_ZeroLagEMA, sc.Index, Input_Period.GetInt());
}
/*==========================================================================*/
SCSFExport scsf_Tenkan_Sen(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_TenkanSen = sc.Subgraph[0];
	SCFloatArrayRef Array_HH = sc.Subgraph[0].Arrays[0];
	SCFloatArrayRef Array_LL = sc.Subgraph[0].Arrays[1];

	SCInputRef Input_Period = sc.Input[0];
	SCInputRef Input_InputDataHigh = sc.Input[1];
	SCInputRef Input_InputDataLow = sc.Input[2];
	SCInputRef Input_Version = sc.Input[3];

	if(sc.SetDefaults)
	{
		sc.GraphName="Tenkan-Sen";

		sc.AutoLoop = 1;
		sc.GraphRegion = 0;

		Subgraph_TenkanSen.Name="Tenkan-Sen";
		Subgraph_TenkanSen.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_TenkanSen.LineWidth = 2;
		Subgraph_TenkanSen.PrimaryColor = RGB(255,128,0);
		Subgraph_TenkanSen.DrawZeros = false;

		Input_Period.Name="Tenkan-Sen Length";
		Input_Period.SetInt(9);
		Input_Period.SetIntLimits(1,MAX_STUDY_LENGTH);

		Input_InputDataHigh.Name = "Input Data High";
		Input_InputDataHigh.SetInputDataIndex(SC_HIGH);

		Input_InputDataLow.Name = "Input Data Low";
		Input_InputDataLow.SetInputDataIndex(SC_LOW);

		Input_Version.SetInt(1);

		return;
	}

	if (Input_Version.GetInt()<1)
	{
		Input_InputDataHigh.SetInputDataIndex(SC_HIGH);
		Input_InputDataLow.SetInputDataIndex(SC_LOW);
		Input_Version.  SetInt(1);
	}

	sc.DataStartIndex = Input_Period.GetInt()-1;

	sc.Highest(sc.BaseData[Input_InputDataHigh.GetInputDataIndex()], Array_HH, Input_Period.GetInt());
	sc.Lowest(sc.BaseData[Input_InputDataLow.GetInputDataIndex()], Array_LL, Input_Period.GetInt());
	Subgraph_TenkanSen[sc.Index] = (Array_HH[sc.Index]+Array_LL[sc.Index])/2.0f;

}
/*==========================================================================*/
SCSFExport scsf_Kijun_Sen(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_KijunSen = sc.Subgraph[0];
	SCFloatArrayRef Array_HH = sc.Subgraph[0].Arrays[0];
	SCFloatArrayRef Array_LL = sc.Subgraph[0].Arrays[1];
	

	SCInputRef Input_Period = sc.Input[0];
	SCInputRef Input_InputDataHigh = sc.Input[1];
	SCInputRef Input_InputDataLow = sc.Input[2];
	SCInputRef Input_Version = sc.Input[3];

	if(sc.SetDefaults)
	{
		sc.GraphName="Kijun-Sen";

		sc.AutoLoop = 1;
		sc.GraphRegion = 0;

		Subgraph_KijunSen.Name="Kijun-Sen";
		Subgraph_KijunSen.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_KijunSen.LineWidth = 2;
		Subgraph_KijunSen.PrimaryColor = RGB(255,0,128);
		Subgraph_KijunSen.DrawZeros = false;

		Input_Period.Name="Kijun-Sen Length";
		Input_Period.SetInt(26);
		Input_Period.SetIntLimits(1,MAX_STUDY_LENGTH);

		Input_InputDataHigh.Name = "Input Data High";
		Input_InputDataHigh.SetInputDataIndex(SC_HIGH);

		Input_InputDataLow.Name = "Input Data Low";
		Input_InputDataLow.SetInputDataIndex(SC_LOW);

		Input_Version.SetInt(1);

		return;
	}

	if (Input_Version.GetInt()<1)
	{
		Input_InputDataHigh.SetInputDataIndex(SC_HIGH);
		Input_InputDataLow.SetInputDataIndex(SC_LOW);

		Input_Version.  SetInt(1);
	}

	sc.DataStartIndex = Input_Period.GetInt()-1;

	sc.Highest(sc.BaseData[Input_InputDataHigh.GetInputDataIndex()],Array_HH, Input_Period.GetInt());
	sc.Lowest(sc.BaseData[Input_InputDataLow.GetInputDataIndex()],Array_LL, Input_Period.GetInt());
	Subgraph_KijunSen[sc.Index] = (Array_HH[sc.Index] + Array_LL[sc.Index])/2.0f;


}
/*==========================================================================*/
SCSFExport scsf_ChikouSpan(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_ChikouSpan = sc.Subgraph[0];

	SCInputRef Input_Period = sc.Input[0];
	SCInputRef Input_InputData = sc.Input[1];

	if(sc.SetDefaults)
	{
		sc.GraphName="Chikou Span";

		sc.AutoLoop = 1;
		sc.GraphRegion = 0;

		Subgraph_ChikouSpan.Name="Chikou Span";
		Subgraph_ChikouSpan.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_ChikouSpan.LineWidth = 2;
		Subgraph_ChikouSpan.PrimaryColor = RGB(20,180,240);
		Subgraph_ChikouSpan.DrawZeros = false;
		Subgraph_ChikouSpan.GraphicalDisplacement = 0;

		Input_Period.Name="Chikou Span Length";
		Input_Period.SetInt(26);
		Input_Period.SetIntLimits(1,MAX_STUDY_LENGTH);

		Input_InputData.Name = "Input Data";
		Input_InputData.SetInputDataIndex(SC_LAST);

		return;
	}

	//ChikouSpan.GraphicalDisplacement = Period.GetInt()*(-1);

	int OutputIndex = sc.Index - Input_Period.GetInt();

	//Chikou Span (Lagging Span): Close plotted 26 days in the past
	Subgraph_ChikouSpan[OutputIndex] = sc.BaseData[Input_InputData.GetInputDataIndex()][sc.Index];

}

/*==========================================================================*/
SCSFExport scsf_SenkouSpanA(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_SpanA = sc.Subgraph[0];
	SCSubgraphRef Subgraph_TenkanHH = sc.Subgraph[1];
	SCSubgraphRef Subgraph_TenkanLL = sc.Subgraph[2];
	SCSubgraphRef Subgraph_KijunHH = sc.Subgraph[3];
	SCSubgraphRef Subgraph_KijunLL = sc.Subgraph[4];
	
	SCInputRef Input_TenkanPeriod = sc.Input[1];
	SCInputRef Input_KijunPeriod = sc.Input[2];

	
	if(sc.SetDefaults)
	{
		sc.GraphName="Senkou Span A";
		sc.AutoLoop = 1;
		sc.GraphRegion = 0;

		Subgraph_SpanA.GraphicalDisplacement = 26;
		Subgraph_SpanA.Name="Span A";
		Subgraph_SpanA.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_SpanA.LineWidth = 4;
		Subgraph_SpanA.PrimaryColor = RGB(0,85,0);
		Subgraph_SpanA.DrawZeros = false;

		Input_TenkanPeriod.Name="Tenkan-Sen Length";
		Input_TenkanPeriod.SetInt(9);
		Input_TenkanPeriod.SetIntLimits(1,MAX_STUDY_LENGTH);

		Input_KijunPeriod.Name="Kijun-Sen Length";
		Input_KijunPeriod.SetInt(26);
		Input_KijunPeriod.SetIntLimits(1,MAX_STUDY_LENGTH);

		return;
	}


	sc.Highest(sc.BaseData[SC_HIGH],Subgraph_TenkanHH, Input_TenkanPeriod.GetInt());
	sc.Lowest(sc.BaseData[SC_LOW],Subgraph_TenkanLL, Input_TenkanPeriod.GetInt());
	sc.Highest(sc.BaseData[SC_HIGH],Subgraph_KijunHH, Input_KijunPeriod.GetInt());
	sc.Lowest(sc.BaseData[SC_LOW],Subgraph_KijunLL, Input_KijunPeriod.GetInt());

	Subgraph_SpanA[sc.Index] = (
		( 
		( (Subgraph_TenkanHH[sc.Index]+Subgraph_TenkanLL[sc.Index])/ 2.0f)+
		( (Subgraph_KijunHH[sc.Index]+Subgraph_KijunLL[sc.Index])/ 2.0f)
		)/2.0f);
}

/*==========================================================================*/
SCSFExport scsf_SenkouSpan(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_SpanA = sc.Subgraph[0];
	SCSubgraphRef Subgraph_SpanB = sc.Subgraph[1];
	SCSubgraphRef Subgraph_SpanBHH = sc.Subgraph[2];
	SCSubgraphRef Subgraph_SpanBLL = sc.Subgraph[3];
	SCSubgraphRef Subgraph_TenkanHH = sc.Subgraph[4];
	SCSubgraphRef Subgraph_TenkanLL = sc.Subgraph[5];
	SCSubgraphRef Subgraph_KijunHH = sc.Subgraph[6];
	SCSubgraphRef Subgraph_KijunLL = sc.Subgraph[7];

	SCInputRef Input_InputDataHigh= sc.Input[0];
	SCInputRef Input_SpanBLength = sc.Input[1];
	SCInputRef Input_TenkanLength = sc.Input[2];
	SCInputRef Input_KijunLength = sc.Input[3];
	SCInputRef Input_InputDataLow = sc.Input[4];
	SCInputRef Input_Version = sc.Input[5];

	if(sc.SetDefaults)
	{
		sc.GraphName = "Senkou Span A & B";
		
		sc.AutoLoop = 1;
		sc.GraphRegion = 0;
		sc.DrawStudyUnderneathMainPriceGraph = 1;

		Subgraph_SpanA.Name = "Span A";
		Subgraph_SpanA.DrawStyle = DRAWSTYLE_FILL_TOP;
		Subgraph_SpanA.PrimaryColor = RGB(133,205,24);
		Subgraph_SpanA.GraphicalDisplacement = 26;
		Subgraph_SpanA.DrawZeros = false;

		Subgraph_SpanB.Name = "Span B";
		Subgraph_SpanB.DrawStyle = DRAWSTYLE_FILL_BOTTOM;
		Subgraph_SpanB.PrimaryColor = RGB(133,205,24);
		Subgraph_SpanB.GraphicalDisplacement = 26;
		Subgraph_SpanB.DrawZeros = false;

		int DisplayOrder = 1;
		Input_InputDataHigh.Name = "Input Data High";
		Input_InputDataHigh.SetInputDataIndex(SC_HIGH);
		Input_InputDataHigh.DisplayOrder = DisplayOrder++;

		Input_InputDataLow.Name = "Input Data Low";
		Input_InputDataLow.SetInputDataIndex(SC_LOW);
		Input_InputDataLow.DisplayOrder = DisplayOrder++;

		Input_SpanBLength.Name="Senkou Span B Length";
		Input_SpanBLength.SetInt(52);
		Input_SpanBLength.SetIntLimits(1,MAX_STUDY_LENGTH);
		Input_SpanBLength.DisplayOrder = DisplayOrder++;

		Input_TenkanLength.Name="Tenkan-Sen Length";
		Input_TenkanLength.SetInt(9);
		Input_TenkanLength.SetIntLimits(1,MAX_STUDY_LENGTH);
		Input_TenkanLength.DisplayOrder = DisplayOrder++;

		Input_KijunLength.Name="Kijun-Sen Length";
		Input_KijunLength.SetInt(26);
		Input_KijunLength.SetIntLimits(1,MAX_STUDY_LENGTH);
		Input_KijunLength.DisplayOrder = DisplayOrder++;

		Input_Version.SetInt(1);

		return;
	}

	if (Input_Version.GetInt() <1)
	{
		Input_InputDataHigh.SetInputDataIndex(SC_HIGH);
		Input_InputDataLow.SetInputDataIndex(SC_LOW);
		Input_Version.SetInt(1);
	}

	// Senkou Span A

	sc.Highest(sc.BaseData[Input_InputDataHigh.GetInputDataIndex()],Subgraph_TenkanHH, Input_TenkanLength.GetInt());
	sc.Lowest(sc.BaseData[Input_InputDataLow.GetInputDataIndex()],Subgraph_TenkanLL, Input_TenkanLength.GetInt());

	sc.Highest(sc.BaseData[Input_InputDataHigh.GetInputDataIndex()],Subgraph_KijunHH, Input_KijunLength.GetInt());
	sc.Lowest(sc.BaseData[Input_InputDataLow.GetInputDataIndex()],Subgraph_KijunLL, Input_KijunLength.GetInt());

	float  Tenkan=(Subgraph_TenkanHH[sc.Index]+Subgraph_TenkanLL[sc.Index]) / 2.0f;
	float Kijun=(Subgraph_KijunHH[sc.Index]+Subgraph_KijunLL[sc.Index]) / 2.0f;
	Subgraph_SpanA[sc.Index] = (Tenkan +Kijun) / 2.0f;



	// Senkou Span B

	sc.Highest(sc.BaseData[Input_InputDataHigh.GetInputDataIndex()],Subgraph_SpanBHH, Input_SpanBLength.GetInt());
	sc.Lowest(sc.BaseData[Input_InputDataLow.GetInputDataIndex()],Subgraph_SpanBLL, Input_SpanBLength.GetInt());

	Subgraph_SpanB[sc.Index] = (Subgraph_SpanBHH[sc.Index]+Subgraph_SpanBLL[sc.Index])/2.0f ;

}

/*==========================================================================*/
SCSFExport scsf_SenkouSpanB(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_SpanB = sc.Subgraph[0];
	SCSubgraphRef Subgraph_HH = sc.Subgraph[1];
	SCSubgraphRef Subgraph_LL = sc.Subgraph[2];

	SCInputRef Input_InputDataHigh = sc.Input[0];
	SCInputRef Input_StudyLength = sc.Input[1];
	SCInputRef Input_InputDataLow = sc.Input[2];
	SCInputRef Input_HiddenFlag = sc.Input[4];

	

	if(sc.SetDefaults)
	{
		sc.GraphName="Senkou Span B";

		sc.AutoLoop = 1;
		sc.GraphRegion = 0;

		Subgraph_SpanB.GraphicalDisplacement = 26;
		Subgraph_SpanB.Name="Span B";
		Subgraph_SpanB.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_SpanB.LineWidth = 4;
		Subgraph_SpanB.PrimaryColor = RGB(133,205,24);
		Subgraph_SpanB.DrawZeros = false;

		Input_StudyLength.Name="Senkou Span B Length";
		Input_StudyLength.SetInt(52);
		Input_StudyLength.SetIntLimits(1,MAX_STUDY_LENGTH);

		Input_InputDataHigh.Name = "Input Data High";
		Input_InputDataHigh.SetInputDataIndex(SC_HIGH);

		Input_InputDataLow.Name = "Input Data Low";
		Input_InputDataLow.SetInputDataIndex(SC_LOW);

		Input_HiddenFlag.SetInt(2);

		return;
	} 
	

	if (Input_HiddenFlag.GetInt() <2)
	{
		Input_InputDataHigh.SetInputDataIndex(SC_HIGH);
		Input_InputDataLow.SetInputDataIndex(SC_LOW);
		Input_HiddenFlag.SetInt(2);
	}

	sc.Highest(sc.BaseData[Input_InputDataHigh.GetInputDataIndex()],Subgraph_HH, Input_StudyLength.GetInt());
	sc.Lowest(sc.BaseData[Input_InputDataLow.GetInputDataIndex()],Subgraph_LL, Input_StudyLength.GetInt());

	Subgraph_SpanB[sc.Index] =  (Subgraph_HH[sc.Index]+Subgraph_LL[sc.Index])/2.0f ;

}
/*==========================================================================*/
// This study function colors bars according to the slope of the Study Subgraph it is based on.

SCSFExport scsf_ColorBarBasedOnSlope(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_ColorBar = sc.Subgraph[0];

	SCInputRef Input_InputData = sc.Input[0];
	SCInputRef Input_ModeInput = sc.Input[1];

	if (sc.SetDefaults)
	{
		// Set the configuration and defaults

		sc.GraphName = "Color Bar Based On Slope";

		sc.StudyDescription = "Colors the main price graph bars based on the slope of a study Subgraph this study is Based On.";

		sc.GraphRegion = 0;
		sc.AutoLoop = 1;

		Subgraph_ColorBar.Name = "Color Bar";
		Subgraph_ColorBar.DrawStyle = DRAWSTYLE_COLOR_BAR;
		Subgraph_ColorBar.SecondaryColorUsed = 1;  // true
		Subgraph_ColorBar.PrimaryColor = RGB(0,255,0);
		Subgraph_ColorBar.SecondaryColor = RGB(255,0,0);
		Subgraph_ColorBar.DrawZeros = true;

		Input_InputData.Name = "Input Data";
		Input_InputData.SetInputDataIndex(0);

		Input_ModeInput.Name = "Use +1 (+slope) and -1 (-slope) for Color Bar Values";
		Input_ModeInput.SetYesNo(0);

		return;
	}
	
	// Do data processing

	if (sc.BaseData[Input_InputData.GetInputDataIndex()][sc.Index] > sc.BaseData[Input_InputData.GetInputDataIndex()][sc.Index-1])
	{
		Subgraph_ColorBar[sc.Index] = 1;
		Subgraph_ColorBar.DataColor[sc.Index] = Subgraph_ColorBar.PrimaryColor;
	}
	else if (sc.BaseData[Input_InputData.GetInputDataIndex()][sc.Index] < sc.BaseData[Input_InputData.GetInputDataIndex()][sc.Index-1])
	{
		if (Input_ModeInput.GetYesNo()== false)
			Subgraph_ColorBar[sc.Index] = 1;
		else
			Subgraph_ColorBar[sc.Index] = -1;

		Subgraph_ColorBar.DataColor[sc.Index] = Subgraph_ColorBar.SecondaryColor;
	}
	else
	{
		Subgraph_ColorBar[sc.Index] = 0;
	}
	
}

/*==========================================================================*/

SCFloatArrayRef MyCCI(SCStudyInterfaceRef sc, SCFloatArrayRef In, SCFloatArrayRef SMAOut, SCFloatArrayRef CCIOut, int Index, int Length, float Multiplier)
{
	if (Length < 1)
		return CCIOut;
	
	if (Index < 2*Length - 1)
		return CCIOut;
	
	sc.SimpleMovAvg(In, SMAOut, Index, Length);
	
	float Num0 = 0;
	for (int j = Index; j > Index - Length && j >= 0; j--)
		Num0 += fabs(SMAOut[Index] - In[j]);
	
	Num0 /= Length;
	
	CCIOut[Index] = (In[Index] - SMAOut[Index]) / (Num0 * Multiplier);
	
	return CCIOut;
}

/*==========================================================================*/
SCSFExport scsf_CCI(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_CCI = sc.Subgraph[0];

	SCInputRef Input_Length = sc.Input[0];

	if(sc.SetDefaults)
	{
		sc.GraphName="Commodity Channel Index";
		sc.StudyDescription="This is an example on how to call a function from your study that is not a member of the 'sc' structure.  It calculates the Commodity Channel Index.";


		sc.AutoLoop = 1;
		sc.GraphRegion = 1;

		Subgraph_CCI.Name="CCI";
		Subgraph_CCI.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_CCI.PrimaryColor = RGB(0,255,0);
		Subgraph_CCI.DrawZeros = true;

		Input_Length.Name="Length";
		Input_Length.SetInt(10);
		Input_Length.SetIntLimits(1,MAX_STUDY_LENGTH);

		return;
	}

	sc.DataStartIndex = Input_Length.GetInt();
	
	//We will call a custom CCI function.

	MyCCI(sc, sc.Close, Subgraph_CCI.Arrays[0], Subgraph_CCI, sc.Index, Input_Length.GetInt(), 0.015f);
}

/*==========================================================================*/
SCSFExport scsf_DMI_ADX_ADXR(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_DmiPlus = sc.Subgraph[0];
	SCSubgraphRef Subgraph_DmiMinus = sc.Subgraph[1];
	SCSubgraphRef Subgraph_ADX = sc.Subgraph[2];
	SCSubgraphRef Subgraph_ADXR = sc.Subgraph[3];

	SCInputRef Input_Length = sc.Input[3];
	SCInputRef Input_MALength = sc.Input[4];
	SCInputRef Input_ADXRInterval = sc.Input[5];

	if (sc.SetDefaults)
	{
		// Set the configuration and defaults

		sc.GraphName = "DMI & ADX & ADXR";

		sc.StudyDescription = "DMI: Welles Wilder's Plus and Minus Directional Indicators +DI and -DI.\n "
								"ADX: Average Directional Movement Index.  This is calculated according to the Welles Wilder formulas.\n"
								"ADXR: Average Directional Movement Index Rating.  This is calculated according to the Welles Wilder formulas.";

		sc.AutoLoop = 1;  // true



		Subgraph_DmiPlus.Name = "DI+";
		Subgraph_DmiPlus.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_DmiPlus.PrimaryColor = RGB(0,255,0);
		Subgraph_DmiPlus.DrawZeros = true;

		Subgraph_DmiMinus.Name = "DI-";
		Subgraph_DmiMinus.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_DmiMinus.PrimaryColor = RGB(255,0,255);
		Subgraph_DmiMinus.DrawZeros = true;

		Subgraph_ADX.Name = "ADX";
		Subgraph_ADX.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_ADX.PrimaryColor = RGB(255,255,0);
		Subgraph_ADX.DrawZeros = true;

		Subgraph_ADXR.Name = "ADXR";
		Subgraph_ADXR.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_ADXR.PrimaryColor = RGB(255,127,0);
		Subgraph_ADXR.DrawZeros = true;

		Input_Length.Name = "Length";
		Input_Length.SetInt(14);
		Input_Length.SetIntLimits(1, INT_MAX);

		Input_MALength.Name = "Mov Avg Length";
		Input_MALength.SetInt(14);
		Input_MALength.SetIntLimits(1, INT_MAX);

		Input_ADXRInterval.Name = "ADXR Interval";
		Input_ADXRInterval.SetInt(14);
		Input_ADXRInterval.SetIntLimits(1, INT_MAX);

		return;
	}

	// Do data processing

	sc.DataStartIndex = max(max(Input_Length.GetInt(), Input_Length.GetInt() + Input_MALength.GetInt() + Input_ADXRInterval.GetInt() - 2), Input_Length.GetInt() + Input_MALength.GetInt() - 1);

	sc.DMI(sc.BaseData, Subgraph_DmiPlus, Subgraph_DmiMinus, sc.Index, Input_Length.GetInt());

	sc.ADX(sc.BaseData, Subgraph_ADX, sc.Index, Input_Length.GetInt(), Input_MALength.GetInt());

	sc.ADXR(sc.BaseData, Subgraph_ADXR, sc.Index, Input_Length.GetInt(), Input_MALength.GetInt(), Input_ADXRInterval.GetInt());
}

/*==========================================================================*/
SCSFExport scsf_ColorBarHHLL(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_ColorBar = sc.Subgraph[0];
	SCSubgraphRef Subgraph_AverageColor = sc.Subgraph[1];

	if (sc.SetDefaults)
	{
		// Set the configuration and defaults
		
		sc.GraphName = "Color Bar HH/LL";
		
		sc.StudyDescription = "This study function colors bars based on if they made a higher high or lower low.";
		
		sc.GraphRegion = 0;
		
		Subgraph_ColorBar.Name = "Color Bar";
		Subgraph_ColorBar.DrawStyle = DRAWSTYLE_COLOR_BAR;
		Subgraph_ColorBar.SecondaryColorUsed = 1;  // true
		Subgraph_ColorBar.PrimaryColor = RGB(0,255,0);
		Subgraph_ColorBar.SecondaryColor = RGB(255,0,0);

		Subgraph_AverageColor.Name = "Average Color";
		Subgraph_AverageColor.DrawStyle = DRAWSTYLE_COLOR_BAR;
		Subgraph_AverageColor.PrimaryColor = RGB(255,128,0);


		sc.AutoLoop = 1;

		return;
	}

	if (Subgraph_AverageColor.PrimaryColor == 0)
		Subgraph_AverageColor.PrimaryColor = RGB(255, 128, 0);
		
	// Do data processing
		
	float HighValue = sc.High[sc.Index];
	float LowValue = sc.Low[sc.Index];
	float PrevHighValue = sc.High[sc.Index-1];
	float PrevLowValue = sc.Low[sc.Index-1];
	
	if (HighValue > PrevHighValue && LowValue < PrevLowValue)
	{
		Subgraph_ColorBar[sc.Index] = 1;

		//COLORREF Pri = ColorBar.PrimaryColor;
		//COLORREF Sec = ColorBar.SecondaryColor;
		Subgraph_ColorBar.DataColor[sc.Index] = Subgraph_AverageColor.PrimaryColor;//sc.RGBInterpolate(Pri, Sec, 0.5f);
	}
	else if (HighValue > PrevHighValue)
	{
		Subgraph_ColorBar[sc.Index] = 1;
		Subgraph_ColorBar.DataColor[sc.Index] = Subgraph_ColorBar.PrimaryColor;
	}
	else if (LowValue < PrevLowValue)
	{
		Subgraph_ColorBar[sc.Index] = 1;
		Subgraph_ColorBar.DataColor[sc.Index] = Subgraph_ColorBar.SecondaryColor;
	}
	else
	{
		Subgraph_ColorBar[sc.Index] = 0;
	}
}

/*==========================================================================*/
SCSFExport scsf_ColorVolumeBasedOnSlope(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_ColorVolume = sc.Subgraph[0];

	SCInputRef Input_InputData = sc.Input[0];

	if (sc.SetDefaults)
	{
		// Set the configuration and defaults
		sc.GraphName = "Color Volume Based On Slope";
		sc.StudyDescription = "Colors Volume bars based on the slope of the study subgraph it is Based On.";

		sc.GraphRegion = 1;
		sc.AutoLoop = 1;

		Subgraph_ColorVolume.Name = "Color Volume";
		Subgraph_ColorVolume.DrawStyle = DRAWSTYLE_BAR;
		Subgraph_ColorVolume.PrimaryColor = RGB(0,255,0);
		Subgraph_ColorVolume.SecondaryColorUsed = 1;  // true
		Subgraph_ColorVolume.SecondaryColor = RGB(0,127,0);

		Input_InputData.Name = "Input Data";
		Input_InputData.SetInputDataIndex(0);

		return;
	}


	// Do data processing

	if (sc.BaseData[Input_InputData.GetInputDataIndex()][sc.Index] > sc.BaseData[Input_InputData.GetInputDataIndex()][sc.Index-1])
	{
		Subgraph_ColorVolume[sc.Index] = sc.Volume[sc.Index]; 
		Subgraph_ColorVolume.DataColor[sc.Index] = Subgraph_ColorVolume.PrimaryColor;
	}
	else if (sc.BaseData[Input_InputData.GetInputDataIndex()][sc.Index] < sc.BaseData[Input_InputData.GetInputDataIndex()][sc.Index-1])
	{
		Subgraph_ColorVolume[sc.Index] = sc.Volume[sc.Index]; 
		Subgraph_ColorVolume.DataColor[sc.Index] = Subgraph_ColorVolume.SecondaryColor;
	}
	else
	{
		Subgraph_ColorVolume[sc.Index] = 0;
	}
}

/*==========================================================================*/
SCSFExport scsf_DetrendedOsc(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_Oscillator = sc.Subgraph[0];
	SCSubgraphRef Subgraph_Line1 = sc.Subgraph[1];
	SCSubgraphRef Subgraph_Line2 = sc.Subgraph[2];

	SCInputRef Input_InputData = sc.Input[0];
	SCInputRef Input_MALength = sc.Input[3];
	SCInputRef Input_Line1Value = sc.Input[4];
	SCInputRef Input_Line2Value = sc.Input[5];

	if (sc.SetDefaults)
	{
		sc.GraphName = "Detrended Oscillator - Di Napoli"; 

		sc.GraphRegion = 1;
		sc.ValueFormat = 3;

		Subgraph_Oscillator.Name = "Oscillator";
		Subgraph_Oscillator.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_Oscillator.PrimaryColor = RGB(0,255,0);
		Subgraph_Oscillator.DrawZeros = true;

		Subgraph_Line1.Name = "Line 1";
		Subgraph_Line1.DrawStyle = DRAWSTYLE_IGNORE;
		Subgraph_Line1.PrimaryColor = RGB(255,0,255);
		Subgraph_Line1.DrawZeros = true;

		Subgraph_Line2.Name = "Line 2";
		Subgraph_Line2.DrawStyle = DRAWSTYLE_IGNORE;
		Subgraph_Line2.PrimaryColor = RGB(255,255,0);
		Subgraph_Line2.DrawZeros = true;

		Input_InputData.Name = "Input Data";
		Input_InputData.SetInputDataIndex(SC_LAST);

		Input_MALength.Name = "Mov Avg Length";
		Input_MALength.SetInt(7);
		Input_MALength.SetIntLimits(1,MAX_STUDY_LENGTH);

		Input_Line1Value.Name = "Line 1 Value";
		Input_Line1Value.SetFloat(10);
	
		Input_Line2Value.Name = "Line 2 Value";
		Input_Line2Value.SetFloat(-10);

		sc.DrawZeros = true;

		sc.AutoLoop = 1;

		return;
	}

	sc.DataStartIndex = Input_MALength.GetInt();

	if (sc.Index < Input_MALength.GetInt())
		return;
	
	sc.SimpleMovAvg(sc.BaseData[Input_InputData.GetInputDataIndex()],Subgraph_Oscillator.Arrays[0], Input_MALength.GetInt());

	Subgraph_Oscillator[sc.Index] = sc.BaseData[Input_InputData.GetInputDataIndex()][sc.Index] - Subgraph_Oscillator.Arrays[0][sc.Index];

	Subgraph_Line1[sc.Index] = Input_Line1Value.GetFloat();
	Subgraph_Line2[sc.Index] = Input_Line2Value.GetFloat();
}

/*==========================================================================*/
SCSFExport scsf_CountDownTimer(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_Countdown = sc.Subgraph[0];

	SCInputRef Input_HorizontalPosition = sc.Input[0];
	SCInputRef Input_VerticalPosition = sc.Input[1];
	SCInputRef Input_DisplayValueOnly = sc.Input[3];
	SCInputRef Input_DisplayContinuousTimeCountdown = sc.Input[4];
	SCInputRef Input_DisplayRangeInTicks = sc.Input[5];
	SCInputRef Input_AlertOnNewBar = sc.Input[6];
	SCInputRef Input_TransparentLabelBackground = sc.Input[7];
	SCInputRef Input_AlertForEveryNewBar = sc.Input[8];
	SCInputRef Input_DisplayRemainingTimeAsSecondsOnly = sc.Input[9];
	SCInputRef Input_UseCurrentPriceForVP = sc.Input[11];
	SCInputRef Input_DrawAboveMainPriceGraph = sc.Input[12];

	if (sc.SetDefaults)
	{
		// Set the configuration and defaults
		
		sc.GraphName = "CountDown Timer";
		
		sc.StudyDescription = "Bar countdown timer";
		
		sc.AutoLoop = 0;//Manual looping

		sc.GraphRegion = 0;
		sc.ValueFormat = 2;
		Subgraph_Countdown.Name = "CountDown";
		Subgraph_Countdown.LineWidth = 20;
		Subgraph_Countdown.DrawStyle = DRAWSTYLE_CUSTOM_TEXT;
		Subgraph_Countdown.PrimaryColor = RGB(0, 0, 0); //black
		Subgraph_Countdown.SecondaryColor = RGB(255, 127, 0); //Orange
		Subgraph_Countdown.SecondaryColorUsed = true;
		Subgraph_Countdown.DisplayNameValueInWindowsFlags = 1;		

		Input_HorizontalPosition.Name.Format("Initial Horizontal Position From Left (1-%d)", static_cast<int>(CHART_DRAWING_MAX_HORIZONTAL_AXIS_RELATIVE_POSITION));
		Input_HorizontalPosition.SetInt(20);
		Input_HorizontalPosition.SetIntLimits(1, static_cast<int>(CHART_DRAWING_MAX_HORIZONTAL_AXIS_RELATIVE_POSITION));

		Input_VerticalPosition.Name.Format("Initial Vertical Position From Bottom (1-%d)", static_cast<int>(CHART_DRAWING_MAX_VERTICAL_AXIS_RELATIVE_POSITION));
		Input_VerticalPosition.SetInt(90);
		Input_VerticalPosition.SetIntLimits(1, static_cast<int>(CHART_DRAWING_MAX_VERTICAL_AXIS_RELATIVE_POSITION));
		
		Input_DisplayValueOnly.Name = "Display Value Only";
		Input_DisplayValueOnly.SetYesNo(false);
		
		Input_DisplayContinuousTimeCountdown.Name = "Display Continuous Time Countdown Based on Real-Time Clock";
		Input_DisplayContinuousTimeCountdown.SetYesNo(false);

		Input_DisplayRangeInTicks.Name = "Display Remaining Range in Ticks";
		Input_DisplayRangeInTicks.SetYesNo(false);

		Input_AlertOnNewBar.Name = "Alert on New Bar";
		Input_AlertOnNewBar.SetYesNo(false);

		Input_AlertForEveryNewBar.Name = "Alert for Every New Bar";
		Input_AlertForEveryNewBar.SetYesNo(false);
		
		Input_TransparentLabelBackground.Name = "Transparent Label Background";
		Input_TransparentLabelBackground.SetYesNo(false);

		Input_DisplayRemainingTimeAsSecondsOnly.Name = "Display Remaining Time as Seconds Only";
		Input_DisplayRemainingTimeAsSecondsOnly.SetYesNo(false);

		Input_UseCurrentPriceForVP.Name = "Use Current Price For Vertical Position";
		Input_UseCurrentPriceForVP.SetYesNo(false);

		Input_DrawAboveMainPriceGraph.Name = "Draw Above Main Price Graph";
		Input_DrawAboveMainPriceGraph.SetYesNo(true);

		return;
	}

	static const int CountDownTimerLineNumber = COUNTDOWN_TIMER_CHART_DRAWINGNUMBER;

	if ((sc.LastCallToFunction || sc.HideStudy)
		&& sc.UserDrawnChartDrawingExists(sc.ChartNumber,CountDownTimerLineNumber) > 0)
	{
		// be sure to delete user drawn type drawing when study removed or the study is hidden
		sc.DeleteUserDrawnACSDrawing(sc.ChartNumber, CountDownTimerLineNumber);
		return;
	}

	if (sc.HideStudy)
		return;

	int& PriorArraySize = sc.GetPersistentInt(1);

	int DrawAboveMainPriceGraph = Input_DrawAboveMainPriceGraph.GetYesNo();
	
	// Disable UpdateAlways.
	sc.UpdateAlways = 0;

	s_UseTool Tool;
	Tool.ChartNumber = sc.ChartNumber;
	Tool.DrawingType = DRAWING_TEXT;
	Tool.Region = sc.GraphRegion;
	Tool.LineNumber = CountDownTimerLineNumber;
	Tool.AddMethod = UTAM_ADD_OR_ADJUST;
	Tool.AddAsUserDrawnDrawing = 1;
	Tool.AllowSaveToChartbook = 1;
	Tool.DrawUnderneathMainGraph = DrawAboveMainPriceGraph ? 0 : 1;

	if (sc.UserDrawnChartDrawingExists(sc.ChartNumber, CountDownTimerLineNumber) == 0)
	{
		Tool.BeginDateTime = Input_HorizontalPosition.GetInt();
		Tool.BeginValue = static_cast<float>(Input_VerticalPosition.GetInt());
		Tool.UseRelativeVerticalValues = true;

	}

	if (Tool.Region == 0 && Input_UseCurrentPriceForVP.GetYesNo() != 0)
	{
		int ValueIndex = sc.ArraySize - 1;

		Tool.BeginValue = sc.Close[ValueIndex];
		Tool.UseRelativeVerticalValues = false;
	}
	else
	{
		Tool.UseRelativeVerticalValues = true;
	}

	Tool.Color = Subgraph_Countdown.PrimaryColor;
	Tool.FontBackColor = Subgraph_Countdown.SecondaryColor;
	if (Input_TransparentLabelBackground.GetYesNo() != 0)
		Tool.TransparentLabelBackground = 1; 

	Tool.ReverseTextColor = false;
	Tool.FontBold = true;
	Tool.FontSize = Subgraph_Countdown.LineWidth;
	Tool.FontFace = sc.GetChartTextFontFaceName();

	float RemainingAmountForSubgraphValue = 0.0;

	n_ACSIL::s_BarPeriod BarPeriod;
	sc.GetBarPeriodParameters(BarPeriod);


	//Continuous time countdown.
	if (Input_DisplayContinuousTimeCountdown.GetYesNo()
		&& BarPeriod.IntradayChartBarPeriodType == IBPT_DAYS_MINS_SECS
		&&  sc.BaseGraphGraphDrawType != GDT_TPO_PROFILE)
	{
		SCDateTime CurrentDateTime = sc.GetCurrentDateTime();

		SCDateTime BarDuration = SCDateTime::SECONDS(sc.SecondsPerBar);

		SCDateTime BarEndingDateTime = sc.BaseDateTimeIn[sc.ArraySize - 1] + SCDateTime::SECONDS(BarPeriod.IntradayChartBarPeriodParameter1);

		SCDateTime RemainingTime = BarEndingDateTime - CurrentDateTime;

		if (RemainingTime < 0.0 && BarDuration != 0.0)
		{
			RemainingTime = 0;
			double ElapsedBars = (CurrentDateTime - sc.BaseDateTimeIn[sc.ArraySize-1]).GetAsDouble() / BarDuration.GetAsDouble();
			double ElapsedPercentageOfCurrentBar = ElapsedBars - static_cast<int>(ElapsedBars);
			RemainingTime = (1.0 - ElapsedPercentageOfCurrentBar)  * BarDuration.GetAsDouble();
		}

		RemainingAmountForSubgraphValue = static_cast<float>(RemainingTime.GetFloatSecondsSinceBaseDate());

		SCString StrRemainingTime;

		int Hour, Minute, Second;
		RemainingTime.GetTimeHMS(Hour, Minute, Second);

		if(Input_DisplayRemainingTimeAsSecondsOnly.GetYesNo())
			StrRemainingTime.Format("%02d", RemainingTime.GetTimeInSeconds());
		else if (Hour && Minute)
			StrRemainingTime.Format("%d:%02d:%02d",Hour, Minute, Second);
		else if (Minute)
			StrRemainingTime.Format("%d:%02d", Minute, Second);
		else
			StrRemainingTime.Format("%02d", Second);

		Tool.Text = StrRemainingTime;
		

		//Enable update always so our real-time countdown is continuously visible.
		sc.UpdateAlways = 1;

	}
	else if(BarPeriod.AreRangeBars() && Input_DisplayRangeInTicks.GetYesNo())
	{
		SCString CountDownText(sc.GetCountDownText());
		const char* CharPosition = strchr(CountDownText.GetChars(),':');
		int RangeInTicks = 0;
		if (CharPosition)
		{
			float RR = static_cast<float>(atof(CharPosition+1));
			RangeInTicks = static_cast<int>(RR/sc.TickSize+0.5f);
			RemainingAmountForSubgraphValue = static_cast<float>(RangeInTicks);
			Tool.Text.Format("%d ",RangeInTicks);
		}
		else
			Tool.Text = "";
		
	}
	else if (Input_DisplayValueOnly.GetYesNo() || (Input_DisplayRemainingTimeAsSecondsOnly.GetYesNo() 
		&& BarPeriod.IntradayChartBarPeriodType == IBPT_DAYS_MINS_SECS))
	{
		int CountdownValue = sc.GetLatestBarCountdownAsInteger();
		RemainingAmountForSubgraphValue = static_cast<float>(CountdownValue);

		Tool.Text.Format("%d",CountdownValue);

	}
	else 
		Tool.Text.Format("%s ",sc.GetCountDownText().GetChars());
	
	
	sc.UseTool(Tool);

	if (!sc.ChartIsDownloadingHistoricalData(sc.ChartNumber)
		&&  PriorArraySize < sc.ArraySize 
		&& sc.UpdateStartIndex != 0 
		&& Input_AlertOnNewBar.GetYesNo())
	{
		int StartIndex;

		if (Input_AlertForEveryNewBar.GetYesNo())
			StartIndex = sc.UpdateStartIndex;
		else
			StartIndex = sc.ArraySize-2;

		for(int BarIndex = StartIndex; BarIndex < sc.ArraySize - 1; BarIndex++)
			sc.PlaySound( sc.SelectedAlertSound, "Bar has completed", 0);
	}



	PriorArraySize = sc.ArraySize;

	// Zero out prior elements and set the remaining time into the last subgraph element.
	for(int Index = sc.UpdateStartIndex; Index < sc.ArraySize; Index++)
	{
		Subgraph_Countdown[Index] = 0;
	}

	Subgraph_Countdown[sc.ArraySize - 1] = RemainingAmountForSubgraphValue;
}

/*==========================================================================*/
SCSFExport scsf_ClockRealTime(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_Clock = sc.Subgraph[0];

	SCInputRef Input_HorizontalPosition = sc.Input[0];
	SCInputRef Input_VerticalPosition = sc.Input[1];
	SCInputRef Input_UseAMPM = sc.Input[3];
	SCInputRef Input_DrawAboveMainPriceGraph = sc.Input[4];
	SCInputRef Input_UseBoldFont = sc.Input[5];
	SCInputRef Input_TransparentLabelBackground = sc.Input[7];
	SCInputRef Input_HourOffset = sc.Input[8];

	if (sc.SetDefaults)
	{
		// Set the configuration and defaults

		sc.GraphName = "Clock - RealTime";

		sc.AutoLoop = 0;//Manual looping
		sc.GraphRegion = 0;
		sc.ValueFormat = 0;
		sc.UpdateAlways = 1;

		Subgraph_Clock.Name = "Clock";
		Subgraph_Clock.LineWidth = 20;
		Subgraph_Clock.DrawStyle = DRAWSTYLE_CUSTOM_TEXT;
		Subgraph_Clock.PrimaryColor = RGB(0, 0, 0); //black
		Subgraph_Clock.SecondaryColor = RGB(255, 127, 0); //Orange
		Subgraph_Clock.SecondaryColorUsed = true;
		Subgraph_Clock.DisplayNameValueInWindowsFlags = 1;

		Input_HorizontalPosition.Name.Format("Initial Horizontal Position From Left (1-%d)", static_cast<int>(CHART_DRAWING_MAX_HORIZONTAL_AXIS_RELATIVE_POSITION));
		Input_HorizontalPosition.SetInt(20);
		Input_HorizontalPosition.SetIntLimits(1, static_cast<int>(CHART_DRAWING_MAX_HORIZONTAL_AXIS_RELATIVE_POSITION));

		Input_VerticalPosition.Name.Format("Initial Vertical Position From Bottom (1-%d)", static_cast<int>(CHART_DRAWING_MAX_VERTICAL_AXIS_RELATIVE_POSITION));
		Input_VerticalPosition.SetInt(90);
		Input_VerticalPosition.SetIntLimits(1, static_cast<int>(CHART_DRAWING_MAX_VERTICAL_AXIS_RELATIVE_POSITION));
		
		Input_UseAMPM.Name = "Use A.M. and P.M.";
		Input_UseAMPM.SetYesNo(false);

		Input_DrawAboveMainPriceGraph.Name = "Draw Above Main Price Graph";
		Input_DrawAboveMainPriceGraph.SetYesNo(false);

		Input_UseBoldFont.Name = "Use Bold Font";
		Input_UseBoldFont.SetYesNo(true);

		Input_TransparentLabelBackground.Name = "Transparent Label Background";
		Input_TransparentLabelBackground.SetYesNo(false);

		Input_HourOffset.Name = "Hour Offset";
		Input_HourOffset.SetInt(0);
		
		return;
	}


	int Hour = 0, Minute = 0, Second = 0;
	if (sc.IsReplayRunning())
		SCDateTimeMS(sc.GetEndingDateTimeForBarIndex(sc.ArraySize - 1)).GetTimeHMS(Hour, Minute, Second);
	else
		sc.CurrentSystemDateTimeMS.GetTimeHMS(Hour, Minute, Second);

	if (Input_HourOffset.GetInt() != 0)
	{
		Hour += Input_HourOffset.GetInt();
		if (Hour > 24)
			Hour -= 24;
		else if (Hour < 0)
			Hour += 24;
	}

	SCString RemainingTimeString;
	if(Input_UseAMPM.GetYesNo())
	{
		int AdjustedHour = Hour;
		if (Hour >= 13)
			AdjustedHour -= 12;

		RemainingTimeString.Format("%d:%02d:%02d ", AdjustedHour, Minute, Second);
		if (Hour < 12)
			RemainingTimeString += "am";
		else
			RemainingTimeString += "pm";
	}
	else
		RemainingTimeString.Format("%d:%02d:%02d", Hour, Minute, Second);
	
	int HorizontalPosition = Input_HorizontalPosition.GetInt();
	int VerticalPosition = Input_VerticalPosition.GetInt();

	int DrawAboveMainPriceGraph = Input_DrawAboveMainPriceGraph.GetYesNo();

	int TransparentLabelBackground = Input_TransparentLabelBackground.GetYesNo();
	int UseBoldFont = Input_UseBoldFont.GetYesNo();

	sc.AddAndManageSingleTextUserDrawnDrawingForStudy(sc, 0, HorizontalPosition, VerticalPosition, Subgraph_Clock, TransparentLabelBackground, RemainingTimeString, DrawAboveMainPriceGraph, 0, UseBoldFont);
}

/*==========================================================================*/
SCSFExport scsf_AccountBalanceExternalService(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_AccountBalance = sc.Subgraph[0];

	SCInputRef Input_HorizontalPosition = sc.Input[0];
	SCInputRef Input_VerticalPosition = sc.Input[1];
	SCInputRef Input_TransparentLabelBackground = sc.Input[4];

	if (sc.SetDefaults)
	{
		// Set the configuration and defaults

		sc.GraphName = "Account Balance Text - External Service";

		sc.AutoLoop = 0;
		sc.GraphRegion = 0;

		Subgraph_AccountBalance.Name = "Cash Balance";
		Subgraph_AccountBalance.LineWidth = 20;
		Subgraph_AccountBalance.DrawStyle = DRAWSTYLE_CUSTOM_TEXT;
		Subgraph_AccountBalance.PrimaryColor = RGB(0, 0, 0); //black
		Subgraph_AccountBalance.SecondaryColor = RGB(255, 127, 0); //Orange
		Subgraph_AccountBalance.SecondaryColorUsed = true;
		Subgraph_AccountBalance.DisplayNameValueInWindowsFlags = 0;

		Input_HorizontalPosition.Name.Format("Initial Horizontal Position From Left (1-%d)", static_cast<int>(CHART_DRAWING_MAX_HORIZONTAL_AXIS_RELATIVE_POSITION));
		Input_HorizontalPosition.SetInt(20);
		Input_HorizontalPosition.SetIntLimits(1, static_cast<int>(CHART_DRAWING_MAX_HORIZONTAL_AXIS_RELATIVE_POSITION));

		Input_VerticalPosition.Name.Format("Initial Vertical Position From Bottom (1-%d)", static_cast<int>(CHART_DRAWING_MAX_VERTICAL_AXIS_RELATIVE_POSITION));
		Input_VerticalPosition.SetInt(90);
		Input_VerticalPosition.SetIntLimits(1, static_cast<int>(CHART_DRAWING_MAX_VERTICAL_AXIS_RELATIVE_POSITION));
		
		Input_TransparentLabelBackground.Name = "Transparent Label Background";
		Input_TransparentLabelBackground.SetYesNo(false);

		return;
	}


	int & IndexOfLastUsedSubgraphElementBalanceData = sc.GetPersistentInt(2);

	Subgraph_AccountBalance[ IndexOfLastUsedSubgraphElementBalanceData ] = 0;

	double AccountValue = 0;
	n_ACSIL::s_TradeAccountDataFields TradeAccountDataFields;
	if (sc.GetTradeAccountData(TradeAccountDataFields, sc.SelectedTradeAccount))
	{
		AccountValue = TradeAccountDataFields.m_CurrentCashBalance;
	}
	
	SCString ValueText;
	ValueText.Format("%.2f", AccountValue);

	Subgraph_AccountBalance[sc.ArraySize - 1] = static_cast<float>(AccountValue);

	IndexOfLastUsedSubgraphElementBalanceData = sc.ArraySize - 1;

	int TransparentLabelBackground = Input_TransparentLabelBackground.GetYesNo();

	sc.AddAndManageSingleTextUserDrawnDrawingForStudy(sc, false, Input_HorizontalPosition.GetInt(), Input_VerticalPosition.GetInt(), Subgraph_AccountBalance, TransparentLabelBackground, ValueText, true, 0);

}


/*==========================================================================*/
SCSFExport scsf_AccountBalanceGraph(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_Balance = sc.Subgraph[0];

	if (sc.SetDefaults)
	{
		// Set the configuration and defaults

		sc.GraphName = "Account Balance Graph - External Service";

		sc.StudyDescription = "";

		sc.AutoLoop = 1;
		sc.GraphRegion = 1;

		Subgraph_Balance.Name = "Balance";
		Subgraph_Balance.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_Balance.DrawZeros = false;  // false
		Subgraph_Balance.PrimaryColor = RGB(0, 255, 0);  // Green

		return;
	}


	// Do data processing
	double AccountValue = 0;
	n_ACSIL::s_TradeAccountDataFields TradeAccountDataFields;
	if (sc.GetTradeAccountData(TradeAccountDataFields, sc.SelectedTradeAccount))
	{
		AccountValue = TradeAccountDataFields.m_CurrentCashBalance;
	}

	Subgraph_Balance[sc.Index] = static_cast<float>(AccountValue);
}


/*==========================================================================*/
SCSFExport scsf_WildersMovingAverage(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_MovAvg = sc.Subgraph[0];

	SCInputRef Input_InputData = sc.Input[0];
	SCInputRef Input_Length = sc.Input[1];

	// Set configuration variables	
	if (sc.SetDefaults)
	{
		// Set the configuration and defaults

		sc.GraphName = "Moving Average - Welles Wilders";

		sc.StudyDescription = "";

		// Set the region to draw the graph in.  Region zero is the main
		// price graph region.
		sc.GraphRegion = 0;

		

		// Set the name of the first subgraph
		Subgraph_MovAvg.Name = "MovAvg";

		// Set the color and style of the graph line.  If these are not set
		// the default will be used.
		Subgraph_MovAvg.PrimaryColor = RGB(255,0,0);  // Red
		Subgraph_MovAvg.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_MovAvg.DrawZeros = false;


		Input_InputData.Name = "Input Data";
		Input_InputData.SetInputDataIndex(SC_LAST); // default data field		

		// Make the Length input and default it to 5
		Input_Length.Name = "Length";
		Input_Length.SetInt(10);
		Input_Length.SetIntLimits(1,MAX_STUDY_LENGTH);

		sc.AutoLoop = 1;

		return;
	}

	// Do data processing		
	
	sc.WildersMovingAverage(sc.BaseDataIn[Input_InputData.GetInputDataIndex()], Subgraph_MovAvg, sc.Index, Input_Length.GetInt());
}



/*==========================================================================*/
SCSFExport scsf_BarNumbering(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_Number = sc.Subgraph[0];
	
	SCInputRef Input_DisplayAtBottom = sc.Input[0];
	SCInputRef Input_TextOffset = sc.Input[1];
	SCInputRef Input_NumberingEveryNBars = sc.Input[2];
	SCInputRef Input_DoNotResetDaily = sc.Input[4];

	// Set configuration variables	
	if (sc.SetDefaults)
	{
		// Set the configuration and defaults

		sc.GraphName = "Bar Numbering";

		sc.GraphRegion = 0;
		sc.ValueFormat = 0;

		// Set the name of the first subgraph
		Subgraph_Number.Name = "Number";
		Subgraph_Number.DrawStyle = DRAWSTYLE_CUSTOM_VALUE_AT_Y;
		Subgraph_Number.PrimaryColor = RGB(0,255,0);
		Subgraph_Number.LineWidth = 8;
		Subgraph_Number.DrawZeros = false;

		Input_DisplayAtBottom.Name = "Display At Bottom";
		Input_DisplayAtBottom.SetYesNo(false);

		Input_TextOffset.Name = "Text Labels Tick Offset";
		Input_TextOffset.SetInt(2); 
		Input_TextOffset.SetIntLimits(0, 10000);

		Input_NumberingEveryNBars.Name = "Number Every N Bars";
		Input_NumberingEveryNBars.SetInt(2);
		Input_NumberingEveryNBars.SetIntLimits(1, MAX_STUDY_LENGTH);

		Input_DoNotResetDaily.Name = "Do Not Reset at Start of New Day";
		Input_DoNotResetDaily.SetYesNo(false);

		sc.AutoLoop = 1;

		return;
	}

	if (!Input_DisplayAtBottom.GetYesNo())
	{
		sc.ScaleRangeType = SCALE_AUTO;
	}
	else
	{
		sc.ScaleRangeType = SCALE_USERDEFINED;
		sc.ScaleRangeTop = 100;
		sc.ScaleRangeBottom = 1;
	}

	sc.ValueFormat = 0;
	Subgraph_Number.DrawStyle = DRAWSTYLE_CUSTOM_VALUE_AT_Y;

	int& r_BarCounter = sc.GetPersistentInt(1);
	int& r_LastProcessedBarIndex = sc.GetPersistentInt(2);
	
	if (sc.Index == 0)
	{
		r_BarCounter = 1;
		r_LastProcessedBarIndex = -1;
	}
	else if(sc.Index != r_LastProcessedBarIndex)
	{
		
		SCDateTimeMS StartDateTimeOfDay;

		StartDateTimeOfDay.SetTime(sc.StartTimeOfDay);

		StartDateTimeOfDay.SetDate(sc.BaseDateTimeIn[sc.Index].GetDate());

		//reset counter if a new session has begun.
		if (!Input_DoNotResetDaily.GetYesNo() &&
			(sc.BaseDateTimeIn[sc.Index] == StartDateTimeOfDay ||
			(sc.BaseDateTimeIn[sc.Index-1] < StartDateTimeOfDay && sc.BaseDateTimeIn[sc.Index] > StartDateTimeOfDay) )
			)
			r_BarCounter = 1;
		else
			r_BarCounter++; //increment counter 
	}

	r_LastProcessedBarIndex = sc.Index;

	if(r_BarCounter != 1 && r_BarCounter % Input_NumberingEveryNBars.GetInt())
		return;

	Subgraph_Number[sc.Index] = static_cast<float>(r_BarCounter);
	
	float Offset = sc.TickSize * Input_TextOffset.GetInt();

	float VerticalPositionValue = 0;

	if (Input_DisplayAtBottom.GetYesNo())
		VerticalPositionValue = 5;
	else
		VerticalPositionValue = sc.Low[sc.Index] - Offset;

	Subgraph_Number.Arrays[0][sc.Index] = VerticalPositionValue;

}


/*==========================================================================*/

SCSFExport scsf_StudySubgraphsReference(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_PriceOverlay1 = sc.Subgraph[0];
	SCSubgraphRef Subgraph_PriceOverlay2 = sc.Subgraph[1];


	SCInputRef Input_StudySubgraph1 = sc.Input[0];
	SCInputRef Input_StudySubgraph2 = sc.Input[1];
	SCInputRef Input_DrawZeros = sc.Input[2];


	// Set configuration variables

	if (sc.SetDefaults)
	{
		sc.GraphName = "Study Subgraphs Reference";
		sc.GraphRegion = 1;

		sc.ScaleRangeType = SCALE_INDEPENDENT;

		Subgraph_PriceOverlay1.Name = "Study Subgraph 1";
		Subgraph_PriceOverlay1.DrawStyle = DRAWSTYLE_FILL_TOP;
		Subgraph_PriceOverlay1.PrimaryColor = RGB(0,255,0);

		Subgraph_PriceOverlay2.Name = "Study Subgraph 2";
		Subgraph_PriceOverlay2.DrawStyle = DRAWSTYLE_FILL_BOTTOM;
		Subgraph_PriceOverlay2.PrimaryColor = RGB(255,0,255);

		Input_StudySubgraph1.Name = "Input Study 1";
		Input_StudySubgraph1.SetStudySubgraphValues(0, 0);

		Input_StudySubgraph2.Name = "Input Study 2";
		Input_StudySubgraph2.SetStudySubgraphValues(0, 0);

		Input_DrawZeros.Name = "Draw Zeros";
		Input_DrawZeros.SetYesNo(true);

		sc.CalculationPrecedence = VERY_LOW_PREC_LEVEL;
		sc.DrawStudyUnderneathMainPriceGraph = true;

		sc.AutoLoop = 0;

		return;
	}


	// Do data processing

	//Set Draw Zeros as defined by user input
	Subgraph_PriceOverlay1.DrawZeros = Input_DrawZeros.GetYesNo();
	Subgraph_PriceOverlay2.DrawZeros = Input_DrawZeros.GetYesNo();

	//This will return sc.UpdateStartIndex or an earlier index if this study is calculated after a study which calculated at an earlier index and supports setting that earlier index.
	int ActualStartIndex = sc.GetCalculationStartIndexForStudy();

	// Get the array for the specified Input Data from the specified studies
	SCFloatArray Study1Array;
	sc.GetStudyArrayUsingID(Input_StudySubgraph1.GetStudyID(), Input_StudySubgraph1.GetSubgraphIndex(),Study1Array);

	SCFloatArray Study2Array;
	sc.GetStudyArrayUsingID(Input_StudySubgraph2.GetStudyID(), Input_StudySubgraph2.GetSubgraphIndex(),Study2Array);

	for(int BarIndex = ActualStartIndex; BarIndex < sc.ArraySize;  BarIndex++)
	{
		Subgraph_PriceOverlay1[BarIndex] = Study1Array[BarIndex];
		Subgraph_PriceOverlay2[BarIndex] = Study2Array[BarIndex];
	}

	sc.EarliestUpdateSubgraphDataArrayIndex = ActualStartIndex;
}

/*==========================================================================*/
SCSFExport scsf_StudySubgraphReference(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_StudySubgraphReference = sc.Subgraph[0];

	SCInputRef Input_StudySubgraphReference = sc.Input[0];
	SCInputRef Input_DrawZeros = sc.Input[1];

	// Set configuration variables

	if (sc.SetDefaults)
	{
		sc.GraphName = "Study Subgraph Reference";
		sc.GraphRegion = 2;

		sc.ScaleRangeType = SCALE_AUTO;

		Subgraph_StudySubgraphReference.Name = "Study Subgraph";
		Subgraph_StudySubgraphReference.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_StudySubgraphReference.PrimaryColor = RGB(0, 255, 0);

		Input_StudySubgraphReference.Name = "Study Subgraph to Reference";
		Input_StudySubgraphReference.SetStudySubgraphValues(0, 0);

		Input_DrawZeros.Name = "Draw Zeros";
		Input_DrawZeros.SetYesNo(true);
		
		sc.CalculationPrecedence = VERY_LOW_PREC_LEVEL;

		sc.AutoLoop = 0;

		return;
	}


	// Do data processing
	Subgraph_StudySubgraphReference.DrawZeros = Input_DrawZeros.GetYesNo();

	//This will return sc.UpdateStartIndex or an earlier index if this study is calculated after a study which calculated at an earlier index and supports setting that earlier index.
	int ActualStartIndex = sc.GetCalculationStartIndexForStudy();

	// Get the array for the specified Input Data from the specified studies
	SCFloatArray Study1Array;
	sc.GetStudyArrayUsingID(Input_StudySubgraphReference.GetStudyID(), Input_StudySubgraphReference.GetSubgraphIndex(), Study1Array);

	for (int BarIndex = ActualStartIndex; BarIndex < sc.ArraySize; BarIndex++)
	{
		Subgraph_StudySubgraphReference[BarIndex] = Study1Array[BarIndex];
	}

	sc.EarliestUpdateSubgraphDataArrayIndex = ActualStartIndex;
}

/*==========================================================================*/
SCSFExport scsf_VolumeCloseToMidpointColoring(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_Volume = sc.Subgraph[0];

	if (sc.SetDefaults)
	{
		sc.GraphName = "Volume - Close To Midpoint Colored";

		sc.ValueFormat = 0;

		sc.AutoLoop = true;
		sc.ScaleRangeType = SCALE_ZEROBASED;

		Subgraph_Volume.Name = "Volume";
		Subgraph_Volume.DrawStyle = DRAWSTYLE_BAR;
		Subgraph_Volume.PrimaryColor = RGB(0, 255, 0);
		Subgraph_Volume.SecondaryColor = RGB(255, 0, 0);
		Subgraph_Volume.SecondaryColorUsed = 1;
		Subgraph_Volume.LineWidth = 2;
		Subgraph_Volume.DrawZeros = false;


		sc.DisplayStudyInputValues = false;

		return;
	}

	Subgraph_Volume[sc.Index] = sc.Volume[sc.Index];

	if(sc.Close[sc.Index] >=  sc.HLAvg[sc.Index])
		Subgraph_Volume.DataColor[sc.Index] = Subgraph_Volume.PrimaryColor;
	else
		Subgraph_Volume.DataColor[sc.Index] = Subgraph_Volume.SecondaryColor;
}

/*==========================================================================*/
SCSFExport scsf_CumulativeAdjustedValue(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_CumulativeValue = sc.Subgraph[0];
	SCFloatArray  Array_AverageValue    = Subgraph_CumulativeValue.Arrays[0];
	SCFloatArray  Array_AdjustedValue   = Subgraph_CumulativeValue.Arrays[1];

	SCInputRef Input_InputData       = sc.Input[0];
	SCInputRef Input_SmoothingLength = sc.Input[1];

	if (sc.SetDefaults)
	{
		// Set the configuration and defaults
		sc.GraphName = "Cumulative Adjusted Value";
		sc.StudyDescription = "Input data is smoothed to attain a bias, then adjusted to remove the bias, and then accumulated.";

		sc.GraphRegion = 2;
		sc.AutoLoop = 1;

		Subgraph_CumulativeValue.Name = "Cumulative Value";
		Subgraph_CumulativeValue.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_CumulativeValue.PrimaryColor = RGB(0, 255, 0);
		Subgraph_CumulativeValue.DrawZeros = true;

		Input_InputData.Name = "Input Data";
		Input_InputData.SetInputDataIndex(SC_OHLC_AVG);

		Input_SmoothingLength.Name = "Long Term Smoothing Length";
		Input_SmoothingLength.SetInt(10000);
		Input_SmoothingLength.SetIntLimits(1, MAX_STUDY_LENGTH);

		return;
	}


	// Do data processing
	sc.ExponentialMovAvg(sc.BaseData[Input_InputData.GetInputDataIndex()], Array_AverageValue, Input_SmoothingLength.GetInt());

	Array_AdjustedValue[sc.Index] = sc.BaseData[Input_InputData.GetInputDataIndex()][sc.Index] - Array_AverageValue[sc.Index];

	if (sc.Index == 0)
		Subgraph_CumulativeValue[sc.Index] = Array_AdjustedValue[sc.Index];
	else
		Subgraph_CumulativeValue[sc.Index] = Subgraph_CumulativeValue[sc.Index-1] + Array_AdjustedValue[sc.Index];
}

/*==========================================================================*/
SCSFExport scsf_TradersDynamicIndex(SCStudyInterfaceRef sc)
{
	if (sc.SetDefaults)
	{
		sc.GraphName = "Traders Dynamic Index";
		sc.StudyDescription = "<p><strong>Traders Dynamic Index</strong></p><p>with thanks to Dean Malone <a href=http://www.compassfx.com>CompassFX</a></p><p><a href=http://www.earnforex.com/metatrader-indicators/Traders-Dynamic-Index>Earnforex description</a></p>";

		sc.AutoLoop = 1;

		sc.Subgraph[0].Name = "RSI";
		sc.Subgraph[0].DrawStyle = DRAWSTYLE_IGNORE;
		sc.Subgraph[1].Name = "UpVol";
		sc.Subgraph[1].DrawStyle = DRAWSTYLE_LINE;
		sc.Subgraph[2].Name = "Mid";
		sc.Subgraph[2].DrawStyle = DRAWSTYLE_LINE;
		sc.Subgraph[3].Name = "DnVol";
		sc.Subgraph[3].DrawStyle = DRAWSTYLE_LINE;
		sc.Subgraph[4].Name = "Ma";
		sc.Subgraph[4].DrawStyle = DRAWSTYLE_LINE;
		sc.Subgraph[5].Name = "Mb";
		sc.Subgraph[5].DrawStyle = DRAWSTYLE_LINE;

		sc.Input[3].Name = "RSI Length";
		sc.Input[3].SetInt(13);
		sc.Input[3].SetDescription("<strong>RSI_Period</strong> (default = 13) &#151; period in bars for calculation of RSI.");

		sc.Input[4].Name = "RSI Price";
		sc.Input[4].SetInputDataIndex(SC_LAST);
		sc.Input[4].SetDescription("<strong>RSI_Price</strong> (default = MODE_CLOSE) &#151; price type to use in RSI calculation");

		sc.Input[5].Name = "Volatility Band Length";
		sc.Input[5].SetInt(34);
		sc.Input[5].SetDescription("<strong>Volatility_Band</strong> (default = 34) &#151; parameter for  volatility band calculation. Can be between 20 and 40. The lower this value is the curvier becomes the band.");

		sc.Input[6].Name = "RSI Price Line";
		sc.Input[6].SetInt(2);
		sc.Input[6].SetDescription("<strong>RSI_Price_Line</strong> (default = 2) &#151; period of the first moving average (fast).");

		sc.Input[7].Name = "RSI Price Type";
		sc.Input[7].SetMovAvgType(MOVAVGTYPE_SIMPLE);

		sc.Input[8].Name = "RSI Trade Signal Line";
		sc.Input[8].SetInt(7);
		sc.Input[8].SetDescription("<strong>Trade_Signal_Line</strong> (default = 7) &#151; period of the second moving average (slow)");

		sc.Input[9].Name = "Trade Signal Type";
		sc.Input[9].SetMovAvgType(MOVAVGTYPE_SIMPLE);

		sc.DocumentationImageURL = "http://codebase.mql4.com/c/codebase/2008/03/indicatori_gtradersmdynamicmindexuvisualqalerts.gif";

		return;
	}


		sc.RSI(sc.BaseDataIn[sc.Input[4].GetInputDataIndex()], sc.Subgraph[0], MOVAVGTYPE_SIMPLE, sc.Input[3].GetInt());
		
		sc.MovingAverage(sc.Subgraph[0], sc.Subgraph[4], sc.Input[7].GetMovAvgType(), sc.Input[6].GetInt());
		
		sc.MovingAverage(sc.Subgraph[0], sc.Subgraph[5], sc.Input[9].GetMovAvgType(), sc.Input[8].GetInt());
		
		sc.BollingerBands(sc.Subgraph[0], sc.Subgraph[2], sc.Input[5].GetInt(), 1.6185f, MOVAVGTYPE_SIMPLE);
		sc.Subgraph[1][sc.Index] = sc.Subgraph[2].Arrays[0][sc.Index];
		sc.Subgraph[3][sc.Index] = sc.Subgraph[2].Arrays[1][sc.Index];

}

/*============================================================================

----------------------------------------------------------------------------*/
SCSFExport scsf_PointFigureChartReversalMarker(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_Marker = sc.Subgraph[0];

	if (sc.SetDefaults)
	{
		// Set the configuration and defaults

		sc.GraphName = "Point and Figure Chart Reversal Marker";
		sc.GraphRegion = 0;
		sc.AutoLoop = 0;
		sc.ValueFormat = sc.BaseGraphValueFormat;

		Subgraph_Marker.Name = "Reversal Mark";
		Subgraph_Marker.DrawStyle = DRAWSTYLE_DASH;
		Subgraph_Marker.LineWidth = 4;
		Subgraph_Marker.PrimaryColor = RGB(255, 0, 128);
		Subgraph_Marker.DrawZeros = false;

		return;
	}

	n_ACSIL::s_BarPeriod BarPeriodData;
	sc.GetBarPeriodParameters(BarPeriodData);

	if (BarPeriodData.ChartDataType != INTRADAY_DATA
		|| BarPeriodData.IntradayChartBarPeriodType != IBPT_POINT_AND_FIGURE)
		return;

	float ReversalAmountNeeded = BarPeriodData.IntradayChartBarPeriodParameter1 * sc.TickSize * BarPeriodData.IntradayChartBarPeriodParameter2;

	for (int BarIndex = sc.UpdateStartIndex; BarIndex < sc.ArraySize; BarIndex++)
	{
		Subgraph_Marker[BarIndex] = 0;
		if (BarIndex == sc.ArraySize - 1)
		{
			if (sc.BaseData[PF_DIRECTION_ARRAY][BarIndex] == 1)//Up bar
			{
				Subgraph_Marker[BarIndex] =  sc.BaseData[SC_POINT_FIGURE_HIGH][BarIndex] - ReversalAmountNeeded;
			}
			else
			{
				Subgraph_Marker[BarIndex] = sc.BaseData[SC_POINT_FIGURE_LOW][BarIndex] + ReversalAmountNeeded;
			}
		}
	}


}
/*============================================================================

----------------------------------------------------------------------------*/
SCSFExport scsf_PointFigureBoxCount(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_BoxCount = sc.Subgraph[0];

	if (sc.SetDefaults)
	{
		// Set the configuration and defaults

		sc.GraphName = "Point and Figure Box Count";
		sc.GraphRegion = 1;
		sc.AutoLoop = 0;
		sc.ValueFormat = 0;

		Subgraph_BoxCount.Name = "P&F Box Count";
		Subgraph_BoxCount.DrawStyle = DRAWSTYLE_BAR;
		Subgraph_BoxCount.LineWidth = 2;
		Subgraph_BoxCount.PrimaryColor = RGB(255, 0, 128);
		Subgraph_BoxCount.DrawZeros = false;

		return;
	}


	n_ACSIL::s_BarPeriod BarPeriod;
	sc.GetBarPeriodParameters(BarPeriod);

	if (BarPeriod.IntradayChartBarPeriodType != IBPT_POINT_AND_FIGURE)
		return;


	for (int BarIndex = sc.UpdateStartIndex; BarIndex < sc.ArraySize; BarIndex++)
	{
		Subgraph_BoxCount[BarIndex] = sc.BaseData[PF_NUM_BOXES_ARRAY][BarIndex];
	}


}

/*============================================================================

----------------------------------------------------------------------------*/
SCSFExport scsf_ReadFromUnderlyingIntradayFileExample(SCStudyInterfaceRef sc)
{
	if (sc.SetDefaults)
	{
		// Set the configuration and defaults

		sc.GraphName = "Read from Underlying Intraday File Example";


		sc.AutoLoop = 0;

		return;
	}

	if (sc.LastCallToFunction)
		return;

	s_IntradayRecord IntradayRecord;

	for (int FileIndex = sc.FileRecordIndexOfLastDataRecordInChart; FileIndex >= sc.FileRecordIndexOfLastDataRecordInChart - 10; FileIndex--)
	{
		bool FirstIteration = FileIndex == sc.FileRecordIndexOfLastDataRecordInChart;
		bool LastIteration = FileIndex <= sc.FileRecordIndexOfLastDataRecordInChart - 10;
		IntradayFileLockActionEnum  IntradayFileLockAction = IFLA_NO_CHANGE;

		if (FirstIteration && LastIteration)
			IntradayFileLockAction = IFLA_LOCK_READ_RELEASE;
		else if (FirstIteration)
			IntradayFileLockAction = IFLA_LOCK_READ_HOLD;
		else if (LastIteration)
			IntradayFileLockAction = IFLA_RELEASE_AFTER_READ;

		sc.ReadIntradayFileRecordAtIndex(FileIndex, IntradayRecord, IntradayFileLockAction);

		SCDateTimeMS TradeTimestampInChartTimeZone = IntradayRecord.DateTime;

	}

	// Could also use this line of code to release the lock if not sure when will be complete with reading and want to do it as a separate operation. An index of -1 signifies not actually to perform a read.
	///sc.ReadIntradayFileRecordAtIndex( -1, IntradayRecord, IFLA_RELEASE_AFTER_READ);
		

}


/*============================================================================

----------------------------------------------------------------------------*/
SCSFExport scsf_ReadChartBarRecordsFromUnderlyingIntradayFileExample(SCStudyInterfaceRef sc)
{
	if (sc.SetDefaults)
	{
		// Set the configuration and defaults

		sc.GraphName = "Read Chart Bar Records from Underlying Intraday File Example";
		
		sc.AutoLoop = 0;

		//this must be set to 1 in order to use the sc.ReadIntradayFileRecordForBarIndexAndSubIndex function.
		sc.MaintainAdditionalChartDataArrays = 1;

		return;
	}

	if (sc.LastCallToFunction)
		return;

	s_IntradayRecord IntradayRecord;

	if (sc.GetBarHasClosedStatus(sc.UpdateStartIndex) == BHCS_BAR_HAS_NOT_CLOSED)//Only execute on updating of last bar.
	{
		int ReadSuccess = true;
		bool FirstIteration = true;
		uint32_t TotalVolume = 0;
		int SubIndex = 0;//Start at first record within bar

		//Read records until sc.ReadIntradayFileRecordForBarIndexAndSubIndex returns 0
		while (ReadSuccess)
		{
			IntradayFileLockActionEnum  IntradayFileLockAction = IFLA_NO_CHANGE;

			if (FirstIteration)
			{
				IntradayFileLockAction = IFLA_LOCK_READ_HOLD;

				FirstIteration = false;
			}

			ReadSuccess = sc.ReadIntradayFileRecordForBarIndexAndSubIndex(sc.ArraySize - 1, SubIndex, IntradayRecord, IntradayFileLockAction);

			if (ReadSuccess)
			{
				TotalVolume += IntradayRecord.TotalVolume;
				++SubIndex;
			}
		}

		sc.ReadIntradayFileRecordForBarIndexAndSubIndex(-1, -1, IntradayRecord, IFLA_RELEASE_AFTER_READ);

		SCString TotalVolumeString;
		TotalVolumeString.Format("Total volume: %u", TotalVolume);

		sc.AddMessageToLog(TotalVolumeString, 0);
	}
	
}


/*==========================================================================*/
SCSFExport scsf_ChangeStudyInputExample(SCStudyInterfaceRef sc)
{
	// Configuration
	if (sc.SetDefaults)
	{
		sc.GraphName = "Change Study Input Example";
		sc.GraphRegion = 0;    // zero based region number

		sc.AutoLoop = 0;

		return;
	}

	// Data processing
	int IntegerInput = 0;
	sc.GetChartStudyInputInt(sc.ChartNumber, 1, 36, IntegerInput);

	double DoubleInput = 0;
	sc.GetChartStudyInputFloat(sc.ChartNumber, 1, 36, DoubleInput);

	if (DoubleInput != 20)
	{
		sc.SetChartStudyInputFloat(sc.ChartNumber, 1, 36, 20);
		sc.RecalculateChart(sc.ChartNumber);
	}

	//SCString InputString;
	//sc.GetChartStudyInputString(sc.ChartNumber, 1, 90, InputString);
}


/*============================================================================
	sc.GetStudyPeakValleyLine example function
----------------------------------------------------------------------------*/
SCSFExport scsf_GetStudyPeakValleyLineExample(SCStudyInterfaceRef sc)
{
	if (sc.SetDefaults)
	{
		// Set the configuration and defaults

		sc.GraphName = "GetStudyPeakValleyLine Example";

		sc.AutoLoop = 0;

		sc.Input[0].SetStudyID(1);
		sc.Input[0].Name = "Volume by Price Study";

		return;
	}


	// Do data processing
	float PeakValleyLinePrice= 0;
	int PeakValleyType = 0;
	int StartIndex = 0;
	int PeakValleyExtensionChartColumnEndIndex = 0;

	// get the first Peak/Valley line from the last volume by price profile
	if (sc.GetStudyPeakValleyLine(sc.ChartNumber, sc.Input[0].GetStudyID(), PeakValleyLinePrice, PeakValleyType, StartIndex, PeakValleyExtensionChartColumnEndIndex, -1, 0))
	{
		// Peak/Valley line found
		int Test = 1;
	}
}


/*============================================================================
	This study periodically recalculates the studies on the chart.
----------------------------------------------------------------------------*/
SCSFExport scsf_PeriodicChartRecalculation(SCStudyInterfaceRef sc)
{
	SCInputRef Input_RecalculationTimeInSeconds = sc.Input[0];
	SCInputRef Input_UpdateAlways = sc.Input[1];

	if (sc.SetDefaults)
	{
		// Set the configuration and defaults

		sc.GraphName = "Chart Recalculation - Periodic";

		sc.AutoLoop =  0;

		sc.GraphRegion = 0;

		Input_RecalculationTimeInSeconds.Name = "Recalculation Time in Seconds";
		Input_RecalculationTimeInSeconds.SetInt(SECONDS_PER_HOUR);// 1 hour
		Input_RecalculationTimeInSeconds.SetIntLimits(1, SECONDS_PER_DAY);

		Input_UpdateAlways.Name = "Update Always";
		Input_UpdateAlways.SetYesNo(false);

		return;
	}		

	sc.UpdateAlways = Input_UpdateAlways.GetYesNo();

	SCDateTime& r_LastCalculationDateTime = sc.GetPersistentSCDateTime(1);

	const SCDateTimeMS CurrentDateTime = sc.GetCurrentDateTime();
	if ((CurrentDateTime - r_LastCalculationDateTime).GetAbsoluteValue() 
> SCDateTime::SECONDS(Input_RecalculationTimeInSeconds.GetInt()))
	{
		r_LastCalculationDateTime = CurrentDateTime;
		sc.FlagFullRecalculate = 1;
		sc.AddMessageToLog("Performing full recalculation of chart", 0);
	}



}

/*==========================================================================*/
SCSFExport scsf_HLVolatility(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_HLDiff = sc.Subgraph[0];
	SCSubgraphRef Subgraph_AvgHLDiff = sc.Subgraph[1];
	SCSubgraphRef Subgraph_AvgClose = sc.Subgraph[2];
	SCSubgraphRef Subgraph_HLVolatility = sc.Subgraph[3];

	SCInputRef Input_MAType = sc.Input[0];
	SCInputRef Input_Length = sc.Input[1];

	if (sc.SetDefaults)
	{
		sc.GraphName = "High Low Volatility";

		sc.GraphRegion = 1;
		sc.AutoLoop = 1;

		Subgraph_HLDiff.Name = "HL Difference";
		Subgraph_HLDiff.DrawStyle = DRAWSTYLE_IGNORE;

		Subgraph_AvgHLDiff.Name = "Average HL Difference";
		Subgraph_AvgHLDiff.DrawStyle = DRAWSTYLE_IGNORE;

		Subgraph_AvgClose.Name = "Average Close";
		Subgraph_AvgClose.DrawStyle = DRAWSTYLE_IGNORE;

		Subgraph_HLVolatility.Name = "HL Volatility";
		Subgraph_HLVolatility.DrawZeros = true;
		Subgraph_HLVolatility.PrimaryColor = RGB(0, 255, 0);
		Subgraph_HLVolatility.DrawStyle = DRAWSTYLE_LINE;

		Input_MAType.Name = "Moving Average Type";
		Input_MAType.SetMovAvgType(MOVAVGTYPE_EXPONENTIAL);

		Input_Length.Name = "Moving Average Length";
		Input_Length.SetInt(9);
		Input_Length.SetIntLimits(1, MAX_STUDY_LENGTH);

		return;
	}

	Subgraph_HLDiff[sc.Index] = sc.GetHighest(sc.BaseDataIn[SC_HIGH], Input_Length.GetInt()) - sc.GetLowest(sc.BaseDataIn[SC_LOW], Input_Length.GetInt());

	sc.MovingAverage(Subgraph_HLDiff, Subgraph_AvgHLDiff, Input_MAType.GetMovAvgType(), Input_Length.GetInt());
	sc.MovingAverage(sc.BaseDataIn[SC_LAST], Subgraph_AvgClose, Input_MAType.GetMovAvgType(), Input_Length.GetInt());

	if (Subgraph_AvgClose[sc.Index] == 0.0f)
		Subgraph_HLVolatility[sc.Index] = 0.0f;
	else
		Subgraph_HLVolatility[sc.Index] = 100.0f*Subgraph_AvgHLDiff[sc.Index] / Subgraph_AvgClose[sc.Index];
}

/*==========================================================================*/
SCSFExport scsf_GetVolumeAtPriceDataForStudyProfileExample(SCStudyInterfaceRef sc)
{
	SCInputRef  Input_StudyReference = sc.Input[0];

	if (sc.SetDefaults)
	{
		// Set the configuration and defaults

		sc.GraphName = "GetVolumeAtPriceDataForStudyProfile Example";

		sc.AutoLoop = 0;
		sc.GraphRegion = 1;

		Input_StudyReference.Name = "Profile Study Reference";
		Input_StudyReference.SetStudyID(1);

		return;
	}

	int PricesCount = sc.GetNumPriceLevelsForStudyProfile(Input_StudyReference.GetStudyID(), 0);

	for (int PriceIndex = 0; PriceIndex < PricesCount; PriceIndex++)
	{

		s_VolumeAtPriceV2 VolumeAtPrice;

		int Result = sc.GetVolumeAtPriceDataForStudyProfile
		(Input_StudyReference.GetStudyID()
			, 0
			, PriceIndex
			, VolumeAtPrice
		);

		int Volume = VolumeAtPrice.Volume;

	}


}

/*==========================================================================*/
SCSFExport scsf_RotationFactor(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_RotationFactor = sc.Subgraph[0];

	if (sc.SetDefaults)
	{
		sc.GraphName = "Rotation Factor";

		sc.GraphRegion = 1;
		sc.AutoLoop = 1;

		Subgraph_RotationFactor.Name = "RF";
		Subgraph_RotationFactor.DrawStyle = DRAWSTYLE_BAR;
		Subgraph_RotationFactor.AutoColoring = AUTOCOLOR_POSNEG;
		Subgraph_RotationFactor.LineWidth = 2;
		Subgraph_RotationFactor.DrawZeros = 1;
		
		sc.DataStartIndex = 1;

		return;
	}

	if (sc.Index == 0)
		return;

	int RotationFactor = 0;

	if (sc.High[sc.Index] > sc.High[sc.Index - 1])
		RotationFactor++;

	if (sc.Low[sc.Index] > sc.Low[sc.Index - 1])
		RotationFactor++;

	if (sc.High[sc.Index] < sc.High[sc.Index - 1])
		RotationFactor--;

	if (sc.Low[sc.Index] < sc.Low[sc.Index - 1])
		RotationFactor--;

	Subgraph_RotationFactor.Arrays[0][sc.Index] = static_cast<float>(RotationFactor);

	if (sc.IsNewTradingDay(sc.Index))
		Subgraph_RotationFactor.Data[sc.Index] = 0;
	else
		Subgraph_RotationFactor.Data[sc.Index] = Subgraph_RotationFactor.Arrays[0][sc.Index] + Subgraph_RotationFactor.Data[sc.Index - 1];

}

/*==========================================================================*/
SCSFExport scsf_HurstBands(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_DisplacedPrice = sc.Subgraph[0];
	SCSubgraphRef Subgraph_MovingAverage = sc.Subgraph[1];
	SCSubgraphRef Subgraph_TopInnerBand = sc.Subgraph[2];
	SCSubgraphRef Subgraph_BottomInnerBand = sc.Subgraph[3];
	SCSubgraphRef Subgraph_TopOuterBand = sc.Subgraph[4];
	SCSubgraphRef Subgraph_BottomOuterBand = sc.Subgraph[5];
	SCSubgraphRef Subgraph_TopExtremeBand = sc.Subgraph[6];
	SCSubgraphRef Subgraph_BottomExtremeBand = sc.Subgraph[7];

	SCInputRef Input_InputData = sc.Input[0];
	SCInputRef Input_Length = sc.Input[1];
	SCInputRef Input_MovAvgType = sc.Input[2];
	SCInputRef Input_InnerMultiplier = sc.Input[3];
	SCInputRef Input_OuterMultiplier = sc.Input[4];
	SCInputRef Input_ExtremeMultiplier = sc.Input[5];

	if (sc.SetDefaults)
	{
		sc.GraphName = "Hurst Bands";

		sc.GraphRegion = 0;
		sc.AutoLoop = 1;

		Subgraph_DisplacedPrice.Name = "Displaced Price";
		Subgraph_DisplacedPrice.DrawStyle = DRAWSTYLE_IGNORE;

		Subgraph_MovingAverage.Name = "Moving Average";
		Subgraph_MovingAverage.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_MovingAverage.PrimaryColor = RGB(128, 0, 128);
		Subgraph_MovingAverage.DrawZeros = true;

		Subgraph_TopInnerBand.Name = "Top Inner Band";
		Subgraph_TopInnerBand.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_TopInnerBand.PrimaryColor = RGB(255, 0, 0);
		Subgraph_TopInnerBand.DrawZeros = true;

		Subgraph_BottomInnerBand.Name = "Bottom Inner Band";
		Subgraph_BottomInnerBand.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_BottomInnerBand.PrimaryColor = RGB(255, 0, 0);
		Subgraph_BottomInnerBand.DrawZeros = true;

		Subgraph_TopOuterBand.Name = "Top Outer Band";
		Subgraph_TopOuterBand.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_TopOuterBand.PrimaryColor = RGB(0, 255, 0);
		Subgraph_TopOuterBand.DrawZeros = true;

		Subgraph_BottomOuterBand.Name = "Bottom Outer Band";
		Subgraph_BottomOuterBand.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_BottomOuterBand.PrimaryColor = RGB(0, 255, 0);
		Subgraph_BottomOuterBand.DrawZeros = true;

		Subgraph_TopExtremeBand.Name = "Top Extreme Band";
		Subgraph_TopExtremeBand.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_TopExtremeBand.PrimaryColor = RGB(0, 0, 255);
		Subgraph_TopExtremeBand.DrawZeros = true;

		Subgraph_BottomExtremeBand.Name = "Bottom Extreme Band";
		Subgraph_BottomExtremeBand.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_BottomExtremeBand.PrimaryColor = RGB(0, 0, 255);
		Subgraph_BottomExtremeBand.DrawZeros = true;

		Input_InputData.Name = "Input Data";
		Input_InputData.SetInputDataIndex(SC_HL);

		Input_Length.Name = "Moving Average Length";
		Input_Length.SetInt(10);
		Input_Length.SetIntLimits(1, MAX_STUDY_LENGTH);

		Input_MovAvgType.Name = "Moving Average Type";
		Input_MovAvgType.SetMovAvgType(MOVAVGTYPE_SIMPLE);

		Input_InnerMultiplier.Name = "Inner Band Multiplier";
		Input_InnerMultiplier.SetFloat(0.05f);

		Input_OuterMultiplier.Name = "Outer Band Multiplier";
		Input_OuterMultiplier.SetFloat(0.025f);

		Input_ExtremeMultiplier.Name = "Extreme Band Multiplier";
		Input_ExtremeMultiplier.SetFloat(0.0125f);

		return;
	}

	int Displacement = Input_Length.GetInt() / 2 + 1;

	sc.DataStartIndex = Input_Length.GetInt() + Displacement - 1;

	Subgraph_DisplacedPrice[sc.Index] = sc.BaseDataIn[Input_InputData.GetInputDataIndex()][sc.Index - Displacement];

	sc.MovingAverage(Subgraph_DisplacedPrice, Subgraph_MovingAverage, Input_MovAvgType.GetMovAvgType(), Input_Length.GetInt());


	Subgraph_TopInnerBand[sc.Index] = Subgraph_MovingAverage[sc.Index] + (Input_InnerMultiplier.GetFloat() / 100.0f) * Subgraph_MovingAverage[sc.Index];

	Subgraph_BottomInnerBand[sc.Index] = Subgraph_MovingAverage[sc.Index] - (Input_InnerMultiplier.GetFloat() / 100.0f) * Subgraph_MovingAverage[sc.Index];

	Subgraph_TopOuterBand[sc.Index] = Subgraph_MovingAverage[sc.Index] + (Input_OuterMultiplier.GetFloat() / 100.0f) * Subgraph_MovingAverage[sc.Index];

	Subgraph_BottomOuterBand[sc.Index] = Subgraph_MovingAverage[sc.Index] - (Input_OuterMultiplier.GetFloat() / 100.0f) * Subgraph_MovingAverage[sc.Index];

	Subgraph_TopExtremeBand[sc.Index] = Subgraph_MovingAverage[sc.Index] + (Input_ExtremeMultiplier.GetFloat() / 100.0f) * Subgraph_MovingAverage[sc.Index];

	Subgraph_BottomExtremeBand[sc.Index] = Subgraph_MovingAverage[sc.Index] - (Input_ExtremeMultiplier.GetFloat() / 100.0f) * Subgraph_MovingAverage[sc.Index];
}

/*==========================================================================*/
SCSFExport scsf_GannHiLoActivator(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_HiAvg = sc.Subgraph[0];
	SCSubgraphRef Subgraph_LoAvg = sc.Subgraph[1];
	SCSubgraphRef Subgraph_HiLo = sc.Subgraph[2];
	SCSubgraphRef Subgraph_GannHiLoActivator = sc.Subgraph[3];

	SCInputRef Input_Length = sc.Input[0];
	SCInputRef Input_MovAvgType = sc.Input[1];

	if (sc.SetDefaults)
	{
		sc.GraphName = "Gann HiLo Activator";

		sc.GraphRegion = 0;
		sc.ValueFormat = 2;
		sc.AutoLoop = 1;

		Subgraph_HiAvg.Name = "Average High Price";
		Subgraph_HiAvg.DrawStyle = DRAWSTYLE_IGNORE;

		Subgraph_LoAvg.Name = "Average Low Price";
		Subgraph_LoAvg.DrawStyle = DRAWSTYLE_IGNORE;

		Subgraph_HiLo.Name = "HiLo";
		Subgraph_HiLo.DrawStyle = DRAWSTYLE_IGNORE;

		Subgraph_GannHiLoActivator.Name = "Gann HiLo Activator";
		Subgraph_GannHiLoActivator.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_GannHiLoActivator.PrimaryColor = RGB(0, 255, 0);
		Subgraph_GannHiLoActivator.SecondaryColor = RGB(255, 0, 0);
		Subgraph_GannHiLoActivator.SecondaryColorUsed = true;
		Subgraph_GannHiLoActivator.DrawZeros = true;

		Input_Length.Name = "Length";
		Input_Length.SetInt(3);
		Input_Length.SetIntLimits(1, MAX_STUDY_LENGTH);

		Input_MovAvgType.Name = "Moving Average Type";
		Input_MovAvgType.SetMovAvgType(MOVAVGTYPE_SIMPLE);

		return;
	}

	sc.DataStartIndex = Input_Length.GetInt();

	sc.MovingAverage(sc.High, Subgraph_HiAvg, Input_MovAvgType.GetMovAvgType(), Input_Length.GetInt());
	sc.MovingAverage(sc.Low, Subgraph_LoAvg, Input_MovAvgType.GetMovAvgType(), Input_Length.GetInt());

	if (sc.Close[sc.Index] > Subgraph_HiAvg[sc.Index - 1])
		Subgraph_HiLo[sc.Index] = 1.0f;

	else if (sc.Close[sc.Index] < Subgraph_LoAvg[sc.Index - 1])
		Subgraph_HiLo[sc.Index] = -1.0f;

	else
		Subgraph_HiLo[sc.Index] = 0.0f;

	if (Subgraph_HiLo[sc.Index] == 1.0f)
	{
		Subgraph_GannHiLoActivator.DataColor[sc.Index] = Subgraph_GannHiLoActivator.PrimaryColor;
		Subgraph_GannHiLoActivator[sc.Index] = Subgraph_LoAvg[sc.Index - 1];
	}

	else if (Subgraph_HiLo[sc.Index] == -1.0f)
	{
		Subgraph_GannHiLoActivator.DataColor[sc.Index] = Subgraph_GannHiLoActivator.SecondaryColor;
		Subgraph_GannHiLoActivator[sc.Index] = Subgraph_HiAvg[sc.Index - 1];
	}
	else
	{
		Subgraph_GannHiLoActivator.DataColor[sc.Index] = Subgraph_GannHiLoActivator.DataColor[sc.Index - 1];
		Subgraph_GannHiLoActivator[sc.Index] = Subgraph_GannHiLoActivator[sc.Index - 1];
	}
}

/*==========================================================================*/
SCSFExport scsf_RangeExpansionIndex(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_REI = sc.Subgraph[0];
	SCSubgraphRef Subgraph_ConditionalMultiplier = sc.Subgraph[1];
	SCSubgraphRef Subgraph_Sum1 = sc.Subgraph[2];
	SCSubgraphRef Subgraph_Sum2 = sc.Subgraph[3];
	SCSubgraphRef Subgraph_OverboughtLine = sc.Subgraph[4];
	SCSubgraphRef Subgraph_OversoldLine = sc.Subgraph[5];
	SCSubgraphRef Subgraph_ZeroLine = sc.Subgraph[6];
	SCSubgraphRef Subgraph_DurationExceededOverbought = sc.Subgraph[7];
	SCSubgraphRef Subgraph_DurationExceededOversold = sc.Subgraph[8];

	SCInputRef Input_Length = sc.Input[0];
	SCInputRef Input_LookbackLength1 = sc.Input[1];
	SCInputRef Input_LookbackLength2 = sc.Input[2];
	SCInputRef Input_LookbackLength3 = sc.Input[3];
	SCInputRef Input_DurationLength = sc.Input[4];
	SCInputRef Input_OffsetPercentage = sc.Input[5];
	SCInputRef Input_InputDataForHighComparison = sc.Input[6];
	SCInputRef Input_InputDataForLowComparison = sc.Input[7];
	SCInputRef Input_BasicOrAdvanced = sc.Input[8];
	SCInputRef Input_UseStrictInequalities = sc.Input[9];
	SCInputRef Input_OverboughtLineValue = sc.Input[10];
	SCInputRef Input_OversoldLineValue = sc.Input[11];

	if (sc.SetDefaults)
	{
		sc.GraphName = "Range Expansion Index";

		sc.AutoLoop = 1;

		Subgraph_REI.Name = "Range Expansion Index";
		Subgraph_REI.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_REI.PrimaryColor = RGB(0, 0, 255);
		Subgraph_REI.DrawZeros = true;

		Subgraph_ConditionalMultiplier.Name = "Conditional Multiplier";
		Subgraph_ConditionalMultiplier.DrawStyle = DRAWSTYLE_IGNORE;

		Subgraph_Sum1.Name = "Sum 1";
		Subgraph_Sum1.DrawStyle = DRAWSTYLE_IGNORE;

		Subgraph_Sum2.Name = "Sum 2";
		Subgraph_Sum2.DrawStyle = DRAWSTYLE_IGNORE;

		Subgraph_OverboughtLine.Name = "Overbought Line";
		Subgraph_OverboughtLine.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_OverboughtLine.PrimaryColor = RGB(0, 255, 0);
		Subgraph_OverboughtLine.DrawZeros = true;

		Subgraph_OversoldLine.Name = "Oversold Line";
		Subgraph_OversoldLine.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_OversoldLine.PrimaryColor = RGB(255, 0, 0);
		Subgraph_OversoldLine.DrawZeros = true;

		Subgraph_ZeroLine.Name = "Zero Line";
		Subgraph_ZeroLine.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_ZeroLine.PrimaryColor = RGB(255, 255, 255);
		Subgraph_ZeroLine.DrawZeros = true;

		Subgraph_DurationExceededOverbought.Name = "Duration Exceeded in Overbought Area";
		Subgraph_DurationExceededOverbought.PrimaryColor = RGB(0, 255, 0);
		Subgraph_DurationExceededOverbought.DrawStyle = DRAWSTYLE_ARROW_DOWN;
		Subgraph_DurationExceededOverbought.LineWidth = 2;
		Subgraph_DurationExceededOverbought.DrawZeros = 0;

		Subgraph_DurationExceededOversold.Name = "Duration Exceeded in Oversold Area";
		Subgraph_DurationExceededOversold.PrimaryColor = RGB(255, 0, 0);
		Subgraph_DurationExceededOversold.DrawStyle = DRAWSTYLE_ARROW_UP;
		Subgraph_DurationExceededOversold.LineWidth = 2;
		Subgraph_DurationExceededOversold.DrawZeros = 0;

		Input_Length.Name = "Length";
		Input_Length.SetInt(8);
		Input_Length.SetIntLimits(2, MAX_STUDY_LENGTH);

		Input_LookbackLength1.Name = "Lookback Length 1";
		Input_LookbackLength1.SetInt(2);
		Input_LookbackLength1.SetIntLimits(1, Input_Length.GetInt());

		Input_LookbackLength2.Name = "Lookback Length 2";
		Input_LookbackLength2.SetInt(5);
		Input_LookbackLength2.SetIntLimits(1, Input_Length.GetInt() - 1);

		Input_LookbackLength3.Name = "Lookback Length 3";
		Input_LookbackLength3.SetInt(7);
		Input_LookbackLength3.SetIntLimits(1, Input_Length.GetInt() - 1);

		Input_DurationLength.Name = "Duration Length";
		Input_DurationLength.SetInt(6);
		Input_DurationLength.SetIntLimits(1, Input_Length.GetInt() - 1);

		Input_OffsetPercentage.Name = "Arrow Offset Percentage";
		Input_OffsetPercentage.SetFloat(8.0f);

		Input_InputDataForHighComparison.Name = "Input Data for Comparison with High";
		Input_InputDataForHighComparison.SetInputDataIndex(SC_LOW);

		Input_InputDataForLowComparison.Name = "Input Data for Comparison with Low";
		Input_InputDataForLowComparison.SetInputDataIndex(SC_HIGH);

		Input_BasicOrAdvanced.Name = "Basic or Advanced?";
		Input_BasicOrAdvanced.SetCustomInputStrings
		("Basic"";Advanced");
		Input_BasicOrAdvanced.SetCustomInputIndex(0);

		Input_UseStrictInequalities.Name = "Use Strict Inequalities?";
		Input_UseStrictInequalities.SetCustomInputStrings
		("No"";Yes");
		Input_UseStrictInequalities.SetCustomInputIndex(0);

		Input_OverboughtLineValue.Name = "Overbought Line Value";
		Input_OverboughtLineValue.SetFloat(45.0f);

		Input_OversoldLineValue.Name = "Oversold Line Value";
		Input_OversoldLineValue.SetFloat(-45.0f);

		return;
	}

	sc.DataStartIndex = Input_Length.GetInt() + max(Input_LookbackLength1.GetInt(), max(Input_LookbackLength2.GetInt(), max(Input_LookbackLength3.GetInt(), Input_DurationLength.GetInt())));

	// Evaluate logical conditions that determine the value of the Conditional Multiplier
	bool Condition1 = ((sc.High[sc.Index] >= sc.BaseData[Input_InputDataForHighComparison.GetInputDataIndex()][sc.Index - Input_LookbackLength2.GetInt()]) ||
		(sc.High[sc.Index] >= sc.BaseData[Input_InputDataForHighComparison.GetInputDataIndex()][sc.Index - Input_LookbackLength2.GetInt() - 1])) &&
		((sc.Low[sc.Index] <= sc.BaseData[Input_InputDataForLowComparison.GetInputDataIndex()][sc.Index - Input_LookbackLength2.GetInt()]) ||
		(sc.Low[sc.Index] <= sc.BaseData[Input_InputDataForLowComparison.GetInputDataIndex()][sc.Index - Input_LookbackLength2.GetInt() - 1]));

	bool Condition2 = ((sc.High[sc.Index - Input_LookbackLength1.GetInt()] >= sc.Close[sc.Index - Input_LookbackLength3.GetInt()]) ||
		(sc.High[sc.Index - Input_LookbackLength1.GetInt()] >= sc.Close[sc.Index - Input_LookbackLength3.GetInt() - 1])) &&
		((sc.Low[sc.Index - Input_LookbackLength1.GetInt()] <= sc.Close[sc.Index - Input_LookbackLength3.GetInt()]) ||
		(sc.Low[sc.Index - Input_LookbackLength1.GetInt()] <= sc.Close[sc.Index - Input_LookbackLength3.GetInt() - 1]));

	bool Condition3 = ((sc.High[sc.Index] > sc.BaseData[Input_InputDataForHighComparison.GetInputDataIndex()][sc.Index - Input_LookbackLength2.GetInt()]) ||
		(sc.High[sc.Index] > sc.BaseData[Input_InputDataForHighComparison.GetInputDataIndex()][sc.Index - Input_LookbackLength2.GetInt() - 1])) &&
		((sc.Low[sc.Index] < sc.BaseData[Input_InputDataForLowComparison.GetInputDataIndex()][sc.Index - Input_LookbackLength2.GetInt()]) ||
		(sc.Low[sc.Index] < sc.BaseData[Input_InputDataForLowComparison.GetInputDataIndex()][sc.Index - Input_LookbackLength2.GetInt() - 1]));

	bool Condition4 = ((sc.High[sc.Index - Input_LookbackLength1.GetInt()] > sc.Close[sc.Index - Input_LookbackLength3.GetInt()]) ||
		(sc.High[sc.Index - Input_LookbackLength1.GetInt()] > sc.Close[sc.Index - Input_LookbackLength3.GetInt() - 1])) &&
		((sc.Low[sc.Index - Input_LookbackLength1.GetInt()] < sc.Close[sc.Index - Input_LookbackLength3.GetInt()]) ||
		(sc.Low[sc.Index - Input_LookbackLength1.GetInt()] < sc.Close[sc.Index - Input_LookbackLength3.GetInt() - 1]));


	// Switch between Basic and Advanced versions of the REI.
	float TempPrevConditionalMultiplier = Subgraph_ConditionalMultiplier[sc.Index - 1];

	const int SelectedIndex1 = Input_BasicOrAdvanced.GetIndex();
	switch (SelectedIndex1)
	{
	case 0:
	{
		if (Condition1 || Condition2)
			Subgraph_ConditionalMultiplier[sc.Index] = 1.0f;
		else
			Subgraph_ConditionalMultiplier[sc.Index] = 0.0f;
	}
	break;

	case 1:
	{
		const int SelectedIndex2 = Input_UseStrictInequalities.GetIndex();
		switch (SelectedIndex2)
		{
		case 0:
		{
			if (Condition1 || Condition2)
				Subgraph_ConditionalMultiplier[sc.Index] = 1.0f;
			else
			{
				Subgraph_ConditionalMultiplier[sc.Index - 1] = 0.0f;
				Subgraph_ConditionalMultiplier[sc.Index] = 0.0f;
			}
		}
		break;

		case 1:
		{
			if (Condition3 || Condition4)
				Subgraph_ConditionalMultiplier[sc.Index] = 1.0f;
			else
			{
				Subgraph_ConditionalMultiplier[sc.Index - 1] = 0.0f;
				Subgraph_ConditionalMultiplier[sc.Index] = 0.0f;
			}
		}
		break;
		}
	}
	break;
	}

	// Compute sums.
	float Sum1 = 0;
	float Sum2 = 0;

	for (int Index = sc.Index - Input_Length.GetInt() + 1; Index <= sc.Index; Index++)
	{
		Sum1 += Subgraph_ConditionalMultiplier[Index] * (sc.High[Index] - sc.High[Index - Input_LookbackLength1.GetInt()] + sc.Low[Index] - sc.Low[Index - Input_LookbackLength1.GetInt()]);

		Sum2 += fabs(sc.High[Index] - sc.High[Index - Input_LookbackLength1.GetInt()]) + fabs(sc.Low[Index] - sc.Low[Index - Input_LookbackLength1.GetInt()]);
	}

	Subgraph_Sum1[sc.Index] = Sum1;

	Subgraph_Sum2[sc.Index] = Sum2;

	// Compute REI.
	if (Sum2 != 0)
		Subgraph_REI[sc.Index] = 100.0f * Subgraph_Sum1[sc.Index] / Subgraph_Sum2[sc.Index];
	else
		Subgraph_REI[sc.Index] = Subgraph_REI[sc.Index - 1];

	// Recompute Sum1 and REI if previous value of Conditional Multiplier changes.
	if (Subgraph_ConditionalMultiplier[sc.Index - 1] != TempPrevConditionalMultiplier) 
	{
		Subgraph_Sum1[sc.Index - 1] = Subgraph_Sum1[sc.Index - 1] - (sc.High[sc.Index - 1] - sc.High[sc.Index - 1 - Input_LookbackLength1.GetInt()] + sc.Low[sc.Index - 1] - sc.Low[sc.Index - 1 - Input_LookbackLength1.GetInt()]);

		Subgraph_REI[sc.Index - 1] = 100.0f * Subgraph_Sum1[sc.Index - 1] / Subgraph_Sum2[sc.Index - 1];
	}

	Subgraph_DurationExceededOverbought[sc.Index] = 0.0f;
	Subgraph_DurationExceededOversold[sc.Index] = 0.0f;

	// Perform Duration Analysis
	if (Subgraph_REI[sc.Index] > Input_OverboughtLineValue.GetFloat())
	{
		// Check beginning of chart.
		if (sc.Index == sc.DataStartIndex + Input_DurationLength.GetInt() - 1)
		{
			int OverboughtSum = 1;

			for (int Index = sc.Index - Input_DurationLength.GetInt() + 1; Index <= sc.Index - 1; Index++)
			{
				if (Subgraph_REI[Index] > Input_OverboughtLineValue.GetFloat())
					OverboughtSum += 1;
			}

			if (OverboughtSum == Input_DurationLength.GetInt())
			{
				Subgraph_DurationExceededOverbought[sc.Index] =
					Subgraph_REI[sc.Index] + (Input_OffsetPercentage.GetFloat() / 100.0f) *
					Subgraph_REI[sc.Index];
			}
		}

		int OverboughtIndex = 1;

		while (Subgraph_REI[sc.Index - OverboughtIndex] > Input_OverboughtLineValue.GetFloat() && OverboughtIndex <= Input_DurationLength.GetInt())
			OverboughtIndex++;

		if (OverboughtIndex == Input_DurationLength.GetInt() && sc.Index >= sc.DataStartIndex + Input_DurationLength.GetInt() - 1)
		{
			Subgraph_DurationExceededOverbought[sc.Index] =
				Subgraph_REI[sc.Index] +
				(Input_OffsetPercentage.GetFloat() / 100.0f) *
				Subgraph_REI[sc.Index];
		}
	}

	if (Subgraph_REI[sc.Index] < Input_OversoldLineValue.GetFloat())
	{
		// Check beginning of chart.
		if (sc.Index == sc.DataStartIndex + Input_DurationLength.GetInt() - 1)
		{
			int OversoldSum = 1;

			for (int Index = sc.Index - Input_DurationLength.GetInt() + 1; Index <= sc.Index - 1; Index++)
			{
				if (Subgraph_REI[Index] < Input_OversoldLineValue.GetFloat())
					OversoldSum += 1;
			}

			if (OversoldSum == Input_DurationLength.GetInt())
			{
				Subgraph_DurationExceededOversold[sc.Index] =
					Subgraph_REI[sc.Index] - (Input_OffsetPercentage.GetFloat() / 100.0f) *
					Subgraph_REI[sc.Index];
			}
		}

		int OversoldIndex = 1;

		while (Subgraph_REI[sc.Index - OversoldIndex] < Input_OversoldLineValue.GetFloat() && OversoldIndex <= Input_DurationLength.GetInt())
			OversoldIndex++;

		if (OversoldIndex == Input_DurationLength.GetInt() && sc.Index >= sc.DataStartIndex + Input_DurationLength.GetInt() - 1)
		{
			Subgraph_DurationExceededOversold[sc.Index] =
				Subgraph_REI[sc.Index] +
				(Input_OffsetPercentage.GetFloat() / 100.0f) *
				Subgraph_REI[sc.Index];
		}
	}

	// Set horizontal lines.
	Subgraph_OverboughtLine[sc.Index] = Input_OverboughtLineValue.GetFloat();
	Subgraph_OversoldLine[sc.Index] = Input_OversoldLineValue.GetFloat();
	Subgraph_ZeroLine[sc.Index] = 0.0f;
}


/*==========================================================================*/
SCSFExport scsf_CumulativeSumOverNBars(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_Sum = sc.Subgraph[0];
	SCInputRef Input_StudySubgraphReference = sc.Input[1];
	SCInputRef Input_Length = sc.Input[2];

	if (sc.SetDefaults)
	{
		sc.GraphName = "Cumulative Sum Over N Bars";
		sc.AutoLoop = 0;//Manual looping
		sc.GraphRegion = 1;
		sc.CalculationPrecedence = LOW_PREC_LEVEL;

		Subgraph_Sum.Name = "Sum";
		Subgraph_Sum.PrimaryColor = RGB(0, 255, 0);
		Subgraph_Sum.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_Sum.LineWidth = 2;
		Subgraph_Sum.DrawZeros = false;

		Input_StudySubgraphReference.Name = "Study and Subgraph to Reference";
		Input_StudySubgraphReference.SetStudySubgraphValues(1, 0);

		Input_Length.Name = "Length";
		Input_Length.SetInt(20);
		
		return;
	}

	SCFloatArray StudyArray;
	sc.GetStudyArrayUsingID(Input_StudySubgraphReference.GetStudyID(), Input_StudySubgraphReference.GetSubgraphIndex(), StudyArray);
	if (StudyArray.GetArraySize() == 0)
	{
		sc.AddMessageToLog("Subgraph array being referenced is empty.", 1);
		return;
	}

	sc.DataStartIndex = max(Input_Length.GetInt(), sc.GetStudyDataStartIndexUsingID(Input_StudySubgraphReference.GetStudyID()));

	if (StudyArray.GetArraySize() != sc.ArraySize)
	{
		sc.AddMessageToLog("Subgraph array being referenced is not of the correct array size. Check the settings for the 'Study and Subgraph to Reference' input.", 1);
		return;
	}

	SCDateTime NextSessionStart = SCDateTime(sc.GetTradingDayStartDateTimeOfBar(sc.BaseDateTimeIn[sc.UpdateStartIndex - 1])) + SCDateTime::DAYS(1);

	if (sc.UpdateStartIndex == 0)
		Subgraph_Sum[0] = StudyArray[0];
	
	for (int BarIndex = sc.UpdateStartIndex; BarIndex < sc.ArraySize; BarIndex++)
	{
		Subgraph_Sum[BarIndex] = 0;

		for (int RefBackIndex = BarIndex; RefBackIndex > max(BarIndex - Input_Length.GetInt(), 0); RefBackIndex--)
		{
			Subgraph_Sum[BarIndex] += StudyArray[RefBackIndex];
		}
	}
}


/*==========================================================================*/
SCSFExport scsf_BarPeriodParametersTest(SCStudyInterfaceRef sc)
{
	if (sc.SetDefaults)
	{
		// Set the configuration and defaults.

		sc.GraphName = "Bar Period Parameters Test";

		sc.AutoLoop = 0;
		sc.GraphRegion = 0;
		sc.UpdateAlways = 1;

		return;
	}

	n_ACSIL::s_BarPeriod BarPeriod;
	sc.GetBarPeriodParameters(BarPeriod);

	if (BarPeriod.ChartDataType == INTRADAY_DATA && BarPeriod.IntradayChartBarPeriodType == IBPT_DAYS_MINS_SECS)
	{
		int SecondsPerBar = BarPeriod.IntradayChartBarPeriodParameter1;
	}

	SCString DebugString;
	DebugString.Format
	("Bar Period type=%d, parameters={%d, %d, %d, %d}."
		, BarPeriod.IntradayChartBarPeriodType
		, BarPeriod.IntradayChartBarPeriodParameter1
		, BarPeriod.IntradayChartBarPeriodParameter2
		, BarPeriod.IntradayChartBarPeriodParameter3
		, BarPeriod.IntradayChartBarPeriodParameter4
	);

	sc.AddMessageToLog(DebugString, 0);

	if (BarPeriod.ChartDataType != INTRADAY_DATA
		|| BarPeriod.IntradayChartBarPeriodType != IBPT_DAYS_MINS_SECS
		|| BarPeriod.IntradayChartBarPeriodParameter1 != 300)
	{
		n_ACSIL::s_BarPeriod NewBarPeriod;
		NewBarPeriod.ChartDataType = INTRADAY_DATA;
		NewBarPeriod.IntradayChartBarPeriodType = IBPT_DAYS_MINS_SECS;
		NewBarPeriod.IntradayChartBarPeriodParameter1 = 300;// 300 seconds per bar which is 5 minutes

		//Set the bar period parameters. This will go into effect after the study function returns.
		sc.SetBarPeriodParameters(NewBarPeriod);
	}
}

/*==========================================================================*/
SCSFExport scsf_RateOfChangeOscillatorTypeI(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_Temp1 = sc.Subgraph[0];
	SCSubgraphRef Subgraph_Temp2 = sc.Subgraph[1];
	SCSubgraphRef Subgraph_ROCI = sc.Subgraph[2];
	SCSubgraphRef Subgraph_OverboughtLine = sc.Subgraph[3];
	SCSubgraphRef Subgraph_OversoldLine = sc.Subgraph[4];
	SCSubgraphRef Subgraph_DurationExceededOverbought = sc.Subgraph[5];
	SCSubgraphRef Subgraph_DurationExceededOversold = sc.Subgraph[6];

	SCInputRef Input_InputData = sc.Input[0];
	SCInputRef Input_ROCLength = sc.Input[1];
	SCInputRef Input_UseSmoothing = sc.Input[2];
	SCInputRef Input_SmoothingLength = sc.Input[3];
	SCInputRef Input_SmoothingMAType = sc.Input[4];
	SCInputRef Input_UseMovingAverage = sc.Input[5];
	SCInputRef Input_AverageROCMALength = sc.Input[6];
	SCInputRef Input_AverageROCMAType = sc.Input[7];
	SCInputRef Input_DurationLength = sc.Input[8];
	SCInputRef Input_OffsetPercentage = sc.Input[9];
	SCInputRef Input_OverboughtLineValue = sc.Input[10];
	SCInputRef Input_OversoldLineValue = sc.Input[11];

	if (sc.SetDefaults)
	{
		sc.GraphName = "Rate of Change Oscillator Type I";

		sc.AutoLoop = 1;

		Subgraph_ROCI.Name = "ROC I";
		Subgraph_ROCI.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_ROCI.PrimaryColor = RGB(0, 0, 255);
		Subgraph_ROCI.DrawZeros = true;

		Subgraph_OverboughtLine.Name = "Overbought Line";
		Subgraph_OverboughtLine.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_OverboughtLine.PrimaryColor = RGB(0, 255, 0);
		Subgraph_OverboughtLine.DrawZeros = true;

		Subgraph_OversoldLine.Name = "Oversold Line";
		Subgraph_OversoldLine.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_OversoldLine.PrimaryColor = RGB(255, 0, 0);
		Subgraph_OversoldLine.DrawZeros = true;

		Subgraph_DurationExceededOverbought.Name = "Duration Exceeded in Overbought Area";
		Subgraph_DurationExceededOverbought.PrimaryColor = RGB(0, 255, 0);
		Subgraph_DurationExceededOverbought.DrawStyle = DRAWSTYLE_ARROW_DOWN;
		Subgraph_DurationExceededOverbought.LineWidth = 2;
		Subgraph_DurationExceededOverbought.DrawZeros = 0;

		Subgraph_DurationExceededOversold.Name = "Duration Exceeded in Oversold Area";
		Subgraph_DurationExceededOversold.PrimaryColor = RGB(255, 0, 0);
		Subgraph_DurationExceededOversold.DrawStyle = DRAWSTYLE_ARROW_UP;
		Subgraph_DurationExceededOversold.LineWidth = 2;
		Subgraph_DurationExceededOversold.DrawZeros = 0;

		Input_InputData.Name = "Input Data";
		Input_InputData.SetInputDataIndex(SC_LAST);

		Input_ROCLength.Name = "ROC Length";
		Input_ROCLength.SetInt(12);
		Input_ROCLength.SetIntLimits(1, MAX_STUDY_LENGTH);

		Input_UseSmoothing.Name = "Use Smoothing?";
		Input_UseSmoothing.SetCustomInputStrings
		("No"";Yes");
		Input_UseSmoothing.SetCustomInputIndex(0);

		Input_SmoothingLength.Name = "Smoothing Length";
		Input_SmoothingLength.SetInt(3);
		Input_SmoothingLength.SetIntLimits(1, Input_ROCLength.GetInt());

		Input_SmoothingMAType.Name = "Smoothing MA Type";
		Input_SmoothingMAType.SetMovAvgType(MOVAVGTYPE_SIMPLE);

		Input_UseMovingAverage.Name = "Use Moving Average?";
		Input_UseMovingAverage.SetCustomInputStrings
		("No"";Yes");
		Input_UseMovingAverage.SetCustomInputIndex(0);

		Input_AverageROCMALength.Name = "Average ROC MA Length";
		Input_AverageROCMALength.SetInt(12);
		Input_AverageROCMALength.SetIntLimits(1, MAX_STUDY_LENGTH);

		Input_AverageROCMAType.Name = "Average ROC MA Type";
		Input_AverageROCMAType.SetMovAvgType(MOVAVGTYPE_SIMPLE);

		Input_DurationLength.Name = "Duration Length";
		Input_DurationLength.SetInt(16);
		Input_DurationLength.SetIntLimits(1, MAX_STUDY_LENGTH);

		Input_OffsetPercentage.Name = "Arrow Offset Percentage";
		Input_OffsetPercentage.SetFloat(1.0f);

		Input_OverboughtLineValue.Name = "Overbought Line Value";
		Input_OverboughtLineValue.SetFloat(102.5f);

		Input_OversoldLineValue.Name = "Oversold Line Value";
		Input_OversoldLineValue.SetFloat(97.5f);

		return;
	}

	if (Input_UseSmoothing.GetIndex() == 0 && Input_UseMovingAverage.GetIndex() == 0)
		sc.DataStartIndex = Input_ROCLength.GetInt();
	else if (Input_UseSmoothing.GetIndex() == 1 && Input_UseMovingAverage.GetIndex() == 0)
		sc.DataStartIndex = Input_ROCLength.GetInt() + Input_SmoothingLength.GetInt() - 1;
	else if (Input_UseSmoothing.GetIndex() == 0 && Input_UseMovingAverage.GetIndex() == 1)
		sc.DataStartIndex = Input_ROCLength.GetInt() + Input_AverageROCMALength.GetInt() - 1;
	else
		sc.DataStartIndex = Input_ROCLength.GetInt() + Input_SmoothingLength.GetInt() + Input_AverageROCMALength.GetInt() - 2;


	// Compute ROC I.
	if (sc.Index >= Input_ROCLength.GetInt())
	{
		Subgraph_Temp1[sc.Index] = 100.0f * sc.BaseDataIn[Input_InputData.GetInputDataIndex()][sc.Index] / sc.BaseDataIn[Input_InputData.GetInputDataIndex()][sc.Index - Input_ROCLength.GetInt()];
	}

	if (Input_UseSmoothing.GetIndex() == 1)
		sc.MovingAverage(Subgraph_Temp1, Subgraph_Temp2, Input_SmoothingMAType.GetMovAvgType(), Input_SmoothingLength.GetInt());

	if (Input_UseSmoothing.GetIndex() == 0 && Input_UseMovingAverage.GetIndex() == 0)
		Subgraph_ROCI[sc.Index] = Subgraph_Temp1[sc.Index];
	else if (Input_UseSmoothing.GetIndex() == 1 && Input_UseMovingAverage.GetIndex() == 0)
		Subgraph_ROCI[sc.Index] = Subgraph_Temp2[sc.Index];
	else if (Input_UseSmoothing.GetIndex() == 0 && Input_UseMovingAverage.GetIndex() == 1)
		sc.MovingAverage(Subgraph_Temp1, Subgraph_ROCI, Input_AverageROCMAType.GetMovAvgType(), Input_AverageROCMALength.GetInt());
	else
		sc.MovingAverage(Subgraph_Temp2, Subgraph_ROCI, Input_AverageROCMAType.GetMovAvgType(), Input_AverageROCMALength.GetInt());

	Subgraph_DurationExceededOverbought[sc.Index] = 0.0f;
	Subgraph_DurationExceededOversold[sc.Index] = 0.0f;

	// Perform Duration Analysis.
	if (Subgraph_ROCI[sc.Index] > Input_OverboughtLineValue.GetFloat())
	{
		// Check beginning of chart.
		if (sc.Index == sc.DataStartIndex + Input_DurationLength.GetInt() - 1)
		{
			int OverboughtSum = 1;

			for (int Index = sc.Index - Input_DurationLength.GetInt() + 1; Index <= sc.Index - 1; Index++)
			{
				if (Subgraph_ROCI[Index] > Input_OverboughtLineValue.GetFloat())
					OverboughtSum += 1;
			}

			if (OverboughtSum == Input_DurationLength.GetInt())
			{
				Subgraph_DurationExceededOverbought[sc.Index] =
					Subgraph_ROCI[sc.Index] + 
					(Input_OffsetPercentage.GetFloat() / 100.0f) *
					Subgraph_ROCI[sc.Index];
			}
		}

		int OverboughtIndex = 1;

		while (Subgraph_ROCI[sc.Index - OverboughtIndex] > Input_OverboughtLineValue.GetFloat() && OverboughtIndex <= Input_DurationLength.GetInt())
			OverboughtIndex++;

		if (OverboughtIndex == Input_DurationLength.GetInt() && sc.Index >= sc.DataStartIndex + Input_DurationLength.GetInt() - 1)
		{
			Subgraph_DurationExceededOverbought[sc.Index] =
				Subgraph_ROCI[sc.Index] + 
				(Input_OffsetPercentage.GetFloat() / 100.0f) *
				Subgraph_ROCI[sc.Index];
		}
	}

	if (Subgraph_ROCI[sc.Index] < Input_OversoldLineValue.GetFloat())
	{
		// Check beginning of chart.
		if (sc.Index == sc.DataStartIndex + Input_DurationLength.GetInt() - 1)
		{
			int OversoldSum = 1;

			for (int Index = sc.Index - Input_DurationLength.GetInt() + 1; Index <= sc.Index - 1; Index++)
			{
				if (Subgraph_ROCI[Index] < Input_OversoldLineValue.GetFloat())
					OversoldSum += 1;
			}

			if (OversoldSum == Input_DurationLength.GetInt())
			{
				Subgraph_DurationExceededOversold[sc.Index] =
					Subgraph_ROCI[sc.Index] - 
					(Input_OffsetPercentage.GetFloat() / 100.0f) *
					Subgraph_ROCI[sc.Index];
			}
		}

		int OversoldIndex = 1;

		while (Subgraph_ROCI[sc.Index - OversoldIndex] < Input_OversoldLineValue.GetFloat() && OversoldIndex <= Input_DurationLength.GetInt())
			OversoldIndex++;

		if (OversoldIndex == Input_DurationLength.GetInt() && sc.Index >= sc.DataStartIndex + Input_DurationLength.GetInt() - 1)
		{
			Subgraph_DurationExceededOversold[sc.Index] =
				Subgraph_ROCI[sc.Index] - 
				(Input_OffsetPercentage.GetFloat() / 100.0f) * 
				Subgraph_ROCI[sc.Index];
		}
	}

	// Set horizontal lines.
	Subgraph_OverboughtLine[sc.Index] = Input_OverboughtLineValue.GetFloat();
	Subgraph_OversoldLine[sc.Index] = Input_OversoldLineValue.GetFloat();
}

/*==========================================================================*/
SCSFExport scsf_RateOfChangeOscillatorTypeII(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_ROCI = sc.Subgraph[0];
	SCSubgraphRef Subgraph_Temp1 = sc.Subgraph[1];
	SCSubgraphRef Subgraph_Temp2 = sc.Subgraph[2];
	SCSubgraphRef Subgraph_ROCII = sc.Subgraph[3];
	SCSubgraphRef Subgraph_OverboughtLine = sc.Subgraph[4];
	SCSubgraphRef Subgraph_OversoldLine = sc.Subgraph[5];
	SCSubgraphRef Subgraph_DurationExceededOverbought = sc.Subgraph[6];
	SCSubgraphRef Subgraph_DurationExceededOversold = sc.Subgraph[7];

	SCInputRef Input_InputData = sc.Input[0];
	SCInputRef Input_InputDataHigh = sc.Input[1];
	SCInputRef Input_InputDataLow = sc.Input[2];
	SCInputRef Input_ROCLength = sc.Input[3];
	SCInputRef Input_HighThreshold = sc.Input[4];
	SCInputRef Input_LowThreshold = sc.Input[5];
	SCInputRef Input_UseSmoothing = sc.Input[6];
	SCInputRef Input_SmoothingLength = sc.Input[7];
	SCInputRef Input_SmoothingMAType = sc.Input[8];
	SCInputRef Input_UseMovingAverage = sc.Input[9];
	SCInputRef Input_AverageROCMALength = sc.Input[10];
	SCInputRef Input_AverageROCMAType = sc.Input[11];
	SCInputRef Input_DurationLength = sc.Input[12];
	SCInputRef Input_OffsetPercentage = sc.Input[13];
	SCInputRef Input_OverboughtLineValue = sc.Input[14];
	SCInputRef Input_OversoldLineValue = sc.Input[15];

	if (sc.SetDefaults)
	{
		sc.GraphName = "Rate of Change Oscillator Type II";

		sc.AutoLoop = 1;

		Subgraph_ROCI.Name = "ROC I";
		Subgraph_ROCI.DrawStyle = DRAWSTYLE_IGNORE;

		Subgraph_ROCII.Name = "ROC II";
		Subgraph_ROCII.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_ROCII.PrimaryColor = RGB(0, 0, 255);
		Subgraph_ROCII.DrawZeros = true;

		Subgraph_OverboughtLine.Name = "Overbought Line";
		Subgraph_OverboughtLine.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_OverboughtLine.PrimaryColor = RGB(0, 255, 0);
		Subgraph_OverboughtLine.DrawZeros = true;

		Subgraph_OversoldLine.Name = "Oversold Line";
		Subgraph_OversoldLine.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_OversoldLine.PrimaryColor = RGB(255, 0, 0);
		Subgraph_OversoldLine.DrawZeros = true;

		Subgraph_DurationExceededOverbought.Name = "Duration Exceeded in Overbought Area";
		Subgraph_DurationExceededOverbought.PrimaryColor = RGB(0, 255, 0);
		Subgraph_DurationExceededOverbought.DrawStyle = DRAWSTYLE_ARROW_DOWN;
		Subgraph_DurationExceededOverbought.LineWidth = 2;
		Subgraph_DurationExceededOverbought.DrawZeros = 0;

		Subgraph_DurationExceededOversold.Name = "Duration Exceeded in Oversold Area";
		Subgraph_DurationExceededOversold.PrimaryColor = RGB(255, 0, 0);
		Subgraph_DurationExceededOversold.DrawStyle = DRAWSTYLE_ARROW_UP;
		Subgraph_DurationExceededOversold.LineWidth = 2;
		Subgraph_DurationExceededOversold.DrawZeros = 0;

		Input_InputData.Name = "Input Data";
		Input_InputData.SetInputDataIndex(SC_LAST);

		Input_InputDataHigh.Name = "Input Data High";
		Input_InputDataHigh.SetInputDataIndex(SC_HIGH);

		Input_InputDataLow.Name = "Input Data Low";
		Input_InputDataLow.SetInputDataIndex(SC_LOW);

		Input_ROCLength.Name = "ROC Length";
		Input_ROCLength.SetInt(12);
		Input_ROCLength.SetIntLimits(1, MAX_STUDY_LENGTH);

		Input_HighThreshold.Name = "High Threshold";
		Input_HighThreshold.SetFloat(100.0f);

		Input_LowThreshold.Name = "Low Threshold";
		Input_LowThreshold.SetFloat(100.0f);

		Input_UseSmoothing.Name = "Use Smoothing?";
		Input_UseSmoothing.SetCustomInputStrings
		("No"";Yes");
		Input_UseSmoothing.SetCustomInputIndex(0);

		Input_SmoothingLength.Name = "Smoothing Length";
		Input_SmoothingLength.SetInt(3);
		Input_SmoothingLength.SetIntLimits(1, Input_ROCLength.GetInt());

		Input_SmoothingMAType.Name = "Smoothing MA Type";
		Input_SmoothingMAType.SetMovAvgType(MOVAVGTYPE_SIMPLE);

		Input_UseMovingAverage.Name = "Use Moving Average?";
		Input_UseMovingAverage.SetCustomInputStrings
		("No"";Yes");
		Input_UseMovingAverage.SetCustomInputIndex(0);

		Input_AverageROCMALength.Name = "Average ROC MA Length";
		Input_AverageROCMALength.SetInt(12);
		Input_AverageROCMALength.SetIntLimits(1, MAX_STUDY_LENGTH);

		Input_AverageROCMAType.Name = "Average ROC MA Type";
		Input_AverageROCMAType.SetMovAvgType(MOVAVGTYPE_SIMPLE);

		Input_DurationLength.Name = "Duration Length";
		Input_DurationLength.SetInt(16);
		Input_DurationLength.SetIntLimits(1, MAX_STUDY_LENGTH);

		Input_OffsetPercentage.Name = "Arrow Offset Percentage";
		Input_OffsetPercentage.SetFloat(1.0f);

		Input_OverboughtLineValue.Name = "Overbought Line Value";
		Input_OverboughtLineValue.SetFloat(102.5f);

		Input_OversoldLineValue.Name = "Oversold Line Value";
		Input_OversoldLineValue.SetFloat(97.5f);

		return;
	}

	if (Input_UseSmoothing.GetIndex() == 0 && Input_UseMovingAverage.GetIndex() == 0)
		sc.DataStartIndex = Input_ROCLength.GetInt();
	else if (Input_UseSmoothing.GetIndex() == 1 && Input_UseMovingAverage.GetIndex() == 0)
		sc.DataStartIndex = Input_ROCLength.GetInt() + Input_SmoothingLength.GetInt() - 1;
	else if (Input_UseSmoothing.GetIndex() == 0 && Input_UseMovingAverage.GetIndex() == 1)
		sc.DataStartIndex = Input_ROCLength.GetInt() + Input_AverageROCMALength.GetInt() - 1;
	else
		sc.DataStartIndex = Input_ROCLength.GetInt() + Input_SmoothingLength.GetInt() + Input_AverageROCMALength.GetInt() - 2;

	// Compute ROC I.
	if (sc.Index >= Input_ROCLength.GetInt())
	{
		Subgraph_ROCI[sc.Index] = 100.0f * sc.BaseDataIn[Input_InputData.GetInputDataIndex()][sc.Index] / sc.BaseDataIn[Input_InputData.GetInputDataIndex()][sc.Index - Input_ROCLength.GetInt()];
	}

	//Compute ROC II.
	if (Subgraph_ROCI[sc.Index] > Input_HighThreshold.GetFloat())
		Subgraph_Temp1[sc.Index] = 100.0f * sc.BaseDataIn[Input_InputDataHigh.GetInputDataIndex()][sc.Index] / sc.BaseDataIn[Input_InputDataHigh.GetInputDataIndex()][sc.Index - Input_ROCLength.GetInt()];
	else if (Subgraph_ROCI[sc.Index] < Input_LowThreshold.GetFloat())
		Subgraph_Temp1[sc.Index] = 100.0f * sc.BaseDataIn[Input_InputDataLow.GetInputDataIndex()][sc.Index] / sc.BaseDataIn[Input_InputDataLow.GetInputDataIndex()][sc.Index - Input_ROCLength.GetInt()];
	else
		Subgraph_Temp1[sc.Index] = Subgraph_ROCI[sc.Index];

	if (Input_UseSmoothing.GetIndex() == 1)
		sc.MovingAverage(Subgraph_Temp1, Subgraph_Temp2, Input_SmoothingMAType.GetMovAvgType(), Input_SmoothingLength.GetInt());

	if (Input_UseSmoothing.GetIndex() == 0 && Input_UseMovingAverage.GetIndex() == 0)
		Subgraph_ROCII[sc.Index] = Subgraph_Temp1[sc.Index];
	else if (Input_UseSmoothing.GetIndex() == 1 && Input_UseMovingAverage.GetIndex() == 0)
		Subgraph_ROCII[sc.Index] = Subgraph_Temp2[sc.Index];
	else if (Input_UseSmoothing.GetIndex() == 0 && Input_UseMovingAverage.GetIndex() == 1)
		sc.MovingAverage(Subgraph_Temp1, Subgraph_ROCII, Input_AverageROCMAType.GetMovAvgType(), Input_AverageROCMALength.GetInt());
	else
		sc.MovingAverage(Subgraph_Temp2, Subgraph_ROCII, Input_AverageROCMAType.GetMovAvgType(), Input_AverageROCMALength.GetInt());

	Subgraph_DurationExceededOverbought[sc.Index] = 0.0f;
	Subgraph_DurationExceededOversold[sc.Index] = 0.0f;

	// Perform Duration Analysis.
	if (Subgraph_ROCII[sc.Index] > Input_OverboughtLineValue.GetFloat())
	{
		// Check beginning of chart.
		if (sc.Index == sc.DataStartIndex + Input_DurationLength.GetInt() - 1)
		{
			int OverboughtSum = 1;

			for (int Index = sc.Index - Input_DurationLength.GetInt() + 1; Index <= sc.Index - 1; Index++)
			{
				if (Subgraph_ROCII[Index] > Input_OverboughtLineValue.GetFloat())
					OverboughtSum += 1;
			}

			if (OverboughtSum == Input_DurationLength.GetInt())
			{
				Subgraph_DurationExceededOverbought[sc.Index] =
					Subgraph_ROCII[sc.Index] + 
					(Input_OffsetPercentage.GetFloat() / 100.0f) *
					Subgraph_ROCII[sc.Index];
			}
		}

		int OverboughtIndex = 1;

		while (Subgraph_ROCII[sc.Index - OverboughtIndex] > Input_OverboughtLineValue.GetFloat() && OverboughtIndex <= Input_DurationLength.GetInt())
			OverboughtIndex++;

		if (OverboughtIndex == Input_DurationLength.GetInt() && sc.Index >= sc.DataStartIndex + Input_DurationLength.GetInt() - 1)
		{
			Subgraph_DurationExceededOverbought[sc.Index] =
				Subgraph_ROCII[sc.Index] + 
				(Input_OffsetPercentage.GetFloat() / 100.0f) *
				Subgraph_ROCII[sc.Index];
		}
	}

	if (Subgraph_ROCII[sc.Index] < Input_OversoldLineValue.GetFloat())
	{
		// Check beginning of chart.
		if (sc.Index == sc.DataStartIndex + Input_DurationLength.GetInt() - 1)
		{
			int OversoldSum = 1;

			for (int Index = sc.Index - Input_DurationLength.GetInt() + 1; Index <= sc.Index - 1; Index++)
			{
				if (Subgraph_ROCII[Index] < Input_OversoldLineValue.GetFloat())
					OversoldSum += 1;
			}

			if (OversoldSum == Input_DurationLength.GetInt())
			{
				Subgraph_DurationExceededOversold[sc.Index] =
					Subgraph_ROCII[sc.Index] - 
					(Input_OffsetPercentage.GetFloat() / 100.0f) *
					Subgraph_ROCII[sc.Index];
			}
		}

		int OversoldIndex = 1;

		while (Subgraph_ROCII[sc.Index - OversoldIndex] < Input_OversoldLineValue.GetFloat() && OversoldIndex <= Input_DurationLength.GetInt())
			OversoldIndex++;

		if (OversoldIndex == Input_DurationLength.GetInt() && sc.Index >= sc.DataStartIndex + Input_DurationLength.GetInt() - 1)
		{
			Subgraph_DurationExceededOversold[sc.Index] =
				Subgraph_ROCII[sc.Index] - 
				(Input_OffsetPercentage.GetFloat() / 100.0f) * 
				Subgraph_ROCII[sc.Index];
		}
	}

	// Set horizontal lines.
	Subgraph_OverboughtLine[sc.Index] = Input_OverboughtLineValue.GetFloat();
	Subgraph_OversoldLine[sc.Index] = Input_OversoldLineValue.GetFloat();
}

/*==========================================================================*/
SCSFExport scsf_GetStudyDataColorArrayFromChartUsingIDExample(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_ColorBar = sc.Subgraph[0];
	SCInputRef Input_ChartStudySubgraph = sc.Input[0];

	if (sc.SetDefaults)
	{
		// Set the configuration and defaults

		sc.GraphName = "GetStudyDataColorArrayFromChartUsingID Example";

		sc.AutoLoop = 0;

		sc.GraphRegion = 0;

		Subgraph_ColorBar.Name = "Bar";
		Subgraph_ColorBar.DrawStyle = DRAWSTYLE_COLOR_BAR;
		Subgraph_ColorBar.PrimaryColor = RGB(200, 200, 0);

		Input_ChartStudySubgraph.Name = "Study Subgraph Reference";
		Input_ChartStudySubgraph.SetChartStudySubgraphValues(1, 1, 0);

		sc.CalculationPrecedence = LOW_PREC_LEVEL;

		return;
	}


	// Do data processing


	SCColorArray DataColorArray;
	sc.GetStudyDataColorArrayFromChartUsingID(Input_ChartStudySubgraph.GetChartNumber(), Input_ChartStudySubgraph.GetStudyID(), Input_ChartStudySubgraph.GetSubgraphIndex(), DataColorArray);

	if (DataColorArray.GetArraySize() > 0)
	{
		for (int BarIndex = sc.UpdateStartIndex; BarIndex < sc.ArraySize; BarIndex++)
		{

			Subgraph_ColorBar[BarIndex] = 1;
			Subgraph_ColorBar.DataColor[BarIndex] = DataColorArray[BarIndex];

		}
	}


}


/*==========================================================================*/
SCSFExport scsf_ApplyStudyCollectionExample(SCStudyInterfaceRef sc)
{

	if (sc.SetDefaults)
	{
		// Set the configuration and defaults

		sc.GraphName = "Apply Study Collection Example";

		sc.AutoLoop = 0;

		return;
	}


	//if (sc.IsFullRecalculation)
	//	return;

	int& r_IsStudyCollectionApplied = sc.GetPersistentInt(1);

	if (r_IsStudyCollectionApplied)
		return;

	sc.ApplyStudyCollection(sc.ChartNumber, "Volume", 0);

	r_IsStudyCollectionApplied = 1;

}

/*============================================================================

----------------------------------------------------------------------------*/
SCSFExport scsf_FileFunctionsExample(SCStudyInterfaceRef sc)
{

	SCSubgraphRef FirstSubgraph = sc.Subgraph[0];

	if (sc.SetDefaults)
	{
		// Set the configuration and defaults

		sc.GraphName = "File Functions Example";

		sc.AutoLoop = 0;
		sc.GraphRegion = 0;

		return;
	}

	if (sc.IsFullRecalculation && sc.UpdateStartIndex == 0)
	{
		int FileHandle = 0;
		SCString PathAndFileName = sc.DataFilesFolder();
		PathAndFileName += "Testing.txt";
		sc.OpenFile(PathAndFileName, n_ACSIL::FILE_MODE_OPEN_TO_APPEND, FileHandle);
		unsigned int BytesWritten;
		const char* TestLine = "Test Line\r\n";
		sc.WriteFile(FileHandle, TestLine, static_cast<int>(strlen(TestLine)), &BytesWritten);
		sc.CloseFile(FileHandle);
	}


}


/*==========================================================================*/
SCSFExport scsf_VolumeByPriceResetButton(SCStudyInterfaceRef sc)
{
	SCInputRef Input_VolumeByPriceStudy = sc.Input[0];
	SCInputRef Input_ControlBarButtonNumberForEnableDisable = sc.Input[1];


	if (sc.SetDefaults)
	{
		// Set the configuration and defaults

		sc.GraphName = "Volume By Price Reset Button";

		sc.AutoLoop = 0;  // manual looping
		sc.GraphRegion = 0;

		Input_VolumeByPriceStudy.Name = "Volume By Price Study Reference";
		Input_VolumeByPriceStudy.SetStudyID(0);

		Input_ControlBarButtonNumberForEnableDisable.Name = "ACS Control Bar Button # for Reset";
		Input_ControlBarButtonNumberForEnableDisable.SetInt(1);
		Input_ControlBarButtonNumberForEnableDisable.SetIntLimits(1, MAX_ACS_CONTROL_BAR_BUTTONS);


		return;
	}

	if (sc.MenuEventID == Input_ControlBarButtonNumberForEnableDisable.GetInt())
	{
		const int ButtonState = (sc.PointerEventType == SC_ACS_BUTTON_ON) ? 1 : 0;
		if (ButtonState == 1)
		{
			sc.SetCustomStudyControlBarButtonEnable(Input_ControlBarButtonNumberForEnableDisable.GetInt(), 0);

			sc.SetChartStudyInputFloat(sc.ChartNumber, Input_VolumeByPriceStudy.GetStudyID(), 36, sc.GetCurrentDateTime().GetDateAsSCDateTime().GetAsDouble());

			sc.SetChartStudyInputFloat(sc.ChartNumber, Input_VolumeByPriceStudy.GetStudyID(), 38, sc.GetCurrentDateTime().GetTimeAsSCDateTime().GetAsDouble());

			// Set the 'Volume Graph Period Type' to: 'From Start Date-Time To End'.
			sc.SetChartStudyInputInt(sc.ChartNumber, Input_VolumeByPriceStudy.GetStudyID(), 32, 5);

			sc.RecalculateChart(sc.ChartNumber);
		}
	}

}


/*==========================================================================*/
SCSFExport scsf_MESAAdaptiveMovingAverage(SCStudyGraphRef sc)
{

	SCSubgraphRef Subgraph_MAMA = sc.Subgraph[0];
	SCSubgraphRef Subgraph_FAMA = sc.Subgraph[1];
	SCSubgraphRef Subgraph_Smooth = sc.Subgraph[2];
	SCSubgraphRef Subgraph_Detrender = sc.Subgraph[3];
	SCSubgraphRef Subgraph_Q1 = sc.Subgraph[4];
	SCSubgraphRef Subgraph_I1 = sc.Subgraph[5];
	SCSubgraphRef Subgraph_jI = sc.Subgraph[6];
	SCSubgraphRef Subgraph_jQ = sc.Subgraph[7];
	SCSubgraphRef Subgraph_I2 = sc.Subgraph[8];
	SCSubgraphRef Subgraph_Q2 = sc.Subgraph[9];
	SCSubgraphRef Subgraph_Re = sc.Subgraph[10];
	SCSubgraphRef Subgraph_Im = sc.Subgraph[11];
	SCSubgraphRef Subgraph_Period = sc.Subgraph[12];
	SCSubgraphRef Subgraph_Phase = sc.Subgraph[13];
	SCSubgraphRef Subgraph_SmoothPeriod = sc.Subgraph[14];

#define GREEN RGB(0,255,0)
#define RED RGB(255,0,0)
#define BLACK RGB(0,0,1)
#define WHITE RGB(255,255,255)
#define PURPLE RGB(255,0,255)
#define GREY RGB(192,192,192)
#define BLUE RGB(0,128,255)
#define ORANGE RGB(255, 127, 0)

	if (sc.SetDefaults)
	{
		// Set the configuration and defaults

		sc.GraphName = "MESA Adaptive Moving Average";
		sc.StudyDescription = "MAMA";
		//sg.FreeDLL = 0;

		sc.AutoLoop = 1;  // true

		sc.GraphRegion = 0;

		// Set the name of the first subgraph
		sc.Subgraph[0].Name = "MAMA";
		sc.Subgraph[0].PrimaryColor = RED;
		sc.Subgraph[0].DrawStyle = DRAWSTYLE_LINE;
		sc.Subgraph[0].LineWidth = 2;

		sc.Subgraph[1].Name = "FAMA";
		sc.Subgraph[1].PrimaryColor = GREEN;
		sc.Subgraph[1].DrawStyle = DRAWSTYLE_LINE;
		sc.Subgraph[1].LineWidth = 2;

		sc.Subgraph[14].Name = "Period";
		sc.Subgraph[14].PrimaryColor = GREEN;
		sc.Subgraph[14].DrawStyle = DRAWSTYLE_IGNORE;
		sc.Subgraph[14].LineWidth = 2;

		sc.Input[0].Name = "Input Data";
		sc.Input[0].SetInputDataIndex(SC_HL);

		sc.Input[1].Name = "Fast Limit";
		sc.Input[1].SetFloat(0.5);

		sc.Input[2].Name = "Slow Limit";
		sc.Input[2].SetFloat(0.05f);

		return;
	}

	int BarIndex;
	float FastLimit = sc.Input[1].FloatValue;
	float SlowLimit = sc.Input[2].FloatValue;
	float alpha, DeltaPhase;

	SCFloatArrayRef Price = sc.BaseDataIn[sc.Input[0].GetInputDataIndex()];

	sc.DataStartIndex = 50;
	BarIndex = sc.CurrentIndex;

	// smooth
	Subgraph_Smooth[BarIndex] = (4 * Price[BarIndex] + 3 * Price[BarIndex - 1] + 2 * Price[BarIndex - 2] + Price[BarIndex - 3]) / 10;

	// detrender
	Subgraph_Detrender[BarIndex] = (0.0962f*Subgraph_Smooth[BarIndex] + 0.5769f*Subgraph_Smooth[BarIndex - 2] - 0.5769f*Subgraph_Smooth[BarIndex - 4] - 0.0962f*Subgraph_Smooth[BarIndex - 6])*(0.075f*Subgraph_Period[BarIndex - 1] + 0.54f);

	// compute InPhase and Quadrature components
	Subgraph_Q1[BarIndex] = (0.0962f*Subgraph_Detrender[BarIndex] + 0.5769f*Subgraph_Detrender[BarIndex - 2] - 0.5769f*Subgraph_Detrender[BarIndex - 4] - 0.0962f*Subgraph_Detrender[BarIndex - 6])*(0.075f*Subgraph_Period[BarIndex - 1] + 0.54f);
	Subgraph_I1[BarIndex] = Subgraph_Detrender[BarIndex - 3];

	// Advance the phase of I1 and Q1 by 90 degrees
	Subgraph_jI[BarIndex] = (0.0962f*Subgraph_I1[BarIndex] + 0.5769f*Subgraph_I1[BarIndex - 2] - 0.5769f*Subgraph_I1[BarIndex - 4] - 0.0962f*Subgraph_I1[BarIndex - 6])*(0.075f*Subgraph_Period[BarIndex - 1] + 0.54f);
	Subgraph_jQ[BarIndex] = (0.0962f*Subgraph_Q1[BarIndex] + 0.5769f*Subgraph_Q1[BarIndex - 2] - 0.5769f*Subgraph_Q1[BarIndex - 4] - 0.0962f*Subgraph_Q1[BarIndex - 6])*(0.075f*Subgraph_Period[BarIndex - 1] + 0.54f);

	// Phasor addition for 3 bar averaging
	Subgraph_I2[BarIndex] = Subgraph_I1[BarIndex] - Subgraph_jQ[BarIndex];
	Subgraph_Q2[BarIndex] = Subgraph_Q1[BarIndex] + Subgraph_jI[BarIndex];

	// Smooth the I and Q components before applying the discriminator
	Subgraph_I2[BarIndex] = 0.2f*Subgraph_I2[BarIndex] + 0.8f*Subgraph_I2[BarIndex - 1];
	Subgraph_Q2[BarIndex] = 0.2f*Subgraph_Q2[BarIndex] + 0.8f*Subgraph_Q2[BarIndex - 1];

	// Homodyne Discriminator
	Subgraph_Re[BarIndex] = Subgraph_I2[BarIndex] * Subgraph_I2[BarIndex - 1] + Subgraph_Q2[BarIndex] * Subgraph_Q2[BarIndex - 1];
	Subgraph_Im[BarIndex] = Subgraph_I2[BarIndex] * Subgraph_Q2[BarIndex - 1] - Subgraph_Q2[BarIndex] * Subgraph_I2[BarIndex - 1];
	Subgraph_Re[BarIndex] = 0.2f*Subgraph_Re[BarIndex] + 0.8f*Subgraph_Re[BarIndex - 1];
	Subgraph_Im[BarIndex] = 0.2f*Subgraph_Im[BarIndex] + 0.8f*Subgraph_Im[BarIndex - 1];

	if (Subgraph_Im[BarIndex] != 0.0 && Subgraph_Re[BarIndex] != 0.0)
		Subgraph_Period[BarIndex] = 360 / (57.3f*atan(Subgraph_Im[BarIndex] / Subgraph_Re[BarIndex]));
	if (Subgraph_Period[BarIndex] > 1.5f*Subgraph_Period[BarIndex - 1])
		Subgraph_Period[BarIndex] = 1.5f*Subgraph_Period[BarIndex - 1];
	if (Subgraph_Period[BarIndex] < 0.67f*Subgraph_Period[BarIndex - 1])
		Subgraph_Period[BarIndex] = 0.67f*Subgraph_Period[BarIndex - 1];
	if (Subgraph_Period[BarIndex] < 6)
		Subgraph_Period[BarIndex] = 6;
	if (Subgraph_Period[BarIndex] > 50)
		Subgraph_Period[BarIndex] = 50;
	Subgraph_Period[BarIndex] = 0.2f*Subgraph_Period[BarIndex] + 0.8f*Subgraph_Period[BarIndex - 1];
	Subgraph_SmoothPeriod[BarIndex] = 0.33f*Subgraph_Period[BarIndex] + 0.67f*Subgraph_SmoothPeriod[BarIndex - 1];

	if (Subgraph_I1[BarIndex] != 0)
		Subgraph_Phase[BarIndex] = 57.3f*atan(Subgraph_Q1[BarIndex] / Subgraph_I1[BarIndex]);

	DeltaPhase = Subgraph_Phase[BarIndex - 1] - Subgraph_Phase[BarIndex];

	if (DeltaPhase < 1) DeltaPhase = 1;

	alpha = FastLimit / DeltaPhase;
	if (alpha < SlowLimit) alpha = SlowLimit;

	Subgraph_MAMA[BarIndex] = alpha * Price[BarIndex] + (1 - alpha)*Subgraph_MAMA[BarIndex - 1];
	Subgraph_FAMA[BarIndex] = 0.5f*alpha*Subgraph_MAMA[BarIndex] + (1 - 0.5f*alpha)*Subgraph_FAMA[BarIndex - 1];
}

/*==========================================================================*/
SCSFExport scsf_FibonacciBands(SCStudyInterfaceRef sc)
{
	if (sc.SetDefaults)
	{
		sc.GraphName = "Fibonacci Bands";
		sc.GraphRegion = 0;
		sc.Subgraph[0].Name = "MA";
		sc.Subgraph[1].Name = "U1";
		sc.Subgraph[2].Name = "L1";
		sc.Subgraph[3].Name = "U2";
		sc.Subgraph[4].Name = "L2";
		sc.Subgraph[4].DrawStyle = DRAWSTYLE_LINE;
		sc.Subgraph[5].Name = "U3";
		sc.Subgraph[5].DrawStyle = DRAWSTYLE_LINE;
		sc.Subgraph[6].Name = "L3";
		sc.Subgraph[6].DrawStyle = DRAWSTYLE_LINE;

		sc.Input[0].Name = "Study And Subgraph Reference";
		sc.Input[0].SetStudySubgraphValues(0, SC_LAST);

		sc.Input[2].Name = "Moving Average Type";
		sc.Input[2].SetMovAvgType(MOVAVGTYPE_EXPONENTIAL);

		sc.Input[3].Name = "True Range Moving Average Type";
		sc.Input[3].SetMovAvgType(MOVAVGTYPE_EXPONENTIAL);

		sc.Input[4].Name = "Moving Average Length";
		sc.Input[4].SetInt(8);

		sc.Input[5].Name = "ATR Moving Average Length";
		sc.Input[5].SetInt(14);

		sc.Input[6].Name = "Fib 1";
		sc.Input[6].SetFloat(0.382f);
		
		sc.Input[7].Name = "Fib 2";
		sc.Input[7].SetFloat(0.618f);

		sc.Input[8].Name = "Fib 3";
		sc.Input[8].SetFloat(1.0f);

		sc.CalculationPrecedence = LOW_PREC_LEVEL;
		sc.AutoLoop = 0;
		return;
	}

	SCFloatArray SubgraphArray;
	sc.GetStudyArrayUsingID(sc.Input[0].GetStudyID(), sc.Input[0].GetSubgraphIndex(), SubgraphArray);

	for (int BarIndex = sc.UpdateStartIndex; BarIndex < sc.ArraySize; ++BarIndex)
	{
		sc.MovingAverage(SubgraphArray, sc.Subgraph[0], sc.Input[2].GetMovAvgType(), BarIndex, sc.Input[4].GetInt());
		sc.ATR(sc.BaseDataIn, sc.Subgraph[8], BarIndex, sc.Input[5].GetInt(), sc.Input[3].GetMovAvgType());

		float Gap = sc.Subgraph[8][BarIndex];
		float t1 = sc.Subgraph[0][BarIndex] + sc.Input[6].FloatValue*Gap;
		float b1 = sc.Subgraph[0][BarIndex] - sc.Input[6].FloatValue*Gap;
		float t2 = sc.Subgraph[0][BarIndex] + sc.Input[7].FloatValue*Gap;
		float b2 = sc.Subgraph[0][BarIndex] - sc.Input[7].FloatValue*Gap;
		float t3 = sc.Subgraph[0][BarIndex] + sc.Input[8].FloatValue*Gap;
		float b3 = sc.Subgraph[0][BarIndex] - sc.Input[8].FloatValue*Gap;

		sc.Subgraph[1][BarIndex] = t1;
		sc.Subgraph[2][BarIndex] = b1;
		sc.Subgraph[3][BarIndex] = t2;
		sc.Subgraph[4][BarIndex] = b2;
		sc.Subgraph[5][BarIndex] = t3;
		sc.Subgraph[6][BarIndex] = b3;
	}

}


/*============================================================================
	
----------------------------------------------------------------------------*/
SCSFExport scsf_TradeQuantityGraph(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_TradeQuantity = sc.Subgraph[0];

	if (sc.SetDefaults)
	{
		// Set the configuration and defaults

		sc.GraphName = "Trade Quantity Graph";

		sc.AutoLoop = 0;

		sc.GraphRegion = 1;
		sc.UpdateAlways = 1;

		Subgraph_TradeQuantity.Name = "Quantity";
		Subgraph_TradeQuantity.DrawStyle = DRAWSTYLE_LINE;
		Subgraph_TradeQuantity.LineWidth = 2;
		Subgraph_TradeQuantity.PrimaryColor = RGB(200, 200, 0);
		return;
	}


	// Do data processing
	for (int BarIndex = sc.UpdateStartIndex; BarIndex < sc.ArraySize; BarIndex++)
	{
		Subgraph_TradeQuantity.Data[BarIndex] = static_cast<float>(sc.TradeWindowOrderQuantity);
	}

}


/*==========================================================================*/
SCSFExport scsf_RolloverDateDisplay(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_Clock = sc.Subgraph[0];

	SCInputRef Input_HorizontalPosition = sc.Input[0];
	SCInputRef Input_VerticalPosition = sc.Input[1];
	SCInputRef Input_DrawAboveMainPriceGraph = sc.Input[4];
	SCInputRef Input_UseBoldFont = sc.Input[5];
	SCInputRef Input_TransparentLabelBackground = sc.Input[7];

	if (sc.SetDefaults)
	{
		// Set the configuration and defaults

		sc.GraphName =  "Rollover Date Display";

		sc.AutoLoop = 0;//Manual looping
		sc.GraphRegion = 0;
		sc.ValueFormat = 0;

		Subgraph_Clock.Name = "Date";
		Subgraph_Clock.LineWidth = 10;
		Subgraph_Clock.DrawStyle = DRAWSTYLE_CUSTOM_TEXT;
		Subgraph_Clock.PrimaryColor = RGB(0, 200, 0);
		Subgraph_Clock.SecondaryColor = RGB(0, 0, 0);
		Subgraph_Clock.SecondaryColorUsed = true;
		Subgraph_Clock.DisplayNameValueInWindowsFlags = 1;

		Input_HorizontalPosition.Name.Format("Initial Horizontal Position From Left (1-%d)", static_cast<int>(CHART_DRAWING_MAX_HORIZONTAL_AXIS_RELATIVE_POSITION));
		Input_HorizontalPosition.SetInt(20);
		Input_HorizontalPosition.SetIntLimits(1, static_cast<int>(CHART_DRAWING_MAX_HORIZONTAL_AXIS_RELATIVE_POSITION));

		Input_VerticalPosition.Name.Format("Initial Vertical Position From Bottom (1-%d)", static_cast<int>(CHART_DRAWING_MAX_VERTICAL_AXIS_RELATIVE_POSITION));
		Input_VerticalPosition.SetInt(90);
		Input_VerticalPosition.SetIntLimits(1, static_cast<int>(CHART_DRAWING_MAX_VERTICAL_AXIS_RELATIVE_POSITION));


		Input_DrawAboveMainPriceGraph.Name = "Draw Above Main Price Graph";
		Input_DrawAboveMainPriceGraph.SetYesNo(false);

		Input_UseBoldFont.Name = "Use Bold Font";
		Input_UseBoldFont.SetYesNo(true);

		Input_TransparentLabelBackground.Name = "Transparent Label Background";
		Input_TransparentLabelBackground.SetYesNo(true);

		return;
	}

	SCString  DateString ("Rollover: ");
	DateString += sc.DateToString(sc.ContractRolloverDate);

	int HorizontalPosition = Input_HorizontalPosition.GetInt();
	int VerticalPosition = Input_VerticalPosition.GetInt();

	int DrawAboveMainPriceGraph = Input_DrawAboveMainPriceGraph.GetYesNo();

	int TransparentLabelBackground = Input_TransparentLabelBackground.GetYesNo();
	int UseBoldFont = Input_UseBoldFont.GetYesNo();

	sc.AddAndManageSingleTextUserDrawnDrawingForStudy(sc, 0, HorizontalPosition, VerticalPosition, Subgraph_Clock, TransparentLabelBackground, DateString, DrawAboveMainPriceGraph, 0, UseBoldFont);
}


/*============================================================================

----------------------------------------------------------------------------*/
SCSFExport scsf_VolumePointOfControlForBars(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_VPOC = sc.Subgraph[0];

	if (sc.SetDefaults)
	{
		// Set the configuration and defaults

		sc.GraphName = "Volume Point of Control for Bars";

		sc.AutoLoop = 0;
		sc.MaintainVolumeAtPriceData = true;

		sc.GraphRegion = 0;

		Subgraph_VPOC.Name = "VPOC";
		Subgraph_VPOC.DrawStyle = DRAWSTYLE_SQUARE_OFFSET_LEFT_FOR_CANDLESTICK;
		Subgraph_VPOC.LineWidth = 8;
		Subgraph_VPOC.PrimaryColor = RGB(255, 128, 0);
		return;
	}


	// Do data processing
	for (int BarIndex = sc.UpdateStartIndex; BarIndex < sc.ArraySize; BarIndex++)
	{
		s_VolumeAtPriceV2 VolumeAtPrice;
		sc.GetPointOfControlPriceVolumeForBar(BarIndex, VolumeAtPrice);

		if (VolumeAtPrice.PriceInTicks != 0)
		{
			Subgraph_VPOC.Data[BarIndex]
				= static_cast<float>
					( sc.TicksToPriceValue(VolumeAtPrice.PriceInTicks)
					);
		}
	}

}

/*============================================================================

----------------------------------------------------------------------------*/
SCSFExport scsf_ValueAreaForBars(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_ValueAreaHigh = sc.Subgraph[0];
	SCSubgraphRef Subgraph_ValueAreaLow = sc.Subgraph[1];
	
	SCInputRef Input_ValueAreaPercentage = sc.Input[0];

	if (sc.SetDefaults)
	{
		// Set the configuration and defaults

		sc.GraphName = "Volume Value Area for Bars";

		sc.AutoLoop = 0;
		sc.MaintainVolumeAtPriceData = true;

		sc.GraphRegion = 0;

		Subgraph_ValueAreaHigh.Name = "VAH";
		Subgraph_ValueAreaHigh.DrawStyle = DRAWSTYLE_SQUARE_OFFSET_LEFT_FOR_CANDLESTICK;
		Subgraph_ValueAreaHigh.LineWidth = 8;
		Subgraph_ValueAreaHigh.PrimaryColor = RGB(255, 128, 0);

		Subgraph_ValueAreaLow.Name = "VAL";
		Subgraph_ValueAreaLow.DrawStyle = DRAWSTYLE_SQUARE_OFFSET_LEFT_FOR_CANDLESTICK;
		Subgraph_ValueAreaLow.LineWidth = 8;
		Subgraph_ValueAreaLow.PrimaryColor = RGB(255, 0, 128);

		Input_ValueAreaPercentage.Name = "Value Area Percentage";
		Input_ValueAreaPercentage.SetFloat(70.0f);


		return;
	}


	// Do data processing
	for (int BarIndex = sc.UpdateStartIndex; BarIndex < sc.ArraySize; BarIndex++)
	{
		double PointOfControl = 0.0f;
		double ValueAreaHigh = 0.0f;
		double ValueAreaLow = 0.0f;

		sc.GetPointOfControlAndValueAreaPricesForBar(BarIndex, PointOfControl, ValueAreaHigh, ValueAreaLow, Input_ValueAreaPercentage.GetFloat());


		Subgraph_ValueAreaHigh.Data[BarIndex] = static_cast <float> (ValueAreaHigh);
		Subgraph_ValueAreaLow.Data[BarIndex] = static_cast <float> (ValueAreaLow);
	}

}


/*============================================================================

----------------------------------------------------------------------------*/
SCSFExport scsf_ElderImpulse(SCStudyInterfaceRef sc)
{
	SCSubgraphRef Subgraph_MovAvg = sc.Subgraph[0];
	SCSubgraphRef Subgraph_FastMovAvg = sc.Subgraph[1];
	SCSubgraphRef Subgraph_SlowMovAvg = sc.Subgraph[2];
	SCSubgraphRef Subgraph_MACD = sc.Subgraph[3];
	SCSubgraphRef Subgraph_MovAvgOfMACD = sc.Subgraph[4];
	SCSubgraphRef Subgraph_MACDDiff = sc.Subgraph[5];
	SCSubgraphRef Subgraph_ColorBar = sc.Subgraph[6];

	SCInputRef Input_InputData = sc.Input[0];
	SCInputRef Input_MovAvgLength = sc.Input[1];
	SCInputRef Input_FastLength = sc.Input[2];
	SCInputRef Input_SlowLength = sc.Input[3];
	SCInputRef Input_MACDLength = sc.Input[4];
	SCInputRef Input_MovingAverageType = sc.Input[5];
	SCInputRef Input_MACDMovingAverageType = sc.Input[6];
	SCInputRef Input_Color1 = sc.Input[7];
	SCInputRef Input_Color2 = sc.Input[8];
	SCInputRef Input_Color3 = sc.Input[9];

	if (sc.SetDefaults)
	{
		sc.GraphName = "Elder Impulse";

		sc.ValueFormat = VALUEFORMAT_INHERITED;
		sc.GraphRegion = 0;
		sc.AutoLoop = 1;
		sc.GraphDrawType = GDT_CUSTOM;

		Subgraph_MovAvg.Name = "Moving Average of Input Data";
		Subgraph_MovAvg.DrawStyle = DRAWSTYLE_IGNORE;

		Subgraph_FastMovAvg.Name = "Fast Moving Average";
		Subgraph_FastMovAvg.DrawStyle = DRAWSTYLE_IGNORE;

		Subgraph_SlowMovAvg.Name = "Slow Moving Average";
		Subgraph_SlowMovAvg.DrawStyle = DRAWSTYLE_IGNORE;

		Subgraph_MACD.Name = "MACD";
		Subgraph_MACD.DrawStyle = DRAWSTYLE_IGNORE;

		Subgraph_MovAvgOfMACD.Name = "MA of MACD";
		Subgraph_MovAvgOfMACD.DrawStyle = DRAWSTYLE_IGNORE;

		Subgraph_MACDDiff.Name = "MACD Diff";
		Subgraph_MACDDiff.DrawStyle = DRAWSTYLE_IGNORE;

		Subgraph_ColorBar.Name = "Color Bar";
		Subgraph_ColorBar.DrawStyle = DRAWSTYLE_COLORBAR;
		Subgraph_ColorBar.DrawZeros = false;

		Input_InputData.Name = "Input Data";
		Input_InputData.SetInputDataIndex(SC_LAST);

		Input_MovAvgLength.Name = "Moving Average Length";
		Input_MovAvgLength.SetInt(13);
		Input_MovAvgLength.SetIntLimits(1, MAX_STUDY_LENGTH);

		Input_FastLength.Name = "Fast Moving Average Length";
		Input_FastLength.SetInt(12);
		Input_FastLength.SetIntLimits(1, MAX_STUDY_LENGTH);

		Input_SlowLength.Name = "Slow Moving Average Length";
		Input_SlowLength.SetInt(26);
		Input_SlowLength.SetIntLimits(1, MAX_STUDY_LENGTH);

		Input_MACDLength.Name = "MACD Moving Average Length";
		Input_MACDLength.SetInt(9);
		Input_MACDLength.SetIntLimits(1, MAX_STUDY_LENGTH);

		Input_MovingAverageType.Name = "Moving Average Type";
		Input_MovingAverageType.SetMovAvgType(MOVAVGTYPE_EXPONENTIAL);

		Input_MACDMovingAverageType.Name = "MACD Moving Average Type";
		Input_MACDMovingAverageType.SetMovAvgType(MOVAVGTYPE_EXPONENTIAL);

		Input_Color1.Name = "Color 1";
		Input_Color1.SetColor(BLUE);

		Input_Color2.Name = "Color 2";
		Input_Color2.SetColor(GREEN);

		Input_Color3.Name = "Color 3";
		Input_Color3.SetColor(RED);

		return;
	}

	sc.MovingAverage(sc.BaseDataIn[Input_InputData.GetInputDataIndex()], Subgraph_MovAvg, Input_MovingAverageType.GetMovAvgType(), Input_MovAvgLength.GetInt());

	sc.MovingAverage(sc.BaseDataIn[Input_InputData.GetInputDataIndex()], Subgraph_FastMovAvg, Input_MACDMovingAverageType.GetMovAvgType(), Input_FastLength.GetInt());
	sc.MovingAverage(sc.BaseDataIn[Input_InputData.GetInputDataIndex()], Subgraph_SlowMovAvg, Input_MACDMovingAverageType.GetMovAvgType(), Input_SlowLength.GetInt());

	Subgraph_MACD[sc.Index] = Subgraph_FastMovAvg[sc.Index] - Subgraph_SlowMovAvg[sc.Index];

	sc.MovingAverage(Subgraph_MACD, Subgraph_MovAvgOfMACD, Input_MACDMovingAverageType.GetMovAvgType(), Input_MACDLength.GetInt());

	Subgraph_MACDDiff[sc.Index] = Subgraph_MACD[sc.Index] - Subgraph_MovAvgOfMACD[sc.Index];

	Subgraph_ColorBar[sc.Index] = 0;

	if (Subgraph_MovAvg[sc.Index] > Subgraph_MovAvg[sc.Index - 1] && Subgraph_MACDDiff[sc.Index] > Subgraph_MACDDiff[sc.Index - 1])
	{
		Subgraph_ColorBar[sc.Index] = 1;
		Subgraph_ColorBar.DataColor[sc.Index] = Input_Color2.GetColor();
	}
	else if (Subgraph_MovAvg[sc.Index] < Subgraph_MovAvg[sc.Index - 1] && Subgraph_MACDDiff[sc.Index] < Subgraph_MACDDiff[sc.Index - 1])
	{
		Subgraph_ColorBar[sc.Index] = 1;
		Subgraph_ColorBar.DataColor[sc.Index] = Input_Color3.GetColor();
	}
	else
	{
		Subgraph_ColorBar[sc.Index] = 1;
		Subgraph_ColorBar.DataColor[sc.Index] = Input_Color1.GetColor();
	}
}

/*==========================================================================*/
SCSFExport scsf_OneTimeInitializationExample(SCStudyInterfaceRef sc)
{

	if (sc.SetDefaults)
	{
		// Set the configuration and defaults

		sc.GraphName = "One Time Initialization Example";

		sc.AutoLoop = 0;

		return;
	}

	int& r_IsInitialized = sc.GetPersistentInt(1);

	if (!r_IsInitialized)
	{
		//Perform initialization here

		r_IsInitialized = 1;
	}

	if (sc.LastCallToFunction)
	{
		if (r_IsInitialized)
		{
			//Perform uninitialization here

			r_IsInitialized = 0;
		}

		return;
	}


	//Do standard processing here


}

/*============================================================================
	
----------------------------------------------------------------------------*/
SCSFExport scsf_IsLastBarClosedBasedOnElapsedTimeExample(SCStudyInterfaceRef sc)
{
	if (sc.SetDefaults)
	{
		// Set the configuration and defaults

		sc.GraphName = "IsLastBarClosedBasedOnElapsedTime Example";

		sc.StudyDescription = "Example of IsLastBarClosedBasedOnElapsedTime function.";

		sc.AutoLoop = 1;
		sc.UpdateAlways = 1;
		return;
	}


	// Do data processing
	if (sc.Index == sc.ArraySize - 1)
	{
		int IsClosed = sc.IsLastBarClosedBasedOnElapsedTime(sc.ChartNumber);
		SCString MessageText("sc.IsLastBarClosedBasedOnElapsedTime=");
		MessageText.AppendFormat("%d", IsClosed);
		sc.AddMessageToLog(MessageText, 0);
	}

}

/*============================================================================
	
----------------------------------------------------------------------------*/
SCSFExport scsf_MarketLimitOrdersForPriceExample(SCStudyInterfaceRef sc)
{
	if (sc.SetDefaults)
	{
		// Set the configuration and defaults

		sc.GraphName = "MarketLimitOrdersForPrice Example";

		sc.AutoLoop = 0;
		return;
	}


	// Do data processing
	int BidNumLevels = sc.GetBidMarketDepthNumberOfLevels();
	int AskNumLevels = sc.GetAskMarketDepthNumberOfLevels();

	const int NumberOfMarketOrderDataElements = 20;
	n_ACSIL::s_MarketOrderData MarketOrderData[NumberOfMarketOrderDataElements];
		
	for (int LevelIndex = 0; LevelIndex < BidNumLevels; LevelIndex++)
	{
		s_MarketDepthEntry MarketDepthEntry;
		sc.GetBidMarketDepthEntryAtLevel(MarketDepthEntry, LevelIndex);

		int ActualLevels = sc.GetBidMarketLimitOrdersForPrice(sc.Round(MarketDepthEntry.AdjustedPrice / sc.TickSize), NumberOfMarketOrderDataElements, MarketOrderData);

		for (int OrderDataIndex = 0; OrderDataIndex < ActualLevels; OrderDataIndex++)
		{
			uint64_t OrderID = MarketOrderData[OrderDataIndex].OrderID;
			t_MarketDataQuantity MarketDataQuantity = MarketOrderData[OrderDataIndex].OrderQuantity;
		}

	}

	for (int LevelIndex = 0; LevelIndex < AskNumLevels; LevelIndex++)
	{
		s_MarketDepthEntry MarketDepthEntry;
		sc.GetAskMarketDepthEntryAtLevel(MarketDepthEntry, LevelIndex);

		int ActualLevels = sc.GetAskMarketLimitOrdersForPrice(sc.Round(MarketDepthEntry.AdjustedPrice / sc.TickSize), NumberOfMarketOrderDataElements, MarketOrderData);

		for (int OrderDataIndex = 0; OrderDataIndex < ActualLevels; OrderDataIndex++)
		{
			uint64_t OrderID = MarketOrderData[OrderDataIndex].OrderID;
			t_MarketDataQuantity MarketDataQuantity = MarketOrderData[OrderDataIndex].OrderQuantity;
		}

	}

}