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_nombre = lbl_color = lbl_flujo = 0;
  26
  27         rg->get_widget("lbl_nombre", lbl_nombre);
  28         rg->get_widget("lbl_flujo", lbl_flujo);
  29         rg->get_widget("mnu_file_connect", conect);
  30         rg->get_widget("mnu_file_disconnect", mnu_disconnect);
  31         rg->get_widget("mnu_file_exit", exit);
  32         rg->get_widget("mnu_help_about", about);
  33         rg->get_widget("mnu_prop", mnu_prop);
  34         rg->get_widget_derived("dlgConectar", dlg_conectar);
  35         rg->get_widget("btn_get", btn_get);
  36         rg->get_widget("txt_view", txt_view);
  37         rg->get_widget("txt_target", txt_target);
  38         rg->get_widget("txt_command", txt_command);
  39         rg->get_widget("txt_args", txt_args);
  40         rg->get_widget("bar_connect", bar_connect);
  41         rg->get_widget("work_place", work_place);
  42         rg->get_widget("ico_conected", ico_conected);
  43
  44         dlg_conectar->get_ok_button()->signal_clicked().connect( SigC::slot(*this, &Principal::on_dlg_connect_ok) );
  45         mnu_disconnect->signal_activate().connect( SigC::slot(*this, &Principal::on_mnu_file_disconnect));
  46         conect->signal_activate().connect( SigC::slot(*this, &Principal::on_mnu_file_connect));
  47         bar_connect->signal_clicked().connect( SigC::slot(*this, &Principal::on_mnu_file_connect));
  48         exit->signal_activate().connect( SigC::slot(*this, &Principal::on_mnu_file_exit));
  49         about->signal_activate().connect( SigC::slot(*this, &Principal::on_mnu_help_about));
  50         btn_get->signal_clicked().connect( SigC::slot(*this, &Principal::on_get_clicked) );
  51
  52         conexion = NULL;
  53         is_xml_loaded = false;
  54
  55         load_xml_dispatch.connect( SigC::slot(*this, &Principal::loadXML ) );
  56 }
  57
  58 Principal::~Principal()
  59 {
  60         delete conexion;
  61 }
  62
  63 void Principal::on_dlg_connect_ok()
  64 {
  65         if (conexion == NULL) {
  66                 // Creo la conexion
  67                 try {
  68                         conexion = new PlaQui::Server::ControlClient(dlg_conectar->get_server_name(), dlg_conectar->get_server_port());
  69                 }
  70                 catch (...) {
  71                         txt_view->get_buffer()->insert_at_cursor("NO SE PUDO CREAR OBJETO\n");
  72                         delete conexion;
  73                         conexion == NULL;
  74                         return;
  75                 }
  76
  77                 // Conecto las señales
  78                 conexion->signal_ok_received().connect( SigC::slot(*this, &Principal::on_conexion_ok) );
  79                 conexion->signal_error_received().connect( SigC::slot(*this, &Principal::on_conexion_error) );
  80                 conexion->signal_connected().connect( SigC::slot(*this, &Principal::on_conexion_connected) );
  81                 conexion->signal_finished().connect( SigC::slot(*this, &Principal::on_conexion_finished) );
  82                 conexion->signal_frame_received().connect(SigC::slot(*this, &Principal::on_conexion_frame));
  83                 // Lanzo la conexion!
  84                 try {
  85                         conexion->run();
  86                 }
  87                 catch (...) {
  88                         txt_view->get_buffer()->insert_at_cursor("no se puede correr conexion->run()!!!\n");
  89                 }
  90         } else {
  91                 txt_view->get_buffer()->insert_at_cursor("YA ESTAS CONECTADO\n");
  92         }
  93         dlg_conectar->hide();
  94 }
  95
  96 void Principal::on_mnu_file_exit()
  97 {
  98         Gtk::Main::quit();
  99 }
 100
 101 void Principal::on_mnu_file_disconnect()
 102 {
 103         if (conexion == NULL) return;
 104
 105         PlaQui::Server::Command c("connection", "stop");
 106         c.add_arg(conexion->get_host());
 107         c.add_arg(conexion->get_port());
 108         conexion->send(c);
 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         txt_view->get_buffer()->insert_at_cursor("Selecciono ");
 153         txt_view->get_buffer()->insert_at_cursor(i->get_name());
 154         txt_view->get_buffer()->insert_at_cursor("\n");
 155 }
 156
 157 void Principal::on_conexion_connected()
 158 {
 159         txt_view->get_buffer()->insert_at_cursor("CONNECTED\n");
 160         ico_conected->set( Gtk::Stock::YES , Gtk::IconSize(Gtk::ICON_SIZE_LARGE_TOOLBAR));
 161
 162         // Pido la planta por defecto
 163         PlaQui::Server::Command c("plant", "get");
 164         c.add_arg("default");
 165         conexion->send(c);
 166 }
 167
 168 void Principal::on_conexion_frame(const std::string &frame)
 169 {
 170         read_status_xml(frame);
 171 }
 172
 173 void Principal::on_conexion_finished()
 174 {
 175         txt_view->get_buffer()->insert_at_cursor("HANG UP\n");
 176         ico_conected->set( Gtk::Stock::NO , Gtk::IconSize(Gtk::ICON_SIZE_LARGE_TOOLBAR));
 177         conexion = NULL;
 178 }
 179
 180 void Principal::on_conexion_ok(const std::string &body)
 181 {
 182         /* lo paso a la carga del XML */
 183         /* verifico que body este completo */
 184         if ((body.find("</planta>")>0) && (body.find("<planta>")>0)) {
 185                 //loadXML(body);
 186                 xml_body = body;
 187                 load_xml_dispatch();
 188                 // Ya cargado el XML, mando un msg para empezar a recibir los frames!
 189                 PlaQui::Server::Command c("transmission", "start");
 190                 c.add_arg("default");
 191                 c.add_arg("");
 192                 c.add_arg("7528");
 193                 conexion->send(c);
 194         } else {
 195                 std::cout << body << std::endl;
 196                 txt_view->get_buffer()->insert_at_cursor("<IN>\n");
 197                 txt_view->get_buffer()->insert_at_cursor(Glib::locale_to_utf8(body));
 198                 txt_view->get_buffer()->insert_at_cursor("</IN>\n");
 199         }
 200 }
 201
 202 void Principal::on_conexion_error(unsigned code)
 203 {
 204         std::stringstream a;
 205         std::string s;
 206         a << code;
 207         a >> s;
 208         txt_view->get_buffer()->insert_at_cursor("El server dice que hay error : ");
 209         txt_view->get_buffer()->insert_at_cursor(s);
 210         txt_view->get_buffer()->insert_at_cursor("\n");
 211
 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
 222         PlaQui::Server::Command command(txt_target->get_text(), txt_command->get_text());
 223         command.add_arg( txt_args->get_text() );
 224         txt_view->get_buffer()->insert_at_cursor("Enviando comando\n");
 225         try {
 226                 conexion->send(command);
 227         }
 228         catch (...) {
 229                 txt_view->get_buffer()->insert_at_cursor("EXCEPTION EN conexion->send !!\n");
 230         }
 231
 232 }
 233
 234 void Principal::loadXML()
 235 {
 236         // ya lo cargue
 237         if (is_xml_loaded) return;
 238
 239         /* Parseo de ejemplo de un XML desde archivo */
 240         xmlDocPtr document;
 241         document = xmlParseMemory(xml_body.c_str(),xml_body.size());
 242         if (document == NULL) {
 243                 std::cout << "EEERRRRRRROOOOOOOOOO" << std::endl;
 244                 return;
 245         }
 246         is_xml_loaded = true;
 247         /* bien, el archivo se parseo bien! */
 248         xmlNodePtr nodo, items;
 249         nodo = document->children;
 250
 251         if (strcmp((char *)nodo->name, "planta") == 0) {
 252                 items = nodo->children;
 253                 while (items != NULL) {
 254                         if (items->type == XML_ELEMENT_NODE) {
 255                                 if (xmlStrcmp(items->name, BAD_CAST"bomba")==0) {
 256                                         loadBomba(items);
 257                                 } else if (xmlStrcmp(items->name, BAD_CAST"codo")==0) {
 258                                         loadCodo(items);
 259                                 } else if (xmlStrcmp(items->name, BAD_CAST"tubo")==0) {
 260                                         loadConduct(items);
 261                                 } else if (xmlStrcmp(items->name, BAD_CAST"exclusa")==0) {
 262                                         loadExclusa(items);
 263                                 } else if (xmlStrcmp(items->name, BAD_CAST"tanque")==0) {
 264                                         loadTank(items);
 265                                 } else if (xmlStrcmp(items->name, BAD_CAST"empalme")==0) {
 266                                         loadUnion(items);
 267                                 } else if (xmlStrcmp(items->name, BAD_CAST"drenaje")==0) {
 268                                         loadDrain(items);
 269                                 }
 270
 271                         }
 272                         items = items->next;
 273                 }
 274         }
 275
 276 }
 277
 278 void Principal::loadBomba(xmlNodePtr nodo)
 279 {
 280         Glib::ustring name = (char *)xmlGetProp(nodo, BAD_CAST"nombre");
 281         int orientacion=0, x, y;
 282
 283         nodo = nodo->children;
 284         while (nodo != NULL) {
 285                 if (nodo->type == XML_ELEMENT_NODE) {
 286                         if (xmlStrcmp(nodo->name, BAD_CAST"orientacion") == 0) {
 287                                 orientacion = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 288                         } else if (xmlStrcmp(nodo->name, BAD_CAST"x") == 0) {
 289                                 x = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 290                         } else if (xmlStrcmp(nodo->name, BAD_CAST"y") == 0) {
 291                                 y = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 292                         }
 293                 }
 294                 nodo = nodo->next;
 295         }
 296
 297         // listo, ya recolecte todos los datos, ahora creo el objeto!
 298         ViewPump *b = new ViewPump(name, orientacion);
 299         b->signal_button_press_event().connect(SigC::bind( SigC::slot(*this, &Principal::on_item_clicked), b) );
 300         b->set_position(x,y);
 301         work_place->put(*b, x, y);
 302         b->show();
 303         // los agrego al hash
 304         mapItems[name] = b;
 305 }
 306
 307 void Principal::loadCodo(xmlNodePtr nodo)
 308 {
 309         std::string name = (char *)xmlGetProp(nodo, BAD_CAST"nombre");
 310         int orientacion=0, x, y;
 311
 312         nodo = nodo->children;
 313         while (nodo != NULL) {
 314                 if (nodo->type == XML_ELEMENT_NODE) {
 315                         if (xmlStrcmp(nodo->name, BAD_CAST"orientacion") == 0) {
 316                                 orientacion = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 317                         } else if (xmlStrcmp(nodo->name, BAD_CAST"x") == 0) {
 318                                 x = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 319                         } else if (xmlStrcmp(nodo->name, BAD_CAST"y") == 0) {
 320                                 y = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 321                         }
 322                 }
 323                 nodo = nodo->next;
 324         }
 325
 326         // listo, ya recolecte todos los datos, ahora creo el objeto!
 327         ViewItem *b = new ViewCodo(name, orientacion);
 328         b->signal_button_press_event().connect(SigC::bind( SigC::slot(*this, &Principal::on_item_clicked), b) );
 329         b->set_position(x,y);
 330         work_place->put(*b, x, y);
 331         b->show();
 332         // los agrego al hash
 333         mapItems[name] = b;
 334 }
 335
 336 void Principal::loadConduct(xmlNodePtr nodo)
 337 {
 338         Glib::ustring name = (char *)xmlGetProp(nodo, BAD_CAST"nombre");
 339         int orientacion=0, x, y;
 340
 341         nodo = nodo->children;
 342         while (nodo != NULL) {
 343                 if (nodo->type == XML_ELEMENT_NODE) {
 344                         if (xmlStrcmp(nodo->name, BAD_CAST"orientacion") == 0) {
 345                                 orientacion = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 346                         } else if (xmlStrcmp(nodo->name, BAD_CAST"x") == 0) {
 347                                 x = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 348                         } else if (xmlStrcmp(nodo->name, BAD_CAST"y") == 0) {
 349                                 y = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 350                         }
 351                 }
 352                 nodo = nodo->next;
 353         }
 354
 355         // listo, ya recolecte todos los datos, ahora creo el objeto!
 356         ViewConduct *b = new ViewConduct(name, orientacion);
 357         b->signal_button_press_event().connect(SigC::bind( SigC::slot(*this, &Principal::on_item_clicked), b) );
 358         b->set_position(x,y);
 359         work_place->put(*b, x, y);
 360         b->show();
 361         // los agrego al hash
 362         mapItems[name] = b;
 363 }
 364
 365 void Principal::loadExclusa(xmlNodePtr nodo)
 366 {
 367         Glib::ustring name = (char *)xmlGetProp(nodo, BAD_CAST"nombre");
 368         int orientacion=0, x, y;
 369
 370         nodo = nodo->children;
 371         while (nodo != NULL) {
 372                 if (nodo->type == XML_ELEMENT_NODE) {
 373                         if (xmlStrcmp(nodo->name, BAD_CAST"orientacion") == 0) {
 374                                 orientacion = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 375                         } else if (xmlStrcmp(nodo->name, BAD_CAST"x") == 0) {
 376                                 x = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 377                         } else if (xmlStrcmp(nodo->name, BAD_CAST"y") == 0) {
 378                                 y = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 379                         }
 380                 }
 381                 nodo = nodo->next;
 382         }
 383
 384         // listo, ya recolecte todos los datos, ahora creo el objeto!
 385         ViewExclusa *b = new ViewExclusa(name, orientacion);
 386         b->signal_button_press_event().connect(SigC::bind( SigC::slot(*this, &Principal::on_item_clicked), b) );
 387         b->set_position(x,y);
 388         work_place->put(*b, x, y);
 389         b->show();
 390         // los agrego al hash
 391         mapItems[name] = b;
 392 }
 393
 394 void Principal::loadTank(xmlNodePtr nodo)
 395 {
 396         Glib::ustring name = (char *)xmlGetProp(nodo, BAD_CAST"nombre");
 397         int orientacion=0, x, y;
 398
 399         nodo = nodo->children;
 400         while (nodo != NULL) {
 401                 if (nodo->type == XML_ELEMENT_NODE) {
 402                         if (xmlStrcmp(nodo->name, BAD_CAST"orientacion") == 0) {
 403                                 orientacion = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 404                         } else if (xmlStrcmp(nodo->name, BAD_CAST"x") == 0) {
 405                                 x = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 406                         } else if (xmlStrcmp(nodo->name, BAD_CAST"y") == 0) {
 407                                 y = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 408                         }
 409                 }
 410                 nodo = nodo->next;
 411         }
 412
 413         // listo, ya recolecte todos los datos, ahora creo el objeto!
 414         ViewTank *b = new ViewTank(name, orientacion);
 415         b->signal_button_press_event().connect(SigC::bind( SigC::slot(*this, &Principal::on_item_clicked), b) );
 416         b->set_position(x,y);
 417         work_place->put(*b, x, y);
 418         b->show();
 419         // los agrego al hash
 420         mapItems[name] = b;
 421 }
 422
 423 void Principal::loadUnion(xmlNodePtr nodo)
 424 {
 425         Glib::ustring name = (char *)xmlGetProp(nodo, BAD_CAST"nombre");
 426         int orientacion=0, x, y;
 427
 428         nodo = nodo->children;
 429         while (nodo != NULL) {
 430                 if (nodo->type == XML_ELEMENT_NODE) {
 431                         if (xmlStrcmp(nodo->name, BAD_CAST"orientacion") == 0) {
 432                                 orientacion = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 433                         } else if (xmlStrcmp(nodo->name, BAD_CAST"x") == 0) {
 434                                 x = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 435                         } else if (xmlStrcmp(nodo->name, BAD_CAST"y") == 0) {
 436                                 y = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 437                         }
 438                 }
 439                 nodo = nodo->next;
 440         }
 441
 442         // listo, ya recolecte todos los datos, ahora creo el objeto!
 443         ViewUnion *b = new ViewUnion(name, orientacion);
 444         b->signal_button_release_event().connect(SigC::bind( SigC::slot(*this, &Principal::on_item_clicked), b) );
 445         b->set_position(x,y);
 446         work_place->put(*b, x, y);
 447         b->show();
 448         // los agrego al hash
 449         mapItems[name] = b;
 450 }
 451
 452 void Principal::loadDrain(xmlNodePtr nodo)
 453 {
 454         Glib::ustring name = (char *)xmlGetProp(nodo, BAD_CAST"nombre");
 455         int orientacion=0, x, y;
 456
 457         nodo = nodo->children;
 458         while (nodo != NULL) {
 459                 if (nodo->type == XML_ELEMENT_NODE) {
 460                         if (xmlStrcmp(nodo->name, BAD_CAST"orientacion") == 0) {
 461                                 orientacion = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 462                         } else if (xmlStrcmp(nodo->name, BAD_CAST"x") == 0) {
 463                                 x = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 464                         } else if (xmlStrcmp(nodo->name, BAD_CAST"y") == 0) {
 465                                 y = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 466                         }
 467                 }
 468                 nodo = nodo->next;
 469         }
 470
 471         // listo, ya recolecte todos los datos, ahora creo el objeto!
 472         ViewDrain *b = new ViewDrain(name, orientacion);
 473         b->signal_button_release_event().connect(SigC::bind( SigC::slot(*this, &Principal::on_item_clicked), b) );
 474         b->set_position(x,y);
 475         work_place->put(*b, x, y);
 476         b->show();
 477         // los agrego al hash
 478         mapItems[name] = b;
 479 }
 480
 481 void Principal::read_status_xml(const std::string &frame)
 482 {
 483         std::string item_name;
 484         xmlDocPtr document;
 485         document = xmlParseMemory(frame.c_str(),frame.size());
 486         if (document == NULL) {
 487                 std::cout << "read_status_xml::no se creo documento" << std::endl;
 488                 return;
 489         }
 490
 491         xmlNodePtr nodo, items, props;
 492         nodo = document->children;
 493         float tmp;
 494
 495         if (strcmp((char *)nodo->name, "plantastatus") == 0) {
 496                 items = nodo->children;
 497                 while (items != NULL) {
 498                         tmp = -1;
 499                         if (items->type == XML_ELEMENT_NODE) {
 500                                 if (xmlStrcmp(items->name, BAD_CAST"conduct")==0) {
 501                                         tmp = get_float_from_xml(items->children);
 502                                         item_name = (char *)xmlGetProp(nodo, BAD_CAST"nombre");
 503                                         mapItems[item_name]->set_actual_flow(tmp);
 504                                 }
 505                         }
 506                         items = items->next;
 507                 }
 508         }
 509 }
 510
 511 float Principal::get_float_from_xml(xmlNodePtr nodo)
 512 {
 513         float tmp = -1;
 514         while (nodo != NULL) {
 515                 if (nodo->type == XML_ELEMENT_NODE) {
 516                         if (xmlStrcmp(nodo->name, BAD_CAST"actual_flow")==0) {
 517                                 tmp = atof( (char *)XML_GET_CONTENT(nodo->children) );
 518                                 break;
 519                         }
 520                 }
 521                 nodo = nodo->next;
 522         }
 523         return tmp;
 524 }
 525