gboolean cairo_dock_set_class_use_xicon (const gchar *cClass, gboolean bUseXIcon)
{
CairoDockClassAppli *pClassAppli = cairo_dock_get_class (cClass);
g_return_val_if_fail (pClassAppli!= NULL, FALSE);
if (pClassAppli->bUseXIcon == bUseXIcon) // rien a faire.
return FALSE;
GList *pElement;
Icon *pAppliIcon;
cairo_t *pCairoContext = cairo_dock_create_context_from_window (CAIRO_CONTAINER (g_pMainDock));
for (pElement = pClassAppli->pAppliOfClass; pElement != NULL; pElement = pElement->next)
{
pAppliIcon = pElement->data;
if (bUseXIcon)
{
cd_message ("%s prend l'icone de X", pAppliIcon->acName);
}
else
{
cd_message ("%s n'utilise plus l'icone de X", pAppliIcon->acName);
}
cairo_dock_fill_one_icon_buffer (pAppliIcon, pCairoContext, (1 + g_fAmplitude), g_pMainDock->bHorizontalDock, TRUE, g_pMainDock->bDirectionUp);
}
cairo_destroy (pCairoContext);
return TRUE;
}
static GDrive *_cd_find_drive_from_name (const gchar *cName)
{
g_return_val_if_fail (cName != NULL, NULL);
cd_message ("%s (%s)", __func__, cName);
GVolumeMonitor *pVolumeMonitor = g_volume_monitor_get ();
GDrive *pFoundDrive = NULL;
//\___________________ On chope les disques connectes (lecteur de CD/disquette/etc) et on liste leurs volumes.
GList *pDrivesList = g_volume_monitor_get_connected_drives (pVolumeMonitor);
GList *dl;
GDrive *pDrive;
gchar *cDriveName;
for (dl = pDrivesList; dl != NULL; dl = dl->next)
{
pDrive = dl->data;
if (pFoundDrive == NULL)
{
cDriveName = g_drive_get_name (pDrive);
cd_message (" drive '%s'", cDriveName);
if (cDriveName != NULL && strcmp (cDriveName, cName) == 0)
pFoundDrive = pDrive;
else
g_object_unref (pDrive);
//g_free (cDriveName);
}
else
g_object_unref (pDrive);
}
g_list_free (pDrivesList);
return pFoundDrive;
}
static gboolean _on_window_destroyed (G_GNUC_UNUSED gpointer data, GldiWindowActor *actor)
{
cd_debug ("window %s (%p) is destroyed", actor->cName, actor);
Icon *icon = _get_appli_icon (actor);
if (icon != NULL)
{
if (actor->bDemandsAttention) // force the stop demanding attention, in case the icon was in a sub-dock (the main icon is also animating).
gldi_appli_icon_stop_demanding_attention (icon);
CairoDock *pParentDock = CAIRO_DOCK(cairo_dock_get_icon_container (icon));
if (pParentDock != NULL)
{
cd_message (" va etre supprimee");
cairo_dock_unregister_appli (icon); // unregister the icon immediately, since it doesn't represent anything any more; it unsets pAppli, so that when the animation is over, the icon will be destroyed.
cairo_dock_trigger_icon_removal_from_dock (icon);
}
else // inhibited or not shown -> destroy it immediately
{
cd_message (" pas dans un container, on la detruit donc immediatement");
///cairo_dock_update_name_on_inhibitors (icon->cClass, actor, NULL);
gldi_window_inhibitors_set_name (actor, NULL);
gldi_object_unref (GLDI_OBJECT (icon)); // will call cairo_dock_unregister_appli and update the inhibitors.
}
}
if (s_pCurrentActiveWindow == actor)
s_pCurrentActiveWindow = NULL;
return GLDI_NOTIFICATION_LET_PASS;
}
static void _vfs_backend_mount_callback (gpointer pObject, GAsyncResult *res, gpointer *data)
//static void _vfs_backend_mount_callback (gboolean succeeded, char *error, char *detailed_error, gpointer *data)
{
cd_message ("%s (%d)", __func__, GPOINTER_TO_INT (data[1]));
CairoDockFMMountCallback pCallback = data[0];
GError *erreur = NULL;
gboolean bSuccess;
if (GPOINTER_TO_INT (data[1]) == 1)
bSuccess = (g_file_mount_mountable_finish (G_FILE (pObject), res, &erreur) != NULL);
//bSuccess = (g_volume_mount_finish (G_VOLUME (pObject), res, &erreur));
else if (GPOINTER_TO_INT (data[1]) == 0)
bSuccess = g_mount_unmount_finish (G_MOUNT (pObject), res, &erreur);
else
bSuccess = g_mount_eject_finish (G_MOUNT (pObject), res, &erreur);
if (erreur != NULL)
{
cd_warning ("Attention : %s", erreur->message);
g_error_free (erreur);
}
cd_message ("(un)mount fini -> %d", bSuccess);
pCallback (GPOINTER_TO_INT (data[1]) == 1, bSuccess, data[2], data[3], data[4]);
//g_free (data[2]);
//g_object_unref (pObject);
//g_free (data);
}
void cairo_dock_update_Xid_on_inhibators (Window Xid, const gchar *cClass)
{
cd_message ("%s (%s)", __func__, cClass);
CairoDockClassAppli *pClassAppli = cairo_dock_find_class_appli (cClass);
if (pClassAppli != NULL)
{
int iNextXid = -1;
Icon *pSameClassIcon = NULL;
Icon *pIcon;
GList *pElement;
for (pElement = pClassAppli->pIconsOfClass; pElement != NULL; pElement = pElement->next)
{
pIcon = pElement->data;
if (pIcon->Xid == Xid)
{
if (iNextXid == -1) // on prend la 1ere appli de meme classe.
{
GList *pList = pClassAppli->pAppliOfClass;
if (pList != NULL)
{
pSameClassIcon = pList->data;
if (pSameClassIcon->Xid == Xid) // normalement impossible.
{
if (pList->next != NULL)
pSameClassIcon = pList->next->data;
else
pSameClassIcon = NULL;
}
}
iNextXid = (pSameClassIcon != NULL ? pSameClassIcon->Xid : 0);
if (pSameClassIcon != NULL)
{
cd_message (" c'est %s qui va la remplacer", pSameClassIcon->acName);
CairoDock *pClassSubDock = cairo_dock_search_dock_from_name (pSameClassIcon->cParentDockName);
if (pClassSubDock != NULL)
{
cairo_dock_detach_icon_from_dock (pSameClassIcon, pClassSubDock, FALSE);
if (pClassSubDock->icons == NULL && pClassSubDock == cairo_dock_search_dock_from_name (cClass)) // le sous-dock de la classe devient vide.
cairo_dock_destroy_dock (pClassSubDock, cClass, NULL, NULL);
else
cairo_dock_update_dock_size (pClassSubDock);
}
}
}
pIcon->Xid = iNextXid;
pIcon->bHasIndicator = (iNextXid != 0);
_cairo_dock_set_same_indicator_on_sub_dock (pIcon);
cd_message (" %s : bHasIndicator <- %d, Xid <- %d", pIcon->acName, pIcon->bHasIndicator, pIcon->Xid);
}
}
}
}
static void _xgamma_apply_value_simple (int iClickedButton, GtkWidget *pWidget, gpointer data, CairoDialog *pDialog)
{
if (iClickedButton == 0 || iClickedButton == -1) // ok button or Enter.
{
cd_message ("%s (ok)", __func__);
}
else
{
cd_message ("%s (cancel)", __func__);
myData.Xgamma = myData.XoldGamma;
xgamma_set_gamma (&myData.Xgamma);
}
}
void cairo_dock_deinhibate_class (const gchar *cClass, Icon *pInhibatorIcon)
{
cd_message ("%s (%s)", __func__, cClass);
gboolean bStillInhibated = cairo_dock_remove_icon_from_class (pInhibatorIcon);
cd_debug (" bStillInhibated : %d", bStillInhibated);
///if (! bStillInhibated) // il n'y a plus personne dans cette classe.
/// return ;
if (pInhibatorIcon == NULL || pInhibatorIcon->Xid != 0)
{
cairo_t *pCairoContext = cairo_dock_create_context_from_window (CAIRO_CONTAINER (g_pMainDock));
const GList *pList = cairo_dock_list_existing_appli_with_class (cClass);
Icon *pIcon;
gboolean bNeedsRedraw = FALSE;
CairoDock *pParentDock;
const GList *pElement;
for (pElement = pList; pElement != NULL; pElement = pElement->next)
{
pIcon = pElement->data;
if (pInhibatorIcon == NULL || pIcon->Xid == pInhibatorIcon->Xid)
{
cd_message ("rajout de l'icone precedemment inhibee (Xid:%d)", pIcon->Xid);
pIcon->fPersonnalScale = 0;
pIcon->fScale = 1.;
pParentDock = cairo_dock_insert_appli_in_dock (pIcon, g_pMainDock, CAIRO_DOCK_UPDATE_DOCK_SIZE, ! CAIRO_DOCK_ANIMATE_ICON);
bNeedsRedraw = (pParentDock != NULL && pParentDock->bIsMainDock);
//if (pInhibatorIcon != NULL)
// break ;
}
pParentDock = cairo_dock_search_dock_from_name (pIcon->cParentDockName);
if (pParentDock != NULL)
{
cd_message ("on recharge l'icone de l'appli %s", pIcon->acName);
cairo_dock_fill_one_icon_buffer (pIcon, pCairoContext, 1 + g_fAmplitude, pParentDock->bHorizontalDock, TRUE, pParentDock->bDirectionUp);
}
}
cairo_destroy (pCairoContext);
if (bNeedsRedraw)
gtk_widget_queue_draw (g_pMainDock->pWidget); /// pDock->calculate_icons (pDock); ?...
}
if (pInhibatorIcon != NULL)
{
cd_message (" l'inhibiteur a perdu toute sa mana");
pInhibatorIcon->Xid = 0;
pInhibatorIcon->bHasIndicator = FALSE;
g_free (pInhibatorIcon->cClass);
pInhibatorIcon->cClass = NULL;
}
}
gboolean cairo_dock_prevent_inhibated_class (Icon *pIcon)
{
g_return_val_if_fail (pIcon != NULL, FALSE);
cd_message ("");
gboolean bToBeInhibited = FALSE;
CairoDockClassAppli *pClassAppli = cairo_dock_find_class_appli (pIcon->cClass);
if (pClassAppli != NULL)
{
Icon *pInhibatorIcon;
GList *pElement;
for (pElement = pClassAppli->pIconsOfClass; pElement != NULL; pElement = pElement->next)
{
pInhibatorIcon = pElement->data;
if (pInhibatorIcon == NULL) // cette appli est inhibee par Dieu.
{
cd_debug ("cette appli est inhibee par Dieu");
bToBeInhibited = TRUE;
}
else
{
if (pInhibatorIcon->Xid == 0) // cette icone inhibe cette classe mais ne controle encore aucune appli, on s'y asservit.
{
pInhibatorIcon->Xid = pIcon->Xid;
pInhibatorIcon->bIsHidden = pIcon->bIsHidden;
///if (CAIRO_DOCK_IS_NORMAL_LAUNCHER (pInhibatorIcon)) // pas d'indicateur pour les applets, elles ont deja leurs propres moyens pour signaler de l'information a l'utilisateur.
{
cd_message (">>> %s prendra un indicateur au prochain redraw ! (Xid : %d)", pInhibatorIcon->acName, pInhibatorIcon->Xid);
pInhibatorIcon->bHasIndicator = TRUE;
_cairo_dock_set_same_indicator_on_sub_dock (pInhibatorIcon);
}
}
if (pInhibatorIcon->Xid == pIcon->Xid) // cette icone nous controle. Sinon c'est qu'elle controle deja une autre appli, auquel cas on n'est pas inhibe.
{
CairoDock *pInhibhatorDock = cairo_dock_search_dock_from_name (pInhibatorIcon->cParentDockName);
if (! bToBeInhibited) // on ne met le thumbnail que sur la 1ere.
{
if (pInhibhatorDock != NULL)
cairo_dock_set_one_icon_geometry_for_window_manager (pInhibatorIcon, pInhibhatorDock);
bToBeInhibited = TRUE;
}
}
}
}
}
return bToBeInhibited;
}
void cd_shortcuts_add_one_bookmark (const gchar *cURI, GldiModuleInstance *myApplet)
{
g_return_if_fail (cURI != NULL);
cd_message ("%s (%s)", __func__, cURI);
// see if we need to add a new line before the new URI.
gchar *cContent = NULL;
gsize length = 0;
g_file_get_contents (myData.cBookmarksURI,
&cContent,
&length,
NULL);
gboolean bAddNewLine = (cContent && length > 0 && cContent[length-1] != '\n');
g_free (cContent);
// append the new URI to the file.
FILE *f = fopen (myData.cBookmarksURI, "a");
if (f != NULL)
{
gchar *cNewLine = g_strdup_printf ("%s%s\n", bAddNewLine ? "\n" : "", cURI);
fputs(cNewLine, f);
g_free (cNewLine);
fclose (f);
}
}
void cairo_dock_normalize_icons_order (GList *pIconList, CairoDockIconType iType)
{
cd_message ("%s (%d)", __func__, iType);
int iOrder = 1;
CairoDockIconType iGroupOrder = cairo_dock_get_group_order (iType);
GString *sDesktopFilePath = g_string_new ("");
GList* ic;
Icon *icon;
for (ic = pIconList; ic != NULL; ic = ic->next)
{
icon = ic->data;
if (cairo_dock_get_icon_order (icon) != iGroupOrder)
continue;
icon->fOrder = iOrder ++;
if (icon->acDesktopFileName != NULL)
{
g_string_printf (sDesktopFilePath, "%s/%s", g_cCurrentLaunchersPath, icon->acDesktopFileName);
cairo_dock_update_conf_file (sDesktopFilePath->str,
G_TYPE_DOUBLE, "Desktop Entry", "Order", icon->fOrder,
G_TYPE_INVALID);
}
else if (CAIRO_DOCK_IS_APPLET (icon))
{
cairo_dock_update_conf_file (icon->pModuleInstance->cConfFilePath,
G_TYPE_DOUBLE, "Icon", "order", icon->fOrder,
G_TYPE_INVALID);
}
}
g_string_free (sDesktopFilePath, TRUE);
}
gboolean cairo_dock_simulate_key_sequence (gchar *cKeyString) // the idea was taken from xdo.
{
#ifdef HAVE_XEXTEND
g_return_val_if_fail (cKeyString != NULL, FALSE);
cd_message ("%s (%s)", __func__, cKeyString);
int iNbKeys = 0;
int *pKeySyms = egg_keystring_to_keysyms (cKeyString, &iNbKeys);
int i;
int keycode;
Display *dpy = cairo_dock_get_Xdisplay ();
for (i = 0; i < iNbKeys; i ++)
{
keycode = XKeysymToKeycode (dpy, pKeySyms[i]);
XTestFakeKeyEvent (dpy, keycode, TRUE, CurrentTime); // TRUE <=> presse.
}
for (i = iNbKeys-1; i >=0; i --)
{
keycode = XKeysymToKeycode (dpy, pKeySyms[i]);
XTestFakeKeyEvent (dpy, keycode, FALSE, CurrentTime); // TRUE <=> presse.
}
XFlush (dpy);
return TRUE;
#else
return FALSE;
#endif
}
static void _terminal_rm (GtkMenuItem *menu_item, gpointer *data)
{
GtkWidget *pWidget = data[0];
gchar *cReceivedData = data[1];
cd_message ("%s (%s)\n", __func__, cReceivedData);
_terminal_write_command_with_data (pWidget, "rm -r", cReceivedData);
}
void cairo_dock_set_dialog_renderer_by_name (CairoDialog *pDialog, const gchar *cRendererName, CairoDialogRendererConfigPtr pConfig)
{
cd_message ("%s (%s)", __func__, cRendererName);
CairoDialogRenderer *pRenderer = (cRendererName != NULL ? cairo_dock_get_dialog_renderer (cRendererName) : NULL);
cairo_dock_set_dialog_renderer (pDialog, pRenderer, pConfig);
}
void cairo_dock_set_renderer (CairoDock *pDock, const gchar *cRendererName)
{
g_return_if_fail (pDock != NULL);
cd_message ("%s (%x:%s)", __func__, pDock, cRendererName);
if (pDock->pRenderer && pDock->pRenderer->free_data)
{
pDock->pRenderer->free_data (pDock);
pDock->pRendererData = NULL;
}
pDock->pRenderer = cairo_dock_get_renderer (cRendererName, (pDock->iRefCount == 0));
pDock->fMagnitudeMax = 1.;
pDock->container.bUseReflect = pDock->pRenderer->bUseReflect;
int iAnimationDeltaT = pDock->container.iAnimationDeltaT;
pDock->container.iAnimationDeltaT = (g_bUseOpenGL && pDock->pRenderer->render_opengl != NULL ? myContainersParam.iGLAnimationDeltaT : myContainersParam.iCairoAnimationDeltaT);
if (pDock->container.iAnimationDeltaT == 0)
pDock->container.iAnimationDeltaT = 30; // le main dock est cree avant meme qu'on ait recupere la valeur en conf. Lorsqu'une vue lui sera attribuee, la bonne valeur sera renseignee, en attendant on met un truc non nul.
if (iAnimationDeltaT != pDock->container.iAnimationDeltaT && pDock->container.iSidGLAnimation != 0)
{
g_source_remove (pDock->container.iSidGLAnimation);
pDock->container.iSidGLAnimation = 0;
cairo_dock_launch_animation (CAIRO_CONTAINER (pDock));
}
if (pDock->cRendererName != cRendererName) // NULL ecrase le nom de l'ancienne vue.
{
g_free (pDock->cRendererName);
pDock->cRendererName = g_strdup (cRendererName);
}
}
void cairo_dock_update_visibility_on_inhibators (gchar *cClass, Window Xid, gboolean bIsHidden)
{
CairoDockClassAppli *pClassAppli = cairo_dock_get_class (cClass);
if (pClassAppli != NULL)
{
GList *pElement;
Icon *pInhibatorIcon;
for (pElement = pClassAppli->pIconsOfClass; pElement != NULL; pElement = pElement->next)
{
pInhibatorIcon = pElement->data;
if (pInhibatorIcon->Xid == Xid)
{
cd_message (" %s aussi se %s", pInhibatorIcon->acName, (bIsHidden ? "cache" : "montre"));
pInhibatorIcon->bIsHidden = bIsHidden;
if (! CAIRO_DOCK_IS_APPLET (pInhibatorIcon) && g_fVisibleAppliAlpha != 0)
{
CairoDock *pInhibhatorDock = cairo_dock_search_dock_from_name (pInhibatorIcon->cParentDockName);
pInhibatorIcon->fAlpha = 1; // on triche un peu.
cairo_dock_redraw_my_icon (pInhibatorIcon, CAIRO_CONTAINER (pInhibhatorDock));
}
}
}
}
}
void cairo_dock_set_dialog_decorator_by_name (CairoDialog *pDialog, const gchar *cDecoratorName)
{
cd_message ("%s (%s)", __func__, cDecoratorName);
CairoDialogDecorator *pDecorator = cairo_dock_get_dialog_decorator (cDecoratorName);
cairo_dock_set_dialog_decorator (pDialog, pDecorator);
}
void xgamma_apply_values (int iClickedButton, GtkWidget *pWidget, gpointer data, CairoDialog *pDialog)
{
if (iClickedButton == 0)
{
cd_message ("%s (ok)", __func__);
}
else
{
cd_message ("%s (cancel)", __func__);
myData.Xgamma = myData.XoldGamma;
xgamma_set_gamma (&myData.Xgamma);
}
cairo_dock_hide_dialog (myData.pDialog);
cairo_dock_dialog_reference (myData.pDialog); // pour garder notre dialogue en vie.
}
/* Recupere tout chaque seconde (aucun signal).
*/
static void cd_exaile_read_data (void)
{
if (! myData.dbus_enable)
{
cd_warning ("couldn't connect to bus");
return;
}
if (! myData.bIsRunning)
cd_musicplayer_dbus_detect_player ();
if (myData.bIsRunning)
{
g_print ("Exaile is running\n");
cd_exaile_getSongInfos ();
if (myData.iPlayingStatus == PLAYER_PLAYING && cairo_dock_strings_differ (myData.cRawTitle, myData.cPreviousRawTitle))
cd_exaile_getCoverPath ();
else if (myData.iPlayingStatus == PLAYER_STOPPED) // en pause le temps et la chanson reste constants.
{
myData.iCurrentTime = 0;
}
cd_message (" myData.iCurrentTime <- %d", __func__, myData.iCurrentTime);
}
else
{
cd_debug ("MP : lecteur non ouvert");
myData.iPlayingStatus = PLAYER_NONE;
}
}
void gldi_task_downgrade_frequency (GldiTask *pTask)
{
if (pTask->iFrequencyState < GLDI_TASK_FREQUENCY_SLEEP)
{
pTask->iFrequencyState ++;
int iNewPeriod;
switch (pTask->iFrequencyState)
{
case GLDI_TASK_FREQUENCY_LOW :
iNewPeriod = 2 * pTask->iPeriod;
break ;
case GLDI_TASK_FREQUENCY_VERY_LOW :
iNewPeriod = 4 * pTask->iPeriod;
break ;
case GLDI_TASK_FREQUENCY_SLEEP :
iNewPeriod = 10 * pTask->iPeriod;
break ;
default : // ne doit pas arriver.
iNewPeriod = pTask->iPeriod;
break ;
}
cd_message ("degradation de la mesure (etat <- %d/%d)", pTask->iFrequencyState, GLDI_TASK_NB_FREQUENCIES-1);
_restart_timer_with_frequency (pTask, iNewPeriod);
}
}
void vfs_backend_add_monitor (const gchar *cURI, gboolean bDirectory, CairoDockFMMonitorCallback pCallback, gpointer user_data)
{
g_return_if_fail (cURI != NULL);
GError *erreur = NULL;
GFileMonitor *pMonitor;
GFile *pFile = (*cURI == '/' ? g_file_new_for_path (cURI) : g_file_new_for_uri (cURI));
if (bDirectory)
pMonitor = g_file_monitor_directory (pFile,
G_FILE_MONITOR_WATCH_MOUNTS,
NULL,
&erreur);
else
pMonitor = g_file_monitor_file (pFile,
G_FILE_MONITOR_WATCH_MOUNTS,
NULL,
&erreur);
//g_object_unref (pFile);
if (erreur != NULL)
{
cd_warning ("Attention : couldn't add monitor on '%s' (%d) [%s]", cURI, bDirectory, erreur->message);
g_error_free (erreur);
return ;
}
gpointer *data = g_new0 (gpointer, 3);
data[0] = pCallback;
data[1] = user_data;
data[2] = pMonitor;
g_signal_connect (G_OBJECT (pMonitor), "changed", G_CALLBACK (_on_monitor_changed), data);
g_hash_table_insert (s_hMonitorHandleTable, g_strdup (cURI), data);
cd_message (">>> moniteur ajoute sur %s (%x)", cURI, user_data);
}
static void _xgamma_apply_values (int iClickedButton, GtkWidget *pWidget, gpointer data, CairoDialog *pDialog)
{
if (iClickedButton == 0 || iClickedButton == -1) // ok button or Enter.
{
cd_message ("%s (ok)", __func__);
}
else
{
cd_message ("%s (cancel)", __func__);
myData.Xgamma = myData.XoldGamma;
xgamma_set_gamma (&myData.Xgamma);
}
gldi_dialog_hide (myData.pDialog);
gldi_object_ref (GLDI_OBJECT(myData.pDialog)); // pour garder notre dialogue en vie.
}
gboolean vfs_backend_move_file (const gchar *cURI, const gchar *cDirectoryURI)
{
g_return_val_if_fail (cURI != NULL, FALSE);
cd_message (" %s -> %s", cURI, cDirectoryURI);
GFile *pFile = (*cURI == '/' ? g_file_new_for_path (cURI) : g_file_new_for_uri (cURI));
gchar *cFileName = g_file_get_basename (pFile);
gchar *cNewFileURI = g_strconcat (cDirectoryURI, "/", cFileName, NULL); // un peu moyen mais bon...
GFile *pDestinationFile = (*cNewFileURI == '/' ? g_file_new_for_path (cNewFileURI) : g_file_new_for_uri (cNewFileURI));
g_free (cNewFileURI);
g_free (cFileName);
GError *erreur = NULL;
gboolean bSuccess = g_file_move (pFile,
pDestinationFile,
G_FILE_COPY_NOFOLLOW_SYMLINKS,
NULL,
NULL, // GFileProgressCallback
NULL, // data
&erreur);
if (erreur != NULL)
{
cd_warning ("Attention : %s", erreur->message);
g_error_free (erreur);
}
g_object_unref (pFile);
g_object_unref (pDestinationFile);
return bSuccess;
}
GList * cd_shortcuts_list_drives (CDSharedMemory *pSharedMemory)
{
GList *pIconList = NULL;
gchar *cFullURI = NULL;
//\_______________________ Get the list of mount points.
pIconList = cairo_dock_fm_list_directory (CAIRO_DOCK_FM_VFS_ROOT,
CAIRO_DOCK_FM_SORT_BY_NAME, CD_DRIVE_GROUP, FALSE, 100, &cFullURI);
cd_message (" cFullURI : %s", cFullURI);
if (pIconList == NULL)
{
cd_warning ("couldn't detect any drives"); // continue: for bookmarks
}
/// TODO: if ! bListBookmarks, then we should add the Home in the drives list, to have the disk space information...
pSharedMemory->cDisksURI = cFullURI;
//\_______________________ Initialize disk usages.
Icon *pIcon;
GList *ic;
for (ic = pIconList; ic != NULL; ic = ic->next)
{
pIcon = ic->data;
_init_disk_usage (pIcon, pSharedMemory->pApplet);
}
return pIconList;
}
static void _cairo_dock_set_same_indicator_on_sub_dock (Icon *pInhibhatorIcon)
{
CairoDock *pInhibhatorDock = cairo_dock_search_dock_from_name (pInhibhatorIcon->cParentDockName);
if (pInhibhatorDock != NULL && pInhibhatorDock->iRefCount > 0) // l'inhibiteur est dans un sous-dock.
{
gboolean bSubDockHasIndicator = FALSE;
if (pInhibhatorIcon->bHasIndicator)
{
bSubDockHasIndicator = TRUE;
}
else
{
GList* ic;
Icon *icon;
for (ic =pInhibhatorDock->icons ; ic != NULL; ic = ic->next)
{
icon = ic->data;
if (icon->bHasIndicator)
{
bSubDockHasIndicator = TRUE;
break;
}
}
}
Icon *pPointingIcon = cairo_dock_search_icon_pointing_on_dock (pInhibhatorDock, NULL);
if (pPointingIcon != NULL)
{
cd_message (" pour le sous-dock %s : indicateur <- %d", pPointingIcon->acName, bSubDockHasIndicator);
pPointingIcon->bHasIndicator = bSubDockHasIndicator;
}
}
}
/* Fonction executée à chaque changement de musique.
*/
static void onChangeSong(DBusGProxy *player_proxy,const gchar *uri, gpointer data)
{
cd_message ("MP : %s (%s)",__func__,uri);
g_free (myData.cPlayingUri);
if(uri != NULL && *uri != '\0')
{
myData.cPlayingUri = g_strdup (uri);
myData.bIsRunning = TRUE;
cd_rhythmbox_getSongInfos (TRUE); // TRUE <=> get all
}
else
{
myData.cPlayingUri = NULL;
myData.cover_exist = FALSE;
g_free (myData.cArtist);
myData.cArtist = NULL;
g_free (myData.cAlbum);
myData.cAlbum = NULL;
g_free (myData.cTitle);
myData.cTitle = NULL;
g_free (myData.cCoverPath);
myData.cCoverPath = NULL;
myData.iSongLength = 0;
myData.iTrackNumber = 0;
cd_musicplayer_dbus_detect_player ();
}
cd_musicplayer_update_icon (TRUE);
}
/* Teste si Rhythmbox joue de la musique ou non
*/
static void _rhythmbox_getPlaying (void)
{
cd_message ("");
if (cairo_dock_dbus_get_boolean (myData.dbus_proxy_player,"getPlaying"))
myData.iPlayingStatus = PLAYER_PLAYING;
else
myData.iPlayingStatus = PLAYER_PAUSED;
}
void vfs_backend_remove_monitor (const gchar *cURI)
{
if (cURI != NULL)
{
cd_message (">>> moniteur supprime sur %s", cURI);
g_hash_table_remove (s_hMonitorHandleTable, cURI);
}
}
gchar *vfs_backend_is_mounted (const gchar *cURI, gboolean *bIsMounted)
{
cd_message ("%s (%s)", __func__, cURI);
gchar *cTargetURI = NULL;
GMount *pMount = _cd_find_mount_from_uri (cURI, &cTargetURI);
cd_message (" cTargetURI : %s", cTargetURI);
if (pMount != NULL)
*bIsMounted = TRUE;
else
{
if (cTargetURI != NULL && strcmp (cTargetURI, "file:///") == 0) // cas particulier ?
*bIsMounted = TRUE;
else
*bIsMounted = FALSE;
}
return cTargetURI;
}
GList *cd_shortcuts_list_bookmarks (gchar *cBookmarkFilePath, GldiModuleInstance *myApplet)
{
GList *pBookmarkIconList = NULL;
Icon *pNewIcon;
double fCurrentOrder = 0.;
// Home
gchar *cHome = g_strdup_printf ("file://%s", g_getenv ("HOME"));
pNewIcon = _cd_shortcuts_get_icon (cHome, D_("Home Folder"), fCurrentOrder++);
if (pNewIcon != NULL)
{
_init_disk_usage (pNewIcon, myApplet);
CDDiskUsage *pDiskUsage = CD_APPLET_GET_MY_ICON_DATA (pNewIcon);
if (pDiskUsage) // so that this bookmark will never be considered old, and therefore removed.
pDiskUsage->iLastCheckTime = 1e9;
pBookmarkIconList = g_list_append (pBookmarkIconList, pNewIcon);
}
else
g_free (cHome);
gchar *cContent = NULL;
gsize length = 0;
GError *erreur = NULL;
g_file_get_contents (cBookmarkFilePath, &cContent, &length, &erreur);
if (erreur != NULL)
{
cd_warning ("Attention: %s\n no bookmark will be available", erreur->message);
g_error_free (erreur);
}
else
{
gchar **cBookmarksList = g_strsplit (cContent, "\n", -1);
g_free (cContent);
gchar *cOneBookmark;
const gchar *cUserName;
int i = 0;
for (i = 0; cBookmarksList[i] != NULL; i ++)
{
cUserName = _get_custom_name_and_uri (cBookmarksList[i], &cOneBookmark);
if (*cOneBookmark != '\0' && *cOneBookmark != '#')
{
cd_message (" + 1 bookmark : %s", cOneBookmark);
pNewIcon = _cd_shortcuts_get_icon (cOneBookmark, cUserName, fCurrentOrder++);
if (pNewIcon)
pBookmarkIconList = g_list_append (pBookmarkIconList, pNewIcon);
else
g_free (cOneBookmark);
}
else
{
g_free (cOneBookmark);
}
}
g_free (cBookmarksList);
}
return pBookmarkIconList;
}
gboolean cairo_dock_add_appli_to_class (Icon *pIcon)
{
g_return_val_if_fail (pIcon!= NULL, FALSE);
cd_message ("%s (%s)", __func__, pIcon->cClass);
if (pIcon->cClass == NULL)
{
cd_message (" %s n'a pas de classe, c'est po bien", pIcon->acName);
return FALSE;
}
CairoDockClassAppli *pClassAppli = cairo_dock_get_class (pIcon->cClass);
g_return_val_if_fail (pClassAppli!= NULL, FALSE);
g_return_val_if_fail (g_list_find (pClassAppli->pAppliOfClass, pIcon) == NULL, TRUE);
pClassAppli->pAppliOfClass = g_list_prepend (pClassAppli->pAppliOfClass, pIcon);
return TRUE;
}
