Layer Class Reference

#include <tiledbitmaplayer.hh>

Inheritance diagram for Layer:

Collaboration diagram for Layer:

Public Types
using	Ptr = std::shared_ptr< Layer >
Public Types inherited from Viewable
using	Ptr = std::shared_ptr< Viewable >
using	WeakPtr = std::weak_ptr< Viewable >

Public Member Functions
int	getHorTileCount () const
int	getVerTileCount () const
CompressedTile::Ptr	getTile (int i, int j)
CompressedTileLine &	getTileLine (int j)
void	fetchData (SourcePresentation::Ptr sp, const ThreadPool::WeakQueue::Ptr &queue, std::function< void()> on_finished)
int	getWidth () const
int	getHeight () const
int	getDepth () const
Scroom::Utils::Rectangle< int >	getRect () const
Scroom::Bookkeeping::Token	registerObserver (const TileInitialisationObserver::Ptr &observer)
Scroom::MemoryBlobs::PageProvider::Ptr	getPageProvider ()
void	open (ViewInterface::WeakPtr vi) override
void	close (ViewInterface::WeakPtr vi) override
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 depth, int layerWidth, int layerHeight, int bpp, Scroom::MemoryBlobs::PageProvider::Ptr provider)
static Ptr	create (int layerWidth, int layerHeight, int bpp)

Private Member Functions
	Layer (int depth, int layerWidth, int layerHeight, int bpp, Scroom::MemoryBlobs::PageProvider::Ptr provider)
	Layer.

Private Attributes
int	depth
int	width
int	height
int	horTileCount
int	verTileCount
CompressedTileGrid	tiles
CompressedTile::Ptr	outOfBounds
CompressedTileLine	lineOutOfBounds
Scroom::MemoryBlobs::PageProvider::Ptr	pageProvider
Scroom::Logger	logger

Member Typedef Documentation

Ptr

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

Constructor & Destructor Documentation

Layer()

Layer::Layer ( int  depth, int  layerWidth, int  layerHeight, int  bpp, Scroom::MemoryBlobs::PageProvider::Ptr  provider  )

private

Layer.

  : depth(depth_)
  , width(layerWidth)
  , height(layerHeight)
  , horTileCount((width + TILESIZE - 1) / TILESIZE)
  , verTileCount((height + TILESIZE - 1) / TILESIZE)
  , pageProvider(std::move(provider))
{
  for(int j = 0; j < verTileCount; j++)
  {
    tiles.emplace_back();
    CompressedTileLine& tl = tiles[j];
    for(int i = 0; i < horTileCount; i++)
    {
      CompressedTile::Ptr const tile = CompressedTile::create(depth_, i, j, bpp, pageProvider);
      tl.push_back(tile);
    }
  }
 
  outOfBounds = CompressedTile::create(depth_, -1, -1, bpp, pageProvider, TSI_OUT_OF_BOUNDS);
  for(int i = 0; i < horTileCount; i++)
  {
    lineOutOfBounds.push_back(outOfBounds);
  }
 
  logger->debug("Layer {} ({} bpp), {}*{}, TileCount {}*{}", depth_, bpp, width, height, horTileCount, verTileCount);
}

Here is the call graph for this function:

Member Function Documentation

close()

void Layer::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(CompressedTileLine const& line: tiles)
  {
    for(const CompressedTile::Ptr& tile: line)
    {
      tile->close(vi);
    }
  }
  for(const CompressedTile::Ptr& tile: lineOutOfBounds)
  {
    tile->close(vi);
  }
  outOfBounds->close(vi);
}

create() [1/2]

Layer::Ptr Layer::create ( int  depth, int  layerWidth, int  layerHeight, int  bpp, Scroom::MemoryBlobs::PageProvider::Ptr  provider  )

static

{
  return Ptr(new Layer(depth, layerWidth, layerHeight, bpp, std::move(provider)));
}

Referenced by create(), TiledBitmap::initialize(), TiledBitmap::initialize(), Pnm::open(), and Tiff::open().

Here is the caller graph for this function:

create() [2/2]

Layer::Ptr Layer::create ( int  layerWidth, int  layerHeight, int  bpp  )

static

{
  Scroom::MemoryBlobs::PageProvider::Ptr const provider = createProvider(layerWidth, layerHeight, bpp);
 
  return create(0, layerWidth, layerHeight, bpp, provider);
}

Here is the call graph for this function:

fetchData()

void Layer::fetchData	(	SourcePresentation::Ptr	sp,
		const ThreadPool::WeakQueue::Ptr &	queue,
		std::function< void()>	on_finished
	)

{
  DataFetcher const df(
    shared_from_this<Layer>(), height, horTileCount, verTileCount, std::move(sp), queue, std::move(on_finished)
  );
  CpuBound()->schedule(df, DATAFETCH_PRIO, queue);
}

Here is the call graph for this function:

getDepth()

int Layer::getDepth ( ) const

inline

{ return depth; }

getHeight()

int Layer::getHeight ( ) const

inline

{ return height; }

getHorTileCount()

int Layer::getHorTileCount

(

)

const

{ return horTileCount; }

getPageProvider()

Scroom::MemoryBlobs::PageProvider::Ptr Layer::getPageProvider ( )

inline

{ return pageProvider; }

getRect()

Scroom::Utils::Rectangle< int > Layer::getRect ( ) const

inline

{ return {0, 0, width, height}; }

getTile()

CompressedTile::Ptr Layer::getTile	(	int	i,
		int	j
	)

{
  if(0 <= i && i < horTileCount && 0 <= j && j < verTileCount)
  {
    return tiles[j][i];
  }
 
  return outOfBounds;
}

getTileLine()

CompressedTileLine & Layer::getTileLine

(

int

j

)

{
  if(0 <= j && j < verTileCount)
  {
    return tiles[j];
  }
 
  return lineOutOfBounds;
}

getVerTileCount()

int Layer::getVerTileCount

(

)

const

{ return verTileCount; }

getWidth()

int Layer::getWidth ( ) const

inline

{ return width; }

open()

void Layer::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.

{
  for(CompressedTileLine const& line: tiles)
  {
    for(const CompressedTile::Ptr& tile: line)
    {
      tile->open(vi);
    }
  }
  for(const CompressedTile::Ptr& tile: lineOutOfBounds)
  {
    tile->open(vi);
  }
  outOfBounds->open(vi);
}

registerObserver()

Scroom::Bookkeeping::Token Layer::registerObserver

(

const TileInitialisationObserver::Ptr &

observer

)

{
  Scroom::Bookkeeping::Token t;
 
  for(auto& line: tiles)
  {
    for(auto& tile: line)
    {
      t.add(tile->registerObserver(observer));
    }
  }
  return t;
}

Here is the call graph for this function:

Member Data Documentation

depth

int Layer::depth

private

Referenced by create(), and getDepth().

height

int Layer::height

private

Referenced by fetchData(), getHeight(), getRect(), and Layer().

horTileCount

int Layer::horTileCount

private

Referenced by fetchData(), getHorTileCount(), getTile(), and Layer().

lineOutOfBounds

CompressedTileLine Layer::lineOutOfBounds

private

Referenced by close(), getTileLine(), Layer(), and open().

logger

Scroom::Logger Layer::logger

private

Referenced by Layer().

outOfBounds

CompressedTile::Ptr Layer::outOfBounds

private

Referenced by close(), getTile(), Layer(), and open().

pageProvider

Scroom::MemoryBlobs::PageProvider::Ptr Layer::pageProvider

private

Referenced by getPageProvider(), and Layer().

tiles

CompressedTileGrid Layer::tiles

private

Referenced by close(), getTile(), getTileLine(), Layer(), open(), and registerObserver().

verTileCount

int Layer::verTileCount

private

Referenced by fetchData(), getTile(), getTileLine(), getVerTileCount(), and Layer().

width

int Layer::width

private

Referenced by getRect(), getWidth(), and Layer().

---

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

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