static gboolean update (Icon *pIcon, CairoDock *pDock, CDAnimationData *pData, double dt, gboolean bUseOpenGL, gboolean bRepeat)
{
pData->fAdjustFactor = 0.;
if (pData->fRotationAngle < alpha_brake)
{
if (pData->bRotationBeginning)
{
pData->fAdjustFactor = (alpha_brake - pData->fRotationAngle) / (alpha_brake - 0.);
pData->fRotationBrake = MAX (.2, (pData->fRotationAngle) / (alpha_brake));
}
}
else if (pData->bRotationBeginning)
pData->bRotationBeginning = FALSE;
if (pData->fRotationAngle > 360 - alpha_brake)
{
if (! bRepeat)
{
pData->fRotationBrake = MAX (.2, (360. - pData->fRotationAngle) / (alpha_brake));
pData->fAdjustFactor = (pData->fRotationAngle - (360 - alpha_brake)) / (alpha_brake);
}
}
pData->fRotationAngle += pData->fRotationSpeed * pData->fRotationBrake;
if (! bUseOpenGL)
{
double fDamageWidthFactor = pData->fRotateWidthFactor;
pData->fRotateWidthFactor = cos (pData->fRotationAngle/180.*G_PI);
if (fabs (pData->fRotateWidthFactor) < .01)
pData->fRotateWidthFactor = .01;
if (! pDock->bIsShrinkingDown && ! pDock->bIsGrowingUp)
{
fDamageWidthFactor = MAX (fabs (fDamageWidthFactor), fabs (pData->fRotateWidthFactor));
pIcon->fWidthFactor *= fDamageWidthFactor;
cairo_dock_redraw_icon (pIcon);
pIcon->fWidthFactor /= fDamageWidthFactor;
}
}
else
{
//if (myConfig.iMeshType == CD_CUBE_MESH)
//pIcon->fWidth *= (1 + .2 * 1); // the cube is larger than it's icon
cairo_dock_redraw_icon (pIcon);
//if (myConfig.iMeshType == CD_CUBE_MESH)
//pIcon->fWidth /= (1 + .2 * 1);
}
gboolean bContinue = (pData->fRotationAngle < 360);
if (! bContinue)
{
if (bRepeat)
pData->fRotationAngle -= 360;
else
pData->fRotationAngle = 0.;
}
return bContinue;
}
static gboolean _on_active_window_changed (G_GNUC_UNUSED gpointer data, GldiWindowActor *actor)
{
// on gere son animation et son indicateur.
Icon *icon = _get_appli_icon (actor);
CairoDock *pParentDock = NULL;
if (CAIRO_DOCK_IS_APPLI (icon))
{
if (icon->bIsDemandingAttention) // force the stop demanding attention, as it can happen (for some reason) that the attention state doesn't change when the appli takes the focus.
gldi_appli_icon_stop_demanding_attention (icon);
pParentDock = CAIRO_DOCK(cairo_dock_get_icon_container (icon));
if (pParentDock == NULL) // inhibited or not shown
{
///cairo_dock_update_activity_on_inhibitors (icon->cClass, actor);
gldi_window_inhibitors_set_active_state (actor, TRUE);
}
else
{
gldi_appli_icon_animate_on_active (icon, pParentDock);
}
}
// on enleve l'indicateur sur la precedente appli active.
Icon *pLastActiveIcon = _get_appli_icon (s_pCurrentActiveWindow);
if (CAIRO_DOCK_IS_APPLI (pLastActiveIcon))
{
CairoDock *pLastActiveParentDock = CAIRO_DOCK(cairo_dock_get_icon_container (pLastActiveIcon));
if (pLastActiveParentDock == NULL) // inhibited or not shown
{
///cairo_dock_update_inactivity_on_inhibitors (pLastActiveIcon->cClass, s_pCurrentActiveWindow);
gldi_window_inhibitors_set_active_state (s_pCurrentActiveWindow, FALSE);
}
else
{
cairo_dock_redraw_icon (pLastActiveIcon);
if (pLastActiveParentDock->iRefCount != 0) // l'icone est dans un sous-dock, comme l'indicateur est aussi dessine sur l'icone pointant sur ce sous-dock, il faut la redessiner sans l'indicateur.
{
CairoDock *pMainDock = NULL;
Icon *pPointingIcon = cairo_dock_search_icon_pointing_on_dock (pLastActiveParentDock, &pMainDock);
if (pPointingIcon && pMainDock)
{
cairo_dock_redraw_icon (pPointingIcon);
}
}
}
}
s_pCurrentActiveWindow = actor;
return GLDI_NOTIFICATION_LET_PASS;
}
gboolean cd_drop_indicator_update_dock (gpointer pUserData, CairoDock *pDock, gboolean *bContinueAnimation)
{
CDDropIndicatorData *pData = CD_APPLET_GET_MY_DOCK_DATA (pDock);
if (pData == NULL)
return GLDI_NOTIFICATION_LET_PASS;
pData->iDropIndicatorOffset += myConfig.iSpeed;
if (pData->iDropIndicatorOffset > 2*myData.dropIndicator.iHeight)
pData->iDropIndicatorOffset -= 2*myData.dropIndicator.iHeight;
double dt = cairo_dock_get_animation_delta_t (CAIRO_CONTAINER (pDock));
pData->iDropIndicatorRotation += myConfig.fRotationSpeed * 360. * dt/1e3;
if (pDock->bCanDrop)
{
pData->fAlphaHover -= delta_alpha;
*bContinueAnimation = TRUE;
}
else
{
pData->fAlpha -= delta_alpha;
if (!pDock->bIsDragging)
pData->fAlphaHover -= delta_alpha;
if (pData->fAlpha <= 0 && pData->fAlphaHover <= 0)
{
g_free (pData);
pData = NULL;
CD_APPLET_SET_MY_DOCK_DATA (pDock, NULL);
}
else
*bContinueAnimation = TRUE;
}
GdkRectangle rect = {(int) pDock->container.iMouseX - myData.dropIndicator.iWidth/2,
(int) (pDock->container.bDirectionUp ? 0 : pDock->iActiveHeight - 2*myData.dropIndicator.iHeight),
(int) myData.dropIndicator.iWidth,
(int) 2*myData.dropIndicator.iHeight};
if (! pDock->container.bIsHorizontal)
{
rect.x = (int) (pDock->container.bDirectionUp ? pDock->container.iHeight - pDock->iActiveHeight : pDock->iActiveHeight - 2*myData.dropIndicator.iHeight);
rect.y = (int) pDock->container.iMouseX - myData.dropIndicator.iWidth/2;
rect.width = (int) 2*myData.dropIndicator.iHeight;
rect.height = (int) myData.dropIndicator.iWidth;
}
//g_print ("rect (%d;%d) (%dx%d)\n", rect.x, rect.y, rect.width, rect.height);
if (rect.width > 0 && rect.height > 0)
{
cairo_dock_redraw_container_area (CAIRO_CONTAINER (pDock), &rect);
}
if (pData && pData->fAlphaHover > 0)
{
Icon *pIcon = cairo_dock_get_pointed_icon (pDock->icons);
if (pIcon != NULL)
cairo_dock_redraw_icon (pIcon);
}
return GLDI_NOTIFICATION_LET_PASS;
}
static GKeyFile* reload_object (GldiObject *obj, gboolean bReloadConf, GKeyFile *pKeyFile)
{
Icon *icon = (Icon*)obj;
if (bReloadConf)
g_return_val_if_fail (pKeyFile != NULL, NULL);
gchar *cClass = icon->cClass;
icon->cClass = NULL;
gchar *cName = icon->cName;
icon->cName = NULL;
g_free (icon->cFileName);
icon->cFileName = NULL;
g_free (icon->cCommand);
icon->cCommand = NULL;
if (icon->pMimeTypes != NULL)
{
g_strfreev (icon->pMimeTypes);
icon->pMimeTypes = NULL;
}
g_free (icon->cWorkingDirectory);
icon->cWorkingDirectory = NULL;
//\__________________ get parameters
_get_launcher_params (icon, pKeyFile);
//\_____________ reload icon's buffers
GldiContainer *pNewContainer = cairo_dock_get_icon_container (icon);
cairo_dock_load_icon_image (icon, pNewContainer);
if (g_strcmp0 (cName, icon->cName) != 0)
cairo_dock_load_icon_text (icon);
//\_____________ handle class inhibition.
gchar *cNowClass = icon->cClass;
if (cClass != NULL && (cNowClass == NULL || strcmp (cNowClass, cClass) != 0)) // la classe a change, on desinhibe l'ancienne.
{
icon->cClass = cClass;
cairo_dock_deinhibite_class (cClass, icon);
cClass = NULL; // libere par la fonction precedente.
icon->cClass = cNowClass;
}
if (myTaskbarParam.bMixLauncherAppli && cNowClass != NULL && (cClass == NULL || strcmp (cNowClass, cClass) != 0)) // la classe a change, on inhibe la nouvelle.
cairo_dock_inhibite_class (cNowClass, icon);
//\_____________ redraw dock.
cairo_dock_redraw_icon (icon);
g_free (cClass);
g_free (cName);
return pKeyFile;
}
static gboolean _cairo_dock_transition_step (G_GNUC_UNUSED gpointer pUserData, Icon *pIcon, GldiContainer *pContainer, gboolean *bContinueAnimation)
{
CairoDockTransition *pTransition = cairo_dock_get_transition (pIcon);
if (pTransition == NULL)
return GLDI_NOTIFICATION_LET_PASS;
pTransition->iCount ++;
int iDetlaT = (pTransition->bFastPace ? cairo_dock_get_animation_delta_t (pContainer) : cairo_dock_get_slow_animation_delta_t (pContainer));
//int iNbSteps = 1.*pTransition->iDuration / iDetlaT;
pTransition->iElapsedTime += iDetlaT;
if (pTransition->iElapsedTime > pTransition->iDuration)
pTransition->iElapsedTime = pTransition->iDuration;
if (! pTransition->bRemoveWhenFinished && pTransition->iDuration != 0 && pTransition->iElapsedTime >= pTransition->iDuration) // skip
return GLDI_NOTIFICATION_LET_PASS;
gboolean bContinue = FALSE;
if (CAIRO_CONTAINER_IS_OPENGL (pTransition->pContainer))
{
if (pTransition->render_opengl)
{
if (! cairo_dock_begin_draw_icon (pIcon, 0))
return GLDI_NOTIFICATION_LET_PASS;
bContinue = pTransition->render_opengl (pIcon, pTransition->pUserData);
cairo_dock_end_draw_icon (pIcon);
cairo_dock_redraw_icon (pIcon);
}
else if (pTransition->render != NULL)
{
bContinue = pTransition->render (pIcon, pTransition->pUserData);
}
}
else if (pTransition->render != NULL)
{
bContinue = pTransition->render (pIcon, pTransition->pUserData);
}
if (pTransition->iDuration != 0 && pTransition->iElapsedTime >= pTransition->iDuration)
bContinue = FALSE;
if (! bContinue)
{
if (pTransition->bRemoveWhenFinished)
cairo_dock_remove_transition_on_icon (pIcon);
}
else
{
*bContinueAnimation = TRUE;
}
return GLDI_NOTIFICATION_LET_PASS;
}
gboolean cd_animations_update_wobbly_cairo (Icon *pIcon, CairoDock *pDock, CDAnimationData *pData, gboolean bWillContinue)
{
int iNbIterInOneRound = 20;
int c = pData->iWobblyCount;
int n = iNbIterInOneRound / 4; // nbre d'iteration pour 1 etirement/retrecissement.
int k = c%n;
double fDamageWidthFactor = (c == iNbIterInOneRound-1 ? 1. : pData->fWobblyWidthFactor);
double fDamageHeightFactor = (c == iNbIterInOneRound-1 ? 1. : pData->fWobblyHeightFactor);
double fMinSize = .3, fMaxSize = MIN (1.75, pDock->iCurrentHeight / pIcon->fWidth); // au plus 1.75, soit 3/8 de l'icone qui deborde de part et d'autre de son emplacement. c'est suffisamment faible pour ne pas trop empieter sur ses voisines.
double fSizeFactor = ((c/n) & 1 ? 1. / (n - k) : 1. / (1 + k));
//double fSizeFactor = ((c/n) & 1 ? 1.*(k+1)/n : 1.*(n-k)/n);
fSizeFactor = (fMinSize - fMaxSize) * fSizeFactor + fMaxSize;
if ((c/(2*n)) & 1)
{
pData->fWobblyWidthFactor = fSizeFactor;
pData->fWobblyHeightFactor = fMinSize;
//g_print ("%d) width <- %.2f ; height <- %.2f (%d)\n", c, pData->fWidthFactor, pData->fHeightFactor, k);
}
else if (c != 0 || bWillContinue)
{
pData->fWobblyHeightFactor = fSizeFactor;
pData->fWobblyWidthFactor = fMinSize;
//g_print ("%d) height <- %.2f ; width <- %.2f (%d)\n", c, pData->fHeightFactor, pData->fWidthFactor, k);
}
else
{
pData->fWobblyHeightFactor = 1.;
pData->fWobblyWidthFactor = 1.;
}
pData->iWobblyCount --;
if (! pDock->bIsShrinkingDown && ! pDock->bIsGrowingUp)
{
fDamageWidthFactor = MAX (fDamageWidthFactor, pData->fWobblyWidthFactor);
fDamageHeightFactor = MAX (fDamageHeightFactor, pData->fWobblyHeightFactor);
pIcon->fWidthFactor *= fDamageWidthFactor;
pIcon->fHeightFactor *= fDamageHeightFactor;
cairo_dock_redraw_icon (pIcon, CAIRO_CONTAINER (pDock));
pIcon->fWidthFactor /= fDamageWidthFactor;
pIcon->fHeightFactor /= fDamageHeightFactor;
}
return (pData->iWobblyCount >= 0);
}
static gboolean _load_icon_buffer_idle (Icon *pIcon)
{
//g_print ("%s (%s; %dx%d; %.2fx%.2f; %x)\n", __func__, pIcon->cName, pIcon->iAllocatedWidth, pIcon->iAllocatedHeight, pIcon->fWidth, pIcon->fHeight, pIcon->pContainer);
pIcon->iSidLoadImage = 0;
GldiContainer *pContainer = pIcon->pContainer;
if (pContainer)
{
cairo_dock_load_icon_image (pIcon, pContainer);
if (cairo_dock_get_icon_data_renderer (pIcon) != NULL)
cairo_dock_refresh_data_renderer (pIcon, pContainer);
cairo_dock_load_icon_quickinfo (pIcon);
cairo_dock_redraw_icon (pIcon);
//g_print ("icon-factory: do 1 main loop iteration\n");
//gtk_main_iteration_do (FALSE); /// "unforseen consequences" : if _redraw_subdock_content_idle is planned just after, the container-icon stays blank in opengl only. couldn't figure why exactly :-/
}
return FALSE;
}
static gboolean cairo_dock_update_icon_data_renderer_notification (G_GNUC_UNUSED gpointer pUserData, Icon *pIcon, GldiContainer *pContainer, gboolean *bContinueAnimation)
{
CairoDataRenderer *pRenderer = cairo_dock_get_icon_data_renderer (pIcon);
if (pRenderer == NULL)
return GLDI_NOTIFICATION_LET_PASS;
if (pRenderer->iSmoothAnimationStep > 0)
{
pRenderer->iSmoothAnimationStep --;
int iDeltaT = cairo_dock_get_slow_animation_delta_t (pContainer);
int iNbIterations = pRenderer->iLatencyTime / iDeltaT;
pRenderer->fLatency = (double) pRenderer->iSmoothAnimationStep / iNbIterations;
_cairo_dock_render_to_texture (pRenderer, pIcon, pContainer);
cairo_dock_redraw_icon (pIcon);
if (pRenderer->iSmoothAnimationStep < iNbIterations)
*bContinueAnimation = TRUE;
}
return GLDI_NOTIFICATION_LET_PASS;
}
static gboolean _on_window_icon_changed (G_GNUC_UNUSED gpointer data, GldiWindowActor *actor)
{
Icon *icon = _get_appli_icon (actor);
if (icon == NULL)
return GLDI_NOTIFICATION_LET_PASS;
if (cairo_dock_class_is_using_xicon (icon->cClass) || ! myTaskbarParam.bOverWriteXIcons)
{
GldiContainer *pContainer = cairo_dock_get_icon_container (icon);
if (pContainer != NULL) // if the icon is not in a container (for instance inhibited), it's no use trying to load its image. It's not even useful to mark it as 'damaged', since anyway it will be loaded when inserted inside a container.
{
cairo_dock_load_icon_image (icon, pContainer);
if (CAIRO_DOCK_IS_DOCK (pContainer))
{
CairoDock *pDock = CAIRO_DOCK (pContainer);
if (pDock->iRefCount != 0)
cairo_dock_trigger_redraw_subdock_content (pDock);
}
cairo_dock_redraw_icon (icon);
}
}
return GLDI_NOTIFICATION_LET_PASS;
}
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));
}
static gboolean _on_window_state_changed (G_GNUC_UNUSED gpointer data, GldiWindowActor *actor, gboolean bHiddenChanged, G_GNUC_UNUSED gboolean bMaximizedChanged, G_GNUC_UNUSED gboolean bFullScreenChanged)
{
Icon *icon = _get_appli_icon (actor);
if (icon == NULL)
return GLDI_NOTIFICATION_LET_PASS;
// on gere le cachage/apparition de l'icone (transparence ou miniature, applis minimisees seulement).
CairoDock *pParentDock = CAIRO_DOCK(cairo_dock_get_icon_container (icon));
if (bHiddenChanged)
{
cd_message (" changement de visibilite -> %d", actor->bIsHidden);
// drawing of hidden appli-icons.
if (g_bUseOpenGL && myTaskbarParam.iMinimizedWindowRenderType == 2)
{
if (pParentDock != NULL)
{
cairo_dock_draw_hidden_appli_icon (icon, CAIRO_CONTAINER (pParentDock), TRUE);
}
}
else if (myTaskbarParam.iMinimizedWindowRenderType == 0)
{
// transparence sur les inhibiteurs.
///cairo_dock_update_visibility_on_inhibitors (icon->cClass, actor, actor->bIsHidden);
gldi_window_inhibitors_set_hidden_state (actor, actor->bIsHidden);
}
// showing hidden appli-icons only
if (myTaskbarParam.bHideVisibleApplis && myTaskbarParam.bShowAppli) // on insere/detache l'icone selon la visibilite de la fenetre, avec une animation.
{
if (actor->bIsHidden) // se cache => on insere son icone.
{
cd_message (" => se cache");
pParentDock = gldi_appli_icon_insert_in_dock (icon, g_pMainDock, CAIRO_DOCK_ANIMATE_ICON);
if (pParentDock != NULL)
{
if (g_bUseOpenGL && myTaskbarParam.iMinimizedWindowRenderType == 2) // quand on est passe dans ce cas tout a l'heure l'icone n'etait pas encore dans son dock.
cairo_dock_draw_hidden_appli_icon (icon, CAIRO_CONTAINER (pParentDock), TRUE);
gtk_widget_queue_draw (pParentDock->container.pWidget);
}
}
else // se montre => on detache l'icone.
{
cd_message (" => re-apparait");
cairo_dock_trigger_icon_removal_from_dock (icon);
}
}
else if (myTaskbarParam.fVisibleAppliAlpha != 0) // transparence
{
icon->fAlpha = 1; // on triche un peu.
if (pParentDock != NULL)
cairo_dock_redraw_icon (icon);
}
// miniature (on le fait apres l'avoir inseree/detachee, car comme ca dans le cas ou on l'enleve du dock apres l'avoir deminimisee, l'icone est marquee comme en cours de suppression, et donc on ne recharge pas son icone. Sinon l'image change pendant la transition, ce qui est pas top. Comme ca ne change pas la taille de l'icone dans le dock, on peut faire ca apres l'avoir inseree.
if (myTaskbarParam.iMinimizedWindowRenderType == 1 && (pParentDock != NULL || myTaskbarParam.bHideVisibleApplis))
{
// on redessine avec ou sans la miniature, suivant le nouvel etat.
cairo_dock_load_icon_image (icon, CAIRO_CONTAINER (pParentDock));
if (pParentDock)
{
cairo_dock_redraw_icon (icon);
if (pParentDock->iRefCount != 0) // on prevoit le redessin de l'icone pointant sur le sous-dock.
{
cairo_dock_trigger_redraw_subdock_content (pParentDock);
}
}
}
}
return GLDI_NOTIFICATION_LET_PASS;
}
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);
}
