---

dutree.h

Go to the documentation of this file.

/* dutree  -- Graphical display of disk useage
   Copyright (C) 1992, 1996, 2000 Free Software Foundation, Inc.
   Copyright (C) 2002 Aaron Bentley

   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, 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.  */

#if HAVE_DIRENT_H
# include <dirent.h>
#else
# define dirent direct
# if HAVE_SYS_NDIR_H
#  include <sys/ndir.h>
# endif
# if HAVE_SYS_DIR_H
#  include <sys/dir.h>
# endif
# if HAVE_NDIR_H
#  include <ndir.h>
# endif
#endif


#define DOT_OR_DOTDOT(Basename) \
  (Basename[0] == '.' && (Basename[1] == '\0' \
           || (Basename[1] == '.' && Basename[2] == '\0')))

#define xstrdup strdup
#define xrealloc realloc
/* Extract or fake data from a `struct stat'.
   ST_BLKSIZE: Preferred I/O blocksize for the file, in bytes.
   ST_NBLOCKS: Number of blocks in the file, including indirect blocks.
   ST_NBLOCKSIZE: Size of blocks used when calculating ST_NBLOCKS.  */
#ifndef HAVE_STRUCT_STAT_ST_BLOCKS
# define ST_BLKSIZE(statbuf) DEV_BSIZE
# if defined(_POSIX_SOURCE) || !defined(BSIZE) /* fileblocks.c uses BSIZE.  */
#  define ST_NBLOCKS(statbuf) \
  (S_ISREG ((statbuf).st_mode) \
   || S_ISDIR ((statbuf).st_mode) \
   ? (statbuf).st_size / ST_NBLOCKSIZE + ((statbuf).st_size % ST_NBLOCKSIZE != 0) : 0)
# else /* !_POSIX_SOURCE && BSIZE */
#  define ST_NBLOCKS(statbuf) \
  (S_ISREG ((statbuf).st_mode) \
   || S_ISDIR ((statbuf).st_mode) \
   ? st_blocks ((statbuf).st_size) : 0)
# endif /* !_POSIX_SOURCE && BSIZE */
#else /* HAVE_STRUCT_STAT_ST_BLOCKS */
/* Some systems, like Sequents, return st_blksize of 0 on pipes. */
# define ST_BLKSIZE(statbuf) ((statbuf).st_blksize > 0 \
                ? (statbuf).st_blksize : DEV_BSIZE)
# if defined(hpux) || defined(__hpux__) || defined(__hpux)
/* HP-UX counts st_blocks in 1024-byte units.
   This loses when mixing HP-UX and BSD filesystems with NFS.  */
#  define ST_NBLOCKSIZE 1024
# else /* !hpux */
#  if defined(_AIX) && defined(_I386)
/* AIX PS/2 counts st_blocks in 4K units.  */
#   define ST_NBLOCKSIZE (4 * 1024)
#  else /* not AIX PS/2 */
#   if defined(_CRAY)
#    define ST_NBLOCKS(statbuf) \
  (S_ISREG ((statbuf).st_mode) \
   || S_ISDIR ((statbuf).st_mode) \
   ? (statbuf).st_blocks * ST_BLKSIZE(statbuf)/ST_NBLOCKSIZE : 0)
#   endif /* _CRAY */
#  endif /* not AIX PS/2 */
# endif /* !hpux */
#endif /* HAVE_STRUCT_STAT_ST_BLOCKS */

#ifndef ST_NBLOCKS
# define ST_NBLOCKS(statbuf) \
  (S_ISREG ((statbuf).st_mode) \
   || S_ISDIR ((statbuf).st_mode) \
   ? (statbuf).st_blocks : 0)
#endif

#ifndef ST_NBLOCKSIZE
# define ST_NBLOCKSIZE 512
#endif

#ifndef O_DIRECTORY
# define O_DIRECTORY 0
#endif

#if CLOSEDIR_VOID
/* Fake a return value. */
# define CLOSEDIR(d) (closedir (d), 0)
#else
# define CLOSEDIR(d) closedir (d)
#endif

#if STDC_HEADERS || (!defined (isascii) && !HAVE_ISASCII)
# define IN_CTYPE_DOMAIN(c) 1
#else
# define IN_CTYPE_DOMAIN(c) isascii(c)
#endif

#define ISUPPER(c) (IN_CTYPE_DOMAIN (c) && isupper (c))

using std::cout;
using std::endl;

using SigC::slot;

struct String
{
  unsigned alloc;    /* Size of allocation for the text.  */
  unsigned length;      /* Length of the text currently.  */
  char *text;        /* Pointer to the text.  */
};
typedef struct String String;

class DirTree
{
private:
   struct exclude_st *exclude;
   String *path;
   int (*xstat) (const char *, struct stat *buf);
   int exit_status;
   uintmax_t tot_size;
   struct htab *htab;

   /* Allocate space for the hash structures, and set the global
    variable `htab' to point to it.  The initial hash module is specified in
    MODULUS, and the number of entries are specified in ENTRY_TAB_SIZE.  (The
    hash structure will be rebuilt when ENTRY_TAB_SIZE entries have been
    inserted, and MODULUS and ENTRY_TAB_SIZE in the global `htab' will be
    doubled.)  */

   void hash_init (unsigned int modulus, unsigned int entry_tab_size);
   int hash_insert2 (struct htab *ht, ino_t ino, dev_t dev);
   int hash_insert (ino_t ino, dev_t dev);
   void hash_reset (void);

   uintmax_t count_entry (const char *ent, int top, dev_t last_dev, int depth, 
   EnTree *target);
   uintmax_t propogate_up(uintmax_t size, EnTree *target);

   void init();
   Watcher<DirTree> *my_watch;
public:
   bool opt_count_all;
   bool opt_dereference_arguments;
   bool opt_one_file_system;
   bool opt_separate_dirs;
   bool opt_all;
   bool up_immediate;
   int max_depth;

   DirTree();
   void calc_EnTree(const char *target, EnTree *my_tree);
   void set_watcher(Watcher<DirTree> &my_watch);
};


class TreeView: public ImageMap, public Watcher<DirTree>, 
   public RegionWatcher<EntryRect>
{
private:
   std::auto_ptr<EnTree> my_tree;
   EnTree const *cur_tree;
   bool firsttime;
   uintmax_t oldsize;
   DirTree treeGen;
   std::auto_ptr<Drawer> dwr;
   std::auto_ptr<ColorPicker> cpick;
   bool drawing;

public:
   RecTransform rt;
   TreeView(gint x_size = 0, gint y_size = 0);

   EnTree const &get_EnTree() const;

   void set_EnTree(EnTree const &newcur);

   EnTree const &get_top_EnTree() const;

   void modified(DirTree const &moddir);

   void EnTree_rect(EnTree const *curent, bool vertical, gint x, gint y, 
      gint width, gint height);

   void draw_rect();
   
   bool isReady();

   void test_tree();

   void setDrawer(Drawer *d)
   {
      dwr.reset(d);
   }

   void set_cpick(ColorPicker *cp)
   {
      cpick.reset(cp);
   }

   Drawer *getDrawer()
   {
      return dwr.get();
   }

   gint expose_event_impl(GdkEventExpose*);

   gint delayed_calc();

   bool clicked(EntryRect const *, int button);
   virtual bool region_hover(EntryRect &region)
   {
      me_modified();
      //set_EnTree(region.get_EnTree());
      return true;
   }
};

/* Initial number of entries in each hash table entry's table of inodes.  */
#define INITIAL_HASH_MODULE 100

/* Initial number of entries in the inode hash table.  */
#define INITIAL_ENTRY_TAB_SIZE 70

/* Initial size to allocate for `path'.  */
#define INITIAL_PATH_SIZE 100

#include "commandbutton.h"
class MainWindow: public Gtk::Window, public Watcher<ImageMap>
{
private:
   Gtk::Button child_button;
   Gtk::Button next_button;
   Gtk::Button prev_button;
   Gtk::Button parent_button;
   Gtk::Label curdir;
   Gtk::VBox packer;
   Gtk::HBox buttons;
   Gtk::HBox hbox;
   Gtk::HBox buttonslabel;
   TreeView tview;
   CommandButton rbutton;
   CommandButton colorbutton;
   void nav(EnTree &en_new)
   {
      //setInfo(&en_new, tview.get_top_EnTree());
      tview.set_EnTree(en_new);
   }
   void nav_child()
   {
      EnTree *child=tview.get_EnTree().child;
      if (child!=NULL) nav(*child);
   }
   void nav_next()
   {
      EnTree *next=tview.get_EnTree().next;
      if (next!=NULL) nav(*next);
   }
   void nav_prev()
   {
      EnTree *prev=tview.get_EnTree().prev;
      if (prev!=NULL) nav(*prev);
   }
   void nav_parent()
   {
      if (! tview.isReady()) return;

      EnTree *parent=tview.get_EnTree().parent;
      if (parent!=NULL) nav(*parent);
   }
   void setInfo(EnTree const &cur, EnTree const &top);

   public:
   MainWindow();
   virtual int delete_event_impl(GdkEventAny *event);
   void modified(const ImageMap &);
   gint delayed_calc()
   {
      return false;
   }
};

struct entry
{
  ino_t ino;
  dev_t dev;
  struct entry *coll_link;
};

struct htab
{
  unsigned modulus;     /* Size of the `hash' pointer vector.  */
  struct entry *entry_tab; /* Pointer to dynamically growing vector.  */
  unsigned entry_tab_size; /* Size of current `entry_tab' allocation.  */
  unsigned first_free_entry;  /* Index in `entry_tab'.  */
  struct entry *hash[1];   /* Vector of pointers in `entry_tab'.  */
};

---