You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
koffice/chalk/ui/kis_birdeye_box.cpp

312 lines
10 KiB

/*
* Copyright (c) 2004 Kivio Team
* Copyright (c) 2004 Boudewijn Rempt <boud@valdyas.org>
*
* 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#include "tqlayout.h"
#include "tqlabel.h"
#include "tqpixmap.h"
#include "tqpainter.h"
#include "tqimage.h"
#include "config.h"
#include LCMS_HEADER
#include "tdelocale.h"
#include "tqtooltip.h"
#include "kis_view.h"
#include "kis_doc.h"
#include "kis_canvas_controller.h"
#include "kis_birdeye_box.h"
#include "kis_double_widget.h"
#include "kis_canvas.h"
#include "kis_image.h"
#include "kis_rect.h"
#include "kis_iterators_pixel.h"
#include "kobirdeyepanel.h"
namespace {
class CanvasAdapter : public KoCanvasAdapter {
public:
CanvasAdapter(KisCanvasSubject * canvasSubject) : KoCanvasAdapter(), m_canvasSubject(canvasSubject) {}
virtual ~CanvasAdapter() {}
public:
virtual KoRect visibleArea()
{
if (!m_canvasSubject->currentImg()) return KoRect(0,0,0,0);
KisCanvasController * c = m_canvasSubject->canvasController();
if (c && c->kiscanvas())
return c->viewToWindow(KisRect(0, 0, c->kiscanvas()->width(), c->kiscanvas()->height()));
else
return KoRect(0,0,0,0);
}
virtual double zoomFactor()
{
return m_canvasSubject->zoomFactor();
}
virtual TQRect size()
{
if (!m_canvasSubject->currentImg()) return TQRect(0,0,0,0);
return TQRect(0, 0, m_canvasSubject->currentImg()->width(), m_canvasSubject->currentImg()->height());
}
virtual void setViewCenterPoint(double x, double y)
{
m_canvasSubject->canvasController()->zoomAroundPoint(x, y, m_canvasSubject->zoomFactor());
}
private:
KisCanvasSubject * m_canvasSubject;
};
class ZoomListener : public KoZoomAdapter {
public:
ZoomListener(KisCanvasController * canvasController)
: KoZoomAdapter()
, m_canvasController(canvasController) {}
virtual ~ZoomListener() {}
public:
void zoomTo( double x, double y, double factor ) { m_canvasController->zoomAroundPoint(x, y, factor); }
void zoomIn() { m_canvasController->zoomIn(); }
void zoomOut() { m_canvasController->zoomOut(); }
double getMinZoom() { return (1.0 / 500); }
double getMaxZoom() { return 16.0; }
private:
KisCanvasController * m_canvasController;
};
class ThumbnailProvider : public KoThumbnailAdapter {
public:
ThumbnailProvider(KisImageSP image, KisCanvasSubject* canvasSubject)
: KoThumbnailAdapter()
, m_image(image)
, m_canvasSubject(canvasSubject) {}
virtual ~ThumbnailProvider() {}
public:
virtual TQSize pixelSize()
{
if (!m_image) return TQSize(0, 0);
return TQSize(m_image->width(), m_image->height());
}
virtual TQImage image(TQRect r, TQSize thumbnailSize)
{
if (!m_image || r.isEmpty() || thumbnailSize.width() == 0 || thumbnailSize.height() == 0) {
return TQImage();
}
KisPaintDevice thumbnailRect(m_image->colorSpace(), "thumbnailRect");
KisPaintDeviceSP mergedImage = m_image->projection();
TQ_INT32 imageWidth = m_image->width();
TQ_INT32 imageHeight = m_image->height();
TQ_UINT32 pixelSize = m_image->colorSpace()->pixelSize();
for (TQ_INT32 y = 0; y < r.height(); ++y) {
KisHLineIteratorPixel it = thumbnailRect.createHLineIterator(0, y, r.width(), true);
TQ_INT32 thumbnailY = r.y() + y;
TQ_INT32 thumbnailX = r.x();
TQ_INT32 imageY = (thumbnailY * imageHeight) / thumbnailSize.height();
KisHLineIteratorPixel srcIt = mergedImage -> createHLineIterator(0, imageY, imageWidth, false);
while (!it.isDone()) {
TQ_INT32 imageX = (thumbnailX * imageWidth) / thumbnailSize.width();
TQ_INT32 dx = imageX - srcIt.x();
srcIt += dx;
//KisColor pixelColor = mergedImage->colorAt(imageX, imageY);
memcpy(it.rawData(), srcIt.rawData(), pixelSize);
++it;
++thumbnailX;
}
}
return thumbnailRect.convertToTQImage(m_canvasSubject->monitorProfile(), 0, 0, r.width(), r.height(),
m_canvasSubject->HDRExposure());
}
void setImage(KisImageSP image)
{
m_image = image;
}
private:
KisImageSP m_image;
KisCanvasSubject * m_canvasSubject;
};
}
KisBirdEyeBox::KisBirdEyeBox(KisView * view, TQWidget* parent, const char* name)
: TQWidget(parent, name)
, m_view(view)
, m_subject(view->canvasSubject())
{
TQVBoxLayout * l = new TQVBoxLayout(this);
m_image = m_subject->currentImg();
m_zoomAdapter = new ZoomListener(m_subject->canvasController()); // The birdeye panel deletes
KoThumbnailAdapter * ktp = new ThumbnailProvider(m_image, m_subject); // The birdeye panel deletes
KoCanvasAdapter * kpc = new CanvasAdapter(m_subject); // The birdeye panel deletes
m_birdEyePanel = new KoBirdEyePanel(m_zoomAdapter, ktp, kpc, this);
connect(view, TQT_SIGNAL(cursorPosition( TQ_INT32, TQ_INT32 )), m_birdEyePanel, TQT_SLOT(cursorPosChanged( TQ_INT32, TQ_INT32 )));
connect(view, TQT_SIGNAL(viewTransformationsChanged()), m_birdEyePanel, TQT_SLOT(slotViewTransformationChanged()));
l->addWidget(m_birdEyePanel);
TQHBoxLayout * hl = new TQHBoxLayout(l);
m_exposureLabel = new TQLabel(i18n("Exposure:"), this);
hl->addWidget(m_exposureLabel);
m_exposureDoubleWidget = new KisDoubleWidget(-10, 10, this);
m_exposureDoubleWidget->setSizePolicy(TQSizePolicy::Expanding, TQSizePolicy::Fixed);
hl->addWidget(m_exposureDoubleWidget);
TQToolTip::add(m_exposureDoubleWidget, i18n("Select the exposure (stops) for HDR images"));
l->addItem(new TQSpacerItem(0, 1, TQSizePolicy::Minimum, TQSizePolicy::MinimumExpanding));
m_exposureDoubleWidget->setPrecision(1);
m_exposureDoubleWidget->setValue(0);
m_exposureDoubleWidget->setLineStep(0.1);
m_exposureDoubleWidget->setPageStep(1);
connect(m_exposureDoubleWidget, TQT_SIGNAL(valueChanged(double)), TQT_SLOT(exposureValueChanged(double)));
connect(m_exposureDoubleWidget, TQT_SIGNAL(sliderPressed()), TQT_SLOT(exposureSliderPressed()));
connect(m_exposureDoubleWidget, TQT_SIGNAL(sliderReleased()), TQT_SLOT(exposureSliderReleased()));
m_draggingExposureSlider = false;
Q_ASSERT(m_subject->document() != 0);
connect(m_subject->document(), TQT_SIGNAL(sigCommandExecuted()), TQT_SLOT(slotDocCommandExecuted()));
if (m_image) {
connect(m_image, TQT_SIGNAL(sigImageUpdated(TQRect)), TQT_SLOT(slotImageUpdated(TQRect)));
}
}
KisBirdEyeBox::~KisBirdEyeBox()
{
// Huh? Why does this cause a crash?
// delete m_zoomAdapter;
}
void KisBirdEyeBox::setImage(KisImageSP image)
{
if (m_image) {
m_image->disconnect(this);
}
m_image = image;
KoThumbnailAdapter * ktp = new ThumbnailProvider(m_image, m_subject);
m_birdEyePanel->setThumbnailProvider(ktp);
if (m_image) {
connect(m_image, TQT_SIGNAL(sigImageUpdated(TQRect)), TQT_SLOT(slotImageUpdated(TQRect)));
connect(m_image, TQT_SIGNAL(sigSizeChanged(TQ_INT32, TQ_INT32)), TQT_SLOT(slotImageSizeChanged(TQ_INT32, TQ_INT32)));
connect(m_image, TQT_SIGNAL(sigColorSpaceChanged(KisColorSpace *)), TQT_SLOT(slotImageColorSpaceChanged(KisColorSpace *)));
m_birdEyePanel->slotUpdate(m_image->bounds());
slotImageColorSpaceChanged(m_image->colorSpace());
}
}
void KisBirdEyeBox::slotDocCommandExecuted()
{
if (m_image) {
if (!m_dirtyRect.isEmpty()) {
m_birdEyePanel->slotUpdate(m_dirtyRect);
}
m_dirtyRect = TQRect();
}
}
void KisBirdEyeBox::slotImageUpdated(TQRect r)
{
m_dirtyRect |= r;
}
void KisBirdEyeBox::slotImageSizeChanged(TQ_INT32 /*w*/, TQ_INT32 /*h*/)
{
if (m_image) {
m_birdEyePanel->slotUpdate(m_image->bounds());
}
}
void KisBirdEyeBox::slotImageColorSpaceChanged(KisColorSpace *cs)
{
if (cs->hasHighDynamicRange()) {
m_exposureDoubleWidget->show();
m_exposureLabel->show();
} else {
m_exposureDoubleWidget->hide();
m_exposureLabel->hide();
}
}
void KisBirdEyeBox::exposureValueChanged(double exposure)
{
if (!m_draggingExposureSlider) {
m_subject->setHDRExposure(exposure);
if (m_image && m_image->colorSpace()->hasHighDynamicRange()) {
m_birdEyePanel->slotUpdate(m_image->bounds());
}
}
}
void KisBirdEyeBox::exposureSliderPressed()
{
m_draggingExposureSlider = true;
}
void KisBirdEyeBox::exposureSliderReleased()
{
m_draggingExposureSlider = false;
exposureValueChanged(m_exposureDoubleWidget->value());
}
#include "kis_birdeye_box.moc"