dataformfield.h

/*
  Copyright (c) 2005-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 DATAFORMFIELD_H__
#define DATAFORMFIELD_H__

#include "gloox.h"

#include <utility>
#include <string>

namespace gloox
{

  class Tag;
  class GLOOX_API DataFormField
  {
    public:

      enum DataFormFieldType
      {
        FieldTypeBoolean,           
        FieldTypeFixed,             
        FieldTypeHidden,            
        FieldTypeJidMulti,          
        FieldTypeJidSingle,         
        FieldTypeListMulti,         
        FieldTypeListSingle,        
        FieldTypeTextMulti,         
        FieldTypeTextPrivate,       
        FieldTypeTextSingle,        
        FieldTypeItem,              
        FieldTypeReported,          
        FieldTypeInvalid,           
        FieldTypeNone               
      };

      DataFormField( DataFormFieldType type = FieldTypeTextSingle );

      DataFormField( const std::string& name, const std::string& value = "",
                     const std::string& label = "", DataFormFieldType type = FieldTypeTextSingle );

      DataFormField( Tag *tag );

      virtual ~DataFormField();

      virtual StringMap& options() { return m_options; }

      virtual Tag* tag() const;

      virtual const std::string& name() const { return m_name; }

      virtual void setName( const std::string& name ) { m_name = name; }

      virtual void setOptions( const StringMap& options ) { m_options = options; }

      virtual void addOption( const std::string& label, const std::string& value )
        { m_options.insert( std::make_pair( label, value ) ); }

      virtual bool required() const { return m_required; }

      virtual void setRequired( bool required ) { m_required = required; }

      virtual DataFormFieldType type() const { return m_type; }

      virtual const std::string& label() const { return m_label; }

      virtual void setLabel( const std::string& label ) { m_label = label; }

      virtual const std::string& description() const { return m_desc; }

      virtual void setDescription( const std::string& desc ) { m_desc = desc; }

      virtual const std::string& value() const { return m_values.front(); }

      virtual void setValue( const std::string& value ) { m_values.clear(); addValue( value ); }

      virtual const StringList& values() const { return m_values; }

      virtual void setValues( const StringList& values ) { m_values = values; }

      virtual void addValue( const std::string& value ) { m_values.push_back( value ); }

    private:
      StringMap m_options;
      StringList m_values;

      std::string m_name;
      std::string m_desc;
      std::string m_label;
      DataFormFieldType m_type;
      bool m_required;
  };

}

#endif // DATAFORMFIELD_H__