Fawkes API
Fawkes Development Version
|
00001 00002 /*************************************************************************** 00003 * lasergui.cpp - minimalistic laser visualization 00004 * 00005 * Created: Thu Oct 09 12:51:52 2008 00006 * Copyright 2008-2011 Tim Niemueller [www.niemueller.de] 00007 * 2009 Masrur Doostdar <doostdar@kbsg.rwth-aachen.de> 00008 * 00009 ****************************************************************************/ 00010 00011 /* This program is free software; you can redistribute it and/or modify 00012 * it under the terms of the GNU General Public License as published by 00013 * the Free Software Foundation; either version 2 of the License, or 00014 * (at your option) any later version. 00015 * 00016 * This program is distributed in the hope that it will be useful, 00017 * but WITHOUT ANY WARRANTY; without even the implied warranty of 00018 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00019 * GNU Library General Public License for more details. 00020 * 00021 * Read the full text in the LICENSE.GPL file in the doc directory. 00022 */ 00023 00024 #include "laser_drawing_area.h" 00025 00026 #include <netcomm/fawkes/client.h> 00027 #include <blackboard/remote.h> 00028 #include <interfaces/Laser360Interface.h> 00029 #include <interfaces/Laser720Interface.h> 00030 00031 #include <interfaces/ObjectPositionInterface.h> 00032 #include <interfaces/Position2DTrackInterface.h> 00033 #include <interfaces/SwitchInterface.h> 00034 #include <interfaces/VisualDisplay2DInterface.h> 00035 00036 00037 #include <gui_utils/service_chooser_dialog.h> 00038 #include <gui_utils/multi_interface_chooser_dialog.h> 00039 #include <gui_utils/interface_dispatcher.h> 00040 #include <gui_utils/connection_dispatcher.h> 00041 #include <gui_utils/robot/allemaniacs_athome.h> 00042 00043 #include <gtkmm/main.h> 00044 #include <list> 00045 #include <memory> 00046 #include <set> 00047 #include <map> 00048 #include <utils/misc/string_conversions.h> 00049 00050 00051 #define MAX_OBJECTPOSITIONINTERFACES_PERSONS 10 00052 #define MAX_OBJECTPOSITIONINTERFACES_LEGS 15 00053 #define MAX_OBJECTPOSITIONINTERFACES_MISC 20 00054 #define MAX_TRACKINTERFACES 10 00055 00056 using namespace fawkes; 00057 00058 /** @class LaserGuiGtkWindow "lasergui.cpp" 00059 * Laser GUI window for Gtkmm. 00060 * @author Tim Niemueller 00061 */ 00062 class LaserGuiGtkWindow : public Gtk::Window 00063 { 00064 public: 00065 /** Typedef of fawkes::Interface to override Glib::Interface. */ 00066 typedef fawkes::Interface Interface; 00067 /** Shorthand for pair of interface type and ID. */ 00068 typedef MultiInterfaceChooserDialog::TypeIdPair TypeIdPair; 00069 /** Shorthand for set of pairs of interface type and ID. */ 00070 typedef MultiInterfaceChooserDialog::TypeIdPairList TypeIdPairList; 00071 /** For each interface, an interface dispatcher is opened that listens for 00072 * data changes. */ 00073 typedef std::pair<Interface*, InterfaceDispatcher*> InterfaceDispatcherPair; 00074 /** A list of interfaces and their respective dispatchers. 00075 * Note that this is a list and not a map from interface to dispatcher only 00076 * to keep the ordering specified by the user in the GUI. */ 00077 typedef std::list<InterfaceDispatcherPair> InterfaceDispatcherPairList; 00078 00079 /** Constructor for Gtk::Builder. 00080 * @param cobject C base object 00081 * @param builder Gtk Builder 00082 */ 00083 LaserGuiGtkWindow(BaseObjectType* cobject, 00084 const Glib::RefPtr<Gtk::Builder> &builder) 00085 : Gtk::Window(cobject), __athome_drawer(true) 00086 { 00087 __laser_if_names.push_back(std::make_pair("Laser360Interface", "Laser")); 00088 00089 builder->get_widget_derived("da_laser", __area); 00090 builder->get_widget("tb_connection", __tb_connection); 00091 builder->get_widget("tb_select", __tb_select); 00092 builder->get_widget("tb_lines", __tb_lines); 00093 builder->get_widget("tb_points", __tb_points); 00094 builder->get_widget("tb_hull", __tb_hull); 00095 builder->get_widget("tb_trimvals", __tb_trimvals); 00096 builder->get_widget("tb_rotation", __tb_rotation); 00097 builder->get_widget("tb_legtracker", __tb_legtracker); 00098 builder->get_widget("tb_stop", __tb_stop); 00099 builder->get_widget("tb_zoom_in", __tb_zoom_in); 00100 builder->get_widget("tb_zoom_out", __tb_zoom_out); 00101 builder->get_widget("tb_exit", __tb_exit); 00102 builder->get_widget("dlg_ltopen", __dlg_ltopen); 00103 builder->get_widget("pgb_ltopen", __pgb_ltopen); 00104 00105 __area->set_robot_drawer(&__athome_drawer); 00106 00107 __tb_select->set_sensitive(false); 00108 __tb_lines->set_sensitive(false); 00109 __tb_points->set_sensitive(false); 00110 __tb_hull->set_sensitive(false); 00111 __tb_trimvals->set_sensitive(false); 00112 __tb_rotation->set_sensitive(false); 00113 __tb_legtracker->set_sensitive(false); 00114 __tb_stop->set_sensitive(false); 00115 __tb_zoom_in->set_sensitive(false); 00116 __tb_zoom_out->set_sensitive(false); 00117 00118 __tb_connection->signal_clicked().connect(sigc::mem_fun(*this, &LaserGuiGtkWindow::on_connection_clicked)); 00119 __tb_select->signal_clicked().connect(sigc::mem_fun(*this, &LaserGuiGtkWindow::on_select_clicked)); 00120 __tb_lines->signal_toggled().connect(sigc::bind(sigc::mem_fun(*__area, &LaserDrawingArea::set_draw_mode), LaserDrawingArea::MODE_LINES)); 00121 __tb_points->signal_toggled().connect(sigc::bind(sigc::mem_fun(*__area, &LaserDrawingArea::set_draw_mode), LaserDrawingArea::MODE_POINTS)); 00122 __tb_hull->signal_toggled().connect(sigc::bind(sigc::mem_fun(*__area, &LaserDrawingArea::set_draw_mode), LaserDrawingArea::MODE_HULL)); 00123 __tb_zoom_in->signal_clicked().connect(sigc::mem_fun(*__area, &LaserDrawingArea::zoom_in)); 00124 __tb_zoom_out->signal_clicked().connect(sigc::mem_fun(*__area, &LaserDrawingArea::zoom_out)); 00125 00126 __tb_legtracker->signal_clicked().connect(sigc::mem_fun(*this, &LaserGuiGtkWindow::on_legtracker_toggled)); 00127 __tb_trimvals->signal_clicked().connect(sigc::mem_fun(*this, &LaserGuiGtkWindow::on_trimvals_toggled)); 00128 __tb_rotation->signal_clicked().connect(sigc::mem_fun(*this, &LaserGuiGtkWindow::on_rotation_toggled)); 00129 __tb_stop->signal_clicked().connect(sigc::mem_fun(*this, &LaserGuiGtkWindow::on_stop_toggled)); 00130 __tb_exit->signal_clicked().connect(sigc::mem_fun(*this, &LaserGuiGtkWindow::on_exit_clicked)); 00131 00132 __connection_dispatcher.signal_connected().connect(sigc::mem_fun(*this, &LaserGuiGtkWindow::on_connect)); 00133 __connection_dispatcher.signal_disconnected().connect(sigc::mem_fun(*this, &LaserGuiGtkWindow::on_disconnect)); 00134 } 00135 00136 00137 protected: 00138 /** Event handler for connection button. */ 00139 virtual void on_connection_clicked() 00140 { 00141 if ( ! __connection_dispatcher.get_client()->connected() ) { 00142 ServiceChooserDialog ssd(*this, __connection_dispatcher.get_client()); 00143 ssd.run_and_connect(); 00144 } else { 00145 __connection_dispatcher.get_client()->disconnect(); 00146 } 00147 00148 } 00149 00150 /** Event handler for connection button. */ 00151 virtual void on_select_clicked() 00152 { 00153 if ( ! __connection_dispatcher.get_client()->connected() ) { 00154 Gtk::MessageDialog md(*this, 00155 "Cannot get list of interfaces if not connected.", 00156 /* markup */ false, 00157 Gtk::MESSAGE_ERROR, Gtk::BUTTONS_OK, 00158 /* modal */ true); 00159 md.set_title("Interface Selection Failed"); 00160 md.run(); 00161 } else { 00162 std::auto_ptr<MultiInterfaceChooserDialog> ifcd( 00163 MultiInterfaceChooserDialog::create(*this, 00164 __bb, 00165 "Laser*Interface", 00166 "*", 00167 __laser_if_names)); 00168 if (ifcd->run()) { 00169 const TypeIdPairList interfaces = ifcd->get_selected_interfaces(); 00170 open_interfaces(interfaces); 00171 } 00172 } 00173 } 00174 00175 /** Open interfaces. 00176 * Tries to open the interfaces. 00177 * Even if it fails, the old interfaces are closed. 00178 * @param types_and_ids types and ids of interfaces to open 00179 */ 00180 void 00181 open_interfaces(const TypeIdPairList& types_and_ids) 00182 { 00183 __area->reset_laser_ifs(); 00184 for (InterfaceDispatcherPairList::const_iterator it = __laser_ifs.begin(); 00185 it != __laser_ifs.end(); ++it) { 00186 __bb->unregister_listener(it->second); 00187 delete it->second; 00188 __bb->close(it->first); 00189 } 00190 __laser_ifs.clear(); 00191 __laser_if_names = types_and_ids; 00192 00193 // Open interfaces. 00194 for (TypeIdPairList::const_iterator it = types_and_ids.begin(); 00195 it != types_and_ids.end(); ++it) 00196 { 00197 const Glib::ustring& type = it->first; 00198 const Glib::ustring& id = it->second; 00199 Interface* itf = NULL; 00200 try { 00201 if (type == "Laser720Interface") { 00202 itf = __bb->open_for_reading<Laser720Interface>(id.c_str()); 00203 } else if (type == "Laser360Interface") { 00204 itf = __bb->open_for_reading<Laser360Interface>(id.c_str()); 00205 } else { 00206 throw Exception("Invalid interface type %s", type.c_str()); 00207 } 00208 } catch (const Exception& e) { 00209 std::string msg = std::string("Failed to open interface: ") + e.what(); 00210 Gtk::MessageDialog md(*this, msg, /* markup */ false, 00211 Gtk::MESSAGE_ERROR, Gtk::BUTTONS_OK, 00212 /* modal */ true); 00213 md.set_title("Opening Interface Failed"); 00214 md.run(); 00215 continue; 00216 } 00217 InterfaceDispatcher* itfd = new InterfaceDispatcher("LaserInterfaceDispatcher", itf); 00218 itfd->signal_data_changed().connect( 00219 sigc::hide(sigc::mem_fun(*__area, &LaserDrawingArea::queue_draw))); 00220 try { 00221 __bb->register_listener(itfd, BlackBoard::BBIL_FLAG_DATA); 00222 } catch (const Exception& e) { 00223 std::string msg = std::string("Failed to register interface dispatcher: ") + e.what(); 00224 Gtk::MessageDialog md(*this, msg, /* markup */ false, 00225 Gtk::MESSAGE_ERROR, Gtk::BUTTONS_OK, 00226 /* modal */ true); 00227 md.set_title("Registrating Interface Dispatcher Failed"); 00228 md.run(); 00229 delete itfd; 00230 __bb->close(itf); 00231 continue; 00232 } 00233 const InterfaceDispatcherPair p = std::make_pair(itf, itfd); 00234 __laser_ifs.push_back(p); 00235 } 00236 00237 // Inform the drawing area. 00238 std::list<Interface*> keys; 00239 for (InterfaceDispatcherPairList::const_iterator it = __laser_ifs.begin(); 00240 it != __laser_ifs.end(); ++it) 00241 { 00242 keys.push_back(it->first); 00243 } 00244 __area->set_laser_ifs(keys); 00245 } 00246 00247 /** Event handler for connected event. */ 00248 virtual void on_connect() 00249 { 00250 try { 00251 __bb = new RemoteBlackBoard(__connection_dispatcher.get_client()); 00252 __laser_ifs.clear(); 00253 __l_objpos_if_persons = NULL; 00254 __l_objpos_if_legs = NULL; 00255 __l_objpos_if_misc = NULL; 00256 __l_track_if = NULL; 00257 __laser_segmentation_if = NULL; 00258 __switch_if = NULL; 00259 __target_if = NULL; 00260 __line_if = NULL; 00261 __visdis_if = NULL; 00262 00263 //__laser_if = __bb->open_for_reading<Laser360Interface>("LegtrackerAveragedLaser"); 00264 00265 __area->set_connected(true); 00266 open_interfaces(__laser_if_names); 00267 00268 __line_if = __bb->open_for_reading<ObjectPositionInterface>("LaserLine"); 00269 __area->set_line_if(__line_if); 00270 try { 00271 __visdis_if = __bb->open_for_writing<VisualDisplay2DInterface>("LaserGUI"); 00272 __area->set_visdisp_if(__visdis_if); 00273 } catch (Exception &e) { 00274 __visdis_if = NULL; 00275 // visdisplay is optional, probably some other lasergui has it 00276 // open atm 00277 } 00278 00279 on_legtracker_toggled(); 00280 00281 __area->queue_draw(); 00282 00283 __tb_connection->set_stock_id(Gtk::Stock::DISCONNECT); 00284 __tb_select->set_sensitive(true); 00285 __tb_lines->set_sensitive(true); 00286 __tb_points->set_sensitive(true); 00287 __tb_hull->set_sensitive(true); 00288 __tb_trimvals->set_sensitive(true); 00289 __tb_rotation->set_sensitive(true); 00290 __tb_legtracker->set_sensitive(true); 00291 __tb_stop->set_sensitive(true); 00292 __tb_zoom_in->set_sensitive(true); 00293 __tb_zoom_out->set_sensitive(true); 00294 } catch (Exception &e) { 00295 __area->reset_laser_ifs(); 00296 __area->set_line_if(NULL); 00297 __area->set_visdisp_if(NULL); 00298 __area->queue_draw(); 00299 __area->set_connected(false); 00300 if ( __bb ) { 00301 __area->reset_laser_ifs(); 00302 for (InterfaceDispatcherPairList::const_iterator it = __laser_ifs.begin(); 00303 it != __laser_ifs.end(); ++it) { 00304 __bb->unregister_listener(it->second); 00305 delete it->second; 00306 __bb->close(it->first); 00307 } 00308 __bb->close(__line_if); 00309 __bb->close(__visdis_if); 00310 delete __bb; 00311 __laser_ifs.clear(); 00312 __bb = NULL; 00313 __line_if = NULL; 00314 __visdis_if = NULL; 00315 } 00316 } 00317 } 00318 00319 /** Event handler for disconnected event. */ 00320 virtual void on_disconnect() 00321 { 00322 __area->set_connected(false); 00323 __area->reset_laser_ifs(); 00324 __area->set_line_if(NULL); 00325 __area->set_visdisp_if(NULL); 00326 __area->queue_draw(); 00327 for (InterfaceDispatcherPairList::const_iterator it = __laser_ifs.begin(); 00328 it != __laser_ifs.end(); ++it) { 00329 __bb->unregister_listener(it->second); 00330 delete it->second; 00331 __bb->close(it->first); 00332 } 00333 __laser_ifs.clear(); 00334 if(__laser_segmentation_if) 00335 __bb->close(__laser_segmentation_if); 00336 if(__switch_if) 00337 __bb->close(__switch_if); 00338 if(__target_if) 00339 __bb->close(__target_if); 00340 __bb->close(__line_if); 00341 __bb->close(__visdis_if); 00342 00343 std::list<ObjectPositionInterface*>::iterator objpos_if_itt; 00344 std::list<Position2DTrackInterface*>::iterator track_if_itt; 00345 if(__l_objpos_if_persons){ 00346 for( objpos_if_itt = __l_objpos_if_persons->begin(); objpos_if_itt != __l_objpos_if_persons->end(); objpos_if_itt++ ) { 00347 __bb->close(*objpos_if_itt); 00348 } 00349 __l_objpos_if_persons->clear(); 00350 } 00351 if(__l_objpos_if_legs){ 00352 for( objpos_if_itt = __l_objpos_if_legs->begin(); objpos_if_itt != __l_objpos_if_legs->end(); objpos_if_itt++ ) { 00353 __bb->close(*objpos_if_itt); 00354 } 00355 __l_objpos_if_legs->clear(); 00356 } 00357 if(__l_objpos_if_misc){ 00358 for( objpos_if_itt = __l_objpos_if_misc->begin(); objpos_if_itt != __l_objpos_if_misc->end(); objpos_if_itt++ ) { 00359 __bb->close(*objpos_if_itt); 00360 } 00361 __l_objpos_if_misc->clear(); 00362 } 00363 if(__l_track_if){ 00364 for( track_if_itt = __l_track_if->begin(); track_if_itt != __l_track_if->end(); track_if_itt++ ) { 00365 __bb->close(*track_if_itt); 00366 } 00367 __l_track_if->clear(); 00368 } 00369 00370 00371 00372 delete __bb; 00373 __bb = NULL; 00374 __laser_ifs.clear(); 00375 __l_objpos_if_persons = NULL; 00376 __l_objpos_if_legs = NULL; 00377 __l_objpos_if_misc = NULL; 00378 __l_track_if = NULL; 00379 __laser_segmentation_if = NULL; 00380 __switch_if = NULL; 00381 __target_if = NULL; 00382 __visdis_if = NULL; 00383 __line_if = NULL; 00384 00385 __tb_connection->set_stock_id(Gtk::Stock::CONNECT); 00386 __tb_select->set_sensitive(false); 00387 __tb_lines->set_sensitive(false); 00388 __tb_points->set_sensitive(false); 00389 __tb_hull->set_sensitive(false); 00390 __tb_trimvals->set_sensitive(false); 00391 __tb_rotation->set_sensitive(false); 00392 __tb_legtracker->set_sensitive(false); 00393 __tb_stop->set_sensitive(false); 00394 __tb_zoom_in->set_sensitive(false); 00395 __tb_zoom_out->set_sensitive(false); 00396 } 00397 00398 00399 /** Event handler for rotation button. */ 00400 void on_rotation_toggled() 00401 { 00402 if ( __tb_rotation->get_active() ) { 00403 __area->set_rotation(M_PI / 2); 00404 } else { 00405 __area->set_rotation(0); 00406 } 00407 } 00408 00409 00410 /** Event handler for stop button */ 00411 void on_stop_toggled() 00412 { 00413 __area->toggle_break_drawing(); 00414 } 00415 00416 /** Event handler for legtracker button */ 00417 void on_legtracker_toggled() 00418 { 00419 if (! __bb) return; 00420 00421 if (!__tb_legtracker->get_active()) { 00422 __bb->close(__laser_segmentation_if); 00423 __bb->close(__switch_if); 00424 __bb->close(__target_if); 00425 00426 std::list<ObjectPositionInterface*>::iterator objpos_if_itt; 00427 std::list<Position2DTrackInterface*>::iterator track_if_itt; 00428 if (__l_objpos_if_persons) { 00429 for( objpos_if_itt = __l_objpos_if_persons->begin(); objpos_if_itt != __l_objpos_if_persons->end(); objpos_if_itt++ ) { 00430 __bb->close(*objpos_if_itt); 00431 } 00432 __l_objpos_if_persons->clear(); 00433 } 00434 if (__l_objpos_if_legs) { 00435 for( objpos_if_itt = __l_objpos_if_legs->begin(); objpos_if_itt != __l_objpos_if_legs->end(); objpos_if_itt++ ) { 00436 __bb->close(*objpos_if_itt); 00437 } 00438 __l_objpos_if_legs->clear(); 00439 } 00440 if (__l_objpos_if_misc) { 00441 for( objpos_if_itt = __l_objpos_if_misc->begin(); objpos_if_itt != __l_objpos_if_misc->end(); objpos_if_itt++ ) { 00442 __bb->close(*objpos_if_itt); 00443 } 00444 __l_objpos_if_misc->clear(); 00445 } 00446 00447 if (__l_track_if) { 00448 for( track_if_itt = __l_track_if->begin(); track_if_itt != __l_track_if->end(); track_if_itt++ ) { 00449 __bb->close(*track_if_itt); 00450 } 00451 __l_track_if->clear(); 00452 } 00453 00454 __laser_segmentation_if = NULL; 00455 __switch_if = NULL; 00456 __target_if = NULL; 00457 __l_objpos_if_persons = NULL; 00458 __l_objpos_if_legs = NULL; 00459 __l_objpos_if_misc = NULL; 00460 __l_track_if = NULL; 00461 00462 __area->set_objpos_if(__l_objpos_if_persons,__l_objpos_if_legs,__l_objpos_if_misc,__laser_segmentation_if, __l_track_if, __target_if,__switch_if); 00463 00464 } else { 00465 unsigned int num_opens = 3 00466 + MAX_OBJECTPOSITIONINTERFACES_PERSONS 00467 + MAX_OBJECTPOSITIONINTERFACES_LEGS 00468 + MAX_OBJECTPOSITIONINTERFACES_MISC 00469 + MAX_TRACKINTERFACES; 00470 00471 float step_fraction = 1.0 / num_opens; 00472 unsigned int opened = 0; 00473 __pgb_ltopen->set_fraction(0); 00474 __dlg_ltopen->show(); 00475 __area->queue_draw(); 00476 00477 __laser_segmentation_if = __bb->open_for_reading<Laser720Interface>("SegmentsLaser"); 00478 __pgb_ltopen->set_fraction(++opened * step_fraction); 00479 while (Gtk::Main::events_pending()) Gtk::Main::iteration(); 00480 00481 __target_if = __bb->open_for_reading<ObjectPositionInterface>("legtracker Target"); 00482 00483 ObjectPositionInterface* new_objpos_if; 00484 __l_objpos_if_persons = new std::list<ObjectPositionInterface*>(); 00485 __l_objpos_if_legs = new std::list<ObjectPositionInterface*>(); 00486 __l_objpos_if_misc = new std::list<ObjectPositionInterface*>(); 00487 __l_track_if = new std::list<Position2DTrackInterface*>(); 00488 for (int i=1; i <= MAX_OBJECTPOSITIONINTERFACES_PERSONS; ++i){ 00489 new_objpos_if= __bb->open_for_reading<ObjectPositionInterface>((std::string("legtracker CurrentLegsTracked") + StringConversions::to_string(i)).c_str()); 00490 __l_objpos_if_persons->push_back(new_objpos_if); 00491 __pgb_ltopen->set_fraction(++opened * step_fraction); 00492 while (Gtk::Main::events_pending()) Gtk::Main::iteration(); 00493 } 00494 for (int i=1; i <= MAX_OBJECTPOSITIONINTERFACES_LEGS; ++i){ 00495 new_objpos_if= __bb->open_for_reading<ObjectPositionInterface>((std::string("legtracker Leg") + StringConversions::to_string(i)).c_str()); 00496 __l_objpos_if_legs->push_back(new_objpos_if); 00497 __pgb_ltopen->set_fraction(++opened * step_fraction); 00498 while (Gtk::Main::events_pending()) Gtk::Main::iteration(); 00499 } 00500 for (int i=1; i <= MAX_OBJECTPOSITIONINTERFACES_MISC; ++i){ 00501 new_objpos_if= __bb->open_for_reading<ObjectPositionInterface>((std::string("legtracker Misc") + StringConversions::to_string(i)).c_str()); 00502 __l_objpos_if_misc->push_back(new_objpos_if); 00503 __pgb_ltopen->set_fraction(++opened * step_fraction); 00504 while (Gtk::Main::events_pending()) Gtk::Main::iteration(); 00505 } 00506 Position2DTrackInterface* new_track_if; 00507 for (int i=1; i <= MAX_TRACKINTERFACES; ++i){ 00508 new_track_if = __bb->open_for_reading<Position2DTrackInterface>((std::string("legtracker Track") + StringConversions::to_string(i)).c_str()); 00509 __l_track_if->push_back( new_track_if ); 00510 __pgb_ltopen->set_fraction(++opened * step_fraction); 00511 while (Gtk::Main::events_pending()) Gtk::Main::iteration(); 00512 } 00513 00514 __switch_if = __bb->open_for_reading<SwitchInterface>("legtracker write!"); 00515 __pgb_ltopen->set_fraction(++opened * step_fraction); 00516 while (Gtk::Main::events_pending()) Gtk::Main::iteration(); 00517 __dlg_ltopen->hide(); 00518 __area->set_objpos_if(__l_objpos_if_persons, __l_objpos_if_legs, 00519 __l_objpos_if_misc,__laser_segmentation_if, 00520 __l_track_if, __target_if,__switch_if); 00521 __area->queue_draw(); 00522 } 00523 } 00524 00525 00526 /** Event handler for trim button. */ 00527 void on_trimvals_toggled() 00528 { 00529 if ( __tb_trimvals->get_active() ) { 00530 __area->set_resolution(3); 00531 } else { 00532 __area->set_resolution(1); 00533 } 00534 } 00535 00536 /** Event handler for exit button. */ 00537 void on_exit_clicked() 00538 { 00539 Gtk::Main::quit(); 00540 } 00541 00542 private: 00543 BlackBoard *__bb; 00544 InterfaceDispatcherPairList __laser_ifs; 00545 Laser720Interface *__laser_segmentation_if; 00546 SwitchInterface *__switch_if; 00547 ObjectPositionInterface *__target_if; 00548 00549 std::list<ObjectPositionInterface*>* __l_objpos_if_persons; 00550 std::list<ObjectPositionInterface*>* __l_objpos_if_legs; 00551 std::list<ObjectPositionInterface*>* __l_objpos_if_misc; 00552 std::list<Position2DTrackInterface*>* __l_track_if; 00553 00554 ObjectPositionInterface *__line_if; 00555 VisualDisplay2DInterface *__visdis_if; 00556 00557 LaserDrawingArea *__area; 00558 AllemaniACsAtHomeCairoRobotDrawer __athome_drawer; 00559 ConnectionDispatcher __connection_dispatcher; 00560 00561 Gtk::ToolButton *__tb_connection; 00562 Gtk::RadioToolButton *__tb_lines; 00563 Gtk::RadioToolButton *__tb_points; 00564 Gtk::RadioToolButton *__tb_hull; 00565 Gtk::ToggleToolButton *__tb_trimvals; 00566 Gtk::ToggleToolButton *__tb_rotation; 00567 Gtk::ToggleToolButton *__tb_legtracker; 00568 Gtk::ToggleToolButton *__tb_stop; 00569 Gtk::ToolButton *__tb_zoom_in; 00570 Gtk::ToolButton *__tb_zoom_out; 00571 Gtk::ToolButton *__tb_exit; 00572 Gtk::ToolButton *__tb_select; 00573 00574 Gtk::Dialog *__dlg_ltopen; 00575 Gtk::ProgressBar *__pgb_ltopen; 00576 00577 TypeIdPairList __laser_if_names; 00578 }; 00579 00580 int 00581 main(int argc, char** argv) 00582 { 00583 Gtk::Main kit(argc, argv); 00584 00585 Glib::RefPtr<Gtk::Builder> builder; 00586 builder = Gtk::Builder::create_from_file(RESDIR"/guis/lasergui/lasergui.ui"); 00587 00588 LaserGuiGtkWindow *window = NULL; 00589 builder->get_widget_derived("wnd_lasergui", window); 00590 00591 Gtk::Main::run(*window); 00592 00593 return 0; 00594 }