src/interface/vapiGtkMacrosTables.c

Ir para a documentação deste ficheiro.

#include <gtk/gtk.h>
#include <glade/glade.h>
#include "vapiMacroList.h"
#include "vapiMacro.h"
#include "vapiGtkMacrosTables.h"
#include "vapiGtkEventsMacros.h"
#include "vapiGtkInterface.h"
#include "vapiGtkTable.h"
#include "vapiGtkMacro.h"
#include "vapiMacroBypass.h"

#define ByPassColumnName "Executar"
#define StopByColumnName "Mostrar"

//#define USE_SCROLLED_WINDOWS

static struct _vMacroTables
{
        GtkWidget *MacroNotebook;
        GtkWidget *lblMainMacro;
        GtkWidget *MainMacroTable;
        vMacroList *MacroList;
        gulong NotebookEventId;
        GtkWidget *cbMacro;
        vImages *Images;
} MacroTables;

typedef struct _vMacroTagDecode
{
        int *Indexes;
        int NumberOfIndexes;
        char *MacroName;
} vMacroTagDecode;

vMacroTablesSelect *MacroTablesSelect;


/*
 * Protótipos.
 */
static void vapiGtkMacroTagDecodeAddIndex (vMacroTagDecode * MacroTagDecode,
                                           int newIndex);

static void vMacroTagDecodeFree (vMacroTagDecode * vFree);

vMacroTagDecode *vapiGtkTablesMacroTagDecoder (const char *macroTag);

static char *vapiGtkMacroMacroTagEncode (vMacroTagDecode * MacroTagDecode);

static int vapiGtkMacroTablesAddTable (GtkWidget * table, GtkWidget * label);

static const char *vapiGtkMacroTablesGetMacroTag (int notebook_page);

void
vapiGtkMacrosTablesInit (GladeXML * xml, vMacroList * MacroList,
                         GList ** List0, GList ** List1, GList ** List2,
                         vImages * Images)
{
        GtkCellRenderer *renderer;

        MacroTablesSelect = malloc (sizeof (vMacroTablesSelect));;
        MacroTables.MacroNotebook =
                glade_xml_get_widget (xml, "MacroNotebook");
        MacroTables.lblMainMacro = glade_xml_get_widget (xml, "lblMainMacro");
        MacroTables.MainMacroTable = glade_xml_get_widget (xml, "treeMacro");
        MacroTablesSelect->txtOperation =
                glade_xml_get_widget (xml, "txtOperation");
        MacroTables.cbMacro = glade_xml_get_widget (xml, "cbMacro");
        MacroTablesSelect->imActual = glade_xml_get_widget (xml, "imActual");
        MacroTables.MacroList = MacroList;
        MacroTablesSelect->Images = Images;
        MacroTables.Images = Images;
        MacroTablesSelect->MacroList = MacroList;

        MacroTablesSelect->Lists[0] = List0;
        MacroTablesSelect->Lists[1] = List1;
        MacroTablesSelect->Lists[2] = List2;

        gtk_notebook_set_scrollable ((GtkNotebook *) MacroTables.
                                     MacroNotebook, TRUE);
        gtk_notebook_set_show_tabs ((GtkNotebook *) MacroTables.
                                    MacroNotebook, TRUE);


        gtk_tree_selection_set_mode (gtk_tree_view_get_selection
                                     (GTK_TREE_VIEW
                                      (MacroTables.MainMacroTable)),
                                     GTK_SELECTION_SINGLE);

        renderer = gtk_cell_renderer_text_new ();
        gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW
                                                     (MacroTables.
                                                      MainMacroTable), -1,
                                                     "id", renderer, "text",
                                                     0, NULL);

        renderer = gtk_cell_renderer_toggle_new ();
        g_signal_connect (renderer, "toggled",
                          G_CALLBACK (vapiGtkMacroSetStopby), NULL);
        g_object_set (renderer, "activatable", TRUE, NULL);
        gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW
                                                     (MacroTables.
                                                      MainMacroTable), -1,
                                                     StopByColumnName,
                                                     renderer, "active", 1,
                                                     NULL);


        renderer = gtk_cell_renderer_toggle_new ();
        g_signal_connect (renderer, "toggled",
                          G_CALLBACK (vapiGtkMacroSetBypass), NULL);
        g_object_set (renderer, "activatable", TRUE, NULL);
        gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW
                                                     (MacroTables.
                                                      MainMacroTable), -1,
                                                     ByPassColumnName,
                                                     renderer, "active", 2,
                                                     NULL);


        renderer = gtk_cell_renderer_text_new ();
        gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW
                                                     (MacroTables.
                                                      MainMacroTable), -1,
                                                     "Operação", renderer,
                                                     "text", 3, NULL);
        /*
         * Adicionar uma linha em banco para apenas aparecer o título da Coluna
         */
        vapiGtkMacrosTablesCleanToDefault ();

        MacroTables.NotebookEventId =
                g_signal_connect_after (G_OBJECT (MacroTables.MacroNotebook),
                                        "switch-page",
                                        G_CALLBACK
                                        (vapiGtkMacrosTableSetSelectedMacro),
                                        NULL);

        g_signal_connect (G_OBJECT (MacroTables.MainMacroTable),
                          "row_activated",
                          G_CALLBACK (vapiGtkMacroSelectItem),
                          MacroTablesSelect);


        g_signal_connect (G_OBJECT (MacroTables.cbMacro), "changed",
                          G_CALLBACK (vapiGtkMacroSelect), NULL);

}

static void
vapiGtkMacrosTablesClean ()
{
        int n_pages, i;

        n_pages =
                gtk_notebook_get_n_pages ((GtkNotebook *) MacroTables.
                                          MacroNotebook);

        if (n_pages == 1)
        {
                return;
        }
        for (i = (n_pages - 1); i > 0; i--)
        {

                gtk_notebook_remove_page ((GtkNotebook *) MacroTables.
                                          MacroNotebook, i);
        }
}

void
vapiGtkMacrosTablesCleanToDefault ()
{
        GtkTreeStore *treeStore;

        vapiGtkMacrosTablesClean ();
        gtk_label_set_text ((GtkLabel *) MacroTables.lblMainMacro,
                            "Tarefa Principal");
        treeStore =
                gtk_tree_store_new (3, G_TYPE_INT, G_TYPE_OBJECT,
                                    G_TYPE_STRING);

        gtk_tree_view_set_model (GTK_TREE_VIEW (MacroTables.MainMacroTable),
                                 GTK_TREE_MODEL (treeStore));
        g_object_unref (treeStore);
}

void
vapiGtkMacroTable ()
{
        GtkTreeStore *treeStore;
        int macro_number;
        vMacroHeader *MacroHeader;

        if (SelectedMacroGlobal == -1)
        {
                return;
        }
        g_signal_handler_block (MacroTables.MacroNotebook,
                                MacroTables.NotebookEventId);
        vapiGtkMacrosTablesClean ();
        v_bypass_reload ();
        macro_number = SelectedMacroGlobal;
        MacroHeader =
                vapiMacroListSelectItem (MacroTables.MacroList, macro_number);

        gtk_label_set_text ((GtkLabel *) MacroTables.lblMainMacro,
                            MacroHeader->MacroName);
        v_bypass_append ("0", v_list_count_elements (MacroHeader->Macro));
        treeStore = vapiGtkMacroTableModel (MacroHeader, "0");
        v_bypass_set_updatable (vFALSE);

        gtk_tree_view_set_model (GTK_TREE_VIEW (MacroTables.MainMacroTable),
                                 GTK_TREE_MODEL (treeStore));

        g_object_unref (treeStore);

        g_signal_handler_unblock (MacroTables.MacroNotebook,
                                  MacroTables.NotebookEventId);
}

GtkTreeStore *
vapiGtkMacroTableModel (vMacroHeader * MacroHeader, const char *macroTag)
{

        int i, total, second_macro;
        char *newID;
        vMacroItem *item;
        GtkTreeIter iter;
        GtkTreeStore *treeStore;
        /*
         * Iniciar conteudo da Tabela Macro.
         */
        if (macroTag == NULL)
        {
                treeStore =
                        gtk_tree_store_new (4, G_TYPE_INT, G_TYPE_BOOLEAN,
                                            G_TYPE_BOOLEAN, G_TYPE_STRING);
        }
        else
        {
                treeStore =
                        gtk_tree_store_new (4, G_TYPE_STRING, G_TYPE_BOOLEAN,
                                            G_TYPE_BOOLEAN, G_TYPE_STRING);
        }

        if (MacroHeader == NULL)
        {
                goto set_store;
        }


        total = vapiMacroCountElements (MacroHeader->Macro);
        for (i = 0; i < total; i++)
        {
                item = vapiMacroSelectItem (MacroHeader->Macro, i);
                /*
                 * Adicionar Nova linha na tabela.
                 */
                gtk_tree_store_append (treeStore, &iter, NULL);
                if (macroTag != NULL)
                {
                        newID = g_strdup_printf ("%s.%d", macroTag, i);
                        gtk_tree_store_set (treeStore, &iter, 0, newID, 1,
                                            v_stopby_get (macroTag, i), 2,
                                            v_bypass_get (macroTag, i), 3,
                                            item->Operation->name, -1);
                        g_free (newID);
                }
                else
                {
                        gtk_tree_store_set (treeStore, &iter, 0, i, 1,
                                            v_stopby_get (macroTag, i), 2,
                                            v_bypass_get (macroTag, i), 3,
                                            item->Operation->name, -1);
                }
                v_debug ("Nome da Macro %s", item->Operation->name);
                if (!strcmp (item->Operation->name, "Executar Tarefa")
                    && strcmp (item->Options->chars[0].ch,
                               MacroHeader->MacroName))
                {
                        second_macro =
                                vapiMacroListMacroExist (MacroTables.
                                                         MacroList,
                                                         item->Options->
                                                         chars[0].ch, 0);
                        v_debug ("numero da segunda macro %d", second_macro);
                        if (second_macro >= 0)
                        {
                                vapiGtkMacroTableAux (second_macro, macroTag,
                                                      i);
                        }
                }
        }
      set_store:
        return treeStore;
}

void
vapiGtkMacroTableAux (int macro_number, const char *previousMacroTag,
                      int operationNumber)
{
        /*
         * Adicionar uma Macro Secundária.
         */
        vMacroHeader *MacroHeader;
        GtkWidget *tempLabel;
        GtkWidget *tempTable;
        int book_page_number;
        GtkTreeStore *treeStore;
        char *macroTag, *pageLabel;

        if (macro_number < 0)
        {
                return;
        }
        MacroHeader =
                vapiMacroListSelectItem (MacroTables.MacroList, macro_number);
        macroTag = vapiMacroTag (previousMacroTag, operationNumber);
        v_bypass_append (macroTag,
                         v_list_count_elements (MacroHeader->Macro));
        pageLabel =
                g_strdup_printf ("%s %s", macroTag, MacroHeader->MacroName);
        tempLabel = gtk_label_new (pageLabel);

        tempTable = vapiGtkMacrosTablesCreateTable ();

        treeStore = vapiGtkMacroTableModel (MacroHeader, macroTag);

        gtk_tree_view_set_model (GTK_TREE_VIEW (tempTable),
                                 GTK_TREE_MODEL (treeStore));

        book_page_number = vapiGtkMacroTablesAddTable (tempTable, tempLabel);

        g_object_unref (treeStore);
        v_debug ("esta mcro é a seleccionada?: %d, %d",
                 SelectedMacro, macro_number);

        if (SelectedMacro == macro_number)
        {
                v_debug ("esta mcro é a seleccionada: %d, %d, %d",
                         SelectedMacro, macro_number, book_page_number);

                gtk_notebook_set_current_page ((GtkNotebook *) MacroTables.
                                               MacroNotebook,
                                               book_page_number);

        }
}

GtkWidget *
vapiGtkMacrosTablesCreateTable ()
{
        GtkCellRenderer *renderer;
        GtkWidget *tempTable;
        GtkTreeSelection *selection;

        tempTable = gtk_tree_view_new ();


        selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tempTable));
        gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);

        renderer = gtk_cell_renderer_text_new ();
        gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW
                                                     (tempTable), -1,
                                                     "id", renderer, "text",
                                                     0, NULL);
        renderer = gtk_cell_renderer_toggle_new ();

        g_signal_connect (renderer, "toggled",
                          G_CALLBACK (vapiGtkMacroSetStopby), NULL);
        g_object_set (renderer, "activatable", TRUE, NULL);
        gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW
                                                     (tempTable), -1,
                                                     StopByColumnName,
                                                     renderer, "active", 1,
                                                     NULL);
        renderer = gtk_cell_renderer_toggle_new ();

        g_signal_connect (renderer, "toggled",
                          G_CALLBACK (vapiGtkMacroSetBypass), NULL);
        g_object_set (renderer, "activatable", TRUE, NULL);
        gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW
                                                     (tempTable), -1,
                                                     ByPassColumnName,
                                                     renderer, "active", 2,
                                                     NULL);


        renderer = gtk_cell_renderer_text_new ();
        gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW
                                                     (tempTable), -1,
                                                     "Operação", renderer,
                                                     "text", 3, NULL);
        return tempTable;
}

int
vapiGtkMacroTableGetSelected ()
{
        int selectedRow;
        GtkWidget *tempTable;

        tempTable = vapiGtkMacroTablesGetTable (-1);

        selectedRow = vapiGtkTableGetSelectedRow (tempTable);
        gtk_widget_grab_focus (tempTable);
        return selectedRow;
}

void
vapiGtkMacrosTableSetSelectedMacro (GtkNotebook * notebook,
                                    gint arg1, gpointer user_data)
{
        int n_page;
        const char *macroTag;
        vMacroTagDecode *MacroTagDecode;
        n_page = gtk_notebook_get_current_page (notebook);

        if (n_page == 0 && SelectedMacroGlobal >= 0)
        {
                SelectedMacro = SelectedMacroGlobal;
                return;
        }
        if (n_page == 0 && SelectedMacroGlobal < 0)
        {
                SelectedMacro = -1;
                return;
        }
        macroTag = vapiGtkMacroTablesGetMacroTag (n_page);

        MacroTagDecode = vapiGtkTablesMacroTagDecoder (macroTag);

        SelectedMacro =
                vapiMacroListMacroExist (MacroTables.MacroList,
                                         MacroTagDecode->MacroName, 0);
        if (SelectedMacro < 0)
        {
                /*
                 * Confirmar que fic a -1;
                 */
                SelectedMacro = -1;
        }
        vMacroTagDecodeFree (MacroTagDecode);
        v_debug ("selected Macro agora %d", SelectedMacro);
}

vBoolean
vapiGtkMacroTableSelectRow (int row)
{
        GtkWidget *child;

        child = vapiGtkMacroTablesGetTable (-1);
        return (vapiGtkTableSelectRow (child, row));
}

void
vapiGtkMacroApplyAllMacros ()
{
        int currentNotebookPage;
        const char *macroTag;

        currentNotebookPage =
                gtk_notebook_get_current_page ((GtkNotebook *) MacroTables.
                                               MacroNotebook);
        if (currentNotebookPage == 0)
        {
                return;
        }
        macroTag = vapiGtkMacroTablesGetMacroTag (currentNotebookPage);
        vapiGtkMacroTablesApplyUntil (macroTag);
}

void
vapiGtkCbMacroStart ()
{

        int i, ListSize;
        GtkTreeStore *treeStore;
        GtkTreeIter iter, iter2;
        vMacroHeader *MacroHeader;
        treeStore = gtk_tree_store_new (1, G_TYPE_STRING);
        ListSize = vapiMacroListCountElements (MacroTables.MacroList);
        if (ListSize > 0)
        {
                for (i = 0; i < ListSize; i++)
                {
                        MacroHeader =
                                vapiMacroListSelectItem (MacroTables.
                                                         MacroList, i);
                        gtk_tree_store_append (treeStore, &iter, NULL);
                        gtk_tree_store_set (treeStore, &iter, 0,
                                            MacroHeader->MacroName, -1);
                        if (i == SelectedMacro)
                        {
                                iter2 = iter;
                        }

                }
        }
        gtk_combo_box_set_model ((GtkComboBox *) MacroTables.cbMacro,
                                 GTK_TREE_MODEL (treeStore));
        if (SelectedMacro > -1)
        {
                gtk_combo_box_set_active_iter ((GtkComboBox *) MacroTables.
                                               cbMacro, &iter2);
        }
        g_object_unref (treeStore);
}

void
vapiGtkMacroTablesApplyUntil (const char *macroTag)
{
        vMacroTagDecode *MacroTagDecode;
        vMacroHeader *MacroHeader, *PreviousMacroHeader;
        vMacroItem *item;
        int index, macro_number, i;
        /*
         * MacroTag tem o formato: MacroDeOrigem:OperaçãoEmqueAMacroÉexecutada"
         *  macro de origem é sempre 0.
         */

        MacroTagDecode = vapiGtkTablesMacroTagDecoder (macroTag);

        /*
         * Primeiro: Aplica-se a MacroBase até à operação indice-1.
         */
        MacroHeader =
                vapiMacroListSelectItem (MacroTables.MacroList,
                                         SelectedMacroGlobal);
        i = 1;
        index = MacroTagDecode->Indexes[i];
        vResultReset (MacroHeader->PreviousResult);

        MacroHeader->PreviousResult->macroTag = v_printf ("0");
        vapiApplyMacroUntil (MacroHeader, MacroTables.Images, (index - 1));

        if (i == MacroTagDecode->NumberOfIndexes - 1)
        {
                vMacroTagDecodeFree (MacroTagDecode);
                return;
        }
        for (; i < MacroTagDecode->NumberOfIndexes; i++)
        {
                item = vapiMacroSelectItem (MacroHeader->Macro, index);
                macro_number =
                        vapiMacroListMacroExist (MacroTables.MacroList,
                                                 item->Options->chars[0].ch,
                                                 0);
                if (macro_number >= 0)
                {
                        PreviousMacroHeader = MacroHeader;
                        MacroHeader =
                                vapiMacroListSelectItem (MacroTables.
                                                         MacroList,
                                                         macro_number);
                        index = MacroTagDecode->Indexes[i];
                }
                else
                {
                        index = MacroTagDecode->Indexes[++i];
                        continue;
                }
                vResultReset (MacroHeader->PreviousResult);
                MacroHeader->PreviousResult->macroTag =
                        v_printf ("%s",
                                  PreviousMacroHeader->PreviousResult->
                                  macroTag);
                vapiApplyMacroUntil (MacroHeader, MacroTables.Images,
                                     (index - 1));
        }
        vMacroTagDecodeFree (MacroTagDecode);
}

vMacroTagDecode *
vapiGtkTablesMacroTagDecoder (const char *macroTag)
{
        char CharPtr, *indexString, *indexString2;
        vMacroTagDecode *MacroTagDecode = malloc (sizeof (vMacroTagDecode));
        int newIndex, len, j;
        /*
         * Init MacroTagDecode.
         */
        MacroTagDecode->NumberOfIndexes = 0;

        len = strlen (macroTag);
        indexString = v_printf ("");
        printf ("original %s\n", macroTag);
        for (j = 0; j < len; j++)
        {
                CharPtr = macroTag[j];
                printf ("char seleccionado %c\n", CharPtr);
                if (CharPtr == ':' || CharPtr == '.')
                {
                        /*
                         * chegou a 2 pontos ':'.
                         */
                        newIndex = atoi (indexString);
                        vapiGtkMacroTagDecodeAddIndex (MacroTagDecode,
                                                       newIndex);
                        v_debug ("10");
                        v_debug ("numero %d string %s\n",
                                 MacroTagDecode->Indexes[MacroTagDecode->
                                                         NumberOfIndexes - 1],
                                 indexString);
                        free (indexString);
                        indexString = v_printf ("");
                        continue;
                }
                if (CharPtr == ' ')
                {
                        newIndex = atoi (indexString);
                        vapiGtkMacroTagDecodeAddIndex (MacroTagDecode,
                                                       newIndex);
                        v_debug ("numero %d string %s\n",
                                 MacroTagDecode->Indexes[MacroTagDecode->
                                                         NumberOfIndexes - 1],
                                 indexString);
                        free (indexString);
                        indexString = strchr (macroTag, ' ');
                        v_debug ("nome da macro :%s", indexString);
                        MacroTagDecode->MacroName =
                                v_printf ("%s", ++indexString);
                        return MacroTagDecode;
                }
                indexString2 = indexString;
                indexString = v_printf ("%s%c", indexString2, CharPtr);
                free (indexString2);
        }
        return MacroTagDecode;
}

static void
vapiGtkMacroTagDecodeAddIndex (vMacroTagDecode * MacroTagDecode, int newIndex)
{
        if (MacroTagDecode->NumberOfIndexes == 0)
        {
                MacroTagDecode->Indexes = malloc (sizeof (int));
                ++MacroTagDecode->NumberOfIndexes;
        }
        else
        {
                MacroTagDecode->Indexes =
                        realloc (MacroTagDecode->Indexes,
                                 ++MacroTagDecode->NumberOfIndexes *
                                 sizeof (int));
        }
        MacroTagDecode->Indexes[MacroTagDecode->NumberOfIndexes - 1] =
                newIndex;
}
static void
vMacroTagDecodeFree (vMacroTagDecode * vFree)
{
        free (vFree->Indexes);
        free (vFree->MacroName);
        free (vFree);
}

char *
vapiGtkMacroMacroTagEncode (vMacroTagDecode * MacroTagDecode)
{
        int i;
        char *tempMacroTag, *macroTag;


        tempMacroTag = v_printf ("%d", MacroTagDecode->Indexes[0]);
        macroTag = tempMacroTag;
        for (i = 1; i < MacroTagDecode->NumberOfIndexes; i++)
        {
                macroTag =
                        v_printf ("%s:%d", tempMacroTag,
                                  MacroTagDecode->Indexes[i]);
                free (tempMacroTag);
                tempMacroTag = macroTag;
        }
        return macroTag;
}

char *
vapiGtkMacroGetMacroTag ()
{
        int current_notebook_page;
        const gchar *tab_label;
        vMacroTagDecode *MacroTagDecode;

        current_notebook_page =
                gtk_notebook_get_current_page ((GtkNotebook *) MacroTables.
                                               MacroNotebook);
        if (current_notebook_page == 0)
        {
                return v_printf ("0");
        }

        tab_label = vapiGtkMacroTablesGetMacroTag (current_notebook_page);

        MacroTagDecode = vapiGtkTablesMacroTagDecoder (tab_label);

        return vapiGtkMacroMacroTagEncode (MacroTagDecode);
}

GtkWidget *
vapiGtkMacroTablesGetTable (int notebook_page)
{
        GtkWidget *table;
        GtkWidget *NotebookChild;

        if (notebook_page < 0)
        {
                notebook_page =
                        gtk_notebook_get_current_page ((GtkNotebook *)
                                                       MacroTables.
                                                       MacroNotebook);
        }
#ifndef USE_SCROLLED_WINDOWS
        if (notebook_page == 0)
        {
#endif
                NotebookChild =
                        gtk_notebook_get_nth_page ((GtkNotebook *)
                                                   MacroTables.MacroNotebook,
                                                   notebook_page);

                table = gtk_bin_get_child ((GtkBin *) NotebookChild);
#ifndef USE_SCROLLED_WINDOWS
        }
        else
        {

                table = gtk_notebook_get_nth_page ((GtkNotebook *)
                                                   MacroTables.MacroNotebook,
                                                   notebook_page);
        }
#endif

        return table;
}

static const char *
vapiGtkMacroTablesGetMacroTag (int notebook_page)
{
        GtkWidget *child;
        const char *macroTag;
        if (notebook_page < 0)
        {
                notebook_page =
                        gtk_notebook_get_current_page ((GtkNotebook *)
                                                       MacroTables.
                                                       MacroNotebook);
        }

        child = gtk_notebook_get_nth_page ((GtkNotebook *) MacroTables.
                                           MacroNotebook, notebook_page);
        macroTag =
                gtk_notebook_get_tab_label_text ((GtkNotebook *) MacroTables.
                                                 MacroNotebook, child);

        return macroTag;
}

static int
vapiGtkMacroTablesAddTable (GtkWidget * table, GtkWidget * label)
{
        int book_page;

#ifdef USE_SCROLLED_WINDOWS
        GtkWidget *scrolledWindow;

        scrolledWindow = gtk_scrolled_window_new (NULL, NULL);
        gtk_scrolled_window_set_policy ((GtkScrolledWindow *) scrolledWindow,
                                        GTK_POLICY_AUTOMATIC,
                                        GTK_POLICY_AUTOMATIC);
        gtk_scrolled_window_add_with_viewport ((GtkScrolledWindow *)
                                               scrolledWindow, table);

        book_page = gtk_notebook_append_page ((GtkNotebook *) MacroTables.
                                              MacroNotebook, scrolledWindow,
                                              label);

        gtk_widget_show_all (scrolledWindow);
#else
        book_page = gtk_notebook_append_page ((GtkNotebook *) MacroTables.
                                              MacroNotebook, table, label);
        gtk_widget_show_all (table);

#endif
        gtk_widget_show (label);
        g_signal_connect (G_OBJECT (table),
                          "row_activated",
                          G_CALLBACK (vapiGtkMacroSelectItem),
                          MacroTablesSelect);
        return book_page;
}

---