Re: [gtk-list] signals...?

[Owen Taylor <owt1 cornell edu>]

> both widgets show....i can draw pictures etc using image->mem.....
> but one the drawingarea one registers signals.... :/
> 
> what fundamental thing am I missing? :)
> beginning to bother me since I cannot seem to gleen the answer from source

This is beginning to become a bit of a FAQ. The problem is that image
widgets don't have associated X windows, so they can't have receive
events.

(Maybe the heirarchy of classes in the tutorial should list which
 one's are GTK_NO_WINDOW, Ian?)

The solution:

Stick it in an EventBox. Of course, the eventbox widget isn't part
of the standard distribution yet ...

I've appended a new version of my EventBox widget below, with a
suitable portion for the tutorial. (This version is presented as a
patch to be included in the main distribution. It needs automake/autoconf
or Makefile hackery to build ) It will be part of my GTK tree at:

  http://www.msc.cornell.edu/~otaylor/gtk-gimp/patches.html

soon, but probably not tonight.

Regards,
                                        Owen

(Yes, I've made some arbitrary name changes here, sorry Hoek)

(Ian - feel free to edit the following for your uses. I also have tutorial
 sections on my AspectFrame and Paned widgets, that I'll send along
 shortly.)

===== a section about eventboxes for the tutorial

<sect>The EventBox widget

<p> 
At first glance, the EventBox widget might appear to be totally
useless. It draws nothing on the screen and responds to no
events. However, it does serve a function - it provides a X window for
its child widget. This is important because many gtk widgets do not
have an associated X window. Not having an X window saves memory and
improves performance, but also has some drawbacks. A widget without an
X window cannot receive events, and does not perform any clipping on
it's contents. Although the name ``EventBox'' emphasizes the
event-handling function, the widget also can be used for clipping. 
(And more ... see the example below.)

<p>
To create a new EventBox widget, use:

<tscreen><verb>
GtkWidget* gtk_event_box_new (void);
</verb></tscreen>

<p>
A child widget can then be added to this EventBox:

<tscreen><verb>
gtk_container_add (GTK_CONTAINER(event_box), widget);
</verb></tscreen>

<p>
The following example demonstrates both uses of an EventBox - a label
is created that clipped to a small box, and set up so that a
mouse-click on the label causes the program to exit.

<tscreen><verb>

#include <gtk/gtk.h>

int 
main (int argc, char *argv[])
{
  GtkWidget *window;
  GtkWidget *event_box;
  GtkWidget *label;
  
  gtk_init (&amp;argc, &amp;argv);

  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  
  gtk_window_set_title (GTK_WINDOW (window), "Event Box");
  
  gtk_signal_connect (GTK_OBJECT (window), "destroy",
		      GTK_SIGNAL_FUNC (gtk_exit), NULL);
  
  gtk_container_border_width (GTK_CONTAINER (window), 10);

  /* Create an EventBox and add it to our toplevel window */

  event_box = gtk_event_box_new ();
  gtk_container_add (GTK_CONTAINER(window), event_box);
  gtk_widget_show (event_box);

  /* Create a long label */

  label = gtk_label_new ("Click here to quit, quit, quit, quit, quit");
  gtk_container_add (GTK_CONTAINER (event_box), label);
  gtk_widget_show (label);

  /* Clip it short. */
  gtk_widget_set_usize (label, 110, 20);

  /* And bind an action to it */
  gtk_widget_set_events (event_box, GDK_BUTTON_PRESS_MASK);
  gtk_signal_connect (GTK_OBJECT(event_box), "button_press_event",
		      GTK_SIGNAL_FUNC (gtk_exit), NULL);

  /* Yet one more thing you need an X window for ... */

  gtk_widget_realize (event_box);
  gdk_window_set_cursor (event_box->window, gdk_cursor_new (GDK_HAND1));

  gtk_widget_show (window);
  
  gtk_main ();
  
  return 0;
}


</verb></tscreen>

===== and the patch

diff -r -P -c -X patch-exclude gtk+.bak/gtk/Makefile.am gtk+/gtk/Makefile.am
*** gtk+.bak/gtk/Makefile.am	Fri Aug  1 17:06:54 1997
--- gtk+/gtk/Makefile.am	Thu Aug  7 05:25:06 1997
***************
*** 22,27 ****
--- 22,28 ----
  	gtkdialog.c		\
  	gtkdrawingarea.c	\
  	gtkentry.c		\
+ 	gtkeventbox.c		\
  	gtkfilesel.c		\
  	gtkframe.c		\
  	gtkgamma.c		\
***************
*** 102,107 ****
--- 103,109 ----
  	gtkdrawingarea.h	\
  	gtkentry.h		\
  	gtkenums.h		\
+ 	gtkeventbox.h		\
  	gtkfilesel.h		\
  	gtkframe.h		\
  	gtkgamma.h		\
diff -r -P -c -X patch-exclude gtk+.bak/gtk/gtk.h gtk+/gtk/gtk.h
*** gtk+.bak/gtk/gtk.h	Fri Aug  1 17:05:35 1997
--- gtk+/gtk/gtk.h	Thu Aug  7 05:25:33 1997
***************
*** 39,44 ****
--- 39,45 ----
  #include <gtk/gtkdrawingarea.h>
  #include <gtk/gtkentry.h>
  #include <gtk/gtkenums.h>
+ #include <gtk/gtkeventbox.h>
  #include <gtk/gtkfilesel.h>
  #include <gtk/gtkframe.h>
  #include <gtk/gtkgc.h>
diff -r -P -c -X patch-exclude gtk+.bak/gtk/gtkeventbox.c gtk+/gtk/gtkeventbox.c
*** gtk+.bak/gtk/gtkeventbox.c	Wed Dec 31 19:00:00 1969
--- gtk+/gtk/gtkeventbox.c	Thu Aug  7 05:28:23 1997
***************
*** 0 ****
--- 1,220 ----
+ /* 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+  */
+ #include "gtksignal.h"
+ #include "gtkeventbox.h"
+ 
+ 
+ static void gtk_event_box_class_init               (GtkEventBoxClass *klass);
+ static void gtk_event_box_init                     (GtkEventBox      *event_box);
+ static void gtk_event_box_realize                  (GtkWidget        *widget);
+ static void gtk_event_box_size_request             (GtkWidget        *widget,
+ 						   GtkRequisition   *requisition);
+ static void gtk_event_box_size_allocate            (GtkWidget        *widget,
+ 						   GtkAllocation    *allocation);
+ static void gtk_event_box_draw                     (GtkWidget    *widget,
+ 						   GdkRectangle *area);
+ static gint gtk_event_box_expose                   (GtkWidget      *widget,
+ 						   GdkEventExpose *event);
+ 
+ 
+ guint
+ gtk_event_box_get_type ()
+ {
+   static guint event_box_type = 0;
+ 
+   if (!event_box_type)
+     {
+       GtkTypeInfo event_box_info =
+       {
+ 	"GtkEventBox",
+ 	sizeof (GtkEventBox),
+ 	sizeof (GtkEventBoxClass),
+ 	(GtkClassInitFunc) gtk_event_box_class_init,
+ 	(GtkObjectInitFunc) gtk_event_box_init,
+ 	(GtkArgFunc) NULL,
+       };
+ 
+       event_box_type = gtk_type_unique (gtk_bin_get_type (), &event_box_info);
+     }
+ 
+   return event_box_type;
+ }
+ 
+ static void
+ gtk_event_box_class_init (GtkEventBoxClass *class)
+ {
+   GtkWidgetClass *widget_class;
+ 
+   widget_class = (GtkWidgetClass*) class;
+ 
+   widget_class->realize = gtk_event_box_realize;
+   widget_class->size_request = gtk_event_box_size_request;
+   widget_class->size_allocate = gtk_event_box_size_allocate;
+   widget_class->draw = gtk_event_box_draw;
+   widget_class->expose_event = gtk_event_box_expose;
+ }
+ 
+ static void
+ gtk_event_box_init (GtkEventBox *event_box)
+ {
+   GTK_WIDGET_UNSET_FLAGS (event_box, GTK_NO_WINDOW);
+   GTK_WIDGET_SET_FLAGS (event_box, GTK_BASIC);
+ }
+ 
+ GtkWidget*
+ gtk_event_box_new ()
+ {
+   return GTK_WIDGET ( gtk_type_new (gtk_event_box_get_type ()));
+ }
+ 
+ static void
+ gtk_event_box_realize (GtkWidget *widget)
+ {
+   GdkWindowAttr attributes;
+   gint attributes_mask;
+ 
+   g_return_if_fail (widget != NULL);
+   g_return_if_fail (GTK_IS_EVENT_BOX (widget));
+ 
+   GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
+ 
+   attributes.x = widget->allocation.x;
+   attributes.y = widget->allocation.y;
+   attributes.width = widget->allocation.width;
+   attributes.height = widget->allocation.height;
+   attributes.window_type = GDK_WINDOW_CHILD;
+   attributes.wclass = GDK_INPUT_OUTPUT;
+   attributes.visual = gtk_widget_get_visual (widget);
+   attributes.colormap = gtk_widget_get_colormap (widget);
+   attributes.event_mask = gtk_widget_get_events (widget) | GDK_EXPOSURE_MASK;;
+ 
+   attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
+ 
+   widget->window = gdk_window_new (widget->parent->window, &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 void
+ gtk_event_box_size_request (GtkWidget      *widget,
+ 			GtkRequisition *requisition)
+ {
+   GtkBin *bin;
+ 
+   g_return_if_fail (widget != NULL);
+   g_return_if_fail (GTK_IS_EVENT_BOX (widget));
+   g_return_if_fail (requisition != NULL);
+ 
+   bin = GTK_BIN (widget);
+ 
+   requisition->width = GTK_CONTAINER (widget)->border_width * 2;
+   requisition->height = GTK_CONTAINER (widget)->border_width * 2;
+ 
+   if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
+     {
+       gtk_widget_size_request (bin->child, &bin->child->requisition);
+ 
+       requisition->width += bin->child->requisition.width;
+       requisition->height += bin->child->requisition.height;
+     }
+ }
+ 
+ static void
+ gtk_event_box_size_allocate (GtkWidget     *widget,
+ 			    GtkAllocation *allocation)
+ {
+   GtkBin *bin;
+   GtkAllocation child_allocation;
+ 
+   g_return_if_fail (widget != NULL);
+   g_return_if_fail (GTK_IS_EVENT_BOX (widget));
+   g_return_if_fail (allocation != NULL);
+ 
+   widget->allocation = *allocation;
+   bin = GTK_BIN (widget);
+ 
+   child_allocation.x = 0;
+   child_allocation.y = 0;
+   child_allocation.width = allocation->width - GTK_CONTAINER (widget)->border_width * 2;
+   child_allocation.height = allocation->height - GTK_CONTAINER (widget)->border_width * 2;
+ 
+   if (GTK_WIDGET_REALIZED (widget))
+     {
+       gdk_window_move_resize (widget->window,
+ 			      allocation->x + GTK_CONTAINER (widget)->border_width,
+ 			      allocation->y + GTK_CONTAINER (widget)->border_width,
+ 			      child_allocation.width,
+ 			      child_allocation.height);
+     }
+   
+   if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
+     {
+       gtk_widget_size_allocate (bin->child, &child_allocation);
+     }
+ }
+ 
+ static void
+ gtk_event_box_draw (GtkWidget    *widget,
+ 		   GdkRectangle *area)
+ {
+   GtkBin *bin;
+   GdkRectangle child_area;
+ 
+   g_return_if_fail (widget != NULL);
+   g_return_if_fail (GTK_IS_EVENT_BOX (widget));
+   g_return_if_fail (area != NULL);
+ 
+   if (GTK_WIDGET_DRAWABLE (widget))
+     {
+       bin = GTK_BIN (widget);
+ 
+       if (bin->child)
+ 	{
+ 	  if (gtk_widget_intersect (bin->child, area, &child_area))
+ 	    gtk_widget_draw (bin->child, &child_area);
+ 	}
+     }
+ }
+ 
+ static gint
+ gtk_event_box_expose (GtkWidget      *widget,
+ 		     GdkEventExpose *event)
+ {
+   GtkBin *bin;
+   GdkEventExpose child_event;
+ 
+   g_return_val_if_fail (widget != NULL, FALSE);
+   g_return_val_if_fail (GTK_IS_EVENT_BOX (widget), FALSE);
+   g_return_val_if_fail (event != NULL, FALSE);
+ 
+   if (GTK_WIDGET_DRAWABLE (widget))
+     {
+       bin = GTK_BIN (widget);
+ 
+       child_event = *event;
+       if (bin->child &&
+ 	  GTK_WIDGET_NO_WINDOW (bin->child) &&
+ 	  gtk_widget_intersect (bin->child, &event->area, &child_event.area))
+ 	gtk_widget_event (bin->child, (GdkEvent*) &child_event);
+     }
+ 
+   return FALSE;
+ }
+ 
diff -r -P -c -X patch-exclude gtk+.bak/gtk/gtkeventbox.h gtk+/gtk/gtkeventbox.h
*** gtk+.bak/gtk/gtkeventbox.h	Wed Dec 31 19:00:00 1969
--- gtk+/gtk/gtkeventbox.h	Thu Aug  7 05:24:18 1997
***************
*** 0 ****
--- 1,57 ----
+ /* 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+  */
+ #ifndef __GTK_EVENT_BOX_H__
+ #define __GTK_EVENT_BOX_H__
+ 
+ 
+ #include <gdk/gdk.h>
+ #include <gtk/gtkbin.h>
+ 
+ 
+ #ifdef __cplusplus
+ extern "C" {
+ #endif /* __cplusplus */
+ 
+ 
+ #define GTK_EVENT_BOX(obj)          GTK_CHECK_CAST (obj, gtk_event_box_get_type (), GtkEventBox)
+ #define GTK_EVENT_BOX_CLASS(klass)  GTK_CHECK_CLASS_CAST (klass, gtk_event_box_get_type (), GtkEventBoxClass)
+ #define GTK_IS_EVENT_BOX(obj)       GTK_CHECK_TYPE (obj, gtk_event_box_get_type ())
+ 
+ 
+ typedef struct _GtkEventBox       GtkEventBox;
+ typedef struct _GtkEventBoxClass  GtkEventBoxClass;
+ 
+ struct _GtkEventBox
+ {
+   GtkBin bin;
+ };
+ 
+ struct _GtkEventBoxClass
+ {
+   GtkBinClass parent_class;
+ };
+ 
+ guint          gtk_event_box_get_type        (void);
+ GtkWidget*     gtk_event_box_new             (void);
+ 
+ #ifdef __cplusplus
+ }
+ #endif /* __cplusplus */
+ 
+ 
+ #endif /* __GTK_EVENT_BOX_H__ */