void PropertyValuesDispatcher::afterSetEdgeValue(tlp::PropertyInterface *sourceProp, const tlp::edge e) {
if (_modifying)
return;
_modifying = true;
if (sourceProp->getGraph()->getRoot() == _source->getRoot()) {
PropertyInterface *targetProp = _target->getProperty(sourceProp->getName());
std::string strVal = sourceProp->getEdgeStringValue(e);
vector<int> vect = _graphEntitiesToDisplayedNodes->getEdgeValue(e);
for(vector<int>::iterator it = vect.begin(); it != vect.end(); ++it)
targetProp->setNodeStringValue(node(*it), strVal);
edge ee = _edgesMap[e];
// corresponding edge may not exist if e
// has been added after the build of the MatrixView
if (ee.isValid())
targetProp->setEdgeStringValue(_edgesMap[e], sourceProp->getEdgeStringValue(e));
}
else if (sourceProp->getGraph()->getRoot() == _target->getRoot()) {
PropertyInterface *targetProp = _source->getProperty(sourceProp->getName());
unsigned int id = _displayedEdgesToGraphEdges->getEdgeValue(e);
std::string strVal = sourceProp->getEdgeStringValue(e);
targetProp->setEdgeStringValue(edge(id), strVal);
vector<int> vect = _graphEntitiesToDisplayedNodes->getEdgeValue(edge(id));
for(vector<int>::iterator it = vect.begin(); it != vect.end(); ++it)
sourceProp->setNodeStringValue(node(*it), strVal);
}
_modifying = false;
}
//=================================================
void PropertyDialog::toStringProperty() {
if (editedProperty == NULL)
return;
string name = editedPropertyName;
if (name == "viewLabel")
return;
Observable::holdObservers();
// allow to undo
graph->push();
PropertyInterface *newLabels = graph->getProperty(name);
StringProperty *labels = graph->getLocalProperty<StringProperty> ("viewLabel");
if (tabWidget->currentIndex() == 0) {
Iterator<node> *itN;
if (_filterSelection)
itN = graph->getProperty<BooleanProperty> ("viewSelection")-> getNonDefaultValuatedNodes();
else {
labels->setAllNodeValue(newLabels->getNodeDefaultStringValue());
itN = graph->getNodes();
}
while (itN->hasNext()) {
node itn = itN->next();
labels->setNodeValue(itn, newLabels->getNodeStringValue(itn));
}
delete itN;
}
else {
Iterator<edge> *itE;
if (_filterSelection)
itE = graph->getProperty<BooleanProperty> ("viewSelection")-> getNonDefaultValuatedEdges();
else {
labels->setAllEdgeValue(newLabels->getEdgeDefaultStringValue());
itE = graph->getEdges();
}
while (itE->hasNext()) {
edge ite = itE->next();
labels->setEdgeValue(ite, newLabels->getEdgeStringValue(ite));
}
delete itE;
}
Observable::unholdObservers();
}
void PropertyValuesDispatcher::afterSetAllEdgeValue(tlp::PropertyInterface *sourceProp) {
if (sourceProp->getGraph()->getRoot() == _source->getRoot()) {
PropertyInterface *targetProp = _target->getProperty(sourceProp->getName());
string val = sourceProp->getEdgeDefaultStringValue();
node n;
forEach(n, _displayedNodesAreNodes->getNodesEqualTo(false))
targetProp->setNodeStringValue(n, val);
}
else if (sourceProp->getGraph()->getRoot() == _target->getRoot()) {
PropertyInterface *targetProp = _source->getProperty(sourceProp->getName());
targetProp->setAllEdgeStringValue(sourceProp->getNodeDefaultStringValue());
}
}
//==========================================
void ElementPropertiesWidget::propertyTableValueChanged(int row, int col) {
if (col == 0)
return;
// cerr << __PRETTY_FUNCTION__ << endl;
QString property = propertyTable->item(row, 0)->text();
QString value = ((TulipTableWidgetItem *)propertyTable->item(row, col))->textForTulip();
PropertyInterface *editedProperty = graph->getProperty(property.toUtf8().data());
if (editedProperty==NULL) return;
//cerr << "Value :" << value.toUtf8().data() << endl;
bool result=true;
switch(displayMode) {
case NODE:
// allow to undo
graph->push();
result=editedProperty->setNodeStringValue(currentNode, value.toUtf8().data());
break;
case EDGE:
// allow to undo
graph->push();
result=editedProperty->setEdgeStringValue(currentEdge, value.toUtf8().data());
break;
}
if (!result) {
QMessageBox::critical( 0, "Tulip Property Editor Change Failed",
QString("The value entered for this property is not correct,\n"
"The change won't be applied\n"
"Modify the entered value to apply the changes.")
);
}
else {
switch(displayMode) {
case NODE:
emit tulipNodePropertyChanged(graph, currentNode, property, value);
break;
case EDGE:
emit tulipEdgePropertyChanged(graph, currentEdge, property, value);
break;
}
}
//}
}
//=================================================
void PropertyDialog::newProperty() {
if (!graph)
return;
Observable::holdObservers();
PropertyInterface* property = PropertyCreationDialog::createNewProperty(graph,this);
if(property) {
setGraph(graph);
emit newPropertySignal(graph, property->getName());
}
Observable::unholdObservers();
}
void PropertyValuesDispatcher::afterSetNodeValue(tlp::PropertyInterface *sourceProp, const tlp::node n) {
if (_modifying)
return;
_modifying = true;
if (sourceProp->getGraph()->getRoot() == _source->getRoot()) {
PropertyInterface *targetProp = _target->getProperty(sourceProp->getName());
std::string strVal = sourceProp->getNodeStringValue(n);
vector<int> vect = _graphEntitiesToDisplayedNodes->getNodeValue(n);
for(vector<int>::iterator it = vect.begin(); it != vect.end(); ++it)
targetProp->setNodeStringValue(node(*it), strVal);
}
else if (sourceProp->getGraph()->getRoot() == _target->getRoot()) {
PropertyInterface *targetProp = _source->getProperty(sourceProp->getName());
unsigned int id = _displayedNodesToGraphEntities->getNodeValue(n);
if (_displayedNodesAreNodes->getNodeValue(n)) {
targetProp->setNodeStringValue(node(id), sourceProp->getNodeStringValue(n));
// update the other node
vector<int> vect = _graphEntitiesToDisplayedNodes->getNodeValue(node(id));
for(vector<int>::iterator it = vect.begin(); it != vect.end(); ++it) {
node n1(*it);
if (n1 != n)
sourceProp->setNodeStringValue(n1, sourceProp->getNodeStringValue(n));
}
}
else {
targetProp->setEdgeStringValue(edge(id), sourceProp->getNodeStringValue(n));
sourceProp->setEdgeStringValue(_edgesMap[edge(id)], sourceProp->getNodeStringValue(n));
vector<int> vect = _graphEntitiesToDisplayedNodes->getEdgeValue(edge(id));
for(vector<int>::iterator it = vect.begin(); it != vect.end(); ++it) {
node n1(*it);
if (n1 != n)
sourceProp->setNodeStringValue(n1, sourceProp->getNodeStringValue(n));
}
}
}
_modifying = false;
}
void PropertyValuesDispatcher::addLocalProperty(tlp::Graph *g, const std::string &name) {
if ((g == _source && _sourceToTargetProperties.find(name) != _sourceToTargetProperties.end()) ||
(g == _target && _targetToSourceProperties.find(name) != _targetToSourceProperties.end())) {
Observable::holdObservers();
PropertyInterface *sourceProp = g->getProperty(name);
afterSetAllNodeValue(sourceProp);
afterSetAllEdgeValue(sourceProp);
node n;
forEach(n, sourceProp->getNonDefaultValuatedNodes())
afterSetNodeValue(sourceProp,n);
edge e;
forEach(e, sourceProp->getNonDefaultValuatedEdges())
afterSetEdgeValue(sourceProp, e);
Observable::unholdObservers();
sourceProp->addListener(this);
}
}
void SetPorperty(PropertyInterface& comp, Property& property)
{
typedef std::map<std::string, std::string> PropertyMap;
PropertyMap& propertyMap = property.GetProperty();
for (PropertyMap::const_iterator itor = propertyMap.begin()
; itor != propertyMap.end(); ++itor)
{
comp.setProperty(itor->first, itor->second);
}
}
//================================================================================
bool TLPBImport::importGraph() {
std::string filename;
std::istream* is = NULL;
if (dataSet->exist("file::filename")) {
dataSet->get<std::string>("file::filename", filename);
struct stat infoEntry;
bool result = (stat(filename.c_str(),&infoEntry) == 0);
if (!result) {
std::stringstream ess;
ess << filename.c_str() << ": " << strerror(errno);
pluginProgress->setError(ess.str());
tlp::error() << pluginProgress->getError() << std::endl;
return errorTrap();
}
if (filename.rfind(".gz") == (filename.length() - 3)) {
is = tlp::getIgzstream(filename);
}
else
is = tlp::getInputFileStream(filename, std::ifstream::in |
std::ifstream::binary);
}
else {
pluginProgress->setError("No file to open: 'file::filename' parameter is missing");
tlp::error() << pluginProgress->getError() << std::endl;
return errorTrap();
}
pluginProgress->showPreview(false);
pluginProgress->setComment(std::string("Loading ") + filename + "...");
// header
TLPBHeader header;
// read header
if (!bool(is->read((char *) &header, sizeof(header))))
return (delete is, errorTrap());
if (!header.checkCompatibility()) {
pluginProgress->setError("file is not in TLPB format.");
tlp::error() << pluginProgress->getError() << std::endl;
return (delete is, errorTrap());
}
// add nodes
{
// we have to pass a vector to get the newly created nodes
// but as we do not need them, we use a null ref which is
// supported by the underlying GraphStorage class
std::vector<node>* vptr = NULL;
graph->addNodes(header.numNodes, *vptr);
}
// loop to read edges
{
// we can use a buffer to limit the disk reads
std::vector< std::pair<node, node> > vEdges(MAX_EDGES_TO_READ);
unsigned int nbEdges = header.numEdges;
pluginProgress->setComment(filename + ": reading edges...");
while(nbEdges) {
unsigned int edgesToRead =
nbEdges > MAX_EDGES_TO_READ ? MAX_EDGES_TO_READ : nbEdges;
vEdges.resize(edgesToRead);
// read a bunch of edges
if (!bool(is->read((char *) vEdges.data(),
edgesToRead * sizeof(vEdges[0]))))
return (delete is, errorTrap());
if (pluginProgress->progress(header.numEdges - nbEdges,
header.numEdges) !=TLP_CONTINUE)
return pluginProgress->state()!=TLP_CANCEL;
// we have to pass a vector to get the newly created edges
// but as we do not need them, we use a null ref which is
// supported by the underlying GraphStorage class
vector<edge>* vptr = NULL;
// add edges in the graph
graph->addEdges(vEdges, *vptr);
// decrement nbEdges
nbEdges -= edgesToRead;
}
}
// read subgraphs
unsigned int numSubGraphs = 0;
{
// read the number of subgraphs
if (!bool(is->read((char *) &numSubGraphs, sizeof(numSubGraphs))))
return (delete is, errorTrap());
// read loop for subgraphs
pluginProgress->setComment(filename + ": reading subgraphs...");
for (unsigned int i = 0; i < numSubGraphs; ++i) {
std::pair<unsigned int, unsigned int> ids;
// read subgraph id and parent id
if (!bool(is->read((char *) &ids, sizeof(ids))))
return (delete is, errorTrap());
// add subgraph
Graph* parent =
ids.second ? graph->getDescendantGraph(ids.second) : graph;
Graph* sg = ((GraphAbstract *) parent)->addSubGraph(ids.first);
// read sg nodes ranges
{
unsigned int numRanges = 0;
// read the number of nodes ranges
if (!bool(is->read((char *) &numRanges, sizeof(numRanges))))
return (delete is, errorTrap());
// we can use a buffer to limit the disk reads
std::vector<std::pair<node, node> > vRanges(MAX_RANGES_TO_READ);
// loop to read ranges
while(numRanges) {
unsigned int rangesToRead =
numRanges > MAX_RANGES_TO_READ ? MAX_RANGES_TO_READ : numRanges;
vRanges.resize(rangesToRead);
// read a bunch of ranges
if (!bool(is->read((char *) vRanges.data(),
rangesToRead * sizeof(vRanges[0]))))
return (delete is, errorTrap());
// loop to add nodes
for (unsigned int i = 0; i < rangesToRead; ++i) {
std::pair<node, node>& range = vRanges[i];
RangeIterator<node> itr(range.first, range.second);
sg->addNodes(&itr);
}
numRanges -= rangesToRead;
}
}
// read sg edges ranges
{
unsigned int numRanges = 0;
// read the number of edges ranges
if (!bool(is->read((char *) &numRanges, sizeof(numRanges))))
return (delete is, errorTrap());
// loop to read ranges
std::vector<std::pair<edge, edge> > vRanges(MAX_RANGES_TO_READ);
while(numRanges) {
unsigned int rangesToRead =
numRanges > MAX_RANGES_TO_READ ? MAX_RANGES_TO_READ : numRanges;
vRanges.resize(rangesToRead);
// read a bunch of ranges
if (!bool(is->read((char *) vRanges.data(),
rangesToRead * sizeof(vRanges[0]))))
return (delete is, errorTrap());
// loop to add edges
for (unsigned int i = 0; i < rangesToRead; ++i) {
std::pair<edge, edge>& range = vRanges[i];
RangeIterator<edge> itr(range.first, range.second);
sg->addEdges(&itr);
}
numRanges -= rangesToRead;
}
}
if (pluginProgress->progress(i + 1, numSubGraphs) !=TLP_CONTINUE)
return pluginProgress->state()!=TLP_CANCEL;
}
}
// read properties
{
unsigned int numProperties = 0;
// read number of properties
if (!bool(is->read((char *) &numProperties, sizeof(numProperties))))
return (delete is, errorTrap());
// read loop on properties
pluginProgress->setComment(filename + ": reading properties...");
for (unsigned int i = 0; i < numProperties; ++i) {
unsigned int size = 0;
// read name length
if (!bool(is->read((char *) &size, sizeof(size))))
return (delete is, errorTrap());
// + 1 to ensure a null terminated string
std::string propName(size + 1, 0);
// read name
if (!is->read((char *) propName.data(), size))
return (delete is, errorTrap());
propName.resize(size);
// special treament for pathnames view properties
bool pnViewProp = (propName == string("viewFont") ||
propName == string("viewTexture"));
// read graph id
if (!bool(is->read((char *) &size, sizeof(size))))
return (delete is, errorTrap());
// get corresponding graph
Graph* g = size ? graph->getDescendantGraph(size) : graph;
assert(g);
if (g == NULL)
return (delete is, errorTrap());
// read type length
if (!bool(is->read((char *) &size, sizeof(size))))
return (delete is, errorTrap());
// + 1 to ensure a null terminated string
std::string propType(size + 1, 0);
// read type
if (!is->read((char *) propType.data(), size))
return (delete is, errorTrap());
propType.resize(size);
PropertyInterface* prop = NULL;
// create property
if (propType==GraphProperty::propertyTypename)
prop = g->getLocalProperty<GraphProperty>(propName);
else if (propType==DoubleProperty::propertyTypename)
prop = g->getLocalProperty<DoubleProperty>(propName);
else if (propType==LayoutProperty::propertyTypename)
prop = g->getLocalProperty<LayoutProperty>(propName);
else if (propType==SizeProperty::propertyTypename)
prop = g->getLocalProperty<SizeProperty>(propName);
else if (propType==ColorProperty::propertyTypename)
prop = g->getLocalProperty<ColorProperty>(propName);
else if (propType==IntegerProperty::propertyTypename)
prop = g->getLocalProperty<IntegerProperty>(propName);
else if (propType==BooleanProperty::propertyTypename)
prop = g->getLocalProperty<BooleanProperty>(propName);
else if (propType==StringProperty::propertyTypename)
prop = g->getLocalProperty<StringProperty>(propName);
else if (propType==SizeVectorProperty::propertyTypename)
prop = g->getLocalProperty<SizeVectorProperty>(propName);
else if (propType==ColorVectorProperty::propertyTypename)
prop = g->getLocalProperty<ColorVectorProperty>(propName);
else if (propType==CoordVectorProperty::propertyTypename)
prop = g->getLocalProperty<CoordVectorProperty>(propName);
else if (propType==DoubleVectorProperty::propertyTypename)
prop = g->getLocalProperty<DoubleVectorProperty>(propName);
else if (propType==IntegerVectorProperty::propertyTypename)
prop = g->getLocalProperty<IntegerVectorProperty>(propName);
else if (propType==BooleanVectorProperty::propertyTypename)
prop = g->getLocalProperty<BooleanVectorProperty>(propName);
else if (propType==StringVectorProperty::propertyTypename)
prop = g->getLocalProperty<StringVectorProperty>(propName);
assert(prop);
if (prop == NULL)
return (delete is, errorTrap());
if (pnViewProp) {
std::string value;
StringType::readb(*is, value);
// if needed replace symbolic path by real path
size_t pos = value.find("TulipBitmapDir/");
if (pos!=std::string::npos)
value.replace(pos, 15, TulipBitmapDir);
((StringProperty *)prop)->setAllNodeValue(value);
StringType::readb(*is, value);
// if needed replace symbolic path by real path
pos = value.find("TulipBitmapDir/");
if (pos!=std::string::npos)
value.replace(pos, 15, TulipBitmapDir);
((StringProperty *)prop)->setAllEdgeValue(value);
}
else {
// read and set property node default value
if (!prop->readNodeDefaultValue(*is))
return (delete is, errorTrap());
// read and set property edge default value
if (!prop->readEdgeDefaultValue(*is))
return (delete is, errorTrap());
}
// nodes / edges values
{
unsigned int numValues = 0;
// read the number of nodes values
if (!bool(is->read((char *) &numValues, sizeof(numValues))))
return (delete is, errorTrap());
// loop on nodes values
size = prop->nodeValueSize();
if (size) {
// as the size of any value is fixed
// we can use a buffer to limit the number of disk reads
char *vBuf;
if (numValues < MAX_VALUES_TO_READ)
vBuf = (char *) malloc(numValues * (sizeof(unsigned int) + size));
else
vBuf = (char *) malloc(MAX_VALUES_TO_READ * (sizeof(unsigned int) + size));
while(numValues) {
// read a bunch of <node, prop_value>
unsigned int valuesToRead =
(numValues > MAX_VALUES_TO_READ) ? MAX_VALUES_TO_READ : numValues;
if (!is->read((char *) vBuf, valuesToRead * (sizeof(unsigned int) + size)))
return (delete is, errorTrap(vBuf));
// use a stringstream to read nodes and properties
stringstream vs;
// set read buffer of stringstream to vBuf
vs.rdbuf()->pubsetbuf((char*) vBuf,
valuesToRead * (sizeof(unsigned int) + size));
for (unsigned int i = 0; i < valuesToRead; ++i) {
node n;
// read node id
if (!bool(vs.read((char *) &n.id, sizeof(unsigned int))))
return (delete is, errorTrap(vBuf));
// read and set node value
if (!prop->readNodeValue(vs, n))
return (delete is, errorTrap(vBuf));
}
numValues -= valuesToRead;
}
free(vBuf);
}
else {
// we cannot predict the size of property values
// so the loop is simpler but with more disk reads
for (unsigned int i = 0; i < numValues; ++i) {
node n;
// read node id
if (!bool(is->read((char *) &(n.id), sizeof(unsigned int))))
return (delete is, errorTrap());
if (pnViewProp) {
std::string value;
StringType::readb(*is, value);
// if needed replace symbolic path by real path
size_t pos = value.find("TulipBitmapDir/");
if (pos!=std::string::npos)
value.replace(pos, 15, TulipBitmapDir);
((StringProperty *)prop)->setNodeValue(n, value);
}
else {
// read and set node value
if (!prop->readNodeValue(*is, n))
return (delete is, errorTrap());
}
}
}
// read the number of edges values
if (!bool(is->read((char *) &numValues, sizeof(numValues))))
return (delete is, errorTrap());
// loop on edges values
size = prop->edgeValueSize();
if (size) {
// as the size of any value is fixed
// we can use a buffer to limit the number of disk reads
char *vBuf;
if (numValues < MAX_VALUES_TO_READ)
vBuf = (char *) malloc(numValues * (sizeof(unsigned int) + size));
else
vBuf = (char *) malloc(MAX_VALUES_TO_READ * (sizeof(unsigned int) + size));
while(numValues) {
// read a bunch of <edge, prop_value> in vBuf
unsigned int valuesToRead =
(numValues > MAX_VALUES_TO_READ) ? MAX_VALUES_TO_READ : numValues;
if (!is->read((char *) vBuf, valuesToRead * (sizeof(unsigned int) + size)))
return (delete is, errorTrap(vBuf));
// use a stringstream to read edges and properties
stringstream vs;
// set read buffer of stringstream to vBuf
vs.rdbuf()->pubsetbuf((char *) vBuf,
valuesToRead * (sizeof(unsigned int) + size));
for (unsigned int i = 0; i < valuesToRead; ++i) {
edge e;
// read edge id
if (!bool(vs.read((char *) &e.id, sizeof(unsigned int))))
return (delete is, errorTrap(vBuf));
if (pnViewProp) {
std::string value;
StringType::readb(*is, value);
// if needed replace symbolic path by real path
size_t pos = value.find("TulipBitmapDir/");
if (pos!=std::string::npos)
value.replace(pos, 15, TulipBitmapDir);
((StringProperty *)prop)->setEdgeValue(e, value);
}
else
// read and set edge value
if (!prop->readEdgeValue(vs, e))
return (delete is, errorTrap(vBuf));
}
numValues -= valuesToRead;
}
free(vBuf);
}
else {
// we cannot predict the size of property values
// so the loop is simpler but with more disk reads
for (unsigned int i = 0; i < numValues; ++i) {
edge e;
// read edge id
if (!bool(is->read((char *) &e.id, sizeof(unsigned int))))
return (delete is, errorTrap());
// read and set edge value
if (!prop->readEdgeValue(*is, e))
return (delete is, errorTrap());
}
}
}
if (pluginProgress->progress(i + 1, numProperties) !=TLP_CONTINUE)
return pluginProgress->state()!=TLP_CANCEL;
}
}
// read graphs (root graph + subgraphs) attributes
pluginProgress->setComment(filename + ": reading attributes of graphs...");
for(unsigned int i = 0; i < numSubGraphs + 1; ++i) {
unsigned int id = 0;
// read graph id
if (!bool(is->read((char *) &id, sizeof(id))))
return (delete is, errorTrap());
Graph* g = id ? graph->getDescendantGraph(id) : graph;
assert(g);
if (g == NULL)
return (delete is, errorTrap());
// read graph attributes
DataSet::read(*is, const_cast<DataSet &>(g->getAttributes()));
// do not forget to read the end marker
char c = '\0';
is->get(c);
assert(c == ')');
if (c != ')')
return false;
if (pluginProgress->progress(i + 1, numSubGraphs + 1) !=TLP_CONTINUE) {
delete is;
return pluginProgress->state()!=TLP_CANCEL;
}
}
delete is;
return true;
}
