Wholesale cruft removal part 1

(bzr r9508.1.44)

26 files changed, 43 insertions, 1255 deletions

diff --git a/src/display/Makefile_insert b/src/display/Makefile_insert
index 3e8b6ff91..843f5aa8f 100644
--- a/src/display/Makefile_insert
+++ b/src/display/Makefile_insert
@@ -91,17 +91,13 @@ ink_common_sources += \
 	display/nr-light.h				\
 	display/nr-light-types.h	\
 	display/nr-plain-stuff.cpp	\
+	display/nr-plain-stuff.h	\
 	display/nr-plain-stuff-gdk.cpp	\
 	display/nr-plain-stuff-gdk.h	\
-	display/nr-plain-stuff.h	\
 	display/nr-style.cpp	\
 	display/nr-style.h	\
 	display/nr-svgfonts.cpp		\
 	display/nr-svgfonts.h		\
-	display/pixblock-scaler.cpp     \
-	display/pixblock-scaler.h       \
-	display/pixblock-transform.cpp  \
-	display/pixblock-transform.h    \
 	display/rendermode.h		\
 	display/snap-indicator.cpp	\
 	display/snap-indicator.h	\
diff --git a/src/display/cairo-utils.cpp b/src/display/cairo-utils.cpp
index 25a1e7988..15fceedae 100644
--- a/src/display/cairo-utils.cpp
+++ b/src/display/cairo-utils.cpp
@@ -457,6 +457,32 @@ ink_cairo_surface_get_height(cairo_surface_t *surface)
     return cairo_image_surface_get_height(surface);
 }
 
+cairo_pattern_t *
+ink_cairo_pattern_create_checkerboard()
+{
+    int const w = 8;
+    int const h = 8;
+
+    cairo_surface_t *s = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, 2*w, 2*h);
+
+    cairo_t *ct = cairo_create(s);
+    cairo_set_operator(ct, CAIRO_OPERATOR_SOURCE);
+    cairo_set_source_rgb(ct, 0.75, 0.75, 0.75);
+    cairo_paint(ct);
+    cairo_set_source_rgb(ct, 0.5, 0.5, 0.5);
+    cairo_rectangle(ct, 0, 0, w, h);
+    cairo_rectangle(ct, w, h, w, h);
+    cairo_fill(ct);
+    cairo_destroy(ct);
+
+    cairo_pattern_t *p = cairo_pattern_create_for_surface(s);
+    cairo_pattern_set_extend(p, CAIRO_EXTEND_REPEAT);
+    cairo_pattern_set_filter(p, CAIRO_FILTER_NEAREST);
+
+    cairo_surface_destroy(s);
+    return p;
+}
+
 /**
  * @brief Convert pixel data from GdkPixbuf format to ARGB.
  * This will convert pixel data from GdkPixbuf format to Cairo's native pixel format.
diff --git a/src/display/cairo-utils.h b/src/display/cairo-utils.h
index 5ac546067..f74ceed14 100644
--- a/src/display/cairo-utils.h
+++ b/src/display/cairo-utils.h
@@ -96,6 +96,8 @@ void ink_cairo_surface_blit(cairo_surface_t *src, cairo_surface_t *dest);
 int ink_cairo_surface_get_width(cairo_surface_t *surface);
 int ink_cairo_surface_get_height(cairo_surface_t *surface);
 
+cairo_pattern_t *ink_cairo_pattern_create_checkerboard();
+
 void convert_pixels_pixbuf_to_argb32(guchar *data, int w, int h, int rs);
 void convert_pixels_argb32_to_pixbuf(guchar *data, int w, int h, int rs);
 void convert_pixbuf_normal_to_argb32(GdkPixbuf *);
diff --git a/src/display/canvas-arena.cpp b/src/display/canvas-arena.cpp
index db8e1757c..6f85573d1 100644
--- a/src/display/canvas-arena.cpp
+++ b/src/display/canvas-arena.cpp
@@ -14,7 +14,6 @@
 
 #include <gtk/gtksignal.h>
 
-#include "libnr/nr-blit.h"
 #include "display/display-forward.h"
 #include "display/sp-canvas-util.h"
 #include "helper/sp-marshal.h"
@@ -22,6 +21,7 @@
 #include "display/nr-arena-group.h"
 #include "display/canvas-arena.h"
 #include "display/cairo-utils.h"
+#include "libnr/nr-pixblock.h"
 
 enum {
     ARENA_EVENT,
diff --git a/src/display/nr-3dutils.cpp b/src/display/nr-3dutils.cpp
index 89c21940a..1d92d3ec9 100644
--- a/src/display/nr-3dutils.cpp
+++ b/src/display/nr-3dutils.cpp
@@ -11,134 +11,15 @@
 
 #include <glib/gmessages.h>
 
-#include "libnr/nr-pixblock.h"
 #include "display/nr-3dutils.h"
 #include <cmath>
+#include <2geom/point.h>
+#include <2geom/matrix.h>
 
 namespace NR {
 
-#define BEGIN 0 // TOP or LEFT
-#define MIDDLE 1
-#define END 2 // BOTTOM or RIGHT
-
-#define START(v) ((v)==BEGIN? 1 : 0)
-#define FINISH(v) ((v)==END? 1 : 2)
-
-signed char K_X[3][3][3][3] = {
-    //K_X[TOP]
-    {
-        //K_X[TOP][LEFT]
-        {
-            { 0,  0,  0},
-            { 0, -2,  2},
-            { 0, -1,  1}
-        },
-        {
-            { 0,  0,  0},
-            {-2,  0,  2},
-            {-1,  0,  1}
-        },
-        {
-            { 0,  0,  0},
-            {-2,  2,  0},
-            {-1,  1,  0}
-        }
-    },
-    //K_X[MIDDLE]
-    {
-        //K_X[MIDDLE][LEFT]
-        {
-            { 0, -1,  1},
-            { 0, -2,  2},
-            { 0, -1,  1}
-        },
-        {
-            {-1,  0,  1},
-            {-2,  0,  2},
-            {-1,  0,  1}
-        },
-        {
-            {-1,  1,  0},
-            {-2,  2,  0},
-            {-1,  1,  0}
-        }
-    },
-    //K_X[BOTTOM]
-    {
-        //K_X[BOTTOM][LEFT]
-        {
-            { 0, -1,  1},
-            { 0, -2,  2},
-            { 0,  0,  0}
-        },
-        {
-            {-1,  0,  1},
-            {-2,  0,  2},
-            { 0,  0,  0}
-        },
-        {
-            {-1,  1,  0},
-            {-2,  2,  0},
-            { 0,  0,  0}
-        }
-    }
-};
-
-//K_Y is obtained by transposing K_X globally and each of its components
-
-gdouble FACTOR_X[3][3] = {
-    {2./3, 1./3, 2./3},
-    {1./2, 1./4, 1./2},
-    {2./3, 1./3, 2./3}
-};
-
-//FACTOR_Y is obtained by transposing FACTOR_X
-
-inline
-int get_carac(int i, int len, int delta) {
-    if (i < delta)
-        return BEGIN;
-    else if (i > len - 1 - delta)
-        return END;
-    else
-        return MIDDLE;
-}
-
-//assumes in is RGBA
-//should be made more resistant
-void compute_surface_normal(Fvector &N, gdouble ss, NRPixBlock *in, int i, int j, int dx, int dy) {
-    int w = in->area.x1 - in->area.x0;
-    int h = in->area.y1 - in->area.y0;
-    int k, l, alpha_idx, alpha_idx_y;
-    int x_carac, y_carac;
-    gdouble alpha;
-    gdouble accu_x;
-    gdouble accu_y;
-    unsigned char *data = NR_PIXBLOCK_PX (in);
-    g_assert(NR_PIXBLOCK_BPP(in) == 4);
-    x_carac = get_carac(j, w, dx); //LEFT, MIDDLE or RIGHT
-    y_carac = get_carac(i, h, dy); //TOP, MIDDLE or BOTTOM
-    alpha_idx = 4*(i*w + j);
-    accu_x = 0;
-    accu_y = 0;
-    for (k = START(y_carac); k <= FINISH(y_carac); k++) {
-        alpha_idx_y = alpha_idx + 4*(k-1)*dy*w;
-        for (l = START(x_carac); l <= FINISH(x_carac); l++) {
-            alpha = (data + alpha_idx_y + 4*dx*(l-1))[3];
-            accu_x += K_X[y_carac][x_carac][k][l] * alpha;
-            accu_y += K_X[x_carac][y_carac][l][k] * alpha;
-        }
-    }
-    ss /= 255.0; // Correction for scale of pixel values
-    N[X_3D] = -ss * FACTOR_X[y_carac][x_carac] * accu_x / dx;
-    N[Y_3D] = -ss * FACTOR_X[x_carac][y_carac] * accu_y / dy;
-    N[Z_3D] = 1.0;
-    normalize_vector(N);
-    //std::cout << "(" << N[X_3D] << ", " << N[Y_3D] << ", " << N[Z_3D] << ")" << std::endl;
-}
-
 void convert_coord(gdouble &x, gdouble &y, gdouble &z, Geom::Matrix const &trans) {
-    Point p = Point(x, y);
+    Geom::Point p = Geom::Point(x, y);
     p *= trans;
     x = p[Geom::X];
     y = p[Geom::Y];
diff --git a/src/display/nr-3dutils.h b/src/display/nr-3dutils.h
index 42df36c82..9a198a73d 100644
--- a/src/display/nr-3dutils.h
+++ b/src/display/nr-3dutils.h
@@ -81,22 +81,6 @@ gdouble scalar_product(const Fvector &a, const Fvector &b);
 void normalized_sum(Fvector &r, const Fvector &a, const Fvector &b);
 
 /**
- * Computes the unit suface normal vector of surface given by "in" at (i, j)
- * and store it into N. "in" is a (NRPixBlock *) in mode RGBA but only the alpha
- * channel is considered as a bump map. ss is the altitude when for the alpha
- * value 255. dx and dy are the deltas used to compute in our discrete setting
- *
- * \param N a reference to a Fvector in which we store the unit surface normal
- * \param ss the surface scale
- * \param in a NRPixBlock * whose alpha channel codes the surface
- * \param i the x coordinate of the point at which we compute the normal
- * \param j the y coordinate of the point at which we compute the normal
- * \param dx the delta used in the x coordinate
- * \param dy the delta used in the y coordinate
- */
-void compute_surface_normal(Fvector &N, gdouble ss, NRPixBlock *in, int i, int j, int dx, int dy);
-
-/**
  * Applies the transformation matrix to (x, y, z). This function assumes that
  * trans[0] = trans[3]. x and y are transformed according to trans, z is
  * multiplied by trans[0].
diff --git a/src/display/nr-arena-glyphs.cpp b/src/display/nr-arena-glyphs.cpp
index faf10bd38..d35489d70 100644
--- a/src/display/nr-arena-glyphs.cpp
+++ b/src/display/nr-arena-glyphs.cpp
@@ -16,7 +16,6 @@
 #ifdef HAVE_CONFIG_H
 # include <config.h>
 #endif
-#include "libnr/nr-blit.h"
 #include "libnr/nr-convert2geom.h"
 #include <2geom/matrix.h>
 #include "style.h"
diff --git a/src/display/nr-arena-image.cpp b/src/display/nr-arena-image.cpp
index 066133dde..5617bb084 100644
--- a/src/display/nr-arena-image.cpp
+++ b/src/display/nr-arena-image.cpp
@@ -12,9 +12,7 @@
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
 
-#include <libnr/nr-compose-transform.h>
 #include <2geom/transforms.h>
-#include <libnr/nr-blit.h>
 #include "../preferences.h"
 #include "nr-arena-image.h"
 #include "style.h"
diff --git a/src/display/nr-arena-item.cpp b/src/display/nr-arena-item.cpp
index e7cf08722..0bdbd12ae 100644
--- a/src/display/nr-arena-item.cpp
+++ b/src/display/nr-arena-item.cpp
@@ -19,8 +19,6 @@
 #include <string>
 #include <cairomm/cairomm.h>
 
-#include <libnr/nr-blit.h>
-#include <libnr/nr-pixops.h>
 #include "display/cairo-utils.h"
 #include "nr-arena.h"
 #include "nr-arena-item.h"
@@ -317,7 +315,7 @@ nr_arena_item_invoke_render (cairo_t *ct, NRArenaItem *item, NRRectL const *area
    bool outline = (item->arena->rendermode == Inkscape::RENDERMODE_OUTLINE);
     bool filter = (item->arena->rendermode != Inkscape::RENDERMODE_OUTLINE &&
                    item->arena->rendermode != Inkscape::RENDERMODE_NO_FILTERS);
-    bool print_colors = (item->arena->rendermode == Inkscape::RENDERMODE_PRINT_COLORS_PREVIEW);
+    //bool print_colors = (item->arena->rendermode == Inkscape::RENDERMODE_PRINT_COLORS_PREVIEW);
 
     nr_return_val_if_fail (item != NULL, NR_ARENA_ITEM_STATE_INVALID);
     nr_return_val_if_fail (NR_IS_ARENA_ITEM (item),
@@ -375,193 +373,6 @@ nr_arena_item_invoke_render (cairo_t *ct, NRArenaItem *item, NRRectL const *area
         return item->state | NR_ARENA_ITEM_STATE_RENDER;
     }
 
-#if 0
-    NRPixBlock *dpb = pb;
-
-    /* Determine, whether we need temporary buffer */
-/*    if (item->clip || item->mask
-        || ((item->opacity != 255) && !item->render_opacity)
-        || (item->filter && filter) || item->background_new
-        || (item->parent && item->parent->background_pb))*/
-    if (0) {
-
-        /* Setup and render item buffer */
-        NRPixBlock ipb;
-        nr_pixblock_setup_fast (&ipb, NR_PIXBLOCK_MODE_R8G8B8A8P,
-                                carea.x0, carea.y0, carea.x1, carea.y1,
-                                TRUE);
-
-        //  if memory allocation failed, abort render
-        if (ipb.size != NR_PIXBLOCK_SIZE_TINY && ipb.data.px == NULL) {
-            nr_pixblock_release (&ipb);
-            return (item->state);
-        }
-
-        /* If background access is used, save the pixblock address.
-         * This address is set to NULL at the end of this block */
-        if (item->background_new ||
-            (item->parent && item->parent->background_pb)) {
-            item->background_pb = &ipb;
-        }
-
-        ipb.visible_area = pb->visible_area;
-        if (item->filter && filter) {
-              item->filter->area_enlarge (ipb.visible_area, item);
-        }
-
-        unsigned int state = NR_ARENA_ITEM_VIRTUAL (item, render) (ct, item, &carea, &ipb, flags);
-        if (state & NR_ARENA_ITEM_STATE_INVALID) {
-            /* Clean up and return error */
-            nr_pixblock_release (&ipb);
-            if (dpb != pb)
-                nr_pixblock_release (dpb);
-            item->state |= NR_ARENA_ITEM_STATE_INVALID;
-            return item->state;
-        }
-        ipb.empty = FALSE;
-
-        /* Run filtering, if a filter is set for this object */
-        if (item->filter && filter) {
-            item->filter->render (item, &ipb);
-        }
-
-        if (item->clip || item->mask) {
-            /* Setup mask pixblock */
-            NRPixBlock mpb;
-            nr_pixblock_setup_fast (&mpb, NR_PIXBLOCK_MODE_A8, carea.x0,
-                                    carea.y0, carea.x1, carea.y1, TRUE);
-
-            if (mpb.data.px != NULL) { // if memory allocation was successful
-
-                mpb.visible_area = pb->visible_area;
-                /* Do clip if needed */
-                if (item->clip) {
-                    state = nr_arena_item_invoke_clip (item->clip, &carea, &mpb);
-                    if (state & NR_ARENA_ITEM_STATE_INVALID) {
-                        /* Clean up and return error */
-                        nr_pixblock_release (&mpb);
-                        nr_pixblock_release (&ipb);
-                        if (dpb != pb)
-                            nr_pixblock_release (dpb);
-                        item->state |= NR_ARENA_ITEM_STATE_INVALID;
-                        return item->state;
-                    }
-                    mpb.empty = FALSE;
-                }
-                /* Do mask if needed */
-                if (item->mask) {
-                    NRPixBlock tpb;
-                    /* Set up yet another temporary pixblock */
-                    nr_pixblock_setup_fast (&tpb, NR_PIXBLOCK_MODE_R8G8B8A8N,
-                                            carea.x0, carea.y0, carea.x1,
-                                            carea.y1, TRUE);
-
-                    if (tpb.data.px != NULL) { // if memory allocation was successful
-
-                        tpb.visible_area = pb->visible_area;
-                        unsigned int state = NR_ARENA_ITEM_VIRTUAL (item->mask, render) (ct, item->mask, &carea, &tpb, flags);
-                        if (state & NR_ARENA_ITEM_STATE_INVALID) {
-                            /* Clean up and return error */
-                            nr_pixblock_release (&tpb);
-                            nr_pixblock_release (&mpb);
-                            nr_pixblock_release (&ipb);
-                            if (dpb != pb)
-                                nr_pixblock_release (dpb);
-                            item->state |= NR_ARENA_ITEM_STATE_INVALID;
-                            return item->state;
-                        }
-                        /* Composite with clip */
-                        if (item->clip) {
-                            int x, y;
-                            for (y = carea.y0; y < carea.y1; y++) {
-                                unsigned char *s, *d;
-                                s = NR_PIXBLOCK_PX (&tpb) + (y -
-                                                             carea.y0) * tpb.rs;
-                                d = NR_PIXBLOCK_PX (&mpb) + (y -
-                                                             carea.y0) * mpb.rs;
-                                for (x = carea.x0; x < carea.x1; x++) {
-                                    unsigned int m;
-                                    m = NR_PREMUL_112 (s[0] + s[1] + s[2], s[3]);
-                                    d[0] =
-                                        FAST_DIV_ROUND < 3 * 255 * 255 >
-                                        (NR_PREMUL_123 (d[0], m));
-                                    s += 4;
-                                    d += 1;
-                                }
-                            }
-                        } else {
-                            int x, y;
-                            for (y = carea.y0; y < carea.y1; y++) {
-                                unsigned char *s, *d;
-                                s = NR_PIXBLOCK_PX (&tpb) + (y -
-                                                             carea.y0) * tpb.rs;
-                                d = NR_PIXBLOCK_PX (&mpb) + (y -
-                                                             carea.y0) * mpb.rs;
-                                for (x = carea.x0; x < carea.x1; x++) {
-                                    unsigned int m;
-                                    m = NR_PREMUL_112 (s[0] + s[1] + s[2], s[3]);
-                                    d[0] = FAST_DIV_ROUND < 3 * 255 > (m);
-                                    s += 4;
-                                    d += 1;
-                                }
-                            }
-                            mpb.empty = FALSE;
-                        }
-                    }
-                    nr_pixblock_release (&tpb);
-                }
-                /* Multiply with opacity if needed */
-                if ((item->opacity != 255) && !item->render_opacity
-                    ) {
-                    int x, y;
-                    unsigned int a;
-                    a = item->opacity;
-                    for (y = carea.y0; y < carea.y1; y++) {
-                        unsigned char *d;
-                        d = NR_PIXBLOCK_PX (&mpb) + (y - carea.y0) * mpb.rs;
-                        for (x = carea.x0; x < carea.x1; x++) {
-                            d[0] = NR_PREMUL_111 (d[0], a);
-                            d += 1;
-                        }
-                    }
-                }
-                /* Compose rendering pixblock int destination */
-                nr_blit_pixblock_pixblock_mask (dpb, &ipb, &mpb);
-            }
-            nr_pixblock_release (&mpb);
-        } else {
-            if (item->render_opacity) { // opacity was already rendered in, just copy to dpb here
-                nr_blit_pixblock_pixblock(dpb, &ipb);
-            } else { // copy while multiplying by opacity
-                nr_blit_pixblock_pixblock_alpha (dpb, &ipb, item->opacity);
-            }
-        }
-        nr_pixblock_release (&ipb);
-        dpb->empty = FALSE;
-        /* This pointer wouldn't be valid outside this block, so clear it */
-        item->background_pb = NULL;
-    } else {
-        /* Just render */
-        unsigned int state = NR_ARENA_ITEM_VIRTUAL (item, render) (ct, item, const_cast<NRRectL*>(area), dpb, flags);
-        if (state & NR_ARENA_ITEM_STATE_INVALID) {
-            /* Clean up and return error */
-            if (dpb != pb)
-                nr_pixblock_release (dpb);
-            item->state |= NR_ARENA_ITEM_STATE_INVALID;
-            return item->state;
-        }
-        dpb->empty = FALSE;
-    }
-
-    if (dpb != pb) {
-        /* Have to blit from cache */
-        nr_blit_pixblock_pixblock (pb, dpb);
-        nr_pixblock_release (dpb);
-        pb->empty = FALSE;
-        item->state |= NR_ARENA_ITEM_STATE_IMAGE;
-    }
-#endif
-
     using namespace Inkscape;
 
     // clipping and masks
@@ -947,27 +758,7 @@ nr_arena_item_set_item_bbox (NRArenaItem *item, Geom::OptRect &bbox)
 NRPixBlock *
 nr_arena_item_get_background (NRArenaItem const *item, int depth)
 {
-    NRPixBlock *pb;
-    if (!item->background_pb)
-        return NULL;
-    if (item->background_new) {
-        pb = new NRPixBlock ();
-        nr_pixblock_setup_fast (pb, item->background_pb->mode,
-                                item->background_pb->area.x0,
-                                item->background_pb->area.y0,
-                                item->background_pb->area.x1,
-                                item->background_pb->area.y1, true);
-        if (pb->size != NR_PIXBLOCK_SIZE_TINY && pb->data.px == NULL) // allocation failed
-            return NULL;
-    } else if (item->parent) {
-        pb = nr_arena_item_get_background (item->parent, depth + 1);
-    } else
-        return NULL;
-
-    if (depth > 0)
-        nr_blit_pixblock_pixblock (pb, item->background_pb);
-
-    return pb;
+    return NULL;
 }
 
 /* Helpers */
diff --git a/src/display/nr-arena-item.h b/src/display/nr-arena-item.h
index 447307535..752390776 100644
--- a/src/display/nr-arena-item.h
+++ b/src/display/nr-arena-item.h
@@ -15,9 +15,8 @@
 
 #include <cairo.h>
 #include <2geom/matrix.h>
-#include <libnr/nr-rect-l.h>
-#include <libnr/nr-pixblock.h>
-#include <libnr/nr-object.h>
+#include "libnr/nr-rect-l.h"
+#include "libnr/nr-object.h"
 #include "gc-soft-ptr.h"
 #include "nr-arena-forward.h"
 
diff --git a/src/display/nr-arena-shape.cpp b/src/display/nr-arena-shape.cpp
index b51f3a9cf..0f86db041 100644
--- a/src/display/nr-arena-shape.cpp
+++ b/src/display/nr-arena-shape.cpp
@@ -29,9 +29,7 @@
 #include "display/nr-filter.h"
 #include "helper/geom-curves.h"
 #include "helper/geom.h"
-#include "libnr/nr-blit.h"
 #include "libnr/nr-convert2geom.h"
-#include "libnr/nr-pixops.h"
 #include "preferences.h"
 #include "sp-filter.h"
 #include "sp-filter-reference.h"
diff --git a/src/display/nr-arena.cpp b/src/display/nr-arena.cpp
index 33870a118..1339786bd 100644
--- a/src/display/nr-arena.cpp
+++ b/src/display/nr-arena.cpp
@@ -16,7 +16,6 @@
 #include "nr-arena.h"
 #include "nr-filter-gaussian.h"
 #include "nr-filter-types.h"
-#include <libnr/nr-blit.h>
 #include "preferences.h"
 #include "color.h"
 
@@ -131,41 +130,6 @@ nr_arena_request_render_rect (NRArena *arena, NRRectL *area)
     }
 }
 
-void
-nr_arena_render_paintserver_fill (NRPixBlock *pb, NRRectL *area, SPPainter *painter, float opacity, NRPixBlock *mask)
-{
-    NRPixBlock cb, cb_opa;
-    nr_pixblock_setup_fast (&cb, NR_PIXBLOCK_MODE_R8G8B8A8N, area->x0, area->y0, area->x1, area->y1, TRUE);
-    nr_pixblock_setup_fast (&cb_opa, NR_PIXBLOCK_MODE_R8G8B8A8N, area->x0, area->y0, area->x1, area->y1, TRUE);
-
-    // if memory allocation failed, abort
-    if ((cb.size != NR_PIXBLOCK_SIZE_TINY && cb.data.px == NULL) || (cb_opa.size != NR_PIXBLOCK_SIZE_TINY && cb_opa.data.px == NULL)) {
-        return;
-    }
-
-    cb.visible_area = pb->visible_area;
-    cb_opa.visible_area = pb->visible_area;
-
-    /* Need separate gradient buffer (lauris)*/
-    // do the filling
-    painter->fill (painter, &cb);
-    cb.empty = FALSE;
-
-    // do the fill-opacity and mask composite
-    if (opacity < 1.0) {
-        nr_blit_pixblock_pixblock_alpha (&cb_opa, &cb, (int) floor (255 * opacity));
-        cb_opa.empty = FALSE;
-        nr_blit_pixblock_pixblock_mask (pb, &cb_opa, mask);
-    } else {
-        nr_blit_pixblock_pixblock_mask (pb, &cb, mask);
-    }
-
-    pb->empty = FALSE;
-
-    nr_pixblock_release (&cb);
-    nr_pixblock_release (&cb_opa);
-}
-
 /**
     set arena to offscreen mode
     rendering will be exact
diff --git a/src/display/nr-arena.h b/src/display/nr-arena.h
index d2f9dc246..f4d86a2e6 100644
--- a/src/display/nr-arena.h
+++ b/src/display/nr-arena.h
@@ -62,8 +62,6 @@ void nr_arena_request_update (NRArena *arena, NRArenaItem *item);
 void nr_arena_request_render_rect (NRArena *arena, NRRectL *area);
 void nr_arena_set_renderoffscreen (NRArena *arena);
 
-void nr_arena_render_paintserver_fill (NRPixBlock *pb, NRRectL *area, SPPainter *painter, float opacity, NRPixBlock *mask);
-
 void nr_arena_separate_color_plates(guint32* rgba);
 
 #endif
diff --git a/src/display/nr-filter-skeleton.cpp b/src/display/nr-filter-skeleton.cpp
index bdb993ed9..d5adedad9 100644
--- a/src/display/nr-filter-skeleton.cpp
+++ b/src/display/nr-filter-skeleton.cpp
@@ -24,7 +24,6 @@
 #include "display/nr-filter-skeleton.h"
 #include "display/nr-filter-slot.h"
 #include "display/nr-filter-units.h"
-#include "libnr/nr-pixblock.h"
 
 namespace Inkscape {
 namespace Filters {
diff --git a/src/display/nr-filter-slot.h b/src/display/nr-filter-slot.h
index 7b32f1210..93c8e2fe2 100644
--- a/src/display/nr-filter-slot.h
+++ b/src/display/nr-filter-slot.h
@@ -16,7 +16,6 @@
 
 #include <map>
 #include <cairo.h>
-#include "libnr/nr-pixblock.h"
 #include "display/nr-filter-types.h"
 #include "display/nr-filter-units.h"
 
@@ -41,7 +40,6 @@ public:
      * NR_FILTER_FILLPAINT, NR_FILTER_SOURCEPAINT.
      */
     cairo_surface_t *getcairo(int slot);
-    NRPixBlock *get(int slot) { return NULL; }
 
     /** Sets or re-sets the pixblock associated with given slot.
      * If there was a pixblock already assigned with this slot,
@@ -49,8 +47,6 @@ public:
      */
     void set(int slot, cairo_surface_t *s);
 
-    void set(int, NRPixBlock*){}
-
     cairo_surface_t *get_result(int slot_nr);
 
     /** Returns the number of slots in use. */
diff --git a/src/display/nr-filter-turbulence.cpp b/src/display/nr-filter-turbulence.cpp
index d60c4f617..54b5cf7c6 100644
--- a/src/display/nr-filter-turbulence.cpp
+++ b/src/display/nr-filter-turbulence.cpp
@@ -24,7 +24,6 @@
 #include "display/nr-filter-units.h"
 #include "display/nr-filter-utils.h"
 #include "libnr/nr-rect-l.h"
-#include "libnr/nr-blit.h"
 #include <math.h>
 
 namespace Inkscape {
@@ -301,7 +300,6 @@ FilterTurbulence::FilterTurbulence()
     , seed(0)
     , updated(false)
     , updated_area(NR::IPoint(), NR::IPoint())
-    , pix(NULL)
     , fTileWidth(10) //guessed
     , fTileHeight(10) //guessed
     , fTileX(1) //guessed
@@ -316,11 +314,6 @@ FilterPrimitive * FilterTurbulence::create() {
 FilterTurbulence::~FilterTurbulence()
 {
     delete gen;
-
-    if (pix) {
-        nr_pixblock_release(pix);
-        delete pix;
-    }
 }
 
 void FilterTurbulence::set_baseFrequency(int axis, double freq){
@@ -352,89 +345,6 @@ void FilterTurbulence::set_type(FilterTurbulenceType t){
 void FilterTurbulence::set_updated(bool u){
 }
 
-void FilterTurbulence::render_area(NRPixBlock *pix, NR::IRect &full_area, FilterUnits const &units) {
-#if 0
-    const int bbox_x0 = full_area.min()[NR::X];
-    const int bbox_y0 = full_area.min()[NR::Y];
-    const int bbox_x1 = full_area.max()[NR::X];
-    const int bbox_y1 = full_area.max()[NR::Y];
-
-    Geom::Matrix unit_trans = units.get_matrix_primitiveunits2pb().inverse();
-
-    double point[2];
-
-    unsigned char *pb = NR_PIXBLOCK_PX(pix);
-
-    if (type==TURBULENCE_TURBULENCE){
-        for (int y = std::max(bbox_y0, pix->area.y0); y < std::min(bbox_y1, pix->area.y1); y++){
-            int out_line = (y - pix->area.y0) * pix->rs;
-            point[1] = y * unit_trans[3] + unit_trans[5];
-            for (int x = std::max(bbox_x0, pix->area.x0); x < std::min(bbox_x1, pix->area.x1); x++){
-                int out_pos = out_line + 4 * (x - pix->area.x0);
-                point[0] = x * unit_trans[0] + unit_trans[4];
-                pb[out_pos] = CLAMP_D_TO_U8( turbulence(0,point)*255 ); // CLAMP includes rounding!
-                pb[out_pos + 1] = CLAMP_D_TO_U8( turbulence(1,point)*255 );
-                pb[out_pos + 2] = CLAMP_D_TO_U8( turbulence(2,point)*255 );
-                pb[out_pos + 3] = CLAMP_D_TO_U8( turbulence(3,point)*255 );
-            }
-        }
-    } else {
-        for (int y = std::max(bbox_y0, pix->area.y0); y < std::min(bbox_y1, pix->area.y1); y++){
-            int out_line = (y - pix->area.y0) * pix->rs;
-            point[1] = y * unit_trans[3] + unit_trans[5];
-            for (int x = std::max(bbox_x0, pix->area.x0); x < std::min(bbox_x1, pix->area.x1); x++){
-                int out_pos = out_line + 4 * (x - pix->area.x0);
-                point[0] = x * unit_trans[0] + unit_trans[4];
-                pb[out_pos] = CLAMP_D_TO_U8( ((turbulence(0,point)*255) +255)/2 );
-                pb[out_pos + 1] = CLAMP_D_TO_U8( ((turbulence(1,point)*255)+255)/2 );
-                pb[out_pos + 2] = CLAMP_D_TO_U8( ((turbulence(2,point)*255) +255)/2 );
-                pb[out_pos + 3] = CLAMP_D_TO_U8( ((turbulence(3,point)*255) +255)/2 );
-            }
-        }
-    }
-
-    pix->empty = FALSE;
-#endif
-}
-
-void FilterTurbulence::update_pixbuffer(NR::IRect &area, FilterUnits const &units) {
-    int bbox_x0 = area.min()[NR::X];
-    int bbox_y0 = area.min()[NR::Y];
-    int bbox_x1 = area.max()[NR::X];
-    int bbox_y1 = area.max()[NR::Y];
-
-    //TurbulenceInit((long)seed);
-
-    if (!pix){
-        pix = new NRPixBlock;
-        nr_pixblock_setup_fast(pix, NR_PIXBLOCK_MODE_R8G8B8A8N, bbox_x0, bbox_y0, bbox_x1, bbox_y1, true);
-    }
-    else if (bbox_x0 != pix->area.x0 || bbox_y0 != pix->area.y0 ||
-        bbox_x1 != pix->area.x1 || bbox_y1 != pix->area.y1)
-    {
-        /* TODO: release-setup cycle not actually needed, if pixblock
-         * width and height don't change */
-        nr_pixblock_release(pix);
-        nr_pixblock_setup_fast(pix, NR_PIXBLOCK_MODE_R8G8B8A8N, bbox_x0, bbox_y0, bbox_x1, bbox_y1, true);
-    }
-
-    /* This limits pre-rendered turbulence to two megapixels. This is
-     * arbitary limit and could be something other, too.
-     * If bigger area is needed, visible area is rendered on demand. */
-    if (!pix || (pix->size != NR_PIXBLOCK_SIZE_TINY && pix->data.px == NULL) ||
-        ((bbox_x1 - bbox_x0) * (bbox_y1 - bbox_y0) > 2*1024*1024)) {
-        pix_data = NULL;
-        return;
-    }
-
-    render_area(pix, area, units);
-
-    pix_data = NR_PIXBLOCK_PX(pix);
-    
-    updated=true;
-    updated_area = area;
-}
-
 struct Turbulence {
     Turbulence(TurbulenceGenerator const &gen, Geom::Matrix const &trans, int x0, int y0)
         : _gen(gen)
diff --git a/src/display/nr-filter-turbulence.h b/src/display/nr-filter-turbulence.h
index b2bc3a185..fca6ebde3 100644
--- a/src/display/nr-filter-turbulence.h
+++ b/src/display/nr-filter-turbulence.h
@@ -36,9 +36,6 @@ enum FilterTurbulenceType {
     TURBULENCE_ENDTYPE
 };
 
-struct StitchInfo;
-
-//#define BSize 0x100
 class TurbulenceGenerator;
 
 class FilterTurbulence : public FilterPrimitive {
@@ -48,8 +45,6 @@ public:
     virtual ~FilterTurbulence();
 
     virtual void render_cairo(FilterSlot &slot);
-    void update_pixbuffer(NR::IRect &area, FilterUnits const &units);
-    void render_area(NRPixBlock *pix, NR::IRect &full_area, FilterUnits const &units);
 
     void set_baseFrequency(int axis, double freq);
     void set_numOctaves(int num);
@@ -62,13 +57,7 @@ private:
     TurbulenceGenerator *gen;
 
     void turbulenceInit(long seed);
-/*
-    long Turbulence_setup_seed(long lSeed);
-    long TurbulenceRandom(long lSeed);
-    void TurbulenceInit(long lSeed);
-    double TurbulenceNoise2(int nColorChannel, double vec[2], StitchInfo *pStitchInfo);
-    double turbulence(int nColorChannel, Geom::Point const &point);
-*/
+
     double XbaseFrequency, YbaseFrequency;
     int numOctaves;
     double seed;
@@ -76,12 +65,8 @@ private:
     FilterTurbulenceType type;
     bool updated;
     NR::IRect updated_area;
-    NRPixBlock *pix;
     unsigned char *pix_data;
 
-    //int uLatticeSelector[BSize + BSize + 2];
-    //double fGradient[4][BSize + BSize + 2][2];
-
     double fTileWidth;
     double fTileHeight;
 
diff --git a/src/display/nr-filter-units.h b/src/display/nr-filter-units.h
index dcf7e5838..12f0ca2ca 100644
--- a/src/display/nr-filter-units.h
+++ b/src/display/nr-filter-units.h
@@ -13,8 +13,6 @@
  */
 
 #include "sp-filter-units.h"
-#include "libnr/nr-matrix.h"
-#include "libnr/nr-rect.h"
 #include "libnr/nr-rect-l.h"
 #include <2geom/matrix.h>
 #include <2geom/rect.h>
diff --git a/src/display/nr-filter.cpp b/src/display/nr-filter.cpp
index 8c638415d..8273cc591 100644
--- a/src/display/nr-filter.cpp
+++ b/src/display/nr-filter.cpp
@@ -42,8 +42,6 @@
 
 #include "display/nr-arena.h"
 #include "display/nr-arena-item.h"
-#include "libnr/nr-pixblock.h"
-#include "libnr/nr-blit.h"
 #include <2geom/matrix.h>
 #include <2geom/rect.h>
 #include "svg/svg-length.h"
@@ -211,52 +209,6 @@ int Filter::render(NRArenaItem const *item, cairo_t *bgct, NRRectL const *bgarea
     cairo_set_operator(graphic, CAIRO_OPERATOR_OVER);
     cairo_surface_destroy(result);
 
-    //slot.set_units(units);
-
-    /*cairo_surface_t *in = cairo_surface_create_similar(
-        cairo_get_target(ct), CAIRO_CONTENT_COLOR_ALPHA,
-        area->x1 - area->x0, area->y1 - area->y0);
-    cairo_t *inct = cairo_create(in);
-    cairo_translate(inct, -area->x0, -area->y0);
-    cairo_set_source_surface(inct, cairo_get_target(ct), 0, 0);
-    cairo_paint(inct);
-    slot.set(NR_FILTER_SOURCEGRAPHIC, in);
-    cairo_destroy(inct);
-    cairo_surface_destroy(in);*/
-
-    /*NRPixBlock *in = new NRPixBlock;
-    nr_pixblock_setup_fast(in, pb->mode, pb->area.x0, pb->area.y0,
-                           pb->area.x1, pb->area.y1, true);
-    if (in->size != NR_PIXBLOCK_SIZE_TINY && in->data.px == NULL) {
-        g_warning("Inkscape::Filters::Filter::render: failed to reserve temporary buffer");
-        return 0;
-    }
-    nr_blit_pixblock_pixblock(in, pb);
-    in->empty = FALSE;
-    slot.set(NR_FILTER_SOURCEGRAPHIC, in);*/
-
-    // Check that we are rendering a non-empty area
-    /*in = slot.get(NR_FILTER_SOURCEGRAPHIC);
-    if (in->area.x1 - in->area.x0 <= 0 || in->area.y1 - in->area.y0 <= 0) {
-        if (in->area.x1 - in->area.x0 < 0 || in->area.y1 - in->area.y0 < 0) {
-            g_warning("Inkscape::Filters::Filter::render: negative area! (%d, %d) (%d, %d)",
-                      in->area.x0, in->area.y0, in->area.x1, in->area.y1);
-        }
-        return 0;
-    }
-    in = NULL; // in is now handled by FilterSlot, we should not touch it
-    */
-
-    /*for (int i = 0 ; i < _primitive_count ; i++) {
-        _primitive[i]->render(slot, units);
-    }*/
-
-    //slot.get_final(_output_slot, ct, area);
-
-    // Take note of the amount of used image slots
-    // -> next time this filter is rendered, we can reserve enough slots
-    // immediately
-    //_slot_count = slot.get_slot_count();
     return 0;
 }
 
@@ -327,10 +279,10 @@ void Filter::bbox_enlarge(NRRectL &bbox) {
 
     Geom::Rect enlarged = filter_effect_area(tmp_bbox);
 
-    bbox.x0 = (NR::ICoord)enlarged.min()[X];
-    bbox.y0 = (NR::ICoord)enlarged.min()[Y];
-    bbox.x1 = (NR::ICoord)enlarged.max()[X];
-    bbox.y1 = (NR::ICoord)enlarged.max()[Y];
+    bbox.x0 = (NR::ICoord) floor(enlarged.min()[X]);
+    bbox.y0 = (NR::ICoord) floor(enlarged.min()[Y]);
+    bbox.x1 = (NR::ICoord) ceil(enlarged.max()[X]);
+    bbox.y1 = (NR::ICoord) ceil(enlarged.max()[Y]);
 }
 
 Geom::Rect Filter::filter_effect_area(Geom::Rect const &bbox)
diff --git a/src/display/nr-filter.h b/src/display/nr-filter.h
index cd805043c..4db1ec988 100644
--- a/src/display/nr-filter.h
+++ b/src/display/nr-filter.h
@@ -16,8 +16,6 @@
 #include <cairo.h>
 #include "display/nr-filter-primitive.h"
 #include "display/nr-filter-types.h"
-#include "libnr/nr-pixblock.h"
-#include "libnr/nr-matrix.h"
 #include "libnr/nr-rect.h"
 #include "svg/svg-length.h"
 #include "sp-filter-units.h"
diff --git a/src/display/pixblock-scaler.cpp b/src/display/pixblock-scaler.cpp
deleted file mode 100644
index 1f2b1db3f..000000000
--- a/src/display/pixblock-scaler.cpp
+++ /dev/null
@@ -1,299 +0,0 @@
-#define __NR_PIXBLOCK_SCALER_CPP__
-
-/*
- * Functions for blitting pixblocks using scaling
- *
- * Author:
- *   Niko Kiirala <niko@kiirala.com>
- *
- * Copyright (C) 2006,2009 Niko Kiirala
- *
- * Released under GNU GPL, read the file 'COPYING' for more information
- */
-
-#include <glib.h>
-#include <cmath>
-#if defined (SOLARIS) && (SOLARIS == 8)
-#include "round.h"
-using Inkscape::round;
-#endif 
-using std::floor;
-
-#include "display/nr-filter-utils.h"
-#include "libnr/nr-pixblock.h"
-#include "libnr/nr-blit.h"
-#include <2geom/forward.h>
-
-namespace NR {
-
-struct RGBA {
-    double r, g, b, a;
-};
-
-/** Calculates cubically interpolated value of the four given pixel values.
- * The pixel values should be from four adjacent pixels in source image or
- * four adjacent interpolated values. len should be the x- or y-coordinate
- * (depending on interpolation direction) of the center of the target pixel
- * in source image coordinates.
- */
-__attribute__ ((const))
-inline static double sample(double const a, double const b,
-                            double const c, double const d,
-                            double const len)
-{
-    double lena = 1.5 + (len - round(len));
-    double lenb = 0.5 + (len - round(len));
-    double lenc = 0.5 - (len - round(len));
-    double lend = 1.5 - (len - round(len));
-    double const f = -0.5; // corresponds to cubic Hermite spline
-    double sum = 0;
-    sum += ((((f * lena) - 5.0 * f) * lena + 8.0 * f) * lena - 4 * f) * a;
-    sum += (((f + 2.0) * lenb - (f + 3.0)) * lenb * lenb + 1.0) * b;
-    sum += (((f + 2.0) * lenc - (f + 3.0)) * lenc * lenc + 1.0) * c;
-    sum += ((((f * lend) - 5.0 * f) * lend + 8.0 * f) * lend - 4 * f) * d;
-
-    return sum;
-}
-
-/**
- * Sanity check function for indexing pixblocks.
- * Catches reading and writing outside the pixblock area.
- * When enabled, decreases filter rendering speed massively.
- */
-inline static void _check_index(NRPixBlock const * const pb, int const location, int const line)
-{
-    if(false) {
-        int max_loc = pb->rs * (pb->area.y1 - pb->area.y0);
-        if (location < 0 || (location + 4) > max_loc)
-            g_warning("Location %d out of bounds (0 ... %d) at line %d", location, max_loc, line);
-    }
-}
-
-static void scale_bicubic_rgba(NRPixBlock *to, NRPixBlock *from,
-                               Geom::Matrix const &trans)
-{
-    if (NR_PIXBLOCK_BPP(from) != 4 || NR_PIXBLOCK_BPP(to) != 4) {
-        g_warning("A non-32-bpp image passed to scale_bicubic_rgba: scaling aborted.");
-        return;
-    }
-
-    bool free_from_on_exit = false;
-    if (from->mode != to->mode){
-        NRPixBlock *o_from = from;
-        from = new NRPixBlock;
-        nr_pixblock_setup_fast(from, to->mode, o_from->area.x0, o_from->area.y0, o_from->area.x1, o_from->area.y1, false);
-        nr_blit_pixblock_pixblock(from, o_from);
-        free_from_on_exit = true;
-    }
-
-    // Precalculate sizes of source and destination pixblocks
-    int from_width = from->area.x1 - from->area.x0;
-    int from_height = from->area.y1 - from->area.y0;
-    int to_width = to->area.x1 - to->area.x0;
-    int to_height = to->area.y1 - to->area.y0;
-
-    // from_step: when advancing one pixel in destination image,
-    // how much we should advance in source image
-    double from_stepx = 1.0 / trans[0];
-    double from_stepy = 1.0 / trans[3];
-    double from_diffx = from_stepx * (-trans[4]);
-    double from_diffy = from_stepy * (-trans[5]);
-    from_diffx = (to->area.x0 * from_stepx + from_diffx) - from->area.x0;
-    from_diffy = (to->area.y0 * from_stepy + from_diffy) - from->area.y0;
-
-    // Loop through every pixel of destination image, a line at a time
-    for (int to_y = 0 ; to_y < to_height ; to_y++) {
-        double from_y = (to_y + 0.5) * from_stepy + from_diffy;
-        // Pre-calculate beginning of the four horizontal lines, from
-        // which we should read
-        int from_line[4];
-        for (int i = 0 ; i < 4 ; i++) {
-            int fy_line = (int)round(from_y) + i - 2;
-            if (fy_line >= 0) {
-                if (fy_line < from_height) {
-                    from_line[i] = fy_line * from->rs;
-                } else {
-                    from_line[i] = (from_height - 1) * from->rs;
-                }
-            } else {
-                from_line[i] = 0;
-            }
-        }
-        // Loop through this horizontal line in destination image
-        // For every pixel, calculate the color of pixel with
-        // bicubic interpolation and set the pixel value in destination image
-        for (int to_x = 0 ; to_x < to_width ; to_x++) {
-            double from_x = (to_x + 0.5) * from_stepx + from_diffx;
-            RGBA line[4];
-            for (int i = 0 ; i < 4 ; i++) {
-                int k = (int)round(from_x) + i - 2;
-                if (k < 0) k = 0;
-                if (k >= from_width) k = from_width - 1;
-                k *= 4;
-                _check_index(from, from_line[0] + k, __LINE__);
-                _check_index(from, from_line[1] + k, __LINE__);
-                _check_index(from, from_line[2] + k, __LINE__);
-                _check_index(from, from_line[3] + k, __LINE__);
-                line[i].r = sample(NR_PIXBLOCK_PX(from)[from_line[0] + k],
-                                   NR_PIXBLOCK_PX(from)[from_line[1] + k],
-                                   NR_PIXBLOCK_PX(from)[from_line[2] + k],
-                                   NR_PIXBLOCK_PX(from)[from_line[3] + k],
-                                   from_y);
-                line[i].g = sample(NR_PIXBLOCK_PX(from)[from_line[0] + k + 1],
-                                   NR_PIXBLOCK_PX(from)[from_line[1] + k + 1],
-                                   NR_PIXBLOCK_PX(from)[from_line[2] + k + 1],
-                                   NR_PIXBLOCK_PX(from)[from_line[3] + k + 1],
-                                   from_y);
-                line[i].b = sample(NR_PIXBLOCK_PX(from)[from_line[0] + k + 2],
-                                   NR_PIXBLOCK_PX(from)[from_line[1] + k + 2],
-                                   NR_PIXBLOCK_PX(from)[from_line[2] + k + 2],
-                                   NR_PIXBLOCK_PX(from)[from_line[3] + k + 2],
-                                   from_y);
-                line[i].a = sample(NR_PIXBLOCK_PX(from)[from_line[0] + k + 3],
-                                   NR_PIXBLOCK_PX(from)[from_line[1] + k + 3],
-                                   NR_PIXBLOCK_PX(from)[from_line[2] + k + 3],
-                                   NR_PIXBLOCK_PX(from)[from_line[3] + k + 3],
-                                   from_y);
-            }
-            RGBA result;
-            result.r = round(sample(line[0].r, line[1].r, line[2].r, line[3].r,
-                                    from_x));
-            result.g = round(sample(line[0].g, line[1].g, line[2].g, line[3].g,
-                                    from_x));
-            result.b = round(sample(line[0].b, line[1].b, line[2].b, line[3].b,
-                                    from_x));
-            result.a = round(sample(line[0].a, line[1].a, line[2].a, line[3].a,
-                                    from_x));
-
-            _check_index(to, to_y * to->rs + to_x * 4, __LINE__);
-
-            using Inkscape::Filters::clamp;
-            using Inkscape::Filters::clamp_alpha;
-            if (to->mode == NR_PIXBLOCK_MODE_R8G8B8A8P) {
-                /* Clamp the colour channels to range from 0 to result.a to
-                 * make sure, we don't exceed 100% per colour channel with
-                 * images that have premultiplied alpha */
-
-                int const alpha = clamp((int)result.a);
-
-                NR_PIXBLOCK_PX(to)[to_y * to->rs + to_x * 4]
-                    = clamp_alpha((int)result.r, alpha);
-                NR_PIXBLOCK_PX(to)[to_y * to->rs + to_x * 4 + 1]
-                    = clamp_alpha((int)result.g, alpha);
-                NR_PIXBLOCK_PX(to)[to_y * to->rs + to_x * 4 + 2]
-                    = clamp_alpha((int)result.b, alpha);
-                NR_PIXBLOCK_PX(to)[to_y * to->rs + to_x * 4 + 3] = alpha;
-            } else {
-                NR_PIXBLOCK_PX(to)[to_y * to->rs + to_x * 4]
-                    = clamp((int)result.r);
-                NR_PIXBLOCK_PX(to)[to_y * to->rs + to_x * 4 + 1]
-                    = clamp((int)result.g);
-                NR_PIXBLOCK_PX(to)[to_y * to->rs + to_x * 4 + 2]
-                    = clamp((int)result.b);
-                NR_PIXBLOCK_PX(to)[to_y * to->rs + to_x * 4 + 3]
-                    = clamp((int)result.a);
-            }
-        }
-    }
-    if (free_from_on_exit) {
-        nr_pixblock_release(from);
-        delete from;
-    }
-
-}
-
-void scale_bicubic_alpha(NRPixBlock *to, NRPixBlock *from,
-                         Geom::Matrix const &trans)
-{
-    if (NR_PIXBLOCK_BPP(from) != 1 || NR_PIXBLOCK_BPP(to) != 1) {
-        g_warning("A non-8-bpp image passed to scale_bicubic_alpha: scaling aborted.");
-        return;
-    }
-
-    // Precalculate sizes of source and destination pixblocks
-    int from_width = from->area.x1 - from->area.x0;
-    int from_height = from->area.y1 - from->area.y0;
-    int to_width = to->area.x1 - to->area.x0;
-    int to_height = to->area.y1 - to->area.y0;
-
-    // from_step: when advancing one pixel in destination image,
-    // how much we should advance in source image
-    double from_stepx = 1.0 / trans[0];
-    double from_stepy = 1.0 / trans[3];
-    double from_diffx = from_stepx * (-trans[4]);
-    double from_diffy = from_stepy * (-trans[5]);
-    from_diffx = (to->area.x0 * from_stepx + from_diffx) - from->area.x0;
-    from_diffy = (to->area.y0 * from_stepy + from_diffy) - from->area.y0;
-
-    // Loop through every pixel of destination image, a line at a time
-    for (int to_y = 0 ; to_y < to_height ; to_y++) {
-        double from_y = (to_y + 0.5) * from_stepy - from_diffy;
-        // Pre-calculate beginning of the four horizontal lines, from
-        // which we should read
-        int from_line[4];
-        for (int i = 0 ; i < 4 ; i++) {
-            int fy_line = (int)round(from_y) + i - 2;
-            if (fy_line >= 0) {
-                if (fy_line < from_height) {
-                    from_line[i] = fy_line * from->rs;
-                } else {
-                    from_line[i] = (from_height - 1) * from->rs;
-                }
-            } else {
-                from_line[i] = 0;
-            }
-        }
-        // Loop through this horizontal line in destination image
-        // For every pixel, calculate the color of pixel with
-        // bicubic interpolation and set the pixel value in destination image
-        for (int to_x = 0 ; to_x < to_width ; to_x++) {
-            double from_x = (to_x + 0.5) * from_stepx - from_diffx;
-            double line[4];
-            for (int i = 0 ; i < 4 ; i++) {
-                int k = (int)round(from_x) + i - 2;
-                if (k < 0) k = 0;
-                if (k >= from_width) k = from_width - 1;
-                _check_index(from, from_line[0] + k, __LINE__);
-                _check_index(from, from_line[1] + k, __LINE__);
-                _check_index(from, from_line[2] + k, __LINE__);
-                _check_index(from, from_line[3] + k, __LINE__);
-                line[i] = sample(NR_PIXBLOCK_PX(from)[from_line[0] + k],
-                                 NR_PIXBLOCK_PX(from)[from_line[1] + k],
-                                 NR_PIXBLOCK_PX(from)[from_line[2] + k],
-                                 NR_PIXBLOCK_PX(from)[from_line[3] + k],
-                                 from_y);
-            }
-            int result;
-            result = (int)round(sample(line[0], line[1], line[2], line[3],
-                                       from_x));
-
-            _check_index(to, to_y * to->rs + to_x, __LINE__);
-
-            NR_PIXBLOCK_PX(to)[to_y * to->rs + to_x]
-                = Inkscape::Filters::clamp(result);
-        }
-    }
-}
-
-void scale_bicubic(NRPixBlock *to, NRPixBlock *from, Geom::Matrix const &trans)
-{
-    if (NR_PIXBLOCK_BPP(to) == 4 && NR_PIXBLOCK_BPP(from) == 4) {
-        scale_bicubic_rgba(to, from, trans);
-    } else if (NR_PIXBLOCK_BPP(to) == 1 && NR_PIXBLOCK_BPP(from) == 1) {
-        scale_bicubic_alpha(to, from, trans);
-    } else {
-        g_warning("NR::scale_bicubic: unsupported bitdepths for scaling: to %d, from %d", NR_PIXBLOCK_BPP(to), NR_PIXBLOCK_BPP(from));
-    }
-}
-
-} /* namespace NR */
-/*
-  Local Variables:
-  mode:c++
-  c-file-style:"stroustrup"
-  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
-  indent-tabs-mode:nil
-  fill-column:99
-  End:
-*/
-// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :
diff --git a/src/display/pixblock-scaler.h b/src/display/pixblock-scaler.h
deleted file mode 100644
index 8e9b1ec62..000000000
--- a/src/display/pixblock-scaler.h
+++ /dev/null
@@ -1,40 +0,0 @@
-#ifndef __NR_PIXBLOCK_SCALER_H__
-#define __NR_PIXBLOCK_SCALER_H__
-
-/*
- * Functions for blitting pixblocks using scaling
- *
- * Author:
- *   Niko Kiirala <niko@kiirala.com>
- *
- * Copyright (C) 2006 Niko Kiirala
- *
- * Released under GNU GPL, read the file 'COPYING' for more information
- */
-
-#include "libnr/nr-pixblock.h"
-#include <2geom/forward.h>
-
-namespace NR {
-
-/** Blits the second pixblock to the first.
- * Image in source pixblock is scaled to the size of destination pixblock
- * using bicubic interpolation.
- * Source pixblock is not modified in process.
- * Only works for 32-bpp images.
- */
-void scale_bicubic(NRPixBlock *to, NRPixBlock *from, Geom::Matrix const &trans);
-
-} /* namespace NR */
-
-#endif // __NR_PIXBLOCK_SCALER_H__
-/*
-  Local Variables:
-  mode:c++
-  c-file-style:"stroustrup"
-  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
-  indent-tabs-mode:nil
-  fill-column:99
-  End:
-*/
-// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :
diff --git a/src/display/pixblock-transform.cpp b/src/display/pixblock-transform.cpp
deleted file mode 100644
index af05a9b88..000000000
--- a/src/display/pixblock-transform.cpp
+++ /dev/null
@@ -1,279 +0,0 @@
-#define __NR_PIXBLOCK_SCALER_CPP__
-
-/*
- * Functions for blitting pixblocks using matrix transformation
- *
- * Author:
- *   Niko Kiirala <niko@kiirala.com>
- *
- * Copyright (C) 2006,2009 Niko Kiirala
- *
- * Released under GNU GPL, read the file 'COPYING' for more information
- */
-
-#include <glib.h>
-#include <cmath>
-#if defined (SOLARIS) && (SOLARIS == 8)
-#include "round.h"
-using Inkscape::round;
-#endif 
-using std::floor;
-
-#include "display/nr-filter-utils.h"
-
-#include "libnr/nr-blit.h"
-#include "libnr/nr-pixblock.h"
-#include <2geom/matrix.h>
-
-namespace NR {
-
-struct RGBA {
-    double r, g, b, a;
-};
-struct RGBAi {
-    int r, g, b, a;
-};
-
-/**
- * Sanity check function for indexing pixblocks.
- * Catches reading and writing outside the pixblock area.
- * When enabled, decreases filter rendering speed massively.
- */
-inline void _check_index(NRPixBlock const * const pb, int const location, int const line)
-{
-    if(false) {
-        int max_loc = pb->rs * (pb->area.y1 - pb->area.y0);
-        if (location < 0 || (location + 4) > max_loc)
-            g_warning("Location %d out of bounds (0 ... %d) at line %d", location, max_loc, line);
-    }
-}
-
-void transform_nearest(NRPixBlock *to, NRPixBlock *from, Geom::Matrix const &trans)
-{
-    if (NR_PIXBLOCK_BPP(from) != 4 || NR_PIXBLOCK_BPP(to) != 4) {
-        g_warning("A non-32-bpp image passed to transform_nearest: scaling aborted.");
-        return;
-    }
-
-    bool free_from_on_exit = false;
-    if (from->mode != to->mode){
-        NRPixBlock *o_from = from;
-        from = new NRPixBlock;
-        nr_pixblock_setup_fast(from, to->mode, o_from->area.x0, o_from->area.y0, o_from->area.x1, o_from->area.y1, false);
-        nr_blit_pixblock_pixblock(from, o_from);
-        free_from_on_exit = true;
-    }
-
-    // Precalculate sizes of source and destination pixblocks
-    int from_width = from->area.x1 - from->area.x0;
-    int from_height = from->area.y1 - from->area.y0;
-    int to_width = to->area.x1 - to->area.x0;
-    int to_height = to->area.y1 - to->area.y0;
-
-    Geom::Matrix itrans = trans.inverse();
-
-    // Loop through every pixel of destination image, a line at a time
-    for (int to_y = 0 ; to_y < to_height ; to_y++) {
-        for (int to_x = 0 ; to_x < to_width ; to_x++) {
-            RGBAi result = {0,0,0,0};
-
-            int from_x = (int)floor(itrans[0] * (to_x + 0.5 + to->area.x0)
-                                    + itrans[2] * (to_y + 0.5 + to->area.y0)
-                                    + itrans[4]);
-            from_x -= from->area.x0;
-            int from_y = (int)floor(itrans[1] * (to_x + 0.5 + to->area.x0)
-                                    + itrans[3] * (to_y + 0.5 + to->area.y0)
-                                    + itrans[5]);
-            from_y -= from->area.y0;
-
-            if (from_x >= 0 && from_x < from_width
-                && from_y >= 0 && from_y < from_height) {
-                _check_index(from, from_y * from->rs + from_x * 4, __LINE__);
-                result.r = NR_PIXBLOCK_PX(from)[from_y * from->rs + from_x * 4];
-                result.g = NR_PIXBLOCK_PX(from)[from_y * from->rs + from_x * 4 + 1];
-                result.b = NR_PIXBLOCK_PX(from)[from_y * from->rs + from_x * 4 + 2];
-                result.a = NR_PIXBLOCK_PX(from)[from_y * from->rs + from_x * 4 + 3];
-            }
-
-            _check_index(to, to_y * to->rs + to_x * 4, __LINE__);
-            NR_PIXBLOCK_PX(to)[to_y * to->rs + to_x * 4] = result.r;
-            NR_PIXBLOCK_PX(to)[to_y * to->rs + to_x * 4 + 1] = result.g;
-            NR_PIXBLOCK_PX(to)[to_y * to->rs + to_x * 4 + 2] = result.b;
-            NR_PIXBLOCK_PX(to)[to_y * to->rs + to_x * 4 + 3] = result.a;
-        }
-    }
-    if (free_from_on_exit) {
-        nr_pixblock_release(from);
-        delete from;
-    }
-}
-
-/** Calculates cubically interpolated value of the four given pixel values.
- * The pixel values should be from four adjacent pixels in source image or
- * four adjacent interpolated values. len should be the x- or y-coordinate
- * (depending on interpolation direction) of the center of the target pixel
- * in source image coordinates.
- */
-__attribute__ ((const))
-inline static double sample(double const a, double const b,
-                            double const c, double const d,
-                            double const len)
-{
-    double lena = 1.5 + (len - round(len));
-    double lenb = 0.5 + (len - round(len));
-    double lenc = 0.5 - (len - round(len));
-    double lend = 1.5 - (len - round(len));
-    double const f = -0.5; // corresponds to cubic Hermite spline
-    double sum = 0;
-    sum += ((((f * lena) - 5.0 * f) * lena + 8.0 * f) * lena - 4 * f) * a;
-    sum += (((f + 2.0) * lenb - (f + 3.0)) * lenb * lenb + 1.0) * b;
-    sum += (((f + 2.0) * lenc - (f + 3.0)) * lenc * lenc + 1.0) * c;
-    sum += ((((f * lend) - 5.0 * f) * lend + 8.0 * f) * lend - 4 * f) * d;
-
-    return sum;
-}
-
-void transform_bicubic(NRPixBlock *to, NRPixBlock *from, Geom::Matrix const &trans)
-{
-    if (NR_PIXBLOCK_BPP(from) != 4 || NR_PIXBLOCK_BPP(to) != 4) {
-        g_warning("A non-32-bpp image passed to transform_bicubic: scaling aborted.");
-        return;
-    }
-
-    bool free_from_on_exit = false;
-    if (from->mode != to->mode){
-        NRPixBlock *o_from = from;
-        from = new NRPixBlock;
-        nr_pixblock_setup_fast(from, to->mode, o_from->area.x0, o_from->area.y0, o_from->area.x1, o_from->area.y1, false);
-        nr_blit_pixblock_pixblock(from, o_from);
-        free_from_on_exit = true;
-    }
-
-    if (from->mode != NR_PIXBLOCK_MODE_R8G8B8A8P) {
-        // TODO: Fix this... (The problem is that for interpolation non-premultiplied colors should be premultiplied...)
-        g_warning("transform_bicubic does not properly support non-premultiplied images");
-    }
-    
-    // Precalculate sizes of source and destination pixblocks
-    int from_width = from->area.x1 - from->area.x0;
-    int from_height = from->area.y1 - from->area.y0;
-    int to_width = to->area.x1 - to->area.x0;
-    int to_height = to->area.y1 - to->area.y0;
-
-    Geom::Matrix itrans = trans.inverse();
-
-    // Loop through every pixel of destination image, a line at a time
-    for (int to_y = 0 ; to_y < to_height ; to_y++) {
-        for (int to_x = 0 ; to_x < to_width ; to_x++) {
-            double from_x = itrans[0] * (to_x + 0.5 + to->area.x0)
-                + itrans[2] * (to_y + 0.5 + to->area.y0)
-                + itrans[4] - from->area.x0;
-            double from_y = itrans[1] * (to_x + 0.5 + to->area.x0)
-                + itrans[3] * (to_y + 0.5 + to->area.y0)
-                + itrans[5] - from->area.y0;
-
-            if (from_x < 0 || from_x >= from_width ||
-                from_y < 0 || from_y >= from_height) {
-                continue;
-            }
-
-            RGBA line[4];
-
-            int from_line[4];
-            for (int i = 0 ; i < 4 ; i++) {
-                int fy_line = (int)round(from_y) + i - 2;
-                if (fy_line >= 0) {
-                    if (fy_line < from_height) {
-                        from_line[i] = fy_line * from->rs;
-                    } else {
-                        from_line[i] = (from_height - 1) * from->rs;
-                    }
-                } else {
-                    from_line[i] = 0;
-                }                
-            }
-
-            for (int i = 0 ; i < 4 ; i++) {
-                int k = (int)round(from_x) + i - 2;
-                if (k < 0) k = 0;
-                if (k >= from_width) k = from_width - 1;
-                k *= 4;
-                _check_index(from, from_line[0] + k, __LINE__);
-                _check_index(from, from_line[1] + k, __LINE__);
-                _check_index(from, from_line[2] + k, __LINE__);
-                _check_index(from, from_line[3] + k, __LINE__);
-                line[i].r = sample(NR_PIXBLOCK_PX(from)[from_line[0] + k],
-                                   NR_PIXBLOCK_PX(from)[from_line[1] + k],
-                                   NR_PIXBLOCK_PX(from)[from_line[2] + k],
-                                   NR_PIXBLOCK_PX(from)[from_line[3] + k],
-                                   from_y);
-                line[i].g = sample(NR_PIXBLOCK_PX(from)[from_line[0] + k + 1],
-                                   NR_PIXBLOCK_PX(from)[from_line[1] + k + 1],
-                                   NR_PIXBLOCK_PX(from)[from_line[2] + k + 1],
-                                   NR_PIXBLOCK_PX(from)[from_line[3] + k + 1],
-                                   from_y);
-                line[i].b = sample(NR_PIXBLOCK_PX(from)[from_line[0] + k + 2],
-                                   NR_PIXBLOCK_PX(from)[from_line[1] + k + 2],
-                                   NR_PIXBLOCK_PX(from)[from_line[2] + k + 2],
-                                   NR_PIXBLOCK_PX(from)[from_line[3] + k + 2],
-                                   from_y);
-                line[i].a = sample(NR_PIXBLOCK_PX(from)[from_line[0] + k + 3],
-                                   NR_PIXBLOCK_PX(from)[from_line[1] + k + 3],
-                                   NR_PIXBLOCK_PX(from)[from_line[2] + k + 3],
-                                   NR_PIXBLOCK_PX(from)[from_line[3] + k + 3],
-                                   from_y);
-            }
-            RGBA result;
-            result.r = round(sample(line[0].r, line[1].r, line[2].r, line[3].r,
-                                    from_x));
-            result.g = round(sample(line[0].g, line[1].g, line[2].g, line[3].g,
-                                    from_x));
-            result.b = round(sample(line[0].b, line[1].b, line[2].b, line[3].b,
-                                    from_x));
-            result.a = round(sample(line[0].a, line[1].a, line[2].a, line[3].a,
-                                    from_x));
-
-            using Inkscape::Filters::clamp;
-            using Inkscape::Filters::clamp_alpha;
-            _check_index(to, to_y * to->rs + to_x * 4, __LINE__);
-            if (to->mode == NR_PIXBLOCK_MODE_R8G8B8A8P) {
-                /* Make sure, none of the RGB channels exceeds 100% intensity
-                 * in premultiplied output */
-                int const alpha = clamp((int)result.a);
-                NR_PIXBLOCK_PX(to)[to_y * to->rs + to_x * 4] = 
-                    clamp_alpha((int)result.r, alpha);
-                NR_PIXBLOCK_PX(to)[to_y * to->rs + to_x * 4 + 1] = 
-                    clamp_alpha((int)result.g, alpha);
-                NR_PIXBLOCK_PX(to)[to_y * to->rs + to_x * 4 + 2] = 
-                    clamp_alpha((int)result.b, alpha);
-                NR_PIXBLOCK_PX(to)[to_y * to->rs + to_x * 4 + 3] = alpha;
-            } else {
-                /* Clamp the output to unsigned char range */
-                NR_PIXBLOCK_PX(to)[to_y * to->rs + to_x * 4]
-                    = clamp((int)result.r);
-                NR_PIXBLOCK_PX(to)[to_y * to->rs + to_x * 4 + 1]
-                    = clamp((int)result.g);
-                NR_PIXBLOCK_PX(to)[to_y * to->rs + to_x * 4 + 2]
-                    = clamp((int)result.b);
-                NR_PIXBLOCK_PX(to)[to_y * to->rs + to_x * 4 + 3]
-                    = clamp((int)result.a);
-            }
-        }
-    }
-    if (free_from_on_exit) {
-        nr_pixblock_release(from);
-        delete from;
-    }
-}
-
-} /* namespace NR */
-/*
-  Local Variables:
-  mode:c++
-  c-file-style:"stroustrup"
-  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
-  indent-tabs-mode:nil
-  fill-column:99
-  End:
-*/
-// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :
diff --git a/src/display/pixblock-transform.h b/src/display/pixblock-transform.h
deleted file mode 100644
index 3ba00a08f..000000000
--- a/src/display/pixblock-transform.h
+++ /dev/null
@@ -1,35 +0,0 @@
-#ifndef __NR_PIXBLOCK_TRANSFORM_H__
-#define __NR_PIXBLOCK_TRANSFORM_H__
-
-/*
- * Functions for blitting pixblocks using matrix transfomation
- *
- * Author:
- *   Niko Kiirala <niko@kiirala.com>
- *
- * Copyright (C) 2006 Niko Kiirala
- *
- * Released under GNU GPL, read the file 'COPYING' for more information
- */
-
-#include "libnr/nr-pixblock.h"
-#include <2geom/forward.h>
-
-namespace NR {
-
-void transform_nearest(NRPixBlock *to, NRPixBlock *from, Geom::Matrix const &trans);
-void transform_bicubic(NRPixBlock *to, NRPixBlock *from, Geom::Matrix const &trans);
-
-} /* namespace NR */
-
-#endif // __NR_PIXBLOCK_TRANSFORM_H__
-/*
-  Local Variables:
-  mode:c++
-  c-file-style:"stroustrup"
-  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
-  indent-tabs-mode:nil
-  fill-column:99
-  End:
-*/
-// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :
diff --git a/src/display/sp-canvas.cpp b/src/display/sp-canvas.cpp
index 4c74af6d9..8be585a43 100644
--- a/src/display/sp-canvas.cpp
+++ b/src/display/sp-canvas.cpp
@@ -20,8 +20,6 @@
 # include "config.h"
 #endif
 
-#include <libnr/nr-pixblock.h>
-
 #include <gtk/gtkmain.h>
 #include <gtk/gtksignal.h>
 #include <gtk/gtkversion.h>
@@ -33,7 +31,6 @@
 #include <display/sp-canvas.h>
 #include "display-forward.h"
 #include <2geom/matrix.h>
-#include <libnr/nr-convex-hull.h>
 #include "preferences.h"
 #include "inkscape.h"
 #include "sodipodi-ctrlrect.h"
@@ -41,7 +38,6 @@
 #include "color-profile-fns.h"
 #endif // ENABLE_LCMS
 #include "display/rendermode.h"
-#include "libnr/nr-blit.h"
 #include "display/cairo-utils.h"
 #include "debug/gdk-event-latency-tracker.h"
 #include "desktop.h"
@@ -1758,6 +1754,7 @@ sp_canvas_paint_single_buffer (SPCanvas *canvas, int x0, int y0, int x1, int y1,
     }
 #endif
 
+
     // output to X
     cairo_destroy(buf.ct);
 
@@ -1775,12 +1772,6 @@ sp_canvas_paint_single_buffer (SPCanvas *canvas, int x0, int y0, int x1, int y1,
     //cairo_destroy (buf.ct);
     //cairo_surface_finish (cst);
     //cairo_surface_destroy (cst);
-
-    if (canvas->rendermode != Inkscape::RENDERMODE_OUTLINE) {
-        nr_pixelstore_256K_free (buf.buf);
-    } else {
-        nr_pixelstore_1M_free (buf.buf);
-    }
 }
 
 struct PaintRectSetup {
diff --git a/src/display/testnr.cpp b/src/display/testnr.cpp
deleted file mode 100644
index 3a3478d28..000000000
--- a/src/display/testnr.cpp
+++ /dev/null
@@ -1,24 +0,0 @@
-#include <gtk/gtk.h>
-#include "sp-arena.h"
-
-int
-main (int argc, char ** argv)
-{
-	GtkWidget * w, * c;
-
-	gtk_init (&argc, &argv);
-
-	w = gtk_window_new (GTK_WINDOW_TOPLEVEL);
-
-	c = sp_arena_new ();
-	gtk_widget_show (c);
-
-	gtk_container_add (GTK_CONTAINER (w), c);
-
-	gtk_widget_show (w);
-
-	gtk_main ();
-
-	return 0;
-}
-