TiledBitmapViewData Class Reference

#include <tiledbitmapviewdata.hh>

Inheritance diagram for TiledBitmapViewData:

Collaboration diagram for TiledBitmapViewData:

Public Types
using	Ptr = boost::shared_ptr< TiledBitmapViewData >
Public Types inherited from TileLoadingObserver
using	Ptr = boost::shared_ptr< TileLoadingObserver >
using	WeakPtr = boost::weak_ptr< TileLoadingObserver >
Public Types inherited from ProgressInterface
using	Ptr = boost::shared_ptr< ProgressInterface >
using	WeakPtr = boost::weak_ptr< ProgressInterface >

Public Member Functions
void	setNeededTiles (Layer::Ptr const &l, int imin, int imax, int jmin, int jmax, int zoom, LayerOperations::Ptr layerOperations)
void	resetNeededTiles ()
void	storeVolatileStuff (const Scroom::Utils::Stuff &stuff)
void	clearVolatileStuff ()
void	tileLoaded (ConstTile::Ptr tile) override
void	setIdle () override
void	setWaiting (double progress=0.0) override
void	setWorking (double progress) override
void	setFinished () 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 >
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 (const ViewInterface::WeakPtr &viewInterface)

Public Attributes
ViewInterface::WeakPtr	viewInterface
ProgressInterface::Ptr	progressInterface
Scroom::Bookkeeping::Token	token

Private Member Functions
	TiledBitmapViewData (const ViewInterface::WeakPtr &viewInterface)

Private Attributes
Layer::Ptr	layer
int	imin {0}
int	imax {0}
int	jmin {0}
int	jmax {0}
int	zoom {0}
LayerOperations::Ptr	layerOperations
Scroom::Utils::StuffList	stuff
Scroom::Utils::StuffList	volatileStuff
bool	redrawPending {false}
boost::mutex	mut

Member Typedef Documentation

Ptr

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

Constructor & Destructor Documentation

TiledBitmapViewData()

TiledBitmapViewData::TiledBitmapViewData ( const ViewInterface::WeakPtr &  viewInterface )

explicitprivate

  : viewInterface(viewInterface_)
  , progressInterface(viewInterface_.lock()->getProgressInterface())
 
{
}

Referenced by create().

Here is the caller graph for this function:

Member Function Documentation

clearVolatileStuff()

void TiledBitmapViewData::clearVolatileStuff

(

)

{
  std::list<boost::shared_ptr<void>> oldVolatileStuff;
  {
    boost::unique_lock<boost::mutex> const lock(mut);
    oldVolatileStuff.swap(volatileStuff);
  }
  // oldVolatileStuff gets erased here, without holding the lock. So
  // if anyone is calling storeVolatileStuff() as a side effect, they
  // can do so safely.
  oldVolatileStuff.clear();
  resetNeededTiles();
}

Here is the call graph for this function:

create()

TiledBitmapViewData::Ptr TiledBitmapViewData::create ( const ViewInterface::WeakPtr &  viewInterface )

static

{
  return TiledBitmapViewData::Ptr(new TiledBitmapViewData(std::move(viewInterface)));
}

Referenced by TiledBitmap::open().

Here is the call graph for this function:

Here is the caller graph for this function:

resetNeededTiles()

void TiledBitmapViewData::resetNeededTiles

(

)

{
  boost::unique_lock<boost::mutex> lock(mut);
 
  // If we just cleared out oldStuff, old tiles would be unloaded, and
  // we might still need them. So create a backup to throw away later
  std::list<boost::shared_ptr<void>> oldStuff;
  oldStuff.swap(stuff);
  std::list<boost::shared_ptr<void>> oldVolatileStuff;
  oldVolatileStuff.swap(volatileStuff);
 
  lock.unlock();
  // The stuff list contains both registrations and references to needed tiles.
  // Registering an observer can result in tileLoaded() being called immediately
  // if the tile was already loaded. Hence, we cannot hold the lock while registering
  // observers.
 
  std::list<boost::shared_ptr<void>> newStuff;
  // If we don't hold the lock, we cannot add to the stuff list directly. Hence,
  // temporarily add registrations to the newStuff list, and add the newStuff to
  // stuff later.
 
  for(int i = imin; i < imax; i++)
  {
    for(int j = jmin; j < jmax; j++)
    {
      CompressedTile::Ptr const tile = layer->getTile(i, j);
 
      TileViewState::Ptr const tileViewState = tile->getViewState(viewInterface);
      tileViewState->setViewData(shared_from_this<TiledBitmapViewData>());
      tileViewState->setZoom(layerOperations, zoom);
      newStuff.emplace_back(tileViewState);
      newStuff.emplace_back(tileViewState->registerObserver(shared_from_this<TiledBitmapViewData>()));
    }
  }
 
  // At this point, everything we need is either in the stuff list, or the newStuff list.
  // Hence, this is an excellent time to clear the oldStuff list. We cannot clear the
  // oldStuff list while holding the lock, because that would result in deadlock (see
  // ticket #35)
  oldStuff.clear();
  oldVolatileStuff.clear();
 
  // Re-acquire the lock
  lock.lock();
  stuff.splice(stuff.end(), newStuff, newStuff.begin(), newStuff.end());
}

Referenced by clearVolatileStuff(), and setNeededTiles().

Here is the caller graph for this function:

setFinished()

void TiledBitmapViewData::setFinished ( )

overridevirtual

Implements ProgressInterface.

{ progressInterface->setFinished(); }

setIdle()

void TiledBitmapViewData::setIdle ( )

overridevirtual

Implements ProgressInterface.

{ progressInterface->setIdle(); }

setNeededTiles()

void TiledBitmapViewData::setNeededTiles	(	Layer::Ptr const &	l,
		int	imin,
		int	imax,
		int	jmin,
		int	jmax,
		int	zoom,
		LayerOperations::Ptr	layerOperations
	)

{
  boost::unique_lock<boost::mutex> lock(mut);
 
  if(layer == l && imin <= imin_ && imax >= imax_ && jmin <= jmin_ && jmax >= jmax_ && zoom == zoom_)
  {
    // Nothing to do...
  }
  else
  {
    layer           = l;
    imin            = imin_;
    imax            = imax_;
    jmin            = jmin_;
    jmax            = jmax_;
    zoom            = zoom_;
    layerOperations = std::move(layerOperations_);
 
    // Get data for new tiles
    redrawPending = true; // if it isn't already
    lock.unlock();
    resetNeededTiles();
    lock.lock();
  }
  redrawPending = false;
}

Here is the call graph for this function:

setWaiting()

void TiledBitmapViewData::setWaiting ( double  progress = 0.0 )

overridevirtual

Implements ProgressInterface.

{ progressInterface->setWaiting(progress); }

setWorking()

void TiledBitmapViewData::setWorking ( double  progress )

overridevirtual

Implements ProgressInterface.

{ progressInterface->setWorking(progress); }

storeVolatileStuff()

void TiledBitmapViewData::storeVolatileStuff

(

const Scroom::Utils::Stuff &

stuff

)

{
  boost::unique_lock<boost::mutex> const lock(mut);
  volatileStuff.push_back(stuff_);
}

tileLoaded()

void TiledBitmapViewData::tileLoaded ( ConstTile::Ptr  tile )

overridevirtual

The Tile has been loaded.

Implements TileLoadingObserver.

{
  boost::unique_lock<boost::mutex> const lock(mut);
  stuff.emplace_back(tile);
 
  if(!redrawPending)
  {
    // We're not sure about whether gdk_threads_enter() has been
    // called or not, so we have no choice but to invalidate on
    // another thread.
    Scroom::GtkHelpers::async_on_ui_thread([=] { invalidate_view(viewInterface); });
    redrawPending = true;
  }
}

Here is the call graph for this function:

Member Data Documentation

imax

int TiledBitmapViewData::imax {0}

private

Referenced by resetNeededTiles(), and setNeededTiles().

imin

int TiledBitmapViewData::imin {0}

private

Referenced by resetNeededTiles(), and setNeededTiles().

jmax

int TiledBitmapViewData::jmax {0}

private

Referenced by resetNeededTiles(), and setNeededTiles().

jmin

int TiledBitmapViewData::jmin {0}

private

Referenced by resetNeededTiles(), and setNeededTiles().

layer

Layer::Ptr TiledBitmapViewData::layer

private

Referenced by resetNeededTiles(), and setNeededTiles().

layerOperations

LayerOperations::Ptr TiledBitmapViewData::layerOperations

private

Referenced by resetNeededTiles(), and setNeededTiles().

mut

boost::mutex TiledBitmapViewData::mut

private

Protect stuff and redrawPending

Referenced by clearVolatileStuff(), resetNeededTiles(), setNeededTiles(), storeVolatileStuff(), and tileLoaded().

progressInterface

ProgressInterface::Ptr TiledBitmapViewData::progressInterface

Referenced by setFinished(), setIdle(), setWaiting(), and setWorking().

redrawPending

bool TiledBitmapViewData::redrawPending {false}

private

Referenced by setNeededTiles(), and tileLoaded().

stuff

Scroom::Utils::StuffList TiledBitmapViewData::stuff

private

References to things we want to keep around.

This includes

• observer registrations
• tiles that have been loaded

Referenced by resetNeededTiles(), and tileLoaded().

token

Scroom::Bookkeeping::Token TiledBitmapViewData::token

viewInterface

ViewInterface::WeakPtr TiledBitmapViewData::viewInterface

Referenced by create(), resetNeededTiles(), and tileLoaded().

volatileStuff

Scroom::Utils::StuffList TiledBitmapViewData::volatileStuff

private

References to things the user should be able to throw away on request

This includes

• pre-drawn bitmaps to make redraws go faster

Referenced by clearVolatileStuff(), resetNeededTiles(), and storeVolatileStuff().

zoom

int TiledBitmapViewData::zoom {0}

private

Referenced by resetNeededTiles(), and setNeededTiles().

---

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

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