slider.cpp

爱可视605看PDF程式源代码, 基于APDF

#include "slider.h"
#include "style.h"

#include <qpainter.h>
#include <qapplication.h>
#include <qsize.h>

using namespace archos;

SpeedUpTimer::SpeedUpTimer(QObject *parent)
	: QTimer(parent)
	, m_startInterval(0)
	, m_finalInterval(0)
	, m_currentInterval(0)
{
	connect(this, SIGNAL(timeout()), this, SLOT(decreaseInterval()));
};

void SpeedUpTimer::start()
{
	QTimer::start(m_startInterval);
}

void SpeedUpTimer::stop()
{
	QTimer::stop();
	m_currentInterval = m_startInterval;
}

// start interval must be higher than the finalInterval
void SpeedUpTimer::setIntervals(int startInterval, int finalInterval)
{
	QTimer::stop();
	m_startInterval = startInterval;
	m_finalInterval = finalInterval;
}

void SpeedUpTimer::decreaseInterval()
{
	if (m_currentInterval == m_finalInterval) {
		return;
	}

	m_currentInterval /= 2;
	if (m_currentInterval < m_finalInterval) {
		m_currentInterval = m_finalInterval;
	}
	changeInterval(m_currentInterval);
}

Slider::Slider(int width, QWidget *parent, const char *name)
	: QWidget(parent, name, WRepaintNoErase)
	, m_cursorSnapped(false)
	, m_stepSize(1)
{
	if (s_larrow == 0) {
		setupBitmaps();
	}
	else if (s_mode != Screen::mode()) {
		delete s_larrow;
		delete s_rarrow;
		delete s_empty_left;
		delete s_empty_center;
		delete s_empty_right;
		delete s_cursor;
		delete s_center;
		setupBitmaps();
	}

	QFont appFont = qApp->font();
	if (Screen::mode() == wqvga || Screen::mode() == qvga) {
		appFont.setPointSize(14);
	}
	else if ( Screen::mode() == wvga ) {
		appFont.setPointSize(22);
	}
	else {  // tv
		appFont.setPointSize(18);
	}
	setFont(appFont);

	int keyMiddlePos = ((sizeHint().height() - s_larrow->height()) / 2) + 1;
	int sliderMiddlePos = (sizeHint().height() - s_empty_center->height()) / 2;
	m_leftArrowPos = QPoint(5, keyMiddlePos);
	m_sliderStartPos = QPoint(m_leftArrowPos.x() + s_larrow->width() + 5, sliderMiddlePos);
	int sliderTextPos = width - 20 - QFontMetrics(font()).width(s_widthTemplate);
	m_rightArrowPos = QPoint(sliderTextPos - 5 - s_rarrow->width(), keyMiddlePos);
	m_sliderLength = (m_rightArrowPos.x() - 5) - m_sliderStartPos.x();
	m_sliderLastStep = m_sliderLength - s_cursor->width();
	
	setMinimumSize(sizeHint());
	connect(&kbd_timer, SIGNAL(timeout()), this, SLOT(updateValue()));
	kbd_timer.setIntervals(400, 10);
	connect(&mouse_timer, SIGNAL(timeout()), this, SLOT(updateValue()));
	mouse_timer.setIntervals(400, 10);
}

void Slider::setupBitmaps()
{
	s_mode = Screen::mode();
	QString path = AStyle::iconpath + Screen::prefix();
	s_larrow = new QPixmap(path + "general/choice_left_arrow.png");
	s_rarrow = new QPixmap(path + "general/choice_right_arrow.png");
	s_empty_left = new QPixmap(path + "general/slider_empty_left.png");
	s_empty_center = new QPixmap(path + "general/slider_empty_center.png");
	s_empty_right = new QPixmap(path + "general/slider_empty_right.png");
	s_cursor = new QPixmap(path + "general/slider_cursor.png");
	s_center = new QPixmap(path + "general/slider_center.png");
}

QPixmap *Slider::s_larrow = 0;
QPixmap *Slider::s_rarrow = 0;
QPixmap *Slider::s_empty_left = 0;
QPixmap *Slider::s_empty_center = 0;
QPixmap *Slider::s_empty_right = 0;
QPixmap *Slider::s_cursor = 0;
QPixmap *Slider::s_center = 0;
ScreenMode Slider::s_mode = wqvga;
QString Slider::s_widthTemplate("9999/9999");

void Slider::paintEvent(QPaintEvent *evt)
{
	QRect area(evt->rect());
	QPixmap buffer(area.size());
	QPainter p(&buffer, this);
	
	p.fillRect(rect(), QBrush(QColor(255, 255, 255)));
	p.drawPixmap(m_leftArrowPos, *s_larrow);

	int widgetHeight = sizeHint().height();

	// draw slider
	int sliderMiddlePos = ( widgetHeight - s_empty_center->height()) / 2;
	p.drawPixmap(m_sliderStartPos, *s_empty_left);
	for (int i = 0; i < m_sliderLength - s_empty_left->width() * 2; i++) {
		p.drawPixmap(m_sliderStartPos.x() + s_empty_left->width() + i, sliderMiddlePos, *s_empty_center);
	}
	p.drawPixmap(m_sliderStartPos.x() + m_sliderLength - s_empty_left->width(), sliderMiddlePos, *s_empty_right);
	p.drawPixmap(m_sliderStartPos.x() + m_sliderLength / 2, sliderMiddlePos, *s_center);

	p.drawPixmap(m_rightArrowPos, *s_rarrow);

	int slider_x_pos;
	// make sure it's left alligned
	if (m_x == 1) {
		slider_x_pos = m_sliderStartPos.x();
	}
	// make sure it is right alligned
	else if (m_x == m_y) {
		slider_x_pos = m_sliderStartPos.x() + m_sliderLastStep;
	}
	// center it betwen x and x + 1
	else {
		slider_x_pos = static_cast<int>(m_sliderStartPos.x() + ((float)m_sliderLastStep / m_y) * (m_x - 1));
		slider_x_pos += static_cast<int>(((m_sliderStartPos.x() + ((float)m_sliderLastStep / m_y) * m_x) - slider_x_pos) / 2);
	}
	p.drawPixmap(slider_x_pos, sliderMiddlePos, *s_cursor);

	p.setPen(QColor(0, 0, 0));
	int tx = m_rightArrowPos.x() + s_rarrow->width();
	int tw = sizeHint().width() - tx;
	p.drawText(tx, 0, tw, widgetHeight, AlignHCenter | AlignVCenter, QString("%1/%2").arg(m_x).arg(m_y));

	QPainter sp(this);
	sp.drawPixmap(area.topLeft(), buffer);
}

QSize Slider::sizeHint() const
{
	return QSize(m_sliderLength + s_larrow->width() + s_rarrow->width() +
		QFontMetrics(font()).width(s_widthTemplate) + 30, s_rarrow->height() + 20);
}

void Slider::setValues(int x, int y)
{
	m_x = x;
	m_y = y;
}

int Slider::getValue()
{
	return m_x;
}

void Slider::incValue()
{
	if (m_x < m_y) {
		emit valueChanged(++m_x);
		update();
	}
}

void Slider::decValue()
{
	if (m_x > 1) {
		emit valueChanged(--m_x);
		update();
	}
}

void Slider::incValueBy10()
{
	if (m_x < m_y) {
		m_x = m_x + 10 <= m_y ? m_x + 10 : m_y;
		emit valueChanged(m_x);
		update();
	}
}

void Slider::decValueBy10()
{
	if (m_x > 1) {
		m_x = m_x - 10 >= 1 ? m_x - 10 : 1;
		emit valueChanged(m_x);
		update();
	}
}

void Slider::updateValue()
{
	qWarning("updateValue");
	if (m_stepSize == 1) {
		qWarning("step size = 1");
		if ( m_direction == left) {
			decValue();
			qWarning("dec1");
		}
		else {
			qWarning("inc1");
			incValue();
		}
	}
	else if (m_stepSize == 10) {
		qWarning("step size = 10");
		if ( m_direction == left) {
			decValueBy10();
			qWarning("dec10");
		}
		else {
			qWarning("inc1");
			incValueBy10();
		}
	}
}

void Slider::keyPressEvent(QKeyEvent *e)
{
	if (e->isAutoRepeat() && (e->key() == Key_Left || e->key() == Key_Right ||
			e->key() == Key_Up  || e->key() == Key_Down ||
			e->key() == Key_PageUp || e->key() == Key_PageDown)) {
		e->ignore();
		return;
	}

	switch(e->key()) {
		case Key_Up:
		case Key_Left:
			m_direction = left;
			m_stepSize = 1;
			kbd_timer.start();
			break;
		case Key_Down:
		case Key_Right:
			m_direction = right;
			m_stepSize = 1;
			kbd_timer.start();
			break;
		case Key_PageUp:
			m_direction = left;
			m_stepSize = 10;
			kbd_timer.start();
			break;
		case Key_PageDown:
			m_direction = right;
			m_stepSize = 10;
			kbd_timer.start();
			break;
		default:
			e->ignore();
			break;
	}
}

void Slider::keyReleaseEvent(QKeyEvent *e)
{
	if (e->isAutoRepeat() && (e->key() == Key_Left || e->key() == Key_Right  ||
			e->key() == Key_Up  || e->key() == Key_Down ||
			e->key() == Key_PageDown || e->key() == Key_PageUp)) {
		e->ignore();
		return;
	}

	switch(e->key()) {
		case Key_Up:
		case Key_Left:
			kbd_timer.stop();
			decValue();
			break;
		case Key_Right:
		case Key_Down:
			kbd_timer.stop();
			incValue();
			break;
		case Key_PageUp:
			kbd_timer.stop();
			decValueBy10();
			break;
		case Key_PageDown:
			kbd_timer.stop();
			incValueBy10();
			break;
		default:
			e->ignore();
			break;
	}
}

QRect Slider::leftArrowRect()
{
	return QRect(m_leftArrowPos, QSize(s_larrow->width(), s_larrow->height()));
}

QRect Slider::rightArrowRect()
{
	return QRect(m_rightArrowPos, QSize(s_rarrow->width(), s_rarrow->height()));
}

QRect Slider::sliderRect()
{
	return QRect(m_sliderStartPos, QSize(m_sliderLength, s_empty_center->height()));
}

void Slider::mousePressEvent(QMouseEvent *e)
{
	if (leftArrowRect().contains(e->pos())) {
		m_direction = left;
		mouse_timer.start();
	}
	else if (rightArrowRect().contains(e->pos())) {
		m_direction = right;
		mouse_timer.start();
	}
	else if (sliderRect().contains(e->pos())) {
		m_cursorSnapped = true;
		m_x = sliderPosToValue(e->pos().x());
		emit valueChanged(m_x);
		update();
	}
}

void Slider::mouseMoveEvent(QMouseEvent *e)
{
	if (!leftArrowRect().contains(e->pos()) && !rightArrowRect().contains(e->pos())) {
		mouse_timer.stop();
	}

	if (m_cursorSnapped) {
		m_x = sliderPosToValue(e->pos().x());
		emit valueChanged(m_x);
		update();
	}
}

int Slider::sliderPosToValue(int x)
{
	int value = x - s_cursor->width()/2 - sliderRect().x();
	value = static_cast<int>((value / ((float)m_sliderLastStep / m_y)) + 1);
	if (value < 1) {
		value = 1;
	}
	else if (value > m_y) {
		value = m_y;
	}
	return value;
}

void Slider::mouseReleaseEvent(QMouseEvent *e)
{
 	if (leftArrowRect().contains(e->pos())) {
		mouse_timer.stop();
		decValue();
	}
	else if (rightArrowRect().contains(e->pos())) {
		mouse_timer.stop();
		incValue();
	}
	m_cursorSnapped = false;
}