TDE
/
koffice
mirror of https://mirror.git.trinitydesktop.org/gitea/TDE/koffice
0
0
Fork 0
Code Issues Releases Wiki Activity
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.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'd7ae9fb514'
${ noResults }
koffice/kspread/kspread_editors.cpp

1590 lines
44 KiB
Raw Blame History

/* This file is part of the KDE project
Copyright 1999-2006 The KSpread Team <koffice-devel@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.
*/
#include "kspread_editors.h"
#include "kspread_canvas.h"
#include "kspread_cell.h"
#include "kspread_doc.h"
#include "selection.h"
#include "kspread_sheet.h"
#include "kspread_view.h"
#include "kspread_util.h"
#include "formula.h"
#include "functions.h"
#include <tdelistbox.h>
#include <tqapplication.h>
#include <tqlistbox.h>
#include <tqtimer.h>
#include <tqlabel.h>
#include <tqvbox.h>
#include <tqvaluelist.h>
#include <tqrichtext_p.h>
//#include <klineedit.h>
#include <ktextedit.h>
#include <tqapplication.h>
#include <tqbutton.h>
#include <tqfont.h>
#include <tqfontmetrics.h>
#include <tqregexp.h>
#include <kdebug.h>
using namespace KSpread;
/*****************************************************************************
*
* FormulaEditorHighlighter
*
****************************************************************************/
namespace KSpread
{
class FormulaEditorHighlighter::Private
{
public:
Private()
{
canvas = 0;
tokens = Tokens();
rangeCount = 0;
rangeChanged = false;
}
// source for cell reference checking
Canvas* canvas;
Tokens tokens;
uint rangeCount;
bool rangeChanged;
};
FormulaEditorHighlighter::FormulaEditorHighlighter(TQTextEdit* textEdit, Canvas* canvas)
: TQSyntaxHighlighter(textEdit)
{
d = new Private();
d->canvas = canvas;
}
FormulaEditorHighlighter::~FormulaEditorHighlighter()
{
delete d;
}
const Tokens& FormulaEditorHighlighter::formulaTokens() const
{
return d->tokens;
}
int FormulaEditorHighlighter::highlightParagraph(const TQString& text, int /* endStateOfLastPara */)
{
// reset syntax highlighting
setFormat(0, text.length(), TQt::black);
// save the old ones to identify range changes
Tokens oldTokens = d->tokens;
// interpret the text as formula
// we accept invalid/incomplete formulas
Formula f;
d->tokens = f.scan(text);
TQFont editorFont = textEdit()->currentFont();
TQFont font;
uint oldRangeCount = d->rangeCount;
d->rangeCount = 0;
TQValueList<TQColor> colors = d->canvas->choice()->colors();
TQValueList<Range> alreadyFoundRanges;
for (uint i = 0; i < d->tokens.count(); ++i)
{
Token token = d->tokens[i];
Token::Type type = token.type();
switch (type)
{
case Token::Cell:
case Token::Range:
{
// don't compare, if we have already found a change
if (!d->rangeChanged && i < oldTokens.count() && token.text() != oldTokens[i].text())
{
d->rangeChanged = true;
}
Range newRange( token.text() );
if (!alreadyFoundRanges.contains(newRange))
{
alreadyFoundRanges.append(newRange);
d->rangeCount++;
}
setFormat(token.pos() + 1, token.text().length(), colors[ alreadyFoundRanges.findIndex(newRange) % colors.size()] );
}
break;
case Token::Boolean: // True, False (also i18n-ized)
/* font = TQFont(editorFont);
font.setBold(true);
setFormat(token.pos() + 1, token.text().length(), font);*/
break;
case Token::Identifier: // function name or named area*/
/* font = TQFont(editorFont);
font.setBold(true);
setFormat(token.pos() + 1, token.text().length(), font);*/
break;
case Token::Unknown:
case Token::Integer: // 14, 3, 1977
case Token::Float: // 3.141592, 1e10, 5.9e-7
case Token::String: // "KOffice", "The quick brown fox..."
case Token::Operator: // +, *, /, -
{
switch (token.asOperator())
{
case Token::LeftPar:
case Token::RightPar:
//Check where this brace is in relation to the cursor and highlight it if necessary.
handleBrace( i );
break;
default:
break;
}
}
break;
}
}
if (oldRangeCount != d->rangeCount)
d->rangeChanged = true;
return 0;
}
void FormulaEditorHighlighter::handleBrace( uint index )
{
int cursorParagraph;
int cursorPos;
const Token& token = d->tokens.at( index );
textEdit()->getCursorPosition( &cursorParagraph , &cursorPos );
int distance = cursorPos-token.pos();
int opType = token.asOperator();
bool highlightBrace=false;
//Check where the cursor is in relation to this left or right parenthesis token.
//Only one pair of braces should be highlighted at a time, and if the cursor
//is between two braces, the inner-most pair should be highlighted.
if ( opType == Token::LeftPar )
{
//If cursor is directly to the left of this left brace, highlight it
if ( distance == 1 )
highlightBrace=true;
else
//Cursor is directly to the right of this left brace, highlight it unless
//there is another left brace to the right (in which case that should be highlighted instead as it
//is the inner-most brace)
if (distance==2)
if ( (index == d->tokens.count()-1) || ( d->tokens.at(index+1).asOperator() != Token::LeftPar) )
highlightBrace=true;
}
else
{
//If cursor is directly to the right of this right brace, highlight it
if ( distance == 2 )
highlightBrace=true;
else
//Cursor is directly to the left of this right brace, so highlight it unless
//there is another right brace to the left (in which case that should be highlighted instead as it
//is the inner-most brace)
if ( distance == 1 )
if ( (index == 0) || (d->tokens.at(index-1).asOperator() != Token::RightPar) )
highlightBrace=true;
}
if (highlightBrace)
{
TQFont font = TQFont( textEdit()->currentFont() );
font.setBold(true);
setFormat(token.pos() + 1, token.text().length(), font);
int matching = findMatchingBrace( index );
if (matching != -1)
{
Token matchingBrace = d->tokens.at(matching);
setFormat( matchingBrace.pos() + 1 , matchingBrace.text().length() , font);
}
}
}
int FormulaEditorHighlighter::findMatchingBrace(int pos)
{
int depth=0;
int step=0;
Tokens tokens = d->tokens;
//If this is a left brace we need to step forwards through the text to find the matching right brace,
//otherwise, it is a right brace so we need to step backwards through the text to find the matching left
//brace.
if (tokens.at(pos).asOperator() == Token::LeftPar)
step = 1;
else
step = -1;
for (int index=pos ; (index >= 0) && (index < (int) tokens.count() ) ; index += step )
{
if (tokens.at(index).asOperator() == Token::LeftPar)
depth++;
if (tokens.at(index).asOperator() == Token::RightPar)
depth--;
if (depth == 0)
{
return index;
}
}
return -1;
}
uint FormulaEditorHighlighter::rangeCount() const
{
return d->rangeCount;
}
bool FormulaEditorHighlighter::rangeChanged() const
{
return d->rangeChanged;
}
void FormulaEditorHighlighter::resetRangeChanged()
{
d->rangeChanged=false;
}
} // namespace KSpread
/*****************************************************************************
*
* FunctionCompletion
*
****************************************************************************/
class FunctionCompletion::Private
{
public:
CellEditor* editor;
TQVBox *completionPopup;
TDEListBox *completionListBox;
TQLabel* hintLabel;
};
FunctionCompletion::FunctionCompletion( CellEditor* editor ):
TQObject( editor )
{
d = new Private;
d->editor = editor;
d->hintLabel = 0;
d->completionPopup = new TQVBox( editor->topLevelWidget(), 0, WType_Popup );
d->completionPopup->setFrameStyle( TQFrame::Box | TQFrame::Plain );
d->completionPopup->setLineWidth( 1 );
d->completionPopup->installEventFilter( this );
d->completionPopup->setSizePolicy( TQSizePolicy::Expanding, TQSizePolicy::Minimum);
d->completionListBox = new TDEListBox( d->completionPopup );
d->completionPopup->setFocusProxy( d->completionListBox );
d->completionListBox->setFrameStyle( TQFrame::NoFrame );
d->completionListBox->setVariableWidth( true );
d->completionListBox->installEventFilter( this );
connect( d->completionListBox, TQT_SIGNAL(selected(const TQString&)), this,
TQT_SLOT(itemSelected(const TQString&)) );
connect( d->completionListBox, TQT_SIGNAL(highlighted(const TQString&)), this,
TQT_SLOT(itemSelected(const TQString&)) );
d->hintLabel = new TQLabel( 0, "autocalc", TQt::WStyle_StaysOnTop |
TQt::WStyle_Customize | TQt::WStyle_NoBorder | TQt::WStyle_Tool | TQt::WX11BypassWM );
d->hintLabel->setFrameStyle( TQFrame::Plain | TQFrame::Box );
d->hintLabel->setPalette( TQToolTip::palette() );
d->hintLabel->hide();
}
FunctionCompletion::~FunctionCompletion()
{
delete d->hintLabel;
delete d;
}
void FunctionCompletion::itemSelected( const TQString& item )
{
KSpread::FunctionDescription* desc;
desc = KSpread::FunctionRepository::self()->functionInfo(item);
if(!desc)
{
d->hintLabel->hide();
return;
}
TQString helpText = desc->helpText()[0];
if( helpText.isEmpty() )
{
d->hintLabel->hide();
return;
}
helpText.append("</qt>").prepend("<qt>");
d->hintLabel->setText( helpText );
d->hintLabel->adjustSize();
// reposition nicely
TQPoint pos = d->editor->mapToGlobal( TQPoint( d->editor->width(), 0 ) );
pos.setY( pos.y() - d->hintLabel->height() - 1 );
d->hintLabel->move( pos );
d->hintLabel->show();
d->hintLabel->raise();
// do not show it forever
//TQTimer::singleShot( 5000, d->hintLabel, TQT_SLOT( hide()) );
}
bool FunctionCompletion::eventFilter( TQObject *obj, TQEvent *ev )
{
if ( obj == d->completionPopup || obj == d->completionListBox )
{
if ( ev->type() == TQEvent::KeyPress )
{
TQKeyEvent *ke = (TQKeyEvent*)ev;
if ( ke->key() == Key_Enter || ke->key() == Key_Return )
{
doneCompletion();
return true;
}
else if ( ke->key() == Key_Left || ke->key() == Key_Right ||
ke->key() == Key_Up || ke->key() == Key_Down ||
ke->key() == Key_Home || ke->key() == Key_End ||
ke->key() == Key_Prior || ke->key() == Key_Next )
return false;
d->hintLabel->hide();
d->completionPopup->close();
d->editor->setFocus();
TQApplication::sendEvent( d->editor, ev );
return true;
}
if ( ev->type() == TQEvent::MouseButtonDblClick )
{
doneCompletion();
return true;
}
}
return false;
}
void FunctionCompletion::doneCompletion()
{
d->hintLabel->hide();
d->completionPopup->close();
d->editor->setFocus();
emit selectedCompletion( d->completionListBox->currentText() );
}
void FunctionCompletion::showCompletion( const TQStringList &choices )
{
if( !choices.count() ) return;
d->completionListBox->clear();
for( unsigned i = 0; i < choices.count(); i++ )
new TQListBoxText( (TQListBox*)d->completionListBox, choices[i] );
d->completionListBox->setCurrentItem( 0 );
// size of the pop-up
d->completionPopup->setMaximumHeight( 100 );
d->completionPopup->resize( d->completionListBox->sizeHint() +
TQSize( d->completionListBox->verticalScrollBar()->width() + 4,
d->completionListBox->horizontalScrollBar()->height() + 4 ) );
int h = d->completionListBox->height();
int w = d->completionListBox->width();
TQPoint pos = d->editor->globalCursorPosition();
// if popup is partially invisible, move to other position
// FIXME check it if it works in Xinerama multihead
int screen_num = TQApplication::desktop()->screenNumber( d->completionPopup );
TQRect screen = TQApplication::desktop()->screenGeometry( screen_num );
if( pos.y() + h > screen.y()+screen.height() )
pos.setY( pos.y() - h - d->editor->height() );
if( pos.x() + w > screen.x()+screen.width() )
pos.setX( screen.x()+screen.width() - w );
d->completionPopup->move( pos );
d->completionListBox->setFocus();
d->completionPopup->show();
}
/****************************************************************************
*
* CellEditor
*
****************************************************************************/
class CellEditor::Private
{
public:
Cell* cell;
Canvas* canvas;
KTextEdit* textEdit;
FormulaEditorHighlighter* highlighter;
FunctionCompletion* functionCompletion;
TQTimer* functionCompletionTimer;
TQPoint globalCursorPos;
bool captureAllKeyEvents : 1;
bool checkChoice : 1;
bool updateChoice : 1;
bool updatingChoice : 1;
uint length;
uint fontLength;
uint length_namecell;
uint length_text;
uint currentToken;
uint rangeCount;
};
CellEditor::CellEditor( Cell* _cell, Canvas* _parent, bool captureAllKeyEvents, const char* _name )
: TQWidget( _parent, _name )
{
d = new Private();
d->cell = _cell;
d->canvas = _parent;
d->textEdit = new KTextEdit(this);
d->globalCursorPos = TQPoint();
d->captureAllKeyEvents = captureAllKeyEvents;
d->checkChoice = true;
d->updateChoice = true;
d->updatingChoice = false;
d->length = 0;
d->fontLength = 0;
d->length_namecell = 0;
d->length_text = 0;
d->currentToken = 0;
d->rangeCount = 0;
//TODO - Get rid of TQTextEdit margins, this doesn't seem easily possible in TQt 3.3, so a job for TQt 4 porting.
d->textEdit->setHScrollBarMode(TQScrollView::AlwaysOff);
d->textEdit->setVScrollBarMode(TQScrollView::AlwaysOff);
d->textEdit->setFrameStyle(TQFrame::NoFrame);
d->textEdit->setLineWidth(0);
d->textEdit->installEventFilter( this );
d->highlighter = new FormulaEditorHighlighter(d->textEdit, _parent);
d->functionCompletion = new FunctionCompletion( this );
d->functionCompletionTimer = new TQTimer( this );
connect( d->functionCompletion, TQT_SIGNAL( selectedCompletion( const TQString& ) ),
TQT_SLOT( functionAutoComplete( const TQString& ) ) );
connect( d->textEdit, TQT_SIGNAL( textChanged() ), TQT_SLOT( checkFunctionAutoComplete() ) );
connect( d->functionCompletionTimer, TQT_SIGNAL( timeout() ),
TQT_SLOT( triggerFunctionAutoComplete() ) );
if (!cell()->format()->multiRow(cell()->column(),cell()->row()))
d->textEdit->setWordWrap(TQTextEdit::NoWrap);
else
d->textEdit->setWrapPolicy(TQTextEdit::AtWordOrDocumentBoundary);
//TODO - Custom KTextEdit class which supports text completion
/*
d->textEdit->setFrame( false );
d->textEdit->setCompletionMode((TDEGlobalSettings::Completion)canvas()->view()->doc()->completionMode() );
d->textEdit->setCompletionObject( &canvas()->view()->doc()->completion(),true );
*/
setFocusProxy( d->textEdit );
connect( d->textEdit, TQT_SIGNAL( cursorPositionChanged(int,int) ), this, TQT_SLOT (slotCursorPositionChanged(int,int)));
connect( d->textEdit, TQT_SIGNAL( cursorPositionChanged(TQTextCursor*) ), this, TQT_SLOT (slotTextCursorChanged(TQTextCursor*)));
connect( d->textEdit, TQT_SIGNAL( textChanged() ), this, TQT_SLOT( slotTextChanged() ) );
// connect( d->textEdit, TQT_SIGNAL(completionModeChanged( TDEGlobalSettings::Completion )),this,TQT_SLOT (slotCompletionModeChanged(TDEGlobalSettings::Completion)));
// A choose should always start at the edited cell
// canvas()->setChooseMarkerRow( canvas()->markerRow() );
// canvas()->setChooseMarkerColumn( canvas()->markerColumn() );
// set font size according to zoom factor
TQFont font( _cell->format()->font() );
font.setPointSizeFloat( 0.01 * _parent->doc()->zoom() * font.pointSizeFloat() );
d->textEdit->setFont( font );
if (d->fontLength == 0)
{
TQFontMetrics fm( d->textEdit->font() );
d->fontLength = fm.width('x');
}
}
CellEditor::~CellEditor()
{
canvas()->endChoose();
delete d->highlighter;
delete d->functionCompletion;
delete d->functionCompletionTimer;
delete d;
}
Cell* CellEditor::cell() const
{
return d->cell;
}
Canvas* CellEditor::canvas() const
{
return d->canvas;
}
TQPoint CellEditor::globalCursorPosition() const
{
return d->globalCursorPos;
}
void CellEditor::checkFunctionAutoComplete()
{
d->functionCompletionTimer->stop();
d->functionCompletionTimer->start( 2000, true );
}
void CellEditor::triggerFunctionAutoComplete()
{
// tokenize the expression (don't worry, this is very fast)
int para = 0, curPos = 0;
d->textEdit->getCursorPosition( &para, &curPos );
TQString subtext = d->textEdit->text().left( curPos );
KSpread::Formula f;
KSpread::Tokens tokens = f.scan( subtext );
if( !tokens.valid() ) return;
if( tokens.count()<1 ) return;
KSpread::Token lastToken = tokens[ tokens.count()-1 ];
// last token must be an identifier
if( !lastToken.isIdentifier() ) return;
TQString id = lastToken.text();
if( id.length() < 1 ) return;
// find matches in function names
TQStringList fnames = KSpread::FunctionRepository::self()->functionNames();
TQStringList choices;
for( unsigned i=0; i<fnames.count(); i++ )
if( fnames[i].startsWith( id, false ) )
choices.append( fnames[i] );
choices.sort();
// no match, don't bother with completion
if( !choices.count() ) return;
// single perfect match, no need to give choices
if( choices.count()==1 )
if( choices[0].lower() == id.lower() )
return;
// present the user with completion choices
d->functionCompletion->showCompletion( choices );
}
void CellEditor::functionAutoComplete( const TQString& item )
{
if( item.isEmpty() ) return;
int para = 0, curPos = 0;
d->textEdit->getCursorPosition( &para, &curPos );
TQString subtext = text().left( curPos );
KSpread::Formula f;
KSpread::Tokens tokens = f.scan( subtext );
if( !tokens.valid() ) return;
if( tokens.count()<1 ) return;
KSpread::Token lastToken = tokens[ tokens.count()-1 ];
if( !lastToken.isIdentifier() ) return;
d->textEdit->blockSignals( true );
d->textEdit->setSelection( 0, lastToken.pos()+1, 0, lastToken.pos()+lastToken.text().length()+1 );
d->textEdit->insert( item );
d->textEdit->blockSignals( false );
}
void CellEditor::slotCursorPositionChanged(int /* para */, int pos)
{
// kdDebug() << k_funcinfo << endl;
// TODO Stefan: optimize this function!
// turn choose mode on/off
if (!checkChoice())
return;
d->highlighter->rehighlight();
Tokens tokens = d->highlighter->formulaTokens();
uint rangeCounter = 0;
uint currentRange = 0;
uint regionStart = 0;
uint regionEnd = 0;
bool lastWasASemicolon = false;
d->currentToken = 0;
uint rangeCount = d->highlighter->rangeCount();
d->rangeCount = rangeCount;
Token token;
Token::Type type;
// search the current token
// determine the subregion number, btw
for (uint i = 0; i < tokens.count(); ++i)
{
if (tokens[i].pos() >= pos - 1) // without '='
{
/* kdDebug() << "token.pos >= cursor.pos" << endl;*/
type = tokens[i].type();
if (type == Token::Cell || type == Token::Range)
{
if (lastWasASemicolon)
{
regionEnd = rangeCounter++;
lastWasASemicolon = false;
continue;
}
}
if (type == Token::Operator && tokens[i].asOperator() == Token::Semicolon)
{
lastWasASemicolon = true;
continue;
}
lastWasASemicolon = false;
break;
}
token = tokens[i];
d->currentToken = i;
type = token.type();
if (type == Token::Cell || type == Token::Range)
{
if (!lastWasASemicolon)
{
regionStart = rangeCounter;
}
regionEnd = rangeCounter;
currentRange = rangeCounter++;
}
// semicolons are use as deliminiters in regions
if (type == Token::Operator)
{
if (token.asOperator() == Token::Semicolon)
{
lastWasASemicolon = true;
}
else
{
lastWasASemicolon = false;
// set the region start to the next element
regionStart = currentRange + 1;
regionEnd = regionStart - 1; // len = 0
}
}
}
// kdDebug() << "regionStart = " << regionStart/* << endl*/
// << ", regionEnd = " << regionEnd/* << endl*/
// << ", currentRange = " << currentRange << endl;
d->canvas->choice()->setActiveElement(currentRange);
d->canvas->choice()->setActiveSubRegion(regionStart, regionEnd-regionStart+1);
// triggered by keyboard action?
if (!d->updatingChoice)
{
if (d->highlighter->rangeChanged())
{
d->highlighter->resetRangeChanged();
disconnect( d->canvas->choice(), TQT_SIGNAL(changed(const Region&)),
d->canvas->view(), TQT_SLOT(slotScrollChoice(const Region&)) );
d->canvas->doc()->emitBeginOperation();
setUpdateChoice(false);
Tokens tokens = d->highlighter->formulaTokens();
d->canvas->choice()->update(); // set the old one dirty
d->canvas->choice()->clear();
Region tmpRegion;
Region::ConstIterator it;
//A list of regions which have already been highlighted on the spreadsheet.
//This is so that we don't end up highlighting the same region twice in two different
//colours.
TQValueList<Region> alreadyUsedRegions;
for (uint i = 0; i < tokens.count(); ++i)
{
Token token = tokens[i];
Token::Type type = token.type();
if (type == Token::Cell || type == Token::Range)
{
Region region(d->canvas->view(), token.text());
it = region.constBegin();
if (!alreadyUsedRegions.contains(region))
{
TQRect r=(*it)->rect();
if (d->canvas->choice()->isEmpty())
d->canvas->choice()->initialize((*it)->rect(), (*it)->sheet());
else
d->canvas->choice()->extend((*it)->rect(), (*it)->sheet());
alreadyUsedRegions.append(region);
}
}
}
setUpdateChoice(true);
d->canvas->doc()->emitEndOperation(*d->canvas->choice());
connect( d->canvas->choice(), TQT_SIGNAL(changed(const Region&)),
d->canvas->view(), TQT_SLOT(slotScrollChoice(const Region&)) );
}
}
}
void CellEditor::slotTextCursorChanged(TQTextCursor* cursor)
{
TQTextStringChar *chr = cursor->paragraph()->at( cursor->index() );
int h = cursor->paragraph()->lineHeightOfChar( cursor->index() );
int x = cursor->paragraph()->rect().x() + chr->x;
int y, dummy;
cursor->paragraph()->lineHeightOfChar( cursor->index(), &dummy, &y );
y += cursor->paragraph()->rect().y();
d->globalCursorPos = d->textEdit->mapToGlobal( d->textEdit-> contentsToViewport( TQPoint( x, y + h ) ) );
}
void CellEditor::cut()
{
d->textEdit->cut();
}
void CellEditor::paste()
{
d->textEdit->paste();
}
void CellEditor::copy()
{
d->textEdit->copy();
}
void CellEditor::setEditorFont(TQFont const & font, bool updateSize)
{
TQFont tmpFont( font );
tmpFont.setPointSizeFloat( 0.01 * canvas()->doc()->zoom() * tmpFont.pointSizeFloat() );
d->textEdit->setFont( tmpFont );
if (updateSize)
{
TQFontMetrics fm( d->textEdit->font() );
d->fontLength = fm.width('x');
int mw = fm.width( d->textEdit->text() ) + d->fontLength;
// don't make it smaller: then we would have to repaint the obscured cells
if (mw < width())
mw = width();
int mh = fm.height();
if (mh < height())
mh = height();
setGeometry(x(), y(), mw, mh);
}
}
void CellEditor::slotCompletionModeChanged(TDEGlobalSettings::Completion _completion)
{
canvas()->view()->doc()->setCompletionMode( _completion );
}
void CellEditor::slotTextChanged()
{
// kdDebug() << k_funcinfo << endl;
//FIXME - text() may return richtext?
TQString t = text();
if (t.length() > d->length)
{
d->length = t.length();
TQFontMetrics fm(d->textEdit->font());
// - requiredWidth = width of text plus some spacer characters
int requiredWidth = fm.width(t) + (2*fm.width('x'));
//For normal single-row cells, the text editor must be expanded horizontally to
//allow the text to fit if the new text is too wide
//For multi-row (word-wrap enabled) cells, the text editor must expand vertically to
//allow for new rows of text & the width of the text editor is not affected
if (d->textEdit->wordWrap() == TQTextEdit::NoWrap)
{
if (requiredWidth > width())
{
if (t.isRightToLeft())
{
setGeometry(x() - requiredWidth + width(), y(), requiredWidth,height());
}
else
{
setGeometry(x(), y(), requiredWidth,height());
}
}
}
else
{
int requiredHeight = d->textEdit->heightForWidth(width());
if (requiredHeight > height())
{
setGeometry(x(), y(), width(), requiredHeight);
}
}
/* // allocate more space than needed. Otherwise it might be too slow
d->length = t.length();
// Too slow for long texts
// TQFontMetrics fm( d->textEdit->font() );
// int mw = fm.width( t ) + fm.width('x');
int mw = d->fontLength * d->length;
if (mw < width())
mw = width();
if (t.isRightToLeft())
setGeometry(x() - mw + width(), y(), mw, height());
else
setGeometry(x(), y(), mw, height());
d->length -= 2; */
}
if ( (cell()->formatType()) == Percentage_format )
{
if ( (t.length() == 1) && t[0].isDigit() )
{
TQString tmp = t + " %";
d->textEdit->setText(tmp);
d->textEdit->setCursorPosition(0,1);
return;
}
}
canvas()->view()->editWidget()->setText( t );
// canvas()->view()->editWidget()->setCursorPosition( d->textEdit->cursorPosition() );
}
void CellEditor::setCheckChoice(bool state)
{
d->checkChoice = state;
}
bool CellEditor::checkChoice()
{
if (!d->checkChoice)
return false;
// // prevent recursion
// d->checkChoice = false; // TODO nescessary?
d->length_namecell = 0;
d->currentToken = 0;
TQString text = d->textEdit->text();
if ( text[0] != '=' )
{
canvas()->setChooseMode(false);
}
else
{
int para, cur;
d->textEdit->getCursorPosition(&para, &cur);
Tokens tokens = d->highlighter->formulaTokens();
// empty formula?
if (tokens.count() < 1)
{
canvas()->startChoose();
}
else
{
Token token;
for (uint i = 0; i < tokens.count(); ++i)
{
if (tokens[i].pos() >= cur - 1) // without '='
{
break;
}
token = tokens[i];
d->currentToken = i;
}
Token::Type type = token.type();
if (type == Token::Operator && token.asOperator() != Token::RightPar)
{
canvas()->setChooseMode(true);
}
else if (type == Token::Cell || type == Token::Range)
{
d->length_namecell = token.text().length();
canvas()->setChooseMode(true);
}
else
{
canvas()->setChooseMode(false);
}
}
}
// d->checkChoice = true;
return true;
}
void CellEditor::setUpdateChoice(bool state)
{
d->updateChoice = state;
}
void CellEditor::updateChoice()
{
// kdDebug() << k_funcinfo << endl;
if (!d->updateChoice)
return;
// // prevent recursion
// d->updateChoice = false; // TODO nescessary?
d->updatingChoice = true;
Selection* choice = d->canvas->choice();
if (choice->isEmpty())
return;
if (!choice->activeElement())
return;
// only one element TODO
if (++choice->constBegin() == choice->constEnd())
{
}
TQString name_cell = choice->activeSubRegionName();
Tokens tokens = d->highlighter->formulaTokens();
uint start = 1;
uint length = 0;
if (!tokens.empty())
{
Token token = tokens[d->currentToken];
Token::Type type = token.type();
if (type == Token::Cell || type == Token::Range)
{
start = token.pos() + 1; // don't forget the '='!
length = token.text().length();
}
else
{
start = token.pos() + token.text().length() + 1;
}
}
d->length_namecell = name_cell.length();
d->length_text = text().length();
//kdDebug(36001) << "updateChooseMarker2 len=" << d->length_namecell << endl;
TQString oldText = text();
TQString newText = oldText.left(start) + name_cell + oldText.right(d->length_text - start - length);
setCheckChoice( false );
setText( newText );
setCheckChoice( true );
setCursorPosition( start + d->length_namecell );
d->canvas->view()->editWidget()->setText( newText );
//kdDebug(36001) << "old=" << old << " len=" << d->length_namecell << " pos=" << pos << endl;
// d->updateChoice = false;
d->updatingChoice = false;
}
void CellEditor::resizeEvent( TQResizeEvent* )
{
d->textEdit->setGeometry( 0, 0, width(), height() );
}
void CellEditor::handleKeyPressEvent( TQKeyEvent * _ev )
{
if (_ev->key() == TQt::Key_F4)
{
if (d->textEdit == 0)
{
TQApplication::sendEvent( d->textEdit, _ev );
return;
}
TQRegExp exp("(\\$?)([a-zA-Z]+)(\\$?)([0-9]+)$");
int para,cur;
d->textEdit->getCursorPosition(&para,&cur);
// int cur = d->textEdit->cursorPosition();
TQString tmp, tmp2;
int n = -1;
// this is ugly, and sort of hack
// FIXME rewrite to use the real Tokenizer
unsigned i;
for( i = 0; i < 10; i++ )
{
tmp = d->textEdit->text().left( cur+i );
tmp2 = d->textEdit->text().right( d->textEdit->text().length() - cur - i );
n = exp.search(tmp);
if( n >= 0 ) break;
}
if (n == -1) return;
TQString newPart;
if ((exp.cap(1) == "$") && (exp.cap(3) == "$"))
newPart = "$" + exp.cap(2) + exp.cap(4);
else if ((exp.cap(1) != "$") && (exp.cap(3) != "$"))
newPart = "$" + exp.cap(2) + "$" + exp.cap(4);
else if ((exp.cap(1) == "$") && (exp.cap(3) != "$"))
newPart = exp.cap(2) + "$" + exp.cap(4);
else if ((exp.cap(1) != "$") && (exp.cap(3) == "$"))
newPart = exp.cap(2) + exp.cap(4);
TQString newString = tmp.left(n);
newString += newPart;
cur = newString.length() - i;
newString += tmp2;
d->textEdit->setText(newString);
d->textEdit->setCursorPosition( 0, cur );
_ev->accept();
return;
}
// Send the key event to the KLineEdit
TQApplication::sendEvent( d->textEdit, _ev );
}
void CellEditor::handleIMEvent( TQIMEvent * _ev )
{
// send the IM event to the KLineEdit
TQApplication::sendEvent( d->textEdit, _ev );
}
TQString CellEditor::text() const
{
return d->textEdit->text();
}
void CellEditor::setText(TQString text)
{
d->textEdit->setText(text);
//Usability : It is usually more convenient if the cursor is positioned at the end of the text so it can
//be quickly deleted using the backspace key
//This also ensures that the caret is sized correctly for the text
d->textEdit->setCursorPosition(0,text.length());
if (d->fontLength == 0)
{
TQFontMetrics fm( d->textEdit->font() );
d->fontLength = fm.width('x');
}
}
int CellEditor::cursorPosition() const
{
int para,cur;
d->textEdit->getCursorPosition(&para,&cur);
return cur;
// return d->textEdit->cursorPosition();
}
void CellEditor::setCursorPosition( int pos )
{
d->textEdit->setCursorPosition(0,pos);
canvas()->view()->editWidget()->setCursorPosition( pos );
}
bool CellEditor::eventFilter( TQObject* o, TQEvent* e )
{
// Only interested in KTextEdit
if ( o != d->textEdit )
return false;
if ( e->type() == TQEvent::FocusOut )
{
canvas()->setLastEditorWithFocus( Canvas::CellEditor );
return false;
}
if ( e->type() == TQEvent::KeyPress || e->type() == TQEvent::KeyRelease )
{
TQKeyEvent* k = (TQKeyEvent*)e;
if (!(k->state() & TQt::ShiftButton) || canvas()->chooseMode())
{
//If the user presses the return key to finish editing this cell, choose mode must be turned off first
//otherwise it will merely select a different cell
if (k->key() == Key_Return || k->key() == Key_Enter)
{
kdDebug() << "CellEditor::eventFilter: canvas()->endChoose();" << endl;
canvas()->endChoose();
}
//NB - Added check for Key_Return when migrating text edit from KLineEdit to KTextEdit, since
//normal behaviour for KTextEdit is to swallow return key presses
if ( k->key() == Key_Up || k->key() == Key_Down ||
k->key() == Key_Next || k->key() == Key_Prior ||
k->key() == Key_Escape || k->key() == Key_Tab ||
k->key() == Key_Return || k->key() == Key_Enter)
{
// Send directly to canvas
TQApplication::sendEvent( parent(), e );
return true;
}
}
else if ( k->state() & TQt::ShiftButton && ( k->key() == Key_Return || k->key() == Key_Enter ) )
{
// enable content wrapping
d->cell->format()->setMultiRow( true );
}
// End choosing. May be restarted by CellEditor::slotTextChanged
if ( e->type() == TQEvent::KeyPress && !k->text().isEmpty() )
{
canvas()->setChooseMode(false);
}
// forward Left/Right keys - so that pressing left/right in this
// editor leaves editing mode ... otherwise editing is annoying
// left/right arrows still work with the F2-editor.
// Forward left & right arrows to parent, unless this editor has been set to capture arrow key events
// Changed to this behaviour for consistancy with OO Calc & MS Office.
if ( ((k->key() == TQt::Key_Left) || (k->key() == TQt::Key_Right)) && (!d->captureAllKeyEvents)) {
TQApplication::sendEvent (parent(), e);
return true;
}
}
return false;
}
void CellEditor::setCursorToRange(uint pos)
{
// kdDebug() << k_funcinfo << endl;
d->updatingChoice = true;
uint counter = 0;
Tokens tokens = d->highlighter->formulaTokens();
for (uint i = 0; i < tokens.count(); ++i)
{
Token token = tokens[i];
Token::Type type = token.type();
if (type == Token::Cell || type == Token::Range)
{
if (counter == pos)
{
setCursorPosition(token.pos() + token.text().length() + 1);
}
counter++;
}
}
d->updatingChoice = false;
}
/*****************************************************************************
*
* ComboboxLocationEditWidget
*
****************************************************************************/
ComboboxLocationEditWidget::ComboboxLocationEditWidget( TQWidget * _parent,
View * _view )
: KComboBox( _parent, "ComboboxLocationEditWidget" )
{
m_locationWidget = new LocationEditWidget( _parent, _view );
setLineEdit( m_locationWidget );
insertItem( "" );
TQValueList<Reference>::Iterator it;
TQValueList<Reference> area = _view->doc()->listArea();
for ( it = area.begin(); it != area.end(); ++it )
slotAddAreaName( (*it).ref_name);
connect( this, TQT_SIGNAL( activated ( const TQString & ) ), m_locationWidget, TQT_SLOT( slotActivateItem() ) );
}
void ComboboxLocationEditWidget::slotAddAreaName( const TQString &_name)
{
insertItem( _name );
m_locationWidget->addCompletionItem( _name );
}
void ComboboxLocationEditWidget::slotRemoveAreaName( const TQString &_name )
{
for ( int i = 0; i<count(); i++ )
{
if ( text(i)==_name )
{
removeItem( i );
break;
}
}
m_locationWidget->removeCompletionItem( _name );
}
/*****************************************************************************
*
* LocationEditWidget
*
****************************************************************************/
LocationEditWidget::LocationEditWidget( TQWidget * _parent,
View * _view )
: KLineEdit( _parent, "LocationEditWidget" ),
m_pView(_view)
{
setCompletionObject( &completionList,true );
setCompletionMode(TDEGlobalSettings::CompletionAuto );
}
void LocationEditWidget::addCompletionItem( const TQString &_item )
{
kdDebug()<<" LocationEditWidget::addCompletionItem add :"<<_item<<endl;
if ( completionList.items().contains( _item) == 0 )
{
completionList.addItem( _item );
kdDebug()<<" _utem :"<<_item<<endl;
kdDebug()<<" completionList.items().count()"<<completionList.items().count()<<endl;
}
}
void LocationEditWidget::removeCompletionItem( const TQString &_item )
{
completionList.removeItem( _item );
}
void LocationEditWidget::slotActivateItem()
{
activateItem();
}
bool LocationEditWidget::activateItem()
{
TQString ltext = text();
TQString tmp = ltext.lower();
TQValueList<Reference>::Iterator it;
TQValueList<Reference> area = m_pView->doc()->listArea();
for ( it = area.begin(); it != area.end(); ++it )
{
if ((*it).ref_name == tmp)
{
TQString tmp = (*it).sheet_name;
tmp += "!";
tmp += util_rangeName((*it).rect);
m_pView->selectionInfo()->initialize( Region(m_pView,tmp) );
return true;
}
}
// Set the cell component to uppercase:
// Sheet1!a1 -> Sheet1!A2
int pos = ltext.find('!');
if ( pos !=- 1 )
tmp = ltext.left(pos)+ltext.mid(pos).upper();
else
tmp = ltext.upper();
// Selection entered in location widget
if ( ltext.contains( ':' ) )
m_pView->selectionInfo()->initialize( Region(m_pView,tmp) );
// Location entered in location widget
else
{
Region region(m_pView,tmp);
bool validName = true;
for (unsigned int i = 0; i < ltext.length(); ++i)
{
if (!ltext[i].isLetter())
{
validName = false;
break;
}
}
if ( !region.isValid() && validName)
{
TQRect rect( m_pView->selectionInfo()->selection() );
Sheet * t = m_pView->activeSheet();
// set area name on current selection/cell
m_pView->doc()->addAreaName(rect, ltext.lower(), t->sheetName());
}
if (!validName)
{
m_pView->selectionInfo()->initialize(region);
}
}
// Set the focus back on the canvas.
m_pView->canvasWidget()->setFocus();
return false;
}
void LocationEditWidget::keyPressEvent( TQKeyEvent * _ev )
{
// Do not handle special keys and accelerators. This is
// done by TQLineEdit.
if ( _ev->state() & ( TQt::AltButton | TQt::ControlButton ) )
{
TQLineEdit::keyPressEvent( _ev );
// Never allow that keys are passed on to the parent.
_ev->accept();
return;
}
// Handle some special keys here. Eve
switch( _ev->key() )
{
case Key_Return:
case Key_Enter:
{
if ( activateItem() )
return;
_ev->accept();
}
break;
// Escape pressed, restore original value
case Key_Escape:
// #### Torben says: This is duplicated code. Bad.
if ( m_pView->selectionInfo()->isSingular() ) {
setText( Cell::columnName( m_pView->canvasWidget()->markerColumn() )
+ TQString::number( m_pView->canvasWidget()->markerRow() ) );
} else {
setText( Cell::columnName( m_pView->selectionInfo()->lastRange().left() )
+ TQString::number( m_pView->selectionInfo()->lastRange().top() )
+ ":"
+ Cell::columnName( m_pView->selectionInfo()->lastRange().right() )
+ TQString::number( m_pView->selectionInfo()->lastRange().bottom() ) );
}
m_pView->canvasWidget()->setFocus();
_ev->accept();
break;
default:
TQLineEdit::keyPressEvent( _ev );
// Never allow that keys are passed on to the parent.
_ev->accept();
}
}
/****************************************************************
*
* EditWidget
* The line-editor that appears above the sheet and allows to
* edit the cells content.
*
****************************************************************/
EditWidget::EditWidget( TQWidget *_parent, Canvas *_canvas,
TQButton *cancelButton, TQButton *okButton )
: TQLineEdit( _parent, "EditWidget" )
{
m_pCanvas = _canvas;
Q_ASSERT(m_pCanvas != NULL);
// Those buttons are created by the caller, so that they are inserted
// properly in the layout - but they are then managed here.
m_pCancelButton = cancelButton;
m_pOkButton = okButton;
isArray = false;
installEventFilter(m_pCanvas);
if ( !m_pCanvas->doc()->isReadWrite() || !m_pCanvas->activeSheet() )
setEnabled( false );
TQObject::connect( m_pCancelButton, TQT_SIGNAL( clicked() ),
this, TQT_SLOT( slotAbortEdit() ) );
TQObject::connect( m_pOkButton, TQT_SIGNAL( clicked() ),
this, TQT_SLOT( slotDoneEdit() ) );
setEditMode( false ); // disable buttons
}
void EditWidget::showEditWidget(bool _show)
{
if (_show)
{
m_pCancelButton->show();
m_pOkButton->show();
show();
}
else
{
m_pCancelButton->hide();
m_pOkButton->hide();
hide();
}
}
void EditWidget::slotAbortEdit()
{
m_pCanvas->deleteEditor( false /*discard changes*/ );
// will take care of the buttons
}
void EditWidget::slotDoneEdit()
{
m_pCanvas->deleteEditor( true /*keep changes*/, isArray);
isArray = false;
// will take care of the buttons
}
void EditWidget::keyPressEvent ( TQKeyEvent* _ev )
{
// Dont handle special keys and accelerators, except Enter ones
if (( ( _ev->state() & ( TQt::AltButton | TQt::ControlButton ) )
|| ( _ev->state() & TQt::ShiftButton )
|| ( _ev->key() == Key_Shift )
|| ( _ev->key() == Key_Control ) )
&& (_ev->key() != Key_Return) && (_ev->key() != Key_Enter))
{
TQLineEdit::keyPressEvent( _ev );
_ev->accept();
return;
}
if ( !m_pCanvas->doc()->isReadWrite() )
return;
if ( !m_pCanvas->editor() )
{
// Start editing the current cell
m_pCanvas->createEditor( Canvas::CellEditor,false );
}
CellEditor * cellEditor = (CellEditor*) m_pCanvas->editor();
switch ( _ev->key() )
{
case Key_Down:
case Key_Up:
case Key_Return:
case Key_Enter:
cellEditor->setText( text());
// Don't allow to start a chooser when pressing the arrow keys
// in this widget, since only up and down would work anyway.
// This is why we call slotDoneEdit now, instead of sending
// to the canvas.
//TQApplication::sendEvent( m_pCanvas, _ev );
isArray = (_ev->state() & TQt::AltButton) &&
(_ev->state() & TQt::ControlButton);
slotDoneEdit();
m_pCanvas->view()->updateEditWidget();
_ev->accept();
break;
case Key_F2:
cellEditor->setFocus();
cellEditor->setText( text());
cellEditor->setCursorPosition(cursorPosition());
break;
default:
TQLineEdit::keyPressEvent( _ev );
setFocus();
cellEditor->setCheckChoice( false );
cellEditor->setText( text() );
cellEditor->setCheckChoice( true );
cellEditor->setCursorPosition( cursorPosition() );
}
}
void EditWidget::setEditMode( bool mode )
{
m_pCancelButton->setEnabled(mode);
m_pOkButton->setEnabled(mode);
}
void EditWidget::focusOutEvent( TQFocusEvent* ev )
{
//kdDebug(36001) << "EditWidget lost focus" << endl;
// See comment about setLastEditorWithFocus
m_pCanvas->setLastEditorWithFocus( Canvas::EditWidget );
TQLineEdit::focusOutEvent( ev );
}
void EditWidget::setText( const TQString& t )
{
if ( t == text() ) // Why this? (David)
return;
TQLineEdit::setText( t );
}
#include "kspread_editors.moc"
View Git Blame Copy Permalink