Follow Techotopia on Twitter

On-line Guides
All Guides
eBook Store
iOS / Android
Linux for Beginners
Office Productivity
Linux Installation
Linux Security
Linux Utilities
Linux Virtualization
Linux Kernel
System/Network Admin
Programming
Scripting Languages
Development Tools
Web Development
GUI Toolkits/Desktop
Databases
Mail Systems
openSolaris
Eclipse Documentation
Techotopia.com
Virtuatopia.com

How To Guides
Virtualization
General System Admin
Linux Security
Linux Filesystems
Web Servers
Graphics & Desktop
PC Hardware
Windows
Problem Solutions
Privacy Policy

  




 

 

Gtk+/Gnome Application Development
Prev Home Next

gtkev.c


#include "gtkev.h"

static void   gtk_ev_class_init    (GtkEvClass  *klass);
static void   gtk_ev_init          (GtkEv       *ev);


/* GtkObject functions */
static void   gtk_ev_destroy       (GtkObject   *object);


/* GtkWidget functions */

static gint   gtk_ev_event (GtkWidget          *widget,
                            GdkEvent           *event);

static void gtk_ev_realize        (GtkWidget        *widget);
static void gtk_ev_unrealize      (GtkWidget        *widget);
static void gtk_ev_size_request   (GtkWidget        *widget,
                                   GtkRequisition   *requisition);
static void gtk_ev_size_allocate  (GtkWidget        *widget,
                                   GtkAllocation    *allocation);

static void gtk_ev_draw           (GtkWidget        *widget,
                                   GdkRectangle     *area);
static void gtk_ev_draw_focus     (GtkWidget        *widget);

static gint gtk_ev_expose         (GtkWidget        *widget,
                                   GdkEventExpose   *event);
static gint gtk_ev_focus_in       (GtkWidget        *widget,
                                   GdkEventFocus    *event);
static gint gtk_ev_focus_out      (GtkWidget        *widget,
                                   GdkEventFocus    *event);

/* GtkEv-specific functions */

static void gtk_ev_paint          (GtkEv            *ev,
                                   GdkRectangle     *area);

static void gtk_ev_paint_event_window  (GtkEv            *ev,
                                        GdkRectangle     *area);

static void gtk_ev_push_text       (GtkEv            *ev,
                                    const gchar*     text);

/* Utility Functions */

static gchar* event_to_text (GdkEvent* event);

static GtkWidgetClass *parent_class = NULL;

guint
gtk_ev_get_type (void)
{
  static guint ev_type = 0;

  if (!ev_type)
    {
      static const GtkTypeInfo ev_info =
      {
        "GtkEv",
        sizeof (GtkEv),
        sizeof (GtkEvClass),
        (GtkClassInitFunc) gtk_ev_class_init,
        (GtkObjectInitFunc) gtk_ev_init,
        /* reserved_1 */ NULL,
        /* reserved_2 */ NULL,
        (GtkClassInitFunc) NULL,
      };

      ev_type = gtk_type_unique (gtk_widget_get_type (), &ev_info);
    }

  return ev_type;
}

static void
gtk_ev_class_init (GtkEvClass *klass)
{
  GtkObjectClass *object_class;
  GtkWidgetClass *widget_class;

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

  parent_class = gtk_type_class (gtk_widget_get_type ());

  object_class->destroy = gtk_ev_destroy;

  widget_class->realize = gtk_ev_realize;
  widget_class->unrealize = gtk_ev_unrealize;

  widget_class->size_request = gtk_ev_size_request;
  
  widget_class->size_allocate = gtk_ev_size_allocate;
  
  widget_class->draw = gtk_ev_draw;         

  widget_class->event = gtk_ev_event;
  
  widget_class->draw_focus = gtk_ev_draw_focus;

  widget_class->expose_event = gtk_ev_expose;
    
  widget_class->focus_in_event = gtk_ev_focus_in;
  widget_class->focus_out_event = gtk_ev_focus_out;
}

static void
gtk_ev_init (GtkEv *ev)
{
  GTK_WIDGET_SET_FLAGS (GTK_WIDGET(ev), GTK_CAN_FOCUS);

  ev->event_window = NULL;
  ev->buffer       = NULL;
  ev->buffer_end   = NULL;
  ev->buffer_size  = 0;
  
  ev->event_window_rect.x = ev->event_window_rect.y = 0;
  ev->event_window_rect.width = ev->event_window_rect.height = 0;

  ev->description_rect.x = ev->description_rect.y = 0;
  ev->description_rect.width = ev->description_rect.height = 0;
}

GtkWidget*
gtk_ev_new (void)
{
  GtkEv *ev;

  ev = gtk_type_new (gtk_ev_get_type ());

  return GTK_WIDGET (ev);
}

/* GtkObject functions */
static void   
gtk_ev_destroy       (GtkObject   *object)
{
  GtkEv* ev;
  GList* tmp;

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

  ev = GTK_EV(object);

  tmp = ev->buffer;
  while (tmp != NULL)
    {
      g_strfreev((gchar**)tmp->data);
      
      tmp = g_list_next(tmp);
    }

  g_list_free(ev->buffer);

  ev->buffer = NULL;
  ev->buffer_end = NULL;
  ev->buffer_size = 0;

  /* Chain up */
  if (GTK_OBJECT_CLASS(parent_class)->destroy)
    (* GTK_OBJECT_CLASS(parent_class)->destroy) (object);
}

/* GtkWidget functions */

static gint   
gtk_ev_event (GtkWidget        *widget,
              GdkEvent         *event)
{
  GtkEv* ev;

  g_return_val_if_fail(widget != NULL, FALSE);
  g_return_val_if_fail(GTK_IS_EV(widget), FALSE);

  ev = GTK_EV(widget);

  if (event->any.window == widget->window)
    {
      if (GTK_WIDGET_CLASS(parent_class)->event)
        return (* GTK_WIDGET_CLASS(parent_class)->event) (widget, event);
      else
        return FALSE;
    }
  else
    {
      gchar* text;

      /* The event is either on ev->event_window, or it is a key event 
       * passed down to us from the toplevel GtkWindow
       */

      text = event_to_text(event);
      
      gtk_ev_push_text(ev, text);

      g_free(text);

      /* If it was a motion event, make sure we get more */
      if (event->type == GDK_MOTION_NOTIFY)
        {
          gdk_window_get_pointer(ev->event_window, NULL, NULL, NULL);
        }

      /* We didn't "handle" the event, just listened in on it. */
      return FALSE;
    }
}

static void 
gtk_ev_realize        (GtkWidget        *widget)
{
  GdkWindowAttr attributes;
  gint attributes_mask;
  GtkEv* ev;
  GdkCursor* cursor;

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

  ev = GTK_EV(widget);

  /* Set realized flag */

  GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);

  /* Main widget window */

  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.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 (gtk_widget_get_parent_window (widget),
                                   &attributes, attributes_mask);
  gdk_window_set_user_data (widget->window, widget);

  /* Event window */

  cursor = gdk_cursor_new(GDK_CROSSHAIR);

  attributes.window_type = GDK_WINDOW_CHILD;
  attributes.x = ev->event_window_rect.x;
  attributes.y = ev->event_window_rect.y;
  attributes.width = ev->event_window_rect.width;
  attributes.height = ev->event_window_rect.height;
  attributes.wclass = GDK_INPUT_OUTPUT;
  attributes.visual = gtk_widget_get_visual (widget);
  attributes.colormap = gtk_widget_get_colormap (widget);
  attributes.event_mask = GDK_ALL_EVENTS_MASK;
  attributes.cursor = cursor;

  attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | 
    GDK_WA_COLORMAP | GDK_WA_CURSOR;

  ev->event_window = gdk_window_new (widget->window,
                                     &attributes, attributes_mask);
  gdk_window_set_user_data (ev->event_window, widget);

  gdk_window_show(ev->event_window);

  gdk_cursor_destroy(cursor);

  /* Style */

  widget->style = gtk_style_attach (widget->style, widget->window);

  gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);

  gdk_window_set_background (ev->event_window, 
                             &widget->style->base[GTK_STATE_NORMAL]);
}

static void 
gtk_ev_unrealize (GtkWidget        *widget)
{
  GtkEv* ev;

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

  ev = GTK_EV(widget);

  /* Hide all windows */

  if (GTK_WIDGET_MAPPED (widget))
    gtk_widget_unmap (widget);
  
  GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);

  /* Destroy our child window */

  if (ev->event_window)
    {
      gdk_window_set_user_data(ev->event_window, NULL);
      gdk_window_destroy(ev->event_window);
      ev->event_window = NULL;
    }

  /* This destroys widget->window and unsets the realized flag
   */
  if (GTK_WIDGET_CLASS(parent_class)->unrealize)
    (* GTK_WIDGET_CLASS(parent_class)->unrealize) (widget);
}

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

  /* 
   * GtkEv always wants to be the same fixed size.
   */
  
  requisition->width  = 450;
  requisition->height = 300;
}

static void 
gtk_ev_size_allocate  (GtkWidget        *widget,
                       GtkAllocation    *allocation)
{
  static const gint spacing = 10; 
  GtkEv* ev;

  g_return_if_fail(widget != NULL);
  g_return_if_fail(GTK_IS_EV(widget));
  
  ev = GTK_EV(widget);

  widget->allocation = *allocation;

  ev->event_window_rect.width = 
    MAX(allocation->width - spacing*2, 0);
  ev->event_window_rect.height = 
    MAX(allocation->height / 5 - spacing / 2, 0);

  ev->event_window_rect.x = 
    (allocation->width - ev->event_window_rect.width)/2;
  ev->event_window_rect.y = 
    MIN(spacing, allocation->height);

  ev->description_rect.x = ev->event_window_rect.x;
  ev->description_rect.y = 
    ev->event_window_rect.y + ev->event_window_rect.height + spacing;
  ev->description_rect.width = 
    ev->event_window_rect.width;
  ev->description_rect.height = 
    MAX((allocation->height - ev->event_window_rect.height - spacing*3), 0);

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

      gdk_window_move_resize (ev->event_window,
                              ev->event_window_rect.x, 
                              ev->event_window_rect.y,
                              ev->event_window_rect.width,
                              ev->event_window_rect.height);      
    }
}

static void 
gtk_ev_draw           (GtkWidget        *widget,
                       GdkRectangle     *area)
{
  GdkRectangle event_window_area;
  GdkRectangle intersection;
  GtkEv* ev;

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

  ev = GTK_EV(widget);

  gtk_ev_paint(ev, area);

  event_window_area = *area;

  if (gdk_rectangle_intersect(area, &ev->event_window_rect, &intersection))
    {
      /* Make the intersection relative to the event window */
      intersection.x -= ev->event_window_rect.x;
      intersection.y -= ev->event_window_rect.y;
      
      gtk_ev_paint_event_window(ev, &intersection);
    }
}

static void 
gtk_ev_draw_focus     (GtkWidget        *widget)
{
  GdkRectangle rect;
  GtkEv* ev;

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

  ev = GTK_EV(widget);

  rect.x = 0;
  rect.y = 0;
  rect.width = widget->allocation.width;
  rect.height = widget->allocation.height;

  if (GTK_WIDGET_DRAWABLE (ev))
    gtk_ev_paint(ev, &rect);
}

static gint 
gtk_ev_expose         (GtkWidget        *widget,
                       GdkEventExpose   *event)
{  
  if (event->window == widget->window)
    gtk_ev_paint(GTK_EV(widget), &event->area);
  else if (event->window == GTK_EV(widget)->event_window)
    gtk_ev_paint_event_window(GTK_EV(widget), &event->area);
  else
    g_assert_not_reached();

  return TRUE;
}

static gint 
gtk_ev_focus_in       (GtkWidget        *widget,
                       GdkEventFocus    *event)
{
  g_return_val_if_fail(widget != NULL, FALSE);
  g_return_val_if_fail(GTK_IS_EV(widget), FALSE);

  GTK_WIDGET_SET_FLAGS (widget, GTK_HAS_FOCUS);
  gtk_widget_draw_focus (widget);

  return FALSE;
}

static gint 
gtk_ev_focus_out      (GtkWidget        *widget,
                       GdkEventFocus    *event)
{
  g_return_val_if_fail(widget != NULL, FALSE);
  g_return_val_if_fail(GTK_IS_EV(widget), FALSE);

  GTK_WIDGET_UNSET_FLAGS (widget, GTK_HAS_FOCUS);
  gtk_widget_draw_focus (widget);

  return FALSE;
}

/* GtkEv-specific functions */

static void 
gtk_ev_paint          (GtkEv            *ev,
                       GdkRectangle     *area)
{
  GtkWidget* widget;

  g_return_if_fail(ev != NULL);
  g_return_if_fail(GTK_IS_EV(ev));

  widget = GTK_WIDGET(ev);

  if (!GTK_WIDGET_DRAWABLE (widget))
    return;

  gdk_window_clear_area (widget->window,
                         area->x, 
                         area->y,
                         area->width, 
                         area->height);

  gdk_gc_set_clip_rectangle(widget->style->black_gc, area);

  /* Draw a black rectangle around the event window */

  gdk_draw_rectangle(widget->window,
                     widget->style->black_gc,
                     FALSE,
                     ev->event_window_rect.x - 1, 
                     ev->event_window_rect.y - 1,
                     ev->event_window_rect.width + 2,
                     ev->event_window_rect.height + 2);

  gdk_gc_set_clip_rectangle(widget->style->black_gc, NULL);

  /* Draw text in the description area, if applicable */

  if (ev->buffer)
    {
      GdkRectangle intersection;

      if (gdk_rectangle_intersect(area,
                                  &ev->description_rect,
                                  &intersection))
        {
          static const gint space = 2;
          gint line;
          gint step;
          gint first_baseline;          
          GList* tmp;
      
          step  = widget->style->font->ascent + 
            widget->style->font->descent + space;
      
          first_baseline = ev->description_rect.y + 
            widget->style->font->ascent + space;
      
          line = 0;
      
          tmp = ev->buffer;
      
          while (tmp != NULL)
            {
              gchar** this_event = tmp->data;
              gint i = 0;
              while (this_event[i])
                {
                  gtk_paint_string (widget->style, 
                                    widget->window, 
                                    widget->state,
                                    &intersection, widget, "ev", 
                                    ev->description_rect.x,
                                    first_baseline + line*step,
                                    this_event[i]);
                  ++i;
                  ++line;
                }
          
              /* Bail out if we're off the bottom; the "- 2*step" is
               *  needed because the next baseline may be outside the
               *  redraw area but we are interested in the whole row of 
               *  text, not the baseline. The 2* is because line is one 
               *  larger than we've actually drawn.
               */
              if ((first_baseline + line*step - 2*step) > 
                  (intersection.y + intersection.height))
                break;
          
              tmp = g_list_next(tmp);
            }
        }
    }

  if (GTK_WIDGET_HAS_FOCUS (widget))
    {
      gtk_paint_focus (widget->style, widget->window,
                       area, widget, "ev",
                       widget->allocation.x, widget->allocation.y, 
                       widget->allocation.width-1, widget->allocation.height-1);
    }
}

static void 
gtk_ev_paint_event_window  (GtkEv            *ev,
                            GdkRectangle     *area)
{
  GtkWidget* widget;
  gint width;
  gint x, y;
  const char* title;

  g_return_if_fail(ev != NULL);
  g_return_if_fail(GTK_IS_EV(ev));

  widget = GTK_WIDGET(ev);

  if (!GTK_WIDGET_DRAWABLE (widget))
    return;

  title = _("Event Window");

  gdk_window_clear_area (ev->event_window,
                         area->x, 
                         area->y,
                         area->width, 
                         area->height);

  gdk_gc_set_clip_rectangle(widget->style->black_gc, area);

  /* Clearly it would be better to cache this */

  width = gdk_string_width(widget->style->font,
                           title);

  x = (ev->event_window_rect.width - width)/2;
  y = widget->style->font->ascent + 2;

  gdk_draw_string(ev->event_window,
                  widget->style->font,
                  widget->style->black_gc,
                  x, y, 
                  title);

  gdk_gc_set_clip_rectangle(widget->style->black_gc, NULL);
}

static void 
gtk_ev_push_text (GtkEv            *ev,
                  const gchar*     text)
{  
  if (text)
    {
      gchar** event; 
      event = g_strsplit(text, "\n", 10);
      ev->buffer = g_list_prepend(ev->buffer, event);
      ev->buffer_size += 1;

      /* See if this was the first one we added */
      if (ev->buffer_end == NULL)
        {
          ev->buffer_end = ev->buffer;
        }
      
      /* See if we have too many to possibly fit on-screen */
      if (ev->buffer_size > 100)
        {
          GList* prev = ev->buffer_end->prev;
          
          prev->next = NULL;
          
          g_strfreev(ev->buffer_end->data);
          g_list_free_1(ev->buffer_end);

          ev->buffer_end = prev;

          ev->buffer_size -= 1;
        }
    }

  if (GTK_WIDGET_DRAWABLE (ev))
    gtk_widget_queue_draw_area(GTK_WIDGET(ev), 
                               ev->description_rect.x,
                               ev->description_rect.y,
                               ev->description_rect.width,
                               ev->description_rect.height);
}

static gchar*
event_name_line(GdkEvent* event)
{
  switch (event->type)
    {
    case GDK_NOTHING:
      return g_strdup(_("Invalid event!\n"));
      break;
      
    case GDK_DELETE:
      return g_strdup(_("Delete\n"));
      break;
               
    case GDK_DESTROY:
      return g_strdup(_("Destroy\n"));
      break;
               
    case GDK_EXPOSE:
      return g_strdup(_("Expose\n"));
      break;
               
    case GDK_MOTION_NOTIFY:
      return g_strdup(_("Motion Notify\n"));
      break;
    
    case GDK_BUTTON_PRESS:
      return g_strdup(_("Button Press\n"));
      break;

    case GDK_2BUTTON_PRESS:
      return g_strdup(_("2 Button Press\n"));
      break;
    
    case GDK_3BUTTON_PRESS:
      return g_strdup(_("3 Button Press\n"));
      break;
    
    case GDK_BUTTON_RELEASE:
      return g_strdup(_("Button Release\n"));
      break;
   
    case GDK_KEY_PRESS:
      return g_strdup(_("Key Press\n"));
      break;
               
    case GDK_KEY_RELEASE:
      return g_strdup(_("Key Release\n"));
      break;
      
    case GDK_ENTER_NOTIFY:
      return g_strdup(_("Enter Notify\n"));
      break;
     
    case GDK_LEAVE_NOTIFY:
      return g_strdup(_("Leave Notify\n"));
      break;
     
    case GDK_FOCUS_CHANGE:
      return g_strdup(_("Focus Change\n"));
      break;
     
    case GDK_CONFIGURE:
      return g_strdup(_("Configure\n"));
      break;
               
    case GDK_MAP:
      return g_strdup(_("Map\n"));
      break;
               
    case GDK_UNMAP:
      return g_strdup(_("Unmap\n"));
      break;
               
    case GDK_PROPERTY_NOTIFY:
      return g_strdup(_("Property Notify\n"));
      break;
  
    case GDK_SELECTION_CLEAR:
      return g_strdup(_("Selection Clear\n"));
      break;
  
    case GDK_SELECTION_REQUEST:
      return g_strdup(_("Selection Request\n"));
      break;

    case GDK_SELECTION_NOTIFY:
      return g_strdup(_("Selection Notify\n"));
      break;
 
    case GDK_PROXIMITY_IN:
      return g_strdup(_("Proximity In\n"));
      break;
     
    case GDK_PROXIMITY_OUT:
      return g_strdup(_("Proximity Out\n"));
      break;
    
    case GDK_DRAG_ENTER:
      return g_strdup(_("Drag Enter\n"));
      break;
       
    case GDK_DRAG_LEAVE:
      return g_strdup(_("Drag Leave\n"));
      break;
       
    case GDK_DRAG_MOTION:
      return g_strdup(_("Drag Motion\n"));
      break;
      
    case GDK_DRAG_STATUS:
      return g_strdup(_("Drag Status\n"));
      break;
      
    case GDK_DROP_START:
      return g_strdup(_("Drop Start\n"));
      break;
       
    case GDK_DROP_FINISHED: 
      return g_strdup(_("Drop Finished\n"));
      break;
    
    case GDK_CLIENT_EVENT:
      return g_strdup(_("Client Event\n"));
      break;
     
    case GDK_VISIBILITY_NOTIFY:
      return g_strdup(_("Visibility Notify\n"));
      break;

    case GDK_NO_EXPOSE:
      return g_strdup(_("No Expose\n"));
      break;
               
    default:
      g_assert_not_reached();
      return NULL;
      break;
    }
}

static gchar* 
any_event_line(GdkEvent* event)
{
  guint32 event_time;

  event_time = gdk_event_get_time(event);

  if (event_time != GDK_CURRENT_TIME)
    return g_strdup_printf(_("Window: %p Time: %u send_event: %s\n"),
                           event->any.window, 
                           event_time,
                           event->any.send_event ? _("True") : _("False"));
  else
    return g_strdup_printf(_("Window: %p send_event: %s\n"),
                           event->any.window, 
                           event->any.send_event ? _("True") : _("False"));
}

#define MAX_STATES 30

static gchar* 
event_state_line(GdkModifierType state)
{
  gchar** states;
  gint n_active;

  states = g_new(gchar*, MAX_STATES);

  n_active = 0;
  
  if (state & GDK_SHIFT_MASK)
    {
      states[n_active] = _("Shift");
      ++n_active;
    }   
  if (state & GDK_LOCK_MASK)
    {
      states[n_active] = _("Lock");
      ++n_active;
    }      
  if (state & GDK_CONTROL_MASK)
    {
      states[n_active] = _("Ctrl");
      ++n_active;
    } 
  if (state & GDK_MOD1_MASK)
    {
      states[n_active] = _("Mod1");
      ++n_active;
    }      
  if (state & GDK_MOD2_MASK)
    {
      states[n_active] = _("Mod2");
      ++n_active;
    }      
  if (state & GDK_MOD3_MASK)
    {
      states[n_active] = _("Mod3");
      ++n_active;
    }      
  if (state & GDK_MOD4_MASK)
    {
      states[n_active] = _("Mod4");
      ++n_active;
    }      
  if (state & GDK_MOD5_MASK)
    {
      states[n_active] = _("Mod5");
      ++n_active;
    }      
  if (state & GDK_BUTTON1_MASK)
    {
      states[n_active] = _("Button1");
      ++n_active;
    } 
  if (state & GDK_BUTTON2_MASK)
    {
      states[n_active] = _("Button2");
      ++n_active;
    } 
  if (state & GDK_BUTTON3_MASK)
    {
      states[n_active] = _("Button3");
      ++n_active;
    } 
  if (state & GDK_BUTTON4_MASK)
    {
      states[n_active] = _("Button4");
      ++n_active;
    } 
  if (state & GDK_BUTTON5_MASK)
    {
      states[n_active] = _("Button4");
      ++n_active;
    } 
  if (state & GDK_RELEASE_MASK)
    {
      states[n_active] = _("Release");
      ++n_active;
    }   

  if (n_active == 0)
    return NULL;
  else
    {
      /* Not efficient, but not important */

      gchar* str = NULL;
      gchar* tmp = NULL;

      guint i = 0;
      while (i < n_active)
        {

          if (str)
            {
              tmp = str;          
              str = g_strconcat(str, " | ", states[i], NULL);
              g_free(tmp);
            }
          else
            {
              str = g_strdup(states[i]);
            }

          ++i;
        }

      tmp = str;
      str = g_strconcat(str, "\n", NULL);
      g_free(tmp);

      return str;
    }
}

static gchar* 
event_to_text (GdkEvent* event)
{
  gchar* any_line;
  gchar* name_line;
  gchar* entire_line;
  gchar* detail;
  gchar* state;

  name_line = event_name_line(event);
  any_line = any_event_line(event);

  entire_line = NULL;
  detail = NULL;
  state = NULL;

  switch (event->type)
    {
    case GDK_NOTHING:
      break;
      
    case GDK_DELETE:
      break;
               
    case GDK_DESTROY:
      break;
               
    case GDK_EXPOSE:
      detail = g_strdup_printf(_("Area: %d,%d  %dx%d Count: %d\n"),
                               event->expose.area.x, 
                               event->expose.area.y,
                               event->expose.area.width,
                               event->expose.area.height,
                               event->expose.count);
      break;
               
    case GDK_MOTION_NOTIFY:
      detail = g_strdup_printf(_("x: %g y: %g\n"),
                               event->motion.x, 
                               event->motion.y);
      state = event_state_line(event->motion.state);
      break;
    
    case GDK_BUTTON_PRESS:
    case GDK_2BUTTON_PRESS:
    case GDK_3BUTTON_PRESS:
    case GDK_BUTTON_RELEASE:
      detail = g_strdup_printf(_("Button: %d\n"),
                               event->button.button);
      state = event_state_line(event->button.state);
      break;
   
    case GDK_KEY_PRESS:
    case GDK_KEY_RELEASE:
      detail = g_strdup_printf(_("Keyval: GDK_%s Text: %s\n"),
                               gdk_keyval_name(event->key.keyval),
                               event->key.string);
      state = event_state_line(event->key.state);
      break;
      
    case GDK_ENTER_NOTIFY:
      break;
     
    case GDK_LEAVE_NOTIFY:
      break;
     
    case GDK_FOCUS_CHANGE:
      break;
     
    case GDK_CONFIGURE:
      break;
               
    case GDK_MAP:
      break;
               
    case GDK_UNMAP:
      break;
               
    case GDK_PROPERTY_NOTIFY:
      break;
  
    case GDK_SELECTION_CLEAR:
      break;
  
    case GDK_SELECTION_REQUEST:
      break;

    case GDK_SELECTION_NOTIFY:
      break;
 
    case GDK_PROXIMITY_IN:
      break;
     
    case GDK_PROXIMITY_OUT:
      break;
    
    case GDK_DRAG_ENTER:
      break;
       
    case GDK_DRAG_LEAVE:
      break;
       
    case GDK_DRAG_MOTION:
      break;
      
    case GDK_DRAG_STATUS:
      break;
      
    case GDK_DROP_START:
      break;
       
    case GDK_DROP_FINISHED:
      break;
    
    case GDK_CLIENT_EVENT:
      break;
     
    case GDK_VISIBILITY_NOTIFY:
      break;

    case GDK_NO_EXPOSE:
      break;
               
    default:
      g_assert_not_reached();
      break;
    }

  if (entire_line == NULL)
    {
      /* Assumes we always have a detail if we have a state */

      entire_line = g_strconcat(name_line, 
                                "  ", any_line, 
                                detail ? "  " : NULL, detail, 
                                state ? "  " : NULL, state,
                                NULL);
    }

  g_free(name_line);
  g_free(any_line);
  g_free(detail);
  g_free(state);

  return entire_line;
}


Gtk+/Gnome Application Development
Prev Home Next

 
 
  Published under free license. Design by Interspire