* Added TextElementBranch that uses a slot as the conditional.

* Added timeout to WindowText and updated download and peer info.

* Moved default http agent string to rtorrent/configure.ac.

* Periodic syncing of chunks now tries to only sync tightly packed
  ranges of chunks unless timeout_sync has been reached.

* ChunkManager now checks if max memory is set to RLIM_INFINITY, if so
  use 2^32.

* Added safe_sync option that forces MS_SYNC to be used before
  unmapping chunks.


git-svn-id: svn://rakshasa.no/libtorrent/trunk/rtorrent@757 e378c898-3ddf-0310-93e7-cc216c733640

src/display/Makefile.am

@@ -14,6 +14,7 @@ libsub_display_a_SOURCES = \
 	utils.h \
 	text_element.h \
 	text_element_helpers.h \
+	text_element_lambda.h \
 	text_element_list.cc \
 	text_element_list.h \
 	text_element_string.cc \

src/display/text_element.h

@@ -50,6 +50,7 @@ public:
 
   static const extent_type extent_full   = ~extent_type();
 
+  TextElement() {}
   virtual ~TextElement() {}
 
   // The last element must point to a valid memory location into which
@@ -58,6 +59,10 @@ public:
   virtual char*       print(char* first, char* last, Canvas::attributes_list* attributes, void* object) = 0;
 
   virtual extent_type max_length() = 0;
+
+private:
+  TextElement(const TextElement&);
+  void operator = (const TextElement&);
 };
 
 }

src/display/text_element_helpers.h

@@ -53,6 +53,11 @@ typedef TextElementValueBase  value_base;
 
 // String stuff:
 
+inline TextElementStringBase*
+te_string(const char* str) {
+  return new display::TextElementCString(str);
+}
+
 // template <typename Object, typename Return>
 // inline TextElementStringBase*
 // te_string(Return (Object::*fptr)() const, const Object* object, int attributes = Attributes::a_invalid) {

src/display/text_element_lambda.h

@@ -0,0 +1,116 @@
+// rTorrent - BitTorrent client
+// Copyright (C) 2005-2006, Jari Sundell
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+// 
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+// In addition, as a special exception, the copyright holders give
+// permission to link the code of portions of this program with the
+// OpenSSL library under certain conditions as described in each
+// individual source file, and distribute linked combinations
+// including the two.
+//
+// You must obey the GNU General Public License in all respects for
+// all of the code used other than OpenSSL.  If you modify file(s)
+// with this exception, you may extend this exception to your version
+// of the file(s), but you are not obligated to do so.  If you do not
+// wish to do so, delete this exception statement from your version.
+// If you delete this exception statement from all source files in the
+// program, then also delete it here.
+//
+// Contact:  Jari Sundell <jaris@ifi.uio.no>
+//
+//           Skomakerveien 33
+//           3185 Skoppum, NORWAY
+
+#ifndef RTORRENT_DISPLAY_TEXT_ELEMENT_LAMBDA_H
+#define RTORRENT_DISPLAY_TEXT_ELEMENT_LAMBDA_H
+
+#include "text_element.h"
+
+namespace display {
+
+template <typename slot_type>
+class TextElementBranchVoid : public TextElement {
+public:
+  typedef typename slot_type::result_type   result_type;
+  
+  TextElementBranchVoid(const slot_type& slot, TextElement* branch1, TextElement* branch2) :
+    m_slot(slot), m_branch1(branch1), m_branch2(branch2) {}
+
+  virtual char* print(char* first, char* last, Canvas::attributes_list* attributes, void* object) {
+    if (m_slot())
+      return m_branch1 != NULL ? m_branch1->print(first, last, attributes, object) : first;
+    else
+      return m_branch2 != NULL ? m_branch2->print(first, last, attributes, object) : first;
+  }
+
+  virtual extent_type max_length() {
+    return std::max(m_branch1 != NULL ? m_branch1->max_length() : 0,
+                    m_branch2 != NULL ? m_branch2->max_length() : 0);
+  }
+
+private:
+  slot_type           m_slot;
+
+  TextElement*        m_branch1;
+  TextElement*        m_branch2;
+};
+
+template <typename slot_type>
+class TextElementBranch : public TextElement {
+public:
+  typedef typename slot_type::argument_type arg1_type;
+  typedef typename slot_type::result_type   result_type;
+  
+  TextElementBranch(const slot_type& slot, TextElement* branch1, TextElement* branch2) :
+    m_slot(slot), m_branch1(branch1), m_branch2(branch2) {}
+
+  virtual char* print(char* first, char* last, Canvas::attributes_list* attributes, void* object) {
+    if (object == NULL)
+      return first;
+
+    if (m_slot(reinterpret_cast<arg1_type>(object)))
+      return m_branch1 != NULL ? m_branch1->print(first, last, attributes, object) : first;
+    else
+      return m_branch2 != NULL ? m_branch2->print(first, last, attributes, object) : first;
+  }
+
+  virtual extent_type max_length() {
+    return std::max(m_branch1 != NULL ? m_branch1->max_length() : 0,
+                    m_branch2 != NULL ? m_branch2->max_length() : 0);
+  }
+
+private:
+  slot_type           m_slot;
+
+  TextElement*        m_branch1;
+  TextElement*        m_branch2;
+};
+
+template <typename slot_type>
+inline TextElementBranchVoid<slot_type>*
+text_element_branch_void(const slot_type& slot, TextElement* branch1, TextElement* branch2) {
+  return new TextElementBranchVoid<slot_type>(slot, branch1, branch2);
+}
+
+template <typename slot_type>
+inline TextElementBranch<slot_type>*
+text_element_branch(const slot_type& slot, TextElement* branch1, TextElement* branch2) {
+  return new TextElementBranch<slot_type>(slot, branch1, branch2);
+}
+
+}
+
+#endif

src/display/text_element_string.h

@@ -78,9 +78,9 @@ public:
   const std::string&  str() const                   { return m_string; }
   void                set_str(const std::string& s) { m_string = s; }
 
-private:
   virtual extent_type max_length()                  { return m_string.size(); }
 
+private:
   virtual char*       copy_string(char* first, char* last, void* object);
 
   std::string         m_string;
@@ -93,9 +93,9 @@ public:
     m_attributes = attributes;
   }
 
-private:
   virtual extent_type max_length()                  { return m_length; }
 
+private:
   virtual char*       copy_string(char* first, char* last, void* object);
 
   extent_type         m_length;
@@ -113,16 +113,14 @@ public:
     m_attributes = attributes;
   }
 
-private:
   virtual extent_type max_length()                  { return m_length; }
 
+private:
   virtual char* copy_string(char* first, char* last, void* object) {
-    arg1_type arg1 = reinterpret_cast<arg1_type>(object);
-
-    if (arg1 == NULL)
+    if (object == NULL)
       return first;
 
-    result_type result = m_slot(arg1);
+    result_type result = m_slot(reinterpret_cast<arg1_type>(object));
     extent_type length = std::min<extent_type>(result_length(&result), last - first);
 
     std::memcpy(first, result_buffer(&result), length);

src/display/text_element_value.h

@@ -83,9 +83,9 @@ public:
   int64_t             value() const                 { return m_value; }
   void                set_value(int64_t v)          { m_value = v; }
 
-private:
   virtual extent_type max_length()                  { return 12; }
 
+private:
   virtual int64_t     value(void* object)           { return m_value; }
 
   int64_t             m_value;
@@ -101,9 +101,9 @@ public:
     m_attributes = attributes;
   }
 
-private:
   virtual extent_type max_length()        { return 12; }
 
+private:
   virtual int64_t     value(void* object) { return m_slot(); }
 
   slot_type           m_slot;
@@ -120,16 +120,14 @@ public:
     m_attributes = attributes;
   }
 
-private:
   virtual extent_type max_length()                  { return 12; }
 
+private:
   virtual int64_t value(void* object) {
-    arg1_type arg1 = reinterpret_cast<arg1_type>(object);
-
-    if (arg1 == NULL)
+    if (object == NULL)
       return 0;
 
-    return m_slot(arg1);
+    return m_slot(reinterpret_cast<arg1_type>(object));
   }
 
   slot_type           m_slot;

src/display/window_text.cc

@@ -72,6 +72,9 @@ WindowText::push_back(TextElement* element) {
 
 void
 WindowText::redraw() {
+  if (m_interval != 0)
+    m_slotSchedule(this, (cachedTime + rak::timer::from_seconds(m_interval)).round_seconds());
+
   m_canvas->erase();
 
   unsigned int position = 0;

src/display/window_text.h

@@ -46,7 +46,7 @@ namespace display {
 
 class WindowText : public Window, public std::vector<TextElement*> {
 public:
-  typedef std::vector<TextElement*> base_type;
+  typedef std::vector<TextElement*>   base_type;
 
   typedef base_type::value_type       value_type;
   typedef base_type::reference        reference;
@@ -63,7 +63,7 @@ public:
   using base_type::rend;
 
   WindowText(void* object = NULL, extent_type margin = 0) :
-    Window(new Canvas, 0, 0, 0, extent_static, extent_static), m_object(object), m_margin(margin) {}
+    Window(new Canvas, 0, 0, 0, extent_static, extent_static), m_object(object), m_margin(margin), m_interval(0) {}
   ~WindowText() { clear(); }
 
   void                clear();
@@ -71,6 +71,9 @@ public:
   void*               object() const           { return m_object; }
   void                set_object(void* object) { m_object = object; }
 
+  uint32_t            interval() const         { return m_interval; }
+  void                set_interval(uint32_t i) { m_interval = i; }
+
   void                push_back(TextElement* element);
 
   virtual void        redraw();
@@ -79,6 +82,7 @@ private:
   void*               m_object;
 
   extent_type         m_margin;
+  uint32_t            m_interval;
 };
 
 }