src/interface/vapiGtkWindowIOConfigure.c

Ir para a documentação deste ficheiro.

#include "vapiGtkInterface.h"
#include "vapiIO.h"
#include "vapiIOXML.h"
#include "vapiIOList.h"
#include "vapiGtkOptions.h"
#include "vapiGtkWindowIOConfigure.h"
#include "vapiGtkTable.h"

#define NumberOfIOTypes 3
#define NumberOfIOTypesPlusPlus NumberOfIOTypes + 1

GtkWidget *tvIOConfiguredList[NumberOfIOTypesPlusPlus];
GtkWidget *vboxIOConfiguredOptionsContainer;
GtkWidget *OptionsIOConfiguredContainer;
GList *IOConfAuxiliar;
GList *IOConfOptionsData;
GList *IOConfOptionsEvents;

GList **ListsConfigured[3];

int SelectedIOConfigured;

void
vapiGtkWindowIOConfigureInit (GladeXML * xml)
{
        GtkWidget *btIOConfiguredWinEdit;
        GtkWidget *btIOConfiguredRemove;
        GtkWidget *btIOConfiguredWinSaveChanges;

        tvIOConfiguredList[0] =
                glade_xml_get_widget (xml, "tvIOConfiguredInput");
        tvIOConfiguredList[1] =
                glade_xml_get_widget (xml, "tvIOConfiguredOutput");
        tvIOConfiguredList[2] =
                glade_xml_get_widget (xml, "tvIOConfiguredInput_Output");
        tvIOConfiguredList[3] =
                glade_xml_get_widget (xml, "tvIOConfiguredALL");

        vboxIOConfiguredOptionsContainer =
                glade_xml_get_widget (xml,
                                      "vboxIOConfiguredOptionsContainer");
        btIOConfiguredWinEdit = glade_xml_get_widget (xml,
                                                      "btIOConfiguredWinEdit");

        btIOConfiguredRemove = glade_xml_get_widget (xml,
                                                     "btIOConfiguredRemove");

        btIOConfiguredWinSaveChanges = glade_xml_get_widget (xml,
                                                             "btIOConfiguredWinSaveChanges");
        OptionsIOConfiguredContainer = 0;
        IOConfAuxiliar = NULL;
        IOConfOptionsData = NULL;
        IOConfOptionsEvents = NULL;
        ListsConfigured[0] = &IOConfAuxiliar;
        ListsConfigured[1] = &IOConfOptionsData;
        ListsConfigured[2] = &IOConfOptionsEvents;

        SelectedIOConfigured = -1;

        /*
         * Configurar a Tabela.
         */
        vapiGtkWindowIOConfiguredTablesInit ();

        vapiGtkWindowIOConfiguredList ();

        /*
         * FIXME: Necessita de uma função para detectar o IO seleccionado
         
         *g_signal_connect (G_OBJECT (btIOConfiguredWinEdit), "clicked",
         *                G_CALLBACK (vapiGtkWindowIOConfiguredSelect), NULL);
         */
        g_signal_connect (G_OBJECT (btIOConfiguredRemove), "clicked",
                          G_CALLBACK (vapiGtkWindowIOConfiguredRemove), NULL);

        g_signal_connect (G_OBJECT (btIOConfiguredWinSaveChanges), "clicked",
                          G_CALLBACK (vapiGtkWindowIOConfiguredSaveChanges),
                          NULL);
}

void
vapiGtkWindowIOConfiguredList ()
{

        int i, ConfiguredListSize, type;
        vIOConfigured *IOConfigured;
        GtkTreeIter iter;
        GtkTreeStore *treeStore[NumberOfIOTypesPlusPlus];

        /*
         * Iniciar variaveis e treeStores.
         */
        SelectedIOConfigured = -1;

        for (i = 0; i <= NumberOfIOTypes; i++)
        {
                treeStore[i] =
                        gtk_tree_store_new (3, G_TYPE_INT, G_TYPE_STRING,
                                            G_TYPE_STRING);
        }

        ConfiguredListSize = v_list_count_elements (GlobalIOListConfigured);

        if (ConfiguredListSize > 0)
        {

                for (i = 0; i < ConfiguredListSize; i++)
                {
                        IOConfigured =
                                (vIOConfigured *)
                                v_list_get (GlobalIOListConfigured, i);
                        /*
                         * Adicionar Nova linha na tabela.
                         */
                        v_debug ("aqui %d", IOConfigured->IO->IOtype);
                        switch (IOConfigured->IO->IOtype)
                        {
                        case vInput:
                        case vInputN:
                        {
                                type = 0;
                                break;
                        }

                        case vOutput:
                        case vOutputN:
                        {
                                type = 1;
                                break;
                        }
                        case vIOBoth:
                        case vIOBothN:
                        {
                                type = 2;
                                break;
                        }
                        default:
                        {
                                type = NumberOfIOTypes;
                                v_error ("Tipo de IO não definido");
                                break;
                        }
                        }
                        v_debug ("ali %d", type);
                        if (type >= 0 && type < NumberOfIOTypes)
                        {
                                v_debug ("Type of IO %d", type);
                                gtk_tree_store_append (treeStore[type], &iter,
                                                       NULL);
                                gtk_tree_store_set (treeStore[type], &iter, 0,
                                                    i, 1,
                                                    vapiIOTypeToString
                                                    (IOConfigured->IO->
                                                     IOtype), 2,
                                                    IOConfigured->IO->IOname,
                                                    -1);

                                gtk_tree_store_append (treeStore
                                                       [NumberOfIOTypes],
                                                       &iter, NULL);
                                gtk_tree_store_set (treeStore
                                                    [NumberOfIOTypes], &iter,
                                                    0, i, 1,
                                                    vapiIOTypeToString
                                                    (IOConfigured->IO->
                                                     IOtype), 2,
                                                    IOConfigured->IO->IOname,
                                                    -1);
                        }
                }
        }
        for (i = 0; i <= NumberOfIOTypes; i++)
        {
                gtk_tree_view_set_model (GTK_TREE_VIEW
                                         (tvIOConfiguredList[i]),
                                         GTK_TREE_MODEL (treeStore[i]));
        }

}

void
vapiGtkWindowIOConfiguredSelect (GtkWidget * widget, GtkTreePath * path,
                                 GtkTreeIter * iter, gpointer data)
{
        vIOConfigured *IOConfigured;
        GtkWidget *Table;
        GValue gvalue = { 0, };
        if (path == NULL)
        {
                return;
        }
        Table = vapiGtkWindowIOConfiguredGetActiveTable ();

        if (Table == NULL)
        {
                return;
        }

        vapiGtkTableGetValueFromSelection (Table, &gvalue, 0);
        SelectedIOConfigured = (int) g_value_get_int (&gvalue);
        IOConfigured = v_list_get (GlobalIOListConfigured, SelectedIOConfigured);

        vapiGtkOptionsCreate
                (vboxIOConfiguredOptionsContainer,
                 &OptionsIOConfiguredContainer,
                 ListsConfigured, IOConfigured->Options,
                 IOConfigured->IO->OptionsSettings, NULL, NULL, NULL);

        gtk_box_reorder_child ((GtkBox *) vboxIOConfiguredOptionsContainer,
                               OptionsIOConfiguredContainer, 1);
}

void
vapiGtkWindowIOConfiguredTablesInit ()
{
        GtkCellRenderer *renderer;
        int i;

        for (i = 0; i <= NumberOfIOTypes; i++)
        {

                renderer = gtk_cell_renderer_text_new ();
                gtk_tree_selection_set_mode (gtk_tree_view_get_selection
                                             (GTK_TREE_VIEW
                                              (tvIOConfiguredList[i])),
                                             GTK_SELECTION_SINGLE);

                gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW
                                                             (tvIOConfiguredList
                                                              [i]), -1, "id",
                                                             renderer, "text",
                                                             0, NULL);

                gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW
                                                             (tvIOConfiguredList
                                                              [i]), -1,
                                                             "Tipo", renderer,
                                                             "text", 1, NULL);
                gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW
                                                             (tvIOConfiguredList
                                                              [i]), -1,
                                                             "Nome", renderer,
                                                             "text", 2, NULL);

                g_signal_connect (G_OBJECT (tvIOConfiguredList[i]),
                                  "row_activated",
                                  G_CALLBACK
                                  (vapiGtkWindowIOConfiguredSelect), NULL);

        }


        g_signal_connect (G_OBJECT (tvIOConfiguredList[NumberOfIOTypes]),
                          "row_activated",
                          G_CALLBACK (vapiGtkWindowIOConfiguredSelect), NULL);
}

GtkWidget *
vapiGtkWindowIOConfiguredGetActiveTable ()
{
        int selectedRow, i;
        for (i = 0; i <= NumberOfIOTypes; i++)
        {
                selectedRow =
                        vapiGtkTableGetSelectedRow (tvIOConfiguredList[i]);

                if (selectedRow >= 0)
                {
                        v_debug ("é a tabela numero %d", i);
                        return tvIOConfiguredList[i];
                }
        }
        return NULL;
}

void
vapiGtkWindowIOConfiguredRemove (GtkWidget * widget, gpointer user_data)
{
        GtkWidget *Table;
        GValue gvalue = {
                0,
        };

        int IOConfiguredIndex;

        Table = vapiGtkWindowIOConfiguredGetActiveTable ();
        if (Table == NULL)
        {
                return;
        }
        vapiGtkTableGetValueFromSelection (Table, &gvalue, 0);
        IOConfiguredIndex = (int) g_value_get_int (&gvalue);

        vapiIOConfiguredDelete (IOConfiguredIndex);

        vapiGtkWindowIOConfiguredList ();
        vapiIOConfiguredToXML ();
}

void
vapiGtkWindowIOConfiguredSaveChanges (GtkWidget * widget, gpointer user_data)
{
        vOptions *Options;
        GtkWidget *Table;
        GValue gvalue = { 0, };
        int IOConfiguredIndex;
        vIOConfigured *IOConfigured;
        Table = vapiGtkWindowIOConfiguredGetActiveTable ();

        if (Table == NULL)
        {
                return;
        }
        vapiGtkTableGetValueFromSelection (Table, &gvalue, 0);
        IOConfiguredIndex = (int) g_value_get_int (&gvalue);
        IOConfigured = v_list_get (GlobalIOListConfigured, IOConfiguredIndex);

        Options = vapiOptionsInit (IOConfigured->IO->OptionsSettings);
        vapiGtkOptionsGetOptions (Options, IOConfigured->IO->OptionsSettings,
                                  NULL, &IOConfOptionsData);
        vOptionsFree (IOConfigured->Options,
                      IOConfigured->IO->OptionsSettings, NULL);
        IOConfigured->Options=Options;
        
        vapiIOConfiguredToXML ();
}

---