assuancommand.h

Go to the documentation of this file.

/* -*- mode: c++; c-basic-offset:4 -*-
    uiserver/assuancommand.h

    This file is part of Kleopatra, the KDE keymanager
    Copyright (c) 2007 Klarälvdalens Datakonsult AB

    Kleopatra 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.

    Kleopatra 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

    In addition, as a special exception, the copyright holders give
    permission to link the code of this program with any edition of
    the Qt library by Trolltech AS, Norway (or with modified versions
    of Qt that use the same license as Qt), 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
    Qt.  If you modify this file, you may extend this exception to
    your version of the file, but you are not obligated to do so.  If
    you do not wish to do so, delete this exception statement from
    your version.
*/

#ifndef __KLEOPATRA_UISERVER_ASSUANCOMMAND_H__
#define __KLEOPATRA_UISERVER_ASSUANCOMMAND_H__

#include <utils/pimpl_ptr.h>
#include <utils/types.h>

#include <gpgme++/global.h>
#include <gpgme++/error.h>

#ifdef HAVE_ASSUAN2
#include <gpg-error.h>

#endif
#include <kmime/kmime_header_parsing.h>

#include <qwindowdefs.h> // for WId

#ifndef Q_MOC_RUN
#include <boost/shared_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>
#endif

#include <string>
#include <map>
#include <vector>

class QVariant;
class QIODevice;
class QObject;
class QStringList;
class QDialog;
class QFile;

struct assuan_context_s;

namespace Kleo {

    class Input;
    class Output;

    class AssuanCommandFactory;

    class AssuanCommand : public ExecutionContext, public boost::enable_shared_from_this<AssuanCommand> {
        // defined in assuanserverconnection.cpp!
    public:
        AssuanCommand();
        virtual ~AssuanCommand();

        int start();
        void canceled();

        virtual const char * name() const = 0;

        class Memento {
        public:
            virtual ~Memento() {}
        };

        template <typename T>
        class TypedMemento : public Memento {
            T m_t;
        public:
            explicit TypedMemento( const T & t ) : m_t( t ) {}

            const T & get() const { return m_t; }
            T & get() { return m_t; }
        };

        template <typename T>
        static boost::shared_ptr< TypedMemento<T> > make_typed_memento( const T & t ) {
            return boost::shared_ptr< TypedMemento<T> >( new TypedMemento<T>( t ) );
        }

        static int makeError( int code );

        // convenience methods:
        enum Mode { NoMode, EMail, FileManager };
        Mode checkMode() const;

        enum CheckProtocolOption {
            AllowProtocolMissing=0x01
        };

        GpgME::Protocol checkProtocol( Mode mode, int options=0 ) const;

        /* reimp */ void applyWindowID( QWidget* w ) const {
            doApplyWindowID( w );
        }
        WId parentWId() const;

        void setNohup( bool on );
        bool isNohup() const;
        bool isDone() const;

        QString sessionTitle() const;
        unsigned int sessionId() const;

        bool informativeRecipients() const;
        bool informativeSenders() const;

        const std::vector<KMime::Types::Mailbox> & recipients() const;
        const std::vector<KMime::Types::Mailbox> & senders() const;

        bool hasMemento( const QByteArray & tag ) const;
        boost::shared_ptr<Memento> memento( const QByteArray & tag ) const;
        template <typename T>
        boost::shared_ptr<T> mementoAs( const QByteArray & tag ) const {
            return boost::dynamic_pointer_cast<T>( this->memento( tag ) );
        }
        QByteArray registerMemento( const boost::shared_ptr<Memento> & mem );
        QByteArray registerMemento( const QByteArray & tag, const boost::shared_ptr<Memento> & mem );
        void removeMemento( const QByteArray & tag );
        template <typename T>
        T mementoContent( const QByteArray & tag ) const {
            if ( boost::shared_ptr< TypedMemento<T> > m = mementoAs< TypedMemento<T> >( tag ) )
                return m->get();
            else
                return T();
        }

        bool hasOption( const char * opt ) const;
        QVariant option( const char * opt ) const;
        const std::map<std::string,QVariant> & options() const;

        const std::vector< boost::shared_ptr<Input> > & inputs() const;
        const std::vector< boost::shared_ptr<Input> > & messages() const;
        const std::vector< boost::shared_ptr<Output> > & outputs() const;

        QStringList fileNames() const;
        unsigned int numFiles() const;

        void sendStatus( const char * keyword, const QString & text );
        void sendStatusEncoded( const char * keyword, const std::string & text );
        void sendData( const QByteArray & data, bool moreToCome=false );

        int inquire( const char * keyword, QObject * receiver, const char * slot, unsigned int maxSize=0 );

        void done( const GpgME::Error& err = GpgME::Error() );
        void done( const GpgME::Error& err, const QString & details );
        void done( int err ) { done( GpgME::Error(err) ); }
        void done( int err, const QString & details ) { done( GpgME::Error(err), details ); }

    private:
        virtual void doCanceled() = 0;
        virtual int doStart() = 0;

    private:
        void doApplyWindowID( QWidget * w ) const;

    private:
        const std::map< QByteArray, boost::shared_ptr<Memento> > & mementos() const;

    private:
        friend class ::Kleo::AssuanCommandFactory;
        class Private;
        kdtools::pimpl_ptr<Private> d;
    };

    class AssuanCommandFactory {
    public:
        virtual ~AssuanCommandFactory() {}

        virtual boost::shared_ptr<AssuanCommand> create() const = 0;
        virtual const char * name() const = 0;

#ifndef HAVE_ASSUAN2
        typedef int(*_Handler)( assuan_context_s*, char *);
#else
        typedef gpg_error_t(*_Handler)( assuan_context_s*, char *);
#endif
        virtual _Handler _handler() const = 0;

#ifndef HAVE_ASSUAN2
        static int _handle( assuan_context_s*, char *, const char * );
#else
        static gpg_error_t _handle( assuan_context_s*, char *, const char * );
#endif
    };

    template <typename Command>
    class GenericAssuanCommandFactory : public AssuanCommandFactory {
        /* reimp */ AssuanCommandFactory::_Handler _handler() const { return &GenericAssuanCommandFactory::_handle; }
#ifndef HAVE_ASSUAN2
        static int _handle( assuan_context_s* _ctx, char * _line ) {
#else
        static gpg_error_t _handle( assuan_context_s* _ctx, char * _line ) {
#endif
            return AssuanCommandFactory::_handle( _ctx, _line, Command::staticName() );
        }
        /* reimp */ boost::shared_ptr<AssuanCommand> create() const { return make(); }
        /* reimp */ const char * name() const { return Command::staticName(); }
    public:
        static boost::shared_ptr<Command> make() { return boost::shared_ptr<Command>( new Command ); }
    };

    template <typename Derived, typename Base=AssuanCommand>
    class AssuanCommandMixin : public Base {
    protected:
        /* reimp */ const char * name() const { return Derived::staticName(); }
    };

}

#endif /* __KLEOPATRA_UISERVER_ASSUANCOMMAND_H__ */