]> SALOME platform Git repositories - plugins/hexablockplugin.git/commitdiff
Salome HOME
Merge from V6_main_20120808 08Aug12
authorvsr <vsr@opencascade.com>
Thu, 9 Aug 2012 14:24:43 +0000 (14:24 +0000)
committervsr <vsr@opencascade.com>
Thu, 9 Aug 2012 14:24:43 +0000 (14:24 +0000)
47 files changed:
AUTHORS [new file with mode: 0755]
COPYING [new file with mode: 0755]
ChangeLog [new file with mode: 0755]
HEXABLOCKPLUGIN_version.h.in [new file with mode: 0755]
INSTALL [new file with mode: 0755]
Makefile.am [new file with mode: 0755]
NEWS [new file with mode: 0755]
README [new file with mode: 0755]
adm_local/Makefile.am [new file with mode: 0755]
adm_local/unix/Makefile.am [new file with mode: 0755]
adm_local/unix/config_files/Makefile.am [new file with mode: 0755]
adm_local/unix/config_files/check_HEXABLOCKPLUGIN.m4 [new file with mode: 0755]
adm_local/unix/make_common_starter.am [new file with mode: 0755]
bin/Makefile.am [new file with mode: 0755]
bin/VERSION.in [new file with mode: 0755]
build_configure [new file with mode: 0755]
clean_configure [new file with mode: 0755]
configure.ac [new file with mode: 0755]
env_HEXABLOCKPLUGIN_src.sh [new file with mode: 0644]
idl/HEXABLOCKPlugin_Algorithm.idl [new file with mode: 0755]
idl/Makefile.am [new file with mode: 0755]
resources/HEXABLOCKPlugin.xml [new file with mode: 0755]
resources/Makefile.am [new file with mode: 0755]
resources/SalomeApp.xml [new file with mode: 0755]
resources/mesh_hypo_HEXABLOCK.png [new file with mode: 0755]
resources/mesh_tree_hypo_HEXABLOCK.png [new file with mode: 0755]
src/GUI/HEXABLOCKPluginGUI_HypothesisCreator.cxx [new file with mode: 0755]
src/GUI/HEXABLOCKPluginGUI_HypothesisCreator.h [new file with mode: 0755]
src/GUI/HEXABLOCKPlugin_images.ts [new file with mode: 0755]
src/GUI/HEXABLOCKPlugin_msg_en.ts [new file with mode: 0755]
src/GUI/Makefile.am [new file with mode: 0755]
src/HEXABLOCKPlugin/HEXABLOCKPlugin_Defs.hxx [new file with mode: 0755]
src/HEXABLOCKPlugin/HEXABLOCKPlugin_FromSkin_3D.cxx [new file with mode: 0755]
src/HEXABLOCKPlugin/HEXABLOCKPlugin_FromSkin_3D.hxx [new file with mode: 0755]
src/HEXABLOCKPlugin/HEXABLOCKPlugin_HEXABLOCK.cxx [new file with mode: 0755]
src/HEXABLOCKPlugin/HEXABLOCKPlugin_HEXABLOCK.hxx [new file with mode: 0755]
src/HEXABLOCKPlugin/HEXABLOCKPlugin_HEXABLOCK_i.cxx [new file with mode: 0755]
src/HEXABLOCKPlugin/HEXABLOCKPlugin_HEXABLOCK_i.hxx [new file with mode: 0755]
src/HEXABLOCKPlugin/HEXABLOCKPlugin_Hypothesis.cxx [new file with mode: 0755]
src/HEXABLOCKPlugin/HEXABLOCKPlugin_Hypothesis.hxx [new file with mode: 0755]
src/HEXABLOCKPlugin/HEXABLOCKPlugin_Hypothesis_i.cxx [new file with mode: 0755]
src/HEXABLOCKPlugin/HEXABLOCKPlugin_Hypothesis_i.hxx [new file with mode: 0755]
src/HEXABLOCKPlugin/HEXABLOCKPlugin_i.cxx [new file with mode: 0755]
src/HEXABLOCKPlugin/HEXABLOCKPlugin_mesh.cxx [new file with mode: 0755]
src/HEXABLOCKPlugin/HEXABLOCKPlugin_mesh.hxx [new file with mode: 0755]
src/HEXABLOCKPlugin/Makefile.am [new file with mode: 0755]
src/Makefile.am [new file with mode: 0755]

diff --git a/AUTHORS b/AUTHORS
new file mode 100755 (executable)
index 0000000..e69de29
diff --git a/COPYING b/COPYING
new file mode 100755 (executable)
index 0000000..b1e3f5a
--- /dev/null
+++ b/COPYING
@@ -0,0 +1,504 @@
+                 GNU LESSER GENERAL PUBLIC LICENSE
+                      Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+     59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL.  It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+                           Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+  When we speak of free software, we are referring to freedom of use,
+not price.  Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+\f
+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard.  To achieve this, non-free programs must be
+allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+\f
+                 GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+  
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+\f
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+\f
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+\f
+  6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Use a suitable shared library mechanism for linking with the
+    Library.  A suitable mechanism is one that (1) uses at run time a
+    copy of the library already present on the user's computer system,
+    rather than copying library functions into the executable, and (2)
+    will operate properly with a modified version of the library, if
+    the user installs one, as long as the modified version is
+    interface-compatible with the version that the work was made with.
+
+    c) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    d) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    e) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+\f
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+\f
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+\f
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+                           NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+                    END OF TERMS AND CONDITIONS
+\f
+           How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!
+
+
diff --git a/ChangeLog b/ChangeLog
new file mode 100755 (executable)
index 0000000..e69de29
diff --git a/HEXABLOCKPLUGIN_version.h.in b/HEXABLOCKPLUGIN_version.h.in
new file mode 100755 (executable)
index 0000000..3fc901b
--- /dev/null
@@ -0,0 +1,35 @@
+// Copyright (C) 2009-2012  CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+//  File   : HEXABLOCKPLUGIN_version.h
+//  Author : Lioka RAZAFINDRAZAKA (CEA)
+//  Module : SALOME
+//
+#if !defined(__HEXABLOCKPLUGIN_VERSION_H__)
+#define __HEXABLOCKPLUGIN_VERSION_H__
+
+/*
+  HEXABLOCKPLUGIN_VERSION is (major << 16) + (minor << 8) + patch.
+*/
+
+#define HEXABLOCKPLUGIN_VERSION_STR "@VERSION@"
+#define HEXABLOCKPLUGIN_VERSION     @XVERSION@
+#define HEXABLOCKPLUGIN_DEVELOPMENT @VERSION_DEV@
+
+#endif // __HEXABLOCKPLUGIN_VERSION_H__
diff --git a/INSTALL b/INSTALL
new file mode 100755 (executable)
index 0000000..9953d28
--- /dev/null
+++ b/INSTALL
@@ -0,0 +1 @@
+SALOME2 : HEXABLOCKPLUGIN module (SMESH plugin)
diff --git a/Makefile.am b/Makefile.am
new file mode 100755 (executable)
index 0000000..041ce58
--- /dev/null
@@ -0,0 +1,58 @@
+# Copyright (C) 2009-2012  CEA/DEN, EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+# -* Makefile *-
+# Author : Lioka RAZAFINDRAZAKA (CEA)
+# Date : 2010/11/08
+#  Modified by : Alexander BORODIN (OCN) - autotools usage
+# $Header:
+#
+include $(top_srcdir)/adm_local/unix/make_common_starter.am
+
+if HEXABLOCKPLUGIN_ENABLE_GUI
+  ACLOCAL_AMFLAGS = -I adm_local/unix/config_files \
+                    -I ${KERNEL_ROOT_DIR}/salome_adm/unix/config_files \
+                    -I ${GUI_ROOT_DIR}/adm_local/unix/config_files \
+                    -I ${MED_ROOT_DIR}/adm_local/unix/config_files \
+                    -I ${GEOM_ROOT_DIR}/adm_local/unix/config_files \
+                    -I ${HEXABLOCK_ROOT_DIR}/adm_local/unix/config_files \
+                    -I ${SMESH_ROOT_DIR}/adm_local/unix/config_files
+else !HEXABLOCKPLUGIN_ENABLE_GUI
+  ACLOCAL_AMFLAGS = -I adm_local/unix/config_files \
+                    -I ${KERNEL_ROOT_DIR}/salome_adm/unix/config_files \
+                    -I ${MED_ROOT_DIR}/adm_local/unix/config_files \
+                    -I ${GEOM_ROOT_DIR}/adm_local/unix/config_files \
+                    -I ${HEXABLOCK_ROOT_DIR}/adm_local/unix/config_files \
+                    -I ${SMESH_ROOT_DIR}/adm_local/unix/config_files
+endif
+
+SUBDIRS = idl adm_local resources src bin
+
+DIST_SUBDIRS = idl adm_local resources src bin 
+
+DISTCLEANFILES = a.out aclocal.m4 configure local-install.sh
+
+salomeinclude_DATA = HEXABLOCKPLUGIN_version.h
+
+EXTRA_DIST += \
+       build_configure \
+       clean_configure
+
+dist-hook:
+       rm -rf `find $(distdir) -name CVS`
diff --git a/NEWS b/NEWS
new file mode 100755 (executable)
index 0000000..e69de29
diff --git a/README b/README
new file mode 100755 (executable)
index 0000000..e69de29
diff --git a/adm_local/Makefile.am b/adm_local/Makefile.am
new file mode 100755 (executable)
index 0000000..a8219b0
--- /dev/null
@@ -0,0 +1,22 @@
+# Copyright (C) 2009-2012  CEA/DEN, EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+include $(top_srcdir)/adm_local/unix/make_common_starter.am
+
+SUBDIRS = unix
diff --git a/adm_local/unix/Makefile.am b/adm_local/unix/Makefile.am
new file mode 100755 (executable)
index 0000000..8473d5e
--- /dev/null
@@ -0,0 +1,22 @@
+# Copyright (C) 2009-2012  CEA/DEN, EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+include $(top_srcdir)/adm_local/unix/make_common_starter.am
+
+SUBDIRS = config_files
diff --git a/adm_local/unix/config_files/Makefile.am b/adm_local/unix/config_files/Makefile.am
new file mode 100755 (executable)
index 0000000..71cf40e
--- /dev/null
@@ -0,0 +1,23 @@
+# Copyright (C) 2009-2012  CEA/DEN, EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+include $(top_srcdir)/adm_local/unix/make_common_starter.am
+
+dist_admlocalm4_DATA =         \
+    check_HEXABLOCKPLUGIN.m4
diff --git a/adm_local/unix/config_files/check_HEXABLOCKPLUGIN.m4 b/adm_local/unix/config_files/check_HEXABLOCKPLUGIN.m4
new file mode 100755 (executable)
index 0000000..bb80030
--- /dev/null
@@ -0,0 +1,78 @@
+dnl Copyright (C) 2009-2012  CEA/DEN, EDF R&D
+dnl
+dnl This library is free software; you can redistribute it and/or
+dnl modify it under the terms of the GNU Lesser General Public
+dnl License as published by the Free Software Foundation; either
+dnl version 2.1 of the License.
+dnl
+dnl This library is distributed in the hope that it will be useful,
+dnl but WITHOUT ANY WARRANTY; without even the implied warranty of
+dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+dnl Lesser General Public License for more details.
+dnl
+dnl You should have received a copy of the GNU Lesser General Public
+dnl License along with this library; if not, write to the Free Software
+dnl Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+dnl
+dnl See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+dnl
+
+#  Check availability of HEXABLOCKPLUGIN binary distribution
+#
+#  Author : Lioka RAZAFINDRAZAKA (CEA)
+#------------------------------------------------------------
+
+AC_DEFUN([CHECK_HEXABLOCKPLUGIN],[
+
+HEXABLOCKPLUGIN_LDFLAGS=""
+HEXABLOCKPLUGIN_CXXFLAGS=""
+
+AC_CHECKING(for GHS3dPlugin)
+
+HEXABLOCKPLUGIN_ok=no
+
+AC_ARG_WITH(ghs,
+           --with-HEXABLOCKPlugin=DIR  root directory path of HEXABLOCKPLUGIN build or installation,
+           HEXABLOCKPLUGIN_DIR="$withval",HEXABLOCKPLUGIN_DIR="")
+
+if test "x$HEXABLOCKPLUGIN_DIR" = "x" ; then
+
+# no --with-gui-dir option used
+
+  if test "x$HEXABLOCKPLUGIN_ROOT_DIR" != "x" ; then
+
+    # SALOME_ROOT_DIR environment variable defined
+    HEXABLOCKPLUGIN_DIR=$HEXABLOCKPLUGIN_ROOT_DIR
+
+  else
+
+    # search Salome binaries in PATH variable
+    AC_PATH_PROG(TEMP, libHexaBlockEngine.so)
+    if test "x$TEMP" != "x" ; then
+      HEXABLOCKPLUGIN_DIR=`dirname $TEMP`
+    fi
+
+  fi
+
+fi
+
+if test -f ${HEXABLOCKPLUGIN_DIR}/lib/salome/libHexaBlockEngine.so  ; then
+  HEXABLOCKPLUGIN_ok=yes
+  AC_MSG_RESULT(Using HEXABLOCKPLUGIN module distribution in ${HEXABLOCKPLUGIN_DIR})
+
+  if test "x$HEXABLOCKPLUGIN_ROOT_DIR" == "x" ; then
+    HEXABLOCKPLUGIN_ROOT_DIR=${HEXABLOCKPLUGIN_DIR}
+  fi
+  HEXABLOCKPLUGIN_CXXFLAGS+=-I${HEXABLOCKPLUGIN_ROOT_DIR}/include/salome
+  HEXABLOCKPLUGIN_LDFLAGS+=-L${HEXABLOCKPLUGIN_ROOT_DIR}/lib${LIB_LOCATION_SUFFIX}/salome
+  AC_SUBST(HEXABLOCKPLUGIN_ROOT_DIR)
+  AC_SUBST(HEXABLOCKPLUGIN_LDFLAGS)
+  AC_SUBST(HEXABLOCKPLUGIN_CXXFLAGS)
+else
+  AC_MSG_WARN("Cannot find compiled HEXABLOCKPLUGIN module distribution")
+fi
+  
+AC_MSG_RESULT(for HEXABLOCKPLUGIN: $HEXABLOCKPLUGIN_ok)
+])dnl
diff --git a/adm_local/unix/make_common_starter.am b/adm_local/unix/make_common_starter.am
new file mode 100755 (executable)
index 0000000..ba9f279
--- /dev/null
@@ -0,0 +1,94 @@
+# Copyright (C) 2009-2012  CEA/DEN, EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+# ============================================================
+# The following is to avoid PACKAGE_... env variable
+# redefinition compilation warnings
+# ============================================================
+#
+AM_CXXFLAGS = @KERNEL_CXXFLAGS@ -include SALOMEconfig.h
+AM_CPPFLAGS = @KERNEL_CXXFLAGS@ -include SALOMEconfig.h
+
+# ============================================================
+# This file defines the common definitions used in several
+# Makefile. This file must be included, if needed, by the file
+# Makefile.am.
+# ============================================================
+# Standard directory for installation
+#
+salomeincludedir   = $(includedir)/salome
+libdir             = $(prefix)/lib@LIB_LOCATION_SUFFIX@/salome
+bindir             = $(prefix)/bin/salome
+salomescriptdir    = $(bindir)
+salomepythondir    = $(pythondir)/salome
+salomepyexecdir    = $(pyexecdir)/salome
+
+# Directory for installing idl files
+salomeidldir       = $(prefix)/idl/salome
+
+# Directory for installing resource files
+salomeresdir       = $(prefix)/share/salome/resources/@MODULE_NAME@
+
+# Directories for installing admin files
+admlocaldir        = $(prefix)/adm_local
+admlocalunixdir    = $(admlocaldir)/unix
+admlocalm4dir      = $(admlocaldir)/unix/config_files
+
+# Shared modules installation directory
+sharedpkgpythondir = $(salomepythondir)/shared_modules
+
+# Documentation directory
+docdir             = $(datadir)/doc/salome
+
+# common rules
+
+# meta object implementation files generation (moc)
+%_moc.cxx: %.h
+       $(MOC) $< -o $@
+
+# translation (*.qm) files generation (lrelease)
+%.qm: %.ts
+       $(LRELEASE) $< -qm $@
+
+# resource files generation (qrcc)
+qrc_%.cxx: %.qrc
+       $(QRCC) $< -o $@ -name $(*F)
+
+# qt forms files generation (uic)
+ui_%.h: %.ui
+       $(UIC) -o $@ $<
+
+# extra distributed files
+EXTRA_DIST = $(MOC_FILES:%_moc.cxx=%.h) $(QRC_FILES:qrc_%.cxx=%.qrc) \
+             $(UIC_FILES:ui_%.h=%.ui) $(nodist_salomeres_DATA:%.qm=%.ts)
+
+# customize clean operation
+mostlyclean-local:
+       rm -f @builddir@/*_moc.cxx
+       rm -f @builddir@/*.qm
+       rm -f @builddir@/ui_*.h
+       rm -f @builddir@/qrc_*.cxx
+
+# tests
+tests: unittest
+
+unittest: $(UNIT_TEST_PROG)
+       @if test "x$(UNIT_TEST_PROG)" != "x"; then \
+           $(UNIT_TEST_PROG);                     \
+       fi;
diff --git a/bin/Makefile.am b/bin/Makefile.am
new file mode 100755 (executable)
index 0000000..18059c1
--- /dev/null
@@ -0,0 +1,30 @@
+# Copyright (C) 2009-2012  CEA/DEN, EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+# -* Makefile *- 
+# Author : Lioka RAZAFINDRAZAKA (CEA)
+# Module : HEXABLOCKPLUGIN
+#
+include $(top_srcdir)/adm_local/unix/make_common_starter.am
+
+# non-distributed files 
+nodist_salomescript_DATA = VERSION
+
+# distributed files
+dist_salomescript_SCRIPTS =
diff --git a/bin/VERSION.in b/bin/VERSION.in
new file mode 100755 (executable)
index 0000000..5d92d97
--- /dev/null
@@ -0,0 +1,3 @@
+[SALOME HEXABLOCKPLUGIN] : @VERSION@
+[DEVELOPMENT]            : @VERSION_DEV@
+[DESCRIPTION]            : HEXABLOCK meshing plug-in for SALOME Mesh module
diff --git a/build_configure b/build_configure
new file mode 100755 (executable)
index 0000000..e3d4f52
--- /dev/null
@@ -0,0 +1,138 @@
+#!/bin/bash
+# Copyright (C) 2009-2012  CEA/DEN, EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+# Tool for updating list of .in file for the SALOME project 
+# and regenerating configure script
+# Author : Lioka RAZAFINDRAZAKA (CEA)
+# Date : 2010/11/08
+# $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
+
+########################################################################
+# Test if the GEOM_ROOT_DIR is set correctly
+
+if test ! -d "${GEOM_ROOT_DIR}"; then
+    echo "failed : GEOM_ROOT_DIR variable is not correct !"
+    exit
+fi
+
+########################################################################
+# Test if the HEXABLOCK_ROOT_DIR is set correctly
+
+if test ! -d "${HEXABLOCK_ROOT_DIR}"; then
+    echo "failed : HEXABLOCK_ROOT_DIR variable is not correct !"
+    exit
+fi
+
+########################################################################
+# Test if the MED_ROOT_DIR is set correctly
+
+if test ! -d "${MED_ROOT_DIR}"; then
+    echo "failed : MED_ROOT_DIR variable is not correct !"
+    exit
+fi
+
+########################################################################
+# Test if the SMESH_ROOT_DIR is set correctly
+
+if test ! -d "${SMESH_ROOT_DIR}"; then
+    echo "failed : SMESH_ROOT_DIR variable is not correct !"
+    exit
+fi
+
+cd ${CONF_DIR}
+ABS_CONF_DIR=`pwd`
+
+#######################################################################
+
+# ____________________________________________________________________
+# aclocal creates the aclocal.m4 file from the standard macro and the
+# custom macro embedded in the directory adm_local/unix/config_files
+# and KERNEL config_files directory.
+# output:
+#   aclocal.m4
+#   autom4te.cache (directory)
+echo "======================================================= aclocal"
+
+if test -d "${GUI_ROOT_DIR}"; then
+  aclocal -I adm_local/unix/config_files \
+          -I ${KERNEL_ROOT_DIR}/salome_adm/unix/config_files \
+          -I ${GUI_ROOT_DIR}/adm_local/unix/config_files \
+          -I ${MED_ROOT_DIR}/adm_local/unix/config_files \
+          -I ${GEOM_ROOT_DIR}/adm_local/unix/config_files \
+          -I ${HEXABLOCK_ROOT_DIR}/adm_local/unix/config_files \
+          -I ${SMESH_ROOT_DIR}/adm_local/unix/config_files || exit 1
+else
+  aclocal -I adm_local/unix/config_files \
+          -I ${KERNEL_ROOT_DIR}/salome_adm/unix/config_files \
+          -I ${MED_ROOT_DIR}/adm_local/unix/config_files \
+          -I ${GEOM_ROOT_DIR}/adm_local/unix/config_files \
+          -I ${HEXABLOCK_ROOT_DIR}/adm_local/unix/config_files \
+          -I ${SMESH_ROOT_DIR}/adm_local/unix/config_files || exit 1
+fi
+
+# ____________________________________________________________________
+# libtoolize creates some configuration files (ltmain.sh,
+# config.guess and config.sub). It only depends on the libtool
+# version. The files are created in the directory specified with the
+# AC_CONFIG_AUX_DIR(<mydir>) tag (see configure.ac).
+# output:
+#   adm_local/unix/config_files/config.guess
+#   adm_local/unix/config_files/config.sub
+#   adm_local/unix/config_files/ltmain.sh
+echo "==================================================== libtoolize"
+
+libtoolize --force --copy --automake || exit 1
+
+# ____________________________________________________________________
+# autoconf creates the configure script from the file configure.ac (or
+# configure.in if configure.ac doesn't exist)
+# output:
+#   configure
+echo "====================================================== autoconf"
+
+autoconf
+
+# ____________________________________________________________________
+# automake creates some scripts used in building process
+# (install-sh, missing, ...). It only depends on the automake
+# version. The files are created in the directory specified with the
+# AC_CONFIG_AUX_DIR(<mydir>) tag (see configure.ac). This step also
+# creates the Makefile.in files from the Makefile.am files.
+# output:
+#   adm_local/unix/config_files/compile
+#   adm_local/unix/config_files/depcomp
+#   adm_local/unix/config_files/install-sh
+#   adm_local/unix/config_files/missing
+#   adm_local/unix/config_files/py-compile
+#   Makefile.in (from Makefile.am)
+echo "====================================================== automake"
+
+automake --copy --gnu --add-missing
diff --git a/clean_configure b/clean_configure
new file mode 100755 (executable)
index 0000000..a5d9070
--- /dev/null
@@ -0,0 +1,25 @@
+#!/bin/sh
+# Copyright (C) 2009-2012  CEA/DEN, EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+rm -rf autom4te.cache aclocal.m4 configure make_config
+find . -name "*~" -print -exec rm {} \;
+find . -name "*.pyc" -print -exec rm {} \;
+find . -name Makefile.in | xargs rm -f
+( cd adm_local/unix/config_files && rm -f config.* depcomp install-sh l*.m4 ltmain.sh missing py-compile )
diff --git a/configure.ac b/configure.ac
new file mode 100755 (executable)
index 0000000..1fec193
--- /dev/null
@@ -0,0 +1,417 @@
+# Copyright (C) 2009-2012  CEA/DEN, EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+#  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 : Lioka RAZAFINDRAZAKA (CEA)
+# Date : 2010/11/08
+# Modified by : Patrick GOLDBRONN (CEA)
+# Modified by : Marc Tajchman (CEA)
+# Created from configure.in.base
+#
+AC_INIT([Salome2 Project HEXABLOCKPLUGIN module],[6.5.0], [webmaster.salome@opencascade.com], [SalomeHEXABLOCKPLUGIN])
+AC_CONFIG_AUX_DIR(adm_local/unix/config_files)
+AC_CANONICAL_HOST
+AC_CANONICAL_TARGET
+AM_INIT_AUTOMAKE([-Wno-portability])
+
+XVERSION=`echo $VERSION | awk -F. '{printf("0x%02x%02x%02x",$1,$2,$3)}'`
+AC_SUBST(XVERSION)
+VERSION_DEV=0
+AC_SUBST(VERSION_DEV)
+
+# set up MODULE_NAME variable for dynamic construction of directories (resources, etc.)
+MODULE_NAME=HEXABLOCKplugin
+AC_SUBST(MODULE_NAME)
+
+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
+
+AC_CHECK_PROG(SHELL,sh)
+AC_SUBST(SHELL)
+
+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
+AC_LOCAL_INSTALL
+dnl 
+dnl libtool macro check for CC, LD, NM, LN_S, RANLIB, STRIP + pour les librairies dynamiques !
+
+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}/adm_local/unix/config_files/install-sh -c"
+      ;;
+esac
+
+echo
+echo ---------------------------------------------
+echo testing C/C++
+echo ---------------------------------------------
+echo
+
+cc_ok=no
+dnl inutil car libtool
+dnl AC_PROG_CC
+AC_PROG_CXX
+AC_CXX_WARNINGS
+AC_CXX_TEMPLATE_OPTIONS
+AC_DEPEND_FLAG
+# AC_CC_WARNINGS([ansi])
+cc_ok=yes
+
+dnl Library libdl :
+AC_CHECK_LIB(dl,dlopen)
+
+dnl Library librt : for alpha/osf
+AC_CHECK_LIB(rt,nanosleep)
+
+dnl add library libm :
+AC_CHECK_LIB(m,ceil)
+
+dnl 
+dnl Well we use sstream which is not in gcc pre-2.95.3
+dnl We must test if it exists. If not, add it in include !
+dnl
+
+AC_CXX_HAVE_SSTREAM
+
+dnl
+dnl ---------------------------------------------
+dnl testing MPICH
+dnl ---------------------------------------------
+dnl
+
+dnl CHECK_MPICH
+
+echo
+echo ---------------------------------------------
+echo testing MPI
+echo ---------------------------------------------
+echo
+
+CHECK_MPI
+
+echo
+echo ---------------------------------------------
+echo testing LEX \& YACC
+echo ---------------------------------------------
+echo
+
+lex_yacc_ok=no
+AC_PROG_YACC
+AC_PROG_LEX
+lex_yacc_ok=yes
+
+echo
+echo ---------------------------------------------
+echo testing python
+echo ---------------------------------------------
+echo
+
+CHECK_PYTHON
+
+AM_PATH_PYTHON(2.3)
+
+dnl echo
+dnl echo ---------------------------------------------
+dnl echo testing java
+dnl echo ---------------------------------------------
+dnl echo
+
+dnl CHECK_JAVA
+
+echo
+echo ---------------------------------------------
+echo testing swig
+echo ---------------------------------------------
+echo
+
+CHECK_SWIG
+
+echo
+echo ---------------------------------------------
+echo testing threads
+echo ---------------------------------------------
+echo
+
+ENABLE_PTHREADS
+
+echo
+echo ---------------------------------------------
+echo testing omniORB
+echo ---------------------------------------------
+echo
+
+CHECK_OMNIORB
+
+dnl echo
+dnl echo ---------------------------------------------
+dnl echo testing mico
+dnl echo ---------------------------------------------
+dnl echo
+
+dnl CHECK_MICO
+
+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 GUI
+echo ---------------------------------------------
+echo
+
+CHECK_GUI_MODULE
+
+gui_ok=no
+if test "${SalomeGUI_need}" != "no" -a "${FullGUI_ok}" = "yes" ; then 
+  gui_ok=yes
+fi
+
+AM_CONDITIONAL(HEXABLOCKPLUGIN_ENABLE_GUI, [test "${gui_ok}" = "yes"])
+
+if test "${SalomeGUI_need}" == "yes"; then
+  if test "${FullGUI_ok}" != "yes"; then
+    AC_MSG_WARN(For configure HEXABLOCKPLUGIN module necessary full GUI!)
+  fi
+elif test "${SalomeGUI_need}" == "auto"; then
+  if test "${FullGUI_ok}" != "yes"; then
+    AC_MSG_WARN(Full GUI not found. Build will be done without GUI!)
+  fi
+elif test "${SalomeGUI_need}" == "no"; then
+  echo Build without GUI option has been chosen
+fi
+
+if test "${gui_ok}" = "yes"; then
+
+    echo
+    echo ---------------------------------------------
+    echo testing openGL
+    echo ---------------------------------------------
+    echo
+
+    CHECK_OPENGL
+
+    echo
+    echo ---------------------------------------------
+    echo testing QT
+    echo ---------------------------------------------
+    echo
+
+    CHECK_QT
+
+    echo
+    echo ---------------------------------------------
+    echo testing VTK
+    echo ---------------------------------------------
+    echo
+
+    CHECK_VTK
+fi
+
+echo
+echo ---------------------------------------------
+echo Testing HDF5
+echo ---------------------------------------------
+echo
+
+CHECK_HDF5
+
+echo
+echo ---------------------------------------------
+echo BOOST Library
+echo ---------------------------------------------
+echo
+
+CHECK_BOOST
+
+echo
+echo ---------------------------------------------
+echo Testing OpenCascade
+echo ---------------------------------------------
+echo
+
+CHECK_CAS
+
+echo
+echo ---------------------------------------------
+echo Testing html generators
+echo ---------------------------------------------
+echo
+
+CHECK_HTML_GENERATORS
+
+echo
+echo ---------------------------------------------
+echo Testing Kernel
+echo ---------------------------------------------
+echo
+
+CHECK_KERNEL
+
+echo
+echo ---------------------------------------------
+echo Testing Geom
+echo ---------------------------------------------
+echo
+
+CHECK_GEOM
+
+echo
+echo ---------------------------------------------
+echo Testing Med
+echo ---------------------------------------------
+echo
+
+CHECK_MED
+
+echo
+echo ---------------------------------------------
+echo Testing SMesh
+echo ---------------------------------------------
+echo
+
+CHECK_SMESH
+
+echo
+echo ---------------------------------------------
+echo Testing HEXABLOCK
+echo ---------------------------------------------
+echo
+
+CHECK_HEXABLOCK
+
+echo
+echo ---------------------------------------------
+echo Summary
+echo ---------------------------------------------
+echo
+
+echo Configure
+if test "${gui_ok}" = "yes"; then
+  variables="cc_ok boost_ok threads_ok omniORB_ok occ_ok doxygen_ok OpenGL_ok qt_ok vtk_ok Kernel_ok gui_ok Geom_ok Med_ok SMesh_ok HEXABLOCK_ok"
+elif test "${SalomeGUI_need}" != "no"; then
+  variables="cc_ok boost_ok threads_ok omniORB_ok occ_ok doxygen_ok Kernel_ok gui_ok Geom_ok Med_ok SMesh_ok HEXABLOCK_ok"
+else
+  variables="cc_ok boost_ok threads_ok omniORB_ok occ_ok doxygen_ok Kernel_ok Geom_ok Med_ok SMesh_ok HEXABLOCK_ok"
+fi
+
+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 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
+echo
+echo ---------------------------------------------
+echo generating Makefiles and configure files
+echo ---------------------------------------------
+echo
+
+AC_OUTPUT_COMMANDS([ \
+      chmod +x ./bin/*; \
+])
+
+# This list is initiated using autoscan and must be updated manually
+# when adding a new file <filename>.in to manage. When you execute
+# autoscan, the Makefile list is generated in the output file configure.scan.
+# This could be helpfull to update de configuration.
+AC_OUTPUT([ \
+  adm_local/Makefile \
+  adm_local/unix/Makefile \
+  adm_local/unix/config_files/Makefile \
+  bin/VERSION \
+  bin/Makefile \
+  HEXABLOCKPLUGIN_version.h \
+  src/Makefile \
+  src/HEXABLOCKPlugin/Makefile \
+  src/GUI/Makefile \
+  resources/Makefile \
+  idl/Makefile \
+  Makefile \
+])
diff --git a/env_HEXABLOCKPLUGIN_src.sh b/env_HEXABLOCKPLUGIN_src.sh
new file mode 100644 (file)
index 0000000..4578c00
--- /dev/null
@@ -0,0 +1,3 @@
+#------ HEXABLOCKPLUGIN_src ------
+export HEXABLOCKPLUGIN_SRC_DIR=${INST_ROOT}/HEXABLOCKPLUGIN_SRC_6.2.0
+##
diff --git a/idl/HEXABLOCKPlugin_Algorithm.idl b/idl/HEXABLOCKPlugin_Algorithm.idl
new file mode 100755 (executable)
index 0000000..8250c3d
--- /dev/null
@@ -0,0 +1,63 @@
+// Copyright (C) 2009-2012  CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+//  File   : HEXABLOCK_Algorithm.idl
+//  Author : Lioka RAZAFINDRAZAKA (CEA)
+//  $Header$
+//
+#ifndef _HEXABLOCK_Algorithm_IDL_
+#define _HEXABLOCK_Algorithm_IDL_
+
+#include "SALOME_Exception.idl"
+#include "SMESH_Hypothesis.idl"
+
+#include "Document.idl"
+/*!
+ * HEXABLOCKPlugin: interfaces to HEXABLOCK related hypotheses and algorithms
+ */
+module HEXABLOCKPlugin
+{
+
+  /*!
+   * HEXABLOCKPlugin_HEXABLOCK: interface of "hexaBlock" algorithm
+   */
+  interface HEXABLOCKPlugin_HEXABLOCK : SMESH::SMESH_3D_Algo
+  {
+  };
+
+  /*!
+   * Parameters of "HexaBlock" algorithm
+   */
+  interface HEXABLOCKPlugin_Hypothesis : SMESH::SMESH_Hypothesis
+  {
+    /*!
+     * Define the document to be meshed, mandatory
+     */
+    void SetDocument(in HEXABLOCK_ORB::Document doc);
+    HEXABLOCK_ORB::Document GetDocument();
+
+    /*!
+     * To define the hight dimension to generated: 3 = hexas, 2 = quads, 1 = segments, 0 = nodes
+     */
+    void SetDimension(in long dim);
+    long GetDimension();
+  };
+};
+
+#endif
diff --git a/idl/Makefile.am b/idl/Makefile.am
new file mode 100755 (executable)
index 0000000..9d5ca99
--- /dev/null
@@ -0,0 +1,129 @@
+# Copyright (C) 2009-2012  CEA/DEN, EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+# This Makefile is responsible of generating the client and server
+# implementation of IDL interfaces for both C++ and python usage.
+# The building process of the C++ files is in charge of each source
+# package and then is not manage here.
+#
+include $(top_srcdir)/adm_local/unix/make_common_starter.am
+
+BASEIDL_FILES = HEXABLOCKPlugin_Algorithm.idl
+
+BASEIDL_FILES_PY=$(BASEIDL_FILES:%.idl=%_idl.py)
+
+# This variable defines the files to be installed
+dist_salomeidl_DATA = $(BASEIDL_FILES)
+
+# GUI idl common library
+lib_LTLIBRARIES = libSalomeIDLHEXABLOCKPLUGIN.la
+
+# Sources built from idl files
+nodist_libSalomeIDLHEXABLOCKPLUGIN_la_SOURCES = \
+       HEXABLOCKPlugin_AlgorithmSK.cc \
+       HEXABLOCKPlugin_AlgorithmDynSK.cc
+HEXABLOCKPlugin_AlgorithmDynSK.cc: HEXABLOCKPlugin_AlgorithmSK.cc
+
+# header files must be exported: other modules have to use this library
+nodist_salomeinclude_HEADERS = $(BASEIDL_FILES:%.idl=%.hh)
+
+libSalomeIDLHEXABLOCKPLUGIN_la_CPPFLAGS = \
+       -I$(top_builddir)/idl \
+       $(CORBA_CXXFLAGS) \
+       $(CORBA_INCLUDES) \
+       $(KERNEL_CXXFLAGS) \
+       $(GEOM_CXXFLAGS) \
+       $(HEXABLOCK_CXXFLAGS) \
+       $(SMESH_CXXFLAGS)
+
+libSalomeIDLHEXABLOCKPLUGIN_la_LDFLAGS = -no-undefined -version-info=0:0:0
+libSalomeIDLHEXABLOCKPLUGIN_la_LIBADD  = \
+       $(KERNEL_LDFLAGS) -lSalomeIDLKernel \
+       $(GEOM_LDFLAGS) -lSalomeIDLGEOM \
+       $(HEXABLOCK_LDFLAGS) -lSalomeIDLHEXABLOCK \
+       $(SMESH_LDFLAGS) -lSalomeIDLSMESH \
+       @CORBA_LIBS@
+
+# These variables defines the building process of CORBA files
+OMNIORB_IDL         = @OMNIORB_IDL@
+OMNIORB_IDLCXXFLAGS = @OMNIORB_IDLCXXFLAGS@
+OMNIORB_IDLPYFLAGS  = \
+       @OMNIORB_IDLPYFLAGS@ \
+       -I$(top_builddir)/idl/salome \
+       -I$(KERNEL_ROOT_DIR)/idl/salome \
+       -I$(GEOM_ROOT_DIR)/idl/salome \
+       -I$(HEXABLOCK_ROOT_DIR)/idl/salome \
+       -I$(SMESH_ROOT_DIR)/idl/salome
+
+IDLCXXFLAGS = \
+       -bcxx \
+       @IDLCXXFLAGS@ \
+       -I$(top_builddir)/idl/salome \
+       -I$(KERNEL_ROOT_DIR)/idl/salome \
+       -I$(GEOM_ROOT_DIR)/idl/salome \
+       -I$(HEXABLOCK_ROOT_DIR)/idl/salome \
+       -I$(SMESH_ROOT_DIR)/idl/salome
+IDLPYFLAGS  = \
+       @IDLPYFLAGS@ \
+       -I$(KERNEL_ROOT_DIR)/idl/salome \
+       -I$(GEOM_ROOT_DIR)/idl/salome \
+       -I$(HEXABLOCK_ROOT_DIR)/idl/salome \
+       -I$(SMESH_ROOT_DIR)/idl/salome
+
+# potential problem on parallel make on the following - multiple outputs
+SUFFIXES = .idl .hh SK.cc
+.idlSK.cc:
+       $(OMNIORB_IDL) $(IDLCXXFLAGS) $(OMNIORB_IDLCXXFLAGS) $<
+.idl.hh:
+       $(OMNIORB_IDL) $(IDLCXXFLAGS) $(OMNIORB_IDLCXXFLAGS) $<
+
+install-exec-local: $(BASEIDL_FILES:%=$(top_srcdir)/idl/%)
+       $(INSTALL) -d  $(DESTDIR)$(salomepythondir)
+       ls $^ | while read file; do \
+         $(OMNIORB_IDL) $(IDLPYFLAGS) -C$(DESTDIR)$(salomepythondir) $$file ; \
+       done
+
+# we want to remove only staff generated for IDL files and nothing more
+uninstall-local:
+       @for modulen in HEXABLOCKPlugin ; do \
+         test -d $(DESTDIR)$(salomepythondir)/$${modulen} && echo "Removing $(DESTDIR)$(salomepythondir)/$${modulen}" && rm -rf $(DESTDIR)$(salomepythondir)/$${modulen} ; \
+         test -d $(DESTDIR)$(salomepythondir)/$${modulen}__POA && echo "Removing $(DESTDIR)$(salomepythondir)/$${modulen}__POA" && rm -rf $(DESTDIR)$(salomepythondir)/$${modulen}__POA ; \
+       done ; \
+       for filen in $(BASEIDL_FILES_PY) ; do \
+         echo "Removing $(DESTDIR)$(salomepythondir)/$${filen}" && rm -f $(DESTDIR)$(salomepythondir)/$${filen}* ; \
+       done
+
+mostlyclean-local:
+       -rm -f *.hh *.cc .depidl
+
+# we use cpp to generate dependencies between idl files.
+# option x c tells the preprocessor to consider idl as a c file.
+# if an idl is modified, all idl dependencies are rebuilt
+
+.depidl: $(BASEIDL_FILES)
+       @echo "" > $@
+       @for dep in $^ dummy; do \
+         if [ $$dep != "dummy" ]; then \
+           echo Building dependencies for $$dep; \
+           $(CPP) $(C_DEPEND_FLAG) -x c -I$(srcdir) -I$(KERNEL_ROOT_DIR)/idl/salome -I$(GEOM_ROOT_DIR)/idl/salome -I$(HEXABLOCK_ROOT_DIR)/idl/salome -I$(SMESH_ROOT_DIR)/idl/salome $$dep 2>/dev/null | \
+           sed 's/\.o/\SK.cc/' >>$@; \
+         fi; \
+       done ;
+
+-include .depidl
diff --git a/resources/HEXABLOCKPlugin.xml b/resources/HEXABLOCKPlugin.xml
new file mode 100755 (executable)
index 0000000..a5c7c29
--- /dev/null
@@ -0,0 +1,52 @@
+<?xml version='1.0' encoding='us-ascii'?>
+<!DOCTYPE meshers PUBLIC "" "desktop.dtd">
+<!--
+  Copyright (C) 2009-2012  CEA/DEN, EDF R&D
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+
+  See http:www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+
+-->
+
+<!--  GUI customization for MESH component  -->
+
+<meshers>
+
+<meshers-group name="HEXABLOCK"
+               resources="HEXABLOCKPlugin"
+               server-lib="HEXABLOCKEngine"
+               gui-lib="HEXABLOCKPluginGUI">
+
+  <hypotheses>
+    <hypothesis type="HEXABLOCK_Parameters"
+               label-id="HEXABLOCK_Parameters"
+               icon-id="mesh_hypo_HEXABLOCK.png"
+               dim="3"/>
+  </hypotheses>
+
+  <algorithms>
+    <algorithm type="HEXABLOCK_3D"
+               label-id="Hexahedron (HEXABLOCK)"
+               icon-id="mesh_tree_hypo_HEXABLOCK.png"
+              need-geom="false"
+               hypos="HEXABLOCK_Parameters"
+               dim="3"
+               support-submeshes="false"
+               />
+  </algorithms>
+</meshers-group>
+
+</meshers>
diff --git a/resources/Makefile.am b/resources/Makefile.am
new file mode 100755 (executable)
index 0000000..0e89788
--- /dev/null
@@ -0,0 +1,36 @@
+# Copyright (C) 2009-2012  CEA/DEN, EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+# -* Makefile *- 
+# Author : Lioka RAZAFINDRAZAKA (CEA)
+# Date : 2010/11/08
+#  Modified by : Alexander BORODIN (OCN) - autotools usage
+# $Header$
+#
+include $(top_srcdir)/adm_local/unix/make_common_starter.am
+
+dist_salomeres_DATA =          \
+       HEXABLOCKPlugin.xml             \
+       SalomeApp.xml
+
+if HEXABLOCKPLUGIN_ENABLE_GUI
+  dist_salomeres_DATA +=       \
+       mesh_hypo_HEXABLOCK.png \
+       mesh_tree_hypo_HEXABLOCK.png
+endif
diff --git a/resources/SalomeApp.xml b/resources/SalomeApp.xml
new file mode 100755 (executable)
index 0000000..64e860a
--- /dev/null
@@ -0,0 +1,29 @@
+<!--
+  Copyright (C) 2009-2012  CEA/DEN, EDF R&D
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+
+  See http:www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+
+-->
+<document>
+  <section name="resources">
+    <parameter name="HEXABLOCKPlugin" value="${HEXABLOCKPLUGIN_ROOT_DIR}/share/salome/resources/HEXABLOCKplugin"/>
+  </section>
+  <section name="SMESH">
+    <!-- Default SMESH module plugins -->
+    <parameter name="plugins" value="HEXABLOCKPlugin"/>
+  </section>
+</document>
diff --git a/resources/mesh_hypo_HEXABLOCK.png b/resources/mesh_hypo_HEXABLOCK.png
new file mode 100755 (executable)
index 0000000..3fb67d5
Binary files /dev/null and b/resources/mesh_hypo_HEXABLOCK.png differ
diff --git a/resources/mesh_tree_hypo_HEXABLOCK.png b/resources/mesh_tree_hypo_HEXABLOCK.png
new file mode 100755 (executable)
index 0000000..ad5e9f3
Binary files /dev/null and b/resources/mesh_tree_hypo_HEXABLOCK.png differ
diff --git a/src/GUI/HEXABLOCKPluginGUI_HypothesisCreator.cxx b/src/GUI/HEXABLOCKPluginGUI_HypothesisCreator.cxx
new file mode 100755 (executable)
index 0000000..4f4d2f9
--- /dev/null
@@ -0,0 +1,822 @@
+// Copyright (C) 2009-2012  CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+//  HEXABLOCKPlugin GUI: GUI for plugged-in mesher HEXABLOCKPlugin
+//  File   : HEXABLOCKPluginGUI_HypothesisCreator.cxx
+//  Author : Lioka RAZAFINDRAZAKA (CEA)
+//  Module : HEXABLOCKPlugin
+//  $Header: 
+//
+#include "HEXABLOCKPluginGUI_HypothesisCreator.h"
+
+#include <SMESHGUI_Utils.h>
+#include <SMESHGUI_HypothesesUtils.h>
+
+#include <SUIT_Session.h>
+#include <SUIT_MessageBox.h>
+#include <SUIT_ResourceMgr.h>
+#include <SUIT_FileDlg.h>
+#include <SalomeApp_Tools.h>
+#include <SalomeApp_TypeFilter.h>
+
+#include <QComboBox>
+#include <QLabel>
+#include <QFrame>
+#include <QVBoxLayout>
+#include <QGridLayout>
+#include <QLineEdit>
+#include <QCheckBox>
+#include <QTabWidget>
+#include <QSpinBox>
+#include <QPushButton>
+#include <QFileInfo>
+
+#include <QTableWidget>
+#include <QStandardItemModel>
+#include <QStandardItem>
+#include <QHeaderView>
+#include <QModelIndexList>
+
+#include <stdexcept>
+#include <utilities.h>
+
+#ifdef _DEBUG_
+static int MYDEBUG = 1;
+#else
+static int MYDEBUG = 0;
+#endif
+
+
+// tabs
+enum {
+  STD_TAB = 0,
+  ADV_TAB,
+  ENF_VER_TAB
+};
+
+// Enforced vertices array columns
+enum {
+  ENF_VER_X_COLUMN = 0,
+  ENF_VER_Y_COLUMN,
+  ENF_VER_Z_COLUMN,
+  ENF_VER_SIZE_COLUMN,
+  ENF_VER_NB_COLUMNS
+};
+
+// Enforced vertices inputs
+enum {
+  ENF_VER_BTNS = 0,
+  ENF_VER_X_COORD,
+  ENF_VER_Y_COORD,
+  ENF_VER_Z_COORD,
+  ENF_VER_SIZE,
+  ENF_VER_VERTEX_BTN,
+  ENF_VER_SEPARATOR,
+  ENF_VER_REMOVE_BTN,
+};
+
+namespace {
+
+#ifdef WIN32
+#include <windows.h>
+#else
+#include <sys/sysinfo.h>
+#endif
+
+  int maxAvailableMemory()
+  {
+#ifdef WIN32
+    // See http://msdn.microsoft.com/en-us/library/aa366589.aspx
+    MEMORYSTATUSEX statex;
+    statex.dwLength = sizeof (statex);
+    int err = GlobalMemoryStatusEx (&statex);
+    if (err != 0) {
+      int totMB = 
+        statex.ullTotalPhys / 1024 / 1024 +
+        statex.ullTotalPageFile / 1024 / 1024 +
+        statex.ullTotalVirtual / 1024 / 1024;
+      return (int) ( 0.7 * totMB );
+    }
+#else
+    struct sysinfo si;
+    int err = sysinfo( &si );
+    if ( err == 0 ) {
+      int totMB =
+        si.totalram * si.mem_unit / 1024 / 1024 +
+        si.totalswap * si.mem_unit / 1024 / 1024 ;
+      return (int) ( 0.7 * totMB );
+    }
+#endif
+    return 0;
+  }
+}
+
+class QDoubleValidator;
+
+//
+// BEGIN DoubleLineEditDelegate
+//
+
+DoubleLineEditDelegate::DoubleLineEditDelegate(QObject *parent)
+    : QItemDelegate(parent)
+{
+}
+
+QWidget *DoubleLineEditDelegate::createEditor(QWidget *parent,
+    const QStyleOptionViewItem &/* option */,
+    const QModelIndex &/* index */) const
+{
+    QLineEdit *editor = new QLineEdit(parent);
+    editor->setValidator(new QDoubleValidator(parent));
+
+    return editor;
+}
+
+void DoubleLineEditDelegate::setEditorData(QWidget *editor,
+                                    const QModelIndex &index) const
+{
+    QString value = index.model()->data(index, Qt::EditRole).toString();
+
+    QLineEdit *lineEdit = static_cast<QLineEdit*>(editor);
+    lineEdit->setText(value);
+}
+
+void DoubleLineEditDelegate::setModelData(QWidget *editor, QAbstractItemModel *model,
+                                    const QModelIndex &index) const
+{
+    QLineEdit *lineEdit = static_cast<QLineEdit*>(editor);
+    bool ok;
+    double value = lineEdit->text().toDouble(&ok);
+
+    if (ok) {
+        model->setData(index, value, Qt::EditRole);
+        if(MYDEBUG) MESSAGE("Value " << value << " was set at index(" << index.row() << "," << index.column() << ")");
+    }
+}
+
+void DoubleLineEditDelegate::updateEditorGeometry(QWidget *editor,
+    const QStyleOptionViewItem &option, const QModelIndex &/* index */) const
+{
+    editor->setGeometry(option.rect);
+}
+
+//
+// END DoubleLineEditDelegate
+//
+
+HEXABLOCKPluginGUI_HypothesisCreator::HEXABLOCKPluginGUI_HypothesisCreator( const QString& theHypType )
+: SMESHGUI_GenericHypothesisCreator( theHypType )
+{
+}
+
+HEXABLOCKPluginGUI_HypothesisCreator::~HEXABLOCKPluginGUI_HypothesisCreator()
+{
+}
+
+QFrame* HEXABLOCKPluginGUI_HypothesisCreator::buildFrame()
+{
+  QFrame* fr = new QFrame( 0 );
+  QVBoxLayout* lay = new QVBoxLayout( fr );
+  lay->setMargin( 5 );
+  lay->setSpacing( 0 );
+
+  // tab
+  QTabWidget* tab = new QTabWidget( fr );
+  tab->setTabShape( QTabWidget::Rounded );
+  tab->setTabPosition( QTabWidget::North );
+  lay->addWidget( tab );
+
+  // basic parameters
+  myStdGroup = new QWidget();
+  QGridLayout* aStdLayout = new QGridLayout( myStdGroup );
+  aStdLayout->setSpacing( 6 );
+  aStdLayout->setMargin( 11 );
+
+  int row = 0;
+  myName = 0;
+  if( isCreation() )
+  {
+    aStdLayout->addWidget( new QLabel( tr( "SMESH_NAME" ), myStdGroup ), row, 0, 1, 1 );
+    myName = new QLineEdit( myStdGroup );
+    aStdLayout->addWidget( myName, row++, 1, 1, 1 );
+  }
+
+  myToMeshHolesCheck = new QCheckBox( tr( "HEXABLOCK_TO_MESH_HOLES" ), myStdGroup );
+  aStdLayout->addWidget( myToMeshHolesCheck, row++, 0, 1, 2 );
+
+  aStdLayout->addWidget( new QLabel( tr( "HEXABLOCK_OPTIMIZATIOL_LEVEL" ), myStdGroup ), row, 0 );
+  myOptimizationLevelCombo = new QComboBox( myStdGroup );
+  aStdLayout->addWidget( myOptimizationLevelCombo, row++, 1, 1, 1 );
+
+  QStringList types;
+  types << tr( "LEVEL_NONE" ) << tr( "LEVEL_LIGHT" ) << tr( "LEVEL_MEDIUM" ) << tr( "LEVEL_STANDARDPLUS" ) << tr( "LEVEL_STRONG" );
+  myOptimizationLevelCombo->addItems( types );
+
+  aStdLayout->setRowStretch( row, 5 );
+
+  // advanced parameters
+  myAdvGroup = new QWidget();
+  QGridLayout* anAdvLayout = new QGridLayout( myAdvGroup );
+  anAdvLayout->setSpacing( 6 );
+  anAdvLayout->setMargin( 11 );
+  
+  myMaximumMemoryCheck = new QCheckBox( tr( "MAX_MEMORY_SIZE" ), myAdvGroup );
+  myMaximumMemorySpin = new QSpinBox( myAdvGroup );
+  myMaximumMemorySpin->setMinimum( 1 );
+  myMaximumMemorySpin->setMaximum( maxAvailableMemory() );
+  myMaximumMemorySpin->setSingleStep( 10 );
+  QLabel* aMegabyteLabel = new QLabel( tr( "MEGABYTE" ), myAdvGroup );
+
+  myInitialMemoryCheck = new QCheckBox( tr( "INIT_MEMORY_SIZE" ), myAdvGroup );
+  myInitialMemorySpin = new QSpinBox( myAdvGroup );
+  myInitialMemorySpin->setMinimum( 1 );
+  myInitialMemorySpin->setMaximum( maxAvailableMemory() );
+  myInitialMemorySpin->setSingleStep( 10 );
+  QLabel* aMegabyteLabel2 = new QLabel( tr( "MEGABYTE" ), myAdvGroup );
+
+  QLabel* aWorkinDirLabel = new QLabel( tr( "WORKING_DIR" ), myAdvGroup );
+  myWorkingDir = new QLineEdit( myAdvGroup );
+  //myWorkingDir->setReadOnly( true );
+  QPushButton* dirBtn = new QPushButton( tr( "SELECT_DIR" ), myAdvGroup );
+  dirBtn->setSizePolicy( QSizePolicy( QSizePolicy::Fixed, QSizePolicy::Fixed ) );
+  
+  myKeepFiles = new QCheckBox( tr( "KEEP_WORKING_FILES" ), myAdvGroup );
+
+  QLabel* aVerboseLevelLabel = new QLabel( tr( "VERBOSE_LEVEL" ), myAdvGroup );
+  myVerboseLevelSpin = new QSpinBox( myAdvGroup );
+  myVerboseLevelSpin->setMinimum( 0 );
+  myVerboseLevelSpin->setMaximum( 10 );
+  myVerboseLevelSpin->setSingleStep( 1 );
+
+  myToCreateNewNodesCheck = new QCheckBox( tr( "TO_ADD_NODES" ), myAdvGroup );
+  
+  myRemoveInitialCentralPointCheck = new QCheckBox( tr( "NO_INITIAL_CENTRAL_POINT" ), myAdvGroup );
+  
+  myBoundaryRecoveryCheck = new QCheckBox( tr( "RECOVERY_VERSION" ), myAdvGroup );
+  
+  myFEMCorrectionCheck = new QCheckBox( tr( "FEM_CORRECTION" ), myAdvGroup );
+
+  QLabel* aTextOptionLabel = new QLabel( tr( "TEXT_OPTION" ), myAdvGroup );
+  myTextOption = new QLineEdit( myAdvGroup );
+
+  anAdvLayout->addWidget( myMaximumMemoryCheck,             0, 0, 1, 1 );
+  anAdvLayout->addWidget( myMaximumMemorySpin,              0, 1, 1, 1 );
+  anAdvLayout->addWidget( aMegabyteLabel,                   0, 2, 1, 1 );
+  anAdvLayout->addWidget( myInitialMemoryCheck,             1, 0, 1, 1 );
+  anAdvLayout->addWidget( myInitialMemorySpin,              1, 1, 1, 1 );
+  anAdvLayout->addWidget( aMegabyteLabel2,                  1, 2, 1, 1 );
+  anAdvLayout->addWidget( aWorkinDirLabel,                  2, 0, 1, 1 );
+  anAdvLayout->addWidget( myWorkingDir,                     2, 1, 1, 2 );
+  anAdvLayout->addWidget( dirBtn,                           2, 3, 1, 1 );
+  anAdvLayout->addWidget( myKeepFiles,                      3, 0, 1, 4 );
+  anAdvLayout->addWidget( aVerboseLevelLabel,               4, 0, 1, 1 );
+  anAdvLayout->addWidget( myVerboseLevelSpin,               4, 1, 1, 1 );
+  anAdvLayout->addWidget( myToCreateNewNodesCheck,          5, 0, 1, 4 );
+  anAdvLayout->addWidget( myRemoveInitialCentralPointCheck, 6, 0, 1, 4 );
+  anAdvLayout->addWidget( myBoundaryRecoveryCheck,          7, 0, 1, 4 );
+  anAdvLayout->addWidget( myFEMCorrectionCheck,             8, 0, 1, 4 );
+  anAdvLayout->addWidget( aTextOptionLabel,                 9, 0, 1, 1 );
+  anAdvLayout->addWidget( myTextOption,                     9, 1, 1, 2 );
+
+  // Size Maps parameters
+  myEnfGroup = new QWidget();
+  QGridLayout* anSmpLayout = new QGridLayout(myEnfGroup);
+  
+  mySmpModel = new QStandardItemModel(0, ENF_VER_NB_COLUMNS);
+  myEnforcedTableView = new QTableView(myEnfGroup);
+  myEnforcedTableView->setModel(mySmpModel);
+  myEnforcedTableView->setSortingEnabled(true);
+  myEnforcedTableView->setItemDelegateForColumn(ENF_VER_SIZE_COLUMN,new DoubleLineEditDelegate(this));
+  anSmpLayout->addWidget(myEnforcedTableView, 1, 0, 9, 1);
+  QStringList enforcedHeaders;
+  enforcedHeaders << tr( "HEXABLOCK_ENF_VER_X_COLUMN" )<< tr( "HEXABLOCK_ENF_VER_Y_COLUMN" ) << tr( "HEXABLOCK_ENF_VER_Z_COLUMN" ) << tr( "HEXABLOCK_ENF_VER_SIZE_COLUMN" ); 
+  mySmpModel->setHorizontalHeaderLabels(enforcedHeaders);
+  myEnforcedTableView->setAlternatingRowColors(true);
+  myEnforcedTableView->verticalHeader()->hide();
+  myEnforcedTableView->horizontalHeader()->setResizeMode(QHeaderView::Stretch);
+  
+  QLabel* myXCoordLabel = new QLabel( tr( "HEXABLOCK_ENF_VER_X_LABEL" ), myEnfGroup );
+  anSmpLayout->addWidget(myXCoordLabel, ENF_VER_X_COORD, 1, 1, 1);
+  myXCoord = new QLineEdit(myEnfGroup);
+  myXCoord->setValidator(new QDoubleValidator(myEnfGroup));
+  anSmpLayout->addWidget(myXCoord, ENF_VER_X_COORD, 2, 1, 1);
+  QLabel* myYCoordLabel = new QLabel( tr( "HEXABLOCK_ENF_VER_Y_LABEL" ), myEnfGroup );
+  anSmpLayout->addWidget(myYCoordLabel, ENF_VER_Y_COORD, 1, 1, 1);
+  myYCoord = new QLineEdit(myEnfGroup);
+  myYCoord->setValidator(new QDoubleValidator(myEnfGroup));
+  anSmpLayout->addWidget(myYCoord, ENF_VER_Y_COORD, 2, 1, 1);
+  QLabel* myZCoordLabel = new QLabel( tr( "HEXABLOCK_ENF_VER_Z_LABEL" ), myEnfGroup );
+  anSmpLayout->addWidget(myZCoordLabel, ENF_VER_Z_COORD, 1, 1, 1);
+  myZCoord = new QLineEdit(myEnfGroup);
+  myZCoord->setValidator(new QDoubleValidator(myEnfGroup));
+  anSmpLayout->addWidget(myZCoord, ENF_VER_Z_COORD, 2, 1, 1);
+  QLabel* mySizeLabel = new QLabel( tr( "HEXABLOCK_ENF_VER_SIZE_LABEL" ), myEnfGroup );
+  anSmpLayout->addWidget(mySizeLabel, ENF_VER_SIZE, 1, 1, 1);
+  mySizeValue = new QLineEdit(myEnfGroup);
+  mySizeValue->setValidator(new QDoubleValidator(myEnfGroup));
+  anSmpLayout->addWidget(mySizeValue, ENF_VER_SIZE, 2, 1, 1);
+
+  addVertexButton = new QPushButton(tr("HEXABLOCK_ENF_VER_VERTEX"),myEnfGroup);
+  anSmpLayout->addWidget(addVertexButton, ENF_VER_VERTEX_BTN, 1, 1, 2);
+  addVertexButton->setEnabled(false);
+
+  QFrame *line = new QFrame(myEnfGroup);
+  line->setFrameShape(QFrame::HLine);
+  line->setFrameShadow(QFrame::Sunken);
+  anSmpLayout->addWidget(line, ENF_VER_SEPARATOR, 1, 1, 2);
+
+  removeVertexButton = new QPushButton(tr("HEXABLOCK_ENF_VER_REMOVE"),myEnfGroup);
+  anSmpLayout->addWidget(removeVertexButton, ENF_VER_REMOVE_BTN, 1, 1, 2);
+          
+  // add tabs
+  tab->insertTab( STD_TAB, myStdGroup, tr( "SMESH_ARGUMENTS" ) );
+  tab->insertTab( ADV_TAB, myAdvGroup, tr( "HEXABLOCK_ADV_ARGS" ) );
+  tab->insertTab( ENF_VER_TAB, myEnfGroup, tr( "HEXABLOCK_ENFORCED_VERTICES" ) );
+  tab->setCurrentIndex( STD_TAB );
+
+  // connections
+  connect( myMaximumMemoryCheck,    SIGNAL( toggled( bool ) ), this, SLOT( updateWidgets() ) );
+  connect( myInitialMemoryCheck,    SIGNAL( toggled( bool ) ), this, SLOT( updateWidgets() ) );
+  connect( myBoundaryRecoveryCheck, SIGNAL( toggled( bool ) ), this, SLOT( updateWidgets() ) );
+  connect( dirBtn,                  SIGNAL( clicked() ),       this, SLOT( onDirBtnClicked() ) );
+  connect( myXCoord,                SIGNAL( textChanged(const QString&) ),   this, SLOT( checkVertexIsDefined() ) );
+  connect( myYCoord,                SIGNAL( textChanged(const QString&) ),   this, SLOT( checkVertexIsDefined() ) );
+  connect( myZCoord,                SIGNAL( textChanged(const QString&) ),   this, SLOT( checkVertexIsDefined() ) );
+  connect( mySizeValue,             SIGNAL( textChanged(const QString&) ),   this, SLOT( checkVertexIsDefined() ) );
+  connect( this,                    SIGNAL( vertexDefined(bool) ), addVertexButton, SLOT( setEnabled(bool) ) );
+  connect( addVertexButton,         SIGNAL( clicked() ),       this, SLOT( onVertexBtnClicked() ) );
+  connect( removeVertexButton,      SIGNAL( clicked() ),       this, SLOT( onRemoveVertexBtnClicked() ) );
+  
+
+  
+  return fr;
+}
+
+bool HEXABLOCKPluginGUI_HypothesisCreator::smpVertexExists(double x, double y, double z) const
+{
+    const int rowCount = mySmpModel->rowCount();
+    for (int i=0 ; i < rowCount ; i++) {
+      double myX = mySmpModel->data(mySmpModel->index(i, ENF_VER_X_COLUMN)).toDouble();
+      if (myX == x) {
+//         MESSAGE("Found x value " << x << " at row " << i);
+        double myY = mySmpModel->data(mySmpModel->index(i, ENF_VER_Y_COLUMN)).toDouble();
+        if (myY == y) {
+//           MESSAGE("Found y value " << y << " at row " << i);
+          double myZ = mySmpModel->data(mySmpModel->index(i, ENF_VER_Z_COLUMN)).toDouble();
+          if (myZ == z) {
+            if (MYDEBUG){
+              MESSAGE("Found x value " << x << " at row " << i);
+              MESSAGE("Found y value " << y << " at row " << i);
+              MESSAGE("Found z value " << z << " at row " << i);
+            }
+            return true;
+          }
+        }
+      }
+    }
+//     MESSAGE("Not found x,y,z values: " << x << " " << y << " " << z);
+    return false;
+}
+
+bool HEXABLOCKPluginGUI_HypothesisCreator::checkVertexIsDefined()
+{
+  bool val = (!myXCoord->text().isEmpty())&&(!myYCoord->text().isEmpty())&&(!myZCoord->text().isEmpty())&&(!mySizeValue->text().isEmpty());
+  bool isDefined = val;
+  if (val)
+    isDefined = ! smpVertexExists(myXCoord->text().toDouble(),myYCoord->text().toDouble(),myZCoord->text().toDouble());
+
+  emit vertexDefined(isDefined);
+  return isDefined;
+}
+
+void HEXABLOCKPluginGUI_HypothesisCreator::onVertexBtnClicked()
+{
+    if (MYDEBUG) MESSAGE("HEXABLOCKPluginGUI_HypothesisCreator::onVertexBtnClicked()");
+    const int row = mySmpModel->rowCount() ;
+    double x = myXCoord->text().toDouble();
+    double y = myYCoord->text().toDouble();
+    double z = myZCoord->text().toDouble();
+    double size = mySizeValue->text().toDouble();
+    
+    if (smpVertexExists(x,y,z)) return;
+    
+//     double size = 10.0;
+    // ENF_VER_X_COLUMN
+    mySmpModel->setData(mySmpModel->index(row, ENF_VER_X_COLUMN),x);
+    mySmpModel->setItem( row, ENF_VER_X_COLUMN, new QStandardItem(QString::number(x)) );
+    mySmpModel->item( row, ENF_VER_X_COLUMN )->setFlags( Qt::ItemIsSelectable );
+    // ENF_VER_Y_COLUMN
+    mySmpModel->setData(mySmpModel->index(row, ENF_VER_Y_COLUMN),y);
+    mySmpModel->setItem( row, ENF_VER_Y_COLUMN, new QStandardItem(QString::number(y)) );
+    mySmpModel->item( row, ENF_VER_Y_COLUMN )->setFlags( Qt::ItemIsSelectable );
+    // ENF_VER_Z_COLUMN
+    mySmpModel->setData(mySmpModel->index(row, ENF_VER_Z_COLUMN),z);
+    mySmpModel->setItem( row, ENF_VER_Z_COLUMN, new QStandardItem(QString::number(z)) );
+    mySmpModel->item( row, ENF_VER_Z_COLUMN )->setFlags( Qt::ItemIsSelectable );
+    // ENF_VER_SIZE_COLUMN
+    mySmpModel->setData(mySmpModel->index(row, ENF_VER_SIZE_COLUMN),size);
+    mySmpModel->setItem( row, ENF_VER_SIZE_COLUMN, new QStandardItem(QString::number(size,'f')) );
+
+    myEnforcedTableView->clearSelection();
+    myEnforcedTableView->scrollTo( mySmpModel->item( row, ENF_VER_SIZE_COLUMN )->index() );
+    checkVertexIsDefined();
+}
+
+void HEXABLOCKPluginGUI_HypothesisCreator::onRemoveVertexBtnClicked()
+{
+    QList<int> selectedRows;
+    QList<QModelIndex> selectedIndex = myEnforcedTableView->selectionModel()->selectedIndexes();
+    int row;
+    QModelIndex index;
+    foreach( index, selectedIndex ) {
+        row = index.row();
+        if ( !selectedRows.contains( row ) ) 
+        selectedRows.append( row );
+    }
+    qSort( selectedRows );
+    QListIterator<int> it( selectedRows );
+    it.toBack();
+    while ( it.hasPrevious() ) {
+        row = it.previous();
+        if (MYDEBUG) MESSAGE("delete row #"<< row);
+        mySmpModel->removeRow(row );
+    }
+    myEnforcedTableView->clearSelection();
+}
+void HEXABLOCKPluginGUI_HypothesisCreator::onDirBtnClicked()
+{
+  QString dir = SUIT_FileDlg::getExistingDirectory( dlg(), myWorkingDir->text(), QString() );
+  if ( !dir.isEmpty() )
+    myWorkingDir->setText( dir );
+}
+
+void HEXABLOCKPluginGUI_HypothesisCreator::updateWidgets()
+{
+  myMaximumMemorySpin->setEnabled( myMaximumMemoryCheck->isChecked() );
+  myInitialMemoryCheck->setEnabled( !myBoundaryRecoveryCheck->isChecked() );
+  myInitialMemorySpin->setEnabled( myInitialMemoryCheck->isChecked() && !myBoundaryRecoveryCheck->isChecked() );
+  myOptimizationLevelCombo->setEnabled( !myBoundaryRecoveryCheck->isChecked() );
+}
+
+bool HEXABLOCKPluginGUI_HypothesisCreator::checkParams(QString& msg) const
+{
+  if (MYDEBUG) MESSAGE("HEXABLOCKPluginGUI_HypothesisCreator::checkParams");
+
+  if ( !QFileInfo( myWorkingDir->text().trimmed() ).isWritable() ) {
+    SUIT_MessageBox::warning( dlg(),
+                              tr( "SMESH_WRN_WARNING" ),
+                              tr( "HEXABLOCK_PERMISSION_DENIED" ) );
+    return false;
+  }
+
+  return true;
+}
+
+void HEXABLOCKPluginGUI_HypothesisCreator::retrieveParams() const
+{
+  if (MYDEBUG) MESSAGE("HEXABLOCKPluginGUI_HypothesisCreator::retrieveParams");
+  HEXABLOCKHypothesisData data;
+  readParamsFromHypo( data );
+
+  if ( myName )
+    myName->setText( data.myName );
+  
+  myToMeshHolesCheck               ->setChecked    ( data.myToMeshHoles );
+  myOptimizationLevelCombo         ->setCurrentIndex( data.myOptimizationLevel );
+  myMaximumMemoryCheck             ->setChecked    ( data.myMaximumMemory > 0 );
+  myMaximumMemorySpin              ->setValue      ( qMax( data.myMaximumMemory,
+                                                           myMaximumMemorySpin->minimum() ));
+  myInitialMemoryCheck             ->setChecked    ( data.myInitialMemory > 0 );
+  myInitialMemorySpin              ->setValue      ( qMax( data.myInitialMemory,
+                                                           myInitialMemorySpin->minimum() ));
+  myWorkingDir                     ->setText       ( data.myWorkingDir );
+  myKeepFiles                      ->setChecked    ( data.myKeepFiles );
+  myVerboseLevelSpin               ->setValue      ( data.myVerboseLevel );
+  myToCreateNewNodesCheck          ->setChecked    ( data.myToCreateNewNodes );
+  myRemoveInitialCentralPointCheck ->setChecked    ( data.myRemoveInitialCentralPoint );
+  myBoundaryRecoveryCheck          ->setChecked    ( data.myBoundaryRecovery );
+  myFEMCorrectionCheck             ->setChecked    ( data.myFEMCorrection );
+  myTextOption                     ->setText       ( data.myTextOption );
+
+  TEnforcedVertexValues::const_iterator it;
+  int row = 0;
+  for(it = data.myEnforcedVertices.begin() ; it != data.myEnforcedVertices.end(); it++ )
+  {
+    double x = it->at(0);
+    double y = it->at(1);
+    double z = it->at(2);
+    double size = it->at(3);
+    // ENF_VER_X_COLUMN
+    mySmpModel->setData(mySmpModel->index(row, ENF_VER_X_COLUMN),x);
+    mySmpModel->setItem( row, ENF_VER_X_COLUMN, new QStandardItem(QString::number(x)) );
+    mySmpModel->item( row, ENF_VER_X_COLUMN )->setFlags( Qt::ItemIsSelectable );
+    // ENF_VER_Y_COLUMN
+    mySmpModel->setData(mySmpModel->index(row, ENF_VER_Y_COLUMN),y);
+    mySmpModel->setItem( row, ENF_VER_Y_COLUMN, new QStandardItem(QString::number(y)) );
+    mySmpModel->item( row, ENF_VER_Y_COLUMN )->setFlags( Qt::ItemIsSelectable );
+    // ENF_VER_Z_COLUMN
+    mySmpModel->setData(mySmpModel->index(row, ENF_VER_Z_COLUMN),z);
+    mySmpModel->setItem( row, ENF_VER_Z_COLUMN, new QStandardItem(QString::number(z)) );
+    mySmpModel->item( row, ENF_VER_Z_COLUMN )->setFlags( Qt::ItemIsSelectable );
+    // ENF_VER_SIZE_COLUMN
+    mySmpModel->setData(mySmpModel->index(row, ENF_VER_SIZE_COLUMN),size);
+    mySmpModel->setItem( row, ENF_VER_SIZE_COLUMN, new QStandardItem(QString::number(size)) );
+
+    if (MYDEBUG) MESSAGE("Row " << row << ": (" << x << ","<< y << ","<< z << ") ="<< size);
+    row++;
+  }
+  
+  HEXABLOCKPluginGUI_HypothesisCreator* that = (HEXABLOCKPluginGUI_HypothesisCreator*)this;
+  that->updateWidgets();
+}
+
+QString HEXABLOCKPluginGUI_HypothesisCreator::storeParams() const
+{
+    if (MYDEBUG) MESSAGE("HEXABLOCKPluginGUI_HypothesisCreator::storeParams");
+    HEXABLOCKHypothesisData data;
+    readParamsFromWidgets( data );
+    storeParamsToHypo( data );
+    
+    QString valStr = "";
+    
+    if ( !data.myBoundaryRecovery )
+        valStr = "-c " + QString::number( !data.myToMeshHoles );
+    
+    if ( data.myOptimizationLevel >= 0 && data.myOptimizationLevel < 5 && !data.myBoundaryRecovery) {
+        const char* level[] = { "none" , "light" , "standard" , "standard+" , "strong" };
+        valStr += " -o ";
+        valStr += level[ data.myOptimizationLevel ];
+    }
+    if ( data.myMaximumMemory > 0 ) {
+        valStr += " -m ";
+        valStr += QString::number( data.myMaximumMemory );
+    }
+    if ( data.myInitialMemory > 0 && !data.myBoundaryRecovery ) {
+        valStr += " -M ";
+        valStr += QString::number( data.myInitialMemory );
+    }
+    valStr += " -v ";
+    valStr += QString::number( data.myVerboseLevel );
+    
+    if ( !data.myToCreateNewNodes )
+        valStr += " -p0";
+    
+    if ( data.myRemoveInitialCentralPoint )
+        valStr += " -no_initial_central_point";
+    
+    if ( data.myBoundaryRecovery )
+        valStr += " -C";
+    
+    if ( data.myFEMCorrection )
+        valStr += " -FEM";
+    
+    valStr += " ";
+    valStr += data.myTextOption;
+    
+    valStr += " #BEGIN ENFORCED VERTICES#";
+    // Add size map parameters storage
+    for (int i=0 ; i<mySmpModel->rowCount() ; i++) {
+        valStr += " (";
+        double x = mySmpModel->data(mySmpModel->index(i,ENF_VER_X_COLUMN)).toDouble();
+        double y = mySmpModel->data(mySmpModel->index(i,ENF_VER_Y_COLUMN)).toDouble();
+        double z = mySmpModel->data(mySmpModel->index(i,ENF_VER_Z_COLUMN)).toDouble();
+        double size = mySmpModel->data(mySmpModel->index(i,ENF_VER_SIZE_COLUMN)).toDouble();
+        valStr += QString::number( x );
+        valStr += ",";
+        valStr += QString::number( y );
+        valStr += ",";
+        valStr += QString::number( z );
+        valStr += ")=";
+        valStr += QString::number( size );
+        if (i!=mySmpModel->rowCount()-1)
+            valStr += ";";
+    }
+    valStr += " #END ENFORCED VERTICES#";
+    if (MYDEBUG) MESSAGE(valStr.toStdString());
+  return valStr;
+}
+
+bool HEXABLOCKPluginGUI_HypothesisCreator::readParamsFromHypo( HEXABLOCKHypothesisData& h_data ) const
+{
+  if (MYDEBUG) MESSAGE("HEXABLOCKPluginGUI_HypothesisCreator::readParamsFromHypo");
+  HEXABLOCKPlugin::HEXABLOCKPlugin_Hypothesis_var h =
+    HEXABLOCKPlugin::HEXABLOCKPlugin_Hypothesis::_narrow( initParamsHypothesis() );
+
+  HypothesisData* data = SMESH::GetHypothesisData( hypType() );
+  h_data.myName = isCreation() && data ? hypName() : "";
+
+  /* fkl to update:
+  h_data.myToMeshHoles                = h->GetToMeshHoles();
+  h_data.myMaximumMemory              = h->GetMaximumMemory();
+  h_data.myInitialMemory              = h->GetInitialMemory();
+  h_data.myInitialMemory              = h->GetInitialMemory();
+  h_data.myOptimizationLevel          = h->GetOptimizationLevel();
+  h_data.myKeepFiles                  = h->GetKeepFiles();
+  h_data.myWorkingDir                 = h->GetWorkingDirectory();
+  h_data.myVerboseLevel               = h->GetVerboseLevel();
+  h_data.myToCreateNewNodes           = h->GetToCreateNewNodes();
+  h_data.myRemoveInitialCentralPoint  = h->GetToRemoveCentralPoint();
+  h_data.myBoundaryRecovery           = h->GetToUseBoundaryRecoveryVersion();
+  h_data.myFEMCorrection              = h->GetFEMCorrection();
+  h_data.myTextOption                 = h->GetTextOption();
+
+  HEXABLOCKPlugin::HEXABLOCKEnforcedVertexList_var vertices = h->GetEnforcedVertices();
+  MESSAGE("vertices->length(): " << vertices->length());
+  h_data.myEnforcedVertices.clear();
+  for (int i=0 ; i<vertices->length() ; i++) {
+    HEXABLOCKEnforcedVertex myVertex;
+    myVertex.push_back(vertices[i].x);
+    myVertex.push_back(vertices[i].y);
+    myVertex.push_back(vertices[i].z);
+    myVertex.push_back(vertices[i].size);
+    MESSAGE("Add enforced vertex ("<< myVertex[0] << ","<< myVertex[1] << ","<< myVertex[2] << ") ="<< myVertex[3]);
+    h_data.myEnforcedVertices.push_back(myVertex);
+  }
+  */
+
+  return true;
+}
+
+bool HEXABLOCKPluginGUI_HypothesisCreator::storeParamsToHypo( const HEXABLOCKHypothesisData& h_data ) const
+{
+  if (MYDEBUG) MESSAGE("HEXABLOCKPluginGUI_HypothesisCreator::storeParamsToHypo");
+  HEXABLOCKPlugin::HEXABLOCKPlugin_Hypothesis_var h =
+    HEXABLOCKPlugin::HEXABLOCKPlugin_Hypothesis::_narrow( hypothesis() );
+
+  bool ok = true;
+  try
+  {
+    if( isCreation() )
+      SMESH::SetName( SMESH::FindSObject( h ), h_data.myName.toLatin1().constData() );
+
+    /* fkl to update:
+    if ( h->GetToMeshHoles() != h_data.myToMeshHoles ) // avoid duplication of DumpPython commands
+      h->SetToMeshHoles      ( h_data.myToMeshHoles       );
+    if ( h->GetMaximumMemory() != h_data.myMaximumMemory )
+      h->SetMaximumMemory    ( h_data.myMaximumMemory     );
+    if ( h->GetInitialMemory() != h_data.myInitialMemory )
+      h->SetInitialMemory    ( h_data.myInitialMemory     );
+    if ( h->GetInitialMemory() != h_data.myInitialMemory )
+      h->SetInitialMemory    ( h_data.myInitialMemory     );
+    if ( h->GetOptimizationLevel() != h_data.myOptimizationLevel )
+      h->SetOptimizationLevel( h_data.myOptimizationLevel );
+    if ( h->GetKeepFiles() != h_data.myKeepFiles )
+      h->SetKeepFiles        ( h_data.myKeepFiles         );
+    if ( h->GetWorkingDirectory() != h_data.myWorkingDir )
+      h->SetWorkingDirectory ( h_data.myWorkingDir.toLatin1().constData() );
+    if ( h->GetVerboseLevel() != h_data.myVerboseLevel )
+      h->SetVerboseLevel     ( h_data.myVerboseLevel );
+    if ( h->GetToCreateNewNodes() != h_data.myToCreateNewNodes )
+      h->SetToCreateNewNodes( h_data.myToCreateNewNodes );
+    if ( h->GetToRemoveCentralPoint() != h_data.myRemoveInitialCentralPoint )
+      h->SetToRemoveCentralPoint( h_data.myRemoveInitialCentralPoint );
+    if ( h->GetToUseBoundaryRecoveryVersion() != h_data.myBoundaryRecovery )
+      h->SetToUseBoundaryRecoveryVersion( h_data.myBoundaryRecovery );
+    if ( h->GetFEMCorrection() != h_data.myFEMCorrection )
+      h->SetFEMCorrection( h_data.myFEMCorrection );
+    if ( h->GetTextOption() != h_data.myTextOption )
+      h->SetTextOption       ( h_data.myTextOption.toLatin1().constData() );
+    
+    int nbVertex = (int) h_data.myEnforcedVertices.size();
+    HEXABLOCKPlugin::HEXABLOCKEnforcedVertexList_var vertexHyp = h->GetEnforcedVertices();
+    int nbVertexHyp = vertexHyp->length();
+    
+    MESSAGE("Store params for size maps: " << nbVertex << " enforced vertices");
+    MESSAGE("h->GetEnforcedVertices()->length(): " << nbVertexHyp);
+    
+    // Some vertices were removed
+    if (nbVertex < nbVertexHyp) {
+//        if (nbVertex == 0)
+//            h->ClearEnforcedVertices();
+//        else {
+            // iterate over vertices of hypo
+            for(int i = 0 ; i <nbVertexHyp ; i++) {
+                double x = vertexHyp[i].x;
+                double y = vertexHyp[i].y;
+                double z = vertexHyp[i].z;
+                // vertex is removed
+                if (!smpVertexExists(x,y,z))
+                    h->RemoveEnforcedVertex(x,y,z);
+            }
+//        }
+    }
+    
+    TEnforcedVertexValues::const_iterator it;
+    for(it = h_data.myEnforcedVertices.begin() ; it != h_data.myEnforcedVertices.end(); it++ ) {
+      double x = it->at(0);
+      double y = it->at(1);
+      double z = it->at(2);
+      double size = it->at(3);
+      MESSAGE("(" << x   << ", "
+                       << y   << ", "
+                       << z   << ") = "
+                       << size  );
+      double mySize;
+      try {
+        mySize = h->GetEnforcedVertex(x,y,z);
+        MESSAGE("Old size: " << mySize);
+        if (mySize != size) {
+          MESSAGE("Setting new size: " << size);
+          h->SetEnforcedVertex(x,y,z,size);
+        }
+      }
+      catch (...) {
+        MESSAGE("Setting new size: " << size);
+        h->SetEnforcedVertex(x,y,z,size);
+      }
+    }
+    */
+  }
+  catch ( const SALOME::SALOME_Exception& ex )
+  {
+    SalomeApp_Tools::QtCatchCorbaException( ex );
+    ok = false;
+  }
+  return ok;
+}
+
+bool HEXABLOCKPluginGUI_HypothesisCreator::readParamsFromWidgets( HEXABLOCKHypothesisData& h_data ) const
+{
+  if (MYDEBUG) MESSAGE("HEXABLOCKPluginGUI_HypothesisCreator::readParamsFromWidgets");
+  h_data.myName                       = myName ? myName->text() : "";
+  h_data.myToMeshHoles                = myToMeshHolesCheck->isChecked();
+  h_data.myMaximumMemory              = myMaximumMemoryCheck->isChecked() ? myMaximumMemorySpin->value() : -1;
+  h_data.myInitialMemory              = myInitialMemoryCheck->isChecked() ? myInitialMemorySpin->value() : -1;
+  h_data.myOptimizationLevel          = myOptimizationLevelCombo->currentIndex();
+  h_data.myKeepFiles                  = myKeepFiles->isChecked();
+  h_data.myWorkingDir                 = myWorkingDir->text().trimmed();
+  h_data.myVerboseLevel               = myVerboseLevelSpin->value();
+  h_data.myToCreateNewNodes           = myToCreateNewNodesCheck->isChecked();
+  h_data.myRemoveInitialCentralPoint  = myRemoveInitialCentralPointCheck->isChecked();
+  h_data.myBoundaryRecovery           = myBoundaryRecoveryCheck->isChecked();
+  h_data.myFEMCorrection              = myFEMCorrectionCheck->isChecked();
+  h_data.myTextOption                 = myTextOption->text();
+  h_data.myEnforcedVertices.clear();
+
+  for (int i=0 ; i<mySmpModel->rowCount() ; i++) {
+    HEXABLOCKEnforcedVertex myVertex;
+    myVertex.push_back(mySmpModel->data(mySmpModel->index(i,ENF_VER_X_COLUMN)).toDouble());
+    myVertex.push_back(mySmpModel->data(mySmpModel->index(i,ENF_VER_Y_COLUMN)).toDouble());
+    myVertex.push_back(mySmpModel->data(mySmpModel->index(i,ENF_VER_Z_COLUMN)).toDouble());
+    myVertex.push_back(mySmpModel->data(mySmpModel->index(i,ENF_VER_SIZE_COLUMN)).toDouble());
+    if (MYDEBUG) MESSAGE("Add new enforced vertex (" << myVertex[0] << ", "
+                                             << myVertex[1] << ", "
+                                             << myVertex[2] << ") = "
+                                             << myVertex[3]);
+    h_data.myEnforcedVertices.push_back(myVertex);
+  }
+
+  return true;
+}
+
+QString HEXABLOCKPluginGUI_HypothesisCreator::caption() const
+{
+  return tr( "HEXABLOCK_TITLE" );
+}
+
+QPixmap HEXABLOCKPluginGUI_HypothesisCreator::icon() const
+{
+  return SUIT_Session::session()->resourceMgr()->loadPixmap( "HEXABLOCKPlugin", tr( "ICON_DLG_HEXABLOCK_PARAMETERS" ) );
+}
+
+QString HEXABLOCKPluginGUI_HypothesisCreator::type() const
+{
+  return tr( "HEXABLOCK_HYPOTHESIS" );
+}
+
+QString HEXABLOCKPluginGUI_HypothesisCreator::helpPage() const
+{
+  return "HEXABLOCK_hypo_page.html";
+}
+
+//=============================================================================
+/*! GetHypothesisCreator
+ *
+ */
+//=============================================================================
+extern "C"
+{
+  HEXABLOCKPLUGINGUI_EXPORT
+  SMESHGUI_GenericHypothesisCreator* GetHypothesisCreator( const QString& aHypType )
+  {
+    if ( aHypType == "HEXABLOCK_Parameters" )
+      return new HEXABLOCKPluginGUI_HypothesisCreator( aHypType );
+    return 0;
+  }
+}
diff --git a/src/GUI/HEXABLOCKPluginGUI_HypothesisCreator.h b/src/GUI/HEXABLOCKPluginGUI_HypothesisCreator.h
new file mode 100755 (executable)
index 0000000..d2ecc42
--- /dev/null
@@ -0,0 +1,161 @@
+// Copyright (C) 2009-2012  CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+//  HEXABLOCKPlugin GUI: GUI for plugged-in mesher HEXABLOCKPlugin
+//  File   : HEXABLOCKPluginGUI_HypothesisCreator.h
+//  Author : Lioka RAZAFINDRAZAKA (CEA)
+//  Module : HEXABLOCKPlugin
+//
+#ifndef HEXABLOCKPLUGINGUI_HypothesisCreator_HeaderFile
+#define HEXABLOCKPLUGINGUI_HypothesisCreator_HeaderFile
+
+#ifdef WIN32
+  #if defined HEXABLOCKPluginGUI_EXPORTS
+    #define HEXABLOCKPLUGINGUI_EXPORT __declspec( dllexport )
+  #else
+    #define HEXABLOCKPLUGINGUI_EXPORT __declspec( dllimport )
+  #endif
+#else
+  #define HEXABLOCKPLUGINGUI_EXPORT
+#endif
+
+#include <SMESHGUI_Hypotheses.h>
+// #include <SalomeApp_DoubleSpinBox.h>
+
+#include <QItemDelegate>
+#include <map>
+#include <vector>
+#include CORBA_SERVER_HEADER(HEXABLOCKPlugin_Algorithm)
+
+class QWidget;
+class QComboBox;
+class QCheckBox;
+class QLineEdit;
+class QSpinBox;
+class QStandardItemModel;
+class QTableView;
+class QHeaderView;
+class QDoubleSpinBox;
+
+class LightApp_SelectionMgr;
+
+typedef std::vector<double> HEXABLOCKEnforcedVertex;
+typedef std::vector<HEXABLOCKEnforcedVertex> TEnforcedVertexValues;
+
+typedef struct
+{
+  bool    myToMeshHoles,myKeepFiles,myToCreateNewNodes,myBoundaryRecovery,myFEMCorrection,myRemoveInitialCentralPoint;
+  int     myMaximumMemory,myInitialMemory,myOptimizationLevel;
+  QString myName,myWorkingDir,myTextOption;
+  short   myVerboseLevel;
+  TEnforcedVertexValues myEnforcedVertices;
+} HEXABLOCKHypothesisData;
+
+/*!
+  \brief Class for creation of HEXABLOCK2D and HEXABLOCK3D hypotheses
+*/
+class HEXABLOCKPLUGINGUI_EXPORT HEXABLOCKPluginGUI_HypothesisCreator : public SMESHGUI_GenericHypothesisCreator
+{
+  Q_OBJECT
+
+public:
+  HEXABLOCKPluginGUI_HypothesisCreator( const QString& );
+  virtual ~HEXABLOCKPluginGUI_HypothesisCreator();
+
+  virtual bool     checkParams(QString& msg) const;
+  virtual QString  helpPage() const;
+
+protected:
+  virtual QFrame*  buildFrame    ();
+  virtual void     retrieveParams() const;
+  virtual QString  storeParams   () const;
+
+  virtual QString  caption() const;
+  virtual QPixmap  icon() const;
+  virtual QString  type() const;
+
+protected slots:
+  void                onDirBtnClicked();
+  void                updateWidgets();
+  void                onVertexBtnClicked();
+  void                onRemoveVertexBtnClicked();
+  bool                checkVertexIsDefined();
+
+signals:
+  void                vertexDefined(bool);
+
+private:
+  bool                readParamsFromHypo( HEXABLOCKHypothesisData& ) const;
+  bool                readParamsFromWidgets( HEXABLOCKHypothesisData& ) const;
+  bool                storeParamsToHypo( const HEXABLOCKHypothesisData& ) const;
+  bool                smpVertexExists(double, double, double) const;
+
+private:
+  QWidget*            myStdGroup;
+  QLineEdit*          myName;
+  QCheckBox*          myToMeshHolesCheck;
+  QComboBox*          myOptimizationLevelCombo;
+
+  QWidget*            myAdvGroup;
+  QCheckBox*          myMaximumMemoryCheck;
+  QSpinBox*           myMaximumMemorySpin;
+  QCheckBox*          myInitialMemoryCheck;
+  QSpinBox*           myInitialMemorySpin;
+  QLineEdit*          myWorkingDir;
+  QCheckBox*          myKeepFiles;
+  QSpinBox*           myVerboseLevelSpin;
+  QCheckBox*          myToCreateNewNodesCheck;
+  QCheckBox*          myRemoveInitialCentralPointCheck;
+  QCheckBox*          myBoundaryRecoveryCheck;
+  QCheckBox*          myFEMCorrectionCheck;
+QLineEdit*            myTextOption;
+  
+  QWidget*            myEnfGroup;
+  QStandardItemModel* mySmpModel;
+  QTableView*         myEnforcedTableView;
+  QLineEdit*          myXCoord;
+  QLineEdit*          myYCoord;
+  QLineEdit*          myZCoord;
+  QLineEdit*          mySizeValue;
+  QPushButton*        addVertexButton;
+  QPushButton*        removeVertexButton;
+  
+  LightApp_SelectionMgr*  mySelectionMgr;          /* User shape selection */
+//   SVTK_Selector*          mySelector;
+};
+
+class DoubleLineEditDelegate : public QItemDelegate
+{
+    Q_OBJECT
+
+public:
+    DoubleLineEditDelegate(QObject *parent = 0);
+
+    QWidget *createEditor(QWidget *parent, const QStyleOptionViewItem &option,
+                        const QModelIndex &index) const;
+
+    void setEditorData(QWidget *editor, const QModelIndex &index) const;
+    void setModelData(QWidget *editor, QAbstractItemModel *model,
+                    const QModelIndex &index) const;
+
+    void updateEditorGeometry(QWidget *editor,
+        const QStyleOptionViewItem &option, const QModelIndex &index) const;
+};
+
+#endif
diff --git a/src/GUI/HEXABLOCKPlugin_images.ts b/src/GUI/HEXABLOCKPlugin_images.ts
new file mode 100755 (executable)
index 0000000..2b8aff0
--- /dev/null
@@ -0,0 +1,38 @@
+<!DOCTYPE TS>
+<!--
+  Copyright (C) 2009-2011  CEA/DEN, EDF R&D
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+
+  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+
+-->
+<TS version="1.1" >
+    <context>
+        <name>@default</name>
+        <message>
+            <source>ICON_DLG_HEXABLOCK_PARAMETERS</source>
+            <translation>mesh_hypo_HEXABLOCK.png</translation>
+        </message>
+        <message>
+            <source>ICON_SMESH_TREE_ALGO_HEXABLOCK_3D</source>
+            <translation>mesh_tree_hypo_HEXABLOCK.png</translation>
+        </message>
+        <message>
+            <source>ICON_SMESH_TREE_HYPO_HEXABLOCK_Parameters</source>
+            <translation>mesh_tree_hypo_HEXABLOCK.png</translation>
+        </message>
+    </context>
+</TS>
diff --git a/src/GUI/HEXABLOCKPlugin_msg_en.ts b/src/GUI/HEXABLOCKPlugin_msg_en.ts
new file mode 100755 (executable)
index 0000000..229650f
--- /dev/null
@@ -0,0 +1,166 @@
+<!DOCTYPE TS>
+<!--
+  Copyright (C) 2009-2011  CEA/DEN, EDF R&D
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+
+  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+
+-->
+<TS version="1.1" >
+    <context>
+        <name>@default</name>
+        <message>
+            <source>HEXABLOCK_ADV_ARGS</source>
+            <translation>Advanced</translation>
+        </message>
+        <message>
+            <source>HEXABLOCK_HYPOTHESIS</source>
+            <translation>HEXABLOCK</translation>
+        </message>
+        <message>
+            <source>HEXABLOCK_OPTIMIZATIOL_LEVEL</source>
+            <translation>Optimization level</translation>
+        </message>
+        <message>
+            <source>HEXABLOCK_PERMISSION_DENIED</source>
+            <translation>Working directory is not writable</translation>
+        </message>
+        <message>
+            <source>HEXABLOCK_STD_ARGS</source>
+            <translation>Parameters</translation>
+        </message>
+        <message>
+            <source>HEXABLOCK_TITLE</source>
+            <translation>Hypothesis Construction</translation>
+        </message>
+        <message>
+            <source>HEXABLOCK_TO_MESH_HOLES</source>
+            <translation>To mesh holes</translation>
+        </message>
+        <message>
+            <source>INIT_MEMORY_SIZE</source>
+            <translation>Initial memory size</translation>
+        </message>
+        <message>
+            <source>KEEP_WORKING_FILES</source>
+            <translation>To keep working files</translation>
+        </message>
+        <message>
+            <source>LEVEL_NONE</source>
+            <translation>None</translation>
+        </message>
+        <message>
+            <source>LEVEL_LIGHT</source>
+            <translation>Light</translation>
+        </message>
+        <message>
+            <source>LEVEL_MEDIUM</source>
+            <translation>Medium (standard)</translation>
+        </message>
+        <message>
+            <source>LEVEL_STANDARDPLUS</source>
+            <translation>Standard+</translation>
+        </message>
+        <message>
+            <source>LEVEL_STRONG</source>
+            <translation>Strong</translation>
+        </message>
+        <message>
+            <source>MAX_MEMORY_SIZE</source>
+            <translation>Maximum memory size</translation>
+        </message>
+        <message>
+            <source>MEGABYTE</source>
+            <translation>Megabytes</translation>
+        </message>
+        <message>
+            <source>NO_INITIAL_CENTRAL_POINT</source>
+            <translation>To remove initial central point</translation>
+        </message>
+        <message>
+            <source>RECOVERY_VERSION</source>
+            <translation>To use boundary recovery version</translation>
+        </message>
+        <message>
+            <source>FEM_CORRECTION</source>
+            <translation>To use FEM correction</translation>
+        </message>
+        <message>
+            <source>SELECT_DIR</source>
+            <translation>...</translation>
+        </message>
+        <message>
+            <source>TEXT_OPTION</source>
+            <translation>Option as text</translation>
+        </message>
+        <message>
+            <source>TO_ADD_NODES</source>
+            <translation>To create new nodes</translation>
+        </message>
+        <message>
+            <source>VERBOSE_LEVEL</source>
+            <translation>Verbose level</translation>
+        </message>
+        <message>
+            <source>WORKING_DIR</source>
+            <translation>Working directory</translation>
+        </message>
+        <message>
+            <source>HEXABLOCK_ENFORCED_VERTICES</source>
+            <translation>Enforced vertices</translation>
+        </message>
+        <message>
+            <source>HEXABLOCK_ENF_VER_X_COLUMN</source>
+            <translation>X</translation>
+        </message>
+        <message>
+            <source>HEXABLOCK_ENF_VER_Y_COLUMN</source>
+            <translation>Y</translation>
+        </message>
+        <message>
+            <source>HEXABLOCK_ENF_VER_Z_COLUMN</source>
+            <translation>Z</translation>
+        </message>
+        <message>
+            <source>HEXABLOCK_ENF_VER_SIZE_COLUMN</source>
+            <translation>Size</translation>
+        </message>
+        <message>
+            <source>HEXABLOCK_ENF_VER_X_LABEL</source>
+            <translation>X:</translation>
+        </message>
+        <message>
+            <source>HEXABLOCK_ENF_VER_Y_LABEL</source>
+            <translation>Y:</translation>
+        </message>
+        <message>
+            <source>HEXABLOCK_ENF_VER_Z_LABEL</source>
+            <translation>Z:</translation>
+        </message>
+        <message>
+            <source>HEXABLOCK_ENF_VER_SIZE_LABEL</source>
+            <translation>Size:</translation>
+        </message>
+        <message>
+            <source>HEXABLOCK_ENF_VER_VERTEX</source>
+            <translation>Add enforced vertex</translation>
+        </message>
+        <message>
+            <source>HEXABLOCK_ENF_VER_REMOVE</source>
+            <translation>Remove vertex</translation>
+        </message>
+    </context>
+</TS>
diff --git a/src/GUI/Makefile.am b/src/GUI/Makefile.am
new file mode 100755 (executable)
index 0000000..e7f84d2
--- /dev/null
@@ -0,0 +1,67 @@
+# Copyright (C) 2009-2012  CEA/DEN, EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+# -* Makefile *- 
+# Author : Lioka RAZAFINDRAZAKA (CEA)
+# Modified by : Alexander BORODIN (OCN) - autotools usage
+# Module : HEXABLOCKPLUGIN
+# Date : 2010/11/08
+#
+include $(top_srcdir)/adm_local/unix/make_common_starter.am
+
+# header files 
+salomeinclude_HEADERS = 
+
+# Libraries targets
+lib_LTLIBRARIES = libHEXABLOCKPluginGUI.la
+
+dist_libHEXABLOCKPluginGUI_la_SOURCES = HEXABLOCKPluginGUI_HypothesisCreator.cxx 
+
+MOC_FILES = HEXABLOCKPluginGUI_HypothesisCreator_moc.cxx
+nodist_libHEXABLOCKPluginGUI_la_SOURCES= $(MOC_FILES)
+
+libHEXABLOCKPluginGUI_la_CPPFLAGS =  \
+       $(QT_INCLUDES)        \
+       $(KERNEL_CXXFLAGS)    \
+       $(GUI_CXXFLAGS)       \
+       $(GEOM_CXXFLAGS)      \
+       $(HEXABLOCK_CXXFLAGS) \
+       $(MED_CXXFLAGS)       \
+       $(SMESH_CXXFLAGS)     \
+       $(BOOST_CPPFLAGS)     \
+       $(CORBA_CXXFLAGS)     \
+       $(CORBA_INCLUDES)     \
+       $(CAS_CPPFLAGS)       \
+        -I$(srcdir)/..        \
+       -I$(top_builddir)/idl
+
+libHEXABLOCKPluginGUI_la_LDFLAGS  = \
+       ../../idl/libSalomeIDLHEXABLOCKPLUGIN.la \
+       $(QT_LIBS) \
+       $(KERNEL_LDFLAGS) -lSALOMELocalTrace \
+       $(HEXABLOCK_LDFLAGS) -lSalomeIDLHEXABLOCK \
+       $(MED_LDFLAGS) -lSalomeIDLMED \
+       $(SMESH_LDFLAGS) -lSMESH \
+       $(GUI_LDFLAGS) -lsuit -lqtx -lSalomeApp \
+       $(CAS_KERNEL)
+
+# resources files
+nodist_salomeres_DATA= \
+       HEXABLOCKPlugin_images.qm \
+       HEXABLOCKPlugin_msg_en.qm
diff --git a/src/HEXABLOCKPlugin/HEXABLOCKPlugin_Defs.hxx b/src/HEXABLOCKPlugin/HEXABLOCKPlugin_Defs.hxx
new file mode 100755 (executable)
index 0000000..f2ed997
--- /dev/null
@@ -0,0 +1,37 @@
+// Copyright (C) 2009-2012  CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+//=============================================================================
+// File      : HEXABLOCKPlugin_Defs.hxx
+// Author    : Lioka RAZAFINDRAZAKA (CEA)
+//
+#ifndef _HEXABLOCKPlugin_DEFS_HXX_
+#define _HEXABLOCKPlugin_DEFS_HXX_
+
+#ifdef WIN32
+  #if defined HEXABLOCKPLUGIN_EXPORTS || defined HEXABLOCKEngine_EXPORTS
+    #define HEXABLOCKPLUGIN_EXPORT __declspec( dllexport )
+  #else
+    #define HEXABLOCKPLUGIN_EXPORT __declspec( dllimport )
+  #endif
+#else
+  #define HEXABLOCKPLUGIN_EXPORT
+#endif
+
+#endif
diff --git a/src/HEXABLOCKPlugin/HEXABLOCKPlugin_FromSkin_3D.cxx b/src/HEXABLOCKPlugin/HEXABLOCKPlugin_FromSkin_3D.cxx
new file mode 100755 (executable)
index 0000000..1dc0e31
--- /dev/null
@@ -0,0 +1,1580 @@
+//  Copyright (C) 2009-2011  CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+// File      : SMESH_HexaFromSkin_3D.cxx
+// Created   : Wed Jan 27 12:28:07 2010
+// Author    : Edward AGAPOV (eap)
+//
+#include "HEXABLOCKPlugin_FromSkin_3D.hxx"
+
+#include "SMDS_VolumeOfNodes.hxx"
+#include "SMDS_VolumeTool.hxx"
+#include "SMESH_Block.hxx"
+#include "SMESH_MesherHelper.hxx"
+
+#include <gp_Ax2.hxx>
+
+//#include "utilities.h"
+#include <limits>
+
+// Define error message and _MYDEBUG_ if needed
+#ifdef _DEBUG_
+#define BAD_MESH_ERR \
+  error(SMESH_Comment("Can't detect block-wise structure of the input 2D mesh.\n" \
+                      __FILE__ ":" )<<__LINE__)
+//#define _MYDEBUG_
+#else
+#define BAD_MESH_ERR \
+  error(SMESH_Comment("Can't detect block-wise structure of the input 2D mesh"))
+#endif
+
+// Debug output
+#ifdef _MYDEBUG_
+#define _DUMP_(msg) cout << msg << endl
+#else
+#define _DUMP_(msg)
+#endif
+
+
+#ifdef _DEBUG_
+static int MYDEBUG = 1;
+#else
+static int MYDEBUG = 0;
+#endif
+
+
+namespace
+{
+  enum EBoxSides //!< sides of the block
+    {
+      B_BOTTOM=0, B_RIGHT, B_TOP, B_LEFT, B_FRONT, B_BACK, NB_BLOCK_SIDES
+    };
+#ifdef _MYDEBUG_
+  const char* SBoxSides[] = //!< names of block sides
+    {
+      "BOTTOM", "RIGHT", "TOP", "LEFT", "FRONT", "BACK", "UNDEFINED"
+    };
+#endif    
+  enum EQuadEdge //!< edges of quadrangle side
+    {
+      Q_BOTTOM = 0, Q_RIGHT, Q_TOP, Q_LEFT, NB_QUAD_SIDES
+    };
+
+
+  //================================================================================
+  /*!
+   * \brief return logical coordinates (i.e. min or max) of ends of edge
+   */
+  //================================================================================
+
+  bool getEdgeEnds(EQuadEdge edge, bool& xMax1, bool& yMax1, bool& xMax2, bool& yMax2 )
+  {
+    xMax1=0, yMax1=0, xMax2=1, yMax2=1;
+    switch( edge )
+    {
+    case Q_BOTTOM: yMax2 = 0; break;
+    case Q_RIGHT:  xMax1 = 1; break;
+    case Q_TOP:    yMax1 = 1; break;
+    case Q_LEFT:   xMax2 = 0; break;
+    default:
+      return false;
+    }
+    return true;
+  }
+
+  //================================================================================
+  /*!
+   * \brief return true if a node is at block corner
+   *
+   * This check is valid for simple cases only
+   */
+  //================================================================================
+
+  bool isCornerNode( const SMDS_MeshNode* n )
+  {
+    int nbF = n ? n->NbInverseElements( SMDSAbs_Face ) : 1;
+    if ( nbF % 2 )
+      return true;
+
+    set<const SMDS_MeshNode*> nodesInInverseFaces;
+    SMDS_ElemIteratorPtr fIt = n->GetInverseElementIterator(SMDSAbs_Face );
+    while ( fIt->more() )
+    {
+      const SMDS_MeshElement* face = fIt->next();
+      nodesInInverseFaces.insert( face->begin_nodes(), face->end_nodes() );
+    }
+
+    return nodesInInverseFaces.size() != ( 6 + (nbF/2-1)*3 );
+  }
+
+  //================================================================================
+  /*!
+   * \brief check element type
+   */
+  //================================================================================
+
+  bool isQuadrangle(const SMDS_MeshElement* e)
+  {
+    return ( e && e->NbCornerNodes() == 4 );
+  }
+
+  //================================================================================
+  /*!
+   * \brief return opposite node of a quadrangle face
+   */
+  //================================================================================
+
+  const SMDS_MeshNode* oppositeNode(const SMDS_MeshElement* quad, int iNode)
+  {
+    return quad->GetNode( (iNode+2) % 4 );
+  }
+
+  //================================================================================
+  /*!
+   * \brief Convertor of a pair of integers to a sole index
+   */
+  struct _Indexer
+  {
+    int _xSize, _ySize;
+    _Indexer( int xSize=0, int ySize=0 ): _xSize(xSize), _ySize(ySize) {}
+    int size() const { return _xSize * _ySize; }
+    int operator()(int x, int y) const { return y * _xSize + x; }
+  };
+  //================================================================================
+  /*!
+   * \brief Oriented convertor of a pair of integers to a sole index 
+   */
+  class _OrientedIndexer : public _Indexer
+  {
+  public:
+    enum OriFlags //!< types of block side orientation
+      {
+        REV_X = 1, REV_Y = 2, SWAP_XY = 4, MAX_ORI = REV_X|REV_Y|SWAP_XY
+      };
+    _OrientedIndexer( const _Indexer& indexer, const int oriFlags ):
+      _Indexer( indexer._xSize, indexer._ySize ),
+      _xSize (indexer._xSize), _ySize(indexer._ySize),
+      _xRevFun((oriFlags & REV_X) ? & reverse : & lazy),
+      _yRevFun((oriFlags & REV_Y) ? & reverse : & lazy),
+      _swapFun((oriFlags & SWAP_XY ) ? & swap : & lazy)
+    {
+      (*_swapFun)( _xSize, _ySize );
+    }
+    //!< Return index by XY
+    int operator()(int x, int y) const
+    {
+      (*_xRevFun)( x, const_cast<int&>( _xSize ));
+      (*_yRevFun)( y, const_cast<int&>( _ySize ));
+      (*_swapFun)( x, y );
+      return _Indexer::operator()(x,y);
+    }
+    //!< Return index for a corner
+    int corner(bool xMax, bool yMax) const
+    {
+      int x = xMax, y = yMax, size = 2;
+      (*_xRevFun)( x, size );
+      (*_yRevFun)( y, size );
+      (*_swapFun)( x, y );
+      return _Indexer::operator()(x ? _Indexer::_xSize-1 : 0 , y ? _Indexer::_ySize-1 : 0);
+    }
+    int xSize() const { return _xSize; }
+    int ySize() const { return _ySize; }
+  private:
+    _Indexer _indexer;
+    int _xSize, _ySize;
+
+    typedef void (*TFun)(int& x, int& y);
+    TFun _xRevFun, _yRevFun, _swapFun;
+    
+    static void lazy   (int&, int&) {}
+    static void reverse(int& x, int& size) { x = size - x - 1; }
+    static void swap   (int& x, int& y) { std::swap(x,y); }
+  };
+  //================================================================================
+  /*!
+   * \brief Structure corresponding to the meshed side of block
+   */
+  struct _BlockSide
+  {
+    vector<const SMDS_MeshNode*> _grid;
+    _Indexer                     _index;
+    int                          _nbBlocksExpected;
+    int                          _nbBlocksFound;
+
+#ifdef _DEBUG_ // want to get SIGSEGV in case of invalid index
+#define _grid_access_(pobj, i) pobj->_grid[ ((i) < pobj->_grid.size()) ? i : int(1e100)]
+#else
+#define _grid_access_(pobj, i) pobj->_grid[ i ]
+#endif
+    //!< Return node at XY
+    const SMDS_MeshNode* getNode(int x, int y) const { return _grid_access_(this, _index( x,y ));}
+    //!< Set node at XY
+    void setNode(int x, int y, const SMDS_MeshNode* n) { _grid_access_(this, _index( x,y )) = n; }
+    //!< Return an edge
+    SMESH_OrientedLink getEdge(EQuadEdge edge) const
+    {
+      bool x1, y1, x2, y2; getEdgeEnds( edge, x1, y1, x2, y2 );
+      return SMESH_OrientedLink( getCornerNode ( x1, y1 ), getCornerNode( x2, y2 ));
+    }
+    //!< Return a corner node
+    const SMDS_MeshNode* getCornerNode(bool isXMax, bool isYMax) const
+    {
+      return getNode( isXMax ? _index._xSize-1 : 0 , isYMax ? _index._ySize-1 : 0 );
+    }
+    const SMDS_MeshElement* getCornerFace(const SMDS_MeshNode* cornerNode) const;
+    //!< True if all blocks this side belongs to have been found
+    bool isBound() const { return _nbBlocksExpected <= _nbBlocksFound; }
+    //!< Return coordinates of node at XY
+    gp_XYZ getXYZ(int x, int y) const { return SMESH_TNodeXYZ( getNode( x, y )); }
+    //!< Return gravity center of the four corners and the middle node
+    gp_XYZ getGC() const
+    {
+      gp_XYZ xyz =
+        getXYZ( 0, 0 ) +
+        getXYZ( _index._xSize-1, 0 ) +
+        getXYZ( 0, _index._ySize-1 ) +
+        getXYZ( _index._xSize-1, _index._ySize-1 ) +
+        getXYZ( _index._xSize/2, _index._ySize/2 );
+      return xyz / 5;
+    }
+    //!< Return number of mesh faces
+    int getNbFaces() const { return (_index._xSize-1) * (_index._ySize-1); }
+  };
+  //================================================================================
+  /*!
+   * \brief _BlockSide with changed orientation
+   */
+  struct _OrientedBlockSide
+  {
+    _BlockSide*       _side;
+    _OrientedIndexer  _index;
+
+    _OrientedBlockSide( _BlockSide* side=0, const int oriFlags=0 ):
+      _side(side), _index(side ? side->_index : _Indexer(), oriFlags ) {}
+    //!< return coordinates by XY
+    gp_XYZ xyz(int x, int y) const
+    {
+      return SMESH_TNodeXYZ( _grid_access_(_side, _index( x, y )) );
+    }
+    //!< safely return a node by XY
+    const SMDS_MeshNode* node(int x, int y) const
+    {
+      int i = _index( x, y );
+      return ( i < 0 || i >= _side->_grid.size()) ? 0 : _side->_grid[i];
+    }
+    //!< Return an edge
+    SMESH_OrientedLink edge(EQuadEdge edge) const
+    {
+      bool x1, y1, x2, y2; getEdgeEnds( edge, x1, y1, x2, y2 );
+      return SMESH_OrientedLink( cornerNode ( x1, y1 ), cornerNode( x2, y2 ));
+    }
+    //!< Return a corner node
+    const SMDS_MeshNode* cornerNode(bool isXMax, bool isYMax) const
+    {
+      return _grid_access_(_side, _index.corner( isXMax, isYMax ));
+    }
+    //!< return its size in nodes
+    int getHoriSize() const { return _index.xSize(); }
+    int getVertSize() const  { return _index.ySize(); }
+    //!< True if _side has been initialized
+    operator bool() const { return _side; }
+    //! Direct access to _side
+    const _BlockSide* operator->() const { return _side; }
+    _BlockSide* operator->() { return _side; }
+  };
+  //================================================================================
+  /*!
+   * \brief Meshed skin of block
+   */
+  struct _Block
+  {
+    _OrientedBlockSide        _side[6]; // 6 sides of a sub-block
+    set<const SMDS_MeshNode*> _corners;
+
+    const _OrientedBlockSide& getSide(int i) const { return _side[i]; }
+    bool setSide( int i, const _OrientedBlockSide& s)
+    {
+      if (( _side[i] = s ))
+      {
+        _corners.insert( s.cornerNode(0,0));
+        _corners.insert( s.cornerNode(1,0));
+        _corners.insert( s.cornerNode(0,1));
+        _corners.insert( s.cornerNode(1,1));
+      }
+      return s;
+    }
+    void clear() { for (int i=0;i<6;++i) _side[i]=0; _corners.clear(); }
+    bool hasSide( const _OrientedBlockSide& s) const
+    {
+      if ( s ) for (int i=0;i<6;++i) if ( _side[i] && _side[i]._side == s._side ) return true;
+      return false;
+    }
+    int nbSides() const { int n=0; for (int i=0;i<6;++i) if ( _side[i] ) ++n; return n; }
+    bool isValid() const;
+  };
+  //================================================================================
+  /*!
+   * \brief Skin mesh possibly containing several meshed blocks
+   */
+  class _Skin
+  {
+  public:
+
+    int findBlocks(SMESH_Mesh& mesh);
+    //!< return i-th block
+    const _Block& getBlock(int i) const { return _blocks[i]; }
+    //!< return error description
+    const SMESH_Comment& error() const { return _error; }
+
+  private:
+    bool fillSide( _BlockSide&             side,
+                   const SMDS_MeshElement* cornerQuad,
+                   const SMDS_MeshNode*    cornerNode);
+    bool fillRowsUntilCorner(const SMDS_MeshElement* quad,
+                             const SMDS_MeshNode*    n1,
+                             const SMDS_MeshNode*    n2,
+                             vector<const SMDS_MeshNode*>& verRow1,
+                             vector<const SMDS_MeshNode*>& verRow2,
+                             bool alongN1N2 );
+    _OrientedBlockSide findBlockSide( EBoxSides           startBlockSide,
+                                      EQuadEdge           sharedSideEdge1,
+                                      EQuadEdge           sharedSideEdge2,
+                                      bool                withGeometricAnalysis,
+                                      set< _BlockSide* >& sidesAround);
+    //!< update own data and data of the side bound to block
+    void setSideBoundToBlock( _BlockSide& side )
+    {
+      if ( side._nbBlocksFound++, side.isBound() )
+        for ( int e = 0; e < int(NB_QUAD_SIDES); ++e )
+          _edge2sides[ side.getEdge( (EQuadEdge) e ) ].erase( &side );
+    }
+    //!< store reason of error
+    int error(const SMESH_Comment& reason) { _error = reason; return 0; }
+
+    SMESH_Comment      _error;
+
+    list< _BlockSide > _allSides;
+    vector< _Block >   _blocks;
+
+    //map< const SMDS_MeshNode*, set< _BlockSide* > > _corner2sides;
+    map< SMESH_OrientedLink, set< _BlockSide* > > _edge2sides;
+  };
+
+  //================================================================================
+  /*!
+   * \brief Find and return number of submeshes corresponding to blocks
+   */
+  //================================================================================
+
+  int _Skin::findBlocks(SMESH_Mesh& mesh)
+  {
+    SMESHDS_Mesh* meshDS = mesh.GetMeshDS();
+
+    // Find a node at any block corner
+
+    SMDS_NodeIteratorPtr nIt = meshDS->nodesIterator(/*idInceasingOrder=*/true);
+    if ( !nIt->more() ) return error("Empty mesh");
+
+    const SMDS_MeshNode* nCorner = 0;
+    while ( nIt->more() )
+    {
+      nCorner = nIt->next();
+      if ( isCornerNode( nCorner ))
+        break;
+      else
+        nCorner = 0;
+    }
+    if ( !nCorner )
+      return BAD_MESH_ERR;
+
+    // --------------------------------------------------------------------
+    // Find all block sides starting from mesh faces sharing the corner node
+    // --------------------------------------------------------------------
+
+    int nbFacesOnSides = 0;
+    TIDSortedElemSet cornerFaces; // corner faces of found _BlockSide's
+    list< const SMDS_MeshNode* > corners( 1, nCorner );
+    list< const SMDS_MeshNode* >::iterator corner = corners.begin();
+    while ( corner != corners.end() )
+    {
+      SMDS_ElemIteratorPtr faceIt = (*corner)->GetInverseElementIterator( SMDSAbs_Face );
+      while ( faceIt->more() )
+      {
+        const SMDS_MeshElement* face = faceIt->next();
+        if ( !cornerFaces.insert( face ).second )
+          continue; // already loaded block side
+
+        if ( !isQuadrangle( face ))
+          return error("Non-quadrangle elements in the input mesh");
+
+        if ( _allSides.empty() || !_allSides.back()._grid.empty() )
+          _allSides.push_back( _BlockSide() );
+
+        _BlockSide& side = _allSides.back();
+        if ( !fillSide( side, face, *corner ) )
+        {
+          if ( !_error.empty() )
+            return false;
+        }
+        else
+        {
+          for ( int isXMax = 0; isXMax < 2; ++isXMax )
+            for ( int isYMax = 0; isYMax < 2; ++isYMax )
+            {
+              const SMDS_MeshNode* nCorner = side.getCornerNode(isXMax,isYMax );
+              corners.push_back( nCorner );
+              cornerFaces.insert( side.getCornerFace( nCorner ));
+            }
+          for ( int e = 0; e < int(NB_QUAD_SIDES); ++e )
+            _edge2sides[ side.getEdge( (EQuadEdge) e ) ].insert( &side );
+
+          nbFacesOnSides += side.getNbFaces();
+        }
+      }
+      ++corner;
+
+      // find block sides of other domains if any
+      if ( corner == corners.end() && nbFacesOnSides < mesh.NbQuadrangles() )
+      {
+        while ( nIt->more() )
+        {
+          nCorner = nIt->next();
+          if ( isCornerNode( nCorner ))
+            corner = corners.insert( corner, nCorner );
+        }
+        nbFacesOnSides = mesh.NbQuadrangles();
+      }
+    }
+    
+    if ( _allSides.empty() )
+      return BAD_MESH_ERR;
+    if ( _allSides.back()._grid.empty() )
+      _allSides.pop_back();
+    _DUMP_("Nb detected sides "<< _allSides.size());
+
+    // ---------------------------
+    // Organize sides into blocks
+    // ---------------------------
+
+    // analyse sharing of sides by blocks and sort sides by nb of adjacent sides
+    int nbBlockSides = 0; // total nb of block sides taking into account their sharing
+    multimap<int, _BlockSide* > sortedSides;
+    {
+      list < _BlockSide >::iterator sideIt = _allSides.begin();
+      for ( ; sideIt != _allSides.end(); ++sideIt )
+      {
+        _BlockSide& side = *sideIt;
+        bool isSharedSide = true;
+        int nbAdjacent = 0;
+        for ( int e = 0; e < int(NB_QUAD_SIDES) && isSharedSide; ++e )
+        {
+          int nbAdj = _edge2sides[ side.getEdge( (EQuadEdge) e ) ].size();
+          nbAdjacent += nbAdj;
+          isSharedSide = ( nbAdj > 2 );
+        }
+        side._nbBlocksFound = 0;
+        side._nbBlocksExpected = isSharedSide ? 2 : 1;
+        nbBlockSides += side._nbBlocksExpected;
+        sortedSides.insert( make_pair( nbAdjacent, & side ));
+      }
+    }
+
+    // find sides of each block
+    int nbBlocks = 0;
+    while ( nbBlockSides >= 6 )
+    {
+      // get any side not bound to all blocks it belongs to
+      multimap<int, _BlockSide*>::iterator i_side = sortedSides.begin();
+      while ( i_side != sortedSides.end() && i_side->second->isBound())
+        ++i_side;
+
+      // start searching for block sides from the got side
+      bool ok = true;
+      if ( _blocks.empty() || _blocks.back()._side[B_FRONT] )
+        _blocks.resize( _blocks.size() + 1 );
+
+      _Block& block = _blocks.back();
+      block.setSide( B_FRONT, i_side->second );
+      setSideBoundToBlock( *i_side->second );
+      nbBlockSides--;
+
+      // edges of adjacent sides of B_FRONT corresponding to front's edges
+      EQuadEdge edgeOfFront[4] = { Q_BOTTOM, Q_RIGHT, Q_TOP, Q_LEFT };
+      EQuadEdge edgeOfAdj  [4] = { Q_BOTTOM, Q_LEFT, Q_BOTTOM, Q_LEFT };
+      // first find all sides detectable w/o advanced analysis,
+      // then repeat the search, which then may pass without advanced analysis
+      set< _BlockSide* > sidesAround;
+      for ( int advAnalys = 0; advAnalys < 2; ++advAnalys )
+      {
+        // try to find 4 sides adjacent to a FRONT side
+        for ( int i = 0; (ok || !advAnalys) && i < NB_QUAD_SIDES; ++i )
+          if ( !block._side[i] )
+            ok = block.setSide( i, findBlockSide( B_FRONT, edgeOfFront[i], edgeOfAdj[i],
+                                                  advAnalys, sidesAround));
+        // try to find a BACK side by a TOP one
+        if ( ok || !advAnalys)
+          if ( !block._side[B_BACK] && block._side[B_TOP] )
+            ok = block.setSide( B_BACK, findBlockSide( B_TOP, Q_TOP, Q_TOP,
+                                                       advAnalys, sidesAround ));
+        if ( !advAnalys ) ok = true;
+      }
+      ok = block.isValid();
+      if ( ok )
+      {
+        // check if just found block is same as one of previously found blocks
+        bool isSame = false;
+        for ( int i = 1; i < _blocks.size() && !isSame; ++i )
+          isSame = ( block._corners == _blocks[i-1]._corners );
+        ok = !isSame;
+      }
+
+      // count the found sides
+      _DUMP_(endl << "** Block " << _blocks.size() << " valid: " << block.isValid());
+      for (int i = 0; i < NB_BLOCK_SIDES; ++i )
+      {
+        _DUMP_("\tSide "<< SBoxSides[i] <<" "<< block._side[ i ]._side);
+        if ( block._side[ i ] )
+        {
+          if ( ok && i != B_FRONT)
+          {
+            setSideBoundToBlock( *block._side[ i ]._side );
+            nbBlockSides--;
+          }
+          _DUMP_("\t corners "<<
+                 block._side[ i ].cornerNode(0,0)->GetID() << ", " <<
+                 block._side[ i ].cornerNode(1,0)->GetID() << ", " <<
+                 block._side[ i ].cornerNode(1,1)->GetID() << ", " <<
+                 block._side[ i ].cornerNode(0,1)->GetID() << ", "<<endl);
+        }
+        else
+        {
+          _DUMP_("\t not found"<<endl);
+        }
+      }
+      if ( !ok )
+        block.clear();
+      else
+        nbBlocks++;
+    }
+    _DUMP_("Nb found blocks "<< nbBlocks <<endl);
+
+    if ( nbBlocks == 0 && _error.empty() )
+      return BAD_MESH_ERR;
+
+    return nbBlocks;
+  }
+
+  //================================================================================
+  /*!
+   * \brief Fill block side data starting from its corner quadrangle
+   */
+  //================================================================================
+
+  bool _Skin::fillSide( _BlockSide&             side,
+                        const SMDS_MeshElement* cornerQuad,
+                        const SMDS_MeshNode*    nCorner)
+  {
+    // Find out size of block side mesured in nodes and by the way find two rows
+    // of nodes in two directions.
+
+    int x, y, nbX, nbY;
+    const SMDS_MeshElement* firstQuad = cornerQuad;
+    {
+      // get a node on block edge
+      int iCorner = firstQuad->GetNodeIndex( nCorner );
+      const SMDS_MeshNode* nOnEdge = firstQuad->GetNode( (iCorner+1) % 4);
+
+      // find out size of block side
+      vector<const SMDS_MeshNode*> horRow1, horRow2, verRow1, verRow2;
+      if ( !fillRowsUntilCorner( firstQuad, nCorner, nOnEdge, horRow1, horRow2, true ) ||
+           !fillRowsUntilCorner( firstQuad, nCorner, nOnEdge, verRow1, verRow2, false ))
+        return false;
+      nbX = horRow1.size(), nbY = verRow1.size();
+
+      // store found nodes
+      side._index._xSize = horRow1.size();
+      side._index._ySize = verRow1.size();
+      side._grid.resize( side._index.size(), NULL );
+
+      for ( x = 0; x < horRow1.size(); ++x )
+      {
+        side.setNode( x, 0, horRow1[x] );
+        side.setNode( x, 1, horRow2[x] );
+      }
+      for ( y = 0; y < verRow1.size(); ++y )
+      {
+        side.setNode( 0, y, verRow1[y] );
+        side.setNode( 1, y, verRow2[y] );
+      }
+    }
+    // Find the rest nodes
+
+    y = 1; // y of the row to fill
+    TIDSortedElemSet emptySet, avoidSet;
+    while ( ++y < nbY )
+    {
+      // get next firstQuad in the next row of quadrangles
+      //
+      //          n2up
+      //     o---o               <- y row
+      //     |   |
+      //     o---o  o  o  o  o   <- found nodes
+      //n1down    n2down       
+      //
+      int i1down, i2down, i2up;
+      const SMDS_MeshNode* n1down = side.getNode( 0, y-1 );
+      const SMDS_MeshNode* n2down = side.getNode( 1, y-1 );
+      avoidSet.clear(); avoidSet.insert( firstQuad );
+      firstQuad = SMESH_MeshEditor::FindFaceInSet( n1down, n2down, emptySet, avoidSet,
+                                                   &i1down, &i2down);
+      if ( !isQuadrangle( firstQuad ))
+        return BAD_MESH_ERR;
+
+      const SMDS_MeshNode* n2up = oppositeNode( firstQuad, i1down );
+      avoidSet.clear(); avoidSet.insert( firstQuad );
+
+      // find the rest nodes in the y-th row by faces in the row
+
+      x = 1; 
+      while ( ++x < nbX )
+      {
+        const SMDS_MeshElement* quad = SMESH_MeshEditor::FindFaceInSet( n2up, n2down, emptySet,
+                                                                        avoidSet, &i2up, &i2down);
+        if ( !isQuadrangle( quad ))
+          return BAD_MESH_ERR;
+
+        n2up   = oppositeNode( quad, i2down );
+        n2down = oppositeNode( quad, i2up );
+        avoidSet.clear(); avoidSet.insert( quad );
+
+        side.setNode( x, y, n2up );
+      }
+    }
+
+    // check side validity
+    bool ok =
+      side.getCornerFace( side.getCornerNode( 0, 0 )) &&
+      side.getCornerFace( side.getCornerNode( 1, 0 )) &&
+      side.getCornerFace( side.getCornerNode( 0, 1 )) &&
+      side.getCornerFace( side.getCornerNode( 1, 1 ));
+
+    return ok;
+  }
+
+  //================================================================================
+  /*!
+   * \brief Return true if it's possible to make a loop over corner2Sides starting
+   * from the startSide
+   */
+  //================================================================================
+
+  bool isClosedChainOfSides( _BlockSide*                                        startSide,
+                             map< const SMDS_MeshNode*, list< _BlockSide* > > & corner2Sides )
+  {
+    // get start and end nodes
+    const SMDS_MeshNode *n1 = 0, *n2 = 0, *n;
+    for ( int y = 0; y < 2; ++y )
+      for ( int x = 0; x < 2; ++x )
+      {
+        n = startSide->getCornerNode(x,y);
+        if ( !corner2Sides.count( n )) continue;
+        if ( n1 )
+          n2 = n;
+        else
+          n1 = n;
+      }
+    if ( !n2 ) return false;
+
+    map< const SMDS_MeshNode*, list< _BlockSide* > >::iterator
+      c2sides = corner2Sides.find( n1 );
+    if ( c2sides == corner2Sides.end() ) return false;
+
+    int nbChainLinks = 1;
+    n = n1;
+    _BlockSide* prevSide = startSide;
+    while ( n != n2 )
+    {
+      // get the next side sharing n
+      list< _BlockSide* > & sides = c2sides->second;
+      _BlockSide* nextSide = ( sides.back() == prevSide ? sides.front() : sides.back() );
+      if ( nextSide == prevSide ) return false;
+
+      // find the next corner of the nextSide being in corner2Sides
+      n1 = n;
+      n = 0;
+      for ( int y = 0; y < 2 && !n; ++y )
+        for ( int x = 0; x < 2; ++x )
+        {
+          n = nextSide->getCornerNode(x,y);
+          c2sides = corner2Sides.find( n );
+          if ( n == n1 || c2sides == corner2Sides.end() )
+            n = 0;
+          else
+            break;
+        }
+      if ( !n ) return false;
+
+      prevSide = nextSide;
+      nbChainLinks++;
+    }
+
+    return ( n == n2 && nbChainLinks == NB_QUAD_SIDES );
+  }
+
+  //================================================================================
+  /*!
+   * \brief Try to find a block side adjacent to the given side by given edge
+   */
+  //================================================================================
+
+  _OrientedBlockSide _Skin::findBlockSide( EBoxSides           startBlockSide,
+                                           EQuadEdge           sharedSideEdge1,
+                                           EQuadEdge           sharedSideEdge2,
+                                           bool                withGeometricAnalysis,
+                                           set< _BlockSide* >& sidesAround)
+  {
+    _Block& block = _blocks.back();
+    _OrientedBlockSide& side1 = block._side[ startBlockSide ];
+
+    // get corner nodes of the given block edge
+    SMESH_OrientedLink edge = side1.edge( sharedSideEdge1 );
+    const SMDS_MeshNode* n1 = edge.node1();
+    const SMDS_MeshNode* n2 = edge.node2();
+    if ( edge._reversed ) swap( n1, n2 );
+
+    // find all sides sharing both nodes n1 and n2
+    set< _BlockSide* > sidesOnEdge = _edge2sides[ edge ]; // copy a set
+
+    // exclude loaded sides of block from sidesOnEdge
+    for (int i = 0; i < NB_BLOCK_SIDES; ++i )
+      if ( block._side[ i ] )
+        sidesOnEdge.erase( block._side[ i ]._side );
+
+    int nbSidesOnEdge = sidesOnEdge.size();
+    _DUMP_("nbSidesOnEdge "<< nbSidesOnEdge << " " << n1->GetID() << "-" << n2->GetID() );
+    if ( nbSidesOnEdge == 0 )
+      return 0;
+
+    _BlockSide* foundSide = 0;
+    if ( nbSidesOnEdge == 1 )
+    {
+      foundSide = *sidesOnEdge.begin();
+    }
+    else
+    {
+      set< _BlockSide* >::iterator sideIt = sidesOnEdge.begin();
+      int nbLoadedSides = block.nbSides();
+      if ( nbLoadedSides > 1 )
+      {
+        // Find the side having more than 2 corners common with already loaded sides
+        for (; !foundSide && sideIt != sidesOnEdge.end(); ++sideIt )
+        {
+          _BlockSide* sideI = *sideIt;
+          int nbCommonCorners =
+            block._corners.count( sideI->getCornerNode(0,0)) +
+            block._corners.count( sideI->getCornerNode(1,0)) +
+            block._corners.count( sideI->getCornerNode(0,1)) +
+            block._corners.count( sideI->getCornerNode(1,1));
+          if ( nbCommonCorners > 2 )
+            foundSide = sideI;
+        }
+      }
+
+      if ( !foundSide )
+      {
+        if ( !withGeometricAnalysis )
+        {
+          sidesAround.insert( sidesOnEdge.begin(), sidesOnEdge.end() );
+          return 0;
+        }
+        if ( nbLoadedSides == 1 )
+        {
+          // Issue 0021529. There are at least 2 sides by each edge and
+          // position of block gravity center is undefined.
+          // Find a side starting from which we can walk around the startBlockSide
+
+          // fill in corner2Sides
+          map< const SMDS_MeshNode*, list< _BlockSide* > > corner2Sides;
+          for ( sideIt = sidesAround.begin(); sideIt != sidesAround.end(); ++sideIt )
+          {
+            _BlockSide* sideI = *sideIt;
+            corner2Sides[ sideI->getCornerNode(0,0) ].push_back( sideI );
+            corner2Sides[ sideI->getCornerNode(1,0) ].push_back( sideI );
+            corner2Sides[ sideI->getCornerNode(0,1) ].push_back( sideI );
+            corner2Sides[ sideI->getCornerNode(1,1) ].push_back( sideI );
+          }
+          // remove corners of startBlockSide from corner2Sides
+          set<const SMDS_MeshNode*>::iterator nIt = block._corners.begin();
+          for ( ; nIt != block._corners.end(); ++nIt )
+            corner2Sides.erase( *nIt );
+
+          // select a side
+          for ( sideIt = sidesOnEdge.begin(); sideIt != sidesOnEdge.end(); ++sideIt )
+          {
+            if ( isClosedChainOfSides( *sideIt, corner2Sides ))
+            {
+              foundSide = *sideIt;
+              break;
+            }
+          }
+          if ( !foundSide )
+            return 0;
+        }
+        else
+        {
+          // Select one of found sides most close to startBlockSide
+
+          gp_XYZ p1 ( n1->X(),n1->Y(),n1->Z()),  p2 (n2->X(),n2->Y(),n2->Z());
+          gp_Vec p1p2( p1, p2 );
+
+          const SMDS_MeshElement* face1 = side1->getCornerFace( n1 );
+          gp_XYZ p1Op = SMESH_TNodeXYZ( oppositeNode( face1, face1->GetNodeIndex(n1)));
+          gp_Vec side1Dir( p1, p1Op );
+          gp_Ax2 pln( p1, p1p2, side1Dir ); // plane with normal p1p2 and X dir side1Dir
+          _DUMP_("  Select adjacent for "<< side1._side << " - side dir ("
+                 << side1Dir.X() << ", " << side1Dir.Y() << ", " << side1Dir.Z() << ")" );
+
+          map < double , _BlockSide* > angleOfSide;
+          for (sideIt = sidesOnEdge.begin(); sideIt != sidesOnEdge.end(); ++sideIt )
+          {
+            _BlockSide* sideI = *sideIt;
+            const SMDS_MeshElement* faceI = sideI->getCornerFace( n1 );
+            gp_XYZ p1Op = SMESH_TNodeXYZ( oppositeNode( faceI, faceI->GetNodeIndex(n1)));
+            gp_Vec sideIDir( p1, p1Op );
+            // compute angle of (sideIDir projection to pln) and (X dir of pln)
+            gp_Vec2d sideIDirProj( sideIDir * pln.XDirection(), sideIDir * pln.YDirection());
+            double angle = sideIDirProj.Angle( gp::DX2d() );
+            if ( angle < 0 ) angle += 2. * M_PI; // angle [0-2*PI]
+            angleOfSide.insert( make_pair( angle, sideI ));
+            _DUMP_("  "<< sideI << " - side dir ("
+                   << sideIDir.X() << ", " << sideIDir.Y() << ", " << sideIDir.Z() << ")"
+                   << " angle " << angle);
+          }
+
+          gp_XYZ gc(0,0,0); // gravity center of already loaded block sides
+          for (int i = 0; i < NB_BLOCK_SIDES; ++i )
+            if ( block._side[ i ] )
+              gc += block._side[ i ]._side->getGC();
+          gc /= nbLoadedSides;
+
+          gp_Vec gcDir( p1, gc );
+          gp_Vec2d gcDirProj( gcDir * pln.XDirection(), gcDir * pln.YDirection());
+          double gcAngle = gcDirProj.Angle( gp::DX2d() );
+          foundSide = gcAngle < 0 ? angleOfSide.rbegin()->second : angleOfSide.begin()->second;
+        }
+      }
+      _DUMP_("  selected "<< foundSide );
+    }
+
+    // Orient the found side correctly
+
+    // corners of found side corresponding to nodes n1 and n2
+    bool xMax1, yMax1, xMax2, yMax2;
+    if ( !getEdgeEnds( sharedSideEdge2, xMax1, yMax1, xMax2, yMax2 ))
+      return error(SMESH_Comment("Internal error at ")<<__FILE__<<":"<<__LINE__),
+        _OrientedBlockSide(0);
+
+    for ( int ori = 0; ori < _OrientedIndexer::MAX_ORI+1; ++ori )
+    {
+      _OrientedBlockSide orientedSide( foundSide, ori );
+      const SMDS_MeshNode* n12 = orientedSide.cornerNode( xMax1, yMax1);
+      const SMDS_MeshNode* n22 = orientedSide.cornerNode( xMax2, yMax2);
+      if ( n1 == n12 && n2 == n22 )
+        return orientedSide;
+    }
+    error(SMESH_Comment("Failed to orient a block side found by edge ")<<sharedSideEdge1
+          << " of side " << startBlockSide
+          << " of block " << _blocks.size());
+    return 0;
+  }
+
+  //================================================================================
+  /*!
+   * \brief: Fill rows (which are actually columns,if !alongN1N2) of nodes starting
+   * from the given quadrangle until another block corner encounters.
+   *  n1 and n2 are at bottom of quad, n1 is at block corner.
+   */
+  //================================================================================
+
+  bool _Skin::fillRowsUntilCorner(const SMDS_MeshElement*       quad,
+                                  const SMDS_MeshNode*          n1,
+                                  const SMDS_MeshNode*          n2,
+                                  vector<const SMDS_MeshNode*>& row1,
+                                  vector<const SMDS_MeshNode*>& row2,
+                                  const bool                    alongN1N2 )
+  {
+    const SMDS_MeshNode* corner1 = n1;
+
+    // Store nodes of quad in the rows and find new n1 and n2 to get
+    // the next face so that new n2 is on block edge
+    int i1 = quad->GetNodeIndex( n1 );
+    int i2 = quad->GetNodeIndex( n2 );
+    row1.clear(); row2.clear();
+    row1.push_back( n1 );
+    if ( alongN1N2 )
+    {
+      row1.push_back( n2 );
+      row2.push_back( oppositeNode( quad, i2 ));
+      row2.push_back( n1 = oppositeNode( quad, i1 ));
+    }
+    else
+    {
+      row2.push_back( n2 );
+      row1.push_back( n2 = oppositeNode( quad, i2 ));
+      row2.push_back( n1 = oppositeNode( quad, i1 ));
+    }
+
+    if ( isCornerNode( row1[1] ))
+      return true;
+
+    // Find the rest nodes
+    TIDSortedElemSet emptySet, avoidSet;
+    while ( !isCornerNode( n2 ) )
+    {
+      avoidSet.clear(); avoidSet.insert( quad );
+      quad = SMESH_MeshEditor::FindFaceInSet( n1, n2, emptySet, avoidSet, &i1, &i2 );
+      if ( !isQuadrangle( quad ))
+        return BAD_MESH_ERR;
+
+      row1.push_back( n2 = oppositeNode( quad, i1 ));
+      row2.push_back( n1 = oppositeNode( quad, i2 ));
+    }
+    return n1 != corner1;
+  }
+
+  //================================================================================
+  /*!
+   * \brief Return a corner face by a corner node
+   */
+  //================================================================================
+
+  const SMDS_MeshElement* _BlockSide::getCornerFace(const SMDS_MeshNode* cornerNode) const
+  {
+    int x, y, isXMax, isYMax, found = 0;
+    for ( isXMax = 0; isXMax < 2; ++isXMax )
+    {
+      for ( isYMax = 0; isYMax < 2; ++isYMax )
+      {
+        x = isXMax ? _index._xSize-1 : 0;
+        y = isYMax ? _index._ySize-1 : 0;
+        found = ( getNode(x,y) == cornerNode );
+        if ( found ) break;
+      }
+      if ( found ) break;
+    }
+    if ( !found ) return 0;
+    int dx = isXMax ? -1 : +1;
+    int dy = isYMax ? -1 : +1;
+    const SMDS_MeshNode* n1 = getNode(x,y);
+    const SMDS_MeshNode* n2 = getNode(x+dx,y);
+    const SMDS_MeshNode* n3 = getNode(x,y+dy);
+    const SMDS_MeshNode* n4 = getNode(x+dx,y+dy);
+    return SMDS_Mesh::FindFace(n1, n2, n3, n4 );
+  }
+
+  //================================================================================
+  /*!
+   * \brief Checks own validity
+   */
+  //================================================================================
+
+  bool _Block::isValid() const
+  {
+    bool ok = ( nbSides() == 6 );
+
+    // check only corners depending on side selection
+    EBoxSides adjacent[4] = { B_BOTTOM, B_RIGHT, B_TOP, B_LEFT };
+    EQuadEdge edgeAdj [4] = { Q_TOP,    Q_RIGHT, Q_TOP, Q_RIGHT };
+    EQuadEdge edgeBack[4] = { Q_BOTTOM, Q_RIGHT, Q_TOP, Q_LEFT };
+
+    for ( int i=0; ok && i < NB_QUAD_SIDES; ++i )
+    { 
+      SMESH_OrientedLink eBack = _side[ B_BACK      ].edge( edgeBack[i] );
+      SMESH_OrientedLink eAdja = _side[ adjacent[i] ].edge( edgeAdj[i] );
+      ok = ( eBack == eAdja );
+    }
+    return ok;
+  }
+
+} // namespace
+
+
+
+
+
+HEXA_NS::Hexa* _block2Hexa( const _Block& block,
+                            HEXA_NS::Document* doc,
+                            std::map<HEXA_NS::Vertex*, SMDS_MeshNode*> vertexNode )
+{
+    const SMDS_MeshNode* n000 = block.getSide(B_BOTTOM).cornerNode( 0, 0 );
+    const SMDS_MeshNode* n100 = block.getSide(B_BOTTOM).cornerNode( 1, 0 );
+    const SMDS_MeshNode* n010 = block.getSide(B_BOTTOM).cornerNode( 0, 1 );
+    const SMDS_MeshNode* n110 = block.getSide(B_BOTTOM).cornerNode( 1, 1 );
+    const SMDS_MeshNode* n001 = block.getSide(B_TOP).cornerNode( 0, 0 );
+    const SMDS_MeshNode* n101 = block.getSide(B_TOP).cornerNode( 1, 0 );
+    const SMDS_MeshNode* n011 = block.getSide(B_TOP).cornerNode( 0, 1 );
+    const SMDS_MeshNode* n111 = block.getSide(B_TOP).cornerNode( 1, 1 );
+
+    list<const SMDS_MeshNode* > nodeFromBlock;
+    nodeFromBlock.push_back(n000);
+    nodeFromBlock.push_back(n100);
+    nodeFromBlock.push_back(n010);
+    nodeFromBlock.push_back(n110);
+    nodeFromBlock.push_back(n001);
+    nodeFromBlock.push_back(n101);
+    nodeFromBlock.push_back(n011);
+    nodeFromBlock.push_back(n111);
+    nodeFromBlock.sort();
+
+
+    HEXA_NS::Hexa* hexa = NULL;
+    int nHexa = doc->countUsedHexa();
+    for (int j=0; j <nHexa; ++j ){
+      hexa = doc->getUsedHexa(j);
+      list<const SMDS_MeshNode* > nodeFromHexa;
+      int nVx = hexa->countVertex();
+      for ( int i=0; i <nVx; ++i ){
+        HEXA_NS::Vertex* v = hexa->getVertex(i);
+        const SMDS_MeshNode* n = vertexNode[v];
+        nodeFromHexa.push_back(n);
+    }
+      nodeFromHexa.sort();
+
+      if ( nodeFromBlock == nodeFromHexa ){
+//         std::cout << "OK block match hexa "<< hexa <<" id = "<<hexa->getId()<<std::endl;
+        return hexa;
+      } /*else {
+        std::cout << "KO block does not match hexa "<< hexa <<" id = "<<hexa->getId()<<std::endl;
+      }*/
+    }
+    return NULL;
+}
+
+
+
+
+
+
+
+
+//=======================================================================
+//function : SMESH_HexaFromSkin_3D
+//purpose  : 
+//=======================================================================
+
+// SMESH_HexaFromSkin_3D::SMESH_HexaFromSkin_3D(int hypId, int studyId, SMESH_Gen* gen)
+//   :SMESH_3D_Algo(hypId, studyId, gen)
+// {
+//   MESSAGE("SMESH_HexaFromSkin_3D::SMESH_HexaFromSkin_3D");
+//   _name = "HexaFromSkin_3D";
+// }
+
+SMESH_HexaFromSkin_3D::SMESH_HexaFromSkin_3D(int hypId, int studyId, SMESH_Gen* gen, HEXA_NS::Document* doc)
+  :SMESH_3D_Algo(hypId, studyId, gen),
+  _doc( doc )
+{
+  if(MYDEBUG) MESSAGE("SMESH_HexaFromSkin_3D::SMESH_HexaFromSkin_3D");
+  _name = "HexaFromSkin_3D";
+}
+
+
+SMESH_HexaFromSkin_3D::~SMESH_HexaFromSkin_3D()
+{
+  if(MYDEBUG) MESSAGE("SMESH_HexaFromSkin_3D::~SMESH_HexaFromSkin_3D");
+}
+
+//================================================================================
+/*!
+ * \brief Main method, which generates hexaheda
+ */
+//================================================================================
+
+bool SMESH_HexaFromSkin_3D::Compute(SMESH_Mesh & aMesh, SMESH_MesherHelper* aHelper)
+{
+  _Skin skin;
+  int nbBlocks = skin.findBlocks(aMesh);
+  if ( nbBlocks == 0 )
+    return error( skin.error());
+
+  vector< vector< const SMDS_MeshNode* > > columns;
+  int x, xSize, y, ySize, z, zSize;
+  _Indexer colIndex;
+
+  for ( int i = 0; i < nbBlocks; ++i )
+  {
+    const _Block& block = skin.getBlock( i );
+
+    // ------------------------------------------
+    // Fill columns of nodes with existing nodes
+    // ------------------------------------------
+
+    xSize = block.getSide(B_BOTTOM).getHoriSize();
+    ySize = block.getSide(B_BOTTOM).getVertSize();
+    zSize = block.getSide(B_FRONT ).getVertSize();
+    int X = xSize - 1, Y = ySize - 1, Z = zSize - 1;
+    colIndex = _Indexer( xSize, ySize );
+    columns.resize( colIndex.size() );
+
+    // fill node columns by front and back box sides
+    for ( x = 0; x < xSize; ++x ) {
+      vector< const SMDS_MeshNode* >& column0 = columns[ colIndex( x, 0 )];
+      vector< const SMDS_MeshNode* >& column1 = columns[ colIndex( x, Y )];
+      column0.resize( zSize );
+      column1.resize( zSize );
+      for ( z = 0; z < zSize; ++z ) {
+        column0[ z ] = block.getSide(B_FRONT).node( x, z );
+        column1[ z ] = block.getSide(B_BACK) .node( x, z );
+      }
+    }
+    // fill node columns by left and right box sides
+    for ( y = 1; y < ySize-1; ++y ) {
+      vector< const SMDS_MeshNode* >& column0 = columns[ colIndex( 0, y )];
+      vector< const SMDS_MeshNode* >& column1 = columns[ colIndex( X, y )];
+      column0.resize( zSize );
+      column1.resize( zSize );
+      for ( z = 0; z < zSize; ++z ) {
+        column0[ z ] = block.getSide(B_LEFT) .node( y, z );
+        column1[ z ] = block.getSide(B_RIGHT).node( y, z );
+      }
+    }
+    // get nodes from top and bottom box sides
+    for ( x = 1; x < xSize-1; ++x ) {
+      for ( y = 1; y < ySize-1; ++y ) {
+        vector< const SMDS_MeshNode* >& column = columns[ colIndex( x, y )];
+        column.resize( zSize );
+        column.front() = block.getSide(B_BOTTOM).node( x, y );
+        column.back()  = block.getSide(B_TOP)   .node( x, y );
+      }
+    }
+
+    // ----------------------------
+    // Add internal nodes of a box
+    // ----------------------------
+    // projection points of internal nodes on box sub-shapes by which
+    // coordinates of internal nodes are computed
+    vector<gp_XYZ> pointOnShape( SMESH_Block::ID_Shell );
+
+    // projections on vertices are constant
+    pointOnShape[ SMESH_Block::ID_V000 ] = block.getSide(B_BOTTOM).xyz( 0, 0 );
+    pointOnShape[ SMESH_Block::ID_V100 ] = block.getSide(B_BOTTOM).xyz( X, 0 );
+    pointOnShape[ SMESH_Block::ID_V010 ] = block.getSide(B_BOTTOM).xyz( 0, Y );
+    pointOnShape[ SMESH_Block::ID_V110 ] = block.getSide(B_BOTTOM).xyz( X, Y );
+    pointOnShape[ SMESH_Block::ID_V001 ] = block.getSide(B_TOP).xyz( 0, 0 );
+    pointOnShape[ SMESH_Block::ID_V101 ] = block.getSide(B_TOP).xyz( X, 0 );
+    pointOnShape[ SMESH_Block::ID_V011 ] = block.getSide(B_TOP).xyz( 0, Y );
+    pointOnShape[ SMESH_Block::ID_V111 ] = block.getSide(B_TOP).xyz( X, Y );
+
+    for ( x = 1; x < xSize-1; ++x )
+    {
+      gp_XYZ params; // normalized parameters of internal node within a unit box
+      params.SetCoord( 1, x / double(X) );
+      for ( y = 1; y < ySize-1; ++y )
+      {
+        params.SetCoord( 2, y / double(Y) );
+        // column to fill during z loop
+        vector< const SMDS_MeshNode* >& column = columns[ colIndex( x, y )];
+        // projections on horizontal edges
+        pointOnShape[ SMESH_Block::ID_Ex00 ] = block.getSide(B_BOTTOM).xyz( x, 0 );
+        pointOnShape[ SMESH_Block::ID_Ex10 ] = block.getSide(B_BOTTOM).xyz( x, Y );
+        pointOnShape[ SMESH_Block::ID_E0y0 ] = block.getSide(B_BOTTOM).xyz( 0, y );
+        pointOnShape[ SMESH_Block::ID_E1y0 ] = block.getSide(B_BOTTOM).xyz( X, y );
+        pointOnShape[ SMESH_Block::ID_Ex01 ] = block.getSide(B_TOP).xyz( x, 0 );
+        pointOnShape[ SMESH_Block::ID_Ex11 ] = block.getSide(B_TOP).xyz( x, Y );
+        pointOnShape[ SMESH_Block::ID_E0y1 ] = block.getSide(B_TOP).xyz( 0, y );
+        pointOnShape[ SMESH_Block::ID_E1y1 ] = block.getSide(B_TOP).xyz( X, y );
+        // projections on horizontal sides
+        pointOnShape[ SMESH_Block::ID_Fxy0 ] = block.getSide(B_BOTTOM).xyz( x, y );
+        pointOnShape[ SMESH_Block::ID_Fxy1 ] = block.getSide(B_TOP)   .xyz( x, y );
+        for ( z = 1; z < zSize-1; ++z ) // z loop
+        {
+          params.SetCoord( 3, z / double(Z) );
+          // projections on vertical edges
+          pointOnShape[ SMESH_Block::ID_E00z ] = block.getSide(B_FRONT).xyz( 0, z );    
+          pointOnShape[ SMESH_Block::ID_E10z ] = block.getSide(B_FRONT).xyz( X, z );    
+          pointOnShape[ SMESH_Block::ID_E01z ] = block.getSide(B_BACK).xyz( 0, z );    
+          pointOnShape[ SMESH_Block::ID_E11z ] = block.getSide(B_BACK).xyz( X, z );
+          // projections on vertical sides
+          pointOnShape[ SMESH_Block::ID_Fx0z ] = block.getSide(B_FRONT).xyz( x, z );    
+          pointOnShape[ SMESH_Block::ID_Fx1z ] = block.getSide(B_BACK) .xyz( x, z );    
+          pointOnShape[ SMESH_Block::ID_F0yz ] = block.getSide(B_LEFT) .xyz( y, z );    
+          pointOnShape[ SMESH_Block::ID_F1yz ] = block.getSide(B_RIGHT).xyz( y, z );
+
+          // compute internal node coordinates
+          gp_XYZ coords;
+          SMESH_Block::ShellPoint( params, pointOnShape, coords );
+          column[ z ] = aHelper->AddNode( coords.X(), coords.Y(), coords.Z() );
+
+#ifdef DEB_GRID
+          // debug
+          //cout << "----------------------------------------------------------------------"<<endl;
+          //for ( int id = SMESH_Block::ID_V000; id < SMESH_Block::ID_Shell; ++id)
+          //{
+          //  gp_XYZ p = pointOnShape[ id ];
+          //  SMESH_Block::DumpShapeID( id,cout)<<" ( "<<p.X()<<", "<<p.Y()<<", "<<p.Z()<<" )"<<endl;
+          //}
+          //cout << "Params: ( "<< params.X()<<", "<<params.Y()<<", "<<params.Z()<<" )"<<endl;
+          //cout << "coords: ( "<< coords.X()<<", "<<coords.Y()<<", "<<coords.Z()<<" )"<<endl;
+#endif
+        }
+      }
+    }
+    // ----------------
+    // Add hexahedrons
+    // ----------------
+
+    // find out orientation by a least distorted hexahedron (issue 0020855);
+    // the last is defined by evaluating sum of face normals of 8 corner hexahedrons
+    double badness = numeric_limits<double>::max();
+    bool isForw = true;
+    for ( int xMax = 0; xMax < 2; ++xMax )
+      for ( int yMax = 0; yMax < 2; ++yMax )
+        for ( int zMax = 0; zMax < 2; ++zMax )
+        {
+          x = xMax ? xSize-1 : 1;
+          y = yMax ? ySize-1 : 1;
+          z = zMax ? zSize-1 : 1;
+          vector< const SMDS_MeshNode* >& col00 = columns[ colIndex( x-1, y-1 )];
+          vector< const SMDS_MeshNode* >& col10 = columns[ colIndex( x  , y-1 )];
+          vector< const SMDS_MeshNode* >& col01 = columns[ colIndex( x-1, y   )];
+          vector< const SMDS_MeshNode* >& col11 = columns[ colIndex( x  , y )];
+          
+          const SMDS_MeshNode* n000 = col00[z-1];
+          const SMDS_MeshNode* n100 = col10[z-1];
+          const SMDS_MeshNode* n010 = col01[z-1];
+          const SMDS_MeshNode* n110 = col11[z-1];
+          const SMDS_MeshNode* n001 = col00[z];
+          const SMDS_MeshNode* n101 = col10[z];
+          const SMDS_MeshNode* n011 = col01[z];
+          const SMDS_MeshNode* n111 = col11[z];
+          SMDS_VolumeOfNodes probeVolume (n000,n010,n110,n100,
+                                          n001,n011,n111,n101);
+          SMDS_VolumeTool volTool( &probeVolume );
+          double Nx=0.,Ny=0.,Nz=0.;
+          for ( int iFace = 0; iFace < volTool.NbFaces(); ++iFace )
+          {
+            double nx,ny,nz;
+            volTool.GetFaceNormal( iFace, nx,ny,nz );
+            Nx += nx;
+            Ny += ny;
+            Nz += nz;
+          }
+          double quality = Nx*Nx + Ny*Ny + Nz*Nz;
+          if ( quality < badness )
+          {
+            badness = quality;
+            isForw = volTool.IsForward();
+          }
+        }
+
+    // add elements
+    for ( x = 0; x < xSize-1; ++x ) {
+      for ( y = 0; y < ySize-1; ++y ) {
+        vector< const SMDS_MeshNode* >& col00 = columns[ colIndex( x, y )];
+        vector< const SMDS_MeshNode* >& col10 = columns[ colIndex( x+1, y )];
+        vector< const SMDS_MeshNode* >& col01 = columns[ colIndex( x, y+1 )];
+        vector< const SMDS_MeshNode* >& col11 = columns[ colIndex( x+1, y+1 )];
+        // bottom face normal of a hexa mush point outside the volume
+        if ( isForw )
+          for ( z = 0; z < zSize-1; ++z )
+            aHelper->AddVolume(col00[z],   col01[z],   col11[z],   col10[z],
+                               col00[z+1], col01[z+1], col11[z+1], col10[z+1]);
+        else
+          for ( z = 0; z < zSize-1; ++z )
+            aHelper->AddVolume(col00[z],   col10[z],   col11[z],   col01[z],
+                               col00[z+1], col10[z+1], col11[z+1], col01[z+1]);
+      }
+    }
+  } // loop on blocks
+
+  return true;
+}
+
+
+//================================================================================
+/*!
+ * \brief Main method, which generates hexaheda
+ */
+//================================================================================
+bool SMESH_HexaFromSkin_3D::Compute( SMESH_Mesh & aMesh, SMESH_MesherHelper* aHelper,
+      std::map<HEXA_NS::Hexa*, SMESH_HexaBlocks::SMESHVolumes>& volumesOnHexa,
+      std::map<HEXA_NS::Vertex*, SMDS_MeshNode*> vertexNode )
+          {
+  if(MYDEBUG) MESSAGE("SMESH_HexaFromSkin_3D::Compute BEGIN");
+  _Skin skin;
+  int nbBlocks = skin.findBlocks(aMesh);
+  if ( nbBlocks == 0 )
+    return error( skin.error());
+
+  vector< vector< const SMDS_MeshNode* > > columns;
+  int x, xSize, y, ySize, z, zSize;
+  _Indexer colIndex;
+
+  for ( int i = 0; i < nbBlocks; ++i )
+  {
+    const _Block& block = skin.getBlock( i );
+
+    // ------------------------------------------
+    // Fill columns of nodes with existing nodes
+    // ------------------------------------------
+
+    xSize = block.getSide(B_BOTTOM).getHoriSize();
+    ySize = block.getSide(B_BOTTOM).getVertSize();
+    zSize = block.getSide(B_FRONT ).getVertSize();
+    int X = xSize - 1, Y = ySize - 1, Z = zSize - 1;
+    colIndex = _Indexer( xSize, ySize );
+    columns.resize( colIndex.size() );
+
+    // fill node columns by front and back box sides
+    for ( x = 0; x < xSize; ++x ) {
+      vector< const SMDS_MeshNode* >& column0 = columns[ colIndex( x, 0 )];
+      vector< const SMDS_MeshNode* >& column1 = columns[ colIndex( x, Y )];
+      column0.resize( zSize );
+      column1.resize( zSize );
+      for ( z = 0; z < zSize; ++z ) {
+        column0[ z ] = block.getSide(B_FRONT).node( x, z );
+        column1[ z ] = block.getSide(B_BACK) .node( x, z );
+          }
+    }
+    // fill node columns by left and right box sides
+    for ( y = 1; y < ySize-1; ++y ) {
+      vector< const SMDS_MeshNode* >& column0 = columns[ colIndex( 0, y )];
+      vector< const SMDS_MeshNode* >& column1 = columns[ colIndex( X, y )];
+      column0.resize( zSize );
+      column1.resize( zSize );
+      for ( z = 0; z < zSize; ++z ) {
+        column0[ z ] = block.getSide(B_LEFT) .node( y, z );
+        column1[ z ] = block.getSide(B_RIGHT).node( y, z );
+      }
+    }
+    // get nodes from top and bottom box sides
+    for ( x = 1; x < xSize-1; ++x ) {
+      for ( y = 1; y < ySize-1; ++y ) {
+        vector< const SMDS_MeshNode* >& column = columns[ colIndex( x, y )];
+        column.resize( zSize );
+        column.front() = block.getSide(B_BOTTOM).node( x, y );
+        column.back()  = block.getSide(B_TOP)   .node( x, y );
+      }
+    }
+
+    // ----------------------------
+    // Add internal nodes of a box
+    // ----------------------------
+    // projection points of internal nodes on box subshapes by which
+    // coordinates of internal nodes are computed
+    vector<gp_XYZ> pointOnShape( SMESH_Block::ID_Shell );
+
+    // projections on vertices are constant
+    pointOnShape[ SMESH_Block::ID_V000 ] = block.getSide(B_BOTTOM).xyz( 0, 0 );
+    pointOnShape[ SMESH_Block::ID_V100 ] = block.getSide(B_BOTTOM).xyz( X, 0 );
+    pointOnShape[ SMESH_Block::ID_V010 ] = block.getSide(B_BOTTOM).xyz( 0, Y );
+    pointOnShape[ SMESH_Block::ID_V110 ] = block.getSide(B_BOTTOM).xyz( X, Y );
+    pointOnShape[ SMESH_Block::ID_V001 ] = block.getSide(B_TOP).xyz( 0, 0 );
+    pointOnShape[ SMESH_Block::ID_V101 ] = block.getSide(B_TOP).xyz( X, 0 );
+    pointOnShape[ SMESH_Block::ID_V011 ] = block.getSide(B_TOP).xyz( 0, Y );
+    pointOnShape[ SMESH_Block::ID_V111 ] = block.getSide(B_TOP).xyz( X, Y );
+
+    for ( x = 1; x < xSize-1; ++x )
+          {
+      gp_XYZ params; // normalized parameters of internal node within a unit box
+      params.SetCoord( 1, x / double(X) );
+      for ( y = 1; y < ySize-1; ++y )
+      {
+        params.SetCoord( 2, y / double(Y) );
+        // column to fill during z loop
+        vector< const SMDS_MeshNode* >& column = columns[ colIndex( x, y )];
+        // projections on horizontal edges
+        pointOnShape[ SMESH_Block::ID_Ex00 ] = block.getSide(B_BOTTOM).xyz( x, 0 );
+        pointOnShape[ SMESH_Block::ID_Ex10 ] = block.getSide(B_BOTTOM).xyz( x, Y );
+        pointOnShape[ SMESH_Block::ID_E0y0 ] = block.getSide(B_BOTTOM).xyz( 0, y );
+        pointOnShape[ SMESH_Block::ID_E1y0 ] = block.getSide(B_BOTTOM).xyz( X, y );
+        pointOnShape[ SMESH_Block::ID_Ex01 ] = block.getSide(B_TOP).xyz( x, 0 );
+        pointOnShape[ SMESH_Block::ID_Ex11 ] = block.getSide(B_TOP).xyz( x, Y );
+        pointOnShape[ SMESH_Block::ID_E0y1 ] = block.getSide(B_TOP).xyz( 0, y );
+        pointOnShape[ SMESH_Block::ID_E1y1 ] = block.getSide(B_TOP).xyz( X, y );
+        // projections on horizontal sides
+        pointOnShape[ SMESH_Block::ID_Fxy0 ] = block.getSide(B_BOTTOM).xyz( x, y );
+        pointOnShape[ SMESH_Block::ID_Fxy1 ] = block.getSide(B_TOP)   .xyz( x, y );
+        for ( z = 1; z < zSize-1; ++z ) // z loop
+        {
+          params.SetCoord( 3, z / double(Z) );
+          // projections on vertical edges
+          pointOnShape[ SMESH_Block::ID_E00z ] = block.getSide(B_FRONT).xyz( 0, z );    
+          pointOnShape[ SMESH_Block::ID_E10z ] = block.getSide(B_FRONT).xyz( X, z );    
+          pointOnShape[ SMESH_Block::ID_E01z ] = block.getSide(B_BACK).xyz( 0, z );    
+          pointOnShape[ SMESH_Block::ID_E11z ] = block.getSide(B_BACK).xyz( X, z );
+          // projections on vertical sides
+          pointOnShape[ SMESH_Block::ID_Fx0z ] = block.getSide(B_FRONT).xyz( x, z );    
+          pointOnShape[ SMESH_Block::ID_Fx1z ] = block.getSide(B_BACK) .xyz( x, z );    
+          pointOnShape[ SMESH_Block::ID_F0yz ] = block.getSide(B_LEFT) .xyz( y, z );    
+          pointOnShape[ SMESH_Block::ID_F1yz ] = block.getSide(B_RIGHT).xyz( y, z );
+
+          // compute internal node coordinates
+          gp_XYZ coords;
+          SMESH_Block::ShellPoint( params, pointOnShape, coords );
+          column[ z ] = aHelper->AddNode( coords.X(), coords.Y(), coords.Z() );
+
+#ifdef DEB_GRID
+          // debug
+          //cout << "----------------------------------------------------------------------"<<endl;
+          //for ( int id = SMESH_Block::ID_V000; id < SMESH_Block::ID_Shell; ++id)
+          //{
+          //  gp_XYZ p = pointOnShape[ id ];
+          //  SMESH_Block::DumpShapeID( id,cout)<<" ( "<<p.X()<<", "<<p.Y()<<", "<<p.Z()<<" )"<<endl;
+          //}
+          //cout << "Params: ( "<< params.X()<<", "<<params.Y()<<", "<<params.Z()<<" )"<<endl;
+          //cout << "coords: ( "<< coords.X()<<", "<<coords.Y()<<", "<<coords.Z()<<" )"<<endl;
+#endif
+          }
+        }
+    }
+    // ----------------
+    // Add hexahedrons
+    // ----------------
+
+    // find out orientation
+    const SMDS_MeshNode* n000 = block.getSide(B_BOTTOM).cornerNode( 0, 0 );
+    const SMDS_MeshNode* n100 = block.getSide(B_BOTTOM).cornerNode( 1, 0 );
+    const SMDS_MeshNode* n010 = block.getSide(B_BOTTOM).cornerNode( 0, 1 );
+    const SMDS_MeshNode* n110 = block.getSide(B_BOTTOM).cornerNode( 1, 1 );
+    const SMDS_MeshNode* n001 = block.getSide(B_TOP).cornerNode( 0, 0 );
+    const SMDS_MeshNode* n101 = block.getSide(B_TOP).cornerNode( 1, 0 );
+    const SMDS_MeshNode* n011 = block.getSide(B_TOP).cornerNode( 0, 1 );
+    const SMDS_MeshNode* n111 = block.getSide(B_TOP).cornerNode( 1, 1 );
+    SMDS_VolumeOfNodes probeVolume (n000,n010,n110,n100,
+                                    n001,n011,n111,n101);
+    bool isForw = SMDS_VolumeTool( &probeVolume ).IsForward();
+
+    // add elements
+    SMESH_HexaBlocks::SMESHVolumes volumesOnBlock; //Groups creation
+
+    for ( x = 0; x < xSize-1; ++x ) {
+      for ( y = 0; y < ySize-1; ++y ) {
+        vector< const SMDS_MeshNode* >& col00 = columns[ colIndex( x, y )];
+        vector< const SMDS_MeshNode* >& col10 = columns[ colIndex( x+1, y )];
+        vector< const SMDS_MeshNode* >& col01 = columns[ colIndex( x, y+1 )];
+        vector< const SMDS_MeshNode* >& col11 = columns[ colIndex( x+1, y+1 )];
+        // bottom face normal of a hexa mush point outside the volume
+        if ( isForw )
+          for ( z = 0; z < zSize-1; ++z ){
+            SMDS_MeshVolume* newVolume = 
+            aHelper->AddVolume(col00[z],   col01[z],   col11[z],   col10[z],
+                               col00[z+1], col01[z+1], col11[z+1], col10[z+1]);
+            volumesOnBlock.push_back( newVolume );
+          }
+        else
+          for ( z = 0; z < zSize-1; ++z ){
+            SMDS_MeshVolume* newVolume = 
+            aHelper->AddVolume(col00[z],   col10[z],   col11[z],   col01[z],
+                               col00[z+1], col10[z+1], col11[z+1], col01[z+1]);
+            volumesOnBlock.push_back( newVolume );
+      }
+    }
+    }
+//     std::cout << "block i = " << i << std::endl;
+    HEXA_NS::Hexa* currentHexa = _block2Hexa( block, _doc, vertexNode );
+    if ( currentHexa != NULL ){
+//       std::cout<<"===== found ->"<<currentHexa<<" for block "<<i<<std::endl;
+      if ( volumesOnHexa.count(currentHexa)==0 ) {
+//         std::cout<<"added!! "<<std::endl;
+        volumesOnHexa[currentHexa] = volumesOnBlock;
+      } else {
+//         std::cout<<"already !! "<<std::endl;
+      }
+    } else {
+//       std::cout<<"===== not found ->"<<currentHexa<<" for block "<<i<<std::endl;
+    }
+
+  } // loop on blocks
+
+  if(MYDEBUG) MESSAGE("SMESH_HexaFromSkin_3D::Compute END");
+  return true;
+}
+
+//================================================================================
+/*!
+ * \brief Evaluate nb of hexa
+ */
+//================================================================================
+
+bool SMESH_HexaFromSkin_3D::Evaluate(SMESH_Mesh &         aMesh,
+                                          const TopoDS_Shape & aShape,
+                                          MapShapeNbElems&     aResMap)
+{
+  _Skin skin;
+  int nbBlocks = skin.findBlocks(aMesh);
+  if ( nbBlocks == 0 )
+    return error( skin.error());
+
+  bool secondOrder = aMesh.NbFaces( ORDER_QUADRATIC );
+
+  int entity = secondOrder ? SMDSEntity_Quad_Hexa : SMDSEntity_Hexa;
+  vector<int>& nbByType = aResMap[ aMesh.GetSubMesh( aShape )];
+  if ( entity >= nbByType.size() )
+    nbByType.resize( SMDSEntity_Last, 0 );
+
+  for ( int i = 0; i < nbBlocks; ++i )
+  {
+    const _Block& block = skin.getBlock( i );
+
+    int nbX = block.getSide(B_BOTTOM).getHoriSize();
+    int nbY = block.getSide(B_BOTTOM).getVertSize();
+    int nbZ = block.getSide(B_FRONT ).getVertSize();
+
+    int nbHexa  = (nbX-1) * (nbY-1) * (nbZ-1);
+    int nbNodes = (nbX-2) * (nbY-2) * (nbZ-2);
+    if ( secondOrder )
+      nbNodes +=
+        (nbX-2) * (nbY-2) * (nbZ-1) +
+        (nbX-2) * (nbY-1) * (nbZ-2) +
+        (nbX-1) * (nbY-2) * (nbZ-2);
+
+
+    nbByType[ entity ] += nbHexa;
+    nbByType[ SMDSEntity_Node ] += nbNodes;
+  }
+
+  return true;
+}
+
+//================================================================================
+/*!
+ * \brief Abstract method must be defined but does nothing
+ */
+//================================================================================
+
+bool SMESH_HexaFromSkin_3D::CheckHypothesis(SMESH_Mesh&, const TopoDS_Shape&,
+                                                 Hypothesis_Status& aStatus)
+{
+  aStatus = SMESH_Hypothesis::HYP_OK;
+  return true;
+}
+
+//================================================================================
+/*!
+ * \brief Abstract method must be defined but just reports an error as this
+ *  algo is not intended to work with shapes
+ */
+//================================================================================
+
+bool SMESH_HexaFromSkin_3D::Compute(SMESH_Mesh&, const TopoDS_Shape&)
+{
+  return error("Algorithm can't work with geometrical shapes");
+}
+
+
diff --git a/src/HEXABLOCKPlugin/HEXABLOCKPlugin_FromSkin_3D.hxx b/src/HEXABLOCKPlugin/HEXABLOCKPlugin_FromSkin_3D.hxx
new file mode 100755 (executable)
index 0000000..aac1fa8
--- /dev/null
@@ -0,0 +1,70 @@
+// Copyright (C) 2009-2012  CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+// File      : SMESH_HexaFromSkin_3D.hxx
+// Created   : Wed Jan 27 12:23:21 2010
+// Author    : Edward AGAPOV (eap)
+//
+#ifndef __SMESH_HexaFromSkin_3D_HXX__
+#define __SMESH_HexaFromSkin_3D_HXX__
+
+#include "SMESH_StdMeshers.hxx"
+#include "SMESH_3D_Algo.hxx"
+
+// from HexaBlocks
+#include "hexa_base.hxx" 
+#include "HexDocument.hxx"
+#include "HexVertex.hxx"
+// #include "HexEdge.hxx"
+// #include "HexQuad.hxx"
+#include "HexHexa.hxx"
+#include "HEXABLOCKPlugin_mesh.hxx"
+
+/*!
+ * \brief Alorithm generating hexahedral mesh from 2D skin of block
+ */
+
+class STDMESHERS_EXPORT SMESH_HexaFromSkin_3D : public SMESH_3D_Algo
+{
+public:
+//   SMESH_HexaFromSkin_3D(int hypId, int studyId, SMESH_Gen* gen);
+  SMESH_HexaFromSkin_3D(int hypId, int studyId, SMESH_Gen* gen, HEXA_NS::Document* doc);
+  virtual ~SMESH_HexaFromSkin_3D();
+
+  virtual bool Compute(SMESH_Mesh & aMesh, SMESH_MesherHelper* aHelper);
+  virtual bool Compute(SMESH_Mesh & aMesh, SMESH_MesherHelper* aHelper,
+      std::map<HEXA_NS::Hexa*, SMESH_HexaBlocks::SMESHVolumes>& volumesOnHexa,
+      std::map<HEXA_NS::Vertex*, SMDS_MeshNode*> vertexNode );
+
+  virtual bool CheckHypothesis(SMESH_Mesh& aMesh,
+                               const TopoDS_Shape& aShape,
+                               Hypothesis_Status& aStatus);
+
+  virtual bool Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape);
+
+  virtual bool Evaluate(SMESH_Mesh &         aMesh,
+                        const TopoDS_Shape & aShape,
+                        MapShapeNbElems&     aResMap);
+
+private:
+  HEXA_NS::Document*  _doc;
+
+};
+
+#endif
diff --git a/src/HEXABLOCKPlugin/HEXABLOCKPlugin_HEXABLOCK.cxx b/src/HEXABLOCKPlugin/HEXABLOCKPlugin_HEXABLOCK.cxx
new file mode 100755 (executable)
index 0000000..9c5fdca
--- /dev/null
@@ -0,0 +1,403 @@
+// Copyright (C) 2009-2012  CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+//=============================================================================
+// File      : HEXABLOCKPlugin_HEXABLOCK.cxx
+// Created   : 
+// Author    : Lioka RAZAFINDRAZAKA (CEA)
+// Project   : SALOME
+// $Header$
+//=============================================================================
+//
+#include "HEXABLOCKPlugin_HEXABLOCK.hxx"
+#include "HEXABLOCKPlugin_Hypothesis.hxx"
+
+#include "TopExp_Explorer.hxx"
+
+#include <Basics_Utils.hxx>
+
+#include "SMESH_Gen.hxx"
+#include "SMESH_Mesh.hxx"
+#include "SMESH_MesherHelper.hxx"
+
+#include "HEXABLOCKPlugin_mesh.hxx"
+#include "HexQuad.hxx"
+#include "HexEdge.hxx"
+#include "HexVertex.hxx"
+#include "HexPropagation.hxx"
+
+#include "utilities.h"
+
+using namespace std;
+
+#ifdef _DEBUG_
+static int MYDEBUG = 1;
+#else
+static int MYDEBUG = 0;
+#endif
+
+//=============================================================================
+/*!
+ *  
+ */
+//=============================================================================
+
+HEXABLOCKPlugin_HEXABLOCK::HEXABLOCKPlugin_HEXABLOCK(int hypId, int studyId, SMESH_Gen* gen)
+  : SMESH_3D_Algo(hypId, studyId, gen)
+{
+  if(MYDEBUG) MESSAGE("HEXABLOCKPlugin_HEXABLOCK::HEXABLOCKPlugin_HEXABLOCK");
+  _name = "HEXABLOCK_3D";
+  _shapeType = (1 << TopAbs_SHELL) | (1 << TopAbs_SOLID);// 1 bit /shape type
+  _compatibleHypothesis.push_back("HEXABLOCK_Parameters");
+  _requireShape = false; // can work without shape
+  _requireDiscreteBoundary = false;
+  _hyp = NULL;
+  _supportSubmeshes = false;
+  _iShape  = 0;
+  _nbShape = 0;
+}
+
+//=============================================================================
+/*!
+ *  
+ */
+//=============================================================================
+
+HEXABLOCKPlugin_HEXABLOCK::~HEXABLOCKPlugin_HEXABLOCK()
+{
+  if(MYDEBUG) MESSAGE("HEXABLOCKPlugin_HEXABLOCK::~HEXABLOCKPlugin_HEXABLOCK");
+}
+
+//=============================================================================
+/*!
+ *  
+ */
+//=============================================================================
+
+bool HEXABLOCKPlugin_HEXABLOCK::CheckHypothesis ( SMESH_Mesh& aMesh,
+                                          const TopoDS_Shape& aShape,
+                                          Hypothesis_Status&  aStatus )
+{
+  aStatus = SMESH_Hypothesis::HYP_OK;
+
+  // there is only one compatible Hypothesis so far
+  _hyp = 0;
+  const list <const SMESHDS_Hypothesis * >& hyps = GetUsedHypothesis(aMesh, aShape);
+  if ( !hyps.empty() )
+    _hyp = static_cast<const HEXABLOCKPlugin_Hypothesis*> ( hyps.front() );
+
+  return true;
+}
+
+//=============================================================================
+/*!
+ *Here we are going to use the HEXABLOCK mesher
+ */
+//=============================================================================
+
+bool HEXABLOCKPlugin_HEXABLOCK::Compute(SMESH_Mesh& theMesh, const TopoDS_Shape& theShape) {
+  if(MYDEBUG) MESSAGE("HEXABLOCKPlugin_HEXABLOCK::Compute with a shape");
+
+  SMESHDS_Mesh* meshDS = theMesh.GetMeshDS();
+  if ( (_iShape == 0) && (_nbShape == 0) ) {
+    TopExp_Explorer expShape ( meshDS->ShapeToMesh(), TopAbs_SOLID );
+    for ( ; expShape.More(); expShape.Next() ) {
+      _nbShape++;
+    }
+  }
+
+  // to prevent from displaying error message after computing,
+  for ( int i = 0; i < _nbShape; ++i )
+    if ( SMESH_subMesh* sm = theMesh.GetSubMeshContaining( theShape ))
+    {
+      SMESH_subMeshIteratorPtr smIt = sm->getDependsOnIterator(/*includeSelf=*/true,
+                                                               /*complexShapeFirst=*/false);
+      while ( smIt->more() )
+      {
+        sm = smIt->next();
+        if ( !sm->IsMeshComputed() )
+          sm->SetIsAlwaysComputed( true );
+      }
+    }
+
+
+  _iShape++;
+
+  if ( _iShape == _nbShape ) {
+    _nbShape = 0;
+    _iShape  = 0;
+
+    switch (_hyp->GetDimension()) {
+      case 0 : return( Compute0D(theMesh) );
+      case 1 : return( Compute1D(theMesh) );
+      case 2 : return( Compute2D(theMesh) );
+      default: return( Compute3D(theMesh) );
+    };
+  }
+}
+
+//=============================================================================
+/*!
+ *Here we are going to use the HEXABLOCK mesher w/o geometry
+ */
+//=============================================================================
+
+bool HEXABLOCKPlugin_HEXABLOCK::Compute(SMESH_Mesh& theMesh,
+                                SMESH_MesherHelper* aHelper)
+{
+  if(MYDEBUG) MESSAGE("HEXABLOCKPlugin_HEXABLOCK::Compute without a shape");
+
+  switch (_hyp->GetDimension()) {
+    case 0 : return( Compute0D(theMesh) );
+    case 1 : return( Compute1D(theMesh) );
+    case 2 : return( Compute2D(theMesh) );
+    default: return( Compute3D(theMesh) );
+  }
+}
+
+//=============================================================================
+/*!
+ *  
+ */
+//=============================================================================
+bool HEXABLOCKPlugin_HEXABLOCK::Evaluate(SMESH_Mesh& aMesh,
+                                 const TopoDS_Shape& aShape,
+                                 MapShapeNbElems& aResMap)
+{
+  if(MYDEBUG) MESSAGE("HEXABLOCKPlugin_HEXABLOCK::Evaluate: do nothing");
+
+  return true;
+}
+
+//=============================================================================
+/*!
+ *  Generate hexehedral
+ */
+//=============================================================================
+
+bool HEXABLOCKPlugin_HEXABLOCK::Compute3D(SMESH_Mesh& theMesh) {
+  if(MYDEBUG) MESSAGE("HEXABLOCKPlugin_HEXABLOCK::Compute 3D Begin");
+
+  SMESH_HexaBlocks hexaBuilder(theMesh);
+
+  HEXA_NS::Document* doc = _hyp->GetDocument();
+  // doc->reorderFaces ();                 // 0) Abu 06/03/2012
+
+  hexaBuilder.computeDoc(doc);
+  hexaBuilder.buildGroups(doc); 
+
+  if(MYDEBUG) MESSAGE("HEXABLOCKPlugin_HEXABLOCK::Compute 3D End");
+  return true;
+}
+
+//=============================================================================
+/*!
+ *  Generate quadrangles
+ */
+//=============================================================================
+
+bool HEXABLOCKPlugin_HEXABLOCK::Compute2D(SMESH_Mesh& theMesh)
+{
+  if(MYDEBUG) MESSAGE("HEXABLOCKPlugin_HEXABLOCK::Compute 2D");
+
+  HEXA_NS::Document* doc = _hyp->GetDocument();
+  // doc->reorderFaces ();                 // 0) Abu 06/03/2012
+
+  SMESH_HexaBlocks hexaBuilder(theMesh);
+
+  // A) Vertex computation
+  int nVertex = doc->countUsedVertex();
+  HEXA_NS::Vertex* vertex = NULL;
+  for ( int j=0; j <nVertex; ++j ){ //Computing each vertex of the document
+    vertex = doc->getUsedVertex(j);
+    hexaBuilder.computeVertex(*vertex);
+  };
+
+  // B) Edges computation
+  int nbPropa = 0;
+  HEXA_NS::Propagation* propa = NULL;
+  HEXA_NS::Law*         law   = NULL;
+  HEXA_NS::Edges        edges;
+
+  nbPropa = doc->countPropagation();
+  for (int j=0; j < nbPropa; ++j ){ //Computing each edge's propagations of the document
+    propa = doc->getPropagation(j);
+    edges = propa->getEdges();
+    law   = propa->getLaw();
+    if (law == NULL){
+      law = doc->getLaw(0); // default law
+    };
+    for( HEXA_NS::Edges::const_iterator iter = edges.begin(); iter != edges.end(); ++iter ) {
+      hexaBuilder.computeEdge(**iter, *law);
+    };
+  };
+
+  // C) Quad computation
+  std::map<HEXA_NS::Quad*, bool>  quadWays = hexaBuilder.computeQuadWays(doc);
+  int nQuad = doc->countUsedQuad();
+  HEXA_NS::Quad* quad = NULL;
+  for (int j=0; j <nQuad; ++j ){ //Computing each quad of the document
+    quad = doc->getUsedQuad(j);
+    int id = quad->getId();
+    if ( quadWays.count(quad) > 0 )
+      hexaBuilder.computeQuad(*quad, quadWays[quad]);
+    else
+      if(MYDEBUG) MESSAGE("NO QUAD WAY ID = "<<id);
+  };
+
+  // D) build Groups
+  hexaBuilder.buildGroups(doc);
+
+    return true;
+}
+
+// SMESH::SMESH_Mesh_ptr SMESH_Gen_i::HexaBlocksQuad( HEXABLOCK_ORB::Document_ptr docIn, ::CORBA::Long quadID )
+// {
+//   try {
+//     SMESH::SMESH_Mesh_var aNewMesh = CreateEmptyMesh();
+//     if ( !aNewMesh->_is_nil() ) {
+//       SMESH_Mesh_i* aNewImpl    = dynamic_cast<SMESH_Mesh_i*>( GetServant( aNewMesh ).in() );
+//       Document_impl* docServant = dynamic_cast<Document_impl*>( GetServant( docIn ).in() );
+//       ASSERT( aNewImpl );
+//       ASSERT( docServant );
+
+//       HEXA_NS::Document* doc = docServant->GetImpl();
+//       SMESH_HexaBlocks hexaBuilder(aNewImpl);
+
+//       // A) Vertex computation
+//       int nVertex = doc->countVertex();
+//       HEXA_NS::Vertex* vertex = NULL;
+//       for ( int j=0; j <nVertex; ++j ){ //Computing each vertex of the document
+//         vertex = doc->getUsedVertex(j);
+//         hexaBuilder.computeVertex(*vertex);
+//       }
+
+//       // B) Edges computation
+//       int nbPropa = 0;
+//       HEXA_NS::Propagation* propa = NULL;
+//       HEXA_NS::Law*         law   = NULL;
+//       HEXA_NS::Edges        edges;
+
+//       nbPropa = doc->countPropagation();
+//       for (int j=0; j < nbPropa; ++j ){//Computing each edge's propagations of the document
+//         propa = doc->getPropagation(j);
+//         edges = propa->getEdges();
+//         law   = propa->getLaw();
+// //         ASSERT( law );
+//         if (law == NULL){
+//           law = doc->getLaw(0); // default law
+//         }
+//         for( HEXA_NS::Edges::const_iterator iter = edges.begin();
+//             iter != edges.end();
+//             ++iter ){
+//             hexaBuilder.computeEdge(**iter, *law);
+//         }
+//       }
+
+//       // C) Quad computation
+//       std::map<HEXA_NS::Quad*, bool>  quadWays = hexaBuilder.computeQuadWays(*doc);
+//       int nQuad = doc->countQuad();
+//       HEXA_NS::Quad* quad = NULL;
+//       for (int j=0; j <nQuad; ++j ){ //Computing each quad of the document
+//         quad = doc->getQuad(j);
+//         int id = quad->getId();
+//         if ( quadID == id and (quadWays.count(quad) > 0) )
+//           hexaBuilder.computeQuad( *quad, quadWays[quad] );
+
+//         if ( quadWays.count(quad) ==  0 )
+//             if(MYDEBUG) MESSAGE("NO QUAD WAY ID = "<<id);
+
+//       }
+
+//       // D) build Groups
+//       hexaBuilder.buildGroups(doc);
+
+//     }
+//     return aNewMesh._retn();
+//   } catch (SALOME_Exception& S_ex) {
+//     THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
+//   }
+// }
+
+bool HEXABLOCKPlugin_HEXABLOCK::Compute1D(SMESH_Mesh& theMesh)
+{
+  if(MYDEBUG) MESSAGE("HEXABLOCKPlugin_HEXABLOCK::Compute 1D");
+
+  HEXA_NS::Document* doc = _hyp->GetDocument();
+  // doc->reorderFaces ();                 // 0) Abu 06/03/2012
+
+  SMESH_HexaBlocks hexaBuilder(theMesh);
+
+  // A) Vertex computation
+  int nVertex = doc->countUsedVertex();
+  HEXA_NS::Vertex* vertex = NULL;
+  for ( int j=0; j <nVertex; ++j ){ //Computing each vertex of the document
+    vertex = doc->getUsedVertex(j);
+    hexaBuilder.computeVertex(*vertex);
+  };
+
+  // B) Edges computation
+  int nbPropa = 0;
+  HEXA_NS::Propagation* propa = NULL;
+  HEXA_NS::Law*         law   = NULL;
+  HEXA_NS::Edges        edges;
+
+  nbPropa = doc->countPropagation();
+  for (int j=0; j < nbPropa; ++j ){//Computing each edge's propagations of the document
+    propa = doc->getPropagation(j);
+    edges = propa->getEdges();
+    law   = propa->getLaw();
+    //         ASSERT( law );
+    if (law == NULL){
+      law = doc->getLaw(0); // default law
+    };
+    for( HEXA_NS::Edges::const_iterator iter = edges.begin(); iter != edges.end(); ++iter ) {
+      hexaBuilder.computeEdge(**iter, *law);
+    };
+  };
+
+  // C) build Groups
+  hexaBuilder.buildGroups(doc);
+
+    return true;
+}
+
+bool HEXABLOCKPlugin_HEXABLOCK::Compute0D(SMESH_Mesh& theMesh)
+{
+  if(MYDEBUG) MESSAGE("HEXABLOCKPlugin_HEXABLOCK::Compute 0D");
+
+  HEXA_NS::Document* doc = _hyp->GetDocument();
+  // doc->reorderFaces ();                 // 0) Abu 06/03/2012
+
+  SMESH_HexaBlocks hexaBuilder(theMesh);
+
+  // A) Vertex computation
+  int nVertex = doc->countUsedVertex();
+  HEXA_NS::Vertex* vertex = NULL;
+  for ( int j=0; j <nVertex; ++j ){ //Computing each vertex of the document
+    vertex = doc->getUsedVertex(j);
+    hexaBuilder.computeVertex(*vertex);
+  };
+
+  // B) build Groups
+  hexaBuilder.buildGroups(doc);
+
+  return true;
+}
diff --git a/src/HEXABLOCKPlugin/HEXABLOCKPlugin_HEXABLOCK.hxx b/src/HEXABLOCKPlugin/HEXABLOCKPlugin_HEXABLOCK.hxx
new file mode 100755 (executable)
index 0000000..5817a42
--- /dev/null
@@ -0,0 +1,66 @@
+// Copyright (C) 2009-2012  CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+//=============================================================================
+// File      : HEXABLOCKPlugin_HEXABLOCK.hxx
+// Author    : Lioka RAZAFINDRAZAKA (CEA)
+// Project   : SALOME
+// $Header$
+//=============================================================================
+//
+#ifndef _HEXABLOCKPlugin_HEXABLOCK_HXX_
+#define _HEXABLOCKPlugin_HEXABLOCK_HXX_
+
+#include "SMESH_3D_Algo.hxx"
+#include "SMESH_Mesh.hxx"
+
+class SMESH_Mesh;
+class HEXABLOCKPlugin_Hypothesis;
+
+class HEXABLOCKPlugin_HEXABLOCK: public SMESH_3D_Algo
+{
+public:
+  HEXABLOCKPlugin_HEXABLOCK(int hypId, int studyId, SMESH_Gen* gen);
+  virtual ~HEXABLOCKPlugin_HEXABLOCK();
+
+  virtual bool CheckHypothesis(SMESH_Mesh&         aMesh,
+                               const TopoDS_Shape& aShape,
+                               Hypothesis_Status&  aStatus);
+
+  virtual bool Compute(SMESH_Mesh&         aMesh,
+                       const TopoDS_Shape& aShape);
+
+  virtual bool Evaluate(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape,
+                        MapShapeNbElems& aResMap);
+
+  virtual bool Compute(SMESH_Mesh&         theMesh,
+                       SMESH_MesherHelper* aHelper);
+
+  bool Compute3D(SMESH_Mesh& aMesh);
+  bool Compute2D(SMESH_Mesh& aMesh);
+  bool Compute1D(SMESH_Mesh& aMesh);
+  bool Compute0D(SMESH_Mesh& aMesh);
+
+private:
+  const HEXABLOCKPlugin_Hypothesis* _hyp;
+  int  _iShape;
+  int  _nbShape;
+};
+
+#endif
diff --git a/src/HEXABLOCKPlugin/HEXABLOCKPlugin_HEXABLOCK_i.cxx b/src/HEXABLOCKPlugin/HEXABLOCKPlugin_HEXABLOCK_i.cxx
new file mode 100755 (executable)
index 0000000..65428ab
--- /dev/null
@@ -0,0 +1,88 @@
+// Copyright (C) 2009-2012  CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+//  SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses
+//  File   : HEXABLOCKPlugin_HEXABLOCK_i.cxx
+//  Author : Lioka RAZAFINDRAZAKA (CEA)
+//  Module : HEXABLOCKPlugin
+//  $Header$
+//
+#include "HEXABLOCKPlugin_HEXABLOCK_i.hxx"
+#include "SMESH_Gen.hxx"
+#include "HEXABLOCKPlugin_HEXABLOCK.hxx"
+
+#include "utilities.h"
+
+#ifdef _DEBUG_
+static int MYDEBUG = 1;
+#else
+static int MYDEBUG = 0;
+#endif
+
+using namespace std;
+
+//=============================================================================
+/*!
+ *  HEXABLOCKPlugin_HEXABLOCK_i::HEXABLOCKPlugin_HEXABLOCK_i
+ *
+ *  Constructor
+ */
+//=============================================================================
+
+HEXABLOCKPlugin_HEXABLOCK_i::HEXABLOCKPlugin_HEXABLOCK_i (PortableServer::POA_ptr thePOA,
+                                          int                     theStudyId,
+                                          ::SMESH_Gen*            theGenImpl )
+     : SALOME::GenericObj_i( thePOA ), 
+       SMESH_Hypothesis_i( thePOA ), 
+       SMESH_Algo_i( thePOA ),
+       SMESH_3D_Algo_i( thePOA )
+{
+  if(MYDEBUG) MESSAGE( "HEXABLOCKPlugin_HEXABLOCK_i::HEXABLOCKPlugin_HEXABLOCK_i" );
+  myBaseImpl = new ::HEXABLOCKPlugin_HEXABLOCK (theGenImpl->GetANewId(),
+                                        theStudyId,
+                                        theGenImpl );
+}
+
+//=============================================================================
+/*!
+ *  HEXABLOCKPlugin_HEXABLOCK_i::~HEXABLOCKPlugin_HEXABLOCK_i
+ *
+ *  Destructor
+ */
+//=============================================================================
+
+HEXABLOCKPlugin_HEXABLOCK_i::~HEXABLOCKPlugin_HEXABLOCK_i()
+{
+  if(MYDEBUG) MESSAGE( "HEXABLOCKPlugin_HEXABLOCK_i::~HEXABLOCKPlugin_HEXABLOCK_i" );
+}
+
+//=============================================================================
+/*!
+ *  HEXABLOCKPlugin_HEXABLOCK_i::GetImpl
+ *
+ *  Get implementation
+ */
+//=============================================================================
+
+::HEXABLOCKPlugin_HEXABLOCK* HEXABLOCKPlugin_HEXABLOCK_i::GetImpl()
+{
+  if(MYDEBUG) MESSAGE( "HEXABLOCKPlugin_HEXABLOCK_i::GetImpl" );
+  return ( ::HEXABLOCKPlugin_HEXABLOCK* )myBaseImpl;
+}
+
diff --git a/src/HEXABLOCKPlugin/HEXABLOCKPlugin_HEXABLOCK_i.hxx b/src/HEXABLOCKPlugin/HEXABLOCKPlugin_HEXABLOCK_i.hxx
new file mode 100755 (executable)
index 0000000..b0ffdef
--- /dev/null
@@ -0,0 +1,54 @@
+// Copyright (C) 2009-2012  CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+//  File   : HEXABLOCKPlugin_HEXABLOCK_i.hxx
+//  Author : Lioka RAZAFINDRAZAKA (CEA)
+//  Module : HEXABLOCKPlugin
+//  $Header$
+//
+#ifndef _HEXABLOCKPlugin_HEXABLOCK_I_HXX_
+#define _HEXABLOCKPlugin_HEXABLOCK_I_HXX_
+
+#include <SALOMEconfig.h>
+#include CORBA_SERVER_HEADER(HEXABLOCKPlugin_Algorithm)
+#include CORBA_SERVER_HEADER(SALOME_Exception)
+
+#include "SMESH_3D_Algo_i.hxx"
+#include "HEXABLOCKPlugin_HEXABLOCK.hxx"
+
+// ======================================================
+// HEXABLOCK 3d algorithm
+// ======================================================
+class HEXABLOCKPlugin_HEXABLOCK_i:
+  public virtual POA_HEXABLOCKPlugin::HEXABLOCKPlugin_HEXABLOCK,
+  public virtual SMESH_3D_Algo_i
+{
+public:
+  // Constructor
+  HEXABLOCKPlugin_HEXABLOCK_i (PortableServer::POA_ptr thePOA,
+                       int                     theStudyId,
+                       ::SMESH_Gen*            theGenImpl );
+  // Destructor
+  virtual ~HEXABLOCKPlugin_HEXABLOCK_i();
+  // Get implementation
+  ::HEXABLOCKPlugin_HEXABLOCK* GetImpl();
+};
+
+#endif
diff --git a/src/HEXABLOCKPlugin/HEXABLOCKPlugin_Hypothesis.cxx b/src/HEXABLOCKPlugin/HEXABLOCKPlugin_Hypothesis.cxx
new file mode 100755 (executable)
index 0000000..c13474f
--- /dev/null
@@ -0,0 +1,134 @@
+// Copyright (C) 2009-2012  CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+//=============================================================================
+// File      : HEXABLOCKPlugin_Hypothesis.cxx
+// Created   : Wed Apr  2 12:36:29 2008
+// Author    : Lioka RAZAFINDRAZAKA (CEA)
+//=============================================================================
+//
+#include "HEXABLOCKPlugin_Hypothesis.hxx"
+
+//=======================================================================
+//function : HEXABLOCKPlugin_Hypothesis
+//=======================================================================
+
+HEXABLOCKPlugin_Hypothesis::HEXABLOCKPlugin_Hypothesis(int hypId, int studyId, SMESH_Gen * gen)
+  : SMESH_Hypothesis(hypId, studyId, gen),
+  _document(NULL),
+  _dimension(3)
+{
+  _name = "HEXABLOCK_Parameters";
+  _param_algo_dim = 3;
+}
+
+//=======================================================================
+//function : GetDocument
+//=======================================================================
+
+HEXA_NS::Document* HEXABLOCKPlugin_Hypothesis::GetDocument() const
+{
+  return(_document);
+}
+
+//=======================================================================
+//function : SetDocument
+//=======================================================================
+
+void HEXABLOCKPlugin_Hypothesis::SetDocument(HEXA_NS::Document* doc)
+{
+  _document = doc;
+}
+
+//=======================================================================
+//function : GetDimension
+//=======================================================================
+
+int HEXABLOCKPlugin_Hypothesis::GetDimension() const
+{
+  return(_dimension);
+}
+
+//=======================================================================
+//function : SetDimension
+//=======================================================================
+
+void HEXABLOCKPlugin_Hypothesis::SetDimension(int dim)
+{
+  _dimension = dim;
+}
+
+//=======================================================================
+//function : SaveTo
+//=======================================================================
+
+std::ostream & HEXABLOCKPlugin_Hypothesis::SaveTo(std::ostream & save)
+{
+//save << _document->getXML() << " ";
+  save <<_dimension           << " ";
+
+  return save;
+}
+
+//=======================================================================
+//function : LoadFrom
+//=======================================================================
+
+std::istream & HEXABLOCKPlugin_Hypothesis::LoadFrom(std::istream & load)
+{
+    bool isOK = true;
+    int i;
+
+//     char* str;
+//     isOK = (load >> str);
+//     if (isOK)
+//         _document = xml_2_doc(str);
+//     else
+//         load.clear(ios::badbit | load.rdstate());
+    
+    isOK = (load >> i);
+    if (isOK)
+        _dimension = i;
+    else
+        load.clear(ios::badbit | load.rdstate());
+    
+  return load;
+}
+
+//=======================================================================
+//function : SetParametersByMesh
+//=======================================================================
+
+bool HEXABLOCKPlugin_Hypothesis::SetParametersByMesh(const SMESH_Mesh* ,const TopoDS_Shape&)
+{
+  return false;
+}
+
+
+//================================================================================
+/*!
+ * \brief Return false
+ */
+//================================================================================
+
+bool HEXABLOCKPlugin_Hypothesis::SetParametersByDefaults(const TDefaults&  /*dflts*/,
+                                                     const SMESH_Mesh* /*theMesh*/)
+{
+  return false;
+}
diff --git a/src/HEXABLOCKPlugin/HEXABLOCKPlugin_Hypothesis.hxx b/src/HEXABLOCKPlugin/HEXABLOCKPlugin_Hypothesis.hxx
new file mode 100755 (executable)
index 0000000..27407b6
--- /dev/null
@@ -0,0 +1,79 @@
+// Copyright (C) 2009-2012  CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+//  HEXABLOCKPlugin : C++ implementation
+// File      : HEXABLOCKPlugin_Hypothesis.hxx
+// Created   : Wed Apr  2 12:21:17 2008
+// Author    : Lioka RAZAFINDRAZAKA (CEA)
+//
+#ifndef HEXABLOCKPlugin_Hypothesis_HeaderFile
+#define HEXABLOCKPlugin_Hypothesis_HeaderFile
+
+#include "HEXABLOCKPlugin_Defs.hxx"
+
+#include <SMESH_Hypothesis.hxx>
+
+#include "HexDocument.hxx"
+
+#include <utilities.h>
+
+#include <stdexcept>
+#include <cstdio>
+
+class HEXABLOCKPLUGIN_EXPORT HEXABLOCKPlugin_Hypothesis: public SMESH_Hypothesis
+{
+public:
+
+  HEXABLOCKPlugin_Hypothesis(int hypId, int studyId, SMESH_Gen * gen);
+
+  /*!
+   * Define the document to be meshed, mandatory
+   */
+  void SetDocument(HEXA_NS::Document* doc);
+  HEXA_NS::Document* GetDocument() const;
+
+  /*!
+   * To define the hight dimension to generated: 3 = hexas, 2 = quads, 1 = segments, 0 = nodes
+   */
+  void SetDimension(int dim);
+  int GetDimension() const;
+
+  // Persistence
+  virtual std::ostream & SaveTo(std::ostream & save);
+  virtual std::istream & LoadFrom(std::istream & load);
+  friend HEXABLOCKPLUGIN_EXPORT std::ostream & operator <<(std::ostream & save, HEXABLOCKPlugin_Hypothesis & hyp);
+  friend HEXABLOCKPLUGIN_EXPORT std::istream & operator >>(std::istream & load, HEXABLOCKPlugin_Hypothesis & hyp);
+
+  /*!
+   * \brief Does nothing
+   */
+  virtual bool SetParametersByMesh(const SMESH_Mesh* theMesh, const TopoDS_Shape& theShape);
+
+  /*!
+   * \brief Does nothing
+   */
+  virtual bool SetParametersByDefaults(const TDefaults& dflts, const SMESH_Mesh* theMesh=0);
+
+private:
+  HEXA_NS::Document* _document;
+  int _dimension;
+};
+
+
+#endif
diff --git a/src/HEXABLOCKPlugin/HEXABLOCKPlugin_Hypothesis_i.cxx b/src/HEXABLOCKPlugin/HEXABLOCKPlugin_Hypothesis_i.cxx
new file mode 100755 (executable)
index 0000000..4e864ea
--- /dev/null
@@ -0,0 +1,126 @@
+// Copyright (C) 2009-2012  CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+// File      : HEXABLOCKPlugin_Hypothesis_i.cxx
+// Created   : Wed Apr  2 13:53:01 2008
+// Author    : Lioka RAZAFINDRAZAKA (CEA)
+//
+#include <SMESH_Gen.hxx>
+#include <SMESH_PythonDump.hxx>
+#include <SMESH_Mesh_i.hxx>
+
+#include "HEXABLOCK.hxx"
+#include "HEXABLOCKPlugin_Hypothesis_i.hxx"
+#include "HexDocument_impl.hxx"
+
+#include <Utils_CorbaException.hxx>
+#include <utilities.h>
+
+#ifdef _DEBUG_
+static int MYDEBUG = 1;
+#else
+static int MYDEBUG = 0;
+#endif
+
+//=======================================================================
+//function : HEXABLOCKPlugin_Hypothesis_i
+//=======================================================================
+
+HEXABLOCKPlugin_Hypothesis_i::HEXABLOCKPlugin_Hypothesis_i (PortableServer::POA_ptr thePOA,
+                                                    int                     theStudyId,
+                                                    ::SMESH_Gen*            theGenImpl)
+  : SALOME::GenericObj_i( thePOA ), 
+    SMESH_Hypothesis_i( thePOA )
+{
+  if(MYDEBUG) MESSAGE( "HEXABLOCKPlugin_Hypothesis_i::HEXABLOCKPlugin_Hypothesis_i" );
+  myBaseImpl = new ::HEXABLOCKPlugin_Hypothesis (theGenImpl->GetANewId(),
+                                              theStudyId,
+                                              theGenImpl);
+  _poa = PortableServer::POA::_duplicate(thePOA);
+}
+
+//=======================================================================
+//function : ~HEXABLOCKPlugin_Hypothesis_i
+//=======================================================================
+
+HEXABLOCKPlugin_Hypothesis_i::~HEXABLOCKPlugin_Hypothesis_i()
+{
+  if(MYDEBUG) MESSAGE( "HEXABLOCKPlugin_Hypothesis_i::~HEXABLOCKPlugin_Hypothesis_i" );
+}
+
+//=============================================================================
+/*!
+ *  Get implementation
+ */
+//=============================================================================
+
+::HEXABLOCKPlugin_Hypothesis* HEXABLOCKPlugin_Hypothesis_i::GetImpl()
+{
+  return (::HEXABLOCKPlugin_Hypothesis*)myBaseImpl;
+}
+
+//================================================================================
+/*!
+ * \brief Verify whether hypothesis supports given entity type 
+ */
+//================================================================================  
+
+CORBA::Boolean HEXABLOCKPlugin_Hypothesis_i::IsDimSupported( SMESH::Dimension type )
+{
+  return type == SMESH::DIM_3D;
+}
+
+//================================================================================
+/*!
+ * Define the document to be meshed, mandatory
+ */
+//================================================================================
+
+HEXABLOCK_ORB::Document_ptr HEXABLOCKPlugin_Hypothesis_i::GetDocument() {
+  ASSERT(myBaseImpl);
+  HEXA_NS::Document* d = this->GetImpl()->GetDocument();
+  Document_impl* servantCorba = new Document_impl(_poa, d);
+  HEXABLOCK_ORB::Document_ptr result = servantCorba->_this();
+  return result;
+}
+
+void HEXABLOCKPlugin_Hypothesis_i::SetDocument(HEXABLOCK_ORB::Document_ptr doc) {
+  Document_impl* docServant = ::DownCast<Document_impl*>(doc);
+  if ( docServant ) {
+    HEXA_NS::Document* d = docServant->GetImpl();
+    ASSERT(myBaseImpl);
+    this->GetImpl()->SetDocument(d);
+  }
+}
+
+//================================================================================
+/*!
+ * To define the hight dimension to generated: 3 = hexas, 2 = quads, 1 = segments, 0 = nodes
+ */
+//================================================================================
+
+CORBA::Long HEXABLOCKPlugin_Hypothesis_i::GetDimension() {
+  ASSERT(myBaseImpl);
+  return this->GetImpl()->GetDimension();
+}
+
+void HEXABLOCKPlugin_Hypothesis_i::SetDimension(CORBA::Long dim) {
+  ASSERT(myBaseImpl);
+  this->GetImpl()->SetDimension(dim);
+}
diff --git a/src/HEXABLOCKPlugin/HEXABLOCKPlugin_Hypothesis_i.hxx b/src/HEXABLOCKPlugin/HEXABLOCKPlugin_Hypothesis_i.hxx
new file mode 100755 (executable)
index 0000000..4a0add0
--- /dev/null
@@ -0,0 +1,76 @@
+// Copyright (C) 2009-2012  CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+//  HEXABLOCKPlugin : C++ implementation
+// File      : HEXABLOCKPlugin_Hypothesis_i.hxx
+// Date      : 2010/11/08
+// Project   : SALOME
+//
+#ifndef _HEXABLOCKPlugin_Hypothesis_i_HXX_
+#define _HEXABLOCKPlugin_Hypothesis_i_HXX_
+
+#include "HEXABLOCKPlugin_Defs.hxx"
+
+#include <SALOMEconfig.h>
+#include CORBA_SERVER_HEADER(HEXABLOCKPlugin_Algorithm)
+#include CORBA_CLIENT_HEADER(Document)
+
+#include "SMESH_Hypothesis_i.hxx"
+#include "HEXABLOCKPlugin_Hypothesis.hxx"
+
+class SMESH_Gen;
+
+// HEXABLOCKPlugin parameters hypothesis
+
+class HEXABLOCKPLUGIN_EXPORT HEXABLOCKPlugin_Hypothesis_i:
+  public virtual POA_HEXABLOCKPlugin::HEXABLOCKPlugin_Hypothesis,
+  public virtual SMESH_Hypothesis_i
+{
+ public:
+  // Constructor
+  HEXABLOCKPlugin_Hypothesis_i (PortableServer::POA_ptr thePOA,
+                            int                     theStudyId,
+                            ::SMESH_Gen*            theGenImpl);
+  // Destructor
+  virtual ~HEXABLOCKPlugin_Hypothesis_i();
+
+    /*!
+     * Define the document to be meshed, mandatory
+     */
+    HEXABLOCK_ORB::Document_ptr GetDocument();
+    void SetDocument(HEXABLOCK_ORB::Document_ptr doc);
+
+    /*!
+     * To define the hight dimension to generated: 3 = hexas, 2 = quads, 1 = segments, 0 = nodes
+     */
+    CORBA::Long GetDimension();
+    void SetDimension(CORBA::Long dim);
+
+    // Get implementation
+    ::HEXABLOCKPlugin_Hypothesis* GetImpl();
+  
+    // Verify whether hypothesis supports given entity type 
+    CORBA::Boolean IsDimSupported( SMESH::Dimension type );
+
+ private:
+    PortableServer::POA_var _poa;// POA reference
+
+};
+
+#endif
diff --git a/src/HEXABLOCKPlugin/HEXABLOCKPlugin_i.cxx b/src/HEXABLOCKPlugin/HEXABLOCKPlugin_i.cxx
new file mode 100755 (executable)
index 0000000..01c0968
--- /dev/null
@@ -0,0 +1,76 @@
+// Copyright (C) 2009-2012  CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+//  SMESH HEXABLOCKPlugin : implementaion of SMESH idl descriptions
+//  File   : HEXABLOCKPlugin.cxx
+//  Author : Lioka RAZAFINDRAZAKA (CEA)
+//  Module : SMESH
+//  $Header$
+//
+#include "SMESH_Hypothesis_i.hxx"
+
+#include "utilities.h"
+
+#include "HEXABLOCKPlugin_HEXABLOCK_i.hxx"
+#include "HEXABLOCKPlugin_Hypothesis_i.hxx"
+
+
+#ifdef _DEBUG_
+static int MYDEBUG = 1;
+#else
+static int MYDEBUG = 0;
+#endif
+
+
+using namespace std;
+
+template <class T> class HEXABLOCKPlugin_Creator_i:public HypothesisCreator_i<T>
+{
+  // as we have 'module HEXABLOCKPlugin' in HEXABLOCKPlugin_Algorithm.idl
+  virtual std::string GetModuleName() { return "HEXABLOCKPlugin"; }
+};
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+extern "C"
+{
+  HEXABLOCKPLUGIN_EXPORT
+  GenericHypothesisCreator_i* GetHypothesisCreator (const char* aHypName)
+  {
+    if(MYDEBUG) MESSAGE("GetHypothesisCreator " << aHypName);
+
+    GenericHypothesisCreator_i* aCreator = 0;
+
+    // Hypotheses
+
+    // Algorithm
+    if (strcmp(aHypName, "HEXABLOCK_3D") == 0)
+      aCreator = new HEXABLOCKPlugin_Creator_i<HEXABLOCKPlugin_HEXABLOCK_i>;
+    // Hypothesis
+    else if (strcmp(aHypName, "HEXABLOCK_Parameters") == 0)
+      aCreator = new HEXABLOCKPlugin_Creator_i<HEXABLOCKPlugin_Hypothesis_i>;
+    else ;
+
+    return aCreator;
+  }
+}
diff --git a/src/HEXABLOCKPlugin/HEXABLOCKPlugin_mesh.cxx b/src/HEXABLOCKPlugin/HEXABLOCKPlugin_mesh.cxx
new file mode 100755 (executable)
index 0000000..b0a2c6a
--- /dev/null
@@ -0,0 +1,1947 @@
+// Copyright (C) 2009-2012  CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+//  File   : SMESH_HexaBlocks.cxx
+//  Author : 
+//  Module : SMESH
+//
+
+#include <sstream>
+#include <algorithm>
+
+// CasCade includes
+#include <AIS_Shape.hxx>
+
+#include <Precision.hxx>
+#include <BRep_Tool.hxx>
+#include <BRepTools.hxx>
+#include <BRep_Builder.hxx>
+#include <BRepAdaptor_Curve.hxx>
+#include <BRepBuilderAPI_MakeFace.hxx>
+
+#include <GeomConvert_CompCurveToBSplineCurve.hxx>
+#include <GCPnts_AbscissaPoint.hxx>
+#include <TopoDS_Wire.hxx>
+
+#include <TopoDS.hxx>
+#include <TopoDS_Shape.hxx>
+#include <TopoDS_Compound.hxx>
+#include <gp_Pln.hxx>
+#include <gp_Pnt.hxx>
+#include <gp_Dir.hxx>
+#include <gp_Lin.hxx>
+#include <IntCurvesFace_ShapeIntersector.hxx>
+
+// SMESH includes
+#include "SMDS_MeshNode.hxx"
+#include "SMDS_MeshVolume.hxx"
+#include "SMESH_Gen.hxx"
+#include "SMESH_MesherHelper.hxx"
+#include "SMESHDS_Group.hxx"
+
+// HEXABLOCK includes
+#include "HexDocument.hxx"
+#include "HexVertex.hxx"
+#include "HexEdge.hxx"
+#include "HexQuad.hxx"
+#include "HexHexa.hxx"
+#include "HexPropagation.hxx"
+#include "HexShape.hxx"
+#include "HexGroup.hxx"
+
+// HEXABLOCKPLUGIN includes
+#include "HEXABLOCKPlugin_mesh.hxx"
+#include "HEXABLOCKPlugin_FromSkin_3D.hxx"
+
+// other includes
+#include "Basics_Utils.hxx"
+#include "utilities.h"
+
+#ifdef WNT
+#include <process.h>
+#else
+#include <unistd.h>
+#endif
+
+#include <stdexcept>
+
+#ifndef EXCEPTION
+#define EXCEPTION(TYPE, MSG) {\
+  std::ostringstream aStream;\
+  aStream<<__FILE__<<"["<<__LINE__<<"]::"<<MSG;\
+  throw TYPE(aStream.str());\
+}
+#endif
+
+#ifdef _DEBUG_
+static int MYDEBUG = 1;
+#else
+static int MYDEBUG = 0;
+#endif
+
+
+static double HEXA_EPSILON = 1E-3; //1E-3; 
+static double HEXA_QUAD_WAY = PI/4.; //3.*PI/8.;
+// static double HEXA_QUAD_WAY2 = 499999999.*PI/1000000000.;
+
+
+TopoDS_Shape string2shape( const string& brep )
+{
+  TopoDS_Shape shape;
+  istringstream streamBrep(brep);
+  BRep_Builder aBuilder;
+  BRepTools::Read(shape, streamBrep, aBuilder);
+  return shape;
+}
+
+
+bool shape2coord(const TopoDS_Shape& aShape, double& x, double& y, double& z)
+{
+   if ( aShape.ShapeType() == TopAbs_VERTEX ){
+      TopoDS_Vertex aPoint;
+       aPoint = TopoDS::Vertex( aShape );
+       gp_Pnt aPnt = BRep_Tool::Pnt( aPoint );
+       x = aPnt.X();
+       y = aPnt.Y();
+       z = aPnt.Z();
+       return(1);
+   } else {
+       return(0);
+   };
+}
+
+
+
+// SMESH_HexaBlocks::SMESH_HexaBlocks( SMESH_Mesh* theMesh ):
+SMESH_HexaBlocks::SMESH_HexaBlocks(SMESH_Mesh& theMesh):
+  _total(0),
+  _found(0),
+  _notFound(0),
+  _computeVertexOK(false),
+  _computeEdgeOK(false),
+  _computeQuadOK(false),
+  _theMesh(&theMesh),  //groups creation
+  _theMeshDS(theMesh.GetMeshDS()) //meshing
+{
+}
+
+
+SMESH_HexaBlocks::~SMESH_HexaBlocks()
+{
+}
+
+
+// --------------------------------------------------------------
+//                      PUBLIC METHODS
+// --------------------------------------------------------------
+
+// --------------------------------------------------------------
+//                     Vertex computing
+// --------------------------------------------------------------
+bool SMESH_HexaBlocks::computeVertex(HEXA_NS::Vertex& vx)
+{
+  bool ok = false;
+  ok = computeVertexByAssoc( vx );
+  if ( ok == false ){
+    ok = computeVertexByModel( vx );
+  }
+  if (ok == true){
+    _computeVertexOK = true;
+  }
+  return ok;
+}
+
+
+bool SMESH_HexaBlocks::computeVertexByAssoc(HEXA_NS::Vertex& vx)
+{
+  if(MYDEBUG) MESSAGE("computeVertexByAssoc() : : begin   <<<<<<");
+  bool ok = true;
+
+  SMDS_MeshNode* newNode = NULL; // new node on mesh
+  double x, y, z; //new node coordinates
+
+  HEXA_NS::Shape* assoc = vx.getAssociation();
+  if ( assoc == NULL ){
+    if (MYDEBUG){
+      MESSAGE("computeVertexByAssoc() : ASSOC not found " << vx.getName ());
+      // vx.printName();
+    }
+    return false;
+  }
+
+  string strBrep = assoc->getBrep();
+  TopoDS_Shape shape = string2shape( strBrep );
+  ok = shape2coord( shape, x, y, z );
+//   ASSERT(ok);
+  if (!ok) throw (SALOME_Exception(LOCALIZED("vertex association : shape2coord() error ")));
+  newNode = _theMeshDS->AddNode(x, y, z);
+  if  (_node.count(&vx) >= 1  and MYDEBUG) MESSAGE("_node : ALREADY");
+  _node[&vx] = newNode;//needed in computeEdge()
+  _vertex[newNode] = &vx;
+
+  if (MYDEBUG){
+    MESSAGE("computeVertexByAssoc() : ASSOC found " << vx.getName());
+    /// vx.printName();
+    MESSAGE("( "<< x <<","<< y <<","<< z <<" )");
+  }
+
+  if(MYDEBUG) MESSAGE("computeVertexByAssoc() : end  >>>>>>>>");
+  return ok;
+}
+
+bool SMESH_HexaBlocks::computeVertexByModel(HEXA_NS::Vertex& vx)
+{
+  if(MYDEBUG) MESSAGE("computeVertexByModel() : : begin   <<<<<<");
+  bool ok = true;
+
+  SMDS_MeshNode* newNode = NULL; // new node on mesh
+  double x, y, z; //new node coordinates
+
+//   vx.printName();
+//   std::cout << std::endl;
+  x = vx.getX();
+  y = vx.getY();
+  z = vx.getZ();
+
+  newNode = _theMeshDS->AddNode(x, y, z);
+
+  if  (_node.count(&vx) >= 1 and MYDEBUG) MESSAGE("_node : ALREADY");
+  _node[&vx] = newNode;//needed in computeEdge()
+  _vertex[newNode] = &vx;
+  if (MYDEBUG){
+    MESSAGE("computeVertexByModel() :" << vx.getName());
+    /// vx.printName();
+    MESSAGE("( "<< x <<","<< y <<","<< z <<" )");
+  }
+
+  if(MYDEBUG) MESSAGE("computeVertexByModel() : end  >>>>>>>>");
+  return ok;
+}
+
+// --------------------------------------------------------------
+//                      Edge computing
+// --------------------------------------------------------------
+bool SMESH_HexaBlocks::computeEdge(HEXA_NS::Edge& edge, HEXA_NS::Law& law)
+{
+  bool ok = false;
+
+  ok = computeEdgeByAssoc( edge, law);
+  if ( ok == false ){
+    ok = computeEdgeByShortestWire( edge, law);
+  }
+  if ( ok == false ){
+    ok = computeEdgeByPlanWire( edge, law);
+  }
+  if ( ok == false ){
+    ok = computeEdgeByIsoWire( edge, law);
+  }
+  if ( ok == false ){
+    ok = computeEdgeBySegment( edge, law);
+  }
+  if (ok == true){
+    _computeEdgeOK = true;
+  }
+  return ok;
+}
+
+
+
+bool SMESH_HexaBlocks::computeEdgeByAssoc( HEXA_NS::Edge& edge, HEXA_NS::Law& law )
+{
+  if(MYDEBUG) MESSAGE("computeEdgeByAssoc(edgeID = "<<edge.getId()<<"): begin   <<<<<<");
+  ASSERT( _computeVertexOK );
+  bool ok = true;
+
+  const std::vector <HEXA_NS::Shape*> associations = edge.getAssociations();
+  if ( associations.size() == 0 ){
+    return false;
+  }
+  //vertex from edge
+  HEXA_NS::Vertex* vx0 = NULL;
+  HEXA_NS::Vertex* vx1 = NULL;
+
+  // way of discretization
+  if (edge.getWay() == true){
+    vx0 = edge.getVertex(0);
+    vx1 = edge.getVertex(1);
+  } else {
+    vx0 = edge.getVertex(1);
+    vx1 = edge.getVertex(0);
+  }
+  // nodes on mesh
+  SMDS_MeshNode* FIRST_NODE = _node[vx0];
+  SMDS_MeshNode* LAST_NODE  = _node[vx1];
+
+
+  // A) Build myCurve
+  std::list< BRepAdaptor_Curve* >        myCurve;
+  double                                 myCurve_length;
+  std::map< BRepAdaptor_Curve*, double>  myCurve_lengths;
+  std::map< BRepAdaptor_Curve*, bool>    myCurve_ways;
+  std::map< BRepAdaptor_Curve*, double>  myCurve_starts;
+  gp_Pnt                                 myCurve_start( FIRST_NODE->X(), FIRST_NODE->Y(), FIRST_NODE->Z() );
+  gp_Pnt                                 myCurve_end( LAST_NODE->X(), LAST_NODE->Y(), LAST_NODE->Z() );
+
+
+  _buildMyCurve(
+      associations,
+      myCurve_start,
+      myCurve_end,
+      myCurve,
+      myCurve_length,
+      myCurve_lengths,
+      myCurve_ways,
+      myCurve_starts,
+      edge
+  );
+
+
+  // B) Build nodes and edges on mesh from myCurve
+  SMDS_MeshNode* node_a  = NULL;
+  SMDS_MeshNode* node_b  = NULL;
+  SMDS_MeshEdge* edge_ab = NULL;
+  SMESHNodes     nodesOnEdge;
+  SMESHEdges     edgesOnEdge; //backup for group creation
+//   Xx             nodesXxOnEdge;
+
+  node_a = FIRST_NODE;
+  nodesOnEdge.push_back(FIRST_NODE);
+//   nodesXxOnEdge.push_back(0.);
+  // _nodeXx[FIRST_NODE] = 0.;
+
+  gp_Pnt ptOnMyCurve;
+  double u, myCurve_u;
+  double myCurve_start_u = 0.;
+  int nbNodes = law.getNodes(); //law of discretization
+  if (MYDEBUG) MESSAGE("nbNodes -> "<<nbNodes);
+  for (int i = 0; i < nbNodes; ++i){
+      u = _Xx(i, law, nbNodes); //u between [0,1]
+      myCurve_u = u*myCurve_length;
+      if (MYDEBUG) {
+        MESSAGE("u -> "<<u);
+        MESSAGE("myCurve_u  -> "<<myCurve_u);
+        MESSAGE("myCurve_length -> "<<myCurve_length);
+      }
+      ptOnMyCurve = _getPtOnMyCurve( myCurve_u,
+                                     myCurve_ways,
+                                     myCurve_lengths,
+                                     myCurve_starts,
+                                     myCurve,
+                                     myCurve_start_u
+                                     );
+
+      node_b = _theMeshDS->AddNode( ptOnMyCurve.X(), ptOnMyCurve.Y(), ptOnMyCurve.Z() );
+      edge_ab     = _theMeshDS->AddEdge( node_a, node_b );
+      nodesOnEdge.push_back( node_b );
+      edgesOnEdge.push_back( edge_ab );
+//       nodesXxOnEdge.push_back( u );
+      if  (_nodeXx.count(node_b) >= 1 ) ASSERT(false);
+      _nodeXx[node_b] = u;
+      node_a = node_b;
+  }
+  edge_ab      = _theMeshDS->AddEdge( node_a, LAST_NODE );
+  nodesOnEdge.push_back( LAST_NODE );
+  edgesOnEdge.push_back( edge_ab );
+//   nodesXxOnEdge.push_back( 1. );
+  // _nodeXx[LAST_NODE] = 1.;
+  _nodesOnEdge[&edge] = nodesOnEdge;
+  _edgesOnEdge[&edge] = edgesOnEdge;
+
+
+
+//   _edgeXx[&edge]      = nodesXxOnEdge;
+
+  if(MYDEBUG) MESSAGE("computeEdgeByAssoc() : end  >>>>>>>>");
+  return ok;
+}
+
+
+
+
+bool SMESH_HexaBlocks::computeEdgeByShortestWire( HEXA_NS::Edge& edge, HEXA_NS::Law& law)
+{
+  if(MYDEBUG) MESSAGE("computeEdgeByShortestWire() not implemented");
+  return false;
+}
+
+bool SMESH_HexaBlocks::computeEdgeByPlanWire( HEXA_NS::Edge& edge, HEXA_NS::Law& law)
+{
+  if(MYDEBUG) MESSAGE("computeEdgeByPlanWire() not implemented");
+  return false;
+}
+
+bool SMESH_HexaBlocks::computeEdgeByIsoWire( HEXA_NS::Edge& edge, HEXA_NS::Law& law)
+{
+  if(MYDEBUG) MESSAGE("computeEdgeByIsoWire() not implemented");
+  return false;
+}
+
+
+bool SMESH_HexaBlocks::computeEdgeBySegment(HEXA_NS::Edge& edge, HEXA_NS::Law& law)
+{
+  if(MYDEBUG) MESSAGE("computeEdgeBySegment() : : begin   <<<<<<");
+  ASSERT( _computeVertexOK );
+  bool ok = true;
+
+  //vertex from edge
+  HEXA_NS::Vertex* vx0 = NULL;
+  HEXA_NS::Vertex* vx1 = NULL;
+
+  // way of discretization
+  if (edge.getWay() == true){
+    vx0 = edge.getVertex(0);
+    vx1 = edge.getVertex(1);
+  } else {
+    vx0 = edge.getVertex(1);
+    vx1 = edge.getVertex(0);
+  }
+
+  // nodes on mesh
+  SMDS_MeshNode* FIRST_NODE = _node[vx0];
+  SMDS_MeshNode* LAST_NODE  = _node[vx1];
+  SMDS_MeshNode* node_a = NULL; //new node (to be added)
+  SMDS_MeshNode* node_b = NULL; //new node (to be added)
+
+  // node and edge creation
+  SMESHNodes nodesOnEdge;
+  SMESHEdges edgesOnEdge;
+
+  double u; //
+  double newNodeX, newNodeY, newNodeZ;
+  SMDS_MeshEdge* newEdge = NULL;
+
+  node_a = FIRST_NODE;
+  nodesOnEdge.push_back(FIRST_NODE);
+
+  //law of discretization
+  int nbNodes = law.getNodes();
+  if (MYDEBUG) MESSAGE("nbNodes -> "<<nbNodes);
+  for (int i = 0; i < nbNodes; ++i){
+    u = _Xx(i, law, nbNodes);
+    newNodeX = FIRST_NODE->X() + u * ( LAST_NODE->X() - FIRST_NODE->X() );
+    newNodeY = FIRST_NODE->Y() + u * ( LAST_NODE->Y() - FIRST_NODE->Y() );
+    newNodeZ = FIRST_NODE->Z() + u * ( LAST_NODE->Z() - FIRST_NODE->Z() );
+    node_b = _theMeshDS->AddNode(newNodeX, newNodeY, newNodeZ);
+    newEdge = _theMeshDS->AddEdge(node_a, node_b);
+    edgesOnEdge.push_back(newEdge);
+    nodesOnEdge.push_back(node_b);
+    if  (_nodeXx.count(node_b) >= 1 ) ASSERT(false);
+    _nodeXx[ node_b ] = u;
+    if(MYDEBUG) MESSAGE("_nodeXx <-"<<u);
+    node_a = node_b;
+  }
+  newEdge = _theMeshDS->AddEdge(node_a, LAST_NODE);
+  nodesOnEdge.push_back(LAST_NODE);
+  edgesOnEdge.push_back(newEdge);
+
+  _nodesOnEdge[&edge] = nodesOnEdge;
+  _edgesOnEdge[&edge] = edgesOnEdge;
+
+  if(MYDEBUG) MESSAGE("computeEdgeBySegment() : end  >>>>>>>>");
+  return ok;
+}
+
+
+// --------------------------------------------------------------
+//                        Quad computing
+// --------------------------------------------------------------
+std::map<HEXA_NS::Quad*, bool>  SMESH_HexaBlocks::computeQuadWays( HEXA_NS::Document* doc )
+{
+  std::map<HEXA_NS::Quad*, bool>  quadWays;
+  std::map<HEXA_NS::Edge*, std::pair<HEXA_NS::Vertex*, HEXA_NS::Vertex*> > edgeWays;
+  std::list<HEXA_NS::Quad*>       skinQuad;
+  std::list<HEXA_NS::Quad*>       workingQuad;
+  HEXA_NS::Quad* first_q = NULL;
+  HEXA_NS::Quad* q = NULL;
+  HEXA_NS::Edge* e = NULL;
+  HEXA_NS::Vertex *e_0, *e_1 = NULL;
+
+  // FIRST STEP: eliminate free quad + internal quad
+  int nTotalQuad = doc->countUsedQuad();
+  for (int i=0; i < nTotalQuad; ++i ){
+    q = doc->getUsedQuad(i);
+    switch ( q->getNbrParents() ){ // parent == hexaedron
+      case 0: case 2: quadWays[q] = true; break;
+      case 1: skinQuad.push_back(q); break;
+      default: if ( q->getNbrParents() > 2 ) ASSERT(false);
+    }
+  }
+
+  // SECOND STEP: setting edges ways 
+  while ( skinQuad.size()>0 ){
+    if(MYDEBUG) MESSAGE("SEARCHING INITIAL QUAD ..." );
+    for ( std::list<HEXA_NS::Quad*>::iterator it = skinQuad.begin(); it != skinQuad.end(); it++ ){
+        _searchInitialQuadWay( *it, e_0, e_1 );
+        if ( e_0 != NULL and e_1 != NULL ){
+          q = first_q = *it;
+          break;
+        }
+    }
+    if ( e_0 == NULL and e_1 == NULL ) ASSERT(false);// should never happened, 
+    if(MYDEBUG) MESSAGE("INITIAL QUAD FOUND!" );
+    for ( int j=0 ; j < 4 ; ++j ){
+      e = q->getEdge(j);
+      if  ( (e_0 == e->getVertex(0)) and (e_1 == e->getVertex(1)) or 
+            (e_0 == e->getVertex(1)) and (e_1 == e->getVertex(0)) ){
+        break;
+      }
+    }
+    if(MYDEBUG) MESSAGE("INITIAL EDGE WAY FOUND!" );
+
+    edgeWays[e] = std::make_pair( e_0, e_1 );
+    workingQuad.push_back(q);
+
+    while ( workingQuad.size() > 0 ){
+        if(MYDEBUG) MESSAGE("COMPUTE QUAD WAY ... ID ="<< q->getId());
+        HEXA_NS::Vertex *lastVertex=NULL, *firstVertex = NULL;
+        int i = 0;
+        std::map<HEXA_NS::Edge*, std::pair<HEXA_NS::Vertex*, HEXA_NS::Vertex*> > localEdgeWays;
+        while ( localEdgeWays.size() != 4 ){
+            HEXA_NS::Edge* e = q->getEdge(i%4);
+            if ( lastVertex == NULL ){
+                if ( edgeWays.count(e) == 1 ){
+                  if ( q == first_q ){
+                    localEdgeWays[e] = std::make_pair( edgeWays[e].first, edgeWays[e].second );
+                  } else {
+                    localEdgeWays[e] = std::make_pair( edgeWays[e].second, edgeWays[e].first); 
+                  }
+                  firstVertex = localEdgeWays[e].first;
+                  lastVertex  = localEdgeWays[e].second;
+                }
+            } else {
+              HEXA_NS::Vertex* e_0 = e->getVertex(0);
+              HEXA_NS::Vertex* e_1 = e->getVertex(1);
+  
+              if ( lastVertex == e_0 ){
+                firstVertex = e_0; lastVertex = e_1;
+              } else if ( lastVertex == e_1 ){
+                firstVertex = e_1; lastVertex = e_0;
+              } else if ( firstVertex == e_0 ) {
+                firstVertex = e_1; lastVertex = e_0;
+              } else if ( firstVertex == e_1 ) {
+                firstVertex = e_0; lastVertex = e_1;
+              } else {
+                ASSERT(false);
+              }
+              localEdgeWays[e] = std::make_pair( firstVertex, lastVertex );
+              if ( edgeWays.count(e) == 0 ){ // keep current value if present otherwise add it
+                edgeWays[e] = localEdgeWays[e];
+              }
+            }
+            ++i;
+        }
+  
+  
+        //add new working quad
+        for ( int i=0 ; i < 4; ++i ){
+            HEXA_NS::Quad* next_q = NULL;
+            HEXA_NS::Edge* e = q->getEdge(i);
+            for ( int j=0 ; j < e->getNbrParents(); ++j ){
+                next_q = e->getParent(j);
+                if ( next_q == q ){
+                  next_q = NULL;
+                }
+                int fromSkin = std::count( skinQuad.begin(), skinQuad.end(), next_q );
+                if (fromSkin != 0){ 
+                  int fromWorkingQuad = std::count( workingQuad.begin(), workingQuad.end(), next_q );
+                    if ( fromWorkingQuad == 0 ){
+                        workingQuad.push_front( next_q );
+                    }
+                }
+            }
+        }
+  
+        // setting quad way
+        HEXA_NS::Edge* e0 = q->getEdge(0);
+        HEXA_NS::Vertex* e0_0 = e0->getVertex(0);
+  
+        if (  e0_0 == localEdgeWays[ e0 ].first ){
+            quadWays[q] = true;
+        } else if ( e0_0 == localEdgeWays[ e0 ].second ){
+            quadWays[q] = false;
+        } else {
+          ASSERT(false);
+        }
+        workingQuad.remove( q );
+        skinQuad.remove( q );
+        q = workingQuad.back();
+    }
+  }
+
+  return quadWays;
+}
+
+
+
+
+
+// std::map<HEXA_NS::Quad*, bool>  SMESH_HexaBlocks::computeQuadWays( HEXA_NS::Document& doc, std::map<HEXA_NS::Quad*, bool>  initQuads )
+// {
+//   std::map<HEXA_NS::Quad*, bool>  quadWays;
+// //   std::map<HEXA_NS::Edge*, bool>  edgeWays;
+// //   std::map<HEXA_NS::Edge*, std::pair<HEXA_NS::Vertex*, HEXA_NS::Vertex*> > edgeWays;
+//   std::map<HEXA_NS::Quad*, std::pair<HEXA_NS::Vertex*, HEXA_NS::Vertex*> > workingQuads;
+// 
+//   std::list<HEXA_NS::Quad*>       skinQuad;
+//   std::list<HEXA_NS::Quad*>       notSkinQuad;
+// //   std::list<HEXA_NS::Quad*>       workingQuad;
+//   HEXA_NS::Quad* first_q = NULL;
+//   HEXA_NS::Quad* q = NULL;
+//   HEXA_NS::Edge* e = NULL;
+//   HEXA_NS::Vertex *e_0, *e_1 = NULL;
+// 
+//   // FIRST STEP: eliminate free quad + internal quad
+//   int nTotalQuad = doc.countQuad();
+//   for (int i=0; i < nTotalQuad; ++i ){
+//     q = doc.getQuad(i);
+//     switch ( q->getNbrParents() ){ // parent == hexaedron
+//       case 0: case 2: quadWays[q] = true; break;
+// //       case 0: case 2: notSkinQuad.push_back(q); break; //CS_TEST
+//       case 1: skinQuad.push_back(q); break;
+//       default: if ( q->getNbrParents() > 2 ) ASSERT(false);
+//     }
+//   }
+// 
+// 
+//   // SECOND STEP
+//   q = first_q = skinQuad.front();
+//   e = q->getUsedEdge(0);
+//   e_0 = e->getVertex(0);
+//   e_1 = e->getVertex(1);
+// 
+//   workingQuads[q] = std::make_pair( e_0, e_1 );
+// 
+//   while ( workingQuads.size() > 0 ){
+//       MESSAGE("CURRENT QUAD ------>"<< q->getId());
+//       HEXA_NS::Vertex *lastVertex=NULL, *firstVertex = NULL;
+//       int i = 0;
+// 
+//       std::map<HEXA_NS::Edge*, std::pair<HEXA_NS::Vertex*, HEXA_NS::Vertex*> > localEdgeWays;
+//       while ( localEdgeWays.size() != 4 ){
+//           HEXA_NS::Edge* e = q->getUsedEdge(i%4);
+//           if ( lastVertex == NULL ){
+//               HEXA_NS::Vertex* e_0 = e->getVertex(0);
+//               HEXA_NS::Vertex* e_1 = e->getVertex(1);
+// 
+//               if ( (workingQuads[q].first == e_0 and workingQuads[q].second == e_1) 
+//                     or (workingQuads[q].first == e_1 and workingQuads[q].second == e_0) ){
+//                 if ( q == first_q ){
+//                   localEdgeWays[e] = std::make_pair( workingQuads[q].first, workingQuads[q].second );
+//                   MESSAGE("FIRST QUAD ");
+//                 } else {
+//                   localEdgeWays[e] = std::make_pair( workingQuads[q].second, workingQuads[q].first);
+//                   MESSAGE("NOT FIRST QUAD ");
+//                 }
+//                 firstVertex = localEdgeWays[e].first;
+//                 lastVertex  = localEdgeWays[e].second;
+//               }
+//           } else {
+//             HEXA_NS::Vertex* e_0 = e->getVertex(0);
+//             HEXA_NS::Vertex* e_1 = e->getVertex(1);
+//             if ( lastVertex == e_0 ){
+//               localEdgeWays[e] = std::make_pair( e_0, e_1 );
+//               firstVertex = e_0;
+//               lastVertex = e_1;
+//             } else if ( lastVertex == e_1 ){
+//               localEdgeWays[e] = std::make_pair( e_1, e_0 );
+//               firstVertex = e_1;
+//               lastVertex = e_0;
+//             } else if ( firstVertex == e_0 ) {
+//               localEdgeWays[e] = std::make_pair( e_1, e_0 );
+//               firstVertex = e_1;
+//               lastVertex = e_0;
+//             } else if ( firstVertex == e_1 ) {
+//               localEdgeWays[e] = std::make_pair( e_0, e_1 );
+//               firstVertex = e_0;
+//               lastVertex = e_1;
+//             } else {
+//               ASSERT(false);
+//             }
+//           }
+//           ++i;
+//       }
+// 
+// 
+//       //add new working quad
+//       for ( int i=0 ; i < 4; ++i ){
+//           HEXA_NS::Quad* next_q = NULL;
+//           HEXA_NS::Edge* e = q->getUsedEdge(i);
+//           MESSAGE("NB PARENTS ="<< e->getNbrParents() );
+//           for ( int j=0 ; j < e->getNbrParents(); ++j ){
+//               next_q = e->getParent(j);
+//               if ( next_q == q ){
+//                 next_q = NULL;
+//               }
+//               int fromSkin = std::count( skinQuad.begin(), skinQuad.end(), next_q );
+//               if (fromSkin != 0){ 
+// //                 int fromWorkingQuad = std::count( workingQuads.begin(), workingQuads.end(), next_q );
+//                 int fromWorkingQuad = workingQuads.count( next_q );
+// //             MESSAGE("CHECK QUAD:"<< newWorkingQuad->getId()); 
+//                   if ( fromWorkingQuad == 0 ){
+// //                       workingQuads.push_front( next_q );
+//                       workingQuads[ next_q ] = localEdgeWays[e];
+// //                   MESSAGE("EDGE :"<<e->getId()<<"ADD QUAD :"<< newWorkingQuad->getId()); 
+//                   }
+//               }
+//           }
+//       }
+// 
+//       //setting quad way
+//       HEXA_NS::Edge* e0 = q->getUsedEdge(0);
+//       HEXA_NS::Vertex* e0_0 = e0->getVertex(0);
+// 
+//       if (  e0_0 == localEdgeWays[ e0 ].first ){
+//           quadWays[q] = true;
+//       } else if ( e0_0 == localEdgeWays[ e0 ].second ){
+//           quadWays[q] = false;
+//       } else {
+//         ASSERT(false);
+//       }
+//       MESSAGE("quadWays ID ="<< q->getId() << ", WAY = " << quadWays[q] );
+// 
+// //       workingQuad.remove( q );
+//       workingQuads.erase( q );
+//       skinQuad.remove( q );
+//       *workingQuads.begin();
+//       q = (*workingQuads.begin()).first;
+//   }
+//   return quadWays;
+// }
+
+
+bool SMESH_HexaBlocks::computeQuad( HEXA_NS::Quad& quad, bool way )
+{
+  bool ok = false;
+
+  ok = computeQuadByAssoc(quad, way);
+  if ( ok == false ){
+    ok = computeQuadByFindingGeom(quad, way);
+  }
+  if ( ok == false ){
+    ok = computeQuadByLinearApproximation(quad, way);
+  }
+  if (ok == true){
+    _computeQuadOK = true;
+  }
+  return ok;
+}
+
+
+bool SMESH_HexaBlocks::computeQuadByAssoc( HEXA_NS::Quad& quad, bool way  )
+{
+//   int id = quad.getId();
+//   if ( id != 11 )  return false; //7
+  if (MYDEBUG){
+    MESSAGE("computeQuadByLinearApproximation() : : begin   <<<<<<");
+    MESSAGE("quadID = "<<quad.getId());
+  }
+  ASSERT( _computeEdgeOK );
+  bool ok = true;
+
+  ArrayOfSMESHNodes nodesOnQuad; // nodes in this quad ( to be added on the mesh )
+  SMESHFaces      facesOnQuad;
+  SMDS_MeshFace*  newFace = NULL;
+  std::vector<double> xx, yy;
+
+  // Elements for quad computation
+  SMDS_MeshNode *S1, *S2, *S4, *S3;
+
+//   bool initOk = _computeQuadInit( quad, eh, eb, eg, ed, S1, S2, S3, S4 );
+  bool initOk = _computeQuadInit( quad, nodesOnQuad, xx, yy );
+  if ( initOk == false ){
+    return false;
+  }
+
+  const std::vector <HEXA_NS::Shape*>  shapes = quad.getAssociations();
+  if ( shapes.size() == 0 ){
+    if(MYDEBUG) MESSAGE("computeQuadByAssoc() : end  >>>>>>>>");
+    return false;
+  }  
+  TopoDS_Shape shapeOrCompound = _getShapeOrCompound( shapes );
+//   bool quadWay = _computeQuadWay( quad, S1, S2, S3, S4, &shapeOrCompound );
+//   bool quadWay = _computeQuadWay( quad );
+
+
+  std::map<SMDS_MeshNode*, gp_Pnt> interpolatedPoints;
+  int iSize = nodesOnQuad.size();
+  int jSize = nodesOnQuad[0].size();
+
+  S1 = nodesOnQuad[0][0];
+//   S2 = nodesOnQuad[bNodes.size()-1][0];
+  S2 = nodesOnQuad[iSize-1][0];
+  S4 = nodesOnQuad[0][jSize-1];
+  S3 = nodesOnQuad[iSize-1][jSize-1];
+
+
+  for (int j = 1; j < jSize; ++j){
+    for (int i = 1; i < iSize; ++i){
+        SMDS_MeshNode* n1 = nodesOnQuad[i-1][j];
+        SMDS_MeshNode* n2 = nodesOnQuad[i-1][j-1];
+        SMDS_MeshNode* n3 = nodesOnQuad[i][j-1];
+        SMDS_MeshNode* n4 = nodesOnQuad[i][j];
+
+        if ( n4 == NULL ){
+            double newNodeX, newNodeY, newNodeZ;
+            SMDS_MeshNode* Ph = nodesOnQuad[i][jSize-1];   //dNodes[h_i];
+            SMDS_MeshNode* Pb = nodesOnQuad[i][0];   //bNodes[b_i];
+            SMDS_MeshNode* Pg = nodesOnQuad[0][j];   //gNodes[g_j];
+            SMDS_MeshNode* Pd = nodesOnQuad[iSize-1][j];  //dNodes[d_j];
+            double u = xx[i];
+            double v = yy[j];
+
+            _nodeInterpolationUV(u, v, Pg, Pd, Ph, Pb, S1, S2, S3, S4, newNodeX, newNodeY, newNodeZ);
+              gp_Pnt newPt = gp_Pnt( newNodeX, newNodeY, newNodeZ );//interpolated point 
+              gp_Pnt pt1;
+              gp_Pnt pt3;
+              if ( interpolatedPoints.count(n1) > 0 ){
+                      pt1 = interpolatedPoints[n1];
+              } else {
+                      pt1 = gp_Pnt( n1->X(), n1->Y(), n1->Z() );
+              }
+              if ( interpolatedPoints.count(n3) > 0 ){
+                      pt3 = interpolatedPoints[n3];
+              } else {
+                      pt3 = gp_Pnt( n3->X(), n3->Y(), n3->Z() );
+              }
+              gp_Vec vec1( newPt, pt1 );
+              gp_Vec vec2( newPt, pt3 );
+
+              gp_Pnt ptOnShape = _intersect(newPt, vec1, vec2, shapeOrCompound);
+              newNodeX = ptOnShape.X();
+              newNodeY = ptOnShape.Y();
+              newNodeZ = ptOnShape.Z();
+              n4 = _theMeshDS->AddNode( newNodeX, newNodeY, newNodeZ );
+              nodesOnQuad[i][j] = n4;
+              interpolatedPoints[ n4 ] = newPt;
+
+              if (MYDEBUG) {
+                  MESSAGE("u parameter is "<<u);
+                  MESSAGE("v parameter is "<<v);
+                  MESSAGE("point interpolated ("<<newPt.X()<<","<<newPt.Y()<<","<<newPt.Z()<<" )");
+                  MESSAGE("point on shape     ("<<newNodeX<<","<<newNodeY<<","<<newNodeZ<<" )");
+              }
+        }
+
+        if (MYDEBUG){
+          MESSAGE("n1 (" << n1->X() << "," << n1->Y() << "," << n1->Z() << ")");
+          MESSAGE("n2 (" << n2->X() << "," << n2->Y() << "," << n2->Z() << ")");
+          MESSAGE("n4 (" << n4->X() << "," << n4->Y() << "," << n4->Z() << ")");
+          MESSAGE("n3 (" << n3->X() << "," << n3->Y() << "," << n3->Z() << ")");
+        }
+
+        if ( way == true ){
+            if (MYDEBUG) MESSAGE("AddFace( n1, n2, n3, n4 )");
+            newFace = _theMeshDS->AddFace( n1, n2, n3, n4 );
+        } else {
+            if (MYDEBUG) MESSAGE("AddFace( n4, n3, n2, n1 )");
+            newFace = _theMeshDS->AddFace( n4, n3, n2, n1 );
+        }
+        facesOnQuad.push_back(newFace);
+      }
+  }
+  _quadNodes[ &quad ] = nodesOnQuad;
+  _facesOnQuad[&quad] = facesOnQuad;
+  
+  if(MYDEBUG) MESSAGE("computeQuadByLinearApproximation() : end  >>>>>>>>");
+  return ok;
+}
+
+
+bool SMESH_HexaBlocks::computeQuadByFindingGeom( HEXA_NS::Quad& quad, bool way )
+{
+  if(MYDEBUG) MESSAGE("computeQuadByFindingGeom() not implemented");
+  return false;
+}
+
+bool SMESH_HexaBlocks::_computeQuadInit(
+  HEXA_NS::Quad& quad,
+  ArrayOfSMESHNodes& nodesOnQuad,
+  std::vector<double>& xx, std::vector<double>& yy)
+{
+  if(MYDEBUG) MESSAGE("_computeQuadInit() : begin ---------------");
+  bool ok = true;
+
+  SMDS_MeshNode *S1, *S2, *S4, *S3;
+  HEXA_NS::Edge *eh, *eb, *eg, *ed;
+  HEXA_NS::Edge *e1, *e2, *e3, *e4;
+  HEXA_NS::Vertex *e1_0, *e1_1, *e2_0, *e2_1, *e3_0, *e3_1, *e4_0, *e4_1;
+
+  e1 = quad.getEdge(0);
+  e2 = quad.getEdge(1);
+  e3 = quad.getEdge(2);
+  e4 = quad.getEdge(3);
+
+  e1_0 = e1->getVertex(0); e1_1 = e1->getVertex(1);
+  e2_0 = e2->getVertex(0); e2_1 = e2->getVertex(1);
+  e3_0 = e3->getVertex(0); e3_1 = e3->getVertex(1);
+  e4_0 = e4->getVertex(0); e4_1 = e4->getVertex(1);
+
+  //S1, S2
+  S1 = _node[e1_0]; S2 = _node[e1_1];
+  eb = e1; eh = e3;
+  //S4
+  if ( e1_0 == e2_0 ){
+    S4 = _node[e2_1];
+    eg = e2; ed = e4;
+  } else if ( e1_0 == e2_1 ){
+    S4 = _node[e2_0];
+    eg = e2; ed = e4;
+  } else if ( e1_0 == e4_0 ){
+    S4 = _node[e4_1];
+    eg = e4; ed = e2;
+  } else if ( e1_0 == e4_1 ){
+    S4 = _node[e4_0];
+    eg = e4; ed = e2;
+  } else {
+    ASSERT(false);
+  }
+  //S3
+  if ( S4 == _node[e3_0] ){
+    S3 = _node[e3_1];
+  } else if ( S4 == _node[e3_1] ){
+    S3 = _node[e3_0];
+  } else {
+    ASSERT(false);
+  }
+
+  SMESHNodes hNodes = _nodesOnEdge[eh];
+  SMESHNodes bNodes = _nodesOnEdge[eb];
+  SMESHNodes gNodes = _nodesOnEdge[eg];
+  SMESHNodes dNodes = _nodesOnEdge[ed];
+  nodesOnQuad.resize( bNodes.size(), SMESHNodes(gNodes.size(), static_cast<SMDS_MeshNode*>(NULL)) );
+
+
+  int i, j, _i, _j;
+//   int &b_i = i, &h_i = i, &g_j = j, &d_j = j;
+  int *b_i = &i, *h_i = &i, *g_j = &j, *d_j = &j;
+  bool uWay = true, vWay = true;
+
+  if ( bNodes[0] != S1 ){
+    b_i = &_i;
+    uWay = false;
+    ASSERT( bNodes[bNodes.size()-1] == S1 );
+  } else {
+    ASSERT( bNodes[0] == S1);
+  }
+  if ( hNodes[0] != S4 ){
+    h_i = &_i;
+  } else {
+    ASSERT( hNodes[0] == S4 );
+  }
+  if ( gNodes[0] != S1 ){
+    g_j = &_j;
+    vWay = false;
+  } else {
+    ASSERT( gNodes[0] == S1 );
+  }
+  if ( dNodes[0] != S2 ){
+    d_j = &_j;
+  } else {
+    ASSERT( dNodes[0] == S2 );
+  }
+
+  //bNodes, hNodes
+  double u;
+  for (i = 0, _i = bNodes.size()-1; i < bNodes.size(); ++i, --_i){
+    nodesOnQuad[i][0]                = bNodes[*b_i];
+    nodesOnQuad[i][gNodes.size()-1 ] = hNodes[*h_i];
+
+    u = _nodeXx[ bNodes[*b_i] ];
+    if ( uWay == true ){
+      xx.push_back(u);
+    } else {
+      xx.push_back(1.-u);
+    }
+  }
+  if ( S1 != nodesOnQuad[0][0] ){
+    if(MYDEBUG) MESSAGE("ZZZZZZZZZZZZZZZZ quadID = "<<quad.getId());
+  }
+//   ASSERT( S1 == nodesOnQuad[0][0] );
+
+  //gNodes, dNodes
+  double v;
+  for (j = 0, _j = gNodes.size()-1; j < gNodes.size(); ++j, --_j){
+    nodesOnQuad[0][j] = gNodes[*g_j];
+    if ( S1 != nodesOnQuad[0][0] ){
+      if(MYDEBUG) MESSAGE("XXXXXXXXXXXXXXXX quadID = "<<quad.getId());
+    }
+//     ASSERT( S1 == nodesOnQuad[0][0] );
+    nodesOnQuad[bNodes.size()-1][j] = dNodes[*d_j];
+    v = _nodeXx[ gNodes[*g_j] ];
+    if ( vWay == true ){
+      yy.push_back(v);
+    } else {
+      yy.push_back(1.-v);
+    }
+  }
+
+
+  int iSize = nodesOnQuad.size();
+  int jSize = nodesOnQuad[0].size();
+  ASSERT( iSize = bNodes.size() );
+  ASSERT( jSize = gNodes.size() );
+
+//   ASSERT( S1 == nodesOnQuad[0][0] );
+//   ASSERT( S2 == nodesOnQuad[iSize-1][0]);
+//   ASSERT( S4 == nodesOnQuad[0][jSize-1]);
+//   ASSERT( S3 == nodesOnQuad[iSize-1][jSize-1]);
+
+  return ok;
+}
+
+
+bool SMESH_HexaBlocks::computeQuadByLinearApproximation( HEXA_NS::Quad& quad, bool way )
+{
+//   int id = quad.getId();
+//   if ( quad.getId() != 66 )  return false; //7, 41
+  if (MYDEBUG){
+    MESSAGE("computeQuadByLinearApproximation() : : begin   <<<<<<");
+    MESSAGE("quadID = "<<quad.getId());
+  }
+  ASSERT( _computeEdgeOK );
+  bool ok = true;
+
+  ArrayOfSMESHNodes nodesOnQuad; // nodes in this quad ( to be added on the mesh )
+  SMESHFaces      facesOnQuad;
+  SMDS_MeshFace*  newFace = NULL;
+  std::vector<double> xx, yy;
+
+  // Elements for quad computation
+  SMDS_MeshNode *S1, *S2, *S4, *S3; 
+
+//   bool initOk = _computeQuadInit( quad, eh, eb, eg, ed, S1, S2, S3, S4 );
+  bool initOk = _computeQuadInit( quad, nodesOnQuad, xx, yy );
+  if ( initOk == false ){
+    return false;
+  }
+
+  int iSize = nodesOnQuad.size();
+  int jSize = nodesOnQuad[0].size();
+
+  S1 = nodesOnQuad[0][0];
+//   S2 = nodesOnQuad[bNodes.size()-1][0];
+  S2 = nodesOnQuad[iSize-1][0];
+  S4 = nodesOnQuad[0][jSize-1];
+  S3 = nodesOnQuad[iSize-1][jSize-1];
+
+  for (int j = 1; j < jSize; ++j){
+    for (int i = 1; i < iSize; ++i){
+        SMDS_MeshNode* n1 = nodesOnQuad[i-1][j];
+        SMDS_MeshNode* n2 = nodesOnQuad[i-1][j-1];
+        SMDS_MeshNode* n3 = nodesOnQuad[i][j-1];
+        SMDS_MeshNode* n4 = nodesOnQuad[i][j];
+
+        if ( n4 == NULL ){
+            double newNodeX, newNodeY, newNodeZ;
+            SMDS_MeshNode* Ph = nodesOnQuad[i][jSize-1];   //dNodes[h_i];
+            SMDS_MeshNode* Pb = nodesOnQuad[i][0];   //bNodes[b_i];
+            SMDS_MeshNode* Pg = nodesOnQuad[0][j];   //gNodes[g_j];
+            SMDS_MeshNode* Pd = nodesOnQuad[iSize-1][j];  //dNodes[d_j];
+            double u = xx[i];
+            double v = yy[j];
+
+            _nodeInterpolationUV(u, v, Pg, Pd, Ph, Pb, S1, S2, S3, S4, newNodeX, newNodeY, newNodeZ);
+            n4 = _theMeshDS->AddNode( newNodeX, newNodeY, newNodeZ );
+            nodesOnQuad[i][j] = n4;
+        }
+
+        if (MYDEBUG){
+          MESSAGE("n1 (" << n1->X() << "," << n1->Y() << "," << n1->Z() << ")");
+          MESSAGE("n2 (" << n2->X() << "," << n2->Y() << "," << n2->Z() << ")");
+          MESSAGE("n4 (" << n4->X() << "," << n4->Y() << "," << n4->Z() << ")");
+          MESSAGE("n3 (" << n3->X() << "," << n3->Y() << "," << n3->Z() << ")");
+        }
+
+        if ( way == true ){
+            if (MYDEBUG) MESSAGE("AddFace( n1, n2, n3, n4 )");
+            newFace = _theMeshDS->AddFace( n1, n2, n3, n4 );
+        } else {
+            if (MYDEBUG) MESSAGE("AddFace( n4, n3, n2, n1 )");
+            newFace = _theMeshDS->AddFace( n4, n3, n2, n1 );
+        }
+        facesOnQuad.push_back(newFace);
+      }
+  }
+  _quadNodes[ &quad ] = nodesOnQuad;
+  _facesOnQuad[&quad] = facesOnQuad;
+  
+  if(MYDEBUG) MESSAGE("computeQuadByLinearApproximation() : end  >>>>>>>>");
+  return ok;
+}
+
+
+// --------------------------------------------------------------
+//                      Hexa computing
+// --------------------------------------------------------------
+bool SMESH_HexaBlocks::computeHexa( HEXA_NS::Document* doc )
+{
+  if(MYDEBUG) MESSAGE("computeHexa() : : begin   <<<<<<");
+  bool ok=false;
+
+  SMESH_MesherHelper aHelper(*_theMesh);
+  TopoDS_Shape shape = _theMesh->GetShapeToMesh();
+  aHelper.SetSubShape( shape );
+  aHelper.SetElementsOnShape( true );
+
+  SMESH_Gen* gen = _theMesh->GetGen();
+  SMESH_HexaFromSkin_3D algo( gen->GetANewId(), 0, gen, doc );
+  algo.InitComputeError();
+  try {
+      ok = algo.Compute( *_theMesh, &aHelper, _volumesOnHexa, _node );
+  } catch(...) {
+    if(MYDEBUG) MESSAGE("SMESH_HexaFromSkin_3D error!!! ");
+  }
+  if (MYDEBUG){
+    MESSAGE("SMESH_HexaFromSkin_3D.comment = "<<algo.GetComputeError()->myComment);
+    MESSAGE("computeHexa() : end  >>>>>>>>");
+  }
+  return ok;
+}
+
+
+
+// --------------------------------------------------------------
+//                Document computing
+// --------------------------------------------------------------
+bool SMESH_HexaBlocks::computeDoc(  HEXA_NS::Document* doc )
+{
+  if(MYDEBUG) MESSAGE("computeDoc() : : begin   <<<<<<");
+  bool ok = true;
+
+  // A) Vertex computation
+  
+  int nVertex = doc->countUsedVertex();
+  HEXA_NS::Vertex* vertex = NULL;
+
+  for (int j=0; j <nVertex; ++j ){ //Computing each vertex of the document
+    vertex = doc->getUsedVertex(j);
+    ok = computeVertex(*vertex);
+  }
+
+  // B) Edges computation
+  int nbPropa = 0;
+  HEXA_NS::Propagation* propa = NULL;
+  HEXA_NS::Law*         law   = NULL;
+  HEXA_NS::Edges edges;
+
+  nbPropa = doc->countPropagation();
+  for (int j=0; j < nbPropa; ++j ){//Computing each edge's propagations of the document
+    propa = doc->getPropagation(j);
+    edges = propa->getEdges();
+    law   = propa->getLaw();
+//     ASSERT( law );
+    if (law == NULL){
+      law = doc->getLaw(0); // default law
+    }
+    for( HEXA_NS::Edges::const_iterator iter = edges.begin();
+        iter != edges.end();
+        ++iter ){
+        ok = computeEdge(**iter, *law);
+    }
+  }
+  // C) Quad computation
+  std::map<HEXA_NS::Quad*, bool>  quadWays = computeQuadWays(doc);
+  int nQuad = doc->countUsedQuad();
+  HEXA_NS::Quad* q = NULL;
+  for (int j=0; j <nQuad; ++j ){ //Computing each quad of the document
+    q = doc->getUsedQuad(j);
+    int id = q->getId();
+    if ( quadWays.count(q) > 0 )
+      ok = computeQuad( *q, quadWays[q] );
+    else
+      if(MYDEBUG) MESSAGE("NO QUAD WAY ID = "<<id);
+
+  }
+
+  // D) Hexa computation: Calling HexaFromSkin algo
+  ok = computeHexa(doc);
+
+  if(MYDEBUG) MESSAGE("computeDoc() : end  >>>>>>>>");
+  return ok;
+}
+
+
+void SMESH_HexaBlocks::buildGroups(HEXA_NS::Document* doc)
+{
+  if (MYDEBUG){
+    MESSAGE("_addGroups() : : begin   <<<<<<");
+    MESSAGE("_addGroups() : : nb. hexas= " << doc->countUsedHexa());
+    MESSAGE("_addGroups() : : nb. quads= " << doc->countUsedQuad());
+    MESSAGE("_addGroups() : : nb. edges= " << doc->countUsedEdge());
+    MESSAGE("_addGroups() : : nb. nodes= " << doc->countUsedVertex());
+  }
+  // Looping on each groups of the document
+  for ( int i=0; i < doc->countGroup(); i++ ){
+      _fillGroup( doc->getGroup(i) );
+  };
+
+  if(MYDEBUG) MESSAGE("_addGroups() : end  >>>>>>>>");
+}
+
+// --------------------------------------------------------------
+//                      PRIVATE METHODS
+// --------------------------------------------------------------
+double SMESH_HexaBlocks::_Xx( double i, HEXA_NS::Law law, double nbNodes) //, double pos0 )
+{
+  double result;
+  double u0;
+
+  HEXA_NS::KindLaw k = law.getKind();
+  double coeff       = law.getCoefficient();
+  switch (k){
+    case HEXA_NS::Uniform:
+        result = (i+1)/(nbNodes+1);
+        if(MYDEBUG) MESSAGE( "_Xx():" << " Uniform u("<<i<< ")"<< " = " << result);
+        break;
+    case HEXA_NS::Arithmetic:
+        u0 = 1./(nbNodes + 1.) - (coeff*nbNodes)/2.;
+//         ASSERT(u0>0);
+        if ( u0 <= 0 ) throw (SALOME_Exception(LOCALIZED("Arithmetic discretization : check coefficient")));
+        if (i==0){
+          result = u0;
+        } else {
+          result = (i + 1.)*u0 + coeff*i*(i+1.)/2.;
+        };
+        if(MYDEBUG) MESSAGE( "_Xx():" << " Arithmetic u("<<i<< ")"<< " = " << result);
+        break;
+    case HEXA_NS::Geometric:
+        u0 = (1.-coeff)/(1.-pow(coeff, nbNodes + 1) )  ;
+//         ASSERT(u0>0);
+        if ( u0 <= 0 ) throw (SALOME_Exception(LOCALIZED("Geometric discretization : check coefficient")));
+        if (i==0){
+          result = u0;
+        } else {
+          result = u0 * (1.- pow(coeff, i + 1) )/(1.-coeff) ;
+        };
+        if(MYDEBUG) MESSAGE( "_Xx():" << " Geometric u("<<i<< ")"<< " = " << result);
+        break;
+  }
+  return result;
+}
+
+
+double SMESH_HexaBlocks::_edgeLength(const TopoDS_Edge & E)
+{
+  if(MYDEBUG) MESSAGE("_edgeLength() : : begin   <<<<<<");
+  double UMin = 0, UMax = 0;
+  if (BRep_Tool::Degenerated(E))
+    return 0;
+  TopLoc_Location L;
+  Handle(Geom_Curve) C = BRep_Tool::Curve(E, L, UMin, UMax);
+  GeomAdaptor_Curve AdaptCurve(C);
+  double length = GCPnts_AbscissaPoint::Length(AdaptCurve, UMin, UMax);
+  if(MYDEBUG) MESSAGE("_edgeLength() : end  >>>>>>>>");
+  return length;
+}
+
+
+void SMESH_HexaBlocks::_buildMyCurve(
+    const std::vector <HEXA_NS::Shape*>&       associations,   //IN
+    const gp_Pnt&                               myCurve_start,  //IN
+    const gp_Pnt&                              myCurve_end,    //IN
+    std::list< BRepAdaptor_Curve* >&           myCurve,        //INOUT
+    double&                                    myCurve_length, //INOUT
+    std::map< BRepAdaptor_Curve*, double>&     myCurve_lengths,//INOUT
+    std::map< BRepAdaptor_Curve*, bool>&       myCurve_ways,   //INOUT
+    std::map< BRepAdaptor_Curve*, double>&      myCurve_starts,   //INOUT
+    HEXA_NS::Edge&                             edge) // For error diagnostic
+{
+    if(MYDEBUG) MESSAGE("_buildMyCurve() : : begin   <<<<<<");
+    bool myCurve_way  = true;
+    myCurve_length    = 0.;
+    BRepAdaptor_Curve* thePreviousCurve = NULL;
+    BRepAdaptor_Curve* theCurve         = NULL;
+
+    gp_Pnt  theCurve_start, theCurve_end;
+    gp_Pnt  thePreviousCurve_start , thePreviousCurve_end;
+
+    for ( std::vector <HEXA_NS::Shape*> ::const_iterator assoc = associations.begin();
+          assoc != associations.end();
+          ++assoc ){
+        string        theBrep  = (*assoc)->getBrep();
+        double        ass_debut = std::min ((*assoc)->debut, (*assoc)->fin);
+        double        ass_fin   = std::max ((*assoc)->debut, (*assoc)->fin);
+        TopoDS_Shape  theShape = string2shape( theBrep );
+        TopoDS_Edge   theEdge  = TopoDS::Edge( theShape );
+        double        theCurve_length = _edgeLength( theEdge );
+        if (MYDEBUG)
+            MESSAGE("_edgeLength ->"<<theCurve_length);
+
+        if ( theCurve_length > 0 ){
+            double f, l;
+            Handle(Geom_Curve) testCurve = BRep_Tool::Curve(theEdge, f, l);
+            theCurve = new BRepAdaptor_Curve( theEdge );
+
+            GCPnts_AbscissaPoint discret_start (*theCurve, 
+                                                 theCurve_length*ass_debut, 
+                                                 theCurve->FirstParameter() );
+            GCPnts_AbscissaPoint discret_end (*theCurve, 
+                                               theCurve_length*ass_fin, 
+                                               theCurve->FirstParameter() );
+            double u_start = discret_start.Parameter();
+            double u_end   = discret_end.Parameter();
+            ASSERT( discret_start.IsDone() && discret_end.IsDone() );
+            theCurve_start  = theCurve->Value( u_start);
+            theCurve_end    = theCurve->Value( u_end );
+            theCurve_length = theCurve_length*( ass_fin - ass_debut);
+
+            if (MYDEBUG){
+              MESSAGE("testCurve->f ->"<<f);
+              MESSAGE("testCurve->l ->"<<l);
+              MESSAGE("testCurve->FirstParameter ->"<<testCurve->FirstParameter());
+              MESSAGE("testCurve->LastParameter  ->"<<testCurve->LastParameter());
+
+              MESSAGE("FirstParameter ->"<<theCurve->FirstParameter());
+              MESSAGE("LastParameter  ->"<<theCurve->LastParameter());
+              MESSAGE("theCurve_length ->"<<theCurve_length);
+              MESSAGE("(*assoc)->debut ->"<< ass_debut );
+              MESSAGE("(*assoc)->fin   ->"<< ass_fin );
+              MESSAGE("u_start ->"<<u_start);
+              MESSAGE("u_end   ->"<<u_end);
+              MESSAGE("myCurve_start( "<<myCurve_start.X()<<", "<<myCurve_start.Y()<<", "<<myCurve_start.Z()<<") ");
+              MESSAGE("theCurve_start( "<<theCurve_start.X()<<", "<<theCurve_start.Y()<<", "<<theCurve_start.Z()<<") ");
+              MESSAGE("myCurve_end( "<<myCurve_end.X()<<", "<<myCurve_end.Y()<<", "<<myCurve_end.Z()<<") ");  
+              MESSAGE("theCurve_end( "<<theCurve_end.X()<<", "<<theCurve_end.Y()<<", "<<theCurve_end.Z()<<") ");
+            }
+
+            if ( thePreviousCurve == NULL ){ 
+                // setting myCurve_way and first curve way
+                if ( myCurve_start.IsEqual(theCurve_start, HEXA_EPSILON) ){
+                    if(MYDEBUG) MESSAGE("myCurve_start.IsEqual(theCurve_start, HEXA_EPSILON)");
+                    myCurve_way = true;
+                    myCurve_ways[theCurve] = true;
+                } else if ( myCurve_start.IsEqual(theCurve_end, HEXA_EPSILON) ){
+                    if(MYDEBUG) MESSAGE("myCurve_start.IsEqual(theCurve_end, HEXA_EPSILON)");
+                    myCurve_way = true;
+                    myCurve_ways[theCurve] = false;
+                } else if ( myCurve_end.IsEqual(theCurve_end, HEXA_EPSILON) ){
+                    if(MYDEBUG) MESSAGE("myCurve_end.IsEqual(theCurve_end, HEXA_EPSILON)");
+                    myCurve_way = false;
+                    myCurve_ways[theCurve] = true;
+                } else if ( myCurve_end.IsEqual(theCurve_start, HEXA_EPSILON) ){
+                    if(MYDEBUG) MESSAGE("myCurve_end.IsEqual(theCurve_start, HEXA_EPSILON)");
+                    myCurve_way = false;
+                    myCurve_ways[theCurve] = false;
+                } else {
+                    if(MYDEBUG) MESSAGE("SOMETHING WRONG on edge association... Bad script?");
+//                     ASSERT(false);
+                    edge.dumpAsso();
+                    throw (SALOME_Exception(LOCALIZED("Edge association : check association parameters ( first, last ) between HEXA model and CAO")));
+                }
+
+            } else {
+                // it is not the first or last curve.
+                // ways are calculated between previous and new one.
+                if (   thePreviousCurve_end.IsEqual( theCurve_end, HEXA_EPSILON  )
+                    or thePreviousCurve_start.IsEqual( theCurve_start, HEXA_EPSILON ) ){
+                    myCurve_ways[theCurve] = !myCurve_ways[thePreviousCurve];// opposite WAY 
+                    if(MYDEBUG) MESSAGE("opposite WAY");
+                } else if (  thePreviousCurve_end.IsEqual( theCurve_start, HEXA_EPSILON )
+                          or thePreviousCurve_start.IsEqual( theCurve_end, HEXA_EPSILON ) ){
+                    myCurve_ways[theCurve] = myCurve_ways[thePreviousCurve];// same WAY 
+                    if(MYDEBUG) MESSAGE("same WAY");
+                } else {
+                    if(MYDEBUG) MESSAGE("SOMETHING WRONG on edge association... bad script?");
+//                     ASSERT(false);
+                    throw (SALOME_Exception(LOCALIZED("Edge association : Check association parameters ( first, last ) between HEXA model and CAO")));
+                }
+            }
+
+            myCurve_starts[theCurve]  = u_start;
+            myCurve_lengths[theCurve] = theCurve_length;
+            myCurve_length            += theCurve_length;
+            myCurve.push_back( theCurve );
+
+            thePreviousCurve       = theCurve;
+            thePreviousCurve_start = theCurve_start;
+            thePreviousCurve_end   = theCurve_end;
+
+        }//if ( theCurveLength > 0 ){
+
+    }// for
+
+
+    if ( myCurve_way == false ){
+        std::list< BRepAdaptor_Curve* > tmp( myCurve.size() ); 
+       std::copy( myCurve.rbegin(), myCurve.rend(), tmp.begin() );
+       myCurve = tmp;
+    }
+
+    if (MYDEBUG) {
+      MESSAGE("myCurve_way  was :"<<myCurve_way);
+      MESSAGE("_buildMyCurve() : end  >>>>>>>>");
+    }
+}
+
+
+
+
+gp_Pnt SMESH_HexaBlocks::_getPtOnMyCurve( 
+    const double&                             myCurve_u,      //IN
+    std::map< BRepAdaptor_Curve*, bool>&      myCurve_ways,   //IN
+    std::map< BRepAdaptor_Curve*, double>&    myCurve_lengths,//IN
+    std::map< BRepAdaptor_Curve*, double>&    myCurve_starts, //IN
+    std::list< BRepAdaptor_Curve* >&          myCurve,        //INOUT
+    double&                                   myCurve_start ) //INOUT
+//     std::map< BRepAdaptor_Curve*, double>&  myCurve_firsts,
+//     std::map< BRepAdaptor_Curve*, double>&  myCurve_lasts,
+{
+  if(MYDEBUG) MESSAGE("_getPtOnMyCurve() : : begin   <<<<<<");
+  gp_Pnt ptOnMyCurve;
+
+  // looking for curve which contains parameter myCurve_u 
+  BRepAdaptor_Curve* curve      = myCurve.front();
+  double            curve_start = myCurve_start;
+  double            curve_end   = curve_start + myCurve_lengths[curve];
+  double            curve_u;
+  GCPnts_AbscissaPoint discret;
+
+  if (MYDEBUG){
+    MESSAGE("looking for curve: c    = "<<myCurve_u);
+    MESSAGE("looking for curve: curve_start  = "<<curve_start);
+    MESSAGE("looking for curve: curve_end    = "<<curve_end);
+    MESSAGE("looking for curve: curve_lenght = "<<myCurve_lengths[curve]);
+    MESSAGE("looking for curve: curve.size _lenght= "<<myCurve.size());
+  }
+  while ( not ( (myCurve_u >= curve_start) and  (myCurve_u <= curve_end) ) ) {
+    // if (myCurve.size() == 0 )
+       // {
+       // PutData (myCurve.size());
+       // PutData (myCurve_u);
+       // }
+
+    ASSERT( myCurve.size() != 0 );
+    myCurve.pop_front();
+    curve       = myCurve.front();
+    curve_start = curve_end;
+    curve_end   = curve_start + myCurve_lengths[curve];
+    if (MYDEBUG){
+      MESSAGE("go next curve: curve_lenght = "<<myCurve_lengths[curve]);
+      MESSAGE("go next curve: curve_start  = "<<curve_start);
+      MESSAGE("go next curve: curve_end    = "<<curve_end);
+      MESSAGE("go next curve: myCurve_u    = "<<myCurve_u);
+    }
+  }
+  myCurve_start = curve_start;
+
+  // compute point
+  if ( myCurve_ways[curve] ){
+//     curve_u = myCurve_firsts[curve] + (myCurve_u - curve_start);
+//     discret = GCPnts_AbscissaPoint( *curve, (myCurve_u - curve_start), curve->FirstParameter() );
+    discret = GCPnts_AbscissaPoint( *curve, (myCurve_u - curve_start), myCurve_starts[curve] );
+  } else {
+//     discret = GCPnts_AbscissaPoint( *curve, myCurve_lengths[curve]- (myCurve_u - curve_start), curve->FirstParameter() );
+    discret = GCPnts_AbscissaPoint( *curve, myCurve_lengths[curve]- (myCurve_u - curve_start), myCurve_starts[curve] );
+  }
+  ASSERT(discret.IsDone());
+  curve_u = discret.Parameter();
+  ptOnMyCurve = curve->Value( curve_u );
+
+  if (MYDEBUG){
+    MESSAGE("curve found!");
+    MESSAGE("curve_u = "<< curve_u);
+    MESSAGE("curve way = "<< myCurve_ways[curve]);
+    MESSAGE("_getPtOnMyCurve() : end  >>>>>>>>");
+  }
+  return ptOnMyCurve;
+}
+
+
+
+
+
+
+
+void SMESH_HexaBlocks::_nodeInterpolationUV(double u, double v,
+    SMDS_MeshNode* Pg, SMDS_MeshNode* Pd, SMDS_MeshNode* Ph, SMDS_MeshNode* Pb,
+    SMDS_MeshNode* S1, SMDS_MeshNode* S2, SMDS_MeshNode* S3, SMDS_MeshNode* S4,
+    double& xOut, double& yOut, double& zOut )
+{ 
+  if (MYDEBUG){
+    MESSAGE("_nodeInterpolationUV() IN:");
+    MESSAGE("u ( "<< u <<" )");
+    MESSAGE("v ( "<< v <<" )");
+
+    MESSAGE("S1 (" << S1->X() << "," << S1->Y() << "," << S1->Z() << ")");
+    MESSAGE("S2 (" << S2->X() << "," << S2->Y() << "," << S2->Z() << ")");
+    MESSAGE("S4 (" << S4->X() << "," << S4->Y() << "," << S4->Z() << ")");
+    MESSAGE("S3 (" << S3->X() << "," << S3->Y() << "," << S3->Z() << ")");
+
+    MESSAGE("Pg (" << Pg->X() << "," << Pg->Y() << "," << Pg->Z() << ")");
+    MESSAGE("Pd (" << Pd->X() << "," << Pd->Y() << "," << Pd->Z() << ")");
+    MESSAGE("Ph (" << Ph->X() << "," << Ph->Y() << "," << Ph->Z() << ")");
+    MESSAGE("Pb (" << Pb->X() << "," << Pb->Y() << "," << Pb->Z() << ")");
+  }
+
+  xOut = ((1.-u)*Pg->X() + v*Ph->X() + u*Pd->X() + (1.-v)*Pb->X()) - (1.-u)*(1.-v)*S1->X() - u*(1.-v)*S2->X() - u*v*S3->X() - (1.-u)*v*S4->X();
+  yOut = ((1.-u)*Pg->Y() + v*Ph->Y() + u*Pd->Y() + (1.-v)*Pb->Y()) - (1.-u)*(1.-v)*S1->Y() - u*(1.-v)*S2->Y() - u*v*S3->Y() - (1.-u)*v*S4->Y();
+  zOut = ((1.-u)*Pg->Z() + v*Ph->Z() + u*Pd->Z() + (1.-v)*Pb->Z()) - (1.-u)*(1.-v)*S1->Z() - u*(1.-v)*S2->Z() - u*v*S3->Z() - (1.-u)*v*S4->Z();
+
+  if (MYDEBUG){
+    MESSAGE("_nodeInterpolationUV() OUT("<<xOut<<","<<yOut<<","<<zOut<<" )");
+  }
+}
+
+
+TopoDS_Shape SMESH_HexaBlocks::_getShapeOrCompound( const std::vector<HEXA_NS::Shape*>& shapesIn)
+{
+  ASSERT( shapesIn.size()!=0 );
+
+  if (shapesIn.size() == 1) {
+    HEXA_NS::Shape* assoc = shapesIn.front(); 
+    string strBrep = assoc->getBrep();
+    return string2shape( strBrep );
+  } else {
+    TopoDS_Compound aCompound;
+    BRep_Builder aBuilder;
+    aBuilder.MakeCompound( aCompound );
+
+    for ( std::vector <HEXA_NS::Shape*> ::const_iterator assoc = shapesIn.begin();
+          assoc != shapesIn.end();
+          ++assoc ){
+        string strBrep     = (*assoc)->getBrep();
+        TopoDS_Shape shape = string2shape( strBrep );
+        aBuilder.Add( aCompound, shape );
+    }
+    return aCompound;
+  }
+}
+
+
+// ================================================== carre
+inline double carre (double val)
+{
+  return val*val;
+}
+// ================================================== dist2
+inline double dist2 (const gp_Pnt& pt1, const gp_Pnt& pt2)
+{
+   double dist = carre (pt2.X()-pt1.X()) + carre (pt2.Y()-pt1.Y()) 
+                                         + carre (pt2.Z()-pt1.Z());
+   return dist;
+}
+// ================================================== _intersect
+gp_Pnt SMESH_HexaBlocks::_intersect( const gp_Pnt& Pt,
+                                     const gp_Vec& u, const gp_Vec& v,
+                                     const TopoDS_Shape& shape,
+                                     Standard_Real tol )
+{
+  gp_Pnt result;
+
+  gp_Vec normale = u^v;
+  gp_Dir dir(normale);
+  gp_Lin li( Pt, dir );
+
+  Standard_Real s = -Precision::Infinite();
+  Standard_Real e = +Precision::Infinite();
+
+  IntCurvesFace_ShapeIntersector inter;
+  inter.Load(shape, tol);
+//   inter.Load(S, tol);
+  inter.Perform(li, s, e);//inter.PerformNearest(li, s, e);
+
+/**************************************************************  Abu 2011-11-04 */
+  /// if ( inter.IsDone() && (inter.NbPnt()==1) ) {
+  if ( inter.IsDone() )
+     {
+     result = inter.Pnt(1);//first
+     int nbrpts = inter.NbPnt();
+     if (nbrpts>1)
+        {
+        double d0 = dist2 (result, Pt);
+        for (int i=2; i <= inter.NbPnt(); ++i )
+            {
+            double d1 = dist2 (Pt, inter.Pnt(i));
+            if (d1<d0)
+               {
+               d0 = d1;
+               result = inter.Pnt (i);
+               }
+            }
+        }
+/**************************************************************  Abu 2011-11-04 (fin) */
+    if (MYDEBUG){
+      MESSAGE("_intersect() : OK");
+      for ( int i=1; i <= inter.NbPnt(); ++i ){
+        gp_Pnt tmp = inter.Pnt(i);
+        MESSAGE("_intersect() : pnt("<<i<<") = ("<<tmp.X()<<","<<tmp.Y()<<","<<tmp.Z()<<" )");
+      }
+    }
+    _found +=1;
+  } else {
+    if(MYDEBUG) MESSAGE("_intersect() : KO");
+    result = Pt;
+    _notFound +=1;
+  }
+  _total+=1;
+
+  return result;
+}
+
+// parameters q : IN,  v0: INOUT, v1: INOUT
+void SMESH_HexaBlocks::_searchInitialQuadWay( HEXA_NS::Quad* q, HEXA_NS::Vertex*& v0, HEXA_NS::Vertex*& v1 )
+{
+  if(MYDEBUG) MESSAGE("_searchInitialQuadWay() : begin");
+  v0 = NULL; v1 = NULL;
+  if ( q->getNbrParents() != 1 ) return; // q must be a skin quad
+
+  HEXA_NS::Vertex* qA = q->getVertex(0);
+  HEXA_NS::Vertex* qB = q->getVertex(1);
+  HEXA_NS::Vertex* qC = q->getVertex(2);
+  HEXA_NS::Vertex* qD = q->getVertex(3);
+
+  // searching for vertex on opposed quad
+  HEXA_NS::Vertex *qAA = NULL, *qBB = NULL, *qCC = NULL, *qDD = NULL;
+  HEXA_NS::Hexa* h = q->getParent(0);
+  for( int i=0; i < h->countEdge(); ++i  ){
+    HEXA_NS::Edge* e = h->getEdge(i);
+    HEXA_NS::Vertex* e0 = e->getVertex(0);
+    HEXA_NS::Vertex* e1 = e->getVertex(1);
+
+    if ( e0 == qA and e1 != qB and e1 != qC and e1 != qD ){
+      qAA = e1;
+    } else if ( e1 == qA and e0 != qB and e0 != qC and e0 != qD ){
+      qAA = e0;
+    } else if ( e0 == qB and e1 != qA and e1 != qC and e1 != qD ){
+      qBB = e1;
+    } else if ( e1 == qB and e0 != qA and e0 != qC and e0 != qD ){
+      qBB = e0;
+    } else if ( e0 == qC and e1 != qA and e1 != qB and e1 != qD ){
+      qCC = e1;
+    } else if ( e1 == qC and e0 != qA and e0 != qB and e0 != qD ){
+      qCC = e0;
+    } else if ( e0 == qD and e1 != qA and e1 != qB and e1 != qC ){
+      qDD = e1;
+    } else if ( e1 == qD and e0 != qA and e0 != qB and e0 != qC ){
+      qDD = e0;
+    }
+  }
+
+  // working on final value ( point on CAO ), not on model
+  SMDS_MeshNode *nA = _node[qA], *nAA = _node[qAA];
+  SMDS_MeshNode *nB = _node[qB], *nBB = _node[qBB];
+  SMDS_MeshNode *nC = _node[qC], *nCC = _node[qCC];
+  SMDS_MeshNode *nD = _node[qD], *nDD = _node[qDD];
+
+  gp_Pnt pA( nA->X(), nA->Y(), nA->Z() );
+  gp_Pnt pB( nB->X(), nB->Y(), nB->Z() );
+  gp_Pnt pC( nC->X(), nC->Y(), nC->Z() );
+  gp_Pnt pD( nD->X(), nD->Y(), nD->Z() );
+
+  gp_Pnt pAA( nAA->X(), nAA->Y(), nAA->Z() );
+  gp_Pnt pBB( nBB->X(), nBB->Y(), nBB->Z() );
+  gp_Pnt pCC( nCC->X(), nCC->Y(), nCC->Z() );
+  gp_Pnt pDD( nDD->X(), nDD->Y(), nDD->Z() );
+
+  gp_Vec AB( pA, pB );
+  gp_Vec AC( pA, pC );
+  gp_Vec normP = AB^AC; 
+  gp_Dir dirP( normP );
+
+  // building plane for point projection
+  gp_Pln plnP( gp_Pnt(nA->X(), nA->Y(), nA->Z()), dirP);
+  TopoDS_Shape sPlnP = BRepBuilderAPI_MakeFace(plnP).Face();
+
+  // PAAA is the result of PAA projection
+  gp_Pnt pAAA = _intersect( pAA, AB, AC, sPlnP );
+  gp_Pnt pBBB = _intersect( pBB, AB, AC, sPlnP );
+  gp_Pnt pCCC = _intersect( pCC, AB, AC, sPlnP );
+  gp_Pnt pDDD = _intersect( pDD, AB, AC, sPlnP );
+
+  gp_Dir AA( gp_Vec(pAA, pAAA) );
+  gp_Dir BB( gp_Vec(pBB, pBBB) );
+  gp_Dir CC( gp_Vec(pCC, pCCC) );
+  gp_Dir DD( gp_Vec(pDD, pDDD) );
+
+  // eventually, we are able to know if the input quad is a good client!
+  // exit the fonction otherwise
+  if ( AA.IsOpposite(BB, HEXA_QUAD_WAY) ) return;
+  if ( BB.IsOpposite(CC, HEXA_QUAD_WAY) ) return;
+  if ( CC.IsOpposite(DD, HEXA_QUAD_WAY) ) return;
+
+  // ok, give the input quad the good orientation by
+  // setting 2 vertex 
+  if ( !dirP.IsOpposite(AA, HEXA_QUAD_WAY) ) { //OK
+      v0 = qA; v1 = qB;
+  } else {
+      v0 = qB; v1 = qA;
+  }
+
+  if(MYDEBUG) MESSAGE("_searchInitialQuadWay() : end");
+}
+
+SMESH_Group* SMESH_HexaBlocks::_createGroup(HEXA_NS::Group& grHex)
+{
+  if(MYDEBUG) MESSAGE("_createGroup() : : begin   <<<<<<");
+
+  std::string aGrName           = grHex.getName();
+  HEXA_NS::EnumGroup grHexKind  = grHex.getKind();
+
+  if(MYDEBUG) MESSAGE("aGrName"<<aGrName);
+
+  SMDSAbs_ElementType aGrType;
+  switch ( grHexKind ){
+    case HEXA_NS::HexaCell   : aGrType = SMDSAbs_Volume; break;
+    case HEXA_NS::QuadCell   : aGrType = SMDSAbs_Face  ; break;
+    case HEXA_NS::EdgeCell   : aGrType = SMDSAbs_Edge  ; break;
+    case HEXA_NS::HexaNode   : aGrType = SMDSAbs_Node  ; break;
+    case HEXA_NS::QuadNode   : aGrType = SMDSAbs_Node  ; break;
+    case HEXA_NS::EdgeNode   : aGrType = SMDSAbs_Node  ; break;
+    case HEXA_NS::VertexNode : aGrType = SMDSAbs_Node  ; break;
+    default : ASSERT(false);
+  }
+
+  int aId;
+  SMESH_Group* aGr = _theMesh->AddGroup(aGrType, aGrName.c_str(), aId);
+
+  if(MYDEBUG) MESSAGE("_createGroup() : end  >>>>>>>>");
+  return aGr;
+}
+
+void SMESH_HexaBlocks::_fillGroup(HEXA_NS::Group* grHex )
+{
+  if(MYDEBUG) MESSAGE("_fillGroup() : : begin   <<<<<<");
+
+  SMESH_Group* aGr = _createGroup( *grHex );
+  HEXA_NS::EltBase*  grHexElt   = NULL;
+  HEXA_NS::EnumGroup grHexKind  = grHex->getKind();
+  int                grHexNbElt = grHex->countElement();
+
+  if(MYDEBUG) MESSAGE("_fillGroup() : kind = " << grHexKind);
+  if(MYDEBUG) MESSAGE("_fillGroup() : count= " << grHexNbElt);
+
+  // A)Looking for elements ID
+  std::vector<const SMDS_MeshElement*> aGrEltIDs;
+
+  for ( int n=0; n<grHexNbElt; ++n ){
+      grHexElt = grHex->getElement(n);
+
+      switch ( grHexKind ){
+        case HEXA_NS::HexaCell:
+        {
+            HEXA_NS::Hexa* h = reinterpret_cast<HEXA_NS::Hexa*>(grHexElt);
+//             HEXA_NS::Hexa* h = dynamic_cast<HEXA_NS::Hexa*>(grHexElt);
+//             ASSERT(h);
+            if ( _volumesOnHexa.count(h)>0 ){
+              SMESHVolumes volumes = _volumesOnHexa[h];
+              for ( SMESHVolumes::iterator aVolume = volumes.begin(); aVolume != volumes.end(); ++aVolume ){
+                  aGrEltIDs.push_back(*aVolume);
+              }
+            } else {
+              if(MYDEBUG) MESSAGE("GROUP OF VOLUME: volume for hexa (id = "<<h->getId()<<") not found");
+            }
+        }
+        break;
+        case HEXA_NS::QuadCell:
+        {
+            HEXA_NS::Quad* q = reinterpret_cast<HEXA_NS::Quad*>(grHexElt);
+//             HEXA_NS::Quad* q = dynamic_cast<HEXA_NS::Quad*>(grHexElt);
+//             ASSERT(q);
+            if ( _facesOnQuad.count(q)>0 ){
+              SMESHFaces faces = _facesOnQuad[q];
+              for ( SMESHFaces::iterator aFace = faces.begin(); aFace != faces.end(); ++aFace ){
+                  aGrEltIDs.push_back(*aFace);
+              }
+            } else {
+              if(MYDEBUG) MESSAGE("GROUP OF FACE: face for quad (id = "<<q->getId()<<") not found");
+            }
+        }
+        break;
+        case HEXA_NS::EdgeCell:
+        {
+            HEXA_NS::Edge* e = reinterpret_cast<HEXA_NS::Edge*>(grHexElt);
+//             HEXA_NS::Edge* e = dynamic_cast<HEXA_NS::Edge*>(grHexElt);
+//             ASSERT(e);
+            if ( _edgesOnEdge.count(e)>0 ){
+              SMESHEdges edges = _edgesOnEdge[e];
+              for ( SMESHEdges::iterator anEdge = edges.begin(); anEdge != edges.end(); ++anEdge ){
+                  aGrEltIDs.push_back(*anEdge);
+              }
+            } else {
+              if(MYDEBUG) MESSAGE("GROUP OF Edge: edge for edge (id = "<<e->getId()<<") not found");
+            }
+        }
+        break;
+        case HEXA_NS::HexaNode: 
+        {
+            HEXA_NS::Hexa* h = reinterpret_cast<HEXA_NS::Hexa*>(grHexElt);
+//             HEXA_NS::Hexa* h = dynamic_cast<HEXA_NS::Hexa*>(grHexElt);
+//             ASSERT(h);
+            if ( _volumesOnHexa.count(h)>0 ){
+              SMESHVolumes volumes = _volumesOnHexa[h];
+              for ( SMESHVolumes::iterator aVolume = volumes.begin(); aVolume != volumes.end(); ++aVolume ){
+                SMDS_ElemIteratorPtr aNodeIter = (*aVolume)->nodesIterator();
+                while( aNodeIter->more() ){
+                  const SMDS_MeshNode* aNode = 
+                    dynamic_cast<const SMDS_MeshNode*>( aNodeIter->next() );
+                  if ( aNode ){
+                      aGrEltIDs.push_back(aNode);
+                  }
+                }
+              }
+            } else {
+              if(MYDEBUG) MESSAGE("GROUP OF HEXA NODES: nodes on hexa  (id = "<<h->getId()<<") not found");
+            }
+        }
+        break;
+        case HEXA_NS::QuadNode:
+        {
+            HEXA_NS::Quad* q = reinterpret_cast<HEXA_NS::Quad*>(grHexElt);
+//             HEXA_NS::Quad* q = dynamic_cast<HEXA_NS::Quad*>(grHexElt);
+//             ASSERT(q);
+            if ( _quadNodes.count(q)>0 ){
+              ArrayOfSMESHNodes nodesOnQuad = _quadNodes[q];
+              for ( ArrayOfSMESHNodes::iterator nodes = nodesOnQuad.begin(); nodes != nodesOnQuad.end(); ++nodes){
+                for ( SMESHNodes::iterator aNode = nodes->begin(); aNode != nodes->end(); ++aNode){
+                  aGrEltIDs.push_back(*aNode);
+                }
+              }
+            } else {
+              if(MYDEBUG) MESSAGE("GROUP OF QUAD NODES: nodes on quad (id = "<<q->getId()<<") not found");
+            }
+        }
+        break;
+        case HEXA_NS::EdgeNode:
+        {
+            HEXA_NS::Edge* e = reinterpret_cast<HEXA_NS::Edge*>(grHexElt);
+//             HEXA_NS::Edge* e = dynamic_cast<HEXA_NS::Edge*>(grHexElt);
+//             ASSERT(e);
+            if ( _nodesOnEdge.count(e)>0 ){
+              SMESHNodes nodes = _nodesOnEdge[e];
+              for ( SMESHNodes::iterator aNode = nodes.begin(); aNode != nodes.end(); ++aNode){
+                aGrEltIDs.push_back(*aNode);
+              }
+            } else {
+              if(MYDEBUG) MESSAGE("GROUP OF EDGE NODES: nodes on edge (id = "<<e->getId()<<") not found");
+            }
+        }
+        break;
+        case HEXA_NS::VertexNode:
+        {
+          HEXA_NS::Vertex* v = reinterpret_cast<HEXA_NS::Vertex*>(grHexElt);
+//             HEXA_NS::Vertex* v = dynamic_cast<HEXA_NS::Vertex*>(grHexElt);
+//             ASSERT(v);
+            if ( _node.count(v)>0 ){
+              aGrEltIDs.push_back(_node[v]);
+            } else {
+              if(MYDEBUG) MESSAGE("GROUP OF VERTEX NODES: nodes for vertex (id = "<<v->getId()<<") not found");
+            }
+        }
+        break;
+        default : ASSERT(false);
+      }
+  }
+
+  // B)Filling the group on SMESH
+  SMESHDS_Group* aGroupDS = dynamic_cast<SMESHDS_Group*>( aGr->GetGroupDS() );
+
+  for ( int i=0; i < aGrEltIDs.size(); i++ ) {
+    aGroupDS->SMDSGroup().Add( aGrEltIDs[i] );
+  };
+
+  if(MYDEBUG) MESSAGE("_fillGroup() : end  >>>>>>>>");
+}
+
+
+
+
+
+// not used, for backup purpose only:
+void SMESH_HexaBlocks::_getCurve( const std::vector<HEXA_NS::Shape*>& shapesIn,
+  Handle_Geom_Curve& curveOut, double& curveFirstOut, double& curveLastOut )
+{
+//   std::cout<<"------------------- _getCurve ------------ "<<std::endl;
+  GeomConvert_CompCurveToBSplineCurve* gen = NULL;
+
+  double curvesLenght = 0.;
+  double curvesFirst = shapesIn.front()->debut;
+  double curvesLast  = shapesIn.back()->fin;
+
+  for ( std::vector <HEXA_NS::Shape*> ::const_iterator assoc = shapesIn.begin();
+        assoc != shapesIn.end();
+        ++assoc ){
+      string strBrep     = (*assoc)->getBrep();
+      TopoDS_Shape shape = string2shape( strBrep );
+      TopoDS_Edge Edge   = TopoDS::Edge(shape);
+      double f, l;
+      Handle(Geom_Curve) curve = BRep_Tool::Curve(Edge, f, l);
+      curvesLenght += l-f;
+      Handle(Geom_BoundedCurve) bCurve = Handle(Geom_BoundedCurve)::DownCast(curve);
+      if ( gen == NULL ){
+        gen = new GeomConvert_CompCurveToBSplineCurve(bCurve);
+      } else {
+        bool bb=gen->Add(bCurve, Precision::Confusion(), Standard_True, Standard_False, 1);
+        ASSERT(bb);
+      }
+  }
+  curveFirstOut = curvesFirst/curvesLenght;
+  curveLastOut  = curvesLenght - (1.-curvesLast)/curvesLenght;
+  curveOut      = gen->BSplineCurve();
+
+  std::cout<<"curvesFirst -> "<<curvesFirst<<std::endl;
+  std::cout<<"curvesLast  -> "<<curvesLast<<std::endl;
+  std::cout<<"curvesLenght  -> "<<curvesLenght<<std::endl;
+  std::cout<<"curveFirstOut -> "<<curveFirstOut<<std::endl;
+  std::cout<<"curveLastOut  -> "<<curveLastOut<<std::endl;
+
+}
+
+
+
+
+
+// bool SMESH_HexaBlocks::_areSame(double a, double b)
+// {
+//   return fabs(a - b) < HEXA_EPSILON;
+// }
+// //     MESSAGE("Angular() :" << dir2.IsOpposite(dir1, Precision::Angular()));
+// //   ASSERT( dir2.IsParallel(dir1, HEXA_QUAD_WAY) );
+// //   bool test2 = norm2.IsOpposite(norm1, HEXA_QUAD_WAY2) == norm3.IsOpposite(norm1, HEXA_QUAD_WAY2);
+// //       way = norm1.IsOpposite(norm3.Reversed(), HEXA_QUAD_WAY2);
+//   gp_Pnt p( n->X(), n->Y(), n->Z() );
+//   gp_Pnt ptOnPlane;
+//   gp_Pnt ptOnSurface;
+//   gp_Pnt ptOnPlaneOrSurface;
+// //   gp_Vec norm2(p1, p);
+//   TopoDS_Shape  planeOrSurface;
+// 
+// 
+//   gp_Pln        pln(p1, dir1);
+//   TopoDS_Shape  shapePln = BRepBuilderAPI_MakeFace(pln).Face();
+//   ptOnPlane = _intersect( p, a1, b1, shapePln );
+//   ptOnPlaneOrSurface = ptOnPlane;
+// 
+// 
+// //   if ( assoc != NULL ){
+// //     MESSAGE("_computeQuadWay with assoc");
+//   for( int i=0; i < h->countEdge(); ++i  ){ 
+//     HEXA_NS::Edge* e = h->getUsedEdge(i);
+//     if ( e->definedBy(v1,v2) ){
+//       const std::vector <HEXA_NS::Shape*> assocs = e->getAssociations();
+//       if ( assocs.size() != 0 ){
+//         HEXA_NS::Shape* assoc = assocs[0]; //CS_TODO
+//         string        theBrep  = assoc->getBrep();
+//         TopoDS_Shape  theShape = string2shape( theBrep );
+//         ptOnSurface = _intersect( p, a1, b1, theShape );
+//         if ( !ptOnSurface.IsEqual(p, HEXA_EPSILON) ){
+//           ptOnPlaneOrSurface = ptOnSurface;
+//         } 
+//       }
+//     }
+//   }
+// 
diff --git a/src/HEXABLOCKPlugin/HEXABLOCKPlugin_mesh.hxx b/src/HEXABLOCKPlugin/HEXABLOCKPlugin_mesh.hxx
new file mode 100755 (executable)
index 0000000..d187069
--- /dev/null
@@ -0,0 +1,217 @@
+// Copyright (C) 2009-2012  CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+//  File   : SMESH_HexaBlocks.hxx
+//  Author : 
+//  Module : SMESH
+//
+#ifndef _SMESH_HexaBlocks_HeaderFile
+#define _SMESH_HexaBlocks_HeaderFile
+
+#include <SALOMEconfig.h>
+
+#ifdef WNT
+# if defined HEXABLOCKS_EXPORTS || defined HexaBlocks_EXPORTS
+#  define HEXABLOCKS_EXPORT __declspec( dllexport )
+# else
+#  define HEXABLOCKS_EXPORT __declspec( dllimport )
+# endif
+#else
+# define HEXABLOCKS_EXPORT
+#endif
+
+#include "SMESH_Mesh.hxx"
+#include "SMESH_Group.hxx"
+#include "hexa_base.hxx" // from HexaBlocks
+
+#ifndef _Standard_Real_HeaderFile
+#include <Standard_Real.hxx>
+#endif
+
+#include <gp_Pnt.hxx>
+#include <gp_Vec.hxx>
+#include <TopoDS_Face.hxx>
+#include "Handle_Geom_Curve.hxx"
+#include <BRepAdaptor_Curve.hxx>
+
+//=====================================================================
+// SMESH_HexaBlocks : class definition
+//=====================================================================
+class HEXABLOCKS_EXPORT SMESH_HexaBlocks
+{
+public:
+
+//   typedef std::vector<double>            Xx;
+  typedef std::vector<SMDS_MeshVolume*>  SMESHVolumes;
+  typedef std::vector<SMDS_MeshNode*>    SMESHNodes;
+  typedef std::vector<SMDS_MeshFace*>    SMESHFaces;
+  typedef std::vector<SMDS_MeshEdge*>    SMESHEdges;
+
+  typedef std::vector< SMESHNodes >      ArrayOfSMESHNodes;
+
+  struct Coord{
+    double x;
+    double y;
+    double z;
+  };
+
+
+   SMESH_HexaBlocks(SMESH_Mesh& theMesh);
+  ~SMESH_HexaBlocks();
+
+  // --------------------------------------------------------------
+  //  Vertex computing
+  // --------------------------------------------------------------
+  bool computeVertex( HEXA_NS::Vertex& vertex );
+  // Association solving
+  bool computeVertexByAssoc( HEXA_NS::Vertex& vertex );
+  // Automatic solving
+  bool computeVertexByModel( HEXA_NS::Vertex& vertex );
+
+
+  // --------------------------------------------------------------
+  //  Edge computing
+  // --------------------------------------------------------------
+  bool computeEdge( HEXA_NS::Edge& edge, HEXA_NS::Law& law);
+  // Association solving
+  bool computeEdgeByAssoc( HEXA_NS::Edge& edge, HEXA_NS::Law& law);
+  
+  // Automatic solving
+  bool computeEdgeByShortestWire( HEXA_NS::Edge& edge, HEXA_NS::Law& law);
+  bool computeEdgeByPlanWire( HEXA_NS::Edge& edge, HEXA_NS::Law& law);
+  bool computeEdgeByIsoWire( HEXA_NS::Edge& edge, HEXA_NS::Law& law);
+  bool computeEdgeBySegment( HEXA_NS::Edge& edge, HEXA_NS::Law& law);
+
+  // --------------------------------------------------------------
+  //  Quad computing
+  // --------------------------------------------------------------
+  std::map<HEXA_NS::Quad*, bool>  computeQuadWays( HEXA_NS::Document* doc );
+  bool computeQuad( HEXA_NS::Quad& quad, bool way );
+  // Association solving
+  bool computeQuadByAssoc( HEXA_NS::Quad& quad, bool way );
+  // Automatic solving
+  bool computeQuadByFindingGeom( HEXA_NS::Quad& quad, bool way );
+  bool computeQuadByLinearApproximation( HEXA_NS::Quad& quad, bool way );
+
+  // --------------------------------------------------------------
+  //  Hexa computing
+  // --------------------------------------------------------------
+  bool computeHexa( HEXA_NS::Document* doc );
+
+  // --------------------------------------------------------------
+  //  Document computing: Vertex, Edge, Quad and Hexa computing
+  // --------------------------------------------------------------
+  bool computeDoc( HEXA_NS::Document* doc );
+
+
+  // --------------------------------------------------------------
+  //  Build groups
+  // --------------------------------------------------------------
+  void buildGroups(HEXA_NS::Document* doc);
+
+
+private:
+  //    ********     METHOD FOR MESH COMPUTATION    ********
+  //  EDGE
+  double _Xx( double i, HEXA_NS::Law law, double nbNodes );
+
+  double _edgeLength(const TopoDS_Edge & E);
+
+  void _buildMyCurve(
+      const std::vector <HEXA_NS::Shape*>&     associations,   //IN
+      const gp_Pnt&                             myCurve_start,  //IN
+      const gp_Pnt&                            myCurve_end,    //IN
+      std::list< BRepAdaptor_Curve* >&                 myCurve,        //INOUT
+      double&                                  myCurve_length, //INOUT
+      std::map< BRepAdaptor_Curve*, double>&   myCurve_lengths,//INOUT
+      std::map< BRepAdaptor_Curve*, bool>&     myCurve_ways,   //INOUT
+      std::map< BRepAdaptor_Curve*, double>&    myCurve_starts,   //INOUT
+      HEXA_NS::Edge&                            edge);  // For diagnostic
+
+  gp_Pnt _getPtOnMyCurve( 
+      const double&                           myCurve_u,      //IN
+      std::map< BRepAdaptor_Curve*, bool>&    myCurve_ways,   //IN
+      std::map< BRepAdaptor_Curve*, double>&  myCurve_lengths,//IN
+      std::map< BRepAdaptor_Curve*, double>&  myCurve_starts, //IN
+      std::list< BRepAdaptor_Curve* >&        myCurve,        //INOUT
+      double&                                 myCurve_start); //INOUT
+
+  // QUAD
+  void _nodeInterpolationUV( double u, double v,
+    SMDS_MeshNode* Pg, SMDS_MeshNode* Pd, SMDS_MeshNode* Ph, SMDS_MeshNode* Pb,
+    SMDS_MeshNode* S0, SMDS_MeshNode* S1, SMDS_MeshNode* S2, SMDS_MeshNode* S3,
+    double& xOut, double& yOut, double& zOut );
+
+  TopoDS_Shape _getShapeOrCompound( const std::vector<HEXA_NS::Shape*>& shapesIn );
+
+  gp_Pnt _intersect( const gp_Pnt& Pt,
+                     const gp_Vec& u, const gp_Vec& v,
+                     const TopoDS_Shape& s,
+                     Standard_Real tol = 0.0001 );
+
+  bool _computeQuadInit(
+    HEXA_NS::Quad& quad,
+    ArrayOfSMESHNodes& nodesOnQuad,
+    std::vector<double>& xx, std::vector<double>& yy);
+
+  void _searchInitialQuadWay( HEXA_NS::Quad* quad, //IN
+                              HEXA_NS::Vertex*& v0,      //INOUT
+                              HEXA_NS::Vertex*& v1 );    //INOUT
+
+
+  //    ********     DATA FOR MESH COMPUTATION    ********
+  //    NODES
+  std::map<HEXA_NS::Vertex*, SMDS_MeshNode*>        _node;    //_vertexNode;
+  std::map<const SMDS_MeshNode*, HEXA_NS::Vertex*>  _vertex;  //_nodeVertex;
+
+  //    EDGES
+  std::map<HEXA_NS::Edge*, SMESHNodes>  _nodesOnEdge; //_edgeNodes;
+//   std::map<HEXA_NS::Edge*, Xx>                _edgeXx;
+  std::map<SMDS_MeshNode*, double>  _nodeXx; //_edgeNodes;
+  std::map<HEXA_NS::Quad*, ArrayOfSMESHNodes> _quadNodes;
+
+  bool _computeVertexOK;
+  bool _computeEdgeOK;
+  bool _computeQuadOK;
+
+  SMESHDS_Mesh* _theMeshDS;
+  SMESH_Mesh*   _theMesh;
+
+  //    ********     METHOD FOR GROUPS COMPUTATION    ********
+  SMESH_Group* _createGroup(HEXA_NS::Group& grHex);
+  void _fillGroup(HEXA_NS::Group* grHex);
+
+  //    ********     DATA FOR GROUPS COMPUTATION    ********
+  std::map<HEXA_NS::Hexa*, SMESHVolumes> _volumesOnHexa;
+  std::map<HEXA_NS::Quad*, SMESHFaces>   _facesOnQuad;
+  std::map<HEXA_NS::Edge*, SMESHEdges>   _edgesOnEdge;
+
+
+  // for DEBUG purpose only:
+  int _total;
+  int _found;
+  int _notFound;
+
+  // not used, for backup purpose only:
+  void _getCurve( const std::vector<HEXA_NS::Shape*>& shapesIn,
+                  Handle_Geom_Curve& curveOut, double& curveFirstOut, double& curveLastOut );
+//   bool computeEdgeByAssoc2( HEXA_NS::Edge& edge, HEXA_NS::Law& law); // alternative method
+};
+
+
+#endif
diff --git a/src/HEXABLOCKPlugin/Makefile.am b/src/HEXABLOCKPlugin/Makefile.am
new file mode 100755 (executable)
index 0000000..0b27622
--- /dev/null
@@ -0,0 +1,69 @@
+# Copyright (C) 2009-2012  CEA/DEN, EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+# -* Makefile *- 
+# Author : Lioka RAZAFINDRAZAKA (CEA)
+# Modified by : Alexander BORODIN (OCN) - autotools usage
+# Module : HEXABLOCKPLUGIN
+# Date : 2010/11/08
+#
+include $(top_srcdir)/adm_local/unix/make_common_starter.am
+
+# header files 
+salomeinclude_HEADERS = \
+       HEXABLOCKPlugin_Defs.hxx \
+       HEXABLOCKPlugin_HEXABLOCK.hxx \
+       HEXABLOCKPlugin_HEXABLOCK_i.hxx \
+       HEXABLOCKPlugin_Hypothesis.hxx \
+       HEXABLOCKPlugin_Hypothesis_i.hxx \
+       HEXABLOCKPlugin_mesh.hxx \
+       HEXABLOCKPlugin_FromSkin_3D.hxx
+
+# Libraries targets
+lib_LTLIBRARIES = libHexaBlockEngine.la
+
+dist_libHexaBlockEngine_la_SOURCES = \
+       HEXABLOCKPlugin_HEXABLOCK.cxx \
+       HEXABLOCKPlugin_HEXABLOCK_i.cxx \
+       HEXABLOCKPlugin_i.cxx \
+       HEXABLOCKPlugin_Hypothesis.cxx \
+       HEXABLOCKPlugin_Hypothesis_i.cxx \
+        HEXABLOCKPlugin_mesh.cxx \
+        HEXABLOCKPlugin_FromSkin_3D.cxx
+
+libHexaBlockEngine_la_CPPFLAGS =  \
+       $(KERNEL_CXXFLAGS)    \
+       $(CAS_CPPFLAGS)       \
+        $(VTK_INCLUDES)       \
+       $(GEOM_CXXFLAGS)      \
+       $(HEXABLOCK_CXXFLAGS) \
+       $(MED_CXXFLAGS)       \
+       $(SMESH_CXXFLAGS)     \
+       $(BOOST_CPPFLAGS)     \
+       $(CORBA_CXXFLAGS)     \
+       $(CORBA_INCLUDES)     \
+       -I$(top_builddir)/idl
+
+libHexaBlockEngine_la_LDFLAGS  = \
+       ../../idl/libSalomeIDLHEXABLOCKPLUGIN.la \
+       $(CAS_KERNEL) -lTKBRep -lTKG2d -lTKG3d -lTKTopAlgo -lTKGeomBase -lTKGeomAlgo \
+       $(HEXABLOCK_LDFLAGS) -lHEXABLOCKEngine \
+       $(MED_LDFLAGS) -lSalomeIDLMED \
+       $(SMESH_LDFLAGS) -lSMESHimpl -lSMESHEngine -lSMESHDS -lSMDS \
+       $(KERNEL_LDFLAGS) -lSalomeGenericObj -lSALOMELocalTrace -lSALOMEBasics
diff --git a/src/Makefile.am b/src/Makefile.am
new file mode 100755 (executable)
index 0000000..65fa269
--- /dev/null
@@ -0,0 +1,34 @@
+# Copyright (C) 2009-2012  CEA/DEN, EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+# -* Makefile *- 
+# Author : Lioka RAZAFINDRAZAKA (CEA)
+# Modified by : Alexander BORODIN (OCN) - autotools usage
+# Module : HEXABLOCKPLUGIN
+# Date : 2010/11/08
+#
+include $(top_srcdir)/adm_local/unix/make_common_starter.am
+
+SUBDIRS = HEXABLOCKPlugin
+
+if HEXABLOCKPLUGIN_ENABLE_GUI
+  SUBDIRS += GUI
+endif
+
+DIST_SUBDIRS = HEXABLOCKPlugin GUI