/*
Copyright © 2010  yan Verdavaine

This file is part of QExtend.

QExtend 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 3 of the License, or
any later version.

QExtend 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 QExtend.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef QEXTEND_CONNECTOR_H
#define QEXTEND_CONNECTOR_H
#include "extendptr.hpp"
#include <QObject>
namespace QExtend
{

class Receiver;



//! \~english   Interfaces a QObject instance with one of its signal.
//! \~french    Interface une instance de QObject avec un de ses signal.
/*!
\~english
    Emitter is use to simplify connexion lisibility with connect coding like a stream. Emitter could be connect to a Receiver or another Emitter.
\~french
    Emitter est utilisé pour simplifier la lisibilité des connexions avec l'écriture des connect comme un flux. Un Emitter peut être connecté vers un Receiver ou un autre Emitter.
*/
class QEXTEND_EXPORT  Emitter
{
    ExtendPtr<const QObject,WEAK> m_emitter;
    const char *            m_signal;
    mutable Qt::ConnectionType      m_type;

public:
    //! \~english   Create a Emitter
    //! \~french    Crée un Emitter. 
    /*!
    \~english
        Create a Emitter

        \param obj      QObject pointer.
        \param signal   Object signal signature. Like normal connect, you should use SIGNAL macro.

    \~french
        Créé un Emitter.  
        
        \param obj      Pointeur sur l'objet.
        \param signal   Signature du signal de l'objet. Comme pour un connect, vous devez utiliser la macro SIGNAL.
    \~
    */
    Emitter(const QObject * obj = 0, const char * signal = 0);

    //! \~english   Creates an Emitter to a specific signal.
    //! \~french    Crée un Emitter pour un signal précis. 
    /*!
    \~english
        Creates an Emitter to a spécific signal

        \param signal   Object signal signature. like normale connect, you should use SIGNAL macro.

    \~french
        Crée un Emitter pour un signal précis. 
        
        \param signal   Signature du signal de l'objet. Comme pour un connect, vous devez utiliser la macro SIGNAL.
    \~
    */
    Emitter(const char * signal );

    //! \~english  Gives the interfaced QObject Emitter. If QObject has been deleted, this function returns 0.
    //! \~french   Accès au QObject interfacé qui émet un signal. Si l'object as été détruit, la fonction retourne 0.    
    const QObject * emitter() const;

    

    //! \~english  Gives the interfaced signal signature.
    //! \~french   Accès à la signature du siganl du QObject.    
    const char *    signal() const;


    
    //! \~english   Replaces the interfaced QObject.
    //! \~french    Remplace le QObject interfacé.
    /*!
    \~english
        Replaces interfaced QObject

         \param obj      QObject pointer.
    \~french
        Remplace le QObject interfacé.
        
        \param obj      Pointeur sur l'objet.
    \~
    */
    void replaceObject(const QObject * obj);

    //! \~english   Replaces the signal signature.
    //! \~french    Remplace la signature du signal.
    /*!
    \~english
        Replace signal signature.

         \param signal   Object signal signature. Like normal connect, you should use SIGNAL macro.
    \~french
        Remplace la signature du signal.
        
        \param signal   Signature du signal de l'objet. Comme pour un connect, vous devez utiliser la macro SIGNAL.
    \~
    */
    void replaceSignal( const char * signal);

    //! \~english   Replaces the interfaced QObject and the signal signature.
    //! \~french    Remplace le QObject interfacé et la signature du signal
    /*!
    \~english
        Replaces interfaced QObject and signal signature.

        \param obj      QObject pointer.
        \param signal   Object signal signature. Like normal connect, you should use SIGNAL macro.

    \~french
        Remplace le QObject interfacé et la signature du signal.
        
        \param obj      Pointeur sur l'objet.
        \param signal   Signature du signal de l'objet. Comme pour un connect, vous devez utiliser la macro SIGNAL.
    \~
    */
    void replaceEmitter(const QObject * obj, const char * signal);

    //! \~english   Connects an Emitter to a Receiver
    //! \~french    Connecte un Emitter vers un Receiver
    /*!
    \~english
        Connects an Emitter to a Receiver

        \param r        Target Receiver.
    \~french
        Connecte un Emitter vers un Receiver
        
        \param r      le Recpter cible.
    \~
    */
    const Emitter & operator >> (const Receiver & r) const;


    //! \~english   Connects Emitter to another Emitter
    //! \~french    Connect un Emitter vers un autre Emitter
    /*!
    \~english
        Connect Emitter to another Emitter

        \param e        Emitter target.
    \~french
        Connecte un Emitter vers un Receiver
        
        \param e      l'Emitter cible.
    \~
    */
    const Emitter & operator >> (const Emitter & e) const;

     const Emitter & operator << (const Emitter & e) const;


    //! \~english   Modify the next connexion type. 
    //! \~french    Modifie le type de la prochaine connexion. 
    /*!
    \~english
        By default connexion type is Qt::AutoConnection. After the next connection, type is reinitialized to Qt::AutoConnection.

        \param type      Connection type.
    \~french
       Par défaut, le type de connection est Qt::AutoConnection. Après la prochaine connexion, le type est réinitialisé à  Qt::AutoConnection.
        
        \param type      Type de connexion.
    \~
    */
    const Emitter & operator >> (Qt::ConnectionType type) const ;



};

//! \~english   Interfaces a QObject instance  with one of its slot or signal that will be connected to a signal
//! \~french    Interface une instance de QObject avec un de ses slots ou signaux qui seront connectés à  un signal
/*!
\~english
    Receiver is used to simplify connection lisibility with connect coded like streams. Receiver could be connected to an Emitter.
\~french
    Receiver est utilisé pour simplifier la lisibilité des connexions avec l'écriture des connect comme un flux. Un Receiver peut être connecté vers un Emitter.
*/
class QEXTEND_EXPORT  Receiver
{
    ExtendPtr<const QObject,WEAK>  m_receiver;
    const char *            m_slot;
    mutable Qt::ConnectionType      m_type;

    public:
    //! \~english   Create a Receiver
    //! \~french    Créé un Receiver. 
    /*!
    \~english
        Create a Receiver

        \param obj      QObject pointer.
        \param slot   Object slot signature. like normale connect, you should use SLOT macro.

    \~french
        Créé un Receiver.  
        
        \param obj      Pointeur sur l'objet.
        \param slot   Signature du slot de l'objet. Comme pour un connet, vous devez utiliser la macro SLOT.
    \~
    */
    Receiver(const QObject * obj = 0, const char * slot = 0);

    //! \~english   Create a Receiver
    //! \~french    Créé un Receiver. 
    /*!
    \~english
        Create a Receiver  to a spécific slot

        \param slot   Object slot signature. like normale connect, you should use SLOT macro.

    \~french
        Créé un Receiver pour un slot spécifique.  
        
        \param slot   Signature du slot de l'objet. Comme pour un connet, vous devez utiliser la macro SLOT.
    \~
    */
    Receiver( const char * slot );

    //! \~english  Give interfaced QObject Receiver. If QObject has been deleted, this function return 0.
    //! \~french   Accés au QObject interfacé. Si l'object as été détruit, a fonction retourne 0.  
    const QObject * receiver() const;

    //! \~english  Give interfaced slot signature.
    //! \~french   Accés à  la signature du slot du QObject.    
    const char *    slot() const;

    //! \~english   Replace interfaced QObject
    //! \~french    Remplace le QObject interfacé.
    /*!
    \~english
        Replace interfaced QObject

         \param obj      QObject pointer.
    \~french
        Remplace le QObject interfacé.
        
        \param obj      Pointeur sur l'objet.
    \~
    */
    void replaceObject(const QObject * obj);

    //! \~english   Replace slot signature.
    //! \~french    Remplace la signature du slot.
    /*!
    \~english
        Replace slot signature.

         \param slot   Object slot signature. like normale connect, you should use SLOT macro.
    \~french
        Remplace le slot du signal.
        
        \param signal   Signature du slot de l'objet. Comme pour un connet, vous devez utiliser la macro SLOT.
    \~
    */
    void replaceSlot( const char * slot);


    //! \~english   Replace interfaced QObject ans slot signature.
    //! \~french    remplace le QObject interfacé et la signature du slot. 
    /*!
    \~english
        Create a Receiver

        \param obj      QObject pointer.
        \param slot   Object slot signature. like normale connect, you should use SLOT macro.

    \~french
        Créé un Receiver.  
        
        \param obj      Pointeur sur l'objet.
        \param slot   Signature du slot de l'objet. Comme pour un connet, vous devez utiliser la macro SLOT.
    \~
    */
    void replaceReceiver(const QObject * obj, const char * slot);

    //! \~english   Connect an Emitter to Receiver
    //! \~french    Connect un Emitter vers le Receiver
    /*!
    \~english
        Connect an Emitter to Receiver

        \param e        Emitter source.
    \~french
        Connect un Emitter vers un Receiver
        
        \param e      l'Emitter source.
    \~
    */
    const Receiver & operator << (const Emitter & e) const;

    //! \~english   Modify the next connexion type. 
    //! \~french    Modifie le type de la prochaine connexion. 
    /*!
    \~english
        By default connexion type is Qt::AutoConnection. After the next connexion, type is reinitialized to Qt::AutoConnection.

        \param type      Connexion type.
    \~french
       Par défaut, le type de connection est Qt::AutoConnection. Aprés la prochaine connection, le type est reinitialisé à  Qt::AutoConnection.
        
        \param type      type de connexion.
    \~
    */
    const Receiver & operator << (Qt::ConnectionType type) const;

};


//! \~english   Macro to simplify Emitter creation. It's hide the SIGNAL macro call.
//! \~french    Macro simpifiant la création d'un Emitter. Il cache l'appel à la macro SIGNAL.
/*!
\~english
    Macro to simplify Emitter creation. It's hide the SIGNAL macro call.

    \param x object emitter.
    \param y signal signature. SIGNAL macro is used internally.
\~french
    Macro simpifiant la création d'un Emitter. Il cache l'appel à  la macro SIGNAL.

    \param x L'objet emitter.
    \param y Signature du dignal.  La macro SIGNAL est utilisé à l'interieur.
*/
#define EMITTER(x,y) Emitter(x,SIGNAL(y))

//! \~english   Macro to simplify Receiver creation. It's hide the SLOT macro call.
//! \~french    Macro simpifiant la création d'un Receiver. Il cache l'appel à la macro SLOT.
/*!
\~english
    Macro to simplify Emitter creation. It's hide the SLOT macro call.

    \param x Object Receiver.
    \param y SLot signature. SIGNAL macro is used internally.
\~french
    Macro simpifiant la création d'un Receiver. Il cache l'appel à la macro SLOT.

    \param x L'objet receveur.
    \param y Slot du dignal.  La macro SIGNAL est utilisée à  l'interieur.
*/
#define RECEIVER(x,y) Receiver(x,SLOT(y))
}
#endif