void GDIFontFamily::FindStyleVariations() { if (mHasStyles) return; mHasStyles = PR_TRUE; HDC hdc = GetDC(nsnull); SetGraphicsMode(hdc, GM_ADVANCED); LOGFONTW logFont; memset(&logFont, 0, sizeof(LOGFONTW)); logFont.lfCharSet = DEFAULT_CHARSET; logFont.lfPitchAndFamily = 0; PRUint32 l = PR_MIN(mName.Length(), LF_FACESIZE - 1); memcpy(logFont.lfFaceName, nsPromiseFlatString(mName).get(), l * sizeof(PRUnichar)); logFont.lfFaceName[l] = 0; EnumFontFamiliesExW(hdc, &logFont, (FONTENUMPROCW)GDIFontFamily::FamilyAddStylesProc, (LPARAM)this, 0); #ifdef PR_LOGGING if (LOG_FONTLIST_ENABLED() && mAvailableFonts.Length() == 0) { LOG_FONTLIST(("(fontlist) no styles available in family \"%s\"", NS_ConvertUTF16toUTF8(mName).get())); } #endif ReleaseDC(nsnull, hdc); if (mIsBadUnderlineFamily) SetBadUnderlineFonts(); }
void GDIFontEntry::InitLogFont(const nsAString& aName, gfxWindowsFontType aFontType) { #define CLIP_TURNOFF_FONTASSOCIATION 0x40 mLogFont.lfHeight = -1; // Fill in logFont structure mLogFont.lfWidth = 0; mLogFont.lfEscapement = 0; mLogFont.lfOrientation = 0; mLogFont.lfUnderline = FALSE; mLogFont.lfStrikeOut = FALSE; mLogFont.lfCharSet = DEFAULT_CHARSET; mLogFont.lfOutPrecision = FontTypeToOutPrecision(aFontType); mLogFont.lfClipPrecision = CLIP_TURNOFF_FONTASSOCIATION; mLogFont.lfQuality = DEFAULT_QUALITY; mLogFont.lfPitchAndFamily = DEFAULT_PITCH | FF_DONTCARE; // always force lfItalic if we want it. Font selection code will // do its best to give us an italic font entry, but if no face exists // it may give us a regular one based on weight. Windows should // do fake italic for us in that case. mLogFont.lfItalic = mItalic; mLogFont.lfWeight = mWeight; int len = PR_MIN(aName.Length(), LF_FACESIZE - 1); memcpy(&mLogFont.lfFaceName, nsPromiseFlatString(aName).get(), len * 2); mLogFont.lfFaceName[len] = '\0'; }
NS_IMETHODIMP nsSOAPMessage::Encode(PRUint16 aVersion, const nsAString & aMethodName, const nsAString & aTargetObjectURI, PRUint32 aHeaderBlockCount, nsISOAPHeaderBlock ** aHeaderBlocks, PRUint32 aParameterCount, nsISOAPParameter ** aParameters) { static NS_NAMED_LITERAL_STRING(realEmptySOAPDocStr1, "<env:Envelope xmlns:env=\"http://schemas.xmlsoap.org/soap/envelope/\" xmlns:enc=\"http://schemas.xmlsoap.org/soap/encoding/\"><env:Header/><env:Body/></env:Envelope>"); static NS_NAMED_LITERAL_STRING(realEmptySOAPDocStr2, "<env:Envelope xmlns:env=\"http://www.w3.org/2001/09/soap-envelope\" xmlns:enc=\"http://www.w3.org/2001/09/soap-encoding\"><env:Header/><env:Body/></env:Envelope>"); static const nsAString *kEmptySOAPDocStr[] = { &realEmptySOAPDocStr1, &realEmptySOAPDocStr2 }; if (aVersion != nsISOAPMessage::VERSION_1_1 && aVersion != nsISOAPMessage::VERSION_1_2) return SOAP_EXCEPTION(NS_ERROR_ILLEGAL_VALUE,"SOAP_BAD_VALUE","Cannot encode message blocks without a valid SOAP version specified."); // Construct the message skeleton nsresult rv; nsCOMPtr<nsIDOMNode> ignored; nsCOMPtr<nsIDOMParser> parser = do_CreateInstance(kDOMParserCID, &rv); if (NS_FAILED(rv)) return rv; rv = parser->ParseFromString(nsPromiseFlatString(*kEmptySOAPDocStr[aVersion]).get(), "application/xml", getter_AddRefs(mMessage)); if (NS_FAILED(rv)) return rv; // Declare the default encoding. This should always be non-null, but may be empty string. nsCOMPtr<nsISOAPEncoding> encoding; rv = GetEncoding(getter_AddRefs(encoding)); if (NS_FAILED(rv)) return rv; nsCOMPtr<nsIDOMElement> envelope; rv = GetEnvelope(getter_AddRefs(envelope)); if (NS_FAILED(rv)) return rv; if (envelope) { nsAutoString enc; rv = mEncoding->GetStyleURI(enc); if (NS_FAILED(rv)) return rv; if (!enc.IsEmpty()) { rv = envelope->SetAttributeNS(*gSOAPStrings->kSOAPEnvURI[aVersion], gSOAPStrings->kEncodingStyleAttribute, enc); if (NS_FAILED(rv)) return rv; } } // Declare the schema namespaces, taking into account any mappings that are present. nsAutoString temp; nsAutoString temp2; temp.Assign(gSOAPStrings->kXMLNamespacePrefix); temp.Append(gSOAPStrings->kXSPrefix); rv = encoding->GetExternalSchemaURI(gSOAPStrings->kXSURI, temp2); if (NS_FAILED(rv)) return rv; rv = envelope->SetAttributeNS(gSOAPStrings->kXMLNamespaceNamespaceURI, temp, temp2); if (NS_FAILED(rv)) return rv; temp.Assign(gSOAPStrings->kXMLNamespacePrefix); temp.Append(gSOAPStrings->kXSIPrefix); rv = encoding->GetExternalSchemaURI(gSOAPStrings->kXSIURI, temp2); if (NS_FAILED(rv)) return rv; rv = envelope->SetAttributeNS(gSOAPStrings->kXMLNamespaceNamespaceURI, temp, temp2); if (NS_FAILED(rv)) return rv; // Encode and add headers, if any were specified if (aHeaderBlockCount) { nsCOMPtr<nsIDOMElement> parent; rv = GetHeader(getter_AddRefs(parent)); if (NS_FAILED(rv)) return rv; nsCOMPtr<nsISOAPHeaderBlock> header; nsCOMPtr<nsIDOMElement> element; nsAutoString name; nsAutoString namespaceURI; PRUint32 i; for (i = 0; i < aHeaderBlockCount; i++) { header = aHeaderBlocks[i]; if (!header) return SOAP_EXCEPTION(NS_ERROR_ILLEGAL_VALUE,"SOAP_NULL_HEADER","Cannot encode null in header array."); rv = header->GetElement(getter_AddRefs(element)); if (element) { nsCOMPtr<nsIDOMNode> node1; node1 = element; nsCOMPtr<nsIDOMNode> node2; rv = mMessage->ImportNode(node1, PR_TRUE, getter_AddRefs(node1)); if (NS_FAILED(rv)) return rv; rv = parent->AppendChild(node2, getter_AddRefs(node1)); if (NS_FAILED(rv)) return rv; element = do_QueryInterface(node1); } else { rv = header->GetNamespaceURI(namespaceURI); if (NS_FAILED(rv)) return rv; rv = header->GetName(name); if (NS_FAILED(rv)) return rv; nsAutoString actorURI; rv = header->GetActorURI(actorURI); if (NS_FAILED(rv)) return rv; PRBool mustUnderstand; rv = header->GetMustUnderstand(&mustUnderstand); if (NS_FAILED(rv)) return rv; rv = header->GetEncoding(getter_AddRefs(encoding)); if (NS_FAILED(rv)) return rv; if (!encoding) { rv = GetEncoding(getter_AddRefs(encoding)); if (NS_FAILED(rv)) return rv; } nsCOMPtr<nsISchemaType> schemaType; rv = header->GetSchemaType(getter_AddRefs(schemaType)); if (NS_FAILED(rv)) return rv; nsCOMPtr<nsIVariant> value; rv = header->GetValue(getter_AddRefs(value)); if (NS_FAILED(rv)) return rv; rv = encoding->Encode(value, namespaceURI, name, schemaType, nsnull, parent, getter_AddRefs(element)); if (NS_FAILED(rv)) return rv; if (!actorURI.IsEmpty()) { element->SetAttributeNS(gSOAPStrings->kSOAPEnvPrefix, gSOAPStrings->kActorAttribute, actorURI); if (NS_FAILED(rv)) return rv; } if (mustUnderstand) { element->SetAttributeNS(gSOAPStrings->kSOAPEnvPrefix, gSOAPStrings->kMustUnderstandAttribute, gSOAPStrings->kTrueA); if (NS_FAILED(rv)) return rv; } if (mEncoding != encoding) { nsAutoString enc; encoding->GetStyleURI(enc); element-> SetAttributeNS(*gSOAPStrings->kSOAPEnvURI[aVersion], gSOAPStrings->kEncodingStyleAttribute, enc); } } } } nsCOMPtr<nsIDOMElement> body; rv = GetBody(getter_AddRefs(body)); if (NS_FAILED(rv)) return rv; // Only produce a call element if mMethodName was non-empty if (!aMethodName.IsEmpty()) { nsAutoString temp; rv = encoding->GetExternalSchemaURI(aTargetObjectURI, temp); nsCOMPtr<nsIDOMElement> call; rv = mMessage->CreateElementNS(temp, aMethodName, getter_AddRefs(call)); if (NS_FAILED(rv)) return rv; nsCOMPtr<nsIDOMNode> ignored; rv = body->AppendChild(call, getter_AddRefs(ignored)); if (NS_FAILED(rv)) return rv; body = call; } // Encode and add all of the parameters into the body nsCOMPtr<nsISOAPParameter> param; nsCOMPtr<nsIDOMElement> element; nsCOMPtr<nsISOAPEncoding> newencoding; nsAutoString name; nsAutoString namespaceURI; PRUint32 i; for (i = 0; i < aParameterCount; i++) { param = aParameters[i]; if (!param) return SOAP_EXCEPTION(NS_ERROR_ILLEGAL_VALUE,"SOAP_NULL_PARAMETER","Cannot encode null in parameter array."); rv = param->GetElement(getter_AddRefs(element)); if (element) { nsCOMPtr<nsIDOMNode> node1; node1 = element; nsCOMPtr<nsIDOMNode> node2; rv = mMessage->ImportNode(node1, PR_TRUE, getter_AddRefs(node2)); if (NS_FAILED(rv)) return rv; rv = body->AppendChild(node2, getter_AddRefs(node1)); if (NS_FAILED(rv)) return rv; element = do_QueryInterface(node1); } else { rv = param->GetNamespaceURI(namespaceURI); if (NS_FAILED(rv)) return rv; rv = param->GetName(name); if (NS_FAILED(rv)) return rv; rv = param->GetEncoding(getter_AddRefs(newencoding)); if (NS_FAILED(rv)) return rv; if (!newencoding) { newencoding = encoding; } nsCOMPtr<nsISchemaType> schemaType; rv = param->GetSchemaType(getter_AddRefs(schemaType)); if (NS_FAILED(rv)) return rv; nsCOMPtr<nsIVariant> value; rv = param->GetValue(getter_AddRefs(value)); if (NS_FAILED(rv)) return rv; rv = newencoding->Encode(value, namespaceURI, name, schemaType, nsnull, body, getter_AddRefs(element)); if (NS_FAILED(rv)) return rv; if (encoding != newencoding) { nsAutoString enc; newencoding->GetStyleURI(enc); element->SetAttributeNS(*gSOAPStrings->kSOAPEnvURI[aVersion], gSOAPStrings->kEncodingStyleAttribute, enc); } } } return NS_OK; }
/* static */ nsresult ImageEncoder::ExtractDataInternal(const nsAString& aType, const nsAString& aOptions, uint8_t* aImageBuffer, int32_t aFormat, const nsIntSize aSize, layers::Image* aImage, nsICanvasRenderingContextInternal* aContext, nsIInputStream** aStream, imgIEncoder* aEncoder) { if (aSize.IsEmpty()) { return NS_ERROR_INVALID_ARG; } nsCOMPtr<nsIInputStream> imgStream; // get image bytes nsresult rv; if (aImageBuffer) { rv = ImageEncoder::GetInputStream( aSize.width, aSize.height, aImageBuffer, aFormat, aEncoder, nsPromiseFlatString(aOptions).get(), getter_AddRefs(imgStream)); } else if (aContext) { NS_ConvertUTF16toUTF8 encoderType(aType); rv = aContext->GetInputStream(encoderType.get(), nsPromiseFlatString(aOptions).get(), getter_AddRefs(imgStream)); } else if (aImage) { // It is safe to convert PlanarYCbCr format from YUV to RGB off-main-thread. // Other image formats could have problem to convert format off-main-thread. // So here it uses a help function GetBRGADataSourceSurfaceSync() to convert // format on main thread. if (aImage->GetFormat() == ImageFormat::PLANAR_YCBCR) { nsTArray<uint8_t> data; layers::PlanarYCbCrImage* ycbcrImage = static_cast<layers::PlanarYCbCrImage*> (aImage); gfxImageFormat format = gfxImageFormat::ARGB32; uint32_t stride = GetAlignedStride<16>(aSize.width * 4); size_t length = BufferSizeFromStrideAndHeight(stride, aSize.height); data.SetCapacity(length); gfxUtils::ConvertYCbCrToRGB(*ycbcrImage->GetData(), format, aSize, data.Elements(), stride); rv = aEncoder->InitFromData(data.Elements(), aSize.width * aSize.height * 4, aSize.width, aSize.height, aSize.width * 4, imgIEncoder::INPUT_FORMAT_HOSTARGB, aOptions); } else { RefPtr<gfx::DataSourceSurface> dataSurface; dataSurface = GetBRGADataSourceSurfaceSync(aImage); DataSourceSurface::MappedSurface map; if (!dataSurface->Map(gfx::DataSourceSurface::MapType::READ, &map)) { return NS_ERROR_INVALID_ARG; } rv = aEncoder->InitFromData(map.mData, aSize.width * aSize.height * 4, aSize.width, aSize.height, aSize.width * 4, imgIEncoder::INPUT_FORMAT_HOSTARGB, aOptions); dataSurface->Unmap(); } if (NS_SUCCEEDED(rv)) { imgStream = do_QueryInterface(aEncoder); } } else { // no context, so we have to encode an empty image // note that if we didn't have a current context, the spec says we're // supposed to just return transparent black pixels of the canvas // dimensions. RefPtr<DataSourceSurface> emptyCanvas = Factory::CreateDataSourceSurfaceWithStride(IntSize(aSize.width, aSize.height), SurfaceFormat::B8G8R8A8, 4 * aSize.width, true); if (NS_WARN_IF(!emptyCanvas)) { return NS_ERROR_INVALID_ARG; } DataSourceSurface::MappedSurface map; if (!emptyCanvas->Map(DataSourceSurface::MapType::WRITE, &map)) { return NS_ERROR_INVALID_ARG; } rv = aEncoder->InitFromData(map.mData, aSize.width * aSize.height * 4, aSize.width, aSize.height, aSize.width * 4, imgIEncoder::INPUT_FORMAT_HOSTARGB, aOptions); emptyCanvas->Unmap(); if (NS_SUCCEEDED(rv)) { imgStream = do_QueryInterface(aEncoder); } } NS_ENSURE_SUCCESS(rv, rv); imgStream.forget(aStream); return rv; }
/* static */ nsresult ImageEncoder::ExtractDataInternal(const nsAString& aType, const nsAString& aOptions, uint8_t* aImageBuffer, int32_t aFormat, const nsIntSize aSize, nsICanvasRenderingContextInternal* aContext, nsIInputStream** aStream, imgIEncoder* aEncoder) { if (aSize.IsEmpty()) { return NS_ERROR_INVALID_ARG; } nsCOMPtr<nsIInputStream> imgStream; // get image bytes nsresult rv; if (aImageBuffer) { rv = ImageEncoder::GetInputStream( aSize.width, aSize.height, aImageBuffer, aFormat, aEncoder, nsPromiseFlatString(aOptions).get(), getter_AddRefs(imgStream)); } else if (aContext) { NS_ConvertUTF16toUTF8 encoderType(aType); rv = aContext->GetInputStream(encoderType.get(), nsPromiseFlatString(aOptions).get(), getter_AddRefs(imgStream)); } else { // no context, so we have to encode an empty image // note that if we didn't have a current context, the spec says we're // supposed to just return transparent black pixels of the canvas // dimensions. RefPtr<DataSourceSurface> emptyCanvas = Factory::CreateDataSourceSurfaceWithStride(IntSize(aSize.width, aSize.height), SurfaceFormat::B8G8R8A8, 4 * aSize.width, true); if (NS_WARN_IF(!emptyCanvas)) { return NS_ERROR_INVALID_ARG; } DataSourceSurface::MappedSurface map; if (!emptyCanvas->Map(DataSourceSurface::MapType::WRITE, &map)) { return NS_ERROR_INVALID_ARG; } rv = aEncoder->InitFromData(map.mData, aSize.width * aSize.height * 4, aSize.width, aSize.height, aSize.width * 4, imgIEncoder::INPUT_FORMAT_HOSTARGB, aOptions); emptyCanvas->Unmap(); if (NS_SUCCEEDED(rv)) { imgStream = do_QueryInterface(aEncoder); } } NS_ENSURE_SUCCESS(rv, rv); imgStream.forget(aStream); return rv; }