mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-11-05 00:25:27 +00:00
01583602a9
The bulk of this commit was generated with a script, executed at the top
level of a typical source code checkout. The only non-machine-generated
part was modifying MFBT's moz.build to reflect the new naming.
CLOSED TREE makes big refactorings like this a piece of cake.
# The main substitution.
find . -name '*.cpp' -o -name '*.cc' -o -name '*.h' -o -name '*.mm' -o -name '*.idl'| \
xargs perl -p -i -e '
s/nsRefPtr\.h/RefPtr\.h/g; # handle includes
s/nsRefPtr ?</RefPtr</g; # handle declarations and variables
'
# Handle a special friend declaration in gfx/layers/AtomicRefCountedWithFinalize.h.
perl -p -i -e 's/::nsRefPtr;/::RefPtr;/' gfx/layers/AtomicRefCountedWithFinalize.h
# Handle nsRefPtr.h itself, a couple places that define constructors
# from nsRefPtr, and code generators specially. We do this here, rather
# than indiscriminantly s/nsRefPtr/RefPtr/, because that would rename
# things like nsRefPtrHashtable.
perl -p -i -e 's/nsRefPtr/RefPtr/g' \
mfbt/nsRefPtr.h \
xpcom/glue/nsCOMPtr.h \
xpcom/base/OwningNonNull.h \
ipc/ipdl/ipdl/lower.py \
ipc/ipdl/ipdl/builtin.py \
dom/bindings/Codegen.py \
python/lldbutils/lldbutils/utils.py
# In our indiscriminate substitution above, we renamed
# nsRefPtrGetterAddRefs, the class behind getter_AddRefs. Fix that up.
find . -name '*.cpp' -o -name '*.h' -o -name '*.idl' | \
xargs perl -p -i -e 's/nsRefPtrGetterAddRefs/RefPtrGetterAddRefs/g'
if [ -d .git ]; then
git mv mfbt/nsRefPtr.h mfbt/RefPtr.h
else
hg mv mfbt/nsRefPtr.h mfbt/RefPtr.h
fi
--HG--
rename : mfbt/nsRefPtr.h => mfbt/RefPtr.h
498 lines
17 KiB
C++
498 lines
17 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 "nsAutoPtr.h" // for nsRefPtr, getter_AddRefs, etc
|
|
#include "nsCOMPtr.h" // for nsCOMPtr, do_QueryInterface, etc
|
|
#include "nsCRT.h" // for nsCRT
|
|
#include "nsComposerCommands.h" // for nsSetDocumentOptionsCommand, etc
|
|
#include "nsDebug.h" // for NS_ENSURE_ARG_POINTER, etc
|
|
#include "nsError.h" // for NS_ERROR_INVALID_ARG, etc
|
|
#include "nsICommandParams.h" // for nsICommandParams
|
|
#include "nsIDOMDocument.h" // for nsIDOMDocument
|
|
#include "nsIDocShell.h" // for nsIDocShell
|
|
#include "nsIDocument.h" // for nsIDocument
|
|
#include "nsIEditingSession.h" // for nsIEditingSession, etc
|
|
#include "nsIEditor.h" // for nsIEditor
|
|
#include "nsIHTMLEditor.h" // for nsIHTMLEditor
|
|
#include "nsIHTMLInlineTableEditor.h" // for nsIHTMLInlineTableEditor
|
|
#include "nsIHTMLObjectResizer.h" // for nsIHTMLObjectResizer
|
|
#include "nsIPlaintextEditor.h" // for nsIPlaintextEditor, etc
|
|
#include "nsIPresShell.h" // for nsIPresShell
|
|
#include "nsISelectionController.h" // for nsISelectionController
|
|
#include "nsISupportsImpl.h" // for nsPresContext::Release
|
|
#include "nsISupportsUtils.h" // for NS_IF_ADDREF
|
|
#include "nsIURI.h" // for nsIURI
|
|
#include "nsPresContext.h" // for nsPresContext
|
|
#include "nscore.h" // for NS_IMETHODIMP, nsresult, etc
|
|
|
|
class nsISupports;
|
|
|
|
//defines
|
|
#define STATE_ENABLED "state_enabled"
|
|
#define STATE_ALL "state_all"
|
|
#define STATE_ATTRIBUTE "state_attribute"
|
|
#define STATE_DATA "state_data"
|
|
|
|
static
|
|
nsresult
|
|
GetPresContextFromEditor(nsIEditor *aEditor, nsPresContext **aResult)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aResult);
|
|
*aResult = nullptr;
|
|
NS_ENSURE_ARG_POINTER(aEditor);
|
|
|
|
nsCOMPtr<nsISelectionController> selCon;
|
|
nsresult rv = aEditor->GetSelectionController(getter_AddRefs(selCon));
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
NS_ENSURE_TRUE(selCon, NS_ERROR_FAILURE);
|
|
|
|
nsCOMPtr<nsIPresShell> presShell = do_QueryInterface(selCon);
|
|
NS_ENSURE_TRUE(presShell, NS_ERROR_FAILURE);
|
|
|
|
NS_IF_ADDREF(*aResult = presShell->GetPresContext());
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsSetDocumentOptionsCommand::IsCommandEnabled(const char * aCommandName,
|
|
nsISupports *refCon,
|
|
bool *outCmdEnabled)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(outCmdEnabled);
|
|
nsCOMPtr<nsIEditor> editor = do_QueryInterface(refCon);
|
|
if (editor)
|
|
return editor->GetIsSelectionEditable(outCmdEnabled);
|
|
|
|
*outCmdEnabled = false;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsSetDocumentOptionsCommand::DoCommand(const char *aCommandName,
|
|
nsISupports *refCon)
|
|
{
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsSetDocumentOptionsCommand::DoCommandParams(const char *aCommandName,
|
|
nsICommandParams *aParams,
|
|
nsISupports *refCon)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aParams);
|
|
|
|
nsCOMPtr<nsIEditor> editor = do_QueryInterface(refCon);
|
|
NS_ENSURE_TRUE(editor, NS_ERROR_INVALID_ARG);
|
|
|
|
RefPtr<nsPresContext> presContext;
|
|
nsresult rv = GetPresContextFromEditor(editor, getter_AddRefs(presContext));
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
NS_ENSURE_TRUE(presContext, NS_ERROR_FAILURE);
|
|
|
|
int32_t animationMode;
|
|
rv = aParams->GetLongValue("imageAnimation", &animationMode);
|
|
if (NS_SUCCEEDED(rv))
|
|
{
|
|
// for possible values of animation mode, see:
|
|
// http://lxr.mozilla.org/seamonkey/source/image/public/imgIContainer.idl
|
|
presContext->SetImageAnimationMode(animationMode);
|
|
}
|
|
|
|
bool allowPlugins;
|
|
rv = aParams->GetBooleanValue("plugins", &allowPlugins);
|
|
if (NS_SUCCEEDED(rv))
|
|
{
|
|
nsCOMPtr<nsIDocShell> docShell(presContext->GetDocShell());
|
|
NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE);
|
|
|
|
rv = docShell->SetAllowPlugins(allowPlugins);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsSetDocumentOptionsCommand::GetCommandStateParams(const char *aCommandName,
|
|
nsICommandParams *aParams,
|
|
nsISupports *refCon)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aParams);
|
|
NS_ENSURE_ARG_POINTER(refCon);
|
|
|
|
// The base editor owns most state info
|
|
nsCOMPtr<nsIEditor> editor = do_QueryInterface(refCon);
|
|
NS_ENSURE_TRUE(editor, NS_ERROR_INVALID_ARG);
|
|
|
|
// Always get the enabled state
|
|
bool outCmdEnabled = false;
|
|
IsCommandEnabled(aCommandName, refCon, &outCmdEnabled);
|
|
nsresult rv = aParams->SetBooleanValue(STATE_ENABLED, outCmdEnabled);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
// get pres context
|
|
RefPtr<nsPresContext> presContext;
|
|
rv = GetPresContextFromEditor(editor, getter_AddRefs(presContext));
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
NS_ENSURE_TRUE(presContext, NS_ERROR_FAILURE);
|
|
|
|
int32_t animationMode;
|
|
rv = aParams->GetLongValue("imageAnimation", &animationMode);
|
|
if (NS_SUCCEEDED(rv))
|
|
{
|
|
// for possible values of animation mode, see
|
|
// http://lxr.mozilla.org/seamonkey/source/image/public/imgIContainer.idl
|
|
rv = aParams->SetLongValue("imageAnimation",
|
|
presContext->ImageAnimationMode());
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
}
|
|
|
|
bool allowPlugins = false;
|
|
rv = aParams->GetBooleanValue("plugins", &allowPlugins);
|
|
if (NS_SUCCEEDED(rv))
|
|
{
|
|
nsCOMPtr<nsIDocShell> docShell(presContext->GetDocShell());
|
|
NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE);
|
|
|
|
allowPlugins = docShell->PluginsAllowedInCurrentDoc();
|
|
|
|
rv = aParams->SetBooleanValue("plugins", allowPlugins);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
|
|
/**
|
|
* Commands for document state that may be changed via doCommandParams
|
|
* As of 11/11/02, this is just "cmd_setDocumentModified"
|
|
* Note that you can use the same command class, nsSetDocumentStateCommand,
|
|
* for more than one of this type of command
|
|
* We check the input command param for different behavior
|
|
*/
|
|
|
|
NS_IMETHODIMP
|
|
nsSetDocumentStateCommand::IsCommandEnabled(const char * aCommandName,
|
|
nsISupports *refCon,
|
|
bool *outCmdEnabled)
|
|
{
|
|
// These commands are always enabled
|
|
NS_ENSURE_ARG_POINTER(outCmdEnabled);
|
|
*outCmdEnabled = true;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsSetDocumentStateCommand::DoCommand(const char *aCommandName,
|
|
nsISupports *refCon)
|
|
{
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsSetDocumentStateCommand::DoCommandParams(const char *aCommandName,
|
|
nsICommandParams *aParams,
|
|
nsISupports *refCon)
|
|
{
|
|
nsCOMPtr<nsIEditor> editor = do_QueryInterface(refCon);
|
|
NS_ENSURE_TRUE(editor, NS_ERROR_INVALID_ARG);
|
|
|
|
if (!nsCRT::strcmp(aCommandName, "cmd_setDocumentModified"))
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aParams);
|
|
|
|
bool modified;
|
|
nsresult rv = aParams->GetBooleanValue(STATE_ATTRIBUTE, &modified);
|
|
|
|
// Should we fail if this param wasn't set?
|
|
// I'm not sure we should be that strict
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
if (modified)
|
|
return editor->IncrementModificationCount(1);
|
|
|
|
return editor->ResetModificationCount();
|
|
}
|
|
|
|
if (!nsCRT::strcmp(aCommandName, "cmd_setDocumentReadOnly"))
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aParams);
|
|
bool isReadOnly;
|
|
nsresult rvRO = aParams->GetBooleanValue(STATE_ATTRIBUTE, &isReadOnly);
|
|
NS_ENSURE_SUCCESS(rvRO, rvRO);
|
|
|
|
uint32_t flags;
|
|
editor->GetFlags(&flags);
|
|
if (isReadOnly)
|
|
flags |= nsIPlaintextEditor::eEditorReadonlyMask;
|
|
else
|
|
flags &= ~(nsIPlaintextEditor::eEditorReadonlyMask);
|
|
|
|
return editor->SetFlags(flags);
|
|
}
|
|
|
|
if (!nsCRT::strcmp(aCommandName, "cmd_setDocumentUseCSS"))
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aParams);
|
|
nsCOMPtr<nsIHTMLEditor> htmleditor = do_QueryInterface(refCon);
|
|
NS_ENSURE_TRUE(htmleditor, NS_ERROR_INVALID_ARG);
|
|
|
|
bool desireCSS;
|
|
nsresult rvCSS = aParams->GetBooleanValue(STATE_ATTRIBUTE, &desireCSS);
|
|
NS_ENSURE_SUCCESS(rvCSS, rvCSS);
|
|
|
|
return htmleditor->SetIsCSSEnabled(desireCSS);
|
|
}
|
|
|
|
if (!nsCRT::strcmp(aCommandName, "cmd_insertBrOnReturn"))
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aParams);
|
|
nsCOMPtr<nsIHTMLEditor> htmleditor = do_QueryInterface(refCon);
|
|
NS_ENSURE_TRUE(htmleditor, NS_ERROR_INVALID_ARG);
|
|
|
|
bool insertBrOnReturn;
|
|
nsresult rvBR = aParams->GetBooleanValue(STATE_ATTRIBUTE,
|
|
&insertBrOnReturn);
|
|
NS_ENSURE_SUCCESS(rvBR, rvBR);
|
|
|
|
return htmleditor->SetReturnInParagraphCreatesNewParagraph(!insertBrOnReturn);
|
|
}
|
|
|
|
if (!nsCRT::strcmp(aCommandName, "cmd_enableObjectResizing"))
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aParams);
|
|
nsCOMPtr<nsIHTMLObjectResizer> resizer = do_QueryInterface(refCon);
|
|
NS_ENSURE_TRUE(resizer, NS_ERROR_INVALID_ARG);
|
|
|
|
bool enabled;
|
|
nsresult rvOR = aParams->GetBooleanValue(STATE_ATTRIBUTE, &enabled);
|
|
NS_ENSURE_SUCCESS(rvOR, rvOR);
|
|
|
|
return resizer->SetObjectResizingEnabled(enabled);
|
|
}
|
|
|
|
if (!nsCRT::strcmp(aCommandName, "cmd_enableInlineTableEditing"))
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aParams);
|
|
nsCOMPtr<nsIHTMLInlineTableEditor> editor = do_QueryInterface(refCon);
|
|
NS_ENSURE_TRUE(editor, NS_ERROR_INVALID_ARG);
|
|
|
|
bool enabled;
|
|
nsresult rvOR = aParams->GetBooleanValue(STATE_ATTRIBUTE, &enabled);
|
|
NS_ENSURE_SUCCESS(rvOR, rvOR);
|
|
|
|
return editor->SetInlineTableEditingEnabled(enabled);
|
|
}
|
|
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsSetDocumentStateCommand::GetCommandStateParams(const char *aCommandName,
|
|
nsICommandParams *aParams,
|
|
nsISupports *refCon)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aParams);
|
|
NS_ENSURE_ARG_POINTER(refCon);
|
|
|
|
// The base editor owns most state info
|
|
nsCOMPtr<nsIEditor> editor = do_QueryInterface(refCon);
|
|
NS_ENSURE_TRUE(editor, NS_ERROR_INVALID_ARG);
|
|
|
|
// Always get the enabled state
|
|
bool outCmdEnabled = false;
|
|
IsCommandEnabled(aCommandName, refCon, &outCmdEnabled);
|
|
nsresult rv = aParams->SetBooleanValue(STATE_ENABLED, outCmdEnabled);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
if (!nsCRT::strcmp(aCommandName, "cmd_setDocumentModified"))
|
|
{
|
|
bool modified;
|
|
rv = editor->GetDocumentModified(&modified);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
return aParams->SetBooleanValue(STATE_ATTRIBUTE, modified);
|
|
}
|
|
|
|
if (!nsCRT::strcmp(aCommandName, "cmd_setDocumentReadOnly"))
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aParams);
|
|
|
|
uint32_t flags;
|
|
editor->GetFlags(&flags);
|
|
bool isReadOnly = flags & nsIPlaintextEditor::eEditorReadonlyMask;
|
|
return aParams->SetBooleanValue(STATE_ATTRIBUTE, isReadOnly);
|
|
}
|
|
|
|
if (!nsCRT::strcmp(aCommandName, "cmd_setDocumentUseCSS"))
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aParams);
|
|
nsCOMPtr<nsIHTMLEditor> htmleditor = do_QueryInterface(refCon);
|
|
NS_ENSURE_TRUE(htmleditor, NS_ERROR_INVALID_ARG);
|
|
|
|
bool isCSS;
|
|
htmleditor->GetIsCSSEnabled(&isCSS);
|
|
return aParams->SetBooleanValue(STATE_ALL, isCSS);
|
|
}
|
|
|
|
if (!nsCRT::strcmp(aCommandName, "cmd_insertBrOnReturn"))
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aParams);
|
|
nsCOMPtr<nsIHTMLEditor> htmleditor = do_QueryInterface(refCon);
|
|
NS_ENSURE_TRUE(htmleditor, NS_ERROR_INVALID_ARG);
|
|
|
|
bool createPOnReturn;
|
|
htmleditor->GetReturnInParagraphCreatesNewParagraph(&createPOnReturn);
|
|
return aParams->SetBooleanValue(STATE_ATTRIBUTE, !createPOnReturn);
|
|
}
|
|
|
|
if (!nsCRT::strcmp(aCommandName, "cmd_enableObjectResizing"))
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aParams);
|
|
nsCOMPtr<nsIHTMLObjectResizer> resizer = do_QueryInterface(refCon);
|
|
NS_ENSURE_TRUE(resizer, NS_ERROR_INVALID_ARG);
|
|
|
|
bool enabled;
|
|
resizer->GetObjectResizingEnabled(&enabled);
|
|
return aParams->SetBooleanValue(STATE_ATTRIBUTE, enabled);
|
|
}
|
|
|
|
if (!nsCRT::strcmp(aCommandName, "cmd_enableInlineTableEditing"))
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aParams);
|
|
nsCOMPtr<nsIHTMLInlineTableEditor> editor = do_QueryInterface(refCon);
|
|
NS_ENSURE_TRUE(editor, NS_ERROR_INVALID_ARG);
|
|
|
|
bool enabled;
|
|
editor->GetInlineTableEditingEnabled(&enabled);
|
|
return aParams->SetBooleanValue(STATE_ATTRIBUTE, enabled);
|
|
}
|
|
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
/**
|
|
* Commands just for state notification
|
|
* As of 11/21/02, possible commands are:
|
|
* "obs_documentCreated"
|
|
* "obs_documentWillBeDestroyed"
|
|
* "obs_documentLocationChanged"
|
|
* Note that you can use the same command class, nsDocumentStateCommand
|
|
* for these or future observer commands.
|
|
* We check the input command param for different behavior
|
|
*
|
|
* How to use:
|
|
* 1. Get the nsICommandManager for the current editor
|
|
* 2. Implement an nsIObserve object, e.g:
|
|
*
|
|
* void Observe(
|
|
* in nsISupports aSubject, // The nsICommandManager calling this Observer
|
|
* in string aTopic, // command name, e.g.:"obs_documentCreated"
|
|
* // or "obs_documentWillBeDestroyed"
|
|
in wstring aData ); // ignored (set to "command_status_changed")
|
|
*
|
|
* 3. Add the observer by:
|
|
* commandManager.addObserver(observeobject, obs_documentCreated);
|
|
* 4. In the appropriate location in editorSession, editor, or commands code,
|
|
* trigger the notification of this observer by something like:
|
|
*
|
|
* nsCOMPtr<nsICommandManager> commandManager = do_GetInterface(mDocShell);
|
|
* nsCOMPtr<nsPICommandUpdater> commandUpdater = do_QueryInterface(commandManager);
|
|
* NS_ENSURE_TRUE(commandUpdater, NS_ERROR_FAILURE);
|
|
* commandUpdater->CommandStatusChanged(obs_documentCreated);
|
|
*
|
|
* 5. Use GetCommandStateParams() to obtain state information
|
|
* e.g., any creation state codes when creating an editor are
|
|
* supplied for "obs_documentCreated" command in the
|
|
* "state_data" param's value
|
|
*
|
|
*/
|
|
|
|
NS_IMETHODIMP
|
|
nsDocumentStateCommand::IsCommandEnabled(const char* aCommandName,
|
|
nsISupports *refCon,
|
|
bool *outCmdEnabled)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(outCmdEnabled);
|
|
// Always return false to discourage callers from using DoCommand()
|
|
*outCmdEnabled = false;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsDocumentStateCommand::DoCommand(const char *aCommandName,
|
|
nsISupports *refCon)
|
|
{
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsDocumentStateCommand::DoCommandParams(const char *aCommandName,
|
|
nsICommandParams *aParams,
|
|
nsISupports *refCon)
|
|
{
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsDocumentStateCommand::GetCommandStateParams(const char *aCommandName,
|
|
nsICommandParams *aParams,
|
|
nsISupports *refCon)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aParams);
|
|
NS_ENSURE_ARG_POINTER(aCommandName);
|
|
nsresult rv;
|
|
|
|
if (!nsCRT::strcmp(aCommandName, "obs_documentCreated"))
|
|
{
|
|
uint32_t editorStatus = nsIEditingSession::eEditorErrorUnknown;
|
|
|
|
nsCOMPtr<nsIEditingSession> editingSession = do_QueryInterface(refCon);
|
|
if (editingSession)
|
|
{
|
|
// refCon is initially set to nsIEditingSession until editor
|
|
// is successfully created and source doc is loaded
|
|
// Embedder gets error status if this fails
|
|
// If called before startup is finished,
|
|
// status = eEditorCreationInProgress
|
|
rv = editingSession->GetEditorStatus(&editorStatus);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
}
|
|
else
|
|
{
|
|
// If refCon is an editor, then everything started up OK!
|
|
nsCOMPtr<nsIEditor> editor = do_QueryInterface(refCon);
|
|
if (editor)
|
|
editorStatus = nsIEditingSession::eEditorOK;
|
|
}
|
|
|
|
// Note that if refCon is not-null, but is neither
|
|
// an nsIEditingSession or nsIEditor, we return "eEditorErrorUnknown"
|
|
aParams->SetLongValue(STATE_DATA, editorStatus);
|
|
return NS_OK;
|
|
}
|
|
else if (!nsCRT::strcmp(aCommandName, "obs_documentLocationChanged"))
|
|
{
|
|
nsCOMPtr<nsIEditor> editor = do_QueryInterface(refCon);
|
|
if (editor)
|
|
{
|
|
nsCOMPtr<nsIDOMDocument> domDoc;
|
|
editor->GetDocument(getter_AddRefs(domDoc));
|
|
nsCOMPtr<nsIDocument> doc = do_QueryInterface(domDoc);
|
|
NS_ENSURE_TRUE(doc, NS_ERROR_FAILURE);
|
|
|
|
nsIURI *uri = doc->GetDocumentURI();
|
|
NS_ENSURE_TRUE(uri, NS_ERROR_FAILURE);
|
|
|
|
return aParams->SetISupportsValue(STATE_DATA, (nsISupports*)uri);
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|