Discussion :

[Invité]

Bonjour,
Je souhaite écrire un nouveau compositeur virtuel pour instrument MIDI.

j'ai défini un certain nombre de limite qui décrivent un ensemble d'espace de discourt.
Je vous la refais. J'ai découpé mon programme en un certain nombre de bibliothèques.

J'ai fait comme on m'a dis, c'est à dire que j'ai séparer par une interface/une couche supplémentaire, l'interface graphique et l'application.

Mais je n'arrive pas à spécifier la dépendance entre l'application l'interface intermédiaire et l'interface graphique.

A priori, si je faisait les chose sans réfléchir, j'aurais un main dépendant de mon interface graphique et l'interface graphique dépendant de l'interface avec l'application.

Je ne sais pas si pour faire au mieux je peux faire une interface graphique génerique pour la donner à mon interface intermédiaire générique également ou l'inverse ?

Merci pour votre analyse.

[Invité]

Re-bonjour,

Pour le moment j'ai décidé de passer la bibliothèque de l'interface du système en paramètre de la bibliothèque de l'interface graphique.
ce qui donne ceci :

Code ada :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 
----------------------------------------                                                                                                                                                                            
-- Description : Compositeur virtuel.                                                                                                                                                                               
----------------------------------------                                                                                                                                                                            
 
with Ap.AcidPulse.Generic_Pulser;
 
 
 
with AP.HMI.Xwindow;
 
with Gtk.Main;
 
procedure Acidpulse is
 
   package Pulser is new Ap.Acidpulse.Generic_Pulser;
begin
 
   Pulser.Initialize;
 
   Gtk.Main.Init;
 
   declare
 
      package XAcidPulser is new Ap.HMI.Xwindow(Pulser);
 
      Xwindow : XAcidpulser.Xwindow_Type;
   begin
 
      XAcidpulser.New_Xwindow(Xwindow);
 
      XAcidPulser.Initialize(Xwindow);
 
      Gtk.Main.Main;
   end;
 
end Acidpulse;

Super le nouveau look ! Dommage, toujours pas de coloration du langage Ada.

[Invité]

Bonjour,

Je me propose après avoir échoué une 4iemme fois avec mon compositeur virtuel, d'en écrire un nouveau.

Dans le précédent programme je me suis un peu embrouillé en court de route probablement parce que je n'ai pas pris suffisamment de distance entre l'interface graphique et le service du programme.

Je souhaite donc recommencer, avec de nouvelles interrogations peut-être plus pertinentes.

Donc, je désire à présent construire un type qui aurait deux fonctions ; L'une est de répondre aux besoins graphiques, l'autre est d'héberger un type de donnée destiner à l'exploitation du service du programme.

J'aurais donc un type article, peut-être objet pour les donnée et un type article intégrant une fenêtre Gtk_Window.

J'ai donc plusieurs option que vous connaissez peut-être mieux que moi.

Quelle serait la bonne ?

Par exemple :
cas 1)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
type fenêtre_principale is new data_type and gtk_window with null record

cas 2)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
type fenêtre_principale is new data_type with record Window : gtk_Window; end record;

cas 3)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
type fenêtre_principale is new gtk_Window with record data : data_type; end record;

cas 4)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
type fenêtre_principale is record data : data_type; window : gtk_Window; en record

Lequel choisir et éventuellement pourquoi, si vous avez un moment, merci ?