src/StatTree.h

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