CMMLParser.cpp

Go to the documentation of this file.
00001 //===========================================================================
00002 //Copyright (C) 2004 Zentaro Kavanagh
00003 //
00004 //Copyright (C) 2004 Commonwealth Scientific and Industrial Research
00005 //   Organisation (CSIRO) Australia
00006 //
00007 //Redistribution and use in source and binary forms, with or without
00008 //modification, are permitted provided that the following conditions
00009 //are met:
00010 //
00011 //- Redistributions of source code must retain the above copyright
00012 //  notice, this list of conditions and the following disclaimer.
00013 //
00014 //- Redistributions in binary form must reproduce the above copyright
00015 //  notice, this list of conditions and the following disclaimer in the
00016 //  documentation and/or other materials provided with the distribution.
00017 //
00018 //- Neither the name of Zentaro Kavanagh nor the names of contributors 
00019 //  may be used to endorse or promote products derived from this software 
00020 //  without specific prior written permission.
00021 //
00022 //THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
00023 //``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
00024 //LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
00025 //PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE ORGANISATION OR
00026 //CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
00027 //EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
00028 //PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
00029 //PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
00030 //LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
00031 //NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
00032 //SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00033 //===========================================================================
00034 #include "stdafx.h"
00035 #include <libWinCMMLParse/CMMLParser.h>
00036 
00037 CMMLParser::CMMLParser(void)
00038 {
00039         HRESULT hr;
00040         hr = CoInitialize(NULL); 
00041 }
00042 
00043 CMMLParser::~CMMLParser(void)
00044 {
00045 }
00046 
00047 
00048 
00052 bool CMMLParser::setupXMLHandles(wstring inText, MSXML2::IXMLDOMDocument** outDoc)
00053 {
00054 
00055         HRESULT locHR = S_FALSE;
00056         // Check the return value, hr...
00057         locHR = CoCreateInstance(__uuidof(DOMDocument30), NULL, CLSCTX_INPROC_SERVER, IID_IXMLDOMDocument, (void**)outDoc);
00058         if (locHR != S_OK) {
00059                 return false;
00060         }
00061         
00062         BSTR locClipStr = SysAllocString(inText.c_str());
00063         VARIANT_BOOL locBool;
00064         locHR = (*outDoc)->loadXML(locClipStr, &locBool);
00065 
00066 
00067         SysFreeString(locClipStr);
00068 
00069         if (locHR == S_OK) {
00070                 return true;
00071         } else {
00072                 return false;
00073         }
00074 }
00075 
00076 bool CMMLParser::parseDocFromFile(wstring inFilename, C_CMMLDoc* outCMMLDoc) {
00077 
00078         MSXML2::IXMLDOMDocument* locDoc         =       NULL;
00079         MSXML2::IXMLDOMNode*            locNode =       NULL;
00080         BSTR locQuery   = SysAllocString(L"cmml");;
00081         VARIANT locFilename;
00082 
00083         VariantInit(&locFilename);
00084         V_BSTR(&locFilename) = SysAllocString(inFilename.c_str());
00085         V_VT(&locFilename) = VT_BSTR;
00086         //locFilename.vt = VT_BSTR;
00087         //locFilename.bstrVal = SysAllocString(inFilename.c_str());
00088 
00089 
00090         bool retVal = true;
00091         HRESULT locHR = S_FALSE;
00092 
00093         
00094         locHR = CoCreateInstance(__uuidof(DOMDocument30), NULL, CLSCTX_INPROC_SERVER, IID_IXMLDOMDocument, (void**)&locDoc);
00095         if (locHR != S_OK) {
00096                 retVal = false;
00097         } else {
00098         
00099                 
00100                 VARIANT_BOOL locBool = VARIANT_FALSE;
00101                 locDoc->put_validateOnParse(locBool);
00102                 
00103                 locHR = locDoc->load(locFilename, &locBool);
00104                 MSXML2::IXMLDOMParseError *locParseError = NULL;
00105                 locHR = locDoc->get_parseError(&locParseError);
00106                 long locEC = 0;
00107                 locParseError->get_errorCode(&locEC);
00108                 BSTR locStr;
00109                 locParseError->get_reason(&locStr);
00110 
00111                 
00112 
00113                 //--------------Child Nodes-----------------
00114                 locHR = locDoc->selectSingleNode(locQuery, &locNode);
00115                 if (locHR != S_OK) {
00116                         retVal = false;
00117                 } else {
00118 
00119                         C_CMMLRootTag* locRootTag = new C_CMMLRootTag;
00120 
00121                         retVal = parseCMMLRootTag(locNode, locRootTag);
00122                         if (retVal) {
00123                                 outCMMLDoc->setRoot(locRootTag);        
00124                         } else {
00125                                 delete locRootTag;
00126                         }
00127                 }
00128         }
00129 
00130         //SysFreeString(locFilename.bstrVal);
00131         SysFreeString(locQuery);
00132         if (&locFilename) VariantClear(&locFilename);
00133         if (locDoc != NULL)                     locDoc->Release();
00134         if (locNode != NULL)            locNode->Release();
00135 
00136         return retVal;
00137 }
00138 
00139 
00140 
00141 MSXML2::IXMLDOMNode* CMMLParser::getNamedNode(wstring inXPath, MSXML2::IXMLDOMDocument* inDoc) {
00142         BSTR locQuery = SysAllocString(inXPath.c_str());
00143         HRESULT locHR = S_FALSE;
00144         MSXML2::IXMLDOMNode* retNode = NULL;
00145         
00146         locHR = inDoc->selectSingleNode(locQuery, &retNode);
00147         
00148     SysFreeString(locQuery);
00149 
00150         //If the select fails... will return NULL
00151         return retNode;
00152 }
00153 
00154 wstring CMMLParser::getNamedAttribValue(wstring inAttribName, MSXML2::IXMLDOMNamedNodeMap* inAttribMap) {
00155         BSTR                                    locAttribName   = SysAllocString(inAttribName.c_str());
00156         BSTR                                    locBStr                 = NULL;
00157         MSXML2::IXMLDOMNode*    locAttribNode   = NULL;
00158         HRESULT                                 locHR                   = S_FALSE;
00159         wstring                                 retStr                  = L"";
00160         
00161         locHR = inAttribMap->getNamedItem(locAttribName, &locAttribNode);
00162 
00163         if (locHR == S_OK) {
00164                 locHR =  locAttribNode->get_text(&locBStr);
00165                 retStr = locBStr;
00166         }
00167         
00168         //Cleanup
00169         if (locAttribNode != NULL) locAttribNode->Release();
00170         SysFreeString(locBStr);
00171         SysFreeString(locAttribName);
00172 
00173         //Will return "" on error
00174         return retStr;
00175 }
00176 
00177 bool CMMLParser::parseClipTag(MSXML2::IXMLDOMNode* inClipNode, C_ClipTag* outClip) {
00178 
00179         //Required start is not checked for, because CMML in annodex doesn't have one. May need to be
00180         // cvalidated elsewhere to be used in CMML documents
00181         MSXML2::IXMLDOMNamedNodeMap*    locAttribMap            = NULL;
00182         MSXML2::IXMLDOMNode*                    locNode                         = NULL;
00183         MSXML2::IXMLDOMNodeList*                locChildNodes           = NULL;
00184         BSTR                                                    locBStr                         = NULL;
00185         HRESULT                                                 locHR                           = S_FALSE;
00186         
00187         wstring                                                 locNodeName;
00188         long                                                    locNumNodes                     = 0;
00189         
00190         unsigned long                                   locNum_a                        = 0;
00191         unsigned long                                   locNum_desc                     = 0;
00192         unsigned long                                   locNum_img                      = 0;
00193         unsigned long                                   locNum_meta                     = 0;
00194         unsigned long                                   locNumUnknown           = 0;
00195 
00196         //---------------Attributes-----------------
00197         //Get the attributes
00198         locHR = inClipNode->get_attributes(&locAttribMap);
00199         
00200         outClip->setId(getNamedAttribValue(L"id", locAttribMap));
00201         outClip->setLang(getNamedAttribValue(L"lang", locAttribMap));
00202         outClip->setDirn(getNamedAttribValue(L"dir", locAttribMap));
00203         outClip->setTrack(getNamedAttribValue(L"track", locAttribMap));
00204         outClip->setStart(getNamedAttribValue(L"start", locAttribMap));
00205         outClip->setEnd(getNamedAttribValue(L"end", locAttribMap));
00206         //------------------------------------------
00207         //--------------Child Nodes-----------------
00208         locHR = inClipNode->get_childNodes(&locChildNodes);
00209         locHR = locChildNodes->get_length(&locNumNodes);
00210         
00211         for (int i = 0; i < locNumNodes; i++) {
00212                 
00213                 locHR = locChildNodes->get_item(i, &locNode);
00214                 locHR = locNode->get_nodeName(&locBStr);
00215                 locNodeName = locBStr;
00216                 
00217                 if (locNodeName == L"a") {
00218                         
00219                         //ZERO OR ONE a elements allowed
00220                         C_AnchorTag* locAnchor = new C_AnchorTag;
00221 
00222                         if (parseAnchorTag(locNode, locAnchor)) {
00223                                 outClip->setAnchor(locAnchor);
00224                                 locNum_a++;
00225                         } else {
00226                                 delete locAnchor;
00227                                 outClip->setAnchor(NULL);
00228                         }
00229 
00230                 } else if(locNodeName == L"desc") {
00231                         
00232                         //ZERO OR ONE desc elements allowed
00233                         C_DescTag* locDesc = new C_DescTag;
00234                         if (parseDescTag(locNode, locDesc)) {
00235                                 outClip->setDesc(locDesc);
00236                                 locNum_desc++;
00237                         } else {
00238                                 delete locDesc;
00239                                 outClip->setDesc(NULL);
00240                         }
00241                         
00242                 } else if (locNodeName == L"img") {
00243                         
00244                         //ZERO OR ONE img elements allowed
00245                         C_ImageTag* locImage = new C_ImageTag;
00246                         if (parseImageTag(locNode, locImage)) {
00247                                 outClip->setImage(locImage);
00248                                 locNum_img++;
00249                         } else {
00250                                 delete locImage;
00251                                 outClip->setImage(locImage);
00252                         }
00253 
00254                 } else if (locNodeName == L"meta") {
00255                         
00256                         //ZERO OR *MORE* meta  elements allowed
00257                         C_MetaTag* locMeta = new C_MetaTag;
00258                         if (parseMetaTag(locNode, locMeta)) {
00259                                 outClip->metaList()->addTag(locMeta);
00260                                 locNum_meta++;
00261                         } else {
00262                                 delete locMeta;
00263                         }
00264 
00265                 } else {
00266                         
00267                         //TODO::: How to handle ??? For now just ignore tags we don't know.
00268                         locNumUnknown++;
00269                 }
00270         }
00271 
00272         bool retVal     =               (locNum_a <= 1)
00273                                         &&      (locNum_img <= 1)
00274                                         &&      (locNum_desc <= 1);
00275 
00276         SysFreeString(locBStr);
00277         if (locAttribMap != NULL)                                       locAttribMap->Release();
00278         if (locNode != NULL)                                            locNode->Release();
00279         if (locChildNodes != NULL)                                      locChildNodes->Release();
00280         return retVal;
00281 }
00282 
00283 bool CMMLParser::parseClipTag(wstring inClipText, C_ClipTag* outClip) {
00284         MSXML2::IXMLDOMDocument*        locXMLClipFrag  = NULL;
00285         MSXML2::IXMLDOMNode*            locClipNode             = NULL;
00286                 
00287         bool retVal = setupXMLHandles(inClipText, &locXMLClipFrag);
00288 
00289         if (retVal) {
00290                 locClipNode = getNamedNode(L"clip", locXMLClipFrag);
00291                 
00292                 if (locClipNode != NULL) {
00293                         //Now we have a node representing the clip tag and it's children.
00294                         retVal = parseClipTag(locClipNode, outClip);
00295                 } else {
00296                         retVal = false;
00297                 }
00298         }
00299 
00300         if (locXMLClipFrag != NULL)                                     locXMLClipFrag->Release();
00301         if (locClipNode != NULL)                                        locClipNode->Release();
00302 
00303         return retVal;
00304 }
00305 
00306 bool CMMLParser::parseCMMLRootTag(MSXML2::IXMLDOMNode* inCMMLRootNode, C_CMMLRootTag* outCMMLRoot) {
00307         MSXML2::IXMLDOMNamedNodeMap*    locAttribMap    = NULL;
00308         MSXML2::IXMLDOMNodeList*                locChildNodes   = NULL;
00309         MSXML2::IXMLDOMNode*                    locNode                 = NULL;
00310         HRESULT                                                 locHR                   = S_FALSE;
00311         long                                                    locNumNodes             = 0;
00312         BSTR                                                    locBStr                 = NULL;
00313         wstring                                                 locNodeName             = L"";
00314 
00315 
00316         unsigned long                                   locNum_clip             = 0;
00317         unsigned long                                   locNum_head             = 0;
00318         unsigned long                                   locNum_stream   = 0;
00319         unsigned long                                   locNumUnknown   = 0;
00320 
00321         bool retVal = true;
00322         
00323         //---------------Attributes-----------------
00324         locHR = inCMMLRootNode->get_attributes(&locAttribMap);
00325 
00326         outCMMLRoot->setId(getNamedAttribValue(L"id", locAttribMap));
00327         outCMMLRoot->setLang(getNamedAttribValue(L"lang", locAttribMap));
00328         outCMMLRoot->setDirn(getNamedAttribValue(L"dir", locAttribMap));
00329         
00330         //------------------------------------------
00331         //--------------Child Nodes-----------------
00332         locHR = inCMMLRootNode->get_childNodes(&locChildNodes);
00333         locHR = locChildNodes->get_length(&locNumNodes);
00334 
00335         for (int i = 0; i < locNumNodes; i++) {
00336                 locHR = locChildNodes->get_item(i, &locNode);
00337                 locHR = locNode->get_nodeName(&locBStr);
00338                 //TODO::: Needs checks ??
00339 
00340                 locNodeName = locBStr;
00341                 if (locNodeName == L"stream") {
00342                         //If it exists it must be first
00343                         if (            (locNum_stream == 0)
00344                                         &&      (locNum_clip == 0)
00345                                         &&      (locNum_head == 0)) {
00346                                 //OPTIONALLY ONE stream tag
00347                                 C_StreamTag* locStream = new C_StreamTag;
00348                         
00349                                 if (parseStreamTag(locNode, locStream)) {
00350                                         outCMMLRoot->setStream(locStream);
00351                                         locNum_stream++;
00352                                 } else {
00353                                         delete locStream;
00354                                         outCMMLRoot->setStream(NULL);
00355                                 }
00356                         } else {
00357                                 retVal = false;
00358                         }
00359 
00360 
00361                 } else if (locNodeName == L"head") {
00362                         
00363                         //MUST HAVE ONE head tag
00364                         if (            (locNum_stream <= 1)
00365                                         &&      (locNum_clip == 0)
00366                                         &&      (locNum_head == 0)) {
00367                         
00368                                 C_HeadTag* locHead = new C_HeadTag;
00369                         
00370                                 if (parseHeadTag(locNode, locHead)) {
00371                                         outCMMLRoot->setHead(locHead);
00372                                         locNum_head++;
00373                                 } else {
00374                                         delete locHead; 
00375                                         retVal = false;
00376                                 }
00377                         } else {
00378                                 retVal = false;
00379 
00380                         }
00381                 } else if (locNodeName == L"clip") {
00382 
00383                         //ZERO OR MORE clip tags
00384                         if (            (locNum_stream <= 1)
00385                                         &&      (locNum_head == 1)) {
00386 
00387                                 C_ClipTag* locClip = new C_ClipTag;
00388                         
00389                                 if(parseClipTag(locNode, locClip)) {
00390                                         outCMMLRoot->clipList()->addTag(locClip);
00391                                         locNum_clip++;
00392                                 } else {
00393                                         delete locClip;
00394                                 }
00395                         } else { 
00396                                 retVal = false;
00397                         }
00398                         
00399                 } else {
00400                         locNumUnknown++;
00401                 }
00402         }
00403 
00404         retVal          =               (retVal)
00405                                                 &&      (locNum_stream <= 1)
00406                                                 &&      (locNum_head == 1);
00407                                                 
00408 
00409 
00410         SysFreeString(locBStr);
00411         if (locAttribMap != NULL)                                       locAttribMap->Release();
00412         if (locNode != NULL)                                            locNode->Release();
00413         if (locChildNodes != NULL)                                      locChildNodes->Release();
00414         return retVal;
00415 }
00416 
00417 
00418 bool CMMLParser::parseCMMLRootTag(wstring inCMMLRootText, C_CMMLRootTag* outCMMLRoot) {
00419         MSXML2::IXMLDOMDocument*        locXMLCMMLRootFrag      = NULL;
00420         MSXML2::IXMLDOMNode*            locCMMLRootNode                 = NULL;
00421                 
00422         bool retVal = setupXMLHandles(inCMMLRootText, &locXMLCMMLRootFrag);
00423 
00424         if (retVal) {
00425                 locCMMLRootNode = getNamedNode(L"cmml", locXMLCMMLRootFrag);
00426                 
00427                 if (locCMMLRootNode != NULL) {
00428                         
00429                         retVal = parseCMMLRootTag(locCMMLRootNode, outCMMLRoot);
00430                 } else {
00431                         retVal = false;
00432                 }
00433         }
00434 
00435         if (locXMLCMMLRootFrag != NULL)                                 locXMLCMMLRootFrag->Release();
00436         if (locCMMLRootNode != NULL)                                            locCMMLRootNode->Release();
00437 
00438         return retVal;
00439 }
00440 bool CMMLParser::parseHeadTag(MSXML2::IXMLDOMNode* inHeadNode, C_HeadTag* outHead) {
00441         MSXML2::IXMLDOMNamedNodeMap*    locAttribMap    = NULL;
00442         MSXML2::IXMLDOMNodeList*                locChildNodes   = NULL;
00443         MSXML2::IXMLDOMNode*                    locNode                 = NULL;
00444         HRESULT                                                 locHR                   = S_FALSE;
00445         long                                                    locNumNodes             = 0;
00446         BSTR                                                    locBStr                 = NULL;
00447         wstring                                                 locNodeName;
00448                                                                 
00449         unsigned long                                   locNum_title    = 0;
00450         unsigned long                                   locNum_meta             = 0;
00451         unsigned long                                   locNum_base             = 0;
00452         unsigned long                                   locNumUnknown   = 0;
00453 
00454         
00455         //---------------Attributes-----------------
00456         locHR = inHeadNode->get_attributes(&locAttribMap);
00457 
00458         outHead->setId(getNamedAttribValue(L"id", locAttribMap));
00459         outHead->setLang(getNamedAttribValue(L"lang", locAttribMap));
00460         outHead->setDirn(getNamedAttribValue(L"dir", locAttribMap));
00461         outHead->setProfile(getNamedAttribValue(L"profile", locAttribMap));
00462         //------------------------------------------
00463 
00464         //--------------Child Nodes-----------------
00465         locHR = inHeadNode->get_childNodes(&locChildNodes);
00466         locHR = locChildNodes->get_length(&locNumNodes);
00467         for (int i = 0; i < locNumNodes; i++) {
00468                 locHR = locChildNodes->get_item(i, &locNode);
00469                 locHR = locNode->get_nodeName(&locBStr);
00470                 //TODO::: Needs checks ??
00471 
00472                 locNodeName = locBStr;
00473                 if (locNodeName == L"title") {
00474                 
00475                         //Must contain ONE title tag
00476                         C_TitleTag* locTitle = new C_TitleTag;
00477                         
00478                         if (parseTitleTag(locNode, locTitle)) {
00479                                 outHead->setTitle(locTitle);
00480                                 locNum_title++;
00481                         } else {
00482                                 delete locTitle;
00483                                 outHead->setTitle(NULL);
00484                         }
00485 
00486 
00487                 } else if (locNodeName == L"meta") {
00488                         
00489                         //Can contain ANY AMOUNT of meta tags
00490                         C_MetaTag* locMeta = new C_MetaTag;
00491                         
00492                         if (parseMetaTag(locNode, locMeta)) {
00493                                 outHead->metaList()->addTag(locMeta);
00494                                 locNum_meta++;
00495                         } else {
00496                                 delete locMeta;                         
00497                         }
00498                         
00499                 } else if (locNodeName == L"base") {
00500 
00501                         //OPTIONALLY ONE base tag.
00502                         C_BaseTag* locBase = new C_BaseTag;
00503                         
00504                         if(parseBaseTag(locNode, locBase)) {
00505                 outHead->setBase(locBase);
00506                                 locNum_base++;
00507                         } else {
00508                                 delete locBase;
00509                                 outHead->setBase(NULL);
00510                         }
00511                         
00512                 } else {
00513                         locNumUnknown++;
00514                 }
00515         }
00516 
00517         bool retVal             =               (locNum_title == 1)
00518                                                 &&      (locNum_base <= 1);
00519 
00520 
00521         SysFreeString(locBStr);
00522         if (locAttribMap != NULL)                                       locAttribMap->Release();
00523         if (locNode != NULL)                                            locNode->Release();
00524         if (locChildNodes != NULL)                                      locChildNodes->Release();
00525         return retVal;
00526 }
00527 
00528 bool CMMLParser::parseHeadTag(wstring inHeadText, C_HeadTag* outHead) {
00529         MSXML2::IXMLDOMDocument* locXMLHeadFrag = NULL;
00530         MSXML2::IXMLDOMNode* locHeadNode  = NULL;
00531                 
00532         bool retVal = setupXMLHandles(inHeadText, &locXMLHeadFrag);
00533 
00534         if (retVal) {
00535                 locHeadNode = getNamedNode(L"head", locXMLHeadFrag);
00536                 if (locHeadNode != NULL) {
00537 
00538                         //Now we have a node representing the clip tag and it's children.
00539                         retVal = parseHeadTag(locHeadNode, outHead);
00540                 } else {
00541                         retVal = false;
00542                 }
00543         }
00544 
00545         if (locXMLHeadFrag != NULL)                                     locXMLHeadFrag->Release();
00546         if (locHeadNode != NULL)                                        locHeadNode->Release();
00547 
00548         return retVal;
00549 }
00550 
00551 bool CMMLParser::parseStreamTag(MSXML2::IXMLDOMNode* inStreamNode, C_StreamTag* outStream) {
00553         MSXML2::IXMLDOMNamedNodeMap*    locAttribMap    = NULL;
00554         MSXML2::IXMLDOMNode*                    locNode                 = NULL;
00555         MSXML2::IXMLDOMNodeList*                locChildNodes   = NULL;
00556         HRESULT                                                 locHR                   = S_FALSE;
00557         long                                                    locNumNodes             = 0;
00558         BSTR                                                    locBStr                 = NULL;
00559         wstring                                                 locNodeName             = L"";
00560 
00561         //---------------Attributes-----------------
00562         locHR = inStreamNode->get_attributes(&locAttribMap);
00563         //outStream->setLang(getNamedAttribValue(L"lang", locAttribMap));
00564         //outStream->setDirn(getNamedAttribValue(L"dir", locAttribMap));        
00565         outStream->setId(getNamedAttribValue(L"id", locAttribMap));
00566         outStream->setTimebase(getNamedAttribValue(L"timebase", locAttribMap));
00567         outStream->setUtc(getNamedAttribValue(L"utc", locAttribMap));
00568         //------------------------------------------
00569         //--------------Child Nodes-----------------
00570         locHR = inStreamNode->get_childNodes(&locChildNodes);
00571         locHR = locChildNodes->get_length(&locNumNodes);
00572         for (int i = 0; i < locNumNodes; i++) {
00573                 locHR = locChildNodes->get_item(i, &locNode);
00574                 locHR = locNode->get_nodeName(&locBStr);
00575                 locNodeName = locBStr;
00576                 if(locNodeName == L"import") {
00577                         
00578                         C_ImportTag* locImport = new C_ImportTag;
00579                         if (parseImportTag(locNode, locImport)) {
00580                                 outStream->importList()->addTag(locImport);
00581                         } else {
00582                                 //TODO::: Anything ???
00583                         }
00584                         
00585                 } else {
00586                         //TODO::: Handle this, otherwise ignore.
00587                 }
00588         }
00589 
00590         //--------------Clean Up--------------------
00591         SysFreeString(locBStr);
00592         if (locAttribMap != NULL)               locAttribMap->Release();
00593         if (locNode != NULL)                    locNode->Release();
00594         if (locChildNodes != NULL)              locChildNodes->Release();
00595         return true;
00596 }
00597 
00598 bool CMMLParser::parseImportTag(MSXML2::IXMLDOMNode* inImportNode, C_ImportTag* outImport) {
00599 
00600         //TODO::: Stream and import tags need checking about what to do with internationalisation
00601         MSXML2::IXMLDOMNamedNodeMap*    locAttribMap    = NULL;
00602         MSXML2::IXMLDOMNode*                    locNode                 = NULL;
00603         MSXML2::IXMLDOMNodeList*                locChildNodes   = NULL;
00604         HRESULT                                                 locHR                   = S_FALSE;
00605         long                                                    locNumNodes             = 0;
00606         BSTR                                                    locBStr                 = NULL;
00607         wstring                                                 locNodeName             = L"";
00608 
00609         bool retVal = true;
00610 
00611         //---------------Attributes-----------------
00612         locHR = inImportNode->get_attributes(&locAttribMap);
00613 
00614         outImport->setId(getNamedAttribValue(L"id", locAttribMap));
00615         outImport->setContentType(getNamedAttribValue(L"contenttype", locAttribMap));
00616         outImport->setSrc(getNamedAttribValue(L"src", locAttribMap));
00617         if (outImport->src() == L"") {
00618                 //Source is required.
00619                 retVal = false;
00620         }
00621         outImport->setStart(getNamedAttribValue(L"start", locAttribMap));
00622         outImport->setEnd(getNamedAttribValue(L"end", locAttribMap));
00623         outImport->setTitle(getNamedAttribValue(L"title", locAttribMap));
00624         outImport->setGranuleRate(getNamedAttribValue(L"granulerate", locAttribMap));
00625         //------------------------------------------
00626 
00627 
00628         locHR = inImportNode->get_childNodes(&locChildNodes);
00629         locHR = locChildNodes->get_length(&locNumNodes);
00630         for (int i = 0; i < locNumNodes; i++) {
00631                 locHR = locChildNodes->get_item(i, &locNode);
00632                 locHR = locNode->get_nodeName(&locBStr);
00633                 locNodeName = locBStr;
00634                 if(locNodeName == L"param") {
00635                         
00636                         C_ParamTag* locParam = new C_ParamTag;
00637                         if (parseParamTag(locNode, locParam)) {
00638                                 outImport->paramList()->addTag(locParam);
00639                         } else {
00640                                 //TODO::: Anything ???
00641                         }
00642                         
00643                 } else {
00644                         //TODO::: Handle this, otherwise ignore.
00645                 }
00646         }
00647 
00648         SysFreeString(locBStr);
00649         if (locAttribMap != NULL)               locAttribMap->Release();
00650         if (locNode != NULL)                    locNode->Release();
00651         if (locChildNodes != NULL)              locChildNodes->Release();
00652         return retVal;
00653 }
00654 
00655 bool CMMLParser::parseImageTag(MSXML2::IXMLDOMNode* inImageNode, C_ImageTag* outImage) {
00656         MSXML2::IXMLDOMNamedNodeMap* locAttribMap = NULL;
00657         //      MSXML2::IXMLDOMNode* locImageNode = NULL;
00658         HRESULT locHR = S_FALSE;
00659 
00660         bool retVal = true;
00661         //---------------Attributes-----------------
00662         locHR = inImageNode->get_attributes(&locAttribMap);
00663         outImage->setId(getNamedAttribValue(L"id", locAttribMap));
00664         outImage->setSrc(getNamedAttribValue(L"src", locAttribMap));
00665         if (outImage->src() == L"") {
00666                 retVal = false;
00667         }
00668         outImage->setAlt(getNamedAttribValue(L"alt", locAttribMap));
00669 
00670         if (locAttribMap != NULL)               locAttribMap->Release();
00671         return retVal;
00672 }
00673 /*
00674 bool CMMLParser::parseMetaTag(MSXML2::IXMLDOMNode* inMetaNode, C_MetaTag* outMeta) {
00675         MSXML2::IXMLDOMNamedNodeMap* locAttribMap = NULL;
00676         MSXML2::IXMLDOMNode* locMetaNode = NULL;
00677         HRESULT locHR = S_FALSE;
00678 
00679         //---------------Attributes-----------------
00680         locHR = inMetaNode->get_attributes(&locAttribMap);
00681 
00682 }
00683 */
00684 
00685 bool CMMLParser::parseMetaTag(MSXML2::IXMLDOMNode* inMetaNode, C_MetaTag* outMeta) {
00686         MSXML2::IXMLDOMNamedNodeMap* locAttribMap = NULL;
00687         HRESULT locHR = S_FALSE;
00688 
00689         bool retVal = true;
00690         //---------------Attributes-----------------
00691         locHR = inMetaNode->get_attributes(&locAttribMap);
00692 
00693         outMeta->setId(getNamedAttribValue(L"id", locAttribMap));
00694         outMeta->setLang(getNamedAttribValue(L"lang", locAttribMap));
00695         outMeta->setDirn(getNamedAttribValue(L"dir", locAttribMap));
00696         outMeta->setName(getNamedAttribValue(L"name", locAttribMap));
00697         if (outMeta->name() == L"") {
00698                 retVal = false;
00699         } else {
00700                 outMeta->setContent(getNamedAttribValue(L"content", locAttribMap));
00701                 if (outMeta->content() == L"") {
00702                         retVal = false;
00703                 }
00704         }
00705 
00706         outMeta->setScheme(getNamedAttribValue(L"scheme", locAttribMap));
00707         //------------------------------------------
00708 
00709         if (locAttribMap != NULL)               locAttribMap->Release();
00710         return true;
00711 }
00712 
00713 //string CMMLParser::toNarrowStr(wstring inString) {
00714 //      string retVal;
00715 //
00716 //
00717 //      for (std::wstring::const_iterator i = inString.begin(); i != inString.end(); i++) {
00718 //              retVal.append(1, *i);
00719 //      }
00720 //      
00721 //      return retVal;
00722 //}
00723 
00724 bool CMMLParser::parseAnchorTag(MSXML2::IXMLDOMNode* inAnchorNode, C_AnchorTag* outAnchor) {
00725         MSXML2::IXMLDOMNamedNodeMap*            locAttribMap    = NULL;
00726         HRESULT                                                         locHR                   = S_FALSE;
00727         BSTR                                                            locBStr                 = NULL;
00728         wstring                                                         locAnchorText   = L"";
00729 
00730         bool                                                            retVal                  = true;
00731         //---------------Attributes-----------------
00732         locHR = inAnchorNode->get_attributes(&locAttribMap);
00733         outAnchor->setId(getNamedAttribValue(L"id", locAttribMap));
00734         outAnchor->setLang(getNamedAttribValue(L"lang", locAttribMap));
00735         outAnchor->setDirn(getNamedAttribValue(L"dir", locAttribMap));
00736         outAnchor->setCls(getNamedAttribValue(L"class", locAttribMap));
00737         outAnchor->setHref(getNamedAttribValue(L"href", locAttribMap));
00738         if (outAnchor->href() == L"") {
00739                 retVal = false;
00740         }
00741         //------------------------------------------
00742         //Anchor text
00743 
00744         inAnchorNode->get_text(&locBStr);
00745         locAnchorText = locBStr;
00746 
00747         //if (locAnchorText == L"") {
00748         //      retVal = false;
00749         //}
00750         outAnchor->setText(locAnchorText);
00751 
00752         //Cleanup
00753         SysFreeString(locBStr);
00754     if (locAttribMap != NULL)                                   locAttribMap->Release();
00755         return retVal;
00756 }
00757 
00758 bool CMMLParser::parseTitleTag(MSXML2::IXMLDOMNode* inTitleNode, C_TitleTag* outTitle) {
00759         MSXML2::IXMLDOMNamedNodeMap* locAttribMap = NULL;
00760         BSTR locBStr = NULL;
00761         wstring locTitleText;
00762         HRESULT locHR = S_FALSE;
00763 
00764         //---------------Attributes-----------------
00765         locHR = inTitleNode->get_attributes(&locAttribMap);
00766         
00767         outTitle->setId(getNamedAttribValue(L"id", locAttribMap));
00768         outTitle->setLang(getNamedAttribValue(L"lang", locAttribMap));
00769         outTitle->setDirn(getNamedAttribValue(L"dir", locAttribMap));
00770         //------------------------------------------
00771 
00772         inTitleNode->get_text(&locBStr);
00773         locTitleText = locBStr;
00774         outTitle->setText(locTitleText);
00775 
00776         SysFreeString(locBStr);
00777         if (locAttribMap != NULL)                                       locAttribMap->Release();
00778         return true;
00779 
00780 }
00781 
00782 bool CMMLParser::parseDescTag(MSXML2::IXMLDOMNode* inDescNode, C_DescTag* outDesc) {
00783         MSXML2::IXMLDOMNamedNodeMap* locAttribMap = NULL;
00784         BSTR locBStr = NULL;
00785         wstring locDescText;
00786         HRESULT locHR = S_FALSE;
00787 
00788         //---------------Attributes-----------------
00789         locHR = inDescNode->get_attributes(&locAttribMap);
00790         outDesc->setId(getNamedAttribValue(L"id", locAttribMap));
00791         outDesc->setLang(getNamedAttribValue(L"lang", locAttribMap));
00792         outDesc->setDirn(getNamedAttribValue(L"dir", locAttribMap));
00793         //------------------------------------------
00794         inDescNode->get_text(&locBStr);
00795         locDescText = locBStr;
00796         outDesc->setText(locDescText);
00797 
00798         SysFreeString(locBStr);
00799         if (locAttribMap != NULL)                                       locAttribMap->Release();
00800         return true;
00801 
00802 }
00803 
00804 
00805 
00806 
00807 bool CMMLParser::parseBaseTag(MSXML2::IXMLDOMNode* inBaseNode, C_BaseTag* outBase) {
00808         MSXML2::IXMLDOMNamedNodeMap* locAttribMap = NULL;
00809         HRESULT locHR = S_FALSE;
00810 
00811         bool retVal = true;
00812         //---------------Attributes-----------------
00813         locHR = inBaseNode->get_attributes(&locAttribMap);
00814         
00815         outBase->setId(getNamedAttribValue(L"id", locAttribMap));
00816         outBase->setHref(getNamedAttribValue(L"href", locAttribMap));
00817         if (outBase->href() == L"") {
00818                 retVal = false;
00819         }
00820         //------------------------------------------
00821 
00822         if (locAttribMap != NULL)                                       locAttribMap->Release();
00823         return retVal;
00824 
00825 }
00826 
00827 
00828 
00829 bool CMMLParser::parseParamTag(MSXML2::IXMLDOMNode* inParamNode, C_ParamTag* outParam) {
00830         MSXML2::IXMLDOMNamedNodeMap* locAttribMap = NULL;
00831         HRESULT locHR = S_FALSE;
00832 
00833         bool retVal = true;
00834         //---------------Attributes-----------------
00835         locHR = inParamNode->get_attributes(&locAttribMap);
00836 
00837         outParam->setId(getNamedAttribValue(L"id", locAttribMap));
00838         outParam->setName(getNamedAttribValue(L"name", locAttribMap));
00839         if (outParam->name() == L"") {
00840                 retVal = false;
00841         } else {
00842                 outParam->setContent(getNamedAttribValue(L"value", locAttribMap));
00843                 if (outParam->content() == L"") {
00844                         retVal = false;
00845                 }
00846         }
00847 
00848         
00849         //------------------------------------------
00850 
00851         if (locAttribMap != NULL)               locAttribMap->Release();
00852         return true;
00853 }

Generated on Tue Feb 15 14:54:12 2005 for oggdsf by  doxygen 1.3.9