TiledBitmap Class Reference

#include <tiled-bitmap.hh>

Inheritance diagram for TiledBitmap:

Collaboration diagram for TiledBitmap:

Public Types
using	Ptr = boost::shared_ptr< TiledBitmap >
using	WeakPtr = boost::weak_ptr< TiledBitmap >
using	ViewDataMap = std::map< ViewInterface::WeakPtr, TiledBitmapViewData::Ptr >
Public Types inherited from TiledBitmapInterface
using	Ptr = boost::shared_ptr< TiledBitmapInterface >
Public Types inherited from Viewable
using	Ptr = boost::shared_ptr< Viewable >
using	WeakPtr = boost::weak_ptr< Viewable >
Public Types inherited from TileInitialisationObserver
using	Ptr = boost::shared_ptr< TileInitialisationObserver >
using	WeakPtr = boost::weak_ptr< TileInitialisationObserver >

Public Member Functions
	~TiledBitmap () override
	TiledBitmap (const TiledBitmap &)=delete
	TiledBitmap (TiledBitmap &&)=delete
TiledBitmap	operator= (const TiledBitmap &)=delete
TiledBitmap	operator= (TiledBitmap &&)=delete
void	setSource (SourcePresentation::Ptr sp) override
Layer::Ptr	getBottomLayer () override
void	open (ViewInterface::WeakPtr viewInterface) override
void	close (ViewInterface::WeakPtr vi) override
void	redraw (ViewInterface::Ptr const &vi, cairo_t *cr, Scroom::Utils::Rectangle< double > const &presentationArea, int zoom) override
void	clearCaches (ViewInterface::Ptr vi) override
void	tileCreated (const CompressedTile::Ptr &tile) override
void	tileFinished (const CompressedTile::Ptr &tile) override
ProgressInterface::Ptr	progressInterface ()
Public Member Functions inherited from TileInitialisationObserver
virtual void	tileCreated (const boost::shared_ptr< CompressedTile > &tile)
virtual void	tileFinished (const boost::shared_ptr< CompressedTile > &tile)
	TileInitialisationObserver. More...
Public Member Functions inherited from Scroom::Utils::Base
	Base ()=default
	Base (const Base &)=delete
	Base (Base &&)=delete
Base &	operator= (const Base &)=delete
Base &	operator= (Base &&)=delete
virtual	~Base ()=default
template<typename R >
boost::shared_ptr< R >	shared_from_this ()
template<typename R >
boost::shared_ptr< R const >	shared_from_this () const

Static Public Member Functions
static Ptr	create (int bitmapWidth, int bitmapHeight, LayerSpec const &ls)
static Ptr	create (const Layer::Ptr &bottom, const LayerSpec &ls)

Private Member Functions
	TiledBitmap (int bitmapWidth, int bitmapHeight, LayerSpec ls)
void	initialize ()
void	initialize (const Layer::Ptr &bottom)
void	connect (Layer::Ptr const &layer, Layer::Ptr const &prevLayer, const LayerOperations::Ptr &prevLo)

Static Private Member Functions
static void	drawTile (cairo_t *cr, const CompressedTile::Ptr &tile, const Scroom::Utils::Rectangle< double > &viewArea)

Private Attributes
int	bitmapWidth
int	bitmapHeight
LayerSpec	ls
std::vector< Layer::Ptr >	layers
std::list< LayerCoordinator::Ptr >	coordinators
boost::mutex	viewDataMutex
ViewDataMap	viewData
int	tileCount {0}
boost::mutex	tileFinishedMutex
int	tileFinishedCount {0}
Scroom::Utils::ProgressInterfaceBroadcaster::Ptr	progressBroadcaster
Scroom::Utils::StuffList	registrations

Member Typedef Documentation

Ptr

using TiledBitmap::Ptr = boost::shared_ptr<TiledBitmap>

ViewDataMap

using TiledBitmap::ViewDataMap = std::map<ViewInterface::WeakPtr, TiledBitmapViewData::Ptr>

WeakPtr

using TiledBitmap::WeakPtr = boost::weak_ptr<TiledBitmap>

Constructor & Destructor Documentation

~TiledBitmap()

TiledBitmap::~TiledBitmap ( )

override

{
  spdlog::debug("TiledBitmap: Destructing...");
 
  coordinators.clear();
  layers.clear();
}

TiledBitmap() [1/3]

TiledBitmap::TiledBitmap ( const TiledBitmap &  )

delete

Referenced by create().

Here is the caller graph for this function:

TiledBitmap() [2/3]

TiledBitmap::TiledBitmap ( TiledBitmap &&  )

delete

TiledBitmap() [3/3]

TiledBitmap::TiledBitmap ( int  bitmapWidth, int  bitmapHeight, LayerSpec  ls  )

private

  : bitmapWidth(bitmapWidth_)
  , bitmapHeight(bitmapHeight_)
  , ls(std::move(ls_))
  , progressBroadcaster(Scroom::Utils::ProgressInterfaceBroadcaster::create())
{
}

Member Function Documentation

clearCaches()

void TiledBitmap::clearCaches ( ViewInterface::Ptr  vi )

overridevirtual

Clear all bitmap caches related to the view.

You'd typically do this if the bitmap has somehow changed appearance, for example when switching to a new Colormap.

Parameters

vi	The ViewInterface for which to clear the caches

Implements TiledBitmapInterface.

{
  boost::mutex::scoped_lock const lock(viewDataMutex);
  TiledBitmapViewData::Ptr const  tbvd = viewData[viewInterface];
  if(tbvd)
  {
    tbvd->clearVolatileStuff();
  }
}

close()

void TiledBitmap::close ( ViewInterface::WeakPtr  vi )

overridevirtual

Gets called just before the View is destroyed

Precondition

Should be called from within a Gdk critical section (i.e. between gdk_threads_enter() and gdk_threads_leave() calls)

Implements Viewable.

{
  for(Layer::Ptr const& l: layers)
  {
    l->close(vi);
  }
 
  boost::mutex::scoped_lock const lock(viewDataMutex);
  TiledBitmapViewData::Ptr const  vd = viewData[vi];
  // Yuk. ProgressBroadcaster has a reference to viewData, so erasing it
  // from the map isn't enough.
  vd->token.reset();
  viewData.erase(vi);
}

connect()

void TiledBitmap::connect ( Layer::Ptr const &  layer, Layer::Ptr const &  prevLayer, const LayerOperations::Ptr &  prevLo  )

private

{
  const int horTileCount = prevLayer->getHorTileCount();
  const int verTileCount = prevLayer->getVerTileCount();
 
  std::vector<LayerCoordinator::Ptr> coordinators_;
 
  for(int j = 0; j < verTileCount; j++)
  {
    const int voffset = j % 8;
    if(!voffset)
    {
      // New line of target tiles
      coordinators_.clear();
      CompressedTileLine const& tileLine = layer->getTileLine(j / 8);
      for(auto& z: tileLine)
      {
        LayerCoordinator::Ptr const lc = LayerCoordinator::create(z, prevLo);
        coordinators_.push_back(lc);
        coordinators.push_back(lc);
      }
    }
 
    for(int i = 0; i < horTileCount; i++)
    {
      const int                   hoffset = i % 8;
      LayerCoordinator::Ptr const lc      = coordinators_[i / 8];
      lc->addSourceTile(hoffset, voffset, prevLayer->getTile(i, j));
    }
  }
}

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

create() [1/2]

TiledBitmap::Ptr TiledBitmap::create ( const Layer::Ptr &  bottom, const LayerSpec &  ls  )

static

{
  TiledBitmap::Ptr result(new TiledBitmap(bottom->getWidth(), bottom->getHeight(), ls));
  result->initialize(bottom);
  return result;
}

Here is the call graph for this function:

create() [2/2]

TiledBitmap::Ptr TiledBitmap::create ( int  bitmapWidth, int  bitmapHeight, LayerSpec const &  ls  )

static

{
  TiledBitmap::Ptr result(new TiledBitmap(bitmapWidth, bitmapHeight, ls));
  result->initialize();
  return result;
}

Referenced by createTiledBitmap(), and anonymous_namespace{tiledbitmappresentation.cc}::OpenTiledBitmapAsPresentation::open().

Here is the call graph for this function:

Here is the caller graph for this function:

drawTile()

void TiledBitmap::drawTile ( cairo_t *  cr, const CompressedTile::Ptr &  tile, const Scroom::Utils::Rectangle< double > &  viewArea  )

staticprivate

{
  const int margin = 5;
 
  if(viewArea.width() > 2 * margin && viewArea.height() > 2 * margin)
  {
    Scroom::Utils::Rectangle<double> const rect(
      viewArea.x() + margin, viewArea.y() + margin, viewArea.width() - 2 * margin, viewArea.height() - 2 * margin);
 
    cairo_set_source_rgb(cr, 0, 0, 0); // Black
    drawRectangleContour(cr, rect);
 
    const std::string label = fmt::format("Layer {}, Tile ({}, {}), {} bpp", tile->depth, tile->x, tile->y, tile->bpp);
    cairo_move_to(cr, rect.x() + 20, rect.y() + 20);
    cairo_show_text(cr, label.c_str());
  }
}

Referenced by redraw().

Here is the call graph for this function:

Here is the caller graph for this function:

getBottomLayer()

Layer::Ptr TiledBitmap::getBottomLayer ( )

overridevirtual

Retrieve the bottom layer of the TiledBitmap.

This allows you to fill the layer with data yourself, instead of relying on setSource()

See also

setSource()

Implements TiledBitmapInterface.

{ return layers[0]; }

initialize() [1/2]

void TiledBitmap::initialize ( )

private

{ initialize(Layer::create(bitmapWidth, bitmapHeight, ls[0]->getBpp())); }

Here is the call graph for this function:

initialize() [2/2]

void TiledBitmap::initialize ( const Layer::Ptr &  bottom )

private

{
  int                                          width    = bitmapWidth;
  int                                          height   = bitmapHeight;
  unsigned int                                 i        = 0;
  LayerOperations::Ptr                         lo       = ls[i];
  Scroom::MemoryBlobs::PageProvider::Ptr const provider = bottom->getPageProvider();
 
  registrations.emplace_back(bottom->registerObserver(shared_from_this<TileInitialisationObserver>()));
  layers.push_back(bottom);
 
  Layer::Ptr           prevLayer = bottom;
  LayerOperations::Ptr prevLo    = lo;
 
  width  = (width + 7) / 8; // Round up
  height = (height + 7) / 8;
  i++;
 
  while(std::max(width, height) > TILESIZE / 4)
  {
    if(i < ls.size())
    {
      lo = ls[i];
    }
 
    Layer::Ptr const layer = Layer::create(i, width, height, lo->getBpp(), provider);
    registrations.emplace_back(layer->registerObserver(shared_from_this<TileInitialisationObserver>()));
    layers.push_back(layer);
 
    connect(layer, prevLayer, prevLo);
 
    prevLayer = layer;
    prevLo    = lo;
    width     = (width + 7) / 8; // Round up
    height    = (height + 7) / 8;
    i++;
  }
}

Here is the call graph for this function:

open()

void TiledBitmap::open ( ViewInterface::WeakPtr  vi )

overridevirtual

Gets called just after the View is created

Precondition

Should be called from within a Gdk critical section (i.e. between gdk_threads_enter() and gdk_threads_leave() calls)

Implements Viewable.

{
  boost::mutex::scoped_lock      lock(viewDataMutex);
  TiledBitmapViewData::Ptr const vd = TiledBitmapViewData::create(viewInterface);
  viewData[viewInterface]           = vd;
  vd->token.add(progressBroadcaster->subscribe(vd));
  lock.unlock();
 
  for(Layer::Ptr const& l: layers)
  {
    l->open(viewInterface);
  }
}

Here is the call graph for this function:

operator=() [1/2]

TiledBitmap TiledBitmap::operator= ( const TiledBitmap &  )

delete

operator=() [2/2]

TiledBitmap TiledBitmap::operator= ( TiledBitmap &&  )

delete

progressInterface()

ProgressInterface::Ptr TiledBitmap::progressInterface ( )

inline

{ return progressBroadcaster; }

redraw()

void TiledBitmap::redraw ( ViewInterface::Ptr const &  vi, cairo_t *  cr, Scroom::Utils::Rectangle< double > const &  presentationArea, int  zoom  )

overridevirtual

Redraw a portion of the bitmap.

This is typically called from PresentationInterface::redraw()

See also

PresentationInterface::redraw()

Implements TiledBitmapInterface.

{
  TiledBitmapViewData::Ptr const viewData_                       = viewData[vi];
  auto                           scaledRequestedPresentationArea = presentationArea;
 
  unsigned int layerNr = 0;
  while(zoom <= -3 && layerNr < layers.size() - 1)
  {
    layerNr++;
    zoom += 3;
    scaledRequestedPresentationArea /= 8;
  }
  Layer::Ptr const           layer           = layers[layerNr];
  LayerOperations::Ptr const layerOperations = ls[std::min(ls.size() - 1, static_cast<size_t>(layerNr))];
 
  const Scroom::Utils::Rectangle<int> actualPresentationArea = layer->getRect();
  const auto validPresentationArea = scaledRequestedPresentationArea.intersection(actualPresentationArea);
 
  const int left   = scaledRequestedPresentationArea.getLeft();
  const int top    = scaledRequestedPresentationArea.getTop();
  const int right  = scaledRequestedPresentationArea.getRight();
  const int bottom = scaledRequestedPresentationArea.getBottom();
 
  const int imin = std::max(0, left / TILESIZE);
  const int imax = (right + TILESIZE - 1) / TILESIZE;
  const int jmin = std::max(0, top / TILESIZE);
  const int jmax = (bottom + TILESIZE - 1) / TILESIZE;
 
  viewData_->setNeededTiles(layer, imin, imax, jmin, jmax, zoom, layerOperations);
 
  const double pixelSize = pixelSizeFromZoom(zoom);
 
  layerOperations->initializeCairo(cr);
 
  const auto clippedRequestedPresentationArea =
    scaledRequestedPresentationArea.above(validPresentationArea.getBottom()).leftOf(validPresentationArea.getRight());
 
  for(int i = imin; i < imax; i++)
  {
    for(int j = jmin; j < jmax; j++)
    {
      Scroom::Utils::Point<int> const tileIndex(i, j);
 
      const auto tileArea        = TileAreaForIndex(tileIndex);
      const auto visibleTileArea = tileArea.intersection(clippedRequestedPresentationArea);
 
      const auto tileAreaRect = visibleTileArea - tileArea.getTopLeft();
      const auto viewAreaRect = (visibleTileArea - clippedRequestedPresentationArea.getTopLeft()) * pixelSize;
 
      CompressedTile::Ptr const  tile          = layer->getTile(i, j);
      TileViewState::Ptr const   tileViewState = tile->getViewState(vi);
      Scroom::Utils::Stuff const cacheResult   = tileViewState->getCacheResult();
      ConstTile::Ptr const       t             = tile->getConstTileAsync();
 
      if(t)
      {
        cairo_save(cr);
        layerOperations->draw(cr, t, tileAreaRect, viewAreaRect, zoom, cacheResult);
        cairo_restore(cr);
      }
      else
      {
        layerOperations->drawState(cr, tile->getState(), viewAreaRect);
      }
#ifdef DEBUG_TILES
      drawTile(cr, tile, viewAreaRect);
#endif
    }
  }
}

Here is the call graph for this function:

setSource()

void TiledBitmap::setSource ( SourcePresentation::Ptr  sp )

overridevirtual

Provide bitmap data to the TiledBitmap

Bitmap data will be loaded and pre-scaled in a fashion that least loads cpu and memory.

Parameters

sp	source of the bitmap data

Implements TiledBitmapInterface.

{
  registrations.push_back(Scroom::TiledBitmap::scheduleLoadingBitmap(sp, layers[0], progressBroadcaster));
}

Here is the call graph for this function:

tileCreated()

void TiledBitmap::tileCreated ( const CompressedTile::Ptr &  tile )

override

{
  UNUSED(tile);
  tileCount++;
}

tileFinished()

void TiledBitmap::tileFinished ( const CompressedTile::Ptr &  tile )

override

{
  UNUSED(tile);
  boost::mutex::scoped_lock const lock(tileFinishedMutex);
  tileFinishedCount++;
  if(tileFinishedCount > tileCount)
  {
    defect_message("ERROR: Too many tiles are finished!");
  }
  else
  {
    Scroom::GtkHelpers::sync_on_ui_thread(
      [=]
      {
        progressBroadcaster->setWorking(1.0 * tileFinishedCount / tileCount);
        if(tileFinishedCount == tileCount)
        {
          progressBroadcaster->setFinished();
          spdlog::info("Finished loading file");
        }
      });
  }
}

Here is the call graph for this function:

Member Data Documentation

bitmapHeight

int TiledBitmap::bitmapHeight

private

Referenced by create(), and initialize().

bitmapWidth

int TiledBitmap::bitmapWidth

private

Referenced by create(), and initialize().

coordinators

std::list<LayerCoordinator::Ptr> TiledBitmap::coordinators

private

Referenced by connect(), and ~TiledBitmap().

layers

std::vector<Layer::Ptr> TiledBitmap::layers

private

Referenced by close(), getBottomLayer(), initialize(), open(), redraw(), setSource(), and ~TiledBitmap().

ls

LayerSpec TiledBitmap::ls

private

Referenced by create(), initialize(), and redraw().

progressBroadcaster

Scroom::Utils::ProgressInterfaceBroadcaster::Ptr TiledBitmap::progressBroadcaster

private

Referenced by open(), progressInterface(), setSource(), and tileFinished().

registrations

Scroom::Utils::StuffList TiledBitmap::registrations

private

Referenced by initialize(), and setSource().

tileCount

int TiledBitmap::tileCount {0}

private

Referenced by tileCreated(), and tileFinished().

tileFinishedCount

int TiledBitmap::tileFinishedCount {0}

private

Referenced by tileFinished().

tileFinishedMutex

boost::mutex TiledBitmap::tileFinishedMutex

private

Referenced by tileFinished().

viewData

ViewDataMap TiledBitmap::viewData

private

Referenced by clearCaches(), close(), open(), and redraw().

viewDataMutex

boost::mutex TiledBitmap::viewDataMutex

private

Referenced by clearCaches(), close(), and open().

---

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

• libs/tiled-bitmap/src/tiled-bitmap.hh
• libs/tiled-bitmap/src/tiled-bitmap.cc