user_interaction.hpp

Go to the documentation of this file.

/*********************************************************************/
// dar - disk archive - a backup/restoration program
// Copyright (C) 2002-2052 Denis Corbin
//
// 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.
//
// to contact the author : http://dar.linux.free.fr/email.html
/*********************************************************************/


// IMPORTANT : THIS FILE MUST ALWAYS BE INCLUDE AFTER infinint.hpp   //
//             (and infinint.hpp must be included too, always)       //
#include "infinint.hpp"



#ifndef USER_INTERACTION_HPP
#define USER_INTERACTION_HPP

#include "../my_config.h"

#include <string>
#include "erreurs.hpp"
#include "integers.hpp"
#include "secu_string.hpp"

namespace libdar
{





    class user_interaction
    {
    public:

        user_interaction();
        virtual ~user_interaction() {};


        virtual void pause(const std::string & message)
            {
                if(!pause2(message))
                    throw Euser_abort(message);
            };


        virtual bool pause2(const std::string & message)
        { throw Elibcall("user_interaction::pause2", "user_interaction::pause() or pause2() must be overwritten !"); };


        void warning(const std::string & message);


        virtual std::string get_string(const std::string & message, bool echo) = 0;


        virtual secu_string get_secu_string(const std::string & message, bool echo) = 0;



        virtual void listing(const std::string & flag,
                             const std::string & perm,
                             const std::string & uid,
                             const std::string & gid,
                             const std::string & size,
                             const std::string & date,
                             const std::string & filename,
                             bool is_dir,
                             bool has_children);




        virtual void dar_manager_show_files(const std::string & filename,
                                            bool data_change,
                                            bool ea_change);



        virtual void dar_manager_contents(U_I number,
                                         const std::string & chemin,
                                         const std::string & archive_name);


        virtual void dar_manager_statistics(U_I number,
                                            const infinint & data_count,
                                            const infinint & total_data,
                                            const infinint & ea_count,
                                            const infinint & total_ea);


        virtual void dar_manager_show_version(U_I number,
                                              const std::string & data_date,
                                              const std::string & data_presence,
                                              const std::string & ea_date,
                                              const std::string & ea_presence);


        void printf(const char *format, ...);


        bool get_use_listing() const { return use_listing; };
        bool get_use_dar_manager_show_files() const { return use_dar_manager_show_files; };
        bool get_use_dar_manager_contents() const { return use_dar_manager_contents; };
        bool get_use_dar_manager_statistics() const { return use_dar_manager_statistics; };
        bool get_use_dar_manager_show_version() const { return use_dar_manager_show_version; };



        virtual user_interaction *clone() const = 0;


        void warning_with_more(U_I num) { at_once = num; count = 0; };

    protected:


        void set_use_listing(bool val) { use_listing = val; };

        void set_use_dar_manager_show_files(bool val) { use_dar_manager_show_files = val; };

        void set_use_dar_manager_contents(bool val) { use_dar_manager_contents = val; };

        void set_use_dar_manager_statistics(bool val) { use_dar_manager_statistics = val; };

        void set_use_dar_manager_show_version(bool val) { use_dar_manager_show_version = val; };


        virtual void inherited_warning(const std::string & message) = 0;

    private:
        bool use_listing;
        bool use_dar_manager_show_files;
        bool use_dar_manager_contents;
        bool use_dar_manager_statistics;
        bool use_dar_manager_show_version;
        U_I at_once, count;

    };



    class user_interaction_callback : public user_interaction
    {
    public:


        user_interaction_callback(void (*x_warning_callback)(const std::string &x, void *context),
                                  bool (*x_answer_callback)(const std::string &x, void *context),
                                  std::string (*x_string_callback)(const std::string &x, bool echo, void *context),
                                  secu_string (*x_secu_string_callback)(const std::string &x, bool echo, void *context),
                                  void *context_value);

        void pause(const std::string & message);
        std::string get_string(const std::string & message, bool echo);
        secu_string get_secu_string(const std::string & message, bool echo);
        void listing(const std::string & flag,
                     const std::string & perm,
                     const std::string & uid,
                     const std::string & gid,
                     const std::string & size,
                     const std::string & date,
                     const std::string & filename,
                     bool is_dir,
                     bool has_children);

        void dar_manager_show_files(const std::string & filename,
                                    bool available_data,
                                    bool available_ea);

        void dar_manager_contents(U_I number,
                                 const std::string & chemin,
                                 const std::string & archive_name);

        void dar_manager_statistics(U_I number,
                                    const infinint & data_count,
                                    const infinint & total_data,
                                    const infinint & ea_count,
                                    const infinint & total_ea);

        void dar_manager_show_version(U_I number,
                                      const std::string & data_date,
                                      const std::string & data_presence,
                                      const std::string & ea_date,
                                      const std::string & ea_presence);


        void set_listing_callback(void (*callback)(const std::string & flag,
                                                   const std::string & perm,
                                                   const std::string & uid,
                                                   const std::string & gid,
                                                   const std::string & size,
                                                   const std::string & date,
                                                   const std::string & filename,
                                                   bool is_dir,
                                                   bool has_children,
                                                   void *context))
        {
            tar_listing_callback = callback;
            set_use_listing(true); // this is to inform libdar to use listing()
        };

            // You can set a dar_manager_show_files callback thanks to this method

        void set_dar_manager_show_files_callback(void (*callback)(const std::string & filename,
                                                                  bool available_data,
                                                                  bool available_ea,
                                                                  void *context))
        {
            dar_manager_show_files_callback = callback;
            set_use_dar_manager_show_files(true); // this is to inform libdar to use the dar_manager_show_files() method
        };

        void set_dar_manager_contents_callback(void (*callback)(U_I number,
                                                                const std::string & chemin,
                                                                const std::string & archive_name,
                                                                void *context))
        {
            dar_manager_contents_callback = callback;
            set_use_dar_manager_contents(true); // this is to inform libdar to use the dar_manager_contents() method
        };

        void set_dar_manager_statistics_callback(void (*callback)(U_I number,
                                                                  const infinint & data_count,
                                                                  const infinint & total_data,
                                                                  const infinint & ea_count,
                                                                  const infinint & total_ea,
                                                                  void *context))
        {
            dar_manager_statistics_callback = callback;
            set_use_dar_manager_statistics(true); // this is to inform libdar to use the dar_manager_statistics() method
        };

        void set_dar_manager_show_version_callback(void (*callback)(U_I number,
                                                                    const std::string & data_date,
                                                                    const std::string & data_presence,
                                                                    const std::string & ea_date,
                                                                    const std::string & ea_presence,
                                                                    void *context))
        {
            dar_manager_show_version_callback = callback;
            set_use_dar_manager_show_version(true);  // this is to inform libdar to use the dar_manager_show_version() method
        };


        virtual user_interaction *clone() const;

    protected:
        void inherited_warning(const std::string & message);

    private:
        void (*warning_callback)(const std::string & x, void *context);  // pointer to function
        bool (*answer_callback)(const std::string & x, void *context);   // pointer to function
        std::string (*string_callback)(const std::string & x, bool echo, void *context); // pointer to function
        secu_string (*secu_string_callback)(const std::string & x, bool echo, void *context); // pointer to function
        void (*tar_listing_callback)(const std::string & flags,
                                     const std::string & perm,
                                     const std::string & uid,
                                     const std::string & gid,
                                     const std::string & size,
                                     const std::string & date,
                                     const std::string & filename,
                                     bool is_dir,
                                     bool has_children,
                                     void *context);
        void (*dar_manager_show_files_callback)(const std::string & filename,
                                              bool available_data,
                                              bool available_ea,
                                                void *context);
        void (*dar_manager_contents_callback)(U_I number,
                                             const std::string & chemin,
                                             const std::string & archive_name,
                                              void *context);
        void (*dar_manager_statistics_callback)(U_I number,
                                                const infinint & data_count,
                                                const infinint & total_data,
                                                const infinint & ea_count,
                                                const infinint & total_ea,
                                                void *context);
        void (*dar_manager_show_version_callback)(U_I number,
                                                  const std::string & data_date,
                                                  const std::string & data_presence,
                                                  const std::string & ea_date,
                                                  const std::string & ea_presence,
                                                  void *context);

        void *context_val;
    };



    class user_interaction_blind : public user_interaction
    {
    public:
        bool pause2(const std::string & message) { return false; };

        std::string get_string(const std::string & message, bool echo) { return "user_interaction_blind, is blindly answering no"; };
        secu_string get_secu_string(const std::string & message, bool echo) { return secu_string(); };

        user_interaction *clone() const { user_interaction *ret = new (std::nothrow) user_interaction_blind(); if(ret == NULL) throw Ememory("user_interaction_blind::clone"); return ret; };

    protected:
        void inherited_warning(const std::string & message) {}; // do not display any warning, this is "bind user_interaction" !

    };


} // end of namespace

#endif