1
2
3
4
5
6
7
static GtkWidget *boutsfac;
static GtkWidget *boutsfcli;
static GtkWidget *boutsprod;
static GtkWidget *boutliprod;
static GtkWidget *boutopen;
static GtkWidget *boutlicli;
static GtkWidget *labdb;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
void deactiv_bmenu()
{
 gtk_widget_set_sensitive(boutsfac,FALSE);
 gtk_widget_set_sensitive(boutlicli,FALSE);
 gtk_widget_set_sensitive(boutsfcli,FALSE);
 gtk_widget_set_sensitive(boutsprod,FALSE);
 gtk_widget_set_sensitive(boutliprod,FALSE);
 gtk_widget_set_sensitive(cbparam,FALSE);
}
 
void activ_bmenu()
{
 gtk_widget_set_sensitive(boutsfac,TRUE);
 gtk_widget_set_sensitive(boutlicli,TRUE);
 gtk_widget_set_sensitive(boutsfcli,TRUE);
 gtk_widget_set_sensitive(boutsprod,TRUE);
 gtk_widget_set_sensitive(boutliprod,TRUE);
 gtk_widget_set_sensitive(cbparam,TRUE);
}

1
2
3
4
5
6
7
GtkWidget
     GtkContainer
          GtkBin
          GtkBox
          GtkCList
          GtkFixed
          ...

1
2
3
void
gtk_widget_set_name (GtkWidget *widget,
                     const gchar *name);

1
2
const gchar *
gtk_widget_get_name (GtkWidget *widget);

1
2
3
4
void
gtk_container_foreach (GtkContainer *container,
                       GtkCallback callback,
                       gpointer callback_data);

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
static void
callback_find_widget (GtkWidget *widget, gpointer data)
{
  /* Création d'une structure interne pour pouvoir récupérer les différents
   * widgets de l'interface mais aussi le résultat de la comparaison des noms.
   */
  typedef struct
  {
    GtkWidget *widget;
    const gchar *name;
    gboolean resultcomp;
    GtkWidget *ptrfind;
  } Sresult;
 
  Sresult *result = (Sresult*)data;
 
  if (g_strcmp0 (gtk_widget_get_name (widget), result->name)==0)
  {
    result->resultcomp = TRUE;
    result->ptrfind = widget;
  }
 
  result->widget = widget;
}
 
GtkWidget *
get_widget_from_window (GtkWidget *winp, const gchar *name)
{
  /* Retourne NULL si le widget n'est pas valide */
  g_return_val_if_fail (GTK_IS_WIDGET (winp), NULL);
  /* Retourne NULL si name = NULL */
  g_return_val_if_fail (name!=NULL, NULL);
 
  /* Création d'uns structure interne pour pouvoir récupérer les différents
   * widgets de l'interface mais aussi le résultat de la comparaison des noms.
   */
  typedef struct
  {
    GtkWidget *widget;
    const gchar *name;
    gboolean resultcomp;
    GtkWidget *ptrfind;
  } Sresult;
 
  Sresult result;
  GtkWidget *widget = NULL;
 
  /* Initialisation de result */
  result.widget = winp;
  result.name = name;
  result.resultcomp = FALSE;
  widget = winp;
  while (1)
    {
       if (GTK_IS_CONTAINER (widget))
	gtk_container_foreach (GTK_CONTAINER (widget),(GtkCallback)callback_find_widget, &result);
 
      if (result.resultcomp == TRUE)
	return result.ptrfind;
      else
	{
	  /* Permet de sortir de la boucle lorsque tous les widgets ont été parcourus */
	  if (widget==result.widget)
	    break;
	  else
	    widget = result.widget;
	}
    }
 
  return NULL;
}

1
2
3
4
5
6
...
boutsfac = gtk_button_new_with_label("Saisie Facture");
gtk_widget_set_size_request(boutsfac, 120, 25);
gtk_fixed_put(GTK_FIXED(frawp), boutsfac,20,py);
gtk_widget_set_name (boutsfac, "boutsfac");
...

1
2
3
4
  if (get_widget_from_window (winp, "boutsfac"))
    g_printerr ("widget trouvé\n");
  else
    g_printerr ("widget non trouvé !!!\n");

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
/* static GtkWidget *boutsfac; */
static GtkWidget *boutsfcli;
static GtkWidget *boutsprod;
static GtkWidget *boutliprod;
static GtkWidget *boutopen;
static GtkWidget *boutlicli;
static GtkWidget *labdb;

void deactiv_bmenu()
{
  gtk_widget_set_sensitive(get_widget_from_window (winp, "boutsfac"), FALSE);
  gtk_widget_set_sensitive(boutlicli,FALSE);
  gtk_widget_set_sensitive(boutsfcli,FALSE);
  gtk_widget_set_sensitive(boutsprod,FALSE);
  gtk_widget_set_sensitive(boutliprod,FALSE);
  gtk_widget_set_sensitive(cbparam,FALSE);
}

void activ_bmenu()
{
  gtk_widget_set_sensitive(get_widget_from_window (winp, "boutsfac"), TRUE);
  gtk_widget_set_sensitive(boutlicli,TRUE);
  gtk_widget_set_sensitive(boutsfcli,TRUE);
  gtk_widget_set_sensitive(boutsprod,TRUE);
  gtk_widget_set_sensitive(boutliprod,TRUE);
  gtk_widget_set_sensitive(cbparam,TRUE);
}

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
/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*-  */
/*
 * main.c
 * Copyright (C) 2013 Gerald Dumas <gerald.dumas@laposte.net>
 *
 * tableur is free software: you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * tableur is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License along
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#include <config.h>
#include <gtk/gtk.h>
 
gboolean draw_child_widget (GtkWidget *ChildWidget, cairo_t *cr, GdkRGBA *color)
{
	/* Dans cette fonction nous accédons au context cairo de chaque widget enfant inséré dans le GtkGrid.
	 * Il nous suffit maintenant de dessiner ce que l'on veut dessus.
	 * La couleur de chaque encadrement est récupérée dans le pointeur utilisateur.
	 */
	gdouble dash[2];
	gint width = gtk_widget_get_allocated_width (ChildWidget);
	gint height = gtk_widget_get_allocated_height (ChildWidget);
 
	dash[0]=5;
	dash[1]=10;
	cairo_set_dash (cr, dash, 1, 0); // Affectation du trait discontinue déclaré dans le tableau dash
	cairo_set_line_width (cr, 1); // Epaisseur du trait
	cairo_set_source_rgb (cr, color->red, color->green, color->blue); // Affectation de la couleur récupérée en tant que donnée utilisateur
 
	/*Dessin d'un trait autour du widget*/
	cairo_move_to (cr, 0, 0);
	cairo_line_to (cr, width, 0);
	cairo_line_to (cr, width, height);
	cairo_line_to (cr, 0, height);
	cairo_line_to (cr, 0, 0);
	cairo_stroke (cr);
 
	return FALSE;
}
 
int
main (int argc, char *argv[])
{
	GtkWidget *MainWindow=NULL;
	GtkWidget *Grid = NULL;
	GtkWidget *ChildWidget = NULL;
	int i, j, k=0;
	gchar *CaseNumber = NULL;
 
	/* Déclaration de trois couleurs primaires pour exemple. */
	GdkRGBA color [3];
	color[0].red=1; color[0].green=0; color[0].blue=0;
	color[1].red=0; color[1].green=1; color[1].blue=0;
	color[2].red=0; color[2].green=0; color[2].blue=1;
 
	gtk_init (&argc, &argv);
 
	/*Création d'une fenêtre principale*/
	MainWindow = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 
	/*Création d'une grille dont les cases sont homogènes*/
	Grid = gtk_grid_new ();
	gtk_grid_set_row_homogeneous (GTK_GRID(Grid), TRUE);
	gtk_grid_set_column_homogeneous (GTK_GRID(Grid), TRUE);
	gtk_container_add (GTK_CONTAINER(MainWindow), Grid);
 
	for (j=0; j<3; j++)
		for (i=0; i<3; i++)
		{
			/*Initialisation d'un GtkLabel comme widget enfant*/
			CaseNumber = g_strdup_printf ("(%d,%d)", i,j);
			ChildWidget = gtk_label_new (CaseNumber);
			g_free (CaseNumber);
 
			/*On affecte une fonction callback pour chaque widget enfant accrochée au signal "draw"*/
			g_signal_connect (G_OBJECT (ChildWidget), "draw", (GCallback)draw_child_widget, &color[k]);
 
			/*Finalement on insère le widget enfant dans la grille*/
			gtk_grid_attach (GTK_GRID(Grid), ChildWidget, i, j, 1, 1);
 
			// Pour que la couleur affectée soit cyclique
			if (k<2) k++; else k=0;
		}
 
	g_signal_connect (G_OBJECT (MainWindow), "destroy", (GCallback)gtk_main_quit, NULL);
	g_signal_connect (G_OBJECT (MainWindow), "delete-event", (GCallback)gtk_main_quit, NULL);
 
	gtk_widget_show_all (MainWindow);
 
	gtk_main ();
 
	return 0;
}

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
#include <stdlib.h>
#include <gtk/gtk.h>
 
typedef struct
{
  GtkWidget *coordx, *coordy;
} SCoord;
 
gboolean
g_callback_draw (GtkWidget    *widget, cairo_t *cr, SCoord *coord)
{
  GdkWindow *root = NULL;
  gint x, y;
 
  // Récupération de la fenêtre root
  root = gdk_get_default_root_window ();
  if (root==NULL) g_printerr ("root = NULL !!!");
 
  // Récupération du pointeur de la souris
  GdkDevice *pointer = gdk_device_manager_get_client_pointer (gdk_display_get_device_manager (gdk_window_get_display (root)));
 
  // Récupération des coordonnées de la souris
  gdk_window_get_device_position (root, pointer, &x, &y, NULL);
 
  // Mise à jour des GtkLabel pour afficher les coordonnées.
  gchar *text_x = g_strdup_printf("%d", x);
  gchar *text_y = g_strdup_printf("%d", y);
  gtk_label_set_text (GTK_LABEL (coord->coordx), text_x);
  gtk_label_set_text (GTK_LABEL (coord->coordy), text_y);
  g_free(text_x);
  g_free(text_y);
 
  return FALSE;
}
 
int
main(int argc, char** argv)
{
  GtkWidget *window = NULL;
  GtkWidget *grid = NULL;
  GtkWidget *label = NULL;
  SCoord coord;
 
  // Initialisation gtk
  gtk_init(&argc, &argv);
 
  // Creation fenetre
  window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  gtk_window_set_title(GTK_WINDOW(window), "Test capture évènements souris");
  gtk_window_set_default_size(GTK_WINDOW(window), 400, 200);
  gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER_ALWAYS);
 
  // Connexion du signal "destroy" pour fermer l'application
  g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), NULL);
 
  // Création d'une grille pour afficher les coordonnées de la souris en temps réel.
  grid = gtk_grid_new ();
  gtk_container_add (GTK_CONTAINER(window), grid);
 
  label = gtk_label_new ("coordonnées souris :");
  gtk_grid_attach (GTK_GRID(grid), label, 0, 0, 4, 1);
  label = gtk_label_new (",");
  gtk_grid_attach (GTK_GRID(grid), label, 1, 1, 1, 1);
 
  coord.coordx = gtk_label_new ("0");
  gtk_grid_attach (GTK_GRID(grid), coord.coordx, 0, 1, 1, 1);
 
  coord.coordy = gtk_label_new ("0");
  gtk_grid_attach (GTK_GRID(grid), coord.coordy, 2, 1, 1, 1);
 
  // Connexion du signal "draw". Dans ce callback on va pouvoir accéder à la fenêtre root
  g_signal_connect(G_OBJECT(window), "draw", G_CALLBACK(g_callback_draw), &coord);
 
  // Affichage de tout
  gtk_widget_show_all(window);
 
  gtk_main();
 
  return EXIT_SUCCESS;
}