/**
* \copydoc MythUIType::ParseElement()
*/
bool MythScreenType::ParseElement(
const QString &filename, QDomElement &element, bool showWarnings)
{
if (element.tagName() == "area")
{
MythRect rect = parseRect(element, false);
MythRect rectN = parseRect(element);
QRect screenArea = GetMythMainWindow()->GetUIScreenRect();
if (rect.x() == -1)
rectN.moveLeft((screenArea.width() - rectN.width()) / 2);
if (rect.y() == -1)
rectN.moveTop((screenArea.height() - rectN.height()) / 2);
SetArea(rectN);
if (m_Area.width() < screenArea.width() ||
m_Area.height() < screenArea.height())
{
m_FullScreen = false;
}
else
{
m_FullScreen = true;
}
}
else
{
return MythUIType::ParseElement(filename, element, showWarnings);
}
return true;
}
bool VirtualKeyboardParser::parserCallback_area(ParserNode *node) {
String &shape = node->values["shape"];
String &target = node->values["target"];
String &coords = node->values["coords"];
if (target.equalsIgnoreCase("display_area")) {
if (!shape.equalsIgnoreCase("rect"))
return parserError("display_area must be a rect area");
_mode->displayArea = Rect();
return parseRect(_mode->displayArea, coords);
} else if (shape.equalsIgnoreCase("rect")) {
Polygon *poly = _mode->imageMap.createArea(target);
if (!poly)
return parserError(Common::String::format("Cannot define area '%s' again", target.c_str()));
else
return parseRectAsPolygon(*poly, coords);
} else if (shape.equalsIgnoreCase("poly")) {
Polygon *poly = _mode->imageMap.createArea(target);
if (!poly)
return parserError(Common::String::format("Cannot define area '%s' again", target.c_str()));
else
return parsePolygon(*poly, coords);
}
return parserError("Area shape '" + shape + "' not known");
}
/**
* \brief Parse the xml definition of this widget setting the state of the
* object accordingly
*/
bool MythUIType::ParseElement(
const QString &filename, QDomElement &element, bool showWarnings)
{
//FIXME add movement etc.
if (element.tagName() == "position")
SetPosition(parsePoint(element));
else if (element.tagName() == "area")
{
SetArea(parseRect(element));
}
else if (element.tagName() == "minsize")
{
// Use parsePoint so percentages can be used
if (element.hasAttribute("initiator"))
m_Initiator = parseBool(element.attribute("initiator"));
if (element.hasAttribute("vanish"))
m_Vanish = parseBool(element.attribute("vanish"));
SetMinSize(parsePoint(element));
}
else if (element.tagName() == "alpha")
{
m_Alpha = getFirstText(element).toInt();
m_AlphaChangeMode = 0;
}
else if (element.tagName() == "alphapulse")
{
m_AlphaChangeMode = 2;
m_AlphaMin = element.attribute("min", "0").toInt();
m_Alpha = m_AlphaMax = element.attribute("max", "255").toInt();
if (m_AlphaMax > 255)
m_Alpha = m_AlphaMax = 255;
if (m_AlphaMin < 0)
m_AlphaMin = 0;
m_AlphaChange = element.attribute("change", "5").toInt();
}
else if (element.tagName() == "focusorder")
{
int order = getFirstText(element).toInt();
SetFocusOrder(order);
}
else if (element.tagName() == "loadondemand")
{
SetDeferLoad(parseBool(element));
}
else if (element.tagName() == "helptext")
{
m_helptext = getFirstText(element);
}
else
return false;
return true;
}
bool VirtualKeyboardParser::parseRectAsPolygon(Polygon &poly, const String& coords) {
Rect rect;
if (!parseRect(rect, coords))
return false;
poly.addPoint(rect.left, rect.top);
poly.addPoint(rect.right, rect.top);
poly.addPoint(rect.right, rect.bottom);
poly.addPoint(rect.left, rect.bottom);
return true;
}
bool SVGAnimatedType::setValueAsString(const QualifiedName& attrName, const String& value)
{
switch (m_type) {
case AnimatedColor:
ASSERT(m_data.color);
*m_data.color = value.isEmpty() ? Color() : SVGColor::colorFromRGBColorString(value);
break;
case AnimatedLength: {
ASSERT(m_data.length);
ExceptionCode ec = 0;
m_data.length->setValueAsString(value, SVGLength::lengthModeForAnimatedLengthAttribute(attrName), ec);
return !ec;
}
case AnimatedLengthList:
ASSERT(m_data.lengthList);
m_data.lengthList->parse(value, SVGLength::lengthModeForAnimatedLengthAttribute(attrName));
break;
case AnimatedNumber:
ASSERT(m_data.number);
parseNumberFromString(value, *m_data.number);
break;
case AnimatedRect:
ASSERT(m_data.rect);
parseRect(value, *m_data.rect);
break;
case AnimatedString:
ASSERT(m_data.string);
*m_data.string = value;
break;
// These types don't appear in the table in SVGElement::cssPropertyToTypeMap() and thus don't need setValueAsString() support.
case AnimatedAngle:
case AnimatedBoolean:
case AnimatedEnumeration:
case AnimatedInteger:
case AnimatedIntegerOptionalInteger:
case AnimatedNumberList:
case AnimatedNumberOptionalNumber:
case AnimatedPath:
case AnimatedPoints:
case AnimatedPreserveAspectRatio:
case AnimatedTransformList:
case AnimatedUnknown:
// Only SVG DOM animations use these property types - that means setValueAsString() is never used for those.
ASSERT_NOT_REACHED();
break;
}
return true;
}
void InspectorLayerTreeAgent::profileSnapshot(ErrorString* errorString, const String& snapshotId, const int* minRepeatCount, const double* minDuration, const RefPtr<JSONObject>* clipRect, RefPtr<TypeBuilder::Array<TypeBuilder::Array<double> > >& outTimings)
{
const PictureSnapshot* snapshot = snapshotById(errorString, snapshotId);
if (!snapshot)
return;
FloatRect rect;
if (clipRect && !parseRect(**clipRect, &rect)) {
*errorString = "Invalid argument, missing required field";
return;
}
OwnPtr<PictureSnapshot::Timings> timings = snapshot->profile(minRepeatCount ? *minRepeatCount : 1, minDuration ? *minDuration : 0, clipRect ? &rect : 0);
outTimings = TypeBuilder::Array<TypeBuilder::Array<double> >::create();
for (size_t i = 0; i < timings->size(); ++i) {
const Vector<double>& row = (*timings)[i];
RefPtr<TypeBuilder::Array<double> > outRow = TypeBuilder::Array<double>::create();
for (size_t j = 0; j < row.size(); ++j)
outRow->addItem(row[j]);
outTimings->addItem(outRow.release());
}
}
bool MythUITextEdit::ParseElement(
const QString &filename, QDomElement &element, bool showWarnings)
{
bool parsed = true;
if (element.tagName() == "area")
{
SetArea(parseRect(element));
}
else if (element.tagName() == "keyboardposition")
{
QString pos = getFirstText(element);
if (pos == "aboveedit")
m_keyboardPosition = VK_POSABOVEEDIT;
else if (pos == "belowedit")
m_keyboardPosition = VK_POSBELOWEDIT;
else if (pos == "screentop")
m_keyboardPosition = VK_POSTOPDIALOG;
else if (pos == "screenbottom")
m_keyboardPosition = VK_POSBOTTOMDIALOG;
else if (pos == "screencenter")
m_keyboardPosition = VK_POSCENTERDIALOG;
else
{
VERBOSE_XML(VB_GENERAL, LOG_ERR, filename, element,
QString("Unknown popup position '%1'").arg(pos));
m_keyboardPosition = VK_POSBELOWEDIT;
}
}
else
{
return MythUIType::ParseElement(filename, element, showWarnings);
}
return parsed;
}
MythRect XMLParseBase::parseRect(QDomElement &element, bool normalize)
{
return parseRect(getFirstText(element), normalize);
}
bool SvmParser::parse(const QByteArray &data)
{
// Check the signature "VCLMTF"
if (!data.startsWith("VCLMTF"))
return false;
QBuffer buffer((QByteArray *) &data);
buffer.open(QIODevice::ReadOnly);
QDataStream mainStream(&buffer);
mainStream.setByteOrder(QDataStream::LittleEndian);
// Start reading from the stream: read past the signature and get the header.
soakBytes(mainStream, 6);
SvmHeader header(mainStream);
#if DEBUG_SVMPARSER
debugVectorImage << "================ SVM HEADER ================";
debugVectorImage << "version, length:" << header.versionCompat.version << header.versionCompat.length;
debugVectorImage << "compressionMode:" << header.compressionMode;
debugVectorImage << "mapMode:" << "Origin" << header.mapMode.origin
<< "scaleX"
<< header.mapMode.scaleX.numerator << header.mapMode.scaleX.denominator
<< (qreal(header.mapMode.scaleX.numerator) / header.mapMode.scaleX.denominator)
<< "scaleY"
<< header.mapMode.scaleY.numerator << header.mapMode.scaleY.denominator
<< (qreal(header.mapMode.scaleY.numerator) / header.mapMode.scaleY.denominator);
debugVectorImage << "size:" << header.width << header.height;
debugVectorImage << "actionCount:" << header.actionCount;
debugVectorImage << "================ SVM HEADER ================";
#endif
mBackend->init(header);
#if DEBUG_SVMPARSER
{
QPolygon polygon;
polygon << QPoint(0, 0);
polygon << QPoint(header.width, header.height);
mBackend->polyLine(mContext, polygon);
}
#endif
// Parse all actions and call the appropriate backend callback for
// the graphics drawing actions. The context actions will
// manipulate the graphics context, which is maintained here.
for (uint action = 0; action < header.actionCount; ++action) {
quint16 actionType;
quint16 version;
quint32 totalSize;
// Here starts the Action itself. The first two bytes is the action type.
mainStream >> actionType;
// The VersionCompat object
mainStream >> version;
mainStream >> totalSize;
char *rawData = new char[totalSize];
mainStream.readRawData(rawData, totalSize);
QByteArray dataArray(rawData, totalSize);
QDataStream stream(&dataArray, QIODevice::ReadOnly);
stream.setByteOrder(QDataStream::LittleEndian);
// Debug
#if DEBUG_SVMPARSER
{
QString name;
if (actionType == 0)
name = actionNames[0].actionName;
else if (100 <= actionType && actionType <= META_LAST_ACTION)
name = actionNames[actionType - 99].actionName;
else if (actionType == 512)
name = "META_COMMENT_ACTION";
else
name = "(out of bounds)";
debugVectorImage << name << "(" << actionType << ")" << "version" << version
<< "totalSize" << totalSize;
}
#endif
// Parse all actions.
switch (actionType) {
case META_NULL_ACTION:
break;
case META_PIXEL_ACTION:
break;
case META_POINT_ACTION:
break;
case META_LINE_ACTION:
break;
case META_RECT_ACTION:
{
QRect rect;
parseRect(stream, rect);
debugVectorImage << "Rect:" << rect;
mBackend->rect(mContext, rect);
}
break;
case META_ROUNDRECT_ACTION:
break;
case META_ELLIPSE_ACTION:
break;
case META_ARC_ACTION:
break;
case META_PIE_ACTION:
break;
case META_CHORD_ACTION:
break;
case META_POLYLINE_ACTION:
{
QPolygon polygon;
parsePolygon(stream, polygon);
debugVectorImage << "Polyline:" << polygon;
mBackend->polyLine(mContext, polygon);
// FIXME: Version 2: Lineinfo, Version 3: polyflags
if (version > 1)
soakBytes(stream, totalSize - 2 - 4 * 2 * polygon.size());
}
break;
case META_POLYGON_ACTION:
{
QPolygon polygon;
parsePolygon(stream, polygon);
debugVectorImage << "Polygon:" << polygon;
mBackend->polygon(mContext, polygon);
// FIXME: Version 2: Lineinfo, Version 3: polyflags
if (version > 1)
soakBytes(stream, totalSize - 2 - 4 * 2 * polygon.size());
}
break;
case META_POLYPOLYGON_ACTION:
{
quint16 polygonCount;
stream >> polygonCount;
//debugVectorImage << "Number of polygons:" << polygonCount;
QList<QPolygon> polygons;
for (quint16 i = 0 ; i < polygonCount ; i++) {
QPolygon polygon;
parsePolygon(stream, polygon);
polygons << polygon;
//debugVectorImage << "Polygon:" << polygon;
}
if (version > 1) {
quint16 complexPolygonCount;
stream >> complexPolygonCount;
//debugVectorImage << "Number of complex polygons:" << complexPolygonCount;
// Parse the so called "complex polygons". For
// each one, there is an index and a polygon. The
// index tells which of the original polygons to
// replace.
for (quint16 i = 0; i < complexPolygonCount; i++) {
quint16 complexPolygonIndex;
stream >> complexPolygonIndex;
QPolygon polygon;
parsePolygon(stream, polygon);
//debugVectorImage << "polygon index:" << complexPolygonIndex << polygon;
// FIXME: The so called complex polygons have something to do
// with modifying the polygons, but I have not yet been
// able to understand how. So until I do, we'll disable
// this.
//polygons[complexPolygonIndex] = polygon;
}
}
mBackend->polyPolygon(mContext, polygons);
}
break;
case META_TEXT_ACTION:
break;
case META_TEXTARRAY_ACTION:
{
QPoint startPoint;
QString string;
quint16 startIndex;
quint16 len;
quint32 dxArrayLen;
qint32 *dxArray = 0;
stream >> startPoint;
parseString(stream, string);
stream >> startIndex;
stream >> len;
stream >> dxArrayLen;
if (dxArrayLen > 0) {
quint32 maxDxArrayLen = totalSize - stream.device()->pos();
if (dxArrayLen > maxDxArrayLen) {
debugVectorImage << "Defined dxArrayLen= " << dxArrayLen << "exceeds availalable size" << maxDxArrayLen;
dxArrayLen = maxDxArrayLen;
}
dxArray = new qint32[dxArrayLen];
for (uint i = 0; i < dxArrayLen; ++i)
stream >> dxArray[i];
}
if (version > 1) {
quint16 len2;
stream >> len2;
// FIXME: More here
}
#if 0
debugVectorImage << "Text: " << startPoint << string
<< startIndex << len;
if (dxArrayLen > 0) {
debugVectorImage << "dxArrayLen:" << dxArrayLen;
for (uint i = 0; i < dxArrayLen; ++i)
debugVectorImage << dxArray[i];
}
else
debugVectorImage << "dxArrayLen = 0";
#endif
mBackend->textArray(mContext, startPoint, string, startIndex, len,
dxArrayLen, dxArray);
if (dxArrayLen)
delete[] dxArray;
}
/**
* \copydoc MythUIType::ParseElement()
*/
bool MythUIImage::ParseElement(
const QString &filename, QDomElement &element, bool showWarnings)
{
QWriteLocker updateLocker(&d->m_UpdateLock);
if (element.tagName() == "filename")
{
m_OrigFilename = m_Filename = getFirstText(element);
if (m_Filename.endsWith('/'))
{
QDir imageDir(m_Filename);
if (!imageDir.exists())
{
QString themeDir = GetMythUI()->GetThemeDir() + '/';
imageDir = themeDir + m_Filename;
}
QStringList imageTypes;
QList< QByteArray > exts = QImageReader::supportedImageFormats();
QList< QByteArray >::Iterator it = exts.begin();
for (;it != exts.end();++it)
{
imageTypes.append( QString("*.").append(*it) );
}
imageDir.setNameFilters(imageTypes);
QStringList imageList = imageDir.entryList();
srand(time(NULL));
QString randFile;
if (imageList.size())
randFile = QString("%1%2").arg(m_Filename)
.arg(imageList.takeAt(rand() % imageList.size()));
m_OrigFilename = m_Filename = randFile;
}
}
else if (element.tagName() == "filepattern")
{
m_OrigFilename = m_Filename = getFirstText(element);
QString tmp = element.attribute("low");
if (!tmp.isEmpty())
m_LowNum = tmp.toInt();
tmp = element.attribute("high");
if (!tmp.isEmpty())
m_HighNum = tmp.toInt();
tmp = element.attribute("cycle", "start");
if (tmp == "reverse")
m_animationCycle = kCycleReverse;
}
else if (element.tagName() == "area")
{
SetArea(parseRect(element));
m_ForceSize = m_Area.size();
}
else if (element.tagName() == "preserveaspect")
m_preserveAspect = parseBool(element);
else if (element.tagName() == "crop")
m_cropRect = parseRect(element);
else if (element.tagName() == "delay")
{
QString value = getFirstText(element);
if (value.contains(","))
{
QVector<int> delays;
QStringList tokens = value.split(",");
QStringList::iterator it = tokens.begin();
for (; it != tokens.end(); ++it)
{
if ((*it).isEmpty())
{
if (delays.size())
delays.append(delays[delays.size()-1]);
else
delays.append(0); // Default 0ms delay before first image
}
else
{
delays.append((*it).toInt());
}
}
if (delays.size())
{
m_Delay = delays[0];
SetDelays(delays);
}
}
else
{
m_Delay = value.toInt();
}
}
else if (element.tagName() == "reflection")
{
m_isReflected = true;
QString tmp = element.attribute("axis");
if (!tmp.isEmpty())
{
if (tmp.toLower() == "horizontal")
m_reflectAxis = ReflectHorizontal;
else
m_reflectAxis = ReflectVertical;
}
tmp = element.attribute("shear");
if (!tmp.isEmpty())
m_reflectShear = tmp.toInt();
tmp = element.attribute("scale");
if (!tmp.isEmpty())
m_reflectScale = tmp.toInt();
tmp = element.attribute("length");
if (!tmp.isEmpty())
m_reflectLength = tmp.toInt();
tmp = element.attribute("spacing");
if (!tmp.isEmpty())
m_reflectSpacing = tmp.toInt();
}
else if (element.tagName() == "mask")
{
QString maskfile = getFirstText(element);
if (m_maskImage)
{
m_maskImage->DownRef();
m_maskImage = NULL;
}
m_maskImage = GetPainter()->GetFormatImage();
m_maskImage->UpRef();
if (m_maskImage->Load(maskfile))
m_isMasked = true;
else
{
m_maskImage->DownRef();
m_maskImage = NULL;
m_isMasked = false;
}
}
else if (element.tagName() == "grayscale" ||
element.tagName() == "greyscale")
{
m_isGreyscale = parseBool(element);
}
else
{
return MythUIType::ParseElement(filename, element, showWarnings);
}
m_NeedLoad = true;
if (m_Parent && m_Parent->IsDeferredLoading(true))
m_NeedLoad = false;
return true;
}
bool MythUIText::ParseElement(
const QString &filename, QDomElement &element, bool showWarnings)
{
if (element.tagName() == "area")
{
SetArea(parseRect(element));
m_OrigDisplayRect = m_Area;
}
// else if (element.tagName() == "altarea") // Unused, but maybe in future?
// m_AltDisplayRect = parseRect(element);
else if (element.tagName() == "font")
{
QString fontname = getFirstText(element);
MythFontProperties *fp = GetFont(fontname);
if (!fp)
fp = GetGlobalFontMap()->GetFont(fontname);
if (fp)
{
MythFontProperties font = *fp;
int screenHeight = GetMythMainWindow()->GetUIScreenRect().height();
font.Rescale(screenHeight);
int fontStretch = GetMythUI()->GetFontStretch();
font.AdjustStretch(fontStretch);
QString state = element.attribute("state","");
if (!state.isEmpty())
{
m_FontStates.insert(state, font);
}
else
{
m_FontStates.insert("default", font);
*m_Font = m_FontStates["default"];
}
}
}
else if (element.tagName() == "value")
{
if (element.attribute("lang","").isEmpty())
{
m_Message = qApp->translate("ThemeUI",
parseText(element).toUtf8(), NULL,
QCoreApplication::UnicodeUTF8);
}
#if 0
else if (element.attribute("lang","").toLower() ==
gCoreContext->GetLanguageAndVariant())
#else
else if (element.attribute("lang","").toLower() ==
"en_us")
#endif
{
m_Message = parseText(element);
}
#if 0
else if (element.attribute("lang","").toLower() ==
gCoreContext->GetLanguage())
#else
else if (element.attribute("lang","").toLower() ==
"en")
#endif
{
m_Message = parseText(element);
}
m_DefaultMessage = m_Message;
SetText(m_Message);
}
else if (element.tagName() == "template")
PassOwnPtr<SVGAnimatedType> SVGAnimatedRectAnimator::constructFromString(const String& string)
{
OwnPtr<SVGAnimatedType> animatedType = SVGAnimatedType::createRect(new FloatRect);
parseRect(string, animatedType->rect());
return animatedType.release();
}
bool MythUIText::ParseElement(
const QString &filename, QDomElement &element, bool showWarnings)
{
if (element.tagName() == "area")
{
SetArea(parseRect(element));
m_OrigDisplayRect = m_Area;
}
// else if (element.tagName() == "altarea") // Unused, but maybe in future?
// m_AltDisplayRect = parseRect(element);
else if (element.tagName() == "font")
{
QString fontname = getFirstText(element);
MythFontProperties *fp = GetFont(fontname);
if (!fp)
fp = GetGlobalFontMap()->GetFont(fontname);
if (fp)
{
MythFontProperties font = *fp;
int screenHeight = GetMythMainWindow()->GetUIScreenRect().height();
font.Rescale(screenHeight);
int fontStretch = GetMythUI()->GetFontStretch();
font.AdjustStretch(fontStretch);
QString state = element.attribute("state","");
if (!state.isEmpty())
{
m_FontStates.insert(state, font);
}
else
{
m_FontStates.insert("default", font);
*m_Font = m_FontStates["default"];
}
}
}
else if (element.tagName() == "value")
{
if (element.attribute("lang","").isEmpty())
{
m_Message = qApp->translate("ThemeUI",
parseText(element).toUtf8(), NULL,
QCoreApplication::UnicodeUTF8);
}
else if (element.attribute("lang","").toLower() ==
gCoreContext->GetLanguageAndVariant())
{
m_Message = parseText(element);
}
else if (element.attribute("lang","").toLower() ==
gCoreContext->GetLanguage())
{
m_Message = parseText(element);
}
m_DefaultMessage = m_Message;
SetText(m_Message);
}
else if (element.tagName() == "template")
{
m_TemplateText = parseText(element);
}
else if (element.tagName() == "cutdown")
{
SetCutDown(parseBool(element));
}
else if (element.tagName() == "multiline")
{
SetMultiLine(parseBool(element));
}
else if (element.tagName() == "align")
{
QString align = getFirstText(element).toLower();
SetJustification(parseAlignment(align));
}
else if (element.tagName() == "colorcycle")
{
if (GetPainter()->SupportsAnimation())
{
QString tmp = element.attribute("start");
if (!tmp.isEmpty())
m_startColor = QColor(tmp);
tmp = element.attribute("end");
if (!tmp.isEmpty())
m_endColor = QColor(tmp);
tmp = element.attribute("steps");
if (!tmp.isEmpty())
m_numSteps = tmp.toInt();
// initialize the rest of the stuff
CycleColor(m_startColor, m_endColor, m_numSteps);
}
else
m_colorCycling = false;
m_colorCycling = parseBool(element.attribute("disable"));
}
else if (element.tagName() == "scroll")
{
if (GetPainter()->SupportsAnimation())
{
QString tmp = element.attribute("direction");
if (!tmp.isEmpty())
{
tmp = tmp.toLower();
if (tmp == "left")
m_scrollDirection = ScrollLeft;
else if (tmp == "right")
m_scrollDirection = ScrollRight;
else if (tmp == "up")
m_scrollDirection = ScrollUp;
else if (tmp == "down")
m_scrollDirection = ScrollDown;
}
m_scrolling = true;
}
else
m_scrolling = false;
}
else if (element.tagName() == "case")
{
QString stringCase = getFirstText(element).toLower();
if (stringCase == "lower")
m_textCase = CaseLower;
else if (stringCase == "upper")
m_textCase = CaseUpper;
else if (stringCase == "capitalisefirst")
m_textCase = CaseCapitaliseFirst;
else if (stringCase == "capitaliseall")
m_textCase = CaseCapitaliseAll;
else
m_textCase = CaseNormal;
FillCutMessage();
}
else
{
return MythUIType::ParseElement(filename, element, showWarnings);
}
return true;
}
bool SVGAnimatedType::setValueAsString(const QualifiedName& attrName, const String& value)
{
ExceptionCode ec = 0;
switch (m_type) {
case AnimatedAngle:
ASSERT(m_data.angle);
m_data.angle->setValueAsString(value, ec);
break;
case AnimatedBoolean:
ASSERT(m_data.boolean);
*m_data.boolean = value == "true" ? true : false;
break;
case AnimatedColor:
ASSERT(m_data.color);
*m_data.color = value.isEmpty() ? Color() : SVGColor::colorFromRGBColorString(value);
break;
case AnimatedInteger: {
ASSERT(m_data.integer);
bool ok;
*m_data.integer = value.toIntStrict(&ok);
if (!ok)
ec = 1; // Arbitary value > 0, it doesn't matter as we don't report the exception code.
break;
}
case AnimatedLength:
ASSERT(m_data.length);
m_data.length->setValueAsString(value, SVGLength::lengthModeForAnimatedLengthAttribute(attrName), ec);
break;
case AnimatedLengthList:
ASSERT(m_data.lengthList);
m_data.lengthList->parse(value, SVGLength::lengthModeForAnimatedLengthAttribute(attrName));
break;
case AnimatedNumber:
ASSERT(m_data.number);
parseNumberFromString(value, *m_data.number);
break;
case AnimatedNumberList:
ASSERT(m_data.numberList);
m_data.numberList->parse(value);
break;
case AnimatedNumberOptionalNumber:
ASSERT(m_data.numberOptionalNumber);
parseNumberOptionalNumber(value, m_data.numberOptionalNumber->first, m_data.numberOptionalNumber->second);
break;
case AnimatedPath: {
ASSERT(m_data.path);
OwnPtr<SVGPathByteStream> pathByteStream = adoptPtr(m_data.path);
if (!SVGPathParserFactory::self()->buildSVGPathByteStreamFromString(value, pathByteStream, UnalteredParsing))
ec = 1; // Arbitary value > 0, it doesn't matter as we don't report the exception code.
m_data.path = pathByteStream.leakPtr();
break;
}
case AnimatedPoints:
ASSERT(m_data.pointList);
m_data.pointList->clear();
pointsListFromSVGData(*m_data.pointList, value);
break;
case AnimatedPreserveAspectRatio:
ASSERT(m_data.preserveAspectRatio);
SVGPreserveAspectRatio::parsePreserveAspectRatio(this, value);
break;
case AnimatedRect:
ASSERT(m_data.rect);
parseRect(value, *m_data.rect);
break;
case AnimatedString:
ASSERT(m_data.string);
*m_data.string = value;
break;
default:
ASSERT_NOT_REACHED();
break;
}
return !ec;
}
RECT TxSkin::parseRect( LPWSTR section, LPWSTR key, LPWSTR iniFile )
{
WCHAR str[255];
GetPrivateProfileString(section, key, L"0 0 0 0", str, 255, iniFile);
return parseRect(str);
}
/**
* \copydoc MythUIType::ParseElement()
*/
bool MythUIImage::ParseElement(
const QString &filename, QDomElement &element, bool showWarnings)
{
QWriteLocker updateLocker(&d->m_UpdateLock);
if (element.tagName() == "filename")
{
m_imageProperties.isThemeImage = true; // This is an image distributed with the them
m_OrigFilename = m_imageProperties.filename = getFirstText(element);
if (m_imageProperties.filename.endsWith('/'))
{
m_showingRandomImage = true;
m_imageDirectory = m_imageProperties.filename;
FindRandomImage();
}
}
else if (element.tagName() == "filepattern")
{
m_imageProperties.isThemeImage = true; // This is an image distributed with the theme
m_OrigFilename = m_imageProperties.filename = getFirstText(element);
QString tmp = element.attribute("low");
if (!tmp.isEmpty())
m_LowNum = tmp.toInt();
tmp = element.attribute("high");
if (!tmp.isEmpty())
m_HighNum = tmp.toInt();
tmp = element.attribute("cycle", "start");
if (tmp == "reverse")
m_animationCycle = kCycleReverse;
}
else if (element.tagName() == "area")
{
SetArea(parseRect(element));
m_imageProperties.forceSize = m_Area.size();
}
else if (element.tagName() == "preserveaspect")
m_imageProperties.preserveAspect = parseBool(element);
else if (element.tagName() == "crop")
m_imageProperties.cropRect = parseRect(element);
else if (element.tagName() == "delay")
{
QString value = getFirstText(element);
if (value.contains(","))
{
QVector<int> delays;
QStringList tokens = value.split(",");
QStringList::iterator it = tokens.begin();
for (; it != tokens.end(); ++it)
{
if ((*it).isEmpty())
{
if (delays.size())
delays.append(delays[delays.size()-1]);
else
delays.append(0); // Default 0ms delay before first image
}
else
{
delays.append((*it).toInt());
}
}
if (delays.size())
{
m_Delay = delays[0];
SetDelays(delays);
}
}
else
{
m_Delay = value.toInt();
}
}
else if (element.tagName() == "reflection")
{
m_imageProperties.isReflected = true;
QString tmp = element.attribute("axis");
if (!tmp.isEmpty())
{
if (tmp.toLower() == "horizontal")
m_imageProperties.reflectAxis = ReflectHorizontal;
else
m_imageProperties.reflectAxis = ReflectVertical;
}
tmp = element.attribute("shear");
if (!tmp.isEmpty())
m_imageProperties.reflectShear = tmp.toInt();
tmp = element.attribute("scale");
if (!tmp.isEmpty())
m_imageProperties.reflectScale = tmp.toInt();
tmp = element.attribute("length");
if (!tmp.isEmpty())
m_imageProperties.reflectLength = tmp.toInt();
tmp = element.attribute("spacing");
if (!tmp.isEmpty())
m_imageProperties.reflectSpacing = tmp.toInt();
}
else if (element.tagName() == "mask")
{
QString maskfile = getFirstText(element);
MythImage *newMaskImage = GetPainter()->GetFormatImage();
if (newMaskImage->Load(maskfile))
{
float wmult; // Width multipler
float hmult; // Height multipler
GetMythUI()->GetScreenSettings(wmult, hmult);
if (wmult != 1.0f || hmult != 1.0f)
{
int width = newMaskImage->size().width() * wmult;
int height = newMaskImage->size().height() * hmult;
newMaskImage->Resize(QSize(width, height));
}
m_imageProperties.SetMaskImage(newMaskImage);
}
else
m_imageProperties.SetMaskImage(NULL);
newMaskImage->DecrRef();
}
else if (element.tagName() == "grayscale" ||
element.tagName() == "greyscale")
{
m_imageProperties.isGreyscale = parseBool(element);
}
else
{
return MythUIType::ParseElement(filename, element, showWarnings);
}
m_NeedLoad = true;
if (m_Parent && m_Parent->IsDeferredLoading(true))
m_NeedLoad = false;
return true;
}
bool DeviceSkinParameters::read(QTextStream &ts, ReadMode rm, QString *errorMessage)
{
QStringList closedAreas;
QStringList toggleAreas;
QStringList toggleActiveAreas;
int nareas = 0;
screenDepth = 0;
QString mark;
ts >> mark;
hasMouseHover = true; // historical default
if ( mark == QLatin1String("[SkinFile]") ) {
const QString UpKey = QLatin1String("Up");
const QString DownKey = QLatin1String("Down");
const QString ClosedKey = QLatin1String("Closed");
const QString ClosedAreasKey = QLatin1String("ClosedAreas");
const QString ScreenKey = QLatin1String("Screen");
const QString ScreenDepthKey = QLatin1String("ScreenDepth");
const QString BackScreenKey = QLatin1String("BackScreen");
const QString ClosedScreenKey = QLatin1String("ClosedScreen");
const QString CursorKey = QLatin1String("Cursor");
const QString AreasKey = QLatin1String("Areas");
const QString ToggleAreasKey = QLatin1String("ToggleAreas");
const QString ToggleActiveAreasKey = QLatin1String("ToggleActiveAreas");
const QString HasMouseHoverKey = QLatin1String("HasMouseHover");
// New
while (!nareas) {
QString line = ts.readLine();
if ( line.isNull() )
break;
if ( line[0] != QLatin1Char('#') && !line.isEmpty() ) {
int eq = line.indexOf(QLatin1Char('='));
if ( eq >= 0 ) {
const QString key = line.left(eq);
eq++;
while (eq<line.length()-1 && line[eq].isSpace())
eq++;
const QString value = line.mid(eq);
if ( key == UpKey ) {
skinImageUpFileName = value;
} else if ( key == DownKey ) {
skinImageDownFileName = value;
} else if ( key == ClosedKey ) {
skinImageClosedFileName = value;
} else if ( key == ClosedAreasKey ) {
closedAreas = value.split(QLatin1Char(' '));
} else if ( key == ScreenKey ) {
parseRect( value, &screenRect);
} else if ( key == ScreenDepthKey ) {
screenDepth = value.toInt();
} else if ( key == BackScreenKey ) {
parseRect(value, &backScreenRect);
} else if ( key == ClosedScreenKey ) {
parseRect( value, &closedScreenRect );
} else if ( key == CursorKey ) {
QStringList l = value.split(QLatin1Char(' '));
skinCursorFileName = l[0];
cursorHot = QPoint(l[1].toInt(),l[2].toInt());
} else if ( key == AreasKey ) {
nareas = value.toInt();
} else if ( key == ToggleAreasKey ) {
toggleAreas = value.split(QLatin1Char(' '));
} else if ( key == ToggleActiveAreasKey ) {
toggleActiveAreas = value.split(QLatin1Char(' '));
} else if ( key == HasMouseHoverKey ) {
hasMouseHover = value == QLatin1String("true") || value == QLatin1String("1");
}
} else {
*errorMessage = DeviceSkin::tr("Syntax error: %1").arg(line);
return false;
}
}
}
} else {
// Old
skinImageUpFileName = mark;
QString s;
int x,y,w,h,na;
ts >> s >> x >> y >> w >> h >> na;
skinImageDownFileName = s;
screenRect.setRect(x, y, w, h);
nareas = na;
}
// Done for short mode
if (rm == ReadSizeOnly)
return true;
// verify skin files exist
skinImageUpFileName.insert(0, prefix);
if (!QFile(skinImageUpFileName).exists()) {
*errorMessage = DeviceSkin::tr("The skin \"up\" image file '%1' does not exist.").arg(skinImageUpFileName);
return false;
}
if (!skinImageUp.load(skinImageUpFileName)) {
*errorMessage = msgImageNotLoaded(skinImageUpFileName);
return false;
}
skinImageDownFileName.insert(0, prefix);
if (!QFile(skinImageDownFileName).exists()) {
*errorMessage = DeviceSkin::tr("The skin \"down\" image file '%1' does not exist.").arg(skinImageDownFileName);
return false;
}
if (!skinImageDown.load(skinImageDownFileName)) {
*errorMessage = msgImageNotLoaded(skinImageDownFileName);
return false;
}
if (!skinImageClosedFileName.isEmpty()) {
skinImageClosedFileName.insert(0, prefix);
if (!QFile(skinImageClosedFileName).exists()) {
*errorMessage = DeviceSkin::tr("The skin \"closed\" image file '%1' does not exist.").arg(skinImageClosedFileName);
return false;
}
if (!skinImageClosed.load(skinImageClosedFileName)) {
*errorMessage = msgImageNotLoaded(skinImageClosedFileName);
return false;
}
}
if (!skinCursorFileName.isEmpty()) {
skinCursorFileName.insert(0, prefix);
if (!QFile(skinCursorFileName).exists()) {
*errorMessage = DeviceSkin::tr("The skin cursor image file '%1' does not exist.").arg(skinCursorFileName);
return false;
}
if (!skinCursor.load(skinCursorFileName)) {
*errorMessage = msgImageNotLoaded(skinCursorFileName);
return false;
}
}
// read areas
if (!nareas)
return true;
buttonAreas.reserve(nareas);
int i = 0;
ts.readLine(); // eol
joystick = -1;
const QString Joystick = QLatin1String("Joystick");
while (i < nareas && !ts.atEnd() ) {
buttonAreas.push_back(DeviceSkinButtonArea());
DeviceSkinButtonArea &area = buttonAreas.back();
const QString line = ts.readLine();
if ( !line.isEmpty() && line[0] != QLatin1Char('#') ) {
const QStringList tok = line.split(QRegExp(QLatin1String("[ \t][ \t]*")));
if ( tok.count()<6 ) {
*errorMessage = DeviceSkin::tr("Syntax error in area definition: %1").arg(line);
return false;
} else {
area.name = tok[0];
QString k = tok[1];
if ( k.left(2).toLower() == QLatin1String("0x")) {
area.keyCode = k.mid(2).toInt(0,16);
} else {
area.keyCode = k.toInt();
}
int p=0;
for (int j=2; j < tok.count() - 1; ) {
const int x = tok[j++].toInt();
const int y = tok[j++].toInt();
area.area.putPoints(p++,1,x,y);
}
const QChar doubleQuote = QLatin1Char('"');
if ( area.name[0] == doubleQuote && area.name.endsWith(doubleQuote)) {
area.name.truncate(area.name.size() - 1);
area.name.remove(0, 1);
}
if ( area.name.length() == 1 )
area.text = area.name;
if ( area.name == Joystick)
joystick = i;
area.activeWhenClosed = closedAreas.contains(area.name)
|| area.keyCode == Qt::Key_Flip; // must be to work
area.toggleArea = toggleAreas.contains(area.name);
area.toggleActiveArea = toggleActiveAreas.contains(area.name);
if ( area.toggleArea )
toggleAreaList += i;
i++;
}
}
}
if (i != nareas) {
qWarning() << DeviceSkin::tr("Mismatch in number of areas, expected %1, got %2.")
.arg(nareas).arg(i);
}
if (debugDeviceSkin)
qDebug() << *this;
return true;
}
std::unique_ptr<SVGAnimatedType> SVGAnimatedRectAnimator::constructFromString(const String& string)
{
auto animatedType = SVGAnimatedType::createRect(std::make_unique<FloatRect>());
parseRect(string, animatedType->rect());
return animatedType;
}
