8 files changed, 68 insertions, 375 deletions

diff --git a/client/canvas.cpp b/client/canvas.cpp
index 516a874c..ba446c9a 100644
--- a/client/canvas.cpp
+++ b/client/canvas.cpp
@@ -23,7 +23,8 @@
 
 Canvas::Canvas(PixmapCache& pixmap_cache, PaletteCache& palette_cache,
                GlzDecoderWindow &glz_decoder_window)
-    : _pixmap_cache (pixmap_cache)
+    : _canvas (NULL)
+    , _pixmap_cache (pixmap_cache)
     , _palette_cache (palette_cache)
     , _glz_decoder(glz_decoder_window, _glz_handler, _glz_debug)
 {
@@ -31,8 +32,17 @@ Canvas::Canvas(PixmapCache& pixmap_cache, PaletteCache& palette_cache,
 
 Canvas::~Canvas()
 {
+    /* _canvas is both set and destroyed by derived class */
 }
 
+void Canvas::clear()
+{
+    if (_canvas) {
+        _canvas->ops->clear(_canvas);
+    }
+}
+
+
 inline void Canvas::access_test(void *ptr, size_t size)
 {
     if ((unsigned long)ptr < _base || (unsigned long)ptr + size > _max) {
@@ -107,7 +117,7 @@ void Canvas::begin_draw(SpiceMsgDisplayBase& base, int size, size_t min_size)
 {
     _base = (unsigned long)&base;
     _max = _base + size;
-    set_access_params(_base, _max);
+    _canvas->ops->set_access_params(_canvas, _base, _max);
     access_test(&base, min_size);
     localalize_ptr(&base.clip.data);
 }
@@ -117,7 +127,8 @@ void Canvas::draw_fill(SpiceMsgDisplayDrawFill& fill, int size)
     begin_draw(fill.base, size, sizeof(SpiceMsgDisplayDrawFill));
     localalize_brush(fill.data.brush);
     localalize_mask(fill.data.mask);
-    draw_fill(&fill.base.box, &fill.base.clip, &fill.data);
+    _canvas->ops->draw_fill(_canvas, &fill.base.box, &fill.base.clip, &fill.data);
+    touched_bbox(&fill.base.box);
 }
 
 void Canvas::draw_text(SpiceMsgDisplayDrawText& text, int size)
@@ -126,7 +137,8 @@ void Canvas::draw_text(SpiceMsgDisplayDrawText& text, int size)
     localalize_brush(text.data.fore_brush);
     localalize_brush(text.data.back_brush);
     localalize_ptr(&text.data.str);
-    draw_text(&text.base.box, &text.base.clip, &text.data);
+    _canvas->ops->draw_text(_canvas, &text.base.box, &text.base.clip, &text.data);
+    touched_bbox(&text.base.box);
 }
 
 void Canvas::draw_opaque(SpiceMsgDisplayDrawOpaque& opaque, int size)
@@ -135,7 +147,8 @@ void Canvas::draw_opaque(SpiceMsgDisplayDrawOpaque& opaque, int size)
     localalize_brush(opaque.data.brush);
     localalize_image(&opaque.data.src_bitmap);
     localalize_mask(opaque.data.mask);
-    draw_opaque(&opaque.base.box, &opaque.base.clip, &opaque.data);
+    _canvas->ops->draw_opaque(_canvas, &opaque.base.box, &opaque.base.clip, &opaque.data);
+    touched_bbox(&opaque.base.box);
 }
 
 void Canvas::draw_copy(SpiceMsgDisplayDrawCopy& copy, int size)
@@ -143,27 +156,31 @@ void Canvas::draw_copy(SpiceMsgDisplayDrawCopy& copy, int size)
     begin_draw(copy.base, size, sizeof(SpiceMsgDisplayDrawCopy));
     localalize_image(&copy.data.src_bitmap);
     localalize_mask(copy.data.mask);
-    draw_copy(&copy.base.box, &copy.base.clip, &copy.data);
+    _canvas->ops->draw_copy(_canvas, &copy.base.box, &copy.base.clip, &copy.data);
+    touched_bbox(&copy.base.box);
 }
 
 void Canvas::draw_transparent(SpiceMsgDisplayDrawTransparent& transparent, int size)
 {
     begin_draw(transparent.base, size, sizeof(SpiceMsgDisplayDrawTransparent));
     localalize_image(&transparent.data.src_bitmap);
-    draw_transparent(&transparent.base.box, &transparent.base.clip, &transparent.data);
+    _canvas->ops->draw_transparent(_canvas, &transparent.base.box, &transparent.base.clip, &transparent.data);
+    touched_bbox(&transparent.base.box);
 }
 
 void Canvas::draw_alpha_blend(SpiceMsgDisplayDrawAlphaBlend& alpha_blend, int size)
 {
     begin_draw(alpha_blend.base, size, sizeof(SpiceMsgDisplayDrawAlphaBlend));
     localalize_image(&alpha_blend.data.src_bitmap);
-    draw_alpha_blend(&alpha_blend.base.box, &alpha_blend.base.clip, &alpha_blend.data);
+    _canvas->ops->draw_alpha_blend(_canvas, &alpha_blend.base.box, &alpha_blend.base.clip, &alpha_blend.data);
+    touched_bbox(&alpha_blend.base.box);
 }
 
 void Canvas::copy_bits(SpiceMsgDisplayCopyBits& copy, int size)
 {
     begin_draw(copy.base, size, sizeof(SpiceMsgDisplayCopyBits));
-    copy_bits(&copy.base.box, &copy.base.clip, &copy.src_pos);
+    _canvas->ops->copy_bits(_canvas, &copy.base.box, &copy.base.clip, &copy.src_pos);
+    touched_bbox(&copy.base.box);
 }
 
 void Canvas::draw_blend(SpiceMsgDisplayDrawBlend& blend, int size)
@@ -171,28 +188,32 @@ void Canvas::draw_blend(SpiceMsgDisplayDrawBlend& blend, int size)
     begin_draw(blend.base, size, sizeof(SpiceMsgDisplayDrawBlend));
     localalize_image(&blend.data.src_bitmap);
     localalize_mask(blend.data.mask);
-    draw_blend(&blend.base.box, &blend.base.clip, &blend.data);
+    _canvas->ops->draw_blend(_canvas, &blend.base.box, &blend.base.clip, &blend.data);
+    touched_bbox(&blend.base.box);
 }
 
 void Canvas::draw_blackness(SpiceMsgDisplayDrawBlackness& blackness, int size)
 {
     begin_draw(blackness.base, size, sizeof(SpiceMsgDisplayDrawBlackness));
     localalize_mask(blackness.data.mask);
-    draw_blackness(&blackness.base.box, &blackness.base.clip, &blackness.data);
+    _canvas->ops->draw_blackness(_canvas, &blackness.base.box, &blackness.base.clip, &blackness.data);
+    touched_bbox(&blackness.base.box);
 }
 
 void Canvas::draw_whiteness(SpiceMsgDisplayDrawWhiteness& whiteness, int size)
 {
     begin_draw(whiteness.base, size, sizeof(SpiceMsgDisplayDrawWhiteness));
     localalize_mask(whiteness.data.mask);
-    draw_whiteness(&whiteness.base.box, &whiteness.base.clip, &whiteness.data);
+    _canvas->ops->draw_whiteness(_canvas, &whiteness.base.box, &whiteness.base.clip, &whiteness.data);
+    touched_bbox(&whiteness.base.box);
 }
 
 void Canvas::draw_invers(SpiceMsgDisplayDrawInvers& invers, int size)
 {
     begin_draw(invers.base, size, sizeof(SpiceMsgDisplayDrawInvers));
     localalize_mask(invers.data.mask);
-    draw_invers(&invers.base.box, &invers.base.clip, &invers.data);
+    _canvas->ops->draw_invers(_canvas, &invers.base.box, &invers.base.clip, &invers.data);
+    touched_bbox(&invers.base.box);
 }
 
 void Canvas::draw_rop3(SpiceMsgDisplayDrawRop3& rop3, int size)
@@ -201,7 +222,8 @@ void Canvas::draw_rop3(SpiceMsgDisplayDrawRop3& rop3, int size)
     localalize_brush(rop3.data.brush);
     localalize_image(&rop3.data.src_bitmap);
     localalize_mask(rop3.data.mask);
-    draw_rop3(&rop3.base.box, &rop3.base.clip, &rop3.data);
+    _canvas->ops->draw_rop3(_canvas, &rop3.base.box, &rop3.base.clip, &rop3.data);
+    touched_bbox(&rop3.base.box);
 }
 
 void Canvas::draw_stroke(SpiceMsgDisplayDrawStroke& stroke, int size)
@@ -210,5 +232,21 @@ void Canvas::draw_stroke(SpiceMsgDisplayDrawStroke& stroke, int size)
     localalize_brush(stroke.data.brush);
     localalize_ptr(&stroke.data.path);
     localalize_attr(stroke.data.attr);
-    draw_stroke(&stroke.base.box, &stroke.base.clip, &stroke.data);
+    _canvas->ops->draw_stroke(_canvas, &stroke.base.box, &stroke.base.clip, &stroke.data);
+    touched_bbox(&stroke.base.box);
+}
+
+void Canvas::put_image(
+#ifdef WIN32
+                        HDC dc,
+#endif
+                        const PixmapHeader& image, const SpiceRect& dest, const QRegion* clip)
+{
+    _canvas->ops->put_image(_canvas,
+#ifdef WIN32
+                            dc,
+#endif
+                            &dest, image.data, image.width, image.height, image.stride,
+                            clip);
+    touched_bbox(&dest);
 }
diff --git a/client/canvas.h b/client/canvas.h
index 2f122638..8e3a8f1b 100644
--- a/client/canvas.h
+++ b/client/canvas.h
@@ -249,7 +249,7 @@ public:
     virtual void copy_pixels(const QRegion& region, RedDrawable& dc) = 0;
     virtual void thread_touch() = 0;
 
-    virtual void clear() = 0;
+    void clear();
 
     void draw_fill(SpiceMsgDisplayDrawFill& fill, int size);
     void draw_text(SpiceMsgDisplayDrawText& text, int size);
@@ -265,31 +265,17 @@ public:
     void draw_rop3(SpiceMsgDisplayDrawRop3& rop3, int size);
     void draw_stroke(SpiceMsgDisplayDrawStroke& stroke, int size);
 
+    void put_image(
 #ifdef WIN32
-    virtual void put_image(HDC dc, const PixmapHeader& image,
-                           const SpiceRect& dest, const QRegion* clip) = 0;
-#else
-    virtual void put_image(const PixmapHeader& image, const SpiceRect& dest,
-                           const QRegion* clip) = 0;
+                   HDC dc,
 #endif
+                   const PixmapHeader& image,
+                   const SpiceRect& dest, const QRegion* clip);
 
     virtual CanvasType get_pixmap_type() { return CANVAS_TYPE_INVALID; }
 
 protected:
-    virtual void set_access_params(unsigned long base, unsigned long max) = 0;
-    virtual void draw_fill(SpiceRect *bbox, SpiceClip *clip, SpiceFill *fill) = 0;
-    virtual void draw_copy(SpiceRect *bbox, SpiceClip *clip, SpiceCopy *copy) = 0;
-    virtual void draw_opaque(SpiceRect *bbox, SpiceClip *clip, SpiceOpaque *opaque) = 0;
-    virtual void copy_bits(SpiceRect *bbox, SpiceClip *clip, SpicePoint *src_pos) = 0;
-    virtual void draw_text(SpiceRect *bbox, SpiceClip *clip, SpiceText *text) = 0;
-    virtual void draw_stroke(SpiceRect *bbox, SpiceClip *clip, SpiceStroke *stroke) = 0;
-    virtual void draw_rop3(SpiceRect *bbox, SpiceClip *clip, SpiceRop3 *rop3) = 0;
-    virtual void draw_blend(SpiceRect *bbox, SpiceClip *clip, SpiceBlend *blend) = 0;
-    virtual void draw_blackness(SpiceRect *bbox, SpiceClip *clip, SpiceBlackness *blackness) = 0;
-    virtual void draw_whiteness(SpiceRect *bbox, SpiceClip *clip, SpiceWhiteness *whiteness) = 0;
-    virtual void draw_invers(SpiceRect *bbox, SpiceClip *clip, SpiceInvers *invers) = 0;
-    virtual void draw_transparent(SpiceRect *bbox, SpiceClip *clip, SpiceTransparent* transparent) = 0;
-    virtual void draw_alpha_blend(SpiceRect *bbox, SpiceClip *clip, SpiceAlphaBlnd* alpha_blend) = 0;
+    virtual void touched_bbox(const SpiceRect *bbox) {};
 
     PixmapCache& pixmap_cache() { return _pixmap_cache;}
     PaletteCache& palette_cache() { return _palette_cache;}
@@ -305,6 +291,9 @@ private:
     void localalize_mask(SpiceQMask& mask);
     void begin_draw(SpiceMsgDisplayBase& base, int size, size_t min_size);
 
+protected:
+    SpiceCanvas* _canvas;
+
 private:
     PixmapCache& _pixmap_cache;
     PaletteCache& _palette_cache;
diff --git a/client/red_cairo_canvas.cpp b/client/red_cairo_canvas.cpp
index 97277fb3..02c105a6 100644
--- a/client/red_cairo_canvas.cpp
+++ b/client/red_cairo_canvas.cpp
@@ -27,7 +27,6 @@
 CCanvas::CCanvas(PixmapCache& pixmap_cache, PaletteCache& palette_cache,
                  GlzDecoderWindow &glz_decoder_window)
     : Canvas (pixmap_cache, palette_cache, glz_decoder_window)
-    , _canvas (NULL)
     , _pixmap (0)
 {
 }
@@ -40,19 +39,12 @@ CCanvas::~CCanvas()
 void CCanvas::destroy()
 {
     if (_canvas) {
-        canvas_destroy(_canvas);
+        _canvas->ops->destroy(_canvas);
         _canvas = NULL;
     }
     destroy_pixmap();
 }
 
-void CCanvas::clear()
-{
-    if (_canvas) {
-        canvas_clear(_canvas);
-    }
-}
-
 void CCanvas::destroy_pixmap()
 {
     delete _pixmap;
@@ -108,92 +100,6 @@ void CCanvas::set_mode(int width, int height, int depth, RedWindow *win)
     pixman_image_unref (surface);
 }
 
-void CCanvas::set_access_params(unsigned long base, unsigned long max)
-{
-    canvas_set_access_params(_canvas, base, max);
-}
-
-void CCanvas::draw_fill(SpiceRect *bbox, SpiceClip *clip, SpiceFill *fill)
-{
-    canvas_draw_fill(_canvas, bbox, clip, fill);
-}
-
-void CCanvas::draw_text(SpiceRect *bbox, SpiceClip *clip, SpiceText *text)
-{
-    canvas_draw_text(_canvas, bbox, clip, text);
-}
-
-void CCanvas::draw_opaque(SpiceRect *bbox, SpiceClip *clip, SpiceOpaque *opaque)
-{
-    canvas_draw_opaque(_canvas, bbox, clip, opaque);
-}
-
-void CCanvas::draw_copy(SpiceRect *bbox, SpiceClip *clip, SpiceCopy *copy)
-{
-    canvas_draw_copy(_canvas, bbox, clip, copy);
-}
-
-void CCanvas::draw_transparent(SpiceRect *bbox, SpiceClip *clip, SpiceTransparent* transparent)
-{
-    canvas_draw_transparent(_canvas, bbox, clip, transparent);
-}
-
-void CCanvas::draw_alpha_blend(SpiceRect *bbox, SpiceClip *clip, SpiceAlphaBlnd* alpha_blend)
-{
-    canvas_draw_alpha_blend(_canvas, bbox, clip, alpha_blend);
-}
-
-void CCanvas::copy_bits(SpiceRect *bbox, SpiceClip *clip, SpicePoint *src_pos)
-{
-    canvas_copy_bits(_canvas, bbox, clip, src_pos);
-}
-
-void CCanvas::draw_blend(SpiceRect *bbox, SpiceClip *clip, SpiceBlend *blend)
-{
-    canvas_draw_blend(_canvas, bbox, clip, blend);
-}
-
-void CCanvas::draw_blackness(SpiceRect *bbox, SpiceClip *clip, SpiceBlackness *blackness)
-{
-    canvas_draw_blackness(_canvas, bbox, clip, blackness);
-}
-
-void CCanvas::draw_whiteness(SpiceRect *bbox, SpiceClip *clip, SpiceWhiteness *whiteness)
-{
-    canvas_draw_whiteness(_canvas, bbox, clip, whiteness);
-}
-
-void CCanvas::draw_invers(SpiceRect *bbox, SpiceClip *clip, SpiceInvers *invers)
-{
-    canvas_draw_invers(_canvas, bbox, clip, invers);
-}
-
-void CCanvas::draw_rop3(SpiceRect *bbox, SpiceClip *clip, SpiceRop3 *rop3)
-{
-    canvas_draw_rop3(_canvas, bbox, clip, rop3);
-}
-
-void CCanvas::draw_stroke(SpiceRect *bbox, SpiceClip *clip, SpiceStroke *stroke)
-{
-    canvas_draw_stroke(_canvas, bbox, clip, stroke);
-}
-
-#ifdef WIN32
-void CCanvas::put_image(HDC dc, const PixmapHeader& image, const SpiceRect& dest, const QRegion* clip)
-{
-    canvas_put_image(_canvas, dc, &dest, image.data, image.width, image.height, image.stride,
-                     clip);
-}
-
-#else
-void CCanvas::put_image(const PixmapHeader& image, const SpiceRect& dest, const QRegion* clip)
-{
-    canvas_put_image(_canvas, &dest, image.data, image.width, image.height, image.stride,
-                     clip);
-}
-
-#endif
-
 CanvasType CCanvas::get_pixmap_type()
 {
     return CANVAS_TYPE_CAIRO;
diff --git a/client/red_cairo_canvas.h b/client/red_cairo_canvas.h
index 2bcb3a89..51c6c5ad 100644
--- a/client/red_cairo_canvas.h
+++ b/client/red_cairo_canvas.h
@@ -30,44 +30,19 @@ public:
     virtual ~CCanvas();
 
     virtual void set_mode(int x, int y, int bits, RedWindow *win);
-    virtual void clear();
     virtual void thread_touch() {}
     virtual void copy_pixels(const QRegion& region, RedDrawable* dc,
                              const PixmapHeader* pixmap);
     virtual void copy_pixels(const QRegion& region, RedDrawable& dc);
-#ifdef WIN32
-    virtual void put_image(HDC dc, const PixmapHeader& image,
-                           const SpiceRect& dest, const QRegion* clip);
-#else
-    virtual void put_image(const PixmapHeader& image, const SpiceRect& dest,
-                           const QRegion* clip);
-#endif
 
     virtual CanvasType get_pixmap_type();
 
-protected:
-    virtual void set_access_params(unsigned long base, unsigned long max);
-    virtual void draw_fill(SpiceRect *bbox, SpiceClip *clip, SpiceFill *fill);
-    virtual void draw_copy(SpiceRect *bbox, SpiceClip *clip, SpiceCopy *copy);
-    virtual void draw_opaque(SpiceRect *bbox, SpiceClip *clip, SpiceOpaque *opaque);
-    virtual void copy_bits(SpiceRect *bbox, SpiceClip *clip, SpicePoint *src_pos);
-    virtual void draw_text(SpiceRect *bbox, SpiceClip *clip, SpiceText *text);
-    virtual void draw_stroke(SpiceRect *bbox, SpiceClip *clip, SpiceStroke *stroke);
-    virtual void draw_rop3(SpiceRect *bbox, SpiceClip *clip, SpiceRop3 *rop3);
-    virtual void draw_blend(SpiceRect *bbox, SpiceClip *clip, SpiceBlend *blend);
-    virtual void draw_blackness(SpiceRect *bbox, SpiceClip *clip, SpiceBlackness *blackness);
-    virtual void draw_whiteness(SpiceRect *bbox, SpiceClip *clip, SpiceWhiteness *whiteness);
-    virtual void draw_invers(SpiceRect *bbox, SpiceClip *clip, SpiceInvers *invers);
-    virtual void draw_transparent(SpiceRect *bbox, SpiceClip *clip, SpiceTransparent* transparent);
-    virtual void draw_alpha_blend(SpiceRect *bbox, SpiceClip *clip, SpiceAlphaBlnd* alpha_blend);
-
 private:
     void create_pixmap(int width, int height, RedWindow *win);
     void destroy_pixmap();
     void destroy();
 
 private:
-    CairoCanvas* _canvas;
     RedPixmap *_pixmap;
     unsigned long _base;
     unsigned long _max;
diff --git a/client/red_gdi_canvas.cpp b/client/red_gdi_canvas.cpp
index efdf5d4d..a623e64c 100644
--- a/client/red_gdi_canvas.cpp
+++ b/client/red_gdi_canvas.cpp
@@ -26,7 +26,6 @@
 GDICanvas::GDICanvas(PixmapCache& pixmap_cache, PaletteCache& palette_cache,
                      GlzDecoderWindow &glz_decoder_window)
     : Canvas (pixmap_cache, palette_cache, glz_decoder_window)
-    , _canvas (NULL)
     , _pixmap (0)
 {
 }
@@ -44,13 +43,6 @@ void GDICanvas::destroy()
     destroy_pixmap();
 }
 
-void GDICanvas::clear()
-{
-    if (_canvas) {
-        gdi_canvas_clear(_canvas);
-    }
-}
-
 void GDICanvas::destroy_pixmap()
 {
     delete _pixmap;
@@ -97,82 +89,6 @@ void GDICanvas::set_mode(int width, int height, int depth)
     }
 }
 
-void GDICanvas::set_access_params(unsigned long base, unsigned long max)
-{
-    gdi_canvas_set_access_params(_canvas, base, max);
-}
-
-void GDICanvas::draw_fill(SpiceRect *bbox, SpiceClip *clip, SpiceFill *fill)
-{
-    gdi_canvas_draw_fill(_canvas, bbox, clip, fill);
-}
-
-void GDICanvas::draw_text(SpiceRect *bbox, SpiceClip *clip, SpiceText *text)
-{
-    gdi_canvas_draw_text(_canvas, bbox, clip, text);
-}
-
-void GDICanvas::draw_opaque(SpiceRect *bbox, SpiceClip *clip, SpiceOpaque *opaque)
-{
-    gdi_canvas_draw_opaque(_canvas, bbox, clip, opaque);
-}
-
-void GDICanvas::draw_copy(SpiceRect *bbox, SpiceClip *clip, SpiceCopy *copy)
-{
-    gdi_canvas_draw_copy(_canvas, bbox, clip, copy);
-}
-
-void GDICanvas::draw_transparent(SpiceRect *bbox, SpiceClip *clip, SpiceTransparent* transparent)
-{
-    gdi_canvas_draw_transparent(_canvas, bbox, clip, transparent);
-}
-
-void GDICanvas::draw_alpha_blend(SpiceRect *bbox, SpiceClip *clip, SpiceAlphaBlnd* alpha_blend)
-{
-    gdi_canvas_draw_alpha_blend(_canvas, bbox, clip, alpha_blend);
-}
-
-void GDICanvas::copy_bits(SpiceRect *bbox, SpiceClip *clip, SpicePoint *src_pos)
-{
-    gdi_canvas_copy_bits(_canvas, bbox, clip, src_pos);
-}
-
-void GDICanvas::draw_blend(SpiceRect *bbox, SpiceClip *clip, SpiceBlend *blend)
-{
-    gdi_canvas_draw_blend(_canvas, bbox, clip, blend);
-}
-
-void GDICanvas::draw_blackness(SpiceRect *bbox, SpiceClip *clip, SpiceBlackness *blackness)
-{
-    gdi_canvas_draw_blackness(_canvas, bbox, clip, blackness);
-}
-
-void GDICanvas::draw_whiteness(SpiceRect *bbox, SpiceClip *clip, SpiceWhiteness *whiteness)
-{
-    gdi_canvas_draw_whiteness(_canvas, bbox, clip, whiteness);
-}
-
-void GDICanvas::draw_invers(SpiceRect *bbox, SpiceClip *clip, SpiceInvers *invers)
-{
-    gdi_canvas_draw_invers(_canvas, bbox, clip, invers);
-}
-
-void GDICanvas::draw_rop3(SpiceRect *bbox, SpiceClip *clip, SpiceRop3 *rop3)
-{
-    gdi_canvas_draw_rop3(_canvas, bbox, clip, rop3);
-}
-
-void GDICanvas::draw_stroke(SpiceRect *bbox, SpiceClip *clip, SpiceStroke *stroke)
-{
-    gdi_canvas_draw_stroke(_canvas, bbox, clip, stroke);
-}
-
-void GDICanvas::put_image(HDC dc, const PixmapHeader& image, const SpiceRect& dest, const QRegion* clip)
-{
-    gdi_canvas_put_image(_canvas, dc, &dest, image.data, image.width, image.height, image.stride,
-                         clip);
-}
-
 CanvasType GDICanvas::get_pixmap_type()
 {
     return CANVAS_TYPE_GDI;
diff --git a/client/red_gdi_canvas.h b/client/red_gdi_canvas.h
index 6f494340..83fc1205 100644
--- a/client/red_gdi_canvas.h
+++ b/client/red_gdi_canvas.h
@@ -32,39 +32,19 @@ public:
     virtual ~GDICanvas();
 
     virtual void set_mode(int x, int y, int bits);
-    virtual void clear();
     virtual void thread_touch() {}
     virtual void copy_pixels(const QRegion& region, RedDrawable* dc,
                              const PixmapHeader* pixmap);
     virtual void copy_pixels(const QRegion& region, RedDrawable& dc);
-    virtual void put_image(HDC dc, const PixmapHeader& image, const SpiceRect& dest,
-                           const QRegion* clip);
 
     virtual CanvasType get_pixmap_type();
 
-protected:
-    virtual void set_access_params(unsigned long base, unsigned long max);
-    virtual void draw_fill(SpiceRect *bbox, SpiceClip *clip, SpiceFill *fill);
-    virtual void draw_copy(SpiceRect *bbox, SpiceClip *clip, SpiceCopy *copy);
-    virtual void draw_opaque(SpiceRect *bbox, SpiceClip *clip, SpiceOpaque *opaque);
-    virtual void copy_bits(SpiceRect *bbox, SpiceClip *clip, SpicePoint *src_pos);
-    virtual void draw_text(SpiceRect *bbox, SpiceClip *clip, SpiceText *text);
-    virtual void draw_stroke(SpiceRect *bbox, SpiceClip *clip, SpiceStroke *stroke);
-    virtual void draw_rop3(SpiceRect *bbox, SpiceClip *clip, SpiceRop3 *rop3);
-    virtual void draw_blend(SpiceRect *bbox, SpiceClip *clip, SpiceBlend *blend);
-    virtual void draw_blackness(SpiceRect *bbox, SpiceClip *clip, SpiceBlackness *blackness);
-    virtual void draw_whiteness(SpiceRect *bbox, SpiceClip *clip, SpiceWhiteness *whiteness);
-    virtual void draw_invers(SpiceRect *bbox, SpiceClip *clip, SpiceInvers *invers);
-    virtual void draw_transparent(SpiceRect *bbox, SpiceClip *clip, SpiceTransparent* transparent);
-    virtual void draw_alpha_blend(SpiceRect *bbox, SpiceClip *clip, SpiceAlphaBlnd* alpha_blend);
-
 private:
     void create_pixmap(int width, int height);
     void destroy_pixmap();
     void destroy();
 
 private:
-    GdiCanvas* _canvas;
     RedPixmapGdi *_pixmap;
     RedPixmapGdi *_helper_pixmap;
     HDC _dc;
diff --git a/client/red_gl_canvas.cpp b/client/red_gl_canvas.cpp
index 76dabc71..c6bb1137 100644
--- a/client/red_gl_canvas.cpp
+++ b/client/red_gl_canvas.cpp
@@ -27,7 +27,6 @@
 GCanvas::GCanvas(PixmapCache& pixmap_cache, PaletteCache& palette_cache,
                  GlzDecoderWindow &glz_decoder_window)
     : Canvas(pixmap_cache, palette_cache, glz_decoder_window)
-    , _canvas (NULL)
     , _pixmap (0)
     , _textures_lost (false)
 {
@@ -41,19 +40,13 @@ GCanvas::~GCanvas()
 void GCanvas::destroy()
 {
     if (_canvas) {
-        gl_canvas_destroy(_canvas, _textures_lost);
+        gl_canvas_set_textures_lost (_canvas, (int)_textures_lost);
+        _canvas->ops->destroy(_canvas);
         _canvas = NULL;
     }
     destroy_pixmap();
 }
 
-void GCanvas::clear()
-{
-    if (_canvas) {
-        gl_canvas_clear(_canvas);
-    }
-}
-
 void GCanvas::destroy_pixmap()
 {
     delete _pixmap;
@@ -96,7 +89,7 @@ void GCanvas::set_mode(int width, int height, int depth, RedWindow *win,
     destroy();
 
     create_pixmap(width, height, win, rendertype);
-    if (!(_canvas = gl_canvas_create(NULL, width, height, depth,
+    if (!(_canvas = gl_canvas_create(width, height, depth,
                                      &pixmap_cache().base,
                                      &palette_cache().base,
                                      &glz_decoder()))) {
@@ -104,97 +97,11 @@ void GCanvas::set_mode(int width, int height, int depth, RedWindow *win,
     }
 }
 
-void GCanvas::set_access_params(unsigned long base, unsigned long max)
-{
-    gl_canvas_set_access_params(_canvas, base, max);
-}
-
-void GCanvas::draw_fill(SpiceRect *bbox, SpiceClip *clip, SpiceFill *fill)
-{
-    gl_canvas_draw_fill(_canvas, bbox, clip, fill);
-    _pixmap->update_texture(bbox);
-}
-
-void GCanvas::draw_text(SpiceRect *bbox, SpiceClip *clip, SpiceText *text)
-{
-    gl_canvas_draw_text(_canvas, bbox, clip, text);
-    _pixmap->update_texture(bbox);
-}
-
-void GCanvas::draw_opaque(SpiceRect *bbox, SpiceClip *clip, SpiceOpaque *opaque)
-{
-    gl_canvas_draw_opaque(_canvas, bbox, clip, opaque);
-    _pixmap->update_texture(bbox);
-}
-
-void GCanvas::draw_copy(SpiceRect *bbox, SpiceClip *clip, SpiceCopy *copy)
+void GCanvas::touched_bbox(const SpiceRect *bbox)
 {
-    gl_canvas_draw_copy(_canvas, bbox, clip, copy);
     _pixmap->update_texture(bbox);
 }
 
-void GCanvas::draw_transparent(SpiceRect *bbox, SpiceClip *clip, SpiceTransparent* transparent)
-{
-    gl_canvas_draw_transparent(_canvas, bbox, clip, transparent);
-    _pixmap->update_texture(bbox);
-}
-
-void GCanvas::draw_alpha_blend(SpiceRect *bbox, SpiceClip *clip, SpiceAlphaBlnd* alpha_blend)
-{
-    gl_canvas_draw_alpha_blend(_canvas, bbox, clip, alpha_blend);
-    _pixmap->update_texture(bbox);
-}
-
-void GCanvas::copy_bits(SpiceRect *bbox, SpiceClip *clip, SpicePoint *src_pos)
-{
-    gl_canvas_copy_pixels(_canvas, bbox, clip, src_pos);
-    _pixmap->update_texture(bbox);
-}
-
-void GCanvas::draw_blend(SpiceRect *bbox, SpiceClip *clip, SpiceBlend *blend)
-{
-    gl_canvas_draw_blend(_canvas, bbox, clip, blend);
-    _pixmap->update_texture(bbox);
-}
-
-void GCanvas::draw_blackness(SpiceRect *bbox, SpiceClip *clip, SpiceBlackness *blackness)
-{
-    gl_canvas_draw_blackness(_canvas, bbox, clip, blackness);
-    _pixmap->update_texture(bbox);
-}
-
-void GCanvas::draw_whiteness(SpiceRect *bbox, SpiceClip *clip, SpiceWhiteness *whiteness)
-{
-    gl_canvas_draw_whiteness(_canvas, bbox, clip, whiteness);
-    _pixmap->update_texture(bbox);
-}
-
-void GCanvas::draw_invers(SpiceRect *bbox, SpiceClip *clip, SpiceInvers *invers)
-{
-    gl_canvas_draw_invers(_canvas, bbox, clip, invers);
-    _pixmap->update_texture(bbox);
-}
-
-void GCanvas::draw_rop3(SpiceRect *bbox, SpiceClip *clip, SpiceRop3 *rop3)
-{
-    gl_canvas_draw_rop3(_canvas, bbox, clip, rop3);
-    _pixmap->update_texture(bbox);
-}
-
-void GCanvas::draw_stroke(SpiceRect *bbox, SpiceClip *clip, SpiceStroke *stroke)
-{
-    gl_canvas_draw_stroke(_canvas, bbox, clip, stroke);
-    _pixmap->update_texture(bbox);
-}
-
-void GCanvas::put_image(const PixmapHeader& image, const SpiceRect& dest,
-                        const QRegion* clip)
-{
-    gl_canvas_put_image(_canvas, &dest, image.data, image.width, image.height,
-                        image.stride, clip);
-    _pixmap->update_texture(&dest);
-}
-
 CanvasType GCanvas::get_pixmap_type()
 {
     return CANVAS_TYPE_GL;
diff --git a/client/red_gl_canvas.h b/client/red_gl_canvas.h
index 918aa6c6..983f7729 100644
--- a/client/red_gl_canvas.h
+++ b/client/red_gl_canvas.h
@@ -39,29 +39,12 @@ public:
     void copy_pixels(const QRegion& region, RedDrawable* dc,
                      const PixmapHeader* pixmap);
     void copy_pixels(const QRegion& region, RedDrawable& dc);
-    void put_image(const PixmapHeader& image, const SpiceRect& dest,
-                   const QRegion* clip);
-
-    void set_access_params(unsigned long base, unsigned long max);
-    void draw_fill(SpiceRect *bbox, SpiceClip *clip, SpiceFill *fill);
-    void draw_copy(SpiceRect *bbox, SpiceClip *clip, SpiceCopy *copy);
-    void draw_opaque(SpiceRect *bbox, SpiceClip *clip, SpiceOpaque *opaque);
-    void copy_bits(SpiceRect *bbox, SpiceClip *clip, SpicePoint *src_pos);
-    void draw_text(SpiceRect *bbox, SpiceClip *clip, SpiceText *text);
-    void draw_stroke(SpiceRect *bbox, SpiceClip *clip, SpiceStroke *stroke);
-    void draw_rop3(SpiceRect *bbox, SpiceClip *clip, SpiceRop3 *rop3);
-    void draw_blend(SpiceRect *bbox, SpiceClip *clip, SpiceBlend *blend);
-    void draw_blackness(SpiceRect *bbox, SpiceClip *clip, SpiceBlackness *blackness);
-    void draw_whiteness(SpiceRect *bbox, SpiceClip *clip, SpiceWhiteness *whiteness);
-    void draw_invers(SpiceRect *bbox, SpiceClip *clip, SpiceInvers *invers);
-    void draw_transparent(SpiceRect *bbox, SpiceClip *clip, SpiceTransparent* transparent);
-    void draw_alpha_blend(SpiceRect *bbox, SpiceClip *clip, SpiceAlphaBlnd* alpha_blend);
-
     virtual void textures_lost();
     virtual CanvasType get_pixmap_type();
     virtual void touch_context();
     virtual void pre_gl_copy();
     virtual void post_gl_copy();
+    void touched_bbox(const SpiceRect *bbox);
 
 private:
     void create_pixmap(int width, int height, RedWindow *win,
@@ -70,7 +53,6 @@ private:
     void destroy();
 
 private:
-    GLCanvas* _canvas;
     RedPixmapGL *_pixmap;
     bool _textures_lost;
 };