NS_IMETHODIMP nsInternetCiter::Rewrap(const nsAString& aInString, PRUint32 aWrapCol, PRUint32 aFirstLineOffset, PRBool aRespectNewlines, nsAString& aOutString) { // There shouldn't be returns in this string, only dom newlines. // Check to make sure: #ifdef DEBUG PRInt32 cr = aInString.FindChar(PRUnichar('\r')); NS_ASSERTION((cr < 0), "Rewrap: CR in string gotten from DOM!\n"); #endif /* DEBUG */ aOutString.Truncate(); nsCOMPtr<nsILineBreaker> lineBreaker; nsILineBreakerFactory *lf; nsresult rv; rv = CallGetService(NS_LWBRK_CONTRACTID, &lf); if (NS_SUCCEEDED(rv)) { nsAutoString lbarg; lf->GetBreaker(lbarg, getter_AddRefs(lineBreaker)); NS_RELEASE(lf); } // Loop over lines in the input string, rewrapping each one. PRUint32 length; PRUint32 posInString = 0; PRUint32 outStringCol = 0; PRUint32 citeLevel = 0; const nsPromiseFlatString &tString = PromiseFlatString(aInString); length = tString.Length(); #ifdef DEBUG_wrapping int loopcount = 0; #endif while (posInString < length) { #ifdef DEBUG_wrapping printf("Outer loop: '%s'\n", NS_LossyConvertUCS2toASCII(Substring(tString, posInString, length-posInString)).get()); printf("out string is now: '%s'\n", NS_LossyConvertUCS2toASCII(aOutString).get()); #endif // Get the new cite level here since we're at the beginning of a line PRUint32 newCiteLevel = 0; while (posInString < length && tString[posInString] == gt) { ++newCiteLevel; ++posInString; while (posInString < length && tString[posInString] == space) ++posInString; } if (posInString >= length) break; // Special case: if this is a blank line, maintain a blank line // (retain the original paragraph breaks) if (tString[posInString] == nl && !aOutString.IsEmpty()) { if (aOutString.Last() != nl) aOutString.Append(nl); AddCite(aOutString, newCiteLevel); aOutString.Append(nl); ++posInString; outStringCol = 0; continue; } // If the cite level has changed, then start a new line with the // new cite level (but if we're at the beginning of the string, // don't bother). if (newCiteLevel != citeLevel && posInString > newCiteLevel+1 && outStringCol != 0) { BreakLine(aOutString, outStringCol, 0); } citeLevel = newCiteLevel; // Prepend the quote level to the out string if appropriate if (outStringCol == 0) { AddCite(aOutString, citeLevel); outStringCol = citeLevel + (citeLevel ? 1 : 0); } // If it's not a cite, and we're not at the beginning of a line in // the output string, add a space to separate new text from the // previous text. else if (outStringCol > citeLevel) { aOutString.Append(space); ++outStringCol; } // find the next newline -- don't want to go farther than that PRInt32 nextNewline = tString.FindChar(nl, posInString); if (nextNewline < 0) nextNewline = length; // For now, don't wrap unquoted lines at all. // This is because the plaintext edit window has already wrapped them // by the time we get them for rewrap, yet when we call the line // breaker, it will refuse to break backwards, and we'll end up // with a line that's too long and gets displayed as a lone word // on a line by itself. Need special logic to detect this case // and break it ourselves without resorting to the line breaker. if (citeLevel == 0) { aOutString.Append(Substring(tString, posInString, nextNewline-posInString)); outStringCol += nextNewline - posInString; if (nextNewline != (PRInt32)length) { aOutString.Append(nl); outStringCol = 0; } posInString = nextNewline+1; continue; } // Otherwise we have to use the line breaker and loop // over this line of the input string to get all of it: while ((PRInt32)posInString < nextNewline) { #ifdef DEBUG_wrapping if (++loopcount > 1000) NS_ASSERTION(PR_FALSE, "possible infinite loop in nsInternetCiter\n"); printf("Inner loop: '%s'\n", NS_LossyConvertUCS2toASCII(Substring(tString, posInString, nextNewline-posInString)).get()); #endif // Skip over initial spaces: while ((PRInt32)posInString < nextNewline && nsCRT::IsAsciiSpace(tString[posInString])) ++posInString; // If this is a short line, just append it and continue: if (outStringCol + nextNewline - posInString <= aWrapCol-citeLevel-1) { // If this short line is the final one in the in string, // then we need to include the final newline, if any: if (nextNewline+1 == (PRInt32)length && tString[nextNewline-1] == nl) ++nextNewline; // Trim trailing spaces: PRInt32 lastRealChar = nextNewline; while ((PRUint32)lastRealChar > posInString && nsCRT::IsAsciiSpace(tString[lastRealChar-1])) --lastRealChar; aOutString += Substring(tString, posInString, lastRealChar - posInString); outStringCol += lastRealChar - posInString; posInString = nextNewline + 1; continue; } PRInt32 eol = posInString + aWrapCol - citeLevel - outStringCol; // eol is the prospective end of line. // We'll first look backwards from there for a place to break. // If it's already less than our current position, // then our line is already too long, so break now. if (eol <= (PRInt32)posInString) { BreakLine(aOutString, outStringCol, citeLevel); continue; // continue inner loop, with outStringCol now at bol } PRUint32 breakPt; rv = NS_ERROR_BASE; if (lineBreaker) { PRBool needMore; rv = lineBreaker->Prev(tString.get() + posInString, length - posInString, eol + 1 - posInString, &breakPt, &needMore); if (NS_FAILED(rv) || needMore) { // if we couldn't find a breakpoint looking backwards, // and we're not starting a new line, then end this line // and loop around again: if (outStringCol > citeLevel + 1) { BreakLine(aOutString, outStringCol, citeLevel); continue; // continue inner loop, with outStringCol now at bol } // Else try looking forwards: rv = lineBreaker->Next(tString.get() + posInString, length - posInString, eol - posInString, &breakPt, &needMore); if (needMore) rv = NS_ERROR_BASE; } } // If rv is okay, then breakPt is the place to break. // If we get out here and rv is set, something went wrong with line // breaker. Just break the line, hard. if (NS_FAILED(rv)) { #ifdef DEBUG_akkana printf("nsInternetCiter: LineBreaker not working -- breaking hard\n"); #endif breakPt = eol; } // Special case: maybe we should have wrapped last time. // If the first breakpoint here makes the current line too long, // then if we already have text on the current line, // break and loop around again. // If we're at the beginning of the current line, though, // don't force a break since the long word might be a url // and breaking it would make it unclickable on the other end. const int SLOP = 6; if (outStringCol + breakPt > aWrapCol + SLOP && outStringCol > citeLevel+1) { BreakLine(aOutString, outStringCol, citeLevel); continue; } nsAutoString sub (Substring(tString, posInString, breakPt)); // skip newlines or whitespace at the end of the string PRInt32 subend = sub.Length(); while (subend > 0 && IsSpace(sub[subend-1])) --subend; sub.Left(sub, subend); aOutString += sub; outStringCol += sub.Length(); // Advance past the whitespace which caused the wrap: posInString += breakPt; while (posInString < length && IsSpace(tString[posInString])) ++posInString; // Add a newline and the quote level to the out string if (posInString < length) // not for the last line, though BreakLine(aOutString, outStringCol, citeLevel); } // end inner loop within one line of aInString #ifdef DEBUG_wrapping printf("---------\nEnd inner loop: out string is now '%s'\n-----------\n", NS_LossyConvertUCS2toASCII(aOutString).get()); #endif } // end outer loop over lines of aInString #ifdef DEBUG_wrapping printf("Final out string is now: '%s'\n", NS_LossyConvertUCS2toASCII(aOutString).get()); #endif return NS_OK; }
void nsFont::CopyAlternates(const nsFont& aOther) { variantAlternates = aOther.variantAlternates; alternateValues = aOther.alternateValues; featureValueLookup = aOther.featureValueLookup; } static bool IsGenericFontFamily(const nsString& aFamily) { uint8_t generic; nsFont::GetGenericID(aFamily, &generic); return generic != kGenericFont_NONE; } const PRUnichar kSingleQuote = PRUnichar('\''); const PRUnichar kDoubleQuote = PRUnichar('\"'); const PRUnichar kComma = PRUnichar(','); bool nsFont::EnumerateFamilies(nsFontFamilyEnumFunc aFunc, void* aData) const { const PRUnichar *p, *p_end; name.BeginReading(p); name.EndReading(p_end); nsAutoString family; while (p < p_end) { while (nsCRT::IsAsciiSpace(*p)) if (++p == p_end) return true;
void GetReversedHostname(const nsString& aForward, nsString& aRevHost) { ReverseString(aForward, aRevHost); aRevHost.Append(PRUnichar('.')); }
nsresult nsRDFXMLSerializer::SerializeDescription(nsIOutputStream* aStream, nsIRDFResource* aResource) { nsresult rv; PRBool isTypedNode = PR_FALSE; nsCString typeQName; nsCOMPtr<nsIRDFNode> typeNode; mDataSource->GetTarget(aResource, kRDF_type, PR_TRUE, getter_AddRefs(typeNode)); if (typeNode) { nsCOMPtr<nsIRDFResource> type = do_QueryInterface(typeNode, &rv); if (type) { // Try to get a namespace prefix. If none is available, // just treat the description as if it weren't a typed node // after all and emit rdf:type as a normal property. This // seems preferable to using a bogus (invented) prefix. isTypedNode = NS_SUCCEEDED(GetQName(type, typeQName)); } } nsCAutoString uri; rv = aResource->GetValueUTF8(uri); if (NS_FAILED(rv)) return rv; rdf_MakeRelativeRef(mBaseURLSpec, uri); rdf_EscapeAttributeValue(uri); // Emit an open tag and the subject if (isTypedNode) { rv = rdf_BlockingWrite(aStream, NS_LITERAL_STRING(" <")); if (NS_FAILED(rv)) return rv; // Watch out for the default namespace! rv = rdf_BlockingWrite(aStream, typeQName); if (NS_FAILED(rv)) return rv; } else { rv = rdf_BlockingWrite(aStream, kRDFDescriptionOpen, sizeof(kRDFDescriptionOpen) - 1); if (NS_FAILED(rv)) return rv; } if (uri[0] == PRUnichar('#')) { uri.Cut(0, 1); rv = rdf_BlockingWrite(aStream, kIDAttr, sizeof(kIDAttr) - 1); } else { rv = rdf_BlockingWrite(aStream, kAboutAttr, sizeof(kAboutAttr) - 1); } if (NS_FAILED(rv)) return rv; uri.Append('"'); rv = rdf_BlockingWrite(aStream, uri); if (NS_FAILED(rv)) return rv; // Any value that's a literal we can write out as an inline // attribute on the RDF:Description nsAutoTArray<nsIRDFResource*, 8> visited; PRInt32 skipped = 0; nsCOMPtr<nsISimpleEnumerator> arcs; mDataSource->ArcLabelsOut(aResource, getter_AddRefs(arcs)); if (arcs) { // Don't re-serialize rdf:type later on if (isTypedNode) visited.AppendElement(kRDF_type); while (1) { PRBool hasMore = PR_FALSE; arcs->HasMoreElements(&hasMore); if (! hasMore) break; nsCOMPtr<nsISupports> isupports; arcs->GetNext(getter_AddRefs(isupports)); nsCOMPtr<nsIRDFResource> property = do_QueryInterface(isupports); if (! property) continue; // Ignore properties that pertain to containers; we may be // called from SerializeContainer() if the container resource // has been assigned non-container properties. if (IsContainerProperty(property)) continue; // Only serialize values for the property once. if (visited.Contains(property.get())) continue; visited.AppendElement(property.get()); SerializeProperty(aStream, aResource, property, PR_TRUE, &skipped); } } if (skipped) { // Close the RDF:Description tag. rv = rdf_BlockingWrite(aStream, NS_LITERAL_CSTRING(">\n")); if (NS_FAILED(rv)) return rv; // Now write out resources (which might have their own // substructure) as children. mDataSource->ArcLabelsOut(aResource, getter_AddRefs(arcs)); if (arcs) { // Forget that we've visited anything visited.Clear(); // ... except for rdf:type if (isTypedNode) visited.AppendElement(kRDF_type); while (1) { PRBool hasMore = PR_FALSE; arcs->HasMoreElements(&hasMore); if (! hasMore) break; nsCOMPtr<nsISupports> isupports; arcs->GetNext(getter_AddRefs(isupports)); nsCOMPtr<nsIRDFResource> property = do_QueryInterface(isupports); if (! property) continue; // Ignore properties that pertain to containers; we may be // called from SerializeContainer() if the container // resource has been assigned non-container properties. if (IsContainerProperty(property)) continue; // have we already seen this property? If so, don't write it // out again; serialize property will write each instance. if (visited.Contains(property.get())) continue; visited.AppendElement(property.get()); SerializeProperty(aStream, aResource, property, PR_FALSE, &skipped); } } // Emit a proper close-tag. if (isTypedNode) { rv = rdf_BlockingWrite(aStream, NS_LITERAL_CSTRING(" </")); if (NS_FAILED(rv)) return rv; // Watch out for the default namespace! rdf_BlockingWrite(aStream, typeQName); if (NS_FAILED(rv)) return rv; rdf_BlockingWrite(aStream, ">\n", 2); if (NS_FAILED(rv)) return rv; } else { rv = rdf_BlockingWrite(aStream, kRDFDescriptionClose, sizeof(kRDFDescriptionClose) - 1); if (NS_FAILED(rv)) return rv; } } else { // If we saw _no_ child properties, then we can don't need a // close-tag. rv = rdf_BlockingWrite(aStream, NS_LITERAL_CSTRING(" />\n")); if (NS_FAILED(rv)) return rv; } return NS_OK; }
// submission // much of this is cut and paste from nsFormFrame::OnSubmit NS_IMETHODIMP nsIsIndexFrame::OnSubmit(nsPresContext* aPresContext) { if (!mContent || !mInputContent) { return NS_ERROR_UNEXPECTED; } if (mContent->IsEditable()) { return NS_OK; } nsresult result = NS_OK; // Begin ProcessAsURLEncoded nsAutoString data; nsCOMPtr<nsIUnicodeEncoder> encoder; if(NS_FAILED(GetEncoder(getter_AddRefs(encoder)))) // Non-fatal error encoder = nsnull; nsAutoString value; GetInputValue(value); URLEncode(value, encoder, data); // End ProcessAsURLEncoded // make the url string nsAutoString href; // Get the document. // We'll need it now to form the URL we're submitting to. // We'll also need it later to get the DOM window when notifying form submit observers (bug 33203) nsCOMPtr<nsIDocument> document = mContent->GetDocument(); if (!document) return NS_OK; // No doc means don't submit, see Bug 28988 // Resolve url to an absolute url nsIURI *baseURI = document->GetDocBaseURI(); if (!baseURI) { NS_ERROR("No Base URL found in Form Submit!"); return NS_OK; // No base URL -> exit early, see Bug 30721 } // If an action is not specified and we are inside // a HTML document then reload the URL. This makes us // compatible with 4.x browsers. // If we are in some other type of document such as XML or // XUL, do nothing. This prevents undesirable reloading of // a document inside XUL. nsresult rv; nsCOMPtr<nsIHTMLDocument> htmlDoc; htmlDoc = do_QueryInterface(document, &rv); if (NS_FAILED(rv)) { // Must be a XML, XUL or other non-HTML document type // so do nothing. return NS_OK; } // Necko's MakeAbsoluteURI doesn't reuse the baseURL's rel path if it is // passed a zero length rel path. nsCAutoString relPath; baseURI->GetSpec(relPath); if (!relPath.IsEmpty()) { CopyUTF8toUTF16(relPath, href); // If re-using the same URL, chop off old query string (bug 25330) PRInt32 queryStart = href.FindChar('?'); if (kNotFound != queryStart) { href.Truncate(queryStart); } } else { NS_ERROR("Rel path couldn't be formed in form submit!"); return NS_ERROR_OUT_OF_MEMORY; } // Add the URI encoded form values to the URI // Get the scheme of the URI. nsCOMPtr<nsIURI> actionURL; nsXPIDLCString scheme; PRBool isJSURL = PR_FALSE; const nsACString &docCharset = document->GetDocumentCharacterSet(); const nsPromiseFlatCString& flatDocCharset = PromiseFlatCString(docCharset); if (NS_SUCCEEDED(result = NS_NewURI(getter_AddRefs(actionURL), href, flatDocCharset.get(), baseURI))) { result = actionURL->SchemeIs("javascript", &isJSURL); } // Append the URI encoded variable/value pairs for GET's if (!isJSURL) { // Not for JS URIs, see bug 26917 if (href.FindChar('?') == kNotFound) { // Add a ? if needed href.Append(PRUnichar('?')); } else { // Adding to existing query string if (href.Last() != '&' && href.Last() != '?') { // Add a & if needed href.Append(PRUnichar('&')); } } href.Append(data); } nsCOMPtr<nsIURI> uri; result = NS_NewURI(getter_AddRefs(uri), href, flatDocCharset.get(), baseURI); if (NS_FAILED(result)) return result; // Now pretend we're triggering a link nsContentUtils::TriggerLink(mContent, aPresContext, uri, EmptyString(), PR_TRUE, PR_TRUE); return result; }
PRBool nsCSSScanner::NextURL(nsresult& aErrorCode, nsCSSToken& aToken) { PRInt32 ch = Read(aErrorCode); if (ch < 0) { return PR_FALSE; } if (ch < 256) { PRUint8* lexTable = gLexTable; // STRING if ((ch == '"') || (ch == '\'')) { return ParseString(aErrorCode, ch, aToken); } // WS if ((lexTable[ch] & IS_WHITESPACE) != 0) { aToken.mType = eCSSToken_WhiteSpace; aToken.mIdent.Assign(PRUnichar(ch)); (void) EatWhiteSpace(aErrorCode); return PR_TRUE; } if (ch == '/') { PRInt32 nextChar = Peek(aErrorCode); if (nextChar == '*') { (void) Read(aErrorCode); #if 0 // If we change our storage data structures such that comments are // stored (for Editor), we should reenable this code, condition it // on being in editor mode, and apply glazou's patch from bug // 60290. aToken.mIdent.SetCapacity(2); aToken.mIdent.Assign(PRUnichar(ch)); aToken.mIdent.Append(PRUnichar(nextChar)); return ParseCComment(aErrorCode, aToken); #endif return SkipCComment(aErrorCode) && Next(aErrorCode, aToken); } } // Process a url lexical token. A CSS1 url token can contain // characters beyond identifier characters (e.g. '/', ':', etc.) // Because of this the normal rules for tokenizing the input don't // apply very well. To simplify the parser and relax some of the // requirements on the scanner we parse url's here. If we find a // malformed URL then we emit a token of type "InvalidURL" so that // the CSS1 parser can ignore the invalid input. We attempt to eat // the right amount of input data when an invalid URL is presented. aToken.mType = eCSSToken_InvalidURL; nsString& ident = aToken.mIdent; ident.SetLength(0); if (ch == ')') { Pushback(ch); // empty url spec; just get out of here aToken.mType = eCSSToken_URL; } else { // start of a non-quoted url Pushback(ch); PRBool ok = PR_TRUE; for (;;) { ch = Read(aErrorCode); if (ch < 0) break; if (ch == CSS_ESCAPE) { ParseAndAppendEscape(aErrorCode, ident); } else if ((ch == '"') || (ch == '\'') || (ch == '(')) { // This is an invalid URL spec ok = PR_FALSE; } else if ((256 > ch) && ((gLexTable[ch] & IS_WHITESPACE) != 0)) { // Whitespace is allowed at the end of the URL (void) EatWhiteSpace(aErrorCode); if (LookAhead(aErrorCode, ')')) { Pushback(')'); // leave the closing symbol // done! break; } // Whitespace is followed by something other than a // ")". This is an invalid url spec. ok = PR_FALSE; } else if (ch == ')') { Unread(); // All done break; } else { // A regular url character. ident.Append(PRUnichar(ch)); } } // If the result of the above scanning is ok then change the token // type to a useful one. if (ok) { aToken.mType = eCSSToken_URL; } } } return PR_TRUE; }
void gfxGDIFont::Initialize() { NS_ASSERTION(!mMetrics, "re-creating metrics? this will leak"); LOGFONTW logFont; if (mAdjustedSize == 0.0) { mAdjustedSize = mStyle.size; if (mStyle.sizeAdjust != 0.0 && mAdjustedSize > 0.0) { // to implement font-size-adjust, we first create the "unadjusted" font FillLogFont(logFont, mAdjustedSize); mFont = ::CreateFontIndirectW(&logFont); // initialize its metrics so we can calculate size adjustment Initialize(); // calculate the properly adjusted size, and then proceed // to recreate mFont and recalculate metrics gfxFloat aspect = mMetrics->xHeight / mMetrics->emHeight; mAdjustedSize = mStyle.GetAdjustedSize(aspect); // delete the temporary font and metrics ::DeleteObject(mFont); mFont = nsnull; delete mMetrics; mMetrics = nsnull; } } FillLogFont(logFont, mAdjustedSize); mFont = ::CreateFontIndirectW(&logFont); mMetrics = new gfxFont::Metrics; ::memset(mMetrics, 0, sizeof(*mMetrics)); AutoDC dc; SetGraphicsMode(dc.GetDC(), GM_ADVANCED); AutoSelectFont selectFont(dc.GetDC(), mFont); // Get font metrics OUTLINETEXTMETRIC oMetrics; TEXTMETRIC& metrics = oMetrics.otmTextMetrics; if (0 < GetOutlineTextMetrics(dc.GetDC(), sizeof(oMetrics), &oMetrics)) { mMetrics->superscriptOffset = (double)oMetrics.otmptSuperscriptOffset.y; // Some fonts have wrong sign on their subscript offset, bug 410917. mMetrics->subscriptOffset = fabs((double)oMetrics.otmptSubscriptOffset.y); mMetrics->strikeoutSize = (double)oMetrics.otmsStrikeoutSize; mMetrics->strikeoutOffset = (double)oMetrics.otmsStrikeoutPosition; mMetrics->underlineSize = (double)oMetrics.otmsUnderscoreSize; mMetrics->underlineOffset = (double)oMetrics.otmsUnderscorePosition; const MAT2 kIdentityMatrix = { {0, 1}, {0, 0}, {0, 0}, {0, 1} }; GLYPHMETRICS gm; DWORD len = GetGlyphOutlineW(dc.GetDC(), PRUnichar('x'), GGO_METRICS, &gm, 0, nsnull, &kIdentityMatrix); if (len == GDI_ERROR || gm.gmptGlyphOrigin.y <= 0) { // 56% of ascent, best guess for true type mMetrics->xHeight = ROUND((double)metrics.tmAscent * DEFAULT_XHEIGHT_FACTOR); } else { mMetrics->xHeight = gm.gmptGlyphOrigin.y; } mMetrics->emHeight = metrics.tmHeight - metrics.tmInternalLeading; gfxFloat typEmHeight = (double)oMetrics.otmAscent - (double)oMetrics.otmDescent; mMetrics->emAscent = ROUND(mMetrics->emHeight * (double)oMetrics.otmAscent / typEmHeight); mMetrics->emDescent = mMetrics->emHeight - mMetrics->emAscent; if (oMetrics.otmEMSquare > 0) { mFUnitsConvFactor = float(mAdjustedSize / oMetrics.otmEMSquare); } } else { // Make a best-effort guess at extended metrics // this is based on general typographic guidelines // GetTextMetrics can fail if the font file has been removed // or corrupted recently. BOOL result = GetTextMetrics(dc.GetDC(), &metrics); if (!result) { NS_WARNING("Missing or corrupt font data, fasten your seatbelt"); mIsValid = PR_FALSE; memset(mMetrics, 0, sizeof(*mMetrics)); return; } mMetrics->xHeight = ROUND((float)metrics.tmAscent * DEFAULT_XHEIGHT_FACTOR); mMetrics->superscriptOffset = mMetrics->xHeight; mMetrics->subscriptOffset = mMetrics->xHeight; mMetrics->strikeoutSize = 1; mMetrics->strikeoutOffset = ROUND(mMetrics->xHeight * 0.5f); // 50% of xHeight mMetrics->underlineSize = 1; mMetrics->underlineOffset = -ROUND((float)metrics.tmDescent * 0.30f); // 30% of descent mMetrics->emHeight = metrics.tmHeight - metrics.tmInternalLeading; mMetrics->emAscent = metrics.tmAscent - metrics.tmInternalLeading; mMetrics->emDescent = metrics.tmDescent; } mMetrics->internalLeading = metrics.tmInternalLeading; mMetrics->externalLeading = metrics.tmExternalLeading; mMetrics->maxHeight = metrics.tmHeight; mMetrics->maxAscent = metrics.tmAscent; mMetrics->maxDescent = metrics.tmDescent; mMetrics->maxAdvance = metrics.tmMaxCharWidth; mMetrics->aveCharWidth = PR_MAX(1, metrics.tmAveCharWidth); // The font is monospace when TMPF_FIXED_PITCH is *not* set! // See http://msdn2.microsoft.com/en-us/library/ms534202(VS.85).aspx if (!(metrics.tmPitchAndFamily & TMPF_FIXED_PITCH)) { mMetrics->maxAdvance = mMetrics->aveCharWidth; } // Cache the width of a single space. SIZE size; GetTextExtentPoint32W(dc.GetDC(), L" ", 1, &size); mMetrics->spaceWidth = ROUND(size.cx); // Cache the width of digit zero. // XXX MSDN (http://msdn.microsoft.com/en-us/library/ms534223.aspx) // does not say what the failure modes for GetTextExtentPoint32 are - // is it safe to assume it will fail iff the font has no '0'? if (GetTextExtentPoint32W(dc.GetDC(), L"0", 1, &size)) { mMetrics->zeroOrAveCharWidth = ROUND(size.cx); } else { mMetrics->zeroOrAveCharWidth = mMetrics->aveCharWidth; } mSpaceGlyph = 0; if (metrics.tmPitchAndFamily & TMPF_TRUETYPE) { WORD glyph; DWORD ret = GetGlyphIndicesW(dc.GetDC(), L" ", 1, &glyph, GGI_MARK_NONEXISTING_GLYPHS); if (ret != GDI_ERROR && glyph != 0xFFFF) { mSpaceGlyph = glyph; } } SanitizeMetrics(mMetrics, GetFontEntry()->mIsBadUnderlineFont); mFontFace = cairo_win32_font_face_create_for_logfontw_hfont(&logFont, mFont); cairo_matrix_t sizeMatrix, ctm; cairo_matrix_init_identity(&ctm); cairo_matrix_init_scale(&sizeMatrix, mAdjustedSize, mAdjustedSize); cairo_font_options_t *fontOptions = cairo_font_options_create(); if (mAntialiasOption != kAntialiasDefault) { cairo_font_options_set_antialias(fontOptions, GetCairoAntialiasOption(mAntialiasOption)); } mScaledFont = cairo_scaled_font_create(mFontFace, &sizeMatrix, &ctm, fontOptions); cairo_font_options_destroy(fontOptions); if (!mScaledFont || cairo_scaled_font_status(mScaledFont) != CAIRO_STATUS_SUCCESS) { #ifdef DEBUG char warnBuf[1024]; sprintf(warnBuf, "Failed to create scaled font: %s status: %d", NS_ConvertUTF16toUTF8(mFontEntry->Name()).get(), mScaledFont ? cairo_scaled_font_status(mScaledFont) : 0); NS_WARNING(warnBuf); #endif } mIsValid = PR_TRUE; #if 0 printf("Font: %p (%s) size: %f\n", this, NS_ConvertUTF16toUTF8(GetName()).get(), mStyle.size); printf(" emHeight: %f emAscent: %f emDescent: %f\n", mMetrics.emHeight, mMetrics.emAscent, mMetrics.emDescent); printf(" maxAscent: %f maxDescent: %f maxAdvance: %f\n", mMetrics.maxAscent, mMetrics.maxDescent, mMetrics.maxAdvance); printf(" internalLeading: %f externalLeading: %f\n", mMetrics.internalLeading, mMetrics.externalLeading); printf(" spaceWidth: %f aveCharWidth: %f xHeight: %f\n", mMetrics.spaceWidth, mMetrics.aveCharWidth, mMetrics.xHeight); printf(" uOff: %f uSize: %f stOff: %f stSize: %f supOff: %f subOff: %f\n", mMetrics.underlineOffset, mMetrics.underlineSize, mMetrics.strikeoutOffset, mMetrics.strikeoutSize, mMetrics.superscriptOffset, mMetrics.subscriptOffset); #endif }
nsresult GetSpecialSystemDirectory(SystemDirectories aSystemSystemDirectory, nsIFile** aFile) { #if defined(XP_WIN) WCHAR path[MAX_PATH]; #else char path[MAXPATHLEN]; #endif switch (aSystemSystemDirectory) { case OS_CurrentWorkingDirectory: #if defined(XP_WIN) if (!_wgetcwd(path, MAX_PATH)) return NS_ERROR_FAILURE; return NS_NewLocalFile(nsDependentString(path), true, aFile); #else if(!getcwd(path, MAXPATHLEN)) return NS_ERROR_FAILURE; #endif #if !defined(XP_WIN) return NS_NewNativeLocalFile(nsDependentCString(path), true, aFile); #endif case OS_DriveDirectory: #if defined (XP_WIN) { int32_t len = ::GetWindowsDirectoryW(path, MAX_PATH); if (len == 0) break; if (path[1] == PRUnichar(':') && path[2] == PRUnichar('\\')) path[3] = 0; return NS_NewLocalFile(nsDependentString(path), true, aFile); } #else return NS_NewNativeLocalFile(nsDependentCString("/"), true, aFile); #endif case OS_TemporaryDirectory: #if defined (XP_WIN) { DWORD len = ::GetTempPathW(MAX_PATH, path); if (len == 0) break; return NS_NewLocalFile(nsDependentString(path, len), true, aFile); } #elif defined(MOZ_WIDGET_COCOA) { return GetOSXFolderType(kUserDomain, kTemporaryFolderType, aFile); } #elif defined(XP_UNIX) { static const char *tPath = nullptr; if (!tPath) { tPath = PR_GetEnv("PANDORATMP"); if (!tPath) { tPath = PR_GetEnv("TMPDIR"); if (!tPath || !*tPath) { tPath = PR_GetEnv("TMP"); if (!tPath || !*tPath) { tPath = PR_GetEnv("TEMP"); if (!tPath || !*tPath) { tPath = "/tmp/"; } } } } } return NS_NewNativeLocalFile(nsDependentCString(tPath), true, aFile); } #else break; #endif #if defined (XP_WIN) case Win_SystemDirectory: { int32_t len = ::GetSystemDirectoryW(path, MAX_PATH); // Need enough space to add the trailing backslash if (!len || len > MAX_PATH - 2) break; path[len] = L'\\'; path[++len] = L'\0'; return NS_NewLocalFile(nsDependentString(path, len), true, aFile); } case Win_WindowsDirectory: { int32_t len = ::GetWindowsDirectoryW(path, MAX_PATH); // Need enough space to add the trailing backslash if (!len || len > MAX_PATH - 2) break; path[len] = L'\\'; path[++len] = L'\0'; return NS_NewLocalFile(nsDependentString(path, len), true, aFile); } case Win_ProgramFiles: { return GetWindowsFolder(CSIDL_PROGRAM_FILES, aFile); } case Win_HomeDirectory: { nsresult rv = GetWindowsFolder(CSIDL_PROFILE, aFile); if (NS_SUCCEEDED(rv)) return rv; int32_t len; if ((len = ::GetEnvironmentVariableW(L"HOME", path, MAX_PATH)) > 0) { // Need enough space to add the trailing backslash if (len > MAX_PATH - 2) break; path[len] = L'\\'; path[++len] = L'\0'; rv = NS_NewLocalFile(nsDependentString(path, len), true, aFile); if (NS_SUCCEEDED(rv)) return rv; } len = ::GetEnvironmentVariableW(L"HOMEDRIVE", path, MAX_PATH); if (0 < len && len < MAX_PATH) { WCHAR temp[MAX_PATH]; DWORD len2 = ::GetEnvironmentVariableW(L"HOMEPATH", temp, MAX_PATH); if (0 < len2 && len + len2 < MAX_PATH) wcsncat(path, temp, len2); len = wcslen(path); // Need enough space to add the trailing backslash if (len > MAX_PATH - 2) break; path[len] = L'\\'; path[++len] = L'\0'; return NS_NewLocalFile(nsDependentString(path, len), true, aFile); } } case Win_Desktop: { return GetWindowsFolder(CSIDL_DESKTOP, aFile); } case Win_Programs: { return GetWindowsFolder(CSIDL_PROGRAMS, aFile); } case Win_Downloads: { // Defined in KnownFolders.h. GUID folderid_downloads = {0x374de290, 0x123f, 0x4565, {0x91, 0x64, 0x39, 0xc4, 0x92, 0x5e, 0x46, 0x7b}}; nsresult rv = GetKnownFolder(&folderid_downloads, aFile); // On WinXP, there is no downloads folder, default // to 'Desktop'. if(NS_ERROR_FAILURE == rv) { rv = GetWindowsFolder(CSIDL_DESKTOP, aFile); } return rv; } case Win_Controls: { return GetWindowsFolder(CSIDL_CONTROLS, aFile); } case Win_Printers: { return GetWindowsFolder(CSIDL_PRINTERS, aFile); } case Win_Personal: { return GetWindowsFolder(CSIDL_PERSONAL, aFile); } case Win_Favorites: { return GetWindowsFolder(CSIDL_FAVORITES, aFile); } case Win_Startup: { return GetWindowsFolder(CSIDL_STARTUP, aFile); } case Win_Recent: { return GetWindowsFolder(CSIDL_RECENT, aFile); } case Win_Sendto: { return GetWindowsFolder(CSIDL_SENDTO, aFile); } case Win_Bitbucket: { return GetWindowsFolder(CSIDL_BITBUCKET, aFile); } case Win_Startmenu: { return GetWindowsFolder(CSIDL_STARTMENU, aFile); } case Win_Desktopdirectory: { return GetWindowsFolder(CSIDL_DESKTOPDIRECTORY, aFile); } case Win_Drives: { return GetWindowsFolder(CSIDL_DRIVES, aFile); } case Win_Network: { return GetWindowsFolder(CSIDL_NETWORK, aFile); } case Win_Nethood: { return GetWindowsFolder(CSIDL_NETHOOD, aFile); } case Win_Fonts: { return GetWindowsFolder(CSIDL_FONTS, aFile); } case Win_Templates: { return GetWindowsFolder(CSIDL_TEMPLATES, aFile); } case Win_Common_Startmenu: { return GetWindowsFolder(CSIDL_COMMON_STARTMENU, aFile); } case Win_Common_Programs: { return GetWindowsFolder(CSIDL_COMMON_PROGRAMS, aFile); } case Win_Common_Startup: { return GetWindowsFolder(CSIDL_COMMON_STARTUP, aFile); } case Win_Common_Desktopdirectory: { return GetWindowsFolder(CSIDL_COMMON_DESKTOPDIRECTORY, aFile); } case Win_Common_AppData: { return GetWindowsFolder(CSIDL_COMMON_APPDATA, aFile); } case Win_Printhood: { return GetWindowsFolder(CSIDL_PRINTHOOD, aFile); } case Win_Cookies: { return GetWindowsFolder(CSIDL_COOKIES, aFile); } case Win_Appdata: { nsresult rv = GetWindowsFolder(CSIDL_APPDATA, aFile); if (NS_FAILED(rv)) rv = GetRegWindowsAppDataFolder(false, aFile); return rv; } case Win_LocalAppdata: { nsresult rv = GetWindowsFolder(CSIDL_LOCAL_APPDATA, aFile); if (NS_FAILED(rv)) rv = GetRegWindowsAppDataFolder(true, aFile); return rv; } case Win_Documents: { return GetLibrarySaveToPath(CSIDL_MYDOCUMENTS, FOLDERID_DocumentsLibrary, aFile); } case Win_Pictures: { return GetLibrarySaveToPath(CSIDL_MYPICTURES, FOLDERID_PicturesLibrary, aFile); } case Win_Music: { return GetLibrarySaveToPath(CSIDL_MYMUSIC, FOLDERID_MusicLibrary, aFile); } case Win_Videos: { return GetLibrarySaveToPath(CSIDL_MYVIDEO, FOLDERID_VideosLibrary, aFile); } #endif // XP_WIN #if defined(XP_UNIX) case Unix_LocalDirectory: return NS_NewNativeLocalFile(nsDependentCString("/usr/local/netscape/"), true, aFile); case Unix_LibDirectory: return NS_NewNativeLocalFile(nsDependentCString("/usr/local/lib/netscape/"), true, aFile); case Unix_HomeDirectory: return GetUnixHomeDir(aFile); case Unix_XDG_Desktop: case Unix_XDG_Documents: case Unix_XDG_Download: case Unix_XDG_Music: case Unix_XDG_Pictures: case Unix_XDG_PublicShare: case Unix_XDG_Templates: case Unix_XDG_Videos: return GetUnixXDGUserDirectory(aSystemSystemDirectory, aFile); #endif // XP_UNIX default: break; } return NS_ERROR_NOT_AVAILABLE; }
void nsCSSValue::AppendToString(nsCSSProperty aProperty, nsAString& aResult) const { // eCSSProperty_UNKNOWN gets used for some recursive calls below. NS_ABORT_IF_FALSE((0 <= aProperty && aProperty <= eCSSProperty_COUNT_no_shorthands) || aProperty == eCSSProperty_UNKNOWN, "property ID out of range"); nsCSSUnit unit = GetUnit(); if (unit == eCSSUnit_Null) { return; } if (eCSSUnit_String <= unit && unit <= eCSSUnit_Attr) { if (unit == eCSSUnit_Attr) { aResult.AppendLiteral("attr("); } nsAutoString buffer; GetStringValue(buffer); if (unit == eCSSUnit_String) { nsStyleUtil::AppendEscapedCSSString(buffer, aResult); } else if (unit == eCSSUnit_Families) { // XXX We really need to do *some* escaping. aResult.Append(buffer); } else { nsStyleUtil::AppendEscapedCSSIdent(buffer, aResult); } } else if (eCSSUnit_Array <= unit && unit <= eCSSUnit_Cubic_Bezier) { switch (unit) { case eCSSUnit_Counter: aResult.AppendLiteral("counter("); break; case eCSSUnit_Counters: aResult.AppendLiteral("counters("); break; case eCSSUnit_Cubic_Bezier: aResult.AppendLiteral("cubic-bezier("); break; default: break; } nsCSSValue::Array *array = GetArrayValue(); PRBool mark = PR_FALSE; for (size_t i = 0, i_end = array->Count(); i < i_end; ++i) { if (aProperty == eCSSProperty_border_image && i >= 5) { if (array->Item(i).GetUnit() == eCSSUnit_Null) { continue; } if (i == 5) { aResult.AppendLiteral(" /"); } } if (mark && array->Item(i).GetUnit() != eCSSUnit_Null) { if (unit == eCSSUnit_Array && eCSSProperty_transition_timing_function != aProperty) aResult.AppendLiteral(" "); else aResult.AppendLiteral(", "); } nsCSSProperty prop = ((eCSSUnit_Counter <= unit && unit <= eCSSUnit_Counters) && i == array->Count() - 1) ? eCSSProperty_list_style_type : aProperty; if (array->Item(i).GetUnit() != eCSSUnit_Null) { array->Item(i).AppendToString(prop, aResult); mark = PR_TRUE; } } if (eCSSUnit_Array == unit && aProperty == eCSSProperty_transition_timing_function) { aResult.AppendLiteral(")"); } } /* Although Function is backed by an Array, we'll handle it separately * because it's a bit quirky. */ else if (eCSSUnit_Function == unit) { const nsCSSValue::Array* array = GetArrayValue(); NS_ABORT_IF_FALSE(array->Count() >= 1, "Functions must have at least one element for the name."); /* Append the function name. */ const nsCSSValue& functionName = array->Item(0); if (functionName.GetUnit() == eCSSUnit_Enumerated) { // We assume that the first argument is always of nsCSSKeyword type. const nsCSSKeyword functionId = static_cast<nsCSSKeyword>(functionName.GetIntValue()); nsStyleUtil::AppendEscapedCSSIdent( NS_ConvertASCIItoUTF16(nsCSSKeywords::GetStringValue(functionId)), aResult); } else { functionName.AppendToString(aProperty, aResult); } aResult.AppendLiteral("("); /* Now, step through the function contents, writing each of them as we go. */ for (size_t index = 1; index < array->Count(); ++index) { array->Item(index).AppendToString(aProperty, aResult); /* If we're not at the final element, append a comma. */ if (index + 1 != array->Count()) aResult.AppendLiteral(", "); } /* Finally, append the closing parenthesis. */ aResult.AppendLiteral(")"); } else if (IsCalcUnit()) { NS_ABORT_IF_FALSE(GetUnit() == eCSSUnit_Calc || GetUnit() == eCSSUnit_Calc_Maximum || GetUnit() == eCSSUnit_Calc_Minimum, "unexpected unit"); CSSValueSerializeCalcOps ops(aProperty, aResult); css::SerializeCalc(*this, ops); } else if (eCSSUnit_Integer == unit) { nsAutoString tmpStr; tmpStr.AppendInt(GetIntValue(), 10); aResult.Append(tmpStr); } else if (eCSSUnit_Enumerated == unit) { if (eCSSProperty_text_decoration == aProperty) { PRInt32 intValue = GetIntValue(); if (NS_STYLE_TEXT_DECORATION_NONE == intValue) { AppendASCIItoUTF16(nsCSSProps::LookupPropertyValue(aProperty, intValue), aResult); } else { // Ignore the "override all" internal value. // (It doesn't have a string representation.) intValue &= ~NS_STYLE_TEXT_DECORATION_OVERRIDE_ALL; nsStyleUtil::AppendBitmaskCSSValue( aProperty, intValue, NS_STYLE_TEXT_DECORATION_UNDERLINE, NS_STYLE_TEXT_DECORATION_PREF_ANCHORS, aResult); } } else if (eCSSProperty_azimuth == aProperty) { PRInt32 intValue = GetIntValue(); AppendASCIItoUTF16(nsCSSProps::LookupPropertyValue(aProperty, (intValue & ~NS_STYLE_AZIMUTH_BEHIND)), aResult); if ((NS_STYLE_AZIMUTH_BEHIND & intValue) != 0) { aResult.Append(PRUnichar(' ')); AppendASCIItoUTF16(nsCSSProps::LookupPropertyValue(aProperty, NS_STYLE_AZIMUTH_BEHIND), aResult); } } else if (eCSSProperty_marks == aProperty) { PRInt32 intValue = GetIntValue(); if (intValue == NS_STYLE_PAGE_MARKS_NONE) { AppendASCIItoUTF16(nsCSSProps::LookupPropertyValue(aProperty, intValue), aResult); } else { nsStyleUtil::AppendBitmaskCSSValue(aProperty, intValue, NS_STYLE_PAGE_MARKS_CROP, NS_STYLE_PAGE_MARKS_REGISTER, aResult); } } else { const nsAFlatCString& name = nsCSSProps::LookupPropertyValue(aProperty, GetIntValue()); AppendASCIItoUTF16(name, aResult); } } else if (eCSSUnit_EnumColor == unit) { // we can lookup the property in the ColorTable and then // get a string mapping the name nsCAutoString str; if (nsCSSProps::GetColorName(GetIntValue(), str)){ AppendASCIItoUTF16(str, aResult); } else { NS_ABORT_IF_FALSE(false, "bad color value"); } } else if (eCSSUnit_Color == unit) { nscolor color = GetColorValue(); if (color == NS_RGBA(0, 0, 0, 0)) { // Use the strictest match for 'transparent' so we do correct // round-tripping of all other rgba() values. aResult.AppendLiteral("transparent"); } else { nsAutoString tmpStr; PRUint8 a = NS_GET_A(color); if (a < 255) { tmpStr.AppendLiteral("rgba("); } else { tmpStr.AppendLiteral("rgb("); } NS_NAMED_LITERAL_STRING(comma, ", "); tmpStr.AppendInt(NS_GET_R(color), 10); tmpStr.Append(comma); tmpStr.AppendInt(NS_GET_G(color), 10); tmpStr.Append(comma); tmpStr.AppendInt(NS_GET_B(color), 10); if (a < 255) { tmpStr.Append(comma); tmpStr.AppendFloat(nsStyleUtil::ColorComponentToFloat(a)); } tmpStr.Append(PRUnichar(')')); aResult.Append(tmpStr); } } else if (eCSSUnit_URL == unit || eCSSUnit_Image == unit) { aResult.Append(NS_LITERAL_STRING("url(")); nsStyleUtil::AppendEscapedCSSString( nsDependentString(GetOriginalURLValue()), aResult); aResult.Append(NS_LITERAL_STRING(")")); } else if (eCSSUnit_Element == unit) { aResult.Append(NS_LITERAL_STRING("-moz-element(#")); nsAutoString tmpStr; GetStringValue(tmpStr); nsStyleUtil::AppendEscapedCSSIdent( nsDependentString(tmpStr), aResult); aResult.Append(NS_LITERAL_STRING(")")); } else if (eCSSUnit_Percent == unit) { nsAutoString tmpStr; tmpStr.AppendFloat(GetPercentValue() * 100.0f); aResult.Append(tmpStr); } else if (eCSSUnit_Percent < unit) { // length unit nsAutoString tmpStr; tmpStr.AppendFloat(GetFloatValue()); aResult.Append(tmpStr); } else if (eCSSUnit_Gradient == unit) { nsCSSValueGradient* gradient = GetGradientValue(); if (gradient->mIsRepeating) { if (gradient->mIsRadial) aResult.AppendLiteral("-moz-repeating-radial-gradient("); else aResult.AppendLiteral("-moz-repeating-linear-gradient("); } else { if (gradient->mIsRadial) aResult.AppendLiteral("-moz-radial-gradient("); else aResult.AppendLiteral("-moz-linear-gradient("); } if (gradient->mBgPos.mXValue.GetUnit() != eCSSUnit_None || gradient->mBgPos.mYValue.GetUnit() != eCSSUnit_None || gradient->mAngle.GetUnit() != eCSSUnit_None) { if (gradient->mBgPos.mXValue.GetUnit() != eCSSUnit_None) { gradient->mBgPos.mXValue.AppendToString(eCSSProperty_background_position, aResult); aResult.AppendLiteral(" "); } if (gradient->mBgPos.mXValue.GetUnit() != eCSSUnit_None) { gradient->mBgPos.mYValue.AppendToString(eCSSProperty_background_position, aResult); aResult.AppendLiteral(" "); } if (gradient->mAngle.GetUnit() != eCSSUnit_None) { gradient->mAngle.AppendToString(aProperty, aResult); } aResult.AppendLiteral(", "); } if (gradient->mIsRadial && (gradient->mRadialShape.GetUnit() != eCSSUnit_None || gradient->mRadialSize.GetUnit() != eCSSUnit_None)) { if (gradient->mRadialShape.GetUnit() != eCSSUnit_None) { NS_ABORT_IF_FALSE(gradient->mRadialShape.GetUnit() == eCSSUnit_Enumerated, "bad unit for radial gradient shape"); PRInt32 intValue = gradient->mRadialShape.GetIntValue(); NS_ABORT_IF_FALSE(intValue != NS_STYLE_GRADIENT_SHAPE_LINEAR, "radial gradient with linear shape?!"); AppendASCIItoUTF16(nsCSSProps::ValueToKeyword(intValue, nsCSSProps::kRadialGradientShapeKTable), aResult); aResult.AppendLiteral(" "); } if (gradient->mRadialSize.GetUnit() != eCSSUnit_None) { NS_ABORT_IF_FALSE(gradient->mRadialSize.GetUnit() == eCSSUnit_Enumerated, "bad unit for radial gradient size"); PRInt32 intValue = gradient->mRadialSize.GetIntValue(); AppendASCIItoUTF16(nsCSSProps::ValueToKeyword(intValue, nsCSSProps::kRadialGradientSizeKTable), aResult); } aResult.AppendLiteral(", "); } for (PRUint32 i = 0 ;;) { gradient->mStops[i].mColor.AppendToString(aProperty, aResult); if (gradient->mStops[i].mLocation.GetUnit() != eCSSUnit_None) { aResult.AppendLiteral(" "); gradient->mStops[i].mLocation.AppendToString(aProperty, aResult); } if (++i == gradient->mStops.Length()) { break; } aResult.AppendLiteral(", "); } aResult.AppendLiteral(")"); } else if (eCSSUnit_Pair == unit) { GetPairValue().AppendToString(aProperty, aResult); } else if (eCSSUnit_Rect == unit) { GetRectValue().AppendToString(aProperty, aResult); } else if (eCSSUnit_List == unit || eCSSUnit_ListDep == unit) { GetListValue()->AppendToString(aProperty, aResult); } else if (eCSSUnit_PairList == unit || eCSSUnit_PairListDep == unit) { GetPairListValue()->AppendToString(aProperty, aResult); } switch (unit) { case eCSSUnit_Null: break; case eCSSUnit_Auto: aResult.AppendLiteral("auto"); break; case eCSSUnit_Inherit: aResult.AppendLiteral("inherit"); break; case eCSSUnit_Initial: aResult.AppendLiteral("-moz-initial"); break; case eCSSUnit_None: aResult.AppendLiteral("none"); break; case eCSSUnit_Normal: aResult.AppendLiteral("normal"); break; case eCSSUnit_System_Font: aResult.AppendLiteral("-moz-use-system-font"); break; case eCSSUnit_All: aResult.AppendLiteral("all"); break; case eCSSUnit_Dummy: case eCSSUnit_DummyInherit: NS_ABORT_IF_FALSE(false, "should never serialize"); break; case eCSSUnit_String: break; case eCSSUnit_Ident: break; case eCSSUnit_Families: break; case eCSSUnit_URL: break; case eCSSUnit_Image: break; case eCSSUnit_Element: break; case eCSSUnit_Array: break; case eCSSUnit_Attr: case eCSSUnit_Cubic_Bezier: case eCSSUnit_Counter: case eCSSUnit_Counters: aResult.Append(PRUnichar(')')); break; case eCSSUnit_Local_Font: break; case eCSSUnit_Font_Format: break; case eCSSUnit_Function: break; case eCSSUnit_Calc: break; case eCSSUnit_Calc_Plus: break; case eCSSUnit_Calc_Minus: break; case eCSSUnit_Calc_Times_L: break; case eCSSUnit_Calc_Times_R: break; case eCSSUnit_Calc_Divided: break; case eCSSUnit_Calc_Minimum: break; case eCSSUnit_Calc_Maximum: break; case eCSSUnit_Integer: break; case eCSSUnit_Enumerated: break; case eCSSUnit_EnumColor: break; case eCSSUnit_Color: break; case eCSSUnit_Percent: aResult.Append(PRUnichar('%')); break; case eCSSUnit_Number: break; case eCSSUnit_Gradient: break; case eCSSUnit_Pair: break; case eCSSUnit_Rect: break; case eCSSUnit_List: break; case eCSSUnit_ListDep: break; case eCSSUnit_PairList: break; case eCSSUnit_PairListDep: break; case eCSSUnit_Inch: aResult.AppendLiteral("in"); break; case eCSSUnit_Millimeter: aResult.AppendLiteral("mm"); break; case eCSSUnit_PhysicalMillimeter: aResult.AppendLiteral("mozmm"); break; case eCSSUnit_Centimeter: aResult.AppendLiteral("cm"); break; case eCSSUnit_Point: aResult.AppendLiteral("pt"); break; case eCSSUnit_Pica: aResult.AppendLiteral("pc"); break; case eCSSUnit_EM: aResult.AppendLiteral("em"); break; case eCSSUnit_XHeight: aResult.AppendLiteral("ex"); break; case eCSSUnit_Char: aResult.AppendLiteral("ch"); break; case eCSSUnit_RootEM: aResult.AppendLiteral("rem"); break; case eCSSUnit_Pixel: aResult.AppendLiteral("px"); break; case eCSSUnit_Degree: aResult.AppendLiteral("deg"); break; case eCSSUnit_Grad: aResult.AppendLiteral("grad"); break; case eCSSUnit_Radian: aResult.AppendLiteral("rad"); break; case eCSSUnit_Hertz: aResult.AppendLiteral("Hz"); break; case eCSSUnit_Kilohertz: aResult.AppendLiteral("kHz"); break; case eCSSUnit_Seconds: aResult.Append(PRUnichar('s')); break; case eCSSUnit_Milliseconds: aResult.AppendLiteral("ms"); break; } }
nsresult nsNSSCertificate::FormatUIStrings(const nsAutoString &nickname, nsAutoString &nickWithSerial, nsAutoString &details) { if (!NS_IsMainThread()) { NS_ERROR("nsNSSCertificate::FormatUIStrings called off the main thread"); return NS_ERROR_NOT_SAME_THREAD; } nsresult rv = NS_OK; nsCOMPtr<nsINSSComponent> nssComponent(do_GetService(kNSSComponentCID, &rv)); if (NS_FAILED(rv) || !nssComponent) { return NS_ERROR_FAILURE; } nsAutoString info; nsAutoString temp1; nickWithSerial.Append(nickname); if (NS_SUCCEEDED(nssComponent->GetPIPNSSBundleString("CertInfoIssuedFor", info))) { details.Append(info); details.Append(PRUnichar(' ')); if (NS_SUCCEEDED(GetSubjectName(temp1)) && !temp1.IsEmpty()) { details.Append(temp1); } details.Append(PRUnichar('\n')); } if (NS_SUCCEEDED(GetSerialNumber(temp1)) && !temp1.IsEmpty()) { details.AppendLiteral(" "); if (NS_SUCCEEDED(nssComponent->GetPIPNSSBundleString("CertDumpSerialNo", info))) { details.Append(info); details.AppendLiteral(": "); } details.Append(temp1); nickWithSerial.AppendLiteral(" ["); nickWithSerial.Append(temp1); nickWithSerial.Append(PRUnichar(']')); details.Append(PRUnichar('\n')); } nsCOMPtr<nsIX509CertValidity> validity; rv = GetValidity(getter_AddRefs(validity)); if (NS_SUCCEEDED(rv) && validity) { details.AppendLiteral(" "); if (NS_SUCCEEDED(nssComponent->GetPIPNSSBundleString("CertInfoValid", info))) { details.Append(info); } if (NS_SUCCEEDED(validity->GetNotBeforeLocalTime(temp1)) && !temp1.IsEmpty()) { details.Append(PRUnichar(' ')); if (NS_SUCCEEDED(nssComponent->GetPIPNSSBundleString("CertInfoFrom", info))) { details.Append(info); details.Append(PRUnichar(' ')); } details.Append(temp1); } if (NS_SUCCEEDED(validity->GetNotAfterLocalTime(temp1)) && !temp1.IsEmpty()) { details.Append(PRUnichar(' ')); if (NS_SUCCEEDED(nssComponent->GetPIPNSSBundleString("CertInfoTo", info))) { details.Append(info); details.Append(PRUnichar(' ')); } details.Append(temp1); } details.Append(PRUnichar('\n')); } if (NS_SUCCEEDED(GetKeyUsagesString(mCert, nssComponent, temp1)) && !temp1.IsEmpty()) { details.AppendLiteral(" "); if (NS_SUCCEEDED(nssComponent->GetPIPNSSBundleString("CertDumpKeyUsage", info))) { details.Append(info); details.AppendLiteral(": "); } details.Append(temp1); details.Append(PRUnichar('\n')); } nsAutoString firstEmail; const char *aWalkAddr; for (aWalkAddr = CERT_GetFirstEmailAddress(mCert) ; aWalkAddr ; aWalkAddr = CERT_GetNextEmailAddress(mCert, aWalkAddr)) { NS_ConvertUTF8toUTF16 email(aWalkAddr); if (email.IsEmpty()) continue; if (firstEmail.IsEmpty()) { /* * If the first email address from the subject DN is also present * in the subjectAltName extension, GetEmailAddresses() will return * it twice (as received from NSS). Remember the first address so that * we can filter out duplicates later on. */ firstEmail = email; details.AppendLiteral(" "); if (NS_SUCCEEDED(nssComponent->GetPIPNSSBundleString("CertInfoEmail", info))) { details.Append(info); details.AppendLiteral(": "); } details.Append(email); } else { // Append current address if it's different from the first one. if (!firstEmail.Equals(email)) { details.AppendLiteral(", "); details.Append(email); } } } if (!firstEmail.IsEmpty()) { // We got at least one email address, so we want a newline details.Append(PRUnichar('\n')); } if (NS_SUCCEEDED(nssComponent->GetPIPNSSBundleString("CertInfoIssuedBy", info))) { details.Append(info); details.Append(PRUnichar(' ')); if (NS_SUCCEEDED(GetIssuerName(temp1)) && !temp1.IsEmpty()) { details.Append(temp1); } details.Append(PRUnichar('\n')); } if (NS_SUCCEEDED(nssComponent->GetPIPNSSBundleString("CertInfoStoredIn", info))) { details.Append(info); details.Append(PRUnichar(' ')); if (NS_SUCCEEDED(GetTokenName(temp1)) && !temp1.IsEmpty()) { details.Append(temp1); } } /* the above produces the following output: Issued to: $subjectName Serial number: $serialNumber Valid from: $starting_date to $expiration_date Certificate Key usage: $usages Email: $address(es) Issued by: $issuerName Stored in: $token */ return rv; }
PRUnichar nsShiftJISToUnicode::GetCharacterForUnMapped() { return PRUnichar(SJIS_UNMAPPED); }
NS_IMETHODIMP nsIndexedToHTML::OnIndexAvailable(nsIRequest *aRequest, nsISupports *aCtxt, nsIDirIndex *aIndex) { nsresult rv; if (!aIndex) return NS_ERROR_NULL_POINTER; nsString pushBuffer; pushBuffer.AppendLiteral("<tr"); nsXPIDLString description; aIndex->GetDescription(getter_Copies(description)); if (description.First() == PRUnichar('.')) pushBuffer.AppendLiteral(" class=\"hidden-object\""); pushBuffer.AppendLiteral(">\n <td sortable-data=\""); // The sort key is the name of the item, prepended by either 0, 1 or 2 // in order to group items. PRUint32 type; aIndex->GetType(&type); switch (type) { case nsIDirIndex::TYPE_SYMLINK: pushBuffer.AppendInt(0); break; case nsIDirIndex::TYPE_DIRECTORY: pushBuffer.AppendInt(1); break; case nsIDirIndex::TYPE_FILE: case nsIDirIndex::TYPE_UNKNOWN: pushBuffer.AppendInt(2); break; } PRUnichar* escaped = nsEscapeHTML2(description.get(), description.Length()); pushBuffer.Append(escaped); pushBuffer.AppendLiteral("\"><a class=\""); switch (type) { case nsIDirIndex::TYPE_DIRECTORY: pushBuffer.AppendLiteral("dir"); break; case nsIDirIndex::TYPE_SYMLINK: pushBuffer.AppendLiteral("symlink"); break; case nsIDirIndex::TYPE_FILE: case nsIDirIndex::TYPE_UNKNOWN: pushBuffer.AppendLiteral("file"); break; } pushBuffer.AppendLiteral("\""); // Truncate long names to not stretch the table //XXX this should be left to the stylesheet (bug 391471) nsString escapedShort; if (description.Length() > 71) { nsCOMPtr<nsIChannel> channel = do_QueryInterface(aRequest); nsCOMPtr<nsIURI> uri; rv = channel->GetURI(getter_AddRefs(uri)); if (NS_FAILED(rv)) return rv; //XXX this potentially truncates after a combining char (bug 391472) nsXPIDLString descriptionAffix; descriptionAffix.Assign(description); descriptionAffix.Cut(0, descriptionAffix.Length() - 25); if (NS_IS_LOW_SURROGATE(descriptionAffix.First())) descriptionAffix.Cut(0, 1); description.Truncate(NS_MIN<PRUint32>(71, description.Length() - 28)); if (NS_IS_HIGH_SURROGATE(description.Last())) description.Truncate(description.Length() - 1); escapedShort.Adopt(nsEscapeHTML2(description.get(), description.Length())); escapedShort.Append(mEscapedEllipsis); // add ZERO WIDTH SPACE (U+200B) for wrapping escapedShort.AppendLiteral("​"); nsString tmp; tmp.Adopt(nsEscapeHTML2(descriptionAffix.get(), descriptionAffix.Length())); escapedShort.Append(tmp); pushBuffer.AppendLiteral(" title=\""); pushBuffer.Append(escaped); pushBuffer.AppendLiteral("\""); } if (escapedShort.IsEmpty()) escapedShort.Assign(escaped); nsMemory::Free(escaped); pushBuffer.AppendLiteral(" href=\""); nsXPIDLCString loc; aIndex->GetLocation(getter_Copies(loc)); if (!mTextToSubURI) { mTextToSubURI = do_GetService(NS_ITEXTTOSUBURI_CONTRACTID, &rv); if (NS_FAILED(rv)) return rv; } nsXPIDLCString encoding; rv = mParser->GetEncoding(getter_Copies(encoding)); if (NS_FAILED(rv)) return rv; nsXPIDLString unEscapeSpec; rv = mTextToSubURI->UnEscapeAndConvert(encoding, loc, getter_Copies(unEscapeSpec)); if (NS_FAILED(rv)) return rv; // need to escape links nsCAutoString escapeBuf; NS_ConvertUTF16toUTF8 utf8UnEscapeSpec(unEscapeSpec); // Adding trailing slash helps to recognize whether the URL points to a file // or a directory (bug #214405). if ((type == nsIDirIndex::TYPE_DIRECTORY) && (utf8UnEscapeSpec.Last() != '/')) { utf8UnEscapeSpec.Append('/'); } // now minimally re-escape the location... PRUint32 escFlags; // for some protocols, we expect the location to be absolute. // if so, and if the location indeed appears to be a valid URI, then go // ahead and treat it like one. if (mExpectAbsLoc && NS_SUCCEEDED(net_ExtractURLScheme(utf8UnEscapeSpec, nsnull, nsnull, nsnull))) { // escape as absolute escFlags = esc_Forced | esc_OnlyASCII | esc_AlwaysCopy | esc_Minimal; } else { // escape as relative // esc_Directory is needed because directories have a trailing slash. // Without it, the trailing '/' will be escaped, and links from within // that directory will be incorrect escFlags = esc_Forced | esc_OnlyASCII | esc_AlwaysCopy | esc_FileBaseName | esc_Colon | esc_Directory; } NS_EscapeURL(utf8UnEscapeSpec.get(), utf8UnEscapeSpec.Length(), escFlags, escapeBuf); // esc_Directory does not escape the semicolons, so if a filename // contains semicolons we need to manually escape them. // This replacement should be removed in bug #473280 escapeBuf.ReplaceSubstring(";", "%3b"); NS_ConvertUTF8toUTF16 utf16URI(escapeBuf); nsString htmlEscapedURL; htmlEscapedURL.Adopt(nsEscapeHTML2(utf16URI.get(), utf16URI.Length())); pushBuffer.Append(htmlEscapedURL); pushBuffer.AppendLiteral("\">"); if (type == nsIDirIndex::TYPE_FILE || type == nsIDirIndex::TYPE_UNKNOWN) { pushBuffer.AppendLiteral("<img src=\"moz-icon://"); PRInt32 lastDot = escapeBuf.RFindChar('.'); if (lastDot != kNotFound) { escapeBuf.Cut(0, lastDot); NS_ConvertUTF8toUTF16 utf16EscapeBuf(escapeBuf); nsString htmlFileExt; htmlFileExt.Adopt(nsEscapeHTML2(utf16EscapeBuf.get(), utf16EscapeBuf.Length())); pushBuffer.Append(htmlFileExt); } else { pushBuffer.AppendLiteral("unknown"); } pushBuffer.AppendLiteral("?size=16\" alt=\""); nsXPIDLString altText; rv = mBundle->GetStringFromName(NS_LITERAL_STRING("DirFileLabel").get(), getter_Copies(altText)); if (NS_FAILED(rv)) return rv; AppendNonAsciiToNCR(altText, pushBuffer); pushBuffer.AppendLiteral("\">"); } pushBuffer.Append(escapedShort); pushBuffer.AppendLiteral("</a></td>\n <td"); if (type == nsIDirIndex::TYPE_DIRECTORY || type == nsIDirIndex::TYPE_SYMLINK) { pushBuffer.AppendLiteral(">"); } else { PRInt64 size; aIndex->GetSize(&size); if (PRUint64(size) != LL_MAXUINT) { pushBuffer.AppendLiteral(" sortable-data=\""); pushBuffer.AppendInt(size); pushBuffer.AppendLiteral("\">"); nsAutoString sizeString; FormatSizeString(size, sizeString); pushBuffer.Append(sizeString); } else { pushBuffer.AppendLiteral(">"); } } pushBuffer.AppendLiteral("</td>\n <td"); PRTime t; aIndex->GetLastModified(&t); if (t == -1) { pushBuffer.AppendLiteral("></td>\n <td>"); } else { pushBuffer.AppendLiteral(" sortable-data=\""); pushBuffer.AppendInt(t); pushBuffer.AppendLiteral("\">"); nsAutoString formatted; mDateTime->FormatPRTime(nsnull, kDateFormatShort, kTimeFormatNone, t, formatted); AppendNonAsciiToNCR(formatted, pushBuffer); pushBuffer.AppendLiteral("</td>\n <td>"); mDateTime->FormatPRTime(nsnull, kDateFormatNone, kTimeFormatSeconds, t, formatted); // use NCR to show date in any doc charset AppendNonAsciiToNCR(formatted, pushBuffer); } pushBuffer.AppendLiteral("</td>\n</tr>"); return FormatInputStream(aRequest, aCtxt, pushBuffer); }
void nsCSSSelector::ToStringInternal(nsAString& aString, nsICSSStyleSheet* aSheet, PRBool aIsPseudoElem, PRIntn aNegatedIndex, const nsString& aIdPrefix) const { nsAutoString temp; PRBool aIsNegated = PRBool(0 < aNegatedIndex); PRBool isPseudoElement = IsPseudoElement(mTag); // selectors are linked from right-to-left, so the next selector in the linked list // actually precedes this one in the resulting string if (mNext) { mNext->ToStringInternal(aString, aSheet, IsPseudoElement(mTag), 0, aIdPrefix); if (!aIsNegated && !isPseudoElement) { // don't add a leading whitespace if we have a pseudo-element // or a negated simple selector aString.Append(PRUnichar(' ')); } } if (1 < aNegatedIndex) { // the first mNegations does not contain a negated type element selector // or a negated universal selector NS_IF_NEGATED_START(aIsNegated, aString) } // For non-pseudo-element selectors or for lone pseudo-elements, deal with // namespace prefixes. if (!isPseudoElement || !mNext) { // append the namespace prefix if needed if (mNameSpace == kNameSpaceID_None) { // The only way to do this in CSS is to have an explicit namespace // of "none" specified in the sheet by having a '|' with nothing // before it. aString.Append(PRUnichar('|')); } else { #ifndef FBML if (aSheet) { nsXMLNameSpaceMap *sheetNS = aSheet->GetNameSpaceMap(); // sheetNS is non-null if and only if we had an @namespace rule. If it's // null, that means that the only namespaces we could have are the // wildcard namespace (which can be implicit in this case) and the "none" // namespace, which we handled above. So no need to output anything when // sheetNS is null. if (sheetNS) { nsIAtom *prefixAtom = nsnull; // prefixAtom is non-null if and only if we have a prefix other than // '*' if (mNameSpace != kNameSpaceID_Unknown) { prefixAtom = sheetNS->FindPrefix(mNameSpace); } if (prefixAtom) { nsAutoString prefix; prefixAtom->ToString(prefix); aString.Append(prefix); aString.Append(PRUnichar('|')); } else if (mNameSpace == kNameSpaceID_Unknown) { // explicit *| or only non-default namespace rules and we're not // using any of those namespaces aString.AppendLiteral("*|"); } // else we are in the default namespace and don't need to output // anything } } #endif } } // smells like a universal selector if (!mTag && !mIDList && !mClassList) { if (1 != aNegatedIndex) { aString.Append(PRUnichar('*')); } if (1 < aNegatedIndex) { NS_IF_NEGATED_END(aIsNegated, aString) } } else { // Append the tag name, if there is one if (mTag) {
order of preference: infix, postfix, prefix." The following variable will be used to keep track of all possible forms encountered in the Operator Dictionary. */ static OperatorData* gOperatorFound[4]; static PRInt32 gTableRefCount = 0; static PRInt32 gOperatorCount = 0; static OperatorData* gOperatorArray = nsnull; static nsHashtable* gOperatorTable = nsnull; static PRBool gInitialized = PR_FALSE; static nsTArray<OperatorData*>* gStretchyOperatorArray = nsnull; static nsTArray<nsString>* gInvariantCharArray = nsnull; static const PRUnichar kNullCh = PRUnichar('\0'); static const PRUnichar kDashCh = PRUnichar('#'); static const PRUnichar kEqualCh = PRUnichar('='); static const PRUnichar kColonCh = PRUnichar(':'); static const char* const kMathVariant_name[] = { "normal", "bold", "italic", "bold-italic", "sans-serif", "bold-sans-serif", "sans-serif-italic", "sans-serif-bold-italic", "monospace", "script",
void nsCSSScanner::Unread() { NS_PRECONDITION((mLastRead >= 0), "double pushback"); Pushback(PRUnichar(mLastRead)); mLastRead = -1; }
void nsAbAutoCompleteSession::AddToResult(const PRUnichar* pNickNameStr, const PRUnichar* pDisplayNameStr, const PRUnichar* pFirstNameStr, const PRUnichar* pLastNameStr, const PRUnichar* pEmailStr, const PRUnichar* pNotesStr, const PRUnichar* pDirName, PRUint32 aPopularityIndex, PRBool bIsMailList, PRBool pDefaultMatch, nsIAutoCompleteResults* results) { nsresult rv; PRUnichar* fullAddrStr = nsnull; if (pDefaultMatch) { if (mDefaultDomain[0] == 0) return; nsAutoString aStr(pDisplayNameStr); if (aStr.FindChar('@') == kNotFound) { aStr.Append(PRUnichar('@')); aStr += mDefaultDomain; } fullAddrStr = ToNewUnicode(aStr); } else { if (mParser) { nsXPIDLCString fullAddress; nsXPIDLCString utf8Email; if (bIsMailList) { if (pNotesStr && pNotesStr[0] != 0) utf8Email.Adopt(ToNewUTF8String(nsDependentString(pNotesStr))); else utf8Email.Adopt(ToNewUTF8String(nsDependentString(pDisplayNameStr))); } else utf8Email.Adopt(ToNewUTF8String(nsDependentString(pEmailStr))); mParser->MakeFullAddress(nsnull, NS_ConvertUCS2toUTF8(pDisplayNameStr).get(), utf8Email, getter_Copies(fullAddress)); if (!fullAddress.IsEmpty()) { /* We need to convert back the result from UTF-8 to Unicode */ fullAddrStr = nsCRT::strdup(NS_ConvertUTF8toUCS2(fullAddress.get()).get()); } } if (!fullAddrStr) { //oops, parser problem! I will try to do my best... const PRUnichar * pStr = nsnull; if (bIsMailList) { if (pNotesStr && pNotesStr[0] != 0) pStr = pNotesStr; else pStr = pDisplayNameStr; } else pStr = pEmailStr; // check this so we do not get a bogus entry "someName <>" if (pStr && pStr[0] != 0) { nsAutoString aStr(pDisplayNameStr); aStr.AppendLiteral(" <"); aStr += pStr; aStr.AppendLiteral(">"); fullAddrStr = ToNewUnicode(aStr); } else fullAddrStr = nsnull; } } if (fullAddrStr && ! ItsADuplicate(fullAddrStr, aPopularityIndex, results)) { nsCOMPtr<nsIAutoCompleteItem> newItem = do_CreateInstance(NS_AUTOCOMPLETEITEM_CONTRACTID, &rv); if (NS_SUCCEEDED(rv)) { nsAbAutoCompleteParam *param = new nsAbAutoCompleteParam(pNickNameStr, pDisplayNameStr, pFirstNameStr, pLastNameStr, pEmailStr, pNotesStr, pDirName, aPopularityIndex, bIsMailList); NS_IF_ADDREF(param); newItem->SetParam(param); NS_IF_RELEASE(param); // how to process the comment column, if at all. this value // comes from "mail.autoComplete.commentColumn", or, if that // doesn't exist, defaults to 0 // // 0 = none // 1 = name of addressbook this card came from // 2 = other per-addressbook format (currrently unused here) // if (mAutoCompleteCommentColumn == 1) { rv = newItem->SetComment(pDirName); if (NS_FAILED(rv)) { NS_WARNING("nsAbAutoCompleteSession::AddToResult():" " newItem->SetComment() failed\n"); } } // if this isn't a default match, set the class name so we can style // this cell with the local addressbook icon (or whatever) // rv = newItem->SetClassName(pDefaultMatch ? "default-match" : "local-abook"); if (NS_FAILED(rv)) { NS_WARNING("nsAbAutoCompleteSession::AddToResult():" " newItem->SetClassName() failed\n"); } newItem->SetValue(nsDependentString(fullAddrStr)); nsCOMPtr<nsISupportsArray> array; rv = results->GetItems(getter_AddRefs(array)); if (NS_SUCCEEDED(rv)) { PRUint32 nbrOfItems; rv = array->Count(&nbrOfItems); PRInt32 insertPosition = 0; for (; insertPosition < nbrOfItems && !pDefaultMatch; insertPosition++) { nsCOMPtr<nsISupports> currentItemParams; nsCOMPtr<nsIAutoCompleteItem> resultItem; nsresult rv = array->QueryElementAt(insertPosition, NS_GET_IID(nsIAutoCompleteItem), getter_AddRefs(resultItem)); if (NS_FAILED(rv)) continue; rv = resultItem->GetParam(getter_AddRefs(currentItemParams)); if (NS_FAILED(rv)) continue; param = (nsAbAutoCompleteParam *)(void *)currentItemParams; if (aPopularityIndex > param->mPopularityIndex) // sort the search results by popularity index break; } rv = array->InsertElementAt(newItem, insertPosition); } } } PR_Free(fullAddrStr); }
PRBool nsCSSScanner::Next(nsresult& aErrorCode, nsCSSToken& aToken) { PRInt32 ch = Read(aErrorCode); if (ch < 0) { return PR_FALSE; } PRUint8* lexTable = gLexTable; // IDENT if (StartsIdent(ch, Peek(aErrorCode), lexTable)) return ParseIdent(aErrorCode, ch, aToken); // From this point on, 0 <= ch < 256. // AT_KEYWORD if (ch == '@') { PRInt32 nextChar = Read(aErrorCode); PRInt32 followingChar = Peek(aErrorCode); Pushback(nextChar); if (StartsIdent(nextChar, followingChar, lexTable)) return ParseAtKeyword(aErrorCode, ch, aToken); } // NUMBER or DIM if ((ch == '.') || (ch == '+') || (ch == '-')) { PRInt32 nextChar = Peek(aErrorCode); if (CheckLexTable(nextChar, IS_DIGIT, lexTable)) { return ParseNumber(aErrorCode, ch, aToken); } else if (('.' == nextChar) && ('.' != ch)) { nextChar = Read(aErrorCode); PRInt32 followingChar = Peek(aErrorCode); Pushback(nextChar); if (CheckLexTable(followingChar, IS_DIGIT, lexTable)) return ParseNumber(aErrorCode, ch, aToken); } } if ((lexTable[ch] & IS_DIGIT) != 0) { return ParseNumber(aErrorCode, ch, aToken); } // ID if (ch == '#') { return ParseRef(aErrorCode, ch, aToken); } // STRING if ((ch == '"') || (ch == '\'')) { return ParseString(aErrorCode, ch, aToken); } // WS if ((lexTable[ch] & IS_WHITESPACE) != 0) { aToken.mType = eCSSToken_WhiteSpace; aToken.mIdent.Assign(PRUnichar(ch)); (void) EatWhiteSpace(aErrorCode); return PR_TRUE; } if (ch == '/') { PRInt32 nextChar = Peek(aErrorCode); if (nextChar == '*') { (void) Read(aErrorCode); #if 0 // If we change our storage data structures such that comments are // stored (for Editor), we should reenable this code, condition it // on being in editor mode, and apply glazou's patch from bug // 60290. aToken.mIdent.SetCapacity(2); aToken.mIdent.Assign(PRUnichar(ch)); aToken.mIdent.Append(PRUnichar(nextChar)); return ParseCComment(aErrorCode, aToken); #endif return SkipCComment(aErrorCode) && Next(aErrorCode, aToken); } } if (ch == '<') { // consume HTML comment tags if (LookAhead(aErrorCode, '!')) { if (LookAhead(aErrorCode, '-')) { if (LookAhead(aErrorCode, '-')) { aToken.mType = eCSSToken_HTMLComment; aToken.mIdent.AssignLiteral("<!--"); return PR_TRUE; } Pushback('-'); } Pushback('!'); } } if (ch == '-') { // check for HTML comment end if (LookAhead(aErrorCode, '-')) { if (LookAhead(aErrorCode, '>')) { aToken.mType = eCSSToken_HTMLComment; aToken.mIdent.AssignLiteral("-->"); return PR_TRUE; } Pushback('-'); } } // INCLUDES ("~=") and DASHMATCH ("|=") if (( ch == '|' ) || ( ch == '~' ) || ( ch == '^' ) || ( ch == '$' ) || ( ch == '*' )) { PRInt32 nextChar = Read(aErrorCode); if ( nextChar == '=' ) { if (ch == '~') { aToken.mType = eCSSToken_Includes; } else if (ch == '|') { aToken.mType = eCSSToken_Dashmatch; } else if (ch == '^') { aToken.mType = eCSSToken_Beginsmatch; } else if (ch == '$') { aToken.mType = eCSSToken_Endsmatch; } else if (ch == '*') { aToken.mType = eCSSToken_Containsmatch; } return PR_TRUE; } else { Pushback(nextChar); } } aToken.mType = eCSSToken_Symbol; aToken.mSymbol = ch; return PR_TRUE; }
/** * Returns a list of nsILocalHandlerApp objects containing local * handlers associated with this mimeinfo. Implemented per * platform using information in this object to generate the * best list. Typically used for an "open with" style user * option. * * @return nsIArray of nsILocalHandlerApp */ NS_IMETHODIMP nsMIMEInfoWin::GetPossibleLocalHandlers(nsIArray **_retval) { nsresult rv; *_retval = nullptr; nsCOMPtr<nsIMutableArray> appList = do_CreateInstance("@mozilla.org/array;1"); if (!appList) return NS_ERROR_FAILURE; nsTArray<nsString> trackList; nsAutoCString fileExt; GetPrimaryExtension(fileExt); nsCOMPtr<nsIWindowsRegKey> regKey = do_CreateInstance("@mozilla.org/windows-registry-key;1"); if (!regKey) return NS_ERROR_FAILURE; nsCOMPtr<nsIWindowsRegKey> appKey = do_CreateInstance("@mozilla.org/windows-registry-key;1"); if (!appKey) return NS_ERROR_FAILURE; nsAutoString workingRegistryPath; bool extKnown = false; if (fileExt.IsEmpty()) { extKnown = true; // Mime type discovery is possible in some cases, through // HKEY_CLASSES_ROOT\MIME\Database\Content Type, however, a number // of file extensions related to mime type are simply not defined, // (application/rss+xml & application/atom+xml are good examples) // in which case we can only provide a generic list. nsAutoCString mimeType; GetMIMEType(mimeType); if (!mimeType.IsEmpty()) { workingRegistryPath.AppendLiteral("MIME\\Database\\Content Type\\"); workingRegistryPath.Append(NS_ConvertASCIItoUTF16(mimeType)); rv = regKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT, workingRegistryPath, nsIWindowsRegKey::ACCESS_QUERY_VALUE); if(NS_SUCCEEDED(rv)) { nsAutoString mimeFileExt; if (NS_SUCCEEDED(regKey->ReadStringValue(EmptyString(), mimeFileExt))) { CopyUTF16toUTF8(mimeFileExt, fileExt); extKnown = false; } } } } nsAutoString fileExtToUse; if (fileExt.First() != '.') fileExtToUse = PRUnichar('.'); fileExtToUse.Append(NS_ConvertUTF8toUTF16(fileExt)); // Note, the order in which these occur has an effect on the // validity of the resulting display list. if (!extKnown) { // 1) Get the default handler if it exists workingRegistryPath = fileExtToUse; rv = regKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT, workingRegistryPath, nsIWindowsRegKey::ACCESS_QUERY_VALUE); if (NS_SUCCEEDED(rv)) { nsAutoString appProgId; if (NS_SUCCEEDED(regKey->ReadStringValue(EmptyString(), appProgId))) { // Bug 358297 - ignore the embedded internet explorer handler if (appProgId != NS_LITERAL_STRING("XPSViewer.Document")) { nsAutoString appFilesystemCommand; if (GetProgIDVerbCommandHandler(appProgId, appFilesystemCommand, false) && !IsPathInList(appFilesystemCommand, trackList)) { ProcessPath(appList, trackList, appFilesystemCommand); } } } regKey->Close(); } // 2) list HKEY_CLASSES_ROOT\.ext\OpenWithList workingRegistryPath = fileExtToUse; workingRegistryPath.AppendLiteral("\\OpenWithList"); rv = regKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT, workingRegistryPath, nsIWindowsRegKey::ACCESS_QUERY_VALUE); if (NS_SUCCEEDED(rv)) { uint32_t count = 0; if (NS_SUCCEEDED(regKey->GetValueCount(&count)) && count > 0) { for (uint32_t index = 0; index < count; index++) { nsAutoString appName; if (NS_FAILED(regKey->GetValueName(index, appName))) continue; // HKEY_CLASSES_ROOT\Applications\firefox.exe = "path params" nsAutoString appFilesystemCommand; if (!GetAppsVerbCommandHandler(appName, appFilesystemCommand, false) || IsPathInList(appFilesystemCommand, trackList)) continue; ProcessPath(appList, trackList, appFilesystemCommand); } } regKey->Close(); } // 3) List HKEY_CLASSES_ROOT\.ext\OpenWithProgids, with the // different step of resolving the progids for the command handler. workingRegistryPath = fileExtToUse; workingRegistryPath.AppendLiteral("\\OpenWithProgids"); rv = regKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT, workingRegistryPath, nsIWindowsRegKey::ACCESS_QUERY_VALUE); if (NS_SUCCEEDED(rv)) { uint32_t count = 0; if (NS_SUCCEEDED(regKey->GetValueCount(&count)) && count > 0) { for (uint32_t index = 0; index < count; index++) { // HKEY_CLASSES_ROOT\.ext\OpenWithProgids\Windows.XPSReachViewer nsAutoString appProgId; if (NS_FAILED(regKey->GetValueName(index, appProgId))) continue; nsAutoString appFilesystemCommand; if (!GetProgIDVerbCommandHandler(appProgId, appFilesystemCommand, false) || IsPathInList(appFilesystemCommand, trackList)) continue; ProcessPath(appList, trackList, appFilesystemCommand); } } regKey->Close(); } // 4) Add any non configured applications located in the MRU list // HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion // \Explorer\FileExts\.ext\OpenWithList workingRegistryPath = NS_LITERAL_STRING("Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\FileExts\\"); workingRegistryPath += fileExtToUse; workingRegistryPath.AppendLiteral("\\OpenWithList"); rv = regKey->Open(nsIWindowsRegKey::ROOT_KEY_CURRENT_USER, workingRegistryPath, nsIWindowsRegKey::ACCESS_QUERY_VALUE); if (NS_SUCCEEDED(rv)) { uint32_t count = 0; if (NS_SUCCEEDED(regKey->GetValueCount(&count)) && count > 0) { for (uint32_t index = 0; index < count; index++) { nsAutoString appName, appValue; if (NS_FAILED(regKey->GetValueName(index, appName))) continue; if (appName.EqualsLiteral("MRUList")) continue; if (NS_FAILED(regKey->ReadStringValue(appName, appValue))) continue; // HKEY_CLASSES_ROOT\Applications\firefox.exe = "path params" nsAutoString appFilesystemCommand; if (!GetAppsVerbCommandHandler(appValue, appFilesystemCommand, false) || IsPathInList(appFilesystemCommand, trackList)) continue; ProcessPath(appList, trackList, appFilesystemCommand); } } } // 5) Add any non configured progids in the MRU list, with the // different step of resolving the progids for the command handler. // HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion // \Explorer\FileExts\.ext\OpenWithProgids workingRegistryPath = NS_LITERAL_STRING("Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\FileExts\\"); workingRegistryPath += fileExtToUse; workingRegistryPath.AppendLiteral("\\OpenWithProgids"); regKey->Open(nsIWindowsRegKey::ROOT_KEY_CURRENT_USER, workingRegistryPath, nsIWindowsRegKey::ACCESS_QUERY_VALUE); if (NS_SUCCEEDED(rv)) { uint32_t count = 0; if (NS_SUCCEEDED(regKey->GetValueCount(&count)) && count > 0) { for (uint32_t index = 0; index < count; index++) { nsAutoString appIndex, appProgId; if (NS_FAILED(regKey->GetValueName(index, appProgId))) continue; nsAutoString appFilesystemCommand; if (!GetProgIDVerbCommandHandler(appProgId, appFilesystemCommand, false) || IsPathInList(appFilesystemCommand, trackList)) continue; ProcessPath(appList, trackList, appFilesystemCommand); } } regKey->Close(); } // 6) Check the perceived type value, and use this to lookup the perceivedtype // open with list. // http://msdn2.microsoft.com/en-us/library/aa969373.aspx workingRegistryPath = fileExtToUse; regKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT, workingRegistryPath, nsIWindowsRegKey::ACCESS_QUERY_VALUE); if (NS_SUCCEEDED(rv)) { nsAutoString perceivedType; rv = regKey->ReadStringValue(NS_LITERAL_STRING("PerceivedType"), perceivedType); if (NS_SUCCEEDED(rv)) { nsAutoString openWithListPath(NS_LITERAL_STRING("SystemFileAssociations\\")); openWithListPath.Append(perceivedType); // no period openWithListPath.Append(NS_LITERAL_STRING("\\OpenWithList")); nsresult rv = appKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT, openWithListPath, nsIWindowsRegKey::ACCESS_QUERY_VALUE); if (NS_SUCCEEDED(rv)) { uint32_t count = 0; if (NS_SUCCEEDED(regKey->GetValueCount(&count)) && count > 0) { for (uint32_t index = 0; index < count; index++) { nsAutoString appName; if (NS_FAILED(regKey->GetValueName(index, appName))) continue; // HKEY_CLASSES_ROOT\Applications\firefox.exe = "path params" nsAutoString appFilesystemCommand; if (!GetAppsVerbCommandHandler(appName, appFilesystemCommand, false) || IsPathInList(appFilesystemCommand, trackList)) continue; ProcessPath(appList, trackList, appFilesystemCommand); } } } } } } // extKnown == false // 7) list global HKEY_CLASSES_ROOT\*\OpenWithList // Listing general purpose handlers, not specific to a mime type or file extension workingRegistryPath = NS_LITERAL_STRING("*\\OpenWithList"); rv = regKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT, workingRegistryPath, nsIWindowsRegKey::ACCESS_QUERY_VALUE); if (NS_SUCCEEDED(rv)) { uint32_t count = 0; if (NS_SUCCEEDED(regKey->GetValueCount(&count)) && count > 0) { for (uint32_t index = 0; index < count; index++) { nsAutoString appName; if (NS_FAILED(regKey->GetValueName(index, appName))) continue; // HKEY_CLASSES_ROOT\Applications\firefox.exe = "path params" nsAutoString appFilesystemCommand; if (!GetAppsVerbCommandHandler(appName, appFilesystemCommand, false) || IsPathInList(appFilesystemCommand, trackList)) continue; ProcessPath(appList, trackList, appFilesystemCommand); } } regKey->Close(); } // 8) General application's list - not file extension specific on windows workingRegistryPath = NS_LITERAL_STRING("Applications"); rv = regKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT, workingRegistryPath, nsIWindowsRegKey::ACCESS_ENUMERATE_SUB_KEYS| nsIWindowsRegKey::ACCESS_QUERY_VALUE); if (NS_SUCCEEDED(rv)) { uint32_t count = 0; if (NS_SUCCEEDED(regKey->GetChildCount(&count)) && count > 0) { for (uint32_t index = 0; index < count; index++) { nsAutoString appName; if (NS_FAILED(regKey->GetChildName(index, appName))) continue; // HKEY_CLASSES_ROOT\Applications\firefox.exe = "path params" nsAutoString appFilesystemCommand; if (!GetAppsVerbCommandHandler(appName, appFilesystemCommand, false) || IsPathInList(appFilesystemCommand, trackList)) continue; ProcessPath(appList, trackList, appFilesystemCommand); } } } // Return to the caller *_retval = appList; NS_ADDREF(*_retval); return NS_OK; }
PRBool nsCSSScanner::ParseNumber(nsresult& aErrorCode, PRInt32 c, nsCSSToken& aToken) { nsString& ident = aToken.mIdent; ident.SetLength(0); PRBool gotDot = (c == '.') ? PR_TRUE : PR_FALSE; if (c != '+') { ident.Append(PRUnichar(c)); } // Gather up characters that make up the number PRUint8* lexTable = gLexTable; for (;;) { c = Read(aErrorCode); if (c < 0) break; if (!gotDot && (c == '.') && CheckLexTable(Peek(aErrorCode), IS_DIGIT, lexTable)) { gotDot = PR_TRUE; } else if ((c > 255) || ((lexTable[c] & IS_DIGIT) == 0)) { break; } ident.Append(PRUnichar(c)); } // Convert number to floating point nsCSSTokenType type = eCSSToken_Number; PRInt32 ec; float value = ident.ToFloat(&ec); // Look at character that terminated the number aToken.mIntegerValid = PR_FALSE; if (c >= 0) { if ((c <= 255) && ((lexTable[c] & START_IDENT) != 0)) { ident.SetLength(0); if (!GatherIdent(aErrorCode, c, ident)) { return PR_FALSE; } type = eCSSToken_Dimension; } else if ('%' == c) { type = eCSSToken_Percentage; value = value / 100.0f; ident.SetLength(0); } else { // Put back character that stopped numeric scan Unread(); if (!gotDot) { aToken.mInteger = ident.ToInteger(&ec); aToken.mIntegerValid = PR_TRUE; } ident.SetLength(0); } } else { // stream ended if (!gotDot) { aToken.mInteger = ident.ToInteger(&ec); aToken.mIntegerValid = PR_TRUE; } ident.SetLength(0); } aToken.mNumber = value; aToken.mType = type; return PR_TRUE; }
bool nsPropertiesParser::ParseValueCharacter( PRUnichar c, const PRUnichar* cur, const PRUnichar* &tokenStart, nsAString& oldValue) { switch (mSpecialState) { // the normal state - look for special characters case eParserSpecial_None: switch (c) { case '\\': if (mHaveMultiLine) // there is nothing to append to mValue yet mHaveMultiLine = false; else mValue += Substring(tokenStart, cur); mSpecialState = eParserSpecial_Escaped; break; case '\n': // if we detected multiline and got only "\\\r" ignore next "\n" if any if (mHaveMultiLine && mMultiLineCanSkipN) { // but don't allow another '\n' to be skipped mMultiLineCanSkipN = false; // Now there is nothing to append to the mValue since we are skipping // whitespaces at the beginning of the new line of the multiline // property. Set tokenStart properly to ensure that nothing is appended // if we find regular line-end or the end of the buffer. tokenStart = cur+1; break; } // no break case '\r': // we're done! We have a key and value mValue += Substring(tokenStart, cur); FinishValueState(oldValue); mHaveMultiLine = false; break; default: // there is nothing to do with normal characters, // but handle multilines correctly if (mHaveMultiLine) { if (c == ' ' || c == '\t') { // don't allow another '\n' to be skipped mMultiLineCanSkipN = false; // Now there is nothing to append to the mValue since we are skipping // whitespaces at the beginning of the new line of the multiline // property. Set tokenStart properly to ensure that nothing is appended // if we find regular line-end or the end of the buffer. tokenStart = cur+1; break; } mHaveMultiLine = false; tokenStart = cur; } break; // from switch on (c) } break; // from switch on (mSpecialState) // saw a \ character, so parse the character after that case eParserSpecial_Escaped: // probably want to start parsing at the next token // other characters, like 'u' might override this tokenStart = cur+1; mSpecialState = eParserSpecial_None; switch (c) { // the easy characters - \t, \n, and so forth case 't': mValue += PRUnichar('\t'); mMinLength = mValue.Length(); break; case 'n': mValue += PRUnichar('\n'); mMinLength = mValue.Length(); break; case 'r': mValue += PRUnichar('\r'); mMinLength = mValue.Length(); break; case '\\': mValue += PRUnichar('\\'); break; // switch to unicode mode! case 'u': case 'U': mSpecialState = eParserSpecial_Unicode; mUnicodeValuesRead = 0; mUnicodeValue = 0; break; // a \ immediately followed by a newline means we're going multiline case '\r': case '\n': mHaveMultiLine = true; mMultiLineCanSkipN = (c == '\r'); mSpecialState = eParserSpecial_None; break; default: // don't recognize the character, so just append it mValue += c; break; } break; // we're in the middle of parsing a 4-character unicode value // like \u5f39 case eParserSpecial_Unicode: if(('0' <= c) && (c <= '9')) mUnicodeValue = (mUnicodeValue << 4) | (c - '0'); else if(('a' <= c) && (c <= 'f')) mUnicodeValue = (mUnicodeValue << 4) | (c - 'a' + 0x0a); else if(('A' <= c) && (c <= 'F')) mUnicodeValue = (mUnicodeValue << 4) | (c - 'A' + 0x0a); else { // non-hex character. Append what we have, and move on. mValue += mUnicodeValue; mMinLength = mValue.Length(); mSpecialState = eParserSpecial_None; // leave tokenStart at this unknown character, so it gets appended tokenStart = cur; // ensure parsing this non-hex character again return false; } if (++mUnicodeValuesRead >= 4) { tokenStart = cur+1; mSpecialState = eParserSpecial_None; mValue += mUnicodeValue; mMinLength = mValue.Length(); } break; } return true; }
nsresult nsRDFXMLSerializer::SerializeProperty(nsIOutputStream* aStream, nsIRDFResource* aResource, nsIRDFResource* aProperty, PRBool aInline, PRInt32* aSkipped) { nsresult rv = NS_OK; PRInt32 skipped = 0; nsCOMPtr<nsISimpleEnumerator> assertions; mDataSource->GetTargets(aResource, aProperty, PR_TRUE, getter_AddRefs(assertions)); if (! assertions) return NS_ERROR_FAILURE; // Serializing the assertion inline is ok as long as the property has // only one target value, and it is a literal that doesn't include line // breaks. PRBool needsChild = PR_FALSE; while (1) { PRBool hasMore = PR_FALSE; assertions->HasMoreElements(&hasMore); if (! hasMore) break; nsCOMPtr<nsISupports> isupports; assertions->GetNext(getter_AddRefs(isupports)); nsCOMPtr<nsIRDFLiteral> literal = do_QueryInterface(isupports); needsChild |= (!literal); if (!needsChild) { assertions->HasMoreElements(&needsChild); if (!needsChild) { const PRUnichar* literalVal = nsnull; literal->GetValueConst(&literalVal); if (literalVal) { for (; *literalVal; literalVal++) { if (*literalVal == PRUnichar('\n') || *literalVal == PRUnichar('\r')) { needsChild = PR_TRUE; break; } } } } } if (aInline && !needsChild) { rv = SerializeInlineAssertion(aStream, aResource, aProperty, literal); } else if (!aInline && needsChild) { nsCOMPtr<nsIRDFNode> value = do_QueryInterface(isupports); rv = SerializeChildAssertion(aStream, aResource, aProperty, value); } else { ++skipped; rv = NS_OK; } if (NS_FAILED(rv)) break; } *aSkipped += skipped; return rv; }
void nsXBLPrototypeHandler::ConstructPrototype(nsIContent* aKeyElement, const PRUnichar* aEvent, const PRUnichar* aPhase, const PRUnichar* aAction, const PRUnichar* aCommand, const PRUnichar* aKeyCode, const PRUnichar* aCharCode, const PRUnichar* aModifiers, const PRUnichar* aButton, const PRUnichar* aClickCount, const PRUnichar* aGroup, const PRUnichar* aPreventDefault, const PRUnichar* aAllowUntrusted) { mType = 0; if (aKeyElement) { mType |= NS_HANDLER_TYPE_XUL; nsCOMPtr<nsIWeakReference> weak = do_GetWeakReference(aKeyElement); if (!weak) { return; } weak.swap(mHandlerElement); } else { mType |= aCommand ? NS_HANDLER_TYPE_XBL_COMMAND : NS_HANDLER_TYPE_XBL_JS; mHandlerText = nsnull; } mDetail = -1; mMisc = 0; mKeyMask = 0; mPhase = NS_PHASE_BUBBLING; if (aAction) mHandlerText = ToNewUnicode(nsDependentString(aAction)); else if (aCommand) mHandlerText = ToNewUnicode(nsDependentString(aCommand)); nsAutoString event(aEvent); if (event.IsEmpty()) { if (mType & NS_HANDLER_TYPE_XUL) GetEventType(event); if (event.IsEmpty()) return; } mEventName = do_GetAtom(event); if (aPhase) { const nsDependentString phase(aPhase); if (phase.EqualsLiteral("capturing")) mPhase = NS_PHASE_CAPTURING; else if (phase.EqualsLiteral("target")) mPhase = NS_PHASE_TARGET; } // Button and clickcount apply only to XBL handlers and don't apply to XUL key // handlers. if (aButton && *aButton) mDetail = *aButton - '0'; if (aClickCount && *aClickCount) mMisc = *aClickCount - '0'; // Modifiers are supported by both types of handlers (XUL and XBL). nsAutoString modifiers(aModifiers); if (mType & NS_HANDLER_TYPE_XUL) aKeyElement->GetAttr(kNameSpaceID_None, nsGkAtoms::modifiers, modifiers); if (!modifiers.IsEmpty()) { mKeyMask = cAllModifiers; char* str = ToNewCString(modifiers); char* newStr; char* token = nsCRT::strtok( str, ", \t", &newStr ); while( token != NULL ) { if (PL_strcmp(token, "shift") == 0) mKeyMask |= cShift | cShiftMask; else if (PL_strcmp(token, "alt") == 0) mKeyMask |= cAlt | cAltMask; else if (PL_strcmp(token, "meta") == 0) mKeyMask |= cMeta | cMetaMask; else if (PL_strcmp(token, "control") == 0) mKeyMask |= cControl | cControlMask; else if (PL_strcmp(token, "accel") == 0) mKeyMask |= KeyToMask(kAccelKey); else if (PL_strcmp(token, "access") == 0) mKeyMask |= KeyToMask(kMenuAccessKey); else if (PL_strcmp(token, "any") == 0) mKeyMask &= ~(mKeyMask << 4); token = nsCRT::strtok( newStr, ", \t", &newStr ); } nsMemory::Free(str); } nsAutoString key(aCharCode); if (key.IsEmpty()) { if (mType & NS_HANDLER_TYPE_XUL) { aKeyElement->GetAttr(kNameSpaceID_None, nsGkAtoms::key, key); if (key.IsEmpty()) aKeyElement->GetAttr(kNameSpaceID_None, nsGkAtoms::charcode, key); } } if (!key.IsEmpty()) { if (mKeyMask == 0) mKeyMask = cAllModifiers; ToLowerCase(key); // We have a charcode. mMisc = 1; mDetail = key[0]; const PRUint8 GTK2Modifiers = cShift | cControl | cShiftMask | cControlMask; if ((mKeyMask & GTK2Modifiers) == GTK2Modifiers && modifiers.First() != PRUnichar(',') && (mDetail == 'u' || mDetail == 'U')) ReportKeyConflict(key.get(), modifiers.get(), aKeyElement, "GTK2Conflict"); const PRUint8 WinModifiers = cControl | cAlt | cControlMask | cAltMask; if ((mKeyMask & WinModifiers) == WinModifiers && modifiers.First() != PRUnichar(',') && (('A' <= mDetail && mDetail <= 'Z') || ('a' <= mDetail && mDetail <= 'z'))) ReportKeyConflict(key.get(), modifiers.get(), aKeyElement, "WinConflict"); } else { key.Assign(aKeyCode); if (mType & NS_HANDLER_TYPE_XUL) aKeyElement->GetAttr(kNameSpaceID_None, nsGkAtoms::keycode, key); if (!key.IsEmpty()) { if (mKeyMask == 0) mKeyMask = cAllModifiers; mDetail = GetMatchingKeyCode(key); } } if (aGroup && nsDependentString(aGroup).EqualsLiteral("system")) mType |= NS_HANDLER_TYPE_SYSTEM; if (aPreventDefault && nsDependentString(aPreventDefault).EqualsLiteral("true")) mType |= NS_HANDLER_TYPE_PREVENTDEFAULT; if (aAllowUntrusted) { mType |= NS_HANDLER_HAS_ALLOW_UNTRUSTED_ATTR; if (nsDependentString(aAllowUntrusted).EqualsLiteral("true")) { mType |= NS_HANDLER_ALLOW_UNTRUSTED; } else { mType &= ~NS_HANDLER_ALLOW_UNTRUSTED; } } }
void gfxGDIFont::Initialize() { NS_ASSERTION(!mMetrics, "re-creating metrics? this will leak"); LOGFONTW logFont; // Figure out if we want to do synthetic oblique styling. GDIFontEntry* fe = static_cast<GDIFontEntry*>(GetFontEntry()); bool wantFakeItalic = (mStyle.style & (NS_FONT_STYLE_ITALIC | NS_FONT_STYLE_OBLIQUE)) && !fe->IsItalic(); // If the font's family has an actual italic face (but font matching // didn't choose it), we have to use a cairo transform instead of asking // GDI to italicize, because that would use a different face and result // in a possible glyph ID mismatch between shaping and rendering. // // We use the mFamilyHasItalicFace flag in the entry in case of user fonts, // where the *CSS* family may not know about italic faces that are present // in the *GDI* family, and which GDI would use if we asked it to perform // the "italicization". bool useCairoFakeItalic = wantFakeItalic && fe->mFamilyHasItalicFace; if (mAdjustedSize == 0.0) { mAdjustedSize = mStyle.size; if (mStyle.sizeAdjust != 0.0 && mAdjustedSize > 0.0) { // to implement font-size-adjust, we first create the "unadjusted" font FillLogFont(logFont, mAdjustedSize, wantFakeItalic && !useCairoFakeItalic); mFont = ::CreateFontIndirectW(&logFont); // initialize its metrics so we can calculate size adjustment Initialize(); // calculate the properly adjusted size, and then proceed // to recreate mFont and recalculate metrics gfxFloat aspect = mMetrics->xHeight / mMetrics->emHeight; mAdjustedSize = mStyle.GetAdjustedSize(aspect); // delete the temporary font and metrics ::DeleteObject(mFont); mFont = nullptr; delete mMetrics; mMetrics = nullptr; } } // (bug 724231) for local user fonts, we don't use GDI's synthetic bold, // as it could lead to a different, incompatible face being used // but instead do our own multi-striking if (mNeedsBold && GetFontEntry()->IsLocalUserFont()) { mApplySyntheticBold = true; } // this may end up being zero mAdjustedSize = ROUND(mAdjustedSize); FillLogFont(logFont, mAdjustedSize, wantFakeItalic && !useCairoFakeItalic); mFont = ::CreateFontIndirectW(&logFont); mMetrics = new gfxFont::Metrics; ::memset(mMetrics, 0, sizeof(*mMetrics)); AutoDC dc; SetGraphicsMode(dc.GetDC(), GM_ADVANCED); AutoSelectFont selectFont(dc.GetDC(), mFont); // Get font metrics if size > 0 if (mAdjustedSize > 0.0) { OUTLINETEXTMETRIC oMetrics; TEXTMETRIC& metrics = oMetrics.otmTextMetrics; if (0 < GetOutlineTextMetrics(dc.GetDC(), sizeof(oMetrics), &oMetrics)) { mMetrics->superscriptOffset = (double)oMetrics.otmptSuperscriptOffset.y; // Some fonts have wrong sign on their subscript offset, bug 410917. mMetrics->subscriptOffset = fabs((double)oMetrics.otmptSubscriptOffset.y); mMetrics->strikeoutSize = (double)oMetrics.otmsStrikeoutSize; mMetrics->strikeoutOffset = (double)oMetrics.otmsStrikeoutPosition; mMetrics->underlineSize = (double)oMetrics.otmsUnderscoreSize; mMetrics->underlineOffset = (double)oMetrics.otmsUnderscorePosition; const MAT2 kIdentityMatrix = { {0, 1}, {0, 0}, {0, 0}, {0, 1} }; GLYPHMETRICS gm; DWORD len = GetGlyphOutlineW(dc.GetDC(), PRUnichar('x'), GGO_METRICS, &gm, 0, nullptr, &kIdentityMatrix); if (len == GDI_ERROR || gm.gmptGlyphOrigin.y <= 0) { // 56% of ascent, best guess for true type mMetrics->xHeight = ROUND((double)metrics.tmAscent * DEFAULT_XHEIGHT_FACTOR); } else { mMetrics->xHeight = gm.gmptGlyphOrigin.y; } mMetrics->emHeight = metrics.tmHeight - metrics.tmInternalLeading; gfxFloat typEmHeight = (double)oMetrics.otmAscent - (double)oMetrics.otmDescent; mMetrics->emAscent = ROUND(mMetrics->emHeight * (double)oMetrics.otmAscent / typEmHeight); mMetrics->emDescent = mMetrics->emHeight - mMetrics->emAscent; if (oMetrics.otmEMSquare > 0) { mFUnitsConvFactor = float(mAdjustedSize / oMetrics.otmEMSquare); } } else { // Make a best-effort guess at extended metrics // this is based on general typographic guidelines // GetTextMetrics can fail if the font file has been removed // or corrupted recently. BOOL result = GetTextMetrics(dc.GetDC(), &metrics); if (!result) { NS_WARNING("Missing or corrupt font data, fasten your seatbelt"); mIsValid = false; memset(mMetrics, 0, sizeof(*mMetrics)); return; } mMetrics->xHeight = ROUND((float)metrics.tmAscent * DEFAULT_XHEIGHT_FACTOR); mMetrics->superscriptOffset = mMetrics->xHeight; mMetrics->subscriptOffset = mMetrics->xHeight; mMetrics->strikeoutSize = 1; mMetrics->strikeoutOffset = ROUND(mMetrics->xHeight * 0.5f); // 50% of xHeight mMetrics->underlineSize = 1; mMetrics->underlineOffset = -ROUND((float)metrics.tmDescent * 0.30f); // 30% of descent mMetrics->emHeight = metrics.tmHeight - metrics.tmInternalLeading; mMetrics->emAscent = metrics.tmAscent - metrics.tmInternalLeading; mMetrics->emDescent = metrics.tmDescent; } mMetrics->internalLeading = metrics.tmInternalLeading; mMetrics->externalLeading = metrics.tmExternalLeading; mMetrics->maxHeight = metrics.tmHeight; mMetrics->maxAscent = metrics.tmAscent; mMetrics->maxDescent = metrics.tmDescent; mMetrics->maxAdvance = metrics.tmMaxCharWidth; mMetrics->aveCharWidth = std::max<gfxFloat>(1, metrics.tmAveCharWidth); // The font is monospace when TMPF_FIXED_PITCH is *not* set! // See http://msdn2.microsoft.com/en-us/library/ms534202(VS.85).aspx if (!(metrics.tmPitchAndFamily & TMPF_FIXED_PITCH)) { mMetrics->maxAdvance = mMetrics->aveCharWidth; } // Cache the width of a single space. SIZE size; GetTextExtentPoint32W(dc.GetDC(), L" ", 1, &size); mMetrics->spaceWidth = ROUND(size.cx); // Cache the width of digit zero. // XXX MSDN (http://msdn.microsoft.com/en-us/library/ms534223.aspx) // does not say what the failure modes for GetTextExtentPoint32 are - // is it safe to assume it will fail iff the font has no '0'? if (GetTextExtentPoint32W(dc.GetDC(), L"0", 1, &size)) { mMetrics->zeroOrAveCharWidth = ROUND(size.cx); } else { mMetrics->zeroOrAveCharWidth = mMetrics->aveCharWidth; } WORD glyph; DWORD ret = GetGlyphIndicesW(dc.GetDC(), L" ", 1, &glyph, GGI_MARK_NONEXISTING_GLYPHS); if (ret != GDI_ERROR && glyph != 0xFFFF) { mSpaceGlyph = glyph; } SanitizeMetrics(mMetrics, GetFontEntry()->mIsBadUnderlineFont); } if (IsSyntheticBold()) { mMetrics->aveCharWidth += GetSyntheticBoldOffset(); mMetrics->maxAdvance += GetSyntheticBoldOffset(); } mFontFace = cairo_win32_font_face_create_for_logfontw_hfont(&logFont, mFont); cairo_matrix_t sizeMatrix, ctm; cairo_matrix_init_identity(&ctm); cairo_matrix_init_scale(&sizeMatrix, mAdjustedSize, mAdjustedSize); if (useCairoFakeItalic) { // Skew the matrix to do fake italic if it wasn't already applied // via the LOGFONT double skewfactor = OBLIQUE_SKEW_FACTOR; cairo_matrix_t style; cairo_matrix_init(&style, 1, //xx 0, //yx -1 * skewfactor, //xy 1, //yy 0, //x0 0); //y0 cairo_matrix_multiply(&sizeMatrix, &sizeMatrix, &style); } cairo_font_options_t *fontOptions = cairo_font_options_create(); if (mAntialiasOption != kAntialiasDefault) { cairo_font_options_set_antialias(fontOptions, GetCairoAntialiasOption(mAntialiasOption)); } mScaledFont = cairo_scaled_font_create(mFontFace, &sizeMatrix, &ctm, fontOptions); cairo_font_options_destroy(fontOptions); if (!mScaledFont || cairo_scaled_font_status(mScaledFont) != CAIRO_STATUS_SUCCESS) { #ifdef DEBUG char warnBuf[1024]; sprintf(warnBuf, "Failed to create scaled font: %s status: %d", NS_ConvertUTF16toUTF8(mFontEntry->Name()).get(), mScaledFont ? cairo_scaled_font_status(mScaledFont) : 0); NS_WARNING(warnBuf); #endif mIsValid = false; } else { mIsValid = true; } #if 0 printf("Font: %p (%s) size: %f adjusted size: %f valid: %s\n", this, NS_ConvertUTF16toUTF8(GetName()).get(), mStyle.size, mAdjustedSize, (mIsValid ? "yes" : "no")); printf(" emHeight: %f emAscent: %f emDescent: %f\n", mMetrics->emHeight, mMetrics->emAscent, mMetrics->emDescent); printf(" maxAscent: %f maxDescent: %f maxAdvance: %f\n", mMetrics->maxAscent, mMetrics->maxDescent, mMetrics->maxAdvance); printf(" internalLeading: %f externalLeading: %f\n", mMetrics->internalLeading, mMetrics->externalLeading); printf(" spaceWidth: %f aveCharWidth: %f xHeight: %f\n", mMetrics->spaceWidth, mMetrics->aveCharWidth, mMetrics->xHeight); printf(" uOff: %f uSize: %f stOff: %f stSize: %f supOff: %f subOff: %f\n", mMetrics->underlineOffset, mMetrics->underlineSize, mMetrics->strikeoutOffset, mMetrics->strikeoutSize, mMetrics->superscriptOffset, mMetrics->subscriptOffset); #endif }
/* * Converts the value of the given double to a String, and places * The result into the destination String. * @return the given dest string */ void txDouble::toString(double aValue, nsAString& aDest) { // check for special cases if (MOZ_DOUBLE_IS_NaN(aValue)) { aDest.AppendLiteral("NaN"); return; } if (MOZ_DOUBLE_IS_INFINITE(aValue)) { if (aValue < 0) aDest.Append(PRUnichar('-')); aDest.AppendLiteral("Infinity"); return; } // Mantissa length is 17, so this is plenty const int buflen = 20; char buf[buflen]; int intDigits, sign; char* endp; PR_dtoa(aValue, 0, 0, &intDigits, &sign, &endp, buf, buflen - 1); // compute length int32_t length = endp - buf; if (length > intDigits) { // decimal point needed ++length; if (intDigits < 1) { // leading zeros, -intDigits + 1 length += 1 - intDigits; } } else { // trailing zeros, total length given by intDigits length = intDigits; } if (aValue < 0) ++length; // grow the string uint32_t oldlength = aDest.Length(); if (!aDest.SetLength(oldlength + length, mozilla::fallible_t())) return; // out of memory nsAString::iterator dest; aDest.BeginWriting(dest).advance(int32_t(oldlength)); if (aValue < 0) { *dest = '-'; ++dest; } int i; // leading zeros if (intDigits < 1) { *dest = '0'; ++dest; *dest = '.'; ++dest; for (i = 0; i > intDigits; --i) { *dest = '0'; ++dest; } } // mantissa int firstlen = std::min<size_t>(intDigits, endp - buf); for (i = 0; i < firstlen; i++) { *dest = buf[i]; ++dest; } if (i < endp - buf) { if (i > 0) { *dest = '.'; ++dest; } for (; i < endp - buf; i++) { *dest = buf[i]; ++dest; } } // trailing zeros for (; i < intDigits; i++) { *dest = '0'; ++dest; } }
NS_INTERFACE_MAP_END // nsIDOMCSSValue NS_IMETHODIMP nsROCSSPrimitiveValue::GetCssText(nsAString& aCssText) { nsAutoString tmpStr; aCssText.Truncate(); nsresult result = NS_OK; switch (mType) { case CSS_PX : { float val = nsPresContext::AppUnitsToFloatCSSPixels(mValue.mAppUnits); tmpStr.AppendFloat(val); tmpStr.AppendLiteral("px"); break; } case CSS_IDENT : { AppendUTF8toUTF16(nsCSSKeywords::GetStringValue(mValue.mKeyword), tmpStr); break; } case CSS_STRING : case CSS_COUNTER : /* FIXME: COUNTER should use an object */ { tmpStr.Append(mValue.mString); break; } case CSS_URI : { if (mValue.mURI) { nsCAutoString specUTF8; mValue.mURI->GetSpec(specUTF8); tmpStr.AssignLiteral("url("); nsStyleUtil::AppendEscapedCSSString(NS_ConvertUTF8toUTF16(specUTF8), tmpStr); tmpStr.AppendLiteral(")"); } else { // XXXldb Any better ideas? It's good to have something that // doesn't parse so that things round-trip "correctly". tmpStr.Assign(NS_LITERAL_STRING("url(invalid-url:)")); } break; } case CSS_ATTR : { tmpStr.AppendLiteral("attr("); tmpStr.Append(mValue.mString); tmpStr.Append(PRUnichar(')')); break; } case CSS_PERCENTAGE : { tmpStr.AppendFloat(mValue.mFloat * 100); tmpStr.Append(PRUnichar('%')); break; } case CSS_NUMBER : { tmpStr.AppendFloat(mValue.mFloat); break; } case CSS_RECT : { NS_ASSERTION(mValue.mRect, "mValue.mRect should never be null"); NS_NAMED_LITERAL_STRING(comma, ", "); nsCOMPtr<nsIDOMCSSPrimitiveValue> sideCSSValue; nsAutoString sideValue; tmpStr.AssignLiteral("rect("); // get the top result = mValue.mRect->GetTop(getter_AddRefs(sideCSSValue)); if (NS_FAILED(result)) break; result = sideCSSValue->GetCssText(sideValue); if (NS_FAILED(result)) break; tmpStr.Append(sideValue + comma); // get the right result = mValue.mRect->GetRight(getter_AddRefs(sideCSSValue)); if (NS_FAILED(result)) break; result = sideCSSValue->GetCssText(sideValue); if (NS_FAILED(result)) break; tmpStr.Append(sideValue + comma); // get the bottom result = mValue.mRect->GetBottom(getter_AddRefs(sideCSSValue)); if (NS_FAILED(result)) break; result = sideCSSValue->GetCssText(sideValue); if (NS_FAILED(result)) break; tmpStr.Append(sideValue + comma); // get the left result = mValue.mRect->GetLeft(getter_AddRefs(sideCSSValue)); if (NS_FAILED(result)) break; result = sideCSSValue->GetCssText(sideValue); if (NS_FAILED(result)) break; tmpStr.Append(sideValue + NS_LITERAL_STRING(")")); break; } case CSS_RGBCOLOR : { NS_ASSERTION(mValue.mColor, "mValue.mColor should never be null"); NS_NAMED_LITERAL_STRING(comma, ", "); nsCOMPtr<nsIDOMCSSPrimitiveValue> colorCSSValue; nsAutoString colorValue; if (mValue.mColor->HasAlpha()) tmpStr.AssignLiteral("rgba("); else tmpStr.AssignLiteral("rgb("); // get the red component result = mValue.mColor->GetRed(getter_AddRefs(colorCSSValue)); if (NS_FAILED(result)) break; result = colorCSSValue->GetCssText(colorValue); if (NS_FAILED(result)) break; tmpStr.Append(colorValue + comma); // get the green component result = mValue.mColor->GetGreen(getter_AddRefs(colorCSSValue)); if (NS_FAILED(result)) break; result = colorCSSValue->GetCssText(colorValue); if (NS_FAILED(result)) break; tmpStr.Append(colorValue + comma); // get the blue component result = mValue.mColor->GetBlue(getter_AddRefs(colorCSSValue)); if (NS_FAILED(result)) break; result = colorCSSValue->GetCssText(colorValue); if (NS_FAILED(result)) break; tmpStr.Append(colorValue); if (mValue.mColor->HasAlpha()) { // get the alpha component result = mValue.mColor->GetAlpha(getter_AddRefs(colorCSSValue)); if (NS_FAILED(result)) break; result = colorCSSValue->GetCssText(colorValue); if (NS_FAILED(result)) break; tmpStr.Append(comma + colorValue); } tmpStr.Append(NS_LITERAL_STRING(")")); break; } case CSS_S : { tmpStr.AppendFloat(mValue.mFloat); tmpStr.AppendLiteral("s"); break; } case CSS_CM : case CSS_MM : case CSS_IN : case CSS_PT : case CSS_PC : case CSS_UNKNOWN : case CSS_EMS : case CSS_EXS : case CSS_DEG : case CSS_RAD : case CSS_GRAD : case CSS_MS : case CSS_HZ : case CSS_KHZ : case CSS_DIMENSION : NS_ERROR("We have a bogus value set. This should not happen"); return NS_ERROR_DOM_INVALID_ACCESS_ERR; } if (NS_SUCCEEDED(result)) { aCssText.Assign(tmpStr); } return NS_OK; }
#include "nsCOMPtr.h" #include "nsIServiceManager.h" #include "nsIComponentManager.h" #include "nsReadableUtils.h" #include "nsIURI.h" #include "nsIConsoleService.h" #include "nsIScriptError.h" #include "nsIStringBundle.h" #include "nsContentUtils.h" // Don't bother collecting whitespace characters in token's mIdent buffer #undef COLLECT_WHITESPACE #define BUFFER_SIZE 256 static const PRUnichar CSS_ESCAPE = PRUnichar('\\'); const PRUint8 nsCSSScanner::IS_DIGIT = 0x01; const PRUint8 nsCSSScanner::IS_HEX_DIGIT = 0x02; const PRUint8 nsCSSScanner::START_IDENT = 0x04; const PRUint8 nsCSSScanner::IS_IDENT = 0x08; const PRUint8 nsCSSScanner::IS_WHITESPACE = 0x10; static PRBool gLexTableSetup = PR_FALSE; PRUint8 nsCSSScanner::gLexTable[256]; #ifdef CSS_REPORT_PARSE_ERRORS static PRBool gReportErrors = PR_TRUE; static nsIConsoleService *gConsoleService; static nsIFactory *gScriptErrorFactory; static nsIStringBundle *gStringBundle; #endif
void ImportEudoraMailImpl::AddLinebreak(nsString *pStream) { if (pStream) pStream->Append(PRUnichar('\n')); }
void nsCSSToken::AppendToString(nsString& aBuffer) { switch (mType) { case eCSSToken_AtKeyword: aBuffer.Append(PRUnichar('@')); // fall through intentional case eCSSToken_Ident: case eCSSToken_WhiteSpace: case eCSSToken_Function: case eCSSToken_URL: case eCSSToken_InvalidURL: case eCSSToken_HTMLComment: aBuffer.Append(mIdent); break; case eCSSToken_Number: if (mIntegerValid) { aBuffer.AppendInt(mInteger, 10); } else { aBuffer.AppendFloat(mNumber); } break; case eCSSToken_Percentage: NS_ASSERTION(!mIntegerValid, "How did a percentage token get this set?"); aBuffer.AppendFloat(mNumber * 100.0f); aBuffer.Append(PRUnichar('%')); // STRING USE WARNING: technically, this should be |AppendWithConversion| break; case eCSSToken_Dimension: if (mIntegerValid) { aBuffer.AppendInt(mInteger, 10); } else { aBuffer.AppendFloat(mNumber); } aBuffer.Append(mIdent); break; case eCSSToken_String: aBuffer.Append(mSymbol); aBuffer.Append(mIdent); // fall through intentional case eCSSToken_Symbol: aBuffer.Append(mSymbol); break; case eCSSToken_ID: case eCSSToken_Ref: aBuffer.Append(PRUnichar('#')); aBuffer.Append(mIdent); break; case eCSSToken_Includes: aBuffer.AppendLiteral("~="); break; case eCSSToken_Dashmatch: aBuffer.AppendLiteral("|="); break; case eCSSToken_Error: aBuffer.Append(mSymbol); aBuffer.Append(mIdent); break; default: NS_ERROR("invalid token type"); break; } }
// additional style context to be used by our MathMLChar. #define NS_MATHML_CHAR_STYLE_CONTEXT_INDEX 0 nsIFrame* NS_NewMathMLmoFrame(nsIPresShell* aPresShell, nsStyleContext *aContext) { return new (aPresShell) nsMathMLmoFrame(aContext); } NS_IMPL_FRAMEARENA_HELPERS(nsMathMLmoFrame) nsMathMLmoFrame::~nsMathMLmoFrame() { } static const PRUnichar kInvisibleComma = PRUnichar(0x200B); // a.k.a. ZERO WIDTH SPACE static const PRUnichar kApplyFunction = PRUnichar(0x2061); static const PRUnichar kInvisibleTimes = PRUnichar(0x2062); static const PRUnichar kNullCh = PRUnichar('\0'); eMathMLFrameType nsMathMLmoFrame::GetMathMLFrameType() { return NS_MATHML_OPERATOR_IS_INVISIBLE(mFlags) ? eMathMLFrameType_OperatorInvisible : eMathMLFrameType_OperatorOrdinary; } // since a mouse click implies selection, we cannot just rely on the // frame's state bit in our child text frame. So we will first check // its selected state bit, and use this little helper to double check.
/* void onStartLookup (in wstring searchString, in nsIAutoCompleteResults previousSearchResult, in nsIAutoCompleteListener listener); */ NS_IMETHODIMP nsLDAPAutoCompleteSession::OnStartLookup(const PRUnichar *searchString, nsIAutoCompleteResults *previousSearchResult, nsIAutoCompleteListener *listener) { NS_ENSURE_ARG_POINTER(listener); if (!mFormatter) { NS_WARNING("mFormatter should not be null for nsLDAPAutoCompleteSession::OnStartLookup"); return NS_ERROR_NOT_INITIALIZED; } nsresult rv; // Hold return values from XPCOM calls #ifdef PR_LOGGING // Initialize logging, if it hasn't been already. if (!sLDAPAutoCompleteLogModule) { sLDAPAutoCompleteLogModule = PR_NewLogModule("ldapautocomplete"); NS_ABORT_IF_FALSE(sLDAPAutoCompleteLogModule, "failed to initialize ldapautocomplete log module"); } #endif PR_LOG(sLDAPAutoCompleteLogModule, PR_LOG_DEBUG, ("nsLDAPAutoCompleteSession::OnStartLookup entered\n")); mListener = listener; // Ignore the empty string, strings with @ in them, and strings // that are too short. if (searchString[0] == 0 || nsDependentString(searchString).FindChar(PRUnichar('@'), 0) != -1 || nsDependentString(searchString).FindChar(PRUnichar(','), 0) != -1 || ( !IS_CJK_CHAR_FOR_LDAP(searchString[0]) ? mMinStringLength && NS_strlen(searchString) < mMinStringLength : mCjkMinStringLength && NS_strlen(searchString) < mCjkMinStringLength ) ) { FinishAutoCompleteLookup(nsIAutoCompleteStatus::ignored, 0, mState); return NS_OK; } else { mSearchString = searchString; // save it for later use } // Make sure this was called appropriately. if (mState == SEARCHING || mState == BINDING) { NS_ERROR("nsLDAPAutoCompleteSession::OnStartLookup(): called while " "search already in progress; no lookup started."); FinishAutoCompleteLookup(nsIAutoCompleteStatus::failureItems, NS_ERROR_FAILURE, mState); return NS_ERROR_FAILURE; } // See if this is a narrow search that we could potentially do locally. if (previousSearchResult) { // Get the string representing previous search results. nsString prevSearchStr; rv = previousSearchResult->GetSearchString( getter_Copies(prevSearchStr)); if ( NS_FAILED(rv) ) { NS_ERROR("nsLDAPAutoCompleteSession::OnStartLookup(): couldn't " "get search string from previousSearchResult"); FinishAutoCompleteLookup(nsIAutoCompleteStatus::failureItems, NS_ERROR_FAILURE, mState); return NS_ERROR_FAILURE; } // Does the string actually contain anything? if ( prevSearchStr.get() && prevSearchStr.get()[0]) { PR_LOG(sLDAPAutoCompleteLogModule, PR_LOG_DEBUG, ("nsLDAPAutoCompleteSession::OnStartLookup(): starting " "narrowing search\n")); // XXXdmose for performance, we should really do a local, // synchronous search against the existing dataset instead of // just kicking off a new LDAP search here. When implementing // this, need to be sure that only previous results which did not // hit the size limit and were successfully completed are used. // mState = SEARCHING; return DoTask(); } } // Init connection if necessary // switch (mState) { case UNBOUND: // Initialize the connection. // rv = InitConnection(); if (NS_FAILED(rv)) { // InitConnection() will have already called // FinishAutoCompleteLookup for us as necessary // return rv; } return NS_OK; case BOUND: PR_LOG(sLDAPAutoCompleteLogModule, PR_LOG_DEBUG, ("nsLDAPAutoComplete::OnStartLookup(): subsequent search " "starting")); // Kick off an LDAP search mState = SEARCHING; return DoTask(); case INITIALIZING: // We don't need to do anything here (for now at least), because // we can't really abandon the initialization. If we allowed the // initialization to be aborted, we could potentially lock the // UI thread again, since the DNS service might be stalled. // return NS_OK; case BINDING: case SEARCHING: // We should never get here NS_ERROR("nsLDAPAutoCompleteSession::OnStartLookup(): unexpected " "value of mStatus"); return NS_ERROR_UNEXPECTED; } return NS_ERROR_UNEXPECTED; /*NOTREACHED*/ }