1 // Copyright (c) 2001-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // Parsing and Processing of script commands, to test the

    15 // SMIL DOM classes.

    16 // 

    17 //

    18 

    19 

    20 #include "t_ScriptRunner.h"

    21 

    22 

    23 _LIT(KLogFileName, "c:\\MsgTest\\SMIL_DOM\\SmilDomLog.txt");

    24 

    25 

    26 // Script Commands

    27 _LIT(KCreateDOMtree, "createdomtree");

    28 _LIT(KDeleteDOMtree, "deletedomtree");

    29 _LIT(KCreate,        "create");

    30 _LIT(KDeleteChild,   "deletechild");

    31 _LIT(KParent,        "parent");

    32 _LIT(KRootSmil,      "rootsmil");

    33 _LIT(KFirstChild,    "firstchild");

    34 _LIT(KLastChild,     "lastchild");

    35 _LIT(KNextSibling,   "nextsibling");

    36 _LIT(KPrevSibling,   "prevsibling");

    37 _LIT(KFirst,         "first");

    38 _LIT(KLast,          "last");

    39 _LIT(KNext,          "next");

    40 _LIT(KPrev,          "prev");

    41 _LIT(KSetAtt,        "setatt");

    42 _LIT(KGetAtt,        "getatt");

    43 _LIT(KUnsetAtt,      "unsetatt");

    44 _LIT(KLegalChildren, "legalchildren");

    45 _LIT(KSetId,         "setid");

    46 _LIT(KGetId,         "getid");

    47 _LIT(KRemoveId,      "removeid");

    48 

    49 

    50 // Script Command Arguments: SMIL Elements (excluding 'smil')

    51 _LIT(KA,           "a");

    52 _LIT(KAnchor,      "anchor");

    53 _LIT(KAnimation,   "animation");

    54 _LIT(KArea,        "area");

    55 _LIT(KAudio,       "audio");

    56 _LIT(KBody,        "body");

    57 _LIT(KHead,        "head");

    58 _LIT(KImg,         "img");

    59 _LIT(KLayout,      "layout");

    60 _LIT(KMeta,        "meta");

    61 _LIT(KPar,         "par");

    62 _LIT(KRef,         "ref");

    63 _LIT(KRegion,      "region");

    64 _LIT(KRoot_layout, "root-layout");

    65 _LIT(KSeq,         "seq");

    66 _LIT(KSwitch,      "switch");

    67 _LIT(KText,        "text");

    68 _LIT(KTextstream,  "textstream");

    69 _LIT(KVideo,       "video");

    70 

    71 

    72 // Other Script Command Arguments

    73 _LIT(KAppend,      "append");

    74 _LIT(KInsert,      "insert");

    75 _LIT(KReplace,     "replace");

    76 

    77 

    78 // Errors reported via the log file

    79 _LIT(KNotSupported,                      "Not supported.");

    80 _LIT(KInvalidChild,                      "Invalid child.");

    81 _LIT(KCannotFindSpecifiedChild,          "Cannot find specified child.");

    82 _LIT(KReachedEnd_ElementInsertedAtStart, "Reached end of child list, element inserted at start of list.");

    83 _LIT(KReachedEnd_NoChildReplaced,        "Reached end of child list, no child has been replaced.");

    84 _LIT(KReachedEnd_NoChildRemoved,         "Reached end of child list, no child has been removed.");

    85 _LIT(KAlreadyAtEndOfList,                "Already at end of list.");

    86 _LIT(KInvalidArgument,                   "Invalid argument.");

    87 _LIT(KAttributeNotSet,                   "Attribute not set.");

    88 _LIT(KElementHasLegalChildren,           "Element has legal children.");

    89 _LIT(KElementHasIllegalChildren,         "Element has illegal children.");

    90 _LIT(KUnrecognisedCommand,               "Unrecognised command.");

    91 _LIT(KUnrecognisedArgument,              "Unrecognised argument.");

    92 _LIT(KUnrecognisedElementType,           "Unrecognised element type.");

    93 _LIT(KNotABasicElt,                      "Error: Current element is not a BasicElt.");

    94 _LIT(KNotOfSpecifiedType,                "Error: Current element is not of the specified type.");

    95 

    96 //

    97 //

    98 // CScriptRunner

    99 //

   100 

   101 CScriptRunner* CScriptRunner::NewL()

   102 	{

   103 	CScriptRunner* self = new (ELeave) CScriptRunner();

   104 	CleanupStack::PushL(self);

   105 	self->ConstructL();

   106 	CleanupStack::Pop();

   107 	return self;

   108 	}

   109 

   110 

   111 CScriptRunner::~CScriptRunner()

   112 	{

   113 	delete iArgumentList;

   114 	delete iCurrentCommand;

   115 	delete iWriter;

   116 	delete iDOMtreeRoot; // This will delete the entire DOM tree

   117 	}

   118 

   119 

   120 CScriptRunner::CScriptRunner()

   121 : iCurrentCommand(NULL), iCurrentElement(NULL), iDOMtreeRoot(NULL)

   122 	{

   123 	}

   124 

   125 

   126 void CScriptRunner::ConstructL()

   127 	{

   128 	iArgumentList = new (ELeave) CDesCArrayFlat(3);

   129 	iWriter = CTestDataWriter::NewL(KLogFileName);

   130 	}

   131 

   132 

   133 // Extract the command, and any arguments, from the given string

   134 void CScriptRunner::ParseL(const TDesC& aCommand)

   135 	{

   136 	// First, echo the command line to the log file

   137 	iWriter->WriteTest(aCommand);

   138 

   139 	iArgumentList->Reset();

   140 	delete iCurrentCommand;

   141 	iCurrentCommand = NULL;

   142 

   143 	// Determine whether aCommand is a command, or a comment

   144 	if (aCommand.Length() >= 2  &&  aCommand[0] == '/'  &&  aCommand[1] == '/')

   145 		{

   146 		// This is a comment

   147 		iCurrentCommand = NULL;

   148 		}

   149 	else // Extract the command, and any arguments

   150 		{

   151 		TInt commandIter = 0;

   152 		TInt commandStart = 0;

   153 		TBool inQuotes = EFalse;

   154 		while (commandIter <= aCommand.Length())

   155 			{

   156 			TBool commandFound = EFalse;

   157 

   158 			if (commandIter < aCommand.Length())

   159 				{

   160 				if (aCommand[commandIter] == '"')

   161 					{

   162 					// We assume that quotes only occur at the beginning and end

   163 					// of arguments. Hence, if we've just found a new quote, we should

   164 					// not make it part of the argument.

   165 					if (!inQuotes)

   166 						{

   167 						inQuotes = ETrue;

   168 						commandStart++;

   169 						}

   170 					else

   171 						{

   172 						// Assume we've got to the end of the argument, and skip the

   173 						// following space.

   174 						commandFound = ETrue;

   175 						commandIter++;

   176 						}

   177 					}

   178 				else if ((aCommand[commandIter] == ' ') && (!inQuotes))

   179 					{

   180 					commandFound = ETrue;

   181 					}

   182 				}

   183 			else

   184 				{

   185 				commandFound = ETrue;

   186 				}

   187 

   188 			if (commandFound)

   189 				{

   190 				if (commandIter > commandStart)

   191 					{

   192 					// Command or argument found

   193 					TInt commandLength = commandIter - commandStart;

   194 

   195 					// If the argument ended in quotes, modify the length to exclude them

   196 					if (inQuotes)

   197 						{

   198 						inQuotes = EFalse;

   199 						commandLength--;

   200 						}

   201 

   202 					if (iCurrentCommand == NULL)

   203 						{

   204 						// This is a command

   205 						iCurrentCommand = HBufC::NewL(commandLength);

   206 						(*iCurrentCommand) = aCommand.Mid(commandStart, commandLength);

   207 						}

   208 					else

   209 						{

   210 						// This is a command argument

   211 						iArgumentList->AppendL(aCommand.Mid(commandStart, commandLength));

   212 						}

   213 

   214 					// Set the start of the next argument

   215 					commandStart = commandIter + 1;

   216 					}

   217 				}

   218 

   219 			commandIter++;

   220 			}

   221 		}

   222 

   223 	if (iCurrentCommand != NULL)

   224 		{

   225 		// Process the command

   226 		ProcessL();

   227 		}

   228 	}

   229 

   230 

   231 // Process the script command

   232 void CScriptRunner::ProcessL()

   233 	{

   234 	if (iCurrentCommand->Compare(KCreateDOMtree) == 0)

   235 		{

   236 		// Create a new DOM tree (document + smil) & make the smil the current element.

   237 		// Command: createdomtree

   238 

   239 		iDOMtreeRoot = CMDXMLSMILDocument::NewL();

   240 		CMDXMLSMILsmil* smilElement = CMDXMLSMILsmil::NewL(iDOMtreeRoot);

   241 

   242 		// The 'document' takes ownership of the 'smil' element

   243 		CMDXMLElement* documentElement = iDOMtreeRoot->DocumentElement();

   244 		documentElement->AppendChild(smilElement);

   245 		iCurrentElement = smilElement;

   246 		}

   247 	else if (iCurrentCommand->Compare(KDeleteDOMtree) == 0)

   248 		{

   249 		// Delete the DOM tree

   250 		// Command: deletedomtree

   251 

   252 		delete iDOMtreeRoot; // This will delete the entire DOM tree

   253 		iDOMtreeRoot = NULL;

   254 		iCurrentElement = NULL;

   255 		}

   256 	else if (iCurrentCommand->Compare(KCreate) == 0)

   257 		{

   258 		CMDXMLElement* newElement = NULL;

   259 

   260 		// Determine element type to create

   261 		if ((*iArgumentList)[0].Compare(KA) == 0)

   262 			{

   263 			newElement = CMDXMLSMILa::NewL(iDOMtreeRoot);

   264 			}

   265 		else if ((*iArgumentList)[0].Compare(KAnchor) == 0)

   266 			{

   267 			newElement = CMDXMLSMILanchor::NewL(iDOMtreeRoot);

   268 			}

   269 		else if ((*iArgumentList)[0].Compare(KAnimation) == 0)

   270 			{

   271 			newElement = CMDXMLSMILanimation::NewL(iDOMtreeRoot);

   272 			}

   273 		else if ((*iArgumentList)[0].Compare(KArea) == 0)

   274 			{

   275 			newElement = CMDXMLSMILarea::NewL(iDOMtreeRoot);

   276 			}

   277 		else if ((*iArgumentList)[0].Compare(KAudio) == 0)

   278 			{

   279 			newElement = CMDXMLSMILaudio::NewL(iDOMtreeRoot);

   280 			}

   281 		else if ((*iArgumentList)[0].Compare(KBody) == 0)

   282 			{

   283 			newElement = CMDXMLSMILbody::NewL(iDOMtreeRoot);

   284 			}

   285 		else if ((*iArgumentList)[0].Compare(KHead) == 0)

   286 			{

   287 			newElement = CMDXMLSMILhead::NewL(iDOMtreeRoot);

   288 			}

   289 		else if ((*iArgumentList)[0].Compare(KImg) == 0)

   290 			{

   291 			newElement = CMDXMLSMILimg::NewL(iDOMtreeRoot);

   292 			}

   293 		else if ((*iArgumentList)[0].Compare(KLayout) == 0)

   294 			{

   295 			newElement = CMDXMLSMILlayout::NewL(iDOMtreeRoot);

   296 			}

   297 		else if ((*iArgumentList)[0].Compare(KMeta) == 0)

   298 			{

   299 			newElement = CMDXMLSMILmeta::NewL(iDOMtreeRoot);

   300 			}

   301 		else if ((*iArgumentList)[0].Compare(KPar) == 0)

   302 			{

   303 			newElement = CMDXMLSMILpar::NewL(iDOMtreeRoot);

   304 			}

   305 		else if ((*iArgumentList)[0].Compare(KRef) == 0)

   306 			{

   307 			newElement = CMDXMLSMILref::NewL(iDOMtreeRoot);

   308 			}

   309 		else if ((*iArgumentList)[0].Compare(KRegion) == 0)

   310 			{

   311 			newElement = CMDXMLSMILregion::NewL(iDOMtreeRoot);

   312 			}

   313 		else if ((*iArgumentList)[0].Compare(KRoot_layout) == 0)

   314 			{

   315 			newElement = CMDXMLSMILroot_layout::NewL(iDOMtreeRoot);

   316 			}

   317 		else if ((*iArgumentList)[0].Compare(KSeq) == 0)

   318 			{

   319 			newElement = CMDXMLSMILseq::NewL(iDOMtreeRoot);

   320 			}

   321 		else if ((*iArgumentList)[0].Compare(KSwitch) == 0)

   322 			{

   323 			newElement = CMDXMLSMILswitch::NewL(iDOMtreeRoot);

   324 			}

   325 		else if ((*iArgumentList)[0].Compare(KText) == 0)

   326 			{

   327 			newElement = CMDXMLSMILtext::NewL(iDOMtreeRoot);

   328 			}

   329 		else if ((*iArgumentList)[0].Compare(KTextstream) == 0)

   330 			{

   331 			newElement = CMDXMLSMILtextstream::NewL(iDOMtreeRoot);

   332 			}

   333 		else if ((*iArgumentList)[0].Compare(KVideo) == 0)

   334 			{

   335 			newElement = CMDXMLSMILvideo::NewL(iDOMtreeRoot);

   336 			}

   337 		else  // Unrecognised element type

   338 			{

   339 			iWriter->WriteTest(KUnrecognisedElementType);

   340 			}

   341 

   342 

   343 		if ((*iArgumentList)[1].Compare(KAppend) == 0)

   344 			{

   345 			// Create an element of a specified type, and add it to the end of the current

   346 			// element’s child list.

   347 			// Command: create <element type> append

   348 

   349 			TInt err = iCurrentElement->AppendChild(newElement);

   350 			if (err != KErrNone)

   351 				{

   352 				delete newElement; // Ownership was not taken

   353 				if (err == KErrNotSupported)

   354 					{

   355 					iWriter->WriteTest(KNotSupported);

   356 					}

   357 				else if (err == KErrXMLInvalidChild)

   358 					{

   359 					iWriter->WriteTest(KInvalidChild);

   360 					}

   361 				}

   362 			}

   363 		else if ((*iArgumentList)[1].Compare(KInsert) == 0)

   364 			{

   365 			// Create an element of a specified type, and insert it at a numerically defined

   366 			// position in the current element’s child list.

   367 			// Command: create <element type> insert n

   368 			// Use n = -3 for start of list (specified with NULL parameter),

   369 			// and no element to insert.

   370 			// Use n = -2 for start of list (specified with pointer to first child),

   371 			// and no element to insert.

   372 			// Use n = -1 for invalid pointer specifying place to insert.

   373 			// Use n = 0 for start of list (specified with NULL parameter)

   374 			// Use n = 1 for start of list (specified with pointer to first child)

   375 			// Then n = 2 for second child etc.

   376 

   377 			// Convert the final argument to an integer

   378 			TLex lex = (*iArgumentList)[2];

   379 			TInt position;

   380 			lex.Val(position);

   381 

   382 			CMDXMLNode* insertBeforeChild = NULL;

   383 

   384 			if (position == -3)

   385 				{

   386 				insertBeforeChild = NULL; // One way of specifying start of list

   387 				delete newElement;

   388 				newElement = NULL;

   389 				}

   390 			else if (position == -2)

   391 				{

   392 				insertBeforeChild = iCurrentElement->FirstChild();

   393 				delete newElement;

   394 				newElement = NULL;

   395 				}

   396 			else if (position == -1)

   397 				{

   398 				insertBeforeChild = iCurrentElement; // Invalid pointer - not a child

   399 				}

   400 			else if (position == 0)

   401 				{

   402 				insertBeforeChild = NULL; // One way of specifying start of list

   403 				}

   404 			else if (position > 0)

   405 				{

   406 				insertBeforeChild = iCurrentElement->FirstChild();

   407 

   408 				while (position-- > 1  &&  insertBeforeChild != NULL)

   409 					{

   410 					insertBeforeChild = insertBeforeChild->NextSibling();

   411 					}

   412 

   413 				if (insertBeforeChild == NULL)

   414 					{

   415 					iWriter->WriteTest(KReachedEnd_ElementInsertedAtStart);

   416 					}

   417 				}

   418 

   419 			TInt err = iCurrentElement->InsertBefore(insertBeforeChild, newElement);

   420 			if (err != KErrNone)

   421 				{

   422 				delete newElement; // Ownership was not taken

   423 				if (err == KErrNotSupported)

   424 					{

   425 					iWriter->WriteTest(KNotSupported);

   426 					}

   427 				else if (err == KErrXMLInvalidChild)

   428 					{

   429 					iWriter->WriteTest(KInvalidChild);

   430 					}

   431 				else if (err == KErrNotFound)

   432 					{

   433 					iWriter->WriteTest(KCannotFindSpecifiedChild);

   434 					}

   435 				}

   436 			}

   437 		else if ((*iArgumentList)[1].Compare(KReplace) == 0)

   438 			{

   439 			// Create an element of a specified type and use it to replace a numerically defined

   440 			// child element in the current element’s child list. Delete the old child.

   441 			// Command: create <element type> replace n

   442 			// Use n = -2 for start of list, and no element to insert.

   443 			// Use n = -1 for invalid pointer specifying child to replace.

   444 			// Use n = 0 for NULL, in place of pointer to child to replace.

   445 			// Use n = 1 for start of list

   446 			// Then n = 2 for second child etc.

   447 

   448 			// Convert the final argument to an integer

   449 			TLex lex = (*iArgumentList)[2];

   450 			TInt position;

   451 			lex.Val(position);

   452 

   453 			CMDXMLNode* childToReplace = NULL;

   454 

   455 			if (position == -2)

   456 				{

   457 				childToReplace = iCurrentElement->FirstChild();

   458 				delete newElement;

   459 				newElement = NULL;

   460 				}

   461 			else if (position == -1)

   462 				{

   463 				childToReplace = iCurrentElement; // Invalid pointer - not a child

   464 				}

   465 			else if (position == 0)

   466 				{

   467 				childToReplace = NULL; // Invalid

   468 				}

   469 			else if (position > 0)

   470 				{

   471 				childToReplace = iCurrentElement->FirstChild();

   472 

   473 				while (position-- > 1  &&  childToReplace != NULL)

   474 					{

   475 					childToReplace = childToReplace->NextSibling();

   476 					}

   477 

   478 				if (childToReplace == NULL)

   479 					{

   480 					iWriter->WriteTest(KReachedEnd_NoChildReplaced);

   481 					}

   482 				}

   483 

   484 			TInt err = iCurrentElement->ReplaceChild(newElement, childToReplace);

   485 			if (err != KErrNone)

   486 				{

   487 				delete newElement; // Ownership was not taken

   488 				if (err == KErrNotSupported)

   489 					{

   490 					iWriter->WriteTest(KNotSupported);

   491 					}

   492 				else if (err == KErrXMLInvalidChild)

   493 					{

   494 					iWriter->WriteTest(KInvalidChild);

   495 					}

   496 				else if (err == KErrNotFound)

   497 					{

   498 					iWriter->WriteTest(KCannotFindSpecifiedChild);

   499 					}

   500 				}

   501 			else // Replace operation was successful

   502 				{

   503 				delete childToReplace;

   504 				}

   505 			}

   506 		else  // Unrecognised argument

   507 			{

   508 			iWriter->WriteTest(KUnrecognisedArgument);

   509 			}

   510 		}

   511 	else if (iCurrentCommand->Compare(KDeleteChild) == 0)

   512 		{

   513 		// Remove a child element, defined by a numeric position, in the current element’s

   514 		// list of children. Then delete it.

   515 		// Command: deletechild n

   516 		// Use n = -1 for invalid pointer specifying child to remove.

   517 		// Use n = 0 for NULL, in place of pointer to child to remove.

   518 		// Use n = 1 for start of list

   519 		// Then n = 2 for second child etc.

   520 

   521 		// Convert the argument to an integer

   522 		TLex lex = (*iArgumentList)[0];

   523 		TInt position;

   524 		lex.Val(position);

   525 

   526 		CMDXMLNode* childToRemove = NULL;

   527 

   528 		if (position == -1)

   529 			{

   530 			childToRemove = iCurrentElement; // Invalid pointer - not a child

   531 			}

   532 		else if (position == 0)

   533 			{

   534 			childToRemove = NULL; // Invalid

   535 			}

   536 		else if (position > 0)

   537 			{

   538 			childToRemove = iCurrentElement->FirstChild();

   539 

   540 			while (position-- > 1  &&  childToRemove != NULL)

   541 				{

   542 				childToRemove = childToRemove->NextSibling();

   543 				}

   544 

   545 			if (childToRemove == NULL)

   546 				{

   547 				iWriter->WriteTest(KReachedEnd_NoChildRemoved);

   548 				}

   549 			}

   550 

   551 		TInt err = iCurrentElement->RemoveChild(childToRemove);

   552 		if (err != KErrNone)

   553 			{

   554 			if (err == KErrNotSupported)

   555 				{

   556 				iWriter->WriteTest(KNotSupported);

   557 				}

   558 			else if (err == KErrXMLInvalidChild)

   559 				{

   560 				iWriter->WriteTest(KInvalidChild);

   561 				}

   562 			else if (err == KErrNotFound)

   563 				{

   564 				iWriter->WriteTest(KCannotFindSpecifiedChild);

   565 				}

   566 			}

   567 		else // Remove operation was successful

   568 			{

   569 			delete childToRemove;

   570 			}

   571 		}

   572 	else if (iCurrentCommand->Compare(KParent) == 0)

   573 		{

   574 		// Navigate up the object tree to the current element’s parent.

   575 		// Command: parent

   576 

   577 		CMDXMLNode* parentNode = iCurrentElement->ParentNode();

   578 

   579 		if (parentNode == NULL || parentNode->NodeName() == KXMLDocumentElementNodeName)

   580 			{

   581 			iWriter->WriteTest(KAlreadyAtEndOfList);

   582 			}

   583 		else

   584 			{

   585 			iCurrentElement = (CMDXMLElement*)parentNode;

   586 			}

   587 		}

   588 	else if (iCurrentCommand->Compare(KRootSmil) == 0)

   589 		{

   590 		// Navigate to the element at the root of the DOM tree (smil).

   591 		// Command: rootsmil

   592 

   593 		iCurrentElement = (CMDXMLElement*)iDOMtreeRoot->DocumentElement()->FirstChild();

   594 		}

   595 	else if (iCurrentCommand->Compare(KFirstChild) == 0)

   596 		{

   597 		// Navigate to the first child of the current element.

   598 		// Command: firstchild

   599 

   600 		CMDXMLNode* firstChild = iCurrentElement->FirstChild();

   601 

   602 		if (firstChild == NULL)

   603 			{

   604 			iWriter->WriteTest(KCannotFindSpecifiedChild);

   605 			}

   606 		else

   607 			{

   608 			iCurrentElement = (CMDXMLElement*)firstChild;

   609 			}

   610 		}

   611 	else if (iCurrentCommand->Compare(KLastChild) == 0)

   612 		{

   613 		// Navigate to the last child of the current element.

   614 		// Command: lastchild

   615 

   616 		CMDXMLNode* lastChild = iCurrentElement->LastChild();

   617 

   618 		if (lastChild == NULL)

   619 			{

   620 			iWriter->WriteTest(KCannotFindSpecifiedChild);

   621 			}

   622 		else

   623 			{

   624 			iCurrentElement = (CMDXMLElement*)lastChild;

   625 			}

   626 		}

   627 	else if (iCurrentCommand->Compare(KNextSibling) == 0)

   628 		{

   629 		// Navigate to the next sibling of the current element.

   630 		// Command: nextsibling

   631 

   632 		CMDXMLNode* nextSibling = iCurrentElement->NextSibling();

   633 

   634 		if (nextSibling == NULL)

   635 			{

   636 			iWriter->WriteTest(KAlreadyAtEndOfList);

   637 			}

   638 		else

   639 			{

   640 			iCurrentElement = (CMDXMLElement*)nextSibling;

   641 			}

   642 		}

   643 	else if (iCurrentCommand->Compare(KPrevSibling) == 0)

   644 		{

   645 		// Navigate to the previous sibling of the current element.

   646 		// Command: prevsibling

   647 

   648 		CMDXMLNode* prevSibling = iCurrentElement->PreviousSibling();

   649 

   650 		if (prevSibling == NULL)

   651 			{

   652 			iWriter->WriteTest(KAlreadyAtEndOfList);

   653 			}

   654 		else

   655 			{

   656 			iCurrentElement = (CMDXMLElement*)prevSibling;

   657 			}

   658 		}

   659 	else if (iCurrentCommand->Compare(KFirst) == 0)

   660 		{

   661 		// Navigate to the first child, of specified element type, belonging to the current

   662 		// element.

   663 		// Command: first <element type>

   664 

   665 		// If current element is a BasicElt, cast the pointer, so that we can call BasicElt

   666 		// members.

   667 		if (iCurrentElement->NodeType() == CMDXMLNode::EElementNode

   668 		&&  iCurrentElement->NodeName() != KXMLSMILEltmeta)

   669 			{

   670 			CMDXMLSMILBasicElt* basicElt = (CMDXMLSMILBasicElt*)iCurrentElement;

   671 

   672 			if ((*iArgumentList)[0].Compare(KAnimation) == 0)

   673 				{

   674 				CMDXMLElement* firstChild = basicElt->FirstanimationChild();

   675 

   676 				if (firstChild == NULL)

   677 					{

   678 					iWriter->WriteTest(KCannotFindSpecifiedChild);

   679 					}

   680 				else

   681 					{

   682 					iCurrentElement = firstChild;

   683 					}

   684 				}

   685 			else if ((*iArgumentList)[0].Compare(KAudio) == 0)

   686 				{

   687 				CMDXMLElement* firstChild = basicElt->FirstaudioChild();

   688 

   689 				if (firstChild == NULL)

   690 					{

   691 					iWriter->WriteTest(KCannotFindSpecifiedChild);

   692 					}

   693 				else

   694 					{

   695 					iCurrentElement = firstChild;

   696 					}

   697 				}

   698 			else if ((*iArgumentList)[0].Compare(KImg) == 0)

   699 				{

   700 				CMDXMLElement* firstChild = basicElt->FirstimgChild();

   701 

   702 				if (firstChild == NULL)

   703 					{

   704 					iWriter->WriteTest(KCannotFindSpecifiedChild);

   705 					}

   706 				else

   707 					{

   708 					iCurrentElement = firstChild;

   709 					}

   710 				}

   711 			else if ((*iArgumentList)[0].Compare(KPar) == 0)

   712 				{

   713 				CMDXMLElement* firstChild = basicElt->FirstparChild();

   714 

   715 				if (firstChild == NULL)

   716 					{

   717 					iWriter->WriteTest(KCannotFindSpecifiedChild);

   718 					}

   719 				else

   720 					{

   721 					iCurrentElement = firstChild;

   722 					}

   723 				}

   724 			else if ((*iArgumentList)[0].Compare(KRef) == 0)

   725 				{

   726 				CMDXMLElement* firstChild = basicElt->FirstrefChild();

   727 

   728 				if (firstChild == NULL)

   729 					{

   730 					iWriter->WriteTest(KCannotFindSpecifiedChild);

   731 					}

   732 				else

   733 					{

   734 					iCurrentElement = firstChild;

   735 					}

   736 				}

   737 			else if ((*iArgumentList)[0].Compare(KRegion) == 0)

   738 				{

   739 				CMDXMLElement* firstChild = basicElt->FirstregionChild();

   740 

   741 				if (firstChild == NULL)

   742 					{

   743 					iWriter->WriteTest(KCannotFindSpecifiedChild);

   744 					}

   745 				else

   746 					{

   747 					iCurrentElement = firstChild;

   748 					}

   749 				}

   750 			else if ((*iArgumentList)[0].Compare(KSeq) == 0)

   751 				{

   752 				CMDXMLElement* firstChild = basicElt->FirstseqChild();

   753 

   754 				if (firstChild == NULL)

   755 					{

   756 					iWriter->WriteTest(KCannotFindSpecifiedChild);

   757 					}

   758 				else

   759 					{

   760 					iCurrentElement = firstChild;

   761 					}

   762 				}

   763 			else if ((*iArgumentList)[0].Compare(KText) == 0)

   764 				{

   765 				CMDXMLElement* firstChild = basicElt->FirsttextChild();

   766 

   767 				if (firstChild == NULL)

   768 					{

   769 					iWriter->WriteTest(KCannotFindSpecifiedChild);

   770 					}

   771 				else

   772 					{

   773 					iCurrentElement = firstChild;

   774 					}

   775 				}

   776 			else if ((*iArgumentList)[0].Compare(KTextstream) == 0)

   777 				{

   778 				CMDXMLElement* firstChild = basicElt->FirsttextstreamChild();

   779 

   780 				if (firstChild == NULL)

   781 					{

   782 					iWriter->WriteTest(KCannotFindSpecifiedChild);

   783 					}

   784 				else

   785 					{

   786 					iCurrentElement = firstChild;

   787 					}

   788 				}

   789 			else if ((*iArgumentList)[0].Compare(KVideo) == 0)

   790 				{

   791 				CMDXMLElement* firstChild = basicElt->FirstvideoChild();

   792 

   793 				if (firstChild == NULL)

   794 					{

   795 					iWriter->WriteTest(KCannotFindSpecifiedChild);

   796 					}

   797 				else

   798 					{

   799 					iCurrentElement = firstChild;

   800 					}

   801 				}

   802 			else  // Invalid element type

   803 				{

   804 				iWriter->WriteTest(KInvalidArgument);

   805 				}

   806 			}

   807 		else // Error: Current element is not a BasicElt

   808 			{

   809 			iWriter->WriteTest(KNotABasicElt);

   810 			}

   811 		}

   812 	else if (iCurrentCommand->Compare(KLast) == 0)

   813 		{

   814 		// Navigate to the last child, of specified element type, belonging to the current

   815 		// element.

   816 		// Command: last <element type>

   817 

   818 		// If current element is a BasicElt, cast the pointer, so that we can call BasicElt

   819 		// members.

   820 		if (iCurrentElement->NodeType() == CMDXMLNode::EElementNode

   821 		&&  iCurrentElement->NodeName() != KXMLSMILEltmeta)

   822 			{

   823 			CMDXMLSMILBasicElt* basicElt = (CMDXMLSMILBasicElt*)iCurrentElement;

   824 

   825 			if ((*iArgumentList)[0].Compare(KAnimation) == 0)

   826 				{

   827 				CMDXMLElement* lastChild = basicElt->LastanimationChild();

   828 

   829 				if (lastChild == NULL)

   830 					{

   831 					iWriter->WriteTest(KCannotFindSpecifiedChild);

   832 					}

   833 				else

   834 					{

   835 					iCurrentElement = lastChild;

   836 					}

   837 				}

   838 			else if ((*iArgumentList)[0].Compare(KAudio) == 0)

   839 				{

   840 				CMDXMLElement* lastChild = basicElt->LastaudioChild();

   841 

   842 				if (lastChild == NULL)

   843 					{

   844 					iWriter->WriteTest(KCannotFindSpecifiedChild);

   845 					}

   846 				else

   847 					{

   848 					iCurrentElement = lastChild;

   849 					}

   850 				}

   851 			else if ((*iArgumentList)[0].Compare(KImg) == 0)

   852 				{

   853 				CMDXMLElement* lastChild = basicElt->LastimgChild();

   854 

   855 				if (lastChild == NULL)

   856 					{

   857 					iWriter->WriteTest(KCannotFindSpecifiedChild);

   858 					}

   859 				else

   860 					{

   861 					iCurrentElement = lastChild;

   862 					}

   863 				}

   864 			else if ((*iArgumentList)[0].Compare(KPar) == 0)

   865 				{

   866 				CMDXMLElement* lastChild = basicElt->LastparChild();

   867 

   868 				if (lastChild == NULL)

   869 					{

   870 					iWriter->WriteTest(KCannotFindSpecifiedChild);

   871 					}

   872 				else

   873 					{

   874 					iCurrentElement = lastChild;

   875 					}

   876 				}

   877 			else if ((*iArgumentList)[0].Compare(KRef) == 0)

   878 				{

   879 				CMDXMLElement* lastChild = basicElt->LastrefChild();

   880 

   881 				if (lastChild == NULL)

   882 					{

   883 					iWriter->WriteTest(KCannotFindSpecifiedChild);

   884 					}

   885 				else

   886 					{

   887 					iCurrentElement = lastChild;

   888 					}

   889 				}

   890 			else if ((*iArgumentList)[0].Compare(KRegion) == 0)

   891 				{

   892 				CMDXMLElement* lastChild = basicElt->LastregionChild();

   893 

   894 				if (lastChild == NULL)

   895 					{

   896 					iWriter->WriteTest(KCannotFindSpecifiedChild);

   897 					}

   898 				else

   899 					{

   900 					iCurrentElement = lastChild;

   901 					}

   902 				}

   903 			else if ((*iArgumentList)[0].Compare(KSeq) == 0)

   904 				{

   905 				CMDXMLElement* lastChild = basicElt->LastseqChild();

   906 

   907 				if (lastChild == NULL)

   908 					{

   909 					iWriter->WriteTest(KCannotFindSpecifiedChild);

   910 					}

   911 				else

   912 					{

   913 					iCurrentElement = lastChild;

   914 					}

   915 				}

   916 			else if ((*iArgumentList)[0].Compare(KText) == 0)

   917 				{

   918 				CMDXMLElement* lastChild = basicElt->LasttextChild();

   919 

   920 				if (lastChild == NULL)

   921 					{

   922 					iWriter->WriteTest(KCannotFindSpecifiedChild);

   923 					}

   924 				else

   925 					{

   926 					iCurrentElement = lastChild;

   927 					}

   928 				}

   929 			else if ((*iArgumentList)[0].Compare(KTextstream) == 0)

   930 				{

   931 				CMDXMLElement* lastChild = basicElt->LasttextstreamChild();

   932 

   933 				if (lastChild == NULL)

   934 					{

   935 					iWriter->WriteTest(KCannotFindSpecifiedChild);

   936 					}

   937 				else

   938 					{

   939 					iCurrentElement = lastChild;

   940 					}

   941 				}

   942 			else if ((*iArgumentList)[0].Compare(KVideo) == 0)

   943 				{

   944 				CMDXMLElement* lastChild = basicElt->LastvideoChild();

   945 

   946 				if (lastChild == NULL)

   947 					{

   948 					iWriter->WriteTest(KCannotFindSpecifiedChild);

   949 					}

   950 				else

   951 					{

   952 					iCurrentElement = lastChild;

   953 					}

   954 				}

   955 			else  // Invalid element type

   956 				{

   957 				iWriter->WriteTest(KInvalidArgument);

   958 				}

   959 			}

   960 		else // Error: Current element is not a BasicElt

   961 			{

   962 			iWriter->WriteTest(KNotABasicElt);

   963 			}

   964 		}

   965 	else if (iCurrentCommand->Compare(KNext) == 0)

   966 		{

   967 		// Navigate to the next sibling, of specified element type, from a current

   968 		// element of the same type.

   969 		// Command: next <element type>

   970 

   971 		if ((*iArgumentList)[0].Compare(KAnimation) == 0)

   972 			{

   973 			// If current element is of the specified type...

   974 			if (iCurrentElement->NodeType() == CMDXMLNode::EElementNode

   975 			&&  iCurrentElement->NodeName() == KXMLSMILEltanimation)

   976 				{

   977 				// ...cast the pointer, so that we can call the members of that type.

   978 				CMDXMLSMILanimation* eltOfSpecificType = (CMDXMLSMILanimation*)iCurrentElement;

   979 

   980 				CMDXMLElement* nextSibling = eltOfSpecificType->NextanimationSibling();

   981 

   982 				if (nextSibling == NULL)

   983 					{

   984 					iWriter->WriteTest(KAlreadyAtEndOfList);

   985 					}

   986 				else

   987 					{

   988 					iCurrentElement = nextSibling;

   989 					}

   990 				}

   991 			else // Error: Current element is not of the specified type

   992 				{

   993 				iWriter->WriteTest(KNotOfSpecifiedType);

   994 				}

   995 			}

   996 		else if ((*iArgumentList)[0].Compare(KAudio) == 0)

   997 			{

   998 			// If current element is of the specified type...

   999 			if (iCurrentElement->NodeType() == CMDXMLNode::EElementNode

  1000 			&&  iCurrentElement->NodeName() == KXMLSMILEltaudio)

  1001 				{

  1002 				// ...cast the pointer, so that we can call the members of that type.

  1003 				CMDXMLSMILaudio* eltOfSpecificType = (CMDXMLSMILaudio*)iCurrentElement;

  1004 

  1005 				CMDXMLElement* nextSibling = eltOfSpecificType->NextaudioSibling();

  1006 

  1007 				if (nextSibling == NULL)

  1008 					{

  1009 					iWriter->WriteTest(KAlreadyAtEndOfList);

  1010 					}

  1011 				else

  1012 					{

  1013 					iCurrentElement = nextSibling;

  1014 					}

  1015 				}

  1016 			else // Error: Current element is not of the specified type

  1017 				{

  1018 				iWriter->WriteTest(KNotOfSpecifiedType);

  1019 				}

  1020 			}

  1021 		else if ((*iArgumentList)[0].Compare(KImg) == 0)

  1022 			{

  1023 			// If current element is of the specified type...

  1024 			if (iCurrentElement->NodeType() == CMDXMLNode::EElementNode

  1025 			&&  iCurrentElement->NodeName() == KXMLSMILEltimg)

  1026 				{

  1027 				// ...cast the pointer, so that we can call the members of that type.

  1028 				CMDXMLSMILimg* eltOfSpecificType = (CMDXMLSMILimg*)iCurrentElement;

  1029 

  1030 				CMDXMLElement* nextSibling = eltOfSpecificType->NextimgSibling();

  1031 

  1032 				if (nextSibling == NULL)

  1033 					{

  1034 					iWriter->WriteTest(KAlreadyAtEndOfList);

  1035 					}

  1036 				else

  1037 					{

  1038 					iCurrentElement = nextSibling;

  1039 					}

  1040 				}

  1041 			else // Error: Current element is not of the specified type

  1042 				{

  1043 				iWriter->WriteTest(KNotOfSpecifiedType);

  1044 				}

  1045 			}

  1046 		else if ((*iArgumentList)[0].Compare(KPar) == 0)

  1047 			{

  1048 			// If current element is of the specified type...

  1049 			if (iCurrentElement->NodeType() == CMDXMLNode::EElementNode

  1050 			&&  iCurrentElement->NodeName() == KXMLSMILEltpar)

  1051 				{

  1052 				// ...cast the pointer, so that we can call the members of that type.

  1053 				CMDXMLSMILpar* eltOfSpecificType = (CMDXMLSMILpar*)iCurrentElement;

  1054 

  1055 				CMDXMLElement* nextSibling = eltOfSpecificType->NextparSibling();

  1056 

  1057 				if (nextSibling == NULL)

  1058 					{

  1059 					iWriter->WriteTest(KAlreadyAtEndOfList);

  1060 					}

  1061 				else

  1062 					{

  1063 					iCurrentElement = nextSibling;

  1064 					}

  1065 				}

  1066 			else // Error: Current element is not of the specified type

  1067 				{

  1068 				iWriter->WriteTest(KNotOfSpecifiedType);

  1069 				}

  1070 			}

  1071 		else if ((*iArgumentList)[0].Compare(KRef) == 0)

  1072 			{

  1073 			// If current element is of the specified type...

  1074 			if (iCurrentElement->NodeType() == CMDXMLNode::EElementNode

  1075 			&&  iCurrentElement->NodeName() == KXMLSMILEltref)

  1076 				{

  1077 				// ...cast the pointer, so that we can call the members of that type.

  1078 				CMDXMLSMILref* eltOfSpecificType = (CMDXMLSMILref*)iCurrentElement;

  1079 

  1080 				CMDXMLElement* nextSibling = eltOfSpecificType->NextrefSibling();

  1081 

  1082 				if (nextSibling == NULL)

  1083 					{

  1084 					iWriter->WriteTest(KAlreadyAtEndOfList);

  1085 					}

  1086 				else

  1087 					{

  1088 					iCurrentElement = nextSibling;

  1089 					}

  1090 				}

  1091 			else // Error: Current element is not of the specified type

  1092 				{

  1093 				iWriter->WriteTest(KNotOfSpecifiedType);

  1094 				}

  1095 			}

  1096 		else if ((*iArgumentList)[0].Compare(KRegion) == 0)

  1097 			{

  1098 			// If current element is of the specified type...

  1099 			if (iCurrentElement->NodeType() == CMDXMLNode::EElementNode

  1100 			&&  iCurrentElement->NodeName() == KXMLSMILEltregion)

  1101 				{

  1102 				// ...cast the pointer, so that we can call the members of that type.

  1103 				CMDXMLSMILregion* eltOfSpecificType = (CMDXMLSMILregion*)iCurrentElement;

  1104 

  1105 				CMDXMLElement* nextSibling = eltOfSpecificType->NextregionSibling();

  1106 

  1107 				if (nextSibling == NULL)

  1108 					{

  1109 					iWriter->WriteTest(KAlreadyAtEndOfList);

  1110 					}

  1111 				else

  1112 					{

  1113 					iCurrentElement = nextSibling;

  1114 					}

  1115 				}

  1116 			else // Error: Current element is not of the specified type

  1117 				{

  1118 				iWriter->WriteTest(KNotOfSpecifiedType);

  1119 				}

  1120 			}

  1121 		else if ((*iArgumentList)[0].Compare(KSeq) == 0)

  1122 			{

  1123 			// If current element is of the specified type...

  1124 			if (iCurrentElement->NodeType() == CMDXMLNode::EElementNode

  1125 			&&  iCurrentElement->NodeName() == KXMLSMILEltseq)

  1126 				{

  1127 				// ...cast the pointer, so that we can call the members of that type.

  1128 				CMDXMLSMILseq* eltOfSpecificType = (CMDXMLSMILseq*)iCurrentElement;

  1129 

  1130 				CMDXMLElement* nextSibling = eltOfSpecificType->NextseqSibling();

  1131 

  1132 				if (nextSibling == NULL)

  1133 					{

  1134 					iWriter->WriteTest(KAlreadyAtEndOfList);

  1135 					}