forcing focus

[John C Atkeson <jcatkeson juno com>]

  This example (another hack  of Scribble) works right in gtk-win32 but
not in Linux/KDE or Irix.  
  
  In Win32, when I click on the drawing area, the text-entry window
raises and keeps focus, so that I can type in text without having to move
the mouse away from the drawing area.
  
  In Linux/KDE and Irix, the text-entry comes forward but stays out of
focus.  
  
  How do I force the text window to be type-able after every click in the
graphic window?
  
  Thanks,
  John
  
  
   (My real program's kind of like a GIS, the user can click on graphical
objects in one window while he does fast data entry in a 'properties'
window off to the side.)

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

     #include <gtk/gtk.h>

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


     gint delete_event_not( GtkWidget *widget,GdkEvent *event,gpointer
data)
     {
         /* Change TRUE to FALSE and the main window will be destroyed
with
          * a "delete_event". */
         gtk_widget_hide(widget);
         return(TRUE);
     }

     /* 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)
     {
       GtkWidget *top;
       if (event->button == 1 && pixmap != NULL){
         draw_brush (widget, event->x, event->y);
         gtk_widget_show(win2);
         gdk_window_raise(win2->window);
       }

       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_main_quit ();
     }

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

       GtkWidget *textreport, *textVbox;

       gtk_init (&argc, &argv);

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

       {
       win2 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
       gtk_widget_set_name (window, "Win2");
       gtk_widget_show (win2);
       gtk_signal_connect (GTK_OBJECT (win2), "delete_event",
                           GTK_SIGNAL_FUNC (delete_event_not), NULL);

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

       textreport = gtk_text_new( NULL,NULL );
       gtk_text_set_editable(GTK_TEXT(textreport),TRUE);
       gtk_text_set_word_wrap(GTK_TEXT(textreport),FALSE);
       gtk_widget_set_usize (textreport, 300, 300);

       gtk_box_pack_start (GTK_BOX (vbox), textreport, TRUE, TRUE, 0);
       gtk_widget_show (textreport);
       gtk_widget_grab_focus(textreport);
       gtk_text_insert(GTK_TEXT(textreport),NULL, 
          NULL,NULL, "Type here after clicking in scribble:", 
          strlen("Type here after clicking in scribble:") ); 

       textreport = gtk_text_new( NULL,NULL );
       gtk_text_set_editable(GTK_TEXT(textreport),TRUE);
       gtk_text_set_word_wrap(GTK_TEXT(textreport),FALSE);
       gtk_widget_set_usize (textreport, 300, 100);

       gtk_box_pack_start (GTK_BOX (vbox), textreport, TRUE, TRUE, 0);
       gtk_widget_show (textreport);
       }


       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 */


___________________________________________________________________
Why pay more to get Web access?
Try Juno for FREE -- then it's just $9.95/month if you act NOW!
Get your free software today: http://dl.www.juno.com/dynoget/tagj.