diff options
Diffstat (limited to 'client/canvas.cpp')
-rw-r--r-- | client/canvas.cpp | 251 |
1 files changed, 251 insertions, 0 deletions
diff --git a/client/canvas.cpp b/client/canvas.cpp new file mode 100644 index 00000000..310cdec9 --- /dev/null +++ b/client/canvas.cpp @@ -0,0 +1,251 @@ +/* + Copyright (C) 2009 Red Hat, Inc. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of + the License, or (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. +*/ + +#include "common.h" +#include "canvas.h" +#include "utils.h" +#include "debug.h" + + +Canvas::Canvas(PixmapCache& pixmap_cache, PaletteCache& palette_cache, + GlzDecoderWindow &glz_decoder_window) + : _pixmap_cache (pixmap_cache) + , _palette_cache (palette_cache) + , _glz_decoder(glz_decoder_window, _glz_handler, _glz_debug) +{ +} + +Canvas::~Canvas() +{ +} + +inline void Canvas::access_test(void *ptr, size_t size) +{ + if ((unsigned long)ptr < _base || (unsigned long)ptr + size > _max) { + THROW("access violation %p %lu", ptr, size); + } +} + +void Canvas::localalize_ptr(ADDRESS* data) +{ + if (*data) { + *data += _base; + } +} + +void Canvas::localalize_image(ADDRESS* in_bitmap) +{ + ImageDescriptor* image; + + ASSERT(*in_bitmap); + localalize_ptr(in_bitmap); + image = (ImageDescriptor*)GET_ADDRESS(*in_bitmap); + switch (image->type) { + case IMAGE_TYPE_BITMAP: { + BitmapImage *bitmap = (BitmapImage *)image; + localalize_ptr(&bitmap->bitmap.data); + if (bitmap->bitmap.palette && !(bitmap->bitmap.flags & BITMAP_PAL_FROM_CACHE)) { + localalize_ptr(&bitmap->bitmap.palette); + } + break; + } + case IMAGE_TYPE_LZ_PLT: { + LZ_PLTImage *lzImage = (LZ_PLTImage *)image; + ASSERT(lzImage->lz_plt.palette); + if (!(lzImage->lz_plt.flags & BITMAP_PAL_FROM_CACHE)) { + localalize_ptr(&lzImage->lz_plt.palette); + } + break; + } + case IMAGE_TYPE_LZ_RGB: + case IMAGE_TYPE_GLZ_RGB: + case IMAGE_TYPE_QUIC: + break; + case IMAGE_TYPE_FROM_CACHE: + break; + default: + THROW("invalid image type %u", image->type); + } +} + +void Canvas::localalize_brush(Brush& brush) +{ + if (brush.type == BRUSH_TYPE_PATTERN) { + localalize_image(&brush.u.pattern.pat); + } +} + +void Canvas::localalize_attr(LineAttr& attr) +{ + if (attr.style_nseg) { + localalize_ptr(&attr.style); + } +} + +void Canvas::localalize_mask(QMask& mask) +{ + if (mask.bitmap) { + localalize_image(&mask.bitmap); + } +} + +void Canvas::begin_draw(RedDrawBase& base, int size, size_t min_size) +{ + _base = (unsigned long)&base; + _max = _base + size; + set_access_params(_base, _base, _max); + access_test(&base, min_size); + localalize_ptr(&base.clip.data); +} + +void Canvas::draw_fill(RedFill& fill, int size) +{ + begin_draw(fill.base, size, sizeof(RedFill)); + 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) +{ + begin_draw(text.base, size, sizeof(RedText)); + 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) +{ + begin_draw(opaque.base, size, sizeof(RedOpaque)); + 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) +{ + begin_draw(copy.base, size, sizeof(RedCopy)); + localalize_image(©.data.src_bitmap); + localalize_mask(copy.data.mask); + draw_copy(©.base.box, ©.base.clip, ©.data); +} + +void Canvas::draw_transparent(RedTransparent& transparent, int size) +{ + begin_draw(transparent.base, size, sizeof(RedTransparent)); + 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) +{ + begin_draw(alpha_blend.base, size, sizeof(RedAlphaBlend)); + 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) +{ + begin_draw(copy.base, size, sizeof(RedCopyBits)); + copy_bits(©.base.box, ©.base.clip, ©.src_pos); +} + +void Canvas::draw_blend(RedBlend& blend, int size) +{ + begin_draw(blend.base, size, sizeof(RedBlend)); + 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) +{ + begin_draw(blackness.base, size, sizeof(RedBlackness)); + localalize_mask(blackness.data.mask); + draw_blackness(&blackness.base.box, &blackness.base.clip, &blackness.data); +} + +void Canvas::draw_whiteness(RedWhiteness& whiteness, int size) +{ + begin_draw(whiteness.base, size, sizeof(RedWhiteness)); + localalize_mask(whiteness.data.mask); + draw_whiteness(&whiteness.base.box, &whiteness.base.clip, &whiteness.data); +} + +void Canvas::draw_invers(RedInvers& invers, int size) +{ + begin_draw(invers.base, size, sizeof(RedInvers)); + localalize_mask(invers.data.mask); + draw_invers(&invers.base.box, &invers.base.clip, &invers.data); +} + +void Canvas::draw_rop3(RedRop3& rop3, int size) +{ + begin_draw(rop3.base, size, sizeof(RedRop3)); + 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) +{ + begin_draw(stroke.base, size, sizeof(RedStroke)); + 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); +} + +void Canvas::bits_cache_put(void *opaque, uint64_t id, cairo_surface_t *surface) +{ + PixmapCache* cache = static_cast<PixmapCache*>(opaque); + cache->add(id, surface); +} + +cairo_surface_t* Canvas::bits_cache_get(void *opaque, uint64_t id) +{ + PixmapCache* cache = static_cast<PixmapCache*>(opaque); + return cache->get(id); +} + +void Canvas::palette_cache_put(void *opaque, Palette *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) +{ + PaletteCache* cache = static_cast<PaletteCache*>(opaque); + return cache->get(id)->palette(); +} + +void Canvas::palette_cache_release(Palette* palette) +{ + CachedPalette::unref(palette); +} + +void Canvas::glz_decode(void *opaque, uint8_t *data, Palette *plt, void *usr_data) +{ + GlzDecoder* decoder = static_cast<GlzDecoder*>(opaque); + decoder->decode(data, plt, usr_data); +} + |