src/StatTree.h

   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 #ifndef STATTREE_H
  27 #define STATTREE_H
  28
  29 /**
  30  * @file StatTree.h
  31  *
  32  * Interface to stat tree nodes.
  33  *
  34  * This file defines various classes representing
  35  * statistics tree nodes.
  36  */
  37
  38
  39 #ifndef EC_REMOTE       // i.e. not CLIENT_GUI
  40 #       define VIRTUAL virtual
  41 #else
  42 #       define VIRTUAL
  43 #endif
  44
  45
  46 #include <list>                 // Needed for std::list
  47 #include <wx/string.h>          // Needed for wxString
  48 #include <wx/thread.h>          // Needed for wxMutex
  49
  50 #ifndef EC_REMOTE
  51
  52 #include <wx/datetime.h>        // Needed for wxDateTime
  53 #include "GetTickCount.h"       // Needed for GetTickCount64()
  54
  55
  56 /**
  57  * Stat tree flags
  58  */
  59 enum EStatTreeFlags
  60 {
  61         stNone          = 0,            ///< Nothing. Really.
  62         stSortChildren  = 1,            ///< Childrens are sorted descending by their ID.
  63         stShowPercent   = 2,            /*!< Shows percentage compared to parent.
  64                                          *   Counters only, whose parent is also counter! (khmm...)
  65                                          */
  66         stHideIfZero    = 4,            ///< Hides item (and children) if value is zero.
  67         stSortByValue   = 8,            /*!< Together with stSortChildren, sorts children by their value.
  68                                          *   WARNING! This assumes that value-sorted children are
  69                                          *   counters!
  70                                          *   Sort-by-value works only on children with ID between 0x00000100-0x7fffffff.
  71                                          *   @note CStatTreeItemBase::ReSortChildren() must be called to get sort order right.
  72                                          */
  73         stCapChildren   = 16            ///< Caps children list.
  74                                         /*!< Shows only top n children, where n is set by CStatisticsDlg::FillTree() to thePrefs::GetMaxClientVersions().
  75                                          *   The list itself is not changed, only visibility is ignored on items
  76                                          *   outside the top n visible.
  77                                          *
  78                                          *   On an EC request, visibility range can be set with the EC_TAG_STATTREE_CAPPING tag.
  79                                          */
  80 };
  81
  82 enum EValueType
  83 {
  84         vtUnknown,
  85         vtString,
  86         vtInteger,
  87         vtFloat
  88 };
  89
  90 /**
  91  * Display modes for Simple and Counter items
  92  */
  93 enum EDisplayMode
  94 {
  95         dmDefault,              ///< Default display mode.
  96         dmTime,                 ///< Treat integer value as time in seconds.
  97         dmBytes                 ///< Treat integer value as bytes count.
  98 };
  99
 100 #endif /* !EC_REMOTE */
 101
 102
 103 class CStatTreeItemBase;
 104 typedef std::list<CStatTreeItemBase*>::iterator StatTreeItemIterator;
 105
 106
 107 class CECTag;
 108
 109 uint32_t NewStatTreeItemId();
 110
 111
 112 /**
 113  * Base tree item class
 114  */
 115 class CStatTreeItemBase
 116 {
 117 public:
 118
 119 #ifndef EC_REMOTE
 120         /**
 121          * Creates an item with a constant label.
 122          *
 123          * @param label Visible text for the item.
 124          * @param flags Flags to use.
 125          */
 126         CStatTreeItemBase(const wxString &label, unsigned flags = stNone)
 127                 : m_label(label), m_parent(NULL), m_flags(flags), m_id(0),
 128                 m_uniqueid(NewStatTreeItemId())
 129                 {}
 130 #else
 131         /**
 132          * Creates an item with a constant label.
 133          *
 134          * @param label Visible text for the item.
 135          */
 136         CStatTreeItemBase(const wxString &label, uint32_t uniqueid)
 137                 : m_label(label), m_uniqueid(uniqueid)
 138                 {}
 139
 140         /**
 141          * Creates an item (and the whole subtree) from an EC tag.
 142          *
 143          * @param tag EC tag containing a stat subtree.
 144          */
 145         CStatTreeItemBase(const CECTag *tag);
 146 #endif
 147
 148         /**
 149          * Deletes all children.
 150          */
 151         VIRTUAL ~CStatTreeItemBase();
 152
 153 #ifndef EC_REMOTE
 154         /**
 155          * Adds a new child node.
 156          *
 157          * @param child child to add.
 158          * @param id    an optional ID for the new item.
 159          * @param skipOneLevel activates a trick to let the code work for aMule OSInfo and Version trees.
 160          *
 161          * @return the newly added item.
 162          */
 163         CStatTreeItemBase *AddChild(
 164                 CStatTreeItemBase* child,
 165                 uint32_t id = 0,
 166                 bool skipOneLevel = false);
 167 #endif
 168
 169         /**
 170          * Check for children.
 171          *
 172          * @return true if this node has children, false otherwise.
 173          */
 174         bool HasChildren() { wxMutexLocker lock(m_lock); return !m_children.empty(); }
 175
 176         /**
 177          * Check for visible children.
 178          *
 179          * @return true if this node has children and at least one of them is visible.
 180          */
 181         bool HasVisibleChildren();
 182
 183 #ifndef EC_REMOTE
 184
 185         /**
 186          * Check for a given child.
 187          *
 188          * @return true if this node has a child with the given ID.
 189          */
 190         bool HasChildWithId(uint32_t id);
 191
 192         /**
 193          * Access a specific child.
 194          *
 195          * @return the child with the given ID, or NULL if not found.
 196          */
 197         CStatTreeItemBase *GetChildById(uint32_t id);
 198
 199         /**
 200          * Get the first visible child.
 201          *
 202          * @param max_children The maximum number of children to show, when the stCapChildren flag is set. Otherwise it has no effect. (0 = unlimited)
 203          *
 204          * @return An iterator, that should be passed to GetNextVisibleChild() and IsAtEndOfList().
 205          */
 206         StatTreeItemIterator GetFirstVisibleChild(uint32_t max_children);
 207
 208         /**
 209          * Get the next visible child.
 210          */
 211         void GetNextVisibleChild(StatTreeItemIterator& it);
 212
 213 #else /* EC_REMOTE */
 214
 215         /**
 216          * Get the first visible child.
 217          *
 218          * @return An iterator, that should be passed to GetNextVisibleChild() and IsAtEndOfList().
 219          *
 220          * @note On a remote list every item is visible.
 221          */
 222         StatTreeItemIterator GetFirstVisibleChild() { return m_children.begin(); }
 223
 224         /**
 225          * Get the next visible child.
 226          *
 227          * @note On a remote list every item is visible.
 228          */
 229         void GetNextVisibleChild(StatTreeItemIterator& it) { ++it; }
 230
 231 #endif /* !EC_REMOTE / EC_REMOTE */
 232
 233         /**
 234          * Check if we are past the end of child list.
 235          */
 236         bool IsAtEndOfList(StatTreeItemIterator& it) { return it == m_children.end(); }
 237
 238 #ifndef EC_REMOTE
 239         /**
 240          * Resorts children for the stSortByValue flag.
 241          */
 242         void ReSortChildren() { wxMutexLocker lock(m_lock); m_children.sort(ValueSort); }
 243 #endif
 244
 245 #ifndef AMULE_DAEMON
 246 #ifndef EC_REMOTE
 247         /**
 248          * Returns a string that will be displayed on the GUI tree.
 249          */
 250         virtual wxString GetDisplayString() const;
 251 #else
 252         /**
 253          * Returns the associated text (GUI item label).
 254          */
 255         const wxString& GetDisplayString() const { return m_label; }
 256 #endif /* !EC_REMOTE / EC_REMOTE */
 257
 258         /**
 259          * Returns the mutex used to lock the child list of this node.
 260          *
 261          * This function is used by CStatisticsDlg to be able to lock the
 262          * core tree while updating the GUI tree.
 263          */
 264         wxMutex& GetLock() { return m_lock; }
 265
 266         /**
 267          * Returns the unique ID of this node.
 268          */
 269         uint32_t GetUniqueId() const { return m_uniqueid; }
 270 #endif /* !AMULE_DAEMON */
 271
 272         /**
 273          * Check whether this node is visible.
 274          */
 275         VIRTUAL bool IsVisible() const { return true; }
 276
 277 #ifndef EC_REMOTE
 278         /**
 279          * Create an EC tag from this node (and children).
 280          *
 281          * @param max_children The maximum number of children to show, when the stCapChildren flag is set. Otherwise it has no effect. (0 = unlimited)
 282          *
 283          * @return A EC tag containing this node and all its children.
 284          */
 285         virtual CECTag *CreateECTag(uint32_t max_children);
 286 #endif
 287
 288 protected:
 289
 290 #ifndef EC_REMOTE
 291         /**
 292          * Add values to the EC tag being generated.
 293          *
 294          * Should have a real implementation in children which have some value.
 295          * The given parameter is the tag to which values should be added.
 296          */
 297         virtual void AddECValues(CECTag*) const {}
 298 #endif
 299
 300         //! Unformatted and untranslated label of the node. Note: On remote gui it is already formatted and translated.
 301         const wxString m_label;
 302 #ifndef EC_REMOTE
 303
 304         //! Parent of this node.
 305         CStatTreeItemBase *m_parent;
 306
 307         //! Flags for the node.
 308         unsigned m_flags;
 309 #endif
 310
 311 private:
 312
 313 #ifndef EC_REMOTE
 314         //! Function used when sorting children by value.
 315         static bool ValueSort(CStatTreeItemBase* a, CStatTreeItemBase* b);
 316
 317         //! ID of this node.
 318         uint32_t m_id;
 319
 320         //! Counter to keep track of displayed visible items
 321         // (needed for the stCapChildren flag)
 322         uint32_t m_visible_counter;
 323 #endif
 324
 325         //! Unique ID of this node.
 326         uint32_t m_uniqueid;
 327
 328         //! Children of this node.
 329         std::list<CStatTreeItemBase*>   m_children;
 330
 331         //! Lock to protect list from simultanous access.
 332         wxMutex m_lock;
 333 };
 334
 335
 336 //
 337 // Anything below is only for core.
 338 //
 339 #ifndef EC_REMOTE
 340
 341 /**
 342  * Simple tree item.
 343  *
 344  * This tree item has one value and nothing speciality. :)
 345  * The value might be an arbitrary integer or floating point type,
 346  * or a wxString string.
 347  *
 348  * The item is able to display value in different formats, see SetDisplayMode().
 349  *
 350  * @note that you have to specify the right format code on 'label', i.e.:
 351  * %s for string and integers with displayMode dmTime or dmBytes,
 352  * %u or similar for integers, and
 353  * %f or similar for floating point types.
 354  *
 355  * @note You have to call SetValue() after creation for non-integer values, otherwise
 356  * you'll get undesired results.
 357  */
 358 class CStatTreeItemSimple : public CStatTreeItemBase
 359 {
 360 public:
 361
 362         /**
 363          * Constructor.
 364          *
 365          * @see CStatTreeItemBase::CStatTreeItemBase
 366          */
 367         CStatTreeItemSimple(
 368                 const wxString &label,
 369                 unsigned flags = stNone,
 370                 enum EDisplayMode displaymode = dmDefault)
 371         :
 372         CStatTreeItemBase(label, flags),
 373         m_valuetype(vtUnknown),
 374         m_displaymode(displaymode)
 375         {
 376                 SetValue((uint64_t)0);
 377         }
 378
 379         /**
 380          * Sets the desired display mode of value.
 381          */
 382         void SetDisplayMode(enum EDisplayMode mode)
 383         {
 384                 m_displaymode = mode;
 385         }
 386
 387         /**
 388          * Sets an integer type value.
 389          *
 390          * @param value the value to be set.
 391          */
 392         void SetValue(uint64_t value)
 393         {
 394                 m_valuetype = vtInteger;
 395                 m_intvalue = value;
 396         }
 397
 398         /**
 399          * Sets a floating point type value.
 400          *
 401          * @param value the value to be set.
 402          */
 403         void SetValue(double value)
 404         {
 405                 m_valuetype = vtFloat;
 406                 m_floatvalue = value;
 407         }
 408
 409         /**
 410          * Sets a string type value.
 411          *
 412          * @param value the value to be set.
 413          */
 414         void SetValue(const wxString& value)
 415         {
 416                 m_valuetype = vtString;
 417                 m_stringvalue = value;
 418         }
 419
 420 #ifndef AMULE_DAEMON
 421         /**
 422          * @see CStatTreeItemBase::GetDisplayString()
 423          */
 424         virtual wxString GetDisplayString() const;
 425 #endif
 426
 427         /**
 428          * @see CStatTreeItemBase::IsVisible()
 429          */
 430         virtual bool IsVisible() const;
 431
 432 protected:
 433         /**
 434          * Add values to EC tag being generated.
 435          *
 436          * @param tag The tag to which values should be added.
 437          *
 438          * @see CStatTreeItemBase::AddECValues
 439          */
 440         virtual void AddECValues(CECTag *tag) const;
 441
 442         //! Type of the value.
 443         enum EValueType m_valuetype;
 444         //! Display mode of the value.
 445         enum EDisplayMode m_displaymode;
 446         //! Union to save space.
 447         union
 448         {
 449                 uint64_t m_intvalue;    ///< Integer value.
 450                 double   m_floatvalue;  ///< Floating point value.
 451         };
 452         wxString m_stringvalue; ///< String value.
 453 };
 454
 455
 456 /**
 457  * Counter-type tree item template.
 458  *
 459  * Able to show percentage compared to parent, hide itself
 460  * when value is zero, and nice functions for changing the value.
 461  * stShowPercent and stHideIfZero flags take effect only on
 462  * this node.
 463  */
 464 template<typename _Tp>
 465 class CStatTreeItemCounterTmpl : public CStatTreeItemBase
 466 {
 467 public:
 468         /**
 469          * Constructor.
 470          *
 471          * @see CStatTreeItemBase::CStatTreeItemBase
 472          */
 473         CStatTreeItemCounterTmpl(
 474                 const wxString &label,
 475                 unsigned flags = stNone)
 476         :
 477         CStatTreeItemBase(label, flags),
 478         m_value(0),
 479         m_displaymode(dmDefault) {}
 480
 481         /**
 482          * Retrieve counter value.
 483          */
 484         _Tp GetValue() const { return m_value; }
 485
 486         /**
 487          * Retrieve counter value.
 488          */
 489         operator _Tp() const { return m_value; }
 490
 491         /**
 492          * Set counter to given value.
 493          */
 494         void SetValue(_Tp value) { m_value = value; }
 495
 496         /**
 497          * Set counter to given value.
 498          */
 499         void operator=(_Tp value) { m_value = value; }
 500
 501         /**
 502          * Increase value by 1.
 503          */
 504         void operator++() { ++m_value; }
 505
 506         /**
 507          * Decrease value by 1.
 508          */
 509         void operator--() { --m_value; }
 510
 511         /**
 512          * Increase value by given amount.
 513          */
 514         void operator+=(_Tp value) { m_value += value; }
 515
 516         /**
 517          * Decrease value by given amount.
 518          */
 519         void operator-=(_Tp value) { m_value -= value; }
 520
 521         /**
 522          * Sets the desired display mode of value.
 523          */
 524         void SetDisplayMode(enum EDisplayMode mode) { m_displaymode = mode; }
 525
 526 #ifndef AMULE_DAEMON
 527         /**
 528          * @see CStatTreeItemBase::GetDisplayString()
 529          */
 530         virtual wxString GetDisplayString() const;
 531 #endif
 532
 533         /**
 534          * @see CStatTreeItemBase::IsVisible()
 535          */
 536         virtual bool IsVisible() const
 537         {
 538                 return (m_flags & stHideIfZero) ? (m_value != 0) : true;
 539         }
 540
 541 protected:
 542         /**
 543          * Add values to EC tag being generated.
 544          *
 545          * @param tag The tag to which values should be added.
 546          *
 547          * @see CStatTreeItemBase::AddECValues
 548          */
 549         virtual void AddECValues(CECTag *tag) const;
 550
 551         //! Actual value of the counter.
 552         _Tp m_value;
 553
 554         //! Display mode of the value.
 555         enum EDisplayMode m_displaymode;
 556 };
 557
 558 typedef CStatTreeItemCounterTmpl<uint64_t>      CStatTreeItemCounter;
 559 typedef CStatTreeItemCounterTmpl<uint32_t>      CStatTreeItemNativeCounter;
 560
 561
 562 /**
 563  * A counter, which does not display its value :P
 564  */
 565 class CStatTreeItemHiddenCounter : public CStatTreeItemCounter
 566 {
 567 public:
 568         /**
 569          * Constructor.
 570          *
 571          * @see CStatTreeItemCounter::CStatTreeItemCounter
 572          */
 573         CStatTreeItemHiddenCounter(
 574                 const wxString &label,
 575                 unsigned flags = stNone)
 576         :
 577         CStatTreeItemCounter(label, flags) {}
 578
 579 #ifndef AMULE_DAEMON
 580         /**
 581          * @see CStatTreeItemBase::GetDisplayString()
 582          */
 583         virtual wxString GetDisplayString() const
 584         {
 585                 return CStatTreeItemBase::GetDisplayString();
 586         }
 587 #endif
 588
 589         /**
 590          * @see CStatTreeItemBase::IsVisible()
 591          */
 592         virtual bool IsVisible() const { return true; }
 593
 594 protected:
 595         //! Do nothing here.
 596         virtual void AddECValues(CECTag*) const {}
 597 };
 598
 599
 600 /**
 601  * Item for the session/total upload/download counter
 602  */
 603 class CStatTreeItemUlDlCounter : public CStatTreeItemCounter
 604 {
 605 public:
 606         /**
 607          * @param label     format text for item.
 608          * @param totalfunc function that will return the totals.
 609          */
 610         CStatTreeItemUlDlCounter(
 611                 const wxString &label,
 612                 uint64_t (*totalfunc)(),
 613                 unsigned flags = stNone)
 614         :
 615         CStatTreeItemCounter(label, flags),
 616         m_totalfunc(totalfunc) {}
 617
 618 #ifndef AMULE_DAEMON
 619         /**
 620          * @see CStatTreeBase::GetDisplayString()
 621          */
 622         virtual wxString GetDisplayString() const;
 623 #endif
 624
 625 protected:
 626         /**
 627          * Add values to EC tag being generated.
 628          *
 629          * @param tag The tag to which values should be added.
 630          *
 631          * @see CStatTreeItemBase::AddECValues
 632          */
 633         virtual void AddECValues(CECTag *tag) const;
 634
 635         //! A function whose return value is the total (without current) value.
 636         uint64_t (*m_totalfunc)();
 637 };
 638
 639
 640 /**
 641  * Counter-like tree item which remembers its max value.
 642  *
 643  * Used for active connections counter, to be able to get peak connections.
 644  */
 645 class CStatTreeItemCounterMax : public CStatTreeItemBase
 646 {
 647 public:
 648         /**
 649          * @see CStatTreeItemBase::CStatTreeItemBase
 650          */
 651         CStatTreeItemCounterMax(const wxString &label)
 652         :
 653         CStatTreeItemBase(label),
 654         m_value(0),
 655         m_max_value(0)
 656         {}
 657
 658         /**
 659          * Increase value
 660          */
 661         void operator++()
 662         {
 663                 if (++m_value > m_max_value) {
 664                         m_max_value = m_value;
 665                 }
 666         }
 667
 668         /**
 669          * Decrease value
 670          */
 671         void operator--() { --m_value; }
 672
 673         /**
 674          * Retrieve actual value
 675          */
 676         uint32_t GetValue() { return m_value; }
 677
 678         /**
 679          * Retrieve max value
 680          */
 681         uint32_t GetMaxValue() { return m_max_value; }
 682
 683 #ifndef AMULE_DAEMON
 684         /**
 685          * @see CStatTreeItemBase::GetDisplayString()
 686          */
 687         virtual wxString GetDisplayString() const;
 688 #endif
 689
 690 protected:
 691         /**
 692          * Add values to EC tag being generated.
 693          *
 694          * @param tag The tag to which values should be added.
 695          *
 696          * @see CStatTreeItemBase::AddECValues
 697          */
 698         virtual void AddECValues(CECTag *tag) const;
 699
 700         //! Actual value of the counter.
 701         uint32_t m_value;
 702
 703         //! Maximal value the counter has ever reached.
 704         uint32_t m_max_value;
 705 };
 706
 707
 708 /**
 709  * Tree item for counting packets
 710  */
 711 class CStatTreeItemPackets : public CStatTreeItemBase
 712 {
 713         friend class CStatTreeItemPacketTotals;
 714
 715 public:
 716         /**
 717          * @see CStatTreeItemBase::CStatTreeItemBase
 718          */
 719         CStatTreeItemPackets(const wxString &label)
 720         :
 721         CStatTreeItemBase(label, stNone),
 722         m_packets(0),
 723         m_bytes(0) {}
 724
 725         /**
 726          * Add a packet of size 'size'.
 727          */
 728         void operator+=(long size)
 729         {
 730                 ++m_packets;
 731                 m_bytes += size;
 732         }
 733
 734 #ifndef AMULE_DAEMON
 735         /**
 736          * @see CStatTreeItemBase::GetDisplayString()
 737          */
 738         virtual wxString GetDisplayString() const;
 739 #endif
 740
 741 protected:
 742         /**
 743          * Add values to EC tag being generated.
 744          *
 745          * @param tag The tag to which values should be added.
 746          *
 747          * @see CStatTreeItemBase::AddECValues
 748          */
 749         virtual void AddECValues(CECTag *tag) const;
 750
 751         //! Total number of packets.
 752         uint32_t m_packets;
 753
 754         //! Total bytes in the packets.
 755         uint64_t m_bytes;
 756 };
 757
 758
 759 /**
 760  * Tree item for counting totals on packet counters.
 761  *
 762  * This item sums up a number of packet counters, plus adds its own values.
 763  */
 764 class CStatTreeItemPacketTotals : public CStatTreeItemPackets
 765 {
 766 public:
 767         /**
 768          * @see CStatTreeItemPackets::CStatTreeItemPackets
 769          */
 770         CStatTreeItemPacketTotals(const wxString &label)
 771         :
 772         CStatTreeItemPackets(label) {}
 773
 774         /**
 775          * Adds a packet counter, whose values should be counted in the totals.
 776          */
 777         void AddPacketCounter(CStatTreeItemPackets* counter)
 778         {
 779                 m_counters.push_back(counter);
 780         }
 781
 782 #ifndef AMULE_DAEMON
 783         /**
 784          * @see CStatTreeItemPackets::GetDisplayString()
 785          */
 786         virtual wxString GetDisplayString() const;
 787 #endif
 788
 789 protected:
 790         /**
 791          * Add values to EC tag being generated.
 792          *
 793          * @param tag The tag to which values should be added.
 794          *
 795          * @see CStatTreeItemBase::AddECValues
 796          */
 797         virtual void AddECValues(CECTag *tag) const;
 798
 799         //! List of packet counters to sum.
 800         std::vector<CStatTreeItemPackets*> m_counters;
 801 };
 802
 803
 804 /**
 805  * Tree item for timer type nodes.
 806  */
 807 class CStatTreeItemTimer : public CStatTreeItemBase
 808 {
 809 public:
 810
 811         /**
 812          * @see CStatTreeItemBase::CStatTreeItemBase
 813          */
 814         CStatTreeItemTimer(
 815                 const wxString &label,
 816                 unsigned flags = stNone)
 817         :
 818         CStatTreeItemBase(label, flags),
 819         m_value(0) {}
 820
 821         /**
 822          * Sets timer start time (and thus starts timer).
 823          */
 824         void SetStartTime(uint64_t value) { m_value = value; }
 825
 826         /**
 827          * Starts the timer if it's not running.
 828          */
 829         void StartTimer() { if (!m_value) m_value = GetTickCount64(); }
 830
 831         /**
 832          * Stops the timer.
 833          */
 834         void StopTimer() { m_value = 0; }
 835
 836         /**
 837          * Check whether the timer is running.
 838          */
 839         bool IsRunning() const { return m_value != 0; }
 840
 841         /**
 842          * Reset timer unconditionally.
 843          */
 844         void ResetTimer() { m_value = GetTickCount64(); }
 845
 846         /**
 847          * Get timer value.
 848          */
 849         uint64_t GetTimerValue() const
 850         {
 851                 return m_value ? GetTickCount64() - m_value : 0;
 852         }
 853
 854         /**
 855          * Get timer value (in ticks).
 856          */
 857         operator uint64_t() const
 858         {
 859                 return m_value ? GetTickCount64() - m_value : 0;
 860         }
 861
 862         /**
 863          * Get elapsed time in seconds.
 864          */
 865         uint64_t GetTimerSeconds() const
 866         {
 867                 return m_value ? (GetTickCount64() - m_value) / 1000 : 0;
 868         }
 869
 870         /**
 871          * Get start time of the timer.
 872          */
 873         uint64_t GetTimerStart() const { return m_value; }
 874
 875 #ifndef AMULE_DAEMON
 876         /**
 877          * @see CStatTreeItemBase::GetDisplayString()
 878          */
 879         virtual wxString GetDisplayString() const;
 880 #endif
 881
 882         /**
 883          * @see CStatTreeItemBase::IsVisible()
 884          */
 885         virtual bool IsVisible() const
 886         {
 887                 return (m_flags & stHideIfZero) ? m_value != 0 : true;
 888         }
 889
 890 protected:
 891         /**
 892          * Add values to EC tag being generated.
 893          *
 894          * @param tag The tag to which values should be added.
 895          *
 896          * @see CStatTreeItemBase::AddECValues
 897          */
 898         virtual void AddECValues(CECTag *tag) const;
 899
 900         //! Tick count value when timer was started.
 901         uint64_t m_value;
 902 };
 903
 904
 905 /**
 906  * Tree item for shared files average size.
 907  *
 908  * Average is counted as dividend / divisor, if divisor is non-zero.
 909  */
 910 class CStatTreeItemAverage : public CStatTreeItemBase
 911 {
 912 public:
 913         /**
 914          * @see CStatTreeItemBase::CStatTreeItemBase
 915          *
 916          * @param dividend What to divide.
 917          * @param divisor Divide by what.
 918          */
 919         CStatTreeItemAverage(
 920                 const wxString &label,
 921                 const CStatTreeItemCounter *dividend,
 922                 const CStatTreeItemCounter *divisor,
 923                 enum EDisplayMode displaymode)
 924         :
 925         CStatTreeItemBase(label, stNone),
 926         m_dividend(dividend),
 927         m_divisor(divisor),
 928         m_displaymode(displaymode) {}
 929
 930 #ifndef AMULE_DAEMON
 931         /**
 932          * @see CStatTreeItemBase::GetDisplayString()
 933          */
 934         virtual wxString GetDisplayString() const;
 935 #endif
 936
 937         /**
 938          * @see CStatTreeItemBase::IsVisible()
 939          */
 940         virtual bool IsVisible() const  { return (*m_divisor) != 0; }
 941
 942 protected:
 943         /**
 944          * Add values to EC tag being generated.
 945          *
 946          * @param tag The tag to which values should be added.
 947          *
 948          * @see CStatTreeItemBase::AddECValues
 949          */
 950         virtual void AddECValues(CECTag *tag) const;
 951
 952         //! What to divide.
 953         const CStatTreeItemCounter *m_dividend;
 954
 955         //! Divide by what.
 956         const CStatTreeItemCounter *m_divisor;
 957
 958         //! Display mode.
 959         enum EDisplayMode m_displaymode;
 960 };
 961
 962
 963 /**
 964  * Tree item for average up/down speed.
 965  */
 966 class CStatTreeItemAverageSpeed : public CStatTreeItemBase
 967 {
 968 public:
 969
 970         /**
 971          * @see CStatTreeItemBase::CStatTreeItemBase
 972          *
 973          * @param counter Session up/down counter.
 974          * @param timer Session uptime timer.
 975          */
 976         CStatTreeItemAverageSpeed(
 977                 const wxString &label,
 978                 const CStatTreeItemUlDlCounter *counter,
 979                 const CStatTreeItemTimer *timer)
 980         :
 981         CStatTreeItemBase(label, stNone),
 982         m_counter(counter),
 983         m_timer(timer) {}
 984
 985 #ifndef AMULE_DAEMON
 986         /**
 987          * @see CStatTreeItemBase::GetDisplayString()
 988          */
 989         virtual wxString GetDisplayString() const;
 990 #endif
 991
 992 protected:
 993         /**
 994          * Add values to EC tag being generated.
 995          *
 996          * @param tag The tag to which values should be added.
 997          *
 998          * @see CStatTreeItemBase::AddECValues
 999          */
1000         virtual void AddECValues(CECTag *tag) const;
1001
1002         //! Session sent/received bytes counter.
1003         const CStatTreeItemUlDlCounter *m_counter;
1004
1005         //! Session uptime.
1006         const CStatTreeItemTimer *m_timer;
1007 };
1008
1009
1010 /**
1011  * Tree item for displaying ratio between two counters.
1012  *
1013  * Ratio is counted as counter1:counter2.
1014  */
1015 class CStatTreeItemRatio : public CStatTreeItemBase
1016 {
1017 public:
1018         /**
1019          * @see CStatTreeItemBase::CStatTreeItemBase
1020          *
1021          * @param cnt1 First counter to use.
1022          * @param cnt2 Second counter to use.
1023          */
1024         CStatTreeItemRatio(
1025                 const wxString &label,
1026                 const CStatTreeItemCounter *cnt1,
1027                 const CStatTreeItemCounter* cnt2)
1028         :
1029         CStatTreeItemBase(label, stNone),
1030         m_counter1(cnt1),
1031         m_counter2(cnt2) {}
1032
1033 #ifndef AMULE_DAEMON
1034         /**
1035          * @see CStatTreeItemBase::GetDisplayString()
1036          */
1037         virtual wxString GetDisplayString() const;
1038 #endif
1039
1040 protected:
1041         /**
1042          * Add values to EC tag being generated.
1043          *
1044          * @param tag The tag to which values should be added.
1045          *
1046          * @see CStatTreeItemBase::AddECValues
1047          */
1048         virtual void AddECValues(CECTag *tag) const;
1049
1050         //! First counter.
1051         const CStatTreeItemCounter *m_counter1;
1052
1053         //! Second counter.
1054         const CStatTreeItemCounter *m_counter2;
1055 };
1056
1057
1058 /**
1059  * Special counter for reconnects.
1060  */
1061 class CStatTreeItemReconnects : public CStatTreeItemNativeCounter {
1062 public:
1063         /**
1064          * @see CStatTreeItemBase::CStatTreeItemBase
1065          */
1066         CStatTreeItemReconnects(const wxString &label)
1067         :
1068         CStatTreeItemNativeCounter(label, stNone) {}
1069
1070 #ifndef AMULE_DAEMON
1071         /**
1072          * @see CStatTreeItemBase::GetDisplayString()
1073          */
1074         virtual wxString GetDisplayString() const;
1075 #endif
1076
1077 protected:
1078         /**
1079          * Add values to EC tag being generated.
1080          *
1081          * @param tag The tag to which values should be added.
1082          *
1083          * @see CStatTreeItemBase::AddECValues
1084          */
1085         virtual void AddECValues(CECTag *tag) const;
1086 };
1087
1088 /**
1089  * Special item for Max Connection Limit Reached
1090  */
1091 class CStatTreeItemMaxConnLimitReached : public CStatTreeItemBase
1092 {
1093 public:
1094         /**
1095          * @see CStatTreeItemBase::CStatTreeItemBase
1096          */
1097         CStatTreeItemMaxConnLimitReached(const wxString &label)
1098         :
1099         CStatTreeItemBase(label),
1100         m_count(0) {}
1101
1102         /**
1103          * Increase counter and save time.
1104          */
1105         void operator++()
1106         {
1107                 ++m_count;
1108                 m_time.SetToCurrent();
1109         }
1110
1111 #ifndef AMULE_DAEMON
1112         /**
1113          * Returns a string to be displayed on GUI.
1114          *
1115          * For m_count == 0 it will display "Never",
1116          * for other values it will display the counter value and the
1117          * date & time of the event.
1118          */
1119         virtual wxString GetDisplayString() const;
1120 #endif
1121
1122 protected:
1123         /**
1124          * Add values to EC tag being generated.
1125          *
1126          * @param tag The tag to which values should be added.
1127          *
1128          * @see CStatTreeItemBase::AddECValues
1129          */
1130         virtual void AddECValues(CECTag *tag) const;
1131
1132         //! Number of times max conn limit reached.
1133         uint32_t m_count;
1134
1135         //! Last time when max conn limit reached.
1136         wxDateTime m_time;
1137 };
1138
1139 /**
1140  * Special item for total client count
1141  */
1142 class CStatTreeItemTotalClients : public CStatTreeItemBase
1143 {
1144 public:
1145         /**
1146          * @see CStatTreeItemBase::CStatTreeItemBase
1147          *
1148          * @param known Counter that counts known clients.
1149          * @param unknown Counter that counts unknown clients.
1150          */
1151         CStatTreeItemTotalClients(
1152                 const wxString &label,
1153                 const CStatTreeItemCounter *known,
1154                 const CStatTreeItemCounter *unknown)
1155         :
1156         CStatTreeItemBase(label),
1157         m_known(known),
1158         m_unknown(unknown) {}
1159
1160 #ifndef AMULE_DAEMON
1161         /**
1162          * @see CStatTreeItemBase::GetDisplayString()
1163          */
1164         virtual wxString GetDisplayString() const;
1165 #endif
1166
1167 protected:
1168         /**
1169          * Add values to EC tag being generated.
1170          *
1171          * @param tag The tag to which values should be added.
1172          *
1173          * @see CStatTreeItemBase::AddECValues
1174          */
1175         virtual void AddECValues(CECTag *tag) const;
1176
1177         //! Counter counting known clients.
1178         const CStatTreeItemCounter *m_known;
1179
1180         //! Counter counting unknown clients.
1181         const CStatTreeItemCounter *m_unknown;
1182 };
1183
1184 #endif /* !EC_REMOTE */
1185
1186 #endif /* STATTREE_H */
1187 // File_checked_for_headers