summaryrefslogtreecommitdiffstats
path: root/content/browser/renderer_host/gtk_key_bindings_handler.cc
blob: 756bcc3e2ebdcff90ee5ede3838ce8e22bd0864a (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "content/browser/renderer_host/gtk_key_bindings_handler.h"

#include <gdk/gdkkeysyms.h>

#include <string>

#include "base/logging.h"
#include "base/string_util.h"
#include "content/public/browser/native_web_keyboard_event.h"

namespace content {

GtkKeyBindingsHandler::GtkKeyBindingsHandler(GtkWidget* parent_widget)
    : handler_(CreateNewHandler()) {
  DCHECK(GTK_IS_FIXED(parent_widget));
  // We need add the |handler_| object into gtk widget hierarchy, so that
  // gtk_bindings_activate_event() can find correct display and keymaps from
  // the |handler_| object.
  gtk_fixed_put(GTK_FIXED(parent_widget), handler_.get(), -1, -1);
}

GtkKeyBindingsHandler::~GtkKeyBindingsHandler() {
  handler_.Destroy();
}

bool GtkKeyBindingsHandler::Match(const NativeWebKeyboardEvent& wke,
                                  EditCommands* edit_commands) {
  if (wke.type == WebKit::WebInputEvent::Char || !wke.os_event)
    return false;

  edit_commands_.clear();
  // If this key event matches a predefined key binding, corresponding signal
  // will be emitted.
  gtk_bindings_activate_event(GTK_OBJECT(handler_.get()), &wke.os_event->key);

  bool matched = !edit_commands_.empty();
  if (edit_commands)
    edit_commands->swap(edit_commands_);
  return matched;
}

GtkWidget* GtkKeyBindingsHandler::CreateNewHandler() {
  Handler* handler =
      static_cast<Handler*>(g_object_new(HandlerGetType(), NULL));

  handler->owner = this;

  // We don't need to show the |handler| object on screen, so set its size to
  // zero.
  gtk_widget_set_size_request(GTK_WIDGET(handler), 0, 0);

  // Prevents it from handling any events by itself.
  gtk_widget_set_sensitive(GTK_WIDGET(handler), FALSE);
  gtk_widget_set_events(GTK_WIDGET(handler), 0);
  gtk_widget_set_can_focus(GTK_WIDGET(handler), TRUE);

  return GTK_WIDGET(handler);
}

void GtkKeyBindingsHandler::EditCommandMatched(
    const std::string& name, const std::string& value) {
  edit_commands_.push_back(EditCommand(name, value));
}

void GtkKeyBindingsHandler::HandlerInit(Handler *self) {
  self->owner = NULL;
}

void GtkKeyBindingsHandler::HandlerClassInit(HandlerClass *klass) {
  GtkTextViewClass* text_view_class = GTK_TEXT_VIEW_CLASS(klass);
  GtkWidgetClass* widget_class = GTK_WIDGET_CLASS(klass);

  // Overrides all virtual methods related to editor key bindings.
  text_view_class->backspace = BackSpace;
  text_view_class->copy_clipboard = CopyClipboard;
  text_view_class->cut_clipboard = CutClipboard;
  text_view_class->delete_from_cursor = DeleteFromCursor;
  text_view_class->insert_at_cursor = InsertAtCursor;
  text_view_class->move_cursor = MoveCursor;
  text_view_class->paste_clipboard = PasteClipboard;
  text_view_class->set_anchor = SetAnchor;
  text_view_class->toggle_overwrite = ToggleOverwrite;
  widget_class->show_help = ShowHelp;

  // "move-focus", "move-viewport", "select-all" and "toggle-cursor-visible"
  // have no corresponding virtual methods. Since glib 2.18 (gtk 2.14),
  // g_signal_override_class_handler() is introduced to override a signal
  // handler.
  g_signal_override_class_handler("move-focus",
                                  G_TYPE_FROM_CLASS(klass),
                                  G_CALLBACK(MoveFocus));

  g_signal_override_class_handler("move-viewport",
                                  G_TYPE_FROM_CLASS(klass),
                                  G_CALLBACK(MoveViewport));

  g_signal_override_class_handler("select-all",
                                  G_TYPE_FROM_CLASS(klass),
                                  G_CALLBACK(SelectAll));

  g_signal_override_class_handler("toggle-cursor-visible",
                                  G_TYPE_FROM_CLASS(klass),
                                  G_CALLBACK(ToggleCursorVisible));
}

GType GtkKeyBindingsHandler::HandlerGetType() {
  static volatile gsize type_id_volatile = 0;
  if (g_once_init_enter(&type_id_volatile)) {
    GType type_id = g_type_register_static_simple(
        GTK_TYPE_TEXT_VIEW,
        g_intern_static_string("GtkKeyBindingsHandler"),
        sizeof(HandlerClass),
        reinterpret_cast<GClassInitFunc>(HandlerClassInit),
        sizeof(Handler),
        reinterpret_cast<GInstanceInitFunc>(HandlerInit),
        static_cast<GTypeFlags>(0));
    g_once_init_leave(&type_id_volatile, type_id);
  }
  return type_id_volatile;
}

GtkKeyBindingsHandler* GtkKeyBindingsHandler::GetHandlerOwner(
    GtkTextView* text_view) {
  Handler* handler = G_TYPE_CHECK_INSTANCE_CAST(
      text_view, HandlerGetType(), Handler);
  DCHECK(handler);
  return handler->owner;
}

void GtkKeyBindingsHandler::BackSpace(GtkTextView* text_view) {
  GetHandlerOwner(text_view)->EditCommandMatched("DeleteBackward", "");
}

void GtkKeyBindingsHandler::CopyClipboard(GtkTextView* text_view) {
  GetHandlerOwner(text_view)->EditCommandMatched("Copy", "");
}

void GtkKeyBindingsHandler::CutClipboard(GtkTextView* text_view) {
  GetHandlerOwner(text_view)->EditCommandMatched("Cut", "");
}

void GtkKeyBindingsHandler::DeleteFromCursor(
    GtkTextView* text_view, GtkDeleteType type, gint count) {
  if (!count)
    return;

  const char *commands[3] = { NULL, NULL, NULL };
  switch (type) {
    case GTK_DELETE_CHARS:
      commands[0] = (count > 0 ? "DeleteForward" : "DeleteBackward");
      break;
    case GTK_DELETE_WORD_ENDS:
      commands[0] = (count > 0 ? "DeleteWordForward" : "DeleteWordBackward");
      break;
    case GTK_DELETE_WORDS:
      if (count > 0) {
        commands[0] = "MoveWordForward";
        commands[1] = "DeleteWordBackward";
      } else {
        commands[0] = "MoveWordBackward";
        commands[1] = "DeleteWordForward";
      }
      break;
    case GTK_DELETE_DISPLAY_LINES:
      commands[0] = "MoveToBeginningOfLine";
      commands[1] = "DeleteToEndOfLine";
      break;
    case GTK_DELETE_DISPLAY_LINE_ENDS:
      commands[0] = (count > 0 ? "DeleteToEndOfLine" :
                     "DeleteToBeginningOfLine");
      break;
    case GTK_DELETE_PARAGRAPH_ENDS:
      commands[0] = (count > 0 ? "DeleteToEndOfParagraph" :
                     "DeleteToBeginningOfParagraph");
      break;
    case GTK_DELETE_PARAGRAPHS:
      commands[0] = "MoveToBeginningOfParagraph";
      commands[1] = "DeleteToEndOfParagraph";
      break;
    default:
      // GTK_DELETE_WHITESPACE has no corresponding editor command.
      return;
  }

  GtkKeyBindingsHandler* owner = GetHandlerOwner(text_view);
  if (count < 0)
    count = -count;
  for (; count > 0; --count) {
    for (const char* const* p = commands; *p; ++p)
      owner->EditCommandMatched(*p, "");
  }
}

void GtkKeyBindingsHandler::InsertAtCursor(GtkTextView* text_view,
                                           const gchar* str) {
  if (str && *str)
    GetHandlerOwner(text_view)->EditCommandMatched("InsertText", str);
}

void GtkKeyBindingsHandler::MoveCursor(
    GtkTextView* text_view, GtkMovementStep step, gint count,
    gboolean extend_selection) {
  if (!count)
    return;

  std::string command;
  switch (step) {
    case GTK_MOVEMENT_LOGICAL_POSITIONS:
      command = (count > 0 ? "MoveForward" : "MoveBackward");
      break;
    case GTK_MOVEMENT_VISUAL_POSITIONS:
      command = (count > 0 ? "MoveRight" : "MoveLeft");
      break;
    case GTK_MOVEMENT_WORDS:
      command = (count > 0 ? "MoveWordRight" : "MoveWordLeft");
      break;
    case GTK_MOVEMENT_DISPLAY_LINES:
      command = (count > 0 ? "MoveDown" : "MoveUp");
      break;
    case GTK_MOVEMENT_DISPLAY_LINE_ENDS:
      command = (count > 0 ? "MoveToEndOfLine" : "MoveToBeginningOfLine");
      break;
    case GTK_MOVEMENT_PARAGRAPH_ENDS:
      command = (count > 0 ? "MoveToEndOfParagraph" :
                 "MoveToBeginningOfParagraph");
      break;
    case GTK_MOVEMENT_PAGES:
      command = (count > 0 ? "MovePageDown" : "MovePageUp");
      break;
    case GTK_MOVEMENT_BUFFER_ENDS:
      command = (count > 0 ? "MoveToEndOfDocument" :
                 "MoveToBeginningOfDocument");
      break;
    default:
      // GTK_MOVEMENT_PARAGRAPHS and GTK_MOVEMENT_HORIZONTAL_PAGES have
      // no corresponding editor commands.
      return;
  }

  GtkKeyBindingsHandler* owner = GetHandlerOwner(text_view);
  if (extend_selection)
    command.append("AndModifySelection");
  if (count < 0)
    count = -count;
  for (; count > 0; --count)
    owner->EditCommandMatched(command, "");
}

void GtkKeyBindingsHandler::MoveViewport(
    GtkTextView* text_view, GtkScrollStep step, gint count) {
  // Not supported by webkit.
}

void GtkKeyBindingsHandler::PasteClipboard(GtkTextView* text_view) {
  GetHandlerOwner(text_view)->EditCommandMatched("Paste", "");
}

void GtkKeyBindingsHandler::SelectAll(GtkTextView* text_view, gboolean select) {
  if (select)
    GetHandlerOwner(text_view)->EditCommandMatched("SelectAll", "");
  else
    GetHandlerOwner(text_view)->EditCommandMatched("Unselect", "");
}

void GtkKeyBindingsHandler::SetAnchor(GtkTextView* text_view) {
  GetHandlerOwner(text_view)->EditCommandMatched("SetMark", "");
}

void GtkKeyBindingsHandler::ToggleCursorVisible(GtkTextView* text_view) {
  // Not supported by webkit.
}

void GtkKeyBindingsHandler::ToggleOverwrite(GtkTextView* text_view) {
  // Not supported by webkit.
}

gboolean GtkKeyBindingsHandler::ShowHelp(GtkWidget* widget,
                                         GtkWidgetHelpType arg1) {
  // Just for disabling the default handler.
  return FALSE;
}

void GtkKeyBindingsHandler::MoveFocus(GtkWidget* widget,
                                      GtkDirectionType arg1) {
  // Just for disabling the default handler.
}

}  // namespace content