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(); }