Scroom::Utils Namespace Reference

Namespaces
namespace	anonymous_namespace{tweak-view.cc}
namespace	Detail

Classes
class	Base
class	Context
class	Count
class	Counted
class	Counter
class	ITweakPositionTextBox
class	ITweakPresentationPosition
class	ITweakRulers
class	ITweakSelection
class	Observable
class	on_scope_exit
class	optional_cleanup
class	ParentContext
class	Point
class	ProgressInterfaceBroadcaster
class	ProgressInterfaceFromProgressStateInterface
class	ProgressInterfaceFromProgressStateInterfaceForwarder
class	ProgressInterfaceMultiplexer
class	ProgressStateInterface
class	ProgressStateInterfaceFromProgressInterface
class	ProgressStateInterfaceFromProgressInterfaceForwarder
class	Rectangle
class	RecursiveContext
class	Segment
class	SingleContext
class	TweakGridSelection
class	TweakPixelSelection
class	TweakPositionTextBox
class	TweakPresentationPosition
class	TweakRulers
class	TweakSelection

Typedefs
using	Stuff = std::shared_ptr< void >
using	StuffWeak = std::weak_ptr< void >
using	StuffList = std::list< Stuff >
template<typename K , typename V >
using	WeakKeyMap = std::map< K, V, std::owner_less< K > >
template<typename K >
using	WeakKeySet = std::set< K, std::owner_less< K > >

Functions
ITweakPresentationPosition::Ptr	getDefaultTweakPresentationPosition ()
ITweakRulers::Ptr	getDefaultTweakRulers ()
ITweakSelection::Ptr	getDefaultTweakSelection ()
ITweakSelection::Map	getDefaultTweakSelectionMap ()
ITweakPositionTextBox::Ptr	getDefaultTweakPositionTextBox ()
template<typename T >
T	get (const Context::ConstPtr &context, std::string name)
template<typename T >
T	get (const Context::ConstPtr &context)
template<typename T >
std::optional< T >	try_get (const Context::ConstPtr &context, std::string name)
template<typename T >
std::optional< T >	try_get (const Context::ConstPtr &context)
template<typename T , typename Callable >
auto	get_or (const Context::ConstPtr &context, std::string name, const Callable &default_value) -> std::enable_if_t< std::is_same_v< T, std::remove_reference_t< decltype(default_value())> >, T >
template<typename T , typename Callable >
auto	get_or (const Context::ConstPtr &context, const Callable &default_value) -> std::enable_if_t< std::is_same_v< T, std::remove_reference_t< decltype(default_value())> >, T >
template<typename T >
T	get_or (const Context::ConstPtr &context, std::string name, T default_value)
template<typename T >
T	get_or (const Context::ConstPtr &context, T default_value)
template<typename T >
void	set (const Context::Ptr &context, std::string name, T value)
template<typename T >
void	set (const Context::Ptr &context, T value)
template<typename Callable >
void	setFactory (const Context::Ptr &context, std::string name, Callable value)
template<typename Callable >
void	setFactory (const Context::Ptr &context, Callable value)
template<typename T >
bool	isZero (T v)
template<>
bool	isZero< int > (int v)
template<>
bool	isZero< double > (double v)
template<typename T >
bool	areEqual (T a, T b)
template<typename T >
Segment< T >	make_segment (T start, T size)
template<typename T >
Segment< T >	make_segment_from_start_end (T start, T end)
template<typename T >
std::ostream &	operator<< (std::ostream &os, const Segment< T > &s)
Segment< double >	roundOutward (Segment< double > s)
template<typename T >
T	center (Segment< T > s)
template<typename T >
Point< T >	make_point (T x, T y)
template<typename T >
Point< T >	make_point (T c)
template<typename T >
std::ostream &	operator<< (std::ostream &os, const Point< T > &p)
template<typename T , typename U >
Point< std::common_type_t< T, U > >	operator- (Point< T > left, Point< U > right)
template<typename T , typename U >
Point< std::common_type_t< T, U > >	operator+ (Point< T > left, Point< U > right)
template<typename T , typename U >
Point< std::common_type_t< T, U > >	operator* (Point< T > left, Point< U > right)
template<typename T , typename U >
Point< std::common_type_t< T, U > >	operator/ (Point< T > left, Point< U > right)
template<typename T , typename U >
Point< std::common_type_t< T, U > >	operator/ (T left, Point< U > right)
template<typename T , typename U >
Point< std::common_type_t< T, U > >	operator/ (Point< T > left, U right)
template<typename T >
Point< T >	rounded_divide_by (Point< T > value, T factor)
template<typename T >
Point< T >	ceiled_divide_by (Point< T > value, T factor)
template<typename T >
Point< T >	floored_divide_by (Point< T > value, T factor)
template<typename T >
Point< T >	rounded_divide_by (Point< T > value, Point< T > factor)
template<typename T >
Point< T >	ceiled_divide_by (Point< T > value, Point< T > factor)
template<typename T >
Point< T >	floored_divide_by (Point< T > value, Point< T > factor)
template<typename T >
Point< T >	ceil (Point< T > p)
template<typename T >
Rectangle< T >	make_rect (T x, T y, T width, T height)
template<typename T >
Rectangle< T >	make_rect (Point< T > position, Point< T > size)
template<typename T >
Rectangle< T >	make_rect_from_start_end (Point< T > start, Point< T > end)
template<typename T >
std::ostream &	operator<< (std::ostream &os, const Rectangle< T > &r)
std::ostream &	operator<< (std::ostream &os, const cairo_rectangle_int_t &r)
template<typename T , typename U >
Rectangle< std::common_type_t< T, U > >	operator* (Rectangle< T > left, U right)
template<typename T , typename U >
Rectangle< std::common_type_t< T, U > >	operator* (T left, Rectangle< U > right)
Rectangle< double >	operator* (cairo_rectangle_int_t const &r, Point< double > const &p)
Rectangle< double >	operator* (Point< double > const &p, cairo_rectangle_int_t const &r)
template<typename T , typename U >
Rectangle< std::common_type_t< T, U > >	operator- (Rectangle< T > left, Point< U > right)
Rectangle< double >	roundOutward (Rectangle< double > r)
Rectangle< double >	roundCorners (Rectangle< double > r)
template<typename T >
Point< T >	center (Rectangle< T > r)
Stuff	Empty ()
template<typename F >
std::shared_ptr< void >	on_destruction (F f)
std::shared_ptr< unsigned char >	shared_malloc (size_t size)
void	dumpCounts ()

Variables
constexpr double	epsilon = 1e-6

Typedef Documentation

Stuff

using Scroom::Utils::Stuff = typedef std::shared_ptr<void>

Stuff is a pointer to some private data.

StuffList

using Scroom::Utils::StuffList = typedef std::list<Stuff>

StuffWeak

using Scroom::Utils::StuffWeak = typedef std::weak_ptr<void>

WeakKeyMap

template<typename K , typename V >

using Scroom::Utils::WeakKeyMap = typedef std::map<K, V, std::owner_less<K> >

WeakKeySet

template<typename K >

using Scroom::Utils::WeakKeySet = typedef std::set<K, std::owner_less<K> >

Function Documentation

areEqual()

template<typename T >

bool Scroom::Utils::areEqual	(	T	a,
		T	b
	)

  {
    return isZero(a - b);
  }

Referenced by Scroom::Utils::Segment< T >::operator==().

Here is the call graph for this function:

Here is the caller graph for this function:

ceil()

template<typename T >

Point< T > Scroom::Utils::ceil

(

Point< T >

p

)

  {
    using std::ceil;
    return {ceil(p.x), ceil(p.y)};
  }

Referenced by ceil().

Here is the call graph for this function:

Here is the caller graph for this function:

ceiled_divide_by() [1/2]

template<typename T >

Point< T > Scroom::Utils::ceiled_divide_by	(	Point< T >	value,
		Point< T >	factor
	)

  {
    using ::ceiled_divide_by;
    return {ceiled_divide_by(value.x, factor.x), ceiled_divide_by(value.y, factor.y)};
  }

Here is the call graph for this function:

ceiled_divide_by() [2/2]

template<typename T >

Point< T > Scroom::Utils::ceiled_divide_by	(	Point< T >	value,
		T	factor
	)

  {
    using ::ceiled_divide_by;
    return {ceiled_divide_by(value.x, factor), ceiled_divide_by(value.y, factor)};
  }

Referenced by ceiled_divide_by(), and ceiled_divide_by().

Here is the call graph for this function:

Here is the caller graph for this function:

center() [1/2]

template<typename T >

Point< T > Scroom::Utils::center ( Rectangle< T >  r )

inline

  {
    return make_point(center(r.getHorizontally()), center(r.getVertically()));
  }

Here is the call graph for this function:

center() [2/2]

template<typename T >

T Scroom::Utils::center

(

Segment< T >

s

)

  {
    return s.getStart() + s.getSize() / 2;
  }

Referenced by center(), and Scroom::Utils::anonymous_namespace{tweak-view.cc}::find_closest_corner().

Here is the caller graph for this function:

dumpCounts()

void Scroom::Utils::dumpCounts

(

)

{ Counter::instance()->dump(); }

Here is the call graph for this function:

Empty()

Stuff Scroom::Utils::Empty ( )

inline

{ return {}; }

Referenced by Pnm::open(), and Tiff::open().

Here is the caller graph for this function:

floored_divide_by() [1/2]

template<typename T >

Point< T > Scroom::Utils::floored_divide_by	(	Point< T >	value,
		Point< T >	factor
	)

  {
    using ::floored_divide_by;
    return {floored_divide_by(value.x, factor.x), floored_divide_by(value.y, factor.y)};
  }

Here is the call graph for this function:

floored_divide_by() [2/2]

template<typename T >

Point< T > Scroom::Utils::floored_divide_by	(	Point< T >	value,
		T	factor
	)

  {
    using ::floored_divide_by;
    return {floored_divide_by(value.x, factor), floored_divide_by(value.y, factor)};
  }

Referenced by floored_divide_by(), and floored_divide_by().

Here is the call graph for this function:

Here is the caller graph for this function:

get() [1/2]

template<typename T >

T Scroom::Utils::get

(

const Context::ConstPtr &

context

)

  {
    return get<T>(context, typeid(T).name());
  }

get() [2/2]

template<typename T >

T Scroom::Utils::get	(	const Context::ConstPtr &	context,
		std::string	name
	)

  {
    const std::any& result = context->get(std::move(name));
    try
    {
      return std::any_cast<T>(result);
    }
    catch(std::bad_any_cast&)
    {
      using F = std::function<T()>;
      return std::any_cast<F>(result)();
    }
  }

get_or() [1/4]

template<typename T , typename Callable >

auto Scroom::Utils::get_or	(	const Context::ConstPtr &	context,
		const Callable &	default_value
	)		-> std::enable_if_t<std::is_same_v<T, std::remove_reference_t<decltype(default_value())>>, T>

  {
    return get_or<T>(context, typeid(T).name(), default_value);
  }

get_or() [2/4]

template<typename T , typename Callable >

auto Scroom::Utils::get_or	(	const Context::ConstPtr &	context,
		std::string	name,
		const Callable &	default_value
	)		-> std::enable_if_t<std::is_same_v<T, std::remove_reference_t<decltype(default_value())>>, T>

  {
    try
    {
      return get<T>(context, std::move(name));
    }
    catch(Context::name_not_found&)
    {
      return default_value();
    }
  }

get_or() [3/4]

template<typename T >

T Scroom::Utils::get_or	(	const Context::ConstPtr &	context,
		std::string	name,
		T	default_value
	)

  {
    return get_or<T>(context, std::move(name), [&default_value] { return std::move(default_value); });
  }

get_or() [4/4]

template<typename T >

T Scroom::Utils::get_or	(	const Context::ConstPtr &	context,
		T	default_value
	)

  {
    return get_or<T>(context, typeid(T).name(), [&default_value] { return std::move(default_value); });
  }

getDefaultTweakPositionTextBox()

ITweakPositionTextBox::Ptr Scroom::Utils::getDefaultTweakPositionTextBox

(

)

{ return TweakPositionTextBox::create(); }

Here is the call graph for this function:

getDefaultTweakPresentationPosition()

ITweakPresentationPosition::Ptr Scroom::Utils::getDefaultTweakPresentationPosition

(

)

  {
    return std::make_shared<DefaultTweakPresentationPosition>();
  }

getDefaultTweakRulers()

ITweakRulers::Ptr Scroom::Utils::getDefaultTweakRulers

(

)

{ return TweakRulers::create(); }

Here is the call graph for this function:

getDefaultTweakSelection()

ITweakSelection::Ptr Scroom::Utils::getDefaultTweakSelection

(

)

{ return std::make_shared<DefaultTweakSelection>(); }

Referenced by getDefaultTweakSelectionMap().

Here is the caller graph for this function:

getDefaultTweakSelectionMap()

ITweakSelection::Map Scroom::Utils::getDefaultTweakSelectionMap

(

)

  {
    return TweakSelection::Map{{SelectionType::DEFAULT, getDefaultTweakSelection()}};
  }

Here is the call graph for this function:

isZero()

template<typename T >

bool Scroom::Utils::isZero

(

T

v

)

Referenced by areEqual(), and Scroom::Utils::Segment< T >::isEmpty().

Here is the caller graph for this function:

isZero< double >()

template<>

bool Scroom::Utils::isZero< double > ( double  v )

inline

  {
    return std::abs(v) < epsilon;
  }

isZero< int >()

template<>

bool Scroom::Utils::isZero< int > ( int  v )

inline

  {
    return v == 0;
  }

make_point() [1/2]

template<typename T >

Point< T > Scroom::Utils::make_point

(

T

c

)

  {
    return Point<T>(c, c);
  }

Here is the call graph for this function:

make_point() [2/2]

template<typename T >

Point< T > Scroom::Utils::make_point	(	T	x,
		T	y
	)

  {
    return Point<T>(x, y);
  }

Referenced by center(), getAspectRatio(), make_point(), make_point(), operator/(), operator/(), roundCorners(), and TransformationData::setAspectRatio().

Here is the call graph for this function:

Here is the caller graph for this function:

make_rect() [1/2]

template<typename T >

Rectangle< T > Scroom::Utils::make_rect	(	Point< T >	position,
		Point< T >	size
	)

  {
    return Rectangle<T>(position.x, position.y, size.x, size.y);
  }

Here is the call graph for this function:

make_rect() [2/2]

template<typename T >

Rectangle< T > Scroom::Utils::make_rect	(	T	x,
		T	y,
		T	width,
		T	height
	)

  {
    return Rectangle<T>(x, y, width, height);
  }

Referenced by make_rect(), make_rect(), View::redraw(), and Scroom::Utils::TweakRulers::tweakRulers().

Here is the call graph for this function:

Here is the caller graph for this function:

make_rect_from_start_end()

template<typename T >

Rectangle< T > Scroom::Utils::make_rect_from_start_end	(	Point< T >	start,
		Point< T >	end
	)

  {
    return Rectangle<T>(make_segment_from_start_end(start.x, end.x), make_segment_from_start_end(start.y, end.y));
  }

Referenced by PipetteHandler::onSelectionEnd(), roundCorners(), and Scroom::Utils::anonymous_namespace{tweak-view.cc}::toRectangle().

Here is the call graph for this function:

Here is the caller graph for this function:

make_segment()

template<typename T >

Segment< T > Scroom::Utils::make_segment	(	T	start,
		T	size
	)

  {
    return Segment<T>(start, size);
  }

Referenced by make_segment().

Here is the call graph for this function:

Here is the caller graph for this function:

make_segment_from_start_end()

template<typename T >

Segment< T > Scroom::Utils::make_segment_from_start_end	(	T	start,
		T	end
	)

  {
    return Segment<T>(start, end - start);
  }

Referenced by make_rect_from_start_end(), and roundOutward().

Here is the caller graph for this function:

on_destruction()

template<typename F >

std::shared_ptr< void > Scroom::Utils::on_destruction

(

F

f

)

  {
    return std::make_shared<on_scope_exit<F>>(std::move(f));
  }

Referenced by Scroom::TiledBitmap::scheduleLoadingBitmap().

Here is the caller graph for this function:

operator*() [1/5]

Rectangle< double > Scroom::Utils::operator* ( cairo_rectangle_int_t const &  r, Point< double > const &  p  )

inline

{ return Rectangle<double>(r) * p; }

operator*() [2/5]

Rectangle< double > Scroom::Utils::operator* ( Point< double > const &  p, cairo_rectangle_int_t const &  r  )

inline

{ return Rectangle<double>(r) * p; }

operator*() [3/5]

template<typename T , typename U >

Point< std::common_type_t< T, U > > Scroom::Utils::operator*	(	Point< T >	left,
		Point< U >	right
	)

  {
    using R = std::common_type_t<T, U>;
 
    Point<R> result(left);
    result *= Point<R>(right);
    return result;
  }

operator*() [4/5]

template<typename T , typename U >

Rectangle< std::common_type_t< T, U > > Scroom::Utils::operator*	(	Rectangle< T >	left,
		U	right
	)

  {
    Rectangle<std::common_type_t<T, U>> result(left);
    result *= static_cast<std::common_type_t<T, U>>(right);
    return result;
  }

operator*() [5/5]

template<typename T , typename U >

Rectangle< std::common_type_t< T, U > > Scroom::Utils::operator*	(	T	left,
		Rectangle< U >	right
	)

  {
    return right * left;
  }

operator+()

template<typename T , typename U >

Point< std::common_type_t< T, U > > Scroom::Utils::operator+	(	Point< T >	left,
		Point< U >	right
	)

  {
    using R = std::common_type_t<T, U>;
 
    Point<R> result(left);
    result += Point<R>(right);
    return result;
  }

operator-() [1/2]

template<typename T , typename U >

Point< std::common_type_t< T, U > > Scroom::Utils::operator-	(	Point< T >	left,
		Point< U >	right
	)

  {
    using R = std::common_type_t<T, U>;
 
    Point<R> result(left);
    result -= Point<R>(right);
    return result;
  }

operator-() [2/2]

template<typename T , typename U >

Rectangle< std::common_type_t< T, U > > Scroom::Utils::operator-	(	Rectangle< T >	left,
		Point< U >	right
	)

  {
    using R = std::common_type_t<T, U>;
 
    return Rectangle<R>(left) - Point<R>(right);
  }

operator/() [1/3]

template<typename T , typename U >

Point< std::common_type_t< T, U > > Scroom::Utils::operator/	(	Point< T >	left,
		Point< U >	right
	)

  {
    using R = std::common_type_t<T, U>;
 
    Point<R> result(left);
    result /= Point<R>(right);
    return result;
  }

operator/() [2/3]

template<typename T , typename U >

Point< std::common_type_t< T, U > > Scroom::Utils::operator/	(	Point< T >	left,
		U	right
	)

  {
    return left / make_point(right, right);
  }

Here is the call graph for this function:

operator/() [3/3]

template<typename T , typename U >

Point< std::common_type_t< T, U > > Scroom::Utils::operator/	(	T	left,
		Point< U >	right
	)

  {
    return make_point(left, left) / right;
  }

Here is the call graph for this function:

operator<<() [1/4]

std::ostream & Scroom::Utils::operator<< ( std::ostream &  os, const cairo_rectangle_int_t &  r  )

inline

{ return os << Rectangle<double>(r); }

operator<<() [2/4]

template<typename T >

std::ostream & Scroom::Utils::operator<<	(	std::ostream &	os,
		const Point< T > &	p
	)

  {
    return os << '(' << p.x << ',' << p.y << ')';
  }

operator<<() [3/4]

template<typename T >

std::ostream & Scroom::Utils::operator<<	(	std::ostream &	os,
		const Rectangle< T > &	r
	)

  {
    os << '<' << r.getLeft() << ',' << r.getTop() << ',' << r.getWidth() << ',' << r.getHeight() << '>';
 
    return os;
  }

Here is the call graph for this function:

operator<<() [4/4]

template<typename T >

std::ostream & Scroom::Utils::operator<<	(	std::ostream &	os,
		const Segment< T > &	s
	)

  {
    return os << '(' << s.getStart() << ',' << s.getSize() << ')';
  }

roundCorners()

Rectangle< double > Scroom::Utils::roundCorners ( Rectangle< double >  r )

inline

  {
    return make_rect_from_start_end(
      round_to_multiple_of(r.getTopLeft(), make_point(1.0)), round_to_multiple_of(r.getBottomRight(), make_point(1.0))
    );
  }

Referenced by Scroom::Utils::TweakGridSelection::tweakSelection().

Here is the call graph for this function:

Here is the caller graph for this function:

rounded_divide_by() [1/2]

template<typename T >

Point< T > Scroom::Utils::rounded_divide_by	(	Point< T >	value,
		Point< T >	factor
	)

  {
    using ::rounded_divide_by;
    return {rounded_divide_by(value.x, factor.x), rounded_divide_by(value.y, factor.y)};
  }

Here is the call graph for this function:

rounded_divide_by() [2/2]

template<typename T >

Point< T > Scroom::Utils::rounded_divide_by	(	Point< T >	value,
		T	factor
	)

  {
    using ::rounded_divide_by;
    return {rounded_divide_by(value.x, factor), rounded_divide_by(value.y, factor)};
  }

Referenced by rounded_divide_by(), and rounded_divide_by().

Here is the call graph for this function:

Here is the caller graph for this function:

roundOutward() [1/2]

Rectangle< double > Scroom::Utils::roundOutward ( Rectangle< double >  r )

inline

  {
    return {
      roundOutward(r.getHorizontally()),
      roundOutward(r.getVertically()),
    };
  }

Here is the call graph for this function:

roundOutward() [2/2]

Segment< double > Scroom::Utils::roundOutward ( Segment< double >  s )

inline

  {
    return make_segment_from_start_end(round_down_to_multiple_of(s.getStart(), 1.0), round_up_to_multiple_of(s.getEnd(), 1.0));
  }

Referenced by roundOutward(), and Scroom::Utils::TweakPixelSelection::tweakSelection().

Here is the call graph for this function:

Here is the caller graph for this function:

set() [1/2]

template<typename T >

void Scroom::Utils::set	(	const Context::Ptr &	context,
		std::string	name,
		T	value
	)

  {
    context->set(std::move(name), std::any(std::move(value)));
  }

Referenced by set(), and setFactory().

Here is the caller graph for this function:

set() [2/2]

template<typename T >

void Scroom::Utils::set	(	const Context::Ptr &	context,
		T	value
	)

  {
    set(context, typeid(value).name(), std::move(value));
  }

Here is the call graph for this function:

setFactory() [1/2]

template<typename Callable >

void Scroom::Utils::setFactory	(	const Context::Ptr &	context,
		Callable	value
	)

  {
    using T = std::remove_reference_t<decltype(value())>;
    setFactory(context, typeid(T).name(), std::move(value));
  }

Here is the call graph for this function:

setFactory() [2/2]

template<typename Callable >

void Scroom::Utils::setFactory	(	const Context::Ptr &	context,
		std::string	name,
		Callable	value
	)

  {
    using T = std::remove_reference_t<decltype(value())>;
    set(context, std::move(name), std::function<T()>(std::move(value)));
  }

Referenced by setFactory().

Here is the call graph for this function:

Here is the caller graph for this function:

shared_malloc()

std::shared_ptr< unsigned char > Scroom::Utils::shared_malloc ( size_t  size )

inline

{ return {static_cast<unsigned char*>(malloc(size)), free}; }

Referenced by OperationsCMYK32::cache(), OperationsCMYK16::cache(), OperationsCMYK8::cache(), and OperationsCMYK4::cache().

Here is the caller graph for this function:

try_get() [1/2]

template<typename T >

std::optional< T > Scroom::Utils::try_get

(

const Context::ConstPtr &

context

)

  {
    return try_get<T>(context, typeid(T).name());
  }

try_get() [2/2]

template<typename T >

std::optional< T > Scroom::Utils::try_get	(	const Context::ConstPtr &	context,
		std::string	name
	)

  {
    try
    {
      return get<T>(context, std::move(name));
    }
    catch(Context::name_not_found&)
    {
      return std::nullopt;
    }
  }

Variable Documentation

epsilon

constexpr double Scroom::Utils::epsilon = 1e-6

constexpr

Referenced by isZero< double >().