-// Copyright (C) 2003 CEA/DEN, EDF R&D
+// VISU OBJECT : interactive object for VISU entities implementation
//
+// Copyright (C) 2003 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
// File : VISU_Table_i.cc
// Author : Vadim SANDLER
// Module : VISU
-using namespace std;
#include "VISU_Table_i.hh"
#include "QAD_Application.h"
#include "QAD_Desktop.h"
#include "QAD_Study.h"
+
+#include "VISU_CutLines_i.hh"
+
+#include <memory>
#include <fstream>
#include <strstream>
+
#include <qfileinfo.h>
-#include <qstringlist.h>
-#include <memory>
+#include <qfile.h>
+
+using namespace std;
-#ifdef DEBUG
-static int MYDEBUG = 1;
+#ifdef _DEBUG_
+static int MYDEBUG = 0;
#else
static int MYDEBUG = 0;
#endif
-
//----------------------------------------------------------------
// Table Object
//----------------------------------------------------------------
VISU::Table_i::Table_i( SALOMEDS::Study_ptr theStudy, const char* theObjectEntry )
: PrsObject_i(theStudy)
{
- myObjectEntry = theObjectEntry;
+ mySObj = SALOMEDS::SObject::_duplicate((theStudy->FindObjectID(theObjectEntry)));
myOrientation = VISU::Table::HORIZONTAL;
}
/*!
*/
VISU::Table_i::~Table_i()
{
+ MESSAGE("Table_i::~Table_i");
}
/*!
Gets number of rows in table
*/
CORBA::Long VISU::Table_i::GetNbRows()
{
- SALOMEDS::SObject_var SO = myStudy->FindObjectID( myObjectEntry.c_str() );
+ SALOMEDS::SObject_var SO = mySObj;
SALOMEDS::StudyBuilder_var Builder = myStudy->NewBuilder();
if ( !SO->_is_nil() ) {
SALOMEDS::GenericAttribute_var anAttr;
if ( Builder->FindAttribute( SO, anAttr, "AttributeTableOfInteger" ) ) {
SALOMEDS::AttributeTableOfInteger_var anInt = SALOMEDS::AttributeTableOfInteger::_narrow( anAttr );
- return anInt->GetNbRows();
+ return anInt->GetNbRows();
}
else if ( Builder->FindAttribute( SO, anAttr, "AttributeTableOfReal" ) ) {
SALOMEDS::AttributeTableOfReal_var aReal = SALOMEDS::AttributeTableOfReal::_narrow( anAttr );
*/
CORBA::Long VISU::Table_i::GetNbColumns()
{
- SALOMEDS::SObject_var SO = myStudy->FindObjectID( myObjectEntry.c_str() );
+ SALOMEDS::SObject_var SO = mySObj;
SALOMEDS::StudyBuilder_var Builder = myStudy->NewBuilder();
if ( !SO->_is_nil() ) {
SALOMEDS::GenericAttribute_var anAttr;
{
// generate name ...
myName = GetTableTitle();
+
+ // mpv (PAL 5357): if name attribute already exist at this label, use it as name of table
+ if ( myName == "" )
+ if ( !mySObj->_is_nil() ) {
+ CutLines_i* pCutLines = NULL;
+ CORBA::Object_var anObj = SObjectToObject(mySObj);
+ if(!CORBA::is_nil(anObj)){
+ VISU::CutLines_var aCutLines = VISU::CutLines::_narrow(anObj);
+ if(!aCutLines->_is_nil())
+ pCutLines = dynamic_cast<CutLines_i*>(GetServant(aCutLines).in());
+ }
+ if (!pCutLines)
+ if (mySObj->GetName()) myName = mySObj->GetName();
+ }
+
if ( myName == "" )
myName = GenerateName();
// ... and build the object
*/
VISU::Storable* VISU::Table_i::Build( int theRestoring )
{
+
// look for reference SObject with table attribute
- SALOMEDS::SObject_var SO = myStudy->FindObjectID( myObjectEntry.c_str() );
+ SALOMEDS::SObject_var SO = mySObj;
+
if ( !SO->_is_nil() ) {
CutLines_i* pCutLines = NULL;
CORBA::Object_var anObj = SObjectToObject(SO);
if(!CORBA::is_nil(anObj)){
VISU::CutLines_var aCutLines = VISU::CutLines::_narrow(anObj);
if(!aCutLines->_is_nil())
- pCutLines = dynamic_cast<CutLines_i*>(GetServant(aCutLines));
+ pCutLines = dynamic_cast<CutLines_i*>(GetServant(aCutLines).in());
}
SALOMEDS::StudyBuilder_var Builder = myStudy->NewBuilder();
SALOMEDS::GenericAttribute_var anAttr;
- if ( Builder->FindAttribute( SO, anAttr, "AttributeTableOfInteger" ) ||
- Builder->FindAttribute( SO, anAttr, "AttributeTableOfReal" ) || pCutLines) {
- // look for component
- if ( !theRestoring ) {
+ // look for component
+ if ( !theRestoring ) {
SALOMEDS::SComponent_var SComponent = VISU::FindOrCreateVisuComponent( myStudy );
// create SObject and set attributes
QString aComment;
aComment.sprintf("myComment=%s;myType=%d",GetComment(),VISU::TTABLE);
string anEntry = CreateAttributes( myStudy,
- SComponent->GetID(),
- "",
- GetID(),
- GetName(),
- "",
- aComment.latin1(),
- true );
+ SO->GetID(),//SComponent->GetID(),
+ "",
+ GetID(),
+ GetName(),
+ "",
+ aComment.latin1(),
+ pCutLines );
// create SObject referenced to real table object
- SALOMEDS::SObject_var newSO = myStudy->FindObjectID( anEntry.c_str() );
+ mySObj = SALOMEDS::SObject::_duplicate(myStudy->FindObjectID( anEntry.c_str() ));
if(pCutLines) {
- pCutLines->BuildTableOfReal(newSO);
- myObjectEntry = anEntry;
+ pCutLines->BuildTableOfReal(mySObj);
}
- SALOMEDS::SObject_var refSO = Builder->NewObject( newSO );
- Builder->Addreference( refSO, SO );
+ // mpv (PAL5357): reference attributes are unnecessary now
+ //SALOMEDS::SObject_var refSO = Builder->NewObject( mySObj );
+ //Builder->Addreference( refSO, SO );
}
- return this;
- }
+ return this;
}
return NULL;
}
/*!
Restores table object from stream
*/
-VISU::Storable* VISU::Table_i::Restore( const Storable::TRestoringMap& theMap )
- throw( std::logic_error& )
+VISU::Storable* VISU::Table_i::Restore( const Storable::TRestoringMap& theMap, SALOMEDS::SObject_ptr SO)
{
if(MYDEBUG) MESSAGE(GetComment());
myName = (const char*)(VISU::Storable::FindValue(theMap,"myName"));
- myObjectEntry = (const char *)(VISU::Storable::FindValue(theMap,"myObjectEntry"));
myTitle = (const char*)(VISU::Storable::FindValue(theMap,"myTitle"));
myOrientation = ( VISU::Table::Orientation )( VISU::Storable::FindValue(theMap,"myOrientation").toInt() );
+ mySObj = SALOMEDS::SObject::_duplicate(SO);
return Build( true );
}
/*!
void VISU::Table_i::ToStream( std::ostringstream& theStr )
{
Storable::DataToStream( theStr, "myName", myName.c_str() );
- Storable::DataToStream( theStr, "myObjectEntry", myObjectEntry.c_str() );
Storable::DataToStream( theStr, "myTitle", myTitle.c_str() );
Storable::DataToStream( theStr, "myOrientation", myOrientation );
}
/*!
Called from engine to restore table from the file
*/
-VISU::Storable* VISU::TableRestore(SALOMEDS::SObject_ptr theSObject,
- const string& thePrefix, const Storable::TRestoringMap& theMap)
+VISU::Storable* VISU::Table_i::Restore(SALOMEDS::SObject_ptr theSObject,
+ const string& thePrefix, const Storable::TRestoringMap& theMap)
{
SALOMEDS::Study_var aStudy = theSObject->GetStudy();
VISU::Table_i* pResent = new VISU::Table_i( aStudy, "" );
- return pResent->Restore( theMap );
+ return pResent->Restore( theMap, theSObject);
}
/*!
Gets title for the original table object
*/
const char* VISU::Table_i::GetTableTitle()
{
- SALOMEDS::SObject_var SO = myStudy->FindObjectID( GetObjectEntry() );
+ SALOMEDS::SObject_var SO = mySObj;
SALOMEDS::StudyBuilder_var Builder = myStudy->NewBuilder();
SALOMEDS::GenericAttribute_var anAttr;
SALOMEDS::AttributeTableOfInteger_var anInt;
/*!
Restores table object from the stream [ static ]
*/
-static VISU::Table_i* GetTable( SALOMEDS::Study_var& theStudy, const VISU::Storable::TRestoringMap& theMap ) {
- string anEntry = VISU::Storable::FindValue( theMap, "TableID" ).latin1();
- SALOMEDS::SObject_var aSObject = theStudy->FindObjectID( anEntry.c_str() );
- CORBA::Object_var anObject = VISU::SObjectToObject( aSObject );
+static VISU::Table_i* GetTable( SALOMEDS::Study_ptr theStudy, SALOMEDS::SObject_ptr theSO ) {
+ CORBA::Object_var anObject = VISU::SObjectToObject( theSO );
if( !CORBA::is_nil( anObject ) ) {
CORBA::Object_ptr aTable = VISU::Table::_narrow( anObject );
if( !CORBA::is_nil( aTable ) )
- return dynamic_cast<VISU::Table_i*>( VISU::GetServant( aTable ) );
+ return dynamic_cast<VISU::Table_i*>(VISU::GetServant(aTable).in());
}
return NULL;
}
*/
VISU::Curve_i::~Curve_i()
{
+ MESSAGE("Curve_i::~Curve_i");
}
/*!
Creates curve object
/*!
Builds presentation of curve
*/
-VISU::Storable* VISU::Curve_i::Build( int theRestoring )
+VISU::Storable* VISU::Curve_i::Build(int theRestoring )
{
if ( myTable != NULL ) {
// getting table SObject by it's entry
- SALOMEDS::SObject_var SO = myStudy->FindObjectID( myTable->GetEntry() );
int nbRows = myTable->GetNbRows();
- if ( !SO->_is_nil() && myHRow > 0 && myHRow <= nbRows && myVRow > 0 && myVRow <= nbRows ) {
+ if ( myHRow > 0 && myHRow <= nbRows && myVRow > 0 && myVRow <= nbRows ) {
if ( !theRestoring ) {
// look for component
SALOMEDS::SComponent_var SComponent = VISU::FindOrCreateVisuComponent( myStudy );
QString aComment;
aComment.sprintf("myComment=%s;myType=%d",GetComment(),VISU::TCURVE);
string anEntry = CreateAttributes( myStudy,
- myTable->GetEntry(),
- "",
- GetID(),
- GetName(),
- "",
- aComment.latin1(),
- true );
+ myTable->GetObjectEntry(),
+ "",
+ GetID(),
+ GetName(),
+ "",
+ aComment.latin1(),
+ true );
+ // create SObject referenced to real table object
+ mySObj = SALOMEDS::SObject::_duplicate(myStudy->FindObjectID(anEntry.c_str()));
}
return this;
}
CORBA::Boolean VISU::Curve_i::IsValid()
{
// getting table SObject by it's entry
- SALOMEDS::SObject_var SO = myStudy->FindObjectID( myTable->GetObjectEntry() );
+ SALOMEDS::SObject_var SO = myStudy->FindObjectID(myTable->GetObjectEntry());
SALOMEDS::StudyBuilder_var Builder = myStudy->NewBuilder();
SALOMEDS::GenericAttribute_var anAttr;
SALOMEDS::AttributeTableOfInteger_var anInt;
{
string title;
// getting table SObject by it's entry
- SALOMEDS::SObject_var SO = myStudy->FindObjectID( myTable->GetObjectEntry() );
+ SALOMEDS::SObject_var SO = myStudy->FindObjectID(myTable->GetObjectEntry());
SALOMEDS::StudyBuilder_var Builder = myStudy->NewBuilder();
SALOMEDS::GenericAttribute_var anAttr;
SALOMEDS::AttributeTableOfInteger_var anInt;
{
string title;
// getting table SObject by it's entry
- SALOMEDS::SObject_var SO = myStudy->FindObjectID( myTable->GetObjectEntry() );
+ SALOMEDS::SObject_var SO = myStudy->FindObjectID(myTable->GetObjectEntry());
SALOMEDS::StudyBuilder_var Builder = myStudy->NewBuilder();
SALOMEDS::GenericAttribute_var anAttr;
SALOMEDS::AttributeTableOfInteger_var anInt;
{
string units;
// getting table SObject by it's entry
- SALOMEDS::SObject_var SO = myStudy->FindObjectID( myTable->GetObjectEntry() );
+ SALOMEDS::SObject_var SO = myStudy->FindObjectID(myTable->GetObjectEntry());
SALOMEDS::StudyBuilder_var Builder = myStudy->NewBuilder();
SALOMEDS::GenericAttribute_var anAttr;
SALOMEDS::AttributeTableOfInteger_var anInt;
{
string units;
// getting table SObject by it's entry
- SALOMEDS::SObject_var SO = myStudy->FindObjectID( myTable->GetObjectEntry() );
+ SALOMEDS::SObject_var SO = myStudy->FindObjectID(myTable->GetObjectEntry());
SALOMEDS::StudyBuilder_var Builder = myStudy->NewBuilder();
SALOMEDS::GenericAttribute_var anAttr;
SALOMEDS::AttributeTableOfInteger_var anInt;
{
theHorList = 0; theVerList = 0;
// getting table SObject by it's entry
- SALOMEDS::SObject_var SO = myStudy->FindObjectID( myTable->GetObjectEntry() );
+ SALOMEDS::SObject_var SO = myStudy->FindObjectID(myTable->GetObjectEntry());
SALOMEDS::StudyBuilder_var Builder = myStudy->NewBuilder();
SALOMEDS::GenericAttribute_var anAttr;
SALOMEDS::AttributeTableOfInteger_var anInt;
SALOMEDS::Color color = GetColor();
crv->setColor( QColor( (int)(color.R*255.), (int)(color.G*255.), (int)(color.B*255.) ) );
crv->setAutoAssign( IsAuto() );
- crv->setIO(new SALOME_InteractiveObject(strdup(GetEntry()),"VISU",strdup(GetName())));
+ crv->setIO(new SALOME_InteractiveObject(strdup(mySObj->GetID()),"VISU",strdup(GetName())));
if ( myTable )
- crv->setTableIO(new SALOME_InteractiveObject(strdup(myTable->GetEntry()),"VISU",strdup(myTable->GetName())));
+ crv->setTableIO(new SALOME_InteractiveObject(strdup(myTable->GetObjectEntry()),"VISU",strdup(myTable->GetName())));
return crv;
}
/*!
Restores curve object from stream
*/
-VISU::Storable* VISU::Curve_i::Restore( const Storable::TRestoringMap& theMap )
- throw( std::logic_error& )
+VISU::Storable* VISU::Curve_i::Restore( const Storable::TRestoringMap& theMap, SALOMEDS::SObject_ptr theSO)
{
if(MYDEBUG) MESSAGE(GetComment());
- myName = (const char*)(VISU::Storable::FindValue(theMap,"myName"));
+ mySObj = SALOMEDS::SObject::_duplicate(theSO);
+ myName = VISU::Storable::FindValue(theMap,"myName").latin1();
myHRow = VISU::Storable::FindValue(theMap,"myHRow").toInt();
myVRow = VISU::Storable::FindValue(theMap,"myVRow").toInt();
myColor.R = VISU::Storable::FindValue(theMap,"myColor.R").toDouble();
myColor.B = VISU::Storable::FindValue(theMap,"myColor.B").toDouble();
myMarker = ( VISU::Curve::MarkerType )( VISU::Storable::FindValue(theMap,"myMarker").toInt() );
myLine = ( VISU::Curve::LineType )( VISU::Storable::FindValue(theMap,"myLine").toInt() );
+ myLineWidth = VISU::Storable::FindValue(theMap,"myLineWidth").toInt();
+ myAuto = VISU::Storable::FindValue(theMap,"myAuto").toInt();
return Build( true );
}
/*!
*/
void VISU::Curve_i::ToStream( std::ostringstream& theStr )
{
- Storable::DataToStream( theStr, "TableID", GetTableID());
- Storable::DataToStream( theStr, "myName", myName.c_str() );
- Storable::DataToStream( theStr, "myHRow", myHRow );
- Storable::DataToStream( theStr, "myVRow", myVRow );
- Storable::DataToStream( theStr, "myColor.R", myColor.R );
- Storable::DataToStream( theStr, "myColor.G", myColor.G );
- Storable::DataToStream( theStr, "myColor.B", myColor.B );
- Storable::DataToStream( theStr, "myMarker", myMarker );
- Storable::DataToStream( theStr, "myLine", myLine );
+ Storable::DataToStream( theStr, "myName", myName.c_str() );
+ Storable::DataToStream( theStr, "myHRow", myHRow );
+ Storable::DataToStream( theStr, "myVRow", myVRow );
+ Storable::DataToStream( theStr, "myColor.R", myColor.R );
+ Storable::DataToStream( theStr, "myColor.G", myColor.G );
+ Storable::DataToStream( theStr, "myColor.B", myColor.B );
+ Storable::DataToStream( theStr, "myMarker", myMarker );
+ Storable::DataToStream( theStr, "myLine", myLine );
+ Storable::DataToStream( theStr, "myLineWidth", myLineWidth );
+ Storable::DataToStream( theStr, "myAuto", myAuto );
}
/*!
Gets reference table's entry
*/
const char* VISU::Curve_i::GetTableID() {
- return CORBA::string_dup(myTable->GetEntry());
+ return CORBA::string_dup(myTable->GetObjectEntry());
}
/*!
Called from engine to restore curve from the file
*/
-VISU::Storable* VISU::CurveRestore(SALOMEDS::SObject_ptr theSObject,
- const string& thePrefix, const Storable::TRestoringMap& theMap)
+VISU::Storable* VISU::Curve_i::Restore(SALOMEDS::SObject_ptr theSObject,
+ const string& thePrefix, const Storable::TRestoringMap& theMap)
{
SALOMEDS::Study_var aStudy = theSObject->GetStudy();
- VISU::Table_i* pTable = GetTable( aStudy, theMap );
+ VISU::Table_i* pTable = GetTable(aStudy, theSObject->GetFather());
if( pTable != NULL ) {
VISU::Curve_i* pResent = new VISU::Curve_i( aStudy, pTable, 0, 0 );
- return pResent->Restore( theMap );
+ return pResent->Restore( theMap, theSObject);
}
return NULL;
}
*/
const char* VISU::Container_i::GenerateName()
{
- return VISU::GenerateName( "Container", ++myNbPresent );
+ return VISU::GenerateName( "Plot2DView", ++myNbPresent );
}
/*!
Gets comment string
*/
VISU::Container_i::~Container_i()
{
+ MESSAGE("Container_i::~Container_i");
myCurves.clear();
}
/*!
*/
CORBA::Long VISU::Container_i::GetNbCurves()
{
+ Update();
return myCurves.count();
}
/*!
// if real Curve Object exists
CORBA::Object_ptr aCurve = VISU::Curve::_narrow( anObject );
if( !CORBA::is_nil( aCurve ) )
- return dynamic_cast<VISU::Curve_i*>(VISU::GetServant( aCurve ) );
+ return dynamic_cast<VISU::Curve_i*>(VISU::GetServant(aCurve).in());
}
}
return NULL;
Restores container data from the stream
*/
VISU::Storable* VISU::Container_i::Restore( const Storable::TRestoringMap& theMap )
- throw( std::logic_error& )
{
if(MYDEBUG) MESSAGE(GetComment());
- myName = (const char*)(VISU::Storable::FindValue( theMap, "myName" ));
+ myName = VISU::Storable::FindValue( theMap, "myName" ).latin1();
QString val = VISU::Storable::FindValue( theMap, "myCurves" );
myCurves = QStringList::split( QString( "*" ), val, false );
return Build( true );
/*!
Called from engine to restore container from the file
*/
-VISU::Storable* VISU::ContainerRestore(SALOMEDS::SObject_ptr theSObject,
- const string& thePrefix, const Storable::TRestoringMap& theMap)
+VISU::Storable* VISU::Container_i::Restore(SALOMEDS::SObject_ptr theSObject,
+ const string& thePrefix, const Storable::TRestoringMap& theMap)
{
SALOMEDS::Study_var aStudy = theSObject->GetStudy();
VISU::Container_i* pResent = new VISU::Container_i( aStudy );
//-------------------------------------------------------------
// Implementation of reading from file
//-------------------------------------------------------------
-typedef vector<float> TValues;
+typedef double TValue;
+typedef vector<TValue> TValues;
struct TRow{
string myTitle;
typedef vector<TRow> TRows;
-struct TTable2D{
+struct TTable2D {
string myTitle;
vector<string> myColumnUnits;
vector<string> myColumnTitles;
if(myColumnUnits.size() != iEnd) myColumnUnits.resize(iEnd);
int jEnd = myRows.size();
for(int j = 0; j < jEnd; j++)
- if(myRows[j].myValues.size() != iEnd) return 0;
+ if(myRows[j].myValues.size() != iEnd)
+ return 0;
return 1;
}
void getColumns(TTable2D& theTable2D) const {
if(tmp == '\n') break;
}
aStrOut<<ends;
- auto_ptr<char> aRet(aStrOut.str());
- theString = aRet.get();
+ theString = aStrOut.str();
return !theStmIn.eof();
}
void ImportTables(const char* theFileName, TTableCont& theTableCont){
+ static int STRPRECISION = 12;
ifstream aStmIn;
QFileInfo aFileInfo(theFileName);
if(!aFileInfo.isFile() || !aFileInfo.isReadable() || !aFileInfo.size()) return;
do{
//Find beginning of Table
while(getLine(aStmIn,aTmp) && aTmp == "\n");
- //cout<<"\n There is new Table2D with Title = ";
+ if(MYDEBUG) cout<<"\n There is new Table2D with Title = ";
TTable2D aTable2D;
while(!aStmIn.eof() && aTmp != "\n"){
if(aTmp.find("#TITLE:") == 0){
int aLen = aTmp.find(":") + 1;
aTmp.remove(0,aLen);
QString aTitle = aTmp.stripWhiteSpace();
- aTable2D.myTitle = (const char*)aTitle;
+ aTable2D.myTitle = aTitle.latin1();
+
if(MYDEBUG) cout<<aTitle<<endl;
}else if(aTmp.find("#COLUMN_TITLES:") == 0){
int aLen = aTmp.find(":") + 1;
aTmp.remove(0,aLen);
QStringList aStrList = QStringList::split("|",aTmp);
- //cout<<"Its Column Titles : ";
+ if(MYDEBUG) cout<<"Its Column Titles : ";
for(int i = 0; i < aStrList.count(); i++){
aTmp = aStrList[i].stripWhiteSpace();
aTable2D.myColumnTitles.push_back(aTmp.latin1());
+
if(MYDEBUG) cout<<"\t"<<aTmp;
}
- //cout<<endl;
+ if(MYDEBUG) cout<<endl;
}else if(aTmp.find("#COLUMN_UNITS:") == 0){
int aLen = aTmp.find(":") + 1;
aTmp.remove(0,aLen);
QStringList aStrList = QStringList::split(" ",aTmp);
- //cout<<"Its Column Units : ";
+ if(MYDEBUG) cout<<"Its Column Units : ";
for(int i = 0; i < aStrList.count(); i++){
aTmp = aStrList[i].stripWhiteSpace();
aTable2D.myColumnUnits.push_back(aTmp.latin1());
+
if(MYDEBUG) cout<<"\t"<<aTmp;
}
- //cout<<endl;
+ if(MYDEBUG) cout<<endl;
}else if(aTmp.find("#") == 0){
//It is a comment
}else if(aTmp.find("#TITLE:") > 0){
QStringList aStrList = QStringList::split("#TITLE:",aTmp);
QString aTitle = aStrList[1].stripWhiteSpace();
TRow aRow;
- aRow.myTitle = (const char*)aTitle;
+ aRow.myTitle = aTitle.latin1();
+
if(MYDEBUG) cout<<aTitle<<" : ";
QStringList aValList = QStringList::split(" ",aStrList[0]);
for(int i = 0; i < aValList.count(); i++){
float aVal = aValList[i].toFloat();
aRow.myValues.push_back(aVal);
+
if(MYDEBUG) cout<<"\t"<<aVal;
}
aTable2D.myRows.push_back(aRow);
- //cout<<endl;
+ if(MYDEBUG) cout<<endl;
}else{
- QStringList aValList = QStringList::split(" ",aTmp);
- TRow aRow;
- for(int i = 0; i < aValList.count(); i++){
- float aVal = aValList[i].toFloat();
+ TRow aRow;
+ TValue aVal;
+ istrstream aStream(aTmp);
+ aStream.precision(STRPRECISION);
+ while(aStream>>aVal){
aRow.myValues.push_back(aVal);
+
if(MYDEBUG) cout<<"\t"<<aVal;
}
- aTable2D.myRows.push_back(aRow);
- //cout<<endl;
+ if(aRow.myValues.size() > 0)
+ aTable2D.myRows.push_back(aRow);
+ if(MYDEBUG) cout<<endl;
}
getLine(aStmIn,aTmp);
}
if(aTable2D.Check()){
-
//cout<<"aTable2D checked "<<aTable2D.myTitle<<endl;
+
if(MYDEBUG) cout<<"aTable2D checked "<<aTable2D.myTitle<<endl;
theTableCont.push_back(aTable2D);
}
}while(!aStmIn.eof());
aStmIn.close();
- //cout<<"After close"<<endl;
+ if(MYDEBUG) cout<<"After close"<<endl;
}
SALOMEDS::SObject_var VISU::ImportTables(const char* theFileName, SALOMEDS::Study_ptr theStudy){
QFileInfo aFileInfo(theFileName);
aName->SetValue(aFileInfo.fileName().latin1());
int iEnd = aTableCont.size();
- /*
- for(int i = 0, iEnd = aTableCont.size(); i < iEnd; i++){
- const TTable2D& aTable2D = aTableCont[i];
- SALOMEDS::SObject_var aRealObject = aStudyBuilder->NewObject(aFileObject);
- anAttr = aStudyBuilder->FindOrCreateAttribute(aRealObject, "AttributeName");
- aName = SALOMEDS::AttributeName::_narrow(anAttr);
- cout<<"aTable2D.myTitle = "<<aTable2D.myTitle<<endl;
- if(aTable2D.myTitle != "")
- aName->SetValue(aTable2D.myTitle.c_str());
- else{
- QString aNewName;
- aNewName.sprintf("Table:%d",i);
- aName->SetValue(aNewName.latin1());
- }
- anAttr = aStudyBuilder->FindOrCreateAttribute(aRealObject, "AttributeTableOfReal");
- SALOMEDS::AttributeTableOfReal_var aTableOfReal = SALOMEDS::AttributeTableOfReal::_narrow(anAttr);
- aTableOfReal->SetTitle(aTable2D.myTitle.c_str());
- const TRows& aRows = aTable2D.myRows;
- //aTable2D.getColumns(aRows);
- int kEnd = aRows[0].myValues.size();
- aTableOfReal->SetNbColumns(kEnd);
- for(int j = 0, jEnd = aRows.size(); j < jEnd; j++){
- cout<<"j = "<<j<<endl;
- const TRow& aRow = aRows[j];
- SALOMEDS::DoubleSeq_var aDoubleSeq = new SALOMEDS::DoubleSeq();
- int kEnd = aRow.myValues.size();
- aDoubleSeq->length(kEnd);
- cout<<"kEnd = "<<kEnd<<endl;
- for(int k = 0; k < kEnd; k++) aDoubleSeq[k] = aRow.myValues[k];
- aTableOfReal->AddRow(aDoubleSeq.in());
- aTableOfReal->SetRowTitle(j+1,aRow.myTitle.c_str());
- aTableOfReal->SetRowUnit(j+1,aRow.myUnit.c_str());
- }
- for(int k = 0; k < kEnd; k++){
- aTableOfReal->SetColumnTitle(k+1,aTable2D.myColumnTitles[k].c_str());
- //aTableOfReal->SetColumnUnit(k+1,aTable2D.myColumnUnits[k].c_str());
- }
- }
- */
for(int i = 0, iEnd = aTableCont.size(); i < iEnd; i++){
const TTable2D& aTable2D = aTableCont[i];
SALOMEDS::SObject_var aRealObject = aStudyBuilder->NewObject(aFileObject);
anAttr = aStudyBuilder->FindOrCreateAttribute(aRealObject, "AttributeName");
aName = SALOMEDS::AttributeName::_narrow(anAttr);
-
//cout<<"aTable2D.myTitle = "<<aTable2D.myTitle<<endl;
+
if(MYDEBUG) cout<<"aTable2D.myTitle = "<<aTable2D.myTitle<<endl;
if(aTable2D.myTitle != "")
aName->SetValue(aTable2D.myTitle.c_str());
else{
int kEnd = aNewTable2D.myRows[0].myValues.size();
aTableOfReal->SetNbColumns(kEnd);
for(int j = 0, jEnd = aNewTable2D.myRows.size(); j < jEnd; j++){
- //cout<<"j = "<<j<<endl;
+ if(MYDEBUG) cout<<"j = "<<j<<endl;
SALOMEDS::DoubleSeq_var aDoubleSeq = new SALOMEDS::DoubleSeq();
aDoubleSeq->length(kEnd);
- //cout<<"kEnd = "<<kEnd<<endl;
+ if(MYDEBUG) cout<<"kEnd = "<<kEnd<<endl;
for(int k = 0; k < kEnd; k++) aDoubleSeq[k] = aNewTable2D.myRows[j].myValues[k];
aTableOfReal->AddRow(aDoubleSeq.in());
aTableOfReal->SetRowTitle(j+1,aNewTable2D.myRows[j].myTitle.c_str());
aTableOfReal->SetRowUnit(j+1,aNewTable2D.myRows[j].myUnit.c_str());
}
- for(int k = 0; k < kEnd; k++){
+ for(int k = 0; k < kEnd; k++)
aTableOfReal->SetColumnTitle(k+1,aNewTable2D.myColumnTitles[k].c_str());
- //aTableOfReal->SetColumnUnit(k+1,aTable2D.myColumnUnits[k].c_str());
- }
}
return aFileObject;
}
+
+template<class TTableAttr> bool ExportTableToFile(const TTableAttr& aTabAttr,
+ const char* theFileName)
+{
+ if (!CORBA::is_nil(aTabAttr)) {
+ QFile aFile(theFileName);
+ aFile.open(IO_WriteOnly);
+
+ /* extract the tabe info and write it into file */
+
+ QString aTitle(aTabAttr->GetTitle()); /*Table title*/
+ int aRowsNb = aTabAttr->GetNbRows();
+ int aColNb = aTabAttr->GetNbColumns();
+
+ SALOMEDS::StringSeq_var aRowTitles = aTabAttr->GetRowTitles();
+ QString anAbscissTitle(aRowTitles[0]); /*Absciss row title (X coord)*/
+ anAbscissTitle.stripWhiteSpace();
+
+ SALOMEDS::StringSeq_var aRowUnits = aTabAttr->GetRowUnits();
+ QString anAbscissUnit(aRowUnits[0]);
+ anAbscissUnit.stripWhiteSpace();
+
+ SALOMEDS::StringSeq_var aColumnTitles = aTabAttr->GetColumnTitles();
+ if (aRowsNb > 2 && aTitle.length() ) aTitle = aTitle + " - ";
+
+ QString aLine;
+ for (int i = 2; i <= aRowsNb; i++ )
+ {
+ /* TITLE */
+ QString anOrdinate(aRowTitles[i-1]), aTail;
+ anOrdinate.stripWhiteSpace();
+
+ aLine = "#TITLE: " + aTitle +
+ ((anOrdinate.length())? anOrdinate :
+ (aRowsNb>2)? aTail.sprintf("%d",i-1) : aTail.sprintf("") ) + "\n";
+ aFile.writeBlock(aLine, aLine.length() );
+
+ /* COLUMN_TITLES */
+ if ( anAbscissTitle.length() || anOrdinate.length() ) {
+ aLine = "#COLUMN_TITLES: " + anAbscissTitle + " | " + anOrdinate + "\n";
+ aFile.writeBlock(aLine, aLine.length() );
+ }
+
+ /* COLUMN_UNITS */
+ aLine = anAbscissUnit + " " +aRowUnits[i-1];
+ if (!aLine.stripWhiteSpace().isEmpty()) {
+ aLine = "#COLUMN_UNITS: " + aLine + "\n";
+ aFile.writeBlock(aLine, aLine.length() );
+ }
+
+ /* CURVE COORDINATES */
+ for (int j = 1; j <= aColNb; j++)
+ {
+ if ( aTabAttr -> HasValue(i,j) && aTabAttr -> HasValue(1, j)) {
+ aLine = aLine.sprintf("%.16g %.16g",
+ (double)(aTabAttr->GetValue(1,j)),
+ (double)(aTabAttr->GetValue(i,j))); /* aTabAttr->GetValue(1,j) - X coord */
+ if ( !aLine.stripWhiteSpace().isEmpty() ) {
+ QString aColTitle(aColumnTitles[j-1]);
+ if ( !aColTitle.stripWhiteSpace().isEmpty() )
+ aLine = aLine + " #TITLE: " + aColTitle ;
+ aFile.writeBlock(aLine + "\n", aLine.length() + 1);
+ }
+ }
+ }
+ aFile.writeBlock("\n", 1);
+ }
+ aFile.close();
+ return true;
+ }
+ return false;
+}
+
+bool VISU::ExportTableToFile(SALOMEDS::SObject_ptr theTable, const char* theFileName)
+{
+ //Find table
+ SALOMEDS::GenericAttribute_var anAttr ;
+ if (theTable->FindAttribute(anAttr, "AttributeTableOfReal"))
+ {
+ SALOMEDS::AttributeTableOfReal_var aTabAttr = SALOMEDS::AttributeTableOfReal ::_narrow(anAttr);
+ return ExportTableToFile ( aTabAttr , theFileName);
+
+ }
+ else if (theTable->FindAttribute(anAttr, "AttributeTableOfInteger")) {
+
+ SALOMEDS::AttributeTableOfInteger_var aTabAttr = SALOMEDS::AttributeTableOfInteger ::_narrow(anAttr);
+ return ExportTableToFile ( aTabAttr , theFileName);
+
+ }
+ return false;
+}
