src/interface/vapiGtkOptions.c

Ir para a documentação deste ficheiro.

#include "vapiGtkInterface.h"
#include "vapiOptions.h"
#include "vapiGtkOptions.h"
#include "vapiGtkOptionsOperations.h"
#include "vapiGtkEventsOperations.h"
#include "vapiAux.h"

#define OptionWidgetsWidth 80

void
vapiGtkOptionsCreate (GtkWidget * ParentContainer,
                      GtkWidget ** Container, GList ** OptionsList[3],
                      vOptions * Options,
                      vOptionsSettings * OptionsSettings,
                      vGtkOptionsCustomCreate CustomFunc,
                      GCallback EventFunc, vpointer EventData)
{
        int i = 0, j;
        GList *tempList[3], **tempLists[3];
        int widgetsWidth = OptionWidgetsWidth;

        tempList[0] = NULL;
        tempList[1] = NULL;
        tempList[2] = NULL;

        tempLists[0] = &tempList[0];
        tempLists[1] = &tempList[1];
        tempLists[2] = &tempList[2];


        /*
         * Criar Listas
         */
        vapiGtkOptionsFree (Container, OptionsList);
        *Container = gtk_scrolled_window_new (NULL, NULL);

        gtk_scrolled_window_set_policy ((GtkScrolledWindow *) * Container,
                                        GTK_POLICY_AUTOMATIC,
                                        GTK_POLICY_AUTOMATIC);

        gtk_box_pack_start ((GtkBox *)
                            ParentContainer, *Container, TRUE, TRUE, 1);
        gtk_box_reorder_child ((GtkBox *) ParentContainer, *Container, 4);

        *OptionsList[0] =
                g_list_append (*OptionsList[0], gtk_vbox_new (TRUE, 1));

        gtk_scrolled_window_add_with_viewport ((GtkScrolledWindow *)
                                               * Container,
                                               g_list_nth_data (*OptionsList
                                                                [0], 0));
        gtk_box_set_homogeneous ((GtkBox *)
                                 g_list_nth_data (*OptionsList[0], 0), FALSE);


        /*
         * Criar as widgets para as opções.
         * Primeiro, as custom, caso existam.
         */
        if (CustomFunc != NULL)
        {
                i = CustomFunc (Options, OptionsSettings,
                                OptionsList, tempLists,
                                i, widgetsWidth, EventFunc, EventData);
        }

        /*
         * Depois as default.
         */
        i = vapiGtkOptionsCreateDefault (Options, OptionsSettings,
                                         OptionsList, tempLists,
                                         i, widgetsWidth, EventFunc,
                                         EventData);

        /* inserir todos na vbox */
        for (j = 0; j < i; j++)
        {
                gtk_box_pack_start ((GtkBox *)
                                    g_list_nth_data (*OptionsList[0],
                                                     0),
                                    (GtkWidget *)
                                    g_list_nth_data
                                    (tempList[1], j), FALSE, FALSE, 6);
                gtk_box_pack_start ((GtkBox *)
                                    g_list_nth_data (*OptionsList[0],
                                                     0),
                                    (GtkWidget *)
                                    g_list_nth_data (*OptionsList[1],
                                                     j), FALSE, FALSE, 0);
                if (tempList[0] != NULL && j > 0)
                {
                        gtk_box_pack_start ((GtkBox *)
                                            g_list_nth_data (*OptionsList[0],
                                                             0),
                                            (GtkWidget *)
                                            g_list_nth_data (tempList[0],
                                                             j - 1), FALSE,
                                            FALSE, 0);
                }

                tempList[2] =
                        g_list_append (tempList[2], gtk_hseparator_new ());
                gtk_widget_set_size_request (g_list_nth_data
                                             (tempList[2], j), widgetsWidth,
                                             5);

                gtk_box_pack_start ((GtkBox *)
                                    g_list_nth_data (*OptionsList[0],
                                                     0),
                                    (GtkWidget *)
                                    g_list_nth_data (tempList[2],
                                                     j), FALSE, FALSE, 0);

        }
        g_list_free (tempList[0]);
        g_list_free (tempList[1]);
        g_list_free (tempList[2]);
        gtk_widget_show_all (*Container);
}

void
vapiGtkOptionsFree (GtkWidget ** Container, GList ** OptionsList[3])
{
        int listSize, i;
        if (*Container != 0)
        {
                g_list_free (*OptionsList[0]);
                g_list_free (*OptionsList[1]);
                /*
                 * A lista de eventos tem uma estrutura cujo espaço é alocado.
                 * Esse espaço tem que ser libertado.
                 */
                if (*OptionsList[2] != NULL)
                {
                        listSize = g_list_length (*OptionsList[2]);
                        if (listSize > 0)
                        {
                                for (i = 0; i < listSize; i++)
                                {
                                        free (g_list_nth_data
                                              (*OptionsList[2], i));
                                }
                                g_list_free (*OptionsList[2]);
                        }
                }
                gtk_widget_destroy (*Container);
                *Container = 0;
                *OptionsList[0] = NULL;
                *OptionsList[1] = NULL;
                *OptionsList[2] = NULL;
        }


}

int
vapiGtkOptionsCreateDefault (vOptions * Options,
                             vOptionsSettings * OptionsSettings,
                             GList ** OptionsList[3], GList ** tempList[3],
                             int i, int widgetsWidth,
                             GCallback EventFunc, vpointer EventData)
{
        int j, k;
        vapiEventList *eventList;
        if (OptionsSettings->floatsNumber)
        {

                for (j = 0; j < OptionsSettings->floatsNumber; j++)
                {
                        *OptionsList[1] =
                                g_list_append (*OptionsList[1],
                                               vapiGtkOptionsCreateByInterfaceType
                                               (OptionsSettings->
                                                floats[j].interfaceType,
                                                OptionsSettings->
                                                floats[j].min,
                                                OptionsSettings->
                                                floats[j].max,
                                                OptionsSettings->
                                                floats[j].scale,
                                                Options->floats[j]));
                        gtk_widget_set_size_request (g_list_nth_data
                                                     (*OptionsList[1], i),
                                                     widgetsWidth, 35);

                        *tempList[1] =
                                g_list_append (*tempList[1],
                                               gtk_label_new
                                               (OptionsSettings->floats[j].
                                                name));


                        *tempList[2] =
                                g_list_append (*tempList[2],
                                               gtk_hseparator_new ());
                        if (OptionsSettings->floats[j].interfaceType == vBar)
                        {
                                eventList = malloc (sizeof (vapiEventList));
                                eventList->widget
                                        =
                                        g_list_nth_data (*OptionsList[1], i);
                                eventList->eventHandler =
                                        g_signal_connect_after
                                        (G_OBJECT
                                         (g_list_nth_data
                                          (*OptionsList[1],
                                           i)),
                                         "value-changed",
                                         EventFunc, EventData);
                                *OptionsList[2] =
                                        g_list_append (*OptionsList[2],
                                                       eventList);
                        }

                        ++i;
                }
        }
        if (OptionsSettings->intsNumber)
        {

                for (j = 0; j < OptionsSettings->intsNumber; j++)
                {

                        *OptionsList[1] =
                                g_list_append (*OptionsList[1],
                                               vapiGtkOptionsCreateByInterfaceType
                                               (OptionsSettings->
                                                ints[j].interfaceType,
                                                OptionsSettings->
                                                ints[j].min,
                                                OptionsSettings->
                                                ints[j].max,
                                                OptionsSettings->
                                                ints[j].scale,
                                                Options->ints[j]));
                        *tempList[1] =
                                g_list_append (*tempList[1],
                                               gtk_label_new
                                               (OptionsSettings->ints[j].
                                                name));
                        if (OptionsSettings->ints[j].interfaceType == vBar)
                        {
                                eventList = malloc (sizeof (vapiEventList));
                                eventList->widget
                                        =
                                        g_list_nth_data (*OptionsList[1], i);
                                eventList->eventHandler =
                                        g_signal_connect_after
                                        (G_OBJECT
                                         (g_list_nth_data
                                          (*OptionsList[1],
                                           i)),
                                         "value-changed",
                                         EventFunc, EventData);
                                *OptionsList[2] =
                                        g_list_append (*OptionsList[2],
                                                       eventList);
                        }


                        ++i;
                }
        }
        if (OptionsSettings->charsNumber)
        {
                for (j = 0; j < OptionsSettings->charsNumber; j++)
                {
                        *OptionsList[1] =
                                g_list_append (*OptionsList[1],
                                               gtk_entry_new ());
                        *tempList[1] =
                                g_list_append (*tempList[1],
                                               gtk_label_new
                                               (OptionsSettings->chars[j].
                                                name));


                        gtk_entry_set_text ((GtkEntry *)
                                            g_list_nth_data (*OptionsList[1],
                                                             i),
                                            Options->chars[j].ch);
                        ++i;
                }
        }
        if (OptionsSettings->chooseNumber)
        {
                for (j = 0; j < OptionsSettings->chooseNumber; j++)
                {
                        *OptionsList[1] =
                                g_list_append (*OptionsList[1],
                                               gtk_combo_box_new_text ());
                        *tempList[1] =
                                g_list_append (*tempList[1],
                                               gtk_label_new
                                               (OptionsSettings->choose[j].
                                                name));


                        for (k = 0;
                             k <
                             OptionsSettings->choose[j].numberOfChoices; k++)
                        {
                                gtk_combo_box_append_text ((GtkComboBox *)
                                                           g_list_nth_data
                                                           (*OptionsList[1],
                                                            i),
                                                           OptionsSettings->
                                                           choose[j].
                                                           listOfChoices[k].
                                                           ch);
                        }

                        gtk_combo_box_set_active ((GtkComboBox *)
                                                  g_list_nth_data
                                                  (*OptionsList[1], i),
                                                  OptionsSettings->
                                                  choose[j].defaultOption);
                        ++i;
                }
        }
        if (OptionsSettings->booleansNumber)
        {
                for (j = 0; j < OptionsSettings->booleansNumber; j++)
                {
                        *OptionsList[1] =
                                g_list_append (*OptionsList[1],
                                               gtk_check_button_new ());
                        *tempList[1] =
                                g_list_append (*tempList[1],
                                               gtk_label_new
                                               (OptionsSettings->booleans[j].
                                                name));


                        gtk_toggle_button_set_active ((GtkToggleButton *)
                                                      g_list_nth_data
                                                      (*OptionsList[1], i),
                                                      OptionsSettings->
                                                      booleans[j].
                                                      defaultValue);
                        ++i;
                }
        }
        return i;
}

GtkWidget *
vapiGtkOptionsCreateByInterfaceType (vInterfaceType interfaceType,
                                     double min, double max,
                                     double scale, double defaultValue)
{
        GtkWidget *newRange=NULL;

        if (interfaceType == vBar || !interfaceType)
        {
                newRange = gtk_hscale_new_with_range (min, max, scale);
                gtk_range_set_value ((GtkRange *) newRange, defaultValue);
                gtk_range_set_update_policy ((GtkRange *)
                                             newRange,
                                             GTK_UPDATE_DISCONTINUOUS);
        }
        if (interfaceType == vSpin)
        {
                newRange = gtk_spin_button_new_with_range (min, max, scale);
                gtk_spin_button_set_value ((GtkSpinButton *) newRange,
                                           defaultValue);
                gtk_spin_button_set_update_policy ((GtkSpinButton *) newRange,
                                                   GTK_UPDATE_IF_VALID);
        }
        return newRange;
}


void
vapiGtkOptionsPopulate (vOptions * Options,
                        vOptionsSettings * OptionsSettings,
                        GList ** OptionsList[3],
                        vGtkOptionsCustomPopulate CustomFunc)
{
        int i = 0, j;

        vapiGtkOptionsBlockEvents (OptionsList[2]);

        i = CustomFunc (Options, OptionsSettings, OptionsList, i);

        if (OptionsSettings->floatsNumber)
        {
                for (j = 0; j < OptionsSettings->floatsNumber; j++)
                {

                        vapiGtkOptionsSetOptionByInterfaceType
                                (g_list_nth_data
                                 (*OptionsList[1], i),
                                 Options->floats[j],
                                 OptionsSettings->floats[j].
                                 interfaceType, vFALSE);
                        ++i;
                }
        }
        if (OptionsSettings->intsNumber)
        {

                for (j = 0; j < OptionsSettings->intsNumber; j++)
                {

                        vapiGtkOptionsSetOptionByInterfaceType
                                (g_list_nth_data
                                 (*OptionsList[1], i),
                                 Options->ints[j],
                                 OptionsSettings->ints[j].
                                 interfaceType, vTRUE);
                        ++i;
                }
        }
        if (OptionsSettings->charsNumber)
        {
                for (j = 0; j < OptionsSettings->charsNumber; j++)
                {

                        gtk_entry_set_text ((GtkEntry *)
                                            g_list_nth_data
                                            (*OptionsList[1], i),
                                            Options->chars[j].ch);
                        ++i;
                }
        }
        if (OptionsSettings->chooseNumber)
        {
                for (j = 0; j < OptionsSettings->chooseNumber; j++)
                {
                        gtk_combo_box_set_active ((GtkComboBox *)
                                                  g_list_nth_data
                                                  (*OptionsList[1], i),
                                                  Options->choices[j]);
                        ++j;
                }
        }
        if (OptionsSettings->booleansNumber)
        {
                for (j = 0; j < OptionsSettings->booleansNumber; j++)
                {

                        gtk_toggle_button_set_active ((GtkToggleButton *)
                                                      g_list_nth_data
                                                      (*OptionsList[1], i),
                                                      Options->booleans[j]);
                        ++j;
                }
        }
        vapiGtkOptionsUnBlockEvents (OptionsList[2]);
}

void
vapiGtkOptionsBlockEvents (GList ** OptionsEvents)
{
        int listSize, i;
        vapiEventList *eventList;
        if (*OptionsEvents == NULL)
        {
                return;
        }
        listSize = g_list_length (*OptionsEvents);
        if (listSize > 0)
        {
                for (i = 0; i < listSize; i++)
                {
                        eventList = (vapiEventList *) g_list_nth_data
                                (*OptionsEvents, i);
                        g_signal_handler_block (GTK_OBJECT
                                                (eventList->widget),
                                                eventList->eventHandler);
                }
        }


}

void
vapiGtkOptionsUnBlockEvents (GList ** OptionsEvents)
{
        int listSize, i;
        vapiEventList *eventList;
        if (*OptionsEvents == NULL)
        {
                return;
        }
        listSize = g_list_length (*OptionsEvents);
        if (listSize > 0)
        {
                for (i = 0; i < listSize; i++)
                {
                        eventList = (vapiEventList *) g_list_nth_data
                                (*OptionsEvents, i);
                        g_signal_handler_unblock (GTK_OBJECT
                                                  (eventList->widget),
                                                  eventList->eventHandler);
                }
        }


}

GtkWidget *
vapiGtkOptionsGetAssociatedWidget (const char *requiredOption,
                                   vOptionsSettings * OptionsSettings,
                                   GList ** OptionsData)
{
        int i = 0, varNumber = 0, times;

        /*
         * FIXME: isto tem que ser opção e ter opção para retornar
         *  as widgets das customOptions.
         */
        times = vapiGtkOptionsCountCustomOperationsMembers (OptionsSettings);

        switch (requiredOption[i])
        {
        case 'f':
        {

                if (OptionsSettings->floatsNumber == 0)
                {
                        return NULL;
                }
                varNumber = atoi (&requiredOption[i]);
                /*
                 * Para floats, antes existe o times, e em seguida basta o 
                 * numero do float.
                 */
                return g_list_nth_data (*OptionsData, varNumber + times);
                break;
        }
        case 'd':
        {

                if (OptionsSettings->intsNumber == 0)
                {
                        return NULL;
                }
                varNumber = atoi (&requiredOption[++i]);
                /*
                 * Para ints, antes existe o times e os floats, e em seguida basta o 
                 * numero do int.
                 */
                return g_list_nth_data (*OptionsData,
                                        times + varNumber +
                                        OptionsSettings->floatsNumber);
                break;
        }
        case 'c':
        {

                if (OptionsSettings->charsNumber == 0)
                {
                        return NULL;
                }
                varNumber = atoi (&requiredOption[++i]);
                /*
                 * Para ints, antes existe o times e os floats, e em seguida basta o 
                 * numero do int.
                 */
                return g_list_nth_data (*OptionsData,
                                        varNumber + times +
                                        OptionsSettings->
                                        floatsNumber +
                                        OptionsSettings->intsNumber);
                break;
        }

        }
        return NULL;

}

void
vapiGtkOptionsSetOptionByInterfaceType (GtkWidget * Range, double Value,
                                        vInterfaceType interfaceType,
                                        vBoolean ISint)
{

        if (interfaceType == vBar || !interfaceType)
        {
                if (ISint)
                {
                        gtk_range_set_value ((GtkRange *) Range, (int) Value);
                }
                else
                {
                        gtk_range_set_value ((GtkRange *) Range, Value);
                }
        }
        if (interfaceType == vSpin)
        {
                if (ISint)
                {
                        gtk_spin_button_set_value ((GtkSpinButton *) Range,
                                                   (int) Value);
                }
                else
                {
                        gtk_spin_button_set_value ((GtkSpinButton *) Range,
                                                   Value);
                }
        }

}

vTempFloat *
vapiGtkOptionsGetOptionByInterfaceType (GtkWidget * Range,
                                        vInterfaceType interfaceType,
                                        vBoolean ISint)
{
        vTempFloat *Value = malloc (sizeof (vTempFloat));

        if (interfaceType == vBar || !interfaceType)
        {
                if (ISint)
                {
                        Value->intValue =
                                (int) gtk_range_get_value ((GtkRange *)
                                                           Range);
                }
                else
                {
                        Value->value =
                                gtk_range_get_value ((GtkRange *) Range);
                }

        }
        if (interfaceType == vSpin)
        {
                if (ISint)
                {
                        Value->intValue =
                                gtk_spin_button_get_value_as_int ((GtkSpinButton *) Range);
                }
                else
                {
                        Value->value =
                                gtk_spin_button_get_value ((GtkSpinButton *)
                                                           Range);
                }

        }

        return Value;

}

void
vapiGtkOptionsGetOptions (vOptions * options,
                          vOptionsSettings * OptionsSettings,
                          vGtkOptionsCustomGet CustomGet,
                          GList ** OptionsData)
{
        vTempFloat *tempFloat;
        int i=0, j;
        
        if (CustomGet!=NULL)
        {
        i= CustomGet(options,
                           OptionsSettings, OptionsData);
        }

        if (OptionsSettings->floatsNumber)
        {
                for (j = 0; j < OptionsSettings->floatsNumber; j++)
                {
                        tempFloat = (vTempFloat *)
                                vapiGtkOptionsGetOptionByInterfaceType
                                (g_list_nth_data
                                 (*OptionsData, i),
                                 OptionsSettings->floats[j].
                                 interfaceType, vFALSE);
                        options->floats[j] = tempFloat->value;
                        v_debug ("OPTIONS FLOAT VALOR: %f", options->floats[j]);
                        free (tempFloat);
                        ++i;
                }
        }
        if (OptionsSettings->intsNumber)
        {
                for (j = 0; j < OptionsSettings->intsNumber; j++)
                {

                        tempFloat = (vTempFloat *)
                                vapiGtkOptionsGetOptionByInterfaceType
                                (g_list_nth_data
                                 (*OptionsData, i),
                                 OptionsSettings->ints[j].
                                 interfaceType, vTRUE);
                        options->ints[j] = tempFloat->intValue;
                        v_debug ("OPTIONS VALOR: %d", options->ints[j]);
                        free (tempFloat);
                        ++i;
                }
        }
        if (OptionsSettings->charsNumber)
        {
                for (j = 0; j < OptionsSettings->charsNumber; j++)
                {
                        options->chars[j].ch =
                                vapiReturnStringPointer (gtk_entry_get_text
                                                         ((GtkEntry *)
                                                          g_list_nth_data
                                                          (*OptionsData, i)));
                        v_debug ("GET O CHAR: %s.", options->chars[j].ch);
                        ++i;
                }
        }
        if (OptionsSettings->chooseNumber)
        {
                for (j = 0; j < OptionsSettings->chooseNumber; j++)
                {

                        options->choices[j] =
                                gtk_combo_box_get_active ((GtkComboBox *)
                                                          g_list_nth_data
                                                          (*OptionsData, i));
                        ++i;
                }
        }
        if (OptionsSettings->booleansNumber)
        {
                for (j = 0; j < OptionsSettings->booleansNumber; j++)
                {

                        options->booleans[j] =
                                gtk_toggle_button_get_active ((GtkToggleButton
                                                               *)
                                                              g_list_nth_data
                                                              (*OptionsData,
                                                               i));
                        ++i;
                }
        }
}

---