tty.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2001 by Rick L. Vinyard, Jr.                            *
 *   rvinyard@cs.nmsu.edu                                                  *
 *                                                                         *
 *   This file is part of the conexus library.                             *
 *                                                                         *
 *   The conexus library is free software; you can redistribute it and/or  *
 *   modify it under the terms of the GNU General Public License           *
 *   version 3 as published by the Free Software Foundation.               *
 *                                                                         *
 *   The conexus library 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 software. If not see <http://www.gnu.org/licenses/>.  *
 ***************************************************************************/
#ifndef CONEXUSTTY_H
#define CONEXUSTTY_H

#include <conexus/serial.h>
#include <conexus/tty_interface.h>

#include <termios.h>
#include <unistd.h>

namespace Conexus
{

  class TTY : public Serial, public virtual TTYInterface
  {
    protected:

      TTY( const std::string& device = std::string(), ReadWrite rwmode = READ_WRITE );

    public:

      typedef ConexusPointer<TTY> pointer;

      CONEXUS_ENDPOINT_GENERIC_CREATE();

      static TTY::pointer create( const std::string& device = std::string(), ReadWrite rwmode = READ_WRITE );

      virtual ~TTY();

      virtual void drain();

      virtual void flush_input();

      virtual void flush_output();

      virtual void flush();

      virtual void suspend_output();

      virtual void restart_output();

      virtual void suspend_input();

      virtual void restart_input();

      void set_input_speed( unsigned speed, SetOption option = SET_NOW );

      void set_output_speed( unsigned speed, SetOption option = SET_NOW );

      void set_speed( unsigned speed, SetOption option = SET_NOW );

      unsigned input_speed();

      unsigned output_speed();

      void set_parity( Parity parity, ParityError error = PARITY_ERROR_IGNORE, SetOption option = SET_NOW );

      Parity parity();

      ParityError parity_error();

      unsigned byte_size();

      void set_byte_size( unsigned size, SetOption option = SET_NOW );

      unsigned stop_bits();

      void set_stop_bits( unsigned size, SetOption option = SET_NOW );

      FlowControl flow_control();

      void set_flow_control( FlowControl flowcontrol, SetOption option = SET_NOW );

      bool is_carrier_detect_enabled();

      void enable_carrier_detect( bool enable = true, SetOption option = SET_NOW );

      bool is_receiver_enabled();

      void enable_receiver( bool enable = true, SetOption option = SET_NOW );

      virtual void open() throw ( open_exception );

      virtual void open( const std::string& name, ReadWrite mode = READ_WRITE_UNCHANGED ) throw ( open_exception );

      virtual void close( bool force = false ) throw ( close_exception );

      void set_input_modes( tcflag_t iflag, SetOption option = SET_NOW );

      void set_output_modes( tcflag_t oflag, SetOption option = SET_NOW );

      void set_control_modes( tcflag_t cflag, SetOption option = SET_NOW );

      void set_local_modes( tcflag_t lflag, SetOption option = SET_NOW );

      void set_control_characters( int index, cc_t value, SetOption option = SET_NOW );

      struct termios attributes();

      void inject( char data );

      void inject( const char* buffer, size_t bufsize );

      void inject( const std::string& buffer );

      bool is_reset_on_close_enabled();

      void enable_reset_on_close( bool reset = true );

      sigc::signal<void>& signal_input_speed_changed();
      sigc::signal<void>& signal_output_speed_changed();
      sigc::signal<void>& signal_parity_changed();
      sigc::signal<void>& signal_byte_size_changed();
      sigc::signal<void>& signal_stop_bits_changed();
      sigc::signal<void>& signal_flow_control_changed();
      sigc::signal<void>& signal_carrier_detect_changed();
      sigc::signal<void>& signal_receiver_changed();

      virtual size_t input_available() throw();

    protected:
      struct termios m_termios, m_origtermios;
      bool m_reset_on_close;

      sigc::signal<void> m_signal_input_speed_changed;
      sigc::signal<void> m_signal_output_speed_changed;
      sigc::signal<void> m_signal_parity_changed;
      sigc::signal<void> m_signal_byte_size_changed;
      sigc::signal<void> m_signal_stop_bits_changed;
      sigc::signal<void> m_signal_flow_control_changed;
      sigc::signal<void> m_signal_carrier_detect_changed;
      sigc::signal<void> m_signal_receiver_changed;

      void tcsetattr( SetOption option );

      speed_t unsigned2speed( unsigned speed );
      unsigned speed2unsigned( speed_t speed );

  };

}

#endif