MeasureHandler Class Reference

#include <measure.hh>

Inheritance diagram for MeasureHandler:

Collaboration diagram for MeasureHandler:

Public Types
using	Ptr = boost::shared_ptr< MeasureHandler >
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
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
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 std::string	getSelectionType ()
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 Member Functions
virtual void	displayMeasurement (const ViewInterface::Ptr &view)
virtual void	drawCross (cairo_t *cr, Scroom::Utils::Point< double > p)

Private Attributes
std::optional< Selection >	selection
bool	enabled {false}

Member Typedef Documentation

Ptr

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

Member Function Documentation

create()

MeasureHandler::Ptr MeasureHandler::create ( )

static

{ return Ptr(new MeasureHandler()); }

Referenced by Measure::viewAdded().

Here is the caller graph for this function:

displayMeasurement()

void MeasureHandler::displayMeasurement ( const ViewInterface::Ptr &  view )

privatevirtual

{
  const auto      aspectRatio = view->getCurrentPresentation()->getAspectRatio();
  const Selection tweaked(selection->start / aspectRatio, selection->end / aspectRatio);
 
  view->setStatusMessage(fmt::format("l: {:.1f}, dx: {}, dy: {}, from: {}, to: {}",
                                     tweaked.length(),
                                     tweaked.width(),
                                     tweaked.height(),
                                     tweaked.start,
                                     tweaked.end));
}

Referenced by onSelectionEnd(), and onSelectionUpdate().

Here is the call graph for this function:

Here is the caller graph for this function:

drawCross()

void MeasureHandler::drawCross ( cairo_t *  cr, Scroom::Utils::Point< double >  p  )

privatevirtual

{
  static const int size = 10;
  cairo_move_to(cr, p.x - size, p.y);
  cairo_line_to(cr, p.x + size, p.y);
  cairo_move_to(cr, p.x, p.y - size);
  cairo_line_to(cr, p.x, p.y + size);
}

Referenced by render().

Here is the caller graph for this function:

onDisable()

void MeasureHandler::onDisable ( )

overridevirtual

Then function is called whenever the tool button is deselected.

Implements ToolStateListener.

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

onEnable()

void MeasureHandler::onEnable ( )

overridevirtual

This function is called whenever the tool button is selected.

Implements ToolStateListener.

{ enabled = true; }

onSelectionEnd()

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

override

{
  if(enabled)
  {
    selection = s;
    displayMeasurement(view);
  }
}

Here is the call graph for this function:

onSelectionStart()

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

override

{}

onSelectionUpdate()

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

override

{
  if(enabled)
  {
    selection = s;
    displayMeasurement(view);
  }
}

Here is the call graph for this function:

render()

void MeasureHandler::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.75, 0, 0); // Dark Red
    drawCross(cr, start);
    drawCross(cr, end);
    cairo_stroke(cr);
    cairo_set_source_rgb(cr, 1, 0, 0); // Red
    cairo_move_to(cr, start.x, start.y);
    cairo_line_to(cr, end.x, end.y);
    cairo_stroke(cr);
  }
}

Here is the call graph for this function:

Member Data Documentation

enabled

bool MeasureHandler::enabled {false}

private

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

selection

std::optional<Selection> MeasureHandler::selection

private

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

---

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

• plugins/measure/src/measure.hh
• plugins/measure/src/measure.cc