Referência MQL5Funções de ObjetoTextSetFont

TextSetFont

A função define a fonte para exibir o texto usando métodos de desenho e retorna o resultado dessa operação. Fonte Arial com o tamanho -120 (12 pt) é usado por padrão.

bool  TextSetFont(
   const string  name,            // nome da fonte ou caminho para o arquivo da fonte no disco
   int           size,            // tamanho da fonte
   uint          flags,           // combinação de sinalizadores
   int           orientation=0    // ângulo de inclinação do texto
   );

Parâmetros

name

[in] Nome da fonte no sistema ou o nome do recurso contendo a fonte ou o caminho ao arquivo da fonte no disco.

size

[in] O tamanho da fonte, que pode ser definida usando valores positivos e negativos. No caso de valores negativos, o valor é definido em décimos de um ponto e o tamanho do texto depende das configurações do sistema operacional ("escala padrão" ou "grande escala"). No caso de valores negativos, o valor é definido em décimos de um ponto e o tamanho do texto depende das configurações do sistema operacional ("escala padrão" ou "grande escala"). Veja a Nota abaixo para mais informações sobre as diferenças entre os modos.

flags

[in] Combinação de sinalizadores descrevendo o estilo da fonte.

orientation

[in] Inclinação horizontal do texto em relação ao eixo X, a unidade de medida é 0,1 grau. Isso significa que orientação=450 está para inclinação igual a 45 graus.

Valor de retorno

Retorna verdadeiro se a fonte atual é instalado com êxito, caso contrário é falso. Possibilidade de erros de códigos:

ERR_INVALID_PARAMETER(4003) - name apresenta NULL ou"" (string vazia),
ERR_INTERNAL_ERROR(4001) - erro de sistema operacional (por exemplo, uma tentativa de criar uma fonte inexistente).

Observação

Se "::" é usado em nome da fonte, a fonte é baixada do recurso EX5. Se name nome da fonte é especificado com uma extensão, a fonte é baixada do arquivo, se o caminho começa com "\" ou "/", o arquivo é procurado em relação ao diretório MQL5. Caso contrário, ele é procurado em relação ao caminho do arquivo EX5 que chamou a função TextSetFont().

O tamanho da fonte é definido usando valores positivos ou negativos. Esse fato define a dependência do tamanho do texto a partir das configurações do sistema operacional (escala de tamanho).

Se o tamanho é especificado por um número positivo, este tamanho é transformado em unidades de medidas físicas de um dispositivo (pixels) quando se muda de uma fonte lógica para uma física, e este tamanho corresponde à altura dos símbolos glifos escolhidos entre as fontes disponíveis. Este caso não é recomendado quando os textos exibidos pela função TextOut() e os exibidos pelo OBJ_LABEL ("Etiquetas"), onde objetos gráfico estão a ser utilizados em conjunto no gráfico.
Se o tamanho é determinado por um número negativo, este número deve ser definido em décimos de um ponto lógico (-350 é igual a 35 pontos lógicos) dividido em 10. Um valor obtido é então transformado em unidades de medidas físicas de um dispositivo (pixels) e corresponde ao valor absoluto da altura de um símbolo escolhido a partir das fontes disponíveis. Multiplicar o do tamanho de fonte determinada nas propriedades do objeto por -10 para tornar o tamanho de um texto na tela semelhante ao de um objeto OBJ_LABEL.

Os sinalizadores podem ser usados com a combinação de sinalizadores de estilo com um dos sinalizadores especificando a largura da fonte. Nome dos sinalizadores são mostrados abaixo.

Sinalizadores para especificar o estilo da fonte

Flag	Description
FONT_ITALIC	Itálico
FONT_UNDERLINE	Sublinhado
FONT_STRIKEOUT	Riscado

Sinalizadores para especificar a largura da fonte

Flag
FW_DONTCARE
FW_THIN
FW_EXTRALIGHT
FW_ULTRALIGHT
FW_LIGHT
FW_NORMAL
FW_REGULAR
FW_MEDIUM
FW_SEMIBOLD
FW_DEMIBOLD
FW_BOLD
FW_EXTRABOLD
FW_ULTRABOLD
FW_HEAVY
FW_BLACK

Exemplo:

#property copyright "Copyright 2025, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"

#define   COORD_X    200
#define   COORD_Y    100
#define   OBJ_NAME   "TestTextGetSizeBitmapLabel"
#define   RES_NAME   "TestTextGetSizeResource"
#define   COLOR_NULL 0x00FFFFFF
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- identificador do gráfico atual
   long   chart_id= ChartID();

   string font_names[] ={"Arial", "Tahoma", "Calibri"};
   uint   flags_array[]={0, FONT_ITALIC, FONT_UNDERLINE, FONT_STRIKEOUT};
   uint   fw_array[]={FW_DONTCARE, FW_THIN, FW_EXTRALIGHT, FW_ULTRALIGHT, FW_LIGHT,
                      FW_NORMAL, FW_REGULAR, FW_MEDIUM, FW_SEMIBOLD, FW_DEMIBOLD,
                      FW_BOLD, FW_EXTRABOLD, FW_ULTRABOLD, FW_HEAVY, FW_BLACK};

//--- desativaremos a renderização de quaisquer atributos do gráfico de preços
   ChartSetInteger(chart_id, CHART_SHOW, false);

//--- declaramos os parâmetros do recurso gráfico
   uint rc_width =(int)ChartGetInteger(chart_id, CHART_WIDTH_IN_PIXELS);
   uint rc_height=(int)ChartGetInteger(chart_id, CHART_HEIGHT_IN_PIXELS);
   uint rc_data[];
   uint rc_size=rc_width*rc_height;

//--- criamos um recurso gráfico para saída de texto
   if(!CreateResource(chart_id, rc_data, rc_width, rc_height))
      return;

//--- laço sobre os nomes de fontes
   for(int i=0; i<(int)font_names.Size(); i++)
     {
      //--- laço sobre os flags da fonte
      for(int j=0; j<(int)flags_array.Size(); j++)
        {
         //--- desenhamos o texto com a fonte obtida do array e o flag de estilo
         DrawText(font_names[i], flags_array[j], rc_data, rc_width, rc_height);
         Sleep(800);
         ArrayInitialize(rc_data, COLOR_NULL);
        }
      Sleep(800);
      ArrayInitialize(rc_data, COLOR_NULL);
     }

//--- após exibir todos os textos com diferentes tamanhos e estilos de fonte,
//--- mostraremos texto com diferentes flags de espessura da fonte
   for(int i=0; i<(int)fw_array.Size(); i++)
     {
      //--- configuramos o tamanho e o nome da fonte para exibir o texto com os flags de espessura
      string font_name="Tahoma";
      int    size=-140;
      TextSetFont(font_name, size, fw_array[i]);

      //--- criamos a string de texto a ser desenhada, a enviamos para o array de pixels do recurso e atualizamos o recurso
      string text=StringFormat("Text%d: Font name: \"%s%s\", size: %d (%d)", i+1, font_name, FlagWidthDescription(fw_array[i]), size, size/-10);
      TextOut(text, COORD_X, COORD_Y, ANCHOR_LEFT_UPPER, rc_data, rc_width, rc_height, ColorToARGB(clrDodgerBlue), COLOR_FORMAT_ARGB_NORMALIZE);
      Update(RES_NAME, rc_data, rc_width, rc_height, true);
      //--- aguardamos um segundo
      Sleep(1000);
      ArrayInitialize(rc_data, COLOR_NULL);
     }

//--- aguardamos cinco segundos, depois liberamos o recurso e removemos o objeto gráfico
   Sleep(5000);
   ResourceFree(RES_NAME);
   ObjectDelete(chart_id, OBJ_NAME);

//--- permitiremos a renderização de quaisquer atributos do gráfico de preços
   ChartSetInteger(chart_id, CHART_SHOW, true);
   ChartRedraw(chart_id);
   /*
   em resultado da execução do script, mensagens de texto serão exibidas no gráfico
   com fontes diferentes, em tamanhos distintos e com flags de estilo e de espessura do texto4
   */
  }
//+------------------------------------------------------------------+
//| Exibe no gráfico cinco linhas de texto diferentes                |
//| em tamanhos com a fonte e flags indicados                        |
//+------------------------------------------------------------------+
void DrawText(const string font_name, uint flags, uint &pixels_array[], uint res_width, uint res_height)
  {
//--- exibiremos cinco linhas de texto com tamanhos de fonte diferentes
   for(int i=0; i<5; i++)
     {
      //--- calculamos o tamanho da fonte e configuramos a fonte para saída de texto pelos métodos de desenho
      int size=-140+10*i;
      TextSetFont(font_name, size, flags);

      //--- criamos a string de texto a ser desenhada, a enviamos para o array de pixels do recurso e atualizamos o recurso
      string text=StringFormat("Text%d: Font name: \"%s%s\", size: %d (%d)", i+1, font_name, FlagDescription(flags), size, size/-10);
      TextOut(text, COORD_X, COORD_Y+22*i, ANCHOR_LEFT_UPPER, pixels_array, res_width, res_height, ColorToARGB(clrDodgerBlue), COLOR_FORMAT_ARGB_NORMALIZE);
      Update(RES_NAME, pixels_array, res_width, res_height, true);
      //--- aguardamos um pouco
      Sleep(800);
     }
  }
//+------------------------------------------------------------------+
//| Retorna a descrição dos flags de estilo da fonte                 |
//+------------------------------------------------------------------+
string FlagDescription(const uint flag)
  {
   switch(flag)
     {
      case FONT_ITALIC     :  return(" Italic");
      case FONT_UNDERLINE  :  return(" Underline");
      case FONT_STRIKEOUT  :  return(" Strikeout");
     }
   return("");
  }
//+------------------------------------------------------------------+
//| Retorna a descrição dos flags de espessura da fonte              |
//+------------------------------------------------------------------+
string FlagWidthDescription(const uint flag)
  {
   switch(flag)
     {
      case FW_DONTCARE  :  return(" Dontcare");
      case FW_THIN      :  return(" Thin");
      case FW_EXTRALIGHT:  return(" Extralight");
      case FW_ULTRALIGHT:  return(" Ultralight");
      case FW_LIGHT     :  return(" Light");
      case FW_NORMAL    :  return(" Normal");
      case FW_REGULAR   :  return(" Regular");
      case FW_MEDIUM    :  return(" Medium");
      case FW_SEMIBOLD  :  return(" Semibold");
      case FW_DEMIBOLD  :  return(" Demibold");
      case FW_BOLD      :  return(" Bold");
      case FW_EXTRABOLD :  return(" Extrabold");
      case FW_ULTRABOLD :  return(" Ultrabold");
      case FW_HEAVY     :  return(" Heavy");
      case FW_BLACK     :  return(" Black");
     }
   return("");
  }
//+------------------------------------------------------------------+
//| Cria um recurso gráfico para todo o gráfico                      |
//+------------------------------------------------------------------+
bool CreateResource(const long chart_id, uint &pixel_data[], const uint width, const uint height)
  {
//--- definimos o tamanho do array de pixels
   ResetLastError();
   uint size=width*height;
   if(ArrayResize(pixel_data, size)!=size)
     {
      PrintFormat("%s: ArrayResize() failed. Error code %d",__FUNCTION__, GetLastError());
      return(false);
     }
//--- preenchemos o array de pixels com cor transparente e com base nele criamos um recurso gráfico
   ArrayInitialize(pixel_data, COLOR_NULL);
   if(!ResourceCreate(RES_NAME, pixel_data, width, height, 0, 0, 0, COLOR_FORMAT_ARGB_NORMALIZE))
     {
      PrintFormat("%s: ResourceCreate() failed. Error code ",__FUNCTION__, GetLastError());
      return(false);
     }

//--- criamos o objeto "Rótulo Gráfico" nas coordenadas do canto superior esquerdo do gráfico
   if(!ObjectCreate(0, OBJ_NAME, OBJ_BITMAP_LABEL, 0, 0, 0))
     {
      PrintFormat("%s: ObjectCreate() failed. Error code %d",__FUNCTION__, GetLastError());
      return(false);
     }
//--- definimos para o objeto-desenho a largura e a altura iguais às do recurso gráfico.
//--- definimos o ponto de ancoragem do objeto pelo seu centro.
   if(!ObjectSetInteger(chart_id, OBJ_NAME, OBJPROP_XSIZE, width))
     {
      PrintFormat("%s: ObjectSetInteger() failed. Error code %d",__FUNCTION__, GetLastError());
      return(false);
     }
   if(!ObjectSetInteger(chart_id, OBJ_NAME, OBJPROP_YSIZE, height))
     {
      PrintFormat("%s: ObjectSetInteger() failed. Error code %d",__FUNCTION__, GetLastError());
      return(false);
     }
//--- especificamos para o objeto-desenho o arquivo de imagem do recurso gráfico criado anteriormente
//--- neste caso, para indicar o nome do recurso gráfico usado, deve-se escrever "::" antes de seu nome
   if(!ObjectSetString(chart_id, OBJ_NAME, OBJPROP_BMPFILE, "::"+RES_NAME))
     {
      PrintFormat("%s: ObjectSetString() failed. Error code %d",__FUNCTION__, GetLastError());
      return(false);
     }

//--- tudo concluído com sucesso
   return(true);
  }
//+------------------------------------------------------------------+
//| Atualiza os dados do recurso gráfico                             |
//+------------------------------------------------------------------+
void Update(const string res_name, const uint &pixel_data[], const uint width, const uint height, const bool redraw)
  {
//--- se forem passados tamanhos nulos, saímos
   if(width==0 || height==0)
      return;
//--- atualizamos os dados do recurso e redesenhamos o gráfico
   if(ResourceCreate(res_name, pixel_data, width, height, 0, 0, 0, COLOR_FORMAT_ARGB_NORMALIZE) && redraw)
      ChartRedraw();
  }

Também Veja

Recursos, ResourceCreate(), ResourceSave(), TextOut()

ObjectGetString

TextOut