src/interface/vapiGtkSetOriginWindow.c

Ir para a documentação deste ficheiro.

#include "vapiGtkInterface.h"
#include "vapiAux.h"
#include "vapiString.h"
#include "vapiImagesAux.h"
#include "vapiGtkImages.h"
#include "vapiGtkSetOriginWindow.h"
#include "vapiCameraSettings.h"
#include "vapiCameraAcquisition.h"

GtkWidget *btTestOrigin;

void
vapiGtkSetOriginWindowInit (GladeXML * xml, vCameraSettings * CameraSettings,
                            vImages * Images)
{
        vapiGtkSetOriginWindow *SetOrigin =
                malloc (sizeof (vapiGtkSetOriginWindow));
        GtkWidget *btSaveOrigin;
        GtkWidget *btNewVapi;
        GtkWidget *winSetImageOrigin;
        GtkWidget *btSelectImage;

        SetOrigin->Images = Images;
        SetOrigin->CameraSettings = CameraSettings;
        SetOrigin->nbCameraType = glade_xml_get_widget (xml, "nbCamType");
        SetOrigin->CamLocalFilePATH =
                glade_xml_get_widget (xml, "CamLocalFilePATH");
        btTestOrigin = glade_xml_get_widget (xml, "btTestOrigin");
        btSaveOrigin = glade_xml_get_widget (xml, "btSaveOrigin");
        SetOrigin->imOriginTest = glade_xml_get_widget (xml, "imOriginTest");
        SetOrigin->CamIndex = glade_xml_get_widget (xml, "CamIndex");
        SetOrigin->CamIP = glade_xml_get_widget (xml, "CamIP");
        SetOrigin->CamURL = glade_xml_get_widget (xml, "CamURL");
        btNewVapi = glade_xml_get_widget (xml, "btNewVapi");
        winSetImageOrigin = glade_xml_get_widget (xml, "winSetImageOrigin");
        SetOrigin->RefreshButton = glade_xml_get_widget (xml, "btRefresh");
        btSelectImage = glade_xml_get_widget (xml, "btSelectImage");
        /*
         * Eventos associados aos botões.
         */
        g_signal_connect_after (G_OBJECT (btTestOrigin), "clicked",
                                G_CALLBACK (vapiGtkSetOriginWindowTestOrigin),
                                SetOrigin);

        g_signal_connect_after (G_OBJECT (btSaveOrigin), "clicked",
                                G_CALLBACK (vapiGtkSetOriginWindowSaveOrigin),
                                SetOrigin);
        g_signal_connect_after (G_OBJECT (btNewVapi), "clicked",
                                G_CALLBACK (vapiGtkSetOriginWindowNewVapi),
                                SetOrigin);
        g_signal_connect_after (G_OBJECT (btSelectImage), "clicked",
                                G_CALLBACK
                                (vapiGtkSetOriginWindowLaunchImageLoad),
                                SetOrigin);

        if (vapiCameraSettingsGetType (SetOrigin->CameraSettings) ==
            vCameraNONE)
        {
                gtk_widget_show_all (winSetImageOrigin);
                gtk_widget_grab_focus (LoadScreen);
        }
}

void
vapiGtkSetOriginWindowTestOrigin (GtkWidget * widget,
                                  vapiGtkSetOriginWindow * SetOrigin)
{
        vapiGtkSetOriginWindowTestSaveOrigin (SetOrigin, vFALSE);

}

void
vapiGtkSetOriginWindowSaveOrigin (GtkWidget * widget,
                                  vapiGtkSetOriginWindow * SetOrigin)
{
        vImagesFreeImages (SetOrigin->Images);
        vapiGtkSetOriginWindowTestSaveOrigin (SetOrigin, vTRUE);
        /*
         * ctualizar a imagem na janela Principal.
         */
        g_signal_emit_by_name (SetOrigin->RefreshButton, "clicked", NULL);
}

void
vapiGtkSetOriginWindowTestSaveOrigin (vapiGtkSetOriginWindow * SetOrigin,
                                      vBoolean SaveSettings)
{
        int NoteBookPage, CamIndex;
        vCameraSettings *CameraSettings;
        vImages *tempImages;
        const char *Filename, *IP, *URL;

        HaveAcquisitionLoadingProgress = vFALSE;

        if (SaveSettings)
        {
                tempImages = SetOrigin->Images;
                CameraSettings = SetOrigin->CameraSettings;
        }
        else
        {
                tempImages = vImagesInit ();
                CameraSettings = vapiCameraSettingsInit ();

        }

        NoteBookPage =
                gtk_notebook_get_current_page ((GtkNotebook *) SetOrigin->
                                               nbCameraType);

        switch (NoteBookPage)
        {
        case 0:
        {
                Filename =
                        gtk_entry_get_text ((GtkEntry *)
                                            SetOrigin->CamLocalFilePATH);
                if (strlen (Filename) < 4)
                {
                        return;
                }
                vapiCameraSettingsSetTypeLocalFile (CameraSettings, Filename);
                break;
        }
#ifndef VAPI_DEMO
        case 1:
        {

                CamIndex =
                        gtk_spin_button_get_value_as_int ((GtkSpinButton *)
                                                          SetOrigin->
                                                          CamIndex);
                vapiCameraSettingsSetTypeLocal (CameraSettings, CamIndex);
                break;
        }
        case 2:
        {
                IP = gtk_entry_get_text ((GtkEntry *) SetOrigin->CamIP);
                URL = gtk_entry_get_text ((GtkEntry *) SetOrigin->CamURL);
                vapiCameraSettingsSetTypeRemoteIP (CameraSettings, IP, URL);
                break;
        }
#endif

        }

        vapiGetSnapshot (tempImages, CameraSettings);

        vapiOriginal2Actual (tempImages);


        if (!SaveSettings)
        {
                vapiGtkPutImage (SetOrigin->imOriginTest,
                                 tempImages->Original);
                vImagesFree (tempImages);
                vCameraSettingsFree (CameraSettings);
        }

}

void
vapiGtkSetOriginWindowNewVapi (GtkWidget * widget,
                               vapiGtkSetOriginWindow * SetOrigin)
{

        vapiGtkSetOriginWindow *SetOrigin2;
        vImages *tempImages = vImagesInit ();
        vCameraSettings *tempCameraSettings;
        tempCameraSettings = vapiCameraSettingsInit ();

        SetOrigin2 = malloc (sizeof (vapiGtkSetOriginWindow));

        SetOrigin2->Images = tempImages;
        SetOrigin2->nbCameraType = SetOrigin->nbCameraType;
        SetOrigin2->CameraSettings = tempCameraSettings;
        SetOrigin2->CamLocalFilePATH = SetOrigin->CamLocalFilePATH;
        SetOrigin2->CamIP = SetOrigin->CamIP;
        SetOrigin2->CamIndex = SetOrigin->CamIndex;
        SetOrigin2->CamURL = SetOrigin->CamURL;
        v_info ("a iniciar um vapi novo");
        vapiGtkSetOriginWindowTestSaveOrigin (SetOrigin2, vTRUE);
        if (vapiCameraSettingsStartNewVapi (SetOrigin2->CameraSettings))
        {
                v_error ("erro ao iniciar um novo vapi");
        }
        vImagesFree (tempImages);
        vCameraSettingsFree (tempCameraSettings);
        free (SetOrigin2);
}

void
vapiGtkSetOriginWindowDefineSource (GtkFileChooser * chooser, gint response,
                                    vapiGtkSetOriginWindow * SetOrigin)
{
        char *filename;
        if (response == GTK_RESPONSE_CANCEL)
        {
                gtk_widget_destroy ((GtkWidget *) chooser);
                return;
        }
        if (response != GTK_RESPONSE_OK)
        {
                return;
        }
        filename = gtk_file_chooser_get_filename (chooser);
        v_debug ("here");
        gtk_entry_set_text ((GtkEntry *) SetOrigin->CamLocalFilePATH,
                            filename);
        v_debug ("here2");
        gtk_widget_destroy ((GtkWidget *) chooser);
        g_free (filename);
        g_signal_emit_by_name (btTestOrigin, "clicked");
}

void
vapiGtkSetOriginWindowUpdatePreview (GtkFileChooser * chooser,
                                     GtkWidget * ImPreview)
{
        char *filename;
        GError *error = NULL;
        GdkPixbuf *image;

        filename = gtk_file_chooser_get_preview_filename (chooser);
        if (filename == NULL)
        {
                return;
        }
        image = gdk_pixbuf_new_from_file_at_scale (filename, 260, -1, TRUE,
                                                   &error);
        if (image == NULL)
        {
                return;
        }
        gtk_image_set_from_pixbuf ((GtkImage *) ImPreview, image);
        g_object_unref (image);
        g_free (filename);
}

void
vapiGtkSetOriginWindowLaunchImageLoad (GtkWidget * widget,
                                       vapiGtkSetOriginWindow * SetOrigin)
{
        GtkWidget *chooser;
        GtkWidget *ImPreview;

        ImPreview = gtk_image_new ();
        gtk_widget_set_size_request (ImPreview, 260, 200);

        chooser =
                gtk_file_chooser_dialog_new ("Carregar Macro de ficheiro",
                                             NULL,
                                             GTK_FILE_CHOOSER_ACTION_OPEN,
                                             NULL, NULL);
        /*
         * Adicionar botões de ok e cancel.
         */
        gtk_dialog_add_buttons ((GtkDialog *) chooser,
                                "gtk-cancel", GTK_RESPONSE_CANCEL, "gtk-open",
                                GTK_RESPONSE_OK, NULL);
        gtk_file_chooser_set_preview_widget_active ((GtkFileChooser *)
                                                    chooser, TRUE);
        gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser),
                                     vapiGtkImagesFilter ());
        gtk_file_chooser_set_preview_widget (GTK_FILE_CHOOSER (chooser),
                                             ImPreview);

        g_signal_connect (G_OBJECT (chooser), "update-preview",
                          G_CALLBACK (vapiGtkSetOriginWindowUpdatePreview),
                          ImPreview);

        g_signal_connect (G_OBJECT (chooser), "response",
                          G_CALLBACK (vapiGtkSetOriginWindowDefineSource),
                          SetOrigin);

        gtk_widget_show_all (chooser);
}

---