src/PyConsole/PyConsole_Editor.cxx

   1 // Copyright (C) 2007-2014  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 // This library is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU Lesser General Public
   8 // License as published by the Free Software Foundation; either
   9 // version 2.1 of the License, or (at your option) any later version.
  10 //
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 // Lesser General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU Lesser General Public
  17 // License along with this library; if not, write to the Free Software
  18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22
  23 //  SALOME SALOMEGUI : implementation of desktop and GUI kernel
  24 // File   : PyConsole_Editor.cxx
  25 // Author : Vadim SANDLER, Open CASCADE S.A.S. (vadim.sandler@opencascade.com)
  26 //
  27 /*!
  28   \class PyConsole_Editor
  29   \brief Python command line interpreter front-end GUI widget.
  30
  31   This class provides simple GUI interface to the Python interpreter, including basic
  32   navigation operations, executing commands (both interactively and programmatically),
  33   copy-paste operations, history of the commands and so on.
  34
  35   Here below is the shortcut keyboard boundings used for navigation and other operations:
  36   - <Enter>              : execute current command
  37   - <Ctrl><Break>        : clear current command
  38   - <Escape>             : clear current command
  39   - <Up>                 : previous command in the history
  40   - <Shift><Up>          : move cursor one row up with selection
  41   - <Ctrl><Up>           : move cursor one row up without selection
  42   - <Ctrl><Shift><Up>    : move cursor one row up with selection
  43   - <Down>               : next command in the history
  44   - <Shift><Down>        : move cursor one row down with selection
  45   - <Ctrl><Down>         : move cursor one row down without selection
  46   - <Ctrl><Shift><Down>  : move cursor one row down with selection
  47   - <Left>               : move one symbol left without selection
  48   - <Shift><Left>        : move one symbol left with selection
  49   - <Ctrl><Left>         : move one word left without selection
  50   - <Ctrl><Shift><Left>  : move one word left with selection
  51   - <Right>              : move one symbol right without selection
  52   - <Shift><Right>       : move one symbol right with selection
  53   - <Ctrl><Right>        : move one word right without selection
  54   - <Ctrl><Shift><Right> : move one word right with selection
  55   - <PgUp>               : first command in the history
  56   - <Shift><PgUp>        : move one page up with selection
  57   - <Ctrl><PgUp>         : move one page up without selection
  58   - <Ctrl><Shift><PgUp>  : scroll one page up
  59   - <PgDn>               : last command in the history
  60   - <Shift><PgDn>        : move one page down with selection
  61   - <Ctrl><PgDn>         : move one page down without selection
  62   - <Ctrl><Shift><PgDn>  : scroll one page down
  63   - <Home>               : move to the beginning of the line without selection
  64   - <Shift><Home>        : move to the beginning of the line with selection
  65   - <Ctrl><Home>         : move to the very first symbol without selection
  66   - <Ctrl><Shift><Home>  : move to the very first symbol with selection
  67   - <End>                : move to the end of the line without selection
  68   - <Shift><End>         : move to the end of the line with selection
  69   - <Ctrl><End>          : move to the very last symbol without selection
  70   - <Ctrl><Shift><End>   : move to the very last symbol with selection
  71   - <Backspace>          : delete symbol before the cursor
  72                            / remove selected text and put it to the clipboard (cut)
  73   - <Shift><Backspace>   : delete previous word
  74                            / remove selected text and put it to the clipboard (cut)
  75   - <Ctrl><Backspace>    : delete text from the cursor to the beginning of the line
  76                            / remove selected text and put it to the clipboard (cut)
  77   - <Delete>             : delete symbol after the cursor
  78                            / remove selected text and put it to the clipboard (cut)
  79   - <Shift><Delete>      : delete next word
  80                            / remove selected text and put it to the clipboard (cut)
  81   - <Ctrl><Delete>       : delete text from the cursor to the end of the line
  82                            / remove selected text and put it to the clipboard (cut)
  83   - <Ctrl><Insert>       : copy
  84   - <Shift><Insert>      : paste
  85   - <Ctrl><V>            : paste
  86   - <Ctrl><C>            : copy
  87   - <Ctrl><X>            : cut
  88   - <Ctrl><V>            : paste
  89 */
  90
  91 #include "PyConsole_Interp.h"   // !!! WARNING !!! THIS INCLUDE MUST BE THE VERY FIRST !!!
  92 #include "PyConsole_Editor.h"
  93 #include "PyConsole_Event.h"
  94 #include "PyInterp_Event.h"
  95 #include "PyInterp_Dispatcher.h"
  96 #include "PyConsole_Request.h"
  97
  98 #include <SUIT_Tools.h>
  99 #include <SUIT_FileDlg.h>
 100 #include <SUIT_MessageBox.h>
 101 #include <SUIT_FileValidator.h>
 102
 103 #include <QApplication>
 104 #include <QClipboard>
 105 #include <QDropEvent>
 106 #include <QEvent>
 107 #include <QKeyEvent>
 108 #include <QMouseEvent>
 109 #include <QScrollBar>
 110 #include <QTextBlock>
 111 #include <QTextCursor>
 112 #include <QTextDocument>
 113 #include <QTextStream>
 114 #include <QChar>
 115
 116 static QString READY_PROMPT = ">>> ";
 117 static QString DOTS_PROMPT  = "... ";
 118
 119 class DumpCommandsFileValidator : public SUIT_FileValidator
 120 {
 121  public:
 122   DumpCommandsFileValidator( QWidget* parent = 0 ) : SUIT_FileValidator ( parent ) {};
 123   virtual ~DumpCommandsFileValidator() {};
 124   virtual bool canSave( const QString& file, bool permissions );
 125 };
 126
 127 bool DumpCommandsFileValidator::canSave(const QString& file, bool permissions)
 128 {
 129   QFileInfo fi( file );
 130   if ( !QRegExp( "[A-Za-z_][A-Za-z0-9_]*" ).exactMatch( fi.completeBaseName() ) ) {
 131     SUIT_MessageBox::critical( parent(),
 132                                QObject::tr("WRN_WARNING"),
 133                                QObject::tr("WRN_FILE_NAME_BAD") );
 134     return false;
 135   }
 136   return SUIT_FileValidator::canSave( file, permissions);
 137 }
 138
 139 void staticCallbackStdout( void* data, char* c )
 140 {
 141   if(!((PyConsole_Editor*)data)->isSuppressOutput()) {
 142     PyConsole_Editor* e = (PyConsole_Editor*)data;
 143     e->putLog( QString::fromUtf8(c) );
 144     QApplication::postEvent( e, new PrintEvent( QString::fromUtf8(c), false ) );
 145   }
 146 }
 147
 148 void staticCallbackStderr( void* data, char* c )
 149 {
 150   if(!((PyConsole_Editor*)data)->isSuppressOutput()) {
 151     PyConsole_Editor* e = (PyConsole_Editor*)data;
 152     e->putLog( QString::fromUtf8(c) );
 153     QApplication::postEvent( e, new PrintEvent( QString::fromUtf8(c), true ) );
 154   }
 155 }
 156
 157
 158 /*!
 159   \brief Constructor.
 160
 161   Creates python editor window.
 162   \param theInterp python interper
 163   \param theParent parent widget
 164 */
 165 PyConsole_Editor::PyConsole_Editor( PyConsole_Interp* theInterp,
 166                                     QWidget*          theParent )
 167 : QTextEdit( theParent ),
 168   myInterp( 0 ),
 169   myCmdInHistory( -1 ),
 170   myEventLoop( 0 ),
 171   myShowBanner( true ),
 172   myIsSync( true ),
 173   myIsSuppressOutput( false )
 174 {
 175   QString fntSet( "" );
 176   QFont aFont = SUIT_Tools::stringToFont( fntSet );
 177   setFont( aFont );
 178   setUndoRedoEnabled( false );
 179
 180   myPrompt = READY_PROMPT;
 181   setLineWrapMode( QTextEdit::WidgetWidth );
 182   setWordWrapMode( QTextOption::WrapAnywhere );
 183   setAcceptRichText( false );
 184
 185   theInterp->setvoutcb( staticCallbackStdout, this );
 186   theInterp->setverrcb( staticCallbackStderr, this );
 187
 188   // san - This is necessary for troubleless initialization
 189   onPyInterpChanged( theInterp );
 190 }
 191
 192 /*!
 193   \brief Destructor.
 194 */
 195 PyConsole_Editor::~PyConsole_Editor()
 196 {
 197   myInterp = 0;
 198 }
 199
 200 /*!
 201   \brief Get Python interpreter
 202 */
 203 PyConsole_Interp* PyConsole_Editor::getInterp() const
 204 {
 205   return myInterp;
 206 }
 207
 208 /*!
 209   \brief Get synchronous mode flag value.
 210
 211   \sa setIsSync()
 212   \return True if python console works in synchronous mode
 213 */
 214 bool PyConsole_Editor::isSync() const
 215 {
 216   return myIsSync;
 217 }
 218
 219 /*!
 220   \brief Set synchronous mode flag value.
 221
 222   In synhronous mode the Python commands are executed in the GUI thread
 223   and the GUI is blocked until the command is finished. In the asynchronous
 224   mode each Python command is executed in the separate thread that does not
 225   block the main GUI loop.
 226
 227   \param on synhronous mode flag
 228 */
 229 void PyConsole_Editor::setIsSync( const bool on )
 230 {
 231   myIsSync = on;
 232 }
 233
 234 /*!
 235   \brief Get suppress output flag value.
 236
 237   \sa setIsSuppressOutput()
 238   \return \c true if python console output is suppressed.
 239 */
 240 bool PyConsole_Editor::isSuppressOutput() const
 241 {
 242   return myIsSuppressOutput;
 243 }
 244
 245 /*!
 246   \brief Set suppress output flag value.
 247
 248   In case if suppress output flag is true, the python
 249   console output suppressed.
 250
 251   \param on suppress output flag
 252 */
 253 void PyConsole_Editor::setIsSuppressOutput( const bool on )
 254 {
 255   myIsSuppressOutput = on;
 256 }
 257
 258 /*!
 259   \brief Get 'show banner' flag value.
 260
 261   \sa setIsShowBanner()
 262   \return \c true if python console shows banner
 263 */
 264 bool PyConsole_Editor::isShowBanner() const
 265 {
 266   return myShowBanner;
 267 }
 268
 269 /*!
 270   \brief Set 'show banner' flag value.
 271
 272   The banner is shown in the top of the python console window.
 273
 274   \sa isShowBanner()
 275   \param on 'show banner' flag
 276 */
 277 void PyConsole_Editor::setIsShowBanner( const bool on )
 278 {
 279   if ( myShowBanner != on ) {
 280     myShowBanner = on;
 281     clear();
 282   }
 283 }
 284
 285 /*!
 286   \brief Check if trace logging is switched on.
 287
 288   \sa startLog(), stopLog()
 289   \return \c true if trace logging is switched on
 290 */
 291 bool PyConsole_Editor::isLogging() const
 292 {
 293   return !myLogFile.isEmpty();
 294 }
 295
 296 /*!
 297   \brief Get size hint for the Python console window
 298   \return size hint value
 299 */
 300 QSize PyConsole_Editor::sizeHint() const
 301 {
 302   QFontMetrics fm( font() );
 303   int nbLines = ( isShowBanner() ? myBanner.split("\n").count() : 0 ) + 1;
 304   QSize s(100, fm.lineSpacing()*nbLines);
 305   return s;
 306 }
 307
 308 /*!
 309   \brief Put the string \a str to the python editor.
 310   \param str string to be put in the command line of the editor
 311   \param newBlock if True, then the string is printed on a new line
 312   \param isError if true, the text is printed in dark red
 313 */
 314 void PyConsole_Editor::addText( const QString& str,
 315                                 const bool     newBlock,
 316                                 const bool    isError)
 317 {
 318   QTextCursor theCursor(textCursor());
 319   QTextCharFormat cf;
 320
 321   moveCursor( QTextCursor::End );
 322   if ( newBlock )
 323     theCursor.insertBlock();
 324   if (isError)
 325       cf.setForeground(QBrush(Qt::red));
 326   else
 327       cf.setForeground(QBrush(Qt::black));
 328   theCursor.insertText( str, cf);
 329   moveCursor( QTextCursor::End );
 330   ensureCursorVisible();
 331 }
 332
 333 /*!
 334   \brief Convenient method for executing a Python command,
 335   as if the user typed it manually.
 336   \param command python command to be executed
 337
 338   !!! WARNING: doesn't work properly with multi-line commands. !!!
 339 */
 340 void PyConsole_Editor::exec( const QString& command )
 341 {
 342   if ( isReadOnly() ) {
 343     // some interactive command is being executed in this editor...
 344     // shedule the command to the queue
 345     myQueue.push_back( command );
 346     return;
 347   }
 348   // remove last line
 349   moveCursor( QTextCursor::End );
 350   moveCursor( QTextCursor::StartOfBlock, QTextCursor::KeepAnchor );
 351   textCursor().removeSelectedText();
 352   // set "ready" prompt
 353   myPrompt = READY_PROMPT;
 354   // clear command buffer
 355   myCommandBuffer.truncate( 0 );
 356   // unset history browsing mode
 357   myCmdInHistory = -1;
 358   // print command line by line
 359   QString cmd = command;
 360   if ( !cmd.endsWith( "\n" ) ) cmd += "\n";
 361   QStringList lines = command.split( "\n" );
 362   for ( int i = 0; i < lines.size(); i++ ) {
 363     if ( !lines[i].trimmed().isEmpty() )
 364       myHistory.push_back( lines[i] );
 365     addText( ( i == 0 ? READY_PROMPT : DOTS_PROMPT ) + lines[i], i != 0 );
 366     putLog( QString( "%1%2\n" ).arg( i == 0 ? READY_PROMPT : DOTS_PROMPT ).arg( lines[i] ) );
 367   }
 368   // IPAL20182
 369   addText( "", true );
 370   // set read-only mode
 371   setReadOnly( true );
 372   // set busy cursor
 373   setCursor( Qt::BusyCursor );
 374
 375   // post a request to execute Python command;
 376   // editor will be informed via a custom event that execution has been completed
 377   PyInterp_Dispatcher::Get()->Exec( createRequest( cmd ) );
 378 }
 379
 380 /*!
 381   \brief Create request to the python dispatcher for the command execution.
 382
 383   \param command python command to be executed
 384  */
 385 PyInterp_Request* PyConsole_Editor::createRequest( const QString& command )
 386 {
 387   return new ExecCommand( myInterp, command, this, isSync() );
 388 }
 389
 390 /*!
 391   \brief Execute command in the python interpreter
 392   and wait until it is finished.
 393
 394   \param command python command to be executed
 395  */
 396 void PyConsole_Editor::execAndWait( const QString& command )
 397 {
 398   // already running ?
 399   if( myEventLoop )
 400     return;
 401
 402   // create new event loop
 403   bool sync = isSync();
 404   if ( !sync ) {
 405     myEventLoop = new QEventLoop( this );
 406   }
 407
 408   // execute command
 409   exec( command );
 410
 411   if ( !sync ) {
 412     // run event loop
 413     myEventLoop->exec();
 414     // delete event loop after command is processed
 415     delete myEventLoop;
 416     myEventLoop = 0;
 417   }
 418 }
 419
 420 /*!
 421   \brief Process "Enter" key press event.
 422
 423   Execute the command entered by the user.
 424 */
 425 void PyConsole_Editor::handleReturn()
 426 {
 427   // Position cursor at the end
 428   QTextCursor curs(textCursor());
 429   curs.movePosition(QTextCursor::End);
 430   setTextCursor(curs);
 431
 432   // get last line
 433   QTextBlock par = document()->end().previous();
 434   if ( !par.isValid() ) return;
 435
 436   // get command
 437   QString cmd = par.text().remove( 0, promptSize() );
 438   // extend the command buffer with the current command
 439   myCommandBuffer.append( cmd );
 440   // add command to the history
 441   if ( !cmd.trimmed().isEmpty() )
 442     myHistory.push_back( cmd );
 443   putLog( QString( "%1%2\n" ).arg( myPrompt ).arg( cmd ) );
 444
 445   // IPAL19397
 446   addText( "", true );
 447
 448   // set read-only mode
 449   setReadOnly( true );
 450   // set busy cursor
 451   setCursor( Qt::BusyCursor );
 452
 453   // post a request to execute Python command;
 454   // editor will be informed via a custom event that execution has been completed
 455   PyInterp_Dispatcher::Get()->Exec( createRequest( myCommandBuffer ) );
 456 }
 457
 458 /*!
 459   \brief Process drop event.
 460
 461   Paste dragged text.
 462   \param event drop event
 463 */
 464 void PyConsole_Editor::dropEvent( QDropEvent* event )
 465 {
 466   // get the initial drop position
 467   QPoint pos = event->pos();
 468   QTextCursor cur = cursorForPosition( event->pos() );
 469   // if the position is not in the last line move it to the end of the command line
 470   if ( cur.position() < document()->end().previous().position() + promptSize() ) {
 471     moveCursor( QTextCursor::End );
 472     pos = cursorRect().center();
 473   }
 474   // create new drop event and use it instead of the original
 475   QDropEvent de( pos,
 476                  event->possibleActions(),
 477                  event->mimeData(),
 478                  event->mouseButtons(),
 479                  event->keyboardModifiers(),
 480                  event->type() );
 481   QTextEdit::dropEvent( &de );
 482   // accept the original event
 483   event->acceptProposedAction();
 484 }
 485
 486 /*!
 487   \brief Process mouse button release event.
 488
 489   Left mouse button: copy selection to the clipboard.
 490   Middle mouse button: paste clipboard's contents.
 491   \param event mouse event
 492 */
 493 void PyConsole_Editor::mouseReleaseEvent( QMouseEvent* event )
 494 {
 495   if ( event->button() == Qt::LeftButton ) {
 496     QTextEdit::mouseReleaseEvent( event );
 497     //copy();
 498   }
 499   else if ( event->button() == Qt::MidButton ) {
 500     QTextCursor cur = cursorForPosition( event->pos() );
 501     // if the position is not in the last line move it to the end of the command line
 502     if ( cur.position() < document()->end().previous().position() + promptSize() ) {
 503       moveCursor( QTextCursor::End );
 504     }
 505     else {
 506       setTextCursor( cur );
 507     }
 508     const QMimeData* md = QApplication::clipboard()->mimeData( QApplication::clipboard()->supportsSelection() ?
 509                                                                QClipboard::Selection : QClipboard::Clipboard );
 510     if ( md )
 511       insertFromMimeData( md );
 512   }
 513   else {
 514     QTextEdit::mouseReleaseEvent( event );
 515   }
 516 }
 517
 518 /*!
 519   \brief Check if the string is command.
 520
 521   Return True if the string \a str is likely to be the command
 522   (i.e. it is started from the '>>>' or '...').
 523   \param str string to be checked
 524 */
 525 bool PyConsole_Editor::isCommand( const QString& str ) const
 526 {
 527   return str.startsWith( READY_PROMPT ) || str.startsWith( DOTS_PROMPT );
 528 }
 529
 530 /*!
 531   \brief Handle keyboard event.
 532
 533   Implement navigation, history browsing, copy/paste and other common
 534   operations.
 535   \param event keyboard event
 536 */
 537 void PyConsole_Editor::keyPressEvent( QKeyEvent* event )
 538 {
 539   // get cursor position
 540   QTextCursor cur = textCursor();
 541   int curLine = cur.blockNumber();
 542   int curCol  = cur.columnNumber();
 543
 544   // get last edited line
 545   int endLine = document()->blockCount()-1;
 546
 547   // get pressed key code
 548   int aKey = event->key();
 549
 550   // check if <Ctrl> is pressed
 551   bool ctrlPressed = event->modifiers() & Qt::ControlModifier;
 552   // check if <Shift> is pressed
 553   bool shftPressed = event->modifiers() & Qt::ShiftModifier;
 554
 555   if ( aKey == Qt::Key_Escape || ( ctrlPressed && aKey == -1 ) ) {
 556     // process <Ctrl>+<Break> key-binding and <Escape> key: clear current command
 557     myCommandBuffer.truncate( 0 );
 558     myPrompt = READY_PROMPT;
 559     addText( myPrompt, true );
 560     horizontalScrollBar()->setValue( horizontalScrollBar()->minimum() );
 561     return;
 562   }
 563   else if ( ctrlPressed && aKey == Qt::Key_C ) {
 564     // process <Ctrl>+<C> key-binding : copy
 565     copy();
 566     return;
 567   }
 568   else if ( ctrlPressed && aKey == Qt::Key_X ) {
 569     // process <Ctrl>+<X> key-binding : cut
 570     cut();
 571     return;
 572   }
 573   else if ( ctrlPressed && aKey == Qt::Key_V ) {
 574     // process <Ctrl>+<V> key-binding : paste
 575     paste();
 576     return;
 577   }
 578
 579   // check for printed key
 580   // #### aKey = ( aKey < Qt::Key_Space || aKey > Qt::Key_ydiaeresis ) ? aKey : 0;
 581   // Better:
 582   aKey = !(QChar(aKey).isPrint()) ? aKey : 0;
 583
 584   switch ( aKey ) {
 585   case 0 :
 586     // any printed key: just print it
 587     {
 588       if ( curLine < endLine || curCol < promptSize() ) {
 589         moveCursor( QTextCursor::End );
 590       }
 591       QTextEdit::keyPressEvent( event );
 592       break;
 593     }
 594   case Qt::Key_Return:
 595   case Qt::Key_Enter:
 596     // <Enter> key: process the current command
 597     {
 598       handleReturn();
 599       break;
 600     }
 601   case Qt::Key_Up:
 602     // <Up> arrow key: process as follows:
 603     // - without <Ctrl>, <Shift> modifiers: previous command in history
 604     // - with <Ctrl> modifier key pressed:  move cursor one row up without selection
 605     // - with <Shift> modifier key pressed: move cursor one row up with selection
 606     // - with <Ctrl>+<Shift> modifier keys pressed: scroll one row up
 607     {
 608       if ( ctrlPressed && shftPressed ) {
 609         int value   = verticalScrollBar()->value();
 610         int spacing = fontMetrics().lineSpacing();
 611         verticalScrollBar()->setValue( value > spacing ? value-spacing : 0 );
 612       }
 613       else if ( shftPressed || ctrlPressed ) {
 614         if ( curLine > 0 )
 615           moveCursor( QTextCursor::Up,
 616                       shftPressed ? QTextCursor::KeepAnchor : QTextCursor::MoveAnchor );
 617       }
 618       else {
 619         if ( myCmdInHistory < 0 && myHistory.count() > 0 ) {
 620           // set history browsing mode
 621           myCmdInHistory = myHistory.count();
 622           // remember current command
 623           QTextBlock par = document()->end().previous();
 624           myCurrentCommand = par.text().remove( 0, promptSize() );
 625         }
 626         if ( myCmdInHistory > 0 ) {
 627           myCmdInHistory--;
 628           // get previous command in the history
 629           QString previousCommand = myHistory.at( myCmdInHistory );
 630           // print previous command
 631           moveCursor( QTextCursor::End );
 632           moveCursor( QTextCursor::StartOfBlock, QTextCursor::KeepAnchor );
 633           textCursor().removeSelectedText();
 634           addText( myPrompt + previousCommand );
 635           // move cursor to the end
 636           moveCursor( QTextCursor::End );
 637         }
 638       }
 639       break;
 640     }
 641   case Qt::Key_Down:
 642     // <Down> arrow key: process as follows:
 643     // - without <Ctrl>, <Shift> modifiers: next command in history
 644     // - with <Ctrl> modifier key pressed:  move cursor one row down without selection
 645     // - with <Shift> modifier key pressed: move cursor one row down with selection
 646     // - with <Ctrl>+<Shift> modifier keys pressed: scroll one row down
 647     {
 648       if ( ctrlPressed && shftPressed ) {
 649         int value   = verticalScrollBar()->value();
 650         int maxval  = verticalScrollBar()->maximum();
 651         int spacing = fontMetrics().lineSpacing();
 652         verticalScrollBar()->setValue( value+spacing < maxval ? value+spacing : maxval );
 653       }
 654       else if ( shftPressed || ctrlPressed) {
 655         if ( curLine < endLine )
 656           moveCursor( QTextCursor::Down,
 657                       shftPressed ? QTextCursor::KeepAnchor : QTextCursor::MoveAnchor );
 658       }
 659       else {
 660         if ( myCmdInHistory >= 0 ) {
 661           // get next command in the history
 662           myCmdInHistory++;
 663           QString nextCommand;
 664           if ( myCmdInHistory < myHistory.count() ) {
 665             // next command in history
 666             nextCommand = myHistory.at( myCmdInHistory );
 667           }
 668           else {
 669             // end of history is reached
 670             // last printed command
 671             nextCommand = myCurrentCommand;
 672             // unset history browsing mode
 673             myCmdInHistory = -1;
 674           }
 675           // print next or current command
 676           moveCursor( QTextCursor::End );
 677           moveCursor( QTextCursor::StartOfBlock, QTextCursor::KeepAnchor );
 678           textCursor().removeSelectedText();
 679           addText( myPrompt + nextCommand );
 680           // move cursor to the end
 681           moveCursor( QTextCursor::End );
 682         }
 683       }
 684       break;
 685     }
 686   case Qt::Key_Left:
 687     // <Left> arrow key: process as follows:
 688     // - without <Ctrl>, <Shift> modifiers: move one symbol left (taking into account prompt)
 689     // - with <Ctrl> modifier key pressed:  move one word left (taking into account prompt)
 690     // - with <Shift> modifier key pressed: move one symbol left with selection
 691     // - with <Ctrl>+<Shift> modifier keys pressed: move one word left with selection
 692     {
 693       QString txt = textCursor().block().text();
 694       if ( !shftPressed && isCommand( txt ) && curCol <= promptSize() ) {
 695         moveCursor( QTextCursor::Up );
 696         moveCursor( QTextCursor::EndOfBlock );
 697       }
 698       else {
 699         QTextEdit::keyPressEvent( event );
 700       }
 701       break;
 702     }
 703   case Qt::Key_Right:
 704     // <Right> arrow key: process as follows:
 705     // - without <Ctrl>, <Shift> modifiers: move one symbol right (taking into account prompt)
 706     // - with <Ctrl> modifier key pressed:  move one word right (taking into account prompt)
 707     // - with <Shift> modifier key pressed: move one symbol right with selection
 708     // - with <Ctrl>+<Shift> modifier keys pressed: move one word right with selection
 709     {
 710       QString txt = textCursor().block().text();
 711       if ( !shftPressed ) {
 712         if ( curCol < txt.length() ) {
 713           if ( isCommand( txt ) && curCol < promptSize() ) {
 714             cur.setPosition( cur.block().position() + promptSize() );
 715             setTextCursor( cur );
 716             break;
 717           }
 718         }
 719         else {
 720           if ( curLine < endLine && isCommand( textCursor().block().next().text() ) ) {
 721             cur.setPosition( cur.position() + promptSize()+1 );
 722             setTextCursor( cur );
 723             horizontalScrollBar()->setValue( horizontalScrollBar()->minimum() );
 724             break;
 725           }
 726         }
 727       }
 728       QTextEdit::keyPressEvent( event );
 729       break;
 730     }
 731   case Qt::Key_PageUp:
 732     // <PageUp> key: process as follows:
 733     // - without <Ctrl>, <Shift> modifiers: first command in history
 734     // - with <Ctrl> modifier key pressed:  move cursor one page up without selection
 735     // - with <Shift> modifier key pressed: move cursor one page up with selection
 736     // - with <Ctrl>+<Shift> modifier keys pressed: scroll one page up
 737     {
 738       if ( ctrlPressed && shftPressed ) {
 739         verticalScrollBar()->triggerAction(QAbstractSlider::SliderPageStepSub);
 740       }
 741       else if ( shftPressed || ctrlPressed ) {
 742         bool moved = false;
 743         qreal lastY = cursorRect( cur ).top();
 744         qreal distance = 0;
 745         // move using movePosition to keep the cursor's x
 746         do {
 747           qreal y = cursorRect( cur ).top();
 748           distance += qAbs( y - lastY );
 749           lastY = y;
 750           moved = cur.movePosition( QTextCursor::Up,
 751                                     shftPressed ? QTextCursor::KeepAnchor :
 752                                                   QTextCursor::MoveAnchor );
 753         } while ( moved && distance < viewport()->height() );
 754         if ( moved ) {
 755           cur.movePosition( QTextCursor::Down,
 756                             shftPressed ? QTextCursor::KeepAnchor :
 757                                           QTextCursor::MoveAnchor );
 758           verticalScrollBar()->triggerAction( QAbstractSlider::SliderPageStepSub );
 759         }
 760         setTextCursor( cur );
 761       }
 762       else {
 763         if ( myCmdInHistory < 0 && myHistory.count() > 0 ) {
 764           // set history browsing mode
 765           myCmdInHistory = myHistory.count();
 766           // remember current command
 767           QTextBlock par = document()->end().previous();
 768           myCurrentCommand = par.text().remove( 0, promptSize() );
 769         }
 770         if ( myCmdInHistory > 0 ) {
 771           myCmdInHistory = 0;
 772           // get very first command in the history
 773           QString firstCommand = myHistory.at( myCmdInHistory );
 774           // print first command
 775           moveCursor( QTextCursor::End );
 776           moveCursor( QTextCursor::StartOfBlock, QTextCursor::KeepAnchor );
 777           textCursor().removeSelectedText();
 778           addText( myPrompt + firstCommand );
 779           // move cursor to the end
 780           moveCursor( QTextCursor::End );
 781         }
 782       }
 783       break;
 784     }
 785   case Qt::Key_PageDown:
 786     // <PageDown> key: process as follows:
 787     // - without <Ctrl>, <Shift> modifiers: last command in history
 788     // - with <Ctrl> modifier key pressed:  move cursor one page down without selection
 789     // - with <Shift> modifier key pressed: move cursor one page down with selection
 790     // - with <Ctrl>+<Shift> modifier keys pressed: scroll one page down
 791     {
 792       if ( ctrlPressed && shftPressed ) {
 793         verticalScrollBar()->triggerAction(QAbstractSlider::SliderPageStepAdd);
 794       }
 795       else if ( shftPressed || ctrlPressed ) {
 796         bool moved = false;
 797         qreal lastY = cursorRect( cur ).top();
 798         qreal distance = 0;
 799         // move using movePosition to keep the cursor's x
 800         do {
 801           qreal y = cursorRect( cur ).top();
 802           distance += qAbs( y - lastY );
 803           lastY = y;
 804           moved = cur.movePosition( QTextCursor::Down,
 805                                     shftPressed ? QTextCursor::KeepAnchor :
 806                                                   QTextCursor::MoveAnchor );
 807         } while ( moved && distance < viewport()->height() );
 808         if ( moved ) {
 809           cur.movePosition( QTextCursor::Up,
 810                             shftPressed ? QTextCursor::KeepAnchor :
 811                                           QTextCursor::MoveAnchor );
 812           verticalScrollBar()->triggerAction( QAbstractSlider::SliderPageStepSub );
 813         }
 814         setTextCursor( cur );
 815       }
 816       else {
 817         if ( myCmdInHistory >= 0 ) {
 818           // unset history browsing mode
 819           myCmdInHistory = -1;
 820           // print current command
 821           moveCursor( QTextCursor::End );
 822           moveCursor( QTextCursor::StartOfBlock, QTextCursor::KeepAnchor );
 823           textCursor().removeSelectedText();
 824           addText( myPrompt + myCurrentCommand );
 825           // move cursor to the end
 826           moveCursor( QTextCursor::End );
 827         }
 828       }
 829       break;
 830     }
 831   case Qt::Key_Home:
 832     // <Home> key: process as follows:
 833     // - without <Ctrl>, <Shift> modifiers: move cursor to the beginning of the current line without selection
 834     // - with <Ctrl> modifier key pressed:  move cursor to the very first symbol without selection
 835     // - with <Shift> modifier key pressed: move cursor to the beginning of the current line with selection
 836     // - with <Ctrl>+<Shift> modifier keys pressed: move cursor to the very first symbol with selection
 837     {
 838       if ( ctrlPressed ) {
 839         moveCursor( QTextCursor::Start,
 840                     shftPressed ? QTextCursor::KeepAnchor : QTextCursor::MoveAnchor );
 841       }
 842       else {
 843         QString txt = textCursor().block().text();
 844         if ( isCommand( txt ) ) {
 845           if ( shftPressed ) {
 846             if ( curCol > promptSize() ) {
 847               cur.movePosition( QTextCursor::StartOfLine, QTextCursor::KeepAnchor );
 848               cur.movePosition( QTextCursor::Right, QTextCursor::KeepAnchor, promptSize() );
 849             }
 850           }
 851           else {
 852             cur.movePosition( QTextCursor::StartOfLine );
 853             cur.movePosition( QTextCursor::Right, QTextCursor::MoveAnchor, promptSize() );
 854           }
 855           setTextCursor( cur );
 856         }
 857         else {
 858           moveCursor( QTextCursor::StartOfBlock,
 859                       shftPressed ? QTextCursor::KeepAnchor : QTextCursor::MoveAnchor );
 860         }
 861         horizontalScrollBar()->setValue( horizontalScrollBar()->minimum() );
 862       }
 863       break;
 864     }
 865   case Qt::Key_End:
 866     // <End> key: process as follows:
 867     // - without <Ctrl>, <Shift> modifiers: move cursor to the end of the current line without selection
 868     // - with <Ctrl> modifier key pressed:  move cursor to the very last symbol without selection
 869     // - with <Shift> modifier key pressed: move cursor to the end of the current line with selection
 870     // - with <Ctrl>+<Shift> modifier keys pressed: move cursor to the very last symbol with selection
 871     {
 872       moveCursor( ctrlPressed ? QTextCursor::End : QTextCursor::EndOfBlock,
 873                   shftPressed ? QTextCursor::KeepAnchor : QTextCursor::MoveAnchor );
 874       break;
 875     }
 876   case Qt::Key_Backspace :
 877     // <Backspace> key: process as follows
 878     // - without any modifiers : delete symbol before the cursor / selection (taking into account prompt)
 879     // - with <Shift> modifier key pressed: delete previous word
 880     // - with <Ctrl> modifier key pressed: delete text from the cursor to the line beginning
 881     // works only for last (command) line
 882     {
 883       if ( cur.hasSelection() ) {
 884         cut();
 885       }
 886       else if ( cur.position() > document()->end().previous().position() + promptSize() ) {
 887         if ( shftPressed ) {
 888           moveCursor( QTextCursor::PreviousWord, QTextCursor::KeepAnchor );
 889           textCursor().removeSelectedText();
 890         }
 891         else if ( ctrlPressed ) {
 892           cur.setPosition( document()->end().previous().position() + promptSize(),
 893                            QTextCursor::KeepAnchor );
 894           setTextCursor( cur );
 895           textCursor().removeSelectedText();
 896         }
 897         else {
 898           QTextEdit::keyPressEvent( event );
 899         }
 900       }
 901       else {
 902         cur.setPosition( document()->end().previous().position() + promptSize() );
 903         setTextCursor( cur );
 904         horizontalScrollBar()->setValue( horizontalScrollBar()->minimum() );
 905       }
 906       break;
 907     }
 908   case Qt::Key_Delete :
 909     // <Delete> key: process as follows
 910     // - without any modifiers : delete symbol after the cursor / selection (taking into account prompt)
 911     // - with <Shift> modifier key pressed: delete next word
 912     // - with <Ctrl> modifier key pressed: delete text from the cursor to the end of line
 913     // works only for last (command) line
 914     {
 915       if ( cur.hasSelection() ) {
 916         cut();
 917       }
 918       else if ( cur.position() > document()->end().previous().position() + promptSize()-1 ) {
 919         if ( shftPressed ) {
 920           moveCursor( QTextCursor::NextWord, QTextCursor::KeepAnchor );
 921           textCursor().removeSelectedText();
 922         }
 923         else if ( ctrlPressed ) {
 924           moveCursor( QTextCursor::EndOfBlock, QTextCursor::KeepAnchor );
 925           textCursor().removeSelectedText();
 926         }
 927         else {
 928           QTextEdit::keyPressEvent( event );
 929         }
 930       }
 931       else {
 932         cur.setPosition( document()->end().previous().position() + promptSize() );
 933         setTextCursor( cur );
 934         horizontalScrollBar()->setValue( horizontalScrollBar()->minimum() );
 935       }
 936       break;
 937     }
 938   case Qt::Key_Insert :
 939     // <Insert> key: process as follows
 940     // - with <Ctrl> modifier key pressed:  copy()
 941     // - with <Shift> modifier key pressed: paste() to the command line
 942     {
 943       if ( ctrlPressed ) {
 944         copy();
 945       }
 946       else if ( shftPressed ) {
 947         paste();
 948       }
 949       else
 950         QTextEdit::keyPressEvent( event );
 951       break;
 952     }
 953   }
 954 }
 955
 956 /*!
 957   \brief Handle notification event coming from Python dispatcher.
 958   \param event notification event
 959 */
 960 void PyConsole_Editor::customEvent( QEvent* event )
 961 {
 962   switch( event->type() )
 963   {
 964   case PrintEvent::EVENT_ID:
 965     {
 966       PrintEvent* pe=(PrintEvent*)event;
 967       addText( pe->text(), false, pe->isError());
 968       return;
 969     }
 970   case PyInterp_Event::ES_OK:
 971   case PyInterp_Event::ES_ERROR:
 972   {
 973     // clear command buffer
 974     myCommandBuffer.truncate( 0 );
 975     // add caret return line if necessary
 976     QTextBlock par = document()->end().previous();
 977     QString txt = par.text();
 978     txt.truncate( txt.length() - 1 );
 979     // IPAL19397 : addText moved to handleReturn() method
 980     //if ( !txt.isEmpty() )
 981     //  addText( "", true );
 982     // set "ready" prompt
 983     myPrompt = READY_PROMPT;
 984     addText( myPrompt );
 985     // unset busy cursor
 986     unsetCursor();
 987     // stop event loop (if running)
 988     if ( myEventLoop )
 989       myEventLoop->exit();
 990     break;
 991   }
 992   case PyInterp_Event::ES_INCOMPLETE:
 993   {
 994     // extend command buffer (multi-line command)
 995     myCommandBuffer.append( "\n" );
 996     // add caret return line if necessary
 997     QTextBlock par = document()->end().previous();
 998     QString txt = par.text();
 999     txt.truncate( txt.length() - 1 );
1000     // IPAL19397 : addText moved to handleReturn() method
1001     //if ( !txt.isEmpty() )
1002     //  addText( "", true );
1003     // set "dot" prompt
1004     myPrompt = DOTS_PROMPT;
1005     addText( myPrompt/*, true*/ ); // IPAL19397
1006     // unset busy cursor
1007     unsetCursor();
1008     // stop event loop (if running)
1009     if ( myEventLoop )
1010       myEventLoop->exit();
1011     break;
1012   }
1013   default:
1014     QTextEdit::customEvent( event );
1015   }
1016
1017   // unset read-only state
1018   setReadOnly( false );
1019   // unset history browsing mode
1020   myCmdInHistory = -1;
1021
1022   if ( (int)event->type() == (int)PyInterp_Event::ES_OK && myQueue.count() > 0 )
1023   {
1024     // process the next sheduled command from the queue (if there is any)
1025     QString nextcmd = myQueue[0];
1026     myQueue.pop_front();
1027     exec( nextcmd );
1028   }
1029 }
1030
1031 /*!
1032   \brief Handle Python interpreter change.
1033
1034   Perform initialization actions if the interpreter is changed.
1035   \param interp python interpreter is being set
1036 */
1037 void PyConsole_Editor::onPyInterpChanged( PyConsole_Interp* interp )
1038 {
1039   if ( myInterp != interp
1040        // Force read-only state and wait cursor when myInterp is NULL
1041       || !myInterp ) {
1042     myInterp = interp;
1043     if ( myInterp ) {
1044       // print banner
1045       myBanner = myInterp->getbanner().c_str();
1046       if ( isShowBanner() )
1047         addText( myBanner );
1048       // clear command buffer
1049       myCommandBuffer.truncate(0);
1050       // unset read-only state
1051       setReadOnly( false );
1052       // unset history browsing mode
1053       myCmdInHistory = -1;
1054       // add prompt
1055       addText( myPrompt );
1056       // unset busy cursor
1057       viewport()->unsetCursor();
1058       // stop event loop (if running)
1059       if( myEventLoop)
1060         myEventLoop->exit();
1061     }
1062     else {
1063       // clear contents
1064       clear();
1065       // set read-only state
1066       setReadOnly( true );
1067       // set busy cursor
1068       setCursor( Qt::WaitCursor );
1069     }
1070   }
1071 }
1072
1073 /*!
1074   \brief "Copy" operation.
1075
1076   Reimplemented from Qt.
1077   Warning! In Qt4 this method is not virtual.
1078  */
1079 void PyConsole_Editor::cut()
1080 {
1081   QTextCursor cur = textCursor();
1082   if ( cur.hasSelection() ) {
1083     QApplication::clipboard()->setText( cur.selectedText() );
1084     int startSelection = cur.selectionStart();
1085     if ( startSelection < document()->end().previous().position() + promptSize() )
1086       startSelection = document()->end().previous().position() + promptSize();
1087     int endSelection = cur.selectionEnd();
1088     if ( endSelection < document()->end().previous().position() + promptSize() )
1089       endSelection = document()->end().previous().position() + promptSize();
1090     cur.setPosition( startSelection );
1091     cur.setPosition( endSelection, QTextCursor::KeepAnchor );
1092     horizontalScrollBar()->setValue( horizontalScrollBar()->minimum() );
1093     setTextCursor( cur );
1094     textCursor().removeSelectedText();
1095   }
1096 }
1097
1098 /*!
1099   \brief "Paste" operation.
1100
1101   Reimplemented from Qt.
1102   Warning! In Qt4 this method is not virtual.
1103  */
1104 void PyConsole_Editor::paste()
1105 {
1106   QTextCursor cur = textCursor();
1107   if ( cur.hasSelection() ) {
1108     int startSelection = cur.selectionStart();
1109     if ( startSelection < document()->end().previous().position() + promptSize() )
1110       startSelection = document()->end().previous().position() + promptSize();
1111     int endSelection = cur.selectionEnd();
1112     if ( endSelection < document()->end().previous().position() + promptSize() )
1113       endSelection = document()->end().previous().position() + promptSize();
1114     cur.setPosition( startSelection );
1115     cur.setPosition( endSelection, QTextCursor::KeepAnchor );
1116     horizontalScrollBar()->setValue( horizontalScrollBar()->minimum() );
1117     setTextCursor( cur );
1118     textCursor().removeSelectedText();
1119   }
1120   if ( textCursor().position() < document()->end().previous().position() + promptSize() )
1121     moveCursor( QTextCursor::End );
1122   QTextEdit::paste();
1123 }
1124
1125 /*!
1126   \brief "Clear" operation.
1127
1128   Reimplemented from Qt.
1129   Warning! In Qt4 this method is not virtual.
1130  */
1131 void PyConsole_Editor::clear()
1132 {
1133   QTextEdit::clear();
1134   if ( isShowBanner() )
1135     addText( myBanner );
1136   myPrompt = READY_PROMPT;
1137   addText( myPrompt );
1138 }
1139
1140 /*!
1141   \brief "Dump commands" operation.
1142  */
1143 void PyConsole_Editor::dump()
1144 {
1145   QStringList aFilters;
1146   aFilters.append( tr( "PYTHON_FILES_FILTER" ) );
1147
1148   QString fileName = SUIT_FileDlg::getFileName( this, QString(),
1149                                                 aFilters, tr( "TOT_DUMP_PYCOMMANDS" ),
1150                                                 false, true, new DumpCommandsFileValidator( this ) );
1151   if ( !fileName.isEmpty() ) {
1152     QFile file( fileName );
1153     if ( !file.open( QFile::WriteOnly ) )
1154       return;
1155
1156     QTextStream out (&file);
1157
1158     for ( int i=0; i<myHistory.count(); i++ ) {
1159       out << myHistory[i] << endl;
1160     }
1161     file.close();
1162   }
1163 }
1164 /*!
1165   \brief "Start log" operation.
1166  */
1167 void PyConsole_Editor::startLog()
1168 {
1169   QStringList aFilters;
1170   aFilters.append( tr( "LOG_FILES_FILTER" ) );
1171
1172   while (1) {
1173     QString fileName = SUIT_FileDlg::getFileName( this, QString(),
1174                                                   aFilters, tr( "TOT_SAVE_PYLOG" ),
1175                                                   false, true );
1176     if ( !fileName.isEmpty() ) {
1177       if ( startLog( fileName ) ) {
1178         break;
1179       }
1180       else {
1181         SUIT_MessageBox::critical( this,
1182                                    QObject::tr("ERR_ERROR"),
1183                                    QObject::tr("ERR_FILE_NOT_WRITABLE") );
1184       }
1185     }
1186     else {
1187       break;
1188     }
1189   }
1190 }
1191
1192 /*!
1193   \brief Start python trace logging
1194   \param fileName the path to the log file
1195   \sa stopLog()
1196  */
1197 bool PyConsole_Editor::startLog( const QString& fileName )
1198 {
1199   bool ok = false;
1200   if ( !fileName.isEmpty() ) {
1201     QFile file( fileName );
1202     if ( file.open( QFile::WriteOnly ) ) {
1203       file.close();
1204       myLogFile = fileName;
1205       ok = true;
1206     }
1207   }
1208   return ok;
1209 }
1210
1211 /*!
1212   \brief "Stop log" operation.
1213   \sa startLog()
1214  */
1215 void PyConsole_Editor::stopLog()
1216 {
1217   myLogFile = QString();
1218 }
1219
1220 /*!
1221   \brief Put string to the log file
1222  */
1223 void PyConsole_Editor::putLog( const QString& s )
1224 {
1225   if ( !myLogFile.isEmpty() ) {
1226     QFile file( myLogFile );
1227     if ( !file.open( QFile::Append ) )
1228       return;
1229
1230     QTextStream out (&file);
1231     out << s;
1232
1233     file.close();
1234   }
1235 }