src/vapiMacro.c

Ir para a documentação deste ficheiro.

#include <stdio.h>
#include <string.h>
#include "vapi.h"
#include "vapiLists.h"
#include "vapiMacro.h"
#include "vapiMacroBypass.h"
#include "vapiOperationsDefault.h"
#include "vapiOperationOptions.h"
#include "vapiTypes.h"
#include "vapiAux.h"
#include "vapiImagesAux.h"
#include "vapiMemory.h"
#include <highgui.h>
#ifndef VAPI_WITHOUT_INTERFACE
#include <gtk/gtk.h>
#include "vapiGtkImages.h"
#include "vapiGtkEventsMacros.h"
#endif

// temporario
#include "vapiGtkAux.h"

vMacroHeader *
vapiMacroNew (const char *MacroName)
{
        vMacroHeader *MacroHeader;
        vMacro *Macro = malloc (sizeof (vMacro));
        *Macro = NULL;
        MacroHeader = malloc (sizeof (vMacroHeader));
        MacroHeader->PreviousResult = vapiMacroResultInit ();
        MacroHeader->MacroName = vapiReturnStringPointer (MacroName);
        MacroHeader->Macro = Macro;
        MacroHeader->MacroComment = vapiReturnStringPointer ("");

        return MacroHeader;
}

void
vapiMacroAddItem (vMacro * Macro, vEffect * Operation, vOptions * Options)
{
        vMacroItem *MacroItem;

        MacroItem = malloc (sizeof (vMacroItem));
        MacroItem->Operation = Operation;
        MacroItem->Options = Options;
        v_list_append ((vList *) Macro, MacroItem);
}

int
vapiMacroCountElements (vMacro * Macro)
{
        return v_list_count_elements ((vList *) Macro);
}

void
vapiMacroDeleteItem (vMacro * Macro, int Delete)
{
        v_list_delete_item ((vList *) Macro,
                            (vFreeFunction *) & vMacroItemFree, Delete);
}

vMacroItem *
vapiMacroSelectItem (vMacro * Macro, int Item)
{
        return (v_list_get ((vList *) Macro, Item));
}

void
vapiMacroAddItemPositioned (vMacro * Macro, vEffect * Operation,
                            vOptions * Options, int position)
{
        vMacroItem *MacroItem;

        MacroItem = malloc (sizeof (vMacroItem));
        MacroItem->Operation = Operation;
        MacroItem->Options = Options;

        v_list_insert ((vList *) Macro, MacroItem, position);

        vapiMacroToText (Macro);
}

void
vapiApplyMacro (vMacroHeader * MacroHeader, vImages * Images,
                vBoolean ResetResult, vBoolean SaveSequence)
{
        vMacroItem *Item;
        int i = 0, MacroSize;
        char *filename, *macroTag;
        MacroSize = vapiMacroCountElements (MacroHeader->Macro);
        if (MacroSize == 0)
        {
                return;
        }
        /*
         * Fazer Reset aos Resultados Memorizados, se existirem.
         */
        if (ResetResult)
        {
                vResultReset ((vMacroResult *) MacroHeader->PreviousResult);
        }
        macroTag = vapiResultCheckMacroTag (MacroHeader->PreviousResult);
        for (i = 0; i < MacroSize; i++)
        {
                if (!vapiGtkMacroRunningTest ())
                {
                        return;
                }
                if (!v_bypass_get (macroTag, i))
                {
                        continue;
                }
                vapiResultSetCurrentMacroTag (MacroHeader->PreviousResult,
                                              macroTag, i);
                if (MacroHeader->PreviousResult->End)
                {

                        MacroHeader->PreviousResult->End = vFALSE;
                        return;
                }
                Item = vapiMacroSelectItem (MacroHeader->Macro, i);
                vapiApplyOperation (Images, (vEffect *) Item->Operation,
                                    (vOptions *) Item->Options,
                                    MacroHeader->PreviousResult);
                if (v_stopby_get (macroTag, i))
                {
                        vapiGtkImagesFastUpdateInterface (Images->Actual,
                                                          gtkImActual);
                }
                if (SaveSequence)
                {
                        filename = v_printf ("%s_Operation_%d.jpg",
                                             MacroHeader->MacroName, i);
                        cvSaveImage (filename, Images->Actual);
                        free (filename);

                }
                if (MacroHeader->PreviousResult->JumpTo != -1)
                {
                        i = MacroHeader->PreviousResult->JumpTo - 1;
                        MacroHeader->PreviousResult->JumpTo = -1;
                        continue;
                }
        }
        free (macroTag);
}

void
vapiMacroToText (vMacro * Macro)
{
        vMacroItem *Item;
        int i, MacroSize;
        MacroSize = vapiMacroCountElements (Macro);

        for (i = 0; i < MacroSize; i++)
        {
                /*
                 * Carregar os dados do Operation.
                 */
                Item = vapiMacroSelectItem (Macro, i);

                /*
                 * Executar o Operation com os parâmetros definidos.
                 */

        }
}

void
vapiLoadMacro (vImages * Images, vOptions * options,
               vMacroResult * PreviousResult)
{
        vMacroHeader *originalMacroHeader, *tempMacroHeader;

        if (((vEffectOptions *) options->CustomOptions)->Macros == NULL)
        {
                v_error ("Macro Não seleccionada correctamente");
                return;
        }

        tempMacroHeader = malloc (sizeof (vMacroHeader));
        originalMacroHeader =
                ((vEffectOptions *) options->CustomOptions)->Macros;
        tempMacroHeader->Macro = originalMacroHeader->Macro;
        tempMacroHeader->MacroName = originalMacroHeader->MacroName;
        tempMacroHeader->PreviousResult = PreviousResult;
#ifdef VAPI_WITHOUT_INTERFACE
        vapiApplyMacro (tempMacroHeader, Images, vFALSE, vFALSE);
#else
        vapiApplyMacro (tempMacroHeader, Images, vFALSE, vFALSE);
#endif

        free (tempMacroHeader);

}

void
vapiMacroDelete (vMacroHeader * MacroHeader)
{

        v_list_free (MacroHeader->Macro, (vFreeFunction *) & vMacroItemFree);
        free (MacroHeader->PreviousResult);
        free (MacroHeader);
}

void
vapiApplyMacroUntil (vMacroHeader * MacroHeader, vImages * Images, int Until)
{
        vMacroItem *Item;
        int i = 0, MacroSize;
        char *macroTag;

        MacroSize = vapiMacroCountElements (MacroHeader->Macro);
        if (MacroSize == 0)
        {
                return;
        }
        macroTag = vapiResultCheckMacroTag (MacroHeader->PreviousResult);
        for (i = 0; i < MacroSize; i++)
        {
                if (!vapiGtkMacroRunningTest ())
                {
                        return;
                }
                if (!v_bypass_get (macroTag, i))
                {
                        continue;
                }
                vapiResultSetCurrentMacroTag (MacroHeader->PreviousResult,
                                              macroTag, i);
                if (MacroHeader->PreviousResult->End)
                {
                        MacroHeader->PreviousResult->End = vFALSE;
                        return;
                }
                Item = vapiMacroSelectItem (MacroHeader->Macro, i);
                vapiApplyOperation (Images, (vEffect *) Item->Operation,
                                    (vOptions *) Item->Options,
                                    MacroHeader->PreviousResult);
                if (v_stopby_get (macroTag, i))
                {
                        vapiGtkImagesFastUpdateInterface (Images->Actual,
                                                          gtkImActual);
                }
                if (MacroHeader->PreviousResult->JumpTo != -1)
                {

                        i = MacroHeader->PreviousResult->JumpTo - 1;
                        MacroHeader->PreviousResult->JumpTo = -1;
                        continue;
                }
                if (i == Until)
                {
                        return;
                }
        }
        free (macroTag);
}

void
vapiConditionalJump (vImages * Images, vOptions * Options,
                     vMacroResult * PreviousResult)
{
        if (PreviousResult->Decision)
        {
                v_debug ("JUMP TO TRUE");
                PreviousResult->JumpTo = Options->ints[0];
                PreviousResult->Decision = vFALSE;

        }
        else
        {
                v_debug ("JUMP TO FALSE");
                PreviousResult->JumpTo = Options->ints[1];
        }
}

void
vMacroItemFree (vMacroItem * Free)
{
        vOperationOptionsFree (Free->Options, Free->Operation);
        free (Free);
}

int
vapiMacroGetMacroIndex (vMacro * Macro, const char *MacroName, int order)
{

        int MacroSize, tempOrder = 0, i;
        vMacroItem *item;

        MacroSize = v_list_count_elements (Macro);

        for (i = 0; i < MacroSize; i++)
        {
                item = v_list_get (Macro, i);

                if (!strcmp (item->Operation->name, "Executar Tarefa"))
                {
                        if (!strcmp (item->Options->chars[0].ch, MacroName))
                        {
                                if (++tempOrder == order)
                                {
                                        return i;
                                }
                        }
                }
        }
        return -1;
}

void
vapiMacroUpdateComment (vMacroHeader * MacroHeader, const char *MacroComment)
{
        free (MacroHeader->MacroComment);
        MacroHeader->MacroComment = vapiReturnStringPointer (MacroComment);
}

void
vapiMacroUpdateName (vMacroHeader * MacroHeader, const char *MacroName)
{
        free (MacroHeader->MacroName);
        MacroHeader->MacroName = vapiReturnStringPointer (MacroName);
}

char *
vapiMacroTag (const char *previousMacroTag, int operationNumber)
{
        return v_printf ("%s:%d", previousMacroTag, operationNumber);
}

---