Scroom::Utils Namespace Reference

Namespaces
	Detail

Classes
class	Base
class	Count
class	Counted
class	Counter
class	Observable
class	on_scope_exit
class	optional_cleanup
class	Point
class	ProgressInterfaceBroadcaster
class	ProgressInterfaceFromProgressStateInterface
class	ProgressInterfaceFromProgressStateInterfaceForwarder
class	ProgressInterfaceMultiplexer
class	ProgressStateInterface
class	ProgressStateInterfaceFromProgressInterface
class	ProgressStateInterfaceFromProgressInterfaceForwarder
class	Rectangle
class	Segment
class	Timer

Typedefs
using	Stuff = boost::shared_ptr< void >
using	StuffWeak = boost::weak_ptr< void >
using	StuffList = std::list< Stuff >

Functions
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< typename std::common_type< T, U >::type >	operator- (Point< T > left, Point< U > right)
template<typename T , typename U >
Point< typename std::common_type< T, U >::type >	operator+ (Point< T > left, Point< U > right)
template<typename T , typename U >
Point< typename std::common_type< T, U >::type >	operator* (Point< T > left, Point< U > right)
template<typename T , typename U >
Point< typename std::common_type< T, U >::type >	operator/ (Point< T > left, Point< U > right)
template<typename T , typename U >
Point< typename std::common_type< T, U >::type >	operator/ (T left, Point< U > right)
template<typename T , typename U >
Point< typename std::common_type< T, U >::type >	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< typename std::common_type< T, U >::type >	operator* (Rectangle< T > left, U right)
template<typename T , typename U >
Rectangle< typename std::common_type< T, U >::type >	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< typename std::common_type< T, U >::type >	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 >
boost::shared_ptr< void >	on_destruction (F f)
void	dumpCounts ()

Variables
constexpr double	epsilon = 1e-6

Typedef Documentation

Stuff

using Scroom::Utils::Stuff = typedef boost::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 boost::weak_ptr<void>

Function Documentation

areEqual()

template<typename T >

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

  {
    return isZero(a - b);
  }

Referenced by Scroom::Utils::Segment< value_type >::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 ceiled_divide_by(), createProvider(), TransformPresentation::redraw(), and testCorrectIntervalForMinWidth().

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)};
  }

Referenced by ceiled_divide_by().

Here is the call graph for this function:

Here is the caller 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().

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(), TweakPositionTextBox::display(), and find_closest_corner().

Here is the call graph for this function:

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 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)};
  }

Referenced by floored_divide_by().

Here is the call graph for this function:

Here is the caller 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().

Here is the call graph for this function:

Here is the caller graph for this function:

isZero()

template<typename T >

bool Scroom::Utils::isZero

(

T

v

)

Referenced by areEqual(), and Scroom::Utils::Segment< value_type >::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);
  }

make_point() [2/2]

template<typename T >

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

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

Referenced by BOOST_AUTO_TEST_CASE(), center(), RectangleHorizontalTestScaffold::contains(), RectangleVerticalTestScaffold::contains(), PresentationInterface::getAspectRatio(), RectangleHorizontalTestScaffold::moveTo(), RectangleVerticalTestScaffold::moveTo(), operator/(), roundCorners(), and TransformationData::setAspectRatio().

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);
  }

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 BOOST_AUTO_TEST_CASE(), View::redraw(), TEST(), and TweakRulers::tweakRulers().

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 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 BOOST_AUTO_TEST_CASE().

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 >

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

(

F

f

)

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

Referenced by BOOST_AUTO_TEST_CASE(), and 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<typename std::common_type<T, U>::type> Scroom::Utils::operator*	(	Point< T >	left,
		Point< U >	right
	)

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

operator*() [4/5]

template<typename T , typename U >

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

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

operator*() [5/5]

template<typename T , typename U >

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

  {
    return right * left;
  }

operator+()

template<typename T , typename U >

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

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

operator-() [1/2]

template<typename T , typename U >

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

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

operator-() [2/2]

template<typename T , typename U >

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

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

operator/() [1/3]

template<typename T , typename U >

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

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

operator/() [2/3]

template<typename T , typename U >

Point<typename std::common_type<T, U>::type> 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<typename std::common_type<T, U>::type> 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() << ')';
  }

Here is the call graph for this function:

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 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)};
  }

Referenced by rounded_divide_by().

Here is the call graph for this function:

Here is the caller 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().

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 PipetteHandler::computeValues(), Operations1bpp::draw(), Operations8bpp::draw(), Operations::draw(), anonymous_namespace{tiledbitmappresentation.cc}::TiledBitmapPresentation::getPixelAverages(), roundOutward(), and TweakPixelSelection::tweakSelection().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

epsilon

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

constexpr

Referenced by isZero< double >().