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 gboolean _render_step_opengl (Icon *pIcon, GldiModuleInstance *myApplet)
{
g_return_val_if_fail (myData.pCurrentImage != NULL, FALSE);
CD_APPLET_ENTER;
double f = CD_APPLET_GET_TRANSITION_FRACTION ();
int iWidth, iHeight;
CD_APPLET_GET_MY_ICON_EXTENT (&iWidth, &iHeight);
_cairo_dock_enable_texture ();
_cairo_dock_set_blend_alpha ();
// image precedente.
if (myData.pOldImage != NULL)
{
_cairo_dock_set_alpha (1. - f);
cairo_dock_apply_image_buffer_texture_with_offset (myData.pOldImage, 0, 0);
}
// image courante.
if (myData.pCurrentImage != NULL)
{
_cairo_dock_set_alpha (f);
cairo_dock_apply_image_buffer_texture_with_offset (myData.pCurrentImage, 0, 0);
}
_cairo_dock_disable_texture ();
CD_APPLET_LEAVE (TRUE);
}
void cd_illusion_draw_black_hole_icon (Icon *pIcon, CairoDock *pDock, CDIllusionData *pData)
{
_cairo_dock_enable_texture ();
_cairo_dock_set_alpha (pIcon->fAlpha);
if (pIcon->fAlpha == 1)
_cairo_dock_set_blend_over ();
else
_cairo_dock_set_blend_alpha ();
glBindTexture(GL_TEXTURE_2D, pIcon->iIconTexture);
glPushMatrix ();
cairo_dock_set_icon_scale (pIcon, pDock, 1.);
glEnableClientState (GL_TEXTURE_COORD_ARRAY);
glEnableClientState (GL_VERTEX_ARRAY);
glTexCoordPointer (2, GL_FLOAT, 2 * sizeof(GLfloat), pData->pBlackHoleCoords);
glVertexPointer (2, GL_FLOAT, 2 * sizeof(GLfloat), pData->pBlackHoleVertices);
glDrawArrays (GL_QUADS, 0, 4 * (SPIRAL_NB_PTS - 1) * (SPIRAL_NB_PTS - 1));
glPopMatrix ();
glDisableClientState (GL_TEXTURE_COORD_ARRAY);
glDisableClientState (GL_VERTEX_ARRAY);
_cairo_dock_disable_texture ();
}
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);
}
static void _apply_desktop_background (GldiContainer *pContainer)
{
if (! g_pFakeTransparencyDesktopBg || g_pFakeTransparencyDesktopBg->iTexture == 0)
return ;
glPushMatrix ();
gboolean bSetPerspective = pContainer->bPerspectiveView;
if (bSetPerspective)
gldi_gl_container_set_ortho_view (pContainer);
glLoadIdentity ();
_cairo_dock_enable_texture ();
_cairo_dock_set_blend_source ();
_cairo_dock_set_alpha (1.);
glBindTexture (GL_TEXTURE_2D, g_pFakeTransparencyDesktopBg->iTexture);
double x, y, w, h, W, H;
W = gldi_desktop_get_width();
H = gldi_desktop_get_height();
if (pContainer->bIsHorizontal)
{
w = pContainer->iWidth;
h = pContainer->iHeight;
x = pContainer->iWindowPositionX;
y = pContainer->iWindowPositionY;
}
else
{
h = pContainer->iWidth;
w = pContainer->iHeight;
y = pContainer->iWindowPositionX;
x = pContainer->iWindowPositionY;
}
glBegin(GL_QUADS);
glTexCoord2f ((x + 0) / W, (y + 0) / H);
glVertex3f (0., h, 0.); // Top Left.
glTexCoord2f ((x + w) / W, (y + 0) / H);
glVertex3f (w, h, 0.); // Top Right
glTexCoord2f ((x + w) / W, (y + h) / H);
glVertex3f (w, 0., 0.); // Bottom Right
glTexCoord2f ((x + 0.) / W, (y + h) / H);
glVertex3f (0., 0., 0.); // Bottom Left
glEnd();
_cairo_dock_disable_texture ();
if (bSetPerspective)
gldi_gl_container_set_perspective_view (pContainer);
glPopMatrix ();
}
void cairo_dock_draw_subdock_content_on_icon (Icon *pIcon, CairoDock *pDock)
{
g_return_if_fail (pIcon != NULL && pIcon->pSubDock != NULL && (pIcon->image.pSurface != NULL || pIcon->image.iTexture != 0));
CairoIconContainerRenderer *pRenderer = cairo_dock_get_icon_container_renderer (pIcon->cClass != NULL ? "Stack" : s_cRendererNames[pIcon->iSubdockViewType]);
if (pRenderer == NULL)
return;
cd_debug ("%s (%s)", __func__, pIcon->cName);
int w, h;
cairo_dock_get_icon_extent (pIcon, &w, &h);
if (pIcon->image.iTexture != 0 && pRenderer->render_opengl) // dessin opengl
{
//\______________ On efface le dessin existant.
if (! cairo_dock_begin_draw_icon (pIcon, 0)) // 0 <=> erase the current texture.
return ;
_cairo_dock_set_blend_alpha ();
_cairo_dock_set_alpha (1.);
_cairo_dock_enable_texture ();
//\______________ On dessine les 3 ou 4 premieres icones du sous-dock.
pRenderer->render_opengl (pIcon, CAIRO_CONTAINER (pDock), w, h);
//\______________ On finit le dessin.
_cairo_dock_disable_texture ();
cairo_dock_end_draw_icon (pIcon);
}
else if (pIcon->image.pSurface != NULL && pRenderer->render != NULL) // dessin cairo
{
//\______________ On efface le dessin existant.
cairo_t *pCairoContext = cairo_dock_begin_draw_icon_cairo (pIcon, 0, NULL); // 0 <=> erase
g_return_if_fail (pCairoContext != NULL);
//\______________ On dessine les 3 ou 4 premieres icones du sous-dock.
pRenderer->render (pIcon, CAIRO_CONTAINER (pDock), w, h, pCairoContext);
//\______________ On finit le dessin.
cairo_dock_end_draw_icon_cairo (pIcon);
cairo_destroy (pCairoContext);
}
}
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();
}
}
}
gboolean cd_xkbd_render_step_opengl (Icon *pIcon, GldiModuleInstance *myApplet)
{
g_return_val_if_fail (myData.pCurrentImage != NULL, FALSE);
CD_APPLET_ENTER;
double f = CD_APPLET_GET_TRANSITION_FRACTION ();
cd_debug ("%s (%.2f; %.2fx%.2f)", __func__, f, myIcon->fWidth, myIcon->fHeight);
int iWidth, iHeight;
CD_APPLET_GET_MY_ICON_EXTENT (&iWidth, &iHeight);
gldi_gl_container_set_perspective_view_for_icon (myIcon);
glScalef (1., -1., 1.);
_cairo_dock_enable_texture ();
_cairo_dock_set_blend_alpha ();
_cairo_dock_set_alpha (1.);
// fond
if (myData.bgImage.iTexture != 0)
cairo_dock_apply_texture_at_size (myData.bgImage.iTexture, iWidth, iHeight);
double fTheta = - 45. + f * 90.; // -45 -> 45
glTranslatef (0., 0., - iWidth * sqrt(2)/2 * cos (fTheta/180.*G_PI)); // pour faire tenir le cube dans la fenetre.
glEnable (GL_DEPTH_TEST);
// image precedente.
int w=0, h;
if (fTheta < 25 && myData.pOldImage != NULL) // inutile de dessiner si elle est derriere l'image courante, par l'effet de perspective (en fait 22.5, mais bizarrement ca a l'air un peu trop tot).
{
w = iWidth * myConfig.fTextRatio; // fill horizontally
h = myData.pOldImage->iHeight * (double)w/myData.pOldImage->iWidth; // keep ratio
if (h > iHeight * myConfig.fTextRatio)
{
w *= iHeight * myConfig.fTextRatio / h;
h = iHeight * myConfig.fTextRatio;
}
glPushMatrix ();
glRotatef (45. + fTheta, 0., 1., 0.); // 0 -> 90
glTranslatef (0., (-iHeight + h)/2, w/2); // H center, V bottom
cairo_dock_apply_texture_at_size (myData.pOldImage->iTexture, w, h);
glPopMatrix ();
}
// image courante a 90deg.
w = iWidth * myConfig.fTextRatio; // fill horizontally
h = myData.pCurrentImage->iHeight * (double)w/myData.pCurrentImage->iWidth; // keep ratio
if (h > iHeight * myConfig.fTextRatio)
{
w *= iHeight * myConfig.fTextRatio / h;
h = iHeight * myConfig.fTextRatio;
}
/**glRotatef (45. + fTheta, 0., 1., 0.); // 0 -> 90
glTranslatef (- (w ? w : iWidth)/2, 0., 0.);
glRotatef (-90., 0., 1., 0.);*/
glRotatef (-45. + fTheta, 0., 1., 0.); // -90 -> 0
glTranslatef (0., (-iHeight + h)/2, w/2); // H center, V bottom
cairo_dock_apply_texture_at_size (myData.pCurrentImage->iTexture, w, h);
glDisable (GL_DEPTH_TEST);
_cairo_dock_disable_texture ();
if (myDock)
{
gldi_gl_container_set_ortho_view (myContainer);
}
CD_APPLET_LEAVE (TRUE);
}
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 ();
}
static void render_opengl (CairoDesklet *pDesklet)
{
static CairoDockGLPath *pPath = NULL;
static const int iNbPoints1Round = 5;
static const int iNbPointsCurve = 15;
CDPanelParameters *pPanel = (CDPanelParameters *) pDesklet->pRendererData;
if (pPanel == NULL)
return ;
// draw frame
double fRadius = pPanel->iRadius;
double fLineWidth = pPanel->iLineWidth;
//double fOffsetX = fRadius + fLineWidth/2;
//double fOffsetY = fLineWidth/2;
double fFrameWidth = pDesklet->container.iWidth - 2 * fRadius - fLineWidth;
double fFrameHeight = pDesklet->container.iHeight - 2 * fRadius - fLineWidth;
double w = fFrameWidth / 2;
double h = fFrameHeight / 2;
double r = fRadius;
if (fLineWidth != 0 && pPanel->fBgColor[3] != 0)
{
if (pPath == NULL)
{
pPath = cairo_dock_new_gl_path (4*iNbPoints1Round+iNbPointsCurve+1, -w, -h, pDesklet->container.iWidth, pDesklet->container.iHeight); // on commence en bas a gauche pour avoir une bonne triangulation du polygone. // 4 corners + 1 curve
}
else
{
cairo_dock_gl_path_move_to (pPath, -w, -h-r);
cairo_dock_gl_path_set_extent (pPath, pDesklet->container.iWidth, pDesklet->container.iHeight);
}
_cairo_dock_disable_texture ();
_cairo_dock_set_blend_alpha ();
cairo_dock_gl_path_arc (pPath, iNbPoints1Round, -w, -h, r, -G_PI/2, -G_PI/2); // coin bas gauche.
cairo_dock_gl_path_arc (pPath, iNbPoints1Round, -w, h, r, -G_PI, -G_PI/2); // coin haut gauche.
cairo_dock_gl_path_rel_curve_to (pPath, iNbPointsCurve,
w, 0,
w, - pPanel->iMainIconSize,
2*w, - pPanel->iMainIconSize);
cairo_dock_gl_path_arc (pPath, iNbPoints1Round, w, h - pPanel->iMainIconSize, r, G_PI/2, -G_PI/2); // coin haut droit.
cairo_dock_gl_path_arc (pPath, iNbPoints1Round, w, -h, r, 0., -G_PI/2); // coin bas droit.
glColor4f (pPanel->fBgColor[0], pPanel->fBgColor[1], pPanel->fBgColor[2], 1.);
glLineWidth (fLineWidth);
cairo_dock_stroke_gl_path (pPath, TRUE);
glColor4f (pPanel->fBgColor[0], pPanel->fBgColor[1], pPanel->fBgColor[2], pPanel->fBgColor[3]);
cairo_dock_fill_gl_path (pPath, 0);
}
glTranslatef (-pDesklet->container.iWidth/2, -pDesklet->container.iHeight/2, 0.);
// draw main icon.
_cairo_dock_enable_texture ();
_cairo_dock_set_blend_alpha ();
_cairo_dock_set_alpha (1.);
Icon *pIcon = pDesklet->pIcon;
if (pIcon && pIcon->image.iTexture != 0 )
{
glPushMatrix ();
glTranslatef (floor (pIcon->fDrawX + pIcon->fWidth/2),
floor (pDesklet->container.iHeight - pIcon->fDrawY - pIcon->fHeight/2),
0.);
_cairo_dock_apply_texture_at_size (pIcon->image.iTexture, pIcon->fWidth, pIcon->fHeight);
/**if (pIcon->iQuickInfoTexture != 0)
{
glPushMatrix ();
double dx = .5 * (pIcon->iQuickInfoWidth & 1); // on decale la texture pour la coller sur la grille des coordonnees entieres.
double dy = .5 * (pIcon->iQuickInfoHeight & 1);
glTranslatef (floor (pIcon->fWidth/2 + pIcon->iQuickInfoWidth/2) + dx, dy, 0.);
_cairo_dock_apply_texture_at_size (pIcon->iQuickInfoTexture,
pIcon->iQuickInfoWidth,
pIcon->iQuickInfoHeight);
glPopMatrix ();
}*/
glTranslatef (floor (pIcon->fWidth),
0.,
0.);
cairo_dock_draw_icon_overlays_opengl (pIcon, pDesklet->container.fRatio);
glPopMatrix ();
}
// draw icons.
GList *pFirstDrawnElement = cairo_dock_get_first_drawn_element_linear (pDesklet->icons);
if (pFirstDrawnElement == NULL)
return;
GList *ic = pFirstDrawnElement;
do
{
pIcon = ic->data;
if (pIcon->image.iTexture != 0 && ! CAIRO_DOCK_ICON_TYPE_IS_SEPARATOR (pIcon))
{
glPushMatrix ();
glTranslatef (floor (pIcon->fDrawX + pIcon->fWidth/2),
floor (pDesklet->container.iHeight - pIcon->fDrawY - pIcon->fHeight/2),
0.);
_cairo_dock_enable_texture (); // cairo_dock_draw_icon_overlays_opengl() disable textures
_cairo_dock_apply_texture_at_size (pIcon->image.iTexture, pIcon->fWidth, pIcon->fHeight);
if (pIcon->label.iTexture != 0)
{
glPushMatrix ();
double dx = .5 * (pIcon->label.iWidth & 1); // on decale la texture pour la coller sur la grille des coordonnees entieres.
double dy = .5 * (pIcon->label.iHeight & 1);
double u0 = 0., u1 = 1.;
double fOffsetX = 0.;
if (pIcon->bPointed)
{
_cairo_dock_set_alpha (1.);
if (pIcon->fDrawX + pIcon->fWidth + pIcon->label.iWidth/2 > pDesklet->container.iWidth)
fOffsetX = pDesklet->container.iWidth - (pIcon->fDrawX + pIcon->fWidth + pIcon->label.iWidth/2);
if (pIcon->fDrawX + pIcon->fWidth - pIcon->label.iWidth/2 < 0)
fOffsetX = pIcon->label.iWidth/2 - (pIcon->fDrawX + pIcon->fWidth);
}
else
{
_cairo_dock_set_alpha (.6);
if (pIcon->label.iWidth > 2*pIcon->fWidth + 2 * myIconsParam.iLabelSize)
{
fOffsetX = 0.;
u1 = (double) (2*pIcon->fWidth + 2 * myIconsParam.iLabelSize) / pIcon->label.iWidth;
}
}
glTranslatef (ceil (-pIcon->fWidth/2 + fOffsetX + pIcon->label.iWidth/2) + dx, ceil (pIcon->fHeight/2 + pIcon->label.iHeight / 2) + dy, 0.);
glBindTexture (GL_TEXTURE_2D, pIcon->label.iTexture);
_cairo_dock_apply_current_texture_portion_at_size_with_offset (u0, 0.,
u1 - u0, 1.,
pIcon->label.iWidth * (u1 - u0), pIcon->label.iHeight,
0., 0.);
_cairo_dock_set_alpha (1.);
glPopMatrix ();
}
/**if (pIcon->iQuickInfoTexture != 0)
{
double dx = .5 * (pIcon->iQuickInfoWidth & 1); // on decale la texture pour la coller sur la grille des coordonnees entieres.
double dy = .5 * (pIcon->iQuickInfoHeight & 1);
glTranslatef (floor (pIcon->fWidth/2 + pIcon->iQuickInfoWidth/2) + dx, dy, 0.);
_cairo_dock_set_alpha (1.);
_cairo_dock_apply_texture_at_size (pIcon->iQuickInfoTexture,
pIcon->iQuickInfoWidth,
pIcon->iQuickInfoHeight);
}*/
cairo_dock_draw_icon_overlays_opengl (pIcon, pDesklet->container.fRatio);
glPopMatrix ();
}
ic = cairo_dock_get_next_element (ic, pDesklet->icons);
} while (ic != pFirstDrawnElement);
_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;
}
static void _render_desklet_opengl (CairoDesklet *pDesklet)
{
gboolean bUseDefaultColors = pDesklet->bUseDefaultColors;
glPushMatrix ();
///glTranslatef (0*pDesklet->container.iWidth/2, 0*pDesklet->container.iHeight/2, 0.); // avec une perspective ortho.
///glTranslatef (0*pDesklet->container.iWidth/2, 0*pDesklet->container.iHeight/2, -pDesklet->container.iWidth*(1.87 +.35*fabs (sin(pDesklet->fDepthRotationY)))); // avec 30 deg de perspective
_set_desklet_matrix (pDesklet);
if (bUseDefaultColors)
{
_cairo_dock_set_blend_alpha ();
gldi_style_colors_set_bg_color (NULL);
cairo_dock_draw_rounded_rectangle_opengl (pDesklet->container.iWidth - 2 * (myStyleParam.iCornerRadius + myStyleParam.iLineWidth), pDesklet->container.iHeight - 2*myStyleParam.iLineWidth, myStyleParam.iCornerRadius, 0, NULL);
gldi_style_colors_set_line_color (NULL);
cairo_dock_draw_rounded_rectangle_opengl (pDesklet->container.iWidth - 2 * (myStyleParam.iCornerRadius + myStyleParam.iLineWidth), pDesklet->container.iHeight - 2*myStyleParam.iLineWidth, myStyleParam.iCornerRadius, myStyleParam.iLineWidth, NULL);
}
_cairo_dock_enable_texture ();
_cairo_dock_set_blend_pbuffer ();
_cairo_dock_set_alpha (1.);
if (pDesklet->backGroundImageBuffer.iTexture != 0)
{
cairo_dock_apply_image_buffer_texture (&pDesklet->backGroundImageBuffer);
}
glPushMatrix ();
if (pDesklet->iLeftSurfaceOffset != 0 || pDesklet->iTopSurfaceOffset != 0 || pDesklet->iRightSurfaceOffset != 0 || pDesklet->iBottomSurfaceOffset != 0)
{
glTranslatef ((pDesklet->iLeftSurfaceOffset - pDesklet->iRightSurfaceOffset)/2, (pDesklet->iBottomSurfaceOffset - pDesklet->iTopSurfaceOffset)/2, 0.);
glScalef (1. - (double)(pDesklet->iLeftSurfaceOffset + pDesklet->iRightSurfaceOffset) / pDesklet->container.iWidth,
1. - (double)(pDesklet->iTopSurfaceOffset + pDesklet->iBottomSurfaceOffset) / pDesklet->container.iHeight,
1.);
}
if (pDesklet->pRenderer != NULL && pDesklet->pRenderer->render_opengl != NULL) // un moteur de rendu specifique a ete fourni.
{
pDesklet->pRenderer->render_opengl (pDesklet);
}
glPopMatrix ();
_cairo_dock_enable_texture ();
_cairo_dock_set_blend_pbuffer ();
if (pDesklet->foreGroundImageBuffer.iTexture != 0)
{
cairo_dock_apply_image_buffer_texture (&pDesklet->foreGroundImageBuffer);
}
//if (pDesklet->container.bInside && cairo_dock_desklet_is_free (pDesklet))
{
if (! pDesklet->rotating && ! pDesklet->rotatingY && ! pDesklet->rotatingX)
{
glPopMatrix ();
glPushMatrix ();
glTranslatef (0., 0., -pDesklet->container.iHeight*(sqrt(3)/2));
}
}
if ((pDesklet->container.bInside || pDesklet->fButtonsAlpha != 0 || pDesklet->rotating || pDesklet->rotatingY || pDesklet->rotatingX) && cairo_dock_desklet_is_free (pDesklet))
{
_cairo_dock_set_blend_alpha ();
_cairo_dock_set_alpha (sqrt(pDesklet->fButtonsAlpha));
if (s_pRotateButtonBuffer.iTexture != 0)
{
cairo_dock_apply_image_buffer_texture_with_offset (&s_pRotateButtonBuffer,
-pDesklet->container.iWidth/2 + s_pRotateButtonBuffer.iWidth/2,
pDesklet->container.iHeight/2 - s_pRotateButtonBuffer.iHeight/2);
}
if (s_pRetachButtonBuffer.iTexture != 0 && g_pMainDock)
{
cairo_dock_apply_image_buffer_texture_with_offset (&s_pRetachButtonBuffer,
pDesklet->container.iWidth/2 - s_pRetachButtonBuffer.iWidth/2,
pDesklet->container.iHeight/2 - s_pRetachButtonBuffer.iHeight/2);
}
if (s_pDepthRotateButtonBuffer.iTexture != 0)
{
cairo_dock_apply_image_buffer_texture_with_offset (&s_pDepthRotateButtonBuffer,
0.,
pDesklet->container.iHeight/2 - s_pDepthRotateButtonBuffer.iHeight/2);
glPushMatrix ();
glRotatef (90., 0., 0., 1.);
cairo_dock_apply_image_buffer_texture_with_offset (&s_pDepthRotateButtonBuffer,
0.,
pDesklet->container.iWidth/2 - s_pDepthRotateButtonBuffer.iHeight/2);
glPopMatrix ();
}
}
if ((pDesklet->container.bInside || pDesklet->fButtonsAlpha != 0 || pDesklet->bNoInput) && s_pNoInputButtonBuffer.iTexture != 0 && pDesklet->bAllowNoClickable)
{
_cairo_dock_set_blend_alpha ();
_cairo_dock_set_alpha (_no_input_button_alpha(pDesklet));
cairo_dock_apply_image_buffer_texture_with_offset (&s_pNoInputButtonBuffer,
pDesklet->container.iWidth/2 - s_pNoInputButtonBuffer.iWidth/2,
- pDesklet->container.iHeight/2 + s_pNoInputButtonBuffer.iHeight/2);
}
_cairo_dock_disable_texture ();
glPopMatrix ();
}
static void render_opengl (CairoDesklet *pDesklet)
{
CDSlideParameters *pSlide = (CDSlideParameters *) pDesklet->pRendererData;
if (pSlide == NULL)
return ;
// le cadre.
double fRadius = (pSlide->bRoundedRadius ? pSlide->iRadius : 0.);
double fLineWidth = pSlide->iLineWidth;
if (fLineWidth != 0 && pSlide->fLineColor[3] != 0)
{
cairo_dock_draw_rounded_rectangle_opengl (pDesklet->container.iWidth - 2 * fRadius,
pDesklet->container.iHeight,
fRadius,
fLineWidth,
pSlide->fLineColor);
}
glTranslatef (-pDesklet->container.iWidth/2, -pDesklet->container.iHeight/2, 0.);
// les icones.
double w = pDesklet->container.iWidth - 2 * pSlide->fMargin;
double h = pDesklet->container.iHeight - 2 * pSlide->fMargin;
int dh = (h - pSlide->iNbLines * (pSlide->iIconSize + myIconsParam.iLabelSize)) / (pSlide->iNbLines != 1 ? pSlide->iNbLines - 1 : 1); // ecart entre 2 lignes.
int dw = (w - pSlide->iNbColumns * pSlide->iIconSize) / pSlide->iNbColumns; // ecart entre 2 colonnes.
_cairo_dock_enable_texture ();
_cairo_dock_set_blend_alpha ();
_cairo_dock_set_alpha (1.);
double x = pSlide->fMargin + dw/2, y = pSlide->fMargin + myIconsParam.iLabelSize;
int q = 0;
Icon *pIcon;
GList *ic;
for (ic = pDesklet->icons; ic != NULL; ic = ic->next)
{
pIcon = ic->data;
if (CAIRO_DOCK_ICON_TYPE_IS_SEPARATOR (pIcon))
continue;
pIcon->fDrawX = x;
pIcon->fDrawY = y;
x += pSlide->iIconSize + dw;
q ++;
if (q == pSlide->iNbColumns)
{
q = 0;
x = pSlide->fMargin + dw/2;
y += pSlide->iIconSize + myIconsParam.iLabelSize + dh;
}
}
GList *pFirstDrawnElement = cairo_dock_get_first_drawn_element_linear (pDesklet->icons);
if (pFirstDrawnElement == NULL)
return;
ic = pFirstDrawnElement;
do
{
pIcon = ic->data;
if (pIcon->image.iTexture != 0 && ! CAIRO_DOCK_ICON_TYPE_IS_SEPARATOR (pIcon))
{
glPushMatrix ();
glTranslatef (pIcon->fDrawX + pIcon->fWidth/2,
pDesklet->container.iHeight - pIcon->fDrawY - pIcon->fHeight/2,
0.);
_cairo_dock_enable_texture (); // cairo_dock_draw_icon_overlays_opengl() disable textures
_cairo_dock_apply_texture_at_size (pIcon->image.iTexture, pIcon->fWidth, pIcon->fHeight);
/// generer une notification ...
/*if (pIcon->bHasIndicator && g_pIndicatorBuffer.iTexture != 0)
{
glPushMatrix ();
glTranslatef (0., - pIcon->fHeight/2 + g_pIndicatorBuffer.iHeight/2 * pIcon->fWidth / g_pIndicatorBuffer.iWidth, 0.);
_cairo_dock_apply_texture_at_size (g_pIndicatorBuffer.iTexture, pIcon->fWidth, g_pIndicatorBuffer.iHeight * pIcon->fWidth / g_pIndicatorBuffer.iWidth);
glPopMatrix ();
}*/
if (pIcon->label.iTexture != 0)
{
glPushMatrix ();
double dx = .5 * (pIcon->label.iWidth & 1); // on decale la texture pour la coller sur la grille des coordonnees entieres.
double dy = .5 * (pIcon->label.iHeight & 1);
double u0 = 0., u1 = 1.;
double fOffsetX = 0.;
if (pIcon->bPointed)
{
_cairo_dock_set_alpha (1.);
if (pIcon->fDrawX + pIcon->fWidth/2 + pIcon->label.iWidth/2 > pDesklet->container.iWidth)
fOffsetX = pDesklet->container.iWidth - (pIcon->fDrawX + pIcon->fWidth/2 + pIcon->label.iWidth/2);
if (pIcon->fDrawX + pIcon->fWidth/2 - pIcon->label.iWidth/2 < 0)
fOffsetX = pIcon->label.iWidth/2 - (pIcon->fDrawX + pIcon->fWidth/2);
}
else
{
_cairo_dock_set_alpha (.6);
if (pIcon->label.iWidth > pIcon->fWidth + 2 * myIconsParam.iLabelSize)
{
fOffsetX = 0.;
u1 = (double) (pIcon->fWidth + 2 * myIconsParam.iLabelSize) / pIcon->label.iWidth;
}
}
glTranslatef (ceil (fOffsetX) + dx, ceil (pIcon->fHeight/2 + pIcon->label.iHeight / 2) + dy, 0.);
glBindTexture (GL_TEXTURE_2D, pIcon->label.iTexture);
_cairo_dock_apply_current_texture_portion_at_size_with_offset (u0, 0.,
u1 - u0, 1.,
pIcon->label.iWidth * (u1 - u0), pIcon->label.iHeight,
0., 0.);
_cairo_dock_set_alpha (1.);
glPopMatrix ();
}
cairo_dock_draw_icon_overlays_opengl (pIcon, pDesklet->container.fRatio);
glPopMatrix ();
}
ic = cairo_dock_get_next_element (ic, pDesklet->icons);
} while (ic != pFirstDrawnElement);
_cairo_dock_disable_texture ();
}
void rendering_draw_slide_in_desklet_opengl (CairoDesklet *pDesklet)
{
_cairo_dock_define_static_vertex_tab (7);
CDSlideParameters *pSlide = (CDSlideParameters *) pDesklet->pRendererData;
if (pSlide == NULL)
return ;
// le cadre.
double fRadius = pSlide->iRadius;
double fLineWidth = pSlide->iLineWidth;
if (fLineWidth != 0 && pSlide->fLineColor[3] != 0)
{
if (pSlide->bRoundedRadius)
{
cairo_dock_draw_rounded_rectangle_opengl (fRadius,
fLineWidth,
pDesklet->iWidth - 2 * fRadius,
pDesklet->iHeight,
0., 0.,
pSlide->fLineColor);
glTranslatef (-pDesklet->iWidth/2, -pDesklet->iHeight/2, 0.);
}
else
{
int i = 0;
_cairo_dock_set_vertex_xy (0, -pDesklet->iWidth/2, +pDesklet->iHeight/2);
_cairo_dock_set_vertex_xy (1, -pDesklet->iWidth/2, -pDesklet->iHeight/2 + fRadius);
_cairo_dock_set_vertex_xy (2, -pDesklet->iWidth/2 + fRadius, -pDesklet->iHeight/2);
_cairo_dock_set_vertex_xy (3, +pDesklet->iWidth/2, -pDesklet->iHeight/2);
_cairo_dock_set_path_as_current ();
cairo_dock_draw_current_path_opengl (fLineWidth, pSlide->fLineColor, 4);
}
}
glTranslatef (-pDesklet->iWidth/2, -pDesklet->iHeight/2, 0.);
// les icones.
double w = pDesklet->iWidth - 2 * pSlide->fMargin;
double h = pDesklet->iHeight - 2 * pSlide->fMargin;
int dh = (h - pSlide->iNbLines * (pSlide->iIconSize + myLabels.iLabelSize)) / (pSlide->iNbLines != 1 ? pSlide->iNbLines - 1 : 1); // ecart entre 2 lignes.
int dw = (w - pSlide->iNbColumns * pSlide->iIconSize) / pSlide->iNbColumns; // ecart entre 2 colonnes.
_cairo_dock_enable_texture ();
_cairo_dock_set_blend_alpha ();
_cairo_dock_set_alpha (1.);
double x = pSlide->fMargin + dw/2, y = pSlide->fMargin + myLabels.iLabelSize;
int q = 0;
Icon *pIcon;
GList *ic;
for (ic = pDesklet->icons; ic != NULL; ic = ic->next)
{
pIcon = ic->data;
pIcon->fDrawX = x;
pIcon->fDrawY = y;
x += pSlide->iIconSize + dw;
q ++;
if (q == pSlide->iNbColumns)
{
q = 0;
x = pSlide->fMargin + dw/2;
y += pSlide->iIconSize + myLabels.iLabelSize + dh;
}
}
GList *pFirstDrawnElement = cairo_dock_get_first_drawn_element_linear (pDesklet->icons);
if (pFirstDrawnElement == NULL)
return;
ic = pFirstDrawnElement;
do
{
pIcon = ic->data;
if (pIcon->iIconTexture != 0)
{
glPushMatrix ();
glTranslatef (pIcon->fDrawX + pIcon->fWidth/2,
pDesklet->iHeight - pIcon->fDrawY - pIcon->fHeight/2,
0.);
//g_print (" %d) %d;%d %dx%d\n", pIcon->iIconTexture, (int)(pIcon->fDrawX + pIcon->fWidth/2), (int)(pDesklet->iHeight - pIcon->fDrawY - pIcon->fHeight/2), (int)(pIcon->fWidth/2), (int)(pIcon->fHeight/2));
_cairo_dock_apply_texture_at_size (pIcon->iIconTexture, pIcon->fWidth, pIcon->fHeight);
if (pIcon->bHasIndicator && g_iIndicatorTexture != 0)
{
glPushMatrix ();
glTranslatef (0., - pIcon->fHeight/2 + g_fIndicatorHeight/2 * pIcon->fWidth / g_fIndicatorWidth, 0.);
_cairo_dock_apply_texture_at_size (g_iIndicatorTexture, pIcon->fWidth, g_fIndicatorHeight * pIcon->fWidth / g_fIndicatorWidth);
glPopMatrix ();
}
if (pIcon->iLabelTexture != 0)
{
glPushMatrix ();
double u0 = 0., u1 = 1.;
double fOffsetX = 0.;
if (pIcon->bPointed)
{
_cairo_dock_set_alpha (1.);
if (pIcon->fDrawX + pIcon->fWidth/2 + pIcon->iTextWidth/2 > pDesklet->iWidth)
fOffsetX = pDesklet->iWidth - (pIcon->fDrawX + pIcon->fWidth/2 + pIcon->iTextWidth/2);
if (pIcon->fDrawX + pIcon->fWidth/2 - pIcon->iTextWidth/2 < 0)
fOffsetX = pIcon->iTextWidth/2 - (pIcon->fDrawX + pIcon->fWidth/2);
}
else
{
_cairo_dock_set_alpha (.6);
if (pIcon->iTextWidth > pIcon->fWidth + 2 * myLabels.iLabelSize)
{
fOffsetX = 0.;
u1 = (double) (pIcon->fWidth + 2 * myLabels.iLabelSize) / pIcon->iTextWidth;
}
}
glTranslatef (fOffsetX, pIcon->fHeight/2 + pIcon->iTextHeight / 2, 0.);
glBindTexture (GL_TEXTURE_2D, pIcon->iLabelTexture);
_cairo_dock_apply_current_texture_portion_at_size_with_offset (u0, 0.,
u1 - u0, 1.,
pIcon->iTextWidth * (u1 - u0), pIcon->iTextHeight,
0., 0.);
_cairo_dock_set_alpha (1.);
glPopMatrix ();
}
if (pIcon->iQuickInfoTexture != 0)
{
glTranslatef (0., (- pIcon->fHeight + pIcon->iQuickInfoHeight)/2, 0.);
_cairo_dock_apply_texture_at_size (pIcon->iQuickInfoTexture,
pIcon->iQuickInfoWidth,
pIcon->iQuickInfoHeight);
}
glPopMatrix ();
}
ic = cairo_dock_get_next_element (ic, pDesklet->icons);
} while (ic != pFirstDrawnElement);
_cairo_dock_disable_texture ();
}
void cairo_dock_render_overlays_to_texture (CairoDataRenderer *pRenderer, int iNumValue)
{
gint iWidth = pRenderer->iWidth, iHeight = pRenderer->iHeight;
cairo_data_renderer_get_size (pRenderer, &iWidth, &iHeight);
glPushMatrix ();
if (pRenderer->bisRotate)
glRotatef (90., 0., 0., 1.);
if (pRenderer->pEmblems != NULL)
{
_cairo_dock_enable_texture ();
_cairo_dock_set_blend_over ();
CairoDataRendererEmblem *pEmblem;
pEmblem = &pRenderer->pEmblems[iNumValue];
if (pEmblem->iTexture != 0)
{
glBindTexture (GL_TEXTURE_2D, pEmblem->iTexture);
_cairo_dock_set_alpha (pEmblem->param.fAlpha);
_cairo_dock_apply_current_texture_at_size_with_offset (
pEmblem->param.fWidth * iWidth,
pEmblem->param.fHeight * iHeight,
pEmblem->param.fX * iWidth,
pEmblem->param.fY * iHeight);
}
_cairo_dock_disable_texture ();
}
if (pRenderer->pLabels != NULL)
{
_cairo_dock_enable_texture ();
_cairo_dock_set_blend_pbuffer (); // rend mieux pour les textes
CairoDataRendererText *pLabel;
int w, h, dw, dh;
pLabel = &pRenderer->pLabels[iNumValue];
if (pLabel->iTexture != 0)
{
double f = MIN (pLabel->param.fWidth * iWidth / pLabel->iTextWidth, pLabel->param.fHeight * iHeight / pLabel->iTextHeight); // on garde le ratio du texte.
w = pLabel->iTextWidth * f;
h = pLabel->iTextHeight * f;
dw = w & 1;
dh = h & 1;
glBindTexture (GL_TEXTURE_2D, pLabel->iTexture);
_cairo_dock_set_alpha (pLabel->param.pColor[3]);
_cairo_dock_apply_current_texture_at_size_with_offset (
w + dw,
h + dh,
pLabel->param.fX * iWidth,
pLabel->param.fY * iHeight);
}
_cairo_dock_disable_texture ();
}
if (pRenderer->bWriteValues && pRenderer->bCanRenderValueAsText)
{
CairoDataRendererTextParam *pText;
pText = &pRenderer->pValuesText[iNumValue];
if (pText->fWidth != 0 && pText->fHeight != 0)
{
cairo_data_renderer_format_value (pRenderer, iNumValue);
CairoDockGLFont *pFont = cairo_dock_get_default_data_renderer_font ();
glColor3f (pText->pColor[0], pText->pColor[1], pText->pColor[2]);
glPushMatrix ();
int w = pText->fWidth * pRenderer->iWidth;
int h = pText->fHeight * pRenderer->iHeight;
int dw = w & 1;
int dh = h & 1;
cairo_dock_draw_gl_text_at_position_in_area ((guchar *) pRenderer->cFormatBuffer,
pFont,
floor (pText->fX * iWidth) + .5*dw,
floor (pText->fY * iHeight) + .5*dh,
w,
h,
TRUE);
glPopMatrix ();
glColor3f (1.0, 1.0, 1.0);
}
}
glPopMatrix ();
}
gboolean cd_slider_diaporama (GldiModuleInstance *myApplet) {
static double a = .75;
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);
gldi_gl_container_set_perspective_view_for_icon (myIcon);
glScalef (1., -1., 1.);
if (myData.iPrevTexture != 0 && myData.fAnimAlpha < a)
{
glPushMatrix ();
glTranslatef (-myData.iSurfaceWidth/2, 0., 0.);
glRotatef (120. * (myData.fAnimAlpha/a), 0., 1., 0.);
glTranslatef (myData.iSurfaceWidth/2, 0., 0.);
//On empeche la transparence
_cd_slider_add_background_to_prev_slide_opengl (myApplet, 0., 0., 1.);
//Image
_cairo_dock_enable_texture ();
_cairo_dock_set_blend_alpha ();
_cairo_dock_set_alpha (1.);
cairo_dock_apply_texture_at_size (myData.iPrevTexture, myData.prevSlideArea.fImgW, myData.prevSlideArea.fImgH);
glPopMatrix ();
}
if (myData.fAnimAlpha > 1-a)
{
glTranslatef (myData.iSurfaceWidth/2, 0., 0.);
glRotatef (-120. * (1-myData.fAnimAlpha)/a, 0., 1., 0.);
glTranslatef (-myData.iSurfaceWidth/2, 0., 0.);
//On empeche la transparence
_cd_slider_add_background_to_current_slide_opengl (myApplet, 0., 0., 1.);
//Image
_cairo_dock_enable_texture ();
_cairo_dock_set_blend_alpha ();
_cairo_dock_set_alpha (1.);
glColor4f (1., 1., 1., 1.);
cairo_dock_apply_texture_at_size (myData.iTexture, myData.slideArea.fImgW, myData.slideArea.fImgH);
}
_cairo_dock_disable_texture ();
CD_APPLET_FINISH_DRAWING_MY_ICON;
if (myDock)
gldi_gl_container_set_ortho_view (myContainer);
}
else
{
CD_APPLET_START_DRAWING_MY_ICON_OR_RETURN_CAIRO (FALSE);
//On efface le fond
///_cd_slider_erase_surface (myApplet);
//Image précédante
if (myData.pPrevCairoSurface != NULL)
{
_cd_slider_add_background_to_prev_slide (myApplet, myData.prevSlideArea.fImgX - myData.fAnimAlpha * myData.iSurfaceWidth, myData.prevSlideArea.fImgY, 1.);
cairo_set_source_surface (myDrawContext, myData.pPrevCairoSurface, myData.prevSlideArea.fImgX - myData.fAnimAlpha * myData.iSurfaceWidth, myData.prevSlideArea.fImgY);
cairo_paint(myDrawContext);
}
//Image courante.
_cd_slider_add_background_to_current_slide (myApplet, myData.slideArea.fImgX + myData.iSurfaceWidth * (1 - myData.fAnimAlpha), myData.slideArea.fImgY, 1.);
cairo_set_source_surface (myDrawContext, myData.pCairoSurface, myData.slideArea.fImgX + myData.iSurfaceWidth * (1 - myData.fAnimAlpha), myData.slideArea.fImgY);
cairo_paint(myDrawContext);
CD_APPLET_FINISH_DRAWING_MY_ICON_CAIRO;
}
return (myData.fAnimAlpha < .999);
}
static gboolean _on_render_flying_container_notification (G_GNUC_UNUSED gpointer pUserData, CairoFlyingContainer *pFlyingContainer, cairo_t *pCairoContext)
{
Icon *pIcon = pFlyingContainer->pIcon;
if (pCairoContext != NULL)
{
if (pIcon != NULL)
{
cairo_save (pCairoContext);
cairo_translate (pCairoContext, pIcon->fDrawX, pIcon->fDrawY);
if (pIcon->image.pSurface != NULL) // we can't use cairo_dock_render_one_icon() here since it's not a dock, and anyway we don't need it.
{
cairo_save (pCairoContext);
cairo_dock_set_icon_scale_on_context (pCairoContext, pIcon, pFlyingContainer->container.bIsHorizontal, pFlyingContainer->container.fRatio, pFlyingContainer->container.bDirectionUp);
cairo_set_source_surface (pCairoContext, pIcon->image.pSurface, 0.0, 0.0);
cairo_paint (pCairoContext);
cairo_restore (pCairoContext);
}
cairo_restore (pCairoContext);
if (s_pEmblem)
{
cairo_dock_apply_image_buffer_surface (s_pEmblem, pCairoContext);
}
}
else
{
cairo_dock_apply_image_buffer_surface_with_offset (s_pExplosion, pCairoContext,
(pFlyingContainer->container.iWidth - s_pExplosion->iWidth / s_pExplosion->iNbFrames) / 2,
(pFlyingContainer->container.iHeight - s_pExplosion->iHeight) / 2,
1.);
}
}
else
{
if (pIcon != NULL)
{
glPushMatrix ();
cairo_dock_translate_on_icon_opengl (pIcon, CAIRO_CONTAINER (pFlyingContainer), 1.);
cairo_dock_draw_icon_texture (pIcon, CAIRO_CONTAINER (pFlyingContainer));
glPopMatrix ();
_cairo_dock_enable_texture ();
_cairo_dock_set_blend_alpha ();
if (s_pEmblem && s_pEmblem->iTexture != 0)
{
cairo_dock_apply_image_buffer_texture_with_offset (s_pEmblem, s_pEmblem->iWidth/2, pFlyingContainer->container.iHeight - s_pEmblem->iHeight/2);
}
_cairo_dock_disable_texture ();
}
else
{
_cairo_dock_enable_texture ();
cairo_dock_apply_image_buffer_texture_with_offset (s_pExplosion,
pFlyingContainer->container.iWidth/2,
pFlyingContainer->container.iHeight/2);
_cairo_dock_disable_texture ();
}
}
return GLDI_NOTIFICATION_LET_PASS;
}
static void render_opengl (ProgressBar *pProgressBar)
{
g_return_if_fail (pProgressBar != NULL);
CairoDataRenderer *pRenderer = CAIRO_DATA_RENDERER (pProgressBar);
int iNbValues = cairo_data_renderer_get_nb_values (pRenderer);
int iWidth = pRenderer->iWidth;
double x, y, v, w, r = pProgressBar->iBarThickness/2.;
double dx = .5; // required to not have sharp edges on the left rounded corners... although maybe it should be adressed by the Overlay...
int i;
for (i = 0; i < iNbValues; i ++)
{
v = cairo_data_renderer_get_normalized_current_value_with_latency (pRenderer, i);
w = iWidth - pProgressBar->iBarThickness;
x = - iWidth / 2. + w * v/2 + r + dx; // center of the bar; the bar is left-aligned.
y = i * pProgressBar->iBarThickness; // first value at bottom.
if (v > 0 && v <= 1) // any negative value is an "undef" value
{
// make a rounded rectangle path.
const CairoDockGLPath *pFramePath = cairo_dock_generate_rectangle_path (w * v, 2*r, r, TRUE);
// bind the texture to the path
// we don't use the automatic coords generation because we want to bind the texture to the interval [0; v].
glColor4f (1., 1., 1., 1.);
_cairo_dock_set_blend_source (); // doesn't really matter here.
_cairo_dock_enable_texture ();
glBindTexture (GL_TEXTURE_2D, pProgressBar->iBarTexture);
GLfloat *pCoords = g_new0 (GLfloat, (pFramePath->iNbPoints+1) * _CD_PATH_DIM);
int i;
for (i = 0; i < pFramePath->iCurrentPt; i ++)
{
pCoords[_CD_PATH_DIM*i] = (.5 + _cd_gl_path_get_nth_vertex_x (pFramePath, i) / (w*v+2*r)) * v; // [0;v]
pCoords[_CD_PATH_DIM*i+1] = .5 + _cd_gl_path_get_nth_vertex_y (pFramePath, i) / (pProgressBar->iBarThickness);
}
glEnableClientState (GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer (_CD_PATH_DIM, GL_FLOAT, 0, pCoords);
// draw the path.
glPushMatrix ();
glTranslatef (x,
y,
0.);
cairo_dock_fill_gl_path (pFramePath, 0); // 0 <=> no texture, since we bound it ourselves.
_cairo_dock_disable_texture ();
glDisableClientState (GL_TEXTURE_COORD_ARRAY);
// outline
if (myIndicatorsParam.bBarUseDefaultColors || myIndicatorsParam.fBarColorOutline.rgba.alpha != 0.)
{
if (myIndicatorsParam.bBarUseDefaultColors)
gldi_style_colors_set_line_color (NULL);
else
gldi_color_set_opengl (&myIndicatorsParam.fBarColorOutline);
_cairo_dock_set_blend_alpha ();
glLineWidth (1.5);
cairo_dock_stroke_gl_path (pFramePath, FALSE);
}
g_free (pCoords);
glPopMatrix ();
}
}
}