Discussion :

[Gamall]

Bonjour,
J'essaie, en ce moment, d'apprendre à utiliser gnome-canvas/gdk-pixbuf, mais je n'arrive absolument pas à afficher le moindre pixel dans un canvas, voici mon code, pour l'instant:

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
#include <stdlib.h>
#include <gtk/gtk.h>
#include <glib.h>
#include <libgnomecanvas/libgnomecanvas.h>
 
typedef struct _CanvasRegion
{
	gdouble x1;
	gdouble x2;
	gdouble y1;
	gdouble y2;
} CanvasRegion;
 
int main(int argc, char ** argv)
{
	GtkWidget *pWindow = NULL;
	GtkWidget *pCanvas = NULL;
	CanvasRegion  region;
 
	region.x1 = 0;
	region.y1 = 0;
	region.x2 = 320;
	region.y2 = 200;
 
 
	gtk_init(&argc, &argv);
 
	pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_window_set_default_size(GTK_WINDOW(pWindow), 320, 200);
	g_signal_connect(G_OBJECT(pWindow),
                                           "destroy",
                                           G_CALLBACK(gtk_main_quit), NULL);
 
	pCanvas = gnome_canvas_new();
	gnome_canvas_set_scroll_region(
			GNOME_CANVAS(pCanvas),
			region.x1,
			region.y1,
			region.x2,
			region.y2
			);
 
	gtk_widget_show_all(pWindow);
	gtk_main();
 
 
	return EXIT_SUCCESS;
}

Pour l'instant, j'arrive à créer un canvas, mais je regarde dans la doc, et je ne vois aucune fonction pour afficher un point dans ce canvas

il y a cette fonction:

Code :

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

 gnome_canvas_item_new ()

mais je ne comprends pas à quoi elle sert

Bref, donc, si quelqu'un a un exemple de code detaillé, pas trop compliqué qui affiche, une droite, ou un rectangle dans un canvas, pour comprendre comment ça fonctionne, parce que là, je tourne vraiment en rond

Merci

[Gamall]

UP! personne?
J'ai essayé aussi les drawing area, mais pas moyen d'afficher le moindre pixel

[liberforce]

N'utilise pas GnomeCanvas, libgnome est dépréciée... Sinon tu as un exemple sur les GtkDrawingArea dans gtk-demo, mais il utilise GDK. Le mieux reste d'utiliser cairo. Tu dois récupérer le contexte cairo avec gdk_cairo_create, tu peux ensuite dessiner à l'intérieur en utilisant l'API cairo.

[Gamall]

Salut, merci d'avoir répondu

Oui, finalement, j'utilise cairo, j'ai fini par trouver des petits bouts de codes par ci par là, c'est deja mieux

Sinon, pour GdkPixbuf, j'ai essayé de comprendre la doc, mais c'était beaucoup trop compliqué, pareil pour les drawing area

[gerald3d]

Un petit tour sur la faq peut être

[Gamall]

Moui, ben ça reste quand même très obscur

En fait ce que je fais, je trouve des petits bouts de code sur cairo, par ci par là, je regarde la doc, et j'essai de bidouiller plus ou moins

Par exemple, en partant de ce code trouvé dans la FAQ, eh ben je suis arrivé à ce 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
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
#include <gtk/gtk.h>
#include <math.h>
#include <cairo.h>
 
#define WIDTH 640
#define HEIGHT 480
 
 
static gboolean
expose (GtkWidget * widget, GdkEventExpose * event, gpointer userdata)
{
  int x_zero = WIDTH/2;
  int y_zero = HEIGHT/2;
 
  cairo_surface_t * surface = NULL;
 
  cairo_t *cr = NULL;
  gint x[3] =
  {
	  -WIDTH / 2,
	  -WIDTH / 2,
	  -WIDTH / 2
  };
  gint y[3] = {0};
 
 
  cr = gdk_cairo_create (widget->window);
 
  cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
  cairo_paint (cr);
  cairo_set_source_rgba (cr, 1, 0.2, 0.2, 0.6);
 
  surface = cairo_get_target(cr);
 
  cairo_surface_set_device_offset(surface, WIDTH/2, HEIGHT/2);
 
  while (x[0] != WIDTH)
    {
      x[0] = x[2];
      x[1] = x[0] + 1;
      x[2] = x[1] + 2;
 
      /* On calcul y = f(x) tous les trois points */
      y[0] = pow(0.03*x[0] , 3);
      y[1] = pow(0.03*x[1] , 3);
      y[2] = pow(0.03*x[2] , 3);
 
      /* On affiche le morceau de courbe qui
       * passe par ces trois points
       */
      cairo_curve_to (cr,
		      x[0],   -y[0],
		      x[1],   -y[1], 
		      x[2],   -y[2]
		      );
    }
  cairo_stroke (cr);
 
  cairo_destroy (cr);
  return FALSE;
}
 
 
int
main (int argc, char **argv)
{
  GtkWidget *window = NULL;
 
  gtk_init (&argc, &argv);
 
  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  gtk_window_set_default_size (GTK_WINDOW (window), WIDTH, HEIGHT);
  gtk_window_set_title (GTK_WINDOW (window), "Affichage de courbe");
  g_signal_connect (G_OBJECT (window), "delete-event", gtk_main_quit, NULL);
 
 
  gtk_widget_set_app_paintable (window, TRUE);
 
  g_signal_connect (G_OBJECT (window), "expose-event", G_CALLBACK (expose),
		    NULL);
 
  gtk_widget_show_all (window);
  gtk_main ();
 
  return 0;
}

Bon, alors maintenant, je cherche à afficher les axes verticaux et horizontaux, mais je ne trouve pas une fonction pour afficher une droite.

.

[liberforce]

Tu crées d'abord un chemin, par exemple avec cairo_arc pour faire un cercle, ou cairo_move_to + cairo_line_to pour faire une ligne. Ensuite tu appelles cairo_stroke pour tracer un chemin. Si tu veux remplir le chemin, c'est cairo_fill.

Pour tout ce qui est transformations (changement de repères avec cairo_translate et cairo_scale) consulte le chapitre sur les transformations.

http://library.gnome.org/devel/cairo...ormations.html

Cela te permettra de ne pas avoir une fenêtre de taille fixe comme actuellement (tu peux récupérer la taille du widget et mettre à l'échelle), et pouvoir dessiner avec les coordonnées des points dans ton repère, plutôt que dans le repère "pixels".