633 lines
18 KiB
C++
633 lines
18 KiB
C++
/***************************************************************************
|
|
* Copyright (C) 2008 by Oliver Groß *
|
|
* z.o.gross@gmx.de *
|
|
* *
|
|
* This program is free software; you can redistribute it and/or modify *
|
|
* it under the terms of the GNU General Public License as published by *
|
|
* the Free Software Foundation; either version 2 of the License, or *
|
|
* (at your option) any later version. *
|
|
* *
|
|
* This program is distributed in the hope that it will be useful, *
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
|
|
* GNU General Public License for more details. *
|
|
* *
|
|
* You should have received a copy of the GNU General Public License *
|
|
* along with this program; if not, write to the *
|
|
* Free Software Foundation, Inc., *
|
|
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
|
|
***************************************************************************/
|
|
#include "ccrossfieldwidget.h"
|
|
#include <libqcross/cnonogram.h>
|
|
#include <QPainter>
|
|
#include <QMouseEvent>
|
|
#include <QLCDNumber>
|
|
#include <QDebug>
|
|
#include <QFrame>
|
|
#include <QLabel>
|
|
#include <QHBoxLayout>
|
|
#include <QStyle>
|
|
#include <QApplication>
|
|
|
|
namespace qcross {
|
|
using namespace libqcross;
|
|
|
|
int min(int a, int b) {
|
|
return (a < b) ? a : b;
|
|
}
|
|
|
|
int max(int a, int b) {
|
|
return (a > b) ? a : b;
|
|
}
|
|
|
|
//public
|
|
CCrossFieldWidget::CCrossFieldWidget(CNonogram * picture, QWidget * parent) : QWidget(parent),
|
|
m_Picture(picture),
|
|
m_OverlayData(NULL),
|
|
m_MouseMark(CMT_NONE),
|
|
m_ErrorAware(false),
|
|
m_NumbersMarkable(true),
|
|
m_Time(0),
|
|
m_Paused(true),
|
|
m_Solved(false),
|
|
m_TimerId(-1),
|
|
m_MessageTimeoutId(-1),
|
|
m_Clock(NULL),
|
|
m_ErrorCount(0),
|
|
m_LastErrorMark(-1,-1)
|
|
{
|
|
m_Notifier = new QFrame(this);
|
|
m_Notifier->setLineWidth(10);
|
|
m_Notifier->setFrameStyle(QFrame::StyledPanel | QFrame::Sunken);
|
|
QPalette notifierPalette(QApplication::palette().color(QPalette::ToolTipBase));
|
|
notifierPalette.setColor(QPalette::Text, QApplication::palette().color(QPalette::ToolTipText));
|
|
|
|
m_Notifier->setPalette(notifierPalette);
|
|
m_Notifier->setAutoFillBackground(true);
|
|
|
|
QHBoxLayout * notifierLayout = new QHBoxLayout(m_Notifier);
|
|
m_NotifierIcon = new QLabel(m_Notifier);
|
|
m_NotifierText = new QLabel(m_Notifier);
|
|
|
|
m_NotifierText->setWordWrap(true);
|
|
notifierLayout->addWidget(m_NotifierIcon);
|
|
notifierLayout->addWidget(m_NotifierText);
|
|
notifierLayout->addStretch();
|
|
m_Notifier->setLayout(notifierLayout);
|
|
|
|
m_Notifier->hide();
|
|
|
|
m_Clock = new QLCDNumber(8, this);
|
|
m_Clock->setVisible(m_Picture);
|
|
|
|
if (m_Picture) {
|
|
initialize();
|
|
m_RemainingPixels = m_Picture->blackPixels();
|
|
updateTimeDisplay();
|
|
}
|
|
|
|
setEnabled(false);
|
|
}
|
|
|
|
CCrossFieldWidget::~CCrossFieldWidget() {
|
|
cleanup();
|
|
|
|
delete m_Clock;
|
|
}
|
|
|
|
void CCrossFieldWidget::setPicture(CNonogram * picture) {
|
|
cleanup();
|
|
m_Picture = picture;
|
|
if (m_Picture) {
|
|
m_LastErrorMark.setX(-1);
|
|
m_LastErrorMark.setY(-1);
|
|
m_ErrorCount = 0;
|
|
m_Time = picture->timeout();
|
|
m_ErrorAware = picture->timeout();
|
|
m_Solved = false;
|
|
|
|
updateTimeDisplay();
|
|
emit timeChanged(m_Time);
|
|
|
|
initialize();
|
|
|
|
m_Messages.clear();
|
|
nextMessage();
|
|
|
|
updateMetrics();
|
|
|
|
m_RemainingPixels = m_Picture->blackPixels();
|
|
}
|
|
m_Clock->setVisible(m_Picture);
|
|
}
|
|
//beim Laden eines neuen Spiels nach einem beendeten wird das neue nicht automatisch gestartet (Restart nötig)
|
|
void CCrossFieldWidget::showMessage(const QString message, int timeout, MessageType type) {
|
|
if (!message.isEmpty()) {
|
|
Message newMessage;
|
|
newMessage.type = type;
|
|
newMessage.text = message;
|
|
newMessage.timeout = timeout;
|
|
m_Messages.enqueue(newMessage);
|
|
}
|
|
|
|
if (m_MessageTimeoutId == -1)
|
|
nextMessage();
|
|
}
|
|
|
|
//public slots
|
|
void CCrossFieldWidget::mark(int x, int y, qcross::MarkerType type) {
|
|
if (type == CMT_NONE || x < 0 || x >= m_Picture->width() || y < 0 || y >= m_Picture->height())
|
|
return;
|
|
|
|
if (type == CMT_MARKED && checkNoError(x, y))
|
|
m_OverlayData[x][y] = CMT_MARKED;
|
|
else
|
|
m_OverlayData[x][y] = type;
|
|
}
|
|
|
|
void CCrossFieldWidget::setTime(int value) {
|
|
if (value < 0)
|
|
value = 0;
|
|
|
|
if (m_Time != value) {
|
|
m_Time = value;
|
|
|
|
if (m_ErrorAware && !m_Time) {
|
|
killTimer(m_TimerId);
|
|
m_Paused = true;
|
|
emit timeUp();
|
|
}
|
|
|
|
updateTimeDisplay();
|
|
|
|
emit timeChanged(m_Time);
|
|
}
|
|
}
|
|
|
|
void CCrossFieldWidget::setErrorAware(bool value) {
|
|
m_ErrorAware = value;
|
|
}
|
|
|
|
void CCrossFieldWidget::setNumbersMarkable(bool value) {
|
|
m_NumbersMarkable = value;
|
|
}
|
|
|
|
void CCrossFieldWidget::start() {
|
|
reset();
|
|
resume();
|
|
}
|
|
|
|
void CCrossFieldWidget::pause() {
|
|
if (m_Solved)
|
|
return;
|
|
|
|
killTimer(m_TimerId);
|
|
m_Paused = true;
|
|
setEnabled(false);
|
|
}
|
|
|
|
void CCrossFieldWidget::resume() {
|
|
if (m_Solved)
|
|
return;
|
|
|
|
m_Paused = false;
|
|
setEnabled(true);
|
|
update();
|
|
m_TimerId = startTimer(1000);
|
|
}
|
|
|
|
//protected
|
|
void CCrossFieldWidget::nextMessage() {
|
|
if (m_MessageTimeoutId != -1)
|
|
killTimer(m_MessageTimeoutId);
|
|
|
|
m_MessageTimeoutId = -1;
|
|
|
|
if (m_Messages.isEmpty()) {
|
|
m_Message.type = Invalid;
|
|
update();
|
|
return;
|
|
}
|
|
|
|
Message m_Next = m_Messages.dequeue();
|
|
update();
|
|
|
|
// switch (next.type) {
|
|
// case Information:
|
|
// m_NotifierIcon->setPixmap(style()->standardIcon(QStyle::SP_MessageBoxInformation).pixmap(22, 22));
|
|
// break;
|
|
// case Warning:
|
|
// m_NotifierIcon->setPixmap(style()->standardIcon(QStyle::SP_MessageBoxWarning).pixmap(22, 22));
|
|
// break;
|
|
// case Critical:
|
|
// m_NotifierIcon->setPixmap(style()->standardIcon(QStyle::SP_MessageBoxCritical).pixmap(22, 22));
|
|
// break;
|
|
// default:
|
|
// break;
|
|
// }
|
|
|
|
// m_NotifierText->setText(next.text);
|
|
|
|
// m_Notifier->show();
|
|
// updateMetrics();
|
|
|
|
if (m_Message.timeout)
|
|
m_MessageTimeoutId = startTimer(m_Message.timeout);
|
|
}
|
|
|
|
void CCrossFieldWidget::initialize() {
|
|
m_OverlayData = new MarkerType *[m_Picture->width()];
|
|
for (int i = 0; i < m_Picture->width(); i++) {
|
|
m_OverlayData[i] = new MarkerType[m_Picture->height()];
|
|
for (int j = 0; j < m_Picture->height(); j++)
|
|
m_OverlayData[i][j] = CMT_UNMARKED;
|
|
}
|
|
|
|
int minimumW = max(m_Picture->maximumNumberCount()+1, 5);
|
|
int minimumH = minimumW;
|
|
|
|
minimumW += m_Picture->width();
|
|
minimumH += m_Picture->height();
|
|
|
|
int minimumBoxSize = max(fontMetrics().width(QString::number(m_Picture->height())), fontMetrics().width(QString::number(m_Picture->width())));
|
|
minimumBoxSize = max(minimumBoxSize, fontInfo().pixelSize() * 1.5);
|
|
|
|
minimumW *= minimumBoxSize;
|
|
minimumH *= minimumBoxSize;
|
|
|
|
setMinimumSize(minimumW, minimumH);
|
|
}
|
|
|
|
void CCrossFieldWidget::cleanup() {
|
|
killTimer(m_TimerId);
|
|
killTimer(m_MessageTimeoutId);
|
|
|
|
if (m_OverlayData) {
|
|
for (int i = 0; i < m_Picture->width(); i++)
|
|
delete[] m_OverlayData[i];
|
|
delete[] m_OverlayData;
|
|
m_OverlayData = NULL;
|
|
}
|
|
}
|
|
|
|
void CCrossFieldWidget::reset() {
|
|
m_Messages.clear();
|
|
nextMessage();
|
|
|
|
for (int i = 0; i < m_Picture->width(); i++) {
|
|
for (int j = 0; j < m_Picture->height(); j++)
|
|
m_OverlayData[i][j] = CMT_UNMARKED;
|
|
}
|
|
|
|
m_Solved = false;
|
|
m_ErrorCount = 0;
|
|
m_LastErrorMark.setX(-1);
|
|
m_LastErrorMark.setY(-1);
|
|
m_RemainingPixels = m_Picture->blackPixels();
|
|
}
|
|
|
|
bool CCrossFieldWidget::checkNoError(int x, int y) {
|
|
return (m_OverlayData[x][y] == CMT_MARKED) || m_Picture->pixel(x, y);
|
|
}
|
|
|
|
void CCrossFieldWidget::timerEvent(QTimerEvent * event) {
|
|
if (event->timerId() == m_TimerId)
|
|
setTime(m_Time + (m_ErrorAware ? -1 : +1));
|
|
else if (event->timerId() == m_MessageTimeoutId)
|
|
nextMessage();
|
|
}
|
|
|
|
void CCrossFieldWidget::updateTimeDisplay() {
|
|
quint8 seconds = m_Time % 60;
|
|
quint8 minutes = m_Time / 60;
|
|
quint8 hours = minutes / 60;
|
|
minutes %= 60;
|
|
|
|
QString time("");
|
|
|
|
if (hours)
|
|
time += QString::number(hours) + ':';
|
|
|
|
if (minutes < 10)
|
|
time += '0';
|
|
|
|
time += QString::number(minutes) + ':';
|
|
|
|
if (seconds < 10)
|
|
time += '0';
|
|
|
|
time += QString::number(seconds);
|
|
|
|
m_Clock->display(time);
|
|
}
|
|
|
|
void CCrossFieldWidget::execMark(int x, int y) {
|
|
/* if (m_OverlayData[x][y] == m_MouseMark)
|
|
return;*/
|
|
|
|
switch (m_MouseMark) {
|
|
case CMT_MARKED:
|
|
if (m_Picture->pixel(x, y)) {
|
|
m_RemainingPixels--;
|
|
m_OverlayData[x][y] = m_MouseMark;
|
|
}
|
|
else if (m_ErrorAware) {
|
|
m_ErrorCount++;
|
|
m_MouseMark = CMT_NONE;
|
|
m_OverlayData[x][y] = CMT_CROSSED;
|
|
m_LastErrorMark.setX(x);
|
|
m_LastErrorMark.setY(y);
|
|
emit markError();
|
|
}
|
|
else {
|
|
m_ErrorCount++;
|
|
m_OverlayData[x][y] = m_MouseMark;
|
|
}
|
|
break;
|
|
case CMT_CROSSED:
|
|
case CMT_UNMARKED:
|
|
if (m_ErrorAware && x == m_LastErrorMark.x() && y == m_LastErrorMark.y()) {
|
|
m_LastErrorMark.setX(-1);
|
|
m_LastErrorMark.setY(-1);
|
|
}
|
|
|
|
if (m_OverlayData[x][y] == CMT_MARKED) {
|
|
if (m_Picture->pixel(x, y))
|
|
m_RemainingPixels++;
|
|
else
|
|
m_ErrorCount--;
|
|
}
|
|
|
|
m_OverlayData[x][y] = m_MouseMark;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (!m_RemainingPixels && (m_ErrorAware || !m_ErrorCount)) {
|
|
killTimer(m_TimerId);
|
|
m_Paused = true;
|
|
m_Solved = true;
|
|
emit solved();
|
|
}
|
|
}
|
|
|
|
void CCrossFieldWidget::paintEvent(QPaintEvent *) {
|
|
QPainter painter(this);
|
|
|
|
if (!m_Picture) {
|
|
/* painter.drawText(originX, originY, m_BoxSize, m_BoxSize,
|
|
Qt::AlignVCenter | Qt::AlignCenter, QString::number(m_Picture->rowNumbers(i)[m_Picture->rowNumbers(i).size() - j]));*/
|
|
return;
|
|
}
|
|
|
|
int originX = m_OffsetX + m_HeaderWidth;
|
|
int originY = m_OffsetY + m_HeaderHeight;
|
|
|
|
int gridWidth = m_RasterWidth - m_HeaderWidth;
|
|
int gridHeight = m_RasterHeight - m_HeaderHeight;
|
|
|
|
{
|
|
const int delta = 5 * m_BoxSize;
|
|
|
|
int offsetX = 0;
|
|
int offsetY;
|
|
int deltaX = delta;
|
|
int deltaY;
|
|
|
|
bool useBase = false;
|
|
|
|
while (offsetX < gridWidth) {
|
|
offsetY = 0;
|
|
deltaY = delta;
|
|
while (offsetY < gridHeight) {
|
|
painter.fillRect(originX + offsetX, originY + offsetY, deltaX, deltaY,
|
|
palette().color(useBase ? QPalette::Base : QPalette::AlternateBase));
|
|
|
|
useBase = !useBase;
|
|
|
|
offsetY += delta;
|
|
|
|
if (gridWidth - offsetY < delta)
|
|
deltaY = gridWidth - offsetY;
|
|
}
|
|
|
|
useBase = !useBase;
|
|
|
|
offsetX += delta;
|
|
|
|
if (gridWidth - offsetX < delta)
|
|
deltaX = gridWidth - offsetX;
|
|
}
|
|
}
|
|
|
|
painter.setBrush(palette().color(QPalette::Highlight));
|
|
|
|
QFont font = painter.font();
|
|
font.setPixelSize(m_MarkerSize * 0.9);
|
|
|
|
{
|
|
QPen pen;
|
|
|
|
pen.setWidth(m_MarkerSize / 10);
|
|
|
|
painter.setPen(pen);
|
|
}
|
|
|
|
QRectF markerRect(m_MarkerOffset, m_MarkerOffset, m_MarkerSize, m_MarkerSize);
|
|
|
|
for (int i = 0; i < m_Picture->width(); i++) {
|
|
originX = m_OffsetX + m_HeaderWidth + i * m_BoxSize;
|
|
markerRect.moveLeft(originX + m_MarkerOffset);
|
|
|
|
for (int j = 0; j < m_Picture->height(); j++) {
|
|
originY = m_OffsetY + m_HeaderHeight + j * m_BoxSize;
|
|
markerRect.moveTop(originY + m_MarkerOffset);
|
|
|
|
switch (m_OverlayData[i][j]) {
|
|
case CMT_MARKED:
|
|
painter.fillRect(markerRect, painter.brush());
|
|
break;
|
|
case CMT_CROSSED:
|
|
if (m_Solved)
|
|
break;
|
|
|
|
if (m_ErrorAware && m_ErrorCount && i == m_LastErrorMark.x() && j == m_LastErrorMark.y()) {
|
|
painter.fillRect(markerRect, painter.brush());
|
|
}
|
|
|
|
painter.drawLine(markerRect.topLeft(), markerRect.bottomRight());
|
|
painter.drawLine(markerRect.bottomLeft(), markerRect.topRight());
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
painter.setPen(palette().color(QPalette::Dark));
|
|
|
|
for (int i = m_OffsetX + m_HeaderWidth; i < m_OffsetX + m_RasterWidth; i += m_BoxSize) {
|
|
painter.drawLine(i, m_OffsetY + m_HeaderHeight, i, m_OffsetY + m_RasterHeight-1);
|
|
}
|
|
|
|
for (int i = m_OffsetY + m_HeaderHeight; i < m_OffsetY + m_RasterHeight; i += m_BoxSize) {
|
|
painter.drawLine(m_OffsetX + m_HeaderWidth, i, m_OffsetX + m_RasterWidth-1, i);
|
|
}
|
|
|
|
if (m_Paused)
|
|
painter.setPen(palette().color(QPalette::Shadow));
|
|
|
|
painter.setFont(font);
|
|
|
|
for (int i = 0; i < m_Picture->width(); i++) {
|
|
originX = m_OffsetX + m_HeaderWidth + i * m_BoxSize;
|
|
painter.fillRect(originX, m_OffsetY, m_BoxSize, m_HeaderHeight, palette().color((i % 2) ? QPalette::AlternateBase : QPalette::Base));
|
|
if (!m_Paused) {
|
|
painter.setPen(palette().color(QPalette::WindowText));
|
|
for (int j = 1; j <= m_Picture->columnNumbers(i).size(); j++) {
|
|
originY = m_OffsetY + m_HeaderHeight - j * m_BoxSize;
|
|
|
|
painter.drawText(originX, originY, m_BoxSize, m_BoxSize,
|
|
Qt::AlignVCenter | Qt::AlignCenter, QString::number(m_Picture->columnNumbers(i)[m_Picture->columnNumbers(i).size() - j]));
|
|
}
|
|
painter.setPen(palette().color(QPalette::Shadow));
|
|
}
|
|
if (!(i % 5))
|
|
painter.drawLine(originX, m_OffsetY, originX, m_OffsetY + m_RasterHeight-1);
|
|
}
|
|
// painter.drawLine(m_OffsetX + m_RasterWidth, m_OffsetY, m_OffsetX + m_RasterWidth, m_OffsetY + m_RasterHeight);
|
|
|
|
for (int i = 0; i < m_Picture->height(); i++) {
|
|
originY = m_OffsetY + m_HeaderHeight + i * m_BoxSize;
|
|
painter.fillRect(m_OffsetX, originY, m_HeaderWidth, m_BoxSize, palette().color((i % 2) ? QPalette::AlternateBase : QPalette::Base));
|
|
if (!m_Paused) {
|
|
painter.setPen(palette().color(QPalette::WindowText));
|
|
for (int j = 1; j <= m_Picture->rowNumbers(i).size(); j++) {
|
|
originX = m_OffsetX + m_HeaderWidth - j * m_BoxSize;
|
|
painter.drawText(originX, originY, m_BoxSize, m_BoxSize,
|
|
Qt::AlignVCenter | Qt::AlignCenter, QString::number(m_Picture->rowNumbers(i)[m_Picture->rowNumbers(i).size() - j]));
|
|
}
|
|
painter.setPen(palette().color(QPalette::Shadow));
|
|
}
|
|
if (!(i % 5))
|
|
painter.drawLine(m_OffsetX, originY, m_OffsetX + m_RasterWidth-1, originY);
|
|
}
|
|
|
|
if (m_Message.type != Invalid) {
|
|
painter.drawText(m_HeaderWidth + m_OffsetX, m_HeaderHeight + m_OffsetY, m_Message.text);
|
|
}
|
|
// painter.drawLine(m_OffsetX, m_OffsetY + m_RasterHeight, m_OffsetX + m_RasterWidth, m_OffsetY + m_RasterHeight);
|
|
}
|
|
|
|
/* void CCrossFieldWidget::updateCell(int x, int y) {
|
|
QPainter painter(this);
|
|
int originX, originY;
|
|
originX = m_OffsetX + m_HeaderWidth + x * m_BoxSize;
|
|
originY = m_OffsetY + m_HeaderHeight + y * m_BoxSize;
|
|
painter.fillRect(originX + 1, originY + 1, m_BoxSize - 2, m_BoxSize - 2, palette().color(QPalette::Base));
|
|
switch (m_OverlayData[x][y]) {
|
|
case CMT_MARKED:
|
|
painter.drawRect(originX + 2, originY + 2, m_BoxSize - 4, m_BoxSize - 4);
|
|
break;
|
|
case CMT_CROSSED:
|
|
painter.drawLine(originX + 2, originY + 2, originX + m_BoxSize - 2, originY + m_BoxSize - 2);
|
|
painter.drawLine(originX + 2, originY + m_BoxSize - 2, originX + m_BoxSize - 2, originY + 2);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}*/
|
|
|
|
void CCrossFieldWidget::resizeEvent(QResizeEvent * /*event*/) {
|
|
if (!m_Picture)
|
|
return;
|
|
|
|
updateMetrics();
|
|
}
|
|
|
|
void CCrossFieldWidget::updateMetrics() {
|
|
m_HeaderWidth = max(m_Picture->maximumNumberCount()+1, 5);
|
|
/* m_HeaderWidth = max(m_Picture->width() / 2 + 1, m_Picture->height() / 2 + 1);
|
|
m_HeaderWidth = m_Picture->width() / 2 + 1;
|
|
m_HeaderHeight = m_Picture->height() / 2 + 1;*/
|
|
|
|
int fieldsize = min((m_Picture->width() + m_HeaderWidth), (m_Picture->height() + m_HeaderWidth));
|
|
int widgetsize = min(width(), height());
|
|
|
|
m_BoxSize = ((double)widgetsize / fieldsize);
|
|
/*min((double)width() / (m_Picture->width() + m_HeaderWidth), (double)height() / (m_Picture->height() + m_HeaderWidth));*/
|
|
|
|
m_MarkerSize = m_BoxSize * 2.0/3.0;
|
|
m_MarkerOffset = ((m_BoxSize - m_MarkerSize) / 2.0);
|
|
|
|
m_HeaderWidth *= m_BoxSize;
|
|
m_HeaderHeight = m_HeaderWidth;
|
|
|
|
m_RasterWidth = m_BoxSize * m_Picture->width() + m_HeaderWidth;
|
|
m_RasterHeight = m_BoxSize * m_Picture->height() + m_HeaderHeight;
|
|
|
|
m_OffsetX = (width() - m_RasterWidth) / 2;
|
|
m_OffsetY = (height() - m_RasterHeight) / 2;
|
|
|
|
int clockHeight = m_Notifier->isVisible() ? m_HeaderHeight - m_Notifier->sizeHint().height() /* * 3.0 / 4.0 */ : m_HeaderHeight;
|
|
|
|
if (m_Clock)
|
|
m_Clock->setGeometry(m_OffsetX, m_OffsetY, m_HeaderWidth, clockHeight);
|
|
if (m_Notifier && m_Notifier->isVisible())
|
|
m_Notifier->setGeometry(m_OffsetX, m_OffsetY + clockHeight, m_HeaderWidth, m_Notifier->sizeHint().height());
|
|
}
|
|
|
|
void CCrossFieldWidget::mousePressEvent(QMouseEvent * event) {
|
|
if (m_Paused)
|
|
return;
|
|
|
|
int pressedX = event->x() - m_OffsetX;
|
|
int pressedY = event->y() - m_OffsetY;
|
|
|
|
if (pressedX < m_HeaderWidth || pressedY < m_HeaderHeight || pressedX >= m_RasterWidth || pressedY >= m_RasterHeight)
|
|
return;
|
|
|
|
pressedX = (pressedX - m_HeaderWidth) / m_BoxSize;
|
|
pressedY = (pressedY - m_HeaderHeight) / m_BoxSize;
|
|
|
|
|
|
if (event->button() == Qt::RightButton)
|
|
m_MouseMark = CMT_CROSSED;
|
|
else
|
|
m_MouseMark = CMT_MARKED;
|
|
|
|
if (m_OverlayData[pressedX][pressedY] == m_MouseMark)
|
|
m_MouseMark = CMT_UNMARKED;
|
|
|
|
execMark(pressedX, pressedY);
|
|
update();
|
|
}
|
|
|
|
void CCrossFieldWidget::mouseMoveEvent(QMouseEvent * event) {
|
|
if (m_Paused)
|
|
return;
|
|
|
|
if (m_MouseMark == CMT_NONE)
|
|
return;
|
|
|
|
int pressedX = event->x() - m_OffsetX;
|
|
int pressedY = event->y() - m_OffsetY;
|
|
|
|
if (pressedX < m_HeaderWidth || pressedY < m_HeaderHeight || pressedX >= m_RasterWidth || pressedY >= m_RasterHeight)
|
|
return;
|
|
|
|
pressedX = (pressedX - m_HeaderWidth) / m_BoxSize;
|
|
pressedY = (pressedY - m_HeaderHeight) / m_BoxSize;
|
|
|
|
if (m_OverlayData[pressedX][pressedY] != m_MouseMark) {
|
|
execMark(pressedX, pressedY);
|
|
update();
|
|
}
|
|
}
|
|
|
|
void CCrossFieldWidget::mouseReleaseEvent(QMouseEvent *) {
|
|
m_MouseMark = CMT_NONE;
|
|
}
|
|
}
|