path: root/src/gnome/gnome-cellrendererkeys.c

/*
 * Copyright (C) 2003 Benjamin Otte <otte@gnome.org>
 *
 * based on EggCellRendererKeys
 * Copyright (C) 2000 Red Hat, Inc., Jonathan Blandford <jrb@redhat.com>
 *
 * 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.
 *
 * $Id$
 */

#ifdef HAVE_CONFIG_H
#  include "config.h"
#endif

#include "gnome-cellrendererkeys.h"

#include <glib/gi18n.h>
#include <gdk/gdkkeysyms.h>

#include "gnome-marshal.h"

#define GAME_CELL_RENDERER_TEXT_PATH "game-cell-renderer-text"

static void             game_cell_renderer_keys_finalize      (GObject             *object);
static void             game_cell_renderer_keys_init          (GameCellRendererKeys *cell_keys);
static void             game_cell_renderer_keys_class_init    (GameCellRendererKeysClass *cell_keys_class);
static GtkCellEditable *game_cell_renderer_keys_start_editing (GtkCellRenderer          *cell,
							      GdkEvent                 *event,
							      GtkWidget                *widget,
							      const gchar              *path,
							      GdkRectangle             *background_area,
							      GdkRectangle             *cell_area,
							      GtkCellRendererState      flags);


static void game_cell_renderer_keys_get_property (GObject         *object,
						 guint            param_id,
						 GValue          *value,
						 GParamSpec      *pspec);
static void game_cell_renderer_keys_set_property (GObject         *object,
						 guint            param_id,
						 const GValue    *value,
						 GParamSpec      *pspec);
static void game_cell_renderer_keys_get_size     (GtkCellRenderer *cell,
						 GtkWidget       *widget,
						 GdkRectangle    *cell_area,
						 gint            *x_offset,
						 gint            *y_offset,
						 gint            *width,
						 gint            *height);


enum {
  PROP_0,

  PROP_KEYCODE,
};

static GtkCellRendererTextClass *parent_class = NULL;

GType
game_cell_renderer_keys_get_type (void)
{
  static GType cell_keys_type = 0;

  if (!cell_keys_type)
    {
      static const GTypeInfo cell_keys_info =
      {
        sizeof (GameCellRendererKeysClass),
	NULL,		/* base_init */
	NULL,		/* base_finalize */
        (GClassInitFunc)game_cell_renderer_keys_class_init,
	NULL,		/* class_finalize */
	NULL,		/* class_data */
        sizeof (GameCellRendererKeys),
	0,              /* n_preallocs */
        (GInstanceInitFunc) game_cell_renderer_keys_init
      };

      cell_keys_type = g_type_register_static (GTK_TYPE_CELL_RENDERER_TEXT, "GameCellRendererKeys", &cell_keys_info, 0);
    }

  return cell_keys_type;
}

static void
game_cell_renderer_keys_init (GameCellRendererKeys *cell_keys)
{
}
static void
game_cell_renderer_keys_class_init (GameCellRendererKeysClass *cell_keys_class)
{
  GObjectClass *object_class;
  GtkCellRendererClass *cell_renderer_class;

  object_class = G_OBJECT_CLASS (cell_keys_class);
  cell_renderer_class = GTK_CELL_RENDERER_CLASS (cell_keys_class);
  parent_class = g_type_class_peek_parent (object_class);
  
  GTK_CELL_RENDERER_CLASS (cell_keys_class)->start_editing = game_cell_renderer_keys_start_editing;

  object_class->set_property = game_cell_renderer_keys_set_property;
  object_class->get_property = game_cell_renderer_keys_get_property;
  cell_renderer_class->get_size = game_cell_renderer_keys_get_size;

  object_class->finalize = game_cell_renderer_keys_finalize;
  
  g_object_class_install_property (object_class, PROP_KEYCODE,
	  g_param_spec_uint ("keycode", _("keycode"), _("hardware keycode"),
	  0, 32767 /* G_MAXUINT16 */, 0, G_PARAM_READWRITE));

  g_signal_new ("keys_edited", GAME_TYPE_CELL_RENDERER_KEYS, G_SIGNAL_RUN_LAST,
                G_STRUCT_OFFSET (GameCellRendererKeysClass, keys_edited), NULL, NULL,
                game_gnome_marshal_VOID__STRING_UINT, G_TYPE_NONE, 2, G_TYPE_STRING, G_TYPE_UINT);
}


GtkCellRenderer *
game_cell_renderer_keys_new (void)
{
  return GTK_CELL_RENDERER (g_object_new (GAME_TYPE_CELL_RENDERER_KEYS, NULL));
}

static void
game_cell_renderer_keys_finalize (GObject *object)
{
  (* G_OBJECT_CLASS (parent_class)->finalize) (object);
}
static void
game_cell_renderer_keys_get_property (GObject *object, guint param_id, GValue *value, GParamSpec *pspec)
{
  GameCellRendererKeys *keys;

  g_return_if_fail (GAME_IS_CELL_RENDERER_KEYS (object));

  keys = GAME_CELL_RENDERER_KEYS (object);
  
  switch (param_id) {
    case PROP_KEYCODE:
      g_value_set_uint (value, keys->keycode);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
      break;
  }
}
static void
game_cell_renderer_keys_set_property (GObject *object, guint param_id, const GValue *value, GParamSpec *pspec)
{
  GameCellRendererKeys *keys;

  g_return_if_fail (GAME_IS_CELL_RENDERER_KEYS (object));

  keys = GAME_CELL_RENDERER_KEYS (object);
  
  switch (param_id) {
    case PROP_KEYCODE:
      game_cell_renderer_keys_set_keycode (keys, g_value_get_uint (value));
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
      break;
  }
}
static void
game_cell_renderer_keys_get_size (GtkCellRenderer *cell, GtkWidget *widget, GdkRectangle *cell_area,
				  gint *x_offset, gint *y_offset, gint *width, gint *height)
{
  GameCellRendererKeys *keys = (GameCellRendererKeys *) cell;
  GtkRequisition requisition;

  if (keys->sizing_label == NULL)
    keys->sizing_label = gtk_label_new (_("Press the key to use"));

  gtk_widget_size_request (keys->sizing_label, &requisition);
  (* GTK_CELL_RENDERER_CLASS (parent_class)->get_size) (cell, widget, cell_area, x_offset, y_offset, width, height);
  /* FIXME: need to take the cell_area et al. into account */
  if (width)
    *width = MAX (*width, requisition.width);
  if (height)
    *height = MAX (*height, requisition.height);
}

/* FIXME: Currently we don't differentiate between a 'bogus' key (like tab in
 * GTK mode) and a removed key.
 */
   
static gboolean
grab_key_callback (GtkWidget *widget, GdkEventKey *event, gpointer data)
{
  GameCellRendererKeys *keys;
  char *path;
  
  keys = GAME_CELL_RENDERER_KEYS (data);

  path = g_strdup (g_object_get_data (G_OBJECT (keys->edit_widget),
                                      GAME_CELL_RENDERER_TEXT_PATH));
  
  gdk_keyboard_ungrab (event->time);
  gdk_pointer_ungrab (event->time);
  
  gtk_cell_editable_editing_done (GTK_CELL_EDITABLE (keys->edit_widget));
  gtk_cell_editable_remove_widget (GTK_CELL_EDITABLE (keys->edit_widget));
  keys->edit_widget = NULL;
  keys->grab_widget = NULL;
  
  g_signal_emit_by_name (G_OBJECT (keys), "keys_edited", path, (guint) event->hardware_keycode);

  g_free (path);
  
  return TRUE;
}

static void
ungrab_stuff (GtkWidget *widget, gpointer data)
{
  GameCellRendererKeys *keys = GAME_CELL_RENDERER_KEYS (data);

  gdk_keyboard_ungrab (GDK_CURRENT_TIME);
  gdk_pointer_ungrab (GDK_CURRENT_TIME);

  g_signal_handlers_disconnect_by_func (G_OBJECT (keys->grab_widget),
                                        G_CALLBACK (grab_key_callback), data);
}

static void
pointless_eventbox_start_editing (GtkCellEditable *cell_editable,
                                  GdkEvent        *event)
{
  /* do nothing, because we are pointless */
}

static void
pointless_eventbox_cell_editable_init (GtkCellEditableIface *iface)
{
  iface->start_editing = pointless_eventbox_start_editing;
}

static GType
pointless_eventbox_subclass_get_type (void)
{
  static GType eventbox_type = 0;

  if (!eventbox_type)
    {
      static const GTypeInfo eventbox_info =
      {
        sizeof (GtkEventBoxClass),
	NULL,		/* base_init */
	NULL,		/* base_finalize */
        NULL,
	NULL,		/* class_finalize */
	NULL,		/* class_data */
        sizeof (GtkEventBox),
	0,              /* n_preallocs */
        (GInstanceInitFunc) NULL,
      };

      static const GInterfaceInfo cell_editable_info = {
        (GInterfaceInitFunc) pointless_eventbox_cell_editable_init,
        NULL, NULL };

      eventbox_type = g_type_register_static (GTK_TYPE_EVENT_BOX, "GameCellEditableEventBox", &eventbox_info, 0);
      
      g_type_add_interface_static (eventbox_type,
				   GTK_TYPE_CELL_EDITABLE,
				   &cell_editable_info);
    }

  return eventbox_type;
}
static GtkCellEditable *
game_cell_renderer_keys_start_editing (GtkCellRenderer *cell, GdkEvent *event, GtkWidget *widget,
				       const gchar *path, GdkRectangle *background_area, 
				       GdkRectangle *cell_area, GtkCellRendererState flags)
{
  GameCellRendererKeys *keys;
  GdkWindow *window;
  GtkWidget *label;
  GtkWidget *eventbox;
  
  keys = GAME_CELL_RENDERER_KEYS (cell);
  
  window = gtk_widget_get_window (widget);
  if (window == NULL)
    return NULL;
  
  if (gdk_keyboard_grab (window, FALSE, gdk_event_get_time (event)) != GDK_GRAB_SUCCESS)
    return NULL;

  if (gdk_pointer_grab (window, FALSE, GDK_BUTTON_PRESS_MASK, FALSE, NULL,
	                gdk_event_get_time (event)) != GDK_GRAB_SUCCESS) {
    gdk_keyboard_ungrab (gdk_event_get_time (event));
    return NULL;
  }
  
  keys->grab_widget = widget;

  g_signal_connect (G_OBJECT (widget), "key_press_event",
                    G_CALLBACK (grab_key_callback),
                    keys);

  eventbox = g_object_new (pointless_eventbox_subclass_get_type (), NULL);
  keys->edit_widget = eventbox;
  g_object_add_weak_pointer (G_OBJECT (keys->edit_widget), (void**) &keys->edit_widget);
  
  label = gtk_label_new (NULL);
  gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
  
  gtk_label_set_text (GTK_LABEL (label), _("Press the key to use"));

  gtk_container_add (GTK_CONTAINER (eventbox), label);
  
  g_object_set_data_full (G_OBJECT (keys->edit_widget), GAME_CELL_RENDERER_TEXT_PATH,
                          g_strdup (path), g_free);
  
  gtk_widget_show_all (keys->edit_widget);

  g_signal_connect (G_OBJECT (keys->edit_widget), "unrealize",
                    G_CALLBACK (ungrab_stuff), keys);
  
  return GTK_CELL_EDITABLE (keys->edit_widget);
}
static gchar *
lookup_key (guint16 hw_keyval)
{
  gchar *ret;
  GdkKeymapKey key = {hw_keyval, 0, 0};
  guint keycode;
  
  keycode = gdk_keymap_lookup_key (NULL, &key);
  keycode = gdk_keyval_to_upper (keycode);
  ret = gdk_keyval_name (keycode);
  if (ret == NULL) {
    if (hw_keyval == 0) {
      ret = g_strdup (_("undefined"));
    } else {
      ret = g_strdup_printf (_("Key %u"), hw_keyval);
    }
  } else {
    ret = g_strdup (ret);
  }
  
  return ret;
}
void
game_cell_renderer_keys_set_keycode (GameCellRendererKeys *keys, guint keycode)
{
  char *text;

  g_return_if_fail (GAME_IS_CELL_RENDERER_KEYS (keys));

  if (keycode == keys->keycode) return;
  
  keys->keycode = keycode;
  g_object_notify (G_OBJECT (keys), "keycode");

  /* sync string to the key values */
  text = lookup_key (keycode);
  g_object_set (keys, "text", text, NULL);
  g_free (text);
}