mucroom.h

/*
  Copyright (c) 2006-2008 by Jakob Schroeter <js@camaya.net>
  This file is part of the gloox library. http://camaya.net/gloox

  This software is distributed under a license. The full license
  agreement can be found in the file LICENSE in this distribution.
  This software may not be copied, modified, sold or distributed
  other than expressed in the named license agreement.

  This software is distributed without any warranty.
*/



#ifndef MUCROOM_H__
#define MUCROOM_H__

#include "discohandler.h"
#include "disconodehandler.h"
#include "presencehandler.h"
#include "iqhandler.h"
#include "messagehandler.h"
#include "mucroomhandler.h"
#include "mucroomconfighandler.h"
#include "jid.h"

#include <string>

namespace gloox
{

  class ClientBase;
  class MUCMessageSession;
  class Stanza;

  class GLOOX_API MUCRoom : private DiscoHandler, private PresenceHandler,
                            public IqHandler, private MessageHandler, private DiscoNodeHandler
  {
    public:
      enum HistoryRequestType
      {
        HistoryUnknown,             
        HistoryMaxChars,            
        HistoryMaxStanzas,          
        HistorySeconds,             
        HistorySince                
      };

      MUCRoom( ClientBase *parent, const JID& nick, MUCRoomHandler *mrh, MUCRoomConfigHandler *mrch = 0 );

      virtual ~MUCRoom();

      void setPassword( const std::string& password ) { m_password = password; }

      const std::string name() const { return m_nick.username(); }

      const std::string service() const { return m_nick.server(); }

      const std::string nick() const { return m_nick.resource(); }

      virtual void join();

      void leave( const std::string& msg = "" );

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

      void setSubject( const std::string& subject );

      MUCRoomAffiliation affiliation() const { return m_affiliation; }

      MUCRoomRole role() const { return m_role; }

      void setNick( const std::string& nick );

      void setPresence( Presence presence, const std::string& msg = "" );

      void invite( const JID& invitee, const std::string& reason, bool cont = false );

      void getRoomInfo();

      void getRoomItems();

      void setPublish( bool publish, bool publishNick );

      void registerMUCRoomHandler( MUCRoomHandler *mrl ) { m_roomHandler = mrl; }

      void removeMUCRoomHandler() { m_roomHandler = 0; }

      void registerMUCRoomConfigHandler( MUCRoomConfigHandler *mrch ) { m_roomConfigHandler = mrch; }

      void removeMUCRoomConfigHandler() { m_roomConfigHandler = 0; }

      void addHistory( const std::string& message, const JID& from, const std::string& stamp );

      void setRequestHistory( int value, HistoryRequestType type );

      void setRequestHistory( const std::string& since );

      static Stanza* declineInvitation( const JID& room, const JID& invitor,
                                        const std::string& reason = "");

      void requestVoice();

      void kick( const std::string& nick, const std::string& reason = "" );

      void ban( const std::string& nick, const std::string& reason );

      void grantVoice( const std::string& nick, const std::string& reason );

      static Stanza* createDataForm( const JID& room, const DataForm& df );

      void revokeVoice( const std::string& nick, const std::string& reason );

      void setRole( const std::string& nick, MUCRoomRole role, const std::string& reason = "" );

      void setAffiliation( const std::string& nick, MUCRoomAffiliation affiliation,
                           const std::string& reason );

      void requestRoomConfig();

      void setRoomConfig( DataForm* form );

      void acknowledgeInstantRoom();

      void cancelRoomCreation();

      void destroy( const std::string& reason = "",
                    const JID* alternate = 0, const std::string& password = "" );

      void requestList( MUCOperation operation );

      void storeList( const MUCListItemList items, MUCOperation operation );

      int flags() const { return m_flags; }

      // reimplemented from DiscoHandler
      virtual void handleDiscoInfoResult( Stanza *stanza, int context );

      // reimplemented from DiscoHandler
      virtual void handleDiscoItemsResult( Stanza *stanza, int context );

      // reimplemented from DiscoHandler
      virtual void handleDiscoError( Stanza *stanza, int context );

      // reimplemented from PresenceHandler
      virtual void handlePresence( Stanza *stanza );

      // reimplemented from MessageHandler
      virtual void handleMessage( Stanza *stanza, MessageSession *session = 0 );

      // reimplemented from IqHandler
      virtual bool handleIq( Stanza* /*stanza*/ ) { return false; }

      // reimplemented from IqHandler
      virtual bool handleIqID( Stanza *stanza, int context );

      // reimplemented from DiscoNodeHandler
      virtual StringList handleDiscoNodeFeatures( const std::string& node );

      // reimplemented from DiscoNodeHandler
      virtual StringMap handleDiscoNodeIdentities( const std::string& node, std::string& name );

      // reimplemented from DiscoNodeHandler
      virtual DiscoNodeItemList handleDiscoNodeItems( const std::string& node = "" );

    protected:
      void setName( const std::string& name ) { m_nick.setUsername( name ); }
      virtual bool instantRoomHook() const { return false; }

      ClientBase *m_parent;
      JID m_nick;

      bool m_joined;

    private:
      bool handleIqResult( Stanza *stanza, int context );
      bool handleIqError( Stanza *stanza, int context );
      void setNonAnonymous();
      void setSemiAnonymous();
      void setFullyAnonymous();
      void modifyOccupant( const std::string& nick, int state, const std::string roa,
                           const std::string& reason );
      void acknowledgeRoomCreation();
      MUCRoomAffiliation getEnumAffiliation( const std::string& affiliation );
      MUCRoomRole getEnumRole( const std::string& role );

      MUCRoomHandler *m_roomHandler;
      MUCRoomConfigHandler *m_roomConfigHandler;
      MUCMessageSession *m_session;

      typedef std::list<MUCRoomParticipant> ParticipantList;
      ParticipantList m_participants;

      std::string m_password;
      std::string m_newNick;

      MUCRoomAffiliation m_affiliation;
      MUCRoomRole m_role;

      HistoryRequestType m_historyType;

      std::string m_historySince;
      int m_historyValue;
      int m_flags;
      bool m_creationInProgress;
      bool m_configChanged;
      bool m_publishNick;
      bool m_publish;
      bool m_unique;

  };

}

#endif // MUCROOM_H__