perso
/
finalcut
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge pull request #79 from gansm/master 

merge
This commit is contained in:
Markus Gans 2020-11-07 21:56:51 +01:00 committed by GitHub
parent 5149301d29 d71ca6f028
commit 09d494cb65
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
93 changed files with 7635 additions and 9420 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
ChangeLog
View File

@ -1,3 +1,35 @@
2019-11-07 Markus Gans <guru.mail@muenster.de>
* Version 0.7.0
2020-11-04 Markus Gans <guru.mail@muenster.de>
* Elimination of unnecessary terminal flushes
2020-11-03 Markus Gans <guru.mail@muenster.de>
* Use FIONREAD to get the number of characters available
for reading on stdin
2020-11-02 Markus Gans <guru.mail@muenster.de>
* Non-blocking reading before timeout after keystroke
* Every fourth event processing causes a terminal flush
* Call of TIOCLINUX only in the Linux console
2020-11-01 Markus Gans <guru.mail@muenster.de>
* Now FINAL CUT queues keyboard and mouse input to speed up
the processing of widget events
2020-10-22 Markus Gans <guru.mail@muenster.de>
* Repair terminal update skipping
2020-10-20 Markus Gans <guru.mail@muenster.de>
* For fast mouse movements the keyboard interval was increased
from 13.3 to 30 Hz
2020-10-19 Markus Gans <guru.mail@muenster.de>
* Optimize the terminal output speed
2020-10-17 Markus Gans <guru.mail@muenster.de>
* Fixes unit test segfault
2020-10-11 Markus Gans <guru.mail@muenster.de>
* Solaris build fix
* Added saving and restoring xterm titles to the stack
@ -224,7 +256,7 @@
* Revision of FString number input stream
2019-11-16 Markus Gans <guru.mail@muenster.de>
* New Widget class FSpinBox to provide spin boxes
* New widget class FSpinBox to provide spin boxes
2019-11-06 Markus Gans <guru.mail@muenster.de>
* Improved display of the NewFont midline

4
configure.ac
View File

@ -4,7 +4,7 @@
# Process this file with autoconf to produce a configure script.
AC_INIT([finalcut], [0.6.1])
AC_INIT([finalcut], [0.7.0])
AC_CONFIG_HEADER([config.h])
AX_PREFIX_CONFIG_H([src/include/final/fconfig.h], [F])
AC_CONFIG_SRCDIR([src/fobject.cpp])
@ -64,7 +64,7 @@ LT_OUTPUT
### This defines the version number of the installed .so files
### Update this value for every release! (A:B:C will map to foo.so.(A-C).C.B)
### using libtool's versioning system.
AC_SUBST(SO_VERSION, ["6:1:6"])
AC_SUBST(SO_VERSION, ["7:0:7"])
AC_SUBST([LIBTOOL_DEPS])

6
debian/changelog vendored
View File

@ -1,3 +1,9 @@
finalcut (0.7.0) unstable; urgency=low
* Release (version 0.7.0)
-- Markus Gans <guru.mail@muenster.de> Sat, 07 Nov 2020 11:24:39 +0100
finalcut (0.6.0) unstable; urgency=low
* Release (version 0.6.0)

34
debian/libfinal-dev.docs vendored
View File

@ -3,21 +3,34 @@ COPYING
COPYING.LESSER
ChangeLog
README.md
doc/calendar-draft.png
doc/benchmark.md
doc/calculator.png
doc/calendar-draft.png
doc/class-diagram.txt
doc/class_template.cpp
doc/class_template.h
doc/coding-style.txt
doc/console_codes-manual.sh
doc/console_ioctl-manual.sh
doc/faq.md
doc/fileopen-dialog.png
doc/final-cut-application-structure.svg
doc/final-cut-widget-tree.svg
doc/first-steps_callback-function.cpp.png
doc/first-steps_callback-lambda.cpp.png
doc/first-steps_callback-method.cpp.png
doc/first-steps_dialog.cpp.png
doc/first-steps_emit-signal.cpp.png
doc/first-steps.md
doc/first-steps_memory.cpp.png
doc/first-steps_scrollview.cpp.png
doc/first-steps_size-adjustment.cpp.png
doc/first-steps_timer.cpp.png
doc/first-steps_user-event.cpp.png
doc/framebuffer.txt
doc/Mandelbrot.png
doc/mouse-control.md
doc/ncurses.supp
doc/newfont1.png
doc/newfont2.png
doc/progress-bar.png
doc/readme.txt
doc/coding-style.txt
@ -25,9 +38,20 @@ doc/terminfo-capabilities.sh
doc/terminfo-manual.sh
doc/textview.png
doc/TODO
doc/user-theme-bee-palette.svg
doc/user-theme-fc16-dark-palette.svg
doc/user-theme-fc16-palette.svg
doc/user-theme-fc8-palette.svg
doc/user-theme.md
doc/user-theme.png
doc/user-theme-vga-palette.svg
doc/vga.txt
doc/vt100_line_drawing_graphics.png
doc/virtual-terminal.txt
doc/xterm.txt
doc/vt100_line_drawing_graphics.png
doc/widget-coordinates.svg
doc/widget-geometry.svg
doc/widget-lengths.svg
doc/xgraphics
doc/xterm.txt
fonts/newfont.txt

2
debian/libfinal0.shlibs vendored
View File

@ -1 +1 @@
libfinal 0 libfinal0 (>= 0.6.0)
libfinal 0 libfinal0 (>= 0.7.0)

9441
debian/libfinal0.symbols vendored
View File

File diff suppressed because it is too large Load Diff

2
doc/Makefile.am
View File

@ -18,6 +18,7 @@ EXTRA_DIST = \
faq.md \
fileopen-dialog.png \
final-cut-application-structure.svg \
final-cut-widget-tree.svg \
first-steps.md \
first-steps_callback-function.cpp.png \
first-steps_callback-lambda.cpp.png \
@ -74,6 +75,7 @@ doc_DATA = \
faq.md \
fileopen-dialog.png \
final-cut-application-structure.svg \
final-cut-widget-tree.svg \
first-steps.md \
first-steps_callback-function.cpp.png \
first-steps_callback-lambda.cpp.png \

0
doc/final-cut-widget tree.svg → doc/final-cut-widget-tree.svg
View File

Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 9.5 KiB

After

Width:  |  Height:  |  Size: 9.5 KiB

2
doc/first-steps.md
View File

@ -89,7 +89,7 @@ unique and can not have a parent widget. The class `FApplication` manages
all settings and assigns keyboard and mouse input to the different widgets.
<figure class="image">
<img src="final-cut-widget tree.svg" alt="widget tree">
<img src="final-cut-widget-tree.svg" alt="widget tree">
<figcaption>Figure 2. Widget tree of a FINAL CUT application</figcaption>
</figure>
<br /><br />

2
examples/background-color.cpp
View File

@ -183,7 +183,6 @@ void Background::cb_changed()
, int(green.getValue())
, int(blue.getValue()) );
redraw();
updateTerminal();
}
//----------------------------------------------------------------------
@ -205,7 +204,6 @@ void Background::cb_choice()
, int(green.getValue())
, int(blue.getValue()) );
redraw();
updateTerminal();
}
//----------------------------------------------------------------------

2
examples/calculator.cpp
View File

@ -335,7 +335,6 @@ void Calc::onKeyPress (finalcut::FKeyEvent* ev)
}
drawDispay();
updateTerminal();
}
ev->accept();
@ -394,7 +393,6 @@ void Calc::cb_buttonClicked (Calc::button key)
}
drawDispay();
updateTerminal();
if ( infix_operator && ! isDataEntryKey(key) )
input = "";

3
examples/choice.cpp
View File

@ -147,7 +147,7 @@ int main (int argc, char* argv[])
dgl.show();
// Get the checked radio button text
for (int n{1}; n <= int(checkButtonGroup.getCount()); n++)
for (auto n{1}; n <= int(checkButtonGroup.getCount()); n++)
{
if ( checkButtonGroup.isChecked(n) )
{
@ -157,7 +157,6 @@ int main (int argc, char* argv[])
}
} // Hide and destroy the dialog object
// Create and show tooltip for two seconds
finalcut::FToolTip tooltip{&app};
tooltip.setText ("You have chosen " + label_text);

1
examples/event-log.cpp
View File

@ -294,7 +294,6 @@ void EventLog::onTimer (finalcut::FTimerEvent*)
str("");
scrolltext.scrollToEnd();
redraw();
updateTerminal();
}
}

4
examples/fullwidth-character.cpp
View File

@ -111,7 +111,7 @@ int main (int argc, char* argv[])
};
auto cb_tooltip = \
[] (finalcut::FApplication* a)
[] (finalcut::FDialog* a)
{
finalcut::FToolTip tooltip(a);
tooltip.setText (full("A tooltip with\ncharacters\n"
@ -124,7 +124,7 @@ int main (int argc, char* argv[])
btn.addCallback ("clicked", cb_exit, std::ref(app));
Exit.addCallback ("clicked", cb_exit, std::ref(app));
Quit.addCallback ("clicked", cb_exit, std::ref(app));
key_F1.addCallback ("activate", cb_tooltip, &app);
key_F1.addCallback ("activate", cb_tooltip, &dgl);
// Set dialog object as main widget
finalcut::FWidget::setMainWidget(&dgl);

4
examples/listbox.cpp
View File

@ -116,12 +116,12 @@ Listbox::Listbox (FWidget* parent)
list1.setGeometry(FPoint{2, 1}, FSize{18, 10});
list1.setText ("FListBoxItem");
for (int i{1}; i < 30; i++)
for (auto i{1}; i < 30; i++)
list1.insert (L"----- " + (FString{} << i) + L" -----");
// listbox 2
//----------
for (int i{1}; i <= 15; i++)
for (auto i{1}; i <= 15; i++)
double_list.push_back(2 * double(i) + (double(i) / 100));
list2.setGeometry(FPoint{21, 1}, FSize{10, 10});

23
examples/mouse.cpp
View File

@ -152,7 +152,7 @@ void ColorChooser::onMouseDown (finalcut::FMouseEvent* ev)
if ( ev->getButton() == fc::MiddleButton )
return;
for (int c{0}; c < 16; c++)
for (auto c{0}; c < 16; c++)
{
const int xmin = 2 + (c / 8) * 3;
const int xmax = 4 + (c / 8) * 3;
@ -434,7 +434,7 @@ void MouseDraw::draw()
if ( finalcut::FTerm::isNewFont() )
{
for (int y{2}; y < y_max; y++)
for (auto y{2}; y < y_max; y++)
{
print() << FPoint{10, y}
<< fc::NF_rev_border_line_right;
@ -448,7 +448,7 @@ void MouseDraw::draw()
print() << FPoint{10, 2}
<< fc::BoxDrawingsDownAndHorizontal;
for (int y{3}; y < y_max; y++)
for (auto y{3}; y < y_max; y++)
{
print() << FPoint{10, y} << fc::BoxDrawingsVertical;
}
@ -503,14 +503,14 @@ void MouseDraw::drawCanvas()
const int x_end = canvas->width;
const int w_line_len = printarea->width + printarea->right_shadow;
for (int y{0}; y < y_end; y++) // line loop
for (auto y{0}; y < y_end; y++) // line loop
{
const finalcut::FChar* canvaschar{}; // canvas character
finalcut::FChar* winchar{}; // window character
canvaschar = &canvas->data[y * x_end];
winchar = &printarea->data[(ay + y) * w_line_len + ax];
std::memcpy ( winchar
, canvaschar
// canvas character
const auto& canvaschar = canvas->data[y * x_end];
// window character
auto& winchar = printarea->data[(ay + y) * w_line_len + ax];
std::memcpy ( &winchar
, &canvaschar
, sizeof(finalcut::FChar) * unsigned(x_end) );
if ( int(printarea->changes[ay + y].xmin) > ax )
@ -521,6 +521,9 @@ void MouseDraw::drawCanvas()
}
printarea->has_changes = true;
if ( updateTerminal() )
flush();
}
//----------------------------------------------------------------------

13
examples/opti-move.cpp
View File

@ -27,10 +27,6 @@
#include <final/final.h>
// Global FApplication object
static finalcut::FApplication* app{nullptr};
// function prototype
bool keyPressed();
void term_boundaries (int&, int&);
@ -66,8 +62,8 @@ bool keyPressed()
void term_boundaries (int& x, int& y)
{
// checks and corrects the terminal boundaries
const auto term_width = int(app->getDesktopWidth());
const auto term_height = int(app->getDesktopHeight());
const auto term_width = int(finalcut::FTerm::getColumnNumber());
const auto term_height = int(finalcut::FTerm::getLineNumber());
if ( x < 0 )
x = 0;
@ -226,9 +222,6 @@ int main (int argc, char* argv[])
if ( finalcut::FApplication::isQuit() )
return 0;
// Pointer to the global virtual terminal object
app = &term_app;
// Get screen dimension
auto xmax = int(term_app.getDesktopWidth() - 1);
auto ymax = int(term_app.getDesktopHeight() - 1);
@ -282,7 +275,5 @@ int main (int argc, char* argv[])
// Waiting for keypress
keyPressed();
app = nullptr; // End of term_app object scope
return 0;
}

8
examples/rotozoomer.cpp
View File

@ -157,13 +157,13 @@ void RotoZoomer::rotozoomer (double cx, double cy, double r, double a)
int dxdy = (Cx - Ax) / 23;
int dydy = (Cy - Ay) / 23;
for (int y = 0; y < Lines; y++)
for (auto y = 0; y < Lines; y++)
{
Cx = Ax;
Cy = Ay;
print() << FPoint{2, 3 + y};
for (int x = 0; x < Cols; x++)
for (auto x = 0; x < Cols; x++)
{
auto ch = data[((Cy >> 14) & 0xf) + ((Cx >> 10) & 0xf0)];
@ -225,7 +225,7 @@ void RotoZoomer::onShow (finalcut::FShowEvent*)
for (path = 1; path < loops; path++)
{
redraw();
updateTerminal();
processTerminalUpdate();
}
end = system_clock::now();
@ -244,8 +244,6 @@ void RotoZoomer::onTimer (finalcut::FTimerEvent*)
path++;
redraw();
updateTerminal();
flush();
}
//----------------------------------------------------------------------

4
examples/scrollview.cpp
View File

@ -135,11 +135,11 @@ void Scrollview::draw()
setColor (wc->label_inactive_fg, wc->dialog_bg);
clearArea();
for (int y{0}; y < int(getScrollHeight()); y++)
for (auto y{0}; y < int(getScrollHeight()); y++)
{
print() << FPoint{1, 1 + y};
for (int x{0}; x < int(getScrollWidth()); x++)
for (auto x{0}; x < int(getScrollWidth()); x++)
print (32 + ((x + y) % 0x5f));
}

6
examples/string-operations.cpp
View File

@ -370,7 +370,7 @@ void stringConcatenationExample()
// Test: concatenate a FString and a wide string (operator +)
const finalcut::FString& add3 = finalcut::FString("FString + ")
+ const_cast<wchar_t*>(L"wchar_t*");
+ L"wchar_t*";
std::cout << " add: " << add3 << std::endl;
// Test: concatenate a FString and a c++ string (operator +)
@ -402,7 +402,7 @@ void stringConcatenationExample()
std::cout << " add: " << add9 << std::endl;
// Test: concatenate a c-string and a FString (operator +)
const finalcut::FString& add10 = const_cast<char*>("char*")
const finalcut::FString& add10 = "char*"
+ finalcut::FString(" + FString");
std::cout << " add: " << add10 << std::endl;
@ -412,7 +412,7 @@ void stringConcatenationExample()
std::cout << " add: " << add11 << std::endl;
// Test: concatenate a wide string and a FString (operator +)
const finalcut::FString& add12 = const_cast<wchar_t*>(L"wchar_t*")
const finalcut::FString& add12 = L"wchar_t*"
+ finalcut::FString(" + FString");
std::cout << " add: " << add12 << std::endl;

4
examples/termcap.cpp
View File

@ -230,10 +230,10 @@ void debug (const finalcut::FApplication& TermApp)
<< debug_data.getTermType_SecDA() << "\r\n";
if ( ! ab_s.isEmpty() )
tcapString ("| The answerback String", ab_s);
tcapString ("| The answerback String", ab_s.c_str());
if ( ! sec_da.isEmpty() )
tcapString ("| The SecDA String", sec_da);
tcapString ("| The SecDA String", sec_da.c_str());
std::cout << "`------------------- debug -------------------\r\n";
}

4
examples/transparent.cpp
View File

@ -113,7 +113,7 @@ void Transparent::draw()
const finalcut::FString line{getClientWidth(), '.'};
// Fill window area
for (int n{1}; n <= int(getClientHeight()); n++)
for (auto n{1}; n <= int(getClientHeight()); n++)
{
print() << FPoint{2, 2 + n}
<< line;
@ -237,8 +237,6 @@ void MainWindow::draw()
if ( finalcut::FTerm::isMonochron() )
setReverse(false);
updateTerminal();
}
//----------------------------------------------------------------------

11
examples/ui.cpp
View File

@ -159,9 +159,6 @@ void ProgressDialog::onTimer (finalcut::FTimerEvent*)
if ( getStatusBar() )
getStatusBar()->drawMessage();
updateTerminal();
flush();
}
//----------------------------------------------------------------------
@ -300,7 +297,7 @@ class MyDialog final : public finalcut::FDialog
void cb_copyClipboard();
void cb_pasteClipboard();
void cb_clearInput();
void cb_switchTheme (const finalcut::FCheckMenuItem*) const;
void cb_switchTheme (const finalcut::FCheckMenuItem*);
void cb_input2buttonText ( finalcut::FButton&
, const finalcut::FLineEdit& ) const;
void cb_setTitlebar (const finalcut::FLineEdit&);
@ -600,7 +597,7 @@ void MyDialog::initWidgets()
myList.setMultiSelection();
myList.reserve(100);
for (int z{1}; z < 100; z++)
for (auto z{1}; z < 100; z++)
myList.insert (finalcut::FString{} << z << L" placeholder");
// Text labels
@ -936,7 +933,7 @@ void MyDialog::cb_clearInput()
}
//----------------------------------------------------------------------
void MyDialog::cb_switchTheme (const finalcut::FCheckMenuItem* check_menu) const
void MyDialog::cb_switchTheme (const finalcut::FCheckMenuItem* check_menu)
{
if ( check_menu->isChecked() )
finalcut::FApplication::setDarkTheme();
@ -1021,7 +1018,7 @@ void MyDialog::cb_view (const finalcut::FMenuItem* item)
view->setResizeable();
std::string line{""};
std::ifstream infile;
infile.open(file);
infile.open(file.c_str());
while ( ! infile.eof() && infile.good() )
{

3
examples/windows.cpp
View File

@ -153,7 +153,6 @@ void SmallWindow::onTimer (finalcut::FTimerEvent*)
top_right_label.redraw();
bottom_label.unsetEmphasis();
bottom_label.redraw();
updateTerminal();
delOwnTimers();
}
@ -344,8 +343,6 @@ void Window::activateWindow (finalcut::FDialog* win) const
if ( has_raised )
win->redraw();
updateTerminal();
}
//----------------------------------------------------------------------

4
finalcut.changes
View File

@ -1,3 +1,7 @@
-------------------------------------------------------------------
Sat Nov 07 11:24:39 UTC 2020 - Markus Gans <guru.mail@muenster.de>
- Release (version 0.7.0)
-------------------------------------------------------------------
Mon Oct 14 23:49:57 UTC 2019 - Markus Gans <guru.mail@muenster.de>
- Release (version 0.6.0)

15
m4/libtool.m4 vendored
View File

@ -4063,7 +4063,8 @@ _LT_EOF
if AC_TRY_EVAL(ac_compile); then
# Now try to grab the symbols.
nlist=conftest.nm
if AC_TRY_EVAL(NM conftest.$ac_objext \| "$lt_cv_sys_global_symbol_pipe" \> $nlist) && test -s "$nlist"; then
$ECHO "$as_me:$LINENO: $NM conftest.$ac_objext | $lt_cv_sys_global_symbol_pipe > $nlist" >&AS_MESSAGE_LOG_FD
if eval "$NM" conftest.$ac_objext \| "$lt_cv_sys_global_symbol_pipe" \> $nlist 2>&AS_MESSAGE_LOG_FD && test -s "$nlist"; then
# Try sorting and uniquifying the output.
if sort "$nlist" | uniq > "$nlist"T; then
mv -f "$nlist"T "$nlist"
@ -6438,7 +6439,7 @@ if test yes != "$_lt_caught_CXX_error"; then
# Commands to make compiler produce verbose output that lists
# what "hidden" libraries, object files and flags are used when
# linking a shared library.
output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"'
output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP " \-L"'
else
GXX=no
@ -6813,7 +6814,7 @@ if test yes != "$_lt_caught_CXX_error"; then
# explicitly linking system object files so we need to strip them
# from the output so that they don't get included in the library
# dependencies.
output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $EGREP "\-L"`; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $EGREP " \-L"`; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
;;
*)
if test yes = "$GXX"; then
@ -6878,7 +6879,7 @@ if test yes != "$_lt_caught_CXX_error"; then
# explicitly linking system object files so we need to strip them
# from the output so that they don't get included in the library
# dependencies.
output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $GREP "\-L"`; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $GREP " \-L"`; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
;;
*)
if test yes = "$GXX"; then
@ -7217,7 +7218,7 @@ if test yes != "$_lt_caught_CXX_error"; then
# Commands to make compiler produce verbose output that lists
# what "hidden" libraries, object files and flags are used when
# linking a shared library.
output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"'
output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP " \-L"'
else
# FIXME: insert proper C++ library support
@ -7301,7 +7302,7 @@ if test yes != "$_lt_caught_CXX_error"; then
# Commands to make compiler produce verbose output that lists
# what "hidden" libraries, object files and flags are used when
# linking a shared library.
output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"'
output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP " \-L"'
else
# g++ 2.7 appears to require '-G' NOT '-shared' on this
# platform.
@ -7312,7 +7313,7 @@ if test yes != "$_lt_caught_CXX_error"; then
# Commands to make compiler produce verbose output that lists
# what "hidden" libraries, object files and flags are used when
# linking a shared library.
output_verbose_link_cmd='$CC -G $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"'
output_verbose_link_cmd='$CC -G $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP " \-L"'
fi
_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-R $wl$libdir'

4
scripts/cppcheck.sh
View File

@ -2,8 +2,8 @@
if [ $# -gt 0 ]
then
eval cppcheck --force --std=c++11 --enable=all -I../src/include/ "$@"
eval cppcheck --force --language=c++ --std=c++11 --enable=all -I../src/include/ "$@"
else
eval cppcheck --force --std=c++11 --enable=all -I../src/include/ ../src/ ../examples/
eval cppcheck --force --language=c++ --std=c++11 --enable=all -I../src/include/ ../src/ ../examples/
fi

2
sonar-project.properties
View File

@ -1,6 +1,6 @@
sonar.projectKey=gansm_finalcut
sonar.projectName=finalcut
sonar.projectVersion=0.6.1
sonar.projectVersion=0.7.0
sonar.projectDescription=A text-based widget toolkit
#----------------------------------------------------------------------

2
src/Makefile.clang
View File

@ -3,7 +3,7 @@
#-----------------------------------------------------------------------------
# This is where make install will install the library
VERSION = "0.6.1"
VERSION = "0.7.0"
MAJOR := $(shell echo ${VERSION} | cut -d. -f1)
LIBDIR = /usr/local/lib
INCLUDEDIR1 = include/final

2
src/Makefile.gcc
View File

@ -3,7 +3,7 @@
#-----------------------------------------------------------------------------
# This is where make install will install the library
VERSION = "0.6.1"
VERSION = "0.7.0"
MAJOR := $(shell echo ${VERSION} | cut -d. -f1)
LIBDIR = /usr/local/lib
INCLUDEDIR1 = include/final

548
src/fapplication.cpp
View File

@ -46,11 +46,19 @@
namespace finalcut
{
// Global application object
static FApplication* app_object{nullptr};
namespace internal
{
// Flag to exit the local event loop
static bool app_exit_loop{false};
struct var
{
static FApplication* app_object; // Global application object
static bool exit_loop; // Flag to exit the local event loop
};
FApplication* var::app_object {nullptr};
bool var::exit_loop {false};
} // namespace internal
// Static attributes
FWidget* FWidget::main_widget {nullptr}; // main application widget
@ -65,33 +73,9 @@ FMouseControl* FApplication::mouse {nullptr}; // mouse control
int FApplication::loop_level {0}; // event loop level
int FApplication::quit_code {EXIT_SUCCESS};
bool FApplication::quit_now {false};
uInt64 FApplication::next_event_wait {5000}; // preset to 5 ms (200 Hz)
struct timeval FApplication::time_last_event{};
const std::vector<FApplication::CmdOption> FApplication::long_options =
{
{"encoding", required_argument, nullptr, 'e' },
{"log-file", required_argument, nullptr, 'l' },
{"no-mouse", no_argument, nullptr, 'm' },
{"no-optimized-cursor", no_argument, nullptr, 'o' },
{"no-terminal-detection", no_argument, nullptr, 'd' },
{"no-terminal-data-request", no_argument, nullptr, 'r' },
{"no-color-change", no_argument, nullptr, 'c' },
{"no-sgr-optimizer", no_argument, nullptr, 's' },
{"vgafont", no_argument, nullptr, 'v' },
{"newfont", no_argument, nullptr, 'n' },
{"dark-theme", no_argument, nullptr, 't' },
#if defined(__FreeBSD__) || defined(__DragonFly__)
{"no-esc-for-alt-meta", no_argument, nullptr, 'E' },
{"no-cursorstyle-change", no_argument, nullptr, 'C' },
#elif defined(__NetBSD__) || defined(__OpenBSD__)
{"no-esc-for-alt-meta", no_argument, nullptr, 'E' },
#endif
{nullptr, 0, nullptr, 0 }
};
bool FApplication::pending_updates {false};
uInt64 FApplication::next_event_wait {5000}; // 5 ms (200 Hz)
struct timeval FApplication::time_last_event {};
//----------------------------------------------------------------------
@ -108,7 +92,7 @@ FApplication::FApplication (const int& _argc, char* _argv[])
if ( quit_now )
return;
if ( app_object )
if ( internal::var::app_object )
{
auto ftermdata = FTerm::getFTermData();
ftermdata->setExitMessage("FApplication: There should be "
@ -118,7 +102,7 @@ FApplication::FApplication (const int& _argc, char* _argv[])
}
// First define the application object
app_object = this;
internal::var::app_object = this;
if ( ! (_argc && _argv) )
{
@ -134,7 +118,7 @@ FApplication::FApplication (const int& _argc, char* _argv[])
//----------------------------------------------------------------------
FApplication::~FApplication() // destructor
{
app_object = nullptr;
internal::var::app_object = nullptr;
if ( eventInQueue() )
event_queue.clear();
@ -147,7 +131,7 @@ FApplication::~FApplication() // destructor
//----------------------------------------------------------------------
FApplication* FApplication::getApplicationObject()
{
return app_object;
return internal::var::app_object;
}
//----------------------------------------------------------------------
@ -187,7 +171,7 @@ void FApplication::setLog (const FLogPtr& log)
//----------------------------------------------------------------------
bool FApplication::isQuit()
{
return ( app_object ) ? quit_now : true;
return ( internal::var::app_object ) ? quit_now : true;
}
//----------------------------------------------------------------------
@ -210,13 +194,13 @@ int FApplication::enterLoop() // event loop
loop_level++;
quit_now = false;
const bool old_app_exit_loop = app_exit_loop;
app_exit_loop = false;
const bool old_app_exit_loop = internal::var::exit_loop;
internal::var::exit_loop = false;
while ( ! (quit_now || app_exit_loop) )
while ( ! (quit_now || internal::var::exit_loop) )
processNextEvent();
app_exit_loop = old_app_exit_loop;
internal::var::exit_loop = old_app_exit_loop;
loop_level--;
return 0;
}
@ -224,7 +208,7 @@ int FApplication::enterLoop() // event loop
//----------------------------------------------------------------------
void FApplication::exitLoop() const
{
app_exit_loop = true;
internal::var::exit_loop = true;
}
//----------------------------------------------------------------------
@ -243,7 +227,7 @@ void FApplication::quit() const
//----------------------------------------------------------------------
bool FApplication::sendEvent (FObject* receiver, FEvent* event )
{
if ( quit_now || app_exit_loop || ! (bool(receiver) && bool(event)) )
if ( quit_now || internal::var::exit_loop || ! (bool(receiver) && bool(event)) )
return false;
if ( ! isEventProcessable (receiver, event) )
@ -281,7 +265,7 @@ void FApplication::sendQueuedEvents()
//----------------------------------------------------------------------
bool FApplication::eventInQueue() const
{
if ( app_object )
if ( internal::var::app_object )
return ( ! event_queue.empty() );
else
return false;
@ -355,7 +339,7 @@ void FApplication::setDarkTheme()
void FApplication::setLogFile (const FString& filename)
{
auto& log_stream = getStartOptions().logfile_stream;
log_stream.open(filename, std::ofstream::out);
log_stream.open(filename.c_str(), std::ofstream::out);
if ( log_stream.is_open() )
{
@ -383,7 +367,7 @@ void FApplication::setKeyboardWidget (FWidget* widget)
//----------------------------------------------------------------------
void FApplication::closeConfirmationDialog (FWidget* w, FCloseEvent* ev)
{
app_object->unsetMoveSizeMode();
internal::var::app_object->unsetMoveSizeMode();
const int ret = FMessageBox::info ( w, "Quit"
, "Do you really want\n"
"to quit the program ?"
@ -427,31 +411,39 @@ void FApplication::init()
// Initialize keyboard
keyboard = FTerm::getFKeyboard();
// Set the keyboard keypress timeout
if ( keyboard )
{
auto cmd1 = std::bind(&FApplication::keyPressed, this);
auto cmd2 = std::bind(&FApplication::keyReleased, this);
auto cmd3 = std::bind(&FApplication::escapeKeyPressed, this);
auto cmd4 = std::bind(&FApplication::mouseTracking, this);
FKeyboardCommand key_cmd1 (cmd1);
FKeyboardCommand key_cmd2 (cmd2);
FKeyboardCommand key_cmd3 (cmd3);
FKeyboardCommand key_cmd4 (cmd4);
keyboard->setPressCommand (key_cmd1);
keyboard->setReleaseCommand (key_cmd2);
keyboard->setEscPressedCommand (key_cmd3);
keyboard->setMouseTrackingCommand (key_cmd4);
// Set the keyboard keypress timeout
keyboard->setKeypressTimeout (key_timeout);
}
// Initialize mouse control
mouse = FTerm::getFMouseControl();
if ( mouse )
{
using namespace std::placeholders;
auto cmd = std::bind(&FApplication::mouseEvent, this, _1);
FMouseCommand mouse_cmd (cmd);
mouse->setEventCommand (mouse_cmd);
// Set stdin number for a gpm-mouse
if ( mouse )
mouse->setStdinNo (FTermios::getStdIn());
// Set the default double click interval
if ( mouse )
mouse->setDblclickInterval (dblclick_interval);
}
// Initialize logging
if ( ! getStartOptions().logfile_stream.is_open() )
@ -484,13 +476,40 @@ void FApplication::setTerminalEncoding (const FString& enc_str)
}
//----------------------------------------------------------------------
inline FApplication::CmdMap& FApplication::mapCmdOptions()
inline void FApplication::setLongOptions (std::vector<CmdOption>& long_options)
{
long_options =
{
{"encoding", required_argument, nullptr, 'e' },
{"log-file", required_argument, nullptr, 'l' },
{"no-mouse", no_argument, nullptr, 'm' },
{"no-optimized-cursor", no_argument, nullptr, 'o' },
{"no-terminal-detection", no_argument, nullptr, 'd' },
{"no-terminal-data-request", no_argument, nullptr, 'r' },
{"no-color-change", no_argument, nullptr, 'c' },
{"no-sgr-optimizer", no_argument, nullptr, 's' },
{"vgafont", no_argument, nullptr, 'v' },
{"newfont", no_argument, nullptr, 'n' },
{"dark-theme", no_argument, nullptr, 't' },
#if defined(__FreeBSD__) || defined(__DragonFly__)
{"no-esc-for-alt-meta", no_argument, nullptr, 'E' },
{"no-cursorstyle-change", no_argument, nullptr, 'C' },
#elif defined(__NetBSD__) || defined(__OpenBSD__)
{"no-esc-for-alt-meta", no_argument, nullptr, 'E' },
#endif
{nullptr, 0, nullptr, 0 }
};
}
//----------------------------------------------------------------------
inline void FApplication::setCmdOptionsMap (CmdMap& cmd_map)
{
using std::placeholders::_1;
auto enc = std::bind(&FApplication::setTerminalEncoding, _1);
auto log = std::bind(&FApplication::setLogFile, _1);
auto opt = &FApplication::getStartOptions;
static CmdMap cmd_map{};
// --encoding
cmd_map['e'] = [enc] (const char* arg) { enc(FString(arg)); };
@ -523,7 +542,6 @@ inline FApplication::CmdMap& FApplication::mapCmdOptions()
// --no-esc-for-alt-meta
cmd_map['E'] = [opt] (const char*) { opt().meta_sends_escape = false; };
#endif
return cmd_map;
}
//----------------------------------------------------------------------
@ -531,12 +549,15 @@ void FApplication::cmdOptions (const int& argc, char* argv[])
{
// Interpret the command line options
auto& cmd_map = mapCmdOptions();
CmdMap cmd_map{};
setCmdOptionsMap(cmd_map);
while ( true )
{
opterr = 0;
int idx{0};
std::vector<CmdOption> long_options{};
setLongOptions(long_options);
auto p = reinterpret_cast<const struct option*>(long_options.data());
const int opt = getopt_long (argc, argv, "", p, &idx);
@ -649,9 +670,9 @@ inline void FApplication::findKeyboardWidget() const
inline bool FApplication::isKeyPressed() const
{
if ( mouse && mouse->isGpmMouseEnabled() )
return mouse->getGpmKeyPressed(keyboard->unprocessedInput());
return mouse->getGpmKeyPressed(keyboard->hasUnprocessedInput());
return keyboard->isKeyPressed();
return (keyboard->isKeyPressed() || keyboard->hasPendingInput());
}
//----------------------------------------------------------------------
@ -672,56 +693,76 @@ void FApplication::escapeKeyPressed() const
sendEscapeKeyPressEvent();
}
//----------------------------------------------------------------------
void FApplication::mouseTracking() const
{
performMouseAction();
}
//----------------------------------------------------------------------
inline void FApplication::performKeyboardAction()
{
switch ( keyboard->getKey() )
if ( keyboard->getKey() == fc::Fckey_l ) // Ctrl-L (redraw the screen)
{
case fc::Fckey_l: // Ctrl-L (redraw the screen)
redraw();
break;
case fc::Fkey_mouse:
if ( mouse )
{
FKeyboard::keybuffer& buffer = keyboard->getKeyBuffer();
mouse->setRawData (FMouse::x11, buffer);
keyboard->unprocessedInput() = mouse->isInputDataPending();
processMouseEvent();
}
break;
case fc::Fkey_extended_mouse:
if ( mouse )
else
{
FKeyboard::keybuffer& buffer = keyboard->getKeyBuffer();
mouse->setRawData (FMouse::sgr, buffer);
keyboard->unprocessedInput() = mouse->isInputDataPending();
processMouseEvent();
}
break;
case fc::Fkey_urxvt_mouse:
if ( mouse )
{
FKeyboard::keybuffer& buffer = keyboard->getKeyBuffer();
mouse->setRawData (FMouse::urxvt, buffer);
keyboard->unprocessedInput() = mouse->isInputDataPending();
processMouseEvent();
}
break;
default:
const bool acceptKeyDown = sendKeyDownEvent (keyboard_widget);
const bool acceptKeyPress = sendKeyPressEvent (keyboard_widget);
if ( ! (acceptKeyDown || acceptKeyPress) )
sendKeyboardAccelerator();
break;
}
}
//----------------------------------------------------------------------
inline void FApplication::performMouseAction() const
{
if ( ! mouse )
return;
auto& buffer = keyboard->getKeyBuffer();
switch ( keyboard->getKey() )
{
case fc::Fkey_mouse:
mouse->setRawData (FMouse::x11, buffer);
break;
case fc::Fkey_extended_mouse:
mouse->setRawData (FMouse::sgr, buffer);
break;
case fc::Fkey_urxvt_mouse:
mouse->setRawData (FMouse::urxvt, buffer);
break;
default:
return;
}
keyboard->hasUnprocessedInput() = mouse->hasUnprocessedInput();
queuingMouseInput();
}
//----------------------------------------------------------------------
void FApplication::mouseEvent (const FMouseData& md)
{
determineClickedWidget (md);
if ( FWidget::getClickedWidget() )
{
unsetMoveSizeMode();
closeDropDown (md);
unselectMenubarItems (md);
sendMouseEvent (md);
}
if ( mouse )
mouse->drawGpmPointer();
}
//----------------------------------------------------------------------
inline void FApplication::sendEscapeKeyPressEvent() const
{
@ -758,7 +799,7 @@ inline bool FApplication::sendKeyUpEvent (FWidget* widget) const
}
//----------------------------------------------------------------------
inline void FApplication::sendKeyboardAccelerator() const
inline void FApplication::sendKeyboardAccelerator()
{
if ( FWidget::getOpenMenu() )
return;
@ -772,27 +813,37 @@ inline void FApplication::sendKeyboardAccelerator() const
auto window = static_cast<const FWidget*>(getActiveWindow());
if ( window )
accpt = processAccelerator (window);
accpt = processAccelerator(*window);
}
// Global keyboard accelerator
if ( ! accpt )
{
auto root_widget = static_cast<const FWidget*>(getRootWidget());
auto root_widget = getRootWidget();
if ( root_widget )
processAccelerator (root_widget);
processAccelerator(*root_widget);
}
}
//----------------------------------------------------------------------
void FApplication::processKeyboardEvent() const
inline bool FApplication::hasDataInQueue() const
{
if ( quit_now || app_exit_loop )
if ( keyboard && keyboard->hasDataInQueue() )
return true;
else if ( mouse && mouse->hasDataInQueue() )
return true;
return false;
}
//----------------------------------------------------------------------
void FApplication::queuingKeyboardInput() const
{
if ( quit_now || internal::var::exit_loop || ! keyboard )
return;
findKeyboardWidget();
flush();
keyboard->escapeKeyHandling(); // special case: Esc key
keyboard->clearKeyBufferOnTimeout();
@ -800,6 +851,37 @@ void FApplication::processKeyboardEvent() const
keyboard->fetchKeyCode();
}
//----------------------------------------------------------------------
void FApplication::queuingMouseInput() const
{
if ( quit_now || internal::var::exit_loop
|| ! mouse || ! mouse->hasData() )
return;
struct timeval* time_keypressed = keyboard->getKeyPressedTime();
mouse->processEvent (time_keypressed);
keyboard->hasUnprocessedInput() = mouse->hasUnprocessedInput();
mouse->clearEvent();
}
//----------------------------------------------------------------------
void FApplication::processKeyboardEvent() const
{
if ( quit_now || internal::var::exit_loop || ! keyboard )
return;
keyboard->processQueuedInput();
}
//----------------------------------------------------------------------
void FApplication::processMouseEvent() const
{
if ( quit_now || internal::var::exit_loop || ! mouse )
return;
mouse->processQueuedInput();
}
//----------------------------------------------------------------------
bool FApplication::processDialogSwitchAccelerator() const
{
@ -832,14 +914,12 @@ bool FApplication::processDialogSwitchAccelerator() const
}
//----------------------------------------------------------------------
bool FApplication::processAccelerator (const FWidget* const& widget) const
bool FApplication::processAccelerator (const FWidget& widget) const
{
bool accpt{false};
if ( widget.getAcceleratorList().empty() )
return false;
if ( ! widget || widget->getAcceleratorList().empty() )
return accpt;
for (auto&& item : widget->getAcceleratorList())
for (auto&& item : widget.getAcceleratorList())
{
if ( item.key == keyboard->getKey() )
{
@ -854,50 +934,33 @@ bool FApplication::processAccelerator (const FWidget* const& widget) const
FAccelEvent a_ev (fc::Accelerator_Event, getFocusWidget());
sendEvent (item.object, &a_ev);
accpt = a_ev.isAccepted();
return a_ev.isAccepted();
}
if ( quit_now || internal::var::exit_loop )
break;
}
if ( quit_now || app_exit_loop )
break;
}
return accpt;
return false;
}
//----------------------------------------------------------------------
bool FApplication::getMouseEvent() const
void FApplication::determineClickedWidget (const FMouseData& md)
{
bool mouse_event_occurred{false};
clicked_widget = FWidget::getClickedWidget();
if ( mouse && mouse->hasData() )
{
struct timeval* time_keypressed = keyboard->getKeyPressedTime();
mouse->processEvent (time_keypressed);
keyboard->unprocessedInput() = mouse->isInputDataPending();
mouse_event_occurred = mouse->hasEvent();
}
if ( clicked_widget )
return; // The clicked widget was already found
return mouse_event_occurred;
}
if ( ! md.isLeftButtonPressed()
&& ! md.isLeftButtonDoubleClick()
&& ! md.isRightButtonPressed()
&& ! md.isMiddleButtonPressed()
&& ! md.isWheelUp()
&& ! md.isWheelDown() )
return;
//----------------------------------------------------------------------
FWidget*& FApplication::determineClickedWidget()
{
FWidget*& clicked = FWidget::getClickedWidget();
if ( clicked || ! mouse )
return clicked;
if ( ! mouse->isLeftButtonPressed()
&& ! mouse->isLeftButtonDoubleClick()
&& ! mouse->isRightButtonPressed()
&& ! mouse->isMiddleButtonPressed()
&& ! mouse->isWheelUp()
&& ! mouse->isWheelDown() )
return clicked;
auto mouse_position = mouse->getPos();
const auto& mouse_position = md.getPos();
// Determine the window object on the current click position
auto window = FWindow::getWindowWidgetAt (mouse_position);
@ -905,12 +968,10 @@ FWidget*& FApplication::determineClickedWidget()
if ( window )
{
// Determine the widget at the current click position
auto child = window->childWidgetAt (mouse_position);
clicked = ( child != nullptr ) ? child : window;
setClickedWidget (clicked);
auto child = window->childWidgetAt(mouse_position);
clicked_widget = ( child != nullptr ) ? child : window;
setClickedWidget (clicked_widget);
}
return clicked;
}
//----------------------------------------------------------------------
@ -918,43 +979,43 @@ void FApplication::unsetMoveSizeMode() const
{
// Unset the move/size mode
auto move_size = getMoveSizeWidget();
auto& move_size = getMoveSizeWidget();
if ( move_size )
{
auto w = move_size;
setMoveSizeWidget(nullptr);
FWidget* w{nullptr};
std::swap(w, move_size); // Clear move_size_widget
w->redraw();
}
}
//----------------------------------------------------------------------
void FApplication::closeDropDown() const
void FApplication::closeDropDown (const FMouseData& md) const
{
// Close the open menu
if ( ! mouse || mouse->isMoved() )
if ( md.isMoved() )
return;
auto mouse_position = mouse->getPos();
const auto& mouse_position = md.getPos();
finalcut::closeDropDown (this, mouse_position);
}
//----------------------------------------------------------------------
void FApplication::unselectMenubarItems() const
void FApplication::unselectMenubarItems (const FMouseData& md) const
{
// Unselect the menu bar items
const auto& openmenu = FWidget::getOpenMenu();
auto menu_bar = FWidget::getMenuBar();
if ( openmenu || (mouse && mouse->isMoved()) )
if ( openmenu || md.isMoved() )
return;
if ( ! (menu_bar && menu_bar->hasSelectedItem() && mouse) )
if ( ! (menu_bar && menu_bar->hasSelectedItem()) )
return;
const auto& mouse_position = mouse->getPos();
const auto& mouse_position = md.getPos();
if ( ! menu_bar->getTermGeometry().contains(mouse_position) )
{
@ -970,123 +1031,106 @@ void FApplication::unselectMenubarItems() const
if ( FWidget::getStatusBar() )
FWidget::getStatusBar()->drawMessage();
updateTerminal();
flush();
}
}
//----------------------------------------------------------------------
void FApplication::sendMouseEvent() const
void FApplication::sendMouseEvent (const FMouseData& md) const
{
auto clicked = FWidget::getClickedWidget();
if ( ! (clicked && mouse) )
return;
const auto& mouse_position = mouse->getPos();
const auto& mouse_position = md.getPos();
int key_state{0};
if ( mouse->isShiftKeyPressed() )
if ( md.isShiftKeyPressed() )
key_state |= fc::ShiftButton;
if ( mouse->isControlKeyPressed() )
if ( md.isControlKeyPressed() )
key_state |= fc::ControlButton;
if ( mouse->isMetaKeyPressed() )
if ( md.isMetaKeyPressed() )
key_state |= fc::MetaButton;
const auto& widgetMousePos = clicked->termToWidgetPos(mouse_position);
const auto& widgetMousePos = clicked_widget->termToWidgetPos(mouse_position);
if ( mouse->isMoved() )
if ( md.isMoved() )
{
sendMouseMoveEvent (widgetMousePos, mouse_position, key_state);
sendMouseMoveEvent (md, widgetMousePos, mouse_position, key_state);
}
else
{
sendMouseLeftClickEvent (widgetMousePos, mouse_position, key_state);
sendMouseRightClickEvent (widgetMousePos, mouse_position, key_state);
sendMouseMiddleClickEvent (widgetMousePos, mouse_position, key_state);
sendMouseLeftClickEvent (md, widgetMousePos, mouse_position, key_state);
sendMouseRightClickEvent (md, widgetMousePos, mouse_position, key_state);
sendMouseMiddleClickEvent (md, widgetMousePos, mouse_position, key_state);
}
sendWheelEvent (widgetMousePos, mouse_position);
mouse->clearEvent();
sendWheelEvent (md, widgetMousePos, mouse_position);
}
//----------------------------------------------------------------------
void FApplication::sendMouseMoveEvent ( const FPoint& widgetMousePos
void FApplication::sendMouseMoveEvent ( const FMouseData& md
, const FPoint& widgetMousePos
, const FPoint& mouse_position
, int key_state ) const
{
if ( ! mouse )
return;
auto clicked = FWidget::getClickedWidget();
if ( mouse->isLeftButtonPressed() )
if ( md.isLeftButtonPressed() )
{
FMouseEvent m_down_ev ( fc::MouseMove_Event
, widgetMousePos
, mouse_position
, fc::LeftButton | key_state );
sendEvent (clicked, &m_down_ev);
sendEvent (clicked_widget, &m_down_ev);
}
if ( mouse->isRightButtonPressed() )
if ( md.isRightButtonPressed() )
{
FMouseEvent m_down_ev ( fc::MouseMove_Event
, widgetMousePos
, mouse_position
, fc::RightButton | key_state );
sendEvent (clicked, &m_down_ev);
sendEvent (clicked_widget, &m_down_ev);
}
if ( mouse->isMiddleButtonPressed() )
if ( md.isMiddleButtonPressed() )
{
FMouseEvent m_down_ev ( fc::MouseMove_Event
, widgetMousePos
, mouse_position
, fc::MiddleButton | key_state );
sendEvent (clicked, &m_down_ev);
sendEvent (clicked_widget, &m_down_ev);
}
}
//----------------------------------------------------------------------
void FApplication::sendMouseLeftClickEvent ( const FPoint& widgetMousePos
void FApplication::sendMouseLeftClickEvent ( const FMouseData& md
, const FPoint& widgetMousePos
, const FPoint& mouse_position
, int key_state ) const
{
if ( ! mouse )
return;
auto clicked = FWidget::getClickedWidget();
if ( mouse->isLeftButtonDoubleClick() )
if ( md.isLeftButtonDoubleClick() )
{
FMouseEvent m_dblclick_ev ( fc::MouseDoubleClick_Event
, widgetMousePos
, mouse_position
, fc::LeftButton | key_state );
sendEvent (clicked, &m_dblclick_ev);
sendEvent (clicked_widget, &m_dblclick_ev);
}
else if ( mouse->isLeftButtonPressed() )
else if ( md.isLeftButtonPressed() )
{
FMouseEvent m_down_ev ( fc::MouseDown_Event
, widgetMousePos
, mouse_position
, fc::LeftButton | key_state );
sendEvent (clicked, &m_down_ev);
sendEvent (clicked_widget, &m_down_ev);
}
else if ( mouse->isLeftButtonReleased() )
else if ( md.isLeftButtonReleased() )
{
FMouseEvent m_up_ev ( fc::MouseUp_Event
, widgetMousePos
, mouse_position
, fc::LeftButton | key_state );
auto released_widget = clicked;
auto released_widget = clicked_widget;
if ( ! mouse->isRightButtonPressed()
&& ! mouse->isMiddleButtonPressed() )
if ( ! md.isRightButtonPressed()
&& ! md.isMiddleButtonPressed() )
setClickedWidget(nullptr);
sendEvent (released_widget, &m_up_ev);
@ -1094,33 +1138,29 @@ void FApplication::sendMouseLeftClickEvent ( const FPoint& widgetMousePos
}
//----------------------------------------------------------------------
void FApplication::sendMouseRightClickEvent ( const FPoint& widgetMousePos
void FApplication::sendMouseRightClickEvent ( const FMouseData& md
, const FPoint& widgetMousePos
, const FPoint& mouse_position
, int key_state ) const
{
if ( ! mouse )
return;
auto clicked = FWidget::getClickedWidget();
if ( mouse->isRightButtonPressed() )
if ( md.isRightButtonPressed() )
{
FMouseEvent m_down_ev ( fc::MouseDown_Event
, widgetMousePos
, mouse_position
, fc::RightButton | key_state );
sendEvent (clicked, &m_down_ev);
sendEvent (clicked_widget, &m_down_ev);
}
else if ( mouse->isRightButtonReleased() )
else if ( md.isRightButtonReleased() )
{
FMouseEvent m_up_ev ( fc::MouseUp_Event
, widgetMousePos
, mouse_position
, fc::RightButton | key_state );
auto released_widget = clicked;
auto released_widget = clicked_widget;
if ( ! mouse->isLeftButtonPressed()
&& ! mouse->isMiddleButtonPressed() )
if ( ! md.isLeftButtonPressed()
&& ! md.isMiddleButtonPressed() )
setClickedWidget(nullptr);
sendEvent (released_widget, &m_up_ev);
@ -1128,37 +1168,33 @@ void FApplication::sendMouseRightClickEvent ( const FPoint& widgetMousePos
}
//----------------------------------------------------------------------
void FApplication::sendMouseMiddleClickEvent ( const FPoint& widgetMousePos
void FApplication::sendMouseMiddleClickEvent ( const FMouseData& md
, const FPoint& widgetMousePos
, const FPoint& mouse_position
, int key_state ) const
{
if ( ! mouse )
return;
auto clicked = FWidget::getClickedWidget();
if ( mouse->isMiddleButtonPressed() )
if ( md.isMiddleButtonPressed() )
{
FMouseEvent m_down_ev ( fc::MouseDown_Event
, widgetMousePos
, mouse_position
, fc::MiddleButton | key_state );
sendEvent (clicked, &m_down_ev);
sendEvent (clicked_widget, &m_down_ev);
// gnome-terminal sends no released on middle click
if ( FTerm::isGnomeTerminal() )
setClickedWidget(nullptr);
}
else if ( mouse->isMiddleButtonReleased() )
else if ( md.isMiddleButtonReleased() )
{
FMouseEvent m_up_ev ( fc::MouseUp_Event
, widgetMousePos
, mouse_position
, fc::MiddleButton | key_state );
auto released_widget = clicked;
auto released_widget = clicked_widget;
if ( ! mouse->isLeftButtonPressed()
&& ! mouse->isRightButtonPressed() )
if ( ! md.isLeftButtonPressed()
&& ! md.isRightButtonPressed() )
{
setClickedWidget(nullptr);
}
@ -1168,37 +1204,50 @@ void FApplication::sendMouseMiddleClickEvent ( const FPoint& widgetMousePos
}
//----------------------------------------------------------------------
void FApplication::sendWheelEvent ( const FPoint& widgetMousePos
void FApplication::sendWheelEvent ( const FMouseData& md
, const FPoint& widgetMousePos
, const FPoint& mouse_position ) const
{
if ( ! mouse )
return;
auto clicked = FWidget::getClickedWidget();
if ( mouse->isWheelUp() )
if ( md.isWheelUp() )
{
FWheelEvent wheel_ev ( fc::MouseWheel_Event
, widgetMousePos
, mouse_position
, fc::WheelUp );
auto scroll_over_widget = clicked;
auto scroll_over_widget = clicked_widget;
setClickedWidget(nullptr);
sendEvent(scroll_over_widget, &wheel_ev);
}
if ( mouse->isWheelDown() )
if ( md.isWheelDown() )
{
FWheelEvent wheel_ev ( fc::MouseWheel_Event
, widgetMousePos
, mouse_position
, fc::WheelDown );
auto scroll_over_widget = clicked;
auto scroll_over_widget = clicked_widget;
setClickedWidget(nullptr);
sendEvent (scroll_over_widget, &wheel_ev);
}
}
//----------------------------------------------------------------------
inline void FApplication::flushTerminal()
{
if ( ! pending_updates )
return;
if ( flush_count < 4 )
{
flush_count++;
return;
}
flush();
flush_count = 0;
pending_updates = false;
}
//----------------------------------------------------------------------
FWidget* FApplication::processParameters (const int& argc, char* argv[])
{
@ -1213,22 +1262,6 @@ FWidget* FApplication::processParameters (const int& argc, char* argv[])
return nullptr;
}
//----------------------------------------------------------------------
void FApplication::processMouseEvent()
{
if ( ! getMouseEvent() )
return;
determineClickedWidget();
unsetMoveSizeMode();
closeDropDown();
unselectMenubarItems();
sendMouseEvent();
if ( mouse )
mouse->drawGpmPointer();
}
//----------------------------------------------------------------------
void FApplication::processResizeEvent() const
{
@ -1242,7 +1275,7 @@ void FApplication::processResizeEvent() const
}
FResizeEvent r_ev(fc::Resize_Event);
sendEvent(app_object, &r_ev);
sendEvent(internal::var::app_object, &r_ev);
if ( r_ev.isAccepted() )
FTerm::changeTermSizeFinished();
@ -1286,16 +1319,21 @@ bool FApplication::processNextEvent()
uInt num_events{0};
bool is_timeout = isNextEventTimeout();
if ( is_timeout )
if ( is_timeout || hasDataInQueue() )
{
FObject::getCurrentTime (&time_last_event);
queuingKeyboardInput();
queuingMouseInput();
processKeyboardEvent();
processMouseEvent();
processResizeEvent();
processTerminalUpdate();
processCloseWidget();
if ( processTerminalUpdate() ) // after terminal changes
pending_updates = true;
flushTerminal();
processLogger();
updateTerminal();
}
processExternalUserEvent();
@ -1318,13 +1356,13 @@ void FApplication::performTimerAction (FObject* receiver, FEvent* event)
}
//----------------------------------------------------------------------
bool FApplication::isEventProcessable ( const FObject* receiver
bool FApplication::isEventProcessable ( FObject* receiver
, const FEvent* event )
{
if ( ! receiver->isWidget() ) // No restrictions for non-widgets
return true;
const auto widget = static_cast<const FWidget*>(receiver);
auto widget = static_cast<FWidget*>(receiver);
if ( getModalDialogCounter() > 0 )
{

6
src/fbusyindicator.cpp
View File

@ -50,8 +50,6 @@ void FBusyIndicator::start()
running = true;
createIndicatorText();
show();
updateTerminal();
flush();
addTimer(TIMER);
}
@ -61,8 +59,6 @@ void FBusyIndicator::stop()
delOwnTimers();
running = false;
hide();
updateTerminal();
flush();
}
@ -119,8 +115,6 @@ void FBusyIndicator::onTimer (finalcut::FTimerEvent*)
// Redraw the rotated pattern
createIndicatorText();
redraw();
updateTerminal();
flush();
}
} // namespace finalcut

4
src/fbutton.cpp
View File

@ -443,7 +443,7 @@ inline std::size_t FButton::clickAnimationIndent (const FWidget* parent_widget)
setColor ( parent_widget->getForegroundColor()
, parent_widget->getBackgroundColor() );
for (int y{1}; y <= int(getHeight()); y++)
for (auto y{1}; y <= int(getHeight()); y++)
{
print() << FPoint{1, y} << ' '; // clear one left █
}
@ -462,7 +462,7 @@ inline void FButton::clearRightMargin (const FWidget* parent_widget)
setColor ( parent_widget->getForegroundColor()
, parent_widget->getBackgroundColor() );
for (int y{1}; y <= int(getHeight()); y++)
for (auto y{1}; y <= int(getHeight()); y++)
{
if ( FTerm::isMonochron() )
setReverse(true); // Light background

15
src/fbuttongroup.cpp
View File

@ -210,7 +210,7 @@ void FButtonGroup::hide()
// Hide border
unsetViewportPrint();
for (int y{0}; y < int(getHeight()); y++)
for (auto y{0}; y < int(getHeight()); y++)
print() << FPoint{1, 1 + y} << FString{size, L' '};
setViewportPrint();
@ -331,8 +331,6 @@ void FButtonGroup::onFocusIn (FFocusEvent* in_ev)
if ( getStatusBar() )
{
getStatusBar()->drawMessage();
updateTerminal();
flush();
}
}
@ -476,20 +474,15 @@ bool FButtonGroup::directFocusRadioButton() const
if ( ! hasCheckedButton() || buttonlist.empty() )
return false;
bool found_checked{false};
for (auto&& item : buttonlist)
{
auto toggle_button = static_cast<FToggleButton*>(item);
if ( toggle_button->isChecked() )
{
found_checked = directFocusCheckedRadioButton(toggle_button);
break;
}
return directFocusCheckedRadioButton (toggle_button);
}
return found_checked;
return false;
}
//----------------------------------------------------------------------
@ -512,8 +505,6 @@ void FButtonGroup::directFocus()
if ( getStatusBar() )
{
getStatusBar()->drawMessage();
updateTerminal();
flush();
}
}

12
src/fcombobox.cpp
View File

@ -102,8 +102,6 @@ void FDropDownListBox::hide()
setOpenMenu(nullptr);
const auto& t_geometry = getTermGeometryWithShadow();
restoreVTerm (t_geometry);
updateTerminal();
flush();
}
@ -428,8 +426,6 @@ void FComboBox::onMouseDown (FMouseEvent* ev)
else
list_window.hide();
}
updateTerminal();
}
//----------------------------------------------------------------------
@ -440,7 +436,7 @@ void FComboBox::onMouseMove (FMouseEvent* ev)
if ( isMouseOverListWindow(ev->getTermPos()) )
{
passEventToListWindow(ev); // Event handover to window list
passEventToListWindow(*ev); // Event handover to window list
return;
}
}
@ -594,13 +590,13 @@ void FComboBox::onePosDown()
}
//----------------------------------------------------------------------
void FComboBox::passEventToListWindow (FMouseEvent* const& ev)
void FComboBox::passEventToListWindow (const FMouseEvent& ev)
{
// Mouse event handover to list window
const auto& t = ev->getTermPos();
const auto& t = ev.getTermPos();
const auto& p = list_window.list.termToWidgetPos(t);
const int b = ev->getButton();
const int b = ev.getButton();
try
{

32
src/fdialog.cpp
View File

@ -270,7 +270,9 @@ void FDialog::setPos (const FPoint& pos, bool)
restoreOverlaidWindows();
FWindow::adjustSize();
setCursorToFocusWidget();
updateTerminal();
if ( updateTerminal() )
flush();
}
//----------------------------------------------------------------------
@ -447,8 +449,6 @@ void FDialog::activateDialog()
if ( getStatusBar() )
getStatusBar()->drawMessage();
updateTerminal();
}
//----------------------------------------------------------------------
@ -530,8 +530,7 @@ void FDialog::onMouseDown (FMouseEvent* ev)
else // ev->getButton() != fc::LeftButton
{
// Click on titlebar menu button
if ( ms.mouse_x < 4 && ms.mouse_y == 1
&& dialog_menu->isShown() )
if ( ms.mouse_x < 4 && ms.mouse_y == 1 && dialog_menu->isShown() )
leaveMenu(); // close menu
cancelMouseResize(); // Cancel resize
@ -624,7 +623,7 @@ void FDialog::onMouseMove (FMouseEvent* ev)
// Mouse event handover to the menu
if ( ms.mouse_over_menu )
passEventToSubMenu (ms, ev);
passEventToSubMenu (ms, std::move(*ev));
leaveZoomButton(ms); // Check zoom button pressed
resizeMouseUpMove(ms); // Resize the dialog
@ -690,8 +689,6 @@ void FDialog::onAccel (FAccelEvent*)
if ( has_raised )
redraw();
updateTerminal();
}
}
@ -717,8 +714,6 @@ void FDialog::onWindowActive (FEvent*)
if ( getStatusBar() )
getStatusBar()->drawMessage();
updateTerminal();
}
//----------------------------------------------------------------------
@ -967,7 +962,7 @@ void FDialog::drawBorder()
{
const FRect r{FPoint{1, 1}, getSize()};
for (int y = r.getY1() + 1; y < r.getY2(); y++)
for (auto y = r.getY1() + 1; y < r.getY2(); y++)
{
print() << FPoint{r.getX1(), y}
<< fc::NF_border_line_left // border left ⎸
@ -1227,9 +1222,6 @@ void FDialog::leaveMenu()
if ( getStatusBar() )
getStatusBar()->drawMessage();
updateTerminal();
flush();
}
//----------------------------------------------------------------------
@ -1273,9 +1265,6 @@ void FDialog::selectFirstMenuItem()
if ( getStatusBar() )
getStatusBar()->drawMessage();
updateTerminal();
flush();
}
//----------------------------------------------------------------------
@ -1372,7 +1361,7 @@ inline bool FDialog::isMouseOverMenu (const FPoint& termpos) const
//----------------------------------------------------------------------
inline void FDialog::passEventToSubMenu ( const MouseStates& ms
, const FMouseEvent* ev )
, const FMouseEvent&& ev )
{
// Mouse event handover to the dialog menu
if ( ! ms.mouse_over_menu
@ -1381,7 +1370,7 @@ inline void FDialog::passEventToSubMenu ( const MouseStates& ms
const auto& g = ms.termPos;
const auto& p = dialog_menu->termToWidgetPos(g);
const int b = ev->getButton();
const int b = ev.getButton();
try
{
@ -1480,12 +1469,10 @@ inline void FDialog::raiseActivateDialog()
//----------------------------------------------------------------------
inline void FDialog::lowerActivateDialog()
{
const bool has_lowered = lowerWindow();
lowerWindow();
if ( ! isWindowActive() )
activateDialog();
else if ( has_lowered )
updateTerminal();
}
//----------------------------------------------------------------------
@ -1624,7 +1611,6 @@ void FDialog::cancelMouseResize()
resize_click_pos.setPoint (0, 0);
drawBorder();
updateTerminal();
}
//----------------------------------------------------------------------

8
src/ffiledialog.cpp
View File

@ -179,7 +179,7 @@ FString FFileDialog::getSelectedFile() const
//----------------------------------------------------------------------
void FFileDialog::setPath (const FString& dir)
{
const char* const dirname = dir.c_str();
const auto& dirname = dir.c_str();
std::array<char, MAXPATHLEN> resolved_path{};
FString r_dir{};
struct stat sb{};
@ -491,7 +491,7 @@ void FFileDialog::sortDir()
//----------------------------------------------------------------------
int FFileDialog::readDir()
{
const char* const dir = directory.c_str();
const auto& dir = directory.c_str();
directory_stream = opendir(dir);
if ( ! directory_stream )
@ -555,7 +555,7 @@ int FFileDialog::readDir()
//----------------------------------------------------------------------
void FFileDialog::getEntry (const char* const dir, const struct dirent* d_entry)
{
const char* const filter = filter_pattern.c_str();
const auto& filter = filter_pattern.c_str();
FDirEntry entry{};
entry.name = d_entry->d_name;
@ -790,7 +790,7 @@ void FFileDialog::cb_processActivate()
return ! entry.name.empty()
&& input
&& ! input.isNull()
&& std::strcmp(entry.name.c_str(), input) == 0
&& std::strcmp(entry.name.c_str(), input.c_str()) == 0
&& entry.directory;
}
);

160
src/fkeyboard.cpp
View File

@ -21,8 +21,11 @@
***********************************************************************/
#include <fcntl.h>
#include <sys/ioctl.h>
#if defined(__CYGWIN__)
#if defined(__sun) && defined(__SVR4)
#include <sys/filio.h> // need for FIONREAD
#elif defined(__CYGWIN__)
#include <sys/select.h> // need for FD_ZERO, FD_SET, FD_CLR, ...
#endif
@ -30,10 +33,12 @@
#include <array>
#include <string>
#include "final/fapplication.h"
#include "final/fkeyboard.h"
#include "final/fkey_map.h"
#include "final/fobject.h"
#include "final/fterm.h"
#include "final/ftermdetection.h"
#include "final/ftermios.h"
#if defined(__linux__)
@ -44,11 +49,11 @@ namespace finalcut
{
// static class attributes
uInt64 FKeyboard::read_blocking_time{100000}; // preset to 100 ms / 10 Hz
uInt64 FKeyboard::key_timeout{100000}; // preset to 100 ms / 10 Hz
uInt64 FKeyboard::interval_timeout{75000}; // preset to 75 ms / 13.3 Hz
uInt64 FKeyboard::key_timeout{100000}; // 100 ms (10 Hz)
uInt64 FKeyboard::read_blocking_time{100000}; // 100 ms (10 Hz)
uInt64 FKeyboard::read_blocking_time_short{5000}; // 5 ms (200 Hz)
bool FKeyboard::non_blocking_input_support{true};
struct timeval FKeyboard::time_keypressed{};
struct timeval FKeyboard::time_last_request{};
#if defined(__linux__)
FTermLinux* FKeyboard::linux{nullptr};
@ -66,14 +71,14 @@ FKeyboard::FKeyboard()
// Initialize keyboard values
time_keypressed.tv_sec = 0;
time_keypressed.tv_usec = 0;
time_last_request.tv_sec = 0;
time_last_request.tv_usec = 0;
// Get the stdin file status flags
stdin_status_flags = fcntl(FTermios::getStdIn(), F_GETFL);
if ( stdin_status_flags == -1 )
std::abort();
term_detection = FTerm::getFTermDetection();
}
//----------------------------------------------------------------------
@ -84,6 +89,7 @@ FKeyboard::~FKeyboard() // destructor
//----------------------------------------------------------------------
void FKeyboard::fetchKeyCode()
{
if ( fkey_queue.size() < MAX_QUEUE_SIZE )
parseKeyBuffer();
}
@ -142,15 +148,15 @@ void FKeyboard::init()
}
//----------------------------------------------------------------------
bool& FKeyboard::unprocessedInput()
bool& FKeyboard::hasUnprocessedInput()
{
return input_data_pending;
return unprocessed_buffer_data;
}
//----------------------------------------------------------------------
bool FKeyboard::isKeyPressed() const
bool FKeyboard::isKeyPressed (uInt64 blocking_time)
{
if ( ! isIntervalTimeout() )
if ( has_pending_input )
return false;
fd_set ifds{};
@ -159,15 +165,31 @@ bool FKeyboard::isKeyPressed() const
FD_ZERO(&ifds);
FD_SET(stdin_no, &ifds);
tv.tv_sec = 0;
tv.tv_usec = suseconds_t(read_blocking_time); // preset to 100 ms
FObject::getCurrentTime (&time_last_request);
const int result = select (stdin_no + 1, &ifds, nullptr, nullptr, &tv);
tv.tv_sec = tv.tv_usec = 0; // Non-blocking input
if ( result > 0 && FD_ISSET(stdin_no, &ifds) )
if ( blocking_time > 0
&& non_blocking_input_support
&& select(stdin_no + 1, &ifds, nullptr, nullptr, &tv) > 0
&& FD_ISSET(stdin_no, &ifds) )
{
has_pending_input = true;
FD_CLR (stdin_no, &ifds);
tv.tv_sec = 0;
}
return ( result > 0 );
if ( isKeypressTimeout() || ! non_blocking_input_support )
tv.tv_usec = suseconds_t(blocking_time);
else
tv.tv_usec = suseconds_t(read_blocking_time_short);
if ( ! has_pending_input
&& select(stdin_no + 1, &ifds, nullptr, nullptr, &tv) > 0
&& FD_ISSET(stdin_no, &ifds) )
{
has_pending_input = true;
}
return has_pending_input;
}
//----------------------------------------------------------------------
@ -176,6 +198,7 @@ void FKeyboard::clearKeyBuffer()
// Empty the buffer
fifo_offset = 0;
fkey = 0;
key = 0;
std::fill_n (fifo_buf, FIFO_BUF_SIZE, '\0');
fifo_in_use = false;
@ -205,7 +228,7 @@ void FKeyboard::escapeKeyHandling()
fifo_offset = 0;
fifo_buf[0] = 0x00;
fifo_in_use = false;
input_data_pending = false;
unprocessed_buffer_data = false;
escapeKeyPressed();
}
@ -213,6 +236,30 @@ void FKeyboard::escapeKeyHandling()
substringKeyHandling();
}
//----------------------------------------------------------------------
void FKeyboard::processQueuedInput()
{
while ( ! fkey_queue.empty() )
{
key = fkey_queue.front();
fkey_queue.pop();
if ( key > 0 )
{
keyPressed();
if ( FApplication::isQuit() )
return;
keyReleased();
if ( FApplication::isQuit() )
return;
key = 0;
}
}
}
// private methods of FKeyboard
//----------------------------------------------------------------------
@ -268,7 +315,7 @@ inline FKey FKeyboard::getTermcapKey()
for (n = n - len; n < FIFO_BUF_SIZE; n++) // Fill rest with '\0'
fifo_buf[n] = '\0';
input_data_pending = bool(fifo_buf[0] != '\0');
unprocessed_buffer_data = bool(fifo_buf[0] != '\0');
return entry.num;
}
}
@ -307,7 +354,7 @@ inline FKey FKeyboard::getMetaKey()
for (n = n - len; n < FIFO_BUF_SIZE; n++) // Fill rest with '\0'
fifo_buf[n] = '\0';
input_data_pending = bool(fifo_buf[0] != '\0');
unprocessed_buffer_data = bool(fifo_buf[0] != '\0');
return entry.num;
}
}
@ -355,7 +402,7 @@ inline FKey FKeyboard::getSingleKey()
for (n = n - len; n < FIFO_BUF_SIZE; n++) // Fill the rest with '\0' bytes
fifo_buf[n] = '\0';
input_data_pending = bool(fifo_buf[0] != '\0');
unprocessed_buffer_data = bool(fifo_buf[0] != '\0');
if ( keycode == 0 ) // Ctrl+Space or Ctrl+@
keycode = fc::Fckey_space;
@ -369,12 +416,6 @@ inline bool FKeyboard::isKeypressTimeout()
return FObject::isTimeout (&time_keypressed, key_timeout);
}
//----------------------------------------------------------------------
inline bool FKeyboard::isIntervalTimeout()
{
return FObject::isTimeout (&time_last_request, interval_timeout);
}
//----------------------------------------------------------------------
FKey FKeyboard::UTF8decode (const char utf8[]) const
{
@ -427,6 +468,13 @@ FKey FKeyboard::UTF8decode (const char utf8[]) const
//----------------------------------------------------------------------
inline ssize_t FKeyboard::readKey()
{
#if !defined(__CYGWIN__)
int len{0};
if ( ioctl(FTermios::getStdIn(), FIONREAD, &len) < 0 || len == 0 )
return 0;
#endif
setNonBlockingInput();
const ssize_t bytes = read(FTermios::getStdIn(), &read_character, 1);
unsetNonBlockingInput();
@ -441,9 +489,11 @@ void FKeyboard::parseKeyBuffer()
while ( (bytesread = readKey()) > 0 )
{
has_pending_input = false;
if ( bytesread + fifo_offset <= int(FIFO_BUF_SIZE) )
{
fifo_buf[fifo_offset] = char(read_character);
fifo_buf[fifo_offset] = read_character;
fifo_offset++;
fifo_in_use = true;
}
@ -451,30 +501,33 @@ void FKeyboard::parseKeyBuffer()
// Read the rest from the fifo buffer
while ( ! isKeypressTimeout()
&& fifo_offset > 0
&& key != fc::Fkey_incomplete )
&& fkey != fc::Fkey_incomplete )
{
key = parseKeyString();
key = keyCorrection(key);
if ( key != fc::Fkey_incomplete )
keyPressed();
fkey = parseKeyString();
fkey = keyCorrection(fkey);
if ( fkey == fc::Fkey_mouse
|| fkey == fc::Fkey_extended_mouse
|| fkey == fc::Fkey_urxvt_mouse )
{
key = fkey;
mouseTracking();
fifo_offset = int(std::strlen(fifo_buf));
if ( key == fc::Fkey_mouse
|| key == fc::Fkey_extended_mouse
|| key == fc::Fkey_urxvt_mouse )
break;
}
// Send key up event
if ( key > 0 )
keyReleased();
key = 0;
if ( fkey != fc::Fkey_incomplete )
{
fkey_queue.push(fkey);
fifo_offset = int(std::strlen(fifo_buf));
}
}
read_character = 0;
fkey = 0;
if ( fkey_queue.size() >= MAX_QUEUE_SIZE )
break;
}
}
//----------------------------------------------------------------------
@ -512,7 +565,7 @@ FKey FKeyboard::keyCorrection (const FKey& keycode) const
FKey key_correction;
#if defined(__linux__)
if ( linux )
if ( linux && FTerm::isLinuxTerm() )
key_correction = linux->modifierKeyCorrection(keycode);
else
key_correction = keycode;
@ -539,17 +592,16 @@ void FKeyboard::substringKeyHandling()
fifo_offset = 0;
fifo_buf[0] = 0x00;
fifo_in_use = false;
input_data_pending = false;
unprocessed_buffer_data = false;
if ( fifo_buf[1] == 'O' )
key = fc::Fmkey_O;
fkey = fc::Fmkey_O;
else if ( fifo_buf[1] == '[' )
key = fc::Fmkey_left_square_bracket;
fkey = fc::Fmkey_left_square_bracket;
else
key = fc::Fmkey_right_square_bracket;
fkey = fc::Fmkey_right_square_bracket;
keyPressed();
keyReleased();
fkey_queue.push(fkey);
}
}
@ -571,4 +623,10 @@ void FKeyboard::escapeKeyPressed() const
escape_key_cmd.execute();
}
//----------------------------------------------------------------------
void FKeyboard::mouseTracking() const
{
mouse_tracking_cmd.execute();
}
} // namespace finalcut

8
src/flabel.cpp
View File

@ -205,11 +205,7 @@ void FLabel::onMouseDown (FMouseEvent* ev)
accel_widget->redraw();
if ( getStatusBar() )
{
accel_widget->getStatusBar()->drawMessage();
updateTerminal();
flush();
}
}
}
@ -232,11 +228,7 @@ void FLabel::onAccel (FAccelEvent* ev)
FApplication::sendEvent(accel_widget, &in);
if ( getStatusBar() )
{
accel_widget->getStatusBar()->drawMessage();
updateTerminal();
flush();
}
}
}

24
src/flineedit.cpp
View File

@ -357,7 +357,9 @@ void FLineEdit::onKeyPress (FKeyEvent* ev)
&& key != fc::Fkey_enter )
{
drawInputField();
updateTerminal();
if ( processTerminalUpdate() )
flush();
}
}
@ -397,7 +399,9 @@ void FLineEdit::onMouseDown (FMouseEvent* ev)
adjustTextOffset();
drawInputField();
updateTerminal();
if ( processTerminalUpdate() )
flush();
}
}
@ -431,7 +435,9 @@ void FLineEdit::onMouseMove (FMouseEvent* ev)
adjustTextOffset();
drawInputField();
updateTerminal();
if ( processTerminalUpdate() )
flush();
}
// auto-scrolling when dragging mouse outside the widget
@ -534,7 +540,9 @@ void FLineEdit::onTimer (FTimerEvent*)
adjustTextOffset();
drawInputField();
updateTerminal();
if ( processTerminalUpdate() )
flush();
}
//----------------------------------------------------------------------
@ -554,11 +562,7 @@ void FLineEdit::onAccel (FAccelEvent* ev)
redraw();
if ( getStatusBar() )
{
getStatusBar()->drawMessage();
updateTerminal();
flush();
}
}
}
@ -584,11 +588,7 @@ void FLineEdit::onFocusIn (FFocusEvent*)
}
if ( getStatusBar() )
{
getStatusBar()->drawMessage();
updateTerminal();
flush();
}
}
//----------------------------------------------------------------------

23
src/flistbox.cpp
View File

@ -280,7 +280,7 @@ void FListBox::clear()
if ( size == 0 )
return;
for (int y{0}; y < int(getHeight()) - 2; y++)
for (auto y{0}; y < int(getHeight()) - 2; y++)
{
print() << FPoint{2, 2 + y} << FString{size, L' '};
}
@ -352,7 +352,7 @@ void FListBox::onMouseDown (FMouseEvent* ev)
if ( yoffset_before != yoffset )
vbar->drawBar();
updateTerminal();
if ( processTerminalUpdate() )
flush();
}
}
@ -426,7 +426,7 @@ void FListBox::onMouseMove (FMouseEvent* ev)
if ( yoffset_before != yoffset )
vbar->drawBar();
updateTerminal();
if ( processTerminalUpdate() )
flush();
}
@ -504,7 +504,7 @@ void FListBox::onTimer (FTimerEvent*)
if ( yoffset_before != yoffset )
vbar->drawBar();
updateTerminal();
if ( processTerminalUpdate() )
flush();
}
@ -547,7 +547,7 @@ void FListBox::onWheel (FWheelEvent* ev)
if ( yoffset_before != yoffset )
vbar->drawBar();
updateTerminal();
if ( processTerminalUpdate() )
flush();
}
@ -727,7 +727,7 @@ void FListBox::draw()
{
setColor();
for (int y{2}; y < int(getHeight()); y++)
for (auto y{2}; y < int(getHeight()); y++)
{
print() << FPoint{int(getWidth()) - 1, y}
<< ' '; // clear right side of the scrollbar
@ -1082,7 +1082,7 @@ inline void FListBox::updateDrawing (bool draw_vbar, bool draw_hbar)
if ( draw_hbar )
hbar->drawBar();
updateTerminal();
if ( processTerminalUpdate() )
flush();
}
@ -1803,7 +1803,7 @@ void FListBox::cb_vbarChange (const FWidget*)
if ( yoffset_before != yoffset )
vbar->drawBar();
updateTerminal();
if ( processTerminalUpdate() )
flush();
}
}
@ -1862,11 +1862,8 @@ void FListBox::cb_hbarChange (const FWidget*)
inc_search.clear();
if ( isShown() )
{
drawList();
updateTerminal();
flush();
}
if ( scrollType >= FScrollbar::scrollStepBackward )
{
@ -1875,7 +1872,7 @@ void FListBox::cb_hbarChange (const FWidget*)
if ( xoffset_before != xoffset )
hbar->drawBar();
updateTerminal();
if ( processTerminalUpdate() )
flush();
}
}

25
src/flistview.cpp
View File

@ -1116,7 +1116,7 @@ void FListView::onMouseDown (FMouseEvent* ev)
if ( first_line_position_before != first_visible_line.getPosition() )
vbar->drawBar();
updateTerminal();
if ( processTerminalUpdate() )
flush();
}
}
@ -1221,7 +1221,7 @@ void FListView::onMouseMove (FMouseEvent* ev)
if ( first_line_position_before != first_visible_line.getPosition() )
vbar->drawBar();
updateTerminal();
if ( processTerminalUpdate() )
flush();
}
@ -1308,7 +1308,7 @@ void FListView::onTimer (FTimerEvent*)
if ( first_line_position_before != first_visible_line.getPosition() )
vbar->drawBar();
updateTerminal();
if ( processTerminalUpdate() )
flush();
}
@ -1347,7 +1347,7 @@ void FListView::onWheel (FWheelEvent* ev)
if ( first_line_position_before != first_visible_line.getPosition() )
vbar->drawBar();
updateTerminal();
if ( processTerminalUpdate() )
flush();
}
@ -1604,7 +1604,7 @@ void FListView::draw()
{
setColor();
for (int y{2}; y < int(getHeight()); y++)
for (auto y{2}; y < int(getHeight()); y++)
{
print() << FPoint{int(getWidth()) - 1, y}
<< ' '; // clear right side of the scrollbar
@ -1841,7 +1841,7 @@ void FListView::clearList()
if ( size == 0 )
return;
for (int y{0}; y < int(getHeight()) - 2; y++)
for (auto y{0}; y < int(getHeight()) - 2; y++)
{
print() << FPoint{2, 2 + y} << FString{size, L' '};
}
@ -2152,7 +2152,7 @@ void FListView::updateDrawing (bool draw_vbar, bool draw_hbar)
if ( draw_hbar )
hbar->drawBar();
updateTerminal();
if ( processTerminalUpdate() )
flush();
}
@ -2849,11 +2849,8 @@ void FListView::cb_vbarChange (const FWidget*)
break;
case FScrollbar::scrollJump:
{
int value = vbar->getValue();
scrollToY (value);
scrollToY (vbar->getValue());
break;
}
case FScrollbar::scrollWheelUp:
wheelUp (wheel_distance);
@ -2875,7 +2872,7 @@ void FListView::cb_vbarChange (const FWidget*)
if ( first_line_position_before != first_visible_line.getPosition() )
vbar->drawBar();
updateTerminal();
if ( processTerminalUpdate() )
flush();
}
}
@ -2932,8 +2929,6 @@ void FListView::cb_hbarChange (const FWidget*)
{
drawHeadlines();
drawList();
updateTerminal();
flush();
}
if ( scrollType >= FScrollbar::scrollStepBackward )
@ -2943,7 +2938,7 @@ void FListView::cb_hbarChange (const FWidget*)
if ( xoffset_before != xoffset )
hbar->drawBar();
updateTerminal();
if ( processTerminalUpdate() )
flush();
}
}

55
src/fmenu.cpp
View File

@ -110,8 +110,6 @@ void FMenu::hide()
FWindow::hide();
const auto& t_geometry = getTermGeometryWithShadow();
restoreVTerm (t_geometry);
updateTerminal();
flush();
if ( ! isSubMenu() )
{
@ -206,9 +204,6 @@ void FMenu::onMouseDown (FMouseEvent* ev)
if ( getStatusBar() )
getStatusBar()->drawMessage();
updateTerminal();
flush();
}
return;
@ -284,19 +279,19 @@ void FMenu::onMouseMove (FMouseEvent* ev)
if ( ms.mouse_over_submenu )
{
passEventToSubMenu(ev); // Event handover to sub-menu
passEventToSubMenu(std::move(*ev)); // Event handover to sub-menu
return;
}
if ( ! ms.mouse_over_menu && ms.mouse_over_supermenu )
{
passEventToSuperMenu(ev); // Event handover to super-menu
passEventToSuperMenu(std::move(*ev)); // Event handover to super-menu
return;
}
if ( ms.mouse_over_menubar )
{
passEventToMenuBar(ev); // Event handover to the menu bar
passEventToMenuBar(std::move(*ev)); // Event handover to the menu bar
return;
}
@ -316,7 +311,8 @@ void FMenu::onMouseMove (FMouseEvent* ev)
else if ( ms.hide_sub_menu )
{
closeOpenedSubMenu();
updateTerminal();
if ( processTerminalUpdate() )
flush();
}
}
@ -615,9 +611,6 @@ void FMenu::openSubMenu (FMenu* sub_menu, bool select)
if ( getStatusBar() )
getStatusBar()->drawMessage();
updateTerminal();
flush();
}
//----------------------------------------------------------------------
@ -728,9 +721,6 @@ void FMenu::mouseDownSubmenu (const FMenuItem* m_item)
if ( getStatusBar() )
getStatusBar()->drawMessage();
updateTerminal();
flush();
}
}
@ -798,9 +788,6 @@ bool FMenu::mouseUpOverList (const FPoint& mouse_pos)
if ( getStatusBar() )
getStatusBar()->drawMessage();
updateTerminal();
flush();
}
return true;
@ -923,13 +910,13 @@ void FMenu::mouseMoveOverBorder (MouseStates& ms) const
}
//----------------------------------------------------------------------
void FMenu::passEventToSubMenu (FMouseEvent* const& ev)
void FMenu::passEventToSubMenu (const FMouseEvent&& ev)
{
// Mouse event handover to sub-menu
const auto& t = ev->getTermPos();
const auto& t = ev.getTermPos();
const auto& p = opened_sub_menu->termToWidgetPos(t);
const int b = ev->getButton();
const int b = ev.getButton();
try
{
@ -946,14 +933,14 @@ void FMenu::passEventToSubMenu (FMouseEvent* const& ev)
}
//----------------------------------------------------------------------
void FMenu::passEventToSuperMenu (FMouseEvent* const& ev)
void FMenu::passEventToSuperMenu (const FMouseEvent&& ev)
{
// Mouse event handover to super-menu
auto smenu = superMenuAt (ev->getTermPos());
const auto& t = ev->getTermPos();
auto smenu = superMenuAt (ev.getTermPos());
const auto& t = ev.getTermPos();
const auto& p = smenu->termToWidgetPos(t);
const int b = ev->getButton();
const int b = ev.getButton();
try
{
@ -970,14 +957,14 @@ void FMenu::passEventToSuperMenu (FMouseEvent* const& ev)
}
//----------------------------------------------------------------------
void FMenu::passEventToMenuBar (FMouseEvent* const& ev) const
void FMenu::passEventToMenuBar (const FMouseEvent&& ev) const
{
// Mouse event handover to the menu bar
auto menu_bar = getMenuBar();
const auto& t = ev->getTermPos();
const auto& t = ev.getTermPos();
const auto& p = menu_bar->termToWidgetPos(t);
const int b = ev->getButton();
const int b = ev.getButton();
try
{
@ -1073,8 +1060,6 @@ bool FMenu::selectNextItem()
getStatusBar()->drawMessage();
redraw();
updateTerminal();
flush();
break;
}
@ -1123,8 +1108,6 @@ bool FMenu::selectPrevItem()
getStatusBar()->drawMessage();
redraw();
updateTerminal();
flush();
break;
}
}
@ -1186,8 +1169,6 @@ bool FMenu::hotkeyMenu (FKeyEvent* ev)
hideSubMenus();
hide();
hideSuperMenus();
updateTerminal();
flush();
ev->accept();
item->processClicked();
}
@ -1527,9 +1508,6 @@ inline void FMenu::selectPrevMenu (FKeyEvent* ev)
if ( getStatusBar() )
getStatusBar()->drawMessage();
updateTerminal();
flush();
}
else
keypressMenuBar(ev); // select previous menu
@ -1600,9 +1578,6 @@ inline void FMenu::closeMenu()
if ( getStatusBar() )
getStatusBar()->drawMessage();
updateTerminal();
flush();
}
//----------------------------------------------------------------------

34
src/fmenubar.cpp
View File

@ -79,7 +79,6 @@ void FMenuBar::hide()
FColor bg = wc->term_bg;
setColor (fg, bg);
print() << FPoint{1, 1} << FString{getDesktopWidth(), L' '};
updateTerminal();
FWindow::hide();
}
@ -210,7 +209,7 @@ void FMenuBar::onMouseMove (FMouseEvent* ev)
// Handle menu entries
if ( mouse_down )
mouseMoveOverList(ev);
mouseMoveOverList(std::move(*ev));
}
//----------------------------------------------------------------------
@ -224,6 +223,10 @@ void FMenuBar::onAccel (FAccelEvent* ev)
getStatusBar()->drawMessage();
redraw();
if ( processTerminalUpdate() )
flush();
ev->accept();
}
@ -825,10 +828,7 @@ void FMenuBar::mouseDownOverList (const FMouseEvent* ev)
}
if ( focus_changed )
{
redraw();
updateTerminal();
}
}
//----------------------------------------------------------------------
@ -869,7 +869,7 @@ void FMenuBar::mouseUpOverList (const FMouseEvent* ev)
}
//----------------------------------------------------------------------
void FMenuBar::mouseMoveOverList (const FMouseEvent* ev)
void FMenuBar::mouseMoveOverList (const FMouseEvent&& ev)
{
auto list = getItemList();
@ -878,10 +878,10 @@ void FMenuBar::mouseMoveOverList (const FMouseEvent* ev)
focus_changed = false;
bool mouse_over_menubar{false};
int mouse_x = ev->getX();
int mouse_y = ev->getY();
int mouse_x = ev.getX();
int mouse_y = ev.getY();
if ( getTermGeometry().contains(ev->getTermPos()) )
if ( getTermGeometry().contains(ev.getTermPos()) )
mouse_over_menubar = true;
for (auto&& item : list)
@ -906,7 +906,7 @@ void FMenuBar::mouseMoveOverList (const FMouseEvent* ev)
else
{
// Event handover to the menu
passEventToMenu(ev);
passEventToMenu(std::move(ev));
}
}
}
@ -922,12 +922,14 @@ void FMenuBar::mouseMoveOverList (const FMouseEvent* ev)
if ( focus_changed )
{
redraw();
updateTerminal();
if ( processTerminalUpdate() )
flush();
}
}
//----------------------------------------------------------------------
void FMenuBar::passEventToMenu (const FMouseEvent* const& ev) const
void FMenuBar::passEventToMenu (const FMouseEvent&& ev) const
{
if ( ! hasSelectedItem() || ! getSelectedItem()->hasMenu() )
return;
@ -937,11 +939,11 @@ void FMenuBar::passEventToMenu (const FMouseEvent* const& ev) const
const auto& menu_geometry = menu->getTermGeometry();
if ( menu->getCount() > 0
&& menu_geometry.contains(ev->getTermPos()) )
&& menu_geometry.contains(ev.getTermPos()) )
{
const auto& t = ev->getTermPos();
const auto& t = ev.getTermPos();
const auto& p = menu->termToWidgetPos(t);
const int b = ev->getButton();
const int b = ev.getButton();
try
{
@ -972,8 +974,6 @@ void FMenuBar::leaveMenuBar()
if ( getStatusBar() )
getStatusBar()->drawMessage();
updateTerminal();
flush();
mouse_down = false;
}

6
src/fmenuitem.cpp
View File

@ -250,8 +250,6 @@ void FMenuItem::openMenu() const
dd_menu->show();
dd_menu->raiseWindow();
dd_menu->redraw();
updateTerminal();
flush();
}
//----------------------------------------------------------------------
@ -419,6 +417,7 @@ void FMenuItem::onAccel (FAccelEvent* ev)
mbar->redraw();
mbar->drop_down = true;
}
else
{
@ -429,6 +428,9 @@ void FMenuItem::onAccel (FAccelEvent* ev)
mbar->drop_down = false;
}
if ( processTerminalUpdate() )
flush();
ev->accept();
}

270
src/fmouse.cpp
View File

@ -28,6 +28,7 @@
#include <iostream>
#include <new>
#include "final/fapplication.h"
#include "final/fconfig.h"
#include "final/fkeyboard.h"
#include "final/fmouse.h"
@ -39,6 +40,136 @@
namespace finalcut
{
//----------------------------------------------------------------------
// class FMouseData
//----------------------------------------------------------------------
// constructors and destructor
//----------------------------------------------------------------------
FMouseData::FMouseData()
{ }
//----------------------------------------------------------------------
FMouseData::~FMouseData()
{ }
// public methods of FMouseData
//----------------------------------------------------------------------
FString FMouseData::getClassName() const
{
return "FMouseData";
}
//----------------------------------------------------------------------
const FPoint& FMouseData::getPos() const
{
return mouse;
}
//----------------------------------------------------------------------
bool FMouseData::isLeftButtonPressed() const
{
return bool(getButtonState().left_button == Pressed);
}
//----------------------------------------------------------------------
bool FMouseData::isLeftButtonReleased() const
{
return bool(getButtonState().left_button == Released);
}
//----------------------------------------------------------------------
bool FMouseData::isLeftButtonDoubleClick() const
{
return bool(getButtonState().left_button == DoubleClick);
}
//----------------------------------------------------------------------
bool FMouseData::isRightButtonPressed() const
{
return bool(getButtonState().right_button == Pressed);
}
//----------------------------------------------------------------------
bool FMouseData::isRightButtonReleased() const
{
return bool(getButtonState().right_button == Released);
}
//----------------------------------------------------------------------
bool FMouseData::isMiddleButtonPressed() const
{
return bool(getButtonState().middle_button == Pressed);
}
//----------------------------------------------------------------------
bool FMouseData::isMiddleButtonReleased() const
{
return bool(getButtonState().middle_button == Released);
}
//----------------------------------------------------------------------
bool FMouseData::isShiftKeyPressed() const
{
return bool(getButtonState().shift_button);
}
//----------------------------------------------------------------------
bool FMouseData::isControlKeyPressed() const
{
return bool(getButtonState().control_button);
}
//----------------------------------------------------------------------
bool FMouseData::isMetaKeyPressed() const
{
return bool(getButtonState().meta_button);
}
//----------------------------------------------------------------------
bool FMouseData::isWheelUp() const
{
return bool(getButtonState().wheel_up);
}
//----------------------------------------------------------------------
bool FMouseData::isWheelDown() const
{
return bool(getButtonState().wheel_down);
}
//----------------------------------------------------------------------
bool FMouseData::isMoved() const
{
return bool(getButtonState().mouse_moved);
}
//----------------------------------------------------------------------
void FMouseData::clearButtonState()
{
// Fill bit field with 0
std::memset(&b_state, 0x00, sizeof(b_state));
}
// protected methods of FMouseData
//----------------------------------------------------------------------
inline FMouseData::FMouseButton& FMouseData::getButtonState()
{
return b_state;
}
//----------------------------------------------------------------------
inline const FMouseData::FMouseButton& FMouseData::getButtonState() const
{
return b_state;
}
//----------------------------------------------------------------------
void FMouseData::setPos (const FPoint& m)
{
mouse = m;
}
//----------------------------------------------------------------------
// class FMouse
//----------------------------------------------------------------------
@ -51,6 +182,10 @@ FMouse::FMouse()
clearButtonState();
}
//----------------------------------------------------------------------
FMouse::~FMouse() // destructor
{ }
// public methods of FMouse
//----------------------------------------------------------------------
@ -59,12 +194,6 @@ FString FMouse::getClassName() const
return "FMouse";
}
//----------------------------------------------------------------------
inline const FPoint& FMouse::getPos() const
{
return mouse;
}
//----------------------------------------------------------------------
inline void FMouse::clearEvent()
{
@ -96,103 +225,13 @@ inline bool FMouse::hasEvent() const
}
//----------------------------------------------------------------------
inline bool FMouse::isLeftButtonPressed()
inline bool FMouse::hasUnprocessedInput() const
{
return bool(getButtonState().left_button == Pressed);
}
//----------------------------------------------------------------------
inline bool FMouse::isLeftButtonReleased()
{
return bool(getButtonState().left_button == Released);
}
//----------------------------------------------------------------------
inline bool FMouse::isLeftButtonDoubleClick()
{
return bool(getButtonState().left_button == DoubleClick);
}
//----------------------------------------------------------------------
inline bool FMouse::isRightButtonPressed()
{
return bool(getButtonState().right_button == Pressed);
}
//----------------------------------------------------------------------
inline bool FMouse::isRightButtonReleased()
{
return bool(getButtonState().right_button == Released);
}
//----------------------------------------------------------------------
inline bool FMouse::isMiddleButtonPressed()
{
return bool(getButtonState().middle_button == Pressed);
}
//----------------------------------------------------------------------
inline bool FMouse::isMiddleButtonReleased()
{
return bool(getButtonState().middle_button == Released);
}
//----------------------------------------------------------------------
inline bool FMouse::isShiftKeyPressed()
{
return bool(getButtonState().shift_button);
}
//----------------------------------------------------------------------
inline bool FMouse::isControlKeyPressed()
{
return bool(getButtonState().control_button);
}
//----------------------------------------------------------------------
inline bool FMouse::isMetaKeyPressed()
{
return bool(getButtonState().meta_button);
}
//----------------------------------------------------------------------
inline bool FMouse::isWheelUp()
{
return bool(getButtonState().wheel_up);
}
//----------------------------------------------------------------------
inline bool FMouse::isWheelDown()
{
return bool(getButtonState().wheel_down);
}
//----------------------------------------------------------------------
inline bool FMouse::isMoved()
{
return bool(getButtonState().mouse_moved);
}
//----------------------------------------------------------------------
inline bool FMouse::isInputDataPending() const
{
return input_data_pending;
}
//----------------------------------------------------------------------
void FMouse::clearButtonState()
{
// Fill bit field with 0
std::memset(&b_state, 0x00, sizeof(b_state));
return unprocessed_buffer_data;
}
// protected methods of FMouse
//----------------------------------------------------------------------
inline FMouse::FMouseButton& FMouse::getButtonState()
{
return b_state;
}
//----------------------------------------------------------------------
inline const FPoint& FMouse::getNewPos() const
{
@ -223,12 +262,6 @@ timeval* FMouse::getMousePressedTime()
return &time_mousepressed;
}
//----------------------------------------------------------------------
void FMouse::setPos (const FPoint& m)
{
mouse = m;
}
//----------------------------------------------------------------------
void FMouse::setNewPos (int x, int y)
{
@ -238,7 +271,7 @@ void FMouse::setNewPos (int x, int y)
//----------------------------------------------------------------------
void FMouse::setPending (bool is_pending)
{
input_data_pending = is_pending;
unprocessed_buffer_data = is_pending;
}
//----------------------------------------------------------------------
@ -1434,14 +1467,14 @@ bool FMouseControl::isMoved()
}
//----------------------------------------------------------------------
bool FMouseControl::isInputDataPending()
bool FMouseControl::hasUnprocessedInput()
{
return std::any_of ( std::begin(mouse_protocol)
, std::end(mouse_protocol)
, [] (FMouseProtocol::const_reference m)
{
return m.second
&& m.second->isInputDataPending();
&& m.second->hasUnprocessedInput();
}
);
}
@ -1514,6 +1547,25 @@ void FMouseControl::setRawData ( FMouse::mouse_type mt
mouse->setRawData (fifo_buf);
}
//----------------------------------------------------------------------
void FMouseControl::processQueuedInput()
{
while ( ! fmousedata_queue.empty() )
{
if ( FApplication::isQuit() )
return;
FMouseDataPtr md(std::move(fmousedata_queue.front()));
fmousedata_queue.pop();
if ( md.get() )
event_cmd.execute(*md);
if ( FApplication::isQuit() )
return;
}
}
//----------------------------------------------------------------------
void FMouseControl::processEvent (struct timeval* time)
{
@ -1522,7 +1574,11 @@ void FMouseControl::processEvent (struct timeval* time)
clearEvent();
if ( mouse_object )
{
mouse_object->processEvent(time);
auto& md = static_cast<FMouseData&>(*mouse_object);
fmousedata_queue.emplace(new FMouseData(std::move(md)));
}
}
//----------------------------------------------------------------------

534
src/foptiattr.cpp
View File

File diff suppressed because it is too large Load Diff

8
src/fprogressbar.cpp
View File

@ -64,8 +64,6 @@ void FProgressbar::setPercentage (std::size_t percentage_value)
drawProgressLabel();
drawProgressBar();
}
updateTerminal();
}
//----------------------------------------------------------------------
@ -126,8 +124,6 @@ void FProgressbar::reset()
drawProgressLabel();
drawProgressBar();
}
updateTerminal();
}
@ -148,6 +144,7 @@ void FProgressbar::draw()
if ( getFlags().shadow )
drawShadow(this);
if ( processTerminalUpdate() )
flush();
}
@ -182,9 +179,6 @@ void FProgressbar::drawProgressBar()
if ( FTerm::isMonochron() )
setReverse(false);
updateTerminal();
flush();
}
//----------------------------------------------------------------------

20
src/fscrollbar.cpp
View File

@ -352,7 +352,10 @@ void FScrollbar::onMouseMove (FMouseEvent* ev)
{
setValue(new_val);
drawBar();
updateTerminal();
if ( processTerminalUpdate() )
flush();
processScroll();
}
}
@ -463,7 +466,7 @@ void FScrollbar::drawVerticalBar()
const auto& wc = getColorTheme();
setColor (wc->scrollbar_fg, wc->scrollbar_bg);
for (int z{1}; z <= slider_pos; z++)
for (auto z{1}; z <= slider_pos; z++)
{
print() << FPoint{1, 1 + z};
drawVerticalBackgroundLine();
@ -474,7 +477,7 @@ void FScrollbar::drawVerticalBar()
if ( FTerm::isMonochron() )
setReverse(false);
for (int z{1}; z <= int(slider_length); z++) // Draw slider
for (auto z{1}; z <= int(slider_length); z++) // Draw slider
{
print() << FPoint{1, 1 + slider_pos + z};
@ -489,7 +492,7 @@ void FScrollbar::drawVerticalBar()
setColor (wc->scrollbar_fg, wc->scrollbar_bg);
for (int z = slider_pos + int(slider_length) + 1; z <= int(bar_length); z++)
for (auto z = slider_pos + int(slider_length) + 1; z <= int(bar_length); z++)
{
print() << FPoint{1, 1 + z};
drawVerticalBackgroundLine();
@ -529,7 +532,7 @@ void FScrollbar::drawHorizontalBar()
else
print() << FPoint{2, 1};
for (int z{0}; z < slider_pos; z++)
for (auto z{0}; z < slider_pos; z++)
drawHorizontalBackgroundColumn();
setColor (wc->scrollbar_bg, wc->scrollbar_fg);
@ -537,7 +540,7 @@ void FScrollbar::drawHorizontalBar()
if ( FTerm::isMonochron() )
setReverse(false);
for (int z{0}; z < int(slider_length); z++) // Draw slider
for (auto z{0}; z < int(slider_length); z++) // Draw slider
print (' ');
if ( FTerm::isMonochron() )
@ -757,7 +760,10 @@ void FScrollbar::jumpToClickPos (int x, int y)
{
setValue(new_val);
drawBar();
updateTerminal();
if ( processTerminalUpdate() )
flush();
scroll_type = FScrollbar::scrollJump;
processScroll();
}

27
src/fscrollview.cpp
View File

@ -411,7 +411,9 @@ void FScrollView::scrollTo (int x, int y)
viewport->has_changes = true;
copy2area();
updateTerminal();
if ( processTerminalUpdate() )
flush();
}
//----------------------------------------------------------------------
@ -647,10 +649,7 @@ void FScrollView::copy2area()
if ( ! hasPrintArea() )
FWidget::getPrintArea();
if ( ! (hasPrintArea() && viewport) )
return;
if ( ! viewport->has_changes )
if ( ! (hasPrintArea() && viewport && viewport->has_changes) )
return;
auto printarea = getCurrentPrintArea();
@ -669,15 +668,15 @@ void FScrollView::copy2area()
if ( printarea->height <= ay + y_end )
y_end = printarea->height - ay;
for (int y{0}; y < y_end; y++) // line loop
for (auto y{0}; y < y_end; y++) // line loop
{
const FChar* vc{}; // viewport character
FChar* ac{}; // area character
const int v_line_len = viewport->width;
const int a_line_len = printarea->width + printarea->right_shadow;
vc = &viewport->data[(dy + y) * v_line_len + dx];
ac = &printarea->data[(ay + y) * a_line_len + ax];
std::memcpy (ac, vc, sizeof(FChar) * unsigned(x_end));
// viewport character
const auto& vc = viewport->data[(dy + y) * v_line_len + dx];
// area character
auto& ac = printarea->data[(ay + y) * a_line_len + ax];
std::memcpy (&ac, &vc, sizeof(FChar) * unsigned(x_end));
if ( int(printarea->changes[ay + y].xmin) > ax )
printarea->changes[ay + y].xmin = uInt(ax);
@ -694,9 +693,9 @@ void FScrollView::copy2area()
// private methods of FScrollView
//----------------------------------------------------------------------
inline FPoint FScrollView::getViewportCursorPos() const
inline FPoint FScrollView::getViewportCursorPos()
{
const auto& window = FWindow::getWindowWidget(this);
auto window = FWindow::getWindowWidget(this);
if ( window )
{
@ -846,7 +845,7 @@ void FScrollView::setVerticalScrollBarVisibility() const
}
//----------------------------------------------------------------------
void FScrollView::setViewportCursor() const
void FScrollView::setViewportCursor()
{
if ( ! isChild(getFocusWidget()) )
return;

1
src/fspinbox.cpp
View File

@ -371,7 +371,6 @@ inline void FSpinBox::updateInputField()
input_field << pfix << value << sfix;
input_field.redraw();
redraw();
updateTerminal();
}
//----------------------------------------------------------------------

3
src/fstatusbar.cpp
View File

@ -189,7 +189,6 @@ void FStatusBar::hide()
const FColor bg = wc->term_bg;
setColor (fg, bg);
print() << FPoint{1, 1} << FString{getDesktopWidth(), L' '};
updateTerminal();
FWindow::hide();
}
@ -256,7 +255,7 @@ void FStatusBar::drawMessage()
}
}
for (int i = x; i <= int(termWidth); i++)
for (auto i = x; i <= int(termWidth); i++)
print (' ');
if ( FTerm::isMonochron() )

113
src/fstring.cpp
View File

@ -128,10 +128,8 @@ FString::FString (fc::SpecialCharacter c)
{
if ( c )
{
wchar_t s[2];
s[0] = static_cast<wchar_t>(c);
s[1] = L'\0';
_assign (s);
std::array<wchar_t, 2> s{{ static_cast<wchar_t>(c), L'\0' }};
_assign (s.data());
}
}
@ -140,10 +138,8 @@ FString::FString (const wchar_t c)
{
if ( c )
{
wchar_t s[2];
s[0] = c;
s[1] = L'\0';
_assign (s);
std::array<wchar_t, 2> s{{ c, L'\0' }};
_assign (s.data());
}
}
@ -152,10 +148,8 @@ FString::FString (const char c)
{
if ( c )
{
wchar_t s[2];
s[0] = wchar_t(c & 0xff);
s[1] = L'\0';
_assign (s);
std::array<wchar_t, 2> s{{ wchar_t(c & 0xff), L'\0' }};
_assign (s.data());
}
}
@ -403,7 +397,10 @@ char* FString::c_str()
if ( length > 0 )
return const_cast<char*>(_to_cstring(string));
else if ( string )
return const_cast<char*>("");
{
static char empty_string{'\0'};
return &empty_string;
}
else
return nullptr;
}
@ -769,7 +766,7 @@ FString& FString::setString (const FString& s)
//----------------------------------------------------------------------
FString& FString::setNumber (sInt64 num)
{
wchar_t buf[30]{};
std::array<wchar_t, 30> buf{};
wchar_t* s = &buf[29]; // Pointer to the last character
auto abs_num = static_cast<uInt64>(num);
@ -813,7 +810,7 @@ FString& FString::setNumber (uInt64 num)
//----------------------------------------------------------------------
FString& FString::setNumber (lDouble f_num, int precision)
{
wchar_t format[20]{}; // = "%.<precision>Lg"
std::array<wchar_t, 20> format{}; // = "%.<precision>Lg"
wchar_t* s = &format[0];
*s++ = L'%';
*s++ = L'.';
@ -838,14 +835,14 @@ FString& FString::setNumber (lDouble f_num, int precision)
*s++ = L'g';
*s = L'\0';
return sprintf(format, f_num);
return sprintf(format.data(), f_num);
}
//----------------------------------------------------------------------
FString& FString::setFormatedNumber (sInt64 num, char separator)
{
int n{0};
wchar_t buf[30]{};
std::array<wchar_t, 30> buf{};
wchar_t* s = &buf[29]; // Pointer to the last character
auto abs_num = static_cast<uInt64>(num);
@ -1534,76 +1531,6 @@ FString operator + (const FString& s1, const FString& s2)
return tmp;
}
//----------------------------------------------------------------------
FString operator + (const FString& s, const wchar_t c)
{
FString tmp1{s};
wchar_t tmp2[2];
tmp2[0] = c;
tmp2[1] = L'\0';
tmp1._insert (tmp1.length, 1, tmp2);
return tmp1;
}
//----------------------------------------------------------------------
FString operator + (const std::wstring& s1, const FString& s2)
{
FString tmp{s1};
tmp._insert (tmp.length, s2.length, s2.wc_str());
return tmp;
}
//----------------------------------------------------------------------
FString operator + (const wchar_t s1[], const FString& s2)
{
FString tmp{s1};
tmp._insert (tmp.length, s2.length, s2.wc_str());
return tmp;
}
//----------------------------------------------------------------------
FString operator + (const std::string& s1, const FString& s2)
{
FString tmp{s1};
tmp._insert (tmp.length, s2.length, s2.wc_str());
return tmp;
}
//----------------------------------------------------------------------
FString operator + (const char s1[], const FString& s2)
{
FString tmp{s1};
tmp._insert (tmp.length, s2.length, s2.wc_str());
return tmp;
}
//----------------------------------------------------------------------
FString operator + (const wchar_t c, const FString& s)
{
FString tmp{c};
tmp._insert (1, s.length, s.wc_str());
return tmp;
}
//----------------------------------------------------------------------
FString operator + (const char c, const FString& s)
{
FString tmp{c};
tmp._insert (1, s.length, s.wc_str());
return tmp;
}
//----------------------------------------------------------------------
FString operator + (const FString& s, const char c)
{
FString tmp1{s};
wchar_t tmp2[2];
tmp2[0] = wchar_t(c & 0xff);
tmp2[1] = L'\0';
tmp1._insert (tmp1.length, 1, tmp2);
return tmp1;
}
//----------------------------------------------------------------------
std::ostream& operator << (std::ostream& outstr, const FString& s)
{
@ -1625,9 +1552,9 @@ std::ostream& operator << (std::ostream& outstr, const FString& s)
//----------------------------------------------------------------------
std::istream& operator >> (std::istream& instr, FString& s)
{
char buf[FString::INPBUFFER + 1]{};
instr.getline (buf, FString::INPBUFFER);
const wchar_t* wc_str = s._to_wcstring(buf);
std::array<char, FString::INPBUFFER + 1> buf{};
instr.getline (buf.data(), FString::INPBUFFER);
const wchar_t* wc_str = s._to_wcstring(buf.data());
if ( wc_str )
{
@ -1659,9 +1586,9 @@ std::wostream& operator << (std::wostream& outstr, const FString& s)
//----------------------------------------------------------------------
std::wistream& operator >> (std::wistream& instr, FString& s)
{
wchar_t buf[FString::INPBUFFER + 1]{};
instr.getline (buf, FString::INPBUFFER);
s._assign (buf);
std::array<wchar_t, FString::INPBUFFER + 1> buf{};
instr.getline (buf.data(), FString::INPBUFFER);
s._assign (buf.data());
return instr;
}

2
src/fswitch.cpp
View File

@ -123,8 +123,6 @@ void FSwitch::draw()
drawLabel();
drawCheckButton();
FToggleButton::draw();
updateTerminal();
flush();
}
//----------------------------------------------------------------------

50
src/fterm.cpp
View File

@ -63,14 +63,21 @@
namespace finalcut
{
// Global FTerm object
static FTerm* init_term_object{nullptr};
namespace internal
{
// Global init state
static bool term_initialized{false};
struct var
{
static FTerm* init_term_object; // Global FTerm object
static bool term_initialized; // Global init state
static uInt object_counter; // Counts the number of object instances
};
// Counts the number of object instances
static uInt object_counter{0};
FTerm* var::init_term_object{nullptr};
bool var::term_initialized{false};
uInt var::object_counter{0};
} // namespace internal
// Static class attributes
FTermData* FTerm::data {nullptr};
@ -107,21 +114,21 @@ FMouseControl* FTerm::mouse {nullptr};
//----------------------------------------------------------------------
FTerm::FTerm()
{
if ( object_counter == 0 )
if ( internal::var::object_counter == 0 )
allocationValues(); // Allocation of global objects
object_counter++;
internal::var::object_counter++;
}
//----------------------------------------------------------------------
FTerm::~FTerm() // destructor
{
if ( init_term_object == this )
if ( internal::var::init_term_object == this )
finish(); // Resetting console settings
object_counter--;
internal::var::object_counter--;
if ( object_counter == 0 )
if ( internal::var::object_counter == 0 )
{
printExitMessage();
deallocationValues(); // Deallocation of global objects
@ -442,7 +449,7 @@ FTermDebugData& FTerm::getFTermDebugData()
#endif // DEBUG
//----------------------------------------------------------------------
bool FTerm::isNormal (const FChar* const& ch)
bool FTerm::isNormal (const FChar& ch)
{
return FOptiAttr::isNormal(ch);
}
@ -588,7 +595,7 @@ bool FTerm::isNewFont()
//----------------------------------------------------------------------
bool FTerm::isInitialized()
{
return term_initialized;
return internal::var::term_initialized;
}
//----------------------------------------------------------------------
@ -1243,9 +1250,6 @@ FTerm::defaultPutChar& FTerm::putchar()
//----------------------------------------------------------------------
void FTerm::putstring (const char str[], int affcnt)
{
if ( ! fsys )
getFSystem();
FTermcap::paddingPrint (str, affcnt, FTerm::putchar_ASCII);
}
@ -1322,7 +1326,7 @@ void FTerm::initScreenSettings()
}
//----------------------------------------------------------------------
const char* FTerm::changeAttribute (FChar*& term_attr, FChar*& next_attr)
const char* FTerm::changeAttribute (FChar& term_attr, FChar& next_attr)
{
return opti_attr->changeAttribute (term_attr, next_attr);
}
@ -2274,7 +2278,7 @@ inline void FTerm::deallocationValues()
//----------------------------------------------------------------------
void FTerm::init()
{
init_term_object = this;
internal::var::init_term_object = this;
// Initialize global values for all objects
init_global_values();
@ -2362,7 +2366,7 @@ void FTerm::init()
FTermios::setRawMode();
// The terminal is now initialized
term_initialized = true;
internal::var::term_initialized = true;
}
//----------------------------------------------------------------------
@ -2587,8 +2591,8 @@ void FTerm::terminalSizeChange()
//----------------------------------------------------------------------
void FTerm::processTermination (int signum)
{
if ( init_term_object )
init_term_object->finish();
if ( internal::var::init_term_object )
internal::var::init_term_object->finish();
std::fflush (stderr);
std::fflush (stdout);
@ -2602,8 +2606,8 @@ void FTerm::processTermination (int signum)
printExitMessage();
}
if ( init_term_object )
init_term_object->deallocationValues();
if ( internal::var::init_term_object )
internal::var::init_term_object->deallocationValues();
std::terminate();
}

6
src/ftermcapquirks.cpp
View File

@ -271,7 +271,8 @@ void FTermcapQuirks::vte()
if ( term_detection->getGnomeTerminalID() >= 5300 ) // vte >= 0.53.0
{
if ( ! std::strstr(TCAP(fc::t_enter_ca_mode), "\033[22;0;0t") )
if ( TCAP(fc::t_enter_ca_mode)
&& ! std::strstr(TCAP(fc::t_enter_ca_mode), "\033[22;0;0t") )
{
// Save the cursor position, enter alternate screen buffer
// and save xterm icon and window title on stack
@ -279,7 +280,8 @@ void FTermcapQuirks::vte()
CSI "?1049h" CSI "22;0;0t";
}
if ( ! std::strstr(TCAP(fc::t_exit_ca_mode), "\033[23;0;0t") )
if ( TCAP(fc::t_exit_ca_mode)
&& ! std::strstr(TCAP(fc::t_exit_ca_mode), "\033[23;0;0t") )
{
// Use normal screen buffer, restore the cursor position
// and restore xterm icon and window title from stack

21
src/ftermdetection.cpp
View File

@ -60,6 +60,7 @@ FKeyboard* FTermDetection::keyboard{nullptr};
char FTermDetection::termtype[256]{};
char FTermDetection::ttytypename[256]{};
bool FTermDetection::decscusr_support{};
bool FTermDetection::terminal_detection{};
bool FTermDetection::color256{};
const FString* FTermDetection::answer_back{nullptr};
@ -163,8 +164,8 @@ void FTermDetection::deallocation()
void FTermDetection::getSystemTermType()
{
// Import the untrusted environment variable TERM
const char* const& term_env = std::getenv("TERM");
const char* termfilename = fterm_data->getTermFileName();
const auto& term_env = std::getenv("TERM");
const auto& termfilename = fterm_data->getTermFileName();
if ( term_env )
{
@ -211,7 +212,7 @@ bool FTermDetection::getTTYtype()
term_basename++;
std::FILE* fp{};
char str[BUFSIZ]{};
std::array<char, BUFSIZ> str{};
if ( ! fsystem )
return false;
@ -220,11 +221,11 @@ bool FTermDetection::getTTYtype()
return false;
// Read and parse the file
while ( fgets(str, sizeof(str) - 1, fp) != nullptr )
while ( fgets(str.data(), str.size() - 1, fp) != nullptr )
{
const char* type{nullptr}; // nullptr == not found
const char* name{nullptr};
char* p = str;
char* p = str.data();
while ( *p )
{
@ -232,7 +233,7 @@ bool FTermDetection::getTTYtype()
*p = '\0';
else if ( type == nullptr )
type = p;
else if ( name == nullptr && p != str && p[-1] == '\0' )
else if ( name == nullptr && p != str.data() && p[-1] == '\0' )
name = p;
p++;
@ -405,6 +406,14 @@ void FTermDetection::detectTerminal()
std::strncpy (termtype, new_termtype, sizeof(termtype));
termtype[sizeof(termtype) - 1] = '\0';
}
#if defined(__CYGWIN__)
const auto& termfilename = fterm_data->getTermFileName();
// Fixes problem with mouse input
if ( std::strncmp(termfilename, "/dev/cons", 9) == 0 )
FKeyboard::setNonBlockingInputSupport(false);
#endif
}
//----------------------------------------------------------------------

10
src/ftermlinux.cpp
View File

@ -277,9 +277,8 @@ bool FTermLinux::loadVGAFont()
// Unicode character mapping
struct unimapdesc unimap;
unimap.entry_ct = uInt16 ( sizeof(fc::unicode_cp437_pairs)
/ sizeof(unipair) );
unimap.entries = const_cast<unipair*>(&fc::unicode_cp437_pairs[0]);
unimap.entry_ct = uInt16(fc::unicode_cp437_pairs.size());
unimap.entries = const_cast<unipair*>(fc::unicode_cp437_pairs.data());
setUnicodeMap(&unimap);
}
else
@ -328,9 +327,8 @@ bool FTermLinux::loadNewFont()
// Unicode character mapping
struct unimapdesc unimap;
unimap.entry_ct = uInt16 ( sizeof(fc::unicode_newfont_pairs)
/ sizeof(unipair) );
unimap.entries = const_cast<unipair*>(&fc::unicode_newfont_pairs[0]);
unimap.entry_ct = uInt16(fc::unicode_newfont_pairs.size());
unimap.entries = const_cast<unipair*>(fc::unicode_newfont_pairs.data());
setUnicodeMap(&unimap);
}
else

12
src/ftextview.cpp
View File

@ -184,7 +184,9 @@ void FTextView::scrollTo (int x, int y)
}
drawText();
updateTerminal();
if ( processTerminalUpdate() )
flush();
}
//----------------------------------------------------------------------
@ -322,13 +324,12 @@ void FTextView::clear()
if ( size == 0 )
return;
for (int y{0}; y < int(getTextHeight()); y++)
for (auto y{0}; y < int(getTextHeight()); y++)
{
print() << FPoint{2, 2 - nf_offset + y}
<< FString{size, L' '};
}
updateTerminal();
processChanged();
}
@ -476,7 +477,8 @@ void FTextView::onWheel (FWheelEvent* ev)
if ( isShown() )
drawText();
updateTerminal();
if ( processTerminalUpdate() )
flush();
}
//----------------------------------------------------------------------
@ -621,8 +623,6 @@ void FTextView::draw()
}
setCursorPos ({int(getWidth()), int(getHeight())});
updateTerminal();
flush();
}
//----------------------------------------------------------------------

11
src/ftogglebutton.cpp
View File

@ -222,11 +222,7 @@ void FToggleButton::onMouseDown (FMouseEvent* ev)
redraw();
if ( getStatusBar() )
{
getStatusBar()->drawMessage();
updateTerminal();
flush();
}
}
//----------------------------------------------------------------------
@ -299,11 +295,7 @@ void FToggleButton::onAccel (FAccelEvent* ev)
redraw();
if ( getStatusBar() )
{
getStatusBar()->drawMessage();
updateTerminal();
flush();
}
processClick();
ev->accept();
@ -474,10 +466,7 @@ void FToggleButton::onKeyPress (FKeyEvent* ev)
}
if ( ev->isAccepted() )
{
draw();
updateTerminal();
}
}

856
src/fvterm.cpp
View File

File diff suppressed because it is too large Load Diff

75
src/fwidget.cpp
View File

@ -37,8 +37,17 @@
namespace finalcut
{
// global FWidget object
static FWidget* root_widget{nullptr};
namespace internal
{
struct var
{
static FWidget* root_widget; // global FWidget object
};
FWidget* var::root_widget{nullptr};
} // namespace internal
// static class attributes
FStatusBar* FWidget::statusbar{nullptr};
@ -74,7 +83,7 @@ FWidget::FWidget (FWidget* parent)
if ( ! parent )
{
if ( root_widget )
if ( internal::var::root_widget )
{
auto ftermdata = FTerm::getFTermData();
ftermdata->setExitMessage("FWidget: No parent defined! "
@ -134,16 +143,16 @@ FWidget::~FWidget() // destructor
accelerator_list.clear();
// finish the program
if ( root_widget == this )
if ( internal::var::root_widget == this )
finish();
}
// public methods of FWidget
//----------------------------------------------------------------------
FWidget* FWidget::getRootWidget() const
FWidget* FWidget::getRootWidget()
{
auto obj = const_cast<FWidget*>(this);
FWidget* obj = this;
auto p_obj = getParentWidget();
while ( ! obj->isRootWidget() && p_obj )
@ -496,7 +505,7 @@ void FWidget::setTopPadding (int top, bool adjust)
{
if ( isRootWidget() )
{
auto r = root_widget;
auto r = internal::var::root_widget;
r->wclient_offset.setY1 (r->padding.top);
adjustSizeGlobal();
}
@ -517,7 +526,7 @@ void FWidget::setLeftPadding (int left, bool adjust)
{
if ( isRootWidget() )
{
auto r = root_widget;
auto r = internal::var::root_widget;
r->wclient_offset.setX1 (r->padding.left);
adjustSizeGlobal();
}
@ -538,7 +547,7 @@ void FWidget::setBottomPadding (int bottom, bool adjust)
{
if ( isRootWidget() )
{
auto r = root_widget;
auto r = internal::var::root_widget;
r->wclient_offset.setY2 (int(r->getHeight()) - 1 - r->padding.bottom);
adjustSizeGlobal();
}
@ -559,7 +568,7 @@ void FWidget::setRightPadding (int right, bool adjust)
{
if ( isRootWidget() )
{
auto r = root_widget;
auto r = internal::var::root_widget;
r->wclient_offset.setX2 (int(r->getWidth()) - 1 - r->padding.right);
adjustSizeGlobal();
}
@ -575,8 +584,8 @@ void FWidget::setTermSize (const FSize& size) const
if ( FTerm::isXTerminal() )
{
root_widget->wsize.setRect(FPoint{1, 1}, size);
root_widget->adjust_wsize = root_widget->wsize;
internal::var::root_widget->wsize.setRect(FPoint{1, 1}, size);
internal::var::root_widget->adjust_wsize = internal::var::root_widget->wsize;
FTerm::setTermSize(size); // width = columns / height = lines
detectTermSize();
}
@ -885,7 +894,7 @@ void FWidget::redraw()
if ( isRootWidget() )
{
startTerminalUpdate();
startDrawing();
// clean desktop
auto color_theme = getColorTheme();
setColor (color_theme->term_fg, color_theme->term_bg);
@ -902,14 +911,10 @@ void FWidget::redraw()
drawChildren();
if ( isRootWidget() )
finishTerminalUpdate();
finishDrawing();
if ( redraw_root_widget == this )
{
updateTerminal();
flush();
redraw_root_widget = nullptr;
}
}
//----------------------------------------------------------------------
@ -948,12 +953,12 @@ void FWidget::show()
return;
// Initialize desktop on first call
if ( ! init_desktop && root_widget )
root_widget->initDesktop();
if ( ! init_desktop && internal::var::root_widget )
internal::var::root_widget->initDesktop();
if ( ! show_root_widget )
{
startTerminalUpdate();
startDrawing();
show_root_widget = this;
}
@ -975,9 +980,11 @@ void FWidget::show()
if ( show_root_widget && show_root_widget == this )
{
finishTerminalUpdate();
updateTerminal();
finishDrawing();
if ( processTerminalUpdate() )
flush();
show_root_widget = nullptr;
}
@ -1241,8 +1248,8 @@ void FWidget::initTerminal()
// Set default foreground and background color of the desktop/terminal
auto color_theme = getColorTheme();
root_widget->foreground_color = color_theme->term_fg;
root_widget->background_color = color_theme->term_bg;
internal::var::root_widget->foreground_color = color_theme->term_fg;
internal::var::root_widget->background_color = color_theme->term_bg;
resetColors();
// The terminal is now initialized
@ -1282,7 +1289,7 @@ void FWidget::adjustSize()
if ( ignore_padding && ! isDialogWidget() )
setTermOffset();
else
woffset = root_widget->wclient_offset;
woffset = internal::var::root_widget->wclient_offset;
}
else if ( ignore_padding && p )
{
@ -1322,7 +1329,7 @@ void FWidget::adjustSize()
}
//----------------------------------------------------------------------
void FWidget::adjustSizeGlobal() const
void FWidget::adjustSizeGlobal()
{
if ( ! isRootWidget() )
{
@ -1364,7 +1371,7 @@ void FWidget::hideArea (const FSize& size)
if ( size.getWidth() == 0 )
return;
for (int y{0}; y < int(size.getHeight()); y++)
for (auto y{0}; y < int(size.getHeight()); y++)
{
print() << FPoint{1, 1 + y} << FString{size.getWidth(), L' '};
}
@ -1678,8 +1685,8 @@ void FWidget::onAccel (FAccelEvent*)
void FWidget::onResize (FResizeEvent* ev)
{
// The terminal was resized
root_widget->resize();
root_widget->redraw();
internal::var::root_widget->resize();
internal::var::root_widget->redraw();
ev->accept();
}
@ -1737,11 +1744,11 @@ void FWidget::initRootWidget()
}
// Initialize default widget colors
// (before terminal detection and root_widget is set)
// (before terminal detection and internal::var::root_widget is set)
initColorTheme();
// Root widget basic initialization
root_widget = this;
internal::var::root_widget = this;
show_root_widget = nullptr;
redraw_root_widget = nullptr;
modal_dialog_counter = 0;
@ -1953,8 +1960,6 @@ bool FWidget::changeFocus ( FWidget* follower, FWidget* parent
{
redraw();
follower->redraw();
updateTerminal();
flush();
}
}
@ -2100,7 +2105,7 @@ void FWidget::setStatusbarText (bool enable) const
//----------------------------------------------------------------------
void detectTermSize()
{
const auto& r = root_widget;
const auto& r = internal::var::root_widget;
FTerm::detectTermSize();
r->adjust_wsize.setRect (1, 1, r->getDesktopWidth(), r->getDesktopHeight());
r->woffset.setRect (0, 0, r->getDesktopWidth(), r->getDesktopHeight());

6
src/fwidget_functions.cpp
View File

@ -451,7 +451,7 @@ inline void drawBox (FWidget* w, const FRect& r)
<< FString{r.getWidth() - 2, fc::BoxDrawingsHorizontal} // ─
<< fc::BoxDrawingsDownAndLeft; // ┐
for (int y = r.getY1() + 1; y < r.getY2(); y++)
for (auto y = r.getY1() + 1; y < r.getY2(); y++)
{
w->print() << FPoint{r.getX1(), y}
<< fc::BoxDrawingsVertical // │
@ -475,7 +475,7 @@ inline void drawNewFontBox (FWidget* w, const FRect& r)
<< FString{r.getWidth() - 2, fc::NF_border_line_horizontal} // ─
<< fc::NF_border_corner_middle_upper_right; // ┐
for (int y = r.getY1() + 1; y < r.getY2(); y++)
for (auto y = r.getY1() + 1; y < r.getY2(); y++)
{
w->print() << FPoint{r.getX1(), y}
<< fc::NF_border_line_vertical // │
@ -497,7 +497,7 @@ inline void drawNewFontListBox (FWidget* w, const FRect& r)
<< FString{r.getWidth() - 2, fc::NF_border_line_horizontal} // ─
<< fc::NF_border_line_left_down; // ╷
for (int y = r.getY1() + 1; y < r.getY2(); y++)
for (auto y = r.getY1() + 1; y < r.getY2(); y++)
{
w->print() << FPoint{r.getX1(), y}
<< fc::NF_border_line_left // border left ⎸

16
src/fwindow.cpp
View File

@ -247,7 +247,7 @@ void FWindow::drawBorder()
<< FString{r.getWidth() - 2, fc::NF_border_line_upper} // ¯
<< fc::NF_rev_border_corner_upper_right; // ⎤
for (int y = r.getY1() + 1; y < r.getY2(); y++)
for (auto y = r.getY1() + 1; y < r.getY2(); y++)
{
print() << FPoint{r.getX1(), y}
<< fc::NF_border_line_left // border left ⎸
@ -483,7 +483,7 @@ void FWindow::delWindow (const FWidget* obj)
}
//----------------------------------------------------------------------
FWindow* FWindow::getWindowWidget (const FWidget* obj)
FWindow* FWindow::getWindowWidget (FWidget* obj)
{
// returns the window object to the given widget obj
auto p_obj = obj->getParentWidget();
@ -495,22 +495,19 @@ FWindow* FWindow::getWindowWidget (const FWidget* obj)
}
if ( obj->isWindowWidget() )
return const_cast<FWindow*>(reinterpret_cast<const FWindow*>(obj));
return static_cast<FWindow*>(obj);
else
return nullptr;
}
//----------------------------------------------------------------------
int FWindow::getWindowLayer (const FWidget* obj)
int FWindow::getWindowLayer (FWidget* obj)
{
// returns the window layer from the widget obj
const FWidget* window;
if ( ! getWindowList() )
return -1;
if ( getWindowList()->empty() )
if ( ! getWindowList() || getWindowList()->empty() )
return -1;
if ( ! obj->isWindowWidget() )
@ -929,9 +926,6 @@ void closeDropDown (const FWidget* widget, const FPoint& mouse_position)
if ( FWidget::getStatusBar() )
FWidget::getStatusBar()->drawMessage();
widget->updateTerminal();
FVTerm::flush();
}
} // namespace finalcut

163
src/include/final/fapplication.h
View File

@ -80,6 +80,7 @@ class FEvent;
class FFocusEvent;
class FKeyEvent;
class FLog;
class FMouseData;
class FMouseEvent;
class FStartOptions;
class FTimerEvent;
@ -150,79 +151,6 @@ class FApplication : public FWidget
virtual void processExternalUserEvent();
private:
// Typedefs
typedef std::pair<FObject*, FEvent*> EventPair;
typedef std::deque<EventPair> FEventQueue;
typedef std::unordered_map<int, std::function<void(char*)>> CmdMap;
// Methods
void init();
static void setTerminalEncoding (const FString&);
static CmdMap& mapCmdOptions();
static void cmdOptions (const int&, char*[]);
static FStartOptions& getStartOptions();
static void showParameterUsage();
void destroyLog();
void findKeyboardWidget() const;
bool isKeyPressed() const;
void keyPressed();
void keyReleased() const;
void escapeKeyPressed() const;
void performKeyboardAction();
void sendEscapeKeyPressEvent() const;
bool sendKeyDownEvent (FWidget*) const;
bool sendKeyPressEvent (FWidget*) const;
bool sendKeyUpEvent (FWidget*) const;
void sendKeyboardAccelerator() const;
void processKeyboardEvent() const;
bool processDialogSwitchAccelerator() const;
bool processAccelerator (const FWidget* const&) const;
bool getMouseEvent() const;
FWidget*& determineClickedWidget();
void unsetMoveSizeMode() const;
void closeDropDown() const;
void unselectMenubarItems() const;
void sendMouseEvent() const;
void sendMouseMoveEvent ( const FPoint&
, const FPoint&
, int ) const;
void sendMouseLeftClickEvent ( const FPoint&
, const FPoint&
, int ) const;
void sendMouseRightClickEvent ( const FPoint&
, const FPoint&
, int ) const;
void sendMouseMiddleClickEvent ( const FPoint&
, const FPoint&
, int ) const;
void sendWheelEvent (const FPoint&, const FPoint&) const;
static FWidget* processParameters (const int&, char*[]);
void processMouseEvent();
void processResizeEvent() const;
void processCloseWidget();
void processLogger() const;
bool processNextEvent();
void performTimerAction (FObject*, FEvent*) override;
static bool isEventProcessable (const FObject*, const FEvent*);
static bool isNextEventTimeout();
// Data members
int app_argc{};
char** app_argv{};
uInt64 key_timeout{100000}; // 100 ms
uInt64 dblclick_interval{500000}; // 500 ms
std::streambuf* default_clog_rdbuf{std::clog.rdbuf()};
FEventQueue event_queue{};
static uInt64 next_event_wait;
static timeval time_last_event;
static int quit_code;
static bool quit_now;
static int loop_level;
static bool process_timer_event;
static FMouseControl* mouse;
static FKeyboard* keyboard;
static FWidget* keyboard_widget;
#if defined(__sun) && defined(__SVR4)
struct CmdOption
{
@ -235,9 +163,94 @@ class FApplication : public FWidget
using CmdOption = struct option;
#endif
static const std::vector<CmdOption> long_options;
};
// Typedefs
typedef std::pair<FObject*, FEvent*> EventPair;
typedef std::deque<EventPair> FEventQueue;
typedef std::unordered_map<int, std::function<void(char*)>> CmdMap;
// Methods
void init();
static void setTerminalEncoding (const FString&);
static void setLongOptions(std::vector<CmdOption>&);
static void setCmdOptionsMap (CmdMap&);
static void cmdOptions (const int&, char*[]);
static FStartOptions& getStartOptions();
static void showParameterUsage();
void destroyLog();
void findKeyboardWidget() const;
bool isKeyPressed() const;
void keyPressed();
void keyReleased() const;
void escapeKeyPressed() const;
void mouseTracking() const;
void performKeyboardAction();
void performMouseAction() const;
void mouseEvent (const FMouseData&);
void sendEscapeKeyPressEvent() const;
bool sendKeyDownEvent (FWidget*) const;
bool sendKeyPressEvent (FWidget*) const;
bool sendKeyUpEvent (FWidget*) const;
void sendKeyboardAccelerator();
bool hasDataInQueue() const;
void queuingKeyboardInput() const;
void queuingMouseInput() const;
void processKeyboardEvent() const;
void processMouseEvent() const;
bool processDialogSwitchAccelerator() const;
bool processAccelerator (const FWidget&) const;
void determineClickedWidget (const FMouseData&);
void unsetMoveSizeMode() const;
void closeDropDown (const FMouseData&) const;
void unselectMenubarItems (const FMouseData&) const;
void sendMouseEvent (const FMouseData&) const;
void sendMouseMoveEvent ( const FMouseData&
, const FPoint&
, const FPoint&
, int ) const;
void sendMouseLeftClickEvent ( const FMouseData&
, const FPoint&
, const FPoint&
, int ) const;
void sendMouseRightClickEvent ( const FMouseData&
, const FPoint&
, const FPoint&
, int ) const;
void sendMouseMiddleClickEvent ( const FMouseData&
, const FPoint&
, const FPoint&
, int ) const;
void sendWheelEvent ( const FMouseData&
, const FPoint&
, const FPoint& ) const;
void flushTerminal();
static FWidget* processParameters (const int&, char*[]);
void processResizeEvent() const;
void processCloseWidget();
void processLogger() const;
bool processNextEvent();
void performTimerAction (FObject*, FEvent*) override;
static bool isEventProcessable (FObject*, const FEvent*);
static bool isNextEventTimeout();
// Data members
int app_argc{};
char** app_argv{};
uInt64 key_timeout{100000}; // 100 ms
uInt64 dblclick_interval{500000}; // 500 ms
std::streambuf* default_clog_rdbuf{std::clog.rdbuf()};
FWidget* clicked_widget{};
FEventQueue event_queue{};
int flush_count{0};
static uInt64 next_event_wait;
static timeval time_last_event;
static int loop_level;
static int quit_code;
static bool quit_now;
static bool pending_updates;
static FMouseControl* mouse;
static FKeyboard* keyboard;
static FWidget* keyboard_widget;
};
// non-member function forward declarations
// implemented in fwidget_functions.cpp

2
src/include/final/fcombobox.h
View File

@ -216,7 +216,7 @@ class FComboBox : public FWidget
void draw() override;
void onePosUp();
void onePosDown();
void passEventToListWindow (FMouseEvent* const&);
void passEventToListWindow (const FMouseEvent&);
void processClick() const;
void processChanged() const;

6
src/include/final/fconfig.h
View File

@ -183,7 +183,7 @@
/* Define to the full name and version of this package. */
#ifndef F_PACKAGE_STRING
#define F_PACKAGE_STRING "finalcut 0.6.1"
#define F_PACKAGE_STRING "finalcut 0.7.0"
#endif
/* Define to the one symbol short name of this package. */
@ -198,7 +198,7 @@
/* Define to the version of this package. */
#ifndef F_PACKAGE_VERSION
#define F_PACKAGE_VERSION "0.6.1"
#define F_PACKAGE_VERSION "0.7.0"
#endif
/* Define to 1 if you have the ANSI C header files. */
@ -230,7 +230,7 @@
/* Version number of package */
#ifndef F_VERSION
#define F_VERSION "0.6.1"
#define F_VERSION "0.7.0"
#endif
/* Define to 1 if on MINIX. */

2
src/include/final/fdialog.h
View File

@ -195,7 +195,7 @@ class FDialog : public FWindow
void pressZoomButton (const MouseStates&);
bool isMouseOverMenu (const FPoint&) const;
void passEventToSubMenu ( const MouseStates&
, const FMouseEvent* );
, const FMouseEvent&& );
void moveSizeKey (FKeyEvent*);
void raiseActivateDialog();
void lowerActivateDialog();

43
src/include/final/fkeyboard.h
View File

@ -40,6 +40,7 @@
#include <array>
#include <functional>
#include <memory>
#include <queue>
#include "final/fkey_map.h"
#include "final/fstring.h"
@ -51,6 +52,7 @@ namespace finalcut
// class forward declaration
class FApplication;
class FString;
class FTermDetection;
class FTermLinux;
//----------------------------------------------------------------------
@ -117,6 +119,7 @@ class FKeyboard final
void setTermcapMap (const T&);
static void setKeypressTimeout (const uInt64);
static void setReadBlockingTime (const uInt64);
static void setNonBlockingInputSupport (bool);
bool setNonBlockingInput (bool);
bool setNonBlockingInput();
bool unsetNonBlockingInput();
@ -127,18 +130,21 @@ class FKeyboard final
void setPressCommand (const FKeyboardCommand&);
void setReleaseCommand (const FKeyboardCommand&);
void setEscPressedCommand (const FKeyboardCommand&);
void setMouseTrackingCommand (const FKeyboardCommand&);
// Inquiry
bool isInputDataPending() const;
bool hasPendingInput() const;
bool hasDataInQueue() const;
// Methods
static void init();
bool& unprocessedInput();
bool isKeyPressed() const;
bool& hasUnprocessedInput();
bool isKeyPressed (uInt64 = read_blocking_time);
void clearKeyBuffer();
void clearKeyBufferOnTimeout();
void fetchKeyCode();
void escapeKeyHandling();
void processQueuedInput();
private:
// Using-declaration
@ -146,6 +152,7 @@ class FKeyboard final
// Constants
static constexpr FKey NOT_SET = static_cast<FKey>(-1);
static constexpr std::size_t MAX_QUEUE_SIZE = 32;
// Accessors
FKey getMouseProtocolKey() const;
@ -167,30 +174,36 @@ class FKeyboard final
void keyPressed() const;
void keyReleased() const;
void escapeKeyPressed() const;
void mouseTracking() const;
// Data members
FKeyboardCommand keypressed_cmd{};
FKeyboardCommand keyreleased_cmd{};
FKeyboardCommand escape_key_cmd{};
FKeyboardCommand mouse_tracking_cmd{};
#if defined(__linux__)
#undef linux
static FTermLinux* linux;
#endif
FTermDetection* term_detection{nullptr};
static timeval time_keypressed;
static timeval time_last_request;
static uInt64 read_blocking_time;
static uInt64 read_blocking_time_short;
static uInt64 key_timeout;
static uInt64 interval_timeout;
static bool non_blocking_input_support;
FKeyMapPtr key_map{};
std::queue<FKey> fkey_queue{};
FKey fkey{0};
FKey key{0};
uChar read_character{};
char read_character{};
char fifo_buf[FIFO_BUF_SIZE]{'\0'};
int fifo_offset{0};
int stdin_status_flags{0};
bool has_pending_input{false};
bool fifo_in_use{false};
bool input_data_pending{false};
bool unprocessed_buffer_data{false};
bool utf8_input{false};
bool mouse_support{true};
bool non_blocking_stdin{false};
@ -234,6 +247,10 @@ inline void FKeyboard::setKeypressTimeout (const uInt64 timeout)
inline void FKeyboard::setReadBlockingTime (const uInt64 blocking_time)
{ read_blocking_time = blocking_time; }
//----------------------------------------------------------------------
inline void FKeyboard::setNonBlockingInputSupport (bool enable)
{ non_blocking_input_support = enable; }
//----------------------------------------------------------------------
inline bool FKeyboard::setNonBlockingInput()
{ return setNonBlockingInput(true); }
@ -243,8 +260,12 @@ inline bool FKeyboard::unsetNonBlockingInput()
{ return setNonBlockingInput(false); }
//----------------------------------------------------------------------
inline bool FKeyboard::isInputDataPending() const
{ return input_data_pending; }
inline bool FKeyboard::hasPendingInput() const
{ return has_pending_input; }
//----------------------------------------------------------------------
inline bool FKeyboard::hasDataInQueue() const
{ return ! fkey_queue.empty(); }
//----------------------------------------------------------------------
inline void FKeyboard::enableUTF8()
@ -274,6 +295,10 @@ inline void FKeyboard::setReleaseCommand (const FKeyboardCommand& cmd)
inline void FKeyboard::setEscPressedCommand (const FKeyboardCommand& cmd)
{ escape_key_cmd = cmd; }
//----------------------------------------------------------------------
inline void FKeyboard::setMouseTrackingCommand (const FKeyboardCommand& cmd)
{ mouse_tracking_cmd = cmd; }
} // namespace finalcut
#endif // FKEYBOARD_H

8
src/include/final/flistview.h
View File

@ -213,10 +213,10 @@ inline bool FListViewItem::isCheckable() const
class FListViewIterator
{
public:
// Typedefs
typedef std::list<FObject*> FObjectList;
typedef FObjectList::iterator iterator;
typedef std::stack<iterator> iterator_stack;
// Using-declarations
using FObjectList = std::list<FObject*>;
using iterator = FObjectList::iterator;
using iterator_stack = std::stack<iterator>;
// Constructor
FListViewIterator ();

2
src/include/final/flog.h
View File

@ -108,7 +108,7 @@ class FLog : public std::stringbuf
// Data member
LogLevel level{Info};
LineEnding end_of_line{CRLF};
std::mutex mut;
std::mutex mut{};
FLogPrint current_log{std::bind(&FLog::info, this, std::placeholders::_1)};
std::ostream stream{this};

6
src/include/final/fmenu.h
View File

@ -192,9 +192,9 @@ class FMenu : public FWindow, public FMenuList
void mouseMoveDeselection (FMenuItem*, MouseStates&);
void mouseUpOverBorder();
void mouseMoveOverBorder (MouseStates&) const;
void passEventToSubMenu (FMouseEvent* const&);
void passEventToSuperMenu (FMouseEvent* const&);
void passEventToMenuBar (FMouseEvent* const&) const;
void passEventToSubMenu (const FMouseEvent&&);
void passEventToSuperMenu (const FMouseEvent&&);
void passEventToMenuBar (const FMouseEvent&&) const;
bool containsMenuStructure (const FPoint&);
bool containsMenuStructure (int, int);
FMenu* superMenuAt (const FPoint&);

4
src/include/final/fmenubar.h
View File

@ -139,8 +139,8 @@ class FMenuBar : public FWindow, public FMenuList
void selectMenuItem (FMenuItem*);
void mouseDownOverList (const FMouseEvent*);
void mouseUpOverList (const FMouseEvent*);
void mouseMoveOverList (const FMouseEvent*);
void passEventToMenu (const FMouseEvent* const&) const;
void mouseMoveOverList (const FMouseEvent&&);
void passEventToMenu (const FMouseEvent&&) const;
void leaveMenuBar();
// Data members

185
src/include/final/fmouse.h
View File

@ -23,6 +23,11 @@
/* Inheritance diagram
* ═══════════════════
*
* ▕▔▔▔▔▔▔▔▔▔▔▔▔▔▔▏
* ▕ FMouseData ▏
* ▕▁▁▁▁▁▁▁▁▁▁▁▁▁▁▏
* ▲
* │
* ▕▔▔▔▔▔▔▔▔▔▔▏
* ▕ FMouse ▏
* ▕▁▁▁▁▁▁▁▁▁▁▏
@ -61,7 +66,9 @@
#endif
#include <cstddef>
#include <functional>
#include <map>
#include <queue>
#include "final/fkeyboard.h"
#include "final/fpoint.h"
@ -78,63 +85,47 @@ namespace finalcut
{
//----------------------------------------------------------------------
// class FMouse
// class FMouseData
//----------------------------------------------------------------------
class FMouse
class FMouseData
{
public:
// Enumeration
enum mouse_type
{
none = 0,
gpm = 1,
x11 = 2,
sgr = 3,
urxvt = 4
};
// Constructor
FMouse();
// Destructor
virtual ~FMouse()
{ }
// Accessors
virtual FString getClassName() const;
const FPoint& getPos() const;
void clearEvent();
// Mutators
void setMaxWidth (uInt16);
void setMaxHeight (uInt16);
void setDblclickInterval (const uInt64);
// Constructor
FMouseData();
// Default copy constructor
FMouseData (const FMouseData&) = default;
// Default move constructor
FMouseData (FMouseData&&) = default;
// Default copy assignment operator (=)
FMouseData& operator = (const FMouseData&) = default;
// Default move assignment operator (=)
FMouseData& operator = (FMouseData&&) = default;
// Destructor
virtual ~FMouseData();
// Inquiries
virtual bool hasData() = 0;
bool hasEvent() const;
bool isLeftButtonPressed();
bool isLeftButtonReleased();
bool isLeftButtonDoubleClick();
bool isRightButtonPressed();
bool isRightButtonReleased();
bool isMiddleButtonPressed();
bool isMiddleButtonReleased();
bool isShiftKeyPressed();
bool isControlKeyPressed();
bool isMetaKeyPressed();
bool isWheelUp();
bool isWheelDown();
bool isMoved();
bool isInputDataPending() const;
bool isLeftButtonPressed() const;
bool isLeftButtonReleased() const;
bool isLeftButtonDoubleClick() const;
bool isRightButtonPressed() const;
bool isRightButtonReleased() const;
bool isMiddleButtonPressed() const;
bool isMiddleButtonReleased() const;
bool isShiftKeyPressed() const;
bool isControlKeyPressed() const;
bool isMetaKeyPressed() const;
bool isWheelUp() const;
bool isWheelDown() const;
bool isMoved() const;
// Methods
template <typename ClassT>
static FMouse* createMouseObject ();
void clearButtonState();
virtual void setRawData (FKeyboard::keybuffer&) = 0;
virtual void processEvent (struct timeval*) = 0;
protected:
// Typedef and Enumerations
@ -162,6 +153,63 @@ class FMouse
// Accessors
FMouseButton& getButtonState();
const FMouseButton& getButtonState() const;
// Mutator
void setPos (const FPoint&);
private:
// Data members
FMouseButton b_state{};
FPoint mouse{0, 0}; // mouse click position
};
//----------------------------------------------------------------------
// class FMouse
//----------------------------------------------------------------------
class FMouse : public FMouseData
{
public:
// Enumeration
enum mouse_type
{
none = 0,
gpm = 1,
x11 = 2,
sgr = 3,
urxvt = 4
};
// Constructor
FMouse();
// Destructor
~FMouse() override;
// Accessors
FString getClassName() const override;
void clearEvent();
// Mutators
void setMaxWidth (uInt16);
void setMaxHeight (uInt16);
void setDblclickInterval (const uInt64);
// Inquiries
virtual bool hasData() = 0;
bool hasEvent() const;
bool hasUnprocessedInput() const;
// Methods
template <typename ClassT>
static FMouse* createMouseObject ();
virtual void setRawData (FKeyboard::keybuffer&) = 0;
virtual void processEvent (struct timeval*) = 0;
protected:
// Accessors
const FPoint& getNewPos() const;
uInt16 getMaxWidth() const;
uInt16 getMaxHeight() const;
@ -169,7 +217,6 @@ class FMouse
timeval* getMousePressedTime();
// Mutator
void setPos (const FPoint&);
void setNewPos (int, int);
void setPending (bool);
void setEvent();
@ -181,14 +228,12 @@ class FMouse
private:
// Data members
FMouseButton b_state{};
bool mouse_event_occurred{false};
bool input_data_pending{false};
bool unprocessed_buffer_data{false};
uInt16 max_width{80};
uInt16 max_height{25};
uInt64 dblclick_interval{500000}; // 500 ms
struct timeval time_mousepressed{};
FPoint mouse{0, 0}; // mouse click position
FPoint new_mouse_position{};
};
@ -446,6 +491,32 @@ class FMouseUrxvt final : public FMouse
};
//----------------------------------------------------------------------
// class FMouseCommand
//----------------------------------------------------------------------
class FMouseCommand final
{
public:
// Constructors
FMouseCommand () = default;
explicit FMouseCommand (const std::function<void(const FMouseData&)>& fn)
: handler(fn)
{ }
// Method
template <typename T>
void execute(T&& arg) const
{
handler(std::forward<T>(arg));
}
private:
// Data members
std::function<void(const FMouseData&)> handler{};
};
//----------------------------------------------------------------------
// class FMouseControl
//----------------------------------------------------------------------
@ -475,6 +546,7 @@ class FMouseControl
void setMaxWidth (uInt16);
void setMaxHeight (uInt16);
void setDblclickInterval (const uInt64);
void setEventCommand (const FMouseCommand&);
void useGpmMouse (bool = true);
void useXtermMouse (bool = true);
@ -494,7 +566,8 @@ class FMouseControl
bool isWheelUp();
bool isWheelDown();
bool isMoved();
bool isInputDataPending();
bool hasUnprocessedInput();
bool hasDataInQueue() const;
bool isGpmMouseEnabled();
// Methods
@ -503,12 +576,14 @@ class FMouseControl
virtual void setRawData ( FMouse::mouse_type
, FKeyboard::keybuffer& );
virtual void processEvent (struct timeval* time);
void processQueuedInput();
bool getGpmKeyPressed (bool);
void drawGpmPointer();
private:
// Typedef
typedef std::map<FMouse::mouse_type, FMouse*> FMouseProtocol;
typedef std::unique_ptr<FMouseData> FMouseDataPtr;
// Accessor
FMouse* getMouseWithData();
@ -519,6 +594,8 @@ class FMouseControl
// Data member
FMouseProtocol mouse_protocol{};
FMouseCommand event_cmd{};
std::queue<FMouseDataPtr> fmousedata_queue{};
FPoint zero_point{0, 0};
bool use_gpm_mouse{false};
bool use_xterm_mouse{false};
@ -529,6 +606,14 @@ class FMouseControl
inline FString FMouseControl::getClassName() const
{ return "FMouseControl"; }
//----------------------------------------------------------------------
inline void FMouseControl::setEventCommand (const FMouseCommand& cmd)
{ event_cmd = cmd; }
//----------------------------------------------------------------------
inline bool FMouseControl::hasDataInQueue() const
{ return ! fmousedata_queue.empty(); }
//----------------------------------------------------------------------
inline void FMouseControl::enableXTermMouse() const
{ xtermMouse(true); }

30
src/include/final/fobject.h
View File

@ -73,10 +73,12 @@ class FUserEvent;
class FObject
{
public:
// Typedef
typedef std::list<FObject*> FObjectList;
typedef FObjectList::iterator iterator;
typedef FObjectList::const_iterator const_iterator;
// Using-declarations
using FObjectList = std::list<FObject*>;
using iterator = FObjectList::iterator;
using const_iterator = FObjectList::const_iterator;
using reference = FObjectList::reference;
using const_reference = FObjectList::const_reference;
// Constants
static constexpr auto UNLIMITED = static_cast<std::size_t>(-1);
@ -105,6 +107,10 @@ class FObject
iterator end();
const_iterator begin() const;
const_iterator end() const;
reference front();
reference back();
const_reference front() const;
const_reference back() const;
// Mutator
void setMaxChildren (std::size_t);
@ -215,6 +221,22 @@ inline FObject::const_iterator FObject::begin() const
inline FObject::const_iterator FObject::end() const
{ return children_list.end(); }
//----------------------------------------------------------------------
inline FObject::reference FObject::front()
{ return children_list.front(); }
//----------------------------------------------------------------------
inline FObject::reference FObject::back()
{ return children_list.back(); }
//----------------------------------------------------------------------
inline FObject::const_reference FObject::front() const
{ return children_list.front(); }
//----------------------------------------------------------------------
inline FObject::const_reference FObject::back() const
{ return children_list.back(); }
//----------------------------------------------------------------------
inline void FObject::setMaxChildren (std::size_t max)
{ max_children = max; }

98
src/include/final/foptiattr.h
View File

@ -152,12 +152,12 @@ class FOptiAttr final
void set_orig_orig_colors (const char[]);
// Inquiry
static bool isNormal (const FChar* const&);
static bool isNormal (const FChar&);
// Methods
void initialize();
static FColor vga2ansi (FColor);
const char* changeAttribute (FChar*&, FChar*&);
const char* changeAttribute (FChar&, FChar&);
private:
// Typedefs and Enumerations
@ -202,62 +202,62 @@ class FOptiAttr final
};
// Mutators
bool setTermBold (FChar*&);
bool unsetTermBold (FChar*&);
bool setTermDim (FChar*&);
bool unsetTermDim (FChar*&);
bool setTermItalic (FChar*&);
bool unsetTermItalic (FChar*&);
bool setTermUnderline (FChar*&);
bool unsetTermUnderline (FChar*&);
bool setTermBlink (FChar*&);
bool unsetTermBlink (FChar*&);
bool setTermReverse (FChar*&);
bool unsetTermReverse (FChar*&);
bool setTermStandout (FChar*&);
bool unsetTermStandout (FChar*&);
bool setTermInvisible (FChar*&);
bool unsetTermInvisible (FChar*&);
bool setTermProtected (FChar*&);
bool unsetTermProtected (FChar*&);
bool setTermCrossedOut (FChar*&);
bool unsetTermCrossedOut (FChar*&);
bool setTermDoubleUnderline (FChar*&);
bool unsetTermDoubleUnderline (FChar*&);
bool setTermAttributes ( FChar*&
bool setTermBold (FChar&);
bool unsetTermBold (FChar&);
bool setTermDim (FChar&);
bool unsetTermDim (FChar&);
bool setTermItalic (FChar&);
bool unsetTermItalic (FChar&);
bool setTermUnderline (FChar&);
bool unsetTermUnderline (FChar&);
bool setTermBlink (FChar&);
bool unsetTermBlink (FChar&);
bool setTermReverse (FChar&);
bool unsetTermReverse (FChar&);
bool setTermStandout (FChar&);
bool unsetTermStandout (FChar&);
bool setTermInvisible (FChar&);
bool unsetTermInvisible (FChar&);
bool setTermProtected (FChar&);
bool unsetTermProtected (FChar&);
bool setTermCrossedOut (FChar&);
bool unsetTermCrossedOut (FChar&);
bool setTermDoubleUnderline (FChar&);
bool unsetTermDoubleUnderline (FChar&);
bool setTermAttributes ( FChar&
, bool, bool, bool
, bool, bool, bool
, bool, bool, bool );
bool unsetTermAttributes (FChar*&);
bool setTermAltCharset (FChar*&);
bool unsetTermAltCharset (FChar*&);
bool setTermPCcharset (FChar*&);
bool unsetTermPCcharset (FChar*&);
bool setTermDefaultColor (FChar*&);
void setAttributesOn (FChar*&);
void setAttributesOff (FChar*&);
bool unsetTermAttributes (FChar&);
bool setTermAltCharset (FChar&);
bool unsetTermAltCharset (FChar&);
bool setTermPCcharset (FChar&);
bool unsetTermPCcharset (FChar&);
bool setTermDefaultColor (FChar&);
void setAttributesOn (FChar&);
void setAttributesOff (FChar&);
// Inquiries
static bool hasColor (const FChar* const&);
static bool hasAttribute (const FChar* const&);
static bool hasNoAttribute (const FChar* const&);
static bool hasColor (const FChar&);
static bool hasAttribute (const FChar&);
static bool hasNoAttribute (const FChar&);
// Methods
bool hasColorChanged (const FChar* const&, const FChar* const&) const;
void resetColor (FChar*&) const;
void prevent_no_color_video_attributes (FChar*&, bool = false);
void deactivateAttributes (FChar*&, FChar*&);
void changeAttributeSGR (FChar*&, FChar*&);
void changeAttributeSeparately (FChar*&, FChar*&);
void change_color (FChar*&, FChar*&);
void change_to_default_color (FChar*&, FChar*&, FColor&, FColor&);
void change_current_color (const FChar* const&, FColor, FColor);
void resetAttribute (FChar*&) const;
void reset (FChar*&) const;
bool hasColorChanged (const FChar&, const FChar&) const;
void resetColor (FChar&) const;
void prevent_no_color_video_attributes (FChar&, bool = false);
void deactivateAttributes (FChar&, FChar&);
void changeAttributeSGR (FChar&, FChar&);
void changeAttributeSeparately (FChar&, FChar&);
void change_color (FChar&, FChar&);
void change_to_default_color (FChar&, FChar&, FColor&, FColor&);
void change_current_color (const FChar&, FColor, FColor);
void resetAttribute (FChar&) const;
void reset (FChar&) const;
bool caused_reset_attributes (const char[], uChar = all_tests) const;
bool hasCharsetEquivalence() const;
void detectSwitchOn (const FChar* const&, const FChar* const&);
void detectSwitchOff (const FChar* const&, const FChar* const&);
void detectSwitchOn (const FChar&, const FChar&);
void detectSwitchOff (const FChar&, const FChar&);
bool switchOn() const;
bool switchOff() const;
bool append_sequence (const char[]);

4
src/include/final/fscrollview.h
View File

@ -157,7 +157,7 @@ class FScrollView : public FWidget
static constexpr int horizontal_border_spacing = 2;
// Accessors
FPoint getViewportCursorPos() const;
FPoint getViewportCursorPos();
// Methods
void init();
@ -169,7 +169,7 @@ class FScrollView : public FWidget
, Callback );
void setHorizontalScrollBarVisibility() const;
void setVerticalScrollBarVisibility() const;
void setViewportCursor() const;
void setViewportCursor();
// Callback methods
void cb_vbarChange (const FWidget*);

68
src/include/final/fstring.h
View File

@ -79,9 +79,11 @@ typedef std::vector<FString> FStringList;
class FString
{
public:
// Typedef
typedef const wchar_t* const_iterator;
typedef wchar_t* iterator;
// Using-declarations
using iterator = wchar_t*;
using const_iterator = const wchar_t*;
using reference = wchar_t&;
using const_reference = const wchar_t&;
// Constructors
FString () = default;
@ -112,8 +114,11 @@ class FString
FString& operator << (const wchar_t);
FString& operator << (const char);
template <typename NumT
, typename std::enable_if< std::is_integral<NumT>::value
|| std::is_floating_point<NumT>::value
, typename std::enable_if< ( std::is_integral<NumT>::value
&& ! std::is_same<NumT, bool>::value
&& ! std::is_pointer<NumT>::value )
|| ( std::is_floating_point<NumT>::value
&& ! std::is_pointer<NumT>::value )
, int>::type = 0 >
FString& operator << (const NumT);
@ -132,9 +137,9 @@ class FString
const FString& operator >> (float&) const;
template <typename IndexT>
wchar_t& operator [] (const IndexT);
reference operator [] (const IndexT);
template <typename IndexT>
const wchar_t& operator [] (const IndexT) const;
const_reference operator [] (const IndexT) const;
explicit operator bool () const;
const FString& operator () () const;
@ -157,8 +162,6 @@ class FString
template <typename CharT>
bool operator > (const CharT&) const;
operator const char* () const { return c_str(); }
// Accessor
virtual FString getClassName() const;
@ -175,8 +178,10 @@ class FString
iterator end();
const_iterator begin() const;
const_iterator end() const;
wchar_t front() const;
wchar_t back() const;
reference front();
reference back() ;
const_reference front() const;
const_reference back() const;
template <typename... Args>
FString& sprintf (const FString&, Args&&...);
@ -263,14 +268,6 @@ class FString
// Friend Non-member operator functions
friend FString operator + (const FString&, const FString&);
friend FString operator + (const FString&, const wchar_t);
friend FString operator + (const std::wstring&, const FString&);
friend FString operator + (const wchar_t[], const FString&);
friend FString operator + (const std::string&, const FString&);
friend FString operator + (const char[], const FString&);
friend FString operator + (const wchar_t, const FString&);
friend FString operator + (const char, const FString&);
friend FString operator + (const FString&, const char);
friend std::ostream& operator << (std::ostream&, const FString&);
friend std::istream& operator >> (std::istream&, FString& s);
@ -282,8 +279,11 @@ class FString
// FString inline functions
//----------------------------------------------------------------------
template <typename NumT
, typename std::enable_if< std::is_integral<NumT>::value
|| std::is_floating_point<NumT>::value
, typename std::enable_if< ( std::is_integral<NumT>::value
&& ! std::is_same<NumT, bool>::value
&& ! std::is_pointer<NumT>::value )
|| ( std::is_floating_point<NumT>::value
&& ! std::is_pointer<NumT>::value )
, int>::type >
inline FString& FString::operator << (const NumT val)
{
@ -294,7 +294,7 @@ inline FString& FString::operator << (const NumT val)
//----------------------------------------------------------------------
template <typename IndexT>
inline wchar_t& FString::operator [] (const IndexT pos)
inline FString::reference FString::operator [] (const IndexT pos)
{
if ( isNegative(pos) || pos > IndexT(length) )
throw std::out_of_range(""); // Invalid index position
@ -307,7 +307,7 @@ inline wchar_t& FString::operator [] (const IndexT pos)
//----------------------------------------------------------------------
template <typename IndexT>
inline const wchar_t& FString::operator [] (const IndexT pos) const
inline FString::const_reference FString::operator [] (const IndexT pos) const
{
if ( isNegative(pos) || pos > IndexT(length) )
throw std::out_of_range(""); // Invalid index position
@ -403,17 +403,31 @@ inline FString::const_iterator FString::end() const
{ return string + length; }
//----------------------------------------------------------------------
inline wchar_t FString::front() const
inline FString::reference FString::front()
{
assert ( ! isEmpty() );
return string[0];
return (*this)[0];
}
//----------------------------------------------------------------------
inline wchar_t FString::back() const
inline FString::reference FString::back()
{
assert( ! isEmpty() );
return string[length - 1];
return (*this)[length - 1];
}
//----------------------------------------------------------------------
inline FString::const_reference FString::front() const
{
assert ( ! isEmpty() );
return (*this)[0];
}
//----------------------------------------------------------------------
inline FString::const_reference FString::back() const
{
assert( ! isEmpty() );
return (*this)[length - 1];
}
//----------------------------------------------------------------------

8
src/include/final/fstringstream.h
View File

@ -83,7 +83,7 @@ class FStringStream : public std::wiostream
virtual FString getClassName() const;
void swap (FStringStream&) noexcept;
void clear();
std::wstringbuf* rdbuf() const;
std::wstringbuf* rdbuf();
FString str() const;
private:
@ -101,12 +101,12 @@ inline void FStringStream::clear()
{ buffer.str(L""); }
//----------------------------------------------------------------------
inline std::wstringbuf* FStringStream::rdbuf() const
{ return const_cast<std::wstringbuf*>(&buffer); }
inline std::wstringbuf* FStringStream::rdbuf()
{ return &buffer; }
//----------------------------------------------------------------------
inline FString FStringStream::str() const
{ return buffer.str(); }
{ return FString{buffer.str()}; }
// FStringStream non-member function

4
src/include/final/fterm.h
View File

@ -216,7 +216,7 @@ class FTerm final
#endif
// Inquiries
static bool isNormal (const FChar* const&);
static bool isNormal (const FChar&);
static bool isRaw();
static bool hasUTF8();
static bool hasVT100();
@ -304,7 +304,7 @@ class FTerm final
void initTerminal();
static void initScreenSettings();
static const char* changeAttribute (FChar*&, FChar*&);
static const char* changeAttribute (FChar&, FChar&);
static void changeTermSizeFinished();
private:

28
src/include/final/ftermbuffer.h
View File

@ -56,10 +56,12 @@ class FColorPair;
class FTermBuffer
{
public:
// Typedef
typedef std::vector<FChar> FCharVector;
typedef FCharVector::iterator iterator;
typedef FCharVector::const_iterator const_iterator;
// Using-declarations
using FCharVector = std::vector<FChar>;
using iterator = FCharVector::iterator;
using const_iterator = FCharVector::const_iterator;
using reference = FCharVector::reference;
using const_reference = FCharVector::const_reference;
// Constructor
FTermBuffer() = default;
@ -91,8 +93,10 @@ class FTermBuffer
iterator end();
const_iterator begin() const;
const_iterator end() const;
FChar front() const;
FChar back() const;
reference front();
reference back();
const_reference front() const;
const_reference back() const;
FString toString() const;
void clear();
template <typename... Args>
@ -201,11 +205,19 @@ inline FTermBuffer::const_iterator FTermBuffer::end() const
{ return data.end(); }
//----------------------------------------------------------------------
inline FChar FTermBuffer::front() const
inline FTermBuffer::reference FTermBuffer::front()
{ return data.front(); }
//----------------------------------------------------------------------
inline FChar FTermBuffer::back() const
inline FTermBuffer::reference FTermBuffer::back()
{ return data.back(); }
//----------------------------------------------------------------------
inline FTermBuffer::const_reference FTermBuffer::front() const
{ return data.front(); }
//----------------------------------------------------------------------
inline FTermBuffer::const_reference FTermBuffer::back() const
{ return data.back(); }
//----------------------------------------------------------------------

1
src/include/final/ftermcap.h
View File

@ -137,7 +137,6 @@ class FTermcap final
// Constant
static constexpr std::size_t BUF_SIZE{2048};
// Methods
static void termcap();
static void termcapError (int);

89
src/include/final/fvterm.h
View File

@ -50,7 +50,6 @@
#include <sys/time.h> // need for timeval (cygwin)
#include <queue>
#include <string>
#include <utility>
#include <vector>
@ -255,7 +254,7 @@ class FVTerm
void createVTerm (const FSize&);
void resizeVTerm (const FSize&) const;
void putVTerm() const;
void updateTerminal() const;
bool updateTerminal() const;
virtual void addPreprocessingHandler ( const FVTerm*
, const FPreprocessingFunction& );
virtual void delPreprocessingHandler (const FVTerm*);
@ -318,9 +317,9 @@ class FVTerm
void scrollAreaForward (FTermArea*) const;
void scrollAreaReverse (FTermArea*) const;
void clearArea (FTermArea*, int = ' ') const;
void processTerminalUpdate() const;
static void startTerminalUpdate();
static void finishTerminalUpdate();
bool processTerminalUpdate() const;
static void startDrawing();
static void finishDrawing();
virtual void initTerminal();
private:
@ -340,7 +339,8 @@ class FVTerm
// Constants
// Buffer size for character output on the terminal
static constexpr uInt TERMINAL_OUTPUT_BUFFER_SIZE = 32768;
static constexpr uInt TERMINAL_OUTPUT_BUFFER_SIZE = 131072;
static constexpr int max_skip = 20;
// Methods
void resetTextAreaToDefault ( const FTermArea*
@ -351,20 +351,11 @@ class FVTerm
static bool reallocateTextArea ( FTermArea*
, std::size_t );
static covered_state isCovered (const FPoint&, const FTermArea*);
static void updateOverlappedColor ( const FTermArea*
, const FPoint&
, const FPoint& );
static void updateOverlappedCharacter ( const FTermArea*
, const FPoint& );
static void updateShadedCharacter ( const FTermArea*
, const FPoint&
, const FPoint& );
static void updateInheritBackground ( const FTermArea*
, const FPoint&
, const FPoint& );
static void updateCharacter ( const FTermArea*
, const FPoint&
, const FPoint& );
static void updateOverlappedColor (const FChar&, const FChar&, FChar&);
static void updateOverlappedCharacter (FChar&, FChar&);
static void updateShadedCharacter (const FChar&, FChar&, FChar&);
static void updateInheritBackground (const FChar&, const FChar&, FChar&);
static void updateCharacter (const FChar&, FChar&);
static bool updateVTermCharacter ( const FTermArea*
, const FPoint&
, const FPoint& );
@ -376,15 +367,15 @@ class FVTerm
static FChar generateCharacter (const FPoint&);
static FChar getCharacter ( character_type
, const FPoint&
, FVTerm* );
static FChar getCoveredCharacter (const FPoint&, FVTerm*);
static FChar getOverlappedCharacter (const FPoint&, FVTerm*);
, const FTermArea* );
static FChar getCoveredCharacter (const FPoint&, const FTermArea*);
static FChar getOverlappedCharacter (const FPoint&, const FTermArea*);
void init();
static void init_characterLengths (const FOptiMove*);
void finish();
static void putAreaLine (const FChar*, FChar*, int);
static void putAreaCharacter ( const FPoint&, FVTerm*
, const FChar*, FChar* );
static void putAreaLine (const FChar&, FChar&, std::size_t);
static void putAreaCharacter ( const FPoint&, const FTermArea*
, const FChar&, FChar& );
static void getAreaCharacter ( const FPoint&, const FTermArea*
, FChar*& );
bool clearTerm (int = ' ') const;
@ -395,47 +386,52 @@ class FVTerm
static bool canClearTrailingWS (uInt&, uInt);
bool skipUnchangedCharacters (uInt&, uInt, uInt) const;
void printRange (uInt, uInt, uInt, bool) const;
void replaceNonPrintableFullwidth (uInt, FChar*&) const;
void printCharacter (uInt&, uInt, bool, FChar*&) const;
void printFullWidthCharacter (uInt&, uInt, FChar*&) const;
void printFullWidthPaddingCharacter (uInt&, uInt, FChar*&) const;
void printHalfCovertFullWidthCharacter (uInt&, uInt, FChar*&) const;
void skipPaddingCharacter (uInt&, uInt, const FChar* const&) const;
void replaceNonPrintableFullwidth (uInt, FChar&) const;
void printCharacter (uInt&, uInt, bool, FChar&) const;
void printFullWidthCharacter (uInt&, uInt, FChar&) const;
void printFullWidthPaddingCharacter (uInt&, uInt, FChar&) const;
void printHalfCovertFullWidthCharacter (uInt&, uInt, FChar&) const;
void skipPaddingCharacter (uInt&, uInt, const FChar&) const;
exit_state eraseCharacters (uInt&, uInt, uInt, bool) const;
exit_state repeatCharacter (uInt&, uInt, uInt) const;
bool isFullWidthChar (const FChar* const&) const;
bool isFullWidthPaddingChar (const FChar* const&) const;
bool isFullWidthChar (const FChar&) const;
bool isFullWidthPaddingChar (const FChar&) const;
static void cursorWrap();
bool printWrap (FTermArea*) const;
void printCharacterOnCoordinate ( FTermArea*
, const int&
, const int&
, const FChar&) const;
void printPaddingCharacter (FTermArea*, const FChar&);
void updateTerminalLine (uInt) const;
bool updateTerminalLine (uInt) const;
bool updateTerminalCursor() const;
bool isInsideTerminal (const FPoint&) const;
bool isTermSizeChanged() const;
static bool isTermSizeCheckTimeout();
static bool hasPendingUpdates (const FTermArea*);
static void markAsPrinted (uInt, uInt);
static void markAsPrinted (uInt, uInt, uInt);
static void newFontChanges (FChar*&);
static void charsetChanges (FChar*&);
void appendCharacter (FChar*&) const;
void appendChar (FChar*&) const;
void appendAttributes (FChar*&) const;
int appendLowerRight (FChar*&) const;
static void characterFilter (FChar*&);
static void newFontChanges (FChar&);
static void charsetChanges (FChar&);
void appendCharacter (FChar&) const;
void appendChar (FChar&) const;
void appendAttributes (FChar&) const;
void appendLowerRight (FChar&) const;
static void characterFilter (FChar&);
static void appendOutputBuffer (const std::string&);
static void appendOutputBuffer (const char[]);
static int appendOutputBuffer (int);
// Data members
FTermArea* print_area{nullptr}; // print area for this object
FTermArea* child_print_area{nullptr}; // print area for children
FTermArea* vwin{nullptr}; // virtual window
static const FVTerm* init_object; // Global FVTerm object
static FSystem* fsystem;
static FTerm* fterm;
static FTermArea* vterm; // virtual terminal
static FTermArea* vdesktop; // virtual desktop
static FTermArea* active_area; // active area
static std::queue<int>* output_buffer;
static std::vector<int>* output_buffer;
static FChar term_attribute;
static FChar next_attribute;
static FChar s_ch; // shadow character
@ -443,9 +439,7 @@ class FVTerm
static FPoint* term_pos; // terminal cursor position
static FKeyboard* keyboard;
static timeval last_term_size_check;
static bool terminal_update_complete;
static bool terminal_update_pending;
static bool force_terminal_update;
static bool draw_completed;
static bool no_terminal_updates;
static uInt64 term_size_check_timeout;
static int skipped_terminal_update;
@ -992,6 +986,7 @@ inline bool FVTerm::isCursorHideable() const
inline void FVTerm::hideVTermCursor() const
{ vterm->input_cursor_visible = false; }
} // namespace finalcut
#endif // FVTERM_H

4
src/include/final/fwidget.h
View File

@ -184,7 +184,7 @@ class FWidget : public FVTerm, public FObject
// Accessors
FString getClassName() const override;
FWidget* getRootWidget() const;
FWidget* getRootWidget();
FWidget* getParentWidget() const;
static FWidget*& getMainWidget();
static FWidget*& getActiveWindow();
@ -364,7 +364,7 @@ class FWidget : public FVTerm, public FObject
void initTerminal() override;
void initDesktop();
virtual void adjustSize();
void adjustSizeGlobal() const;
void adjustSizeGlobal();
void hideArea (const FSize&);
virtual bool focusNextChild(); // Change child...
virtual bool focusPrevChild(); // ...focus

4
src/include/final/fwindow.h
View File

@ -84,8 +84,8 @@ class FWindow : public FWidget
// Accessors
FString getClassName() const override;
static FWindow* getWindowWidget (const FWidget*);
static int getWindowLayer (const FWidget*);
static FWindow* getWindowWidget (FWidget*);
static int getWindowLayer (FWidget*);
FWidget* getWindowFocusWidget() const;
// Mutators

37
test/fkeyboard-test.cpp
View File

@ -49,6 +49,24 @@ void check_c_string ( const char* s1
::CppUnit::Asserter::fail ("Strings are not equal", sourceLine);
}
namespace finalcut
{
namespace internal
{
struct var
{
// Global application object is need for FApplication::isQuit()
static FApplication* app_object;
};
FApplication* var::app_object {nullptr};
} // namespace internal
} // namespace finalcut
namespace test
{
@ -311,6 +329,7 @@ class FKeyboardTest : public CPPUNIT_NS::TestFixture
void keyPressed();
void keyReleased();
void escapeKeyPressed();
void mouseTracking();
// Data members
FKey key_pressed{0};
@ -359,8 +378,7 @@ void FKeyboardTest::noArgumentTest()
CPPUNIT_ASSERT ( time->tv_sec == 0);
CPPUNIT_ASSERT ( time->tv_usec == 0);
CPPUNIT_ASSERT ( ! keyboard->isInputDataPending() );
CPPUNIT_ASSERT ( ! keyboard->unprocessedInput() );
CPPUNIT_ASSERT ( ! keyboard->hasUnprocessedInput() );
CPPUNIT_ASSERT ( ! keyboard->isKeyPressed() );
keyboard->clearKeyBufferOnTimeout();
@ -2153,6 +2171,7 @@ void FKeyboardTest::metaKeyTest()
const struct timespec ms[]{{0, 100000000L}};
nanosleep (ms, NULL);
keyboard->escapeKeyHandling();
keyboard->processQueuedInput();
std::cout << " - Key: " << keyboard->getKeyName(key_pressed) << std::endl;
CPPUNIT_ASSERT ( key_pressed == finalcut::fc::Fmkey_O );
clear();
@ -2240,6 +2259,7 @@ void FKeyboardTest::metaKeyTest()
// Wait 100 ms - Substring keys needs a timeout
nanosleep (ms, NULL);
keyboard->escapeKeyHandling();
keyboard->processQueuedInput();
std::cout << " - Key: " << keyboard->getKeyName(key_pressed) << std::endl;
CPPUNIT_ASSERT ( key_pressed == finalcut::fc::Fmkey_left_square_bracket );
clear();
@ -2257,6 +2277,7 @@ void FKeyboardTest::metaKeyTest()
// Wait 100 ms - Substring keys needs a timeout
nanosleep (ms, NULL);
keyboard->escapeKeyHandling();
keyboard->processQueuedInput();
std::cout << " - Key: " << keyboard->getKeyName(key_pressed) << std::endl;
CPPUNIT_ASSERT ( key_pressed == finalcut::fc::Fmkey_right_square_bracket );
clear();
@ -2955,16 +2976,21 @@ void FKeyboardTest::unknownKeyTest()
//----------------------------------------------------------------------
void FKeyboardTest::init()
{
finalcut::internal::var::app_object \
= reinterpret_cast<finalcut::FApplication*>(this); // Need for isQuit()
keyboard = new finalcut::FKeyboard();
auto cmd1 = std::bind(&FKeyboardTest::keyPressed, this);
auto cmd2 = std::bind(&FKeyboardTest::keyReleased, this);
auto cmd3 = std::bind(&FKeyboardTest::escapeKeyPressed, this);
auto cmd4 = std::bind(&FKeyboardTest::mouseTracking, this);
finalcut::FKeyboardCommand key_cmd1 (cmd1);
finalcut::FKeyboardCommand key_cmd2 (cmd2);
finalcut::FKeyboardCommand key_cmd3 (cmd3);
finalcut::FKeyboardCommand key_cmd4 (cmd4);
keyboard->setPressCommand (key_cmd1);
keyboard->setReleaseCommand (key_cmd2);
keyboard->setEscPressedCommand (key_cmd3);
keyboard->setMouseTrackingCommand (key_cmd4);
keyboard->setKeypressTimeout (100000); // 100 ms
processInput();
CPPUNIT_ASSERT ( key_pressed == 0 );
@ -3009,6 +3035,7 @@ void FKeyboardTest::processInput()
if ( keyboard->isKeyPressed() )
keyboard->fetchKeyCode();
keyboard->processQueuedInput();
// Keyboard interval timeout 75 ms (= 75,000,000 ns)
const struct timespec ms[]{{0, 75000000L}};
nanosleep (ms, NULL);
@ -3044,6 +3071,12 @@ void FKeyboardTest::escapeKeyPressed()
number_of_keys++;
}
//----------------------------------------------------------------------
void FKeyboardTest::mouseTracking()
{
key_pressed = keyboard->getKey();
}
// Put the test suite in the registry
CPPUNIT_TEST_SUITE_REGISTRATION (FKeyboardTest);

98
test/fmouse-test.cpp
View File

@ -172,7 +172,7 @@ void FMouseTest::noArgumentTest()
CPPUNIT_ASSERT ( ! mouse.isWheelUp() );
CPPUNIT_ASSERT ( ! mouse.isWheelDown() );
CPPUNIT_ASSERT ( ! mouse.isMoved() );
CPPUNIT_ASSERT ( ! mouse.isInputDataPending() );
CPPUNIT_ASSERT ( ! mouse.hasUnprocessedInput() );
#ifdef F_HAVE_LIBGPM
finalcut::FMouseGPM gpm_mouse;
@ -263,7 +263,7 @@ void FMouseTest::x11MouseTest()
{ 0x1b, '[', 'M', 0x23, 0x50, 0x32, 0x40, 0x40 };
x11_mouse.setRawData (rawdata1);
CPPUNIT_ASSERT ( x11_mouse.hasData() );
CPPUNIT_ASSERT ( x11_mouse.isInputDataPending() );
CPPUNIT_ASSERT ( x11_mouse.hasUnprocessedInput() );
CPPUNIT_ASSERT ( std::strcmp(rawdata1, "@@") == 0 );
timeval tv;
@ -298,7 +298,7 @@ void FMouseTest::x11MouseTest()
{ 0x1b, '[', 'M', 0x20, 0x21, 0x21 };
x11_mouse.setRawData (rawdata2);
CPPUNIT_ASSERT ( x11_mouse.hasData() );
CPPUNIT_ASSERT ( ! x11_mouse.isInputDataPending() );
CPPUNIT_ASSERT ( ! x11_mouse.hasUnprocessedInput() );
x11_mouse.processEvent (&tv);
CPPUNIT_ASSERT ( ! x11_mouse.hasData() );
CPPUNIT_ASSERT ( x11_mouse.getPos() == finalcut::FPoint(1, 1) );
@ -323,7 +323,7 @@ void FMouseTest::x11MouseTest()
x11_mouse.setRawData (rawdata3);
CPPUNIT_ASSERT ( x11_mouse.hasData() );
CPPUNIT_ASSERT ( ! x11_mouse.isInputDataPending() );
CPPUNIT_ASSERT ( ! x11_mouse.hasUnprocessedInput() );
x11_mouse.processEvent (&tv);
CPPUNIT_ASSERT ( ! x11_mouse.hasData() );
CPPUNIT_ASSERT ( x11_mouse.getPos() == finalcut::FPoint(1, 1) );
@ -348,7 +348,7 @@ void FMouseTest::x11MouseTest()
x11_mouse.setRawData (rawdata4);
CPPUNIT_ASSERT ( x11_mouse.hasData() );
CPPUNIT_ASSERT ( ! x11_mouse.isInputDataPending() );
CPPUNIT_ASSERT ( ! x11_mouse.hasUnprocessedInput() );
finalcut::FObject::getCurrentTime(&tv);
x11_mouse.processEvent (&tv);
CPPUNIT_ASSERT ( ! x11_mouse.hasData() );
@ -376,7 +376,7 @@ void FMouseTest::x11MouseTest()
x11_mouse.setRawData (rawdata5);
CPPUNIT_ASSERT ( x11_mouse.hasData() );
CPPUNIT_ASSERT ( x11_mouse.isInputDataPending() );
CPPUNIT_ASSERT ( x11_mouse.hasUnprocessedInput() );
finalcut::FObject::getCurrentTime(&tv);
x11_mouse.processEvent (&tv);
CPPUNIT_ASSERT ( ! x11_mouse.hasData() );
@ -398,7 +398,7 @@ void FMouseTest::x11MouseTest()
x11_mouse.setRawData (rawdata5);
x11_mouse.processEvent (&tv);
CPPUNIT_ASSERT ( ! x11_mouse.isInputDataPending() );
CPPUNIT_ASSERT ( ! x11_mouse.hasUnprocessedInput() );
CPPUNIT_ASSERT ( ! x11_mouse.isMiddleButtonPressed() );
CPPUNIT_ASSERT ( x11_mouse.isMiddleButtonReleased() );
@ -409,7 +409,7 @@ void FMouseTest::x11MouseTest()
x11_mouse.setRawData (rawdata6);
CPPUNIT_ASSERT ( x11_mouse.hasData() );
CPPUNIT_ASSERT ( x11_mouse.isInputDataPending() );
CPPUNIT_ASSERT ( x11_mouse.hasUnprocessedInput() );
finalcut::FObject::getCurrentTime(&tv);
x11_mouse.processEvent (&tv);
CPPUNIT_ASSERT ( ! x11_mouse.hasData() );
@ -431,7 +431,7 @@ void FMouseTest::x11MouseTest()
x11_mouse.setRawData (rawdata6);
x11_mouse.processEvent (&tv);
CPPUNIT_ASSERT ( ! x11_mouse.isInputDataPending() );
CPPUNIT_ASSERT ( ! x11_mouse.hasUnprocessedInput() );
CPPUNIT_ASSERT ( ! x11_mouse.isRightButtonPressed() );
CPPUNIT_ASSERT ( x11_mouse.isRightButtonReleased() );
@ -442,7 +442,7 @@ void FMouseTest::x11MouseTest()
x11_mouse.setRawData (rawdata7);
CPPUNIT_ASSERT ( x11_mouse.hasData() );
CPPUNIT_ASSERT ( x11_mouse.isInputDataPending() );
CPPUNIT_ASSERT ( x11_mouse.hasUnprocessedInput() );
finalcut::FObject::getCurrentTime(&tv);
x11_mouse.processEvent (&tv);
CPPUNIT_ASSERT ( ! x11_mouse.hasData() );
@ -464,7 +464,7 @@ void FMouseTest::x11MouseTest()
x11_mouse.setRawData (rawdata7);
x11_mouse.processEvent (&tv);
CPPUNIT_ASSERT ( ! x11_mouse.isInputDataPending() );
CPPUNIT_ASSERT ( ! x11_mouse.hasUnprocessedInput() );
CPPUNIT_ASSERT ( x11_mouse.isWheelDown() );
// Mouse move
@ -475,7 +475,7 @@ void FMouseTest::x11MouseTest()
x11_mouse.setRawData (rawdata8);
CPPUNIT_ASSERT ( x11_mouse.hasData() );
CPPUNIT_ASSERT ( x11_mouse.isInputDataPending() );
CPPUNIT_ASSERT ( x11_mouse.hasUnprocessedInput() );
finalcut::FObject::getCurrentTime(&tv);
x11_mouse.processEvent (&tv);
CPPUNIT_ASSERT ( ! x11_mouse.hasData() );
@ -514,7 +514,7 @@ void FMouseTest::x11MouseTest()
x11_mouse.setRawData (rawdata9);
CPPUNIT_ASSERT ( x11_mouse.hasData() );
CPPUNIT_ASSERT ( x11_mouse.isInputDataPending() );
CPPUNIT_ASSERT ( x11_mouse.hasUnprocessedInput() );
finalcut::FObject::getCurrentTime(&tv);
x11_mouse.processEvent (&tv);
CPPUNIT_ASSERT ( ! x11_mouse.hasData() );
@ -578,7 +578,7 @@ void FMouseTest::sgrMouseTest()
, '3', ';', '4', 'M', '@', '@' };
sgr_mouse.setRawData (rawdata1);
CPPUNIT_ASSERT ( sgr_mouse.hasData() );
CPPUNIT_ASSERT ( sgr_mouse.isInputDataPending() );
CPPUNIT_ASSERT ( sgr_mouse.hasUnprocessedInput() );
CPPUNIT_ASSERT ( std::strcmp(rawdata1, "@@") == 0 );
timeval tv;
@ -614,7 +614,7 @@ void FMouseTest::sgrMouseTest()
sgr_mouse.setRawData (rawdata2);
CPPUNIT_ASSERT ( sgr_mouse.hasData() );
CPPUNIT_ASSERT ( ! sgr_mouse.isInputDataPending() );
CPPUNIT_ASSERT ( ! sgr_mouse.hasUnprocessedInput() );
sgr_mouse.processEvent (&tv);
CPPUNIT_ASSERT ( ! sgr_mouse.hasData() );
CPPUNIT_ASSERT ( sgr_mouse.getPos() == finalcut::FPoint(73, 4) );
@ -639,7 +639,7 @@ void FMouseTest::sgrMouseTest()
sgr_mouse.setRawData (rawdata4);
CPPUNIT_ASSERT ( sgr_mouse.hasData() );
CPPUNIT_ASSERT ( ! sgr_mouse.isInputDataPending() );
CPPUNIT_ASSERT ( ! sgr_mouse.hasUnprocessedInput() );
finalcut::FObject::getCurrentTime(&tv);
sgr_mouse.processEvent (&tv);
CPPUNIT_ASSERT ( ! sgr_mouse.hasData() );
@ -666,7 +666,7 @@ void FMouseTest::sgrMouseTest()
sgr_mouse.setRawData (rawdata5);
CPPUNIT_ASSERT ( sgr_mouse.hasData() );
CPPUNIT_ASSERT ( sgr_mouse.isInputDataPending() );
CPPUNIT_ASSERT ( sgr_mouse.hasUnprocessedInput() );
finalcut::FObject::getCurrentTime(&tv);
sgr_mouse.processEvent (&tv);
CPPUNIT_ASSERT ( ! sgr_mouse.hasData() );
@ -688,7 +688,7 @@ void FMouseTest::sgrMouseTest()
sgr_mouse.setRawData (rawdata5);
sgr_mouse.processEvent (&tv);
CPPUNIT_ASSERT ( ! sgr_mouse.isInputDataPending() );
CPPUNIT_ASSERT ( ! sgr_mouse.hasUnprocessedInput() );
CPPUNIT_ASSERT ( ! sgr_mouse.isMiddleButtonPressed() );
CPPUNIT_ASSERT ( sgr_mouse.isMiddleButtonReleased() );
@ -699,7 +699,7 @@ void FMouseTest::sgrMouseTest()
sgr_mouse.setRawData (rawdata6);
CPPUNIT_ASSERT ( sgr_mouse.hasData() );
CPPUNIT_ASSERT ( sgr_mouse.isInputDataPending() );
CPPUNIT_ASSERT ( sgr_mouse.hasUnprocessedInput() );
finalcut::FObject::getCurrentTime(&tv);
sgr_mouse.processEvent (&tv);
CPPUNIT_ASSERT ( ! sgr_mouse.hasData() );
@ -722,7 +722,7 @@ void FMouseTest::sgrMouseTest()
sgr_mouse.setRawData (rawdata6);
sgr_mouse.processEvent (&tv);
CPPUNIT_ASSERT ( sgr_mouse.getPos() == finalcut::FPoint(3, 4) );
CPPUNIT_ASSERT ( ! sgr_mouse.isInputDataPending() );
CPPUNIT_ASSERT ( ! sgr_mouse.hasUnprocessedInput() );
CPPUNIT_ASSERT ( ! sgr_mouse.isRightButtonPressed() );
CPPUNIT_ASSERT ( sgr_mouse.isRightButtonReleased() );
@ -733,7 +733,7 @@ void FMouseTest::sgrMouseTest()
sgr_mouse.setRawData (rawdata7);
CPPUNIT_ASSERT ( sgr_mouse.hasData() );
CPPUNIT_ASSERT ( sgr_mouse.isInputDataPending() );
CPPUNIT_ASSERT ( sgr_mouse.hasUnprocessedInput() );
finalcut::FObject::getCurrentTime(&tv);
sgr_mouse.processEvent (&tv);
CPPUNIT_ASSERT ( ! sgr_mouse.hasData() );
@ -755,7 +755,7 @@ void FMouseTest::sgrMouseTest()
sgr_mouse.setRawData (rawdata7);
sgr_mouse.processEvent (&tv);
CPPUNIT_ASSERT ( ! sgr_mouse.isInputDataPending() );
CPPUNIT_ASSERT ( ! sgr_mouse.hasUnprocessedInput() );
CPPUNIT_ASSERT ( sgr_mouse.isWheelDown() );
// Mouse move
@ -766,7 +766,7 @@ void FMouseTest::sgrMouseTest()
sgr_mouse.setRawData (rawdata8);
CPPUNIT_ASSERT ( sgr_mouse.hasData() );
CPPUNIT_ASSERT ( sgr_mouse.isInputDataPending() );
CPPUNIT_ASSERT ( sgr_mouse.hasUnprocessedInput() );
finalcut::FObject::getCurrentTime(&tv);
sgr_mouse.processEvent (&tv);
CPPUNIT_ASSERT ( ! sgr_mouse.hasData() );
@ -805,7 +805,7 @@ void FMouseTest::sgrMouseTest()
sgr_mouse.setRawData (rawdata9);
CPPUNIT_ASSERT ( sgr_mouse.hasData() );
CPPUNIT_ASSERT ( sgr_mouse.isInputDataPending() );
CPPUNIT_ASSERT ( sgr_mouse.hasUnprocessedInput() );
finalcut::FObject::getCurrentTime(&tv);
sgr_mouse.processEvent (&tv);
CPPUNIT_ASSERT ( ! sgr_mouse.hasData() );
@ -876,7 +876,7 @@ void FMouseTest::sgrMouseTest()
sgr_mouse.processEvent (&tv);
CPPUNIT_ASSERT ( ! sgr_mouse.hasEvent() );
CPPUNIT_ASSERT ( sgr_mouse.isInputDataPending() );
CPPUNIT_ASSERT ( sgr_mouse.hasUnprocessedInput() );
CPPUNIT_ASSERT ( std::strcmp(rawdata11, "@") == 0 );
}
@ -892,7 +892,7 @@ void FMouseTest::urxvtMouseTest()
, '9', ';', '6', 'M', '@', '@' };
urxvt_mouse.setRawData (rawdata1);
CPPUNIT_ASSERT ( urxvt_mouse.hasData() );
CPPUNIT_ASSERT ( urxvt_mouse.isInputDataPending() );
CPPUNIT_ASSERT ( urxvt_mouse.hasUnprocessedInput() );
CPPUNIT_ASSERT ( std::strcmp(rawdata1, "@@") == 0 );
timeval tv;
@ -927,7 +927,7 @@ void FMouseTest::urxvtMouseTest()
urxvt_mouse.setRawData (rawdata2);
CPPUNIT_ASSERT ( urxvt_mouse.hasData() );
CPPUNIT_ASSERT ( ! urxvt_mouse.isInputDataPending() );
CPPUNIT_ASSERT ( ! urxvt_mouse.hasUnprocessedInput() );
urxvt_mouse.processEvent (&tv);
CPPUNIT_ASSERT ( ! urxvt_mouse.hasData() );
CPPUNIT_ASSERT ( urxvt_mouse.getPos() == finalcut::FPoint(49, 6) );
@ -952,7 +952,7 @@ void FMouseTest::urxvtMouseTest()
urxvt_mouse.setRawData (rawdata4);
CPPUNIT_ASSERT ( urxvt_mouse.hasData() );
CPPUNIT_ASSERT ( ! urxvt_mouse.isInputDataPending() );
CPPUNIT_ASSERT ( ! urxvt_mouse.hasUnprocessedInput() );
finalcut::FObject::getCurrentTime(&tv);
urxvt_mouse.processEvent (&tv);
CPPUNIT_ASSERT ( ! urxvt_mouse.hasData() );
@ -979,7 +979,7 @@ void FMouseTest::urxvtMouseTest()
urxvt_mouse.setRawData (rawdata5);
CPPUNIT_ASSERT ( urxvt_mouse.hasData() );
CPPUNIT_ASSERT ( urxvt_mouse.isInputDataPending() );
CPPUNIT_ASSERT ( urxvt_mouse.hasUnprocessedInput() );
finalcut::FObject::getCurrentTime(&tv);
urxvt_mouse.processEvent (&tv);
CPPUNIT_ASSERT ( ! urxvt_mouse.hasData() );
@ -1001,7 +1001,7 @@ void FMouseTest::urxvtMouseTest()
urxvt_mouse.setRawData (rawdata5);
urxvt_mouse.processEvent (&tv);
CPPUNIT_ASSERT ( ! urxvt_mouse.isInputDataPending() );
CPPUNIT_ASSERT ( ! urxvt_mouse.hasUnprocessedInput() );
CPPUNIT_ASSERT ( ! urxvt_mouse.isMiddleButtonPressed() );
CPPUNIT_ASSERT ( urxvt_mouse.isMiddleButtonReleased() );
@ -1012,7 +1012,7 @@ void FMouseTest::urxvtMouseTest()
urxvt_mouse.setRawData (rawdata6);
CPPUNIT_ASSERT ( urxvt_mouse.hasData() );
CPPUNIT_ASSERT ( urxvt_mouse.isInputDataPending() );
CPPUNIT_ASSERT ( urxvt_mouse.hasUnprocessedInput() );
finalcut::FObject::getCurrentTime(&tv);
urxvt_mouse.processEvent (&tv);
CPPUNIT_ASSERT ( ! urxvt_mouse.hasData() );
@ -1035,7 +1035,7 @@ void FMouseTest::urxvtMouseTest()
urxvt_mouse.setRawData (rawdata6);
urxvt_mouse.processEvent (&tv);
CPPUNIT_ASSERT ( urxvt_mouse.getPos() == finalcut::FPoint(3, 4) );
CPPUNIT_ASSERT ( ! urxvt_mouse.isInputDataPending() );
CPPUNIT_ASSERT ( ! urxvt_mouse.hasUnprocessedInput() );
CPPUNIT_ASSERT ( ! urxvt_mouse.isRightButtonPressed() );
CPPUNIT_ASSERT ( urxvt_mouse.isRightButtonReleased() );
@ -1046,7 +1046,7 @@ void FMouseTest::urxvtMouseTest()
urxvt_mouse.setRawData (rawdata7);
CPPUNIT_ASSERT ( urxvt_mouse.hasData() );
CPPUNIT_ASSERT ( urxvt_mouse.isInputDataPending() );
CPPUNIT_ASSERT ( urxvt_mouse.hasUnprocessedInput() );
finalcut::FObject::getCurrentTime(&tv);
urxvt_mouse.processEvent (&tv);
CPPUNIT_ASSERT ( ! urxvt_mouse.hasData() );
@ -1068,7 +1068,7 @@ void FMouseTest::urxvtMouseTest()
urxvt_mouse.setRawData (rawdata7);
urxvt_mouse.processEvent (&tv);
CPPUNIT_ASSERT ( ! urxvt_mouse.isInputDataPending() );
CPPUNIT_ASSERT ( ! urxvt_mouse.hasUnprocessedInput() );
CPPUNIT_ASSERT ( urxvt_mouse.isWheelDown() );
// Mouse move
@ -1079,7 +1079,7 @@ void FMouseTest::urxvtMouseTest()
urxvt_mouse.setRawData (rawdata8);
CPPUNIT_ASSERT ( urxvt_mouse.hasData() );
CPPUNIT_ASSERT ( urxvt_mouse.isInputDataPending() );
CPPUNIT_ASSERT ( urxvt_mouse.hasUnprocessedInput() );
finalcut::FObject::getCurrentTime(&tv);
urxvt_mouse.processEvent (&tv);
CPPUNIT_ASSERT ( ! urxvt_mouse.hasData() );
@ -1118,7 +1118,7 @@ void FMouseTest::urxvtMouseTest()
urxvt_mouse.setRawData (rawdata9);
CPPUNIT_ASSERT ( urxvt_mouse.hasData() );
CPPUNIT_ASSERT ( urxvt_mouse.isInputDataPending() );
CPPUNIT_ASSERT ( urxvt_mouse.hasUnprocessedInput() );
finalcut::FObject::getCurrentTime(&tv);
urxvt_mouse.processEvent (&tv);
CPPUNIT_ASSERT ( ! urxvt_mouse.hasData() );
@ -1189,7 +1189,7 @@ void FMouseTest::urxvtMouseTest()
urxvt_mouse.processEvent (&tv);
CPPUNIT_ASSERT ( ! urxvt_mouse.hasEvent() );
CPPUNIT_ASSERT ( urxvt_mouse.isInputDataPending() );
CPPUNIT_ASSERT ( urxvt_mouse.hasUnprocessedInput() );
CPPUNIT_ASSERT ( std::strcmp(rawdata11, "@") == 0 );
// Negative values
@ -1198,7 +1198,7 @@ void FMouseTest::urxvtMouseTest()
, 0x1b, '[', '3', '2', ';', '3', ';', '-', '3', 'M' };
urxvt_mouse.setRawData (rawdata12);
CPPUNIT_ASSERT ( urxvt_mouse.hasData() );
CPPUNIT_ASSERT ( urxvt_mouse.isInputDataPending() );
CPPUNIT_ASSERT ( urxvt_mouse.hasUnprocessedInput() );
urxvt_mouse.processEvent (&tv);
CPPUNIT_ASSERT ( ! urxvt_mouse.hasData() );
CPPUNIT_ASSERT ( urxvt_mouse.getPos() != finalcut::FPoint(-5, 5) );
@ -1255,7 +1255,7 @@ void FMouseTest::mouseControlTest()
CPPUNIT_ASSERT ( ! mouse_control.isWheelUp() );
CPPUNIT_ASSERT ( ! mouse_control.isWheelDown() );
CPPUNIT_ASSERT ( ! mouse_control.isMoved() );
CPPUNIT_ASSERT ( ! mouse_control.isInputDataPending() );
CPPUNIT_ASSERT ( ! mouse_control.hasUnprocessedInput() );
if ( mouse_control.isGpmMouseEnabled() )
{
@ -1270,7 +1270,7 @@ void FMouseTest::mouseControlTest()
mouse_control.setRawData (finalcut::FMouse::x11, rawdata1);
CPPUNIT_ASSERT ( mouse_control.hasData() );
CPPUNIT_ASSERT ( mouse_control.isInputDataPending() );
CPPUNIT_ASSERT ( mouse_control.hasUnprocessedInput() );
timeval tv;
finalcut::FObject::getCurrentTime(&tv);
mouse_control.processEvent (&tv);
@ -1290,11 +1290,11 @@ void FMouseTest::mouseControlTest()
CPPUNIT_ASSERT ( ! mouse_control.isWheelUp() );
CPPUNIT_ASSERT ( ! mouse_control.isWheelDown() );
CPPUNIT_ASSERT ( ! mouse_control.isMoved() );
CPPUNIT_ASSERT ( mouse_control.isInputDataPending() );
CPPUNIT_ASSERT ( mouse_control.hasUnprocessedInput() );
mouse_control.setRawData (finalcut::FMouse::x11, rawdata1);
mouse_control.processEvent (&tv);
CPPUNIT_ASSERT ( ! mouse_control.isInputDataPending() );
CPPUNIT_ASSERT ( ! mouse_control.hasUnprocessedInput() );
CPPUNIT_ASSERT ( ! mouse_control.isLeftButtonPressed() );
CPPUNIT_ASSERT ( mouse_control.isLeftButtonReleased() );
CPPUNIT_ASSERT ( ! mouse_control.isLeftButtonDoubleClick() );
@ -1305,7 +1305,7 @@ void FMouseTest::mouseControlTest()
, 0x1b, '[', '<', '1', ';', '1', ';', '1', 'm' };
mouse_control.setRawData (finalcut::FMouse::sgr, rawdata2);
CPPUNIT_ASSERT ( mouse_control.hasData() );
CPPUNIT_ASSERT ( mouse_control.isInputDataPending() );
CPPUNIT_ASSERT ( mouse_control.hasUnprocessedInput() );
finalcut::FObject::getCurrentTime(&tv);
mouse_control.processEvent (&tv);
CPPUNIT_ASSERT ( ! mouse_control.hasData() );
@ -1327,7 +1327,7 @@ void FMouseTest::mouseControlTest()
mouse_control.setRawData (finalcut::FMouse::sgr, rawdata2);
mouse_control.processEvent (&tv);
CPPUNIT_ASSERT ( ! mouse_control.isInputDataPending() );
CPPUNIT_ASSERT ( ! mouse_control.hasUnprocessedInput() );
CPPUNIT_ASSERT ( ! mouse_control.isMiddleButtonPressed() );
CPPUNIT_ASSERT ( mouse_control.isMiddleButtonReleased() );
@ -1336,7 +1336,7 @@ void FMouseTest::mouseControlTest()
, 0x1b, '[', '3', '5', ';', '3', ';', '4', 'M' };
mouse_control.setRawData (finalcut::FMouse::urxvt, rawdata3);
CPPUNIT_ASSERT ( mouse_control.hasData() );
CPPUNIT_ASSERT ( mouse_control.isInputDataPending() );
CPPUNIT_ASSERT ( mouse_control.hasUnprocessedInput() );
finalcut::FObject::getCurrentTime(&tv);
mouse_control.processEvent (&tv);
CPPUNIT_ASSERT ( ! mouse_control.hasData() );
@ -1359,7 +1359,7 @@ void FMouseTest::mouseControlTest()
mouse_control.setRawData (finalcut::FMouse::urxvt, rawdata3);
mouse_control.processEvent (&tv);
CPPUNIT_ASSERT ( mouse_control.getPos() == finalcut::FPoint(3, 4) );
CPPUNIT_ASSERT ( ! mouse_control.isInputDataPending() );
CPPUNIT_ASSERT ( ! mouse_control.hasUnprocessedInput() );
CPPUNIT_ASSERT ( ! mouse_control.isRightButtonPressed() );
CPPUNIT_ASSERT ( mouse_control.isRightButtonReleased() );
@ -1369,7 +1369,7 @@ void FMouseTest::mouseControlTest()
, 0x1b, '[', 'M', 0x61, 0x70, 0x39 };
mouse_control.setRawData (finalcut::FMouse::x11, rawdata4);
CPPUNIT_ASSERT ( mouse_control.hasData() );
CPPUNIT_ASSERT ( mouse_control.isInputDataPending() );
CPPUNIT_ASSERT ( mouse_control.hasUnprocessedInput() );
finalcut::FObject::getCurrentTime(&tv);
mouse_control.processEvent (&tv);
CPPUNIT_ASSERT ( ! mouse_control.hasData() );
@ -1391,7 +1391,7 @@ void FMouseTest::mouseControlTest()
mouse_control.setRawData (finalcut::FMouse::x11, rawdata4);
mouse_control.processEvent (&tv);
CPPUNIT_ASSERT ( ! mouse_control.isInputDataPending() );
CPPUNIT_ASSERT ( ! mouse_control.hasUnprocessedInput() );
CPPUNIT_ASSERT ( mouse_control.isWheelDown() );
// Mouse move on an SGR mouse
@ -1401,7 +1401,7 @@ void FMouseTest::mouseControlTest()
, 0x1b, '[', '<', '0', ';', '3', ';', '4', 'm' };
mouse_control.setRawData (finalcut::FMouse::sgr, rawdata5);
CPPUNIT_ASSERT ( mouse_control.hasData() );
CPPUNIT_ASSERT ( mouse_control.isInputDataPending() );
CPPUNIT_ASSERT ( mouse_control.hasUnprocessedInput() );
finalcut::FObject::getCurrentTime(&tv);
mouse_control.processEvent (&tv);
CPPUNIT_ASSERT ( ! mouse_control.hasData() );

49
test/fobject-test.cpp
View File

@ -157,6 +157,7 @@ class FObjectTest : public CPPUNIT_NS::TestFixture
void setParentTest();
void addTest();
void delTest();
void elementAccessTest();
void iteratorTest();
void timeTest();
void timerTest();
@ -176,6 +177,7 @@ class FObjectTest : public CPPUNIT_NS::TestFixture
CPPUNIT_TEST (setParentTest);
CPPUNIT_TEST (addTest);
CPPUNIT_TEST (delTest);
CPPUNIT_TEST (elementAccessTest);
CPPUNIT_TEST (iteratorTest);
CPPUNIT_TEST (timeTest);
CPPUNIT_TEST (timerTest);
@ -456,6 +458,51 @@ void FObjectTest::delTest()
delete obj;
}
//----------------------------------------------------------------------
void FObjectTest::elementAccessTest()
{
// obj -> child1
// -> child2
// -> child3
// -> child4
// -> child5
auto obj = new finalcut::FObject();
auto child1 = new finalcut::FObject(obj);
auto child2 = new finalcut::FObject(obj);
auto child3 = new finalcut::FObject(obj);
auto child4 = new finalcut::FObject(obj);
auto child5 = new finalcut::FObject(obj);
CPPUNIT_ASSERT ( child1->getParent() == obj );
CPPUNIT_ASSERT ( child2->getParent() == obj );
CPPUNIT_ASSERT ( child3->getParent() == obj );
CPPUNIT_ASSERT ( child4->getParent() == obj );
CPPUNIT_ASSERT ( child5->getParent() == obj );
finalcut::FObject::const_reference c_first = obj->front();
finalcut::FObject::const_reference c_last = obj->back();
CPPUNIT_ASSERT ( c_first == child1 );
CPPUNIT_ASSERT ( c_last == child5 );
CPPUNIT_ASSERT ( obj->numOfChildren() == 5 );
obj->delChild(child1);
CPPUNIT_ASSERT ( obj->numOfChildren() == 4 );
CPPUNIT_ASSERT ( obj->front() == child2 );
CPPUNIT_ASSERT ( obj->back() == child5 );
finalcut::FObject::reference first = obj->front();
finalcut::FObject::reference last = obj->back();
CPPUNIT_ASSERT ( first == child2 );
CPPUNIT_ASSERT ( last == child5 );
CPPUNIT_ASSERT ( obj->numOfChildren() == 4 );
obj->delChild(child5);
CPPUNIT_ASSERT ( obj->numOfChildren() == 3 );
CPPUNIT_ASSERT ( obj->front() == child2 );
CPPUNIT_ASSERT ( obj->back() == child4 );
delete obj;
}
//----------------------------------------------------------------------
void FObjectTest::iteratorTest()
{
@ -648,7 +695,7 @@ void FObjectTest::performTimerActionTest()
CPPUNIT_ASSERT ( t2.getValue() == 0 );
finalcut::FTimerEvent timer_ev (finalcut::fc::Timer_Event, 1);
for (int x = 0; x < 10; x++)
for (auto x = 0; x < 10; x++)
finalcut::FApplication::sendEvent (&t2, &timer_ev);
CPPUNIT_ASSERT ( t2.getValue() == 10 );

3211
test/foptiattr-test.cpp
View File

File diff suppressed because it is too large Load Diff

8
test/fstring-test.cpp
View File

@ -444,7 +444,8 @@ void FStringTest::assignmentTest()
CPPUNIT_ASSERT ( ! s1 );
// Move assignment operator
const finalcut::FString s9 = std::move(finalcut::FString(0));
auto empty = finalcut::FString(0);
const finalcut::FString s9 = std::move(empty);
CPPUNIT_ASSERT ( ! s9 );
CPPUNIT_ASSERT ( s9.isNull() );
CPPUNIT_ASSERT ( s9.isEmpty() );
@ -2196,7 +2197,7 @@ void FStringTest::controlCodesTest()
// C0 control codes (0x01 - 0x1f) - without null (0x00)
finalcut::FString c0(0x1f);
for (int i = 0; i < 0x1f; i++)
for (auto i = 0; i < 0x1f; i++)
c0[i] = i + 1;
CPPUNIT_ASSERT ( c0.getLength() == 31 );
@ -2210,7 +2211,8 @@ void FStringTest::controlCodesTest()
// C1 control codes (0x80 - 0x9f)
// Used as print characters in some character sets
finalcut::FString c1(0x20);
for (int i = 0; i <= 0x1f; i++)
for (auto i = 0; i <= 0x1f; i++)
c1[i] = i + 0x80;
CPPUNIT_ASSERT ( c1.replaceControlCodes() == finalcut::FString(32, L' ') );

2
test/ftermfreebsd-test.cpp
View File

@ -656,6 +656,8 @@ void ftermfreebsdTest::freebsdConsoleTest()
data->setMonochron (false);
data->setTermResized (false);
// setupterm is needed for tputs in ncurses >= 6.1
setupterm (static_cast<char*>(0), 1, static_cast<int*>(0));
term_detection = finalcut::FTerm::getFTermDetection();
term_detection->setTerminalDetection(true);
pid_t pid = forkConEmu();

22
test/ftermlinux-test.cpp
View File

@ -111,10 +111,10 @@ class FSystemTest : public finalcut::FSystem
FILE* fopen (const char*, const char*) override;
int fclose (FILE*) override;
int putchar (int) override;
int tputs (const char*, int, int (*)(int)) override;
int tputs (const char*, int, fn_putc) override;
uid_t getuid() override;
uid_t geteuid() override;
int getpwuid_r (uid_t, struct passwd*, char*
int getpwuid_r ( uid_t, struct passwd*, char*
, size_t, struct passwd** ) override;
char* realpath (const char*, char*) override;
RGB& getRGB (std::size_t);
@ -1121,9 +1121,10 @@ int FSystemTest::ioctl (int fd, uLong request, ...)
terminal_font.width = fn->width;
terminal_font.height = fn->height;
terminal_font.charcount = fn->charcount;
auto size = fn->width / 8 * fn->height * fn->charcount;
if ( fn->data && terminal_font.data )
std::memcpy (terminal_font.data, fn->data, font_data_size);
std::memcpy (terminal_font.data, fn->data, size);
terminal_font.op = KD_FONT_OP_SET;
}
@ -1337,7 +1338,7 @@ int FSystemTest::putchar (int c)
}
//----------------------------------------------------------------------
int FSystemTest::tputs (const char* str, int affcnt, int (*putc)(int))
int FSystemTest::tputs (const char* str, int affcnt, fn_putc putc)
{
return ::tputs (str, affcnt, putc);
}
@ -1557,6 +1558,8 @@ void FTermLinuxTest::linuxConsoleTest()
term_detection = finalcut::FTerm::getFTermDetection();
finalcut::FTermLinux linux;
// setupterm is needed for tputs in ncurses >= 6.1
setupterm (static_cast<char*>(0), 1, static_cast<int*>(0));
term_detection->setLinuxTerm(true);
pid_t pid = forkConEmu();
@ -1676,6 +1679,8 @@ void FTermLinuxTest::linuxCursorStyleTest()
data->setMonochron (false);
data->setTermResized (false);
// setupterm is needed for tputs in ncurses >= 6.1
setupterm (static_cast<char*>(0), 1, static_cast<int*>(0));
term_detection = finalcut::FTerm::getFTermDetection();
finalcut::FTermLinux linux;
@ -1865,9 +1870,10 @@ void FTermLinuxTest::linuxColorPaletteTest()
data->setMonochron (false);
data->setTermResized (false);
// setupterm is needed for tputs in ncurses >= 6.1
setupterm (static_cast<char*>(0), 1, static_cast<int*>(0));
term_detection = finalcut::FTerm::getFTermDetection();
finalcut::FTermLinux linux;
term_detection->setLinuxTerm(true);
pid_t pid = forkConEmu();
@ -2141,6 +2147,8 @@ void FTermLinuxTest::linuxFontTest()
data->setMonochron (false);
data->setTermResized (false);
// setupterm is needed for tputs in ncurses >= 6.1
setupterm (static_cast<char*>(0), 1, static_cast<int*>(0));
term_detection = finalcut::FTerm::getFTermDetection();
finalcut::FTermLinux linux;
@ -2170,7 +2178,7 @@ void FTermLinuxTest::linuxFontTest()
CPPUNIT_ASSERT ( ! linux.isNewFontUsed() );
linux.loadVGAFont();
CPPUNIT_ASSERT ( data->hasShadowCharacter() );
/* CPPUNIT_ASSERT ( data->hasShadowCharacter() );
CPPUNIT_ASSERT ( data->hasHalfBlockCharacter() );
CPPUNIT_ASSERT ( font.op == KD_FONT_OP_SET );
CPPUNIT_ASSERT ( linux.isVGAFontUsed() );
@ -2227,7 +2235,7 @@ void FTermLinuxTest::linuxFontTest()
CPPUNIT_ASSERT ( font.data[249 * 32 + 13] == 0x00 );
CPPUNIT_ASSERT ( font.data[249 * 32 + 14] == 0x00 );
CPPUNIT_ASSERT ( font.data[249 * 32 + 15] == 0x00 );
*/
linux.finish();
closeConEmuStdStreams();

4
test/ftermopenbsd-test.cpp
View File

@ -377,6 +377,8 @@ void ftermopenbsdTest::netbsdConsoleTest()
data->setMonochron (false);
data->setTermResized (false);
// setupterm is needed for tputs in ncurses >= 6.1
setupterm (static_cast<char*>(0), 1, static_cast<int*>(0));
term_detection = finalcut::FTerm::getFTermDetection();
term_detection->setTerminalDetection(true);
pid_t pid = forkConEmu();
@ -482,6 +484,8 @@ void ftermopenbsdTest::openbsdConsoleTest()
data->setMonochron (false);
data->setTermResized (false);
// setupterm is needed for tputs in ncurses >= 6.1
setupterm (static_cast<char*>(0), 1, static_cast<int*>(0));
term_detection = finalcut::FTerm::getFTermDetection();
term_detection->setTerminalDetection(true);
pid_t pid = forkConEmu();