src/interface/vapiGtkEventsMacros.c

Ir para a documentação deste ficheiro.

#include <gtk/gtk.h>
#include "vapi.h"
#include "vapiAux.h"
#include "vapiTypes.h"
#include "vapiString.h"
#include "vapiGtkInterface.h"
#include "vapiGtkAux.h"
#include "vapiGtkAuxWindow.h"
#include "vapiGtkOptions.h"
#include "vapiGtkOptionsOperations.h"
#include "vapiOperationOptions.h"
#include "vapiGtkEventsOperations.h"
#include "vapiGtkEventsMacros.h"
#include "vapiMacroXML.h"
#include "vapiGtkMacro.h"
#include "vapiGtkMacrosTables.h"
#include "vapiGtkTable.h"
#include "vapiOperationsDefault.h"
#include "vapiImagesAux.h"
#include "vapiGtkImages.h"
#include "vapiMacroBypass.h"

static vBoolean AppendOperation;

static struct
{
        GtkWidget *dialogMacroDelete;
        GtkWidget *lblMacroDelete;
        GtkWidget *cbMacro;
        GtkTextView *txtMacroComent;
        GtkWidget *txtMacroName;
        vMacroList *MacroList;
        vOperationList *OperationList;
        GtkTextView *txtMacroChangeComment;
        GtkWidget *txtMacroChangeName;
        GList **OptionsData;
} GtkMacroEvents;
static GtkWidget *winCreateMacro;
static GtkWidget *txtOperation;
static vBoolean MacroRunning;
void
vapiGtkEventsMacrosInit (GladeXML * xml, vMacroList * MacroList,
                         vOperationList * OperationList, vImages * Images,
                         GList ** OptionsData)
{
        GtkWidget *btMacroDeleteOk;
        GtkWidget *btMacroOpen;
        GtkWidget *btMacroSave;
        GtkWidget *btMacroNew;
        GtkWidget *winMacroChange;
        GtkWidget *btMacroChange;
        GtkWidget *btMacroNext;
        GtkWidget *btMacroStop;

        GtkMacroEvents.txtMacroName =
                glade_xml_get_widget (xml, "txtMacroName");
        btMacroNew = glade_xml_get_widget (xml, "btMacroNew");
        GtkMacroEvents.dialogMacroDelete =
                glade_xml_get_widget (xml, "dialogMacroDelete");
        GtkMacroEvents.lblMacroDelete =
                glade_xml_get_widget (xml, "lblMacroDelete");
        GtkMacroEvents.cbMacro = glade_xml_get_widget (xml, "cbMacro");
        btMacroDeleteOk = glade_xml_get_widget (xml, "btMacroDeleteOk");
        btMacroOpen = glade_xml_get_widget (xml, "btMacroFromFile");
        btMacroSave = glade_xml_get_widget (xml, "btMacroSave");
        btMacroChange = glade_xml_get_widget (xml, "btMacroChange");
        winMacroChange = glade_xml_get_widget (xml, "winMacroChange");
        winCreateMacro = glade_xml_get_widget (xml, "winCreateMacro");
        GtkMacroEvents.txtMacroComent =
                (GtkTextView *) glade_xml_get_widget (xml, "txtMacroComment");
        GtkMacroEvents.txtMacroChangeComment =
                (GtkTextView *) glade_xml_get_widget (xml,
                                                      "txtMacroChangeComment");
        GtkMacroEvents.txtMacroChangeName =
                glade_xml_get_widget (xml, "txtMacroChangeName");
        btMacroNext = glade_xml_get_widget (xml, "btMacroNext");
        btMacroStop = glade_xml_get_widget (xml, "btMacroStop");
        txtOperation = glade_xml_get_widget (xml, "txtOperation");
        AppendOperation = vFALSE;
        GtkMacroEvents.MacroList = MacroList;
        GtkMacroEvents.OptionsData = OptionsData;
        GtkMacroEvents.OperationList = OperationList;
        MacroRunning = vFALSE;

        g_signal_connect (G_OBJECT (btMacroDeleteOk), "clicked",
                          G_CALLBACK (vapiGtkMacroDeleteMacro), NULL);
        g_signal_connect (G_OBJECT (btMacroSave), "clicked",
                          G_CALLBACK (vapiGtkMacroLaunchMacroSave), NULL);
        g_signal_connect (G_OBJECT (btMacroOpen), "clicked",
                          G_CALLBACK (vapiGtkMacroLaunchMacroOpen),
                          OperationList);
        g_signal_connect (G_OBJECT (btMacroChange), "clicked",
                          G_CALLBACK (vapiGtkMacroLaunchChangeWindow),
                          winMacroChange);
        g_signal_connect (G_OBJECT (winMacroChange), "response",
                          G_CALLBACK (vapiGtkMacroChange), NULL);
        g_signal_connect (G_OBJECT (btMacroNew), "clicked",
                          G_CALLBACK (vapiGtkMacroCreate), NULL);
        g_signal_connect (G_OBJECT (winCreateMacro), "response",
                          G_CALLBACK (vapiGtkMacroCreate), NULL);
        g_signal_connect (G_OBJECT (btMacroNext), "clicked",
                          G_CALLBACK (vapiGtkMacroSelectNext), Images);
        g_signal_connect (G_OBJECT (btMacroStop), "clicked",
                          G_CALLBACK (vapiGtkMacroStop), NULL);
}

void
vapiGtkMacroCreate (GtkWidget * widget, int response, vapiTemp1Struct * temp)
{
        char *string;
        char *MacroComment;
        GtkTextBuffer *textBuffer;
        GtkTextIter iterStart, iterEnd;
        int MacroNumber;
        vMacroHeader *MacroHeader;
        if (response != GTK_RESPONSE_OK)
        {
                return;
        }
        if (vapiGtkMacroIsItRunning ())
        {
                return;
        }
        string = (char *) gtk_entry_get_text ((GtkEntry *) GtkMacroEvents.
                                              txtMacroName);
        if (!strcmp (string, ""))
        {
                return;
        }
        if ((MacroNumber =
             vapiMacroListMacroExist (GtkMacroEvents.MacroList, string,
                                      1)) != -1)
        {
                MacroHeader = vapiMacroNew (string);
                textBuffer =
                        gtk_text_view_get_buffer (GtkMacroEvents.
                                                  txtMacroComent);
                gtk_text_buffer_get_start_iter (textBuffer, &iterStart);

                gtk_text_buffer_get_end_iter (textBuffer, &iterEnd);

                MacroComment =
                        gtk_text_buffer_get_text (textBuffer, &iterStart,
                                                  &iterEnd, TRUE);
                gtk_text_buffer_set_text (textBuffer, "", -1);
                v_debug ("comentário à macro .%s.", MacroComment);
                vapiMacroUpdateComment (MacroHeader, MacroComment);
                vapiMacroListAddItem (GtkMacroEvents.MacroList, MacroHeader);
                MacroNumber =
                        vapiMacroListMacroExist (GtkMacroEvents.MacroList,
                                                 string, 0);
                vapiGtkCbMacroStart ();

                if (SelectedMacro == -1 && AppendOperation)
                {
                        SelectedMacro = MacroNumber;
                        vapiGtkMacroAppendItem (widget, NULL);

                        AppendOperation = vFALSE;
                }
                gtk_widget_hide (widget);

                vapiGtkComboBoxSetActive (GtkMacroEvents.cbMacro,
                                          MacroNumber);
        }
        gtk_entry_set_text ((GtkEntry *) GtkMacroEvents.txtMacroName, "");
}

void
vapiGtkMacroLaunchChangeWindow (GtkWidget * widget,
                                GtkWidget * winMacroChange)
{
        GtkTextBuffer *textBuffer;
        vMacroHeader *MacroHeader;
        if (vapiGtkMacroCheckSelected ())
        {
                return;
        }
        MacroHeader =
                vapiMacroListSelectItem (GtkMacroEvents.MacroList,
                                         SelectedMacro);
        gtk_entry_set_text ((GtkEntry *) GtkMacroEvents.txtMacroChangeName,
                            MacroHeader->MacroName);
        textBuffer =
                gtk_text_view_get_buffer (GtkMacroEvents.
                                          txtMacroChangeComment);
        gtk_text_buffer_set_text (textBuffer, MacroHeader->MacroComment, -1);
        gtk_widget_show (winMacroChange);
}

void
vapiGtkMacroChange (GtkWidget * widget, int response, vapiTemp1Struct * temp)
{
        char *MacroName, *MacroComment;
        GtkTextBuffer *textBuffer;
        GtkTextIter iterEnd, iterStart;
        vMacroHeader *MacroHeader;
        if (response != GTK_RESPONSE_OK)
        {
                return;
        }
        if (SelectedMacro == -1)
        {
                return;
        }
        MacroHeader =
                vapiMacroListSelectItem (GtkMacroEvents.MacroList,
                                         SelectedMacro);

        MacroName = (char *) gtk_entry_get_text ((GtkEntry *)
                                                 GtkMacroEvents.
                                                 txtMacroChangeName);
        textBuffer =
                gtk_text_view_get_buffer (GtkMacroEvents.
                                          txtMacroChangeComment);
        gtk_text_buffer_get_start_iter (textBuffer, &iterStart);

        gtk_text_buffer_get_end_iter (textBuffer, &iterEnd);

        MacroComment =
                gtk_text_buffer_get_text (textBuffer, &iterStart,
                                          &iterEnd, TRUE);
        gtk_text_buffer_set_text (textBuffer, "", -1);

        vapiMacroUpdateName (MacroHeader, MacroName);

        vapiMacroUpdateComment (MacroHeader, MacroComment);

        vapiGtkCbMacroStart ();

        gtk_widget_hide (widget);
}

void
vapiGtkMacroUpdateItemOptions (GtkWidget * widget, vapiTemp1Struct * temp)
{

        vMacroItem *item;
        vMacroHeader *MacroHeader;
        int selected;
        if (vapiGtkMacroCheckSelected ())
        {
                return;
        }
        MacroHeader =
                vapiMacroListSelectItem (temp->MacroList, SelectedMacro);
        selected = vapiGtkMacroTableGetSelected ();
        if (selected >= 0)
        {
                item = vapiMacroSelectItem (MacroHeader->Macro, selected);
                vOperationOptionsFree (item->Options, item->Operation);
                item->Options = vapiOperationOptionsInit (item->Operation);
                vapiGtkOptionsGetOptions (item->Options,
                                          item->Operation->
                                          OptionsSettings,
                                          &vapiGtkOptionsGetOptionsCustomOperations,
                                          &temp->Widgets->OptionsData);
                vapiGtkMacroTable ();
        }
        else
        {
                v_error ("Nenhuma Operação seleccionada para actualização.");
        }
}

void
vapiGtkMacroAppendItem (GtkWidget * widget, vapiTemp1Struct * temp1)
{
        vOptions *options;
        vMacroHeader *MacroHeader;
        vEffect *Operation;
        if (vapiGtkMacroIsItRunning ())
        {
                return;
        }
        Operation =
                vapiGetOperationFromTxtOperation (txtOperation,
                                                  GtkMacroEvents.
                                                  OperationList);
        if (vapiGtkAuxCheckOperation (Operation))
        {
                return;
        }
        if (SelectedMacro == -1)
        {
                AppendOperation = vTRUE;
                gtk_widget_show (winCreateMacro);
                return;
        }
        AppendOperation = vFALSE;
        if (Operation == NULL)
        {
                return;
        }
        /*
         * Detectar Opções
         */
        options = vapiOperationOptionsInit (Operation);
        vapiGtkOptionsGetOptions (options,
                                  Operation->OptionsSettings,
                                  &vapiGtkOptionsGetOptionsCustomOperations,
                                  GtkMacroEvents.OptionsData);
        if (vapiCheckOperations
            (Operation, options, GtkMacroEvents.MacroList))
        {
                return;
        }
        MacroHeader =
                vapiMacroListSelectItem (GtkMacroEvents.MacroList,
                                         SelectedMacro);
        vapiMacroAddItem (MacroHeader->Macro, Operation, options);
        v_bypass_set_updatable (vTRUE);
        vapiGtkMacroTable ();
}


void
vapiGtkMacroInsertItem (GtkWidget * widget, vapiTemp1Struct * temp1)
{
        vMacroHeader *MacroHeader;
        vOptions *options;
        vEffect *Operation;
        int total, selectedRow;
        if (vapiGtkMacroCheckSelected ())
        {
                return;
        }
        if (vapiGtkMacroIsItRunning ())
        {
                return;
        }
        MacroHeader =
                vapiMacroListSelectItem (temp1->MacroList, SelectedMacro);
        Operation =
                vapiGetOperationFromTxtOperation (txtOperation,
                                                  GtkMacroEvents.
                                                  OperationList);
        if (vapiGtkAuxCheckOperation (Operation))
        {
                return;
        }
        options = vapiOperationOptionsInit (Operation);
        vapiGtkOptionsGetOptions (options,
                                  Operation->OptionsSettings,
                                  &vapiGtkOptionsGetOptionsCustomOperations,
                                  &temp1->Widgets->OptionsData);
        if (vapiCheckOperations (Operation, options, temp1->MacroList))
        {
                return;
        }

        /*
         * Verificar se existe algum elemento seleccionado
         */

        selectedRow = vapiGtkMacroTableGetSelected ();
        /*
         * Iniciar conteudo da Tabela Macro.
         */
        total = vapiMacroCountElements (MacroHeader->Macro);
        /*
         * Adicionar Nova linha na tabela.
         */
        vapiMacroAddItemPositioned (MacroHeader->Macro,
                                    Operation, options, selectedRow);
        v_bypass_set_updatable (vTRUE);
        vapiGtkMacroTable ();
}


void
vapiGtkMacroDeleteItem (GtkWidget * widget, vapiTemp1Struct * temp1)
{
        vMacroHeader *MacroHeader;
        int selectedRow;
        if (vapiGtkMacroCheckSelected ())
        {
                return;
        }
        if (vapiGtkMacroIsItRunning ())
        {
                return;
        }
        MacroHeader =
                vapiMacroListSelectItem (temp1->MacroList, SelectedMacro);
        selectedRow = vapiGtkMacroTableGetSelected ();
        if (selectedRow >= 0)
        {
                vapiMacroDeleteItem (MacroHeader->Macro, selectedRow);
                v_bypass_set_updatable (vTRUE);
                vapiGtkMacroTable (MacroHeader);
        }
        else
        {
                v_info ("Macro Delete Item: no row selected.\n");
        }
}

void
vapiGtkMacroApply (GtkWidget * widget, vapiTemp1Struct * temp)
{
        vMacroHeader *MacroHeader;
        vMacroThread *MacroThread;
        GError *error;
        if (vapiGtkMacroCheckSelected ())
        {
                return;
        }
        if (vapiGtkMacroIsItRunning ())
        {
                return;
        }
        vapiGtkMacroRunningStart ();
        MacroHeader =
                vapiMacroListSelectItem (temp->MacroList, SelectedMacro);
        MacroThread = vapiGtkMacroThreadNew (MacroHeader, temp->Images);
        g_thread_create ((vpointer) & vapiGtkApplyMacroThread, MacroThread,
                         FALSE, &error);
}

void
vapiGtkMacroSelectItem (GtkWidget * widget,
                        GtkTreePath * path,
                        GtkTreeIter * iter,
                        vMacroTablesSelect * MacroTablesSelect)
{
        vMacroItem *item;
        gint *itemNum;
        GError *error;
        vMacroThread *MacroThread;
        vMacroHeader *MacroHeader;
        itemNum = gtk_tree_path_get_indices (path);
        v_debug ("antes do if");
        MacroHeader =
                vapiMacroListSelectItem (MacroTablesSelect->MacroList,
                                         SelectedMacro);        
        if (!vapiGtkMacroRunningTest ())
        {
                vResultReset (MacroHeader->PreviousResult);
                MacroHeader->PreviousResult->macroTag =
                        vapiGtkMacroGetMacroTag ();
                vapiGtkMacroApplyAllMacros ();

                MacroThread =
                        vapiGtkMacroThreadNew (MacroHeader,
                                               MacroTablesSelect->Images);
                MacroThread->Until = itemNum[0];
                g_thread_create ((vpointer) & vapiGtkApplyMacroUntilThread,
                                 MacroThread, FALSE, &error);
        }
        item = vapiMacroSelectItem (MacroHeader->Macro, itemNum[0]);
        v_debug ("depois do select");
        gtk_entry_set_text ((GtkEntry *) MacroTablesSelect->
                            txtOperation, item->Operation->name);
        v_debug ("set text");
        vapiGtkOptionsPopulate (item->Options,
                                item->Operation->
                                OptionsSettings,
                                MacroTablesSelect->Lists,
                                &vapiGtkOptionsPopulateCustomOperations);
        v_debug ("populate");
}

void
vapiGtkMacroSaveToXML (GtkFileChooser * chooser,
                       gint response, vapiTemp1Struct * temp)
{
        vMacroHeader *MacroHeader;
        char *filename;
        v_debug ("entrou no grvar xml");
        if (response == GTK_RESPONSE_CANCEL)
        {
                gtk_widget_destroy ((GtkWidget *) chooser);
                return;
        }

        if (vapiGtkMacroCheckSelected () || response != GTK_RESPONSE_OK)
        {
                v_error_ui ("Nenhua Macro Seleccionada");
                return;
        }

        MacroHeader =
                vapiMacroListSelectItem (GtkMacroEvents.MacroList,
                                         SelectedMacro);
        filename = gtk_file_chooser_get_filename (chooser);
        vapiMacroToXML (MacroHeader, filename);
        gtk_widget_destroy ((GtkWidget *) chooser);
}

void
vapiGtkMacroOpenFromXML (GtkFileChooser * chooser,
                         gint response, vOperationList * OperationList)
{
        const char *filename;
        vMacroHeader *MacroHeader;
        if (response == GTK_RESPONSE_CANCEL)
        {
                gtk_widget_destroy ((GtkWidget *) chooser);
                return;
        }
        if (response != GTK_RESPONSE_OK)
        {
                return;
        }
        filename = gtk_file_chooser_get_filename ((GtkFileChooser *) chooser);
        v_debug ("aqui %s", filename);
        if (vapiMacroXMLLoadToList
            (GtkMacroEvents.MacroList, OperationList, filename))
        {
                if (!vapiGtkMacroIsItRunning ())
                {
                        SelectedMacro =
                                (vapiMacroListCountElements
                                 (GtkMacroEvents.MacroList) - 1);
                }
                vapiGtkCbMacroStart ();
                MacroHeader =
                        vapiMacroListSelectItem (GtkMacroEvents.MacroList,
                                                 SelectedMacro);
                gtk_widget_destroy ((GtkWidget *) chooser);
        }
        else
        {
                v_error_ui ("A Macro \"%s\" jé existe",
                            vapiMacroFromXMLSetName (filename));
        }
}

void
vapiGtkMacroDeleteMacro (GtkWidget * widget, gpointer user_data)
{
        if (vapiGtkMacroCheckSelected ())
        {
                return;
        }
        if (vapiGtkMacroIsItRunning ())
        {
                return;
        }
        vapiMacroListDeleteItem (GtkMacroEvents.MacroList, SelectedMacro);
        SelectedMacro = -1;
        SelectedMacroGlobal = -1;
        vapiGtkCbMacroStart ();
        vapiGtkMacrosTablesCleanToDefault ();
        gtk_widget_hide (GtkMacroEvents.dialogMacroDelete);
}

void
vapiGtkMacroSelect (GtkWidget * widget, gpointer user_data)
{
        int Exist;
        char *string;
        vMacroHeader *MacroHeader;
        string = gtk_combo_box_get_active_text ((GtkComboBox *) widget);

        Exist = vapiGtkComboBoxGetActiveRow (widget);
        if (Exist >= 0)
        {
                if (SelectedMacroGlobal == -1)
                {
                        v_bypass_init ();
                }
                SelectedMacro = Exist;
                SelectedMacroGlobal = Exist;
                MacroHeader =
                        vapiMacroListSelectItem (GtkMacroEvents.MacroList,
                                                 Exist);
                v_bypass_set_updatable (vTRUE);
                vapiGtkMacroTable ();
        }
        else
        {
                vapiGtkMacrosTablesCleanToDefault ();
                SelectedMacroGlobal = -1;
                SelectedMacro = -1;
        }
}

void
vapiGtkMacroLauchDeleteDialog (GtkWidget * widget, gpointer user_data)
{
        vMacroHeader *MacroHeader;
        if (vapiGtkMacroCheckSelected ())
        {
                return;
        }
        if (vapiGtkMacroIsItRunning ())
        {
                return;
        }
        MacroHeader =
                vapiMacroListSelectItem (GtkMacroEvents.MacroList,
                                         SelectedMacro);
        gtk_label_set_text ((GtkLabel *) GtkMacroEvents.
                            lblMacroDelete,
                            g_strdup_printf
                            ("Tem a certeza que deseja eliminar a Tarefa com o nome: \n %s",
                             MacroHeader->MacroName));
        gtk_widget_show (GtkMacroEvents.dialogMacroDelete);
}

void
vapiGtkMacroLaunchMacroOpen (GtkWidget * widget,
                             vOperationList * OperationList)
{
        GtkWidget *chooser;
        GtkWidget *preview_macro_label;
        GtkWidget *preview_macro_name;
        GtkWidget *preview_pack;
        GtkWidget *preview_separator;
        preview_pack = gtk_vbox_new (FALSE, 0);
        gtk_widget_set_size_request (preview_pack, 260, -1);
        preview_macro_label = gtk_label_new ("");
        gtk_label_set_markup ((GtkLabel *)
                              preview_macro_label,
                              "<b><span size=\"large\"> Nome da Macro</span></b>");
        gtk_box_pack_start ((GtkBox *) preview_pack,
                            preview_macro_label, FALSE, FALSE, 6);
        preview_separator = gtk_hseparator_new ();
        gtk_box_pack_start ((GtkBox *) preview_pack,
                            preview_separator, FALSE, FALSE, 0);
        preview_macro_name = gtk_label_new ("");
        gtk_box_pack_start ((GtkBox *) preview_pack,
                            preview_macro_name, FALSE, FALSE, 4);
        chooser =
                gtk_file_chooser_dialog_new
                ("Carregar Macro de ficheiro", NULL,
                 GTK_FILE_CHOOSER_ACTION_OPEN, NULL, NULL);
        /*
         * Adicionar botões de ok e cancel.
         */
        gtk_dialog_add_buttons ((GtkDialog *) chooser,
                                "gtk-cancel",
                                GTK_RESPONSE_CANCEL,
                                "gtk-open", GTK_RESPONSE_OK, NULL);
        gtk_file_chooser_set_preview_widget_active ((GtkFileChooser *)
                                                    chooser, TRUE);
        gtk_file_chooser_set_preview_widget ((GtkFileChooser *) chooser,
                                             preview_pack);
        gtk_file_chooser_add_filter ((GtkFileChooser *) chooser,
                                     vapiGtkMacroFileFilterOpen ());
        g_signal_connect (G_OBJECT (chooser), "response",
                          G_CALLBACK (vapiGtkMacroOpenFromXML),
                          OperationList);
        g_signal_connect_after (G_OBJECT (chooser), "update-preview",
                                G_CALLBACK (vapiGtkMacroUpdateMacroName),
                                preview_macro_name);
        gtk_widget_show_all (chooser);
        gtk_widget_show_all (preview_pack);
}

void
vapiGtkMacroLaunchMacroSave (GtkWidget * widget,
                             vOperationList * OperationList)
{
        GtkWidget *chooser;
        if (vapiGtkMacroCheckSelected ())
        {
                return;
        }

        chooser =
                gtk_file_chooser_dialog_new
                ("Guardar Macro Para Ficheiro", NULL,
                 GTK_FILE_CHOOSER_ACTION_SAVE, NULL, NULL);
        /*
         * Adicionar botões de ok e cancel.
         */
        gtk_dialog_add_buttons ((GtkDialog *) chooser,
                                "gtk-cancel",
                                GTK_RESPONSE_CANCEL,
                                "gtk-save", GTK_RESPONSE_OK, NULL);
        gtk_file_chooser_set_preview_widget_active ((GtkFileChooser *)
                                                    chooser, FALSE);
        gtk_file_chooser_add_filter ((GtkFileChooser *) chooser,
                                     vapiGtkMacroFileFilterSave ());
        g_signal_connect (G_OBJECT (chooser), "response",
                          G_CALLBACK (vapiGtkMacroSaveToXML), NULL);
        gtk_widget_show_all (chooser);
}

void
vapiGtkMacroUpdateMacroName (GtkWidget * widget,
                             GtkLabel * preview_macro_name)
{
        char *filename, *macro_name;
        filename = gtk_file_chooser_get_filename ((GtkFileChooser *) widget);
        if (filename == NULL)
        {
                return;
        }
        /*
         * Em linux existe a pssibilidade de detectar se estamos perante um 
         *  directorio. Em windows isso não parece ser directo, pelo que a função
         *  para windows ainda não funciona.
         * Como "workaround", verifica-se se o ficheiro tem ".xml", em windows.
         *  Em linux verifica-se mesmo se é directorio.
         */
#ifdef VAPI_OS_LINUX
        if (vapiIsDirectory (filename))
        {
                return;
        }
#else
        if (strstr (filename, ".xml") == NULL)
        {
                return;
        }
#endif
        macro_name = vapiMacroFromXMLSetName (filename);
        if (macro_name == NULL)
        {
                g_free (filename);
                gtk_label_set_text ((GtkLabel *) preview_macro_name, "");
                return;
        }

        gtk_label_set_text ((GtkLabel *) preview_macro_name, macro_name);
        g_free (filename);
        v_debug ("macro preview");
}

void
vapiGtkMacroSelectNext (GtkWidget * widget, vImages * Images)
{
        int SelectedOperation;
        vMacroHeader *MacroHeader;
        vMacroItem *Item;
        if (vapiGtkMacroCheckSelected ())
        {
                return;
        }
        if (vapiGtkMacroIsItRunning ())
        {
                return;
        }
        vapiGtkMacroRunningStart ();
        SelectedOperation = vapiGtkMacroTableGetSelected ();
        if (SelectedOperation < 0)
        {
                SelectedOperation = 0;
        }
        else
        {
                SelectedOperation++;
        }
        if (vapiGtkMacroTableSelectRow (SelectedOperation))
        {
                vapiGtkMacroRunningStop ();
                return;
        }
        MacroHeader = vapiMacroListSelectItem (GtkMacroEvents.MacroList,
                                               SelectedMacro);
        Item = vapiMacroSelectItem (MacroHeader->Macro, SelectedOperation);

        vapiApplyOperation (Images, Item->Operation, Item->Options,
                            MacroHeader->PreviousResult);
        vapiGtkMacroRunningStop ();
        vapiGtkImagesUpdateInterface (Images, gtkImActual);

}

void
vapiGtkMacroStop (GtkWidget * widget, GMutex * mutex)
{
        vapiGtkMacroRunningStop ();
        v_debug ("parar a macro");
}

void
vapiGtkMacroSetBypass (GtkCellRendererToggle * cell_renderer,
                       gchar * path, gpointer user_data)
{
        char *macroTag;
        GtkTreePath *TreePath;
        gint *itemNum;
        TreePath = gtk_tree_path_new_from_string (path);
        itemNum = gtk_tree_path_get_indices (TreePath);
        macroTag = vapiGtkMacroGetMacroTag ();
        v_debug ("macro tag no bypass: %s", macroTag);
        v_bypass_set (macroTag, itemNum[0]);
        vapiGtkMacroTable ();
        free (macroTag);
}

vBoolean
vapiGtkMacroIsItRunning ()
{
        if (MacroRunning)
        {
                v_error_ui ("Existe uma tarefa em execução.");
                return vTRUE;
        }
        return vFALSE;
}

void
vapiGtkMacroSetStopby (GtkCellRendererToggle * cell_renderer,
                       gchar * path, gpointer user_data)
{
        char *macroTag;
        GtkTreePath *TreePath;
        gint *itemNum;
        TreePath = gtk_tree_path_new_from_string (path);
        itemNum = gtk_tree_path_get_indices (TreePath);
        macroTag = vapiGtkMacroGetMacroTag ();
        v_stopby_set (macroTag, itemNum[0]);
        vapiGtkMacroTable ();
        free (macroTag);
}

void
vapiGtkMacroRunningStart ()
{
        v_debug ("vapiGtkMacroRunningStart");
        MacroRunning = vTRUE;
}

void
vapiGtkMacroRunningStop ()
{
        v_debug ("vapiGtkMacroRunningStop");
        MacroRunning = vFALSE;
}

vBoolean
vapiGtkMacroRunningTest ()
{
        if (MacroRunning)
        {
                return vTRUE;
        }
        return vFALSE;
}

---