src/vapiMacroXML.c

Ir para a documentação deste ficheiro.

#include <stdio.h>
#include "vapiTypes.h"
#include "vapiAux.h"
#include "vapiString.h"
#include "vapiMacro.h"
#include "vapiMacroList.h"
#include "vapiOperationList.h"
#include "vapiOperationOptions.h"
#include "vapiGtkAux.h"
#include "vapiGtkAuxWindow.h"
#include "vapiOptions.h"
#include "vapiOptionsXML.h"
#include "vapiXML.h"
#include "vapiOperationXML.h"
#include <libxml/encoding.h>
#include <libxml/xmlreader.h>
#include <libxml/xmlwriter.h>
#include <string.h>

static xmlTextWriter *
vapiMacroXMLFileInit (vMacroHeader * MacroHeader, const char *filename)
{
        xmlTextWriter *xmlOutput;

        /*
         * Como colocar a string do ficheiro Automatica.
         */

        xmlOutput = xmlNewTextWriterFilename (filename, 0);

        xmlTextWriterSetIndent (xmlOutput, 1);

        xmlTextWriterStartDocument (xmlOutput, NULL, "ISO-8859-1", NULL);

        xmlTextWriterStartDTD (xmlOutput, BAD_CAST "vapiMacro", NULL, NULL);

        xmlTextWriterWriteDTDElement (xmlOutput,
                                      BAD_CAST "vapiMacro",
                                      BAD_CAST "(Operation*,Comment?)");
        xmlTextWriterWriteDTDAttlist (xmlOutput,
                                      BAD_CAST "vapiMacro",
                                      BAD_CAST "name NMTOKENS #REQUIRED");
        xmlTextWriterWriteDTDElement (xmlOutput, BAD_CAST "Comment",
                                      BAD_CAST "(#PCDATA)");
        xmlTextWriterWriteDTDElement (xmlOutput,
                                      BAD_CAST "Operation",
                                      BAD_CAST "(option)*");
        xmlTextWriterWriteDTDAttlist (xmlOutput,
                                      BAD_CAST "Operation",
                                      BAD_CAST "name NMTOKENS #REQUIRED");

        vapiOptionsXMLOptionsElement (xmlOutput, 2, "times", "original");

        xmlTextWriterEndDTD (xmlOutput);

        xmlTextWriterStartElement (xmlOutput, BAD_CAST "vapiMacro");
        xmlTextWriterWriteAttribute (xmlOutput, BAD_CAST "name",
                                     BAD_CAST MacroHeader->MacroName);
        
        xmlTextWriterStartElement (xmlOutput, BAD_CAST "Comment");
        xmlTextWriterWriteString (xmlOutput, BAD_CAST MacroHeader->MacroComment);
        xmlTextWriterEndElement (xmlOutput);

        return xmlOutput;
}

void
vapiMacroToXML (vMacroHeader * MacroHeader, const char *filename)
{
        xmlTextWriter *xmlOutput;
        int i, OperationNumber;
        vMacroItem *Item;

        /*
         * Criar cabeçalho do Ficheiro XML.
         */

        xmlOutput = vapiMacroXMLFileInit (MacroHeader, filename);

        /*
         * Ir a cada Operação da Macro.
         */

        OperationNumber = vapiMacroCountElements (MacroHeader->Macro);

        if (!OperationNumber)
        {
                return;
        }

        for (i = 0; i < OperationNumber; i++)
        {
                Item = vapiMacroSelectItem (MacroHeader->Macro, i);

                xmlTextWriterStartElement (xmlOutput, BAD_CAST "Operation");

                xmlTextWriterWriteAttribute (xmlOutput, BAD_CAST "name",
                                             BAD_CAST Item->Operation->name);

                /*
                 * Get Options.
                 */
                vapiOptionsXMLGetOptions (xmlOutput,
                                          Item->Operation->OptionsSettings,
                                          Item->Options,
                                          &vapiOptionsXMLGetOptionsOperation);


                xmlTextWriterEndElement (xmlOutput);

        }


        xmlTextWriterEndDocument (xmlOutput);

        xmlFreeTextWriter (xmlOutput);
        v_info ("Guardada Macro para xml");

}

vMacroHeader *
vapiMacroFromXML (const char *filename, vOperationList * OperationList,
                  vMacroList * MacroList)
{
        xmlTextReader *xmlInput;
        vMacroHeader *MacroHeader;
        vEffect *tempOperation;
        vOptions *tempOptions;
        int ret = 1;
        xmlInput = xmlReaderForFile (filename, "ISO-8859-1", XML_PARSE_DTDATTR |        /* default DTD attributes */
                                     XML_PARSE_NOENT |  /* substitute entities */
                                     XML_PARSE_DTDVALID);       /* validate with the DTD */

        if (xmlInput == NULL)
        {
                return NULL;
        }
        xmlTextReaderRead (xmlInput);
        if (!strcmp
            ((char *) xmlTextReaderLocalName (xmlInput), "vapiMacro "))
        {
                return MacroHeader = 0;
        }

        vapiXMLNextElement (xmlInput);
        MacroHeader =
                vapiMacroNew ((char *) xmlTextReaderGetAttribute
                              (xmlInput, BAD_CAST "name"));
        /*
         * Entramos nas Operações.
         */
        if (vapiXMLNextElement (xmlInput) > 0)
        {
                if (!strcmp
                    ((char *) xmlTextReaderLocalName (xmlInput), "Comment"))
                {
                        v_debug ("comentário lido: .%s.", xmlTextReaderReadString
                                                (xmlInput));
                        vapiMacroUpdateComment (MacroHeader,
                                                (char *)
                                                xmlTextReaderReadString
                                                (xmlInput));
                        v_debug ("comentário lido: .%s.", xmlTextReaderReadString
                                                (xmlInput));
                        vapiXMLNextElement (xmlInput);
                        
                }
                if (strcmp
                    ((char *) xmlTextReaderLocalName (xmlInput), "Operation"))
                {
                        return MacroHeader = 0;
                }

                while (ret > 0)
                {

                        tempOperation =
                                vapiOperationListSelectOperation
                                (OperationList, (char *)
                                 xmlTextReaderGetAttribute (xmlInput,
                                                            BAD_CAST "name"));
                        v_debug ("operation name: %s",
                                 xmlTextReaderGetAttribute (xmlInput,
                                                            BAD_CAST "name"));

                        tempOptions =
                                vapiOperationOptionsInit (tempOperation);

                        vapiOptionsXMLSetOptions (xmlInput, tempOptions,
                                                  &vapiOptionsXMLSetOptionsOperation);

                        vapiMacroAddItem (MacroHeader->Macro,
                                          tempOperation, tempOptions);
                        ret = vapiXMLNextElement (xmlInput);

                        vapiOptionsCheck (tempOperation->OptionsSettings,
                                          tempOptions);

                        vapiCheckOperations (tempOperation, tempOptions,
                                             MacroList);
                }

        }


        //v_info ("Carregada a Macro de xml");
        return MacroHeader;
}

char *
vapiMacroFromXMLSetName (const char *filename)
{

        xmlTextReader *xmlInput;

        xmlInput = xmlReaderForFile (filename, "ISO-8859-1", XML_PARSE_DTDATTR |        /* default DTD attributes */
                                     XML_PARSE_NOENT |  /* substitute entities */
                                     XML_PARSE_DTDVALID);       /* validate with the DTD */

        if (xmlInput == NULL)
        {
                return NULL;
        }
        if (xmlTextReaderRead (xmlInput) < 0)
        {
                return NULL;
        }

        if (!strcmp
            ((char *) xmlTextReaderLocalName (xmlInput), "vapiMacro "))
        {
                return NULL;
        }

        vapiXMLNextElement (xmlInput);
        return ((char *)
                xmlTextReaderGetAttribute (xmlInput, BAD_CAST "name"));
}

vBoolean
vapiMacroXMLLoadToList (vMacroList * MacroList,
                        vOperationList * OperationList, const char *filename)
{
        char *MacroName;
        vMacroHeader *MacroHeader;

        MacroName = vapiMacroFromXMLSetName (filename);

        if (MacroName == NULL)
        {
                return vFALSE;
        }

        if (vapiMacroListMacroExist (MacroList, MacroName, 1) == -1)
        {
                return vFALSE;
        }

        MacroHeader = vapiMacroFromXML (filename, OperationList, MacroList);

        vapiMacroListAddItem (MacroList, MacroHeader);

        return vTRUE;

}

---