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/lib/kofficeui/KoRuler.cpp

1203 lines
41 KiB

/* This file is part of the KDE project
Copyright (C) 1998, 1999 Reginald Stadlbauer <reggie@kde.org>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library 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
Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with this library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
// Description: Ruler (header)
/******************************************************************/
#include "KoRuler.h"
#include <klocale.h>
#include <kglobalsettings.h>
#include <kdebug.h>
#include <kiconloader.h>
#include <tqcursor.h>
#include <tqpainter.h>
#include <tqpopupmenu.h>
#include <tqtooltip.h>
#include <KoPageLayout.h>
class KoRulerPrivate {
public:
KoRulerPrivate() {
}
~KoRulerPrivate() {}
TQWidget *canvas;
int flags;
int oldMx, oldMy;
bool whileMovingBorderLeft, whileMovingBorderRight;
bool whileMovingBorderTop, whileMovingBorderBottom;
TQPixmap pmFirst, pmLeft;
KoPageLayout layout;
KoTabChooser *tabChooser;
KoTabulatorList tabList;
// Do we have to remove a certain tab in the DC Event?
KoTabulator removeTab;
// The tab we're moving / clicking on - basically only valid between press and release time
KoTabulator currTab;
// The action we're currently doing - basically only valid between press and release time
KoRuler::Action action;
TQPopupMenu *rb_menu;
int mRemoveTab, mPageLayout; // menu item ids
int frameEnd;
double i_right;
bool m_bReadWrite;
bool doubleClickedIndent;
bool rtl;
bool mousePressed;
};
// Equality test for tab positions in particular
static inline bool equals( double a, double b ) {
return kAbs( a - b ) < 1E-4;
}
/******************************************************************/
/* Class: KoRuler */
/******************************************************************/
const int KoRuler::F_TABS = 1;
const int KoRuler::F_INDENTS = 2;
const int KoRuler::F_HELPLINES = 4;
const int KoRuler::F_NORESIZE = 8;
/*================================================================*/
KoRuler::KoRuler( TQWidget *_parent, TQWidget *_canvas, Qt::Orientation _orientation,
const KoPageLayout& _layout, int _flags, KoUnit::Unit _unit, KoTabChooser *_tabChooser )
: TQFrame( _parent ), buffer( width(), height() ), m_zoom(1.0), m_1_zoom(1.0),
m_unit( _unit )
{
setWFlags( WResizeNoErase | WRepaintNoErase );
setFrameStyle( MenuBarPanel );
d=new KoRulerPrivate();
d->tabChooser = _tabChooser;
d->canvas = _canvas;
orientation = _orientation;
d->layout = _layout;
d->flags = _flags;
d->m_bReadWrite=true;
d->doubleClickedIndent=false;
diffx = 0;
diffy = 0;
i_left=0.0;
i_first=0.0;
d->i_right=0.0;
setMouseTracking( true );
d->mousePressed = false;
d->action = A_NONE;
d->oldMx = 0;
d->oldMy = 0;
d->rtl = false;
showMPos = false;
mposX = 0;
mposY = 0;
gridSize=0.0;
hasToDelete = false;
d->whileMovingBorderLeft = d->whileMovingBorderRight = d->whileMovingBorderTop = d->whileMovingBorderBottom = false;
d->pmFirst = UserIcon( "koRulerFirst" );
d->pmLeft = UserIcon( "koRulerLeft" );
d->currTab.type = T_INVALID;
d->removeTab.type = T_INVALID;
if ( orientation == Qt::Horizontal ) {
frameStart = tqRound( zoomIt(d->layout.ptLeft) );
d->frameEnd = tqRound( zoomIt(d->layout.ptWidth - d->layout.ptRight) );
} else {
frameStart = tqRound( zoomIt(d->layout.ptTop) );
d->frameEnd = tqRound( zoomIt(d->layout.ptHeight - d->layout.ptBottom) );
}
m_bFrameStartSet = false;
setupMenu();
// For compatibility, emitting doubleClicked shall emit openPageLayoutDia
connect( this, TQT_SIGNAL( doubleClicked() ), this, TQT_SIGNAL( openPageLayoutDia() ) );
}
/*================================================================*/
KoRuler::~KoRuler()
{
delete d->rb_menu;
delete d;
}
void KoRuler::setPageLayoutMenuItemEnabled(bool b)
{
d->rb_menu->setItemEnabled(d->mPageLayout, b);
}
/*================================================================*/
void KoRuler::setMousePos( int mx, int my )
{
if ( !showMPos || ( mx == mposX && my == mposY ) ) return;
TQPainter p( this );
p.setRasterOp( TQt::NotROP );
if ( orientation == Qt::Horizontal ) {
if ( hasToDelete )
p.drawLine( mposX, 1, mposX, height() - 1 );
p.drawLine( mx, 1, mx, height() - 1 );
hasToDelete = true;
}
else {
if ( hasToDelete )
p.drawLine( 1, mposY, width() - 1, mposY );
p.drawLine( 1, my, width() - 1, my );
hasToDelete = true;
}
p.end();
mposX = mx;
mposY = my;
}
// distance between the main lines (those with a number)
double KoRuler::lineDistance() const
{
switch( m_unit ) {
case KoUnit::U_INCH:
return INCH_TO_POINT( m_zoom ); // every inch
case KoUnit::U_PT:
return 100.0 * m_zoom; // every 100 pt
case KoUnit::U_MM:
case KoUnit::U_CM:
case KoUnit::U_DM:
return CM_TO_POINT ( m_zoom ); // every cm
case KoUnit::U_PI:
return PI_TO_POINT ( 10.0 * m_zoom ); // every 10 pica
case KoUnit::U_DD:
return DD_TO_POINT( m_zoom ); // every diderot
case KoUnit::U_CC:
return CC_TO_POINT( 10.0 * m_zoom ); // every 10 cicero
}
// should never end up here
return 100.0 * m_zoom;
}
/*================================================================*/
void KoRuler::drawHorizontal( TQPainter *_painter )
{
TQFont font = KGlobalSettings::toolBarFont();
TQFontMetrics fm( font );
resize( width(), TQMAX( fm.height() + 4, 20 ) );
// Use a double-buffer pixmap
TQPainter p( &buffer );
p.fillRect( 0, 0, width(), height(), TQBrush( colorGroup().brush( TQColorGroup::Background ) ) );
int totalw = tqRound( zoomIt(d->layout.ptWidth) );
TQString str;
p.setBrush( colorGroup().brush( TQColorGroup::Base ) );
// Draw white rect
TQRect r;
if ( !d->whileMovingBorderLeft )
r.setLeft( -diffx + frameStart );
else
r.setLeft( d->oldMx );
r.setTop( 0 );
if ( !d->whileMovingBorderRight )
r.setWidth(d->frameEnd-frameStart);
else
r.setRight( d->oldMx );
r.setBottom( height() );
p.drawRect( r );
p.setFont( font );
// Draw the numbers
double dist = lineDistance();
int maxwidth = 0;
for ( double i = 0.0;i <= (double)totalw;i += dist ) {
str = TQString::number( KoUnit::toUserValue( i / m_zoom, m_unit ) );
int textwidth = fm.width( str );
maxwidth = TQMAX( maxwidth, textwidth );
}
// Make sure that the ruler stays readable at lower zoom levels
while( dist <= maxwidth ) {
dist += lineDistance();
}
for ( double i = 0.0;i <= (double)totalw;i += dist ) {
str = TQString::number( KoUnit::toUserValue( i / m_zoom, m_unit ) );
int textwidth = fm.width( str );
maxwidth = TQMAX( maxwidth, textwidth );
p.drawText( tqRound(i) - diffx - tqRound(textwidth * 0.5),
tqRound(( height() - fm.height() ) * 0.5),
textwidth, height(), AlignLeft | AlignTop, str );
}
// Draw the medium-sized lines
// Only if we have enough space (i.e. not at 33%)
if ( dist > maxwidth + 2 )
{
for ( double i = dist * 0.5;i <= (double)totalw;i += dist ) {
int ii=tqRound(i);
p.drawLine( ii - diffx, 7, ii - diffx, height() - 7 );
}
}
// Draw the small lines
// Only if we have enough space (i.e. not at 33%)
if ( dist * 0.5 > maxwidth + 2 )
{
for ( double i = dist * 0.25;i <= (double)totalw;i += dist * 0.5 ) {
int ii=tqRound(i);
p.drawLine( ii - diffx, 9, ii - diffx, height() - 9 );
}
}
// Draw ending bar (at page width)
//int constant=zoomIt(1);
//p.drawLine( totalw - diffx + constant, 1, totalw - diffx + constant, height() - 1 );
//p.setPen( colorGroup().color( TQColorGroup::Base ) );
//p.drawLine( totalw - diffx, 1, totalw - diffx, height() - 1 );
// Draw starting bar (at 0)
//p.setPen( colorGroup().color( TQColorGroup::Text ) );
//p.drawLine( -diffx, 1, -diffx, height() - 1 );
//p.setPen( colorGroup().color( TQColorGroup::Base ) );
//p.drawLine( -diffx - constant, 1, -diffx - constant, height() - 1 );
// Draw the indents triangles
if ( d->flags & F_INDENTS ) {
int top = 1;
double halfPixmapWidth = d->pmFirst.width() * 0.5;
// Cumulate i_first with correct indent
double firstLineIdent = i_first + ( d->rtl ? d->i_right : i_left );
p.drawPixmap( tqRound( static_cast<double>(r.left()) + applyRtlAndZoom( firstLineIdent ) - halfPixmapWidth ),
top, d->pmFirst );
int bottom = height() - d->pmLeft.height() - 1;
halfPixmapWidth = d->pmLeft.width() * 0.5;
p.drawPixmap( tqRound( static_cast<double>(r.left()) + zoomIt(i_left) - halfPixmapWidth ),
bottom, d->pmLeft );
p.drawPixmap( tqRound( static_cast<double>(r.right()) - zoomIt(d->i_right) - halfPixmapWidth ),
bottom, d->pmLeft );
}
// Show the mouse position
if ( d->action == A_NONE && showMPos ) {
p.setPen( colorGroup().color( TQColorGroup::Text ) );
p.drawLine( mposX, 1, mposX, height() - 1 );
}
hasToDelete = false;
// Draw the tabs
if ( d->tabChooser && ( d->flags & F_TABS ) && !d->tabList.isEmpty() )
drawTabs( p );
p.end();
_painter->drawPixmap( 0, 0, buffer );
}
/*================================================================*/
void KoRuler::drawTabs( TQPainter &_painter )
{
int ptPos = 0;
_painter.setPen( TQPen( colorGroup().color( TQColorGroup::Text ), 2, SolidLine ) );
// Check if we're in a mousemove event, removing a tab.
// In that case, we'll have to skip drawing that one.
bool willRemove = d->mousePressed && willRemoveTab( d->oldMy ) && d->currTab.type != T_INVALID;
KoTabulatorList::ConstIterator it = d->tabList.begin();
for ( ; it != d->tabList.end() ; it++ ) {
if ( willRemove && equals( d->currTab.ptPos, (*it).ptPos ) )
continue;
ptPos = tqRound(applyRtlAndZoom((*it).ptPos)) - diffx + frameStart;
switch ( (*it).type ) {
case T_LEFT: {
ptPos -= 4;
_painter.drawLine( ptPos + 4, height() - 4, ptPos + 20 - 4, height() - 4 );
_painter.drawLine( ptPos + 5, 4, ptPos + 5, height() - 4 );
} break;
case T_CENTER: {
ptPos -= 10;
_painter.drawLine( ptPos + 4, height() - 4, ptPos + 20 - 4, height() - 4 );
_painter.drawLine( ptPos + 20 / 2, 4, ptPos + 20 / 2, height() - 4 );
} break;
case T_RIGHT: {
ptPos -= 16;
_painter.drawLine( ptPos + 4, height() - 4, ptPos + 20 - 4, height() - 4 );
_painter.drawLine( ptPos + 20 - 5, 4, ptPos + 20 - 5, height() - 4 );
} break;
case T_DEC_PNT: {
ptPos -= 10;
_painter.drawLine( ptPos + 4, height() - 4, ptPos + 20 - 4, height() - 4 );
_painter.drawLine( ptPos + 20 / 2, 4, ptPos + 20 / 2, height() - 4 );
_painter.fillRect( ptPos + 20 / 2 + 2, height() - 9, 3, 3,
colorGroup().color( TQColorGroup::Text ) );
} break;
default: break;
}
}
}
/*================================================================*/
void KoRuler::drawVertical( TQPainter *_painter )
{
TQFont font = KGlobalSettings::toolBarFont();
TQFontMetrics fm( font );
resize( TQMAX( fm.height() + 4, 20 ), height() );
TQPainter p( &buffer );
p.fillRect( 0, 0, width(), height(), TQBrush( colorGroup().brush( TQColorGroup::Background ) ) );
int totalh = tqRound( zoomIt(d->layout.ptHeight) );
// Clip rect - this gives basically always a rect like (2,2,width-2,height-2)
TQRect paintRect = _painter->clipRegion( TQPainter::CoordPainter ).boundingRect();
// Ruler rect
TQRect rulerRect( 0, -diffy, width(), totalh );
if ( paintRect.intersects( rulerRect ) ) {
TQString str;
p.setBrush( colorGroup().brush( TQColorGroup::Base ) );
// Draw white rect
TQRect r;
if ( !d->whileMovingBorderTop )
r.setTop( -diffy + frameStart );
else
r.setTop( d->oldMy );
r.setLeft( 0 );
if ( !d->whileMovingBorderBottom )
r.setHeight(d->frameEnd-frameStart);
else
r.setBottom( d->oldMy );
r.setRight( width() );
p.drawRect( r );
p.setFont( font );
// Draw the numbers
double dist = lineDistance();
int maxheight = 0;
for ( double i = 0.0;i <= (double)totalh;i += dist ) {
str = TQString::number( KoUnit::toUserValue( i / m_zoom, m_unit ) );
int textwidth = fm.width( str );
maxheight = TQMAX( maxheight, textwidth );
}
// Make sure that the ruler stays readable at lower zoom levels
while( dist <= maxheight ) {
dist += lineDistance();
}
for ( double i = 0.0;i <= (double)totalh;i += dist ) {
str = TQString::number( KoUnit::toUserValue( i / m_zoom, m_unit ) );
int textwidth = fm.width( str );
int yOffset = tqRound(i) - diffy + tqRound(textwidth * 0.5);
if(yOffset > paintRect.bottom())
break; // stop drawing when outside the to-paint-region
int textheight = fm.height();
maxheight = TQMAX( maxheight, textwidth );
p.save();
p.translate( tqRound(( width() - textheight ) * 0.5), yOffset);
p.rotate( -90 );
p.drawText( 0, 0, textwidth + 1, textheight, AlignLeft | AlignTop, str );
p.restore();
}
// Draw the medium-sized lines
if ( dist > maxheight + 2 )
{
for ( double i = dist * 0.5;i <= (double)totalh;i += dist ) {
int ii=tqRound(i) - diffy;
if(ii > paintRect.bottom())
break; // stop drawing when outside the to-paint-region
p.drawLine( 7, ii, width() - 7, ii);
}
}
// Draw the small lines
if ( dist * 0.5 > maxheight + 2 )
{
for ( double i = dist * 0.25;i <=(double)totalh;i += dist *0.5 ) {
int ii=tqRound(i) - diffy;
if(ii > paintRect.bottom())
break; // stop drawing when outside the to-paint-region
p.drawLine( 9, ii, width() - 9, ii);
}
}
// Draw ending bar (at page height)
//p.drawLine( 1, totalh - diffy + 1, width() - 1, totalh - diffy + 1 );
//p.setPen( colorGroup().color( TQColorGroup::Base ) );
//p.drawLine( 1, totalh - diffy, width() - 1, totalh - diffy );
// Draw starting bar (at 0)
//p.setPen( colorGroup().color( TQColorGroup::Text ) );
//p.drawLine( 1, -diffy, width() - 1, -diffy );
//p.setPen( colorGroup().color( TQColorGroup::Base ) );
//p.drawLine( 1, -diffy - 1, width() - 1, -diffy - 1 );
}
// Show the mouse position
if ( d->action == A_NONE && showMPos ) {
p.setPen( colorGroup().color( TQColorGroup::Text ) );
p.drawLine( 1, mposY, width() - 1, mposY );
}
hasToDelete = false;
p.end();
_painter->drawPixmap( 0, 0, buffer );
}
void KoRuler::mousePressEvent( TQMouseEvent *e )
{
if( !d->m_bReadWrite)
return;
d->oldMx = e->x();
d->oldMy = e->y();
d->mousePressed = true;
d->removeTab.type = T_INVALID;
switch ( e->button() ) {
case Qt::RightButton:
if(d->currTab.type == T_INVALID || !(d->flags & F_TABS))
d->rb_menu->setItemEnabled(d->mRemoveTab, false);
else
d->rb_menu->setItemEnabled(d->mRemoveTab, true);
d->rb_menu->popup( TQCursor::pos() );
d->action = A_NONE;
d->mousePressed = false;
return;
case Qt::MidButton:
// MMB shall do like double-click (it opens a dialog).
handleDoubleClick();
return;
case Qt::LeftButton:
if ( d->action == A_BR_RIGHT || d->action == A_BR_LEFT ) {
if ( d->action == A_BR_RIGHT )
d->whileMovingBorderRight = true;
else
d->whileMovingBorderLeft = true;
if ( d->canvas )
drawLine(d->oldMx, -1);
update();
} else if ( d->action == A_BR_TOP || d->action == A_BR_BOTTOM ) {
if ( d->action == A_BR_TOP )
d->whileMovingBorderTop = true;
else
d->whileMovingBorderBottom = true;
if ( d->canvas ) {
TQPainter p( d->canvas );
p.setRasterOp( TQt::NotROP );
p.drawLine( 0, d->oldMy, d->canvas->width(), d->oldMy );
p.end();
}
update();
} else if ( d->action == A_FIRST_INDENT || d->action == A_LEFT_INDENT || d->action == A_RIGHT_INDENT ) {
if ( d->canvas )
drawLine(d->oldMx, -1);
} else if ( d->action == A_TAB ) {
if ( d->canvas && d->currTab.type != T_INVALID ) {
drawLine( tqRound( applyRtlAndZoom(d->currTab.ptPos) ) + frameStart - diffx, -1 );
}
} else if ( d->tabChooser && ( d->flags & F_TABS ) && d->tabChooser->getCurrTabType() != 0 ) {
int left = frameStart - diffx;
int right = d->frameEnd - diffx;
if( e->x()-left < 0 || right-e->x() < 0 )
return;
KoTabulator tab;
tab.filling = TF_BLANK;
tab.ptWidth = 0.5;
switch ( d->tabChooser->getCurrTabType() ) {
case KoTabChooser::TAB_LEFT:
tab.type = T_LEFT;
break;
case KoTabChooser::TAB_CENTER:
tab.type = T_CENTER;
break;
case KoTabChooser::TAB_RIGHT:
tab.type = T_RIGHT;
break;
case KoTabChooser::TAB_DEC_PNT:
tab.type = T_DEC_PNT;
tab.alignChar = KGlobal::locale()->decimalSymbol()[0];
break;
default: break;
}
tab.ptPos = unZoomItRtl( e->x() + diffx - frameStart );
KoTabulatorList::Iterator it=d->tabList.begin();
while ( it!=d->tabList.end() && tab > (*it) )
++it;
d->tabList.insert(it, tab);
d->action = A_TAB;
d->removeTab = tab;
d->currTab = tab;
emit tabListChanged( d->tabList );
update();
}
else if ( d->flags & F_HELPLINES )
{
setCursor( orientation == Qt::Horizontal ?
TQt::sizeVerCursor : TQt::sizeHorCursor );
d->action = A_HELPLINES;
}
default:
break;
}
}
void KoRuler::mouseReleaseEvent( TQMouseEvent *e )
{
d->mousePressed = false;
// Hacky, but necessary to prevent multiple tabs with the same coordinates (Werner)
bool fakeMovement=false;
if(d->removeTab.type != T_INVALID) {
mouseMoveEvent(e);
fakeMovement=true;
}
if ( d->action == A_BR_RIGHT || d->action == A_BR_LEFT ) {
d->whileMovingBorderRight = false;
d->whileMovingBorderLeft = false;
if ( d->canvas )
drawLine(d->oldMx, -1);
update();
emit newPageLayout( d->layout );
} else if ( d->action == A_BR_TOP || d->action == A_BR_BOTTOM ) {
d->whileMovingBorderTop = false;
d->whileMovingBorderBottom = false;
if ( d->canvas ) {
TQPainter p( d->canvas );
p.setRasterOp( TQt::NotROP );
p.drawLine( 0, d->oldMy, d->canvas->width(), d->oldMy );
p.end();
}
update();
emit newPageLayout( d->layout );
} else if ( d->action == A_FIRST_INDENT ) {
if ( d->canvas )
drawLine(d->oldMx, -1);
update();
emit newFirstIndent( i_first );
} else if ( d->action == A_LEFT_INDENT ) {
if ( d->canvas )
drawLine(d->oldMx, -1);
update();
emit newLeftIndent( i_left );
} else if ( d->action == A_RIGHT_INDENT ) {
if ( d->canvas )
drawLine(d->oldMx, -1);
update();
emit newRightIndent( d->i_right );
} else if ( d->action == A_TAB ) {
if ( d->canvas && !fakeMovement ) {
drawLine( tqRound( applyRtlAndZoom( d->currTab.ptPos ) ) + frameStart - diffx, -1);
}
if ( willRemoveTab( e->y() ) )
{
d->tabList.remove(d->currTab);
}
qHeapSort( d->tabList );
// Delete the new tabulator if it is placed on top of another.
KoTabulatorList::ConstIterator tmpTab=d->tabList.begin();
int count=0;
while(tmpTab!=d->tabList.end()) {
if( equals( (*tmpTab).ptPos, d->currTab.ptPos ) ) {
count++;
if(count > 1) {
d->tabList.remove(d->currTab);
break;
}
}
tmpTab++;
}
//searchTab( e->x() ); // DF: why set currTab here?
emit tabListChanged( d->tabList );
update();
}
else if( d->action == A_HELPLINES )
{
emit addGuide( e->pos(), orientation == Qt::Horizontal, orientation == Qt::Horizontal ? size().height() : size().width() );
emit addHelpline( e->pos(), orientation == Qt::Horizontal);
setCursor( ArrowCursor );
}
d->currTab.type = T_INVALID; // added (DF)
}
void KoRuler::mouseMoveEvent( TQMouseEvent *e )
{
hasToDelete = false;
int pw = d->frameEnd - frameStart;
int ph = tqRound(zoomIt(d->layout.ptHeight));
int left = frameStart - diffx;
int top = tqRound(zoomIt(d->layout.ptTop));
top -= diffy;
int right = d->frameEnd - diffx;
int bottom = tqRound(zoomIt(d->layout.ptBottom));
bottom = ph - bottom - diffy;
// Cumulate first-line-indent
int ip_first = tqRound( zoomIt( i_first + ( d->rtl ? d->i_right : i_left) ) );
int ip_left = tqRound(zoomIt(i_left));
int ip_right = tqRound(zoomIt(d->i_right));
int mx = e->x();
mx = mx+diffx < 0 ? 0 : mx;
int my = e->y();
my = my+diffy < 0 ? 0 : my;
TQToolTip::remove( this);
switch ( orientation ) {
case Qt::Horizontal: {
if ( !d->mousePressed ) {
setCursor( ArrowCursor );
d->action = A_NONE;
/////// ######
// At the moment, moving the left and right border indicators
// is disabled when setFrameStartEnd has been called (i.e. in KWord)
// Changing the layout margins directly from it would be utterly wrong
// (just try the 2-columns modes...). What needs to be done is:
// emitting a signal frameResized in mouseReleaseEvent, when a left/right
// border has been moved, and in kword we need to update the margins from
// there, if the left border of the 1st column or the right border of the
// last column was moved... and find what to do with the other borders.
// And for normal frames, resize the frame without touching the page layout.
// All that is too much for now -> disabling.
if ( !m_bFrameStartSet )
{
if ( mx > left - 5 && mx < left + 5 ) {
setCursor( TQt::sizeHorCursor );
d->action = A_BR_LEFT;
} else if ( mx > right - 5 && mx < right + 5 ) {
setCursor( TQt::sizeHorCursor );
d->action = A_BR_RIGHT;
}
}
if ( d->flags & F_INDENTS ) {
int firstX = d->rtl ? right - ip_first : left + ip_first;
if ( mx > firstX - 5 && mx < firstX + 5 &&
my >= 2 && my <= d->pmFirst.size().height() + 2 ) {
TQToolTip::add( this, i18n("First line indent") );
setCursor( ArrowCursor );
d->action = A_FIRST_INDENT;
} else if ( mx > left + ip_left - 5 && mx < left + ip_left + 5 &&
my >= height() - d->pmLeft.size().height() - 2 && my <= height() - 2 ) {
TQToolTip::add( this, i18n("Left indent") );
setCursor( ArrowCursor );
d->action = A_LEFT_INDENT;
} else if ( mx > right - ip_right - 5 && mx < right - ip_right + 5 &&
my >= height() - d->pmLeft.size().height() - 2 && my <= height() - 2 ) {
TQToolTip::add( this, i18n("Right indent") );
setCursor( ArrowCursor );
d->action = A_RIGHT_INDENT;
}
}
if ( d->flags & F_TABS )
searchTab(mx);
} else {
// Calculate the new value.
int newPos=mx;
if( newPos!=right && gridSize!=0.0 && (e->state() & ShiftButton)==0) { // apply grid.
double grid=zoomIt(gridSize * 16);
newPos=tqRound( ((newPos * 16 / grid) * grid) / 16 );
}
if(newPos-left < 0) newPos=left;
else if (right-newPos < 0) newPos=right;
double newValue = unZoomIt(static_cast<double>(newPos) - frameStart + diffx);
switch ( d->action ) {
case A_BR_LEFT: {
if ( d->canvas && mx < right-10 && mx+diffx-2 > 0) {
drawLine( d->oldMx, mx );
d->layout.ptLeft = unZoomIt(static_cast<double>(mx + diffx));
if( ip_left > right-left-15 ) {
ip_left=right-left-15;
ip_left=ip_left<0 ? 0 : ip_left;
i_left=unZoomIt( ip_left );
emit newLeftIndent( i_left );
}
if ( ip_right > right-left-15 ) {
ip_right=right-left-15;
ip_right=ip_right<0? 0 : ip_right;
d->i_right=unZoomIt( ip_right );
emit newRightIndent( d->i_right );
}
d->oldMx = mx;
d->oldMy = my;
update();
}
else
return;
} break;
case A_BR_RIGHT: {
if ( d->canvas && mx > left+10 && mx+diffx <= pw-2) {
drawLine( d->oldMx, mx );
d->layout.ptRight = unZoomIt(static_cast<double>(pw - ( mx + diffx )));
if( ip_left > right-left-15 ) {
ip_left=right-left-15;
ip_left=ip_left<0 ? 0 : ip_left;
i_left=unZoomIt( ip_left );
emit newLeftIndent( i_left );
}
if ( ip_right > right-left-15 ) {
ip_right=right-left-15;
ip_right=ip_right<0? 0 : ip_right;
d->i_right=unZoomIt( ip_right );
emit newRightIndent( d->i_right );
}
d->oldMx = mx;
d->oldMy = my;
update();
}
else
return;
} break;
case A_FIRST_INDENT: {
if ( d->canvas ) {
if (d->rtl)
newValue = unZoomIt(pw) - newValue - d->i_right;
else
newValue -= i_left;
if(newValue == i_first) break;
drawLine( d->oldMx, newPos);
d->oldMx=newPos;
i_first = newValue;
update();
}
} break;
case A_LEFT_INDENT: {
if ( d->canvas ) {
//if (d->rtl) newValue = unZoomIt(pw) - newValue;
if(newValue == i_left) break;
drawLine( d->oldMx, newPos);
i_left = newValue;
d->oldMx = newPos;
update();
}
} break;
case A_RIGHT_INDENT: {
if ( d->canvas ) {
double rightValue = unZoomIt(right - newPos);
//if (d->rtl) rightValue = unZoomIt(pw) - rightValue;
if(rightValue == d->i_right) break;
drawLine( d->oldMx, newPos);
d->i_right=rightValue;
d->oldMx = newPos;
update();
}
} break;
case A_TAB: {
if ( d->canvas) {
if (d->rtl) newValue = unZoomIt(pw) - newValue;
if(newValue == d->currTab.ptPos) break; // no change
TQPainter p( d->canvas );
p.setRasterOp( TQt::NotROP );
// prevent 1st drawLine when we just created a new tab
// (it's a NOT line)
double pt;
int pt_fr;
if( d->currTab != d->removeTab )
{
pt = applyRtlAndZoom(d->currTab.ptPos);
pt_fr = tqRound(pt) + frameStart - diffx;
p.drawLine( pt_fr, 0, pt_fr, d->canvas->height() );
}
KoTabulatorList::Iterator it = d->tabList.find( d->currTab );
Q_ASSERT( it != d->tabList.end() );
if ( it != d->tabList.end() )
(*it).ptPos = newValue;
d->currTab.ptPos = newValue;
pt = applyRtlAndZoom( newValue );
pt_fr = tqRound(pt) + frameStart - diffx;
p.drawLine( pt_fr, 0, pt_fr, d->canvas->height() );
p.end();
d->oldMx = mx;
d->oldMy = my;
d->removeTab.type = T_INVALID;
update();
}
} break;
default: break;
}
}
if( d->action == A_HELPLINES )
{
emit moveGuide( e->pos(), true, size().height() );
emit moveHelpLines( e->pos(), true );
}
return;
} break;
case Qt::Vertical: {
if ( !d->mousePressed ) {
setCursor( ArrowCursor );
d->action = A_NONE;
if ( d->flags & F_NORESIZE )
break;
if ( my > top - 5 && my < top + 5 ) {
TQToolTip::add( this, i18n("Top margin") );
setCursor( TQt::sizeVerCursor );
d->action = A_BR_TOP;
} else if ( my > bottom - 5 && my < bottom + 5 ) {
TQToolTip::add( this, i18n("Bottom margin") );
setCursor( TQt::sizeVerCursor );
d->action = A_BR_BOTTOM;
}
} else {
switch ( d->action ) {
case A_BR_TOP: {
if ( d->canvas && my < bottom-20 && my+diffy-2 > 0) {
TQPainter p( d->canvas );
p.setRasterOp( TQt::NotROP );
p.drawLine( 0, d->oldMy, d->canvas->width(), d->oldMy );
p.drawLine( 0, my, d->canvas->width(), my );
p.end();
d->layout.ptTop = unZoomIt(static_cast<double>(my + diffy));
d->oldMx = mx;
d->oldMy = my;
update();
}
else
return;
} break;
case A_BR_BOTTOM: {
if ( d->canvas && my > top+20 && my+diffy < ph-2) {
TQPainter p( d->canvas );
p.setRasterOp( TQt::NotROP );
p.drawLine( 0, d->oldMy, d->canvas->width(), d->oldMy );
p.drawLine( 0, my, d->canvas->width(), my );
p.end();
d->layout.ptBottom = unZoomIt(static_cast<double>(ph - ( my + diffy )));
d->oldMx = mx;
d->oldMy = my;
update();
}
else
return;
} break;
default: break;
}
}
if( d->action == A_HELPLINES )
{
emit moveGuide( e->pos(), false, size().width() );
emit moveHelpLines( e->pos(), false );
}
} break;
}
d->oldMx = mx;
d->oldMy = my;
}
void KoRuler::resizeEvent( TQResizeEvent *e )
{
TQFrame::resizeEvent( e );
buffer.resize( size() );
}
void KoRuler::mouseDoubleClickEvent( TQMouseEvent* )
{
handleDoubleClick();
}
void KoRuler::handleDoubleClick()
{
if ( !d->m_bReadWrite )
return;
d->doubleClickedIndent = false;
if ( d->tabChooser && ( d->flags & F_TABS ) ) {
// Double-click and mousePressed inserted a tab -> need to remove it
if ( d->tabChooser->getCurrTabType() != 0 && d->removeTab.type != T_INVALID && !d->tabList.isEmpty()) {
uint c = d->tabList.count();
d->tabList.remove( d->removeTab );
Q_ASSERT( d->tabList.count() < c );
d->removeTab.type = T_INVALID;
d->currTab.type = T_INVALID;
emit tabListChanged( d->tabList );
setCursor( ArrowCursor );
update();
// --- we didn't click on a tab, fall out to indents test ---
} else if ( d->action == A_TAB ) {
// Double-click on a tab
emit doubleClicked( d->currTab.ptPos ); // usually paragraph dialog
return;
}
}
// When Binary Compatibility is broken this will hopefully emit a
// doubleClicked(int) to differentiate between double-clicking an
// indent and double-clicking the ruler
if ( d->flags & F_INDENTS ) {
if ( d->action == A_LEFT_INDENT || d->action == A_RIGHT_INDENT || d->action == A_FIRST_INDENT ) {
d->doubleClickedIndent = true;
emit doubleClicked(); // usually paragraph dialog
return;
}
}
// Double-clicked nothing
d->action = A_NONE;
emit doubleClicked(); // usually page layout dialog
}
void KoRuler::setTabList( const KoTabulatorList & _tabList )
{
d->tabList = _tabList;
qHeapSort(d->tabList); // "Trust no one." as opposed to "In David we trust."
// Note that d->currTab and d->removeTab could now point to
// tabs which don't exist in d->tabList
update();
}
double KoRuler::makeIntern( double _v )
{
return KoUnit::fromUserValue( _v, m_unit );
}
void KoRuler::setupMenu()
{
d->rb_menu = new TQPopupMenu();
TQ_CHECK_PTR( d->rb_menu );
for ( uint i = 0 ; i <= KoUnit::U_LASTUNIT ; ++i )
{
KoUnit::Unit unit = static_cast<KoUnit::Unit>( i );
d->rb_menu->insertItem( KoUnit::unitDescription( unit ), i /*as id*/ );
if ( m_unit == unit )
d->rb_menu->setItemChecked( i, true );
}
connect( d->rb_menu, TQT_SIGNAL( activated( int ) ), TQT_SLOT( slotMenuActivated( int ) ) );
d->rb_menu->insertSeparator();
d->mPageLayout=d->rb_menu->insertItem(i18n("Page Layout..."), this, TQT_SLOT(pageLayoutDia()));
d->rb_menu->insertSeparator();
d->mRemoveTab=d->rb_menu->insertItem(i18n("Remove Tabulator"), this, TQT_SLOT(rbRemoveTab()));
d->rb_menu->setItemEnabled( d->mRemoveTab, false );
}
void KoRuler::uncheckMenu()
{
for ( uint i = 0 ; i <= KoUnit::U_LASTUNIT ; ++i )
d->rb_menu->setItemChecked( i, false );
}
void KoRuler::setUnit( const TQString& _unit )
{
setUnit( KoUnit::unit( _unit ) );
}
void KoRuler::setUnit( KoUnit::Unit unit )
{
m_unit = unit;
uncheckMenu();
d->rb_menu->setItemChecked( m_unit, true );
update();
}
void KoRuler::setZoom( const double& zoom )
{
if(zoom==m_zoom)
return;
if(zoom < 1E-4) // Don't do 0 or negative values
return;
m_zoom=zoom;
m_1_zoom=1/m_zoom;
update();
}
bool KoRuler::willRemoveTab( int y ) const
{
return (y < -50 || y > height() + 25) && d->currTab.type != T_INVALID;
}
void KoRuler::rbRemoveTab() {
d->tabList.remove( d->currTab );
d->currTab.type = T_INVALID;
emit tabListChanged( d->tabList );
update();
}
void KoRuler::setReadWrite(bool _readWrite)
{
d->m_bReadWrite=_readWrite;
}
void KoRuler::searchTab(int mx) {
int pos;
d->currTab.type = T_INVALID;
KoTabulatorList::ConstIterator it = d->tabList.begin();
for ( ; it != d->tabList.end() ; ++it ) {
pos = tqRound(applyRtlAndZoom((*it).ptPos)) - diffx + frameStart;
if ( mx > pos - 5 && mx < pos + 5 ) {
setCursor( TQt::sizeHorCursor );
d->action = A_TAB;
d->currTab = *it;
break;
}
}
}
void KoRuler::drawLine(int oldX, int newX) {
TQPainter p( d->canvas );
p.setRasterOp( TQt::NotROP );
p.drawLine( oldX, 0, oldX, d->canvas->height() );
if(newX!=-1)
p.drawLine( newX, 0, newX, d->canvas->height() );
p.end();
}
void KoRuler::showMousePos( bool _showMPos )
{
showMPos = _showMPos;
hasToDelete = false;
mposX = -1;
mposY = -1;
update();
}
void KoRuler::setOffset( int _diffx, int _diffy )
{
//kdDebug() << "KoRuler::setOffset " << _diffx << "," << _diffy << endl;
diffx = _diffx;
diffy = _diffy;
update();
}
void KoRuler::setFrameStartEnd( int _frameStart, int _frameEnd )
{
if ( _frameStart != frameStart || _frameEnd != d->frameEnd || !m_bFrameStartSet )
{
frameStart = _frameStart;
d->frameEnd = _frameEnd;
// Remember that setFrameStartEnd was called. This activates a slightly
// different mode (when moving start and end positions).
m_bFrameStartSet = true;
update();
}
}
void KoRuler::setRightIndent( double _right )
{
d->i_right = makeIntern( _right );
update();
}
void KoRuler::setDirection( bool rtl )
{
d->rtl = rtl;
update();
}
void KoRuler::changeFlags(int _flags)
{
d->flags = _flags;
}
int KoRuler::flags() const
{
return d->flags;
}
bool KoRuler::doubleClickedIndent() const
{
return d->doubleClickedIndent;
}
double KoRuler::applyRtlAndZoom( double value ) const
{
int frameWidth = d->frameEnd - frameStart;
return d->rtl ? ( frameWidth - zoomIt( value ) ) : zoomIt( value );
}
double KoRuler::unZoomItRtl( int pixValue ) const
{
int frameWidth = d->frameEnd - frameStart;
return d->rtl ? ( unZoomIt( (double)(frameWidth - pixValue) ) ) : unZoomIt( (double)pixValue );
}
void KoRuler::slotMenuActivated( int i )
{
if ( i >= 0 && i <= KoUnit::U_LASTUNIT )
{
KoUnit::Unit unit = static_cast<KoUnit::Unit>(i);
setUnit( unit );
emit unitChanged( unit );
}
}
TQSize KoRuler::minimumSizeHint() const
{
TQSize size;
TQFont font = KGlobalSettings::toolBarFont();
TQFontMetrics fm( font );
size.setWidth( TQMAX( fm.height() + 4, 20 ) );
size.setHeight( TQMAX( fm.height() + 4, 20 ) );
return size;
}
TQSize KoRuler::sizeHint() const
{
return minimumSizeHint();
}
void KoRuler::setPageLayout( const KoPageLayout& _layout )
{
d->layout = _layout;
update();
}
#include "KoRuler.moc"