QskTickmarks.cpp

/******************************************************************************
 * QSkinny - Copyright (C) The authors
 *           SPDX-License-Identifier: BSD-3-Clause
 *****************************************************************************/
 
#include "QskTickmarks.h"
#include <algorithm>
 
static void qskRegisterTickmarks()
{
    qRegisterMetaType< QskTickmarks >();
 
#if QT_VERSION < QT_VERSION_CHECK( 6, 0, 0 )
    QMetaType::registerEqualsComparator< QskTickmarks >();
#endif
}
 
Q_CONSTRUCTOR_FUNCTION( qskRegisterTickmarks )
 
QskTickmarks::QskTickmarks()
{
}
 
QskTickmarks::QskTickmarks( const QVector< qreal >& minorTicks,
        const QVector< qreal >& mediumTicks, const QVector< qreal >& majorTicks )
    : m_ticks{ minorTicks, mediumTicks, majorTicks }
{
}
 
QskTickmarks::~QskTickmarks()
{
}
 
int QskTickmarks::tickCount() const noexcept
{
    const auto count = m_ticks[ MajorTick ].count()
        + m_ticks[ MediumTick ].count()
        + m_ticks[ MinorTick ].count();
 
    return static_cast< int >( count );
}
 
 
int QskTickmarks::tickCount( TickType type ) const noexcept
{
    return static_cast< int >( m_ticks[ type ].count() );
}
 
QVector< qreal > QskTickmarks::ticks( TickType type ) const noexcept
{
    return m_ticks[ type ];
}
 
void QskTickmarks::setTicks(TickType type, const QVector< qreal >& ticks )
{
    m_ticks[ type ] = ticks;
}
 
qreal QskTickmarks::tickAt( TickType type, int index ) const
{
    return m_ticks[ type ].at( index );
}
 
void QskTickmarks::reset()
{
    m_ticks[ 0 ].clear();
    m_ticks[ 1 ].clear();
    m_ticks[ 2 ].clear();
}
 
void QskTickmarks::invert()
{
    std::reverse( m_ticks[ 0 ].begin(), m_ticks[ 0 ].end() );
    std::reverse( m_ticks[ 1 ].begin(), m_ticks[ 1 ].end() );
    std::reverse( m_ticks[ 2 ].begin(), m_ticks[ 2 ].end() );
}
 
QskHashValue QskTickmarks::hash( QskHashValue seed ) const noexcept
{
    seed = qHash( m_ticks[0], seed );
    seed = qHash( m_ticks[1], seed );
    seed = qHash( m_ticks[2], seed );
 
    return seed;
}
 
bool QskTickmarks::operator==( const QskTickmarks& other ) const noexcept
{
    return ( m_ticks[ 0 ] == other.m_ticks[ 0 ] )
        && ( m_ticks[ 1 ] == other.m_ticks[ 1 ] )
        && ( m_ticks[ 2 ] == other.m_ticks[ 2 ] );
}
 
#ifndef QT_NO_DEBUG_STREAM
 
#include <qdebug.h>
 
QDebug operator<<( QDebug debug, const QskTickmarks& tickmarks )
{
    debug << tickmarks.majorTicks()
        << tickmarks.mediumTicks() << tickmarks.minorTicks();
 
    return debug;
}
 
#endif
 
#include "moc_QskTickmarks.cpp"