TransparentOverlayViewInfo Class Reference

#include <transparentoverlayviewinfo.hh>

Inheritance diagram for TransparentOverlayViewInfo:

Collaboration diagram for TransparentOverlayViewInfo:

Public Types
using	Ptr = boost::shared_ptr< TransparentOverlayViewInfo >

Public Member Functions
void	addChildren (const std::list< PresentationInterface::Ptr > &children)
void	addChild (const PresentationInterface::Ptr &child)
PresentationInterface::Ptr	getChild (const ChildView::Ptr &cv)
void	close ()
void	redraw (cairo_t *cr, Scroom::Utils::Rectangle< double > const &presentationArea, int zoom)
void	invalidate ()
ProgressInterface::Ptr	getProgressInterface ()
void	toggled (GtkToggleButton *button)
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 &vi, SizeDeterminer::Ptr const &sizeDeterminer)

Private Types
using	ChildMap = std::map< PresentationInterface::Ptr, ChildView::Ptr >

Private Member Functions
	TransparentOverlayViewInfo (const ViewInterface::WeakPtr &vi, SizeDeterminer::Ptr sizeDeterminer)
void	createToggleToolButton (PresentationInterface::Ptr const &p)

Private Attributes
ViewInterface::Ptr	parentView
ChildMap	childViews
Scroom::Utils::ProgressInterfaceMultiplexer::Ptr	progressInterfaceMultiplexer
std::vector< GtkWidget * >	buttons
std::vector< PresentationInterface::Ptr >	children
SizeDeterminer::Ptr	sizeDeterminer

Member Typedef Documentation

ChildMap

using TransparentOverlayViewInfo::ChildMap = std::map<PresentationInterface::Ptr, ChildView::Ptr>

private

Ptr

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

Constructor & Destructor Documentation

TransparentOverlayViewInfo()

TransparentOverlayViewInfo::TransparentOverlayViewInfo ( const ViewInterface::WeakPtr &  vi, SizeDeterminer::Ptr  sizeDeterminer  )

private

  : parentView(vi)
  , progressInterfaceMultiplexer(Scroom::Utils::ProgressInterfaceMultiplexer::create(parentView->getProgressInterface()))
  , sizeDeterminer(std::move(sizeDeterminer_))
{
}

Referenced by create().

Here is the caller graph for this function:

Member Function Documentation

addChild()

void TransparentOverlayViewInfo::addChild

(

const PresentationInterface::Ptr &

child

)

{
  ChildView::Ptr const view = ChildView::create(shared_from_this<TransparentOverlayViewInfo>());
  childViews[child]         = view;
  child->open(view);
  sizeDeterminer->open(child, view);
  children.push_back(child);
  createToggleToolButton(child);
}

Referenced by addChildren().

Here is the call graph for this function:

Here is the caller graph for this function:

addChildren()

void TransparentOverlayViewInfo::addChildren

(

const std::list< PresentationInterface::Ptr > &

children

)

{
  for(PresentationInterface::Ptr const& child: children_)
  {
    addChild(child);
  }
}

Here is the call graph for this function:

close()

void TransparentOverlayViewInfo::close

(

)

{
  for(ChildMap::value_type const& v: childViews)
  {
    sizeDeterminer->close(v.first, v.second);
    v.first->close(v.second);
  }
 
  childViews.clear();
  children.clear();
  buttons.clear();
}

create()

TransparentOverlayViewInfo::Ptr TransparentOverlayViewInfo::create ( const ViewInterface::WeakPtr &  vi, SizeDeterminer::Ptr const &  sizeDeterminer  )

static

{
  return Ptr(new TransparentOverlayViewInfo(vi, sizeDeterminer));
}

Referenced by TransparentOverlayPresentation::viewAdded().

Here is the call graph for this function:

Here is the caller graph for this function:

createToggleToolButton()

void TransparentOverlayViewInfo::createToggleToolButton ( PresentationInterface::Ptr const &  p )

private

{
  const int         n = buttons.size() + 1;
  std::stringstream s;
  s << "_" << n;
 
  GtkToolItem* button       = gtk_tool_item_new();
  GtkWidget*   toggleButton = gtk_toggle_button_new_with_mnemonic(s.str().c_str());
  setToggleButtonColor(toggleButton, p);
  gtk_widget_set_visible(toggleButton, true);
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggleButton), true);
 
  gtk_container_add(GTK_CONTAINER(button), toggleButton);
  g_signal_connect(static_cast<gpointer>(toggleButton), "toggled", G_CALLBACK(on_toggled), this);
 
  buttons.push_back(toggleButton);
 
  parentView->addToToolbar(button);
}

Referenced by addChild().

Here is the call graph for this function:

Here is the caller graph for this function:

getChild()

PresentationInterface::Ptr TransparentOverlayViewInfo::getChild

(

const ChildView::Ptr &

cv

)

{
  for(ChildMap::value_type const& v: childViews)
  {
    if(v.second == cv)
    {
      return v.first;
    }
  }
  return {};
}

getProgressInterface()

ProgressInterface::Ptr TransparentOverlayViewInfo::getProgressInterface ( )

inline

{ return progressInterfaceMultiplexer->createProgressInterface(); }

invalidate()

void TransparentOverlayViewInfo::invalidate ( )

inline

{ parentView->invalidate(); }

Referenced by toggled().

Here is the caller graph for this function:

redraw()

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

{
  using Scroom::Bitmap::BitmapSurface;
 
  cairo_rectangle_int_t const presentationArea = pa.toGdkRectangle();
 
  cairo_rectangle_int_t viewArea;
  viewArea.x = 0;
  viewArea.y = 0;
 
  if(zoom > 0)
  {
    const int pixelSize = 1 << zoom;
    viewArea.width      = presentationArea.width * pixelSize;
    viewArea.height     = presentationArea.height * pixelSize;
  }
  else
  {
    const int pixelSize = 1 << -zoom;
    viewArea.width      = presentationArea.width / pixelSize;
    viewArea.height     = presentationArea.height / pixelSize;
  }
 
  BitmapSurface::Ptr const s       = BitmapSurface::create(viewArea.width, viewArea.height, CAIRO_FORMAT_ARGB32);
  cairo_surface_t*         surface = s->get();
  cairo_t*                 cr_sub  = cairo_create(surface);
 
  int count = 0;
 
  for(size_t i = 0; i < children.size(); i++)
  {
    if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(buttons[i])))
    {
      PresentationInterface::Ptr const& p = children[i];
 
      Colormappable::Ptr const c                        = boost::dynamic_pointer_cast<Colormappable>(p);
      bool                     hasTransparentBackground = false;
      if(c && p->isPropertyDefined(TRANSPARENT_BACKGROUND_PROPERTY_NAME))
      {
        if(count == 0)
        {
          c->disableTransparentBackground();
        }
        else
        {
          c->setTransparentBackground();
          hasTransparentBackground = true;
        }
      }
 
      cairo_save(cr_sub);
      cairo_set_operator(cr_sub, CAIRO_OPERATOR_CLEAR);
      cairo_paint(cr_sub);
      cairo_restore(cr_sub);
 
      cairo_save(cr_sub);
      p->redraw(childViews[p], cr_sub, pa, zoom);
      cairo_restore(cr_sub);
 
      cairo_set_source_surface(cr, surface, 0, 0);
 
      if(hasTransparentBackground)
      {
        cairo_paint(cr);
      }
      else
      {
        cairo_paint_with_alpha(cr, 1.0 / (count + 1));
      }
 
      if(!hasTransparentBackground)
      {
        count++;
      }
    }
  }
 
  cairo_destroy(cr_sub);
}

Here is the call graph for this function:

toggled()

void TransparentOverlayViewInfo::toggled

(

GtkToggleButton *

button

)

{ invalidate(); }

Here is the call graph for this function:

Member Data Documentation

buttons

std::vector<GtkWidget*> TransparentOverlayViewInfo::buttons

private

Referenced by close(), createToggleToolButton(), and redraw().

children

std::vector<PresentationInterface::Ptr> TransparentOverlayViewInfo::children

private

Referenced by addChild(), close(), and redraw().

childViews

ChildMap TransparentOverlayViewInfo::childViews

private

Referenced by addChild(), close(), getChild(), and redraw().

parentView

ViewInterface::Ptr TransparentOverlayViewInfo::parentView

private

Referenced by createToggleToolButton(), and invalidate().

progressInterfaceMultiplexer

Scroom::Utils::ProgressInterfaceMultiplexer::Ptr TransparentOverlayViewInfo::progressInterfaceMultiplexer

private

Referenced by getProgressInterface().

sizeDeterminer

SizeDeterminer::Ptr TransparentOverlayViewInfo::sizeDeterminer

private

Referenced by addChild(), close(), and create().

---

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

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