PipetteHandler Class Reference

#include <pipette.hh>

Inheritance diagram for PipetteHandler:

Collaboration diagram for PipetteHandler:

Public Types
using	Ptr = std::shared_ptr< PipetteHandler >
Public Types inherited from ToolStateListener
using	Ptr = std::shared_ptr< ToolStateListener >
Public Types inherited from PostRenderer
using	Ptr = std::shared_ptr< PostRenderer >
Public Types inherited from SelectionListener
using	Ptr = std::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 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 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()}
Scroom::Logger	logger

Member Typedef Documentation

Ptr

using PipetteHandler::Ptr = std::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 = std::dynamic_pointer_cast<PipetteViewInterface>(presentation);
  if(pipette == nullptr || !presentation->isPropertyDefined(PIPETTE_PROPERTY_NAME))
  {
    logger->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 / getAspectRatio(presentation));
 
  // 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 std::make_shared<PipetteHandler>(); }

Referenced by 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  selection, ViewInterface::Ptr  view  )

overridevirtual

This function is called whenever the selection ends. That is, whenever the user releases the mouse button that was pressed.

The final selection is passed as an argument.

See also

Selection

Implements SelectionListener.

{
  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  selection, ViewInterface::Ptr  view  )

overridevirtual

This function is called whenever the user clicks a view. The point that is clicked is passed as an argument.

The passed point is a point in the presentation coordinate space.

Implements SelectionListener.

{}

onSelectionUpdate()

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

overridevirtual

This function is called whenever the selection updates. That is, whenever the user moves the mouse while keeping the mouse button pressed.

The updated selection is passed as an argument.

See also

Selection

Implements SelectionListener.

{
  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  )

overridevirtual

This function is called after the presentation finishes redrawing.

Parameters

vi	The ViewInterface on whose behalf the request is made
cr	The context to with, the origin of the context is translated to be the same as the origin of the presentation.
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 should have size 2**zoom when drawn. zoom may be negative.

Implements PostRenderer.

{
  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

{ThreadPool::Queue::createAsync()};

Referenced by onSelectionEnd().

enabled

bool PipetteHandler::enabled {false}

private

{false};

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

jobMutex

std::mutex PipetteHandler::jobMutex

private

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

logger

Scroom::Logger PipetteHandler::logger

private

Referenced by computeValues().

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