+/*! \page page1 Mapping of IDL definitions to Python language.
+\section Intro Introduction
+%SALOME PRO is a distributed client/server application using the Common Object Request Broker Architecture (CORBA).
+CORBA architecture uses the Interface Definition Language (IDL), which specifies interfaces between CORBA objects. So with help of IDL
+CORBA's language independence is ensured . Because interfaces described in IDL can be mapped to the most of currently used programming languages, CORBA applications and components are thus
+independent of the language(s) used to implement them. In other words, a client written in C++ can communicate with a server written in Java, which in turn can communicate with
+another server written in COBOL, and so forth.
+
+One important thing to remember about IDL is that it is not an implementation language. That is, applications can't be written in IDL. The sole purpose of IDL is to define interfaces;
+providing implementations for these interfaces is performed using some other language.
+
+This page contains an abridged reference manual for mapping of IDL definitions to Python language. It will be useful for Python programmers who are not familiar
+with IDL language. All examples are taken from %SALOME PRO source files.
+The complete version of Python Language Mapping Specification can be found <A HREF="http://www.omg.org">here.</A>
+
+<BR><STRONG>CONTENTS:</STRONG>
+- \ref subsection1
+- \ref subsection2
+- \ref subsection3
+- \ref subsection4
+- \ref subsection5
+- \ref subsection6
+- \ref subsection7
+
+\subsection subsection1 Using Scoped Names
+
+Python implements a module concept that is similar to the IDL scoping mechanisms,
+except that it does not allow for nested modules. In addition, Python requires each
+object to be implemented in a module; globally visible objects are not supported.
+
+Because of these constraints, scoped names are translated into Python using the
+following rules:
+
+\95 An IDL module mapped into a Python module. Modules containing modules are
+mapped to packages (i.e., directories with an <STRONG>__init__</STRONG> module containing all
+definitions excluding the nested modules). An implementation can chose to map toplevel
+definitions (including the module CORBA) to modules in an implementationdefined
+package, to allow concurrent installations of different CORBA runtime
+libraries. In that case, the implementation must provide additional modules so that
+toplevel modules can be used without importing them from a package.
+
+\95 For all other scopes, a Python class is introduced that contains all the definitions
+inside this scope.
+
+\95 Other global definitions (except modules) appear in a module whose name is
+implementation dependent. Implementations are encouraged to use the name of the
+IDL file when defining the name of that module.
+
+For instance,
+
+\verbatim
+module SALOMEDS {
+ interface StudyManager {
+ void Close(in Study aStudy);
+ };
+};
+\endverbatim
+
+would introduce a module SALOMEDS.py, which contains the following definitions:
+
+\verbatim
+# module SALOMEDS.py
+class StudyManager:
+ def _Close(self,aStudy):
+ pass #interfaces are discussed later
+\endverbatim
+
+To avoid conflicts, IDL names that are also Python identifiers are prefixed with an underscore (\91_\92).
+
+\subsection subsection2 Mapping for Template and Array Types
+
+Both the bounded and the unbounded string type of IDL are mapped to the Python
+string type. Wide strings are represented by an implementation-defined type with the
+following properties:
+
+\95 For the wide string X and the integer n, X[n] returns the nth character, which is a
+wide string of length 1.
+
+\95 len(X) returns the number of characters of wide string X.
+
+\95 CORBA.wstr(c) returns a wide character with the code point c in an
+implementation-defined encoding.
+
+\95 X+Y returns the concatenation of wide strings X and Y.
+
+\95 CORBA.word(CORBA.wstr(c)) == c
+
+The sequence template is mapped to sequence objects (e.g., tuples or lists).
+Applications should not assume that values of a sequence type are mutable. Sequences
+and arrays of octets and characters are mapped to the string type for efficiency reasons.
The %StudyBuilder can be created with the method <VAR>NewBuilder</VAR>. While invocation of this method a new object of the class <VAR>Callback</VAR> is created
and this object is assigned to the newly created Builder as callback which should be called when adding and removing of the ojects.
@@ -1043,5+1367,5 @@ Activates the %UseCaseIterator. If <VAR>allLevels</VAR> is True the Iterator is