नमस्ते ,
मेरे पास उन सभी लोगों के लिए बहुत खास विचार है जो एमटी 4एमटी 5 को रैखिक चार्ट्स के साथ सही और सही ट्रेंडलाइन नहीं खींचने के लिए दोषी मानते हैं whcih MT4MT5 का उपयोग कर रहा है।
क्या कोई भी कोडर इस अवधि कनवर्टर को सामान्य MT4 -Arithmetic -Linear चार्ट से लॉगरिदमिक चार्ट स्केल में बदल सकता है।
मुझे लगता है कि सभी तकनीकी ट्रेंडलाइन-प्रेमी के लिए एमटी 4एमटी 5 में लॉगरिदमिक चार्ट प्राप्त करने का यही एकमात्र तरीका है।
यहां इंडी और स्रोत कोड है:
// ------------------------------------ ----------- -------------------
//| Period_Converter_Opt.mq4 |
//| कॉपीराइट (सी) 2005, मेटाक्वाट्स सॉफ्टवेयर कॉर्प
//|
http://www.metaquotes.net|
//| Ver.1.6 micclly द्वारा संशोधित |
//| Ver.1.5 fai द्वारा संशोधित |
//| Period_Converter पर आधारित wfy05 @ talkforex द्वारा संशोधित |
//|
http://www.talkforex.com|
// ------------------------------------ ----------- -------------------
#property कॉपीराइट
#property लिंक http://www.mql4.com/codebase/indiors/277/
#property indior_chart_window
# शामिल लेफ्टिनेंट; WinUser32.mqhgt;
/*
रीडमी:
I. विशेषताएं:
यह एमटी 4 के आधार पर अवधि कनवर्टर का एक बेहतर संस्करण है
Metaquotes द्वारा MT4 की डिफ़ॉल्ट अवधि कनवर्टर।
डिफ़ॉल्ट अवधि कनवर्टर स्क्रिप्ट रीयल-टाइम रीफ्रेशिंग का समर्थन नहीं करती है,
और पूरे सिस्टम को धीमा बनाने के लिए बहुत से CPU (50% -9x%) का उपभोग करें।
साथ ही, डिफ़ॉल्ट एक स्क्रिप्ट है जो एमटी 4 से बाहर निकलने पर सहेजती नहीं है,
इसलिए आपको पुनरारंभ करने के बाद फिर से प्रत्येक कनवर्टर स्क्रिप्ट को लागू करना होगा
कष्टप्रद।
यह सभी उपर्युक्त समस्याओं को ठीक करता है:
1. वास्तविक समय अद्यतन या कस्टम अंतराल मिलीसेकंद स्तर अद्यतन।
2. कम सीपीयू लागत, औसत 5% -10% या उससे कम।
3. एक संकेतक के रूप में काम करता है, इसलिए पुनरारंभ के दौरान सहेजा जा सकता है और पुनः लोड किया जा सकता है।
4. प्रति चार्ट सीमा के रूप में कोई भी कनवर्टर नहीं है क्योंकि यह स्क्रिप्ट नहीं है
और भी, आप केवल एक खिड़की का उपयोग स्रोत के रूप में कई उत्पन्न करने के लिए कर सकते हैं
नया टाइमफ्रेम चार्ट जितना संभव हो।
5. नया इतिहास ब्लॉक लोड होने पर ऑटो अपडेटिंग।
द्वितीय। कैसे इस्तेमाल करे:
Mq4 फ़ाइल को अपने एमटी 4 संकेतक फ़ोल्डर (विशेषज्ञों \ संकेतकों) में कॉपी करें
इसे एक सूचक के रूप में स्थापित करने के लिए, स्क्रिप्ट नहीं। फिर कस्टम सूचक में
सूची, इच्छित चार्ट में period_converter_opt संलग्न करें।
यह 4 पैरामीटर का समर्थन करता है:
अवधि मॉड्यूलियर: नई अवधि गुणक कारक, डिफ़ॉल्ट 2 है
अद्यतन अंतराल: मिलीसेकंड में अंतराल अद्यतन करें,
शून्य का मतलब वास्तविक समय अपडेट करें। डिफ़ॉल्ट शून्य है।
सक्षम: आप इसे इस विकल्प के साथ हटाए बिना अक्षम कर सकते हैं।
अन्य पैरामीटर टिप्पणियां हैं या डिबगिंग के लिए, उन्हें अनदेखा करना सुरक्षित है।
यह भी सुनिश्चित करें कि आपने सामान्य टैब में चेक किए गए डीएल आयात विकल्प को अनुमति दी है या
यह काम नहीं करेगा
उसके बाद, जेनरेट ऑफ़लाइन डेटा खोलने के लिए फ़ाइल ओपन ऑफ़लाइन। फिर
ऑफ़लाइन डेटा स्वचालित रूप से अपडेट हो जाएगा।
जब तक आप स्रोत चार्ट को खोलें और कनवर्टर सूचक रखें
चल रहा है, अंदर संकेतक सहित उत्पन्न चार्ट हमेशा होगा
अद्यतन किया जा। आप जेनरेट किए गए चार्ट को बंद कर सकते हैं और फिर से खोल सकते हैं
बाद में बिना किसी समस्या के FileOpen ऑफ़लाइन से।
अगर आप एमटी 4 छोड़ना चाहते हैं, तो आप उन ऑफ़लाइन चार्ट को दूसरे के रूप में छोड़ सकते हैं
सामान्य ऑनलाइन चार्ट। जब आप अगली बार एमटी 4 शुरू करेंगे, तो वे चार्ट होंगे
भी लोड और अद्यतन किया जा सकता है।
तृतीय। टिप्पणियाँ:
1. ऑफ़लाइन चार्ट सामान्य गुणों में ऑफ़लाइन चार्ट विकल्प को अनचेक न करें।
या एमटी 4 पुनरारंभ करने के बाद, यह उस चार्ट को ऑनलाइन चार्ट और अनुरोध के रूप में पेश करेगा
सर्वर से डेटा, जिसके परिणामस्वरूप खाली चार्ट विंडो।
2. आप एक से अधिक कनवर्टर को एक ही विंडो में अलग से संलग्न कर सकते हैं
अवधि Multiplier, उदाहरण: आप के साथ 3 कनवर्टर संलग्न कर सकते हैं
अवधि Multiplier = 2, 4, 10 से एम 1 एक ही समय में एम 2, एम 4, एम 10 उत्पन्न करने के लिए।
एच 2 जैसे घंटे चार्ट बनाने के लिए एम 1 चार्ट का उपयोग करना भी ठीक है, जो
प्रारंभिक रूपांतरण के दौरान केवल कुछ और CPU संसाधनों की लागत होती है। लेकिन आम तौर पर
अधिकांश सर्वर के पास उन छोटी अवधि के लिए अधिक डेटा नहीं है। परिणामस्वरूप
जेनरेट किया गया डेटा लंबे समय तक पर्याप्त नहीं है। तो यह सुझाव दिया जाता है
आवश्यक होने पर स्रोत के रूप में प्रति घंटादैनिक चार्ट का उपयोग करने के लिए।
3. रीयल-टाइम अपडेटिंग मोड अपडेट जितनी जल्दी हो सके उद्धरण देता है, लेकिन जैसा कि
यह स्क्रिप्ट के माध्यम से किया जाता है, और एमटी कॉलिंग स्टार्ट () फ़ंक्शन को छोड़ देगा
आपका पीसी व्यस्त है और उद्धरण आय के बहुत सारे हैं। वैसे भी, यह शायद ही कभी होता है,
और आप कम से कम 10 सेकंड प्रत्येक अपडेट प्राप्त कर सकते हैं जो बहुत अधिक है
पर्याप्त से ज्यादा
4. ऑफ़लाइन चार्ट में चार्ट में प्रदर्शित बोली रेखा नहीं है, लेकिन सभी डेटा
संकेतक सहित चार्ट में अभी भी अपडेट किया जा रहा है,
तो चिंता मत करो। आप ऑफलाइन चार्ट को अनलॉक करके बोली लाइन दिखा सकते हैं
चार्ट गुणों में विकल्प। लेकिन जो ज्यादा मदद नहीं करता है और यदि आप भूल जाते हैं
बाहर निकलने से पहले ऑफलाइन चार्ट विकल्प की जांच करने के लिए। यह त्रुटियों का कारण बन जाएगा
अगले स्टार्टअप पर खाली हो जाओ। आपको खिड़की को बंद करना और खोलना है
फिर से FileOpen ऑफ़लाइन से, जो मुसीबत के लायक नहीं है।
चतुर्थ। इतिहास:
2014.03.10 1.6 600 और बाद के निर्माण के लिए संशोधित करने के लिए संशोधित
2009.08.07 1.5 जोड़ा गया 3 विकल्प। (ShiftTiming, GMTShift, OmitD igit)
2005.12.24 1.4 फ्लोट प्वाइंट को हटाकर डेटा बदलकर पता लगाने के लिए तेज़ी से 1.4
संचालन, वास्तविक समय में आउटपुट सीएसवी फ़ाइल में समर्थन जोड़ा गया।
आउटपुटCSVFile = 0 का मतलब कोई सीएसवी नहीं है।
आउटपुटCSVFile = 1 का मतलब सीएसवी एचएसटी है
आउटपुटCSVFile = 2 सीएसवी केवल, कोई एचएसटी नहीं।
(उपयोगी अगर आप अंतर्निहित अवधि के लिए सीएसवी उत्पन्न करना चाहते हैं)
सीएसवी फ़ाइल नाम एक्सटेंशन को छोड़कर एचएसटी फ़ाइल के समान होगा।
अवधि गुणक के लिए सुरक्षित जांच जोड़ा गया।
2005.12.04 1.3 बड़ी मात्रा में डेटा होने पर फिक्स्ड लापता डेटा
कई ब्लॉक में लोड, और ऑटो अपडेटिंग का समर्थन करते हैं
जब नया इतिहास लोड हो जाता है।
2005.11.2 9 1.2 गायब डेटा और सर्वर बदलने के लिए अतिरिक्त फिक्स।
2005.11.2 9 1.1 पुनरारंभ करने के बाद फिक्स्ड लापता आंशिक डेटा।
सर्वर या डेटा को दूषित करने के बाद पुन: प्रारंभ करें।
2005.11.28 1.0 प्रारंभिक रिलीज
*
बाहरी डबल संस्करण = 1.6;/कोड संस्करण
बाहरी स्ट्रिंग BuildInfo = 2014.03.10 micclly द्वारा;
बाहरी int अवधिMultiplier = 1;/नई अवधि गुणक कारक
बाहरी int आउटपुटCSVFile = 0;/आउटपुट सीएसवी फ़ाइल भी?
बाहरी int अद्यतन इंटरवल = 0;/मिलीसेकंड में अपडेट अंतराल, शून्य का मतलब वास्तविक समय अपडेट करें।
बाहरी बूल सक्षम = सच;
बाहरी बूल डीबग = झूठा;
बाहरी int ShiftTiming = 0;/0-3, H1Chart और PeriodMultiplier = 4 का उपयोग करना;
//अगर 1, सर्वरएच 4 चार्ट = 00: 00/04: 00/08: 00/12: 00 ...
//= gt; ऑफ़लाइन एच 4 चार्ट = 01: 00/05: 00/09: 00/13: 00 ...
बाहरी int जीएमटीएसफ़्ट = 0;/अगर 9, सर्वर समय = जीएमटी 0 ऑफ़लाइन चार्ट समय = जीएमटी 9
बाहरी int OmitDigit = 0;/अगर 1, 5 अंक 4 अंक
int FileHandle = -1;
int CSVHandle = -1;
int न्यूपीरियोड = 0;
स्ट्रिंग MySymbol =;
int ShiftBase;
#define OUTPUT_HST_ONLY 0
#define OUTPUT_CSV_HST 1
#define OUTPUT_CSV_ONLY 2
# परिभाषित करें CHART_CMD_UPDATE_DATA 33324
शून्य डीबगएमएसएस (स्ट्रिंग msg)
{
अगर (डीबग) अलर्ट (संदेश);
}
int init ()
{
ShiftBase = अवधि () * 60;/सेकंड
स्ट्रिंग प्रत्यय =;
अगर (ShiftTiming! = 0) प्रत्यय = स्ट्रिंगकोनकटनेट (प्रत्यय, एस, शिफ्ट समय);
अगर (जीएमटीएसफ़्ट! = 0) प्रत्यय = स्ट्रिंगकोनकटनेट (प्रत्यय, जी, जीएमटीएस आईएफटी);
अगर (OmitDigit! = 0) प्रत्यय = स्ट्रिंगकोनकटनेट (प्रत्यय, ओ*, ओमिटडिजिट *);
MySymbol = प्रतीक () _ प्रत्यय;
अगर (StringLen (MySymbol) gt; 11)
MySymbol = StringConenate (StringSubstr (MySy mbol, 0,11-स्ट्रिंगलेन (प्रत्यय)), प्रत्यय);
//अवधि गुणक के लिए/सुरक्षित जांच।
अगर (PeriodMultiplier लेफ्टिनेंट; = 1 प्रत्यय ==) {
//केवल आउटपुट सीएसवी फ़ाइल
अवधि गुणक = 1;
आउटपुट सीएसवी फ़ाइल = 2;
}
न्यूपीरियोड = अवधि () * अवधि मल्टीप्लायर;
अगर (OpenHistoryFile () lt; 0) वापसी (-1);
WriteHistoryHeader ();
UpdateHistoryFile (बार्स -1, सच);
UpdateChartWindow ();
वापसी (0);
}
शून्य डेनिट ()
{
//बंद फ़ाइल हैंडल
अगर (फाइलहैंडल gt; = 0) {
FileClose (filehandle);
FileHandle = -1;
}
अगर (सीएसवीएचंडल gt; = 0) {
FileClose (CSVHandle);
सीएसवीएचंडल = -1;
}
}
int OpenHistoryFile ()
{
स्ट्रिंग नाम;
नाम = MySymbol NewPeriod;
अगर (आउटपुटCSVFile! = OUTPUT_CSV_ONLY) {
FileHandle = FileOpenHistory (नाम .hst, FILE_BIN | FILE_WRITE | FILE_SHARE_READ);
अगर (फाइलहैंडल लेफ्टिनेंट; 0) वापसी (-1);
}
अगर (आउटपुटCSVFile! = OUTPUT_HST_ONLY) {
CSVHandle = FileOpen (नाम .csv, FILE_CSV | FILE_WRITE | FILE_SHARE_READ | FILE_ANSI, ',');
अगर (सीएसवीएचंडल लेफ्टिनेंट; 0) रिटर्न (-1);
}
वापसी (0);
}
int WriteHistoryHeader ()
{
स्ट्रिंग c_copyright;
int i_digits = अंक-ओमिटडिजिट;
int i_unused [13] = {0};
int संस्करण = 400;
अगर (फाइलहैंडल लेफ्टिनेंट; 0) वापसी (-1);
c_copyright = (सी) ओपराइट 2003, मेटाक्वाट्स सॉफ्टवेयर कॉर्प;
FileWriteInteger (FileHandle, संस्करण, LONG_VALUE);
FileWriteString (FileHandle, c_copyright, 64);
FileWriteString (FileHandle, MySymbol, 12);
FileWriteInteger (FileHandle, NewPeriod, LONG_VALUE);
FileWriteInteger (FileHandle, i_digits, LONG_VALUE);
FileWriteInteger (FileHandle, 0, LONG_VALUE);/timesign
FileWriteInteger (FileHandle, 0, LONG_VALUE);/last_sync
FileWriteArray (FileHandle, i_unused, 0, ArraySize (i_unused));
वापसी (0);
}
स्थिर डबल d_open, d_low, d_high, d_close, d_volume;
स्थैतिक int i_time;
शून्य लिखें हिस्ट्रीडाटा ()
{
अगर (फाइलहैंडल gt; = 0) {
FileWriteInteger (FileHandle, i_time GMTShift * 60 * 60, LONG_VALUE);
FileWriteDouble (FileHandle, d_open, DOUBLE_VALUE);
FileWriteDouble (FileHandle, d_low, DOUBLE_VALUE);
FileWriteDouble (FileHandle, d_high, DOUBLE_VALUE);
FileWriteDouble (FileHandle, d_close, DOUBLE_VALUE);
FileWriteDouble (FileHandle, d_volume, DOUBLE_VALUE);
}
अगर (सीएसवीएचंडल gt; = 0) {
int i_digits = अंक-ओमिटडिजिट;
FileWrite (CSVHandle,
TimeToStr (i_time, TIME_DATE),
TimeToStr (i_time, TIME_MINUTES),
DoubleToStr (d_open, i_digits),
DoubleToStr (d_high, i_digits),
DoubleToStr (d_low, i_digits),
DoubleToStr (d_close, i_digits),
d_volume);
}
}
int UpdateHistoryFile (int start_pos, bool init = false)
{
स्थिर int last_fpos, csv_fpos;
int i, ps;
//अगर (फाइलहैंडल लेफ्टिनेंट; 0) वापसी (-1);
//खुले समय को सामान्य करें
पीएस = न्यूपीरियोड * 60;
i_time = (समय [start_pos] -ShiftBase * ShiftTiming)ps;
i_time = i_time * ps ShiftBase * ShiftTiming;
अगर (init) {
//पहली बार, डेटा init
d_open = खोलें [start_pos];
d_low = कम [start_pos];
d_high = उच्च [start_pos];
d_close = बंद करें [start_pos];
d_volume = वॉल्यूम [start_pos];
मैं = start_pos - 1;
अगर (FileHandle gt; = 0) last_fpos = FileTell (FileHandle);
अगर (सीएसवीएचंडल gt; = 0) csv_fpos = फ़ाइलटेल (सीएसवीएचंडल);
} अन्य {
मैं = start_pos;
अगर (FileHandle gt; = 0) फ़ाइलसेक (फ़ाइलहैंडल, last_fpos, SEEK_ SET);
अगर (सीएसवीएचंडल gt; = 0) फाइलसेक (सीएसवीएचंडल, सीएसवी_फॉस, एसईईके_एसईटी);
}
अगर (i lt; 0) वापसी (-1);
int cnt = 0;
int LastBarTime;
//प्रसंस्करण सलाखों
जबकि (i gt; = 0) {
LastBarTime = समय [i];
//एक नई बार
अगर (LastBarTime gt; = i_time ps) {
//बार डेटा लिखें
WriteHistoryData ();
cnt ;
i_time = (LastBarTime-ShiftBase * ShiftTiming)ps;
i_time = i_time * ps ShiftBase * ShiftTiming;
d_open = ओपन [i];
d_low = कम [i];
d_high = उच्च [i];
d_close = बंद करें [i];
d_volume = वॉल्यूम [i];
} अन्य {
//कोई नई बार नहीं
d_volume = वॉल्यूम [i];
अगर (कम [i] lt; d_low) d_low = कम [i];
अगर (उच्च [i] मिलता है; डी उच्च) डी उच्च = उच्च [i];
d_close = बंद करें [i];
}
मैं--;
}
अंतिम बार लिखने से पहले/last last_fpos रिकॉर्ड करें।
अगर (FileHandle gt; = 0) last_fpos = FileTell (FileHandle);
अगर (सीएसवीएचंडल gt; = 0) csv_fpos = फ़ाइलटेल (सीएसवीएचंडल);
WriteHistoryData ();
cnt ;
d_volume - = वॉल्यूम [0];
//लिखित डेटा फ्लश करें
अगर (FileHandle gt; = 0) फ़ाइलफ्लश (फ़ाइलहैंडल);
अगर (सीएसवीएचंडल gt; = 0) फाइलफ्लश (सीएसवीएचंडल);
वापसी (सीएनटी);
}
int UpdateChartWindow ()
{
स्थिर int hwnd = 0;
अगर (फाइलहैंडल लेफ्टिनेंट; 0) {
//कोई एचएसटी फ़ाइल खोला नहीं, अद्यतन करने की कोई ज़रूरत नहीं है।
वापसी (-1);
}
अगर (hwnd == 0) {
//अद्यतन करने के लिए चार्ट विंडो का पता लगाने की कोशिश कर रहा है
hwnd = windowHandle (MySymbol, NewPeriod);
}
अगर (hwnd! = 0) {
अगर (IsDllsAllowed () == झूठी) {
//डीएलएल कॉल की अनुमति दी जानी चाहिए
DebugMsg (डीएल कॉल की अनुमति दी जानी चाहिए);
वापसी (-1);
}
अगर (PostMessageA (hwnd, WM_COMMAND, चार्ट _CMD_UPDATE_DATA, 0) == 0) {
//PostMessage विफल, चार्ट विंडो बंद है
hwnd = 0;
} अन्य {
//PostMessage सफल
वापसी (0);
}
}
//विंडो नहीं मिली या पोस्टमेस विफल रहा
वापसी (-1);
}
/*
int PerfCheck (बूल स्टार्ट)
{
स्थैतिक int स्टार्टटाइम = 0;
स्थिर int सूचकांक = 0;
अगर (प्रारंभ) {
स्टार्टटाइम = GetTickCount ();
सूचकांक = 0;
वापसी (स्टार्टटाइम);
}
सूचकांक ;
int diff = GetTickCount () - स्टार्टटाइम;
चेतावनी (समय का उपयोग किया गया [ सूचकांक ]: diff);
स्टार्टटाइम = GetTickCount ();
वापसी (diff);
}
*
स्थैतिक int LastStartTime = 0;
स्थैतिक int LastEndTime = 0;
स्थिर int LastBarCount = 0;
शून्य पुनर्मिलन ()
{
deinit ();
इस में();
LastStartTime = समय [बार्स -1];
LastEndTime = समय [0];
LastBarCount = बार्स;
}
बूल IsDataChanged ()
{
/*
स्थैतिक int LastBars = 0, LastTime = 0, LastVolume = 0;
स्थैतिक डबल LastOpen = 0, LastClose = 0, LastHigh = 0, LastLow = 0;
अगर (LastVolume! = वॉल्यूम [0] || लास्टबार्स! = बार्स || लास्टटाइम! = समय [0] ||
LastClose! = बंद करें [0] || LastHigh! = उच्च [0] || LastLow! = कम [0] ||
LastOpen! = खोलें [0]) {
LastBars = बार्स;
LastVolume = वॉल्यूम [0];
अंतिम समय = समय [0];
LastClose = बंद करें [0];
LastHigh = उच्च [0];
LastLow = कम [0];
LastOpen = ओपन [0];
वापसी (सच);
}
विवरण झूठा है);
*
/*
फ्लोट प्वाइंट ऑपरेशन के बिना तेज़ संस्करण
*
स्थैतिक int LastBars = 0, LastTime = 0, LastVolume = 0;
बूल रिट;
पीछे = झूठा;
अगर (LastVolume! = वॉल्यूम [0]) {
LastVolume = वॉल्यूम [0];
ret = true;
}
अगर (अंतिम समय! = समय [0]) {
अंतिम समय = समय [0];
ret = true;
}
अगर (लास्टबार्स! = बार्स) {
LastBars = बार्स;
ret = true;
}
वापसी (पीछे);
}
int CheckNewData ()
{
स्थैतिक स्ट्रिंग LastServer =;
अगर (बार्स लेफ्टिनेंट; 2) {
//डेटा अभी तक लोड नहीं हुआ है।
DebugMsg (डेटा लोड नहीं किया गया, केवल बार्स बार्स);
वापसी (-1);
}
स्ट्रिंग सर्व = सर्वर एड्रेस ();
अगर (सर्वो ==) {
//अभी तक कोई सर्वर नहीं है
DebugMsg (कोई सर्वर कनेक्ट नहीं है);
वापसी (-1);
}
//सर्वर बदल गया? सर्वर को बदलते समय गलत डेटा को रोकने के लिए इसे जांचें और पुनः लिखें।
अगर (LastServer! = सर्वो) {
DebugMsg (सर्वर अंतिम सर्वर से सर्वर में बदल गया);
LastServer = सर्वो;
reinit ();
वापसी (-1);
}
अगर (! IsDataChanged ()) {
//वापसी अगर संसाधन को बचाने के लिए कोई डेटा नहीं बदला गया है
//DebugMsg (कोई डेटा नहीं बदला गया);
वापसी (-1);
}
अगर (समय [बार्स -1]! = LastStartTime) {
DebugMsg (प्रारंभ समय बदल गया, नया इतिहास लोड या सर्वर बदल गया);
reinit ();
वापसी (-1);
}
int i, cnt;
//LastEndTime बार खोजने का प्रयास करें, जो समय [0] या समय [1] होना चाहिए, आमतौर पर,
//तो ऑपरेशन तेज़ है
के लिए (i = 0; i lt; बार्स; i ) {
अगर (समय [i] lt; = LastEndTime) {
टूटना;
}
}
अगर (i gt; = बार्स || समय [i]! = LastEndTime) {
DebugMsg (समाप्ति समय TimeToStr (LastEndTime) नहीं मिला);
reinit ();
वापसी (-1);
}
सीएनटी = बार्स - मैं;
अगर (सीएनटी! = लास्टबार्काउंट) {
DebugMsg (डेटा लोड किया गया, सीएनटी cnt LastBarCount LastBarCount है);
reinit ();
वापसी (-1);
}
//कोई नया डेटा लोड नहीं हुआ, LastEndTime स्थिति के साथ वापस आना।
LastBarCount = बार्स;
LastEndTime = समय [0];
वापसी (i);
}
// ------------------------------------ ----------- -------------------
//| कार्यक्रम शुरू समारोह |
// ------------------------------------ ----------- -------------------
int प्रारंभ ()
{
स्थैतिक int last_time = 0;
अगर (! सक्षम) वापसी (0);
//हमेशा कुछ अंतराल के बाद अद्यतन या अद्यतन करें
अगर (अद्यतन इंटरवल! = 0) {
int cur_time;
cur_time = GetTickCount ();
अगर (MathAbs (cur_time - last_time) lt; अद्यतन इंटरवल) {
वापसी (0);
}
last_time = cur_time;
}
//अगर (डीबग) PerfCheck (सच);
int n = checkNewData ();
//अगर (डीबग) पेर्फ चेक (झूठा);
अगर (एन लेफ्टिनेंट; 0) वापसी (0);
//नए डेटा के साथ अद्यतन इतिहास फ़ाइल
UpdateHistoryFile (एन);
//ताज़ा चार्ट विंडो
UpdateChartWindow ();
//अगर (डीबग) पेर्फ चेक (झूठा);
वापसी (0);
}
अनुलग्नक संकेतक:
संलग्न फाइल
https://www.asjforex.com/attachments...9574793598.mq460 केबी | 0 डाउनलोड
मूल्य के साथ जवाब दीजिये
Originally Posted by ;
