PRBool
nsAttrValue::Equals(const nsAString& aValue,
nsCaseTreatment aCaseSensitive) const
{
switch (BaseType()) {
case eStringBase:
{
nsStringBuffer* str = static_cast<nsStringBuffer*>(GetPtr());
if (str) {
nsDependentString dep(static_cast<PRUnichar*>(str->Data()),
str->StorageSize()/sizeof(PRUnichar) - 1);
return aCaseSensitive == eCaseMatters ? aValue.Equals(dep) :
aValue.Equals(dep, nsCaseInsensitiveStringComparator());
}
return aValue.IsEmpty();
}
case eAtomBase:
if (aCaseSensitive == eCaseMatters) {
return static_cast<nsIAtom*>(GetPtr())->Equals(aValue);
}
return nsDependentAtomString(static_cast<nsIAtom*>(GetPtr())).
Equals(aValue, nsCaseInsensitiveStringComparator());
default:
break;
}
nsAutoString val;
ToString(val);
return aCaseSensitive == eCaseMatters ? val.Equals(aValue) :
val.Equals(aValue, nsCaseInsensitiveStringComparator());
}
NS_IMETHODIMP ImportEudoraMailImpl::TranslateFolderName(const nsAString & aFolderName, nsAString & _retval)
{
if (aFolderName.Equals(NS_LITERAL_STRING("Out"), nsCaseInsensitiveStringComparator()))
_retval = NS_LITERAL_STRING(kDestSentFolderName);
else if (aFolderName.Equals(NS_LITERAL_STRING("In"), nsCaseInsensitiveStringComparator()))
_retval = NS_LITERAL_STRING(kDestInboxFolderName);
else
_retval = aFolderName;
return NS_OK;
}
nsresult
nsAutoCompleteController::CompleteValue(nsString &aValue)
/* mInput contains mSearchString, which we want to autocomplete to aValue. If
* selectDifference is true, select the remaining portion of aValue not
* contained in mSearchString. */
{
const PRInt32 mSearchStringLength = mSearchString.Length();
PRInt32 endSelect = aValue.Length(); // By default, select all of aValue.
if (aValue.IsEmpty() ||
StringBeginsWith(aValue, mSearchString,
nsCaseInsensitiveStringComparator())) {
// aValue is empty (we were asked to clear mInput), or mSearchString
// matches the beginning of aValue. In either case we can simply
// autocomplete to aValue.
mInput->SetTextValue(aValue);
} else {
nsresult rv;
nsCOMPtr<nsIIOService> ios = do_GetService(NS_IOSERVICE_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
nsCAutoString scheme;
if (NS_SUCCEEDED(ios->ExtractScheme(NS_ConvertUTF16toUTF8(aValue), scheme))) {
// Trying to autocomplete a URI from somewhere other than the beginning.
// Only succeed if the missing portion is "http://"; otherwise do not
// autocomplete. This prevents us from "helpfully" autocompleting to a
// URI that isn't equivalent to what the user expected.
const PRInt32 findIndex = 7; // length of "http://"
if ((endSelect < findIndex + mSearchStringLength) ||
!scheme.LowerCaseEqualsLiteral("http") ||
!Substring(aValue, findIndex, mSearchStringLength).Equals(
mSearchString, nsCaseInsensitiveStringComparator())) {
return NS_OK;
}
mInput->SetTextValue(mSearchString +
Substring(aValue, mSearchStringLength + findIndex,
endSelect));
endSelect -= findIndex; // We're skipping this many characters of aValue.
} else {
// Autocompleting something other than a URI from the middle.
// Use the format "searchstring >> full string" to indicate to the user
// what we are going to replace their search string with.
mInput->SetTextValue(mSearchString + NS_LITERAL_STRING(" >> ") + aValue);
endSelect = mSearchString.Length() + 4 + aValue.Length();
}
}
mInput->SelectTextRange(mSearchStringLength, endSelect);
return NS_OK;
}
PRBool
nsAbAutoCompleteSession::CheckEntry(nsAbAutoCompleteSearchString* searchStr,
const PRUnichar* nickName,
const PRUnichar* displayName,
const PRUnichar* firstName,
const PRUnichar* lastName,
const PRUnichar* emailAddress)
{
const PRUnichar * fullString;
PRUint32 fullStringLen;
PRBool isAMatch = PR_FALSE;
if (searchStr->mFirstPartLen > 0 && searchStr->mSecondPartLen == 0)
{
fullString = searchStr->mFirstPart;
fullStringLen = searchStr->mFirstPartLen;
}
else
{
fullString = searchStr->mFullString;
fullStringLen = searchStr->mFullStringLen;
}
nsDependentString fullStringStr(fullString, fullStringLen);
// Compare various properties looking for a match (exact or partial)
if ( (nickName &&
fullStringStr.Equals(nsDependentString(nickName), nsCaseInsensitiveStringComparator())) ||
(displayName &&
fullStringStr.Equals(nsDependentString(displayName), nsCaseInsensitiveStringComparator())) ||
(firstName &&
fullStringStr.Equals(nsDependentString(firstName), nsCaseInsensitiveStringComparator())) ||
(lastName &&
fullStringStr.Equals(nsDependentString(lastName), nsCaseInsensitiveStringComparator())) ||
(emailAddress &&
fullStringStr.Equals(nsDependentString(emailAddress), nsCaseInsensitiveStringComparator())) ||
(nickName && CommonPrefix(nickName, fullString, fullStringLen)) ||
(displayName && CommonPrefix(displayName, fullString, fullStringLen)) ||
(firstName && CommonPrefix(firstName, fullString, fullStringLen)) ||
(lastName && CommonPrefix(lastName, fullString, fullStringLen)) ||
(emailAddress && CommonPrefix(emailAddress, fullString, fullStringLen)) )
isAMatch = PR_TRUE;
//If we have a muti-part search string, look for a partial match with first name and last name or reverse
else if (searchStr->mFirstPartLen && searchStr->mSecondPartLen)
{
if (((firstName && CommonPrefix(firstName, searchStr->mFirstPart, searchStr->mFirstPartLen)) &&
(lastName && CommonPrefix(lastName, searchStr->mSecondPart, searchStr->mSecondPartLen))) ||
((lastName && CommonPrefix(lastName, searchStr->mFirstPart, searchStr->mFirstPartLen)) &&
(firstName && CommonPrefix(firstName, searchStr->mSecondPart, searchStr->mSecondPartLen))))
isAMatch = PR_TRUE;
}
return isAMatch;
}
NS_IMETHODIMP ImportOutlookMailImpl::TranslateFolderName(const nsAString & aFolderName, nsAString & _retval)
{
if (aFolderName.Equals(NS_LITERAL_STRING("Deleted Items"), nsCaseInsensitiveStringComparator()))
_retval = NS_LITERAL_STRING(kDestTrashFolderName);
else if (aFolderName.Equals(NS_LITERAL_STRING("Sent Items"), nsCaseInsensitiveStringComparator()))
_retval = NS_LITERAL_STRING(kDestSentFolderName);
else if (aFolderName.Equals(NS_LITERAL_STRING("Outbox"), nsCaseInsensitiveStringComparator()))
_retval = NS_LITERAL_STRING(kDestUnsentMessagesFolderName);
else
_retval = aFolderName;
return NS_OK;
}
nsresult nsDateTimeFormatMac::Initialize(nsILocale* locale)
{
nsAutoString localeStr;
nsAutoString category(NS_LITERAL_STRING("NSILOCALE_TIME"));
nsresult res;
// use cached info if match with stored locale
if (nullptr == locale) {
if (!mLocale.IsEmpty() &&
mLocale.Equals(mAppLocale, nsCaseInsensitiveStringComparator())) {
return NS_OK;
}
}
else {
res = locale->GetCategory(category, localeStr);
if (NS_SUCCEEDED(res) && !localeStr.IsEmpty()) {
if (!mLocale.IsEmpty() &&
mLocale.Equals(localeStr,
nsCaseInsensitiveStringComparator())) {
return NS_OK;
}
}
}
// get application locale
nsCOMPtr<nsILocaleService> localeService =
do_GetService(NS_LOCALESERVICE_CONTRACTID, &res);
if (NS_SUCCEEDED(res)) {
nsCOMPtr<nsILocale> appLocale;
res = localeService->GetApplicationLocale(getter_AddRefs(appLocale));
if (NS_SUCCEEDED(res)) {
res = appLocale->GetCategory(category, localeStr);
if (NS_SUCCEEDED(res) && !localeStr.IsEmpty()) {
mAppLocale = localeStr; // cache app locale name
}
}
}
// use app default if no locale specified
if (nullptr == locale) {
mUseDefaultLocale = true;
}
else {
mUseDefaultLocale = false;
res = locale->GetCategory(category, localeStr);
}
if (NS_SUCCEEDED(res) && !localeStr.IsEmpty()) {
mLocale.Assign(localeStr); // cache locale name
}
return res;
}
// init this interface to a specified locale
nsresult nsDateTimeFormatWin::Initialize(nsILocale* locale)
{
nsAutoString localeStr;
nsresult res = NS_OK;
// use cached info if match with stored locale
if (!locale) {
if (!mLocale.IsEmpty() &&
mLocale.Equals(mAppLocale, nsCaseInsensitiveStringComparator())) {
return NS_OK;
}
}
else {
res = locale->GetCategory(NS_LITERAL_STRING("NSILOCALE_TIME"), localeStr);
if (NS_SUCCEEDED(res) && !localeStr.IsEmpty()) {
if (!mLocale.IsEmpty() &&
mLocale.Equals(localeStr, nsCaseInsensitiveStringComparator())) {
return NS_OK;
}
}
}
// default LCID (en-US)
mLCID = 1033;
// get locale string, use app default if no locale specified
if (!locale) {
nsCOMPtr<nsILocaleService> localeService =
do_GetService(NS_LOCALESERVICE_CONTRACTID);
if (localeService) {
nsCOMPtr<nsILocale> appLocale;
res = localeService->GetApplicationLocale(getter_AddRefs(appLocale));
if (NS_SUCCEEDED(res)) {
res = appLocale->GetCategory(NS_LITERAL_STRING("NSILOCALE_TIME"),
localeStr);
if (NS_SUCCEEDED(res) && !localeStr.IsEmpty()) {
mAppLocale.Assign(localeStr); // cache app locale name
}
}
}
}
else {
res = locale->GetCategory(NS_LITERAL_STRING("NSILOCALE_TIME"), localeStr);
}
// Get LCID and charset name from locale, if available
if (NS_SUCCEEDED(res) && !localeStr.IsEmpty()) {
mLocale.Assign(localeStr); // cache locale name
res = nsWin32Locale::GetPlatformLocale(mLocale, (LCID *) &mLCID);
}
return res;
}
void
nsTextBoxFrame::UpdateAccessIndex()
{
PRInt32 menuAccessKey;
nsMenuBarListener::GetMenuAccessKey(&menuAccessKey);
if (menuAccessKey) {
if (mAccessKey.IsEmpty()) {
if (mAccessKeyInfo) {
delete mAccessKeyInfo;
mAccessKeyInfo = nsnull;
}
} else {
if (!mAccessKeyInfo) {
mAccessKeyInfo = new nsAccessKeyInfo();
if (!mAccessKeyInfo)
return;
}
nsAString::const_iterator start, end;
mCroppedTitle.BeginReading(start);
mCroppedTitle.EndReading(end);
// remember the beginning of the string
nsAString::const_iterator originalStart = start;
PRBool found;
if (!AlwaysAppendAccessKey()) {
// not appending access key - do case-sensitive search
// first
found = FindInReadable(mAccessKey, start, end);
if (!found) {
// didn't find it - perform a case-insensitive search
start = originalStart;
found = FindInReadable(mAccessKey, start, end,
nsCaseInsensitiveStringComparator());
}
} else {
found = RFindInReadable(mAccessKey, start, end,
nsCaseInsensitiveStringComparator());
}
if (found)
mAccessKeyInfo->mAccesskeyIndex = Distance(originalStart, start);
else
mAccessKeyInfo->mAccesskeyIndex = kNotFound;
}
}
}
void CMapiFolderList::EnsureUniqueName( CMapiFolder *pFolder)
{
// For everybody in the array before me with the SAME
// depth, my name must be unique
CMapiFolder * pCurrent;
int i;
BOOL done;
nsString name;
nsString cName;
pFolder->GetDisplayName( name);
do {
done = TRUE;
i = m_array.Count() - 1;
while (i >= 0) {
pCurrent = (CMapiFolder *)GetAt(i);
if (pCurrent->GetDepth() == pFolder->GetDepth()) {
pCurrent->GetDisplayName(cName);
if (cName.Equals(name, nsCaseInsensitiveStringComparator())) {
ChangeName(name);
pFolder->SetDisplayName(name.get());
done = FALSE;
break;
}
}
else if (pCurrent->GetDepth() < pFolder->GetDepth())
break;
i--;
}
} while (!done);
}
int32_t
XULSortServiceImpl::CompareValues(const nsAString& aLeft,
const nsAString& aRight,
uint32_t aSortHints)
{
if (aSortHints & SORT_INTEGER) {
nsresult err;
int32_t leftint = PromiseFlatString(aLeft).ToInteger(&err);
if (NS_SUCCEEDED(err)) {
int32_t rightint = PromiseFlatString(aRight).ToInteger(&err);
if (NS_SUCCEEDED(err)) {
return leftint - rightint;
}
}
// if they aren't integers, just fall through and compare strings
}
if (aSortHints & SORT_COMPARECASE) {
return ::Compare(aLeft, aRight);
}
nsICollation* collation = nsXULContentUtils::GetCollation();
if (collation) {
int32_t result;
collation->CompareString(nsICollation::kCollationCaseInSensitive,
aLeft, aRight, &result);
return result;
}
return ::Compare(aLeft, aRight, nsCaseInsensitiveStringComparator());
}
PRInt32
nsCertTree::CmpByCrit(nsIX509Cert *a, CompareCacheHashEntry *ace,
nsIX509Cert *b, CompareCacheHashEntry *bce,
sortCriterion crit, PRInt32 level)
{
NS_ENSURE_TRUE( (a!=0 && ace!=0 && b!=0 && bce!=0), 0 );
if (!ace->mCritInit[level]) {
CmpInitCriterion(a, ace, crit, level);
}
if (!bce->mCritInit[level]) {
CmpInitCriterion(b, bce, crit, level);
}
nsXPIDLString &str_a = ace->mCrit[level];
nsXPIDLString &str_b = bce->mCrit[level];
PRInt32 result;
if (str_a && str_b)
result = Compare(str_a, str_b, nsCaseInsensitiveStringComparator());
else
result = !str_a ? (!str_b ? 0 : -1) : 1;
if (sort_IssuedDateDescending == crit)
result *= -1; // reverse compare order
return result;
}
PRBool
nsXTFElementWrapper::AttrValueIs(PRInt32 aNameSpaceID,
nsIAtom* aName,
nsIAtom* aValue,
nsCaseTreatment aCaseSensitive) const
{
NS_ASSERTION(aName, "Must have attr name");
NS_ASSERTION(aNameSpaceID != kNameSpaceID_Unknown, "Must have namespace");
NS_ASSERTION(aValue, "Null value atom");
if (aNameSpaceID == kNameSpaceID_None && HandledByInner(aName)) {
nsAutoString ourVal;
if (!GetAttr(aNameSpaceID, aName, ourVal)) {
return PR_FALSE;
}
if (aCaseSensitive == eCaseMatters) {
return aValue->Equals(ourVal);
}
nsAutoString val;
aValue->ToString(val);
return val.Equals(ourVal, nsCaseInsensitiveStringComparator());
}
return nsXTFElementWrapperBase::AttrValueIs(aNameSpaceID, aName, aValue,
aCaseSensitive);
}
bool nsFont::BaseEquals(const nsFont& aOther) const
{
if ((style == aOther.style) &&
(systemFont == aOther.systemFont) &&
(weight == aOther.weight) &&
(stretch == aOther.stretch) &&
(size == aOther.size) &&
(sizeAdjust == aOther.sizeAdjust) &&
name.Equals(aOther.name, nsCaseInsensitiveStringComparator()) &&
(kerning == aOther.kerning) &&
(synthesis == aOther.synthesis) &&
(fontFeatureSettings == aOther.fontFeatureSettings) &&
(languageOverride == aOther.languageOverride) &&
(variantAlternates == aOther.variantAlternates) &&
(variantCaps == aOther.variantCaps) &&
(variantEastAsian == aOther.variantEastAsian) &&
(variantLigatures == aOther.variantLigatures) &&
(variantNumeric == aOther.variantNumeric) &&
(variantPosition == aOther.variantPosition) &&
(alternateValues == aOther.alternateValues) &&
(featureValueLookup == aOther.featureValueLookup) &&
(smoothing == aOther.smoothing)) {
return true;
}
return false;
}
PRInt32
nsXTFElementWrapper::FindAttrValueIn(PRInt32 aNameSpaceID,
nsIAtom* aName,
AttrValuesArray* aValues,
nsCaseTreatment aCaseSensitive) const
{
NS_ASSERTION(aName, "Must have attr name");
NS_ASSERTION(aNameSpaceID != kNameSpaceID_Unknown, "Must have namespace");
NS_ASSERTION(aValues, "Null value array");
if (aNameSpaceID == kNameSpaceID_None && HandledByInner(aName)) {
nsAutoString ourVal;
if (!GetAttr(aNameSpaceID, aName, ourVal)) {
return ATTR_MISSING;
}
for (PRInt32 i = 0; aValues[i]; ++i) {
if (aCaseSensitive == eCaseMatters) {
if ((*aValues[i])->Equals(ourVal)) {
return i;
}
} else {
nsAutoString val;
(*aValues[i])->ToString(val);
if (val.Equals(ourVal, nsCaseInsensitiveStringComparator())) {
return i;
}
}
}
return ATTR_VALUE_NO_MATCH;
}
return nsXTFElementWrapperBase::FindAttrValueIn(aNameSpaceID, aName, aValues,
aCaseSensitive);
}
bool
mozTXTToHTMLConv::ItMatchesDelimited(const PRUnichar * aInString,
PRInt32 aInLength, const PRUnichar* rep, PRInt32 aRepLen,
LIMTYPE before, LIMTYPE after)
{
// this little method gets called a LOT. I found we were spending a
// lot of time just calculating the length of the variable "rep"
// over and over again every time we called it. So we're now passing
// an integer in here.
PRInt32 textLen = aInLength;
if
(
((before == LT_IGNORE && (after == LT_IGNORE || after == LT_DELIMITER))
&& textLen < aRepLen) ||
((before != LT_IGNORE || (after != LT_IGNORE && after != LT_DELIMITER))
&& textLen < aRepLen + 1) ||
(before != LT_IGNORE && after != LT_IGNORE && after != LT_DELIMITER
&& textLen < aRepLen + 2)
)
return false;
PRUnichar text0 = aInString[0];
PRUnichar textAfterPos = aInString[aRepLen + (before == LT_IGNORE ? 0 : 1)];
if
(
(before == LT_ALPHA
&& !nsCRT::IsAsciiAlpha(text0)) ||
(before == LT_DIGIT
&& !nsCRT::IsAsciiDigit(text0)) ||
(before == LT_DELIMITER
&&
(
nsCRT::IsAsciiAlpha(text0) ||
nsCRT::IsAsciiDigit(text0) ||
text0 == *rep
)) ||
(after == LT_ALPHA
&& !nsCRT::IsAsciiAlpha(textAfterPos)) ||
(after == LT_DIGIT
&& !nsCRT::IsAsciiDigit(textAfterPos)) ||
(after == LT_DELIMITER
&&
(
nsCRT::IsAsciiAlpha(textAfterPos) ||
nsCRT::IsAsciiDigit(textAfterPos) ||
textAfterPos == *rep
)) ||
!Substring(Substring(aInString, aInString+aInLength),
(before == LT_IGNORE ? 0 : 1),
aRepLen).Equals(Substring(rep, rep+aRepLen),
nsCaseInsensitiveStringComparator())
)
return false;
return true;
}
PRBool nsAbIPCCard::CompareValue(PRBool isUnicode, LPTSTR cardValue, nsString & attribValue)
{
if(cardValue) {
if(isUnicode) {
if (Compare(nsDependentString(cardValue), attribValue, nsCaseInsensitiveStringComparator()))
return PR_FALSE;
}
else {
nsAutoString str;
CONVERT_ASSIGNTO_UNICODE(str, cardValue, PR_TRUE);
if (Compare(str, attribValue, nsCaseInsensitiveStringComparator()))
return PR_FALSE;
}
}
return PR_TRUE;
}
static PRBool
rdf_RequiresAbsoluteURI(const nsString& uri)
{
// cheap shot at figuring out if this requires an absolute url translation
return !(StringBeginsWith(uri, NS_LITERAL_STRING("urn:")) ||
StringBeginsWith(uri, NS_LITERAL_STRING("chrome:")) ||
StringBeginsWith(uri, NS_LITERAL_STRING("nc:"),
nsCaseInsensitiveStringComparator()));
}
static PRBool CommonPrefix(const PRUnichar *aString, const PRUnichar *aSubstr, PRInt32 aSubstrLen)
{
if (!aSubstrLen || (nsCRT::strlen(aString) < NS_STATIC_CAST(PRUint32, aSubstrLen)))
return PR_FALSE;
return (Substring(aString,
aString+aSubstrLen).Equals(Substring(aSubstr, aSubstr+aSubstrLen),
nsCaseInsensitiveStringComparator()));
}
bool
WMFDecoderModule::ShouldUseDXVA(const VideoInfo& aConfig) const
{
static bool isAMD = false;
static bool initialized = false;
if (!initialized) {
nsCOMPtr<nsIGfxInfo> gfxInfo = services::GetGfxInfo();
nsAutoString vendor;
gfxInfo->GetAdapterVendorID(vendor);
isAMD = vendor.Equals(widget::GfxDriverInfo::GetDeviceVendor(widget::VendorAMD), nsCaseInsensitiveStringComparator()) ||
vendor.Equals(widget::GfxDriverInfo::GetDeviceVendor(widget::VendorATI), nsCaseInsensitiveStringComparator());
initialized = true;
}
if (!isAMD) {
return true;
}
// Don't use DXVA for 4k videos or above, since it seems to perform poorly.
return aConfig.mDisplay.width <= 1920 && aConfig.mDisplay.height <= 1200;
}
nsresult
nsAutoCompleteController::GetDefaultCompleteValue(PRInt32 aSearchIndex,
PRBool aPreserveCasing,
nsAString &_retval)
{
PRInt32 defaultIndex = -1;
PRInt32 index = aSearchIndex;
if (index < 0) {
PRUint32 count = mResults.Count();
for (PRUint32 i = 0; i < count; ++i) {
nsIAutoCompleteResult *result = mResults[i];
if (result && NS_SUCCEEDED(result->GetDefaultIndex(&defaultIndex)) &&
defaultIndex >= 0) {
index = i;
break;
}
}
}
NS_ENSURE_TRUE(index >= 0, NS_ERROR_FAILURE);
nsIAutoCompleteResult *result = mResults.SafeObjectAt(index);
NS_ENSURE_TRUE(result != nsnull, NS_ERROR_FAILURE);
if (defaultIndex < 0) {
// The search must explicitly provide a default index in order
// for us to be able to complete.
result->GetDefaultIndex(&defaultIndex);
}
NS_ENSURE_TRUE(defaultIndex >= 0, NS_ERROR_FAILURE);
nsAutoString resultValue;
result->GetValueAt(defaultIndex, resultValue);
if (aPreserveCasing &&
StringBeginsWith(resultValue, mSearchString,
nsCaseInsensitiveStringComparator())) {
// We try to preserve user casing, otherwise we would end up changing
// the case of what he typed, if we have a result with a different casing.
// For example if we have result "Test", and user starts writing "tuna",
// after digiting t, we would convert it to T trying to autocomplete "Test".
// We will still complete to cased "Test" if the user explicitely choose
// that result, by either selecting it in the results popup, or with
// keyboard navigation or if autocompleting in the middle.
nsAutoString casedResultValue;
casedResultValue.Assign(mSearchString);
// Use what the user has typed so far.
casedResultValue.Append(Substring(resultValue,
mSearchString.Length(),
resultValue.Length()));
_retval = casedResultValue;
}
else
_retval = resultValue;
return NS_OK;
}
// caller passes in upgrading==true if they want back a db even if the db is out of date.
// If so, they'll extract out the interesting info from the db, close it, delete it, and
// then try to open the db again, prior to reparsing.
nsresult nsMailDatabase::Open(nsIFile *aSummaryFile, bool aCreate,
bool aUpgrading)
{
#ifdef DEBUG
nsString leafName;
aSummaryFile->GetLeafName(leafName);
if (!StringEndsWith(leafName, NS_LITERAL_STRING(".msf"),
nsCaseInsensitiveStringComparator()))
NS_ERROR("non summary file passed into open\n");
#endif
return nsMsgDatabase::Open(aSummaryFile, aCreate, aUpgrading);
}
// the following block is to append the accesskey to mTitle if there is an accesskey
// but the mTitle doesn't have the character
void
nsTextBoxFrame::UpdateAccessTitle()
{
/*
* Note that if you change appending access key label spec,
* you need to maintain same logic in following methods. See bug 324159.
* toolkit/content/commonDialog.js (setLabelForNode)
* toolkit/content/widgets/text.xml (formatAccessKey)
*/
PRInt32 menuAccessKey;
nsMenuBarListener::GetMenuAccessKey(&menuAccessKey);
if (!menuAccessKey || mAccessKey.IsEmpty())
return;
if (!AlwaysAppendAccessKey() &&
FindInReadable(mAccessKey, mTitle, nsCaseInsensitiveStringComparator()))
return;
nsAutoString accessKeyLabel;
accessKeyLabel += '(';
accessKeyLabel += mAccessKey;
ToUpperCase(accessKeyLabel);
accessKeyLabel += ')';
if (mTitle.IsEmpty()) {
mTitle = accessKeyLabel;
return;
}
const nsDependentString& kEllipsis = nsContentUtils::GetLocalizedEllipsis();
PRUint32 offset = mTitle.Length();
if (StringEndsWith(mTitle, kEllipsis)) {
offset -= kEllipsis.Length();
} else if (StringEndsWith(mTitle, OLD_ELLIPSIS)) {
// Try to check with our old ellipsis (for old addons)
offset -= OLD_ELLIPSIS.Length();
} else {
// Try to check with
// our default ellipsis (for non-localized addons) or ':'
const PRUnichar kLastChar = mTitle.Last();
if (kLastChar == PRUnichar(0x2026) || kLastChar == PRUnichar(':'))
offset--;
}
if (InsertSeparatorBeforeAccessKey() &&
offset > 0 && !NS_IS_SPACE(mTitle[offset - 1])) {
mTitle.Insert(' ', offset);
offset++;
}
mTitle.Insert(accessKeyLabel, offset);
}
PRBool nsAbIPCCard::Same(nsIAbCard *card)
{
if(!card)
return PR_FALSE;
nsresult rv;
nsCOMPtr<nsIAbMDBCard> dbCard;
dbCard = do_QueryInterface(card, &rv);
if(NS_SUCCEEDED(rv)) {
// first check the palmID for the cards if they exist
nsXPIDLString palmIDStr;
rv = dbCard->GetStringAttribute(CARD_ATTRIB_PALMID, getter_Copies(palmIDStr));
if(NS_SUCCEEDED(rv) && palmIDStr.get()) {
PRInt32 palmID=0;
PRFloat64 f = PR_strtod(NS_LossyConvertUCS2toASCII(palmIDStr).get(), nsnull);
PRInt64 l;
LL_D2L(l, f);
LL_L2UI(palmID, l);
if(palmID && mRecordId)
return mRecordId == palmID;
}
}
nsXPIDLString str;
card->GetFirstName(getter_Copies(str));
if (Compare(str, m_FirstName, nsCaseInsensitiveStringComparator()))
return PR_FALSE;
card->GetLastName(getter_Copies(str));
if (Compare(str, m_LastName, nsCaseInsensitiveStringComparator()))
return PR_FALSE;
card->GetDisplayName(getter_Copies(str));
if (Compare(str, m_DisplayName, nsCaseInsensitiveStringComparator()))
return PR_FALSE;
card->GetNickName(getter_Copies(str));
if (Compare(str, m_NickName, nsCaseInsensitiveStringComparator()))
return PR_FALSE;
return PR_TRUE;
}
int32_t os2Printers::GetPrinterIndex(const char16_t* aPrinterName)
{
ULONG index;
for (index = 0; index < mQueueCount; index++) {
if (mPQBuf[index]->PrinterTitle()->Equals(aPrinterName, nsCaseInsensitiveStringComparator()))
break;
}
if (index >= mQueueCount)
return -1;
return index;
}
NS_METHOD nsKeygenFormProcessor::ProvideContent(const nsAString& aFormType,
nsTArray<nsString>& aContent,
nsAString& aAttribute)
{
if (Compare(aFormType, NS_LITERAL_STRING("SELECT"),
nsCaseInsensitiveStringComparator()) == 0) {
for (size_t i = 0; i < number_of_key_size_choices; ++i) {
aContent.AppendElement(mSECKeySizeChoiceList[i].name);
}
aAttribute.AssignLiteral("-mozilla-keygen");
}
return NS_OK;
}
PRBool nsFont::BaseEquals(const nsFont& aOther) const
{
if ((style == aOther.style) &&
(systemFont == aOther.systemFont) &&
(familyNameQuirks == aOther.familyNameQuirks) &&
(weight == aOther.weight) &&
(stretch == aOther.stretch) &&
(size == aOther.size) &&
(sizeAdjust == aOther.sizeAdjust) &&
name.Equals(aOther.name, nsCaseInsensitiveStringComparator())) {
return PR_TRUE;
}
return PR_FALSE;
}
bool nsFont::BaseEquals(const nsFont& aOther) const
{
if ((style == aOther.style) &&
(systemFont == aOther.systemFont) &&
(weight == aOther.weight) &&
(stretch == aOther.stretch) &&
(size == aOther.size) &&
(sizeAdjust == aOther.sizeAdjust) &&
name.Equals(aOther.name, nsCaseInsensitiveStringComparator()) &&
(featureSettings == aOther.featureSettings) &&
(languageOverride == aOther.languageOverride)) {
return true;
}
return false;
}
/* helper routine. Iterate over the passed in settings object. */
bool
nsWindowsShellService::TestForDefault(SETTING aSettings[], int32_t aSize)
{
bool isDefault = true;
char16_t currValue[MAX_BUF];
SETTING* end = aSettings + aSize;
for (SETTING * settings = aSettings; settings < end; ++settings)
{
NS_ConvertUTF8toUTF16 dataLongPath(settings->valueData);
NS_ConvertUTF8toUTF16 key(settings->keyName);
NS_ConvertUTF8toUTF16 value(settings->valueName);
if (settings->flags & APP_PATH_SUBSTITUTION)
{
int32_t offset = dataLongPath.Find("%APPPATH%");
dataLongPath.Replace(offset, 9, mAppLongPath);
}
::ZeroMemory(currValue, sizeof(currValue));
HKEY theKey;
nsresult rv = OpenKeyForReading(HKEY_CLASSES_ROOT, key, &theKey);
if (NS_FAILED(rv))
{
// Key doesn't exist
isDefault = false;
break;
}
DWORD len = sizeof currValue;
DWORD result = ::RegQueryValueExW(theKey, value.get(),
NULL, NULL, (LPBYTE)currValue, &len);
// Close the key we opened.
::RegCloseKey(theKey);
if (REG_FAILED(result) ||
!dataLongPath.Equals(currValue, nsCaseInsensitiveStringComparator()))
{
// Key wasn't set, or was set to something else (something else became the default client)
isDefault = false;
break;
}
} // for each registry key we want to look at
return isDefault;
}
// answers true if aValue is in the string list of white-space separated values aValueList
// a case-sensitive search is performed if aCaseSensitive is true
bool
ChangeCSSInlineStyleTxn::ValueIncludes(const nsAString &aValueList, const nsAString &aValue, bool aCaseSensitive)
{
nsAutoString valueList(aValueList);
bool result = false;
valueList.Append(kNullCh); // put an extra null at the end
PRUnichar *value = ToNewUnicode(aValue);
PRUnichar *start = valueList.BeginWriting();
PRUnichar *end = start;
while (kNullCh != *start) {
while ((kNullCh != *start) && nsCRT::IsAsciiSpace(*start)) { // skip leading space
start++;
}
end = start;
while ((kNullCh != *end) && (false == nsCRT::IsAsciiSpace(*end))) { // look for space or end
end++;
}
*end = kNullCh; // end string here
if (start < end) {
if (aCaseSensitive) {
if (!nsCRT::strcmp(value, start)) {
result = true;
break;
}
}
else {
if (nsDependentString(value).Equals(nsDependentString(start),
nsCaseInsensitiveStringComparator())) {
result = true;
break;
}
}
}
start = ++end;
}
NS_Free(value);
return result;
}
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();
}