DoEasy. Funções de serviço (Parte 2): Padrão "Barra Interna"
MetaTrader 5
—
Exemplos
| 16 agosto 2024, 08:20
17
0
Conteúdo
- Conceito
- Melhorias nas classes da biblioteca
- Classe do elemento gráfico "Desenho"
- Classe do padrão "Barra Interna"
- Testes
- Próximos passos
Conceito
Continuamos a desenvolver padrões formados com base em séries temporais. No primeiro artigo desta série sobre padrões, criamos ferramentas para localizar e exibir vários padrões, além de criar uma funcionalidade para identificar o padrão "Pin Bar" nas formações Price Action. Neste artigo, vamos expandir e refinar essa funcionalidade para localizar outros padrões nos gráficos de preços, incluindo o padrão "Barra Interna" (Inside Bar) das formações Price Action.
Enquanto o padrão "Pin Bar" é uma formação de uma única vela e é identificado pelas proporções da mesma, a "Barra Interna" é uma formação de duas velas: a vela principal (à esquerda) e a vela secundária (à direita):
Para identificar essas formações, comparar as proporções de uma única vela não é suficiente. É necessário comparar duas velas próximas. Além disso, essas formações podem aparecer em sequência. Nesse caso, uma única vela principal serve para todas as formações aninhadas e será a mais à esquerda. Já as velas secundárias serão várias, cada uma representando o lado direito de uma formação aninhada. A vela mais à direita será a última das velas secundárias em toda a formação aninhada. Para localizar essas estruturas, desenvolvemos uma funcionalidade universal e adicionamos uma nova propriedade aos padrões, nomeadamente o tempo de abertura da vela principal. A diferença entre os tempos de abertura da vela principal e da secundária nos ajuda a saber quantas velas fazem parte da formação aninhada. Isso é útil para marcar os padrões no gráfico. Além de marcar cada padrão com um ponto no gráfico, também podemos indicar visualmente o padrão cercando as velas da formação com uma moldura. Também incluiremos a opção de escolher diferentes maneiras de exibir os padrões no gráfico.
A funcionalidade que desenvolvemos hoje vai ser útil para criar outros tipos de padrões.
Melhorias nas classes da biblioteca
Antes de começarmos a codificar o próximo padrão, vamos melhorar os arquivos e classes que já temos na biblioteca.
No arquivo \MQL5\Include\DoEasy\Defines.mqh, adicionamos à lista de tipos de objetos da biblioteca o tipo "desenho":
//+------------------------------------------------------------------+ //| List of library object types | //+------------------------------------------------------------------+ enum ENUM_OBJECT_DE_TYPE { //--- Graphics OBJECT_DE_TYPE_GBASE = COLLECTION_ID_LIST_END+1, // "Base object of all library graphical objects" object type OBJECT_DE_TYPE_GELEMENT, // "Graphical element" object type OBJECT_DE_TYPE_GFORM, // Form object type OBJECT_DE_TYPE_GFORM_CONTROL, // "Form for managing pivot points of graphical object" object type OBJECT_DE_TYPE_GSHADOW, // Shadow object type OBJECT_DE_TYPE_GGLARE, // Glare object type OBJECT_DE_TYPE_GBITMAP, // Bitmap object type //--- WinForms OBJECT_DE_TYPE_GWF_BASE, // WinForms Base object type (base abstract WinForms object) OBJECT_DE_TYPE_GWF_CONTAINER, // WinForms container object type OBJECT_DE_TYPE_GWF_COMMON, // WinForms standard control object type OBJECT_DE_TYPE_GWF_HELPER, // WinForms auxiliary control object type //--- Animation //--- ... //---...
Os objetos do tipo OBJ_BITMAP permitem anexar a eles um recurso bmp e desenhar nele vários elementos primitivos. Esse objeto é vinculado ao tempo da vela e ao preço. Vamos utilizá-los para desenhar uma moldura ao redor das velas que compõem os padrões.
Além de armazenar os tempos das velas onde os padrões foram identificados, vamos adicionar ao objeto-vela da biblioteca os tipos de padrões encontrados. Como os tipos de padrões são representados por flags de bits, é possível armazenar múltiplos padrões em uma única variável, permitindo extrair posteriormente o tipo e o nome de todos os padrões identificados na vela.
Isso é oportuno ao procurar o padrão com o qual se precisa trabalhar a partir de um programa do usuário: obtemos o objeto-barra, verificamos os tipos de padrões encontrados nele e trabalhamos exatamente com aqueles cujas flags estão armazenadas na variável.
Nas propriedades inteiras do objeto-barra, adicionamos mais uma propriedade e aumentamos o número de propriedades inteiras do objeto-barra de 13 para 14:
//+------------------------------------------------------------------+ //| Bar integer properties | //+------------------------------------------------------------------+ enum ENUM_BAR_PROP_INTEGER { BAR_PROP_TIME = 0, // Bar period start time BAR_PROP_TYPE, // Bar type (from the ENUM_BAR_BODY_TYPE enumeration) BAR_PROP_PERIOD, // Bar period (timeframe) BAR_PROP_SPREAD, // Bar spread BAR_PROP_VOLUME_TICK, // Bar tick volume BAR_PROP_VOLUME_REAL, // Bar exchange volume BAR_PROP_TIME_DAY_OF_YEAR, // Bar day serial number in a year BAR_PROP_TIME_YEAR, // A year the bar belongs to BAR_PROP_TIME_MONTH, // A month the bar belongs to BAR_PROP_TIME_DAY_OF_WEEK, // Bar week day BAR_PROP_TIME_DAY, // Bar day of month (number) BAR_PROP_TIME_HOUR, // Bar hour BAR_PROP_TIME_MINUTE, // Bar minute BAR_PROP_PATTERNS_TYPE, // Pattern types on the bar (pattern flags from the ENUM_PATTERN_TYPE enumeration) }; #define BAR_PROP_INTEGER_TOTAL (14) // Total number of integer bar properties
Ao procurar padrões nas listas de séries temporais e encontrar um padrão na barra, adicionaremos o tipo do padrão encontrado a essa variável no objeto-barra. Como resultado da busca de vários tipos de padrões, as diferentes flags dos padrões encontrados podem ser salvas nessa variável em uma barra.
Na lista de possíveis critérios de ordenação dos objetos-barra, incluímos a ordenação por tipo de padrões na barra:
//+------------------------------------------------------------------+ //| Possible bar sorting criteria | //+------------------------------------------------------------------+ #define FIRST_BAR_DBL_PROP (BAR_PROP_INTEGER_TOTAL-BAR_PROP_INTEGER_SKIP) #define FIRST_BAR_STR_PROP (BAR_PROP_INTEGER_TOTAL-BAR_PROP_INTEGER_SKIP+BAR_PROP_DOUBLE_TOTAL-BAR_PROP_DOUBLE_SKIP) enum ENUM_SORT_BAR_MODE { //--- Sort by integer properties SORT_BY_BAR_TIME = 0, // Sort by bar period start time SORT_BY_BAR_TYPE, // Sort by bar type (from the ENUM_BAR_BODY_TYPE enumeration) SORT_BY_BAR_PERIOD, // Sort by bar period (timeframe) SORT_BY_BAR_SPREAD, // Sort by bar spread SORT_BY_BAR_VOLUME_TICK, // Sort by bar tick volume SORT_BY_BAR_VOLUME_REAL, // Sort by bar exchange volume SORT_BY_BAR_TIME_DAY_OF_YEAR, // Sort by bar day number in a year SORT_BY_BAR_TIME_YEAR, // Sort by a year the bar belongs to SORT_BY_BAR_TIME_MONTH, // Sort by a month the bar belongs to SORT_BY_BAR_TIME_DAY_OF_WEEK, // Sort by a bar week day SORT_BY_BAR_TIME_DAY, // Sort by a bar day SORT_BY_BAR_TIME_HOUR, // Sort by a bar hour SORT_BY_BAR_TIME_MINUTE, // Sort by a bar minute SORT_BY_BAR_PATTERN_TYPE, // Sort by pattern types on the bar (pattern flags from the ENUM_PATTERN_TYPE enumeration) //--- Sort by real properties SORT_BY_BAR_OPEN = FIRST_BAR_DBL_PROP, // Sort by bar open price SORT_BY_BAR_HIGH, // Sort by the highest price for the bar period SORT_BY_BAR_LOW, // Sort by the lowest price for the bar period SORT_BY_BAR_CLOSE, // Sort by a bar close price SORT_BY_BAR_CANDLE_SIZE, // Sort by a candle price SORT_BY_BAR_CANDLE_SIZE_BODY, // Sort by a candle body size SORT_BY_BAR_CANDLE_BODY_TOP, // Sort by a candle body top SORT_BY_BAR_CANDLE_BODY_BOTTOM, // Sort by a candle body bottom SORT_BY_BAR_CANDLE_SIZE_SHADOW_UP, // Sort by candle upper wick size SORT_BY_BAR_CANDLE_SIZE_SHADOW_DOWN, // Sort by candle lower wick size //--- Sort by string properties SORT_BY_BAR_SYMBOL = FIRST_BAR_STR_PROP, // Sort by a bar symbol };
Anteriormente, no enum de tipos de padrões, o valor 0 era atribuído ao padrão "Harami". Isso não é totalmente correto. Afinal, seria melhor se zero indicasse a ausência de padrões na barra.
Corrigiremos isso e adicionaremos uma macro substituição que indica o número total de padrões disponíveis para busca na biblioteca:
//+------------------------------------------------------------------+ //| Pattern type | //+------------------------------------------------------------------+ enum ENUM_PATTERN_TYPE { //--- Candle formations PATTERN_TYPE_NONE = 0x0, // None PATTERN_TYPE_HARAMI = 0x1, // Harami PATTERN_TYPE_HARAMI_CROSS = 0x2, // Harami Cross PATTERN_TYPE_TWEEZER = 0x4, // Tweezer PATTERN_TYPE_PIERCING_LINE = 0x8, // Piercing Line PATTERN_TYPE_DARK_CLOUD_COVER = 0x10, // Dark Cloud Cover PATTERN_TYPE_THREE_WHITE_SOLDIERS= 0x20, // Three White Soldiers PATTERN_TYPE_THREE_BLACK_CROWS = 0x40, // Three Black Crows PATTERN_TYPE_SHOOTING_STAR = 0x80, // Shooting Star PATTERN_TYPE_HAMMER = 0x100, // Hammer PATTERN_TYPE_INVERTED_HAMMER = 0x200, // Inverted Hammer PATTERN_TYPE_HANGING_MAN = 0x400, // Hanging Man PATTERN_TYPE_DOJI = 0x800, // Doji PATTERN_TYPE_DRAGONFLY_DOJI = 0x1000, // Dragonfly Doji PATTERN_TYPE_GRAVESTONE_DOJI = 0x2000, // Gravestone Doji PATTERN_TYPE_MORNING_STAR = 0x4000, // Morning Star PATTERN_TYPE_MORNING_DOJI_STAR = 0x8000, // Morning Doji Star PATTERN_TYPE_EVENING_STAR = 0x10000, // Evening Star PATTERN_TYPE_EVENING_DOJI_STAR = 0x20000, // Evening Doji Star PATTERN_TYPE_THREE_STARS = 0x40000, // Three Stars PATTERN_TYPE_ABANDONED_BABY = 0x80000, // Abandoned Baby //--- Price Action PATTERN_TYPE_PIVOT_POINT_REVERSAL= 0x100000, // Price Action Reversal Pattern PATTERN_TYPE_OUTSIDE_BAR = 0x200000, // Price Action Outside Bar PATTERN_TYPE_INSIDE_BAR = 0x400000, // Price Action Inside Bar PATTERN_TYPE_PIN_BAR = 0x800000, // Price Action Pin Bar PATTERN_TYPE_RAILS = 0x1000000, // Price Action Rails }; #define PATTERNS_TOTAL (26) // Total number of patterns (including the missing one)
À lista de propriedades inteiras do padrão, adicionaremos uma nova propriedade que armazena o tempo da barra principal e aumentaremos o número de propriedades inteiras do padrão de 9 para 10:
//+------------------------------------------------------------------+ //| Pattern integer properties | //+------------------------------------------------------------------+ enum ENUM_PATTERN_PROP_INTEGER { PATTERN_PROP_CODE = 0, // Unique pattern code (time + type + status + direction + timeframe + symbol) PATTERN_PROP_CTRL_OBJ_ID, // Pattern control object ID PATTERN_PROP_ID, // Pattern ID PATTERN_PROP_TIME, // Pattern defining bar time PATTERN_PROP_MOTHERBAR_TIME, // Pattern mother bar time PATTERN_PROP_STATUS, // Pattern status (from the ENUM_PATTERN_STATUS enumeration) PATTERN_PROP_TYPE, // Pattern type (from the ENUM_PATTERN_TYPE enumeration) PATTERN_PROP_DIRECTION, // Pattern type by direction (from the ENUM_PATTERN_TYPE_DIRECTION enumeration) PATTERN_PROP_PERIOD, // Pattern period (timeframe) PATTERN_PROP_CANDLES, // Number of candles that make up the pattern }; #define PATTERN_PROP_INTEGER_TOTAL (10) // Total number of integer pattern properties
Na lista de possíveis critérios de organização dos padrões, adicionaremos a ordenação por essa nova propriedade:
//+------------------------------------------------------------------+ //| Possible pattern sorting criteria | //+------------------------------------------------------------------+ #define FIRST_PATTERN_DBL_PROP (PATTERN_PROP_INTEGER_TOTAL-PATTERN_PROP_INTEGER_SKIP) #define FIRST_PATTERN_STR_PROP (PATTERN_PROP_INTEGER_TOTAL-PATTERN_PROP_INTEGER_SKIP+PATTERN_PROP_DOUBLE_TOTAL-PATTERN_PROP_DOUBLE_SKIP) enum ENUM_SORT_PATTERN_MODE { //--- Sort by integer properties SORT_BY_PATTERN_CODE = 0, // Sort by unique pattern code (time + type + status + direction + timeframe) SORT_BY_PATTERN_CTRL_OBJ_ID, // Sort by pattern control object ID SORT_BY_PATTERN_ID, // Sort by pattern ID SORT_BY_PATTERN_TIME, // Sort by pattern defining bar time SORT_BY_PATTERN_MOTHERBAR_TIME, // Sort by pattern mother bar time SORT_BY_PATTERN_STATUS, // Sort by pattern status (from the ENUM_PATTERN_STATUS enumeration) SORT_BY_PATTERN_TYPE, // Sort by pattern type (from the ENUM_PATTERN_TYPE enumeration) SORT_BY_PATTERN_DIRECTION, // Sort by pattern type based on direction (from the ENUM_PATTERN_TYPE_DIRECTION enumeration) SORT_BY_PATTERN_PERIOD, // Sort by pattern period (timeframe) SORT_BY_PATTERN_CANDLES, // Sort by the number of candles that make up the pattern //--- Sort by real properties SORT_BY_PATTERN_BAR_PRICE_OPEN = FIRST_PATTERN_DBL_PROP, // Sort by pattern defining bar Open price SORT_BY_PATTERN_BAR_PRICE_HIGH, // Sort by pattern defining bar High price SORT_BY_PATTERN_BAR_PRICE_LOW, // Sort by pattern defining bar Low price SORT_BY_PATTERN_BAR_PRICE_CLOSE, // Sort by pattern defining bar Close price SORT_BY_PATTERN_RATIO_BODY_TO_CANDLE_SIZE, // Sort by percentage ratio of the candle body to the full size of the candle SORT_BY_PATTERN_RATIO_UPPER_SHADOW_TO_CANDLE_SIZE, // Sort by percentage ratio of the upper shadow size to the candle size SORT_BY_PATTERN_RATIO_LOWER_SHADOW_TO_CANDLE_SIZE, // Sort by percentage ratio of the lower shadow size to the candle size SORT_BY_PATTERN_RATIO_BODY_TO_CANDLE_SIZE_CRITERION, // Sort by defined criterion of the ratio of the candle body to the full candle size in % SORT_BY_PATTERN_RATIO_LARGER_SHADOW_TO_CANDLE_SIZE_CRITERION, // Sort by defined criterion of the ratio of the maximum shadow to the candle size in % SORT_BY_PATTERN_RATIO_SMALLER_SHADOW_TO_CANDLE_SIZE_CRITERION, // Sort by defined criterion of the ratio of the minimum shadow to the candle size in % //--- Sort by string properties SORT_BY_PATTERN_SYMBOL = FIRST_BAR_STR_PROP, // Sort by a pattern symbol SORT_BY_PATTERN_NAME, // Sort by pattern name };
Na lista de tipos de elementos gráficos, adicionaremos um novo tipo: objeto-desenho:
//+------------------------------------------------------------------+ //| The list of graphical element types | //+------------------------------------------------------------------+ enum ENUM_GRAPH_ELEMENT_TYPE { GRAPH_ELEMENT_TYPE_STANDARD, // Standard graphical object GRAPH_ELEMENT_TYPE_STANDARD_EXTENDED, // Extended standard graphical object GRAPH_ELEMENT_TYPE_SHADOW_OBJ, // Shadow object GRAPH_ELEMENT_TYPE_ELEMENT, // Element GRAPH_ELEMENT_TYPE_BITMAP, // Bitmap GRAPH_ELEMENT_TYPE_FORM, // Form GRAPH_ELEMENT_TYPE_WINDOW, // Window //--- WinForms GRAPH_ELEMENT_TYPE_WF_UNDERLAY, // Panel object underlay GRAPH_ELEMENT_TYPE_WF_BASE, // Windows Forms Base //--- 'Container' object types are to be set below GRAPH_ELEMENT_TYPE_WF_CONTAINER, // Windows Forms container base object GRAPH_ELEMENT_TYPE_WF_PANEL, // Windows Forms Panel GRAPH_ELEMENT_TYPE_WF_GROUPBOX, // Windows Forms GroupBox GRAPH_ELEMENT_TYPE_WF_TAB_CONTROL, // Windows Forms TabControl GRAPH_ELEMENT_TYPE_WF_SPLIT_CONTAINER, // Windows Forms SplitContainer //--- 'Standard control' object types are to be set below GRAPH_ELEMENT_TYPE_WF_COMMON_BASE, // Windows Forms base standard control GRAPH_ELEMENT_TYPE_WF_LABEL, // Windows Forms Label GRAPH_ELEMENT_TYPE_WF_BUTTON, // Windows Forms Button GRAPH_ELEMENT_TYPE_WF_CHECKBOX, // Windows Forms CheckBox GRAPH_ELEMENT_TYPE_WF_RADIOBUTTON, // Windows Forms RadioButton GRAPH_ELEMENT_TYPE_WF_ELEMENTS_LIST_BOX, // Base list object of Windows Forms elements GRAPH_ELEMENT_TYPE_WF_LIST_BOX, // Windows Forms ListBox GRAPH_ELEMENT_TYPE_WF_CHECKED_LIST_BOX, // Windows Forms CheckedListBox GRAPH_ELEMENT_TYPE_WF_BUTTON_LIST_BOX, // Windows Forms ButtonListBox GRAPH_ELEMENT_TYPE_WF_TOOLTIP, // Windows Forms ToolTip GRAPH_ELEMENT_TYPE_WF_PROGRESS_BAR, // Windows Forms ProgressBar //--- Auxiliary elements of WinForms objects GRAPH_ELEMENT_TYPE_WF_LIST_BOX_ITEM, // Windows Forms ListBoxItem GRAPH_ELEMENT_TYPE_WF_TAB_HEADER, // Windows Forms TabHeader GRAPH_ELEMENT_TYPE_WF_TAB_FIELD, // Windows Forms TabField GRAPH_ELEMENT_TYPE_WF_SPLIT_CONTAINER_PANEL, // Windows Forms SplitContainerPanel GRAPH_ELEMENT_TYPE_WF_ARROW_BUTTON, // Windows Forms ArrowButton GRAPH_ELEMENT_TYPE_WF_ARROW_BUTTON_UP, // Windows Forms UpArrowButton GRAPH_ELEMENT_TYPE_WF_ARROW_BUTTON_DOWN, // Windows Forms DownArrowButton GRAPH_ELEMENT_TYPE_WF_ARROW_BUTTON_LEFT, // Windows Forms LeftArrowButton GRAPH_ELEMENT_TYPE_WF_ARROW_BUTTON_RIGHT, // Windows Forms RightArrowButton GRAPH_ELEMENT_TYPE_WF_ARROW_BUTTONS_UD_BOX, // Windows Forms UpDownArrowButtonsBox GRAPH_ELEMENT_TYPE_WF_ARROW_BUTTONS_LR_BOX, // Windows Forms LeftRightArrowButtonsBox GRAPH_ELEMENT_TYPE_WF_SPLITTER, // Windows Forms Splitter GRAPH_ELEMENT_TYPE_WF_HINT_BASE, // Windows Forms HintBase GRAPH_ELEMENT_TYPE_WF_HINT_MOVE_LEFT, // Windows Forms HintMoveLeft GRAPH_ELEMENT_TYPE_WF_HINT_MOVE_RIGHT, // Windows Forms HintMoveRight GRAPH_ELEMENT_TYPE_WF_HINT_MOVE_UP, // Windows Forms HintMoveUp GRAPH_ELEMENT_TYPE_WF_HINT_MOVE_DOWN, // Windows Forms HintMoveDown GRAPH_ELEMENT_TYPE_WF_BAR_PROGRESS_BAR, // Windows Forms BarProgressBar GRAPH_ELEMENT_TYPE_WF_GLARE_OBJ, // Glare object GRAPH_ELEMENT_TYPE_WF_SCROLL_BAR_THUMB, // Windows Forms ScrollBarThumb GRAPH_ELEMENT_TYPE_WF_SCROLL_BAR, // Windows Forms ScrollBar GRAPH_ELEMENT_TYPE_WF_SCROLL_BAR_HORISONTAL, // Windows Forms ScrollBarHorisontal GRAPH_ELEMENT_TYPE_WF_SCROLL_BAR_VERTICAL, // Windows Forms ScrollBarVertical };Este é um novo tipo de objeto gráfico na biblioteca, vinculado às coordenadas preço/tempo, permitindo desenhar nele da mesma forma que nos elementos da GUI da biblioteca. Por essa razão, foi adicionado a essa lista, assim ele pode ser usado para outras necessidades da biblioteca, além de desenhar as barras dos padrões no gráfico de preços.
No arquivo da biblioteca \MQL5\Include\DoEasy\Data.mqh inseriremos os índices das novas mensagens da biblioteca:
//+------------------------------------------------------------------+ //| List of the library's text message indices | //+------------------------------------------------------------------+ enum ENUM_MESSAGES_LIB { MSG_LIB_PARAMS_LIST_BEG=ERR_USER_ERROR_FIRST, // Beginning of the parameter list MSG_LIB_PARAMS_LIST_END, // End of the parameter list MSG_LIB_PROP_NOT_SUPPORTED, // Property not supported MSG_LIB_PROP_NOT_SUPPORTED_MQL4, // Property not supported in MQL4 MSG_LIB_PROP_NOT_SUPPORTED_MT5_LESS_2155, // Property not supported in MetaTrader 5 versions lower than 2155 MSG_LIB_PROP_NOT_SUPPORTED_MT5_LESS_3245, // Property not supported in MetaTrader 5 versions lower than 3245 MSG_LIB_PROP_NOT_SUPPORTED_MT5_LESS_3260, // Property not supported in MetaTrader 5 versions lower than 3260 MSG_LIB_PROP_NOT_SUPPORTED_POSITION, // Property not supported for position MSG_LIB_PROP_NOT_SUPPORTED_PENDING, // Property not supported for pending order MSG_LIB_PROP_NOT_SUPPORTED_MARKET, // Property not supported for market order MSG_LIB_PROP_NOT_SUPPORTED_MARKET_HIST, // Property not supported for historical market order MSG_LIB_PROP_NOT_SET, // Value not set MSG_LIB_PROP_EMPTY, // Not set MSG_LIB_PROP_NOT_FOUND, // Not found MSG_LIB_PROP_AUTO, // Generated by the terminal MSG_LIB_PROP_AS_IN_ORDER, // According to the order expiration mode
...
MSG_LIB_TEXT_BAR_RATIO_BODY_TO_CANDLE_SIZE, // Ratio of the candle body to the full size of the candle MSG_LIB_TEXT_BAR_RATIO_UPPER_SHADOW_TO_CANDLE_SIZE,// Ratio of the upper shadow size to the candle size MSG_LIB_TEXT_BAR_RATIO_LOWER_SHADOW_TO_CANDLE_SIZE,// Ratio of the lower shadow size to the candle size MSG_LIB_TEXT_BAR_PATTERNS_TYPE, // Types of patterns on the bar //--- CTimeSeries
...
//--- CPattern MSG_LIB_TEXT_PATTERN_CODE, // Code MSG_LIB_TEXT_PATTERN_TIME, // Defining bar time MSG_LIB_TEXT_PATTERN_MOTHERBAR_TIME, // "Mother" bar time MSG_LIB_TEXT_PATTERN_ID, // Pattern ID MSG_LIB_TEXT_PATTERN_CTRL_OBJ_ID, // Pattern control object ID
...
MSG_GRAPH_ELEMENT_TYPE_STANDARD_EXTENDED, // Extended standard graphical object MSG_GRAPH_ELEMENT_TYPE_ELEMENT, // Element MSG_GRAPH_ELEMENT_TYPE_BITMAP, // Bitmap MSG_GRAPH_ELEMENT_TYPE_SHADOW_OBJ, // Shadow object MSG_GRAPH_ELEMENT_TYPE_FORM, // Form
...
//--- String properties of graphical elements MSG_CANV_ELEMENT_PROP_NAME_OBJ, // Graphical element object name MSG_CANV_ELEMENT_PROP_NAME_RES, // Graphical resource name MSG_CANV_ELEMENT_PROP_TEXT, // Graphical element text MSG_CANV_ELEMENT_PROP_DESCRIPTION, // Graphical element description MSG_CANV_ELEMENT_PROP_TOOLTIP_TITLE, // Element tooltip title MSG_CANV_ELEMENT_PROP_TOOLTIP_TEXT, // Element tooltip text //--- CGCnvBitmap MSG_ERR_FAILED_SET_BITMAP_OBJ_TIME, // Failed to set the time value to the Bitmap object MSG_ERR_FAILED_SET_BITMAP_OBJ_PRICE, // Failed to set the price value for the Bitmap object };
e as mensagens de texto correspondentes aos novos índices adicionados:
string messages_library[][TOTAL_LANG]= { {"Начало списка параметров","The beginning of the parameter list"}, {"Конец списка параметров","End of parameter list"}, {"Свойство не поддерживается","Property not supported"}, {"Свойство не поддерживается в MQL4","Property not supported in MQL4"}, {"Свойство не поддерживается в MetaTrader5 версии ниже 2155","The property is not supported in MetaTrader5, build lower than 2155"}, {"Свойство не поддерживается в MetaTrader5 версии ниже 3245","The property is not supported in MetaTrader5, build lower than 3245"}, {"Свойство не поддерживается в MetaTrader5 версии ниже 3260","The property is not supported in MetaTrader5, build lower than 3260"}, {"Свойство не поддерживается у позиции","Property not supported for position"}, {"Свойство не поддерживается у отложенного ордера","The property is not supported for a pending order"}, {"Свойство не поддерживается у маркет-ордера","The property is not supported for a market-order"}, {"Свойство не поддерживается у исторического маркет-ордера","The property is not supported for a history market-order"}, {"Значение не задано","Value not set"}, {"Отсутствует","Not set"}, {"Не найдено","Not found"}, {"Формируется терминалом","Formed by the terminal"}, {"В соответствии с режимом истечения ордера","In accordance with the order expiration mode"},
...
{"Отношение тела свечи к полному размеру свечи","Ratio of candle body to full candle size"},
{"Отношение размера верхней тени к размеру свечи","Ratio of the upper shadow size to the candle size"},
{"Отношение размера нижней тени к размеру свечи","Ratio of the lower shadow size to the candle size"},
{"Типы паттернов на баре","Types of patterns on the bar"},
//--- CTimeSeries
...
//--- CPattern {"Код","Code"}, {"Время определяющего бара","Time of the defining bar"}, {"Время \"материнского\" бара","Time open of the mother bar"}, {"Идентификатор паттерна","Pattern ID"}, {"Идентификатор объекта управления паттерном","Pattern Control object ID"},
...
{"Расширенный стандартный графический объект","Extended standard graphic object"},
{"Элемент","Element"},
{"Рисунок","Bitmap"},
{"Объект тени","Shadow object"},
{"Форма","Form"},
...
//--- String properties of graphical elements {"Имя объекта-графического элемента","The name of the graphic element object"}, {"Имя графического ресурса","Image resource name"}, {"Текст графического элемента","Text of the graphic element"}, {"Описание графического элемента","Description of the graphic element"}, {"Заголовок подсказки элемента","Element tooltip header"}, {"Текст подсказки элемента","Element tooltip title"}, //--- CGCnvBitmap {"Не удалось установить значение времени Bitmap-объекту","Failed to set time value to Bitmap object"}, {"Не удалось установить значение цены Bitmap-объекту","Failed to set price value to Bitmap object"}, };
Muitas vezes, é necessário verificar a validade dos valores de símbolo e período de gráfico passados para funções e métodos. Para evitar escrever o mesmo código repetitivo nesses casos, no arquivo \MQL5\Include\DoEasy\Services\DELib.mqh, escreveremos funções que retornam o nome válido do símbolo e o valor do período do gráfico:
//+------------------------------------------------------------------+ //| Service functions | //+------------------------------------------------------------------+ //+------------------------------------------------------------------+ //| Correct and return a symbol name | //+------------------------------------------------------------------+ string CorrectSymbol(const string symbol) { return(symbol==NULL || symbol=="" ? ::Symbol() : symbol); } //+------------------------------------------------------------------+ //| Correct and return a timeframe name | //+------------------------------------------------------------------+ ENUM_TIMEFRAMES CorrectTimeframe(const ENUM_TIMEFRAMES timeframe) { return(timeframe==PERIOD_CURRENT ? ::Period() : timeframe); }
Se valores NULL ou uma string vazia forem passados como nome do símbolo, ou 0 ou PERIOD_CURRENT como valor do período do gráfico, as funções retornarão o símbolo ou período atuais. Em qualquer outro caso, os valores passados para a função serão retornados. Assim, com essas funções, gradualmente substituiremos em toda a biblioteca os códigos onde são realizadas verificações semelhantes para validar os valores passados aos métodos.
Também adicionaremos funções que retornam descrições dos padrões:
//+------------------------------------------------------------------+ //| Return pattern type description | //+------------------------------------------------------------------+ string PatternTypeDescription(const ENUM_PATTERN_TYPE type) { switch(type) { case PATTERN_TYPE_HARAMI : return CMessage::Text(MSG_LIB_TEXT_PATTERN_TYPE_HARAMI); case PATTERN_TYPE_HARAMI_CROSS : return CMessage::Text(MSG_LIB_TEXT_PATTERN_TYPE_HARAMI_CROSS); case PATTERN_TYPE_TWEEZER : return CMessage::Text(MSG_LIB_TEXT_PATTERN_TYPE_TWEEZER); case PATTERN_TYPE_PIERCING_LINE : return CMessage::Text(MSG_LIB_TEXT_PATTERN_TYPE_PIERCING_LINE); case PATTERN_TYPE_DARK_CLOUD_COVER : return CMessage::Text(MSG_LIB_TEXT_PATTERN_TYPE_DARK_CLOUD_COVER); case PATTERN_TYPE_THREE_WHITE_SOLDIERS : return CMessage::Text(MSG_LIB_TEXT_PATTERN_TYPE_THREE_WHITE_SOLDIERS); case PATTERN_TYPE_THREE_BLACK_CROWS : return CMessage::Text(MSG_LIB_TEXT_PATTERN_TYPE_THREE_BLACK_CROWS); case PATTERN_TYPE_SHOOTING_STAR : return CMessage::Text(MSG_LIB_TEXT_PATTERN_TYPE_SHOOTING_STAR); case PATTERN_TYPE_HAMMER : return CMessage::Text(MSG_LIB_TEXT_PATTERN_TYPE_HAMMER); case PATTERN_TYPE_INVERTED_HAMMER : return CMessage::Text(MSG_LIB_TEXT_PATTERN_TYPE_INVERTED_HAMMER); case PATTERN_TYPE_HANGING_MAN : return CMessage::Text(MSG_LIB_TEXT_PATTERN_TYPE_HANGING_MAN); case PATTERN_TYPE_DOJI : return CMessage::Text(MSG_LIB_TEXT_PATTERN_TYPE_DOJI); case PATTERN_TYPE_DRAGONFLY_DOJI : return CMessage::Text(MSG_LIB_TEXT_PATTERN_TYPE_DRAGONFLY_DOJI); case PATTERN_TYPE_GRAVESTONE_DOJI : return CMessage::Text(MSG_LIB_TEXT_PATTERN_TYPE_GRAVESTONE_DOJI); case PATTERN_TYPE_MORNING_STAR : return CMessage::Text(MSG_LIB_TEXT_PATTERN_TYPE_MORNING_STAR); case PATTERN_TYPE_MORNING_DOJI_STAR : return CMessage::Text(MSG_LIB_TEXT_PATTERN_TYPE_MORNING_DOJI_STAR); case PATTERN_TYPE_EVENING_STAR : return CMessage::Text(MSG_LIB_TEXT_PATTERN_TYPE_EVENING_STAR); case PATTERN_TYPE_EVENING_DOJI_STAR : return CMessage::Text(MSG_LIB_TEXT_PATTERN_TYPE_EVENING_DOJI_STAR); case PATTERN_TYPE_THREE_STARS : return CMessage::Text(MSG_LIB_TEXT_PATTERN_TYPE_THREE_STARS); case PATTERN_TYPE_ABANDONED_BABY : return CMessage::Text(MSG_LIB_TEXT_PATTERN_TYPE_ABANDONED_BABY); case PATTERN_TYPE_PIVOT_POINT_REVERSAL : return CMessage::Text(MSG_LIB_TEXT_PATTERN_TYPE_PIVOT_POINT_REVERSAL); case PATTERN_TYPE_OUTSIDE_BAR : return CMessage::Text(MSG_LIB_TEXT_PATTERN_TYPE_OUTSIDE_BAR); case PATTERN_TYPE_INSIDE_BAR : return CMessage::Text(MSG_LIB_TEXT_PATTERN_TYPE_INSIDE_BAR); case PATTERN_TYPE_PIN_BAR : return CMessage::Text(MSG_LIB_TEXT_PATTERN_TYPE_PIN_BAR); case PATTERN_TYPE_RAILS : return CMessage::Text(MSG_LIB_TEXT_PATTERN_TYPE_RAILS); default : return CMessage::Text(MSG_LIB_TEXT_FRAME_STYLE_NONE); } }
Dependendo do tipo de padrão passado para a função, a descrição textual correspondente será retornada.
Função que retorna o número e a lista de padrões na variável ulong:
//+------------------------------------------------------------------+ //| Return the number and list of patterns in the ulong variable | //+------------------------------------------------------------------+ int ListPatternsInVar(const ulong var,ulong &array[]) { int size=0; ulong x=1; //--- In the loop from 1 to the number of patterns PATTERNS_TOTAL-1 for(int i=1;i<PATTERNS_TOTAL;i++) { //--- set the value of the pattern flag to be checked from the ENUM_PATTERN_TYPE enumeration by the loop index x=(i>1 ? x*2 : 1); ENUM_PATTERN_TYPE type=(ENUM_PATTERN_TYPE)x; //--- If the value passed to the function contains the pattern flag with x value, bool res=(var & type)==type; if(res) { //--- increase the size of the pattern array size++; ArrayResize(array,size,PATTERNS_TOTAL-1); //--- write the pattern type to the array array[size-1]=type; } } //--- Return the number of pattern types stored in the variable return size; }
A função recebe uma variável contendo as flags dos padrões e um array no qual os tipos de padrões extraídos dessa variável serão gravados. Como cada flag é o dobro da anterior, é fácil, em um loop, formar o valor da flag a partir do valor do índice do loop e, em seguida, verificar a presença dessa flag no valor da variável. Se tal flag estiver registrada na variável, o tipo de padrão será gravado no array, que é previamente aumentado em 1 para armazenar o novo tipo de padrão. Ao final do loop pelos tipos de padrões, todos os padrões gravados na variável como flags serão inseridos no array, que então poderá ser utilizado no programa.
Função que exibe no log a descrição dos tipos de padrões na variável ulong:
//+-------------------------------------------------------------------------+ //| Send a description of pattern types in a ulong variable to the journal | //+-------------------------------------------------------------------------+ void PatternsInVarDescriptionPrint(const ulong var,const bool dash=false) { ulong array[]; //--- Get the number of patterns in the value passed to the function int total=ListPatternsInVar(var,array); //--- In the loop by the array of patterns, obtain a description of the next pattern and print it for(int i=0;i<total;i++) Print((dash ? " - " : ""),PatternTypeDescription((ENUM_PATTERN_TYPE)array[i])); }
A lógica do método é totalmente descrita nos comentários do código.
Função que retorna a descrição dos tipos de padrões na variável ulong:
//+------------------------------------------------------------------+ //| Return a description of pattern types in a ulong variable | //+------------------------------------------------------------------+ string PatternsInVarDescription(const ulong var,const bool dash=false) { ulong array[]; //--- Get the number of patterns in the value passed to the function int total=ListPatternsInVar(var,array); string txt=""; //--- In the loop by the array of patterns, obtain a description of the next pattern and add it to the text variable for(int i=0;i<total;i++) txt+=((dash ? " - " : "")+PatternTypeDescription((ENUM_PATTERN_TYPE)array[i]))+(i<total-1 ? "\n" : ""); //--- Return the obtained text return txt; }
Todas essas funções estão disponíveis de qualquer lugar do programa, proporcionando ao usuário um acesso simples às listas de padrões detectados em uma barra. Na propriedade da barra, agora existe uma variável que armazena as flags dos padrões encontrados, e pelo valor dessa propriedade, com a ajuda dessas funções, é sempre possível extrair todos os tipos de padrões na barra e processá-los no programa, o que faremos no EA de teste.
A classe do objeto gráfico no arquivo \MQL5\Include\DoEasy\Objects\Graph\GCnvElement.mqh serve como base para a criação de elementos GUI mais complexos, mas há algumas variáveis nesta classe cujo acesso está fechado para as classes derivadas. Moveremos essas variáveis e métodos da seção privada para a protegida:
//+------------------------------------------------------------------+ //| Class of the graphical element object | //+------------------------------------------------------------------+ class CGCnvElement : public CGBaseObj { protected: CGCnvElement *m_element_main; // Pointer to the initial parent element within all the groups of bound objects CGCnvElement *m_element_base; // Pointer to the parent element within related objects of the current group CCanvas m_canvas; // CCanvas class object CPause m_pause; // Pause class object bool m_shadow; // Shadow presence color m_chart_color_bg; // Chart background color uint m_duplicate_res[]; // Array for storing resource data copy color m_array_colors_bg[]; // Array of element background colors color m_array_colors_bg_dwn[]; // Array of control background colors when clicking on the control color m_array_colors_bg_ovr[]; // Array of control background colors when hovering the mouse over the control bool m_gradient_v; // Vertical gradient filling flag bool m_gradient_c; // Cyclic gradient filling flag int m_init_relative_x; // Initial relative X coordinate int m_init_relative_y; // Initial relative Y coordinate color m_array_colors_bg_init[]; // Array of element background colors (initial color) int m_shift_coord_x; // Offset of the X coordinate relative to the base object int m_shift_coord_y; // Offset of the Y coordinate relative to the base object //--- Create (1) the object structure and (2) the object from the structure
...
long m_long_prop[CANV_ELEMENT_PROP_INTEGER_TOTAL]; // Integer properties double m_double_prop[CANV_ELEMENT_PROP_DOUBLE_TOTAL]; // Real properties string m_string_prop[CANV_ELEMENT_PROP_STRING_TOTAL]; // String properties ENUM_FRAME_ANCHOR m_text_anchor; // Current text alignment int m_text_x; // Text last X coordinate int m_text_y; // Text last Y coordinate protected: //--- Initialize property values void Initialize(const ENUM_GRAPH_ELEMENT_TYPE element_type, const int element_id,const int element_num, const int x,const int y,const int w,const int h, const string descript,const bool movable,const bool activity); private: //--- Return the index of the array the order's (1) double and (2) string properties are located at
Na seção de métodos de manipulação de texto, escreveremos dois métodos para acessar a configuração das propriedades privadas da classe:
//+------------------------------------------------------------------+ //| Methods of working with text | //+------------------------------------------------------------------+ //--- Set the last text coordinate (1) X, (2) Y void SetTextLastX(const int x) { this.m_text_x=x; } void SetTextLastY(const int y) { this.m_text_y=y; } //--- Return (1) alignment type (anchor method), the last (2) X and (3) Y text coordinate
Esses métodos serão úteis no construtor das classes herdadas, pois colocar essas variáveis na seção protegida da classe exige ainda mais alterações em outras classes. Por enquanto, nos limitaremos a esses métodos sem renomear variáveis.
Até agora, usamos objetos baseados em OBJ_BITMAP_LABEL — o objeto "Etiqueta Gráfica" para construir elementos gráficos de interface:
Também é possível escolher o canto de ancoragem da etiqueta gráfica a partir da enumeração ENUM_BASE_CORNER.
Esses objetos têm coordenadas de tela em pixels e são adequados para a criação de elementos gráficos de interface.
Mas, se precisarmos vincular tal objeto às coordenadas de preço/tempo e, ao mesmo tempo, usar as mesmas capacidades de desenho dentro do objeto como em uma tela, o objeto gráfico OBJ_BITMAP — Objeto "Desenho" será útil:
Este é um objeto gráfico exatamente igual, que pode usar como sua imagem um arquivo de imagem rasterizada ou um recurso criado dinamicamente, onde ocorre o desenho.
Os métodos da classe CCanvas permitem criar um objeto-desenho. Dessa forma, só precisamos criar, com base na classe de elementos gráficos, uma classe para o objeto-desenho. Com mínimas modificações.
Classe do elemento gráfico "Desenho"
Na pasta da biblioteca \MQL5\Include\DoEasy\Objects\Graph\, criaremos um novo arquivo GCnvBitmap.mqh da classe CGCnvBitmap.
A classe deve ser herdada da classe de elemento gráfico, cujo arquivo deve ser incluído no arquivo da classe a ser criada:
//+------------------------------------------------------------------+ //| GCnvBitmap.mqh | //| Copyright 2024, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2024, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" #property strict // Necessary for mql4 //+------------------------------------------------------------------+ //| Include files | //+------------------------------------------------------------------+ #include "GCnvElement.mqh" //+------------------------------------------------------------------+ //| Class of the graphical element object | //+------------------------------------------------------------------+ class CGCnvBitmap : public CGCnvElement { }
No corpo da classe, precisamos apenas de algumas variáveis privadas e métodos para manipulá-las, um método virtual para criar o objeto e os construtores com o destrutor. O restante já foi implementado na classe pai:
//+------------------------------------------------------------------+ //| Class of the graphical element object | //+------------------------------------------------------------------+ class CGCnvBitmap : public CGCnvElement { private: datetime m_time; // Time coordinate double m_price; // Price ccoordinate protected: //--- Protected constructor CGCnvBitmap(const ENUM_GRAPH_ELEMENT_TYPE element_type, CGCnvElement *main_obj,CGCnvElement *base_obj, const long chart_id, const int wnd_num, const string descript, const datetime time, const double price, const int w, const int h); public: //--- Create Bitmap virtual bool Create(const long chart_id, const int wnd_num, const int x, const int y, const int w, const int h, const bool redraw=false); //--- Parametric constructor CGCnvBitmap(const ENUM_GRAPH_ELEMENT_TYPE element_type, CGCnvElement *main_obj,CGCnvElement *base_obj, const int element_id, const int element_num, const long chart_id, const int wnd_num, const string descript, const datetime time, const double price, const int w, const int h, const color colour, const uchar opacity, const bool movable=false, const bool activity=true, const bool redraw=false); //--- Default constructor CGCnvBitmap() { this.m_shadow=false; this.m_chart_color_bg=(color)::ChartGetInteger(::ChartID(),CHART_COLOR_BACKGROUND); this.m_type=OBJECT_DE_TYPE_GBITMAP; this.m_element_main=NULL; this.m_element_base=NULL; this.m_shift_coord_x=0; this.m_shift_coord_y=0; } //--- Destructor ~CGCnvBitmap() { this.m_canvas.Destroy(); } //+------------------------------------------------------------------+ //| Methods of simplified access to object properties | //+------------------------------------------------------------------+ //--- Set the (1) time and (2) price coordinate or (3) both bool SetTime(const datetime time); bool SetPrice(const double price); bool SetTimePrice(const datetime time,const double price); //--- Return (1) time and (2) price coordinate datetime Time(void) const { return this.m_time; } double Price(void) const { return this.m_price; } };
Todos os construtores são cópias dos construtores da classe pai e, durante a sua inicialização, utilizam o construtor padrão da classe pai:
//+------------------------------------------------------------------+ //| Parametric constructor | //+------------------------------------------------------------------+ CGCnvBitmap::CGCnvBitmap(const ENUM_GRAPH_ELEMENT_TYPE element_type, CGCnvElement *main_obj,CGCnvElement *base_obj, const int element_id, const int element_num, const long chart_id, const int wnd_num, const string descript, const datetime time, const double price, const int w, const int h, const color colour, const uchar opacity, const bool movable=false, const bool activity=true, const bool redraw=false) { this.SetTypeElement(element_type); this.m_type=OBJECT_DE_TYPE_GBITMAP; this.m_element_main=main_obj; this.m_element_base=base_obj; this.m_chart_color_bg=(color)::ChartGetInteger((chart_id==NULL ? ::ChartID() : chart_id),CHART_COLOR_BACKGROUND); this.m_name=this.CreateNameGraphElement(element_type); this.m_chart_id=(chart_id==NULL || chart_id==0 ? ::ChartID() : chart_id); this.m_subwindow=wnd_num; this.SetFont(DEF_FONT,DEF_FONT_SIZE); this.SetTextAnchor(0); this.SetTextLastX(0); this.SetTextLastY(0); this.SetBackgroundColor(colour,true); this.SetOpacity(opacity); this.m_shift_coord_x=0; this.m_shift_coord_y=0; if(::ArrayResize(this.m_array_colors_bg,1)==1) this.m_array_colors_bg[0]=this.BackgroundColor(); if(::ArrayResize(this.m_array_colors_bg_dwn,1)==1) this.m_array_colors_bg_dwn[0]=this.BackgroundColor(); if(::ArrayResize(this.m_array_colors_bg_ovr,1)==1) this.m_array_colors_bg_ovr[0]=this.BackgroundColor(); if(this.Create(chart_id,wnd_num,0,0,w,h,redraw)) { this.Initialize(element_type,element_id,element_num,0,0,w,h,descript,movable,activity); this.SetVisibleFlag(false,false); this.SetTimePrice(time,price); } else { ::Print(DFUN,CMessage::Text(MSG_LIB_SYS_FAILED_CREATE_ELM_OBJ),"\"",this.TypeElementDescription(element_type),"\" ",this.NameObj()); } } //+------------------------------------------------------------------+ //| Protected constructor | //+------------------------------------------------------------------+ CGCnvBitmap::CGCnvBitmap(const ENUM_GRAPH_ELEMENT_TYPE element_type, CGCnvElement *main_obj,CGCnvElement *base_obj, const long chart_id, const int wnd_num, const string descript, const datetime time, const double price, const int w, const int h) { this.m_type=OBJECT_DE_TYPE_GBITMAP; this.m_element_main=main_obj; this.m_element_base=base_obj; this.m_chart_color_bg=(color)::ChartGetInteger((chart_id==NULL ? ::ChartID() : chart_id),CHART_COLOR_BACKGROUND); this.m_name=this.CreateNameGraphElement(element_type); this.m_chart_id=(chart_id==NULL || chart_id==0 ? ::ChartID() : chart_id); this.m_subwindow=wnd_num; this.m_type_element=element_type; this.SetFont(DEF_FONT,DEF_FONT_SIZE); this.SetTextAnchor(0); this.SetTextLastX(0); this.SetTextLastY(0); this.SetBackgroundColor(CLR_CANV_NULL,true); this.SetOpacity(0); this.m_shift_coord_x=0; this.m_shift_coord_y=0; this.m_shadow=false; if(::ArrayResize(this.m_array_colors_bg,1)==1) this.m_array_colors_bg[0]=this.BackgroundColor(); if(::ArrayResize(this.m_array_colors_bg_dwn,1)==1) this.m_array_colors_bg_dwn[0]=this.BackgroundColor(); if(::ArrayResize(this.m_array_colors_bg_ovr,1)==1) this.m_array_colors_bg_ovr[0]=this.BackgroundColor(); if(this.Create(chart_id,wnd_num,0,0,w,h,false)) { this.Initialize(element_type,0,0,0,0,w,h,descript,false,false); this.SetVisibleFlag(false,false); this.SetTimePrice(time,price); } else { ::Print(DFUN,CMessage::Text(MSG_LIB_SYS_FAILED_CREATE_ELM_OBJ),"\"",this.TypeElementDescription(element_type),"\" ",this.NameObj()); } }
Aqui, utilizamos o construtor padrão da classe pai porque é nele que todos os parâmetros do objeto são configurados e o objeto é criado. Para não redefinir os parâmetros novamente neste construtor, nem excluir e recriar o objeto do novo tipo, fazemos tudo isso diretamente aqui, nesses construtores, utilizando o construtor padrão do objeto pai.
Método virtual para criar o objeto gráfico "desenho":
//+------------------------------------------------------------------+ //| Create the graphical bitmap object | //+------------------------------------------------------------------+ bool CGCnvBitmap::Create(const long chart_id, // Chart ID const int wnd_num, // Chart subwindow const int x, // X coordinate const int y, // Y coordinate const int w, // Width const int h, // Height const bool redraw=false) // Flag indicating the need to redraw { ::ResetLastError(); if(this.m_canvas.CreateBitmap((chart_id==NULL ? ::ChartID() : chart_id),wnd_num,this.m_name,x,y,w,h,COLOR_FORMAT_ARGB_NORMALIZE)) { this.Erase(CLR_CANV_NULL); this.m_canvas.Update(redraw); this.m_shift_y=(int)::ChartGetInteger((chart_id==NULL ? ::ChartID() : chart_id),CHART_WINDOW_YDISTANCE,wnd_num); return true; } int err=::GetLastError(); int code=(err==0 ? (w<1 ? MSG_CANV_ELEMENT_ERR_FAILED_SET_WIDTH : h<1 ? MSG_CANV_ELEMENT_ERR_FAILED_SET_HEIGHT : ERR_OBJECT_ERROR) : err); string subj=(w<1 ? "Width="+(string)w+". " : h<1 ? "Height="+(string)h+". " : ""); CMessage::ToLog(DFUN_ERR_LINE+subj,code,true); return false; }
Aqui, ao contrário do método equivalente na classe pai, utilizamos o método CreateBitmap() da classe CCanvas em vez do método CreateBitmapLabel() para criar o objeto gráfico. E essa é a única diferença deste método em relação ao método da classe pai.
Métodos para definir as coordenadas de preço e tempo para o objeto-desenho:
//+------------------------------------------------------------------+ //| Set the time coordinate | //+------------------------------------------------------------------+ bool CGCnvBitmap::SetTime(const datetime time) { string name=this.NameObj(); if(name==NULL || name=="") return false; ::ResetLastError(); if(!::ObjectSetInteger(this.ChartID(),name,OBJPROP_TIME,time)) { ::PrintFormat("%s%s. %s %s",DFUN,CMessage::Text(MSG_ERR_FAILED_SET_BITMAP_OBJ_TIME),CMessage::Text(MSG_LIB_SYS_ERROR),::GetLastError()); return false; } this.m_time=time; return true; } //+------------------------------------------------------------------+ //| Set the price coordinate | //+------------------------------------------------------------------+ bool CGCnvBitmap::SetPrice(const double price) { string name=this.NameObj(); if(name==NULL || name=="") return false; ::ResetLastError(); if(!::ObjectSetDouble(this.ChartID(),name,OBJPROP_PRICE,price)) { ::PrintFormat("%s%s. %s %s",DFUN,CMessage::Text(MSG_ERR_FAILED_SET_BITMAP_OBJ_PRICE),CMessage::Text(MSG_LIB_SYS_ERROR),::GetLastError()); return false; } this.m_price=price; return true; } //+------------------------------------------------------------------+ //| Set both coordinates | //+------------------------------------------------------------------+ bool CGCnvBitmap::SetTimePrice(const datetime time,const double price) { if(!this.SetTime(time)) return false; return this.SetPrice(price); } //+------------------------------------------------------------------+Resumidamente: se não for possível definir uma propriedade para o objeto gráfico, uma mensagem é exibida no log e false é retornado.
Se a propriedade for definida com sucesso no objeto, o novo valor é registrado na variável da classe e true é retornado.
Na classe de controle de elementos gráficos, no arquivo \MQL5\Include\DoEasy\Objects\Graph\GraphElmControl.mqh, declararemos um método para criar o objeto-desenho:
//+------------------------------------------------------------------+ //| Class for managing graphical elements | //+------------------------------------------------------------------+ class CGraphElmControl : public CObject { private: int m_type; // Object type int m_type_node; // Type of the object the graphics is constructed for //--- Set general parameters for standard graphical objects void SetCommonParamsStdGraphObj(const long chart_id,const string name); public: //--- Return itself CGraphElmControl *GetObject(void) { return &this; } //--- Set a type of the object the graphics is constructed for void SetTypeNode(const int type_node) { this.m_type_node=type_node; } //--- Create a form object CForm *CreateForm(const int form_id,const long chart_id,const int wnd,const string name,const int x,const int y,const int w,const int h); CForm *CreateForm(const int form_id,const int wnd,const string name,const int x,const int y,const int w,const int h); CForm *CreateForm(const int form_id,const string name,const int x,const int y,const int w,const int h); //--- Create Bitmap object CGCnvBitmap *CreateBitmap(const int obj_id,const long chart_id,const int wnd,const string name,const datetime time,const double price,const int w,const int h,const color clr); //--- Creates the trend line standard graphical object
Fora do corpo da classe, escreveremos a implementação:
//+------------------------------------------------------------------+ //| Create Bitmap object | //+------------------------------------------------------------------+ CGCnvBitmap *CGraphElmControl::CreateBitmap(const int obj_id,const long chart_id,const int wnd,const string name,const datetime time,const double price,const int w,const int h,const color clr) { CGCnvBitmap *obj=new CGCnvBitmap(GRAPH_ELEMENT_TYPE_BITMAP,NULL,NULL,obj_id,0,chart_id,wnd,name,time,price,w,h,clr,200); return obj; }
O método cria um novo objeto da classe CDCnvBitmap com os parâmetros passados para ele e opacidade da tela igual a 200, retornando um ponteiro para o objeto criado.
Agora, na classe base do objeto da biblioteca CBaseObj, no arquivo \MQL5\Include\DoEasy\Objects\BaseObj.mqh, escreveremos métodos para criar o objeto-desenho:
//+------------------------------------------------------------------+ //| Methods for handling graphical elements | //+------------------------------------------------------------------+ //--- Create a form object on a specified chart in a specified subwindow CForm *CreateForm(const int form_id,const long chart_id,const int wnd,const string name,const int x,const int y,const int w,const int h) { return this.m_graph_elm.CreateForm(form_id,chart_id,wnd,name,x,y,w,h); } //--- Create a form object on the current chart in a specified subwindow CForm *CreateForm(const int form_id,const int wnd,const string name,const int x,const int y,const int w,const int h) { return this.m_graph_elm.CreateForm(form_id,wnd,name,x,y,w,h); } //--- Create the form object on the current chart in the main window CForm *CreateForm(const int form_id,const string name,const int x,const int y,const int w,const int h) { return this.m_graph_elm.CreateForm(form_id,name,x,y,w,h); } //--- Create a bitmap object on a specified chart in a specified subwindow CGCnvBitmap *CreateBitmap(const int obj_id,const long chart_id,const int wnd,const string name,const datetime time,const double price,const int w,const int h,const color clr) { return this.m_graph_elm.CreateBitmap(obj_id,chart_id,wnd,name,time,price,w,h,clr); } //--- Create a bitmap object on the current chart in a specified subwindow CGCnvBitmap *CreateBitmap(const int obj_id,const int wnd,const string name,const datetime time,const double price,const int w,const int h,const color clr) { return this.m_graph_elm.CreateBitmap(obj_id,::ChartID(),wnd,name,time,price,w,h,clr);} //--- Create the bitmap object on the current chart in the main window CGCnvBitmap *CreateBitmap(const int obj_id,const string name,const datetime time,const double price,const int w,const int h,const color clr) { return this.m_graph_elm.CreateBitmap(obj_id,::ChartID(),0,name,time,price,w,h,clr); } //--- Create a standard graphical trend line object in the specified subwindow of the specified chart
Três métodos para criar o objeto-desenho: (1) no gráfico especificado na subjanela especificada, (2) no gráfico atual na subjanela especificada, (3) no gráfico atual na janela principal. Os métodos simplesmente retornam o resultado da chamada do método de criação do objeto-desenho da classe CGraphElmControl com os parâmetros especificados, que foram escritos acima.
Agora, a partir de qualquer objeto da biblioteca, podemos construir um objeto-desenho para a visualização de qualquer coisa. A propósito, anteriormente, já podíamos criar alguns primitivos gráficos e elementos GUI a partir de qualquer objeto da biblioteca. Agora, foi adicionado o objeto-desenho.
A classe do objeto gráfico de formulário foi herdada da classe de elemento gráfico. Portanto, o arquivo do elemento gráfico foi incluído no arquivo da classe do objeto de formulário. Como agora temos mais uma classe herdada do elemento gráfico — a classe do objeto-desenho, para otimizar a integração de todas essas classes, incluiremos no arquivo da classe do objeto de formulário o arquivo da classe do objeto-desenho. Como essa classe foi herdada do elemento gráfico, ambas as classes estarão disponíveis na classe do objeto-forma.
No arquivo da classe do objeto-forma \MQL5\Include\DoEasy\Objects\Graph\Form.mqh, em vez do arquivo do elemento gráfico, conectaremos o arquivo da classe do objeto-desenho:
//+------------------------------------------------------------------+ //| Form.mqh | //| Copyright 2022, MetaQuotes Ltd. | //| https://mql5.com/en/users/artmedia70 | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://mql5.com/en/users/artmedia70" #property version "1.00" #property strict // Necessary for mql4 //+------------------------------------------------------------------+ //| Include files | //+------------------------------------------------------------------+ #include "GCnvBitmap.mqh" #include "ShadowObj.mqh" #include "Animations\Animations.mqh" #include "..\..\Services\MouseState.mqh" //+------------------------------------------------------------------+ //| Form object class | //+------------------------------------------------------------------+ class CForm : public CGCnvElement {
Agora, no objeto-forma, estarão disponíveis tanto o objeto-elemento quanto o objeto-desenho. Consequentemente, nos outros arquivos onde o objeto-elemento for necessário, ambos os objetos estarão disponíveis.
No objeto-barra, registraremos os padrões encontrados nele.
Para isso, no arquivo da classe do objeto-barra \MQL5\Include\DoEasy\Objects\Series\Bar.mqh, na seção pública, escreveremos um método que adiciona ao atributo da barra o tipo de um novo padrão:
//--- Return itself CBar *GetObject(void) { return &this;} //--- Set (1) bar symbol, timeframe and time, (2) bar object parameters void SetSymbolPeriod(const string symbol,const ENUM_TIMEFRAMES timeframe,const datetime time); void SetProperties(const MqlRates &rates); //--- Add the pattern type on bar void AddPattern(const ENUM_PATTERN_TYPE pattern_type) { this.m_long_prop[BAR_PROP_PATTERNS_TYPE] |=pattern_type; } //--- Compare CBar objects by all possible properties (for sorting the lists by a specified bar object property) virtual int Compare(const CObject *node,const int mode=0) const; //--- Compare CBar objects by all properties (to search for equal bar objects) bool IsEqual(CBar* compared_bar) const; //--- Constructors CBar(){ this.m_type=OBJECT_DE_TYPE_SERIES_BAR; } CBar(const string symbol,const ENUM_TIMEFRAMES timeframe,const datetime time,const string source); CBar(const string symbol,const ENUM_TIMEFRAMES timeframe,const MqlRates &rates);
O tipo de padrão é passado para o método, e seu valor (uma máscara de bits) é adicionado ao valor da propriedade BAR_PROP_PATTERNS_TYPE. Usando a operação lógica "ou", podemos adicionar vários tipos à variável sem sobrescrever seu valor. Assim, é possível armazenar diferentes tipos de padrões em uma única variável.
Na seção de descrição das propriedades da barra, declararemos um método que retorna a lista de padrões no array passado e um método que imprime no log a lista de padrões na barra:
//+------------------------------------------------------------------+ //| Descriptions of bar object properties | //+------------------------------------------------------------------+ //--- Get description of a bar's (1) integer, (2) real and (3) string properties string GetPropertyDescription(ENUM_BAR_PROP_INTEGER property); string GetPropertyDescription(ENUM_BAR_PROP_DOUBLE property); string GetPropertyDescription(ENUM_BAR_PROP_STRING property); //--- Return the bar type description string BodyTypeDescription(void) const; //--- Display the description of the object properties in the journal (full_prop=true - all properties, false - supported ones only - implemented in descendant classes) virtual void Print(const bool full_prop=false,const bool dash=false); //--- Display a short description of the object in the journal virtual void PrintShort(const bool dash=false,const bool symbol=false); //--- Return the (1) short name, (2) description of bar object parameters and (3) a list of patterns in the passed array virtual string Header(void); string ParameterDescription(void); int GetPatternsList(ulong &array[]); //--- Display a list of patterns on the bar in the journal void PatternTypeDescriptionPrint(const bool dash=false); //--- };
No método que define os parâmetros do objeto-barra, definiremos o tipo de padrão na barra como ausente (o valor da variável é zero):
//+------------------------------------------------------------------+ //| Set bar object parameters | //+------------------------------------------------------------------+ void CBar::SetProperties(const MqlRates &rates) { this.SetProperty(BAR_PROP_SPREAD,rates.spread); this.SetProperty(BAR_PROP_VOLUME_TICK,rates.tick_volume); this.SetProperty(BAR_PROP_VOLUME_REAL,rates.real_volume); this.SetProperty(BAR_PROP_TIME,rates.time); this.SetProperty(BAR_PROP_TIME_YEAR,this.TimeYear()); this.SetProperty(BAR_PROP_TIME_MONTH,this.TimeMonth()); this.SetProperty(BAR_PROP_TIME_DAY_OF_YEAR,this.TimeDayOfYear()); this.SetProperty(BAR_PROP_TIME_DAY_OF_WEEK,this.TimeDayOfWeek()); this.SetProperty(BAR_PROP_TIME_DAY,this.TimeDay()); this.SetProperty(BAR_PROP_TIME_HOUR,this.TimeHour()); this.SetProperty(BAR_PROP_TIME_MINUTE,this.TimeMinute()); //--- this.SetProperty(BAR_PROP_OPEN,rates.open); this.SetProperty(BAR_PROP_HIGH,rates.high); this.SetProperty(BAR_PROP_LOW,rates.low); this.SetProperty(BAR_PROP_CLOSE,rates.close); this.SetProperty(BAR_PROP_CANDLE_SIZE,this.CandleSize()); this.SetProperty(BAR_PROP_CANDLE_SIZE_BODY,this.BodySize()); this.SetProperty(BAR_PROP_CANDLE_BODY_TOP,this.BodyHigh()); this.SetProperty(BAR_PROP_CANDLE_BODY_BOTTOM,this.BodyLow()); this.SetProperty(BAR_PROP_CANDLE_SIZE_SHADOW_UP,this.ShadowUpSize()); this.SetProperty(BAR_PROP_CANDLE_SIZE_SHADOW_DOWN,this.ShadowDownSize()); //--- this.SetProperty(BAR_PROP_RATIO_BODY_TO_CANDLE_SIZE,this.CandleRatioBodyToCandleSize()); this.SetProperty(BAR_PROP_RATIO_UPPER_SHADOW_TO_CANDLE_SIZE,this.CandleRatioUpperShadowToCandleSize()); this.SetProperty(BAR_PROP_RATIO_LOWER_SHADOW_TO_CANDLE_SIZE,this.CandleRatioLowerShadowToCandleSize()); this.SetProperty(BAR_PROP_PATTERNS_TYPE,0); this.SetProperty(BAR_PROP_TYPE,this.BodyType()); //--- Set the object type to the object of the graphical object management class this.m_graph_elm.SetTypeNode(this.m_type); }
Fora do corpo da classe, escreveremos um método que retorna a lista de padrões no array passado:
//+------------------------------------------------------------------+ //| Return the list of patterns in the passed array | //+------------------------------------------------------------------+ int CBar::GetPatternsList(ulong &array[]) { return ListPatternsInVar(this.GetProperty(BAR_PROP_PATTERNS_TYPE),array); }
O array é passado para o método, e o resultado da execução da função ListPatternsInVar(), escrita anteriormente, é retornado. Dessa forma, a lista de todos os padrões na barra é armazenada no array passado por referência ao método.
Método que imprime no log a descrição dos padrões na barra:
//+------------------------------------------------------------------+ //| Display the description of patterns on the bar in the journal | //+------------------------------------------------------------------+ void CBar::PatternTypeDescriptionPrint(const bool dash=false) { ulong patt=this.GetProperty(BAR_PROP_PATTERNS_TYPE); ::Print(CMessage::Text(MSG_LIB_TEXT_BAR_PATTERNS_TYPE),": ",(patt>0 ? "" : CMessage::Text(MSG_LIB_PROP_EMPTY))); if(patt>0) ::Print(PatternsInVarDescription(patt,dash)); }
Anteriormente, escrevemos a função PatternsInVarDescription(), que retorna uma string contendo descrições de todos os padrões cujas flags estão armazenadas na variável. Aqui, passamos o valor da variável que armazena a propriedade da barra BAR_PROP_PATTERNS_TYPE para essa função e imprimimos no log a string recebida da função.
No método que retorna a descrição da propriedade inteira da barra, adicionaremos a descrição do valor da propriedade BAR_PROP_PATTERNS_TYPE:
//+------------------------------------------------------------------+ //| Return the description of the bar integer property | //+------------------------------------------------------------------+ string CBar::GetPropertyDescription(ENUM_BAR_PROP_INTEGER property) { return ( property==BAR_PROP_TIME ? CMessage::Text(MSG_LIB_TEXT_BAR_TIME)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+::TimeToString(this.GetProperty(property),TIME_DATE|TIME_MINUTES|TIME_SECONDS) ) : property==BAR_PROP_TYPE ? CMessage::Text(MSG_ORD_TYPE)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+this.BodyTypeDescription() ) : property==BAR_PROP_PERIOD ? CMessage::Text(MSG_LIB_TEXT_BAR_PERIOD)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+this.m_period_description ) : property==BAR_PROP_SPREAD ? CMessage::Text(MSG_LIB_TEXT_BAR_SPREAD)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+(string)this.GetProperty(property) ) : property==BAR_PROP_VOLUME_TICK ? CMessage::Text(MSG_LIB_TEXT_BAR_VOLUME_TICK)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+(string)this.GetProperty(property) ) : property==BAR_PROP_VOLUME_REAL ? CMessage::Text(MSG_LIB_TEXT_BAR_VOLUME_REAL)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+(string)this.GetProperty(property) ) : property==BAR_PROP_TIME_YEAR ? CMessage::Text(MSG_LIB_TEXT_BAR_TIME_YEAR)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+(string)this.Year() ) : property==BAR_PROP_TIME_MONTH ? CMessage::Text(MSG_LIB_TEXT_BAR_TIME_MONTH)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+MonthDescription((int)this.Month()) ) : property==BAR_PROP_TIME_DAY_OF_YEAR ? CMessage::Text(MSG_LIB_TEXT_BAR_TIME_DAY_OF_YEAR)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+::IntegerToString(this.DayOfYear(),3,'0') ) : property==BAR_PROP_TIME_DAY_OF_WEEK ? CMessage::Text(MSG_LIB_TEXT_BAR_TIME_DAY_OF_WEEK)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+DayOfWeekDescription((ENUM_DAY_OF_WEEK)this.DayOfWeek()) ) : property==BAR_PROP_TIME_DAY ? CMessage::Text(MSG_LIB_TEXT_BAR_TIME_DAY)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+::IntegerToString(this.Day(),2,'0') ) : property==BAR_PROP_TIME_HOUR ? CMessage::Text(MSG_LIB_TEXT_BAR_TIME_HOUR)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+::IntegerToString(this.Hour(),2,'0') ) : property==BAR_PROP_TIME_MINUTE ? CMessage::Text(MSG_LIB_TEXT_BAR_TIME_MINUTE)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+::IntegerToString(this.Minute(),2,'0') ) : property==BAR_PROP_PATTERNS_TYPE ? CMessage::Text(MSG_LIB_TEXT_BAR_PATTERNS_TYPE)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+(this.GetProperty(property)==0 ? CMessage::Text(MSG_LIB_PROP_NOT_FOUND) : "\n"+PatternsInVarDescription(this.GetProperty(property),true)) ) : "" ); }
Faremos modificações no arquivo \MQL5\Include\DoEasy\Objects\Series\Patterns\Pattern.mqh.
Como o objeto-padrão conterá um ponteiro para o objeto-barra onde o padrão foi encontrado, será necessário conectar ao arquivo da classe do objeto-padrão o arquivo da classe do objeto-barra. O padrão possui uma barra "formadora" e uma barra "mãe". Para a barra formadora, usaremos um ponteiro para o objeto-barra (que é a barra onde o padrão foi encontrado), e para a barra "mãe" criaremos uma estrutura MqlRates, onde serão armazenados os dados dessa barra. Dessa forma, sempre teremos todos os dados sobre as barras que o padrão "abrange". A propósito, se o padrão for de uma única barra, a barra "mãe" e a barra formadora são a mesma única barra. O padrão será "desenhado" usando o objeto-desenho, cuja classe criamos hoje. O ponteiro para o objeto dessa classe será declarado na seção protegida da classe do objeto-padrão abstrato. Para calcular o tamanho do desenho que cerca as barras do padrão, precisamos conhecer os tamanhos e parâmetros do gráfico. Declararemos variáveis para armazenar os parâmetros do gráfico, necessários para calcular o tamanho do objeto-desenho.
//+------------------------------------------------------------------+ //| Include files | //+------------------------------------------------------------------+ #include "..\..\BaseObj.mqh" #include "..\Bar.mqh" //+------------------------------------------------------------------+ //| Abstract pattern class | //+------------------------------------------------------------------+ class CPattern : public CBaseObj { private: CBar *m_bar_pattern; // Pointer to the bar the pattern is formed on MqlRates m_mother_bar_prop; // "Mother" bar parameters long m_long_prop[PATTERN_PROP_INTEGER_TOTAL]; // Integer properties double m_double_prop[PATTERN_PROP_DOUBLE_TOTAL]; // Real properties string m_string_prop[PATTERN_PROP_STRING_TOTAL]; // String properties //--- Return the index of the array the pattern (1) double and (2) string properties are located at int IndexProp(ENUM_PATTERN_PROP_DOUBLE property) const { return(int)property-PATTERN_PROP_INTEGER_TOTAL; } int IndexProp(ENUM_PATTERN_PROP_STRING property) const { return(int)property-PATTERN_PROP_INTEGER_TOTAL-PATTERN_PROP_DOUBLE_TOTAL;} protected: CForm *m_form; // Pointer to form object CGCnvBitmap *m_bitmap; // Pointer to the bitmap object int m_digits; // Symbol's digits value ulong m_symbol_code; // Symbol as a number (sum of name symbol codes) string m_name_graph_obj; // Name of the graphical object displaying the pattern double m_price; // Price level the graphical object is placed at color m_color_bullish; // Color of a graphical object set to the bullish pattern icon color m_color_bearish; // Color of a graphical object set to the bearish pattern icon color m_color_bidirect; // Color of a graphical object set to the bidirectional pattern icon color m_color; // Graphical object color color m_color_panel_bullish; // Bullish pattern panel color color m_color_panel_bearish; // Bearish pattern panel color color m_color_panel_bidirect; // Bidirectional pattern panel color int m_bars_formation; // Number of bars in the formation (nested pattern) bool m_draw_dots; // Draw on the chart with dots int m_chart_scale; // Chart scale int m_chart_height_px; // Height of the chart in pixels double m_chart_price_max; // Chart maximum double m_chart_price_min; // Chart minimum public:
Na seção pública da classe, adicionaremos métodos para definir e retornar as novas propriedades e ponteiros:
public: //--- Set pattern (1) integer, (2) real and (3) string properties void SetProperty(ENUM_PATTERN_PROP_INTEGER property,long value) { this.m_long_prop[property]=value; } void SetProperty(ENUM_PATTERN_PROP_DOUBLE property,double value){ this.m_double_prop[this.IndexProp(property)]=value; } void SetProperty(ENUM_PATTERN_PROP_STRING property,string value){ this.m_string_prop[this.IndexProp(property)]=value; } //--- Return (1) integer, (2) real and (3) string pattern properties from the property array long GetProperty(ENUM_PATTERN_PROP_INTEGER property) const { return this.m_long_prop[property]; } double GetProperty(ENUM_PATTERN_PROP_DOUBLE property) const { return this.m_double_prop[this.IndexProp(property)]; } string GetProperty(ENUM_PATTERN_PROP_STRING property) const { return this.m_string_prop[this.IndexProp(property)]; } //--- Return the flag of the pattern supporting the specified property virtual bool SupportProperty(ENUM_PATTERN_PROP_INTEGER property) { return true; } virtual bool SupportProperty(ENUM_PATTERN_PROP_DOUBLE property) { return true; } virtual bool SupportProperty(ENUM_PATTERN_PROP_STRING property) { return true; } //--- Return itself CPattern *GetObject(void) { return &this; } CForm *GetForm(void) { return this.m_form;} //--- Compare CPattern objects by all possible properties (for sorting the lists by a specified pattern object property) virtual int Compare(const CObject *node,const int mode=0) const; //--- Compare CPattern objects with each other by all properties (to search equal pattern objects) bool IsEqual(CPattern* compared_obj) const; //--- Constructors CPattern(){ this.m_type=OBJECT_DE_TYPE_SERIES_PATTERN; } protected: //--- Protected parametric constructor CPattern(const ENUM_PATTERN_STATUS status, const ENUM_PATTERN_TYPE type, const uint id, const ENUM_PATTERN_DIRECTION direction, const string symbol, const ENUM_TIMEFRAMES timeframe,MqlRates &rates); public: //--- Destructor ~CPattern(void); //+------------------------------------------------------------------+ //| Methods of a simplified access to the pattern object properties | //+------------------------------------------------------------------+ //--- Return (1) type, (2) direction, (3) period, (4) status, //--- (5) code, (6) pattern defining bar time, //--- (7) number of candles forming the pattern ENUM_PATTERN_TYPE TypePattern(void) const { return (ENUM_PATTERN_TYPE)this.GetProperty(PATTERN_PROP_TYPE); } ENUM_PATTERN_DIRECTION Direction(void) const { return (ENUM_PATTERN_DIRECTION)this.GetProperty(PATTERN_PROP_DIRECTION); } ENUM_TIMEFRAMES Timeframe(void) const { return (ENUM_TIMEFRAMES)this.GetProperty(PATTERN_PROP_PERIOD); } ENUM_PATTERN_STATUS Status(void) const { return (ENUM_PATTERN_STATUS)this.GetProperty(PATTERN_PROP_STATUS); } ulong Code(void) const { return this.GetProperty(PATTERN_PROP_CODE); } uint ID(void) const { return (uint)this.GetProperty(PATTERN_PROP_ID); } ulong ControlObjectID(void) const { return this.GetProperty(PATTERN_PROP_CTRL_OBJ_ID); } datetime Time(void) const { return (datetime)this.GetProperty(PATTERN_PROP_TIME); } uint Candles(void) const { return (uint)this.GetProperty(PATTERN_PROP_CANDLES); } //--- Return pattern defining bar prices double BarPriceOpen(void) const { return this.GetProperty(PATTERN_PROP_BAR_PRICE_OPEN); } double BarPriceHigh(void) const { return this.GetProperty(PATTERN_PROP_BAR_PRICE_HIGH); } double BarPriceLow(void) const { return this.GetProperty(PATTERN_PROP_BAR_PRICE_LOW); } double BarPriceClose(void) const { return this.GetProperty(PATTERN_PROP_BAR_PRICE_CLOSE); } //--- Return pattern (1) symbol and (2) name string Symbol(void) const { return this.GetProperty(PATTERN_PROP_SYMBOL); } string Name(void) const { return this.GetProperty(PATTERN_PROP_NAME); } //--- Set the pointer to the (1) pattern bar, (2) "mother" bar data void SetPatternBar(CBar *bar) { this.m_bar_pattern=bar; } void SetMotherBarData(MqlRates &data); //--- Set the (1) "mother" bar OHLC and (2) the number of bars in nested formations void SetMotherBarOpen(const double open) { this.m_mother_bar_prop.open=open; } void SetMotherBarHigh(const double high) { this.m_mother_bar_prop.high=high; } void SetMotherBarLow(const double low) { this.m_mother_bar_prop.low=low; } void SetMotherBarClose(const double close) { this.m_mother_bar_prop.close=close; } void SetBarsInNestedFormations(const int bars) { this.m_bars_formation=bars; } //--- Return the pointer to the (1) pattern bar, (2) time, (3 - 6) "mother" bar OHLC and (7) the number of bars in nested formations CBar *PatternBar(void) const { return this.m_bar_pattern; } datetime MotherBarTime(void) const { return (datetime)this.GetProperty(PATTERN_PROP_MOTHERBAR_TIME); } double MotherBarOpen(void) const { return this.m_mother_bar_prop.open; } double MotherBarHigh(void) const { return this.m_mother_bar_prop.high; } double MotherBarLow(void) const { return this.m_mother_bar_prop.low; } double MotherBarClose(void) const { return this.m_mother_bar_prop.close; } int BarsInNestedFormations(void) const { return this.m_bars_formation; } //+------------------------------------------------------------------+ //| Descriptions of pattern object properties | //+------------------------------------------------------------------+ //--- Get description of pattern (1) integer, (2) real and (3) string property string GetPropertyDescription(ENUM_PATTERN_PROP_INTEGER property); string GetPropertyDescription(ENUM_PATTERN_PROP_DOUBLE property); string GetPropertyDescription(ENUM_PATTERN_PROP_STRING property); //--- Return description of the pattern (1) status, (2) type and (3) direction virtual string StatusDescription(void) const { return NULL; } virtual string TypeDescription(void) const { return NULL; } string DirectDescription(void) const; //--- Display the description of the object properties in the journal (full_prop=true - all properties, false - supported ones only - implemented in descendant classes) virtual void Print(const bool full_prop=false,const bool dash=false); //--- Display a short description of the object in the journal virtual void PrintShort(const bool dash=false,const bool symbol=false); //--- Return a short name of a pattern object virtual string Header(void); //+------------------------------------------------------------------+ //| Handle graphical display | //+------------------------------------------------------------------+ protected: //--- Set graphical object display colors for the (1) bullish, (2) bearish and (3) bidirectional pattern void SetColorBullish(const color clr) { this.m_color_bullish=clr; } void SetColorBearish(const color clr) { this.m_color_bearish=clr; } void SetColorBiDirect(const color clr) { this.m_color_bidirect=clr; } //--- Create the (1) info panel and (2) Bitmap object bool CreateInfoPanel(void); virtual bool CreateBitmap(void); //--- Create the info panel appearance virtual void CreateInfoPanelView(void){} //--- Calculate the bitmap object (1) width and (2) height int GetBitmapWidth(void); int GetBitmapHeight(void); public: //--- Remove a graphical object bool DeleteGraphObj(bool redraw=false); //--- Set graphical object display colors and pattern display color void SetColors(const color color_bullish,const color color_bearish,const color color_bidirect,const bool redraw=false); //--- Set the flag for drawing pattern labels as dots void SetDrawAsDots(const bool flag) { this.m_draw_dots=flag; } //--- Set the background color for the (1) bullish, (2) bearish and (3) bidirectional pattern panel void SetColorPanelBullish(const color clr) { this.m_color_panel_bullish=clr; } void SetColorPanelBearish(const color clr) { this.m_color_panel_bearish=clr; } void SetColorPanelBiDirect(const color clr) { this.m_color_panel_bidirect=clr; } //--- Set the background color for the (1) bullish, (2) bearish and (3) bidirectional pattern panel by setting the values of the RGB color components void SetColorPanelBullish(const uchar R,const uchar G,const uchar B); void SetColorPanelBearish(const uchar R,const uchar G,const uchar B); void SetColorPanelBiDirect(const uchar R,const uchar G,const uchar B); //--- Draw the pattern icon on the chart virtual void Draw(const bool redraw); //--- (1) Display, (2) hide the pattern icon on the chart void Show(const bool redraw=false); void Hide(const bool redraw=false); //--- (1) Display and (2) hide the info panel on the chart void ShowInfoPanel(const int x,const int y,const bool redraw=true); void HideInfoPanel(void); //--- Change the bitmap object (1) width, (2) height and (3) size bool BitmapSetWidth(const int width); bool BitmapSetHeight(const int height); bool BitmapResize(const int w,const int h); //--- Set the (1) chart scale, (2) chart height in pixels, (3) chart maximum and (3) minimum void SetChartScale(const int scale) { this.m_chart_scale=scale; } void SetChartHeightInPixels(const int height) { this.m_chart_height_px=height; } void SetChartPriceMax(const double price) { this.m_chart_price_max=price; } void SetChartPriceMin(const double price) { this.m_chart_price_min=price; } //--- Return the (1) chart scale, (2) chart height in pixels, (3) chart maximum and (3) minimum int ChartScale(void) const { return this.m_chart_scale; } int ChartHeightInPixels(void) const { return this.m_chart_height_px; } double ChartPriceMax(void) const { return this.m_chart_price_max; } double ChartPriceMin(void) const { return this.m_chart_price_min; } };
No construtor da classe abstrata do padrão, mudaremos a cor da marca do padrão bidirecional e definiremos valores padrão para o ponteiro do objeto-desenho (NULL), para a flag de desenho de padrões com pontos (true) e para a quantidade de formações aninhadas, igual a 1 (sem padrões aninhados):
//+------------------------------------------------------------------+ //| Constructor | //+------------------------------------------------------------------+ CPattern::CPattern(const ENUM_PATTERN_STATUS status,const ENUM_PATTERN_TYPE type,const uint id,const ENUM_PATTERN_DIRECTION direction,const string symbol,const ENUM_TIMEFRAMES timeframe,MqlRates &rates) { //--- Set pattern object properties this.m_digits=(int)::SymbolInfoInteger(symbol,SYMBOL_DIGITS); this.m_type=OBJECT_DE_TYPE_SERIES_PATTERN; this.SetProperty(PATTERN_PROP_STATUS,status); this.SetProperty(PATTERN_PROP_TYPE,type); this.SetProperty(PATTERN_PROP_ID,id); this.SetProperty(PATTERN_PROP_DIRECTION,direction); this.SetProperty(PATTERN_PROP_PERIOD,timeframe); this.SetProperty(PATTERN_PROP_TIME,rates.time); this.SetProperty(PATTERN_PROP_BAR_PRICE_OPEN,rates.open); this.SetProperty(PATTERN_PROP_BAR_PRICE_HIGH,rates.high); this.SetProperty(PATTERN_PROP_BAR_PRICE_LOW,rates.low); this.SetProperty(PATTERN_PROP_BAR_PRICE_CLOSE,rates.close); this.SetProperty(PATTERN_PROP_SYMBOL,symbol); //--- Create symbol code this.m_symbol_code=0; for(int i=0;i<(int)symbol.Length();i++) this.m_symbol_code+=symbol.GetChar(i); //--- Pattern code = defining bar time + type + status + pattern direction + timeframe + symbol code ulong code=(ulong)rates.time+type+status+direction+timeframe+this.m_symbol_code; this.SetProperty(PATTERN_PROP_CODE,code); //--- Set pattern graphical objects parameters (chart labels) this.m_name_graph_obj=::StringFormat("%s_p%lu",this.m_name_program,code); this.m_color_bullish=clrBlue; this.m_color_bearish=clrRed; this.m_color_bidirect=clrMediumSeaGreen; if(this.Direction()==PATTERN_DIRECTION_BULLISH) { this.m_color=this.m_color_bullish; this.m_price=rates.low; } else if(this.Direction()==PATTERN_DIRECTION_BEARISH) { this.m_color=this.m_color_bearish; this.m_price=rates.high; } else { this.m_color=this.m_color_bidirect; this.m_price=(rates.open+rates.close)/2; } //--- Set base colors of the pattern information panels this.m_color_panel_bullish=clrLightGray; this.m_color_panel_bearish=clrLightGray; this.m_color_panel_bidirect=clrLightGray; this.m_form=NULL; this.m_bitmap=NULL; this.m_draw_dots=true; this.m_bars_formation=1; }
No destrutor da classe, removeremos o objeto-desenho:
//+------------------------------------------------------------------+ //| Destructor | //+------------------------------------------------------------------+ CPattern::~CPattern(void) { //--- Delete the form object and pattern label on the chart if(this.m_form!=NULL) delete this.m_form; if(this.m_bitmap!=NULL) delete this.m_bitmap; this.DeleteGraphObj(); }
No método que retorna a descrição da propriedade inteira do padrão, adicionaremos a exibição do tempo de abertura da barra "mãe" do padrão:
//+------------------------------------------------------------------+ //| Return the description of the pattern integer property | //+------------------------------------------------------------------+ string CPattern::GetPropertyDescription(ENUM_PATTERN_PROP_INTEGER property) { return ( property==PATTERN_PROP_CODE ? CMessage::Text(MSG_LIB_TEXT_PATTERN_CODE)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+(string)this.GetProperty(property) ) : property==PATTERN_PROP_TIME ? CMessage::Text(MSG_LIB_TEXT_PATTERN_TIME)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+::TimeToString(this.GetProperty(property),TIME_DATE|TIME_MINUTES) ) : property==PATTERN_PROP_MOTHERBAR_TIME ? CMessage::Text(MSG_LIB_TEXT_PATTERN_MOTHERBAR_TIME)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+::TimeToString(this.GetProperty(property),TIME_DATE|TIME_MINUTES) ) : property==PATTERN_PROP_STATUS ? CMessage::Text(MSG_ORD_STATUS)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+this.StatusDescription() ) : property==PATTERN_PROP_TYPE ? CMessage::Text(MSG_ORD_TYPE)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+this.TypeDescription() ) : property==PATTERN_PROP_ID ? CMessage::Text(MSG_LIB_TEXT_PATTERN_ID)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+(string)this.GetProperty(property) ) : property==PATTERN_PROP_CTRL_OBJ_ID ? CMessage::Text(MSG_LIB_TEXT_PATTERN_CTRL_OBJ_ID)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+(string)this.GetProperty(property) ) : property==PATTERN_PROP_DIRECTION ? CMessage::Text(MSG_LIB_TEXT_PATTERN_DIRECTION)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+this.DirectDescription() ) : property==PATTERN_PROP_PERIOD ? CMessage::Text(MSG_LIB_TEXT_BAR_PERIOD)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+TimeframeDescription((ENUM_TIMEFRAMES)this.GetProperty(property)) ) : property==PATTERN_PROP_CANDLES ? CMessage::Text(MSG_LIB_TEXT_PATTERN_CANDLES)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+(string)this.GetProperty(property) ) : "" ); }
Implementação do método que define os dados da barra "mãe":
//+------------------------------------------------------------------+ //| Set the "mother" bar data | //+------------------------------------------------------------------+ void CPattern::SetMotherBarData(MqlRates &data) { this.m_mother_bar_prop.open=data.open; this.m_mother_bar_prop.high=data.high; this.m_mother_bar_prop.low=data.low; this.m_mother_bar_prop.close=data.close; this.m_mother_bar_prop.time=data.time; this.SetProperty(PATTERN_PROP_MOTHERBAR_TIME,data.time); }
A estrutura da barra é passada para o método, e os campos necessários dessa estrutura são gravados nos campos correspondentes da variável membro da classe m_mother_bar_prop. Além disso, o tempo da barra "mãe" é registrado na propriedade de tempo da barra "mãe" — esse valor está presente nas propriedades do objeto e deve ser corretamente preenchido.
No método que exibe o painel de informações no gráfico, foi adicionada uma variável de entrada para indicar a necessidade de redesenhar o gráfico, e o gráfico é redesenhado se o valor dessa variável for definido como true:
//+------------------------------------------------------------------+ //| Display the info panel on the chart | //+------------------------------------------------------------------+ void CPattern::ShowInfoPanel(const int x,const int y,const bool redraw=true) { //--- If there is no panel object yet, create it if(this.m_form==NULL) if(!this.CreateInfoPanel()) return; //--- Get the chart width and height int chart_w=(int)::ChartGetInteger(this.m_chart_id,CHART_WIDTH_IN_PIXELS); int chart_h=(int)::ChartGetInteger(this.m_chart_id,CHART_HEIGHT_IN_PIXELS); //--- Calculate the X and Y coordinates of the panel so that it does not go beyond the chart int cx=(x+this.m_form.Width() >chart_w-1 ? chart_w-1-this.m_form.Width() : x); int cy=(y+this.m_form.Height()>chart_h-1 ? chart_h-1-this.m_form.Height() : y); //--- Set the calculated coordinates and display the panel if(this.m_form.SetCoordX(cx) && this.m_form.SetCoordY(cy)) this.m_form.Show(); if(redraw) ::ChartRedraw(this.m_chart_id); }
Isso foi feito para que o painel com a descrição do padrão apareça sem atrasos após o cursor do mouse passar sobre a barra com o padrão. Se houver vários padrões nessa barra, o valor dessa variável deve ser definido como false para todos os painéis de informações ao serem exibidos no gráfico, e apenas para o último deve ser definido como true. Nesse caso, o gráfico será redesenhado apenas após a exibição do último painel, e não a cada vez.
Como os padrões podem ser exibidos no gráfico de duas maneiras — com pontos e com objetos-desenho, aprimoraremos o método que exibe o ícone do padrão no gráfico:
//+------------------------------------------------------------------+ //| Display the pattern icon on the chart | //+------------------------------------------------------------------+ void CPattern::Show(const bool redraw=false) { if(this.m_draw_dots) { ::ObjectSetInteger(this.m_chart_id,this.m_name_graph_obj,OBJPROP_TIMEFRAMES,OBJ_ALL_PERIODS); return; } if(this.m_bitmap!=NULL) this.m_bitmap.Show(); if(redraw) ::ChartRedraw(this.m_chart_id); }
Se estivermos desenhando com pontos, como antes — ativamos a visibilidade do objeto gráfico. Se estivermos desenhando com um objeto-desenho, se ele existir, chamamos seu método Show(). Por fim, atualizamos o gráfico se a flag de redesenho estiver ativada.
Da mesma forma, aprimoraremos o método que oculta o ícone do padrão no gráfico:
//+------------------------------------------------------------------+ //| Hide the pattern icon on the chart | //+------------------------------------------------------------------+ void CPattern::Hide(const bool redraw=false) { if(this.m_draw_dots) { ::ObjectSetInteger(this.m_chart_id,this.m_name_graph_obj,OBJPROP_TIMEFRAMES,OBJ_NO_PERIODS); return; } if(this.m_bitmap!=NULL) this.m_bitmap.Hide(); if(redraw) ::ChartRedraw(this.m_chart_id); }
Método que calcula a largura do objeto-desenho:
//+------------------------------------------------------------------+ //| Calculate the bitmap object width | //+------------------------------------------------------------------+ int CPattern::GetBitmapWidth(void) { //--- Calculate the width of the chart candles in pixels int px=int(1<<this.m_chart_scale); //--- Calculate the number of bars that make up the pattern int num_bars=::Bars(this.Symbol(),this.Timeframe(),this.MotherBarTime(),this.Time()); if(num_bars==0) num_bars=(int)this.Candles(); //--- Calculate and return the width of the bitmap object return (px*num_bars*2)-px+1; }
Dependendo da escala do gráfico, calculamos a largura das velas em pixels. Em seguida, obtemos a largura do padrão em barras e, com base nesses dois valores, calculamos e retornamos a largura necessária do objeto-desenho.
Método que calcula a altura do objeto-desenho:
//+------------------------------------------------------------------+ //| Calculate the bitmap object height | //+------------------------------------------------------------------+ int CPattern::GetBitmapHeight(void) { //--- Calculate the chart price range and pattern price range double chart_price_range=this.m_chart_price_max-this.m_chart_price_min; double patt_price_range=this.MotherBarHigh()-this.MotherBarLow(); //--- Using the calculated price ranges, calculate and return the height of the bitmap object return (int)ceil(patt_price_range*this.m_chart_height_px/chart_price_range)+8; }
Aqui, obtemos o intervalo de preços do gráfico, da maior para a menor cotação, e o intervalo de preços do padrão, do High da vela "mãe" ao Low da vela "mãe". Em seguida, calculamos a relação de um intervalo com o outro em pixels e retornamos o valor obtido da altura do objeto-desenho, adicionando 8 pixels — quatro em cima e quatro embaixo.
No construtor do padrão "Pin Bar", definiremos a quantidade de padrões aninhados igual ao valor das barras do padrão (1):
//+------------------------------------------------------------------+ //| Constructor | //+------------------------------------------------------------------+ CPatternPinBar::CPatternPinBar(const uint id,const string symbol,const ENUM_TIMEFRAMES timeframe,MqlRates &rates,const ENUM_PATTERN_DIRECTION direct) : CPattern(PATTERN_STATUS_PA,PATTERN_TYPE_PIN_BAR,id,direct,symbol,timeframe,rates) { this.SetProperty(PATTERN_PROP_NAME,"Pin Bar"); this.SetProperty(PATTERN_PROP_CANDLES,1); this.m_bars_formation=(int)this.GetProperty(PATTERN_PROP_CANDLES); }
Agora, vamos criar a classe de um novo padrão Price Action, "Barra Interna".
Classe do padrão "Barra Interna"
No mesmo arquivo onde estão as classes do padrão abstrato e do padrão "Pin Bar", criaremos uma nova classe — a classe do padrão "Barra Interna". Basicamente, precisamos apenas escrever (redefinir) alguns métodos virtuais e valores das propriedades do padrão. A classe deve ser herdada da classe do objeto padrão abstrato:
//+------------------------------------------------------------------+ //| "Inside Bar" pattern class | //+------------------------------------------------------------------+ class CPatternInsideBar : public CPattern { protected: //--- Create the (1) image object, the appearance of the (2) info panel and (3) the bitmap object virtual bool CreateBitmap(void); virtual void CreateInfoPanelView(void); void CreateBitmapView(void); public: //--- Return the flag of the pattern supporting the specified property virtual bool SupportProperty(ENUM_PATTERN_PROP_INTEGER property) { return true; } virtual bool SupportProperty(ENUM_PATTERN_PROP_DOUBLE property) { return true; } virtual bool SupportProperty(ENUM_PATTERN_PROP_STRING property) { return true; } //--- Return description of the pattern (1) status and (2) type virtual string StatusDescription(void) const { return CMessage::Text(MSG_LIB_TEXT_PATTERN_STATUS_PA); } virtual string TypeDescription(void) const { return CMessage::Text(MSG_LIB_TEXT_PATTERN_TYPE_INSIDE_BAR); } //--- Draw the pattern icon on the chart virtual void Draw(const bool redraw); //--- Constructor CPatternInsideBar(const uint id,const string symbol,const ENUM_TIMEFRAMES timeframe,MqlRates &rates,const ENUM_PATTERN_DIRECTION direct); };
No construtor da classe, definiremos o nome do padrão, a quantidade de barras do padrão como duas, e, consequentemente, a quantidade de barras nas formações aninhadas como 2 — sem formações aninhadas:
//+------------------------------------------------------------------+ //| Constructor | //+------------------------------------------------------------------+ CPatternInsideBar::CPatternInsideBar(const uint id,const string symbol,const ENUM_TIMEFRAMES timeframe,MqlRates &rates,const ENUM_PATTERN_DIRECTION direct) : CPattern(PATTERN_STATUS_PA,PATTERN_TYPE_INSIDE_BAR,id,direct,symbol,timeframe,rates) { this.SetProperty(PATTERN_PROP_NAME,"Inside Bar"); this.SetProperty(PATTERN_PROP_CANDLES,2); this.m_bars_formation=(int)this.GetProperty(PATTERN_PROP_CANDLES); }
Método virtual que cria a aparência do painel de informações:
//+------------------------------------------------------------------+ //| Create the info panel appearance | //+------------------------------------------------------------------+ void CPatternInsideBar::CreateInfoPanelView(void) { //--- If the form object is not created, leave if(this.m_form==NULL) return; //--- Declare the array for the initial and final colors of the gradient fill color clr[2]={this.m_form.ChangeColorLightness(this.m_color_panel_bidirect,-5),this.m_form.ChangeColorLightness(this.m_color_panel_bidirect,15)}; //--- Set the background and form frame colors this.m_form.SetBackgroundColor(this.m_color_panel_bidirect,true); this.m_form.SetBorderColor(clrGray,true); //--- Create strings to describe the pattern, its parameters and search criteria string name=::StringFormat("Inside Bar (%lu bars)",int(this.Time()-this.MotherBarTime())/::PeriodSeconds(this.Timeframe())+1); string param=this.DirectDescription();//::StringFormat("%s (%.2f/%.2f/%.2f)",this.DirectDescription(),this.GetProperty(PATTERN_PROP_RATIO_BODY_TO_CANDLE_SIZE_CRITERION),this.GetProperty(PATTERN_PROP_RATIO_LARGER_SHADOW_TO_CANDLE_SIZE_CRITERION),this.GetProperty(PATTERN_PROP_RATIO_SMALLER_SHADOW_TO_CANDLE_SIZE_CRITERION)); //--- Set the coordinates of the panel and calculate its width and height depending on the size of the texts placed on the panel int x=3; int y=20; int w=4+(::fmax(20+this.m_form.TextWidth(name),::fmax(x+this.m_form.TextWidth(param),x+this.m_form.TextWidth(::TimeToString(this.Time()))))); int h=2+(20+this.m_form.TextHeight(this.DirectDescription())+this.m_form.TextHeight(::TimeToString(this.Time()))); //--- Set the width and height of the panel according to the calculated values this.m_form.SetWidth(w); this.m_form.SetHeight(h); //--- Depending on the chart size and coordinates, we calculate the coordinates of the panel so that it does not go beyond the chart int chart_w=(int)::ChartGetInteger(this.m_chart_id,CHART_WIDTH_IN_PIXELS); int chart_h=(int)::ChartGetInteger(this.m_chart_id,CHART_HEIGHT_IN_PIXELS); int cx=(this.m_form.RightEdge() >chart_w-1 ? chart_w-1-this.m_form.Width() : this.m_form.CoordX()); int cy=(this.m_form.BottomEdge()>chart_h-1 ? chart_h-1-this.m_form.Height() : this.m_form.CoordY()); this.m_form.SetCoordX(cx); this.m_form.SetCoordY(cy); //--- Fill the background with a gradient color this.m_form.Erase(clr,200,true,false); //--- Draw the panel frame, an icon with (i), draw the header text with the proportions of a candle and separate the header with a horizontal line this.m_form.DrawFrameSimple(0,0,this.m_form.Width(),this.m_form.Height(),1,1,1,1,this.m_form.BorderColor(),200); this.m_form.DrawIconInfo(1,1,200); this.m_form.Text(20,3,name,clrBlack,200); this.m_form.DrawLine(1,18,this.m_form.Width()-1,18,clrDarkGray,250); //--- Under the horizontal line, enter the pattern description with its search criteria and the date of the pattern-defining bar y=20; this.m_form.Text(x,y,param,clrBlack,200); y+=this.m_form.TextHeight(::TimeToString(this.Time())); this.m_form.Text(x,y,::TimeToString(this.Time()),clrBlack,200); //--- Update the panel while redrawing the chart this.m_form.Update(true); }
Para cada tipo de padrão, faremos métodos virtuais próprios para criar a aparência do painel de informações, porque cada padrão tem seu conjunto de parâmetros significativos, que podem ser exibidos no painel para descrever o padrão de forma mais clara.
Método que desenha o ícone do padrão no gráfico:
//+------------------------------------------------------------------+ //| Draw the pattern icon on the chart | //+------------------------------------------------------------------+ void CPatternInsideBar::Draw(const bool redraw) { //--- If the flag for drawing with dots is set, call the parent class method and leave if(this.m_draw_dots) { CPattern::Draw(redraw); return; } //--- If the bitmap object has not yet been created, create it if(this.m_bitmap==NULL) { if(!this.CreateBitmap()) return; } //--- display this.Show(redraw); }
A lógica do método está descrita nos comentários. O método da classe pai cria e desenha os ícones dos padrões (pontos) no gráfico. Portanto, se a flag de desenho com pontos estiver ativada, eles serão desenhados pelo método da classe pai.
Caso contrário, é criado um objeto-desenho e exibido no gráfico.
Método que cria o objeto-desenho:
//+------------------------------------------------------------------+ //| Create the bitmap object | //+------------------------------------------------------------------+ bool CPatternInsideBar::CreateBitmap(void) { //--- If the bitmap object has already been created earlier, return 'true' if(this.m_bitmap!=NULL) return true; //--- Calculate the object coordinates and dimensions datetime time=this.MotherBarTime(); double price=(this.MotherBarHigh()+this.MotherBarLow())/2; int w=this.GetBitmapWidth(); int h=this.GetBitmapHeight(); //--- Create the Bitmap object this.m_bitmap=this.CreateBitmap(this.ID(),this.GetChartID(),0,this.Name(),time,price,w,h,this.m_color_bidirect); if(this.m_bitmap==NULL) return false; //--- Set the object origin to its center and remove the tooltip ::ObjectSetInteger(this.GetChartID(),this.m_bitmap.NameObj(),OBJPROP_ANCHOR,ANCHOR_CENTER); ::ObjectSetString(this.GetChartID(),this.m_bitmap.NameObj(),OBJPROP_TOOLTIP,"\n"); //--- Draw the bitmap object appearance this.CreateBitmapView(); return true; }
Método que cria a aparência do objeto-desenho:
//+------------------------------------------------------------------+ //| Create the bitmap object appearance | //+------------------------------------------------------------------+ void CPatternInsideBar::CreateBitmapView(void) { this.m_bitmap.Erase(CLR_CANV_NULL,0); int x=this.m_bitmap.Width()/2-int(1<<this.m_chart_scale)/2; this.m_bitmap.DrawRectangleFill(x,0,this.m_bitmap.Width()-1,this.m_bitmap.Height()-1,this.m_color_bidirect,80); this.m_bitmap.DrawRectangle(x,0,this.m_bitmap.Width()-1,this.m_bitmap.Height()-1,clrGray); this.m_bitmap.Update(false); }
Aqui: preenchemos a tela com uma cor transparente, calculamos a coordenada X inicial do retângulo que contorna as barras do padrão. Em seguida, preenchemos a área retangular, começando na coordenada X calculada, com a cor definida para o padrão bidirecional e uma opacidade de 80, e contornamos a área preenchida com um retângulo cinza. Após terminar o desenho, atualizamos o recurso sem redesenhar o gráfico.
Cada padrão procurado com seus parâmetros é controlado e processado por um objeto da classe de controle de padrões. Esse objeto é criado uma vez ao ativar a permissão para a busca de um padrão com o tipo especificado e os parâmetros de busca definidos. Nessa mesma classe, é necessário fazer a leitura das propriedades da janela do gráfico — para que elas sejam lidas apenas uma vez ao criar o objeto de controle, e depois os parâmetros do gráfico lidos sejam gravados nos objetos de padrões criados. As propriedades do gráfico são necessárias para que os painéis de informações de cada padrão específico não ultrapassem as bordas do gráfico ao serem exibidos. Se formos ler os parâmetros do gráfico a cada criação de um novo objeto-padrão, isso será bastante custoso — afinal, há muitos padrões em uma única série temporal. Além disso, por que ler os mesmos parâmetros repetidamente, se eles podem ser lidos uma vez e depois usados em cada padrão criado? Também precisaremos dos parâmetros do gráfico ao criar os objetos-desenho que contornam as barras dos padrões. Novamente, ler o tamanho do gráfico a cada vez não é ideal. Por isso, faremos essa leitura apenas ao criar o objeto de controle do padrão. Mas há um detalhe importante: ao alterar o tamanho do gráfico, todos os dados lidos anteriormente permanecem os mesmos que já foram obtidos. E esses dados precisam ser requisitados novamente do gráfico e gravados nas propriedades de cada padrão. Isso será abordado em artigos futuros.
A classe do objeto de controle de padrões está no arquivo \MQL5\Include\DoEasy\Objects\Series\SeriesDE.mqh. Faremos as devidas modificações:
//+------------------------------------------------------------------+ //| Abstract pattern control class | //+------------------------------------------------------------------+ class CPatternControl : public CBaseObjExt { private: ENUM_TIMEFRAMES m_timeframe; // Pattern timeseries chart period string m_symbol; // Pattern timeseries symbol double m_point; // Symbol Point bool m_used; // Pattern use flag bool m_drawing; // Flag for drawing the pattern icon on the chart bool m_draw_dots; // Flag for drawing the pattern icon on the chart with dots //--- Handled pattern ENUM_PATTERN_TYPE m_type_pattern; // Pattern type protected: //--- Candle proportions double m_ratio_body_to_candle_size; // Percentage ratio of the candle body to the full size of the candle double m_ratio_larger_shadow_to_candle_size; // Percentage ratio of the size of the larger shadow to the size of the candle double m_ratio_smaller_shadow_to_candle_size; // Percentage ratio of the size of the smaller shadow to the size of the candle ulong m_object_id; // Unique object code based on pattern search criteria //--- List views CArrayObj *m_list_series; // Pointer to the timeseries list CArrayObj *m_list_all_patterns; // Pointer to the list of all patterns CPattern m_pattern_instance; // Pattern object for searching by property ulong m_symbol_code; // Chart symbol name as a number int m_chart_scale; // Chart scale int m_chart_height_px; // Height of the chart in pixels double m_chart_price_max; // Chart maximum double m_chart_price_min; // Chart minimum //--- (1) Search for a pattern, return direction (or -1 if no pattern is found), //--- (2) create a pattern with a specified direction, //--- (3) create and return a unique pattern code, //--- (4) return the list of patterns managed by the object virtual ENUM_PATTERN_DIRECTION FindPattern(const datetime series_bar_time,const uint min_body_size,MqlRates &mother_bar_data) const { return WRONG_VALUE; } virtual CPattern *CreatePattern(const ENUM_PATTERN_DIRECTION direction,const uint id,CBar *bar){ return NULL; } virtual ulong GetPatternCode(const ENUM_PATTERN_DIRECTION direction,const datetime time) const { return 0; } virtual CArrayObj*GetListPatterns(void) { return NULL; } //--- Create object ID based on pattern search criteria virtual ulong CreateObjectID(void) { return 0; } //--- Write bar data to the structure void SetBarData(CBar *bar,MqlRates &rates) const { if(bar==NULL) return; rates.open=bar.Open(); rates.high=bar.High(); rates.low=bar.Low(); rates.close=bar.Close(); rates.time=bar.Time(); } public: //--- Returns (1) itself, (2) pattern usage flag CPatternControl *GetObject(void) { return &this; } //--- (1) Set and (2) return the pattern usage flag void SetUsed(const bool flag) { this.m_used=flag; } bool IsUsed(void) const { return this.m_used; } //--- (1) Set and (2) return the pattern drawing flag void SetDrawing(const bool flag) { this.m_drawing=flag; } bool IsDrawing(void) const { return this.m_drawing; } //--- (1) Set and (2) return the flag for drawing pattern icons as dots void SetDrawingAsDots(const bool flag,const bool redraw); bool IsDrawingAsDots(void) const { return this.m_draw_dots; } //--- Set the necessary percentage ratio of the candle body to the full size of the candle, //--- size of the (2) upper and (3) lower shadow to the candle size void SetRatioBodyToCandleSizeValue(const double value) { this.m_ratio_body_to_candle_size=value; } void SetRatioLargerShadowToCandleSizeValue(const double value) { this.m_ratio_larger_shadow_to_candle_size=value; } void SetRatioSmallerShadowToCandleSizeValue(const double value) { this.m_ratio_smaller_shadow_to_candle_size=value; } //--- Return the percentage ratio (1) of the candle body to the full size of the candle, //--- size of the (2) upper and (3) lower shadow to the candle size double RatioBodyToCandleSizeValue(void) const { return this.m_ratio_body_to_candle_size; } double RatioLargerShadowToCandleSizeValue(void) const { return this.m_ratio_larger_shadow_to_candle_size; } double RatioSmallerShadowToCandleSizeValue(void) const { return this.m_ratio_smaller_shadow_to_candle_size; } //--- Return object ID based on pattern search criteria virtual ulong ObjectID(void) const { return this.m_object_id; } //--- Return pattern (1) type, (2) timeframe, (3) symbol, (4) symbol Point, (5) symbol code ENUM_PATTERN_TYPE TypePattern(void) const { return this.m_type_pattern; } ENUM_TIMEFRAMES Timeframe(void) const { return this.m_timeframe; } string Symbol(void) const { return this.m_symbol; } double Point(void) const { return this.m_point; } ulong SymbolCode(void) const { return this.m_symbol_code; } //--- Set the (1) chart scale, (2) chart height in pixels, (3) chart maximum and (3) minimum void SetChartScale(const int scale) { this.m_chart_scale=scale; } void SetChartHeightInPixels(const int height) { this.m_chart_height_px=height; } void SetChartPriceMax(const double price) { this.m_chart_price_max=price; } void SetChartPriceMin(const double price) { this.m_chart_price_min=price; } //--- Return the (1) chart scale, (2) chart height in pixels, (3) chart maximum and (3) minimum int ChartScale(void) const { return this.m_chart_scale; } int ChartHeightInPixels(void) const { return this.m_chart_height_px; } double ChartPriceMax(void) const { return this.m_chart_price_max; } double ChartPriceMin(void) const { return this.m_chart_price_min; } //--- Compare CPatternControl objects by all possible properties virtual int Compare(const CObject *node,const int mode=0) const; //--- Search for patterns and add found ones to the list of all patterns virtual int CreateAndRefreshPatternList(const uint min_body_size); //--- Display patterns on the chart void DrawPatterns(const bool redraw=false); //--- Protected parametric constructor protected: CPatternControl(const string symbol,const ENUM_TIMEFRAMES timeframe,const ENUM_PATTERN_STATUS status,const ENUM_PATTERN_TYPE type,CArrayObj *list_series,CArrayObj *list_patterns); };
A maioria dos métodos não precisa de explicação — sua finalidade está descrita nos comentários, e os métodos apenas definem ou retornam os parâmetros correspondentes do objeto da classe. Agora, no método de busca de padrões, passaremos uma referência para a estrutura MqlRates, onde serão gravados os dados da barra "mãe". Para registrar esses dados, foi criado o método SetBarData(), no qual um ponteiro para o objeto-barra e uma referência para uma variável do tipo MqlRates são passados, e os campos dessa variável são preenchidos com as propriedades correspondentes do objeto-barra. No método CreateAndRefreshPatternList(), passaremos o tamanho mínimo do corpo da vela. Posteriormente, adicionaremos a definição desse valor no objeto de controle de padrões, que será então passado para o método de busca e atualização dos padrões. A ideia é que, durante a busca de padrões, sejam ignoradas as barras cujo tamanho seja menor que essa medida — como um filtro adicional baseado no tamanho do corpo da vela, definido na busca de padrões para eliminar barras com corpos muito pequenos. Por enquanto, passaremos o valor zero, o que desativa esse filtro.
No construtor da classe, leremos os dados do gráfico e os registraremos em novas variáveis da classe:
//+------------------------------------------------------------------+ //| CPatternControl::Protected parametric constructor | //+------------------------------------------------------------------+ CPatternControl::CPatternControl(const string symbol,const ENUM_TIMEFRAMES timeframe,const ENUM_PATTERN_STATUS status,const ENUM_PATTERN_TYPE type,CArrayObj *list_series,CArrayObj *list_patterns) : m_ratio_body_to_candle_size(30),m_ratio_larger_shadow_to_candle_size(60),m_ratio_smaller_shadow_to_candle_size(30),m_used(true),m_drawing(true) { this.m_type=OBJECT_DE_TYPE_SERIES_PATTERN_CONTROL; this.m_type_pattern=type; this.m_symbol=(symbol==NULL || symbol=="" ? ::Symbol() : symbol); this.m_timeframe=(timeframe==PERIOD_CURRENT ? ::Period() : timeframe); this.m_point=::SymbolInfoDouble(this.m_symbol,SYMBOL_POINT); this.m_object_id=0; this.m_list_series=list_series; this.m_list_all_patterns=list_patterns; for(int i=0;i<(int)this.m_symbol.Length();i++) this.m_symbol_code+=this.m_symbol.GetChar(i); this.m_chart_scale=(int)::ChartGetInteger(this.m_chart_id,CHART_SCALE); this.m_chart_height_px=(int)::ChartGetInteger(this.m_chart_id,CHART_HEIGHT_IN_PIXELS); this.m_chart_price_max=::ChartGetDouble(this.m_chart_id,CHART_PRICE_MAX); this.m_chart_price_min=::ChartGetDouble(this.m_chart_id,CHART_PRICE_MIN); }
No método que busca os padrões e adiciona os encontrados à lista de todos os padrões, faremos as devidas modificações:
//+------------------------------------------------------------------+ //| CPatternControl::Search for patterns and add | //| found ones to the list of all patterns | //+------------------------------------------------------------------+ int CPatternControl::CreateAndRefreshPatternList(const uint min_body_size) { //--- If not used, leave if(!this.m_used) return 0; //--- Reset the timeseries event flag and clear the list of all timeseries pattern events this.m_is_event=false; this.m_list_events.Clear(); //--- Get the opening date of the last (current) bar datetime time_open=0; if(!::SeriesInfoInteger(this.Symbol(),this.Timeframe(),SERIES_LASTBAR_DATE,time_open)) return 0; //--- Get a list of all bars in the timeseries except the current one CArrayObj *list=CSelect::ByBarProperty(this.m_list_series,BAR_PROP_TIME,time_open,LESS); if(list==NULL || list.Total()==0) return 0; //--- "Mother" bar data structure MqlRates pattern_mother_bar_data={}; //--- Sort the resulting list by bar opening time list.Sort(SORT_BY_BAR_TIME); //--- In a loop from the latest bar, for(int i=list.Total()-1;i>=0;i--) { //--- get the next bar object from the list CBar *bar=list.At(i); if(bar==NULL) continue; //--- look for a pattern relative to the received bar ENUM_PATTERN_DIRECTION direction=this.FindPattern(bar.Time(),min_body_size,pattern_mother_bar_data); //--- If there is no pattern, go to the next bar if(direction==WRONG_VALUE) continue; //--- Pattern found on the current bar of the loop //--- unique pattern code = candle opening time + type + status + pattern direction + timeframe + timeseries symbol ulong code=this.GetPatternCode(direction,bar.Time()); //--- Set the pattern code to the sample this.m_pattern_instance.SetProperty(PATTERN_PROP_CODE,code); //--- Sort the list of all patterns by the unique pattern code this.m_list_all_patterns.Sort(SORT_BY_PATTERN_CODE); //--- search for a pattern in the list using a unique code int index=this.m_list_all_patterns.Search(&this.m_pattern_instance); //--- If there is no pattern equal to the sample in the list of all patterns if(index==WRONG_VALUE) { //--- Create the pattern object CPattern *pattern=this.CreatePattern(direction,this.m_list_all_patterns.Total(),bar); if(pattern==NULL) continue; //--- Sort the list of all patterns by time and insert the pattern into the list by its time this.m_list_all_patterns.Sort(SORT_BY_PATTERN_TIME); if(!this.m_list_all_patterns.InsertSort(pattern)) { delete pattern; continue; } //--- Add the pattern to the list of bar object patterns bar.AddPattern(pattern.TypePattern()); //--- Add the pointer to the bar the pattern object is found on, together with the mother bar data pattern.SetPatternBar(bar); pattern.SetMotherBarData(pattern_mother_bar_data); //--- set the chart data to the pattern object pattern.SetChartHeightInPixels(this.m_chart_height_px); pattern.SetChartScale(this.m_chart_scale); pattern.SetChartPriceMax(this.m_chart_price_max); pattern.SetChartPriceMin(this.m_chart_price_min); //--- If the drawing flag is set, draw the pattern label on the chart if(this.m_drawing) pattern.Draw(false); } } //--- Sort the list of all patterns by time and return the total number of patterns in the list this.m_list_all_patterns.Sort(SORT_BY_PATTERN_TIME); return m_list_all_patterns.Total(); }
Agora, o método recebe o tamanho mínimo do corpo da barra do padrão buscado. Esse tamanho e a referência para a estrutura da barra "mãe", na qual os parâmetros dessa barra serão gravados, são passados para o método de busca do padrão. Se o padrão for encontrado, o tipo do padrão encontrado é registrado no objeto-barra onde o padrão foi encontrado, e o ponteiro para essa barra, os dados da barra "mãe" e os dados do gráfico são registrados no objeto-padrão encontrado na barra.
Método que define a flag para desenhar os ícones do padrão como pontos:
//+------------------------------------------------------------------+ //| Set the flag for drawing pattern icons as dots | //+------------------------------------------------------------------+ void CPatternControl::SetDrawingAsDots(const bool flag,const bool redraw) { this.m_draw_dots=flag; //--- Get a list of patterns controlled by the control object CArrayObj *list=this.GetListPatterns(); if(list==NULL || list.Total()==0) return; //--- In a loop by the list of patterns, for(int i=list.Total()-1;i>=0;i--) { //--- get the next pattern object CPattern *obj=list.At(i); if(obj==NULL) continue; //--- Set the flag value. If 'false', remove the pattern dot object obj.SetDrawAsDots(flag); if(!flag) obj.DeleteGraphObj(); //--- Display the pattern label on the chart if the flag is 'true' else obj.Draw(false); } //--- At the end of the cycle, redraw the chart if the flag is set if(redraw) ::ChartRedraw(this.m_chart_id); }
A lógica do método está descrita detalhadamente nos comentários do código. Aqui, obtemos a lista de padrões gerenciados por esse objeto de controle e registramos a flag de desenho com pontos em cada objeto-padrão. Se a flag for desativada, o ponto desenhado anteriormente deve ser removido, e se a flag estiver ativada, o ponto deve ser desenhado. Após o ciclo de processamento de todos os padrões na lista, e se a flag de redesenho for passada para o método, o gráfico é redesenhado.
Em seguida, precisamos aprimorar a classe de controle do padrão "Pin Bar". No método de busca do padrão, adicionaremos a variável MqlRates para registrar os dados da barra "mãe":
//+------------------------------------------------------------------+ //| Pin Bar pattern control class | //+------------------------------------------------------------------+ class CPatternControlPinBar : public CPatternControl { protected: //--- (1) Search for a pattern, return direction (or -1), //--- (2) create a pattern with a specified direction, //--- (3) create and return a unique pattern code //--- (4) return the list of patterns managed by the object virtual ENUM_PATTERN_DIRECTION FindPattern(const datetime series_bar_time,const uint min_body_size,MqlRates &mother_bar_data) const; virtual CPattern *CreatePattern(const ENUM_PATTERN_DIRECTION direction,const uint id,CBar *bar); virtual ulong GetPatternCode(const ENUM_PATTERN_DIRECTION direction,const datetime time) const { //--- unique pattern code = candle opening time + type + status + pattern direction + timeframe + timeseries symbol return(time+PATTERN_TYPE_PIN_BAR+PATTERN_STATUS_PA+direction+this.Timeframe()+this.m_symbol_code); } virtual CArrayObj*GetListPatterns(void); //--- Create object ID based on pattern search criteria virtual ulong CreateObjectID(void); public: //--- Parametric constructor CPatternControlPinBar(const string symbol,const ENUM_TIMEFRAMES timeframe, CArrayObj *list_series,CArrayObj *list_patterns, const double ratio_body_to_candle_size, const double ratio_larger_shadow_to_candle_size, const double ratio_smaller_shadow_to_candle_size) : CPatternControl(symbol,timeframe,PATTERN_STATUS_PA,PATTERN_TYPE_PIN_BAR,list_series,list_patterns) { this.m_ratio_body_to_candle_size=ratio_body_to_candle_size; this.m_ratio_larger_shadow_to_candle_size=ratio_larger_shadow_to_candle_size; this.m_ratio_smaller_shadow_to_candle_size=ratio_smaller_shadow_to_candle_size; this.m_object_id=this.CreateObjectID(); } };
No método que cria o padrão com a direção especificada, registraremos os dados da barra na variável MqlRates:
//+--------------------------------------------------------------------+ //| CPatternControlPinBar::Create a pattern with a specified direction | //+--------------------------------------------------------------------+ CPattern *CPatternControlPinBar::CreatePattern(const ENUM_PATTERN_DIRECTION direction,const uint id,CBar *bar) { //--- If invalid indicator is passed to the bar object, return NULL if(bar==NULL) return NULL; //--- Fill the MqlRates structure with bar data MqlRates rates={0}; this.SetBarData(bar,rates); //--- Create a new Pin Bar pattern CPatternPinBar *obj=new CPatternPinBar(id,this.Symbol(),this.Timeframe(),rates,direction); if(obj==NULL) return NULL; //--- set the proportions of the candle the pattern was found on to the properties of the created pattern object obj.SetProperty(PATTERN_PROP_RATIO_BODY_TO_CANDLE_SIZE,bar.RatioBodyToCandleSize()); obj.SetProperty(PATTERN_PROP_RATIO_LOWER_SHADOW_TO_CANDLE_SIZE,bar.RatioLowerShadowToCandleSize()); obj.SetProperty(PATTERN_PROP_RATIO_UPPER_SHADOW_TO_CANDLE_SIZE,bar.RatioUpperShadowToCandleSize()); //--- set the search criteria of the candle the pattern was found on to the properties of the created pattern object obj.SetProperty(PATTERN_PROP_RATIO_BODY_TO_CANDLE_SIZE_CRITERION,this.RatioBodyToCandleSizeValue()); obj.SetProperty(PATTERN_PROP_RATIO_LARGER_SHADOW_TO_CANDLE_SIZE_CRITERION,this.RatioLargerShadowToCandleSizeValue()); obj.SetProperty(PATTERN_PROP_RATIO_SMALLER_SHADOW_TO_CANDLE_SIZE_CRITERION,this.RatioSmallerShadowToCandleSizeValue()); //--- Set the control object ID to the pattern object obj.SetProperty(PATTERN_PROP_CTRL_OBJ_ID,this.ObjectID()); //--- Return the pointer to a created object return obj; }
Anteriormente, registrávamos os dados elemento por elemento. Agora, essa gravação elemento por elemento é realizada no método SetBarData(), o que é o mesmo, mas o código do método fica mais conciso.
No método que busca o padrão, registraremos os dados da barra "mãe" a partir dos dados da barra onde o padrão foi encontrado:
//+------------------------------------------------------------------+ //| CPatternControlPinBar::Search for the pattern | //+------------------------------------------------------------------+ ENUM_PATTERN_DIRECTION CPatternControlPinBar::FindPattern(const datetime series_bar_time,const uint min_body_size,MqlRates &mother_bar_data) const { //--- Get data for one bar by time CArrayObj *list=CSelect::ByBarProperty(this.m_list_series,BAR_PROP_TIME,series_bar_time,EQUAL); //--- If the list is empty, return -1 if(list==NULL || list.Total()==0) return WRONG_VALUE; //--- he size of the candle body should be less than or equal to RatioBodyToCandleSizeValue() (default 30%) of the entire candle size, //--- in this case, the body size should not be less than min_body_size list=CSelect::ByBarProperty(list,BAR_PROP_RATIO_BODY_TO_CANDLE_SIZE,this.RatioBodyToCandleSizeValue(),EQUAL_OR_LESS); list=CSelect::ByBarProperty(list,BAR_PROP_RATIO_BODY_TO_CANDLE_SIZE,min_body_size,EQUAL_OR_MORE); //--- If the list is empty - there are no patterns, return -1 if(list==NULL || list.Total()==0) return WRONG_VALUE; //--- Define the bullish pattern //--- The lower shadow should be equal to or greater than RatioLargerShadowToCandleSizeValue() (default 60%) of the entire candle size CArrayObj *list_bullish=CSelect::ByBarProperty(list,BAR_PROP_RATIO_LOWER_SHADOW_TO_CANDLE_SIZE,this.RatioLargerShadowToCandleSizeValue(),EQUAL_OR_MORE); //--- The upper shadow should be less than or equal to RatioSmallerShadowToCandleSizeValue() (default 30%) of the entire candle size list_bullish=CSelect::ByBarProperty(list_bullish,BAR_PROP_RATIO_UPPER_SHADOW_TO_CANDLE_SIZE,this.RatioSmallerShadowToCandleSizeValue(),EQUAL_OR_LESS); //--- If a pattern is found on the bar if(list_bullish!=NULL && list_bullish.Total()>0) { CBar *bar=list.At(list_bullish.Total()-1); if(bar!=NULL) { this.SetBarData(bar,mother_bar_data); return PATTERN_DIRECTION_BULLISH; } } //--- Define the bearish pattern //--- The upper shadow should be equal to or greater than RatioLargerShadowToCandleSizeValue() (default 60%) of the entire candle size CArrayObj *list_bearish=CSelect::ByBarProperty(list,BAR_PROP_RATIO_UPPER_SHADOW_TO_CANDLE_SIZE,this.RatioLargerShadowToCandleSizeValue(),EQUAL_OR_MORE); //--- The lower shadow should be less than or equal to RatioSmallerShadowToCandleSizeValue() (default 30%) of the entire candle size list_bearish=CSelect::ByBarProperty(list_bearish,BAR_PROP_RATIO_LOWER_SHADOW_TO_CANDLE_SIZE,this.RatioSmallerShadowToCandleSizeValue(),EQUAL_OR_LESS); //--- If a pattern is found on the bar if(list_bearish!=NULL && list_bearish.Total()>0) { CBar *bar=list.At(list_bearish.Total()-1); if(bar!=NULL) { this.SetBarData(bar,mother_bar_data); return PATTERN_DIRECTION_BEARISH; } } //--- No patterns found - return -1 return WRONG_VALUE; }
Como o "Pin Bar" é uma formação de uma única barra, a barra "mãe" é ao mesmo tempo a barra determinante, na qual o padrão foi encontrado.
Vamos criar a classe de controle para o padrão "Barra Interna". A estrutura desse padrão é estritamente definida e não possui outros parâmetros, exceto que a barra determinante (barra à direita) deve estar completamente dentro da barra "mãe" (barra à esquerda). Não há outros parâmetros. Portanto, qualquer padrão "Barra Interna" é o único padrão em uma série temporal, ao contrário do padrão "Pin Bar", no qual podemos definir parâmetros de busca, permitindo que haja vários padrões "Pin Bar" com diferentes parâmetros em uma série temporal, e para cada um desses padrões é criado um objeto de controle próprio. Para o padrão "Barra Interna", com base no que foi dito, sempre será criado apenas um objeto de controle para cada série temporal.
No mesmo arquivo, após a classe de controle do padrão "Pin Bar", vamos inserir a nova classe de controle do padrão "Barra Interna":
//+------------------------------------------------------------------+ //| Inside Bar pattern control class | //+------------------------------------------------------------------+ class CPatternControlInsideBar : public CPatternControl { private: //--- Check and return the presence of a pattern on two adjacent bars bool CheckInsideBar(const CBar *bar1,const CBar *bar0) const { //--- If empty bar objects are passed, return 'false' if(bar0==NULL || bar1==NULL) return false; //--- Return the fact that the bar on the right is completely within the dimensions of the bar on the left return(bar0.High()<bar1.High() && bar0.Low()>bar1.Low()); } bool FindMotherBar(CArrayObj *list,MqlRates &rates) const { bool res=false; if(list==NULL) return false; //--- In a loop through the list, starting from the bar to the left of the base one for(int i=list.Total()-2;i>0;i--) { //--- Get the pointers to two consecutive bars CBar *bar0=list.At(i); CBar *bar1=list.At(i-1); if(bar0==NULL || bar1==NULL) return false; //--- If the obtained bars represent a pattern if(CheckInsideBar(bar1,bar0)) { //--- set mother bar data to the MqlRates variable and set 'res' to 'true' this.SetBarData(bar1,rates); res=true; } //--- If there is no pattern, interrupt the loop else break; } //--- return the result return res; } protected: //--- (1) Search for a pattern, return direction (or -1), //--- (2) create a pattern with a specified direction, //--- (3) create and return a unique pattern code //--- (4) return the list of patterns managed by the object virtual ENUM_PATTERN_DIRECTION FindPattern(const datetime series_bar_time,const uint min_body_size,MqlRates &mother_bar_data) const; virtual CPattern *CreatePattern(const ENUM_PATTERN_DIRECTION direction,const uint id,CBar *bar); virtual ulong GetPatternCode(const ENUM_PATTERN_DIRECTION direction,const datetime time) const { //--- unique pattern code = candle opening time + type + status + pattern direction + timeframe + timeseries symbol return(time+PATTERN_TYPE_INSIDE_BAR+PATTERN_STATUS_PA+PATTERN_DIRECTION_BOTH+this.Timeframe()+this.m_symbol_code); } virtual CArrayObj*GetListPatterns(void); //--- Create object ID based on pattern search criteria virtual ulong CreateObjectID(void); public: //--- Parametric constructor CPatternControlInsideBar(const string symbol,const ENUM_TIMEFRAMES timeframe, CArrayObj *list_series,CArrayObj *list_patterns) : CPatternControl(symbol,timeframe,PATTERN_STATUS_PA,PATTERN_TYPE_INSIDE_BAR,list_series,list_patterns) { this.m_ratio_body_to_candle_size=0; this.m_ratio_larger_shadow_to_candle_size=0; this.m_ratio_smaller_shadow_to_candle_size=0; this.m_object_id=this.CreateObjectID(); } };
A classe é praticamente uma cópia da classe de controle do padrão "Pin Bar", que foi discutida no artigo anterior sobre os padrões da biblioteca. No construtor da classe, definimos todos os critérios de busca do padrão como zero, pois eles não são usados aqui. E o identificador do objeto é sempre igual a zero porque este é o único objeto em uma série temporal:
//+------------------------------------------------------------------+ //| Create object ID based on pattern search criteria | //+------------------------------------------------------------------+ ulong CPatternControlInsideBar::CreateObjectID(void) { return 0; }
Os métodos principais para a busca do padrão são o método de comparação de duas barras adjacentes para a presença do padrão e o método para buscar a barra "mãe":
//--- Check and return the presence of a pattern on two adjacent bars bool CheckInsideBar(const CBar *bar1,const CBar *bar0) const { //--- If empty bar objects are passed, return 'false' if(bar0==NULL || bar1==NULL) return false; //--- Return the fact that the bar on the right is completely within the dimensions of the bar on the left return(bar0.High()<bar1.High() && bar0.Low()>bar1.Low()); } bool FindMotherBar(CArrayObj *list,MqlRates &rates) const { bool res=false; if(list==NULL) return false; //--- In a loop through the list, starting from the bar to the left of the base one for(int i=list.Total()-2;i>0;i--) { //--- Get the pointers to two consecutive bars CBar *bar0=list.At(i); CBar *bar1=list.At(i-1); if(bar0==NULL || bar1==NULL) return false; //--- If the obtained bars represent a pattern if(CheckInsideBar(bar1,bar0)) { //--- set mother bar data to the MqlRates variable and set 'res' to 'true' this.SetBarData(bar1,rates); res=true; } //--- If there is no pattern, interrupt the loop else break; } //--- return the result return res; }
No método de busca do padrão, simplesmente comparamos os tamanhos de duas barras adjacentes e retornamos um indicador de que a barra à direita está completamente dentro da barra à esquerda.
No método de busca da barra "mãe", percorremos a lista de barras em um loop, procurando os padrões, e, se o padrão for encontrado, os dados da barra são registrados na variável MqlRates, e a busca continua na próxima dupla de barras. A busca continua enquanto os padrões forem encontrados em cada iteração do loop, e os dados da barra "mãe" são registrados na variável para cada nova barra. Dessa forma, encontramos todos os padrões aninhados, e os dados da barra "mãe" são finalmente obtidos da barra mais à esquerda de toda a sequência.
Método que cria o padrão com a direção especificada:
//+------------------------------------------------------------------------+ //|CPatternControlInsideBar::Create a pattern with the specified direction | //+------------------------------------------------------------------------+ CPattern *CPatternControlInsideBar::CreatePattern(const ENUM_PATTERN_DIRECTION direction,const uint id,CBar *bar) { //--- If invalid indicator is passed to the bar object, return NULL if(bar==NULL) return NULL; //--- Fill the MqlRates structure with bar data MqlRates rates={0}; this.SetBarData(bar,rates); //--- Create a new Inside Bar pattern CPatternInsideBar *obj=new CPatternInsideBar(id,this.Symbol(),this.Timeframe(),rates,PATTERN_DIRECTION_BOTH); if(obj==NULL) return NULL; //--- set the proportions of the candle the pattern was found on to the properties of the created pattern object obj.SetProperty(PATTERN_PROP_RATIO_BODY_TO_CANDLE_SIZE,bar.RatioBodyToCandleSize()); obj.SetProperty(PATTERN_PROP_RATIO_LOWER_SHADOW_TO_CANDLE_SIZE,bar.RatioLowerShadowToCandleSize()); obj.SetProperty(PATTERN_PROP_RATIO_UPPER_SHADOW_TO_CANDLE_SIZE,bar.RatioUpperShadowToCandleSize()); //--- set the search criteria of the candle the pattern was found on to the properties of the created pattern object obj.SetProperty(PATTERN_PROP_RATIO_BODY_TO_CANDLE_SIZE_CRITERION,this.RatioBodyToCandleSizeValue()); obj.SetProperty(PATTERN_PROP_RATIO_LARGER_SHADOW_TO_CANDLE_SIZE_CRITERION,this.RatioLargerShadowToCandleSizeValue()); obj.SetProperty(PATTERN_PROP_RATIO_SMALLER_SHADOW_TO_CANDLE_SIZE_CRITERION,this.RatioSmallerShadowToCandleSizeValue()); //--- Set the control object ID to the pattern object obj.SetProperty(PATTERN_PROP_CTRL_OBJ_ID,this.ObjectID()); //--- Return the pointer to a created object return obj; }
O método simplesmente cria um novo objeto da classe do padrão "Barra Interna" e retorna o resultado da criação do novo objeto. Tudo o que está abaixo das linhas de criação do novo objeto são, por enquanto, atribuições inúteis de zeros às propriedades do objeto, que já são atribuídas no construtor da classe. Mas isso foi mantido por enquanto, pois no futuro pode ser necessário adicionar o uso de alguns parâmetros para identificar o padrão. Se isso não for necessário, o código redundante será removido daqui.
Método para a busca do padrão:
//+------------------------------------------------------------------+ //| CPatternControlInsideBar::Search for pattern | //+------------------------------------------------------------------+ ENUM_PATTERN_DIRECTION CPatternControlInsideBar::FindPattern(const datetime series_bar_time,const uint min_body_size,MqlRates &mother_bar_data) const { //--- Get bar data up to and including the specified time CArrayObj *list=CSelect::ByBarProperty(this.m_list_series,BAR_PROP_TIME,series_bar_time,EQUAL_OR_LESS); //--- If the list is empty, return -1 if(list==NULL || list.Total()==0) return WRONG_VALUE; //--- Sort the list by bar opening time list.Sort(SORT_BY_BAR_TIME); //--- Get the latest bar from the list (base bar) CBar *bar_patt=list.At(list.Total()-1); if(bar_patt==NULL) return WRONG_VALUE; //--- In the loop from the next bar (mother), for(int i=list.Total()-2;i>=0;i--) { CBar *bar_prev=list.At(i); if(bar_prev==NULL) return WRONG_VALUE; //--- check that the resulting two bars are a pattern. If not, return -1 if(!this.CheckInsideBar(bar_prev,bar_patt)) return WRONG_VALUE; //--- If the pattern is found at the previous step, look for nested patterns. //--- The leftmost bar will be the mother bar for the entire chain of nested patterns //--- If the found pattern does not have nested ones, then its mother bar will be the current cycle bar (to the left of the base one) if(!this.FindMotherBar(list,mother_bar_data)) SetBarData(bar_prev,mother_bar_data); //--- Return the pattern direction (bidirectional) return PATTERN_DIRECTION_BOTH; } //--- No patterns found - return -1 return WRONG_VALUE; }
A lógica do método está descrita nos comentários. O método recebe o horário de abertura da barra atual. Obtemos a lista de todas as barras, exceto a atual (não buscamos padrões na barra zero). No loop pela lista de barras obtida, verificamos cada par de barras adjacentes para verificar se atendem aos critérios do padrão. Se a relação entre as barras representar um padrão, procuramos padrões aninhados, ou seja, em um ciclo adicional, procuramos padrões próximos até que eles sejam encontrados. Assim, encontramos toda a cadeia de padrões próximos, e a barra mais à esquerda deles — sua barra esquerda — será a barra "mãe" para toda a cadeia de padrões aninhados. Essa barra, seu tempo e preços são registrados nas propriedades do padrão encontrado. Esses dados nos permitirão contornar toda a cadeia de padrões aninhados com uma moldura ao exibi-los no gráfico, o que será visível no EA de teste.
Método que retorna a lista de padrões gerenciados por este objeto:
//+------------------------------------------------------------------+ //| Returns the list of patterns managed by the object | //+------------------------------------------------------------------+ CArrayObj *CPatternControlInsideBar::GetListPatterns(void) { CArrayObj *list=CSelect::ByPatternProperty(this.m_list_all_patterns,PATTERN_PROP_PERIOD,this.Timeframe(),EQUAL); list=CSelect::ByPatternProperty(list,PATTERN_PROP_SYMBOL,this.Symbol(),EQUAL); list=CSelect::ByPatternProperty(list,PATTERN_PROP_TYPE,PATTERN_TYPE_INSIDE_BAR,EQUAL); return CSelect::ByPatternProperty(list,PATTERN_PROP_CTRL_OBJ_ID,this.ObjectID(),EQUAL); }
No class de controle de padrões, ajustaremos o método que retorna o objeto de controle do padrão "Barra Interna":
//--- Return the Inside Bar pattern control object CPatternControl *GetObjControlPatternInsideBar(void) { int total=this.m_list_controls.Total(); for(int i=0;i<total;i++) { CPatternControl *obj=this.m_list_controls.At(i); if(obj==NULL) continue; //--- Check search conditions and return the result if(obj.TypePattern()==PATTERN_TYPE_INSIDE_BAR) return obj; } return NULL; }
Anteriormente, o método retornava NULL, pois a classe do objeto retornado pelo método ainda não havia sido criada.
Vamos ajustar o método que define a flag de uso do padrão "Barra Interna" e cria o objeto de controle, caso ainda não exista:
//--- Set the flag for using the Pattern Inside and create a control object if it does not already exist void SetUsedPatternInsideBar(const bool flag) { //--- Get the pointer to the Inner Bar pattern control object CPatternControlInsideBar *obj=this.GetObjControlPatternInsideBar(); //--- If the pointer is received (the object exists), set the use flag if(obj!=NULL) obj.SetUsed(flag); //--- f there is no object and the flag is passed as 'true' else if(flag) { //--- Create the new Inside Bar pattern control object obj=new CPatternControlInsideBar(this.Symbol(),this.Timeframe(),this.m_list_series,this.m_list_all_patterns); if(obj==NULL) return; //--- Add pointer to the created object to the list if(!this.m_list_controls.Add(obj)) { delete obj; return; } //--- Set the usage flag and pattern parameters to the control object obj.SetUsed(flag); obj.SetRatioBodyToCandleSizeValue(0); obj.SetRatioLargerShadowToCandleSizeValue(0); obj.SetRatioSmallerShadowToCandleSizeValue(0); obj.CreateAndRefreshPatternList(0); } }
Anteriormente, o método estava vazio pelo motivo mencionado acima. A lógica do método está comentada no código e não precisa de explicações adicionais.
Vamos escrever métodos para definir a flag de desenho do padrão com pontos:
//+------------------------------------------------------------------+ //| Methods for setting the flag of drawing the pattern using dots | //+------------------------------------------------------------------+ //--- Set the flag for drawing the Harami pattern with dots void SetDrawingAsDotsPatternHarami(const bool flag,const bool redraw) { } //--- Set the flag for drawing the Harami Cross pattern with dots void SetDrawingAsDotsPatternHaramiCross(const bool flag,const bool redraw) { } //--- Set the flag for drawing the Tweezer pattern with dots void SetDrawingAsDotsPatternTweezer(const bool flag,const bool redraw) { } //--- Set the flag for drawing the Piercing Line pattern with dots void SetDrawingAsDotsPatternPiercingLine(const bool flag,const bool redraw) { } //--- Set the flag for drawing the Cloud Cover pattern with dots void SetDrawingAsDotsPatternDarkCloudCover(const bool flag,const bool redraw) { } //--- Set the flag for drawing the Three White Soldiers pattern with dots void SetDrawingAsDotsPatternThreeWhiteSoldiers(const bool flag,const bool redraw) { } //--- Set the flag for drawing the Three Black Crows pattern with dots void SetDrawingAsDotsPatternThreeBlackCrows(const bool flag,const bool redraw) { } //--- Set the flag for drawing the Shooting Star pattern with dots void SetDrawingAsDotsPatternShootingStar(const bool flag,const bool redraw) { } //--- Set the flag for drawing the Hammer pattern with dots void SetDrawingAsDotsPatternHammer(const bool flag,const bool redraw) { } //--- Set the flag for drawing the Inverted Hammer pattern with dots void SetDrawingAsDotsPatternInvertedHammer(const bool flag,const bool redraw) { } //--- Set the flag for drawing the Hanging Man pattern with dots void SetDrawingAsDotsPatternHangingMan(const bool flag,const bool redraw) { } //--- Set the flag for drawing the Doji pattern with dots void SetDrawingAsDotsPatternDoji(const bool flag,const bool redraw) { } //--- Set the flag for drawing the Dragonfly Doji pattern with dots void SetDrawingAsDotsPatternDragonflyDoji(const bool flag,const bool redraw) { } //--- Set the flag for drawing the Gravestone Doji pattern with dots void SetDrawingAsDotsPatternGravestoneDoji(const bool flag,const bool redraw) { } //--- Set the flag for drawing the Morning Star pattern with dots void SetDrawingAsDotsPatternMorningStar(const bool flag,const bool redraw) { } //--- Set the flag for drawing the Morning Doji Star pattern with dots void SetDrawingAsDotsPatternMorningDojiStar(const bool flag,const bool redraw) { } //--- Set the flag for drawing the Evening Star pattern with dots void SetDrawingAsDotsPatternEveningStar(const bool flag,const bool redraw) { } //--- Set the flag for drawing the Evening Doji Star pattern with dots void SetDrawingAsDotsPatternEveningDojiStar(const bool flag,const bool redraw) { } //--- Set the flag for drawing the Three Stars pattern with dots void SetDrawingAsDotsPatternThreeStars(const bool flag,const bool redraw) { } //--- Set the flag for drawing the Abandoned Baby pattern with dots void SetDrawingAsDotsPatternAbandonedBaby(const bool flag,const bool redraw) { } //--- Set the flag for drawing the Pivot Point Reversal pattern with dots //--- Price Action void SetDrawingAsDotsPatternPivotPointReversal(const bool flag,const bool redraw) { } //--- Set the flag for drawing the Outside Bar pattern with dots void SetDrawingAsDotsPatternOutsideBar(const bool flag,const bool redraw) { } //--- Set the flag for drawing the Inside Bar pattern with dots void SetDrawingAsDotsPatternInsideBar(const bool flag,const bool redraw) { //--- Get the pointer to the Inner Bar pattern control object CPatternControlInsideBar *obj=this.GetObjControlPatternInsideBar(); //--- If the pointer is received (the object exists), set the drawing flag if(obj!=NULL) obj.SetDrawingAsDots(flag,redraw); } //--- Set the flag for drawing the Pin Bar pattern with dots void SetDrawingAsDotsPatternPinBar(const bool flag,const bool redraw, // Flag of drawing with dots and Pin Bar Price Action redraw flag const double ratio_body=30, // Percentage ratio of the candle body to the full size of the candle const double ratio_larger_shadow=60, // Percentage ratio of the size of the larger shadow to the size of the candle const double ratio_smaller_shadow=30) // Percentage ratio of the size of the smaller shadow to the size of the candle { //--- Get the pointer to the Pin Bar pattern control object with the specified parameters CPatternControlPinBar *obj=this.GetObjControlPatternPinBar(ratio_body,ratio_larger_shadow,ratio_smaller_shadow); //--- If the pointer is received (the object exists), set the use flag if(obj!=NULL) obj.SetDrawingAsDots(flag,redraw); } //--- Set the flag for drawing the Rails pattern with dots void SetDrawingAsDotsPatternRails(const bool flag,const bool redraw) { }
Apenas para dois padrões os métodos foram completamente escritos. Para os outros padrões, existem apenas esboços, que preencheremos à medida que escrevermos novas classes de objetos-padrões.
Vamos escrever métodos para retornar a flag de desenho do padrão com pontos:
//+------------------------------------------------------------------+ //| Methods of returning the flag of drawing with dots | //+------------------------------------------------------------------+ //--- Candle formations //--- Return the flag for drawing the Harami pattern with dots bool IsDrawingAsDotsPatternHarami(void) { CPatternControl *obj=GetObjControlPatternHarami(); return(obj!=NULL ? obj.IsDrawingAsDots() : false); } //--- Return the flag for drawing the Harami Cross pattern with dots bool IsDrawingAsDotsPatternHaramiCross(void) { CPatternControl *obj=GetObjControlPatternHaramiCross(); return(obj!=NULL ? obj.IsDrawingAsDots() : false); } //--- Return the flag for drawing the Tweezer pattern with dots bool IsDrawingAsDotsPatternTweezer(void) { CPatternControl *obj=GetObjControlPatternTweezer(); return(obj!=NULL ? obj.IsDrawingAsDots() : false); } //--- Return the flag for drawing the Piercing Line pattern with dots bool IsDrawingAsDotsPatternPiercingLine(void) { CPatternControl *obj=GetObjControlPatternPiercingLine(); return(obj!=NULL ? obj.IsDrawingAsDots() : false); } //--- Return the flag for drawing the Cloud Cover pattern with dots bool IsDrawingAsDotsPatternDarkCloudCover(void) { CPatternControl *obj=GetObjControlPatternDarkCloudCover(); return(obj!=NULL ? obj.IsDrawingAsDots() : false); } //--- Return the flag for drawing the Three White Soldiers pattern with dots bool IsDrawingAsDotsPatternThreeWhiteSoldiers(void) { CPatternControl *obj=GetObjControlPatternThreeWhiteSoldiers(); return(obj!=NULL ? obj.IsDrawingAsDots() : false); } //--- Return the flag for drawing the Three Black Crows pattern with dots bool IsDrawingAsDotsPatternThreeBlackCrows(void) { CPatternControl *obj=GetObjControlPatternThreeBlackCrows(); return(obj!=NULL ? obj.IsDrawingAsDots() : false); } //--- Return the flag for drawing the Shooting Star pattern with dots bool IsDrawingAsDotsPatternShootingStar(void) { CPatternControl *obj=GetObjControlPatternShootingStar(); return(obj!=NULL ? obj.IsDrawingAsDots() : false); } //--- Return the flag for drawing the Hammer pattern with dots bool IsDrawingAsDotsPatternHammer(void) { CPatternControl *obj=GetObjControlPatternHammer(); return(obj!=NULL ? obj.IsDrawingAsDots() : false); } //--- Return the flag for drawing the Inverted Hammer pattern with dots bool IsDrawingAsDotsPatternInvertedHammer(void) { CPatternControl *obj=GetObjControlPatternInvertedHammer(); return(obj!=NULL ? obj.IsDrawingAsDots() : false); } //--- Return the flag for drawing the Hanging Man pattern with dots bool IsDrawingAsDotsPatternHangingMan(void) { CPatternControl *obj=GetObjControlPatternHangingMan(); return(obj!=NULL ? obj.IsDrawingAsDots() : false); } //--- Return the flag for drawing the Doji pattern with dots bool IsDrawingAsDotsPatternDoji(void) { CPatternControl *obj=GetObjControlPatternDoji(); return(obj!=NULL ? obj.IsDrawingAsDots() : false); } //--- Return the flag for drawing the Dragonfly Doji pattern with dots bool IsDrawingAsDotsPatternDragonflyDoji(void) { CPatternControl *obj=GetObjControlPatternDragonflyDoji(); return(obj!=NULL ? obj.IsDrawingAsDots() : false); } //--- Return the flag for drawing the Gravestone Doji pattern with dots bool IsDrawingAsDotsPatternGravestoneDoji(void) { CPatternControl *obj=GetObjControlPatternGravestoneDoji(); return(obj!=NULL ? obj.IsDrawingAsDots() : false); } //--- Return the flag for drawing the Morning Star pattern with dots bool IsDrawingAsDotsPatternMorningStar(void) { CPatternControl *obj=GetObjControlPatternMorningStar(); return(obj!=NULL ? obj.IsDrawingAsDots() : false); } //--- Return the flag for drawing the Morning Doji Star pattern with dots bool IsDrawingAsDotsPatternMorningDojiStar(void) { CPatternControl *obj=GetObjControlPatternMorningDojiStar(); return(obj!=NULL ? obj.IsDrawingAsDots() : false); } //--- Return the flag for drawing the Evening Star pattern with dots bool IsDrawingAsDotsPatternEveningStar(void) { CPatternControl *obj=GetObjControlPatternEveningStar(); return(obj!=NULL ? obj.IsDrawingAsDots() : false); } //--- Return the flag for drawing the Evening Doji Star pattern with dots bool IsDrawingAsDotsPatternEveningDojiStar(void) { CPatternControl *obj=GetObjControlPatternEveningDojiStar(); return(obj!=NULL ? obj.IsDrawingAsDots() : false); } //--- Return the flag for drawing the Three Stars pattern with dots bool IsDrawingAsDotsPatternThreeStars(void) { CPatternControl *obj=GetObjControlPatternThreeStars(); return(obj!=NULL ? obj.IsDrawingAsDots() : false); } //--- Return the flag for drawing the Abandoned Baby pattern with dots bool IsDrawingAsDotsPatternAbandonedBaby(void) { CPatternControl *obj=GetObjControlPatternAbandonedBaby(); return(obj!=NULL ? obj.IsDrawingAsDots() : false); } //--- Price Action //--- Return the flag for drawing the Pivot Point Reversal pattern with dots bool IsDrawingAsDotsPatternPivotPointReversal(void) { CPatternControl *obj=GetObjControlPatternPivotPointReversal(); return(obj!=NULL ? obj.IsDrawingAsDots() : false); } //--- Return the flag for drawing the Outside Bar pattern with dots bool IsDrawingAsDotsPatternOutsideBar(void) { CPatternControl *obj=GetObjControlPatternOutsideBar(); return(obj!=NULL ? obj.IsDrawingAsDots() : false); } //--- Return the flag for drawing the Inside Bar pattern with dots bool IsDrawingAsDotsPatternInsideBar(void) { CPatternControl *obj=GetObjControlPatternInsideBar(); return(obj!=NULL ? obj.IsDrawingAsDots() : false); } //--- Return the flag for drawing the Pin Bar pattern with dots bool IsDrawingAsDotsPatternPinBar(const double ratio_body=30, // Percentage ratio of the candle body to the full size of the candle const double ratio_larger_shadow=60, // Percentage ratio of the size of the larger shadow to the size of the candle const double ratio_smaller_shadow=30) // Percentage ratio of the size of the smaller shadow to the size of the candle { //--- Get the pattern control object based on its parameters CPatternControl *obj=this.GetObjControlPatternPinBar(ratio_body,ratio_larger_shadow,ratio_smaller_shadow); //--- Return the pattern use flag, or 'false' if the object is not found return(obj!=NULL ? obj.IsDrawingAsDots() : false); } //--- Return the flag for drawing the Rails pattern with dots bool IsDrawingAsDotsPatternRails(void) { CPatternControl *obj=GetObjControlPatternRails(); return(obj!=NULL ? obj.IsDrawingAsDots() : false); }
Para o método que retorna a flag de desenho com pontos do padrão "Pin Bar", foram escritos os parâmetros de entrada, pois todos os métodos para trabalhar com esse padrão os possuem. Os outros métodos, por enquanto, apenas retornam as flags de desenho com pontos sem quaisquer parâmetros. Se algum padrão precisar de parâmetros, eles serão adicionados a esses métodos posteriormente.
Agora, esses mesmos métodos precisam ser escritos para a classe da série temporal, localizada neste mesmo arquivo:
//--- Set the flag for using the Pattern Inside and create a control object if it does not already exist void SetUsedPatternInsideBar(const bool flag) { if(this.m_patterns_control==NULL) return; this.m_patterns_control.SetUsedPatternInsideBar(flag); }
...
//+------------------------------------------------------------------+ //| Methods for setting the flag of drawing the pattern using dots | //+------------------------------------------------------------------+ //--- Set the flag for drawing the Harami pattern with dots void SetDrawingAsDotsPatternHarami(const bool flag,const bool redraw) { if(this.m_patterns_control==NULL) return; this.m_patterns_control.SetDrawingAsDotsPatternHarami(flag,redraw); } //--- Set the flag for drawing the Harami Cross pattern with dots void SetDrawingAsDotsPatternHaramiCross(const bool flag,const bool redraw) { if(this.m_patterns_control==NULL) return; this.m_patterns_control.SetDrawingAsDotsPatternHaramiCross(flag,redraw); } //--- Set the flag for drawing the Tweezer pattern with dots void SetDrawingAsDotsPatternTweezer(const bool flag,const bool redraw) { if(this.m_patterns_control==NULL) return; this.m_patterns_control.SetDrawingAsDotsPatternTweezer(flag,redraw); } //--- Set the flag for drawing the Piercing Line pattern with dots void SetDrawingAsDotsPatternPiercingLine(const bool flag,const bool redraw) { if(this.m_patterns_control==NULL) return; this.m_patterns_control.SetDrawingAsDotsPatternPiercingLine(flag,redraw); } //--- Set the flag for drawing the Cloud Cover pattern with dots void SetDrawingAsDotsPatternDarkCloudCover(const bool flag,const bool redraw) { if(this.m_patterns_control==NULL) return; this.m_patterns_control.SetDrawingAsDotsPatternDarkCloudCover(flag,redraw); } //--- Set the flag for drawing the Three White Soldiers pattern with dots void SetDrawingAsDotsPatternThreeWhiteSoldiers(const bool flag,const bool redraw) { if(this.m_patterns_control==NULL) return; this.m_patterns_control.SetDrawingAsDotsPatternThreeWhiteSoldiers(flag,redraw); } //--- Set the flag for drawing the Three Black Crows pattern with dots void SetDrawingAsDotsPatternThreeBlackCrows(const bool flag,const bool redraw) { if(this.m_patterns_control==NULL) return; this.m_patterns_control.SetDrawingAsDotsPatternThreeBlackCrows(flag,redraw); } //--- Set the flag for drawing the Shooting Star pattern with dots void SetDrawingAsDotsPatternShootingStar(const bool flag,const bool redraw) { if(this.m_patterns_control==NULL) return; this.m_patterns_control.SetDrawingAsDotsPatternShootingStar(flag,redraw); } //--- Set the flag for drawing the Hammer pattern with dots void SetDrawingAsDotsPatternHammer(const bool flag,const bool redraw) { if(this.m_patterns_control==NULL) return; this.m_patterns_control.SetDrawingAsDotsPatternHammer(flag,redraw); } //--- Set the flag for drawing the Inverted Hammer pattern with dots void SetDrawingAsDotsPatternInvertedHammer(const bool flag,const bool redraw) { if(this.m_patterns_control==NULL) return; this.m_patterns_control.SetDrawingAsDotsPatternInvertedHammer(flag,redraw); } //--- Set the flag for drawing the Hanging Man pattern with dots void SetDrawingAsDotsPatternHangingMan(const bool flag,const bool redraw) { if(this.m_patterns_control==NULL) return; this.m_patterns_control.SetDrawingAsDotsPatternHangingMan(flag,redraw); } //--- Set the flag for drawing the Doji pattern with dots void SetDrawingAsDotsPatternDoji(const bool flag,const bool redraw) { if(this.m_patterns_control==NULL) return; this.m_patterns_control.SetDrawingAsDotsPatternDoji(flag,redraw); } //--- Set the flag for drawing the Dragonfly Doji pattern with dots void SetDrawingAsDotsPatternDragonflyDoji(const bool flag,const bool redraw) { if(this.m_patterns_control==NULL) return; this.m_patterns_control.SetDrawingAsDotsPatternDragonflyDoji(flag,redraw); } //--- Set the flag for drawing the Gravestone Doji pattern with dots void SetDrawingAsDotsPatternGravestoneDoji(const bool flag,const bool redraw) { if(this.m_patterns_control==NULL) return; this.m_patterns_control.SetDrawingAsDotsPatternGravestoneDoji(flag,redraw); } //--- Set the flag for drawing the Morning Star pattern with dots void SetDrawingAsDotsPatternMorningStar(const bool flag,const bool redraw) { if(this.m_patterns_control==NULL) return; this.m_patterns_control.SetDrawingAsDotsPatternMorningStar(flag,redraw); } //--- Set the flag for drawing the Morning Doji Star pattern with dots void SetDrawingAsDotsPatternMorningDojiStar(const bool flag,const bool redraw) { if(this.m_patterns_control==NULL) return; this.m_patterns_control.SetDrawingAsDotsPatternMorningDojiStar(flag,redraw); } //--- Set the flag for drawing the Evening Star pattern with dots void SetDrawingAsDotsPatternEveningStar(const bool flag,const bool redraw) { if(this.m_patterns_control==NULL) return; this.m_patterns_control.SetDrawingAsDotsPatternEveningStar(flag,redraw); } //--- Set the flag for drawing the Evening Doji Star pattern with dots void SetDrawingAsDotsPatternEveningDojiStar(const bool flag,const bool redraw) { if(this.m_patterns_control==NULL) return; this.m_patterns_control.SetDrawingAsDotsPatternEveningDojiStar(flag,redraw); } //--- Set the flag for drawing the Three Stars pattern with dots void SetDrawingAsDotsPatternThreeStars(const bool flag,const bool redraw) { if(this.m_patterns_control==NULL) return; this.m_patterns_control.SetDrawingAsDotsPatternThreeStars(flag,redraw); } //--- Set the flag for drawing the Abandoned Baby pattern with dots void SetDrawingAsDotsPatternAbandonedBaby(const bool flag,const bool redraw) { if(this.m_patterns_control==NULL) return; this.m_patterns_control.SetDrawingAsDotsPatternAbandonedBaby(flag,redraw); } //--- Set the flag for drawing the Pivot Point Reversal pattern with dots //--- Price Action void SetDrawingAsDotsPatternPivotPointReversal(const bool flag,const bool redraw) { if(this.m_patterns_control==NULL) return; this.m_patterns_control.SetDrawingAsDotsPatternPivotPointReversal(flag,redraw); } //--- Set the flag for drawing the Outside Bar pattern with dots void SetDrawingAsDotsPatternOutsideBar(const bool flag,const bool redraw) { if(this.m_patterns_control==NULL) return; this.m_patterns_control.SetDrawingAsDotsPatternOutsideBar(flag,redraw); } //--- Set the flag for drawing the Inside Bar pattern with dots void SetDrawingAsDotsPatternInsideBar(const bool flag,const bool redraw) { if(this.m_patterns_control==NULL) return; this.m_patterns_control.SetDrawingAsDotsPatternInsideBar(flag,redraw); } //--- Set the flag for drawing the Pin Bar pattern with dots void SetDrawingAsDotsPatternPinBar(const bool flag,const bool redraw, // Flag of drawing with dots and Pin Bar Price Action redraw flag const double ratio_body=30, // Percentage ratio of the candle body to the full size of the candle const double ratio_larger_shadow=60, // Percentage ratio of the size of the larger shadow to the size of the candle const double ratio_smaller_shadow=30) // Percentage ratio of the size of the smaller shadow to the size of the candle { if(this.m_patterns_control==NULL) return; this.m_patterns_control.SetDrawingAsDotsPatternPinBar(flag,redraw,ratio_body,ratio_larger_shadow,ratio_smaller_shadow); } //--- Set the flag for drawing the Rails pattern with dots void SetDrawingAsDotsPatternRails(const bool flag,const bool redraw) { if(this.m_patterns_control==NULL) return; this.m_patterns_control.SetDrawingAsDotsPatternRails(flag,redraw); } //+------------------------------------------------------------------+ //| Methods of returning the flag of drawing with dots | //+------------------------------------------------------------------+ //--- Candle formations //--- Return the flag for drawing the Harami pattern with dots bool IsDrawingAsDotsPatternHarami(void) { return(this.m_patterns_control!=NULL ? this.m_patterns_control.IsDrawingAsDotsPatternHarami() : false); } //--- Return the flag for drawing the Harami Cross pattern with dots bool IsDrawingAsDotsPatternHaramiCross(void) { return(this.m_patterns_control!=NULL ? this.m_patterns_control.IsDrawingAsDotsPatternHaramiCross() : false); } //--- Return the flag for drawing the Tweezer pattern with dots bool IsDrawingAsDotsPatternTweezer(void) { return(this.m_patterns_control!=NULL ? this.m_patterns_control.IsDrawingAsDotsPatternTweezer() : false); } //--- Return the flag for drawing the Piercing Line pattern with dots bool IsDrawingAsDotsPatternPiercingLine(void) { return(this.m_patterns_control!=NULL ? this.m_patterns_control.IsDrawingAsDotsPatternPiercingLine() : false); } //--- Return the flag for drawing the Cloud Cover pattern with dots bool IsDrawingAsDotsPatternDarkCloudCover(void) { return(this.m_patterns_control!=NULL ? this.m_patterns_control.IsDrawingAsDotsPatternDarkCloudCover() : false); } //--- Return the flag for drawing the Three White Soldiers pattern with dots bool IsDrawingAsDotsPatternThreeWhiteSoldiers(void) { return(this.m_patterns_control!=NULL ? this.m_patterns_control.IsDrawingAsDotsPatternThreeWhiteSoldiers() : false); } //--- Return the flag for drawing the Three Black Crows pattern with dots bool IsDrawingAsDotsPatternThreeBlackCrows(void) { return(this.m_patterns_control!=NULL ? this.m_patterns_control.IsDrawingAsDotsPatternThreeBlackCrows() : false); } //--- Return the flag for drawing the Shooting Star pattern with dots bool IsDrawingAsDotsPatternShootingStar(void) { return(this.m_patterns_control!=NULL ? this.m_patterns_control.IsDrawingAsDotsPatternShootingStar() : false); } //--- Return the flag for drawing the Hammer pattern with dots bool IsDrawingAsDotsPatternHammer(void) { return(this.m_patterns_control!=NULL ? this.m_patterns_control.IsDrawingAsDotsPatternHammer() : false); } //--- Return the flag for drawing the Inverted Hammer pattern with dots bool IsDrawingAsDotsPatternInvertedHammer(void) { return(this.m_patterns_control!=NULL ? this.m_patterns_control.IsDrawingAsDotsPatternInvertedHammer() : false); } //--- Return the flag for drawing the Hanging Man pattern with dots bool IsDrawingAsDotsPatternHangingMan(void) { return(this.m_patterns_control!=NULL ? this.m_patterns_control.IsDrawingAsDotsPatternHangingMan() : false); } //--- Return the flag for drawing the Doji pattern with dots bool IsDrawingAsDotsPatternDoji(void) { return(this.m_patterns_control!=NULL ? this.m_patterns_control.IsDrawingAsDotsPatternDoji() : false); } //--- Return the flag for drawing the Dragonfly Doji pattern with dots bool IsDrawingAsDotsPatternDragonflyDoji(void) { return(this.m_patterns_control!=NULL ? this.m_patterns_control.IsDrawingAsDotsPatternDragonflyDoji() : false); } //--- Return the flag for drawing the Gravestone Doji pattern with dots bool IsDrawingAsDotsPatternGravestoneDoji(void) { return(this.m_patterns_control!=NULL ? this.m_patterns_control.IsDrawingAsDotsPatternGravestoneDoji() : false); } //--- Return the flag for drawing the Morning Star pattern with dots bool IsDrawingAsDotsPatternMorningStar(void) { return(this.m_patterns_control!=NULL ? this.m_patterns_control.IsDrawingAsDotsPatternMorningStar() : false); } //--- Return the flag for drawing the Morning Doji Star pattern with dots bool IsDrawingAsDotsPatternMorningDojiStar(void) { return(this.m_patterns_control!=NULL ? this.m_patterns_control.IsDrawingAsDotsPatternMorningDojiStar() : false); } //--- Return the flag for drawing the Evening Star pattern with dots bool IsDrawingAsDotsPatternEveningStar(void) { return(this.m_patterns_control!=NULL ? this.m_patterns_control.IsDrawingAsDotsPatternEveningStar() : false); } //--- Return the flag for drawing the Evening Doji Star pattern with dots bool IsDrawingAsDotsPatternEveningDojiStar(void) { return(this.m_patterns_control!=NULL ? this.m_patterns_control.IsDrawingAsDotsPatternEveningDojiStar() : false); } //--- Return the flag for drawing the Three Stars pattern with dots bool IsDrawingAsDotsPatternThreeStars(void) { return(this.m_patterns_control!=NULL ? this.m_patterns_control.IsDrawingAsDotsPatternThreeStars() : false); } //--- Return the flag for drawing the Abandoned Baby pattern with dots bool IsDrawingAsDotsPatternAbandonedBaby(void) { return(this.m_patterns_control!=NULL ? this.m_patterns_control.IsDrawingAsDotsPatternAbandonedBaby() : false); } //--- Price Action //--- Return the flag for drawing the Pivot Point Reversal pattern with dots bool IsDrawingAsDotsPatternPivotPointReversal(void) { return(this.m_patterns_control!=NULL ? this.m_patterns_control.IsDrawingAsDotsPatternPivotPointReversal() : false); } //--- Return the flag for drawing the Outside Bar pattern with dots bool IsDrawingAsDotsPatternOutsideBar(void) { return(this.m_patterns_control!=NULL ? this.m_patterns_control.IsDrawingAsDotsPatternOutsideBar() : false); } //--- Return the flag for drawing the Inside Bar pattern with dots bool IsDrawingAsDotsPatternInsideBar(void) { return(this.m_patterns_control!=NULL ? this.m_patterns_control.IsDrawingAsDotsPatternInsideBar() : false); } //--- Return the flag for drawing the Pin Bar pattern with dots bool IsDrawingAsDotsPatternPinBar(const double ratio_body=30, // Percentage ratio of the candle body to the full size of the candle const double ratio_larger_shadow=60, // Percentage ratio of the size of the larger shadow to the size of the candle const double ratio_smaller_shadow=30) // Percentage ratio of the size of the smaller shadow to the size of the candle { return(this.m_patterns_control!=NULL ? this.m_patterns_control.IsDrawingAsDotsPatternPinBar(ratio_body,ratio_larger_shadow,ratio_smaller_shadow) : false); } //--- Return the flag for drawing the Rails pattern with dots bool IsDrawingAsDotsPatternRails(void) { return(this.m_patterns_control!=NULL ? this.m_patterns_control.IsDrawingAsDotsPatternRails() : false); }
Esses mesmos métodos precisam ser escritos no arquivo \MQL5\Include\DoEasy\Objects\SeriesTimeSeriesDE.mqh da classe da série temporal do símbolo:
Na seção pública, declararemos esses métodos:
//+------------------------------------------------------------------+ //| Methods for setting the flag of drawing the pattern using dots | //+------------------------------------------------------------------+ //--- Set the flag for using the Harami pattern and create a control object if it does not already exist void SetDrawingAsDotsPatternHarami(const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw); //--- Set the flag for using the Harami Cross pattern and create a control object if it does not already exist void SetDrawingAsDotsPatternHaramiCross(const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw); //--- Set the flag for using the Tweezer pattern and create a control object if it does not already exist void SetDrawingAsDotsPatternTweezer(const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw); //--- Set the flag for using the Piercing Line pattern and create a control object if it does not already exist void SetDrawingAsDotsPatternPiercingLine(const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw); //--- Set the flag for using the Cloud Cover pattern and create a control object if it does not already exist void SetDrawingAsDotsPatternDarkCloudCover(const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw); //--- Set the flag for using the Three White Soldiers pattern and create a control object if it does not already exist void SetDrawingAsDotsPatternThreeWhiteSoldiers(const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw); //--- Set the flag for using the Three Black Crows pattern and create a control object if it does not already exist void SetDrawingAsDotsPatternThreeBlackCrows(const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw); //--- Set the flag for using the Shooting Star pattern and create a control object if it does not already exist void SetDrawingAsDotsPatternShootingStar(const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw); //--- Set the flag for using the Hammer pattern and create a control object if it does not already exist void SetDrawingAsDotsPatternHammer(const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw); //--- Set the flag for using the Inverted Hammer pattern and create a control object if it does not already exist void SetDrawingAsDotsPatternInvertedHammer(const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw); //--- Set the flag for using the Hanging Man pattern and create a control object if it does not already exist void SetDrawingAsDotsPatternHangingMan(const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw); //--- Set the flag for using the Doji pattern and create a control object if it does not already exist void SetDrawingAsDotsPatternDoji(const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw); //--- Set the flag for using the Dragonfly Doji pattern and create a control object if it does not already exist void SetDrawingAsDotsPatternDragonflyDoji(const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw); //--- Set the flag for using the Doji Gravestone pattern and create a control object if it does not already exist void SetDrawingAsDotsPatternGravestoneDoji(const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw); //--- Set the flag for using the Morning Star pattern and create a control object if it does not already exist void SetDrawingAsDotsPatternMorningStar(const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw); //--- Set the flag for using the Morning Doji Star pattern and create a control object if it does not already exist void SetDrawingAsDotsPatternMorningDojiStar(const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw); //--- Set the flag for using the Evening Star pattern and create a control object if it does not already exist void SetDrawingAsDotsPatternEveningStar(const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw); //--- Set the flag for using the Evening Doji Star pattern and create a control object if it does not already exist void SetDrawingAsDotsPatternEveningDojiStar(const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw); //--- Set the flag for using the Three Stars pattern and create a control object if it does not already exist void SetDrawingAsDotsPatternThreeStars(const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw); //--- Set the flag for using the Abandoned Baby pattern and create a control object if it does not already exist void SetDrawingAsDotsPatternAbandonedBaby(const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw); //--- Set the flag for using the Pivot Point Reversal pattern and create a control object if it does not already exist //--- Price Action void SetDrawingAsDotsPatternPivotPointReversal(const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw); //--- Set the flag for using the Pattern Outside and create a control object if it does not already exist void SetDrawingAsDotsPatternOutsideBar(const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw); //--- Set the flag for using the Pattern Inside and create a control object if it does not already exist void SetDrawingAsDotsPatternInsideBar(const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw); //--- Set the flag for using the Pin Bar pattern and create a control object if it does not already exist void SetDrawingAsDotsPatternPinBar(const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw, // Flag of drawing with dots and Pin Bar Price Action redraw flag const double ratio_body=30, // Percentage ratio of the candle body to the full size of the candle const double ratio_larger_shadow=60, // Percentage ratio of the size of the larger shadow to the size of the candle const double ratio_smaller_shadow=30); // Percentage ratio of the size of the smaller shadow to the size of the candle //--- Set the flag for using the Rails pattern and create a control object if it does not already exist void SetDrawingAsDotsPatternRails(const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw); //+------------------------------------------------------------------+ //| Methods of returning the flag of drawing with dots | //+------------------------------------------------------------------+ //--- Candle formations //--- Return the flag of using the Harami pattern bool IsDrawingAsDotsPatternHarami(const ENUM_TIMEFRAMES timeframe); //--- Return the flag of using the Harami Cross pattern bool IsDrawingAsDotsPatternHaramiCross(const ENUM_TIMEFRAMES timeframe); //--- Return the flag of using the Tweezer pattern bool IsDrawingAsDotsPatternTweezer(const ENUM_TIMEFRAMES timeframe); //--- Return the flag of using the Piercing Line pattern bool IsDrawingAsDotsPatternPiercingLine(const ENUM_TIMEFRAMES timeframe); //--- Return the flag of using the Cloud Cover pattern bool IsDrawingAsDotsPatternDarkCloudCover(const ENUM_TIMEFRAMES timeframe); //--- Return the flag of using the Three White Soldiers pattern bool IsDrawingAsDotsPatternThreeWhiteSoldiers(const ENUM_TIMEFRAMES timeframe); //--- Return the flag of using the Three Black Crows pattern bool IsDrawingAsDotsPatternThreeBlackCrows(const ENUM_TIMEFRAMES timeframe); //--- Return the flag of using the Shooting Star pattern bool IsDrawingAsDotsPatternShootingStar(const ENUM_TIMEFRAMES timeframe); //--- Return the flag of using the Hammer pattern bool IsDrawingAsDotsPatternHammer(const ENUM_TIMEFRAMES timeframe); //--- Return the flag of using the Inverted Hammer pattern bool IsDrawingAsDotsPatternInvertedHammer(const ENUM_TIMEFRAMES timeframe); //--- Return the flag of using the Hanging Man pattern bool IsDrawingAsDotsPatternHangingMan(const ENUM_TIMEFRAMES timeframe); //--- Return the flag of using the Doji pattern bool IsDrawingAsDotsPatternDoji(const ENUM_TIMEFRAMES timeframe); //--- Return the flag of using the Dragonfly Doji pattern bool IsDrawingAsDotsPatternDragonflyDoji(const ENUM_TIMEFRAMES timeframe); //--- Return the flag of using the Gravestone Doji pattern bool IsDrawingAsDotsPatternGravestoneDoji(const ENUM_TIMEFRAMES timeframe); //--- Return the flag of using the Morning Star pattern bool IsDrawingAsDotsPatternMorningStar(const ENUM_TIMEFRAMES timeframe); //--- Return the flag of using the Morning Doji Star pattern bool IsDrawingAsDotsPatternMorningDojiStar(const ENUM_TIMEFRAMES timeframe); //--- Return the flag of using the Evening Star pattern bool IsDrawingAsDotsPatternEveningStar(const ENUM_TIMEFRAMES timeframe); //--- Return the flag of using the Evening Doji Star pattern bool IsDrawingAsDotsPatternEveningDojiStar(const ENUM_TIMEFRAMES timeframe); //--- Return the flag of using the Three Stars pattern bool IsDrawingAsDotsPatternThreeStars(const ENUM_TIMEFRAMES timeframe); //--- Return the flag of using the Abandoned Baby pattern bool IsDrawingAsDotsPatternAbandonedBaby(const ENUM_TIMEFRAMES timeframe); //--- Price Action //--- Return the flag of using the Pivot Point Reversal pattern bool IsDrawingAsDotsPatternPivotPointReversal(const ENUM_TIMEFRAMES timeframe); //--- Return the flag of using the Pattern Outside bool IsDrawingAsDotsPatternOutsideBar(const ENUM_TIMEFRAMES timeframe); //--- Return the flag of using the Inside Bar pattern bool IsDrawingAsDotsPatternInsideBar(const ENUM_TIMEFRAMES timeframe); //--- Return the flag of using the Pin Bar pattern bool IsDrawingAsDotsPatternPinBar(const ENUM_TIMEFRAMES timeframe,double ratio_body=30, // Percentage ratio of the candle body to the full size of the candle const double ratio_larger_shadow=60, // Percentage ratio of the size of the larger shadow to the size of the candle const double ratio_smaller_shadow=30); // Percentage ratio of the size of the smaller shadow to the size of the candle //--- Return the flag of using the Rails pattern bool IsDrawingAsDotsPatternRails(const ENUM_TIMEFRAMES timeframe); //+------------------------------------------------------------------+ //| Methods for drawing patterns on a chart | //+------------------------------------------------------------------+
Fora do corpo da classe, escreveremos a implementação dos métodos declarados:
//+------------------------------------------------------------------+ //| Methods for setting the flag of drawing the pattern using dots | //+------------------------------------------------------------------+ //--- Set the flag for drawing the Harami pattern with dots void CTimeSeriesDE::SetDrawingAsDotsPatternHarami(const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw) { CSeriesDE *series=this.GetSeries(timeframe); if(series!=NULL) series.SetDrawingAsDotsPatternHarami(flag,redraw); } //--- Set the flag for drawing the Harami Cross pattern with dots void CTimeSeriesDE::SetDrawingAsDotsPatternHaramiCross(const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw) { CSeriesDE *series=this.GetSeries(timeframe); if(series!=NULL) series.SetDrawingAsDotsPatternHaramiCross(flag,redraw); } //--- Set the flag for drawing the Tweezer pattern with dots void CTimeSeriesDE::SetDrawingAsDotsPatternTweezer(const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw) { CSeriesDE *series=this.GetSeries(timeframe); if(series!=NULL) series.SetDrawingAsDotsPatternTweezer(flag,redraw); } //--- Set the flag for drawing the Piercing Line pattern with dots void CTimeSeriesDE::SetDrawingAsDotsPatternPiercingLine(const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw) { CSeriesDE *series=this.GetSeries(timeframe); if(series!=NULL) series.SetDrawingAsDotsPatternPiercingLine(flag,redraw); } //--- Set the flag for drawing the Cloud Cover pattern with dots void CTimeSeriesDE::SetDrawingAsDotsPatternDarkCloudCover(const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw) { CSeriesDE *series=this.GetSeries(timeframe); if(series!=NULL) series.SetDrawingAsDotsPatternDarkCloudCover(flag,redraw); } //--- Set the flag for drawing the Three White Soldiers pattern with dots void CTimeSeriesDE::SetDrawingAsDotsPatternThreeWhiteSoldiers(const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw) { CSeriesDE *series=this.GetSeries(timeframe); if(series!=NULL) series.SetDrawingAsDotsPatternThreeWhiteSoldiers(flag,redraw); } //--- Set the flag for drawing the Three Black Crows pattern with dots void CTimeSeriesDE::SetDrawingAsDotsPatternThreeBlackCrows(const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw) { CSeriesDE *series=this.GetSeries(timeframe); if(series!=NULL) series.SetDrawingAsDotsPatternThreeBlackCrows(flag,redraw); } //--- Set the flag for drawing the Shooting Star pattern with dots void CTimeSeriesDE::SetDrawingAsDotsPatternShootingStar(const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw) { CSeriesDE *series=this.GetSeries(timeframe); if(series!=NULL) series.SetDrawingAsDotsPatternShootingStar(flag,redraw); } //--- Set the flag for drawing the Hammer pattern with dots void CTimeSeriesDE::SetDrawingAsDotsPatternHammer(const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw) { CSeriesDE *series=this.GetSeries(timeframe); if(series!=NULL) series.SetDrawingAsDotsPatternHammer(flag,redraw); } //--- Set the flag for drawing the Inverted Hammer pattern with dots void CTimeSeriesDE::SetDrawingAsDotsPatternInvertedHammer(const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw) { CSeriesDE *series=this.GetSeries(timeframe); if(series!=NULL) series.SetDrawingAsDotsPatternInvertedHammer(flag,redraw); } //--- Set the flag for drawing the Hanging Man pattern with dots void CTimeSeriesDE::SetDrawingAsDotsPatternHangingMan(const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw) { CSeriesDE *series=this.GetSeries(timeframe); if(series!=NULL) series.SetDrawingAsDotsPatternHangingMan(flag,redraw); } //--- Set the flag for drawing the Doji pattern with dots void CTimeSeriesDE::SetDrawingAsDotsPatternDoji(const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw) { CSeriesDE *series=this.GetSeries(timeframe); if(series!=NULL) series.SetDrawingAsDotsPatternDoji(flag,redraw); } //--- Set the flag for drawing the Dragonfly Doji pattern with dots void CTimeSeriesDE::SetDrawingAsDotsPatternDragonflyDoji(const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw) { CSeriesDE *series=this.GetSeries(timeframe); if(series!=NULL) series.SetDrawingAsDotsPatternDragonflyDoji(flag,redraw); } //--- Set the flag for drawing the Gravestone Doji pattern with dots void CTimeSeriesDE::SetDrawingAsDotsPatternGravestoneDoji(const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw) { CSeriesDE *series=this.GetSeries(timeframe); if(series!=NULL) series.SetDrawingAsDotsPatternGravestoneDoji(flag,redraw); } //--- Set the flag for drawing the Morning Star pattern with dots void CTimeSeriesDE::SetDrawingAsDotsPatternMorningStar(const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw) { CSeriesDE *series=this.GetSeries(timeframe); if(series!=NULL) series.SetDrawingAsDotsPatternMorningStar(flag,redraw); } //--- Set the flag for drawing the Morning Doji Star pattern with dots void CTimeSeriesDE::SetDrawingAsDotsPatternMorningDojiStar(const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw) { CSeriesDE *series=this.GetSeries(timeframe); if(series!=NULL) series.SetDrawingAsDotsPatternMorningDojiStar(flag,redraw); } //--- Set the flag for drawing the Evening Star pattern with dots void CTimeSeriesDE::SetDrawingAsDotsPatternEveningStar(const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw) { CSeriesDE *series=this.GetSeries(timeframe); if(series!=NULL) series.SetDrawingAsDotsPatternEveningStar(flag,redraw); } //--- Set the flag for drawing the Evening Doji Star pattern with dots void CTimeSeriesDE::SetDrawingAsDotsPatternEveningDojiStar(const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw) { CSeriesDE *series=this.GetSeries(timeframe); if(series!=NULL) series.SetDrawingAsDotsPatternEveningDojiStar(flag,redraw); } //--- Set the flag for drawing the Three Stars pattern with dots void CTimeSeriesDE::SetDrawingAsDotsPatternThreeStars(const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw) { CSeriesDE *series=this.GetSeries(timeframe); if(series!=NULL) series.SetDrawingAsDotsPatternThreeStars(flag,redraw); } //--- Set the flag for drawing the Abandoned Baby pattern with dots void CTimeSeriesDE::SetDrawingAsDotsPatternAbandonedBaby(const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw) { CSeriesDE *series=this.GetSeries(timeframe); if(series!=NULL) series.SetDrawingAsDotsPatternAbandonedBaby(flag,redraw); } //--- Set the flag for drawing the Pivot Point Reversal pattern with dots //--- Price Action void CTimeSeriesDE::SetDrawingAsDotsPatternPivotPointReversal(const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw) { CSeriesDE *series=this.GetSeries(timeframe); if(series!=NULL) series.SetDrawingAsDotsPatternPivotPointReversal(flag,redraw); } //--- Set the flag for drawing the Outside Bar pattern with dots void CTimeSeriesDE::SetDrawingAsDotsPatternOutsideBar(const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw) { CSeriesDE *series=this.GetSeries(timeframe); if(series!=NULL) series.SetDrawingAsDotsPatternOutsideBar(flag,redraw); } //--- Set the flag for drawing the Inside Bar pattern with dots void CTimeSeriesDE::SetDrawingAsDotsPatternInsideBar(const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw) { CSeriesDE *series=this.GetSeries(timeframe); if(series!=NULL) series.SetDrawingAsDotsPatternInsideBar(flag,redraw); } //--- Set the flag for drawing the Pin Bar pattern with dots void CTimeSeriesDE::SetDrawingAsDotsPatternPinBar(const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw, // Flag of drawing with dots and Pin Bar Price Action redraw flag const double ratio_body=30, // Percentage ratio of the candle body to the full size of the candle const double ratio_larger_shadow=60, // Percentage ratio of the size of the larger shadow to the size of the candle const double ratio_smaller_shadow=30) // Percentage ratio of the size of the smaller shadow to the size of the candle { CSeriesDE *series=this.GetSeries(timeframe); if(series!=NULL) series.SetDrawingAsDotsPatternPinBar(flag,redraw,ratio_body,ratio_larger_shadow,ratio_smaller_shadow); } //--- Set the flag for drawing the Rails pattern with dots void CTimeSeriesDE::SetDrawingAsDotsPatternRails(const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw) { CSeriesDE *series=this.GetSeries(timeframe); if(series!=NULL) series.SetDrawingAsDotsPatternRails(flag,redraw); } //+------------------------------------------------------------------+ //| Methods of returning the flag of drawing with dots | //+------------------------------------------------------------------+ //--- Candle formations //--- Return the flag for drawing the Harami pattern with dots bool CTimeSeriesDE::IsDrawingAsDotsPatternHarami(const ENUM_TIMEFRAMES timeframe) { CSeriesDE *series=this.GetSeries(timeframe); return(series!=NULL ? series.IsDrawingAsDotsPatternHarami() : false); } //--- Return the flag for drawing the Harami Cross pattern with dots bool CTimeSeriesDE::IsDrawingAsDotsPatternHaramiCross(const ENUM_TIMEFRAMES timeframe) { CSeriesDE *series=this.GetSeries(timeframe); return(series!=NULL ? series.IsDrawingAsDotsPatternHaramiCross() : false); } //--- Return the flag for drawing the Tweezer pattern with dots bool CTimeSeriesDE::IsDrawingAsDotsPatternTweezer(const ENUM_TIMEFRAMES timeframe) { CSeriesDE *series=this.GetSeries(timeframe); return(series!=NULL ? series.IsDrawingAsDotsPatternTweezer() : false); } //--- Return the flag for drawing the Piercing Line pattern with dots bool CTimeSeriesDE::IsDrawingAsDotsPatternPiercingLine(const ENUM_TIMEFRAMES timeframe) { CSeriesDE *series=this.GetSeries(timeframe); return(series!=NULL ? series.IsDrawingAsDotsPatternPiercingLine() : false); } //--- Return the flag for drawing the Cloud Cover pattern with dots bool CTimeSeriesDE::IsDrawingAsDotsPatternDarkCloudCover(const ENUM_TIMEFRAMES timeframe) { CSeriesDE *series=this.GetSeries(timeframe); return(series!=NULL ? series.IsDrawingAsDotsPatternDarkCloudCover() : false); } //--- Return the flag for drawing the Three White Soldiers pattern with dots bool CTimeSeriesDE::IsDrawingAsDotsPatternThreeWhiteSoldiers(const ENUM_TIMEFRAMES timeframe) { CSeriesDE *series=this.GetSeries(timeframe); return(series!=NULL ? series.IsDrawingAsDotsPatternThreeWhiteSoldiers() : false); } //--- Return the flag for drawing the Three Black Crows pattern with dots bool CTimeSeriesDE::IsDrawingAsDotsPatternThreeBlackCrows(const ENUM_TIMEFRAMES timeframe) { CSeriesDE *series=this.GetSeries(timeframe); return(series!=NULL ? series.IsDrawingAsDotsPatternThreeBlackCrows() : false); } //--- Return the flag for drawing the Shooting Star pattern with dots bool CTimeSeriesDE::IsDrawingAsDotsPatternShootingStar(const ENUM_TIMEFRAMES timeframe) { CSeriesDE *series=this.GetSeries(timeframe); return(series!=NULL ? series.IsDrawingAsDotsPatternShootingStar() : false); } //--- Return the flag for drawing the Hammer pattern with dots bool CTimeSeriesDE::IsDrawingAsDotsPatternHammer(const ENUM_TIMEFRAMES timeframe) { CSeriesDE *series=this.GetSeries(timeframe); return(series!=NULL ? series.IsDrawingAsDotsPatternHammer() : false); } //--- Return the flag for drawing the Inverted Hammer pattern with dots bool CTimeSeriesDE::IsDrawingAsDotsPatternInvertedHammer(const ENUM_TIMEFRAMES timeframe) { CSeriesDE *series=this.GetSeries(timeframe); return(series!=NULL ? series.IsDrawingAsDotsPatternInvertedHammer() : false); } //--- Return the flag for drawing the Hanging Man pattern with dots bool CTimeSeriesDE::IsDrawingAsDotsPatternHangingMan(const ENUM_TIMEFRAMES timeframe) { CSeriesDE *series=this.GetSeries(timeframe); return(series!=NULL ? series.IsDrawingAsDotsPatternHangingMan() : false); } //--- Return the flag for drawing the Doji pattern with dots bool CTimeSeriesDE::IsDrawingAsDotsPatternDoji(const ENUM_TIMEFRAMES timeframe) { CSeriesDE *series=this.GetSeries(timeframe); return(series!=NULL ? series.IsDrawingAsDotsPatternDoji() : false); } //--- Return the flag for drawing the Dragonfly Doji pattern with dots bool CTimeSeriesDE::IsDrawingAsDotsPatternDragonflyDoji(const ENUM_TIMEFRAMES timeframe) { CSeriesDE *series=this.GetSeries(timeframe); return(series!=NULL ? series.IsDrawingAsDotsPatternDragonflyDoji() : false); } //--- Return the flag for drawing the Gravestone Doji pattern with dots bool CTimeSeriesDE::IsDrawingAsDotsPatternGravestoneDoji(const ENUM_TIMEFRAMES timeframe) { CSeriesDE *series=this.GetSeries(timeframe); return(series!=NULL ? series.IsDrawingAsDotsPatternGravestoneDoji() : false); } //--- Return the flag for drawing the Morning Star pattern with dots bool CTimeSeriesDE::IsDrawingAsDotsPatternMorningStar(const ENUM_TIMEFRAMES timeframe) { CSeriesDE *series=this.GetSeries(timeframe); return(series!=NULL ? series.IsDrawingAsDotsPatternMorningStar() : false); } //--- Return the flag for drawing the Morning Doji Star pattern with dots bool CTimeSeriesDE::IsDrawingAsDotsPatternMorningDojiStar(const ENUM_TIMEFRAMES timeframe) { CSeriesDE *series=this.GetSeries(timeframe); return(series!=NULL ? series.IsDrawingAsDotsPatternMorningDojiStar() : false); } //--- Return the flag for drawing the Evening Star pattern with dots bool CTimeSeriesDE::IsDrawingAsDotsPatternEveningStar(const ENUM_TIMEFRAMES timeframe) { CSeriesDE *series=this.GetSeries(timeframe); return(series!=NULL ? series.IsDrawingAsDotsPatternEveningStar() : false); } //--- Return the flag for drawing the Evening Doji Star pattern with dots bool CTimeSeriesDE::IsDrawingAsDotsPatternEveningDojiStar(const ENUM_TIMEFRAMES timeframe) { CSeriesDE *series=this.GetSeries(timeframe); return(series!=NULL ? series.IsDrawingAsDotsPatternEveningDojiStar() : false); } //--- Return the flag for drawing the Three Stars pattern with dots bool CTimeSeriesDE::IsDrawingAsDotsPatternThreeStars(const ENUM_TIMEFRAMES timeframe) { CSeriesDE *series=this.GetSeries(timeframe); return(series!=NULL ? series.IsDrawingAsDotsPatternThreeStars() : false); } //--- Return the flag for drawing the Abandoned Baby pattern with dots bool CTimeSeriesDE::IsDrawingAsDotsPatternAbandonedBaby(const ENUM_TIMEFRAMES timeframe) { CSeriesDE *series=this.GetSeries(timeframe); return(series!=NULL ? series.IsDrawingAsDotsPatternAbandonedBaby() : false); } //--- Price Action //--- Return the flag for drawing the Pivot Point Reversal pattern with dots bool CTimeSeriesDE::IsDrawingAsDotsPatternPivotPointReversal(const ENUM_TIMEFRAMES timeframe) { CSeriesDE *series=this.GetSeries(timeframe); return(series!=NULL ? series.IsDrawingAsDotsPatternPivotPointReversal() : false); } //--- Return the flag for drawing the Outside Bar pattern with dots bool CTimeSeriesDE::IsDrawingAsDotsPatternOutsideBar(const ENUM_TIMEFRAMES timeframe) { CSeriesDE *series=this.GetSeries(timeframe); return(series!=NULL ? series.IsDrawingAsDotsPatternOutsideBar() : false); } //--- Return the flag for drawing the Inside Bar pattern with dots bool CTimeSeriesDE::IsDrawingAsDotsPatternInsideBar(const ENUM_TIMEFRAMES timeframe) { CSeriesDE *series=this.GetSeries(timeframe); return(series!=NULL ? series.IsDrawingAsDotsPatternInsideBar() : false); } //--- Return the flag for drawing the Pin Bar pattern with dots bool CTimeSeriesDE::IsDrawingAsDotsPatternPinBar(const ENUM_TIMEFRAMES timeframe,const double ratio_body=30, // Percentage ratio of the candle body to the full size of the candle const double ratio_larger_shadow=60, // Percentage ratio of the size of the larger shadow to the size of the candle const double ratio_smaller_shadow=30) // Percentage ratio of the size of the smaller shadow to the size of the candle { CSeriesDE *series=this.GetSeries(timeframe); return(series!=NULL ? series.IsDrawingAsDotsPatternPinBar(ratio_body,ratio_larger_shadow,ratio_smaller_shadow) : false); } //--- Return the flag for drawing the Rails pattern with dots bool CTimeSeriesDE::IsDrawingAsDotsPatternRails(const ENUM_TIMEFRAMES timeframe) { CSeriesDE *series=this.GetSeries(timeframe); return(series!=NULL ? series.IsDrawingAsDotsPatternRails() : false); }
Em artigos futuros, faremos o acompanhamento dos parâmetros do gráfico para redefinir as propriedades do gráfico nos objetos das séries temporais usadas para desenhar os ícones dos padrões. Todas as propriedades de todos os gráficos abertos no terminal estão contidas na coleção de gráficos da biblioteca. Para podermos acessar os dados dessa coleção a partir da coleção de séries temporais de todos os símbolos, precisamos passar um ponteiro para a coleção de gráficos para a coleção de séries temporais.
Para isso, no arquivo da coleção de séries temporais de símbolos \MQL5\Include\DoEasy\CollectionsTimeSeriesCollection.mqh, conectaremos o arquivo da coleção de gráficos e na seção privada, declararemos um ponteiro para a coleção de gráficos:
//+------------------------------------------------------------------+ //| Include files | //+------------------------------------------------------------------+ #include "ListObj.mqh" #include "..\Objects\Series\TimeSeriesDE.mqh" #include "..\Objects\Symbols\Symbol.mqh" #include "ChartObjCollection.mqh" //+------------------------------------------------------------------+ //| Symbol timeseries collection | //+------------------------------------------------------------------+ class CTimeSeriesCollection : public CBaseObjExt { private: CListObj m_list; // List of applied symbol timeseries CListObj m_list_all_patterns; // List of all patterns of all used symbol timeseries CChartObjCollection *m_charts; // Pointer to the chart collection //--- Return the timeseries index by symbol name int IndexTimeSeries(const string symbol); public:
Na seção pública da classe, na parte dos métodos para trabalhar com padrões de séries temporais, declararemos novos métodos:
//+------------------------------------------------------------------+ //| Methods for setting the flag of drawing the pattern using dots | //+------------------------------------------------------------------+ //--- Set the flag for using the Harami pattern and create a control object if it does not already exist void SetDrawingAsDotsPatternHarami(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw); //--- Set the flag for using the Harami Cross pattern and create a control object if it does not already exist void SetDrawingAsDotsPatternHaramiCross(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw); //--- Set the flag for using the Tweezer pattern and create a control object if it does not already exist void SetDrawingAsDotsPatternTweezer(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw); //--- Set the flag for using the Piercing Line pattern and create a control object if it does not already exist void SetDrawingAsDotsPatternPiercingLine(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw); //--- Set the flag for using the Cloud Cover pattern and create a control object if it does not already exist void SetDrawingAsDotsPatternDarkCloudCover(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw); //--- Set the flag for using the Three White Soldiers pattern and create a control object if it does not already exist void SetDrawingAsDotsPatternThreeWhiteSoldiers(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw); //--- Set the flag for using the Three Black Crows pattern and create a control object if it does not already exist void SetDrawingAsDotsPatternThreeBlackCrows(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw); //--- Set the flag for using the Shooting Star pattern and create a control object if it does not already exist void SetDrawingAsDotsPatternShootingStar(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw); //--- Set the flag for using the Hammer pattern and create a control object if it does not already exist void SetDrawingAsDotsPatternHammer(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw); //--- Set the flag for using the Inverted Hammer pattern and create a control object if it does not already exist void SetDrawingAsDotsPatternInvertedHammer(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw); //--- Set the flag for using the Hanging Man pattern and create a control object if it does not already exist void SetDrawingAsDotsPatternHangingMan(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw); //--- Set the flag for using the Doji pattern and create a control object if it does not already exist void SetDrawingAsDotsPatternDoji(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw); //--- Set the flag for using the Dragonfly Doji pattern and create a control object if it does not already exist void SetDrawingAsDotsPatternDragonflyDoji(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw); //--- Set the flag for using the Doji Gravestone pattern and create a control object if it does not already exist void SetDrawingAsDotsPatternGravestoneDoji(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw); //--- Set the flag for using the Morning Star pattern and create a control object if it does not already exist void SetDrawingAsDotsPatternMorningStar(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw); //--- Set the flag for using the Morning Doji Star pattern and create a control object if it does not already exist void SetDrawingAsDotsPatternMorningDojiStar(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw); //--- Set the flag for using the Evening Star pattern and create a control object if it does not already exist void SetDrawingAsDotsPatternEveningStar(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw); //--- Set the flag for using the Evening Doji Star pattern and create a control object if it does not already exist void SetDrawingAsDotsPatternEveningDojiStar(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw); //--- Set the flag for using the Three Stars pattern and create a control object if it does not already exist void SetDrawingAsDotsPatternThreeStars(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw); //--- Set the flag for using the Abandoned Baby pattern and create a control object if it does not already exist void SetDrawingAsDotsPatternAbandonedBaby(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw); //--- Set the flag for using the Pivot Point Reversal pattern and create a control object if it does not already exist //--- Price Action void SetDrawingAsDotsPatternPivotPointReversal(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw); //--- Set the flag for using the Pattern Outside and create a control object if it does not already exist void SetDrawingAsDotsPatternOutsideBar(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw); //--- Set the flag for using the Pattern Inside and create a control object if it does not already exist void SetDrawingAsDotsPatternInsideBar(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw); //--- Set the flag for using the Pin Bar pattern and create a control object if it does not already exist void SetDrawingAsDotsPatternPinBar(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw, // Flag of drawing with dots and Pin Bar Price Action redraw flag const double ratio_body=30, // Percentage ratio of the candle body to the full size of the candle const double ratio_larger_shadow=60, // Percentage ratio of the size of the larger shadow to the size of the candle const double ratio_smaller_shadow=30); // Percentage ratio of the size of the smaller shadow to the size of the candle //--- Set the flag for using the Rails pattern and create a control object if it does not already exist void SetDrawingAsDotsPatternRails(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw); //+------------------------------------------------------------------+ //| Methods of returning the flag of drawing with dots | //+------------------------------------------------------------------+ //--- Candle formations //--- Return the flag of using the Harami pattern bool IsDrawingAsDotsPatternHarami(const string symbol,const ENUM_TIMEFRAMES timeframe); //--- Return the flag of using the Harami Cross pattern bool IsDrawingAsDotsPatternHaramiCross(const string symbol,const ENUM_TIMEFRAMES timeframe); //--- Return the flag of using the Tweezer pattern bool IsDrawingAsDotsPatternTweezer(const string symbol,const ENUM_TIMEFRAMES timeframe); //--- Return the flag of using the Piercing Line pattern bool IsDrawingAsDotsPatternPiercingLine(const string symbol,const ENUM_TIMEFRAMES timeframe); //--- Return the flag of using the Cloud Cover pattern bool IsDrawingAsDotsPatternDarkCloudCover(const string symbol,const ENUM_TIMEFRAMES timeframe); //--- Return the flag of using the Three White Soldiers pattern bool IsDrawingAsDotsPatternThreeWhiteSoldiers(const string symbol,const ENUM_TIMEFRAMES timeframe); //--- Return the flag of using the Three Black Crows pattern bool IsDrawingAsDotsPatternThreeBlackCrows(const string symbol,const ENUM_TIMEFRAMES timeframe); //--- Return the flag of using the Shooting Star pattern bool IsDrawingAsDotsPatternShootingStar(const string symbol,const ENUM_TIMEFRAMES timeframe); //--- Return the flag of using the Hammer pattern bool IsDrawingAsDotsPatternHammer(const string symbol,const ENUM_TIMEFRAMES timeframe); //--- Return the flag of using the Inverted Hammer pattern bool IsDrawingAsDotsPatternInvertedHammer(const string symbol,const ENUM_TIMEFRAMES timeframe); //--- Return the flag of using the Hanging Man pattern bool IsDrawingAsDotsPatternHangingMan(const string symbol,const ENUM_TIMEFRAMES timeframe); //--- Return the flag of using the Doji pattern bool IsDrawingAsDotsPatternDoji(const string symbol,const ENUM_TIMEFRAMES timeframe); //--- Return the flag of using the Dragonfly Doji pattern bool IsDrawingAsDotsPatternDragonflyDoji(const string symbol,const ENUM_TIMEFRAMES timeframe); //--- Return the flag of using the Gravestone Doji pattern bool IsDrawingAsDotsPatternGravestoneDoji(const string symbol,const ENUM_TIMEFRAMES timeframe); //--- Return the flag of using the Morning Star pattern bool IsDrawingAsDotsPatternMorningStar(const string symbol,const ENUM_TIMEFRAMES timeframe); //--- Return the flag of using the Morning Doji Star pattern bool IsDrawingAsDotsPatternMorningDojiStar(const string symbol,const ENUM_TIMEFRAMES timeframe); //--- Return the flag of using the Evening Star pattern bool IsDrawingAsDotsPatternEveningStar(const string symbol,const ENUM_TIMEFRAMES timeframe); //--- Return the flag of using the Evening Doji Star pattern bool IsDrawingAsDotsPatternEveningDojiStar(const string symbol,const ENUM_TIMEFRAMES timeframe); //--- Return the flag of using the Three Stars pattern bool IsDrawingAsDotsPatternThreeStars(const string symbol,const ENUM_TIMEFRAMES timeframe); //--- Return the flag of using the Abandoned Baby pattern bool IsDrawingAsDotsPatternAbandonedBaby(const string symbol,const ENUM_TIMEFRAMES timeframe); //--- Price Action //--- Return the flag of using the Pivot Point Reversal pattern bool IsDrawingAsDotsPatternPivotPointReversal(const string symbol,const ENUM_TIMEFRAMES timeframe); //--- Return the flag of using the Pattern Outside bool IsDrawingAsDotsPatternOutsideBar(const string symbol,const ENUM_TIMEFRAMES timeframe); //--- Return the flag of using the Inside Bar pattern bool IsDrawingAsDotsPatternInsideBar(const string symbol,const ENUM_TIMEFRAMES timeframe); //--- Return the flag of using the Pin Bar pattern bool IsDrawingAsDotsPatternPinBar(const string symbol,const ENUM_TIMEFRAMES timeframe,double ratio_body=30, // Percentage ratio of the candle body to the full size of the candle const double ratio_larger_shadow=60, // Percentage ratio of the size of the larger shadow to the size of the candle const double ratio_smaller_shadow=30); // Percentage ratio of the size of the smaller shadow to the size of the candle //--- Return the flag of using the Rails pattern bool IsDrawingAsDotsPatternRails(const string symbol,const ENUM_TIMEFRAMES timeframe);
No final do corpo da classe, escreveremos um método de inicialização, no qual o ponteiro para a coleção de gráficos, declarado acima, é atribuído ao ponteiro passado para o método:
//--- Draw Rails pattern labels on the chart void DrawPatternRails(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool redraw=false); //--- Initialization void OnInit(CChartObjCollection *charts) { this.m_charts=charts; } //--- Constructor CTimeSeriesCollection(void); };
Fora do corpo da classe, escreveremos a implementação dos métodos para trabalhar com padrões de séries temporais, declarados acima:
//+------------------------------------------------------------------+ //| Methods for setting the flag of drawing the pattern using dots | //+------------------------------------------------------------------+ //+------------------------------------------------------------------+ //| Set the flag for drawing the Harami pattern with dots | //+------------------------------------------------------------------+ void CTimeSeriesCollection::SetDrawingAsDotsPatternHarami(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw) { CTimeSeriesDE *timeseries=this.GetTimeseries(symbol); if(timeseries!=NULL) timeseries.SetDrawingAsDotsPatternHarami(timeframe,flag,redraw); } //+------------------------------------------------------------------+ //| Set the flag for drawing the Harami Cross pattern with dots | //+------------------------------------------------------------------+ void CTimeSeriesCollection::SetDrawingAsDotsPatternHaramiCross(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw) { CTimeSeriesDE *timeseries=this.GetTimeseries(symbol); if(timeseries!=NULL) timeseries.SetDrawingAsDotsPatternHaramiCross(timeframe,flag,redraw); } //+------------------------------------------------------------------+ //| Set the flag for drawing the Tweezer pattern with dots | //+------------------------------------------------------------------+ void CTimeSeriesCollection::SetDrawingAsDotsPatternTweezer(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw) { CTimeSeriesDE *timeseries=this.GetTimeseries(symbol); if(timeseries!=NULL) timeseries.SetDrawingAsDotsPatternTweezer(timeframe,flag,redraw); } //+------------------------------------------------------------------+ //| Set the flag for drawing the Piercing Line pattern with dots | //+------------------------------------------------------------------+ void CTimeSeriesCollection::SetDrawingAsDotsPatternPiercingLine(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw) { CTimeSeriesDE *timeseries=this.GetTimeseries(symbol); if(timeseries!=NULL) timeseries.SetDrawingAsDotsPatternPiercingLine(timeframe,flag,redraw); } //+----------------------------------------------------------------------+ //|Set the flag for drawing the Cloud Cover pattern with dots | //+----------------------------------------------------------------------+ void CTimeSeriesCollection::SetDrawingAsDotsPatternDarkCloudCover(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw) { CTimeSeriesDE *timeseries=this.GetTimeseries(symbol); if(timeseries!=NULL) timeseries.SetDrawingAsDotsPatternDarkCloudCover(timeframe,flag,redraw); } //+--------------------------------------------------------------------+ //| Set the flag for drawing the Three White Soldiers pattern with dots| //+--------------------------------------------------------------------+ void CTimeSeriesCollection::SetDrawingAsDotsPatternThreeWhiteSoldiers(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw) { CTimeSeriesDE *timeseries=this.GetTimeseries(symbol); if(timeseries!=NULL) timeseries.SetDrawingAsDotsPatternThreeWhiteSoldiers(timeframe,flag,redraw); } //+------------------------------------------------------------------+ //| Set the flag for drawing the Three Black Crows pattern with dots | //+------------------------------------------------------------------+ void CTimeSeriesCollection::SetDrawingAsDotsPatternThreeBlackCrows(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw) { CTimeSeriesDE *timeseries=this.GetTimeseries(symbol); if(timeseries!=NULL) timeseries.SetDrawingAsDotsPatternThreeBlackCrows(timeframe,flag,redraw); } //+------------------------------------------------------------------+ //| Set the flag for drawing the Shooting Star pattern with dots | //+------------------------------------------------------------------+ void CTimeSeriesCollection::SetDrawingAsDotsPatternShootingStar(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw) { CTimeSeriesDE *timeseries=this.GetTimeseries(symbol); if(timeseries!=NULL) timeseries.SetDrawingAsDotsPatternShootingStar(timeframe,flag,redraw); } //+------------------------------------------------------------------+ //| Set the flag for drawing the Hammer pattern with dots | //+------------------------------------------------------------------+ void CTimeSeriesCollection::SetDrawingAsDotsPatternHammer(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw) { CTimeSeriesDE *timeseries=this.GetTimeseries(symbol); if(timeseries!=NULL) timeseries.SetDrawingAsDotsPatternHammer(timeframe,flag,redraw); } //+------------------------------------------------------------------+ //| Set the flag for drawing the Inverted Hammer pattern with dots | //+------------------------------------------------------------------+ void CTimeSeriesCollection::SetDrawingAsDotsPatternInvertedHammer(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw) { CTimeSeriesDE *timeseries=this.GetTimeseries(symbol); if(timeseries!=NULL) timeseries.SetDrawingAsDotsPatternInvertedHammer(timeframe,flag,redraw); } //+------------------------------------------------------------------+ //| Set the flag for drawing the Hanging Man pattern with dots | //+------------------------------------------------------------------+ void CTimeSeriesCollection::SetDrawingAsDotsPatternHangingMan(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw) { CTimeSeriesDE *timeseries=this.GetTimeseries(symbol); if(timeseries!=NULL) timeseries.SetDrawingAsDotsPatternHangingMan(timeframe,flag,redraw); } //+------------------------------------------------------------------+ //| Set the flag for drawing the Doji pattern with dots | //+------------------------------------------------------------------+ void CTimeSeriesCollection::SetDrawingAsDotsPatternDoji(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw) { CTimeSeriesDE *timeseries=this.GetTimeseries(symbol); if(timeseries!=NULL) timeseries.SetDrawingAsDotsPatternDoji(timeframe,flag,redraw); } //+------------------------------------------------------------------+ //| Set the flag for drawing the Dragonfly Doji pattern with dots | //+------------------------------------------------------------------+ void CTimeSeriesCollection::SetDrawingAsDotsPatternDragonflyDoji(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw) { CTimeSeriesDE *timeseries=this.GetTimeseries(symbol); if(timeseries!=NULL) timeseries.SetDrawingAsDotsPatternDragonflyDoji(timeframe,flag,redraw); } //+------------------------------------------------------------------+ //| Set the flag for drawing the Gravestone Doji pattern with dots | //+------------------------------------------------------------------+ void CTimeSeriesCollection::SetDrawingAsDotsPatternGravestoneDoji(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw) { CTimeSeriesDE *timeseries=this.GetTimeseries(symbol); if(timeseries!=NULL) timeseries.SetDrawingAsDotsPatternGravestoneDoji(timeframe,flag,redraw); } //+------------------------------------------------------------------+ //| Set the flag for drawing the Morning Star pattern with dots | //+------------------------------------------------------------------+ void CTimeSeriesCollection::SetDrawingAsDotsPatternMorningStar(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw) { CTimeSeriesDE *timeseries=this.GetTimeseries(symbol); if(timeseries!=NULL) timeseries.SetDrawingAsDotsPatternMorningStar(timeframe,flag,redraw); } //+-------------------------------------------------------------------+ //|Set the flag for drawing the Morning Doji Star pattern with dots | //+-------------------------------------------------------------------+ void CTimeSeriesCollection::SetDrawingAsDotsPatternMorningDojiStar(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw) { CTimeSeriesDE *timeseries=this.GetTimeseries(symbol); if(timeseries!=NULL) timeseries.SetDrawingAsDotsPatternMorningDojiStar(timeframe,flag,redraw); } //+------------------------------------------------------------------+ //| Set the flag for drawing the Evening Star pattern with dots | //+------------------------------------------------------------------+ void CTimeSeriesCollection::SetDrawingAsDotsPatternEveningStar(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw) { CTimeSeriesDE *timeseries=this.GetTimeseries(symbol); if(timeseries!=NULL) timeseries.SetDrawingAsDotsPatternEveningStar(timeframe,flag,redraw); } //+-------------------------------------------------------------------+ //|Set the flag for drawing the Evening Doji Star pattern with dots | //+-------------------------------------------------------------------+ void CTimeSeriesCollection::SetDrawingAsDotsPatternEveningDojiStar(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw) { CTimeSeriesDE *timeseries=this.GetTimeseries(symbol); if(timeseries!=NULL) timeseries.SetDrawingAsDotsPatternEveningDojiStar(timeframe,flag,redraw); } //+------------------------------------------------------------------+ //| Set the flag for drawing the Three Stars pattern with dots | //+------------------------------------------------------------------+ void CTimeSeriesCollection::SetDrawingAsDotsPatternThreeStars(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw) { CTimeSeriesDE *timeseries=this.GetTimeseries(symbol); if(timeseries!=NULL) timeseries.SetDrawingAsDotsPatternThreeStars(timeframe,flag,redraw); } //+------------------------------------------------------------------+ //| Set the flag for drawing the Abandoned Baby pattern with dots | //+------------------------------------------------------------------+ void CTimeSeriesCollection::SetDrawingAsDotsPatternAbandonedBaby(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw) { CTimeSeriesDE *timeseries=this.GetTimeseries(symbol); if(timeseries!=NULL) timeseries.SetDrawingAsDotsPatternAbandonedBaby(timeframe,flag,redraw); } //--- Price Action //+-------------------------------------------------------------------+ //|Set the flag for drawing the Pivot Point Reversal pattern with dots| //+-------------------------------------------------------------------+ void CTimeSeriesCollection::SetDrawingAsDotsPatternPivotPointReversal(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw) { CTimeSeriesDE *timeseries=this.GetTimeseries(symbol); if(timeseries!=NULL) timeseries.SetDrawingAsDotsPatternPivotPointReversal(timeframe,flag,redraw); } //+----------------------------------------------------------------------+ //|Set the flag for drawing the Outside Bar pattern with dots | //+----------------------------------------------------------------------+ void CTimeSeriesCollection::SetDrawingAsDotsPatternOutsideBar(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw) { CTimeSeriesDE *timeseries=this.GetTimeseries(symbol); if(timeseries!=NULL) timeseries.SetDrawingAsDotsPatternOutsideBar(timeframe,flag,redraw); } //+------------------------------------------------------------------+ //| Set the flag for drawing the Inside Bar pattern with dots | //+------------------------------------------------------------------+ void CTimeSeriesCollection::SetDrawingAsDotsPatternInsideBar(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw) { CTimeSeriesDE *timeseries=this.GetTimeseries(symbol); if(timeseries!=NULL) timeseries.SetDrawingAsDotsPatternInsideBar(timeframe,flag,redraw); } //+------------------------------------------------------------------+ //| Set the flag for drawing the Pin Bar pattern with dots | //+------------------------------------------------------------------+ void CTimeSeriesCollection::SetDrawingAsDotsPatternPinBar(const string symbol,const ENUM_TIMEFRAMES timeframe, const bool flag,const bool redraw, // Flag of drawing with dots and Pin Bar Price Action redraw flag const double ratio_body=30, // Percentage ratio of the candle body to the full size of the candle const double ratio_larger_shadow=60, // Percentage ratio of the size of the larger shadow to the size of the candle const double ratio_smaller_shadow=30) // Percentage ratio of the size of the smaller shadow to the size of the candle { CTimeSeriesDE *timeseries=this.GetTimeseries(symbol); if(timeseries!=NULL) timeseries.SetDrawingAsDotsPatternPinBar(timeframe,flag,redraw,ratio_body,ratio_larger_shadow,ratio_smaller_shadow); } //+------------------------------------------------------------------+ //| Set the flag for drawing the Rails pattern with dots | //+------------------------------------------------------------------+ void CTimeSeriesCollection::SetDrawingAsDotsPatternRails(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw) { CTimeSeriesDE *timeseries=this.GetTimeseries(symbol); if(timeseries!=NULL) timeseries.SetDrawingAsDotsPatternRails(timeframe,flag,redraw); } //+------------------------------------------------------------------+ //+------------------------------------------------------------------+ //| Methods of returning the flag of drawing with dots | //+------------------------------------------------------------------+ //--- Candle formations //+------------------------------------------------------------------+ //| Return the flag for drawing the Harami pattern with dots | //+------------------------------------------------------------------+ bool CTimeSeriesCollection::IsDrawingAsDotsPatternHarami(const string symbol,const ENUM_TIMEFRAMES timeframe) { CTimeSeriesDE *timeseries=this.GetTimeseries(symbol); return(timeseries!=NULL ? timeseries.IsDrawingAsDotsPatternHarami(timeframe) : false); } //+------------------------------------------------------------------+ //| Return the flag for drawing the Harami Cross pattern with dots | //+------------------------------------------------------------------+ bool CTimeSeriesCollection::IsDrawingAsDotsPatternHaramiCross(const string symbol,const ENUM_TIMEFRAMES timeframe) { CTimeSeriesDE *timeseries=this.GetTimeseries(symbol); return(timeseries!=NULL ? timeseries.IsDrawingAsDotsPatternHaramiCross(timeframe) : false); } //+------------------------------------------------------------------+ //| Return the flag for drawing the Tweezer pattern with dots | //+------------------------------------------------------------------+ bool CTimeSeriesCollection::IsDrawingAsDotsPatternTweezer(const string symbol,const ENUM_TIMEFRAMES timeframe) { CTimeSeriesDE *timeseries=this.GetTimeseries(symbol); return(timeseries!=NULL ? timeseries.IsDrawingAsDotsPatternTweezer(timeframe) : false); } //+------------------------------------------------------------------+ //| Return the flag for drawing the Piercing Line pattern with dots | //+------------------------------------------------------------------+ bool CTimeSeriesCollection::IsDrawingAsDotsPatternPiercingLine(const string symbol,const ENUM_TIMEFRAMES timeframe) { CTimeSeriesDE *timeseries=this.GetTimeseries(symbol); return(timeseries!=NULL ? timeseries.IsDrawingAsDotsPatternPiercingLine(timeframe) : false); } //+-------------------------------------------------------------------+ //|Return the flag for drawing the Cloud Cover pattern with dots | //+-------------------------------------------------------------------+ bool CTimeSeriesCollection::IsDrawingAsDotsPatternDarkCloudCover(const string symbol,const ENUM_TIMEFRAMES timeframe) { CTimeSeriesDE *timeseries=this.GetTimeseries(symbol); return(timeseries!=NULL ? timeseries.IsDrawingAsDotsPatternDarkCloudCover(timeframe) : false); } //+-----------------------------------------------------------------------+ //| Return the flag for drawing the Three White Soldiers pattern with dots| //+-----------------------------------------------------------------------+ bool CTimeSeriesCollection::IsDrawingAsDotsPatternThreeWhiteSoldiers(const string symbol,const ENUM_TIMEFRAMES timeframe) { CTimeSeriesDE *timeseries=this.GetTimeseries(symbol); return(timeseries!=NULL ? timeseries.IsDrawingAsDotsPatternThreeWhiteSoldiers(timeframe) : false); } //+--------------------------------------------------------------------+ //| Return the flag for drawing the Three Black Crows pattern with dots| //+--------------------------------------------------------------------+ bool CTimeSeriesCollection::IsDrawingAsDotsPatternThreeBlackCrows(const string symbol,const ENUM_TIMEFRAMES timeframe) { CTimeSeriesDE *timeseries=this.GetTimeseries(symbol); return(timeseries!=NULL ? timeseries.IsDrawingAsDotsPatternThreeBlackCrows(timeframe) : false); } //+------------------------------------------------------------------+ //| Return the flag for drawing the Shooting Star pattern with dots | //+------------------------------------------------------------------+ bool CTimeSeriesCollection::IsDrawingAsDotsPatternShootingStar(const string symbol,const ENUM_TIMEFRAMES timeframe) { CTimeSeriesDE *timeseries=this.GetTimeseries(symbol); return(timeseries!=NULL ? timeseries.IsDrawingAsDotsPatternShootingStar(timeframe) : false); } //+------------------------------------------------------------------+ //| Return the flag for drawing the Hammer pattern with dots | //+------------------------------------------------------------------+ bool CTimeSeriesCollection::IsDrawingAsDotsPatternHammer(const string symbol,const ENUM_TIMEFRAMES timeframe) { CTimeSeriesDE *timeseries=this.GetTimeseries(symbol); return(timeseries!=NULL ? timeseries.IsDrawingAsDotsPatternHammer(timeframe) : false); } //+------------------------------------------------------------------+ //| Return the flag for drawing the Inverted Hammer pattern with dots| //+------------------------------------------------------------------+ bool CTimeSeriesCollection::IsDrawingAsDotsPatternInvertedHammer(const string symbol,const ENUM_TIMEFRAMES timeframe) { CTimeSeriesDE *timeseries=this.GetTimeseries(symbol); return(timeseries!=NULL ? timeseries.IsDrawingAsDotsPatternInvertedHammer(timeframe) : false); } //+------------------------------------------------------------------+ //| Return the flag for drawing the Hanging Man pattern with dots | //+------------------------------------------------------------------+ bool CTimeSeriesCollection::IsDrawingAsDotsPatternHangingMan(const string symbol,const ENUM_TIMEFRAMES timeframe) { CTimeSeriesDE *timeseries=this.GetTimeseries(symbol); return(timeseries!=NULL ? timeseries.IsDrawingAsDotsPatternHangingMan(timeframe) : false); } //+------------------------------------------------------------------+ //| Return the flag for drawing the Doji pattern with dots | //+------------------------------------------------------------------+ bool CTimeSeriesCollection::IsDrawingAsDotsPatternDoji(const string symbol,const ENUM_TIMEFRAMES timeframe) { CTimeSeriesDE *timeseries=this.GetTimeseries(symbol); return(timeseries!=NULL ? timeseries.IsDrawingAsDotsPatternDoji(timeframe) : false); } //+------------------------------------------------------------------+ //| Return the flag for drawing the Dragonfly Doji pattern with dots | //+------------------------------------------------------------------+ bool CTimeSeriesCollection::IsDrawingAsDotsPatternDragonflyDoji(const string symbol,const ENUM_TIMEFRAMES timeframe) { CTimeSeriesDE *timeseries=this.GetTimeseries(symbol); return(timeseries!=NULL ? timeseries.IsDrawingAsDotsPatternDragonflyDoji(timeframe) : false); } //+------------------------------------------------------------------+ //| Return the flag for drawing the Gravestone Doji pattern with dots| //+------------------------------------------------------------------+ bool CTimeSeriesCollection::IsDrawingAsDotsPatternGravestoneDoji(const string symbol,const ENUM_TIMEFRAMES timeframe) { CTimeSeriesDE *timeseries=this.GetTimeseries(symbol); return(timeseries!=NULL ? timeseries.IsDrawingAsDotsPatternGravestoneDoji(timeframe) : false); } //+------------------------------------------------------------------+ //| Return the flag for drawing the Morning Star pattern with dots | //+------------------------------------------------------------------+ bool CTimeSeriesCollection::IsDrawingAsDotsPatternMorningStar(const string symbol,const ENUM_TIMEFRAMES timeframe) { CTimeSeriesDE *timeseries=this.GetTimeseries(symbol); return(timeseries!=NULL ? timeseries.IsDrawingAsDotsPatternMorningStar(timeframe) : false); } //+---------------------------------------------------------------------+ //| Return the flag for drawing the Morning Doji Star pattern with dots | //+---------------------------------------------------------------------+ bool CTimeSeriesCollection::IsDrawingAsDotsPatternMorningDojiStar(const string symbol,const ENUM_TIMEFRAMES timeframe) { CTimeSeriesDE *timeseries=this.GetTimeseries(symbol); return(timeseries!=NULL ? timeseries.IsDrawingAsDotsPatternMorningDojiStar(timeframe) : false); } //+------------------------------------------------------------------+ //| Return the flag for drawing the Evening Star pattern with dots | //+------------------------------------------------------------------+ bool CTimeSeriesCollection::IsDrawingAsDotsPatternEveningStar(const string symbol,const ENUM_TIMEFRAMES timeframe) { CTimeSeriesDE *timeseries=this.GetTimeseries(symbol); return(timeseries!=NULL ? timeseries.IsDrawingAsDotsPatternEveningStar(timeframe) : false); } //+---------------------------------------------------------------------+ //| Return the flag for drawing the Evening Doji Star pattern with dots | //+---------------------------------------------------------------------+ bool CTimeSeriesCollection::IsDrawingAsDotsPatternEveningDojiStar(const string symbol,const ENUM_TIMEFRAMES timeframe) { CTimeSeriesDE *timeseries=this.GetTimeseries(symbol); return(timeseries!=NULL ? timeseries.IsDrawingAsDotsPatternEveningDojiStar(timeframe) : false); } //+------------------------------------------------------------------+ //| Return the flag for drawing the Three Stars pattern with dots | //+------------------------------------------------------------------+ bool CTimeSeriesCollection::IsDrawingAsDotsPatternThreeStars(const string symbol,const ENUM_TIMEFRAMES timeframe) { CTimeSeriesDE *timeseries=this.GetTimeseries(symbol); return(timeseries!=NULL ? timeseries.IsDrawingAsDotsPatternThreeStars(timeframe) : false); } //+------------------------------------------------------------------+ //| Return the flag for drawing the Abandoned Baby pattern with dots | //+------------------------------------------------------------------+ bool CTimeSeriesCollection::IsDrawingAsDotsPatternAbandonedBaby(const string symbol,const ENUM_TIMEFRAMES timeframe) { CTimeSeriesDE *timeseries=this.GetTimeseries(symbol); return(timeseries!=NULL ? timeseries.IsDrawingAsDotsPatternAbandonedBaby(timeframe) : false); } //--- Price Action //+-------------------------------------------------------------------------+ //| Return the flag for drawing the Pivot Point Reversal pattern with dots | //+-------------------------------------------------------------------------+ bool CTimeSeriesCollection::IsDrawingAsDotsPatternPivotPointReversal(const string symbol,const ENUM_TIMEFRAMES timeframe) { CTimeSeriesDE *timeseries=this.GetTimeseries(symbol); return(timeseries!=NULL ? timeseries.IsDrawingAsDotsPatternPivotPointReversal(timeframe) : false); } //+-------------------------------------------------------------------+ //|Return the flag for drawing the Outside Bar pattern with dots | //+-------------------------------------------------------------------+ bool CTimeSeriesCollection::IsDrawingAsDotsPatternOutsideBar(const string symbol,const ENUM_TIMEFRAMES timeframe) { CTimeSeriesDE *timeseries=this.GetTimeseries(symbol); return(timeseries!=NULL ? timeseries.IsDrawingAsDotsPatternOutsideBar(timeframe) : false); } //+------------------------------------------------------------------+ //| Return the flag for drawing the Inside Bar pattern with dots | //+------------------------------------------------------------------+ bool CTimeSeriesCollection::IsDrawingAsDotsPatternInsideBar(const string symbol,const ENUM_TIMEFRAMES timeframe) { CTimeSeriesDE *timeseries=this.GetTimeseries(symbol); return(timeseries!=NULL ? timeseries.IsDrawingAsDotsPatternInsideBar(timeframe) : false); } //+------------------------------------------------------------------+ //| Return the flag for drawing the Pin Bar pattern with dots | //+------------------------------------------------------------------+ bool CTimeSeriesCollection::IsDrawingAsDotsPatternPinBar(const string symbol,const ENUM_TIMEFRAMES timeframe, const double ratio_body=30, // Percentage ratio of the candle body to the full size of the candle const double ratio_larger_shadow=60, // Percentage ratio of the size of the larger shadow to the size of the candle const double ratio_smaller_shadow=30) // Percentage ratio of the size of the smaller shadow to the size of the candle { CTimeSeriesDE *timeseries=this.GetTimeseries(symbol); return(timeseries!=NULL ? timeseries.IsDrawingAsDotsPatternPinBar(timeframe,ratio_body,ratio_larger_shadow,ratio_smaller_shadow) : false); } //+------------------------------------------------------------------+ //| Return the flag for drawing the Rails pattern with dots | //+------------------------------------------------------------------+ bool CTimeSeriesCollection::IsDrawingAsDotsPatternRails(const string symbol,const ENUM_TIMEFRAMES timeframe) { CTimeSeriesDE *timeseries=this.GetTimeseries(symbol); return(timeseries!=NULL ? timeseries.IsDrawingAsDotsPatternRails(timeframe) : false); }
No artigo anterior foram criados métodos semelhantes, que foram discutidos em mais detalhes. Basicamente, obtemos um ponteiro para a série temporal desejada do símbolo e retornamos o resultado da execução do método homônimo da série temporal obtida. Por sua vez, o ponteiro para a série temporal do período do gráfico é obtido da mesma forma, a partir da qual o método que retorna o ponteiro para o objeto de controle de padrões da série temporal é chamado, e desse objeto, o método de controle correspondente é chamado — tudo em cadeia até obter o resultado necessário. A estrutura é aninhada e inconveniente em termos de volume de códigos idênticos. Posteriormente, tentaremos encurtá-la, organizando o acesso aos objetos necessários de outra forma.
Devemos fazer o mesmo com a classe principal da biblioteca, CEngine, no arquivo \MT5\MQL5\Include\DoEasyEngine.mqh.
Em todos os métodos de trabalho com padrões, substituímos essas ou outras linhas de parâmetros de entrada
CArrayObj *list=this.GetListPatterns(symbol,timeframe); por estas:
CArrayObj *list=this.GetListPatterns(CorrectSymbol(symbol),CorrectTimeframe(timeframe)); Aqui, substituímos os valores de símbolo e período do gráfico, passados como parâmetros do método, pelas funções de correção desses parâmetros, escritas no início do artigo.
Na seção de métodos para trabalhar com padrões, escreveremos novos métodos para trabalhar com a flag de desenho dos padrões como pontos:
//--- Set the flag for using the Rails pattern and create a control object if it does not already exist void SeriesSetUsedPatternRails(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag) { this.m_time_series.SetUsedPatternRails(CorrectSymbol(symbol),CorrectTimeframe(timeframe),flag); } //--- Set the flag for drawing the Harami pattern with dots void SeriesSetDrawingAsDotsPatternHarami(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw=false) { this.m_time_series.SetDrawingAsDotsPatternHarami(CorrectSymbol(symbol),CorrectTimeframe(timeframe),flag,redraw); } //--- Set the flag for drawing the Harami Cross pattern with dots void SeriesSetDrawingAsDotsPatternHaramiCross(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw=false) { this.m_time_series.SetDrawingAsDotsPatternHaramiCross(CorrectSymbol(symbol),CorrectTimeframe(timeframe),flag,redraw); } //--- Set the flag for drawing the Tweezer pattern with dots void SeriesSetDrawingAsDotsPatternTweezer(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw=false) { this.m_time_series.SetDrawingAsDotsPatternTweezer(CorrectSymbol(symbol),CorrectTimeframe(timeframe),flag,redraw); } //--- Set the flag for drawing the Piercing Line pattern with dots void SeriesSetDrawingAsDotsPatternPiercingLine(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw=false) { this.m_time_series.SetDrawingAsDotsPatternPiercingLine(CorrectSymbol(symbol),CorrectTimeframe(timeframe),flag,redraw); } //--- Set the flag for drawing the Cloud Cover pattern with dots void SeriesSetDrawingAsDotsPatternDarkCloudCover(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw=false) { this.m_time_series.SetDrawingAsDotsPatternDarkCloudCover(CorrectSymbol(symbol),CorrectTimeframe(timeframe),flag,redraw); } //--- Set the flag for drawing the Three White Soldiers pattern with dots void SeriesSetDrawingAsDotsPatternThreeWhiteSoldiers(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw=false) { this.m_time_series.SetDrawingAsDotsPatternThreeWhiteSoldiers(CorrectSymbol(symbol),CorrectTimeframe(timeframe),flag,redraw); } //--- Set the flag for drawing the Three Black Crows pattern with dots void SeriesSetDrawingAsDotsPatternThreeBlackCrows(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw=false) { this.m_time_series.SetDrawingAsDotsPatternThreeBlackCrows(CorrectSymbol(symbol),CorrectTimeframe(timeframe),flag,redraw); } //--- Set the flag for drawing the Shooting Star pattern with dots void SeriesSetDrawingAsDotsPatternShootingStar(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw=false) { this.m_time_series.SetDrawingAsDotsPatternShootingStar(CorrectSymbol(symbol),CorrectTimeframe(timeframe),flag,redraw); } //--- Set the flag for drawing the Hammer pattern with dots void SeriesSetDrawingAsDotsPatternHammer(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw=false) { this.m_time_series.SetDrawingAsDotsPatternHammer(CorrectSymbol(symbol),CorrectTimeframe(timeframe),flag,redraw); } //--- Set the flag for drawing the Inverted Hammer pattern with dots void SeriesSetDrawingAsDotsPatternInvertedHammer(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw=false) { this.m_time_series.SetDrawingAsDotsPatternInvertedHammer(CorrectSymbol(symbol),CorrectTimeframe(timeframe),flag,redraw); } //--- Set the flag for drawing the Hanging Man pattern with dots void SeriesSetDrawingAsDotsPatternHangingMan(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw=false) { this.m_time_series.SetDrawingAsDotsPatternHangingMan(CorrectSymbol(symbol),CorrectTimeframe(timeframe),flag,redraw); } //--- Set the flag for drawing the Doji pattern with dots void SeriesSetDrawingAsDotsPatternDoji(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw=false) { this.m_time_series.SetDrawingAsDotsPatternDoji(CorrectSymbol(symbol),CorrectTimeframe(timeframe),flag,redraw); } //--- Set the flag for drawing the Dragonfly Doji pattern with dots void SeriesSetDrawingAsDotsPatternDragonflyDoji(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw=false) { this.m_time_series.SetDrawingAsDotsPatternDragonflyDoji(CorrectSymbol(symbol),CorrectTimeframe(timeframe),flag,redraw); } //--- Set the flag for drawing the Gravestone Doji pattern with dots void SeriesSetDrawingAsDotsPatternGravestoneDoji(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw=false) { this.m_time_series.SetDrawingAsDotsPatternGravestoneDoji(CorrectSymbol(symbol),CorrectTimeframe(timeframe),flag,redraw); } //--- Set the flag for drawing the Morning Star pattern with dots void SeriesSetDrawingAsDotsPatternMorningStar(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw=false) { this.m_time_series.SetDrawingAsDotsPatternMorningStar(CorrectSymbol(symbol),CorrectTimeframe(timeframe),flag,redraw); } //--- Set the flag for drawing the Morning Doji Star pattern with dots void SeriesSetDrawingAsDotsPatternMorningDojiStar(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw=false) { this.m_time_series.SetDrawingAsDotsPatternMorningDojiStar(CorrectSymbol(symbol),CorrectTimeframe(timeframe),flag,redraw); } //--- Set the flag for drawing the Evening Star pattern with dots void SeriesSetDrawingAsDotsPatternEveningStar(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw=false) { this.m_time_series.SetDrawingAsDotsPatternEveningStar(CorrectSymbol(symbol),CorrectTimeframe(timeframe),flag,redraw); } //--- Set the flag for drawing the Evening Doji Star pattern with dots void SeriesSetDrawingAsDotsPatternEveningDojiStar(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw=false) { this.m_time_series.SetDrawingAsDotsPatternEveningDojiStar(CorrectSymbol(symbol),CorrectTimeframe(timeframe),flag,redraw); } //--- Set the flag for drawing the Three Stars pattern with dots void SeriesSetDrawingAsDotsPatternThreeStars(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw=false) { this.m_time_series.SetDrawingAsDotsPatternThreeStars(CorrectSymbol(symbol),CorrectTimeframe(timeframe),flag,redraw); } //--- Set the flag for drawing the Abandoned Baby pattern with dots void SeriesSetDrawingAsDotsPatternAbandonedBaby(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw=false) { this.m_time_series.SetDrawingAsDotsPatternAbandonedBaby(CorrectSymbol(symbol),CorrectTimeframe(timeframe),flag,redraw); } //--- Set the flag for drawing the Pivot Point Reversal pattern with dots //--- Price Action void SeriesSetDrawingAsDotsPatternPivotPointReversal(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw=false) { this.m_time_series.SetDrawingAsDotsPatternPivotPointReversal(CorrectSymbol(symbol),CorrectTimeframe(timeframe),flag,redraw); } //--- Set the flag for drawing the Outside Bar pattern with dots void SeriesSetDrawingAsDotsPatternOutsideBar(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw=false) { this.m_time_series.SetDrawingAsDotsPatternOutsideBar(CorrectSymbol(symbol),CorrectTimeframe(timeframe),flag,redraw); } //--- Set the flag for drawing the Inside Bar pattern with dots void SeriesSetDrawingAsDotsPatternInsideBar(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw=false) { this.m_time_series.SetDrawingAsDotsPatternInsideBar(CorrectSymbol(symbol),CorrectTimeframe(timeframe),flag,redraw); } //--- Set the flag for drawing the Pin Bar pattern with dots void SeriesSetDrawingAsDotsPatternPinBar(const string symbol,const ENUM_TIMEFRAMES timeframe, const bool flag,const bool redraw=false, // Flag of drawing with dots and Pin Bar Price Action redraw flag const double ratio_body=30, // Percentage ratio of the candle body to the full size of the candle const double ratio_larger_shadow=60, // Percentage ratio of the size of the larger shadow to the size of the candle const double ratio_smaller_shadow=30) // Percentage ratio of the size of the smaller shadow to the size of the candle { this.m_time_series.SetDrawingAsDotsPatternPinBar(CorrectSymbol(symbol),CorrectTimeframe(timeframe),flag,redraw,ratio_body,ratio_larger_shadow,ratio_smaller_shadow); } //--- Set the flag for drawing the Rails pattern with dots void SeriesSetDrawingAsDotsPatternRails(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool flag,const bool redraw=false) { this.m_time_series.SetDrawingAsDotsPatternRails(CorrectSymbol(symbol),CorrectTimeframe(timeframe),flag,redraw); } //--- Draw Harami pattern labels on the chart void SeriesDrawPatternHarami(const string symbol,const ENUM_TIMEFRAMES timeframe,const bool redraw=false) { this.m_time_series.DrawPatternHarami(CorrectSymbol(symbol),CorrectTimeframe(timeframe),redraw); }
Os métodos chamam os métodos correspondentes da classe-coleção de séries temporais escritos acima.
Na mesma seção, escreveremos um método que oculta os painéis de informações de todos os padrões, exceto os que estão no tempo especificado da barra:
//--- Hides info panels of all patterns except the specified one void SeriesPatternHideAllInfoPanelsExceptOne(const ulong pattern_code,const bool redraw=false) { CArrayObj *list=CSelect::ByPatternProperty(this.GetListAllPatterns(),PATTERN_PROP_CODE,pattern_code,NO_EQUAL); if(list==NULL) return; for(int i=list.Total()-1;i>=0;i--) { CPattern *obj=list.At(i); if(obj!=NULL) obj.HideInfoPanel(); } if(redraw) ::ChartRedraw(); } //--- Hide info panels of all patterns except those at the specified time of the bar void SeriesPatternHideAllInfoPanelsExceptBarTime(const datetime bar_time,const bool redraw=false) { CArrayObj *list=CSelect::ByPatternProperty(this.GetListAllPatterns(),PATTERN_PROP_TIME,bar_time,NO_EQUAL); if(list==NULL) return; for(int i=list.Total()-1;i>=0;i--) { CPattern *obj=list.At(i); if(obj!=NULL) obj.HideInfoPanel(); } if(redraw) ::ChartRedraw(); }
Aqui: obtemos da lista de todos os padrões, apenas aqueles que não estão na barra com o horário de abertura especificado. Em seguida, no loop pela lista obtida, obtemos um ponteiro para cada objeto-padrão e ocultamos seu painel de informações. Após o ciclo, se a flag de redesenho estiver ativada, o gráfico é redesenhado.
No método que passa para a classe de trading e para a classe-coleção de buffers de indicadores os ponteiros para todas as coleções necessárias, adicionamos a passagem para a coleção de séries temporaisdo ponteiro para a coleção de gráficos:
//--- Play a sound by its description bool PlaySoundByDescription(const string sound_description); //--- Pass the pointers to all the necessary collections to the trading class and the indicator buffer collection class void CollectionOnInit(void) { this.m_trading.OnInit(this.GetAccountCurrent(),this.m_symbols.GetObject(),this.m_market.GetObject(),this.m_history.GetObject(),this.m_events.GetObject()); this.m_buffers.OnInit(this.m_time_series.GetObject(),this.m_indicators.GetObject()); this.m_time_series.OnInit(this.GetChartObjCollection()); } //--- Set the spread multiplier for symbol trading objects in the symbol collection void SetSpreadMultiplier(const uint value=1,const string symbol=NULL) { this.m_trading.SetSpreadMultiplier(value,symbol); }
No manipulador de eventos da biblioteca DoEasy, criamos um esboço para processar os eventos da coleção de gráficos:
//--- Handling market watch window events else if(idx>MARKET_WATCH_EVENT_NO_EVENT && idx<SYMBOL_EVENTS_NEXT_CODE) { //--- Market Watch window event string descr=this.GetMWEventDescription((ENUM_MW_EVENT)idx); string name=(idx==MARKET_WATCH_EVENT_SYMBOL_SORT ? "" : ": "+sparam); Print(TimeMSCtoString(lparam)," ",descr,name); } //--- Handle chart events else if(idx>CHART_OBJ_EVENT_NO_EVENT && idx<CHART_OBJ_EVENTS_NEXT_CODE) { } //--- Handling timeseries events else if(idx>SERIES_EVENTS_NO_EVENT && idx<SERIES_EVENTS_NEXT_CODE) {
Posteriormente, incluiremos aqui os manipuladores de alteração de tamanho do gráfico e a passagem de novos valores para a coleção de séries temporais e, a partir dela, para os objetos-padrões.
Agora, tudo está pronto para testar o que conseguimos.Testes
Para os testes, pegaremos o EA da última matéria e o salvaremos em uma nova pasta \MQL5\Experts\TestDoEasyPart135 com um novo nome TestDoEasy135.mq5.
Na lista de variáveis de entrada, adicionaremos uma variável que define a flag de desenho dos padrões como pontos:
//--- input variables input ushort InpMagic = 123; // Magic number input double InpLots = 0.1; // Lots input uint InpStopLoss = 150; // StopLoss in points input uint InpTakeProfit = 150; // TakeProfit in points input uint InpDistance = 50; // Pending orders distance (points) input uint InpDistanceSL = 50; // StopLimit orders distance (points) input uint InpDistancePReq = 50; // Distance for Pending Request's activate (points) input uint InpBarsDelayPReq = 5; // Bars delay for Pending Request's activate (current timeframe) input uint InpSlippage = 5; // Slippage in points input uint InpSpreadMultiplier = 1; // Spread multiplier for adjusting stop-orders by StopLevel input uchar InpTotalAttempts = 5; // Number of trading attempts sinput double InpWithdrawal = 10; // Withdrawal funds (in tester) sinput uint InpButtShiftX = 0; // Buttons X shift sinput uint InpButtShiftY = 10; // Buttons Y shift input uint InpTrailingStop = 50; // Trailing Stop (points) input uint InpTrailingStep = 20; // Trailing Step (points) input uint InpTrailingStart = 0; // Trailing Start (points) input uint InpStopLossModify = 20; // StopLoss for modification (points) input uint InpTakeProfitModify = 60; // TakeProfit for modification (points) sinput ENUM_SYMBOLS_MODE InpModeUsedSymbols = SYMBOLS_MODE_CURRENT; // Mode of used symbols list sinput string InpUsedSymbols = "EURUSD,AUDUSD,EURAUD,EURCAD,EURGBP,EURJPY,EURUSD,GBPUSD,NZDUSD,USDCAD,USDJPY"; // List of used symbols (comma - separator) sinput ENUM_TIMEFRAMES_MODE InpModeUsedTFs = TIMEFRAMES_MODE_CURRENT; // Mode of used timeframes list sinput string InpUsedTFs = "M1,M5,M15,M30,H1,H4,D1,W1,MN1"; // List of used timeframes (comma - separator) sinput double InpPinBarRatioBody = 30.0; // Pin Bar Ratio Body to Candle size sinput double InpPinBarRatioLarger = 60.0; // Pin Bar Ratio Larger shadow to Candle size sinput double InpPinBarRatioSmaller= 30.0; // Pin Bar Ratio Smaller shadow to Candle size sinput bool InpDrawPatternsAsDots= true; // Draw Patterns as dots sinput ENUM_INPUT_YES_NO InpUseBook = INPUT_NO; // Use Depth of Market sinput ENUM_INPUT_YES_NO InpUseMqlSignals = INPUT_NO; // Use signal service sinput ENUM_INPUT_YES_NO InpUseCharts = INPUT_NO; // Use Charts control sinput ENUM_INPUT_YES_NO InpUseSounds = INPUT_YES; // Use sounds //--- global variables
Quando o valor for true, todos os padrões encontrados serão desenhados como pontos no gráfico. Quando o valor for false, os padrões "Barra Interna" serão desenhados como objetos Bitmap — as barras dos padrões serão contornadas com retângulos coloridos.
No manipulador OnInit() do EA, configuraremos a busca e exibição dos padrões:
//--- Clear the list of all patterns engine.GetListAllPatterns().Clear(); //--- Set the flag of using the Pin Bar pattern with the parameters specified in the settings engine.SeriesSetUsedPatternPinBar(NULL,PERIOD_CURRENT,true,InpPinBarRatioBody,InpPinBarRatioLarger,InpPinBarRatioSmaller); //--- Set the flag of using the Inside Bar pattern engine.SeriesSetUsedPatternInsideBar(NULL,PERIOD_CURRENT,true); //--- Set the flag for drawing the Inside Bar as dots from the inputs engine.SeriesSetDrawingAsDotsPatternInsideBar(NULL,PERIOD_CURRENT,InpDrawPatternsAsDots); //--- Display the Pin Bar pattern icons with the parameters, specified in the settings, on the chart engine.SeriesDrawPatternPinBar(NULL,PERIOD_CURRENT,InpPinBarRatioBody,InpPinBarRatioLarger,InpPinBarRatioSmaller); //--- Display the Inside Bar pattern icons on the chart engine.SeriesDrawPatternInsideBar(NULL,PERIOD_CURRENT,true); //--- return(INIT_SUCCEEDED); }
No manipulador OnChartEvent() do EA, escreveremos este bloco de código para exibir os painéis de informações dos padrões:
//--- Check ChartXYToTimePrice() if(id==CHARTEVENT_MOUSE_MOVE) { //--- Get the chart object of the current (main) program chart CChartObj *chart=engine.ChartGetMainChart(); if(chart==NULL) return; //--- Get the index of a subwindow the cursor is located at int wnd_num=chart.XYToTimePrice(lparam,dparam); if(wnd_num==WRONG_VALUE) return; //--- Get the calculated cursor location time and price datetime time=chart.TimeFromXY(); double price=chart.PriceFromXY(); //--- Get the window object of the chart the cursor is located in by the subwindow index CChartWnd *wnd=chart.GetWindowByNum(wnd_num); if(wnd==NULL) return; //--- If X and Y coordinates are calculated by time and price (make a reverse conversion), if(wnd.TimePriceToXY(time,price)) { //--- in the comment, show the time, price and index of the window that are calculated by X and Y cursor coordinates, //--- as well as the cursor X and Y coordinates converted back from the time and price //Comment // ( // DFUN,"time: ",TimeToString(time),", price: ",DoubleToString(price,Digits()), // ", win num: ",(string)wnd_num,": x: ",(string)wnd.XFromTimePrice(), // ", y: ",(string)wnd.YFromTimePrice()," (",(string)wnd.YFromTimePriceRelative(),")" // ); //--- Get the bar open time on the chart using the cursor time datetime bar_time=GetStartTimeOfBarFast(PERIOD_CURRENT,time); //--- Get the pointer to the bar whose opening time was obtained CBar *bar=engine.SeriesGetBar(Symbol(),PERIOD_CURRENT,bar_time); if(bar!=NULL && price>=bar.Low() && price<=bar.High()) { //--- From the bar object, get the list of patterns found in it into the 'array' ulong array[]={}; int total=bar.GetPatternsList(array); //--- If patterns are found on the bar, if(total>0) { //--- display descriptions of all patterns found on the bar in the journal bar.PatternTypeDescriptionPrint(true); //--- In the loop based on the number of patterns found on the bar, for(int i=0;i<(int)array.Size();i++) { //--- get the type of the next pattern from the 'array', as well as the pointer to it ENUM_PATTERN_TYPE type=(ENUM_PATTERN_TYPE)array[i]; CPattern *pattern=engine.GetPattern(Symbol(),PERIOD_CURRENT,bar_time,type); //--- Print a short description of the pattern in the journal if(pattern==NULL) continue; pattern.PrintShort(true); //pattern.Print(false,true); //--- Get the chart coordinates where you want to display the information panel int x=wnd.XFromTimePrice(); int y=wnd.YFromTimePrice(); //--- Hide all panels except those belonging to patterns found on the bar under the cursor engine.SeriesPatternHideAllInfoPanelsExceptBarTime(bar_time); //--- calculate the Y coordinate of the information panel from the loop index static int shift=0; int cy=y+shift*i; //--- Display the information panel on the chart pattern.ShowInfoPanel(x,cy); CForm *form=pattern.GetForm(); //--- If the pointer to the panel is received, calculate the size of the Y coordinate offset (panel height + 1) if(form!=NULL) shift=form.Height()+1; } } } } }
A lógica do código está descrita nos comentários. Precisamos obter o horário de abertura da barra sobre a qual o cursor do mouse está posicionado. Com base no horário de abertura, obtemos o objeto-barra, e a partir dele "extraímos" a lista de padrões encontrados nele.
Em seguida, simplesmente exibimos os painéis de informações de cada padrão encontrado na tela.
Compilamos o EA e o executamos no gráfico:
Como podemos ver, tudo funciona conforme o esperado. O desenho dos padrões como objetos gráficos apresenta algumas pequenas latências. Vamos resolver isso.
No centro da tela, vemos um padrão aninhado. Quando o cursor do mouse é posicionado sobre ele e o painel de informações aparece, é exibido o número total de barras que compõem a cadeia de padrões.
No lado direito da tela, em uma barra, foram formados dois padrões — "Pin Bar" e "Barra Interna", e os painéis de informações de ambos os padrões são exibidos um sobre o outro.
Próximos passos
No próximo artigo, continuaremos a desenvolver novos padrões para séries temporais.
Todos os arquivos criados estão anexados ao artigo e podem ser baixados para estudo e teste autônomo.
Traduzido do russo pela MetaQuotes Ltd.
Artigo original: https://www.mql5.com/ru/articles/14479
Arquivos anexados |
MQL5.zip
(9582.12 KB)
Aviso: Todos os direitos sobre esses materiais pertencem à MetaQuotes Ltd. É proibida a reimpressão total ou parcial.
Ir para discussão
Do básico ao intermediário: Passagem por valor ou por referência
Neste artigo você entenderá na prática a diferença entre passagem por valor e passagem por referência. Apesar de ser algo aparentemente simples e que não causa problemas. Muitos programadores com uma boa carga de experiência costumam tomar verdadeiras surras de seus códigos, justamente por conta deste pequeno detalhe. Saber quando, como e porque usar uma passagem por valor ou uma passagem por referência, fará grande diferença na sua vida como programador. O conteúdo exposto aqui, visa e tem como objetivo, pura e simplesmente a didática. De modo algum deve ser encarado como sendo, uma aplicação cuja finalidade não venha a ser o aprendizado e estudo dos conceitos mostrados.
Desenvolvendo um sistema de Replay (Parte 60): Dando play no serviço (I)
Já faz um bom tempo que estamos mexendo apenas no indicadores. Mas agora chegou a hora de fazer o serviço voltar a executar o seu trabalho, a fim de que possamos ver o gráfico sendo construído com os dados informados. Mas como nem tudo é tão simples, será preciso ver para entender o que nos espera.
Está chegando o novo MetaTrader 5 e MQL5
Esta é apenas uma breve resenha do MetaTrader 5. Eu não posso descrever todos os novos recursos do sistema por um período tão curto de tempo - os testes começaram em 09.09.2009. Esta é uma data simbólica, e tenho certeza que será um número de sorte. Alguns dias passaram-se desde que eu obtive a versão beta do terminal MetaTrader 5 e MQL5. Eu ainda não consegui testar todos os seus recursos, mas já estou impressionado.
Importância da qualidade do gerador de números aleatórios no desempenho dos algoritmos de otimização
Neste artigo, analisaremos o gerador de números aleatórios Mersenne Twister e o compararemos com o gerador padrão do MQL5. Veremos como a qualidade dos geradores de números aleatórios influencia os resultados dos algoritmos de otimização.
Você está perdendo oportunidades de negociação:
- Aplicativos de negociação gratuitos
- 8 000+ sinais para cópia
- Notícias econômicas para análise dos mercados financeiros
Registro
Login
Você concorda com a política do site e com os termos de uso
Se você não tem uma conta, por favor registre-se