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