source: orxonox.OLD/branches/proxy/src/lib/network/monitor/network_stats_widget.cc @ 9640

/*
   orxonox - the future of 3D-vertical-scrollers

   Copyright (C) 2004 orx

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

   ### File Specific:
   main-programmer: Benjamin Grauer
   co-programmer: ...
*/

//#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_

#include "network_stats_widget.h"
#include "network_monitor.h"

#include "multi_type.h"

#include "shell_command.h"

#include "loading/resource_manager.h"

// this fcuk does not work!
// SHELL_COMMAND(gui, NetworkStatsWidget, toggleGUI)
// ->setAlias("ProxyGui");


HostWidget::HostWidget(const std::string& name, const IP& ip)
    : GLGuiBox(OrxGui::Horizontal)
{
  this->setName(name);
  this->setIP(ip);

  if(_font == NULL)
    _font = new Font(ResourceManager::getInstance()->getDataDir() + "/fonts/arial.ttf", 20);

  this->_name.setFont(*_font);
  this->_name.setTextSize(15);
  this->_ip.setFont(*_font);
  this->_ip.setTextSize(15);

  this->pack(&this->_name);
  this->pack(&this->_ip);
}

void HostWidget::showing()
{
  this->_name.show();
  this->_ip.show();
}

void HostWidget::hiding()
{
  this->_name.hide();
  this->_ip.hide();
}

Font* HostWidget::_font = NULL;

//======================================================//


NodeWidget::NodeWidget(const std::string& proxyName, const IP& ip)
    : _proxyWidget(proxyName, ip)
{
  this->_clientNameWidth = 100.0f;
  this->pack(&_proxyWidget);
}

NodeWidget::NodeWidget(const NetworkNode* node)
    : _proxyWidget("node", node->getPeerInfo()->ip)
{
  this->_clientNameWidth = 100.0f;
  this->pack(&_proxyWidget);
}


void NodeWidget::addClient(const std::string& name, const IP& ip)
{
  HostWidget* newClient = new HostWidget(name, ip);
  newClient->setNameWidth(this->_clientNameWidth);

  this->pack(newClient);

  if (this->isVisible())
    newClient->show();
}

bool NodeWidget::removeClient(const IP& ip)
{
  std::vector<HostWidget*>::iterator rmIt;
  for(rmIt = this->_clients.begin(); rmIt != this->_clients.end(); ++rmIt)
  {
    if (*(*rmIt) == ip)
    {
      delete (*rmIt);
      this->_clients.erase(rmIt);
      return true;
    }
  }
  return false;
}

bool NodeWidget::removeClient(const std::string& name)
{
  std::vector<HostWidget*>::iterator rmIt;
  for(rmIt = this->_clients.begin(); rmIt != this->_clients.end(); ++rmIt)
  {
    if (*(*rmIt) == name)
    {
      delete (*rmIt);
      this->_clients.erase(rmIt);
      return true;
    }
  }
  return false;

}

bool NodeWidget::removeClient(const std::string& name, const IP& ip)
{
  std::vector<HostWidget*>::iterator rmIt;
  for(rmIt = this->_clients.begin(); rmIt != this->_clients.end(); ++rmIt)
  {
    if (*(*rmIt) == ip && *(*rmIt) == name)
    {
      delete (*rmIt);
      this->_clients.erase(rmIt);
      return true;
    }
  }
  return false;
}


void NodeWidget::setClientNameWidths(float width)
{
  this->_clientNameWidth = width;
  for (unsigned int i = 0; i < this->_clients.size(); ++i)
    this->_clients[i]->setNameWidth(width);
}

void NodeWidget::hiding()
{
  this->_proxyWidget.hide();
  for (unsigned int i = 0; i < this->_clients.size(); ++i)
    this->_clients[i]->hide();
}

void NodeWidget::showing()
{
  this->_proxyWidget.show();
  for (unsigned int i = 0; i < this->_clients.size(); ++i)
    this->_clients[i]->show();
}


//======================================================//

/**
 * @brief standard constructor
 */
NetworkStatsWidget::NetworkStatsWidget(const NetworkMonitor* monitor)
    : OrxGui::GLGuiFixedpositionBox(OrxGui::Center, OrxGui::Vertical), _thisHost("myName", IP(127, 0, 0 , 1))
{
  this->_monitor = monitor;

  /*
  this->_bar.setSize2D(100, 30);
  this->pack(&this->_valueText);
  this->_bar.setParent2D(&this->_valueText);

  this->_valueText.setChangedTextColor(Color::white);

  //this->setBackgroundTexture("maps/gui_element_background_2.png");
  this->setBackgroundColor(Color(.5,.5,.5,1));

  //this->_name.setBackgroundTexture(Texture());
  //this->_valueText.setBackgroundTexture("maps/gui_element_background_2.png");
  this->_bar.setBackgroundTexture(Texture());
  this->_bar.setBackgroundColor(Color(0,0,0,0));
  this->_bar.setForegroundTexture("maps/gui_element_background_faded.png");
  this->_bar.setForegroundColor(Color(.5, .5, .5, 1));
  this->_bar.setChangedValueColor(Color::black);
  */
  this->_thisHostIs.setText(std::string("I am ") + _monitor->getLocalNode()->getPeerInfo()->getNodeTypeString());

  this->pack(&this->_thisHostIs);

  this->pack(&this->_thisHost);

  this->pack(&this->_upstreamText);
  this->pack(&this->_downstreamText);


  this->pack(&this->_serverBox);


  this->_refreshButton.setLabel("refresh");
  this->_refreshButton.released.connect(this, &NetworkStatsWidget::rebuild);
  this->pack(&this->_refreshButton);

  this->rebuild();
}


/**
 * @brief standard deconstructor
 */
NetworkStatsWidget::~NetworkStatsWidget ()
{}


void NetworkStatsWidget::addNode(const NetworkNode* node)
{
  this->_proxies.push_back(new NodeWidget(node));
  this->pack(this->_proxies.back(), &this->_refreshButton);
  this->_proxies.back()->show();
}




NetworkStatsWidget* NetworkStatsWidget::_statsWidget = NULL;

#include "class_list.h"

void NetworkStatsWidget::toggleGUI()
{
  BaseObject* bo = NULL;
  const std::list<BaseObject*>* ls = ClassList::getList(CL_NETWORK_MONITOR);
  if (ls != NULL && !ls->empty())
    bo = ls->front();

  if (bo != NULL && NetworkStatsWidget::_statsWidget == NULL)
  {
    NetworkStatsWidget::_statsWidget = new NetworkStatsWidget(dynamic_cast<NetworkMonitor*> (bo));
    NetworkStatsWidget::_statsWidget->showAll();
  }
  else
  {
    delete NetworkStatsWidget::_statsWidget;
    NetworkStatsWidget::_statsWidget = NULL;
  }
}


void NetworkStatsWidget::setMaximum(float max)
{
  // this->_bar.setMaximum(max);
}

void NetworkStatsWidget::setValue(float value)
{
  MultiType val(value);
  val.setType(MT_INT);
  /*

  this->_bar.setValue(value);
  this->_bar.setForegroundColor(Color::slerpHSVColor(Color::red, Color::green, value/this->_bar.maximum()));
  this->_bar.setFrontColor(Color(1,1,1,1), true);
  this->_valueText.setText(val.getString());
  */
}


void NetworkStatsWidget::addProxy(const std::string& name, const IP& proxy)
{}

void clearProxies();


void NetworkStatsWidget::rebuild()
{
  while (!this->_proxies.empty())
  {
    delete this->_proxies.back();
    this->_proxies.pop_back();
  }


  std::list<NetworkNode*>::const_iterator it = this->_monitor->getNodeList().begin();
  for(; it != this->_monitor->getNodeList().end(); it++)
  {
    this->addNode(*it);
  }



}



void NetworkStatsWidget::tick(float dt)
{
  assert (this->_monitor->getLocalNode() != NULL);
  assert(this->_monitor->getLocalNode()->getPeerInfo() != NULL);

  if(this->_monitor->getLocalNode()->getPeerInfo()->connectionMonitor != NULL)
  {
    ConnectionMonitor* mon = this->_monitor->getLocalNode()->getPeerInfo()->connectionMonitor;

    this->_upstreamText.setText(MultiType(mon->getOutgoingZippedBandWidth()).getString());
    this->_downstreamText.setText(MultiType(mon->getIncomingZippedBandWidth()).getString());
  }
}

void NetworkStatsWidget::resize()
{
  GLGuiFixedpositionBox::resize();
}


void NetworkStatsWidget::showing()
{}

void NetworkStatsWidget::hiding()
{}