386 lines
13 KiB
C++
386 lines
13 KiB
C++
/***********************************************************************
|
|
* foptimove.cpp - Cursor movement optimization *
|
|
* *
|
|
* This file is part of the Final Cut widget toolkit *
|
|
* *
|
|
* Copyright 2015-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
|
|
* ════════════════
|
|
*
|
|
* ▕▔▔▔▔▔▔▔▔▔▔▔▏
|
|
* ▕ FOptiMove ▏
|
|
* ▕▁▁▁▁▁▁▁▁▁▁▁▏
|
|
*/
|
|
|
|
// The cursor optimization based on ncurses lib_mvcur.c
|
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
#ifndef FOPTIMOVE_H
|
|
#define FOPTIMOVE_H
|
|
|
|
#if !defined (USE_FINAL_H) && !defined (COMPILE_FINAL_CUT)
|
|
#error "Only <final/final.h> can be included directly."
|
|
#endif
|
|
|
|
#include <assert.h>
|
|
|
|
#if defined(__sun) && defined(__SVR4)
|
|
#include <termio.h>
|
|
typedef struct termio SGTTY;
|
|
typedef struct termios SGTTYS;
|
|
|
|
#ifdef _LP64
|
|
typedef unsigned int chtype;
|
|
#else
|
|
typedef unsigned long chtype;
|
|
#endif // _LP64
|
|
|
|
#include <term.h> // need for tparm
|
|
#else
|
|
#include <term.h> // need for tparm
|
|
#endif // defined(__sun) && defined(__SVR4)
|
|
|
|
#include <cctype>
|
|
#include <climits>
|
|
#include <cstdio> // need for printf
|
|
#include <cstdlib>
|
|
#include <cstring>
|
|
#include <iostream>
|
|
|
|
#include "final/ftypes.h"
|
|
|
|
namespace finalcut
|
|
{
|
|
|
|
//----------------------------------------------------------------------
|
|
// class FOptiMove
|
|
//----------------------------------------------------------------------
|
|
|
|
#pragma pack(push)
|
|
#pragma pack(1)
|
|
|
|
class FOptiMove
|
|
{
|
|
public:
|
|
// Typedef
|
|
typedef struct
|
|
{
|
|
bool automatic_left_margin;
|
|
bool eat_nl_glitch;
|
|
int tabstop;
|
|
char* t_cursor_home;
|
|
char* t_carriage_return;
|
|
char* t_cursor_to_ll;
|
|
char* t_tab;
|
|
char* t_back_tab;
|
|
char* t_cursor_up;
|
|
char* t_cursor_down;
|
|
char* t_cursor_left;
|
|
char* t_cursor_right;
|
|
char* t_cursor_address;
|
|
char* t_column_address;
|
|
char* t_row_address;
|
|
char* t_parm_up_cursor;
|
|
char* t_parm_down_cursor;
|
|
char* t_parm_left_cursor;
|
|
char* t_parm_right_cursor;
|
|
char* t_erase_chars;
|
|
char* t_repeat_char;
|
|
char* t_clr_bol;
|
|
char* t_clr_eol;
|
|
} termEnv;
|
|
|
|
// Constructor
|
|
explicit FOptiMove (int = 0);
|
|
|
|
// Destructor
|
|
virtual ~FOptiMove();
|
|
|
|
// Accessors
|
|
const char* getClassName() const;
|
|
uInt getCursorHomeLength() const;
|
|
uInt getCarriageReturnLength() const;
|
|
uInt getCursorToLLLength() const;
|
|
uInt getTabLength() const;
|
|
uInt getBackTabLength() const;
|
|
uInt getCursorUpLength() const;
|
|
uInt getCursorDownLength() const;
|
|
uInt getCursorLeftLength() const;
|
|
uInt getCursorRightLength() const;
|
|
uInt getCursorAddressLength() const;
|
|
uInt getColumnAddressLength() const;
|
|
uInt getRowAddressLength() const;
|
|
uInt getParmUpCursorLength() const;
|
|
uInt getParmDownCursorLength() const;
|
|
uInt getParmLeftCursorLength() const;
|
|
uInt getParmRightCursorLength() const;
|
|
uInt getEraseCharsLength() const;
|
|
uInt getRepeatCharLength() const;
|
|
uInt getClrBolLength() const;
|
|
uInt getClrEolLength() const;
|
|
|
|
// Mutators
|
|
void setBaudRate (int);
|
|
void setTabStop (int);
|
|
void setTermSize (std::size_t, std::size_t);
|
|
void setTermEnvironment (termEnv&);
|
|
void set_cursor_home (char[]);
|
|
void set_cursor_to_ll (char[]);
|
|
void set_carriage_return (char[]);
|
|
void set_tabular (char[]);
|
|
void set_back_tab (char[]);
|
|
void set_cursor_up (char[]);
|
|
void set_cursor_down (char[]);
|
|
void set_cursor_left (char[]);
|
|
void set_cursor_right (char[]);
|
|
void set_cursor_address (char[]);
|
|
void set_column_address (char[]);
|
|
void set_row_address (char[]);
|
|
void set_parm_up_cursor (char[]);
|
|
void set_parm_down_cursor (char[]);
|
|
void set_parm_left_cursor (char[]);
|
|
void set_parm_right_cursor (char[]);
|
|
void set_erase_chars (char[]);
|
|
void set_repeat_char (char[]);
|
|
void set_clr_bol (char[]);
|
|
void set_clr_eol (char[]);
|
|
void set_auto_left_margin (const bool&);
|
|
void set_eat_newline_glitch (const bool&);
|
|
|
|
// Methods
|
|
void check_boundaries (int&, int&, int&, int&);
|
|
char* moveCursor (int, int, int, int);
|
|
|
|
private:
|
|
// Constant
|
|
static const std::size_t BUF_SIZE{512};
|
|
|
|
// Typedef
|
|
typedef struct
|
|
{
|
|
char* cap;
|
|
int duration;
|
|
int length;
|
|
} capability;
|
|
|
|
// Constants
|
|
static const int LONG_DURATION{INT_MAX};
|
|
// value for a long capability waiting time
|
|
static const int MOVE_LIMIT{7};
|
|
// maximum character distance to avoid direct cursor addressing
|
|
|
|
// Methods
|
|
void calculateCharDuration();
|
|
int capDuration (char[], int);
|
|
int capDurationToLength (int);
|
|
int repeatedAppend (const capability&, volatile int, char*);
|
|
int relativeMove (char[], int, int, int, int);
|
|
int verticalMove (char[], int, int);
|
|
void downMove (char[], int&, int, int);
|
|
void upMove (char[], int&, int, int);
|
|
int horizontalMove (char[], int, int);
|
|
void rightMove (char[], int&, int, int);
|
|
void leftMove (char[], int&, int, int);
|
|
|
|
bool isWideMove (int, int, int, int);
|
|
bool isMethod0Faster (int&, int, int);
|
|
bool isMethod1Faster (int&, int, int, int, int);
|
|
bool isMethod2Faster (int&, int, int, int);
|
|
bool isMethod3Faster (int&, int, int);
|
|
bool isMethod4Faster (int&, int, int);
|
|
bool isMethod5Faster (int&, int, int, int);
|
|
void moveByMethod (int, int, int, int, int);
|
|
|
|
// Friend function
|
|
friend void printDurations (const FOptiMove&);
|
|
|
|
// Data Members
|
|
capability F_cursor_home{};
|
|
capability F_carriage_return{};
|
|
capability F_cursor_to_ll{};
|
|
capability F_tab{};
|
|
capability F_back_tab{};
|
|
capability F_cursor_up{};
|
|
capability F_cursor_down{};
|
|
capability F_cursor_left{};
|
|
capability F_cursor_right{};
|
|
capability F_cursor_address{};
|
|
capability F_column_address{};
|
|
capability F_row_address{};
|
|
capability F_parm_up_cursor{};
|
|
capability F_parm_down_cursor{};
|
|
capability F_parm_left_cursor{};
|
|
capability F_parm_right_cursor{};
|
|
capability F_erase_chars{};
|
|
capability F_repeat_char{};
|
|
capability F_clr_bol{};
|
|
capability F_clr_eol{};
|
|
|
|
bool automatic_left_margin{false};
|
|
bool eat_nl_glitch{false};
|
|
char move_buf[BUF_SIZE]{};
|
|
int char_duration{1};
|
|
int baudrate{9600};
|
|
int tabstop{0};
|
|
std::size_t screen_width{80};
|
|
std::size_t screen_height{24};
|
|
};
|
|
#pragma pack(pop)
|
|
|
|
|
|
// FOptiMove inline functions
|
|
//----------------------------------------------------------------------
|
|
inline const char* FOptiMove::getClassName() const
|
|
{ return "FOptiMove"; }
|
|
|
|
//----------------------------------------------------------------------
|
|
inline uInt FOptiMove::getCursorHomeLength() const
|
|
{ return uInt(F_cursor_home.length); }
|
|
|
|
//----------------------------------------------------------------------
|
|
inline uInt FOptiMove::getCarriageReturnLength() const
|
|
{ return uInt(F_carriage_return.length); }
|
|
|
|
//----------------------------------------------------------------------
|
|
inline uInt FOptiMove::getCursorToLLLength() const
|
|
{ return uInt(F_cursor_to_ll.length); }
|
|
|
|
//----------------------------------------------------------------------
|
|
inline uInt FOptiMove::getTabLength() const
|
|
{ return uInt(F_tab.length); }
|
|
|
|
//----------------------------------------------------------------------
|
|
inline uInt FOptiMove::getBackTabLength() const
|
|
{ return uInt(F_back_tab.length); }
|
|
|
|
//----------------------------------------------------------------------
|
|
inline uInt FOptiMove::getCursorUpLength() const
|
|
{ return uInt(F_cursor_up.length); }
|
|
|
|
//----------------------------------------------------------------------
|
|
inline uInt FOptiMove::getCursorDownLength() const
|
|
{ return uInt(F_cursor_down.length); }
|
|
|
|
//----------------------------------------------------------------------
|
|
inline uInt FOptiMove::getCursorLeftLength() const
|
|
{ return uInt(F_cursor_left.length); }
|
|
|
|
//----------------------------------------------------------------------
|
|
inline uInt FOptiMove::getCursorRightLength() const
|
|
{ return uInt(F_cursor_right.length); }
|
|
|
|
//----------------------------------------------------------------------
|
|
inline uInt FOptiMove::getCursorAddressLength() const
|
|
{ return uInt(F_cursor_address.length); }
|
|
|
|
//----------------------------------------------------------------------
|
|
inline uInt FOptiMove::getColumnAddressLength() const
|
|
{ return uInt(F_column_address.length); }
|
|
|
|
//----------------------------------------------------------------------
|
|
inline uInt FOptiMove::getRowAddressLength() const
|
|
{ return uInt(F_row_address.length); }
|
|
|
|
//----------------------------------------------------------------------
|
|
inline uInt FOptiMove::getParmUpCursorLength() const
|
|
{ return uInt(F_parm_up_cursor.length); }
|
|
|
|
//----------------------------------------------------------------------
|
|
inline uInt FOptiMove::getParmDownCursorLength() const
|
|
{ return uInt(F_parm_down_cursor.length); }
|
|
|
|
//----------------------------------------------------------------------
|
|
inline uInt FOptiMove::getParmLeftCursorLength() const
|
|
{ return uInt(F_parm_left_cursor.length); }
|
|
|
|
//----------------------------------------------------------------------
|
|
inline uInt FOptiMove::getParmRightCursorLength() const
|
|
{ return uInt(F_parm_right_cursor.length); }
|
|
|
|
//----------------------------------------------------------------------
|
|
inline uInt FOptiMove::getEraseCharsLength() const
|
|
{ return uInt(F_erase_chars.length); }
|
|
|
|
//----------------------------------------------------------------------
|
|
inline uInt FOptiMove::getRepeatCharLength() const
|
|
{ return uInt(F_repeat_char.length); }
|
|
|
|
//----------------------------------------------------------------------
|
|
inline uInt FOptiMove::getClrBolLength() const
|
|
{ return uInt(F_clr_bol.length); }
|
|
|
|
//----------------------------------------------------------------------
|
|
inline uInt FOptiMove::getClrEolLength() const
|
|
{ return uInt(F_clr_eol.length); }
|
|
|
|
//----------------------------------------------------------------------
|
|
inline void FOptiMove::set_auto_left_margin (const bool& bcap)
|
|
{ automatic_left_margin = bcap; }
|
|
|
|
//----------------------------------------------------------------------
|
|
inline void FOptiMove::set_eat_newline_glitch (const bool& bcap)
|
|
{ eat_nl_glitch = bcap; }
|
|
|
|
|
|
// FOptiMove non-member function
|
|
//----------------------------------------------------------------------
|
|
inline void printDurations (const FOptiMove& om)
|
|
{
|
|
std::cout << " speed: "
|
|
<< om.baudrate << " baud\r\n";
|
|
std::cout << " char_duration: "
|
|
<< om.char_duration << " ms\r\n";
|
|
std::cout << " cursor_home: "
|
|
<< om.F_cursor_home.duration << " ms\r\n";
|
|
std::cout << " cursor_to_ll: "
|
|
<< om.F_cursor_to_ll.duration << " ms\r\n";
|
|
std::cout << " carriage_return: "
|
|
<< om.F_carriage_return.duration << " ms\r\n";
|
|
std::cout << " tab: "
|
|
<< om.F_tab.duration << " ms\r\n";
|
|
std::cout << " back_tab: "
|
|
<< om.F_back_tab.duration << " ms\r\n";
|
|
std::cout << " cursor_up: "
|
|
<< om.F_cursor_up.duration << " ms\r\n";
|
|
std::cout << " cursor_down: "
|
|
<< om.F_cursor_down.duration << " ms\r\n";
|
|
std::cout << " cursor_left: "
|
|
<< om.F_cursor_left.duration << " ms\r\n";
|
|
std::cout << " cursor_right: "
|
|
<< om.F_cursor_right.duration << " ms\r\n";
|
|
std::cout << " cursor_address: "
|
|
<< om.F_cursor_address.duration << " ms\r\n";
|
|
std::cout << " column_address: "
|
|
<< om.F_column_address.duration << " ms\r\n";
|
|
std::cout << " row_address: "
|
|
<< om.F_row_address.duration << " ms\r\n";
|
|
std::cout << " parm_up_cursor: "
|
|
<< om.F_parm_up_cursor.duration << " ms\r\n";
|
|
std::cout << " parm_down_cursor: "
|
|
<< om.F_parm_down_cursor.duration << " ms\r\n";
|
|
std::cout << " parm_left_cursor: "
|
|
<< om.F_parm_left_cursor.duration << " ms\r\n";
|
|
std::cout << "parm_right_cursor: "
|
|
<< om.F_parm_right_cursor.duration << " ms\r\n";
|
|
}
|
|
|
|
} // namespace finalcut
|
|
|
|
#endif // FOPTIMOVE_H
|