TiledBitmap Class Reference

#include <tiled-bitmap.hh>

Inheritance diagram for TiledBitmap:

Collaboration diagram for TiledBitmap:

Public Types
using	Ptr = std::shared_ptr< TiledBitmap >
using	WeakPtr = std::weak_ptr< TiledBitmap >
using	ViewDataMap = Scroom::Utils::WeakKeyMap< ViewInterface::WeakPtr, TiledBitmapViewData::Ptr >
Public Types inherited from TiledBitmapInterface
using	Ptr = std::shared_ptr< TiledBitmapInterface >
Public Types inherited from Viewable
using	Ptr = std::shared_ptr< Viewable >
using	WeakPtr = std::weak_ptr< Viewable >
Public Types inherited from TileInitialisationObserver
using	Ptr = std::shared_ptr< TileInitialisationObserver >
using	WeakPtr = std::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
Scroom::Utils::Context::ConstPtr	getContext () const override
void	tileCreated (const CompressedTile::Ptr &tile) override
void	tileFinished (const CompressedTile::Ptr &tile) override
	TileInitialisationObserver.
ProgressInterface::Ptr	progressInterface ()
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 >
std::shared_ptr< R >	shared_from_this ()
template<typename R >
std::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
Scroom::Logger	logger
Scroom::Utils::Context::Ptr	context

Member Typedef Documentation

Ptr

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

ViewDataMap

using TiledBitmap::ViewDataMap = Scroom::Utils::WeakKeyMap<ViewInterface::WeakPtr, TiledBitmapViewData::Ptr>

WeakPtr

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

Constructor & Destructor Documentation

~TiledBitmap()

TiledBitmap::~TiledBitmap ( )

override

{
  logger->debug("TiledBitmap: Destructing...");
 
  coordinators.clear();
  layers.clear();
}

TiledBitmap() [1/3]

TiledBitmap::TiledBitmap ( const TiledBitmap &  )

delete

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())
  , context(Scroom::Utils::Context::create())
{
  set(context, Scroom::Utils::TweakPresentationPosition::create());
  set(context, Scroom::Utils::TweakPositionTextBox::create());
  set(context, Scroom::Utils::TweakRulers::create());
  set(
    context,
    Scroom::Utils::ITweakSelection::Map{
      {SelectionType::GRID, Scroom::Utils::TweakGridSelection::create()},
      {SelectionType::PIXEL, Scroom::Utils::TweakPixelSelection::create()}
    }
  );
}

Here is the call graph for this function:

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

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

getContext()

Scroom::Utils::Context::ConstPtr TiledBitmap::getContext ( ) const

overridevirtual

Implements TiledBitmapInterface.

{ return context; }

initialize() [1/2]

void TiledBitmap::initialize ( )

private

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

Referenced by initialize().

Here is the call graph for this function:

Here is the caller 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 )

overridevirtual

The tile has been created.

This event will be sent as soon as the observer is registered (because obvously the tile has already been created beforehand).

Note

This event will be sent using the thread that is registering the observer. Be careful with your mutexes :-)

Reimplemented from TileInitialisationObserver.

{ tileCount++; }

tileFinished()

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

overridevirtual

TileInitialisationObserver.

This event will be sent when the tile is completely filled with data. This would be a good time to update progress bars and start prescaling.

Note

This event will be sent on the thread that is filling the tile with data.

Reimplemented from TileInitialisationObserver.

{
  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(
      [this]
      {
        progressBroadcaster->setWorking(1.0 * tileFinishedCount / tileCount);
        if(tileFinishedCount == tileCount)
        {
          progressBroadcaster->setFinished();
          logger->info("Finished loading file");
        }
      }
    );
  }
}

Here is the call graph for this function:

Member Data Documentation

bitmapHeight

int TiledBitmap::bitmapHeight

private

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

bitmapWidth

int TiledBitmap::bitmapWidth

private

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

context

Scroom::Utils::Context::Ptr TiledBitmap::context

private

Referenced by getContext(), and TiledBitmap().

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().

logger

Scroom::Logger TiledBitmap::logger

private

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

ls

LayerSpec TiledBitmap::ls

private

Referenced by create(), create(), initialize(), 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

{0};

Referenced by tileCreated(), and tileFinished().

tileFinishedCount

int TiledBitmap::tileFinishedCount {0}

private

{0};

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