ENameValueFlag
RootAccessible::Name(nsString& aName)
{
aName.Truncate();
if (mRoleMapEntry) {
Accessible::Name(aName);
if (!aName.IsEmpty())
return eNameOK;
}
nsCOMPtr<nsIDOMDocument> document = do_QueryInterface(mDocument);
NS_ENSURE_TRUE(document, eNameOK);
document->GetTitle(aName);
return eNameOK;
}
void ConvertJSValToStr(nsString& aString,
JSContext* aContext,
jsval aValue)
{
JSString *jsstring;
if ( !JSVAL_IS_NULL(aValue) &&
(jsstring = JS_ValueToString(aContext, aValue)) != nsnull)
{
aString.Assign(reinterpret_cast<const PRUnichar*>(JS_GetStringChars(jsstring)));
}
else
{
aString.Truncate();
}
}
ENameValueFlag
HTMLListBulletAccessible::Name(nsString &aName)
{
aName.Truncate();
// Native anonymous content, ARIA can't be used. Get list bullet text.
nsBlockFrame* blockFrame = do_QueryFrame(mContent->GetPrimaryFrame());
if (blockFrame) {
blockFrame->GetBulletText(aName);
// Append space otherwise bullets are jammed up against list text.
aName.Append(' ');
}
return eNameOK;
}
static void splitString(nsString& aSource, nsString& aTarget)
{
aTarget.Truncate() ;
PRInt32 offset = aSource.FindChar('\n') ;
if (offset >= 0) {
const PRUnichar *source = aSource.get() + offset + 1 ;
while (*source) {
if (*source == '\n' || *source == '\r') { aTarget.Append(PRUnichar(' ')) ; }
else { aTarget.Append(*source) ; }
++ source ;
}
aSource.SetLength(offset);
}
}
void
URL::GetHostname(nsString& aHostname, ErrorResult& aRv) const
{
aHostname.Truncate();
nsAutoCString tmp;
nsresult rv = mURI->GetHost(tmp);
if (NS_SUCCEEDED(rv)) {
if (tmp.FindChar(':') != -1) { // Escape IPv6 address
MOZ_ASSERT(!tmp.Length() ||
(tmp[0] !='[' && tmp[tmp.Length() - 1] != ']'));
tmp.Insert('[', 0);
tmp.Append(']');
}
CopyUTF8toUTF16(tmp, aHostname);
}
}
void
PopupBoxObject::GetAlignmentPosition(nsString& positionStr)
{
positionStr.Truncate();
// This needs to flush layout.
nsMenuPopupFrame *menuPopupFrame = do_QueryFrame(GetFrame(true));
if (!menuPopupFrame)
return;
int8_t position = menuPopupFrame->GetAlignmentPosition();
switch (position) {
case POPUPPOSITION_AFTERSTART:
positionStr.AssignLiteral("after_start");
break;
case POPUPPOSITION_AFTEREND:
positionStr.AssignLiteral("after_end");
break;
case POPUPPOSITION_BEFORESTART:
positionStr.AssignLiteral("before_start");
break;
case POPUPPOSITION_BEFOREEND:
positionStr.AssignLiteral("before_end");
break;
case POPUPPOSITION_STARTBEFORE:
positionStr.AssignLiteral("start_before");
break;
case POPUPPOSITION_ENDBEFORE:
positionStr.AssignLiteral("end_before");
break;
case POPUPPOSITION_STARTAFTER:
positionStr.AssignLiteral("start_after");
break;
case POPUPPOSITION_ENDAFTER:
positionStr.AssignLiteral("end_after");
break;
case POPUPPOSITION_OVERLAP:
positionStr.AssignLiteral("overlap");
break;
case POPUPPOSITION_AFTERPOINTER:
positionStr.AssignLiteral("after_pointer");
break;
default:
// Leave as an empty string.
break;
}
}
void
nsXULTextFieldAccessible::Value(nsString& aValue)
{
aValue.Truncate();
if (NativeRole() == roles::PASSWORD_TEXT) // Don't return password text!
return;
nsCOMPtr<nsIDOMXULTextBoxElement> textBox(do_QueryInterface(mContent));
if (textBox) {
textBox->GetValue(aValue);
return;
}
nsCOMPtr<nsIDOMXULMenuListElement> menuList(do_QueryInterface(mContent));
if (menuList)
menuList->GetLabel(aValue);
}
void
HTMLTextFieldAccessible::Value(nsString& aValue)
{
aValue.Truncate();
if (NativeState() & states::PROTECTED) // Don't return password text!
return;
nsCOMPtr<nsIDOMHTMLTextAreaElement> textArea(do_QueryInterface(mContent));
if (textArea) {
textArea->GetValue(aValue);
return;
}
HTMLInputElement* input = HTMLInputElement::FromContent(mContent);
if (input)
input->GetValue(aValue);
}
ENameValueFlag XULTreeGridRowAccessible::Name(nsString& aName) const {
aName.Truncate();
// XXX: the row name sholdn't be a concatenation of cell names (bug 664384).
RefPtr<nsTreeColumn> column = nsCoreUtils::GetFirstSensibleColumn(mTree);
while (column) {
if (!aName.IsEmpty()) aName.Append(' ');
nsAutoString cellName;
GetCellName(column, cellName);
aName.Append(cellName);
column = nsCoreUtils::GetNextSensibleColumn(column);
}
return eNameOK;
}
nsresult
nsParserMsgUtils::GetLocalizedStringByID(const char * aPropFileName, PRUint32 aID, nsString& oVal)
{
oVal.Truncate();
nsCOMPtr<nsIStringBundle> bundle;
nsresult rv = GetBundle(aPropFileName,getter_AddRefs(bundle));
if (NS_SUCCEEDED(rv) && bundle) {
nsXPIDLString valUni;
rv = bundle->GetStringFromID(aID, getter_Copies(valUni));
if (NS_SUCCEEDED(rv) && valUni) {
oVal.Assign(valUni);
}
}
return rv;
}
ENameValueFlag XULTreeGridCellAccessible::Name(nsString& aName) const {
aName.Truncate();
if (!mTreeView) return eNameOK;
mTreeView->GetCellText(mRow, mColumn, aName);
// If there is still no name try the cell value:
// This is for graphical cells. We need tree/table view implementors to
// implement FooView::GetCellValue to return a meaningful string for cases
// where there is something shown in the cell (non-text) such as a star icon;
// in which case GetCellValue for that cell would return "starred" or
// "flagged" for example.
if (aName.IsEmpty()) mTreeView->GetCellValue(mRow, mColumn, aName);
return eNameOK;
}
nsresult
CryptoBuffer::ToJwkBase64(nsString& aBase64) const
{
// Shortcut for the empty octet string
if (Length() == 0) {
aBase64.Truncate();
return NS_OK;
}
nsAutoCString base64;
nsresult rv = Base64URLEncode(Length(), Elements(),
Base64URLEncodePaddingPolicy::Omit, base64);
NS_ENSURE_SUCCESS(rv, rv);
CopyASCIItoUTF16(base64, aBase64);
return NS_OK;
}
void HTMLTextFieldAccessible::Value(nsString& aValue) const {
aValue.Truncate();
if (NativeState() & states::PROTECTED) // Don't return password text!
return;
HTMLTextAreaElement* textArea = HTMLTextAreaElement::FromNode(mContent);
if (textArea) {
textArea->GetValue(aValue);
return;
}
HTMLInputElement* input = HTMLInputElement::FromNode(mContent);
if (input) {
// Pass NonSystem as the caller type, to be safe. We don't expect to have a
// file input here.
input->GetValue(aValue, CallerType::NonSystem);
}
}
void nsEudoraWin32::GetAccountName( const char *pSection, nsString& str)
{
str.Truncate();
nsCString s(pSection);
if (s.LowerCaseEqualsLiteral("settings"))
{
str.AssignLiteral("Eudora ");
str.Append(NS_ConvertASCIItoUTF16(pSection));
}
else
{
str.AssignASCII(pSection);
if (StringBeginsWith(s, NS_LITERAL_CSTRING("persona-"), nsCaseInsensitiveCStringComparator()))
CopyASCIItoUTF16(Substring(s, 8), str);
}
}
void nsEudoraCompose::ExtractCharset(nsString& str)
{
int32_t idx = MsgFind(str, "charset=", true, 0);
if (idx != -1) {
str.Cut(0, idx + 8);
idx = str.FindChar(';');
if (idx != -1)
str.SetLength(idx);
str.Trim(kWhitespace);
if ((str.CharAt(0) == '"') && (str.Length() > 2)) {
str.SetLength(str.Length() - 1);
str.Cut(0, 1);
str.Trim(kWhitespace);
}
}
else
str.Truncate();
}
//--------------------------------------------------------
// Return localized string
static nsresult
GetLocalizedString(nsIStringBundle* aStrBundle, const char* aKey, nsString& oVal)
{
NS_ENSURE_ARG_POINTER(aStrBundle);
NS_ENSURE_ARG_POINTER(aKey);
// Determine default label from string bundle
nsXPIDLString valUni;
nsAutoString key;
key.AssignWithConversion(aKey);
nsresult rv = aStrBundle->GetStringFromName(key.get(), getter_Copies(valUni));
if (NS_SUCCEEDED(rv) && valUni) {
oVal.Assign(valUni);
} else {
oVal.Truncate();
}
return rv;
}
void
URL::GetSearch(nsString& aSearch) const
{
aSearch.Truncate();
nsCOMPtr<nsIURL> url(do_QueryInterface(mURI));
if (!url) {
// Do not throw! Not having a valid URI or URL should result in an empty
// string.
return;
}
nsAutoCString search;
nsresult rv = url->GetQuery(search);
if (NS_SUCCEEDED(rv) && !search.IsEmpty()) {
CopyUTF8toUTF16(NS_LITERAL_CSTRING("?") + search, aSearch);
}
}
void
URL::GetPathname(nsString& aPathname) const
{
aPathname.Truncate();
nsCOMPtr<nsIURL> url(do_QueryInterface(mURI));
if (!url) {
// Do not throw! Not having a valid URI or URL should result in an empty
// string.
return;
}
nsAutoCString file;
nsresult rv = url->GetFilePath(file);
if (NS_SUCCEEDED(rv)) {
CopyUTF8toUTF16(file, aPathname);
}
}
static void
GetDateBoundary(nsIX509Cert* ix509,
nsString &formattedDate,
nsString &nowDate,
bool &trueExpired_falseNotYetValid)
{
trueExpired_falseNotYetValid = true;
formattedDate.Truncate();
PRTime notAfter, notBefore, timeToUse;
nsCOMPtr<nsIX509CertValidity> validity;
nsresult rv;
rv = ix509->GetValidity(getter_AddRefs(validity));
if (NS_FAILED(rv))
return;
rv = validity->GetNotAfter(¬After);
if (NS_FAILED(rv))
return;
rv = validity->GetNotBefore(¬Before);
if (NS_FAILED(rv))
return;
PRTime now = PR_Now();
if (now > notAfter) {
timeToUse = notAfter;
} else {
timeToUse = notBefore;
trueExpired_falseNotYetValid = false;
}
nsCOMPtr<nsIDateTimeFormat> dateTimeFormat(do_CreateInstance(NS_DATETIMEFORMAT_CONTRACTID, &rv));
if (NS_FAILED(rv))
return;
dateTimeFormat->FormatPRTime(nullptr, kDateFormatShort,
kTimeFormatNoSeconds, timeToUse,
formattedDate);
dateTimeFormat->FormatPRTime(nullptr, kDateFormatShort,
kTimeFormatNoSeconds, now,
nowDate);
}
// Returns NULL if there is no personal namespace on the given host
NS_IMETHODIMP nsIMAPHostSessionList::GetOnlineInboxPathForHost(const char *serverKey, nsString &result)
{
PR_EnterMonitor(gCachedHostInfoMonitor);
nsIMAPHostInfo *host = FindHost(serverKey);
if (host)
{
nsIMAPNamespace *ns = NULL;
ns = host->fNamespaceList->GetDefaultNamespaceOfType(kPersonalNamespace);
if (ns)
{
CopyASCIItoUTF16(nsDependentCString(ns->GetPrefix()), result);
result.AppendLiteral("INBOX");
}
}
else
result.Truncate();
PR_ExitMonitor(gCachedHostInfoMonitor);
return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK;
}
nsresult
nsSAXXMLReader::SplitExpatName(const PRUnichar *aExpatName,
nsString &aURI,
nsString &aLocalName,
nsString &aQName)
{
/**
* Adapted from RDFContentSinkImpl
*
* Expat can send the following:
* localName
* namespaceURI<separator>localName
* namespaceURI<separator>localName<separator>prefix
*
* and we use 0xFFFF for the <separator>.
*
*/
NS_ASSERTION(aExpatName, "null passed to handler");
nsDependentString expatStr(aExpatName);
int32_t break1, break2 = kNotFound;
break1 = expatStr.FindChar(PRUnichar(0xFFFF));
if (break1 == kNotFound) {
aLocalName = expatStr; // no namespace
aURI.Truncate();
aQName = expatStr;
} else {
aURI = StringHead(expatStr, break1);
break2 = expatStr.FindChar(PRUnichar(0xFFFF), break1 + 1);
if (break2 == kNotFound) { // namespace, but no prefix
aLocalName = Substring(expatStr, break1 + 1);
aQName = aLocalName;
} else { // namespace with prefix
aLocalName = Substring(expatStr, break1 + 1, break2 - break1 - 1);
aQName = Substring(expatStr, break2 + 1) +
NS_LITERAL_STRING(":") + aLocalName;
}
}
return NS_OK;
}
void CMapiMessageHeaders::CHeaderField::GetUnfoldedString(nsString& dest,
const char* fallbackCharset) const
{
dest.Truncate();
if (!m_fbody)
return;
nsCString unfolded;
const char* pos = m_fbody;
while (*pos) {
if ((*pos == nsCRT::CR) && (*(pos+1) == nsCRT::LF) && IsWSP(*(pos+2)))
pos += 2; // Skip CRLF if it is followed by SPACE or TAB
else
unfolded.Append(*(pos++));
}
if (m_fbody_utf8)
CopyUTF8toUTF16(unfolded, dest);
else
nsMsgI18NConvertToUnicode(fallbackCharset, unfolded, dest);
}
nsresult
nsParserMsgUtils::GetLocalizedStringByName(const char * aPropFileName, const char* aKey, nsString& oVal)
{
oVal.Truncate();
NS_ENSURE_ARG_POINTER(aKey);
nsCOMPtr<nsIStringBundle> bundle;
nsresult rv = GetBundle(aPropFileName,getter_AddRefs(bundle));
if (NS_SUCCEEDED(rv) && bundle) {
nsXPIDLString valUni;
nsAutoString key; key.AssignWithConversion(aKey);
rv = bundle->GetStringFromName(key.get(), getter_Copies(valUni));
if (NS_SUCCEEDED(rv) && valUni) {
oVal.Assign(valUni);
}
}
return rv;
}
void nsEudoraCompose::ExtractType(nsString& str)
{
nsString tStr;
int32_t idx = str.FindChar(';');
if (idx != -1)
str.SetLength(idx);
str.Trim(kWhitespace);
if ((str.CharAt(0) == '"') && (str.Length() > 2)) {
str.SetLength(str.Length() - 1);
str.Cut(0, 1);
str.Trim(kWhitespace);
}
// if multipart then ignore it since no outlook message body is ever
// valid multipart!
if (StringBeginsWith(str, NS_LITERAL_STRING("multipart/"), nsCaseInsensitiveStringComparator()))
str.Truncate();
}
void
nsMsgPrintEngine::GetString(const PRUnichar *aStringName, nsString& outStr)
{
nsresult res = NS_OK;
outStr.Truncate();
if (!mStringBundle)
{
static const char propertyURL[] = MESSENGER_STRING_URL;
nsCOMPtr<nsIStringBundleService> sBundleService =
do_GetService(NS_STRINGBUNDLE_CONTRACTID, &res);
if (NS_SUCCEEDED(res) && (nsnull != sBundleService))
res = sBundleService->CreateBundle(propertyURL, getter_AddRefs(mStringBundle));
}
if (mStringBundle)
res = mStringBundle->GetStringFromName(aStringName, getter_Copies(outStr));
return;
}
void
nsXULComboboxAccessible::Description(nsString& aDescription)
{
aDescription.Truncate();
// Use description of currently focused option
nsCOMPtr<nsIDOMXULMenuListElement> menuListElm(do_QueryInterface(mContent));
if (!menuListElm)
return;
nsCOMPtr<nsIDOMXULSelectControlItemElement> focusedOptionItem;
menuListElm->GetSelectedItem(getter_AddRefs(focusedOptionItem));
nsCOMPtr<nsIContent> focusedOptionContent =
do_QueryInterface(focusedOptionItem);
if (focusedOptionContent) {
nsAccessible* focusedOptionAcc = GetAccService()->
GetAccessibleInWeakShell(focusedOptionContent, mWeakShell);
if (focusedOptionAcc)
focusedOptionAcc->Description(aDescription);
}
}
void ProxyAccessible::Language(nsString& aLocale) {
aLocale.Truncate();
RefPtr<IAccessible> acc;
if (!GetCOMInterface((void**)getter_AddRefs(acc))) {
return;
}
RefPtr<IAccessible2> acc2;
if (FAILED(acc->QueryInterface(IID_IAccessible2,
(void**)getter_AddRefs(acc2)))) {
return;
}
IA2Locale locale;
HRESULT hr = acc2->get_locale(&locale);
_bstr_t langWrap(locale.language, false);
_bstr_t countryWrap(locale.country, false);
_bstr_t variantWrap(locale.variant, false);
if (FAILED(hr)) {
return;
}
// The remaining code should essentially be the inverse of the
// ia2Accessible::get_locale conversion to IA2Locale.
if (!!variantWrap) {
aLocale = (wchar_t*)variantWrap;
return;
}
if (!!langWrap) {
aLocale = (wchar_t*)langWrap;
if (!!countryWrap) {
aLocale += L"-";
aLocale += (wchar_t*)countryWrap;
}
}
}
void
FontFace::GetDesc(nsCSSFontDesc aDescID,
nsCSSPropertyID aPropID,
nsString& aResult) const
{
MOZ_ASSERT(aDescID == eCSSFontDesc_UnicodeRange ||
aDescID == eCSSFontDesc_Display ||
aPropID != eCSSProperty_UNKNOWN,
"only pass eCSSProperty_UNKNOWN for eCSSFontDesc_UnicodeRange");
nsCSSValue value;
GetDesc(aDescID, value);
aResult.Truncate();
// Fill in a default value for missing descriptors.
if (value.GetUnit() == eCSSUnit_Null) {
if (aDescID == eCSSFontDesc_UnicodeRange) {
aResult.AssignLiteral("U+0-10FFFF");
} else if (aDescID == eCSSFontDesc_Display) {
aResult.AssignLiteral("auto");
} else if (aDescID != eCSSFontDesc_Family &&
aDescID != eCSSFontDesc_Src) {
aResult.AssignLiteral("normal");
}
return;
}
if (aDescID == eCSSFontDesc_UnicodeRange) {
// Since there's no unicode-range property, we can't use
// nsCSSValue::AppendToString to serialize this descriptor.
nsStyleUtil::AppendUnicodeRange(value, aResult);
} else if (aDescID == eCSSFontDesc_Display) {
AppendASCIItoUTF16(nsCSSProps::ValueToKeyword(value.GetIntValue(),
nsCSSProps::kFontDisplayKTable),
aResult);
} else {
value.AppendToString(aPropID, aResult, nsCSSValue::eNormalized);
}
}
/*----------------------------------------------------------------------------
GetXULWindowTypeString
Get the type string for a XUL window
----------------------------------------------------------------------------*/
static void GetXULWindowTypeString(nsIXULWindow *inXULWindow, nsString& outWindowType)
{
outWindowType.Truncate();
if (inXULWindow)
{
nsCOMPtr<nsIDocShellTreeItem> contentShell;
inXULWindow->GetPrimaryContentShell(getter_AddRefs(contentShell));
nsCOMPtr<nsIWebNavigation> webNav(do_QueryInterface(contentShell));
ThrowErrIfNil(webNav, paramErr);
nsCOMPtr<nsIDOMDocument> domDoc;
webNav->GetDocument(getter_AddRefs(domDoc));
if (domDoc)
{
nsCOMPtr<nsIDOMElement> element;
domDoc->GetDocumentElement(getter_AddRefs(element));
if (element)
element->GetAttribute(NS_LITERAL_STRING("windowtype"), outWindowType);
}
}
}
void
FontFace::GetFamily(nsString& aResult)
{
mFontFaceSet->FlushUserFontSet();
// Serialize the same way as in nsCSSFontFaceStyleDecl::GetPropertyValue.
nsCSSValue value;
GetDesc(eCSSFontDesc_Family, value);
aResult.Truncate();
if (value.GetUnit() == eCSSUnit_Null) {
return;
}
nsDependentString family(value.GetStringBufferValue());
if (!family.IsEmpty()) {
// The string length can be zero when the author passed an invalid
// family name or an invalid descriptor to the JS FontFace constructor.
nsStyleUtil::AppendEscapedCSSString(family, aResult);
}
}
