00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030 #include <stdio.h>
00031
00032 #include <QColor>
00033
00034 #include <yaml-cpp/emitter.h>
00035
00036 #include "rviz/display_context.h"
00037 #include "rviz/display_factory.h"
00038 #include "rviz/failed_display.h"
00039 #include "rviz/properties/yaml_helpers.h"
00040 #include "rviz/properties/property_tree_model.h"
00041
00042 #include "display_group.h"
00043
00044 namespace rviz
00045 {
00046
00047 DisplayGroup::DisplayGroup()
00048 {
00049 }
00050
00051 DisplayGroup::~DisplayGroup()
00052 {
00053 removeAllDisplays();
00054 }
00055
00056 void DisplayGroup::removeAllChildren()
00057 {
00058 Display::removeAllChildren();
00059 removeAllDisplays();
00060 }
00061
00062 QVariant DisplayGroup::getViewData( int column, int role ) const
00063 {
00064 if( column == 0 )
00065 {
00066 switch( role )
00067 {
00068 case Qt::BackgroundRole: return QColor( 40, 120, 197 );
00069 case Qt::ForegroundRole: return QColor( Qt::white );
00070 }
00071 }
00072 return Display::getViewData( column, role );
00073 }
00074
00075 Qt::ItemFlags DisplayGroup::getViewFlags( int column ) const
00076 {
00077 return Display::getViewFlags( column ) | Qt::ItemIsDropEnabled;
00078 }
00079
00080 void DisplayGroup::loadChildren( const YAML::Node& yaml_node )
00081 {
00082 if( yaml_node.Type() != YAML::NodeType::Map )
00083 {
00084 printf( "DisplayGroup::load() TODO: error handling - unexpected non-Map YAML type.\n" );
00085 return;
00086 }
00087 removeAllDisplays();
00088
00089
00090 Display::loadChildren( yaml_node );
00091
00092
00093 const YAML::Node& displays_node = yaml_node[ "Displays" ];
00094 if( displays_node.Type() != YAML::NodeType::Sequence )
00095 {
00096 printf( "DisplayGroup::load() TODO: error handling - unexpected non-Sequence YAML type.\n" );
00097 return;
00098 }
00099
00100 if( model_ )
00101 {
00102 model_->beginInsert( this, Display::numChildren(), displays_node.size() );
00103 }
00104
00105 for( YAML::Iterator it = displays_node.begin(); it != displays_node.end(); ++it )
00106 {
00107 const YAML::Node& display_node = *it;
00108 QString display_class;
00109 display_node[ "Class" ] >> display_class;
00110 Display* disp = createDisplay( display_class );
00111 addDisplayWithoutSignallingModel( disp );
00112 disp->initialize( context_ );
00113 disp->load( display_node );
00114 }
00115
00116 if( model_ )
00117 {
00118 model_->endInsert();
00119 }
00120 }
00121
00122 Display* DisplayGroup::createDisplay( const QString& class_id )
00123 {
00124 DisplayFactory* factory = context_->getDisplayFactory();
00125 QString error;
00126 Display* disp = factory->make( class_id, &error );
00127 if( !disp )
00128 {
00129 return new FailedDisplay( class_id, error );
00130 }
00131 return disp;
00132 }
00133
00134 void DisplayGroup::saveChildren( YAML::Emitter& emitter )
00135 {
00136 Display::saveChildren( emitter );
00137
00138
00139 emitter << YAML::Key << "Displays";
00140 emitter << YAML::Value;
00141 emitter << YAML::BeginSeq;
00142 int num_displays = displays_.size();
00143 for( int i = 0; i < num_displays; i++ )
00144 {
00145 displays_.at( i )->save( emitter );
00146 }
00147 emitter << YAML::EndSeq;
00148 }
00149
00150 void DisplayGroup::removeAllDisplays()
00151 {
00152 int num_non_display_children = Display::numChildren();
00153
00154 if( model_ )
00155 {
00156 model_->beginRemove( this, num_non_display_children, displays_.size() );
00157 }
00158 for( int i = displays_.size() - 1; i >= 0; i-- )
00159 {
00160
00161 Display* child = displays_.takeAt( i );
00162 child->setParent( NULL );
00163 delete child;
00164 }
00165 if( model_ )
00166 {
00167 model_->endRemove();
00168 }
00169 }
00170
00171 Display* DisplayGroup::takeDisplay( Display* child )
00172 {
00173 Display* result = NULL;
00174 int num_displays = displays_.size();
00175 for( int i = 0; i < num_displays; i++ )
00176 {
00177 if( displays_.at( i ) == child )
00178 {
00179 if( model_ )
00180 {
00181 model_->beginRemove( this, Display::numChildren() + i, 1 );
00182 }
00183
00184 result = displays_.takeAt( i );
00185 result->setParent( NULL );
00186 result->setModel( NULL );
00187 child_indexes_valid_ = false;
00188 if( model_ )
00189 {
00190 model_->endRemove();
00191 }
00192 break;
00193 }
00194 }
00195 return result;
00196 }
00197
00198 Display* DisplayGroup::getDisplayAt( int index ) const
00199 {
00200 if( 0 <= index && index < displays_.size() )
00201 {
00202 return displays_.at( index );
00203 }
00204 return NULL;
00205 }
00206
00207 void DisplayGroup::fixedFrameChanged()
00208 {
00209 int num_children = displays_.size();
00210 for( int i = 0; i < num_children; i++ )
00211 {
00212 displays_.at( i )->setFixedFrame( fixed_frame_ );
00213 }
00214 }
00215
00216 void DisplayGroup::update( float wall_dt, float ros_dt )
00217 {
00218 int num_children = displays_.size();
00219 for( int i = 0; i < num_children; i++ )
00220 {
00221 displays_.at( i )->update( wall_dt, ros_dt );
00222 }
00223 }
00224
00225 void DisplayGroup::reset()
00226 {
00227 Display::reset();
00228
00229 int num_children = displays_.size();
00230 for( int i = 0; i < num_children; i++ )
00231 {
00232 displays_.at( i )->reset();
00233 }
00234 }
00235
00236 void DisplayGroup::addDisplayWithoutSignallingModel( Display* child )
00237 {
00238
00239 displays_.append( child );
00240 child_indexes_valid_ = false;
00241 child->setModel( model_ );
00242 child->setParent( this );
00243 }
00244
00245 void DisplayGroup::addDisplay( Display* child )
00246 {
00247 if( model_ )
00248 {
00249 model_->beginInsert( this, numChildren(), 1 );
00250 }
00251 addDisplayWithoutSignallingModel( child );
00252 if( model_ )
00253 {
00254 model_->endInsert();
00255 }
00256 }
00257
00258 void DisplayGroup::addChild( Property* child, int index )
00259 {
00260 Display* display = qobject_cast<Display*>( child );
00261 if( !display )
00262 {
00263 Display::addChild( child, index );
00264 return;
00265 }
00266 if( index < 0 || index > numChildren() )
00267 {
00268 index = numChildren();
00269 }
00270 int disp_index = index - Display::numChildren();
00271 if( disp_index < 0 )
00272 {
00273 disp_index = 0;
00274 }
00275 if( model_ )
00276 {
00277 model_->beginInsert( this, index );
00278 }
00279
00280 displays_.insert( disp_index, display );
00281 child_indexes_valid_ = false;
00282 display->setModel( model_ );
00283 display->setParent( this );
00284
00285 if( model_ )
00286 {
00287 model_->endInsert();
00288 }
00289 }
00290
00291 Property* DisplayGroup::takeChildAt( int index )
00292 {
00293 if( index < Display::numChildren() )
00294 {
00295 return Display::takeChildAt( index );
00296 }
00297 int disp_index = index - Display::numChildren();
00298 if( model_ )
00299 {
00300 model_->beginRemove( this, index, 1 );
00301 }
00302
00303 Property* child = displays_.takeAt( disp_index );
00304 child->setModel( NULL );
00305 child->setParent( NULL );
00306 child_indexes_valid_ = false;
00307 if( model_ )
00308 {
00309 model_->endRemove();
00310 }
00311 return child;
00312 }
00313
00314 int DisplayGroup::numDisplays() const
00315 {
00316 return displays_.size();
00317 }
00318
00319 int DisplayGroup::numChildren() const
00320 {
00321 return Display::numChildren() + displays_.size();
00322 }
00323
00324 Property* DisplayGroup::childAtUnchecked( int index ) const
00325 {
00326 int first_child_count = Display::numChildren();
00327 if( index < first_child_count )
00328 {
00329 return Display::childAtUnchecked( index );
00330 }
00331 index -= first_child_count;
00332 return displays_.at( index );
00333 }
00334
00335 }