static Tile *
tile_new( VipsTileCache *cache )
{
Tile *tile;
if( !(tile = VIPS_NEW( NULL, Tile )) )
return( NULL );
tile->cache = cache;
tile->region = NULL;
tile->time = cache->time;
tile->x = -1;
tile->y = -1;
cache->tiles = g_slist_prepend( cache->tiles, tile );
g_assert( cache->ntiles >= 0 );
cache->ntiles += 1;
if( !(tile->region = vips_region_new( cache->in )) ) {
tile_destroy( tile );
return( NULL );
}
vips__region_no_ownership( tile->region );
return( tile );
}
void _Tile::release(Tile *tile, bool dirty)
{
if (tile == NULL)
return;
//qDebug() << "++ tile::release";
//qDebug() << "ref_count" << tile->ref_count;
tile->ref_count--;
//qDebug() << "ref_count" << tile->ref_count;
if (dirty) {
tile->write_count--;
}
if (tile->ref_count == 0) {
if (tile->share_count == 0) {
//qDebug() << "tile_destroy";
tile_destroy(tile);
return;
} else {
//qDebug() << "TileCache insert";
TileCache::instance()->insert(tile);
}
}
//qDebug() << "-- tile::release";
}
static Tile *
tile_new( Read *read )
{
Tile *tile;
if( !(tile = IM_NEW( NULL, Tile )) )
return( NULL );
tile->read = read;
tile->region = NULL;
tile->time = read->time;
tile->x = -1;
tile->y = -1;
read->cache = g_slist_prepend( read->cache, tile );
g_assert( read->ntiles >= 0 );
read->ntiles += 1;
if( !(tile->region = im_region_create( read->in )) ) {
tile_destroy( tile );
return( NULL );
}
im__region_no_ownership( tile->region );
return( tile );
}
static void
read_destroy( Read *read )
{
IM_FREEF( g_mutex_free, read->lock );
while( read->cache ) {
Tile *tile = (Tile *) read->cache->data;
tile_destroy( tile );
}
im_free( read );
}
static void
vips_tile_cache_dispose( GObject *gobject )
{
VipsTileCache *cache = (VipsTileCache *) gobject;
while( cache->tiles ) {
Tile *tile = (Tile *) cache->tiles->data;
tile_destroy( tile );
}
VIPS_FREEF( g_mutex_free, cache->lock );
G_OBJECT_CLASS( vips_tile_cache_parent_class )->dispose( gobject );
}
void
tile_release (Tile *tile,
gboolean dirty)
{
/* Decrement the global reference count.
*/
tile_ref_count--;
/* Decrement this tile's reference count.
*/
tile->ref_count--;
/* Decrement write ref count if dirtying
*/
if (dirty)
{
gint y;
tile->write_count--;
if (tile->rowhint)
{
for (y = 0; y < tile->eheight; y++)
tile->rowhint[y] = TILEROWHINT_UNKNOWN;
}
}
if (tile->ref_count == 0)
{
#ifdef TILE_PROFILING
tile_active_count--;
#endif
if (tile->share_count == 0)
{
/* tile is truly dead */
tile_destroy (tile);
return; /* skip terminal unlock */
}
else
{
/* last reference was just released, so move the tile to the
tile cache */
tile_cache_insert (tile);
}
}
}
void _Tile::detach(Tile *tile, TileManager *tm, int tile_num)
{
TileLink **link;
TileLink *tmp;
for (link = &tile->tlink; *link != 0;
link = &(*link)->next) {
if (((*link)->tm == tm &&
((*link)->tile_num == tile_num)))
break;
}
tmp = *link;
*link = tmp->next;
delete tmp;
tile->share_count--;
if (tile->share_count == 0 && tile->ref_count == 0) {
tile_destroy(tile);
}
}
int
main (int argc,
char** argv)
{
GtkWidget* window;
guint pointer_update_id;
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
if (!window)
return 0;
gtk_window_set_type_hint (GTK_WINDOW (window),
GDK_WINDOW_TYPE_HINT_DOCK);
gtk_widget_add_events (window,
GDK_POINTER_MOTION_MASK |
GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK);
// hook up input/event handlers to window
g_signal_connect (G_OBJECT (window),
"screen-changed",
G_CALLBACK (screen_changed_handler),
NULL);
g_signal_connect (G_OBJECT (window),
"composited-changed",
G_CALLBACK (composited_changed_handler),
NULL);
gtk_window_move (GTK_WINDOW (window), POS_X, POS_Y);
// make sure the window opens with a RGBA-visual
screen_changed_handler (window, NULL, NULL);
gtk_widget_realize (window);
gdk_window_set_back_pixmap (gtk_widget_get_window (window), NULL, FALSE);
// hook up window-event handlers to window
g_signal_connect (G_OBJECT (window),
"expose-event",
G_CALLBACK (expose_handler),
NULL);
// FIXME: read out current mouse-pointer position every 1/25 second
pointer_update_id = g_timeout_add (1000/40,
(GSourceFunc) pointer_update,
(gpointer) window);
g_timeout_add (10000,
(GSourceFunc) quit,
NULL);
g_timeout_add (1000/40,
(GSourceFunc) grow,
(gpointer) window);
// "clear" input-mask, set title/icon/attributes
gtk_widget_set_app_paintable (window, TRUE);
gtk_window_set_decorated (GTK_WINDOW (window), FALSE);
gtk_window_set_keep_above (GTK_WINDOW (window), TRUE);
gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
gtk_window_set_accept_focus (GTK_WINDOW (window), FALSE);
gtk_window_set_opacity (GTK_WINDOW (window), 1.0f);
gtk_widget_set_size_request (window,
(gint) (BUBBLE_WIDTH + 2.0f *
BUBBLE_SHADOW_SIZE),
(gint) (BUBBLE_HEIGHT + 2.0f *
BUBBLE_SHADOW_SIZE));
gtk_widget_show (window);
g_composited = gdk_screen_is_composited(gtk_widget_get_screen (window));
update_input_shape (window, 1, 1);
update_shape (window,
(gint) CORNER_RADIUS,
(gint) BUBBLE_SHADOW_SIZE);
set_bg_blur (window, TRUE);
setup_tile ((gint) (BUBBLE_WIDTH + 2.0f * BUBBLE_SHADOW_SIZE),
(gint) (BUBBLE_HEIGHT + 2.0f * BUBBLE_SHADOW_SIZE));
g_print ("This test will run for 10 seconds and then quit.\n");
gtk_main ();
tile_destroy (g_tile);
return 0;
}
void
setup_tile (gint w, gint h)
{
cairo_status_t status;
cairo_t* cr = NULL;
cairo_surface_t* cr_surf = NULL;
gdouble width = (gdouble) w;
gdouble height = (gdouble) h;
cairo_surface_t* tmp = NULL;
cairo_surface_t* dummy_surf = NULL;
cairo_surface_t* norm_surf = NULL;
cairo_surface_t* blur_surf = NULL;
raico_blur_t* blur = NULL;
tile_t* tile = NULL;
// create tmp. surface for scratch
cr_surf = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
3 * BUBBLE_SHADOW_SIZE,
3 * BUBBLE_SHADOW_SIZE);
status = cairo_surface_status (cr_surf);
if (status != CAIRO_STATUS_SUCCESS)
g_print ("Error: \"%s\"\n", cairo_status_to_string (status));
// create context for that tmp. scratch surface
cr = cairo_create (cr_surf);
status = cairo_status (cr);
if (status != CAIRO_STATUS_SUCCESS)
{
cairo_surface_destroy (cr_surf);
g_print ("Error: \"%s\"\n", cairo_status_to_string (status));
}
// clear, render drop-shadow and bubble-background in scratch-surface
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_composited)
{
draw_shadow (cr,
width,
height,
BUBBLE_SHADOW_SIZE,
CORNER_RADIUS);
cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);
draw_round_rect (cr,
1.0f,
(gdouble) BUBBLE_SHADOW_SIZE,
(gdouble) BUBBLE_SHADOW_SIZE,
(gdouble) CORNER_RADIUS,
(gdouble) (width - 2.0f * BUBBLE_SHADOW_SIZE),
(gdouble) (height - 2.0f* BUBBLE_SHADOW_SIZE));
cairo_fill (cr);
cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
cairo_set_source_rgba (cr,
BUBBLE_BG_COLOR_R,
BUBBLE_BG_COLOR_G,
BUBBLE_BG_COLOR_B,
0.95f);
}
else
cairo_set_source_rgb (cr,
BUBBLE_BG_COLOR_R,
BUBBLE_BG_COLOR_G,
BUBBLE_BG_COLOR_B);
draw_round_rect (cr,
1.0f,
BUBBLE_SHADOW_SIZE,
BUBBLE_SHADOW_SIZE,
CORNER_RADIUS,
(gdouble) (width - 2.0f * BUBBLE_SHADOW_SIZE),
(gdouble) (height - 2.0f * BUBBLE_SHADOW_SIZE));
cairo_fill (cr);
// create tmp. copy of scratch-surface
tmp = cairo_image_surface_create_for_data (
cairo_image_surface_get_data (cr_surf),
cairo_image_surface_get_format (cr_surf),
3 * BUBBLE_SHADOW_SIZE,
3 * BUBBLE_SHADOW_SIZE,
cairo_image_surface_get_stride (cr_surf));
dummy_surf = copy_surface (tmp);
cairo_surface_destroy (tmp);
// create normal-state surface for tile from copy of scratch-surface
tmp = cairo_image_surface_create_for_data (
cairo_image_surface_get_data (dummy_surf),
cairo_image_surface_get_format (dummy_surf),
2 * BUBBLE_SHADOW_SIZE,
2 * BUBBLE_SHADOW_SIZE,
cairo_image_surface_get_stride (dummy_surf));
norm_surf = copy_surface (tmp);
cairo_surface_destroy (tmp);
// blur tmp. copy of scratch-surface
blur = raico_blur_create (RAICO_BLUR_QUALITY_LOW);
raico_blur_set_radius (blur, 6);
raico_blur_apply (blur, dummy_surf);
raico_blur_destroy (blur);
// create blurred-state surface for tile
tmp = cairo_image_surface_create_for_data (
cairo_image_surface_get_data (dummy_surf),
cairo_image_surface_get_format (dummy_surf),
2 * BUBBLE_SHADOW_SIZE,
2 * BUBBLE_SHADOW_SIZE,
cairo_image_surface_get_stride (dummy_surf));
blur_surf = copy_surface (tmp);
cairo_surface_destroy (tmp);
// actually create the tile with padding in mind
tile = tile_new_for_padding (norm_surf, blur_surf);
destroy_cloned_surface (norm_surf);
destroy_cloned_surface (blur_surf);
destroy_cloned_surface (dummy_surf);
cairo_destroy (cr);
cairo_surface_destroy (cr_surf);
norm_surf = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, w, h);
cr = cairo_create (norm_surf);
cairo_scale (cr, 1.0f, 1.0f);
cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);
cairo_paint (cr);
cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
tile_paint_with_padding (tile, cr, 0.0f, 0.0f, w, h, 1.0f, 0.0f);
cairo_destroy (cr);
blur_surf = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, w, h);
cr = cairo_create (blur_surf);
cairo_scale (cr, 1.0f, 1.0f);
cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);
cairo_paint (cr);
cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
tile_paint_with_padding (tile, cr, 0.0f, 0.0f, w, h, 0.0f, 1.0f);
cairo_destroy (cr);
g_tile = tile_new_for_padding (norm_surf, blur_surf);
// clean up
tile_destroy (tile);
cairo_surface_destroy (norm_surf);
cairo_surface_destroy (blur_surf);
}
