Referência ao ficheiro src/interface/vapiGtkMacrosTables.c

#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"

Diagrama de dependências de inclusão para vapiGtkMacrosTables.c:

Ir para o código fonte deste ficheiro.

Estruturas de Dados
struct	_vMacroTables
struct	_vMacroTagDecode
Macros
#define	ByPassColumnName   "Executar"
#define	StopByColumnName   "Mostrar"
Definições de tipos
typedef _vMacroTagDecode	vMacroTagDecode
Funções
void	vapiGtkCbMacroStart ()
void	vapiGtkMacroApplyAllMacros ()
char *	vapiGtkMacroGetMacroTag ()
static char *	vapiGtkMacroMacroTagEncode (vMacroTagDecode *MacroTagDecode)
static void	vapiGtkMacrosTablesClean ()
void	vapiGtkMacrosTablesCleanToDefault ()
GtkWidget *	vapiGtkMacrosTablesCreateTable ()
void	vapiGtkMacrosTableSetSelectedMacro (GtkNotebook *notebook, gint arg1, gpointer user_data)
void	vapiGtkMacrosTablesInit (GladeXML *xml, vMacroList *MacroList, GList **List0, GList **List1, GList **List2, vImages *Images)
void	vapiGtkMacroTable ()
void	vapiGtkMacroTableAux (int macro_number, const char *previousMacroTag, int operationNumber)
int	vapiGtkMacroTableGetSelected ()
GtkTreeStore *	vapiGtkMacroTableModel (vMacroHeader *MacroHeader, const char *macroTag)
static int	vapiGtkMacroTablesAddTable (GtkWidget *table, GtkWidget *label)
void	vapiGtkMacroTablesApplyUntil (const char *macroTag)
vBoolean	vapiGtkMacroTableSelectRow (int row)
static const char *	vapiGtkMacroTablesGetMacroTag (int notebook_page)
GtkWidget *	vapiGtkMacroTablesGetTable (int notebook_page)
static void	vapiGtkMacroTagDecodeAddIndex (vMacroTagDecode *MacroTagDecode, int newIndex)
vMacroTagDecode *	vapiGtkTablesMacroTagDecoder (const char *macroTag)
static void	vMacroTagDecodeFree (vMacroTagDecode *vFree)
Variáveis
static struct _vMacroTables	MacroTables
vMacroTablesSelect *	MacroTablesSelect

---

Documentação das macros

#define ByPassColumnName   "Executar"

Definido na linha 12 do ficheiro vapiGtkMacrosTables.c.

Referenciado por vapiGtkMacrosTablesCreateTable() e vapiGtkMacrosTablesInit().

#define StopByColumnName   "Mostrar"

Definido na linha 13 do ficheiro vapiGtkMacrosTables.c.

Referenciado por vapiGtkMacrosTablesCreateTable() e vapiGtkMacrosTablesInit().

---

Documentação dos tipos

typedef struct _vMacroTagDecode vMacroTagDecode

---

Documentação das funções

void vapiGtkCbMacroStart

(

)

Definido na linha 479 do ficheiro vapiGtkMacrosTables.c.

Referências _vMacroTables::cbMacro, cbMacro, _vMacroTables::MacroList, MacroList, _vMacroHeader::MacroName, MacroTables, SelectedMacro, vapiMacroListCountElements() e vapiMacroListSelectItem().

Referenciado por interface_os_linux(), vapiGtkMacroChange(), vapiGtkMacroCreate(), vapiGtkMacroDeleteMacro() e vapiGtkMacroOpenFromXML().

{

        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);
}

Grafo de chamadas desta função:

Here is the caller graph for this function:

void vapiGtkMacroApplyAllMacros

(

)

Definido na linha 462 do ficheiro vapiGtkMacrosTables.c.

Referências MacroTables, vapiGtkMacroTablesApplyUntil() e vapiGtkMacroTablesGetMacroTag().

Referenciado por vapiGtkMacroSelectItem().

{
        int currentNotebookPage;
        const char *macroTag;

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

Grafo de chamadas desta função:

Here is the caller graph for this function:

char* vapiGtkMacroGetMacroTag

(

)

Definido na linha 684 do ficheiro vapiGtkMacrosTables.c.

Referências MacroTables, v_printf(), vapiGtkMacroMacroTagEncode(), vapiGtkMacroTablesGetMacroTag() e vapiGtkTablesMacroTagDecoder().

Referenciado por vapiGtkMacroSelectItem(), vapiGtkMacroSetBypass() e vapiGtkMacroSetStopby().

{
        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);
}

Grafo de chamadas desta função:

Here is the caller graph for this function:

char * vapiGtkMacroMacroTagEncode

(

vMacroTagDecode *

MacroTagDecode

)

[static]

Definido na linha 664 do ficheiro vapiGtkMacrosTables.c.

Referências _vMacroTagDecode::Indexes, _vMacroTagDecode::NumberOfIndexes e v_printf().

Referenciado por vapiGtkMacroGetMacroTag().

{
        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;
}

Grafo de chamadas desta função:

Here is the caller graph for this function:

static void vapiGtkMacrosTablesClean

(

)

[static]

Definido na linha 154 do ficheiro vapiGtkMacrosTables.c.

Referências MacroTables.

Referenciado por vapiGtkMacrosTablesCleanToDefault() e vapiGtkMacroTable().

{
        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);
        }
}

Here is the caller graph for this function:

void vapiGtkMacrosTablesCleanToDefault

(

)

Definido na linha 175 do ficheiro vapiGtkMacrosTables.c.

Referências _vMacroTables::lblMainMacro, MacroTables, _vMacroTables::MainMacroTable e vapiGtkMacrosTablesClean().

Referenciado por vapiGtkMacroDeleteMacro(), vapiGtkMacroSelect() e vapiGtkMacrosTablesInit().

{
        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);
}

Grafo de chamadas desta função:

Here is the caller graph for this function:

GtkWidget* vapiGtkMacrosTablesCreateTable

(

)

Definido na linha 355 do ficheiro vapiGtkMacrosTables.c.

Referências ByPassColumnName, StopByColumnName, vapiGtkMacroSetBypass() e vapiGtkMacroSetStopby().

Referenciado por vapiGtkMacroTableAux().

{
        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;
}

Grafo de chamadas desta função:

Here is the caller graph for this function:

void vapiGtkMacrosTableSetSelectedMacro	(	GtkNotebook *	notebook,
		gint	arg1,
		gpointer	user_data
	)

Definido na linha 416 do ficheiro vapiGtkMacrosTables.c.

Referências _vMacroTables::MacroList, _vMacroTagDecode::MacroName, MacroTables, SelectedMacro, SelectedMacroGlobal, v_debug, vapiGtkMacroTablesGetMacroTag(), vapiGtkTablesMacroTagDecoder(), vapiMacroListMacroExist() e vMacroTagDecodeFree().

Referenciado por vapiGtkMacrosTablesInit().

{
        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);
}

Grafo de chamadas desta função:

Here is the caller graph for this function:

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

Definido na linha 58 do ficheiro vapiGtkMacrosTables.c.

Referências ByPassColumnName, _vMacroTables::cbMacro, _vMacroTablesSelect::imActual, _vMacroTablesSelect::Images, _vMacroTables::Images, _vMacroTables::lblMainMacro, _vMacroTablesSelect::Lists, _vMacroTables::MacroList, MacroList, _vMacroTablesSelect::MacroList, _vMacroTables::MacroNotebook, MacroTables, MacroTablesSelect, _vMacroTables::MainMacroTable, _vMacroTables::NotebookEventId, StopByColumnName, _vMacroTablesSelect::txtOperation, vapiGtkMacroSelect(), vapiGtkMacroSelectItem(), vapiGtkMacroSetBypass(), vapiGtkMacroSetStopby(), vapiGtkMacrosTablesCleanToDefault() e vapiGtkMacrosTableSetSelectedMacro().

Referenciado por interface_os_linux().

{
        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);

}

Grafo de chamadas desta função:

Here is the caller graph for this function:

void vapiGtkMacroTable

(

)

Definido na linha 192 do ficheiro vapiGtkMacrosTables.c.

Referências _vMacroTables::lblMainMacro, _vMacroHeader::Macro, _vMacroTables::MacroList, _vMacroHeader::MacroName, _vMacroTables::MacroNotebook, MacroTables, _vMacroTables::MainMacroTable, _vMacroTables::NotebookEventId, SelectedMacroGlobal, v_bypass_append(), v_bypass_reload(), v_bypass_set_updatable(), v_list_count_elements(), vapiGtkMacrosTablesClean(), vapiGtkMacroTableModel(), vapiMacroListSelectItem() e vFALSE.

Referenciado por vapiGtkMacroAppendItem(), vapiGtkMacroDeleteItem(), vapiGtkMacroInsertItem(), vapiGtkMacroItemMoveDown(), vapiGtkMacroItemMoveToBottom(), vapiGtkMacroItemMoveToTop(), vapiGtkMacroItemMoveUp(), vapiGtkMacroSelect(), vapiGtkMacroSetBypass(), vapiGtkMacroSetStopby() e vapiGtkMacroUpdateItemOptions().

{
        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);
}

Grafo de chamadas desta função:

Here is the caller graph for this function:

void vapiGtkMacroTableAux	(	int	macro_number,
		const char *	previousMacroTag,
		int	operationNumber
	)

Definido na linha 303 do ficheiro vapiGtkMacrosTables.c.

Referências _vMacroHeader::Macro, _vMacroTables::MacroList, _vMacroHeader::MacroName, MacroTables, SelectedMacro, v_bypass_append(), v_debug, v_list_count_elements(), vapiGtkMacrosTablesCreateTable(), vapiGtkMacroTableModel(), vapiGtkMacroTablesAddTable(), vapiMacroListSelectItem() e vapiMacroTag().

Referenciado por vapiGtkMacroTableModel().

{
        /*
         * 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);

        }
}

Grafo de chamadas desta função:

Here is the caller graph for this function:

int vapiGtkMacroTableGetSelected

(

)

Definido na linha 403 do ficheiro vapiGtkMacrosTables.c.

Referências vapiGtkMacroTablesGetTable() e vapiGtkTableGetSelectedRow().

Referenciado por vapiGtkMacroDeleteItem(), vapiGtkMacroInsertItem(), vapiGtkMacroItemMoveDown(), vapiGtkMacroItemMoveToBottom(), vapiGtkMacroItemMoveToTop(), vapiGtkMacroItemMoveUp(), vapiGtkMacroSelectNext() e vapiGtkMacroUpdateItemOptions().

{
        int selectedRow;
        GtkWidget *tempTable;

        tempTable = vapiGtkMacroTablesGetTable (-1);

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

Grafo de chamadas desta função:

Here is the caller graph for this function:

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

Definido na linha 226 do ficheiro vapiGtkMacrosTables.c.

Referências _vChar::ch, _vOptions::chars, _vMacroHeader::Macro, MacroList, _vMacroHeader::MacroName, MacroTables, _vEffect::name, _vMacroItem::Operation, _vMacroItem::Options, v_bypass_get(), v_debug, v_stopby_get(), vapiGtkMacroTableAux(), vapiMacroCountElements(), vapiMacroListMacroExist() e vapiMacroSelectItem().

Referenciado por vapiGtkMacroTable() e vapiGtkMacroTableAux().

{

        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;
}

Grafo de chamadas desta função:

Here is the caller graph for this function:

static int vapiGtkMacroTablesAddTable	(	GtkWidget *	table,
		GtkWidget *	label
	)			[static]

Definido na linha 765 do ficheiro vapiGtkMacrosTables.c.

Referências MacroTables, MacroTablesSelect e vapiGtkMacroSelectItem().

Referenciado por vapiGtkMacroTableAux().

{
        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;
}

Grafo de chamadas desta função:

Here is the caller graph for this function:

void vapiGtkMacroTablesApplyUntil

(

const char *

macroTag

)

Definido na linha 516 do ficheiro vapiGtkMacrosTables.c.

Referências _vChar::ch, _vOptions::chars, _vMacroTables::Images, _vMacroTagDecode::Indexes, _vMacroHeader::Macro, _vMacroTables::MacroList, MacroList, MacroTables, _vMacroResult::macroTag, _vMacroTagDecode::NumberOfIndexes, _vMacroItem::Options, _vMacroHeader::PreviousResult, SelectedMacroGlobal, v_printf(), vapiApplyMacroUntil(), vapiGtkTablesMacroTagDecoder(), vapiMacroListMacroExist(), vapiMacroListSelectItem(), vapiMacroSelectItem(), vMacroTagDecodeFree() e vResultReset().

Referenciado por vapiGtkMacroApplyAllMacros().

{
        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);
}

Grafo de chamadas desta função:

Here is the caller graph for this function:

vBoolean vapiGtkMacroTableSelectRow

(

int

row

)

Definido na linha 453 do ficheiro vapiGtkMacrosTables.c.

Referências vapiGtkMacroTablesGetTable() e vapiGtkTableSelectRow().

Referenciado por vapiGtkMacroItemMoveDown(), vapiGtkMacroItemMoveToBottom(), vapiGtkMacroItemMoveToTop(), vapiGtkMacroItemMoveUp() e vapiGtkMacroSelectNext().

{
        GtkWidget *child;

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

Grafo de chamadas desta função:

Here is the caller graph for this function:

static const char * vapiGtkMacroTablesGetMacroTag

(

int

notebook_page

)

[static]

Definido na linha 743 do ficheiro vapiGtkMacrosTables.c.

Referências MacroTables.

Referenciado por vapiGtkMacroApplyAllMacros(), vapiGtkMacroGetMacroTag() e vapiGtkMacrosTableSetSelectedMacro().

{
        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;
}

Here is the caller graph for this function:

GtkWidget* vapiGtkMacroTablesGetTable

(

int

notebook_page

)

Definido na linha 706 do ficheiro vapiGtkMacrosTables.c.

Referências _vMacroTables::MacroNotebook e MacroTables.

Referenciado por vapiGtkMacroTableGetSelected() e vapiGtkMacroTableSelectRow().

{
        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;
}

Here is the caller graph for this function:

static void vapiGtkMacroTagDecodeAddIndex	(	vMacroTagDecode *	MacroTagDecode,
		int	newIndex
	)			[static]

Definido na linha 638 do ficheiro vapiGtkMacrosTables.c.

Referências _vMacroTagDecode::Indexes e _vMacroTagDecode::NumberOfIndexes.

Referenciado por vapiGtkTablesMacroTagDecoder().

{
        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;
}

Here is the caller graph for this function:

vMacroTagDecode * vapiGtkTablesMacroTagDecoder

(

const char *

macroTag

)

Definido na linha 580 do ficheiro vapiGtkMacrosTables.c.

Referências _vMacroTagDecode::Indexes, _vMacroTagDecode::MacroName, _vMacroTagDecode::NumberOfIndexes, v_debug, v_printf() e vapiGtkMacroTagDecodeAddIndex().

Referenciado por main(), vapiGtkMacroGetMacroTag(), vapiGtkMacrosTableSetSelectedMacro() e vapiGtkMacroTablesApplyUntil().

{
        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;
}

Grafo de chamadas desta função:

Here is the caller graph for this function:

static void vMacroTagDecodeFree

(

vMacroTagDecode *

vFree

)

[static]

Definido na linha 656 do ficheiro vapiGtkMacrosTables.c.

Referências _vMacroTagDecode::Indexes e _vMacroTagDecode::MacroName.

Referenciado por vapiGtkMacrosTableSetSelectedMacro() e vapiGtkMacroTablesApplyUntil().

{
        free (vFree->Indexes);
        free (vFree->MacroName);
        free (vFree);
}

Here is the caller graph for this function:

---

Documentação das variáveis

struct _vMacroTables MacroTables [static]

Use the operations tables inside scrolled windows.

Referenciado por vapiGtkCbMacroStart(), vapiGtkMacroApplyAllMacros(), vapiGtkMacroGetMacroTag(), vapiGtkMacrosTablesClean(), vapiGtkMacrosTablesCleanToDefault(), vapiGtkMacrosTableSetSelectedMacro(), vapiGtkMacrosTablesInit(), vapiGtkMacroTable(), vapiGtkMacroTableAux(), vapiGtkMacroTableModel(), vapiGtkMacroTablesAddTable(), vapiGtkMacroTablesApplyUntil(), vapiGtkMacroTablesGetMacroTag() e vapiGtkMacroTablesGetTable().

vMacroTablesSelect* MacroTablesSelect

Definido na linha 38 do ficheiro vapiGtkMacrosTables.c.

Referenciado por vapiGtkMacroSelectItem(), vapiGtkMacrosTablesInit() e vapiGtkMacroTablesAddTable().

---