Discussion :

[pvincent]

Bonjour à tous,

GDK2 (comme la Xlib) permet de définir des "Graphics Contexts" (GdkGC) avec un mode XOR (GDK_XOR) qui permet de tracer de façon simple une ligne visible quelque soit la ou les couleurs du fond et d'en faire une ligne élastique (rubber line) que l'on peut modifier avec la souris en consommant un minimum de ressources.

Il semble que cette possibilité, qui n'existe pas dans Cairo a aussi disparu de GDK3 et je me demande comment remplacer cette fonctionnalité.

Je ne suis pas le seul à m'être posé cette question (e.g. http://comments.gmane.org/gmane.comp...vel.apps/28708) mais je n'ai pas trouvé de réponse plus récente ni vraiment satisfaisante sur le Net (compliqué, scintillement, etc).

La raison de cette suppression (comme suggéré ici http://marc.info/?l=cairo&m=136782565609665&w=2) semble être que ni PDF, ni Postscript ne permettent de sonder l'état d'un pixel donné. Si cet argument me semble valable pour sortir une page sur une imprimante, cette omission est bien gênante quand il s'agit d'obtenir sur l'écran un effet interactif provisoire.

Je me demande si le plus simple n'est pas de définir une ou des fonctions court-circuitant Cairo pour accéder directement à l'écran puisqu'en aucun cas, je n'utiliserai cette possibilité pour produire le dessin définitif.

Je suis intéressé si vous avez des idées à ce sujet ou des références plus récentes que le post cité en référence.

[gerald3d]

Je ne sais pas si ma réponse correspond bien à ce que tu cherches mais il existe dans Cairo des fonctions pemettant le XOR.

Tu peux utiliser cairo_region_xor(); ou cairo_region_xor_rectangle(); pour effectuer cette opération.

Tu peux aussi, et je pense qu'elle peut mieux correspondre à tes besoins, définir le type d'opération que tu désires effectuer avant tout dessin grâce à la fonction

Code :

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

void cairo_set_operator  (cairo_t *cr, cairo_operator_t op);

cairo_operator_t peut prendre la valeur CAIRO_OPERATOR_XOR.

[pvincent]

Merci pour ton intérêt.

Ce post http://comments.gmane.org/gmane.comp.lib.cairo/1320 avait d'abord attiré mon attention et incité au pessimisme. J'avoue que je ne sais pas vraiment ce que veut dire ceci

An important point here is that CAIRO_OPERATOR_XOR is the Porter/Duff
XOR compositing operator [1]. It is not a bitwise XOR operator.

mais il me semble que cela va à l'encontre de ce que je cherche à faire.

Je n'ai pas l'impression que ce soit vraiment ce que je recherche aussi car il me semble que le XOR sera pratiqué sur tout un rectangle et non seulement sur la ligne, qui est en général inclinée, donc ne se réduit pas à un rectangle dont les cotés sont // aux bords de l'écran.
Surtout, si je pense que cela permet peut-être de déplacer un objet sur un fond en restituant l'état initial du fond à chaque déplacement: c'est quand même bien lourd et je ne vois pas comment je pourrai assurer le tracé initial de la ligne en assurant sa visibilité quelque soit le fond.
De plus, le passé de GraceGTK induit des lourdeurs dans la programmation qui rendent la mise en oeuvre compliquée et risquent d'entraîner plus de changements que je ne souhaite. C'est pourquoi dans mon cas j'envisage de me passer de Cairo pour cette action particulière.

[gerald3d]

Merci pour ton intérêt.

Ce post http://comments.gmane.org/gmane.comp.lib.cairo/1320 avait d'abord attiré mon attention et incité au pessimisme. J'avoue que je ne sais pas vraiment ce que veut dire ceci

mais il me semble que cela va à l'encontre de ce que je cherche à faire.

En effet tu as raison.

Pour ma part je travaille directement sur le tampon mémoire d'une cairo_surface. C'est peut-être le chemin qu'il te faut emprunter...

[pvincent]

Pour ma part je travaille directement sur le tampon mémoire d'une cairo_surface.

Je crois que tu as raison et je vais creuser dans cette direction.

[pvincent]

Finalement, je me suis orienté vers l'attaque directe, ce qui semble donner les résultats attendus avec ce petit programme de test suivant:

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
 
/* Un exemple pour utiliser le "Graphic Context" XOR directement
 * sans passer par GDK (les GdkGC n'existent pas dans GTK-3)
 * 
 * En deplacant la souris avec un bouton enfonce',
 * on fait apparaitre une ligne elastique tracee avec le mode XOR
 *
 * Fonctionne sous X11 (GTK-2 ou GTK-3: adapter la Makefile)
 * ou MSWindows (teste' seulement pour GTK-2)
 *  MANQUE LE CAS DE MAC OS-X AVEC QUARTZ: AVIS AUX AMATEURS.
 *
 * Compiler avec ( -lX11 avec la Xlib only)
 * Pour GTK-2 
 *   gcc   -g -Wall `pkg-config --cflags  gtk+-2.0`  xor_gtk.c  `pkg-config --libs gtk+-2.0` -lX11
 * et GTK-3
 *   gcc   -g -Wall `pkg-config --cflags  gtk+-3.0`  xor_gtk.c  `pkg-config --libs gtk+-3.0` -lX11
 */
 
#include <math.h>
#include <gtk/gtk.h>
#include <gdk/gdk.h>
#include <cairo.h>
 
/* Taille de la fenêtre en pixels */
static int ix = 800;
static int iy = 500;
 
static GdkDisplay *gg_disp;
static GdkWindow *gg_win;
 
#if defined (GDK_WINDOWING_X11)
  #include <X11/Xlib.h>
  #include <gdk/gdkx.h>
  #include <cairo/cairo-xlib.h>
  static Display  *x_disp;
  static Window   x_canvas;
  static GC       x_gc_xor;
#elif defined (GDK_WINDOWING_WIN32)
  #define _WIN32_WINNT 0x0500
  #include <windows.h>
  #include <gdk/gdkwin32.h>
  static HWND hwnd;
  static HDC  hdc ,hdc_xor;
#endif
 
  /* 
   * Creation de l'image de fond 
   */
#if (GTK_MAJOR_VERSION == 2) 
gboolean ev_expose (GtkWidget *w ,GdkEventExpose *event ,gpointer data)
{
  cairo_t *cr;
  cr = gdk_cairo_create (gtk_widget_get_window(w));
#else
gboolean ev_expose (GtkWidget *w ,cairo_t *cr ,gpointer data)
{
#endif
  gdouble dx ,dy;
  dx = (gdouble)ix / 6.0;
  dy = (gdouble)iy / 6.0;
  /* rectangle noir */
  cairo_set_source_rgb (cr ,0.0 ,0.0, 0.0);
  cairo_rectangle (cr ,dx ,dy ,dx ,dy);
  cairo_fill (cr);
  /* cercle rouge */
  cairo_set_source_rgb (cr ,1.0 ,0.0, 0.0);
  cairo_arc (cr ,3*dx ,1.5*dy ,dx/2.0 ,0.0 ,6.2831853);
  cairo_fill (cr);
  /* cercle vert */
  cairo_set_source_rgb (cr ,0.0 ,1.0, 0.0);
  cairo_arc (cr ,1.5*dx ,3*dy ,dx/2.0 ,0.0 ,6.2831853);
  cairo_fill (cr);
  /* rectangle bleu */
  cairo_set_source_rgb (cr ,0.0 ,0.0, 1.0);
  cairo_rectangle (cr ,2.5*dx ,2.5*dy ,dx ,dy);
  cairo_fill (cr);
  return TRUE;
}
 
/*
 *  Reponses aux actions avec la souris
 */
static int old_x ,old_y ,button_pressed = FALSE;;
 
gint ev_button_press (GtkWidget *w ,GdkEvent *event ,gpointer data)
{
  gint x ,y;
  x = (gint) event->button.x;
  y = (gint) event->button.y;
#ifdef GDK_WINDOWING_X11
  XDrawLine (x_disp ,x_canvas ,x_gc_xor ,0 ,0 ,x ,y);
#elif defined (GDK_WINDOWING_WIN32)
  MoveToEx (hdc ,0 ,0 ,(LPPOINT) NULL);
  LineTo (hdc ,x ,y);
#endif
  old_x = x;
  old_y = y;
  button_pressed = TRUE;
  return TRUE;
}
 
gint ev_button_release (GtkWidget *w ,GdkEvent *event ,gpointer data)
{
  gint x ,y;
  x = (gint) event->button.x;
  y = (gint) event->button.y;
#ifdef GDK_WINDOWING_X11
  XDrawLine (x_disp ,x_canvas ,x_gc_xor ,0 ,0 ,old_x ,old_y);
#elif defined (GDK_WINDOWING_WIN32)
  MoveToEx (hdc ,0 ,0 ,(LPPOINT) NULL);
  LineTo (hdc ,old_x ,old_y);
#endif
  button_pressed = FALSE;
  return TRUE;
}
 
int ev_pointer_motion (GtkWidget *w ,GdkEvent *event ,gpointer data)
{
  int x ,y;
  if (button_pressed ) {
    x = (gint) event->motion.x;
    y = (gint) event->motion.y;
#ifdef GDK_WINDOWING_X11
    XDrawLine (x_disp ,x_canvas ,x_gc_xor ,0 ,0 ,old_x ,old_y);
    XDrawLine (x_disp ,x_canvas ,x_gc_xor ,0 ,0 ,x ,y);
#elif defined (GDK_WINDOWING_WIN32)
  MoveToEx (hdc ,0 ,0 ,(LPPOINT) NULL);
  LineTo (hdc ,old_x ,old_y);
  MoveToEx (hdc ,0 ,0 ,(LPPOINT) NULL);
  LineTo (hdc ,x ,y);
#endif
    old_x = x;
    old_y = y;
  }
  return TRUE;
}
 
/*
 *  Programme principal
 */
int main( int   argc ,char *argv[] )
{
  GtkWidget *w_main_window ,*w_canvas;
#ifdef GDK_WINDOWING_X11
  XGCValues x_gc_val;
  unsigned long valuemask;
#endif
  gtk_init (&argc ,&argv);
  printf ("GTK_MAJOR_VERSION = %d\n" ,GTK_MAJOR_VERSION);
  w_main_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);  
  gg_disp       = gdk_display_get_default ();
  w_canvas      = gtk_drawing_area_new (); 
  gtk_widget_set_size_request (w_main_window ,ix ,iy);
  gtk_container_add           (GTK_CONTAINER (w_main_window) ,w_canvas );
  gtk_widget_add_events (w_canvas 
                         , GDK_BUTTON_PRESS_MASK
                         | GDK_BUTTON_RELEASE_MASK
                         | GDK_POINTER_MOTION_MASK
                         );
  gtk_widget_show_all (w_main_window);
  gg_win        = gtk_widget_get_window (w_canvas);
#ifdef GDK_WINDOWING_X11
  x_disp        = gdk_x11_display_get_xdisplay (gg_disp);
#if (GTK_MAJOR_VERSION == 2) 
    x_canvas = gdk_x11_drawable_get_xid (gg_win);
#else
    x_canvas = gdk_x11_window_get_xid (gg_win);
#endif
  x_gc_val.function   = GXxor;
  x_gc_val.foreground = 0xffffff;
  x_gc_val.line_width = 4;
  valuemask = GCFunction | GCForeground | GCLineWidth;
  x_gc_xor = XCreateGC (x_disp ,x_canvas ,valuemask ,&x_gc_val);
#elif defined (GDK_WINDOWING_WIN32)
  hwnd = GDK_WINDOW_HWND (gg_win);
  hdc  = GetDC (hwnd);
  hdc_xor = CreateCompatibleDC (hdc);
  SetROP2       (hdc ,R2_XORPEN);
  SelectObject  (hdc ,GetStockObject(DC_PEN));
  SetDCPenColor (hdc, RGB           (0,255,0));
#endif
#if (GTK_MAJOR_VERSION == 2) 
  g_signal_connect (w_canvas       ,"expose_event"         ,G_CALLBACK (ev_expose)         ,NULL);
#else
  g_signal_connect (w_canvas       ,"draw"                 ,G_CALLBACK (ev_expose)         ,NULL);
#endif
  g_signal_connect (w_canvas       ,"button-press-event"   ,G_CALLBACK (ev_button_press)   ,NULL);
  g_signal_connect (w_canvas       ,"button-release-event" ,G_CALLBACK (ev_button_release) ,NULL);
  g_signal_connect (w_canvas       ,"motion-notify-event"  ,G_CALLBACK (ev_pointer_motion) ,NULL);
  g_signal_connect (w_main_window  ,"delete_event"         ,G_CALLBACK (gtk_main_quit)     ,NULL);
  gtk_widget_show_all (w_main_window);
  gtk_main ();
  return 0;
}

Je ne mets pas "résolu" car j'aimerai bien avoir une version Mac/Quartz, mais comme je n'ai pas de machine Apple et ne connaît rien à Quartz, ce serait bien si quelqu'un traitai ce cas.

Note: les changements de couleurs diffèrent sous X11 et sous Windows, mais cela n'est pas gênant pour ce que je veux faire.