1073 lines
24 KiB
C++
1073 lines
24 KiB
C++
#include "BasePreview.h"
|
|
|
|
#include <QVector>
|
|
#include <QPainter>
|
|
#include <QTimer>
|
|
#include <QWheelEvent>
|
|
#include <QLabel>
|
|
#include <QMenu>
|
|
#include <QThread>
|
|
#include <QMutex>
|
|
#include <cassert>
|
|
#include <cmath>
|
|
#include "System.h"
|
|
#include "PackStream.h"
|
|
#include "Base2dPreviewRenderer.h"
|
|
#include "PreviewOsd.h"
|
|
#include "ColorProfile.h"
|
|
|
|
/*************** PreviewChunk ***************/
|
|
class PreviewChunk
|
|
{
|
|
public:
|
|
|
|
PreviewChunk(BasePreview* preview, int xstart, int ystart, int xsize, int ysize)
|
|
{
|
|
_preview = preview;
|
|
_xstart = xstart;
|
|
_ystart = ystart;
|
|
_xsize = xsize;
|
|
_ysize = ysize;
|
|
|
|
_need_render = true;
|
|
_rendering = false;
|
|
_alive = true;
|
|
_priority = xstart;
|
|
}
|
|
|
|
inline BasePreview* preview()
|
|
{
|
|
return _preview;
|
|
}
|
|
|
|
inline int priority()
|
|
{
|
|
return _priority;
|
|
}
|
|
|
|
inline bool isOnFront()
|
|
{
|
|
return _preview->isVisible();// && _preview->window()->isActiveWindow();
|
|
}
|
|
|
|
bool isFrom(BasePreview* preview)
|
|
{
|
|
return _preview == preview;
|
|
}
|
|
|
|
void interrupt()
|
|
{
|
|
_alive = false;
|
|
}
|
|
|
|
void update()
|
|
{
|
|
_priority = _xstart;
|
|
_need_render = true;
|
|
}
|
|
|
|
bool render()
|
|
{
|
|
bool changed = false;
|
|
int revision;
|
|
|
|
if (_rendering)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
_rendering = true;
|
|
_alive = true;
|
|
|
|
if (_need_render)
|
|
{
|
|
if (!isOnFront())
|
|
{
|
|
_priority = -1;
|
|
_rendering = false;
|
|
return false;
|
|
}
|
|
|
|
_need_render = false;
|
|
|
|
QImage pixbuf = _preview->startChunkTransaction(_xstart, _ystart, _xsize, _ysize, &revision);
|
|
|
|
for (int x = 0; x < _xsize; x++)
|
|
{
|
|
for (int y = 0; y < _ysize; y++)
|
|
{
|
|
QRgb col = pixbuf.pixel(x, y);
|
|
if (!_alive)
|
|
{
|
|
_need_render = true;
|
|
_preview->rollbackChunkTransaction();
|
|
_rendering = false;
|
|
return true;
|
|
}
|
|
if (qAlpha(col) < 255)
|
|
{
|
|
QColor newcol = _preview->getPixelColor(_xstart + x, _ystart + y);
|
|
newcol.setAlpha(255);
|
|
|
|
pixbuf.setPixel(x, y, newcol.rgb());
|
|
|
|
changed = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (changed)
|
|
{
|
|
_need_render = not _preview->commitChunkTransaction(pixbuf, _xstart, _ystart, _xsize, _ysize, revision);
|
|
}
|
|
else
|
|
{
|
|
_preview->rollbackChunkTransaction();
|
|
}
|
|
}
|
|
|
|
if (not _need_render)
|
|
{
|
|
_priority = -1;
|
|
}
|
|
|
|
_rendering = false;
|
|
return _need_render;
|
|
}
|
|
private:
|
|
BasePreview* _preview;
|
|
int _priority;
|
|
bool _alive;
|
|
bool _need_render;
|
|
bool _rendering;
|
|
int _xstart;
|
|
int _ystart;
|
|
int _xsize;
|
|
int _ysize;
|
|
};
|
|
|
|
class PreviewDrawingThread;
|
|
class PreviewDrawingManager
|
|
{
|
|
public:
|
|
PreviewDrawingManager();
|
|
void startThreads();
|
|
void stopThreads();
|
|
void addChunk(PreviewChunk* chunk);
|
|
void removeChunks(BasePreview* preview);
|
|
void updateChunks(BasePreview* preview);
|
|
void suspendChunks(BasePreview* preview);
|
|
void updateAllChunks();
|
|
void performOneThreadJob();
|
|
int chunkCount();
|
|
|
|
private:
|
|
int _thread_count;
|
|
QVector<PreviewDrawingThread*> _threads;
|
|
QVector<PreviewChunk*> _chunks;
|
|
QList<PreviewChunk*> _updateQueue;
|
|
QMutex _lock;
|
|
};
|
|
|
|
static PreviewDrawingManager* _drawing_manager = NULL;
|
|
|
|
/*************** PreviewDrawingThread ***************/
|
|
class PreviewDrawingThread : public QThread
|
|
{
|
|
public:
|
|
PreviewDrawingThread();
|
|
void askStop();
|
|
|
|
static inline void usleep(int us)
|
|
{
|
|
QThread::usleep(us);
|
|
}
|
|
|
|
protected:
|
|
void run();
|
|
|
|
private:
|
|
bool _running;
|
|
};
|
|
|
|
PreviewDrawingThread::PreviewDrawingThread() :
|
|
QThread()
|
|
{
|
|
_running = false;
|
|
}
|
|
|
|
void PreviewDrawingThread::askStop()
|
|
{
|
|
_running = false;
|
|
}
|
|
|
|
void PreviewDrawingThread::run()
|
|
{
|
|
_running = true;
|
|
while (_running)
|
|
{
|
|
_drawing_manager->performOneThreadJob();
|
|
QThread::usleep(5000);
|
|
}
|
|
}
|
|
|
|
/*************** PreviewDrawingManager ***************/
|
|
PreviewDrawingManager::PreviewDrawingManager()
|
|
{
|
|
_thread_count = System::getCoreCount();
|
|
}
|
|
|
|
void PreviewDrawingManager::startThreads()
|
|
{
|
|
for (int i = 0; i < _thread_count; i++)
|
|
{
|
|
PreviewDrawingThread* thread = new PreviewDrawingThread();
|
|
_threads.append(thread);
|
|
thread->start();
|
|
}
|
|
}
|
|
|
|
void PreviewDrawingManager::stopThreads()
|
|
{
|
|
qDebug("[Previews] Stopping all render threads");
|
|
for (int i = 0; i < _threads.size(); i++)
|
|
{
|
|
_threads.at(i)->askStop();
|
|
}
|
|
for (int i = 0; i < _chunks.size(); i++)
|
|
{
|
|
_chunks.at(i)->interrupt();
|
|
}
|
|
for (int i = 0; i < _threads.size(); i++)
|
|
{
|
|
_threads.at(i)->wait();
|
|
}
|
|
}
|
|
|
|
void PreviewDrawingManager::addChunk(PreviewChunk* chunk)
|
|
{
|
|
_lock.lock();
|
|
_chunks.append(chunk);
|
|
_updateQueue.append(chunk);
|
|
_lock.unlock();
|
|
}
|
|
|
|
void PreviewDrawingManager::removeChunks(BasePreview* preview)
|
|
{
|
|
int removed = 0;
|
|
for (int i = 0; i < _chunks.size(); i++)
|
|
{
|
|
PreviewChunk* chunk;
|
|
chunk = _chunks.at(i);
|
|
if (chunk->isFrom(preview))
|
|
{
|
|
_lock.lock();
|
|
_chunks.remove(i);
|
|
_updateQueue.removeAll(chunk);
|
|
_lock.unlock();
|
|
|
|
removed++;
|
|
i--;
|
|
}
|
|
}
|
|
|
|
qDebug("[Previews] %d chunks removed, %d remaining", removed, _chunks.size());
|
|
}
|
|
|
|
void PreviewDrawingManager::suspendChunks(BasePreview* preview)
|
|
{
|
|
_lock.lock();
|
|
for (int i = 0; i < _updateQueue.size(); i++)
|
|
{
|
|
PreviewChunk* chunk;
|
|
chunk = _updateQueue.at(i);
|
|
if (chunk->isFrom(preview))
|
|
{
|
|
_updateQueue.takeAt(i);
|
|
i--;
|
|
}
|
|
}
|
|
for (int i = 0; i < _chunks.size(); i++)
|
|
{
|
|
_chunks.at(i)->interrupt();
|
|
}
|
|
_lock.unlock();
|
|
}
|
|
|
|
void PreviewDrawingManager::updateChunks(BasePreview* preview)
|
|
{
|
|
for (int i = 0; i < _chunks.size(); i++)
|
|
{
|
|
PreviewChunk* chunk;
|
|
chunk = _chunks.at(i);
|
|
if (chunk->isFrom(preview))
|
|
{
|
|
chunk->update();
|
|
_lock.lock();
|
|
if (!_updateQueue.contains(chunk))
|
|
{
|
|
_updateQueue.prepend(chunk);
|
|
}
|
|
_lock.unlock();
|
|
}
|
|
}
|
|
}
|
|
|
|
void PreviewDrawingManager::updateAllChunks()
|
|
{
|
|
qDebug("[Previews] Reviving all %d preview chunks", _chunks.size());
|
|
for (int i = 0; i < _chunks.size(); i++)
|
|
{
|
|
PreviewChunk* chunk;
|
|
chunk = _chunks.at(i);
|
|
if (chunk->isOnFront())
|
|
{
|
|
chunk->update();
|
|
_lock.lock();
|
|
if (!_updateQueue.contains(chunk))
|
|
{
|
|
_updateQueue.prepend(chunk);
|
|
}
|
|
_lock.unlock();
|
|
}
|
|
}
|
|
}
|
|
|
|
static bool _cmpChunkPriority(const PreviewChunk* chunk1, const PreviewChunk* chunk2)
|
|
{
|
|
return ((PreviewChunk*)chunk1)->priority() < ((PreviewChunk*)chunk2)->priority();
|
|
}
|
|
|
|
|
|
void PreviewDrawingManager::performOneThreadJob()
|
|
{
|
|
PreviewChunk* chunk;
|
|
|
|
chunk = NULL;
|
|
_lock.lock();
|
|
if (!_updateQueue.isEmpty())
|
|
{
|
|
qSort(_updateQueue.begin(), _updateQueue.end(), _cmpChunkPriority);
|
|
chunk = _updateQueue.takeFirst();
|
|
}
|
|
_lock.unlock();
|
|
|
|
if (chunk)
|
|
{
|
|
if (chunk->render())
|
|
{
|
|
_lock.lock();
|
|
if (!_updateQueue.contains(chunk))
|
|
{
|
|
_updateQueue.append(chunk);
|
|
}
|
|
_lock.unlock();
|
|
}
|
|
}
|
|
}
|
|
|
|
int PreviewDrawingManager::chunkCount()
|
|
{
|
|
return _chunks.size();
|
|
}
|
|
|
|
/*************** BasePreview ***************/
|
|
BasePreview::BasePreview(QWidget* parent) :
|
|
DrawingWidget(parent)
|
|
{
|
|
this->_lock_drawing = new QMutex();
|
|
|
|
this->conf_scroll_xmin = 0.0;
|
|
this->conf_scroll_xmax = 0.0;
|
|
this->conf_scroll_xinit = 0.0;
|
|
this->conf_scroll_ymin = 0.0;
|
|
this->conf_scroll_ymax = 0.0;
|
|
this->conf_scroll_yinit = 0.0;
|
|
this->conf_scale_min = 1.0;
|
|
this->conf_scale_max = 1.0;
|
|
this->conf_scale_init = 1.0;
|
|
this->conf_scale_step = 0.0;
|
|
this->conf_scroll_logarithmic = false;
|
|
this->scaling = 1.0;
|
|
this->scalingbase = 1.0;
|
|
this->xoffset = 0.0;
|
|
this->yoffset = 0.0;
|
|
this->_pixbuf = new QImage(this->size(), QImage::Format_ARGB32);
|
|
this->_pixbuf->fill(0x00000000);
|
|
_width = width();
|
|
_height = height();
|
|
_revision = 0;
|
|
_transactions_count = 0;
|
|
_redraw_requested = false;
|
|
|
|
_renderer = NULL;
|
|
|
|
_info = new QLabel(this);
|
|
_info->setVisible(false);
|
|
_info->setStyleSheet("QLabel { background-color: white; color: black; }");
|
|
|
|
_hdr_enabled = false;
|
|
_hdr_profile = new ColorProfile;
|
|
|
|
this->alive = true;
|
|
|
|
QObject::connect(this, SIGNAL(contentChange()), this, SLOT(update()));
|
|
|
|
setMinimumSize(10, 10);
|
|
|
|
startTimer(50);
|
|
}
|
|
|
|
BasePreview::~BasePreview()
|
|
{
|
|
alive = false;
|
|
|
|
delete _hdr_profile;
|
|
|
|
_drawing_manager->removeChunks(this);
|
|
|
|
delete _info;
|
|
delete _pixbuf;
|
|
delete _lock_drawing;
|
|
}
|
|
|
|
void BasePreview::setRenderer(Base2dPreviewRenderer* renderer)
|
|
{
|
|
_renderer = renderer;
|
|
_renderer->bindEvent(this);
|
|
}
|
|
|
|
void BasePreview::configHdrToneMapping(bool active)
|
|
{
|
|
_hdr_enabled = active;
|
|
redraw();
|
|
}
|
|
|
|
void BasePreview::addOsd(QString name)
|
|
{
|
|
_osd.append(PreviewOsd::getInstance(name));
|
|
setMouseTracking(true);
|
|
}
|
|
|
|
void BasePreview::savePack(PackStream* stream)
|
|
{
|
|
stream->write(&this->xoffset);
|
|
stream->write(&this->yoffset);
|
|
stream->write(&this->scalingbase);
|
|
|
|
// TODO Save choices and toggles
|
|
}
|
|
|
|
void BasePreview::loadPack(PackStream* stream)
|
|
{
|
|
stream->read(&this->xoffset);
|
|
stream->read(&this->yoffset);
|
|
stream->read(&this->scalingbase);
|
|
|
|
// TODO Save choices and toggles
|
|
|
|
updateScaling();
|
|
emit contentChange();
|
|
}
|
|
|
|
void BasePreview::initDrawers()
|
|
{
|
|
_drawing_manager = new PreviewDrawingManager();
|
|
_drawing_manager->startThreads();
|
|
}
|
|
|
|
void BasePreview::stopDrawers()
|
|
{
|
|
_drawing_manager->stopThreads();
|
|
}
|
|
|
|
void BasePreview::reviveAll()
|
|
{
|
|
_drawing_manager->updateAllChunks();
|
|
}
|
|
|
|
void BasePreview::updateData()
|
|
{
|
|
if (_renderer)
|
|
{
|
|
_renderer->updateEvent();
|
|
}
|
|
}
|
|
|
|
void BasePreview::cameraEvent()
|
|
{
|
|
if (_renderer)
|
|
{
|
|
_renderer->cameraEvent(xoffset, yoffset, scaling);
|
|
}
|
|
}
|
|
|
|
Color BasePreview::getColor(double x, double y)
|
|
{
|
|
if (_renderer)
|
|
{
|
|
return _renderer->getColor2D(x, y, scaling);
|
|
}
|
|
else
|
|
{
|
|
return COLOR_BLACK;
|
|
}
|
|
}
|
|
|
|
void BasePreview::configScaling(double min, double max, double step, double init, bool logarithmic)
|
|
{
|
|
double size = (double) width();
|
|
|
|
if (size >= 1.0)
|
|
{
|
|
conf_scale_min = min / size;
|
|
conf_scale_max = max / size;
|
|
conf_scale_step = step / size;
|
|
conf_scale_init = init / size;
|
|
conf_scroll_logarithmic = logarithmic;
|
|
scalingbase = init / size;
|
|
if (conf_scroll_logarithmic && conf_scale_max - conf_scale_min > 0.0000001)
|
|
{
|
|
scalingbase = pow((scalingbase - conf_scale_min) / (conf_scale_max - conf_scale_min), 0.5) * (conf_scale_max - conf_scale_min) + conf_scale_min;
|
|
}
|
|
|
|
updateScaling();
|
|
redraw();
|
|
}
|
|
}
|
|
|
|
void BasePreview::configScrolling(double xmin, double xmax, double xinit, double ymin, double ymax, double yinit)
|
|
{
|
|
conf_scroll_xmin = xmin;
|
|
conf_scroll_xmax = xmax;
|
|
conf_scroll_xinit = xinit;
|
|
conf_scroll_ymin = ymin;
|
|
conf_scroll_ymax = ymax;
|
|
conf_scroll_yinit = yinit;
|
|
xoffset = xinit;
|
|
yoffset = yinit;
|
|
redraw();
|
|
}
|
|
|
|
void BasePreview::addChoice(const QString &key, const QString &title, const QStringList &choices, int init_value)
|
|
{
|
|
_ContextChoice choice;
|
|
choice.title = title;
|
|
choice.items << choices;
|
|
choice.current = init_value;
|
|
|
|
_choices.insert(key, choice);
|
|
|
|
choiceChangeEvent(key, init_value);
|
|
}
|
|
|
|
void BasePreview::choiceChangeEvent(const QString &key, int position)
|
|
{
|
|
if (_renderer)
|
|
{
|
|
_renderer->choiceChangeEvent(key.toStdString(), position);
|
|
}
|
|
redraw();
|
|
}
|
|
|
|
void BasePreview::addToggle(const QString &key, const QString &text, bool init_value)
|
|
{
|
|
_ContextToggle toggle;
|
|
toggle.title = text;
|
|
toggle.value = init_value;
|
|
|
|
_toggles.insert(key, toggle);
|
|
|
|
toggleChangeEvent(key, init_value);
|
|
}
|
|
|
|
void BasePreview::toggleChangeEvent(const QString &key, bool value)
|
|
{
|
|
if (_renderer)
|
|
{
|
|
_renderer->toggleChangeEvent(key.toStdString(), value);
|
|
}
|
|
redraw();
|
|
}
|
|
|
|
void BasePreview::redraw()
|
|
{
|
|
_drawing_manager->suspendChunks(this);
|
|
_redraw_requested = true;
|
|
}
|
|
|
|
QImage BasePreview::startChunkTransaction(int x, int y, int w, int h, int* revision)
|
|
{
|
|
QImage result;
|
|
|
|
_lock_drawing->lock();
|
|
|
|
*revision = _revision;
|
|
result = _pixbuf->copy(x, y, w, h);
|
|
_transactions_count++;
|
|
|
|
_lock_drawing->unlock();
|
|
|
|
return result;
|
|
}
|
|
|
|
bool BasePreview::commitChunkTransaction(const QImage &chunk, int x, int y, int w, int h, int revision)
|
|
{
|
|
bool result;
|
|
|
|
_lock_drawing->lock();
|
|
|
|
if (revision == _revision)
|
|
{
|
|
QPainter painter(_pixbuf);
|
|
painter.drawImage(x, y, chunk, 0, 0, w, h);
|
|
emit contentChange();
|
|
result = true;
|
|
}
|
|
else
|
|
{
|
|
result = false;
|
|
}
|
|
|
|
_transactions_count--;
|
|
|
|
_lock_drawing->unlock();
|
|
|
|
return result;
|
|
}
|
|
|
|
void BasePreview::rollbackChunkTransaction()
|
|
{
|
|
_lock_drawing->lock();
|
|
|
|
_transactions_count--;
|
|
|
|
_lock_drawing->unlock();
|
|
}
|
|
|
|
QColor BasePreview::getPixelColor(int x, int y)
|
|
{
|
|
Color col = getColor((double) (x - _width / 2) * scaling + xoffset, (double) (y - _height / 2) * scaling + yoffset);
|
|
if (_hdr_enabled)
|
|
{
|
|
col = _hdr_profile->apply(col);
|
|
}
|
|
col.normalize();
|
|
return QColor::fromRgbF(col.r, col.g, col.b, col.a);
|
|
}
|
|
|
|
void BasePreview::timerEvent(QTimerEvent*)
|
|
{
|
|
_lock_drawing->lock();
|
|
|
|
if (_redraw_requested && _transactions_count == 0)
|
|
{
|
|
updateData();
|
|
invalidatePixbuf(128);
|
|
_redraw_requested = false;
|
|
}
|
|
|
|
_lock_drawing->unlock();
|
|
}
|
|
|
|
void BasePreview::choiceSelected(QAction* action)
|
|
{
|
|
switch (action->property("mode").toInt())
|
|
{
|
|
case 1:
|
|
{
|
|
QString key = action->property("key").toString();
|
|
int value = action->property("value").toInt();
|
|
|
|
_choices[key].current = value;
|
|
|
|
choiceChangeEvent(key, value);
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
QString key = action->property("key").toString();
|
|
bool value = action->property("value").toBool();
|
|
|
|
_toggles[key].value = value;
|
|
|
|
toggleChangeEvent(key, value);
|
|
break;
|
|
}
|
|
default:
|
|
;
|
|
}
|
|
}
|
|
|
|
void BasePreview::showEvent(QShowEvent*)
|
|
{
|
|
updateChunks();
|
|
}
|
|
|
|
void BasePreview::resizeEvent(QResizeEvent* event)
|
|
{
|
|
QImage* image;
|
|
int added = 0;
|
|
|
|
this->_lock_drawing->lock();
|
|
|
|
image = this->_pixbuf;
|
|
|
|
_width = event->size().width();
|
|
_height = event->size().height();
|
|
|
|
this->_pixbuf = new QImage(this->size(), QImage::Format_ARGB32);
|
|
|
|
this->_pixbuf->fill(0x00000000);
|
|
|
|
_drawing_manager->removeChunks(this);
|
|
for (int x = 0; x < _width; x += 32)
|
|
{
|
|
for (int y = 0; y < _height; y += 32)
|
|
{
|
|
_drawing_manager->addChunk(new PreviewChunk(this, x, y, x + 32 > _width ? _width - x : 32, y + 32 > _height ? _height - y : 32));
|
|
added++;
|
|
}
|
|
}
|
|
qDebug("[Previews] %d chunks added, %d total", added, _drawing_manager->chunkCount());
|
|
|
|
delete image;
|
|
|
|
_revision++;
|
|
|
|
this->_lock_drawing->unlock();
|
|
}
|
|
|
|
void BasePreview::doDrawing(QPainter* painter)
|
|
{
|
|
if (isEnabled())
|
|
{
|
|
painter->drawImage(0, 0, *this->_pixbuf);
|
|
|
|
QImage osd(_pixbuf->size(), _pixbuf->format());
|
|
osd.fill(0x00000000);
|
|
for (int i = 0; i < _osd.size(); i++)
|
|
{
|
|
_osd[i]->apply(&osd, xoffset, yoffset, scaling);
|
|
}
|
|
painter->drawImage(0, 0, osd);
|
|
}
|
|
else
|
|
{
|
|
painter->fillRect(rect(), QColor(100, 100, 100));
|
|
}
|
|
}
|
|
|
|
void BasePreview::updateScaling()
|
|
{
|
|
if (conf_scroll_logarithmic && conf_scale_max - conf_scale_min > 0.0000001)
|
|
{
|
|
scaling = pow((scalingbase - conf_scale_min) / (conf_scale_max - conf_scale_min), 2.0) * (conf_scale_max - conf_scale_min) + conf_scale_min;
|
|
}
|
|
else
|
|
{
|
|
scaling = scalingbase;
|
|
}
|
|
}
|
|
|
|
void BasePreview::updateChunks()
|
|
{
|
|
cameraEvent();
|
|
_drawing_manager->updateChunks(this);
|
|
_revision++;
|
|
}
|
|
|
|
void BasePreview::invalidatePixbuf(int value)
|
|
{
|
|
for (int ix = 0; ix < _width; ix++)
|
|
{
|
|
for (int iy = 0; iy < _height; iy++)
|
|
{
|
|
QRgb col = _pixbuf->pixel(ix, iy);
|
|
if (qAlpha(col) == 255)
|
|
{
|
|
_pixbuf->setPixel(ix, iy, qRgba(qRed(col), qGreen(col), qBlue(col), value));
|
|
}
|
|
}
|
|
}
|
|
updateChunks();
|
|
}
|
|
|
|
void BasePreview::contextMenuEvent(QContextMenuEvent* event)
|
|
{
|
|
QMenu menu(this);
|
|
|
|
// TODO Get menu items from OSDs
|
|
|
|
// Fill with choices
|
|
QHashIterator<QString, _ContextChoice> iter1(_choices);
|
|
while (iter1.hasNext())
|
|
{
|
|
if (not menu.isEmpty())
|
|
{
|
|
menu.addSeparator();
|
|
}
|
|
|
|
iter1.next();
|
|
menu.addAction(QString(" %1 ").arg(iter1.value().title))->setDisabled(true);
|
|
|
|
QStringList list = iter1.value().items;
|
|
for (int i = 0; i < list.count(); i++)
|
|
{
|
|
QAction* action = menu.addAction(list[i]);
|
|
action->setProperty("mode", 1);
|
|
action->setProperty("key", iter1.key());
|
|
action->setProperty("value", i);
|
|
if (i == iter1.value().current)
|
|
{
|
|
action->setIcon(QIcon(":/images/choice_on.png"));
|
|
action->setIconVisibleInMenu(true);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Fill with toggles
|
|
QHashIterator<QString, _ContextToggle> iter2(_toggles);
|
|
while (iter2.hasNext())
|
|
{
|
|
if (not menu.isEmpty() and not iter2.hasPrevious())
|
|
{
|
|
menu.addSeparator();
|
|
}
|
|
|
|
iter2.next();
|
|
|
|
QAction* action = menu.addAction(iter2.value().title);
|
|
action->setProperty("mode", 2);
|
|
action->setProperty("key", iter2.key());
|
|
action->setProperty("value", not iter2.value().value);
|
|
if (iter2.value().value)
|
|
{
|
|
action->setIcon(QIcon(":/images/toggle_on.png"));
|
|
action->setIconVisibleInMenu(true);
|
|
}
|
|
}
|
|
|
|
if (not menu.isEmpty())
|
|
{
|
|
connect(&menu, SIGNAL(triggered(QAction*)), this, SLOT(choiceSelected(QAction*)));
|
|
|
|
menu.exec(event->globalPos());
|
|
event->accept();
|
|
}
|
|
}
|
|
|
|
void BasePreview::mousePressEvent(QMouseEvent* event)
|
|
{
|
|
if (event->button() == Qt::LeftButton)
|
|
{
|
|
mousex = event->x();
|
|
mousey = event->y();
|
|
}
|
|
}
|
|
|
|
void BasePreview::mouseMoveEvent(QMouseEvent* event)
|
|
{
|
|
int width, height;
|
|
|
|
width = this->width();
|
|
height = this->height();
|
|
|
|
if (event->buttons() & Qt::LeftButton)
|
|
{
|
|
int dx, dy;
|
|
int ndx, ndy;
|
|
|
|
dx = event->x() - mousex;
|
|
dy = event->y() - mousey;
|
|
|
|
ndx = dx;
|
|
ndy = dy;
|
|
if (xoffset - dx * scaling > conf_scroll_xmax)
|
|
{
|
|
ndx = (int) floor((conf_scroll_xmax - xoffset) / scaling);
|
|
}
|
|
if (xoffset - dx * scaling < conf_scroll_xmin)
|
|
{
|
|
ndx = (int) floor((conf_scroll_xmin - xoffset) / scaling);
|
|
}
|
|
if (yoffset - dy * scaling > conf_scroll_ymax)
|
|
{
|
|
ndy = (int) floor((conf_scroll_ymax - yoffset) / scaling);
|
|
}
|
|
if (yoffset - dy * scaling < conf_scroll_ymin)
|
|
{
|
|
ndy = (int) floor((conf_scroll_ymin - yoffset) / scaling);
|
|
}
|
|
if (ndx != 0 || ndy != 0)
|
|
{
|
|
if (ndx <= -width || ndx >= width || ndy <= -height || ndy >= height)
|
|
{
|
|
xoffset -= (double) ndx * scaling;
|
|
yoffset -= (double) ndy * scaling;
|
|
|
|
_lock_drawing->lock();
|
|
_pixbuf->fill(0x00000000);
|
|
updateChunks();
|
|
_lock_drawing->unlock();
|
|
}
|
|
else
|
|
{
|
|
int xstart, xsize, ystart, ysize;
|
|
|
|
_lock_drawing->lock();
|
|
|
|
xoffset -= (double) ndx * scaling;
|
|
yoffset -= (double) ndy * scaling;
|
|
|
|
if (ndx < 0)
|
|
{
|
|
xstart = -ndx;
|
|
xsize = width + ndx;
|
|
}
|
|
else
|
|
{
|
|
xstart = 0;
|
|
xsize = width - ndx;
|
|
}
|
|
if (ndy < 0)
|
|
{
|
|
ystart = -ndy;
|
|
ysize = height + ndy;
|
|
}
|
|
else
|
|
{
|
|
ystart = 0;
|
|
ysize = height - ndy;
|
|
}
|
|
|
|
QImage part = _pixbuf->copy(xstart, ystart, xsize, ysize);
|
|
_pixbuf->fill(0x00000000);
|
|
QPainter painter(_pixbuf);
|
|
painter.drawImage(xstart + ndx, ystart + ndy, part);
|
|
|
|
updateChunks();
|
|
_lock_drawing->unlock();
|
|
|
|
emit contentChange();
|
|
}
|
|
}
|
|
|
|
mousex = event->x();
|
|
mousey = event->y();
|
|
}
|
|
else
|
|
{
|
|
// Get text info from OSD
|
|
bool found = false;
|
|
for (int i = 0; i < _osd.size(); i++)
|
|
{
|
|
double x = xoffset + (event->x() - width / 2) * scaling;
|
|
double y = yoffset + (event->y() - height / 2) * scaling;
|
|
QString info = _osd[i]->getToolTip(x, y, scaling);
|
|
if (not info.isEmpty())
|
|
{
|
|
_info->setText(info);
|
|
_info->setVisible(true);
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
if (not found)
|
|
{
|
|
_info->setVisible(false);
|
|
}
|
|
}
|
|
}
|
|
|
|
void BasePreview::wheelEvent(QWheelEvent* event)
|
|
{
|
|
double factor;
|
|
double old_scaling;
|
|
int width, height;
|
|
int new_width, new_height;
|
|
|
|
if (event->modifiers() & Qt::ShiftModifier)
|
|
{
|
|
factor = 5.0;
|
|
}
|
|
else if (event->modifiers() & Qt::ControlModifier)
|
|
{
|
|
factor = 0.2;
|
|
}
|
|
else
|
|
{
|
|
factor = 1.0;
|
|
}
|
|
|
|
if (event->orientation() == Qt::Vertical)
|
|
{
|
|
if (event->delta() > 0 && scalingbase > conf_scale_min)
|
|
{
|
|
scalingbase -= factor * conf_scale_step;
|
|
if (scalingbase < conf_scale_min)
|
|
{
|
|
scalingbase = conf_scale_min;
|
|
}
|
|
}
|
|
else if (event->delta() < 0 && scalingbase < conf_scale_max)
|
|
{
|
|
scalingbase += factor * conf_scale_step;
|
|
if (scalingbase > conf_scale_max)
|
|
{
|
|
scalingbase = conf_scale_max;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
event->ignore();
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
event->ignore();
|
|
return;
|
|
}
|
|
|
|
old_scaling = scaling;
|
|
updateScaling();
|
|
|
|
width = _pixbuf->width();
|
|
height = _pixbuf->height();
|
|
|
|
if (scaling < old_scaling)
|
|
{
|
|
_lock_drawing->lock();
|
|
new_width = (int) floor(((double) width) * scaling / old_scaling);
|
|
new_height = (int) floor(((double) height) * scaling / old_scaling);
|
|
QImage part = _pixbuf->copy((width - new_width) / 2, (height - new_height) / 2, new_width, new_height).scaled(width, height, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
|
|
_pixbuf->fill(0x00000000);
|
|
QPainter painter(_pixbuf);
|
|
painter.drawImage(0, 0, part);
|
|
invalidatePixbuf(254);
|
|
_lock_drawing->unlock();
|
|
|
|
emit contentChange();
|
|
}
|
|
else if (scaling > old_scaling)
|
|
{
|
|
_lock_drawing->lock();
|
|
QImage part = _pixbuf->scaled((int) floor(((double) width) * old_scaling / scaling), (int) floor(((double) height) * old_scaling / scaling), Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
|
|
_pixbuf->fill(0x00000000);
|
|
QPainter painter(_pixbuf);
|
|
painter.drawImage((width - part.width()) / 2, (height - part.height()) / 2, part);
|
|
invalidatePixbuf(254);
|
|
_lock_drawing->unlock();
|
|
|
|
emit contentChange();
|
|
}
|
|
|
|
event->accept();
|
|
}
|
|
|
|
void BasePreview::leaveEvent(QEvent*)
|
|
{
|
|
_info->setVisible(false);
|
|
}
|