static void close_dialog(GtkWidget* button, gpointer data)
{
PagerData* pager = data;
GtkTreeViewColumn* col;
#if GTK_CHECK_VERSION (3, 0, 0)
GtkCellArea *area;
GtkCellEditable *edit_widget;
#endif
/* This is a hack. The "editable" signal for GtkCellRenderer is emitted
only on button press or focus cycle. Hence when the user changes the
name and closes the preferences dialog without a button-press he would
lose the name changes. So, we call the gtk_cell_editable_editing_done
to stop the editing. Thanks to Paolo for a better crack than the one I had.
*/
col = gtk_tree_view_get_column(GTK_TREE_VIEW(pager->workspaces_tree), 0);
#if GTK_CHECK_VERSION (3, 0, 0)
area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (col));
edit_widget = gtk_cell_area_get_edit_widget (area);
if (edit_widget)
gtk_cell_editable_editing_done (edit_widget);
#else
if (col->editable_widget != NULL && GTK_IS_CELL_EDITABLE(col->editable_widget))
gtk_cell_editable_editing_done(col->editable_widget);
#endif
gtk_widget_destroy(pager->properties_dialog);
}
static void
preferences_response (MCPrefsDialog *dialog,
int id,
MCData *mc)
{
switch (id) {
case GTK_RESPONSE_HELP:
show_help_section (GTK_WINDOW (dialog), "command-line-prefs-0");
break;
case GTK_RESPONSE_CLOSE:
default: {
GtkTreeViewColumn *col;
dialog = &mc->prefs_dialog;
/* A hack to make sure 'edited' on the renderer if we
* close the dialog while editing.
*/
col = gtk_tree_view_get_column (GTK_TREE_VIEW (dialog->macros_tree), 0);
if (col->editable_widget && GTK_IS_CELL_EDITABLE (col->editable_widget))
gtk_cell_editable_editing_done (col->editable_widget);
col = gtk_tree_view_get_column (GTK_TREE_VIEW (dialog->macros_tree), 1);
if (col->editable_widget && GTK_IS_CELL_EDITABLE (col->editable_widget))
gtk_cell_editable_editing_done (col->editable_widget);
gtk_widget_hide (dialog->dialog);
}
break;
}
}
static gboolean ddb_cell_editable_text_view_real_key_press_event (GtkWidget* base, GdkEventKey* event) {
DdbCellEditableTextView * self;
gboolean result = FALSE;
gboolean res;
GdkEventKey _tmp0_;
guint _tmp1_;
self = (DdbCellEditableTextView*) base;
g_return_val_if_fail (event != NULL, FALSE);
res = TRUE;
_tmp0_ = *event;
_tmp1_ = _tmp0_.keyval;
if (_tmp1_ == ((guint) GDK_Return)) {
GdkEventKey _tmp2_;
GdkModifierType _tmp3_;
_tmp2_ = *event;
_tmp3_ = _tmp2_.state;
if ((_tmp3_ & (GDK_CONTROL_MASK | GDK_SHIFT_MASK)) != 0) {
GdkEventKey _tmp4_;
gboolean _tmp5_ = FALSE;
_tmp4_ = *event;
_tmp5_ = GTK_WIDGET_CLASS (ddb_cell_editable_text_view_parent_class)->key_press_event ((GtkWidget*) GTK_TEXT_VIEW (self), &_tmp4_);
res = _tmp5_;
} else {
gtk_cell_editable_editing_done ((GtkCellEditable*) self);
gtk_cell_editable_remove_widget ((GtkCellEditable*) self);
result = TRUE;
return result;
}
} else {
GdkEventKey _tmp6_;
guint _tmp7_;
_tmp6_ = *event;
_tmp7_ = _tmp6_.keyval;
if (_tmp7_ == ((guint) GDK_Escape)) {
self->priv->editing_canceled = TRUE;
gtk_cell_editable_editing_done ((GtkCellEditable*) self);
gtk_cell_editable_remove_widget ((GtkCellEditable*) self);
result = TRUE;
return result;
} else {
GdkEventKey _tmp8_;
gboolean _tmp9_ = FALSE;
_tmp8_ = *event;
_tmp9_ = GTK_WIDGET_CLASS (ddb_cell_editable_text_view_parent_class)->key_press_event ((GtkWidget*) GTK_TEXT_VIEW (self), &_tmp8_);
res = _tmp9_;
}
}
result = res;
return result;
}
static gboolean
grab_key_callback (GtkWidget *widget,
GdkEventKey *event,
void *data)
{
char *path;
CellRendererKey* key = CELL_RENDERER_KEY(data);
guint scancode = event->hardware_keycode;
gdk_keyboard_ungrab (event->time);
gdk_pointer_ungrab (event->time);
path = g_strdup (g_object_get_data (G_OBJECT (key->edit_widget), CELL_RENDERER_TEXT_PATH));
gtk_cell_editable_editing_done(GTK_CELL_EDITABLE (key->edit_widget));
gtk_cell_editable_remove_widget(GTK_CELL_EDITABLE (key->edit_widget));
key->edit_widget = NULL;
key->grab_widget = NULL;
cell_renderer_key_set_scancode(key, scancode);
g_signal_emit_by_name (G_OBJECT(key), "accel_edited", path, scancode);
g_free (path);
return TRUE;
}
static void
ccm_cell_extension_on_enable_clicked (CCMCellExtension * self)
{
ccm_cell_extension_set_active (self, !self->priv->active);
gtk_cell_editable_editing_done (GTK_CELL_EDITABLE (self));
}
void
cg_combo_flags_popdown(CgComboFlags *combo)
{
CgComboFlagsPrivate *priv;
priv = CG_COMBO_FLAGS_PRIVATE (combo);
if (priv->window != NULL)
{
gtk_grab_remove (priv->window);
gdk_device_ungrab (priv->pointer_device, GDK_CURRENT_TIME);
gdk_device_ungrab (priv->keyboard_device, GDK_CURRENT_TIME);
gtk_widget_hide (priv->window);
g_object_unref (priv->column);
g_idle_add (cg_combo_flags_popdown_idle, priv->window);
priv->window = NULL;
priv->treeview = NULL;
priv->column = NULL;
if (priv->editing_started)
{
priv->editing_started = FALSE;
gtk_cell_editable_editing_done (GTK_CELL_EDITABLE (combo));
/* Seems like someone already calls _remove_widget when the
* cell renderer emits its edited signal (which we rely on if
* the editing was not canceled). */
if (priv->editing_canceled)
gtk_cell_editable_remove_widget (GTK_CELL_EDITABLE (combo));
}
}
}
static gboolean
gpw_key_press_event (GtkWidget *box,
GdkEventKey *key_event)
{
GncPopupEntry *widget = GNC_POPUP_ENTRY (box);
GdkEvent tmp_event;
if (key_event->keyval == GDK_Escape) {
widget->editing_canceled = TRUE;
gtk_cell_editable_editing_done (GTK_CELL_EDITABLE (widget));
gtk_cell_editable_remove_widget (GTK_CELL_EDITABLE (widget));
return TRUE;
}
gtk_widget_grab_focus (widget->entry);
/* Hackish :/ Synthesize a key press event for the entry. */
memcpy (&tmp_event, key_event, sizeof (GdkEventKey));
tmp_event.key.window = widget->entry->window;
tmp_event.key.send_event = TRUE;
gtk_widget_event (widget->entry, &tmp_event);
return GTK_WIDGET_CLASS (parent_class)->key_press_event (GTK_WIDGET (widget),
key_event);
}
static void
preferences_response (MCPrefsDialog *dialog,
int id,
MCData *mc)
{
switch (id) {
case GTK_RESPONSE_HELP:
show_help_section (GTK_WINDOW (dialog), "command-line-prefs-0");
break;
case GTK_RESPONSE_CLOSE:
default: {
GtkTreeViewColumn *col;
GtkCellArea *area;
GtkCellEditable *edit_widget;
dialog = &mc->prefs_dialog;
/* A hack to make sure 'edited' on the renderer if we
* close the dialog while editing.
*/
col = gtk_tree_view_get_column (GTK_TREE_VIEW (dialog->macros_tree), 0);
area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (col));
edit_widget = gtk_cell_area_get_edit_widget (area);
if (edit_widget)
gtk_cell_editable_editing_done (edit_widget);
col = gtk_tree_view_get_column (GTK_TREE_VIEW (dialog->macros_tree), 1);
area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (col));
edit_widget = gtk_cell_area_get_edit_widget (area);
if (edit_widget)
gtk_cell_editable_editing_done (edit_widget);
gtk_widget_hide (dialog->dialog);
}
break;
}
}
static gboolean
key_pressed_cb (GtkWidget *widget,
GdkEvent *event,
gpointer user_data)
{
#if !GDK_KEY_Tab
#define GDK_KEY_Tab GDK_Tab
#endif
/* Tab should behave the same way as Enter (finish editing) */
if (event->type == GDK_KEY_PRESS && event->key.keyval == GDK_KEY_Tab)
gtk_cell_editable_editing_done (GTK_CELL_EDITABLE (widget));
return FALSE;
}
static gboolean
gtk_cell_editable_key_press_event (GtkEntry *entry,
GdkEventKey *key_event,
GncPopupEntry *widget)
{
if (key_event->keyval == GDK_Escape) {
widget->editing_canceled = TRUE;
gtk_cell_editable_editing_done (GTK_CELL_EDITABLE (widget));
gtk_cell_editable_remove_widget (GTK_CELL_EDITABLE (widget));
return TRUE;
}
return FALSE;
}
JNIEXPORT void JNICALL
Java_org_gnome_gtk_GtkCellEditable_gtk_1cell_1editable_1editing_1done
(
JNIEnv* env,
jclass cls,
jlong _self
)
{
GtkCellEditable* self;
// convert parameter self
self = (GtkCellEditable*) _self;
// call function
gtk_cell_editable_editing_done(self);
// cleanup parameter self
}
static gboolean ddb_cell_renderer_text_multiline_gtk_cell_renderer_focus_out_event (DdbCellEditableTextView* entry, GdkEvent* event, DdbCellRendererTextMultiline* _self_) {
gboolean result = FALSE;
g_return_val_if_fail (entry != NULL, FALSE);
g_return_val_if_fail (event != NULL, FALSE);
g_return_val_if_fail (_self_ != NULL, FALSE);
DdbCellRendererTextMultilinePrivate *priv;
priv = DDB_CELL_RENDERER_TEXT_MULTILINE_GET_PRIVATE (_self_);
entry->priv->editing_canceled = TRUE;
if (priv->in_entry_menu)
return FALSE;
gtk_cell_editable_editing_done (GTK_CELL_EDITABLE (entry));
gtk_cell_editable_remove_widget (GTK_CELL_EDITABLE (entry));
result = FALSE;
return result;
}
static void
close_dialog (GtkWidget *button,
gpointer data)
{
PagerData *pager = data;
GtkTreeViewColumn *col;
/* This is a hack. The "editable" signal for GtkCellRenderer is emitted
only on button press or focus cycle. Hence when the user changes the
name and closes the preferences dialog without a button-press he would
lose the name changes. So, we call the gtk_cell_editable_editing_done
to stop the editing. Thanks to Paolo for a better crack than the one I had.
*/
col = gtk_tree_view_get_column(GTK_TREE_VIEW (pager->workspaces_tree),0);
if (col->editable_widget != NULL && GTK_IS_CELL_EDITABLE (col->editable_widget))
gtk_cell_editable_editing_done(col->editable_widget);
gtk_widget_hide (pager->properties_dialog);
}
static void
clear_key_callback(GtkButton *widget, gpointer data)
{
char *path;
CellRendererKey* key = CELL_RENDERER_KEY(data);
gdk_keyboard_ungrab(GDK_CURRENT_TIME);
gdk_pointer_ungrab(GDK_CURRENT_TIME);
path = g_strdup (g_object_get_data (G_OBJECT (key->edit_widget), CELL_RENDERER_TEXT_PATH));
gtk_cell_editable_editing_done(GTK_CELL_EDITABLE (key->edit_widget));
gtk_cell_editable_remove_widget(GTK_CELL_EDITABLE (key->edit_widget));
key->edit_widget = NULL;
key->grab_widget = NULL;
cell_renderer_key_set_scancode(key, 0);
g_signal_emit_by_name (G_OBJECT(key), "accel_cleared", path);
g_free (path);
}
static gboolean
gtk_cell_editable_key_press_event (GtkEntry *entry,
GdkEventKey *key_event,
GncPopupEntry *widget)
{
const char *date_string;
gint year = 0, month = 0, day = 0;
struct tm when;
if (key_event->keyval == GDK_KEY_Escape)
{
widget->editing_canceled = TRUE;
gtk_cell_editable_editing_done (GTK_CELL_EDITABLE (widget));
gtk_cell_editable_remove_widget (GTK_CELL_EDITABLE (widget));
return TRUE;
}
date_string = gtk_entry_get_text (entry);
memset (&when, 0, sizeof (when));
if (qof_scan_date (date_string, &day, &month, &year))
{
when.tm_year = year - 1900;
when.tm_mon = month - 1 ;
when.tm_mday = day;
if (!gnc_handle_date_accelerator (key_event, &when, date_string))
return FALSE;
gtk_entry_set_text (entry, qof_print_date (gnc_mktime (&when)));
gtk_widget_grab_focus (GTK_WIDGET (entry));
return TRUE;
}
return FALSE;
}
/* GtkCellEditable method implementations
*/
static void
gtk_cell_editable_entry_activated (GtkEntry *entry, GncPopupEntry *widget)
{
gtk_cell_editable_editing_done (GTK_CELL_EDITABLE (widget));
gtk_cell_editable_remove_widget (GTK_CELL_EDITABLE (widget));
}
static VALUE
rg_editing_done(VALUE self)
{
gtk_cell_editable_editing_done(_SELF(self));
return self;
}
static gboolean
grab_key_callback (GtkWidget *widget,
GdkEventKey *event,
GtkCellRendererAccel *accel)
{
GdkModifierType accel_mods = 0;
guint accel_key;
gchar *path;
gboolean edited;
gboolean cleared;
GdkModifierType consumed_modifiers;
GdkDisplay *display;
display = gtk_widget_get_display (widget);
if (event->is_modifier)
return TRUE;
edited = FALSE;
cleared = FALSE;
gdk_keymap_translate_keyboard_state (gdk_keymap_get_for_display (display),
event->hardware_keycode,
event->state,
event->group,
NULL, NULL, NULL, &consumed_modifiers);
accel_key = gdk_keyval_to_lower (event->keyval);
if (accel_key == GDK_ISO_Left_Tab)
accel_key = GDK_Tab;
accel_mods = event->state & gtk_accelerator_get_default_mod_mask ();
/* Filter consumed modifiers
*/
if (accel->accel_mode == GTK_CELL_RENDERER_ACCEL_MODE_GTK)
accel_mods &= ~consumed_modifiers;
/* Put shift back if it changed the case of the key, not otherwise.
*/
if (accel_key != event->keyval)
accel_mods |= GDK_SHIFT_MASK;
if (accel_mods == 0)
{
switch (event->keyval)
{
case GDK_Escape:
goto out; /* cancel */
case GDK_BackSpace:
/* clear the accelerator on Backspace */
cleared = TRUE;
goto out;
default:
break;
}
}
if (accel->accel_mode == GTK_CELL_RENDERER_ACCEL_MODE_GTK)
{
if (!gtk_accelerator_valid (accel_key, accel_mods))
{
gtk_widget_error_bell (widget);
return TRUE;
}
}
edited = TRUE;
out:
gdk_display_keyboard_ungrab (display, event->time);
gdk_display_pointer_ungrab (display, event->time);
path = g_strdup (g_object_get_data (G_OBJECT (accel->edit_widget), "gtk-cell-renderer-text"));
gtk_cell_editable_editing_done (GTK_CELL_EDITABLE (accel->edit_widget));
gtk_cell_editable_remove_widget (GTK_CELL_EDITABLE (accel->edit_widget));
accel->edit_widget = NULL;
accel->grab_widget = NULL;
if (edited)
g_signal_emit (accel, signals[ACCEL_EDITED], 0, path,
accel_key, accel_mods, event->hardware_keycode);
else if (cleared)
g_signal_emit (accel, signals[ACCEL_CLEARED], 0, path);
g_free (path);
return TRUE;
}
/*
* GtkCellEditable interface
*/
static void
gtk_cell_editable_entry_editing_done_cb (G_GNUC_UNUSED GtkEntry *entry, GdauiEntryString *mgstr)
{
gtk_cell_editable_editing_done (GTK_CELL_EDITABLE (mgstr));
}
static gboolean grab_key_callback(GtkWidget* widget, GdkEventKey* event, void* data)
{
GdkModifierType accel_mods = 0;
guint accel_keyval;
EggCellRendererKeys *keys;
char *path;
gboolean edited;
gboolean cleared;
GdkModifierType consumed_modifiers;
guint upper;
GdkModifierType ignored_modifiers;
keys = EGG_CELL_RENDERER_KEYS(data);
if (is_modifier(event->hardware_keycode))
{
return TRUE;
}
edited = FALSE;
cleared = FALSE;
consumed_modifiers = 0;
gdk_keymap_translate_keyboard_state(gdk_keymap_get_default(),
event->hardware_keycode,
event->state,
event->group,
NULL, NULL, NULL, &consumed_modifiers);
upper = event->keyval;
accel_keyval = gdk_keyval_to_lower(upper);
if (accel_keyval == GDK_ISO_Left_Tab)
{
accel_keyval = GDK_Tab;
}
/* Put shift back if it changed the case of the key, not otherwise. */
if (upper != accel_keyval && (consumed_modifiers & GDK_SHIFT_MASK))
{
consumed_modifiers &= ~(GDK_SHIFT_MASK);
}
egg_keymap_resolve_virtual_modifiers(gdk_keymap_get_default(),
EGG_VIRTUAL_NUM_LOCK_MASK |
EGG_VIRTUAL_SCROLL_LOCK_MASK |
EGG_VIRTUAL_LOCK_MASK,
&ignored_modifiers);
/* http://bugzilla.gnome.org/show_bug.cgi?id=139605
* mouse keys should effect keybindings */
ignored_modifiers |= GDK_BUTTON1_MASK |
GDK_BUTTON2_MASK |
GDK_BUTTON3_MASK |
GDK_BUTTON4_MASK |
GDK_BUTTON5_MASK;
/* filter consumed/ignored modifiers */
if (keys->accel_mode == EGG_CELL_RENDERER_KEYS_MODE_GTK)
{
accel_mods = event->state & GDK_MODIFIER_MASK & ~(consumed_modifiers | ignored_modifiers);
}
else if (keys->accel_mode == EGG_CELL_RENDERER_KEYS_MODE_X)
{
accel_mods = event->state & GDK_MODIFIER_MASK & ~(ignored_modifiers);
}
else
{
g_assert_not_reached();
}
if (accel_mods == 0 && accel_keyval == GDK_Escape)
{
goto out; /* cancel */
}
/* clear the accelerator on Backspace */
if (accel_mods == 0 && accel_keyval == GDK_BackSpace)
{
cleared = TRUE;
goto out;
}
if (keys->accel_mode == EGG_CELL_RENDERER_KEYS_MODE_GTK)
{
if (!gtk_accelerator_valid (accel_keyval, accel_mods))
{
accel_keyval = 0;
accel_mods = 0;
}
}
edited = TRUE;
out:
gdk_keyboard_ungrab(event->time);
gdk_pointer_ungrab(event->time);
path = g_strdup(g_object_get_data(G_OBJECT(keys->edit_widget), EGG_CELL_RENDERER_TEXT_PATH));
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;
if (edited)
{
g_signal_emit_by_name(G_OBJECT(keys), "accel_edited", path, accel_keyval, accel_mods, event->hardware_keycode);
}
else if (cleared)
{
g_signal_emit_by_name(G_OBJECT(keys), "accel_cleared", path);
}
g_free (path);
return TRUE;
}
