TransparentOverlayPresentation Class Reference

#include <transparentoverlaypresentation.hh>

Inheritance diagram for TransparentOverlayPresentation:

Collaboration diagram for TransparentOverlayPresentation:

Public Types
using	Ptr = std::shared_ptr< TransparentOverlayPresentation >
Public Types inherited from PresentationInterface
using	Ptr = std::shared_ptr< PresentationInterface >
using	WeakPtr = std::weak_ptr< PresentationInterface >
Public Types inherited from Viewable
using	Ptr = std::shared_ptr< Viewable >
using	WeakPtr = std::weak_ptr< Viewable >
Public Types inherited from Scroom::Utils::Observable< T >
using	Observer = std::shared_ptr< T >
using	Ptr = std::shared_ptr< Observable< T > >
Public Types inherited from Aggregate
using	Ptr = std::shared_ptr< Aggregate >

Public Member Functions
Scroom::Utils::Rectangle< double >	getRect () override
void	redraw (ViewInterface::Ptr const &vi, cairo_t *cr, Scroom::Utils::Rectangle< double > presentationArea, int zoom) override
bool	getProperty (const std::string &name, std::string &value) override
bool	isPropertyDefined (const std::string &name) override
std::string	getTitle () override
void	viewAdded (ViewInterface::WeakPtr vi) override
void	viewRemoved (ViewInterface::WeakPtr vi) override
Scroom::Utils::WeakKeySet< ViewInterface::WeakPtr >	getViews () override
void	addPresentation (PresentationInterface::Ptr const &p) override
Scroom::Utils::Context::ConstPtr	getContext () const override
Public Member Functions inherited from PresentationBase
void	open (ViewInterface::WeakPtr vi) override
void	close (ViewInterface::WeakPtr vi) override
Public Member Functions inherited from Scroom::Utils::Observable< T >
	Observable ()
	~Observable () override
	Observable (const Observable &)=delete
	Observable (Observable &&)=delete
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

Static Public Member Functions
static Ptr	create ()

Private Types
using	ViewDataMap = Scroom::Utils::WeakKeyMap< ViewInterface::WeakPtr, TransparentOverlayViewInfo::Ptr >

Private Member Functions
	TransparentOverlayPresentation ()
void	setOptimalColor (PresentationInterface::Ptr const &p)

Private Attributes
std::list< PresentationInterface::Ptr >	children
SizeDeterminer::Ptr	sizeDeterminer
ViewDataMap	viewData
Scroom::Utils::RecursiveContext::Ptr	context

Additional Inherited Members
Protected Member Functions inherited from PresentationBase
void	observerAdded (Viewable::Ptr const &viewable, Scroom::Bookkeeping::Token const &t) override
Protected Member Functions inherited from Scroom::Utils::Observable< T >
std::list< Observer >	getObservers ()
virtual void	observerAdded (Observer const &observer, Scroom::Bookkeeping::Token const &token)

Member Typedef Documentation

Ptr

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

ViewDataMap

using TransparentOverlayPresentation::ViewDataMap = Scroom::Utils::WeakKeyMap<ViewInterface::WeakPtr, TransparentOverlayViewInfo::Ptr>

private

Constructor & Destructor Documentation

TransparentOverlayPresentation()

TransparentOverlayPresentation::TransparentOverlayPresentation ( )

private

  : sizeDeterminer(SizeDeterminer::create())
  , context(Scroom::Utils::RecursiveContext::create())
{
}

Referenced by create().

Here is the caller graph for this function:

Member Function Documentation

addPresentation()

void TransparentOverlayPresentation::addPresentation ( PresentationInterface::Ptr const &  p )

overridevirtual

Implements Aggregate.

{
  if(p)
  {
    context->add(p->getContext());
 
    if(p->isPropertyDefined(MONOCHROME_COLORMAPPABLE_PROPERTY_NAME))
    {
      setOptimalColor(p);
    }
 
    children.push_back(p);
    sizeDeterminer->add(p);
 
    for(ViewDataMap::value_type const& v: viewData)
    {
      v.second->addChild(p);
    }
  }
  else
  {
    defect_message("Can't add a nonexistent presentation");
  }
}

Here is the call graph for this function:

create()

TransparentOverlayPresentation::Ptr TransparentOverlayPresentation::create ( )

static

{ return Ptr(new TransparentOverlayPresentation()); }

Referenced by TransparentOverlay::createNew().

Here is the call graph for this function:

Here is the caller graph for this function:

getContext()

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

overridevirtual

Implements PresentationInterface.

{ return context; }

getProperty()

bool TransparentOverlayPresentation::getProperty ( const std::string &  name, std::string &  value  )

overridevirtual

Return the value of the requested property

Parameters

[in]	name	The name of the requested property
[out]	value	The value of the requested property

Return values

true	if the property existed
false	if the property didn't exist

Implements PresentationInterface.

{ return false; }

getRect()

Scroom::Utils::Rectangle< double > TransparentOverlayPresentation::getRect ( )

overridevirtual

Return the dimensions of your presentation

Implements PresentationInterface.

{ return sizeDeterminer->getRect(); }

getTitle()

std::string TransparentOverlayPresentation::getTitle ( )

overridevirtual

Return the title of the presentation

Implements PresentationInterface.

{
  std::stringstream s;
  s << "Overlay(";
  bool hasPrevious = false;
  for(PresentationInterface::Ptr const& child: children)
  {
    if(hasPrevious)
    {
      s << ", ";
    }
    s << child->getTitle();
    hasPrevious = true;
  }
  s << ")";
 
  return s.str();
}

getViews()

Scroom::Utils::WeakKeySet< ViewInterface::WeakPtr > TransparentOverlayPresentation::getViews ( )

overridevirtual

Implements PresentationBase.

{
  Scroom::Utils::WeakKeySet<ViewInterface::WeakPtr> result;
  for(auto const& p: viewData)
  {
    result.insert(p.first);
  }
 
  return result;
}

isPropertyDefined()

bool TransparentOverlayPresentation::isPropertyDefined ( const std::string &  name )

overridevirtual

Return true if the named property exists

Implements PresentationInterface.

{ return false; }

redraw()

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

overridevirtual

Draw the requested ara at the requested zoom level

Parameters

vi	The ViewInterface on whose behalf the request is made
cr	The context to draw the area on
presentationArea	the area that is to be drawn. The given x and y coordinates should map on 0,0 of the given context cr.
zoom	The requested zoom level. One pixel of your presentation should have size 2**zoom when drawn. zoom may be negative.

Implements PresentationInterface.

{
  auto e = viewData.find(vi);
  if(e != viewData.end())
  {
    e->second->redraw(cr, presentationArea, zoom);
  }
}

setOptimalColor()

void TransparentOverlayPresentation::setOptimalColor ( PresentationInterface::Ptr const &  p )

private

{
  Colormappable::Ptr const c = std::dynamic_pointer_cast<Colormappable>(p);
  if(c)
  {
    std::map<Color, int, ColorComparer> currentColors;
    for(PresentationInterface::Ptr const& child: children)
    {
      Colormappable::Ptr const cChild = std::dynamic_pointer_cast<Colormappable>(child);
      if(cChild && child->isPropertyDefined(MONOCHROME_COLORMAPPABLE_PROPERTY_NAME))
      {
        currentColors[cChild->getMonochromeColor()]++;
      }
    }
 
    Color minimumColor = c->getMonochromeColor();
    int minimumColorValue = currentColors[minimumColor];
 
    for(Color const& color: colors)
    {
      if(currentColors[color] < minimumColorValue)
      {
        minimumColor = color;
        minimumColorValue = currentColors[color];
      }
    }
 
    c->setMonochromeColor(minimumColor);
  }
}

Referenced by addPresentation().

Here is the caller graph for this function:

viewAdded()

void TransparentOverlayPresentation::viewAdded ( ViewInterface::WeakPtr  vi )

overridevirtual

Implements PresentationBase.

{
  TransparentOverlayViewInfo::Ptr const tovi = TransparentOverlayViewInfo::create(vi, sizeDeterminer);
  tovi->addChildren(children);
  viewData[vi] = tovi;
}

Here is the call graph for this function:

viewRemoved()

void TransparentOverlayPresentation::viewRemoved ( ViewInterface::WeakPtr  vi )

overridevirtual

Implements PresentationBase.

{
  auto e = viewData.find(vi);
  if(e != viewData.end())
  {
    e->second->close();
    viewData.erase(e->first);
  }
}

Member Data Documentation

children

std::list<PresentationInterface::Ptr> TransparentOverlayPresentation::children

private

Referenced by addPresentation(), getTitle(), setOptimalColor(), and viewAdded().

context

Scroom::Utils::RecursiveContext::Ptr TransparentOverlayPresentation::context

private

Referenced by addPresentation(), and getContext().

sizeDeterminer

SizeDeterminer::Ptr TransparentOverlayPresentation::sizeDeterminer

private

Referenced by addPresentation(), getRect(), and viewAdded().

viewData

ViewDataMap TransparentOverlayPresentation::viewData

private

Referenced by addPresentation(), getViews(), redraw(), viewAdded(), and viewRemoved().

---

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

• plugins/transparent-overlay/src/transparentoverlaypresentation.hh
• plugins/transparent-overlay/src/transparentoverlaypresentation.cc