CompressedTile Class Reference

#include <tiledbitmaplayer.hh>

Inheritance diagram for CompressedTile:

Collaboration diagram for CompressedTile:

Public Types
using	Ptr = std::shared_ptr< CompressedTile >
Public Types inherited from Scroom::Utils::Observable< TileInitialisationObserver >
using	Observer = std::shared_ptr< TileInitialisationObserver >
using	Ptr = std::shared_ptr< Observable< TileInitialisationObserver > >
Public Types inherited from Scroom::Utils::Observable< TileLoadingObserver >
using	Observer = std::shared_ptr< TileLoadingObserver >
using	Ptr = std::shared_ptr< Observable< TileLoadingObserver > >
Public Types inherited from Viewable
using	Ptr = std::shared_ptr< Viewable >
using	WeakPtr = std::weak_ptr< Viewable >

Public Member Functions
Tile::Ptr	initialize ()
Scroom::Bookkeeping::Token	registerStrongObserver (TileInitialisationObserver::Ptr const &observer)
Scroom::Bookkeeping::Token	registerObserver (TileInitialisationObserver::WeakPtr const &observer)
Scroom::Bookkeeping::Token	registerStrongObserver (TileLoadingObserver::Ptr const &observer)
Scroom::Bookkeeping::Token	registerObserver (TileLoadingObserver::WeakPtr const &observer)
Tile::Ptr	getTileSync ()
ConstTile::Ptr	getConstTileSync ()
ConstTile::Ptr	getConstTileAsync ()
void	reportFinished ()
TileState	getState ()
std::shared_ptr< TileViewState >	getViewState (const ViewInterface::WeakPtr &vi)
void	open (ViewInterface::WeakPtr vi) override
void	close (ViewInterface::WeakPtr vi) override
Public Member Functions inherited from Scroom::Utils::Observable< TileInitialisationObserver >
	Observable ()
	Observable (const Observable &)=delete
	Observable (Observable &&)=delete
	~Observable () override
Observable	operator= (const Observable &)=delete
Observable	operator= (Observable &&)=delete
Scroom::Bookkeeping::Token	registerStrongObserver (Observer const &observer)
Scroom::Bookkeeping::Token	registerObserver (ObserverWeak const &observer)
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
Public Member Functions inherited from Scroom::Utils::Observable< TileLoadingObserver >
	Observable ()
	Observable (const Observable &)=delete
	Observable (Observable &&)=delete
	~Observable () override
Observable	operator= (const Observable &)=delete
Observable	operator= (Observable &&)=delete
Scroom::Bookkeeping::Token	registerStrongObserver (Observer const &observer)
Scroom::Bookkeeping::Token	registerObserver (ObserverWeak const &observer)

Static Public Member Functions
static Ptr	create (int depth, int x, int y, int bpp, const Scroom::MemoryBlobs::PageProvider::Ptr &provider, TileStateInternal state=TSI_UNINITIALIZED)

Public Attributes
const int	depth
const int	x
const int	y
const int	bpp

Protected Member Functions
void	observerAdded (TileInitialisationObserver::Ptr const &observer, Scroom::Bookkeeping::Token const &token) override
void	observerAdded (TileLoadingObserver::Ptr const &observer, Scroom::Bookkeeping::Token const &token) override
Protected Member Functions inherited from Scroom::Utils::Observable< TileInitialisationObserver >
std::list< Observer >	getObservers ()
virtual void	observerAdded (Observer const &observer, Scroom::Bookkeeping::Token const &token)
Protected Member Functions inherited from Scroom::Utils::Observable< TileLoadingObserver >
std::list< Observer >	getObservers ()
virtual void	observerAdded (Observer const &observer, Scroom::Bookkeeping::Token const &token)

Private Member Functions
	CompressedTile (int depth, int x, int y, int bpp, const Scroom::MemoryBlobs::PageProvider::Ptr &provider, TileStateInternal state)
	CompressedTile.
void	cleanupState ()
ConstTile::Ptr	do_load ()
void	notifyObservers (const ConstTile::Ptr &tile)

Private Attributes
TileStateInternal	state
Tile::WeakPtr	tile
ConstTile::WeakPtr	constTile
Scroom::MemoryBlobs::PageProvider::Ptr	provider
Scroom::MemoryBlobs::Blob::Ptr	data
boost::mutex	stateData
boost::mutex	tileData
ThreadPool::Queue::WeakPtr	queue
Scroom::Utils::WeakKeyMap< ViewInterface::WeakPtr, std::weak_ptr< TileViewState > >	viewStates

Detailed Description

Internal data structure representing a Tile.

The CompressedTile class contains administrative information about the Tile. The Tile itself (and associated bitmap data) will be loaded and unloaded as needed. This class will stay in memory always.

Observers can receive events related to this tile.

Member Typedef Documentation

Ptr

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

Constructor & Destructor Documentation

CompressedTile()

CompressedTile::CompressedTile ( int  depth, int  x, int  y, int  bpp, const Scroom::MemoryBlobs::PageProvider::Ptr &  provider, TileStateInternal  state  )

private

CompressedTile.

  : depth(depth_)
  , x(x_)
  , y(y_)
  , bpp(bpp_)
  , state(state_)
  , provider(provider_)
  , data(Blob::create(provider_, TILESIZE * TILESIZE * bpp / 8))
{
}

Member Function Documentation

cleanupState()

void CompressedTile::cleanupState ( )

private

Does some internal state maintenance.

Call only while stateData is locked.

{
  if(state == TSI_LOADING_ASYNCHRONOUSLY && !queue.lock())
  {
    // Someone, after triggering an asynchronous load, decided not to need
    // the tile. Changing back to normal.
    state = TSI_NORMAL;
  }
}

Referenced by do_load(), and observerAdded().

Here is the caller graph for this function:

close()

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

{ viewStates.erase(vi); }

create()

CompressedTile::Ptr CompressedTile::create ( int  depth, int  x, int  y, int  bpp, const Scroom::MemoryBlobs::PageProvider::Ptr &  provider, TileStateInternal  state = TSI_UNINITIALIZED  )

static

{
  CompressedTile::Ptr tile = CompressedTile::Ptr(new CompressedTile(depth, x, y, bpp, std::move(provider), state));
 
  return tile;
}

Referenced by Layer::Layer().

Here is the caller graph for this function:

do_load()

ConstTile::Ptr CompressedTile::do_load ( )

private

{
  bool didLoad = false;
 
  ConstTile::Ptr result;
  {
    boost::mutex::scoped_lock const lock(stateData);
    cleanupState();
    state = TSI_LOADING_SYNCHRONOUSLY;
  }
  {
    boost::mutex::scoped_lock const lock(tileData);
    result = constTile.lock(); // This ought to fail
    if(!result)
    {
      result = std::make_shared<ConstTile>(TILESIZE, TILESIZE, bpp, data->getConst());
      constTile = result;
      didLoad = true;
    }
  }
  {
    boost::mutex::scoped_lock const lock(stateData);
    cleanupState();
    state = TSI_NORMAL;
    if(didLoad)
    {
      notifyObservers(result);
    }
  }
 
  return result;
}

Referenced by getConstTileSync(), observerAdded(), and reportFinished().

Here is the call graph for this function:

Here is the caller graph for this function:

getConstTileAsync()

ConstTile::Ptr CompressedTile::getConstTileAsync

(

)

Get a reference to the ConstTile.

If the tile is currently TSI_LOADED, you'll get a reference, otherwise, you'll receive an empty reference.

{
  ConstTile::Ptr result = constTile.lock();
  return result;
}

getConstTileSync()

ConstTile::Ptr CompressedTile::getConstTileSync

(

)

Get a reference to the Const Tile.

If the tile is currently TSI_NORMAL, it will be loaded, if necessary. If the tile is TSI_UNINITIALIZED, you'll receive an empty reference.

{
  ConstTile::Ptr result = constTile.lock();
  if(!result)
  {
    result = do_load();
  }
 
  return result;
}

Referenced by getTileSync().

Here is the call graph for this function:

Here is the caller graph for this function:

getState()

TileState CompressedTile::getState

(

)

{
  TileState result = TILE_UNINITIALIZED;
  switch(state)
  {
  case TSI_NORMAL:
  {
    Tile::Ptr const t = tile.lock();
    if(t)
    {
      result = TILE_LOADED;
    }
    else
    {
      result = TILE_UNLOADED;
    }
  }
  break;
  case TSI_OUT_OF_BOUNDS:
    result = TILE_OUT_OF_BOUNDS;
    break;
  case TSI_LOADING_SYNCHRONOUSLY:
  case TSI_LOADING_ASYNCHRONOUSLY:
    result = TILE_UNLOADED;
    break;
  case TSI_UNINITIALIZED:
    result = TILE_UNINITIALIZED;
    break;
  }
  return result;
}

getTileSync()

Tile::Ptr CompressedTile::getTileSync

(

)

Get a reference to the Tile.

If the tile is currently TSI_NORMAL, it will be loaded, if necessary. If the tile is TSI_UNINITIALIZED, you'll receive an empty reference.

{
  Tile::Ptr result;
  {
    boost::mutex::scoped_lock const lock(tileData);
    result = tile.lock();
  }
  if(!result)
  {
    // Retrieve the const tile, such that all observers are properly
    // notified of the loading
    ConstTile::Ptr const temp = getConstTileSync();
    require(temp);
    {
      // Check again. Maybe someone else has beaten us to it...
      boost::mutex::scoped_lock const lock(tileData);
      result = tile.lock();
    }
    if(!result)
    {
      boost::mutex::scoped_lock const lock(tileData);
      result = std::make_shared<Tile>(TILESIZE, TILESIZE, bpp, data->get());
      tile = result;
    }
  }
 
  return result;
}

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

getViewState()

TileViewState::Ptr CompressedTile::getViewState

(

const ViewInterface::WeakPtr &

vi

)

{
  TileViewState::Ptr result = viewStates[vi].lock();
 
  if(!result)
  {
    result = TileViewState::create(shared_from_this<CompressedTile>());
    viewStates[vi] = result;
  }
 
  return result;
}

Here is the call graph for this function:

initialize()

Tile::Ptr CompressedTile::initialize

(

)

Initializes the tile data

Allocates memory, initializes it to 0, and changes state to TSI_LOADED

{
  Scroom::Utils::Stuff s;
  Tile::Ptr tile_;
 
  bool didInitialize = false;
  {
    boost::mutex::scoped_lock const stateLock(stateData);
    boost::mutex::scoped_lock const dataLock(tileData);
 
    if(state == TSI_UNINITIALIZED)
    {
      s = data->initialize(0);
      state = TSI_NORMAL;
      didInitialize = true;
    }
  }
 
  if(didInitialize)
  {
    tile_ = getTileSync(); // Trigger notifyObservers(), without holding the lock
  }
 
  return tile_;
}

Here is the call graph for this function:

notifyObservers()

void CompressedTile::notifyObservers ( const ConstTile::Ptr &  tile )

private

{
  for(const TileLoadingObserver::Ptr& observer: Observable<TileLoadingObserver>::getObservers())
  {
    observer->tileLoaded(tile_);
  }
}

Referenced by do_load().

Here is the call graph for this function:

Here is the caller graph for this function:

observerAdded() [1/2]

void CompressedTile::observerAdded ( TileInitialisationObserver::Ptr const &  observer, Scroom::Bookkeeping::Token const &  token  )

overrideprotected

Keep track of new TileInitialisationObserver registrations.

Upon registering an observer, you'll receive the TileInitialisationObserver::tileCreated() event immediately, on your thread. Be careful with your mutexes :-)

{
  observer->tileCreated(shared_from_this<CompressedTile>());
}

observerAdded() [2/2]

void CompressedTile::observerAdded ( TileLoadingObserver::Ptr const &  observer, Scroom::Bookkeeping::Token const &  token  )

overrideprotected

Keep track of new TileLoadingObserver registrations.

{
  ConstTile::Ptr const result = constTile.lock();
  ThreadPool::Queue::Ptr queue_ = queue.lock();
 
  if(!result)
  {
    boost::mutex::scoped_lock const lock(stateData);
    cleanupState();
    switch(state)
    {
    case TSI_UNINITIALIZED:
    case TSI_LOADING_ASYNCHRONOUSLY:
    case TSI_LOADING_SYNCHRONOUSLY:
      // Need to do nothing. All will be well.
      break;
 
    default:
    case TSI_OUT_OF_BOUNDS:
      // Shouldn't happen
      break;
 
    case TSI_NORMAL:
      // Start an asynchronous load
      if(!queue_)
      {
        queue_ = ThreadPool::Queue::create();
        queue = queue_;
      }
      CpuBound()->schedule([this] { do_load(); }, LOAD_PRIO, queue_);
      state = TSI_LOADING_ASYNCHRONOUSLY;
 
      break;
    }
  }
 
  // When the last observer goes away, cancel the load
  if(queue_)
  {
    token.add(queue_);
  }
 
  if(result)
  {
    observer->tileLoaded(result);
  }
}

Here is the call graph for this function:

open()

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

{
  // On open, we do nothing. On close, we destroy any resources related to the view.
}

registerObserver() [1/2]

Scroom::Bookkeeping::Token CompressedTile::registerObserver ( TileInitialisationObserver::WeakPtr const &  observer )

inline

  {
    return Scroom::Utils::Observable<TileInitialisationObserver>::registerObserver(observer);
  }

Here is the call graph for this function:

registerObserver() [2/2]

Scroom::Bookkeeping::Token CompressedTile::registerObserver ( TileLoadingObserver::WeakPtr const &  observer )

inline

  {
    return Scroom::Utils::Observable<TileLoadingObserver>::registerObserver(observer);
  }

Here is the call graph for this function:

registerStrongObserver() [1/2]

Scroom::Bookkeeping::Token CompressedTile::registerStrongObserver ( TileInitialisationObserver::Ptr const &  observer )

inline

  {
    return Scroom::Utils::Observable<TileInitialisationObserver>::registerStrongObserver(observer);
  }

Here is the call graph for this function:

registerStrongObserver() [2/2]

Scroom::Bookkeeping::Token CompressedTile::registerStrongObserver ( TileLoadingObserver::Ptr const &  observer )

inline

  {
    return Scroom::Utils::Observable<TileLoadingObserver>::registerStrongObserver(observer);
  }

Here is the call graph for this function:

reportFinished()

void CompressedTile::reportFinished

(

)

Report that the tile is completely filled with data

This will be used to notify our observers.

{
  CompressedTile::Ptr const me = shared_from_this<CompressedTile>();
  ConstTile::Ptr const t = do_load();
  for(const TileInitialisationObserver::Ptr& observer: Observable<TileInitialisationObserver>::getObservers())
  {
    observer->tileFinished(me);
  }
  for(const TileLoadingObserver::Ptr& observer: Observable<TileLoadingObserver>::getObservers())
  {
    observer->tileLoaded(t);
  }
}

Here is the call graph for this function:

Member Data Documentation

bpp

const int CompressedTile::bpp

Bits per pixel of this tile. Must be a divisor of 8.

Referenced by create(), do_load(), and getTileSync().

constTile

ConstTile::WeakPtr CompressedTile::constTile

private

Reference to the actual Tile

Referenced by do_load(), getConstTileAsync(), getConstTileSync(), and observerAdded().

data

Scroom::MemoryBlobs::Blob::Ptr CompressedTile::data

private

Data associated with the Tile

Referenced by do_load(), getTileSync(), and initialize().

depth

const int CompressedTile::depth

Layer number of this tile

Referenced by create().

provider

Scroom::MemoryBlobs::PageProvider::Ptr CompressedTile::provider

private

Provider of blocks of memory

Referenced by create().

queue

ThreadPool::Queue::WeakPtr CompressedTile::queue

private

Queue on which the load operation is executed

Referenced by cleanupState(), and observerAdded().

state

TileStateInternal CompressedTile::state

private

State of this tile

Referenced by cleanupState(), create(), do_load(), getState(), initialize(), and observerAdded().

stateData

boost::mutex CompressedTile::stateData

private

Mutex protecting the state field

Referenced by do_load(), initialize(), and observerAdded().

tile

Tile::WeakPtr CompressedTile::tile

private

Reference to the actual Tile

Referenced by create(), getState(), and getTileSync().

tileData

boost::mutex CompressedTile::tileData

private

Mutex protecting the data-related fields

Referenced by do_load(), getTileSync(), and initialize().

viewStates

Scroom::Utils::WeakKeyMap<ViewInterface::WeakPtr, std::weak_ptr<TileViewState> > CompressedTile::viewStates

private

Referenced by close(), and getViewState().

x

const int CompressedTile::x

x-coordinate of this tile (i.e. number of tiles to the left of this tile)

Referenced by create().

y

const int CompressedTile::y

y-coordinate of this tile (i.e. number of tiles above this tile)

Referenced by create().

---

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

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