summaryrefslogtreecommitdiffstats
path: root/dom/events/IMEStateManager.h
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /dom/events/IMEStateManager.h
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'dom/events/IMEStateManager.h')
-rw-r--r--dom/events/IMEStateManager.h328
1 files changed, 328 insertions, 0 deletions
diff --git a/dom/events/IMEStateManager.h b/dom/events/IMEStateManager.h
new file mode 100644
index 000000000..7dfc48aa5
--- /dev/null
+++ b/dom/events/IMEStateManager.h
@@ -0,0 +1,328 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#ifndef mozilla_IMEStateManager_h_
+#define mozilla_IMEStateManager_h_
+
+#include "mozilla/EventForwards.h"
+#include "mozilla/StaticPtr.h"
+#include "mozilla/dom/TabParent.h"
+#include "nsIWidget.h"
+
+class nsIContent;
+class nsIDOMMouseEvent;
+class nsINode;
+class nsPresContext;
+class nsISelection;
+
+namespace mozilla {
+
+class EditorBase;
+class EventDispatchingCallback;
+class IMEContentObserver;
+class TextCompositionArray;
+class TextComposition;
+
+/**
+ * IMEStateManager manages InputContext (e.g., active editor type, IME enabled
+ * state and IME open state) of nsIWidget instances, manages IMEContentObserver
+ * and provides useful API for IME.
+ */
+
+class IMEStateManager
+{
+ typedef dom::TabParent TabParent;
+ typedef widget::IMEMessage IMEMessage;
+ typedef widget::IMENotification IMENotification;
+ typedef widget::IMEState IMEState;
+ typedef widget::InputContext InputContext;
+ typedef widget::InputContextAction InputContextAction;
+
+public:
+ static void Init();
+ static void Shutdown();
+
+ /**
+ * GetActiveTabParent() returns a pointer to a TabParent instance which is
+ * managed by the focused content (sContent). If the focused content isn't
+ * managing another process, this returns nullptr.
+ */
+ static TabParent* GetActiveTabParent()
+ {
+ // If menu has pseudo focus, we should ignore active child process.
+ if (sInstalledMenuKeyboardListener) {
+ return nullptr;
+ }
+ return sActiveTabParent.get();
+ }
+
+ /**
+ * OnTabParentDestroying() is called when aTabParent is being destroyed.
+ */
+ static void OnTabParentDestroying(TabParent* aTabParent);
+
+ /**
+ * Called when aWidget is being deleted.
+ */
+ static void WidgetDestroyed(nsIWidget* aWidget);
+
+ /**
+ * GetWidgetForActiveInputContext() returns a widget which IMEStateManager
+ * is managing input context with. If a widget instance needs to cache
+ * the last input context for nsIWidget::GetInputContext() or something,
+ * it should check if its cache is valid with this method before using it
+ * because if this method returns another instance, it means that
+ * IMEStateManager may have already changed shared input context via the
+ * widget.
+ */
+ static nsIWidget* GetWidgetForActiveInputContext()
+ {
+ return sActiveInputContextWidget;
+ }
+
+ /**
+ * SetIMEContextForChildProcess() is called when aTabParent receives
+ * SetInputContext() from the remote process.
+ */
+ static void SetInputContextForChildProcess(TabParent* aTabParent,
+ const InputContext& aInputContext,
+ const InputContextAction& aAction);
+
+ /**
+ * StopIMEStateManagement() is called when the process should stop managing
+ * IME state.
+ */
+ static void StopIMEStateManagement();
+
+ /**
+ * MaybeStartOffsetUpdatedInChild() is called when composition start offset
+ * is maybe updated in the child process. I.e., even if it's not updated,
+ * this is called and never called if the composition is in this process.
+ * @param aWidget The widget whose native IME context has the
+ * composition.
+ * @param aStartOffset New composition start offset with native
+ * linebreaks.
+ */
+ static void MaybeStartOffsetUpdatedInChild(nsIWidget* aWidget,
+ uint32_t aStartOffset);
+
+ static nsresult OnDestroyPresContext(nsPresContext* aPresContext);
+ static nsresult OnRemoveContent(nsPresContext* aPresContext,
+ nsIContent* aContent);
+ /**
+ * OnChangeFocus() should be called when focused content is changed or
+ * IME enabled state is changed. If nobody has focus, set both aPresContext
+ * and aContent nullptr. E.g., all windows are deactivated.
+ */
+ static nsresult OnChangeFocus(nsPresContext* aPresContext,
+ nsIContent* aContent,
+ InputContextAction::Cause aCause);
+ static void OnInstalledMenuKeyboardListener(bool aInstalling);
+
+ // These two methods manage focus and selection/text observers.
+ // They are separate from OnChangeFocus above because this offers finer
+ // control compared to having the two methods incorporated into OnChangeFocus
+
+ // Get the focused editor's selection and root
+ static nsresult GetFocusSelectionAndRoot(nsISelection** aSel,
+ nsIContent** aRoot);
+ // This method updates the current IME state. However, if the enabled state
+ // isn't changed by the new state, this method does nothing.
+ // Note that this method changes the IME state of the active element in the
+ // widget. So, the caller must have focus.
+ static void UpdateIMEState(const IMEState &aNewIMEState,
+ nsIContent* aContent,
+ EditorBase& aEditorBase);
+
+ // This method is called when user operates mouse button in focused editor
+ // and before the editor handles it.
+ // Returns true if IME consumes the event. Otherwise, false.
+ static bool OnMouseButtonEventInEditor(nsPresContext* aPresContext,
+ nsIContent* aContent,
+ nsIDOMMouseEvent* aMouseEvent);
+
+ // This method is called when user clicked in an editor.
+ // aContent must be:
+ // If the editor is for <input> or <textarea>, the element.
+ // If the editor is for contenteditable, the active editinghost.
+ // If the editor is for designMode, nullptr.
+ static void OnClickInEditor(nsPresContext* aPresContext,
+ nsIContent* aContent,
+ nsIDOMMouseEvent* aMouseEvent);
+
+ // This method is called when editor actually gets focus.
+ // aContent must be:
+ // If the editor is for <input> or <textarea>, the element.
+ // If the editor is for contenteditable, the active editinghost.
+ // If the editor is for designMode, nullptr.
+ static void OnFocusInEditor(nsPresContext* aPresContext,
+ nsIContent* aContent,
+ nsIEditor* aEditor);
+
+ // This method is called when the editor is initialized.
+ static void OnEditorInitialized(nsIEditor* aEditor);
+
+ // This method is called when the editor is (might be temporarily) being
+ // destroyed.
+ static void OnEditorDestroying(nsIEditor* aEditor);
+
+ /**
+ * All composition events must be dispatched via DispatchCompositionEvent()
+ * for storing the composition target and ensuring a set of composition
+ * events must be fired the stored target. If the stored composition event
+ * target is destroying, this removes the stored composition automatically.
+ */
+ static void DispatchCompositionEvent(
+ nsINode* aEventTargetNode,
+ nsPresContext* aPresContext,
+ WidgetCompositionEvent* aCompositionEvent,
+ nsEventStatus* aStatus,
+ EventDispatchingCallback* aCallBack,
+ bool aIsSynthesized = false);
+
+ /**
+ * All selection events must be handled via HandleSelectionEvent()
+ * because they must be handled by same target as composition events when
+ * there is a composition.
+ */
+ static void HandleSelectionEvent(nsPresContext* aPresContext,
+ nsIContent* aEventTargetContent,
+ WidgetSelectionEvent* aSelectionEvent);
+
+ /**
+ * This is called when PresShell ignores a composition event due to not safe
+ * to dispatch events.
+ */
+ static void OnCompositionEventDiscarded(
+ WidgetCompositionEvent* aCompositionEvent);
+
+ /**
+ * Get TextComposition from widget.
+ */
+ static already_AddRefed<TextComposition>
+ GetTextCompositionFor(nsIWidget* aWidget);
+
+ /**
+ * Returns TextComposition instance for the event.
+ */
+ static already_AddRefed<TextComposition>
+ GetTextCompositionFor(const WidgetCompositionEvent* aCompositionEvent);
+
+ /**
+ * Returns TextComposition instance for the pres context.
+ * Be aware, even if another pres context which shares native IME context with
+ * specified pres context has composition, this returns nullptr.
+ */
+ static already_AddRefed<TextComposition>
+ GetTextCompositionFor(nsPresContext* aPresContext);
+
+ /**
+ * Send a notification to IME. It depends on the IME or platform spec what
+ * will occur (or not occur).
+ */
+ static nsresult NotifyIME(const IMENotification& aNotification,
+ nsIWidget* aWidget,
+ bool aOriginIsRemote = false);
+ static nsresult NotifyIME(IMEMessage aMessage,
+ nsIWidget* aWidget,
+ bool aOriginIsRemote = false);
+ static nsresult NotifyIME(IMEMessage aMessage,
+ nsPresContext* aPresContext,
+ bool aOriginIsRemote = false);
+
+ static nsINode* GetRootEditableNode(nsPresContext* aPresContext,
+ nsIContent* aContent);
+
+ /**
+ * Returns active IMEContentObserver but may be nullptr if focused content
+ * isn't editable or focus in a remote process.
+ */
+ static IMEContentObserver* GetActiveContentObserver();
+
+protected:
+ static nsresult OnChangeFocusInternal(nsPresContext* aPresContext,
+ nsIContent* aContent,
+ InputContextAction aAction);
+ static void SetIMEState(const IMEState &aState,
+ nsIContent* aContent,
+ nsIWidget* aWidget,
+ InputContextAction aAction);
+ static void SetInputContext(nsIWidget* aWidget,
+ const InputContext& aInputContext,
+ const InputContextAction& aAction);
+ static IMEState GetNewIMEState(nsPresContext* aPresContext,
+ nsIContent* aContent);
+
+ static void EnsureTextCompositionArray();
+ static void CreateIMEContentObserver(nsIEditor* aEditor);
+ static void DestroyIMEContentObserver();
+
+ static bool IsEditable(nsINode* node);
+
+ static bool IsIMEObserverNeeded(const IMEState& aState);
+
+ static nsIContent* GetRootContent(nsPresContext* aPresContext);
+
+ /**
+ * CanHandleWith() returns false if aPresContext is nullptr or it's destroyed.
+ */
+ static bool CanHandleWith(nsPresContext* aPresContext);
+
+ // sContent and sPresContext are the focused content and PresContext. If a
+ // document has focus but there is no focused element, sContent may be
+ // nullptr.
+ static StaticRefPtr<nsIContent> sContent;
+ static StaticRefPtr<nsPresContext> sPresContext;
+ // sWidget is cache for the root widget of sPresContext. Even afer
+ // sPresContext has gone, we need to clean up some IME state on the widget
+ // if the widget is available.
+ static nsIWidget* sWidget;
+ // sFocusedIMEWidget is, the widget which was sent to "focus" notification
+ // from IMEContentObserver and not yet sent "blur" notification.
+ // So, if this is not nullptr, the widget needs to receive "blur"
+ // notification.
+ static nsIWidget* sFocusedIMEWidget;
+ // sActiveInputContextWidget is the last widget whose SetInputContext() is
+ // called. This is important to reduce sync IPC cost with parent process.
+ // If IMEStateManager set input context to different widget, PuppetWidget can
+ // return cached input context safely.
+ static nsIWidget* sActiveInputContextWidget;
+ static StaticRefPtr<TabParent> sActiveTabParent;
+ // sActiveIMEContentObserver points to the currently active
+ // IMEContentObserver. This is null if there is no focused editor.
+ static StaticRefPtr<IMEContentObserver> sActiveIMEContentObserver;
+
+ // All active compositions in the process are stored by this array.
+ // When you get an item of this array and use it, please be careful.
+ // The instances in this array can be destroyed automatically if you do
+ // something to cause committing or canceling the composition.
+ static TextCompositionArray* sTextCompositions;
+
+ static bool sInstalledMenuKeyboardListener;
+ static bool sIsGettingNewIMEState;
+ static bool sCheckForIMEUnawareWebApps;
+ static bool sRemoteHasFocus;
+
+ class MOZ_STACK_CLASS GettingNewIMEStateBlocker final
+ {
+ public:
+ GettingNewIMEStateBlocker()
+ : mOldValue(IMEStateManager::sIsGettingNewIMEState)
+ {
+ IMEStateManager::sIsGettingNewIMEState = true;
+ }
+ ~GettingNewIMEStateBlocker()
+ {
+ IMEStateManager::sIsGettingNewIMEState = mOldValue;
+ }
+ private:
+ bool mOldValue;
+ };
+};
+
+} // namespace mozilla
+
+#endif // mozilla_IMEStateManager_h_