[aptitude @ Import the Subversion repository into darcs.]

1 files changed, 154 insertions, 0 deletions

diff --git a/src/pkg_tree.h b/src/pkg_tree.h
new file mode 100644
index 00000000..bc61c4e2
--- /dev/null
+++ b/src/pkg_tree.h
@@ -0,0 +1,154 @@
+// pkg_tree.h      -*-c++-*-
+//
+//  Copyright 1999-2002, 2004-2005 Daniel Burrows
+//
+//  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; see the file COPYING.  If not, write to
+//  the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+//  Boston, MA 02111-1307, USA.
+//
+//  Uses the vs_tree classes to display a tree containing packages.  A generic
+// version of this, suitable only for displaying the current state of the
+// package cache, is provided; it can be extended as needed.
+
+#ifndef PKG_TREE_H
+#define PKG_TREE_H
+
+#include "apt_undo_tree.h"
+
+#include <apt-pkg/pkgcache.h>
+
+class OpProgress;
+
+class pkg_grouppolicy;
+class pkg_grouppolicy_factory;
+class pkg_sortpolicy;
+class pkg_tree_node;
+class undo_group;
+
+class pkg_tree:public apt_undo_tree
+{
+  /** If \b true, the tree is fully initialized: in particular,
+   *  the cache-reload signals are connected up.
+   */
+  bool initialized;
+
+  pkg_grouppolicy_factory *grouping;
+  std::string groupingstr;
+  pkg_sortpolicy *sorting;
+
+  pkg_matcher *limit;
+  std::wstring limitstr;
+  // Defines the limits on the display (what packages will be allowed
+  // to be displayed)  This could be a grouping policy, but hardcoding the
+  // filter here makes it easier to alter from the UI.
+
+  static vs_editline::history_list limit_history, grouping_history,
+    sorting_history;
+
+  void handle_cache_close();
+
+  /** Set up the limit and handle a few other things. */
+  void init(const char *limitstr);
+
+protected:
+  virtual bool handle_key(const key &k);
+
+  pkg_tree(const std::string &groupingstr,
+	   pkg_grouppolicy_factory *_grouping,
+	   const std::wstring &limitstr);
+
+  pkg_tree(const std::string &groupingstr,
+	   pkg_grouppolicy_factory *_grouping);
+public:
+  /** Initialize a package tree, but don't build it.  The caller
+   *  should call build_tree().  The main reason to do this is so you
+   *  can connect up the tree's signals before building it.
+   */
+  static ref_ptr<pkg_tree>
+  create(const std::string &groupingstr,
+	 pkg_grouppolicy_factory *grouping,
+	 const std::wstring &limitstr)
+  {
+    ref_ptr<pkg_tree> rval(new pkg_tree(groupingstr, grouping, limitstr));
+    rval->decref();
+    return rval;
+  }
+
+  /** Initialize a package tree, but don't build it.  The caller
+   *  should call build_tree().  The main reason to do this is so you
+   *  can connect up the tree's signals before building it.
+   *
+   *  The default tree limit is used.
+   */
+  static ref_ptr<pkg_tree>
+  create(const std::string &groupingstr,
+	 pkg_grouppolicy_factory *grouping)
+  {
+    ref_ptr<pkg_tree> rval(new pkg_tree(groupingstr, grouping));
+    rval->decref();
+    return rval;
+  }
+
+  // Should you be able to just pass in a string (?)
+  ~pkg_tree();
+
+  /** Rebuilds the tree.  If the new tree would be empty, keeps the
+   *  current tree and returns \b false.
+   *
+   *  \param progress a progress bar with which to show the progress
+   *  of the rebuild.
+   *
+   *  \return true iff the rebuild was successful.
+   */
+  bool build_tree(OpProgress &progress);
+
+  /** Rebuilds the tree.  If the new tree would be empty, keeps the
+   *  current tree and returns \b false.  Generates a new progress bar
+   *  using gen_progress_bar().
+   *
+   *  \return true iff the rebuild was successful.
+   */
+  bool build_tree();
+
+  void set_grouping(pkg_grouppolicy_factory *_grouping);
+  void set_grouping(const std::wstring &s);
+  void set_sorting(pkg_sortpolicy *_sorting);
+  void set_sorting(const std::wstring &s);
+  void set_limit(const std::wstring &_limit);
+  // Selects a new limit and rebuilds the tree.
+  std::wstring get_limit_str() {return limitstr;}
+
+  /** Return \b true. */
+  bool find_limit_enabled();
+
+  /** Pop up the limit selection dialog. */
+  bool find_limit();
+
+  /** Return \b true if a limit is already set. */
+  bool find_reset_limit_enabled();
+
+  /** Reset the limit. */
+  bool find_reset_limit();
+
+  // Local bindings:
+  static keybindings *bindings;
+  static void init_bindings();
+
+  sigc::signal2<void, const pkgCache::PkgIterator &, const pkgCache::VerIterator &> selected_signal;
+  sigc::signal1<void, std::wstring> selected_desc_signal;
+};
+
+typedef ref_ptr<pkg_tree> pkg_tree_ref;
+
+#endif