src/interface/vapiGtkAux.c

Ir para a documentação deste ficheiro.

#include <gtk/gtk.h>
#include <string.h>
#include <stdlib.h>
#include "vapiOperationsDefault.h"
#include "vapiString.h"
#include "vapiAux.h"
#include "vapiGroups.h"
#include "vapiImagesAux.h"
#include "vapiCameraAcquisition.h"
#include "vapiOperationOptions.h"
#include "vapiTypes.h"
#include "vapiGtkInterface.h"
#include "vapiGtkAux.h"
#include "vapiCameraSettings.h"
#include "vapiOperationList.h"
#include "vapiGtkMemory.h"
#include "vapiCameraAcquisition.h"
#include "vapiGtkAuxWindow.h"
#include "vapiGtkImages.h"
#include "vapiGtkMacrosTables.h"

void
vapiRefreshImage (vRefreshImage * RefreshImage)
{
        vCameraSettings *CameraSettings = RefreshImage->Temp->CameraSettings;
        vImages *tempImages = vImagesInit ();
        tempImages->Original =
                vapiImagesCopy (RefreshImage->Temp->Images->Original);
        v_info ("iniciar a Câmara\n");

        do
        {
                if (vapiCameraSettingsGetType (CameraSettings) ==
                    vCameraLocalFile)
                {
                        continue;
                }
                else
                {
                        vImagesFreeOriginal (tempImages);
                        if (!vapiGetSnapshot (tempImages, CameraSettings))
                        {


                                /*
                                 * Informar a outra thread de que pode actualizar
                                 *  a imagem.
                                 */
                                vapiGtkImagesFastUpdateInterface
                                        (tempImages->Original, gtkImOriginal);

                        }

                        g_usleep (10);
                }
        }
        while (RefreshImage->STOP == 0);
        if (vapiCameraSettingsGetType (CameraSettings) != vCameraLocalFile)
        {
                vapiOriginal2Actual (tempImages);
                vapiGtkImagesUpdateInterface (tempImages, gtkImActual);
                vapiGtkImagesUpdateInterface (tempImages, gtkImWork);
                vapiGtkImagesUpdateInterface (tempImages, gtkImOriginal);
        }
        free (tempImages);
        g_thread_exit (NULL);
}

void
vapiCamStop (GtkWidget * widget, vRefreshImage * RefreshImage)
{
        if (!gtk_toggle_tool_button_get_active
            ((GtkToggleToolButton *) RefreshImage->Temp->Widgets->cbCam))
        {
                gtk_tool_button_set_label ((GtkToolButton *) RefreshImage->
                                           Temp->Widgets->cbCam,
                                           "Verificar Câmara");
                RefreshImage->STOP = 1;
        }
        else
        {
                gtk_tool_button_set_label ((GtkToolButton *) RefreshImage->
                                           Temp->Widgets->cbCam,
                                           "Aceitar Imagem");
        }
}

int
vapiCheckOperations (vEffect * Operation,
                     vOptions * options, vMacroList * MacroList)
{
        vMacroHeader *MacroHeader;
        vEffectSettings *OperationSettings =
                Operation->OptionsSettings->CustomOptionsSettings;
        vEffectOptions *OperationOptions = options->CustomOptions;
        int MacroNumber, i;
        if (!strcmp (Operation->name, "Executar Tarefa"))
        {
                if ((MacroNumber =
                     vapiMacroListMacroExist (MacroList,
                                              options->chars[0].ch, 0)) >= 0
                    && strcmp (options->chars[0].ch, ""))
                {
                        MacroHeader =
                                vapiMacroListSelectItem ((vMacroList
                                                          *)
                                                         MacroList,
                                                         MacroNumber);
                        v_debug ("nome da macro %s\n",
                                 MacroHeader->MacroName);
                        OperationOptions->Macros = MacroHeader;
                }
                else
                {
                        v_debug ("Não existe a Macro desejada %s",
                                 options->chars[0].ch);
                        OperationOptions->Macros = NULL;
                        return 1;
                }
        }
        if (Operation->OptionsSettings->charsNumber)
        {
                for (i = 0; i < Operation->OptionsSettings->charsNumber; i++)
                {
                        if (strlen (options->chars[i].ch) == 0)
                        {
                                return 1;
                        }
                }

        }
        if (OperationSettings->NeedOfAuxImage == NeedTemplate)
        {
                vOptionsFreeTemplate (options);
                ((vEffectOptions *) options->CustomOptions)->Template =
                        cvLoadImage (options->chars[0].ch, 3);
        }

        return 0;
}


gint
gtk_utils_get_selected_radio_index (GSList * radio_button_group)
{
        int k;
        int length = g_slist_length (radio_button_group);
        for (k = 0; radio_button_group;
             k++, radio_button_group = radio_button_group->next)
        {
                gpointer *radio_button = radio_button_group->data;
                if (gtk_check_menu_item_get_active
                    ((GtkCheckMenuItem *) radio_button))
                        return (length - 1) - k;
        }

        return -1;
}

vImages *
vapiGtkAuxActual2Work (vImages * Images)
{
        vImages *tempImages = vImagesInit ();
        tempImages->Original = Images->Original;
        tempImages->Actual =
                vapiImagesSameSize (Images->Actual,
                                    Images->Actual->nChannels);
        cvCopy (Images->Actual, tempImages->Actual, NULL);
        return tempImages;
}

GtkWidget *
vapiAuxCreateIcon (const char *filename)
{
        GtkWidget *icon;
        GtkIconSource *icon_source;
        GtkIconSet *icon_set;
        icon_set = gtk_icon_set_new ();
        icon_source = gtk_icon_source_new ();
        gtk_icon_source_set_filename (icon_source, filename);
        gtk_icon_set_add_source (icon_set, icon_source);
        icon = gtk_image_new_from_icon_set (icon_set,
                                            GTK_ICON_SIZE_LARGE_TOOLBAR);
        return icon;
}

void
vapiGtkAuxStepInProgressBar (const char *Message, double Step)
{


        gtk_label_set_text ((GtkLabel *) LoadScreenMessage, Message);
        gtk_progress_bar_set_fraction ((GtkProgressBar *)
                                       LoadScreenProgress, Step);
        /*
         * Retirado do bluefish.
         * Serve para que o Splash screen Funcione antes do main loop.
         * Dá um passo no loop.
         */
        if (!MainLoadDone)
        {

                while (g_main_context_pending (NULL))
                {
                        g_main_context_iteration (NULL, TRUE);
                }
        }
        else
        {
                v_error ("%f main load not done\n", Step);
        }


}

vEffect *
vapiGetOperationFromTxtOperation (GtkWidget * txtOperation, vOperationList * OperationList)
{
        char *OperationName;
        vEffect *Operation;
        OperationName =
                (char *) gtk_entry_get_text ((GtkEntry *) txtOperation);
        Operation =
                vapiOperationListSelectOperation (OperationList,
                                                  OperationName);
        return Operation;
}

gboolean
vapiRefreshOriginal (vRefreshImage * RefreshImage)
{
        vapiGtkPutImage (RefreshImage->Temp->Widgets->
                         imOriginal, RefreshImage->Temp->Images->Original);
        RefreshImage->gate = 0;
        return TRUE;
}

void
v_gtk_message (const char *Message)
{
        /*
         * Futuramente a função para descrever mensagens na interface
         *  do programa.
         */
        printf (" ");
}

void
vapiGtkGroupButtons (vGroupList * GroupList,
                     GList ** GroupButtonList,
                     GtkWidget * vBoxGroups, GCallback callback,
                     gpointer data)
{
        int NumberOfGroups, i;
        GtkWidget *GroupToggleButton;

        char *GroupName;


        NumberOfGroups = vapiGroupListCountElements (GroupList);

        if (NumberOfGroups == 0)
        {
                return;
        }

        for (i = 0; i < NumberOfGroups; i++)
        {
                GroupName = vapiGroupListSelectItem (GroupList, i);

                GroupToggleButton =
                        gtk_toggle_button_new_with_label (GroupName);
                g_signal_connect (G_OBJECT (GroupToggleButton), "toggled",
                                  callback, data);
                if (i == 0)
                {
                        gtk_toggle_button_set_active ((GtkToggleButton *)
                                                      GroupToggleButton,
                                                      TRUE);
                }
                *GroupButtonList =
                        g_list_append (*GroupButtonList, GroupToggleButton);
                gtk_box_pack_start ((GtkBox *) vBoxGroups,
                                    GroupToggleButton, FALSE, FALSE, 2);

        }
        gtk_widget_show_all (vBoxGroups);
}

int
vapiGtkSelectGroupButton (GtkWidget * ActiveButton,
                          vGroupList * GroupList, GList ** GroupButtonList)
{
        char *GroupName;
        GtkWidget *GroupButton;
        int i, NumberOfGroups, selected = 0;
        if (!gtk_toggle_button_get_active ((GtkToggleButton *) ActiveButton))
        {
                return -1;
        }

        GroupName =
                (char *) gtk_button_get_label ((GtkButton *) ActiveButton);

        NumberOfGroups = g_list_length (*GroupButtonList);


        for (i = 0; i < NumberOfGroups; i++)
        {
                GroupButton = g_list_nth_data (*GroupButtonList, i);
                if (GroupButton != ActiveButton)
                {


                        gtk_toggle_button_set_active ((GtkToggleButton *)
                                                      GroupButton, FALSE);
                }
                else
                {
                        selected = i;
                }
        }
        return selected;
}

vBoolean
vapiGtkAuxCheckOperation (vEffect * Operation)
{
                if (Operation == NULL)
        {
                v_error_ui("Nenhuma Operação seleccionada.");
                return vTRUE;
        }
        return vFALSE;
}

---