PipetteHandler Class Reference

#include <pipette.hh>

Inheritance diagram for PipetteHandler:

Collaboration diagram for PipetteHandler:

Public Types
using	Ptr = boost::shared_ptr< PipetteHandler >
Public Types inherited from ToolStateListener
using	Ptr = boost::shared_ptr< ToolStateListener >
Public Types inherited from PostRenderer
using	Ptr = boost::shared_ptr< PostRenderer >
Public Types inherited from SelectionListener
using	Ptr = boost::shared_ptr< SelectionListener >

Public Member Functions
void	render (ViewInterface::Ptr const &vi, cairo_t *cr, Scroom::Utils::Rectangle< double > presentationArea, int zoom) override
std::string	getSelectionType () override
void	onSelectionStart (Selection p, ViewInterface::Ptr view) override
void	onSelectionUpdate (Selection s, ViewInterface::Ptr view) override
void	onSelectionEnd (Selection s, ViewInterface::Ptr view) override
void	onEnable () override
void	onDisable () override
virtual void	computeValues (const ViewInterface::Ptr &view, Scroom::Utils::Rectangle< double > sel_rect)
virtual void	displayValues (const ViewInterface::Ptr &view, Scroom::Utils::Rectangle< double > rect, const PipetteLayerOperations::PipetteColor &colors)
std::optional< Selection >	getSelection () const
bool	isEnabled () const
Public Member Functions inherited from PostRenderer
virtual void	render (boost::shared_ptr< ViewInterface > const &vi, cairo_t *cr, Scroom::Utils::Rectangle< double > presentationArea, int zoom)=0
Public Member Functions inherited from SelectionListener
virtual void	onSelectionStart (Selection selection, boost::shared_ptr< ViewInterface > view)=0
virtual void	onSelectionUpdate (Selection selection, boost::shared_ptr< ViewInterface > view)=0
virtual void	onSelectionEnd (Selection selection, boost::shared_ptr< ViewInterface > view)=0
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 ()

Private Attributes
std::optional< Selection >	selection
bool	enabled {false}
std::atomic_flag	wasDisabled = ATOMIC_FLAG_INIT
std::mutex	jobMutex
ThreadPool::Queue::Ptr	currentJob {ThreadPool::Queue::createAsync()}

Member Typedef Documentation

Ptr

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

Member Function Documentation

computeValues()

void PipetteHandler::computeValues ( const ViewInterface::Ptr &  view, Scroom::Utils::Rectangle< double >  sel_rect  )

virtual

{
  jobMutex.lock();
 
  Scroom::GtkHelpers::sync_on_ui_thread([=] { view->setStatusMessage("Computing color values..."); });
 
  // Get the average color within the rectangle
  PresentationInterface::Ptr const presentation = view->getCurrentPresentation();
  auto                             pipette      = boost::dynamic_pointer_cast<PipetteViewInterface>(presentation);
  if(pipette == nullptr || !presentation->isPropertyDefined(PIPETTE_PROPERTY_NAME))
  {
    spdlog::error("Presentation does not implement PipetteViewInterface!");
    Scroom::GtkHelpers::sync_on_ui_thread([=] { view->setStatusMessage("Pipette is not supported for this presentation."); });
    jobMutex.unlock();
    return;
  }
  auto image  = presentation->getRect();
  auto rect   = sel_rect.intersection(image);
  auto colors = pipette->getPixelAverages(rect);
 
  const auto display_rect = roundOutward(rect / presentation->getAspectRatio());
 
  // If the plugin was switched off ignore the result
  if(!wasDisabled.test_and_set())
  {
    displayValues(view, display_rect, colors);
  }
 
  wasDisabled.clear();
  jobMutex.unlock();
}

Here is the call graph for this function:

create()

PipetteHandler::Ptr PipetteHandler::create ( )

static

{ return Ptr(new PipetteHandler()); }

Referenced by BOOST_AUTO_TEST_CASE(), and Pipette::viewAdded().

Here is the caller graph for this function:

displayValues()

void PipetteHandler::displayValues ( const ViewInterface::Ptr &  view, Scroom::Utils::Rectangle< double >  rect, const PipetteLayerOperations::PipetteColor &  colors  )

virtual

{
  std::stringstream info;
 
  info << fmt::format("Top-left: {}, Bottom-right: {}, Height: {}, Width: {}",
                      rect.getTopLeft(),
                      rect.getBottomRight(),
                      rect.getHeight(),
                      rect.getWidth());
 
  if(!colors.empty())
  {
    info << ", Colors:";
    for(const auto& [name, value]: colors)
    {
      info << fmt::format(" {}: {:.2f}", name, value);
    }
  }
 
  Scroom::GtkHelpers::sync_on_ui_thread([view, status = info.str()] { view->setStatusMessage(status); });
}

Referenced by computeValues().

Here is the call graph for this function:

Here is the caller graph for this function:

getSelection()

std::optional<Selection> PipetteHandler::getSelection ( ) const

inline

{ return selection; }

getSelectionType()

std::string PipetteHandler::getSelectionType ( )

overridevirtual

Reimplemented from SelectionListener.

{ return SelectionType::PIXEL; }

Here is the call graph for this function:

isEnabled()

bool PipetteHandler::isEnabled ( ) const

inline

{ return enabled; }

onDisable()

void PipetteHandler::onDisable ( )

overridevirtual

Then function is called whenever the tool button is deselected.

Implements ToolStateListener.

{
  selection.reset();
  enabled = false;
  wasDisabled.test_and_set();
}

onEnable()

void PipetteHandler::onEnable ( )

overridevirtual

This function is called whenever the tool button is selected.

Implements ToolStateListener.

{
  enabled = true;
  if(jobMutex.try_lock())
  {
    wasDisabled.clear();
    jobMutex.unlock();
  }
}

onSelectionEnd()

void PipetteHandler::onSelectionEnd ( Selection  s, ViewInterface::Ptr  view  )

override

{
  if(enabled && jobMutex.try_lock())
  {
    selection = s;
 
    // Get the selection rectangle
    const auto sel_rect = Scroom::Utils::make_rect_from_start_end(selection->start, selection->end);
    Sequentially()->schedule([me = shared_from_this<PipetteHandler>(), view, sel_rect] { me->computeValues(view, sel_rect); },
                             currentJob);
    jobMutex.unlock();
  }
}

Here is the call graph for this function:

onSelectionStart()

void PipetteHandler::onSelectionStart ( Selection  p, ViewInterface::Ptr  view  )

override

{}

onSelectionUpdate()

void PipetteHandler::onSelectionUpdate ( Selection  s, ViewInterface::Ptr  view  )

override

{
  UNUSED(view);
  if(enabled && jobMutex.try_lock())
  {
    selection = s;
    jobMutex.unlock();
  }
}

render()

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

override

{
  if(selection)
  {
    const auto pixelSize = pixelSizeFromZoom(zoom);
    const auto start     = (selection->start - presentationArea.getTopLeft()) * pixelSize;
    const auto end       = (selection->end - presentationArea.getTopLeft()) * pixelSize;
 
    cairo_set_line_width(cr, 1);
    cairo_set_source_rgb(cr, 0, 0, 1); // Blue
    cairo_move_to(cr, end.x, start.y);
    cairo_line_to(cr, start.x, start.y);
    cairo_line_to(cr, start.x, end.y);
    cairo_line_to(cr, end.x, end.y);
    cairo_line_to(cr, end.x, start.y);
    cairo_stroke(cr);
  }
}

Here is the call graph for this function:

Member Data Documentation

currentJob

ThreadPool::Queue::Ptr PipetteHandler::currentJob {ThreadPool::Queue::createAsync()}

private

Referenced by onSelectionEnd().

enabled

bool PipetteHandler::enabled {false}

private

Referenced by isEnabled(), onDisable(), onEnable(), onSelectionEnd(), and onSelectionUpdate().

jobMutex

std::mutex PipetteHandler::jobMutex

private

Referenced by computeValues(), onEnable(), onSelectionEnd(), and onSelectionUpdate().

selection

std::optional<Selection> PipetteHandler::selection

private

Referenced by getSelection(), onDisable(), onSelectionEnd(), onSelectionUpdate(), and render().

wasDisabled

std::atomic_flag PipetteHandler::wasDisabled = ATOMIC_FLAG_INIT

private

Referenced by computeValues(), onDisable(), and onEnable().

---

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

• plugins/pipette/src/pipette.hh
• plugins/pipette/src/pipette.cc