finalcut/include/final/fkeyboard.h

254 lines
7.9 KiB
C++

/***********************************************************************
* fkeyboard.h - Read keyboard events *
* *
* This file is part of the Final Cut widget toolkit *
* *
* Copyright 2018 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/>. *
***********************************************************************/
/* Standalone class
* ════════════════
*
* ▕▔▔▔▔▔▔▔▔▔▔▔▏
* ▕ FKeyboard ▏
* ▕▁▁▁▁▁▁▁▁▁▁▁▏
*/
#ifndef FKEYBOARD_H
#define FKEYBOARD_H
#if !defined (USE_FINAL_H) && !defined (COMPILE_FINAL_CUT)
#error "Only <final/final.h> can be included directly."
#endif
#include "final/fobject.h"
#include "final/ftypes.h"
#if defined(__linux__)
#include "final/ftermlinux.h"
#endif
// class forward declaration
class FApplication;
//----------------------------------------------------------------------
// class FKeyboardCommand
//----------------------------------------------------------------------
#pragma pack(push)
#pragma pack(1)
class FKeyboardCommand
{
public:
// Constructor
FKeyboardCommand (FApplication* = 0, void(FApplication::*)() = 0);
// Method
void execute();
private:
// Data Members
FApplication* instance;
void (FApplication::*handler)();
};
#pragma pack(pop)
//----------------------------------------------------------------------
// class FKeyboard
//----------------------------------------------------------------------
#pragma pack(push)
#pragma pack(1)
class FKeyboard
{
public:
// Constructor
FKeyboard();
// Destructor
~FKeyboard();
// Accessors
int getKey();
const FString getKeyName (int);
char* getKeyBuffer();
int getKeyBufferSize();
timeval* getKeyPressedTime();
// Mutators
void setTermcapMap (fc::fkeymap*);
void setKeypressTimeout (const long);
void enableUTF8();
void disableUTF8();
void enableMouseSequences();
void disableMouseSequences();
#if defined(__linux__)
void setFTermLinux (FTermLinux*);
#endif
void setPressCommand (FKeyboardCommand);
void setReleaseCommand (FKeyboardCommand);
void setEscPressedCommand (FKeyboardCommand);
// Inquiry
bool isInputDataPending();
// Methods
bool& unprocessedInput();
bool isKeyPressed();
void emptyKeyBufferOnTimeout();
void fetchKeyCode();
void escapeKeyHandling();
private:
// Constants
static const int NEED_MORE_DATA = -1;
// Disable copy constructor
FKeyboard (const FKeyboard&);
// Disable assignment operator (=)
FKeyboard& operator = (const FKeyboard&);
// Accessors
int getMouseProtocolKey();
int getTermcapKey();
int getMetaKey();
int getSingleKey();
// Mutators
bool setNonBlockingInput (bool);
bool setNonBlockingInput();
bool unsetNonBlockingInput();
// Inquiry
static bool isKeypressTimeout (timeval*);
// Methods
int UTF8decode (const char[]);
ssize_t readKey();
void parseKeyBuffer();
int parseKeyString();
int keyCorrection (const int&);
void keyPressed();
void keyReleased();
void escapeKeyPressed();
// Data Members
int key;
char k_buf[1024];
char fifo_buf[512];
int fifo_offset;
bool fifo_in_use;
int fifo_buf_size;
int stdin_status_flags;
static long key_timeout;
bool input_data_pending;
bool utf8_input;
bool mouse_support;
bool non_blocking_stdin;
FKeyboardCommand keypressed_cmd;
FKeyboardCommand keyreleased_cmd;
FKeyboardCommand escape_key_cmd;
struct timeval time_keypressed;
fc::fkeymap* termcap_map;
//void* termcap_map;
#if defined(__linux__)
#undef linux
static FTermLinux* linux;
#endif
};
#pragma pack(pop)
// FKeyboard inline functions
//----------------------------------------------------------------------
inline int FKeyboard::getKey()
{ return key; }
inline char* FKeyboard::getKeyBuffer()
{ return fifo_buf; }
//----------------------------------------------------------------------
inline int FKeyboard::getKeyBufferSize()
{ return fifo_buf_size; }
//----------------------------------------------------------------------
inline struct timeval* FKeyboard::getKeyPressedTime()
{ return &time_keypressed; }
//----------------------------------------------------------------------
inline void FKeyboard::setKeypressTimeout (const long timeout)
{ key_timeout = timeout; }
//----------------------------------------------------------------------
inline void FKeyboard::enableUTF8()
{ utf8_input = true; }
//----------------------------------------------------------------------
inline void FKeyboard::disableUTF8()
{ utf8_input = false; }
//----------------------------------------------------------------------
inline void FKeyboard::enableMouseSequences()
{ mouse_support = true; }
//----------------------------------------------------------------------
inline void FKeyboard::disableMouseSequences()
{ mouse_support = false; }
#if defined(__linux__)
//----------------------------------------------------------------------
inline void FKeyboard::setFTermLinux (FTermLinux* linux_obj)
{ linux = linux_obj; }
#endif
//----------------------------------------------------------------------
inline void FKeyboard::setPressCommand (FKeyboardCommand cmd)
{ keypressed_cmd = cmd; }
//----------------------------------------------------------------------
inline void FKeyboard::setReleaseCommand (FKeyboardCommand cmd)
{ keyreleased_cmd = cmd; }
//----------------------------------------------------------------------
inline void FKeyboard::setEscPressedCommand (FKeyboardCommand cmd)
{ escape_key_cmd = cmd; }
//----------------------------------------------------------------------
inline bool FKeyboard::isKeypressTimeout (timeval* time)
{ return FObject::isTimeout (time, key_timeout); }
//----------------------------------------------------------------------
inline bool FKeyboard::isInputDataPending()
{ return input_data_pending; }
//----------------------------------------------------------------------
inline bool FKeyboard::setNonBlockingInput()
{ return setNonBlockingInput(true); }
//----------------------------------------------------------------------
inline bool FKeyboard::unsetNonBlockingInput()
{ return setNonBlockingInput(false); }
#endif // FKEYBOARD_H