Créer une bibliothèque graphique à partir de zéro - page 15

Nouveau commentaire
 
Sinon, c'est génial, continuez comme ça.
 
Pour vous, il est très facile de créer des contrôles sur kanvas :

1. Retirer plusieurs fonctions de dessin de la classe kanvas, à savoir ligne verticale, ligne de montagne. rectangle, rectangle rempli, texte.

2. Pour dessiner chaque élément, écrivez une fonction : void Button(), void Checkbox()... etc.

3. Dans la fonction des éléments de dessin, vous incluez des ensembles d'appels de fonctions de dessin (lignes, rectangles), avec lesquels vous "dessinez" la structure du contrôle requis sur le canevas requis.

4. une instance de chaque élément créé doit être liée à sa fenêtre.

5. Les propriétés de chaque instance créée (texte X, Y, X_SIZE, Y_SIZE...) doivent être sauvegardées dans un tableau ou une structure pour que les autres fonctions puissent les lire/modifier.

Et ensuite vous suivrez le même chemin....)

Et tout cela sur une toile, remarquez bien.

 
Que faire si vous avez besoin d'autres objets qui pourraient se trouver sous l'objet dessiné sur l'arrière-plan principal ?
 
Aliaksandr Hryshyn:
Que faire si vous avez besoin d'autres objets qui peuvent se trouver sous l'objet qui est dessiné sur l'arrière-plan principal ?
Donnez un exemple. Il existe de nombreuses situations différentes avec des solutions différentes.
 
Реter Konow:
Donnez-moi un exemple. Il existe de nombreuses situations différentes avec des solutions différentes.

Dans ma situation, une toile suffirait probablement, je pense que je vais faire comme vous l'avez conseillé.

D'autant plus qu'il existe déjà un support minimal pour les kanvas.
 
Chaque fenêtre est une toile séparée et indépendante.

La création d'une fenêtre est aussi simple que les autres éléments :

1. la fenêtre a des propriétés de base simples de plusieurs rectangles réguliers qui sont dessinés de manière cohérente sur le canevas créé en appelant la fonction FilledRectangle() (de la classe CCanvas) et en leur passant des modèles ou des valeurs utilisables.

2. la fenêtre est dessinée avant ses éléments. Cela se fait à l'aide de la fonction spéciale Draw_window(x, y, w, h) ; par exemple, elle appelle FilledRectangle() le nombre de fois requis pour construire la structure de la fenêtre.

3. Ensuite, des fonctions sont appelées pour dessiner les contrôles. Chacune est construite comme une fenêtre, avec une série de rectangles et de cadres dessinés un par un.

4. Les propriétés de chaque instance de chaque élément créé par l'appel de fonction sont écrites dans toute option de mémoire disponible pour les autres fonctions, parmi lesquelles :

Une fonction qui attrape l'événement de trouver le curseur au-dessus des coordonnées de l'élément dessiné, qui sur chaque événement de déplacement du curseur fait une boucle à travers les coordonnées de tous les éléments dessinés et dessinés dans cette fenêtre et trouve celui directement en dessous.

Une fonction qui fixe l'événement de pression/appui sur l'élément sous le curseur et change son état (s'il est interactif) en appelant une autre fonction qui change les valeurs des paramètres de cet élément (couleur, icône...) et le redessine à nouveau.

C'est suffisant pour un début.

 
Roman:

Pour le HFT, je pense que la 3D serait utile pour créer une analyse graphique du volume de la coupe et du flux d'ordres.
Mais comment interpréter de telles informations, je ne l'ai pas fait.

où est-il disponible ?

 
Il existe plusieurs catégories de contrôles, parmi lesquelles on peut en distinguer deux principales :

1. Décoratif - lignes, cadres, rectangles, icônes...

2. "Paramétrique" - c'est-à-dire ayant un paramètre.

Le deuxième type est représenté par deux sous-catégories :

1. éléments d'entrée - offrent la possibilité de modifier la valeur à l'aide de "mécanismes" graphiques conçus pour différents types de paramètres. Ces éléments sont divisés en plusieurs groupes, par exemple l'état logique vrai/faux (bool) définit le bouton, la case à cocher et le bouton radio, et la valeur du paramètre avec les limites de la plage et du pas est contrôlée par un curseur ou un champ de saisie. Pour chaque type de paramètre, il existe plusieurs éléments du même type qui permettent de modifier sa valeur de manière similaire.

2. les éléments de sortie - ils traduisent la valeur en numérique, en texte ou sous une autre forme transformée graphiquement. Il s'agit notamment des cellules de tableau, des étiquettes de texte, des barres de progression. Les indicateurs et les graphiques appartiennent également à cette catégorie, et leur différence réside uniquement dans leur adaptabilité à un grand volume de données de sortie.


Comme je l'ai dit précédemment, dessiner des éléments est simple et peu compliqué. En fait, il s'agit simplement de marquer un tableau avec des valeurs. Toutes les fonctions sont dans la classe CCanvas - lignes, rectangles, cadres. Les fonctions n'ont qu'à transmettre le tableau, qui est ensuite stocké dans la ressource et connecté à l'objet BITMAP_LABEL à l'aide de la propriété OBJPROP_BMPFILE.

Le wrapper de cette classe me perturbe comme la cinquième patte d'un chien. (Cela doit être la raison pour laquelle personne n'a jamais créé de bibliothèques sur Canvas, car on leur a dit d'en haut : "Tu dois monter la vache uniquement avec une selle ! ;)).
1...89101112131415
Nouveau commentaire
Raison: