From 29a0a7ec53d02adb7839609107f553d2eeea419b Mon Sep 17 00:00:00 2001
From: vsr <vsr@opencascade.com>
Date: Thu, 24 May 2007 11:48:37 +0000
Subject: [PATCH] Porting to Qt 4

---
 src/Event/Event.h                             |  35 ++--
 src/Event/Event.pro                           |   6 +-
 src/Event/Makefile.am                         |   4 +-
 src/Event/SALOME_Event.cxx                    | 162 ++++++++++++---
 .../{SALOME_Event.hxx => SALOME_Event.h}      | 186 ++++++------------
 5 files changed, 209 insertions(+), 184 deletions(-)
 rename src/Event/{SALOME_Event.hxx => SALOME_Event.h} (51%)
 mode change 100755 => 100644

diff --git a/src/Event/Event.h b/src/Event/Event.h
index 472e385bc..9e2abddc8 100755
--- a/src/Event/Event.h
+++ b/src/Event/Event.h
@@ -16,35 +16,22 @@
 // 
 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 //
-//
-//
-// File:      SalomeApp.h
-// Created:   November, 2004
-// Author:    OCC team
-// Copyright (C) CEA 2004
 
+#if !defined ( EVENT_H )
+#define EVENT_H
 
-// The following ifdef block is the standard way of creating macros which make exporting 
-// from a DLL simpler. All files within this DLL are compiled with the SalomeApp_EXPORTS
-// symbol defined on the command line. this symbol should not be defined on any project
-// that uses this DLL. This way any other project whose source files include this file see 
-// SalomeApp_API functions as being imported from a DLL, wheras this DLL sees symbols
-// defined with this macro as being exported.
 #ifdef WIN32
-
-#ifdef EVENT_EXPORTS
-#define EVENT_EXPORT __declspec(dllexport)
-#else
-#define EVENT_EXPORT __declspec(dllimport)
-#endif
-
-#else
-#define EVENT_EXPORT
-#endif               //WIN32
-
-#define APP_VERSION "0.1"
+#  ifdef EVENT_EXPORTS
+#    define EVENT_EXPORT __declspec(dllexport)
+#  else
+#    define EVENT_EXPORT __declspec(dllimport)
+#  endif
+#else               //WIN32
+#  define EVENT_EXPORT
+#endif              //WIN32
 
 #if defined WIN32
 #pragma warning ( disable: 4251 )
 #endif
 
+#endif // EVENT_H
diff --git a/src/Event/Event.pro b/src/Event/Event.pro
index 4361449c1..b28d7bdca 100644
--- a/src/Event/Event.pro
+++ b/src/Event/Event.pro
@@ -4,9 +4,7 @@ DESTDIR = ../../lib
 MOC_DIR = ../../moc
 OBJECTS_DIR = ../../obj/$$TARGET
 
-KERNEL_CXXFLAGS = $$(KERNEL_ROOT_DIR)/include/salome
-
-INCLUDEPATH += ../../include $${KERNEL_CXXFLAGS}
+INCLUDEPATH += ../../include
 LIBS += 
 
 CONFIG -= debug release debug_and_release
@@ -16,7 +14,7 @@ win32:DEFINES += WIN32
 DEFINES += EVENT_EXPORTS
 
 HEADERS  = Event.h
-HEADERS += SALOME_Event.hxx
+HEADERS += SALOME_Event.h
 
 SOURCES  = SALOME_Event.cxx
 
diff --git a/src/Event/Makefile.am b/src/Event/Makefile.am
index c9948969b..c848832b1 100755
--- a/src/Event/Makefile.am
+++ b/src/Event/Makefile.am
@@ -32,11 +32,11 @@ lib_LTLIBRARIES = libEvent.la
 
 salomeinclude_HEADERS= \
 	Event.h \
-	SALOME_Event.hxx 
+	SALOME_Event.h 
 
 dist_libEvent_la_SOURCES = SALOME_Event.cxx 
 
-libEvent_la_CPPFLAGS=$(QT_INCLUDES) @KERNEL_CXXFLAGS@
+libEvent_la_CPPFLAGS=$(QT_INCLUDES)
 libEvent_la_LDFLAGS=$(QT_MT_LIBS)
 
 
diff --git a/src/Event/SALOME_Event.cxx b/src/Event/SALOME_Event.cxx
index f50cdc9c4..7faf45a7d 100755
--- a/src/Event/SALOME_Event.cxx
+++ b/src/Event/SALOME_Event.cxx
@@ -19,60 +19,118 @@
 // 
 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 //
-//
-//
 //  File   : SALOME_Event.cxx
 //  Author : Sergey ANIKIN
-//  Module : KERNEL
-//  $Header$
-
-#include "SALOME_Event.hxx"
 
-//#include "utilities.h"
+#include "SALOME_Event.h"
 
 #include <QSemaphore>
 #include <QApplication>
 
 // asv 21.02.05 : introducing multi-platform approach of thread comparison
-// on Unix using pthread_t type for storing ThreadId
-// on Win32 using integer type for storing ThreadId
+// - on Unix using pthread_t type for storing ThreadId
+// - on Win32 using integer type for storing ThreadId
 // NOT using integer ThreadId on both Unix and Win32 because (from documentation):
 // "...Do not allow your program to rely on the internal structure or size of the pthread_t..."
 
 #ifdef WIN32
 #include <windows.h>
-
 static DWORD myThread;
 #else
 #include <pthread.h>
-
 static pthread_t myThread;
 #endif
 
+/*!
+  \class SALOME_CustomEvent
+  \brief Generic event class for user-defined events
+  
+  This class contains a generic void* data member that may be used
+  for transferring event-specific data to the receiver.
+
+  \warning The internal data is not destroyed by the class destructor.
+*/
+
+/*!
+  \brief Constructor.
+  \param type event type
+*/
 SALOME_CustomEvent::SALOME_CustomEvent( int type )
-  : QEvent( (QEvent::Type)type ), d( 0 )
+: QEvent( (QEvent::Type)type ), d( 0 )
 {
 }
 
-SALOME_CustomEvent::SALOME_CustomEvent( QEvent::Type type, void *data )
-  : QEvent( type ), d( data )
+/*!
+  \brief Constructor.
+  \param type event type
+  \param data custom data
+*/
+SALOME_CustomEvent::SALOME_CustomEvent( QEvent::Type type, void* data )
+: QEvent( type ), d( data )
 {
 }
 
-void * SALOME_CustomEvent::data() const
+/*!
+  \brief Get custom data.
+  \return pointer to the internal data
+*/
+void* SALOME_CustomEvent::data() const
 {
   return d;
 }
 
+/*!
+  \brief Set custom data.
+  \param data pointer to the internal data
+*/
 void SALOME_CustomEvent::setData( void* data )
 {
   d = data;
 }
 
+/*!
+  \class SALOME_Event
+  \brief The class which encapsulates data and functionality required for 
+         posting component-specific events to perform arbitrary operations 
+	 in the main GUI thread. 
+
+  SALOME_Event objects can be posted by any thread belonging to the GUI process.
+  
+  It is necessary to derive a custom event class from SALOME_Event and 
+  re-implement virtual Execute() method. This method should actually perform 
+  the desirable operation. To pass all the required data to Execute() and 
+  store a return value, arbitrary data fields can be added to the custom 
+  event class. There is no need to protect such fields with a mutex, for only
+  one thread working with a SALOME_Event object is active at any moment.
+  
+  Usage:
+  - Create SALOME_Event. Components can derive their own event class from 
+  SALOME_Event in order to pass custom data to the event handler.
+  - Call process() method to post the event. After process() execution
+  it is possible to examine fields of your custom event object.
+  - Perform delete operator on the event to wake up the desktop (you can also 
+  set <autoRelease>  parameter to \c true to automatically wake up desktop after 
+  process().
+  
+  The method processed() is used by the desktop to signal that event processing 
+  has been completed.
+
+  To make all this work, it is necessary to call static method GetSessionThread()
+  during the application initialization, i.e. from main() function.
+  It is important to call this method from the primary application thread.
+
+  Caveats: 
+  - there are no.
+*/
+
+//! Total number of semaphore resources
 const int NumberOfResources = 2;
 
 /*!
-  \return thread id
+  \brief Initialize event mechanism.
+
+  This function sets up the main application thread. It should be called
+  during the application initialization, i.e. main() function.
 */
 void SALOME_Event::GetSessionThread(){
 #ifdef WIN32
@@ -83,7 +141,8 @@ void SALOME_Event::GetSessionThread(){
 }
 
 /*!
-  \return true if it is session thread
+  \brief Check if the processing is in the main application thread.
+  \return \c true if this method is called from the main application thread
 */
 bool SALOME_Event::IsSessionThread(){
   bool aResult = false;
@@ -92,48 +151,93 @@ bool SALOME_Event::IsSessionThread(){
 #else
   aResult = myThread == pthread_self();
 #endif
-//  if(MYDEBUG) INFOS("IsSessionThread() - "<<aResult);
   return aResult;
 }
 
-
 /*!
-  Constructor
+  \brief Constructor.
 */
 SALOME_Event::SALOME_Event(){
-//  if(MYDEBUG) MESSAGE( "SALOME_Event::SALOME_Event(): this = "<<this );
   // Prepare the semaphore 
   mySemaphore = new QSemaphore( NumberOfResources );
   mySemaphore->acquire( NumberOfResources );
 }
 
 /*!
-  Destructor
+  \brief Destructor.
 */
 SALOME_Event::~SALOME_Event(){
-//  if(MYDEBUG) MESSAGE( "SALOME_Event::~SALOME_Event(): this = "<<this );
   if ( mySemaphore->available() < NumberOfResources )
     mySemaphore->release( NumberOfResources - mySemaphore->available() );
   delete mySemaphore;
 }
 
 /*!
-  Posts the event and optionally waits for its completion
+  \brief Post the event and wait for its completion.
+  \sa processed()
 */
 void SALOME_Event::process()
 {
   QApplication::postEvent( qApp, new SALOME_CustomEvent( SALOME_EVENT, (void*)this ) );
-//  if(MYDEBUG) MESSAGE( "SALOME_Event::process(): this = "<<this<<", mySemaphore->acquire( 1 )" );
   mySemaphore->acquire( 1 );
-//  if(MYDEBUG) MESSAGE( "SALOME_Event::process(): this = "<<this<<" - COMPLETED" );
 }
 
 /*!
-  Signals that this event has been processed
+  \brief Use this method to signal that this event has been processed.
 */
 void SALOME_Event::processed()
 {
-//  if(MYDEBUG) MESSAGE( "SALOME_Event::processed(): this = "<<this );
-  // process() takes control over mySemaphore after the next line is executed
   mySemaphore->release( 1 );
 }
+
+/*!
+  \fn virtual void SALOME_Event::Execute();
+  \brief This method should be redefined in the successor classes
+         to do real work.
+*/
+  
+/*!
+  \class TMemFunEvent
+  \brief Template class for event which calls the function
+  without arguments and returning result.
+*/
+
+/*!
+  \class TVoidMemFunEvent
+  \brief Template class for event which calls the function
+  without arguments and without return value.
+*/
+
+/*!
+  \class TMemFun1ArgEvent
+  \brief Template class for event which calls the function
+  with one argument and returning result.
+*/
+
+/*!
+  \class TVoidMemFun1ArgEvent
+  \brief Template class for event which calls the function
+  with one argument and without return value.
+*/
+
+/*!
+  \class TMemFun2ArgEvent
+  \brief Template class for event which calls the function
+  with two arguments and returning result.
+*/
+
+/*!
+  \class TVoidMemFun2ArgEvent
+  \brief Template class for event which calls the function
+  with two arguments and without return value.
+*/
+
+/*!
+  \fn ProcessEvent
+  \brief Template function for processing events with return value.
+*/
+
+/*!
+  \fn ProcessVoidEvent
+  \brief Template function for processing events without return value.
+*/
diff --git a/src/Event/SALOME_Event.hxx b/src/Event/SALOME_Event.h
old mode 100755
new mode 100644
similarity index 51%
rename from src/Event/SALOME_Event.hxx
rename to src/Event/SALOME_Event.h
index 424eb97df..859d62b93
--- a/src/Event/SALOME_Event.hxx
+++ b/src/Event/SALOME_Event.h
@@ -19,102 +19,58 @@
 // 
 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 //
-//
-//
-//  File   : SALOME_Event.hxx
+//  File   : SALOME_Event.h
 //  Author : Sergey ANIKIN
-//  Module : KERNEL
-//  $Header$
 
+#ifndef SALOME_EVENT_H
+#define SALOME_EVENT_H
 
-#ifndef SALOME_Event_HeaderFile
-#define SALOME_Event_HeaderFile
+#include <Event.h>
 
 #include <QEvent>
 
-#include <Event.h>
-
+//! SALOME custom event type
 #define SALOME_EVENT QEvent::Type( QEvent::User + 10000 )
 
-/*!
-  \class SALOME_CustomEvent
-  *  Description:
-  *  It is a generic event class for user-defined events.
-  *  This class contains a generic void* data member that may be used
-  *  for transferring event-specific data to the receiver.
-*/
-class EVENT_EXPORT SALOME_CustomEvent : public QEvent {
+class EVENT_EXPORT SALOME_CustomEvent : public QEvent
+{
 public:
   SALOME_CustomEvent( int type );
-  SALOME_CustomEvent( QEvent::Type type, void *data );
+  SALOME_CustomEvent( QEvent::Type type, void* data );
 
-  void *data() const;
-  void setData( void* data );
+  void* data() const;
+  void  setData( void* data );
 
 private:
-  void *d;
+  void *d;   //!< internal data
 };
 
 class QSemaphore;
 
-/*!
- *  \class SALOME_Event
- *  Description: 
- *  This class encapsulates data and functionality required for 
- *  posting component-specific events to perform arbitrary operations in main GUI thread. 
- *  SALOME_Event objects can be posted by any thread belonging to the GUI process.
- *
- *  It is necessary to derive a custom event class from SALOME_Event and 
- *  re-implement virtual Execute() method. This method should actually perform 
- *  the desirable operation. To pass all the required data to Execute() and store a return value,
- *  arbitrary data fields can be added to the custom event class. There is 
- *  no need to protect such fields with a mutex, for only one thread working with
- *  a SALOME_Event object is active at any moment.
- *
- *  Usage:
- *  - create SALOME_Event. 
- *    Components can derive their own event class from SALOME_Event
- *    in order to pass custom data to the event handler.
- *  - call process() method to post the event. After process() execution
- *    it is possible to examine fields of your custom event object.
- *  - perform delete operator on the event to wake up the desktop (you can also set <autoRelease>
- *    parameter to TRUE to automatically wake up desktop after process()
- * 
- *  processed() method is used by the desktop to signal that event processing 
- *  has been completed.
- *  
- *  Caveats: 
- *    There is no.
- */
-
-class EVENT_EXPORT SALOME_Event{
+class EVENT_EXPORT SALOME_Event
+{
 public:
   SALOME_Event();
   virtual ~SALOME_Event();
 
-  // To do real work
-  virtual void Execute() = 0;
+  virtual void    Execute() = 0;
 
-  static bool IsSessionThread();
-  void process();
+  static bool     IsSessionThread();
+  void            process();
 
 protected:
-  void processed();
-  friend class SalomeApp_EventFilter;
+  void            processed();
+  friend class    SalomeApp_EventFilter;
 
-  static void GetSessionThread();
-  friend int main(int, char **);
+  static void     GetSessionThread();
+  friend int      main(int, char **);
 
 private:
-  QSemaphore* mySemaphore;
+  QSemaphore*     mySemaphore;     //!< internal semaphore
 };
 
-
-/*!
-  \class TMemFunEvent
-  \brief Template class for member function
-*/
-template<class TObject, typename TRes> class /*EVENT_EXPORT */TMemFunEvent: public SALOME_Event{
+template<class TObject, typename TRes> class TMemFunEvent : public SALOME_Event
+{
 public:
   typedef TRes TResult;
   TResult myResult;
@@ -125,27 +81,25 @@ public:
     myAction(theAction),
     myResult(theResult)
   {}
-  virtual void Execute(){
+  virtual void Execute()
+  {
     myResult = (myObject->*myAction)();
   }
 private:
   TObject* myObject;
-  TAction myAction;
+  TAction  myAction;
 };
 
-
-/*!
-  \class TVoidMemFunEvent
-  \brief Template class for member function
-*/
-template<class TObject> class /*EVENT_EXPORT */TVoidMemFunEvent: public SALOME_Event{
+template<class TObject> class TVoidMemFunEvent : public SALOME_Event
+{
 public:
   typedef void (TObject::* TAction)();
   TVoidMemFunEvent(TObject* theObject, TAction theAction):
     myObject(theObject),
     myAction(theAction)
   {}
-  virtual void Execute(){
+  virtual void Execute()
+  {
     (myObject->*myAction)();
   }
 private:
@@ -153,13 +107,9 @@ private:
   TAction myAction;
 };
 
-
-/*!
-  \class TMemFun1ArgEvent
-  \brief Template for member function with one argument
-*/
-template<class TObject, typename TRes, typename TArg, typename TStoreArg = TArg> class/* EVENT_EXPORT */TMemFun1ArgEvent:
-public SALOME_Event{
+template<class TObject, typename TRes, typename TArg, typename TStoreArg = TArg> 
+class TMemFun1ArgEvent : public SALOME_Event
+{
 public:
   typedef TRes TResult;
   TResult myResult;
@@ -171,7 +121,8 @@ public:
     myResult(theResult),
     myArg(theArg)
   {}
-  virtual void Execute(){
+  virtual void Execute()
+  {
     myResult = (myObject->*myAction)(myArg);
   }
 private:
@@ -180,12 +131,9 @@ private:
   TStoreArg myArg;
 };
 
-
-/*!
-  \class TVoidMemFun1ArgEvent
-  \brief Template for member function with one argument
-*/
-template<class TObject, typename TArg, typename TStoreArg = TArg> class /*EVENT_EXPORT */TVoidMemFun1ArgEvent: public SALOME_Event{
+template<class TObject, typename TArg, typename TStoreArg = TArg> 
+class TVoidMemFun1ArgEvent : public SALOME_Event
+{
 public:
   typedef void (TObject::* TAction)(TArg);
   TVoidMemFun1ArgEvent(TObject* theObject, TAction theAction, TArg theArg):
@@ -193,7 +141,8 @@ public:
     myAction(theAction),
     myArg(theArg)
   {}
-  virtual void Execute(){
+  virtual void Execute()
+  {
     (myObject->*myAction)(myArg);
   }
 private:
@@ -202,13 +151,9 @@ private:
   TStoreArg myArg;
 };
 
-
-/*!
-  \class TMemFun2ArgEvent
-  \brief Template for member function with two arguments
-*/
-template<class TObject, typename TRes, typename TArg, typename TArg1, typename TStoreArg = TArg, typename TStoreArg1 = TArg1> class
-/*EVENT_EXPORT */TMemFun2ArgEvent: public SALOME_Event{
+template<class TObject, typename TRes, typename TArg, typename TArg1, typename TStoreArg = TArg, typename TStoreArg1 = TArg1>
+class TMemFun2ArgEvent: public SALOME_Event
+{
 public:
   typedef TRes TResult;
   TResult myResult;
@@ -222,7 +167,8 @@ public:
     myArg(theArg),
     myArg1(theArg1)
   {}
-  virtual void Execute(){
+  virtual void Execute()
+  {
     myResult = (myObject->*myAction)(myArg,myArg1);
   }
 private:
@@ -232,13 +178,9 @@ private:
   TStoreArg1 myArg1;
 };
 
-
-/*!
-  \class TVoidMemFun2ArgEvent
-  \brief Template for member function with two arguments
-*/
-template<class TObject, typename TArg, typename TArg1, typename TStoreArg = TArg, typename TStoreArg1 = TArg1> class
-/*EVENT_EXPORT*/ TVoidMemFun2ArgEvent: public SALOME_Event{
+template<class TObject, typename TArg, typename TArg1, typename TStoreArg = TArg, typename TStoreArg1 = TArg1>
+class TVoidMemFun2ArgEvent : public SALOME_Event
+{
 public:
   typedef void (TObject::* TAction)(TArg,TArg1);
   TVoidMemFun2ArgEvent(TObject* theObject, TAction theAction, TArg theArg, TArg1 theArg1):
@@ -247,7 +189,8 @@ public:
     myArg(theArg),
     myArg1(theArg1)
   {}
-  virtual void Execute(){
+  virtual void Execute()
+  {
     (myObject->*myAction)(myArg,myArg1);
   }
 private:
@@ -257,17 +200,14 @@ private:
   TStoreArg1 myArg1;
 };
 
-
-/*!
-  \fn ProcessEvent
-  \brief Template function for processing events with result returing
-*/
-template<class TEvent> inline typename TEvent::TResult ProcessEvent(TEvent* theEvent){
+template<class TEvent> inline typename TEvent::TResult ProcessEvent(TEvent* theEvent)
+{
   typename TEvent::TResult aResult;
-  if(SALOME_Event::IsSessionThread()){
+  if(SALOME_Event::IsSessionThread()) {
     theEvent->Execute();
     aResult = theEvent->myResult;
-  }else{
+  }
+  else {
     theEvent->process();
     aResult = theEvent->myResult;
   }
@@ -275,19 +215,15 @@ template<class TEvent> inline typename TEvent::TResult ProcessEvent(TEvent* theE
   return aResult;
 }
 
-
-/*!
-  \fn ProcessEvent
-  \brief Template function for processing events without result
-*/
-inline void ProcessVoidEvent(SALOME_Event* theEvent){
-  if(SALOME_Event::IsSessionThread()){
+inline void ProcessVoidEvent(SALOME_Event* theEvent)
+{
+  if(SALOME_Event::IsSessionThread()) {
     theEvent->Execute();
-  }else{
+  }
+  else {
     theEvent->process();
   }
   delete theEvent;
 }
 
-
-#endif
+#endif // SALOME_EVENT_H
-- 
2.39.2