TextGetSize

Rend la largeur et la hauteur de la ligneaux réglages courants de la fonte.

bool  TextGetSize(
   const string       text,          // la ligne du texte
   uint&               width,        // la largeur du tampon en points
   uint&               height        // la hauteur du tampon en points
   );

Réglages

text

[in]  La ligne pour laquelle on reçoit la longueur et la largeur.

width

[out]  Le paramètre d'entrée pour la réception de la largeur.

height

[out]  Le paramètre d'entrée pour la réception de la hauteur.

La valeur rendue

Rend true en cas de l'exécution réussie, autrement rend false. Les codes possibles des erreurs:

  • ERR_INTERNAL_ERROR(4001) - en cas de l'erreur du système d'exploitation.

 

Exemple :

#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"
 
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- prépare 3 lignes de texte pour l'affichage sur le graphique
   string text1="This is the first line of text";
   string text2="The second line also contains text";
   string text3="Each word in each line has its own size";
   
   string text_array1[];   // tableau pour récupérer les mots de text1
   string text_array2[];   // tableau pour récupérer les mots de text2
   string text_array3[];   // tableau pour récupérer les mots de text3
   
//--- remplit les 3 tableaux de mots
   if(!SplitTextIntoWords(text1, text_array1) || !SplitTextIntoWords(text2, text_array2) || !SplitTextIntoWords(text3, text_array3))
      return;
      
//--- Identifiant du graphique courant
   long   chart_id= ChartID();
   
//--- déclare les paramètres de la ressource graphique
   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;
  
//--- crée une ressource graphique pour l'affichage du texte
   if(!CreateResource(chart_id, rc_data, rc_width, rc_height))
      return;
   
//--- récupère la taille du caractère espace (largeur et hauteur)
   int space_w=0, space_h=0;
   if(!TextGetSize(" ", space_w, space_h))
     {
      PrintFormat("%s: TextGetSize() failed. Error code %d",__FUNCTION__, GetLastError()); 
      return; 
     }
   
//--- augmente l'indentation verticale entre les chaînes de caractères de 2 et trace les textes des 3 tableaux sur le graphique
   space_h+=2;
   TextArrayToChart(1, text_array1, COORD_X, COORD_Y+space_h*0, space_w, rc_data, rc_width, rc_height);
   TextArrayToChart(2, text_array2, COORD_X, COORD_Y+space_h*1, space_w, rc_data, rc_width, rc_height);
   TextArrayToChart(3, text_array3, COORD_X, COORD_Y+space_h*2, space_w, rc_data, rc_width, rc_height);
   
//--- une fois que tous les textes ont été affichés, met à jour les données de la ressource
   Update(RES_NAME, rc_data, rc_width, rc_height, true);
   
//--- attends 5 secondes, puis libère la ressource et supprime l'objet graphique
   Sleep(5000);
   ResourceFree(RES_NAME);
   ObjectDelete(chart_id, OBJ_NAME);
   /*
   Trois chaînes de texte s'affichent sur le graphique suite à l'exécution du script.
   Dans chaque chaîne de caractères, chaque mot est affiché à une certaine distance du mot précédent,
   égale à la largeur du texte du mot précédent obtenue à l'aide de la fonction TextGetSize();
   le journal contiendra tous les mots de chaque chaîne de caractères avec leur taille :
   Text array 1:
   [0] word: "This", width=29, height=18
   [1] word: "is", width=12, height=18
   [2] word: "the", width=21, height=18
   [3] word: "first", width=25, height=18
   [4] word: "line", width=24, height=18
   [5] word: "of", width=13, height=18
   [6] word: "text", width=24, height=18
   Text array 2:
   [0] word: "The", width=26, height=18
   [1] word: "second", width=51, height=18
   [2] word: "line", width=24, height=18
   [3] word: "also", width=29, height=18
   [4] word: "contains", width=58, height=18
   [5] word: "text", width=24, height=18
   Text array 3:
   [0] word: "Each", width=36, height=18
   [1] word: "word", width=34, height=18
   [2] word: "in", width=12, height=18
   [3] word: "each", width=34, height=18
   [4] word: "line", width=24, height=18
   [5] word: "has", width=25, height=18
   [6] word: "its", width=16, height=18
   [7] word: "own", width=28, height=18
   [8] word: "size", width=28, height=18
   */ 
  }
//+----------------------------------------------------------------------------+
//| Découpe une chaîne en un tableau de mots séparés par un espace (" ")      |
//+----------------------------------------------------------------------------+
bool SplitTextIntoWords(const string text, string &array[])
  {
   ResetLastError();
   if(StringSplit(text, StringGetCharacter(" ", 0), array)<0)
     {
      PrintFormat("%s: StringSplit() failed. Error code %d",__FUNCTION__, GetLastError()); 
      return(false); 
     }
   return(true);
  }
//+------------------------------------------------------------------+
//| Affiche un texte depuis un tableau sur un graphique              |
//+------------------------------------------------------------------+
void TextArrayToChart(int array_num, string &array[], const int text_x, const int text_y, int space_w, uint &pixel_data[], const uint res_width, const uint res_height)
  {
   int width=0, height=0;  // largeur et hauteur du texte
   int x=text_x;           // coordonnée X du texte affiché
   
//--- affiche un en-tête contenant le nom du tableau de mots traité
   Print("Text array ", array_num,":");
   
//--- dans une boucle sur le tableau de mots
   int total=(int)array.Size();
   for(int i=0; i<total; i++)
     {
      //--- récupère le mot suivant et l'envoie au graphique (il est dessiné dans le tableau de pixels)
      string word=array[i];
      TextOut(word, x, text_y, ANCHOR_LEFT_UPPER, pixel_data, res_width, res_height, ColorToARGB(clrDodgerBlue), COLOR_FORMAT_ARGB_NORMALIZE);
      
      //--- récupère la taille du texte du mot en cours
      ResetLastError();
      if(!TextGetSize(word, width, height))
        {
         PrintFormat("%s: TextGetSize(\"%s\") failed. Error code %d",__FUNCTION__, word, GetLastError()); 
         continue; 
        }
      //--- écrit le texte dans le journal - le mot, sa largeur et sa hauteur,
      //--- augmente ensuite la coordonnée X du mot suivant par (largeur du mot) + (largeur de l'espace)
      PrintFormat("[%d] word: \"%s\", width=%d, height=%d",i, word, width, height);
      x+=width+space_w;
     }
  }
//+------------------------------------------------------------------+
//| Crée une ressource graphique pour le graphique entier            |
//+------------------------------------------------------------------+
bool CreateResource(const long chart_id, uint &pixel_data[], const uint width, const uint height)
  {
//--- définit la taille du tableau de pixels
   ResetLastError(); 
   uint size=width*height;
   if(ArrayResize(pixel_data, size)!=size) 
     { 
      PrintFormat("%s: ArrayResize() failed. Error code %d",__FUNCTION__, GetLastError()); 
      return(false); 
     } 
//--- remplit le tableau de pixels avec une couleur transparente et crée une ressource graphique basée sur ce tableau
   ArrayInitialize(pixel_data, 0x00FFFFFF); 
   if(!ResourceCreate(RES_NAME, pixel_data, width, height, 0, 0, 0, COLOR_FORMAT_ARGB_NORMALIZE)) 
     { 
      PrintFormat("%s: ResourceCreate() failed. Error code %d",__FUNCTION__, GetLastError()); 
      return(false); 
     } 
  
//--- crée un objet Etiquette Graphique (Graphic Label) aux coordonnées du coin supérieur gauche du graphique
   if(!ObjectCreate(0, OBJ_NAME, OBJ_BITMAP_LABEL, 0, 0, 0)) 
     { 
      PrintFormat("%s: ObjectCreate() failed. Error code %d",__FUNCTION__, GetLastError()); 
      return(false); 
     } 
//--- définit la largeur et la hauteur de l'objet bitmap créé égales à la largeur et à la hauteur de la ressource graphique
//--- définit le point d'ancrage au centre
   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); 
     }
//--- spécifie la ressource graphique précédemment créée pour l'objet bitmap sous forme de fichier image
//--- dans ce cas, pour indiquer le nom de la ressource graphique utilisée, il faut ajouter "::" avant son nom
   if(!ObjectSetString(chart_id, OBJ_NAME, OBJPROP_BMPFILE, "::"+RES_NAME))
     {
      PrintFormat("%s: ObjectSetString() failed. Error code %d",__FUNCTION__, GetLastError()); 
      return(false); 
     }
    
//--- tout va bien
   return(true);
  }
//+------------------------------------------------------------------+ 
//| Met à jour les données de la ressource graphique                 |
//+------------------------------------------------------------------+ 
void Update(const string res_name, const uint &pixel_data[], const uint width, const uint height, const bool redraw) 
  { 
//--- passe si aucune dimension n'est passée
   if(width==0 || height==0) 
      return; 
//--- met à jour les données de la ressource et redessine le graphique
   if(ResourceCreate(res_name, pixel_data, width, height, 0, 0, 0, COLOR_FORMAT_ARGB_NORMALIZE) && redraw) 
      ChartRedraw(); 
  } 

 

Voir aussi

Les ressources, ResourceCreate(), ResourceSave(), TextSetFont(), TextOut()