Move virtualization of canvas drawing into common/canvas_base

Instead of having two virtualizations of the canvas we push the
virtualization into the canvas code itself. This not only avoids
the duplication of this code, it also makes the exposed API for the
canvas much smaller (in terms of exported API).

It also lets us use the virtualization to implement basic support
for operations in canvas_base which is then overridden by each canvas
implementation.

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;
 };