kde-extraapps/kompare/komparepart/komparesplitter.cpp

/**************************************************************************
**                              komparesplitter.cpp
**                              -------------------
**      begin                   : Wed Jan 14 2004
**      Copyright 2004-2005 Jeff Snyder  <jeff-webcvsspam@caffeinated.me.uk>
**      Copyright 2007-2011 Kevin Kofler <kevin.kofler@chello.at>
***************************************************************************/

/**************************************************************************
**
**   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.
**
***************************************************************************/

// associated header
#include "komparesplitter.h"

// qt
#include <QtGui/QStyle>
#include <QtCore/QString>
#include <QtCore/QTimer>
#include <QtGui/QScrollBar>
#include <QtCore/QMap>
#include <QtGui/QSplitter>
#include <QtGui/QApplication>
#include <QtGui/QPainter>
#include <QtGui/QPixmap>
#include <QtGui/QKeyEvent>
#include <QtGui/QGridLayout>
#include <QtGui/QResizeEvent>
#include <QtCore/QChildEvent>
#include <QtCore/QEvent>
#include <QtGui/QWheelEvent>

// kde
#include <kdebug.h>
#include <kapplication.h>
#include <kglobalsettings.h>

// kompare
#include "komparelistview.h"
#include "viewsettings.h"
#include "kompareconnectwidget.h"
#include "diffmodel.h"
#include "difference.h"

using namespace Diff2;

KompareSplitter::KompareSplitter( ViewSettings *settings, QWidget *parent ) :
	QSplitter( Qt::Horizontal, parent ),
	m_settings( settings )
{
	QFrame *scrollFrame = static_cast<QFrame *>(parent);

	// Set up the scrollFrame
	scrollFrame->setFrameStyle( QFrame::NoFrame | QFrame::Plain );
	scrollFrame->setLineWidth(scrollFrame->style()->pixelMetric(QStyle::PM_DefaultFrameWidth));
	QGridLayout *pairlayout = new QGridLayout(scrollFrame);
	pairlayout->setSpacing(0);
	pairlayout->setContentsMargins( 0, 0, 0, 0 );
	m_vScroll = new QScrollBar( Qt::Vertical, scrollFrame );
	pairlayout->addWidget( m_vScroll, 0, 1 );
	m_hScroll = new QScrollBar( Qt::Horizontal, scrollFrame );
	pairlayout->addWidget( m_hScroll, 1, 0 );

	new KompareListViewFrame(true, m_settings, this, "source");
	new KompareListViewFrame(false, m_settings, this, "destination");
	pairlayout->addWidget( this, 0, 0 );

	// set up our looks
	setLineWidth( style()->pixelMetric( QStyle::PM_DefaultFrameWidth ) );

	setHandleWidth(50);
	setChildrenCollapsible( false );
	setFrameStyle( QFrame::NoFrame );
	setSizePolicy( QSizePolicy (QSizePolicy::Ignored, QSizePolicy::Ignored ));
	setOpaqueResize( true );
	setFocusPolicy( Qt::WheelFocus );

	connect( this, SIGNAL(configChanged()), SLOT(slotConfigChanged()) );
	connect( this, SIGNAL(configChanged()), SLOT(slotDelayedRepaintHandles()) );
	connect( this, SIGNAL(configChanged()), SLOT(slotDelayedUpdateScrollBars()) );
	
	// scrolling
	connect( m_vScroll, SIGNAL(valueChanged(int)), SLOT(slotScrollToId(int)) );
	connect( m_vScroll, SIGNAL(sliderMoved(int)),  SLOT(slotScrollToId(int)) );
	connect( m_hScroll, SIGNAL(valueChanged(int)), SIGNAL(setXOffset(int)) );
	connect( m_hScroll, SIGNAL(sliderMoved(int)),  SIGNAL(setXOffset(int)) );

	m_scrollTimer=new QTimer(this);
	m_restartTimer = false;
	connect (m_scrollTimer, SIGNAL(timeout()), SLOT(timerTimeout()) );

	// we need to receive childEvents now so that d->list is ready for when
	// slotSetSelection(...) arrives
	kapp->sendPostedEvents(this, QEvent::ChildAdded);

	// init stuff
	slotUpdateScrollBars();
}

KompareSplitter::~KompareSplitter()
{
}

QSplitterHandle* KompareSplitter::createHandle()
{
	return new KompareConnectWidgetFrame(m_settings, this);
}

void KompareSplitter::slotDelayedRepaintHandles()
{
	QTimer::singleShot(0, this, SLOT(slotRepaintHandles()));
}

void KompareSplitter::slotRepaintHandles()
{
	const int end = count();
	for ( int i = 1; i < end; ++i )
		handle(i)->update();
}

void KompareSplitter::timerTimeout()
{
	if ( m_restartTimer )
		m_restartTimer = false;
	else
		m_scrollTimer->stop();

	slotDelayedRepaintHandles();

	emit scrollViewsToId( m_scrollTo );
	slotRepaintHandles();
	m_vScroll->setValue( m_scrollTo );
}

void KompareSplitter::slotScrollToId( int id )
{
	m_scrollTo = id;

	if( m_restartTimer )
		return;

	if( m_scrollTimer->isActive() )
	{
		m_restartTimer = true;
	}
	else
	{
		emit scrollViewsToId( id );
		slotRepaintHandles();
		m_vScroll->setValue( id );
		m_scrollTimer->start( 30 );
	}
}

void KompareSplitter::slotDelayedUpdateScrollBars()
{
	QTimer::singleShot( 0, this, SLOT( slotUpdateScrollBars() ) );
}

void KompareSplitter::slotUpdateScrollBars()
{
	const int end = count();
	for ( int i = 0; i < end; ++i ) {
		KompareListView* lv = listView(i);
		int minHScroll = minHScrollId();
		if (lv->contentsX() < minHScroll) {
			lv->setXOffset(minHScroll);
		}
	}

	int m_scrollDistance = m_settings->m_scrollNoOfLines * lineHeight();
	int m_pageSize = pageSize();

	if( needVScrollBar() )
	{
		m_vScroll->show();

		m_vScroll->blockSignals( true );
		m_vScroll->setRange( minVScrollId(), 
		                     maxVScrollId() );
		m_vScroll->setValue( scrollId() );
		m_vScroll->setSingleStep( m_scrollDistance );
		m_vScroll->setPageStep( m_pageSize );
		m_vScroll->blockSignals( false );
	}
	else
	{
		m_vScroll->hide();
	}

	if( needHScrollBar() )
	{
		m_hScroll->show();
		m_hScroll->blockSignals( true );
		m_hScroll->setRange( minHScrollId(), maxHScrollId() );
		m_hScroll->setValue( maxContentsX() );
		m_hScroll->setSingleStep( 10 );
		m_hScroll->setPageStep( minVisibleWidth() - 10 );
		m_hScroll->blockSignals( false );
	}
	else
	{
		m_hScroll->hide();
	}
}

void KompareSplitter::slotDelayedUpdateVScrollValue()
{
	QTimer::singleShot( 0, this, SLOT( slotUpdateVScrollValue() ) );
}

void KompareSplitter::slotUpdateVScrollValue()
{
	m_vScroll->setValue( scrollId() );
}

void KompareSplitter::keyPressEvent( QKeyEvent* e )
{
	//keyboard scrolling
	switch ( e->key() ) {
	case Qt::Key_Right:
	case Qt::Key_L:
		m_hScroll->triggerAction( QAbstractSlider::SliderSingleStepAdd );
		break;
	case Qt::Key_Left:
	case Qt::Key_H:
		m_hScroll->triggerAction( QAbstractSlider::SliderSingleStepSub );
		break;
	case Qt::Key_Up:
	case Qt::Key_K:
		m_vScroll->triggerAction( QAbstractSlider::SliderSingleStepSub );
		break;
	case Qt::Key_Down:
	case Qt::Key_J:
		m_vScroll->triggerAction( QAbstractSlider::SliderSingleStepAdd );
		break;
	case Qt::Key_PageDown:
		m_vScroll->triggerAction( QAbstractSlider::SliderPageStepAdd );
		break;
	case Qt::Key_PageUp:
		m_vScroll->triggerAction( QAbstractSlider::SliderPageStepSub );
		break;
	}
	e->accept();
	slotRepaintHandles();
}

void KompareSplitter::wheelEvent( QWheelEvent* e )
{
	if ( e->orientation() == Qt::Vertical )
	{
		if ( e->modifiers() & Qt::ControlModifier ) {
			if ( e->delta() < 0 ) // scroll down one page
				m_vScroll->triggerAction( QAbstractSlider::SliderPageStepAdd );
			else // scroll up one page
				m_vScroll->triggerAction( QAbstractSlider::SliderPageStepSub );
		} else {
			if ( e->delta() < 0 ) // scroll down
				m_vScroll->triggerAction( QAbstractSlider::SliderSingleStepAdd );
			else // scroll up
				m_vScroll->triggerAction( QAbstractSlider::SliderSingleStepSub );
		}
	}
	else
	{
		if ( e->modifiers() & Qt::ControlModifier ) {
			if ( e->delta() < 0 ) // scroll right one page
				m_hScroll->triggerAction( QAbstractSlider::SliderPageStepAdd );
			else // scroll left one page
				m_hScroll->triggerAction( QAbstractSlider::SliderPageStepSub );
		} else {
			if ( e->delta() < 0 ) // scroll to the right
				m_hScroll->triggerAction( QAbstractSlider::SliderSingleStepAdd );
			else // scroll to the left
				m_hScroll->triggerAction( QAbstractSlider::SliderSingleStepSub );
		}
	}
	e->accept();
	slotDelayedRepaintHandles();
}

/* FIXME: this should return/the scrollId() from the listview containing the
 * /base/ of the diff. but there's bigger issues with that atm.
 */
 
int KompareSplitter::scrollId()
{
	if(widget(0))
		return listView(0)->scrollId();
	return minVScrollId();
}

int KompareSplitter::lineHeight()
{
	if(widget(0))
		return listView(0)->fontMetrics().height();
	return 1;
}

int KompareSplitter::pageSize()
{
	if(widget(0)) {
		KompareListView *view = listView(0);
		return view->visibleHeight() - view->style()->pixelMetric( QStyle::PM_ScrollBarExtent );
	}
	return 1;
}

bool KompareSplitter::needVScrollBar()
{
	int pagesize = pageSize();
	const int end = count();
	for ( int i = 0; i < end; ++i ) {
		KompareListView *view = listView(i);
		if( view ->contentsHeight() > pagesize)
			return true;
	}
	return false;
}

int KompareSplitter::minVScrollId()
{

	int min = -1;
	int mSId;
	const int end = count();
	for ( int i = 0; i < end; ++i ) {
		mSId = listView(i)->minScrollId();
		if (mSId < min || min == -1)
			min = mSId;
	}
	return ( min == -1 ) ? 0 : min;
}

int KompareSplitter::maxVScrollId()
{
	int max = 0;
	int mSId;
	const int end = count();
	for ( int i = 0; i < end; ++i ) {
		mSId = listView(i)->maxScrollId();
		if ( mSId > max )
			max = mSId;
	}
	return max;
}

bool KompareSplitter::needHScrollBar()
{
	const int end = count();
	for ( int i = 0; i < end; ++i ) {
		KompareListView *view = listView(i);
		if ( view->contentsWidth() > view->visibleWidth() )
			return true;
	}
	return false;
}

int KompareSplitter::minHScrollId()
{
	// hardcode an offset to hide the tree controls
	return 6;
}

int KompareSplitter::maxHScrollId()
{
	int max = 0;
	int mHSId;
	const int end = count();
	for ( int i = 0; i < end; ++i ) {
		KompareListView *view = listView(i);
		mHSId = view->contentsWidth() - view->visibleWidth();
		if ( mHSId > max )
			max = mHSId;
	}
	return max;
}

int KompareSplitter::maxContentsX()
{
	int max = 0;
	int mCX;
	const int end = count();
	for ( int i = 0; i < end; ++i ) {
		mCX = listView(i)->contentsX();
		if ( mCX > max )
			max = mCX;
	}
	return max;
}

int KompareSplitter::minVisibleWidth()
{
	// Why the hell do we want to know this?
	// ah yes, it is because we use it to set the "page size" for horiz. scrolling.
	// despite the fact that *none* has a pgright and pgleft key :P
	// But we do have mousewheels with horizontal scrolling functionality,
	// pressing shift and scrolling then goes left and right one page at the time
	int min = -1;
	int vW;
	const int end = count();
	for ( int i = 0; i < end; ++i ) {
		vW = listView(i)->visibleWidth();
		if ( vW < min || min == -1 )
			min = vW;
	}
	return ( min == -1 ) ? 0 : min;
}

KompareListView* KompareSplitter::listView( int index )
{
	return static_cast<KompareListViewFrame*>(widget(index))->view();
}

KompareConnectWidget* KompareSplitter::connectWidget( int index )
{
	return static_cast<KompareConnectWidgetFrame*>(handle(index))->wid();
}

void KompareSplitter::slotSetSelection( const DiffModel* model, const Difference* diff )
{
	const int end = count();
	for ( int i = 0; i < end; ++i ) {
		connectWidget(i)->slotSetSelection( model, diff );
		listView(i)->slotSetSelection( model, diff );
		static_cast<KompareListViewFrame*>(widget(i))->slotSetModel( model );
	}

	slotDelayedRepaintHandles();
	slotDelayedUpdateScrollBars();
}

void KompareSplitter::slotSetSelection( const Difference* diff )
{
	const int end = count();
	for ( int i = 0; i < end; ++i ) {
		connectWidget(i)->slotSetSelection( diff );
		listView(i)->slotSetSelection( diff );
	}

	slotDelayedRepaintHandles();
	slotDelayedUpdateScrollBars();
}

void KompareSplitter::slotApplyDifference( bool apply )
{
	const int end = count();
	for ( int i = 0; i < end; ++i )
		listView(i)->slotApplyDifference( apply );
	slotDelayedRepaintHandles();
}

void KompareSplitter::slotApplyAllDifferences( bool apply )
{
	const int end = count();
	for ( int i = 0; i < end; ++i )
		listView(i)->slotApplyAllDifferences( apply );
	slotDelayedRepaintHandles();
	slotScrollToId( m_scrollTo ); // FIXME!
}

void KompareSplitter::slotApplyDifference( const Difference* diff, bool apply )
{
	const int end = count();
	for ( int i = 0; i < end; ++i )
		listView(i)->slotApplyDifference( diff, apply );
	slotDelayedRepaintHandles();
}

void KompareSplitter::slotDifferenceClicked( const Difference* diff )
{
	const int end = count();
	for ( int i = 0; i < end; ++i )
		listView(i)->setSelectedDifference( diff, false );
	emit selectionChanged( diff );
}

void KompareSplitter::slotConfigChanged()
{
	const int end = count();
	for ( int i = 0; i < end; ++i ) {
		KompareListView *view = listView(i);
		view->setFont( m_settings->m_font );
		view->update();
	}
}
#include "komparesplitter.moc"