/www/proggenOrg/dedupe/export/trunk/userinterface/interface.h

/*
** Dedupe
**
** GUI Interface
**
********************************************************/

#ifndef ORG_PROGGEN_DEDUPE_GUIINTERFACE
#define ORG_PROGGEN_DEDUPE_GUIINTERFACE

#include <vector>
#include <fileinfo.h>
#include <kernel.h>

namespace Dedupe
{
  namespace GUI
  {
    namespace MainAction
    {
    enum MainAction
    {
        Track,    
        Untrack,  
        Index,    
        Manage,   
        Delete,   
        Edit,     

        Hide,     
        Show,     
        Quit      
      };
    }

    class Main
    {
      public:
        virtual void TrackFile( const Dedupe::FileInfo & file ) = 0;

        virtual void UntrackFile( const Dedupe::FileInfo & file ) = 0;

        virtual void ClearTrackedFiles() = 0;

        virtual bool IsRecursive() = 0;

      public:
        virtual int exec() = 0;

        Main( int argc, char *argv[] )
          : Kernel( ":memory:", 0, std::cout ) { /* Handle Parameters */ }
        virtual ~Main() {}

    protected:
        virtual std::vector<Dedupe::FileInfo> GetFiles() = 0;
        virtual std::vector<Dedupe::FileInfo> GetSelectedTrackedFiles() = 0;
        Dedupe::Core::Kernel Kernel;

        void OnTrack()
        {
          const std::vector<Dedupe::FileInfo> files = GetFiles();
          if( files.size() > 0 )
          {
            bool recursive = IsRecursive();
            Dedupe::FilePaths paths;
            for( unsigned int i = 0; i < files.size(); i++ )
            {
              TrackFile( files[i] );
              paths.push_back( files[i].GetPath() );
            }
            Kernel.TrackFiles( paths, recursive );
          }
        }

        void OnUntrack()
        {
          const std::vector<Dedupe::FileInfo> files = GetSelectedTrackedFiles();
          if( files.size() > 0 )
          {
            bool recursive = IsRecursive();
            Dedupe::FilePaths paths;
            for( unsigned int i = 0; i < files.size(); i++ )
            {
              UntrackFile( files[i] );
              paths.push_back( files[i].GetPath() );
            }
            Kernel.UntrackFiles( paths, recursive );
          }
        }

        void OnIndex()
        {
          ClearTrackedFiles();
          Dedupe::FileStream files = Kernel.GetDatabase();
          for( unsigned int i = 0; i < files.size(); i++ )
            TrackFile( files.at( i ).GetPath() );
        }

        void OnManage()
        {
          std::cout << "OnManage" << std::endl;
        }

        void OnDelete()
        {
          std::cout << "OnDelete" << std::endl;
        }

        void OnEdit()
        {
          std::cout << "OnEdit" << std::endl;
        }

        void OnHide()
        {
          std::cout << "Hiding window" << std::endl;
        }

        void OnShow()
        {
          std::cout << "Showing window" << std::endl;
        }

        void OnQuit()
        {
          std::cout << "Shutting down" << std::endl;
        }

    };
  }
}

#endif