finalcut/src/include/final/fterm.h

/***********************************************************************
* fterm.h - Base class for terminal control                            *
*                                                                      *
* This file is part of the Final Cut widget toolkit                    *
*                                                                      *
* Copyright 2012-2019 Markus Gans                                      *
*                                                                      *
* The Final Cut is free software; you can redistribute it and/or       *
* modify it under the terms of the GNU Lesser General Public License   *
* as published by the Free Software Foundation; either version 3 of    *
* the License, or (at your option) any later version.                  *
*                                                                      *
* The Final Cut 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 Lesser General Public License for more details.                  *
*                                                                      *
* You should have received a copy of the GNU Lesser General Public     *
* License along with this program.  If not, see                        *
* <http://www.gnu.org/licenses/>.                                      *
***********************************************************************/

/*  Base class
 *  ══════════
 *
 * ▕▔▔▔▔▔▔▔▏1       1▕▔▔▔▔▔▔▔▔▔▔▏
 * ▕ FTerm ▏-┬- - - -▕ FTermios ▏
 * ▕▁▁▁▁▁▁▁▏ :       ▕▁▁▁▁▁▁▁▁▁▁▏
 *           :
 *           :      1▕▔▔▔▔▔▔▔▔▔▔▏
 *           :- - - -▕ FTermcap ▏
 *           :       ▕▁▁▁▁▁▁▁▁▁▁▏
 *           :
 *           :      1▕▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▏
 *           :- - - -▕ FTermcapQuirks ▏
 *           :       ▕▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▏
 *           :
 *           :      1▕▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▏
 *           :- - - -▕ FTermDetection ▏
 *           :       ▕▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▏
 *           :
 *           :      1▕▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▏
 *           :- - - -▕ FTermXTerminal ▏
 *           :       ▕▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▏
 *           :
 *           :      1▕▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▏
 *           :- - - -▕   FTermLinux   ▏
 *           :       ▕▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▏
 *           :
 *           :      1▕▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▏
 *           :- - - -▕  FTermFreeBSD  ▏
 *           :       ▕▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▏
 *           :
 *           :      1▕▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▏
 *           :- - - -▕  FTermOpenBSD  ▏
 *           :       ▕▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▏
 *           :
 *           :      1▕▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▏
 *           :- - - -▕ FColorPalette ▏
 *           :       ▕▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▏
 *           :
 *           :      1▕▔▔▔▔▔▔▔▔▔▔▔▏
 *           :- - - -▕ FOptiAttr ▏
 *           :       ▕▁▁▁▁▁▁▁▁▁▁▁▏
 *           :
 *           :      1▕▔▔▔▔▔▔▔▔▔▔▔▏
 *           :- - - -▕ FOptiMove ▏
 *           :       ▕▁▁▁▁▁▁▁▁▁▁▁▏
 *           :
 *           :      1▕▔▔▔▔▔▔▔▔▔▔▔▏
 *           :- - - -▕ FKeyboard ▏
 *           :       ▕▁▁▁▁▁▁▁▁▁▁▁▏
 *           :
 *           :      1▕▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▏
 *           :- - - -▕ FMouseControl ▏
 *           :       ▕▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▏
 *           :
 *           :      *▕▔▔▔▔▔▔▔▔▔▏
 *           :- - - -▕ FString ▏
 *           :       ▕▁▁▁▁▁▁▁▁▁▏
 *           :
 *           :      *▕▔▔▔▔▔▔▔▔▏
 *           :- - - -▕ FPoint ▏
 *           :       ▕▁▁▁▁▁▁▁▁▏
 *           :
 *           :      *▕▔▔▔▔▔▔▔▏
 *           └- - - -▕ FRect ▏
 *                   ▕▁▁▁▁▁▁▁▏
 */

#ifndef FTERM_H
#define FTERM_H

#if !defined (USE_FINAL_H) && !defined (COMPILE_FINAL_CUT)
  #error "Only <final/final.h> can be included directly."
#endif

#include "final/fconfig.h"

#include <sys/ioctl.h>
#include <sys/stat.h>

#include <fcntl.h>
#include <langinfo.h>

#if F_HAVE_GETTTYNAM && F_HAVE_TTYENT_H
  #include <ttyent.h>
#endif

#include <clocale>
#include <cmath>
#include <csignal>
#include <map>
#include <queue>
#include <string>

#include "final/fc.h"
#include "final/fcolorpalette.h"
#include "final/fkey_map.h"
#include "final/fkeyboard.h"
#include "final/fmouse.h"
#include "final/foptiattr.h"
#include "final/foptimove.h"
#include "final/fpoint.h"
#include "final/frect.h"
#include "final/fstring.h"
#include "final/fsystem.h"
#include "final/fsystemimpl.h"
#include "final/ftermcap.h"
#include "final/ftermcapquirks.h"
#include "final/ftermdata.h"
#include "final/ftermdebugdata.h"
#include "final/ftermdetection.h"

#if defined(UNIT_TEST)
  #include "final/ftermlinux.h"
  #include "final/ftermfreebsd.h"
  #include "final/ftermopenbsd.h"
#elif defined(__linux__)
  #include "final/ftermlinux.h"
#elif defined(__FreeBSD__) || defined(__DragonFly__)
  #include "final/ftermfreebsd.h"
#elif defined(__NetBSD__) || defined(__OpenBSD__)
  #include "final/ftermopenbsd.h"
#endif

#include "final/ftermios.h"
#include "final/ftermxterminal.h"

namespace finalcut
{

//----------------------------------------------------------------------
// class FTerm
//----------------------------------------------------------------------

#pragma pack(push)
#pragma pack(1)

class FTerm final
{
  public:
    // Typedefs
    typedef FOptiAttr::charData  charData;
    typedef FTermData::characterSub  characterSub;

    struct initializationValues;  // forward declaration

    // Constructor
    explicit FTerm (bool = false);

    // Disable copy constructor
    FTerm (const FTerm&) = delete;

    // Destructor
    virtual ~FTerm();

    // Disable assignment operator (=)
    FTerm& operator = (const FTerm&) = delete;

    // Accessors
    virtual const char*    getClassName() const;
    static std::size_t     getLineNumber();
    static std::size_t     getColumnNumber();
    static const FString   getKeyName (FKey);
    static int             getTTYFileDescriptor();
    static char*           getTermType();
    static char*           getTermFileName();
    static int             getTabstop();
    static int             getMaxColor();
    initializationValues&  getInitValues();
    characterSub&          getCharSubstitutionMap();

    static FTermData*      getFTermData();
    static FSystem*        getFSystem();
    static FOptiMove*      getFOptiMove();
    static FOptiAttr*      getFOptiAttr();
    static FTermDetection* getFTermDetection();
    static FTermXTerminal* getFTermXTerminal();
    static FKeyboard*      getFKeyboard();
    static FMouseControl*  getFMouseControl();

#if defined(UNIT_TEST)
    static FTermLinux*     getFTermLinux();
    static FTermFreeBSD*   getFTermFreeBSD();
    static FTermOpenBSD*   getFTermOpenBSD();
#elif defined(__linux__)
    static FTermLinux*     getFTermLinux();
#elif defined(__FreeBSD__) || defined(__DragonFly__)
    static FTermFreeBSD*   getFTermFreeBSD();
#elif defined(__NetBSD__) || defined(__OpenBSD__)
    static FTermOpenBSD*   getFTermOpenBSD();
#endif

#if DEBUG
    FTermDebugData&        getFTermDebugData();
#endif

    // Inquiries
    static bool            isNormal (charData*&);
    static bool            isRaw();
    static bool            hasUTF8();
    static bool            hasVT100();
    static bool            hasASCII();
    static bool            isMonochron();
    static bool            isXTerminal();
    static bool            isAnsiTerminal();
    static bool            isRxvtTerminal();
    static bool            isUrxvtTerminal();
    static bool            isMltermTerminal();
    static bool            isPuttyTerminal();
    static bool            isKdeTerminal();
    static bool            isGnomeTerminal();
    static bool            isKtermTerminal();
    static bool            isTeraTerm();
    static bool            isSunTerminal();
    static bool            isCygwinTerminal();
    static bool            isMinttyTerm();
    static bool            isLinuxTerm();
    static bool            isFreeBSDTerm();
    static bool            isNetBSDTerm();
    static bool            isOpenBSDTerm();
    static bool            isScreenTerm();
    static bool            isTmuxTerm();
    static bool            isNewFont();
    static bool            isCursorHideable();
    static bool            hasChangedTermSize();
    static bool            hasShadowCharacter();
    static bool            hasHalfBlockCharacter();
    static bool            hasAlternateScreen();
    static bool            canChangeColorPalette();

    // Mutators
    static void            setFSystem (FSystem*);
    static void            setTermType (const char[]);
    static void            setInsertCursor (bool);
    static void            redefineDefaultColors (bool);
    static void            setDblclickInterval (const uInt64);
    static bool            setUTF8 (bool);
    static bool            setUTF8();
    static bool            unsetUTF8();

    // Methods
    static bool            setVGAFont();
    static bool            setNewFont();
    static bool            setOldFont();
    static int             openConsole();
    static int             closeConsole();
    static char*           moveCursor (int, int, int, int);
    static char*           cursorsVisibility (bool);
    static void            printMoveDurations();
    static char*           enableCursor();
    static char*           disableCursor();
    static void            detectTermSize();
    static void            setTermSize (const FSize&);
    static void            setTermTitle (const FString&);
    static void            setKDECursor (fc::kdeKonsoleCursorShape);
    static void            saveColorMap();
    static void            resetColorMap();
    static void            setPalette (FColor, int, int, int);
    static void            setBeep (int, int);
    static void            resetBeep();
    static void            beep();

    static void            setEncoding (fc::encoding);
    static fc::encoding    getEncoding();
    static std::string     getEncodingString();
    static bool            charEncodable (wchar_t);
    static wchar_t         charEncode (wchar_t);
    static wchar_t         charEncode (wchar_t, fc::encoding);
    static wchar_t         cp437_to_unicode (uChar);
    static uChar           unicode_to_cp437 (wchar_t);

    static bool            scrollTermForward();
    static bool            scrollTermReverse();

    // function pointer -> static function
    static int             (*Fputchar)(int);

    static void            putstringf (const char[], ...)
#if defined(__clang__)
      __attribute__ ((__format__ (__printf__, 1, 2)))
#elif defined(__GNUC__)
      __attribute__ ((format (printf, 1, 2)))
#endif
                           ;
    static void            putstring (const char[], int = 1);
    static int             putchar_ASCII (int);
    static int             putchar_UTF8  (int);

    static void            initScreenSettings();
    static char*           changeAttribute ( charData*&
                                           , charData*& );
    static void            changeTermSizeFinished();
    static void            exitWithMessage (const FString&)
    #if defined(__clang__) || defined(__GNUC__)
      __attribute__((noreturn))
    #endif
                           ;
    // Data Members
    static struct initializationValues
    {
      public:
        void setDefault()
        {
          cursor_optimisation = true;
          mouse_support = true;
          terminal_detection = true;
          color_change = true;
          vgafont = false;
          newfont = false;
          encoding = fc::UNKNOWN;

        #if defined(__FreeBSD__) || defined(__DragonFly__) || defined(UNIT_TEST)
          meta_sends_escape = true;
          change_cursorstyle = true;
        #elif defined(__NetBSD__) || defined(__OpenBSD__)
          meta_sends_escape = true;
        #endif
        }

        uInt8 cursor_optimisation : 1;
        uInt8 mouse_support       : 1;
        uInt8 terminal_detection  : 1;
        uInt8 color_change        : 1;
        uInt8 vgafont             : 1;
        uInt8 newfont             : 1;
        uInt8                     : 2;  // padding bits
        fc::encoding encoding;

      #if defined(__FreeBSD__) || defined(__DragonFly__) || defined(UNIT_TEST)
        uInt8 meta_sends_escape  : 1;
        uInt8 change_cursorstyle : 1;
        uInt8                    : 6;  // padding bits
      #elif defined(__NetBSD__) || defined(__OpenBSD__)
        uInt8 meta_sends_escape  : 1;
        uInt8                    : 7;  // padding bits
      #endif
    } init_values;

  private:
    // Methods
    static void            init_global_values (bool);
    static void            init_terminal_device_path();
    static void            oscPrefix();
    static void            oscPostfix();
    static void            init_alt_charset();
    static void            init_pc_charset();
    static void            init_cygwin_charmap();
    static void            init_teraterm_charmap();
    static void            init_fixed_max_color();
    static void            init_keyboard();
    static void            init_termcap();
    static void            init_quirks();
    static void            init_optiMove();
    static void            init_optiAttr();
    static void            init_font();
    static void            init_locale();
    static void            init_encoding();
    static void            init_encoding_set();
    static void            init_term_encoding();
    static void            init_individual_term_encoding();
    static void            init_force_vt100_encoding();
    static void            init_utf8_without_alt_charset();
    static void            init_tab_quirks();
    static void            init_captureFontAndTitle();
    static bool            hasNoFontSettingOption();
    static void            redefineColorPalette();
    static void            restoreColorPalette();
    static void            setInsertCursorStyle();
    static void            setOverwriteCursorStyle();
    static void            enableMouse();
    static void            disableMouse();
    static void            enableApplicationEscKey();
    static void            disableApplicationEscKey();
    static void            enableKeypad();
    static void            disableKeypad();
    static void            enableAlternateCharset();
    static void            useAlternateScreenBuffer();
    static void            useNormalScreenBuffer();
    void                   allocationValues();
    void                   deallocationValues();
    void                   init (bool);
    void                   initOSspecifics();
    void                   initTermspecifics();
    void                   initBaudRate();
    void                   finish();
    void                   finishOSspecifics1();
    void                   finish_encoding();
    static void            setSignalHandler();
    static void            resetSignalHandler();
    static void            signal_handler (int);

    // Data Members
    static FTermData*      data;
    static FSystem*        fsys;
    static FOptiMove*      opti_move;
    static FOptiAttr*      opti_attr;
    static FTermDetection* term_detection;
    static FTermXTerminal* xterm;
    static FKeyboard*      keyboard;
    static FMouseControl*  mouse;

#if defined(UNIT_TEST)
    #undef linux
    static FTermLinux*     linux;
    static FTermFreeBSD*   freebsd;
    static FTermOpenBSD*   openbsd;
#elif defined(__linux__)
    #undef linux
    static FTermLinux*     linux;
#elif defined(__FreeBSD__) || defined(__DragonFly__)
    static FTermFreeBSD*   freebsd;
#elif defined(__NetBSD__) || defined(__OpenBSD__)
    static FTermOpenBSD*   openbsd;
#endif

#if DEBUG
    static FTermDebugData* debug_data;
#endif
};

#pragma pack(pop)

// FTerm inline functions
//----------------------------------------------------------------------
inline const char* FTerm::getClassName() const
{ return "FTerm"; }

//----------------------------------------------------------------------
inline int FTerm::getTTYFileDescriptor()
{ return ( data ) ? data->getTTYFileDescriptor() : 0; }

//----------------------------------------------------------------------
inline char* FTerm::getTermType()
{ return data->getTermType(); }

//----------------------------------------------------------------------
inline char* FTerm::getTermFileName()
{ return data->getTermFileName(); }

//----------------------------------------------------------------------
inline int FTerm::getTabstop()
{ return FTermcap::tabstop; }

//----------------------------------------------------------------------
inline int FTerm::getMaxColor()
{ return FTermcap::max_color; }

//----------------------------------------------------------------------
inline FTerm::initializationValues& FTerm::getInitValues()
{ return init_values; }

//----------------------------------------------------------------------
inline FTerm::characterSub& FTerm::getCharSubstitutionMap()
{ return data->getCharSubstitutionMap(); }

//----------------------------------------------------------------------
inline FTermData* FTerm::getFTermData()
{
  if ( data == 0 )
  {
    try
    {
      data = new FTermData;
    }
    catch (const std::bad_alloc& ex)
    {
      std::cerr << bad_alloc_str << ex.what() << std::endl;
      std::abort();
    }
  }

  return data;
}

//----------------------------------------------------------------------
inline FSystem* FTerm::getFSystem()
{
  if ( fsys == 0 )
  {
    try
    {
      fsys = new FSystemImpl;
    }
    catch (const std::bad_alloc& ex)
    {
      std::cerr << bad_alloc_str << ex.what() << std::endl;
      std::abort();
    }
  }

  return fsys;
}

//----------------------------------------------------------------------
inline FOptiMove* FTerm::getFOptiMove()
{
  if ( opti_move == 0 )
  {
    try
    {
      opti_move = new FOptiMove;
    }
    catch (const std::bad_alloc& ex)
    {
      std::cerr << bad_alloc_str << ex.what() << std::endl;
      std::abort();
    }
  }

  return opti_move;
}

//----------------------------------------------------------------------
inline FOptiAttr* FTerm::getFOptiAttr()
{
  if ( opti_attr == 0 )
  {
    try
    {
      opti_attr = new FOptiAttr;
    }
    catch (const std::bad_alloc& ex)
    {
      std::cerr << bad_alloc_str << ex.what() << std::endl;
      std::abort();
    }
  }

  return opti_attr;
}

//----------------------------------------------------------------------
inline FTermDetection* FTerm::getFTermDetection()
{
  if ( term_detection == 0 )
  {
    try
    {
      term_detection = new FTermDetection;
    }
    catch (const std::bad_alloc& ex)
    {
      std::cerr << bad_alloc_str << ex.what() << std::endl;
      std::abort();
    }
  }

  return term_detection;
}
//----------------------------------------------------------------------
inline FTermXTerminal* FTerm::getFTermXTerminal()
{
  if ( xterm == 0 )
  {
    try
    {
      xterm = new FTermXTerminal;
    }
    catch (const std::bad_alloc& ex)
    {
      std::cerr << bad_alloc_str << ex.what() << std::endl;
      std::abort();
    }
  }

  return xterm;
}
//----------------------------------------------------------------------
inline FKeyboard* FTerm::getFKeyboard()
{
  if ( keyboard == 0 )
  {
    try
    {
      keyboard = new FKeyboard;
    }
    catch (const std::bad_alloc& ex)
    {
      std::cerr << bad_alloc_str << ex.what() << std::endl;
      std::abort();
    }
  }

  return keyboard;
}
//----------------------------------------------------------------------
inline FMouseControl* FTerm::getFMouseControl()
{
  if ( mouse == 0 )
  {
    try
    {
      mouse = new FMouseControl;
    }
    catch (const std::bad_alloc& ex)
    {
      std::cerr << bad_alloc_str << ex.what() << std::endl;
      std::abort();
    }
  }

  return mouse;
}

#if defined(__linux__)
//----------------------------------------------------------------------
inline FTermLinux* FTerm::getFTermLinux()
{
  if ( linux == 0 )
  {
    try
    {
      linux = new FTermLinux;
    }
    catch (const std::bad_alloc& ex)
    {
      std::cerr << bad_alloc_str << ex.what() << std::endl;
      std::abort();
    }
  }

  return linux;
}

#elif defined(__FreeBSD__) || defined(__DragonFly__) || defined(UNIT_TEST)
//----------------------------------------------------------------------
inline FTermFreeBSD* FTerm::getFTermFreeBSD()
{
  if ( freebsd == 0 )
  {
    try
    {
      freebsd = new FTermFreeBSD;
    }
    catch (const std::bad_alloc& ex)
    {
      std::cerr << bad_alloc_str << ex.what() << std::endl;
      std::abort();
    }
  }

  return freebsd;
}

#elif defined(__NetBSD__) || defined(__OpenBSD__) || defined(UNIT_TEST)
//----------------------------------------------------------------------
inline FTermOpenBSD* FTerm::getFTermOpenBSD()
{
  if ( openbsd == 0 )
  {
    try
    {
      openbsd = new FTermOpenBSD;
    }
    catch (const std::bad_alloc& ex)
    {
      std::cerr << bad_alloc_str << ex.what() << std::endl;
      std::abort();
    }
  }

  return openbsd;
}
#endif

#if DEBUG
//----------------------------------------------------------------------
inline FTermDebugData& FTerm::getFTermDebugData()
{
  if ( debug_data == 0 )
  {
    try
    {
      debug_data = new FTermDebugData;
    }
    catch (const std::bad_alloc& ex)
    {
      std::cerr << bad_alloc_str << ex.what() << std::endl;
      std::abort();
    }
  }

  return *debug_data;
}
#endif  // DEBUG

//----------------------------------------------------------------------
inline bool FTerm::hasUTF8()
{ return data->hasUTF8Console(); }

//----------------------------------------------------------------------
inline bool FTerm::isMonochron()
{ return data->isMonochron(); }

//----------------------------------------------------------------------
inline bool FTerm::isXTerminal()
{ return term_detection->isXTerminal(); }

//----------------------------------------------------------------------
inline bool FTerm::isAnsiTerminal()
{ return term_detection->isAnsiTerminal(); }

//----------------------------------------------------------------------
inline bool FTerm::isRxvtTerminal()
{ return term_detection->isRxvtTerminal(); }

//----------------------------------------------------------------------
inline bool FTerm::isUrxvtTerminal()
{ return term_detection->isUrxvtTerminal(); }

//----------------------------------------------------------------------
inline bool FTerm::isMltermTerminal()
{ return term_detection->isMltermTerminal(); }

//----------------------------------------------------------------------
inline bool FTerm::isPuttyTerminal()
{ return term_detection->isPuttyTerminal(); }

//----------------------------------------------------------------------
inline bool FTerm::isKdeTerminal()
{ return term_detection->isKdeTerminal(); }

//----------------------------------------------------------------------
inline bool FTerm::isGnomeTerminal()
{ return term_detection->isGnomeTerminal(); }

//----------------------------------------------------------------------
inline bool FTerm::isKtermTerminal()
{ return term_detection->isKtermTerminal(); }

//----------------------------------------------------------------------
inline bool FTerm::isTeraTerm()
{ return term_detection->isTeraTerm(); }

//----------------------------------------------------------------------
inline bool FTerm::isSunTerminal()
{ return term_detection->isSunTerminal(); }

//----------------------------------------------------------------------
inline bool FTerm::isCygwinTerminal()
{ return term_detection->isCygwinTerminal(); }

//----------------------------------------------------------------------
inline bool FTerm::isMinttyTerm()
{ return term_detection->isMinttyTerm(); }

//----------------------------------------------------------------------
inline bool FTerm::isLinuxTerm()
{ return term_detection->isLinuxTerm(); }

//----------------------------------------------------------------------
inline bool FTerm::isFreeBSDTerm()
{ return term_detection->isFreeBSDTerm(); }

//----------------------------------------------------------------------
inline bool FTerm::isNetBSDTerm()
{ return term_detection->isNetBSDTerm(); }

//----------------------------------------------------------------------
inline bool FTerm::isOpenBSDTerm()
{ return term_detection->isOpenBSDTerm(); }

//----------------------------------------------------------------------
inline bool FTerm::isScreenTerm()
{ return term_detection->isScreenTerm(); }

//----------------------------------------------------------------------
inline bool FTerm::isTmuxTerm()
{ return term_detection->isTmuxTerm(); }

//----------------------------------------------------------------------
inline bool FTerm::isNewFont()
{ return data->isNewFont(); }

//----------------------------------------------------------------------
inline bool FTerm::hasChangedTermSize()
{ return data->hasTermResized(); }

//----------------------------------------------------------------------
inline bool FTerm::hasShadowCharacter()
{ return data->hasShadowCharacter(); }

//----------------------------------------------------------------------
inline bool FTerm::hasHalfBlockCharacter()
{ return data->hasHalfBlockCharacter(); }

//----------------------------------------------------------------------
inline bool FTerm::hasAlternateScreen()
{ return data->hasAlternateScreen(); }

//----------------------------------------------------------------------
inline void FTerm::setFSystem (FSystem* fsystem)
{ fsys = fsystem; }

//----------------------------------------------------------------------
inline bool FTerm::setUTF8()
{ return setUTF8(true); }

//----------------------------------------------------------------------
inline bool FTerm::unsetUTF8()
{ return setUTF8(false); }

//----------------------------------------------------------------------
inline void FTerm::changeTermSizeFinished()
{ data->setTermResized(false); }

}  // namespace finalcut


namespace
{

//----------------------------------------------------------------------
inline std::ostream& operator << ( std::ostream& os
                                 , finalcut::fc::SpecialCharacter c )
{
  return os << static_cast<char>(c);
}

//----------------------------------------------------------------------
inline std::wostream& operator << ( std::wostream& os
                                  , finalcut::fc::SpecialCharacter c )
{
  return os << static_cast<wchar_t>(c);
}

}  // namespace

#endif  // FTERM_H