CommonOperations Class Reference

#include <layeroperations.hh>

Inheritance diagram for CommonOperations:

Collaboration diagram for CommonOperations:

Public Member Functions
void	initializeCairo (cairo_t *cr) override
void	drawState (cairo_t *cr, TileState s, Scroom::Utils::Rectangle< double > viewArea) override
Scroom::Utils::Stuff	cacheZoom (const ConstTile::Ptr &tile, int zoom, Scroom::Utils::Stuff &cache) override
void	draw (cairo_t *cr, const ConstTile::Ptr &tile, Scroom::Utils::Rectangle< double > tileArea, Scroom::Utils::Rectangle< double > viewArea, int zoom, Scroom::Utils::Stuff cache) override
Public Member Functions inherited from LayerOperations
virtual int	getBpp ()=0
virtual Scroom::Utils::Stuff	cache (const ConstTile::Ptr &tile)
virtual void	reduce (Tile::Ptr target, ConstTile::Ptr source, int x, int y)=0

Static Public Member Functions
static void	drawPixelValue (cairo_t *cr, int x, int y, int size, int value)
static void	drawPixelValue (cairo_t *cr, int x, int y, int size, int value, Color const &bgColor)

Additional Inherited Members
Public Types inherited from LayerOperations
using	Ptr = boost::shared_ptr< LayerOperations >

Member Function Documentation

cacheZoom()

Scroom::Utils::Stuff CommonOperations::cacheZoom ( const ConstTile::Ptr &  tile, int  zoom, Scroom::Utils::Stuff &  cache  )

overridevirtual

Cache data for use during later draw() calls.

This function is called for a given tile and zoom level, and then the results are passed to the draw() function. Because draw() is called relatively frequently (i.e. when scrolling), it is recommended to do cpu-intensive work in the cache() and cacheZoom() functions, and then re-use the data to make the draw() faster.

The default implementation returns an empty reference, meaning nothing is cached. As a result, the draw() function will receive an empty reference.

Parameters

tile	the Tile for which caching is requested
zoom	the requested zoom level
cache	the output of cache(const ConstTile::Ptr)

Reimplemented from LayerOperations.

Reimplemented in Operations1bppClipped.

{
  // In: Cairo surface at zoom level 0
  // Out: Cairo surface at requested zoom level
  Scroom::Utils::Stuff result;
  if(zoom >= 0)
  {
    // Don't zoom in. It is a waste of space
    result = cache;
  }
  else if(!cache)
  {
    defect_message("Base caching failed to return anything");
  }
  else
  {
    const int                divider = 1 << -zoom;
    BitmapSurface::Ptr const source  = boost::static_pointer_cast<BitmapSurface>(cache);
    BitmapSurface::Ptr const target  = BitmapSurface::create(tile->width / divider, tile->height / divider, CAIRO_FORMAT_ARGB32);
    result                           = target;
 
    cairo_surface_t* surface = target->get();
    cairo_t*         cr      = cairo_create(surface);
    initializeCairo(cr);
    cairo_scale(cr, 1.0 / divider, 1.0 / divider);
    cairo_set_source_surface(cr, source->get(), 0, 0);
    cairo_paint(cr);
 
    cairo_destroy(cr);
  }
 
  return result;
}

Here is the call graph for this function:

draw()

void CommonOperations::draw ( cairo_t *  cr, const ConstTile::Ptr &  tile, Scroom::Utils::Rectangle< double >  tileArea, Scroom::Utils::Rectangle< double >  viewArea, int  zoom, Scroom::Utils::Stuff  cache  )

overridevirtual

Draw the given tileArea into the given viewArea at the requested zoom level

Parameters

cr	The canvas on which to draw
tile	The tile to take data from
tileArea	Area of the tile that needs to be drawn
viewArea	Area of the canvas that the tile needs to be drawn in
zoom	The requested zoom level. One pixel of your presentation should have size 2**zoom when drawn. zoom will be negative for all but the first layer.
cache	Depending on whether the cacheZoom() function finished already, this may either be an empty reference, or a reference to the value returned by cacheZoom()

Implements LayerOperations.

Reimplemented in Operations, Operations8bpp, and Operations1bpp.

{
  // In: Cairo surface at requested zoom level
  // Out: given surface rendered to the canvas
  UNUSED(tile);
 
  setClip(cr, viewArea);
 
  if(!cache)
  {
    drawState(cr, TILE_UNLOADED, viewArea);
  }
  else
  {
    BitmapSurface::Ptr const source = boost::static_pointer_cast<BitmapSurface>(cache);
 
    if(zoom > 0)
    {
      // Ask Cairo to zoom in for us
      const int multiplier = 1 << zoom;
      auto      origin     = viewArea.getTopLeft() / multiplier - tileArea.getTopLeft();
 
      cairo_scale(cr, multiplier, multiplier);
      cairo_set_source_surface(cr, source->get(), origin.x, origin.y);
      cairo_pattern_set_filter(cairo_get_source(cr), CAIRO_FILTER_NEAREST);
      cairo_paint(cr);
    }
    else
    {
      // Cached bitmap is to scale
      const int divider = 1 << -zoom;
 
      auto origin = viewArea.getTopLeft() - tileArea.getTopLeft() / divider;
 
      cairo_set_source_surface(cr, source->get(), origin.x, origin.y);
      cairo_paint(cr);
    }
  }
}

Referenced by Operations1bpp::draw(), Operations8bpp::draw(), and Operations::draw().

Here is the call graph for this function:

Here is the caller graph for this function:

drawPixelValue() [1/2]

void CommonOperations::drawPixelValue ( cairo_t *  cr, int  x, int  y, int  size, int  value  )

static

{
  std::ostringstream s;
  s << value;
  const std::string v    = s.str();
  const char*       cstr = v.c_str();
 
  cairo_move_to(cr, x, y);
  cairo_line_to(cr, x + size, y);
  cairo_line_to(cr, x + size, y + size);
  cairo_line_to(cr, x, y + size);
  cairo_line_to(cr, x, y);
  cairo_clip(cr);
  // cairo_stroke(cr);
 
  cairo_text_extents_t extents;
  cairo_text_extents(cr, cstr, &extents);
 
  const double xx = x + size / 2 - (extents.width / 2 + extents.x_bearing);
  const double yy = y + size / 2 - (extents.height / 2 + extents.y_bearing);
 
  cairo_move_to(cr, xx, yy);
  cairo_show_text(cr, cstr);
}

Referenced by Operations1bpp::draw(), Operations8bpp::draw(), and Operations::draw().

Here is the caller graph for this function:

drawPixelValue() [2/2]

void CommonOperations::drawPixelValue ( cairo_t *  cr, int  x, int  y, int  size, int  value, Color const &  bgColor  )

static

{
  bgColor.getContrastingBlackOrWhite().setColor(cr);
  drawPixelValue(cr, x, y, size, value);
}

Here is the call graph for this function:

drawState()

void CommonOperations::drawState ( cairo_t *  cr, TileState  s, Scroom::Utils::Rectangle< double >  viewArea  )

overridevirtual

Draw the given state into the given viewArea

The associated tile is likely not loaded or not initialized or in whatever other TileState that doesn't allow its contents to be drawn.

Something needs to be drawn in the given viewArea anyway. Implementors might want to just draw an empty rectangle, maybe color-coded to reflect the state of the tile.

Implements LayerOperations.

{
  Color c;
 
  switch(s)
  {
  case TILE_UNINITIALIZED:
    c = Color(1, 1, 0.5); // Yellow
    break;
  case TILE_UNLOADED:
    c = Color(0.5, 1, 0.5); // Green
    break;
  case TILE_LOADED:
    c = Color(1, 0.5, 0.5); // Red
    break;
  case TILE_OUT_OF_BOUNDS:
  default:
    c = Colors::OUT_OF_BOUNDS;
    break;
  }
 
  drawRectangle(cr, c, viewArea);
}

Here is the call graph for this function:

initializeCairo()

void CommonOperations::initializeCairo ( cairo_t *  cr )

overridevirtual

Initialize the canvas for drawing the bitmap

When TiledBitmapInterface::redraw() is called, (a portion of) the Layer needs to be redrawn. TiledBitmap will compute which tiles are involved in the redraw, and call draw() or drawState() for each of them, as appropriate. However, before doing so, it will first call initializeCairo(). You can take this opportunity to set various properties that are needed in all subsequent calls to draw() and drawState(), such as anti-aliasing and line caps.

Implements LayerOperations.

{
  cairo_set_antialias(cr, CAIRO_ANTIALIAS_NONE);
  cairo_set_line_cap(cr, CAIRO_LINE_CAP_SQUARE);
}

---

The documentation for this class was generated from the following files:

• inc/scroom/layeroperations.hh
• libs/tiled-bitmap/src/layeroperations.cc