static gboolean
swatch_draw (GtkWidget *widget,
cairo_t *cr)
{
GtkColorSwatch *swatch = (GtkColorSwatch*)widget;
gdouble width, height;
GtkStyleContext *context;
GtkStateFlags state;
GtkIconTheme *theme;
GtkBorder border, padding;
GdkRectangle rect;
GtkIconInfo *icon_info = NULL;
gint scale;
theme = gtk_icon_theme_get_default ();
context = gtk_widget_get_style_context (widget);
state = gtk_style_context_get_state (context);
width = gtk_widget_get_allocated_width (widget);
height = gtk_widget_get_allocated_height (widget);
gtk_render_background (context, cr, 0, 0, width, height);
if (swatch->priv->has_color)
{
cairo_pattern_t *pattern;
cairo_matrix_t matrix;
gtk_render_content_path (context, cr, 0, 0, width, height);
if (swatch->priv->use_alpha)
{
cairo_save (cr);
cairo_clip_preserve (cr);
cairo_set_source_rgb (cr, 0.33, 0.33, 0.33);
cairo_fill_preserve (cr);
pattern = _gtk_color_chooser_get_checkered_pattern ();
cairo_matrix_init_scale (&matrix, 0.125, 0.125);
cairo_pattern_set_matrix (pattern, &matrix);
cairo_set_source_rgb (cr, 0.66, 0.66, 0.66);
cairo_mask (cr, pattern);
cairo_pattern_destroy (pattern);
cairo_restore (cr);
gdk_cairo_set_source_rgba (cr, &swatch->priv->color);
}
else
{
cairo_set_source_rgb (cr,
swatch->priv->color.red,
swatch->priv->color.green,
swatch->priv->color.blue);
}
cairo_fill (cr);
}
gtk_render_frame (context, cr, 0, 0, width, height);
scale = gtk_widget_get_scale_factor (widget);
if (swatch->priv->icon)
{
icon_info = gtk_icon_theme_lookup_icon_for_scale (theme, swatch->priv->icon, PIXBUF_SIZE,
scale,
GTK_ICON_LOOKUP_GENERIC_FALLBACK
| GTK_ICON_LOOKUP_USE_BUILTIN);
}
else if ((state & GTK_STATE_FLAG_SELECTED) != 0)
{
GIcon *gicon;
gicon = g_themed_icon_new ("object-select-symbolic");
/* fallback for themes that don't have object-select-symbolic */
g_themed_icon_append_name (G_THEMED_ICON (gicon), "gtk-apply");
icon_info = gtk_icon_theme_lookup_by_gicon_for_scale (theme, gicon, PIXBUF_SIZE,
scale,
GTK_ICON_LOOKUP_GENERIC_FALLBACK
| GTK_ICON_LOOKUP_USE_BUILTIN);
g_object_unref (gicon);
}
/* now draw the overlay image */
gtk_style_context_get_border (context, state, &border);
gtk_style_context_get_padding (context, state, &padding);
rect.width = width - (border.left + border.right + padding.left + padding.right);
rect.height = height - (border.top + border.bottom + padding.top + padding.bottom);
rect.x = border.left + padding.left;
rect.y = border.top + padding.top;
gtk_style_context_save_to_node (context, swatch->priv->overlay_node);
gtk_render_background (context, cr, rect.x, rect.y, rect.width, rect.height);
gtk_render_frame (context, cr, rect.x, rect.y, rect.width, rect.height);
if (icon_info != NULL)
{
GdkPixbuf *pixbuf;
pixbuf = gtk_icon_info_load_symbolic_for_context (icon_info, context, NULL, NULL);
if (pixbuf != NULL)
{
cairo_surface_t *surface;
surface = gdk_cairo_surface_create_from_pixbuf (pixbuf, scale, gtk_widget_get_window (widget));
gtk_render_icon_surface (context, cr, surface,
rect.x + (rect.width - (gdk_pixbuf_get_width (pixbuf) / scale)) / 2,
rect.y + (rect.height - (gdk_pixbuf_get_height (pixbuf) / scale)) / 2);
cairo_surface_destroy (surface);
g_object_unref (pixbuf);
}
g_object_unref (icon_info);
}
if (gtk_widget_has_visible_focus (widget))
gtk_render_focus (context, cr, 0, 0, width, height);
gtk_style_context_restore (context);
return FALSE;
}
void Context::mask( Pattern *pattern )
{
cairo_mask( mCairo, pattern->getCairoPattern() );
}
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 gboolean
gtk_mirror_bin_expose (GtkWidget *widget,
GdkEventExpose *event)
{
GtkMirrorBin *bin = GTK_MIRROR_BIN (widget);
gint width, height;
if (gtk_widget_is_drawable (widget))
{
if (event->window == widget->window)
{
GdkPixmap *pixmap;
cairo_t *cr;
cairo_matrix_t matrix;
cairo_pattern_t *mask;
if (bin->child && gtk_widget_get_visible (bin->child))
{
pixmap = gdk_offscreen_window_get_pixmap (bin->offscreen_window);
gdk_pixmap_get_size (pixmap, &width, &height);
cr = gdk_cairo_create (widget->window);
cairo_save (cr);
cairo_rectangle (cr, 0, 0, width, height);
cairo_clip (cr);
/* paint the offscreen child */
gdk_cairo_set_source_pixmap (cr, pixmap, 0, 0);
cairo_paint (cr);
cairo_restore (cr);
cairo_matrix_init (&matrix, 1.0, 0.0, 0.3, 1.0, 0.0, 0.0);
cairo_matrix_scale (&matrix, 1.0, -1.0);
cairo_matrix_translate (&matrix, -10, - 3 * height - 10);
cairo_transform (cr, &matrix);
cairo_rectangle (cr, 0, height, width, height);
cairo_clip (cr);
gdk_cairo_set_source_pixmap (cr, pixmap, 0, height);
/* create linear gradient as mask-pattern to fade out the source */
mask = cairo_pattern_create_linear (0.0, height, 0.0, 2*height);
cairo_pattern_add_color_stop_rgba (mask, 0.0, 0.0, 0.0, 0.0, 0.0);
cairo_pattern_add_color_stop_rgba (mask, 0.25, 0.0, 0.0, 0.0, 0.01);
cairo_pattern_add_color_stop_rgba (mask, 0.5, 0.0, 0.0, 0.0, 0.25);
cairo_pattern_add_color_stop_rgba (mask, 0.75, 0.0, 0.0, 0.0, 0.5);
cairo_pattern_add_color_stop_rgba (mask, 1.0, 0.0, 0.0, 0.0, 1.0);
/* paint the reflection */
cairo_mask (cr, mask);
cairo_pattern_destroy (mask);
cairo_destroy (cr);
}
}
else if (event->window == bin->offscreen_window)
{
gtk_paint_flat_box (widget->style, event->window,
GTK_STATE_NORMAL, GTK_SHADOW_NONE,
&event->area, widget, "blah",
0, 0, -1, -1);
if (bin->child)
gtk_container_propagate_expose (GTK_CONTAINER (widget),
bin->child,
event);
}
}
return FALSE;
}
static void render (cairo_t *pCairoContext, CairoDesklet *pDesklet)
{
CDSlideParameters *pSlide = (CDSlideParameters *) pDesklet->pRendererData;
//g_print ("%s(%x)\n", __func__, pSlide);
if (pSlide == NULL)
return ;
double fRadius = pSlide->iRadius;
double fLineWidth = pSlide->iLineWidth;
// le cadre.
cairo_set_line_width (pCairoContext, pSlide->iLineWidth);
if (pSlide->bRoundedRadius)
{
cairo_translate (pCairoContext, 0., .5 * fLineWidth);
cairo_dock_draw_rounded_rectangle (pCairoContext,
fRadius,
fLineWidth,
pDesklet->container.iWidth - 2 * fRadius - fLineWidth,
pDesklet->container.iHeight - 2*fLineWidth);
}
else
{
cairo_move_to (pCairoContext, 0., 0.);
cairo_rel_line_to (pCairoContext,
0.,
pDesklet->container.iHeight - fRadius - fLineWidth);
cairo_rel_line_to (pCairoContext,
pSlide->iRadius,
pSlide->iRadius);
cairo_rel_line_to (pCairoContext,
pDesklet->container.iWidth - fRadius - fLineWidth,
0.);
}
cairo_set_source_rgba (pCairoContext, pSlide->fLineColor[0], pSlide->fLineColor[1], pSlide->fLineColor[2], pSlide->fLineColor[3]);
cairo_stroke (pCairoContext);
// 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.
// on determine la 1ere icone a tracer : l'icone suivant l'icone pointee.
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.pSurface != NULL && ! CAIRO_DOCK_ICON_TYPE_IS_SEPARATOR (pIcon))
{
cairo_save (pCairoContext);
cairo_dock_render_one_icon_in_desklet (pIcon, CAIRO_CONTAINER (pDesklet), pCairoContext, FALSE);
cairo_restore (pCairoContext);
if (pIcon->label.pSurface != NULL)
{
cairo_save (pCairoContext);
cairo_translate (pCairoContext, pIcon->fDrawX, pIcon->fDrawY);
double fOffsetX = 0., fAlpha;
if (pIcon->bPointed)
{
fAlpha = 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);
cairo_set_source_surface (pCairoContext,
pIcon->label.pSurface,
fOffsetX + pIcon->fWidth/2 - pIcon->label.iWidth/2,
-myIconsParam.iLabelSize);
cairo_paint_with_alpha (pCairoContext, fAlpha);
}
else
{
fAlpha = .6;
if (pIcon->label.iWidth > pIcon->fWidth + 2 * myIconsParam.iLabelSize)
{
fOffsetX = - myIconsParam.iLabelSize;
cairo_pattern_t *pGradationPattern = cairo_pattern_create_linear (fOffsetX,
0.,
fOffsetX + pIcon->fWidth + 2*myIconsParam.iLabelSize,
0.);
cairo_pattern_set_extend (pGradationPattern, CAIRO_EXTEND_NONE);
cairo_pattern_add_color_stop_rgba (pGradationPattern,
0.,
0.,
0.,
0.,
fAlpha);
cairo_pattern_add_color_stop_rgba (pGradationPattern,
0.75,
0.,
0.,
0.,
fAlpha);
cairo_pattern_add_color_stop_rgba (pGradationPattern,
1.,
0.,
0.,
0.,
0.);
cairo_set_source_surface (pCairoContext,
pIcon->label.pSurface,
fOffsetX,
-myIconsParam.iLabelSize);
cairo_mask (pCairoContext, pGradationPattern);
cairo_pattern_destroy (pGradationPattern);
}
else
{
fOffsetX = pIcon->fWidth/2 - pIcon->label.iWidth/2;
cairo_set_source_surface (pCairoContext,
pIcon->label.pSurface,
fOffsetX,
-myIconsParam.iLabelSize);
cairo_paint_with_alpha (pCairoContext, fAlpha);
}
}
cairo_restore (pCairoContext);
}
}
ic = cairo_dock_get_next_element (ic, pDesklet->icons);
}
while (ic != pFirstDrawnElement);
}
static gboolean
gstyle_color_widget_draw (GtkWidget *widget,
cairo_t *cr)
{
GstyleColorWidget *self = (GstyleColorWidget *)widget;
GtkStyleContext *style_context;
GdkRectangle margin_box;
GdkRectangle border_box;
cairo_matrix_t matrix;
GdkRGBA bg_color = {0};
gint radius;
g_assert (GSTYLE_IS_COLOR_WIDGET (self));
g_assert (cr != NULL);
style_context = gtk_widget_get_style_context (GTK_WIDGET (self));
gtk_widget_get_allocation (widget, &margin_box);
margin_box.x = margin_box.y = 0;
gstyle_utils_get_rect_resized_box (margin_box, &margin_box, &self->cached_margin);
gstyle_utils_get_rect_resized_box (margin_box, &border_box, &self->cached_border);
cairo_save (cr);
if (self->color != NULL)
{
gtk_style_context_get (style_context,
gtk_style_context_get_state (style_context),
"border-radius", &radius,
NULL);
gstyle_color_fill_rgba (self->color, &bg_color);
if (self->filter_func != NULL)
self->filter_func (&bg_color, &bg_color, self->filter_user_data);
cairo_new_path (cr);
draw_cairo_round_box (cr, border_box, radius, radius, radius, radius);
}
else
cairo_rectangle (cr, border_box.x, border_box.y, border_box.width, border_box.height);
cairo_clip_preserve (cr);
cairo_set_source_rgb (cr, 0.20, 0.20, 0.20);
cairo_paint (cr);
cairo_set_source_rgb (cr, 0.80, 0.80, 0.80);
cairo_matrix_init_scale (&matrix, 0.1, 0.1);
cairo_matrix_translate (&matrix, -border_box.x, -border_box.y);
cairo_pattern_set_matrix (self->checkered_pattern, &matrix);
cairo_mask (cr, self->checkered_pattern);
if (self->color != NULL)
{
gdk_cairo_set_source_rgba (cr, &bg_color);
cairo_fill (cr);
}
else
gtk_render_background (style_context, cr, border_box.x, border_box.y, border_box.width, border_box.height);
cairo_restore (cr);
gtk_render_frame (gtk_widget_get_style_context (widget), cr,
margin_box.x, margin_box.y, margin_box.width, margin_box.height);
return GTK_WIDGET_CLASS (gstyle_color_widget_parent_class)->draw (widget, cr);
}
tile_t*
setup_text_tile (const cairo_font_options_t* font_opts,
gdouble dpi,
gint w,
gint h)
{
tile_t* tile = NULL;
cairo_status_t status;
cairo_surface_t* surface = NULL;
cairo_surface_t* text = NULL;
cairo_surface_t* shadow = NULL;
cairo_t* cr;
gdouble width = (gdouble) w;
gdouble height = (gdouble) h;
raico_blur_t* blur = NULL;
cairo_pattern_t* pattern = NULL;
surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, width, height);
status = cairo_surface_status (surface);
if (status != CAIRO_STATUS_SUCCESS)
g_print ("Error: \"%s\"\n", cairo_status_to_string (status));
cr = cairo_create (surface);
status = cairo_status (cr);
if (status != CAIRO_STATUS_SUCCESS)
{
cairo_surface_destroy (surface);
g_print ("Error: \"%s\"\n", cairo_status_to_string (status));
}
// clear and render drop-shadow and bubble-background
cairo_scale (cr, 1.0f, 1.0f);
cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);
cairo_paint (cr);
cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
text = render_text_to_surface (
"After an evening of hacking at the"
" Fataga hotel here at GUADEC I "
"can present you even text-scroll "
"with blur-cache and fade-out mask"
" and I dedicate this to Behdad who"
" sadly burst his upper lip during "
"the evening and had to go to the "
"hospital. Some spanish KDE-folks "
"kindly accompanied him to help out"
" with translation. True collaboration!\0",
width,
height,
font_opts,
dpi);
shadow = render_text_to_surface (
"After an evening of hacking at the"
" Fataga hotel here at GUADEC I "
"can present you even text-scroll "
"with blur-cache and fade-out mask"
" and I dedicate this to Behdad who"
" sadly burst his upper lip during "
"the evening and had to go to the "
"hospital. Some spanish KDE-folks "
"kindly accompanied him to help out"
" with translation. True collaboration!\0",
width,
height,
font_opts,
dpi);
// create and setup blur
blur = raico_blur_create (RAICO_BLUR_QUALITY_LOW);
raico_blur_set_radius (blur, 4);
// now blur it
raico_blur_apply (blur, shadow);
// blur no longer needed
raico_blur_destroy (blur);
cairo_push_group (cr);
cairo_set_source_surface (cr,
shadow,
0.0f,
0.0f);
cairo_paint (cr);
pattern = cairo_pop_group (cr);
cairo_set_source_rgba (cr, 0.0f, 0.0f, 0.0f, 1.0f);
cairo_mask (cr, pattern);
cairo_surface_destroy (shadow);
cairo_pattern_destroy (pattern);
cairo_set_source_surface (cr, text, 0.0f, 0.0f);
cairo_paint (cr);
cairo_destroy (cr);
cairo_surface_destroy (text);
tile = tile_new (surface, 6);
cairo_surface_destroy (surface);
return tile;
}
static gint
expose_event (GtkWidget *widget,
GdkEventExpose *event,
gpointer data)
#endif
{
MateColorButton *color_button = MATE_COLOR_BUTTON (data);
GtkAllocation allocation;
cairo_pattern_t *checkered;
#if !GTK_CHECK_VERSION (3, 0, 0)
cairo_t *cr;
cr = gdk_cairo_create (event->window);
gtk_widget_get_allocation (widget, &allocation);
gdk_cairo_rectangle (cr, &allocation);
cairo_clip (cr);
#endif
if (mate_color_button_has_alpha (color_button))
{
cairo_save (cr);
cairo_set_source_rgb (cr, CHECK_DARK, CHECK_DARK, CHECK_DARK);
cairo_paint (cr);
cairo_set_source_rgb (cr, CHECK_LIGHT, CHECK_LIGHT, CHECK_LIGHT);
cairo_scale (cr, CHECK_SIZE, CHECK_SIZE);
checkered = mate_color_button_get_checkered ();
cairo_mask (cr, checkered);
cairo_pattern_destroy (checkered);
cairo_restore (cr);
cairo_set_source_rgba (cr,
color_button->priv->color.red / 65535.,
color_button->priv->color.green / 65535.,
color_button->priv->color.blue / 65535.,
color_button->priv->alpha / 65535.);
}
else
{
gdk_cairo_set_source_color (cr, &color_button->priv->color);
}
cairo_paint (cr);
if (!gtk_widget_is_sensitive (GTK_WIDGET (color_button)))
{
gdk_cairo_set_source_color (cr, >k_widget_get_style (GTK_WIDGET(color_button))->bg[GTK_STATE_INSENSITIVE]);
checkered = mate_color_button_get_checkered ();
cairo_mask (cr, checkered);
cairo_pattern_destroy (checkered);
}
#if !GTK_CHECK_VERSION (3, 0, 0)
cairo_destroy (cr);
#endif
return FALSE;
}
gboolean
expose_handler (GtkWidget* window,
cairo_t* cr,
gpointer data)
{
cairo_pattern_t* pattern = NULL;
cairo_pattern_t* mask = NULL;
// clear and render drop-shadow and bubble-background
cairo_scale (cr, 1.0f, 1.0f);
cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);
cairo_paint (cr);
cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
if (g_distance < 1.0f)
{
tile_paint (g_tile, cr, 0.0f, 0.0f, g_distance, 1.0f - g_distance);
cairo_push_group (cr);
tile_paint (g_text,
cr,
2 * BUBBLE_SHADOW_SIZE,
BUBBLE_SHADOW_SIZE - g_offset,
g_distance,
1.0f - g_distance);
pattern = cairo_pop_group (cr);
cairo_set_source (cr, pattern);
mask = cairo_pattern_create_linear (0.0f, 2 * BUBBLE_SHADOW_SIZE, 0.0f, BUBBLE_HEIGHT);
cairo_pattern_add_color_stop_rgba (mask,
0.0f,
0.0f,
0.0f,
0.0f,
0.0f);
cairo_pattern_add_color_stop_rgba (mask,
0.2f,
0.0f,
0.0f,
0.0f,
1.0f);
cairo_pattern_add_color_stop_rgba (mask,
0.8f,
0.0f,
0.0f,
0.0f,
1.0f);
cairo_pattern_add_color_stop_rgba (mask,
1.0f,
0.0f,
0.0f,
0.0f,
0.0f);
cairo_mask (cr, mask);
cairo_pattern_destroy (mask);
cairo_pattern_destroy (pattern);
gtk_window_set_opacity (GTK_WINDOW (window),
0.3f + g_distance * 0.7f);
}
else
{
tile_paint (g_tile, cr, 0.0f, 0.0f, g_distance, 0.0f);
cairo_push_group (cr);
tile_paint (g_text, cr, 2 * BUBBLE_SHADOW_SIZE, BUBBLE_SHADOW_SIZE - g_offset, g_distance, 0.0f);
pattern = cairo_pop_group (cr);
cairo_set_source (cr, pattern);
mask = cairo_pattern_create_linear (0.0f, 2 * BUBBLE_SHADOW_SIZE, 0.0f, BUBBLE_HEIGHT);
cairo_pattern_add_color_stop_rgba (mask, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f);
cairo_pattern_add_color_stop_rgba (mask, 0.2f, 0.0f, 0.0f, 0.0f, 1.0f);
cairo_pattern_add_color_stop_rgba (mask, 0.8f, 0.0f, 0.0f, 0.0f, 1.0f);
cairo_pattern_add_color_stop_rgba (mask, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f);
cairo_mask (cr, mask);
cairo_pattern_destroy (pattern);
gtk_window_set_opacity (GTK_WINDOW (window), 1.0f);
}
return TRUE;
}
static gboolean
swatch_draw (GtkWidget *widget,
cairo_t *cr)
{
GtkColorSwatch *swatch = (GtkColorSwatch*)widget;
GtkThemingBackground background;
gdouble width, height;
GtkStyleContext *context;
GtkStateFlags state;
GtkIconTheme *theme;
GtkIconInfo *icon_info = NULL;
theme = gtk_icon_theme_get_default ();
context = gtk_widget_get_style_context (widget);
state = gtk_widget_get_state_flags (widget);
width = gtk_widget_get_allocated_width (widget);
height = gtk_widget_get_allocated_height (widget);
cairo_save (cr);
gtk_style_context_save (context);
gtk_style_context_set_state (context, state);
_gtk_theming_background_init_from_context (&background, context,
0, 0, width, height,
GTK_JUNCTION_NONE);
if (swatch->priv->has_color)
{
cairo_pattern_t *pattern;
cairo_matrix_t matrix;
if (swatch->priv->use_alpha)
{
cairo_save (cr);
_gtk_rounded_box_path (&background.padding_box, cr);
cairo_clip_preserve (cr);
cairo_set_source_rgb (cr, 0.33, 0.33, 0.33);
cairo_fill_preserve (cr);
pattern = _gtk_color_chooser_get_checkered_pattern ();
cairo_matrix_init_scale (&matrix, 0.125, 0.125);
cairo_pattern_set_matrix (pattern, &matrix);
cairo_set_source_rgb (cr, 0.66, 0.66, 0.66);
cairo_mask (cr, pattern);
cairo_pattern_destroy (pattern);
cairo_restore (cr);
background.bg_color = swatch->priv->color;
}
else
{
background.bg_color = swatch->priv->color;
background.bg_color.alpha = 1.0;
}
_gtk_theming_background_render (&background, cr);
}
else
_gtk_theming_background_render (&background, cr);
gtk_render_frame (context, cr,
0, 0, width, height);
if (gtk_widget_has_visible_focus (widget))
{
cairo_set_line_width (cr, 2);
if (swatch->priv->has_color && INTENSITY (swatch->priv->color.red, swatch->priv->color.green, swatch->priv->color.blue) < 0.5)
cairo_set_source_rgba (cr, 1., 1., 1., 0.4);
else
cairo_set_source_rgba (cr, 0., 0., 0., 0.4);
_gtk_rounded_box_shrink (&background.padding_box, 3, 3, 3, 3);
_gtk_rounded_box_path (&background.padding_box, cr);
cairo_stroke (cr);
}
if (swatch->priv->icon)
{
icon_info = gtk_icon_theme_lookup_icon (theme, swatch->priv->icon, 16,
GTK_ICON_LOOKUP_GENERIC_FALLBACK
| GTK_ICON_LOOKUP_USE_BUILTIN);
}
else if ((state & GTK_STATE_FLAG_SELECTED) != 0)
{
GdkRGBA bg, border;
GtkBorder border_width;
GIcon *gicon;
gtk_style_context_add_class (context, "color-active-badge");
_gtk_theming_background_init_from_context (&background, context,
(width - 2 * ACTIVE_BADGE_RADIUS) / 2, (height - 2 * ACTIVE_BADGE_RADIUS) / 2,
2 * ACTIVE_BADGE_RADIUS, 2* ACTIVE_BADGE_RADIUS,
GTK_JUNCTION_NONE);
if (_gtk_theming_background_has_background_image (&background))
{
_gtk_theming_background_render (&background, cr);
}
else
{
gtk_style_context_get_background_color (context, state, &bg);
gtk_style_context_get_border_color (context, state, &border);
gtk_style_context_get_border (context, state, &border_width);
cairo_new_sub_path (cr);
cairo_arc (cr, width / 2, height / 2, ACTIVE_BADGE_RADIUS, 0, 2 * G_PI);
cairo_close_path (cr);
gdk_cairo_set_source_rgba (cr, &bg);
cairo_fill_preserve (cr);
gdk_cairo_set_source_rgba (cr, &border);
cairo_set_line_width (cr, border_width.left);
cairo_stroke (cr);
gicon = g_themed_icon_new ("object-select-symbolic");
/* fallback for themes that don't have object-select-symbolic */
g_themed_icon_append_name (G_THEMED_ICON (gicon), "gtk-apply");
icon_info = gtk_icon_theme_lookup_by_gicon (theme, gicon, 16,
GTK_ICON_LOOKUP_GENERIC_FALLBACK
| GTK_ICON_LOOKUP_USE_BUILTIN);
g_object_unref (gicon);
}
}
if (icon_info != NULL)
{
GdkPixbuf *pixbuf;
pixbuf = gtk_icon_info_load_symbolic_for_context (icon_info, context,
NULL, NULL);
if (pixbuf != NULL)
{
gtk_render_icon (context, cr, pixbuf,
(width - gdk_pixbuf_get_width (pixbuf)) / 2,
(height - gdk_pixbuf_get_height (pixbuf)) / 2);
g_object_unref (pixbuf);
}
g_object_unref (icon_info);
}
cairo_restore (cr);
gtk_style_context_restore (context);
return FALSE;
}
void
gfxContext::Mask(gfxPattern *pattern)
{
cairo_mask(mCairo, pattern->CairoPattern());
}
static cairo_surface_t* fading_label_make_surface (FadingLabel* self, cairo_t* orig_c) {
cairo_surface_t* result = NULL;
gint w = 0;
gint h = 0;
PangoLayout* _tmp0_ = NULL;
gint _tmp1_ = 0;
gint _tmp2_ = 0;
gint _tmp3_ = 0;
gint bw;
gint _tmp4_ = 0;
gint bh;
cairo_t* _tmp5_;
cairo_surface_t* _tmp6_ = NULL;
gint _tmp7_;
gint _tmp8_;
cairo_surface_t* _tmp9_;
cairo_surface_t* surface;
cairo_surface_t* _tmp10_;
cairo_t* _tmp11_;
cairo_t* c;
gint _tmp12_;
gint _tmp13_;
g_return_val_if_fail (self != NULL, NULL);
g_return_val_if_fail (orig_c != NULL, NULL);
_tmp0_ = gtk_label_get_layout ((GtkLabel*) self);
pango_layout_get_pixel_size (_tmp0_, &_tmp1_, &_tmp2_);
w = _tmp1_;
h = _tmp2_;
_tmp3_ = gtk_widget_get_allocated_width ((GtkWidget*) self);
bw = _tmp3_;
_tmp4_ = gtk_widget_get_allocated_height ((GtkWidget*) self);
bh = _tmp4_;
_tmp5_ = orig_c;
_tmp6_ = cairo_get_target (_tmp5_);
_tmp7_ = bw;
_tmp8_ = bh;
_tmp9_ = cairo_surface_create_similar (_tmp6_, CAIRO_CONTENT_COLOR_ALPHA, _tmp7_, _tmp8_);
surface = _tmp9_;
_tmp10_ = surface;
_tmp11_ = cairo_create (_tmp10_);
c = _tmp11_;
_tmp12_ = w;
_tmp13_ = bw;
if (_tmp12_ > _tmp13_) {
cairo_t* _tmp14_;
cairo_t* _tmp15_;
cairo_t* _tmp16_;
gint _tmp17_;
cairo_pattern_t* _tmp18_;
cairo_pattern_t* mask;
cairo_pattern_t* _tmp19_;
gint _tmp20_;
cairo_pattern_t* _tmp21_;
gint _tmp22_;
cairo_pattern_t* _tmp23_;
cairo_t* _tmp24_;
cairo_pattern_t* _tmp25_;
_tmp14_ = c;
cairo_push_group (_tmp14_);
_tmp15_ = c;
GTK_WIDGET_CLASS (fading_label_parent_class)->draw ((GtkWidget*) G_TYPE_CHECK_INSTANCE_CAST (self, GTK_TYPE_LABEL, GtkLabel), _tmp15_);
_tmp16_ = c;
cairo_pop_group_to_source (_tmp16_);
_tmp17_ = bw;
_tmp18_ = cairo_pattern_create_linear ((gdouble) 0, (gdouble) 0, (gdouble) _tmp17_, (gdouble) 0);
mask = _tmp18_;
_tmp19_ = mask;
_tmp20_ = bw;
cairo_pattern_add_color_stop_rgba (_tmp19_, 1.0 - (27.0 / _tmp20_), 1.0, 1.0, 1.0, 1.0);
_tmp21_ = mask;
_tmp22_ = bw;
cairo_pattern_add_color_stop_rgba (_tmp21_, 1.0 - (21.6 / _tmp22_), 1.0, 1.0, 1.0, 0.5);
_tmp23_ = mask;
cairo_pattern_add_color_stop_rgba (_tmp23_, 1.0, 1.0, 1.0, 1.0, 0.0);
_tmp24_ = c;
_tmp25_ = mask;
cairo_mask (_tmp24_, _tmp25_);
_cairo_pattern_destroy0 (mask);
} else {
cairo_t* _tmp26_;
_tmp26_ = c;
GTK_WIDGET_CLASS (fading_label_parent_class)->draw ((GtkWidget*) G_TYPE_CHECK_INSTANCE_CAST (self, GTK_TYPE_LABEL, GtkLabel), _tmp26_);
}
result = surface;
_cairo_destroy0 (c);
return result;
}
void lime_cairo_mask (value handle, value pattern) {
cairo_mask ((cairo_t*)val_data (handle), (cairo_pattern_t*)val_data (pattern));
}
