src/StatTree.cpp

   1 //
   2 // This file is part of the aMule Project.
   3 //
   4 // Copyright (c) 2003-2008 aMule Team ( admin@amule.org / http://www.amule.org )
   5 // Copyright (c) 2005-2008 Dévai Tamás ( gonosztopi@amule.org )
   6 //
   7 // Any parts of this program derived from the xMule, lMule or eMule project,
   8 // or contributed by third-party developers are copyrighted by their
   9 // respective authors.
  10 //
  11 // This program is free software; you can redistribute it and/or modify
  12 // it under the terms of the GNU General Public License as published by
  13 // the Free Software Foundation; either version 2 of the License, or
  14 // (at your option) any later version.
  15 //
  16 // This program is distributed in the hope that it will be useful,
  17 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 // GNU General Public License for more details.
  20 //
  21 // You should have received a copy of the GNU General Public License
  22 // along with this program; if not, write to the Free Software
  23 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
  24 //
  25
  26 #include "StatTree.h"
  27
  28 #include <wx/intl.h>
  29 #include "OtherFunctions.h"
  30
  31 #ifndef EC_REMOTE
  32
  33 #include <common/Format.h>                      // Needed for CFormat
  34
  35 #define a_brackets_b(a,b) (a + wxT(" (") + b + wxT(")"))
  36
  37 #endif /* !EC_REMOTE */
  38
  39 #include <ec/cpp/ECTag.h>                       // Needed for CECTag
  40
  41 #ifdef EC_REMOTE
  42         #include <ec/cpp/ECSpecialTags.h>       // Needed for CEC_StatTree_Node_Tag
  43 #endif
  44
  45
  46 #ifndef EC_REMOTE
  47 uint32_t NewStatTreeItemId()
  48 {
  49         static uint32_t lastid = 0;
  50
  51         return ++lastid;
  52 }
  53 #endif
  54
  55 /* CStatTreeItemBase */
  56
  57 #ifdef EC_REMOTE
  58 CStatTreeItemBase::CStatTreeItemBase(const CECTag *tag)
  59         : m_label(((CEC_StatTree_Node_Tag*)tag)->GetDisplayString())
  60           , m_uniqueid(tag->GetTagByNameSafe(EC_TAG_STATTREE_NODEID)->GetInt())
  61 {
  62         wxASSERT(tag->GetTagName() == EC_TAG_STATTREE_NODE);
  63
  64         for (size_t i = 0; i < tag->GetTagCount(); ++i) {
  65                 const CECTag *tmp = tag->GetTagByIndex(i);
  66                 if (tmp->GetTagName() == EC_TAG_STATTREE_NODE) {
  67                         m_children.push_back(new CStatTreeItemBase(tmp));
  68                 }
  69         }
  70 }
  71 #endif /* EC_REMOTE */
  72
  73 CStatTreeItemBase::~CStatTreeItemBase()
  74 {
  75         for (std::list<CStatTreeItemBase*>::iterator it = m_children.begin();
  76              it != m_children.end(); ++it) {
  77                 delete *it;
  78         }
  79         m_children.clear();
  80 }
  81
  82 #ifndef EC_REMOTE
  83 CStatTreeItemBase* CStatTreeItemBase::AddChild(
  84         CStatTreeItemBase* child,
  85         uint32_t id,
  86         bool skipOneLevel)
  87 {
  88         wxMutexLocker lock(m_lock);
  89
  90         if (skipOneLevel) {
  91                 child->m_parent = m_parent;
  92         } else {
  93                 child->m_parent = this;
  94         }
  95         child->m_id = id;
  96
  97         if (m_flags & stSortChildren) {
  98                 std::list<CStatTreeItemBase*>::iterator it = m_children.begin();
  99                 while (it != m_children.end() && id < (*it)->m_id) {
 100                         ++it;
 101                 }
 102                 m_children.insert(it, child);
 103         } else {
 104                 m_children.push_back(child);
 105         }
 106         return child;
 107 }
 108 #endif /* !EC_REMOTE */
 109
 110 bool CStatTreeItemBase::HasVisibleChildren()
 111 {
 112         wxMutexLocker lock(m_lock);
 113
 114         for (std::list<CStatTreeItemBase*>::const_iterator it = m_children.begin();
 115              it != m_children.end(); ++it) {
 116                 if ((*it)->IsVisible()) {
 117                         return true;
 118                 }
 119         }
 120         return false;
 121 }
 122
 123 #ifndef EC_REMOTE
 124 bool CStatTreeItemBase::HasChildWithId(uint32_t id)
 125 {
 126         wxMutexLocker lock(m_lock);
 127
 128         for (std::list<CStatTreeItemBase*>::const_iterator it = m_children.begin();
 129              it != m_children.end(); ++it) {
 130                 if ((*it)->m_id == id) {
 131                         return true;
 132                 }
 133         }
 134         return false;
 135 }
 136
 137 CStatTreeItemBase* CStatTreeItemBase::GetChildById(uint32_t id)
 138 {
 139         wxMutexLocker lock(m_lock);
 140
 141         for (std::list<CStatTreeItemBase*>::const_iterator it = m_children.begin();
 142              it != m_children.end(); ++it) {
 143                 if ((*it)->m_id == id) {
 144                         return *it;
 145                 }
 146         }
 147         return NULL;
 148 }
 149 #endif /* !EC_REMOTE */
 150
 151 // Note: these functions do not lock the list, because it is already locked at the time they're called
 152 #ifndef EC_REMOTE
 153 StatTreeItemIterator CStatTreeItemBase::GetFirstVisibleChild(uint32_t max_children)
 154 {
 155         StatTreeItemIterator it = m_children.begin();
 156         m_visible_counter = --max_children;
 157         while (it != m_children.end() && !(*it)->IsVisible()) ++it;
 158         return it;
 159 }
 160
 161 void CStatTreeItemBase::GetNextVisibleChild(StatTreeItemIterator& it)
 162 {
 163         if (m_flags & stCapChildren) {
 164                 if (m_visible_counter == 0) {
 165                         it = m_children.end();
 166                         return;
 167                 } else {
 168                         --m_visible_counter;
 169                 }
 170         }
 171         if (it != m_children.end()) ++it;
 172         while (it != m_children.end() && !(*it)->IsVisible()) ++it;
 173 }
 174 #endif
 175
 176 //
 177 // Anything below is only for core.
 178 //
 179 #ifndef EC_REMOTE
 180
 181 bool CStatTreeItemBase::ValueSort(const CStatTreeItemBase* a, const CStatTreeItemBase* b)
 182 {
 183         if (a->m_id < 0x00000100 || a->m_id > 0x7fffffff || b->m_id < 0x00000100 || b->m_id > 0x7fffffff) {
 184                 return a->m_id > b->m_id;
 185         } else {
 186                 return ((CStatTreeItemCounter*)a)->GetValue() > ((CStatTreeItemCounter*)b)->GetValue();
 187         }
 188 }
 189
 190 #ifndef AMULE_DAEMON
 191 wxString CStatTreeItemBase::GetDisplayString() const
 192 {
 193         return wxGetTranslation(m_label);
 194 }
 195 #endif
 196
 197 CECTag *CStatTreeItemBase::CreateECTag(uint32_t max_children)
 198 {
 199         if (IsVisible()) {
 200                 wxMutexLocker lock(m_lock);
 201                 CECTag *tag = new CECTag(EC_TAG_STATTREE_NODE, m_label);
 202                 tag->AddTag(CECTag(EC_TAG_STATTREE_NODEID, m_uniqueid));
 203                 AddECValues(tag);
 204                 m_visible_counter = max_children - 1;
 205                 for (std::list<CStatTreeItemBase*>::const_iterator it = m_children.begin();
 206                      it != m_children.end(); ++it) {
 207                         CECTag *tmp = (*it)->CreateECTag(max_children);
 208                         if (tmp) {
 209                                 tag->AddTag(*tmp);
 210                                 delete tmp;
 211                                 if (m_flags & stCapChildren) {
 212                                         if (m_visible_counter == 0) {
 213                                                 break;
 214                                         } else {
 215                                                 --m_visible_counter;
 216                                         }
 217                                 }
 218                         }
 219                 }
 220                 return tag;
 221         } else {
 222                 return NULL;
 223         }
 224 }
 225
 226
 227 /* CStatTreeItemSimple */
 228
 229 #ifndef AMULE_DAEMON
 230 wxString CStatTreeItemSimple::GetDisplayString() const
 231 {
 232         switch (m_valuetype) {
 233                 case vtInteger:
 234                         switch (m_displaymode) {
 235                                 case dmTime:    return CFormat(wxGetTranslation(m_label)) % CastSecondsToHM(m_intvalue);
 236                                 case dmBytes:   return CFormat(wxGetTranslation(m_label)) % CastItoXBytes(m_intvalue);
 237                                 default:        return CFormat(wxGetTranslation(m_label)) % m_intvalue;
 238                         }
 239                 case vtFloat:   return wxString::Format(wxGetTranslation(m_label), m_floatvalue);
 240                 case vtString:  return CFormat(wxGetTranslation(m_label)) % m_stringvalue;
 241                 default:        return wxGetTranslation(m_label);
 242         }
 243 }
 244 #endif
 245
 246 bool CStatTreeItemSimple::IsVisible() const
 247 {
 248         if (m_flags & stHideIfZero) {
 249                 switch (m_valuetype) {
 250                         case vtInteger: return m_intvalue != 0;
 251                         case vtFloat:   return m_floatvalue != 0.0;
 252                         case vtString:  return !m_stringvalue.IsEmpty();
 253                         default: return false;
 254                 }
 255         }
 256         return true;
 257 }
 258
 259 void CStatTreeItemSimple::AddECValues(CECTag *tag) const
 260 {
 261         switch (m_valuetype) {
 262                 case vtInteger: {
 263                          if (m_displaymode == dmTime) {
 264                                  CECTag value(EC_TAG_STAT_NODE_VALUE, (uint32)m_intvalue);
 265                                  value.AddTag(CECTag(EC_TAG_STAT_VALUE_TYPE, (uint8)EC_VALUE_TIME));
 266                                  tag->AddTag(value);
 267                          } else {
 268                                  CECTag value(EC_TAG_STAT_NODE_VALUE, (uint64)m_intvalue);
 269                                  if (m_displaymode == dmBytes) {
 270                                          value.AddTag(CECTag(EC_TAG_STAT_VALUE_TYPE, (uint8)EC_VALUE_BYTES));
 271                                  }
 272                                  tag->AddTag(value);
 273                          }
 274                          break;
 275                 }
 276                 case vtFloat: {
 277                         CECTag value(EC_TAG_STAT_NODE_VALUE, m_floatvalue);
 278                         value.AddTag(CECTag(EC_TAG_STAT_VALUE_TYPE, (uint8)EC_VALUE_DOUBLE));
 279                         tag->AddTag(value);
 280                         break;
 281                 }
 282                 case vtString: {
 283                         CECTag value(EC_TAG_STAT_NODE_VALUE, m_stringvalue);
 284                         value.AddTag(CECTag(EC_TAG_STAT_VALUE_TYPE, (uint8)EC_VALUE_STRING));
 285                         tag->AddTag(value);
 286                         break;
 287                 }
 288                 default:
 289                         break;
 290         }
 291 }
 292
 293
 294 /* CStatTreeItemCounterTmpl */
 295
 296 #ifndef AMULE_DAEMON
 297 template<typename _Tp>
 298 wxString CStatTreeItemCounterTmpl<_Tp>::GetDisplayString() const
 299 {
 300         wxString my_label = wxGetTranslation(m_label);
 301         // This is needed for client names, for example
 302         if (my_label == m_label) {
 303                 if (m_label.Right(4) == wxT(": %s")) {
 304                         my_label = wxGetTranslation(
 305                                 m_label.Mid(0, m_label.Length() - 4)) +
 306                                 wxString(wxT(": %s"));
 307                 }
 308         }
 309         CFormat label(my_label);
 310         if (m_displaymode == dmBytes) {
 311                 return label % CastItoXBytes(m_value);
 312         } else {
 313                 wxString result = CFormat(wxT("%u")) % m_value;
 314                 if ((m_flags & stShowPercent) && m_parent) {
 315                         result.append(wxString::Format(wxT(" (%.2f%%)"),
 316                                 ((double)m_value / ((CStatTreeItemCounterTmpl<_Tp>*)m_parent)->m_value) * 100.0));
 317                 }
 318                 return label % result;
 319         }
 320 }
 321
 322 template wxString CStatTreeItemCounter::GetDisplayString() const;
 323 template wxString CStatTreeItemNativeCounter::GetDisplayString() const;
 324
 325 #endif
 326
 327 template<typename _Tp>
 328 void CStatTreeItemCounterTmpl<_Tp>::AddECValues(CECTag *tag) const
 329 {
 330         CECTag value(EC_TAG_STAT_NODE_VALUE, (uint64)m_value);
 331         if (m_displaymode == dmBytes) {
 332                 value.AddTag(CECTag(EC_TAG_STAT_VALUE_TYPE, (uint8)EC_VALUE_BYTES));
 333         } else {
 334                 value.AddTag(CECTag(EC_TAG_STAT_VALUE_TYPE, (uint8)EC_VALUE_ISTRING));
 335                 if ((m_flags & stShowPercent) && m_parent) {
 336                         CECTag tmp(EC_TAG_STAT_NODE_VALUE,
 337                                 ((double)m_value / ((CStatTreeItemCounterTmpl<_Tp>*)m_parent)->m_value) * 100.0);
 338                         tmp.AddTag(CECTag(EC_TAG_STAT_VALUE_TYPE, (uint8)EC_VALUE_DOUBLE));
 339                         value.AddTag(tmp);
 340                 }
 341         }
 342         tag->AddTag(value);
 343 }
 344
 345 template void CStatTreeItemCounter::AddECValues(CECTag *tag) const;
 346 template void CStatTreeItemNativeCounter::AddECValues(CECTag *tag) const;
 347
 348 /* CStatTreeItemUlDlCounter */
 349
 350 #ifndef AMULE_DAEMON
 351 wxString CStatTreeItemUlDlCounter::GetDisplayString() const
 352 {
 353         return CFormat(wxGetTranslation(m_label)) %
 354                 a_brackets_b(CastItoXBytes(m_value), CastItoXBytes(m_value + m_totalfunc()));
 355 }
 356 #endif
 357
 358 void CStatTreeItemUlDlCounter::AddECValues(CECTag *tag) const
 359 {
 360         CECTag value(EC_TAG_STAT_NODE_VALUE, m_value);
 361         value.AddTag(CECTag(EC_TAG_STAT_VALUE_TYPE, (uint8)EC_VALUE_BYTES));
 362         CECTag tmp(EC_TAG_STAT_NODE_VALUE, m_value + m_totalfunc());
 363         tmp.AddTag(CECTag(EC_TAG_STAT_VALUE_TYPE, (uint8)EC_VALUE_BYTES));
 364         value.AddTag(tmp);
 365         tag->AddTag(value);
 366 }
 367
 368
 369 /* CStatTreeItemCounterMax */
 370
 371 #ifndef AMULE_DAEMON
 372 wxString CStatTreeItemCounterMax::GetDisplayString() const
 373 {
 374         return wxString::Format(wxGetTranslation(m_label), m_value);
 375 }
 376 #endif
 377
 378 void CStatTreeItemCounterMax::AddECValues(CECTag *tag) const
 379 {
 380         tag->AddTag(CECTag(EC_TAG_STAT_NODE_VALUE, (uint64)m_value));
 381 }
 382
 383
 384 /* CStatTreeItemPackets */
 385
 386 #ifndef AMULE_DAEMON
 387 wxString CStatTreeItemPackets::GetDisplayString() const
 388 {
 389         return CFormat(wxGetTranslation(m_label)) %
 390                 a_brackets_b(CastItoXBytes(m_bytes), CastItoIShort(m_packets));
 391 }
 392 #endif
 393
 394 void CStatTreeItemPackets::AddECValues(CECTag *tag) const
 395 {
 396         CECTag value(EC_TAG_STAT_NODE_VALUE, m_bytes);
 397         value.AddTag(CECTag(EC_TAG_STAT_VALUE_TYPE, (uint8)EC_VALUE_BYTES));
 398         CECTag tmp(EC_TAG_STAT_NODE_VALUE, (uint64)m_packets);
 399         tmp.AddTag(CECTag(EC_TAG_STAT_VALUE_TYPE, (uint8)EC_VALUE_ISHORT));
 400         value.AddTag(tmp);
 401         tag->AddTag(value);
 402 }
 403
 404
 405 /* CStatTreeItemPacketTotals */
 406
 407 #ifndef AMULE_DAEMON
 408 wxString CStatTreeItemPacketTotals::GetDisplayString() const
 409 {
 410         uint32_t tmp_packets = m_packets;
 411         uint64_t tmp_bytes = m_bytes;
 412         for (std::vector<CStatTreeItemPackets*>::const_iterator it = m_counters.begin();
 413              it != m_counters.end(); ++it) {
 414                 tmp_packets += (*it)->m_packets;
 415                 tmp_bytes += (*it)->m_bytes;
 416         }
 417
 418         return CFormat(wxGetTranslation(m_label)) %
 419                 a_brackets_b(CastItoXBytes(tmp_bytes), CastItoIShort(tmp_packets));
 420 }
 421 #endif
 422
 423 void CStatTreeItemPacketTotals::AddECValues(CECTag *tag) const
 424 {
 425         uint32_t tmp_packets = m_packets;
 426         uint64_t tmp_bytes = m_bytes;
 427         for (std::vector<CStatTreeItemPackets*>::const_iterator it = m_counters.begin();
 428              it != m_counters.end(); ++it) {
 429                 tmp_packets += (*it)->m_packets;
 430                 tmp_bytes += (*it)->m_bytes;
 431         }
 432
 433         CECTag value(EC_TAG_STAT_NODE_VALUE, tmp_bytes);
 434         value.AddTag(CECTag(EC_TAG_STAT_VALUE_TYPE, (uint8)EC_VALUE_BYTES));
 435         CECTag tmp(EC_TAG_STAT_NODE_VALUE, (uint64)tmp_packets);
 436         tmp.AddTag(CECTag(EC_TAG_STAT_VALUE_TYPE, (uint8)EC_VALUE_ISHORT));
 437         value.AddTag(tmp);
 438         tag->AddTag(value);
 439 }
 440
 441
 442 /* CStatTreeItemTimer */
 443
 444 #ifndef AMULE_DAEMON
 445 wxString CStatTreeItemTimer::GetDisplayString() const
 446 {
 447         return CFormat(wxGetTranslation(m_label)) %
 448                 CastSecondsToHM(m_value ? GetTimerSeconds() : 0);
 449 }
 450 #endif
 451
 452 void CStatTreeItemTimer::AddECValues(CECTag *tag) const
 453 {
 454         CECTag value(EC_TAG_STAT_NODE_VALUE,
 455                 m_value ? (uint32)GetTimerSeconds() : (uint32)0);
 456         value.AddTag(CECTag(EC_TAG_STAT_VALUE_TYPE, (uint8)EC_VALUE_TIME));
 457         tag->AddTag(value);
 458 }
 459
 460
 461 /* CStatTreeItemAverage */
 462
 463 #ifndef AMULE_DAEMON
 464 wxString CStatTreeItemAverage::GetDisplayString() const
 465 {
 466         if ((*m_divisor) != 0) {
 467                 switch (m_displaymode) {
 468                         case dmBytes:
 469                                 return CFormat(wxGetTranslation(m_label)) %
 470                                         CastItoXBytes((*m_dividend)/(*m_divisor));
 471                         case dmTime:
 472                                 return CFormat(wxGetTranslation(m_label)) %
 473                                         CastSecondsToHM((*m_dividend)/(*m_divisor));
 474                         default:
 475                                 return CFormat(wxGetTranslation(m_label)) %
 476                                         (CFormat(wxT("%u")) % ((uint64)(*m_dividend)/(*m_divisor))).GetString();
 477                 }
 478         } else {
 479                 return CFormat(wxGetTranslation(m_label)) % wxT("-");
 480         }
 481 }
 482 #endif
 483
 484 void CStatTreeItemAverage::AddECValues(CECTag *tag) const
 485 {
 486         if ((*m_divisor) != 0) {
 487                 uint64 data = (*m_dividend)/(*m_divisor);
 488                 if (m_displaymode == dmTime) {
 489                         CECTag value(EC_TAG_STAT_NODE_VALUE, (uint32)data);
 490                         value.AddTag(CECTag(EC_TAG_STAT_VALUE_TYPE, (uint8)EC_VALUE_TIME));
 491                         tag->AddTag(value);
 492                 } else {
 493                         CECTag value(EC_TAG_STAT_NODE_VALUE, data);
 494                         if (m_displaymode == dmBytes) {
 495                                 value.AddTag(CECTag(EC_TAG_STAT_VALUE_TYPE, (uint8)EC_VALUE_BYTES));
 496                         }
 497                         tag->AddTag(value);
 498                 }
 499         } else {
 500                 CECTag value(EC_TAG_STAT_NODE_VALUE, wxString(wxT("-")));
 501                 value.AddTag(CECTag(EC_TAG_STAT_VALUE_TYPE, (uint8)EC_VALUE_STRING));
 502                 tag->AddTag(value);
 503         }
 504 }
 505
 506
 507 /* CStatTreeItemAverageSpeed */
 508
 509 #ifndef AMULE_DAEMON
 510 wxString CStatTreeItemAverageSpeed::GetDisplayString() const
 511 {
 512         uint64 time = m_timer->GetTimerSeconds();
 513         if (time) {
 514                 return CFormat(wxGetTranslation(m_label)) % CastItoSpeed((*m_counter)/time);
 515         } else {
 516                 return CFormat(wxGetTranslation(m_label)) % CastItoSpeed(0);
 517         }
 518 }
 519 #endif
 520
 521 void CStatTreeItemAverageSpeed::AddECValues(CECTag *tag) const
 522 {
 523         uint64 time = m_timer->GetTimerSeconds();
 524         if (time) {
 525                 CECTag value(EC_TAG_STAT_NODE_VALUE, (uint32)((*m_counter)/time));
 526                 value.AddTag(CECTag(EC_TAG_STAT_VALUE_TYPE, (uint8)EC_VALUE_SPEED));
 527                 tag->AddTag(value);
 528         } else {
 529                 CECTag value(EC_TAG_STAT_NODE_VALUE, (uint32)0);
 530                 value.AddTag(CECTag(EC_TAG_STAT_VALUE_TYPE, (uint8)EC_VALUE_SPEED));
 531                 tag->AddTag(value);
 532         }
 533 }
 534
 535
 536 /* CStatTreeItemRatio */
 537
 538 wxString CStatTreeItemRatio::GetString() const
 539 {
 540         wxString ret;
 541         double v1 = m_counter1->GetValue();
 542         double v2 = m_counter2->GetValue();
 543         if (v1 > 0 && v2 > 0) {
 544                 if (v2 < v1) {
 545                         ret = CFormat(wxT("%.2f : 1")) % (v1 / v2);
 546                 } else {
 547                         ret = CFormat(wxT("1 : %.2f")) % (v2 / v1);
 548                 }
 549
 550                 if (m_totalfunc1 && m_totalfunc2) {
 551                         double t1 = m_totalfunc1() + v1;
 552                         double t2 = m_totalfunc2() + v2;
 553                         if (t2 < t1) {
 554                                 ret += CFormat(wxT(" (%.2f : 1)")) % (t1 / t2);
 555                         } else {
 556                                 ret += CFormat(wxT(" (1 : %.2f)")) % (t2 / t1);
 557                         }
 558                 }
 559         } else {
 560                 ret = _("Not available");
 561         }
 562         return ret;
 563 }
 564
 565 #ifndef AMULE_DAEMON
 566 wxString CStatTreeItemRatio::GetDisplayString() const
 567 {
 568         return CFormat(wxGetTranslation(m_label)) % GetString();
 569 }
 570 #endif
 571
 572 void CStatTreeItemRatio::AddECValues(CECTag *tag) const
 573 {
 574         CECTag value(EC_TAG_STAT_NODE_VALUE, GetString());
 575         value.AddTag(CECTag(EC_TAG_STAT_VALUE_TYPE, (uint8)EC_VALUE_STRING));
 576         tag->AddTag(value);
 577 }
 578
 579
 580 /* CStatTreeItemReconnects */
 581
 582 #ifndef AMULE_DAEMON
 583 wxString CStatTreeItemReconnects::GetDisplayString() const
 584 {
 585         return CFormat(wxGetTranslation(m_label)) % (m_value ? m_value - 1 : 0);
 586 }
 587 #endif
 588
 589 void CStatTreeItemReconnects::AddECValues(CECTag *tag) const
 590 {
 591         tag->AddTag(CECTag(EC_TAG_STAT_NODE_VALUE,
 592                 m_value ? (uint64)(m_value - 1) : (uint64)0));
 593 }
 594
 595 /* CStatTreeItemMaxConnLimitReached */
 596
 597 #ifndef AMULE_DAEMON
 598 wxString CStatTreeItemMaxConnLimitReached::GetDisplayString() const
 599 {
 600         if (m_count) {
 601                 return CFormat(wxGetTranslation(m_label)) %
 602                         (wxString::Format(wxT("%i : "), m_count) +
 603                                 m_time.FormatISODate() +
 604                                 wxT(" ") +
 605                                 m_time.FormatISOTime());
 606         } else {
 607                 return CFormat(wxGetTranslation(m_label)) % _("Never");
 608         }
 609 }
 610 #endif
 611
 612 void CStatTreeItemMaxConnLimitReached::AddECValues(CECTag *tag) const
 613 {
 614         wxString result;
 615         if (m_count) {
 616                 result = wxString::Format(wxT("%i : "), m_count) +
 617                         m_time.FormatISODate() +
 618                         wxT(" ") +
 619                         m_time.FormatISOTime();
 620         } else {
 621                 result = wxTRANSLATE("Never");
 622         }
 623         CECTag value(EC_TAG_STAT_NODE_VALUE, result);
 624         value.AddTag(CECTag(EC_TAG_STAT_VALUE_TYPE, (uint8)EC_VALUE_STRING));
 625         tag->AddTag(value);
 626 }
 627
 628 /* CStatTreeItemTotalClients */
 629
 630 #ifndef AMULE_DAEMON
 631 wxString CStatTreeItemTotalClients::GetDisplayString() const
 632 {
 633         return CFormat(wxGetTranslation(m_label)) %
 634                 (m_known->GetValue() + m_unknown->GetValue()) %
 635                 m_known->GetValue();
 636 }
 637 #endif
 638
 639 void CStatTreeItemTotalClients::AddECValues(CECTag *tag) const
 640 {
 641         CECTag value1(EC_TAG_STAT_NODE_VALUE,
 642                 (uint64)(m_known->GetValue() + m_unknown->GetValue()));
 643         tag->AddTag(value1);
 644         CECTag value2(EC_TAG_STAT_NODE_VALUE,
 645                 (uint64)m_known->GetValue());
 646         tag->AddTag(value2);
 647 }
 648
 649 #endif /* !EC_REMOTE */
 650 // File_checked_for_headers