Coder des formes géometriques avec GTK+Cairo

**codezero1** · 13/01/2016, 12h10

Ça fait longtemps que j'essaie d' afficher des formes geometrique dans un " gtk_drawing_area " .

Car d'aprés ce que j'ai compris c'est dans ce widget que l'on utilise cairo avec GTK .

Bien entendu mon code se compile et s'éxécute .
Voici la fenêtre : http://pix.toile-libre.org/upload/or...1452685945.png

J'ai posté ce topic partout , mais sans résultat :

https://stackoverflow.com/questions/...cairo-with-gtk

https://github.com/AdaCore/gtkada/issues/3

Le code est en Ada , mais le probléme n'est pas le langage , mais que faire aprés avoir crée le " gtk_drawing_area " .

**Gaulouis** · 13/01/2016, 14h28

Salut,

Il y a un tutoriel sur le GtkDrawingArea mais c'est du C et du Gtk+2 et non Gtk+3

J'ai regardé ton git. Il semble qu'il faille ajouter :

Code :

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

1
2
3
Connect(Widget => zone_dessin ,
          Name => "draw" ,
            Cb => ....);

Il y a un Simple GtkDrawingArea usage dans la doc Gtk+3 (Inspire toi de la signature du callback "draw" -tu n'as pas besoin de créer de context cairo car il est passé en paramètre-)

Ceci étant dis, je me permet d'ajouter une petit précision.

Car d’après ce que j'ai compris c'est dans ce widget que l'on utilise cairo avec GTK

Tout les GtkWidget et ses dérivée permettent d'utiliser Cairo via la méthode virtuel "expose" ou via l’événement "expose-event".

PS : Ce poste devrai aussi intéressé : draw in drawing area

@+

**codezero1** · 13/01/2016, 17h32

Envoyé par Gaulouis

Il y a un tutoriel sur le GtkDrawingArea mais c'est du C et du Gtk+2 et non Gtk+3

Au point où j'en suis , il est préférable de résoudre le probleme cerné , plutôt que de suivre un tuto en C .

Envoyé par Gaulouis

J'ai regardé ton git. Il semble qu'il faille ajouter :

Code :

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

1
2
3
Connect(Widget => zone_dessin ,
          Name => "draw" ,
            Cb => ....);

Justement . Par quoi commencer , le signal "draw" ou la méthode virtuel "expose" ou via l’événement "expose-event" ?

Car en fonction de ça l' ordre du code et son fonctionnement sera trés différent .

Envoyé par Gaulouis

Il y a un Simple GtkDrawingArea usage dans la doc Gtk+3 (Inspire toi de la signature du callback "draw" -tu n'as pas besoin de créer de context cairo car il est passé en paramètre-)

Je veux bien , mais il faudrait d'abord que j'ai réponse à la précédente question .

Envoyé par Gaulouis

PS : Ce poste devrai aussi intéressé : draw in drawing area

Oo !

Eh ben , ils ont pas l' air de se débrouiller mieux .

**gerald3d** · 13/01/2016, 20h31

Bonsoir.

Gaulouis t'a donné la solution. Il faut bien passer par le signal "draw" pour dessiner dans GtkDrawingArea.

regarde ce blog, j'utilise ce principe pour dessiner un rectangle dans un GtkLabel.

**codezero1** · 14/01/2016, 04h23

Je n' ai pas précisé que j'utillise la lib suivante : http://packages.ubuntu.com/precise/libgtkada2.24.1-dev

Donc GTK2 ?

Entre temps , J' ai fais les modifs en utilisant ton lien Gaulouis : https://developer.gnome.org/gtk3/sta...awingArea.html

J'obtiens des erreurs de compilation a 2 lignes due au handler :

Code :

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
gnatmake "dessine_avec_cairo" `gtkada-config` (dans le dossier : /home/dead-code/Bureau/graphic)
gcc-4.6 -c -I/usr/share/ada/adainclude/gtkada dessine_avec_cairo.adb
dessine_avec_cairo.adb:155:01: no candidate interpretations match the actuals:
Compilation échouée.
dessine_avec_cairo.adb:155:01: missing argument for parameter "User_Data" in call to "connect" declared at gtk-handlers.ads:1140, instance at line 44
dessine_avec_cairo.adb:155:01: missing argument for parameter "Marsh" in call to "connect" declared at gtk-handlers.ads:1125, instance at line 44
dessine_avec_cairo.adb:155:01: missing argument for parameter "User_Data" in call to "connect" declared at gtk-handlers.ads:1109, instance at line 44
dessine_avec_cairo.adb:155:01: missing argument for parameter "User_Data" in call to "connect" declared at gtk-handlers.ads:1095, instance at line 44
dessine_avec_cairo.adb:155:01: missing argument for parameter "Marsh" in call to "connect" declared at gtk-handlers.ads:1081, instance at line 44
dessine_avec_cairo.adb:155:01: missing argument for parameter "Marsh" in call to "connect" declared at gtk-handlers.ads:880, instance at line 40
dessine_avec_cairo.adb:155:01: missing argument for parameter "Marsh" in call to "connect" declared at gtk-handlers.ads:841, instance at line 40
dessine_avec_cairo.adb:157:32: expected type "Simple_Handler" defined at gtk-handlers.ads:833, instance at line 40
dessine_avec_cairo.adb:157:32: found type access to function "draw_callback" defined at line 157
dessine_avec_cairo.adb:157:32:   ==> in call to "Connect" at gtk-handlers.ads:865, instance at line 40
dessine_avec_cairo.adb:157:32:   ==> in call to "Connect" at gtk-handlers.ads:853, instance at line 40
gnatmake: "dessine_avec_cairo.adb" compilation error

Code :

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
WITH Gtk.Main ;          USE Gtk.Main ;
WITH Gtk.Window ;        USE Gtk.Window ;
WITH Gtk.Enums ;         USE Gtk.Enums ;
WITH Gtk.Button ;        USE Gtk.Button ;
WITH Gtk.Alignment ;     USE Gtk.Alignment ;
WITH Gtk.Box ;           USE Gtk.Box ;
WITH Gtk.Gentry;         USE Gtk.Gentry;
WITH Gtk.Widget ;        USE Gtk.Widget ;
with Gtk.Handlers;
WITH Gtk.Drawing_Area;  USE Gtk.Drawing_Area;
WITH Cairo ;            USE Cairo ;
WITH Gdk.Color ;        USE Gdk.Color ;
WITH Gdk.Cairo ;        USE Gdk.Cairo ;
WITH Gtk.Style ;        USE Gtk.Style ;
WITH Glib ;             USE Glib ;
 
PROCEDURE dessine_avec_cairo IS
 
-----------------------
   -- VARIABLES --    |
----------------------------------------------------------
   win : Gtk_window ;
 
   Btn1, Btn2 ,Btn3  : Gtk_Button ;
 
   alignG, alignM ,alignD  : Gtk_Alignment ;
 
   Boite  : Gtk_VBox ;
 
   Boutons :  Gtk_HBox ;
 
   saisie : Gtk_Entry ;
 
   zone_dessin : Gtk_Drawing_Area ;
 
----------------------------------------------------------
--Instanciation package(s) for connexion
----------------------------------------------------------
 
   PACKAGE P_Callback IS NEW Gtk.Handlers.Callback(Gtk_Widget_Record);
 
   USE P_Callback ;
 
   PACKAGE P2_Callback IS NEW Gtk.Handlers.User_Callback(Gtk_Widget_Record , Boolean);
 
   USE P2_Callback ;
 
----------------------------------------------------------
--  Handlers (or callbacks)   |
----------------------------------------------------------
 
   procedure Stop_Program(Emetteur : access Gtk_Widget_Record'class)
   is
 
      PRAGMA Unreferenced (Emetteur);
 
   begin
 
      Main_Quit;
 
   end Stop_Program ;
 
   function draw_callback (the_Widget : access Gtk_Widget_Record'Class ;
                           cairo_t : Cairo_Context ) return boolean
   is
 
   width : Allocation_Int ;
 
   height : Allocation_Int ;
 
   color : Gdk_Color ;
 
   begin
 
   Queue_Draw (Widget => zone_dessin);
 
   width := Get_Allocation_Width (Widget => the_Widget) ;
 
   height := Get_Allocation_Height (Widget => the_Widget) ;
 
   Arc
     (Cr     => cairo_t ,
      Xc     => 2.0 ,
      Yc     => 2.0 ,
      Radius => 2.0 ,
      Angle1 => 0.0 ,
      Angle2 => 2.0 * 3.14 );
 
    color := Get_Fg
     (Style   => Get_Style (Widget => the_Widget) ,
      State_Type => State_Active) ;
 
 
    Set_Source_Color
     (Cr       => cairo_t ,
      Color    => color);
 
    Set_Fill_Rule
     (Cr        => cairo_t ,
      Fill_Rule => Cairo_Fill_Rule_Winding);
 
    return false ;
 
    end draw_callback ;
 
 
 
-------------------------------------------------
BEGIN
 
   Init ;
 
----------------
   -- NEW --   |
-------------------------------------------------
 
   Gtk_New(zone_dessin);
 
   Gtk_New(win);
 
   Gtk_New(saisie);
 
   Gtk_New(Btn1, "Bouton 1") ;
   Gtk_New(Btn2, "Bouton 2") ;
   Gtk_New(Btn3, "Bouton 3") ;
 
   Gtk_New(alignG,0.0,1.0,1.0,1.0);
   Gtk_New(alignM,0.5,1.0,1.0,1.0);
   Gtk_New(alignD,1.0,1.0,1.0,1.0);
 
  Gtk_New_VBox
  (Boite, homogeneous => false, Spacing => 0) ;
 
  Gtk_New_HBox
  (Boutons, homogeneous => false, Spacing => 0) ;
 
---------------------------------
--  Add                    |
---------------------------------
 
   alignG.add(Btn1) ;
   alignM.add(Btn2) ;
   alignD.add(Btn3) ;
 
   win.Add(Boite);
 
------------------------------------------
--  Connect                |
------------------------------------------
 
Connect(Widget => win ,
          Name => "destroy" ,
            Cb => Stop_Program'access);
 
Connect(Widget => zone_dessin ,
          Name => "draw" ,
            Cb => draw_callback'access);
 
------------------------------------------
--  Design Window          |
------------------------------------------
 
   Size_Allocate
     (Widget  => zone_dessin ,
      Allocation =>  ( X => 0 , Y => 0 , Width => 150 , Height => 150 ) ) ;
 
   Pack_Start
      (In_Box => Boite ,
       Child  => zone_dessin ,
       Expand => true ,
       Fill => true );
 
   Pack_Start
      (In_Box => Boite ,
       Child  => saisie ,
       Expand => false );
 
   Pack_Start
      (In_Box => Boite ,
       Child => Boutons ,
       Expand => true ,
       Fill => true );
 
 
   Pack_Start
      (In_Box => Boutons ,
       Child => alignG ,
       Expand => true ,
       Fill => true );
 
   Pack_Start
      (In_Box => Boutons ,
       Child => alignM ,
       Expand => true ,
       Fill => true );
 
   Pack_Start
      (In_Box => Boutons ,
       Child => alignD ,
       Expand => true ,
       Fill => true );
 
 
 
   win.Set_Default_Size(600,500) ;
 
   win.set_position(Win_Pos_Mouse) ;
 
   win.set_opacity(0.7) ;
 
   win.Show_all ;
   Main ;
 
END dessine_avec_cairo ;

**Gaulouis** · 14/01/2016, 11h23

La documentation Gtk+2 donne une signature :

Code :

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

1
2
gboolean
expose_event_callback (GtkWidget *widget, GdkEventExpose *event, gpointer data)

Donc en Ada, ca devrai donner quelques chose comme :

Code :

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

1
2
3
4
5
6
7
function draw_callback (Widget : access Gtk_Widget_Record'Class ;
                        Event  : in Gdk_Event_Expose;
                        Data   : in Gpointer ) return boolean
is
begin
  -- do stuff --
end draw_callback;

PS : Je ne connais pas le langage Ada.

**codezero1** · 14/01/2016, 13h59

Envoyé par Gaulouis

La documentation Gtk+2 donne une signature :

Code :

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

1
2
gboolean
expose_event_callback (GtkWidget *widget, GdkEventExpose *event, gpointer data)

Donc en Ada, ca devrai donner quelques chose comme :

Code :

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

1
2
3
4
5
6
7
function draw_callback (Widget : access Gtk_Widget_Record'Class ;
                        Event  : in Gdk_Event_Expose;
                        Data   : in Gpointer ) return boolean
is
begin
  -- do stuff --
end draw_callback;

Bon , j'ai trouvé le lien pour ton exemple : https://developer.gnome.org/gtk2/sta...awingArea.html

Mais ... ça n'a rien à voir avec GTK3 .

Où est passé le signal "draw" ?

Il n'y a que du "expose_event" .

Il n'y a plus de "Cairo_Context" , non plus .

Bref , autant tout recommencer .

En ce qui concerne les handlers =

En ADA , il existe une notion d' instantiation pour les packages générique .

Et c'est justement le package générique correspondant au handler , qu'il me faut dans le code .

Mais , là ce n'est pas le même , donc à revoir .

**Gaulouis** · 14/01/2016, 15h57

Code :

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

1
2
3
   package Configured is new Gtk.Handlers.Return_Callback
     (Widget_Type => Gtk_Drawing_Area_Record,
      Return_Type => Boolean);

Code :

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

1
2
3
4
   Configured.Connect (Widget => zone_dessin,
                       Name   => "expose_event",
                       Marsh  => Configured.To_Marshaller
                          (Expose_Event'Access));

Code :

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
 
   function Expose_Event
     (zone_dessin : access Gtk_Drawing_Area_Record'Class;
      Event : in Gdk.Event.Gdk_Event;
      Data   : in Gpointer)
      return Boolean
   is
      Area : Gdk_Rectangle := Get_Area (Event);
      Window : Gdk_Window := Get_Window (zone_dessin);
      Context : Cairo_Context := Cairo_Create (Window);
   begin
 
      -- do draw
 
      return True;
   end Expose_Event;

**codezero1** · 14/01/2016, 19h09

Envoyé par Gaulouis

Context : Cairo_Context := Cairo_Create (Window);

Cette fonction n'existe pas dans le binding Ada .

Par contre il y a celles-là :

Code :

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

1
2
3
4
 
 --function Create (Drawable : Gdk_Drawable) return Cairo_Context;
 
    --function Create (Target : Cairo_Surface) return Cairo_Context;

J'ai allégé le code , mais c'est pas encore ça .

Code :

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
 
WITH Gtk.Main ;          USE Gtk.Main ;
WITH Gtk.Window ;        USE Gtk.Window ;
WITH Gtk.Enums ;         USE Gtk.Enums ;
WITH Gtk.Widget ;        USE Gtk.Widget ;
with Gtk.Handlers;
WITH Gtk.Drawing_Area;  USE Gtk.Drawing_Area;
 
 
WITH Cairo ;            USE Cairo ;
WITH Gdk.Color ;        USE Gdk.Color ;
WITH Gdk.Cairo ;        USE Gdk.Cairo ;
WITH Gtk.Style ;        USE Gtk.Style ;
WITH Glib ;             USE Glib ;
WITH Gdk.Event ;        USE Gdk.Event ;
--WITH Gdk.Rectangle ;    USE Gdk.Rectangle ;
WITH Gdk ;              USE Gdk ;
 
PROCEDURE dessine_avec_cairo IS
 
-----------------------
   -- VARIABLES --    |
----------------------------------------------------------
   win : Gtk_window ;
 
   zone_dessin : Gtk_Drawing_Area ;
 
----------------------------------------------------------
--Instanciation package(s) for connexion
----------------------------------------------------------
 
   PACKAGE P_Callback IS NEW Gtk.Handlers.Callback(Gtk_Widget_Record);
 
   USE P_Callback ;
 
   PACKAGE Configured IS NEW Gtk.Handlers.Return_Callback
     (Widget_Type => Gtk_Drawing_Area_Record,
      Return_Type => Boolean);
 
----------------------------------------------------------
--  Handlers (or callbacks)   |
----------------------------------------------------------
 
   procedure Stop_Program(Emetteur : access Gtk_Widget_Record'class)
   is
 
      PRAGMA Unreferenced (Emetteur);
 
   begin
 
      Main_Quit;
 
   end Stop_Program ;
 
 
   function Expose_Event
     (the_Widget : access Gtk_Drawing_Area_Record'Class;
      Event : Gdk.Event.Gdk_Event )
      return Boolean
   is
 
    Area : Gdk_Rectangle := Get_Area (Event);
 
    Context : Cairo_Context ;
 
    drawable : Gdk_Drawable ;
 
    Win2 : Gdk_Window ;
 
    begin
 
    Context := Create ( drawable ) ;
 
    Win2 := Get_Window (Widget => the_Widget) ;
 
    return true ;
 
    end expose_event;
 
-------------------------------------------------
BEGIN
 
   Init ;
 
----------------
   -- NEW --   |
-------------------------------------------------
 
   Gtk_New(zone_dessin);
 
   Gtk_New(win);
 
---------------------------------
--  Add                    |
---------------------------------
 
   win.Add( zone_dessin );
 
------------------------------------------
--  Connect                |
------------------------------------------
 
Connect(Widget => win ,
          Name => "destroy" ,
            Cb => Stop_Program'access);
 
 
Configured.Connect (Widget => zone_dessin,
                       Name   => "expose_event",
                       Marsh  => Configured.To_Marshaller
                          (Expose_Event'Access));
 
------------------------------------------
--  Design Window          |
------------------------------------------
 
   Size_Allocate
     (Widget  => zone_dessin ,
      Allocation =>  ( X => 0 , Y => 0 , Width => 150 , Height => 150 ) ) ;
 
   win.Set_Default_Size(600,500) ;
 
   win.set_position(Win_Pos_Center) ;
 
   win.set_opacity(0.7) ;
 
   win.Show_all ;
   Main ;
 
END dessine_avec_cairo ;

**Gaulouis** · 14/01/2016, 19h29

C'est cette fonction qu'il faut utiliser :

Code :

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

--function Create (Drawable : Gdk_Drawable) return Cairo_Context;

Ensuite il reste plus qu'a dessiner...

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
   function Expose_Event
-- ...
    begin
    Win2 := Get_Window (Widget => the_Widget) ;
    drawable := Gdk_Drawable (Win2) ;-- transtypage
    Context := Create ( drawable ) ;
 
    Set_Source_Rgb(Context, 1.0, 0.0, 0.0);
    Rectangle(Context, 0, 0, 100, 20);
    Fill(Context);
 
    return true ;
    end expose_event;

PS: Il y a sûrement des erreurs de syntaxe et autre...

Edit:

Où est passé le signal "draw" ?

Le signal "draw" a été introduit dans la version 3 de Gtk+ Il n'est donc pas disponible pour la version 2 de Gtk+

Il n'y a que du "expose_event" .

Tu n'as plus a te poser la question sur le choix de l’événement a utiliser. Reste le choix entre la surcharge GtkWidget::expose et le Callback "expose_event"

Il n'y a plus de "Cairo_Context" , non plus .

Avec Gtk+2, GdkWindow est passé en paramètre aux méthode de dessin (pour dessiner les widget) . Il faut donc créer u nouveau context cairo a chaque fois.
Gtk+3 corrige ça en passant le context cairo en parametre.

**codezero1** · 14/01/2016, 20h23

-- transtypage

Qu'est-ce que tu veux faire exactement ?

J'ai adapté ton code :

Code :

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
38
39
 
 function Expose_Event
     (the_Widget : access Gtk_Drawing_Area_Record'Class;
      Event : Gdk.Event.Gdk_Event )
      return Boolean
   is
 
    Area : Gdk_Rectangle := Get_Area (Event);
 
    Context : Cairo_Context ;
 
    drawable : Gdk_Drawable ;
 
    Win2 : Gdk_Window ;
 
    begin
 
    Win2 := Get_Window (Widget => the_Widget) ;
 
    drawable := Gdk_Drawable (Win2) ;-- transtypage
 
    Context := Create ( drawable ) ;
 
     Set_Source_Rgb(Context, 1.0, 0.0, 0.0);
 
    Rectangle
     (Cr     => Context ,
      X      => 0.0 ,
      Y      => 0.0 ,
      Width  => 100.0 ,
      Height => 20.0 );
 
   Set_Fill_Rule
     (Cr        => Context ,
      Fill_Rule => Cairo_Fill_Rule_Winding);
 
    return true ;
 
    end expose_event;

**Gaulouis** · 14/01/2016, 20h46

Je voulais faire un cast, une conversion de type, une coercition de type

Peut être qu'on peu écrire directement :

Code :

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

Context := Create ( Get_Window (Widget => the_Widget) ) ;

Je n'avais jamais regardé Ada avant. C'est normal si c'est autant verbeux; ou le nom des paramètres passé est optionnel ?

Code :

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

1
2
3
4
5
6
    Rectangle
     (Cr     => Context ,
      X      => 0.0 ,
      Y      => 0.0 ,
      Width  => 100.0 ,
      Height => 20.0 );

Edit : Finalement ça marche ? Le rectangle s'affiche ?

**codezero1** · 14/01/2016, 22h19

Pour la conversion :

Code :

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

Context := Create ( drawable ) ;

Cette fonction retourne un "Cairo_Context" et prends uniquement en parametre un "Gdk_Drawable" .

Context := Create ( Get_Window (Widget => the_Widget) ) ;

Et là tu veux lui donner en paramêtre un "Gdk_Window" ?

Je ne pense pas cela possible .

Sinon , on peut créer un autre type ou subtype .

Ou alors faut avoir de l' experience en Prog GTK de bas niveau .

----------------------------------------------

Quand on utilise une association de parametre ( nom de parametre + la fleche) , c'est pour rendre le code plus clair , c'est optionnel .

De plus , la procedure rectangle dans le binding utilise des "gdoubles" , et non des "gint" .

--------------------------------------------
Edit : Pour qu'un rectangle s'affiche faudrait déjà que le code puisse compiler

**Gaulouis** · 14/01/2016, 22h57

Bein j'ai installé Ada et GtkAda-2.24 mais quand j’essaie de compile j'ai des erreurs de type undefine reference, donc un problème de linkage avec Gtk. Donc j'ai laissé tombé ... C'est pour ça que je comptai sur toi pour nous donner un exemple fonctionnel.

Code :

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

1
2
gnatmake dessine_avec_cairo -aI/usr/share/ada/adainclude/gtkada 'gtkada-config'
référence indéfinie vers « gtk_main »

Pour qu'un rectangle s'affiche faudrait déjà que le code puisse compiler

Quel erreurs as tu ?

Et là tu veux lui donner en paramètre un "Gdk_Window" ?

Clairement oui ! C'est pour ça que je disais de faire une conversion de type:

Code :

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

1
2
3
    Win2 := Get_Window (Widget => the_Widget) ;
    drawable := Gdk_Drawable (Win2) ;
    Context := Create ( drawable ) ;

Je ne pense pas cela possible.

Dans la doc Ada c'est écrit que pour transtyper un Gdk_Window en Gdk_Drawable il faut faire : Gdk_Drawable (Win2)

Ou alors faut avoir de l' experience en Prog GTK de bas niveau .

Je n'ai pas la prétention de dire ça. Mais ça fais super plaisir

**codezero1** · 14/01/2016, 23h14

Envoyé par Gaulouis

Bein j'ai installé Ada et GtkAda-2.24 mais quand j’essaie de compile j'ai des erreurs de type undefine reference, donc un problème de linkage avec Gtk. Donc j'ai laissé tombé ... C'est pour ça que je comptai sur toi pour nous donner un exemple fonctionnel.

Code :

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

1
2
gnatmake dessine_avec_cairo -aI/usr/share/ada/adainclude/gtkada 'gtkada-config'
référence indéfinie vers « gtk_main »

C'est pas ça la bonne commande de compilation , fait simplement :

Code :

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

gnatmake dessine_avec_cairo.adb `gtkada-config`

----------------------------------

Oublie les erreurs du compilo pour l'instant , je n'avais pas compris ce que tu essayait de faire . (transtypage) .

Envoyé par Gaulouis

Dans la doc Ada c'est écrit que pour transtyper un Gdk_Window en Gdk_Drawable il faut faire : Gdk_Drawable (Win2)

Ben... tu pourrai me linker ?

On aura les mêmes infos .

Envoyé par Gaulouis

Je n'ai pas la prétention de dire ça. Mais ça fais super plaisir

C'est mérité

**Gaulouis** · 14/01/2016, 23h21

J'avais une faute dès le départ :"'" au lieu de "`"

Code :

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

gnatmake dessine_avec_cairo.adb `gtkada-config`

Merci l'artiste

Code :

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
WITH Gtk.Main ;          USE Gtk.Main ;
WITH Gtk.Window ;        USE Gtk.Window ;
WITH Gtk.Enums ;         USE Gtk.Enums ;
WITH Gtk.Widget ;        USE Gtk.Widget ;
with Gtk.Handlers;
WITH Gtk.Drawing_Area;  USE Gtk.Drawing_Area;
 
 
WITH Cairo ;            USE Cairo ;
WITH Gdk.Color ;        USE Gdk.Color ;
WITH Gdk.Cairo ;        USE Gdk.Cairo ;
WITH Gtk.Style ;        USE Gtk.Style ;
WITH Glib ;             USE Glib ;
WITH Gdk.Event ;        USE Gdk.Event ;
WITH Gdk.Rectangle ;    USE Gdk.Rectangle ;
WITH Gdk ;              USE Gdk ;
 
PROCEDURE dessine_avec_cairo IS
 
-----------------------
   -- VARIABLES --    |
----------------------------------------------------------
   win : Gtk_window ;
 
   zone_dessin : Gtk_Drawing_Area ;
 
----------------------------------------------------------
--Instanciation package(s) for connexion
----------------------------------------------------------
 
   PACKAGE P_Callback IS NEW Gtk.Handlers.Callback(Gtk_Widget_Record);
 
   USE P_Callback ;
 
   PACKAGE Configured IS NEW Gtk.Handlers.Return_Callback
     (Widget_Type => Gtk_Drawing_Area_Record,
      Return_Type => Boolean);
 
----------------------------------------------------------
--  Handlers (or callbacks)   |
----------------------------------------------------------
 
   procedure Stop_Program(Emetteur : access Gtk_Widget_Record'class)
   is
 
      PRAGMA Unreferenced (Emetteur);
 
   begin
 
      Main_Quit;
 
   end Stop_Program ;
 
 
 
   function Expose_Event
     (the_Widget : access Gtk_Drawing_Area_Record'Class;
      Event : Gdk.Event.Gdk_Event )
      return Boolean
   is
    Area : Gdk_Rectangle := Get_Area (Event);
    Region : Gdk_Rectangle;
 
    Context : Cairo_Context ;
    Win2 : Gdk_Window ;
    drawable : Gdk_Drawable ;
 
    begin
 
    Win2 := Get_Window (Widget => the_Widget) ;
    drawable := Gdk_Drawable (Win2) ;-- transtypage
    Context := Create ( drawable ) ;
 
    Region.Width := Area.Width / 2;
    Region.Height := Area.Height / 2;
    Region.X := Region.Width / 2;
    Region.Y := Region.Height / 2;
 
    Set_Source_Rgb(Context, 1.0, 0.0, 0.0);
    Cairo.Rectangle(Cr => Context, X => GDouble(Region.X), Y => GDouble(Region.Y), Width => GDouble(Region.Width), Height => GDouble(Region.Height));
    Cairo.Fill_Preserve(Context);
 
    Set_Line_Width(Context, 1.0);
    Set_Source_Rgb(Context, 0.0, 0.0, 1.0);
    Cairo.Stroke(Context);
 
 
    return false ;
 
    end expose_event;
 
 
-------------------------------------------------
BEGIN
 
   Init ;
 
----------------
   -- NEW --   |
-------------------------------------------------
 
   Gtk_New(zone_dessin);
 
   Gtk_New(win);
 
---------------------------------
--  Add                    |
---------------------------------
 
   win.Add( zone_dessin );
 
------------------------------------------
--  Connect                |
------------------------------------------
 
Connect(Widget => win ,
          Name => "destroy" ,
            Cb => Stop_Program'access);
 
 
Configured.Connect (Widget => zone_dessin,
                       Name   => "expose_event",
                       Marsh  => Configured.To_Marshaller
                          (Expose_Event'Access));
 
------------------------------------------
--  Design Window          |
------------------------------------------
 
   Size_Allocate
     (Widget  => zone_dessin ,
      Allocation =>  ( X => 0 , Y => 0 , Width => 150 , Height => 150 ) ) ;
 
   win.Set_Default_Size(600,500) ;
 
   win.set_position(Win_Pos_Center) ;
 
   win.set_opacity(0.7) ;
 
   win.Show_all ;
   Main ;
 
END dessine_avec_cairo ;

Ca compile mais c'est pas super chez moi ... Je suis sous Ubuntu avec plein de bug de la part de compiz ...

Edit : Petite étoffage de la fonction expose_event
edit2 : Il est préférable de ne pas casser la chaîne des événement. Donc return false pour expose_event
Edit3 : Transtypage Ada : https://en.wikibooks.org/wiki/Ada_Pr...pe_conversions
Edite 4: Screenshot:
Nom : dessine_avec_cairo.png
Affichages : 407
Taille : 8,1 Ko

Nom : dessine_avec_cairo.png
Affichages : 407
Taille : 8,1 Ko

bonne nuit

**codezero1** · 15/01/2016, 00h09

Là , Chapeau

La conversion de type pour GTK , alors qu'elle est illustré avec des types Standard , fallait trouver

-------------------------------------------------------------

En effet , ça fonctionne !

Bon , je comprend 2/3 , mais ça fonctionne .

ex : Size_Allocate n'a aucun effet .
------------------------------

A +

**Gaulouis** · 15/01/2016, 13h31

Si tu souhaite modifier/retrouver la taille minimal (incompressible) d'un GtkDrawingArea il faut utiliser Set_Size_Request/Get_Size_Request
La méthode virtuel Size_Request est l'implémentation de Get_Size_Request
Size_Allocate indique qu'elle taille est donnée au widget pour son affichage. En écriture cela permet de resizer le GdkWindow. En lecture cela permet de connaître la zone d'affichage. Tu peu accéder a cette propriété depuis the_widget->allocation

On peut améliorer le code en remplaçant :

Code :

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

Area : Gdk_Rectangle := Get_Area (Event);

Par :

Code :

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

Area : Gdk_Rectangle := Get_Allocation(Widget=>the_widget)

Get_Area comme get_allocation indique la zone total d'affichage du widget.
Alors que Get_Region indique le rectangle a mettre à jour dans le widget

**codezero1** · 16/01/2016, 13h47

Size_Allocate indique qu'elle taille est donnée au widget pour son affichage. En écriture cela permet de resizer le GdkWindow. En lecture cela permet de connaître la zone d'affichage.

J'ai pas l'impression que ça permet de "resizer le GdkWindow" .

En utilisant cette procedure , aucun changement de taille (visible) n'est effectué .

Voici sa decription dans la library :

Code :

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
 
procedure Size_Allocate
     (Widget     : access Gtk_Widget_Record;
      Allocation : Gtk_Allocation);
   --  Emit a "size_allocate" event for the widget.
   --  Allocation'size is first constrained to a range between 1x1 and
   --  32767x32767.
   --  A clear and draw request is also queued if required.
 
 type Gtk_Allocation is record
      X      : Gint;
      Y      : Gint;
      Width  : Allocation_Int;
      Height : Allocation_Int;
   end record;
   --  Gtk_Allocation indicates a size and position a widget was allocated.

------------------------------------------

Sinon , j'ai compris pour Set_Size_Request & Get .

----------------------------------------

Peut-être que parce que la fenêtre ne comprend pas de boite , aucun changement de taille n'est possible ?

**Gaulouis** · 16/01/2016, 15h58

J'ai pas l'impression que ça permet de "resizer le GdkWindow" .

Je me suis mal exprimé;

~~Size_Allocate indique qu'elle taille est donnée au widget pour son affichage.~~ Size_Allocate permet d'indiquer la taille de la mémoire tampon dans laquel le dessin pourra se faire

C'est cette zone mémoire (restreinte par Gdk_Event_Expose.Gdk_Region) qui sera envoyé a ta carte grapique/ecran.

En utilisant cette procedure , aucun changement de taille (visible) n'est effectué.

Si tu fais un Size_Allocate(..., Gdk_Allocation(0, 0, 10, 10)) mais que ton widget fait 100 pixels sur 100, le widget ne serra dessiné que sur une zone de 10 pixel sur 10. et de jolie bug graphique apparaitrons. Je n'appel jamais pas cette fonction.

Si tu souhaite agrandir ton widget redimensionne ta fenêtre

Ou ajoute un GtkScrolledWindow:

Code :

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
-- gnatmake dessine_avec_cairo.adb `gtkada-config`
 
 
WITH Gtk.Main ;          USE Gtk.Main ;
WITH Gtk.Window ;        USE Gtk.Window ;
WITH Gtk.Enums ;         USE Gtk.Enums ;
WITH Gtk.Widget ;        USE Gtk.Widget ;
with Gtk.Handlers;
WITH Gtk.Drawing_Area;  USE Gtk.Drawing_Area;
WITH Gtk.Scrolled_Window; USE Gtk.Scrolled_Window ;
 
WITH Cairo ;            USE Cairo ;
WITH Gdk.Color ;        USE Gdk.Color ;
WITH Gdk.Cairo ;        USE Gdk.Cairo ;
WITH Gtk.Style ;        USE Gtk.Style ;
WITH Glib ;             USE Glib ;
WITH Gdk.Event ;        USE Gdk.Event ;
WITH Gdk.Rectangle ;    USE Gdk.Rectangle ;
WITH Gdk ;              USE Gdk ;
 
PROCEDURE dessine_avec_cairo IS
 
-----------------------
   -- VARIABLES --    |
----------------------------------------------------------
   win : Gtk_window ;
 
   scrolled_window : Gtk_Scrolled_Window ;
 
   zone_dessin : Gtk_Drawing_Area ;
 
 
----------------------------------------------------------
--Instanciation package(s) for connexion
----------------------------------------------------------
 
   PACKAGE P_Callback IS NEW Gtk.Handlers.Callback(Gtk_Widget_Record);
 
   USE P_Callback ;
 
   PACKAGE Configured IS NEW Gtk.Handlers.Return_Callback
     (Widget_Type => Gtk_Drawing_Area_Record,
      Return_Type => Boolean);
 
----------------------------------------------------------
--  Handlers (or callbacks)   |
----------------------------------------------------------
 
   procedure Stop_Program(Emetteur : access Gtk_Widget_Record'class)
   is
 
      PRAGMA Unreferenced (Emetteur);
 
   begin
 
      Main_Quit;
 
   end Stop_Program ;
 
 
   function Expose_Event
     (the_Widget : access Gtk_Drawing_Area_Record'Class;
      Event : Gdk.Event.Gdk_Event )
      return Boolean
   is
    Area : Gdk_Rectangle := Get_Area (Event);
    Region : Gdk_Rectangle;
 
    Context : Cairo_Context ;
    Win2 : Gdk_Window ;
    drawable : Gdk_Drawable ;
 
    begin
 
    Win2 := Get_Window (Widget => the_Widget) ;
    drawable := Gdk_Drawable (Win2) ;-- transtypage
    Context := Create ( drawable ) ;
 
    Region.Width := Area.Width / 2;
    Region.Height := Area.Height / 2;
    Region.X := Region.Width / 2;
    Region.Y := Region.Height / 2;
 
    Set_Source_Rgb(Context, 1.0, 0.0, 0.0);
    Cairo.Rectangle(Cr => Context, X => GDouble(Region.X), Y => GDouble(Region.Y), Width => GDouble(Region.Width), Height => GDouble(Region.Height));
    Cairo.Fill_Preserve(Context);
 
    Set_Line_Width(Context, 1.0);
    Set_Source_Rgb(Context, 0.0, 0.0, 1.0);
    Cairo.Stroke(Context);
 
 
    return true ;
 
    end expose_event;
 
-------------------------------------------------
BEGIN
 
   Init ;
 
----------------
   -- NEW --   |
-------------------------------------------------
 
   Gtk_New(zone_dessin);
 
   Gtk_New(scrolled_window);
 
   Gtk_New(win);
 
---------------------------------
--  Add                    |
---------------------------------
 
   scrolled_window.Add_With_Viewport( zone_dessin );
 
   win.Add( scrolled_window );
 
------------------------------------------
--  Connect                |
------------------------------------------
 
Connect(Widget => win ,
          Name => "destroy" ,
            Cb => Stop_Program'access);
 
 
Configured.Connect (Widget => zone_dessin,
                       Name   => "expose_event",
                       Marsh  => Configured.To_Marshaller
                          (Expose_Event'Access));
 
------------------------------------------
--  Design Window          |
------------------------------------------
 
   Set_Size_Request(zone_dessin, 800, 800);
 
   win.Set_Default_Size(600,500) ;
 
   win.set_position(Win_Pos_Center) ;
 
   win.set_opacity(0.7) ;
 
   win.Show_all ;
   Main ;
 
END dessine_avec_cairo ;

Que ce passe-t-il si tu modifie le code avec : Set_Size_Request(zone_dessin, 500, 400);
Que ce passe-t-il si tu redimensionne la fenêtre a son minimum.
Ajoute Set_Size_Request(scrolled_window, 200, 200); et redimensionne la fenêtre a son minimum.

PS: Je dois te quitter, on m'appel pour allé goûter ^^

Coder des formes géometriques avec GTK+Cairo

GTK+ avec C & C++

Discussions similaires

Partager

Partager