void cd_clock_load_textures (CairoDockModuleInstance *myApplet)
{
if (myData.pBackgroundSurface != NULL)
myData.iBgTexture = cairo_dock_create_texture_from_surface (myData.pBackgroundSurface);
if (myData.pForegroundSurface != NULL)
myData.iFgTexture = cairo_dock_create_texture_from_surface (myData.pForegroundSurface);
int iWidth, iHeight;
CD_APPLET_GET_MY_ICON_EXTENT (&iWidth, &iHeight);
int iSize = MIN (iWidth, iHeight);
myData.fNeedleScale = (double) iSize / (double) myData.needleDimension.width; // car l'aiguille est a l'horizontale dans le fichier svg.
myData.iNeedleWidth = (double) myData.iNeedleRealWidth * myData.fNeedleScale;
myData.iNeedleHeight = (double) myData.iNeedleRealHeight * myData.fNeedleScale;
cairo_surface_t *pNeedleSurface = create_needle_surface (myApplet,
myDrawContext,
KIND_HOUR);
if (pNeedleSurface != NULL)
{
myData.iHourNeedleTexture = cairo_dock_create_texture_from_surface (pNeedleSurface);
cairo_surface_destroy (pNeedleSurface);
}
pNeedleSurface = create_needle_surface (myApplet,
myDrawContext,
KIND_MINUTE);
if (pNeedleSurface != NULL)
{
myData.iMinuteNeedleTexture = cairo_dock_create_texture_from_surface (pNeedleSurface);
cairo_surface_destroy (pNeedleSurface);
}
pNeedleSurface = create_needle_surface (myApplet,
myDrawContext,
KIND_SECOND);
if (pNeedleSurface != NULL)
{
myData.iSecondNeedleTexture = cairo_dock_create_texture_from_surface (pNeedleSurface);
cairo_surface_destroy (pNeedleSurface);
}
}
/* Applique la surface correspondant a un etat sur l'icone.
*/
void cd_musicplayer_apply_status_surface (MyPlayerStatus iStatus)
{
cd_debug ("%s (%d)", __func__, iStatus);
g_return_if_fail (iStatus < PLAYER_NB_STATUS);
gboolean bUse3DTheme = (CD_APPLET_MY_CONTAINER_IS_OPENGL && myConfig.bOpenglThemes);
cairo_surface_t *pSurface = myData.pSurfaces[iStatus];
// load the surface if not already in cache
if (pSurface == NULL)
{
gchar *cUserIcon = myConfig.cUserImage[iStatus];
if (cUserIcon != NULL) // l'utilisateur a defini une icone perso pour ce statut => on essaye de la charger.
{
gchar *cUserImagePath = cairo_dock_search_icon_s_path (cUserIcon, MAX (myIcon->image.iWidth, myIcon->image.iHeight));
myData.pSurfaces[iStatus] = CD_APPLET_LOAD_SURFACE_FOR_MY_APPLET (cUserImagePath ? cUserImagePath : cUserIcon); // si on a trouve une icone, on la prend, sinon on considere le fichier comme une image.
g_free (cUserImagePath);
}
if (myData.pSurfaces[iStatus] == NULL) // pas d'icone perso pour ce statut, ou l'icone specifiee n'a pas ete trouvee ou pas ete chargee => on prend l'icone par defaut.
{
const gchar **cIconName = (bUse3DTheme ? s_cDefaultIconName3D : s_cDefaultIconName);
gchar *cImagePath = g_strdup_printf (MY_APPLET_SHARE_DATA_DIR"/%s", cIconName[iStatus]);
myData.pSurfaces[iStatus] = CD_APPLET_LOAD_SURFACE_FOR_MY_APPLET (cImagePath);
g_free (cImagePath);
}
pSurface = myData.pSurfaces[iStatus];
g_return_if_fail (pSurface != NULL);
}
// apply the surface
if (bUse3DTheme) // 3D theme -> make a transition
{
if (myData.iPrevTextureCover != 0)
_cairo_dock_delete_texture (myData.iPrevTextureCover);
myData.iPrevTextureCover = myData.TextureCover;
myData.TextureCover = cairo_dock_create_texture_from_surface (pSurface);
if (myData.iPrevTextureCover != 0)
{
myData.iCoverTransition = NB_TRANSITION_STEP;
cairo_dock_launch_animation (myContainer);
}
else
{
cd_opengl_render_to_texture (myApplet);
CD_APPLET_REDRAW_MY_ICON;
}
}
else // just apply the surface (we could make a transition too ...)
{
CD_APPLET_SET_SURFACE_ON_MY_ICON (pSurface);
}
}
gboolean cd_clock_update_with_time (GldiModuleInstance *myApplet)
{
CD_APPLET_ENTER;
//\________________ On recupere l'heure courante.
time_t epoch = (time_t) time (NULL);
_get_current_time (epoch, myApplet);
//\________________ On change la date si necessaire.
int iWidth, iHeight;
CD_APPLET_GET_MY_ICON_EXTENT (&iWidth, &iHeight);
gboolean bNewDate = (myData.currentTime.tm_mday != myData.iLastCheckedDay || myData.currentTime.tm_mon != myData.iLastCheckedMonth || myData.currentTime.tm_year != myData.iLastCheckedYear);
if (bNewDate)
{
strftime (s_cDateBuffer, CD_CLOCK_DATE_BUFFER_LENGTH, "%a %d %b", &myData.currentTime);
myData.iLastCheckedDay = myData.currentTime.tm_mday;
myData.iLastCheckedMonth = myData.currentTime.tm_mon;
myData.iLastCheckedYear = myData.currentTime.tm_year;
}
if (CD_APPLET_MY_CONTAINER_IS_OPENGL && myConfig.bOldStyle && myConfig.iShowDate == CAIRO_DOCK_INFO_ON_ICON)
{
if (bNewDate || myData.iDateTexture == 0)
{
if (myData.iDateTexture != 0)
_cairo_dock_delete_texture (myData.iDateTexture);
double fScale = (double) iWidth / (double) myData.DimensionData.width;
GldiTextDescription labelDescription;
memset (&labelDescription, 0, sizeof (GldiTextDescription));
gldi_text_description_set_font (&labelDescription, (gchar*)"Sans 8"); // casted and then set to null
labelDescription.fColorStart.rgba.red = myConfig.fDateColor[0];
labelDescription.fColorStart.rgba.green = myConfig.fDateColor[1];
labelDescription.fColorStart.rgba.blue = myConfig.fDateColor[2];
labelDescription.fColorStart.rgba.alpha = 1.;
labelDescription.bNoDecorations = TRUE;
cairo_surface_t *pDateSurface = cairo_dock_create_surface_from_text_full (s_cDateBuffer,
&labelDescription,
fScale,
iWidth,
&myData.iDateWidth, &myData.iDateHeight);
//g_print ("date : %dx%d\n", myData.iDateWidth, myData.iDateHeight);
myData.iDateTexture = cairo_dock_create_texture_from_surface (pDateSurface);
cairo_surface_destroy (pDateSurface);
labelDescription.cFont = NULL;
gldi_text_description_reset (&labelDescription);
}
}
if (bNewDate && myConfig.iShowDate == CAIRO_DOCK_INFO_ON_LABEL)
{
CD_APPLET_SET_NAME_FOR_MY_ICON (s_cDateBuffer);
}
//\________________ On dessine avec cette heure.
myData.iSmoothAnimationStep = 0;
if (myConfig.bOldStyle)
{
if (CD_APPLET_MY_CONTAINER_IS_OPENGL)
cd_clock_render_analogic_to_texture (myApplet, iWidth, iHeight, &myData.currentTime, 0.);
else
cd_clock_draw_analogic (myApplet, iWidth, iHeight, &myData.currentTime);
}
else
{
cd_clock_draw_text (myApplet, iWidth, iHeight, &myData.currentTime);
///if (CD_APPLET_MY_CONTAINER_IS_OPENGL) // on ne sait pas bien dessiner du texte, donc on le fait en cairo, et on transfere tout sur notre texture.
/// cairo_dock_update_icon_texture (myIcon);
}
///CD_APPLET_REDRAW_MY_ICON;
//\________________ On teste les alarmes et les taches.
if (!myConfig.bShowSeconds || myData.currentTime.tm_min != myData.iLastCheckedMinute) // un g_timeout de 1min ne s'effectue pas forcement a exectement 1 minute d'intervalle, et donc pourrait "sauter" la minute de l'alarme, d'ou le test sur bShowSeconds dans le cas ou l'applet ne verifie que chaque minute.
{
myData.iLastCheckedMinute = myData.currentTime.tm_min;
// les alarmes.
CDClockAlarm *pAlarm;
guint i;
for (i = 0; i < myConfig.pAlarms->len; i ++)
{
pAlarm = g_ptr_array_index (myConfig.pAlarms, i);
if (myData.currentTime.tm_hour == pAlarm->iHour && myData.currentTime.tm_min == pAlarm->iMinute)
{
gboolean bShowAlarm = FALSE, bRemoveAlarm = FALSE;
if (pAlarm->iDayOfWeek > 0)
{
if (pAlarm->iDayOfWeek == 1)
bShowAlarm = TRUE;
else if (pAlarm->iDayOfWeek - 1 == myData.currentTime.tm_wday)
bShowAlarm = TRUE;
else if (myData.currentTime.tm_wday == 0 || myData.currentTime.tm_wday == 6) // week-end
{
if (pAlarm->iDayOfWeek == 9)
bShowAlarm = TRUE;
}
else if (pAlarm->iDayOfWeek == 8)
bShowAlarm = TRUE;
}
else if (pAlarm->iDayOfMonth > 0)
bShowAlarm = (pAlarm->iDayOfMonth - 1 == myData.currentTime.tm_mday);
else // c'est une alarme qui ne se repete pas.
{
bShowAlarm = TRUE;
bRemoveAlarm = TRUE;
}
if (bShowAlarm)
{
cd_message ("Dring ! %s", pAlarm->cMessage);
gldi_dialog_show_temporary (pAlarm->cMessage, myIcon, myContainer, 60e3);
if (pAlarm->cCommand != NULL)
{
if (myData.iAlarmPID > 0)
{
kill (myData.iAlarmPID, 1);
myData.iAlarmPID = 0;
}
GError *erreur = NULL;
gchar **argv = g_strsplit (pAlarm->cCommand, " ", -1);
g_spawn_async (NULL,
argv,
NULL,
0,
NULL,
NULL,
&myData.iAlarmPID,
&erreur);
if (erreur != NULL)
{
cd_warning ("clock : when trying to execute '%s' : %s", pAlarm->cCommand, erreur->message);
g_error_free (erreur);
myData.iAlarmPID = 0;
}
g_strfreev (argv);
cd_message (" --> child_pid : %d", myData.iAlarmPID);
}
}
if (bRemoveAlarm)
{
cd_message ("Cette alarme ne sera pas repetee");
g_ptr_array_remove_index (myConfig.pAlarms, i);
cd_clock_free_alarm (pAlarm);
/// A FAIRE : effacer l'heure dans le fichier de conf pour cette alarme.
}
}
}
// display missed tasks.
if (!myData.bTaskCheckedOnce)
{
myData.bTaskCheckedOnce = TRUE;
myData.pMissedTasks = cd_clock_get_missed_tasks (myApplet);
}
if (myData.pMissedTasks != NULL) // so if the dialog was closed before we could acknowledge all the tasks, it will re-open.
{
CDClockTask *pTask = myData.pMissedTasks->data;
gchar *cMessage = _make_missed_task_message (pTask, myApplet);
CairoDialogAttr attr;
memset (&attr, 0, sizeof (CairoDialogAttr));
attr.cText = cMessage;
attr.bUseMarkup = TRUE;
attr.cImageFilePath = (gchar *)MY_APPLET_SHARE_DATA_DIR"/icon-task.png";
const gchar *cButtonsImage[3] = {"ok", NULL, NULL};
if (myData.pMissedTasks->next != NULL)
{
cButtonsImage[0] = "cancel";
cButtonsImage[1] = "next.png";
}
attr.cButtonsImage = cButtonsImage;
attr.pActionFunc = (CairoDockActionOnAnswerFunc)_on_next_missed_task;
attr.pUserData = myApplet;
attr.pFreeDataFunc = NULL;
attr.iTimeLength = 0;
attr.pIcon = myIcon;
attr.pContainer = myContainer;
gldi_dialog_new (&attr);
g_free (cMessage);
}
// display next task.
if (myData.pNextTask != NULL)
{
//g_print ("next task : %s\n", myData.pNextTask->cTitle);
struct tm st;
st.tm_min = myData.pNextTask->iMinute;
st.tm_hour = myData.pNextTask->iHour;
st.tm_mday = myData.pNextTask->iDay;
st.tm_mon = myData.pNextTask->iMonth;
st.tm_year = myData.pNextTask->iYear - 1900;
st.tm_sec = 0;
st.tm_isdst = myData.currentTime.tm_isdst;
time_t t = mktime (&st);
//g_print ("time : %ld, task : %ld\n", epoch, t);
if (t < epoch) // la tache est depassee.
{
// acknowledge this task
myData.pNextTask->bAcknowledged = TRUE;
myData.pBackend->update_task (myData.pNextTask, myApplet);
// look for next task.
myData.pNextTask = cd_clock_get_next_scheduled_task (myApplet);
}
else if (t < epoch + 15*60 && t >= epoch)
{
if (t < epoch + 60)
{
if (! myData.pNextTask->bFirstWarning)
{
//g_print ("first warning\n");
myData.pNextTask->bFirstWarning = TRUE;
gchar *cText = g_strdup_printf ("%s\n<b>%s</b>\n %s\n\n%s",
D_("It's time for the following task:"),
myData.pNextTask->cTitle?myData.pNextTask->cTitle:D_("No title"),
myData.pNextTask->cText?myData.pNextTask->cText:"",
D_("Repeat this message every:"));
_task_warning (myData.pNextTask, cText);
g_free (cText);
}
}
else if (! myData.pNextTask->b15mnWarning)
{
//g_print ("15 mn warning\n");
myData.pNextTask->b15mnWarning = TRUE;
gchar *cText = g_strdup_printf ("%s\n<b>%s</b>\n %s",
D_("This task will begin in 15 minutes:"),
myData.pNextTask->cTitle?myData.pNextTask->cTitle:D_("No title"),
myData.pNextTask->cText?myData.pNextTask->cText:"");
CairoDialogAttr attr;
memset (&attr, 0, sizeof (CairoDialogAttr));
attr.cText = (gchar *)cText;
attr.cImageFilePath = (gchar *)MY_APPLET_SHARE_DATA_DIR"/icon-task.png";
attr.iTimeLength = 60e3;
attr.bUseMarkup = TRUE;
attr.pIcon = myIcon;
attr.pContainer = myContainer;
gldi_dialog_new (&attr);
CD_APPLET_DEMANDS_ATTENTION (NULL, 60);
}
}
// display next anniversary if it is scheduled in less than 1 day, because anniversary require time to prepare.
if (myData.pNextAnniversary != NULL)
{
if (!myData.pNextAnniversary->b1DayWarning && ! myData.pNextAnniversary->bFirstWarning && ! myData.pNextAnniversary->b15mnWarning)
{
GDate* pCurrentDate = g_date_new_dmy (myData.currentTime.tm_mday, myData.currentTime.tm_mon + 1, myData.currentTime.tm_year+1900);
GDate* pAnnivDate = g_date_new_dmy (myData.pNextAnniversary->iDay, myData.pNextAnniversary->iMonth + 1, myData.currentTime.tm_year+1900);
gint iDaysToNextAnniversary = g_date_days_between (pCurrentDate, pAnnivDate);
if (iDaysToNextAnniversary >= 0 && iDaysToNextAnniversary <= 1)
{
myData.pNextAnniversary->b1DayWarning = TRUE;
gchar *cText = g_strdup_printf ("%s\n<b>%s</b>\n %s\n\n%s",
iDaysToNextAnniversary == 0 ? D_("Today is the following anniversary:") : D_("Tomorrow is the following anniversary:"),
myData.pNextTask->cTitle?myData.pNextTask->cTitle:D_("No title"),
myData.pNextTask->cText?myData.pNextTask->cText:"",
D_("Repeat this message every:"));
_task_warning (myData.pNextTask, cText);
g_free (cText);
myData.pNextAnniversary = cd_clock_get_next_anniversary (myApplet);
}
g_date_free (pCurrentDate);
g_date_free (pAnnivDate);
}
}
}
}
CD_APPLET_LEAVE(TRUE);
}
gboolean cd_opengl_load_3D_theme (CairoDockModuleInstance *myApplet, gchar *cThemePath)
{
gchar *cImageName;
cairo_surface_t *pSurface;
gchar *cConfFilePath = g_strdup_printf ("%s/%s", cThemePath, "theme.conf");
GKeyFile *pKeyFile = cairo_dock_open_key_file (cConfFilePath);
g_free (cConfFilePath);
if (pKeyFile == NULL)
return FALSE;
gchar *cThemePathUpToDate = NULL;
gint iVersion = g_key_file_get_integer (pKeyFile, "Description", "Version", NULL);
if (iVersion != 2)
{
/// effacer le theme et le recuperer sur le serveur...
g_print ("theme en version inferieure => sera mis a jour...\n");
// on ferme la config de l'actuel theme.
g_key_file_free (pKeyFile);
pKeyFile = NULL;
// on supprime le theme.
g_return_val_if_fail (cThemePath && *cThemePath == '/', FALSE);
gchar *cCommand = g_strdup_printf ("rm -rf '%s'", cThemePath);
int r = system (cCommand);
g_free (cCommand);
// on recupere le theme distant.
pKeyFile = cairo_dock_open_key_file (myApplet->cConfFilePath);
if (pKeyFile != NULL)
{
gboolean bFlushConfFileNeeded = FALSE;
cThemePathUpToDate = CD_CONFIG_GET_THEME_PATH ("Configuration", "theme", "themes", "cd_box_simple");
cThemePath = cThemePathUpToDate;
g_key_file_free (pKeyFile);
pKeyFile = NULL;
// on ouvre la config du nouveau theme.
cConfFilePath = g_strdup_printf ("%s/%s", cThemePath, "theme.conf");
pKeyFile = cairo_dock_open_key_file (cConfFilePath);
g_free (cConfFilePath);
if (pKeyFile == NULL)
return FALSE;
}
g_return_val_if_fail (pKeyFile != NULL, FALSE);
}
GError *erreur = NULL;
GString *sImagePath = g_string_new ("");
//\_______________ les images d'avant et arriere plan.
int iWidth, iHeight;
CD_APPLET_GET_MY_ICON_EXTENT (&iWidth, &iHeight);
double fImageWidth, fImageHeight; // dimensions de la surface generee.
double fZoomX=1, fZoomY=1; // facteur de zoom qui lui a ete applique.
cImageName = g_key_file_get_string (pKeyFile, "Pictures", "frame", &erreur);
_check_error(erreur);
if (cImageName != NULL)
{
g_string_printf (sImagePath, "%s/%s", cThemePath, cImageName);
pSurface = cairo_dock_create_surface_from_image (sImagePath->str,
myDrawContext,
1.,
iWidth, iHeight,
CAIRO_DOCK_FILL_SPACE,
&fImageWidth, &fImageHeight,
&fZoomX, &fZoomY);
myData.TextureFrame = cairo_dock_create_texture_from_surface (pSurface);
cairo_surface_destroy (pSurface);
g_free (cImageName);
}
cImageName = g_key_file_get_string (pKeyFile, "Pictures", "reflect", &erreur);
_check_error(erreur);
if (cImageName != NULL)
{
g_string_printf (sImagePath, "%s/%s", cThemePath, cImageName);
pSurface = cairo_dock_create_surface_from_image (sImagePath->str,
myDrawContext,
1.,
iWidth, iHeight,
CAIRO_DOCK_FILL_SPACE,
&fImageWidth, &fImageHeight,
NULL, NULL);
myData.TextureReflect = cairo_dock_create_texture_from_surface (pSurface);
cairo_surface_destroy (pSurface);
g_free (cImageName);
}
//\_______________ les coordonnees des 4 coins de la pochette
// dans le referentiel du cadre (directement obtenues avec Gimp) => dans le referentiel de l'icone iWidth x iHeight.
myData.itopleftX = g_key_file_get_integer (pKeyFile, "Configuration", "topleftX", &erreur) * fZoomX;
_check_error(erreur);
myData.itopleftY = g_key_file_get_integer (pKeyFile, "Configuration", "topleftY", &erreur) * fZoomY;
_check_error(erreur);
myData.ibottomleftX = g_key_file_get_integer (pKeyFile, "Configuration", "bottomleftX", &erreur) * fZoomX;
_check_error(erreur);
myData.ibottomleftY = g_key_file_get_integer (pKeyFile, "Configuration", "bottomleftY", &erreur) * fZoomY;
_check_error(erreur);
myData.ibottomrightX = g_key_file_get_integer (pKeyFile, "Configuration", "bottomrightX", &erreur) * fZoomX;
_check_error(erreur);
myData.ibottomrightY = g_key_file_get_integer (pKeyFile, "Configuration", "bottomrightY", &erreur) * fZoomY;
_check_error(erreur);
myData.itoprightX = g_key_file_get_integer (pKeyFile, "Configuration", "toprightX", &erreur) * fZoomX;
_check_error(erreur);
myData.itoprightY = g_key_file_get_integer (pKeyFile, "Configuration", "toprightY", &erreur) * fZoomY;
_check_error(erreur);
//\_______________ On definit la calllist qui déforme la pochette.
myData.draw_cover = glGenLists(1);
glNewList(myData.draw_cover , GL_COMPILE);
glBegin(GL_QUADS);
glTexCoord2d (0,0);
glVertex3f (-.5 + myData.itopleftX / iWidth, +.5 - myData.itopleftY / iHeight, 0);
glTexCoord2d (0,1);
glVertex3f (-.5 + myData.ibottomleftX / iWidth, +.5 - myData.ibottomleftY /iHeight, 0.);
glTexCoord2d (1,1);
glVertex3f (-.5 + myData.ibottomrightX / iWidth, +.5 - myData.ibottomrightY / iHeight, 0.);
glTexCoord2d (1,0);
glVertex3f (-.5 + myData.itoprightX / iWidth, +.5 - myData.itoprightY / iHeight, 0.);
glEnd();
glEndList();
//\_______________ les zones cliquables et l'OSD.
myData.numberButtons = g_key_file_get_integer (pKeyFile, "Buttons", "number", NULL);
if (myData.numberButtons != 0)
{
myData.osd = g_key_file_get_boolean (pKeyFile, "Buttons", "osd", &erreur);
_check_error(erreur);
// Bouton 1
myData.button1sizeX = g_key_file_get_integer (pKeyFile, "Button1", "sizeX", &erreur) * fZoomX;
_check_error(erreur);
myData.button1sizeY = g_key_file_get_integer (pKeyFile, "Button1", "sizeY", &erreur) * fZoomY;
_check_error(erreur);
myData.button1coordX = g_key_file_get_integer (pKeyFile, "Button1", "X", &erreur) * fZoomX + myData.button1sizeX/2; // on se ramene au centre.
_check_error(erreur);
myData.button1coordY = g_key_file_get_integer (pKeyFile, "Button1", "Y", &erreur) * fZoomY + myData.button1sizeY/2; // on se ramene au centre.
_check_error(erreur);
_make_texture_at_size (myData.TextureButton1, "Button1", "picture", myData.button1sizeX, myData.button1sizeY);
if (myData.osd)
{
myData.osdPlaysizeX = g_key_file_get_integer (pKeyFile, "Button1", "osd play sizeX", &erreur) * fZoomX;
_check_error(erreur);
myData.osdPlaysizeY = g_key_file_get_integer (pKeyFile, "Button1", "osd play sizeY", &erreur) * fZoomY;
_check_error(erreur);
myData.osdPlaycoordX = g_key_file_get_integer (pKeyFile, "Button1", "osd play X", &erreur) * fZoomX + myData.osdPlaysizeX/2;
_check_error(erreur);
myData.osdPlaycoordY = g_key_file_get_integer (pKeyFile, "Button1", "osd play Y", &erreur) * fZoomY + myData.osdPlaysizeY/2;
_check_error(erreur);
_make_texture_at_size (myData.TextureOsdPlay, "Button1", "osd_play", myData.osdPlaysizeX, myData.osdPlaysizeY);
myData.osdPausesizeX = g_key_file_get_integer (pKeyFile, "Button1", "osd pause sizeX", &erreur) * fZoomX;
_check_error(erreur);
myData.osdPausesizeY = g_key_file_get_integer (pKeyFile, "Button1", "osd pause sizeY", &erreur) * fZoomY;
_check_error(erreur);
myData.osdPausecoordX = g_key_file_get_integer (pKeyFile, "Button1", "osd pause X", &erreur) * fZoomX + myData.osdPausesizeX/2;
_check_error(erreur);
myData.osdPausecoordY = g_key_file_get_integer (pKeyFile, "Button1", "osd pause Y", &erreur) * fZoomY + myData.osdPausesizeY/2;
_check_error(erreur);
_make_texture_at_size (myData.TextureOsdPause, "Button1", "osd_pause", myData.osdPausesizeX, myData.osdPausesizeY);
}
// Bouton 4
if (myData.numberButtons > 3)
{
_check_error(erreur);
myData.button4sizeX = g_key_file_get_integer (pKeyFile, "Button4", "sizeX", &erreur) * fZoomX;
_check_error(erreur);
myData.button4sizeY = g_key_file_get_integer (pKeyFile, "Button4", "sizeY", &erreur) * fZoomY;
_check_error(erreur);
myData.button4coordX = g_key_file_get_integer (pKeyFile, "Button4", "X", &erreur) * fZoomX + myData.button4sizeX/2;
_check_error(erreur);
myData.button4coordY = g_key_file_get_integer (pKeyFile, "Button4", "Y", &erreur) * fZoomY + myData.button4sizeY/2;
_make_texture_at_size (myData.TextureButton4, "Button4", "picture", myData.button4sizeX, myData.button4sizeY);
if (myData.osd)
{
myData.osdHomesizeX = g_key_file_get_integer (pKeyFile, "Button4", "osd sizeX", &erreur) * fZoomX;
_check_error(erreur);
myData.osdHomesizeY = g_key_file_get_integer (pKeyFile, "Button4", "osd sizeY", &erreur) * fZoomY;
_check_error(erreur);
myData.osdHomecoordX = g_key_file_get_integer (pKeyFile, "Button4", "osd X", &erreur) * fZoomX + myData.osdHomesizeX/2;
_check_error(erreur);
myData.osdHomecoordY = g_key_file_get_integer (pKeyFile, "Button4", "osd Y", &erreur) * fZoomY + myData.osdHomesizeY/2;
_check_error(erreur);
_make_texture_at_size (myData.TextureOsdHome, "Button4", "osd", myData.osdHomesizeX, myData.osdHomesizeY);
}
}
// Bouton 3
if (myData.numberButtons > 2)
{
myData.button3sizeX = g_key_file_get_integer (pKeyFile, "Button3", "sizeX", &erreur) * fZoomX;
_check_error(erreur);
myData.button3sizeY = g_key_file_get_integer (pKeyFile, "Button3", "sizeY", &erreur) * fZoomY;
_check_error(erreur);
myData.button3coordX = g_key_file_get_integer (pKeyFile, "Button3", "X", &erreur) * fZoomX + myData.button3sizeX/2;
_check_error(erreur);
myData.button3coordY = g_key_file_get_integer (pKeyFile, "Button3", "Y", &erreur) * fZoomY + myData.button3sizeY/2;
_check_error(erreur);
_make_texture_at_size (myData.TextureButton3, "Button3", "picture", myData.button3sizeX, myData.button3sizeY);
if (myData.osd)
{
myData.osdNextsizeX = g_key_file_get_integer (pKeyFile, "Button3", "osd sizeX", &erreur) * fZoomX;
_check_error(erreur);
myData.osdNextsizeY = g_key_file_get_integer (pKeyFile, "Button3", "osd sizeY", &erreur) * fZoomY;
_check_error(erreur);
myData.osdNextcoordX = g_key_file_get_integer (pKeyFile, "Button3", "osd X", &erreur) * fZoomX + myData.osdNextsizeX/2;
_check_error(erreur);
myData.osdNextcoordY = g_key_file_get_integer (pKeyFile, "Button3", "osd Y", &erreur) * fZoomY + myData.osdNextsizeY/2;
_check_error(erreur);
_make_texture_at_size (myData.TextureOsdNext, "Button3", "osd", myData.osdNextsizeX, myData.osdNextsizeY);
}
}
// Bouton 2
if (myData.numberButtons > 1)
{
myData.button2sizeX = g_key_file_get_integer (pKeyFile, "Button2", "sizeX", &erreur) * fZoomX;
_check_error(erreur);
myData.button2sizeY = g_key_file_get_integer (pKeyFile, "Button2", "sizeY", &erreur) * fZoomY;
_check_error(erreur);
myData.button2coordX = g_key_file_get_integer (pKeyFile, "Button2", "X", &erreur) * fZoomX + myData.button2sizeX/2;
_check_error(erreur);
myData.button2coordY = g_key_file_get_integer (pKeyFile, "Button2", "Y", &erreur) * fZoomY + myData.button2sizeY/2;
_check_error(erreur);
_make_texture_at_size (myData.TextureButton2, "Button2", "picture", myData.button2sizeX, myData.button2sizeY);
if (myData.osd)
{
myData.osdPrevsizeX = g_key_file_get_integer (pKeyFile, "Button2", "osd sizeX", &erreur) * fZoomX;
_check_error(erreur);
myData.osdPrevsizeY = g_key_file_get_integer (pKeyFile, "Button2", "osd sizeY", &erreur) * fZoomY;
_check_error(erreur);
myData.osdPrevcoordX = g_key_file_get_integer (pKeyFile, "Button2", "osd X", &erreur) * fZoomX + myData.osdPrevsizeX/2;
_check_error(erreur);
myData.osdPrevcoordY = g_key_file_get_integer (pKeyFile, "Button2", "osd Y", &erreur) * fZoomY + myData.osdPrevsizeY/2;
_check_error(erreur);
_make_texture_at_size (myData.TextureOsdPrev, "Button2", "osd", myData.osdPrevsizeX, myData.osdPrevsizeY);
}
}
}
g_key_file_free (pKeyFile);
g_free (cThemePathUpToDate);
return TRUE;
}
static void _cairo_dock_finish_load_data_renderer (CairoDataRenderer *pRenderer, gboolean bLoadTextures, Icon *pIcon)
{
int iNbValues = cairo_data_renderer_get_nb_values (pRenderer);
//\___________________ On charge les emblemes si l'implementation les a valides.
if (pRenderer->pEmblems != NULL)
{
CairoDataRendererEmblem *pEmblem;
cairo_surface_t *pSurface;
int i;
for (i = 0; i < iNbValues; i ++)
{
pEmblem = &pRenderer->pEmblems[i];
if (pEmblem->pSurface != NULL)
{
cairo_surface_destroy (pEmblem->pSurface);
pEmblem->pSurface = NULL;
}
if (pEmblem->iTexture != 0)
{
_cairo_dock_delete_texture (pEmblem->iTexture);
pEmblem->iTexture = 0;
}
if (pEmblem->param.fWidth != 0 && pEmblem->param.fHeight != 0 && pEmblem->cImagePath != NULL)
{
pSurface = cairo_dock_create_surface_from_image_simple (pEmblem->cImagePath,
pEmblem->param.fWidth * pRenderer->iWidth,
pEmblem->param.fHeight * pRenderer->iHeight);
if (bLoadTextures)
{
pEmblem->iTexture = cairo_dock_create_texture_from_surface (pSurface);
cairo_surface_destroy (pSurface);
}
else
pEmblem->pSurface = pSurface;
}
}
}
//\___________________ On charge les labels si l'implementation les a valides.
if (pRenderer->pLabels != NULL)
{
GldiTextDescription textDescription;
gldi_text_description_copy (&textDescription, &myIconsParam.quickInfoTextDescription);
CairoDataRendererText *pLabel;
cairo_surface_t *pSurface;
int i;
for (i = 0; i < iNbValues; i ++)
{
pLabel = &pRenderer->pLabels[i];
if (pLabel->pSurface != NULL)
{
cairo_surface_destroy (pLabel->pSurface);
pLabel->pSurface = NULL;
}
if (pLabel->iTexture != 0)
{
_cairo_dock_delete_texture (pLabel->iTexture);
pLabel->iTexture = 0;
}
if (pLabel->param.fWidth != 0 && pLabel->param.fHeight != 0 && pLabel->cText != NULL)
{
textDescription.bNoDecorations = TRUE;
textDescription.bUseDefaultColors = FALSE;
textDescription.iMargin = 0;
textDescription.bOutlined = TRUE; /// tester avec et sans ...
textDescription.fColorStart.rgba.red = pLabel->param.pColor[0];
textDescription.fColorStart.rgba.green = pLabel->param.pColor[1];
textDescription.fColorStart.rgba.blue = pLabel->param.pColor[2];
textDescription.fColorStart.rgba.alpha = 1.;
pSurface = cairo_dock_create_surface_from_text (pLabel->cText,
&textDescription,
&pLabel->iTextWidth, &pLabel->iTextHeight);
if (bLoadTextures)
{
pLabel->iTexture = cairo_dock_create_texture_from_surface (pSurface);
cairo_surface_destroy (pSurface);
}
else
pLabel->pSurface = pSurface;
}
}
}
//\___________________ On regarde si le texte dessine sur l'icone sera suffisamment lisible.
if (pRenderer->pValuesText != NULL)
{
CairoDataRendererTextParam *pText = &pRenderer->pValuesText[0];
//g_print ("+++++++pText->fWidth * pRenderer->iWidth : %.2f\n", pText->fWidth * pRenderer->iWidth);
pRenderer->bCanRenderValueAsText = (pText->fWidth * pRenderer->iWidth >= CD_MIN_TEXT_WITH);
}
if (pRenderer->bCanRenderValueAsText && pRenderer->bWriteValues)
gldi_icon_set_quick_info (pIcon, NULL);
//\___________________ Build an overlay if the renderer will use some.
if (pRenderer->bUseOverlay)
{
//g_print ("+ overlay %dx%d\n", pRenderer->iWidth, pRenderer->iHeight);
cairo_surface_t *pSurface = cairo_dock_create_blank_surface (pRenderer->iWidth, pRenderer->iHeight);
pRenderer->pOverlay = cairo_dock_add_overlay_from_surface (pIcon, pSurface, pRenderer->iWidth, pRenderer->iHeight, pRenderer->iOverlayPosition, (gpointer)"data-renderer"); // this string is constant; any previous overlay will be removed.
cairo_dock_set_overlay_scale (pRenderer->pOverlay, 0); // keep the original size of the image
}
}
static void _make_bar_surface (ProgressBar *pProgressBar)
{
CairoDataRenderer *pRenderer = CAIRO_DATA_RENDERER (pProgressBar);
int iWidth = pRenderer->iWidth;
if (pProgressBar->cImageGradation != NULL) // an image is provided
{
pProgressBar->pBarSurface = cairo_dock_create_surface_from_image_simple (
pProgressBar->cImageGradation,
iWidth,
pProgressBar->iBarThickness);
}
if (pProgressBar->pBarSurface == NULL) // no image was provided, or it was not valid.
{
// create a surface to bufferize the pattern.
pProgressBar->pBarSurface = cairo_dock_create_blank_surface (iWidth, pProgressBar->iBarThickness);
cairo_t *ctx = cairo_create (pProgressBar->pBarSurface);
cairo_pattern_t *pGradationPattern = NULL;
if (myIndicatorsParam.bBarUseDefaultColors)
{
gldi_style_colors_set_selected_bg_color (ctx);
}
else
{
// create the pattern.
pGradationPattern = cairo_pattern_create_linear (0.,
0.,
iWidth,
0.); // de gauche a droite.
g_return_if_fail (cairo_pattern_status (pGradationPattern) == CAIRO_STATUS_SUCCESS);
cairo_pattern_set_extend (pGradationPattern, CAIRO_EXTEND_NONE);
gdouble *fColorGradation = pProgressBar->fColorGradation;
int iNbColors = 2;
int i;
for (i = 0; i < iNbColors; i ++)
{
cairo_pattern_add_color_stop_rgba (pGradationPattern,
(double)i / (iNbColors-1),
fColorGradation[4*i+0],
fColorGradation[4*i+1],
fColorGradation[4*i+2],
fColorGradation[4*i+3]);
}
cairo_set_source (ctx, pGradationPattern);
}
// draw the pattern on the surface.
cairo_set_operator (ctx, CAIRO_OPERATOR_OVER);
cairo_set_line_width (ctx, pProgressBar->iBarThickness);
double r = .5*pProgressBar->iBarThickness; // radius
cairo_move_to (ctx, 0, r);
cairo_rel_line_to (ctx, iWidth, 0);
cairo_stroke (ctx);
if (pGradationPattern)
cairo_pattern_destroy (pGradationPattern);
cairo_destroy (ctx);
}
pProgressBar->iBarTexture = cairo_dock_create_texture_from_surface (pProgressBar->pBarSurface);
}
