Client/src/principal.cpp

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