mirror of
https://github.com/classilla/tenfourfox.git
synced 2024-09-11 02:56:06 +00:00
1538 lines
45 KiB
C++
1538 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 <stdio.h> // for printf
|
|
|
|
#include "mozilla/Assertions.h" // for MOZ_ASSERT, etc
|
|
#include "nsAString.h"
|
|
#include "nsCOMPtr.h" // for nsCOMPtr, do_QueryInterface, etc
|
|
#include "nsComponentManagerUtils.h" // for do_CreateInstance
|
|
#include "nsComposerCommands.h"
|
|
#include "nsDebug.h" // for NS_ENSURE_TRUE, etc
|
|
#include "nsError.h" // for NS_OK, NS_ERROR_FAILURE, etc
|
|
#include "nsGkAtoms.h" // for nsGkAtoms, nsGkAtoms::font, etc
|
|
#include "nsIAtom.h" // for nsIAtom, etc
|
|
#include "nsIClipboard.h" // for nsIClipboard, etc
|
|
#include "nsICommandParams.h" // for nsICommandParams, etc
|
|
#include "nsID.h"
|
|
#include "nsIDOMElement.h" // for nsIDOMElement
|
|
#include "nsIEditor.h" // for nsIEditor
|
|
#include "nsIHTMLAbsPosEditor.h" // for nsIHTMLAbsPosEditor
|
|
#include "nsIHTMLEditor.h" // for nsIHTMLEditor, etc
|
|
#include "nsLiteralString.h" // for NS_LITERAL_STRING
|
|
#include "nsReadableUtils.h" // for EmptyString
|
|
#include "nsString.h" // for nsAutoString, nsString, etc
|
|
#include "nsStringFwd.h" // for nsAFlatString
|
|
|
|
class nsISupports;
|
|
|
|
//prototype
|
|
nsresult GetListState(nsIHTMLEditor* aEditor, bool* aMixed,
|
|
nsAString& aLocalName);
|
|
nsresult RemoveOneProperty(nsIHTMLEditor* aEditor, const nsAString& aProp);
|
|
nsresult RemoveTextProperty(nsIHTMLEditor* aEditor, const nsAString& aProp);
|
|
nsresult SetTextProperty(nsIHTMLEditor *aEditor, const nsAString& aProp);
|
|
|
|
|
|
//defines
|
|
#define STATE_ENABLED "state_enabled"
|
|
#define STATE_ALL "state_all"
|
|
#define STATE_ANY "state_any"
|
|
#define STATE_MIXED "state_mixed"
|
|
#define STATE_BEGIN "state_begin"
|
|
#define STATE_END "state_end"
|
|
#define STATE_ATTRIBUTE "state_attribute"
|
|
#define STATE_DATA "state_data"
|
|
|
|
|
|
nsBaseComposerCommand::nsBaseComposerCommand()
|
|
{
|
|
}
|
|
|
|
NS_IMPL_ISUPPORTS(nsBaseComposerCommand, nsIControllerCommand)
|
|
|
|
|
|
nsBaseStateUpdatingCommand::nsBaseStateUpdatingCommand(nsIAtom* aTagName)
|
|
: nsBaseComposerCommand()
|
|
, mTagName(aTagName)
|
|
{
|
|
MOZ_ASSERT(mTagName);
|
|
}
|
|
|
|
nsBaseStateUpdatingCommand::~nsBaseStateUpdatingCommand()
|
|
{
|
|
}
|
|
|
|
NS_IMPL_ISUPPORTS_INHERITED0(nsBaseStateUpdatingCommand, nsBaseComposerCommand)
|
|
|
|
NS_IMETHODIMP
|
|
nsBaseStateUpdatingCommand::IsCommandEnabled(const char *aCommandName,
|
|
nsISupports *refCon,
|
|
bool *outCmdEnabled)
|
|
{
|
|
nsCOMPtr<nsIEditor> editor = do_QueryInterface(refCon);
|
|
if (editor)
|
|
return editor->GetIsSelectionEditable(outCmdEnabled);
|
|
|
|
*outCmdEnabled = false;
|
|
return NS_OK;
|
|
}
|
|
|
|
|
|
NS_IMETHODIMP
|
|
nsBaseStateUpdatingCommand::DoCommand(const char *aCommandName,
|
|
nsISupports *refCon)
|
|
{
|
|
nsCOMPtr<nsIEditor> editor = do_QueryInterface(refCon);
|
|
NS_ENSURE_TRUE(editor, NS_ERROR_NOT_INITIALIZED);
|
|
|
|
return ToggleState(editor);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsBaseStateUpdatingCommand::DoCommandParams(const char *aCommandName,
|
|
nsICommandParams *aParams,
|
|
nsISupports *refCon)
|
|
{
|
|
return DoCommand(aCommandName, refCon);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsBaseStateUpdatingCommand::GetCommandStateParams(const char *aCommandName,
|
|
nsICommandParams *aParams,
|
|
nsISupports *refCon)
|
|
{
|
|
nsCOMPtr<nsIEditor> editor = do_QueryInterface(refCon);
|
|
if (editor)
|
|
return GetCurrentState(editor, aParams);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsPasteNoFormattingCommand::IsCommandEnabled(const char * aCommandName,
|
|
nsISupports *refCon,
|
|
bool *outCmdEnabled)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(outCmdEnabled);
|
|
*outCmdEnabled = false;
|
|
|
|
// This command is only implemented by nsIHTMLEditor, since
|
|
// pasting in a plaintext editor automatically only supplies
|
|
// "unformatted" text
|
|
nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(refCon);
|
|
NS_ENSURE_TRUE(htmlEditor, NS_ERROR_NOT_IMPLEMENTED);
|
|
|
|
nsCOMPtr<nsIEditor> editor = do_QueryInterface(htmlEditor);
|
|
NS_ENSURE_TRUE(editor, NS_ERROR_INVALID_ARG);
|
|
|
|
return editor->CanPaste(nsIClipboard::kGlobalClipboard, outCmdEnabled);
|
|
}
|
|
|
|
|
|
NS_IMETHODIMP
|
|
nsPasteNoFormattingCommand::DoCommand(const char *aCommandName,
|
|
nsISupports *refCon)
|
|
{
|
|
nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(refCon);
|
|
NS_ENSURE_TRUE(htmlEditor, NS_ERROR_NOT_IMPLEMENTED);
|
|
|
|
return htmlEditor->PasteNoFormatting(nsIClipboard::kGlobalClipboard);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsPasteNoFormattingCommand::DoCommandParams(const char *aCommandName,
|
|
nsICommandParams *aParams,
|
|
nsISupports *refCon)
|
|
{
|
|
return DoCommand(aCommandName, refCon);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsPasteNoFormattingCommand::GetCommandStateParams(const char *aCommandName,
|
|
nsICommandParams *aParams,
|
|
nsISupports *refCon)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aParams);
|
|
|
|
bool enabled = false;
|
|
nsresult rv = IsCommandEnabled(aCommandName, refCon, &enabled);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
return aParams->SetBooleanValue(STATE_ENABLED, enabled);
|
|
}
|
|
|
|
nsStyleUpdatingCommand::nsStyleUpdatingCommand(nsIAtom* aTagName)
|
|
: nsBaseStateUpdatingCommand(aTagName)
|
|
{
|
|
}
|
|
|
|
nsresult
|
|
nsStyleUpdatingCommand::GetCurrentState(nsIEditor *aEditor,
|
|
nsICommandParams *aParams)
|
|
{
|
|
NS_ASSERTION(aEditor, "Need editor here");
|
|
nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(aEditor);
|
|
NS_ENSURE_TRUE(htmlEditor, NS_ERROR_NOT_INITIALIZED);
|
|
|
|
bool firstOfSelectionHasProp = false;
|
|
bool anyOfSelectionHasProp = false;
|
|
bool allOfSelectionHasProp = false;
|
|
|
|
nsresult rv = htmlEditor->GetInlineProperty(mTagName, EmptyString(),
|
|
EmptyString(),
|
|
&firstOfSelectionHasProp,
|
|
&anyOfSelectionHasProp,
|
|
&allOfSelectionHasProp);
|
|
|
|
aParams->SetBooleanValue(STATE_ENABLED, NS_SUCCEEDED(rv));
|
|
aParams->SetBooleanValue(STATE_ALL, allOfSelectionHasProp);
|
|
aParams->SetBooleanValue(STATE_ANY, anyOfSelectionHasProp);
|
|
aParams->SetBooleanValue(STATE_MIXED, anyOfSelectionHasProp
|
|
&& !allOfSelectionHasProp);
|
|
aParams->SetBooleanValue(STATE_BEGIN, firstOfSelectionHasProp);
|
|
aParams->SetBooleanValue(STATE_END, allOfSelectionHasProp);//not completely accurate
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
nsStyleUpdatingCommand::ToggleState(nsIEditor *aEditor)
|
|
{
|
|
nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(aEditor);
|
|
NS_ENSURE_TRUE(htmlEditor, NS_ERROR_NO_INTERFACE);
|
|
|
|
//create some params now...
|
|
nsresult rv;
|
|
nsCOMPtr<nsICommandParams> params =
|
|
do_CreateInstance(NS_COMMAND_PARAMS_CONTRACTID,&rv);
|
|
if (NS_FAILED(rv) || !params)
|
|
return rv;
|
|
|
|
// tags "href" and "name" are special cases in the core editor
|
|
// they are used to remove named anchor/link and shouldn't be used for insertion
|
|
bool doTagRemoval;
|
|
if (mTagName == nsGkAtoms::href || mTagName == nsGkAtoms::name) {
|
|
doTagRemoval = true;
|
|
} else {
|
|
// check current selection; set doTagRemoval if formatting should be removed
|
|
rv = GetCurrentState(aEditor, params);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
rv = params->GetBooleanValue(STATE_ALL, &doTagRemoval);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
}
|
|
|
|
if (doTagRemoval) {
|
|
// Also remove equivalent properties (bug 317093)
|
|
if (mTagName == nsGkAtoms::b) {
|
|
rv = RemoveTextProperty(htmlEditor, NS_LITERAL_STRING("strong"));
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
} else if (mTagName == nsGkAtoms::i) {
|
|
rv = RemoveTextProperty(htmlEditor, NS_LITERAL_STRING("em"));
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
} else if (mTagName == nsGkAtoms::strike) {
|
|
rv = RemoveTextProperty(htmlEditor, NS_LITERAL_STRING("s"));
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
}
|
|
|
|
rv = RemoveTextProperty(htmlEditor, nsDependentAtomString(mTagName));
|
|
} else {
|
|
// Superscript and Subscript styles are mutually exclusive
|
|
aEditor->BeginTransaction();
|
|
|
|
nsDependentAtomString tagName(mTagName);
|
|
if (mTagName == nsGkAtoms::sub || mTagName == nsGkAtoms::sup) {
|
|
rv = RemoveTextProperty(htmlEditor, tagName);
|
|
}
|
|
if (NS_SUCCEEDED(rv))
|
|
rv = SetTextProperty(htmlEditor, tagName);
|
|
|
|
aEditor->EndTransaction();
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
nsListCommand::nsListCommand(nsIAtom* aTagName)
|
|
: nsBaseStateUpdatingCommand(aTagName)
|
|
{
|
|
}
|
|
|
|
nsresult
|
|
nsListCommand::GetCurrentState(nsIEditor* aEditor, nsICommandParams* aParams)
|
|
{
|
|
NS_ASSERTION(aEditor, "Need editor here");
|
|
nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(aEditor);
|
|
NS_ENSURE_TRUE(htmlEditor, NS_ERROR_NO_INTERFACE);
|
|
|
|
bool bMixed;
|
|
nsAutoString localName;
|
|
nsresult rv = GetListState(htmlEditor, &bMixed, localName);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
bool inList = mTagName->Equals(localName);
|
|
aParams->SetBooleanValue(STATE_ALL, !bMixed && inList);
|
|
aParams->SetBooleanValue(STATE_MIXED, bMixed);
|
|
aParams->SetBooleanValue(STATE_ENABLED, true);
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
nsListCommand::ToggleState(nsIEditor *aEditor)
|
|
{
|
|
nsCOMPtr<nsIHTMLEditor> editor = do_QueryInterface(aEditor);
|
|
NS_ENSURE_TRUE(editor, NS_NOINTERFACE);
|
|
|
|
nsresult rv;
|
|
nsCOMPtr<nsICommandParams> params =
|
|
do_CreateInstance(NS_COMMAND_PARAMS_CONTRACTID,&rv);
|
|
if (NS_FAILED(rv) || !params)
|
|
return rv;
|
|
|
|
rv = GetCurrentState(aEditor, params);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
bool inList;
|
|
rv = params->GetBooleanValue(STATE_ALL,&inList);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
nsDependentAtomString listType(mTagName);
|
|
if (inList) {
|
|
rv = editor->RemoveList(listType);
|
|
} else {
|
|
rv = editor->MakeOrChangeList(listType, false, EmptyString());
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
nsListItemCommand::nsListItemCommand(nsIAtom* aTagName)
|
|
: nsBaseStateUpdatingCommand(aTagName)
|
|
{
|
|
}
|
|
|
|
nsresult
|
|
nsListItemCommand::GetCurrentState(nsIEditor* aEditor,
|
|
nsICommandParams *aParams)
|
|
{
|
|
NS_ASSERTION(aEditor, "Need editor here");
|
|
// 39584
|
|
nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(aEditor);
|
|
NS_ENSURE_TRUE(htmlEditor, NS_NOINTERFACE);
|
|
|
|
bool bMixed, bLI, bDT, bDD;
|
|
nsresult rv = htmlEditor->GetListItemState(&bMixed, &bLI, &bDT, &bDD);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
bool inList = false;
|
|
if (!bMixed)
|
|
{
|
|
if (bLI) {
|
|
inList = mTagName == nsGkAtoms::li;
|
|
} else if (bDT) {
|
|
inList = mTagName == nsGkAtoms::dt;
|
|
} else if (bDD) {
|
|
inList = mTagName == nsGkAtoms::dd;
|
|
}
|
|
}
|
|
|
|
aParams->SetBooleanValue(STATE_ALL, !bMixed && inList);
|
|
aParams->SetBooleanValue(STATE_MIXED, bMixed);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
nsListItemCommand::ToggleState(nsIEditor *aEditor)
|
|
{
|
|
NS_ASSERTION(aEditor, "Need editor here");
|
|
nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(aEditor);
|
|
NS_ENSURE_TRUE(htmlEditor, NS_ERROR_NOT_INITIALIZED);
|
|
|
|
bool inList;
|
|
// Need to use mTagName????
|
|
nsresult rv;
|
|
nsCOMPtr<nsICommandParams> params =
|
|
do_CreateInstance(NS_COMMAND_PARAMS_CONTRACTID,&rv);
|
|
if (NS_FAILED(rv) || !params)
|
|
return rv;
|
|
rv = GetCurrentState(aEditor, params);
|
|
rv = params->GetBooleanValue(STATE_ALL,&inList);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
if (inList) {
|
|
// To remove a list, first get what kind of list we're in
|
|
bool bMixed;
|
|
nsAutoString localName;
|
|
rv = GetListState(htmlEditor, &bMixed, localName);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
if (localName.IsEmpty() || bMixed) {
|
|
return rv;
|
|
}
|
|
return htmlEditor->RemoveList(localName);
|
|
}
|
|
|
|
// Set to the requested paragraph type
|
|
//XXX Note: This actually doesn't work for "LI",
|
|
// but we currently don't use this for non DL lists anyway.
|
|
// Problem: won't this replace any current block paragraph style?
|
|
return htmlEditor->SetParagraphFormat(nsDependentAtomString(mTagName));
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsRemoveListCommand::IsCommandEnabled(const char * aCommandName,
|
|
nsISupports *refCon,
|
|
bool *outCmdEnabled)
|
|
{
|
|
*outCmdEnabled = false;
|
|
nsCOMPtr<nsIEditor> editor = do_QueryInterface(refCon);
|
|
NS_ENSURE_TRUE(editor, NS_OK);
|
|
|
|
bool isEditable = false;
|
|
nsresult rv = editor->GetIsSelectionEditable(&isEditable);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
if (!isEditable) {
|
|
return NS_OK;
|
|
}
|
|
|
|
// It is enabled if we are in any list type
|
|
nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(refCon);
|
|
NS_ENSURE_TRUE(htmlEditor, NS_ERROR_NO_INTERFACE);
|
|
|
|
bool bMixed;
|
|
nsAutoString localName;
|
|
rv = GetListState(htmlEditor, &bMixed, localName);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
*outCmdEnabled = bMixed || !localName.IsEmpty();
|
|
return NS_OK;
|
|
}
|
|
|
|
|
|
NS_IMETHODIMP
|
|
nsRemoveListCommand::DoCommand(const char *aCommandName, nsISupports *refCon)
|
|
{
|
|
nsCOMPtr<nsIHTMLEditor> editor = do_QueryInterface(refCon);
|
|
|
|
nsresult rv = NS_OK;
|
|
if (editor)
|
|
{
|
|
// This removes any list type
|
|
rv = editor->RemoveList(EmptyString());
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsRemoveListCommand::DoCommandParams(const char *aCommandName,
|
|
nsICommandParams *aParams,
|
|
nsISupports *refCon)
|
|
{
|
|
return DoCommand(aCommandName, refCon);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsRemoveListCommand::GetCommandStateParams(const char *aCommandName,
|
|
nsICommandParams *aParams,
|
|
nsISupports *refCon)
|
|
{
|
|
bool outCmdEnabled = false;
|
|
IsCommandEnabled(aCommandName, refCon, &outCmdEnabled);
|
|
return aParams->SetBooleanValue(STATE_ENABLED,outCmdEnabled);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsIndentCommand::IsCommandEnabled(const char * aCommandName,
|
|
nsISupports *refCon, bool *outCmdEnabled)
|
|
{
|
|
nsCOMPtr<nsIEditor> editor = do_QueryInterface(refCon);
|
|
if (editor)
|
|
return editor->GetIsSelectionEditable(outCmdEnabled);
|
|
|
|
*outCmdEnabled = false;
|
|
return NS_OK;
|
|
}
|
|
|
|
|
|
NS_IMETHODIMP
|
|
nsIndentCommand::DoCommand(const char *aCommandName, nsISupports *refCon)
|
|
{
|
|
nsCOMPtr<nsIHTMLEditor> editor = do_QueryInterface(refCon);
|
|
|
|
nsresult rv = NS_OK;
|
|
if (editor)
|
|
{
|
|
rv = editor->Indent(NS_LITERAL_STRING("indent"));
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsIndentCommand::DoCommandParams(const char *aCommandName,
|
|
nsICommandParams *aParams,
|
|
nsISupports *refCon)
|
|
{
|
|
return DoCommand(aCommandName, refCon);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsIndentCommand::GetCommandStateParams(const char *aCommandName,
|
|
nsICommandParams *aParams,
|
|
nsISupports *refCon)
|
|
{
|
|
bool outCmdEnabled = false;
|
|
IsCommandEnabled(aCommandName, refCon, &outCmdEnabled);
|
|
return aParams->SetBooleanValue(STATE_ENABLED,outCmdEnabled);
|
|
}
|
|
|
|
|
|
//OUTDENT
|
|
|
|
NS_IMETHODIMP
|
|
nsOutdentCommand::IsCommandEnabled(const char * aCommandName,
|
|
nsISupports *refCon,
|
|
bool *outCmdEnabled)
|
|
{
|
|
*outCmdEnabled = false;
|
|
|
|
nsCOMPtr<nsIEditor> editor = do_QueryInterface(refCon);
|
|
if (editor) {
|
|
nsresult rv = editor->GetIsSelectionEditable(outCmdEnabled);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
|
|
NS_IMETHODIMP
|
|
nsOutdentCommand::DoCommand(const char *aCommandName, nsISupports *refCon)
|
|
{
|
|
nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(refCon);
|
|
if (htmlEditor)
|
|
return htmlEditor->Indent(NS_LITERAL_STRING("outdent"));
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsOutdentCommand::DoCommandParams(const char *aCommandName,
|
|
nsICommandParams *aParams,
|
|
nsISupports *refCon)
|
|
{
|
|
return DoCommand(aCommandName, refCon);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsOutdentCommand::GetCommandStateParams(const char *aCommandName,
|
|
nsICommandParams *aParams,
|
|
nsISupports *refCon)
|
|
{
|
|
bool outCmdEnabled = false;
|
|
IsCommandEnabled(aCommandName, refCon, &outCmdEnabled);
|
|
return aParams->SetBooleanValue(STATE_ENABLED,outCmdEnabled);
|
|
}
|
|
|
|
nsMultiStateCommand::nsMultiStateCommand()
|
|
: nsBaseComposerCommand()
|
|
{
|
|
}
|
|
|
|
nsMultiStateCommand::~nsMultiStateCommand()
|
|
{
|
|
}
|
|
|
|
NS_IMPL_ISUPPORTS_INHERITED0(nsMultiStateCommand, nsBaseComposerCommand)
|
|
|
|
NS_IMETHODIMP
|
|
nsMultiStateCommand::IsCommandEnabled(const char * aCommandName,
|
|
nsISupports *refCon,
|
|
bool *outCmdEnabled)
|
|
{
|
|
nsCOMPtr<nsIEditor> editor = do_QueryInterface(refCon);
|
|
// should be disabled sometimes, like if the current selection is an image
|
|
if (editor)
|
|
return editor->GetIsSelectionEditable(outCmdEnabled);
|
|
|
|
*outCmdEnabled = false;
|
|
return NS_OK;
|
|
}
|
|
|
|
|
|
NS_IMETHODIMP
|
|
nsMultiStateCommand::DoCommand(const char *aCommandName, nsISupports *refCon)
|
|
{
|
|
#ifdef DEBUG
|
|
printf("who is calling nsMultiStateCommand::DoCommand \
|
|
(no implementation)? %s\n", aCommandName);
|
|
#endif
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsMultiStateCommand::DoCommandParams(const char *aCommandName,
|
|
nsICommandParams *aParams,
|
|
nsISupports *refCon)
|
|
{
|
|
nsCOMPtr<nsIEditor> editor = do_QueryInterface(refCon);
|
|
|
|
nsresult rv = NS_OK;
|
|
if (editor)
|
|
{
|
|
nsAutoString tString;
|
|
|
|
if (aParams) {
|
|
nsXPIDLCString s;
|
|
rv = aParams->GetCStringValue(STATE_ATTRIBUTE, getter_Copies(s));
|
|
if (NS_SUCCEEDED(rv))
|
|
tString.AssignWithConversion(s);
|
|
else
|
|
rv = aParams->GetStringValue(STATE_ATTRIBUTE, tString);
|
|
}
|
|
|
|
rv = SetState(editor, tString);
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsMultiStateCommand::GetCommandStateParams(const char *aCommandName,
|
|
nsICommandParams *aParams,
|
|
nsISupports *refCon)
|
|
{
|
|
nsCOMPtr<nsIEditor> editor = do_QueryInterface(refCon);
|
|
nsresult rv = NS_OK;
|
|
if (editor)
|
|
{
|
|
rv = GetCurrentState(editor, aParams);
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
nsParagraphStateCommand::nsParagraphStateCommand()
|
|
: nsMultiStateCommand()
|
|
{
|
|
}
|
|
|
|
nsresult
|
|
nsParagraphStateCommand::GetCurrentState(nsIEditor *aEditor,
|
|
nsICommandParams *aParams)
|
|
{
|
|
NS_ASSERTION(aEditor, "Need an editor here");
|
|
|
|
nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(aEditor);
|
|
NS_ENSURE_TRUE(htmlEditor, NS_ERROR_FAILURE);
|
|
|
|
bool outMixed;
|
|
nsAutoString outStateString;
|
|
nsresult rv = htmlEditor->GetParagraphState(&outMixed, outStateString);
|
|
if (NS_SUCCEEDED(rv))
|
|
{
|
|
nsAutoCString tOutStateString;
|
|
tOutStateString.AssignWithConversion(outStateString);
|
|
aParams->SetBooleanValue(STATE_MIXED,outMixed);
|
|
aParams->SetCStringValue(STATE_ATTRIBUTE, tOutStateString.get());
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
|
|
nsresult
|
|
nsParagraphStateCommand::SetState(nsIEditor *aEditor, nsString& newState)
|
|
{
|
|
NS_ASSERTION(aEditor, "Need an editor here");
|
|
nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(aEditor);
|
|
NS_ENSURE_TRUE(htmlEditor, NS_ERROR_FAILURE);
|
|
|
|
return htmlEditor->SetParagraphFormat(newState);
|
|
}
|
|
|
|
nsFontFaceStateCommand::nsFontFaceStateCommand()
|
|
: nsMultiStateCommand()
|
|
{
|
|
}
|
|
|
|
nsresult
|
|
nsFontFaceStateCommand::GetCurrentState(nsIEditor *aEditor,
|
|
nsICommandParams *aParams)
|
|
{
|
|
NS_ASSERTION(aEditor, "Need an editor here");
|
|
nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(aEditor);
|
|
NS_ENSURE_TRUE(htmlEditor, NS_ERROR_FAILURE);
|
|
|
|
nsAutoString outStateString;
|
|
bool outMixed;
|
|
nsresult rv = htmlEditor->GetFontFaceState(&outMixed, outStateString);
|
|
if (NS_SUCCEEDED(rv))
|
|
{
|
|
aParams->SetBooleanValue(STATE_MIXED,outMixed);
|
|
aParams->SetCStringValue(STATE_ATTRIBUTE, NS_ConvertUTF16toUTF8(outStateString).get());
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
|
|
nsresult
|
|
nsFontFaceStateCommand::SetState(nsIEditor *aEditor, nsString& newState)
|
|
{
|
|
NS_ASSERTION(aEditor, "Need an editor here");
|
|
nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(aEditor);
|
|
NS_ENSURE_TRUE(htmlEditor, NS_ERROR_FAILURE);
|
|
|
|
if (newState.EqualsLiteral("tt")) {
|
|
// The old "teletype" attribute
|
|
nsresult rv = htmlEditor->SetInlineProperty(nsGkAtoms::tt, EmptyString(),
|
|
EmptyString());
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
// Clear existing font face
|
|
return htmlEditor->RemoveInlineProperty(nsGkAtoms::font,
|
|
NS_LITERAL_STRING("face"));
|
|
}
|
|
|
|
// Remove any existing TT nodes
|
|
nsresult rv = htmlEditor->RemoveInlineProperty(nsGkAtoms::tt, EmptyString());
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
if (newState.IsEmpty() || newState.EqualsLiteral("normal")) {
|
|
return htmlEditor->RemoveInlineProperty(nsGkAtoms::font,
|
|
NS_LITERAL_STRING("face"));
|
|
}
|
|
|
|
return htmlEditor->SetInlineProperty(nsGkAtoms::font,
|
|
NS_LITERAL_STRING("face"), newState);
|
|
}
|
|
|
|
nsFontSizeStateCommand::nsFontSizeStateCommand()
|
|
: nsMultiStateCommand()
|
|
{
|
|
}
|
|
|
|
// nsAutoCString tOutStateString;
|
|
// tOutStateString.AssignWithConversion(outStateString);
|
|
nsresult
|
|
nsFontSizeStateCommand::GetCurrentState(nsIEditor *aEditor,
|
|
nsICommandParams *aParams)
|
|
{
|
|
NS_ASSERTION(aEditor, "Need an editor here");
|
|
nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(aEditor);
|
|
NS_ENSURE_TRUE(htmlEditor, NS_ERROR_INVALID_ARG);
|
|
|
|
nsAutoString outStateString;
|
|
nsCOMPtr<nsIAtom> fontAtom = do_GetAtom("font");
|
|
bool firstHas, anyHas, allHas;
|
|
nsresult rv = htmlEditor->GetInlinePropertyWithAttrValue(fontAtom,
|
|
NS_LITERAL_STRING("size"),
|
|
EmptyString(),
|
|
&firstHas, &anyHas, &allHas,
|
|
outStateString);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
nsAutoCString tOutStateString;
|
|
tOutStateString.AssignWithConversion(outStateString);
|
|
aParams->SetBooleanValue(STATE_MIXED, anyHas && !allHas);
|
|
aParams->SetCStringValue(STATE_ATTRIBUTE, tOutStateString.get());
|
|
aParams->SetBooleanValue(STATE_ENABLED, true);
|
|
|
|
return rv;
|
|
}
|
|
|
|
|
|
// acceptable values for "newState" are:
|
|
// -2
|
|
// -1
|
|
// 0
|
|
// +1
|
|
// +2
|
|
// +3
|
|
// medium
|
|
// normal
|
|
nsresult
|
|
nsFontSizeStateCommand::SetState(nsIEditor *aEditor, nsString& newState)
|
|
{
|
|
NS_ASSERTION(aEditor, "Need an editor here");
|
|
nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(aEditor);
|
|
NS_ENSURE_TRUE(htmlEditor, NS_ERROR_INVALID_ARG);
|
|
|
|
if (!newState.IsEmpty() &&
|
|
!newState.EqualsLiteral("normal") &&
|
|
!newState.EqualsLiteral("medium")) {
|
|
return htmlEditor->SetInlineProperty(nsGkAtoms::font,
|
|
NS_LITERAL_STRING("size"), newState);
|
|
}
|
|
|
|
// remove any existing font size, big or small
|
|
nsresult rv = htmlEditor->RemoveInlineProperty(nsGkAtoms::font,
|
|
NS_LITERAL_STRING("size"));
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
rv = htmlEditor->RemoveInlineProperty(nsGkAtoms::big, EmptyString());
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
return htmlEditor->RemoveInlineProperty(nsGkAtoms::small, EmptyString());
|
|
}
|
|
|
|
nsFontColorStateCommand::nsFontColorStateCommand()
|
|
: nsMultiStateCommand()
|
|
{
|
|
}
|
|
|
|
nsresult
|
|
nsFontColorStateCommand::GetCurrentState(nsIEditor *aEditor,
|
|
nsICommandParams *aParams)
|
|
{
|
|
NS_ASSERTION(aEditor, "Need an editor here");
|
|
|
|
nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(aEditor);
|
|
NS_ENSURE_TRUE(htmlEditor, NS_ERROR_FAILURE);
|
|
|
|
bool outMixed;
|
|
nsAutoString outStateString;
|
|
nsresult rv = htmlEditor->GetFontColorState(&outMixed, outStateString);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
nsAutoCString tOutStateString;
|
|
tOutStateString.AssignWithConversion(outStateString);
|
|
aParams->SetBooleanValue(STATE_MIXED, outMixed);
|
|
aParams->SetCStringValue(STATE_ATTRIBUTE, tOutStateString.get());
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
nsFontColorStateCommand::SetState(nsIEditor *aEditor, nsString& newState)
|
|
{
|
|
NS_ASSERTION(aEditor, "Need an editor here");
|
|
nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(aEditor);
|
|
NS_ENSURE_TRUE(htmlEditor, NS_ERROR_FAILURE);
|
|
|
|
if (newState.IsEmpty() || newState.EqualsLiteral("normal")) {
|
|
return htmlEditor->RemoveInlineProperty(nsGkAtoms::font,
|
|
NS_LITERAL_STRING("color"));
|
|
}
|
|
|
|
return htmlEditor->SetInlineProperty(nsGkAtoms::font,
|
|
NS_LITERAL_STRING("color"), newState);
|
|
}
|
|
|
|
nsHighlightColorStateCommand::nsHighlightColorStateCommand()
|
|
: nsMultiStateCommand()
|
|
{
|
|
}
|
|
|
|
nsresult
|
|
nsHighlightColorStateCommand::GetCurrentState(nsIEditor *aEditor,
|
|
nsICommandParams *aParams)
|
|
{
|
|
NS_ASSERTION(aEditor, "Need an editor here");
|
|
nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(aEditor);
|
|
NS_ENSURE_TRUE(htmlEditor, NS_ERROR_FAILURE);
|
|
|
|
bool outMixed;
|
|
nsAutoString outStateString;
|
|
nsresult rv = htmlEditor->GetHighlightColorState(&outMixed, outStateString);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
nsAutoCString tOutStateString;
|
|
tOutStateString.AssignWithConversion(outStateString);
|
|
aParams->SetBooleanValue(STATE_MIXED, outMixed);
|
|
aParams->SetCStringValue(STATE_ATTRIBUTE, tOutStateString.get());
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
nsHighlightColorStateCommand::SetState(nsIEditor *aEditor, nsString& newState)
|
|
{
|
|
NS_ASSERTION(aEditor, "Need an editor here");
|
|
nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(aEditor);
|
|
NS_ENSURE_TRUE(htmlEditor, NS_ERROR_FAILURE);
|
|
|
|
if (newState.IsEmpty() || newState.EqualsLiteral("normal")) {
|
|
return htmlEditor->RemoveInlineProperty(nsGkAtoms::font,
|
|
NS_LITERAL_STRING("bgcolor"));
|
|
}
|
|
|
|
return htmlEditor->SetInlineProperty(nsGkAtoms::font,
|
|
NS_LITERAL_STRING("bgcolor"),
|
|
newState);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsHighlightColorStateCommand::IsCommandEnabled(const char * aCommandName,
|
|
nsISupports *refCon,
|
|
bool *outCmdEnabled)
|
|
{
|
|
nsCOMPtr<nsIEditor> editor = do_QueryInterface(refCon);
|
|
if (editor)
|
|
return editor->GetIsSelectionEditable(outCmdEnabled);
|
|
|
|
*outCmdEnabled = false;
|
|
return NS_OK;
|
|
}
|
|
|
|
|
|
nsBackgroundColorStateCommand::nsBackgroundColorStateCommand()
|
|
: nsMultiStateCommand()
|
|
{
|
|
}
|
|
|
|
nsresult
|
|
nsBackgroundColorStateCommand::GetCurrentState(nsIEditor *aEditor,
|
|
nsICommandParams *aParams)
|
|
{
|
|
NS_ASSERTION(aEditor, "Need an editor here");
|
|
|
|
nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(aEditor);
|
|
NS_ENSURE_TRUE(htmlEditor, NS_ERROR_FAILURE);
|
|
|
|
bool outMixed;
|
|
nsAutoString outStateString;
|
|
nsresult rv = htmlEditor->GetBackgroundColorState(&outMixed, outStateString);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
nsAutoCString tOutStateString;
|
|
tOutStateString.AssignWithConversion(outStateString);
|
|
aParams->SetBooleanValue(STATE_MIXED, outMixed);
|
|
aParams->SetCStringValue(STATE_ATTRIBUTE, tOutStateString.get());
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
nsBackgroundColorStateCommand::SetState(nsIEditor *aEditor, nsString& newState)
|
|
{
|
|
NS_ASSERTION(aEditor, "Need an editor here");
|
|
|
|
nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(aEditor);
|
|
NS_ENSURE_TRUE(htmlEditor, NS_ERROR_FAILURE);
|
|
|
|
return htmlEditor->SetBackgroundColor(newState);
|
|
}
|
|
|
|
nsAlignCommand::nsAlignCommand()
|
|
: nsMultiStateCommand()
|
|
{
|
|
}
|
|
|
|
nsresult
|
|
nsAlignCommand::GetCurrentState(nsIEditor *aEditor, nsICommandParams *aParams)
|
|
{
|
|
NS_ASSERTION(aEditor, "Need an editor here");
|
|
|
|
nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(aEditor);
|
|
NS_ENSURE_TRUE(htmlEditor, NS_ERROR_FAILURE);
|
|
|
|
nsIHTMLEditor::EAlignment firstAlign;
|
|
bool outMixed;
|
|
nsresult rv = htmlEditor->GetAlignment(&outMixed, &firstAlign);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
nsAutoString outStateString;
|
|
switch (firstAlign)
|
|
{
|
|
default:
|
|
case nsIHTMLEditor::eLeft:
|
|
outStateString.AssignLiteral("left");
|
|
break;
|
|
|
|
case nsIHTMLEditor::eCenter:
|
|
outStateString.AssignLiteral("center");
|
|
break;
|
|
|
|
case nsIHTMLEditor::eRight:
|
|
outStateString.AssignLiteral("right");
|
|
break;
|
|
|
|
case nsIHTMLEditor::eJustify:
|
|
outStateString.AssignLiteral("justify");
|
|
break;
|
|
}
|
|
nsAutoCString tOutStateString;
|
|
tOutStateString.AssignWithConversion(outStateString);
|
|
aParams->SetBooleanValue(STATE_MIXED,outMixed);
|
|
aParams->SetCStringValue(STATE_ATTRIBUTE, tOutStateString.get());
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
nsAlignCommand::SetState(nsIEditor *aEditor, nsString& newState)
|
|
{
|
|
NS_ASSERTION(aEditor, "Need an editor here");
|
|
|
|
nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(aEditor);
|
|
NS_ENSURE_TRUE(htmlEditor, NS_ERROR_FAILURE);
|
|
|
|
return htmlEditor->Align(newState);
|
|
}
|
|
|
|
nsAbsolutePositioningCommand::nsAbsolutePositioningCommand()
|
|
: nsBaseStateUpdatingCommand(nsGkAtoms::_empty)
|
|
{
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsAbsolutePositioningCommand::IsCommandEnabled(const char * aCommandName,
|
|
nsISupports *aCommandRefCon,
|
|
bool *outCmdEnabled)
|
|
{
|
|
nsCOMPtr<nsIEditor> editor = do_QueryInterface(aCommandRefCon);
|
|
nsCOMPtr<nsIHTMLAbsPosEditor> htmlEditor = do_QueryInterface(aCommandRefCon);
|
|
if (htmlEditor)
|
|
{
|
|
bool isEditable = false;
|
|
nsresult rv = editor->GetIsSelectionEditable(&isEditable);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
if (isEditable)
|
|
return htmlEditor->GetAbsolutePositioningEnabled(outCmdEnabled);
|
|
}
|
|
|
|
*outCmdEnabled = false;
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
nsAbsolutePositioningCommand::GetCurrentState(nsIEditor *aEditor, nsICommandParams *aParams)
|
|
{
|
|
NS_ASSERTION(aEditor, "Need an editor here");
|
|
|
|
nsCOMPtr<nsIHTMLAbsPosEditor> htmlEditor = do_QueryInterface(aEditor);
|
|
NS_ENSURE_TRUE(htmlEditor, NS_ERROR_FAILURE);
|
|
|
|
bool isEnabled;
|
|
htmlEditor->GetAbsolutePositioningEnabled(&isEnabled);
|
|
if (!isEnabled) {
|
|
aParams->SetBooleanValue(STATE_MIXED,false);
|
|
aParams->SetCStringValue(STATE_ATTRIBUTE, "");
|
|
return NS_OK;
|
|
}
|
|
|
|
nsCOMPtr<nsIDOMElement> elt;
|
|
nsresult rv = htmlEditor->GetAbsolutelyPositionedSelectionContainer(getter_AddRefs(elt));
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
nsAutoString outStateString;
|
|
if (elt)
|
|
outStateString.AssignLiteral("absolute");
|
|
|
|
aParams->SetBooleanValue(STATE_MIXED,false);
|
|
aParams->SetCStringValue(STATE_ATTRIBUTE, NS_ConvertUTF16toUTF8(outStateString).get());
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
nsAbsolutePositioningCommand::ToggleState(nsIEditor *aEditor)
|
|
{
|
|
NS_ASSERTION(aEditor, "Need an editor here");
|
|
|
|
nsCOMPtr<nsIHTMLAbsPosEditor> htmlEditor = do_QueryInterface(aEditor);
|
|
NS_ENSURE_TRUE(htmlEditor, NS_ERROR_FAILURE);
|
|
|
|
nsCOMPtr<nsIDOMElement> elt;
|
|
nsresult rv = htmlEditor->GetAbsolutelyPositionedSelectionContainer(getter_AddRefs(elt));
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
return htmlEditor->AbsolutePositionSelection(!elt);
|
|
}
|
|
|
|
|
|
NS_IMETHODIMP
|
|
nsDecreaseZIndexCommand::IsCommandEnabled(const char * aCommandName,
|
|
nsISupports *refCon,
|
|
bool *outCmdEnabled)
|
|
{
|
|
nsCOMPtr<nsIHTMLAbsPosEditor> htmlEditor = do_QueryInterface(refCon);
|
|
NS_ENSURE_TRUE(htmlEditor, NS_ERROR_FAILURE);
|
|
|
|
htmlEditor->GetAbsolutePositioningEnabled(outCmdEnabled);
|
|
if (!(*outCmdEnabled))
|
|
return NS_OK;
|
|
|
|
nsCOMPtr<nsIDOMElement> positionedElement;
|
|
htmlEditor->GetPositionedElement(getter_AddRefs(positionedElement));
|
|
*outCmdEnabled = false;
|
|
if (positionedElement) {
|
|
int32_t z;
|
|
nsresult res = htmlEditor->GetElementZIndex(positionedElement, &z);
|
|
NS_ENSURE_SUCCESS(res, res);
|
|
*outCmdEnabled = (z > 0);
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsDecreaseZIndexCommand::DoCommand(const char *aCommandName,
|
|
nsISupports *refCon)
|
|
{
|
|
nsCOMPtr<nsIHTMLAbsPosEditor> htmlEditor = do_QueryInterface(refCon);
|
|
NS_ENSURE_TRUE(htmlEditor, NS_ERROR_NOT_IMPLEMENTED);
|
|
|
|
return htmlEditor->RelativeChangeZIndex(-1);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsDecreaseZIndexCommand::DoCommandParams(const char *aCommandName,
|
|
nsICommandParams *aParams,
|
|
nsISupports *refCon)
|
|
{
|
|
return DoCommand(aCommandName, refCon);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsDecreaseZIndexCommand::GetCommandStateParams(const char *aCommandName,
|
|
nsICommandParams *aParams,
|
|
nsISupports *refCon)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aParams);
|
|
|
|
bool enabled = false;
|
|
nsresult rv = IsCommandEnabled(aCommandName, refCon, &enabled);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
return aParams->SetBooleanValue(STATE_ENABLED, enabled);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsIncreaseZIndexCommand::IsCommandEnabled(const char * aCommandName,
|
|
nsISupports *refCon,
|
|
bool *outCmdEnabled)
|
|
{
|
|
nsCOMPtr<nsIHTMLAbsPosEditor> htmlEditor = do_QueryInterface(refCon);
|
|
NS_ENSURE_TRUE(htmlEditor, NS_ERROR_FAILURE);
|
|
|
|
htmlEditor->GetAbsolutePositioningEnabled(outCmdEnabled);
|
|
if (!(*outCmdEnabled))
|
|
return NS_OK;
|
|
|
|
nsCOMPtr<nsIDOMElement> positionedElement;
|
|
htmlEditor->GetPositionedElement(getter_AddRefs(positionedElement));
|
|
*outCmdEnabled = (nullptr != positionedElement);
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsIncreaseZIndexCommand::DoCommand(const char *aCommandName,
|
|
nsISupports *refCon)
|
|
{
|
|
nsCOMPtr<nsIHTMLAbsPosEditor> htmlEditor = do_QueryInterface(refCon);
|
|
NS_ENSURE_TRUE(htmlEditor, NS_ERROR_NOT_IMPLEMENTED);
|
|
|
|
return htmlEditor->RelativeChangeZIndex(1);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsIncreaseZIndexCommand::DoCommandParams(const char *aCommandName,
|
|
nsICommandParams *aParams,
|
|
nsISupports *refCon)
|
|
{
|
|
return DoCommand(aCommandName, refCon);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsIncreaseZIndexCommand::GetCommandStateParams(const char *aCommandName,
|
|
nsICommandParams *aParams,
|
|
nsISupports *refCon)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aParams);
|
|
|
|
bool enabled = false;
|
|
nsresult rv = IsCommandEnabled(aCommandName, refCon, &enabled);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
return aParams->SetBooleanValue(STATE_ENABLED, enabled);
|
|
}
|
|
|
|
|
|
NS_IMETHODIMP
|
|
nsRemoveStylesCommand::IsCommandEnabled(const char * aCommandName,
|
|
nsISupports *refCon,
|
|
bool *outCmdEnabled)
|
|
{
|
|
nsCOMPtr<nsIEditor> editor = do_QueryInterface(refCon);
|
|
// test if we have any styles?
|
|
if (editor)
|
|
return editor->GetIsSelectionEditable(outCmdEnabled);
|
|
|
|
*outCmdEnabled = false;
|
|
return NS_OK;
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
nsRemoveStylesCommand::DoCommand(const char *aCommandName,
|
|
nsISupports *refCon)
|
|
{
|
|
nsCOMPtr<nsIHTMLEditor> editor = do_QueryInterface(refCon);
|
|
|
|
nsresult rv = NS_OK;
|
|
if (editor)
|
|
{
|
|
rv = editor->RemoveAllInlineProperties();
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsRemoveStylesCommand::DoCommandParams(const char *aCommandName,
|
|
nsICommandParams *aParams,
|
|
nsISupports *refCon)
|
|
{
|
|
return DoCommand(aCommandName, refCon);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsRemoveStylesCommand::GetCommandStateParams(const char *aCommandName,
|
|
nsICommandParams *aParams,
|
|
nsISupports *refCon)
|
|
{
|
|
bool outCmdEnabled = false;
|
|
IsCommandEnabled(aCommandName, refCon, &outCmdEnabled);
|
|
return aParams->SetBooleanValue(STATE_ENABLED,outCmdEnabled);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsIncreaseFontSizeCommand::IsCommandEnabled(const char * aCommandName,
|
|
nsISupports *refCon,
|
|
bool *outCmdEnabled)
|
|
{
|
|
nsCOMPtr<nsIEditor> editor = do_QueryInterface(refCon);
|
|
// test if we are at max size?
|
|
if (editor)
|
|
return editor->GetIsSelectionEditable(outCmdEnabled);
|
|
|
|
*outCmdEnabled = false;
|
|
return NS_OK;
|
|
}
|
|
|
|
|
|
NS_IMETHODIMP
|
|
nsIncreaseFontSizeCommand::DoCommand(const char *aCommandName,
|
|
nsISupports *refCon)
|
|
{
|
|
nsCOMPtr<nsIHTMLEditor> editor = do_QueryInterface(refCon);
|
|
|
|
nsresult rv = NS_OK;
|
|
if (editor)
|
|
{
|
|
rv = editor->IncreaseFontSize();
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsIncreaseFontSizeCommand::DoCommandParams(const char *aCommandName,
|
|
nsICommandParams *aParams,
|
|
nsISupports *refCon)
|
|
{
|
|
return DoCommand(aCommandName, refCon);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsIncreaseFontSizeCommand::GetCommandStateParams(const char *aCommandName,
|
|
nsICommandParams *aParams,
|
|
nsISupports *refCon)
|
|
{
|
|
bool outCmdEnabled = false;
|
|
IsCommandEnabled(aCommandName, refCon, &outCmdEnabled);
|
|
return aParams->SetBooleanValue(STATE_ENABLED,outCmdEnabled);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsDecreaseFontSizeCommand::IsCommandEnabled(const char * aCommandName,
|
|
nsISupports *refCon,
|
|
bool *outCmdEnabled)
|
|
{
|
|
nsCOMPtr<nsIEditor> editor = do_QueryInterface(refCon);
|
|
// test if we are at min size?
|
|
if (editor)
|
|
return editor->GetIsSelectionEditable(outCmdEnabled);
|
|
|
|
*outCmdEnabled = false;
|
|
return NS_OK;
|
|
}
|
|
|
|
|
|
NS_IMETHODIMP
|
|
nsDecreaseFontSizeCommand::DoCommand(const char *aCommandName,
|
|
nsISupports *refCon)
|
|
{
|
|
nsCOMPtr<nsIHTMLEditor> editor = do_QueryInterface(refCon);
|
|
|
|
nsresult rv = NS_OK;
|
|
if (editor)
|
|
{
|
|
rv = editor->DecreaseFontSize();
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsDecreaseFontSizeCommand::DoCommandParams(const char *aCommandName,
|
|
nsICommandParams *aParams,
|
|
nsISupports *refCon)
|
|
{
|
|
return DoCommand(aCommandName, refCon);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsDecreaseFontSizeCommand::GetCommandStateParams(const char *aCommandName,
|
|
nsICommandParams *aParams,
|
|
nsISupports *refCon)
|
|
{
|
|
bool outCmdEnabled = false;
|
|
IsCommandEnabled(aCommandName, refCon, &outCmdEnabled);
|
|
return aParams->SetBooleanValue(STATE_ENABLED,outCmdEnabled);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsInsertHTMLCommand::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
|
|
nsInsertHTMLCommand::DoCommand(const char *aCommandName, nsISupports *refCon)
|
|
{
|
|
// If nsInsertHTMLCommand is called with no parameters, it was probably called with
|
|
// an empty string parameter ''. In this case, it should act the same as the delete command
|
|
NS_ENSURE_ARG_POINTER(refCon);
|
|
|
|
nsCOMPtr<nsIHTMLEditor> editor = do_QueryInterface(refCon);
|
|
NS_ENSURE_TRUE(editor, NS_ERROR_NOT_IMPLEMENTED);
|
|
|
|
nsString html = EmptyString();
|
|
return editor->InsertHTML(html);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsInsertHTMLCommand::DoCommandParams(const char *aCommandName,
|
|
nsICommandParams *aParams,
|
|
nsISupports *refCon)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aParams);
|
|
NS_ENSURE_ARG_POINTER(refCon);
|
|
|
|
nsCOMPtr<nsIHTMLEditor> editor = do_QueryInterface(refCon);
|
|
NS_ENSURE_TRUE(editor, NS_ERROR_NOT_IMPLEMENTED);
|
|
|
|
// Get HTML source string to insert from command params
|
|
nsAutoString html;
|
|
nsresult rv = aParams->GetStringValue(STATE_DATA, html);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
return editor->InsertHTML(html);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsInsertHTMLCommand::GetCommandStateParams(const char *aCommandName,
|
|
nsICommandParams *aParams,
|
|
nsISupports *refCon)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aParams);
|
|
NS_ENSURE_ARG_POINTER(refCon);
|
|
|
|
bool outCmdEnabled = false;
|
|
IsCommandEnabled(aCommandName, refCon, &outCmdEnabled);
|
|
return aParams->SetBooleanValue(STATE_ENABLED, outCmdEnabled);
|
|
}
|
|
|
|
NS_IMPL_ISUPPORTS_INHERITED0(nsInsertTagCommand, nsBaseComposerCommand)
|
|
|
|
nsInsertTagCommand::nsInsertTagCommand(nsIAtom* aTagName)
|
|
: nsBaseComposerCommand()
|
|
, mTagName(aTagName)
|
|
{
|
|
MOZ_ASSERT(mTagName);
|
|
}
|
|
|
|
nsInsertTagCommand::~nsInsertTagCommand()
|
|
{
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsInsertTagCommand::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;
|
|
}
|
|
|
|
|
|
// corresponding STATE_ATTRIBUTE is: src (img) and href (a)
|
|
NS_IMETHODIMP
|
|
nsInsertTagCommand::DoCommand(const char *aCmdName, nsISupports *refCon)
|
|
{
|
|
NS_ENSURE_TRUE(mTagName == nsGkAtoms::hr, NS_ERROR_NOT_IMPLEMENTED);
|
|
|
|
nsCOMPtr<nsIHTMLEditor> editor = do_QueryInterface(refCon);
|
|
NS_ENSURE_TRUE(editor, NS_ERROR_NOT_IMPLEMENTED);
|
|
|
|
nsCOMPtr<nsIDOMElement> domElem;
|
|
nsresult rv = editor->CreateElementWithDefaults(
|
|
nsDependentAtomString(mTagName), getter_AddRefs(domElem));
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
return editor->InsertElementAtSelection(domElem, true);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsInsertTagCommand::DoCommandParams(const char *aCommandName,
|
|
nsICommandParams *aParams,
|
|
nsISupports *refCon)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(refCon);
|
|
|
|
// inserting an hr shouldn't have an parameters, just call DoCommand for that
|
|
if (mTagName == nsGkAtoms::hr) {
|
|
return DoCommand(aCommandName, refCon);
|
|
}
|
|
|
|
NS_ENSURE_ARG_POINTER(aParams);
|
|
|
|
nsCOMPtr<nsIHTMLEditor> editor = do_QueryInterface(refCon);
|
|
NS_ENSURE_TRUE(editor, NS_ERROR_NOT_IMPLEMENTED);
|
|
|
|
// do we have an href to use for creating link?
|
|
nsXPIDLCString s;
|
|
nsresult rv = aParams->GetCStringValue(STATE_ATTRIBUTE, getter_Copies(s));
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
nsAutoString attrib; attrib.AssignWithConversion(s);
|
|
|
|
if (attrib.IsEmpty())
|
|
return NS_ERROR_INVALID_ARG;
|
|
|
|
// filter out tags we don't know how to insert
|
|
nsAutoString attributeType;
|
|
if (mTagName == nsGkAtoms::a) {
|
|
attributeType.AssignLiteral("href");
|
|
} else if (mTagName == nsGkAtoms::img) {
|
|
attributeType.AssignLiteral("src");
|
|
} else {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
nsCOMPtr<nsIDOMElement> domElem;
|
|
rv = editor->CreateElementWithDefaults(nsDependentAtomString(mTagName),
|
|
getter_AddRefs(domElem));
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
rv = domElem->SetAttribute(attributeType, attrib);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
// do actual insertion
|
|
if (mTagName == nsGkAtoms::a)
|
|
return editor->InsertLinkAroundSelection(domElem);
|
|
|
|
return editor->InsertElementAtSelection(domElem, true);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsInsertTagCommand::GetCommandStateParams(const char *aCommandName,
|
|
nsICommandParams *aParams,
|
|
nsISupports *refCon)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aParams);
|
|
NS_ENSURE_ARG_POINTER(refCon);
|
|
|
|
bool outCmdEnabled = false;
|
|
IsCommandEnabled(aCommandName, refCon, &outCmdEnabled);
|
|
return aParams->SetBooleanValue(STATE_ENABLED, outCmdEnabled);
|
|
}
|
|
|
|
|
|
/****************************/
|
|
//HELPER METHODS
|
|
/****************************/
|
|
|
|
nsresult
|
|
GetListState(nsIHTMLEditor* aEditor, bool* aMixed, nsAString& aLocalName)
|
|
{
|
|
MOZ_ASSERT(aEditor);
|
|
MOZ_ASSERT(aMixed);
|
|
|
|
*aMixed = false;
|
|
aLocalName.Truncate();
|
|
|
|
bool bOL, bUL, bDL;
|
|
nsresult rv = aEditor->GetListState(aMixed, &bOL, &bUL, &bDL);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
if (*aMixed) {
|
|
return NS_OK;
|
|
}
|
|
|
|
if (bOL) {
|
|
aLocalName.AssignLiteral("ol");
|
|
} else if (bUL) {
|
|
aLocalName.AssignLiteral("ul");
|
|
} else if (bDL) {
|
|
aLocalName.AssignLiteral("dl");
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
RemoveOneProperty(nsIHTMLEditor* aEditor, const nsAString& aProp)
|
|
{
|
|
MOZ_ASSERT(aEditor);
|
|
|
|
/// XXX Hack alert! Look in nsIEditProperty.h for this
|
|
nsCOMPtr<nsIAtom> styleAtom = do_GetAtom(aProp);
|
|
NS_ENSURE_TRUE(styleAtom, NS_ERROR_OUT_OF_MEMORY);
|
|
|
|
return aEditor->RemoveInlineProperty(styleAtom, EmptyString());
|
|
}
|
|
|
|
|
|
// the name of the attribute here should be the contents of the appropriate
|
|
// tag, e.g. 'b' for bold, 'i' for italics.
|
|
nsresult
|
|
RemoveTextProperty(nsIHTMLEditor* aEditor, const nsAString& aProp)
|
|
{
|
|
MOZ_ASSERT(aEditor);
|
|
|
|
if (aProp.LowerCaseEqualsLiteral("all")) {
|
|
return aEditor->RemoveAllInlineProperties();
|
|
}
|
|
|
|
return RemoveOneProperty(aEditor, aProp);
|
|
}
|
|
|
|
// the name of the attribute here should be the contents of the appropriate
|
|
// tag, e.g. 'b' for bold, 'i' for italics.
|
|
nsresult
|
|
SetTextProperty(nsIHTMLEditor* aEditor, const nsAString& aProp)
|
|
{
|
|
MOZ_ASSERT(aEditor);
|
|
|
|
/// XXX Hack alert! Look in nsIEditProperty.h for this
|
|
nsCOMPtr<nsIAtom> styleAtom = do_GetAtom(aProp);
|
|
NS_ENSURE_TRUE(styleAtom, NS_ERROR_OUT_OF_MEMORY);
|
|
|
|
return aEditor->SetInlineProperty(styleAtom, EmptyString(), EmptyString());
|
|
}
|