# compiler son widget
#makefile
#
# Variables:
#
CC=gcc
BIN=gtk_led
SRC=main.c gtkled.c
OBJ=main.o gtkled.o


#
# Flags du preprocesseur:
#
CPPFLAGS=-Wall -W -ansi -pedantic -O2 `pkg-config --cflags gtk+-2.0`

#
# Flags pour l'editeur de liens:
#
LDFLAGS=`pkg-config --libs gtk+-2.0`

#
# Construction du programme:
#
all: $(BIN)

$(BIN): $(SRC)
$(CC) $(CPPFLAGS) -c $(SRC)
$(CC) $(LDFLAGS) -o $(BIN) $(OBJ)
#
# Nettoyage:
#
clean:
rm -f *.o *~ core $(BIN)


#================================
# fichier main.c
#include <stdio.h>
#include <stdlib.h>
#include <gtk/gtk.h>

#include "gtkled.h"


static void cb_switch (GtkWidget * widget, gpointer data)
{
   GtkWidget * led = (GtkWidget *) data;
   gtk_led_set_state (GTK_LED (led), ! gtk_led_get_state (GTK_LED (led)));
}


int main (int argc, char ** argv)
{
   GtkWidget * win;
   GtkWidget * hbox;
   GtkWidget * btn;
   GtkWidget * led;


   gtk_init (& argc, & argv);


   /*
    * Creation de la fenetre principale et ajout d'un container.
    */
   win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
   gtk_window_set_title (GTK_WINDOW (win), "Test de GtkLed");
   gtk_window_set_position (GTK_WINDOW (win), GTK_WIN_POS_CENTER);
   gtk_window_set_default_size (GTK_WINDOW (win), 250, 50);

   g_signal_connect (
      G_OBJECT (win),
      "destroy",
      G_CALLBACK (gtk_main_quit),
      NULL
   );

   hbox = gtk_hbox_new (0, FALSE);
   gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
   gtk_container_add (GTK_CONTAINER (win), hbox);


   /*
    * Creation d'un bouton et d'un GtkLed.
    */
   btn = gtk_button_new_with_label ("Switch led state");
   gtk_box_pack_start (GTK_BOX (hbox), btn, TRUE, TRUE, 0);

   led = gtk_led_new ("led_on.png", "led_off.png", TRUE);

   if (led == NULL) {
      printf ("Impossible de créer le widget GtkLed !\n");
   } else {
      gtk_box_pack_start (GTK_BOX (hbox), led, TRUE, TRUE, 0);

      g_signal_connect (
         G_OBJECT (btn),
         "clicked",
         G_CALLBACK (cb_switch),
         (gpointer) led
      );
   }


   gtk_widget_show_all (win);
   gtk_main ();


   return EXIT_SUCCESS;
}

#======================================
#fichier 
/* gtkled.c */

#include "gtkled.h"


static void gtk_led_class_init (GtkLedClass * klass);
static void gtk_led_init (GtkLed * led);
static void gtk_led_load_image (GtkLed * led);
static void gtk_led_size_request (GtkWidget * widget,
                                  GtkRequisition * requisition);
static void gtk_led_size_allocate (GtkWidget * widget,
                                   GtkAllocation * allocation);
static void gtk_led_realize (GtkWidget * widget);
static gboolean gtk_led_expose (GtkWidget * widget,
                                GdkEventExpose * event);
static void gtk_led_paint (GtkWidget * widget);
static void gtk_led_destroy (GtkObject * object);


GtkType
gtk_led_get_type (void)
{
   static GtkType gtk_led_type = 0;


   if (! gtk_led_type) {
      static const GtkTypeInfo gtk_led_info = {
         "GtkLed",
         sizeof (GtkLed),
         sizeof (GtkLedClass),
         (GtkClassInitFunc) gtk_led_class_init,
         (GtkObjectInitFunc) gtk_led_init,
         NULL,
         NULL,
         (GtkClassInitFunc) NULL
      };
      gtk_led_type = gtk_type_unique (GTK_TYPE_WIDGET, &gtk_led_info);
   }


   return gtk_led_type;
}


gboolean
gtk_led_get_state (GtkLed * led)
{
   return led->state;
}


void
gtk_led_set_state (GtkLed * led, gboolean state)
{
   led->state = state;
   gtk_led_paint (GTK_WIDGET (led));
}


GtkWidget *
gtk_led_new (const gchar * on_image,
             const gchar * off_image,
             gboolean state)
{
   GtkLed * led = NULL;


   if (on_image != NULL && off_image != NULL) {
      led = gtk_type_new (gtk_led_get_type ());

      if (led != NULL) {
         led->on_image = on_image;
         led->off_image = off_image;
         led->state = state;

         gtk_led_load_image (led);
      }
   }


   return GTK_WIDGET (led);
}


static void
gtk_led_class_init (GtkLedClass * klass)
{
   GtkWidgetClass * widget_class;
   GtkObjectClass * object_class;


   widget_class = (GtkWidgetClass *) klass;
   object_class = (GtkObjectClass *) klass;

   widget_class->realize = gtk_led_realize;
   widget_class->size_request = gtk_led_size_request;
   widget_class->size_allocate = gtk_led_size_allocate;
   widget_class->expose_event = gtk_led_expose;

   object_class->destroy = gtk_led_destroy;
}


static void
gtk_led_init (GtkLed * led)
{
   led->on_image = NULL;
   led->off_image = NULL;
   led->on_pixbuf = NULL;
   led->off_pixbuf = NULL;
   led->width = 0;
   led->height = 0;
   led->state = FALSE;
}


static void
gtk_led_load_image (GtkLed * led)
{
   led->on_pixbuf = gdk_pixbuf_new_from_file (led->on_image, NULL);
   led->off_pixbuf = gdk_pixbuf_new_from_file (led->off_image, NULL);
   led->width = gdk_pixbuf_get_width (led->on_pixbuf);
   led->height = gdk_pixbuf_get_height (led->on_pixbuf);
}


static void
gtk_led_size_request (GtkWidget * widget,
                      GtkRequisition * requisition)
{
   g_return_if_fail (widget != NULL);
   g_return_if_fail (GTK_IS_LED (widget));
   g_return_if_fail (requisition != NULL);

   requisition->width = GTK_LED (widget)->width;
   requisition->height = GTK_LED (widget)->height;
}


static void
gtk_led_size_allocate (GtkWidget * widget,
                       GtkAllocation * allocation)
{
   g_return_if_fail (widget != NULL);
   g_return_if_fail (GTK_IS_LED (widget));
   g_return_if_fail (allocation != NULL);


   widget->allocation = *allocation;

   if (GTK_WIDGET_REALIZED (widget)) {
      gdk_window_move_resize (
         widget->window,
         allocation->x, allocation->y,
         allocation->width, allocation->height
      );
   }
}


static void
gtk_led_realize (GtkWidget * widget)
{
   GdkWindowAttr attributes;
   guint attributes_mask;


   g_return_if_fail (widget != NULL);
   g_return_if_fail (GTK_IS_LED (widget));


   GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);

   attributes.window_type = GDK_WINDOW_CHILD;
   attributes.x = widget->allocation.x;
   attributes.y = widget->allocation.y;
   attributes.width = widget->allocation.width;
   attributes.height = widget->allocation.height;
   attributes.wclass = GDK_INPUT_OUTPUT;
   attributes.event_mask = gtk_widget_get_events (widget) | GDK_EXPOSURE_MASK;

   attributes_mask = GDK_WA_X | GDK_WA_Y;

   widget->window = gdk_window_new (
      gtk_widget_get_parent_window (widget),
      & attributes, attributes_mask
   );

   gdk_window_set_user_data (widget->window, widget);

   widget->style = gtk_style_attach (widget->style, widget->window);
   gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
}


static gboolean
gtk_led_expose (GtkWidget * widget,
                GdkEventExpose * event)
{
   g_return_val_if_fail (widget != NULL, FALSE);
   g_return_val_if_fail (GTK_IS_LED (widget), FALSE);
   g_return_val_if_fail (event != NULL, FALSE);


   gtk_led_paint (widget);


   return FALSE;
}


static void
gtk_led_paint (GtkWidget * widget)
{
   GdkPixbuf * pixbuf = NULL;
   gint center_x = 0;
   gint center_y = 0;


   gdk_window_clear_area (
      widget->window,
      0, 0,
      widget->allocation.width,
      widget->allocation.height
   );


   center_x = (widget->allocation.width / 2) - (GTK_LED (widget)->width / 2);
   center_y = (widget->allocation.height / 2) - (GTK_LED (widget)->height / 2);


   if (GTK_LED (widget)->state)
      pixbuf = GTK_LED (widget)->on_pixbuf;
   else
      pixbuf = GTK_LED (widget)->off_pixbuf;


   gdk_pixbuf_render_to_drawable (
      pixbuf,
      GDK_DRAWABLE (widget->window),
      NULL,
      0, 0, center_x, center_y,
      GTK_LED (widget)->width, GTK_LED (widget)->height,
      GDK_RGB_DITHER_NORMAL, 1, 1
   );
}


static void
gtk_led_destroy (GtkObject * object)
{
   GtkLed * led;
   GtkLedClass * klass;


   g_return_if_fail (object != NULL);
   g_return_if_fail (GTK_IS_LED (object));


   led = GTK_LED (object);

   if (led->on_pixbuf != NULL && led->off_pixbuf != NULL) {
      gdk_pixbuf_unref (led->on_pixbuf);
      gdk_pixbuf_unref (led->off_pixbuf);

      led->on_pixbuf = NULL;
      led->off_pixbuf = NULL;
   }


   klass = gtk_type_class (gtk_widget_get_type ());

   if (GTK_OBJECT_CLASS (klass)->destroy) {
      (* GTK_OBJECT_CLASS (klass)->destroy) (object);
   }
} 

erreur renvoiyée:

 line 6: gtkled.c: command not found
 line 7: gtkled.o: command not found
Package gtk+-2.0 was not found in the pkg-config search path.
Perhaps you should add the directory containing `gtk+-2.0.pc'
to the PKG_CONFIG_PATH environment variable
No package 'gtk+-2.0' found
line 13: -W: command not found
Package gtk+-2.0 was not found in the pkg-config search path.
Perhaps you should add the directory containing `gtk+-2.0.pc'
to the PKG_CONFIG_PATH environment variable
No package 'gtk+-2.0' found

ect ect