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

#include <gtk/gtk.h>
#include <glade/glade.h>
#include "vapiImages.h"
#include "vapiMacroList.h"
#include "vapiMacro.h"

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

Este grafo mostra quais são os ficheiros que incluem directamente ou indirectamente este ficheiro:

Ir para o código fonte deste ficheiro.

Estruturas de Dados
struct	_vMacroTablesSelect
Definições de tipos
typedef _vMacroTablesSelect	vMacroTablesSelect
Funções
void	vapiGtkCbMacroStart ()
void	vapiGtkMacroApplyAllMacros ()
char *	vapiGtkMacroGetMacroTag ()
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)
void	vapiGtkMacroTablesApplyUntil (const char *macroTag)
vBoolean	vapiGtkMacroTableSelectRow (int row)
GtkWidget *	vapiGtkMacroTablesGetTable (int notebook_page)

---

Documentação dos tipos

typedef struct _vMacroTablesSelect vMacroTablesSelect

---

Documentação das funções

void vapiGtkCbMacroStart

(

)

Definido na linha 479 do ficheiro vapiGtkMacrosTables.c.

Referências cbMacro, _vMacroTables::cbMacro, MacroList, _vMacroTables::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:

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, _vMacroTables::Images, _vMacroTablesSelect::Images, _vMacroTables::lblMainMacro, _vMacroTablesSelect::Lists, _vMacroTablesSelect::MacroList, MacroList, _vMacroTables::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:

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, MacroList, _vMacroTables::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:

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:

---