idl/VISU_Gen.idl

Go to the documentation of this file.

// Copyright (C) 2007-2011  CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// 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   : VISU_Gen.idl
//  Author : Alexey Petrov

#ifndef __VISU_GEN__
#define __VISU_GEN__

#include "SALOME_Exception.idl"
#include "SALOME_GenericObj.idl"
#include "SALOME_Component.idl"
#include "SALOMEDS.idl"
#include "SALOMEDS_Attributes.idl"
#include "MED.idl"

module VISU {
  //-------------------------------------------------------
  typedef string IdType;

  typedef sequence<string> string_array;
  typedef sequence<double> double_array;

  enum Scaling{ LINEAR, 
                LOGARITHMIC 
              };

  enum GaussMetric {
    AVERAGE, 
    MINIMUM, 
    MAXIMUM  
  };

  enum Entity {
    NODE, 
    EDGE, 
    FACE, 
    CELL, 
    NONE  
  };

  enum MarkerType {
    MT_NONE,
    MT_POINT,
    MT_PLUS,
    MT_STAR,
    MT_O,
    MT_X,
    MT_O_POINT,
    MT_O_PLUS,
    MT_O_STAR,
    MT_O_X,
    MT_USER,
    MT_POINT_SPRITE 
  };

  enum MarkerScale {
    MS_NONE,
    MS_10,
    MS_15,
    MS_20,
    MS_25,
    MS_30,
    MS_35,
    MS_40,
    MS_45,
    MS_50,
    MS_55,
    MS_60,
    MS_65,
    MS_70
  };

  enum SortOrder {
    AscendingOrder, 
    DescendingOrder 
  };

  enum SortPolicy {
    EmptyLowest,    
    EmptyHighest,   
    EmptyFirst,     
    EmptyLast,      
    EmptyIgnore     
  };

  enum VISUType {
    TNONE, 
    TCURVE, 
    TTABLE, 
    TCONTAINER, 
    TMESH, 
    TSCALARMAP, 
    TISOSURFACES, 
    TDEFORMEDSHAPE, 
    TSCALARMAPONDEFORMEDSHAPE, 
    TDEFORMEDSHAPEANDSCALARMAP, 
    TGAUSSPOINTS, 
    TPLOT3D, 
    TPOINTMAP3D, 
    TCUTPLANES, 
    TCUTLINES, 
    TCUTSEGMENT, 
    TVECTORS, 
    TSTREAMLINES, 
    TVISUGEN, 
    TVIEWMANAGER, 
    TRESULT, 
    TXYPLOT, 
    TTABLEVIEW, 
    TVIEW3D, 
    TGAUSSVIEW, 
    TENTITY, 
    TFAMILY, 
    TGROUP, 
    TFIELD, 
    TTIMESTAMP, 
    TANIMATION, 
    TEVOLUTION, 
    TCOLOREDPRS3DHOLDER, 
    TCOLOREDPRS3DCACHE, 
    TPART, 
    TALL
  };

  /* Clipping planes management */
  struct ClippingPlane {
    double X;
    double Y;
    double Z;
    double dX;
    double dY;
    double dZ;
    boolean isAuto;
    string name;
  };

  interface Base {
    IdType GetID();

    VISUType GetType();
  };

  interface RemovableObject : Base {
    void RemoveFromStudy();
  };

  interface PrsObject : RemovableObject {
  };

  //-------------------------------------------------------
  interface Curve : PrsObject {
    void SetTitle(in string theTitle);

    string GetTitle();

    void SetColor(in SALOMEDS::Color theColor);

    SALOMEDS::Color GetColor();

    enum MarkerType { NONE,
                      CIRCLE,
                      RECTANGLE,
                      DIAMOND,
                      DTRIANGLE,
                      UTRIANGLE,
                      LTRIANGLE,
                      RTRIANGLE,
                      CROSS,
                      XCROSS
    };

    void SetMarker(in MarkerType theType);

    MarkerType GetMarker();

    enum LineType{ VOIDLINE, SOLIDLINE, DASHLINE, DOTLINE, DASHDOTLINE, DASHDOTDOTLINE};

    void SetLine(in LineType theType, in long theLineWidth);

    LineType GetLine();

    long GetLineWidth();
  };

  //-------------------------------------------------------
  interface Container : PrsObject {
    void AddCurve(in Curve theCurve);

    void RemoveCurve(in Curve theCurve);

    long GetNbCurves();

    void Clear();
  };

  //-------------------------------------------------------
  interface Result;
  interface Prs3d : PrsObject, SALOME::GenericObj
  {
    void SetOffset(in float theDx, in float theDy, in float theDz);

    void GetOffset(out float theDx, out float theDy, out float theDz);

    void SetMarkerStd(in MarkerType theType, in MarkerScale theScale);

    void SetMarkerTexture(in long theTextureId);

    MarkerType GetMarkerType();

    MarkerScale GetMarkerScale();

    long GetMarkerTexture();

    float GetMemorySize();
  };

  enum PresentationType{ POINT,
                         WIREFRAME,
                         SHADED,
                         INSIDEFRAME,
                         SURFACEFRAME,
                         FEATURE_EDGES,
                         SHRINK
  };

  enum Quadratic2DPresentationType{
    LINES,
    ARCS
  };

  interface Mesh : Prs3d {
    void SetCellColor(in SALOMEDS::Color theColor);

    SALOMEDS::Color GetCellColor();

    void SetNodeColor(in SALOMEDS::Color theColor);

    SALOMEDS::Color GetNodeColor();

    void SetLinkColor(in SALOMEDS::Color theColor);

    SALOMEDS::Color GetLinkColor();

    void SetPresentationType(in PresentationType theType);

    PresentationType GetPresentationType();


    void SetQuadratic2DPresentationType(in Quadratic2DPresentationType theType);

    Quadratic2DPresentationType GetQuadratic2DPresentationType();

    void SetShrink(in boolean toShrink);

    boolean IsShrank();
  };


  //-------------------------------------------------------
  interface ColoredPrs3dBase : Prs3d
  {
    void SetRange(in double theMin, in double theMax);

    double GetMin();

    double GetMax();

    void SetSourceRange();

    double GetSourceMin();

    double GetSourceMax();

    boolean IsRangeFixed();

    void SetPosition(in double X, in double Y);

    double GetPosX();

    double GetPosY();

    void SetSize(in double theWidth, in double theHeight);

    double GetWidth();

    double GetHeight();

    void SetNbColors(in long theNbColors);

    long GetNbColors();
    void SetLabels(in long theNbLabels);

    long GetLabels();

    enum Orientation {
      HORIZONTAL, 
      VERTICAL    
    };

    void SetBarOrientation(in Orientation theOrientation);

    Orientation GetBarOrientation();
  };

  interface ColoredPrs3d : ColoredPrs3dBase
  {
    void SetTitle(in string theName);

    string GetTitle();

    void SetScalarMode(in long theScalarMode);

    long GetScalarMode();

    void SetIsDistributionVisible(in boolean theIs);

    boolean GetIsDistributionVisible();

    boolean IsScalarFilterUsed();

    void UseScalarFiltering( in boolean theUseScalarFilter );

    void SetScalarFilterRange( in double theMin, in double theMax );

    double GetScalarFilterMin();

    double GetScalarFilterMax();

    void AddMeshOnGroup(in string theGroupName);

    void RemoveAllGeom();
  };


  //-------------------------------------------------------
  interface View3D;
  interface ColoredPrs3dCache;


  //-------------------------------------------------------
  interface ColoredPrs3dHolder : PrsObject, SALOME::GenericObj
  {
    struct BasicInput
    {
      Result myResult;
      string myMeshName;
      Entity myEntity;
      string myFieldName;
      long myTimeStampNumber;
    };

    boolean Apply(in ColoredPrs3d thePrs3d,
                  in BasicInput theInput,
                  in View3D theView3D);

    ColoredPrs3d GetDevice();

    VISUType GetPrsType();

    struct TimeStampInfo
    {
      string myTime;
      long myNumber;
    };

    typedef sequence<TimeStampInfo> TimeStampsRange;

    TimeStampsRange GetTimeStampsRange();

    BasicInput GetBasicInput();

    ColoredPrs3dCache GetCache();

    float GetMemorySize();
  };


  //-------------------------------------------------------
  interface ColoredPrs3dCache : RemovableObject, SALOME::GenericObj
  {
    enum MemoryMode {
      MINIMAL, 
      LIMITED  
    };

    enum EnlargeType {
      NO_ENLARGE, 
      ENLARGE,    
      IMPOSSIBLE  
    };

    void SetMemoryMode(in MemoryMode theMode);

    MemoryMode GetMemoryMode();

    void SetLimitedMemory(in float theMemorySize);

    float GetLimitedMemory();

    float GetMemorySize();

    ColoredPrs3dHolder CreateHolder(in VISUType theType,
                                    in ColoredPrs3dHolder::BasicInput theInput);

    EnlargeType GetRequiredMemory(in VISUType theType,
                                  in ColoredPrs3dHolder::BasicInput theInput,
                                  out float theRequiredMemory);
  };


  //-------------------------------------------------------
  interface ScaledPrs3d {
    void SetScaling(in Scaling theScaling);

    Scaling GetScaling();
  };

  interface ScalarMap : ColoredPrs3d, ScaledPrs3d {

    boolean IsBarVisible();

    void SetBarVisible(in boolean theVisible);

    void SetGaussMetric(in GaussMetric theGaussMetric);

    GaussMetric GetGaussMetric();

    void SetLinkColor(in SALOMEDS::Color theColor);

    SALOMEDS::Color GetLinkColor();
  };

  //-------------------------------------------------------
  //-------------------------------------------------------
  interface GaussPoints : ColoredPrs3d
  {
    void SetIsActiveLocalScalarBar(in boolean theFlag);

    boolean GetIsActiveLocalScalarBar();

    void SetIsDispGlobalScalarBar(in boolean theFlag);

    boolean GetIsDispGlobalScalarBar();

    void SetSpacing(in double theSpacing);

    double GetSpacing();

    boolean IsBarVisible();

    void SetBarVisible(in boolean theVisible);

    void SetIsColored(in boolean theIsColored);

    boolean GetIsColored();

    void SetColor(in SALOMEDS::Color theColor);

    void SetBiColor(in boolean theIsBiColor);

    boolean GetBiColor();

    boolean GetIsDeformed();

    void SetIsDeformed(in boolean theIsDeformed);

    void SetScaleFactor(in double theScaleFactor);

    double GetScaleFactor();

    enum PrimitiveType {
      SPRITE,
      POINT,
      SPHERE
    };

    void SetPrimitiveType(in PrimitiveType thePrimitiveType);

    PrimitiveType GetPrimitiveType();

    void SetClamp(in double theClamp);

    double GetClamp();

    void SetMinSize(in double theMinSize);

    double GetMinSize();

    void SetMaxSize(in double theMaxSize);

    double GetMaxSize();

    void SetMagnification(in double theMagnification);

    double GetMagnification();

    void SetMagnificationIncrement(in double theIncrement);

    double GetMagnificationIncrement();

    void SetGeomSize(in double theGeomSize);

    double GetGeomSize();

    string GetMainTexture();

    string GetAlphaTexture();

    void SetTextures(in string theMainTexture, in string theAlphaTexture);

    void SetAlphaThreshold(in double theAlphaThreshold);

    double GetAlphaThreshold();

    void SetResolution(in long theResolution);

    long GetResolution();

    void SetFaceLimit(in long theFaceLimit);

    long GetFaceLimit();


  };


  interface MonoColorPrs : ScalarMap {

    boolean IsColored();

    void ShowColored(in boolean theColored);

    SALOMEDS::Color GetColor();

    void SetColor(in SALOMEDS::Color theColor);
  };


  interface DeformedShape : MonoColorPrs
  {
    void SetScale(in double theScale);

    double GetScale();

  };

  //-------------------------------------------------------
  interface Deformation{
    void SetScale(in double theScale);

    double GetScale();

    void SetVectorialField(in Entity theEntity,
                           in string theFieldName);

    Entity GetVectorialFieldEntity();

    string GetVectorialFieldName();

  };

  //-------------------------------------------------------
  interface OptionalDeformation : Deformation{

    void UseDeformation(in boolean theFlag);

    boolean IsDeformed();
  };

  //-------------------------------------------------------
  interface DeformedShapeAndScalarMap : ScalarMap {

    void SetScale(in double theScale);

    double GetScale();

    void SetScalarField(in Entity theEntity,
                        in string theFieldName,
                        in long theTimeStampNumber);


    Entity GetScalarEntity();

    string GetScalarFieldName();

    long GetScalarTimeStampNumber();
  };


  //-------------------------------------------------------
  interface Plot3dBase {
    void SetScaleFactor (in double theScaleFactor);

    double GetScaleFactor();

    void SetContourPrs (in boolean theIsContourPrs );

    boolean GetIsContourPrs();

    void SetNbOfContours (in long theNb);

    long GetNbOfContours();
  };

  interface Plot3D : ScalarMap, Plot3dBase {
    enum Orientation { XY,   
                       YZ,   
                       ZX }; 
    void SetOrientation (in Orientation theOrientation, in double theXAngle, in double theYAngle);

    Orientation GetOrientationType();

    double GetRotateX();

    double GetRotateY();

    void SetPlanePosition (in double  thePlanePosition,
                           in boolean theIsRelative);

    double GetPlanePosition();

    boolean IsPositionRelative();
  };

 //-------------------------------------------------------
  interface Table : PrsObject {
    void SetTitle(in string theTitle);

    string GetTitle();

    enum Orientation {
      HORIZONTAL, 
      VERTIACAL   
    };

    void SetOrientation(in Orientation theOrientation);

    Orientation GetOrientation();

    long GetNbRows();

    long GetNbColumns();

    void SortRow(in long theRow, in SortOrder theSortOrder, in SortPolicy theSortPolicy);

    void SortColumn(in long theColumn, in SortOrder theSortOrder, in SortPolicy theSortPolicy);

    void SortByRow(in long theRow, in SortOrder theSortOrder, in SortPolicy theSortPolicy);

    void SortByColumn(in long theColumn, in SortOrder theSortOrder, in SortPolicy theSortPolicy);
  };

  //-------------------------------------------------------
  interface PointMap3d : ColoredPrs3dBase, ScaledPrs3d, Plot3dBase, Table {
  };

  //-------------------------------------------------------
  interface CutPlanes : ScalarMap, OptionalDeformation {
    enum Orientation {XY, 
                      YZ, 
                      ZX}; 
    void SetOrientation(in Orientation theOrientation, in double theXAngle, in double theYAngle);

    Orientation GetOrientationType();

    double GetRotateX();

    double GetRotateY();

    void SetDisplacement(in double theDisp);

    double GetDisplacement();

     void SetPlanePosition(in long thePlaneNumber, in double thePlanePosition);

     void SetDefault(in long thePlaneNumber);

    double GetPlanePosition(in long thePlaneNumber);

    boolean IsDefault(in long thePlaneNumber);

    void SetNbPlanes(in long theNb);

    long GetNbPlanes();
  };

  //-------------------------------------------------------
  interface CutLinesBase : ScalarMap {
    void SetNbLines(in long theNb);

    long GetNbLines();

    void SetAllCurvesInverted(in boolean theInvert);

    boolean IsAllCurvesInverted();

    void SetUseAbsoluteLength(in boolean theAbsLength);

    boolean IsUseAbsoluteLength();
  };

  //-------------------------------------------------------
  interface CutLines : CutLinesBase {
    void SetOrientation(in CutPlanes::Orientation theOrientation, in double theXAngle, in double theYAngle);

    void SetOrientation2(in CutPlanes::Orientation theOrientation, in double theXAngle, in double theYAngle);

    CutPlanes::Orientation GetOrientationType();

    CutPlanes::Orientation GetOrientationType2();

    double GetRotateX();

    double GetRotateX2();

    double GetRotateY();

    double GetRotateY2();

    void SetDisplacement(in double theDisp);

    void SetDisplacement2(in double theDisp);

    double GetDisplacement();

    double GetDisplacement2();

    void SetBasePlanePosition(in double thePlanePosition);

    double GetBasePlanePosition();

    void SetLinePosition(in long thePlaneNumber, in double thePlanePosition);

    double GetLinePosition(in long thePlaneNumber);

    void SetDefault();

    boolean IsDefault();

    void SetDefaultPosition(in long thePlaneNumber);

    boolean IsDefaultPosition(in long thePlaneNumber);
  };

  //-------------------------------------------------------
  interface CutSegment : CutLinesBase {
    void SetPoint1(in double theX, in double theY, in double theZ);

    void GetPoint1(out double theX, out double theY, out double theZ);

    void SetPoint2(in double theX, in double theY, in double theZ);

    void GetPoint2(out double theX, out double theY, out double theZ);
  };

  interface StreamLines : MonoColorPrs {
    enum Direction{ FORWARD,
                    BACKWARD,
                    BOTH
    };

    boolean SetParams(in double theIntStep,
                      in double thePropogationTime,
                      in double theStepLength,
                      in Prs3d thePrs3d,
                      in double thePercents,
                      in Direction theDirection);

    double GetIntegrationStep();

    double GetPropagationTime();

    double GetStepLength();

    Prs3d GetSource();

    double GetUsedPoints();

    Direction GetDirection();
  };

  interface IsoSurfaces : MonoColorPrs {
    void SetNbSurfaces(in long theNb);

    long GetNbSurfaces();

    boolean IsLabeled();

    void ShowLabels(in boolean theShow, in long theNb);

   long GetNbLabels();

  };

  //-------------------------------------------------------
  interface Vectors : DeformedShape {
    void SetLineWidth(in double theWidth);

    double GetLineWidth();

    enum GlyphType{ ARROW,
                    CONE2,
                    CONE6,
                    NONE
                  };

    void SetGlyphType(in GlyphType theType);

    GlyphType GetGlyphType();

    enum GlyphPos{ CENTER, 
                   TAIL,   
                   HEAD  
                 };

    void SetGlyphPos(in GlyphPos thePos);

    GlyphPos GetGlyphPos();
  };

  //-------------------------------------------------------
  interface Animation : Base
  {
    enum AnimationMode{ PARALLEL, 
                        SUCCESSIVE 
    };

    boolean addField(in SALOMEDS::SObject theObject);

    void clearFields();

    void generatePresentations(in long theFieldNum);

    boolean generateFrames();

    void clearView();


    void startAnimation();

    void stopAnimation();

    void nextFrame();

    void prevFrame();

    void firstFrame();

    void lastFrame();

    void gotoFrame(in long theFrame);
    long getNbFields();

    long getNbFrames();

    boolean isRunning();

    long getCurrentFrame();

    ColoredPrs3d getPresentation(in long theField, in long theFrame);

    void setPresentationType(in long theFieldNum, in VISUType theType);

    VISUType getPresentationType(in long theFieldNum);

    void setSpeed(in long theSpeed);

    long getSpeed();

    boolean isProportional();

    void setAnimationRange(in double theMin, in double theMax);

    double getMinRange();

    double getMaxRange();

    boolean isRangeDefined();

    void setAnimationSequence(in string theSequence);

    string getAnimationSequence();

    boolean isSequenceDefined();

    void dumpTo(in string thePath);

    string setDumpFormat(in string theFormat);

    void setTimeStampFrequency(in long theFrequency);

    long getTimeStampFrequency();

    boolean isCycling();

    double getMinTime();

    double getMaxTime();

    void setProportional(in boolean theProp);

    void setCycling(in boolean theCycle);

    boolean isCleaningMemoryAtEachFrame();
    void setCleaningMemoryAtEachFrame(in boolean theCycle);

    SALOMEDS::SObject publishInStudy();

    void saveAnimation();

    void restoreFromStudy(in SALOMEDS::SObject theSObj);

    boolean isSavedInStudy();

    void setAnimationMode(in AnimationMode theMode);

    AnimationMode getAnimationMode();

    void ApplyProperties(in long theFieldNum, in ColoredPrs3d thePrs)
      raises (SALOME::SALOME_Exception);
  };


  //-------------------------------------------------------
  interface XYPlot;

  //-------------------------------------------------------
  interface Evolution : Base
  {
    boolean setField(in SALOMEDS::SObject theObject);

    void setPointId(in long thePointId);

    void setComponentId(in long theComponentId);

    boolean showEvolution();

    void restoreFromStudy(in SALOMEDS::SObject theSObj);
  };


  interface Result : RemovableObject, SALOME::GenericObj
  {
    boolean BuildAll();

    boolean Build(in boolean theIsBuildAll, in boolean theIsAtOnce);

    boolean IsDone();

    boolean IsEntitiesDone();

    void SetBuildFields(in boolean theIsBuildFields, in boolean theIsCalculateMinMax);

    boolean IsFieldsDone();

    void SetBuildGroups(in boolean theIsBuildGroups);

    boolean IsGroupsDone();

    boolean IsMinMaxDone();

    boolean IsPartsDone();

    typedef sequence<Entity> Entities;

    typedef string EntityName;

    typedef sequence<EntityName> EntityNames;

    typedef long TimeStampNumber;

    typedef sequence<TimeStampNumber> TimeStampNumbers;

    enum Resolution {
      FULL,
      MEDIUM,
      LOW,
      HIDDEN
    };

    typedef sequence<Resolution> Resolutions;

    EntityNames GetMeshNames();

    Entities GetEntities(in EntityName theMeshName);

    EntityNames GetFamilies(in EntityName theMeshName, in Entity theEntity);

    EntityNames GetGroups(in EntityName theMeshName);

    EntityNames GetFields(in EntityName theMeshName, in Entity theEntity);

    long GetNumberOfComponents(in EntityName theMeshName, in Entity theEntity, in EntityName theFieldName);

    TimeStampNumbers GetTimeStampNumbers(in EntityName theMeshName, in Entity theEntity,
                                         in EntityName theFieldName);

    double_array GetTimeStampValues(in EntityName theMeshName, in Entity theEntity, in EntityName theFieldName);

    EntityNames GetPartNames(in EntityName theMeshName);

    Resolutions GetResolutions(in EntityName theMeshName, in EntityName thePartName);

    Resolution GetResolution(in EntityName theMeshName, in EntityName thePartName);

    void SetResolution(in EntityName theMeshName, in EntityName thePartName, in Resolution theResolution);

    SALOME_MED::MedFileInfo GetMEDFileInfo();

    boolean ExportMED(in string theFileName);
  };

  //-------------------------------------------------------
  interface ViewManager;

  interface VISU_Gen : Engines::EngineComponent, SALOMEDS::Driver, Base
  {
    void SetCurrentStudy(in SALOMEDS::Study theStudy);

    SALOMEDS::Study GetCurrentStudy();

    ViewManager GetViewManager();

    SALOMEDS::SObject ImportTables(in string theFileName,
                                   in boolean theFirstStrAsTitle);

    boolean ExportTableToFile(in SALOMEDS::SObject theTable, in string theFileName);

    Result ImportFile(in string theFileName);

    Result CreateResult(in string theFileName);

    Result CopyAndImportFile(in string theFileName);

    Result ImportMed(in SALOMEDS::SObject theMedSObject);

    Result ImportMedField(in SALOME_MED::FIELD theField);

    void RenameEntityInStudy(in Result theResult,
                             in string theMeshName,
                             in Entity theEntity,
                             in string theNewName);
    void RenameFamilyInStudy(in Result theResult,
                             in string theMeshName,
                             in Entity theEntity,
                             in string theSubMeshName,
                             in string theNewName);
    void RenameGroupInStudy(in Result theResult,
                            in string theMeshName,
                            in string theSubMeshName,
                            in string theNewName);

    Mesh MeshOnEntity(in Result theResult, in string theMeshName, in Entity theEntity);

    Mesh FamilyMeshOnEntity(in Result theResult, in string theMeshName,
                            in Entity theEntity, in string theFamilyName);

    Mesh GroupMesh(in Result theResult, in string theMeshName, in string theGroupName);

    ScalarMap ScalarMapOnField(in Result theResult, in string theMeshName,
                               in Entity theEntity, in string theFieldName,
                               in long theTimeStampNumber);

    GaussPoints GaussPointsOnField(in Result theResult, in string theMeshName,
                                   in Entity theEntity, in string theFieldName,
                                   in long theTimeStampNumber);

    DeformedShape DeformedShapeOnField(in Result theResult, in string theMeshName,
                                       in Entity theEntity, in string theFieldName,
                                       in long theTimeStampNumber);

    DeformedShapeAndScalarMap ScalarMapOnDeformedShapeOnField(in Result theResult, in string theMeshName,
                                                              in Entity theEntity, in string theFieldName,
                                                              in long theTimeStampNumber);

    DeformedShapeAndScalarMap DeformedShapeAndScalarMapOnField(in Result theResult, in string theMeshName,
                                                               in Entity theEntity, in string theFieldName,
                                                               in long theTimeStampNumber);

    Vectors VectorsOnField(in Result theResult, in string theMeshName,
                           in Entity theEntity, in string theFieldName,
                           in long theTimeStampNumber);

    IsoSurfaces IsoSurfacesOnField(in Result theResult, in string theMeshName,
                                   in Entity theEntity, in string theFieldName,
                                   in long theTimeStampNumber);

    StreamLines StreamLinesOnField(in Result theResult, in string theMeshName,
                                   in Entity theEntity, in string theFieldName,
                                   in long theTimeStampNumber);

    CutPlanes CutPlanesOnField(in Result theResult, in string theMeshName,
                               in Entity theEntity, in string theFieldName,
                               in long theTimeStampNumber);

    CutLines CutLinesOnField(in Result theResult, in string theMeshName,
                             in Entity theEntity, in string theFieldName,
                             in long theTimeStampNumber);

    CutSegment CutSegmentOnField(in Result theResult, in string theMeshName,
                                 in Entity theEntity, in string theFieldName,
                                 in long theTimeStampNumber);

    Plot3D Plot3DOnField(in Result theResult, in string theMeshName,
                         in Entity theEntity, in string theFieldName,
                         in long theTimeStampNumber);

    Table CreateTable(in string theTableEntry);

    Curve CreateCurve(in Table theTable, in long theHRow, in long theVRow);

    Curve CreateCurveWithZ( in Table theTable, in long theHRow, in long theVRow, in long theZRow );

    Curve CreateCurveWithZExt( in Table theTable, in long theHRow, in long theVRow, in long theZRow,
                               in boolean theIsV2 );

    Container CreateContainer();

    Animation CreateAnimation(in View3D theView3d);

    Evolution CreateEvolution(in XYPlot theXYPlot);

    void DeleteResult(in Result theResult);

    void DeletePrs3d(in Prs3d thePrs3d);

    ColoredPrs3dCache GetColoredPrs3dCache(in SALOMEDS::Study theStudy);


    /* Clipping planes management */

    /*Create a clipping plane and return its ID (position in corresponded array)
      Id of clipping plane could be changed after deletion of other clipping plane
    */
    long CreateClippingPlane(in double X, in double Y, in double Z,
                             in double dX, in double dY, in double dZ,
                             in boolean auto, in string name);

    void EditClippingPlane(in long id, in double X, in double Y, in double Z,
                             in double dX, in double dY, in double dZ,
                             in boolean auto, in string name);

    /* Returns clipping plane by its Id */
    ClippingPlane GetClippingPlane(in long id);

    /* Deletes clipping plane by its Id */
    boolean DeleteClippingPlane(in long id);

    /* Applyes a clipping plane with Id to presentation thePrs */
    boolean ApplyClippingPlane(in Prs3d thePrs, in long id);

    /* Detaches a clipping plane with Id from presentation thePrs */
    boolean DetachClippingPlane(in Prs3d thePrs, in long id);


    /* Get number of clipping planes */
    long GetClippingPlanesNb();

    boolean VTK2MED( in string_array theVTKFiles,
                     in string theMEDFile,
                     in string theMeshName,
                     in double_array theTStamps );

    long LoadTexture(in string theTextureFile);
  };

  interface View: Base, SALOME::GenericObj
  {
    enum ViewRepresentation {
      OBJECTBROWSER,
      VIEWER,
      PYTHON,
      MESSAGES
    };

    void ShowPart (in ViewRepresentation ViewRepr, in boolean state );

    boolean IsPartShown( in ViewRepresentation ViewRepr );

    void SplitRight();

    void SplitLeft();

    void SplitBottom();

    void SplitTop();

    void OnTop();

    void Attract (in View theView);

    void AttractAll (in View theView);

    void SetRelativePositionInSplitter (in double thePosition);

    void SetRelativeSizeInSplitter (in double theSize);

    void SetRelativePositionX (in double thePosition);

    void SetRelativePositionY (in double thePosition);

    void SetRelativeSizeX (in double theSize);

    void SetRelativeSizeY (in double theSize);

    void SetViewWidth (in long Width); //setting width of view
    void SetViewHeight (in long Height); //setting height of view
    long GetViewWidth(); //getting view width
    long GetViewHeight(); //getting view height
    enum ViewPosition {TOP, CENTER, BOTTOM, RIGHT, LEFT}; //position of the study frame
    void SetViewPositionHorizontal (in ViewPosition ViewPosHor); //setting of the horizontal view position
    void SetViewPositionVertical (in ViewPosition ViewPosVer); //setting of the vertical view position
    void SetRelativePosition( in double x, in double y );
    void SetRelativeSize( in double x, in double y );
    void Minimize(); // Minimizes to the task bar or to the bottom of the Desktop the %View frame.
    void Restore(); // Restores the %View frame.
    void Maximize(); // Maximizes the %View frame.

    void SetTitle(in string theTitle);

    string GetTitle();

    void SetBackground(in SALOMEDS::Color theColor);

    SALOMEDS::Color GetBackground();

    void EraseAll();

    void DisplayAll();

    void Erase(in PrsObject thePrsObj);

    void Display(in PrsObject thePrsObj);

    void DisplayOnly(in PrsObject thePrsObj);

    void Update();

    boolean SavePicture(in string theFileName);
  };

  //-------------------------------------------------------
  interface View3D : View {
    enum ViewType{ FRONT, BACK, LEFT, RIGHT, TOP, BOTTOM};

    enum Axis{ XAxis, YAxis, ZAxis};

    typedef double XYZ[3];

    void FitAll();

    void SetView(in ViewType theType);

    void SetPointOfView(in XYZ theCoord);

    XYZ GetPointOfView();

    void SetViewUp(in XYZ theDir);

    XYZ GetViewUp();

    void SetFocalPoint(in XYZ theDir);

    XYZ GetFocalPoint();

    void SetParallelScale(in double theScale);

    double GetParallelScale();

    void ScaleView(in Axis theAxis, in double theParam);

    void RemoveScale();

    boolean SaveViewParams(in string theName);

    boolean RestoreViewParams(in string theName);


    PresentationType GetPresentationType(in ScalarMap thePrs);

    string SetPresentationType(in ScalarMap thePrs, in PresentationType thePrsType);


    string SetQuadratic2DPresentationType(in ScalarMap thePrs,in Quadratic2DPresentationType theType);


    Quadratic2DPresentationType GetQuadratic2DPresentationType(in ScalarMap thePrs);


    boolean IsShrinked(in ScalarMap thePrs);

    string SetShrinked(in ScalarMap thePrs, in boolean isShrinked);

    boolean IsShaded(in ScalarMap thePrs);

    string SetShaded(in ScalarMap thePrs, in boolean isShaded);

    double GetOpacity(in ScalarMap thePrs);

    string SetOpacity(in ScalarMap thePrs, in double theOpacity);

    double GetLineWidth(in ScalarMap thePrs);

    string SetLineWidth(in ScalarMap thePrs, in double theLineWidth);
  };

  //-------------------------------------------------------
  interface TableView : View {
  };

  //-------------------------------------------------------
  interface XYPlot : View {
    void SetSubTitle(in string theTitle);

    string GetSubTitle();

    enum CurveType { POINTS, MULTYLINE, SPLINE};

    void SetCurveType(in CurveType theType);

    CurveType GetCurveType();

    void SetMarkerSize(in long theSize);

    long GetMarkerSize();

    void EnableXGrid(in boolean theMajor, in long theNumMajor, in boolean theMinor, in long theNumMinor);

    void EnableYGrid(in boolean theMajor, in long theNumMajor, in boolean theMinor, in long theNumMinor);

    void SetHorScaling(in Scaling theScaling);

    Scaling GetHorScaling();

    void SetVerScaling(in Scaling theScaling);

    Scaling GetVerScaling();

    void SetXTitle(in string theTitle);

    string GetXTitle();

    void SetYTitle(in string theTitle);

    string GetYTitle();

    void ShowLegend(in boolean theShowing);

    void FitAll();

    void FitXRange(in double xMin, in double xMax);

    void FitYRange(in double yMin, in double yMax);

    void FitRange(in double xMin, in double xMax,
                  in double yMin, in double yMax);

    void GetFitRanges(out double xMin,out double xMax,
                      out double yMin,out double yMax);
  };

  //-------------------------------------------------------
  interface ViewManager: Base {
    View GetCurrentView();

    View3D Create3DView();

    TableView CreateTableView(in Table theTable);

    XYPlot CreateXYPlot();

    void Destroy(in View theView);
  };


};

#endif