Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

  1. #1
    Membre confirmé
    Profil pro
    Retraité
    Inscrit en
    novembre 2009
    Messages
    301
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : novembre 2009
    Messages : 301
    Points : 544
    Points
    544

    Par défaut A la recherche du XOR perdu

    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.
    GraceGTK: a plotting tool at https://sourceforge.net/projects/gracegtk

  2. #2
    Membre expert
    Avatar de gerald3d
    Homme Profil pro
    Conducteur de train
    Inscrit en
    février 2008
    Messages
    1 969
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 48
    Localisation : France, Côte d'Or (Bourgogne)

    Informations professionnelles :
    Activité : Conducteur de train
    Secteur : Transports

    Informations forums :
    Inscription : février 2008
    Messages : 1 969
    Points : 3 731
    Points
    3 731
    Billets dans le blog
    4

    Par défaut

    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.
    Utilisation de Glade avec Gtk+ - N'oubliez pas de consulter les FAQ Gtk et les cours et tutoriels Gtk

  3. #3
    Membre confirmé
    Profil pro
    Retraité
    Inscrit en
    novembre 2009
    Messages
    301
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : novembre 2009
    Messages : 301
    Points : 544
    Points
    544

    Par défaut

    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.
    GraceGTK: a plotting tool at https://sourceforge.net/projects/gracegtk

  4. #4
    Membre expert
    Avatar de gerald3d
    Homme Profil pro
    Conducteur de train
    Inscrit en
    février 2008
    Messages
    1 969
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 48
    Localisation : France, Côte d'Or (Bourgogne)

    Informations professionnelles :
    Activité : Conducteur de train
    Secteur : Transports

    Informations forums :
    Inscription : février 2008
    Messages : 1 969
    Points : 3 731
    Points
    3 731
    Billets dans le blog
    4

    Par défaut

    Citation Envoyé par pvincent Voir le message
    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...
    Utilisation de Glade avec Gtk+ - N'oubliez pas de consulter les FAQ Gtk et les cours et tutoriels Gtk

  5. #5
    Membre confirmé
    Profil pro
    Retraité
    Inscrit en
    novembre 2009
    Messages
    301
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : novembre 2009
    Messages : 301
    Points : 544
    Points
    544

    Par défaut

    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.
    GraceGTK: a plotting tool at https://sourceforge.net/projects/gracegtk

  6. #6
    Membre confirmé
    Profil pro
    Retraité
    Inscrit en
    novembre 2009
    Messages
    301
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : novembre 2009
    Messages : 301
    Points : 544
    Points
    544

    Par défaut

    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.
    GraceGTK: a plotting tool at https://sourceforge.net/projects/gracegtk

  7. #7
    Membre confirmé
    Profil pro
    Retraité
    Inscrit en
    novembre 2009
    Messages
    301
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : novembre 2009
    Messages : 301
    Points : 544
    Points
    544

    Par défaut

    Je reviens sur ce vieux post pour donner mes conclusions: court-circuiter GTK/GDK n'est pas une bonne idée pour deux raisons:
    1. cela crée des problèmes quasi-insolubles de priorité avec les rafraîchissements dû aux callbacks
    2. en passant de Xorg à Wayland, les GC disparaissent

    Je me suis donc rabattu sur la méthode de contournement adoptée par Gimp: pour que la ligne soit visible quelque soit le fond, on trace une ligne noire épaisse et par dessus une ligne blanche plus étroite. C'est un mode dégradé car la ligne produite est forcément plus épaisse...
    D'autre part, j'ai constaté dans Gimp que, si on a une image fortement agrandie, la ligne élastique à du mal à suivre la souris: je pense que c'est un problème de rafraîchissement et de clipping.
    Dans l'exemple ci-dessous, quand j'ai essayé d'utiliser un rectangle de clip, cela n'a pas fonctionné correctement donc à chaque mouvement de la souris, je rafraîchis la totalité de l'image.
    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
     
    /* Un exemple pour tracer un segment elastique  <<à la Gimp>>:
     *
     * Tracer une ligne noire épaisse et une ligne blanche par dessus
     * en rafraichissant l'image de fond à chaque déplacement de la souris.
     *
     * Compiler avec ( -lX11 avec la Xlib only)
     * Pour GTK-2 
     *   gcc   -g -Wall `pkg-config --cflags  gtk+-2.0`  segment_elastique.c  `pkg-config --libs gtk+-2.0` -lX11
     * et GTK-3
     *   gcc   -g -Wall `pkg-config --cflags  gtk+-3.0`  segment_elastique.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 GtkWidget *w_main_window ,*w_canvas;
    static GdkWindow *gg_win;
    static cairo_surface_t *surf_ecran;
    static cairo_surface_t *surf_fond;
     
    static int button_pressed = FALSE;
    static gdouble x_init ,y_init;
    //A26 static gdouble old_x ,old_y;
     
    #define MIN2(a, b) (((a) < (b)) ? a : b)
    #define MAX2(a, b) (((a) > (b)) ? a : b)
     
    /* 
     * On affiche l'image de fond 
     */
    #if (GTK_MAJOR_VERSION == 2) 
    gboolean ev_expose (GtkWidget *w ,GdkEventExpose *event ,gpointer data)
    {
      cairo_t *cr = gdk_cairo_create (gtk_widget_get_window (w_canvas));
      cairo_set_source_surface (cr ,surf_fond ,0 ,0);
      cairo_paint              (cr);
      cairo_destroy            (cr);
      return TRUE;
    }
    #else
    gboolean ev_draw (GtkWidget *w ,cairo_t *cr ,gpointer data)
    {
      cairo_set_source_surface (cr ,surf_fond ,0 ,0);
      cairo_paint              (cr);
      return TRUE;
    }
    #endif
     
    /*
     * Restore l'image de fond initiale
     */
    void restore_fond (cairo_t *cr ,gdouble x ,gdouble y)
    {
      /* UNE TENTATIVE D'UTILISER UN RECTANGLE DE CLIP */
    //A26   gdouble x0 =  x_init - 2.0;
    //A26   gdouble y0 =  y_init - 2.0;
    //A26   gdouble dx =  (x - x_init) + 4.0;
    //A26   gdouble dy =  (y - y_init) + 4.0;
    //A26 
    //A26   printf ("restore_fond: x0=%g dx=%g x=%g y0=%g dy =%g y=%g\n" ,x0 ,dx ,x ,y0 ,dy ,y);
    //A26 
      //A26 CE CLIPPING NE MARCHE PAS POUR LA DIRECTION VERTICALE 
    //A26   cairo_rectangle (cr ,x0 ,y0 ,dx ,dy);
    //A26   cairo_clip      (cr);
     
      cairo_set_source_surface (cr ,surf_fond ,0 ,0);
      cairo_paint              (cr);
    //A26   cairo_reset_clip         (cr);
    }
     
    void draw_line (cairo_t *cr ,gdouble x ,gdouble y)
    {
      cairo_set_line_width  (cr ,3.0);                 /* large black line */
      cairo_set_source_rgba (cr ,0.0 ,0.0 ,0.0 ,1.0);
      cairo_move_to         (cr ,x_init ,y_init);
      cairo_line_to         (cr ,x ,y);
      cairo_stroke          (cr);
      cairo_set_line_width  (cr ,1.0);                 /* thin white line */
      cairo_set_source_rgba (cr ,1.0 ,1.0 ,1.0 ,1.0);
      cairo_move_to         (cr ,x_init ,y_init);
      cairo_line_to         (cr ,x ,y);
      cairo_stroke          (cr);
    }
     
    /*
     *  Reponses aux actions avec la souris
     */
     
     
    /* Draw the line on w_canvas */
    gint ev_button_press (GtkWidget *w ,GdkEvent *event ,gpointer data)
    {
      gdouble x = event->button.x;
      gdouble y = event->button.y;
      cairo_t *cr = gdk_cairo_create (gtk_widget_get_window (w_canvas));
      x_init = x;
      y_init = y;
      draw_line (cr ,x ,y);
    //A26   old_x = x;
    //A26   old_y = y;
      cairo_destroy (cr);
      button_pressed = TRUE;
      return TRUE;
    }
     
    /* redraw surf_fond without the line */
     
    gint ev_button_release (GtkWidget *w ,GdkEvent *event ,gpointer data)
    {
      cairo_t *cr = gdk_cairo_create (gtk_widget_get_window (w_canvas));
      restore_fond  (cr ,((GdkEventMotion *)event)->x ,((GdkEventMotion *)event)->y);
      cairo_destroy (cr);
      button_pressed = FALSE;
      return TRUE;
    }
     
    int ev_pointer_motion (GtkWidget *w ,GdkEventMotion *event ,gpointer data)
    {
      if (button_pressed ) {
        cairo_t *cr = gdk_cairo_create (gtk_widget_get_window (w_canvas));
        restore_fond  (cr ,((GdkEventMotion *)event)->x ,((GdkEventMotion *)event)->y);
        draw_line     (cr ,event->x ,event->y);
        cairo_destroy (cr);
      }
      return TRUE;
    }
     
    /*
     *  Programme principal
     */
    int main( int   argc ,char *argv[] )
    {
      gdouble w ,h ,dx ,dy;
      cairo_t *cr;
      gtk_init (&argc ,&argv);
      printf ("GTK_MAJOR_VERSION = %d\n" ,GTK_MAJOR_VERSION);
      printf ("GTK_MINOR_VERSION = %d\n" ,GTK_MINOR_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);
     
    #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_draw)           ,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);
      /* Creation de surf_fond, le buffer pour l'image de fond */
      cr          = gdk_cairo_create (gtk_widget_get_window (w_canvas));
      surf_ecran  = cairo_get_target (cr);
      surf_fond   = cairo_surface_create_similar (surf_ecran ,CAIRO_CONTENT_COLOR_ALPHA ,ix ,iy);
      cairo_destroy (cr);
      /* on dessine le fond dans surf_fond */
      w = (gdouble)ix;
      h = (gdouble)iy;
      cr = cairo_create (surf_fond);
      /* set the background color */
      cairo_set_source_rgb (cr ,1.0 ,1.0 ,1.0);
      cairo_rectangle      (cr ,0 ,0 ,w ,h);
      cairo_fill           (cr);
      dx = w / 6.0;
      dy = h / 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);
      /* on copie l'image dans surf_fond */
      cairo_set_source_surface (cr ,surf_fond ,0 ,0);
      cairo_paint              (cr);
      cairo_destroy            (cr);
     
      gtk_main ();
      return 0;
    }
    GraceGTK: a plotting tool at https://sourceforge.net/projects/gracegtk

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. à la recherche du scrollbar perdu
    Par aertys dans le forum VB.NET
    Réponses: 17
    Dernier message: 20/05/2013, 14h12
  2. rechercher un fichier perdu
    Par laurentSc dans le forum Windows 7
    Réponses: 1
    Dernier message: 03/05/2013, 22h45
  3. recherche de fichier perdu
    Par arm3366 dans le forum Linux
    Réponses: 2
    Dernier message: 01/09/2011, 15h24
  4. [Dojo] A la recherche du livre perdu
    Par fayred dans le forum Bibliothèques & Frameworks
    Réponses: 2
    Dernier message: 04/07/2007, 08h32

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo