void
nsMenuFrame::BuildAcceleratorText(PRBool aNotify)
{
nsAutoString accelText;
if ((GetStateBits() & NS_STATE_ACCELTEXT_IS_DERIVED) == 0) {
mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::acceltext, accelText);
if (!accelText.IsEmpty())
return;
}
// accelText is definitely empty here.
// Now we're going to compute the accelerator text, so remember that we did.
AddStateBits(NS_STATE_ACCELTEXT_IS_DERIVED);
// If anything below fails, just leave the accelerator text blank.
nsWeakFrame weakFrame(this);
mContent->UnsetAttr(kNameSpaceID_None, nsGkAtoms::acceltext, aNotify);
ENSURE_TRUE(weakFrame.IsAlive());
// See if we have a key node and use that instead.
nsAutoString keyValue;
mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::key, keyValue);
if (keyValue.IsEmpty())
return;
// Turn the document into a DOM document so we can use getElementById
nsIDocument *document = mContent->GetDocument();
if (!document)
return;
nsIContent *keyElement = document->GetElementById(keyValue);
if (!keyElement) {
#ifdef DEBUG
nsAutoString label;
mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::label, label);
nsAutoString msg = NS_LITERAL_STRING("Key '") +
keyValue +
NS_LITERAL_STRING("' of menu item '") +
label +
NS_LITERAL_STRING("' could not be found");
NS_WARNING(NS_ConvertUTF16toUTF8(msg).get());
#endif
return;
}
// get the string to display as accelerator text
// check the key element's attributes in this order:
// |keytext|, |key|, |keycode|
nsAutoString accelString;
keyElement->GetAttr(kNameSpaceID_None, nsGkAtoms::keytext, accelString);
if (accelString.IsEmpty()) {
keyElement->GetAttr(kNameSpaceID_None, nsGkAtoms::key, accelString);
if (!accelString.IsEmpty()) {
ToUpperCase(accelString);
} else {
nsAutoString keyCode;
keyElement->GetAttr(kNameSpaceID_None, nsGkAtoms::keycode, keyCode);
ToUpperCase(keyCode);
nsresult rv;
nsCOMPtr<nsIStringBundleService> bundleService =
mozilla::services::GetStringBundleService();
if (bundleService) {
nsCOMPtr<nsIStringBundle> bundle;
rv = bundleService->CreateBundle("chrome://global/locale/keys.properties",
getter_AddRefs(bundle));
if (NS_SUCCEEDED(rv) && bundle) {
nsXPIDLString keyName;
rv = bundle->GetStringFromName(keyCode.get(), getter_Copies(keyName));
if (keyName)
accelString = keyName;
}
}
// nothing usable found, bail
if (accelString.IsEmpty())
return;
}
}
static PRInt32 accelKey = 0;
if (!accelKey)
{
// Compiled-in defaults, in case we can't get LookAndFeel --
// command for mac, control for all other platforms.
#ifdef XP_MACOSX
accelKey = nsIDOMKeyEvent::DOM_VK_META;
#else
accelKey = nsIDOMKeyEvent::DOM_VK_CONTROL;
#endif
// Get the accelerator key value from prefs, overriding the default:
accelKey = nsContentUtils::GetIntPref("ui.key.accelKey", accelKey);
}
nsAutoString modifiers;
keyElement->GetAttr(kNameSpaceID_None, nsGkAtoms::modifiers, modifiers);
char* str = ToNewCString(modifiers);
char* newStr;
char* token = nsCRT::strtok(str, ", \t", &newStr);
while (token) {
if (PL_strcmp(token, "shift") == 0)
accelText += *gShiftText;
else if (PL_strcmp(token, "alt") == 0)
accelText += *gAltText;
else if (PL_strcmp(token, "meta") == 0)
accelText += *gMetaText;
else if (PL_strcmp(token, "control") == 0)
accelText += *gControlText;
else if (PL_strcmp(token, "accel") == 0) {
switch (accelKey)
{
case nsIDOMKeyEvent::DOM_VK_META:
accelText += *gMetaText;
break;
case nsIDOMKeyEvent::DOM_VK_ALT:
accelText += *gAltText;
break;
case nsIDOMKeyEvent::DOM_VK_CONTROL:
default:
accelText += *gControlText;
break;
}
}
accelText += *gModifierSeparator;
token = nsCRT::strtok(newStr, ", \t", &newStr);
}
nsMemory::Free(str);
accelText += accelString;
mIgnoreAccelTextChange = PR_TRUE;
mContent->SetAttr(kNameSpaceID_None, nsGkAtoms::acceltext, accelText, aNotify);
ENSURE_TRUE(weakFrame.IsAlive());
mIgnoreAccelTextChange = PR_FALSE;
}
//
// IsInternetShortcut
//
// A file is an Internet Shortcut if it ends with .URL
//
PRBool
nsClipboard :: IsInternetShortcut ( const nsAString& inFileName )
{
return StringEndsWith(inFileName, NS_LITERAL_STRING(".url"), nsCaseInsensitiveStringComparator());
} // IsInternetShortcut
nsresult
DOMImplementation::CreateHTMLDocument(const nsAString& aTitle,
nsIDocument** aDocument,
nsIDOMDocument** aDOMDocument)
{
*aDocument = nullptr;
*aDOMDocument = nullptr;
NS_ENSURE_STATE(mOwner);
nsCOMPtr<nsIDOMDocumentType> doctype;
// Indicate that there is no internal subset (not just an empty one)
nsresult rv = NS_NewDOMDocumentType(getter_AddRefs(doctype),
mOwner->NodeInfoManager(),
nsGkAtoms::html, // aName
EmptyString(), // aPublicId
EmptyString(), // aSystemId
NullString()); // aInternalSubset
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIGlobalObject> scriptHandlingObject =
do_QueryReferent(mScriptObject);
NS_ENSURE_STATE(!mScriptObject || scriptHandlingObject);
nsCOMPtr<nsIDOMDocument> document;
rv = NS_NewDOMDocument(getter_AddRefs(document),
EmptyString(), EmptyString(),
doctype, mDocumentURI, mBaseURI,
mOwner->NodePrincipal(),
true, scriptHandlingObject,
DocumentFlavorLegacyGuess);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIDocument> doc = do_QueryInterface(document);
nsCOMPtr<Element> root = doc->CreateElem(NS_LITERAL_STRING("html"), nullptr,
kNameSpaceID_XHTML);
rv = doc->AppendChildTo(root, false);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<Element> head = doc->CreateElem(NS_LITERAL_STRING("head"), nullptr,
kNameSpaceID_XHTML);
rv = root->AppendChildTo(head, false);
NS_ENSURE_SUCCESS(rv, rv);
if (!DOMStringIsNull(aTitle)) {
nsCOMPtr<Element> title = doc->CreateElem(NS_LITERAL_STRING("title"),
nullptr, kNameSpaceID_XHTML);
rv = head->AppendChildTo(title, false);
NS_ENSURE_SUCCESS(rv, rv);
RefPtr<nsTextNode> titleText = new nsTextNode(doc->NodeInfoManager());
rv = titleText->SetText(aTitle, false);
NS_ENSURE_SUCCESS(rv, rv);
rv = title->AppendChildTo(titleText, false);
NS_ENSURE_SUCCESS(rv, rv);
}
nsCOMPtr<Element> body = doc->CreateElem(NS_LITERAL_STRING("body"), nullptr,
kNameSpaceID_XHTML);
rv = root->AppendChildTo(body, false);
NS_ENSURE_SUCCESS(rv, rv);
// When the createHTMLDocument method is invoked,
// use the registry of the associated document to the new instance.
doc->UseRegistryFromDocument(mOwner);
doc->SetReadyStateInternal(nsIDocument::READYSTATE_COMPLETE);
doc.forget(aDocument);
document.forget(aDOMDocument);
return NS_OK;
}
NS_IMETHODIMP
nsHTMLContentSerializer::AppendElementStart(nsIDOMElement *aElement,
nsIDOMElement *aOriginalElement,
nsAString& aStr)
{
NS_ENSURE_ARG(aElement);
nsCOMPtr<nsIContent> content = do_QueryInterface(aElement);
if (!content) return NS_ERROR_FAILURE;
// The _moz_dirty attribute is emitted by the editor to
// indicate that this element should be pretty printed
// even if we're not in pretty printing mode
PRBool hasDirtyAttr = content->HasAttr(kNameSpaceID_None,
nsGkAtoms::mozdirty);
nsIAtom *name = content->Tag();
if (name == nsGkAtoms::br && mPreLevel > 0
&& (mFlags & nsIDocumentEncoder::OutputNoFormattingInPre)) {
AppendToString(mLineBreak, aStr);
mMayIgnoreLineBreakSequence = PR_TRUE;
mColPos = 0;
return NS_OK;
}
if (name == nsGkAtoms::body) {
mInBody = PR_TRUE;
}
if (LineBreakBeforeOpen(name, hasDirtyAttr)) {
AppendToString(mLineBreak, aStr);
mMayIgnoreLineBreakSequence = PR_TRUE;
mColPos = 0;
mAddSpace = PR_FALSE;
}
else if (mAddSpace) {
AppendToString(PRUnichar(' '), aStr);
mAddSpace = PR_FALSE;
}
else {
MaybeAddNewline(aStr);
}
// Always reset to avoid false newlines in case MaybeAddNewline wasn't
// called
mAddNewline = PR_FALSE;
StartIndentation(name, hasDirtyAttr, aStr);
if (name == nsGkAtoms::pre ||
name == nsGkAtoms::script ||
name == nsGkAtoms::style) {
mPreLevel++;
}
AppendToString(kLessThan, aStr);
nsAutoString nameStr;
name->ToString(nameStr);
AppendToString(nameStr.get(), -1, aStr);
// Need to keep track of OL and LI elements in order to get ordinal number
// for the LI.
if (mIsCopying && name == nsGkAtoms::ol) {
// We are copying and current node is an OL;
// Store it's start attribute value in olState->startVal.
nsAutoString start;
PRInt32 startAttrVal = 0;
aElement->GetAttribute(NS_LITERAL_STRING("start"), start);
if (!start.IsEmpty()) {
PRInt32 rv = 0;
startAttrVal = start.ToInteger(&rv);
//If OL has "start" attribute, first LI element has to start with that value
//Therefore subtracting 1 as all the LI elements are incrementing it before using it;
//In failure of ToInteger(), default StartAttrValue to 0.
if (NS_SUCCEEDED(rv))
startAttrVal--;
else
startAttrVal = 0;
}
olState* state = new olState(startAttrVal, PR_TRUE);
if (state)
mOLStateStack.AppendElement(state);
}
if (mIsCopying && name == nsGkAtoms::li) {
mIsFirstChildOfOL = IsFirstChildOfOL(aOriginalElement);
if (mIsFirstChildOfOL) {
// If OL is parent of this LI, serialize attributes in different manner.
SerializeLIValueAttribute(aElement, aStr);
}
}
// Even LI passed above have to go through this
// for serializing attributes other than "value".
SerializeAttributes(content, name, aStr);
AppendToString(kGreaterThan, aStr);
if (LineBreakAfterOpen(name, hasDirtyAttr)) {
AppendToString(mLineBreak, aStr);
mMayIgnoreLineBreakSequence = PR_TRUE;
mColPos = 0;
}
if (name == nsGkAtoms::script ||
name == nsGkAtoms::style ||
name == nsGkAtoms::noscript ||
name == nsGkAtoms::noframes) {
mInCDATA = PR_TRUE;
}
if (mIsWholeDocument && name == nsGkAtoms::head) {
// Check if there already are any content-type meta children.
// If there are, they will be modified to use the correct charset.
// If there aren't, we'll insert one here.
PRBool hasMeta = PR_FALSE;
PRUint32 i, childCount = content->GetChildCount();
for (i = 0; i < childCount; ++i) {
nsIContent* child = content->GetChildAt(i);
if (child->IsNodeOfType(nsINode::eHTML) &&
child->Tag() == nsGkAtoms::meta &&
child->HasAttr(kNameSpaceID_None, nsGkAtoms::content)) {
nsAutoString header;
child->GetAttr(kNameSpaceID_None, nsGkAtoms::httpEquiv, header);
if (header.LowerCaseEqualsLiteral("content-type")) {
hasMeta = PR_TRUE;
break;
}
}
}
if (!hasMeta) {
AppendToString(mLineBreak, aStr);
AppendToString(NS_LITERAL_STRING("<meta http-equiv=\"content-type\""),
aStr);
AppendToString(NS_LITERAL_STRING(" content=\"text/html; charset="), aStr);
AppendToString(NS_ConvertASCIItoUTF16(mCharset), aStr);
AppendToString(NS_LITERAL_STRING("\">"), aStr);
}
}
return NS_OK;
}
NS_IMETHODIMP nsPop3IncomingServer::SetDeferredToAccount(const nsACString& aAccountKey)
{
nsCString deferredToAccount;
GetDeferredToAccount(deferredToAccount);
m_rootMsgFolder = nullptr; // clear this so we'll recalculate it on demand.
//Notify listeners who listen to every folder
nsresult rv = SetCharValue("deferred_to_account", aAccountKey);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIFolderListener> folderListenerManager =
do_GetService(NS_MSGMAILSESSION_CONTRACTID, &rv);
if (NS_SUCCEEDED(rv))
{
nsCOMPtr<nsIMsgFolder> rootFolder;
// use GetRootFolder, because that returns the real
// root, not the deferred to root.
rv = GetRootFolder(getter_AddRefs(rootFolder));
if (rootFolder)
{
// if isDeferred state has changed, send notification
if (aAccountKey.IsEmpty() != deferredToAccount.IsEmpty())
{
nsCOMPtr <nsIAtom> deferAtom = MsgGetAtom("isDeferred");
nsCOMPtr <nsIAtom> canFileAtom = MsgGetAtom("CanFileMessages");
folderListenerManager->OnItemBoolPropertyChanged(rootFolder, deferAtom,
!deferredToAccount.IsEmpty(), deferredToAccount.IsEmpty());
folderListenerManager->OnItemBoolPropertyChanged(rootFolder, canFileAtom,
deferredToAccount.IsEmpty(), !deferredToAccount.IsEmpty());
// this hack causes the account manager ds to send notifications to the
// xul content builder that make the changed acct appear or disappear
// from the folder pane and related menus.
nsCOMPtr<nsIMsgAccountManager> acctMgr =
do_GetService(NS_MSGACCOUNTMANAGER_CONTRACTID);
if (acctMgr)
{
acctMgr->NotifyServerUnloaded(this);
acctMgr->NotifyServerLoaded(this);
// check if this newly deferred to account is the local folders account
// and needs to have a newly created INBOX.
if (!aAccountKey.IsEmpty())
{
nsCOMPtr <nsIMsgAccount> account;
acctMgr->GetAccount(aAccountKey, getter_AddRefs(account));
if (account)
{
nsCOMPtr <nsIMsgIncomingServer> server;
account->GetIncomingServer(getter_AddRefs(server));
if (server)
{
nsCOMPtr <nsILocalMailIncomingServer> incomingLocalServer = do_QueryInterface(server);
if (incomingLocalServer)
{
nsCOMPtr <nsIMsgFolder> rootFolder;
rv = server->GetRootFolder(getter_AddRefs(rootFolder));
NS_ENSURE_SUCCESS(rv, rv);
// this will fail if it already exists, which is fine.
rootFolder->CreateSubfolder(NS_LITERAL_STRING("Inbox"), nullptr);
}
}
}
}
}
}
}
}
return rv;
}
nsresult
nsNNTPNewsgroupList::GetRangeOfArtsToDownload(nsIMsgWindow *aMsgWindow,
int32_t first_possible,
int32_t last_possible,
int32_t maxextra,
int32_t *first,
int32_t *last,
int32_t *status)
{
nsresult rv = NS_OK;
NS_ENSURE_ARG_POINTER(first);
NS_ENSURE_ARG_POINTER(last);
NS_ENSURE_ARG_POINTER(status);
*first = 0;
*last = 0;
nsCOMPtr <nsIMsgFolder> folder = do_QueryInterface(m_newsFolder, &rv);
NS_ENSURE_SUCCESS(rv,rv);
m_msgWindow = aMsgWindow;
nsCOMPtr<nsINewsDatabase> db(do_QueryInterface(m_newsDB, &rv));
NS_ENSURE_SUCCESS(rv,rv);
rv = db->GetReadSet(&m_set);
if (NS_FAILED(rv) || !m_set)
return rv;
m_set->SetLastMember(last_possible); // make sure highwater mark is valid.
nsCOMPtr <nsIDBFolderInfo> newsGroupInfo;
rv = m_newsDB->GetDBFolderInfo(getter_AddRefs(newsGroupInfo));
if (NS_SUCCEEDED(rv) && newsGroupInfo) {
nsCString knownArtsString;
nsMsgKey mark;
newsGroupInfo->GetKnownArtsSet(getter_Copies(knownArtsString));
rv = newsGroupInfo->GetHighWater(&mark);
NS_ENSURE_SUCCESS(rv,rv);
if (last_possible < ((int32_t)mark))
newsGroupInfo->SetHighWater(last_possible);
if (m_knownArts.set)
delete m_knownArts.set;
m_knownArts.set = nsMsgKeySet::Create(knownArtsString.get());
}
else
{
if (m_knownArts.set)
delete m_knownArts.set;
m_knownArts.set = nsMsgKeySet::Create();
nsMsgKey low, high;
rv = m_newsDB->GetLowWaterArticleNum(&low);
NS_ENSURE_SUCCESS(rv,rv);
rv = m_newsDB->GetHighWaterArticleNum(&high);
NS_ENSURE_SUCCESS(rv,rv);
m_knownArts.set->AddRange(low,high);
}
if (m_knownArts.set->IsMember(last_possible)) {
nsString statusString;
nsCOMPtr<nsIStringBundleService> bundleService =
mozilla::services::GetStringBundleService();
NS_ENSURE_TRUE(bundleService, NS_ERROR_UNEXPECTED);
nsCOMPtr<nsIStringBundle> bundle;
rv = bundleService->CreateBundle(NEWS_MSGS_URL, getter_AddRefs(bundle));
NS_ENSURE_SUCCESS(rv, rv);
rv = bundle->GetStringFromName(NS_LITERAL_STRING("noNewMessages").get(), getter_Copies(statusString));
NS_ENSURE_SUCCESS(rv, rv);
SetProgressStatus(statusString.get());
}
if (maxextra <= 0 || last_possible < first_possible || last_possible < 1)
{
*status=0;
return NS_OK;
}
m_knownArts.first_possible = first_possible;
m_knownArts.last_possible = last_possible;
nsCOMPtr <nsIMsgIncomingServer> server;
rv = folder->GetServer(getter_AddRefs(server));
NS_ENSURE_SUCCESS(rv,rv);
nsCOMPtr<nsINntpIncomingServer> nntpServer = do_QueryInterface(server, &rv);
NS_ENSURE_SUCCESS(rv,rv);
/* Determine if we only want to get just new articles or more messages.
If there are new articles at the end we haven't seen, we always want to get those first.
Otherwise, we get the newest articles we haven't gotten, if we're getting more.
My thought for now is that opening a newsgroup should only try to get new articles.
Selecting "More Messages" will first try to get unseen messages, then old messages. */
if (m_getOldMessages || !m_knownArts.set->IsMember(last_possible))
{
bool notifyMaxExceededOn = true;
rv = nntpServer->GetNotifyOn(¬ifyMaxExceededOn);
if (NS_FAILED(rv)) notifyMaxExceededOn = true;
// if the preference to notify when downloading more than x headers is not on,
// and we're downloading new headers, set maxextra to a very large number.
if (!m_getOldMessages && !notifyMaxExceededOn)
maxextra = 0x7FFFFFFFL;
int result =
m_knownArts.set->LastMissingRange(first_possible, last_possible,
first, last);
if (result < 0) {
*status=result;
return NS_ERROR_NOT_INITIALIZED;
}
if (*first > 0 && *last - *first >= maxextra)
{
if (!m_getOldMessages && !m_promptedAlready && notifyMaxExceededOn)
{
m_downloadAll = false;
nsCOMPtr<nsINewsDownloadDialogArgs> args = do_CreateInstance("@mozilla.org/messenger/newsdownloaddialogargs;1", &rv);
if (NS_FAILED(rv)) return rv;
NS_ENSURE_SUCCESS(rv,rv);
rv = args->SetArticleCount(*last - *first + 1);
NS_ENSURE_SUCCESS(rv,rv);
nsString groupName;
rv = m_newsFolder->GetUnicodeName(groupName);
NS_ENSURE_SUCCESS(rv,rv);
rv = args->SetGroupName(groupName);
NS_ENSURE_SUCCESS(rv,rv);
// get the server key
nsCString serverKey;
rv = server->GetKey(serverKey);
NS_ENSURE_SUCCESS(rv,rv);
rv = args->SetServerKey(serverKey.get());
NS_ENSURE_SUCCESS(rv,rv);
// we many not have a msgWindow if we are running an autosubscribe url from the browser
// and there isn't a 3 pane open.
//
// if we don't have one, bad things will happen when we fail to open up the "download headers dialog"
// (we will subscribe to the newsgroup, but it will appear like there are no messages!)
//
// for now, act like the "download headers dialog" came up, and the user hit cancel. (very safe)
//
// TODO, figure out why we aren't opening and using a 3 pane when the autosubscribe url is run.
// perhaps we can find an available 3 pane, and use it.
bool download = false;
if (aMsgWindow) {
rv = openWindow(aMsgWindow, DOWNLOAD_HEADERS_URL, args);
NS_ENSURE_SUCCESS(rv,rv);
rv = args->GetHitOK(&download);
NS_ENSURE_SUCCESS(rv,rv);
}
if (download) {
rv = args->GetDownloadAll(&m_downloadAll);
NS_ENSURE_SUCCESS(rv,rv);
m_maxArticles = 0;
rv = nntpServer->GetMaxArticles(&m_maxArticles);
NS_ENSURE_SUCCESS(rv,rv);
maxextra = m_maxArticles;
if (!m_downloadAll)
{
bool markOldRead = false;
rv = nntpServer->GetMarkOldRead(&markOldRead);
if (NS_FAILED(rv)) markOldRead = false;
if (markOldRead && m_set)
m_set->AddRange(*first, *last - maxextra);
*first = *last - maxextra + 1;
}
}
else
*first = *last = 0;
m_promptedAlready = true;
}
else if (m_promptedAlready && !m_downloadAll)
*first = *last - m_maxArticles + 1;
else if (!m_downloadAll)
*first = *last - maxextra + 1;
}
}
m_firstMsgToDownload = *first;
m_lastMsgToDownload = *last;
*status=0;
return NS_OK;
}
void
nsHTMLContentSerializer::SerializeLIValueAttribute(nsIDOMElement* aElement,
nsAString& aStr)
{
// We are copying and we are at the "first" LI node of OL in selected range.
// It may not be the first LI child of OL but it's first in the selected range.
// Note that we get into this condition only once per a OL.
PRBool found = PR_FALSE;
nsCOMPtr<nsIDOMNode> currNode = do_QueryInterface(aElement);
nsAutoString valueStr;
PRInt32 offset = 0;
olState defaultOLState(0, PR_FALSE);
olState* state = nsnull;
if (mOLStateStack.Count() > 0)
state = (olState*)mOLStateStack.ElementAt(mOLStateStack.Count()-1);
/* Though we should never reach to a "state" as null or mOLStateStack.Count() == 0
at this point as all LI are supposed to be inside some OL and OL tag should have
pushed a state to the olStateStack.*/
if (!state || mOLStateStack.Count() == 0)
state = &defaultOLState;
PRInt32 startVal = state->startVal;
state->isFirstListItem = PR_FALSE;
// Traverse previous siblings until we find one with "value" attribute.
// offset keeps track of how many previous siblings we had tocurrNode traverse.
while (currNode && !found) {
nsCOMPtr<nsIDOMElement> currElement = do_QueryInterface(currNode);
// currElement may be null if it were a text node.
if (currElement) {
nsAutoString tagName;
currElement->GetTagName(tagName);
if (tagName.LowerCaseEqualsLiteral("li")) {
currElement->GetAttribute(NS_LITERAL_STRING("value"), valueStr);
if (valueStr.IsEmpty())
offset++;
else {
found = PR_TRUE;
PRInt32 rv = 0;
startVal = valueStr.ToInteger(&rv);
}
}
}
nsCOMPtr<nsIDOMNode> tmp;
currNode->GetPreviousSibling(getter_AddRefs(tmp));
currNode.swap(tmp);
}
// If LI was not having "value", Set the "value" attribute for it.
// Note that We are at the first LI in the selected range of OL.
if (offset == 0 && found) {
// offset = 0 => LI itself has the value attribute and we did not need to traverse back.
// Just serialize value attribute like other tags.
SerializeAttr(EmptyString(), NS_LITERAL_STRING("value"), valueStr, aStr, PR_FALSE);
}
else if (offset == 1 && !found) {
/*(offset = 1 && !found) means either LI is the first child node of OL
and LI is not having "value" attribute.
In that case we would not like to set "value" attribute to reduce the changes.
*/
//do nothing...
}
else if (offset > 0) {
// Set value attribute.
nsAutoString valueStr;
//As serializer needs to use this valueAttr we are creating here,
valueStr.AppendInt(startVal + offset);
SerializeAttr(EmptyString(), NS_LITERAL_STRING("value"), valueStr, aStr, PR_FALSE);
}
}
NS_IMETHODIMP
nsDOMOfflineResourceList::SetOncached(nsIDOMEventListener *aOncached)
{
return RemoveAddEventListener(NS_LITERAL_STRING(CACHED_STR),
mOnCachedListener, aOncached);
}
NS_IMETHODIMP
nsDOMOfflineResourceList::SetOnupdateready(nsIDOMEventListener *aOnupdateready)
{
return RemoveAddEventListener(NS_LITERAL_STRING(UPDATEREADY_STR),
mOnUpdateReadyListener, aOnupdateready);
}
NS_IMETHODIMP
nsDOMOfflineResourceList::SetOndownloading(nsIDOMEventListener *aOndownloading)
{
return RemoveAddEventListener(NS_LITERAL_STRING(DOWNLOADING_STR),
mOnDownloadingListener, aOndownloading);
}
NS_IMETHODIMP
nsDOMOfflineResourceList::SetOnprogress(nsIDOMEventListener *aOnprogress)
{
return RemoveAddEventListener(NS_LITERAL_STRING(PROGRESS_STR),
mOnProgressListener, aOnprogress);
}
NS_IMETHODIMP
nsDOMOfflineResourceList::SetOnnoupdate(nsIDOMEventListener *aOnnoupdate)
{
return RemoveAddEventListener(NS_LITERAL_STRING(NOUPDATE_STR),
mOnNoUpdateListener, aOnnoupdate);
}
NS_IMETHODIMP
nsDOMOfflineResourceList::SetOnerror(nsIDOMEventListener *aOnerror)
{
return RemoveAddEventListener(NS_LITERAL_STRING(ERROR_STR), mOnErrorListener,
aOnerror);
}
NS_IMETHODIMP
nsDOMOfflineResourceList::SetOnchecking(nsIDOMEventListener *aOnchecking)
{
return RemoveAddEventListener(NS_LITERAL_STRING(CHECKING_STR),
mOnCheckingListener, aOnchecking);
}
nsresult
CryptoKey::PrivateKeyToJwk(SECKEYPrivateKey* aPrivKey,
JsonWebKey& aRetVal,
const nsNSSShutDownPreventionLock& /*proofOfLock*/)
{
switch (aPrivKey->keyType) {
case rsaKey: {
aRetVal.mN.Construct();
aRetVal.mE.Construct();
aRetVal.mD.Construct();
aRetVal.mP.Construct();
aRetVal.mQ.Construct();
aRetVal.mDp.Construct();
aRetVal.mDq.Construct();
aRetVal.mQi.Construct();
if (!ReadAndEncodeAttribute(aPrivKey, CKA_MODULUS, aRetVal.mN) ||
!ReadAndEncodeAttribute(aPrivKey, CKA_PUBLIC_EXPONENT, aRetVal.mE) ||
!ReadAndEncodeAttribute(aPrivKey, CKA_PRIVATE_EXPONENT, aRetVal.mD) ||
!ReadAndEncodeAttribute(aPrivKey, CKA_PRIME_1, aRetVal.mP) ||
!ReadAndEncodeAttribute(aPrivKey, CKA_PRIME_2, aRetVal.mQ) ||
!ReadAndEncodeAttribute(aPrivKey, CKA_EXPONENT_1, aRetVal.mDp) ||
!ReadAndEncodeAttribute(aPrivKey, CKA_EXPONENT_2, aRetVal.mDq) ||
!ReadAndEncodeAttribute(aPrivKey, CKA_COEFFICIENT, aRetVal.mQi)) {
return NS_ERROR_DOM_OPERATION_ERR;
}
aRetVal.mKty.Construct(NS_LITERAL_STRING(JWK_TYPE_RSA));
return NS_OK;
}
case ecKey: {
// Read EC params.
ScopedSECItem params(::SECITEM_AllocItem(nullptr, nullptr, 0));
SECStatus rv = PK11_ReadRawAttribute(PK11_TypePrivKey, aPrivKey,
CKA_EC_PARAMS, params);
if (rv != SECSuccess) {
return NS_ERROR_DOM_OPERATION_ERR;
}
// Read public point Q.
ScopedSECItem ecPoint(::SECITEM_AllocItem(nullptr, nullptr, 0));
rv = PK11_ReadRawAttribute(PK11_TypePrivKey, aPrivKey, CKA_EC_POINT,
ecPoint);
if (rv != SECSuccess) {
return NS_ERROR_DOM_OPERATION_ERR;
}
if (!ECKeyToJwk(PK11_TypePrivKey, aPrivKey, params, ecPoint, aRetVal)) {
return NS_ERROR_DOM_OPERATION_ERR;
}
aRetVal.mD.Construct();
// Read private value.
if (!ReadAndEncodeAttribute(aPrivKey, CKA_VALUE, aRetVal.mD)) {
return NS_ERROR_DOM_OPERATION_ERR;
}
return NS_OK;
}
default:
return NS_ERROR_DOM_NOT_SUPPORTED_ERR;
}
}
NS_IMETHODIMP
nsDOMOfflineResourceList::SetOnobsolete(nsIDOMEventListener *aOnobsolete)
{
return RemoveAddEventListener(NS_LITERAL_STRING(OBSOLETE_STR),
mOnObsoleteListener, aOnobsolete);
}
NS_IMETHODIMP
nsXFormsItemSetElement::Refresh()
{
// We need to create item elements for each element referenced by the
// nodeset. Each of these items will create an anonymous HTML option element
// which will return from GetAnonymousNodes. We then clone our template
// content and insert the cloned content as children of the HTML option.
if (!nsXFormsUtils::IsDocumentReadyForBind(mElement)) {
// not ready to bind yet, defer
nsXFormsModelElement::DeferElementBind(this);
return NS_OK;
}
nsCOMPtr<nsIModelElementPrivate> model;
nsCOMPtr<nsIDOMXPathResult> result;
nsresult rv = ProcessNodeBinding(NS_LITERAL_STRING("nodeset"),
nsIDOMXPathResult::ORDERED_NODE_SNAPSHOT_TYPE,
getter_AddRefs(result),
getter_AddRefs(model));
if (NS_FAILED(rv) | !result | !model)
return rv;
nsCOMPtr<nsIDOMNode> node, templateNode, cloneNode, tmpNode;
nsCOMPtr<nsIDOMElement> itemNode, itemWrapperNode, contextContainer;
nsCOMPtr<nsIDOMNodeList> templateNodes;
mElement->GetChildNodes(getter_AddRefs(templateNodes));
PRUint32 templateNodeCount = 0;
if (templateNodes)
templateNodes->GetLength(&templateNodeCount);
nsCOMPtr<nsIContent> content(do_QueryInterface(mElement));
NS_ENSURE_STATE(content);
nsCOMPtr<nsIDocument> doc = content->GetCurrentDoc();
nsCOMPtr<nsIDOMDocument> domDoc(do_QueryInterface(doc));
NS_ENSURE_STATE(domDoc);
PRUint32 nodeCount;
result->GetSnapshotLength(&nodeCount);
nsCOMPtr<nsIDOMNode> parent, tmp;
mElement->GetParentNode(getter_AddRefs(parent));
while (parent) {
if (nsXFormsUtils::IsXFormsElement(parent, NS_LITERAL_STRING("select1")) ||
nsXFormsUtils::IsXFormsElement(parent, NS_LITERAL_STRING("select"))) {
break;
}
tmp.swap(parent);
tmp->GetParentNode(getter_AddRefs(parent));
}
nsCOMPtr<nsIXFormsItemSetUIElement> uiItemSet(do_QueryInterface(mElement));
nsCOMPtr<nsIDOMElement> anonContent;
if (uiItemSet) {
uiItemSet->GetAnonymousItemSetContent(getter_AddRefs(anonContent));
}
NS_ENSURE_STATE(anonContent);
nsCOMPtr<nsIDOMNode> childNode, nodeReturn;
while (NS_SUCCEEDED(anonContent->GetFirstChild(getter_AddRefs(childNode))) &&
childNode) {
anonContent->RemoveChild(childNode, getter_AddRefs(nodeReturn));
}
for (PRUint32 i = 0; i < nodeCount; ++i) {
result->SnapshotItem(i, getter_AddRefs(node));
NS_ASSERTION(node, "incorrect snapshot length");
rv = domDoc->CreateElementNS(NS_LITERAL_STRING(NS_NAMESPACE_XFORMS),
NS_LITERAL_STRING("item"),
getter_AddRefs(itemNode));
NS_ENSURE_SUCCESS(rv, rv);
anonContent->AppendChild(itemNode, getter_AddRefs(tmpNode));
nsCOMPtr<nsIXFormsContextControl> ctx(do_QueryInterface(itemNode));
if (ctx) {
ctx->SetContext(node, i + 1, nodeCount);
}
// Clone the template content under the item
for (PRUint32 j = 0; j < templateNodeCount; ++j) {
templateNodes->Item(j, getter_AddRefs(templateNode));
templateNode->CloneNode(PR_TRUE, getter_AddRefs(cloneNode));
itemNode->AppendChild(cloneNode, getter_AddRefs(templateNode));
}
}
// refresh parent so that it has a chance to reflect the changes we just made
if (parent) {
nsCOMPtr<nsIXFormsControlBase> control = do_QueryInterface(parent);
if (control) {
control->Refresh();
}
}
return NS_OK;
}
nsresult
nsIconChannel::InitWithGnome(nsIMozIconURI *aIconURI)
{
nsresult rv;
if (NS_FAILED(ensure_libgnomeui()) || NS_FAILED(ensure_libgnome()) || NS_FAILED(ensure_libgnomevfs())) {
gTriedToLoadGnomeLibs = true;
return NS_ERROR_NOT_AVAILABLE;
}
gTriedToLoadGnomeLibs = true;
if (!_gnome_program_get()) {
// Get the brandShortName from the string bundle to pass to GNOME
// as the application name. This may be used for things such as
// the title of grouped windows in the panel.
nsCOMPtr<nsIStringBundleService> bundleService =
do_GetService(NS_STRINGBUNDLE_CONTRACTID);
NS_ASSERTION(bundleService, "String bundle service must be present!");
nsCOMPtr<nsIStringBundle> bundle;
bundleService->CreateBundle("chrome://branding/locale/brand.properties",
getter_AddRefs(bundle));
nsAutoString appName;
if (bundle) {
bundle->GetStringFromName(NS_LITERAL_STRING("brandShortName").get(),
getter_Copies(appName));
} else {
NS_WARNING("brand.properties not present, using default application name");
appName.Assign(NS_LITERAL_STRING("Gecko"));
}
char* empty[] = { "" };
_gnome_init(NS_ConvertUTF16toUTF8(appName).get(), "1.0", 1, empty, NULL, 0, NULL);
}
uint32_t iconSize = GetIconSize(aIconURI);
nsCAutoString type;
aIconURI->GetContentType(type);
GnomeVFSFileInfo fileInfo = {0};
fileInfo.refcount = 1; // In case some GnomeVFS function addrefs and releases it
nsCAutoString spec;
nsCOMPtr<nsIURL> url;
rv = aIconURI->GetIconURL(getter_AddRefs(url));
if (url) {
url->GetAsciiSpec(spec);
// Only ask gnome-vfs for a GnomeVFSFileInfo for file: uris, to avoid a
// network request
bool isFile;
if (NS_SUCCEEDED(url->SchemeIs("file", &isFile)) && isFile) {
_gnome_vfs_get_file_info(spec.get(), &fileInfo, GNOME_VFS_FILE_INFO_DEFAULT);
}
else {
// The filename we get is UTF-8-compatible, which matches gnome expectations.
// See also: http://lists.gnome.org/archives/gnome-vfs-list/2004-March/msg00049.html
// "Whenever we can detect the charset used for the URI type we try to
// convert it to/from utf8 automatically inside gnome-vfs."
// I'll interpret that as "otherwise, this field is random junk".
nsCAutoString name;
url->GetFileName(name);
fileInfo.name = g_strdup(name.get());
if (!type.IsEmpty()) {
fileInfo.valid_fields = GNOME_VFS_FILE_INFO_FIELDS_MIME_TYPE;
fileInfo.mime_type = g_strdup(type.get());
}
}
}
if (type.IsEmpty()) {
nsCOMPtr<nsIMIMEService> ms(do_GetService("@mozilla.org/mime;1"));
if (ms) {
nsCAutoString fileExt;
aIconURI->GetFileExtension(fileExt);
if (!fileExt.IsEmpty()) {
ms->GetTypeFromExtension(fileExt, type);
}
}
}
// Get the icon theme
if (!gIconTheme) {
gIconTheme = _gnome_icon_theme_new();
if (!gIconTheme) {
_gnome_vfs_file_info_clear(&fileInfo);
return NS_ERROR_NOT_AVAILABLE;
}
}
char* name = _gnome_icon_lookup(gIconTheme, NULL, spec.get(), NULL, &fileInfo,
type.get(), GNOME_ICON_LOOKUP_FLAGS_NONE,
NULL);
_gnome_vfs_file_info_clear(&fileInfo);
if (!name)
return NS_ERROR_NOT_AVAILABLE;
// Get the default theme associated with the screen
// Do NOT free.
GtkIconTheme *theme = gtk_icon_theme_get_default();
if (!theme) {
g_free(name);
return NS_ERROR_UNEXPECTED;
}
GError *err = nullptr;
GdkPixbuf* buf = gtk_icon_theme_load_icon(theme, name, iconSize, (GtkIconLookupFlags)0, &err);
g_free(name);
if (!buf) {
if (err)
g_error_free(err);
return NS_ERROR_UNEXPECTED;
}
rv = ScaleIconBuf(&buf, iconSize);
NS_ENSURE_SUCCESS(rv, rv);
rv = moz_gdk_pixbuf_to_channel(buf, aIconURI,
getter_AddRefs(mRealChannel));
g_object_unref(buf);
return rv;
}
nsresult
nsNNTPNewsgroupList::FinishXOVERLINE(int status, int *newstatus)
{
nsresult rv;
struct MSG_NewsKnown* k;
/* If any XOVER lines from the last time failed to come in, mark those
messages as read. */
if (status >= 0 && m_lastProcessedNumber < m_lastMsgNumber) {
m_set->AddRange(m_lastProcessedNumber + 1, m_lastMsgNumber);
}
if (m_lastProcessedNumber)
AddToKnownArticles(m_firstMsgNumber, m_lastProcessedNumber);
k = &m_knownArts;
if (k && k->set)
{
int32_t n = k->set->FirstNonMember();
if (n < k->first_possible || n > k->last_possible)
{
/* We know we've gotten all there is to know.
Take advantage of that to update our counts... */
// ### dmb
}
}
if (!m_finishingXover)
{
// turn on m_finishingXover - this is a horrible hack to avoid recursive
// calls which happen when the fe selects a message as a result of getting EndingUpdate,
// which interrupts this url right before it was going to finish and causes FinishXOver
// to get called again.
m_finishingXover = true;
// XXX is this correct?
m_runningURL = nullptr;
if (m_lastMsgNumber > 0) {
nsAutoString firstStr;
firstStr.AppendInt(m_lastProcessedNumber - m_firstMsgNumber + 1);
nsAutoString lastStr;
lastStr.AppendInt(m_lastMsgNumber - m_firstMsgNumber + 1);
nsString statusString;
nsCOMPtr<nsIStringBundleService> bundleService =
mozilla::services::GetStringBundleService();
NS_ENSURE_TRUE(bundleService, NS_ERROR_UNEXPECTED);
nsCOMPtr<nsIStringBundle> bundle;
rv = bundleService->CreateBundle(NEWS_MSGS_URL, getter_AddRefs(bundle));
NS_ENSURE_SUCCESS(rv, rv);
const PRUnichar *formatStrings[2] = { firstStr.get(), lastStr.get() };
rv = bundle->FormatStringFromName(NS_LITERAL_STRING("downloadingArticles").get(), formatStrings, 2, getter_Copies(statusString));
NS_ENSURE_SUCCESS(rv, rv);
SetProgressStatus(statusString.get());
}
}
if (newstatus)
*newstatus=0;
return NS_OK;
}
/*
* Evaluates this Expr based on the given context node and processor state
* @param context the context node for evaluation of this Expr
* @param cs the ContextState containing the stack information needed
* for evaluation
* @return the result of the evaluation
*/
nsresult
txFormatNumberFunctionCall::evaluate(txIEvalContext* aContext,
txAExprResult** aResult)
{
*aResult = nullptr;
if (!requireParams(2, 3, aContext))
return NS_ERROR_XPATH_BAD_ARGUMENT_COUNT;
// Get number and format
double value;
txExpandedName formatName;
nsresult rv = evaluateToNumber(mParams[0], aContext, &value);
NS_ENSURE_SUCCESS(rv, rv);
nsAutoString formatStr;
rv = mParams[1]->evaluateToString(aContext, formatStr);
NS_ENSURE_SUCCESS(rv, rv);
if (mParams.Length() == 3) {
nsAutoString formatQName;
rv = mParams[2]->evaluateToString(aContext, formatQName);
NS_ENSURE_SUCCESS(rv, rv);
rv = formatName.init(formatQName, mMappings, false);
NS_ENSURE_SUCCESS(rv, rv);
}
txDecimalFormat* format = mStylesheet->getDecimalFormat(formatName);
if (!format) {
nsAutoString err(NS_LITERAL_STRING("unknown decimal format"));
#ifdef TX_TO_STRING
err.AppendLiteral(" for: ");
toString(err);
#endif
aContext->receiveError(err, NS_ERROR_XPATH_INVALID_ARG);
return NS_ERROR_XPATH_INVALID_ARG;
}
// Special cases
if (mozilla::IsNaN(value)) {
return aContext->recycler()->getStringResult(format->mNaN, aResult);
}
if (value == mozilla::PositiveInfinity()) {
return aContext->recycler()->getStringResult(format->mInfinity,
aResult);
}
if (value == mozilla::NegativeInfinity()) {
nsAutoString res;
res.Append(format->mMinusSign);
res.Append(format->mInfinity);
return aContext->recycler()->getStringResult(res, aResult);
}
// Value is a normal finite number
nsAutoString prefix;
nsAutoString suffix;
int minIntegerSize=0;
int minFractionSize=0;
int maxFractionSize=0;
int multiplier=1;
int groupSize=-1;
uint32_t pos = 0;
uint32_t formatLen = formatStr.Length();
bool inQuote;
// Get right subexpression
inQuote = false;
if (mozilla::IsNegative(value)) {
while (pos < formatLen &&
(inQuote ||
formatStr.CharAt(pos) != format->mPatternSeparator)) {
if (formatStr.CharAt(pos) == FORMAT_QUOTE)
inQuote = !inQuote;
pos++;
}
if (pos == formatLen) {
pos = 0;
prefix.Append(format->mMinusSign);
}
else
pos++;
}
// Parse the format string
FormatParseState pState = Prefix;
inQuote = false;
char16_t c = 0;
while (pos < formatLen && pState != Finished) {
c=formatStr.CharAt(pos++);
switch (pState) {
case Prefix:
case Suffix:
if (!inQuote) {
if (c == format->mPercent) {
if (multiplier == 1)
multiplier = 100;
else {
nsAutoString err(INVALID_PARAM_VALUE);
#ifdef TX_TO_STRING
err.AppendLiteral(": ");
toString(err);
#endif
aContext->receiveError(err,
NS_ERROR_XPATH_INVALID_ARG);
return NS_ERROR_XPATH_INVALID_ARG;
}
}
else if (c == format->mPerMille) {
if (multiplier == 1)
multiplier = 1000;
else {
nsAutoString err(INVALID_PARAM_VALUE);
#ifdef TX_TO_STRING
err.AppendLiteral(": ");
toString(err);
#endif
aContext->receiveError(err,
NS_ERROR_XPATH_INVALID_ARG);
return NS_ERROR_XPATH_INVALID_ARG;
}
}
else if (c == format->mDecimalSeparator ||
c == format->mGroupingSeparator ||
c == format->mZeroDigit ||
c == format->mDigit ||
c == format->mPatternSeparator) {
pState = pState == Prefix ? IntDigit : Finished;
pos--;
break;
}
}
if (c == FORMAT_QUOTE)
inQuote = !inQuote;
else if (pState == Prefix)
prefix.Append(c);
else
suffix.Append(c);
break;
case IntDigit:
if (c == format->mGroupingSeparator)
groupSize=0;
else if (c == format->mDigit) {
if (groupSize >= 0)
groupSize++;
}
else {
pState = IntZero;
pos--;
}
break;
case IntZero:
if (c == format->mGroupingSeparator)
groupSize = 0;
else if (c == format->mZeroDigit) {
if (groupSize >= 0)
groupSize++;
minIntegerSize++;
}
else if (c == format->mDecimalSeparator) {
pState = FracZero;
}
else {
pState = Suffix;
pos--;
}
break;
case FracZero:
if (c == format->mZeroDigit) {
maxFractionSize++;
minFractionSize++;
}
else {
pState = FracDigit;
pos--;
}
break;
case FracDigit:
if (c == format->mDigit)
maxFractionSize++;
else {
pState = Suffix;
pos--;
}
break;
case Finished:
break;
}
}
// Did we manage to parse the entire formatstring and was it valid
if ((c != format->mPatternSeparator && pos < formatLen) ||
inQuote ||
groupSize == 0) {
nsAutoString err(INVALID_PARAM_VALUE);
#ifdef TX_TO_STRING
err.AppendLiteral(": ");
toString(err);
#endif
aContext->receiveError(err, NS_ERROR_XPATH_INVALID_ARG);
return NS_ERROR_XPATH_INVALID_ARG;
}
/*
* FINALLY we're done with the parsing
* now build the result string
*/
value = fabs(value) * multiplier;
// Prefix
nsAutoString res(prefix);
int bufsize;
if (value > 1)
bufsize = (int)log10(value) + 30;
else
bufsize = 1 + 30;
char* buf = new char[bufsize];
NS_ENSURE_TRUE(buf, NS_ERROR_OUT_OF_MEMORY);
int bufIntDigits, sign;
char* endp;
PR_dtoa(value, 0, 0, &bufIntDigits, &sign, &endp, buf, bufsize-1);
int buflen = endp - buf;
int intDigits;
intDigits = bufIntDigits > minIntegerSize ? bufIntDigits : minIntegerSize;
if (groupSize < 0)
groupSize = intDigits + 10; //to simplify grouping
// XXX We shouldn't use SetLength.
res.SetLength(res.Length() +
intDigits + // integer digits
1 + // decimal separator
maxFractionSize + // fractions
(intDigits-1)/groupSize); // group separators
int32_t i = bufIntDigits + maxFractionSize - 1;
bool carry = (0 <= i+1) && (i+1 < buflen) && (buf[i+1] >= '5');
bool hasFraction = false;
uint32_t resPos = res.Length()-1;
// Fractions
for (; i >= bufIntDigits; --i) {
int digit;
if (i >= buflen || i < 0) {
digit = 0;
}
else {
digit = buf[i] - '0';
}
if (carry) {
digit = (digit + 1) % 10;
carry = digit == 0;
}
if (hasFraction || digit != 0 || i < bufIntDigits+minFractionSize) {
hasFraction = true;
res.SetCharAt((char16_t)(digit + format->mZeroDigit),
resPos--);
}
else {
res.Truncate(resPos--);
}
}
// Decimal separator
if (hasFraction) {
res.SetCharAt(format->mDecimalSeparator, resPos--);
}
else {
res.Truncate(resPos--);
}
// Integer digits
for (i = 0; i < intDigits; ++i) {
int digit;
if (bufIntDigits-i-1 >= buflen || bufIntDigits-i-1 < 0) {
digit = 0;
}
else {
digit = buf[bufIntDigits-i-1] - '0';
}
if (carry) {
digit = (digit + 1) % 10;
carry = digit == 0;
}
if (i != 0 && i%groupSize == 0) {
res.SetCharAt(format->mGroupingSeparator, resPos--);
}
res.SetCharAt((char16_t)(digit + format->mZeroDigit), resPos--);
}
if (carry) {
if (i%groupSize == 0) {
res.Insert(format->mGroupingSeparator, resPos + 1);
}
res.Insert((char16_t)(1 + format->mZeroDigit), resPos + 1);
}
if (!hasFraction && !intDigits && !carry) {
// If we havn't added any characters we add a '0'
// This can only happen for formats like '##.##'
res.Append(format->mZeroDigit);
}
delete [] buf;
// Build suffix
res.Append(suffix);
return aContext->recycler()->getStringResult(res, aResult);
} //-- evaluate
void
nsHTMLContentSerializer::SerializeAttributes(nsIContent* aContent,
nsIAtom* aTagName,
nsAString& aStr)
{
nsresult rv;
PRUint32 index, count;
nsAutoString nameStr, valueStr;
count = aContent->GetAttrCount();
NS_NAMED_LITERAL_STRING(_mozStr, "_moz");
// Loop backward over the attributes, since the order they are stored in is
// the opposite of the order they were parsed in (see bug 213347 for reason).
// index is unsigned, hence index >= 0 is always true.
for (index = count; index > 0; ) {
--index;
const nsAttrName* name = aContent->GetAttrNameAt(index);
PRInt32 namespaceID = name->NamespaceID();
nsIAtom* attrName = name->LocalName();
// Filter out any attribute starting with [-|_]moz
const char* sharedName;
attrName->GetUTF8String(&sharedName);
if ((('_' == *sharedName) || ('-' == *sharedName)) &&
!nsCRT::strncmp(sharedName+1, kMozStr, PRUint32(sizeof(kMozStr)-1))) {
continue;
}
aContent->GetAttr(namespaceID, attrName, valueStr);
//
// Filter out special case of <br type="_moz"> or <br _moz*>,
// used by the editor. Bug 16988. Yuck.
//
if (aTagName == nsGkAtoms::br && attrName == nsGkAtoms::type &&
StringBeginsWith(valueStr, _mozStr)) {
continue;
}
if (mIsCopying && mIsFirstChildOfOL && (aTagName == nsGkAtoms::li) &&
(attrName == nsGkAtoms::value)) {
// This is handled separately in SerializeLIValueAttribute()
continue;
}
PRBool isJS = IsJavaScript(attrName, valueStr);
if (((attrName == nsGkAtoms::href) ||
(attrName == nsGkAtoms::src))) {
// Make all links absolute when converting only the selection:
if (mFlags & nsIDocumentEncoder::OutputAbsoluteLinks) {
// Would be nice to handle OBJECT and APPLET tags,
// but that gets more complicated since we have to
// search the tag list for CODEBASE as well.
// For now, just leave them relative.
nsCOMPtr<nsIURI> uri = aContent->GetBaseURI();
if (uri) {
nsAutoString absURI;
rv = NS_MakeAbsoluteURI(absURI, valueStr, uri);
if (NS_SUCCEEDED(rv)) {
valueStr = absURI;
}
}
}
// Need to escape URI.
nsAutoString tempURI(valueStr);
if (!isJS && NS_FAILED(EscapeURI(tempURI, valueStr)))
valueStr = tempURI;
}
if (mIsWholeDocument && aTagName == nsGkAtoms::meta &&
attrName == nsGkAtoms::content) {
// If we're serializing a <meta http-equiv="content-type">,
// use the proper value, rather than what's in the document.
nsAutoString header;
aContent->GetAttr(kNameSpaceID_None, nsGkAtoms::httpEquiv, header);
if (header.LowerCaseEqualsLiteral("content-type")) {
valueStr = NS_LITERAL_STRING("text/html; charset=") +
NS_ConvertASCIItoUTF16(mCharset);
}
}
attrName->ToString(nameStr);
/*If we already crossed the MaxColumn limit or
* if this attr name-value pair(including a space,=,opening and closing quotes) is greater than MaxColumn limit
* then start the attribute from a new line.
*/
if (mDoFormat
&& (mColPos >= mMaxColumn
|| ((PRInt32)(mColPos + nameStr.Length() +
valueStr.Length() + 4) > mMaxColumn))) {
aStr.Append(mLineBreak);
mColPos = 0;
}
// Expand shorthand attribute.
if (IsShorthandAttr(attrName, aTagName) && valueStr.IsEmpty()) {
valueStr = nameStr;
}
SerializeAttr(EmptyString(), nameStr, valueStr, aStr, !isJS);
}
}
void
TelephonyCall::ChangeStateInternal(uint16_t aCallState, bool aFireEvents)
{
nsRefPtr<TelephonyCall> kungFuDeathGrip(this);
nsString stateString;
switch (aCallState) {
case nsIRadioInterfaceLayer::CALL_STATE_DIALING:
stateString.AssignLiteral("dialing");
break;
case nsIRadioInterfaceLayer::CALL_STATE_ALERTING:
stateString.AssignLiteral("alerting");
break;
case nsIRadioInterfaceLayer::CALL_STATE_BUSY:
stateString.AssignLiteral("busy");
break;
case nsIRadioInterfaceLayer::CALL_STATE_CONNECTING:
stateString.AssignLiteral("connecting");
break;
case nsIRadioInterfaceLayer::CALL_STATE_CONNECTED:
stateString.AssignLiteral("connected");
break;
case nsIRadioInterfaceLayer::CALL_STATE_HOLDING:
stateString.AssignLiteral("holding");
break;
case nsIRadioInterfaceLayer::CALL_STATE_HELD:
stateString.AssignLiteral("held");
break;
case nsIRadioInterfaceLayer::CALL_STATE_RESUMING:
stateString.AssignLiteral("resuming");
break;
case nsIRadioInterfaceLayer::CALL_STATE_DISCONNECTING:
stateString.AssignLiteral("disconnecting");
break;
case nsIRadioInterfaceLayer::CALL_STATE_DISCONNECTED:
stateString.AssignLiteral("disconnected");
break;
case nsIRadioInterfaceLayer::CALL_STATE_INCOMING:
stateString.AssignLiteral("incoming");
break;
default:
NS_NOTREACHED("Unknown state!");
}
mState = stateString;
mCallState = aCallState;
if (aCallState == nsIRadioInterfaceLayer::CALL_STATE_DIALING) {
mOutgoing = true;
}
if (aCallState == nsIRadioInterfaceLayer::CALL_STATE_DISCONNECTED) {
NS_ASSERTION(mLive, "Should be live!");
mTelephony->RemoveCall(this);
mLive = false;
} else if (!mLive) {
mTelephony->AddCall(this);
mLive = true;
}
if (aFireEvents) {
nsRefPtr<CallEvent> event = CallEvent::Create(this);
NS_ASSERTION(event, "This should never fail!");
if (NS_FAILED(event->Dispatch(ToIDOMEventTarget(),
NS_LITERAL_STRING("statechange")))) {
NS_WARNING("Failed to dispatch statechange event!");
}
// This can change if the statechange handler called back here... Need to
// figure out something smarter.
if (mCallState == aCallState) {
event = CallEvent::Create(this);
NS_ASSERTION(event, "This should never fail!");
if (NS_FAILED(event->Dispatch(ToIDOMEventTarget(), stateString))) {
NS_WARNING("Failed to dispatch specific event!");
}
}
}
}
NS_IMETHODIMP
nsGfxButtonControlFrame::GetFrameName(nsAString& aResult) const
{
return MakeFrameName(NS_LITERAL_STRING("ButtonControl"), aResult);
}
NS_IMETHODIMP
nsHTMLContentSerializer::AppendElementStart(nsIDOMElement *aElement,
PRBool aHasChildren,
nsAString& aStr)
{
NS_ENSURE_ARG(aElement);
nsCOMPtr<nsIContent> content = do_QueryInterface(aElement);
if (!content) return NS_ERROR_FAILURE;
// The _moz_dirty attribute is emitted by the editor to
// indicate that this element should be pretty printed
// even if we're not in pretty printing mode
PRBool hasDirtyAttr = content->HasAttr(kNameSpaceID_None,
nsLayoutAtoms::mozdirty);
nsIAtom *name = content->Tag();
if (name == nsHTMLAtoms::br && mPreLevel > 0
&& (mFlags & nsIDocumentEncoder::OutputNoFormattingInPre)) {
AppendToString(mLineBreak, aStr);
mMayIgnoreLineBreakSequence = PR_TRUE;
mColPos = 0;
return NS_OK;
}
if (name == nsHTMLAtoms::body) {
mInBody = PR_TRUE;
}
if (LineBreakBeforeOpen(name, hasDirtyAttr)) {
AppendToString(mLineBreak, aStr);
mMayIgnoreLineBreakSequence = PR_TRUE;
mColPos = 0;
mAddSpace = PR_FALSE;
}
else if (mAddSpace) {
AppendToString(PRUnichar(' '), aStr);
mAddSpace = PR_FALSE;
}
else {
MaybeAddNewline(aStr);
}
// Always reset to avoid false newlines in case MaybeAddNewline wasn't
// called
mAddNewline = PR_FALSE;
StartIndentation(name, hasDirtyAttr, aStr);
if (name == nsHTMLAtoms::pre ||
name == nsHTMLAtoms::script ||
name == nsHTMLAtoms::style) {
mPreLevel++;
}
AppendToString(kLessThan, aStr);
nsAutoString nameStr;
name->ToString(nameStr);
AppendToString(nameStr.get(), -1, aStr);
// Need to keep track of OL and LI elements in order to get ordinal number
// for the LI.
if (mIsCopying && name == nsHTMLAtoms::ol){
// We are copying and current node is an OL;
// Store it's start attribute value in olState->startVal.
nsAutoString start;
PRInt32 startAttrVal = 0;
aElement->GetAttribute(NS_LITERAL_STRING("start"), start);
if (!start.IsEmpty()){
PRInt32 rv = 0;
startAttrVal = start.ToInteger(&rv);
//If OL has "start" attribute, first LI element has to start with that value
//Therefore subtracting 1 as all the LI elements are incrementing it before using it;
//In failure of ToInteger(), default StartAttrValue to 0.
if (NS_SUCCEEDED(rv))
startAttrVal--;
else
startAttrVal = 0;
}
olState* state = new olState(startAttrVal, PR_TRUE);
if (state)
mOLStateStack.AppendElement(state);
}
if (mIsCopying && name == nsHTMLAtoms::li) {
mIsFirstChildOfOL = IsFirstChildOfOL(aElement);
if (mIsFirstChildOfOL){
// If OL is parent of this LI, serialize attributes in different manner.
SerializeLIValueAttribute(aElement, aStr);
}
}
// Even LI passed above have to go through this
// for serializing attributes other than "value".
SerializeAttributes(content, name, aStr);
AppendToString(kGreaterThan, aStr);
if (LineBreakAfterOpen(name, hasDirtyAttr)) {
AppendToString(mLineBreak, aStr);
mMayIgnoreLineBreakSequence = PR_TRUE;
mColPos = 0;
}
if (name == nsHTMLAtoms::script ||
name == nsHTMLAtoms::style ||
name == nsHTMLAtoms::noscript ||
name == nsHTMLAtoms::noframes) {
mInCDATA = PR_TRUE;
}
return NS_OK;
}
static bool
AdobePluginVoucherExists(const nsACString& aVersionStr)
{
return AdobePluginFileExists(aVersionStr, NS_LITERAL_STRING("eme-adobe.voucher"));
}
nsresult
MediaDocument::CreateSyntheticDocument()
{
// Synthesize an empty html document
nsresult rv;
nsCOMPtr<nsINodeInfo> nodeInfo;
nodeInfo = mNodeInfoManager->GetNodeInfo(nsGkAtoms::html, nsnull,
kNameSpaceID_XHTML,
nsIDOMNode::ELEMENT_NODE);
NS_ENSURE_TRUE(nodeInfo, NS_ERROR_OUT_OF_MEMORY);
nsRefPtr<nsGenericHTMLElement> root = NS_NewHTMLHtmlElement(nodeInfo.forget());
if (!root) {
return NS_ERROR_OUT_OF_MEMORY;
}
NS_ASSERTION(GetChildCount() == 0, "Shouldn't have any kids");
rv = AppendChildTo(root, PR_FALSE);
NS_ENSURE_SUCCESS(rv, rv);
nodeInfo = mNodeInfoManager->GetNodeInfo(nsGkAtoms::head, nsnull,
kNameSpaceID_XHTML,
nsIDOMNode::ELEMENT_NODE);
NS_ENSURE_TRUE(nodeInfo, NS_ERROR_OUT_OF_MEMORY);
// Create a <head> so our title has somewhere to live
nsRefPtr<nsGenericHTMLElement> head = NS_NewHTMLHeadElement(nodeInfo.forget());
if (!head) {
return NS_ERROR_OUT_OF_MEMORY;
}
nsCOMPtr<nsINodeInfo> nodeInfoMeta;
nodeInfoMeta = mNodeInfoManager->GetNodeInfo(nsGkAtoms::meta, nsnull,
kNameSpaceID_XHTML,
nsIDOMNode::ELEMENT_NODE);
NS_ENSURE_TRUE(nodeInfoMeta, NS_ERROR_OUT_OF_MEMORY);
nsRefPtr<nsGenericHTMLElement> metaContent = NS_NewHTMLMetaElement(nodeInfoMeta.forget());
if (!metaContent) {
return NS_ERROR_OUT_OF_MEMORY;
}
metaContent->SetAttr(kNameSpaceID_None, nsGkAtoms::name,
NS_LITERAL_STRING("viewport"),
PR_TRUE);
metaContent->SetAttr(kNameSpaceID_None, nsGkAtoms::content,
NS_LITERAL_STRING("width=device-width; height=device-height;"),
PR_TRUE);
head->AppendChildTo(metaContent, PR_FALSE);
root->AppendChildTo(head, PR_FALSE);
nodeInfo = mNodeInfoManager->GetNodeInfo(nsGkAtoms::body, nsnull,
kNameSpaceID_XHTML,
nsIDOMNode::ELEMENT_NODE);
NS_ENSURE_TRUE(nodeInfo, NS_ERROR_OUT_OF_MEMORY);
nsRefPtr<nsGenericHTMLElement> body = NS_NewHTMLBodyElement(nodeInfo.forget());
if (!body) {
return NS_ERROR_OUT_OF_MEMORY;
}
root->AppendChildTo(body, PR_FALSE);
return NS_OK;
}
void
ImageDocument::UpdateTitleAndCharset()
{
nsAutoCString typeStr;
nsCOMPtr<imgIRequest> imageRequest;
nsCOMPtr<nsIImageLoadingContent> imageLoader = do_QueryInterface(mImageContent);
if (imageLoader) {
imageLoader->GetRequest(nsIImageLoadingContent::CURRENT_REQUEST,
getter_AddRefs(imageRequest));
}
if (imageRequest) {
nsXPIDLCString mimeType;
imageRequest->GetMimeType(getter_Copies(mimeType));
ToUpperCase(mimeType);
nsXPIDLCString::const_iterator start, end;
mimeType.BeginReading(start);
mimeType.EndReading(end);
nsXPIDLCString::const_iterator iter = end;
if (FindInReadable(NS_LITERAL_CSTRING("IMAGE/"), start, iter) &&
iter != end) {
// strip out "X-" if any
if (*iter == 'X') {
++iter;
if (iter != end && *iter == '-') {
++iter;
if (iter == end) {
// looks like "IMAGE/X-" is the type?? Bail out of here.
mimeType.BeginReading(iter);
}
} else {
--iter;
}
}
typeStr = Substring(iter, end);
} else {
typeStr = mimeType;
}
}
nsXPIDLString status;
if (mImageIsResized) {
nsAutoString ratioStr;
ratioStr.AppendInt(NSToCoordFloor(GetRatio() * 100));
const PRUnichar* formatString[1] = { ratioStr.get() };
mStringBundle->FormatStringFromName(NS_LITERAL_STRING("ScaledImage").get(),
formatString, 1,
getter_Copies(status));
}
static const char* const formatNames[4] =
{
"ImageTitleWithNeitherDimensionsNorFile",
"ImageTitleWithoutDimensions",
"ImageTitleWithDimensions",
"ImageTitleWithDimensionsAndFile",
};
MediaDocument::UpdateTitleAndCharset(typeStr, formatNames,
mImageWidth, mImageHeight, status);
}
bool
ECKeyToJwk(const PK11ObjectType aKeyType, void* aKey, const SECItem* aEcParams,
const SECItem* aPublicValue, JsonWebKey& aRetVal)
{
aRetVal.mX.Construct();
aRetVal.mY.Construct();
// Check that the given EC parameters are valid.
if (!CheckEncodedECParameters(aEcParams)) {
return false;
}
// Construct the OID tag.
SECItem oid = { siBuffer, nullptr, 0 };
oid.len = aEcParams->data[1];
oid.data = aEcParams->data + 2;
uint32_t flen;
switch (SECOID_FindOIDTag(&oid)) {
case SEC_OID_SECG_EC_SECP256R1:
flen = 32; // bytes
aRetVal.mCrv.Construct(NS_LITERAL_STRING(WEBCRYPTO_NAMED_CURVE_P256));
break;
case SEC_OID_SECG_EC_SECP384R1:
flen = 48; // bytes
aRetVal.mCrv.Construct(NS_LITERAL_STRING(WEBCRYPTO_NAMED_CURVE_P384));
break;
case SEC_OID_SECG_EC_SECP521R1:
flen = 66; // bytes
aRetVal.mCrv.Construct(NS_LITERAL_STRING(WEBCRYPTO_NAMED_CURVE_P521));
break;
default:
return false;
}
// No support for compressed points.
if (aPublicValue->data[0] != EC_POINT_FORM_UNCOMPRESSED) {
return false;
}
// Check length of uncompressed point coordinates.
if (aPublicValue->len != (2 * flen + 1)) {
return false;
}
ScopedSECItem ecPointX(::SECITEM_AllocItem(nullptr, nullptr, flen));
ScopedSECItem ecPointY(::SECITEM_AllocItem(nullptr, nullptr, flen));
if (!ecPointX || !ecPointY) {
return false;
}
// Extract point data.
memcpy(ecPointX->data, aPublicValue->data + 1, flen);
memcpy(ecPointY->data, aPublicValue->data + 1 + flen, flen);
CryptoBuffer x, y;
if (!x.Assign(ecPointX) || NS_FAILED(x.ToJwkBase64(aRetVal.mX.Value())) ||
!y.Assign(ecPointY) || NS_FAILED(y.ToJwkBase64(aRetVal.mY.Value()))) {
return false;
}
aRetVal.mKty.Construct(NS_LITERAL_STRING(JWK_TYPE_EC));
return true;
}
NS_IMETHODIMP
nsImageBoxFrame::GetFrameName(nsAString& aResult) const
{
return MakeFrameName(NS_LITERAL_STRING("ImageBox"), aResult);
}
/**
* Perform the part of initialization that can only be
* executed on the main thread.
*/
nsresult InitOSFileConstants()
{
MOZ_ASSERT(NS_IsMainThread());
if (gInitialized) {
return NS_OK;
}
gInitialized = true;
nsAutoPtr<Paths> paths(new Paths);
// Initialize paths->libDir
nsCOMPtr<nsIFile> file;
nsresult rv = NS_GetSpecialDirectory(NS_XPCOM_LIBRARY_FILE, getter_AddRefs(file));
if (NS_FAILED(rv)) {
return rv;
}
nsCOMPtr<nsIFile> libDir;
rv = file->GetParent(getter_AddRefs(libDir));
if (NS_FAILED(rv)) {
return rv;
}
rv = libDir->GetPath(paths->libDir);
if (NS_FAILED(rv)) {
return rv;
}
// Setup profileDir and localProfileDir immediately if possible (we
// assume that NS_APP_USER_PROFILE_50_DIR and
// NS_APP_USER_PROFILE_LOCAL_50_DIR are set simultaneously)
rv = GetPathToSpecialDir(NS_APP_USER_PROFILE_50_DIR, paths->profileDir);
if (NS_SUCCEEDED(rv)) {
rv = GetPathToSpecialDir(NS_APP_USER_PROFILE_LOCAL_50_DIR, paths->localProfileDir);
}
// Otherwise, delay setup of profileDir/localProfileDir until they
// become available.
if (NS_FAILED(rv)) {
nsCOMPtr<nsIObserverService> obsService = do_GetService(NS_OBSERVERSERVICE_CONTRACTID, &rv);
if (NS_FAILED(rv)) {
return rv;
}
RefPtr<DelayedPathSetter> pathSetter = new DelayedPathSetter();
rv = obsService->AddObserver(pathSetter, "profile-do-change", false);
if (NS_FAILED(rv)) {
return rv;
}
}
// For other directories, ignore errors (they may be undefined on
// some platforms or in non-Firefox embeddings of Gecko).
GetPathToSpecialDir(NS_OS_TEMP_DIR, paths->tmpDir);
GetPathToSpecialDir(NS_OS_HOME_DIR, paths->homeDir);
GetPathToSpecialDir(NS_OS_DESKTOP_DIR, paths->desktopDir);
GetPathToSpecialDir(XRE_USER_APP_DATA_DIR, paths->userApplicationDataDir);
#if defined(XP_WIN)
GetPathToSpecialDir(NS_WIN_APPDATA_DIR, paths->winAppDataDir);
GetPathToSpecialDir(NS_WIN_PROGRAMS_DIR, paths->winStartMenuProgsDir);
#endif // defined(XP_WIN)
#if defined(XP_MACOSX)
GetPathToSpecialDir(NS_MAC_USER_LIB_DIR, paths->macUserLibDir);
GetPathToSpecialDir(NS_OSX_LOCAL_APPLICATIONS_DIR, paths->macLocalApplicationsDir);
GetPathToSpecialDir(NS_MAC_TRASH_DIR, paths->macTrashDir);
#endif // defined(XP_MACOSX)
gPaths = paths.forget();
// Get the umask from the system-info service.
// The property will always be present, but it will be zero on
// non-Unix systems.
nsCOMPtr<nsIPropertyBag2> infoService =
do_GetService("@mozilla.org/system-info;1");
MOZ_ASSERT(infoService, "Could not access the system information service");
rv = infoService->GetPropertyAsUint32(NS_LITERAL_STRING("umask"),
&gUserUmask);
if (NS_FAILED(rv)) {
return rv;
}
return NS_OK;
}