void KWCanvasBase::paintGrid(QPainter &painter, KWViewMode::ViewMap &vm)
{
painter.save();
painter.translate(-vm.distance.x(), -vm.distance.y());
painter.setRenderHint(QPainter::Antialiasing, false);
const QRectF clipRect = viewConverter()->viewToDocument(vm.clipRect);
document()->gridData().paintGrid(painter, *(viewConverter()), clipRect);
document()->guidesData().paintGuides(painter, *(viewConverter()), clipRect);
painter.restore();
}
void KWCanvasBase::paint(QPainter &painter, const QRectF &paintRect)
{
painter.translate(-m_documentOffset);
static int iteration = 0;
iteration++;
if (m_viewMode->hasPages()) {
int pageContentArea = 0;
if (!m_cacheEnabled || !m_pageCacheManager) { // no caching, simple case
QList<KWViewMode::ViewMap> map =
m_viewMode->mapExposedRects(paintRect.translated(m_documentOffset),
viewConverter());
foreach (KWViewMode::ViewMap vm, map) {
painter.save();
// Set up the painter to clip the part of the canvas that contains the rect.
painter.translate(vm.distance.x(), vm.distance.y());
vm.clipRect = vm.clipRect.adjusted(-1, -1, 1, 1);
painter.setClipRect(vm.clipRect);
// Paint the background of the page.
QColor color = Qt::white;
#ifdef DEBUG_REPAINT
color = QColor(random() % 255, random() % 255, random() % 255);
#endif
painter.fillRect(vm.clipRect, QBrush(color));
// Paint the contents of the page.
painter.setRenderHint(QPainter::Antialiasing);
m_shapeManager->paint(painter, *(viewConverter()), false); // Paint all shapes
paintBorder(painter, vm);
// Paint the page decorations: shadow, etc.
paintPageDecorations(painter, vm);
// Paint the grid
paintGrid(painter, vm);
// paint whatever the tool wants to paint
m_toolProxy->paint(painter, *(viewConverter()));
painter.restore();
int contentArea = vm.clipRect.width() * vm.clipRect.height();
if (contentArea > pageContentArea) {
pageContentArea = contentArea;
}
}
QVariant KoPACanvas::inputMethodQuery(Qt::InputMethodQuery query) const
{
if (query == Qt::ImMicroFocus) {
QRectF rect = (toolProxy()->inputMethodQuery(query, *(viewConverter())).toRectF()).toRect();
QPointF scroll(canvasController()->scrollBarValue());
if (canvasController()->canvasMode() == KoCanvasController::Spreadsheet &&
canvasWidget()->layoutDirection() == Qt::RightToLeft) {
scroll.setX(-scroll.x());
}
rect.translate(documentOrigin() - scroll);
return rect.toRect();
}
return toolProxy()->inputMethodQuery(query, *(viewConverter()) );
}
void KChartCanvas::updateCanvas( const QRectF& clipRect )
{
QRect rect( viewToWidget( viewConverter()->documentToView( clipRect ).toRect() ) );
rect.adjust( -2, -2, 2, 2 ); // grow for anti-aliasing
rect.moveTopLeft( rect.topLeft() - m_documentOffset );
update( rect );
}
void KisImageViewConverterTest::testViewToDocument()
{
const KoColorSpace * colorSpace = KoColorSpaceRegistry::instance()->rgb8();
KisImageSP image = new KisImage(0, 512, 512, colorSpace, "test");
KisImageViewConverter viewConverter(image);
image->setResolution(1.38888888, 1.38888888);
QVERIFY(viewConverter.viewToDocument(QPointF(0.0, 0.0))
== QPointF(0.0, 0.0));
QPointF f = viewConverter.viewToDocument(QPointF(5, 5));
QVERIFY(f.x() < 3.7 && f.x() > 3.5 && f.y() < 3.7 && f.y() > 3.5);
QRectF r = viewConverter.viewToDocument(QRectF(0.0, 0.0, 5, 5));
QVERIFY(r.width() < 3.7 && r.width() > 3.5
&& r.height() < 3.7 && r.height() > 3.5);
QSizeF s = viewConverter.viewToDocument(QSizeF(1.0, 1.0));
QVERIFY(s.width() < 0.721 && s.width() > 0.719
&& s.height() < 0.721 && s.height() > 0.719);
double x = viewConverter.viewToDocumentX(1.0);
QVERIFY(x < 0.721 && x > 0.719);
double y = viewConverter.viewToDocumentY(1.0);
QVERIFY(y < 0.721 && y > 0.719);
}
void KisImageViewConverterTest::testDocumentToView()
{
const KoColorSpace * colorSpace = KoColorSpaceRegistry::instance()->rgb8();
KisImageSP image = new KisImage(0, 512, 512, colorSpace, "test");
KisImageViewConverter viewConverter(image);
image->setResolution(1.38888888, 1.38888888);
QVERIFY(viewConverter.documentToView(QPointF(0.0, 0.0))
== QPointF(0.0, 0.0));
QPointF f = viewConverter.documentToView(QPointF(3.2, 5.2));
QVERIFY(f.x() < 4.44445 && f.x() > 4.44443 && f.y() < 7.22223 && f.y() > 7.22221);
QRectF r = viewConverter.documentToView(QRectF(0.0, 0.0, 10.0, 10.0));
QVERIFY(r.width() < 13.889 && r.width() > 13.8888
&& r.height() < 13.889 && r.height() > 13.8888);
QSizeF s = viewConverter.documentToView(QSizeF(1.0, 1.0));
QVERIFY(s.width() < 1.3888889 && s.width() > 1.388887
&& s.height() < 1.3888889 && s.height() > 1.388887);
double x = viewConverter.documentToViewX(1.0);
QVERIFY(x < 1.3888889 && x > 1.388887);
double y = viewConverter.documentToViewY(1.0);
QVERIFY(y < 1.3888889 && y > 1.388887);
}
void KoPACanvas::updateCanvas( const QRectF& rc )
{
QRect clipRect(viewToWidget(viewConverter()->documentToView(rc).toRect()));
clipRect.adjust( -2, -2, 2, 2 ); // Resize to fit anti-aliasing
clipRect.moveTopLeft( clipRect.topLeft() - documentOffset());
update( clipRect );
emit canvasUpdated();
}
void KoPACanvas::mousePressEvent( QMouseEvent *event )
{
koPAView()->viewMode()->mousePressEvent(event, viewConverter()->viewToDocument(widgetToView(event->pos() + documentOffset())));
if(!event->isAccepted() && event->button() == Qt::RightButton)
{
showContextMenu( event->globalPos(), toolProxy()->popupActionList() );
}
event->setAccepted( true );
}
void KisImageViewConverterTest::testZoom()
{
const KoColorSpace * colorSpace = KoColorSpaceRegistry::instance()->rgb8();
KisImageSP image = new KisImage(0, 512, 512, colorSpace, "test");
KisImageViewConverter viewConverter(image);
image->setResolution(1.38888888, 5.38888888);
qreal zoomX, zoomY;
viewConverter.zoom(&zoomX, &zoomY);
QVERIFY(zoomX < 1.388889 && zoomX > 1.3888887);
QVERIFY(zoomY < 5.388889 && zoomY > 5.3888887);
}
void KWCanvasBase::paintBorder(QPainter &painter, KWViewMode::ViewMap &viewMap)
{
painter.save();
const QRectF pageRect = viewMap.page.rect();
const KoPageLayout pageLayout = viewMap.page.pageStyle().pageLayout();
qreal zoomX, zoomY;
viewConverter()->zoom(&zoomX, &zoomY);
painter.scale(zoomX, zoomY);
QPointF topLeftCorner = QPointF(pageRect.topLeft() + QPointF(pageLayout.leftMargin,
pageLayout.topMargin));
QPointF bottomRightCorner = QPointF(pageRect.bottomRight() + QPointF(-pageLayout.rightMargin,
-pageLayout.bottomMargin));
QRectF borderRect = QRectF(topLeftCorner, bottomRightCorner);
pageLayout.border.paint(painter, borderRect);
painter.restore();
}
QVariant KChartCanvas::inputMethodQuery( Qt::InputMethodQuery query )
{
return m_toolProxy->inputMethodQuery( query, *( viewConverter() ) );
}
void KoPACanvas::wheelEvent ( QWheelEvent * event )
{
koPAView()->viewMode()->wheelEvent( event, viewConverter()->viewToDocument(widgetToView(event->pos() + documentOffset())));
}
void KoPACanvas::mouseReleaseEvent( QMouseEvent *event )
{
koPAView()->viewMode()->mouseReleaseEvent( event, viewConverter()->viewToDocument(widgetToView(event->pos() + documentOffset())));
}
QPointF KoCanvasBase::viewToDocument(const QPointF &viewPoint) const
{
return viewConverter()->viewToDocument(viewPoint - documentOrigin());;
}
void KFormulaCanvas::mouseMoveEvent( QMouseEvent* e )
{
m_toolProxy->mouseMoveEvent( e, viewConverter()->viewToDocument( e->pos() ) );
}
QRect KoPACanvasBase::viewToWidget(const QRect& r) const
{
return r.translated(viewConverter()->documentToView(d->origin()).toPoint());
}
QPoint KoPACanvasBase::viewToWidget(const QPoint& p) const
{
return p + viewConverter()->documentToView(d->origin()).toPoint();
}
QPoint KoPACanvasBase::documentOrigin() const
{
return viewConverter()->documentToView(d->origin()).toPoint();
}
void KoPAView::initGUI()
{
QGridLayout * gridLayout = new QGridLayout( this );
gridLayout->setMargin( 0 );
gridLayout->setSpacing( 0 );
setLayout( gridLayout );
d->canvas = new KoPACanvas( this, d->doc, this );
KoCanvasControllerWidget *canvasController = new KoCanvasControllerWidget( this );
d->canvasController = canvasController;
d->canvasController->setCanvas( d->canvas );
KoToolManager::instance()->addController( d->canvasController );
KoToolManager::instance()->registerTools( actionCollection(), d->canvasController );
d->zoomController = new KoZoomController( d->canvasController, zoomHandler(), actionCollection());
connect( d->zoomController, SIGNAL( zoomChanged( KoZoomMode::Mode, qreal ) ),
this, SLOT( slotZoomChanged( KoZoomMode::Mode, qreal ) ) );
d->zoomAction = d->zoomController->zoomAction();
// set up status bar message
d->status = new QLabel( QString() );
d->status->setAlignment( Qt::AlignLeft | Qt::AlignVCenter );
d->status->setMinimumWidth( 300 );
addStatusBarItem( d->status, 1 );
connect( KoToolManager::instance(), SIGNAL( changedStatusText( const QString & ) ),
d->status, SLOT( setText( const QString & ) ) );
d->zoomActionWidget = d->zoomAction->createWidget( statusBar() );
addStatusBarItem( d->zoomActionWidget, 0 );
d->zoomController->setZoomMode( KoZoomMode::ZOOM_PAGE );
d->viewModeNormal = new KoPAViewModeNormal( this, d->canvas );
setViewMode(d->viewModeNormal);
// The rulers
d->horizontalRuler = new KoRuler(this, Qt::Horizontal, viewConverter( d->canvas ));
d->horizontalRuler->setShowMousePosition(true);
d->horizontalRuler->setUnit(d->doc->unit());
d->verticalRuler = new KoRuler(this, Qt::Vertical, viewConverter( d->canvas ));
d->verticalRuler->setUnit(d->doc->unit());
d->verticalRuler->setShowMousePosition(true);
new KoRulerController(d->horizontalRuler, d->canvas->resourceManager());
connect(d->doc, SIGNAL(unitChanged(const KoUnit&)),
d->horizontalRuler, SLOT(setUnit(const KoUnit&)));
connect(d->doc, SIGNAL(unitChanged(const KoUnit&)),
d->verticalRuler, SLOT(setUnit(const KoUnit&)));
gridLayout->addWidget(d->horizontalRuler, 0, 1);
gridLayout->addWidget(d->verticalRuler, 1, 0);
gridLayout->addWidget(canvasController, 1, 1 );
connect(d->canvasController->proxyObject, SIGNAL(canvasOffsetXChanged(int)),
this, SLOT(pageOffsetChanged()));
connect(d->canvasController->proxyObject, SIGNAL(canvasOffsetYChanged(int)),
this, SLOT(pageOffsetChanged()));
connect(d->canvasController->proxyObject, SIGNAL(sizeChanged(const QSize&)),
this, SLOT(pageOffsetChanged()));
connect(d->canvasController->proxyObject, SIGNAL(canvasMousePositionChanged(const QPoint&)),
this, SLOT(updateMousePosition(const QPoint&)));
d->verticalRuler->createGuideToolConnection(d->canvas);
d->horizontalRuler->createGuideToolConnection(d->canvas);
KoToolBoxFactory toolBoxFactory(d->canvasController, i18n("Tools") );
if (shell())
{
shell()->createDockWidget( &toolBoxFactory );
connect( canvasController, SIGNAL( toolOptionWidgetsChanged(const QMap<QString, QWidget *> &, QWidget*) ),
shell()->dockerManager(), SLOT( newOptionWidgets(const QMap<QString, QWidget *> &, QWidget*) ) );
}
connect(shapeManager(), SIGNAL(selectionChanged()), this, SLOT(selectionChanged()));
connect(d->canvas, SIGNAL(documentSize(const QSize&)), d->canvasController->proxyObject, SLOT(updateDocumentSize(const QSize&)));
connect(d->canvasController->proxyObject, SIGNAL(moveDocumentOffset(const QPoint&)), d->canvas, SLOT(slotSetDocumentOffset(const QPoint&)));
if (shell()) {
KoPADocumentStructureDockerFactory structureDockerFactory( KoDocumentSectionView::ThumbnailMode, d->doc->pageType() );
d->documentStructureDocker = qobject_cast<KoPADocumentStructureDocker*>( shell()->createDockWidget( &structureDockerFactory ) );
connect( shell()->partManager(), SIGNAL( activePartChanged( KParts::Part * ) ),
d->documentStructureDocker, SLOT( setPart( KParts::Part * ) ) );
connect(d->documentStructureDocker, SIGNAL(pageChanged(KoPAPageBase*)), proxyObject, SLOT(updateActivePage(KoPAPageBase*)));
connect(d->documentStructureDocker, SIGNAL(dockerReset()), this, SLOT(reinitDocumentDocker()));
KoToolManager::instance()->requestToolActivation( d->canvasController );
}
}
QVariant KWCanvasItem::inputMethodQuery(Qt::InputMethodQuery query) const
{
return m_toolProxy->inputMethodQuery(query, *(viewConverter()));
}
void KFormulaCanvas::updateCanvas( const QRectF& rc )
{
update( viewConverter()->documentToView( rc ).toRect() );
}
