1392 lines
45 KiB
C++
1392 lines
45 KiB
C++
/* -*- 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 <string.h> // for nullptr, strcmp
|
|
|
|
#include "imgIContainer.h" // for imgIContainer, etc
|
|
#include "mozFlushType.h" // for mozFlushType::Flush_Frames
|
|
#include "mozilla/mozalloc.h" // for operator new
|
|
#include "nsAString.h"
|
|
#include "nsComponentManagerUtils.h" // for do_CreateInstance
|
|
#include "nsComposerCommandsUpdater.h" // for nsComposerCommandsUpdater
|
|
#include "nsDebug.h" // for NS_ENSURE_SUCCESS, etc
|
|
#include "nsEditingSession.h"
|
|
#include "nsError.h" // for NS_ERROR_FAILURE, NS_OK, etc
|
|
#include "nsIChannel.h" // for nsIChannel
|
|
#include "nsICommandManager.h" // for nsICommandManager
|
|
#include "nsIContentViewer.h" // for nsIContentViewer
|
|
#include "nsIController.h" // for nsIController
|
|
#include "nsIControllerContext.h" // for nsIControllerContext
|
|
#include "nsIControllers.h" // for nsIControllers
|
|
#include "nsID.h" // for NS_GET_IID, etc
|
|
#include "nsIDOMDocument.h" // for nsIDOMDocument
|
|
#include "nsIDOMHTMLDocument.h" // for nsIDOMHTMLDocument
|
|
#include "nsIDOMWindow.h" // for nsIDOMWindow
|
|
#include "nsIDocShell.h" // for nsIDocShell
|
|
#include "nsIDocument.h" // for nsIDocument
|
|
#include "nsIDocumentStateListener.h"
|
|
#include "nsIEditor.h" // for nsIEditor
|
|
#include "nsIHTMLDocument.h" // for nsIHTMLDocument, etc
|
|
#include "nsIInterfaceRequestorUtils.h" // for do_GetInterface
|
|
#include "nsIPlaintextEditor.h" // for nsIPlaintextEditor, etc
|
|
#include "nsIPresShell.h" // for nsIPresShell
|
|
#include "nsIRefreshURI.h" // for nsIRefreshURI
|
|
#include "nsIRequest.h" // for nsIRequest
|
|
#include "nsISelection.h" // for nsISelection
|
|
#include "nsISelectionPrivate.h" // for nsISelectionPrivate
|
|
#include "nsITimer.h" // for nsITimer, etc
|
|
#include "nsITransactionManager.h" // for nsITransactionManager
|
|
#include "nsIWeakReference.h" // for nsISupportsWeakReference, etc
|
|
#include "nsIWebNavigation.h" // for nsIWebNavigation
|
|
#include "nsIWebProgress.h" // for nsIWebProgress, etc
|
|
#include "nsLiteralString.h" // for NS_LITERAL_STRING
|
|
#include "nsPICommandUpdater.h" // for nsPICommandUpdater
|
|
#include "nsPIDOMWindow.h" // for nsPIDOMWindow
|
|
#include "nsPresContext.h" // for nsPresContext
|
|
#include "nsReadableUtils.h" // for AppendUTF16toUTF8
|
|
#include "nsStringFwd.h" // for nsAFlatString
|
|
#include "mozilla/dom/Selection.h" // for AutoHideSelectionChanges
|
|
#include "nsFrameSelection.h" // for nsFrameSelection
|
|
|
|
class nsISupports;
|
|
class nsIURI;
|
|
|
|
/*---------------------------------------------------------------------------
|
|
|
|
nsEditingSession
|
|
|
|
----------------------------------------------------------------------------*/
|
|
nsEditingSession::nsEditingSession()
|
|
: mDoneSetup(false)
|
|
, mCanCreateEditor(false)
|
|
, mInteractive(false)
|
|
, mMakeWholeDocumentEditable(true)
|
|
, mDisabledJSAndPlugins(false)
|
|
, mScriptsEnabled(true)
|
|
, mPluginsEnabled(true)
|
|
, mProgressListenerRegistered(false)
|
|
, mImageAnimationMode(0)
|
|
, mEditorFlags(0)
|
|
, mEditorStatus(eEditorOK)
|
|
, mBaseCommandControllerId(0)
|
|
, mDocStateControllerId(0)
|
|
, mHTMLCommandControllerId(0)
|
|
{
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------
|
|
|
|
~nsEditingSession
|
|
|
|
----------------------------------------------------------------------------*/
|
|
nsEditingSession::~nsEditingSession()
|
|
{
|
|
// Must cancel previous timer?
|
|
if (mLoadBlankDocTimer)
|
|
mLoadBlankDocTimer->Cancel();
|
|
}
|
|
|
|
NS_IMPL_ISUPPORTS(nsEditingSession, nsIEditingSession, nsIWebProgressListener,
|
|
nsISupportsWeakReference)
|
|
|
|
/*---------------------------------------------------------------------------
|
|
|
|
MakeWindowEditable
|
|
|
|
aEditorType string, "html" "htmlsimple" "text" "textsimple"
|
|
void makeWindowEditable(in nsIDOMWindow aWindow, in string aEditorType,
|
|
in boolean aDoAfterUriLoad,
|
|
in boolean aMakeWholeDocumentEditable,
|
|
in boolean aInteractive);
|
|
----------------------------------------------------------------------------*/
|
|
#define DEFAULT_EDITOR_TYPE "html"
|
|
|
|
NS_IMETHODIMP
|
|
nsEditingSession::MakeWindowEditable(mozIDOMWindowProxy* aWindow,
|
|
const char *aEditorType,
|
|
bool aDoAfterUriLoad,
|
|
bool aMakeWholeDocumentEditable,
|
|
bool aInteractive)
|
|
{
|
|
mEditorType.Truncate();
|
|
mEditorFlags = 0;
|
|
|
|
NS_ENSURE_TRUE(aWindow, NS_ERROR_FAILURE);
|
|
auto* window = nsPIDOMWindowOuter::From(aWindow);
|
|
|
|
// disable plugins
|
|
nsCOMPtr<nsIDocShell> docShell = window->GetDocShell();
|
|
NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE);
|
|
|
|
mDocShell = do_GetWeakReference(docShell);
|
|
mInteractive = aInteractive;
|
|
mMakeWholeDocumentEditable = aMakeWholeDocumentEditable;
|
|
|
|
nsresult rv;
|
|
if (!mInteractive) {
|
|
rv = DisableJSAndPlugins(aWindow);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
}
|
|
|
|
// Always remove existing editor
|
|
TearDownEditorOnWindow(aWindow);
|
|
|
|
// Tells embedder that startup is in progress
|
|
mEditorStatus = eEditorCreationInProgress;
|
|
|
|
//temporary to set editor type here. we will need different classes soon.
|
|
if (!aEditorType)
|
|
aEditorType = DEFAULT_EDITOR_TYPE;
|
|
mEditorType = aEditorType;
|
|
|
|
// if all this does is setup listeners and I don't need listeners,
|
|
// can't this step be ignored?? (based on aDoAfterURILoad)
|
|
rv = PrepareForEditing(window);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
// set the flag on the docShell to say that it's editable
|
|
rv = docShell->MakeEditable(aDoAfterUriLoad);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
// Setup commands common to plaintext and html editors,
|
|
// including the document creation observers
|
|
// the first is an editing controller
|
|
rv = SetupEditorCommandController("@mozilla.org/editor/editingcontroller;1",
|
|
aWindow,
|
|
static_cast<nsIEditingSession*>(this),
|
|
&mBaseCommandControllerId);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
// The second is a controller to monitor doc state,
|
|
// such as creation and "dirty flag"
|
|
rv = SetupEditorCommandController("@mozilla.org/editor/editordocstatecontroller;1",
|
|
aWindow,
|
|
static_cast<nsIEditingSession*>(this),
|
|
&mDocStateControllerId);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
// aDoAfterUriLoad can be false only when making an existing window editable
|
|
if (!aDoAfterUriLoad) {
|
|
rv = SetupEditorOnWindow(aWindow);
|
|
|
|
// mEditorStatus is set to the error reason
|
|
// Since this is used only when editing an existing page,
|
|
// it IS ok to destroy current editor
|
|
if (NS_FAILED(rv)) {
|
|
TearDownEditorOnWindow(aWindow);
|
|
}
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsEditingSession::DisableJSAndPlugins(mozIDOMWindowProxy* aWindow)
|
|
{
|
|
NS_ENSURE_TRUE(aWindow, NS_ERROR_FAILURE);
|
|
nsIDocShell *docShell = nsPIDOMWindowOuter::From(aWindow)->GetDocShell();
|
|
NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE);
|
|
|
|
bool tmp;
|
|
nsresult rv = docShell->GetAllowJavascript(&tmp);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
mScriptsEnabled = tmp;
|
|
|
|
rv = docShell->SetAllowJavascript(false);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
// Disable plugins in this document:
|
|
mPluginsEnabled = docShell->PluginsAllowedInCurrentDoc();
|
|
|
|
rv = docShell->SetAllowPlugins(false);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
mDisabledJSAndPlugins = true;
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsEditingSession::RestoreJSAndPlugins(mozIDOMWindowProxy* aWindow)
|
|
{
|
|
if (!mDisabledJSAndPlugins) {
|
|
return NS_OK;
|
|
}
|
|
|
|
mDisabledJSAndPlugins = false;
|
|
|
|
NS_ENSURE_TRUE(aWindow, NS_ERROR_FAILURE);
|
|
nsIDocShell *docShell = nsPIDOMWindowOuter::From(aWindow)->GetDocShell();
|
|
NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE);
|
|
|
|
nsresult rv = docShell->SetAllowJavascript(mScriptsEnabled);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
// Disable plugins in this document:
|
|
return docShell->SetAllowPlugins(mPluginsEnabled);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsEditingSession::GetJsAndPluginsDisabled(bool *aResult)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aResult);
|
|
*aResult = mDisabledJSAndPlugins;
|
|
return NS_OK;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------
|
|
|
|
WindowIsEditable
|
|
|
|
boolean windowIsEditable (in nsIDOMWindow aWindow);
|
|
----------------------------------------------------------------------------*/
|
|
NS_IMETHODIMP
|
|
nsEditingSession::WindowIsEditable(mozIDOMWindowProxy* aWindow,
|
|
bool *outIsEditable)
|
|
{
|
|
NS_ENSURE_STATE(aWindow);
|
|
nsCOMPtr<nsIDocShell> docShell = nsPIDOMWindowOuter::From(aWindow)->GetDocShell();
|
|
NS_ENSURE_STATE(docShell);
|
|
|
|
return docShell->GetEditable(outIsEditable);
|
|
}
|
|
|
|
|
|
// These are MIME types that are automatically parsed as "text/plain"
|
|
// and thus we can edit them as plaintext
|
|
// Note: in older versions, we attempted to convert the mimetype of
|
|
// the network channel for these and "text/xml" to "text/plain",
|
|
// but further investigation reveals that strategy doesn't work
|
|
const char* const gSupportedTextTypes[] = {
|
|
"text/plain",
|
|
"text/css",
|
|
"text/rdf",
|
|
"text/xsl",
|
|
"text/javascript", // obsolete type
|
|
"text/ecmascript", // obsolete type
|
|
"application/javascript",
|
|
"application/ecmascript",
|
|
"application/x-javascript", // obsolete type
|
|
"text/xul", // obsolete type
|
|
"application/vnd.mozilla.xul+xml",
|
|
nullptr // IMPORTANT! Null must be at end
|
|
};
|
|
|
|
bool
|
|
IsSupportedTextType(const char* aMIMEType)
|
|
{
|
|
NS_ENSURE_TRUE(aMIMEType, false);
|
|
|
|
for (size_t i = 0; gSupportedTextTypes[i]; ++i) {
|
|
if (!strcmp(gSupportedTextTypes[i], aMIMEType)) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------
|
|
|
|
SetupEditorOnWindow
|
|
|
|
nsIEditor setupEditorOnWindow (in nsIDOMWindow aWindow);
|
|
----------------------------------------------------------------------------*/
|
|
NS_IMETHODIMP
|
|
nsEditingSession::SetupEditorOnWindow(mozIDOMWindowProxy* aWindow)
|
|
{
|
|
mDoneSetup = true;
|
|
|
|
NS_ENSURE_TRUE(aWindow, NS_ERROR_FAILURE);
|
|
auto* window = nsPIDOMWindowOuter::From(aWindow);
|
|
|
|
nsresult rv;
|
|
|
|
//MIME CHECKING
|
|
//must get the content type
|
|
// Note: the doc gets this from the network channel during StartPageLoad,
|
|
// so we don't have to get it from there ourselves
|
|
nsAutoCString mimeCType;
|
|
|
|
//then lets check the mime type
|
|
if (nsCOMPtr<nsIDocument> doc = window->GetDoc()) {
|
|
nsAutoString mimeType;
|
|
if (NS_SUCCEEDED(doc->GetContentType(mimeType)))
|
|
AppendUTF16toUTF8(mimeType, mimeCType);
|
|
|
|
if (IsSupportedTextType(mimeCType.get())) {
|
|
mEditorType.AssignLiteral("text");
|
|
mimeCType = "text/plain";
|
|
} else if (!mimeCType.EqualsLiteral("text/html") &&
|
|
!mimeCType.EqualsLiteral("application/xhtml+xml")) {
|
|
// Neither an acceptable text or html type.
|
|
mEditorStatus = eEditorErrorCantEditMimeType;
|
|
|
|
// Turn editor into HTML -- we will load blank page later
|
|
mEditorType.AssignLiteral("html");
|
|
mimeCType.AssignLiteral("text/html");
|
|
}
|
|
|
|
// Flush out frame construction to make sure that the subframe's
|
|
// presshell is set up if it needs to be.
|
|
nsCOMPtr<nsIDocument> document = do_QueryInterface(doc);
|
|
if (document) {
|
|
document->FlushPendingNotifications(Flush_Frames);
|
|
if (mMakeWholeDocumentEditable) {
|
|
document->SetEditableFlag(true);
|
|
nsCOMPtr<nsIHTMLDocument> htmlDocument = do_QueryInterface(document);
|
|
if (htmlDocument) {
|
|
// Enable usage of the execCommand API
|
|
htmlDocument->SetEditingState(nsIHTMLDocument::eDesignMode);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
bool needHTMLController = false;
|
|
|
|
const char *classString = "@mozilla.org/editor/htmleditor;1";
|
|
if (mEditorType.EqualsLiteral("textmail")) {
|
|
mEditorFlags = nsIPlaintextEditor::eEditorPlaintextMask |
|
|
nsIPlaintextEditor::eEditorEnableWrapHackMask |
|
|
nsIPlaintextEditor::eEditorMailMask;
|
|
} else if (mEditorType.EqualsLiteral("text")) {
|
|
mEditorFlags = nsIPlaintextEditor::eEditorPlaintextMask |
|
|
nsIPlaintextEditor::eEditorEnableWrapHackMask;
|
|
} else if (mEditorType.EqualsLiteral("htmlmail")) {
|
|
if (mimeCType.EqualsLiteral("text/html")) {
|
|
needHTMLController = true;
|
|
mEditorFlags = nsIPlaintextEditor::eEditorMailMask;
|
|
} else {
|
|
// Set the flags back to textplain.
|
|
mEditorFlags = nsIPlaintextEditor::eEditorPlaintextMask |
|
|
nsIPlaintextEditor::eEditorEnableWrapHackMask;
|
|
}
|
|
} else {
|
|
// Defaulted to html
|
|
needHTMLController = true;
|
|
}
|
|
|
|
if (mInteractive) {
|
|
mEditorFlags |= nsIPlaintextEditor::eEditorAllowInteraction;
|
|
}
|
|
|
|
// make the UI state maintainer
|
|
mStateMaintainer = new nsComposerCommandsUpdater();
|
|
|
|
// now init the state maintainer
|
|
// This allows notification of error state
|
|
// even if we don't create an editor
|
|
rv = mStateMaintainer->Init(window);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
if (mEditorStatus != eEditorCreationInProgress) {
|
|
mStateMaintainer->NotifyDocumentCreated();
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
// Create editor and do other things
|
|
// only if we haven't found some error above,
|
|
nsCOMPtr<nsIDocShell> docShell = window->GetDocShell();
|
|
NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE);
|
|
nsCOMPtr<nsIPresShell> presShell = docShell->GetPresShell();
|
|
NS_ENSURE_TRUE(presShell, NS_ERROR_FAILURE);
|
|
|
|
if (!mInteractive) {
|
|
// Disable animation of images in this document:
|
|
nsPresContext* presContext = presShell->GetPresContext();
|
|
NS_ENSURE_TRUE(presContext, NS_ERROR_FAILURE);
|
|
|
|
mImageAnimationMode = presContext->ImageAnimationMode();
|
|
presContext->SetImageAnimationMode(imgIContainer::kDontAnimMode);
|
|
}
|
|
|
|
// Hide selection changes during initialization, in order to hide this
|
|
// from web pages.
|
|
RefPtr<nsFrameSelection> fs = presShell->FrameSelection();
|
|
NS_ENSURE_TRUE(fs, NS_ERROR_FAILURE);
|
|
mozilla::dom::AutoHideSelectionChanges hideSelectionChanges(fs);
|
|
|
|
// create and set editor
|
|
// Try to reuse an existing editor
|
|
nsCOMPtr<nsIEditor> editor = do_QueryReferent(mExistingEditor);
|
|
if (editor) {
|
|
editor->PreDestroy(false);
|
|
} else {
|
|
editor = do_CreateInstance(classString, &rv);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
mExistingEditor = do_GetWeakReference(editor);
|
|
}
|
|
// set the editor on the docShell. The docShell now owns it.
|
|
rv = docShell->SetEditor(editor);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
// setup the HTML editor command controller
|
|
if (needHTMLController) {
|
|
// The third controller takes an nsIEditor as the context
|
|
rv = SetupEditorCommandController("@mozilla.org/editor/htmleditorcontroller;1",
|
|
aWindow, editor,
|
|
&mHTMLCommandControllerId);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
}
|
|
|
|
// Set mimetype on editor
|
|
rv = editor->SetContentsMIMEType(mimeCType.get());
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
nsCOMPtr<nsIContentViewer> contentViewer;
|
|
rv = docShell->GetContentViewer(getter_AddRefs(contentViewer));
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
NS_ENSURE_TRUE(contentViewer, NS_ERROR_FAILURE);
|
|
|
|
nsCOMPtr<nsIDOMDocument> domDoc;
|
|
rv = contentViewer->GetDOMDocument(getter_AddRefs(domDoc));
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
NS_ENSURE_TRUE(domDoc, NS_ERROR_FAILURE);
|
|
|
|
// Set up as a doc state listener
|
|
// Important! We must have this to broadcast the "obs_documentCreated" message
|
|
rv = editor->AddDocumentStateListener(mStateMaintainer);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
rv = editor->Init(domDoc, nullptr /* root content */,
|
|
nullptr, mEditorFlags, EmptyString());
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
nsCOMPtr<nsISelection> selection;
|
|
editor->GetSelection(getter_AddRefs(selection));
|
|
nsCOMPtr<nsISelectionPrivate> selPriv = do_QueryInterface(selection);
|
|
NS_ENSURE_TRUE(selPriv, NS_ERROR_FAILURE);
|
|
|
|
rv = selPriv->AddSelectionListener(mStateMaintainer);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
// and as a transaction listener
|
|
nsCOMPtr<nsITransactionManager> txnMgr;
|
|
editor->GetTransactionManager(getter_AddRefs(txnMgr));
|
|
if (txnMgr) {
|
|
txnMgr->AddListener(mStateMaintainer);
|
|
}
|
|
|
|
// Set context on all controllers to be the editor
|
|
rv = SetEditorOnControllers(aWindow, editor);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
// Everything went fine!
|
|
mEditorStatus = eEditorOK;
|
|
|
|
// This will trigger documentCreation notification
|
|
return editor->PostCreate();
|
|
}
|
|
|
|
// Removes all listeners and controllers from aWindow and aEditor.
|
|
void
|
|
nsEditingSession::RemoveListenersAndControllers(nsPIDOMWindowOuter* aWindow,
|
|
nsIEditor *aEditor)
|
|
{
|
|
if (!mStateMaintainer || !aEditor) {
|
|
return;
|
|
}
|
|
|
|
// Remove all the listeners
|
|
nsCOMPtr<nsISelection> selection;
|
|
aEditor->GetSelection(getter_AddRefs(selection));
|
|
nsCOMPtr<nsISelectionPrivate> selPriv = do_QueryInterface(selection);
|
|
if (selPriv)
|
|
selPriv->RemoveSelectionListener(mStateMaintainer);
|
|
|
|
aEditor->RemoveDocumentStateListener(mStateMaintainer);
|
|
|
|
nsCOMPtr<nsITransactionManager> txnMgr;
|
|
aEditor->GetTransactionManager(getter_AddRefs(txnMgr));
|
|
if (txnMgr) {
|
|
txnMgr->RemoveListener(mStateMaintainer);
|
|
}
|
|
|
|
// Remove editor controllers from the window now that we're not
|
|
// editing in that window any more.
|
|
RemoveEditorControllers(aWindow);
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------
|
|
|
|
TearDownEditorOnWindow
|
|
|
|
void tearDownEditorOnWindow (in nsIDOMWindow aWindow);
|
|
----------------------------------------------------------------------------*/
|
|
NS_IMETHODIMP
|
|
nsEditingSession::TearDownEditorOnWindow(mozIDOMWindowProxy *aWindow)
|
|
{
|
|
if (!mDoneSetup) {
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_ENSURE_TRUE(aWindow, NS_ERROR_NULL_POINTER);
|
|
|
|
nsresult rv;
|
|
|
|
// Kill any existing reload timer
|
|
if (mLoadBlankDocTimer) {
|
|
mLoadBlankDocTimer->Cancel();
|
|
mLoadBlankDocTimer = nullptr;
|
|
}
|
|
|
|
mDoneSetup = false;
|
|
|
|
// Check if we're turning off editing (from contentEditable or designMode).
|
|
auto* window = nsPIDOMWindowOuter::From(aWindow);
|
|
|
|
nsCOMPtr<nsIDocument> doc = window->GetDoc();
|
|
nsCOMPtr<nsIHTMLDocument> htmlDoc = do_QueryInterface(doc);
|
|
bool stopEditing = htmlDoc && htmlDoc->IsEditingOn();
|
|
if (stopEditing) {
|
|
RemoveWebProgressListener(window);
|
|
}
|
|
|
|
nsCOMPtr<nsIDocShell> docShell = window->GetDocShell();
|
|
NS_ENSURE_STATE(docShell);
|
|
|
|
nsCOMPtr<nsIEditor> editor;
|
|
rv = docShell->GetEditor(getter_AddRefs(editor));
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
if (stopEditing) {
|
|
htmlDoc->TearingDownEditor(editor);
|
|
}
|
|
|
|
if (mStateMaintainer && editor) {
|
|
// Null out the editor on the controllers first to prevent their weak
|
|
// references from pointing to a destroyed editor.
|
|
SetEditorOnControllers(aWindow, nullptr);
|
|
}
|
|
|
|
// Null out the editor on the docShell to trigger PreDestroy which
|
|
// needs to happen before document state listeners are removed below.
|
|
docShell->SetEditor(nullptr);
|
|
|
|
RemoveListenersAndControllers(window, editor);
|
|
|
|
if (stopEditing) {
|
|
// Make things the way they were before we started editing.
|
|
RestoreJSAndPlugins(aWindow);
|
|
RestoreAnimationMode(window);
|
|
|
|
if (mMakeWholeDocumentEditable) {
|
|
doc->SetEditableFlag(false);
|
|
nsCOMPtr<nsIHTMLDocument> htmlDocument = do_QueryInterface(doc);
|
|
if (htmlDocument) {
|
|
htmlDocument->SetEditingState(nsIHTMLDocument::eOff);
|
|
}
|
|
}
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------
|
|
|
|
GetEditorForFrame
|
|
|
|
nsIEditor getEditorForFrame (in nsIDOMWindow aWindow);
|
|
----------------------------------------------------------------------------*/
|
|
NS_IMETHODIMP
|
|
nsEditingSession::GetEditorForWindow(mozIDOMWindowProxy* aWindow,
|
|
nsIEditor **outEditor)
|
|
{
|
|
NS_ENSURE_STATE(aWindow);
|
|
nsCOMPtr<nsIDocShell> docShell = nsPIDOMWindowOuter::From(aWindow)->GetDocShell();
|
|
NS_ENSURE_STATE(docShell);
|
|
|
|
return docShell->GetEditor(outEditor);
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------
|
|
|
|
OnStateChange
|
|
|
|
----------------------------------------------------------------------------*/
|
|
NS_IMETHODIMP
|
|
nsEditingSession::OnStateChange(nsIWebProgress *aWebProgress,
|
|
nsIRequest *aRequest,
|
|
uint32_t aStateFlags, nsresult aStatus)
|
|
{
|
|
|
|
#ifdef NOISY_DOC_LOADING
|
|
nsCOMPtr<nsIChannel> channel(do_QueryInterface(aRequest));
|
|
if (channel) {
|
|
nsAutoCString contentType;
|
|
channel->GetContentType(contentType);
|
|
if (!contentType.IsEmpty()) {
|
|
printf(" ++++++ MIMETYPE = %s\n", contentType.get());
|
|
}
|
|
}
|
|
#endif
|
|
|
|
//
|
|
// A Request has started...
|
|
//
|
|
if (aStateFlags & nsIWebProgressListener::STATE_START) {
|
|
#ifdef NOISY_DOC_LOADING
|
|
{
|
|
nsCOMPtr<nsIChannel> channel(do_QueryInterface(aRequest));
|
|
if (channel) {
|
|
nsCOMPtr<nsIURI> uri;
|
|
channel->GetURI(getter_AddRefs(uri));
|
|
if (uri) {
|
|
nsXPIDLCString spec;
|
|
uri->GetSpec(spec);
|
|
printf(" **** STATE_START: CHANNEL URI=%s, flags=%x\n",
|
|
spec.get(), aStateFlags);
|
|
}
|
|
} else {
|
|
printf(" STATE_START: NO CHANNEL flags=%x\n", aStateFlags);
|
|
}
|
|
}
|
|
#endif
|
|
// Page level notification...
|
|
if (aStateFlags & nsIWebProgressListener::STATE_IS_NETWORK) {
|
|
nsCOMPtr<nsIChannel> channel(do_QueryInterface(aRequest));
|
|
StartPageLoad(channel);
|
|
#ifdef NOISY_DOC_LOADING
|
|
printf("STATE_START & STATE_IS_NETWORK flags=%x\n", aStateFlags);
|
|
#endif
|
|
}
|
|
|
|
// Document level notification...
|
|
if (aStateFlags & nsIWebProgressListener::STATE_IS_DOCUMENT &&
|
|
!(aStateFlags & nsIWebProgressListener::STATE_RESTORING)) {
|
|
#ifdef NOISY_DOC_LOADING
|
|
printf("STATE_START & STATE_IS_DOCUMENT flags=%x\n", aStateFlags);
|
|
#endif
|
|
|
|
bool progressIsForTargetDocument =
|
|
IsProgressForTargetDocument(aWebProgress);
|
|
|
|
if (progressIsForTargetDocument) {
|
|
nsCOMPtr<mozIDOMWindowProxy> window;
|
|
aWebProgress->GetDOMWindow(getter_AddRefs(window));
|
|
|
|
auto* piWindow = nsPIDOMWindowOuter::From(window);
|
|
nsCOMPtr<nsIDocument> doc = piWindow->GetDoc();
|
|
|
|
nsCOMPtr<nsIHTMLDocument> htmlDoc(do_QueryInterface(doc));
|
|
|
|
if (htmlDoc && htmlDoc->IsWriting()) {
|
|
nsCOMPtr<nsIDOMHTMLDocument> htmlDomDoc = do_QueryInterface(doc);
|
|
nsAutoString designMode;
|
|
htmlDomDoc->GetDesignMode(designMode);
|
|
|
|
if (designMode.EqualsLiteral("on")) {
|
|
// This notification is for data coming in through
|
|
// document.open/write/close(), ignore it.
|
|
|
|
return NS_OK;
|
|
}
|
|
}
|
|
|
|
mCanCreateEditor = true;
|
|
StartDocumentLoad(aWebProgress, progressIsForTargetDocument);
|
|
}
|
|
}
|
|
}
|
|
//
|
|
// A Request is being processed
|
|
//
|
|
else if (aStateFlags & nsIWebProgressListener::STATE_TRANSFERRING) {
|
|
if (aStateFlags & nsIWebProgressListener::STATE_IS_DOCUMENT) {
|
|
// document transfer started
|
|
}
|
|
}
|
|
//
|
|
// Got a redirection
|
|
//
|
|
else if (aStateFlags & nsIWebProgressListener::STATE_REDIRECTING) {
|
|
if (aStateFlags & nsIWebProgressListener::STATE_IS_DOCUMENT) {
|
|
// got a redirect
|
|
}
|
|
}
|
|
//
|
|
// A network or document Request has finished...
|
|
//
|
|
else if (aStateFlags & nsIWebProgressListener::STATE_STOP) {
|
|
#ifdef NOISY_DOC_LOADING
|
|
{
|
|
nsCOMPtr<nsIChannel> channel(do_QueryInterface(aRequest));
|
|
if (channel) {
|
|
nsCOMPtr<nsIURI> uri;
|
|
channel->GetURI(getter_AddRefs(uri));
|
|
if (uri) {
|
|
nsXPIDLCString spec;
|
|
uri->GetSpec(spec);
|
|
printf(" **** STATE_STOP: CHANNEL URI=%s, flags=%x\n",
|
|
spec.get(), aStateFlags);
|
|
}
|
|
} else {
|
|
printf(" STATE_STOP: NO CHANNEL flags=%x\n", aStateFlags);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// Document level notification...
|
|
if (aStateFlags & nsIWebProgressListener::STATE_IS_DOCUMENT) {
|
|
nsCOMPtr<nsIChannel> channel = do_QueryInterface(aRequest);
|
|
EndDocumentLoad(aWebProgress, channel, aStatus,
|
|
IsProgressForTargetDocument(aWebProgress));
|
|
#ifdef NOISY_DOC_LOADING
|
|
printf("STATE_STOP & STATE_IS_DOCUMENT flags=%x\n", aStateFlags);
|
|
#endif
|
|
}
|
|
|
|
// Page level notification...
|
|
if (aStateFlags & nsIWebProgressListener::STATE_IS_NETWORK) {
|
|
nsCOMPtr<nsIChannel> channel = do_QueryInterface(aRequest);
|
|
(void)EndPageLoad(aWebProgress, channel, aStatus);
|
|
#ifdef NOISY_DOC_LOADING
|
|
printf("STATE_STOP & STATE_IS_NETWORK flags=%x\n", aStateFlags);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------
|
|
|
|
OnProgressChange
|
|
|
|
----------------------------------------------------------------------------*/
|
|
NS_IMETHODIMP
|
|
nsEditingSession::OnProgressChange(nsIWebProgress *aWebProgress,
|
|
nsIRequest *aRequest,
|
|
int32_t aCurSelfProgress,
|
|
int32_t aMaxSelfProgress,
|
|
int32_t aCurTotalProgress,
|
|
int32_t aMaxTotalProgress)
|
|
{
|
|
NS_NOTREACHED("notification excluded in AddProgressListener(...)");
|
|
return NS_OK;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------
|
|
|
|
OnLocationChange
|
|
|
|
----------------------------------------------------------------------------*/
|
|
NS_IMETHODIMP
|
|
nsEditingSession::OnLocationChange(nsIWebProgress *aWebProgress,
|
|
nsIRequest *aRequest, nsIURI *aURI,
|
|
uint32_t aFlags)
|
|
{
|
|
nsCOMPtr<mozIDOMWindowProxy> domWindow;
|
|
nsresult rv = aWebProgress->GetDOMWindow(getter_AddRefs(domWindow));
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
auto* piWindow = nsPIDOMWindowOuter::From(domWindow);
|
|
|
|
nsCOMPtr<nsIDocument> doc = piWindow->GetDoc();
|
|
NS_ENSURE_TRUE(doc, NS_ERROR_FAILURE);
|
|
|
|
doc->SetDocumentURI(aURI);
|
|
|
|
// Notify the location-changed observer that
|
|
// the document URL has changed
|
|
nsIDocShell *docShell = piWindow->GetDocShell();
|
|
NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE);
|
|
|
|
nsCOMPtr<nsICommandManager> commandManager = docShell->GetCommandManager();
|
|
nsCOMPtr<nsPICommandUpdater> commandUpdater =
|
|
do_QueryInterface(commandManager);
|
|
NS_ENSURE_TRUE(commandUpdater, NS_ERROR_FAILURE);
|
|
|
|
return commandUpdater->CommandStatusChanged("obs_documentLocationChanged");
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------
|
|
|
|
OnStatusChange
|
|
|
|
----------------------------------------------------------------------------*/
|
|
NS_IMETHODIMP
|
|
nsEditingSession::OnStatusChange(nsIWebProgress *aWebProgress,
|
|
nsIRequest *aRequest,
|
|
nsresult aStatus,
|
|
const char16_t *aMessage)
|
|
{
|
|
NS_NOTREACHED("notification excluded in AddProgressListener(...)");
|
|
return NS_OK;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------
|
|
|
|
OnSecurityChange
|
|
|
|
----------------------------------------------------------------------------*/
|
|
NS_IMETHODIMP
|
|
nsEditingSession::OnSecurityChange(nsIWebProgress *aWebProgress,
|
|
nsIRequest *aRequest, uint32_t state)
|
|
{
|
|
NS_NOTREACHED("notification excluded in AddProgressListener(...)");
|
|
return NS_OK;
|
|
}
|
|
|
|
|
|
/*---------------------------------------------------------------------------
|
|
|
|
IsProgressForTargetDocument
|
|
|
|
Check that this notification is for our document.
|
|
----------------------------------------------------------------------------*/
|
|
|
|
bool
|
|
nsEditingSession::IsProgressForTargetDocument(nsIWebProgress *aWebProgress)
|
|
{
|
|
nsCOMPtr<nsIWebProgress> editedWebProgress = do_QueryReferent(mDocShell);
|
|
return editedWebProgress == aWebProgress;
|
|
}
|
|
|
|
|
|
/*---------------------------------------------------------------------------
|
|
|
|
GetEditorStatus
|
|
|
|
Called during GetCommandStateParams("obs_documentCreated"...)
|
|
to determine if editor was created and document
|
|
was loaded successfully
|
|
----------------------------------------------------------------------------*/
|
|
NS_IMETHODIMP
|
|
nsEditingSession::GetEditorStatus(uint32_t *aStatus)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aStatus);
|
|
*aStatus = mEditorStatus;
|
|
return NS_OK;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------
|
|
|
|
StartDocumentLoad
|
|
|
|
Called on start of load in a single frame
|
|
----------------------------------------------------------------------------*/
|
|
nsresult
|
|
nsEditingSession::StartDocumentLoad(nsIWebProgress *aWebProgress,
|
|
bool aIsToBeMadeEditable)
|
|
{
|
|
#ifdef NOISY_DOC_LOADING
|
|
printf("======= StartDocumentLoad ========\n");
|
|
#endif
|
|
|
|
NS_ENSURE_ARG_POINTER(aWebProgress);
|
|
|
|
if (aIsToBeMadeEditable) {
|
|
mEditorStatus = eEditorCreationInProgress;
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------
|
|
|
|
EndDocumentLoad
|
|
|
|
Called on end of load in a single frame
|
|
----------------------------------------------------------------------------*/
|
|
nsresult
|
|
nsEditingSession::EndDocumentLoad(nsIWebProgress *aWebProgress,
|
|
nsIChannel* aChannel, nsresult aStatus,
|
|
bool aIsToBeMadeEditable)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aWebProgress);
|
|
|
|
#ifdef NOISY_DOC_LOADING
|
|
printf("======= EndDocumentLoad ========\n");
|
|
printf("with status %d, ", aStatus);
|
|
nsCOMPtr<nsIURI> uri;
|
|
nsXPIDLCString spec;
|
|
if (NS_SUCCEEDED(aChannel->GetURI(getter_AddRefs(uri)))) {
|
|
uri->GetSpec(spec);
|
|
printf(" uri %s\n", spec.get());
|
|
}
|
|
#endif
|
|
|
|
// We want to call the base class EndDocumentLoad,
|
|
// but avoid some of the stuff
|
|
// that nsDocShell does (need to refactor).
|
|
|
|
// OK, time to make an editor on this document
|
|
nsCOMPtr<mozIDOMWindowProxy> domWindow;
|
|
aWebProgress->GetDOMWindow(getter_AddRefs(domWindow));
|
|
NS_ENSURE_TRUE(domWindow, NS_ERROR_FAILURE);
|
|
|
|
// Set the error state -- we will create an editor
|
|
// anyway and load empty doc later
|
|
if (aIsToBeMadeEditable && aStatus == NS_ERROR_FILE_NOT_FOUND) {
|
|
mEditorStatus = eEditorErrorFileNotFound;
|
|
}
|
|
|
|
nsIDocShell *docShell = nsPIDOMWindowOuter::From(domWindow)->GetDocShell();
|
|
NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE); // better error handling?
|
|
|
|
// cancel refresh from meta tags
|
|
// we need to make sure that all pages in editor (whether editable or not)
|
|
// can't refresh contents being edited
|
|
nsCOMPtr<nsIRefreshURI> refreshURI = do_QueryInterface(docShell);
|
|
if (refreshURI) {
|
|
refreshURI->CancelRefreshURITimers();
|
|
}
|
|
|
|
nsresult rv = NS_OK;
|
|
|
|
// did someone set the flag to make this shell editable?
|
|
if (aIsToBeMadeEditable && mCanCreateEditor) {
|
|
bool makeEditable;
|
|
docShell->GetEditable(&makeEditable);
|
|
|
|
if (makeEditable) {
|
|
// To keep pre Gecko 1.9 behavior, setup editor always when
|
|
// mMakeWholeDocumentEditable.
|
|
bool needsSetup = false;
|
|
if (mMakeWholeDocumentEditable) {
|
|
needsSetup = true;
|
|
} else {
|
|
// do we already have an editor here?
|
|
nsCOMPtr<nsIEditor> editor;
|
|
rv = docShell->GetEditor(getter_AddRefs(editor));
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
needsSetup = !editor;
|
|
}
|
|
|
|
if (needsSetup) {
|
|
mCanCreateEditor = false;
|
|
rv = SetupEditorOnWindow(domWindow);
|
|
if (NS_FAILED(rv)) {
|
|
// If we had an error, setup timer to load a blank page later
|
|
if (mLoadBlankDocTimer) {
|
|
// Must cancel previous timer?
|
|
mLoadBlankDocTimer->Cancel();
|
|
mLoadBlankDocTimer = nullptr;
|
|
}
|
|
|
|
mLoadBlankDocTimer = do_CreateInstance("@mozilla.org/timer;1", &rv);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
mEditorStatus = eEditorCreationInProgress;
|
|
mLoadBlankDocTimer->InitWithFuncCallback(
|
|
nsEditingSession::TimerCallback,
|
|
static_cast<void*> (mDocShell.get()),
|
|
10, nsITimer::TYPE_ONE_SHOT);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
|
|
void
|
|
nsEditingSession::TimerCallback(nsITimer* aTimer, void* aClosure)
|
|
{
|
|
nsCOMPtr<nsIDocShell> docShell = do_QueryReferent(static_cast<nsIWeakReference*> (aClosure));
|
|
if (docShell) {
|
|
nsCOMPtr<nsIWebNavigation> webNav(do_QueryInterface(docShell));
|
|
if (webNav) {
|
|
webNav->LoadURI(u"about:blank", 0, nullptr, nullptr, nullptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------
|
|
|
|
StartPageLoad
|
|
|
|
Called on start load of the entire page (incl. subframes)
|
|
----------------------------------------------------------------------------*/
|
|
nsresult
|
|
nsEditingSession::StartPageLoad(nsIChannel *aChannel)
|
|
{
|
|
#ifdef NOISY_DOC_LOADING
|
|
printf("======= StartPageLoad ========\n");
|
|
#endif
|
|
return NS_OK;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------
|
|
|
|
EndPageLoad
|
|
|
|
Called on end load of the entire page (incl. subframes)
|
|
----------------------------------------------------------------------------*/
|
|
nsresult
|
|
nsEditingSession::EndPageLoad(nsIWebProgress *aWebProgress,
|
|
nsIChannel* aChannel, nsresult aStatus)
|
|
{
|
|
#ifdef NOISY_DOC_LOADING
|
|
printf("======= EndPageLoad ========\n");
|
|
printf(" with status %d, ", aStatus);
|
|
nsCOMPtr<nsIURI> uri;
|
|
nsXPIDLCString spec;
|
|
if (NS_SUCCEEDED(aChannel->GetURI(getter_AddRefs(uri)))) {
|
|
uri->GetSpec(spec);
|
|
printf("uri %s\n", spec.get());
|
|
}
|
|
|
|
nsAutoCString contentType;
|
|
aChannel->GetContentType(contentType);
|
|
if (!contentType.IsEmpty()) {
|
|
printf(" flags = %d, status = %d, MIMETYPE = %s\n",
|
|
mEditorFlags, mEditorStatus, contentType.get());
|
|
}
|
|
#endif
|
|
|
|
// Set the error state -- we will create an editor anyway
|
|
// and load empty doc later
|
|
if (aStatus == NS_ERROR_FILE_NOT_FOUND) {
|
|
mEditorStatus = eEditorErrorFileNotFound;
|
|
}
|
|
|
|
nsCOMPtr<mozIDOMWindowProxy> domWindow;
|
|
aWebProgress->GetDOMWindow(getter_AddRefs(domWindow));
|
|
|
|
nsIDocShell *docShell =
|
|
domWindow ? nsPIDOMWindowOuter::From(domWindow)->GetDocShell() : nullptr;
|
|
NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE);
|
|
|
|
// cancel refresh from meta tags
|
|
// we need to make sure that all pages in editor (whether editable or not)
|
|
// can't refresh contents being edited
|
|
nsCOMPtr<nsIRefreshURI> refreshURI = do_QueryInterface(docShell);
|
|
if (refreshURI) {
|
|
refreshURI->CancelRefreshURITimers();
|
|
}
|
|
|
|
#if 0
|
|
// Shouldn't we do this when we want to edit sub-frames?
|
|
return MakeWindowEditable(domWindow, "html", false, mInteractive);
|
|
#else
|
|
return NS_OK;
|
|
#endif
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------
|
|
|
|
PrepareForEditing
|
|
|
|
Set up this editing session for one or more editors
|
|
----------------------------------------------------------------------------*/
|
|
nsresult
|
|
nsEditingSession::PrepareForEditing(nsPIDOMWindowOuter* aWindow)
|
|
{
|
|
if (mProgressListenerRegistered) {
|
|
return NS_OK;
|
|
}
|
|
|
|
nsIDocShell *docShell = aWindow ? aWindow->GetDocShell() : nullptr;
|
|
|
|
// register callback
|
|
nsCOMPtr<nsIWebProgress> webProgress = do_GetInterface(docShell);
|
|
NS_ENSURE_TRUE(webProgress, NS_ERROR_FAILURE);
|
|
|
|
nsresult rv =
|
|
webProgress->AddProgressListener(this,
|
|
(nsIWebProgress::NOTIFY_STATE_NETWORK |
|
|
nsIWebProgress::NOTIFY_STATE_DOCUMENT |
|
|
nsIWebProgress::NOTIFY_LOCATION));
|
|
|
|
mProgressListenerRegistered = NS_SUCCEEDED(rv);
|
|
|
|
return rv;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------
|
|
|
|
SetupEditorCommandController
|
|
|
|
Create a command controller, append to controllers,
|
|
get and return the controller ID, and set the context
|
|
----------------------------------------------------------------------------*/
|
|
nsresult
|
|
nsEditingSession::SetupEditorCommandController(
|
|
const char *aControllerClassName,
|
|
mozIDOMWindowProxy *aWindow,
|
|
nsISupports *aContext,
|
|
uint32_t *aControllerId)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aControllerClassName);
|
|
NS_ENSURE_ARG_POINTER(aWindow);
|
|
NS_ENSURE_ARG_POINTER(aContext);
|
|
NS_ENSURE_ARG_POINTER(aControllerId);
|
|
|
|
auto* piWindow = nsPIDOMWindowOuter::From(aWindow);
|
|
MOZ_ASSERT(piWindow);
|
|
|
|
nsCOMPtr<nsIControllers> controllers;
|
|
nsresult rv = piWindow->GetControllers(getter_AddRefs(controllers));
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
// We only have to create each singleton controller once
|
|
// We know this has happened once we have a controllerId value
|
|
if (!*aControllerId) {
|
|
nsCOMPtr<nsIController> controller;
|
|
controller = do_CreateInstance(aControllerClassName, &rv);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
// We must insert at head of the list to be sure our
|
|
// controller is found before other implementations
|
|
// (e.g., not-implemented versions by browser)
|
|
rv = controllers->InsertControllerAt(0, controller);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
// Remember the ID for the controller
|
|
rv = controllers->GetControllerId(controller, aControllerId);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
}
|
|
|
|
// Set the context
|
|
return SetContextOnControllerById(controllers, aContext, *aControllerId);
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------
|
|
|
|
SetEditorOnControllers
|
|
|
|
Set the editor on the controller(s) for this window
|
|
----------------------------------------------------------------------------*/
|
|
NS_IMETHODIMP
|
|
nsEditingSession::SetEditorOnControllers(mozIDOMWindowProxy* aWindow,
|
|
nsIEditor* aEditor)
|
|
{
|
|
NS_ENSURE_TRUE(aWindow, NS_ERROR_NULL_POINTER);
|
|
|
|
auto* piWindow = nsPIDOMWindowOuter::From(aWindow);
|
|
|
|
nsCOMPtr<nsIControllers> controllers;
|
|
nsresult rv = piWindow->GetControllers(getter_AddRefs(controllers));
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
nsCOMPtr<nsISupports> editorAsISupports = do_QueryInterface(aEditor);
|
|
if (mBaseCommandControllerId) {
|
|
rv = SetContextOnControllerById(controllers, editorAsISupports,
|
|
mBaseCommandControllerId);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
}
|
|
|
|
if (mDocStateControllerId) {
|
|
rv = SetContextOnControllerById(controllers, editorAsISupports,
|
|
mDocStateControllerId);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
}
|
|
|
|
if (mHTMLCommandControllerId) {
|
|
rv = SetContextOnControllerById(controllers, editorAsISupports,
|
|
mHTMLCommandControllerId);
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
nsresult
|
|
nsEditingSession::SetContextOnControllerById(nsIControllers* aControllers,
|
|
nsISupports* aContext,
|
|
uint32_t aID)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aControllers);
|
|
|
|
// aContext can be null (when destroying editor)
|
|
nsCOMPtr<nsIController> controller;
|
|
aControllers->GetControllerById(aID, getter_AddRefs(controller));
|
|
|
|
// ok with nil controller
|
|
nsCOMPtr<nsIControllerContext> editorController =
|
|
do_QueryInterface(controller);
|
|
NS_ENSURE_TRUE(editorController, NS_ERROR_FAILURE);
|
|
|
|
return editorController->SetCommandContext(aContext);
|
|
}
|
|
|
|
void
|
|
nsEditingSession::RemoveEditorControllers(nsPIDOMWindowOuter* aWindow)
|
|
{
|
|
// Remove editor controllers from the aWindow, call when we're
|
|
// tearing down/detaching editor.
|
|
|
|
nsCOMPtr<nsIControllers> controllers;
|
|
if (aWindow) {
|
|
aWindow->GetControllers(getter_AddRefs(controllers));
|
|
}
|
|
|
|
if (controllers) {
|
|
nsCOMPtr<nsIController> controller;
|
|
if (mBaseCommandControllerId) {
|
|
controllers->GetControllerById(mBaseCommandControllerId,
|
|
getter_AddRefs(controller));
|
|
if (controller) {
|
|
controllers->RemoveController(controller);
|
|
}
|
|
}
|
|
|
|
if (mDocStateControllerId) {
|
|
controllers->GetControllerById(mDocStateControllerId,
|
|
getter_AddRefs(controller));
|
|
if (controller) {
|
|
controllers->RemoveController(controller);
|
|
}
|
|
}
|
|
|
|
if (mHTMLCommandControllerId) {
|
|
controllers->GetControllerById(mHTMLCommandControllerId,
|
|
getter_AddRefs(controller));
|
|
if (controller) {
|
|
controllers->RemoveController(controller);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Clear IDs to trigger creation of new controllers.
|
|
mBaseCommandControllerId = 0;
|
|
mDocStateControllerId = 0;
|
|
mHTMLCommandControllerId = 0;
|
|
}
|
|
|
|
void
|
|
nsEditingSession::RemoveWebProgressListener(nsPIDOMWindowOuter* aWindow)
|
|
{
|
|
nsIDocShell *docShell = aWindow ? aWindow->GetDocShell() : nullptr;
|
|
nsCOMPtr<nsIWebProgress> webProgress = do_GetInterface(docShell);
|
|
if (webProgress) {
|
|
webProgress->RemoveProgressListener(this);
|
|
mProgressListenerRegistered = false;
|
|
}
|
|
}
|
|
|
|
void
|
|
nsEditingSession::RestoreAnimationMode(nsPIDOMWindowOuter* aWindow)
|
|
{
|
|
if (mInteractive) {
|
|
return;
|
|
}
|
|
|
|
nsCOMPtr<nsIDocShell> docShell = aWindow ? aWindow->GetDocShell() : nullptr;
|
|
NS_ENSURE_TRUE_VOID(docShell);
|
|
nsCOMPtr<nsIPresShell> presShell = docShell->GetPresShell();
|
|
NS_ENSURE_TRUE_VOID(presShell);
|
|
nsPresContext* presContext = presShell->GetPresContext();
|
|
NS_ENSURE_TRUE_VOID(presContext);
|
|
|
|
presContext->SetImageAnimationMode(mImageAnimationMode);
|
|
}
|
|
|
|
nsresult
|
|
nsEditingSession::DetachFromWindow(mozIDOMWindowProxy* aWindow)
|
|
{
|
|
NS_ENSURE_TRUE(mDoneSetup, NS_OK);
|
|
|
|
NS_ASSERTION(mStateMaintainer, "mStateMaintainer should exist.");
|
|
|
|
// Kill any existing reload timer
|
|
if (mLoadBlankDocTimer) {
|
|
mLoadBlankDocTimer->Cancel();
|
|
mLoadBlankDocTimer = nullptr;
|
|
}
|
|
|
|
auto* window = nsPIDOMWindowOuter::From(aWindow);
|
|
|
|
// Remove controllers, webprogress listener, and otherwise
|
|
// make things the way they were before we started editing.
|
|
RemoveEditorControllers(window);
|
|
RemoveWebProgressListener(window);
|
|
RestoreJSAndPlugins(aWindow);
|
|
RestoreAnimationMode(window);
|
|
|
|
// Kill our weak reference to our original window, in case
|
|
// it changes on restore, or otherwise dies.
|
|
mDocShell = nullptr;
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
nsEditingSession::ReattachToWindow(mozIDOMWindowProxy* aWindow)
|
|
{
|
|
NS_ENSURE_TRUE(mDoneSetup, NS_OK);
|
|
NS_ENSURE_TRUE(aWindow, NS_ERROR_FAILURE);
|
|
|
|
NS_ASSERTION(mStateMaintainer, "mStateMaintainer should exist.");
|
|
|
|
// Imitate nsEditorDocShell::MakeEditable() to reattach the
|
|
// old editor ot the window.
|
|
nsresult rv;
|
|
|
|
auto* window = nsPIDOMWindowOuter::From(aWindow);
|
|
nsIDocShell *docShell = window->GetDocShell();
|
|
NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE);
|
|
mDocShell = do_GetWeakReference(docShell);
|
|
|
|
// Disable plugins.
|
|
if (!mInteractive) {
|
|
rv = DisableJSAndPlugins(aWindow);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
}
|
|
|
|
// Tells embedder that startup is in progress.
|
|
mEditorStatus = eEditorCreationInProgress;
|
|
|
|
// Adds back web progress listener.
|
|
rv = PrepareForEditing(window);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
// Setup the command controllers again.
|
|
rv = SetupEditorCommandController("@mozilla.org/editor/editingcontroller;1",
|
|
aWindow,
|
|
static_cast<nsIEditingSession*>(this),
|
|
&mBaseCommandControllerId);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
rv = SetupEditorCommandController("@mozilla.org/editor/editordocstatecontroller;1",
|
|
aWindow,
|
|
static_cast<nsIEditingSession*>(this),
|
|
&mDocStateControllerId);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
if (mStateMaintainer) {
|
|
mStateMaintainer->Init(window);
|
|
}
|
|
|
|
// Get editor
|
|
nsCOMPtr<nsIEditor> editor;
|
|
rv = GetEditorForWindow(aWindow, getter_AddRefs(editor));
|
|
NS_ENSURE_TRUE(editor, NS_ERROR_FAILURE);
|
|
|
|
if (!mInteractive) {
|
|
// Disable animation of images in this document:
|
|
nsCOMPtr<nsIPresShell> presShell = docShell->GetPresShell();
|
|
NS_ENSURE_TRUE(presShell, NS_ERROR_FAILURE);
|
|
nsPresContext* presContext = presShell->GetPresContext();
|
|
NS_ENSURE_TRUE(presContext, NS_ERROR_FAILURE);
|
|
|
|
mImageAnimationMode = presContext->ImageAnimationMode();
|
|
presContext->SetImageAnimationMode(imgIContainer::kDontAnimMode);
|
|
}
|
|
|
|
// The third controller takes an nsIEditor as the context
|
|
rv = SetupEditorCommandController("@mozilla.org/editor/htmleditorcontroller;1",
|
|
aWindow, editor,
|
|
&mHTMLCommandControllerId);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
// Set context on all controllers to be the editor
|
|
rv = SetEditorOnControllers(aWindow, editor);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
#ifdef DEBUG
|
|
{
|
|
bool isEditable;
|
|
rv = WindowIsEditable(aWindow, &isEditable);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
NS_ASSERTION(isEditable, "Window is not editable after reattaching editor.");
|
|
}
|
|
#endif // DEBUG
|
|
|
|
return NS_OK;
|
|
}
|