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

Merge pull request #22 from gansm/master 

merge
This commit is contained in:
Markus Gans 2018-11-22 00:19:50 +01:00 committed by GitHub
parent fea2d1f5b2 f6df9585f5
commit f30b8f9431
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
141 changed files with 5052 additions and 3349 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.codedocs
View File

@ -1,4 +1,4 @@
PROJECT_NAME = "The Final Cut" PROJECT_NAME = "The Final Cut"
EXCLUDE = debian, icon, logo, m4, scripts, examples EXCLUDE = debian, doc, icon, logo, m4, scripts, examples
EXCLUDE_PATTERNS = */test/* EXCLUDE_PATTERNS = */test/*

1
.gitignore vendored
View File

@ -52,6 +52,7 @@ examples/input-dialog
examples/choice examples/choice
examples/listbox examples/listbox
examples/listview examples/listview
examples/checklist
examples/treeview examples/treeview
examples/mandelbrot examples/mandelbrot
examples/keyboard examples/keyboard

1
.travis.yml
View File

@ -62,6 +62,7 @@ matrix:
- ./configure --prefix=/usr CPPFLAGS="-DDEBUG" CXXFLAGS="-g -O0 -DDEBUG" --with-unit-test - ./configure --prefix=/usr CPPFLAGS="-DDEBUG" CXXFLAGS="-g -O0 -DDEBUG" --with-unit-test
- make V=1 -j10 - make V=1 -j10
- make check - make check
- cat test/*.log
# #
# Coveralls # Coveralls

46
ChangeLog
View File

@ -1,3 +1,43 @@
2018-11-21 Markus Gans <guru.mail@muenster.de>
* New type FKey for key inputs
* The integer type of FPoint and FRect changed from short to int
2018-11-18 Markus Gans <guru.mail@muenster.de>
* The FListViewItem class now provides checkable list view items
* Adding the checklist example to demonstrate the checkable FListViewItems
* A checkable FListViewItem now shows the input cursor
2018-11-12 Markus Gans <guru.mail@muenster.de>
* Clicking on the column header in FListView now changes the sort order
2018-11-10 Markus Gans <guru.mail@muenster.de>
* FListView now has a sort indicator to display the sort order
2018-11-07 Markus Gans <guru.mail@muenster.de>
* Use new type FColor for color values
2018-11-05 Markus Gans <guru.mail@muenster.de>
* FButton now uses the widget flags directly
2018-11-04 Markus Gans <guru.mail@muenster.de>
* Widget flags are now stored in a bit field
2018-11-03 Markus Gans <guru.mail@muenster.de>
* New method rgb2ColorIndex() to converts a 24-bit RGB color
to a 256-color compatible approximation
2018-11-01 Markus Gans <guru.mail@muenster.de>
* Moved FTerm debug access methods to FTermDebugData
2018-10-29 Markus Gans <guru.mail@muenster.de>
* FTerm is now a data member of FVTerm
* Fix FListBox prevListItem()
* Setting the value can_change_color_palette in FTermcapQuirks
2018-10-26 Markus Gans <guru.mail@muenster.de>
* Building Fix for a negative value check (gcc < 4.8)
* Adding the capacity() method to the FString class
2018-10-21 Markus Gans <guru.mail@muenster.de> 2018-10-21 Markus Gans <guru.mail@muenster.de>
* Moving static attributes from FApplication to FWidget * Moving static attributes from FApplication to FWidget
@ -104,7 +144,7 @@
2018-07-01 Markus Gans <guru.mail@muenster.de> 2018-07-01 Markus Gans <guru.mail@muenster.de>
* All in FOptiMove required termcap values can now be passed * All in FOptiMove required termcap values can now be passed
with a single struct with a single struct
2018-06-25 Markus Gans <guru.mail@muenster.de> 2018-06-25 Markus Gans <guru.mail@muenster.de>
* All termcap values required in FOptiAttr can now be passed * All termcap values required in FOptiAttr can now be passed
@ -257,7 +297,7 @@
2018-01-02 Markus Gans <guru.mail@muenster.de> 2018-01-02 Markus Gans <guru.mail@muenster.de>
* Refactoring of secondary device attributes parsing * Refactoring of secondary device attributes parsing
* Small menu improvements * Small menu improvements
2017-12-31 Markus Gans <guru.mail@muenster.de> 2017-12-31 Markus Gans <guru.mail@muenster.de>
* Refactoring of the FListBox mouse event handler * Refactoring of the FListBox mouse event handler
@ -479,7 +519,7 @@
2017-07-18 Markus Gans <guru.mail@muenster.de> 2017-07-18 Markus Gans <guru.mail@muenster.de>
* New Widget class FListView (filled with FListViewItem) * New Widget class FListView (filled with FListViewItem)
to allow a multi-column data view to allow a multi-column data view
* Add the listview example to demonstrate FListView * Add the listview example to demonstrate FListView
2017-07-11 Markus Gans <guru.mail@muenster.de> 2017-07-11 Markus Gans <guru.mail@muenster.de>
* New class FTermBuffer to buffer terminal outputs * New class FTermBuffer to buffer terminal outputs

204
README.md
View File

@ -11,8 +11,9 @@
*Class Reference:*<br /> *Class Reference:*<br />
&#160;&#160;&#160;&#160;&#160;[![documented](https://codedocs.xyz/gansm/finalcut.svg)](https://codedocs.xyz/gansm/finalcut/hierarchy.html) &#160;&#160;&#160;&#160;&#160;[![documented](https://codedocs.xyz/gansm/finalcut.svg)](https://codedocs.xyz/gansm/finalcut/hierarchy.html)
The Final Cut is a C++ class library and widget toolkit with full mouse support for creating a [text-based user interface](https://en.wikipedia.org/wiki/Text-based_user_interface). The library supports the programmer to develop an application for the text console. It allows the simultaneous handling of multiple text windows on the screen. The FINAL CUT is a C++ class library and widget toolkit with full mouse support for creating a [text-based user interface](https://en.wikipedia.org/wiki/Text-based_user_interface). The library supports the programmer to develop an application for the text console. It allows the simultaneous handling of multiple text windows on the screen.
The C++ class design was inspired by the Qt framework. It provides common controls like dialog boxes, push buttons, check boxes, radio buttons, input lines, list boxes, status bars and so on.
The structure of the Qt framework was originally the inspiration for the C++ class design of FINAL CUT. It provides common controls like dialog boxes, push buttons, check boxes, radio buttons, input lines, list boxes, status bars and so on.
### Installation ### Installation
```bash ```bash
@ -141,112 +142,119 @@ printf(...)
Class digramm Class digramm
------------- -------------
<pre style="line-height: 1 !important;"> <pre style="line-height: 1 !important;">
1┌──────────────┐ 1┌──────────────┐
┌-----------┤ FTermFreeBSD │ ┌-----------┤ FTermFreeBSD │
: └──────────────┘ : └──────────────┘
: 1┌──────────────┐ ┌───────────┐ : 1┌──────────────┐ ┌───────────┐
┌-----------┤ FTermOpenBSD │ ┌────┤ FKeyEvent │ ┌-----------┤ FTermOpenBSD │ ┌────┤ FKeyEvent │
: └──────────────┘ │ └───────────┘ : └──────────────┘ │ └───────────┘
: 1┌────────────────┐ │ ┌─────────────┐ : 1┌────────────────┐ │ ┌─────────────┐
┌-----------┤ FTermDetection │ ├────┤ FMouseEvent │ ┌-----------┤ FTermDetection │ ├────┤ FMouseEvent │
: └────────────────┘ │ └─────────────┘ : └────────────────┘ │ └─────────────┘
: 1┌────────────────┐ │ ┌─────────────┐ : 1┌────────────────┐ │ ┌─────────────┐
┌-----------┤ FTermcapQuirks │ ├────┤ FWheelEvent │ ┌-----------┤ FTermcapQuirks │ ├────┤ FWheelEvent │
: └────────────────┘ │ └─────────────┘ : └────────────────┘ │ └─────────────┘
: 1┌────────────────┐ │ ┌─────────────┐ : 1┌────────────────┐ │ ┌─────────────┐
┌-----------┤ FTermXTerminal │ ├────┤ FFocusEvent │ ┌-----------┤ FTermXTerminal │ ├────┤ FFocusEvent │
: └────────────────┘ │ └─────────────┘ : └────────────────┘ │ └─────────────┘
: 1┌──────────┐ │ ┌─────────────┐ : 1┌──────────┐ │ ┌─────────────┐
┌-----------┤ FTermcap │ ┌────────┐ ├────┤ FAccelEvent │ ┌-----------┤ FTermcap │ ├────┤ FAccelEvent │
: └──────────┘ │ FEvent │◄─┤ └─────────────┘ : └──────────┘ │ └─────────────┘
: 1┌──────────┐ └───┬────┘ │ ┌──────────────┐ : 1┌──────────┐ │ ┌──────────────┐
┌-----------┤ FTermios │ :1 ├────┤ FResizeEvent │ ┌-----------┤ FTermios │ ├────┤ FResizeEvent │
: └──────────┘ : │ └──────────────┘ : └──────────┘ │ └──────────────┘
: 1┌───────────────┐ : │ ┌────────────┐ : 1┌───────────────┐ │ ┌────────────┐
┌-----------┤ FColorPalette │ : ├────┤ FShowEvent │ ┌-----------┤ FColorPalette │ ├────┤ FShowEvent │
: └───────────────┘ : │ └────────────┘ : └───────────────┘ │ └────────────┘
: 1┌───────────┐ : │ ┌────────────┐ : 1┌───────────┐ │ ┌────────────┐
┌-----------┤ FOptiMove │ : ├────┤ FHideEvent │ ┌-----------┤ FOptiMove │ ├────┤ FHideEvent │
: └───────────┘ : │ └────────────┘ : └───────────┘ │ └────────────┘
: 1┌───────────┐ : │ ┌─────────────┐ : 1┌───────────┐ │ ┌─────────────┐
┌-----------┤ FOptiAttr │ : ├────┤ FCloseEvent │ ┌-----------┤ FOptiAttr │ ├────┤ FCloseEvent │
: └───────────┘ : │ └─────────────┘ : └───────────┘ │ └─────────────┘
: 1┌───────────┐ : │ ┌─────────────┐ : 1┌───────────┐ │ ┌─────────────┐
┌-----------┤ FKeyboard │ : └────┤ FTimerEvent │ ┌-----------┤ FKeyboard │ ├────┤ FTimerEvent │
: └───────────┘ : └─────────────┘ : └───────────┘ │ └─────────────┘
: 1┌───────────────┐ : : 1┌───────────────┐ │
┌-----------┤ FMouseControl │ : ┌──────────────┐ ┌-----------┤ FMouseControl │ │ ┌──────────────┐
: └───────────────┘ : ┌────┤ FApplication │ : └───────────────┘ │ ┌────┤ FApplication │
: *┌─────────┐ : │ └──────────────┘ : *┌─────────┐ │ │ └──────────────┘
: ┌--------┤ FString │ : │ ┌─────────┐ : ┌--------┤ FString │ │ │ ┌─────────┐
: : └─────────┘ : ├────┤ FButton │ : : └─────────┘ │ ├────┤ FButton │
: : *┌────────┐ : │ └─────────┘ : : *┌────────┐ │ │ └─────────┘
: ┌--------┤ FPoint │ : │ ┌────────┐ : ┌--------┤ FPoint │ │ │ ┌────────┐
: : └────────┘ : ├────┤ FLabel │ : : └────────┘ │ ├────┤ FLabel │
: : *┌───────┐ : │ └────────┘ : : *┌───────┐ │ │ └────────┘
: ┌--------┤ FRect │ : │ ┌───────────┐ : ┌--------┤ FRect │ │ │ ┌───────────┐
: : └───────┘ : ├────┤ FLineEdit │ : : └───────┘ │ ├────┤ FLineEdit │
:1 :1 : │ └───────────┘ :1 :1 │ │ └───────────┘
┌─┴──┴──┐ ┌────────┐ : │ ┌──────────────┐ ┌──────────────┐ ┌─┴──┴──┐ │ │ ┌──────────────┐ ┌──────────────┐
│ FTerm │◄───┤ FVTerm │◄──┐ :1 ├────┤ FButtonGroup │ ┌──┤ FRadioButton │ │ FTerm │ │ ├────┤ FButtonGroup │ ┌──┤ FRadioButton │
└───────┘ └────────┘ │ ┌────┴────┐ │ └──────────────┘ │ └──────────────┘ └───┬───┘ ┌────────┐ │ │ └──────────────┘ │ └──────────────┘
├──┤ FWidget │◄─┤ ┌───────────────┐ │ ┌───────────┐ :1 │ FEvent │◄─────┘ │ ┌───────────────┐ │ ┌───────────┐
┌─────────┐ │ └─────────┘ ├────┤ FToggleButton │◄─┼──┤ FCheckBox │ ┌───┴────┐ └────┬───┘ ├────┤ FToggleButton │◄─┼──┤ FCheckBox │
│ FObject │◄──┘ │ └───────────────┘ │ └───────────┘ │ FVTerm │◄──┐ :1 │ └───────────────┘ │ └───────────┘
└─────────┘ │ ┌──────────────┐ │ ┌─────────┐ └────────┘ │ ┌────┴────┐ │ ┌──────────────┐ │ ┌─────────┐
├────┤ FProgressbar │ └──┤ FSwitch │ ├────┤ FWidget │◄───────┼────┤ FProgressbar │ └──┤ FSwitch │
│ └──────────────┘ └─────────┘ ┌─────────┐ │ └─────────┘ │ └──────────────┘ └─────────┘
│ ┌────────────┐ │ FObject │◄──┘ │ ┌────────────┐
├────┤ FScrollbar │ └─────────┘ ├────┤ FScrollbar │
│ └────────────┘ │ └────────────┘
│ ┌───────────┐ │ ┌───────────┐
├────┤ FTextView │ ├────┤ FTextView │
│ └───────────┘ │ └───────────┘
│ ┌──────────┐1 *┌──────────────┐ │ ┌──────────┐1 *┌──────────────┐
├────┤ FListBox ├-------┤ FListBoxItem │ ├────┤ FListBox ├-------┤ FListBoxItem │
│ └──────────┘ └──────────────┘ │ └──────────┘ └──────────────┘
┌─────────────┐1 │ 1┌───────────┐1 *┌───────────────┐ ┌─────────────┐1 │ 1┌───────────┐1 *┌───────────────┐
│ FTermBuffer ├---------------------------├────┤ FListView ├------┤ FListViewItem │ │ FTermBuffer ├----------------------├────┤ FListView ├------┤ FListViewItem │
└─────────────┘ │ └───────────┘ └───────────────┘ └─────────────┘ │ └───────────┘ └───────────────┘
│ ┌─────────────┐ │ ┌─────────────┐
├────┤ FScrollView │ ├────┤ FScrollView │
│ └─────────────┘ │ └─────────────┘
│ ┌────────────┐1 *┌────────────┐ │ ┌────────────┐1 *┌────────────┐
│ ┌──┤ FStatusBar ├-----┤ FStatusKey │ │ ┌──┤ FStatusBar ├-----┤ FStatusKey │
│ │ └────────────┘ └────────────┘ │ │ └────────────┘ └────────────┘
│ │ │ │
│ ▼ ┌─────────────┐ │ ▼ ┌─────────────┐
┌───┴─┴───┐ ┌─────────┐ ┌──┤ FFileDialog │ ┌───┴─┴───┐ ┌─────────┐ ┌──┤ FFileDialog │
│ FWindow │◄─┤ FDialog │◄──┤ └─────────────┘ │ FWindow │◄─┤ FDialog │◄──┤ └─────────────┘
└──┬──┬───┘ └─────────┘ │ ┌─────────────┐ └──┬──┬───┘ └─────────┘ │ ┌─────────────┐
▲ ▲ └──┤ FMessageBox │ ▲ ▲ └──┤ FMessageBox │
│ │ └─────────────┘ │ │ └─────────────┘
│ │ ┌──────────┐ │ │ ┌──────────┐
│ └──────┤ FToolTip │ │ └──────┤ FToolTip │
│ └──────────┘ │ └──────────┘
└───────────────┐ ┌──────────┐ └───────────────┐ ┌──────────┐
│ ┌───┤ FMenuBar │ │ ┌───┤ FMenuBar │
┌───────────┐ └──────┤ └──────────┘ ┌───────────┐ └──────┤ └──────────┘
│ FMenuList │◄──────────┤ ┌───────┐ │ FMenuList │◄──────────┤ ┌───────┐
└────┬──────┘ └───┤ FMenu │◄──┐ └────┬──────┘ └───┤ FMenu │◄──┐
1: └───────┘ │ :1 └───────┘ │
: ┌─────────────────┐ │ : ┌─────────────────┐ │
: │ FDialogListMenu ├───┘ : │ FDialogListMenu ├───┘
: └─────────────────┘ : └─────────────────┘
└--------------------------------┐ └--------------------------------┐
:* ┌────────────────┐* : :* ┌────────────────┐* :
┌─────┴─────┐ ┌──┤ FCheckMenuItem ├---┘ ┌────┴─────┐ ┌──┤ FCheckMenuItem ├---┘
│ FMenuItem │◄─┤ └────────────────┘ : │FMenuItem │◄─┤ └────────────────┘ :
└───────────┘ │ ┌────────────────┐* : └──────────┘ │ ┌────────────────┐* :
└──┤ FRadioMenuItem ├---┘ └──┤ FRadioMenuItem ├---┘
└────────────────┘ └────────────────┘
</pre> </pre>
License License
------- -------
GNU Lesser General Public License Version 3 GNU Lesser General Public License Version 3
Frequently Asked Questions
--------------------------
If you have any problems, please read the
[FAQ](doc/faq.md#frequently-asked-questions)
before you give up.
Please send bug reports to Please send bug reports to
-------------------------- --------------------------
https://github.com/gansm/finalcut/issues https://github.com/gansm/finalcut/issues

2
autogen.sh
View File

@ -3,7 +3,7 @@
if test "$1" = "update" if test "$1" = "update"
then then
# Update generated configuration files # Update generated configuration files
if which autoreconf >/dev/null if command -v autoreconf >/dev/null
then then
autoreconf --force --install --verbose --warnings=all autoreconf --force --install --verbose --warnings=all
else else

2
build.sh
View File

@ -30,7 +30,7 @@ if [ -n "$1" ]
then then
if [ ! -f ./configure ] if [ ! -f ./configure ]
then then
if which autoreconf >/dev/null if command -v autoreconf >/dev/null
then then
autoreconf --install --force autoreconf --install --force
else else

1
debian/control vendored
View File

@ -23,6 +23,7 @@ Depends:
, ${misc:Depends} , ${misc:Depends}
Suggests: Suggests:
coreutils coreutils
, ncurses-term
, grep , grep
, sed , sed
, vim-common , vim-common

192
doc/class-diagram.txt
View File

@ -4,100 +4,100 @@
1┌──────────────┐ 1┌──────────────┐
┌-----------┤ FTermFreeBSD │ ┌-----------┤ FTermFreeBSD │
: └──────────────┘ : └──────────────┘
: 1┌──────────────┐ ┌───────────┐ : 1┌──────────────┐ ┌───────────┐
┌-----------┤ FTermOpenBSD │ ┌────┤ FKeyEvent │ ┌-----------┤ FTermOpenBSD │ ┌────┤ FKeyEvent │
: └──────────────┘ │ └───────────┘ : └──────────────┘ │ └───────────┘
: 1┌────────────────┐ │ ┌─────────────┐ : 1┌────────────────┐ │ ┌─────────────┐
┌-----------┤ FTermDetection │ ├────┤ FMouseEvent │ ┌-----------┤ FTermDetection │ ├────┤ FMouseEvent │
: └────────────────┘ │ └─────────────┘ : └────────────────┘ │ └─────────────┘
: 1┌────────────────┐ │ ┌─────────────┐ : 1┌────────────────┐ │ ┌─────────────┐
┌-----------┤ FTermcapQuirks │ ├────┤ FWheelEvent │ ┌-----------┤ FTermcapQuirks │ ├────┤ FWheelEvent │
: └────────────────┘ │ └─────────────┘ : └────────────────┘ │ └─────────────┘
: 1┌────────────────┐ │ ┌─────────────┐ : 1┌────────────────┐ │ ┌─────────────┐
┌-----------┤ FTermXTerminal │ ├────┤ FFocusEvent │ ┌-----------┤ FTermXTerminal │ ├────┤ FFocusEvent │
: └────────────────┘ │ └─────────────┘ : └────────────────┘ │ └─────────────┘
: 1┌──────────┐ │ ┌─────────────┐ : 1┌──────────┐ │ ┌─────────────┐
┌-----------┤ FTermcap │ ┌────────┐ ├────┤ FAccelEvent │ ┌-----------┤ FTermcap │ ├────┤ FAccelEvent │
: └──────────┘ │ FEvent │◄─┤ └─────────────┘ : └──────────┘ │ └─────────────┘
: 1┌──────────┐ └───┬────┘ │ ┌──────────────┐ : 1┌──────────┐ │ ┌──────────────┐
┌-----------┤ FTermios │ :1 ├────┤ FResizeEvent │ ┌-----------┤ FTermios │ ├────┤ FResizeEvent │
: └──────────┘ : │ └──────────────┘ : └──────────┘ │ └──────────────┘
: 1┌───────────────┐ : │ ┌────────────┐ : 1┌───────────────┐ │ ┌────────────┐
┌-----------┤ FColorPalette │ : ├────┤ FShowEvent │ ┌-----------┤ FColorPalette │ ├────┤ FShowEvent │
: └───────────────┘ : │ └────────────┘ : └───────────────┘ │ └────────────┘
: 1┌───────────┐ : │ ┌────────────┐ : 1┌───────────┐ │ ┌────────────┐
┌-----------┤ FOptiMove │ : ├────┤ FHideEvent │ ┌-----------┤ FOptiMove │ ├────┤ FHideEvent │
: └───────────┘ : │ └────────────┘ : └───────────┘ │ └────────────┘
: 1┌───────────┐ : │ ┌─────────────┐ : 1┌───────────┐ │ ┌─────────────┐
┌-----------┤ FOptiAttr │ : ├────┤ FCloseEvent │ ┌-----------┤ FOptiAttr │ ├────┤ FCloseEvent │
: └───────────┘ : │ └─────────────┘ : └───────────┘ │ └─────────────┘
: 1┌───────────┐ : │ ┌─────────────┐ : 1┌───────────┐ │ ┌─────────────┐
┌-----------┤ FKeyboard │ : └────┤ FTimerEvent │ ┌-----------┤ FKeyboard │ ├────┤ FTimerEvent │
: └───────────┘ : └─────────────┘ : └───────────┘ │ └─────────────┘
: 1┌───────────────┐ : : 1┌───────────────┐ │
┌-----------┤ FMouseControl │ : ┌──────────────┐ ┌-----------┤ FMouseControl │ │ ┌──────────────┐
: └───────────────┘ : ┌────┤ FApplication │ : └───────────────┘ │ ┌────┤ FApplication │
: *┌─────────┐ : │ └──────────────┘ : *┌─────────┐ │ │ └──────────────┘
: ┌--------┤ FString │ : │ ┌─────────┐ : ┌--------┤ FString │ │ │ ┌─────────┐
: : └─────────┘ : ├────┤ FButton │ : : └─────────┘ │ ├────┤ FButton │
: : *┌────────┐ : │ └─────────┘ : : *┌────────┐ │ │ └─────────┘
: ┌--------┤ FPoint │ : │ ┌────────┐ : ┌--------┤ FPoint │ │ │ ┌────────┐
: : └────────┘ : ├────┤ FLabel │ : : └────────┘ │ ├────┤ FLabel │
: : *┌───────┐ : │ └────────┘ : : *┌───────┐ │ │ └────────┘
: ┌--------┤ FRect │ : │ ┌───────────┐ : ┌--------┤ FRect │ │ │ ┌───────────┐
: : └───────┘ : ├────┤ FLineEdit │ : : └───────┘ │ ├────┤ FLineEdit │
:1 :1 : │ └───────────┘ :1 :1 │ │ └───────────┘
┌─┴──┴──┐ ┌────────┐ : │ ┌──────────────┐ ┌──────────────┐ ┌─┴──┴──┐ │ │ ┌──────────────┐ ┌──────────────┐
│ FTerm │◄───┤ FVTerm │◄──┐ :1 ├────┤ FButtonGroup │ ┌──┤ FRadioButton │ │ FTerm │ │ ├────┤ FButtonGroup │ ┌──┤ FRadioButton │
└───────┘ └────────┘ │ ┌────┴────┐ │ └──────────────┘ │ └──────────────┘ └───┬───┘ ┌────────┐ │ │ └──────────────┘ │ └──────────────┘
├──┤ FWidget │◄─┤ ┌───────────────┐ │ ┌───────────┐ :1 │ FEvent │◄─────┘ │ ┌───────────────┐ │ ┌───────────┐
┌─────────┐ │ └─────────┘ ├────┤ FToggleButton │◄─┼──┤ FCheckBox │ ┌───┴────┐ └────┬───┘ ├────┤ FToggleButton │◄─┼──┤ FCheckBox │
│ FObject │◄──┘ │ └───────────────┘ │ └───────────┘ │ FVTerm │◄──┐ :1 │ └───────────────┘ │ └───────────┘
└─────────┘ │ ┌──────────────┐ │ ┌─────────┐ └────────┘ │ ┌────┴────┐ │ ┌──────────────┐ │ ┌─────────┐
├────┤ FProgressbar │ └──┤ FSwitch │ ├────┤ FWidget │◄───────┼────┤ FProgressbar │ └──┤ FSwitch │
│ └──────────────┘ └─────────┘ ┌─────────┐ │ └─────────┘ │ └──────────────┘ └─────────┘
│ ┌────────────┐ │ FObject │◄──┘ │ ┌────────────┐
├────┤ FScrollbar │ └─────────┘ ├────┤ FScrollbar │
│ └────────────┘ │ └────────────┘
│ ┌───────────┐ │ ┌───────────┐
├────┤ FTextView │ ├────┤ FTextView │
│ └───────────┘ │ └───────────┘
│ ┌──────────┐1 *┌──────────────┐ │ ┌──────────┐1 *┌──────────────┐
├────┤ FListBox ├-------┤ FListBoxItem │ ├────┤ FListBox ├-------┤ FListBoxItem │
│ └──────────┘ └──────────────┘ │ └──────────┘ └──────────────┘
┌─────────────┐1 │ 1┌───────────┐1 *┌───────────────┐ ┌─────────────┐1 │ 1┌───────────┐1 *┌───────────────┐
│ FTermBuffer ├---------------------------├────┤ FListView ├------┤ FListViewItem │ │ FTermBuffer ├----------------------├────┤ FListView ├------┤ FListViewItem │
└─────────────┘ │ └───────────┘ └───────────────┘ └─────────────┘ │ └───────────┘ └───────────────┘
│ ┌─────────────┐ │ ┌─────────────┐
├────┤ FScrollView │ ├────┤ FScrollView │
│ └─────────────┘ │ └─────────────┘
│ ┌────────────┐1 *┌────────────┐ │ ┌────────────┐1 *┌────────────┐
│ ┌──┤ FStatusBar ├-----┤ FStatusKey │ │ ┌──┤ FStatusBar ├-----┤ FStatusKey │
│ │ └────────────┘ └────────────┘ │ │ └────────────┘ └────────────┘
│ │ │ │
│ ▼ ┌─────────────┐ │ ▼ ┌─────────────┐
┌───┴─┴───┐ ┌─────────┐ ┌──┤ FFileDialog │ ┌───┴─┴───┐ ┌─────────┐ ┌──┤ FFileDialog │
│ FWindow │◄─┤ FDialog │◄──┤ └─────────────┘ │ FWindow │◄─┤ FDialog │◄──┤ └─────────────┘
└──┬──┬───┘ └─────────┘ │ ┌─────────────┐ └──┬──┬───┘ └─────────┘ │ ┌─────────────┐
▲ ▲ └──┤ FMessageBox │ ▲ ▲ └──┤ FMessageBox │
│ │ └─────────────┘ │ │ └─────────────┘
│ │ ┌──────────┐ │ │ ┌──────────┐
│ └──────┤ FToolTip │ │ └──────┤ FToolTip │
│ └──────────┘ │ └──────────┘
└───────────────┐ ┌──────────┐ └───────────────┐ ┌──────────┐
│ ┌───┤ FMenuBar │ │ ┌───┤ FMenuBar │
┌───────────┐ └──────┤ └──────────┘ ┌───────────┐ └──────┤ └──────────┘
│ FMenuList │◄──────────┤ ┌───────┐ │ FMenuList │◄──────────┤ ┌───────┐
└────┬──────┘ └───┤ FMenu │◄──┐ └────┬──────┘ └───┤ FMenu │◄──┐
:1 └───────┘ │ :1 └───────┘ │
: ┌─────────────────┐ │ : ┌─────────────────┐ │
: │ FDialogListMenu ├───┘ : │ FDialogListMenu ├───┘
: └─────────────────┘ : └─────────────────┘
└--------------------------------┐ └--------------------------------┐
:* ┌────────────────┐* : :* ┌────────────────┐* :
┌─────┴─────┐ ┌──┤ FCheckMenuItem ├---┘ ┌────┴─────┐ ┌──┤ FCheckMenuItem ├---┘
│ FMenuItem │◄─┤ └────────────────┘ : │FMenuItem │◄─┤ └────────────────┘ :
└───────────┘ │ ┌────────────────┐* : └──────────┘ │ ┌────────────────┐* :
└──┤ FRadioMenuItem ├---┘ └──┤ FRadioMenuItem ├---┘
└────────────────┘ └────────────────┘

2
doc/console_codes-manual.sh
View File

@ -2,6 +2,6 @@
# set the xterm window title # set the xterm window title
TERMTITLE="man 4 console_codes" TERMTITLE="man 4 console_codes"
echo -ne "\033]0;${TERMTITLE}\007" echo -ne "\\033]0;${TERMTITLE}\\007"
man 4 console_codes man 4 console_codes

2
doc/console_ioctl-manual.sh
View File

@ -2,6 +2,6 @@
# set the xterm window title # set the xterm window title
TERMTITLE="man 4 console_ioctl" TERMTITLE="man 4 console_ioctl"
echo -ne "\033]0;${TERMTITLE}\007" echo -ne "\\033]0;${TERMTITLE}\\007"
man 4 console_ioctl man 4 console_ioctl

138
doc/faq.md Normal file
View File

@ -0,0 +1,138 @@
Frequently Asked Questions
==========================
What is FINAL CUT?
------------------
The Final Cut is a [C++](https://en.wikipedia.org/wiki/C%2B%2B) class library
and a widget toolkit with full mouse support for creating a text-based user
interface. It's based on the Termcap library and has its own cursor
optimization and window management.
Why did you develop FINAL CUT?
------------------------------
Most Unix [TUIs](https://en.wikipedia.org/wiki/Text-based_user_interface)
are difficult to use or limited in their functionality. I developed
FINAL CUT to fix these problems. The main goals in FINAL CUT design were
to create a library that is easy to use, powerful, visually appealing and
easily expandable.
Where does the name FINAL CUT come from?
----------------------------------------
From 1991 to 1996 I developed with
[Borland Pascal](https://en.wikipedia.org/wiki/Turbo_Pascal)
under [DOS](https://en.wikipedia.org/wiki/DOS) a text-based file manager
called “The Final Cut”, with the intention to be more visually appealing
than all other products. The calculator example is, among other things an
extract from this program.
As I got to learn
[object-oriented programming](https://en.wikipedia.org/wiki/Object-oriented_programming) (OOP)
with [C++](https://en.wikipedia.org/wiki/C%2B%2B) at the end of
the 90s, I noticed significant design weaknesses in my program code.
I decided to re-implement the code cleanly in C++. This time I wanted to
avoid old mistakes and do everything right and open source. In the meanwhile,
I switched from [DOS](https://en.wikipedia.org/wiki/DOS) to
[Linux](https://en.wikipedia.org/wiki/Linux), so I started the implementing
of the first widgets (FDialog, FButton, FLineEdit, FScrollbar) and the
string class FString for the
[Linux console](https://en.wikipedia.org/wiki/Linux_console).
Unfortunately, the project lost my attention in 2000.
In 2012, I needed an attractive terminal presentation for a textual data
structure. So I have started to develop FINAL CUT to a widget library.
Are Windows and DOS supported by FINAL CUT?
-------------------------------------------
You need an operating system environment that implements a POSIX system
call API. This can be realized in Windows with the Cygwin project.
Is my platform supported?
-------------------------
The supported platforms are Linux, FreeBSD, NetBSD, OpenBSD, macOS,
Cygwin on Microsoft Windows and Oracle Solaris
What do I need to write my own programs with FINAL CUT?
-------------------------------------------------------
You need a C++ compiler like GCC (g++) or Clang (clang++).
What do I need to build this library?
-------------------------------------
You need three things:
1. C++ compiler like GCC (g++) or Clang (clang++).
2. The GNU building tools
*For example, in a Debian-based distribution it would be
the following packages:*
* autotools-dev
* automake
* autoconf
* autoconf-archive
* libtool
3. Development packages for following libraries:
* C standard library
* C++ standard library
* Termcap library *(mostly part of the curses library)*
* General Purpose Mouse library *(optional, only if you need
mouse support on the Linux console)*
*For example, in a Debian-based distribution it would be the following
packages:*
* libglib2.0-dev
* libstdc++-6-dev
* libtinfo-dev
* libncurses5-dev
* libgpm-dev
How to compile FINAL CUT without gpm support?
---------------------------------------------
```bash
./configure --without-gpm
```
What do I need to compile the unit tests?
-----------------------------------------
You need the unit testing framework CppUnit.
How can I fix display problems?
-------------------------------
* Make sure that the environment variable TERM has the right
terminal name.
* Use the command "`msgcat --color=test`" to test whether the terminal
displays colors correctly in the terminal.
* If characters are not displayed in the right place on the screen,
it may help to disable cursor optimization for your program with
the parameter *--no-optimized-cursor*.
* If terminal detection did not work, it is useful to turn off the terminal
detection with the parameter *--no-terminal-detection*.
* If the color palette redefinition causes problems, you can switch off
the color mapping with the parameter *--no-color-change*.

31
doc/first-steps.md
View File

@ -9,7 +9,7 @@ How to use the library
At the beginning of this introduction to the Final Cut At the beginning of this introduction to the Final Cut
we will start with a small example. we will start with a small example.
It creates an empty 30×10 character dialog. The following example creates an empty 30×10 character dialog.
**File:** *dialog.cpp* **File:** *dialog.cpp*
```cpp ```cpp
@ -26,8 +26,8 @@ int main (int argc, char* argv[])
return app.exec(); return app.exec();
} }
``` ```
*(Note: Use mouse or <kbd>Shift</kbd>+<kbd>F10</kbd> or *(Note: You can close the dialog with the mouse,
<kbd>Ctrl</kbd>+<kbd>^</kbd> to close the dialog)* <kbd>Shift</kbd>+<kbd>F10</kbd> or <kbd>Ctrl</kbd>+<kbd>^</kbd>.)*
After entering the source code in *dialog.cpp* you can compile After entering the source code in *dialog.cpp* you can compile
@ -49,12 +49,11 @@ All final cut programs must include the *final.h* header.
```cpp ```cpp
finalcut::FApplication app(argc, argv); finalcut::FApplication app(argc, argv);
``` ```
In this line creates the `finalcut::FApplication` object `app` with This line creates the `finalcut::FApplication` object `app` with
the command line arguments `argc` and `argv`. This object manages the command line arguments `argc` and `argv`. This object manages
the application main event loop. It receives keyboard and mouse events the application main event loop. It receives keyboard and mouse events
and sends them to the target widgets. Before widgets can be created, and sends them to the target widgets. You must create an application
an application object must be created! Only one `finalcut::FApplication` object before you can create a widgets object.
object should be created.
The next line The next line
```cpp ```cpp
@ -72,16 +71,16 @@ The title bar of the dialog box gets the text "A dialog".
```cpp ```cpp
dialog.setGeometry (25, 5, 30, 10); dialog.setGeometry (25, 5, 30, 10);
``` ```
The dialog window geometry is set to a width of 30 characters and The dialog window gets a width of 30 and a height of 10 characters.
a height of 10 characters. The window in the terminal is positioned The position of the window in the terminal is at x=25 and
at the positions x=25 and y=5 (note: x=1 and y=1 represents the upper y=5 (note: x=1 and y=1 represents the upper left corner).
left corner).
```cpp ```cpp
app.setMainWidget(&dialog); app.setMainWidget(&dialog);
``` ```
The `dialog` object is selected as the main widget for the application. The `dialog` object was now selected as the main widget for the application.
When the user closes a main widget, the application will be closed. When you close the main widget, the entire application quits.
```cpp ```cpp
dialog.show(); dialog.show();
@ -94,7 +93,7 @@ if available) visible.
return app.exec(); return app.exec();
``` ```
The last line calls `exec()` to start the application and return The last line calls `exec()` to start the application and return
the result to the operating system. When the application starts, the result to the operating system. The started application enters
it enters the main event loop. This loop doesn't end until the the main event loop. This loop does not end until the window is
window/application is closed. not closed.

4
doc/framebuffer.txt
View File

@ -3,7 +3,7 @@ Framebuffer
The Final Cut determines the used number of bits per pixel (bpp) The Final Cut determines the used number of bits per pixel (bpp)
for Linux framebuffer console to determine whether 16 (or more) for Linux framebuffer console to determine whether 16 (or more)
different background colors can be displayed. Therefor your user different background colors can be displayed. Therefore your user
needs read-access to the framebuffer device (/dev/fb0 or /dev/fb/0). needs read-access to the framebuffer device (/dev/fb0 or /dev/fb/0).
You can check this with the following command: You can check this with the following command:
@ -14,7 +14,7 @@ the group "video". To do this, please enter the following command:
> sudo usermod -a -G video USERNAME > sudo usermod -a -G video USERNAME
You can check the group membership with the id command: You can check the group members with the id command:
> id > id

7
doc/readme.txt
View File

@ -7,7 +7,8 @@ support for creating a text-based user interface. The library supports
the programmer to develop an application for the text console. It allows the programmer to develop an application for the text console. It allows
the simultaneous handling of multiple text windows on the screen. the simultaneous handling of multiple text windows on the screen.
The C++ class design was inspired by the Qt framework. It provides The structure of the Qt framework was originally the inspiration for
common controls like dialog boxes, push buttons, check boxes, the C++ class design of FINAL CUT. It provides common controls like
radio buttons, input lines, list boxes, status bars and so on. dialog boxes, push buttons, check boxes, radio buttons, input lines,
list boxes, status bars and so on.

2
doc/terminfo-capabilities.sh
View File

@ -2,6 +2,6 @@
# set the xterm window title # set the xterm window title
TERMTITLE="infocmp: $TERM" TERMTITLE="infocmp: $TERM"
echo -ne "\033]0;${TERMTITLE}\007" echo -ne "\\033]0;${TERMTITLE}\\007"
infocmp -x | less infocmp -x | less

2
doc/terminfo-manual.sh
View File

@ -2,7 +2,7 @@
# set the xterm window title # set the xterm window title
TERMTITLE="man 5 terminfo" TERMTITLE="man 5 terminfo"
echo -ne "\033]0;${TERMTITLE}\007" echo -ne "\\033]0;${TERMTITLE}\\007"
man 5 terminfo man 5 terminfo

2
examples/Makefile.am
View File

@ -14,6 +14,7 @@ noinst_PROGRAMS = \
choice \ choice \
listbox \ listbox \
listview \ listview \
checklist \
treeview \ treeview \
opti-move \ opti-move \
termcap \ termcap \
@ -37,6 +38,7 @@ input_dialog_SOURCES = input-dialog.cpp
choice_SOURCES = choice.cpp choice_SOURCES = choice.cpp
listbox_SOURCES = listbox.cpp listbox_SOURCES = listbox.cpp
listview_SOURCES = listview.cpp listview_SOURCES = listview.cpp
checklist_SOURCES = checklist.cpp
treeview_SOURCES = treeview.cpp treeview_SOURCES = treeview.cpp
opti_move_SOURCES = opti-move.cpp opti_move_SOURCES = opti-move.cpp
string_operations_SOURCES = string-operations.cpp string_operations_SOURCES = string-operations.cpp

24
examples/calculator.cpp
View File

@ -90,7 +90,7 @@ void Button::setChecked (bool on)
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void Button::onKeyPress (finalcut::FKeyEvent* ev) void Button::onKeyPress (finalcut::FKeyEvent* ev)
{ {
int key = ev->key(); FKey key = ev->key();
// catch the enter key // catch the enter key
if ( key == finalcut::fc::Fkey_return if ( key == finalcut::fc::Fkey_return
@ -316,8 +316,7 @@ Calc::Calc (FWidget* parent)
//---------------------------------------------------------------------- //----------------------------------------------------------------------
Calc::~Calc() Calc::~Calc()
{ { }
}
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void Calc::drawDispay() void Calc::drawDispay()
@ -382,9 +381,9 @@ void Calc::drawDispay()
} }
else else
{ {
wchar_t vertical_and_right = wchar_t(finalcut::fc::BoxDrawingsVerticalAndRight); wchar_t vertical_and_right = wchar_t(finalcut::fc::BoxDrawingsVerticalAndRight);
wchar_t horizontal = wchar_t(finalcut::fc::BoxDrawingsHorizontal); wchar_t horizontal = wchar_t(finalcut::fc::BoxDrawingsHorizontal);
wchar_t vertical_and_left = wchar_t(finalcut::fc::BoxDrawingsVerticalAndLeft); wchar_t vertical_and_left = wchar_t(finalcut::fc::BoxDrawingsVerticalAndLeft);
finalcut::FString separator = finalcut::FString(vertical_and_right) finalcut::FString separator = finalcut::FString(vertical_and_right)
+ finalcut::FString(35, horizontal) + finalcut::FString(35, horizontal)
+ finalcut::FString(vertical_and_left); + finalcut::FString(vertical_and_left);
@ -417,7 +416,6 @@ void Calc::zero (lDouble&)
input += '0'; input += '0';
else else
input = '0'; input = '0';
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -551,8 +549,8 @@ void Calc::subtract (lDouble&)
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void Calc::multiply (lDouble&) void Calc::multiply (lDouble&)
{ {
if ( ! isOperatorKey(last_key) ) if ( ! isOperatorKey(last_key) )
calcInfixOperator(); calcInfixOperator();
setDisplay(a); setDisplay(a);
setInfixOperator('*'); setInfixOperator('*');
@ -735,7 +733,7 @@ void Calc::arcus (lDouble& x)
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void Calc::sine (lDouble& x) void Calc::sine (lDouble& x)
{ {
if ( hyperbolic_mode ) if ( hyperbolic_mode )
{ {
if ( arcus_mode ) if ( arcus_mode )
{ {
@ -831,6 +829,7 @@ void Calc::tangent (lDouble& x)
if ( arcus_mode ) if ( arcus_mode )
x = std::atan(x) * 180.0L / PI; x = std::atan(x) * 180.0L / PI;
else else
{
// Test if (x / 180) != 0 and x / 90 == 0 // Test if (x / 180) != 0 and x / 90 == 0
if ( std::fabs(std::fmod(x, 180.0L)) > LDBL_EPSILON if ( std::fabs(std::fmod(x, 180.0L)) > LDBL_EPSILON
&& std::fabs(std::fmod(x, 90.0L)) < LDBL_EPSILON ) && std::fabs(std::fmod(x, 90.0L)) < LDBL_EPSILON )
@ -839,6 +838,7 @@ void Calc::tangent (lDouble& x)
x = 0.0L; x = 0.0L;
else else
x = std::tan(x * PI / 180.0L); x = std::tan(x * PI / 180.0L);
}
} }
if ( errno == EDOM ) if ( errno == EDOM )
@ -1007,8 +1007,8 @@ void Calc::calcInfixOperator()
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void Calc::onKeyPress (finalcut::FKeyEvent* ev) void Calc::onKeyPress (finalcut::FKeyEvent* ev)
{ {
int len = int(input.getLength()); std::size_t len = input.getLength();
int key = ev->key(); FKey key = ev->key();
switch ( key ) switch ( key )
{ {

210
examples/checklist.cpp Normal file
View File

@ -0,0 +1,210 @@
/***********************************************************************
* checklist.cpp - Example for FListView widget with checkboxes *
* *
* This file is part of the Final Cut widget toolkit *
* *
* Copyright 2017-2018 Markus Gans *
* *
* The Final Cut is free software; you can redistribute it and/or *
* modify it under the terms of the GNU Lesser General Public License *
* as published by the Free Software Foundation; either version 3 of *
* the License, or (at your option) any later version. *
* *
* The Final Cut is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU Lesser General Public License for more details. *
* *
* You should have received a copy of the GNU Lesser General Public *
* License along with this program. If not, see *
* <http://www.gnu.org/licenses/>. *
***********************************************************************/
#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <final/final.h>
//----------------------------------------------------------------------
// class CheckList
//----------------------------------------------------------------------
#pragma pack(push)
#pragma pack(1)
class CheckList : public finalcut::FDialog
{
public:
// Constructor
explicit CheckList (finalcut::FWidget* = 0);
// Destructor
~CheckList();
private:
// Disable copy constructor
CheckList (const CheckList&);
// Disable assignment operator (=)
CheckList& operator = (const CheckList&);
// Method
void populate();
// Event handlers
virtual void onKeyPress (finalcut::FKeyEvent*);
virtual void onClose (finalcut::FCloseEvent*);
// Callback method
void cb_showList (finalcut::FWidget*, data_ptr);
// Data Members
finalcut::FListView listView;
finalcut::FStatusBar status_bar;
};
#pragma pack(pop)
//----------------------------------------------------------------------
CheckList::CheckList (finalcut::FWidget* parent)
: finalcut::FDialog(parent)
, listView(this)
, status_bar(this)
{
setText (L"Shopping list");
setShadow();
setGeometry (int(1 + (parent->getWidth() - 30) / 2), 5, 30, 13);
listView.ignorePadding();
listView.setGeometry (1, 2, getWidth(), getHeight() - 1);
// Add columns to the view
listView.addColumn ("Item");
listView.addColumn ("Priority", 12);
// Set the type of sorting
listView.setColumnSortType (1, finalcut::fc::by_name);
listView.setColumnSortType (2, finalcut::fc::by_name);
// Statusbar at the bottom
finalcut::FString separator;
separator << ' ' << wchar_t(finalcut::fc::BoxDrawingsVertical) << ' ';
listView.setStatusbarMessage ( finalcut::FString()
<< "<Q> exit" << separator
<< "<Space> select an item" << separator
<< "<Enter> see your pick list");
// Populate FListView with a list of items
populate();
// Add callback method
listView.addCallback
(
"clicked",
F_METHOD_CALLBACK (this, &CheckList::cb_showList)
);
}
//----------------------------------------------------------------------
CheckList::~CheckList() // destructor
{ }
//----------------------------------------------------------------------
void CheckList::populate()
{
std::string list[][2] =
{
{ "Milk", "Highest" },
{ "Cheese", "High" },
{ "Yoghurt", "Medium" },
{ "Bread", "Low" },
{ "Eggs", "High" },
{ "Toothpaste", "Medium" },
{ "Apples", "Lowest" },
{ "Bananas", "Medium" },
{ "Fish", "Medium" },
{ "Lemons", "Low" }
};
const int lastItem = int(sizeof(list) / sizeof(list[0])) - 1;
for (int i = 0; i <= lastItem; i++)
{
const finalcut::FStringList line (&list[i][0], &list[i][0] + 2);
finalcut::FObject::FObjectIterator iter = listView.insert (line);
finalcut::FListViewItem* item = \
static_cast<finalcut::FListViewItem*>(*iter);
item->setCheckable(true);
}
}
//----------------------------------------------------------------------
void CheckList::onKeyPress (finalcut::FKeyEvent* ev)
{
if ( ! ev )
return;
if ( ev->key() == 'q'
|| ev->key() == finalcut::fc::Fkey_escape
|| ev->key() == finalcut::fc::Fkey_escape_mintty )
{
close();
ev->accept();
}
else
finalcut::FDialog::onKeyPress(ev);
}
//----------------------------------------------------------------------
void CheckList::onClose (finalcut::FCloseEvent* ev)
{
finalcut::FApplication::closeConfirmationDialog (this, ev);
}
//----------------------------------------------------------------------
void CheckList::cb_showList (finalcut::FWidget*, data_ptr)
{
finalcut::FListViewIterator iter = listView.beginOfList();
finalcut::FString shopping_list;
while ( iter != listView.endOfList() )
{
const finalcut::FListViewItem* item = \
static_cast<finalcut::FListViewItem*>(*iter);
if ( item->isChecked() )
shopping_list << wchar_t(finalcut::fc::Bullet) << ' '
<< item->getText(1) << '\n';
++iter;
}
if ( shopping_list.isEmpty() )
return;
// Create and show tooltip for two seconds
finalcut::FToolTip picklist(this);
picklist.setText (shopping_list);
picklist.show();
sleep(2);
}
//----------------------------------------------------------------------
// main part
//----------------------------------------------------------------------
int main (int argc, char* argv[])
{
// Create the application object
finalcut::FApplication app(argc, argv);
// Create main dialog object
CheckList d(&app);
// Set dialog d as main widget
app.setMainWidget(&d);
// Show and start the application
d.show();
return app.exec();
}

1
examples/choice.cpp
View File

@ -20,6 +20,7 @@
* <http://www.gnu.org/licenses/>. * * <http://www.gnu.org/licenses/>. *
***********************************************************************/ ***********************************************************************/
#include <vector>
#include <final/final.h> #include <final/final.h>

2
examples/keyboard.cpp
View File

@ -53,7 +53,7 @@ Keyboard::Keyboard (finalcut::FWidget* parent)
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void Keyboard::onKeyPress (finalcut::FKeyEvent* ev) void Keyboard::onKeyPress (finalcut::FKeyEvent* ev)
{ {
int key_id = ev->key(); FKey key_id = ev->key();
bool is_last_line = false; bool is_last_line = false;
if ( getPrintPos().getY() == int(getDesktopHeight()) ) if ( getPrintPos().getY() == int(getDesktopHeight()) )

2
examples/listbox.cpp
View File

@ -35,7 +35,7 @@ static finalcut::FString* temp_str = 0;
// Function prototypes // Function prototypes
void doubleToItem ( finalcut::FListBoxItem& void doubleToItem ( finalcut::FListBoxItem&
, finalcut::FWidget::data_ptr container , finalcut::FWidget::data_ptr container
, int index) ; , int index);
finalcut::FString& doubleToString (std::list<double>::const_iterator iter); finalcut::FString& doubleToString (std::list<double>::const_iterator iter);
finalcut::FString& mapToString ( std::map<finalcut::FString finalcut::FString& mapToString ( std::map<finalcut::FString
, finalcut::FString>::const_iterator iter ); , finalcut::FString>::const_iterator iter );

7
examples/listview.cpp
View File

@ -70,7 +70,7 @@ Listview::Listview (finalcut::FWidget* parent)
, listView(this) , listView(this)
, Quit(this) , Quit(this)
{ {
// Create FListView object // Set FListView geometry
listView.setGeometry(2, 1, 33, 14); listView.setGeometry(2, 1, 33, 14);
// Add columns to the view // Add columns to the view
@ -94,9 +94,12 @@ Listview::Listview (finalcut::FWidget* parent)
// Sort in ascending order by the 1st column // Sort in ascending order by the 1st column
listView.setColumnSort (1, finalcut::fc::ascending); listView.setColumnSort (1, finalcut::fc::ascending);
// The sorting occurs later automatically at insert(). // Sorting follows later automatically on insert().
// Otherwise you could start the sorting directly with sort() // Otherwise you could start the sorting directly with sort()
// Allways show the sort indicator (▼/▲)
listView.hideSortIndicator(false);
// Populate FListView with a list of items // Populate FListView with a list of items
populate(); populate();

47
examples/mouse.cpp
View File

@ -40,8 +40,8 @@ class ColorChooser : public finalcut::FWidget
~ColorChooser(); ~ColorChooser();
// Accessors // Accessors
short getForeground(); FColor getForeground();
short getBackground(); FColor getBackground();
private: private:
// Disable copy constructor // Disable copy constructor
@ -56,8 +56,8 @@ class ColorChooser : public finalcut::FWidget
virtual void onMouseDown (finalcut::FMouseEvent*); virtual void onMouseDown (finalcut::FMouseEvent*);
// Data Members // Data Members
short fg_color; FColor fg_color;
short bg_color; FColor bg_color;
finalcut::FLabel headline; finalcut::FLabel headline;
}; };
#pragma pack(pop) #pragma pack(pop)
@ -75,8 +75,8 @@ ColorChooser::ColorChooser (finalcut::FWidget* parent)
if ( parent ) if ( parent )
{ {
short fg = parent->getForegroundColor(); FColor fg = parent->getForegroundColor();
short bg = parent->getBackgroundColor(); FColor bg = parent->getBackgroundColor();
setForegroundColor(fg); setForegroundColor(fg);
setBackgroundColor(bg); setBackgroundColor(bg);
headline.setForegroundColor(fg); headline.setForegroundColor(fg);
@ -112,9 +112,9 @@ void ColorChooser::onMouseDown (finalcut::FMouseEvent* ev)
if ( mouse_x >= xmin && mouse_x <= xmax && mouse_y == y ) if ( mouse_x >= xmin && mouse_x <= xmax && mouse_y == y )
{ {
if ( ev->getButton() == finalcut::fc::LeftButton ) if ( ev->getButton() == finalcut::fc::LeftButton )
bg_color = short(c); bg_color = FColor(c);
else if ( ev->getButton() == finalcut::fc::RightButton ) else if ( ev->getButton() == finalcut::fc::RightButton )
fg_color = short(c); fg_color = FColor(c);
redraw(); redraw();
emitCallback("clicked"); emitCallback("clicked");
@ -128,7 +128,7 @@ void ColorChooser::draw()
setColor(); setColor();
finalcut::FWidget::drawBorder (1, 2, 8, 11); finalcut::FWidget::drawBorder (1, 2, 8, 11);
for (short c = 0; c < 16; c++) for (FColor c = 0; c < 16; c++)
{ {
setPrintPos (2 + (c / 8) * 3, 3 + c % 8); setPrintPos (2 + (c / 8) * 3, 3 + c % 8);
@ -151,13 +151,13 @@ void ColorChooser::draw()
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline short ColorChooser::getForeground() inline FColor ColorChooser::getForeground()
{ {
return fg_color; return fg_color;
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline short ColorChooser::getBackground() inline FColor ColorChooser::getBackground()
{ {
return bg_color; return bg_color;
} }
@ -183,8 +183,8 @@ class Brushes : public finalcut::FWidget
wchar_t getBrush(); wchar_t getBrush();
// Mutators // Mutators
void setForeground (short); void setForeground (FColor);
void setBackground (short); void setBackground (FColor);
private: private:
// Disable copy constructor // Disable copy constructor
@ -200,8 +200,8 @@ class Brushes : public finalcut::FWidget
// Data Members // Data Members
wchar_t brush; wchar_t brush;
short fg_color; FColor fg_color;
short bg_color; FColor bg_color;
finalcut::FLabel headline; finalcut::FLabel headline;
}; };
#pragma pack(pop) #pragma pack(pop)
@ -220,8 +220,8 @@ Brushes::Brushes (finalcut::FWidget* parent)
if ( parent ) if ( parent )
{ {
short fg = parent->getForegroundColor(); FColor fg = parent->getForegroundColor();
short bg = parent->getBackgroundColor(); FColor bg = parent->getBackgroundColor();
setForegroundColor(fg); setForegroundColor(fg);
setBackgroundColor(bg); setBackgroundColor(bg);
headline.setForegroundColor(fg); headline.setForegroundColor(fg);
@ -291,13 +291,13 @@ inline wchar_t Brushes::getBrush()
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline void Brushes::setForeground (short color) inline void Brushes::setForeground (FColor color)
{ {
fg_color = color; fg_color = color;
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline void Brushes::setBackground (short color) inline void Brushes::setBackground (FColor color)
{ {
bg_color = color; bg_color = color;
} }
@ -372,7 +372,7 @@ MouseDraw::MouseDraw (finalcut::FWidget* parent)
brush.setPos (1, 12); brush.setPos (1, 12);
finalcut::FPoint no_shadow(0,0); finalcut::FPoint no_shadow(0, 0);
finalcut::FRect scroll_geometry(0, 0, 1, 1); finalcut::FRect scroll_geometry(0, 0, 1, 1);
createArea (scroll_geometry, no_shadow, canvas); createArea (scroll_geometry, no_shadow, canvas);
} }
@ -382,12 +382,13 @@ MouseDraw::~MouseDraw()
{ } { }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void MouseDraw::setGeometry (int x, int y, std::size_t w, std::size_t h, bool adjust) void MouseDraw::setGeometry ( int x, int y
, std::size_t w, std::size_t h
, bool adjust )
{ {
int old_w, old_h; int old_w, old_h;
finalcut::FDialog::setGeometry (x, y, w, h, adjust); finalcut::FDialog::setGeometry (x, y, w, h, adjust);
finalcut::FPoint no_shadow(0, 0);
finalcut::FPoint no_shadow(0,0);
finalcut::FRect scroll_geometry (0, 0, w - 11, h - 3); finalcut::FRect scroll_geometry (0, 0, w - 11, h - 3);
old_w = canvas->width; old_w = canvas->width;
old_h = canvas->height; old_h = canvas->height;

4
examples/opti-move.cpp
View File

@ -75,7 +75,7 @@ void term_boundaries (int& x, int& y)
if ( y < 0 ) if ( y < 0 )
y = 0; y = 0;
if ( x >= term_width ) if ( x >= term_width && term_width > 0 )
{ {
y += x / term_width; y += x / term_width;
x %= term_width; x %= term_width;
@ -157,7 +157,7 @@ int main (int argc, char* argv[])
finalcut::FString line(std::size_t(xmax) + 1, '-'); finalcut::FString line(std::size_t(xmax) + 1, '-');
// Place the cursor in the upper left corner // Place the cursor in the upper left corner
TermApp.setTermXY(0,0); TermApp.setTermXY(0, 0);
// Reset all terminal attributes // Reset all terminal attributes
TermApp.setNormal(); TermApp.setNormal();
// Clear the screen // Clear the screen

3
examples/scrollview.cpp
View File

@ -84,7 +84,8 @@ Scrollview::Scrollview (finalcut::FWidget* parent)
// Sets the navigation button geometry // Sets the navigation button geometry
go_east.setGeometry (1, 1, 5, 1); go_east.setGeometry (1, 1, 5, 1);
go_south.setGeometry (int(getScrollWidth()) - 5, 1, 5, 1); go_south.setGeometry (int(getScrollWidth()) - 5, 1, 5, 1);
go_west.setGeometry (int(getScrollWidth()) - 5, int(getScrollHeight()) - 2, 5, 1); go_west.setGeometry ( int(getScrollWidth()) - 5
, int(getScrollHeight()) - 2, 5, 1);
go_north.setGeometry (1, int(getScrollHeight()) - 2, 5, 1); go_north.setGeometry (1, int(getScrollHeight()) - 2, 5, 1);
// Add scroll function callbacks to the buttons // Add scroll function callbacks to the buttons

3
examples/string-operations.cpp
View File

@ -512,7 +512,8 @@ void convertToNumberExample()
try try
{ {
const double double_num = finalcut::FString("2.7182818284590452353").toDouble(); const double double_num = \
finalcut::FString("2.7182818284590452353").toDouble();
std::ios_base::fmtflags save_flags = std::cout.flags(); std::ios_base::fmtflags save_flags = std::cout.flags();
std::cout << " toDouble: " << std::setprecision(11) std::cout << " toDouble: " << std::setprecision(11)
<< double_num << std::endl; << double_num << std::endl;

32
examples/term-attributes.cpp
View File

@ -49,7 +49,7 @@ class AttribDlg : public finalcut::FDialog
void cb_back (finalcut::FWidget* = 0, data_ptr = 0); void cb_back (finalcut::FWidget* = 0, data_ptr = 0);
// Data Members // Data Members
short bgcolor; FColor bgcolor;
private: private:
// Disable copy constructor // Disable copy constructor
@ -130,10 +130,12 @@ void AttribDlg::cb_next (finalcut::FWidget*, data_ptr)
if ( isMonochron() ) if ( isMonochron() )
return; return;
bgcolor++; if ( bgcolor == FColor(getMaxColor() - 1) )
if ( bgcolor >= getMaxColor() )
bgcolor = finalcut::fc::Default; bgcolor = finalcut::fc::Default;
else if ( bgcolor == finalcut::fc::Default )
bgcolor = 0;
else
bgcolor++;
redraw(); redraw();
} }
@ -144,10 +146,12 @@ void AttribDlg::cb_back (finalcut::FWidget*, data_ptr)
if ( isMonochron() ) if ( isMonochron() )
return; return;
bgcolor--; if ( bgcolor == 0 )
bgcolor = finalcut::fc::Default;
if ( bgcolor < finalcut::fc::Default ) else if ( bgcolor == finalcut::fc::Default )
bgcolor = short(getMaxColor() - 1); bgcolor = FColor(getMaxColor() - 1);
else
bgcolor--;
redraw(); redraw();
} }
@ -165,8 +169,10 @@ void AttribDlg::adjustSize()
y = 1; y = 1;
setGeometry(x, y, 69, 21, false); setGeometry(x, y, 69, 21, false);
next_button.setGeometry(int(getWidth()) - 13, int(getHeight()) - 4, 10, 1, false); next_button.setGeometry ( int(getWidth()) - 13, int(getHeight()) - 4
back_button.setGeometry(int(getWidth()) - 25, int(getHeight()) - 4, 10, 1, false); , 10, 1, false );
back_button.setGeometry ( int(getWidth()) - 25, int(getHeight()) - 4
, 10, 1, false );
finalcut::FDialog::adjustSize(); finalcut::FDialog::adjustSize();
} }
@ -239,7 +245,7 @@ void AttribDemo::printColorLine()
{ {
AttribDlg* parent = static_cast<AttribDlg*>(getParent()); AttribDlg* parent = static_cast<AttribDlg*>(getParent());
for (short color = 0; color < colors; color++) for (FColor color = 0; color < colors; color++)
{ {
setColor (color, parent->bgcolor); setColor (color, parent->bgcolor);
print (" # "); print (" # ");
@ -254,7 +260,7 @@ void AttribDemo::printAltCharset()
if ( ! isMonochron() ) if ( ! isMonochron() )
setColor (wc.label_fg, wc.label_bg); setColor (wc.label_fg, wc.label_bg);
setPrintPos (1,1); setPrintPos (1, 1);
print("alternate charset: "); print("alternate charset: ");
if ( parent->bgcolor == finalcut::fc::Default ) if ( parent->bgcolor == finalcut::fc::Default )
@ -466,7 +472,7 @@ void AttribDemo::draw()
setColor(wc.label_fg, wc.label_bg); setColor(wc.label_fg, wc.label_bg);
setPrintPos (1, 15); setPrintPos (1, 15);
short bg = static_cast<AttribDlg*>(getParent())->bgcolor; FColor bg = static_cast<AttribDlg*>(getParent())->bgcolor;
print (" Background color:"); print (" Background color:");
if ( bg == finalcut::fc::Default ) if ( bg == finalcut::fc::Default )

17
examples/termcap.cpp
View File

@ -225,20 +225,22 @@ void tcapString (const std::string& name, const char cap_str[])
#if DEBUG #if DEBUG
void debug (finalcut::FApplication& TermApp) void debug (finalcut::FApplication& TermApp)
{ {
const finalcut::FString& ab_s = TermApp.getAnswerbackString(); finalcut::FTermDebugData& debug_data = TermApp.getFTermDebugData();
const finalcut::FString& sec_da = TermApp.getSecDAString(); const finalcut::FString& ab_s = debug_data.getAnswerbackString();
const finalcut::FString& sec_da = debug_data.getSecDAString();
std::cout << "\n.------------------- debug -------------------\r\n"; std::cout << "\n.------------------- debug -------------------\r\n";
#if defined(__linux__) #if defined(__linux__)
std::cout << "| Framebuffer bpp: " std::cout << "| Framebuffer bpp: "
<< TermApp.getFramebufferBpp() << "\r\n"; << debug_data.getFramebufferBpp() << "\r\n";
#endif #endif
std::cout << "| after init_256colorTerminal(): " std::cout << "| after init_256colorTerminal(): "
<< TermApp.getTermType_256color() << "\r\n"; << debug_data.getTermType_256color() << "\r\n";
std::cout << "| after parseAnswerbackMsg(): " std::cout << "| after parseAnswerbackMsg(): "
<< TermApp.getTermType_Answerback() << "\r\n"; << debug_data.getTermType_Answerback() << "\r\n";
std::cout << "| after parseSecDA(): " std::cout << "| after parseSecDA(): "
<< TermApp.getTermType_SecDA() << "\r\n"; << debug_data.getTermType_SecDA() << "\r\n";
if ( ! ab_s.isEmpty() ) if ( ! ab_s.isEmpty() )
tcapString ("| The answerback String", ab_s); tcapString ("| The answerback String", ab_s);
@ -247,7 +249,6 @@ void debug (finalcut::FApplication& TermApp)
tcapString ("| The SecDA String", sec_da); tcapString ("| The SecDA String", sec_da);
std::cout << "`------------------- debug -------------------\r\n"; std::cout << "`------------------- debug -------------------\r\n";
} }
#else #else
void debug (finalcut::FApplication&) void debug (finalcut::FApplication&)
@ -260,6 +261,8 @@ void booleans()
std::cout << "\r\n[Booleans]\r\n"; std::cout << "\r\n[Booleans]\r\n";
tcapBoolean ( "background_color_erase" tcapBoolean ( "background_color_erase"
, finalcut::FTermcap::background_color_erase ); , finalcut::FTermcap::background_color_erase );
tcapBoolean ( "can_change_color_palette"
, finalcut::FTermcap::can_change_color_palette );
tcapBoolean ( "automatic_left_margin" tcapBoolean ( "automatic_left_margin"
, finalcut::FTermcap::automatic_left_margin ); , finalcut::FTermcap::automatic_left_margin );
tcapBoolean ( "automatic_right_margin" tcapBoolean ( "automatic_right_margin"

4
examples/timer.cpp
View File

@ -59,7 +59,7 @@ Timer::Timer (finalcut::FWidget* parent)
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void Timer::draw() void Timer::draw()
{ {
setPrintPos (1,1); setPrintPos (1, 1);
print() << "---------------\n" print() << "---------------\n"
<< "Press Q to quit\n" << "Press Q to quit\n"
<< "---------------\n"; << "---------------\n";
@ -75,7 +75,7 @@ void Timer::onTimer (finalcut::FTimerEvent* ev)
if ( getPrintPos().getY() == int(getDesktopHeight()) ) if ( getPrintPos().getY() == int(getDesktopHeight()) )
is_last_line = true; is_last_line = true;
setColor (short(1 + timer_id), finalcut::fc::Default); setColor (FColor(1 + timer_id), finalcut::fc::Default);
print() << "Timer event, id " << timer_id << '\n'; print() << "Timer event, id " << timer_id << '\n';
if ( is_last_line ) if ( is_last_line )

86
examples/treeview.cpp
View File

@ -28,6 +28,81 @@
#include <final/final.h> #include <final/final.h>
// Function prototypes
long StringToLong (const finalcut::FString&);
bool sortAscending (const finalcut::FObject*, const finalcut::FObject*);
bool sortDescending (const finalcut::FObject*, const finalcut::FObject*);
// non-member functions
//----------------------------------------------------------------------
long StringToLong (const finalcut::FString& str)
{
finalcut::FString NumString = str;
NumString = NumString.replace(",", "");
NumString = NumString.replace('.', "");
long number = NumString.toLong();
return number;
}
//----------------------------------------------------------------------
bool sortAscending ( const finalcut::FObject* lhs
, const finalcut::FObject* rhs )
{
const finalcut::FListViewItem* l_item = static_cast<const finalcut::FListViewItem*>(lhs);
const finalcut::FListViewItem* r_item = static_cast<const finalcut::FListViewItem*>(rhs);
const int column = l_item->getSortColumn();
switch ( column )
{
case 2:
{
const long l_number = StringToLong(l_item->getText(column));
const long r_number = StringToLong(r_item->getText(column));
return bool( l_number < r_number ); // lhs < rhs
}
case 3:
{
std::setlocale(LC_NUMERIC, "C");
const double l_number = l_item->getText(column).toDouble();
const double r_number = r_item->getText(column).toDouble();
return bool( l_number < r_number ); // lhs < rhs
}
}
return false;
}
//----------------------------------------------------------------------
bool sortDescending ( const finalcut::FObject* lhs
, const finalcut::FObject* rhs )
{
const finalcut::FListViewItem* l_item = static_cast<const finalcut::FListViewItem*>(lhs);
const finalcut::FListViewItem* r_item = static_cast<const finalcut::FListViewItem*>(rhs);
const int column = l_item->getSortColumn();
switch ( column )
{
case 2:
{
const long l_number = StringToLong(l_item->getText(column));
const long r_number = StringToLong(r_item->getText(column));
return bool( l_number > r_number ); // lhs > rhs
}
case 3:
{
std::setlocale(LC_NUMERIC, "C");
const double l_number = l_item->getText(column).toDouble();
const double r_number = r_item->getText(column).toDouble();
return bool( l_number > r_number ); // lhs > rhs
}
}
return false;
}
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// class Treeview // class Treeview
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -55,7 +130,7 @@ class Treeview : public finalcut::FDialog
// Methods // Methods
virtual void adjustSize(); virtual void adjustSize();
// Event handlers // Event handler
void onClose (finalcut::FCloseEvent*); void onClose (finalcut::FCloseEvent*);
// Data Members // Data Members
@ -227,7 +302,7 @@ Treeview::Treeview (finalcut::FWidget* parent)
, listView(this) , listView(this)
, Quit(this) , Quit(this)
{ {
// Create FListView object // Set FListView geometry
listView.setGeometry(2, 1, 53, 14); listView.setGeometry(2, 1, 53, 14);
// Add columns to the view // Add columns to the view
@ -239,6 +314,13 @@ Treeview::Treeview (finalcut::FWidget* parent)
listView.setColumnAlignment (2, finalcut::fc::alignRight); listView.setColumnAlignment (2, finalcut::fc::alignRight);
listView.setColumnAlignment (3, finalcut::fc::alignRight); listView.setColumnAlignment (3, finalcut::fc::alignRight);
// Set the type of sorting
listView.setColumnSortType (1, finalcut::fc::by_name);
listView.setColumnSortType (2, finalcut::fc::user_defined);
listView.setColumnSortType (3, finalcut::fc::user_defined);
listView.setUserAscendingCompare(sortAscending);
listView.setUserDescendingCompare(sortDescending);
// Activate tree view // Activate tree view
listView.setTreeView(); listView.setTreeView();

2
examples/ui.cpp
View File

@ -1052,7 +1052,7 @@ int main (int argc, char* argv[])
app.setTermTitle (title); app.setTermTitle (title);
// Force vt100 encoding // Force vt100 encoding
//app.setEncoding("VT100"); //app.setEncoding(finalcut::fc::VT100);
// Sets the terminal size to 94×30 // Sets the terminal size to 94×30
//app.setTermSize(94,30); //app.setTermSize(94,30);

2
examples/windows.cpp
View File

@ -285,7 +285,7 @@ Window::Window (finalcut::FWidget* parent)
for (int n = 1; n <= 6; n++) for (int n = 1; n <= 6; n++)
{ {
win_data* win_dat = new win_data; win_data* win_dat = new win_data;
win_dat->title.sprintf("Window %d", n); win_dat->title.sprintf("Window %1d", n);
windows.push_back(win_dat); windows.push_back(win_dat);
} }
} }

2520
m4/libtool.m4 vendored
View File

File diff suppressed because it is too large Load Diff

127
m4/ltoptions.m4 vendored
View File

@ -1,14 +1,14 @@
# Helper functions for option handling. -*- Autoconf -*- # Helper functions for option handling. -*- Autoconf -*-
# #
# Copyright (C) 2004, 2005, 2007, 2008, 2009 Free Software Foundation, # Copyright (C) 2004-2005, 2007-2009, 2011-2015 Free Software
# Inc. # Foundation, Inc.
# Written by Gary V. Vaughan, 2004 # Written by Gary V. Vaughan, 2004
# #
# This file is free software; the Free Software Foundation gives # This file is free software; the Free Software Foundation gives
# unlimited permission to copy and/or distribute it, with or without # unlimited permission to copy and/or distribute it, with or without
# modifications, as long as this notice is preserved. # modifications, as long as this notice is preserved.
# serial 7 ltoptions.m4 # serial 8 ltoptions.m4
# This is to help aclocal find these macros, as it can't see m4_define. # This is to help aclocal find these macros, as it can't see m4_define.
AC_DEFUN([LTOPTIONS_VERSION], [m4_if([1])]) AC_DEFUN([LTOPTIONS_VERSION], [m4_if([1])])
@ -29,7 +29,7 @@ m4_define([_LT_SET_OPTION],
[m4_define(_LT_MANGLE_OPTION([$1], [$2]))dnl [m4_define(_LT_MANGLE_OPTION([$1], [$2]))dnl
m4_ifdef(_LT_MANGLE_DEFUN([$1], [$2]), m4_ifdef(_LT_MANGLE_DEFUN([$1], [$2]),
_LT_MANGLE_DEFUN([$1], [$2]), _LT_MANGLE_DEFUN([$1], [$2]),
[m4_warning([Unknown $1 option `$2'])])[]dnl [m4_warning([Unknown $1 option '$2'])])[]dnl
]) ])
@ -75,13 +75,15 @@ m4_if([$1],[LT_INIT],[
dnl dnl
dnl If no reference was made to various pairs of opposing options, then dnl If no reference was made to various pairs of opposing options, then
dnl we run the default mode handler for the pair. For example, if neither dnl we run the default mode handler for the pair. For example, if neither
dnl `shared' nor `disable-shared' was passed, we enable building of shared dnl 'shared' nor 'disable-shared' was passed, we enable building of shared
dnl archives by default: dnl archives by default:
_LT_UNLESS_OPTIONS([LT_INIT], [shared disable-shared], [_LT_ENABLE_SHARED]) _LT_UNLESS_OPTIONS([LT_INIT], [shared disable-shared], [_LT_ENABLE_SHARED])
_LT_UNLESS_OPTIONS([LT_INIT], [static disable-static], [_LT_ENABLE_STATIC]) _LT_UNLESS_OPTIONS([LT_INIT], [static disable-static], [_LT_ENABLE_STATIC])
_LT_UNLESS_OPTIONS([LT_INIT], [pic-only no-pic], [_LT_WITH_PIC]) _LT_UNLESS_OPTIONS([LT_INIT], [pic-only no-pic], [_LT_WITH_PIC])
_LT_UNLESS_OPTIONS([LT_INIT], [fast-install disable-fast-install], _LT_UNLESS_OPTIONS([LT_INIT], [fast-install disable-fast-install],
[_LT_ENABLE_FAST_INSTALL]) [_LT_ENABLE_FAST_INSTALL])
_LT_UNLESS_OPTIONS([LT_INIT], [aix-soname=aix aix-soname=both aix-soname=svr4],
[_LT_WITH_AIX_SONAME([aix])])
]) ])
])# _LT_SET_OPTIONS ])# _LT_SET_OPTIONS
@ -112,7 +114,7 @@ AU_DEFUN([AC_LIBTOOL_DLOPEN],
[_LT_SET_OPTION([LT_INIT], [dlopen]) [_LT_SET_OPTION([LT_INIT], [dlopen])
AC_DIAGNOSE([obsolete], AC_DIAGNOSE([obsolete],
[$0: Remove this warning and the call to _LT_SET_OPTION when you [$0: Remove this warning and the call to _LT_SET_OPTION when you
put the `dlopen' option into LT_INIT's first parameter.]) put the 'dlopen' option into LT_INIT's first parameter.])
]) ])
dnl aclocal-1.4 backwards compatibility: dnl aclocal-1.4 backwards compatibility:
@ -148,7 +150,7 @@ AU_DEFUN([AC_LIBTOOL_WIN32_DLL],
_LT_SET_OPTION([LT_INIT], [win32-dll]) _LT_SET_OPTION([LT_INIT], [win32-dll])
AC_DIAGNOSE([obsolete], AC_DIAGNOSE([obsolete],
[$0: Remove this warning and the call to _LT_SET_OPTION when you [$0: Remove this warning and the call to _LT_SET_OPTION when you
put the `win32-dll' option into LT_INIT's first parameter.]) put the 'win32-dll' option into LT_INIT's first parameter.])
]) ])
dnl aclocal-1.4 backwards compatibility: dnl aclocal-1.4 backwards compatibility:
@ -157,9 +159,9 @@ dnl AC_DEFUN([AC_LIBTOOL_WIN32_DLL], [])
# _LT_ENABLE_SHARED([DEFAULT]) # _LT_ENABLE_SHARED([DEFAULT])
# ---------------------------- # ----------------------------
# implement the --enable-shared flag, and supports the `shared' and # implement the --enable-shared flag, and supports the 'shared' and
# `disable-shared' LT_INIT options. # 'disable-shared' LT_INIT options.
# DEFAULT is either `yes' or `no'. If omitted, it defaults to `yes'. # DEFAULT is either 'yes' or 'no'. If omitted, it defaults to 'yes'.
m4_define([_LT_ENABLE_SHARED], m4_define([_LT_ENABLE_SHARED],
[m4_define([_LT_ENABLE_SHARED_DEFAULT], [m4_if($1, no, no, yes)])dnl [m4_define([_LT_ENABLE_SHARED_DEFAULT], [m4_if($1, no, no, yes)])dnl
AC_ARG_ENABLE([shared], AC_ARG_ENABLE([shared],
@ -172,14 +174,14 @@ AC_ARG_ENABLE([shared],
*) *)
enable_shared=no enable_shared=no
# Look at the argument we got. We use all the common list separators. # Look at the argument we got. We use all the common list separators.
lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
for pkg in $enableval; do for pkg in $enableval; do
IFS="$lt_save_ifs" IFS=$lt_save_ifs
if test "X$pkg" = "X$p"; then if test "X$pkg" = "X$p"; then
enable_shared=yes enable_shared=yes
fi fi
done done
IFS="$lt_save_ifs" IFS=$lt_save_ifs
;; ;;
esac], esac],
[enable_shared=]_LT_ENABLE_SHARED_DEFAULT) [enable_shared=]_LT_ENABLE_SHARED_DEFAULT)
@ -211,9 +213,9 @@ dnl AC_DEFUN([AM_DISABLE_SHARED], [])
# _LT_ENABLE_STATIC([DEFAULT]) # _LT_ENABLE_STATIC([DEFAULT])
# ---------------------------- # ----------------------------
# implement the --enable-static flag, and support the `static' and # implement the --enable-static flag, and support the 'static' and
# `disable-static' LT_INIT options. # 'disable-static' LT_INIT options.
# DEFAULT is either `yes' or `no'. If omitted, it defaults to `yes'. # DEFAULT is either 'yes' or 'no'. If omitted, it defaults to 'yes'.
m4_define([_LT_ENABLE_STATIC], m4_define([_LT_ENABLE_STATIC],
[m4_define([_LT_ENABLE_STATIC_DEFAULT], [m4_if($1, no, no, yes)])dnl [m4_define([_LT_ENABLE_STATIC_DEFAULT], [m4_if($1, no, no, yes)])dnl
AC_ARG_ENABLE([static], AC_ARG_ENABLE([static],
@ -226,14 +228,14 @@ AC_ARG_ENABLE([static],
*) *)
enable_static=no enable_static=no
# Look at the argument we got. We use all the common list separators. # Look at the argument we got. We use all the common list separators.
lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
for pkg in $enableval; do for pkg in $enableval; do
IFS="$lt_save_ifs" IFS=$lt_save_ifs
if test "X$pkg" = "X$p"; then if test "X$pkg" = "X$p"; then
enable_static=yes enable_static=yes
fi fi
done done
IFS="$lt_save_ifs" IFS=$lt_save_ifs
;; ;;
esac], esac],
[enable_static=]_LT_ENABLE_STATIC_DEFAULT) [enable_static=]_LT_ENABLE_STATIC_DEFAULT)
@ -265,9 +267,9 @@ dnl AC_DEFUN([AM_DISABLE_STATIC], [])
# _LT_ENABLE_FAST_INSTALL([DEFAULT]) # _LT_ENABLE_FAST_INSTALL([DEFAULT])
# ---------------------------------- # ----------------------------------
# implement the --enable-fast-install flag, and support the `fast-install' # implement the --enable-fast-install flag, and support the 'fast-install'
# and `disable-fast-install' LT_INIT options. # and 'disable-fast-install' LT_INIT options.
# DEFAULT is either `yes' or `no'. If omitted, it defaults to `yes'. # DEFAULT is either 'yes' or 'no'. If omitted, it defaults to 'yes'.
m4_define([_LT_ENABLE_FAST_INSTALL], m4_define([_LT_ENABLE_FAST_INSTALL],
[m4_define([_LT_ENABLE_FAST_INSTALL_DEFAULT], [m4_if($1, no, no, yes)])dnl [m4_define([_LT_ENABLE_FAST_INSTALL_DEFAULT], [m4_if($1, no, no, yes)])dnl
AC_ARG_ENABLE([fast-install], AC_ARG_ENABLE([fast-install],
@ -280,14 +282,14 @@ AC_ARG_ENABLE([fast-install],
*) *)
enable_fast_install=no enable_fast_install=no
# Look at the argument we got. We use all the common list separators. # Look at the argument we got. We use all the common list separators.
lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
for pkg in $enableval; do for pkg in $enableval; do
IFS="$lt_save_ifs" IFS=$lt_save_ifs
if test "X$pkg" = "X$p"; then if test "X$pkg" = "X$p"; then
enable_fast_install=yes enable_fast_install=yes
fi fi
done done
IFS="$lt_save_ifs" IFS=$lt_save_ifs
;; ;;
esac], esac],
[enable_fast_install=]_LT_ENABLE_FAST_INSTALL_DEFAULT) [enable_fast_install=]_LT_ENABLE_FAST_INSTALL_DEFAULT)
@ -304,14 +306,14 @@ AU_DEFUN([AC_ENABLE_FAST_INSTALL],
[_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[fast-install]) [_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[fast-install])
AC_DIAGNOSE([obsolete], AC_DIAGNOSE([obsolete],
[$0: Remove this warning and the call to _LT_SET_OPTION when you put [$0: Remove this warning and the call to _LT_SET_OPTION when you put
the `fast-install' option into LT_INIT's first parameter.]) the 'fast-install' option into LT_INIT's first parameter.])
]) ])
AU_DEFUN([AC_DISABLE_FAST_INSTALL], AU_DEFUN([AC_DISABLE_FAST_INSTALL],
[_LT_SET_OPTION([LT_INIT], [disable-fast-install]) [_LT_SET_OPTION([LT_INIT], [disable-fast-install])
AC_DIAGNOSE([obsolete], AC_DIAGNOSE([obsolete],
[$0: Remove this warning and the call to _LT_SET_OPTION when you put [$0: Remove this warning and the call to _LT_SET_OPTION when you put
the `disable-fast-install' option into LT_INIT's first parameter.]) the 'disable-fast-install' option into LT_INIT's first parameter.])
]) ])
dnl aclocal-1.4 backwards compatibility: dnl aclocal-1.4 backwards compatibility:
@ -319,11 +321,64 @@ dnl AC_DEFUN([AC_ENABLE_FAST_INSTALL], [])
dnl AC_DEFUN([AM_DISABLE_FAST_INSTALL], []) dnl AC_DEFUN([AM_DISABLE_FAST_INSTALL], [])
# _LT_WITH_AIX_SONAME([DEFAULT])
# ----------------------------------
# implement the --with-aix-soname flag, and support the `aix-soname=aix'
# and `aix-soname=both' and `aix-soname=svr4' LT_INIT options. DEFAULT
# is either `aix', `both' or `svr4'. If omitted, it defaults to `aix'.
m4_define([_LT_WITH_AIX_SONAME],
[m4_define([_LT_WITH_AIX_SONAME_DEFAULT], [m4_if($1, svr4, svr4, m4_if($1, both, both, aix))])dnl
shared_archive_member_spec=
case $host,$enable_shared in
power*-*-aix[[5-9]]*,yes)
AC_MSG_CHECKING([which variant of shared library versioning to provide])
AC_ARG_WITH([aix-soname],
[AS_HELP_STRING([--with-aix-soname=aix|svr4|both],
[shared library versioning (aka "SONAME") variant to provide on AIX, @<:@default=]_LT_WITH_AIX_SONAME_DEFAULT[@:>@.])],
[case $withval in
aix|svr4|both)
;;
*)
AC_MSG_ERROR([Unknown argument to --with-aix-soname])
;;
esac
lt_cv_with_aix_soname=$with_aix_soname],
[AC_CACHE_VAL([lt_cv_with_aix_soname],
[lt_cv_with_aix_soname=]_LT_WITH_AIX_SONAME_DEFAULT)
with_aix_soname=$lt_cv_with_aix_soname])
AC_MSG_RESULT([$with_aix_soname])
if test aix != "$with_aix_soname"; then
# For the AIX way of multilib, we name the shared archive member
# based on the bitwidth used, traditionally 'shr.o' or 'shr_64.o',
# and 'shr.imp' or 'shr_64.imp', respectively, for the Import File.
# Even when GNU compilers ignore OBJECT_MODE but need '-maix64' flag,
# the AIX toolchain works better with OBJECT_MODE set (default 32).
if test 64 = "${OBJECT_MODE-32}"; then
shared_archive_member_spec=shr_64
else
shared_archive_member_spec=shr
fi
fi
;;
*)
with_aix_soname=aix
;;
esac
_LT_DECL([], [shared_archive_member_spec], [0],
[Shared archive member basename, for filename based shared library versioning on AIX])dnl
])# _LT_WITH_AIX_SONAME
LT_OPTION_DEFINE([LT_INIT], [aix-soname=aix], [_LT_WITH_AIX_SONAME([aix])])
LT_OPTION_DEFINE([LT_INIT], [aix-soname=both], [_LT_WITH_AIX_SONAME([both])])
LT_OPTION_DEFINE([LT_INIT], [aix-soname=svr4], [_LT_WITH_AIX_SONAME([svr4])])
# _LT_WITH_PIC([MODE]) # _LT_WITH_PIC([MODE])
# -------------------- # --------------------
# implement the --with-pic flag, and support the `pic-only' and `no-pic' # implement the --with-pic flag, and support the 'pic-only' and 'no-pic'
# LT_INIT options. # LT_INIT options.
# MODE is either `yes' or `no'. If omitted, it defaults to `both'. # MODE is either 'yes' or 'no'. If omitted, it defaults to 'both'.
m4_define([_LT_WITH_PIC], m4_define([_LT_WITH_PIC],
[AC_ARG_WITH([pic], [AC_ARG_WITH([pic],
[AS_HELP_STRING([--with-pic@<:@=PKGS@:>@], [AS_HELP_STRING([--with-pic@<:@=PKGS@:>@],
@ -334,19 +389,17 @@ m4_define([_LT_WITH_PIC],
*) *)
pic_mode=default pic_mode=default
# Look at the argument we got. We use all the common list separators. # Look at the argument we got. We use all the common list separators.
lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
for lt_pkg in $withval; do for lt_pkg in $withval; do
IFS="$lt_save_ifs" IFS=$lt_save_ifs
if test "X$lt_pkg" = "X$lt_p"; then if test "X$lt_pkg" = "X$lt_p"; then
pic_mode=yes pic_mode=yes
fi fi
done done
IFS="$lt_save_ifs" IFS=$lt_save_ifs
;; ;;
esac], esac],
[pic_mode=default]) [pic_mode=m4_default([$1], [default])])
test -z "$pic_mode" && pic_mode=m4_default([$1], [default])
_LT_DECL([], [pic_mode], [0], [What type of objects to build])dnl _LT_DECL([], [pic_mode], [0], [What type of objects to build])dnl
])# _LT_WITH_PIC ])# _LT_WITH_PIC
@ -359,7 +412,7 @@ AU_DEFUN([AC_LIBTOOL_PICMODE],
[_LT_SET_OPTION([LT_INIT], [pic-only]) [_LT_SET_OPTION([LT_INIT], [pic-only])
AC_DIAGNOSE([obsolete], AC_DIAGNOSE([obsolete],
[$0: Remove this warning and the call to _LT_SET_OPTION when you [$0: Remove this warning and the call to _LT_SET_OPTION when you
put the `pic-only' option into LT_INIT's first parameter.]) put the 'pic-only' option into LT_INIT's first parameter.])
]) ])
dnl aclocal-1.4 backwards compatibility: dnl aclocal-1.4 backwards compatibility:

7
m4/ltsugar.m4 vendored
View File

@ -1,6 +1,7 @@
# ltsugar.m4 -- libtool m4 base layer. -*-Autoconf-*- # ltsugar.m4 -- libtool m4 base layer. -*-Autoconf-*-
# #
# Copyright (C) 2004, 2005, 2007, 2008 Free Software Foundation, Inc. # Copyright (C) 2004-2005, 2007-2008, 2011-2015 Free Software
# Foundation, Inc.
# Written by Gary V. Vaughan, 2004 # Written by Gary V. Vaughan, 2004
# #
# This file is free software; the Free Software Foundation gives # This file is free software; the Free Software Foundation gives
@ -33,7 +34,7 @@ m4_define([_lt_join],
# ------------ # ------------
# Manipulate m4 lists. # Manipulate m4 lists.
# These macros are necessary as long as will still need to support # These macros are necessary as long as will still need to support
# Autoconf-2.59 which quotes differently. # Autoconf-2.59, which quotes differently.
m4_define([lt_car], [[$1]]) m4_define([lt_car], [[$1]])
m4_define([lt_cdr], m4_define([lt_cdr],
[m4_if([$#], 0, [m4_fatal([$0: cannot be called without arguments])], [m4_if([$#], 0, [m4_fatal([$0: cannot be called without arguments])],
@ -44,7 +45,7 @@ m4_define([lt_unquote], $1)
# lt_append(MACRO-NAME, STRING, [SEPARATOR]) # lt_append(MACRO-NAME, STRING, [SEPARATOR])
# ------------------------------------------ # ------------------------------------------
# Redefine MACRO-NAME to hold its former content plus `SEPARATOR'`STRING'. # Redefine MACRO-NAME to hold its former content plus 'SEPARATOR''STRING'.
# Note that neither SEPARATOR nor STRING are expanded; they are appended # Note that neither SEPARATOR nor STRING are expanded; they are appended
# to MACRO-NAME as is (leaving the expansion for when MACRO-NAME is invoked). # to MACRO-NAME as is (leaving the expansion for when MACRO-NAME is invoked).
# No SEPARATOR is output if MACRO-NAME was previously undefined (different # No SEPARATOR is output if MACRO-NAME was previously undefined (different

12
m4/ltversion.m4 vendored
View File

@ -1,6 +1,6 @@
# ltversion.m4 -- version numbers -*- Autoconf -*- # ltversion.m4 -- version numbers -*- Autoconf -*-
# #
# Copyright (C) 2004 Free Software Foundation, Inc. # Copyright (C) 2004, 2011-2015 Free Software Foundation, Inc.
# Written by Scott James Remnant, 2004 # Written by Scott James Remnant, 2004
# #
# This file is free software; the Free Software Foundation gives # This file is free software; the Free Software Foundation gives
@ -9,15 +9,15 @@
# @configure_input@ # @configure_input@
# serial 3337 ltversion.m4 # serial 4179 ltversion.m4
# This file is part of GNU Libtool # This file is part of GNU Libtool
m4_define([LT_PACKAGE_VERSION], [2.4.2]) m4_define([LT_PACKAGE_VERSION], [2.4.6])
m4_define([LT_PACKAGE_REVISION], [1.3337]) m4_define([LT_PACKAGE_REVISION], [2.4.6])
AC_DEFUN([LTVERSION_VERSION], AC_DEFUN([LTVERSION_VERSION],
[macro_version='2.4.2' [macro_version='2.4.6'
macro_revision='1.3337' macro_revision='2.4.6'
_LT_DECL(, macro_version, 0, [Which release of libtool.m4 was used?]) _LT_DECL(, macro_version, 0, [Which release of libtool.m4 was used?])
_LT_DECL(, macro_revision, 0) _LT_DECL(, macro_revision, 0)
]) ])

5
m4/lt~obsolete.m4 vendored
View File

@ -1,6 +1,7 @@
# lt~obsolete.m4 -- aclocal satisfying obsolete definitions. -*-Autoconf-*- # lt~obsolete.m4 -- aclocal satisfying obsolete definitions. -*-Autoconf-*-
# #
# Copyright (C) 2004, 2005, 2007, 2009 Free Software Foundation, Inc. # Copyright (C) 2004-2005, 2007, 2009, 2011-2015 Free Software
# Foundation, Inc.
# Written by Scott James Remnant, 2004. # Written by Scott James Remnant, 2004.
# #
# This file is free software; the Free Software Foundation gives # This file is free software; the Free Software Foundation gives
@ -11,7 +12,7 @@
# These exist entirely to fool aclocal when bootstrapping libtool. # These exist entirely to fool aclocal when bootstrapping libtool.
# #
# In the past libtool.m4 has provided macros via AC_DEFUN (or AU_DEFUN) # In the past libtool.m4 has provided macros via AC_DEFUN (or AU_DEFUN),
# which have later been changed to m4_define as they aren't part of the # which have later been changed to m4_define as they aren't part of the
# exported API, or moved to Autoconf or Automake where they belong. # exported API, or moved to Autoconf or Automake where they belong.
# #

2
src/Makefile.am
View File

@ -115,9 +115,11 @@ finalcutinclude_HEADERS = \
include/final/ftermfreebsd.h \ include/final/ftermfreebsd.h \
include/final/ftermopenbsd.h \ include/final/ftermopenbsd.h \
include/final/ftermlinux.h \ include/final/ftermlinux.h \
include/final/ftermdebugdata.h \
include/final/ftermdetection.h \ include/final/ftermdetection.h \
include/final/ftermios.h \ include/final/ftermios.h \
include/final/fterm.h \ include/final/fterm.h \
include/final/ftermdata.h \
include/final/fvterm.h \ include/final/fvterm.h \
include/final/ftextview.h \ include/final/ftextview.h \
include/final/ftogglebutton.h \ include/final/ftogglebutton.h \

1
src/Makefile.clang
View File

@ -45,6 +45,7 @@ INCLUDE_HEADERS = \
fkeyboard.h \ fkeyboard.h \
ftermcap.h \ ftermcap.h \
fterm.h \ fterm.h \
ftermdata.h \
ftermios.h \ ftermios.h \
ftermdetection.h \ ftermdetection.h \
ftermcapquirks.h \ ftermcapquirks.h \

1
src/Makefile.gcc
View File

@ -45,6 +45,7 @@ INCLUDE_HEADERS = \
fkeyboard.h \ fkeyboard.h \
ftermcap.h \ ftermcap.h \
fterm.h \ fterm.h \
ftermdata.h \
ftermios.h \ ftermios.h \
ftermdetection.h \ ftermdetection.h \
ftermcapquirks.h \ ftermcapquirks.h \

42
src/fapplication.cpp
View File

@ -63,7 +63,7 @@ FApplication::eventQueue* FApplication::event_queue = 0;
FApplication::FApplication ( const int& _argc FApplication::FApplication ( const int& _argc
, char* _argv[] , char* _argv[]
, bool disable_alt_screen ) , bool disable_alt_screen )
: FWidget(processParameters(_argc,_argv), disable_alt_screen) : FWidget(processParameters(_argc, _argv), disable_alt_screen)
, app_argc(_argc) , app_argc(_argc)
, app_argv(_argv) , app_argv(_argv)
, key_timeout(100000) // 100 ms , key_timeout(100000) // 100 ms
@ -188,7 +188,7 @@ bool FApplication::sendEvent ( const FObject* receiver
// block events for widgets in non modal windows // block events for widgets in non modal windows
if ( window if ( window
&& (window->getFlags() & fc::modal) == 0 && ! window->getFlags().modal
&& ! window->isMenuWidget() ) && ! window->isMenuWidget() )
{ {
switch ( event->type() ) switch ( event->type() )
@ -302,7 +302,7 @@ FWidget* FApplication::processParameters (const int& argc, char* argv[])
showParameterUsage(); showParameterUsage();
} }
init_values.setDefault(); getInitValues().setDefault();
cmd_options (argc, argv); cmd_options (argc, argv);
return 0; return 0;
} }
@ -449,13 +449,13 @@ void FApplication::cmd_options (const int& argc, char* argv[])
encoding = encoding.toLower(); encoding = encoding.toLower();
if ( encoding.includes("utf8") ) if ( encoding.includes("utf8") )
init_values.encoding = fc::UTF8; getInitValues().encoding = fc::UTF8;
else if ( encoding.includes("vt100") ) else if ( encoding.includes("vt100") )
init_values.encoding = fc::VT100; getInitValues().encoding = fc::VT100;
else if ( encoding.includes("pc") ) else if ( encoding.includes("pc") )
init_values.encoding = fc::PC; getInitValues().encoding = fc::PC;
else if ( encoding.includes("ascii") ) else if ( encoding.includes("ascii") )
init_values.encoding = fc::ASCII; getInitValues().encoding = fc::ASCII;
else if ( encoding.includes("help") ) else if ( encoding.includes("help") )
showParameterUsage(); showParameterUsage();
else else
@ -464,32 +464,32 @@ void FApplication::cmd_options (const int& argc, char* argv[])
} }
if ( std::strcmp(long_options[idx].name, "no-mouse") == 0 ) if ( std::strcmp(long_options[idx].name, "no-mouse") == 0 )
init_values.mouse_support = false; getInitValues().mouse_support = false;
if ( std::strcmp(long_options[idx].name, "no-optimized-cursor") == 0 ) if ( std::strcmp(long_options[idx].name, "no-optimized-cursor") == 0 )
init_values.cursor_optimisation = false; getInitValues().cursor_optimisation = false;
if ( std::strcmp(long_options[idx].name, "no-terminal-detection") == 0 ) if ( std::strcmp(long_options[idx].name, "no-terminal-detection") == 0 )
init_values.terminal_detection = false; getInitValues().terminal_detection = false;
if ( std::strcmp(long_options[idx].name, "no-color-change") == 0 ) if ( std::strcmp(long_options[idx].name, "no-color-change") == 0 )
init_values.color_change = false; getInitValues().color_change = false;
if ( std::strcmp(long_options[idx].name, "vgafont") == 0 ) if ( std::strcmp(long_options[idx].name, "vgafont") == 0 )
init_values.vgafont = true; getInitValues().vgafont = true;
if ( std::strcmp(long_options[idx].name, "newfont") == 0 ) if ( std::strcmp(long_options[idx].name, "newfont") == 0 )
init_values.newfont = true; getInitValues().newfont = true;
#if defined(__FreeBSD__) || defined(__DragonFly__) #if defined(__FreeBSD__) || defined(__DragonFly__)
if ( std::strcmp(long_options[idx].name, "no-esc-for-alt-meta") == 0 ) if ( std::strcmp(long_options[idx].name, "no-esc-for-alt-meta") == 0 )
init_values.meta_sends_escape = false; getInitValues().meta_sends_escape = false;
if ( std::strcmp(long_options[idx].name, "no-cursorstyle-change") == 0 ) if ( std::strcmp(long_options[idx].name, "no-cursorstyle-change") == 0 )
init_values.change_cursorstyle = false; getInitValues().change_cursorstyle = false;
#elif defined(__NetBSD__) || defined(__OpenBSD__) #elif defined(__NetBSD__) || defined(__OpenBSD__)
if ( std::strcmp(long_options[idx].name, "no-esc-for-alt-meta") == 0 ) if ( std::strcmp(long_options[idx].name, "no-esc-for-alt-meta") == 0 )
init_values.meta_sends_escape = false; getInitValues().meta_sends_escape = false;
#endif #endif
} }
} }
@ -685,9 +685,9 @@ bool FApplication::processDialogSwitchAccelerator()
if ( keyboard->getKey() >= fc::Fmkey_1 if ( keyboard->getKey() >= fc::Fmkey_1
&& keyboard->getKey() <= fc::Fmkey_9 ) && keyboard->getKey() <= fc::Fmkey_9 )
{ {
int key = keyboard->getKey(); FKey key = keyboard->getKey();
uLong n = uLong(key - fc::Fmkey_0); std::size_t n = key - fc::Fmkey_0;
uLong s = dialog_list->size(); std::size_t s = dialog_list->size();
if ( s > 0 && s >= n ) if ( s > 0 && s >= n )
{ {
@ -853,7 +853,7 @@ void FApplication::closeOpenMenu()
// No widget was been clicked and the menu is no dialog menu // No widget was been clicked and the menu is no dialog menu
if ( ! (getClickedWidget() || is_window_menu) ) if ( ! (getClickedWidget() || is_window_menu) )
FWindow::switchToPrevWindow(); FWindow::switchToPrevWindow(this);
if ( getStatusBar() ) if ( getStatusBar() )
getStatusBar()->drawMessage(); getStatusBar()->drawMessage();
@ -894,7 +894,7 @@ void FApplication::unselectMenubarItems()
// No widget was been clicked // No widget was been clicked
if ( ! getClickedWidget() ) if ( ! getClickedWidget() )
FWindow::switchToPrevWindow(); FWindow::switchToPrevWindow(this);
if ( getStatusBar() ) if ( getStatusBar() )
getStatusBar()->drawMessage(); getStatusBar()->drawMessage();

111
src/fbutton.cpp
View File

@ -37,6 +37,7 @@ FButton::FButton(FWidget* parent)
: FWidget(parent) : FWidget(parent)
, text() , text()
, button_down(false) , button_down(false)
, active_focus(false)
, click_animation(true) , click_animation(true)
, click_time(150) , click_time(150)
, space_char(int(' ')) , space_char(int(' '))
@ -52,7 +53,6 @@ FButton::FButton(FWidget* parent)
, button_focus_bg(wc.button_active_focus_bg) , button_focus_bg(wc.button_active_focus_bg)
, button_inactive_fg(wc.button_inactive_fg) , button_inactive_fg(wc.button_inactive_fg)
, button_inactive_bg(wc.button_inactive_bg) , button_inactive_bg(wc.button_inactive_bg)
, is()
{ {
init(); init();
} }
@ -62,6 +62,7 @@ FButton::FButton (const FString& txt, FWidget* parent)
: FWidget(parent) : FWidget(parent)
, text(txt) , text(txt)
, button_down(false) , button_down(false)
, active_focus(false)
, click_animation(true) , click_animation(true)
, click_time(150) , click_time(150)
, space_char(int(' ')) , space_char(int(' '))
@ -77,7 +78,6 @@ FButton::FButton (const FString& txt, FWidget* parent)
, button_focus_bg(wc.button_active_focus_bg) , button_focus_bg(wc.button_active_focus_bg)
, button_inactive_fg(wc.button_inactive_fg) , button_inactive_fg(wc.button_inactive_fg)
, button_inactive_bg(wc.button_inactive_bg) , button_inactive_bg(wc.button_inactive_bg)
, is()
{ {
init(); init();
detectHotkey(); detectHotkey();
@ -93,21 +93,21 @@ FButton::~FButton() // destructor
// public methods of FButton // public methods of FButton
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FButton::setForegroundColor (short color) void FButton::setForegroundColor (FColor color)
{ {
FWidget::setForegroundColor(color); FWidget::setForegroundColor(color);
updateButtonColor(); updateButtonColor();
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FButton::setBackgroundColor (short color) void FButton::setBackgroundColor (FColor color)
{ {
FWidget::setBackgroundColor(color); FWidget::setBackgroundColor(color);
updateButtonColor(); updateButtonColor();
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FButton::setHotkeyForegroundColor (short color) void FButton::setHotkeyForegroundColor (FColor color)
{ {
// valid colors -1..254 // valid colors -1..254
if ( color == fc::Default || color >> 8 == 0 ) if ( color == fc::Default || color >> 8 == 0 )
@ -115,7 +115,7 @@ void FButton::setHotkeyForegroundColor (short color)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FButton::setFocusForegroundColor (short color) void FButton::setFocusForegroundColor (FColor color)
{ {
// valid colors -1..254 // valid colors -1..254
if ( color == fc::Default || color >> 8 == 0 ) if ( color == fc::Default || color >> 8 == 0 )
@ -125,7 +125,7 @@ void FButton::setFocusForegroundColor (short color)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FButton::setFocusBackgroundColor (short color) void FButton::setFocusBackgroundColor (FColor color)
{ {
// valid colors -1..254 // valid colors -1..254
if ( color == fc::Default || color >> 8 == 0 ) if ( color == fc::Default || color >> 8 == 0 )
@ -135,7 +135,7 @@ void FButton::setFocusBackgroundColor (short color)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FButton::setInactiveForegroundColor (short color) void FButton::setInactiveForegroundColor (FColor color)
{ {
// valid colors -1..254 // valid colors -1..254
if ( color == fc::Default || color >> 8 == 0 ) if ( color == fc::Default || color >> 8 == 0 )
@ -145,7 +145,7 @@ void FButton::setInactiveForegroundColor (short color)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FButton::setInactiveBackgroundColor (short color) void FButton::setInactiveBackgroundColor (FColor color)
{ {
// valid colors -1..254 // valid colors -1..254
if ( color == fc::Default || color >> 8 == 0 ) if ( color == fc::Default || color >> 8 == 0 )
@ -157,12 +157,7 @@ void FButton::setInactiveBackgroundColor (short color)
//---------------------------------------------------------------------- //----------------------------------------------------------------------
bool FButton::setNoUnderline (bool on) bool FButton::setNoUnderline (bool on)
{ {
if ( on ) return (flags.no_underline = on);
flags |= fc::no_underline;
else
flags &= ~fc::no_underline;
return on;
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -211,11 +206,7 @@ bool FButton::setFocus (bool on)
//---------------------------------------------------------------------- //----------------------------------------------------------------------
bool FButton::setFlat (bool on) bool FButton::setFlat (bool on)
{ {
if ( on ) return (flags.flat = on);
flags |= fc::flat;
else
flags &= ~fc::flat;
return on;
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -225,16 +216,16 @@ bool FButton::setShadow (bool on)
&& getEncoding() != fc::VT100 && getEncoding() != fc::VT100
&& getEncoding() != fc::ASCII ) && getEncoding() != fc::ASCII )
{ {
flags |= fc::shadow; flags.shadow = true;
setShadowSize(1,1); setShadowSize(1, 1);
} }
else else
{ {
flags &= ~fc::shadow; flags.shadow = false;
setShadowSize(0,0); setShadowSize(0, 0);
} }
return on; return flags.shadow;
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -264,7 +255,7 @@ void FButton::setText (const FString& txt)
void FButton::hide() void FButton::hide()
{ {
std::size_t s, f, size; std::size_t s, f, size;
short fg, bg; FColor fg, bg;
FWidget* parent_widget = getParentWidget(); FWidget* parent_widget = getParentWidget();
FWidget::hide(); FWidget::hide();
@ -301,12 +292,10 @@ void FButton::hide()
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FButton::onKeyPress (FKeyEvent* ev) void FButton::onKeyPress (FKeyEvent* ev)
{ {
int key;
if ( ! isEnabled() ) if ( ! isEnabled() )
return; return;
key = ev->key(); FKey key = ev->key();
switch ( key ) switch ( key )
{ {
@ -462,18 +451,6 @@ void FButton::init()
setShadow(); setShadow();
} }
//----------------------------------------------------------------------
void FButton::getButtonState()
{
int active_focus = fc::active + fc::focus;
is.active_focus = ((flags & active_focus) == active_focus);
is.active = ((flags & fc::active) != 0);
is.focus = ((flags & fc::focus) != 0);
is.flat = isFlat();
is.non_flat_shadow = ((flags & (fc::shadow + fc::flat)) == fc::shadow);
is.no_underline = ((flags & fc::no_underline) != 0);
}
//---------------------------------------------------------------------- //----------------------------------------------------------------------
uChar FButton::getHotkey() uChar FButton::getHotkey()
{ {
@ -501,16 +478,16 @@ uChar FButton::getHotkey()
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FButton::setHotkeyAccelerator() void FButton::setHotkeyAccelerator()
{ {
int hotkey = getHotkey(); uChar hotkey = getHotkey();
if ( hotkey ) if ( hotkey )
{ {
if ( std::isalpha(hotkey) || std::isdigit(hotkey) ) if ( std::isalpha(hotkey) || std::isdigit(hotkey) )
{ {
addAccelerator (std::tolower(hotkey)); addAccelerator (FKey(std::tolower(hotkey)));
addAccelerator (std::toupper(hotkey)); addAccelerator (FKey(std::toupper(hotkey)));
// Meta + hotkey // Meta + hotkey
addAccelerator (fc::Fmkey_meta + std::tolower(hotkey)); addAccelerator (fc::Fmkey_meta + FKey(std::tolower(hotkey)));
} }
else else
addAccelerator (getHotkey()); addAccelerator (getHotkey());
@ -561,7 +538,7 @@ inline std::size_t FButton::clickAnimationIndent (FWidget* parent_widget)
return 0; return 0;
// noshadow + indent one character to the right // noshadow + indent one character to the right
if ( is.flat ) if ( flags.flat )
clearFlatBorder(); clearFlatBorder();
else if ( hasShadow() ) else if ( hasShadow() )
clearShadow(); clearShadow();
@ -598,7 +575,7 @@ inline void FButton::clearRightMargin (FWidget* parent_widget)
setPrintPos (1 + int(getWidth()), y); setPrintPos (1 + int(getWidth()), y);
print (' '); // clear right print (' '); // clear right
if ( is.active && isMonochron() ) if ( flags.active && isMonochron() )
setReverse(false); // Dark background setReverse(false); // Dark background
} }
} }
@ -614,7 +591,7 @@ inline void FButton::drawMarginLeft()
{ {
setPrintPos (1 + int(indent), 1 + int(y)); setPrintPos (1 + int(indent), 1 + int(y));
if ( isMonochron() && is.active_focus && y == vcenter_offset ) if ( isMonochron() && active_focus && y == vcenter_offset )
print (fc::BlackRightPointingPointer); // ► print (fc::BlackRightPointingPointer); // ►
else else
print (space_char); // full block █ print (space_char); // full block █
@ -630,7 +607,7 @@ inline void FButton::drawMarginRight()
{ {
setPrintPos (int(getWidth() + indent), 1 + int(y)); setPrintPos (int(getWidth() + indent), 1 + int(y));
if ( isMonochron() && is.active_focus && y == vcenter_offset ) if ( isMonochron() && active_focus && y == vcenter_offset )
print (fc::BlackLeftPointingPointer); // ◄ print (fc::BlackLeftPointingPointer); // ◄
else else
print (space_char); // full block █ print (space_char); // full block █
@ -666,10 +643,14 @@ inline void FButton::drawTopBottomBackground()
inline void FButton::drawButtonTextLine (wchar_t button_text[]) inline void FButton::drawButtonTextLine (wchar_t button_text[])
{ {
std::size_t pos; std::size_t pos;
center_offset = (getWidth() - txtlength - 1) / 2;
setPrintPos (2 + int(indent), 1 + int(vcenter_offset)); setPrintPos (2 + int(indent), 1 + int(vcenter_offset));
setColor (button_fg, button_bg); setColor (button_fg, button_bg);
if ( getWidth() < txtlength + 1 )
center_offset = 0;
else
center_offset = (getWidth() - txtlength - 1) / 2;
// Print button text line -------- // Print button text line --------
for (pos = 0; pos < center_offset; pos++) for (pos = 0; pos < center_offset; pos++)
print (space_char); // █ print (space_char); // █
@ -681,32 +662,32 @@ inline void FButton::drawButtonTextLine (wchar_t button_text[])
setCursorPos ( 2 + int(center_offset + hotkeypos) setCursorPos ( 2 + int(center_offset + hotkeypos)
, 1 + int(vcenter_offset) ); // hotkey , 1 + int(vcenter_offset) ); // hotkey
if ( ! is.active && isMonochron() ) if ( ! flags.active && isMonochron() )
setReverse(true); // Light background setReverse(true); // Light background
if ( is.active_focus && (isMonochron() || getMaxColor() < 16) ) if ( active_focus && (isMonochron() || getMaxColor() < 16) )
setBold(); setBold();
for ( std::size_t z = 0 for ( std::size_t z = 0
; pos < center_offset + txtlength && z < getWidth() - 2 ; pos < center_offset + txtlength && z < getWidth() - 2
; z++, pos++) ; z++, pos++)
{ {
if ( z == hotkeypos && is.active ) if ( z == hotkeypos && flags.active )
{ {
setColor (button_hotkey_fg, button_bg); setColor (button_hotkey_fg, button_bg);
if ( ! is.active_focus && getMaxColor() < 16 ) if ( ! active_focus && getMaxColor() < 16 )
setBold(); setBold();
if ( ! is.no_underline ) if ( ! flags.no_underline )
setUnderline(); setUnderline();
print (button_text[z]); print (button_text[z]);
if ( ! is.active_focus && getMaxColor() < 16 ) if ( ! active_focus && getMaxColor() < 16 )
unsetBold(); unsetBold();
if ( ! is.no_underline ) if ( ! flags.no_underline )
unsetUnderline(); unsetUnderline();
setColor (button_fg, button_bg); setColor (button_fg, button_bg);
@ -724,7 +705,7 @@ inline void FButton::drawButtonTextLine (wchar_t button_text[])
print (L".."); print (L"..");
} }
if ( is.active_focus && (isMonochron() || getMaxColor() < 16) ) if ( active_focus && (isMonochron() || getMaxColor() < 16) )
unsetBold(); unsetBold();
for (pos = center_offset + txtlength; pos < getWidth() - 2; pos++) for (pos = center_offset + txtlength; pos < getWidth() - 2; pos++)
@ -738,7 +719,7 @@ void FButton::draw()
FWidget* parent_widget = getParentWidget(); FWidget* parent_widget = getParentWidget();
txtlength = text.getLength(); txtlength = text.getLength();
space_char = int(' '); space_char = int(' ');
getButtonState(); active_focus = flags.active && flags.focus;
try try
{ {
@ -759,13 +740,13 @@ void FButton::draw()
// Clear right margin after animation // Clear right margin after animation
clearRightMargin (parent_widget); clearRightMargin (parent_widget);
if ( ! is.active && isMonochron() ) if ( ! flags.active && isMonochron() )
space_char = fc::MediumShade; // ▒ simulates greyed out at Monochron space_char = fc::MediumShade; // ▒ simulates greyed out at Monochron
if ( isMonochron() && (is.active || is.focus) ) if ( isMonochron() && (flags.active || flags.focus) )
setReverse(false); // Dark background setReverse(false); // Dark background
if ( is.flat && ! button_down ) if ( flags.flat && ! button_down )
drawFlatBorder(); drawFlatBorder();
hotkeypos = getHotkeyPos(text.wc_str(), button_text, uInt(txtlength)); hotkeypos = getHotkeyPos(text.wc_str(), button_text, uInt(txtlength));
@ -791,7 +772,7 @@ void FButton::draw()
drawTopBottomBackground(); drawTopBottomBackground();
// Draw button shadow // Draw button shadow
if ( is.non_flat_shadow && ! button_down ) if ( ! flags.flat && flags.shadow && ! button_down )
drawShadow(); drawShadow();
if ( isMonochron() ) if ( isMonochron() )
@ -804,7 +785,7 @@ void FButton::draw()
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FButton::updateStatusBar() void FButton::updateStatusBar()
{ {
if ( ! is.focus || ! getStatusBar() ) if ( ! flags.focus || ! getStatusBar() )
return; return;
const FString& msg = getStatusbarMessage(); const FString& msg = getStatusbarMessage();

22
src/fbuttongroup.cpp
View File

@ -190,7 +190,7 @@ bool FButtonGroup::hasCheckedButton() const
void FButtonGroup::hide() void FButtonGroup::hide()
{ {
std::size_t size; std::size_t size;
short fg, bg; FColor fg, bg;
FWidget::hide(); FWidget::hide();
FWidget* parent_widget = getParentWidget(); FWidget* parent_widget = getParentWidget();
@ -454,16 +454,16 @@ uChar FButtonGroup::getHotkey()
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FButtonGroup::setHotkeyAccelerator() void FButtonGroup::setHotkeyAccelerator()
{ {
int hotkey = getHotkey(); uChar hotkey = getHotkey();
if ( hotkey ) if ( hotkey )
{ {
if ( std::isalpha(hotkey) || std::isdigit(hotkey) ) if ( std::isalpha(hotkey) || std::isdigit(hotkey) )
{ {
addAccelerator (std::tolower(hotkey)); addAccelerator (FKey(std::tolower(hotkey)));
addAccelerator (std::toupper(hotkey)); addAccelerator (FKey(std::toupper(hotkey)));
// Meta + hotkey // Meta + hotkey
addAccelerator (fc::Fmkey_meta + std::tolower(hotkey)); addAccelerator (fc::Fmkey_meta + FKey(std::tolower(hotkey)));
} }
else else
addAccelerator (getHotkey()); addAccelerator (getHotkey());
@ -543,9 +543,6 @@ bool FButtonGroup::isRadioButton (FToggleButton* button) const
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FButtonGroup::init() void FButtonGroup::init()
{ {
if ( isEnabled() )
flags |= fc::active;
setForegroundColor (wc.label_fg); setForegroundColor (wc.label_fg);
setBackgroundColor (wc.label_bg); setBackgroundColor (wc.label_bg);
setMinimumSize (7, 4); setMinimumSize (7, 4);
@ -582,9 +579,6 @@ void FButtonGroup::drawText ( wchar_t LabelText[]
, std::size_t hotkeypos , std::size_t hotkeypos
, std::size_t length ) , std::size_t length )
{ {
bool isActive = ((flags & fc::active) != 0);
bool isNoUnderline = ((flags & fc::no_underline) != 0);
if ( isMonochron() ) if ( isMonochron() )
setReverse(true); setReverse(true);
@ -595,16 +589,16 @@ void FButtonGroup::drawText ( wchar_t LabelText[]
for (std::size_t z = 0; z < length; z++) for (std::size_t z = 0; z < length; z++)
{ {
if ( (z == hotkeypos) && isActive ) if ( (z == hotkeypos) && flags.active )
{ {
setColor (wc.label_hotkey_fg, wc.label_hotkey_bg); setColor (wc.label_hotkey_fg, wc.label_hotkey_bg);
if ( ! isNoUnderline ) if ( ! flags.no_underline )
setUnderline(); setUnderline();
print (LabelText[z]); print (LabelText[z]);
if ( ! isNoUnderline ) if ( ! flags.no_underline )
unsetUnderline(); unsetUnderline();
setColor (wc.label_emphasis_fg, wc.label_bg); setColor (wc.label_emphasis_fg, wc.label_bg);

2
src/fcheckbox.cpp
View File

@ -72,7 +72,7 @@ void FCheckBox::drawCheckButton()
if ( ! isVisible() ) if ( ! isVisible() )
return; return;
setPrintPos (1,1); setPrintPos (1, 1);
setColor(); setColor();
if ( isMonochron() ) if ( isMonochron() )

2
src/fcheckmenuitem.cpp
View File

@ -75,7 +75,7 @@ void FCheckMenuItem::processToggle()
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FCheckMenuItem::processClicked() void FCheckMenuItem::processClicked()
{ {
checked = not checked; checked = ! checked;
processToggle(); processToggle();
emitCallback("clicked"); emitCallback("clicked");
} }

40
src/fdialog.cpp
View File

@ -87,7 +87,7 @@ FDialog::~FDialog() // destructor
accelerator_list = 0; accelerator_list = 0;
if ( ! is_quit ) if ( ! is_quit )
switchToPrevWindow(); switchToPrevWindow(this);
delDialog(this); delDialog(this);
@ -103,16 +103,12 @@ bool FDialog::setDialogWidget (bool on)
if ( isDialogWidget() == on ) if ( isDialogWidget() == on )
return true; return true;
flags.dialog_widget = on;
if ( on ) if ( on )
{
flags |= fc::dialog_widget;
setTermOffsetWithPadding(); setTermOffsetWithPadding();
}
else else
{
flags &= ~fc::dialog_widget;
setParentOffset(); setParentOffset();
}
return on; return on;
} }
@ -123,16 +119,12 @@ bool FDialog::setModal (bool on)
if ( isModal() == on ) if ( isModal() == on )
return true; return true;
flags.modal = on;
if ( on ) if ( on )
{
flags |= fc::modal;
modal_dialogs++; modal_dialogs++;
}
else else
{
flags &= ~fc::modal;
modal_dialogs--; modal_dialogs--;
}
return on; return on;
} }
@ -141,12 +133,7 @@ bool FDialog::setModal (bool on)
//---------------------------------------------------------------------- //----------------------------------------------------------------------
bool FDialog::setScrollable (bool on) bool FDialog::setScrollable (bool on)
{ {
if ( on ) return (flags.scrollable = on);
flags |= fc::scrollable;
else
flags &= ~fc::scrollable;
return on;
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -541,7 +528,7 @@ void FDialog::onMouseDown (FMouseEvent* ev)
&& ms.mouse_y == 1 ) && ms.mouse_y == 1 )
titlebar_click_pos.setPoint (ev->getTermX(), ev->getTermY()); titlebar_click_pos.setPoint (ev->getTermX(), ev->getTermY());
else else
titlebar_click_pos.setPoint (0,0); titlebar_click_pos.setPoint (0, 0);
// Click on titlebar menu button // Click on titlebar menu button
if ( ms.mouse_x < 4 && ms.mouse_y == 1 ) if ( ms.mouse_x < 4 && ms.mouse_y == 1 )
@ -835,7 +822,7 @@ void FDialog::draw()
drawTitleBar(); drawTitleBar();
setCursorPos(2, int(getHeight()) - 1); setCursorPos(2, int(getHeight()) - 1);
if ( (flags & fc::shadow) != 0 ) if ( flags.shadow )
drawDialogShadow(); drawDialogShadow();
if ( isMonochron() ) if ( isMonochron() )
@ -845,7 +832,7 @@ void FDialog::draw()
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FDialog::drawDialogShadow() void FDialog::drawDialogShadow()
{ {
if ( isMonochron() && (flags & fc::trans_shadow) == 0 ) if ( isMonochron() && ! flags.trans_shadow )
return; return;
drawShadow(); drawShadow();
@ -1591,7 +1578,7 @@ void FDialog::resizeMouseDown (mouseStates& ms)
drawBorder(); drawBorder();
} }
else else
resize_click_pos.setPoint (0,0); resize_click_pos.setPoint (0, 0);
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -1628,13 +1615,14 @@ void FDialog::resizeMouseUpMove (mouseStates& ms, bool mouse_up)
else else
h = int(getMaxHeight()) - getTermY() + y2_offset + 1; h = int(getMaxHeight()) - getTermY() + y2_offset + 1;
setSize (std::size_t(w), std::size_t(h)); setSize ( ( w >= 0) ? std::size_t(w) : 0
, ( h >= 0) ? std::size_t(h) : 0 );
} }
if ( mouse_up ) if ( mouse_up )
{ {
// Reset the border color // Reset the border color
resize_click_pos.setPoint (0,0); resize_click_pos.setPoint (0, 0);
// redraw() is required to draw the standard (black) border // redraw() is required to draw the standard (black) border
// and client objects with ignorePadding() option. // and client objects with ignorePadding() option.
@ -1651,7 +1639,7 @@ void FDialog::cancelMouseResize()
if ( resize_click_pos.isNull() ) if ( resize_click_pos.isNull() )
return; return;
resize_click_pos.setPoint (0,0); resize_click_pos.setPoint (0, 0);
drawBorder(); drawBorder();
updateTerminal(); updateTerminal();
} }

6
src/fevent.cpp
View File

@ -3,7 +3,7 @@
* * * *
* This file is part of the Final Cut widget toolkit * * This file is part of the Final Cut widget toolkit *
* * * *
* Copyright 2014-2017 Markus Gans * * Copyright 2014-2018 Markus Gans *
* * * *
* The Final Cut is free software; you can redistribute it and/or * * The Final Cut is free software; you can redistribute it and/or *
* modify it under the terms of the GNU Lesser General Public License * * modify it under the terms of the GNU Lesser General Public License *
@ -48,7 +48,7 @@ int FEvent::type() const
// class FKeyEvent // class FKeyEvent
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FKeyEvent::FKeyEvent (int ev_type, int key_num) // constructor FKeyEvent::FKeyEvent (int ev_type, FKey key_num) // constructor
: FEvent(ev_type) : FEvent(ev_type)
, k(key_num) , k(key_num)
, accpt(false) , accpt(false)
@ -59,7 +59,7 @@ FKeyEvent::~FKeyEvent() // destructor
{ } { }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
int FKeyEvent::key() const FKey FKeyEvent::key() const
{ return k; } { return k; }
//---------------------------------------------------------------------- //----------------------------------------------------------------------

4
src/ffiledialog.cpp
View File

@ -231,7 +231,7 @@ void FFileDialog::onKeyPress (FKeyEvent* ev)
if ( ! filebrowser.hasFocus() ) if ( ! filebrowser.hasFocus() )
return; return;
int key = ev->key(); FKey key = ev->key();
switch ( key ) switch ( key )
{ {
@ -912,7 +912,7 @@ void FFileDialog::cb_processOpen (FWidget*, data_ptr)
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FFileDialog::cb_processShowHidden (FWidget*, data_ptr) void FFileDialog::cb_processShowHidden (FWidget*, data_ptr)
{ {
setShowHiddenFiles(not show_hidden); setShowHiddenFiles(! show_hidden);
} }
} // namespace finalcut } // namespace finalcut

61
src/fkeyboard.cpp
View File

@ -107,7 +107,7 @@ void FKeyboard::fetchKeyCode()
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
const FString FKeyboard::getKeyName (int keynum) const FString FKeyboard::getKeyName (FKey keynum)
{ {
for (int i = 0; fc::FkeyName[i].string[0] != 0; i++) for (int i = 0; fc::FkeyName[i].string[0] != 0; i++)
if ( fc::FkeyName[i].num && fc::FkeyName[i].num == keynum ) if ( fc::FkeyName[i].num && fc::FkeyName[i].num == keynum )
@ -197,12 +197,12 @@ void FKeyboard::escapeKeyHandling()
// private methods of FKeyboard // private methods of FKeyboard
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline int FKeyboard::getMouseProtocolKey() inline FKey FKeyboard::getMouseProtocolKey()
{ {
// Looking for mouse string in the key buffer // Looking for mouse string in the key buffer
if ( ! mouse_support ) if ( ! mouse_support )
return -1; return NOT_SET;
std::size_t buf_len = std::strlen(fifo_buf); std::size_t buf_len = std::strlen(fifo_buf);
@ -221,23 +221,22 @@ inline int FKeyboard::getMouseProtocolKey()
&& fifo_buf[buf_len - 1] == 'M' ) && fifo_buf[buf_len - 1] == 'M' )
return fc::Fkey_urxvt_mouse; return fc::Fkey_urxvt_mouse;
return -1; return NOT_SET;
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline int FKeyboard::getTermcapKey() inline FKey FKeyboard::getTermcapKey()
{ {
// Looking for termcap key strings in the buffer // Looking for termcap key strings in the buffer
assert ( FIFO_BUF_SIZE > 0 ); assert ( FIFO_BUF_SIZE > 0 );
if ( ! key_map ) if ( ! key_map )
return -1; return NOT_SET;
fc::fkeymap* keymap = reinterpret_cast<fc::fkeymap*>(key_map); for (int i = 0; key_map[i].tname[0] != 0; i++)
for (int i = 0; keymap[i].tname[0] != 0; i++)
{ {
char* k = keymap[i].string; char* k = key_map[i].string;
std::size_t len = ( k ) ? std::strlen(k) : 0; std::size_t len = ( k ) ? std::strlen(k) : 0;
if ( k && std::strncmp(k, fifo_buf, len) == 0 ) // found if ( k && std::strncmp(k, fifo_buf, len) == 0 ) // found
@ -255,11 +254,11 @@ inline int FKeyboard::getTermcapKey()
} }
} }
return -1; return NOT_SET;
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline int FKeyboard::getMetaKey() inline FKey FKeyboard::getMetaKey()
{ {
// Looking for meta key strings in the buffer // Looking for meta key strings in the buffer
@ -279,7 +278,7 @@ inline int FKeyboard::getMetaKey()
|| fifo_buf[1] == ']' ) ) || fifo_buf[1] == ']' ) )
{ {
if ( ! isKeypressTimeout() ) if ( ! isKeypressTimeout() )
return NEED_MORE_DATA; return fc::need_more_data;
} }
for (n = len; n < FIFO_BUF_SIZE; n++) // Remove founded entry for (n = len; n < FIFO_BUF_SIZE; n++) // Remove founded entry
@ -293,18 +292,18 @@ inline int FKeyboard::getMetaKey()
} }
} }
return -1; return NOT_SET;
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline int FKeyboard::getSingleKey() inline FKey FKeyboard::getSingleKey()
{ {
// Looking for single key code in the buffer // Looking for single key code in the buffer
uChar firstchar = uChar(fifo_buf[0]); uChar firstchar = uChar(fifo_buf[0]);
std::size_t n; std::size_t n;
std::size_t len = 1; std::size_t len = 1;
int keycode; FKey keycode;
// Look for a utf-8 character // Look for a utf-8 character
if ( utf8_input && (firstchar & 0xc0) == 0xc0 ) if ( utf8_input && (firstchar & 0xc0) == 0xc0 )
@ -337,7 +336,7 @@ inline int FKeyboard::getSingleKey()
if ( keycode == 0 ) // Ctrl+Space or Ctrl+@ if ( keycode == 0 ) // Ctrl+Space or Ctrl+@
keycode = fc::Fckey_space; keycode = fc::Fckey_space;
return int(keycode == 127 ? fc::Fkey_backspace : keycode); return FKey(keycode == 127 ? fc::Fkey_backspace : keycode);
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -371,16 +370,16 @@ bool FKeyboard::isKeypressTimeout()
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
int FKeyboard::UTF8decode (const char utf8[]) FKey FKeyboard::UTF8decode (const char utf8[])
{ {
int ucs = 0; FKey ucs = 0; // Universal coded character
const int max = 4; const int max = 4;
int len = int(std::strlen(utf8)); std::size_t len = std::strlen(utf8);
if ( len > max ) if ( len > max )
len = max; len = max;
for (int i = 0; i < len; ++i) for (std::size_t i = 0; i < len; ++i)
{ {
uChar ch = uChar(utf8[i]); uChar ch = uChar(utf8[i]);
@ -412,7 +411,7 @@ int FKeyboard::UTF8decode (const char utf8[])
else else
{ {
// error // error
ucs = EOF; ucs = NOT_SET;
} }
} }
@ -451,12 +450,12 @@ void FKeyboard::parseKeyBuffer()
// Read the rest from the fifo buffer // Read the rest from the fifo buffer
while ( ! isKeypressTimeout() while ( ! isKeypressTimeout()
&& fifo_offset > 0 && fifo_offset > 0
&& key != NEED_MORE_DATA ) && key != fc::need_more_data )
{ {
key = parseKeyString(); key = parseKeyString();
key = keyCorrection(key); key = keyCorrection(key);
if ( key != NEED_MORE_DATA ) if ( key != fc::need_more_data )
keyPressed(); keyPressed();
fifo_offset = int(std::strlen(fifo_buf)); fifo_offset = int(std::strlen(fifo_buf));
@ -478,38 +477,38 @@ void FKeyboard::parseKeyBuffer()
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
int FKeyboard::parseKeyString() FKey FKeyboard::parseKeyString()
{ {
uChar firstchar = uChar(fifo_buf[0]); uChar firstchar = uChar(fifo_buf[0]);
if ( firstchar == ESC[0] ) if ( firstchar == ESC[0] )
{ {
int keycode = getMouseProtocolKey(); FKey keycode = getMouseProtocolKey();
if ( keycode > 0 ) if ( keycode != NOT_SET )
return keycode; return keycode;
keycode = getTermcapKey(); keycode = getTermcapKey();
if ( keycode > 0 ) if ( keycode != NOT_SET )
return keycode; return keycode;
keycode = getMetaKey(); keycode = getMetaKey();
if ( keycode > 0 ) if ( keycode != NOT_SET )
return keycode; return keycode;
if ( ! isKeypressTimeout() ) if ( ! isKeypressTimeout() )
return NEED_MORE_DATA; return fc::need_more_data;
} }
return getSingleKey(); return getSingleKey();
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
int FKeyboard::keyCorrection (const int& keycode) FKey FKeyboard::keyCorrection (const FKey& keycode)
{ {
int key_correction; FKey key_correction;
#if defined(__linux__) #if defined(__linux__)
if ( linux ) if ( linux )

17
src/flabel.cpp
View File

@ -241,7 +241,7 @@ void FLabel::setText (const FString& txt)
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FLabel::hide() void FLabel::hide()
{ {
short fg, bg; FColor fg, bg;
std::size_t size; std::size_t size;
FWidget* parent_widget = getParentWidget(); FWidget* parent_widget = getParentWidget();
@ -440,10 +440,10 @@ void FLabel::setHotkeyAccelerator()
{ {
if ( std::isalpha(hotkey) || std::isdigit(hotkey) ) if ( std::isalpha(hotkey) || std::isdigit(hotkey) )
{ {
addAccelerator (std::tolower(hotkey)); addAccelerator (FKey(std::tolower(hotkey)));
addAccelerator (std::toupper(hotkey)); addAccelerator (FKey(std::toupper(hotkey)));
// Meta + hotkey // Meta + hotkey
addAccelerator (fc::Fmkey_meta + std::tolower(hotkey)); addAccelerator (fc::Fmkey_meta + FKey(std::tolower(hotkey)));
} }
else else
addAccelerator (getHotkey()); addAccelerator (getHotkey());
@ -597,9 +597,6 @@ void FLabel::printLine ( wchar_t line[]
{ {
std::size_t to_char; std::size_t to_char;
std::size_t width = std::size_t(getWidth()); std::size_t width = std::size_t(getWidth());
bool isActive, isNoUnderline;
isActive = ((flags & fc::active) != 0);
isNoUnderline = ((flags & fc::no_underline) != 0);
if ( align_offset > 0 ) if ( align_offset > 0 )
print (FString(align_offset, ' ')); // leading spaces print (FString(align_offset, ' ')); // leading spaces
@ -623,16 +620,16 @@ void FLabel::printLine ( wchar_t line[]
} }
} }
if ( z == hotkeypos && isActive ) if ( z == hotkeypos && flags.active )
{ {
setColor (wc.label_hotkey_fg, wc.label_hotkey_bg); setColor (wc.label_hotkey_fg, wc.label_hotkey_bg);
if ( ! isNoUnderline ) if ( ! flags.no_underline )
setUnderline(); setUnderline();
print (line[z]); print (line[z]);
if ( ! isNoUnderline ) if ( ! flags.no_underline )
unsetUnderline(); unsetUnderline();
if ( hasEmphasis() ) if ( hasEmphasis() )

32
src/flineedit.cpp
View File

@ -239,16 +239,16 @@ bool FLineEdit::setShadow (bool on)
&& getEncoding() != fc::VT100 && getEncoding() != fc::VT100
&& getEncoding() != fc::ASCII ) && getEncoding() != fc::ASCII )
{ {
flags |= fc::shadow; flags.shadow = true;
setShadowSize(1,1); setShadowSize(1, 1);
} }
else else
{ {
flags &= ~fc::shadow; flags.shadow = false;
setShadowSize(0,0); setShadowSize(0, 0);
} }
return on; return flags.shadow;
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -282,7 +282,7 @@ void FLineEdit::setLabelOrientation(const label_o o)
void FLineEdit::hide() void FLineEdit::hide()
{ {
std::size_t s, size; std::size_t s, size;
short fg, bg; FColor fg, bg;
FWidget* parent_widget = getParentWidget(); FWidget* parent_widget = getParentWidget();
FWidget::hide(); FWidget::hide();
@ -330,7 +330,7 @@ void FLineEdit::clear()
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FLineEdit::onKeyPress (FKeyEvent* ev) void FLineEdit::onKeyPress (FKeyEvent* ev)
{ {
int key = ev->key(); FKey key = ev->key();
switch ( key ) switch ( key )
{ {
@ -645,7 +645,8 @@ void FLineEdit::adjustLabel()
break; break;
case label_left: case label_left:
label->setGeometry(getX() - int(label_length) - 1, getY(), label_length, 1); label->setGeometry(getX() - int(label_length) - 1, getY()
, label_length, 1);
break; break;
} }
} }
@ -698,11 +699,9 @@ bool FLineEdit::hasHotkey()
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FLineEdit::draw() void FLineEdit::draw()
{ {
bool isFocus;
drawInputField(); drawInputField();
isFocus = ((flags & fc::focus) != 0);
if ( isFocus && getStatusBar() ) if ( flags.focus && getStatusBar() )
{ {
const FString& msg = getStatusbarMessage(); const FString& msg = getStatusbarMessage();
const FString& curMsg = getStatusBar()->getMessage(); const FString& curMsg = getStatusBar()->getMessage();
@ -718,12 +717,9 @@ void FLineEdit::draw()
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FLineEdit::drawInputField() void FLineEdit::drawInputField()
{ {
bool isActiveFocus, isShadow;
std::size_t x; std::size_t x;
FString show_text; FString show_text;
int active_focus = fc::active + fc::focus; bool isActiveFocus = flags.active && flags.focus;
isActiveFocus = ((flags & active_focus) == active_focus);
isShadow = ((flags & fc::shadow) != 0 );
setPrintPos (1, 1); setPrintPos (1, 1);
if ( isMonochron() ) if ( isMonochron() )
@ -776,7 +772,7 @@ void FLineEdit::drawInputField()
setUnderline(false); setUnderline(false);
} }
if ( isShadow ) if ( flags.shadow )
drawShadow (); drawShadow ();
// set the cursor to the first pos. // set the cursor to the first pos.
@ -858,7 +854,7 @@ inline void FLineEdit::keyBackspace()
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline void FLineEdit::keyInsert() inline void FLineEdit::keyInsert()
{ {
insert_mode = not insert_mode; insert_mode = ! insert_mode;
if ( insert_mode ) if ( insert_mode )
setInsertCursor(); setInsertCursor();
@ -873,7 +869,7 @@ inline void FLineEdit::keyEnter()
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline bool FLineEdit::keyInput (int key) inline bool FLineEdit::keyInput (FKey key)
{ {
if ( key >= 0x20 && key <= 0x10fff ) if ( key >= 0x20 && key <= 0x10fff )
{ {

71
src/flistbox.cpp
View File

@ -241,7 +241,7 @@ void FListBox::setText (const FString& txt)
void FListBox::hide() void FListBox::hide()
{ {
std::size_t n, size; std::size_t n, size;
short fg, bg; FColor fg, bg;
FWidget* parent_widget = getParentWidget(); FWidget* parent_widget = getParentWidget();
FWidget::hide(); FWidget::hide();
@ -402,9 +402,9 @@ void FListBox::clear()
void FListBox::onKeyPress (FKeyEvent* ev) void FListBox::onKeyPress (FKeyEvent* ev)
{ {
std::size_t current_before = current; std::size_t current_before = current;
int xoffset_before = xoffset int xoffset_before = xoffset;
, yoffset_before = yoffset int yoffset_before = yoffset;
, key = ev->key(); FKey key = ev->key();
switch ( key ) switch ( key )
{ {
@ -872,8 +872,6 @@ void FListBox::init()
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FListBox::draw() void FListBox::draw()
{ {
bool isFocus;
if ( current < 1 ) if ( current < 1 )
current = 1; current = 1;
@ -898,7 +896,7 @@ void FListBox::draw()
} }
} }
drawLabel(); drawHeadline();
if ( isMonochron() ) if ( isMonochron() )
setReverse(false); setReverse(false);
@ -910,9 +908,8 @@ void FListBox::draw()
hbar->redraw(); hbar->redraw();
drawList(); drawList();
isFocus = ((flags & fc::focus) != 0);
if ( isFocus && getStatusBar() ) if ( flags.focus && getStatusBar() )
{ {
const FString& msg = getStatusbarMessage(); const FString& msg = getStatusbarMessage();
const FString& curMsg = getStatusBar()->getMessage(); const FString& curMsg = getStatusBar()->getMessage();
@ -926,7 +923,7 @@ void FListBox::draw()
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FListBox::drawLabel() void FListBox::drawHeadline()
{ {
if ( text.isNull() || text.isEmpty() ) if ( text.isNull() || text.isEmpty() )
return; return;
@ -1017,14 +1014,13 @@ inline void FListBox::drawListLine ( int y
std::size_t i, len; std::size_t i, len;
std::size_t inc_len = inc_search.getLength(); std::size_t inc_len = inc_search.getLength();
bool isCurrentLine = bool(y + yoffset + 1 == int(current)); bool isCurrentLine = bool(y + yoffset + 1 == int(current));
bool isFocus = ((flags & fc::focus) != 0);
FString element; FString element;
element = getString(iter).mid ( std::size_t(1 + xoffset) element = getString(iter).mid ( std::size_t(1 + xoffset)
, getWidth() - nf_offset - 4 ); , getWidth() - nf_offset - 4 );
const wchar_t* const& element_str = element.wc_str(); const wchar_t* const& element_str = element.wc_str();
len = element.getLength(); len = element.getLength();
if ( isMonochron() && isCurrentLine && isFocus ) if ( isMonochron() && isCurrentLine && flags.focus )
print (fc::BlackRightPointingPointer); // ► print (fc::BlackRightPointingPointer); // ►
else else
print (' '); print (' ');
@ -1035,14 +1031,14 @@ inline void FListBox::drawListLine ( int y
for (i = 0; i < len; i++) for (i = 0; i < len; i++)
{ {
if ( serach_mark && i == inc_len && isFocus ) if ( serach_mark && i == inc_len && flags.focus )
setColor ( wc.current_element_focus_fg setColor ( wc.current_element_focus_fg
, wc.current_element_focus_bg ); , wc.current_element_focus_bg );
print (element_str[i]); print (element_str[i]);
} }
if ( isMonochron() && isCurrentLine && isFocus ) if ( isMonochron() && isCurrentLine && flags.focus )
{ {
print (fc::BlackLeftPointingPointer); // ◄ print (fc::BlackLeftPointingPointer); // ◄
i++; i++;
@ -1116,9 +1112,8 @@ inline void FListBox::drawListBracketsLine ( int y
, i = 0 , i = 0
, b = 0; , b = 0;
bool isCurrentLine = bool(y + yoffset + 1 == int(current)); bool isCurrentLine = bool(y + yoffset + 1 == int(current));
bool isFocus = ((flags & fc::focus) != 0);
if ( isMonochron() && isCurrentLine && isFocus ) if ( isMonochron() && isCurrentLine && flags.focus )
print (fc::BlackRightPointingPointer); // ► print (fc::BlackRightPointingPointer); // ►
else else
print (' '); print (' ');
@ -1164,7 +1159,7 @@ inline void FListBox::drawListBracketsLine ( int y
i++; i++;
} }
if ( isMonochron() && isCurrentLine && isFocus ) if ( isMonochron() && isCurrentLine && flags.focus )
{ {
print (fc::BlackLeftPointingPointer); // ◄ print (fc::BlackLeftPointingPointer); // ◄
i++; i++;
@ -1180,10 +1175,8 @@ inline void FListBox::setLineAttributes ( int y
, bool lineHasBrackets , bool lineHasBrackets
, bool& serach_mark ) , bool& serach_mark )
{ {
bool isFocus = ((flags & fc::focus) != 0) bool isCurrentLine = bool(y + yoffset + 1 == int(current));
, isCurrentLine = bool(y + yoffset + 1 == int(current));
std::size_t inc_len = inc_search.getLength(); std::size_t inc_len = inc_search.getLength();
setPrintPos (2, 2 + int(y)); setPrintPos (2, 2 + int(y));
if ( isLineSelected ) if ( isLineSelected )
@ -1203,14 +1196,14 @@ inline void FListBox::setLineAttributes ( int y
if ( isCurrentLine ) if ( isCurrentLine )
{ {
if ( isFocus && getMaxColor() < 16 ) if ( flags.focus && getMaxColor() < 16 )
setBold(); setBold();
if ( isLineSelected ) if ( isLineSelected )
{ {
if ( isMonochron() ) if ( isMonochron() )
setBold(); setBold();
else if ( isFocus ) else if ( flags.focus )
setColor ( wc.selected_current_element_focus_fg setColor ( wc.selected_current_element_focus_fg
, wc.selected_current_element_focus_bg ); , wc.selected_current_element_focus_bg );
else else
@ -1224,7 +1217,7 @@ inline void FListBox::setLineAttributes ( int y
if ( isMonochron() ) if ( isMonochron() )
unsetBold(); unsetBold();
if ( isFocus ) if ( flags.focus )
{ {
setColor ( wc.current_element_focus_fg setColor ( wc.current_element_focus_fg
, wc.current_element_focus_bg ); , wc.current_element_focus_bg );
@ -1251,7 +1244,7 @@ inline void FListBox::setLineAttributes ( int y
{ {
if ( isMonochron() ) if ( isMonochron() )
setReverse(true); setReverse(true);
else if ( isFocus && getMaxColor() < 16 ) else if ( flags.focus && getMaxColor() < 16 )
unsetBold(); unsetBold();
} }
} }
@ -1532,17 +1525,17 @@ void FListBox::prevListItem (int distance)
if ( current == 1 ) if ( current == 1 )
return; return;
current -= std::size_t(distance); if ( current <= std::size_t(distance) )
if ( current < 1 )
current = 1; current = 1;
else
current -= std::size_t(distance);
if ( current <= std::size_t(yoffset) ) if ( current <= std::size_t(yoffset) )
{ {
yoffset -= distance; if ( yoffset < distance )
if ( yoffset < 0 )
yoffset = 0; yoffset = 0;
else
yoffset -= distance;
} }
} }
@ -1555,23 +1548,23 @@ void FListBox::nextListItem (int distance)
if ( current == element_count ) if ( current == element_count )
return; return;
current += std::size_t(distance); if ( current + std::size_t(distance) > element_count )
if ( current > element_count )
current = element_count; current = element_count;
else
current += std::size_t(distance);
if ( current - std::size_t(yoffset) > getClientHeight() ) if ( current - std::size_t(yoffset) > getClientHeight() )
{ {
yoffset += distance; if ( yoffset > yoffset_end - distance )
if ( yoffset > yoffset_end )
yoffset = yoffset_end; yoffset = yoffset_end;
else
yoffset += distance;
} }
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FListBox::scrollToX (int val) void FListBox::scrollToX (int val)
{ {
static const std::size_t padding_space = 2; // 1 leading space + 1 trailing space static const std::size_t padding_space = 2; // 1 leading + 1 trailing space
std::size_t xoffset_end = max_line_width - getClientWidth() + padding_space; std::size_t xoffset_end = max_line_width - getClientWidth() + padding_space;
if ( xoffset == val ) if ( xoffset == val )
@ -1628,7 +1621,7 @@ void FListBox::scrollLeft (int distance)
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FListBox::scrollRight (int distance) void FListBox::scrollRight (int distance)
{ {
static const std::size_t padding_space = 2; // 1 leading space + 1 trailing space static const std::size_t padding_space = 2; // 1 leading + 1 trailing space
std::size_t xoffset_end = max_line_width - getClientWidth() + padding_space; std::size_t xoffset_end = max_line_width - getClientWidth() + padding_space;
xoffset += distance; xoffset += distance;
@ -1832,7 +1825,7 @@ inline bool FListBox::keyBackspace()
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline bool FListBox::keyIncSearchInput (int key) inline bool FListBox::keyIncSearchInput (FKey key)
{ {
if ( key <= 0x20 || key > 0x10fff ) if ( key <= 0x20 || key > 0x10fff )
return false; return false;

415
src/flistview.cpp
View File

@ -167,6 +167,8 @@ FListViewItem::FListViewItem (const FListViewItem& item)
, visible_lines(1) , visible_lines(1)
, expandable(false) , expandable(false)
, is_expand(false) , is_expand(false)
, checkable(false)
, is_checked(false)
{ {
FObject* parent = getParent(); FObject* parent = getParent();
@ -192,6 +194,8 @@ FListViewItem::FListViewItem (FObjectIterator parent_iter)
, visible_lines(1) , visible_lines(1)
, expandable(false) , expandable(false)
, is_expand(false) , is_expand(false)
, checkable(false)
, is_checked(false)
{ {
insert (this, parent_iter); insert (this, parent_iter);
} }
@ -207,6 +211,8 @@ FListViewItem::FListViewItem ( const FStringList& cols
, visible_lines(1) , visible_lines(1)
, expandable(false) , expandable(false)
, is_expand(false) , is_expand(false)
, checkable(false)
, is_checked(false)
{ {
if ( cols.empty() ) if ( cols.empty() )
return; return;
@ -325,7 +331,7 @@ FObject::FObjectIterator FListViewItem::insert ( FListViewItem* child
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FListViewItem::expand() void FListViewItem::expand()
{ {
if ( is_expand || ! hasChildren() ) if ( isExpand() || ! hasChildren() )
return; return;
is_expand = true; is_expand = true;
@ -334,7 +340,7 @@ void FListViewItem::expand()
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FListViewItem::collapse() void FListViewItem::collapse()
{ {
if ( ! is_expand ) if ( ! isExpand() )
return; return;
is_expand = false; is_expand = false;
@ -346,7 +352,7 @@ void FListViewItem::collapse()
template <typename Compare> template <typename Compare>
void FListViewItem::sort (Compare cmp) void FListViewItem::sort (Compare cmp)
{ {
if ( ! expandable ) if ( ! isExpandable() )
return; return;
// Sort the top level // Sort the top level
@ -418,6 +424,20 @@ std::size_t FListViewItem::getVisibleLines()
return visible_lines; return visible_lines;
} }
//----------------------------------------------------------------------
void FListViewItem::setCheckable (bool on)
{
checkable = on;
if ( *root )
{
FListView* root_obj = static_cast<FListView*>(*root);
if ( ! root_obj->hasCheckableItems() && isCheckable() )
root_obj->has_checkable_items = true;
}
}
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FListViewItem::resetVisibleLineCounter() void FListViewItem::resetVisibleLineCounter()
{ {
@ -610,7 +630,11 @@ FListView::FListView (FWidget* parent)
, scroll_distance(1) , scroll_distance(1)
, scroll_timer(false) , scroll_timer(false)
, tree_view(false) , tree_view(false)
, hide_sort_indicator(false)
, has_checkable_items(false)
, clicked_expander_pos(-1, -1) , clicked_expander_pos(-1, -1)
, clicked_header_pos(-1, -1)
, clicked_checkbox_item(0)
, xoffset(0) , xoffset(0)
, nf_offset(0) , nf_offset(0)
, max_line_width(1) , max_line_width(1)
@ -693,7 +717,9 @@ fc::sorting_type FListView::getColumnSortType (int column) const
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FListView::setGeometry (int x, int y, std::size_t w, std::size_t h, bool adjust) void FListView::setGeometry ( int x, int y
, std::size_t w, std::size_t h
, bool adjust )
{ {
// Set the widget geometry // Set the widget geometry
@ -798,14 +824,11 @@ FObject::FObjectIterator FListView::insert ( FListViewItem* item
, FObjectIterator parent_iter ) , FObjectIterator parent_iter )
{ {
FObjectIterator item_iter; FObjectIterator item_iter;
int line_width;
int element_count;
if ( parent_iter == FListView::null_iter ) if ( parent_iter == FListView::null_iter )
return FListView::null_iter; return FListView::null_iter;
line_width = determineLineWidth (item); beforeInsertion(item); // preprocessing
recalculateHorizontalBar (line_width);
if ( parent_iter == root ) if ( parent_iter == root )
{ {
@ -831,19 +854,7 @@ FObject::FObjectIterator FListView::insert ( FListViewItem* item
else else
item_iter = FListView::null_iter; item_iter = FListView::null_iter;
if ( itemlist.size() == 1 ) afterInsertion(); // post-processing
{
// Select first item on insert
current_iter = itemlist.begin();
// The visible area of the list begins with the first element
first_visible_line = itemlist.begin();
}
// Sort list by a column (only if activated)
sort();
element_count = int(getCount());
recalculateVerticalBar (element_count);
return item_iter; return item_iter;
} }
@ -948,8 +959,8 @@ void FListView::onKeyPress (FKeyEvent* ev)
int position_before = current_iter.getPosition() int position_before = current_iter.getPosition()
, xoffset_before = xoffset , xoffset_before = xoffset
, first_line_position_before = first_visible_line.getPosition() , first_line_position_before = first_visible_line.getPosition()
, pagesize = int(getClientHeight()) - 1 , pagesize = int(getClientHeight()) - 1;
, key = ev->key(); FKey key = ev->key();
clicked_expander_pos.setPoint(-1, -1); clicked_expander_pos.setPoint(-1, -1);
switch ( key ) switch ( key )
@ -960,6 +971,11 @@ void FListView::onKeyPress (FKeyEvent* ev)
ev->accept(); ev->accept();
break; break;
case fc::Fkey_space:
keySpace();
ev->accept();
break;
case fc::Fkey_up: case fc::Fkey_up:
stepBackward(); stepBackward();
ev->accept(); ev->accept();
@ -1053,34 +1069,55 @@ void FListView::onMouseDown (FMouseEvent* ev)
, mouse_x = ev->getX() , mouse_x = ev->getX()
, mouse_y = ev->getY(); , mouse_y = ev->getY();
if ( mouse_x > 1 && mouse_x < int(getWidth()) if ( mouse_x > 1 && mouse_x < int(getWidth()) )
&& mouse_y > 1 && mouse_y < int(getHeight()) )
{ {
int new_pos = first_visible_line.getPosition() + mouse_y - 2; if ( mouse_y == 1 ) // Header
if ( new_pos < int(getCount()) )
setRelativePosition (mouse_y - 2);
if ( tree_view )
{ {
const FListViewItem* item = getCurrentItem(); clicked_header_pos = ev->getPos();
int indent = int(item->getDepth() << 1); // indent = 2 * depth
if ( item->isExpandable() && mouse_x - 2 == indent - xoffset )
clicked_expander_pos = ev->getPos();
} }
else if ( mouse_y > 1 && mouse_y < int(getHeight()) ) // List
{
int indent = 0;
int new_pos = first_visible_line.getPosition() + mouse_y - 2;
if ( isVisible() ) if ( new_pos < int(getCount()) )
drawList(); setRelativePosition (mouse_y - 2);
vbar->setValue (first_visible_line.getPosition()); const FListViewItem* item = getCurrentItem();
if ( vbar->isVisible() if ( tree_view )
&& first_line_position_before != first_visible_line.getPosition() ) {
vbar->drawBar(); indent = int(item->getDepth() << 1); // indent = 2 * depth
updateTerminal(); if ( item->isExpandable() && mouse_x - 2 == indent - xoffset )
flush_out(); clicked_expander_pos = ev->getPos();
}
if ( hasCheckableItems() )
{
if ( tree_view )
indent++; // Plus one space
if ( mouse_x >= 3 + indent - xoffset
&& mouse_x <= 5 + indent - xoffset
&& item->isCheckable() )
{
clicked_checkbox_item = item;
}
}
if ( isVisible() )
drawList();
vbar->setValue (first_visible_line.getPosition());
if ( vbar->isVisible()
&& first_line_position_before != first_visible_line.getPosition() )
vbar->drawBar();
updateTerminal();
flush_out();
}
} }
} }
@ -1095,32 +1132,60 @@ void FListView::onMouseUp (FMouseEvent* ev)
int mouse_x = ev->getX(); int mouse_x = ev->getX();
int mouse_y = ev->getY(); int mouse_y = ev->getY();
if ( mouse_x > 1 && mouse_x < int(getWidth()) if ( mouse_x > 1 && mouse_x < int(getWidth()) )
&& mouse_y > 1 && mouse_y < int(getHeight()) )
{ {
if ( tree_view ) if ( mouse_y == 1 && clicked_header_pos == ev->getPos() ) // Header
{ {
mouseHeaderClicked();
}
else if ( mouse_y > 1 && mouse_y < int(getHeight()) ) // List
{
int indent = 0;
FListViewItem* item = getCurrentItem(); FListViewItem* item = getCurrentItem();
if ( item->isExpandable() && clicked_expander_pos == ev->getPos() ) if ( tree_view )
{ {
if ( item->isExpand() ) indent = int(item->getDepth() << 1); // indent = 2 * depth
item->collapse();
else
item->expand();
adjustSize(); if ( item->isExpandable()
&& clicked_expander_pos == ev->getPos() )
{
if ( item->isExpand() )
item->collapse();
else
item->expand();
if ( isVisible() ) adjustSize();
draw();
if ( isVisible() )
draw();
}
} }
}
processChanged(); if ( hasCheckableItems() )
{
if ( tree_view )
indent++; // Plus one space
if ( mouse_x >= 3 + indent - xoffset
&& mouse_x <= 5 + indent - xoffset
&& clicked_checkbox_item == item )
{
item->setChecked(! item->isChecked());
if ( isVisible() )
draw();
}
}
processChanged();
}
} }
} }
clicked_expander_pos.setPoint(-1, -1); clicked_expander_pos.setPoint(-1, -1);
clicked_header_pos.setPoint(-1, -1);
clicked_checkbox_item = 0;
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -1479,8 +1544,6 @@ std::size_t FListView::getAlignOffset ( fc::text_alignment align
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FListView::draw() void FListView::draw()
{ {
bool isFocus;
if ( current_iter.getPosition() < 1 ) if ( current_iter.getPosition() < 1 )
current_iter = itemlist.begin(); current_iter = itemlist.begin();
@ -1505,7 +1568,7 @@ void FListView::draw()
} }
} }
drawColumnLabels(); drawHeadlines();
if ( isMonochron() ) if ( isMonochron() )
setReverse(false); setReverse(false);
@ -1517,9 +1580,8 @@ void FListView::draw()
hbar->redraw(); hbar->redraw();
drawList(); drawList();
isFocus = ((flags & fc::focus) != 0);
if ( isFocus && getStatusBar() ) if ( flags.focus && getStatusBar() )
{ {
const FString& msg = getStatusbarMessage(); const FString& msg = getStatusbarMessage();
const FString& curMsg = getStatusBar()->getMessage(); const FString& curMsg = getStatusBar()->getMessage();
@ -1533,7 +1595,7 @@ void FListView::draw()
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FListView::drawColumnLabels() void FListView::drawHeadlines()
{ {
std::vector<charData>::const_iterator first, last; std::vector<charData>::const_iterator first, last;
headerItems::const_iterator iter; headerItems::const_iterator iter;
@ -1547,6 +1609,9 @@ void FListView::drawColumnLabels()
iter = header.begin(); iter = header.begin();
headerline.clear(); headerline.clear();
if ( hasCheckableItems() )
drawHeaderBorder(4);
while ( iter != header.end() ) while ( iter != header.end() )
{ {
const FString& text = iter->name; const FString& text = iter->name;
@ -1557,7 +1622,7 @@ void FListView::drawColumnLabels()
continue; continue;
} }
drawColumnText(iter); drawHeadlineLabel(iter);
++iter; ++iter;
} }
@ -1585,28 +1650,32 @@ void FListView::drawColumnLabels()
void FListView::drawList() void FListView::drawList()
{ {
uInt page_height, y; uInt page_height, y;
bool is_focus;
FListViewIterator iter; FListViewIterator iter;
if ( itemlist.empty() || getHeight() <= 2 || getWidth() <= 4 ) if ( itemlist.empty() || getHeight() <= 2 || getWidth() <= 4 )
return; return;
y = 0; y = 0;
page_height = uInt(getHeight() - 2); page_height = uInt(getHeight() - 2);
is_focus = ((flags & fc::focus) != 0); iter = first_visible_line;
iter = first_visible_line;
while ( iter != itemlist.end() && y < page_height ) while ( iter != itemlist.end() && y < page_height )
{ {
bool is_current_line = bool( iter == current_iter ); bool is_current_line = bool( iter == current_iter );
const FListViewItem* item = static_cast<FListViewItem*>(*iter); const FListViewItem* item = static_cast<FListViewItem*>(*iter);
int tree_offset = ( tree_view ) ? int(item->getDepth() << 1) + 1 : 0;
int checkbox_offset = ( item->isCheckable() ) ? 1 : 0;
setPrintPos (2, 2 + int(y)); setPrintPos (2, 2 + int(y));
// Draw one FListViewItem // Draw one FListViewItem
drawListLine (item, is_focus, is_current_line); drawListLine (item, flags.focus, is_current_line);
if ( is_focus && is_current_line ) if ( flags.focus && is_current_line )
setCursorPos (3, 2 + int(y)); // first character {
setVisibleCursor (item->isCheckable());
setCursorPos ( 3 + tree_offset + checkbox_offset - xoffset
, 2 + int(y)); // first character
}
last_visible_line = iter; last_visible_line = iter;
y++; y++;
@ -1616,6 +1685,9 @@ void FListView::drawList()
// Reset color // Reset color
setColor(); setColor();
if ( isMonochron() )
setReverse(true);
// Clean empty space after last element // Clean empty space after last element
while ( y < uInt(getClientHeight()) ) while ( y < uInt(getClientHeight()) )
{ {
@ -1630,35 +1702,37 @@ void FListView::drawListLine ( const FListViewItem* item
, bool is_focus , bool is_focus
, bool is_current ) , bool is_current )
{ {
std::size_t indent = item->getDepth() << 1; // indent = 2 * depth
// Set line color and attributes // Set line color and attributes
setLineAttributes (is_current, is_focus); setLineAttributes (is_current, is_focus);
// Print the entry // Print the entry
std::size_t indent = item->getDepth() << 1; // indent = 2 * depth
FString line = getLinePrefix (item, indent); FString line = getLinePrefix (item, indent);
// Print columns // Print columns
if ( ! item->column_list.empty() ) if ( ! item->column_list.empty() )
{ {
for (std::size_t i = 0; i < item->column_list.size(); ) for (std::size_t col = 0; col < item->column_list.size(); )
{ {
static const std::size_t leading_space = 1; static const std::size_t leading_space = 1;
static const std::size_t checkbox_space = 4;
static const std::size_t ellipsis_length = 2; static const std::size_t ellipsis_length = 2;
const FString& text = item->column_list[i]; const FString& text = item->column_list[col];
std::size_t width = std::size_t(header[i].width); std::size_t width = std::size_t(header[col].width);
std::size_t txt_length = text.getLength(); std::size_t txt_length = text.getLength();
// Increment the value of i for the column position // Increment the value of i for the column position
// and the next iteration // and the next iteration
i++; col++;
fc::text_alignment align = getColumnAlignment(int(i)); fc::text_alignment align = getColumnAlignment(int(col));
std::size_t align_offset = getAlignOffset (align, txt_length, width); std::size_t align_offset = getAlignOffset (align, txt_length, width);
if ( tree_view && i == 1 ) if ( tree_view && col == 1 )
{ {
width -= indent; width -= (indent + 1);
width--;
if ( item->isCheckable() )
width -= checkbox_space;
} }
// Insert alignment spaces // Insert alignment spaces
@ -1736,20 +1810,41 @@ inline void FListView::setLineAttributes ( bool is_current
} }
} }
//----------------------------------------------------------------------
inline FString FListView::getCheckBox (const FListViewItem* item)
{
FString checkbox;
if ( isNewFont() )
{
checkbox = ( item->isChecked() ) ? CHECKBOX_ON : CHECKBOX;
checkbox += L' ';
}
else
{
checkbox = L"[ ] ";
if ( item->isChecked() )
checkbox[1] = wchar_t(fc::Times); // Times ×
}
return checkbox;
}
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline FString FListView::getLinePrefix ( const FListViewItem* item inline FString FListView::getLinePrefix ( const FListViewItem* item
, std::size_t indent ) , std::size_t indent )
{ {
FString line = ""; FString line;
if ( tree_view ) if ( tree_view )
{ {
if ( indent > 0 ) if ( indent > 0 )
line = FString(indent, L' '); line = FString(indent, L' ');
if ( item->expandable ) if ( item->isExpandable() )
{ {
if ( item->is_expand ) if ( item->isExpand() )
{ {
line += wchar_t(fc::BlackDownPointingTriangle); // ▼ line += wchar_t(fc::BlackDownPointingTriangle); // ▼
line += L' '; line += L' ';
@ -1766,40 +1861,84 @@ inline FString FListView::getLinePrefix ( const FListViewItem* item
else else
line = L" "; line = L" ";
if ( item->isCheckable() )
line += getCheckBox(item);
return line; return line;
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FListView::drawColumnText (headerItems::const_iterator& iter) inline void FListView::drawSortIndicator ( std::size_t& length
, std::size_t column_width )
{
if ( length >= column_width )
return;
setColor();
length++;
if ( sort_order == fc::ascending )
headerline << wchar_t(fc::BlackUpPointingTriangle); // ▲
else if ( sort_order == fc::descending )
headerline << wchar_t(fc::BlackDownPointingTriangle); // ▼
if ( length < column_width )
{
length++;
headerline << ' ';
}
}
//----------------------------------------------------------------------
inline void FListView::drawHeaderBorder (std::size_t length)
{
setColor();
const FString line (length, wchar_t(fc::BoxDrawingsHorizontal));
headerline << line; // horizontal line
}
//----------------------------------------------------------------------
void FListView::drawHeadlineLabel (headerItems::const_iterator& iter)
{ {
// Print lable text // Print lable text
static const std::size_t leading_space = 1; static const std::size_t leading_space = 1;
static const std::size_t trailing_space = 1;
const FString& text = iter->name; const FString& text = iter->name;
std::size_t width = std::size_t(iter->width);
FString txt = " " + text; FString txt = " " + text;
std::size_t width = std::size_t(iter->width);
std::size_t txt_length = txt.getLength(); std::size_t txt_length = txt.getLength();
std::size_t column_width = leading_space + width; std::size_t column_width = leading_space + width;
headerItems::const_iterator first = header.begin();
int column = int(std::distance(first, iter)) + 1;
bool has_sort_indicator = bool ( sort_column == column
&& ! hide_sort_indicator );
if ( isEnabled() ) if ( isEnabled() )
setColor (wc.label_emphasis_fg, wc.label_bg); setColor (wc.label_emphasis_fg, wc.label_bg);
else else
setColor (wc.label_inactive_fg, wc.label_inactive_bg); setColor (wc.label_inactive_fg, wc.label_inactive_bg);
if ( has_sort_indicator && txt_length >= column_width - 1 && txt_length > 1 )
{
txt_length = column_width - 2;
txt = txt.left(txt_length);
}
if ( txt_length <= column_width ) if ( txt_length <= column_width )
{ {
std::size_t length = txt_length;
headerline << txt; headerline << txt;
if ( txt_length < column_width ) if ( length < column_width )
headerline << ' '; // trailing space
if ( txt_length + trailing_space < column_width )
{ {
setColor(); length++;
const FString line ( column_width - trailing_space - txt_length headerline << ' '; // trailing space
, wchar_t(fc::BoxDrawingsHorizontal) );
headerline << line; // horizontal line
} }
if ( has_sort_indicator )
drawSortIndicator (length, column_width );
if ( length < column_width )
drawHeaderBorder (column_width - length);
} }
else else
drawColumnEllipsis (iter, text); // Print ellipsis drawColumnEllipsis (iter, text); // Print ellipsis
@ -1878,6 +2017,31 @@ int FListView::determineLineWidth (FListViewItem* item)
return line_width; return line_width;
} }
//----------------------------------------------------------------------
inline void FListView::beforeInsertion (FListViewItem* item)
{
int line_width = determineLineWidth (item);
recalculateHorizontalBar (line_width);
}
//----------------------------------------------------------------------
inline void FListView::afterInsertion()
{
if ( itemlist.size() == 1 )
{
// Select first item on insert
current_iter = itemlist.begin();
// The visible area of the list begins with the first element
first_visible_line = itemlist.begin();
}
// Sort list by a column (only if activated)
sort();
int element_count = int(getCount());
recalculateVerticalBar (element_count);
}
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FListView::recalculateHorizontalBar (int len) void FListView::recalculateHorizontalBar (int len)
{ {
@ -1908,6 +2072,54 @@ void FListView::recalculateVerticalBar (int element_count)
vbar->setVisible(); vbar->setVisible();
} }
//----------------------------------------------------------------------
void FListView::mouseHeaderClicked()
{
int column = 1;
int checkbox_offset = ( hasCheckableItems() ) ? 4 : 0;
int header_start = 2 + checkbox_offset;
int header_pos = clicked_header_pos.getX() + xoffset;
headerItems::const_iterator iter;
iter = header.begin();
while ( iter != header.end() )
{
static const int leading_space = 1;
bool has_sort_indicator = bool( column == sort_column );
int click_width = int(iter->name.getLength());
if ( has_sort_indicator )
click_width += 2;
if ( click_width > iter->width )
click_width = iter->width;
if ( header_pos > header_start
&& header_pos <= header_start + click_width )
{
if ( has_sort_indicator && sort_order == fc::ascending )
setColumnSort (column, fc::descending);
else
setColumnSort (column, fc::ascending);
sort();
if ( isVisible() )
{
drawHeadlines();
drawList();
updateTerminal();
flush_out();
}
break;
}
header_start += leading_space + iter->width;
column++;
++iter;
}
}
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FListView::wheelUp (int pagesize) void FListView::wheelUp (int pagesize)
{ {
@ -2066,6 +2278,15 @@ void FListView::processChanged()
emitCallback("row-changed"); emitCallback("row-changed");
} }
//----------------------------------------------------------------------
inline void FListView::keySpace()
{
FListViewItem* item = getCurrentItem();
if ( item->isCheckable() )
item->setChecked(! item->isChecked());
}
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline void FListView::keyLeft (int& first_line_position_before) inline void FListView::keyLeft (int& first_line_position_before)
{ {
@ -2271,7 +2492,7 @@ void FListView::stepForward (int distance)
void FListView::stepBackward (int distance) void FListView::stepBackward (int distance)
{ {
if ( current_iter.getPosition() == 0 ) if ( current_iter.getPosition() == 0 )
return; return;
if ( current_iter.getPosition() - distance >= 0 ) if ( current_iter.getPosition() - distance >= 0 )
{ {
@ -2468,7 +2689,7 @@ void FListView::cb_HBarChange (FWidget*, data_ptr)
if ( isVisible() ) if ( isVisible() )
{ {
drawColumnLabels(); drawHeadlines();
drawList(); drawList();
updateTerminal(); updateTerminal();
flush_out(); flush_out();

26
src/fmenu.cpp
View File

@ -71,7 +71,7 @@ FMenu::~FMenu() // destructor
FApplication* fapp = static_cast<FApplication*>(getRootWidget()); FApplication* fapp = static_cast<FApplication*>(getRootWidget());
if ( ! fapp->isQuit() ) if ( ! fapp->isQuit() )
switchToPrevWindow(); // Switch to previous window switchToPrevWindow(this); // Switch to previous window
} }
@ -82,12 +82,7 @@ bool FMenu::setMenuWidget (bool on)
if ( isMenuWidget() == on ) if ( isMenuWidget() == on )
return true; return true;
if ( on ) return (flags.menu_widget = on);
flags |= fc::menu_widget;
else
flags &= ~fc::menu_widget;
return on;
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -496,7 +491,7 @@ void FMenu::calculateDimensions()
while ( iter != last ) while ( iter != last )
{ {
std::size_t item_width = (*iter)->getTextLength() + 2; std::size_t item_width = (*iter)->getTextLength() + 2;
int accel_key = (*iter)->accel_key; FKey accel_key = (*iter)->accel_key;
bool has_menu = (*iter)->hasMenu(); bool has_menu = (*iter)->hasMenu();
if ( has_menu ) if ( has_menu )
@ -1176,12 +1171,13 @@ bool FMenu::hotkeyMenu (FKeyEvent* ev)
if ( (*iter)->hasHotkey() ) if ( (*iter)->hasHotkey() )
{ {
bool found = false; bool found = false;
int hotkey = (*iter)->getHotkey(); uChar hotkey = (*iter)->getHotkey();
int key = ev->key(); FKey key = ev->key();
if ( std::isalpha(hotkey) || std::isdigit(hotkey) ) if ( std::isalpha(hotkey) || std::isdigit(hotkey) )
{ {
if ( std::tolower(hotkey) == key || std::toupper(hotkey) == key ) if ( FKey(std::tolower(hotkey)) == key
|| FKey(std::toupper(hotkey)) == key )
found = true; found = true;
} }
else if ( hotkey == key ) else if ( hotkey == key )
@ -1321,7 +1317,7 @@ inline void FMenu::drawMenuLine (FMenuItem* menuitem, int y)
menuText txtdata; menuText txtdata;
std::size_t txt_length = txt.getLength(); std::size_t txt_length = txt.getLength();
std::size_t to_char = txt_length; std::size_t to_char = txt_length;
int accel_key = menuitem->accel_key; FKey accel_key = menuitem->accel_key;
bool is_enabled = menuitem->isEnabled(); bool is_enabled = menuitem->isEnabled();
bool is_selected = menuitem->isSelected(); bool is_selected = menuitem->isSelected();
@ -1350,7 +1346,7 @@ inline void FMenu::drawMenuLine (FMenuItem* menuitem, int y)
to_char--; to_char--;
txtdata.length = to_char; txtdata.length = to_char;
txtdata.no_underline = ((menuitem->getFlags() & fc::no_underline) != 0); txtdata.no_underline = menuitem->getFlags().no_underline;
setCursorToHotkeyPosition (menuitem); setCursorToHotkeyPosition (menuitem);
if ( ! is_enabled || is_selected ) if ( ! is_enabled || is_selected )
@ -1474,7 +1470,7 @@ inline void FMenu::drawSubMenuIndicator (std::size_t& startpos)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline void FMenu::drawAcceleratorKey (std::size_t& startpos, int accel_key) inline void FMenu::drawAcceleratorKey (std::size_t& startpos, FKey accel_key)
{ {
FString accel_name (getKeyName(accel_key)); FString accel_name (getKeyName(accel_key));
std::size_t c = ( has_checkable_items ) ? 1 : 0; std::size_t c = ( has_checkable_items ) ? 1 : 0;
@ -1664,7 +1660,7 @@ inline void FMenu::keyEscape()
getStatusBar()->clearMessage(); getStatusBar()->clearMessage();
if ( ! (super && isWindowsMenu(super)) ) if ( ! (super && isWindowsMenu(super)) )
switchToPrevWindow(); switchToPrevWindow(this);
} }
if ( getStatusBar() ) if ( getStatusBar() )

14
src/fmenubar.cpp
View File

@ -63,7 +63,7 @@ void FMenuBar::resetMenu()
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FMenuBar::hide() void FMenuBar::hide()
{ {
short fg, bg; FColor fg, bg;
FWindow::hide(); FWindow::hide();
fg = wc.term_fg; fg = wc.term_fg;
bg = wc.term_bg; bg = wc.term_bg;
@ -426,10 +426,10 @@ bool FMenuBar::hotkeyMenu (FKeyEvent*& ev)
{ {
if ( (*iter)->isEnabled() ) if ( (*iter)->isEnabled() )
{ {
int hotkey = (*iter)->getHotkey(); uChar hotkey = (*iter)->getHotkey();
int key = ev->key(); FKey key = ev->key();
if ( fc::Fmkey_meta + std::tolower(hotkey) == key ) if ( fc::Fmkey_meta + FKey(std::tolower(hotkey)) == key )
{ {
FMenuItem* sel_item = getSelectedItem(); FMenuItem* sel_item = getSelectedItem();
@ -519,7 +519,7 @@ void FMenuBar::drawItems()
if ( item_list.empty() ) if ( item_list.empty() )
return; return;
setPrintPos (1,1); setPrintPos (1, 1);
if ( isMonochron() ) if ( isMonochron() )
setReverse(true); setReverse(true);
@ -554,7 +554,7 @@ inline void FMenuBar::drawItem (FMenuItem* menuitem, std::size_t& x)
bool is_selected = menuitem->isSelected(); bool is_selected = menuitem->isSelected();
txtdata.startpos = x + 1; txtdata.startpos = x + 1;
txtdata.no_underline = ((menuitem->getFlags() & fc::no_underline) != 0); txtdata.no_underline = menuitem->getFlags().no_underline;
// Set screen attributes // Set screen attributes
setLineAttributes (menuitem); setLineAttributes (menuitem);
@ -1042,7 +1042,7 @@ void FMenuBar::leaveMenuBar()
if ( getStatusBar() ) if ( getStatusBar() )
getStatusBar()->clearMessage(); getStatusBar()->clearMessage();
switchToPrevWindow(); switchToPrevWindow(this);
if ( getStatusBar() ) if ( getStatusBar() )
getStatusBar()->drawMessage(); getStatusBar()->drawMessage();

14
src/fmenuitem.cpp
View File

@ -77,7 +77,7 @@ FMenuItem::FMenuItem (const FString& txt, FWidget* parent)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FMenuItem::FMenuItem (int k, const FString& txt, FWidget* parent) FMenuItem::FMenuItem (FKey k, const FString& txt, FWidget* parent)
: FWidget(parent) : FWidget(parent)
, text(txt) , text(txt)
, selected(false) , selected(false)
@ -127,7 +127,8 @@ bool FMenuItem::setEnable (bool on)
if ( super && isMenuBar(super) ) if ( super && isMenuBar(super) )
{ {
// Meta + hotkey // Meta + hotkey
super->addAccelerator (fc::Fmkey_meta + std::tolower(hotkey), this); super->addAccelerator ( fc::Fmkey_meta + FKey(std::tolower(hotkey))
, this );
} }
} }
else else
@ -231,8 +232,7 @@ void FMenuItem::setText (const FString& txt)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FMenuItem::addAccelerator (FKey key, FWidget* obj)
void FMenuItem::addAccelerator (int key, FWidget* obj)
{ {
FWidget* root = getRootWidget(); FWidget* root = getRootWidget();
accelerator accel = { key, obj }; accelerator accel = { key, obj };
@ -596,7 +596,7 @@ void FMenuItem::init (FWidget* parent)
setSuperMenu (parent); setSuperMenu (parent);
if ( accel_key ) if ( accel_key )
addAccelerator (accel_key); addAccelerator (accel_key);
FMenuList* menu_list = getFMenuList(*parent); FMenuList* menu_list = getFMenuList(*parent);
@ -610,7 +610,7 @@ void FMenuItem::init (FWidget* parent)
menubar_ptr->calculateDimensions(); menubar_ptr->calculateDimensions();
if ( hotkey ) // Meta + hotkey if ( hotkey ) // Meta + hotkey
menubar_ptr->addAccelerator ( fc::Fmkey_meta + std::tolower(hotkey) menubar_ptr->addAccelerator ( fc::Fmkey_meta + FKey(std::tolower(hotkey))
, this ); , this );
addCallback // for this element addCallback // for this element
@ -681,7 +681,7 @@ void FMenuItem::createDialogList (FMenu* winmenu)
if ( win ) if ( win )
{ {
FMenuItem* win_item; FMenuItem* win_item;
int n = int(std::distance(first, iter)); uInt32 n = uInt32(std::distance(first, iter));
// get the dialog title // get the dialog title
const FString& name = win->getText(); const FString& name = win->getText();

8
src/fmouse.cpp
View File

@ -47,8 +47,8 @@ FMouse::FMouse()
, max_width(80) , max_width(80)
, max_height(25) , max_height(25)
, time_mousepressed() , time_mousepressed()
, zero_point(0,0) // zero point (x=0, y=0) , zero_point(0, 0) // zero point (x=0, y=0)
, mouse(0,0) // mouse click position , mouse(0, 0) // mouse click position
, new_mouse_position() , new_mouse_position()
{ {
time_mousepressed.tv_sec = 0; time_mousepressed.tv_sec = 0;
@ -1200,7 +1200,7 @@ void FMouseUrxvt::setButtonState (int btn, struct timeval* time)
FMouseControl::FMouseControl() FMouseControl::FMouseControl()
: mouse_protocol() : mouse_protocol()
, iter() , iter()
, zero_point(0,0) , zero_point(0, 0)
, use_gpm_mouse(false) , use_gpm_mouse(false)
, use_xterm_mouse(false) , use_xterm_mouse(false)
{ {
@ -1575,7 +1575,7 @@ bool FMouseControl::getGpmKeyPressed (bool)
if ( gpm_mouse ) if ( gpm_mouse )
return gpm_mouse->getGpmKeyPressed(pending); return gpm_mouse->getGpmKeyPressed(pending);
#endif // F_HAVE_LIBGPM #endif // F_HAVE_LIBGPM
return false; return false;
} }

46
src/foptiattr.cpp
View File

@ -552,7 +552,7 @@ void FOptiAttr::initialize()
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
short FOptiAttr::vga2ansi (short color) FColor FOptiAttr::vga2ansi (FColor color)
{ {
// VGA | ANSI // VGA | ANSI
// i R G B | i B G R // i R G B | i B G R
@ -574,9 +574,11 @@ short FOptiAttr::vga2ansi (short color)
// 1 1 1 0 | 1 0 1 1 // 1 1 1 0 | 1 0 1 1
// 1 1 1 1 | 1 1 1 1 // 1 1 1 1 | 1 1 1 1
if ( color >= 0 && color < 16 ) if ( color == fc::Default )
color = 0;
else if ( color < 16 )
{ {
static const short lookup_table[] = static const FColor lookup_table[] =
{ {
0, 4, 2, 6, 1, 5, 3, 7, 0, 4, 2, 6, 1, 5, 3, 7,
8, 12, 10, 14, 9, 13, 11, 15 8, 12, 10, 14, 9, 13, 11, 15
@ -584,8 +586,6 @@ short FOptiAttr::vga2ansi (short color)
color = lookup_table[color]; color = lookup_table[color];
} }
else if ( color < 0 )
color = 0;
return color; return color;
} }
@ -610,7 +610,7 @@ char* FOptiAttr::changeAttribute (charData*& term, charData*& next)
next->code = ' '; next->code = ' ';
// Look for no changes // Look for no changes
if ( ! (switchOn() || switchOff() || colorChange(term, next)) ) if ( ! (switchOn() || switchOff() || hasColorChanged(term, next)) )
return 0; return 0;
if ( hasNoAttribute(next) ) if ( hasNoAttribute(next) )
@ -794,7 +794,7 @@ inline bool FOptiAttr::unsetTermBlink (charData*& term)
if ( F_exit_blink_mode.caused_reset ) if ( F_exit_blink_mode.caused_reset )
reset(term); reset(term);
else else
term->attr.bit.blink = false; term->attr.bit.blink = false;
if ( append_sequence(F_exit_blink_mode.cap) ) if ( append_sequence(F_exit_blink_mode.cap) )
return true; return true;
@ -1227,7 +1227,9 @@ void FOptiAttr::setAttributesOff (charData*& term)
//---------------------------------------------------------------------- //----------------------------------------------------------------------
bool FOptiAttr::hasColor (charData*& attr) bool FOptiAttr::hasColor (charData*& attr)
{ {
if ( attr && attr->fg_color < 0 && attr->bg_color < 0 ) if ( attr
&& attr->fg_color == fc::Default
&& attr->bg_color == fc::Default )
return false; return false;
else else
return true; return true;
@ -1263,7 +1265,7 @@ bool FOptiAttr::hasNoAttribute (charData*& attr)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline bool FOptiAttr::colorChange (charData*& term, charData*& next) inline bool FOptiAttr::hasColorChanged (charData*& term, charData*& next)
{ {
if ( term && next ) if ( term && next )
{ {
@ -1370,7 +1372,7 @@ inline void FOptiAttr::deactivateAttributes ( charData*& term
setAttributesOff(term); setAttributesOff(term);
} }
if ( colorChange(term, next) ) if ( hasColorChanged(term, next) )
change_color (term, next); change_color (term, next);
} }
@ -1420,7 +1422,7 @@ inline void FOptiAttr::changeAttributeSGR ( charData*& term
&& pc_charset_usable ) && pc_charset_usable )
setTermPCcharset(term); setTermPCcharset(term);
if ( colorChange(term, next) ) if ( hasColorChanged(term, next) )
change_color(term, next); change_color(term, next);
} }
@ -1430,7 +1432,7 @@ inline void FOptiAttr::changeAttributeSeparately ( charData*& term
{ {
setAttributesOff(term); setAttributesOff(term);
if ( colorChange(term, next) ) if ( hasColorChanged(term, next) )
change_color (term, next); change_color (term, next);
detectSwitchOn (term, next); // After reset all attributes detectSwitchOn (term, next); // After reset all attributes
@ -1440,7 +1442,7 @@ inline void FOptiAttr::changeAttributeSeparately ( charData*& term
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FOptiAttr::change_color (charData*& term, charData*& next) void FOptiAttr::change_color (charData*& term, charData*& next)
{ {
short fg, bg; FColor fg, bg;
if ( ! (term && next) ) if ( ! (term && next) )
return; return;
@ -1452,15 +1454,19 @@ void FOptiAttr::change_color (charData*& term, charData*& next)
return; return;
} }
next->fg_color %= max_color; if ( next->fg_color != fc::Default )
next->bg_color %= max_color; next->fg_color %= max_color;
if ( next->bg_color != fc::Default )
next->bg_color %= max_color;
fg = next->fg_color; fg = next->fg_color;
bg = next->bg_color; bg = next->bg_color;
if ( fg == fc::Default || bg == fc::Default ) if ( fg == fc::Default || bg == fc::Default )
change_to_default_color (term, next, fg, bg); change_to_default_color (term, next, fg, bg);
if ( fake_reverse && fg < 0 && bg < 0 ) if ( fake_reverse && fg == fc::Default && bg == fc::Default )
return; return;
if ( fake_reverse if ( fake_reverse
@ -1481,7 +1487,7 @@ void FOptiAttr::change_color (charData*& term, charData*& next)
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline void FOptiAttr::change_to_default_color ( charData*& term inline void FOptiAttr::change_to_default_color ( charData*& term
, charData*& next , charData*& next
, short& fg, short& bg ) , FColor& fg, FColor& bg )
{ {
if ( ansi_default_color ) if ( ansi_default_color )
{ {
@ -1520,7 +1526,7 @@ inline void FOptiAttr::change_to_default_color ( charData*& term
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline void FOptiAttr::change_current_color ( charData*& term inline void FOptiAttr::change_current_color ( charData*& term
, short fg, short bg ) , FColor fg, FColor bg )
{ {
char* color_str; char* color_str;
char* AF = F_set_a_foreground.cap; char* AF = F_set_a_foreground.cap;
@ -1535,8 +1541,8 @@ inline void FOptiAttr::change_current_color ( charData*& term
if ( AF && AB ) if ( AF && AB )
{ {
short ansi_fg = vga2ansi(fg); FColor ansi_fg = vga2ansi(fg);
short ansi_bg = vga2ansi(bg); FColor ansi_bg = vga2ansi(bg);
if ( (term->fg_color != fg || frev) if ( (term->fg_color != fg || frev)
&& (color_str = tparm(AF, ansi_fg, 0, 0, 0, 0, 0, 0, 0, 0)) ) && (color_str = tparm(AF, ansi_fg, 0, 0, 0, 0, 0, 0, 0, 0)) )

45
src/foptimove.cpp
View File

@ -560,47 +560,6 @@ char* FOptiMove::moveCursor (int xold, int yold, int xnew, int ynew)
return 0; return 0;
} }
//----------------------------------------------------------------------
void FOptiMove::printDurations()
{
std::cout << " speed: "
<< baudrate << " baud\r\n";
std::cout << " char_duration: "
<< char_duration << " ms\r\n";
std::cout << " cursor_home: "
<< F_cursor_home.duration << " ms\r\n";
std::cout << " cursor_to_ll: "
<< F_cursor_to_ll.duration << " ms\r\n";
std::cout << " carriage_return: "
<< F_carriage_return.duration << " ms\r\n";
std::cout << " tab: "
<< F_tab.duration << " ms\r\n";
std::cout << " back_tab: "
<< F_back_tab.duration << " ms\r\n";
std::cout << " cursor_up: "
<< F_cursor_up.duration << " ms\r\n";
std::cout << " cursor_down: "
<< F_cursor_down.duration << " ms\r\n";
std::cout << " cursor_left: "
<< F_cursor_left.duration << " ms\r\n";
std::cout << " cursor_right: "
<< F_cursor_right.duration << " ms\r\n";
std::cout << " cursor_address: "
<< F_cursor_address.duration << " ms\r\n";
std::cout << " column_address: "
<< F_column_address.duration << " ms\r\n";
std::cout << " row_address: "
<< F_row_address.duration << " ms\r\n";
std::cout << " parm_up_cursor: "
<< F_parm_up_cursor.duration << " ms\r\n";
std::cout << " parm_down_cursor: "
<< F_parm_down_cursor.duration << " ms\r\n";
std::cout << " parm_left_cursor: "
<< F_parm_left_cursor.duration << " ms\r\n";
std::cout << "parm_right_cursor: "
<< F_parm_right_cursor.duration << " ms\r\n";
}
// private methods of FApplication // private methods of FApplication
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -857,7 +816,7 @@ inline void FOptiMove::rightMove ( char hmove[], int& htime
{ {
std::strncpy ( hmove std::strncpy ( hmove
, tparm(F_parm_right_cursor.cap, num, 0, 0, 0, 0, 0, 0, 0, 0) , tparm(F_parm_right_cursor.cap, num, 0, 0, 0, 0, 0, 0, 0, 0)
, BUF_SIZE - 1); , BUF_SIZE );
hmove[BUF_SIZE - 1] = '\0'; hmove[BUF_SIZE - 1] = '\0';
htime = F_parm_right_cursor.duration; htime = F_parm_right_cursor.duration;
} }
@ -977,7 +936,7 @@ inline bool FOptiMove::isMethod0Faster ( int& move_time
if ( move_xy ) if ( move_xy )
{ {
char* move_ptr = move_buf; char* move_ptr = move_buf;
std::strncpy (move_ptr, move_xy, BUF_SIZE - 1); std::strncpy (move_ptr, move_xy, BUF_SIZE);
move_ptr[BUF_SIZE - 1] = '\0'; move_ptr[BUF_SIZE - 1] = '\0';
move_time = F_cursor_address.duration; move_time = F_cursor_address.duration;
return true; return true;

18
src/fpoint.cpp
View File

@ -44,36 +44,36 @@ FPoint& FPoint::operator = (const FPoint& p)
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FPoint& FPoint::operator += (const FPoint& p) FPoint& FPoint::operator += (const FPoint& p)
{ {
xpos = short(xpos + p.xpos); xpos = xpos + p.xpos;
ypos = short(ypos + p.ypos); ypos = ypos + p.ypos;
return *this; return *this;
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FPoint& FPoint::operator -= (const FPoint& p) FPoint& FPoint::operator -= (const FPoint& p)
{ {
xpos = short(xpos - p.xpos); xpos = xpos - p.xpos;
ypos = short(ypos - p.ypos); ypos = ypos - p.ypos;
return *this; return *this;
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FPoint::setX (int x) void FPoint::setX (int x)
{ {
xpos = short(x); xpos = x;
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FPoint::setY (int y) void FPoint::setY (int y)
{ {
ypos = short(y); ypos = y;
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FPoint::setPoint (int x, int y) void FPoint::setPoint (int x, int y)
{ {
xpos = short(x); xpos = x;
ypos = short(y); ypos = y;
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -92,7 +92,7 @@ std::ostream& operator << (std::ostream& outstr, const FPoint& p)
//---------------------------------------------------------------------- //----------------------------------------------------------------------
std::istream& operator >> (std::istream& instr, FPoint& p) std::istream& operator >> (std::istream& instr, FPoint& p)
{ {
short x, y; int x, y;
instr >> x; instr >> x;
instr >> y; instr >> y;
p.setPoint (x, y); p.setPoint (x, y);

18
src/fprogressbar.cpp
View File

@ -68,7 +68,9 @@ void FProgressbar::setPercentage (std::size_t percentage_value)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FProgressbar::setGeometry (int x, int y, std::size_t w, std::size_t h, bool adjust) void FProgressbar::setGeometry ( int x, int y
, std::size_t w, std::size_t h
, bool adjust )
{ {
// Set the progress bar geometry // Set the progress bar geometry
@ -83,13 +85,13 @@ bool FProgressbar::setShadow (bool on)
&& getEncoding() != fc::VT100 && getEncoding() != fc::VT100
&& getEncoding() != fc::ASCII ) && getEncoding() != fc::ASCII )
{ {
flags |= fc::shadow; flags.shadow = true;
setShadowSize(1,1); setShadowSize(1, 1);
} }
else else
{ {
flags &= ~fc::shadow; flags.shadow = false;
setShadowSize(0,0); setShadowSize(0, 0);
} }
return on; return on;
@ -99,7 +101,7 @@ bool FProgressbar::setShadow (bool on)
void FProgressbar::hide() void FProgressbar::hide()
{ {
std::size_t s, size; std::size_t s, size;
short fg, bg; FColor fg, bg;
FWidget* parent_widget = getParentWidget(); FWidget* parent_widget = getParentWidget();
FWidget::hide(); FWidget::hide();
@ -157,7 +159,7 @@ void FProgressbar::draw()
drawPercentage(); drawPercentage();
drawBar(); drawBar();
if ( (flags & fc::shadow) != 0 ) if ( flags.shadow )
drawShadow (); drawShadow ();
flush_out(); flush_out();
@ -193,7 +195,7 @@ void FProgressbar::drawBar()
{ {
std::size_t i = 0; std::size_t i = 0;
double length; double length;
setPrintPos (1,1); setPrintPos (1, 1);
setColor ( wc.progressbar_bg setColor ( wc.progressbar_bg
, wc.progressbar_fg ); , wc.progressbar_fg );

2
src/fradiobutton.cpp
View File

@ -73,7 +73,7 @@ void FRadioButton::drawRadioButton()
if ( ! isVisible() ) if ( ! isVisible() )
return; return;
setPrintPos (1,1); setPrintPos (1, 1);
setColor(); setColor();
if ( isMonochron() ) if ( isMonochron() )

104
src/frect.cpp
View File

@ -34,10 +34,10 @@ namespace finalcut
// constructor and destructor // constructor and destructor
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FRect::FRect (const FPoint& p1, const FPoint& p2) FRect::FRect (const FPoint& p1, const FPoint& p2)
: X1(short(p1.getX())) : X1(p1.getX())
, Y1(short(p1.getY())) , Y1(p1.getY())
, X2(short(p2.getX())) , X2(p2.getX())
, Y2(short(p2.getY())) , Y2(p2.getY())
{ } { }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -55,82 +55,82 @@ bool FRect::isNull() const
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FRect::setX1 (int n) void FRect::setX1 (int n)
{ {
X1 = short(n); X1 = n;
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FRect::setY1 (int n) void FRect::setY1 (int n)
{ {
Y1 = short(n); Y1 = n;
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FRect::setX2 (int n) void FRect::setX2 (int n)
{ {
X2 = short(n); X2 = n;
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FRect::setY2 (int n) void FRect::setY2 (int n)
{ {
Y2 = short(n); Y2 = n;
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FRect::setX (int n) void FRect::setX (int n)
{ {
short dX = short(X2 - X1); int dX = X2 - X1;
X1 = short(n); X1 = n;
X2 = short(X1 + dX); X2 = X1 + dX;
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FRect::setY (int n) void FRect::setY (int n)
{ {
short dY = short(Y2 - Y1); int dY = Y2 - Y1;
Y1 = short(n); Y1 = n;
Y2 = short(Y1 + dY); Y2 = Y1 + dY;
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FRect::setPos (int x, int y) void FRect::setPos (int x, int y)
{ {
short dX = short(X2 - X1); int dX = X2 - X1;
short dY = short(Y2 - Y1); int dY = Y2 - Y1;
X1 = short(x); X1 = x;
Y1 = short(y); Y1 = y;
X2 = short(X1 + dX); X2 = X1 + dX;
Y2 = short(Y1 + dY); Y2 = Y1 + dY;
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FRect::setPos (const FPoint& p) void FRect::setPos (const FPoint& p)
{ {
short dX = short(X2 - X1); int dX = X2 - X1;
short dY = short(Y2 - Y1); int dY = Y2 - Y1;
X1 = short(p.getX()); X1 = p.getX();
Y1 = short(p.getY()); Y1 = p.getY();
X2 = short(X1 + dX); X2 = X1 + dX;
Y2 = short(Y1 + dY); Y2 = Y1 + dY;
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FRect::setWidth (std::size_t w) void FRect::setWidth (std::size_t w)
{ {
X2 = short(X1 + short(w) - 1); X2 = X1 + int(w) - 1;
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FRect::setHeight (std::size_t h) void FRect::setHeight (std::size_t h)
{ {
Y2 = short(Y1 + short(h) - 1); Y2 = Y1 + int(h) - 1;
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FRect::setSize (std::size_t w, std::size_t h) void FRect::setSize (std::size_t w, std::size_t h)
{ {
X2 = short(X1 + short(w) - 1); X2 = X1 + int(w) - 1;
Y2 = short(Y1 + short(h) - 1); Y2 = Y1 + int(h) - 1;
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -145,10 +145,10 @@ void FRect::setRect (const FRect& r)
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FRect::setRect (int x, int y, std::size_t width, std::size_t height) void FRect::setRect (int x, int y, std::size_t width, std::size_t height)
{ {
X1 = short(x); X1 = x;
Y1 = short(y); Y1 = y;
X2 = short(x + int(width) - 1); X2 = x + int(width) - 1;
Y2 = short(y + int(height) - 1); Y2 = y + int(height) - 1;
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -160,28 +160,28 @@ void FRect::setCoordinates (const FPoint& p1, const FPoint& p2)
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FRect::setCoordinates (int x1, int y1, int x2, int y2) void FRect::setCoordinates (int x1, int y1, int x2, int y2)
{ {
X1 = short(x1); X1 = x1;
Y1 = short(y1); Y1 = y1;
X2 = short(x2); X2 = x2;
Y2 = short(y2); Y2 = y2;
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FRect::move (int dx, int dy) void FRect::move (int dx, int dy)
{ {
X1 = short(X1 + dx); X1 = X1 + dx;
Y1 = short(Y1 + dy); Y1 = Y1 + dy;
X2 = short(X2 + dx); X2 = X2 + dx;
Y2 = short(Y2 + dy); Y2 = Y2 + dy;
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FRect::move (const FPoint& d) void FRect::move (const FPoint& d)
{ {
X1 = short(X1 + d.getX()); X1 = X1 + d.getX();
Y1 = short(Y1 + d.getY()); Y1 = Y1 + d.getY();
X2 = short(X2 + d.getX()); X2 = X2 + d.getX();
Y2 = short(Y2 + d.getY()); Y2 = Y2 + d.getY();
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -239,10 +239,10 @@ FRect FRect::combined (const FRect& r) const
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FRect& FRect::operator = (const FRect& r) FRect& FRect::operator = (const FRect& r)
{ {
X1 = short(r.getX1()); X1 = r.getX1();
Y1 = short(r.getY1()); Y1 = r.getY1();
X2 = short(r.getX2()); X2 = r.getX2();
Y2 = short(r.getY2()); Y2 = r.getY2();
return *this; return *this;
} }
@ -295,7 +295,7 @@ std::ostream& operator << (std::ostream& outstr, const FRect& r)
//---------------------------------------------------------------------- //----------------------------------------------------------------------
std::istream& operator >> (std::istream& instr, FRect& r) std::istream& operator >> (std::istream& instr, FRect& r)
{ {
short x1, y1, x2, y2; int x1, y1, x2, y2;
instr >> x1; instr >> x1;
instr >> y1; instr >> y1;
instr >> x2; instr >> x2;

10
src/fscrollbar.cpp
View File

@ -174,7 +174,9 @@ void FScrollbar::setOrientation (int o)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FScrollbar::setGeometry (int x, int y, std::size_t w, std::size_t h, bool adjust) void FScrollbar::setGeometry ( int x, int y
, std::size_t w, std::size_t h
, bool adjust )
{ {
// Set the scrollbar geometry // Set the scrollbar geometry
@ -419,10 +421,12 @@ void FScrollbar::onMouseDown (FMouseEvent* ev)
if ( bar_orientation == fc::vertical ) if ( bar_orientation == fc::vertical )
slider_click_stop_pos = mouse_y - 2; slider_click_stop_pos = mouse_y - 2;
else else
{
if ( isNewFont() ) if ( isNewFont() )
slider_click_stop_pos = mouse_x - 3; slider_click_stop_pos = mouse_x - 3;
else else
slider_click_stop_pos = mouse_x - 2; slider_click_stop_pos = mouse_x - 2;
}
} }
else else
slider_click_stop_pos = -1; slider_click_stop_pos = -1;
@ -605,7 +609,7 @@ void FScrollbar::drawButtons()
if ( isNewFont() ) if ( isNewFont() )
{ {
setPrintPos (1,1); setPrintPos (1, 1);
if ( bar_orientation == fc::vertical ) if ( bar_orientation == fc::vertical )
{ {
@ -626,7 +630,7 @@ void FScrollbar::drawButtons()
} }
else else
{ {
setPrintPos (1,1); setPrintPos (1, 1);
if ( isMonochron() ) if ( isMonochron() )
setReverse(true); setReverse(true);

62
src/fscrollview.cpp
View File

@ -72,7 +72,7 @@ void FScrollView::setScrollWidth (std::size_t width)
if ( viewport ) if ( viewport )
{ {
FPoint no_shadow(0,0); FPoint no_shadow(0, 0);
scroll_geometry.setWidth (width); scroll_geometry.setWidth (width);
resizeArea (scroll_geometry, no_shadow, viewport); resizeArea (scroll_geometry, no_shadow, viewport);
@ -100,7 +100,7 @@ void FScrollView::setScrollHeight (std::size_t height)
if ( viewport ) if ( viewport )
{ {
FPoint no_shadow(0,0); FPoint no_shadow(0, 0);
scroll_geometry.setHeight (height); scroll_geometry.setHeight (height);
resizeArea (scroll_geometry, no_shadow, viewport); resizeArea (scroll_geometry, no_shadow, viewport);
addPreprocessingHandler addPreprocessingHandler
@ -133,7 +133,7 @@ void FScrollView::setScrollSize (std::size_t width, std::size_t height)
if ( viewport ) if ( viewport )
{ {
FPoint no_shadow(0,0); FPoint no_shadow(0, 0);
scroll_geometry.setSize (width, height); scroll_geometry.setSize (width, height);
resizeArea (scroll_geometry, no_shadow, viewport); resizeArea (scroll_geometry, no_shadow, viewport);
addPreprocessingHandler addPreprocessingHandler
@ -288,13 +288,13 @@ void FScrollView::setPrintPos (int x, int y)
//---------------------------------------------------------------------- //----------------------------------------------------------------------
bool FScrollView::setViewportPrint (bool on) bool FScrollView::setViewportPrint (bool on)
{ {
return use_own_print_area = ! on; return (use_own_print_area = ! on);
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
bool FScrollView::setBorder (bool on) bool FScrollView::setBorder (bool on)
{ {
return border = on; return (border = on);
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -333,12 +333,12 @@ void FScrollView::scrollToY (int y)
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FScrollView::scrollTo (int x, int y) void FScrollView::scrollTo (int x, int y)
{ {
short& xoffset = viewport_geometry.x1_ref(); int& xoffset = viewport_geometry.x1_ref();
short& yoffset = viewport_geometry.y1_ref(); int& yoffset = viewport_geometry.y1_ref();
short xoffset_before = xoffset; int xoffset_before = xoffset;
short yoffset_before = yoffset; int yoffset_before = yoffset;
short xoffset_end = short(getScrollWidth() - getViewportWidth()); int xoffset_end = int(getScrollWidth() - getViewportWidth());
short yoffset_end = short(getScrollHeight() - getViewportHeight()); int yoffset_end = int(getScrollHeight() - getViewportHeight());
std::size_t save_width = viewport_geometry.getWidth(); std::size_t save_width = viewport_geometry.getWidth();
std::size_t save_height = viewport_geometry.getHeight(); std::size_t save_height = viewport_geometry.getHeight();
bool changeX = false; bool changeX = false;
@ -346,11 +346,11 @@ void FScrollView::scrollTo (int x, int y)
x--; x--;
y--; y--;
if ( xoffset == short(x) && yoffset == short(y) ) if ( xoffset == x && yoffset == y )
return; return;
xoffset = short(x); xoffset = x;
yoffset = short(y); yoffset = y;
if ( yoffset < 0 ) if ( yoffset < 0 )
yoffset = 0; yoffset = 0;
@ -374,7 +374,7 @@ void FScrollView::scrollTo (int x, int y)
{ {
viewport_geometry.setWidth(save_width); viewport_geometry.setWidth(save_width);
setLeftPadding (1 - xoffset); setLeftPadding (1 - xoffset);
setRightPadding (1 - (xoffset_end - xoffset) + short(nf_offset)); setRightPadding (1 - (xoffset_end - xoffset) + int(nf_offset));
if ( update_scrollbar ) if ( update_scrollbar )
{ {
@ -440,7 +440,7 @@ void FScrollView::draw()
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FScrollView::onKeyPress (FKeyEvent* ev) void FScrollView::onKeyPress (FKeyEvent* ev)
{ {
short yoffset_end = short(getScrollHeight() - getViewportHeight()); int yoffset_end = int(getScrollHeight() - getViewportHeight());
switch ( ev->key() ) switch ( ev->key() )
{ {
@ -492,7 +492,7 @@ void FScrollView::onKeyPress (FKeyEvent* ev)
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FScrollView::onWheel (FWheelEvent* ev) void FScrollView::onWheel (FWheelEvent* ev)
{ {
short distance = 4; int distance = 4;
switch ( ev->getWheel() ) switch ( ev->getWheel() )
{ {
@ -548,7 +548,7 @@ void FScrollView::onChildFocusIn (FFocusEvent*)
widget_geometry = focus_widget->getGeometryWithShadow(); widget_geometry = focus_widget->getGeometryWithShadow();
vp_geometry = viewport_geometry; vp_geometry = viewport_geometry;
vp_geometry.move(1,1); vp_geometry.move(1, 1);
if ( ! vp_geometry.contains(widget_geometry) ) if ( ! vp_geometry.contains(widget_geometry) )
{ {
@ -694,10 +694,10 @@ void FScrollView::copy2area()
ac = &print_area->text[(ay + y) * a_line_len + ax]; ac = &print_area->text[(ay + y) * a_line_len + ax];
std::memcpy (ac, vc, sizeof(charData) * unsigned(x_end)); std::memcpy (ac, vc, sizeof(charData) * unsigned(x_end));
if ( short(print_area->changes[ay + y].xmin) > ax ) if ( int(print_area->changes[ay + y].xmin) > ax )
print_area->changes[ay + y].xmin = uInt(ax); print_area->changes[ay + y].xmin = uInt(ax);
if ( short(print_area->changes[ay + y].xmax) < ax + x_end - 1 ) if ( int(print_area->changes[ay + y].xmax) < ax + x_end - 1 )
print_area->changes[ay + y].xmax = uInt(ax + x_end - 1); print_area->changes[ay + y].xmax = uInt(ax + x_end - 1);
} }
@ -749,7 +749,7 @@ void FScrollView::init (FWidget* parent)
setBottomPadding (1 - (yoffset_end - getScrollY())); setBottomPadding (1 - (yoffset_end - getScrollY()));
setRightPadding (1 - (xoffset_end - getScrollX()) + nf_offset); setRightPadding (1 - (xoffset_end - getScrollX()) + nf_offset);
FPoint no_shadow(0,0); FPoint no_shadow(0, 0);
std::size_t w = getViewportWidth(); std::size_t w = getViewportWidth();
std::size_t h = getViewportHeight(); std::size_t h = getViewportHeight();
@ -892,8 +892,8 @@ void FScrollView::setViewportCursor()
void FScrollView::cb_VBarChange (FWidget*, data_ptr) void FScrollView::cb_VBarChange (FWidget*, data_ptr)
{ {
FScrollbar::sType scrollType = vbar->getScrollType(); FScrollbar::sType scrollType = vbar->getScrollType();
short distance = 1; int distance = 1;
short wheel_distance = 4; int wheel_distance = 4;
if ( scrollType >= FScrollbar::scrollStepBackward if ( scrollType >= FScrollbar::scrollStepBackward
&& scrollType <= FScrollbar::scrollWheelDown ) && scrollType <= FScrollbar::scrollWheelDown )
@ -911,21 +911,21 @@ void FScrollView::cb_VBarChange (FWidget*, data_ptr)
break; break;
case FScrollbar::scrollPageBackward: case FScrollbar::scrollPageBackward:
distance = short(getViewportHeight()); distance = int(getViewportHeight());
// fall through // fall through
case FScrollbar::scrollStepBackward: case FScrollbar::scrollStepBackward:
scrollBy (0, -distance); scrollBy (0, -distance);
break; break;
case FScrollbar::scrollPageForward: case FScrollbar::scrollPageForward:
distance = short(getViewportHeight()); distance = int(getViewportHeight());
// fall through // fall through
case FScrollbar::scrollStepForward: case FScrollbar::scrollStepForward:
scrollBy (0, distance); scrollBy (0, distance);
break; break;
case FScrollbar::scrollJump: case FScrollbar::scrollJump:
scrollToY (1 + short(vbar->getValue())); scrollToY (1 + int(vbar->getValue()));
break; break;
case FScrollbar::scrollWheelUp: case FScrollbar::scrollWheelUp:
@ -944,8 +944,8 @@ void FScrollView::cb_VBarChange (FWidget*, data_ptr)
void FScrollView::cb_HBarChange (FWidget*, data_ptr) void FScrollView::cb_HBarChange (FWidget*, data_ptr)
{ {
FScrollbar::sType scrollType = hbar->getScrollType(); FScrollbar::sType scrollType = hbar->getScrollType();
short distance = 1; int distance = 1;
short wheel_distance = 4; int wheel_distance = 4;
if ( scrollType >= FScrollbar::scrollStepBackward if ( scrollType >= FScrollbar::scrollStepBackward
&& scrollType <= FScrollbar::scrollWheelDown ) && scrollType <= FScrollbar::scrollWheelDown )
@ -963,21 +963,21 @@ void FScrollView::cb_HBarChange (FWidget*, data_ptr)
break; break;
case FScrollbar::scrollPageBackward: case FScrollbar::scrollPageBackward:
distance = short(getViewportWidth()); distance = int(getViewportWidth());
// fall through // fall through
case FScrollbar::scrollStepBackward: case FScrollbar::scrollStepBackward:
scrollBy (-distance, 0); scrollBy (-distance, 0);
break; break;
case FScrollbar::scrollPageForward: case FScrollbar::scrollPageForward:
distance = short(getViewportWidth()); distance = int(getViewportWidth());
// fall through // fall through
case FScrollbar::scrollStepForward: case FScrollbar::scrollStepForward:
scrollBy (distance, 0); scrollBy (distance, 0);
break; break;
case FScrollbar::scrollJump: case FScrollbar::scrollJump:
scrollToX (1 + short(hbar->getValue())); scrollToX (1 + int(hbar->getValue()));
break; break;
case FScrollbar::scrollWheelUp: case FScrollbar::scrollWheelUp:

6
src/fstatusbar.cpp
View File

@ -45,7 +45,7 @@ FStatusKey::FStatusKey(FWidget* parent)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FStatusKey::FStatusKey (int k, const FString& txt, FWidget* parent) FStatusKey::FStatusKey (FKey k, const FString& txt, FWidget* parent)
: FWidget(parent) : FWidget(parent)
, key(k) , key(k)
, text(txt) , text(txt)
@ -99,7 +99,7 @@ bool FStatusKey::setMouseFocus(bool on)
if ( on == mouse_focus ) if ( on == mouse_focus )
return true; return true;
return mouse_focus = on; return (mouse_focus = on);
} }
@ -196,7 +196,7 @@ bool FStatusBar::hasActivatedKey()
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FStatusBar::hide() void FStatusBar::hide()
{ {
short fg, bg; FColor fg, bg;
FWindow::hide(); FWindow::hide();
fg = wc.term_fg; fg = wc.term_fg;
bg = wc.term_bg; bg = wc.term_bg;

12
src/fstring.cpp
View File

@ -1192,7 +1192,7 @@ bool FString::operator > (const FString& s) const
//---------------------------------------------------------------------- //----------------------------------------------------------------------
const FString& FString::insert (const FString& s, int pos) const FString& FString::insert (const FString& s, int pos)
{ {
if ( pos < 0 || uInt(pos) > length ) if ( isNegative(pos) || uInt(pos) > length )
throw std::out_of_range(""); throw std::out_of_range("");
_insert (uInt(pos), s.length, s.string); _insert (uInt(pos), s.length, s.string);
@ -1474,7 +1474,7 @@ inline void FString::_assign (const wchar_t s[])
uInt new_length = uInt(std::wcslen(s)); uInt new_length = uInt(std::wcslen(s));
if ( ! string || new_length > bufsize - 1 ) if ( ! string || new_length > capacity() )
{ {
if ( string ) if ( string )
delete[](string); delete[](string);
@ -1493,8 +1493,8 @@ inline void FString::_assign (const wchar_t s[])
} }
std::wcsncpy (string, s, bufsize); std::wcsncpy (string, s, bufsize);
string[bufsize - 1] = L'\0';
length = new_length; length = new_length;
string[capacity()] = L'\0';
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -1520,7 +1520,7 @@ inline void FString::_insert (std::size_t len, const wchar_t s[])
} }
std::wcsncpy (string, s, bufsize); std::wcsncpy (string, s, bufsize);
string[bufsize - 1] = L'\0'; string[capacity()] = L'\0';
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -1539,7 +1539,7 @@ inline void FString::_insert ( std::size_t pos
{ {
std::size_t x; std::size_t x;
if ( (length + len + 1) <= bufsize ) if ( length + len <= capacity() )
{ {
// output string <= bufsize // output string <= bufsize
for (x = length; x + 1 > pos; x--) // shifting right side + '\0' for (x = length; x + 1 > pos; x--) // shifting right side + '\0'
@ -1587,7 +1587,7 @@ inline void FString::_insert ( std::size_t pos
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline void FString::_remove (std::size_t pos, std::size_t len) inline void FString::_remove (std::size_t pos, std::size_t len)
{ {
if ( (bufsize - length - 1 + len) <= FWDBUFFER ) if ( capacity() - length + len <= FWDBUFFER )
{ {
// shifting left side to pos // shifting left side to pos
for (std::size_t i = pos; i + len < length + 1; i++) for (std::size_t i = pos; i + len < length + 1; i++)

51
src/fterm.cpp
View File

@ -59,6 +59,10 @@ FMouseControl* FTerm::mouse = 0;
FTermOpenBSD* FTerm::openbsd = 0; FTermOpenBSD* FTerm::openbsd = 0;
#endif #endif
#if DEBUG
FTermDebugData* FTerm::debug_data = 0;
#endif
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// class FTerm // class FTerm
@ -104,7 +108,7 @@ std::size_t FTerm::getColumnNumber()
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
const FString FTerm::getKeyName (int keynum) const FString FTerm::getKeyName (FKey keynum)
{ {
return keyboard->getKeyName (keynum); return keyboard->getKeyName (keynum);
} }
@ -115,6 +119,17 @@ bool FTerm::isNormal (charData*& ch)
return opti_attr->isNormal(ch); return opti_attr->isNormal(ch);
} }
//----------------------------------------------------------------------
bool FTerm::isCursorHideable()
{
char* cursor_off_str = disableCursor();
if ( cursor_off_str && std::strlen(cursor_off_str) > 0 )
return true;
return false;
}
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FTerm::setTermType (const char term_name[]) void FTerm::setTermType (const char term_name[])
{ {
@ -392,7 +407,7 @@ char* FTerm::cursorsVisibility (bool on)
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FTerm::printMoveDurations() void FTerm::printMoveDurations()
{ {
opti_move->printDurations(); finalcut::printDurations(*opti_move);
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -470,14 +485,13 @@ void FTerm::detectTermSize()
if ( ret != 0 || win_size.ws_col == 0 || win_size.ws_row == 0 ) if ( ret != 0 || win_size.ws_col == 0 || win_size.ws_row == 0 )
{ {
char* str; term_geometry.setPos (1, 1);
term_geometry.setPos(1,1);
// Use COLUMNS or fallback to the xterm default width of 80 characters // Use COLUMNS or fallback to the xterm default width of 80 characters
str = std::getenv("COLUMNS"); char* Columns = std::getenv("COLUMNS");
term_geometry.setWidth(str ? std::size_t(std::atoi(str)) : 80); term_geometry.setWidth(Columns ? std::size_t(std::atoi(Columns)) : 80);
// Use LINES or fallback to the xterm default height of 24 characters // Use LINES or fallback to the xterm default height of 24 characters
str = std::getenv("LINES"); char* Lines = std::getenv("LINES");
term_geometry.setHeight(str ? std::size_t(std::atoi(str)) : 24); term_geometry.setHeight(Lines ? std::size_t(std::atoi(Lines)) : 24);
} }
else else
{ {
@ -550,7 +564,7 @@ void FTerm::resetColorMap()
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FTerm::setPalette (short index, int r, int g, int b) void FTerm::setPalette (FColor index, int r, int g, int b)
{ {
// Redefine RGB color value for a palette entry // Redefine RGB color value for a palette entry
@ -877,6 +891,11 @@ void FTerm::init_global_values (bool disable_alt_screen)
if ( ! init_values.terminal_detection ) if ( ! init_values.terminal_detection )
term_detection->setTerminalDetection (false); term_detection->setTerminalDetection (false);
#if DEBUG
debug_data->setFTermDetection(term_detection);
debug_data->setFTermData(data);
#endif
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -1079,7 +1098,7 @@ void FTerm::init_termcap()
// Initialize the terminal capabilities // Initialize the terminal capabilities
FTermcap termcap; FTermcap termcap;
termcap.setTermData(data); termcap.setFTermData(data);
termcap.setFTermDetection(term_detection); termcap.setFTermDetection(term_detection);
termcap.init(); termcap.init();
@ -1093,7 +1112,7 @@ void FTerm::init_quirks()
// Initialize terminal quirks // Initialize terminal quirks
FTermcapQuirks quirks; FTermcapQuirks quirks;
quirks.setTermData (data); quirks.setFTermData (data);
quirks.setFTermDetection (term_detection); quirks.setFTermDetection (term_detection);
quirks.terminalFixup(); // Fix terminal quirks quirks.terminalFixup(); // Fix terminal quirks
} }
@ -1670,6 +1689,10 @@ inline void FTerm::allocationValues()
#elif defined(__NetBSD__) || defined(__OpenBSD__) #elif defined(__NetBSD__) || defined(__OpenBSD__)
openbsd = new FTermOpenBSD(); openbsd = new FTermOpenBSD();
#endif #endif
#if DEBUG
debug_data = new FTermDebugData();
#endif
} }
catch (const std::bad_alloc& ex) catch (const std::bad_alloc& ex)
{ {
@ -1681,6 +1704,10 @@ inline void FTerm::allocationValues()
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline void FTerm::deallocationValues() inline void FTerm::deallocationValues()
{ {
#if DEBUG
if ( debug_data )
delete debug_data;
#endif
#if defined(__NetBSD__) || defined(__OpenBSD__) #if defined(__NetBSD__) || defined(__OpenBSD__)
if ( openbsd ) if ( openbsd )
@ -1740,7 +1767,7 @@ void FTerm::init (bool disable_alt_screen)
initBaudRate(); initBaudRate();
// Terminal detection // Terminal detection
term_detection->setTermData(data); term_detection->setFTermData(data);
term_detection->detect(); term_detection->detect();
setTermType (term_detection->getTermType()); setTermType (term_detection->getTermType());

13
src/ftermcap.cpp
View File

@ -20,6 +20,9 @@
* <http://www.gnu.org/licenses/>. * * <http://www.gnu.org/licenses/>. *
***********************************************************************/ ***********************************************************************/
#include <algorithm>
#include <vector>
#include "final/ftermcap.h" #include "final/ftermcap.h"
namespace finalcut namespace finalcut
@ -65,7 +68,7 @@ FTermcap::~FTermcap() // destructor
// public methods of FTermcap // public methods of FTermcap
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FTermcap::setTermData (FTermData* data) void FTermcap::setFTermData (FTermData* data)
{ {
fterm_data = data; fterm_data = data;
} }
@ -336,10 +339,10 @@ void FTermcap::termcapKeysVt100 (char*& buffer)
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FTermcap::tcap_map FTermcap::tcap[] = FTermcap::tcap_map FTermcap::tcap[] =
{ {
// .------------- term string // .------------- term string
// | .-------- Tcap-code // | .-------- Tcap-code
// | | // variable name -> description // | | // variable name -> description
//----------------------------------------------------------------------------- //------------------------------------------------------------------------------
{ 0, "bl" }, // bell -> audible signal (bell) (P) { 0, "bl" }, // bell -> audible signal (bell) (P)
{ 0, "ec" }, // erase_chars -> erase #1 characters (P) { 0, "ec" }, // erase_chars -> erase #1 characters (P)
{ 0, "cl" }, // clear_screen -> clear screen and home cursor (P*) { 0, "cl" }, // clear_screen -> clear screen and home cursor (P*)

6
src/ftermcapquirks.cpp
View File

@ -49,7 +49,7 @@ FTermcapQuirks::~FTermcapQuirks() // destructor
// public methods of FTermcapQuirks // public methods of FTermcapQuirks
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FTermcapQuirks::setTermData (FTermData* data) void FTermcapQuirks::setFTermData (FTermData* data)
{ {
fterm_data = data; fterm_data = data;
} }
@ -228,6 +228,7 @@ void FTermcapQuirks::xterm()
// Fallback if "Ic" is not found // Fallback if "Ic" is not found
if ( ! TCAP(fc::t_initialize_color) ) if ( ! TCAP(fc::t_initialize_color) )
{ {
FTermcap::can_change_color_palette = true;
TCAP(fc::t_initialize_color) = \ TCAP(fc::t_initialize_color) = \
C_STR(OSC "4;%p1%d;rgb:" C_STR(OSC "4;%p1%d;rgb:"
"%p2%{255}%*%{1000}%/%2.2X/" "%p2%{255}%*%{1000}%/%2.2X/"
@ -397,6 +398,8 @@ void FTermcapQuirks::screen()
// Fallback if "Ic" is not found // Fallback if "Ic" is not found
if ( ! TCAP(fc::t_initialize_color) ) if ( ! TCAP(fc::t_initialize_color) )
{ {
FTermcap::can_change_color_palette = true;
if ( term_detection->isTmuxTerm() ) if ( term_detection->isTmuxTerm() )
{ {
TCAP(fc::t_initialize_color) = \ TCAP(fc::t_initialize_color) = \
@ -440,6 +443,7 @@ void FTermcapQuirks::general()
// Fallback if "Ic" is not found // Fallback if "Ic" is not found
if ( ! TCAP(fc::t_initialize_color) ) if ( ! TCAP(fc::t_initialize_color) )
{ {
FTermcap::can_change_color_palette = true;
TCAP(fc::t_initialize_color) = \ TCAP(fc::t_initialize_color) = \
C_STR(OSC "P%p1%x" C_STR(OSC "P%p1%x"
"%p2%{255}%*%{1000}%/%02x" "%p2%{255}%*%{1000}%/%02x"

14
src/ftermdetection.cpp
View File

@ -89,7 +89,7 @@ FTermDetection::~FTermDetection() // destructor
// public methods of FTermDetection // public methods of FTermDetection
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FTermDetection::setTermData (FTermData* data) void FTermDetection::setFTermData (FTermData* data)
{ {
fterm_data = data; fterm_data = data;
} }
@ -145,7 +145,8 @@ void FTermDetection::getSystemTermType()
} }
// 2nd fallback: use vt100 if not found // 2nd fallback: use vt100 if not found
std::strncpy (termtype, C_STR("vt100"), 6); std::strncpy (termtype, C_STR("vt100"), sizeof(termtype));
termtype[sizeof(termtype) - 1] = '\0';
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -453,8 +454,9 @@ char* FTermDetection::termtype_256color_quirks()
if ( color_env.string3 && std::strlen(color_env.string3) > 0 ) if ( color_env.string3 && std::strlen(color_env.string3) > 0 )
decscusr_support = true; decscusr_support = true;
if ( (color_env.string1 && std::strncmp(color_env.string1, "gnome-terminal", 14) == 0) if ( color_env.string2
|| color_env.string2 ) || (color_env.string1
&& std::strncmp(color_env.string1, "gnome-terminal", 14) == 0) )
{ {
terminal_type.gnome_terminal = true; terminal_type.gnome_terminal = true;
// Each gnome-terminal should be able to use 256 colors // Each gnome-terminal should be able to use 256 colors
@ -513,7 +515,7 @@ const FString FTermDetection::getXTermColorName (int color)
int stdin_no = FTermios::getStdIn(); int stdin_no = FTermios::getStdIn();
char temp[512] = { }; char temp[512] = { };
std::fprintf (stdout, OSC "4;%d;?" BEL, color); // get color std::fprintf (stdout, OSC "4;%3d;?" BEL, color); // get color
std::fflush(stdout); std::fflush(stdout);
FD_ZERO(&ifds); FD_ZERO(&ifds);
@ -578,7 +580,7 @@ char* FTermDetection::parseAnswerbackMsg (char current_termtype[])
{ {
std::strncpy ( termtype_Answerback std::strncpy ( termtype_Answerback
, new_termtype , new_termtype
, sizeof(termtype_Answerback) ); , sizeof(termtype_Answerback) - 1);
termtype_Answerback[sizeof(termtype_Answerback) - 1] = '\0'; termtype_Answerback[sizeof(termtype_Answerback) - 1] = '\0';
} }
#endif // DEBUG #endif // DEBUG

2
src/ftermios.cpp
View File

@ -20,6 +20,8 @@
* <http://www.gnu.org/licenses/>. * * <http://www.gnu.org/licenses/>. *
***********************************************************************/ ***********************************************************************/
#include <map>
#include "final/ftermios.h" #include "final/ftermios.h"
#include "final/fterm.h" #include "final/fterm.h"

20
src/ftermlinux.cpp
View File

@ -118,7 +118,7 @@ void FTermLinux::setUTF8 (bool on)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
bool FTermLinux::setPalette (short index, int r, int g, int b) bool FTermLinux::setPalette (FColor index, int r, int g, int b)
{ {
if ( ! FTerm::isLinuxTerm() ) if ( ! FTerm::isLinuxTerm() )
return false; return false;
@ -436,7 +436,7 @@ char* FTermLinux::restoreCursorStyle()
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
int FTermLinux::modifierKeyCorrection (const int& key_id) FKey FTermLinux::modifierKeyCorrection (const FKey& key_id)
{ {
// Get the current modifier key state // Get the current modifier key state
modifier_key& m = getModifierKey(); modifier_key& m = getModifierKey();
@ -838,7 +838,7 @@ int FTermLinux::setBlinkAsIntensity (bool on)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
bool FTermLinux::setVGAPalette (short index, int r, int g, int b) bool FTermLinux::setVGAPalette (FColor index, int r, int g, int b)
{ {
// Set the vga color map // Set the vga color map
@ -910,7 +910,7 @@ bool FTermLinux::resetVGAPalette()
#endif // defined(__x86_64__) || defined(__i386) || defined(__arm__) #endif // defined(__x86_64__) || defined(__i386) || defined(__arm__)
//---------------------------------------------------------------------- //----------------------------------------------------------------------
int FTermLinux::shiftKeyCorrection (const int& key_id) FKey FTermLinux::shiftKeyCorrection (const FKey& key_id)
{ {
switch ( key_id ) switch ( key_id )
{ {
@ -950,7 +950,7 @@ int FTermLinux::shiftKeyCorrection (const int& key_id)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
int FTermLinux::ctrlKeyCorrection (const int& key_id) FKey FTermLinux::ctrlKeyCorrection (const FKey& key_id)
{ {
switch ( key_id ) switch ( key_id )
{ {
@ -990,7 +990,7 @@ int FTermLinux::ctrlKeyCorrection (const int& key_id)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
int FTermLinux::altKeyCorrection (const int& key_id) FKey FTermLinux::altKeyCorrection (const FKey& key_id)
{ {
switch ( key_id ) switch ( key_id )
{ {
@ -1030,7 +1030,7 @@ int FTermLinux::altKeyCorrection (const int& key_id)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
int FTermLinux::shiftCtrlKeyCorrection (const int& key_id) FKey FTermLinux::shiftCtrlKeyCorrection (const FKey& key_id)
{ {
switch ( key_id ) switch ( key_id )
{ {
@ -1070,7 +1070,7 @@ int FTermLinux::shiftCtrlKeyCorrection (const int& key_id)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
int FTermLinux::shiftAltKeyCorrection (const int& key_id) FKey FTermLinux::shiftAltKeyCorrection (const FKey& key_id)
{ {
switch ( key_id ) switch ( key_id )
{ {
@ -1110,7 +1110,7 @@ int FTermLinux::shiftAltKeyCorrection (const int& key_id)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
int FTermLinux::ctrlAltKeyCorrection (const int& key_id) FKey FTermLinux::ctrlAltKeyCorrection (const FKey& key_id)
{ {
switch ( key_id ) switch ( key_id )
{ {
@ -1150,7 +1150,7 @@ int FTermLinux::ctrlAltKeyCorrection (const int& key_id)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
int FTermLinux::shiftCtrlAltKeyCorrection (const int& key_id) FKey FTermLinux::shiftCtrlAltKeyCorrection (const FKey& key_id)
{ {
switch ( key_id ) switch ( key_id )
{ {

6
src/ftextview.cpp
View File

@ -93,7 +93,9 @@ const FString FTextView::getText() const
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FTextView::setGeometry (int x, int y, std::size_t w, std::size_t h, bool adjust) void FTextView::setGeometry ( int x, int y
, std::size_t w, std::size_t h
, bool adjust )
{ {
// Set the text view geometry // Set the text view geometry
@ -194,7 +196,7 @@ void FTextView::scrollTo (int x, int y)
void FTextView::hide() void FTextView::hide()
{ {
std::size_t n, size; std::size_t n, size;
short fg, bg; FColor fg, bg;
FWidget* parent_widget = getParentWidget(); FWidget* parent_widget = getParentWidget();
FWidget::hide(); FWidget::hide();

52
src/ftogglebutton.cpp
View File

@ -88,7 +88,9 @@ FToggleButton::~FToggleButton() // destructor
// public methods of FToggleButton // public methods of FToggleButton
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FToggleButton::setGeometry (int x, int y, std::size_t w, std::size_t h, bool adjust) void FToggleButton::setGeometry ( int x, int y
, std::size_t w, std::size_t h
, bool adjust )
{ {
// Set the toggle button geometry // Set the toggle button geometry
@ -109,12 +111,7 @@ void FToggleButton::setGeometry (int x, int y, std::size_t w, std::size_t h, boo
//---------------------------------------------------------------------- //----------------------------------------------------------------------
bool FToggleButton::setNoUnderline (bool on) bool FToggleButton::setNoUnderline (bool on)
{ {
if ( on ) return (flags.no_underline = on);
flags |= fc::no_underline;
else
flags &= ~fc::no_underline;
return on;
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -218,7 +215,7 @@ void FToggleButton::setText (const FString& txt)
void FToggleButton::hide() void FToggleButton::hide()
{ {
std::size_t size; std::size_t size;
short fg, bg; FColor fg, bg;
FWidget* parent_widget = getParentWidget(); FWidget* parent_widget = getParentWidget();
FWidget::hide(); FWidget::hide();
@ -291,7 +288,7 @@ void FToggleButton::onMouseUp (FMouseEvent* ev)
} }
else else
{ {
checked = not checked; checked = ! checked;
processToggle(); processToggle();
} }
@ -337,7 +334,7 @@ void FToggleButton::onAccel (FAccelEvent* ev)
} }
else else
{ {
checked = not checked; checked = ! checked;
processToggle(); processToggle();
} }
@ -431,16 +428,16 @@ uChar FToggleButton::getHotkey()
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FToggleButton::setHotkeyAccelerator() void FToggleButton::setHotkeyAccelerator()
{ {
int hotkey = getHotkey(); uChar hotkey = getHotkey();
if ( hotkey ) if ( hotkey )
{ {
if ( std::isalpha(hotkey) || std::isdigit(hotkey) ) if ( std::isalpha(hotkey) || std::isdigit(hotkey) )
{ {
addAccelerator (std::tolower(hotkey)); addAccelerator (FKey(std::tolower(hotkey)));
addAccelerator (std::toupper(hotkey)); addAccelerator (FKey(std::toupper(hotkey)));
// Meta + hotkey // Meta + hotkey
addAccelerator (fc::Fmkey_meta + std::tolower(hotkey)); addAccelerator (fc::Fmkey_meta + FKey(std::tolower(hotkey)));
} }
else else
addAccelerator (getHotkey()); addAccelerator (getHotkey());
@ -464,9 +461,7 @@ bool FToggleButton::isCheckboxButton() const
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FToggleButton::draw() void FToggleButton::draw()
{ {
bool isFocus = ((flags & fc::focus) != 0); if ( flags.focus && getStatusBar() )
if ( isFocus && getStatusBar() )
{ {
const FString& msg = getStatusbarMessage(); const FString& msg = getStatusbarMessage();
const FString& curMsg = getStatusBar()->getMessage(); const FString& curMsg = getStatusBar()->getMessage();
@ -535,12 +530,10 @@ void FToggleButton::processToggle()
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FToggleButton::onKeyPress (FKeyEvent* ev) void FToggleButton::onKeyPress (FKeyEvent* ev)
{ {
int key;
if ( ! isEnabled() ) if ( ! isEnabled() )
return; return;
key = ev->key(); FKey key = ev->key();
switch ( key ) switch ( key )
{ {
@ -557,7 +550,7 @@ void FToggleButton::onKeyPress (FKeyEvent* ev)
} }
else else
{ {
checked = not checked; checked = ! checked;
processToggle(); processToggle();
} }
processClick(); processClick();
@ -624,8 +617,8 @@ void FToggleButton::init()
//---------------------------------------------------------------------- //----------------------------------------------------------------------
std::size_t FToggleButton::getHotkeyPos ( wchar_t src[] std::size_t FToggleButton::getHotkeyPos ( wchar_t src[]
, wchar_t dest[] , wchar_t dest[]
, std::size_t length ) , std::size_t length )
{ {
// find hotkey position in string // find hotkey position in string
// + generate a new string without the '&'-sign // + generate a new string without the '&'-sign
@ -649,12 +642,9 @@ std::size_t FToggleButton::getHotkeyPos ( wchar_t src[]
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FToggleButton::drawText ( wchar_t LabelText[] void FToggleButton::drawText ( wchar_t LabelText[]
, std::size_t hotkeypos , std::size_t hotkeypos
, std::size_t length ) , std::size_t length )
{ {
bool isActive = ((flags & fc::active) != 0);
bool isNoUnderline = ((flags & fc::no_underline) != 0);
if ( isMonochron() ) if ( isMonochron() )
setReverse(true); setReverse(true);
@ -665,16 +655,16 @@ void FToggleButton::drawText ( wchar_t LabelText[]
for (std::size_t z = 0; z < length; z++) for (std::size_t z = 0; z < length; z++)
{ {
if ( (z == hotkeypos) && isActive ) if ( (z == hotkeypos) && flags.active )
{ {
setColor (wc.label_hotkey_fg, wc.label_hotkey_bg); setColor (wc.label_hotkey_fg, wc.label_hotkey_bg);
if ( ! isNoUnderline ) if ( ! flags.no_underline )
setUnderline(); setUnderline();
print ( LabelText[z] ); print ( LabelText[z] );
if ( ! isNoUnderline ) if ( ! flags.no_underline )
unsetUnderline(); unsetUnderline();
setColor (wc.label_fg, wc.label_bg); setColor (wc.label_fg, wc.label_bg);
@ -684,7 +674,7 @@ void FToggleButton::drawText ( wchar_t LabelText[]
} }
if ( isMonochron() ) if ( isMonochron() )
setReverse(false);; setReverse(false);
} }
} // namespace finalcut } // namespace finalcut

2
src/ftooltip.cpp
View File

@ -71,7 +71,7 @@ FToolTip::~FToolTip() // destructor
if ( parent_win ) if ( parent_win )
setActiveWindow (parent_win); setActiveWindow (parent_win);
else else
switchToPrevWindow(); switchToPrevWindow(this);
} }

126
src/fvterm.cpp
View File

@ -25,6 +25,7 @@
#include <vector> #include <vector>
#include "final/fapplication.h" #include "final/fapplication.h"
#include "final/fterm.h"
#include "final/fvterm.h" #include "final/fvterm.h"
#include "final/fwidget.h" #include "final/fwidget.h"
#include "final/fwindow.h" #include "final/fwindow.h"
@ -48,6 +49,7 @@ uInt FVTerm::clr_eol_length;
uInt FVTerm::cursor_address_length; uInt FVTerm::cursor_address_length;
std::queue<int>* FVTerm::output_buffer = 0; std::queue<int>* FVTerm::output_buffer = 0;
FPoint* FVTerm::term_pos = 0; FPoint* FVTerm::term_pos = 0;
FTerm* FVTerm::fterm = 0;
FVTerm::term_area* FVTerm::vterm = 0; FVTerm::term_area* FVTerm::vterm = 0;
FVTerm::term_area* FVTerm::vdesktop = 0; FVTerm::term_area* FVTerm::vdesktop = 0;
FVTerm::term_area* FVTerm::active_area = 0; FVTerm::term_area* FVTerm::active_area = 0;
@ -66,15 +68,14 @@ FVTerm::charData FVTerm::i_ch;
// constructors and destructor // constructors and destructor
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FVTerm::FVTerm (bool initialize, bool disable_alt_screen) FVTerm::FVTerm (bool initialize, bool disable_alt_screen)
: FTerm(disable_alt_screen) : print_area(0)
, print_area(0)
, child_print_area(0) , child_print_area(0)
, vwin(0) , vwin(0)
{ {
terminal_update_complete = false; terminal_update_complete = false;
if ( initialize ) if ( initialize )
init(); init (disable_alt_screen);
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -97,7 +98,7 @@ FPoint FVTerm::getPrintCursor()
return FPoint ( win->offset_left + win->cursor_x return FPoint ( win->offset_left + win->cursor_x
, win->offset_top + win->cursor_y ); , win->offset_top + win->cursor_y );
return FPoint(0,0); return FPoint(0, 0);
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -113,7 +114,7 @@ void FVTerm::setTermXY (int x, int y)
term_width = int(getColumnNumber()); term_width = int(getColumnNumber());
term_height = int(getLineNumber()); term_height = int(getLineNumber());
if ( x >= term_width ) if ( x >= term_width && term_width > 0 )
{ {
y += x / term_width; y += x / term_width;
x %= term_width; x %= term_width;
@ -128,7 +129,7 @@ void FVTerm::setTermXY (int x, int y)
term_x = term_pos->getX(); term_x = term_pos->getX();
term_y = term_pos->getY(); term_y = term_pos->getY();
move_str = moveCursor (term_x, term_y, x, y); move_str = FTerm::moveCursor (term_x, term_y, x, y);
if ( move_str ) if ( move_str )
appendOutputBuffer(move_str); appendOutputBuffer(move_str);
@ -142,7 +143,7 @@ void FVTerm::hideCursor (bool on)
{ {
// Hides or shows the input cursor on the terminal // Hides or shows the input cursor on the terminal
char* visibility_str = cursorsVisibility (on); char* visibility_str = FTerm::cursorsVisibility (on);
if ( visibility_str ) if ( visibility_str )
appendOutputBuffer(visibility_str); appendOutputBuffer(visibility_str);
@ -162,6 +163,17 @@ void FVTerm::setPrintCursor (int x, int y)
} }
} }
//----------------------------------------------------------------------
FColor FVTerm::rgb2ColorIndex (uInt8 r, uInt8 g, uInt8 b)
{
// Converts a 24-bit RGB color to a 256-color compatible approximation
FColor ri = (((r * 5) + 127) / 255) * 36;
FColor gi = (((g * 5) + 127) / 255) * 6;
FColor bi = (((b * 5) + 127) / 255);
return 16 + ri + gi + bi;
}
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FVTerm::clearArea (int fillchar) void FVTerm::clearArea (int fillchar)
{ {
@ -172,7 +184,7 @@ void FVTerm::clearArea (int fillchar)
void FVTerm::createVTerm (const FRect& r) void FVTerm::createVTerm (const FRect& r)
{ {
// initialize virtual terminal // initialize virtual terminal
const FPoint shadow(0,0); const FPoint shadow(0, 0);
createArea (r, shadow, vterm); createArea (r, shadow, vterm);
} }
@ -186,7 +198,7 @@ void FVTerm::createVTerm (int width, int height)
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FVTerm::resizeVTerm (const FRect& r) void FVTerm::resizeVTerm (const FRect& r)
{ {
const FPoint shadow(0,0); const FPoint shadow(0, 0);
resizeArea (r, shadow, vterm); resizeArea (r, shadow, vterm);
} }
@ -535,7 +547,7 @@ int FVTerm::print (term_area* area, charData& term_char)
} }
// copy character to area // copy character to area
std::memcpy (ac, &nc, sizeof(nc)); std::memcpy (ac, &nc, sizeof(*ac));
if ( ax < short(area->changes[ay].xmin) ) if ( ax < short(area->changes[ay].xmin) )
area->changes[ay].xmin = uInt(ax); area->changes[ay].xmin = uInt(ax);
@ -843,7 +855,7 @@ void FVTerm::restoreVTerm (int x, int y, int w, int h)
int xpos = x + tx; int xpos = x + tx;
tc = &vterm->text[ypos * vterm->width + xpos]; tc = &vterm->text[ypos * vterm->width + xpos];
sc = generateCharacter(xpos, ypos); sc = generateCharacter(xpos, ypos);
std::memcpy (tc, &sc, sizeof(charData)); std::memcpy (tc, &sc, sizeof(*tc));
} }
if ( short(vterm->changes[ypos].xmin) > x ) if ( short(vterm->changes[ypos].xmin) > x )
@ -944,7 +956,7 @@ void FVTerm::updateOverlappedColor ( term_area* area
charData* tc = &vterm->text[ty * vterm->width + tx]; charData* tc = &vterm->text[ty * vterm->width + tx];
// New character // New character
charData nc; charData nc;
std::memcpy (&nc, ac, sizeof(charData)); std::memcpy (&nc, ac, sizeof(nc));
// Overlapped character // Overlapped character
charData oc = getOverlappedCharacter (tx + 1, ty + 1, area->widget); charData oc = getOverlappedCharacter (tx + 1, ty + 1, area->widget);
nc.fg_color = oc.fg_color; nc.fg_color = oc.fg_color;
@ -961,7 +973,7 @@ void FVTerm::updateOverlappedColor ( term_area* area
nc.code = ' '; nc.code = ' ';
nc.attr.bit.no_changes = bool(tc->attr.bit.printed && *tc == nc); nc.attr.bit.no_changes = bool(tc->attr.bit.printed && *tc == nc);
std::memcpy (tc, &nc, sizeof(charData)); std::memcpy (tc, &nc, sizeof(*tc));
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -974,7 +986,7 @@ void FVTerm::updateOverlappedCharacter (term_area* area, int tx, int ty)
// Overlapped character // Overlapped character
charData oc = getCoveredCharacter (tx + 1, ty + 1, area->widget); charData oc = getCoveredCharacter (tx + 1, ty + 1, area->widget);
oc.attr.bit.no_changes = bool(tc->attr.bit.printed && *tc == oc); oc.attr.bit.no_changes = bool(tc->attr.bit.printed && *tc == oc);
std::memcpy (tc, &oc, sizeof(charData)); std::memcpy (tc, &oc, sizeof(*tc));
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -1006,7 +1018,7 @@ void FVTerm::updateShadedCharacter ( term_area* area
oc.code = ' '; oc.code = ' ';
oc.attr.bit.no_changes = bool(tc->attr.bit.printed && *tc == oc); oc.attr.bit.no_changes = bool(tc->attr.bit.printed && *tc == oc);
std::memcpy (tc, &oc, sizeof(charData)); std::memcpy (tc, &oc, sizeof(*tc));
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -1024,12 +1036,12 @@ void FVTerm::updateInheritBackground ( term_area* area
charData* tc = &vterm->text[ty * vterm->width + tx]; charData* tc = &vterm->text[ty * vterm->width + tx];
// New character // New character
charData nc; charData nc;
std::memcpy (&nc, ac, sizeof(charData)); std::memcpy (&nc, ac, sizeof(nc));
// Covered character // Covered character
charData cc = getCoveredCharacter (tx + 1, ty + 1, area->widget); charData cc = getCoveredCharacter (tx + 1, ty + 1, area->widget);
nc.bg_color = cc.bg_color; nc.bg_color = cc.bg_color;
nc.attr.bit.no_changes = bool(tc->attr.bit.printed && *tc == nc); nc.attr.bit.no_changes = bool(tc->attr.bit.printed && *tc == nc);
std::memcpy (tc, &nc, sizeof(charData)); std::memcpy (tc, &nc, sizeof(*tc));
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -1045,7 +1057,7 @@ void FVTerm::updateCharacter ( term_area* area
charData* ac = &area->text[y * line_len + x]; charData* ac = &area->text[y * line_len + x];
// Terminal character // Terminal character
charData* tc = &vterm->text[ty * vterm->width + tx]; charData* tc = &vterm->text[ty * vterm->width + tx];
std::memcpy (tc, ac, sizeof(charData)); std::memcpy (tc, ac, sizeof(*tc));
if ( tc->attr.bit.printed && *tc == *ac ) if ( tc->attr.bit.printed && *tc == *ac )
tc->attr.bit.no_changes = true; tc->attr.bit.no_changes = true;
@ -1373,7 +1385,7 @@ void FVTerm::getArea (int ax, int ay, term_area* area)
charData* ac; // area character charData* ac; // area character
tc = &vterm->text[(ay + y) * vterm->width + ax]; tc = &vterm->text[(ay + y) * vterm->width + ax];
ac = &area->text[y * area->width]; ac = &area->text[y * area->width];
std::memcpy (ac, tc, sizeof(charData) * unsigned(length)); std::memcpy (ac, tc, sizeof(*ac) * unsigned(length));
if ( short(area->changes[y].xmin) > 0 ) if ( short(area->changes[y].xmin) > 0 )
area->changes[y].xmin = 0; area->changes[y].xmin = 0;
@ -1429,7 +1441,7 @@ void FVTerm::getArea (int x, int y, int w, int h, term_area* area)
int line_len = area->width + area->right_shadow; int line_len = area->width + area->right_shadow;
tc = &vterm->text[(y + _y - 1) * vterm->width + x - 1]; tc = &vterm->text[(y + _y - 1) * vterm->width + x - 1];
ac = &area->text[(dy + _y) * line_len + dx]; ac = &area->text[(dy + _y) * line_len + dx];
std::memcpy (ac, tc, sizeof(charData) * unsigned(length)); std::memcpy (ac, tc, sizeof(*ac) * unsigned(length));
if ( short(area->changes[dy + _y].xmin) > dx ) if ( short(area->changes[dy + _y].xmin) > dx )
area->changes[dy + _y].xmin = uInt(dx); area->changes[dy + _y].xmin = uInt(dx);
@ -1557,14 +1569,14 @@ void FVTerm::scrollAreaForward (term_area* area)
int pos2 = (y + 1) * total_width; int pos2 = (y + 1) * total_width;
sc = &area->text[pos2]; sc = &area->text[pos2];
dc = &area->text[pos1]; dc = &area->text[pos1];
std::memcpy (dc, sc, sizeof(charData) * unsigned(length)); std::memcpy (dc, sc, sizeof(*dc) * unsigned(length));
area->changes[y].xmin = 0; area->changes[y].xmin = 0;
area->changes[y].xmax = uInt(area->width - 1); area->changes[y].xmax = uInt(area->width - 1);
} }
// insert a new line below // insert a new line below
lc = &area->text[(y_max * total_width) - area->right_shadow - 1]; lc = &area->text[(y_max * total_width) - area->right_shadow - 1];
std::memcpy (&nc, lc, sizeof(charData)); std::memcpy (&nc, lc, sizeof(nc));
nc.code = ' '; nc.code = ' ';
dc = &area->text[y_max * total_width]; dc = &area->text[y_max * total_width];
std::fill_n (dc, area->width, nc); std::fill_n (dc, area->width, nc);
@ -1577,7 +1589,7 @@ void FVTerm::scrollAreaForward (term_area* area)
if ( TCAP(fc::t_scroll_forward) ) if ( TCAP(fc::t_scroll_forward) )
{ {
setTermXY (0, vdesktop->height); setTermXY (0, vdesktop->height);
scrollTermForward(); FTerm::scrollTermForward();
putArea (1, 1, vdesktop); putArea (1, 1, vdesktop);
// avoid update lines from 0 to (y_max - 1) // avoid update lines from 0 to (y_max - 1)
@ -1618,14 +1630,14 @@ void FVTerm::scrollAreaReverse (term_area* area)
int pos2 = y * total_width; int pos2 = y * total_width;
sc = &area->text[pos1]; sc = &area->text[pos1];
dc = &area->text[pos2]; dc = &area->text[pos2];
std::memcpy (dc, sc, sizeof(charData) * unsigned(length)); std::memcpy (dc, sc, sizeof(*dc) * unsigned(length));
area->changes[y].xmin = 0; area->changes[y].xmin = 0;
area->changes[y].xmax = uInt(area->width - 1); area->changes[y].xmax = uInt(area->width - 1);
} }
// insert a new line above // insert a new line above
lc = &area->text[total_width]; lc = &area->text[total_width];
std::memcpy (&nc, lc, sizeof(charData)); std::memcpy (&nc, lc, sizeof(nc));
nc.code = ' '; nc.code = ' ';
dc = &area->text[0]; dc = &area->text[0];
std::fill_n (dc, area->width, nc); std::fill_n (dc, area->width, nc);
@ -1638,7 +1650,7 @@ void FVTerm::scrollAreaReverse (term_area* area)
if ( TCAP(fc::t_scroll_reverse) ) if ( TCAP(fc::t_scroll_reverse) )
{ {
setTermXY (0, 0); setTermXY (0, 0);
scrollTermReverse(); FTerm::scrollTermReverse();
putArea (1, 1, vdesktop); putArea (1, 1, vdesktop);
// avoid update lines from 1 to y_max // avoid update lines from 1 to y_max
@ -1660,7 +1672,7 @@ void FVTerm::clearArea (term_area* area, int fillchar)
uInt w; uInt w;
// Current attributes with a space character // Current attributes with a space character
std::memcpy (&nc, &next_attribute, sizeof(charData)); std::memcpy (&nc, &next_attribute, sizeof(nc));
nc.code = fillchar; nc.code = fillchar;
if ( ! (area && area->text) ) if ( ! (area && area->text) )
@ -1755,7 +1767,7 @@ FVTerm::charData FVTerm::generateCharacter (int x, int y)
if ( tmp->attr.bit.trans_shadow ) // Transparent shadow if ( tmp->attr.bit.trans_shadow ) // Transparent shadow
{ {
// Keep the current vterm character // Keep the current vterm character
std::memcpy (&s_ch, sc, sizeof(charData)); std::memcpy (&s_ch, sc, sizeof(s_ch));
s_ch.fg_color = tmp->fg_color; s_ch.fg_color = tmp->fg_color;
s_ch.bg_color = tmp->bg_color; s_ch.bg_color = tmp->bg_color;
s_ch.attr.bit.reverse = false; s_ch.attr.bit.reverse = false;
@ -1774,7 +1786,7 @@ FVTerm::charData FVTerm::generateCharacter (int x, int y)
else if ( tmp->attr.bit.inherit_bg ) else if ( tmp->attr.bit.inherit_bg )
{ {
// Add the covered background to this character // Add the covered background to this character
std::memcpy (&i_ch, tmp, sizeof(charData)); std::memcpy (&i_ch, tmp, sizeof(i_ch));
i_ch.bg_color = sc->bg_color; // Last background color i_ch.bg_color = sc->bg_color; // Last background color
sc = &i_ch; sc = &i_ch;
} }
@ -1950,7 +1962,7 @@ void FVTerm::flush_out()
{ {
while ( ! output_buffer->empty() ) while ( ! output_buffer->empty() )
{ {
Fputchar (output_buffer->front()); FTerm::Fputchar(output_buffer->front());
output_buffer->pop(); output_buffer->pop();
} }
@ -1960,7 +1972,7 @@ void FVTerm::flush_out()
// private methods of FVTerm // private methods of FVTerm
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FVTerm::init() void FVTerm::init (bool disable_alt_screen)
{ {
init_object = this; init_object = this;
vterm = 0; vterm = 0;
@ -1968,6 +1980,7 @@ void FVTerm::init()
try try
{ {
fterm = new FTerm (disable_alt_screen);
term_pos = new FPoint(-1, -1); term_pos = new FPoint(-1, -1);
output_buffer = new std::queue<int>; output_buffer = new std::queue<int>;
} }
@ -1991,7 +2004,7 @@ void FVTerm::init()
term_attribute.attr.byte[0] = 0; term_attribute.attr.byte[0] = 0;
// next_attribute contains the state of the next printed character // next_attribute contains the state of the next printed character
std::memcpy (&next_attribute, &term_attribute, sizeof(charData)); std::memcpy (&next_attribute, &term_attribute, sizeof(next_attribute));
// Receive the terminal capabilities // Receive the terminal capabilities
tcap = FTermcap::getTermcapMap(); tcap = FTermcap::getTermcapMap();
@ -2001,19 +2014,19 @@ void FVTerm::init()
createVTerm (term_geometry); createVTerm (term_geometry);
// Create virtual desktop area // Create virtual desktop area
FPoint shadow_size(0,0); FPoint shadow_size(0, 0);
createArea (term_geometry, shadow_size, vdesktop); createArea (term_geometry, shadow_size, vdesktop);
vdesktop->visible = true; vdesktop->visible = true;
active_area = vdesktop; active_area = vdesktop;
// Initialize keyboard // Initialize keyboard
keyboard = getKeyboard(); keyboard = FTerm::getKeyboard();
// Hide the input cursor // Hide the input cursor
hideCursor(); hideCursor();
// Initialize character lengths // Initialize character lengths
init_characterLengths (getFOptiMove()); init_characterLengths (FTerm::getFOptiMove());
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -2046,7 +2059,7 @@ void FVTerm::finish()
// Clear the terminal // Clear the terminal
setNormal(); setNormal();
if ( hasAlternateScreen() ) if ( FTerm::hasAlternateScreen() )
clearTerm(); clearTerm();
flush_out(); flush_out();
@ -2060,6 +2073,9 @@ void FVTerm::finish()
if ( term_pos ) if ( term_pos )
delete term_pos; delete term_pos;
if ( fterm )
delete fterm;
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -2067,7 +2083,7 @@ void FVTerm::putAreaLine (charData* ac, charData* tc, int length)
{ {
// copy "length" characters from area to terminal // copy "length" characters from area to terminal
std::memcpy (tc, ac, sizeof(charData) * unsigned(length)); std::memcpy (tc, ac, sizeof(*tc) * unsigned(length));
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -2080,7 +2096,7 @@ void FVTerm::putAreaCharacter ( int x, int y, FVTerm* obj
// Restore one character on vterm // Restore one character on vterm
charData ch; charData ch;
ch = getCoveredCharacter (x, y, obj); ch = getCoveredCharacter (x, y, obj);
std::memcpy (tc, &ch, sizeof(charData)); std::memcpy (tc, &ch, sizeof(*tc));
} }
else // Mot transparent else // Mot transparent
{ {
@ -2102,19 +2118,19 @@ void FVTerm::putAreaCharacter ( int x, int y, FVTerm* obj
|| ch.code == fc::FullBlock ) || ch.code == fc::FullBlock )
ch.code = ' '; ch.code = ' ';
std::memcpy (tc, &ch, sizeof(charData)); std::memcpy (tc, &ch, sizeof(*tc));
} }
else if ( ac->attr.bit.inherit_bg ) else if ( ac->attr.bit.inherit_bg )
{ {
// Add the covered background to this character // Add the covered background to this character
charData ch, cc; charData ch, cc;
std::memcpy (&ch, ac, sizeof(charData)); std::memcpy (&ch, ac, sizeof(ch));
cc = getCoveredCharacter (x, y, obj); cc = getCoveredCharacter (x, y, obj);
ch.bg_color = cc.bg_color; ch.bg_color = cc.bg_color;
std::memcpy (tc, &ch, sizeof(charData)); std::memcpy (tc, &ch, sizeof(*tc));
} }
else // Default else // Default
std::memcpy (tc, ac, sizeof(charData)); std::memcpy (tc, ac, sizeof(*tc));
} }
} }
@ -2134,7 +2150,7 @@ void FVTerm::getAreaCharacter ( int x, int y, term_area* area
if ( tmp->attr.bit.trans_shadow ) // transparent shadow if ( tmp->attr.bit.trans_shadow ) // transparent shadow
{ {
// Keep the current vterm character // Keep the current vterm character
std::memcpy (&s_ch, cc, sizeof(charData)); std::memcpy (&s_ch, cc, sizeof(s_ch));
s_ch.fg_color = tmp->fg_color; s_ch.fg_color = tmp->fg_color;
s_ch.bg_color = tmp->bg_color; s_ch.bg_color = tmp->bg_color;
s_ch.attr.bit.reverse = false; s_ch.attr.bit.reverse = false;
@ -2144,7 +2160,7 @@ void FVTerm::getAreaCharacter ( int x, int y, term_area* area
else if ( tmp->attr.bit.inherit_bg ) else if ( tmp->attr.bit.inherit_bg )
{ {
// Add the covered background to this character // Add the covered background to this character
std::memcpy (&i_ch, tmp, sizeof(charData)); std::memcpy (&i_ch, tmp, sizeof(i_ch));
i_ch.bg_color = cc->bg_color; // last background color i_ch.bg_color = cc->bg_color; // last background color
cc = &i_ch; cc = &i_ch;
} }
@ -2163,7 +2179,7 @@ bool FVTerm::clearTerm (int fillchar)
char*& cb = TCAP(fc::t_clr_eol); char*& cb = TCAP(fc::t_clr_eol);
bool ut = FTermcap::background_color_erase; bool ut = FTermcap::background_color_erase;
charData* next = &next_attribute; charData* next = &next_attribute;
bool normal = isNormal(next); bool normal = FTerm::isNormal(next);
appendAttributes(next); appendAttributes(next);
if ( ! ( (cl || cd || cb) && (normal || ut) ) if ( ! ( (cl || cd || cb) && (normal || ut) )
@ -2175,7 +2191,7 @@ bool FVTerm::clearTerm (int fillchar)
if ( cl ) // Clear screen if ( cl ) // Clear screen
{ {
appendOutputBuffer (cl); appendOutputBuffer (cl);
term_pos->setPoint(0,0); term_pos->setPoint(0, 0);
} }
else if ( cd ) // Clear to end of screen else if ( cd ) // Clear to end of screen
{ {
@ -2193,7 +2209,7 @@ bool FVTerm::clearTerm (int fillchar)
appendOutputBuffer (cb); appendOutputBuffer (cb);
} }
setTermXY (0,0); setTermXY (0, 0);
} }
flush_out(); flush_out();
@ -2268,7 +2284,7 @@ bool FVTerm::canClearToEOL (uInt xmin, uInt y)
if ( ce && min_char->code == ' ' ) if ( ce && min_char->code == ' ' )
{ {
uInt beginning_whitespace = 1; uInt beginning_whitespace = 1;
bool normal = isNormal(min_char); bool normal = FTerm::isNormal(min_char);
bool& ut = FTermcap::background_color_erase; bool& ut = FTermcap::background_color_erase;
for (uInt x = xmin + 1; x < uInt(vt->width); x++) for (uInt x = xmin + 1; x < uInt(vt->width); x++)
@ -2303,7 +2319,7 @@ bool FVTerm::canClearLeadingWS (uInt& xmin, uInt y)
if ( cb && first_char->code == ' ' ) if ( cb && first_char->code == ' ' )
{ {
uInt leading_whitespace = 1; uInt leading_whitespace = 1;
bool normal = isNormal(first_char); bool normal = FTerm::isNormal(first_char);
bool& ut = FTermcap::background_color_erase; bool& ut = FTermcap::background_color_erase;
for (uInt x = 1; x < uInt(vt->width); x++) for (uInt x = 1; x < uInt(vt->width); x++)
@ -2341,7 +2357,7 @@ bool FVTerm::canClearTrailingWS (uInt& xmax, uInt y)
if ( ce && last_char->code == ' ' ) if ( ce && last_char->code == ' ' )
{ {
uInt trailing_whitespace = 1; uInt trailing_whitespace = 1;
bool normal = isNormal(last_char); bool normal = FTerm::isNormal(last_char);
bool& ut = FTermcap::background_color_erase; bool& ut = FTermcap::background_color_erase;
for (uInt x = uInt(vt->width) - 1; x > 0 ; x--) for (uInt x = uInt(vt->width) - 1; x > 0 ; x--)
@ -2452,7 +2468,7 @@ FVTerm::exit_state FVTerm::eraseCharacters ( uInt& x, uInt xmax, uInt y
return not_used; return not_used;
uInt whitespace = 1; uInt whitespace = 1;
bool normal = isNormal(print_char); bool normal = FTerm::isNormal(print_char);
for (uInt i = x + 1; i <= xmax; i++) for (uInt i = x + 1; i <= xmax; i++)
{ {
@ -2776,14 +2792,14 @@ inline void FVTerm::charsetChanges (charData*& next_char)
return; return;
uInt code = uInt(next_char->code); uInt code = uInt(next_char->code);
uInt ch_enc = charEncode(code); uInt ch_enc = FTerm::charEncode(code);
if ( ch_enc == code ) if ( ch_enc == code )
return; return;
if ( ch_enc == 0 ) if ( ch_enc == 0 )
{ {
next_char->code = int(charEncode(code, fc::ASCII)); next_char->code = int(FTerm::charEncode(code, fc::ASCII));
return; return;
} }
@ -2801,7 +2817,7 @@ inline void FVTerm::charsetChanges (charData*& next_char)
if ( isXTerminal() && ch_enc < 0x20 ) // Character 0x00..0x1f if ( isXTerminal() && ch_enc < 0x20 ) // Character 0x00..0x1f
{ {
if ( hasUTF8() ) if ( hasUTF8() )
next_char->code = int(charEncode(code, fc::ASCII)); next_char->code = int(FTerm::charEncode(code, fc::ASCII));
else else
{ {
next_char->code += 0x5f; next_char->code += 0x5f;
@ -2843,7 +2859,7 @@ inline void FVTerm::appendAttributes (charData*& next_attr)
charData* term_attr = &term_attribute; charData* term_attr = &term_attribute;
// generate attribute string for the next character // generate attribute string for the next character
attr_str = changeAttribute (term_attr, next_attr); attr_str = FTerm::changeAttribute (term_attr, next_attr);
if ( attr_str ) if ( attr_str )
appendOutputBuffer (attr_str); appendOutputBuffer (attr_str);

86
src/fwidget.cpp
View File

@ -58,15 +58,9 @@ FWidget::FWidget (FWidget* parent, bool disable_alt_screen)
: FVTerm(bool(! parent), disable_alt_screen) : FVTerm(bool(! parent), disable_alt_screen)
, FObject(parent) , FObject(parent)
, accelerator_list(0) , accelerator_list(0)
, flags(0) , flags()
, callback_objects() , callback_objects()
, member_callback_objects() , member_callback_objects()
, enable(true)
, visible(true)
, shown(false)
, focus(false)
, focusable(true)
, visible_cursor(true)
, widget_cursor_position(-1, -1) , widget_cursor_position(-1, -1)
, size_hints() , size_hints()
, double_flatline_mask() , double_flatline_mask()
@ -84,10 +78,14 @@ FWidget::FWidget (FWidget* parent, bool disable_alt_screen)
, background_color(fc::Default) , background_color(fc::Default)
, statusbar_message() , statusbar_message()
{ {
if ( isEnabled() ) // init bit field with 0
flags |= fc::active; memset (&flags, 0, sizeof(flags));
widget_object = true; flags.active = true; // Enable widget by default
flags.visible = true; // A widget is visible by default
flags.focusable = true; // A widget is focusable by default
flags.visible_cursor = true; // A widget has a visible cursor by default
widget_object = true; // This FObject is a widget
if ( ! parent ) if ( ! parent )
{ {
@ -103,7 +101,7 @@ FWidget::FWidget (FWidget* parent, bool disable_alt_screen)
} }
else else
{ {
visible_cursor = ! hideable; flags.visible_cursor = ! hideable;
offset = parent->client_offset; offset = parent->client_offset;
double_flatline_mask.top.resize (getWidth(), false); double_flatline_mask.top.resize (getWidth(), false);
double_flatline_mask.right.resize (getHeight(), false); double_flatline_mask.right.resize (getHeight(), false);
@ -124,7 +122,7 @@ FWidget::~FWidget() // destructor
setClickedWidget(0); setClickedWidget(0);
// unset the local window widget focus // unset the local window widget focus
if ( focus ) if ( flags.focus )
{ {
if ( FWindow* window = FWindow::getWindowWidget(this) ) if ( FWindow* window = FWindow::getWindowWidget(this) )
window->setWindowFocusWidget(0); window->setWindowFocusWidget(0);
@ -276,12 +274,7 @@ void FWidget::setMainWidget (FWidget* obj)
//---------------------------------------------------------------------- //----------------------------------------------------------------------
bool FWidget::setEnable (bool on) bool FWidget::setEnable (bool on)
{ {
if ( on ) return (flags.active = on);
flags |= fc::active;
else
flags &= ~fc::active;
return enable = on;
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -290,21 +283,16 @@ bool FWidget::setFocus (bool on)
FWindow* window; FWindow* window;
FWidget* last_focus; FWidget* last_focus;
if ( ! enable ) if ( ! isEnabled() )
return false; return false;
if ( on ) if ( flags.focus == on )
flags |= fc::focus;
else
flags &= ~fc::focus;
if ( on == focus )
return true; return true;
last_focus = FWidget::getFocusWidget(); last_focus = FWidget::getFocusWidget();
// set widget focus // set widget focus
if ( on && ! focus ) if ( on && ! flags.focus )
{ {
int focusable_children = numOfFocusableChildren(); int focusable_children = numOfFocusableChildren();
@ -334,7 +322,7 @@ bool FWidget::setFocus (bool on)
window->setWindowFocusWidget(this); window->setWindowFocusWidget(this);
} }
return focus = on; return (flags.focus = on);
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -604,7 +592,9 @@ void FWidget::setTermSize (std::size_t w, std::size_t h)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FWidget::setGeometry (int x, int y, std::size_t w, std::size_t h, bool adjust) void FWidget::setGeometry ( int x, int y
, std::size_t w, std::size_t h
, bool adjust )
{ {
// Sets the geometry of the widget relative to its parent // Sets the geometry of the widget relative to its parent
@ -657,7 +647,7 @@ bool FWidget::setCursorPos (int x, int y)
widget_cursor_position.setPoint(x, y); widget_cursor_position.setPoint(x, y);
if ( (flags & fc::focus) == 0 || isWindowWidget() ) if ( ! flags.focus || isWindowWidget() )
return false; return false;
if ( ! FWindow::getWindowWidget(this) ) if ( ! FWindow::getWindowWidget(this) )
@ -678,7 +668,7 @@ bool FWidget::setCursorPos (int x, int y)
setAreaCursor ( widget_offsetX + x setAreaCursor ( widget_offsetX + x
, widget_offsetY + y , widget_offsetY + y
, visible_cursor , flags.visible_cursor
, area ); , area );
return true; return true;
} }
@ -854,7 +844,7 @@ bool FWidget::close()
{ {
hide(); hide();
if ( (flags & fc::modal) == 0 ) if ( ! flags.modal )
close_widget->push_back(this); close_widget->push_back(this);
} }
return true; return true;
@ -980,7 +970,7 @@ void FWidget::emitCallback (const FString& emit_signal)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FWidget::addAccelerator (int key, FWidget* obj) void FWidget::addAccelerator (FKey key, FWidget* obj)
{ {
FWidget* widget = FWindow::getWindowWidget(obj); FWidget* widget = FWindow::getWindowWidget(obj);
accelerator accel = { key, obj }; accelerator accel = { key, obj };
@ -1030,7 +1020,7 @@ void FWidget::redraw()
setColor (wc.term_fg, wc.term_bg); setColor (wc.term_fg, wc.term_bg);
clearArea (vdesktop); clearArea (vdesktop);
} }
else if ( ! visible ) else if ( ! isVisible() )
return; return;
draw(); draw();
@ -1077,7 +1067,7 @@ void FWidget::resize()
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FWidget::show() void FWidget::show()
{ {
if ( ! visible ) if ( ! isVisible() )
return; return;
if ( ! init_desktop ) if ( ! init_desktop )
@ -1099,7 +1089,7 @@ void FWidget::show()
} }
draw(); draw();
shown = true; flags.shown = true;
if ( hasChildren() ) if ( hasChildren() )
{ {
@ -1134,10 +1124,10 @@ void FWidget::show()
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FWidget::hide() void FWidget::hide()
{ {
if ( visible ) if ( isVisible() )
{ {
visible = false; flags.visible = false;
shown = false; flags.shown = false;
if ( ! isDialogWidget() if ( ! isDialogWidget()
&& FWidget::getFocusWidget() == this && FWidget::getFocusWidget() == this
@ -1264,13 +1254,11 @@ void FWidget::move (int dx, int dy)
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FWidget::drawShadow() void FWidget::drawShadow()
{ {
bool trans_shadow = ((flags & fc::trans_shadow) != 0); if ( isMonochron() && ! flags.trans_shadow )
if ( isMonochron() && ! trans_shadow )
return; return;
if ( (getEncoding() == fc::VT100 && ! trans_shadow) if ( (getEncoding() == fc::VT100 && ! flags.trans_shadow)
|| (getEncoding() == fc::ASCII && ! trans_shadow) ) || (getEncoding() == fc::ASCII && ! flags.trans_shadow) )
{ {
clearShadow(); clearShadow();
return; return;
@ -1281,7 +1269,7 @@ void FWidget::drawShadow()
, y1 = 1 , y1 = 1
, y2 = int(getHeight()); , y2 = int(getHeight());
if ( trans_shadow ) if ( flags.trans_shadow )
{ {
// transparent shadow // transparent shadow
drawTransparentShadow (x1, y1, x2, y2); drawTransparentShadow (x1, y1, x2, y2);
@ -1974,14 +1962,8 @@ void FWidget::init()
return; return;
} }
char* cursor_off_str = disableCursor(); hideable = isCursorHideable();
flags.visible_cursor = ! hideable;
if ( cursor_off_str && std::strlen(cursor_off_str) > 0 )
hideable = true;
else
hideable = false;
visible_cursor = ! hideable;
// Determine width and height of the terminal // Determine width and height of the terminal
detectTermSize(); detectTermSize();

70
src/fwindow.cpp
View File

@ -93,16 +93,12 @@ bool FWindow::setWindowWidget (bool on)
if ( isWindowWidget() == on ) if ( isWindowWidget() == on )
return true; return true;
flags.window_widget = on;
if ( on ) if ( on )
{
flags |= fc::window_widget;
setTermOffset(); setTermOffset();
}
else else
{
flags &= ~fc::window_widget;
setParentOffset(); setParentOffset();
}
return on; return on;
} }
@ -166,7 +162,7 @@ bool FWindow::activateWindow (bool on)
active_area = getVWin(); active_area = getVWin();
} }
return window_active = on; return (window_active = on);
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -179,29 +175,18 @@ void FWindow::unsetActiveWindow()
//---------------------------------------------------------------------- //----------------------------------------------------------------------
bool FWindow::setResizeable (bool on) bool FWindow::setResizeable (bool on)
{ {
if ( on ) return (flags.resizeable = on);
flags |= fc::resizeable;
else
flags &= ~fc::resizeable;
return on;
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
bool FWindow::setTransparentShadow (bool on) bool FWindow::setTransparentShadow (bool on)
{ {
flags.shadow = flags.trans_shadow = on;
if ( on ) if ( on )
{ setShadowSize (2, 1);
flags |= fc::shadow;
flags |= fc::trans_shadow;
setShadowSize (2,1);
}
else else
{ setShadowSize (0, 0);
flags &= ~fc::shadow;
flags &= ~fc::trans_shadow;
setShadowSize (0,0);
}
return on; return on;
} }
@ -214,15 +199,15 @@ bool FWindow::setShadow (bool on)
if ( on ) if ( on )
{ {
flags |= fc::shadow; flags.shadow = true;
flags &= ~fc::trans_shadow; flags.trans_shadow = false;
setShadowSize (1,1); setShadowSize (1, 1);
} }
else else
{ {
flags &= ~fc::shadow; flags.shadow = false;
flags &= ~fc::trans_shadow; flags.trans_shadow = false;
setShadowSize (0,0); setShadowSize (0, 0);
} }
return on; return on;
@ -234,10 +219,10 @@ bool FWindow::setAlwaysOnTop (bool on)
if ( isAlwaysOnTop() == on ) if ( isAlwaysOnTop() == on )
return true; return true;
flags.always_on_top = on;
if ( on ) if ( on )
{ {
flags |= fc::always_on_top;
if ( always_on_top_list ) if ( always_on_top_list )
{ {
deleteFromAlwaysOnTopList (this); deleteFromAlwaysOnTopList (this);
@ -245,10 +230,7 @@ bool FWindow::setAlwaysOnTop (bool on)
} }
} }
else else
{
flags &= ~fc::always_on_top;
deleteFromAlwaysOnTopList (this); deleteFromAlwaysOnTopList (this);
}
return on; return on;
} }
@ -408,7 +390,9 @@ void FWindow::setSize (std::size_t w, std::size_t h, bool adjust)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FWindow::setGeometry (int x, int y, std::size_t w, std::size_t h, bool adjust) void FWindow::setGeometry ( int x, int y
, std::size_t w, std::size_t h
, bool adjust )
{ {
// Sets the geometry of the widget // Sets the geometry of the widget
@ -578,10 +562,10 @@ void FWindow::swapWindow (FWidget* obj1, FWidget* obj2)
if ( window_list->empty() ) if ( window_list->empty() )
return; return;
if ( (obj1->getFlags() & fc::modal) != 0 ) if ( obj1->getFlags().modal )
return; return;
if ( (obj2->getFlags() & fc::modal) != 0 ) if ( obj2->getFlags().modal )
return; return;
iter = window_list->begin(); iter = window_list->begin();
@ -621,7 +605,7 @@ bool FWindow::raiseWindow (FWidget* obj)
if ( window_list->back() == obj ) if ( window_list->back() == obj )
return false; return false;
if ( (window_list->back()->getFlags() & fc::modal) != 0 if ( window_list->back()->getFlags().modal
&& ! obj->isMenuWidget() ) && ! obj->isMenuWidget() )
return false; return false;
@ -663,7 +647,7 @@ bool FWindow::lowerWindow (FWidget* obj)
if ( window_list->front() == obj ) if ( window_list->front() == obj )
return false; return false;
if ( (obj->getFlags() & fc::modal) != 0 ) if ( obj->getFlags().modal )
return false; return false;
iter = window_list->begin(); iter = window_list->begin();
@ -711,13 +695,14 @@ bool FWindow::zoomWindow()
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FWindow::switchToPrevWindow() void FWindow::switchToPrevWindow (FWidget* widget_object)
{ {
// switch to previous window // switch to previous window
// Disable terminal updates to avoid flickering // Disable terminal updates to avoid flickering
// when redrawing the focused widget // when redrawing the focused widget
updateTerminal (FVTerm::stop_refresh); if ( widget_object )
widget_object->updateTerminal (FVTerm::stop_refresh);
bool is_activated = activatePrevWindow(); bool is_activated = activatePrevWindow();
FWindow* active_window = static_cast<FWindow*>(getActiveWindow()); FWindow* active_window = static_cast<FWindow*>(getActiveWindow());
@ -767,7 +752,8 @@ void FWindow::switchToPrevWindow()
} }
// Enable terminal updates again // Enable terminal updates again
updateTerminal (FVTerm::continue_refresh); if ( widget_object )
widget_object->updateTerminal (FVTerm::continue_refresh);
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------

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

@ -108,7 +108,7 @@ class FApplication : public FWidget
static void sendQueuedEvents (); static void sendQueuedEvents ();
static bool eventInQueue(); static bool eventInQueue();
static bool removeQueuedEvent (const FObject*); static bool removeQueuedEvent (const FObject*);
static FWidget* processParameters (const int&, char*[]); FWidget* processParameters (const int&, char*[]);
static void showParameterUsage () static void showParameterUsage ()
#if defined(__clang__) || defined(__GNUC__) #if defined(__clang__) || defined(__GNUC__)
__attribute__((noreturn)) __attribute__((noreturn))
@ -135,7 +135,7 @@ class FApplication : public FWidget
// Methods // Methods
void init (long, long); void init (long, long);
static void cmd_options (const int&, char*[]); void cmd_options (const int&, char*[]);
void findKeyboardWidget(); void findKeyboardWidget();
bool isKeyPressed(); bool isKeyPressed();
void keyPressed(); void keyPressed();

49
src/include/final/fbutton.h
View File

@ -69,7 +69,7 @@ class FButton : public FWidget
public: public:
// Constructors // Constructors
explicit FButton (FWidget* = 0); explicit FButton (FWidget* = 0);
FButton (const FString&, FWidget* = 0); explicit FButton (const FString&, FWidget* = 0);
// Destructor // Destructor
virtual ~FButton(); virtual ~FButton();
@ -79,13 +79,13 @@ class FButton : public FWidget
FString& getText(); FString& getText();
// Mutators // Mutators
void setForegroundColor (short); void setForegroundColor (FColor);
void setBackgroundColor (short); void setBackgroundColor (FColor);
void setHotkeyForegroundColor (short); void setHotkeyForegroundColor (FColor);
void setFocusForegroundColor (short); void setFocusForegroundColor (FColor);
void setFocusBackgroundColor (short); void setFocusBackgroundColor (FColor);
void setInactiveForegroundColor (short); void setInactiveForegroundColor (FColor);
void setInactiveBackgroundColor (short); void setInactiveBackgroundColor (FColor);
bool setNoUnderline(bool); bool setNoUnderline(bool);
bool setNoUnderline(); bool setNoUnderline();
bool unsetNoUnderline(); bool unsetNoUnderline();
@ -141,7 +141,6 @@ class FButton : public FWidget
// Methods // Methods
void init(); void init();
void getButtonState();
uChar getHotkey(); uChar getHotkey();
void setHotkeyAccelerator(); void setHotkeyAccelerator();
void detectHotkey(); void detectHotkey();
@ -160,6 +159,7 @@ class FButton : public FWidget
// Data Members // Data Members
FString text; FString text;
bool button_down; bool button_down;
bool active_focus;
bool click_animation; bool click_animation;
int click_time; int click_time;
int space_char; int space_char;
@ -168,24 +168,13 @@ class FButton : public FWidget
std::size_t center_offset; std::size_t center_offset;
std::size_t vcenter_offset; std::size_t vcenter_offset;
std::size_t txtlength; std::size_t txtlength;
short button_fg; FColor button_fg;
short button_bg; FColor button_bg;
short button_hotkey_fg; FColor button_hotkey_fg;
short button_focus_fg; FColor button_focus_fg;
short button_focus_bg; FColor button_focus_bg;
short button_inactive_fg; FColor button_inactive_fg;
short button_inactive_bg; FColor button_inactive_bg;
struct state
{
uChar focus : 1;
uChar active_focus : 1;
uChar active : 1;
uChar flat : 1;
uChar non_flat_shadow : 1;
uChar no_underline : 1;
uChar : 2; // padding bits
} is;
}; };
#pragma pack(pop) #pragma pack(pop)
@ -253,7 +242,7 @@ inline bool FButton::setUp()
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline bool FButton::setClickAnimation(bool on) inline bool FButton::setClickAnimation(bool on)
{ return click_animation = on; } { return (click_animation = on); }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline bool FButton::setClickAnimation() inline bool FButton::setClickAnimation()
@ -265,7 +254,7 @@ inline bool FButton::unsetClickAnimation()
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline bool FButton::isFlat() const inline bool FButton::isFlat() const
{ return ((flags & fc::flat) != 0); } { return flags.flat; }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline bool FButton::isDown() const inline bool FButton::isDown() const
@ -273,7 +262,7 @@ inline bool FButton::isDown() const
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline bool FButton::hasShadow() const inline bool FButton::hasShadow() const
{ return ((flags & fc::shadow) != 0); } { return flags.shadow; }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline bool FButton::hasClickAnimation() inline bool FButton::hasClickAnimation()

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

@ -73,7 +73,7 @@ class FButtonGroup : public FScrollView
public: public:
// Constructors // Constructors
explicit FButtonGroup (FWidget* = 0); explicit FButtonGroup (FWidget* = 0);
FButtonGroup (const FString&, FWidget* = 0); explicit FButtonGroup (const FString&, FWidget* = 0);
// Destructor // Destructor
virtual ~FButtonGroup(); virtual ~FButtonGroup();

831
src/include/final/fc.h
View File

@ -27,6 +27,8 @@
#error "Only <final/final.h> can be included directly." #error "Only <final/final.h> can be included directly."
#endif #endif
#include <final/ftypes.h>
// Typecast to c-string // Typecast to c-string
#define C_STR const_cast<char*> #define C_STR const_cast<char*>
@ -79,24 +81,6 @@ enum events
Timer_Event // timer event occur Timer_Event // timer event occur
}; };
// Properties of a widget ⚑
enum widget_flags
{
shadow = 0x00000001,
trans_shadow = 0x00000002,
active = 0x00000004,
focus = 0x00000008,
scrollable = 0x00000010,
resizeable = 0x00000020,
modal = 0x00000040,
window_widget = 0x00000080,
dialog_widget = 0x00000100,
menu_widget = 0x00000200,
always_on_top = 0x00000400,
flat = 0x00000800,
no_underline = 0x00001000
};
// Internal character encoding // Internal character encoding
enum encoding enum encoding
{ {
@ -255,420 +239,420 @@ enum SpecialCharacter
// keyboard - single keys // keyboard - single keys
enum keys enum keys
{ {
Fckey_a = 0x0000001, // control-a Fckey_a = 0x00000001, // control-a
Fckey_b = 0x0000002, // control-b Fckey_b = 0x00000002, // control-b
Fckey_c = 0x0000003, // control-c Fckey_c = 0x00000003, // control-c
Fckey_d = 0x0000004, // control-d Fckey_d = 0x00000004, // control-d
Fckey_e = 0x0000005, // control-e Fckey_e = 0x00000005, // control-e
Fckey_f = 0x0000006, // control-f Fckey_f = 0x00000006, // control-f
Fckey_g = 0x0000007, // control-g Fckey_g = 0x00000007, // control-g
Fkey_erase = 0x0000008, // control-h Fkey_erase = 0x00000008, // control-h
Fkey_tab = 0x0000009, // control-i Fkey_tab = 0x00000009, // control-i
Fckey_j = 0x000000a, // control-j Fckey_j = 0x0000000a, // control-j
Fckey_h = 0x000000b, // control-k Fckey_h = 0x0000000b, // control-k
Fckey_l = 0x000000c, // control-l Fckey_l = 0x0000000c, // control-l
Fkey_return = 0x000000d, // control-m Fkey_return = 0x0000000d, // control-m
Fckey_n = 0x000000e, // control-n Fckey_n = 0x0000000e, // control-n
Fckey_o = 0x000000f, // control-o Fckey_o = 0x0000000f, // control-o
Fckey_p = 0x0000010, // control-p Fckey_p = 0x00000010, // control-p
Fckey_q = 0x0000011, // control-q Fckey_q = 0x00000011, // control-q
Fckey_r = 0x0000012, // control-r Fckey_r = 0x00000012, // control-r
Fckey_s = 0x0000013, // control-s Fckey_s = 0x00000013, // control-s
Fckey_t = 0x0000014, // control-t Fckey_t = 0x00000014, // control-t
Fckey_u = 0x0000015, // control-u Fckey_u = 0x00000015, // control-u
Fckey_v = 0x0000016, // control-v Fckey_v = 0x00000016, // control-v
Fckey_w = 0x0000017, // control-w Fckey_w = 0x00000017, // control-w
Fckey_x = 0x0000018, // control-x Fckey_x = 0x00000018, // control-x
Fckey_y = 0x0000019, // control-y Fckey_y = 0x00000019, // control-y
Fckey_z = 0x000001a, // control-t Fckey_z = 0x0000001a, // control-t
Fkey_escape = 0x000001b, // control-[ Fkey_escape = 0x0000001b, // control-[
Fckey_backslash = 0x000001c, // control-'\' Fckey_backslash = 0x0000001c, // control-'\'
Fckey_right_square_bracket = 0x000001d, // control-] Fckey_right_square_bracket = 0x0000001d, // control-]
Fckey_caret = 0x000001e, // control-^ Fckey_caret = 0x0000001e, // control-^
Fckey_underscore = 0x000001f, // control-_ Fckey_underscore = 0x0000001f, // control-_
Fkey_space = 0x0000020, // space Fkey_space = 0x00000020, // space
Fkey_exclamation_mark = 0x0000021, // ! Fkey_exclamation_mark = 0x00000021, // !
Fkey_quotation_mark = 0x0000022, // " Fkey_quotation_mark = 0x00000022, // "
Fkey_number_sign = 0x0000023, // # Fkey_number_sign = 0x00000023, // #
Fkey_dollar_sign = 0x0000024, // $ Fkey_dollar_sign = 0x00000024, // $
Fkey_percent_sign = 0x0000025, // % Fkey_percent_sign = 0x00000025, // %
Fkey_ampersand = 0x0000026, // & Fkey_ampersand = 0x00000026, // &
Fkey_apostrophe = 0x0000027, // ' Fkey_apostrophe = 0x00000027, // '
Fkey_left_parentheses = 0x0000028, // ( Fkey_left_parentheses = 0x00000028, // (
Fkey_right_parentheses = 0x0000029, // ) Fkey_right_parentheses = 0x00000029, // )
Fkey_asterisk = 0x000002a, // * Fkey_asterisk = 0x0000002a, // *
Fkey_plus_sign = 0x000002b, // + Fkey_plus_sign = 0x0000002b, // +
Fkey_comma = 0x000002c, // , Fkey_comma = 0x0000002c, // ,
Fkey_minus_sign = 0x000002d, // - Fkey_minus_sign = 0x0000002d, // -
Fkey_full_stop = 0x000002e, // . Fkey_full_stop = 0x0000002e, // .
Fkey_slash = 0x000002f, // / Fkey_slash = 0x0000002f, // /
Fckey_space = 0x1000020, // control-space Fckey_space = 0x01000020, // control-space
Fkey_backspace = 0x1000100, Fkey_backspace = 0x01000100,
Fkey_catab = 0x1000101, Fkey_catab = 0x01000101,
Fkey_clear = 0x1000102, Fkey_clear = 0x01000102,
Fkey_ctab = 0x1000103, Fkey_ctab = 0x01000103,
Fkey_dc = 0x1000104, Fkey_dc = 0x01000104,
Fkey_dl = 0x1000105, Fkey_dl = 0x01000105,
Fkey_down = 0x1000106, Fkey_down = 0x01000106,
Fkey_eic = 0x1000107, Fkey_eic = 0x01000107,
Fkey_eol = 0x1000108, Fkey_eol = 0x01000108,
Fkey_eos = 0x1000109, Fkey_eos = 0x01000109,
Fkey_f0 = 0x100010a, Fkey_f0 = 0x0100010a,
Fkey_f1 = 0x100010b, Fkey_f1 = 0x0100010b,
Fkey_f2 = 0x100010c, Fkey_f2 = 0x0100010c,
Fkey_f3 = 0x100010d, Fkey_f3 = 0x0100010d,
Fkey_f4 = 0x100010e, Fkey_f4 = 0x0100010e,
Fkey_f5 = 0x100010f, Fkey_f5 = 0x0100010f,
Fkey_f6 = 0x1000110, Fkey_f6 = 0x01000110,
Fkey_f7 = 0x1000111, Fkey_f7 = 0x01000111,
Fkey_f8 = 0x1000112, Fkey_f8 = 0x01000112,
Fkey_f9 = 0x1000113, Fkey_f9 = 0x01000113,
Fkey_f10 = 0x1000114, Fkey_f10 = 0x01000114,
Fkey_home = 0x1000115, Fkey_home = 0x01000115,
Fkey_ic = 0x1000116, // insert key Fkey_ic = 0x01000116, // insert key
Fkey_il = 0x1000117, Fkey_il = 0x01000117,
Fkey_left = 0x1000118, Fkey_left = 0x01000118,
Fkey_ll = 0x1000119, Fkey_ll = 0x01000119,
Fkey_npage = 0x100011a, Fkey_npage = 0x0100011a,
Fkey_ppage = 0x100011b, Fkey_ppage = 0x0100011b,
Fkey_right = 0x100011c, Fkey_right = 0x0100011c,
Fkey_sf = 0x100011d, Fkey_sf = 0x0100011d,
Fkey_sr = 0x100011e, Fkey_sr = 0x0100011e,
Fkey_stab = 0x100011f, Fkey_stab = 0x0100011f,
Fkey_up = 0x1000120, Fkey_up = 0x01000120,
Fkey_a1 = 0x1000121, Fkey_a1 = 0x01000121,
Fkey_a3 = 0x1000122, Fkey_a3 = 0x01000122,
Fkey_b2 = 0x1000123, Fkey_b2 = 0x01000123,
Fkey_c1 = 0x1000124, Fkey_c1 = 0x01000124,
Fkey_c3 = 0x1000125, Fkey_c3 = 0x01000125,
Fkey_btab = 0x1000126, Fkey_btab = 0x01000126,
Fkey_beg = 0x1000127, Fkey_beg = 0x01000127,
Fkey_cancel = 0x1000128, Fkey_cancel = 0x01000128,
Fkey_close = 0x1000129, Fkey_close = 0x01000129,
Fkey_command = 0x100012a, Fkey_command = 0x0100012a,
Fkey_copy = 0x100012b, Fkey_copy = 0x0100012b,
Fkey_create = 0x100012c, Fkey_create = 0x0100012c,
Fkey_end = 0x100012d, Fkey_end = 0x0100012d,
Fkey_enter = 0x100012e, Fkey_enter = 0x0100012e,
Fkey_exit = 0x100012f, Fkey_exit = 0x0100012f,
Fkey_find = 0x1000130, Fkey_find = 0x01000130,
Fkey_help = 0x1000131, Fkey_help = 0x01000131,
Fkey_mark = 0x1000132, Fkey_mark = 0x01000132,
Fkey_message = 0x1000133, Fkey_message = 0x01000133,
Fkey_move = 0x1000134, Fkey_move = 0x01000134,
Fkey_next = 0x1000135, Fkey_next = 0x01000135,
Fkey_open = 0x1000136, Fkey_open = 0x01000136,
Fkey_options = 0x1000137, Fkey_options = 0x01000137,
Fkey_previous = 0x1000138, Fkey_previous = 0x01000138,
Fkey_print = 0x1000139, Fkey_print = 0x01000139,
Fkey_redo = 0x100013a, Fkey_redo = 0x0100013a,
Fkey_reference = 0x100013b, Fkey_reference = 0x0100013b,
Fkey_refresh = 0x100013c, Fkey_refresh = 0x0100013c,
Fkey_replace = 0x100013d, Fkey_replace = 0x0100013d,
Fkey_restart = 0x100013e, Fkey_restart = 0x0100013e,
Fkey_resume = 0x100013f, Fkey_resume = 0x0100013f,
Fkey_save = 0x1000140, Fkey_save = 0x01000140,
Fkey_suspend = 0x1000141, Fkey_suspend = 0x01000141,
Fkey_undo = 0x1000142, Fkey_undo = 0x01000142,
Fkey_sbeg = 0x1000143, Fkey_sbeg = 0x01000143,
Fkey_scancel = 0x1000144, Fkey_scancel = 0x01000144,
Fkey_scommand = 0x1000145, Fkey_scommand = 0x01000145,
Fkey_scopy = 0x1000146, Fkey_scopy = 0x01000146,
Fkey_screate = 0x1000147, Fkey_screate = 0x01000147,
Fkey_sdc = 0x1000148, Fkey_sdc = 0x01000148,
Fkey_sdl = 0x1000149, Fkey_sdl = 0x01000149,
Fkey_select = 0x100014a, Fkey_select = 0x0100014a,
Fkey_send = 0x100014b, Fkey_send = 0x0100014b,
Fkey_seol = 0x100014c, Fkey_seol = 0x0100014c,
Fkey_sexit = 0x100014d, Fkey_sexit = 0x0100014d,
Fkey_sfind = 0x100014e, Fkey_sfind = 0x0100014e,
Fkey_shelp = 0x100014f, Fkey_shelp = 0x0100014f,
Fkey_shome = 0x1000150, Fkey_shome = 0x01000150,
Fkey_sic = 0x1000151, Fkey_sic = 0x01000151,
Fkey_sleft = 0x1000152, Fkey_sleft = 0x01000152,
Fkey_smessage = 0x1000153, Fkey_smessage = 0x01000153,
Fkey_smove = 0x1000154, Fkey_smove = 0x01000154,
Fkey_snext = 0x1000155, Fkey_snext = 0x01000155,
Fkey_soptions = 0x1000156, Fkey_soptions = 0x01000156,
Fkey_sprevious = 0x1000157, Fkey_sprevious = 0x01000157,
Fkey_sprint = 0x1000158, Fkey_sprint = 0x01000158,
Fkey_sredo = 0x1000159, Fkey_sredo = 0x01000159,
Fkey_sreplace = 0x100015a, Fkey_sreplace = 0x0100015a,
Fkey_sright = 0x100015b, Fkey_sright = 0x0100015b,
Fkey_srsume = 0x100015c, Fkey_srsume = 0x0100015c,
Fkey_ssave = 0x100015d, Fkey_ssave = 0x0100015d,
Fkey_ssuspend = 0x100015e, Fkey_ssuspend = 0x0100015e,
Fkey_sundo = 0x100015f, Fkey_sundo = 0x0100015f,
Fkey_f11 = 0x1000160, Fkey_f11 = 0x01000160,
Fkey_f12 = 0x1000161, Fkey_f12 = 0x01000161,
Fkey_f13 = 0x1000162, Fkey_f13 = 0x01000162,
Fkey_f14 = 0x1000163, Fkey_f14 = 0x01000163,
Fkey_f15 = 0x1000164, Fkey_f15 = 0x01000164,
Fkey_f16 = 0x1000165, Fkey_f16 = 0x01000165,
Fkey_f17 = 0x1000166, Fkey_f17 = 0x01000166,
Fkey_f18 = 0x1000167, Fkey_f18 = 0x01000167,
Fkey_f19 = 0x1000168, Fkey_f19 = 0x01000168,
Fkey_f20 = 0x1000169, Fkey_f20 = 0x01000169,
Fkey_f21 = 0x100016a, Fkey_f21 = 0x0100016a,
Fkey_f22 = 0x100016b, Fkey_f22 = 0x0100016b,
Fkey_f23 = 0x100016c, Fkey_f23 = 0x0100016c,
Fkey_f24 = 0x100016d, Fkey_f24 = 0x0100016d,
Fkey_f25 = 0x100016e, Fkey_f25 = 0x0100016e,
Fkey_f26 = 0x100016f, Fkey_f26 = 0x0100016f,
Fkey_f27 = 0x1000170, Fkey_f27 = 0x01000170,
Fkey_f28 = 0x1000171, Fkey_f28 = 0x01000171,
Fkey_f29 = 0x1000172, Fkey_f29 = 0x01000172,
Fkey_f30 = 0x1000173, Fkey_f30 = 0x01000173,
Fkey_f31 = 0x1000174, Fkey_f31 = 0x01000174,
Fkey_f32 = 0x1000175, Fkey_f32 = 0x01000175,
Fkey_f33 = 0x1000176, Fkey_f33 = 0x01000176,
Fkey_f34 = 0x1000177, Fkey_f34 = 0x01000177,
Fkey_f35 = 0x1000178, Fkey_f35 = 0x01000178,
Fkey_f36 = 0x1000179, Fkey_f36 = 0x01000179,
Fkey_f37 = 0x100017a, Fkey_f37 = 0x0100017a,
Fkey_f38 = 0x100017b, Fkey_f38 = 0x0100017b,
Fkey_f39 = 0x100017c, Fkey_f39 = 0x0100017c,
Fkey_f40 = 0x100017d, Fkey_f40 = 0x0100017d,
Fkey_f41 = 0x100017e, Fkey_f41 = 0x0100017e,
Fkey_f42 = 0x100017f, Fkey_f42 = 0x0100017f,
Fkey_f43 = 0x1000180, Fkey_f43 = 0x01000180,
Fkey_f44 = 0x1000181, Fkey_f44 = 0x01000181,
Fkey_f45 = 0x1000182, Fkey_f45 = 0x01000182,
Fkey_f46 = 0x1000183, Fkey_f46 = 0x01000183,
Fkey_f47 = 0x1000184, Fkey_f47 = 0x01000184,
Fkey_f48 = 0x1000185, Fkey_f48 = 0x01000185,
Fkey_f49 = 0x1000186, Fkey_f49 = 0x01000186,
Fkey_f50 = 0x1000187, Fkey_f50 = 0x01000187,
Fkey_f51 = 0x1000188, Fkey_f51 = 0x01000188,
Fkey_f52 = 0x1000189, Fkey_f52 = 0x01000189,
Fkey_f53 = 0x100018a, Fkey_f53 = 0x0100018a,
Fkey_f54 = 0x100018b, Fkey_f54 = 0x0100018b,
Fkey_f55 = 0x100018c, Fkey_f55 = 0x0100018c,
Fkey_f56 = 0x100018d, Fkey_f56 = 0x0100018d,
Fkey_f57 = 0x100018e, Fkey_f57 = 0x0100018e,
Fkey_f58 = 0x100018f, Fkey_f58 = 0x0100018f,
Fkey_f59 = 0x1000190, Fkey_f59 = 0x01000190,
Fkey_f60 = 0x1000191, Fkey_f60 = 0x01000191,
Fkey_f61 = 0x1000192, Fkey_f61 = 0x01000192,
Fkey_f62 = 0x1000193, Fkey_f62 = 0x01000193,
Fkey_f63 = 0x1000194 Fkey_f63 = 0x01000194,
need_more_data = 0x80000000
}; };
// Keyboard - modifier key combinations // Keyboard - modifier key combinations
enum metakeys enum metakeys
{ {
Fmkey_ic = 0x1500100, // M-insert Fmkey_ic = 0x01500100, // M-insert
Fmkey_dc = 0x1500101, // M-delete Fmkey_dc = 0x01500101, // M-delete
Fmkey_home = 0x1500102, // M-home Fmkey_home = 0x01500102, // M-home
Fmkey_end = 0x1500103, // M-end Fmkey_end = 0x01500103, // M-end
Fmkey_ppage = 0x1500104, // M-prev-page Fmkey_ppage = 0x01500104, // M-prev-page
Fmkey_npage = 0x1500105, // M-next-page Fmkey_npage = 0x01500105, // M-next-page
Fmkey_f1 = 0x1500106, // M-f1 Fmkey_f1 = 0x01500106, // M-f1
Fmkey_f2 = 0x1500107, // M-f2 Fmkey_f2 = 0x01500107, // M-f2
Fmkey_f3 = 0x1500108, // M-f3 Fmkey_f3 = 0x01500108, // M-f3
Fmkey_f4 = 0x1500109, // M-f4 Fmkey_f4 = 0x01500109, // M-f4
Fmkey_f5 = 0x150010a, // M-f5 Fmkey_f5 = 0x0150010a, // M-f5
Fmkey_f6 = 0x150010b, // M-F6 Fmkey_f6 = 0x0150010b, // M-F6
Fmkey_f7 = 0x150010c, // M-f7 Fmkey_f7 = 0x0150010c, // M-f7
Fmkey_f8 = 0x150010d, // M-f8 Fmkey_f8 = 0x0150010d, // M-f8
Fmkey_f9 = 0x150010e, // M-f9 Fmkey_f9 = 0x0150010e, // M-f9
Fmkey_f10 = 0x150010f, // M-f10 Fmkey_f10 = 0x0150010f, // M-f10
Fmkey_f11 = 0x1500110, // M-f11 Fmkey_f11 = 0x01500110, // M-f11
Fmkey_f12 = 0x1500111, // M-f12 Fmkey_f12 = 0x01500111, // M-f12
Fmkey_up = 0x1500112, // M-up Fmkey_up = 0x01500112, // M-up
Fmkey_down = 0x1500113, // M-down Fmkey_down = 0x01500113, // M-down
Fmkey_right = 0x1500114, // M-right Fmkey_right = 0x01500114, // M-right
Fmkey_left = 0x1500115, // M-left Fmkey_left = 0x01500115, // M-left
Fmkey_sic = 0x1500116, // shifted M-Insert Fmkey_sic = 0x01500116, // shifted M-Insert
Fmkey_sdc = 0x1500117, // shifted M-Delete Fmkey_sdc = 0x01500117, // shifted M-Delete
Fmkey_shome = 0x1500118, // shifted M-Home Fmkey_shome = 0x01500118, // shifted M-Home
Fmkey_send = 0x1500119, // shifted M-End Fmkey_send = 0x01500119, // shifted M-End
Fmkey_sppage = 0x150011a, // shifted M-Page_Up Fmkey_sppage = 0x0150011a, // shifted M-Page_Up
Fmkey_snpage = 0x150011b, // shifted M-Page_Down Fmkey_snpage = 0x0150011b, // shifted M-Page_Down
Fmkey_sf1 = 0x150011c, // shifted M-F1 Fmkey_sf1 = 0x0150011c, // shifted M-F1
Fmkey_sf2 = 0x150011d, // shifted M-F2 Fmkey_sf2 = 0x0150011d, // shifted M-F2
Fmkey_sf3 = 0x150011e, // shifted M-F3 Fmkey_sf3 = 0x0150011e, // shifted M-F3
Fmkey_sf4 = 0x150011f, // shifted M-F4 Fmkey_sf4 = 0x0150011f, // shifted M-F4
Fmkey_sf5 = 0x1500120, // shifted M-F5 Fmkey_sf5 = 0x01500120, // shifted M-F5
Fmkey_sf6 = 0x1500121, // shifted M-F6 Fmkey_sf6 = 0x01500121, // shifted M-F6
Fmkey_sf7 = 0x1500122, // shifted M-F7 Fmkey_sf7 = 0x01500122, // shifted M-F7
Fmkey_sf8 = 0x1500123, // shifted M-F8 Fmkey_sf8 = 0x01500123, // shifted M-F8
Fmkey_sf9 = 0x1500124, // shifted M-F9 Fmkey_sf9 = 0x01500124, // shifted M-F9
Fmkey_sf10 = 0x1500125, // shifted M-F10 Fmkey_sf10 = 0x01500125, // shifted M-F10
Fmkey_sf11 = 0x1500126, // shifted M-F11 Fmkey_sf11 = 0x01500126, // shifted M-F11
Fmkey_sf12 = 0x1500127, // shifted M-F12 Fmkey_sf12 = 0x01500127, // shifted M-F12
Fmkey_sup = 0x1500128, // shifted M-Up Fmkey_sup = 0x01500128, // shifted M-Up
Fmkey_sdown = 0x1500129, // shifted M-Down Fmkey_sdown = 0x01500129, // shifted M-Down
Fmkey_sright = 0x150012a, // shifted M-Right Fmkey_sright = 0x0150012a, // shifted M-Right
Fmkey_sleft = 0x150012b, // shifted M-Left Fmkey_sleft = 0x0150012b, // shifted M-Left
Fckey_ic = 0x150012c, // control-Insert Fckey_ic = 0x0150012c, // control-Insert
Fckey_dc = 0x150012d, // control-Delete Fckey_dc = 0x0150012d, // control-Delete
Fckey_home = 0x150012e, // control-Home Fckey_home = 0x0150012e, // control-Home
Fckey_end = 0x150012f, // control-End Fckey_end = 0x0150012f, // control-End
Fckey_ppage = 0x1500130, // control-Page_Up Fckey_ppage = 0x01500130, // control-Page_Up
Fckey_npage = 0x1500131, // control-Page_Down Fckey_npage = 0x01500131, // control-Page_Down
Fckey_up = 0x1500132, // control-Up Fckey_up = 0x01500132, // control-Up
Fckey_down = 0x1500133, // control-Down Fckey_down = 0x01500133, // control-Down
Fckey_right = 0x1500134, // control-Right Fckey_right = 0x01500134, // control-Right
Fckey_left = 0x1500135, // control-Left Fckey_left = 0x01500135, // control-Left
Fckey_sic = 0x1500136, // shifted control-M-Insert Fckey_sic = 0x01500136, // shifted control-M-Insert
Fckey_sdc = 0x1500137, // shifted control-M-Delete Fckey_sdc = 0x01500137, // shifted control-M-Delete
Fckey_shome = 0x1500138, // shifted control-M-Home Fckey_shome = 0x01500138, // shifted control-M-Home
Fckey_send = 0x1500139, // shifted control-M-End Fckey_send = 0x01500139, // shifted control-M-End
Fckey_sppage = 0x150013a, // shifted control-M-Page_Up Fckey_sppage = 0x0150013a, // shifted control-M-Page_Up
Fckey_snpage = 0x150013b, // shifted control-M-Page_Down Fckey_snpage = 0x0150013b, // shifted control-M-Page_Down
Fckey_sup = 0x150013c, // shifted control-M-Up Fckey_sup = 0x0150013c, // shifted control-M-Up
Fckey_sdown = 0x150013d, // shifted control-M-Down Fckey_sdown = 0x0150013d, // shifted control-M-Down
Fckey_sright = 0x150013e, // shifted control-M-Right Fckey_sright = 0x0150013e, // shifted control-M-Right
Fckey_sleft = 0x150013f, // shifted control-M-Left Fckey_sleft = 0x0150013f, // shifted control-M-Left
Fcmkey_ic = 0x1500140, // control-M-Insert Fcmkey_ic = 0x01500140, // control-M-Insert
Fcmkey_dc = 0x1500141, // control-M-Delete Fcmkey_dc = 0x01500141, // control-M-Delete
Fcmkey_home = 0x1500142, // control-M-Home Fcmkey_home = 0x01500142, // control-M-Home
Fcmkey_end = 0x1500143, // control-M-End Fcmkey_end = 0x01500143, // control-M-End
Fcmkey_ppage = 0x1500144, // control-M-Page_Up Fcmkey_ppage = 0x01500144, // control-M-Page_Up
Fcmkey_npage = 0x1500145, // control-M-Page_Down Fcmkey_npage = 0x01500145, // control-M-Page_Down
Fcmkey_up = 0x1500146, // control-M-Up Fcmkey_up = 0x01500146, // control-M-Up
Fcmkey_down = 0x1500147, // control-M-Down Fcmkey_down = 0x01500147, // control-M-Down
Fcmkey_right = 0x1500148, // control-M-Right Fcmkey_right = 0x01500148, // control-M-Right
Fcmkey_left = 0x1500149, // control-M-Left Fcmkey_left = 0x01500149, // control-M-Left
Fcmkey_sic = 0x150014a, // shifted control-M-Insert Fcmkey_sic = 0x0150014a, // shifted control-M-Insert
Fcmkey_sdc = 0x150014b, // shifted control-M-Delete Fcmkey_sdc = 0x0150014b, // shifted control-M-Delete
Fcmkey_shome = 0x150014c, // shifted control-M-Home Fcmkey_shome = 0x0150014c, // shifted control-M-Home
Fcmkey_send = 0x150014d, // shifted control-M-End Fcmkey_send = 0x0150014d, // shifted control-M-End
Fcmkey_sppage = 0x150014e, // shifted control-M-Page_Up Fcmkey_sppage = 0x0150014e, // shifted control-M-Page_Up
Fcmkey_snpage = 0x150014f, // shifted control-M-Page_Down Fcmkey_snpage = 0x0150014f, // shifted control-M-Page_Down
Fcmkey_sf1 = 0x1500150, // shifted control-M-F1 Fcmkey_sf1 = 0x01500150, // shifted control-M-F1
Fcmkey_sf2 = 0x1500151, // shifted control-M-F2 Fcmkey_sf2 = 0x01500151, // shifted control-M-F2
Fcmkey_sf3 = 0x1500152, // shifted control-M-F3 Fcmkey_sf3 = 0x01500152, // shifted control-M-F3
Fcmkey_sf4 = 0x1500153, // shifted control-M-F4 Fcmkey_sf4 = 0x01500153, // shifted control-M-F4
Fcmkey_sf5 = 0x1500154, // shifted control-M-F5 Fcmkey_sf5 = 0x01500154, // shifted control-M-F5
Fcmkey_sf6 = 0x1500155, // shifted control-M-F6 Fcmkey_sf6 = 0x01500155, // shifted control-M-F6
Fcmkey_sf7 = 0x1500156, // shifted control-M-F7 Fcmkey_sf7 = 0x01500156, // shifted control-M-F7
Fcmkey_sf8 = 0x1500157, // shifted control-M-F8 Fcmkey_sf8 = 0x01500157, // shifted control-M-F8
Fcmkey_sf9 = 0x1500158, // shifted control-M-F9 Fcmkey_sf9 = 0x01500158, // shifted control-M-F9
Fcmkey_sf10 = 0x1500159, // shifted control-M-F10 Fcmkey_sf10 = 0x01500159, // shifted control-M-F10
Fcmkey_sf11 = 0x150015a, // shifted control-M-F11 Fcmkey_sf11 = 0x0150015a, // shifted control-M-F11
Fcmkey_sf12 = 0x150015b, // shifted control-M-F12 Fcmkey_sf12 = 0x0150015b, // shifted control-M-F12
Fcmkey_sup = 0x150015c, // shifted control-M-Up Fcmkey_sup = 0x0150015c, // shifted control-M-Up
Fcmkey_sdown = 0x150015d, // shifted control-M-Down Fcmkey_sdown = 0x0150015d, // shifted control-M-Down
Fcmkey_sright = 0x150015e, // shifted control-M-Right Fcmkey_sright = 0x0150015e, // shifted control-M-Right
Fcmkey_sleft = 0x150015f, // shifted control-M-Left Fcmkey_sleft = 0x0150015f, // shifted control-M-Left
Fkey_menu = 0x1600000, // menu Fkey_menu = 0x01600000, // menu
Fkey_smenu = 0x1600001, // shifted menu Fkey_smenu = 0x01600001, // shifted menu
Fckey_menu = 0x1600002, // control-menu Fckey_menu = 0x01600002, // control-menu
Fckey_smenu = 0x1600003, // shifted control-menu Fckey_smenu = 0x01600003, // shifted control-menu
Fmkey_menu = 0x1600004, // M-menu Fmkey_menu = 0x01600004, // M-menu
Fmkey_smenu = 0x1600005, // shifted M-menu Fmkey_smenu = 0x01600005, // shifted M-menu
Fcmkey_menu = 0x1600006, // control-M-menu Fcmkey_menu = 0x01600006, // control-M-menu
Fcmkey_smenu = 0x1600007, // shifted control-M-menu Fcmkey_smenu = 0x01600007, // shifted control-M-menu
Fkey_escape_mintty = 0x200001b, // mintty Esc Fkey_escape_mintty = 0x0200001b, // mintty Esc
Fkey_mouse = 0x2000020, // xterm mouse Fkey_mouse = 0x02000020, // xterm mouse
Fkey_extended_mouse = 0x2000021, // SGR extended mouse Fkey_extended_mouse = 0x02000021, // SGR extended mouse
Fkey_urxvt_mouse = 0x2000022, // urxvt mouse extension Fkey_urxvt_mouse = 0x02000022, // urxvt mouse extension
Fmkey_meta = 0x20000e0, // meta key offset Fmkey_meta = 0x020000e0, // meta key offset
Fmkey_tab = 0x20000e9, // M-tab Fmkey_tab = 0x020000e9, // M-tab
Fmkey_enter = 0x20000ea, // M-enter Fmkey_enter = 0x020000ea, // M-enter
Fmkey_space = 0x2000100, // M-' ' Fmkey_space = 0x02000100, // M-' '
Fmkey_bang = 0x2000101, // M-! Fmkey_bang = 0x02000101, // M-!
Fmkey_quotes = 0x2000102, // M-" Fmkey_quotes = 0x02000102, // M-"
Fmkey_hash = 0x2000103, // M-# Fmkey_hash = 0x02000103, // M-#
Fmkey_dollar = 0x2000104, // M-$ Fmkey_dollar = 0x02000104, // M-$
Fmkey_percent = 0x2000105, // M-% Fmkey_percent = 0x02000105, // M-%
Fmkey_ampersand = 0x2000106, // M-& Fmkey_ampersand = 0x02000106, // M-&
Fmkey_apostrophe = 0x2000107, // M-' Fmkey_apostrophe = 0x02000107, // M-'
Fmkey_left_parenthesis = 0x2000108, // M-( Fmkey_left_parenthesis = 0x02000108, // M-(
Fmkey_right_parenthesis = 0x2000109, // M-) Fmkey_right_parenthesis = 0x02000109, // M-)
Fmkey_asterisk = 0x200010a, // M-* Fmkey_asterisk = 0x0200010a, // M-*
Fmkey_plus = 0x200010b, // M-+ Fmkey_plus = 0x0200010b, // M-+
Fmkey_comma = 0x200010c, // M-, Fmkey_comma = 0x0200010c, // M-,
Fmkey_minus = 0x200010d, // M-'-' Fmkey_minus = 0x0200010d, // M-'-'
Fmkey_full_stop = 0x200010e, // M-. Fmkey_full_stop = 0x0200010e, // M-.
Fmkey_slash = 0x200010f, // M-/ Fmkey_slash = 0x0200010f, // M-/
Fmkey_0 = 0x2000110, // M-0 Fmkey_0 = 0x02000110, // M-0
Fmkey_1 = 0x2000111, // M-1 Fmkey_1 = 0x02000111, // M-1
Fmkey_2 = 0x2000112, // M-2 Fmkey_2 = 0x02000112, // M-2
Fmkey_3 = 0x2000113, // M-3 Fmkey_3 = 0x02000113, // M-3
Fmkey_4 = 0x2000114, // M-4 Fmkey_4 = 0x02000114, // M-4
Fmkey_5 = 0x2000115, // M-5 Fmkey_5 = 0x02000115, // M-5
Fmkey_6 = 0x2000116, // M-6 Fmkey_6 = 0x02000116, // M-6
Fmkey_7 = 0x2000117, // M-7 Fmkey_7 = 0x02000117, // M-7
Fmkey_8 = 0x2000118, // M-8 Fmkey_8 = 0x02000118, // M-8
Fmkey_9 = 0x2000119, // M-9 Fmkey_9 = 0x02000119, // M-9
Fmkey_colon = 0x200011a, // M-: Fmkey_colon = 0x0200011a, // M-:
Fmkey_semicolon = 0x200011b, // M-; Fmkey_semicolon = 0x0200011b, // M-;
Fmkey_less_than = 0x200011c, // M-< Fmkey_less_than = 0x0200011c, // M-<
Fmkey_equals = 0x200011d, // M-= Fmkey_equals = 0x0200011d, // M-=
Fmkey_greater_than = 0x200011e, // M-> Fmkey_greater_than = 0x0200011e, // M->
Fmkey_question_mark = 0x200011f, // M-? Fmkey_question_mark = 0x0200011f, // M-?
Fmkey_at = 0x2000120, // M-@ Fmkey_at = 0x02000120, // M-@
Fmkey_A = 0x2000121, // M-A Fmkey_A = 0x02000121, // M-A
Fmkey_B = 0x2000122, // M-B Fmkey_B = 0x02000122, // M-B
Fmkey_C = 0x2000123, // M-C Fmkey_C = 0x02000123, // M-C
Fmkey_D = 0x2000124, // M-D Fmkey_D = 0x02000124, // M-D
Fmkey_E = 0x2000125, // M-E Fmkey_E = 0x02000125, // M-E
Fmkey_F = 0x2000126, // M-F Fmkey_F = 0x02000126, // M-F
Fmkey_G = 0x2000127, // M-G Fmkey_G = 0x02000127, // M-G
Fmkey_H = 0x2000128, // M-H Fmkey_H = 0x02000128, // M-H
Fmkey_I = 0x2000129, // M-I Fmkey_I = 0x02000129, // M-I
Fmkey_J = 0x200012a, // M-J Fmkey_J = 0x0200012a, // M-J
Fmkey_K = 0x200012b, // M-K Fmkey_K = 0x0200012b, // M-K
Fmkey_L = 0x200012c, // M-L Fmkey_L = 0x0200012c, // M-L
Fmkey_M = 0x200012d, // M-M Fmkey_M = 0x0200012d, // M-M
Fmkey_N = 0x200012e, // M-N Fmkey_N = 0x0200012e, // M-N
Fmkey_O = 0x200012f, // M-O Fmkey_O = 0x0200012f, // M-O
Fmkey_P = 0x2000130, // M-P Fmkey_P = 0x02000130, // M-P
Fmkey_Q = 0x2000131, // M-Q Fmkey_Q = 0x02000131, // M-Q
Fmkey_R = 0x2000132, // M-R Fmkey_R = 0x02000132, // M-R
Fmkey_S = 0x2000133, // M-S Fmkey_S = 0x02000133, // M-S
Fmkey_T = 0x2000134, // M-T Fmkey_T = 0x02000134, // M-T
Fmkey_U = 0x2000135, // M-U Fmkey_U = 0x02000135, // M-U
Fmkey_V = 0x2000136, // M-V Fmkey_V = 0x02000136, // M-V
Fmkey_W = 0x2000137, // M-W Fmkey_W = 0x02000137, // M-W
Fmkey_X = 0x2000138, // M-X Fmkey_X = 0x02000138, // M-X
Fmkey_Y = 0x2000139, // M-Y Fmkey_Y = 0x02000139, // M-Y
Fmkey_Z = 0x200013a, // M-Z Fmkey_Z = 0x0200013a, // M-Z
Fmkey_left_square_bracket = 0x200013b, // M-[ Fmkey_left_square_bracket = 0x0200013b, // M-[
Fmkey_backslash = 0x200013c, // M-'\' Fmkey_backslash = 0x0200013c, // M-'\'
Fmkey_right_square_bracket = 0x200013d, // M-] Fmkey_right_square_bracket = 0x0200013d, // M-]
Fmkey_caret = 0x200013e, // M-^ Fmkey_caret = 0x0200013e, // M-^
Fmkey_underscore = 0x200013f, // M-_ Fmkey_underscore = 0x0200013f, // M-_
Fmkey_grave_accent = 0x2000140, // M-` Fmkey_grave_accent = 0x02000140, // M-`
Fmkey_a = 0x2000141, // M-a Fmkey_a = 0x02000141, // M-a
Fmkey_b = 0x2000142, // M-b Fmkey_b = 0x02000142, // M-b
Fmkey_c = 0x2000143, // M-c Fmkey_c = 0x02000143, // M-c
Fmkey_d = 0x2000144, // M-d Fmkey_d = 0x02000144, // M-d
Fmkey_e = 0x2000145, // M-e Fmkey_e = 0x02000145, // M-e
Fmkey_f = 0x2000146, // M-f Fmkey_f = 0x02000146, // M-f
Fmkey_g = 0x2000147, // M-g Fmkey_g = 0x02000147, // M-g
Fmkey_h = 0x2000148, // M-h Fmkey_h = 0x02000148, // M-h
Fmkey_i = 0x2000149, // M-i Fmkey_i = 0x02000149, // M-i
Fmkey_j = 0x200014a, // M-j Fmkey_j = 0x0200014a, // M-j
Fmkey_k = 0x200014b, // M-k Fmkey_k = 0x0200014b, // M-k
Fmkey_l = 0x200014c, // M-l Fmkey_l = 0x0200014c, // M-l
Fmkey_m = 0x200014d, // M-m Fmkey_m = 0x0200014d, // M-m
Fmkey_n = 0x200014e, // M-n Fmkey_n = 0x0200014e, // M-n
Fmkey_o = 0x200014f, // M-o Fmkey_o = 0x0200014f, // M-o
Fmkey_p = 0x2000150, // M-p Fmkey_p = 0x02000150, // M-p
Fmkey_q = 0x2000151, // M-q Fmkey_q = 0x02000151, // M-q
Fmkey_r = 0x2000152, // M-r Fmkey_r = 0x02000152, // M-r
Fmkey_s = 0x2000153, // M-s Fmkey_s = 0x02000153, // M-s
Fmkey_t = 0x2000154, // M-t Fmkey_t = 0x02000154, // M-t
Fmkey_u = 0x2000155, // M-u Fmkey_u = 0x02000155, // M-u
Fmkey_v = 0x2000156, // M-v Fmkey_v = 0x02000156, // M-v
Fmkey_w = 0x2000157, // M-w Fmkey_w = 0x02000157, // M-w
Fmkey_x = 0x2000158, // M-x Fmkey_x = 0x02000158, // M-x
Fmkey_y = 0x2000159, // M-y Fmkey_y = 0x02000159, // M-y
Fmkey_z = 0x200015a, // M-z Fmkey_z = 0x0200015a, // M-z
Fmkey_left_curly_bracket = 0x200015b, // M-{ Fmkey_left_curly_bracket = 0x0200015b, // M-{
Fmkey_vertical_bar = 0x200015c, // M-| Fmkey_vertical_bar = 0x0200015c, // M-|
Fmkey_right_curly_bracket = 0x200015d, // M-} Fmkey_right_curly_bracket = 0x0200015d, // M-}
Fmkey_tilde = 0x200015e // M-~ Fmkey_tilde = 0x0200015e // M-~
}; };
// Console color names // Console color names
enum colornames enum colornames
{ {
Default = -1,
Black = 0, Black = 0,
Blue = 1, Blue = 1,
Green = 2, Green = 2,
@ -925,7 +909,8 @@ enum colornames
Grey82 = 252, // #d0d0d0 Grey82 = 252, // #d0d0d0
Grey85 = 253, // #dadada Grey85 = 253, // #dadada
Grey89 = 254, // #e4e4e4 Grey89 = 254, // #e4e4e4
Grey93 = 255 // #eeeeee Grey93 = 255, // #eeeeee
Default = static_cast<FColor>(-1)
}; };
// Mouse/keyboard state values // Mouse/keyboard state values

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

@ -74,7 +74,7 @@ class FCheckBox : public FToggleButton
public: public:
// Constructors // Constructors
explicit FCheckBox (FWidget* = 0); explicit FCheckBox (FWidget* = 0);
FCheckBox (const FString&, FWidget* = 0); explicit FCheckBox (const FString&, FWidget* = 0);
// Destructor // Destructor
virtual ~FCheckBox(); virtual ~FCheckBox();

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

@ -74,7 +74,7 @@ class FCheckMenuItem : public FMenuItem
public: public:
// Constructors // Constructors
explicit FCheckMenuItem (FWidget* = 0); explicit FCheckMenuItem (FWidget* = 0);
FCheckMenuItem (const FString&, FWidget* = 0); explicit FCheckMenuItem (const FString&, FWidget* = 0);
// Destructor // Destructor
virtual ~FCheckMenuItem(); virtual ~FCheckMenuItem();

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

@ -51,13 +51,13 @@ class FColorPalette
{ {
public: public:
// Constructor // Constructor
explicit FColorPalette(); FColorPalette();
// Destructor // Destructor
virtual ~FColorPalette(); virtual ~FColorPalette();
// Typedefs // Typedefs
typedef void (*funcp)(short, int, int, int); typedef void (*funcp)(FColor, int, int, int);
// Accessor // Accessor
virtual const char* getClassName() const; virtual const char* getClassName() const;

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

@ -161,8 +161,7 @@
#define F_HAVE_VSNPRINTF 1 #define F_HAVE_VSNPRINTF 1
#endif #endif
/* Define to the sub-directory in which libtool stores uninstalled libraries. /* Define to the sub-directory where libtool stores uninstalled libraries. */
*/
#ifndef F_LT_OBJDIR #ifndef F_LT_OBJDIR
#define F_LT_OBJDIR ".libs/" #define F_LT_OBJDIR ".libs/"
#endif #endif

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

@ -88,7 +88,7 @@ class FDialog : public FWindow
// Constructors // Constructors
explicit FDialog (FWidget* = 0); explicit FDialog (FWidget* = 0);
FDialog (const FString&, FWidget* = 0); explicit FDialog (const FString&, FWidget* = 0);
// Destructor // Destructor
virtual ~FDialog(); virtual ~FDialog();
@ -282,11 +282,11 @@ inline void FDialog::setText (const FString& txt)
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline bool FDialog::isModal() inline bool FDialog::isModal()
{ return ((flags & fc::modal) != 0); } { return flags.modal; }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline bool FDialog::isScrollable() inline bool FDialog::isScrollable()
{ return ((flags & fc::scrollable) != 0); } { return flags.scrollable; }
} // namespace finalcut } // namespace finalcut

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

@ -80,7 +80,7 @@ class FDialogListMenu : public FMenu
public: public:
// Constructors // Constructors
explicit FDialogListMenu (FWidget* = 0); explicit FDialogListMenu (FWidget* = 0);
FDialogListMenu (const FString&, FWidget* = 0); explicit FDialogListMenu (const FString&, FWidget* = 0);
// Destructor // Destructor
virtual ~FDialogListMenu(); virtual ~FDialogListMenu();

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

@ -113,16 +113,16 @@ class FEvent // event base class
class FKeyEvent : public FEvent // keyboard event class FKeyEvent : public FEvent // keyboard event
{ {
public: public:
FKeyEvent (int, int); FKeyEvent (int, FKey);
~FKeyEvent(); ~FKeyEvent();
int key() const; FKey key() const;
bool isAccepted() const; bool isAccepted() const;
void accept(); void accept();
void ignore(); void ignore();
protected: protected:
int k; FKey k;
bool accpt; bool accpt;
}; };

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

@ -60,7 +60,7 @@ class FKeyboardCommand
{ {
public: public:
// Constructor // Constructor
FKeyboardCommand (FApplication* = 0, void(FApplication::*)() = 0); explicit FKeyboardCommand (FApplication* = 0, void(FApplication::*)() = 0);
// Method // Method
void execute(); void execute();
@ -97,8 +97,8 @@ class FKeyboard
// Accessors // Accessors
virtual const char* getClassName() const; virtual const char* getClassName() const;
int getKey(); FKey getKey();
const FString getKeyName (int); const FString getKeyName (FKey);
keybuffer& getKeyBuffer(); keybuffer& getKeyBuffer();
timeval* getKeyPressedTime(); timeval* getKeyPressedTime();
@ -131,8 +131,8 @@ class FKeyboard
private: private:
// Constants // Constants
static const int NEED_MORE_DATA = -1;
static const std::size_t READ_BUF_SIZE = 1024; static const std::size_t READ_BUF_SIZE = 1024;
static const FKey NOT_SET = static_cast<FKey>(-1);
// Disable copy constructor // Disable copy constructor
FKeyboard (const FKeyboard&); FKeyboard (const FKeyboard&);
@ -141,10 +141,10 @@ class FKeyboard
FKeyboard& operator = (const FKeyboard&); FKeyboard& operator = (const FKeyboard&);
// Accessors // Accessors
int getMouseProtocolKey(); FKey getMouseProtocolKey();
int getTermcapKey(); FKey getTermcapKey();
int getMetaKey(); FKey getMetaKey();
int getSingleKey(); FKey getSingleKey();
// Mutators // Mutators
bool setNonBlockingInput (bool); bool setNonBlockingInput (bool);
@ -155,18 +155,18 @@ class FKeyboard
static bool isKeypressTimeout(); static bool isKeypressTimeout();
// Methods // Methods
int UTF8decode (const char[]); FKey UTF8decode (const char[]);
ssize_t readKey(); ssize_t readKey();
void parseKeyBuffer(); void parseKeyBuffer();
int parseKeyString(); FKey parseKeyString();
int keyCorrection (const int&); FKey keyCorrection (const FKey&);
void substringKeyHandling(); void substringKeyHandling();
void keyPressed(); void keyPressed();
void keyReleased(); void keyReleased();
void escapeKeyPressed(); void escapeKeyPressed();
// Data Members // Data Members
int key; FKey key;
char read_buf[READ_BUF_SIZE]; char read_buf[READ_BUF_SIZE];
char fifo_buf[FIFO_BUF_SIZE]; char fifo_buf[FIFO_BUF_SIZE];
int fifo_offset; int fifo_offset;
@ -197,7 +197,7 @@ inline const char* FKeyboard::getClassName() const
{ return "FKeyboard"; } { return "FKeyboard"; }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline int FKeyboard::getKey() inline FKey FKeyboard::getKey()
{ return key; } { return key; }
//---------------------------------------------------------------------- //----------------------------------------------------------------------

10
src/include/final/flabel.h
View File

@ -74,7 +74,7 @@ class FLabel : public FWidget
// Constructor // Constructor
explicit FLabel (FWidget* = 0); explicit FLabel (FWidget* = 0);
FLabel (const FString&, FWidget* = 0); explicit FLabel (const FString&, FWidget* = 0);
// Destructor // Destructor
virtual ~FLabel(); virtual ~FLabel();
@ -94,7 +94,7 @@ class FLabel : public FWidget
// Accessors // Accessors
const char* getClassName() const; const char* getClassName() const;
FTerm* getAccelWidget(); FWidget* getAccelWidget();
fc::text_alignment getAlignment(); fc::text_alignment getAlignment();
FString& getText(); FString& getText();
@ -157,8 +157,8 @@ class FLabel : public FWidget
bool multiline; bool multiline;
FString text; FString text;
fc::text_alignment alignment; fc::text_alignment alignment;
short emphasis_color; FColor emphasis_color;
short ellipsis_color; FColor ellipsis_color;
bool emphasis; bool emphasis;
bool reverse_mode; bool reverse_mode;
FWidget* accel_widget; FWidget* accel_widget;
@ -172,7 +172,7 @@ inline const char* FLabel::getClassName() const
{ return "FLabel"; } { return "FLabel"; }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline FTerm* FLabel::getAccelWidget () inline FWidget* FLabel::getAccelWidget ()
{ return accel_widget; } { return accel_widget; }
//---------------------------------------------------------------------- //----------------------------------------------------------------------

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

@ -77,7 +77,7 @@ class FLineEdit : public FWidget
// Constructor // Constructor
explicit FLineEdit (FWidget* = 0); explicit FLineEdit (FWidget* = 0);
FLineEdit (const FString&, FWidget* = 0); explicit FLineEdit (const FString&, FWidget* = 0);
// Destructor // Destructor
virtual ~FLineEdit(); virtual ~FLineEdit();
@ -165,7 +165,7 @@ class FLineEdit : public FWidget
void keyBackspace(); void keyBackspace();
void keyInsert(); void keyInsert();
void keyEnter(); void keyEnter();
bool keyInput (int); bool keyInput (FKey);
void processActivate(); void processActivate();
void processChanged(); void processChanged();
@ -227,7 +227,7 @@ inline bool FLineEdit::unsetShadow()
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline bool FLineEdit::hasShadow() inline bool FLineEdit::hasShadow()
{ return ((flags & fc::shadow) != 0); } { return flags.shadow; }
} // namespace finalcut } // namespace finalcut

7
src/include/final/flistbox.h
View File

@ -245,7 +245,7 @@ class FListBox : public FWidget
// Methods // Methods
void init(); void init();
virtual void draw(); virtual void draw();
void drawLabel(); void drawHeadline();
void drawList(); void drawList();
void drawListLine (int, listBoxItems::iterator, bool); void drawListLine (int, listBoxItems::iterator, bool);
void printLeftBracket (fc::brackets_type); void printLeftBracket (fc::brackets_type);
@ -285,7 +285,7 @@ class FListBox : public FWidget
bool keySpace(); bool keySpace();
bool keyInsert(); bool keyInsert();
bool keyBackspace(); bool keyBackspace();
bool keyIncSearchInput (int); bool keyIncSearchInput (FKey);
void processClick(); void processClick();
void processSelect(); void processSelect();
void processChanged(); void processChanged();
@ -526,7 +526,8 @@ void FListBox::insert (Container container, LazyConverter convert)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline FListBox::listBoxItems::iterator FListBox::index2iterator (std::size_t index) inline FListBox::listBoxItems::iterator \
FListBox::index2iterator (std::size_t index)
{ {
listBoxItems::iterator iter = itemlist.begin(); listBoxItems::iterator iter = itemlist.begin();
std::advance (iter, index); std::advance (iter, index);

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

@ -52,9 +52,10 @@
#error "Only <final/final.h> can be included directly." #error "Only <final/final.h> can be included directly."
#endif #endif
#include <list>
#include <stack> #include <stack>
#include <vector> #include <vector>
#include "final/fmessagebox.h"
#include "final/fscrollbar.h" #include "final/fscrollbar.h"
#include "final/fstring.h" #include "final/fstring.h"
#include "final/ftermbuffer.h" #include "final/ftermbuffer.h"
@ -97,11 +98,14 @@ class FListViewItem : public FObject
FWidget::data_ptr getData() const; FWidget::data_ptr getData() const;
uInt getDepth() const; uInt getDepth() const;
// Mutator // Mutators
void setText (int, const FString&); void setText (int, const FString&);
void setData (FWidget::data_ptr); void setData (FWidget::data_ptr);
void setCheckable (bool);
void setChecked (bool);
// Inquiry // Inquiry
bool isChecked() const;
bool isExpand() const; bool isExpand() const;
// Methods // Methods
@ -113,6 +117,7 @@ class FListViewItem : public FObject
private: private:
// Inquiry // Inquiry
bool isExpandable() const; bool isExpandable() const;
bool isCheckable() const;
// Methods // Methods
template <typename Compare> template <typename Compare>
@ -129,6 +134,8 @@ class FListViewItem : public FObject
std::size_t visible_lines; std::size_t visible_lines;
bool expandable; bool expandable;
bool is_expand; bool is_expand;
bool checkable;
bool is_checked;
// Friend class // Friend class
friend class FListView; friend class FListView;
@ -154,6 +161,14 @@ inline FWidget::data_ptr FListViewItem::getData() const
inline void FListViewItem::setData (FWidget::data_ptr data) inline void FListViewItem::setData (FWidget::data_ptr data)
{ data_pointer = data; } { data_pointer = data; }
//----------------------------------------------------------------------
inline void FListViewItem::setChecked (bool checked)
{ is_checked = checked; }
//----------------------------------------------------------------------
inline bool FListViewItem::isChecked() const
{ return is_checked; }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline bool FListViewItem::isExpand() const inline bool FListViewItem::isExpand() const
{ return is_expand; } { return is_expand; }
@ -162,6 +177,10 @@ inline bool FListViewItem::isExpand() const
inline bool FListViewItem::isExpandable() const inline bool FListViewItem::isExpandable() const
{ return expandable; } { return expandable; }
//----------------------------------------------------------------------
inline bool FListViewItem::isCheckable() const
{ return checkable; }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// class FListViewIterator // class FListViewIterator
@ -179,7 +198,7 @@ class FListViewIterator
typedef std::stack<FObjectIterator> FObjectIteratorStack; typedef std::stack<FObjectIterator> FObjectIteratorStack;
// Constructor // Constructor
explicit FListViewIterator (); FListViewIterator ();
FListViewIterator (FObjectIterator); FListViewIterator (FObjectIterator);
// Overloaded operators // Overloaded operators
@ -269,17 +288,20 @@ class FListView : public FWidget
FListViewItem* getCurrentItem(); FListViewItem* getCurrentItem();
// Mutators // Mutators
virtual void setGeometry (int, int, std::size_t, std::size_t, bool = true); virtual void setGeometry ( int, int
, std::size_t, std::size_t
, bool = true );
void setColumnAlignment (int, fc::text_alignment); void setColumnAlignment (int, fc::text_alignment);
void setColumnText (int, const FString&); void setColumnText (int, const FString&);
void setColumnSortType (int,fc::sorting_type \ void setColumnSortType (int, fc::sorting_type \
= fc::by_name); = fc::by_name);
void setColumnSort (int, fc::sorting_order \ void setColumnSort (int, fc::sorting_order \
= fc::ascending); = fc::ascending);
template <typename Compare> template <typename Compare>
void setUserAscendingCompare (Compare); void setUserAscendingCompare (Compare);
template <typename Compare> template <typename Compare>
void setUserDescendingCompare (Compare); void setUserDescendingCompare (Compare);
void hideSortIndicator (bool);
bool setTreeView (bool); bool setTreeView (bool);
bool setTreeView(); bool setTreeView();
bool unsetTreeView(); bool unsetTreeView();
@ -348,18 +370,24 @@ class FListView : public FWidget
, std::size_t , std::size_t
, std::size_t ); , std::size_t );
virtual void draw(); virtual void draw();
void drawColumnLabels(); void drawHeadlines();
void drawList(); void drawList();
void drawListLine (const FListViewItem*, bool, bool); void drawListLine (const FListViewItem*, bool, bool);
void setLineAttributes (bool, bool); void setLineAttributes (bool, bool);
FString getCheckBox (const FListViewItem* item);
FString getLinePrefix (const FListViewItem*, std::size_t); FString getLinePrefix (const FListViewItem*, std::size_t);
void drawColumnText (headerItems::const_iterator&); void drawSortIndicator (std::size_t&, std::size_t);
void drawHeadlineLabel (headerItems::const_iterator&);
void drawHeaderBorder (std::size_t);
void drawColumnEllipsis ( headerItems::const_iterator& void drawColumnEllipsis ( headerItems::const_iterator&
, const FString& ); , const FString& );
void updateDrawing (bool, bool); void updateDrawing (bool, bool);
int determineLineWidth (FListViewItem* item); int determineLineWidth (FListViewItem*);
void beforeInsertion (FListViewItem*);
void afterInsertion();
void recalculateHorizontalBar (int); void recalculateHorizontalBar (int);
void recalculateVerticalBar (int); void recalculateVerticalBar (int);
void mouseHeaderClicked();
void wheelUp (int); void wheelUp (int);
void wheelDown (int); void wheelDown (int);
bool dragScrollUp (int); bool dragScrollUp (int);
@ -370,6 +398,7 @@ class FListView : public FWidget
FObjectIterator appendItem (FListViewItem*); FObjectIterator appendItem (FListViewItem*);
void processClick(); void processClick();
void processChanged(); void processChanged();
void keySpace();
void keyLeft (int&); void keyLeft (int&);
void keyRight (int&); void keyRight (int&);
void keyHome(); void keyHome();
@ -386,6 +415,7 @@ class FListView : public FWidget
void scrollTo (const FPoint &); void scrollTo (const FPoint &);
void scrollTo (int, int); void scrollTo (int, int);
void scrollBy (int, int); void scrollBy (int, int);
bool hasCheckableItems() const;
// Callback methods // Callback methods
void cb_VBarChange (FWidget*, data_ptr); void cb_VBarChange (FWidget*, data_ptr);
@ -407,7 +437,11 @@ class FListView : public FWidget
int scroll_distance; int scroll_distance;
bool scroll_timer; bool scroll_timer;
bool tree_view; bool tree_view;
bool hide_sort_indicator;
bool has_checkable_items;
FPoint clicked_expander_pos; FPoint clicked_expander_pos;
FPoint clicked_header_pos;
const FListViewItem* clicked_checkbox_item;
int xoffset; int xoffset;
int nf_offset; int nf_offset;
int max_line_width; int max_line_width;
@ -432,7 +466,7 @@ class FListView : public FWidget
struct FListView::Header struct FListView::Header
{ {
public: public:
explicit Header() Header()
: name() : name()
, width (0) , width (0)
, fixed_width (false) , fixed_width (false)
@ -474,9 +508,13 @@ template <typename Compare>
inline void FListView::setUserDescendingCompare (Compare cmp) inline void FListView::setUserDescendingCompare (Compare cmp)
{ user_defined_descending = cmp; } { user_defined_descending = cmp; }
//----------------------------------------------------------------------
inline void FListView::hideSortIndicator (bool hide)
{ hide_sort_indicator = hide; }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline bool FListView::setTreeView (bool on) inline bool FListView::setTreeView (bool on)
{ return tree_view = on; } { return (tree_view = on); }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline bool FListView::setTreeView() inline bool FListView::setTreeView()
@ -524,6 +562,10 @@ inline FObject::FObjectIterator FListView::endOfList()
inline void FListView::scrollTo (const FPoint& pos) inline void FListView::scrollTo (const FPoint& pos)
{ scrollTo(pos.getX(), pos.getY()); } { scrollTo(pos.getX(), pos.getY()); }
//----------------------------------------------------------------------
inline bool FListView::hasCheckableItems() const
{ return has_checkable_items; }
} // namespace finalcut } // namespace finalcut
#endif // FLISTVIEW_H #endif // FLISTVIEW_H

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

@ -79,7 +79,7 @@ class FMenu : public FWindow, public FMenuList
public: public:
// Constructor // Constructor
explicit FMenu (FWidget* = 0); explicit FMenu (FWidget* = 0);
FMenu (const FString&, FWidget* = 0); explicit FMenu (const FString&, FWidget* = 0);
// Destructor // Destructor
virtual ~FMenu(); virtual ~FMenu();
@ -210,7 +210,7 @@ class FMenu : public FWindow, public FMenuList
void drawCheckMarkPrefix (FMenuItem*); void drawCheckMarkPrefix (FMenuItem*);
void drawMenuText (menuText&); void drawMenuText (menuText&);
void drawSubMenuIndicator (std::size_t&); void drawSubMenuIndicator (std::size_t&);
void drawAcceleratorKey (std::size_t&, int); void drawAcceleratorKey (std::size_t&, FKey);
void drawTrailingSpaces (std::size_t); void drawTrailingSpaces (std::size_t);
void setLineAttributes (FMenuItem*, int); void setLineAttributes (FMenuItem*, int);
void setCursorToHotkeyPosition (FMenuItem*); void setCursorToHotkeyPosition (FMenuItem*);

14
src/include/final/fmenuitem.h
View File

@ -83,15 +83,15 @@ class FMenuItem : public FWidget
// Constructor // Constructor
explicit FMenuItem (FWidget* = 0); explicit FMenuItem (FWidget* = 0);
FMenuItem (const FString&, FWidget* = 0); explicit FMenuItem (const FString&, FWidget* = 0);
FMenuItem (int, const FString&, FWidget* = 0); FMenuItem (FKey, const FString&, FWidget* = 0);
// Destructor // Destructor
virtual ~FMenuItem(); virtual ~FMenuItem();
// Accessors // Accessors
const char* getClassName() const; const char* getClassName() const;
int getHotkey() const; uChar getHotkey() const;
FMenu* getMenu() const; FMenu* getMenu() const;
std::size_t getTextLength() const; std::size_t getTextLength() const;
FString getText() const; FString getText() const;
@ -118,7 +118,7 @@ class FMenuItem : public FWidget
bool hasMenu() const; bool hasMenu() const;
// Methods // Methods
virtual void addAccelerator (int, FWidget*); virtual void addAccelerator (FKey, FWidget*);
virtual void delAccelerator (FWidget*); virtual void delAccelerator (FWidget*);
void openMenu(); void openMenu();
@ -153,8 +153,8 @@ class FMenuItem : public FWidget
bool radio_button; bool radio_button;
bool dialog_index; bool dialog_index;
std::size_t text_length; std::size_t text_length;
int hotkey; uChar hotkey;
int accel_key; FKey accel_key;
FMenu* menu; FMenu* menu;
FWidget* super_menu; FWidget* super_menu;
FDialog* associated_window; FDialog* associated_window;
@ -199,7 +199,7 @@ inline const char* FMenuItem::getClassName() const
{ return "FMenuItem"; } { return "FMenuItem"; }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline int FMenuItem::getHotkey() const inline uChar FMenuItem::getHotkey() const
{ return hotkey; } { return hotkey; }
//---------------------------------------------------------------------- //----------------------------------------------------------------------

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

@ -62,7 +62,7 @@ class FMenuList
{ {
public: public:
// Constructor // Constructor
explicit FMenuList(); FMenuList();
// Destructor // Destructor
virtual ~FMenuList(); virtual ~FMenuList();

Some files were not shown because too many files have changed in this diff Show More