gboolean cd_slider_fade (GldiModuleInstance *myApplet) {
myData.iAnimCNT ++;
myData.fAnimAlpha = 1.*myData.iAnimCNT / myConfig.iNbAnimationStep;
if (myData.fAnimAlpha > 1)
myData.fAnimAlpha = 1;
if (CD_APPLET_MY_CONTAINER_IS_OPENGL)
{
CD_APPLET_START_DRAWING_MY_ICON_OR_RETURN (FALSE);
//Fond précédent.
if (myData.iPrevTexture != 0)
_cd_slider_add_background_to_prev_slide_opengl (myApplet, 0., 0., 1 - myData.fAnimAlpha);
//On empeche la transparence.
_cd_slider_add_background_to_current_slide_opengl (myApplet, 0., 0., myData.fAnimAlpha);
_cairo_dock_set_blend_alpha ();
glEnable (GL_TEXTURE_2D);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
//Image précédente
if (myData.iPrevTexture != 0)
{
_cairo_dock_apply_texture_at_size_with_alpha (myData.iPrevTexture, myData.prevSlideArea.fImgW, myData.prevSlideArea.fImgH, 1 - myData.fAnimAlpha);
}
//Image courante.
_cairo_dock_apply_texture_at_size_with_alpha (myData.iTexture, myData.slideArea.fImgW, myData.slideArea.fImgH, myData.fAnimAlpha);
_cairo_dock_disable_texture ();
CD_APPLET_FINISH_DRAWING_MY_ICON;
}
else
{
CD_APPLET_START_DRAWING_MY_ICON_OR_RETURN_CAIRO (FALSE);
//On efface le fond
///_cd_slider_erase_surface (myApplet);
//Fond précédent.
if (myData.pPrevCairoSurface != NULL)
_cd_slider_add_background_to_prev_slide (myApplet, myData.prevSlideArea.fImgX, myData.prevSlideArea.fImgY, 1 - myData.fAnimAlpha);
//On empeche la transparence.
_cd_slider_add_background_to_current_slide (myApplet, myData.slideArea.fImgX, myData.slideArea.fImgY, myData.fAnimAlpha);
//Image précédente
if (myData.pPrevCairoSurface != NULL) {
cairo_set_source_surface (myDrawContext, myData.pPrevCairoSurface, myData.prevSlideArea.fImgX, myData.prevSlideArea.fImgY);
cairo_paint_with_alpha (myDrawContext, 1 - myData.fAnimAlpha);
}
cairo_set_source_surface (myDrawContext, myData.pCairoSurface, myData.slideArea.fImgX, myData.slideArea.fImgY);
cairo_paint_with_alpha (myDrawContext, myData.fAnimAlpha);
CD_APPLET_FINISH_DRAWING_MY_ICON_CAIRO;
}
return (myData.fAnimAlpha < .99);
}
void cd_slider_draw_default (GldiModuleInstance *myApplet)
{
if (CD_APPLET_MY_CONTAINER_IS_OPENGL)
{
CD_APPLET_START_DRAWING_MY_ICON_OR_RETURN ();
_cd_slider_add_background_to_current_slide_opengl (myApplet, 0., 0., 1.);
_cairo_dock_set_blend_alpha ();
glEnable (GL_TEXTURE_2D);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
_cairo_dock_apply_texture_at_size_with_alpha (myData.iTexture, myData.slideArea.fImgW, myData.slideArea.fImgH, 1.);
_cairo_dock_disable_texture ();
CD_APPLET_FINISH_DRAWING_MY_ICON;
}
else
{
CD_APPLET_START_DRAWING_MY_ICON_OR_RETURN_CAIRO ();
//\______________________ On efface le fond
///_cd_slider_erase_surface (myApplet);
//\______________________ On empeche la transparence
_cd_slider_add_background_to_current_slide (myApplet, myData.slideArea.fImgX, myData.slideArea.fImgY, 1.);
//\______________________ On dessine la nouvelle surface.
cairo_set_source_surface (myDrawContext, myData.pCairoSurface, myData.slideArea.fImgX, myData.slideArea.fImgY);
cairo_paint (myDrawContext);
CD_APPLET_FINISH_DRAWING_MY_ICON_CAIRO;
}
}
static void _render_opengl (GldiContainer *pContainer)
{
double fAlpha;
if (myData.iCloseTime != 0) // animation de fin
fAlpha = (double) myData.iCloseTime / myConfig.iCloseDuration;
else
fAlpha = 1.;
if (myData.pArrowImage->iTexture != 0)
{
double fFrameWidth = myData.pArrowImage->iWidth;
double fFrameHeight = myData.pArrowImage->iHeight;
fFrameWidth = MIN (myData.pArrowImage->iWidth, pContainer->iWidth);
fFrameHeight = MIN (myData.pArrowImage->iHeight, pContainer->iHeight);
/*double fDockOffsetX, fDockOffsetY; // Offset du coin haut gauche du prompt.
fDockOffsetX = (pContainer->iWidth - fFrameWidth) / 2;
fDockOffsetY = (pContainer->iHeight - fFrameHeight) / 2;*/
fAlpha *= _alpha_prompt (myData.iPromptAnimationCount, s_iNbPromptAnimationSteps);
if (fAlpha != 0)
{
glPushMatrix ();
cairo_dock_set_container_orientation_opengl (pContainer);
glTranslatef (pContainer->iWidth/2, pContainer->iHeight/2, 0.);
_cairo_dock_enable_texture ();
_cairo_dock_set_blend_alpha ();
_cairo_dock_apply_texture_at_size_with_alpha (myData.pArrowImage->iTexture, fFrameWidth, fFrameHeight, fAlpha);
_cairo_dock_disable_texture ();
glPopMatrix();
}
}
}
void cd_opengl_scene (CairoDockModuleInstance *myApplet, int iWidth, int iHeight)
{
//g_print ("%s (%d)\n", __func__, myData.iCoverTransition);
_cairo_dock_enable_texture ();
_cairo_dock_set_blend_source ();
// on dessine le cadre.
_cairo_dock_apply_texture_at_size_with_alpha (myData.TextureFrame, iWidth, iHeight, 1.);
// on dessine la couverture.
glPushMatrix ();
glScalef (iWidth, iHeight, 1.);
if (myData.iPrevTextureCover != 0 && myData.iCoverTransition != 0)
{
_cairo_dock_set_blend_over ();
_cairo_dock_set_alpha ((double)myData.iCoverTransition/NB_TRANSITION_STEP);
glBindTexture(GL_TEXTURE_2D, myData.iPrevTextureCover);
glCallList(myData.draw_cover);
}
if (myData.TextureCover != 0)
{
_cairo_dock_set_blend_over ();
_cairo_dock_set_alpha (1.-(double)myData.iCoverTransition/NB_TRANSITION_STEP);
glBindTexture(GL_TEXTURE_2D, myData.TextureCover);
glCallList(myData.draw_cover);
}
glPopMatrix ();
_cairo_dock_set_blend_over ();
// on dessine les boutons qui sont allumes.
if (myData.iButton1Count)
{
glPushMatrix ();
glTranslatef (-iWidth/2 + myData.button1coordX, +iHeight/2 - myData.button1coordY, 0.);
_cairo_dock_apply_texture_at_size_with_alpha (myData.TextureButton1, myData.button1sizeX, myData.button1sizeY, (double)myData.iButton1Count/NB_TRANSITION_STEP);
glPopMatrix ();
}
if (myData.iButton2Count)
{
glPushMatrix ();
glTranslatef (-iWidth/2 + myData.button2coordX, +iHeight/2 - myData.button2coordY, 0.);
_cairo_dock_apply_texture_at_size_with_alpha (myData.TextureButton2, myData.button2sizeX, myData.button2sizeY, (double)myData.iButton2Count/NB_TRANSITION_STEP);
glPopMatrix ();
}
if (myData.iButton3Count)
{
glPushMatrix ();
glTranslatef (-iWidth/2 + myData.button3coordX, +iHeight/2 - myData.button3coordY, 0.);
_cairo_dock_apply_texture_at_size_with_alpha (myData.TextureButton3, myData.button3sizeX, myData.button3sizeY, (double)myData.iButton3Count/NB_TRANSITION_STEP);
glPopMatrix ();
}
if (myData.iButton4Count)
{
glPushMatrix ();
glTranslatef (-iWidth/2 + myData.button4coordX, +iHeight/2 - myData.button4coordY, 0.);
_cairo_dock_apply_texture_at_size_with_alpha (myData.TextureButton4, myData.button4sizeX, myData.button4sizeY, (double)myData.iButton4Count/NB_TRANSITION_STEP);
glPopMatrix ();
}
// on determine la transformation pour les OSD.
// en majuscule : coordonees initiales.
double W = iWidth, H = iHeight;
double X1 = 0, Y1 = 0;
double X2 = W, Y2 = 0;
double X3 = W, Y3 = H;
double X4 = 0, Y4 = H;
// translation du point P1(0;0)
double x1 = myData.ibottomleftX, y1 = myData.ibottomleftY;
double t1x = x1 - X1;
double t1y = y1 - X1;
// translation du point P2(500;0)
double x2 = myData.ibottomrightX, y2 = myData.ibottomrightY;
double t2x = x2 - X2;
double t2y = y2 - Y2;
// translation du point P2(500;500)
double x3 = myData.itoprightX, y3 = myData.itoprightY;
double t3x = x3 - X3;
double t3y = y3 - Y3;
// translation du point P2(0;500)
double x4 = myData.itopleftX, y4 = myData.itopleftY;
double t4x = x4 - X4;
double t4y = y4 - Y4;
double dx1, dy1, dx2, dy2, dx3, dy3, dx4, dy4; // ponderations.
double X, Y; // coordonnees initiales d'un coin de l'OSD.
double u1, v1, u2, v2, u3, v3, u4, v4; // coordonnees finales des coins de l'OSD.
// on dessine les OSD.
//if(myData.bIsRunning && myData.iState != 0)
{
_cairo_dock_set_alpha (1.);
if (myData.mouseOnButton1)
{
if (myData.iPlayingStatus == PLAYER_PLAYING)
{
_draw_osd (myData.TextureOsdPause, myData.osdPausecoordX, myData.osdPausecoordY, myData.osdPausesizeX, myData.osdPausesizeY);
//g_print ("%.1f;%.1f ; %.1f;%.1f ;%.1f;%.1f ;%.1f;%.1f\n", u1, v1, u2, v2,u3,v3,u4,v4);
}
else
{
_draw_osd (myData.TextureOsdPlay, myData.osdPlaycoordX, myData.osdPlaycoordY, myData.osdPlaysizeX, myData.osdPlaysizeY);
//g_print ("%.1f;%.1f ; %.1f;%.1f ;%.1f;%.1f ;%.1f;%.1f\n", u1, v1, u2, v2,u3,v3,u4,v4);
}
}
else if (myData.mouseOnButton2)
{
_draw_osd (myData.TextureOsdPrev, myData.osdPrevcoordX, myData.osdPrevcoordY, myData.osdPrevsizeX, myData.osdPrevsizeY);
}
else if (myData.mouseOnButton3)
{
_draw_osd (myData.TextureOsdNext, myData.osdNextcoordX, myData.osdNextcoordY, myData.osdNextsizeX, myData.osdNextsizeY);
}
else if (myData.mouseOnButton4)
{
_draw_osd (myData.TextureOsdHome, myData.osdHomecoordX, myData.osdHomecoordY, myData.osdHomesizeX, myData.osdHomesizeY);
}
else if (myData.iPlayingStatus != PLAYER_PLAYING)
{
if (myData.bIsRunning) // on verifie que le lecteur est bien ouvert (il se peut qu'il ne nous previenne pas lorsqu'il quitte).
{
cd_musicplayer_dbus_detect_player ();
}
if (myData.bIsRunning) // si rhythmbox n'est pas lancé, on n'affiche pas l'osd de pause ;-)
{
_draw_osd (myData.TextureOsdPause, myData.osdPausecoordX, myData.osdPausecoordY, myData.osdPausesizeX, myData.osdPausesizeY);
}
}
else if (myData.iPlayingStatus == PLAYER_PLAYING && ! myData.cover_exist)
{
_draw_osd (myData.TextureOsdPlay, myData.osdPlaycoordX, myData.osdPlaycoordY, myData.osdPlaysizeX, myData.osdPlaysizeY);
}
}
// on dessine les reflets.
_cairo_dock_set_blend_pbuffer ();
if (myData.TextureReflect != 0)
_cairo_dock_apply_texture_at_size_with_alpha (myData.TextureReflect, iWidth, iHeight, 1.);
_cairo_dock_disable_texture ();
}
gboolean cd_drop_indicator_render (gpointer pUserData, CairoDock *pDock, cairo_t *pCairoContext)
{
CDDropIndicatorData *pData = CD_APPLET_GET_MY_DOCK_DATA (pDock);
if (pData == NULL)
return GLDI_NOTIFICATION_LET_PASS;
if (pCairoContext != NULL)
{
if (pData->fAlpha > 0)
{
cairo_save (pCairoContext);
double fX = pDock->container.iMouseX - myData.dropIndicator.iWidth / 2;
if (pDock->container.bIsHorizontal)
cairo_rectangle (pCairoContext,
(int) pDock->container.iMouseX - myData.dropIndicator.iWidth/2,
(int) (pDock->container.bDirectionUp ? 0 : pDock->iActiveHeight - 2*myData.dropIndicator.iHeight),
(int) myData.dropIndicator.iWidth,
(int) (pDock->container.bDirectionUp ? 2*myData.dropIndicator.iHeight : pDock->iActiveHeight));
else
cairo_rectangle (pCairoContext,
(int) (pDock->container.bDirectionUp ? pDock->container.iHeight - pDock->iActiveHeight : pDock->iActiveHeight - 2*myData.dropIndicator.iHeight),
(int) pDock->container.iMouseX - myData.dropIndicator.iWidth/2,
(int) (pDock->container.bDirectionUp ? 2*myData.dropIndicator.iHeight : pDock->iActiveHeight),
(int) myData.dropIndicator.iWidth);
cairo_clip (pCairoContext);
if (pDock->container.bIsHorizontal)
cairo_translate (pCairoContext, fX, (pDock->container.bDirectionUp ? 0 : pDock->iActiveHeight));
else
cairo_translate (pCairoContext, (pDock->container.bDirectionUp ? 0 : pDock->iActiveHeight), fX);
double fRotationAngle = (pDock->container.bIsHorizontal ? (pDock->container.bDirectionUp ? 0 : G_PI) : (pDock->container.bDirectionUp ? -G_PI/2 : G_PI/2));
cairo_rotate (pCairoContext, fRotationAngle);
cairo_translate (pCairoContext, 0, pData->iDropIndicatorOffset);
cairo_pattern_t* pPattern = cairo_pattern_create_for_surface (myData.dropIndicator.pSurface);
g_return_val_if_fail (cairo_pattern_status (pPattern) == CAIRO_STATUS_SUCCESS, GLDI_NOTIFICATION_LET_PASS);
cairo_pattern_set_extend (pPattern, CAIRO_EXTEND_REPEAT);
cairo_set_source (pCairoContext, pPattern);
cairo_translate (pCairoContext, 0, - pData->iDropIndicatorOffset);
cairo_pattern_t *pGradationPattern = cairo_pattern_create_linear (0.,
0.,
0.,
2*myData.dropIndicator.iHeight); // de haut en bas.
g_return_val_if_fail (cairo_pattern_status (pGradationPattern) == CAIRO_STATUS_SUCCESS, GLDI_NOTIFICATION_LET_PASS);
cairo_pattern_set_extend (pGradationPattern, CAIRO_EXTEND_NONE);
cairo_pattern_add_color_stop_rgba (pGradationPattern,
0.,
0.,
0.,
0.,
0.);
cairo_pattern_add_color_stop_rgba (pGradationPattern,
0.4,
0.,
0.,
0.,
pData->fAlpha);
cairo_pattern_add_color_stop_rgba (pGradationPattern,
0.5,
0.,
0.,
0.,
pData->fAlpha);
cairo_pattern_add_color_stop_rgba (pGradationPattern,
1.,
0.,
0.,
0.,
0.);
cairo_mask (pCairoContext, pGradationPattern);
cairo_pattern_destroy (pPattern);
cairo_pattern_destroy (pGradationPattern);
cairo_restore (pCairoContext);
}
if (pData->fAlphaHover > 0 && myData.hoverIndicator.pSurface != NULL)
{
Icon *pIcon = cairo_dock_get_pointed_icon (pDock->icons);
if (pIcon != NULL && ! CAIRO_DOCK_ICON_TYPE_IS_SEPARATOR (pIcon))
{
cairo_save (pCairoContext);
if (pDock->container.bIsHorizontal)
{
cairo_translate (pCairoContext,
pIcon->fDrawX + 2./3*pIcon->fWidth*pIcon->fScale,
pIcon->fDrawY); // top right corner
cairo_scale (pCairoContext,
pIcon->fWidth*pIcon->fScale/3 / myData.hoverIndicator.iWidth,
pIcon->fHeight*pIcon->fScale/3 / myData.hoverIndicator.iHeight);
}
else
{
cairo_translate (pCairoContext,
pIcon->fDrawY + 2./3*pIcon->fWidth*pIcon->fScale,
pIcon->fDrawX);
cairo_scale (pCairoContext,
pIcon->fHeight*pIcon->fScale/3 / myData.hoverIndicator.iWidth,
pIcon->fWidth*pIcon->fScale/3 / myData.hoverIndicator.iHeight);
}
cairo_set_source_surface (pCairoContext, myData.hoverIndicator.pSurface, 0., 0.);
cairo_paint_with_alpha (pCairoContext, pData->fAlphaHover);
cairo_restore (pCairoContext);
}
}
}
else
{
if (pData->fAlpha > 0)
{
double fX = pDock->container.iMouseX;
double fY = (pDock->container.bDirectionUp ? pDock->iActiveHeight - myData.dropIndicator.iHeight : myData.dropIndicator.iHeight);
glPushMatrix();
glLoadIdentity();
if (pDock->container.bIsHorizontal)
{
fX = pDock->container.iMouseX;
fY = (pDock->container.bDirectionUp ? pDock->iActiveHeight - myData.dropIndicator.iHeight : myData.dropIndicator.iHeight);
glTranslatef (fX, fY, - myData.dropIndicator.iWidth-1.);
if (! pDock->container.bDirectionUp)
glScalef (1., -1., 1.);
}
else
{
fX = pDock->container.iWidth - pDock->container.iMouseX;
fY = (! pDock->container.bDirectionUp ? pDock->iActiveHeight - myData.dropIndicator.iHeight : pDock->container.iHeight - pDock->iActiveHeight + myData.dropIndicator.iHeight);
glTranslatef (fY, fX, - myData.dropIndicator.iWidth-1.);
glRotatef ((pDock->container.bDirectionUp ? 90. : -90.), 0., 0., 1.);
}
glRotatef (pData->iDropIndicatorRotation, 0., 1., 0.);
//\_________________ On decale la texture vers le bas.
glMatrixMode(GL_TEXTURE); // On selectionne la matrice des textures
glPushMatrix();
glLoadIdentity(); // On la reset
glTranslatef(.0, - (double)pData->iDropIndicatorOffset / myData.dropIndicator.iHeight, 0.);
glScalef (1., -2., 1.);
glMatrixMode(GL_MODELVIEW); // On revient sur la matrice d'affichage
//\_________________ On dessine l'indicateur.
glEnable (GL_BLEND);
if (pData->fAlpha != 1)
_cairo_dock_set_blend_alpha ();
else
_cairo_dock_set_blend_over();
//glEnable(GL_DEPTH_TEST);
glScalef (myData.dropIndicator.iWidth, myData.dropIndicator.iHeight, myData.dropIndicator.iWidth);
glColor4f(1.0f, 1.0f, 1.0f, pData->fAlpha);
glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
glEnable(GL_TEXTURE);
glActiveTextureARB(GL_TEXTURE0_ARB); // Go pour le multitexturing 1ere passe
glEnable(GL_TEXTURE_2D); // On active le texturing sur cette passe
glBindTexture(GL_TEXTURE_2D, myData.dropIndicator.iTexture);
glActiveTextureARB(GL_TEXTURE1_ARB); // Go pour le texturing 2eme passe
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, myData.iBilinearGradationTexture);
glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); // Le mode de combinaison des textures
///glTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_ALPHA_EXT, GL_MODULATE); // multiplier les alpha.
//glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_EXT, GL_ONE_MINUS_SRC_ALPHA);
glBegin(GL_QUADS);
glNormal3f(0,0,1);
glMultiTexCoord2fARB( GL_TEXTURE0_ARB,0., 0.); glMultiTexCoord2fARB( GL_TEXTURE1_ARB,0., 0.); glVertex3f(-0.5, -1., 0.); // Bottom Left Of The Texture and Quad
glMultiTexCoord2fARB( GL_TEXTURE0_ARB,1., 0.); glMultiTexCoord2fARB( GL_TEXTURE1_ARB,1., 0.); glVertex3f( 0.5, -1., 0.); // Bottom Right Of The Texture and Quad
glMultiTexCoord2fARB( GL_TEXTURE0_ARB,1., 1.); glMultiTexCoord2fARB( GL_TEXTURE1_ARB,1., 1.); glVertex3f( 0.5, 1., 0.); // Top Right Of The Texture and Quad
glMultiTexCoord2fARB( GL_TEXTURE0_ARB,0., 1.); glMultiTexCoord2fARB( GL_TEXTURE1_ARB,0., 1.); glVertex3f(-0.5, 1., 0.); // Top Left Of The Texture and Quad
glNormal3f(1,0,0);
glMultiTexCoord2fARB( GL_TEXTURE0_ARB,0., 0.); glMultiTexCoord2fARB( GL_TEXTURE1_ARB,0., 0.); glVertex3f(0., -1., -0.5); // Bottom Left Of The Texture and Quad
glMultiTexCoord2fARB( GL_TEXTURE0_ARB,1., 0.); glMultiTexCoord2fARB( GL_TEXTURE1_ARB,1., 0.); glVertex3f(0., -1., 0.5); // Bottom Right Of The Texture and Quad
glMultiTexCoord2fARB( GL_TEXTURE0_ARB,1., 1.); glMultiTexCoord2fARB( GL_TEXTURE1_ARB,1., 1.); glVertex3f(0., 1., 0.5); // Top Right Of The Texture and Quad
glMultiTexCoord2fARB( GL_TEXTURE0_ARB,0., 1.); glMultiTexCoord2fARB( GL_TEXTURE1_ARB,0., 1.); glVertex3f(0., 1., -0.5); // Top Left Of The Texture and Quad
glEnd();
glActiveTextureARB(GL_TEXTURE1_ARB);
glDisable(GL_TEXTURE_2D);
glDisable(GL_TEXTURE_GEN_S);
glDisable(GL_TEXTURE_GEN_T);
glActiveTextureARB(GL_TEXTURE0_ARB);
glDisable(GL_TEXTURE_2D);
glDisable(GL_TEXTURE_GEN_S);
glDisable(GL_TEXTURE_GEN_T);
glDisable (GL_BLEND);
_cairo_dock_set_blend_alpha ();
glPopMatrix();
//\_________________ On remet la matrice des textures.
glMatrixMode(GL_TEXTURE);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
}
if (pData->fAlphaHover > 0 && myData.hoverIndicator.iTexture != 0)
{
Icon *pIcon = cairo_dock_get_pointed_icon (pDock->icons);
if (pIcon != NULL && ! CAIRO_DOCK_ICON_TYPE_IS_SEPARATOR (pIcon))
{
_cairo_dock_enable_texture ();
_cairo_dock_set_blend_alpha ();
glPushMatrix ();
if (pDock->container.bIsHorizontal)
glTranslatef (pIcon->fDrawX + 5./6*pIcon->fWidth*pIcon->fScale,
pDock->iActiveHeight - pIcon->fDrawY - 1./6*pIcon->fHeight*pIcon->fScale,
0.);
else
glTranslatef (pIcon->fDrawY + 5./6*pIcon->fHeight*pIcon->fScale,
pDock->container.iWidth - (pIcon->fDrawX + 1./6*pIcon->fWidth*pIcon->fScale),
0.);
_cairo_dock_apply_texture_at_size_with_alpha (myData.hoverIndicator.iTexture,
myData.hoverIndicator.iWidth,
myData.hoverIndicator.iHeight,
pData->fAlphaHover);
glPopMatrix ();
_cairo_dock_disable_texture ();
}
}
}
return GLDI_NOTIFICATION_LET_PASS;
}
