/** Parse status window type. */
StatusWindowType ParseStatusWindowType(const TokenNode *tp)
{
static const StringMappingType mapping[] = {
{ "corner", SW_CORNER },
{ "off", SW_OFF },
{ "screen", SW_SCREEN },
{ "window", SW_WINDOW }
};
return ParseAttribute(mapping, ARRAY_LENGTH(mapping), tp,
"coordinates", SW_SCREEN);
}
void CImageAttribute::SetAttributeString(LPCTSTR pStrImageAttri)
{
if (m_sImageAttribute == pStrImageAttri)
return;
Clear();
m_sImageAttribute = pStrImageAttri;
m_sImage = m_sImageAttribute;
ParseAttribute(pStrImageAttri);
}
void AttributesScheme::loadXMLSettings(xml::XMLElement* elem)
{
xml::xmlSubElementsMapIT it= elem->getElementsBegin();
xml::xmlSubElementsMapIT end= elem->getElementsEnd();
for(;it!=end;++it)
{
if((*it)->GetType()!=xml::ENT_Element)continue;
xml::XMLElement* e=dynamic_cast<xml::XMLElement*>(*it);
if(e->getName().equals_ignore_case(mT("Attribute")))
{
ParseAttribute(e);
}
}
}
bool GenericXMLParser::ParseTag(String &tag, Anything &tagAttributes)
{
StartTrace(GenericXMLParser.ParseTag);
tag = ParseName();
Trace("tag = " << tag);
while (!IsEof()) {
SkipWhitespace();
int c = Peek();
switch (c) {
case '>': // done with tag
c = Get();
return true;//lint !e438
case '/': // an empty tag? i.e. <br />
c = Get();
if ('>' == Peek()) {
c = Get();
return false;//lint !e438
}
// an error occured, ignore '/' silently
PutBack(c);
default: {//lint !e616
String name;
String value;
if (ParseAttribute(name, value)) {
tagAttributes[name] = value;
} else {
// non-well formed XML...no value given
if (name.Length() > 0) {
tagAttributes.Append(name);
} else {
String msg("Unexpected character <");
c = Get();
msg.AppendAsHex((unsigned char)c).Append("> near ").Append(tag);
Error(msg);
tagAttributes.Append(String(char(c)));
}
}
}
}
}
Error("unexpected EOF in Tag");
return false; // no body to expect
}
bool XMLReader::ParseElement()
{
// element ::= EmptyElemTag
// | STag content ETag
// EmptyElemTag ::= '<' Name (S Attribute)* S? '/>'
// STag ::= '<' Name (S Attribute)* S? '>'
if (ParseString("<") && ParseName(mCurrentName)) {
mNodeType = kElement;
mAttributes.clear();
while (ParseRequiredWhitespace()) {
Attribute attribute;
if (ParseString("/>")) {
mIsEmptyElement = true;
PopNamespaces(PushNamespaces());
return true;
}
else if (ParseString(">")) {
mIsEmptyElement = false;
PushTag();
return true;
}
else if (ParseAttribute(attribute)) {
mAttributes.push_back(attribute);
}
else return false;
}
if (ParseString("/>")) {
mIsEmptyElement = true;
PopNamespaces(PushNamespaces());
return true;
}
else if (ParseString(">")) {
mIsEmptyElement = false;
PushTag();
return true;
}
}
return false;
}
bool XMLReader::ParseXmlDeclaration()
{
// XMLDecl ::= '<?xml' VersionInfo EncodingDecl? SDDecl? S? '?>'
// VersionInfo ::= S 'version' Eq ("'" VersionNum "'" | '"' VersionNum '"')
// EncodingDecl ::= S 'encoding' Eq ('"' EncName '"' | "'" EncName "'" )
// SDDecl ::= S 'standalone' Eq (("'" ('yes' | 'no') "'") | ('"' ('yes' | 'no') '"'))
if (ParseString("<?xml")) {
mNodeType = kXmlDeclaration;
mCurrentName.SetName("xml");
mAttributes.clear();
while (ParseRequiredWhitespace()) {
Attribute attribute;
if (ParseString("?>")) return true;
else if (ParseAttribute(attribute)) {
mAttributes.push_back(attribute);
}
else return false;
}
if (ParseString("?>")) return true;
}
return false;
}
// This reads xmlStream until the end of the start or empty-element tag is
// reached, parsing attributes along the way into attributeDestination,
// throwing an exception if it does not reach the end of the tag without
// the stream ending or finding malformed XML. All the characters of the
// tag get put into tagRecord if it is not NULL.
inline void
RestrictedXmlParser::CloseStartTag( AttributeMap* attributeDestination,
std::ostream* tagRecord )
{
if( !(SkipWhitespace( tagRecord )) )
{
throw std::runtime_error( "Could not find end of start tag!" );
}
// Now currentChar is the end of the start tag ('>'), or the first
// character of the end of an empty element tag ('/' in "/>") (or the
// tag is malformed with a '/' out of place), or is the first character
// of an attribute name.
if( TagIsStillOpen( tagRecord ) )
{
ParseAttribute( attributeDestination,
tagRecord );
if( !(ReadCharacter( tagRecord )) )
{
throw std::runtime_error( "Could not find end of start tag!" );
}
CloseStartTag( attributeDestination,
tagRecord );
}
}
Scale::Scale(const QDomElement& el)
{
m_bBoundScale = true;
Q_ASSERT(el.tagName() == TAG_SCALE);
QString qsA = ParseAttribute(el, TAG_PARAM);
m_pPar = ParameterContainer::GetInstance()->GetParameter(qsA);
if(m_pPar == NULL) {
qCritical() << "Scale parameter" << qsA << "does not exist in ParameterContainer.";
}
m_bYellow = el.attribute(TAG_YELLOW)!=QLatin1String(TAG_NO);
m_bGreen = el.attribute(TAG_GREEN)!=QLatin1String(TAG_NO);
m_bLowLimit = el.attribute(TAG_LO_LIMIT)!=QLatin1String(TAG_NO);
qsA = el.attribute(TAG_HI_LIMIT);
m_eHighLimit = qsA==QLatin1String(TAG_NO) ? ltNone :
qsA==QLatin1String(TAG_ARC) ? ltArc : ltTick;
m_fDumping = el.attribute(TAG_DUMPING, "0").toFloat();
m_vDump.resize(m_pPar->GetCount());
// Scale type
Q_ASSERT(m_pPar->GetUnitKeyUser() >= 0);
bool bFound = false;
QDomElement et = el.firstChildElement(TAG_TYPE);
for(; !et.isNull(); et = et.nextSiblingElement(TAG_TYPE)) {
// We are only interested in user selected units
bFound = (ParseUnitKey(et, TAG_UNIT) == m_pPar->GetUnitKeyUser());
if(bFound) {
m_fS = ParseAttribute(et, TAG_LOW).toFloat();
m_fE = ParseAttribute(et, TAG_HIGH).toFloat();
m_fMajorTickStep = ParseAttribute(et, TAG_MAJOR).toFloat();
m_iMinorIntervalCount = ParseAttribute(et, TAG_MINOR).toInt();
m_fLabelStep = ParseAttribute(et, TAG_LABEL).toFloat();
m_fMultiplier = et.attribute(TAG_MULT,"1").toFloat();
m_iDecimals = el.attribute(TAG_DECIMALS).toInt();
break;
}
}
}
void
nsMathMLmpaddedFrame::ProcessAttributes()
{
/*
parse the attributes
width = [+|-] unsigned-number (% [pseudo-unit] | pseudo-unit | h-unit | namedspace)
height = [+|-] unsigned-number (% [pseudo-unit] | pseudo-unit | v-unit | namedspace)
depth = [+|-] unsigned-number (% [pseudo-unit] | pseudo-unit | v-unit | namedspace)
lspace = [+|-] unsigned-number (% [pseudo-unit] | pseudo-unit | h-unit | namedspace)
voffset= [+|-] unsigned-number (% [pseudo-unit] | pseudo-unit | v-unit | namedspace)
*/
nsAutoString value;
/* The REC says:
There is one exceptional element, <mpadded>, whose attributes cannot be
set with <mstyle>. When the attributes width, height and depth are specified
on an <mstyle> element, they apply only to the <mspace/> element. Similarly,
when lspace is set with <mstyle>, it applies only to the <mo> element. To be
consistent, the voffset attribute of the mpadded element can not be set on
mstyle.
*/
// See if attributes are local, don't access mstyle !
// width
mWidthSign = NS_MATHML_SIGN_INVALID;
GetAttribute(mContent, nullptr, nsGkAtoms::width, value);
if (!value.IsEmpty()) {
if (!ParseAttribute(value, mWidthSign, mWidth, mWidthPseudoUnit)) {
ReportParseError(nsGkAtoms::width->GetUTF16String(), value.get());
}
}
// height
mHeightSign = NS_MATHML_SIGN_INVALID;
GetAttribute(mContent, nullptr, nsGkAtoms::height, value);
if (!value.IsEmpty()) {
if (!ParseAttribute(value, mHeightSign, mHeight, mHeightPseudoUnit)) {
ReportParseError(nsGkAtoms::height->GetUTF16String(), value.get());
}
}
// depth
mDepthSign = NS_MATHML_SIGN_INVALID;
GetAttribute(mContent, nullptr, nsGkAtoms::depth_, value);
if (!value.IsEmpty()) {
if (!ParseAttribute(value, mDepthSign, mDepth, mDepthPseudoUnit)) {
ReportParseError(nsGkAtoms::depth_->GetUTF16String(), value.get());
}
}
// lspace
mLeadingSpaceSign = NS_MATHML_SIGN_INVALID;
GetAttribute(mContent, nullptr, nsGkAtoms::lspace_, value);
if (!value.IsEmpty()) {
if (!ParseAttribute(value, mLeadingSpaceSign, mLeadingSpace,
mLeadingSpacePseudoUnit)) {
ReportParseError(nsGkAtoms::lspace_->GetUTF16String(), value.get());
}
}
// voffset
mVerticalOffsetSign = NS_MATHML_SIGN_INVALID;
GetAttribute(mContent, nullptr, nsGkAtoms::voffset_, value);
if (!value.IsEmpty()) {
if (!ParseAttribute(value, mVerticalOffsetSign, mVerticalOffset,
mVerticalOffsetPseudoUnit)) {
ReportParseError(nsGkAtoms::voffset_->GetUTF16String(), value.get());
}
}
}
bool XSDParser::ParseContent(DTDElement& node, bool extended /*=false*/)
{
DTDElement::EType curr_type;
int emb=0;
bool eatEOT= false;
bool hasContents= false;
TToken tok;
for ( tok=GetNextToken(); ; tok=GetNextToken()) {
emb= node.GetContent().size();
if (tok != T_EOF &&
tok != K_ENDOFTAG &&
tok != K_ANNOTATION) {
hasContents= true;
}
switch (tok) {
case T_EOF:
return hasContents;
case K_ENDOFTAG:
if (eatEOT) {
eatEOT= false;
break;
}
FixEmbeddedNames(node);
return hasContents;
case K_COMPLEXTYPE:
ParseComplexType(node);
break;
case K_SIMPLECONTENT:
ParseSimpleContent(node);
break;
case K_EXTENSION:
ParseExtension(node);
break;
case K_RESTRICTION:
ParseRestriction(node);
break;
case K_ATTRIBUTE:
ParseAttribute(node);
break;
case K_ATTRIBUTEGROUP:
ParseAttributeGroup(node);
break;
case K_ANY:
node.SetTypeIfUnknown(DTDElement::eSequence);
{
string name = CreateTmpEmbeddedName(node.GetName(), emb);
DTDElement& elem = m_MapElement[name];
elem.SetName(name);
elem.SetSourceLine(Lexer().CurrentLine());
elem.SetEmbedded();
elem.SetType(DTDElement::eAny);
elem.SetQualified(node.IsQualified());
ParseAny(elem);
AddElementContent(node,name);
}
break;
case K_SEQUENCE:
emb= node.GetContent().size();
if (emb != 0 && extended) {
node.SetTypeIfUnknown(DTDElement::eSequence);
if (node.GetType() != DTDElement::eSequence) {
ParseError("sequence");
}
tok = GetRawAttributeSet();
eatEOT = true;
break;
}
curr_type = node.GetType();
if (curr_type == DTDElement::eUnknown ||
curr_type == DTDElement::eUnknownGroup ||
(m_ResolveTypes && curr_type == DTDElement::eEmpty)) {
node.SetType(DTDElement::eSequence);
ParseContainer(node);
if (node.GetContent().empty()) {
node.ResetType(curr_type);
}
} else {
string name = CreateTmpEmbeddedName(node.GetName(), emb);
DTDElement& elem = m_MapElement[name];
elem.SetName(name);
elem.SetSourceLine(Lexer().CurrentLine());
elem.SetEmbedded();
elem.SetType(DTDElement::eSequence);
elem.SetQualified(node.IsQualified());
ParseContainer(elem);
AddElementContent(node,name);
}
break;
case K_CHOICE:
curr_type = node.GetType();
if (curr_type == DTDElement::eUnknown ||
curr_type == DTDElement::eUnknownGroup ||
(m_ResolveTypes && curr_type == DTDElement::eEmpty)) {
node.SetType(DTDElement::eChoice);
ParseContainer(node);
if (node.GetContent().empty()) {
node.ResetType(curr_type);
}
} else {
string name = CreateTmpEmbeddedName(node.GetName(), emb);
DTDElement& elem = m_MapElement[name];
elem.SetName(name);
elem.SetSourceLine(Lexer().CurrentLine());
elem.SetEmbedded();
elem.SetType(DTDElement::eChoice);
elem.SetQualified(node.IsQualified());
ParseContainer(elem);
AddElementContent(node,name);
}
break;
case K_SET:
curr_type = node.GetType();
if (curr_type == DTDElement::eUnknown ||
curr_type == DTDElement::eUnknownGroup ||
(m_ResolveTypes && curr_type == DTDElement::eEmpty)) {
node.SetType(DTDElement::eSet);
ParseContainer(node);
if (node.GetContent().empty()) {
node.ResetType(curr_type);
}
} else {
string name = CreateTmpEmbeddedName(node.GetName(), emb);
DTDElement& elem = m_MapElement[name];
elem.SetName(name);
elem.SetSourceLine(Lexer().CurrentLine());
elem.SetEmbedded();
elem.SetType(DTDElement::eSet);
elem.SetQualified(node.IsQualified());
ParseContainer(elem);
AddElementContent(node,name);
}
break;
case K_ELEMENT:
{
string name = ParseElementContent(&node,emb);
AddElementContent(node,name);
}
break;
case K_GROUP:
{
string name = ParseGroup(&node,emb);
AddElementContent(node,name);
}
break;
case K_ANNOTATION:
SetCommentsIfEmpty(&(node.Comments()));
ParseAnnotation();
break;
case K_UNION:
ParseUnion(node);
break;
case K_LIST:
ParseList(node);
break;
default:
for ( tok = GetNextToken(); tok == K_ATTPAIR || tok == K_XMLNS; tok = GetNextToken())
;
if (tok == K_CLOSING) {
ParseContent(node);
}
break;
}
}
FixEmbeddedNames(node);
return hasContents;
}
ClassAd *ClassAdXMLParser::
ParseClassAd(ClassAd *classad_in)
{
bool in_classad;
ClassAd *classad = NULL;
ClassAd *local_ad = NULL;
XMLLexer::Token token;
classad = NULL;
in_classad = false;
while (lexer.PeekToken(&token)) {
if (!in_classad) {
lexer.ConsumeToken(NULL);
if ( token.token_type == XMLLexer::tokenType_Tag
&& token.tag_id == XMLLexer::tagID_ClassAd) {
// We have a ClassAd tag
if (token.tag_type == XMLLexer::tagType_Start) {
in_classad = true;
if ( classad_in ) {
classad_in->Clear();
classad = classad_in;
} else {
local_ad = new ClassAd();
classad = local_ad;
}
classad->DisableDirtyTracking();
} else {
// We're done, return the ClassAd we got, if any.
in_classad = false;
break;
}
}
} else {
if (token.token_type == XMLLexer::tokenType_Tag) {
if (token.tag_id == XMLLexer::tagID_Attribute) {
if (token.tag_type == XMLLexer::tagType_Invalid) {
delete local_ad;
return NULL;
} else if( token.tag_type == XMLLexer::tagType_Start) {
string attribute_name;
ExprTree *tree;
tree = ParseAttribute(attribute_name);
if (tree != NULL) {
classad->Insert(attribute_name, tree);
}
else {
delete local_ad;
return NULL;
}
} else {
lexer.ConsumeToken(NULL);
}
} else if (token.tag_id == XMLLexer::tagID_ClassAd) {
lexer.ConsumeToken(NULL);
if (token.tag_type == XMLLexer::tagType_End) {
in_classad = false;
break;
} else {
// This is invalid, but we'll just ignore it.
}
} else if ( token.tag_id != XMLLexer::tagID_XML
&& token.tag_id != XMLLexer::tagID_XMLStylesheet
&& token.tag_id != XMLLexer::tagID_Doctype
&& token.tag_id != XMLLexer::tagID_ClassAds) {
// We got a non-attribute, non-xml thingy within a
// ClassAd. That must be an error, but we'll just skip
// it in the hopes of recovering.
lexer.ConsumeToken(NULL);
break;
}
} else {
lexer.ConsumeToken(NULL);
}
}
}
if (classad != NULL) {
classad->EnableDirtyTracking();
}
return classad;
}
void CImageAttribute::ModifyAttribute(LPCTSTR pStrModify)
{
ParseAttribute(pStrModify);
}
void
nsMathMLmpaddedFrame::ProcessAttributes()
{
/*
parse the attributes
width = [+|-] unsigned-number (% [pseudo-unit] | pseudo-unit | h-unit | namedspace)
height = [+|-] unsigned-number (% [pseudo-unit] | pseudo-unit | v-unit | namedspace)
depth = [+|-] unsigned-number (% [pseudo-unit] | pseudo-unit | v-unit | namedspace)
lspace = [+|-] unsigned-number (% [pseudo-unit] | pseudo-unit | h-unit | namedspace)
voffset= [+|-] unsigned-number (% [pseudo-unit] | pseudo-unit | v-unit | namedspace)
*/
nsAutoString value;
// width
mWidthSign = NS_MATHML_SIGN_INVALID;
mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::width, value);
if (!value.IsEmpty()) {
if (!ParseAttribute(value, mWidthSign, mWidth, mWidthPseudoUnit)) {
ReportParseError(nsGkAtoms::width->GetUTF16String(), value.get());
}
}
// height
mHeightSign = NS_MATHML_SIGN_INVALID;
mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::height, value);
if (!value.IsEmpty()) {
if (!ParseAttribute(value, mHeightSign, mHeight, mHeightPseudoUnit)) {
ReportParseError(nsGkAtoms::height->GetUTF16String(), value.get());
}
}
// depth
mDepthSign = NS_MATHML_SIGN_INVALID;
mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::depth_, value);
if (!value.IsEmpty()) {
if (!ParseAttribute(value, mDepthSign, mDepth, mDepthPseudoUnit)) {
ReportParseError(nsGkAtoms::depth_->GetUTF16String(), value.get());
}
}
// lspace
mLeadingSpaceSign = NS_MATHML_SIGN_INVALID;
mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::lspace_, value);
if (!value.IsEmpty()) {
if (!ParseAttribute(value, mLeadingSpaceSign, mLeadingSpace,
mLeadingSpacePseudoUnit)) {
ReportParseError(nsGkAtoms::lspace_->GetUTF16String(), value.get());
}
}
// voffset
mVerticalOffsetSign = NS_MATHML_SIGN_INVALID;
mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::voffset_, value);
if (!value.IsEmpty()) {
if (!ParseAttribute(value, mVerticalOffsetSign, mVerticalOffset,
mVerticalOffsetPseudoUnit)) {
ReportParseError(nsGkAtoms::voffset_->GetUTF16String(), value.get());
}
}
}
status_t
PackageFile::WriteToPath(const char *path, ItemState *state)
{
if (state == NULL)
return B_ERROR;
BPath &destination = state->destination;
status_t ret = B_OK;
parser_debug("File: %s WriteToPath() called!\n", fPath.String());
BFile file;
if (state->status == B_NO_INIT || destination.InitCheck() != B_OK) {
ret = InitPath(path, &destination);
if (ret != B_OK)
return ret;
ret = file.SetTo(destination.Path(),
B_WRITE_ONLY | B_CREATE_FILE | B_FAIL_IF_EXISTS);
if (ret == B_ENTRY_NOT_FOUND) {
BPath directory;
destination.GetParent(&directory);
if (create_directory(directory.Path(), kDefaultMode) != B_OK)
return B_ERROR;
ret = file.SetTo(destination.Path(), B_WRITE_ONLY | B_CREATE_FILE);
} else if (ret == B_FILE_EXISTS)
state->status = B_FILE_EXISTS;
if (ret != B_OK)
return ret;
}
if (state->status == B_FILE_EXISTS) {
switch (state->policy) {
case P_EXISTS_OVERWRITE:
ret = file.SetTo(destination.Path(),
B_WRITE_ONLY | B_ERASE_FILE);
break;
case P_EXISTS_NONE:
case P_EXISTS_ASK:
ret = B_FILE_EXISTS;
break;
case P_EXISTS_SKIP:
return B_OK;
}
}
if (ret != B_OK)
return ret;
parser_debug(" File created!\n");
// Set the file permissions, creation and modification times
ret = file.SetPermissions(static_cast<mode_t>(fMode));
if (fCreationTime && ret == B_OK)
ret = file.SetCreationTime(static_cast<time_t>(fCreationTime));
if (fModificationTime && ret == B_OK)
ret = file.SetModificationTime(static_cast<time_t>(fModificationTime));
if (ret != B_OK)
return ret;
// Set the mimetype and application signature if present
BNodeInfo info(&file);
if (fMimeType.Length() > 0) {
ret = info.SetType(fMimeType.String());
if (ret != B_OK)
return ret;
}
if (fSignature.Length() > 0) {
ret = info.SetPreferredApp(fSignature.String());
if (ret != B_OK)
return ret;
}
if (fOffset) {
parser_debug("We have an offset\n");
if (!fPackage)
return B_ERROR;
ret = fPackage->InitCheck();
if (ret != B_OK)
return ret;
// We need to parse the data section now
fPackage->Seek(fOffset, SEEK_SET);
uint8 buffer[7];
char *attrName = 0;
uint32 nameSize = 0;
uint8 *attrData = new uint8[P_CHUNK_SIZE];
uint64 dataSize = P_CHUNK_SIZE;
uint8 *temp = new uint8[P_CHUNK_SIZE];
uint64 tempSize = P_CHUNK_SIZE;
uint64 attrCSize = 0, attrOSize = 0;
uint32 attrType = 0; // type_code type
bool attrStarted = false, done = false;
uint8 section = P_ATTRIBUTE;
while (fPackage->Read(buffer, 7) == 7) {
if (!memcmp(buffer, "FBeA", 5)) {
parser_debug("-> Attribute\n");
section = P_ATTRIBUTE;
continue;
} else if (!memcmp(buffer, "FiDa", 5)) {
parser_debug("-> File data\n");
section = P_DATA;
continue;
}
switch (section) {
case P_ATTRIBUTE:
ret = ParseAttribute(buffer, &file, &attrName, &nameSize,
&attrType, &attrData, &dataSize, &temp, &tempSize,
&attrCSize, &attrOSize, &attrStarted, &done);
break;
case P_DATA:
ret = ParseData(buffer, &file, fOriginalSize, &done);
break;
default:
return B_ERROR;
}
if (ret != B_OK || done)
break;
}
delete[] attrData;
delete[] temp;
}
return ret;
}
/** Parse tray. */
void ParseTray(const TokenNode *tp)
{
static const StringMappingType mapping[] = {
{ "bottom", THIDE_BOTTOM },
{ "left", THIDE_LEFT },
{ "off", THIDE_OFF },
{ "right", THIDE_RIGHT },
{ "top", THIDE_TOP }
};
const TokenNode *np;
const char *attr;
TrayType *tray;
TrayAutoHideType autohide;
Assert(tp);
tray = CreateTray();
autohide = ParseAttribute(mapping, ARRAY_LENGTH(mapping), tp,
"autohide", THIDE_OFF);
SetAutoHideTray(tray, autohide);
attr = FindAttribute(tp->attributes, X_ATTRIBUTE);
if(attr) {
SetTrayX(tray, attr);
}
attr = FindAttribute(tp->attributes, Y_ATTRIBUTE);
if(attr) {
SetTrayY(tray, attr);
}
attr = FindAttribute(tp->attributes, WIDTH_ATTRIBUTE);
if(attr) {
SetTrayWidth(tray, attr);
}
attr = FindAttribute(tp->attributes, HEIGHT_ATTRIBUTE);
if(attr) {
SetTrayHeight(tray, attr);
}
attr = FindAttribute(tp->attributes, "valign");
SetTrayVerticalAlignment(tray, attr);
attr = FindAttribute(tp->attributes, "halign");
SetTrayHorizontalAlignment(tray, attr);
attr = FindAttribute(tp->attributes, "layout");
SetTrayLayout(tray, attr);
attr = FindAttribute(tp->attributes, "layer");
if(attr) {
SetTrayLayer(tray, ParseLayer(tp, attr));
}
for(np = tp->subnodeHead; np; np = np->next) {
switch(np->type) {
case TOK_PAGER:
ParsePager(np, tray);
break;
case TOK_TASKLIST:
ParseTaskList(np, tray);
break;
case TOK_SWALLOW:
ParseSwallow(np, tray);
break;
case TOK_TRAYBUTTON:
ParseTrayButton(np, tray);
break;
case TOK_CLOCK:
ParseClock(np, tray);
break;
case TOK_DOCK:
ParseDock(np, tray);
break;
case TOK_SPACER:
ParseSpacer(np, tray);
break;
default:
InvalidTag(np, TOK_TRAY);
break;
}
}
}
FarXMLNode *FarXMLScanner::ParseChildNode()
{
SkipWhitespace();
int tagStartLine = fCurLine;
int tagStartCol = GetCurColumn();
if (!NextExpectedChar ('<'))
return NULL;
FarString tagName = NextName();
if (tagName.IsEmpty())
return NULL;
FarXMLNode *theNode = new FarXMLNode();
theNode->SetTag (tagName);
theNode->SetStartPosition (tagStartLine, tagStartCol);
while (1)
{
SkipWhitespace();
char c = PeekNextChar();
if (c == '/')
{
NextChar();
if (!NextExpectedChar ('>'))
{
delete theNode;
return NULL;
}
break;
}
else if (c == '>')
{
NextChar();
SkipWhitespace();
while (1)
{
if (PeekNextChar() == '<' && PeekNextChar (1) == '/')
break;
FarXMLNode *nextChild = ParseChildNode();
if (!nextChild)
{
delete theNode;
return NULL;
}
theNode->AddChild (nextChild);
SkipWhitespace();
}
NextChar(); // <
NextChar(); // /
FarString closeTagName = NextName();
if (closeTagName != tagName)
{
ReportError (tagName);
delete theNode;
return NULL;
}
SkipWhitespace();
if (!NextExpectedChar ('>'))
{
delete theNode;
return NULL;
}
break;
}
else
{
if (!ParseAttribute (theNode))
{
delete theNode;
return NULL;
}
}
}
theNode->SetEndPosition (fCurLine, GetCurColumn());
SkipWhitespace();
return theNode;
}
