Rename symbols that were changed in spice-protocol

This is an automatic change using:
$ find -name "*.[ch]" | xargs ../spice-protocol/rename-identifiers.sh ../spice-protocol/renames
$ find -name "*.cpp" | xargs ../spice-protocol/rename-identifiers.sh ../spice-protocol/renames

1 files changed, 49 insertions, 49 deletions

diff --git a/client/canvas.cpp b/client/canvas.cpp
index 6ce2af2b..04b0ce67 100644
--- a/client/canvas.cpp
+++ b/client/canvas.cpp
@@ -40,70 +40,70 @@ inline void Canvas::access_test(void *ptr, size_t size)
     }
 }
 
-void Canvas::localalize_ptr(ADDRESS* data)
+void Canvas::localalize_ptr(SPICE_ADDRESS* data)
 {
     if (*data) {
         *data += _base;
     }
 }
 
-void Canvas::localalize_image(ADDRESS* in_bitmap)
+void Canvas::localalize_image(SPICE_ADDRESS* in_bitmap)
 {
-    ImageDescriptor* image;
+    SpiceImageDescriptor* image;
 
     ASSERT(*in_bitmap);
     localalize_ptr(in_bitmap);
-    image = (ImageDescriptor*)GET_ADDRESS(*in_bitmap);
+    image = (SpiceImageDescriptor*)SPICE_GET_ADDRESS(*in_bitmap);
     switch (image->type) {
-    case IMAGE_TYPE_BITMAP: {
-        BitmapImage *bitmap = (BitmapImage *)image;
+    case SPICE_IMAGE_TYPE_BITMAP: {
+        SpiceBitmapImage *bitmap = (SpiceBitmapImage *)image;
         localalize_ptr(&bitmap->bitmap.data);
-        if (bitmap->bitmap.palette && !(bitmap->bitmap.flags & BITMAP_PAL_FROM_CACHE)) {
+        if (bitmap->bitmap.palette && !(bitmap->bitmap.flags & SPICE_BITMAP_FLAGS_PAL_FROM_CACHE)) {
             localalize_ptr(&bitmap->bitmap.palette);
         }
         break;
     }
-    case IMAGE_TYPE_LZ_PLT: {
-        LZ_PLTImage *lzImage = (LZ_PLTImage *)image;
+    case SPICE_IMAGE_TYPE_LZ_PLT: {
+        SpiceLZPLTImage *lzImage = (SpiceLZPLTImage *)image;
         ASSERT(lzImage->lz_plt.palette);
-        if (!(lzImage->lz_plt.flags & BITMAP_PAL_FROM_CACHE)) {
+        if (!(lzImage->lz_plt.flags & SPICE_BITMAP_FLAGS_PAL_FROM_CACHE)) {
             localalize_ptr(&lzImage->lz_plt.palette);
         }
         break;
     }
-    case IMAGE_TYPE_LZ_RGB:
-    case IMAGE_TYPE_GLZ_RGB:
-    case IMAGE_TYPE_QUIC:
+    case SPICE_IMAGE_TYPE_LZ_RGB:
+    case SPICE_IMAGE_TYPE_GLZ_RGB:
+    case SPICE_IMAGE_TYPE_QUIC:
         break;
-    case IMAGE_TYPE_FROM_CACHE:
+    case SPICE_IMAGE_TYPE_FROM_CACHE:
         break;
     default:
         THROW("invalid image type %u", image->type);
     }
 }
 
-void Canvas::localalize_brush(Brush& brush)
+void Canvas::localalize_brush(SpiceBrush& brush)
 {
-    if (brush.type == BRUSH_TYPE_PATTERN) {
+    if (brush.type == SPICE_BRUSH_TYPE_PATTERN) {
         localalize_image(&brush.u.pattern.pat);
     }
 }
 
-void Canvas::localalize_attr(LineAttr& attr)
+void Canvas::localalize_attr(SpiceLineAttr& attr)
 {
     if (attr.style_nseg) {
         localalize_ptr(&attr.style);
     }
 }
 
-void Canvas::localalize_mask(QMask& mask)
+void Canvas::localalize_mask(SpiceQMask& mask)
 {
     if (mask.bitmap) {
         localalize_image(&mask.bitmap);
     }
 }
 
-void Canvas::begin_draw(RedDrawBase& base, int size, size_t min_size)
+void Canvas::begin_draw(SpiceMsgDisplayBase& base, int size, size_t min_size)
 {
     _base = (unsigned long)&base;
     _max = _base + size;
@@ -112,101 +112,101 @@ void Canvas::begin_draw(RedDrawBase& base, int size, size_t min_size)
     localalize_ptr(&base.clip.data);
 }
 
-void Canvas::draw_fill(RedFill& fill, int size)
+void Canvas::draw_fill(SpiceMsgDisplayDrawFill& fill, int size)
 {
-    begin_draw(fill.base, size, sizeof(RedFill));
+    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);
 }
 
-void Canvas::draw_text(RedText& text, int size)
+void Canvas::draw_text(SpiceMsgDisplayDrawText& text, int size)
 {
-    begin_draw(text.base, size, sizeof(RedText));
+    begin_draw(text.base, size, sizeof(SpiceMsgDisplayDrawText));
     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);
 }
 
-void Canvas::draw_opaque(RedOpaque& opaque, int size)
+void Canvas::draw_opaque(SpiceMsgDisplayDrawOpaque& opaque, int size)
 {
-    begin_draw(opaque.base, size, sizeof(RedOpaque));
+    begin_draw(opaque.base, size, sizeof(SpiceMsgDisplayDrawOpaque));
     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);
 }
 
-void Canvas::draw_copy(RedCopy& copy, int size)
+void Canvas::draw_copy(SpiceMsgDisplayDrawCopy& copy, int size)
 {
-    begin_draw(copy.base, size, sizeof(RedCopy));
+    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);
 }
 
-void Canvas::draw_transparent(RedTransparent& transparent, int size)
+void Canvas::draw_transparent(SpiceMsgDisplayDrawTransparent& transparent, int size)
 {
-    begin_draw(transparent.base, size, sizeof(RedTransparent));
+    begin_draw(transparent.base, size, sizeof(SpiceMsgDisplayDrawTransparent));
     localalize_image(&transparent.data.src_bitmap);
     draw_transparent(&transparent.base.box, &transparent.base.clip, &transparent.data);
 }
 
-void Canvas::draw_alpha_blend(RedAlphaBlend& alpha_blend, int size)
+void Canvas::draw_alpha_blend(SpiceMsgDisplayDrawAlphaBlend& alpha_blend, int size)
 {
-    begin_draw(alpha_blend.base, size, sizeof(RedAlphaBlend));
+    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);
 }
 
-void Canvas::copy_bits(RedCopyBits& copy, int size)
+void Canvas::copy_bits(SpiceMsgDisplayCopyBits& copy, int size)
 {
-    begin_draw(copy.base, size, sizeof(RedCopyBits));
+    begin_draw(copy.base, size, sizeof(SpiceMsgDisplayCopyBits));
     copy_bits(&copy.base.box, &copy.base.clip, &copy.src_pos);
 }
 
-void Canvas::draw_blend(RedBlend& blend, int size)
+void Canvas::draw_blend(SpiceMsgDisplayDrawBlend& blend, int size)
 {
-    begin_draw(blend.base, size, sizeof(RedBlend));
+    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);
 }
 
-void Canvas::draw_blackness(RedBlackness& blackness, int size)
+void Canvas::draw_blackness(SpiceMsgDisplayDrawBlackness& blackness, int size)
 {
-    begin_draw(blackness.base, size, sizeof(RedBlackness));
+    begin_draw(blackness.base, size, sizeof(SpiceMsgDisplayDrawBlackness));
     localalize_mask(blackness.data.mask);
     draw_blackness(&blackness.base.box, &blackness.base.clip, &blackness.data);
 }
 
-void Canvas::draw_whiteness(RedWhiteness& whiteness, int size)
+void Canvas::draw_whiteness(SpiceMsgDisplayDrawWhiteness& whiteness, int size)
 {
-    begin_draw(whiteness.base, size, sizeof(RedWhiteness));
+    begin_draw(whiteness.base, size, sizeof(SpiceMsgDisplayDrawWhiteness));
     localalize_mask(whiteness.data.mask);
     draw_whiteness(&whiteness.base.box, &whiteness.base.clip, &whiteness.data);
 }
 
-void Canvas::draw_invers(RedInvers& invers, int size)
+void Canvas::draw_invers(SpiceMsgDisplayDrawInvers& invers, int size)
 {
-    begin_draw(invers.base, size, sizeof(RedInvers));
+    begin_draw(invers.base, size, sizeof(SpiceMsgDisplayDrawInvers));
     localalize_mask(invers.data.mask);
     draw_invers(&invers.base.box, &invers.base.clip, &invers.data);
 }
 
-void Canvas::draw_rop3(RedRop3& rop3, int size)
+void Canvas::draw_rop3(SpiceMsgDisplayDrawRop3& rop3, int size)
 {
-    begin_draw(rop3.base, size, sizeof(RedRop3));
+    begin_draw(rop3.base, size, sizeof(SpiceMsgDisplayDrawRop3));
     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);
 }
 
-void Canvas::draw_stroke(RedStroke& stroke, int size)
+void Canvas::draw_stroke(SpiceMsgDisplayDrawStroke& stroke, int size)
 {
-    begin_draw(stroke.base, size, sizeof(RedStroke));
+    begin_draw(stroke.base, size, sizeof(SpiceMsgDisplayDrawStroke));
     localalize_brush(stroke.data.brush);
     localalize_ptr(&stroke.data.path);
     localalize_attr(stroke.data.attr);
@@ -225,25 +225,25 @@ cairo_surface_t* Canvas::bits_cache_get(void *opaque, uint64_t id)
     return cache->get(id);
 }
 
-void Canvas::palette_cache_put(void *opaque, Palette *palette)
+void Canvas::palette_cache_put(void *opaque, SpicePalette *palette)
 {
     PaletteCache* cache = static_cast<PaletteCache*>(opaque);
     AutoRef<CachedPalette> cached_palette(new CachedPalette(palette));
     cache->add(palette->unique, *cached_palette);
 }
 
-Palette* Canvas::palette_cache_get(void *opaque, uint64_t id)
+SpicePalette* Canvas::palette_cache_get(void *opaque, uint64_t id)
 {
     PaletteCache* cache = static_cast<PaletteCache*>(opaque);
     return cache->get(id)->palette();
 }
 
-void Canvas::palette_cache_release(Palette* palette)
+void Canvas::palette_cache_release(SpicePalette* palette)
 {
     CachedPalette::unref(palette);
 }
 
-void Canvas::glz_decode(void *opaque, uint8_t *data, Palette *plt, void *usr_data)
+void Canvas::glz_decode(void *opaque, uint8_t *data, SpicePalette *plt, void *usr_data)
 {
     GlzDecoder* decoder = static_cast<GlzDecoder*>(opaque);
     decoder->decode(data, plt, usr_data);