--- /dev/null
+# -* Makefile *-
+#
+# Author : C. Caremoli
+# Date : 10/10/2003
+# $Header$
+#
+
+# source path
+top_srcdir=@top_srcdir@
+top_builddir=.
+srcdir=@srcdir@
+VPATH=.:@srcdir@:@top_srcdir@/bin:@top_srcdir@/resources:./bin:@top_srcdir@/idl
+
+@COMMENCE@
+
+SUBDIRS = idl src
+
+RESOURCES_FILES = PYHELLOCatalog.xml PYHELLO.png PYHELLO_en.xml \
+ ExecPYHELLO.png
+
+BIN_SCRIPT= VERSION runAppli runSalome.py
+
+# copy header files in common directory
+ifeq ($(HAVE_SSTREAM),yes)
+ include_list=include/salome/SALOMEconfig.h
+else
+ include_list=include/salome/SALOMEconfig.h include/salome/sstream
+endif
+
+inc: idl $(include_list)
+
+include/salome/SALOMEconfig.h: salome_adm/unix/SALOMEconfig.ref
+ -$(RM) $@
+ $(LN_S) ../../$< $@
+
+# test if SALOMEconfig.h has changed (contents)
+salome_adm/unix/SALOMEconfig.ref: salome_adm/unix/SALOMEconfig.h
+ @if ! [ -a $@ ]; then \
+ cp -p $< $@; \
+ fi; \
+ if ! cmp $< $@; then \
+ cp -p $< $@; \
+ fi; \
+
+include/salome/sstream: salome_adm/unix/sstream
+ -$(RM) $@
+ $(LN_S) ../../$< $@
+
+depend: depend_idl
+
+depend_idl:
+ (cd idl ; $(MAKE) $@) || exit 1
+
+# doc is already build : if you want to had documents, go manually to doc and run 'make doc'
+#doc:
+# (cd doc && $(MAKE) $@) || exit 1
+
+install-end:
+# finish libtool install
+# @$(LT) --mode=finish $(libdir)
+
+install-include: $(include_list)
+ $(INSTALL) -d $(includedir)
+ @for f in X $(include_list); do \
+ if test $$f != X; then \
+ ($(INSTALL_DATA) $$f $(includedir)/. || exit 1); \
+ fi; \
+ done
+
+# install script in $(bindir) :
+install-bin: $(BIN_SCRIPT)
+ $(INSTALL) -d $(bindir)
+ $(INSTALL_PROGRAM) $^ $(bindir)
+
+uninstall: uninstall-idl
+
+uninstall-idl:
+ $(RM) $(idldir)/*.idl
+
+distclean: distclean-other
+
+distclean-other:
+ -$(RM) salome_adm/unix/*~ salome_adm/unix/*% salome_adm/unix/*.bak salome_adm/unix/*.new salome_adm/unix/*.old
+ -$(RM) salome_adm/unix/make_*
+ -$(RM) salome_adm/unix/depend salome_adm/unix/SALOMEconfig.h
+ -$(RM) config.cache config.log config.status
+
+@MODULE@
+
+install: install-bin install-include install-end
+
--- /dev/null
+# common directories to put headerfiles
+inc_builddir=$(top_builddir)/include/salome
+
+@SET_MAKE@
+SHELL=/bin/sh
+
+# header missing
+
+HAVE_SSTREAM=@HAVE_SSTREAM@
+
+
+LIBS=@LIBS@
+LDFLAGS=@LDFLAGS@ -L$(top_builddir)/lib/salome -Xlinker -rpath-link -Xlinker -L$(top_builddir)/lib/salome
+# add libstdc++ to link c++ library with libtool !
+LDFLAGS+= -lstdc++
+
+CP=@CP@
+
+# CPP
+
+CPP=@CPP@
+CXXCPP=@CXXCPP@
+CPPFLAGS=@CPPFLAGS@ -I$(inc_builddir) -I$(srcdir) -I.
+
+# C
+
+CC = @CC@
+CFLAGS = @CFLAGS@
+C_DEPEND_FLAG = @C_DEPEND_FLAG@
+
+# C++
+
+CXX = @CXX@
+CXXFLAGS = @CXXFLAGS@
+CXX_DEPEND_FLAG = @CXX_DEPEND_FLAG@
+
+# JAVA
+
+JAVA_INCLUDES = @JAVA_INCLUDES@
+JAVA_LIBS = @JAVA_LIBS@
+JAVA_LDPATH = @JAVA_LDPATH@
+
+# PYTHON
+
+PYTHON = @PYTHON@
+PYTHONHOME = @PYTHONHOME@
+PYTHON_INCLUDES = @PYTHON_INCLUDES@
+PYTHON_LIBS = @PYTHON_LIBS@
+PYTHON_VERSION = @PYTHON_VERSION@
+PYTHON_SITE = @PYTHON_SITE@
+PYTHON_SITE_INSTALL = @PYTHON_SITE_INSTALL@
+
+# QT
+
+QT_ROOT = @QT_ROOT@
+QT_INCLUDES = @QT_INCLUDES@
+QT_MT_INCLUDES = @QT_INCLUDES@ -DQT_THREAD_SUPPORT
+QT_LIBS = @QT_LIBS@
+QT_MT_LIBS = @QT_MT_LIBS@
+
+MOC = @MOC@
+UIC = @UIC@
+
+
+#QWT
+
+QWT_INCLUDES=@QWT_INCLUDES@
+QWT_LIBS=@QWT_LIBS@
+
+# SIP
+SIP = @SIP@
+SIP_INCLUDES = @SIP_INCLUDES@
+SIP_LIBS = @SIP_LIBS@
+
+# PYQT
+PYQT_SIPS = @PYQT_SIPS@
+PYQT_LIBS = @PYQT_LIBS@
+
+# openGL
+OGL_INCLUDES=@OGL_INCLUDES@
+OGL_LIBS=@OGL_LIBS@
+
+# VTK
+VTK_INCLUDES=@VTK_INCLUDES@
+VTK_LIBS=@VTK_LIBS@
+
+# HDF5
+
+HDF5_INCLUDES=@HDF5_INCLUDES@
+HDF5_LIBS=@HDF5_LIBS@
+HDF5_MT_LIBS=@HDF5_MT_LIBS@
+
+# MED2
+
+MED2_INCLUDES=@MED2_INCLUDES@
+MED2_LIBS=@MED2_LIBS@
+MED2_MT_LIBS=@MED2_MT_LIBS@
+
+# OpenCasCade
+
+OCC_INCLUDES=@CAS_CPPFLAGS@
+OCC_CXXFLAGS=@CAS_CXXFLAGS@
+
+OCC_KERNEL_LIBS=@CAS_KERNEL@
+OCC_OCAF_LIBS=@CAS_OCAF@
+OCC_VIEWER_LIBS=@CAS_VIEWER@
+OCC_MODELER_LIBS=@CAS_MODELER@
+OCC_DATAEXCHANGE_LIBS=@CAS_DATAEXCHANGE@
+OCC_LIBS=@CAS_LDFLAGS@
+
+# MPICH
+
+MPICH_INCLUDES=@MPICH_INCLUDES@
+MPICH_LIBS=@MPICH_LIBS@
+
+# Swig C++ Python
+
+SWIG = @SWIG@
+SWIG_FLAGS = @SWIG_FLAGS@ -I$(inc_builddir) -I$(srcdir) -I.
+
+# OMNIORB
+
+OMNIORB_ROOT = @OMNIORB_ROOT@
+OMNIORB_INCLUDES = @OMNIORB_INCLUDES@
+OMNIORB_LIBS = @OMNIORB_LIBS@
+OMNIORB_CXXFLAGS = @OMNIORB_CXXFLAGS@
+
+OMNIORB_IDL = @OMNIORB_IDL@
+OMNIORB_IDLCXXFLAGS = @OMNIORB_IDLCXXFLAGS@
+OMNIORB_IDLPYFLAGS = @OMNIORB_IDLPYFLAGS@ -I$(top_srcdir)/idl -I$(top_builddir)/idl -I$(KERNEL_ROOT_DIR)/idl/salome
+
+OMNIORB_IDL_CLN_H = @OMNIORB_IDL_CLN_H@
+OMNIORB_IDL_CLN_CXX = @OMNIORB_IDL_CLN_CXX@
+OMNIORB_IDL_CLN_OBJ = @OMNIORB_IDL_CLN_OBJ@
+
+OMNIORB_IDL_SRV_H = @OMNIORB_IDL_SRV_H@
+OMNIORB_IDL_SRV_CXX = @OMNIORB_IDL_SRV_CXX@
+OMNIORB_IDL_SRV_OBJ = @OMNIORB_IDL_SRV_OBJ@
+
+# Default ORB
+
+CORBA_ROOT = @CORBA_ROOT@
+CORBA_INCLUDES = @CORBA_INCLUDES@
+CORBA_LIBS = @CORBA_LIBS@
+CORBA_CXXFLAGS = @CORBA_CXXFLAGS@
+
+IDLCXXFLAGS = -bcxx @IDLCXXFLAGS@ -I$(top_srcdir)/idl -I$(top_builddir)/idl -I$(KERNEL_ROOT_DIR)/idl/salome
+IDLPYFLAGS = @IDLPYFLAGS@
+
+IDL = @IDL@
+
+IDL_CLN_H = @IDL_CLN_H@
+IDL_CLN_CXX = @IDL_CLN_CXX@
+IDL_CLN_OBJ = @IDL_CLN_OBJ@
+
+IDL_SRV_H = @IDL_SRV_H@
+IDL_SRV_CXX = @IDL_SRV_CXX@
+IDL_SRV_OBJ = @IDL_SRV_OBJ@
+
+CPPFLAGS+= $(CORBA_INCLUDES)
+CXXFLAGS+= $(CORBA_CXXFLAGS)
+
+# add corba libs when link salome application !
+#LDFLAGS+= $(CORBA_LIBS)
+LIBS+=$(CORBA_LIBS)
+
+## Shared libraries
+LT_STATIC_EXEC=@LT_STATIC_EXEC@
+DYNAMIC_DIRS=@DYNAMIC_DIRS@
+LT_LIB=libtool
+LT=$(top_builddir)/libtool
+LT_COMPILE=$(LT) --mode=compile $(CC)
+LT_LINK_LIB=$(LT_LIB) --mode=link $(CC) -rpath $(libdir)
+LT_LINK_EXE=$(LT) --mode=link $(CC) $(LT_STATIC_EXEC) -dlopen self -rpath $(bindir) $(DYNAMIC_DIRS)
+LT_RUN=$(LT) --mode=execute
+LT_INSTALL_PROG=$(LT) --mode=install $(INSTALL_PROGRAM)
+LT_INSTALL_LIB=$(LT) --mode=install $(INSTALL_DATA)
+LT_UNINSTALL=$(LT) --mode=uninstall $(RM)
+
+INSTALL=@INSTALL@
+INSTALL_PROGRAM=@INSTALL_PROGRAM@
+INSTALL_DATA=@INSTALL_DATA@
+
+# create a symbolic link (or a copie ?)
+LN_S=@LN_S@
+
+## Installation points
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+bindir=@bindir@/salome
+libdir=@libdir@/salome
+# warning : if user give this path in configure we could have salome/salome :-(
+includedir=@includedir@/salome
+datadir=@datadir@/salome
+idldir=$(prefix)/idl/salome
+sharedpydir=@libdir@/python$(PYTHON_VERSION)/site-packages/salome/shared_modules
+
+docdir=$(datadir)/doc
+
+#
+# begin of package rules
+#
+
+.PHONY: all lib bin inc resources tests install uninstall dep depend depend_idl cleandep mostlyclean clean distclean
+
+.SUFFIXES: .cxx .cc .c .f .o .lo .idl .py .i .ui .po .qm
+
+all:
+ $(MAKE) inc
+ $(MAKE) depend_idl
+ $(MAKE) depend
+ $(MAKE) lib
+ $(MAKE) bin
+ $(MAKE) resources
+
+#
+# add target to build administrative files
+#
+
+Makefile: $(top_builddir)/config.status $(srcdir)/Makefile.in
+ cd $(top_builddir) ; ./config.status
+
+$(top_builddir)/config.status: $(top_srcdir)/configure
+ cd $(top_builddir) ; ./config.status --recheck
+
+# VPATH contain $(srcdir), so make configure is good in top_srcdir and we must add target configure otherwise :-)
+ifneq ($(top_srcdir),$(srcdir))
+configure: $(top_srcdir)/configure
+endif
+
+$(top_srcdir)/configure: $(top_srcdir)/configure.in $(top_srcdir)/aclocal.m4
+ cd $(top_srcdir) ; autoconf
+
+$(top_srcdir)/configure.in: $(top_srcdir)/configure.in.base
+ cd $(top_srcdir) && ./build_configure
+
+
+ACLOCAL_SRC = \
+ac_cxx_bool.m4 check_corba.m4 check_vtk.m4 \
+ac_cxx_depend_flag.m4 check_hdf5.m4 enable_pthreads.m4 \
+ac_cxx_mutable.m4 check_mico.m4 libtool.m4 \
+ac_cxx_namespaces.m4 check_omniorb.m4 pyembed.m4 \
+ac_cxx_partial_specialization.m4 check_opengl.m4 python.m4 \
+ac_cxx_typename.m4 check_pthreads.m4 check_cas.m4 \
+ac_cc_warnings.m4 check_qt.m4 check_med2.m4 \
+check_swig.m4
+
+$(top_srcdir)/aclocal.m4: $(ACLOCAL_SRC:%=@KERNEL_ROOT_DIR@/salome_adm/unix/config_files/%)
+ cd $(top_srcdir) ; aclocal --acdir=adm_local/unix/config_files -I @KERNEL_ROOT_DIR@/salome_adm/unix/config_files
--- /dev/null
+#=======================================================================
+# Begin specific part to omniorb
+# (include from file adm/unix/make_omniorb generated by
+# adm/unix/make_omniorb.in)
+#=======================================================================
+# -* Makefile *-
+#
+# Author : Patrick GOLDBRONN (CEA)
+# Date : 29/06/2001
+# $Header$
+#
+
+# Client and server object are the same with omniorb
+# There are one header file and one source file generate
+
+#IDLOBJ=$(IDLSRC:%.idl=%$(IDL_CLN_OBJ))
+
+# dependancies between idl and it's generated files
+%$(OMNIORB_IDL_CLN_CXX) %$(OMNIORB_IDL_CLN_H): ${KERNEL_ROOT_DIR}/idl/salome/%.idl
+ $(OMNIORB_IDL) $(IDLCXXFLAGS) $(OMNIORB_IDLCXXFLAGS) $<
+
+%$(OMNIORB_IDL_CLN_CXX) %$(OMNIORB_IDL_CLN_H): ${top_srcdir}/idl/%.idl
+ $(OMNIORB_IDL) $(IDLCXXFLAGS) $(OMNIORB_IDLCXXFLAGS) $<
+
+# dependncies between idl files
+depend_idl: .depidl
+
+# we use cpp to generate dependencies between idl files.
+# we change cpp output to keep only idl file and transform it to get a suitable rule
+.depidl: $(IDL_FILES)
+ @touch $@
+ @for dep in $? dummy; do \
+ if [ $$dep != "dummy" ]; then \
+ echo Building dependencies for $$dep; \
+ basedep=`basename $$dep .idl`; \
+ header="$$basedep"$(IDL_CLN_H); \
+ sed '\%^'"$$header"':%,\%[^\\]$$%d' <$@ >$@- && mv $@- $@; \
+ $(CPP) $(C_DEPEND_FLAG) -I$(srcdir) $$dep 2>/dev/null | \
+ sed `echo "s%$$basedep\\.idl%$$header:%g"` | \
+ sed 's% $(srcdir)/% %g' | \
+ sed 's% $(top_srcdir)/% %g' | \
+ sed 's% $(top_builddir)/% %g' | \
+ sed 's%^.*:\.o: *%%' | sed 's%^ *\\ *%%'| sed 's%^ *\(.*\):%\1:%' | \
+ sed 's/\.idl/$(IDL_CLN_H)/' >>$@; \
+ echo '' >>$@; \
+ fi; \
+ done ;
+
+-include .depidl
+
+#=======================================================================
+# End specific part to omniorb
+#=======================================================================
--- /dev/null
+SALOME 2 EXAMPLE MODULE : PYHELLO
+This module works with KERNEL 1.2.1
--- /dev/null
+#!/bin/sh
+
+export KERNEL_ROOT_DIR=@KERNEL_ROOT_DIR@
+export PYHELLO_ROOT_DIR=@prefix@
+
+python -i $PYHELLO_ROOT_DIR/bin/salome/runSalome.py --modules=PYHELLO --xterm --containers=cpp,python --killall
+
+
--- /dev/null
+#!/usr/bin/env python
+
+usage="""USAGE: runSalome.py [options]
+
+[command line options] :
+--help : affichage de l'aide
+--gui : lancement du GUI
+--logger : redirection des messages dans un fichier
+--xterm : les serveurs ouvrent une fenêtre xterm et les messages sont affichés dans cette fenêtre
+--modules=module1,module2,... : où modulen est le nom d'un module Salome à charger dans le catalogue
+--containers=cpp,python,superv: lancement des containers cpp, python et de supervision
+--killall : arrêt des serveurs de salome
+
+ La variable d'environnement <modulen>_ROOT_DIR doit etre préalablement
+ positionnée (modulen doit etre en majuscule).
+ KERNEL_ROOT_DIR est obligatoire.
+"""
+
+# -----------------------------------------------------------------------------
+#
+# Fonction d'arrêt de salome
+#
+
+def killSalome():
+ print "arret des serveurs SALOME"
+ for pid, cmd in process_id.items():
+ print "arret du process %s : %s"% (pid, cmd[0])
+ try:
+ os.kill(pid,signal.SIGKILL)
+ except:
+ print " ------------------ process %s : %s inexistant"% (pid, cmd[0])
+ print "arret du naming service"
+ os.system("killall -9 omniNames")
+
+# -----------------------------------------------------------------------------
+#
+# Fonction message
+#
+
+def message(code, msg=''):
+ if msg: print msg
+ sys.exit(code)
+
+import sys,os,string,glob,time,signal,pickle,getopt
+
+init_time=os.times()
+opts, args=getopt.getopt(sys.argv[1:], 'hmglxck:', ['help','modules=','gui','logger','xterm','containers=','killall'])
+modules_root_dir={}
+process_id={}
+liste_modules={}
+liste_containers={}
+with_gui=0
+with_logger=0
+with_xterm=0
+
+with_container_cpp=0
+with_container_python=0
+with_container_superv=0
+
+try:
+ for o, a in opts:
+ if o in ('-h', '--help'):
+ print usage
+ sys.exit(1)
+ elif o in ('-g', '--gui'):
+ with_gui=1
+ elif o in ('-l', '--logger'):
+ with_logger=1
+ elif o in ('-x', '--xterm'):
+ with_xterm=1
+ elif o in ('-m', '--modules'):
+ liste_modules = [x.upper() for x in a.split(',')]
+ elif o in ('-c', '--containers'):
+ liste_containers = [x.lower() for x in a.split(',')]
+ for r in liste_containers:
+ if r not in ('cpp', 'python', 'superv'):
+ message(1, 'Invalid -c/--containers option: %s' % a)
+ if 'cpp' in liste_containers:
+ with_container_cpp=1
+ else:
+ with_container_cpp=0
+ if 'python' in liste_containers:
+ with_container_python=1
+ else:
+ with_container_python=0
+ if 'superv' in liste_containers:
+ with_container_superv=1
+ else:
+ with_container_superv=0
+ elif o in ('-k', '--killall'):
+ filedict='/tmp/'+os.getenv('USER')+'_SALOME_pidict'
+ #filedict='/tmp/'+os.getlogin()+'_SALOME_pidict'
+ found = 0
+ try:
+ fpid=open(filedict, 'r')
+ found = 1
+ except:
+ print "le fichier %s des process SALOME n'est pas accessible"% filedict
+
+ if found:
+ process_id=pickle.load(fpid)
+ fpid.close()
+ killSalome()
+ process_id={}
+ os.remove(filedict)
+
+except getopt.error, msg:
+ print usage
+ sys.exit(1)
+
+# -----------------------------------------------------------------------------
+#
+# Vérification des variables d'environnement
+#
+try:
+ kernel_root_dir=os.environ["KERNEL_ROOT_DIR"]
+ modules_root_dir["KERNEL"]=kernel_root_dir
+except:
+ print usage
+ sys.exit(1)
+
+for module in liste_modules :
+ try:
+ module=module.upper()
+ module_root_dir=os.environ[module +"_ROOT_DIR"]
+ modules_root_dir[module]=module_root_dir
+ except:
+ print usage
+ sys.exit(1)
+
+# il faut KERNEL en premier dans la liste des modules
+# - l'ordre des modules dans le catalogue sera identique
+# - la liste des modules presents dans le catalogue est exploitée pour charger les modules CORBA python,
+# il faut charger les modules python du KERNEL en premier
+
+if "KERNEL" in liste_modules:liste_modules.remove("KERNEL")
+liste_modules[:0]=["KERNEL"]
+#print liste_modules
+#print modules_root_dir
+
+os.environ["SALOMEPATH"]=":".join(modules_root_dir.values())
+if "SUPERV" in liste_modules:with_container_superv=1
+
+
+# -----------------------------------------------------------------------------
+#
+# Définition des classes d'objets pour le lancement des Server CORBA
+#
+
+class Server:
+ CMD=[]
+ if with_xterm:
+ ARGS=['xterm', '-iconic', '-sb', '-sl', '500', '-e']
+ else:
+ ARGS=[]
+
+ def run(self):
+ args = self.ARGS+self.CMD
+ #print "args = ", args
+ pid = os.spawnvp(os.P_NOWAIT, args[0], args)
+ process_id[pid]=self.CMD
+
+class CatalogServer(Server):
+ SCMD1=['SALOME_ModuleCatalog_Server','-common']
+ SCMD2=['-personal','${HOME}/Salome/resources/CatalogModulePersonnel.xml']
+
+ def setpath(self,liste_modules):
+ cata_path=[]
+ for module in liste_modules:
+ module_root_dir=modules_root_dir[module]
+ module_cata=module+"Catalog.xml"
+ print " ", module_cata
+ cata_path.extend(glob.glob(os.path.join(module_root_dir,"share","salome","resources",module_cata)))
+ self.CMD=self.SCMD1 + [string.join(cata_path,':')] + self.SCMD2
+
+class SalomeDSServer(Server):
+ CMD=['SALOMEDS_Server']
+
+class RegistryServer(Server):
+ CMD=['SALOME_Registry_Server', '--salome_session','theSession']
+
+class ContainerCPPServer(Server):
+ CMD=['SALOME_Container','FactoryServer','-ORBInitRef','NameService=corbaname::localhost']
+
+class ContainerPYServer(Server):
+ CMD=['SALOME_ContainerPy.py','FactoryServerPy','-ORBInitRef','NameService=corbaname::localhost']
+
+class ContainerSUPERVServer(Server):
+ CMD=['SALOME_Container','SuperVisionContainer','-ORBInitRef','NameService=corbaname::localhost']
+
+class LoggerServer(Server):
+ CMD=['SALOME_Logger_Server', 'logger.log']
+
+class SessionLoader(Server):
+ CMD=['SALOME_Session_Loader']
+ if with_container_cpp:
+ CMD=CMD+['CPP']
+ if with_container_python:
+ CMD=CMD+['PY']
+ if with_container_superv:
+ CMD=CMD+['SUPERV']
+ if with_gui:
+ CMD=CMD+['GUI']
+
+class SessionServer(Server):
+ CMD=['SALOME_Session_Server']
+
+class NotifyServer(Server):
+ CMD=['notifd','-c','${KERNEL_ROOT_DIR}/share/salome/resources/channel.cfg -DFactoryIORFileName=/tmp/${LOGNAME}_rdifact.ior -DChannelIORFileName=/tmp/${LOGNAME}_rdichan.ior']
+
+# -----------------------------------------------------------------------------
+#
+# Fonction de test
+#
+
+def test(clt):
+ """
+ Test function that creates an instance of PYHELLO component
+ usage : pyhello=test(clt)
+ """
+ # create an LifeCycleCORBA instance
+ import LifeCycleCORBA
+ lcc = LifeCycleCORBA.LifeCycleCORBA(clt.orb)
+ import PYHELLO_ORB
+ pyhello = lcc.FindOrLoadComponent("FactoryServerPy", "PYHELLO")
+ return pyhello
+
+# -----------------------------------------------------------------------------
+#
+# Fonctions helper pour ajouter des variables d'environnement
+#
+
+def add_path(directory):
+ os.environ["PATH"]=directory + ":" + os.environ["PATH"]
+
+def add_ld_library_path(directory):
+ os.environ["LD_LIBRARY_PATH"]=directory + ":" + os.environ["LD_LIBRARY_PATH"]
+
+def add_python_path(directory):
+ os.environ["PYTHONPATH"]=directory + ":" + os.environ["PYTHONPATH"]
+ sys.path[:0]=[directory]
+
+# -----------------------------------------------------------------------------
+#
+# initialisation des variables d'environnement
+#
+
+python_version="python%d.%d" % sys.version_info[0:2]
+
+#
+# Ajout du chemin d'acces aux executables de KERNEL dans le PATH
+#
+
+add_path(os.path.join(kernel_root_dir,"bin","salome"))
+#print "PATH=",os.environ["PATH"]
+
+#
+# Ajout des modules dans le LD_LIBRARY_PATH
+#
+for module in liste_modules:
+ module_root_dir=modules_root_dir[module]
+ add_ld_library_path(os.path.join(module_root_dir,"lib","salome"))
+#print "LD_LIBRARY_PATH=",os.environ["LD_LIBRARY_PATH"]
+
+#
+# Ajout des modules dans le PYTHONPATH (KERNEL prioritaire, donc en dernier)
+#
+
+liste_modules_reverse=liste_modules[:]
+liste_modules_reverse.reverse()
+#print liste_modules
+#print liste_modules_reverse
+for module in liste_modules_reverse:
+ module_root_dir=modules_root_dir[module]
+ add_python_path(os.path.join(module_root_dir,"bin","salome"))
+ add_python_path(os.path.join(module_root_dir,"lib",python_version,"site-packages","salome"))
+ add_python_path(os.path.join(module_root_dir,"lib","salome"))
+ add_python_path(os.path.join(module_root_dir,"lib",python_version,"site-packages","salome","shared_modules"))
+
+#print "PYTHONPATH=",sys.path
+
+import orbmodule
+
+#
+# -----------------------------------------------------------------------------
+#
+
+def startGUI():
+ import SALOME
+ session=clt.waitNS("/Kernel/Session",SALOME.Session)
+
+ #
+ # Activation du GUI de Session Server
+ #
+
+ session.GetInterface()
+
+#
+# -----------------------------------------------------------------------------
+#
+
+def startSalome():
+
+ #
+ # Lancement Session Loader
+ #
+ SessionLoader().run()
+
+ #
+ # Initialisation ORB et Naming Service
+ #
+ clt=orbmodule.client()
+
+ # (non obligatoire) Lancement Logger Server et attente de sa
+ # disponibilite dans le naming service
+ #
+ if with_logger:
+ LoggerServer().run()
+ clt.waitLogger("Logger")
+
+ #
+ # Lancement Registry Server
+ #
+ RegistryServer().run()
+
+ #
+ # Attente de la disponibilité du Registry dans le Naming Service
+ #
+ clt.waitNS("/Registry")
+
+ #
+ # Lancement Catalog Server
+ #
+ cataServer=CatalogServer()
+ cataServer.setpath(liste_modules)
+ cataServer.run()
+
+ #
+ # Attente de la disponibilité du Catalog Server dans le Naming Service
+ #
+ import SALOME_ModuleCatalog
+ clt.waitNS("/Kernel/ModulCatalog",SALOME_ModuleCatalog.ModuleCatalog)
+
+ #
+ # Lancement SalomeDS Server
+ #
+ os.environ["CSF_PluginDefaults"]=os.path.join(kernel_root_dir,"share","salome","resources")
+ os.environ["CSF_SALOMEDS_ResourcesDefaults"]=os.path.join(kernel_root_dir,"share","salome","resources")
+ SalomeDSServer().run()
+
+ if "GEOM" in liste_modules:
+ print "GEOM OCAF Resources"
+ os.environ["CSF_GEOMDS_ResourcesDefaults"]=os.path.join(modules_root_dir["GEOM"],"share","salome","resources")
+
+
+ #
+ # Attente de la disponibilité du SalomeDS dans le Naming Service
+ #
+ clt.waitNS("/myStudyManager")
+
+ #
+ # Lancement Session Server
+ #
+ SessionServer().run()
+
+ #
+ # Attente de la disponibilité du Session Server dans le Naming Service
+ #
+ import SALOME
+ session=clt.waitNS("/Kernel/Session",SALOME.Session)
+
+ #
+ # Lancement containers
+ #
+ theComputer = os.getenv("HOSTNAME")
+ theComputer = theComputer.split('.')[0]
+
+ #
+ # Lancement Container C++ local
+ #
+ if with_container_cpp:
+ ContainerCPPServer().run()
+ #
+ # Attente de la disponibilité du Container C++ local
+ # dans le Naming Service
+ #
+ clt.waitNS("/Containers/" + theComputer + "/FactoryServer")
+ #
+ # Lancement Container Python local
+ #
+ if with_container_python:
+ ContainerPYServer().run()
+ #
+ # Attente de la disponibilité du Container Python local
+ # dans le Naming Service
+ #
+ clt.waitNS("/Containers/" + theComputer + "/FactoryServerPy")
+
+ if with_container_superv:
+ #
+ # Lancement Container Supervision local
+ #
+ ContainerSUPERVServer().run()
+ #
+ # Attente de la disponibilité du Container Supervision local
+ # dans le Naming Service
+ #
+ clt.waitNS("/Containers/" + theComputer + "/SuperVisionContainer")
+ #
+ # Activation du GUI de Session Server
+ #
+ #session.GetInterface()
+
+ end_time = os.times()
+ print
+ print "Start SALOME, elpased time : %5.1f seconds"% (end_time[4] - init_time[4])
+
+ return clt
+
+#
+# -----------------------------------------------------------------------------
+#
+
+if __name__ == "__main__":
+ clt=None
+ try:
+ clt = startSalome()
+ except:
+ print
+ print
+ print "--- erreur au lancement Salome ---"
+
+ #print process_id
+
+
+ filedict='/tmp/'+os.getenv('USER')+'_SALOME_pidict'
+ #filedict='/tmp/'+os.getlogin()+'_SALOME_pidict'
+
+ fpid=open(filedict, 'w')
+ pickle.dump(process_id,fpid)
+ fpid.close()
+
+ print """
+
+Sauvegarde du dictionnaire des process dans , %s
+Pour tuer les process SALOME, executer : python killSalome.py depuis
+une console, ou bien killSalome() depuis le present interpreteur,
+s'il n'est pas fermé.
+
+runSalome, avec l'option --killall, commence par tuer les process restants
+d'une execution précédente.
+
+Pour lancer uniquement le GUI, executer startGUI() depuis le present interpreteur,
+s'il n'est pas fermé.
+
+""" % filedict
+
+ #
+ # Impression arborescence Naming Service
+ #
+
+ if clt != None:
+ print
+ print " --- registered objects tree in Naming Service ---"
+ clt.showNS()
+ session=clt.waitNS("/Kernel/Session")
+ catalog=clt.waitNS("/Kernel/ModulCatalog")
+ import socket
+ container = clt.waitNS("/Containers/" + socket.gethostname().split('.')[0] + "/FactoryServerPy")
+
+ if os.path.isfile("~/.salome/pystartup"):
+ f=open(os.path.expanduser("~/.salome/pystartup"),'w')
+ PYTHONSTARTUP=f.read()
+ f.close()
+ else:
+ PYTHONSTARTUP="""
+# Add auto-completion and a stored history file of commands to your Python
+# interactive interpreter. Requires Python 2.0+, readline. Autocomplete is
+# bound to the TAB key by default (you can change it - see readline docs).
+#
+# Store the history in ~/.salome/pyhistory,
+#
+import atexit
+import os
+import readline
+import rlcompleter
+readline.parse_and_bind('tab: complete')
+
+historyPath = os.path.expanduser("~/.salome/pyhistory")
+
+def save_history(historyPath=historyPath):
+ import readline
+ readline.write_history_file(historyPath)
+
+if os.path.exists(historyPath):
+ readline.read_history_file(historyPath)
+
+atexit.register(save_history)
+del os, atexit, readline, rlcompleter, save_history, historyPath
+"""
+ f=open(os.path.expanduser("~/.salome/pystartup"),'w')
+ f.write(PYTHONSTARTUP)
+ f.close()
+
+ exec PYTHONSTARTUP in {}
+
--- /dev/null
+#!/bin/bash
+
+#
+# Tool for updating list of .in file for the SALOME project
+# and regenerating configure script
+#
+# Author : Marc Tajchman - CEA
+# Date : 10/10/2002
+# $Header $
+#
+
+ORIG_DIR=`pwd`
+CONF_DIR=`echo $0 | sed -e "s,[^/]*$,,;s,/$,,;s,^$,.,"`
+
+########################################################################
+# Test if the KERNEL_ROOT_DIR is set correctly
+
+if test ! -d "${KERNEL_ROOT_DIR}"; then
+ echo "failed : KERNEL_ROOT_DIR variable is not correct !"
+ exit
+fi
+
+########################################################################
+# find_in - utility function
+#
+# usage :
+# find_in directory filename
+#
+# Finds files following the *.in pattern, recursively in the
+# directory (first argument).
+# Results are appended into the file (second argument)
+#
+# Difference from the standard unix find is that files are tested
+# before directories
+#
+
+find_in()
+{
+ local i
+ local f=$2
+
+# if the first argument is not a directory, returns
+
+ if [ ! -d "$1" ] ; then
+ return
+ fi
+
+# dont look in the CVS directories
+
+ case $1 in
+ */CVS) return ;;
+ *) ;;
+ esac
+
+# for each regular file contained in the directory
+# test if it's a .in file
+
+ for i in "$1"/*
+ do
+ if [ -f "$i" ] ; then
+ case $i in
+ *.in) echo $i" \\" >> $f;;
+ *) ;;
+ esac
+ fi
+ done
+
+# for each subdirectory of the first argument, proceeds recursively
+
+ for i in "$1"/*
+ do
+ if [ -d "$i" ] ; then
+ find_in "$i" "$f"
+ fi
+ done
+}
+
+
+#######################################################################
+# Generate list of .in files (Makefile.in, config.h.in, etc)
+# appending it in file configure.in
+
+cd ${CONF_DIR}
+ABS_CONF_DIR=`pwd`
+
+#
+# Common part of the configure.in file
+#
+chmod u+w configure.in.base
+if ! \cp -f configure.in.base configure.in_tmp1
+then
+ echo
+ echo "error : can't create files in" ${CONF_DIR}
+ echo "aborting ..."
+ chmod u-w configure.in.base
+ exit
+fi
+chmod u-w configure.in.base
+
+if [ -e "${CONF_DIR}/salome_adm" ] ; then
+ \rm -f ${CONF_DIR}/salome_adm
+fi
+
+# make a link allowing AC_OUTPUT to find the salome_adm/.../*.in files
+echo "" >> configure.in_tmp1
+echo 'ln -fs ${KERNEL_ROOT_DIR}/salome_adm ${ROOT_SRCDIR}' >> configure.in_tmp1
+
+echo "" >> configure.in_tmp1
+echo "AC_OUTPUT([ \\" >> configure.in_tmp1
+
+#
+# List of .in files in the adm/unix directory
+# These files MUST be on top of AC_OUTPUT list so we
+# put them "manually"
+#
+
+echo "./salome_adm/unix/SALOMEconfig.h \\" >> configure.in_tmp1
+echo "./salome_adm/unix/F77config.h \\" >> configure.in_tmp1
+echo "./salome_adm/unix/sstream \\" >> configure.in_tmp1
+echo "./salome_adm/unix/depend \\" >> configure.in_tmp1
+echo "./adm_local/unix/make_omniorb \\" >> configure.in_tmp1
+echo "./salome_adm/unix/envScript \\" >> configure.in_tmp1
+echo "./adm_local/unix/make_commence \\" >> configure.in_tmp1
+echo "./salome_adm/unix/make_conclude \\" >> configure.in_tmp1
+echo "./salome_adm/unix/make_module \\" >> configure.in_tmp1
+
+\rm -f configure.in_tmp2
+touch configure.in_tmp2
+find_in . configure.in_tmp2
+
+sed -e '/^.\/salome_adm/d' \
+ -e '/configure.in/d' \
+ -e '/^.\/adm_local/d' \
+ -e 's/.in / /' \
+ configure.in_tmp2 >> configure.in_tmp1
+
+echo "])" >> configure.in_tmp1
+
+# delete the link created for AC_OUTPUT
+echo "" >> configure.in_tmp1
+\mv configure.in_tmp1 configure.in_new
+\rm -f configure.in_tmp2
+
+
+########################################################################
+# Create new (or replace old) configure.in file
+# Print a message if the file is write protected
+#
+
+echo
+if test ! -f configure.in
+then
+ echo -n "Creating new file 'configure.in' ... "
+ if \mv configure.in_new configure.in >& /dev/null
+ then
+ echo "done"
+ else
+ echo "error, check your file permissions"
+ fi
+else
+ echo -n "Updating 'configure.in' file ... "
+ if ! \cp configure.in configure.in_old >& /dev/null
+ then
+ echo
+ echo
+ echo "Can't backup previous configure.in"
+ echo -n "Continue (you will not be able to revert) - (Y/N) ? "
+ read R
+ case "x$R" in
+ xn*) exit;;
+ xN*) exit;;
+ esac
+ echo
+ echo -n " "
+ fi
+ if \cp configure.in_new configure.in >& /dev/null
+ then
+ \rm -f configure.in_new
+ echo "done"
+ else
+ echo
+ echo "error, can't update previous configure.in"
+ fi
+fi
+
+########################################################################
+# Use autoconf to rebuild the configure script
+#
+
+if test -f configure
+then
+ echo -n "Updating 'configure' script ... "
+else
+ echo -n "Creating 'configure' script ... "
+fi
+
+aclocal --acdir=adm_local/unix/config_files -I ${KERNEL_ROOT_DIR}/salome_adm/unix/config_files
+if autoconf
+then
+ echo "done"
+else
+ echo "failed (check file permissions and/or user quotas ...)"
+fi
+
+cd ${ORIG_DIR}
+
+echo
--- /dev/null
+#
+# PLEASE DO NOT MODIFY configure.in FILE
+#
+# ALL CHANGES WILL BE DISCARDED BY THE NEXT
+# build_configure COMMAND
+#
+# CHANGES MUST BE MADE IN configure.in.base FILE
+#
+#
+# Author : Marc Tajchman (CEA)
+# Date : 28/06/2001
+# Modified by : Patrick GOLDBRONN (CEA)
+# Modified by : Marc Tajchman (CEA)
+#
+# Created from configure.in.base
+#
+
+AC_INIT(src)
+AC_CONFIG_AUX_DIR(${KERNEL_ROOT_DIR}/salome_adm/unix/config_files)
+AC_CANONICAL_HOST
+
+PACKAGE=salome
+AC_SUBST(PACKAGE)
+
+VERSION=1.2.1
+AC_SUBST(VERSION)
+
+dnl
+dnl Initialize source and build root directories
+dnl
+
+ROOT_BUILDDIR=`pwd`
+ROOT_SRCDIR=`echo $0 | sed -e "s,[[^/]]*$,,;s,/$,,;s,^$,.,"`
+cd $ROOT_SRCDIR
+ROOT_SRCDIR=`pwd`
+cd $ROOT_BUILDDIR
+
+AC_SUBST(ROOT_SRCDIR)
+AC_SUBST(ROOT_BUILDDIR)
+
+echo
+echo Source root directory : $ROOT_SRCDIR
+echo Build root directory : $ROOT_BUILDDIR
+echo
+echo
+
+if test -z "$AR"; then
+ AC_CHECK_PROGS(AR,ar xar,:,$PATH)
+fi
+AC_SUBST(AR)
+
+dnl Export the AR macro so that it will be placed in the libtool file
+dnl correctly.
+export AR
+
+echo
+echo ---------------------------------------------
+echo testing make
+echo ---------------------------------------------
+echo
+
+AC_PROG_MAKE_SET
+AC_PROG_INSTALL
+dnl
+dnl libtool macro check for CC, LD, NM, LN_S, RANLIB, STRIP + for shared libraries
+
+AC_ENABLE_DEBUG(yes)
+AC_DISABLE_PRODUCTION
+
+echo ---------------------------------------------
+echo testing libtool
+echo ---------------------------------------------
+
+dnl first, we set static to no!
+dnl if we want it, use --enable-static
+AC_ENABLE_STATIC(no)
+
+AC_LIBTOOL_DLOPEN
+AC_PROG_LIBTOOL
+
+dnl Fix up the INSTALL macro if it s a relative path. We want the
+dnl full-path to the binary instead.
+case "$INSTALL" in
+ *install-sh*)
+ INSTALL='\${KERNEL_ROOT_DIR}'/salome_adm/unix/config_files/install-sh
+ ;;
+esac
+
+echo
+echo ---------------------------------------------
+echo testing python
+echo ---------------------------------------------
+echo
+
+CHECK_PYTHON
+
+echo
+echo ---------------------------------------------
+echo testing omniORB
+echo ---------------------------------------------
+echo
+
+CHECK_OMNIORB
+
+echo
+echo ---------------------------------------------
+echo default ORB : omniORB
+echo ---------------------------------------------
+echo
+
+DEFAULT_ORB=omniORB
+CHECK_CORBA
+
+AC_SUBST_FILE(CORBA)
+corba=make_$ORB
+CORBA=adm_local/unix/$corba
+
+echo
+echo ---------------------------------------------
+echo Testing Kernel
+echo ---------------------------------------------
+echo
+
+CHECK_KERNEL
+
+echo
+echo ---------------------------------------------
+echo Summary
+echo ---------------------------------------------
+echo
+
+echo Configure
+variables="python_ok omniORB_ok Kernel_ok"
+
+for var in $variables
+do
+ printf " %10s : " `echo \$var | sed -e "s,_ok,,"`
+ eval echo \$$var
+done
+
+echo
+echo "Default ORB : $DEFAULT_ORB"
+echo
+
+dnl generals files which could be included in every makefile
+
+AC_SUBST_FILE(COMMENCE) COMMENCE=adm_local/unix/make_commence
+AC_SUBST_FILE(CONCLUDE) CONCLUDE=salome_adm/unix/make_conclude
+AC_SUBST_FILE(MODULE) MODULE=salome_adm/unix/make_module
+
+dnl les dependences
+AC_SUBST_FILE(DEPEND) DEPEND=salome_adm/unix/depend
+
+dnl We don t need to say when we re entering directories if we re using
+dnl GNU make becuase make does it for us.
+if test "X$GMAKE" = "Xyes"; then
+ AC_SUBST(SETX) SETX=":"
+else
+ AC_SUBST(SETX) SETX="set -x"
+fi
+
+# make other build directories
+for rep in salome_adm adm_local doc bin/salome include/salome lib/salome share/salome/resources share/salome/doc idl
+do
+ $INSTALL -d $rep
+done
+
+echo
+echo ---------------------------------------------
+echo copying resource files, shell scripts, and
+echo xml files
+echo ---------------------------------------------
+echo
+
+dnl copy shells and utilities contained in the bin directory
+dnl excluding .in files (treated in AC-OUTPUT below) and CVS
+dnl directory
+
+cd bin
+for i in $ROOT_SRCDIR/bin/*
+do
+ local_bin=`echo $i | sed -e "s,$ROOT_SRCDIR,.,"`
+ case "$local_bin" in
+ *.in | *~) ;;
+ ./bin/CVS) ;;
+ *) ln -fs $i; echo $local_bin ;;
+ esac
+done
+cd $ROOT_BUILDDIR
+
+AC_SUBST_FILE(ENVSCRIPT) ENVSCRIPT=salome_adm/unix/envScript
+
+echo
+echo ---------------------------------------------
+echo generating Makefiles and configure files
+echo ---------------------------------------------
+echo
+
+AC_OUTPUT_COMMANDS([ \
+ chmod +x ./bin/* \
+])
+
+## do not delete this line
--- /dev/null
+================================================================
+Guide pour le développement d'un module SALOME 2 en Python
+================================================================
+
+:Auteur: Caremoli C.
+
+.. contents::
+.. sectnum::
+
+Présentation
+=========================
+Ce document a pour objectif de décrire les différentes étapes
+du développement d'un module SALOME 2 en Python.
+Il commence par un bref rappel des principes de SALOME 2. Puis, il décrit
+les étapes successives qui seront suivies pour arriver à une configuration
+de module complète.
+
+Rappels sur les modules et composants SALOME 2
+==================================================
+Dans son principe, la plate-forme SALOME 2 est décomposée en une plate-forme
+de base nommée module KERNEL et une collection de modules divers.
+
+Un module est un produit compilable et installable qui se concrétise par une arborescence source qui doit
+respecter les règles générales SALOME2 et qui comprend une procédure de construction, installation qui
+respecte également les règles SALOME2.
+Chaque module est géré en configuration dans un module CVS
+indépendant. Chaque module peut livrer des versions à son rythme dans le respect des règles de
+cohérence de SALOME2. A chaque module est associée une base de tests de non régression.
+
+Un module a des dépendances avec les autres modules (utilise, est utilisé).
+Le module KERNEL constitue la base de la plate-forme SALOME2.
+Tous les autres modules dépendent du module KERNEL.
+
+===================================== ========= ============= ==================================
+Sous projets Modules Utilise Est utilisé par
+===================================== ========= ============= ==================================
+SP1 - Environnement de production
+SP2 - Architecture KERNEL MED, GEOM, SMESH, VISU,SUPERV
+SP2 - Architecture MED KERNEL SMESH, VISU
+SP3 - Géométrie GEOM KERNEL SMESH
+SP5 - Maillage SMESH KERNEL, MED
+SP6 - Superviseur SUPERV KERNEL
+SP7 - Visualisation VISU KERNEL, MED
+===================================== ========= ============= ==================================
+
+Un module contient un ou plusieurs composants SALOME. Un composant SALOME est un objet CORBA qui
+respecte les règles SALOME et qui est déclaré à SALOME au moyen d'un catalogue. Un composant SALOME
+peut être doté d'une interface utilisateur graphique (GUI) qui doit elle-même respecter les règles
+SALOME.
+
+Les étapes de construction du module exemple
+====================================================
+Le module exemple choisi pour illustrer le processus de construction d'un
+module est extrèmement simple. Il contiendra un seul composant et ce composant
+aura un seul service nommé getBanner qui acceptera une chaine de caractères
+comme unique argument et qui retournera une chaine de caractères obtenue
+par concaténation de "Hello " et de la chaine d'entrée. Ce composant sera
+complété par un GUI graphique écrit en PyQt.
+
+Les différentes étapes du développement seront les suivantes :
+
+ - créer une arborescence de module
+ - créer un composant SALOME 2 chargeable par un container Python
+ - configurer le module pour que le composant soit connu de SALOME
+ - ajouter un GUI graphique
+ - rendre le composant utilisable dans le superviseur
+
+Création de l'arborescence du module
+=======================================
+Dans un premier temps, on se contentera de mettre dans le module exemple un composant
+SALOME écrit en Python qui sera chargeable par un container Python.
+Il suffit donc d'une interface idl et d'une implantation Python du composant.
+Pour mettre en oeuvre ceci dans un module SALOME 2, il faut l'arborescence de
+fichier suivante::
+
+ + PYHELLO1_SRC
+ + build_configure
+ + configure.in.base
+ + Makefile.in
+ + adm_local
+ + unix
+ + make_commence.in
+ + make_omniorb.in
+ + config_files
+ + bin
+ + VERSION
+ + runAppli.in
+ + runSalome.py
+ + idl
+ + Makefile.in
+ + PYHELLO_Gen.idl
+ + src
+ + Makefile.in
+ + PYHELLO
+ + Makefile.in
+ + PYHELLO.py
+ + doc
+
+Le module a pour nom PYHELLO1_SRC et le composant PYHELLO.
+Tous les fichiers sont indispensables à l'exception de VERSION, runAppli et runSalome.py.
+VERSION sert pour documenter le module, il doit donner sa version et ses compatibilités ou
+incompatibilités avec les autres modules. Il est donc fortement recommandé mais pas indispensable
+au fonctionnement.
+Les fichiers runAppli et runSalome.py ne sont pas indispensables mais facilitent la mise en
+oeuvre de l'exemple.
+
+Mise en garde : il ne faut pas copier les fichiers de la plate-forme de base (KERNEL) pour
+initialiser une arborescence de module. Il est, en général, préférable de copier les fichiers
+d'un autre module comme GEOM ou MED.
+
+Mise en oeuvre d'autoconf, configure
+--------------------------------------
+SALOME utilise autoconf pour construire le script configure qui sert à l'installation pour
+tester la configuration du système et pour préconfigurer les fichiers Makefile de contruction
+du module.
+Le fichier build_configure contient une procédure qui à partir de configure.in.base et au moyen
+d'autoconf construit le script configure.
+Tous les fichiers dont l'extension est in sont des squelettes qui seront transformés par le
+processus de configure.
+
+Presque tous les fichiers utilisés pour ce processus sont localisés dans la plate-forme de
+base qui est référencée par la variable d'environnement KERNEL_ROOT_DIR. Cependant quelques
+fichiers doivent être modifiés en fonction du module cible. C'est le cas bien sur de build_configure
+et de configure.in.base qui doivent en général adaptés.
+
+Les fichiers de base pour le configure du module KERNEL et des autres modules sont rassemblés
+dans le répertoire salome_adm du module KERNEL. Il faut cependant, pour pouvoir utiliser les objets
+CORBA du module KERNEL surcharger les fichiers make_commence.in et make_omniorb.in du répertoire
+salome_adm. Cette surcharge est réalisée en mettant les fichiers make_commence.in et make_omniorb.in
+modifiés dans le répertoire adm_local du module exemple.
+
+config_files est un répertoire dans lequel on peut mettre les fichiers m4 qui servent à tester
+la configuration du système dans le processus de configure. Si les fichiers de salome_adm ne sont pas
+suffisants, on peut en ajouter dans adm_local.
+
+Répertoire idl
+------------------
+Dans le répertoire idl, il faut un Makefile qui doit mettre en oeuvre la compilation
+du fichier idl PYHELLO_Gen.idl et installer tous ces fichiers dans les bons répertoires
+de l'installation du module. Il suffit de modifier la cible IDL_FILES pour obtenir
+un fichier adapté.
+
+Concernant le fichier idl lui-même, il doit définir un module CORBA dont le nom
+doit être différent du nom du module pour éviter les conflits de nom et définir une
+interface CORBA qui dérive à minima de l'interface Component du module Engines.
+Le nom du module CORBA sera PYHELLO_ORB et le nom de l'interface PYHELLO_Gen.
+
+Répertoire src
+------------------
+Le répertoire src contiendra tous les composants et GUI graphiques du module. Chacune
+de ces entités doit avoir son propre répertoire.
+
+Le module ne contiendra pour le moment qu'un seul répertoire pour le moteur du
+composant PYHELLO et son nom sera PYHELLO.
+
+Le Makefile se contente de déclencher le parcours des sous répertoires qui sont
+décrits par la cible SUBDIRS.
+
+Répertoire PYHELLO
+'''''''''''''''''''''''
+Le répertoire contient le module Python qui représente le composant et donc contient la classe PYHELLO
+et un fichier Makefile dont le rôle est simplement d'exporter le module PYHELLO.py
+dans le répertoire d'installation du module SALOME.
+
+Le module PYHELLO.py contient la classe PYHELLO qui dérive de l'interface PYHELLO_Gen du
+module CORBA PYHELLO_ORB__POA et de la classe SALOME_ComponentPy_i du module SALOME_ComponentPy.
+
+Répertoire doc
+------------------
+Il ne contient rien pour le moment. Il pourrait contenir ce document.
+
+Répertoire bin
+------------------
+VERSION sert pour documenter le module, il doit donner sa version et ses compatibilités ou
+incompatibilités avec les autres modules. Il est donc fortement recommandé mais pas indispensable
+au fonctionnement.
+
+Le fichier runAppli.in est l'équivalent du runSalome du module KERNEL configuré pour mettre
+en oeuvre le module KERNEL et ce module PYHELLO.
+
+Le fichier runSalome.py est le fichier du module KERNEL avec une correction de bug pour
+tourner seulement avec un container Python, une modification de la fonction test qui crée
+le composant PYHELLO au lieu d'un composant MED et un développement pour disposer de
+la complétion automatique en Python.
+
+Création d'un composant chargeable par un container
+======================================================
+Les fichiers présentés ci-dessus suffisent pour construire et installer le module PYHELLO1_SRC,
+lancer la plate-forme SALOME constituée des modules KERNEL et PYHELLO1 et demander au container
+Python le chargement d'un composant PYHELLO.
+
+Toutes les étapes suivantes supposent que les logiciels prérequis de SALOME sont accessibles dans l'environnement
+du développeur de modules.
+
+Construction, installation
+---------------------------------
+Dans PYHELLO1_SRC, faire::
+
+ export KERNEL_ROOT_DIR=<chemin d'installation du module KERNEL>
+ ./build_configure
+
+Aller dans ../PYHELLO1_BUILD et faire::
+
+ ../PYHELLO1_SRC/configure --prefix=<chemin d'installation du module PYHELLO1>
+ make
+ make install
+
+Lancement de la plate-forme
+-------------------------------
+Aller dans <chemin d'installation du module PYHELLO1> et faire::
+
+ ./bin/salome/runAppli
+
+Cette commande lance SALOME configurée pour KERNEL et le module PYHELLO1. A la fin de ce
+lancement l'utilisateur est devant un interpréteur Python configuré pour SALOME et qui
+donne accès aux objets CORBA de SALOME.
+
+runAppli est un shell qui exécute un script Python en lui passant des arguments en ligne de
+commande::
+
+ python -i $PYHELLO_ROOT_DIR/bin/salome/runSalome.py --modules=PYHELLO --xterm --containers=cpp,python --killall
+
+Ces arguments indiquent que l'on prendra le script runSalome.py situé dans le module PYHELLO, que l'on
+activera le composant PYHELLO, les impressions seront redirigées dans une fenêtre xterm, on lancera un
+container Python et tous les processus SALOME existant avant le lancement seront tués.
+
+Pour que cette commande fonctionne, il faut préalablement avoir positionné les variables d'environnement
+suivantes::
+
+ export KERNEL_ROOT_DIR=<chemin d'installation du module KERNEL>
+ export PYHELLO_ROOT_DIR=<chemin d'installation du module PYHELLO>
+
+Cette méthode d'activation des modules et composants de SALOME 2 tend à confondre module et composant.
+Dans ce cas (1 composant par module), il n'y a pas de difficulté à paramétrer le lancement. Il suffit d'indiquer derrière
+l'option --modules la liste des composants demandés (KERNEL est inutile) et de fournir autant de variables
+d'environnement qu'il y a de composants. Le nom de ces variables doit être <Composant>_ROOT_DIR et doit donner le chemin
+du module contenant le composant. Dans le cas où on a plusieurs composants par module, c'est un peu plus
+compliqué. Ce sera présenté ultérieurement.
+
+Mise en garde: il est possible que le lancement de SALOME 2 n'aille pas jusqu'au bout. En effet
+dans certaines circonstances, le temps de lancement des serveurs CORBA peut être long et dépasser
+le timeout fixé à 21 secondes. Si la raison en est le temps de chargement important des
+bibliothèques dynamiques, il est possible qu'un deuxième lancement dans la foulée aille
+jusqu'au bout.
+
+Chargement du composant exemple
+------------------------------------
+Pour avoir accès aux méthodes du composant, il faut importer le module PYHELLO_ORB avant
+de demander le chargement du composant au container Python. Ce container Python
+a été rendu accessible dans runSalome.py au moyen de la variable container::
+
+ import PYHELLO_ORB
+ c=container.load_impl("PYHELLO","PYHELLO")
+ c.makeBanner("Christian")
+
+La dernière instruction doit retourner 'Hello Christian'.
+Pour voir les objets CORBA créés par ces actions, faire::
+
+ clt.showNS()
+
+On peut voir que le composant a été créé et enregistré dans un contexte de nommage qui peut
+être incorrect en raison d'un bug identifié dans la version 1.2.1 du module KERNEL.
+
+
+Composant SALOME déclaré
+==============================
+Pour le moment, le composant PYHELLO a été chargé en faisant une requête directe au container
+Python. Ce n'est pas la méthode standard pour charger un composant. La voie normale passe
+par le service LifeCycle qui utilise les services du catalogue pour identifier le composant
+et ses propriétés puis appelle le container demandé pour charger le composant.
+
+Pour pouvoir utiliser cette méthode, il faut déclarer le composant dans un catalogue au format XML dont le
+nom doit être <Composant>Catalog.xml. Dans notre cas ce sera PYHELLOCatalog.xml. Ce catalogue sera rangé
+dans le répertoire resources. Arborescence actualisée::
+
+ + PYHELLO1_SRC
+ + build_configure
+ + configure.in.base
+ + Makefile.in
+ + adm_local
+ + bin
+ + idl
+ + src
+ + doc
+ + resources
+ + PYHELLOCatalog.xml
+
+En dehors de l'ajout du répertoire resources et du fichier PYHELLOCatalog.xml, le reste des fichiers
+est identique. Il faut cependant modifier le Makefile.in de tête pour que le catalogue soit bien installé
+dans le répertoire d'installation. Il suffit de le spécifier dans la cible RESOURCES_FILES.
+
+Construction, installation
+---------------------------------
+Il n'est pas nécessaire de refaire un configure pour prendre en compte cette modification. Il
+suffit d'aller dans PYHELLO1_BUILD et de faire::
+
+ ./config.status
+ make
+ make install
+
+Lancement de la plate-forme
+-------------------------------
+Le lancement de la plate-forme se passe de la même manière que précédemment. Aller dans PYHELLO1_INSTALL et faire::
+
+ ./bin/salome/runAppli
+
+Chargement du composant exemple
+------------------------------------
+La méthode de chargement du composant n'est pas très différente de la fois précédente. On
+utiilise maintenant les services du module LifeCycle au lieu d'appeler directement le container.
+La séquence d'appel est contenue dans la fonction test de runSalome.Py. ::
+
+ c=test(clt)
+ c.makeBanner("Christian")
+
+La fonction test crée le LifeCycle. Puis elle demande le chargement du composant PYHELLO
+dans le container FactoryServerPy::
+
+ def test(clt):
+ """
+ Test function that creates an instance of PYHELLO component
+ usage : pyhello=test(clt)
+ """
+ import LifeCycleCORBA
+ lcc = LifeCycleCORBA.LifeCycleCORBA(clt.orb)
+ import PYHELLO_ORB
+ pyhello = lcc.FindOrLoadComponent("FactoryServerPy", "PYHELLO")
+ return pyhello
+
+Chargement depuis l'interface applicative (IAPP)
+----------------------------------------------------------
+Pour pouvoir charger dynamiquement un composant en utilisant la barre à composants
+de l'IAPP, il faut déclarer l'icone représentative du composant dans le catalogue.
+Pour la déclarer il suffit d'ajouter une ligne pour l'icone au catalogue du composant::
+
+ <component-icone>PYHELLO.png</component-icone>
+
+et de mettre le fichier correspondant dans le répertoire resources du module.
+
+Pour tester la bonne configuration de la barre à composants, lancer SALOME 2 comme
+précédemment puis à partir de l'interpréteur Python lancer l'IAPP par::
+
+ startGUI()
+
+et charger le composant en cliquant sur l'icone de PYHELLO après avoir ouvert une étude. L'IAPP doit
+signaler que le GUI du composant n'est pas correctement configuré mais le composant sera quand
+même créé après un temps d'attente. On peut le constater en tapant::
+
+ clt.showNS()
+
+Ajout d'un GUI graphique
+===========================
+L'étape suivante pour compléter le module consiste à ajouter au composant PYHELLO
+une interface graphique qui sera écrite en Python en utilisant la bibliothèque de
+widgets Qt. Cette interface graphique doit s'intégrer dans l'interface applicative
+de SALOME (IAPP) et doit donc respecter certaines contraintes que nous allons voir.
+
+Tout d'abord, précisons le contour du GUI d'un composant.
+Le comportement du GUI est
+donné par un module Python dont le nom est normalisé <Composant>GUI.py. Il doit
+proposer des points d'entrée conventionnels qui seront utilisés par l'IAPP pour activer
+ce GUI ou l'informer de certains évènements.
+L'activation des commandes du GUI est réalisée au moyen d'une barre de menu et d'une barre
+à boutons qui s'intègrent dans la barre à menus et dans la barre à boutons de l'IAPP.
+
+
+Module Python implantant le comportement du GUI
+-----------------------------------------------------
+Le comportement du GUI du composant PYHELLO est implanté dans le module Python PYHELLOGUI.py
+du sous-répertoire PYHELLOGUI.
+Le Makefile.in localisé dans le répertoire src doit être actualisé pour parcourir le sous-répertoire PYHELLOGUI.
+Un Makefile.in doit être ajouté dans le sous-répertoire PYHELLOGUI. Les cibles
+importantes sont PO_FILES et EXPORT_PYSCRIPTS.
+
+La cible EXPORT_PYSCRIPTS doit être mise à jour avec le nom des modules Python à rendre visible
+dans Salome, c'est à dire principalement pour qu'ils soient importables (commande import de Python).
+
+La cible PO_FILES doit être mise à jour avec les noms des fichiers qui sont utilisés pour le multi-linguisme.
+Pour le moment le fichier PYHELLO_msg_en.po (traduction pour langue anglaise) est vide car le multi-linguisme
+n'est pas mis en oeuvre dans cet exemple.
+
+Barre à menus et barre à boutons
+----------------------------------
+Les barres à menus et à boutons du composant PYHELLO sont décrites dans un fichier au format XML
+pour permettre leur chargement dynamique dans l'IAPP. Ce fichier est localisé dans le répertoire resources
+du module et a un nom standardisé <Composant>_en.xml pour la langue anglaise. Pour la langue française, il
+faut également un fichier de nom <Composant>_fr.xml.
+Pour le composant PYHELLO, le fichier PYHELLO_en.xml contient un menu avec un item et un bouton.
+L'icone du bouton est fournie par le fichier ExecPYHELLO.png localisé dans le répertoire resources du module.
+
+Etapes ultérieures restant à décrire
+==========================================
+
+ - lien avec l'étude
+ - lien avec la sélection
+ - ajout d'un popup contextuel
+ - comment rendre le composant supervisable
+ - ajout de la persistance
+ - avoir plusieurs composants dans le même module
+
+Rapides rappels sur l'architecture SALOME 2
+==================================================
+Les containers
+--------------------
+Dans SALOME, les composants sont dynamiquement chargeables. Cette propriété est obtenu
+en utilisant un mécanisme de container.
+
+Dans ses grandes lignes, un container est un serveur CORBA dont l'interface dispose
+des méthodes nécessaires pour effectuer le chargement déchargement de l'implantation
+d'un composant SALOME. Pour effectuer le chargement d'un composant, on appellera la méthode
+load_impl du container.
+
+La mécanique de base du chargement d'un composant est dépendante du langage d'implantation choisi.
+
+En C++, la plate-forme utilise le chargement dynamique de bibliothèque (dlopen) et un mécanisme de fonction
+factory dont le nom doit être <Module>Engine_factory (par exemple GEOMEngine_factory, pour GEOM).
+Cette fonction doit retourner l'objet CORBA effectif qui est le composant SALOME.
+
+En Python, la plate-forme utilise le mécanisme d'import de Python (import <Module>) et instancie
+le composant SALOME Python en utilisant une classe (ou une factory) de même nom (<Module>) pour
+ce faire.
+
+Le multi-linguisme
+-----------------------
+A compléter
+
+Les logiciels prérequis
+---------------------------
+A compléter
+
+
+
--- /dev/null
+#
+# generate dependencies for idl file :
+#
+
+# source path
+top_srcdir=@top_srcdir@
+top_builddir=..
+srcdir=@srcdir@
+VPATH=.:$(srcdir):${KERNEL_ROOT_DIR}/idl/salome
+
+@COMMENCE@
+
+IDL_FILES = PYHELLO_Gen.idl
+
+PY_CLIENT_IDL = $(IDL_FILES)
+
+# we copy all idl file in $(top_builddir)/idl
+inc: $(IDL_FILES:%=$(top_builddir)/idl/%)
+
+$(IDL_FILES:%=$(top_builddir)/idl/%):$(top_builddir)/idl/%:%
+ #$(CP) $< $@
+ cp -f $< $@
+
+lib: pyidl
+
+PYTHON_BUILD_SITE=$(top_builddir)/lib/python$(PYTHON_VERSION)/site-packages/@PACKAGE@
+
+pyidl: $(PYTHON_BUILD_SITE) $(IDL_FILES:%.idl=$(PYTHON_BUILD_SITE)/%_idl.py)
+
+$(PYTHON_BUILD_SITE):
+ $(INSTALL) -d $@
+
+$(PYTHON_BUILD_SITE)/%_idl.py: %.idl
+ $(OMNIORB_IDL) $(OMNIORB_IDLPYFLAGS) -C$(PYTHON_BUILD_SITE) $<
+
+# install python client (generated from idl file
+install: install-pyidl install-idl
+
+# create directory $(idldir) and copy idl files into it
+install-idl: $(IDL_FILES)
+ $(INSTALL) -d $(idldir)
+ cp -p $^ $(idldir)
+
+install-pyidl: $(IDL_FILES)
+ $(INSTALL) -d $(PYTHON_SITE_INSTALL)
+ @for file in $^ dummy; do \
+ if [ $$file != "dummy" ]; then \
+ $(OMNIORB_IDL) $(OMNIORB_IDLPYFLAGS) -C$(PYTHON_SITE_INSTALL) $$file ; \
+ fi ; \
+ done ;
+
+
+cleandep:
+ -$(RM) .dep*
+
+distclean:
+ -$(RM) *.py
+ -$(RM) $(IDL_FILES:%=$(top_builddir)/idl/%)
+ -$(RM) Makefile
+
--- /dev/null
+#ifndef __PYHELLO_GEN__
+#define __PYHELLO_GEN__
+
+#include "SALOME_Component.idl"
+#include "SALOME_Exception.idl"
+
+module PYHELLO_ORB
+{
+ interface PYHELLO_Gen : Engines::Component
+ {
+ string makeBanner(in string name)
+ raises (SALOME::SALOME_Exception);
+ };
+};
+
+#endif
+
--- /dev/null
+<?xml version='1.0' encoding='us-ascii' ?>
+
+<!-- XML component catalog -->
+<begin-catalog>
+
+<!-- Path prefix information -->
+
+<path-prefix-list>
+</path-prefix-list>
+
+<!-- Component list -->
+<component-list>
+ <component>
+ <!-- Component identification -->
+ <component-name>PYHELLO</component-name>
+ <component-username>PYHELLO GUI</component-username>
+ <component-type>Data</component-type>
+ <component-author>C. Caremoli</component-author>
+ <component-version> 1.0</component-version>
+ <component-comment>EDF - RD</component-comment>
+ <component-multistudy>1</component-multistudy>
+ <component-icone>PYHELLO.png</component-icone>
+ <constraint>'linux' ~ OS</constraint>
+
+ </component>
+</component-list>
+</begin-catalog>
--- /dev/null
+<?xml version='1.0' encoding='us-ascii'?>
+<!DOCTYPE application PUBLIC "" "desktop.dtd">
+<application title="PYHELLO component" date="9/12/2001" author="C Caremoli" appId="PYHELLO" >
+<desktop>
+<!-- ### MENUBAR ### -->
+<menubar>
+ <menu-item label-id="PYHELLO" item-id="90" pos-id="3">
+ <popup-item item-id="941" label-id="Lancer IHM" icon-id="" tooltip-id="Lancer IHM PYHELLO" accel-id="" toggle-id="" execute-action=""/>
+ </menu-item>
+</menubar>
+<!-- ### TOOLBAR ### -->
+<toolbar label-id="PYHELLO">
+ <toolbutton-item item-id="941" label-id="Lancer IHM" icon-id="ExecPYHELLO.png" tooltip-id="Lancer IHM PYHELLO" accel-id="" toggle-id="" execute-action=""/>
+</toolbar>
+</desktop>
+</application>
+
--- /dev/null
+#==============================================================================
+# File : Makefile.in
+# Created : ven déc 7 13:32:20 CET 2001
+# Author : Paul RASCLE, EDF
+# Project : SALOME
+# Copyright : EDF 2001
+# $Header$
+#==============================================================================
+
+# source path
+top_srcdir=@top_srcdir@
+top_builddir=..
+srcdir=@srcdir@
+VPATH=.:@srcdir@
+
+@COMMENCE@
+
+SUBDIRS = PYHELLO PYHELLOGUI
+
+@MODULE@
--- /dev/null
+# source path
+top_srcdir=@top_srcdir@
+top_builddir=../..
+srcdir=@srcdir@
+VPATH=.:@srcdir@:@top_srcdir@/idl:$(top_builddir)/idl:${KERNEL_ROOT_DIR}/idl/salome
+
+@COMMENCE@
+
+EXPORT_PYSCRIPTS = \
+PYHELLO.py
+
+# Libraries targets
+
+LIB_SERVER_IDL =
+LIB_CLIENT_IDL =
+
+# Executables targets
+
+@CONCLUDE@
+
--- /dev/null
+import PYHELLO_ORB__POA
+import SALOME_ComponentPy
+
+class PYHELLO(PYHELLO_ORB__POA.PYHELLO_Gen,
+ SALOME_ComponentPy.SALOME_ComponentPy_i):
+ """
+ Pour etre un composant SALOME cette classe Python
+ doit avoir le nom du composant et heriter de la
+ classe PYHELLO_Gen issue de la compilation de l'idl
+ par omniidl et de la classe SALOME_ComponentPy_i
+ qui porte les services generaux d'un composant SALOME
+ """
+ def __init__ (self, orb, poa, contID, containerName, instanceName,
+ interfaceName):
+ print "PYHELLO.__init__: ",containerName,' ',instanceName
+ SALOME_ComponentPy.SALOME_ComponentPy_i.__init__(self, orb, poa,
+ contID, containerName,instanceName, interfaceName, 0 )
+ # On stocke dans l'attribut _naming_service, une reference sur
+ # le Naming Service CORBA
+ self._naming_service=SALOME_ComponentPy.SALOME_NamingServicePy_i(self._orb)
+
+ def makeBanner(self,name):
+ banner= "Hello %s" % name
+ return banner
+
--- /dev/null
+# source path
+top_srcdir=@top_srcdir@
+top_builddir=../..
+srcdir=@srcdir@
+VPATH=.:@srcdir@:@top_srcdir@/idl:$(top_builddir)/idl:${KERNEL_ROOT_DIR}/idl/salome
+
+@COMMENCE@
+
+# header files
+EXPORT_HEADERS=
+
+# .po files to transform in .qm
+PO_FILES = PYHELLO_msg_en.po PYHELLO_icons.po
+
+# Libraries targets
+
+LIB =
+LIB_SRC =
+
+LIB_CLIENT_IDL =
+
+LIB_SERVER_IDL =
+
+EXPORT_PYSCRIPTS=PYHELLOGUI.py
+
+@CONCLUDE@
--- /dev/null
+import qt
+from qt import *
+import traceback
+
+# Global variable to store Salome Workspace
+WORKSPACE=None
+
+import SalomePyQt
+# Communication with Salome : desktop, signal and slots
+sgPyQt=SalomePyQt.SalomePyQt()
+desktop=sgPyQt.getDesktop()
+
+# LifeCycle and component PYHELLO
+import salome
+lifecycle = salome.lcc
+import PYHELLO_ORB
+pyhello=lifecycle.FindOrLoadComponent("FactoryServerPy", "PYHELLO")
+
+def setWorkSpace(pyws):
+ global WORKSPACE
+ print "setWorkSpace: ",pyws
+ WORKSPACE=pyws
+
+def OnGUIEvent(commandID) :
+ print "PYHELLOGUI::OnGUIEvent::commandID,WORKSPACE= ",commandID,WORKSPACE
+ if dict_command.has_key(commandID):
+ try:
+ r=dict_command[commandID](WORKSPACE)
+ print r
+ except:
+ traceback.print_exc()
+ else:
+ print "Pas de commande associée a : ",commandID
+
+def setSettings():
+ print "setSettings"
+
+def activeStudyChanged(ID):
+ print "activeStudyChanged: ",ID
+
+def definePopup(theContext, theObject, theParent):
+ print "PYHELLOGUI --- definePopup: ",theContext,theObject,theParent
+
+def customPopup(popup, theContext, theObject, theParent):
+ print "PYHELLOGUI --- customPopup: ",theContext,theObject,theParent
+
+class MyDialog(qt.QDialog):
+ def __init__(self,parent=None, name=None, modal=0, flags=0):
+ qt.QDialog.__init__(self,parent, name, modal, flags)
+ self.vb = qt.QVBoxLayout(self, 8)
+ self.vb.setAutoAdd(1)
+ self.hb0 = qt.QHBox(self)
+ label=QLabel("Prenom",self.hb0)
+ self.entry=QLineEdit( self.hb0)
+
+ self.hb = qt.QHBox(self)
+ c = qt.QPushButton("OK", self.hb)
+ self.connect(c, qt.SIGNAL('clicked()'), self.accept)
+ d = qt.QPushButton("CANCEL", self.hb)
+ self.connect(d, qt.SIGNAL('clicked()'), self.reject)
+
+def ExecPYHELLO(ws):
+ # Modal dialog, parent desktop
+ w=MyDialog(desktop,"Name",1)
+ # Wait answer
+ r=w.exec_loop()
+ if r == QDialog.Accepted:
+ name=str(w.entry.text())
+ banner=pyhello.makeBanner(name)
+ QMessageBox.about(desktop,'Salome Example',banner)
+ else:
+ print "CANCEL"
+
+dict_command={
+ 941:ExecPYHELLO,
+ }
--- /dev/null
+# This is a Qt message file in .po format. Each msgid starts with
+# a scope. This scope should *NOT* be translated - eg. "Foo::Bar"
+# would be translated to "Pub", not "Foo::Pub".
+msgid ""
+msgstr ""
+"Project-Id-Version: PROJECT VERSION\n"
+"POT-Creation-Date: 2002-05-28 10:57:43 AM CEST\n"
+"PO-Revision-Date: YYYY-MM-DD\n"
+"Last-Translator: FULLNAME <EMAIL@ADDRESS>\n"
+"Content-Type: text/plain; charset=iso-8859-1\n"
+
--- /dev/null
+# This is a Qt message file in .po format. Each msgid starts with
+# a scope. This scope should *NOT* be translated - eg. "Foo::Bar"
+# would be translated to "Pub", not "Foo::Pub".
+msgid ""
+msgstr ""
+"Project-Id-Version: PROJECT VERSION\n"
+"POT-Creation-Date: 2002-05-28 10:57:43 AM CEST\n"
+"PO-Revision-Date: YYYY-MM-DD\n"
+"Last-Translator: FULLNAME <EMAIL@ADDRESS>\n"
+"Content-Type: text/plain; charset=iso-8859-1\n"
+
