Client/src/principal.cpp

   1
   2 #include "principal.h"
   3 #include <iostream>
   4 #include <sstream>
   5 #include <string>
   6 #include "plaqui/server/string.h"
   7 #include "item_codo.h"
   8 #include "item_conduct.h"
   9 #include "item_exclusa.h"
  10 #include "item_tank.h"
  11 #include "item_pump.h"
  12 #include "item_union.h"
  13 #include "item_drain.h"
  14 #include <unistd.h>
  15
  16 Principal::Principal(BaseObjectType *co, const Glib::RefPtr<Gnome::Glade::Xml> &rg):Gtk::Window(co),refXml(rg)
  17 {
  18         Gtk::MenuItem *conect=0, *exit=0, *about=0, *mnu_prop=0, *mnu_disconnect=0;
  19         Gtk::Button *btn_get=0, *bar_connect=0;
  20         txt_view = 0;
  21         txt_target = txt_command = txt_args = 0;
  22         work_place = 0;
  23         lbl_cap_flujo = lbl_cap_extra = lbl_extra = lbl_nombre = lbl_color = lbl_flujo = 0;
  24
  25         rg->get_widget("btn_activar", btn_activar);
  26         rg->get_widget("color_preview", color_preview);
  27         rg->get_widget("lbl_nombre", lbl_nombre);
  28         rg->get_widget("lbl_extra", lbl_extra);
  29         rg->get_widget("lbl_cap_extra", lbl_cap_extra);
  30         rg->get_widget("lbl_cap_flujo", lbl_cap_flujo);
  31         rg->get_widget("lbl_flujo", lbl_flujo);
  32         rg->get_widget("mnu_file_connect", conect);
  33         rg->get_widget("mnu_file_disconnect", mnu_disconnect);
  34         rg->get_widget("mnu_file_exit", exit);
  35         rg->get_widget("mnu_help_about", about);
  36         rg->get_widget("mnu_prop", mnu_prop);
  37         rg->get_widget_derived("dlgConectar", dlg_conectar);
  38         rg->get_widget("btn_get", btn_get);
  39         rg->get_widget("txt_view", txt_view);
  40         rg->get_widget("txt_target", txt_target);
  41         rg->get_widget("txt_command", txt_command);
  42         rg->get_widget("txt_args", txt_args);
  43         rg->get_widget("bar_connect", bar_connect);
  44         rg->get_widget("work_place", work_place);
  45         rg->get_widget("ico_conected", ico_conected);
  46
  47         dlg_conectar->get_ok_button()->signal_clicked().connect( SigC::slot(*this, &Principal::on_dlg_connect_ok) );
  48         mnu_disconnect->signal_activate().connect( SigC::slot(*this, &Principal::on_mnu_file_disconnect));
  49         conect->signal_activate().connect( SigC::slot(*this, &Principal::on_mnu_file_connect));
  50         bar_connect->signal_clicked().connect( SigC::slot(*this, &Principal::on_mnu_file_connect));
  51         exit->signal_activate().connect( SigC::slot(*this, &Principal::on_mnu_file_exit));
  52         about->signal_activate().connect( SigC::slot(*this, &Principal::on_mnu_help_about));
  53         btn_get->signal_clicked().connect( SigC::slot(*this, &Principal::on_get_clicked) );
  54         btn_activar->signal_clicked().connect( SigC::slot(*this, &Principal::on_btn_activar_clicked) );
  55
  56         conexion = NULL;
  57         is_xml_loaded = false;
  58         last_selected = NULL;
  59         update_ui.connect( SigC::slot(*this, &Principal::update_items_prop ) );
  60         load_xml_dispatch.connect( SigC::slot(*this, &Principal::loadXML ) );
  61 }
  62
  63 Principal::~Principal()
  64 {
  65         if (conexion) {
  66                 conexion->finish();
  67         }
  68         // Espera a que termine realmente.
  69         while (conexion) {
  70                 Glib::usleep(10000); // 10 milisegundos
  71         }
  72 }
  73
  74 void Principal::on_dlg_connect_ok()
  75 {
  76         if (conexion == NULL) {
  77                 // Creo la conexion
  78                 try {
  79                         conexion = new PlaQui::Server::ControlClient(dlg_conectar->get_server_name(), dlg_conectar->get_server_port());
  80                 }
  81                 catch (...) {
  82                         txt_view->get_buffer()->insert_at_cursor("NO SE PUDO CREAR OBJETO\n");
  83                         //delete conexion; XXX Si no me equivoco, si falla el
  84                         //constructor, no se reserva la memoria (el delete no va).
  85                         conexion = NULL;
  86                         return;
  87                 }
  88
  89                 // Conecto las señales
  90                 conexion->signal_ok_received().connect( SigC::slot(*this, &Principal::on_conexion_ok) );
  91                 conexion->signal_error_received().connect( SigC::slot(*this, &Principal::on_conexion_error) );
  92                 conexion->signal_connected().connect( SigC::slot(*this, &Principal::on_conexion_connected) );
  93                 conexion->signal_finished().connect( SigC::slot(*this, &Principal::on_conexion_finished) );
  94                 conexion->signal_frame_received().connect(SigC::slot(*this, &Principal::on_conexion_frame));
  95                 // Lanzo la conexion!
  96                 conexion->run();
  97         } else {
  98                 txt_view->get_buffer()->insert_at_cursor("YA ESTAS CONECTADO\n");
  99         }
 100         dlg_conectar->hide();
 101 }
 102
 103 void Principal::on_mnu_file_exit()
 104 {
 105         Gtk::Main::quit();
 106 }
 107
 108 void Principal::on_btn_activar_clicked()
 109 {
 110         if ((conexion == NULL) || (last_selected == NULL)) return;
 111
 112         PlaQui::Server::Command c("plant", "set");
 113         c.add_arg("default");
 114         c.add_arg(last_selected->get_name());
 115         c.add_arg("open");
 116
 117         if (last_selected->get_open())
 118                 c.add_arg("false");
 119         else
 120                 c.add_arg("true");
 121
 122         conexion->send(c);
 123 }
 124
 125 void Principal::on_mnu_file_disconnect()
 126 {
 127         if (conexion == NULL) return;
 128
 129         PlaQui::Server::Command c("connection", "stop");
 130         c.add_arg(conexion->get_host());
 131         c.add_arg(conexion->get_port());
 132         conexion->send(c);
 133 }
 134
 135 void Principal::on_mnu_file_connect()
 136 {
 137         dlg_conectar->show();
 138 }
 139
 140 void Principal::on_mnu_help_about()
 141 {
 142         // preparo para leer el archivo ChangeLog
 143 /*      Glib::RefPtr<Gnome::Glade::Xml> xml;
 144         Glib::ustring line;
 145         Glib::RefPtr<Gtk::TextBuffer> log_buffer;
 146         Glib::RefPtr<Glib::IOChannel> log_io;
 147
 148         log_buffer = Gtk::TextBuffer::create();
 149         log_io = Glib::IOChannel::create_from_file("../ChangeLog", "r");
 150         while (log_io->read_line(line) != Glib::IO_STATUS_EOF) {
 151                 log_buffer->insert_at_cursor(line);
 152         }
 153
 154         try {
 155                 xml = Gnome::Glade::Xml::create("client.glade", "dlgAbout");
 156         }
 157         catch(const Gnome::Glade::XmlError &ex) {
 158                 std::cerr << ex.what() << std::endl;
 159                 return;
 160         }
 161         Gtk::Window *dlg = 0;
 162         Gtk::Button *btn_cerrar = 0;
 163         Gtk::TextView *txt_changelog = 0;
 164         xml->get_widget("dlgAbout", dlg);
 165         xml->get_widget("btn_close", btn_cerrar);
 166         xml->get_widget("txt_changelog", txt_changelog);
 167         btn_cerrar->signal_clicked().connect(SigC::slot(*dlg, &Gtk::Dialog::hide));
 168         txt_changelog->set_buffer(log_buffer);
 169         dlg->show();*/
 170 }
 171
 172 bool Principal::on_item_clicked(GdkEventButton *e, ViewItem *i)
 173 {
 174
 175         txt_view->get_buffer()->insert_at_cursor("Selecciono ");
 176         txt_view->get_buffer()->insert_at_cursor(i->get_name());
 177         txt_view->get_buffer()->insert_at_cursor("\n");
 178
 179         last_selected = i;
 180         update_items_prop();
 181 }
 182
 183 void Principal::update_items_prop()
 184 {
 185         if (last_selected == NULL) return;
 186
 187         lbl_nombre->set_text(last_selected->get_name());
 188         lbl_flujo->set_text(last_selected->get_actual_flow());
 189         lbl_extra->set_text(last_selected->get_extra());
 190
 191         lbl_cap_flujo->set_text(last_selected->get_cap_flow());
 192         lbl_cap_extra->set_text(last_selected->get_cap_extra());
 193
 194         color_preview->modify_bg(Gtk::STATE_NORMAL, last_selected->get_color());
 195         color_preview->queue_draw();
 196 }
 197
 198 void Principal::on_conexion_connected()
 199 {
 200         txt_view->get_buffer()->insert_at_cursor("CONNECTED\n");
 201         ico_conected->set( Gtk::Stock::YES , Gtk::IconSize(Gtk::ICON_SIZE_LARGE_TOOLBAR));
 202
 203         // Pido la planta por defecto
 204         if (conexion != NULL) {
 205                 PlaQui::Server::Command c("plant", "get");
 206                 c.add_arg("default");
 207                 conexion->send(c);
 208         }
 209 }
 210
 211 void Principal::on_conexion_frame(const std::string &frame)
 212 {
 213         if (conexion != NULL) {
 214                 read_status_xml(frame);
 215         }
 216 }
 217
 218 void Principal::on_conexion_finished()
 219 {
 220         txt_view->get_buffer()->insert_at_cursor("HANG UP\n");
 221         ico_conected->set( Gtk::Stock::NO , Gtk::IconSize(Gtk::ICON_SIZE_LARGE_TOOLBAR));
 222         conexion = NULL;
 223 }
 224
 225 void Principal::on_conexion_ok(const std::string &body)
 226 {
 227         /* lo paso a la carga del XML */
 228         /* verifico que body este completo */
 229         if ((body.find("</planta>")>0) && (body.find("<planta>")>0)) {
 230                 //loadXML(body);
 231                 xml_body = body;
 232                 load_xml_dispatch();
 233         } else {
 234                 std::cout << body << std::endl;
 235                 txt_view->get_buffer()->insert_at_cursor("<IN>\n");
 236                 txt_view->get_buffer()->insert_at_cursor(Glib::locale_to_utf8(body));
 237                 txt_view->get_buffer()->insert_at_cursor("</IN>\n");
 238         }
 239 }
 240
 241 void Principal::on_conexion_error(unsigned code)
 242 {
 243         std::stringstream a;
 244         std::string s;
 245         a << code;
 246         a >> s;
 247         txt_view->get_buffer()->insert_at_cursor("El server dice que hay error : ");
 248         txt_view->get_buffer()->insert_at_cursor(s);
 249         txt_view->get_buffer()->insert_at_cursor("\n");
 250 }
 251
 252 void Principal::on_get_clicked()
 253 {
 254         if (conexion == NULL) {
 255                 txt_view->get_buffer()->insert_at_cursor("SIN CONEXION\n");
 256                 return;
 257         }
 258
 259         PlaQui::Server::Command command(txt_target->get_text(), txt_command->get_text());
 260         command.add_arg( txt_args->get_text() );
 261         txt_view->get_buffer()->insert_at_cursor("Enviando comando\n");
 262         try {
 263                 conexion->send(command);
 264         }
 265         catch (...) {
 266                 txt_view->get_buffer()->insert_at_cursor("EXCEPTION EN conexion->send !!\n");
 267         }
 268
 269 }
 270
 271 void Principal::loadXML()
 272 {
 273         // ya lo cargue
 274         if (is_xml_loaded) return;
 275
 276         /* Parseo de ejemplo de un XML desde archivo */
 277         xmlDocPtr document;
 278         document = xmlParseMemory(xml_body.c_str(),xml_body.size());
 279         if (document == NULL) {
 280                 std::cout << "EEERRRRRRROOOOOOOOOO" << std::endl;
 281                 return;
 282         }
 283         is_xml_loaded = true;
 284         /* bien, el archivo se parseo bien! */
 285         xmlNodePtr nodo, items;
 286         nodo = document->children;
 287
 288         if (strcmp((char *)nodo->name, "planta") == 0) {
 289                 items = nodo->children;
 290                 while (items != NULL) {
 291                         if (items->type == XML_ELEMENT_NODE) {
 292                                 if (xmlStrcmp(items->name, BAD_CAST"bomba")==0) {
 293                                         loadBomba(items);
 294                                 } else if (xmlStrcmp(items->name, BAD_CAST"codo")==0) {
 295                                         loadCodo(items);
 296                                 } else if (xmlStrcmp(items->name, BAD_CAST"tubo")==0) {
 297                                         loadConduct(items);
 298                                 } else if (xmlStrcmp(items->name, BAD_CAST"exclusa")==0) {
 299                                         loadExclusa(items);
 300                                 } else if (xmlStrcmp(items->name, BAD_CAST"tanque")==0) {
 301                                         loadTank(items);
 302                                 } else if (xmlStrcmp(items->name, BAD_CAST"empalme")==0) {
 303                                         loadUnion(items);
 304                                 } else if (xmlStrcmp(items->name, BAD_CAST"drenaje")==0) {
 305                                         loadDrain(items);
 306                                 }
 307
 308                         }
 309                         items = items->next;
 310                 }
 311         }
 312
 313         // Ya cargado el XML, mando un msg para empezar a recibir los frames!
 314         PlaQui::Server::Command c("transmission", "start");
 315         c.add_arg("default");
 316         c.add_arg(conexion->get_host());
 317         c.add_arg("7528");
 318         conexion->send(c);
 319 }
 320
 321 void Principal::loadBomba(xmlNodePtr nodo)
 322 {
 323         Glib::ustring name = (char *)xmlGetProp(nodo, BAD_CAST"nombre");
 324         int orientacion=0, x, y;
 325
 326         nodo = nodo->children;
 327         while (nodo != NULL) {
 328                 if (nodo->type == XML_ELEMENT_NODE) {
 329                         if (xmlStrcmp(nodo->name, BAD_CAST"orientacion") == 0) {
 330                                 orientacion = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 331                         } else if (xmlStrcmp(nodo->name, BAD_CAST"x") == 0) {
 332                                 x = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 333                         } else if (xmlStrcmp(nodo->name, BAD_CAST"y") == 0) {
 334                                 y = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 335                         }
 336                 }
 337                 nodo = nodo->next;
 338         }
 339
 340         // listo, ya recolecte todos los datos, ahora creo el objeto!
 341         ViewPump *b = new ViewPump(name, orientacion);
 342         b->signal_button_press_event().connect(SigC::bind( SigC::slot(*this, &Principal::on_item_clicked), b) );
 343         b->set_position(x,y);
 344         work_place->put(*b, x, y);
 345         b->show();
 346         // los agrego al hash
 347         mapItems[name] = b;
 348 }
 349
 350 void Principal::loadCodo(xmlNodePtr nodo)
 351 {
 352         std::string name = (char *)xmlGetProp(nodo, BAD_CAST"nombre");
 353         int orientacion=0, x, y;
 354
 355         nodo = nodo->children;
 356         while (nodo != NULL) {
 357                 if (nodo->type == XML_ELEMENT_NODE) {
 358                         if (xmlStrcmp(nodo->name, BAD_CAST"orientacion") == 0) {
 359                                 orientacion = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 360                         } else if (xmlStrcmp(nodo->name, BAD_CAST"x") == 0) {
 361                                 x = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 362                         } else if (xmlStrcmp(nodo->name, BAD_CAST"y") == 0) {
 363                                 y = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 364                         }
 365                 }
 366                 nodo = nodo->next;
 367         }
 368
 369         // listo, ya recolecte todos los datos, ahora creo el objeto!
 370         ViewItem *b = new ViewCodo(name, orientacion);
 371         b->signal_button_press_event().connect(SigC::bind( SigC::slot(*this, &Principal::on_item_clicked), b) );
 372         b->set_position(x,y);
 373         work_place->put(*b, x, y);
 374         b->show();
 375         // los agrego al hash
 376         mapItems[name] = b;
 377 }
 378
 379 void Principal::loadConduct(xmlNodePtr nodo)
 380 {
 381         Glib::ustring name = (char *)xmlGetProp(nodo, BAD_CAST"nombre");
 382         int orientacion=0, x, y;
 383
 384         nodo = nodo->children;
 385         while (nodo != NULL) {
 386                 if (nodo->type == XML_ELEMENT_NODE) {
 387                         if (xmlStrcmp(nodo->name, BAD_CAST"orientacion") == 0) {
 388                                 orientacion = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 389                         } else if (xmlStrcmp(nodo->name, BAD_CAST"x") == 0) {
 390                                 x = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 391                         } else if (xmlStrcmp(nodo->name, BAD_CAST"y") == 0) {
 392                                 y = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 393                         }
 394                 }
 395                 nodo = nodo->next;
 396         }
 397
 398         // listo, ya recolecte todos los datos, ahora creo el objeto!
 399         ViewConduct *b = new ViewConduct(name, orientacion);
 400         b->signal_button_press_event().connect(SigC::bind( SigC::slot(*this, &Principal::on_item_clicked), b) );
 401         b->set_position(x,y);
 402         work_place->put(*b, x, y);
 403         b->show();
 404         // los agrego al hash
 405         mapItems[name] = b;
 406 }
 407
 408 void Principal::loadExclusa(xmlNodePtr nodo)
 409 {
 410         Glib::ustring name = (char *)xmlGetProp(nodo, BAD_CAST"nombre");
 411         int orientacion=0, x, y;
 412
 413         nodo = nodo->children;
 414         while (nodo != NULL) {
 415                 if (nodo->type == XML_ELEMENT_NODE) {
 416                         if (xmlStrcmp(nodo->name, BAD_CAST"orientacion") == 0) {
 417                                 orientacion = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 418                         } else if (xmlStrcmp(nodo->name, BAD_CAST"x") == 0) {
 419                                 x = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 420                         } else if (xmlStrcmp(nodo->name, BAD_CAST"y") == 0) {
 421                                 y = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 422                         }
 423                 }
 424                 nodo = nodo->next;
 425         }
 426
 427         // listo, ya recolecte todos los datos, ahora creo el objeto!
 428         ViewExclusa *b = new ViewExclusa(name, orientacion);
 429         b->signal_button_press_event().connect(SigC::bind( SigC::slot(*this, &Principal::on_item_clicked), b) );
 430         b->set_position(x,y);
 431         work_place->put(*b, x, y);
 432         b->show();
 433         // los agrego al hash
 434         mapItems[name] = b;
 435 }
 436
 437 void Principal::loadTank(xmlNodePtr nodo)
 438 {
 439         Glib::ustring name = (char *)xmlGetProp(nodo, BAD_CAST"nombre");
 440         int orientacion=0, x, y;
 441
 442         nodo = nodo->children;
 443         while (nodo != NULL) {
 444                 if (nodo->type == XML_ELEMENT_NODE) {
 445                         if (xmlStrcmp(nodo->name, BAD_CAST"orientacion") == 0) {
 446                                 orientacion = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 447                         } else if (xmlStrcmp(nodo->name, BAD_CAST"x") == 0) {
 448                                 x = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 449                         } else if (xmlStrcmp(nodo->name, BAD_CAST"y") == 0) {
 450                                 y = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 451                         }
 452                 }
 453                 nodo = nodo->next;
 454         }
 455
 456         // listo, ya recolecte todos los datos, ahora creo el objeto!
 457         ViewTank *b = new ViewTank(name, orientacion);
 458         b->signal_button_press_event().connect(SigC::bind( SigC::slot(*this, &Principal::on_item_clicked), b) );
 459         b->set_position(x,y);
 460         work_place->put(*b, x, y);
 461         b->show();
 462         // los agrego al hash
 463         mapItems[name] = b;
 464 }
 465
 466 void Principal::loadUnion(xmlNodePtr nodo)
 467 {
 468         Glib::ustring name = (char *)xmlGetProp(nodo, BAD_CAST"nombre");
 469         int orientacion=0, x, y;
 470
 471         nodo = nodo->children;
 472         while (nodo != NULL) {
 473                 if (nodo->type == XML_ELEMENT_NODE) {
 474                         if (xmlStrcmp(nodo->name, BAD_CAST"orientacion") == 0) {
 475                                 orientacion = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 476                         } else if (xmlStrcmp(nodo->name, BAD_CAST"x") == 0) {
 477                                 x = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 478                         } else if (xmlStrcmp(nodo->name, BAD_CAST"y") == 0) {
 479                                 y = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 480                         }
 481                 }
 482                 nodo = nodo->next;
 483         }
 484
 485         // listo, ya recolecte todos los datos, ahora creo el objeto!
 486         ViewUnion *b = new ViewUnion(name, orientacion);
 487         b->signal_button_release_event().connect(SigC::bind( SigC::slot(*this, &Principal::on_item_clicked), b) );
 488         b->set_position(x,y);
 489         work_place->put(*b, x, y);
 490         b->show();
 491         // los agrego al hash
 492         mapItems[name] = b;
 493 }
 494
 495 void Principal::loadDrain(xmlNodePtr nodo)
 496 {
 497         Glib::ustring name = (char *)xmlGetProp(nodo, BAD_CAST"nombre");
 498         int orientacion=0, x, y;
 499
 500         nodo = nodo->children;
 501         while (nodo != NULL) {
 502                 if (nodo->type == XML_ELEMENT_NODE) {
 503                         if (xmlStrcmp(nodo->name, BAD_CAST"orientacion") == 0) {
 504                                 orientacion = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 505                         } else if (xmlStrcmp(nodo->name, BAD_CAST"x") == 0) {
 506                                 x = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 507                         } else if (xmlStrcmp(nodo->name, BAD_CAST"y") == 0) {
 508                                 y = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 509                         }
 510                 }
 511                 nodo = nodo->next;
 512         }
 513
 514         // listo, ya recolecte todos los datos, ahora creo el objeto!
 515         ViewDrain *b = new ViewDrain(name, orientacion);
 516         b->signal_button_release_event().connect(SigC::bind( SigC::slot(*this, &Principal::on_item_clicked), b) );
 517         b->set_position(x,y);
 518         work_place->put(*b, x, y);
 519         b->show();
 520         // los agrego al hash
 521         mapItems[name] = b;
 522 }
 523
 524 void Principal::read_status_xml(const std::string &frame)
 525 {
 526         std::string item_name;
 527         xmlDocPtr document;
 528         document = xmlParseMemory(frame.c_str(),frame.size());
 529         if (document == NULL) {
 530                 std::cout << "read_status_xml::no se creo documento" << std::endl;
 531                 return;
 532         }
 533
 534         xmlNodePtr nodo, items, props;
 535         nodo = document->children;
 536         float tmp;
 537         bool tmp_b;
 538
 539         if (strcmp((char *)nodo->name, "plantstatus") == 0) {
 540                 items = nodo->children;
 541                 while (items != NULL) {
 542                         if (items->type == XML_ELEMENT_NODE) {
 543                                 tmp = -1;
 544                                 item_name = "";
 545                                 if (xmlStrcmp(items->name, BAD_CAST"float")==0) {
 546                                         tmp = get_float_from_xml(items->children);
 547                                         item_name = (char *)xmlGetProp(items, BAD_CAST"name");
 548                                         mapItems[item_name]->set_actual_flow(tmp);
 549                                 } else if (xmlStrcmp(items->name, BAD_CAST"exclusa")==0) {
 550                                         tmp_b = get_bool_from_xml(items->children);
 551                                         item_name = (char *)xmlGetProp(items, BAD_CAST"name");
 552                                         mapItems[item_name]->set_open(tmp_b);
 553                                 } else if (xmlStrcmp(items->name, BAD_CAST"pump")==0) {
 554                                         tmp_b = get_bool_from_xml(items->children);
 555                                         item_name = (char *)xmlGetProp(items, BAD_CAST"name");
 556                                         mapItems[item_name]->set_open(tmp_b);
 557                                 }  else if (xmlStrcmp(items->name, BAD_CAST"color")==0) {
 558                                         item_name = (char *)xmlGetProp(items, BAD_CAST"name");
 559                                         mapItems[item_name]->set_color( get_rgb_from_xml(items->children) );
 560                                 } else if (xmlStrcmp(items->name, BAD_CAST"tank")==0) {
 561                                         xmlNodePtr nodo_tmp = items->children;
 562                                         float cap, lit;
 563                                         cap = lit = -1;
 564                                         while (nodo_tmp != NULL) {
 565                                                 if (nodo_tmp->type == XML_ELEMENT_NODE) {
 566                                                         if (xmlStrcmp(nodo_tmp->name, BAD_CAST"capacity")==0)
 567                                                                 cap = atof( (char *)XML_GET_CONTENT(nodo_tmp->children) );
 568                                                         else if (xmlStrcmp(nodo_tmp->name, BAD_CAST"litros")==0)
 569                                                                 lit= atof( (char *)XML_GET_CONTENT(nodo_tmp->children) );
 570                                                 }
 571                                                 nodo_tmp = nodo_tmp->next;
 572                                         }
 573                                         item_name = (char *)xmlGetProp(items, BAD_CAST"name");
 574                                         mapItems[item_name]->set_actual_flow(cap);
 575                                         mapItems[item_name]->set_extra(lit);
 576                                 }
 577                         }
 578                         items = items->next;
 579                 }
 580
 581                 // Actualizo la UI
 582                 update_ui();
 583         }
 584 }
 585
 586 Gdk::Color Principal::get_rgb_from_xml(xmlNodePtr nodo)
 587 {
 588         unsigned r,g,b;
 589         while (nodo != NULL) {
 590                 if (nodo->type == XML_ELEMENT_NODE) {
 591                         if (xmlStrcmp(nodo->name, BAD_CAST"r")==0)
 592                                 r = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 593                         if (xmlStrcmp(nodo->name, BAD_CAST"g")==0)
 594                                 g = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 595                         if (xmlStrcmp(nodo->name, BAD_CAST"b")==0)
 596                                 b = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 597                 }
 598                 nodo = nodo->next;
 599         }
 600         r = 65535 * r / 255;
 601         g = 65535 * g / 255;
 602         b = 65535 * b / 255;
 603         Gdk::Color c;
 604         c.set_rgb(r,g,b);
 605
 606         return c;
 607 }
 608 float Principal::get_float_from_xml(xmlNodePtr nodo)
 609 {
 610         float tmp = -1;
 611         while (nodo != NULL) {
 612                 if (nodo->type == XML_ELEMENT_NODE) {
 613                         if (xmlStrcmp(nodo->name, BAD_CAST"actual_flow")==0) {
 614                                 tmp = atof( (char *)XML_GET_CONTENT(nodo->children) );
 615                                 break;
 616                         }
 617                 }
 618                 nodo = nodo->next;
 619         }
 620         return tmp;
 621 }
 622
 623 bool Principal::get_bool_from_xml(xmlNodePtr nodo)
 624 {
 625         std::string tmp;
 626         while (nodo != NULL) {
 627                 if (nodo->type == XML_ELEMENT_NODE) {
 628                         if (xmlStrcmp(nodo->name, BAD_CAST"active")==0) {
 629                                 tmp = (char *)XML_GET_CONTENT(nodo->children);
 630                                 break;
 631                         }
 632                 }
 633                 nodo = nodo->next;
 634         }
 635         return tmp == "true";
 636 }
 637