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

/*
   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"

// SHELL_COMMAND(gui, NetworkMonitor, toggleGUI)
//  ->setAlias("ProxyGui");


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

  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();
}



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


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

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

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

void ProxyWidget::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);
}


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


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();
  }



}



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()
{}