void
Map::removeModelLayer( ModelLayer* layer )
{
if ( layer )
{
//Take a reference to the layer since we will be deleting it
osg::ref_ptr< ModelLayer > layerRef = layer;
Revision newRevision;
{
Threading::ScopedWriteLock lock( _mapDataMutex );
for( ModelLayerVector::iterator i = _modelLayers.begin(); i != _modelLayers.end(); ++i )
{
if ( i->get() == layer )
{
_modelLayers.erase( i );
newRevision = ++_dataModelRevision;
break;
}
}
}
for( MapCallbackList::iterator i = _mapCallbacks.begin(); i != _mapCallbacks.end(); ++i )
{
i->get()->onMapModelChanged( MapModelChange(
MapModelChange::REMOVE_MODEL_LAYER, newRevision, layerRef.get()) );
}
}
}
void
Map::removeModelLayer( ModelLayer* layer )
{
if ( layer )
{
Revision newRevision;
{
Threading::ScopedWriteLock lock( _mapDataMutex );
for( ModelLayerVector::iterator i = _modelLayers.begin(); i != _modelLayers.end(); ++i )
{
if ( i->get() == layer )
{
_modelLayers.erase( i );
newRevision = ++_dataModelRevision;
break;
}
}
}
for( MapCallbackList::iterator i = _mapCallbacks.begin(); i != _mapCallbacks.end(); ++i )
{
i->get()->onMapModelChanged( MapModelChange(
MapModelChange::REMOVE_MODEL_LAYER, newRevision, layer) );
}
}
}
void
Map::moveModelLayer( ModelLayer* layer, unsigned int newIndex )
{
unsigned int oldIndex = 0;
unsigned int actualIndex = 0;
Revision newRevision;
if ( layer )
{
Threading::ScopedWriteLock lock( _mapDataMutex );
// preserve the layer with a ref:
osg::ref_ptr<ModelLayer> layerToMove = layer;
// find it:
ModelLayerVector::iterator i_oldIndex = _modelLayers.end();
for( ModelLayerVector::iterator i = _modelLayers.begin(); i != _modelLayers.end(); i++, actualIndex++ )
{
if ( i->get() == layer )
{
i_oldIndex = i;
oldIndex = actualIndex;
break;
}
}
if ( i_oldIndex == _modelLayers.end() )
return; // layer not found in list
// erase the old one and insert the new one.
_modelLayers.erase( i_oldIndex );
_modelLayers.insert( _modelLayers.begin() + newIndex, layerToMove.get() );
newRevision = ++_dataModelRevision;
}
// a separate block b/c we don't need the mutex
if ( layer )
{
for( MapCallbackList::iterator i = _mapCallbacks.begin(); i != _mapCallbacks.end(); i++ )
{
i->get()->onMapModelChanged( MapModelChange(
MapModelChange::MOVE_MODEL_LAYER, newRevision, layer, oldIndex, newIndex) );
}
}
}
void
Map::setLayersFromMap( const Map* map )
{
this->clear();
if ( map )
{
ImageLayerVector newImages;
map->getImageLayers( newImages );
for( ImageLayerVector::iterator i = newImages.begin(); i != newImages.end(); ++i )
addImageLayer( i->get() );
ElevationLayerVector newElev;
map->getElevationLayers( newElev );
for( ElevationLayerVector::iterator i = newElev.begin(); i != newElev.end(); ++i )
addElevationLayer( i->get() );
ModelLayerVector newModels;
map->getModelLayers( newModels );
for( ModelLayerVector::iterator i = newModels.begin(); i != newModels.end(); ++i )
addModelLayer( i->get() );
}
}
void
Map::clear()
{
ImageLayerVector imageLayersRemoved;
ElevationLayerVector elevLayersRemoved;
ModelLayerVector modelLayersRemoved;
MaskLayerVector maskLayersRemoved;
Revision newRevision;
{
Threading::ScopedWriteLock lock( _mapDataMutex );
imageLayersRemoved.swap( _imageLayers );
elevLayersRemoved.swap ( _elevationLayers );
modelLayersRemoved.swap( _modelLayers );
// calculate a new revision.
newRevision = ++_dataModelRevision;
}
// a separate block b/c we don't need the mutex
for( MapCallbackList::iterator i = _mapCallbacks.begin(); i != _mapCallbacks.end(); i++ )
{
for( ImageLayerVector::iterator k = imageLayersRemoved.begin(); k != imageLayersRemoved.end(); ++k )
i->get()->onMapModelChanged( MapModelChange(MapModelChange::REMOVE_IMAGE_LAYER, newRevision, k->get()) );
for( ElevationLayerVector::iterator k = elevLayersRemoved.begin(); k != elevLayersRemoved.end(); ++k )
i->get()->onMapModelChanged( MapModelChange(MapModelChange::REMOVE_ELEVATION_LAYER, newRevision, k->get()) );
for( ModelLayerVector::iterator k = modelLayersRemoved.begin(); k != modelLayersRemoved.end(); ++k )
i->get()->onMapModelChanged( MapModelChange(MapModelChange::REMOVE_MODEL_LAYER, newRevision, k->get()) );
}
}