static void
screen_sharing_password_insert_text_cb (GtkEditable *editable,
gchar *new_text,
gint new_text_length,
gpointer position,
gpointer user_data)
{
int l, available_size;
l = gtk_entry_buffer_get_bytes (gtk_entry_get_buffer (GTK_ENTRY (editable)));
if (l + new_text_length <= MAX_PASSWORD_SIZE)
return;
g_signal_stop_emission_by_name (editable, "insert-text");
gtk_widget_error_bell (GTK_WIDGET (editable));
available_size = g_utf8_strlen (new_text, MAX_PASSWORD_SIZE - l);
if (available_size == 0)
return;
g_signal_handlers_block_by_func (editable,
(gpointer) screen_sharing_password_insert_text_cb,
user_data);
gtk_editable_insert_text (editable, new_text, available_size, position);
g_signal_handlers_unblock_by_func (editable,
(gpointer) screen_sharing_password_insert_text_cb,
user_data);
}
static void
set_status (EphyFindToolbar *toolbar,
EphyFindResult result)
{
const char *icon_name = "edit-find-symbolic";
const char *tooltip = NULL;
switch (result)
{
case EPHY_FIND_RESULT_FOUND:
break;
case EPHY_FIND_RESULT_NOTFOUND:
icon_name = "face-uncertain-symbolic";
tooltip = _("Text not found");
gtk_widget_error_bell (GTK_WIDGET (toolbar));
break;
case EPHY_FIND_RESULT_FOUNDWRAPPED:
icon_name = "view-wrapped-symbolic";
tooltip = _("Search wrapped back to the top");
break;
}
gtk_widget_set_sensitive (toolbar->prev, result != EPHY_FIND_RESULT_NOTFOUND);
gtk_widget_set_sensitive (toolbar->next, result != EPHY_FIND_RESULT_NOTFOUND);
g_object_set (toolbar->entry,
"primary-icon-name", icon_name,
"primary-icon-activatable", FALSE,
"primary-icon-sensitive", FALSE,
"primary-icon-tooltip-text", tooltip,
NULL);
}
static void
tree_view_move_focus (GtkTreeView *view,
GtkMovementStep step,
gint amount)
{
GtkTreeIter iter;
GtkTreePath *path;
GtkTreeModel *model = gtk_tree_view_get_model (view);
gboolean valid = FALSE;
gtk_tree_view_get_cursor (view, &path, NULL);
if (! path) {
valid = gtk_tree_model_get_iter_first (model, &iter);
} else {
switch (step) {
case GTK_MOVEMENT_BUFFER_ENDS:
valid = gtk_tree_model_get_iter_first (model, &iter);
if (valid && amount > 0) {
GtkTreeIter prev;
do {
prev = iter;
} while (gtk_tree_model_iter_next (model, &iter));
iter = prev;
}
break;
case GTK_MOVEMENT_PAGES:
/* FIXME: move by page */
case GTK_MOVEMENT_DISPLAY_LINES:
gtk_tree_model_get_iter (model, &iter, path);
if (amount > 0) {
while ((valid = gtk_tree_model_iter_next (model, &iter)) &&
--amount > 0)
;
} else if (amount < 0) {
while ((valid = gtk_tree_path_prev (path)) && --amount > 0)
;
if (valid) {
gtk_tree_model_get_iter (model, &iter, path);
}
}
break;
default:
g_assert_not_reached ();
}
gtk_tree_path_free (path);
}
if (valid) {
tree_view_set_cursor_from_iter (view, &iter);
} else {
gtk_widget_error_bell (GTK_WIDGET (view));
}
}
static void
gimp_scale_combo_box_entry_activate (GtkWidget *entry,
GimpScaleComboBox *combo_box)
{
const gchar *text = gtk_entry_get_text (GTK_ENTRY (entry));
gdouble scale;
if (gimp_scale_combo_box_parse_text (text, &scale) &&
scale >= 1.0 / 256.0 &&
scale <= 256.0)
{
gimp_scale_combo_box_set_scale (combo_box, scale);
}
else
{
gtk_widget_error_bell (entry);
gimp_scale_combo_box_set_scale (combo_box, combo_box->scale);
}
g_signal_emit (combo_box, scale_combo_box_signals[ENTRY_ACTIVATED], 0);
}
/*
* We need to override this because when we don't show the tabs, like in
* fullscreen we need to have wrap around too
*/
static gboolean
gedit_notebook_change_current_page (GtkNotebook *notebook,
gint offset)
{
gboolean wrap_around;
gint current;
current = gtk_notebook_get_current_page (notebook);
if (current != -1)
{
current = current + offset;
g_object_get (gtk_widget_get_settings (GTK_WIDGET (notebook)),
"gtk-keynav-wrap-around", &wrap_around,
NULL);
if (wrap_around)
{
if (current < 0)
{
current = gtk_notebook_get_n_pages (notebook) - 1;
}
else if (current >= gtk_notebook_get_n_pages (notebook))
{
current = 0;
}
}
gtk_notebook_set_current_page (notebook, current);
}
else
{
gtk_widget_error_bell (GTK_WIDGET (notebook));
}
return TRUE;
}
static void search_entry_changed_cb (GtkEditable *editable, YGtkHelpDialog *dialog)
{
static GdkColor red = { 0, 255 << 8, 102 << 8, 102 << 8 };
static GdkColor white = { 0, 0xffff, 0xffff, 0xffff };
static GdkColor yellow = { 0, 0xf7f7, 0xf7f7, 0xbdbd };
static GdkColor black = { 0, 0, 0, 0 };
GtkWidget *widget = GTK_WIDGET (editable);
GtkEntry *entry = GTK_ENTRY (editable);
const gchar *text = gtk_entry_get_text (entry);
gboolean found = ygtk_html_wrap_search (dialog->help_text, text);
if (found && *text) {
gtk_widget_modify_base (widget, GTK_STATE_NORMAL, &yellow);
gtk_widget_modify_text (widget, GTK_STATE_NORMAL, &black);
}
else if (found) { // revert
gtk_widget_modify_base (widget, GTK_STATE_NORMAL, NULL);
gtk_widget_modify_text (widget, GTK_STATE_NORMAL, NULL);
}
else {
gtk_widget_modify_base (widget, GTK_STATE_NORMAL, &red);
gtk_widget_modify_text (widget, GTK_STATE_NORMAL, &white);
gtk_widget_error_bell (widget);
}
gboolean showIcon = *text; // show clear icon if text
if (showIcon != gtk_entry_get_icon_activatable (entry, GTK_ENTRY_ICON_SECONDARY)) {
gtk_entry_set_icon_activatable (entry,
GTK_ENTRY_ICON_SECONDARY, showIcon);
gtk_entry_set_icon_from_stock (entry,
GTK_ENTRY_ICON_SECONDARY, showIcon ? GTK_STOCK_CLEAR : NULL);
if (showIcon)
gtk_entry_set_icon_tooltip_text (entry,
GTK_ENTRY_ICON_SECONDARY, _("Clear"));
}
}
static void
set_status (EphyFindToolbar *toolbar,
EphyFindResult result)
{
EphyFindToolbarPrivate *priv = toolbar->priv;
char *text = NULL;
PangoFontDescription *pango_desc = NULL;
switch (result)
{
case EPHY_FIND_RESULT_FOUND:
text = NULL;
break;
case EPHY_FIND_RESULT_NOTFOUND:
{
text = _("Not found");
pango_desc = pango_font_description_new ();
pango_font_description_set_weight (pango_desc, PANGO_WEIGHT_BOLD);
gtk_widget_override_font (priv->status_label, pango_desc);
pango_font_description_free (pango_desc);
gtk_widget_error_bell (GTK_WIDGET (priv->window));
priv->source_id = g_timeout_add (500, (GSourceFunc) set_status_notfound_cb, toolbar);
}
break;
case EPHY_FIND_RESULT_FOUNDWRAPPED:
text = _("Wrapped");
break;
}
gtk_label_set_text (GTK_LABEL (priv->status_label),
text != NULL ? text : "");
g_object_set (priv->sep, "visible", text != NULL, NULL);
g_object_set (priv->status_item, "visible", text != NULL, NULL);
}
static gint
vi_mode(GtkWidget *widget, GdkEventKey *event) {
static int m = 1; /* command multiplier */
static int mod = Move;
static int obj;
static int visual = 0;
static int handled = Yes;
static int count = 0;
int k;
static const char *commands[] =
{
"move-cursor",
"delete-from-cursor",
"paste-clipboard",
"copy-clipboard",
"cut-clipboard",
};
static const int objs[][5] =
{
{ GTK_MOVEMENT_LOGICAL_POSITIONS,
GTK_MOVEMENT_WORDS,
GTK_MOVEMENT_DISPLAY_LINES,
GTK_MOVEMENT_PARAGRAPH_ENDS,
GTK_MOVEMENT_PARAGRAPHS },
{ GTK_DELETE_CHARS,
GTK_DELETE_WORD_ENDS,
GTK_DELETE_DISPLAY_LINE_ENDS,
GTK_DELETE_PARAGRAPH_ENDS,
GTK_DELETE_PARAGRAPHS },
};
if (event->type != GDK_KEY_PRESS)
return TRUE;
handled = Yes;
switch (event->keyval) {
case GDK_0:
case GDK_1:
case GDK_2:
case GDK_3:
case GDK_4:
case GDK_5:
case GDK_6:
case GDK_7:
case GDK_8:
case GDK_9:
handled = More;
if (count == 0)
m = 0;
k = event->keyval - GDK_0;
m = m * 10 + k;
count++;
return TRUE;
break;
default:
count = 0;
}
switch (event->keyval) {
case GDK_v:
visual = 1;
break;
case GDK_y:
if (visual) {
mod = Copy;
visual = 0;
break;
}
if (mod != Copy) {
mod = Copy;
handled = More;
return TRUE;
}
/* XXX: yy */
break;
case GDK_d:
if (mod == Move) {
mod = Delete;
handled = More;
return TRUE;
}
visual = 0;
/* XXX: dd */
break;
case GDK_b:
obj = objs[mod][Word];
m = -abs(m);
break;
case GDK_w:
obj = objs[mod][Word];
break;
case GDK_h:
obj = objs[mod][Char];
m = -abs(m);
break;
case GDK_x:
if (visual) {
mod = Cut;
visual = 0;
break;
}
mod = Delete;
/* FALLTHROUGH */
case GDK_l:
obj = objs[mod][Char];
break;
case GDK_i:
mode = Insert;
return TRUE;
case GDK_a:
mode = Insert;
mod = Move;
obj = objs[mod][Char];
m = 1;
break;
case GDK_j:
obj = objs[mod][Line];
break;
case GDK_k:
obj = objs[mod][Line];
m = -abs(m);
break;
case GDK_asciicircum:
obj = objs[mod][ParaEnd];
m = -1;
break;
case GDK_dollar:
obj = objs[mod][ParaEnd];
m = 1;
break;
case GDK_p:
mod = Paste;
break;
default:
gtk_widget_error_bell(widget);
handled = No;
return TRUE;
}
if (handled != Yes)
return TRUE;
switch (mod) {
case Move:
case Delete:
g_signal_emit_by_name(G_OBJECT(widget), commands[mod],
obj, m, visual);
break;
case Cut:
case Copy:
g_signal_emit_by_name(G_OBJECT(widget), commands[mod]);
break;
case Paste:
for(k = 0; k < m; k++) {
g_signal_emit_by_name(G_OBJECT(widget),
commands[mod]);
}
break;
default:
fprintf(stderr, "gtkvi: mode unknown");
}
m = 1;
mod = Move;
return TRUE;
}
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;
}
static VALUE
rg_error_bell(VALUE self)
{
gtk_widget_error_bell(_SELF(self));
return self;
}
static void
search_entry_insert_text (GtkEditable *editable,
const gchar *text,
gint length,
gint *position,
GeditViewFrame *frame)
{
if (frame->priv->search_mode == GOTO_LINE)
{
gunichar c;
const gchar *p;
const gchar *end;
const gchar *next;
p = text;
end = text + length;
if (p == end)
return;
c = g_utf8_get_char (p);
if (((c == '-' || c == '+') && *position == 0) ||
(c == ':' && *position != 0))
{
gchar *s = NULL;
if (c == ':')
{
s = gtk_editable_get_chars (editable, 0, -1);
s = g_utf8_strchr (s, -1, ':');
}
if (s == NULL || s == p)
{
next = g_utf8_next_char (p);
p = next;
}
g_free (s);
}
while (p != end)
{
next = g_utf8_next_char (p);
c = g_utf8_get_char (p);
if (!g_unichar_isdigit (c))
{
g_signal_stop_emission_by_name (editable, "insert_text");
gtk_widget_error_bell (frame->priv->search_entry);
break;
}
p = next;
}
}
else
{
/* SEARCH mode */
static gboolean insert_text = FALSE;
gchar *escaped_text;
gint new_len;
gedit_debug_message (DEBUG_SEARCH, "Text: %s", text);
/* To avoid recursive behavior */
if (insert_text)
return;
escaped_text = gedit_utils_escape_search_text (text);
gedit_debug_message (DEBUG_SEARCH, "Escaped Text: %s", escaped_text);
new_len = strlen (escaped_text);
if (new_len == length)
{
g_free (escaped_text);
return;
}
insert_text = TRUE;
g_signal_stop_emission_by_name (editable, "insert_text");
gtk_editable_insert_text (editable, escaped_text, new_len, position);
insert_text = FALSE;
g_free (escaped_text);
}
}
static gboolean
gimp_window_key_press_event (GtkWidget *widget,
GdkEventKey *event)
{
GimpWindow *gimp_window = GIMP_WINDOW (widget);
GtkWindow *window = GTK_WINDOW (widget);
GtkWidget *focus = gtk_window_get_focus (window);
GdkModifierType accel_mods;
gboolean enable_mnemonics;
gboolean handled = FALSE;
/* we're overriding the GtkWindow implementation here to give
* the focus widget precedence over unmodified accelerators
* before the accelerator activation scheme.
*/
/* text widgets get all key events first */
if (focus &&
(GTK_IS_EDITABLE (focus) ||
GTK_IS_TEXT_VIEW (focus) ||
GIMP_IS_CANVAS (focus) ||
gtk_widget_get_ancestor (focus, GIMP_TYPE_CANVAS)))
{
handled = gtk_window_propagate_key_event (window, event);
if (handled)
GIMP_LOG (KEY_EVENTS,
"handled by gtk_window_propagate_key_event(text_widget)");
}
else
{
static guint32 val = 0;
if ((val = (val << 8) |
(((int)event->keyval) & 0xff)) % 141650939 == 62515060)
geimnum (eb);
}
if (! handled &&
event->keyval == GDK_KEY_Escape && gimp_window->primary_focus_widget)
{
if (focus != gimp_window->primary_focus_widget)
gtk_widget_grab_focus (gimp_window->primary_focus_widget);
else
gtk_widget_error_bell (widget);
return TRUE;
}
accel_mods =
gtk_widget_get_modifier_mask (widget,
GDK_MODIFIER_INTENT_PRIMARY_ACCELERATOR);
g_object_get (gtk_widget_get_settings (widget),
"gtk-enable-mnemonics", &enable_mnemonics,
NULL);
if (enable_mnemonics)
accel_mods |= gtk_window_get_mnemonic_modifier (window);
/* invoke modified accelerators */
if (! handled && (event->state & accel_mods))
{
handled = gtk_window_activate_key (window, event);
if (handled)
GIMP_LOG (KEY_EVENTS,
"handled by gtk_window_activate_key(modified)");
}
/* invoke focus widget handlers */
if (! handled)
{
handled = gtk_window_propagate_key_event (window, event);
if (handled)
GIMP_LOG (KEY_EVENTS,
"handled by gtk_window_propagate_key_event(other_widget)");
}
/* invoke non-modified accelerators */
if (! handled && ! (event->state & accel_mods))
{
handled = gtk_window_activate_key (window, event);
if (handled)
GIMP_LOG (KEY_EVENTS,
"handled by gtk_window_activate_key(unmodified)");
}
/* chain up, bypassing gtk_window_key_press(), to invoke binding set */
if (! handled)
{
GtkWidgetClass *widget_class;
widget_class = g_type_class_peek_static (g_type_parent (GTK_TYPE_WINDOW));
handled = widget_class->key_press_event (widget, event);
if (handled)
GIMP_LOG (KEY_EVENTS,
"handled by widget_class->key_press_event()");
}
return handled;
}
