src/interface/vapiGtkImages.c

Ir para a documentação deste ficheiro.

#include <gtk/gtk.h>
#include "vapiImagesAux.h"
#include "vapiGtkImages.h"
#include "vapiGtkInterface.h"

static struct _vGtkImages
{
        GMutex *mutexOriginal;
        GMutex *mutexActual;
        GMutex *mutexWork;
        vImages *Images;
        GtkWidget *imOriginal;
        GtkWidget *imActual;
        GtkWidget *imWork;
} GtkImages;

void
vapiGtkImagesThreadsInit (GtkWidget * imOriginal, GtkWidget * imActual,
                          GtkWidget * imWork, vImages * Images)
{
        GtkImages.mutexOriginal = g_mutex_new ();
        GtkImages.mutexActual = g_mutex_new ();
        GtkImages.mutexWork = g_mutex_new ();
        GtkImages.Images = Images;
        GtkImages.imOriginal = imOriginal;
        GtkImages.imActual = imActual;
        GtkImages.imWork = imWork;
}

gboolean
vapiGtkImagesUpdateIdle (vGtkImagesIdle * GtkImagesIdle)
{
        GMutex *tempMutex;
        GtkWidget *tempWidget;
        vBoolean FreeImage = vTRUE;
        switch (GtkImagesIdle->GtkImageWidget)
        {
        case gtkImActual:
        {
                v_debug ("ImagesUpdateIdle: Seleccionado o imActual");
                tempMutex = GtkImages.mutexActual;
                tempWidget = GtkImages.imActual;
                if (!g_mutex_trylock (tempMutex))
                {


                        cvReleaseImage (&GtkImagesIdle->Image);

                        vGtkImagesIdleFree (GtkImagesIdle);
                        v_debug ("ImagesUpdateIdle: trylock false");
                        return TRUE;
                }
                vapiImagesSetActual (GtkImages.Images, GtkImagesIdle->Image);
                break;
        }
        case gtkImWork:
        {
                v_debug ("ImagesUpdateIdle: Seleccionado o imWork");
                tempMutex = GtkImages.mutexWork;
                tempWidget = GtkImages.imWork;
                if (!g_mutex_trylock (tempMutex))
                {
                        cvReleaseImage (&GtkImagesIdle->Image);
                        vGtkImagesIdleFree (GtkImagesIdle);
                        v_debug ("ImagesUpdateIdle: trylock false in work mutex");
                        return TRUE;
                }
                if (!g_mutex_trylock (GtkImages.mutexActual))
                {
                        cvReleaseImage (&GtkImagesIdle->Image);
                        vGtkImagesIdleFree (GtkImagesIdle);
                        g_mutex_unlock (tempMutex);
                        v_debug ("ImagesUpdateIdle: trylock false in Actual mutex");
                        return TRUE;
                }
                break;
        }
        case gtkImOriginal:
        {
                v_debug ("ImagesUpdateIdle: Seleccionado o imOriginal");
                tempMutex = GtkImages.mutexOriginal;
                tempWidget = GtkImages.imOriginal;
                if (!g_mutex_trylock (tempMutex))
                {
                        cvReleaseImage (&GtkImagesIdle->Image);
                        vGtkImagesIdleFree (GtkImagesIdle);
                        v_debug ("ImagesUpdateIdle: trylock false in work mutex");
                        return TRUE;
                }
                vapiImagesSetOriginal (GtkImages.Images,
                                       GtkImagesIdle->Image);
                FreeImage = vFALSE;
                v_debug ("ImagesUpdateIdle: trylock true");
                break;
        }
        default:
        {
                cvReleaseImage (&GtkImagesIdle->Image);
                vGtkImagesIdleFree (GtkImagesIdle);
                return FALSE;
                break;
        }
        }
        vapiGtkPutImage (tempWidget, GtkImagesIdle->Image);
        v_debug ("ImagesUpdateIdle: trylock actualizou");
        g_mutex_unlock (tempMutex);
        if (GtkImagesIdle->GtkImageWidget == gtkImWork)
        {
                g_mutex_unlock (GtkImages.mutexActual);
        }
        v_debug ("ImagesUpdateIdle: trylock desbloqueou");
        vGtkImagesIdleFree (GtkImagesIdle);
        return FALSE;
}

void
vapiGtkImagesUpdateInterface (vImages * Images, int GtkImageWidget)
{
        vGtkImagesIdle *GtkImagesIdle;
        IplImage *Image;
        switch (GtkImageWidget)
        {
        case gtkImWork:
        case gtkImActual:
        {
                Image = Images->Actual;
                break;
        }
        case gtkImOriginal:
        {
                Image = Images->Original;
                break;
        }
        default:
        {
                Image = Images->Actual;
        }
        }
        GtkImagesIdle = vGtkImagesIdleNew (Image, GtkImageWidget);
        v_debug ("ImagesUpdate inicio");
        g_idle_add ((GSourceFunc) & vapiGtkImagesUpdateIdle, GtkImagesIdle);
}

vGtkImagesIdle *
vGtkImagesIdleNew (IplImage * Image, int GtkImageWidget)
{
        vGtkImagesIdle *GtkImagesIdle = malloc (sizeof (vGtkImagesIdle));
        GtkImagesIdle->Image = vapiImagesCopy (Image);
        GtkImagesIdle->GtkImageWidget = GtkImageWidget;
        return GtkImagesIdle;
}

void
vGtkImagesIdleFree (vGtkImagesIdle * vFree)
{
        free (vFree);
}

void
vGtkImagesIdleChangeImage (vGtkImagesIdle * GtkImagesIdle, int GtkImageWidget)
{
        GtkImagesIdle->GtkImageWidget = GtkImageWidget;
}

gboolean
vapiGtkImagesFastUpdateIdle (vGtkImagesIdleFast * GtkImagesIdleFast)
{
        GMutex *tempMutex;
        GtkWidget *tempWidget;

        switch (GtkImagesIdleFast->GtkImageWidget)
        {
        case gtkImActual:
        {
                v_debug ("ImagesUpdateIdle: Seleccionado o imActual");
                tempMutex = GtkImages.mutexActual;
                tempWidget = GtkImages.imActual;
                if (!g_mutex_trylock (tempMutex))
                {
                        vGtkImagesIdleFastFree (GtkImagesIdleFast);
                        v_debug ("ImagesUpdateIdle: trylock false");
                        return FALSE;
                }
                break;
        }
        case gtkImWork:
        {
                v_debug ("ImagesUpdateIdle: Seleccionado o imWork");
                tempMutex = GtkImages.mutexWork;
                tempWidget = GtkImages.imWork;
                if (!g_mutex_trylock (tempMutex))
                {
                        vGtkImagesIdleFastFree (GtkImagesIdleFast);
                        v_debug ("ImagesUpdateIdle: trylock false in work mutex");
                        return FALSE;
                }
                if (!g_mutex_trylock (GtkImages.mutexActual))
                {
                        vGtkImagesIdleFastFree (GtkImagesIdleFast);
                        g_mutex_unlock (tempMutex);
                        v_debug ("ImagesUpdateIdle: trylock false in Actual mutex");
                        return FALSE;
                }
                break;
        }
        case gtkImOriginal:
        {
                v_debug ("ImagesUpdateIdle: Seleccionado o imOriginal");
                tempMutex = GtkImages.mutexOriginal;
                tempWidget = GtkImages.imOriginal;
                if (!g_mutex_trylock (tempMutex))
                {
                        vGtkImagesIdleFastFree (GtkImagesIdleFast);
                        v_debug ("ImagesUpdateIdle: trylock false in work mutex");
                        return FALSE;
                }
                break;
        }
        default:
        {
                vGtkImagesIdleFastFree (GtkImagesIdleFast);
                return FALSE;
                break;
        }
        }
        v_debug ("ImagesUpdateIdle: trylock true");
        vapiGtkPutImage (tempWidget, GtkImagesIdleFast->Image);
        v_debug ("ImagesUpdateIdle: trylock actualizou");
        g_mutex_unlock (tempMutex);
        if (GtkImagesIdleFast->GtkImageWidget == gtkImWork)
        {
                g_mutex_unlock (GtkImages.mutexActual);
        }
        v_debug ("ImagesUpdateIdle: trylock desbloqueou");
        vGtkImagesIdleFastFree (GtkImagesIdleFast);

        return FALSE;
}

void
vapiGtkImagesFastUpdateInterface (IplImage * Image, int GtkImageWidget)
{
        vGtkImagesIdleFast *GtkImagesIdleFast;
        GtkImagesIdleFast = vGtkImagesIdleFastNew (Image, GtkImageWidget);

        v_debug ("ImagesUpdateFast inicio");
        g_idle_add ((GSourceFunc) & vapiGtkImagesFastUpdateIdle,
                    GtkImagesIdleFast);
}

vGtkImagesIdleFast *
vGtkImagesIdleFastNew (IplImage * Image, int GtkImageWidget)
{
        vGtkImagesIdleFast *GtkImagesIdleFast =
                malloc (sizeof (vGtkImagesIdleFast));
        GtkImagesIdleFast->Image = vapiImagesCopy (Image);
        GtkImagesIdleFast->GtkImageWidget = GtkImageWidget;
        return GtkImagesIdleFast;
}

void
vGtkImagesIdleFastFree (vGtkImagesIdleFast * vFree)
{
        cvReleaseImage (&vFree->Image);
        free (vFree);
}

GtkFileFilter *
vapiGtkImagesFilter ()
{
        GtkFileFilter *filter;
        filter = gtk_file_filter_new ();
        gtk_file_filter_set_name (filter, "Imagens");
        gtk_file_filter_add_pattern (filter, "*.jpg");
        gtk_file_filter_add_pattern (filter, "*.bmp");
        gtk_file_filter_add_pattern (filter, "*.gif");
        gtk_file_filter_add_pattern (filter, "*.png");
        gtk_file_filter_add_pattern (filter, "*.tif");
        gtk_file_filter_add_pattern (filter, "*.tiff");
        gtk_file_filter_add_pattern (filter, "*.pcx");
        gtk_file_filter_add_pattern (filter, "*.JPG");
        return filter;
}

---