GTK+ 1.2 Tutorial
Prev | Appendix C. Code Examples | Next

# Scribble

## scribble-simple.c

    /* example-start scribble-simple scribble-simple.c */

    /* GTK - The GIMP Toolkit
     * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
     *
     * This library is free software; you can redistribute it and/or
     * modify it under the terms of the GNU Library General Public
     * License as published by the Free Software Foundation; either
     * version 2 of the License, or (at your option) any later version.
     *
     * This library 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
     * Library General Public License for more details.
     *
     * You should have received a copy of the GNU Library General Public
     * License along with this library; if not, write to the
     * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
     * Boston, MA 02111-1307, USA.
     */

    #include <gtk/gtk.h>

    /* Backing pixmap for drawing area */
    static GdkPixmap *pixmap = NULL;

    /* Create a new backing pixmap of the appropriate size */
    static gint configure_event( GtkWidget         *widget,
                                 GdkEventConfigure *event )
    {
      if (pixmap)
        gdk_pixmap_unref(pixmap);

      pixmap = gdk_pixmap_new(widget->window,
    			  widget->allocation.width,
    			  widget->allocation.height,
    			  -1);
      gdk_draw_rectangle (pixmap,
    		      widget->style->white_gc,
    		      TRUE,
    		      0, 0,
    		      widget->allocation.width,
    		      widget->allocation.height);

      return TRUE;
    }

    /* Redraw the screen from the backing pixmap */
    static gint expose_event( GtkWidget      *widget,
                              GdkEventExpose *event )
    {
      gdk_draw_pixmap(widget->window,
    		  widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
    		  pixmap,
    		  event->area.x, event->area.y,
    		  event->area.x, event->area.y,
    		  event->area.width, event->area.height);

      return FALSE;
    }

    /* Draw a rectangle on the screen */
    static void draw_brush( GtkWidget *widget,
                            gdouble    x,
                            gdouble    y)
    {
      GdkRectangle update_rect;

      update_rect.x = x - 5;
      update_rect.y = y - 5;
      update_rect.width = 10;
      update_rect.height = 10;
      gdk_draw_rectangle (pixmap,
    		      widget->style->black_gc,
    		      TRUE,
    		      update_rect.x, update_rect.y,
    		      update_rect.width, update_rect.height);
      gtk_widget_draw (widget, &update_rect);
    }

    static gint button_press_event( GtkWidget      *widget,
                                    GdkEventButton *event )
    {
      if (event->button == 1 && pixmap != NULL)
        draw_brush (widget, event->x, event->y);

      return TRUE;
    }

    static gint motion_notify_event( GtkWidget *widget,
                                     GdkEventMotion *event )
    {
      int x, y;
      GdkModifierType state;

      if (event->is_hint)
        gdk_window_get_pointer (event->window, &x, &y, &state);
      else
        {
          x = event->x;
          y = event->y;
          state = event->state;
        }

      if (state & GDK_BUTTON1_MASK && pixmap != NULL)
        draw_brush (widget, x, y);

      return TRUE;
    }

    void quit ()
    {
      gtk_exit (0);
    }

    int main( int   argc,
              char *argv[] )
    {
      GtkWidget *window;
      GtkWidget *drawing_area;
      GtkWidget *vbox;

      GtkWidget *button;

      gtk_init (&argc, &argv);

      window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
      gtk_widget_set_name (window, "Test Input");

      vbox = gtk_vbox_new (FALSE, 0);
      gtk_container_add (GTK_CONTAINER (window), vbox);
      gtk_widget_show (vbox);

      gtk_signal_connect (GTK_OBJECT (window), "destroy",
    		      GTK_SIGNAL_FUNC (quit), NULL);

      /* Create the drawing area */

      drawing_area = gtk_drawing_area_new ();
      gtk_drawing_area_size (GTK_DRAWING_AREA (drawing_area), 200, 200);
      gtk_box_pack_start (GTK_BOX (vbox), drawing_area, TRUE, TRUE, 0);

      gtk_widget_show (drawing_area);

      /* Signals used to handle backing pixmap */

      gtk_signal_connect (GTK_OBJECT (drawing_area), "expose_event",
    		      (GtkSignalFunc) expose_event, NULL);
      gtk_signal_connect (GTK_OBJECT(drawing_area),"configure_event",
    		      (GtkSignalFunc) configure_event, NULL);

      /* Event signals */

      gtk_signal_connect (GTK_OBJECT (drawing_area), "motion_notify_event",
    		      (GtkSignalFunc) motion_notify_event, NULL);
      gtk_signal_connect (GTK_OBJECT (drawing_area), "button_press_event",
    		      (GtkSignalFunc) button_press_event, NULL);

      gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK
    			 | GDK_LEAVE_NOTIFY_MASK
    			 | GDK_BUTTON_PRESS_MASK
    			 | GDK_POINTER_MOTION_MASK
    			 | GDK_POINTER_MOTION_HINT_MASK);

      /* .. And a quit button */
      button = gtk_button_new_with_label ("Quit");
      gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);

      gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
    			     GTK_SIGNAL_FUNC (gtk_widget_destroy),
    			     GTK_OBJECT (window));
      gtk_widget_show (button);

      gtk_widget_show (window);

      gtk_main ();

      return 0;
    }
    /* example-end */

## scribble-xinput.c

    /* example-start scribble-xinput scribble-xinput.c */

    /* GTK - The GIMP Toolkit
     * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
     *
     * This library is free software; you can redistribute it and/or
     * modify it under the terms of the GNU Library General Public
     * License as published by the Free Software Foundation; either
     * version 2 of the License, or (at your option) any later version.
     *
     * This library 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
     * Library General Public License for more details.
     *
     * You should have received a copy of the GNU Library General Public
     * License along with this library; if not, write to the
     * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
     * Boston, MA 02111-1307, USA.
     */

    #include <gtk/gtk.h>

    /* Backing pixmap for drawing area */
    static GdkPixmap *pixmap = NULL;

    /* Create a new backing pixmap of the appropriate size */
    static gint
    configure_event (GtkWidget *widget, GdkEventConfigure *event)
    {
      if (pixmap)
         gdk_pixmap_unref(pixmap);

      pixmap = gdk_pixmap_new(widget->window,
                              widget->allocation.width,
                              widget->allocation.height,
                              -1);
      gdk_draw_rectangle (pixmap,
                          widget->style->white_gc,
                          TRUE,
                          0, 0,
                          widget->allocation.width,
                          widget->allocation.height);

      return TRUE;
    }

    /* Redraw the screen from the backing pixmap */
    static gint
    expose_event (GtkWidget *widget, GdkEventExpose *event)
    {
      gdk_draw_pixmap(widget->window,
                      widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
                      pixmap,
                      event->area.x, event->area.y,
                      event->area.x, event->area.y,
                      event->area.width, event->area.height);

      return FALSE;
    }

    /* Draw a rectangle on the screen, size depending on pressure,
       and color on the type of device */
    static void
    draw_brush (GtkWidget *widget, GdkInputSource source,
                gdouble x, gdouble y, gdouble pressure)
    {
      GdkGC *gc;
      GdkRectangle update_rect;

      switch (source)
        {
        case GDK_SOURCE_MOUSE:
          gc = widget->style->dark_gc[GTK_WIDGET_STATE (widget)];
          break;
        case GDK_SOURCE_PEN:
          gc = widget->style->black_gc;
          break;
        case GDK_SOURCE_ERASER:
          gc = widget->style->white_gc;
          break;
        default:
          gc = widget->style->light_gc[GTK_WIDGET_STATE (widget)];
        }

      update_rect.x = x - 10 * pressure;
      update_rect.y = y - 10 * pressure;
      update_rect.width = 20 * pressure;
      update_rect.height = 20 * pressure;
      gdk_draw_rectangle (pixmap, gc, TRUE,
                          update_rect.x, update_rect.y,
                          update_rect.width, update_rect.height);
      gtk_widget_draw (widget, &update_rect);
    }

    static void
    print_button_press (guint32 deviceid)
    {
      GList *tmp_list;

      /* gdk_input_list_devices returns an internal list, so we shouldn't
         free it afterwards */
      tmp_list = gdk_input_list_devices();

      while (tmp_list)
        {
          GdkDeviceInfo *info = (GdkDeviceInfo *)tmp_list->data;

          if (info->deviceid == deviceid)
            {
              g_print("Button press on device '%s'\n", info->name);
              return;
            }

          tmp_list = tmp_list->next;
        }
    }

    static gint
    button_press_event (GtkWidget *widget, GdkEventButton *event)
    {
      print_button_press (event->deviceid);

      if (event->button == 1 && pixmap != NULL)
        draw_brush (widget, event->source, event->x, event->y, event->pressure);

      return TRUE;
    }

    static gint
    motion_notify_event (GtkWidget *widget, GdkEventMotion *event)
    {
      gdouble x, y;
      gdouble pressure;
      GdkModifierType state;

      if (event->is_hint)
        gdk_input_window_get_pointer (event->window, event->deviceid,
                                      &x, &y, &pressure,
    				  NULL, NULL, &state);
      else
        {
          x = event->x;
          y = event->y;
          pressure = event->pressure;
          state = event->state;
        }

      if (state & GDK_BUTTON1_MASK && pixmap != NULL)
        draw_brush (widget, event->source, x, y, pressure);

      return TRUE;
    }

    void
    input_dialog_destroy (GtkWidget *w, gpointer data)
    {
      *((GtkWidget **)data) = NULL;
    }

    void
    create_input_dialog ()
    {
      static GtkWidget *inputd = NULL;

      if (!inputd)
        {
          inputd = gtk_input_dialog_new();

          gtk_signal_connect (GTK_OBJECT(inputd), "destroy",
                              (GtkSignalFunc)input_dialog_destroy, &inputd);
          gtk_signal_connect_object (GTK_OBJECT(GTK_INPUT_DIALOG(inputd)->close_button),
                                     "clicked",
                                     (GtkSignalFunc)gtk_widget_hide,
                                     GTK_OBJECT(inputd));
          gtk_widget_hide ( GTK_INPUT_DIALOG(inputd)->save_button);

          gtk_widget_show (inputd);
        }
      else
        {
          if (!GTK_WIDGET_MAPPED(inputd))
            gtk_widget_show(inputd);
          else
            gdk_window_raise(inputd->window);
        }
    }

    void
    quit ()
    {
      gtk_exit (0);
    }

    int
    main (int argc, char *argv[])
    {
      GtkWidget *window;
      GtkWidget *drawing_area;
      GtkWidget *vbox;

      GtkWidget *button;

      gtk_init (&argc, &argv);

      window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
      gtk_widget_set_name (window, "Test Input");

      vbox = gtk_vbox_new (FALSE, 0);
      gtk_container_add (GTK_CONTAINER (window), vbox);
      gtk_widget_show (vbox);

      gtk_signal_connect (GTK_OBJECT (window), "destroy",
                          GTK_SIGNAL_FUNC (quit), NULL);

      /* Create the drawing area */

      drawing_area = gtk_drawing_area_new ();
      gtk_drawing_area_size (GTK_DRAWING_AREA (drawing_area), 200, 200);
      gtk_box_pack_start (GTK_BOX (vbox), drawing_area, TRUE, TRUE, 0);

      gtk_widget_show (drawing_area);

      /* Signals used to handle backing pixmap */

      gtk_signal_connect (GTK_OBJECT (drawing_area), "expose_event",
                          (GtkSignalFunc) expose_event, NULL);
      gtk_signal_connect (GTK_OBJECT(drawing_area),"configure_event",
                          (GtkSignalFunc) configure_event, NULL);

      /* Event signals */

      gtk_signal_connect (GTK_OBJECT (drawing_area), "motion_notify_event",
                          (GtkSignalFunc) motion_notify_event, NULL);
      gtk_signal_connect (GTK_OBJECT (drawing_area), "button_press_event",
                          (GtkSignalFunc) button_press_event, NULL);

      gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK
                             | GDK_LEAVE_NOTIFY_MASK
                             | GDK_BUTTON_PRESS_MASK
                             | GDK_POINTER_MOTION_MASK
                             | GDK_POINTER_MOTION_HINT_MASK);

      /* The following call enables tracking and processing of extension
         events for the drawing area */
      gtk_widget_set_extension_events (drawing_area, GDK_EXTENSION_EVENTS_CURSOR);

      /* .. And some buttons */
      button = gtk_button_new_with_label ("Input Dialog");
      gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);

      gtk_signal_connect (GTK_OBJECT (button), "clicked",
                          GTK_SIGNAL_FUNC (create_input_dialog), NULL);
      gtk_widget_show (button);

      button = gtk_button_new_with_label ("Quit");
      gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);

      gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
                                 GTK_SIGNAL_FUNC (gtk_widget_destroy),
                                 GTK_OBJECT (window));
      gtk_widget_show (button);

      gtk_widget_show (window);

      gtk_main ();

      return 0;
    }
    /* example-end */

Prev | Home | Next
GtkDial | Up | List Widget