/**
* This file is a part of the Cairo-Dock project
*
* Copyright : (C) see the 'copyright' file.
* E-mail : see the 'copyright' file.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 3
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
#include
#include
#include
#include
#include
#include
#ifdef HAVE_EXIF
#include
#endif
#include "cairo-dock.h"
#include "applet-struct.h"
#include "applet-config.h"
#include "applet-transitions.h"
#include "applet-slider.h"
static void _cd_slider_get_exif_props (SliderImage *pImage);
//////////////
/// IMAGES ///
//////////////
static void cd_slider_free_image (SliderImage *pImage) {
if (pImage == NULL)
return;
g_free (pImage->cPath);
g_free (pImage);
}
static void cd_slider_free_images_list (GList *pList) {
g_list_foreach (pList, (GFunc) cd_slider_free_image, NULL);
g_list_free (pList);
}
static void _cd_slider_load_image (GldiModuleInstance *myApplet)
{
g_return_if_fail (myData.pElement != NULL);
SliderImage *pImage = myData.pElement->data;
gchar *cImagePath = pImage->cPath;
if (!pImage->bGotExifData && myData.iSidExifIdle == 0) // no exif data yet and no process currently retrieving them.
_cd_slider_get_exif_props (pImage);
cd_debug (" Slider - loading %s (size %dbytes, orientation:%d)", cImagePath, pImage->iSize, pImage->iOrientation);
//\_______________ On definit comment charger l'image.
double fImgX, fImgY, fImgW=0, fImgH=0;
CairoDockLoadImageModifier iLoadingModifier = 0; // CAIRO_DOCK_FILL_SPACE
if (pImage->iOrientation != 0)
iLoadingModifier |= ((pImage->iOrientation-1) << 3);
if (! myConfig.bFillIcon)
iLoadingModifier |= CAIRO_DOCK_DONT_ZOOM_IN;
if (myConfig.bNoStretch)
iLoadingModifier |= CAIRO_DOCK_KEEP_RATIO;
//\_______________ On cree la surface cairo.
int iLineWidth = 0;
if (myConfig.iBackgroundType == 2)
{
iLineWidth = _get_frame_linewidth (myApplet);
}
myData.pCairoSurface = cairo_dock_create_surface_from_image (cImagePath,
1.,
myData.iSurfaceWidth - iLineWidth, // iLineWidth/2 de chaque cote
myData.iSurfaceHeight - iLineWidth, // idem
iLoadingModifier,
&fImgW, &fImgH,
NULL, NULL);
//\_______________ On garde l'aire de la surface/texture.
fImgX = (myData.iSurfaceWidth - fImgW) / 2;
fImgY = (myData.iSurfaceHeight - fImgH) / 2;
myData.slideArea.fImgX = fImgX;
myData.slideArea.fImgY = fImgY;
myData.slideArea.fImgW = fImgW;
myData.slideArea.fImgH = fImgH;
cd_debug (" %s loaded", cImagePath);
}
static gboolean _cd_slider_display_image (GldiModuleInstance *myApplet)
{
CD_APPLET_ENTER;
//\_______________ On cree la texture (en-dehors du thread).
if (g_bUseOpenGL)
{
myData.iTexture = cairo_dock_create_texture_from_surface (myData.pCairoSurface);
}
//\______________________ On choisit la transition.
if (myConfig.iAnimation == SLIDER_RANDOM) {
srand(time(NULL));
myData.iAnimation = 1 + (rand() % (SLIDER_RANDOM-1)); //Skip the default animation (1+)
}
else {
myData.iAnimation = myConfig.iAnimation;
}
//\______________________ On initialise la transition.
myData.iAnimCNT = 0;
myData.sens = 1;
//\______________________ On lance la transition.
if (myConfig.iAnimation != SLIDER_DEFAULT) // on lance l'animation.
{
cairo_dock_launch_animation (myContainer);
}
else // on dessine tout de suite et on attend l'image suivante.
{
cd_slider_draw_default (myApplet);
CD_APPLET_REDRAW_MY_ICON;
cd_slider_schedule_next_slide (myApplet);
}
CD_APPLET_LEAVE (FALSE);
}
void cd_slider_jump_to_next_slide (GldiModuleInstance *myApplet)
{
//\___________________________ stop any pending action.
if (myData.iTimerID != 0)
{
g_source_remove (myData.iTimerID);
myData.iTimerID = 0;
}
gldi_task_stop (myData.pMeasureImage);
//\___________________________ On recupere la nouvelle image a afficher.
if (myData.pElement == NULL) // debut
myData.pElement = myData.pList;
else
myData.pElement = cairo_dock_get_next_element (myData.pElement, myData.pList);
if (myData.pElement == NULL || myData.pElement->data == NULL)
{
cd_warning ("Slider stopped, empty list");
return;
}
SliderImage *pImage = myData.pElement->data;
cd_message ("Slider - load %s", pImage->cPath);
//\___________________________ On sauvegarde la surface actuelle.
if (myData.pPrevCairoSurface != NULL && myData.pPrevCairoSurface != myData.pCairoSurface)
cairo_surface_destroy (myData.pPrevCairoSurface);
myData.pPrevCairoSurface = myData.pCairoSurface;
myData.pCairoSurface = NULL;
if (myData.iPrevTexture != 0 && myData.iPrevTexture != myData.iTexture)
glDeleteTextures (1, &myData.iPrevTexture);
myData.iPrevTexture = myData.iTexture;
myData.iTexture = 0;
myData.prevSlideArea = myData.slideArea;
//\___________________________ On ecrit le nom de la nouvelle image en info.
if (myConfig.bImageName && myDesklet)
{
gchar *cFilePath = g_strdup (pImage->cPath);
gchar *cFileName = strrchr (cFilePath, '/');
if (cFileName)
cFileName ++;
else
cFileName = cFilePath;
gchar *ext = strrchr (cFileName, '.');
if (ext)
*ext = '\0';
CD_APPLET_SET_QUICK_INFO_ON_MY_ICON (cFileName);
//cd_debug ("Slider - Image path: %s", pImage->cPath);
g_free (cFilePath);
}
//\___________________________ On charge la nouvelle surface/texture et on lance l'animation de transition.
if (myConfig.bUseThread && CD_APPLET_MY_CONTAINER_IS_OPENGL && pImage->iFormat != SLIDER_SVG && // pour certains SVG, ca plante dans X :-(
((pImage->iFormat == SLIDER_PNG && pImage->iSize > 100e3)
|| (pImage->iFormat == SLIDER_JPG && pImage->iSize > 70e3)
|| (pImage->iFormat == SLIDER_GIF && pImage->iSize > 100e3)
|| (pImage->iFormat == SLIDER_XPM && pImage->iSize > 100e3)) )
{
cd_debug ("Slider - launch thread");
gldi_task_launch (myData.pMeasureImage);
}
else
{
_cd_slider_load_image (myApplet);
_cd_slider_display_image (myApplet);
}
}
static gboolean _next_slide (GldiModuleInstance *myApplet)
{
CD_APPLET_ENTER;
myData.iTimerID = 0; // we'll quit this loop anyway, so reset the timer now so that it doesn't disturb us.
if (! myData.bPause) // if paused, don't go to next slide.
{
cd_slider_jump_to_next_slide (myApplet);
}
CD_APPLET_LEAVE (FALSE);
}
void cd_slider_schedule_next_slide (GldiModuleInstance *myApplet)
{
if (myData.iTimerID == 0)
myData.iTimerID = g_timeout_add_seconds (myConfig.iSlideTime, (GSourceFunc) _next_slide, (gpointer) myApplet);
}
/////////////////
/// EXIF DATA ///
/////////////////
static void _cd_slider_get_exif_props (SliderImage *pImage)
{
#ifdef HAVE_EXIF
ExifData *pExifData;
ExifEntry *pExifEntry;
ExifByteOrder byteOrder;
if (pImage->iFormat == SLIDER_JPG)
{
//g_print ("Slider : %s\n", pImage->cPath);
pExifData = exif_data_new_from_file (pImage->cPath);
if (pExifData != NULL)
{
pExifEntry = exif_data_get_entry (pExifData, EXIF_TAG_ORIENTATION);
if (pExifEntry != NULL)
{
byteOrder = exif_data_get_byte_order (pExifData);
pImage->iOrientation = exif_get_short (pExifEntry->data, byteOrder);
//g_print ("Slider : %s -> orientation %d\n", pImage->cPath, pImage->iOrientation);
}
exif_data_unref (pExifData);
}
}
#endif
pImage->bGotExifData = TRUE;
}
static gboolean _cd_slider_get_exif_props_idle (GldiModuleInstance *myApplet)
{
#ifdef HAVE_EXIF
if (myData.pExifElement == NULL)
{
myData.iSidExifIdle = 0;
return FALSE;
}
SliderImage *pImage = myData.pExifElement->data;
_cd_slider_get_exif_props (pImage);
myData.pExifElement = myData.pExifElement->next;
return TRUE;
#else
myData.pExifElement = NULL;
myData.iSidExifIdle = 0;
return FALSE;
#endif
}
//////////////////////
/// FOLDER PARSING ///
//////////////////////
typedef struct {
gchar *cDirectory;
gboolean bSubDirs;
gboolean bRandom;
GList *pList; // the result
GldiModuleInstance *pApplet;
} CDListSharedMemory;
static void _free_shared_memory (CDListSharedMemory *pSharedMemory)
{
g_free (pSharedMemory->cDirectory);
// cd_slider_free_images_list (pSharedMemory->pList); // should be the same as myData.pList
g_free (pSharedMemory);
}
static int _compare_images_order (SliderImage *image2, SliderImage *image1)
{
if (image1->cPath == NULL)
return -1;
if (image2->cPath == NULL)
return 1;
gchar *cURI_1 = g_ascii_strdown (image1->cPath, -1);
gchar *cURI_2 = g_ascii_strdown (image2->cPath, -1);
int iOrder = strcmp (cURI_1, cURI_2);
g_free (cURI_1);
g_free (cURI_2);
return iOrder;
}
static int _cd_slider_random_compare (gconstpointer a, gconstpointer b, GRand *pRandomGenerator)
{
return (g_rand_boolean (pRandomGenerator) ? 1 : -1);
}
static GList *_list_directory (GList *pList, gchar *cDirectory, gboolean bRecursive, gboolean bSortAlpha)
{
cd_debug ("%s (%s)", __func__, cDirectory);
GError *erreur = NULL;
GDir *dir = g_dir_open (cDirectory, 0, &erreur);
if (erreur != NULL) {
cd_warning ("Slider : %s", erreur->message);
g_error_free (erreur);
return pList;
}
struct stat buf;
SliderImage *pImage;
SliderImageFormat iFormat;
const gchar *cFileName, *extension;
GString *sFilePath = g_string_new ("");
while ((cFileName = g_dir_read_name (dir)) != NULL) {
g_string_printf (sFilePath, "%s/%s", cDirectory, cFileName);
if (stat (sFilePath->str, &buf) != -1) {
if (S_ISDIR (buf.st_mode) && bRecursive) {
pList = _list_directory (pList, sFilePath->str, bRecursive, bSortAlpha);
}
else {
extension = strrchr(cFileName,'.');
if (extension != NULL) {
iFormat = SLIDER_UNKNOWN_FORMAT; // le but du format serait de definir un seuil de taille pour chaque format a partir duquel l'image devrait etre chargee par un thread.
if (g_ascii_strcasecmp(extension, ".png") == 0)
iFormat = SLIDER_PNG;
else if (g_ascii_strcasecmp(extension, ".jpg") == 0 || g_ascii_strcasecmp(extension, ".jpeg") == 0)
iFormat = SLIDER_JPG;
else if (g_ascii_strcasecmp(extension, ".svg") == 0)
iFormat = SLIDER_SVG;
else if (g_ascii_strcasecmp(extension, ".gif") == 0)
iFormat = SLIDER_GIF;
else if (g_ascii_strcasecmp(extension, ".xpm") == 0)
iFormat = SLIDER_XPM;
if (iFormat != SLIDER_UNKNOWN_FORMAT) {
cd_debug ("Slider - Adding %s to list", cFileName);
pImage = g_new0 (SliderImage, 1);
pImage->cPath = g_strdup (sFilePath->str);
pImage->iSize = buf.st_size;
pImage->iFormat = iFormat;
// exif orientation is got later.
if (bSortAlpha) // ordre alphabetique.
pList = g_list_insert_sorted (pList, pImage, (GCompareFunc) _compare_images_order);
else // on randomise a la fin.
pList = g_list_prepend (pList, pImage);
}
}
}
}
}
g_string_free (sFilePath, TRUE);
g_dir_close (dir);
return pList;
}
static void cd_slider_get_files_from_dir (CDListSharedMemory *pSharedMemory)
{
if (pSharedMemory->cDirectory == NULL)
{
cd_warning ("Slider : No directory to scan, halt.");
return;
}
// recursively scan the folder
pSharedMemory->pList = _list_directory (NULL, pSharedMemory->cDirectory, pSharedMemory->bSubDirs, ! pSharedMemory->bRandom);
// randomize the list if necessary
if (pSharedMemory->bRandom)
{
GRand *pRandomGenerator = g_rand_new ();
pSharedMemory->pList = g_list_sort_with_data (pSharedMemory->pList, (GCompareDataFunc) _cd_slider_random_compare, pRandomGenerator);
g_rand_free (pRandomGenerator);
}
}
static gboolean cd_slider_start_slide (CDListSharedMemory *pSharedMemory)
{
// grab the result
GldiModuleInstance *myApplet = pSharedMemory->pApplet;
myData.pList = pSharedMemory->pList;
// if needed, get the EXIF data now
if (myData.iSidExifIdle == 0 && myConfig.bGetExifDataAtOnce)
{
myData.pExifElement = myData.pList;
myData.iSidExifIdle = g_idle_add_full (G_PRIORITY_LOW, // on ne veut pas que ca vienne ralentir le chargement des icones, qui lui a une priorite normale.
(GSourceFunc) _cd_slider_get_exif_props_idle,
myApplet,
NULL);
}
// create the loading task that will be used later
myData.pMeasureImage = gldi_task_new (0,
(GldiGetDataAsyncFunc) _cd_slider_load_image,
(GldiUpdateSyncFunc) _cd_slider_display_image,
myApplet); // 0 <=> one shot task.
// display the first slide.
CD_APPLET_SET_QUICK_INFO_ON_MY_ICON (NULL);
if (myData.pList != NULL)
{
cd_slider_jump_to_next_slide (myApplet);
}
else // no images found or folder not defined => no need to launch the loop, display a 'missing' icon
{
CD_APPLET_SET_IMAGE_ON_MY_ICON (GLDI_ICON_NAME_MISSING_IMAGE);
}
return FALSE;
}
void cd_slider_start (GldiModuleInstance *myApplet, gboolean bDelay)
{
gldi_task_discard (myData.pMeasureDirectory);
// remember the current params.
g_free (myData.cDirectory);
myData.cDirectory = g_strdup (myConfig.cDirectory);
myData.bSubDirs = myConfig.bSubDirs;
myData.bRandom = myConfig.bRandom;
// create a task to parse the folder.
CDListSharedMemory *pSharedMemory = g_new0 (CDListSharedMemory, 1);
pSharedMemory->bSubDirs = myConfig.bSubDirs;
pSharedMemory->bRandom = myConfig.bRandom;
pSharedMemory->cDirectory = g_strdup (myConfig.cDirectory);
pSharedMemory->pApplet = myApplet;
CD_APPLET_SET_QUICK_INFO_ON_MY_ICON ("..."); // Note: we could launch a 'busy' animation, but it's maybe not a good idea to add more CPU load (anyway, the animation should be launched with a g_idle_add, because animations may not be inited yet).
myData.pMeasureDirectory = gldi_task_new_full (0,
(GldiGetDataAsyncFunc) cd_slider_get_files_from_dir,
(GldiUpdateSyncFunc) cd_slider_start_slide,
(GFreeFunc) _free_shared_memory,
pSharedMemory); // 0 <=> one shot task.
// launch the parsing.
if (bDelay)
gldi_task_launch_delayed (myData.pMeasureDirectory, cairo_dock_is_loading () ? 1500. : 0.); // launch with a delay or just in the next main loop event.
else
gldi_task_launch (myData.pMeasureDirectory);
}
void cd_slider_stop (GldiModuleInstance *myApplet)
{
//Stop all processes
gldi_task_free (myData.pMeasureImage); // since it needs a cairo context, we can't let it live.
myData.pMeasureImage = NULL;
gldi_task_discard (myData.pMeasureDirectory);
myData.pMeasureDirectory = NULL;
if (myData.iSidExifIdle != 0)
{
g_source_remove(myData.iSidExifIdle);
myData.iSidExifIdle = 0;
}
if (myData.iScrollID != 0)
{
g_source_remove (myData.iScrollID);
myData.iScrollID = 0;
}
if (myData.iTimerID != 0)
{
g_source_remove(myData.iTimerID);
myData.iTimerID = 0;
}
// destroy current buffers.
if (myData.pCairoSurface)
{
cairo_surface_destroy (myData.pCairoSurface);
myData.pCairoSurface = NULL;
}
if (myData.pPrevCairoSurface)
{
cairo_surface_destroy (myData.pPrevCairoSurface);
myData.pPrevCairoSurface = NULL;
}
if (myData.iPrevTexture != 0)
{
_cairo_dock_delete_texture (myData.iPrevTexture);
myData.iPrevTexture = 0;
}
if (myData.iTexture != 0)
{
_cairo_dock_delete_texture (myData.iTexture);
myData.iTexture = 0;
}
cd_slider_free_images_list (myData.pList);
myData.pList = NULL;
myData.pElement = NULL;
myData.pExifElement = NULL;
myData.bPause = FALSE;
}