ewk_tiled_backing_store.c   [plain text]

/*
    Copyright (C) 2009-2010 Samsung Electronics
    Copyright (C) 2009-2010 ProFUSION embedded systems

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
*/

#include "config.h"
#include "ewk_tiled_backing_store.h"

#define _GNU_SOURCE
#include "ewk_tiled_private.h"
#include <Ecore.h>
#include <Eina.h>
#include <errno.h>
#include <math.h>
#include <stdio.h> // XXX REMOVE ME LATER
#include <stdlib.h>
#include <string.h>

#define IDX(col, row, rowspan) (col + (row * rowspan))

#if !defined(MIN)
# define MIN(a, b) ((a < b) ? a : b)
#endif

#if !defined(MAX)
# define MAX(a, b) ((a > b) ? a : b)
#endif

typedef enum _Ewk_Tiled_Backing_Store_Pre_Render_Priority Ewk_Tiled_Backing_Store_Pre_Render_Priority;
typedef struct _Ewk_Tiled_Backing_Store_Data Ewk_Tiled_Backing_Store_Data;
typedef struct _Ewk_Tiled_Backing_Store_Item Ewk_Tiled_Backing_Store_Item;
typedef struct _Ewk_Tiled_Backing_Store_Pre_Render_Request Ewk_Tiled_Backing_Store_Pre_Render_Request;

enum _Ewk_Tiled_Backing_Store_Pre_Render_Priority {
    PRE_RENDER_PRIORITY_LOW = 0, /**< Append the request to the list */
    PRE_RENDER_PRIORITY_HIGH     /**< Prepend the request to the list */
};

struct _Ewk_Tiled_Backing_Store_Item {
    EINA_INLIST;
    Ewk_Tile *tile;
    struct {
        Evas_Coord x, y, w, h;
    } geometry;
    struct {
        Eina_List *process;
        unsigned long row, col;
        float zoom;
    } update;
    Eina_Bool smooth_scale;
};

struct _Ewk_Tiled_Backing_Store_Pre_Render_Request {
    EINA_INLIST;
    unsigned long col, row;
    float zoom;
};

struct _Ewk_Tiled_Backing_Store_Data {
    Evas_Object_Smart_Clipped_Data base;
    Evas_Object *self;
    Evas_Object *contents_clipper;
    struct {
        Eina_Inlist **items;
        Evas_Coord x, y, w, h;
        long cols, rows;
        struct {
            Evas_Coord w, h;
            float zoom;
            Eina_Bool zoom_weak_smooth_scale:1;
        } tile;
        struct {
            struct {
                Evas_Coord x, y;
            } cur, old, base, zoom_center;
        } offset;
    } view;
    Evas_Colorspace cspace;
    struct {
        Ewk_Tile_Matrix *matrix;
        struct {
            unsigned long col, row;
        } base;
        struct {
            unsigned long cols, rows;
        } cur, old;
        Evas_Coord width, height;
    } model;
    struct {
        Eina_Bool (*cb)(void *data, Ewk_Tile *t, const Eina_Rectangle *area);
        void *data;
        Eina_List *queue;
        Eina_Bool process_entire_queue;
        Eina_Inlist *pre_render_requests;
        Ecore_Idler *idler;
        Eina_Bool disabled;
        Eina_Bool suspend:1;
    } render;
    struct {
        void *(*pre_cb)(void *data, Evas_Object *o);
        void *pre_data;
        void *(*post_cb)(void *data, void *pre_data, Evas_Object *o);
        void *post_data;
    } process;
    struct {
        Eina_Bool any:1;
        Eina_Bool pos:1;
        Eina_Bool size:1;
        Eina_Bool model:1;
        Eina_Bool offset:1;
    } changed;
#ifdef DEBUG_MEM_LEAKS
    Ecore_Event_Handler *sig_usr;
#endif
};

static Evas_Smart_Class _parent_sc = EVAS_SMART_CLASS_INIT_NULL;
int _ewk_tiled_log_dom = -1;

#define PRIV_DATA_GET_OR_RETURN(obj, ptr, ...)                       \
    Ewk_Tiled_Backing_Store_Data *ptr = evas_object_smart_data_get(obj); \
    if (!ptr) {                                                      \
        CRITICAL("no private data in obj=%p", obj);                  \
        return __VA_ARGS__;                                          \
    }

static inline void _ewk_tiled_backing_store_item_request_del(Ewk_Tiled_Backing_Store_Data *priv, Ewk_Tiled_Backing_Store_Item *it);
static inline void _ewk_tiled_backing_store_item_request_add(Ewk_Tiled_Backing_Store_Data *priv, Ewk_Tiled_Backing_Store_Item *it, int m_col, int m_row, float zoom);
static void _ewk_tiled_backing_store_fill_renderers(Ewk_Tiled_Backing_Store_Data *priv);
static inline void _ewk_tiled_backing_store_view_dbg(const Ewk_Tiled_Backing_Store_Data *priv);
static inline void _ewk_tiled_backing_store_changed(Ewk_Tiled_Backing_Store_Data *priv);

static inline void _ewk_tiled_backing_store_updates_process(Ewk_Tiled_Backing_Store_Data *priv)
{
    void *data = NULL;

    /* Do not process updates. Note that we still want to get updates requests
     * in the queue in order to not miss any updates after the render is
     * resumed.
     */
    if (priv->render.suspend || !evas_object_visible_get(priv->self))
        return;

    if (priv->process.pre_cb)
        data = priv->process.pre_cb(priv->process.pre_data, priv->self);

    ewk_tile_matrix_updates_process(priv->model.matrix);

    if (priv->process.post_cb)
        priv->process.post_cb(priv->process.post_data, data, priv->self);
}

static int _ewk_tiled_backing_store_flush(void *data)
{
    Ewk_Tiled_Backing_Store_Data *priv = data;
    Ewk_Tile_Unused_Cache *tuc = ewk_tile_matrix_unused_cache_get(priv->model.matrix);

    if (tuc) {
        DBG("flush unused tile cache.");
        ewk_tile_unused_cache_auto_flush(tuc);
    } else
        ERR("no cache?!");

    return 0;
}

static Ewk_Tile *_ewk_tiled_backing_store_tile_new(Ewk_Tiled_Backing_Store_Data *priv, unsigned long col, unsigned long row, float zoom)
{
    Ewk_Tile *t;
    Evas *evas = evas_object_evas_get(priv->self);
    if (!evas) {
        CRITICAL("evas_object_evas_get failed!");
        return NULL;
    }

    t = ewk_tile_matrix_tile_new
        (priv->model.matrix, evas, col, row, zoom);

    if (!t) {
        CRITICAL("ewk_tile_matrix_tile_new failed!");
        return NULL;
    }

    return t;
}

static void _ewk_tiled_backing_store_item_move(Ewk_Tiled_Backing_Store_Item *it, Evas_Coord x, Evas_Coord y)
{
    it->geometry.x = x;
    it->geometry.y = y;

    if (it->tile)
        evas_object_move(it->tile->image, x, y);
}

static void _ewk_tiled_backing_store_item_resize(Ewk_Tiled_Backing_Store_Item *it, Evas_Coord w, Evas_Coord h)
{
    it->geometry.w = w;
    it->geometry.h = h;

    if (it->tile) {
        evas_object_resize(it->tile->image, w, h);
        evas_object_image_fill_set(it->tile->image, 0, 0, w, h);
    }
}

static void _ewk_tiled_backing_store_tile_associate(Ewk_Tiled_Backing_Store_Data *priv, Ewk_Tile *t, Ewk_Tiled_Backing_Store_Item *it)
{
    if (it->tile)
        CRITICAL("it->tile=%p, but it should be NULL!", it->tile);
    it->tile = t;
    evas_object_move(it->tile->image, it->geometry.x, it->geometry.y);
    evas_object_resize(it->tile->image, it->geometry.w, it->geometry.h);
    evas_object_image_fill_set
        (it->tile->image, 0, 0, it->geometry.w, it->geometry.h);
    evas_object_image_smooth_scale_set(it->tile->image, it->smooth_scale);

    if (!ewk_tile_visible_get(t))
        evas_object_smart_member_add(t->image, priv->self);

    ewk_tile_show(t);
}

static void _ewk_tiled_backing_store_tile_dissociate(Ewk_Tiled_Backing_Store_Data *priv, Ewk_Tiled_Backing_Store_Item *it, double last_used)
{
    Ewk_Tile_Unused_Cache *tuc;
    ewk_tile_hide(it->tile);
    if (!ewk_tile_visible_get(it->tile))
        evas_object_smart_member_del(it->tile->image);
    ewk_tile_matrix_tile_put(priv->model.matrix, it->tile, last_used);
    tuc = ewk_tile_matrix_unused_cache_get(priv->model.matrix);
    ewk_tile_unused_cache_auto_flush(tuc);

    it->tile = NULL;
}

static void _ewk_tiled_backing_store_tile_dissociate_all(Ewk_Tiled_Backing_Store_Data *priv)
{
    Eina_Inlist *it;
    Ewk_Tiled_Backing_Store_Item *item;
    int i;
    double last_used = ecore_loop_time_get();

    for (i = 0; i < priv->view.rows; i++) {
        it = priv->view.items[i];
        EINA_INLIST_FOREACH(it, item)
            if (item->tile)
                _ewk_tiled_backing_store_tile_dissociate(priv, item, last_used);
    }
}

static inline Eina_Bool _ewk_tiled_backing_store_pre_render_request_add(Ewk_Tiled_Backing_Store_Data *priv, unsigned long col, unsigned long row, float zoom, Ewk_Tiled_Backing_Store_Pre_Render_Priority priority)
{
    Ewk_Tiled_Backing_Store_Pre_Render_Request *r;

    MALLOC_OR_OOM_RET(r, sizeof(*r), EINA_FALSE);

    if (priority == PRE_RENDER_PRIORITY_HIGH)
        priv->render.pre_render_requests = eina_inlist_prepend
            (priv->render.pre_render_requests, EINA_INLIST_GET(r));
    else
        priv->render.pre_render_requests = eina_inlist_append
            (priv->render.pre_render_requests, EINA_INLIST_GET(r));

    r->col = col;
    r->row = row;
    r->zoom = zoom;

    return EINA_TRUE;
}

static inline void _ewk_tiled_backing_store_pre_render_request_del(Ewk_Tiled_Backing_Store_Data *priv, Ewk_Tiled_Backing_Store_Pre_Render_Request *r)
{
    priv->render.pre_render_requests = eina_inlist_remove
        (priv->render.pre_render_requests, EINA_INLIST_GET(r));
    free(r);
}

static inline Ewk_Tiled_Backing_Store_Pre_Render_Request *_ewk_tiled_backing_store_pre_render_request_first(const Ewk_Tiled_Backing_Store_Data *priv)
{
    return EINA_INLIST_CONTAINER_GET(
        priv->render.pre_render_requests,
        Ewk_Tiled_Backing_Store_Pre_Render_Request);
}

static void _ewk_tiled_backing_store_pre_render_request_flush(Ewk_Tiled_Backing_Store_Data *priv)
{
    Eina_Inlist **pl = &priv->render.pre_render_requests;
    while (*pl) {
        Ewk_Tiled_Backing_Store_Pre_Render_Request *r;
        r = _ewk_tiled_backing_store_pre_render_request_first(priv);
        *pl = eina_inlist_remove(*pl, *pl);
        free(r);
    }
}

static void _ewk_tiled_backing_store_pre_render_request_clear(Ewk_Tiled_Backing_Store_Data *priv)
{
    Eina_Inlist **pl = &priv->render.pre_render_requests;
    Eina_Inlist *iter = *pl, *tmp;
    while (iter) {
        Ewk_Tiled_Backing_Store_Pre_Render_Request *r =
            EINA_INLIST_CONTAINER_GET(
                iter, Ewk_Tiled_Backing_Store_Pre_Render_Request);
        tmp = iter->next;
        *pl = eina_inlist_remove(*pl, iter);
        iter = tmp;
        free(r);
    }
}

/* assumes priv->process.pre_cb was called if required! */
static void _ewk_tiled_backing_store_pre_render_request_process_single(Ewk_Tiled_Backing_Store_Data *priv)
{
    Ewk_Tiled_Backing_Store_Pre_Render_Request *req;
    Eina_Rectangle area;
    Ewk_Tile_Matrix *tm = priv->model.matrix;
    Ewk_Tile *t;
    Ewk_Tile_Unused_Cache *tuc;
    unsigned long col, row;
    float zoom;
    double last_used = ecore_loop_time_get();

    req = _ewk_tiled_backing_store_pre_render_request_first(priv);
    if (!req)
        return;

    col = req->col;
    row = req->row;
    zoom = req->zoom;

    if (ewk_tile_matrix_tile_exact_exists(tm, col, row, zoom)) {
        DBG("no pre-render required for tile %lu,%lu @ %f.", col, row, zoom);
        goto end;
    }

    t = _ewk_tiled_backing_store_tile_new(priv, col, row, zoom);
    if (!t)
        goto end;

    area.x = 0;
    area.y = 0;
    area.w = priv->view.tile.w;
    area.h = priv->view.tile.h;

    priv->render.cb(priv->render.data, t, &area);
    evas_object_image_data_update_add(
        t->image,
        area.x, area.y, area.w, area.h);
    ewk_tile_matrix_tile_updates_clear(tm, t);

    ewk_tile_matrix_tile_put(tm, t, last_used);

end:
    _ewk_tiled_backing_store_pre_render_request_del(priv, req);
    tuc = ewk_tile_matrix_unused_cache_get(priv->model.matrix);
    ewk_tile_unused_cache_auto_flush(tuc);
}

static Eina_Bool _ewk_tiled_backing_store_item_process_idler_cb(void *data)
{
    Ewk_Tiled_Backing_Store_Data *priv = data;
    Ewk_Tiled_Backing_Store_Item *it = NULL;

    while (priv->render.queue) {
        it = priv->render.queue->data;
        if (it->tile->zoom == priv->view.tile.zoom) {
            _ewk_tiled_backing_store_item_request_del(priv, it);
            it = NULL;
        } else {
            unsigned long row, col;
            float zoom;
            Ewk_Tile *t;
            if (it->tile) {
                double last_used = ecore_loop_time_get();
                _ewk_tiled_backing_store_tile_dissociate(priv, it, last_used);
            }

            row = it->update.row;
            col = it->update.col;
            zoom = it->update.zoom;
            t = _ewk_tiled_backing_store_tile_new(priv, col, row, zoom);
            if (!t) {
                priv->render.idler = NULL;
                return EINA_FALSE;
            }

            _ewk_tiled_backing_store_tile_associate(priv, t, it);
            it->update.process = NULL;
            priv->render.queue = eina_list_remove_list(priv->render.queue,
                                                       priv->render.queue);
            if (!priv->render.process_entire_queue)
                break;
        }
    }

    if (priv->process.pre_cb)
        data = priv->process.pre_cb(priv->process.pre_data, priv->self);

    ewk_tile_matrix_updates_process(priv->model.matrix);

    if (!it)
        _ewk_tiled_backing_store_pre_render_request_process_single(priv);

    if (priv->process.post_cb)
        priv->process.post_cb(priv->process.post_data, data, priv->self);

    if (!priv->render.queue && !priv->render.pre_render_requests) {
        priv->render.idler = NULL;
        return EINA_FALSE;
    }

    return EINA_TRUE;
}

static inline void _ewk_tiled_backing_store_item_process_idler_stop(Ewk_Tiled_Backing_Store_Data *priv)
{
    if (!priv->render.idler)
        return;

    ecore_idler_del(priv->render.idler);
    priv->render.idler = NULL;
}

static inline void _ewk_tiled_backing_store_item_process_idler_start(Ewk_Tiled_Backing_Store_Data *priv)
{
    if (priv->render.idler)
        return;
    priv->render.idler = ecore_idler_add(
        _ewk_tiled_backing_store_item_process_idler_cb, priv);
}

static inline void _ewk_tiled_backing_store_item_request_del(Ewk_Tiled_Backing_Store_Data *priv, Ewk_Tiled_Backing_Store_Item *it)
{
    priv->render.queue = eina_list_remove_list(priv->render.queue,
                                               it->update.process);
    it->update.process = NULL;
}

static inline void _ewk_tiled_backing_store_item_request_add(Ewk_Tiled_Backing_Store_Data *priv, Ewk_Tiled_Backing_Store_Item *it, int m_col, int m_row, float zoom)
{
    if (it->update.process)
        return;

    it->update.col = m_col;
    it->update.row = m_row;
    it->update.zoom = zoom;

    priv->render.queue = eina_list_append(priv->render.queue, it);
    it->update.process = eina_list_last(priv->render.queue);

    if (!priv->render.suspend)
        _ewk_tiled_backing_store_item_process_idler_start(priv);
}

static Eina_Bool _ewk_tiled_backing_store_disable_render(Ewk_Tiled_Backing_Store_Data *priv)
{
    if (priv->render.suspend)
        return EINA_TRUE;

    priv->render.suspend = EINA_TRUE;
    _ewk_tiled_backing_store_item_process_idler_stop(priv);
    return EINA_TRUE;
}

static Eina_Bool _ewk_tiled_backing_store_enable_render(Ewk_Tiled_Backing_Store_Data *priv)
{
    if (!priv->render.suspend)
        return EINA_TRUE;

    priv->render.suspend = EINA_FALSE;

    _ewk_tiled_backing_store_fill_renderers(priv);
    _ewk_tiled_backing_store_item_process_idler_start(priv);

    return EINA_TRUE;
}

static inline Eina_Bool _ewk_tiled_backing_store_item_fill(Ewk_Tiled_Backing_Store_Data *priv, Ewk_Tiled_Backing_Store_Item *it, long col, int row)
{
    long m_col = priv->model.base.col + col;
    long m_row = priv->model.base.row + row;
    double last_used = ecore_loop_time_get();

    if (m_col < 0 || m_row < 0
        || (unsigned long)(m_col) >= priv->model.cur.cols
        || (unsigned long)(m_row) >= priv->model.cur.rows) {

        if (it->tile) {
            _ewk_tiled_backing_store_tile_dissociate(priv, it, last_used);
            if (it->update.process)
                _ewk_tiled_backing_store_item_request_del(priv, it);
        }
    } else {
        Ewk_Tile *t;
        const float zoom = priv->view.tile.zoom;

        if (it->update.process) {
            if (it->update.row == (unsigned long)(m_row)
                && it->update.col == (unsigned long)(m_col)
                && it->update.zoom == zoom)
                return EINA_TRUE;

            _ewk_tiled_backing_store_item_request_del(priv, it);
        }

        if (it->tile) {
            Ewk_Tile *old = it->tile;
            if (old->row != (unsigned long)(m_row)
                || old->col != (unsigned long)(m_col)
                || old->zoom != zoom) {
                _ewk_tiled_backing_store_tile_dissociate(priv, it,
                                                         last_used);
                if (it->update.process)
                    _ewk_tiled_backing_store_item_request_del(priv, it);
            } else if (old->row == (unsigned long)(m_row)
                       && old->col == (unsigned long)(m_col)
                       && old->zoom == zoom)
                goto end;
        }

        t = ewk_tile_matrix_tile_exact_get
            (priv->model.matrix, m_col, m_row, zoom);
        if (!t) {
            /* NOTE: it never returns NULL if it->tile was set! */
            if (it->tile) {
                CRITICAL("it->tile=%p, but it should be NULL!", it->tile);
                _ewk_tiled_backing_store_tile_dissociate(priv, it,
                                                         last_used);
            }

            /* Do not add new requests to the render queue */
            if (!priv->render.suspend) {
                t = _ewk_tiled_backing_store_tile_new(priv, m_col, m_row, zoom);
                if (!t)
                    return EINA_FALSE;
                _ewk_tiled_backing_store_tile_associate(priv, t, it);
            }
        } else if (t != it->tile) {
            if (!it->update.process) {
                if (it->tile)
                    _ewk_tiled_backing_store_tile_dissociate(priv,
                                                             it, last_used);
                _ewk_tiled_backing_store_tile_associate(priv, t, it);
            }
        }

      end:

        return EINA_TRUE;
    }

    return EINA_TRUE;
}

static Ewk_Tiled_Backing_Store_Item *_ewk_tiled_backing_store_item_add(Ewk_Tiled_Backing_Store_Data *priv, long col, int row)
{
    Ewk_Tiled_Backing_Store_Item *it;
    Evas_Coord x, y, tw, th;

    DBG("o=%p", priv->self);

    MALLOC_OR_OOM_RET(it, sizeof(*it), NULL);

    tw = priv->view.tile.w;
    th = priv->view.tile.h;
    x = priv->view.offset.base.x + priv->view.x + tw  *col;
    y = priv->view.offset.base.y + priv->view.y + th  *row;

    it->tile = NULL;
    it->update.process = NULL;
    it->smooth_scale = priv->view.tile.zoom_weak_smooth_scale;
    _ewk_tiled_backing_store_item_move(it, x, y);
    _ewk_tiled_backing_store_item_resize(it, tw, th);
    if (!_ewk_tiled_backing_store_item_fill(priv, it, col, row)) {
        free(it);
        return NULL;
    }

    return it;
}

static void _ewk_tiled_backing_store_item_del(Ewk_Tiled_Backing_Store_Data *priv, Ewk_Tiled_Backing_Store_Item *it)
{
    if (it->tile) {
        double last_used = ecore_loop_time_get();
        _ewk_tiled_backing_store_tile_dissociate(priv, it, last_used);
    }
    if (it->update.process)
        _ewk_tiled_backing_store_item_request_del(priv, it);
    free(it);
}

static void _ewk_tiled_backing_store_item_smooth_scale_set(Ewk_Tiled_Backing_Store_Item *it, Eina_Bool smooth_scale)
{
    if (it->smooth_scale == smooth_scale)
        return;

    if (it->tile)
        evas_object_image_smooth_scale_set(it->tile->image, smooth_scale);
}

static inline void _ewk_tiled_backing_store_changed(Ewk_Tiled_Backing_Store_Data *priv)
{
    if (priv->changed.any)
        return;
    evas_object_smart_changed(priv->self);
    priv->changed.any = EINA_TRUE;
}

static void _ewk_tiled_backing_store_view_cols_end_del(Ewk_Tiled_Backing_Store_Data *priv, Eina_Inlist **p_row, unsigned int count)
{
    Eina_Inlist *n;
    unsigned int i;

    if (!count)
        return;

    n = (*p_row)->last;

    for (i = 0; i < count; i++) {
        Ewk_Tiled_Backing_Store_Item *it;
        it = EINA_INLIST_CONTAINER_GET(n, Ewk_Tiled_Backing_Store_Item);
        n = n->prev;
        *p_row = eina_inlist_remove(*p_row, EINA_INLIST_GET(it));
        _ewk_tiled_backing_store_item_del(priv, it);
    }
}

static Eina_Bool _ewk_tiled_backing_store_view_cols_end_add(Ewk_Tiled_Backing_Store_Data *priv, Eina_Inlist **p_row, unsigned int base_col, unsigned int count)
{
    unsigned int i, r = p_row - priv->view.items;

    for (i = 0; i < count; i++, base_col++) {
        Ewk_Tiled_Backing_Store_Item *it;

        it = _ewk_tiled_backing_store_item_add(priv, base_col, r);
        if (!it) {
            CRITICAL("failed to add column %u of %u in row %u.", i, count, r);
            _ewk_tiled_backing_store_view_cols_end_del(priv, p_row, i);
            return EINA_FALSE;
        }

        *p_row = eina_inlist_append(*p_row, EINA_INLIST_GET(it));
    }
    return EINA_TRUE;
}

static void _ewk_tiled_backing_store_view_row_del(Ewk_Tiled_Backing_Store_Data *priv, Eina_Inlist *row)
{
    while (row) {
        Ewk_Tiled_Backing_Store_Item *it;
        it = EINA_INLIST_CONTAINER_GET(row, Ewk_Tiled_Backing_Store_Item);
        row = row->next;
        _ewk_tiled_backing_store_item_del(priv, it);
    }
}

static void _ewk_tiled_backing_store_view_rows_range_del(Ewk_Tiled_Backing_Store_Data *priv, Eina_Inlist **start, Eina_Inlist **end)
{
    for (; start < end; start++) {
        _ewk_tiled_backing_store_view_row_del(priv, *start);
        *start = NULL;
    }
}

static void _ewk_tiled_backing_store_view_rows_all_del(Ewk_Tiled_Backing_Store_Data *priv)
{
    Eina_Inlist **start;
    Eina_Inlist **end;

    start = priv->view.items;
    end = priv->view.items + priv->view.rows;
    _ewk_tiled_backing_store_view_rows_range_del(priv, start, end);

    free(priv->view.items);
    priv->view.items = NULL;
    priv->view.cols = 0;
    priv->view.rows = 0;
}

static void _ewk_tiled_backing_store_render(void *data, Ewk_Tile *t, const Eina_Rectangle *area)
{
    Ewk_Tiled_Backing_Store_Data *priv = data;

    INF("TODO %p (visible? %d) [%lu,%lu] %d,%d + %dx%d",
        t, t->visible, t->col, t->row, area->x, area->y, area->w, area->h);

    if (!t->visible)
        return;

    if (priv->view.tile.w != t->w || priv->view.tile.h != t->h)
        return; // todo: remove me later, don't even flag as dirty!

    EINA_SAFETY_ON_NULL_RETURN(priv->render.cb);
    if (!priv->render.cb(priv->render.data, t, area))
        return;

    evas_object_image_data_update_add(t->image, area->x, area->y, area->w, area->h);
}

static inline void _ewk_tiled_backing_store_model_matrix_create(Ewk_Tiled_Backing_Store_Data *priv, Ewk_Tile_Unused_Cache *tuc)
{
    if (priv->model.matrix) {
        _ewk_tiled_backing_store_view_rows_all_del(priv);

        priv->changed.offset = EINA_FALSE;
        priv->changed.size = EINA_TRUE;

        ewk_tile_matrix_free(priv->model.matrix);
    }

    priv->model.matrix = ewk_tile_matrix_new
        (tuc, priv->model.cur.cols, priv->model.cur.rows, priv->cspace,
         _ewk_tiled_backing_store_render, priv);
}

static void _ewk_tiled_backing_store_smart_member_del(Evas_Object *o, Evas_Object *member)
{
    PRIV_DATA_GET_OR_RETURN(o, priv);
    if (!priv->contents_clipper)
        return;
    evas_object_clip_unset(member);
    if (!evas_object_clipees_get(priv->contents_clipper))
        evas_object_hide(priv->contents_clipper);
}

static void _ewk_tiled_backing_store_smart_member_add(Evas_Object *o, Evas_Object *member)
{
    PRIV_DATA_GET_OR_RETURN(o, priv);
    if (!priv->contents_clipper)
        return;
    evas_object_clip_set(member, priv->contents_clipper);
    if (evas_object_visible_get(o))
        evas_object_show(priv->contents_clipper);
}

#ifdef DEBUG_MEM_LEAKS
static void _ewk_tiled_backing_store_mem_dbg(Ewk_Tiled_Backing_Store_Data *priv)
{
    static int run = 0;

    run++;

    printf("\n--- BEGIN DEBUG TILED BACKING STORE MEMORY [%d] --\n"
           "t=%0.2f, obj=%p, priv=%p, view.items=%p, matrix=%p\n",
           run, ecore_loop_time_get(),
           priv->self, priv, priv->view.items, priv->model.matrix);

    ewk_tile_matrix_dbg(priv->model.matrix);
    ewk_tile_accounting_dbg();

    printf("--- END DEBUG TILED BACKING STORE MEMORY [%d] --\n\n", run);
}

static Eina_Bool _ewk_tiled_backing_store_sig_usr(void *data, int type, void *event)
{
    Ecore_Event_Signal_User *sig = (Ecore_Event_Signal_User*)event;
    Ewk_Tiled_Backing_Store_Data *priv = (Ewk_Tiled_Backing_Store_Data*)data;

    if (sig->number == 2) {
        Ewk_Tile_Unused_Cache *tuc;
        tuc = ewk_tile_matrix_unused_cache_get(priv->model.matrix);
        ewk_tile_unused_cache_auto_flush(tuc);
    }

    _ewk_tiled_backing_store_view_dbg(priv);
    _ewk_tiled_backing_store_mem_dbg(priv);
    return EINA_TRUE;
}
#endif

static void _ewk_tiled_backing_store_smart_add(Evas_Object *o)
{
    Ewk_Tiled_Backing_Store_Data *priv;

    DBG("o=%p", o);

    CALLOC_OR_OOM_RET(priv, sizeof(*priv));

    priv->self = o;
    priv->view.tile.zoom = 1.0;
    priv->view.tile.w = TILE_W;
    priv->view.tile.h = TILE_H;
    priv->view.offset.cur.x = 0;
    priv->view.offset.cur.y = 0;
    priv->view.offset.old.x = 0;
    priv->view.offset.old.y = 0;
    priv->view.offset.base.x = 0;
    priv->view.offset.base.y = 0;

    priv->model.base.col = 0;
    priv->model.base.row = 0;
    priv->model.cur.cols = 1;
    priv->model.cur.rows = 1;
    priv->model.old.cols = 0;
    priv->model.old.rows = 0;
    priv->model.width = 0;
    priv->model.height = 0;
    priv->render.process_entire_queue = EINA_TRUE;
    priv->render.suspend = EINA_FALSE;
    priv->cspace = EVAS_COLORSPACE_ARGB8888; // TODO: detect it.

    evas_object_smart_data_set(o, priv);
    _parent_sc.add(o);

    priv->contents_clipper = evas_object_rectangle_add(
        evas_object_evas_get(o));
    evas_object_move(priv->contents_clipper, 0, 0);
    evas_object_resize(priv->contents_clipper,
                       priv->model.width, priv->model.height);
    evas_object_color_set(priv->contents_clipper, 255, 255, 255, 255);
    evas_object_show(priv->contents_clipper);
    evas_object_smart_member_add(priv->contents_clipper, o);

    _ewk_tiled_backing_store_model_matrix_create(priv, NULL);
    evas_object_move(priv->base.clipper, 0, 0);
    evas_object_resize(priv->base.clipper, 0, 0);
    evas_object_clip_set(priv->contents_clipper, priv->base.clipper);

#ifdef DEBUG_MEM_LEAKS
    priv->sig_usr = ecore_event_handler_add
        (ECORE_EVENT_SIGNAL_USER, _ewk_tiled_backing_store_sig_usr, priv);
#endif
}

static void _ewk_tiled_backing_store_smart_del(Evas_Object *o)
{
    PRIV_DATA_GET_OR_RETURN(o, priv);
    DBG("o=%p", o);
    Ewk_Tile_Unused_Cache *tuc;

    tuc = ewk_tile_matrix_unused_cache_get(priv->model.matrix);
    ewk_tile_unused_cache_unlock_area(tuc);

    _ewk_tiled_backing_store_flush(priv);

    _ewk_tiled_backing_store_pre_render_request_flush(priv);
    _ewk_tiled_backing_store_item_process_idler_stop(priv);
    _ewk_tiled_backing_store_view_rows_all_del(priv);

#ifdef DEBUG_MEM_LEAKS
    _ewk_tiled_backing_store_mem_dbg(priv);
    if (priv->sig_usr)
        priv->sig_usr = ecore_event_handler_del(priv->sig_usr);
#endif

    ewk_tile_matrix_free(priv->model.matrix);
    evas_object_smart_member_del(priv->contents_clipper);
    evas_object_del(priv->contents_clipper);

    _parent_sc.del(o);

#ifdef DEBUG_MEM_LEAKS
    printf("\nIMPORTANT: TILED BACKING STORE DELETED (may be real leaks)\n");
    ewk_tile_accounting_dbg();
#endif
}

static void _ewk_tiled_backing_store_smart_move(Evas_Object *o, Evas_Coord x, Evas_Coord y)
{
    DBG("o=%p, new pos: %dx%d", o, x, y);

    PRIV_DATA_GET_OR_RETURN(o, priv);

    if (priv->changed.pos)
        return;

    if (priv->view.x == x && priv->view.y == y)
        return;

    priv->changed.pos = EINA_TRUE;
    _ewk_tiled_backing_store_changed(priv);
}

static void _ewk_tiled_backing_store_smart_resize(Evas_Object *o, Evas_Coord w, Evas_Coord h)
{
    DBG("o=%p, new size: %dx%d", o, w, h);

    PRIV_DATA_GET_OR_RETURN(o, priv);

    if (priv->changed.size)
        return;

    if (priv->view.w == w && priv->view.h == h)
        return;

    priv->changed.size = EINA_TRUE;
    _ewk_tiled_backing_store_changed(priv);
}

static void _ewk_tiled_backing_store_recalc_renderers(Ewk_Tiled_Backing_Store_Data *priv, Evas_Coord w, Evas_Coord h, Evas_Coord tw, Evas_Coord th)
{
    long cols, rows, old_rows, old_cols;
    INF("o=%p, new size: %dx%d", priv->self, w, h);

    cols = 1 + (int)ceil((float)w / (float)tw);
    rows = 1 + (int)ceil((float)h / (float)th);

    INF("o=%p new grid size cols: %ld, rows: %ld, was %ld, %ld",
        priv->self, cols, rows, priv->view.cols, priv->view.rows);

    if (priv->view.cols == cols && priv->view.rows == rows)
        return;

    old_cols = priv->view.cols;
    old_rows = priv->view.rows;

    if (rows < old_rows) {
        Eina_Inlist **start, **end;
        start = priv->view.items + rows;
        end = priv->view.items + old_rows;
        _ewk_tiled_backing_store_view_rows_range_del(priv, start, end);
    }
    REALLOC_OR_OOM_RET(priv->view.items, sizeof(Eina_Inlist*) * (int)rows);
    priv->view.rows = rows;
    priv->view.cols = cols;
    if (rows > old_rows) {
        Eina_Inlist **start, **end;
        start = priv->view.items + old_rows;
        end = priv->view.items + rows;
        for (; start < end; start++) {
            Eina_Bool r;
            *start = NULL;
            r = _ewk_tiled_backing_store_view_cols_end_add
                (priv, start, 0, cols);
            if (!r) {
                CRITICAL("failed to allocate %ld columns", cols);
                _ewk_tiled_backing_store_view_rows_range_del
                    (priv, priv->view.items + old_rows, start);
                priv->view.rows = old_rows;
                return;
            }
        }
    }

    if (cols != old_cols) {
        Eina_Inlist **start, **end;
        int todo = cols - old_cols;
        start = priv->view.items;
        end = start + MIN(old_rows, rows);
        if (todo > 0) {
            for (; start < end; start++) {
                Eina_Bool r;
                r = _ewk_tiled_backing_store_view_cols_end_add
                    (priv, start, old_cols, todo);
                if (!r) {
                    CRITICAL("failed to allocate %d columns!", todo);

                    for (start--; start >= priv->view.items; start--)
                        _ewk_tiled_backing_store_view_cols_end_del(priv, start, todo);
                    if (rows > old_rows) {
                        start = priv->view.items + old_rows;
                        end = priv->view.items + rows;
                        for (; start < end; start++)
                            _ewk_tiled_backing_store_view_cols_end_del(priv, start, todo);
                    }
                    return;
                }
            }
        } else if (todo < 0) {
            todo = -todo;
            for (; start < end; start++)
                _ewk_tiled_backing_store_view_cols_end_del(priv, start, todo);
        }
    }

    _ewk_tiled_backing_store_fill_renderers(priv);
}

static void _ewk_tiled_backing_store_smart_calculate_size(Ewk_Tiled_Backing_Store_Data *priv, Evas_Coord w, Evas_Coord h)
{
    evas_object_resize(priv->base.clipper, w, h);

    priv->view.w = w;
    priv->view.h = h;

    _ewk_tiled_backing_store_recalc_renderers(
        priv, w, h, priv->view.tile.w, priv->view.tile.h);
}

// TODO: remove me later.
static inline void _ewk_tiled_backing_store_view_dbg(const Ewk_Tiled_Backing_Store_Data *priv)
{
    Eina_Inlist **start, **end;
    printf("tiles=%2ld,%2ld  model=%2ld,%2ld [%dx%d] base=%+3ld,%+4ld offset=%+4d,%+4d old=%+4d,%+4d base=%+3d,%+3d\n",
           priv->view.cols, priv->view.rows,
           priv->model.cur.cols, priv->model.cur.rows,
           priv->model.width, priv->model.height,
           priv->model.base.col, priv->model.base.row,
           priv->view.offset.cur.x, priv->view.offset.cur.y,
           priv->view.offset.old.x, priv->view.offset.old.y,
           priv->view.offset.base.x, priv->view.offset.base.y);

    start = priv->view.items;
    end = priv->view.items + priv->view.rows;
    for (; start < end; start++) {
        const Ewk_Tiled_Backing_Store_Item *it;

        EINA_INLIST_FOREACH(*start, it) {
            printf(" %+4d,%+4d ", it->geometry.x, it->geometry.y);

            if (!it->tile)
                printf("            ;");
            else
                printf("%8p %lu,%lu;", it->tile, it->tile->col, it->tile->row);
        }
        printf("\n");
    }
    printf("---\n");
}

/**
 * @internal
 * Move top row down as last.
 *
 * The final result is visually the same, but logically the top that
 * went out of screen is now at bottom and filled with new model items.
 *
 * This is worth just when @a count is smaller than @c
 * priv->view.rows, after that one is refilling the whole matrix so it
 * is better to trigger full refill.
 *
 * @param count the number of times to repeat the process.
 */
static void _ewk_tiled_backing_store_view_wrap_up(Ewk_Tiled_Backing_Store_Data *priv, Evas_Coord x, Evas_Coord y, unsigned int count)
{
    unsigned int last_row = priv->view.rows - 1;
    Evas_Coord tw = priv->view.tile.w;
    Evas_Coord th = priv->view.tile.h;
    Evas_Coord off_y = priv->view.offset.base.y + count * th;
    Evas_Coord oy = y + (last_row - count + 1) * th + off_y;
    Eina_Inlist **itr_start, **itr_end;

    itr_start = priv->view.items;
    itr_end = itr_start + last_row;

    for (; count > 0; count--) {
        Eina_Inlist **itr;
        Eina_Inlist *tmp = *itr_start;
        Ewk_Tiled_Backing_Store_Item *it;
        Evas_Coord ox = x + priv->view.offset.base.x;
        int c = 0;

        for (itr = itr_start; itr < itr_end; itr++)
            *itr = *(itr + 1);
        *itr = tmp;

        priv->model.base.row++;
        EINA_INLIST_FOREACH(tmp, it) {
            _ewk_tiled_backing_store_item_move(it, ox, oy);
            ox += tw;
            _ewk_tiled_backing_store_item_fill(priv, it, c, last_row);
            c++;
        }
        oy += th;
    }
    priv->view.offset.base.y = off_y;
}

/**
 * @internal
 * Move bottom row up as first.
 *
 * The final result is visually the same, but logically the bottom that
 * went out of screen is now at top and filled with new model items.
 *
 * This is worth just when @a count is smaller than @c
 * priv->view.rows, after that one is refilling the whole matrix so it
 * is better to trigger full refill.
 *
 * @param count the number of times to repeat the process.
 */
static void _ewk_tiled_backing_store_view_wrap_down(Ewk_Tiled_Backing_Store_Data *priv, Evas_Coord x, Evas_Coord y, unsigned int count)
{
    Evas_Coord tw = priv->view.tile.w;
    Evas_Coord th = priv->view.tile.h;
    Evas_Coord off_y = priv->view.offset.base.y - count * th;
    Evas_Coord oy = y + off_y + (count - 1) * th;
    Eina_Inlist **itr_start, **itr_end;

    itr_start = priv->view.items + priv->view.rows - 1;
    itr_end = priv->view.items;

    for (; count > 0; count--) {
        Eina_Inlist **itr;
        Eina_Inlist *tmp = *itr_start;
        Ewk_Tiled_Backing_Store_Item *it;
        Evas_Coord ox = x + priv->view.offset.base.x;
        int c = 0;

        for (itr = itr_start; itr > itr_end; itr--)
            *itr = *(itr - 1);
        *itr = tmp;

        priv->model.base.row--;
        EINA_INLIST_FOREACH(tmp, it) {
            _ewk_tiled_backing_store_item_move(it, ox, oy);
            ox += tw;
            _ewk_tiled_backing_store_item_fill(priv, it, c, 0);
            c++;
        }
        oy -= th;
    }
    priv->view.offset.base.y = off_y;
}

/**
 * @internal
 * Move left-most (first) column right as last (right-most).
 *
 * The final result is visually the same, but logically the first col that
 * went out of screen is now at last and filled with new model items.
 *
 * This is worth just when @a count is smaller than @c
 * priv->view.cols, after that one is refilling the whole matrix so it
 * is better to trigger full refill.
 *
 * @param count the number of times to repeat the process.
 */
static void _ewk_tiled_backing_store_view_wrap_left(Ewk_Tiled_Backing_Store_Data *priv, Evas_Coord x, Evas_Coord y, unsigned int count)
{
    unsigned int r, last_col = priv->view.cols - 1;
    Evas_Coord tw = priv->view.tile.w;
    Evas_Coord th = priv->view.tile.h;
    Evas_Coord off_x = priv->view.offset.base.x + count * tw;
    Evas_Coord oy = y + priv->view.offset.base.y;
    Eina_Inlist **itr;
    Eina_Inlist **itr_end;

    itr = priv->view.items;
    itr_end = itr + priv->view.rows;
    r = 0;

    priv->model.base.col += count;

    for (; itr < itr_end; itr++, r++) {
        Evas_Coord ox = x + (last_col - count + 1) * tw + off_x;
        unsigned int i, c = last_col - count + 1;

        for (i = 0; i < count; i++, c++, ox += tw) {
            Ewk_Tiled_Backing_Store_Item *it;
            it = EINA_INLIST_CONTAINER_GET(*itr, Ewk_Tiled_Backing_Store_Item);
            *itr = eina_inlist_demote(*itr, *itr);

            _ewk_tiled_backing_store_item_move(it, ox, oy);
            _ewk_tiled_backing_store_item_fill(priv, it, c, r);
        }
        oy += th;
    }

    priv->view.offset.base.x = off_x;
}

/**
 * @internal
 * Move right-most (last) column left as first (left-most).
 *
 * The final result is visually the same, but logically the last col that
 * went out of screen is now at first and filled with new model items.
 *
 * This is worth just when @a count is smaller than @c
 * priv->view.cols, after that one is refilling the whole matrix so it
 * is better to trigger full refill.
 *
 * @param count the number of times to repeat the process.
 */
static void _ewk_tiled_backing_store_view_wrap_right(Ewk_Tiled_Backing_Store_Data *priv, Evas_Coord x, Evas_Coord y, unsigned int count)
{
    unsigned int r;
    Evas_Coord tw = priv->view.tile.w;
    Evas_Coord th = priv->view.tile.h;
    Evas_Coord off_x = priv->view.offset.base.x - count * tw;
    Evas_Coord oy = y + priv->view.offset.base.y;
    Eina_Inlist **itr, **itr_end;

    itr = priv->view.items;
    itr_end = itr + priv->view.rows;
    r = 0;

    priv->model.base.col -= count;

    for (; itr < itr_end; itr++, r++) {
        Evas_Coord ox = x + (count - 1) * tw + off_x;
        unsigned int i, c = count - 1;

        for (i = 0; i < count; i++, c--, ox -= tw) {
            Ewk_Tiled_Backing_Store_Item *it;
            it = EINA_INLIST_CONTAINER_GET((*itr)->last, Ewk_Tiled_Backing_Store_Item);
            *itr = eina_inlist_promote(*itr, (*itr)->last);

            _ewk_tiled_backing_store_item_move(it, ox, oy);
            _ewk_tiled_backing_store_item_fill(priv, it, c, r);
        }
        oy += th;
    }

    priv->view.offset.base.x = off_x;
}

static void _ewk_tiled_backing_store_view_refill(Ewk_Tiled_Backing_Store_Data *priv, Evas_Coord x, Evas_Coord y, int step_x, int step_y)
{
    Eina_Inlist **itr, **itr_end;
    Evas_Coord base_ox, oy, tw, th;
    unsigned int r;

    evas_object_move(priv->base.clipper, x, y);

    tw = priv->view.tile.w;
    th = priv->view.tile.h;

    base_ox = x + priv->view.offset.base.x;
    oy = y + priv->view.offset.base.y;

    itr = priv->view.items;
    itr_end = itr + priv->view.rows;
    r = 0;

    priv->model.base.col -= step_x;
    priv->model.base.row -= step_y;

    for (; itr < itr_end; itr++, r++) {
        Ewk_Tiled_Backing_Store_Item *it;
        Evas_Coord ox = base_ox;
        unsigned int c = 0;
        EINA_INLIST_FOREACH(*itr, it) {
            _ewk_tiled_backing_store_item_fill(priv, it, c, r);
            _ewk_tiled_backing_store_item_move(it, ox, oy);
            c++;
            ox += tw;
        }
        oy += th;
    }
}

static void _ewk_tiled_backing_store_view_pos_apply(Ewk_Tiled_Backing_Store_Data *priv, Evas_Coord x, Evas_Coord y)
{
    Eina_Inlist **itr, **itr_end;
    Evas_Coord base_ox, oy, tw, th;

    evas_object_move(priv->base.clipper, x, y);

    tw = priv->view.tile.w;
    th = priv->view.tile.h;

    base_ox = x + priv->view.offset.base.x;
    oy = y + priv->view.offset.base.y;

    itr = priv->view.items;
    itr_end = itr + priv->view.rows;
    for (; itr < itr_end; itr++) {
        Ewk_Tiled_Backing_Store_Item *it;
        Evas_Coord ox = base_ox;
        EINA_INLIST_FOREACH(*itr, it) {
            _ewk_tiled_backing_store_item_move(it, ox, oy);
            ox += tw;
        }
        oy += th;
    }
}

static void _ewk_tiled_backing_store_smart_calculate_offset_force(Ewk_Tiled_Backing_Store_Data *priv)
{
    Evas_Coord dx = priv->view.offset.cur.x - priv->view.offset.old.x;
    Evas_Coord dy = priv->view.offset.cur.y - priv->view.offset.old.y;
    Evas_Coord tw, th;
    int step_y, step_x;

    INF("o=%p, offset: %+4d, %+4d (%+4d, %+4d)",
        priv->self, dx, dy, priv->view.offset.cur.x, priv->view.offset.cur.y);

    tw = priv->view.tile.w;
    th = priv->view.tile.h;

    long new_col = -priv->view.offset.cur.x / tw;
    step_x = priv->model.base.col - new_col;
    long new_row = -priv->view.offset.cur.y / th;
    step_y = priv->model.base.row - new_row;

    priv->view.offset.old.x = priv->view.offset.cur.x;
    priv->view.offset.old.y = priv->view.offset.cur.y;
    evas_object_move(
        priv->contents_clipper,
        priv->view.offset.cur.x + priv->view.x,
        priv->view.offset.cur.y + priv->view.y);

    priv->view.offset.base.x += dx - step_x * tw;
    priv->view.offset.base.y += dy - step_y * th;

    _ewk_tiled_backing_store_view_refill
        (priv, priv->view.x, priv->view.y, step_x, step_y);
}

static void _ewk_tiled_backing_store_smart_calculate_offset(Ewk_Tiled_Backing_Store_Data *priv, Evas_Coord x, Evas_Coord y)
{
    Evas_Coord dx = priv->view.offset.cur.x - priv->view.offset.old.x;
    Evas_Coord dy = priv->view.offset.cur.y - priv->view.offset.old.y;
    Evas_Coord tw, th;
    int step_y, step_x;

    INF("o=%p, offset: %+4d, %+4d (%+4d, %+4d)",
        priv->self, dx, dy, priv->view.offset.cur.x, priv->view.offset.cur.y);

    if (!dx && !dy)
        return;

    tw = priv->view.tile.w;
    th = priv->view.tile.h;

    long new_col = -priv->view.offset.cur.x / tw;
    step_x = priv->model.base.col - new_col;
    long new_row = -priv->view.offset.cur.y / th;
    step_y = priv->model.base.row - new_row;

    priv->view.offset.old.x = priv->view.offset.cur.x;
    priv->view.offset.old.y = priv->view.offset.cur.y;
    evas_object_move(
        priv->contents_clipper,
        priv->view.offset.cur.x + priv->view.x,
        priv->view.offset.cur.y + priv->view.y);

    if ((step_x < 0 && step_x <= -priv->view.cols)
        || (step_x > 0 && step_x >= priv->view.cols)
        || (step_y < 0 && step_y <= -priv->view.rows)
        || (step_y > 0 && step_y >= priv->view.rows)) {

        priv->view.offset.base.x += dx - step_x * tw;
        priv->view.offset.base.y += dy - step_y * th;

        _ewk_tiled_backing_store_view_refill
            (priv, priv->view.x, priv->view.y, step_x, step_y);
        return;
    }

    priv->view.offset.base.x += dx;
    priv->view.offset.base.y += dy;

    if (step_y < 0)
        _ewk_tiled_backing_store_view_wrap_up(priv, x, y, -step_y);
    else if (step_y > 0)
        _ewk_tiled_backing_store_view_wrap_down(priv, x, y, step_y);

    if (step_x < 0)
        _ewk_tiled_backing_store_view_wrap_left(priv, x, y, -step_x);
    else if (step_x > 0)
        _ewk_tiled_backing_store_view_wrap_right(priv, x, y, step_x);

    _ewk_tiled_backing_store_view_pos_apply(priv, x, y);
}

static void _ewk_tiled_backing_store_smart_calculate_pos(Ewk_Tiled_Backing_Store_Data *priv, Evas_Coord x, Evas_Coord y)
{
    _ewk_tiled_backing_store_view_pos_apply(priv, x, y);
    priv->view.x = x;
    priv->view.y = y;
    evas_object_move(
        priv->contents_clipper,
        priv->view.offset.cur.x + priv->view.x,
        priv->view.offset.cur.y + priv->view.y);
}

static void _ewk_tiled_backing_store_fill_renderers(Ewk_Tiled_Backing_Store_Data *priv)
{
    Eina_Inlist *it;
    Ewk_Tiled_Backing_Store_Item *item;
    int i, j;

    for (i = 0; i < priv->view.rows; i++) {
        it = priv->view.items[i];
        j = 0;
        EINA_INLIST_FOREACH(it, item)
            _ewk_tiled_backing_store_item_fill(priv, item, j++, i);
    }
}

static void _ewk_tiled_backing_store_smart_calculate(Evas_Object *o)
{
    Evas_Coord x, y, w, h;

    evas_object_geometry_get(o, &x, &y, &w, &h);
    DBG("o=%p at %d,%d + %dx%d", o, x, y, w, h);

    PRIV_DATA_GET_OR_RETURN(o, priv);

    priv->changed.any = EINA_FALSE;

    ewk_tile_matrix_freeze(priv->model.matrix);

    if (!priv->render.suspend && priv->changed.model) {
        unsigned long cols, rows;

        cols = priv->model.width / priv->view.tile.w + 1;
        rows = priv->model.height / priv->view.tile.h + 1;

        priv->model.old.cols = priv->model.cur.cols;
        priv->model.old.rows = priv->model.cur.rows;
        priv->model.cur.cols = cols;
        priv->model.cur.rows = rows;
        if (priv->model.old.cols > cols)
            cols = priv->model.old.cols;
        if (priv->model.old.rows > rows)
            rows = priv->model.old.rows;
        ewk_tile_matrix_resize(priv->model.matrix, cols, rows);
    }

    if (priv->changed.pos && (priv->view.x != x || priv->view.y != y)) {
        _ewk_tiled_backing_store_smart_calculate_pos(priv, x, y);
        priv->changed.pos = EINA_FALSE;
    } else if (priv->changed.offset) {
        _ewk_tiled_backing_store_smart_calculate_offset(priv, x, y);
        priv->changed.offset = EINA_FALSE;
    }

    if (priv->changed.size) {
        _ewk_tiled_backing_store_smart_calculate_size(priv, w, h);
        priv->changed.size = EINA_FALSE;
    }

    if (!priv->render.suspend && priv->changed.model) {
        Eina_Rectangle rect;
        rect.x = 0;
        rect.y = 0;
        rect.w = priv->model.width;
        rect.h = priv->model.height;
        _ewk_tiled_backing_store_fill_renderers(priv);
        ewk_tile_matrix_resize(priv->model.matrix,
                           priv->model.cur.cols,
                           priv->model.cur.rows);
        priv->changed.model = EINA_FALSE;
        evas_object_resize(priv->contents_clipper,
                           priv->model.width, priv->model.height);
        _ewk_tiled_backing_store_smart_calculate_offset_force(priv);

        /* Make sure we do not miss any important repaint by
         * repainting the whole viewport */
        const Eina_Rectangle r =
            { 0, 0, priv->model.width, priv->model.height };
        ewk_tile_matrix_update(priv->model.matrix, &r,
                               priv->view.tile.zoom);
    }

    ewk_tile_matrix_thaw(priv->model.matrix);

    _ewk_tiled_backing_store_updates_process(priv);

    if (priv->view.offset.base.x > 0
        || priv->view.offset.base.x <= - priv->view.tile.w
        || priv->view.offset.base.y > 0
        || priv->view.offset.base.y <= - priv->view.tile.h)
        ERR("incorrect base offset %+4d,%+4d, tile=%dx%d, cur=%+4d,%+4d\n",
            priv->view.offset.base.x, priv->view.offset.base.y,
            priv->view.tile.w, priv->view.tile.h,
            priv->view.offset.cur.x, priv->view.offset.cur.y);

}

Evas_Object *ewk_tiled_backing_store_add(Evas *e)
{
    static Evas_Smart *smart = NULL;

    if (_ewk_tiled_log_dom < 0)
        _ewk_tiled_log_dom = eina_log_domain_register("Ewk_Tiled_Backing_Store", NULL);

    if (!smart) {
        static Evas_Smart_Class sc =
            EVAS_SMART_CLASS_INIT_NAME_VERSION("Ewk_Tiled_Backing_Store");

        evas_object_smart_clipped_smart_set(&sc);
        _parent_sc = sc;

        sc.add = _ewk_tiled_backing_store_smart_add;
        sc.del = _ewk_tiled_backing_store_smart_del;
        sc.resize = _ewk_tiled_backing_store_smart_resize;
        sc.move = _ewk_tiled_backing_store_smart_move;
        sc.calculate = _ewk_tiled_backing_store_smart_calculate;
        sc.member_add = _ewk_tiled_backing_store_smart_member_add;
        sc.member_del = _ewk_tiled_backing_store_smart_member_del;

        smart = evas_smart_class_new(&sc);
    }

    return evas_object_smart_add(e, smart);
}

void ewk_tiled_backing_store_render_cb_set(Evas_Object *o, Eina_Bool (*cb)(void *data, Ewk_Tile *t, const Eina_Rectangle *area), const void *data)
{
    EINA_SAFETY_ON_NULL_RETURN(cb);
    PRIV_DATA_GET_OR_RETURN(o, priv);
    priv->render.cb = cb;
    priv->render.data = (void*)data;
}

Ewk_Tile_Unused_Cache *ewk_tiled_backing_store_tile_unused_cache_get(const Evas_Object *o)
{
    PRIV_DATA_GET_OR_RETURN(o, priv, NULL);
    return ewk_tile_matrix_unused_cache_get(priv->model.matrix);
}

void ewk_tiled_backing_store_tile_unused_cache_set(Evas_Object *o, Ewk_Tile_Unused_Cache *tuc)
{
    PRIV_DATA_GET_OR_RETURN(o, priv);

    if (ewk_tile_matrix_unused_cache_get(priv->model.matrix) == tuc)
        return;

    _ewk_tiled_backing_store_model_matrix_create(priv, tuc);
}

static Eina_Bool _ewk_tiled_backing_store_scroll_full_offset_set_internal(Ewk_Tiled_Backing_Store_Data *priv, Evas_Coord x, Evas_Coord y)
{
    /* TODO: check offset go out of bounds, clamp */
    if (priv->render.disabled)
        return EINA_FALSE;

    priv->view.offset.cur.x = x;
    priv->view.offset.cur.y = y;

    priv->changed.offset = EINA_TRUE;
    _ewk_tiled_backing_store_changed(priv);

    return EINA_TRUE;
}

Eina_Bool ewk_tiled_backing_store_scroll_full_offset_set(Evas_Object *o, Evas_Coord x, Evas_Coord y)
{
    DBG("o=%p, x=%d, y=%d", o, x, y);

    PRIV_DATA_GET_OR_RETURN(o, priv, EINA_FALSE);
    if (x == priv->view.offset.cur.x && y == priv->view.offset.cur.y)
        return EINA_TRUE;

    return _ewk_tiled_backing_store_scroll_full_offset_set_internal(priv, x, y);
}

Eina_Bool ewk_tiled_backing_store_scroll_full_offset_add(Evas_Object *o, Evas_Coord dx, Evas_Coord dy)
{
    DBG("o=%p, dx=%d, dy=%d", o, dx, dy);

    PRIV_DATA_GET_OR_RETURN(o, priv, EINA_FALSE);
    if (!dx && !dy)
        return EINA_TRUE;

    return _ewk_tiled_backing_store_scroll_full_offset_set_internal
        (priv, priv->view.offset.cur.x + dx, priv->view.offset.cur.y + dy);
}

static Eina_Bool _ewk_tiled_backing_store_zoom_set_internal(Ewk_Tiled_Backing_Store_Data *priv, float *zoom, Evas_Coord cx, Evas_Coord cy, Evas_Coord *offx, Evas_Coord *offy)
{
    *offx = priv->view.offset.cur.x;
    *offy = priv->view.offset.cur.y;

    if (fabsf(priv->view.tile.zoom - *zoom) < ZOOM_STEP_MIN) {
        DBG("ignored as zoom difference is < %f: %f",
            (double)ZOOM_STEP_MIN, fabsf(priv->view.tile.zoom - *zoom));
        return EINA_TRUE;
    }

    _ewk_tiled_backing_store_pre_render_request_flush(priv);
    Evas_Coord tw, th;
    tw = TILE_SIZE_AT_ZOOM(TILE_W, *zoom);
    tw = (tw >> 1) << 1;
    *zoom = TILE_W_ZOOM_AT_SIZE(tw);
    /* WARNING: assume reverse zoom is the same for both axis */
    th = TILE_SIZE_AT_ZOOM(TILE_H, *zoom);

    float scale = *zoom / priv->view.tile.zoom;

    priv->view.tile.zoom = *zoom;
    // todo: check cx [0, w]...
    priv->view.offset.zoom_center.x = cx;
    priv->view.offset.zoom_center.y = cy;

    priv->view.tile.w = tw;
    priv->view.tile.h = th;

    if (!priv->view.w || !priv->view.h) {
        priv->view.offset.base.x = 0;
        priv->view.offset.base.y = 0;
        return EINA_TRUE;
    }
    Eina_Inlist **itr, **itr_end;
    Ewk_Tiled_Backing_Store_Item *it;

    Evas_Coord new_x = cx + (priv->view.offset.cur.x - cx) * scale;
    Evas_Coord new_y = cy + (priv->view.offset.cur.y - cy) * scale;
    Evas_Coord bx = cx + (priv->view.offset.base.x - cx) * scale;
    Evas_Coord by = cy + (priv->view.offset.base.y - cy) * scale;

    Evas_Coord model_width = priv->model.width * scale;
    Evas_Coord model_height = priv->model.height * scale;

    if (model_width < priv->view.w || new_x >= 0)
        new_x = 0;
    else if (-new_x + priv->view.w >= model_width)
        new_x = -model_width + priv->view.w;

    if (model_height < priv->view.h || new_y >= 0)
        new_y = 0;
    else if (-new_y + priv->view.h >= model_height)
        new_y = -model_height + priv->view.h;

    bx = new_x % tw;
    priv->model.base.col = - new_x / tw;
    by = new_y % th;
    priv->model.base.row = - new_y / th;

    priv->changed.size = EINA_TRUE;
    _ewk_tiled_backing_store_changed(priv);

    priv->view.offset.cur.x = new_x;
    priv->view.offset.cur.y = new_y;
    priv->view.offset.base.x = bx;
    priv->view.offset.base.y = by;

    priv->view.offset.old.x = priv->view.offset.cur.x;
    priv->view.offset.old.y = priv->view.offset.cur.y;
    *offx = priv->view.offset.cur.x;
    *offy = priv->view.offset.cur.y;

    evas_object_move(
        priv->contents_clipper,
        new_x + priv->view.x,
        new_y + priv->view.y);

    _ewk_tiled_backing_store_fill_renderers(priv);

    Evas_Coord oy = priv->view.offset.base.y + priv->view.y;
    Evas_Coord base_ox = priv->view.x + priv->view.offset.base.x;

    itr = priv->view.items;
    itr_end = itr + priv->view.rows;

    for (; itr < itr_end; itr++) {
        Evas_Coord ox = base_ox;
        Eina_Inlist *lst = *itr;

        EINA_INLIST_FOREACH(lst, it) {
            _ewk_tiled_backing_store_item_move(it, ox, oy);
            _ewk_tiled_backing_store_item_resize(it, tw, th);
            ox += tw;
        }
        oy += th;
    }

    return EINA_TRUE;
}

Eina_Bool ewk_tiled_backing_store_zoom_set(Evas_Object *o, float *zoom, Evas_Coord cx, Evas_Coord cy, Evas_Coord *offx, Evas_Coord *offy)
{
    DBG("o=%p, zoom=%f", o, (double)*zoom);

    PRIV_DATA_GET_OR_RETURN(o, priv, EINA_FALSE);

    return _ewk_tiled_backing_store_zoom_set_internal(priv, zoom, cx, cy, offx, offy);
}

Eina_Bool ewk_tiled_backing_store_zoom_weak_set(Evas_Object *o, float zoom, Evas_Coord cx, Evas_Coord cy)
{
    DBG("o=%p, zoom=%f", o, (double)zoom);
    PRIV_DATA_GET_OR_RETURN(o, priv, EINA_FALSE);
    if (!priv->view.w || !priv->view.h)
        return EINA_FALSE;
    Eina_Inlist **itr, **itr_end;
    Ewk_Tiled_Backing_Store_Item *it;
    Evas_Coord tw, th;
    Eina_Bool recalc = EINA_FALSE;

    tw = TILE_SIZE_AT_ZOOM(TILE_W, zoom);
    zoom = TILE_W_ZOOM_AT_SIZE(tw);
    /* WARNING: assume reverse zoom is the same for both axis */
    th = TILE_SIZE_AT_ZOOM(TILE_H, zoom);

    float scale = zoom / priv->view.tile.zoom;

    Evas_Coord model_width = priv->model.width * scale;
    Evas_Coord model_height = priv->model.height * scale;

    evas_object_resize(priv->contents_clipper,
                       model_width, model_height);

    int vrows = ceil((float)priv->view.h / (float)th) + 1;
    int vcols = ceil((float)priv->view.w / (float)tw) + 1;
    Evas_Coord new_x = cx + (priv->view.offset.cur.x - cx) * scale;
    Evas_Coord new_y = cy + (priv->view.offset.cur.y - cy) * scale;
    Evas_Coord bx = new_x % tw;
    Evas_Coord by = new_y % th;
    unsigned long base_row = -new_y / th;
    unsigned long base_col = -new_x / tw;

    if (base_row != priv->model.base.row || base_col != priv->model.base.col) {
        priv->model.base.row = base_row;
        priv->model.base.col = base_col;
        recalc = EINA_TRUE;
    }

    if (vrows > priv->view.rows || vcols > priv->view.cols)
        recalc = EINA_TRUE;

    if (recalc) {
        Evas_Coord w, h;
        evas_object_geometry_get(o, NULL, NULL, &w, &h);
        _ewk_tiled_backing_store_recalc_renderers(priv, w, h, tw, th);
        _ewk_tiled_backing_store_fill_renderers(priv);
        _ewk_tiled_backing_store_updates_process(priv);
    }

    Evas_Coord base_ox = bx + priv->view.x;
    Evas_Coord oy = by + priv->view.y;

    evas_object_move(priv->contents_clipper,
                     new_x + priv->view.x,
                     new_y + priv->view.y);

    itr = priv->view.items;
    itr_end = itr + priv->view.rows;

    for (; itr < itr_end; itr++) {
        Evas_Coord ox = base_ox;
        Eina_Inlist *lst = *itr;

        EINA_INLIST_FOREACH(lst, it) {
            _ewk_tiled_backing_store_item_move(it, ox, oy);
            _ewk_tiled_backing_store_item_resize(it, tw, th);
            ox += tw;
        }
        oy += th;
    }

    return EINA_TRUE;
}

void ewk_tiled_backing_store_fix_offsets(Evas_Object *o, Evas_Coord w, Evas_Coord h)
{
    PRIV_DATA_GET_OR_RETURN(o, priv);
    Eina_Inlist **itr, **itr_end;
    Ewk_Tiled_Backing_Store_Item *it;
    Evas_Coord new_x = priv->view.offset.cur.x;
    Evas_Coord new_y = priv->view.offset.cur.y;
    Evas_Coord bx = priv->view.offset.base.x;
    Evas_Coord by = priv->view.offset.base.y;
    Evas_Coord tw = priv->view.tile.w;
    Evas_Coord th = priv->view.tile.h;

    if (-new_x > w) {
        new_x = -w;
        bx = new_x % tw;
        priv->model.base.col = -new_x / tw;
    }

    if (-new_y > h) {
        new_y = -h;
        by = new_y % th;
        priv->model.base.row = -new_y / th;
    }

    if (bx >= 0 || bx <= -2 * priv->view.tile.w) {
        bx = new_x % tw;
        priv->model.base.col = -new_x / tw;
    }

    if (by >= 0 || by <= -2 * priv->view.tile.h) {
        by = new_y % th;
        priv->model.base.row = -new_y / th;
    }

    priv->view.offset.cur.x = new_x;
    priv->view.offset.cur.y = new_y;
    priv->view.offset.old.x = new_x;
    priv->view.offset.old.y = new_y;
    priv->view.offset.base.x = bx;
    priv->view.offset.base.y = by;
    evas_object_move(priv->contents_clipper,
                     new_x + priv->view.x,
                     new_y + priv->view.y);

    Evas_Coord oy = priv->view.offset.base.y + priv->view.y;
    Evas_Coord base_ox = priv->view.x + priv->view.offset.base.x;

    itr = priv->view.items;
    itr_end = itr + priv->view.rows;

    for (; itr < itr_end; itr++) {
        Evas_Coord ox = base_ox;
        Eina_Inlist *lst = *itr;

        EINA_INLIST_FOREACH(lst, it) {
            _ewk_tiled_backing_store_item_move(it, ox, oy);
            _ewk_tiled_backing_store_item_resize(it, tw, th);
            ox += tw;
        }
        oy += th;
    }
}

void ewk_tiled_backing_store_zoom_weak_smooth_scale_set(Evas_Object *o, Eina_Bool smooth_scale)
{
    PRIV_DATA_GET_OR_RETURN(o, priv);
    Eina_Inlist **itr, **itr_end;

    itr = priv->view.items;
    itr_end = itr + priv->view.rows;
    priv->view.tile.zoom_weak_smooth_scale = smooth_scale;

    for (; itr< itr_end; itr++) {
        Ewk_Tiled_Backing_Store_Item *it;
        EINA_INLIST_FOREACH(*itr, it)
            if (it->tile)
                _ewk_tiled_backing_store_item_smooth_scale_set
                    (it, smooth_scale);
    }
}

Eina_Bool ewk_tiled_backing_store_update(Evas_Object *o, const Eina_Rectangle *update)
{
    PRIV_DATA_GET_OR_RETURN(o, priv, EINA_FALSE);

    if (priv->render.disabled)
        return EINA_FALSE;

    return ewk_tile_matrix_update(priv->model.matrix, update,
                                  priv->view.tile.zoom);
}

void ewk_tiled_backing_store_updates_process_pre_set(Evas_Object *o, void *(*cb)(void *data, Evas_Object *o), const void *data)
{
    PRIV_DATA_GET_OR_RETURN(o, priv);
    priv->process.pre_cb = cb;
    priv->process.pre_data = (void*)data;
}

void ewk_tiled_backing_store_updates_process_post_set(Evas_Object *o, void *(*cb)(void *data, void *pre_data, Evas_Object *o), const void *data)
{
    PRIV_DATA_GET_OR_RETURN(o, priv);
    priv->process.post_cb = cb;
    priv->process.post_data = (void*)data;
}

void ewk_tiled_backing_store_updates_process(Evas_Object *o)
{
    PRIV_DATA_GET_OR_RETURN(o, priv);
    _ewk_tiled_backing_store_updates_process(priv);
}

void ewk_tiled_backing_store_updates_clear(Evas_Object *o)
{
    PRIV_DATA_GET_OR_RETURN(o, priv);

    ewk_tile_matrix_updates_clear(priv->model.matrix);
}

void ewk_tiled_backing_store_contents_resize(Evas_Object *o, Evas_Coord width, Evas_Coord height)
{
    PRIV_DATA_GET_OR_RETURN(o, priv);

    if (width == priv->model.width && height == priv->model.height)
        return;

    priv->model.width = width;
    priv->model.height = height;
    priv->changed.model = EINA_TRUE;

    DBG("width,height=%d, %d", width, height);
    _ewk_tiled_backing_store_changed(priv);
}

void ewk_tiled_backing_store_disabled_update_set(Evas_Object *o, Eina_Bool value)
{
    PRIV_DATA_GET_OR_RETURN(o, priv);

    if (value != priv->render.disabled)
        priv->render.disabled = value;
}

void ewk_tiled_backing_store_flush(Evas_Object *o)
{
    PRIV_DATA_GET_OR_RETURN(o, priv);
    Ewk_Tile_Unused_Cache *tuc = NULL;

    priv->view.offset.cur.x = 0;
    priv->view.offset.cur.y = 0;
    priv->view.offset.old.x = 0;
    priv->view.offset.old.y = 0;
    priv->view.offset.base.x = 0;
    priv->view.offset.base.y = 0;
    priv->model.base.col = 0;
    priv->model.base.row = 0;
    priv->changed.size = EINA_TRUE;

#ifdef DEBUG_MEM_LEAKS
    printf("\nFLUSHED BACKING STORE, STATUS BEFORE DELETING TILE MATRIX:\n");
    _ewk_tiled_backing_store_mem_dbg(priv);
#endif

    _ewk_tiled_backing_store_pre_render_request_flush(priv);
    _ewk_tiled_backing_store_tile_dissociate_all(priv);
    tuc = ewk_tile_matrix_unused_cache_get(priv->model.matrix);
    ewk_tile_unused_cache_clear(tuc);

#ifdef DEBUG_MEM_LEAKS
    printf("\nFLUSHED BACKING STORE, STATUS AFTER RECREATING TILE MATRIX:\n");
    _ewk_tiled_backing_store_mem_dbg(priv);
#endif
}

Eina_Bool ewk_tiled_backing_store_pre_render_region(Evas_Object *o, Evas_Coord x, Evas_Coord y, Evas_Coord w, Evas_Coord h, float zoom)
{
    PRIV_DATA_GET_OR_RETURN(o, priv, EINA_FALSE);
    Eina_Tile_Grid_Slicer slicer;
    const Eina_Tile_Grid_Info *info;
    Evas_Coord tw, th;
    Ewk_Tile_Unused_Cache *tuc;

    tw = TILE_SIZE_AT_ZOOM(TILE_W, zoom);
    tw = (tw >> 1) << 1;
    zoom = TILE_W_ZOOM_AT_SIZE(tw);
    /* WARNING: assume reverse zoom is the same for both axis */
    th = TILE_SIZE_AT_ZOOM(TILE_H, zoom);

    if (!eina_tile_grid_slicer_setup(&slicer, x, y, w, h, tw, th)) {
        ERR("could not setup grid slicer for %d,%d+%dx%d tile=%dx%d",
            x, y, w, h, tw, th);
        return EINA_FALSE;
    }

    while (eina_tile_grid_slicer_next(&slicer, &info)) {
        const unsigned long c = info->col;
        const unsigned long r = info->row;
        if (!_ewk_tiled_backing_store_pre_render_request_add(priv, c, r, zoom, PRE_RENDER_PRIORITY_LOW))
            break;
    }

    _ewk_tiled_backing_store_item_process_idler_start(priv);

    tuc = ewk_tile_matrix_unused_cache_get(priv->model.matrix);
    ewk_tile_unused_cache_lock_area(tuc, x, y, w, h, zoom);
    return EINA_TRUE;
}

Eina_Bool ewk_tiled_backing_store_pre_render_relative_radius(Evas_Object *o, unsigned int n, float zoom)
{
    PRIV_DATA_GET_OR_RETURN(o, priv, EINA_FALSE);
    unsigned long start_row, end_row, start_col, end_col, i, j, w, h;
    Ewk_Tile_Unused_Cache *tuc;

    INF("priv->model.base.row =%ld, n=%u priv->view.rows=%lu",
            priv->model.base.row, n, priv->view.rows);
    start_row = (long)priv->model.base.row - n;
    start_col = (long)priv->model.base.col - n;
    end_row = MIN(priv->model.cur.rows - 1,
                  priv->model.base.row + priv->view.rows + n - 1);
    end_col = MIN(priv->model.cur.cols - 1,
                  priv->model.base.col + priv->view.cols + n - 1);

    INF("start_row=%lu, end_row=%lu, start_col=%lu, end_col=%lu",
         start_row, end_row, start_col, end_col);

    for (i = start_row; i <= end_row; i++)
        for (j = start_col; j <= end_col; j++)
            if (!_ewk_tiled_backing_store_pre_render_request_add(priv, j, i, zoom, PRE_RENDER_PRIORITY_LOW))
                goto start_processing;

start_processing:
    _ewk_tiled_backing_store_item_process_idler_start(priv);

    tuc = ewk_tile_matrix_unused_cache_get(priv->model.matrix);
    h = (end_row - start_row + 1) * TILE_SIZE_AT_ZOOM(TILE_H, zoom);
    w = (end_col - start_col + 1) * TILE_SIZE_AT_ZOOM(TILE_W, zoom);
    ewk_tile_unused_cache_lock_area(tuc,
            start_col * TILE_SIZE_AT_ZOOM(TILE_W, zoom),
            start_row * TILE_SIZE_AT_ZOOM(TILE_H, zoom), w, h, zoom);

    return EINA_TRUE;
}

void ewk_tiled_backing_store_pre_render_cancel(Evas_Object *o)
{
    PRIV_DATA_GET_OR_RETURN(o, priv);
    Ewk_Tile_Unused_Cache *tuc;

    _ewk_tiled_backing_store_pre_render_request_clear(priv);

    tuc = ewk_tile_matrix_unused_cache_get(priv->model.matrix);
    ewk_tile_unused_cache_unlock_area(tuc);
}

Eina_Bool ewk_tiled_backing_store_disable_render(Evas_Object *o)
{
    PRIV_DATA_GET_OR_RETURN(o, priv, EINA_FALSE);
    return _ewk_tiled_backing_store_disable_render(priv);
}

Eina_Bool ewk_tiled_backing_store_enable_render(Evas_Object *o)
{
    PRIV_DATA_GET_OR_RETURN(o, priv, EINA_FALSE);
    _ewk_tiled_backing_store_changed(priv);
    return _ewk_tiled_backing_store_enable_render(priv);
}

/**
 * Set the process_entire_queue flag of the renderer idler.
 *
 *
 * @param o the tiled backing store object
 * @param value EINA_TRUE if we want to process all the request of our queue. EINA_FALSE otherwise.
 */
void ewk_tiled_backing_store_process_entire_queue_set(Evas_Object *o, Eina_Bool value)
{
    PRIV_DATA_GET_OR_RETURN(o, priv);
    if (priv->render.process_entire_queue != value)
        priv->render.process_entire_queue = value;
}