]> SALOME platform Git repositories - modules/gui.git/blob - src/PyConsole/PyConsole_Editor.cxx
Salome HOME
0022652: [CEA 1194] Redirect the traces from embedded Python console in a log file
[modules/gui.git] / 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     QApplication::postEvent( (PyConsole_Editor*)data, new PrintEvent( QString::fromUtf8(c), false ) );
143 }
144
145 void staticCallbackStderr( void* data, char* c )
146 {
147   if(!((PyConsole_Editor*)data)->isSuppressOutput())
148     QApplication::postEvent( (PyConsole_Editor*)data, new PrintEvent( QString::fromUtf8(c), true ) );
149 }
150
151
152 /*!
153   \brief Constructor. 
154   
155   Creates python editor window.
156   \param theInterp python interper
157   \param theParent parent widget
158 */
159 PyConsole_Editor::PyConsole_Editor( PyConsole_Interp* theInterp, 
160                                     QWidget*          theParent )
161 : QTextEdit( theParent ),
162   myInterp( 0 ),
163   myCmdInHistory( -1 ),
164   myEventLoop( 0 ),
165   myShowBanner( true ),
166   myIsSync( false ),
167   myIsSuppressOutput( false )
168 {
169   QString fntSet( "" );
170   QFont aFont = SUIT_Tools::stringToFont( fntSet );
171   setFont( aFont );
172   setUndoRedoEnabled( false );
173
174   myPrompt = READY_PROMPT;
175   setLineWrapMode( QTextEdit::WidgetWidth );
176   setWordWrapMode( QTextOption::WrapAnywhere );
177   setAcceptRichText( false );
178
179   theInterp->setvoutcb( staticCallbackStdout, this );
180   theInterp->setverrcb( staticCallbackStderr, this );
181
182   // san - This is necessary for troubleless initialization
183   onPyInterpChanged( theInterp );
184 }
185
186 /*!
187   \brief Destructor.
188
189   Does nothing for the moment.
190 */
191 PyConsole_Editor::~PyConsole_Editor()
192 {
193   myInterp->destroy();
194   delete myInterp;
195   myInterp = 0;
196 }
197
198 /*!
199   \brief Get synchronous mode flag value.
200   
201   \sa setIsSync()
202   \return True if python console works in synchronous mode
203 */
204 bool PyConsole_Editor::isSync() const
205 {
206   return myIsSync;
207 }
208
209 /*!
210   \brief Set synchronous mode flag value.
211
212   In synhronous mode the Python commands are executed in the GUI thread
213   and the GUI is blocked until the command is finished. In the asynchronous
214   mode each Python command is executed in the separate thread that does not
215   block the main GUI loop.
216
217   \param on synhronous mode flag
218 */
219 void PyConsole_Editor::setIsSync( const bool on )
220 {
221   myIsSync = on;
222 }
223
224 /*!
225   \brief Get suppress output flag value.
226   
227   \sa setIsSuppressOutput()
228   \return \c true if python console output is suppressed.
229 */
230 bool PyConsole_Editor::isSuppressOutput() const
231 {
232   return myIsSuppressOutput;
233 }
234
235 /*!
236   \brief Set suppress output flag value.
237
238   In case if suppress output flag is true, the python 
239   console output suppressed.
240
241   \param on suppress output flag
242 */
243 void PyConsole_Editor::setIsSuppressOutput( const bool on )
244 {
245   myIsSuppressOutput = on;
246 }
247
248 /*!
249   \brief Get 'show banner' flag value.
250   
251   \sa setIsShowBanner()
252   \return \c true if python console shows banner
253 */
254 bool PyConsole_Editor::isShowBanner() const
255 {
256   return myShowBanner;
257 }
258
259 /*!
260   \brief Set 'show banner' flag value.
261
262   The banner is shown in the top of the python console window.
263
264   \sa isShowBanner()
265   \param on 'show banner' flag
266 */
267 void PyConsole_Editor::setIsShowBanner( const bool on )
268 {
269   if ( myShowBanner != on ) {
270     myShowBanner = on;
271     clear();
272   }
273 }
274
275 /*!
276   \brief Get size hint for the Python console window
277   \return size hint value
278 */
279 QSize PyConsole_Editor::sizeHint() const
280 {
281   QFontMetrics fm( font() );
282   int nbLines = ( isShowBanner() ? myBanner.split("\n").count() : 0 ) + 1;
283   QSize s(100, fm.lineSpacing()*nbLines);
284   return s;
285 }
286
287 /*!
288   \brief Put the string \a str to the python editor.
289   \param str string to be put in the command line of the editor
290   \param newBlock if True, then the string is printed on a new line
291   \param isError if true, the text is printed in dark red
292 */
293 void PyConsole_Editor::addText( const QString& str, 
294                                 const bool     newBlock,
295                                 const bool    isError)
296 {
297   QTextCursor theCursor(textCursor());
298   QTextCharFormat cf;
299
300   moveCursor( QTextCursor::End );
301   if ( newBlock )
302     theCursor.insertBlock();
303   if (isError)
304       cf.setForeground(QBrush(Qt::red));
305   else
306       cf.setForeground(QBrush(Qt::black));
307   theCursor.insertText( str, cf);
308   moveCursor( QTextCursor::End );
309   ensureCursorVisible();
310 }
311
312 /*!
313   \brief Convenient method for executing a Python command,
314   as if the user typed it manually.
315   \param command python command to be executed
316
317   !!! WARNING: doesn't work properly with multi-line commands. !!!
318 */
319 void PyConsole_Editor::exec( const QString& command )
320 {
321   if ( isReadOnly() ) {
322     // some interactive command is being executed in this editor...
323     // shedule the command to the queue
324     myQueue.push_back( command );
325     return;
326   }
327   // remove last line
328   moveCursor( QTextCursor::End );
329   moveCursor( QTextCursor::StartOfBlock, QTextCursor::KeepAnchor );
330   textCursor().removeSelectedText();
331   // set "ready" prompt
332   myPrompt = READY_PROMPT;
333   // clear command buffer
334   myCommandBuffer.truncate( 0 );
335   // unset history browsing mode
336   myCmdInHistory = -1;
337   // print command line by line
338   QString cmd = command;
339   if ( !cmd.endsWith( "\n" ) ) cmd += "\n";
340   QStringList lines = command.split( "\n" );
341   for ( int i = 0; i < lines.size(); i++ ) {
342     if ( !lines[i].trimmed().isEmpty() ) {
343       PyCommand aCommand;
344       aCommand.command = lines[i];
345       myHistory.append( aCommand );
346     }
347     addText( ( i == 0 ? READY_PROMPT : DOTS_PROMPT ) + lines[i], i != 0 );
348   }
349   // IPAL20182
350   addText( "", true );
351   // set read-only mode
352   setReadOnly( true );
353   // set busy cursor
354   setCursor( Qt::BusyCursor );
355   
356   // post a request to execute Python command;
357   // editor will be informed via a custom event that execution has been completed
358   PyInterp_Dispatcher::Get()->Exec( createRequest( cmd ) );
359 }
360
361 /*!
362   \brief Create request to the python dispatcher for the command execution.
363
364   \param command python command to be executed
365  */
366 PyInterp_Request* PyConsole_Editor::createRequest( const QString& command )
367 {
368   return new ExecCommand( myInterp, command, this, isSync() );
369 }
370
371 /*!
372   \brief Execute command in the python interpreter
373   and wait until it is finished.
374
375   \param command python command to be executed
376  */
377 void PyConsole_Editor::execAndWait( const QString& command )
378 {
379   // already running ?
380   if( myEventLoop )
381     return;
382
383   // create new event loop
384   myEventLoop = new QEventLoop( this );
385   // execute command
386   exec( command );
387   // run event loop
388   myEventLoop->exec();
389   // delete event loop after command is processed
390   delete myEventLoop;
391   myEventLoop = 0;
392 }
393
394 /*!
395   \brief Process "Enter" key press event. 
396   
397   Execute the command entered by the user.
398 */
399 void PyConsole_Editor::handleReturn()
400 {
401   // Position cursor at the end
402   QTextCursor curs(textCursor());
403   curs.movePosition(QTextCursor::End);
404   setTextCursor(curs);
405
406   // get last line
407   QTextBlock par = document()->end().previous();
408   if ( !par.isValid() ) return;
409
410   // get command
411   QString cmd = par.text().remove( 0, promptSize() );
412   // extend the command buffer with the current command 
413   myCommandBuffer.append( cmd );
414   // add command to the history
415   if ( !cmd.trimmed().isEmpty() ) {
416     PyCommand aCommand;
417     aCommand.command = cmd;
418     myHistory.append( aCommand );
419   }
420
421   // IPAL19397
422   addText( "", true ); 
423   
424   // set read-only mode
425   setReadOnly( true );
426   // set busy cursor
427   setCursor( Qt::BusyCursor );
428   
429   // post a request to execute Python command;
430   // editor will be informed via a custom event that execution has been completed
431   PyInterp_Dispatcher::Get()->Exec( createRequest( myCommandBuffer ) );
432 }
433
434 /*!
435   \brief Process drop event.
436
437   Paste dragged text.
438   \param event drop event
439 */
440 void PyConsole_Editor::dropEvent( QDropEvent* event )
441 {
442   // get the initial drop position
443   QPoint pos = event->pos();
444   QTextCursor cur = cursorForPosition( event->pos() );
445   // if the position is not in the last line move it to the end of the command line
446   if ( cur.position() < document()->end().previous().position() + promptSize() ) {
447     moveCursor( QTextCursor::End );
448     pos = cursorRect().center();
449   }
450   // create new drop event and use it instead of the original
451   QDropEvent de( pos,
452                  event->possibleActions(),
453                  event->mimeData(),
454                  event->mouseButtons(),
455                  event->keyboardModifiers(),
456                  event->type() );
457   QTextEdit::dropEvent( &de );
458   // accept the original event
459   event->acceptProposedAction();
460 }
461
462 /*!
463   \brief Process mouse button release event.
464
465   Left mouse button: copy selection to the clipboard.
466   Middle mouse button: paste clipboard's contents.
467   \param event mouse event
468 */
469 void PyConsole_Editor::mouseReleaseEvent( QMouseEvent* event )
470 {
471   if ( event->button() == Qt::LeftButton ) {
472     QTextEdit::mouseReleaseEvent( event );
473     //copy();
474   }
475   else if ( event->button() == Qt::MidButton ) {
476     QTextCursor cur = cursorForPosition( event->pos() );
477     // if the position is not in the last line move it to the end of the command line
478     if ( cur.position() < document()->end().previous().position() + promptSize() ) {
479       moveCursor( QTextCursor::End );
480     }
481     else {
482       setTextCursor( cur );
483     }
484     const QMimeData* md = QApplication::clipboard()->mimeData( QApplication::clipboard()->supportsSelection() ? 
485                                                                QClipboard::Selection : QClipboard::Clipboard );
486     if ( md )
487       insertFromMimeData( md );
488   }
489   else {
490     QTextEdit::mouseReleaseEvent( event );
491   }
492 }
493
494 /*!
495   \brief Check if the string is command.
496   
497   Return True if the string \a str is likely to be the command
498   (i.e. it is started from the '>>>' or '...').
499   \param str string to be checked
500 */
501 bool PyConsole_Editor::isCommand( const QString& str ) const
502 {
503   return str.startsWith( READY_PROMPT ) || str.startsWith( DOTS_PROMPT );
504 }
505
506 /*!
507   \brief Handle keyboard event.
508
509   Implement navigation, history browsing, copy/paste and other common
510   operations.
511   \param event keyboard event
512 */
513 void PyConsole_Editor::keyPressEvent( QKeyEvent* event )
514 {
515   // get cursor position
516   QTextCursor cur = textCursor();
517   int curLine = cur.blockNumber();
518   int curCol  = cur.columnNumber();
519
520   // get last edited line
521   int endLine = document()->blockCount()-1;
522
523   // get pressed key code
524   int aKey = event->key();
525
526   // check if <Ctrl> is pressed
527   bool ctrlPressed = event->modifiers() & Qt::ControlModifier;
528   // check if <Shift> is pressed
529   bool shftPressed = event->modifiers() & Qt::ShiftModifier;
530
531   if ( aKey == Qt::Key_Escape || ( ctrlPressed && aKey == -1 ) ) {
532     // process <Ctrl>+<Break> key-binding and <Escape> key: clear current command
533     myCommandBuffer.truncate( 0 );
534     myPrompt = READY_PROMPT;
535     addText( myPrompt, true );
536     horizontalScrollBar()->setValue( horizontalScrollBar()->minimum() );
537     return;
538   }
539   else if ( ctrlPressed && aKey == Qt::Key_C ) {
540     // process <Ctrl>+<C> key-binding : copy
541     copy();
542     return;
543   }
544   else if ( ctrlPressed && aKey == Qt::Key_X ) {
545     // process <Ctrl>+<X> key-binding : cut
546     cut();
547     return;
548   }
549   else if ( ctrlPressed && aKey == Qt::Key_V ) {
550     // process <Ctrl>+<V> key-binding : paste
551     paste();
552     return;
553   }
554
555   // check for printed key
556   // #### aKey = ( aKey < Qt::Key_Space || aKey > Qt::Key_ydiaeresis ) ? aKey : 0;
557   // Better:
558   aKey = !(QChar(aKey).isPrint()) ? aKey : 0;
559
560   switch ( aKey ) {
561   case 0 :
562     // any printed key: just print it
563     {
564       if ( curLine < endLine || curCol < promptSize() ) {
565         moveCursor( QTextCursor::End );
566       }
567       QTextEdit::keyPressEvent( event );
568       break;
569     }
570   case Qt::Key_Return:
571   case Qt::Key_Enter:
572     // <Enter> key: process the current command
573     {
574       handleReturn();
575       break;
576     }
577   case Qt::Key_Up:
578     // <Up> arrow key: process as follows:
579     // - without <Ctrl>, <Shift> modifiers: previous command in history
580     // - with <Ctrl> modifier key pressed:  move cursor one row up without selection
581     // - with <Shift> modifier key pressed: move cursor one row up with selection
582     // - with <Ctrl>+<Shift> modifier keys pressed: scroll one row up
583     {
584       if ( ctrlPressed && shftPressed ) {
585         int value   = verticalScrollBar()->value();
586         int spacing = fontMetrics().lineSpacing();
587         verticalScrollBar()->setValue( value > spacing ? value-spacing : 0 );
588       }
589       else if ( shftPressed || ctrlPressed ) {
590         if ( curLine > 0 )
591           moveCursor( QTextCursor::Up, 
592                       shftPressed ? QTextCursor::KeepAnchor : QTextCursor::MoveAnchor );
593       }
594       else { 
595         if ( myCmdInHistory < 0 && myHistory.count() > 0 ) {
596           // set history browsing mode
597           myCmdInHistory = myHistory.count();
598           // remember current command
599           QTextBlock par = document()->end().previous();
600           myCurrentCommand = par.text().remove( 0, promptSize() );
601         }
602         if ( myCmdInHistory > 0 ) {
603           myCmdInHistory--;
604           // get previous command in the history
605           QString previousCommand = myHistory.at( myCmdInHistory ).command;
606           // print previous command
607           moveCursor( QTextCursor::End );
608           moveCursor( QTextCursor::StartOfBlock, QTextCursor::KeepAnchor );
609           textCursor().removeSelectedText();
610           addText( myPrompt + previousCommand ); 
611           // move cursor to the end
612           moveCursor( QTextCursor::End );
613         }
614       }
615       break;
616     }
617   case Qt::Key_Down:
618     // <Down> arrow key: process as follows:
619     // - without <Ctrl>, <Shift> modifiers: next command in history
620     // - with <Ctrl> modifier key pressed:  move cursor one row down without selection
621     // - with <Shift> modifier key pressed: move cursor one row down with selection
622     // - with <Ctrl>+<Shift> modifier keys pressed: scroll one row down
623     {
624       if ( ctrlPressed && shftPressed ) {
625         int value   = verticalScrollBar()->value();
626         int maxval  = verticalScrollBar()->maximum();
627         int spacing = fontMetrics().lineSpacing();
628         verticalScrollBar()->setValue( value+spacing < maxval ? value+spacing : maxval );
629       }
630       else if ( shftPressed || ctrlPressed) {
631         if ( curLine < endLine )
632           moveCursor( QTextCursor::Down, 
633                       shftPressed ? QTextCursor::KeepAnchor : QTextCursor::MoveAnchor );
634       }
635       else { 
636         if ( myCmdInHistory >= 0 ) {
637           // get next command in the history
638           myCmdInHistory++;
639           QString nextCommand;
640           if ( myCmdInHistory < myHistory.count() ) {
641             // next command in history
642             nextCommand = myHistory.at( myCmdInHistory ).command;
643           }
644           else {
645             // end of history is reached
646             // last printed command
647             nextCommand = myCurrentCommand;
648             // unset history browsing mode
649             myCmdInHistory = -1;
650           }
651           // print next or current command
652           moveCursor( QTextCursor::End );
653           moveCursor( QTextCursor::StartOfBlock, QTextCursor::KeepAnchor );
654           textCursor().removeSelectedText();
655           addText( myPrompt + nextCommand );
656           // move cursor to the end
657           moveCursor( QTextCursor::End );
658         }
659       }
660       break;
661     }
662   case Qt::Key_Left:
663     // <Left> arrow key: process as follows:
664     // - without <Ctrl>, <Shift> modifiers: move one symbol left (taking into account prompt)
665     // - with <Ctrl> modifier key pressed:  move one word left (taking into account prompt)
666     // - with <Shift> modifier key pressed: move one symbol left with selection
667     // - with <Ctrl>+<Shift> modifier keys pressed: move one word left with selection
668     {
669       QString txt = textCursor().block().text();
670       if ( !shftPressed && isCommand( txt ) && curCol <= promptSize() ) {
671         moveCursor( QTextCursor::Up );
672         moveCursor( QTextCursor::EndOfBlock );
673       }
674       else {
675         QTextEdit::keyPressEvent( event );
676       }
677       break;
678     }
679   case Qt::Key_Right:
680     // <Right> arrow key: process as follows:
681     // - without <Ctrl>, <Shift> modifiers: move one symbol right (taking into account prompt)
682     // - with <Ctrl> modifier key pressed:  move one word right (taking into account prompt)
683     // - with <Shift> modifier key pressed: move one symbol right with selection
684     // - with <Ctrl>+<Shift> modifier keys pressed: move one word right with selection
685     {
686       QString txt = textCursor().block().text();
687       if ( !shftPressed ) {
688         if ( curCol < txt.length() ) {
689           if ( isCommand( txt ) && curCol < promptSize() ) {
690             cur.setPosition( cur.block().position() + promptSize() );
691             setTextCursor( cur );
692             break;
693           }
694         }
695         else {
696           if ( curLine < endLine && isCommand( textCursor().block().next().text() ) ) {
697             cur.setPosition( cur.position() + promptSize()+1 );
698             setTextCursor( cur );
699             horizontalScrollBar()->setValue( horizontalScrollBar()->minimum() );
700             break;
701           }
702         }
703       }
704       QTextEdit::keyPressEvent( event );
705       break;
706     }
707   case Qt::Key_PageUp:
708     // <PageUp> key: process as follows:
709     // - without <Ctrl>, <Shift> modifiers: first command in history
710     // - with <Ctrl> modifier key pressed:  move cursor one page up without selection
711     // - with <Shift> modifier key pressed: move cursor one page up with selection
712     // - with <Ctrl>+<Shift> modifier keys pressed: scroll one page up
713     {
714       if ( ctrlPressed && shftPressed ) {
715         verticalScrollBar()->triggerAction(QAbstractSlider::SliderPageStepSub);
716       }
717       else if ( shftPressed || ctrlPressed ) {
718         bool moved = false;
719         qreal lastY = cursorRect( cur ).top();
720         qreal distance = 0;
721         // move using movePosition to keep the cursor's x
722         do {
723           qreal y = cursorRect( cur ).top();
724           distance += qAbs( y - lastY );
725           lastY = y;
726           moved = cur.movePosition( QTextCursor::Up, 
727                                     shftPressed ? QTextCursor::KeepAnchor : 
728                                                   QTextCursor::MoveAnchor );
729         } while ( moved && distance < viewport()->height() );
730         if ( moved ) {
731           cur.movePosition( QTextCursor::Down, 
732                             shftPressed ? QTextCursor::KeepAnchor : 
733                                           QTextCursor::MoveAnchor );
734           verticalScrollBar()->triggerAction( QAbstractSlider::SliderPageStepSub );
735         }
736         setTextCursor( cur );
737       }
738       else { 
739         if ( myCmdInHistory < 0 && myHistory.count() > 0 ) {
740           // set history browsing mode
741           myCmdInHistory = myHistory.count();
742           // remember current command
743           QTextBlock par = document()->end().previous();
744           myCurrentCommand = par.text().remove( 0, promptSize() );
745         }
746         if ( myCmdInHistory > 0 ) {
747           myCmdInHistory = 0;
748           // get very first command in the history
749           QString firstCommand = myHistory.at( myCmdInHistory ).command;
750           // print first command
751           moveCursor( QTextCursor::End );
752           moveCursor( QTextCursor::StartOfBlock, QTextCursor::KeepAnchor );
753           textCursor().removeSelectedText();
754           addText( myPrompt + firstCommand ); 
755           // move cursor to the end
756           moveCursor( QTextCursor::End );
757         }
758       }
759       break;
760     }
761   case Qt::Key_PageDown:
762     // <PageDown> key: process as follows:
763     // - without <Ctrl>, <Shift> modifiers: last command in history
764     // - with <Ctrl> modifier key pressed:  move cursor one page down without selection
765     // - with <Shift> modifier key pressed: move cursor one page down with selection
766     // - with <Ctrl>+<Shift> modifier keys pressed: scroll one page down
767     {
768       if ( ctrlPressed && shftPressed ) {
769         verticalScrollBar()->triggerAction(QAbstractSlider::SliderPageStepAdd);
770       }
771       else if ( shftPressed || ctrlPressed ) {
772         bool moved = false;
773         qreal lastY = cursorRect( cur ).top();
774         qreal distance = 0;
775         // move using movePosition to keep the cursor's x
776         do {
777           qreal y = cursorRect( cur ).top();
778           distance += qAbs( y - lastY );
779           lastY = y;
780           moved = cur.movePosition( QTextCursor::Down, 
781                                     shftPressed ? QTextCursor::KeepAnchor : 
782                                                   QTextCursor::MoveAnchor );
783         } while ( moved && distance < viewport()->height() );
784         if ( moved ) {
785           cur.movePosition( QTextCursor::Up, 
786                             shftPressed ? QTextCursor::KeepAnchor : 
787                                           QTextCursor::MoveAnchor );
788           verticalScrollBar()->triggerAction( QAbstractSlider::SliderPageStepSub );
789         }
790         setTextCursor( cur );
791       }
792       else { 
793         if ( myCmdInHistory >= 0 ) {
794           // unset history browsing mode
795           myCmdInHistory = -1;
796           // print current command
797           moveCursor( QTextCursor::End );
798           moveCursor( QTextCursor::StartOfBlock, QTextCursor::KeepAnchor );
799           textCursor().removeSelectedText();
800           addText( myPrompt + myCurrentCommand ); 
801           // move cursor to the end
802           moveCursor( QTextCursor::End );
803         }
804       }
805       break;
806     }
807   case Qt::Key_Home: 
808     // <Home> key: process as follows:
809     // - without <Ctrl>, <Shift> modifiers: move cursor to the beginning of the current line without selection
810     // - with <Ctrl> modifier key pressed:  move cursor to the very first symbol without selection
811     // - with <Shift> modifier key pressed: move cursor to the beginning of the current line with selection
812     // - with <Ctrl>+<Shift> modifier keys pressed: move cursor to the very first symbol with selection
813     {
814       if ( ctrlPressed ) { 
815         moveCursor( QTextCursor::Start, 
816                     shftPressed ? QTextCursor::KeepAnchor : QTextCursor::MoveAnchor );
817       }
818       else {
819         QString txt = textCursor().block().text();
820         if ( isCommand( txt ) ) {
821           if ( shftPressed ) {
822             if ( curCol > promptSize() ) {
823               cur.movePosition( QTextCursor::StartOfLine, QTextCursor::KeepAnchor );
824               cur.movePosition( QTextCursor::Right, QTextCursor::KeepAnchor, promptSize() );
825             }
826           }
827           else {
828             cur.movePosition( QTextCursor::StartOfLine );
829             cur.movePosition( QTextCursor::Right, QTextCursor::MoveAnchor, promptSize() );
830           }
831           setTextCursor( cur );
832         }
833         else {
834           moveCursor( QTextCursor::StartOfBlock, 
835                       shftPressed ? QTextCursor::KeepAnchor : QTextCursor::MoveAnchor );
836         }
837         horizontalScrollBar()->setValue( horizontalScrollBar()->minimum() );
838       }
839       break;
840     }
841   case Qt::Key_End:
842     // <End> key: process as follows:
843     // - without <Ctrl>, <Shift> modifiers: move cursor to the end of the current line without selection
844     // - with <Ctrl> modifier key pressed:  move cursor to the very last symbol without selection
845     // - with <Shift> modifier key pressed: move cursor to the end of the current line with selection
846     // - with <Ctrl>+<Shift> modifier keys pressed: move cursor to the very last symbol with selection
847     {
848       moveCursor( ctrlPressed ? QTextCursor::End : QTextCursor::EndOfBlock, 
849                   shftPressed ? QTextCursor::KeepAnchor : QTextCursor::MoveAnchor );
850       break;
851     }  
852   case Qt::Key_Backspace :
853     // <Backspace> key: process as follows
854     // - without any modifiers : delete symbol before the cursor / selection (taking into account prompt)
855     // - with <Shift> modifier key pressed: delete previous word
856     // - with <Ctrl> modifier key pressed: delete text from the cursor to the line beginning
857     // works only for last (command) line
858     {
859       if ( cur.hasSelection() ) {
860         cut();
861       }
862       else if ( cur.position() > document()->end().previous().position() + promptSize() ) {
863         if ( shftPressed ) {
864           moveCursor( QTextCursor::PreviousWord, QTextCursor::KeepAnchor );
865           textCursor().removeSelectedText();
866         }
867         else if ( ctrlPressed ) {
868           cur.setPosition( document()->end().previous().position() + promptSize(),
869                            QTextCursor::KeepAnchor );
870           setTextCursor( cur );
871           textCursor().removeSelectedText();
872         }
873         else {
874           QTextEdit::keyPressEvent( event );
875         }
876       }
877       else {
878         cur.setPosition( document()->end().previous().position() + promptSize() );
879         setTextCursor( cur );
880         horizontalScrollBar()->setValue( horizontalScrollBar()->minimum() );
881       }
882       break;
883     }
884   case Qt::Key_Delete :
885     // <Delete> key: process as follows
886     // - without any modifiers : delete symbol after the cursor / selection (taking into account prompt)
887     // - with <Shift> modifier key pressed: delete next word
888     // - with <Ctrl> modifier key pressed: delete text from the cursor to the end of line
889     // works only for last (command) line
890     {
891       if ( cur.hasSelection() ) {
892         cut();
893       }
894       else if ( cur.position() > document()->end().previous().position() + promptSize()-1 ) {
895         if ( shftPressed ) {
896           moveCursor( QTextCursor::NextWord, QTextCursor::KeepAnchor );
897           textCursor().removeSelectedText();
898         }
899         else if ( ctrlPressed ) {
900           moveCursor( QTextCursor::EndOfBlock, QTextCursor::KeepAnchor );
901           textCursor().removeSelectedText();
902         }
903         else {
904           QTextEdit::keyPressEvent( event );
905         }
906       }
907       else {
908         cur.setPosition( document()->end().previous().position() + promptSize() );
909         setTextCursor( cur );
910         horizontalScrollBar()->setValue( horizontalScrollBar()->minimum() );
911       }
912       break;
913     }
914   case Qt::Key_Insert :
915     // <Insert> key: process as follows
916     // - with <Ctrl> modifier key pressed:  copy()
917     // - with <Shift> modifier key pressed: paste() to the command line
918     {
919       if ( ctrlPressed ) {
920         copy();
921       }
922       else if ( shftPressed ) {
923         paste();
924       }
925       else
926         QTextEdit::keyPressEvent( event );
927       break;
928     }
929   }
930 }
931
932 /*!
933   \brief Handle notification event coming from Python dispatcher.
934   \param event notification event
935 */
936 void PyConsole_Editor::customEvent( QEvent* event )
937 {
938   switch( event->type() )
939   {
940   case PrintEvent::EVENT_ID:
941     {
942       PrintEvent* pe=(PrintEvent*)event;
943       addText( pe->text(), false, pe->isError());
944       myHistory.last().output = myHistory.last().output + pe->text();
945       return;
946     }
947   case PyInterp_Event::ES_OK:
948   case PyInterp_Event::ES_ERROR:
949   {
950     // clear command buffer
951     myCommandBuffer.truncate( 0 );
952     // add caret return line if necessary
953     QTextBlock par = document()->end().previous();
954     QString txt = par.text();
955     txt.truncate( txt.length() - 1 );
956     // IPAL19397 : addText moved to handleReturn() method
957     //if ( !txt.isEmpty() )
958     //  addText( "", true );
959     // set "ready" prompt
960     myPrompt = READY_PROMPT;
961     addText( myPrompt );
962     // unset busy cursor
963     unsetCursor();
964     // stop event loop (if running)
965     if ( myEventLoop )
966       myEventLoop->exit();
967     break;
968   }
969   case PyInterp_Event::ES_INCOMPLETE:
970   {
971     // extend command buffer (multi-line command)
972     myCommandBuffer.append( "\n" );
973     // add caret return line if necessary
974     QTextBlock par = document()->end().previous();
975     QString txt = par.text();
976     txt.truncate( txt.length() - 1 );
977     // IPAL19397 : addText moved to handleReturn() method
978     //if ( !txt.isEmpty() )
979     //  addText( "", true );
980     // set "dot" prompt
981     myPrompt = DOTS_PROMPT;
982     addText( myPrompt/*, true*/ ); // IPAL19397
983     // unset busy cursor
984     unsetCursor();
985     // stop event loop (if running)
986     if ( myEventLoop )
987       myEventLoop->exit();
988     break;
989   }
990   default:
991     QTextEdit::customEvent( event );
992   }
993   
994   // unset read-only state
995   setReadOnly( false );
996   // unset history browsing mode
997   myCmdInHistory = -1;
998
999   if ( (int)event->type() == (int)PyInterp_Event::ES_OK && myQueue.count() > 0 )
1000   {
1001     // process the next sheduled command from the queue (if there is any)
1002     QString nextcmd = myQueue[0];
1003     myQueue.pop_front();
1004     exec( nextcmd );
1005   }
1006 }
1007
1008 /*!
1009   \brief Handle Python interpreter change.
1010
1011   Perform initialization actions if the interpreter is changed.
1012   \param interp python interpreter is being set
1013 */
1014 void PyConsole_Editor::onPyInterpChanged( PyConsole_Interp* interp )
1015 {
1016   if ( myInterp != interp 
1017        // Force read-only state and wait cursor when myInterp is NULL
1018       || !myInterp ) {
1019     myInterp = interp;
1020     if ( myInterp ) {
1021       // print banner
1022       myBanner = myInterp->getbanner().c_str();
1023       if ( isShowBanner() )
1024         addText( myBanner );
1025       // clear command buffer
1026       myCommandBuffer.truncate(0);
1027       // unset read-only state
1028       setReadOnly( false );
1029       // unset history browsing mode
1030       myCmdInHistory = -1;
1031       // add prompt
1032       addText( myPrompt );
1033       // unset busy cursor
1034       viewport()->unsetCursor();
1035       // stop event loop (if running)
1036       if( myEventLoop)
1037         myEventLoop->exit();
1038     }
1039     else {
1040       // clear contents
1041       clear();
1042       // set read-only state
1043       setReadOnly( true );
1044       // set busy cursor
1045       setCursor( Qt::WaitCursor );
1046     }
1047   }
1048 }
1049
1050 /*!
1051   \brief "Copy" operation.
1052   
1053   Reimplemented from Qt.
1054   Warning! In Qt4 this method is not virtual.
1055  */
1056 void PyConsole_Editor::cut()
1057 {
1058   QTextCursor cur = textCursor();
1059   if ( cur.hasSelection() ) {
1060     QApplication::clipboard()->setText( cur.selectedText() );
1061     int startSelection = cur.selectionStart();
1062     if ( startSelection < document()->end().previous().position() + promptSize() )
1063       startSelection = document()->end().previous().position() + promptSize();
1064     int endSelection = cur.selectionEnd();
1065     if ( endSelection < document()->end().previous().position() + promptSize() )
1066       endSelection = document()->end().previous().position() + promptSize();
1067     cur.setPosition( startSelection );
1068     cur.setPosition( endSelection, QTextCursor::KeepAnchor );
1069     horizontalScrollBar()->setValue( horizontalScrollBar()->minimum() );
1070     setTextCursor( cur );
1071     textCursor().removeSelectedText();
1072   }
1073 }
1074
1075 /*!
1076   \brief "Paste" operation.
1077
1078   Reimplemented from Qt.
1079   Warning! In Qt4 this method is not virtual.
1080  */
1081 void PyConsole_Editor::paste()
1082 {
1083   QTextCursor cur = textCursor();
1084   if ( cur.hasSelection() ) {
1085     int startSelection = cur.selectionStart();
1086     if ( startSelection < document()->end().previous().position() + promptSize() )
1087       startSelection = document()->end().previous().position() + promptSize();
1088     int endSelection = cur.selectionEnd();
1089     if ( endSelection < document()->end().previous().position() + promptSize() )
1090       endSelection = document()->end().previous().position() + promptSize();
1091     cur.setPosition( startSelection );
1092     cur.setPosition( endSelection, QTextCursor::KeepAnchor );
1093     horizontalScrollBar()->setValue( horizontalScrollBar()->minimum() );
1094     setTextCursor( cur );
1095     textCursor().removeSelectedText();
1096   }
1097   if ( textCursor().position() < document()->end().previous().position() + promptSize() )
1098     moveCursor( QTextCursor::End );
1099   QTextEdit::paste();
1100 }
1101
1102 /*!
1103   \brief "Clear" operation.
1104
1105   Reimplemented from Qt.
1106   Warning! In Qt4 this method is not virtual.
1107  */
1108 void PyConsole_Editor::clear()
1109 {
1110   QTextEdit::clear();
1111   if ( isShowBanner() )
1112     addText( myBanner );
1113   myPrompt = READY_PROMPT;
1114   addText( myPrompt );
1115 }
1116
1117 /*!
1118   \brief "Dump commands" operation.
1119  */
1120 void PyConsole_Editor::dump()
1121 {
1122   QStringList aFilters;
1123   aFilters.append( tr( "PYTHON_FILES_FILTER" ) );
1124   
1125   QString fileName = SUIT_FileDlg::getFileName( this, QString(),
1126                                      aFilters, tr( "TOT_DUMP_PYCOMMANDS" ),
1127                                      false, true, new DumpCommandsFileValidator( this ) );
1128   if ( fileName != "" ) {
1129     QFile file( fileName ); 
1130     if ( !file.open( QFile::WriteOnly ) )
1131       return;
1132
1133     QTextStream out (&file);
1134   
1135     for( int i=0; i<myHistory.count(); i++ ) {
1136          out<<myHistory.at(i).command<<endl;
1137     }
1138     file.close();
1139   }
1140 }
1141 /*!
1142   \brief "Save log" operation.
1143  */
1144 void PyConsole_Editor::saveLog()
1145 {
1146   QStringList aFilters;
1147   aFilters.append( tr( "PYTHON_FILES_FILTER" ) );
1148
1149   QString fileName = SUIT_FileDlg::getFileName( this, QString(),
1150                      aFilters, tr( "TOT_SAVE_PYLOG" ),
1151                  false, true, new DumpCommandsFileValidator( this ) );
1152   if ( fileName != "" ) {
1153     QFile file( fileName );
1154     if ( !file.open( QFile::WriteOnly ) )
1155       return;
1156
1157     QTextStream out (&file);
1158
1159     for( int i = 0; i < myHistory.count(); i++ ) {
1160          out << myHistory.at(i).command << endl;
1161          out << myHistory.at(i).output;
1162     }
1163     file.close();
1164   }
1165 }