*** empty log message ***

diff --git a/src/PyConsole/PyConsole_Console.cxx b/src/PyConsole/PyConsole_Console.cxx
index c7711b928d2cd73153971262aec7ee155bed6b1a..85ba6c722115b64837ddebcd53a95c996e1d0da2 100644 (file)
--- a/src/PyConsole/PyConsole_Console.cxx
+++ b/src/PyConsole/PyConsole_Console.cxx
@@ -102,6 +102,16 @@ void PythonConsole::execAndWait( const QString& command )
     myEditor->execAndWait( command );
 }
 
+bool PythonConsole::isSync() const
+{
+  return myEditor->isSync();
+}
+
+void PythonConsole::setIsSync( const bool s )
+{
+  myEditor->setIsSync( s );
+}
+
 /*!
   \brief Change the python console's font.
   \param f - new font

diff --git a/src/PyConsole/PyConsole_Console.h b/src/PyConsole/PyConsole_Console.h
index 3d07a595e4dad22dbbe8449bc56fbd3e0aa67541..b25f4d1913f0ebf128129a50489c4517d3751844 100644 (file)
--- a/src/PyConsole/PyConsole_Console.h
+++ b/src/PyConsole/PyConsole_Console.h
@@ -56,6 +56,9 @@ public:
   QFont          font() const;
   virtual void   setFont( const QFont& );
 
+  bool           isSync() const;
+  void           setIsSync( const bool );
+
   void           exec( const QString& command );
   void           execAndWait( const QString& command );
 
@@ -74,6 +77,4 @@ private:
   QMap<int, QAction*> myActions;
 };
 
-
-
 #endif

diff --git a/src/PyConsole/PyConsole_Editor.cxx b/src/PyConsole/PyConsole_Editor.cxx
index c5a371c86cf4cc6314b1c160645b9f8374d4b443..23268097ea5860b5ca0f44fef5ef7f1e7c455865 100644 (file)
--- a/src/PyConsole/PyConsole_Editor.cxx
+++ b/src/PyConsole/PyConsole_Editor.cxx
@@ -131,8 +131,8 @@ public:
     \param sync        if True the request is processed synchronously 
   */
   ExecCommand( PyInterp_base*          theInterp, 
-              const char*             theCommand,
-              PyConsole_Editor* theListener, 
+              const QString&          theCommand,
+              PyConsole_Editor*       theListener, 
               bool                    sync = false )
     : PyInterp_LockRequest( theInterp, theListener, sync ),
       myCommand( theCommand ), myState( PyInterp_Event::OK )
@@ -190,11 +190,12 @@ private:
   \param theParent parent widget
 */
 PyConsole_Editor::PyConsole_Editor( PyInterp_base* theInterp, 
-                                               QWidget*       theParent )
-  : QTextEdit( theParent ),
-    myInterp( 0 ),
-    myCmdInHistory( -1 ),
-    myEventLoop( 0 )
+                                   QWidget*       theParent )
+: QTextEdit( theParent ),
+  myInterp( 0 ),
+  myCmdInHistory( -1 ),
+  myEventLoop( 0 ),
+  myIsSync( false )
 {
   QString fntSet( "" );
   QFont aFont = SUIT_Tools::stringToFont( fntSet );
@@ -219,6 +220,16 @@ PyConsole_Editor::~PyConsole_Editor()
 {
 }
 
+bool PyConsole_Editor::isSync() const
+{
+  return myIsSync;
+}
+
+void PyConsole_Editor::setIsSync( const bool s )
+{
+  myIsSync = s;
+}
+
 /*!
   \brief Put the string \a str to the python editor.
   \param str string to be put in the command line of the editor
@@ -274,9 +285,12 @@ void PyConsole_Editor::exec( const QString& command )
   
   // post a request to execute Python command;
   // editor will be informed via a custom event that execution has been completed
-  PyInterp_Dispatcher::Get()->Exec( new ExecCommand( myInterp, 
-                                                    cmd.toLatin1(), 
-                                                    this ) );
+  PyInterp_Dispatcher::Get()->Exec( createRequest( cmd ) );
+}
+
+PyInterp_Request* PyConsole_Editor::createRequest( const QString& cmd )
+{
+  return new ExecCommand( myInterp, cmd, this, isSync() );
 }
 
 /*!
@@ -327,9 +341,7 @@ void PyConsole_Editor::handleReturn()
   
   // post a request to execute Python command;
   // editor will be informed via a custom event that execution has been completed
-  PyInterp_Dispatcher::Get()->Exec( new ExecCommand( myInterp, 
-                                                    myCommandBuffer.toLatin1(), 
-                                                    this ) );
+  PyInterp_Dispatcher::Get()->Exec( createRequest( myCommandBuffer ) );
 }
 
 /*!
@@ -837,48 +849,51 @@ void PyConsole_Editor::keyPressEvent( QKeyEvent* event )
 */
 void PyConsole_Editor::customEvent( QEvent* event )
 {
-  switch( event->type() ) {
+  switch( event->type() )
+  {
   case PyInterp_Event::OK:
   case PyInterp_Event::ERROR:
+  {
+    PyInterp_Event* pe = dynamic_cast<PyInterp_Event*>( event );
+    if ( pe )
     {
-      PyInterp_Event* pe = dynamic_cast<PyInterp_Event*>( event );
-      if ( pe ){
-       ExecCommand* ec = dynamic_cast<ExecCommand*>( pe->GetRequest() );
-       if ( ec ) {
-         // The next line has appeared dangerous in case if
-         // Python command execution has produced very large output.
-         // A more clever approach is needed...
-         // print python output
-         addText( ec->myOutput, true );
-         addText( ec->myError );
-       }
+      ExecCommand* ec = dynamic_cast<ExecCommand*>( pe->GetRequest() );
+      if ( ec )
+      {
+       // The next line has appeared dangerous in case if
+       // Python command execution has produced very large output.
+       // A more clever approach is needed...
+       // print python output
+       addText( ec->myOutput, true );
+       addText( ec->myError );
       }
-      // clear command buffer
-      myCommandBuffer.truncate( 0 );
-      // set "ready" prompt
-      myPrompt = READY_PROMPT;
-      addText( myPrompt );
-      // unset busy cursor
-      unsetCursor();
-      // stop event loop (if running)
-      if( myEventLoop )
-       myEventLoop->exit();
-      break;
     }
+    // clear command buffer
+    myCommandBuffer.truncate( 0 );
+    // set "ready" prompt
+    myPrompt = READY_PROMPT;
+    addText( myPrompt );
+    // unset busy cursor
+    unsetCursor();
+    // stop event loop (if running)
+    if ( myEventLoop )
+      myEventLoop->exit();
+    break;
+  }
   case PyInterp_Event::INCOMPLETE:
-    {
-      // extend command buffer (multi-line command)
-      myCommandBuffer.append( "\n" );
-      // set "dot" prompt
-      myPrompt = DOTS_PROMPT;
-      addText( myPrompt, true );
-      // unset busy cursor
-      unsetCursor();
-      // stop event loop (if running)
-      if( myEventLoop )
-       myEventLoop->exit();
-      break;
-    }
+  {
+    // extend command buffer (multi-line command)
+    myCommandBuffer.append( "\n" );
+    // set "dot" prompt
+    myPrompt = DOTS_PROMPT;
+    addText( myPrompt, true );
+    // unset busy cursor
+    unsetCursor();
+    // stop event loop (if running)
+    if ( myEventLoop )
+      myEventLoop->exit();
+    break;
+  }
   default:
     QTextEdit::customEvent( event );
   }
@@ -888,7 +903,8 @@ void PyConsole_Editor::customEvent( QEvent* event )
   // unset history browsing mode
   myCmdInHistory = -1;
 
-  if ( (int)event->type() == (int)PyInterp_Event::OK && myQueue.count() > 0 ) {
+  if ( (int)event->type() == (int)PyInterp_Event::OK && myQueue.count() > 0 )
+  {
     // process the next sheduled command from the queue (if there is any)
     QString nextcmd = myQueue[0];
     myQueue.pop_front();

diff --git a/src/PyConsole/PyConsole_Editor.h b/src/PyConsole/PyConsole_Editor.h
index d46c3920c51a920b244a69d48e6a8b995019fdbb..12deee059f8ecd2cbdc2c4d9753d1f4051017e12 100644 (file)
--- a/src/PyConsole/PyConsole_Editor.h
+++ b/src/PyConsole/PyConsole_Editor.h
@@ -33,6 +33,7 @@
 class QMenu;
 class QEventLoop;
 class PyConsole_Interp;
+class PyInterp_Request;
 
 class PYCONSOLE_EXPORT PyConsole_Editor : public QTextEdit
 {
@@ -48,11 +49,16 @@ public:
   virtual void   exec( const QString& command );
   void           execAndWait( const QString& command );
 
+  bool           isSync() const;
+  void           setIsSync( const bool );
+
 protected:
   virtual void   dropEvent( QDropEvent* event );
   virtual void   mouseReleaseEvent( QMouseEvent* event );
   virtual void   keyPressEvent ( QKeyEvent* event);
   virtual void   customEvent( QEvent* event);
+
+  virtual PyInterp_Request* createRequest( const QString& );
   
 public slots:
   void           cut();
@@ -72,6 +78,7 @@ private:
   QEventLoop*    myEventLoop;        //!< internal event loop
   QString        myBanner;           //!< current banner
   QStringList    myQueue;            //!< python commands queue
+  bool           myIsSync;
 };
 
 #endif

diff --git a/src/PyInterp/PyInterp_Dispatcher.cxx b/src/PyInterp/PyInterp_Dispatcher.cxx
index 4a2f3d4ebee93c9b5a6639a33c51ff146f0b4343..917298417922d03ea1b154a5c50269944b34fe4e 100755 (executable)
--- a/src/PyInterp/PyInterp_Dispatcher.cxx
+++ b/src/PyInterp/PyInterp_Dispatcher.cxx
@@ -39,11 +39,16 @@ void PyInterp_Request::process()
 {
   safeExecute();
 
-  myMutex.lock();
-  //if ( !IsSync() && getListener() && getEvent() )
-  if ( getListener() && getEvent() )
-    postEvent();
-  myMutex.unlock();
+  bool isSync = IsSync();
+
+  if ( !isSync )
+    myMutex.lock();
+
+  if ( listener() )
+    processEvent( listener() );
+
+  if ( !isSync )
+    myMutex.unlock();
 }
 
 void PyInterp_Request::safeExecute()
@@ -64,18 +69,22 @@ QEvent* PyInterp_Request::createEvent() const
   return new PyInterp_Event( PyInterp_Event::NOTIFY, (PyInterp_Request*)this );
 }
 
-QEvent* PyInterp_Request::getEvent()
+void PyInterp_Request::processEvent( QObject* o )
 {
-  //if ( !myEvent && !IsSync() )
-  if ( !myEvent )
-    myEvent = createEvent();
-  return myEvent;
-}
+  if ( !o )
+    return;
 
-void PyInterp_Request::postEvent()
-{
-//  MESSAGE("*** PyInterp_Request::postEvent(): for Qt 3.3.3")
-  QCoreApplication::postEvent( getListener(), getEvent() );
+  QEvent* e = createEvent();
+  if ( !e )
+    return;
+
+  if ( !IsSync() )
+    QCoreApplication::postEvent( o, e );
+  else
+  {
+    QCoreApplication::sendEvent( o, e );
+    delete e;
+  }
 }
 
 void PyInterp_Request::setListener( QObject* o )
@@ -143,11 +152,12 @@ void PyInterp_Dispatcher::Exec( PyInterp_Request* theRequest )
   //if ( theRequest->IsSync() && !IsBusy() ) // synchronous processing - nothing is done if dispatcher is busy!
   if ( theRequest->IsSync() ) // synchronous processing - nothing is done if dispatcher is busy!
     processRequest( theRequest );
-  else { // asynchronous processing
+  else // asynchronous processing
+  {
     myQueueMutex.lock();
     myQueue.push_back( theRequest );
-    if ( theRequest->getListener() )
-      QObject::connect( theRequest->getListener(), SIGNAL( destroyed( QObject* ) ), myWatcher, SLOT( onDestroyed( QObject* ) ) );
+    if ( theRequest->listener() )
+      QObject::connect( theRequest->listener(), SIGNAL( destroyed( QObject* ) ), myWatcher, SLOT( onDestroyed( QObject* ) ) );
     myQueueMutex.unlock();  
 
     if ( !IsBusy() )
@@ -197,8 +207,10 @@ void PyInterp_Dispatcher::objectDestroyed( const QObject* o )
   // prepare for modification of the queue
   myQueueMutex.lock();
 
-  for ( std::list<RequestPtr>::iterator it = myQueue.begin(); it != myQueue.end(); ++it ){
-    if ( o == (*it)->getListener() ){
+  for ( std::list<RequestPtr>::iterator it = myQueue.begin(); it != myQueue.end(); ++it )
+  {
+    if ( o == (*it)->listener() )
+    {
       (*it)->setListener( 0 ); // to prevent event posting
       it = myQueue.erase( it );
     }
@@ -206,4 +218,3 @@ void PyInterp_Dispatcher::objectDestroyed( const QObject* o )
 
   myQueueMutex.unlock();
 }
-

diff --git a/src/PyInterp/PyInterp_Dispatcher.h b/src/PyInterp/PyInterp_Dispatcher.h
index cfa43089eb3e4eb68efca3d8099c6936e9548823..6f6240794dc8e66fdc8bfc3eb3ec270eac37af68 100755 (executable)
--- a/src/PyInterp/PyInterp_Dispatcher.h
+++ b/src/PyInterp/PyInterp_Dispatcher.h
@@ -48,12 +48,12 @@ class PYINTERP_EXPORT PyInterp_Request
   PyInterp_Request( const PyInterp_Request& );
 
 protected:
-  virtual         ~PyInterp_Request() {}; 
+  virtual ~PyInterp_Request() {};
   // protected destructor - to control deletion of requests
 
 public:
   PyInterp_Request( QObject* listener, bool sync = false )
-    : myIsSync( sync ), myListener( listener ), myEvent( 0 ) {};
+    : myIsSync( sync ), myListener( listener ) {};
 
   static void     Destroy( PyInterp_Request* );
   // Deletes a request
@@ -71,18 +71,17 @@ protected:
   virtual QEvent* createEvent() const;
   // This method can be overridden to customize notification event creation
 
+  virtual void    processEvent( QObject* );
+
 private:
   void            process();
-  QObject*        getListener() const { return myListener; }
+  QObject*        listener() const { return myListener; }
   void            setListener( QObject* );
-  QEvent*         getEvent();
-  void            postEvent();
 
 private:
+  QMutex          myMutex;
   bool            myIsSync;
   QObject*        myListener;
-  QEvent*         myEvent;
-  QMutex          myMutex;
 };
 
 class PYINTERP_EXPORT PyInterp_LockRequest : public PyInterp_Request