Fawkes API  Fawkes Development Version
lasergui.cpp
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 }