Please Fix Error 2 Warning
- Please edit your (original) post and use the CODE
button (Alt-S)! (For large amounts of code, attach it.)
General rules and best pratices of the Forum. - General - MQL5 programming forum
Messages Editor - You know what the problem is - switch requires an int, not a double.
//double direct; int direct;
this should fix it
lippmaje:
this should fix it
Thank you sir, Its working
You are missing trading opportunities:
- Free trading apps
- Over 8,000 signals for copying
- Economic news for exploring financial markets
Registration
Log in
You agree to website policy and terms of use
If you do not have an account, please register
Dear MQL4 coders,
please fix 2 error warnings in the below code
#property indicator_chart_window
#property indicator_buffers 5
#property indicator_color1 OrangeRed
#property indicator_color2 MediumPurple
#property indicator_color3 Red
#property indicator_color4 Black
#property indicator_color5 Black
#property indicator_width1 2
#property indicator_width2 2
#property indicator_width3 4
//---- input parameters
extern int period = 18;
extern bool show_d1_swing = false;
extern string XABC_setting = "<<-- XABC Settings -->>";
extern bool XABC_enabled = true;
extern datetime XABC_spec_time = 0; //D'2008.12.1 00:00';
extern string XABC_font = "Arial";
extern int XABC_font_size = 16;
extern color XABC_font_color = White;
extern color XABC_ME_line_color = Yellow;
//---- constants
#define LINE_DIRECT_UP 1
#define LINE_DIRECT_DN -1
#define LINE_NO_DIRECT -2
#define XABC_A 0
#define XABC_A_BAR 1
#define XABC_B 2
#define XABC_B_BAR 3
#define XABC_C 4
#define XABC_C_BAR 5
#define XABC_UPPER_ME 6
#define XABC_LOWER_ME 7
#define XABC_PBZ 8
#define XABC_PSZ 9
#define XABC_SWING_COUNT 10
//---- buffers
double d1_swing[];
double dn_swing[];
double XABC[];
double imean[];
double signals[];
double d1_line_direct[];
double dn_line_direct[];
//+------------------------------------------------------------------+
//| Custom indicator initialization function |
//+------------------------------------------------------------------+
int init()
{
//---- indicators
IndicatorBuffers(7);
if (show_d1_swing)
SetIndexStyle(0,DRAW_SECTION);
else
SetIndexStyle(0,DRAW_NONE);
SetIndexBuffer(0,d1_swing);
SetIndexEmptyValue(0, 0);
SetIndexLabel(0, "1-period Swing");
SetIndexStyle(1,DRAW_SECTION);
SetIndexBuffer(1,dn_swing);
SetIndexEmptyValue(1, 0);
SetIndexLabel(1, period + "-period Swing");
SetIndexStyle(2,DRAW_SECTION);
SetIndexBuffer(2,XABC);
SetIndexEmptyValue(2, 0);
SetIndexLabel(2, "XABC");
SetIndexStyle(3,DRAW_NONE);
SetIndexBuffer(3,imean);
SetIndexLabel(3, "Impluse mean");
SetIndexStyle(4, DRAW_NONE);
SetIndexBuffer(4, signals);
SetIndexLabel(4, "Signals");
SetIndexBuffer(5,d1_line_direct);
SetIndexBuffer(6,dn_line_direct);
IndicatorDigits(Digits);
//----
return(0);
}
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function |
//+------------------------------------------------------------------+
int deinit()
{
//----
clear_label();
//----
return(0);
}
//+------------------------------------------------------------------+
//| Custom indicator iteration function |
//+------------------------------------------------------------------+
int start()
{
int counted_bars=IndicatorCounted();
double shd_h, shd_l;
double direct;
static double impulse_mean, impulse_count, last_val_1, last_val_2, last_val_3;
double val_0, val_1, val_2, val_3;
int i, j, n;
//----
n = Bars - counted_bars - 1;
i = n;
while (i>=0){
if (i == Bars - 1){
shd_h = High[i] - High[i-1];
shd_l = Low[i]- Low[i-1];
if (shd_h > shd_l){
d1_swing[i] = High[i];
d1_line_direct[i] = LINE_DIRECT_UP;
} else {
d1_swing[i] = Low[i];
d1_line_direct[i] = LINE_DIRECT_DN;
}
} else {
direct = d1_direct(i);
switch (direct){
case LINE_DIRECT_UP:
d1_swing[i] = High[i];
d1_line_direct[i] = LINE_DIRECT_UP;
if (d1_line_direct[i+1] == LINE_DIRECT_UP) d1_swing[i+1] = 0;
if (d1_line_direct[i+1] == LINE_NO_DIRECT){
j = i+1;
while(d1_line_direct[j] == LINE_NO_DIRECT && j <= Bars) j++;
if(d1_line_direct[j] == LINE_DIRECT_UP){
if(High[j] < High[i]){
d1_swing[j] = 0;
} else {
d1_swing[i] = 0;
d1_line_direct[i] = LINE_NO_DIRECT;
}
}
}
break;
case LINE_DIRECT_DN:
d1_swing[i] = Low[i];
d1_line_direct[i] = LINE_DIRECT_DN;
if (d1_line_direct[i+1] == LINE_DIRECT_DN) d1_swing[i+1] = 0;
if (d1_line_direct[i+1] == LINE_NO_DIRECT){
j = i+1;
while(d1_line_direct[j] == LINE_NO_DIRECT && j <= Bars) j++;
if(d1_line_direct[j] == LINE_DIRECT_DN){
if(Low[j] > Low[i]){
d1_swing[j] = 0;
} else {
d1_swing[i] = 0;
d1_line_direct[i] = LINE_NO_DIRECT;
}
}
}
break;
case LINE_NO_DIRECT:
d1_swing[i] = 0;
d1_line_direct[i] = LINE_NO_DIRECT;
break;
}
}
i--;
}
i = n;
while (i>=0){
if (i == Bars - 1){
shd_h = High[i] - High[i-1];
shd_l = Low[i]- Low[i-1];
if (shd_h > shd_l){
dn_swing[i] = High[i];
dn_line_direct[i] = LINE_DIRECT_UP;
} else {
dn_swing[i] = Low[i];
dn_line_direct[i] = LINE_DIRECT_DN;
}
} else {
direct = dn_direct(i, period);
switch (direct){
case LINE_DIRECT_UP:
dn_swing[i] = High[i];
dn_line_direct[i] = LINE_DIRECT_UP;
if (dn_line_direct[i+1] == LINE_DIRECT_UP) dn_swing[i+1] = 0;
if (dn_line_direct[i+1] == LINE_NO_DIRECT){
j = i+1;
while(dn_line_direct[j] == LINE_NO_DIRECT && j <= Bars) j++;
if(dn_line_direct[j] == LINE_DIRECT_UP){
if(High[j] < High[i]){
dn_swing[j] = 0;
} else {
dn_swing[i] = 0;
dn_line_direct[i] = LINE_NO_DIRECT;
}
}
}
break;
case LINE_DIRECT_DN:
dn_swing[i] = Low[i];
dn_line_direct[i] = LINE_DIRECT_DN;
if (dn_line_direct[i+1] == LINE_DIRECT_DN) dn_swing[i+1] = 0;
if (dn_line_direct[i+1] == LINE_NO_DIRECT){
j = i+1;
while(dn_line_direct[j] == LINE_NO_DIRECT && j <= Bars) j++;
if(dn_line_direct[j] == LINE_DIRECT_DN){
if(Low[j] > Low[i]){
dn_swing[j] = 0;
} else {
dn_swing[i] = 0;
dn_line_direct[i] = LINE_NO_DIRECT;
}
}
}
break;
case LINE_NO_DIRECT:
dn_swing[i] = 0;
dn_line_direct[i] = LINE_NO_DIRECT;
break;
}
}
// Calculate impulse means
val_0 = 0; val_1 = 0; val_2 = 0; val_3 = 0; j = i;
while(val_3 == 0 && j <= Bars){
if (dn_swing[j] > 0){
if (val_0 == 0){
val_0 = dn_swing[j];
} else {
if (val_1 == 0){
val_1 = dn_swing[j];
} else {
if (val_2 == 0){
val_2 = dn_swing[j];
} else {
val_3 = dn_swing[j];
}
}
}
}
j++;
}
bool isimpulse = false;
if (val_2 > val_1){
if (val_3 > val_1) isimpulse = true;
} else {
if (val_3 < val_1) isimpulse = true;
}
if ((last_val_1 != val_1 && last_val_2 != val_2 && last_val_3 != val_3) ||
(last_val_1 == 0 && last_val_2 == 0 && last_val_3 == 0)){
last_val_1 = val_1; last_val_2 = val_2; last_val_3 = val_3;
if(val_1 > 0 && val_2 > 0 && val_3 > 0 && isimpulse){
if(impulse_mean > 0){
if(MathAbs(val_1 - val_2) <= (impulse_mean * 5.0)){
impulse_mean = impulse_mean * impulse_count + MathAbs(val_1 - val_2);
impulse_count++;
impulse_mean /= impulse_count;
}
} else {
impulse_mean = MathAbs(val_1 - val_2);
impulse_count = 1;
}
}
}
GlobalVariableSet(period+"d_Impluse_Mean", impulse_mean);
GlobalVariableSet(period+"d_Impluse_Count", impulse_count);
imean[i] = impulse_mean;
i--;
}
if (XABC_enabled) identify_XABC();
//----
return(0);
}
//+------------------------------------------------------------------+
int d1_direct(int idx){
double shd_h, shd_l;
shd_h = High[idx] - High[idx+1];
shd_l = Low[idx+1] - Low[idx];
if (shd_h > shd_l && shd_h > 0)
return (LINE_DIRECT_UP);
if (shd_h < shd_l && shd_l > 0)
return (LINE_DIRECT_DN);
return (LINE_NO_DIRECT);
}
int dn_direct(int idx, int n){
double shd_h, shd_l, nHigh, nLow, ten_pc;
double val_1, val_2;
int i, j;
nHigh = High[idx+1]; nLow = Low[idx+1];
for (i=1; i<=n; i++){
nHigh = MathMax(nHigh, High[idx+i]);
nLow = MathMin(nLow, Low[idx+i]);
}
j = idx+1; val_1 = 0; val_2 = 0;
while(val_2 == 0 && j <= Bars){
if (d1_swing[j] > 0){
if (val_1 <= 0){
val_1 = d1_swing[j];
} else {
val_2 = d1_swing[j];
}
}
j++;
}
ten_pc = 0;
if(val_1 > 0 && val_2 > 0) ten_pc = MathAbs(val_1 - val_2) * 10 / 100;
nHigh += ten_pc; nLow -= ten_pc;
shd_h = High[idx] - nHigh;
shd_l = nLow - Low[idx];
if (shd_h > shd_l && shd_h > 0)
return (LINE_DIRECT_UP);
if (shd_h < shd_l && shd_l > 0)
return (LINE_DIRECT_DN);
return (LINE_NO_DIRECT);
}
int num_label = 0;
int total_swing_pt = 0;
datetime sDateTime[];
double swing_point[];
int total_XABC_swing_pt = 0;
datetime XABC_DateTime[];
double XABC_swing_point[];
void identify_XABC(){
clear_label();
clear_swing_pts();
if(XABC_spec_time > 0)
catch_swing_pt_ex();
else
catch_swing_pt();
catch_XABC();
show_XABC();
}
void catch_XABC(){
double X_pt, A_pt, B_pt, ME, XA_10pc, AB_20pc, A_Max, A_Min, B_Max, B_Min, imp_mean;
datetime X_dt, A_dt, B_dt, sp_dt;
int i, j, A_pos, B_pos;
bool is_A_Vtop, is_B_Vtop;
clear_XABC_swing_pts();
if (XABC_spec_time > 0){
sp_dt = XABC_spec_time;
imp_mean = imean[iBarShift(NULL, 0, sp_dt)];
} else {
sp_dt = TimeCurrent();
imp_mean = imean[0];
}
X_pt = swing_point[total_swing_pt - 1];
X_dt = sDateTime[total_swing_pt - 1];
A_pt = swing_point[total_swing_pt - 2];
A_dt = sDateTime[total_swing_pt - 2];
A_pos = 2;
B_pt = swing_point[total_swing_pt - 3];
B_dt = sDateTime[total_swing_pt - 3];
B_pos = 3;
XA_10pc = MathAbs(A_pt - X_pt) * 10 / 100;
AB_20pc = MathAbs(B_pt - A_pt) * 20 / 100;
ME = MathMax(XA_10pc, AB_20pc);
if (A_pt > X_pt) is_A_Vtop = true; else is_A_Vtop = false;
if (B_pt > A_pt) is_B_Vtop = true; else is_B_Vtop = false;
A_Max = A_pt; A_Min = A_pt;
for(i=4; i<total_swing_pt-1; i+=2){
if (is_A_Vtop){
A_Max = MathMax(A_Max, swing_point[total_swing_pt - i]);
if (swing_point[total_swing_pt - i] >= A_pt && swing_point[total_swing_pt - i] <= A_pt + ME
&& swing_point[total_swing_pt - i] >= A_Max && sDateTime[total_swing_pt - i] < sp_dt){
A_pt = swing_point[total_swing_pt - i];
A_dt = sDateTime[total_swing_pt - i];
for (j=i-1; j>=0; j-=2){
if(MathAbs(swing_point[total_swing_pt - j] - A_pt) >= imp_mean){
X_pt = swing_point[total_swing_pt - j];
X_dt = sDateTime[total_swing_pt - j];
break;
}
}
XA_10pc = MathAbs(A_pt - X_pt) * 10 / 100;
ME = MathMax(XA_10pc, AB_20pc);
if (A_pt > X_pt) is_A_Vtop = true; else is_A_Vtop = false;
A_pos = i;
}
if (swing_point[total_swing_pt - i - 1] < A_pt && swing_point[total_swing_pt - i] > A_pt + ME
&& swing_point[total_swing_pt - i] >= A_Max && sDateTime[total_swing_pt - i] < sp_dt){
A_pt = swing_point[total_swing_pt - i];
A_dt = sDateTime[total_swing_pt - i];
for (j=i-1; j>=0; j-=2){
if(MathAbs(swing_point[total_swing_pt - j] - A_pt) >= imp_mean){
X_pt = swing_point[total_swing_pt - j];
X_dt = sDateTime[total_swing_pt - j];
break;
}
}
XA_10pc = MathAbs(A_pt - X_pt) * 10 / 100;
ME = MathMax(XA_10pc, AB_20pc);
if (A_pt > X_pt) is_A_Vtop = true; else is_A_Vtop = false;
A_pos = i;
}
} else {
A_Min = MathMin(A_Min, swing_point[total_swing_pt - i]);
if (swing_point[total_swing_pt - i] <= A_pt && swing_point[total_swing_pt - i] >= A_pt - ME
&& swing_point[total_swing_pt - i] <= A_Min && sDateTime[total_swing_pt - i] < sp_dt){
A_pt = swing_point[total_swing_pt - i];
A_dt = sDateTime[total_swing_pt - i];
for (j=i-1; j>=0; j-=2){
if(MathAbs(swing_point[total_swing_pt - j] - A_pt) >= imp_mean){
X_pt = swing_point[total_swing_pt - j];
X_dt = sDateTime[total_swing_pt - j];
break;
}
}
XA_10pc = MathAbs(A_pt - X_pt) * 10 / 100;
ME = MathMax(XA_10pc, AB_20pc);
if (A_pt > X_pt) is_A_Vtop = true; else is_A_Vtop = false;
A_pos = i;
}
if (swing_point[total_swing_pt - i - 1] > A_pt && swing_point[total_swing_pt - i] < A_pt - ME
&& swing_point[total_swing_pt - i] <= A_Min && sDateTime[total_swing_pt - i] < sp_dt){
A_pt = swing_point[total_swing_pt - i];
A_dt = sDateTime[total_swing_pt - i];
for (j=i-1; j>=0; j-=2){
if(MathAbs(swing_point[total_swing_pt - j] - A_pt) >= imp_mean){
X_pt = swing_point[total_swing_pt - j];
X_dt = sDateTime[total_swing_pt - j];
break;
}
}
XA_10pc = MathAbs(A_pt - X_pt) * 10 / 100;
ME = MathMax(XA_10pc, AB_20pc);
if (A_pt > X_pt) is_A_Vtop = true; else is_A_Vtop = false;
A_pos = i;
}
}
}
add_XABC_swing_pt(X_pt, X_dt);
add_XABC_swing_pt(A_pt, A_dt);
if(A_pos != 2){
B_pt = swing_point[total_swing_pt - (A_pos + 1)];
B_dt = sDateTime[total_swing_pt - (A_pos + 1)];
B_pos = (A_pos + 1);
AB_20pc = MathAbs(B_pt - A_pt) * 20 / 100;
ME = MathMax(XA_10pc, AB_20pc);
if (B_pt > A_pt) is_B_Vtop = true; else is_B_Vtop = false;
}
B_Max = B_pt; B_Min = B_pt;
for(i=B_pos+2; i<total_swing_pt; i+=2){
if (is_B_Vtop){
B_Max = MathMax(B_Max, swing_point[total_swing_pt - i]);
if (swing_point[total_swing_pt - i] >= B_pt && swing_point[total_swing_pt - i] <= B_pt + ME
&& swing_point[total_swing_pt - i] >= B_Max && sDateTime[total_swing_pt - i] < sp_dt){
B_pt = swing_point[total_swing_pt - i];
B_dt = sDateTime[total_swing_pt - i];
B_pos = i;
AB_20pc = MathAbs(B_pt - A_pt) * 20 / 100;
ME = MathMax(XA_10pc, AB_20pc);
if (B_pt > A_pt) is_B_Vtop = true; else is_B_Vtop = false;
}
if (swing_point[total_swing_pt - i - 1] < B_pt && swing_point[total_swing_pt - i] > B_pt + ME
&& swing_point[total_swing_pt - i] >= B_Max && sDateTime[total_swing_pt - i] < sp_dt){
B_pt = swing_point[total_swing_pt - i];
B_dt = sDateTime[total_swing_pt - i];
B_pos = i;
AB_20pc = MathAbs(B_pt - A_pt) * 20 / 100;
ME = MathMax(XA_10pc, AB_20pc);
if (B_pt > A_pt) is_B_Vtop = true; else is_B_Vtop = false;
}
} else {
B_Min = MathMin(B_Min, swing_point[total_swing_pt - i]);
if (swing_point[total_swing_pt - i] <= B_pt && swing_point[total_swing_pt - i] >= B_pt - ME
&& swing_point[total_swing_pt - i] <= B_Min && sDateTime[total_swing_pt - i] < sp_dt){
B_pt = swing_point[total_swing_pt - i];
B_dt = sDateTime[total_swing_pt - i];
B_pos = i;
AB_20pc = MathAbs(B_pt - A_pt) * 20 / 100;
ME = MathMax(XA_10pc, AB_20pc);
if (B_pt > A_pt) is_B_Vtop = true; else is_B_Vtop = false;
}
if (swing_point[total_swing_pt - i - 1] > B_pt && swing_point[total_swing_pt - i] < B_pt - ME
&& swing_point[total_swing_pt - i] <= B_Min && sDateTime[total_swing_pt - i] < sp_dt){
B_pt = swing_point[total_swing_pt - i];
B_dt = sDateTime[total_swing_pt - i];
B_pos = i;
AB_20pc = MathAbs(B_pt - A_pt) * 20 / 100;
ME = MathMax(XA_10pc, AB_20pc);
if (B_pt > A_pt) is_B_Vtop = true; else is_B_Vtop = false;
}
}
}
add_XABC_swing_pt(B_pt, B_dt);
for(i=B_pos+1; i<=total_swing_pt; i++)
add_XABC_swing_pt(swing_point[total_swing_pt-i], sDateTime[total_swing_pt-i]);
}
string get_XABC_label(int num){
int n, m, r;
string str;
string labels_1[] = {"X", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L",
"M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"};
string labels[] = {"A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L",
"M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"};
str = "";
if (num < 27){
str = labels_1[num];
} else {
n = num-1;
while (n > 0){
m = n;
n = m / 26;
r = m % 26;
if (n == 0)
str = labels[r-1] + str;
else
str = labels[r] + str;
}
}
return (str);
}
void show_XABC(){
string strlabel;
double sp, pos, X_pt, A_pt, B_pt, C_pt, ME, XA_10pc, AB_20pc, ABdiv8;
datetime A_dt, B_dt, C_dt;
int A_bar, B_bar, C_bar;
int i, n, align;
ArrayInitialize(XABC, 0);
clear_XABC_signals();
for(i=0; i<total_XABC_swing_pt; i++){
strlabel = "XABC_label_" + i;
if (i == total_XABC_swing_pt-1){
if (XABC_swing_point[i] > XABC_swing_point[i - 1])
sp = imean[0] * 20 / 100;
else
sp = -(imean[0] * 10 / 100);
} else {
if (XABC_swing_point[i] > XABC_swing_point[i + 1])
sp = imean[0] * 20 / 100;
else
sp = -(imean[0] * 10 / 100);
}
pos = XABC_swing_point[i] + sp;
ObjectCreate(strlabel, OBJ_TEXT, 0, XABC_DateTime[i], pos);
ObjectSetText(strlabel, get_XABC_label(i), XABC_font_size, XABC_font, XABC_font_color);
num_label++;
n = iBarShift(NULL, 0, XABC_DateTime[i]);
XABC[n] = XABC_swing_point[i];
}
X_pt = XABC_swing_point[0];
A_pt = XABC_swing_point[1];
A_dt = XABC_DateTime[1];
B_pt = XABC_swing_point[2];
B_dt = XABC_DateTime[2];
C_pt = XABC_swing_point[3];
C_dt = XABC_DateTime[3];
A_bar = iBarShift(NULL, 0, A_dt);
B_bar = iBarShift(NULL, 0, B_dt);
C_bar = iBarShift(NULL, 0, C_dt);
XA_10pc = MathAbs(A_pt - X_pt) * 10 / 100;
AB_20pc = MathAbs(B_pt - A_pt) * 20 / 100;
ABdiv8 = MathAbs(A_pt - B_pt) / 8;
align = WindowBarsPerChart() * 10 / 100;
if (X_pt < A_pt){
ME = MathMax(XA_10pc, AB_20pc);
ObjectCreate("XABC_PSZ", OBJ_TREND, 0, A_dt, A_pt-ABdiv8, Time[0], A_pt-ABdiv8);
ObjectCreate("XABC_PSZ_Label", OBJ_TEXT, 0, Time[0]+Period()*60*align, A_pt-ABdiv8);
ObjectCreate("XABC_PBZ", OBJ_TREND, 0, B_dt, B_pt+ABdiv8, Time[0], B_pt+ABdiv8);
ObjectCreate("XABC_PBZ_Label", OBJ_TEXT, 0, Time[0]+Period()*60*align, B_pt+ABdiv8);
ObjectSetText("XABC_PSZ_Label", "Primary Sell Zone @"+DoubleToStr(A_pt-ABdiv8, Digits), 8, XABC_font ,XABC_ME_line_color);
ObjectSetText("XABC_PBZ_Label", "Primary Buy Zone @"+DoubleToStr(B_pt+ABdiv8, Digits), 8, XABC_font ,XABC_ME_line_color);
pop_XABC_signals(X_pt, A_pt, A_bar, B_pt, B_bar, C_pt, C_bar, A_pt+ME, B_pt-ME, B_pt+ABdiv8, A_pt-ABdiv8, total_XABC_swing_pt);
} else {
ME = -MathMax(XA_10pc, AB_20pc);
ObjectCreate("XABC_PBZ", OBJ_TREND, 0, A_dt, A_pt+ABdiv8, Time[0], A_pt+ABdiv8);
ObjectCreate("XABC_PBZ_Label", OBJ_TEXT, 0, Time[0]+Period()*60*align, A_pt+ABdiv8);
ObjectCreate("XABC_PSZ", OBJ_TREND, 0, B_dt, B_pt-ABdiv8, Time[0], B_pt-ABdiv8);
ObjectCreate("XABC_PSZ_Label", OBJ_TEXT, 0, Time[0]+Period()*60*align, B_pt-ABdiv8);
ObjectSetText("XABC_PSZ_Label", "Primary Sell Zone @"+DoubleToStr(B_pt-ABdiv8, Digits), 8, XABC_font ,XABC_ME_line_color);
ObjectSetText("XABC_PBZ_Label", "Primary Buy Zone @"+DoubleToStr(A_pt+ABdiv8, Digits), 8, XABC_font ,XABC_ME_line_color);
pop_XABC_signals(X_pt, A_pt, A_bar, B_pt, B_bar, C_pt, C_bar, B_pt-ME, A_pt+ME, A_pt+ABdiv8, B_pt-ABdiv8, total_XABC_swing_pt);
}
ObjectCreate("XABC_A", OBJ_TREND, 0, A_dt, A_pt, Time[0], A_pt);
ObjectCreate("XABC_A_Label", OBJ_TEXT, 0, Time[0]+Period()*60*align, A_pt);
ObjectSetText("XABC_A_Label", "A Boundary @"+DoubleToStr(A_pt, Digits), 8, XABC_font ,XABC_ME_line_color);
ObjectCreate("XABC_A_ME", OBJ_TREND, 0, A_dt, A_pt+ME, Time[0], A_pt+ME);
ObjectCreate("XABC_A_ME_Label", OBJ_TEXT, 0, Time[0]+Period()*60*align, A_pt+ME);
ObjectSetText("XABC_A_ME_Label", "Maximum Extension @"+DoubleToStr(A_pt+ME, Digits), 8, XABC_font ,XABC_ME_line_color);
ObjectCreate("XABC_B", OBJ_TREND, 0, B_dt, B_pt, Time[0], B_pt);
ObjectCreate("XABC_B_Label", OBJ_TEXT, 0, Time[0]+Period()*60*align, B_pt);
ObjectSetText("XABC_B_Label", "B Boundary @"+DoubleToStr(B_pt, Digits), 8, XABC_font ,XABC_ME_line_color);
ObjectCreate("XABC_B_ME", OBJ_TREND, 0, B_dt, B_pt-ME, Time[0], B_pt-ME);
ObjectCreate("XABC_B_ME_Label", OBJ_TEXT, 0, Time[0]+Period()*60*align, B_pt-ME);
ObjectSetText("XABC_B_ME_Label", "Maximum Extension @"+DoubleToStr(B_pt-ME, Digits), 8, XABC_font ,XABC_ME_line_color);
ObjectSet("XABC_PSZ", OBJPROP_COLOR, XABC_ME_line_color);
ObjectSet("XABC_PBZ", OBJPROP_COLOR, XABC_ME_line_color);
ObjectSet("XABC_A", OBJPROP_COLOR, XABC_ME_line_color);
ObjectSet("XABC_B", OBJPROP_COLOR, XABC_ME_line_color);
ObjectSet("XABC_A_ME", OBJPROP_COLOR, XABC_ME_line_color);
ObjectSet("XABC_B_ME", OBJPROP_COLOR, XABC_ME_line_color);
ObjectSet("XABC_PSZ", OBJPROP_STYLE, STYLE_DOT);
ObjectSet("XABC_PBZ", OBJPROP_STYLE, STYLE_DOT);
ObjectSet("XABC_A", OBJPROP_STYLE, STYLE_DOT);
ObjectSet("XABC_B", OBJPROP_STYLE, STYLE_DOT);
ObjectSet("XABC_A_ME", OBJPROP_STYLE, STYLE_DOT);
ObjectSet("XABC_B_ME", OBJPROP_STYLE, STYLE_DOT);
}
void pop_XABC_signals(double X_pt, double A_pt, int A_pt_bar, double B_pt, int B_pt_bar, double C_pt, int C_pt_bar,
double upper_me, double lower_me, double pbz, double psz, int count){
double XA_height, AB_height;
XA_height = MathAbs(X_pt - A_pt);
AB_height = MathAbs(A_pt - B_pt);
if (AB_height > XA_height){
signals[XABC_A] = 0;
signals[XABC_B] = 0;
signals[XABC_C] = 0;
signals[XABC_A_BAR] = 0;
signals[XABC_B_BAR] = 0;
signals[XABC_C_BAR] = 0;
signals[XABC_UPPER_ME] = 0;
signals[XABC_LOWER_ME] = 0;
signals[XABC_PBZ] = 0;
signals[XABC_PSZ] = 0;
signals[XABC_SWING_COUNT] = 0;
} else {
signals[XABC_A] = A_pt;
signals[XABC_B] = B_pt;
signals[XABC_C] = C_pt;
signals[XABC_A_BAR] = A_pt_bar;
signals[XABC_B_BAR] = B_pt_bar;
signals[XABC_C_BAR] = C_pt_bar;
signals[XABC_UPPER_ME] = upper_me;
signals[XABC_LOWER_ME] = lower_me;
signals[XABC_PBZ] = pbz;
signals[XABC_PSZ] = psz;
signals[XABC_SWING_COUNT] = count;
}
}
void clear_XABC_signals(){
signals[XABC_A] = 0;
signals[XABC_B] = 0;
signals[XABC_C] = 0;
signals[XABC_A_BAR] = 0;
signals[XABC_B_BAR] = 0;
signals[XABC_C_BAR] = 0;
signals[XABC_UPPER_ME] = 0;
signals[XABC_LOWER_ME] = 0;
signals[XABC_PBZ] = 0;
signals[XABC_PSZ] = 0;
signals[XABC_SWING_COUNT] = 0;
}
void catch_swing_pt(){
double imp_mean, sw_pt_1, sw_pt_2;
int count, i;
imp_mean = imean[0];
count = 0; sw_pt_1 = 0; sw_pt_2 = 0; i = 0;
while((count <= 3 || MathAbs(sw_pt_1 - sw_pt_2) < imp_mean) && i <= Bars){
if(dn_swing[i] > 0){
if (sw_pt_1 == 0){
sw_pt_1 = dn_swing[i];
sw_pt_2 = dn_swing[i];
add_swing_pt(sw_pt_1, Time[i]);
count++;
} else {
sw_pt_2 = sw_pt_1;
sw_pt_1 = dn_swing[i];
add_swing_pt(sw_pt_1, Time[i]);
count++;
}
}
i++;
}
}
void catch_swing_pt_ex(){
double imp_mean, sw_pt_1, sw_pt_2;
int i, spt, count;
datetime pt_1_dt, pt_2_dt;
bool imp_mean_hit;
spt = iBarShift(NULL, 0, XABC_spec_time);
imp_mean = imean[spt];
count = 0; sw_pt_1 = 0; sw_pt_2 = 0; i = 0; imp_mean_hit = false;
while(!imp_mean_hit && i <= Bars){
if(dn_swing[i] > 0){
if (sw_pt_1 == 0){
sw_pt_1 = dn_swing[i];
sw_pt_2 = dn_swing[i];
pt_1_dt = Time[i];
pt_2_dt = Time[i];
add_swing_pt(sw_pt_1, pt_1_dt);
if (i > spt) count++;
} else {
sw_pt_2 = sw_pt_1;
pt_2_dt = pt_1_dt;
sw_pt_1 = dn_swing[i];
pt_1_dt = Time[i];
add_swing_pt(sw_pt_1, pt_1_dt);
if (i > spt) count++;
}
}
if (MathAbs(sw_pt_1 - sw_pt_2) >= imp_mean && pt_2_dt < XABC_spec_time) imp_mean_hit = true; // count > 3
i++;
}
}
void clear_label(){
string strlabel;
for (int i=0; i<=num_label; i++){
strlabel = "XABC_label_" + i;
ObjectDelete(strlabel);
}
ObjectDelete("XABC_A");
ObjectDelete("XABC_A_ME");
ObjectDelete("XABC_B");
ObjectDelete("XABC_B_ME");
ObjectDelete("XABC_PBZ");
ObjectDelete("XABC_PSZ");
ObjectDelete("XABC_A_Label");
ObjectDelete("XABC_B_Label");
ObjectDelete("XABC_A_ME_Label");
ObjectDelete("XABC_B_ME_Label");
ObjectDelete("XABC_PBZ_Label");
ObjectDelete("XABC_PSZ_Label");
}
int add_swing_pt(double pt, datetime dt){
int rst;
total_swing_pt++;
rst = ArrayResize(sDateTime, total_swing_pt);
if (rst == -1) return (-1);
rst = ArrayResize(swing_point, total_swing_pt);
if (rst == -1) return (-1);
sDateTime[total_swing_pt - 1] = dt;
swing_point[total_swing_pt - 1] = pt;
return (0);
}
int clear_swing_pts(){
int rst;
total_swing_pt = 0;
rst = ArrayResize(sDateTime, 0);
if (rst == -1) return (-1);
rst = ArrayResize(swing_point, 0);
if (rst == -1) return (-1);
return (0);
}
int add_XABC_swing_pt(double pt, datetime dt){
int rst;
total_XABC_swing_pt++;
rst = ArrayResize(XABC_DateTime, total_XABC_swing_pt);
if (rst == -1) return (-1);
rst = ArrayResize(XABC_swing_point, total_XABC_swing_pt);
if (rst == -1) return (-1);
XABC_DateTime[total_XABC_swing_pt - 1] = dt;
XABC_swing_point[total_XABC_swing_pt - 1] = pt;
return (0);
}
int clear_XABC_swing_pts(){
int rst;
total_XABC_swing_pt = 0;
rst = ArrayResize(XABC_DateTime, 0);
if (rst == -1) return (-1);
rst = ArrayResize(XABC_swing_point, 0);
if (rst == -1) return (-1);
return (0);
}