src/vapiMacroBypass.c

Ir para a documentação deste ficheiro.

#include "vapiLists.h"
#include "vapiTypes.h"
#include "vapiString.h"
#ifndef VAPI_DEBUG_MACRO_BYPASS
#define v_debug(val,...) 
#endif
typedef struct _vBypassItem
{
        char *macroTag;
        vBoolean *ByPassArray;
        vBoolean *StopByArray;
        int NumberOfMacroOperations;
} vBypassItem;

static struct
{
        vList *List;
        vBoolean Updatable;
} Bypass;

void
v_bypass_init ()
{
        Bypass.List = v_list_new ();
        Bypass.Updatable = vTRUE;
}

void
v_bypass_append (const char *macroTag, int NumberOfMacroOperations)
{
        vBypassItem *BypassItem;
        int i;
        v_debug ("bypass init macro Tags: %s", macroTag);
        BypassItem = malloc (sizeof (vBypassItem));
        BypassItem->NumberOfMacroOperations = NumberOfMacroOperations;
        if (NumberOfMacroOperations > 0)
        {
                BypassItem->ByPassArray =
                        malloc (BypassItem->NumberOfMacroOperations *
                                sizeof (vBoolean));
                BypassItem->StopByArray =
                        malloc (BypassItem->NumberOfMacroOperations *
                                sizeof (vBoolean));
                for (i = 0; i < BypassItem->NumberOfMacroOperations; i++)
                {
                        BypassItem->ByPassArray[i] = vTRUE;
                        BypassItem->StopByArray[i] = vFALSE;

                }
        }

        BypassItem->macroTag = v_printf ("%s", macroTag);

        /*
         * Colocr a ultima imagem como visível.
         */
        if (strchr (macroTag, ':') == NULL && NumberOfMacroOperations)
        {
                BypassItem->
                        StopByArray[(BypassItem->NumberOfMacroOperations -
                                     1)] = vTRUE;
        }
        v_list_append (Bypass.List, BypassItem);
}

static vBypassItem *
v_bypass_search (const char *macroTag)
{
        int i, ListSize;
        vBypassItem *tempBypassItem;
        v_debug ("BYPASS SEARCH MAROTAG: %s", macroTag);
        ListSize = v_list_count_elements (Bypass.List);
        if (ListSize == 0)
        {
                return NULL;
        }
        for (i = 0; i < ListSize; i++)
        {
                tempBypassItem = v_list_get (Bypass.List, i);

                if (!strcmp (tempBypassItem->macroTag, macroTag))
                {
                        v_debug("bypass_search found");
                        return tempBypassItem;
                }
        }
        v_debug("bypass_search nothing");
        return NULL;
}

void
v_bypass_set (const char *macroTag, int itemNum)
{
        vBypassItem *tempBypassItem;
        tempBypassItem = v_bypass_search (macroTag);

        if (tempBypassItem == NULL)
        {
                return;
        }

        if (tempBypassItem->ByPassArray[itemNum])
        {
                tempBypassItem->ByPassArray[itemNum] = vFALSE;
        }
        else
        {
                tempBypassItem->ByPassArray[itemNum] = vTRUE;
        }
}

vBoolean
v_bypass_get (const char *macroTag, int itemNum)
{
        vBypassItem *tempBypassItem;
        v_debug ("BYPASS TO SEARCH");
        tempBypassItem = v_bypass_search (macroTag);
        v_debug ("BYPASS FROM SEARCH");
        if (tempBypassItem == NULL)
        {
                v_debug ("BYPASS SEARCH NOTHING");
                return vTRUE;
        }
        v_debug ("BYPASS SEARCH ENCONTROU");
        return tempBypassItem->ByPassArray[itemNum];
}

void
v_bypass_item_free (vBypassItem * vFree)
{
        if (vFree->NumberOfMacroOperations > 0)
        {
                free (vFree->ByPassArray);
                free (vFree->StopByArray);
        }
        free (vFree->macroTag);
        free (vFree);
}

void
v_bypass_clean ()
{
        v_list_free (Bypass.List, (vpointer) & v_bypass_item_free);
}

vBoolean
v_stopby_get (const char *macroTag, int itemNum)
{
        vBypassItem *tempBypassItem;
        tempBypassItem = v_bypass_search (macroTag);
        if (tempBypassItem == NULL)
        {
                v_debug ("BYPASS SEARCH NOTHING");
                return vTRUE;
        }
        v_debug ("BYPASS SEARCH STOP BY");
        if (tempBypassItem->StopByArray[itemNum])
                v_debug("STOP STP");
        return tempBypassItem->StopByArray[itemNum];
}

void
v_stopby_set (const char *macroTag, int itemNum)
{
        vBypassItem *tempBypassItem;
        int j, ListSize;

        ListSize = v_list_count_elements (Bypass.List);
        for (j = 0; j < ListSize; j++)
        {
                tempBypassItem = v_list_get (Bypass.List, j);
                if (!strcmp (macroTag, tempBypassItem->macroTag))
                {
                        if (tempBypassItem->StopByArray[itemNum])
                        {
                                tempBypassItem->StopByArray[itemNum] = vFALSE;
                        }
                        else
                        {
                                tempBypassItem->StopByArray[itemNum] = vTRUE;
                        }
                }
        }
}


void
v_bypass_reload ()
{
        int ListSize = v_list_count_elements (Bypass.List);
        v_debug ("bypass listsize %d", ListSize);
        if (ListSize > 0 && Bypass.Updatable)
        {
                v_bypass_clean ();
                v_bypass_init ();
        }
}

void
v_bypass_set_updatable (vBoolean Updatable)
{
        Bypass.Updatable = Updatable;
}

//v_bypass_move_to

---