void cd_musiplayer_apply_cover (void)
{
cd_debug ("%s (%s)", __func__, myData.cCoverPath);
g_return_if_fail (myData.cCoverPath != NULL);
if (CD_APPLET_MY_CONTAINER_IS_OPENGL && myConfig.bOpenglThemes)
{
if (myData.iPrevTextureCover != 0)
_cairo_dock_delete_texture (myData.iPrevTextureCover);
myData.iPrevTextureCover = myData.TextureCover;
myData.TextureCover = cairo_dock_create_texture_from_image (myData.cCoverPath);
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
{
CD_APPLET_SET_IMAGE_ON_MY_ICON (myData.cCoverPath);
CD_APPLET_REDRAW_MY_ICON;
}
}
void cairo_dock_pop_down (CairoDock *pDock)
{
//g_print ("%s (%d, %d)\n", __func__, pDock->bIsBelow, pDock->container.bInside);
if (! pDock->bIsBelow && pDock->iVisibility == CAIRO_DOCK_VISI_KEEP_BELOW && ! pDock->container.bInside)
{
if (gldi_dock_search_overlapping_window (pDock) != NULL)
{
pDock->iFadeCounter = 0;
pDock->bFadeInOut = TRUE;
gldi_object_register_notification (pDock,
NOTIFICATION_UPDATE,
(GldiNotificationFunc) _update_fade_out_dock,
GLDI_RUN_FIRST, NULL);
if (g_pKeepingBelowBackend != NULL && g_pKeepingBelowBackend->init)
g_pKeepingBelowBackend->init (pDock);
cairo_dock_launch_animation (CAIRO_CONTAINER (pDock));
}
else
{
//g_print ("set below\n");
gtk_window_set_keep_below (GTK_WINDOW (pDock->container.pWidget), TRUE);
}
pDock->bIsBelow = TRUE;
}
}
void cairo_dock_start_hiding (CairoDock *pDock)
{
//g_print ("%s (%d)\n", __func__, pDock->bIsHiding);
if (! pDock->bIsHiding && ! pDock->container.bInside) // rien de plus desagreable que le dock qui se cache quand on est dedans.
{
// set current showing/hiding state
pDock->bIsShowing = FALSE;
pDock->bIsHiding = TRUE;
// empty the input shape (so that the dock doesn't disturb us immediately)
if (pDock->iInputState != CAIRO_DOCK_INPUT_HIDDEN) // if pDock->pHiddenShapeBitmap == NULL (at the beginning), set iInputState anyway, so that when the input-shapes are created, pDock->pHiddenShapeBitmap will be applied to the dock.
{
//g_print ("+++ input shape hidden on start hiding\n");
cairo_dock_set_input_shape_hidden (pDock);
pDock->iInputState = CAIRO_DOCK_INPUT_HIDDEN;
}
// init the animation
if (g_pHidingBackend != NULL && g_pHidingBackend->init)
g_pHidingBackend->init (pDock);
// and launch it
cairo_dock_launch_animation (CAIRO_CONTAINER (pDock));
}
}
void cd_do_select_prev_next_entry_in_listing (gboolean bNext)
{
CDEntry *pEntry;
myData.pListing->fPreviousOffset = myData.pListing->fCurrentOffset;
GList *e = myData.pListing->pCurrentEntry;
if (bNext)
{
do
{
e = cairo_dock_get_next_element (e, myData.pListing->pEntries);
pEntry = e->data;
} while (e != myData.pListing->pCurrentEntry && pEntry->bHidden);
}
else
{
do
{
e = cairo_dock_get_previous_element (e, myData.pListing->pEntries);
pEntry = e->data;
} while (e != myData.pListing->pCurrentEntry && pEntry->bHidden);
}
myData.pListing->pCurrentEntry = e;
myData.pListing->fAimedOffset += (bNext ? 1:-1) * (myDialogs.dialogTextDescription.iSize + 2);
myData.pListing->iCurrentEntryAnimationCount = NB_STEPS_FOR_CURRENT_ENTRY;
myData.pListing->iScrollAnimationCount = NB_STEPS_FOR_SCROLL;
myData.pListing->iTitleOffset = 0;
myData.pListing->sens = 1;
cairo_dock_launch_animation (CAIRO_CONTAINER (myData.pListing));
cairo_dock_redraw_container (CAIRO_CONTAINER (myData.pListing));
}
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);
}
}
static void init_object (GldiObject *obj, gpointer attr)
{
CairoDesklet *pDesklet = (CairoDesklet*)obj;
CairoDeskletAttr *pAttributes = (CairoDeskletAttr*)attr;
g_return_if_fail (pAttributes->pIcon != NULL);
gldi_desklet_init_internals (pDesklet);
// attach the main icon
Icon *pIcon = pAttributes->pIcon;
pDesklet->pIcon = pIcon;
cairo_dock_set_icon_container (pIcon, pDesklet);
if (CAIRO_DOCK_IS_APPLET (pIcon))
gtk_window_set_title (GTK_WINDOW (pDesklet->container.pWidget), pIcon->pModuleInstance->pModule->pVisitCard->cModuleName);
// configure the desklet
gldi_desklet_configure (pDesklet, pAttributes);
// load buttons images
if (s_pRotateButtonBuffer.pSurface == NULL)
{
_load_desklet_buttons ();
}
// register the new desklet
s_pDeskletList = g_list_prepend (s_pDeskletList, pDesklet);
// start the appearance animation
if (! cairo_dock_is_loading ())
{
pDesklet->container.fRatio = 0.1;
pDesklet->bGrowingUp = TRUE;
cairo_dock_launch_animation (CAIRO_CONTAINER (pDesklet));
}
}
void cd_do_select_last_first_entry_in_listing (gboolean bLast)
{
myData.pListing->fPreviousOffset = myData.pListing->fCurrentOffset;
GList *e = myData.pListing->pCurrentEntry;
int i;
if (bLast)
{
e = g_list_last (myData.pListing->pEntries);
i = myData.pListing->iNbEntries - 1;
while (e->prev != NULL && ((CDEntry *)(e->data))->bHidden)
{
e = e->prev;
i --;
}
}
else
{
e = myData.pListing->pEntries;
i = 0;
while (e->next != NULL && ((CDEntry *)(e->data))->bHidden)
{
e = e->next;
i ++;
}
}
myData.pListing->pCurrentEntry = e;
myData.pListing->fAimedOffset = i * (myDialogs.dialogTextDescription.iSize + 2);
myData.pListing->iCurrentEntryAnimationCount = NB_STEPS_FOR_CURRENT_ENTRY;
myData.pListing->iScrollAnimationCount = NB_STEPS_FOR_SCROLL;
myData.pListing->iTitleOffset = 0;
myData.pListing->sens = 1;
cairo_dock_launch_animation (CAIRO_CONTAINER (myData.pListing));
cairo_dock_redraw_container (CAIRO_CONTAINER (myData.pListing));
}
static gboolean on_leave_desklet (GtkWidget* pWidget,
GdkEventCrossing* pEvent,
CairoDesklet *pDesklet)
{
//g_print ("%s (%d, %p, %d;%d)\n", __func__, pDesklet->container.bInside, pEvent, iMouseX, iMouseY);
int iMouseX, iMouseY;
if (pEvent != NULL)
{
iMouseX = pEvent->x;
iMouseY = pEvent->y;
}
else
{
gldi_container_update_mouse_position (CAIRO_CONTAINER (pDesklet));
iMouseX = pDesklet->container.iMouseX;
iMouseY = pDesklet->container.iMouseY;
}
if (gtk_bin_get_child (GTK_BIN (pDesklet->container.pWidget)) != NULL && iMouseX > 0 && iMouseX < pDesklet->container.iWidth && iMouseY > 0 && iMouseY < pDesklet->container.iHeight) // en fait on est dans un widget fils, donc on ne fait rien.
{
return FALSE;
}
pDesklet->container.bInside = FALSE;
Icon *pPointedIcon = cairo_dock_get_pointed_icon (pDesklet->icons);
if (pPointedIcon != NULL)
pPointedIcon->bPointed = FALSE;
gtk_widget_queue_draw (pWidget); // redessin des boutons.
gboolean bStartAnimation = FALSE;
gldi_object_notify (pDesklet, NOTIFICATION_LEAVE_DESKLET, pDesklet, &bStartAnimation);
if (bStartAnimation)
cairo_dock_launch_animation (CAIRO_CONTAINER (pDesklet));
return FALSE;
}
void cairo_dock_start_shrinking (CairoDock *pDock)
{
if (! pDock->bIsShrinkingDown) // on lance l'animation.
{
pDock->bIsGrowingUp = FALSE;
pDock->bIsShrinkingDown = TRUE;
cairo_dock_launch_animation (CAIRO_CONTAINER (pDock));
}
}
void cairo_dock_start_growing (CairoDock *pDock)
{
//g_print ("%s (%d)\n", __func__, pDock->bIsGrowingUp);
if (! pDock->bIsGrowingUp) // on lance l'animation.
{
pDock->bIsShrinkingDown = FALSE;
pDock->bIsGrowingUp = TRUE;
cairo_dock_launch_animation (CAIRO_CONTAINER (pDock));
}
}
/* 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);
}
}
void gldi_icon_start_animation (Icon *pIcon)
{
g_return_if_fail (pIcon != NULL);
CairoDock *pDock = CAIRO_DOCK (cairo_dock_get_icon_container(pIcon));
g_return_if_fail (CAIRO_DOCK_IS_DOCK (pDock)); // currently only animate icons that are inside a dock
cd_message ("%s (%s, %d)", __func__, pIcon->cName, pIcon->iAnimationState);
if (pIcon->iAnimationState != CAIRO_DOCK_STATE_REST &&
(cairo_dock_icon_is_being_inserted_or_removed (pIcon) || pIcon->bIsDemandingAttention || pIcon->bAlwaysVisible || cairo_dock_animation_will_be_visible (pDock)))
{
//g_print (" c'est parti\n");
cairo_dock_launch_animation (CAIRO_CONTAINER (pDock));
}
}
void cd_do_select_nth_entry_in_listing (int iNumEntry)
{
myData.pListing->fPreviousOffset = myData.pListing->fCurrentOffset;
int i = MIN (iNumEntry, myData.pListing->iNbEntries - 1);
myData.pListing->pCurrentEntry = g_list_nth (myData.pListing->pEntries, i);
myData.pListing->fAimedOffset = i * (myDialogs.dialogTextDescription.iSize + 2);
myData.pListing->iCurrentEntryAnimationCount = NB_STEPS_FOR_CURRENT_ENTRY;
myData.pListing->iScrollAnimationCount = NB_STEPS_FOR_SCROLL;
myData.pListing->iTitleOffset = 0;
myData.pListing->sens = 1;
cairo_dock_launch_animation (CAIRO_CONTAINER (myData.pListing));
cairo_dock_redraw_container (CAIRO_CONTAINER (myData.pListing));
}
static gboolean on_enter_desklet (GtkWidget* pWidget,
G_GNUC_UNUSED GdkEventCrossing* pEvent,
CairoDesklet *pDesklet)
{
//g_print ("%s (%d)\n", __func__, pDesklet->container.bInside);
if (! pDesklet->container.bInside) // avant on etait dehors, on redessine donc.
{
pDesklet->container.bInside = TRUE;
gtk_widget_queue_draw (pWidget); // redessin des boutons.
gboolean bStartAnimation = FALSE;
gldi_object_notify (pDesklet, NOTIFICATION_ENTER_DESKLET, pDesklet, &bStartAnimation);
if (bStartAnimation)
cairo_dock_launch_animation (CAIRO_CONTAINER (pDesklet));
}
return FALSE;
}
void cd_do_select_prev_next_page_in_listing (gboolean bNext)
{
myData.pListing->fPreviousOffset = myData.pListing->fCurrentOffset;
GList *e = myData.pListing->pCurrentEntry, *f = e;
CDEntry *pEntry;
int k = 0;
if (bNext)
{
do
{
if (e->next == NULL)
break;
e = e->next;
pEntry = e->data;
if (! pEntry->bHidden)
{
f = e;
k ++;
}
} while (k < myConfig.iNbLinesInListing);
}
else
{
do
{
if (e->prev == NULL)
break;
e = e->prev;
pEntry = e->data;
if (! pEntry->bHidden)
{
f = e;
k ++;
}
} while (k < myConfig.iNbLinesInListing);
}
myData.pListing->pCurrentEntry = f;
myData.pListing->fAimedOffset = g_list_position (myData.pListing->pEntries, f) * (myDialogs.dialogTextDescription.iSize + 2);
myData.pListing->iCurrentEntryAnimationCount = NB_STEPS_FOR_CURRENT_ENTRY;
myData.pListing->iScrollAnimationCount = NB_STEPS_FOR_SCROLL;
myData.pListing->iTitleOffset = 0;
myData.pListing->sens = 1;
cairo_dock_launch_animation (CAIRO_CONTAINER (myData.pListing));
cairo_dock_redraw_container (CAIRO_CONTAINER (myData.pListing));
}
void cd_do_close_session (void)
{
if (! cd_do_session_is_running ()) // session not running
return;
// no more keyboard input.
gldi_object_remove_notification (&myContainerObjectMgr,
NOTIFICATION_KEY_PRESSED,
(GldiNotificationFunc) cd_do_key_pressed, NULL);
gldi_object_remove_notification (&myIconObjectMgr,
NOTIFICATION_DESTROY,
(GldiNotificationFunc) cd_do_check_icon_destroyed, NULL);
gldi_object_remove_notification (&myWindowObjectMgr,
NOTIFICATION_WINDOW_ACTIVATED,
(GldiNotificationFunc) cd_do_check_active_dock, NULL);
g_string_free (myData.sCurrentText, TRUE);
myData.sCurrentText = NULL;
// reset session state.
if (myData.pCurrentIcon != NULL)
{
myData.bIgnoreIconState = TRUE;
gldi_icon_stop_animation (myData.pCurrentIcon);
myData.bIgnoreIconState = FALSE;
myData.pCurrentIcon = NULL;
}
myData.pPreviouslyActiveWindow = NULL;
if (myData.pCurrentDock != NULL)
{
cairo_dock_emit_leave_signal (CAIRO_CONTAINER (myData.pCurrentDock));
cd_do_remove_icons_number (myData.pCurrentDock);
// launch closing animation.
myData.iCloseTime = myConfig.iCloseDuration;
cairo_dock_launch_animation (CAIRO_CONTAINER (myData.pCurrentDock));
}
cairo_dock_freeze_docks (FALSE);
myData.iSessionState = CD_SESSION_CLOSING;
}
void cairo_dock_set_transition_on_icon (Icon *pIcon, GldiContainer *pContainer, CairoDockTransitionRenderFunc render_step_cairo, CairoDockTransitionGLRenderFunc render_step_opengl, gboolean bFastPace, gint iDuration, gboolean bRemoveWhenFinished, gpointer pUserData, GFreeFunc pFreeUserDataFunc)
{
cairo_dock_remove_transition_on_icon (pIcon);
CairoDockTransition *pTransition = g_new0 (CairoDockTransition, 1);
pTransition->render = render_step_cairo;
pTransition->render_opengl = render_step_opengl;
pTransition->bFastPace = bFastPace;
pTransition->iDuration = iDuration;
pTransition->bRemoveWhenFinished = bRemoveWhenFinished;
pTransition->pContainer = pContainer;
pTransition->pUserData = pUserData;
pTransition->pFreeUserDataFunc = pFreeUserDataFunc;
cairo_dock_set_transition (pIcon, pTransition);
gldi_object_register_notification (pIcon,
bFastPace ? NOTIFICATION_UPDATE_ICON : NOTIFICATION_UPDATE_ICON_SLOW,
(GldiNotificationFunc) _cairo_dock_transition_step,
GLDI_RUN_AFTER, pUserData);
cairo_dock_launch_animation (pContainer);
}
void cd_do_load_entries_into_listing (GList *pEntries, int iNbEntries)
{
cd_do_show_listing ();
if (myData.pListing->pEntries != NULL)
{
g_print ("%d entrees precedemment\n", myData.pListing->iNbEntries);
g_list_foreach (myData.pListing->pEntries, (GFunc)cd_do_free_entry, NULL);
g_list_free (myData.pListing->pEntries);
}
myData.pListing->pEntries = pEntries;
myData.pListing->iNbEntries = iNbEntries;
myData.pListing->iNbVisibleEntries = iNbEntries;
if (iNbEntries == 0)
cd_do_set_status (D_("No result"));
else if (iNbEntries >= myConfig.iNbResultMax)
cd_do_set_status_printf ("> %d results", myConfig.iNbResultMax);
else
cd_do_set_status_printf ("%d %s", iNbEntries, iNbEntries > 1 ? D_("results") : D_("result"));
cd_do_rewind_current_entry ();
myData.pListing->iCurrentEntryAnimationCount = NB_STEPS_FOR_CURRENT_ENTRY; // pas de surlignage pendant l'apparition.
myData.pListing->iScrollAnimationCount = 0;
myData.pListing->fAimedOffset = 0;
myData.pListing->fPreviousOffset = myData.pListing->fCurrentOffset = 0;
myData.pListing->sens = 1;
myData.pListing->iTitleOffset = 0;
myData.pListing->iTitleWidth = 0;
myData.pListing->iAppearanceAnimationCount = _listing_compute_nb_steps (myData.pListing);
if (iNbEntries != 0)
cairo_dock_launch_animation (CAIRO_CONTAINER (myData.pListing));
cd_do_fill_listing_entries (myData.pListing);
}
void cairo_dock_start_showing (CairoDock *pDock)
{
//g_print ("%s (%d)\n", __func__, pDock->bIsShowing);
if (! pDock->bIsShowing) // on lance l'animation.
{
// set current showing/hiding state
pDock->bIsShowing = TRUE;
pDock->bIsHiding = FALSE;
// reset the alpha for icons that were always visible (if they were still appearing, their alpha may have not reached 1 yet)
pDock->fPostHideOffset = 1.;
Icon *icon;
GList *ic;
for (ic = pDock->icons; ic != NULL; ic = ic->next)
{
icon = ic->data;
if (icon->bIsDemandingAttention || icon->bAlwaysVisible)
icon->fAlpha = 1.;
}
// reset the input shape (so that we can interact with the dock immediately)
if (pDock->pShapeBitmap && pDock->iInputState == CAIRO_DOCK_INPUT_HIDDEN)
{
//g_print ("+++ input shape at rest on start showing\n");
cairo_dock_set_input_shape_at_rest (pDock);
pDock->iInputState = CAIRO_DOCK_INPUT_AT_REST;
gldi_dialogs_replace_all ();
}
// init the animation
if (g_pHidingBackend != NULL && g_pHidingBackend->init)
g_pHidingBackend->init (pDock);
// and launch it
cairo_dock_launch_animation (CAIRO_CONTAINER (pDock));
}
}
void gldi_flying_container_terminate (CairoFlyingContainer *pFlyingContainer)
{
// detach the icon from the container
Icon *pIcon = pFlyingContainer->pIcon;
pFlyingContainer->pIcon = NULL;
cairo_dock_set_icon_container (pIcon, NULL);
// destroy it, or place it in a desklet.
if (pIcon->cDesktopFileName != NULL) // a launcher/sub-dock/separator, that is part of the theme
{
gldi_object_delete (GLDI_OBJECT(pIcon));
}
else if (CAIRO_DOCK_IS_APPLET(pIcon)) /// faire une fonction dans la factory ...
{
cd_debug ("le module %s devient un desklet", pIcon->pModuleInstance->cConfFilePath);
gldi_module_instance_detach_at_position (pIcon->pModuleInstance,
pFlyingContainer->container.iWindowPositionX + pFlyingContainer->container.iWidth/2,
pFlyingContainer->container.iWindowPositionY + pFlyingContainer->container.iHeight/2);
}
// start the explosion animation
cairo_dock_launch_animation (CAIRO_CONTAINER (pFlyingContainer));
}
static gboolean on_motion_notify_desklet (GtkWidget *pWidget,
GdkEventMotion* pMotion,
CairoDesklet *pDesklet)
{
/*if (pMotion->state & GDK_BUTTON1_MASK && cairo_dock_desklet_is_free (pDesklet))
{
cd_debug ("root : %d;%d", (int) pMotion->x_root, (int) pMotion->y_root);
}
else*/ // le 'press-button' est local au sous-widget clique, alors que le 'motion-notify' est global a la fenetre; c'est donc par lui qu'on peut avoir a coup sur les coordonnees du curseur (juste avant le clic).
{
pDesklet->container.iMouseX = pMotion->x;
pDesklet->container.iMouseY = pMotion->y;
gboolean bStartAnimation = FALSE;
gldi_object_notify (pDesklet, NOTIFICATION_MOUSE_MOVED, pDesklet, &bStartAnimation);
if (bStartAnimation)
cairo_dock_launch_animation (CAIRO_CONTAINER (pDesklet));
}
if (pDesklet->rotating && cairo_dock_desklet_is_free (pDesklet))
{
double alpha = atan2 (pDesklet->container.iHeight, - pDesklet->container.iWidth);
pDesklet->fRotation = alpha - atan2 (.5*pDesklet->container.iHeight - pMotion->y, pMotion->x - .5*pDesklet->container.iWidth);
while (pDesklet->fRotation > G_PI)
pDesklet->fRotation -= 2 * G_PI;
while (pDesklet->fRotation <= - G_PI)
pDesklet->fRotation += 2 * G_PI;
gtk_widget_queue_draw(pDesklet->container.pWidget);
}
else if (pDesklet->rotatingY && cairo_dock_desklet_is_free (pDesklet))
{
pDesklet->fDepthRotationY = G_PI * (pMotion->x - .5*pDesklet->container.iWidth) / pDesklet->container.iWidth;
gtk_widget_queue_draw(pDesklet->container.pWidget);
}
else if (pDesklet->rotatingX && cairo_dock_desklet_is_free (pDesklet))
{
pDesklet->fDepthRotationX = G_PI * (pMotion->y - .5*pDesklet->container.iHeight) / pDesklet->container.iHeight;
gtk_widget_queue_draw(pDesklet->container.pWidget);
}
else if (pMotion->state & GDK_BUTTON1_MASK && cairo_dock_desklet_is_free (pDesklet) && ! pDesklet->moving)
{
gtk_window_begin_move_drag (GTK_WINDOW (gtk_widget_get_toplevel (pWidget)),
1/*pButton->button*/,
pMotion->x_root/*pButton->x_root*/,
pMotion->y_root/*pButton->y_root*/,
pDesklet->time/*pButton->time*/);
pDesklet->moving = TRUE;
}
else
{
gboolean bStartAnimation = FALSE;
Icon *pIcon = gldi_desklet_find_clicked_icon (pDesklet);
if (pIcon != NULL)
{
if (! pIcon->bPointed)
{
Icon *pPointedIcon = cairo_dock_get_pointed_icon (pDesklet->icons);
if (pPointedIcon != NULL)
pPointedIcon->bPointed = FALSE;
pIcon->bPointed = TRUE;
//g_print ("on survole %s\n", pIcon->cName);
gldi_object_notify (pDesklet, NOTIFICATION_ENTER_ICON, pIcon, pDesklet, &bStartAnimation);
}
}
else
{
Icon *pPointedIcon = cairo_dock_get_pointed_icon (pDesklet->icons);
if (pPointedIcon != NULL)
{
pPointedIcon->bPointed = FALSE;
//g_print ("kedal\n");
//gldi_object_notify (pDesklet, NOTIFICATION_ENTER_ICON, pPointedIcon, pDesklet, &bStartAnimation);
}
}
if (bStartAnimation)
{
cairo_dock_launch_animation (CAIRO_CONTAINER (pDesklet));
}
}
gdk_device_get_state (pMotion->device, pMotion->window, NULL, NULL); // pour recevoir d'autres MotionNotify.
return FALSE;
}
void cd_do_change_current_icon (Icon *pIcon, CairoDock *pDock)
{
//\_________________ on gere le cachage et le montrage du dock precedent et actuel.
if (myData.pCurrentDock != NULL && pDock != myData.pCurrentDock && myData.pCurrentDock != g_pMainDock) // on remet au repos dock precedemment anime.
{
cairo_dock_emit_leave_signal (myData.pCurrentDock);
}
if (pDock != NULL && pDock != g_pMainDock && pDock != myData.pCurrentDock) // on montre le nouveau dock
{
if (pDock != NULL)
{
if (pDock->iRefCount > 0)
{
CairoDock *pParentDock = NULL;
Icon *pPointingIcon = cairo_dock_search_icon_pointing_on_dock (pDock, &pParentDock);
if (pPointingIcon != NULL)
{
cairo_dock_show_subdock (pPointingIcon, pParentDock, FALSE); // utile pour le montrage des sous-docks au clic.
}
}
else
{
cairo_dock_pop_up (pDock);
}
cairo_dock_emit_enter_signal (pDock);
}
}
if (pDock != NULL)
{
gtk_window_present (GTK_WINDOW (pDock->pWidget));
}
//\_________________ on gere l'allumage et l'eteignage de l'icone precedente et actuelle.
if (myData.pCurrentIcon != NULL && pIcon != myData.pCurrentIcon) // on remet au repos l'icone precedemment anime.
{
myData.bIgnoreIconState = TRUE;
cairo_dock_stop_icon_animation (myData.pCurrentIcon);
myData.bIgnoreIconState = FALSE;
cairo_dock_redraw_icon (myData.pCurrentIcon, CAIRO_CONTAINER (myData.pCurrentDock)); /// utile ?...
}
if (pIcon != NULL && myData.pCurrentIcon != pIcon) // on anime la nouvelle icone.
{
int x = pIcon->fXAtRest + pIcon->fWidth/2 + (- pDock->fFlatDockWidth + pDock->iMaxDockWidth)/2;
int y = pIcon->fDrawY + pIcon->fHeight/2 * pIcon->fScale;
if (1||myData.pCurrentDock != pDock)
{
cairo_dock_emit_motion_signal (pDock,
x,
y);
}
else
{
myData.iPrevMouseX = myData.iMouseX;
myData.iPrevMouseY = myData.iMouseY;
myData.iMotionCount = 10;
}
myData.iMouseX = x;
myData.iMouseY = y;
cairo_dock_request_icon_animation (pIcon, pDock, myConfig.cIconAnimation, 1e6); // interrompt l'animation de "mouse over".
cairo_dock_launch_animation (CAIRO_CONTAINER (pDock));
//if (myAccessibility.bShowSubDockOnClick)
// cairo_dock_show_subdock (pIcon, pDock, FALSE);
}
myData.pCurrentDock = pDock;
myData.pCurrentIcon = pIcon;
if (myData.pCurrentDock == NULL)
gtk_window_present (GTK_WINDOW (g_pMainDock->pWidget));
}
void cd_do_open_session (void)
{
if (cd_do_session_is_running ()) // session already running, noting to do
return;
if (! cd_do_session_is_off ()) // session not yet closed, close it first to reset the state.
cd_do_exit_session ();
// wait for keyboard input.
gldi_object_register_notification (&myContainerObjectMgr,
NOTIFICATION_KEY_PRESSED, (GldiNotificationFunc) cd_do_key_pressed, GLDI_RUN_AFTER, NULL);
gldi_object_register_notification (&myIconObjectMgr,
NOTIFICATION_DESTROY, (GldiNotificationFunc) cd_do_check_icon_destroyed, GLDI_RUN_AFTER, NULL);
gldi_object_register_notification (&myWindowObjectMgr,
NOTIFICATION_WINDOW_ACTIVATED, (GldiNotificationFunc) cd_do_check_active_dock, GLDI_RUN_AFTER, NULL);
myData.sCurrentText = g_string_sized_new (20);
// set initial position (dock, icon).
myData.pCurrentDock = NULL;
myData.pCurrentIcon = NULL;
CairoDock *pDock = gldi_dock_get (myConfig.cDockName);
if (pDock == NULL)
pDock = g_pMainDock;
Icon *pIcon = NULL;
int n = g_list_length (pDock->icons);
if (n > 0)
{
pIcon = g_list_nth_data (pDock->icons, (n-1) / 2);
if (CAIRO_DOCK_ICON_TYPE_IS_SEPARATOR (pIcon) && n > 1)
pIcon = g_list_nth_data (pDock->icons, (n+1) / 2);
}
cd_do_change_current_icon (pIcon, pDock);
// show the number of the 10 first icons
cd_do_numberize_icons (pDock);
// show the dock.
myData.bIgnoreIconState = TRUE;
cairo_dock_emit_enter_signal (CAIRO_CONTAINER (pDock));
myData.bIgnoreIconState = FALSE;
// give it focus for inputs.
myData.pPreviouslyActiveWindow = gldi_windows_get_active ();
gldi_container_present (CAIRO_CONTAINER (pDock));
cairo_dock_freeze_docks (TRUE);
// launch the animation.
myData.iPromptAnimationCount = 0;
if (myData.pArrowImage == NULL)
{
myData.pArrowImage = cairo_dock_create_image_buffer (MY_APPLET_SHARE_DATA_DIR"/arrows.svg",
pDock->iActiveHeight,
pDock->iActiveHeight,
CAIRO_DOCK_KEEP_RATIO);
}
cairo_dock_launch_animation (CAIRO_CONTAINER (pDock));
myData.iSessionState = CD_SESSION_RUNNING;
}
void cd_do_change_current_icon (Icon *pIcon, CairoDock *pDock)
{
//\_________________ on gere le cachage et le montrage du dock precedent et actuel.
if (myData.pCurrentDock != NULL && pDock != myData.pCurrentDock) // on remet au repos le dock precedemment anime.
{
cd_debug ("leave this dock");
cairo_dock_emit_leave_signal (CAIRO_CONTAINER (myData.pCurrentDock));
cd_do_remove_icons_number (myData.pCurrentDock);
gldi_object_remove_notification (myData.pCurrentDock, NOTIFICATION_RENDER, (GldiNotificationFunc) cd_do_render, NULL);
gldi_object_remove_notification (myData.pCurrentDock, NOTIFICATION_UPDATE, (GldiNotificationFunc) cd_do_update_container, NULL);
gldi_object_remove_notification (myData.pCurrentDock, NOTIFICATION_CLICK_ICON, (GldiNotificationFunc) cd_do_on_click, NULL);
gldi_object_remove_notification (myData.pCurrentDock, NOTIFICATION_MIDDLE_CLICK_ICON, (GldiNotificationFunc) cd_do_on_click, NULL);
}
if (pDock != NULL && pDock != myData.pCurrentDock) // on montre le nouveau dock
{
cd_debug (" dock %p <- %p", myData.pCurrentDock, pDock);
if (pDock->iRefCount > 0)
{
CairoDock *pParentDock = NULL;
Icon *pPointingIcon = cairo_dock_search_icon_pointing_on_dock (pDock, &pParentDock);
if (pPointingIcon != NULL)
{
cairo_dock_show_subdock (pPointingIcon, pParentDock); // utile pour le montrage des sous-docks au clic.
}
}
else
{
/// utile de faire ca si on entre dedans ?...
cd_debug ("enter this dock");
if (pDock->bAutoHide)
cairo_dock_start_showing (pDock);
if (pDock->iVisibility == CAIRO_DOCK_VISI_KEEP_BELOW)
cairo_dock_pop_up (pDock);
}
cairo_dock_emit_enter_signal (CAIRO_CONTAINER (pDock));
cd_do_numberize_icons (pDock);
gldi_object_register_notification (pDock,
NOTIFICATION_UPDATE,
(GldiNotificationFunc) cd_do_update_container,
GLDI_RUN_AFTER, NULL);
gldi_object_register_notification (pDock,
NOTIFICATION_RENDER,
(GldiNotificationFunc) cd_do_render,
GLDI_RUN_AFTER, NULL);
gldi_object_register_notification (pDock,
NOTIFICATION_CLICK_ICON,
(GldiNotificationFunc) cd_do_on_click,
GLDI_RUN_AFTER, NULL); // we don't disable the clicks, rather we will close the session.
gldi_object_register_notification (pDock,
NOTIFICATION_MIDDLE_CLICK_ICON,
(GldiNotificationFunc) cd_do_on_click,
GLDI_RUN_AFTER, NULL);
}
if (pDock != NULL)
{
gtk_window_present (GTK_WINDOW (pDock->container.pWidget));
}
//\_________________ on gere l'allumage et l'eteignage de l'icone precedente et actuelle.
if (myData.pCurrentIcon != NULL && pIcon != myData.pCurrentIcon) // on remet au repos l'icone precedemment anime.
{
myData.bIgnoreIconState = TRUE;
gldi_icon_stop_animation (myData.pCurrentIcon);
myData.bIgnoreIconState = FALSE;
cairo_dock_redraw_icon (myData.pCurrentIcon); /// utile ?...
}
if (pIcon != NULL && myData.pCurrentIcon != pIcon) // on anime la nouvelle icone.
{
int x = pIcon->fXAtRest + pIcon->fWidth/2 + (- pDock->fFlatDockWidth + pDock->iMaxDockWidth)/2;
int y = pIcon->fDrawY + pIcon->fHeight/2 * pIcon->fScale;
if (1||myData.pCurrentDock != pDock)
{
cairo_dock_emit_motion_signal (pDock,
pDock->container.bIsHorizontal ? x : y,
pDock->container.bIsHorizontal ? y : x);
}
else
{
myData.iPrevMouseX = myData.iMouseX;
myData.iPrevMouseY = myData.iMouseY;
myData.iMotionCount = 10;
}
myData.iMouseX = x;
myData.iMouseY = y;
gldi_icon_request_animation (pIcon, myConfig.cIconAnimation, 1e6); // interrompt l'animation de "mouse over".
cairo_dock_launch_animation (CAIRO_CONTAINER (pDock));
}
myData.pCurrentDock = pDock;
myData.pCurrentIcon = pIcon;
cd_debug ("myData.pCurrentDock <- %p", myData.pCurrentDock);
}
void gldi_dialog_init_internals (CairoDialog *pDialog, CairoDialogAttr *pAttribute)
{
pDialog->container.iface.animation_loop = _animation_loop;
//\________________ set up the window
GtkWidget *pWindow = pDialog->container.pWidget;
gtk_window_set_title (GTK_WINDOW (pWindow), "cairo-dock-dialog");
if (! pAttribute->pInteractiveWidget && ! pAttribute->pActionFunc) // not an interactive dialog
gtk_window_set_type_hint (GTK_WINDOW (pDialog->container.pWidget), GDK_WINDOW_TYPE_HINT_SPLASHSCREEN); // pour ne pas prendre le focus.
gtk_widget_add_events (pWindow, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
gtk_window_resize (GTK_WINDOW (pWindow), CAIRO_DIALOG_MIN_SIZE, CAIRO_DIALOG_MIN_SIZE);
gtk_window_set_keep_above (GTK_WINDOW (pWindow), TRUE);
pDialog->pIcon = pAttribute->pIcon;
if (pAttribute->bForceAbove) // try to force it above other windows (with most WM, it will still stay below fullscreen windows).
{
gtk_window_set_keep_above (GTK_WINDOW (pDialog->container.pWidget), TRUE);
gtk_window_set_type_hint (GTK_WINDOW (pDialog->container.pWidget), GDK_WINDOW_TYPE_HINT_DOCK); // should be called before the window becomes visible
}
//\________________ load the message
if (pAttribute->cText != NULL)
{
pDialog->cText = g_strdup (pAttribute->cText); // it may be a const string, so duplicate it
pDialog->pTextBuffer = _cairo_dock_create_dialog_text_surface (pAttribute->cText,
pAttribute->bUseMarkup,
&pDialog->iTextWidth, &pDialog->iTextHeight);
///pDialog->iTextTexture = cairo_dock_create_texture_from_surface (pDialog->pTextBuffer);
}
pDialog->bUseMarkup = pAttribute->bUseMarkup; // remember this attribute, in case another text is set (with cairo_dock_set_dialog_message).
//\________________ load the icon
if (pAttribute->cImageFilePath != NULL)
{
pDialog->pIconBuffer = _cairo_dock_create_dialog_icon_surface (pAttribute->cImageFilePath, pAttribute->pIcon, pAttribute->iIconSize, &pDialog->iIconSize);
///pDialog->iIconTexture = cairo_dock_create_texture_from_surface (pDialog->pIconBuffer);
}
//\________________ load the interactive widget
if (pAttribute->pInteractiveWidget != NULL)
{
pDialog->pInteractiveWidget = pAttribute->pInteractiveWidget;
GtkRequisition requisition;
gtk_widget_get_preferred_size (pAttribute->pInteractiveWidget, &requisition, NULL);
pDialog->iInteractiveWidth = requisition.width;
pDialog->iInteractiveHeight = requisition.height;
}
//\________________ load the buttons
pDialog->pUserData = pAttribute->pUserData;
pDialog->pFreeUserDataFunc = pAttribute->pFreeDataFunc;
if (pAttribute->cButtonsImage != NULL && pAttribute->pActionFunc != NULL)
{
int i;
for (i = 0; pAttribute->cButtonsImage[i] != NULL; i++);
pDialog->iNbButtons = i;
pDialog->action_on_answer = pAttribute->pActionFunc;
pDialog->pButtons = g_new0 (CairoDialogButton, pDialog->iNbButtons);
const gchar *cButtonImage;
for (i = 0; i < pDialog->iNbButtons; i++)
{
cButtonImage = pAttribute->cButtonsImage[i];
if (strcmp (cButtonImage, "ok") == 0)
{
pDialog->pButtons[i].iDefaultType = 1;
}
else if (strcmp (cButtonImage, "cancel") == 0)
{
pDialog->pButtons[i].iDefaultType = 0;
}
else
{
gchar *cButtonPath;
if (*cButtonImage != '/')
cButtonPath = cairo_dock_search_icon_s_path (cButtonImage,
MAX (myDialogsParam.iDialogButtonWidth, myDialogsParam.iDialogButtonHeight));
else
cButtonPath = (gchar*)cButtonImage;
pDialog->pButtons[i].pSurface = cairo_dock_create_surface_from_image_simple (cButtonPath,
myDialogsParam.iDialogButtonWidth,
myDialogsParam.iDialogButtonHeight);
if (cButtonPath != cButtonImage)
g_free (cButtonPath);
///pDialog->pButtons[i].iTexture = cairo_dock_create_texture_from_surface (pDialog->pButtons[i].pSurface);
}
}
}
else
{
pDialog->bNoInput = pAttribute->bNoInput;
}
//\________________ set a decorator.
cairo_dock_set_dialog_decorator_by_name (pDialog, (pAttribute->cDecoratorName ? pAttribute->cDecoratorName : myDialogsParam.cDecoratorName));
if (pDialog->pDecorator != NULL)
pDialog->pDecorator->set_size (pDialog);
//\________________ Maintenant qu'on connait tout, on calcule les tailles des divers elements.
_compute_dialog_sizes (pDialog);
pDialog->container.iWidth = pDialog->iBubbleWidth + pDialog->iLeftMargin + pDialog->iRightMargin;
pDialog->container.iHeight = pDialog->iBubbleHeight + pDialog->iTopMargin + pDialog->iBottomMargin + pDialog->iMinBottomGap;
//\________________ On reserve l'espace pour les decorations.
GtkWidget *pMainHBox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_container_add (GTK_CONTAINER (pDialog->container.pWidget), pMainHBox);
pDialog->pLeftPaddingBox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
g_object_set (pDialog->pLeftPaddingBox, "width-request", pDialog->iLeftMargin, NULL);
gtk_box_pack_start (GTK_BOX (pMainHBox),
pDialog->pLeftPaddingBox,
FALSE,
FALSE,
0);
pDialog->pWidgetLayout = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start (GTK_BOX (pMainHBox),
pDialog->pWidgetLayout,
FALSE,
FALSE,
0);
pDialog->pRightPaddingBox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
g_object_set (pDialog->pRightPaddingBox, "width-request", pDialog->iRightMargin, NULL);
gtk_box_pack_start (GTK_BOX (pMainHBox),
pDialog->pRightPaddingBox,
FALSE,
FALSE,
0);
//\________________ On reserve l'espace pour les elements.
if (pDialog->container.bDirectionUp)
pDialog->pTopWidget = _cairo_dock_add_dialog_internal_box (pDialog, 0, pDialog->iTopMargin, FALSE);
else
pDialog->pTipWidget = _cairo_dock_add_dialog_internal_box (pDialog, 0, pDialog->iMinBottomGap + pDialog->iBottomMargin, TRUE);
if (pDialog->iMessageWidth != 0 && pDialog->iMessageHeight != 0)
{
pDialog->pMessageWidget = _cairo_dock_add_dialog_internal_box (pDialog, pDialog->iMessageWidth, pDialog->iMessageHeight, FALSE);
}
if (pDialog->pInteractiveWidget != NULL)
{
gtk_box_pack_start (GTK_BOX (pDialog->pWidgetLayout),
pDialog->pInteractiveWidget,
FALSE,
FALSE,
0);
gtk_window_present (GTK_WINDOW (pDialog->container.pWidget));
gtk_widget_grab_focus (pDialog->pInteractiveWidget);
// set a MenuItem style to the dialog, so that the interactive widget can use the style defined for menu-items (either from the GTK theme, or from our own .css), and therefore be well integrated into the dialog, as if it was inside a menu.
GtkStyleContext *ctx = gtk_widget_get_style_context (pDialog->pWidgetLayout);
gtk_style_context_add_class (ctx, myDialogsParam.bUseDefaultColors && myStyleParam.bUseSystemColors ? GTK_STYLE_CLASS_MENUITEM : "gldimenuitem");
}
if (pDialog->pButtons != NULL)
{
pDialog->pButtonsWidget = _cairo_dock_add_dialog_internal_box (pDialog, pDialog->iButtonsWidth, pDialog->iButtonsHeight, FALSE);
}
if (pDialog->container.bDirectionUp)
pDialog->pTipWidget = _cairo_dock_add_dialog_internal_box (pDialog, 0, pDialog->iMinBottomGap + pDialog->iBottomMargin, TRUE);
else
pDialog->pTopWidget = _cairo_dock_add_dialog_internal_box (pDialog, 0, pDialog->iTopMargin, TRUE);
gtk_widget_show_all (pDialog->container.pWidget);
//\________________ load the input shape.
if (pDialog->bNoInput)
{
_cairo_dock_set_dialog_input_shape (pDialog);
}
//\________________ connect the signals to the window
g_signal_connect (G_OBJECT (pDialog->container.pWidget),
"draw",
G_CALLBACK (on_expose_dialog),
pDialog);
g_signal_connect_after (G_OBJECT (pDialog->container.pWidget),
"draw",
G_CALLBACK (on_expose_dialog_after),
pDialog);
g_signal_connect (G_OBJECT (pDialog->container.pWidget),
"configure-event",
G_CALLBACK (on_configure_dialog),
pDialog);
g_signal_connect (G_OBJECT (pDialog->container.pWidget),
"unmap-event",
G_CALLBACK (on_unmap_dialog),
pDialog); // prevent dialogs from being hidden (for instance by a 'show-desktop' event), because they might be modal
g_signal_connect (G_OBJECT (pDialog->container.pWidget),
"map-event",
G_CALLBACK (on_map_dialog),
pDialog); // some WM (like GS) prevent the focus to be taken, so we have to force it whenever the dialog is shown (creation or unhide).
if (pDialog->pInteractiveWidget != NULL && pDialog->pButtons == NULL) // the dialog has no button to be closed, so it can be closed by clicking on it. But some widget (like the GTK calendar) let pass the click to their parent (= the dialog), which then close it. To prevent this, we memorize the last click on the widget.
g_signal_connect (G_OBJECT (pDialog->pInteractiveWidget),
"button-press-event",
G_CALLBACK (on_button_press_widget),
pDialog);
cairo_dock_launch_animation (CAIRO_CONTAINER (pDialog));
}
