nsComposerDocumentCommands.cpp
/* -*- 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);
nsRefPtr<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
nsRefPtr<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;
}
