/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

/* This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "mozilla/ArrayUtils.h"

#include "mozilla/MathAlgorithms.h"

#include "mozilla/TextEvents.h"

#include "NativeKeyBindings.h"

#include "nsString.h"

#include "nsMemory.h"

#include "nsGtkKeyUtils.h"

#include <gtk/gtk.h>

#include <gdk/gdkkeysyms.h>

#include <gdk/gdk.h>

namespace mozilla {

namespace widget {

static nsTArray<CommandInt>* gCurrentCommands = nullptr;

static bool gHandled = false;

// Common GtkEntry and GtkTextView signals

static void

copy_clipboard_cb(GtkWidget *w, gpointer user_data)

{

  gCurrentCommands->AppendElement(CommandCopy);

  g_signal_stop_emission_by_name(w, "copy_clipboard");

  gHandled = true;

}

static void

cut_clipboard_cb(GtkWidget *w, gpointer user_data)

{

  gCurrentCommands->AppendElement(CommandCut);

  g_signal_stop_emission_by_name(w, "cut_clipboard");

  gHandled = true;

}

// GTK distinguishes between display lines (wrapped, as they appear on the

// screen) and paragraphs, which are runs of text terminated by a newline.

// We don't have this distinction, so we always use editor's notion of

// lines, which are newline-terminated.

static const Command sDeleteCommands[][2] = {

  // backward, forward

  { CommandDeleteCharBackward, CommandDeleteCharForward },    // CHARS

  { CommandDeleteWordBackward, CommandDeleteWordForward },    // WORD_ENDS

  { CommandDeleteWordBackward, CommandDeleteWordForward },    // WORDS

  { CommandDeleteToBeginningOfLine, CommandDeleteToEndOfLine }, // LINES

  { CommandDeleteToBeginningOfLine, CommandDeleteToEndOfLine }, // LINE_ENDS

  { CommandDeleteToBeginningOfLine, CommandDeleteToEndOfLine }, // PARAGRAPH_ENDS

  { CommandDeleteToBeginningOfLine, CommandDeleteToEndOfLine }, // PARAGRAPHS

  // This deletes from the end of the previous word to the beginning of the

  // next word, but only if the caret is not in a word.

  // XXX need to implement in editor

  { CommandDoNothing, CommandDoNothing } // WHITESPACE

};

static void

delete_from_cursor_cb(GtkWidget *w, GtkDeleteType del_type,

                      gint count, gpointer user_data)

{

  g_signal_stop_emission_by_name(w, "delete_from_cursor");

  if (count == 0) {

    // Nothing to do.

    return;

  }

  bool forward = count > 0;

#ifdef MOZ_WIDGET_GTK

  // Ignore GTK's Ctrl-K keybinding introduced in GTK 3.14 and removed in

  // 3.18 if the user has custom bindings set. See bug 1176929.

  if (del_type == GTK_DELETE_PARAGRAPH_ENDS && forward && GTK_IS_ENTRY(w) &&

      !gtk_check_version(3, 14, 1) && gtk_check_version(3, 17, 9)) {

    GtkStyleContext* context = gtk_widget_get_style_context(w);

    GtkStateFlags flags = gtk_widget_get_state_flags(w);

    GPtrArray* array;

    gtk_style_context_get(context, flags, "gtk-key-bindings", &array, nullptr);

    if (!array)

      return;

    g_ptr_array_unref(array);

  }

#endif

  gHandled = true;

  if (uint32_t(del_type) >= ArrayLength(sDeleteCommands)) {

    // unsupported deletion type

    return;

  }

  if (del_type == GTK_DELETE_WORDS) {

    // This works like word_ends, except we first move the caret to the

    // beginning/end of the current word.

    if (forward) {

      gCurrentCommands->AppendElement(CommandWordNext);

      gCurrentCommands->AppendElement(CommandWordPrevious);

    } else {

      gCurrentCommands->AppendElement(CommandWordPrevious);

      gCurrentCommands->AppendElement(CommandWordNext);

    }

  } else if (del_type == GTK_DELETE_DISPLAY_LINES ||

             del_type == GTK_DELETE_PARAGRAPHS) {

    // This works like display_line_ends, except we first move the caret to the

    // beginning/end of the current line.

    if (forward) {

      gCurrentCommands->AppendElement(CommandBeginLine);

    } else {

      gCurrentCommands->AppendElement(CommandEndLine);

    }

  }

  Command command = sDeleteCommands[del_type][forward];

  if (!command) {

    return; // unsupported command

  }

  unsigned int absCount = Abs(count);

  for (unsigned int i = 0; i < absCount; ++i) {

    gCurrentCommands->AppendElement(command);

  }

}

static const Command sMoveCommands[][2][2] = {

  // non-extend { backward, forward }, extend { backward, forward }

  // GTK differentiates between logical position, which is prev/next,

  // and visual position, which is always left/right.

  // We should fix this to work the same way for RTL text input.

  { // LOGICAL_POSITIONS

    { CommandCharPrevious, CommandCharNext },

    { CommandSelectCharPrevious, CommandSelectCharNext }

  },

  { // VISUAL_POSITIONS

    { CommandCharPrevious, CommandCharNext },

    { CommandSelectCharPrevious, CommandSelectCharNext }

  },

  { // WORDS

    { CommandWordPrevious, CommandWordNext },

    { CommandSelectWordPrevious, CommandSelectWordNext }

  },

  { // DISPLAY_LINES

    { CommandLinePrevious, CommandLineNext },

    { CommandSelectLinePrevious, CommandSelectLineNext }

  },

  { // DISPLAY_LINE_ENDS

    { CommandBeginLine, CommandEndLine },

    { CommandSelectBeginLine, CommandSelectEndLine }

  },

  { // PARAGRAPHS

    { CommandLinePrevious, CommandLineNext },

    { CommandSelectLinePrevious, CommandSelectLineNext }

  },

  { // PARAGRAPH_ENDS

    { CommandBeginLine, CommandEndLine },

    { CommandSelectBeginLine, CommandSelectEndLine }

  },

  { // PAGES

    { CommandMovePageUp, CommandMovePageDown },

    { CommandSelectPageUp, CommandSelectPageDown }

  },

  { // BUFFER_ENDS

    { CommandMoveTop, CommandMoveBottom },

    { CommandSelectTop, CommandSelectBottom }

  },

  { // HORIZONTAL_PAGES (unsupported)

    { CommandDoNothing, CommandDoNothing },

    { CommandDoNothing, CommandDoNothing }

  }

};

static void

move_cursor_cb(GtkWidget *w, GtkMovementStep step, gint count,

               gboolean extend_selection, gpointer user_data)

{

  g_signal_stop_emission_by_name(w, "move_cursor");

  if (count == 0) {

    // Nothing to do.

    return;

  }

  gHandled = true;

  bool forward = count > 0;

  if (uint32_t(step) >= ArrayLength(sMoveCommands)) {

    // unsupported movement type

    return;

  }

  Command command = sMoveCommands[step][extend_selection][forward];

  if (!command) {

    return; // unsupported command

  }

  unsigned int absCount = Abs(count);

  for (unsigned int i = 0; i < absCount; ++i) {

    gCurrentCommands->AppendElement(command);

  }

}

static void

paste_clipboard_cb(GtkWidget *w, gpointer user_data)

{

  gCurrentCommands->AppendElement(CommandPaste);

  g_signal_stop_emission_by_name(w, "paste_clipboard");

  gHandled = true;

}

// GtkTextView-only signals

static void

select_all_cb(GtkWidget *w, gboolean select, gpointer user_data)

{

  gCurrentCommands->AppendElement(CommandSelectAll);

  g_signal_stop_emission_by_name(w, "select_all");

  gHandled = true;

}

NativeKeyBindings* NativeKeyBindings::sInstanceForSingleLineEditor = nullptr;

NativeKeyBindings* NativeKeyBindings::sInstanceForMultiLineEditor = nullptr;

// static

NativeKeyBindings*

NativeKeyBindings::GetInstance(NativeKeyBindingsType aType)

{

  switch (aType) {

    case nsIWidget::NativeKeyBindingsForSingleLineEditor:

      if (!sInstanceForSingleLineEditor) {

        sInstanceForSingleLineEditor = new NativeKeyBindings();

        sInstanceForSingleLineEditor->Init(aType);

      }

      return sInstanceForSingleLineEditor;

    default:

      // fallback to multiline editor case in release build

      MOZ_FALLTHROUGH_ASSERT("aType is invalid or not yet implemented");

    case nsIWidget::NativeKeyBindingsForMultiLineEditor:

    case nsIWidget::NativeKeyBindingsForRichTextEditor:

      if (!sInstanceForMultiLineEditor) {

        sInstanceForMultiLineEditor = new NativeKeyBindings();

        sInstanceForMultiLineEditor->Init(aType);

      }

      return sInstanceForMultiLineEditor;

  }

}

// static

void

NativeKeyBindings::Shutdown()

{

  delete sInstanceForSingleLineEditor;

  sInstanceForSingleLineEditor = nullptr;

  delete sInstanceForMultiLineEditor;

  sInstanceForMultiLineEditor = nullptr;

}

void

NativeKeyBindings::Init(NativeKeyBindingsType  aType)

{

  switch (aType) {

  case nsIWidget::NativeKeyBindingsForSingleLineEditor:

    mNativeTarget = gtk_entry_new();

    break;

  default:

    mNativeTarget = gtk_text_view_new();

    if (gtk_major_version > 2 ||

        (gtk_major_version == 2 && (gtk_minor_version > 2 ||

                                    (gtk_minor_version == 2 &&

                                     gtk_micro_version >= 2)))) {

      // select_all only exists in gtk >= 2.2.2.  Prior to that,

      // ctrl+a is bound to (move to beginning, select to end).

      g_signal_connect(mNativeTarget, "select_all",

                       G_CALLBACK(select_all_cb), this);

    }

    break;

  }

  g_object_ref_sink(mNativeTarget);

  g_signal_connect(mNativeTarget, "copy_clipboard",

                   G_CALLBACK(copy_clipboard_cb), this);

  g_signal_connect(mNativeTarget, "cut_clipboard",

                   G_CALLBACK(cut_clipboard_cb), this);

  g_signal_connect(mNativeTarget, "delete_from_cursor",

                   G_CALLBACK(delete_from_cursor_cb), this);

  g_signal_connect(mNativeTarget, "move_cursor",

                   G_CALLBACK(move_cursor_cb), this);

  g_signal_connect(mNativeTarget, "paste_clipboard",

                   G_CALLBACK(paste_clipboard_cb), this);

}

NativeKeyBindings::~NativeKeyBindings()

{

  gtk_widget_destroy(mNativeTarget);

  g_object_unref(mNativeTarget);

}

void

NativeKeyBindings::GetEditCommands(const WidgetKeyboardEvent& aEvent,

                                   nsTArray<CommandInt>& aCommands)

{

  // If the native key event is set, it must be synthesized for tests.

  // We just ignore such events because this behavior depends on system

  // settings.

  if (!aEvent.mNativeKeyEvent) {

    // It must be synthesized event or dispatched DOM event from chrome.

    return;

  }

  guint keyval;

  if (aEvent.mCharCode) {

    keyval = gdk_unicode_to_keyval(aEvent.mCharCode);

  } else {

    keyval =

      static_cast<GdkEventKey*>(aEvent.mNativeKeyEvent)->keyval;

  }

  if (GetEditCommandsInternal(aEvent, aCommands, keyval)) {

    return;

  }

  for (uint32_t i = 0; i < aEvent.mAlternativeCharCodes.Length(); ++i) {

    uint32_t ch = aEvent.IsShift() ?

      aEvent.mAlternativeCharCodes[i].mShiftedCharCode :

      aEvent.mAlternativeCharCodes[i].mUnshiftedCharCode;

    if (ch && ch != aEvent.mCharCode) {

      keyval = gdk_unicode_to_keyval(ch);

      if (GetEditCommandsInternal(aEvent, aCommands, keyval)) {

        return;

      }

    }

  }

/*

gtk_bindings_activate_event is preferable, but it has unresolved bug:

http://bugzilla.gnome.org/show_bug.cgi?id=162726

The bug was already marked as FIXED.  However, somebody reports that the

bug still exists.

Also gtk_bindings_activate may work with some non-shortcuts operations

(todo: check it). See bug 411005 and bug 406407.

Code, which should be used after fixing GNOME bug 162726:

  gtk_bindings_activate_event(GTK_OBJECT(mNativeTarget),

    static_cast<GdkEventKey*>(aEvent.mNativeKeyEvent));

*/

}

bool

NativeKeyBindings::GetEditCommandsInternal(const WidgetKeyboardEvent& aEvent,

                                           nsTArray<CommandInt>& aCommands,

                                           guint aKeyval)

{

  guint modifiers =

    static_cast<GdkEventKey*>(aEvent.mNativeKeyEvent)->state;

  gCurrentCommands = &aCommands;

  gHandled = false;

  gtk_bindings_activate(G_OBJECT(mNativeTarget),

                        aKeyval, GdkModifierType(modifiers));

  gCurrentCommands = nullptr;

  MOZ_ASSERT(!gHandled || !aCommands.IsEmpty());

  return gHandled;

}

} // namespace widget

} // namespace mozilla