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

bool on -> bool enable

This commit is contained in:
Markus Gans 2018-12-22 23:50:10 +01:00
parent ac9ed260f5
commit 81a4e72916
35 changed files with 278 additions and 278 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
examples/calculator.cpp
View File

@ -64,12 +64,12 @@ Button::Button (finalcut::FWidget* parent)
{ }
//----------------------------------------------------------------------
void Button::setChecked (bool on)
void Button::setChecked (bool enable)
{
if ( checked == on )
if ( checked == enable )
return;
checked = on;
checked = enable;
if ( checked )
{

36
src/fbutton.cpp
View File

@ -119,31 +119,31 @@ void FButton::setInactiveBackgroundColor (FColor color)
}
//----------------------------------------------------------------------
bool FButton::setNoUnderline (bool on)
bool FButton::setNoUnderline (bool enable)
{
return (flags.no_underline = on);
return (flags.no_underline = enable);
}
//----------------------------------------------------------------------
bool FButton::setEnable (bool on)
bool FButton::setEnable (bool enable)
{
FWidget::setEnable(on);
FWidget::setEnable(enable);
if ( on )
if ( enable )
setHotkeyAccelerator();
else
delAccelerator();
updateButtonColor();
return on;
return enable;
}
//----------------------------------------------------------------------
bool FButton::setFocus (bool on)
bool FButton::setFocus (bool enable)
{
FWidget::setFocus(on);
FWidget::setFocus(enable);
if ( on )
if ( enable )
{
if ( isEnabled() )
{
@ -164,19 +164,19 @@ bool FButton::setFocus (bool on)
}
updateButtonColor();
return on;
return enable;
}
//----------------------------------------------------------------------
bool FButton::setFlat (bool on)
bool FButton::setFlat (bool enable)
{
return (flags.flat = on);
return (flags.flat = enable);
}
//----------------------------------------------------------------------
bool FButton::setShadow (bool on)
bool FButton::setShadow (bool enable)
{
if ( on
if ( enable
&& getEncoding() != fc::VT100
&& getEncoding() != fc::ASCII )
{
@ -193,15 +193,15 @@ bool FButton::setShadow (bool on)
}
//----------------------------------------------------------------------
bool FButton::setDown (bool on)
bool FButton::setDown (bool enable)
{
if ( button_down != on )
if ( button_down != enable )
{
button_down = on;
button_down = enable;
redraw();
}
return on;
return enable;
}
//----------------------------------------------------------------------

8
src/fbuttongroup.cpp
View File

@ -99,16 +99,16 @@ FToggleButton* FButtonGroup::getLastButton()
}
//----------------------------------------------------------------------
bool FButtonGroup::setEnable (bool on)
bool FButtonGroup::setEnable (bool enable)
{
FWidget::setEnable(on);
FWidget::setEnable(enable);
if ( on )
if ( enable )
setHotkeyAccelerator();
else
delAccelerator();
return on;
return enable;
}
//----------------------------------------------------------------------

32
src/fdialog.cpp
View File

@ -69,55 +69,55 @@ FDialog::~FDialog() // destructor
// public methods of FDialog
//----------------------------------------------------------------------
bool FDialog::setDialogWidget (bool on)
bool FDialog::setDialogWidget (bool enable)
{
if ( isDialogWidget() == on )
if ( isDialogWidget() == enable )
return true;
flags.dialog_widget = on;
flags.dialog_widget = enable;
if ( on )
if ( enable )
setTermOffsetWithPadding();
else
setParentOffset();
return on;
return enable;
}
//----------------------------------------------------------------------
bool FDialog::setModal (bool on)
bool FDialog::setModal (bool enable)
{
if ( isModal() == on )
if ( isModal() == enable )
return true;
flags.modal = on;
flags.modal = enable;
if ( on )
if ( enable )
modal_dialogs++;
else
modal_dialogs--;
return on;
return enable;
}
//----------------------------------------------------------------------
bool FDialog::setScrollable (bool on)
bool FDialog::setScrollable (bool enable)
{
return (flags.scrollable = on);
return (flags.scrollable = enable);
}
//----------------------------------------------------------------------
bool FDialog::setResizeable (bool on)
bool FDialog::setResizeable (bool enable)
{
FWindow::setResizeable (on);
FWindow::setResizeable (enable);
if ( on )
if ( enable )
zoom_item->setEnable();
else
zoom_item->setDisable();
return on;
return enable;
}
//----------------------------------------------------------------------

6
src/ffiledialog.cpp
View File

@ -178,12 +178,12 @@ void FFileDialog::setFilter (const FString& filter)
}
//----------------------------------------------------------------------
bool FFileDialog::setShowHiddenFiles (bool on)
bool FFileDialog::setShowHiddenFiles (bool enable)
{
if ( on == show_hidden )
if ( show_hidden == enable )
return show_hidden;
show_hidden = on;
show_hidden = enable;
readDir();
filebrowser.redraw();
return show_hidden;

6
src/fkeyboard.cpp
View File

@ -321,12 +321,12 @@ inline FKey FKeyboard::getSingleKey()
}
//----------------------------------------------------------------------
bool FKeyboard::setNonBlockingInput (bool on)
bool FKeyboard::setNonBlockingInput (bool enable)
{
if ( on == non_blocking_stdin )
if ( enable == non_blocking_stdin )
return non_blocking_stdin;
if ( on ) // make stdin non-blocking
if ( enable ) // make stdin non-blocking
{
stdin_status_flags |= O_NONBLOCK;

24
src/flabel.cpp
View File

@ -180,34 +180,34 @@ void FLabel::setAlignment (fc::text_alignment align)
}
//----------------------------------------------------------------------
bool FLabel::setEmphasis (bool on)
bool FLabel::setEmphasis (bool enable)
{
if ( emphasis != on )
emphasis = on;
if ( emphasis != enable )
emphasis = enable;
return on;
return enable;
}
//----------------------------------------------------------------------
bool FLabel::setReverseMode (bool on)
bool FLabel::setReverseMode (bool enable)
{
if ( reverse_mode != on )
reverse_mode = on;
if ( reverse_mode != enable )
reverse_mode = enable;
return on;
return enable;
}
//----------------------------------------------------------------------
bool FLabel::setEnable (bool on)
bool FLabel::setEnable (bool enable)
{
FWidget::setEnable(on);
FWidget::setEnable(enable);
if ( on )
if ( enable )
setHotkeyAccelerator();
else
delAccelerator();
return on;
return enable;
}
//----------------------------------------------------------------------

20
src/flineedit.cpp
View File

@ -159,11 +159,11 @@ const FLineEdit& FLineEdit::operator >> (FString& s)
// public methods of FLineEdit
//----------------------------------------------------------------------
bool FLineEdit::setEnable (bool on)
bool FLineEdit::setEnable (bool enable)
{
FWidget::setEnable(on);
FWidget::setEnable(enable);
if ( on )
if ( enable )
{
if ( hasFocus() )
{
@ -182,15 +182,15 @@ bool FLineEdit::setEnable (bool on)
setBackgroundColor (wc.inputfield_inactive_bg);
}
return on;
return enable;
}
//----------------------------------------------------------------------
bool FLineEdit::setFocus (bool on)
bool FLineEdit::setFocus (bool enable)
{
FWidget::setFocus(on);
FWidget::setFocus(enable);
if ( on )
if ( enable )
{
if ( isEnabled() )
{
@ -219,13 +219,13 @@ bool FLineEdit::setFocus (bool on)
}
}
return on;
return enable;
}
//----------------------------------------------------------------------
bool FLineEdit::setShadow (bool on)
bool FLineEdit::setShadow (bool enable)
{
if ( on
if ( enable
&& getEncoding() != fc::VT100
&& getEncoding() != fc::ASCII )
{

8
src/flistbox.cpp
View File

@ -180,11 +180,11 @@ void FListBox::setGeometry (int x, int y, std::size_t w, std::size_t h, bool adj
}
//----------------------------------------------------------------------
bool FListBox::setFocus (bool on)
bool FListBox::setFocus (bool enable)
{
FWidget::setFocus(on);
FWidget::setFocus(enable);
if ( on )
if ( enable )
{
if ( getStatusBar() )
{
@ -201,7 +201,7 @@ bool FListBox::setFocus (bool on)
getStatusBar()->clearMessage();
}
return on;
return enable;
}
//----------------------------------------------------------------------

4
src/flistview.cpp
View File

@ -393,9 +393,9 @@ std::size_t FListViewItem::getVisibleLines()
}
//----------------------------------------------------------------------
void FListViewItem::setCheckable (bool on)
void FListViewItem::setCheckable (bool enable)
{
checkable = on;
checkable = enable;
if ( *root )
{

6
src/fmenu.cpp
View File

@ -62,12 +62,12 @@ FMenu::~FMenu() // destructor
// public methods of FMenu
//----------------------------------------------------------------------
bool FMenu::setMenuWidget (bool on)
bool FMenu::setMenuWidget (bool enable)
{
if ( isMenuWidget() == on )
if ( isMenuWidget() == enable )
return true;
return (flags.menu_widget = on);
return (flags.menu_widget = enable);
}
//----------------------------------------------------------------------

16
src/fmenuitem.cpp
View File

@ -81,12 +81,12 @@ FMenuItem::~FMenuItem() // destructor
// public methods of FMenuItem
//----------------------------------------------------------------------
bool FMenuItem::setEnable (bool on)
bool FMenuItem::setEnable (bool enable)
{
FWidget::setEnable(on);
FWidget::setEnable(enable);
auto super = getSuperMenu();
if ( on )
if ( enable )
{
if ( super && isMenuBar(super) )
{
@ -101,15 +101,15 @@ bool FMenuItem::setEnable (bool on)
super->delAccelerator (this);
}
return on;
return enable;
}
//----------------------------------------------------------------------
bool FMenuItem::setFocus (bool on)
bool FMenuItem::setFocus (bool enable)
{
FWidget::setFocus(on);
FWidget::setFocus(enable);
if ( on )
if ( enable )
{
if ( isEnabled() )
{
@ -161,7 +161,7 @@ bool FMenuItem::setFocus (bool on)
getStatusBar()->clearMessage();
}
return on;
return enable;
}
//----------------------------------------------------------------------

20
src/fmouse.cpp
View File

@ -321,11 +321,11 @@ void FMouseGPM::processEvent (struct timeval*)
}
//----------------------------------------------------------------------
bool FMouseGPM::gpmMouse (bool on)
bool FMouseGPM::gpmMouse (bool enable)
{
// activate/deactivate the gpm mouse support
if ( on )
if ( enable )
{
Gpm_Connect conn;
conn.eventMask = uInt16(~0); // Get all including wheel event
@ -351,8 +351,8 @@ bool FMouseGPM::gpmMouse (bool on)
Gpm_Close();
}
gpm_mouse_enabled = on;
return on;
gpm_mouse_enabled = enable;
return enable;
}
//----------------------------------------------------------------------
@ -1246,15 +1246,15 @@ void FMouseControl::setDblclickInterval (const long timeout)
}
//----------------------------------------------------------------------
void FMouseControl::useGpmMouse (bool on)
void FMouseControl::useGpmMouse (bool enable)
{
use_gpm_mouse = on;
use_gpm_mouse = enable;
}
//----------------------------------------------------------------------
void FMouseControl::useXtermMouse (bool on)
void FMouseControl::useXtermMouse (bool enable)
{
use_xterm_mouse = on;
use_xterm_mouse = enable;
}
//----------------------------------------------------------------------
@ -1574,14 +1574,14 @@ FMouse* FMouseControl::getMouseWithEvent()
}
//----------------------------------------------------------------------
void FMouseControl::xtermMouse (bool on)
void FMouseControl::xtermMouse (bool enable)
{
// activate/deactivate the xterm mouse support
if ( ! use_xterm_mouse )
return;
FTermXTerminal::setMouseSupport (on);
FTermXTerminal::setMouseSupport (enable);
}
} // namespace finalcut

6
src/fprogressbar.cpp
View File

@ -77,9 +77,9 @@ void FProgressbar::setGeometry ( int x, int y
}
//----------------------------------------------------------------------
bool FProgressbar::setShadow (bool on)
bool FProgressbar::setShadow (bool enable)
{
if ( on
if ( enable
&& getEncoding() != fc::VT100
&& getEncoding() != fc::ASCII )
{
@ -92,7 +92,7 @@ bool FProgressbar::setShadow (bool on)
setShadowSize(0, 0);
}
return on;
return enable;
}
//----------------------------------------------------------------------

8
src/fscrollview.cpp
View File

@ -273,15 +273,15 @@ void FScrollView::setPrintPos (int x, int y)
}
//----------------------------------------------------------------------
bool FScrollView::setViewportPrint (bool on)
bool FScrollView::setViewportPrint (bool enable)
{
return (use_own_print_area = ! on);
return (use_own_print_area = ! enable);
}
//----------------------------------------------------------------------
bool FScrollView::setBorder (bool on)
bool FScrollView::setBorder (bool enable)
{
return (border = on);
return (border = enable);
}
//----------------------------------------------------------------------

6
src/fstatusbar.cpp
View File

@ -86,12 +86,12 @@ void FStatusKey::setActive()
}
//----------------------------------------------------------------------
bool FStatusKey::setMouseFocus(bool on)
bool FStatusKey::setMouseFocus(bool enable)
{
if ( on == mouse_focus )
if ( mouse_focus == enable )
return true;
return (mouse_focus = on);
return (mouse_focus = enable);
}

24
src/fterm.cpp
View File

@ -140,18 +140,18 @@ void FTerm::setTermType (const char term_name[])
}
//----------------------------------------------------------------------
void FTerm::setInsertCursor (bool on)
void FTerm::setInsertCursor (bool enable)
{
if ( on )
if ( enable )
setInsertCursorStyle();
else
setOverwriteCursorStyle();
}
//----------------------------------------------------------------------
void FTerm::redefineDefaultColors (bool on)
void FTerm::redefineDefaultColors (bool enable)
{
xterm->redefineDefaultColors (on);
xterm->redefineDefaultColors (enable);
}
//----------------------------------------------------------------------
@ -161,18 +161,18 @@ void FTerm::setDblclickInterval (const long timeout)
}
//----------------------------------------------------------------------
bool FTerm::setUTF8 (bool on) // UTF-8 (Unicode)
bool FTerm::setUTF8 (bool enable) // UTF-8 (Unicode)
{
if ( on == data->isUTF8() )
return on;
if ( data->isUTF8() == enable )
return enable;
if ( on )
if ( enable )
data->setUTF8(true);
else
data->setUTF8(false);
#if defined(__linux__)
linux->setUTF8 (on);
linux->setUTF8 (enable);
#endif
return data->isUTF8();
@ -380,16 +380,16 @@ char* FTerm::moveCursor (int xold, int yold, int xnew, int ynew)
}
//----------------------------------------------------------------------
char* FTerm::cursorsVisibility (bool on)
char* FTerm::cursorsVisibility (bool enable)
{
// Hides or shows the input cursor on the terminal
char* visibility_str = nullptr;
if ( on == data->isCursorHidden() )
if ( data->isCursorHidden() == enable )
return 0;
if ( on )
if ( enable )
{
visibility_str = disableCursor();

6
src/ftermios.cpp
View File

@ -155,17 +155,17 @@ void FTermios::unsetCaptureSendCharacters()
}
//----------------------------------------------------------------------
bool FTermios::setRawMode (bool on)
bool FTermios::setRawMode (bool enable)
{
// set + unset flags for raw mode
if ( on == raw_mode )
if ( raw_mode == enable )
return raw_mode;
// Info under: man 3 termios
struct termios t;
tcgetattr (stdin_no, &t);
if ( on )
if ( enable )
{
// local mode
#if DEBUG

8
src/ftermlinux.cpp
View File

@ -100,12 +100,12 @@ char* FTermLinux::setCursorStyle ( fc::linuxConsoleCursorStyle style
}
//----------------------------------------------------------------------
void FTermLinux::setUTF8 (bool on)
void FTermLinux::setUTF8 (bool enable)
{
if ( ! FTerm::isLinuxTerm() )
return;
if ( on )
if ( enable )
FTerm::putstring (ESC "%G");
else
FTerm::putstring (ESC "%@");
@ -803,7 +803,7 @@ inline void FTermLinux::setAttributeMode (uChar data)
}
//----------------------------------------------------------------------
int FTermLinux::setBlinkAsIntensity (bool on)
int FTermLinux::setBlinkAsIntensity (bool enable)
{
// Uses blink-bit as background intensity.
// That permits 16 colors for background
@ -824,7 +824,7 @@ int FTermLinux::setBlinkAsIntensity (bool on)
if ( ioctl(fd_tty, KDENABIO, 0) < 0 )
return -1; // error on KDENABIO
if ( on )
if ( enable )
setAttributeMode (getAttributeMode() & 0xF7); // clear bit 3
else
setAttributeMode (getAttributeMode() | 0x08); // set bit 3

8
src/ftermxterminal.cpp
View File

@ -208,22 +208,22 @@ void FTermXTerminal::setHighlightBackground (const FString& hbg)
}
//----------------------------------------------------------------------
void FTermXTerminal::setMouseSupport (bool on)
void FTermXTerminal::setMouseSupport (bool enable)
{
// activate/deactivate the xterm mouse support
if ( on )
if ( enable )
enableXTermMouse();
else
disableXTermMouse();
}
//----------------------------------------------------------------------
void FTermXTerminal::metaSendsESC (bool on)
void FTermXTerminal::metaSendsESC (bool enable)
{
// activate/deactivate the xterm meta key sends escape prefix
if ( on )
if ( enable )
enableXTermMetaSendsESC();
else
disableXTermMetaSendsESC();

18
src/ftextview.cpp
View File

@ -420,9 +420,9 @@ void FTextView::onMouseDown (FMouseEvent* ev)
try
{
auto _ev = new FMouseEvent (fc::MouseDown_Event, p, tp, b);
FApplication::sendEvent (parent, _ev);
delete _ev;
const auto& _ev = \
std::make_shared<FMouseEvent>(fc::MouseDown_Event, p, tp, b);
FApplication::sendEvent (parent, _ev.get());
}
catch (const std::bad_alloc& ex)
{
@ -449,9 +449,9 @@ void FTextView::onMouseUp (FMouseEvent* ev)
try
{
auto _ev = new FMouseEvent (fc::MouseUp_Event, p, tp, b);
FApplication::sendEvent (parent, _ev);
delete _ev;
const auto& _ev = \
std::make_shared<FMouseEvent>(fc::MouseUp_Event, p, tp, b);
FApplication::sendEvent (parent, _ev.get());
}
catch (const std::bad_alloc& ex)
{
@ -485,9 +485,9 @@ void FTextView::onMouseMove (FMouseEvent* ev)
try
{
auto _ev = new FMouseEvent (fc::MouseMove_Event, p, tp, b);
FApplication::sendEvent (parent, _ev);
delete _ev;
const auto& _ev = \
std::make_shared<FMouseEvent>(fc::MouseMove_Event, p, tp, b);
FApplication::sendEvent (parent, _ev.get());
}
catch (const std::bad_alloc& ex)
{

26
src/ftogglebutton.cpp
View File

@ -97,17 +97,17 @@ void FToggleButton::setGeometry ( int x, int y
}
//----------------------------------------------------------------------
bool FToggleButton::setNoUnderline (bool on)
bool FToggleButton::setNoUnderline (bool enable)
{
return (flags.no_underline = on);
return (flags.no_underline = enable);
}
//----------------------------------------------------------------------
bool FToggleButton::setEnable (bool on)
bool FToggleButton::setEnable (bool enable)
{
FWidget::setEnable(on);
FWidget::setEnable(enable);
if ( on )
if ( enable )
{
setHotkeyAccelerator();
@ -129,15 +129,15 @@ bool FToggleButton::setEnable (bool on)
setBackgroundColor (wc.toggle_button_inactive_bg);
}
return on;
return enable;
}
//----------------------------------------------------------------------
bool FToggleButton::setFocus (bool on)
bool FToggleButton::setFocus (bool enable)
{
FWidget::setFocus(on);
FWidget::setFocus(enable);
if ( on )
if ( enable )
{
if ( isEnabled() )
{
@ -169,15 +169,15 @@ bool FToggleButton::setFocus (bool on)
}
}
return on;
return enable;
}
//----------------------------------------------------------------------
bool FToggleButton::setChecked (bool on)
bool FToggleButton::setChecked (bool enable)
{
if ( checked != on )
if ( checked != enable )
{
checked = on;
checked = enable;
processToggle();
}

4
src/fvterm.cpp
View File

@ -135,11 +135,11 @@ void FVTerm::setTermXY (int x, int y)
}
//----------------------------------------------------------------------
void FVTerm::hideCursor (bool on)
void FVTerm::hideCursor (bool enable)
{
// Hides or shows the input cursor on the terminal
const char* visibility_str = FTerm::cursorsVisibility (on);
const char* visibility_str = FTerm::cursorsVisibility (enable);
if ( visibility_str )
appendOutputBuffer(visibility_str);

14
src/fwidget.cpp
View File

@ -248,24 +248,24 @@ void FWidget::setMainWidget (FWidget* obj)
}
//----------------------------------------------------------------------
bool FWidget::setEnable (bool on)
bool FWidget::setEnable (bool enable)
{
return (flags.active = on);
return (flags.active = enable);
}
//----------------------------------------------------------------------
bool FWidget::setFocus (bool on)
bool FWidget::setFocus (bool enable)
{
if ( ! isEnabled() )
return false;
if ( flags.focus == on )
if ( flags.focus == enable )
return true;
auto last_focus = FWidget::getFocusWidget();
// set widget focus
if ( on && ! flags.focus )
if ( enable && ! flags.focus )
{
int focusable_children = numOfFocusableChildren();
@ -282,7 +282,7 @@ bool FWidget::setFocus (bool on)
auto window = FWindow::getWindowWidget(this);
// set window focus
if ( on && window )
if ( enable && window )
{
if ( ! window->isWindowActive() )
{
@ -295,7 +295,7 @@ bool FWidget::setFocus (bool on)
window->setWindowFocusWidget(this);
}
return (flags.focus = on);
return (flags.focus = enable);
}
//----------------------------------------------------------------------

44
src/fwindow.cpp
View File

@ -84,19 +84,19 @@ FWidget* FWindow::getWindowFocusWidget() const
}
//----------------------------------------------------------------------
bool FWindow::setWindowWidget (bool on)
bool FWindow::setWindowWidget (bool enable)
{
if ( isWindowWidget() == on )
if ( isWindowWidget() == enable )
return true;
flags.window_widget = on;
flags.window_widget = enable;
if ( on )
if ( enable )
setTermOffset();
else
setParentOffset();
return on;
return enable;
}
//----------------------------------------------------------------------
@ -148,16 +148,16 @@ void FWindow::setWindowFocusWidget (const FWidget* obj)
}
//----------------------------------------------------------------------
bool FWindow::activateWindow (bool on)
bool FWindow::activateWindow (bool enable)
{
// activate/deactivate this window
if ( on )
if ( enable )
{
FWidget::setActiveWindow (this);
active_area = getVWin();
}
return (window_active = on);
return (window_active = enable);
}
//----------------------------------------------------------------------
@ -168,31 +168,31 @@ void FWindow::unsetActiveWindow()
}
//----------------------------------------------------------------------
bool FWindow::setResizeable (bool on)
bool FWindow::setResizeable (bool enable)
{
return (flags.resizeable = on);
return (flags.resizeable = enable);
}
//----------------------------------------------------------------------
bool FWindow::setTransparentShadow (bool on)
bool FWindow::setTransparentShadow (bool enable)
{
flags.shadow = flags.trans_shadow = on;
flags.shadow = flags.trans_shadow = enable;
if ( on )
if ( enable )
setShadowSize (2, 1);
else
setShadowSize (0, 0);
return on;
return enable;
}
//----------------------------------------------------------------------
bool FWindow::setShadow (bool on)
bool FWindow::setShadow (bool enable)
{
if ( isMonochron() )
return false;
if ( on )
if ( enable )
{
flags.shadow = true;
flags.trans_shadow = false;
@ -205,18 +205,18 @@ bool FWindow::setShadow (bool on)
setShadowSize (0, 0);
}
return on;
return enable;
}
//----------------------------------------------------------------------
bool FWindow::setAlwaysOnTop (bool on)
bool FWindow::setAlwaysOnTop (bool enable)
{
if ( isAlwaysOnTop() == on )
if ( isAlwaysOnTop() == enable )
return true;
flags.always_on_top = on;
flags.always_on_top = enable;
if ( on )
if ( enable )
{
if ( always_on_top_list )
{
@ -227,7 +227,7 @@ bool FWindow::setAlwaysOnTop (bool on)
else
deleteFromAlwaysOnTopList (this);
return on;
return enable;
}
//----------------------------------------------------------------------

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

@ -239,8 +239,8 @@ inline bool FButton::setUp()
{ return setDown(false); }
//----------------------------------------------------------------------
inline bool FButton::setClickAnimation(bool on)
{ return (click_animation = on); }
inline bool FButton::setClickAnimation(bool enable)
{ return (click_animation = enable); }
//----------------------------------------------------------------------
inline bool FButton::setClickAnimation()

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

@ -409,8 +409,8 @@ inline void FListBox::showNoBrackets (listBoxItems::iterator iter)
{ iter->brackets = fc::NoBrackets; }
//----------------------------------------------------------------------
inline void FListBox::setMultiSelection (bool on)
{ multi_select = on; }
inline void FListBox::setMultiSelection (bool enable)
{ multi_select = enable; }
//----------------------------------------------------------------------
inline void FListBox::setMultiSelection()

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

@ -507,8 +507,8 @@ inline void FListView::hideSortIndicator (bool hide)
{ hide_sort_indicator = hide; }
//----------------------------------------------------------------------
inline bool FListView::setTreeView (bool on)
{ return (tree_view = on); }
inline bool FListView::setTreeView (bool enable)
{ return (tree_view = enable); }
//----------------------------------------------------------------------
inline bool FListView::setTreeView()

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

@ -255,8 +255,8 @@ inline FMenuItem* FMenu::getItem()
{ return &item; }
//----------------------------------------------------------------------
inline bool FMenu::setEnable(bool on)
{ return item.setEnable(on); }
inline bool FMenu::setEnable(bool enable)
{ return item.setEnable(enable); }
//----------------------------------------------------------------------
inline bool FMenu::setEnable()

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

@ -196,8 +196,8 @@ inline void FMessageBox::setTitlebarText (const FString& txt)
{ return FDialog::setText(txt); }
//----------------------------------------------------------------------
inline bool FMessageBox::setCenterText(bool on)
{ return (center_text = on); }
inline bool FMessageBox::setCenterText(bool enable)
{ return (center_text = enable); }
//----------------------------------------------------------------------
inline bool FMessageBox::setCenterText()

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

@ -223,7 +223,7 @@ class FTerm
// Mutators
static void setTermType (const char[]);
static void setInsertCursor (bool on);
static void setInsertCursor (bool);
static void redefineDefaultColors (bool);
static void setDblclickInterval (const long);
static bool setUTF8 (bool);

80
src/include/final/ftermdetection.h
View File

@ -378,84 +378,84 @@ inline bool FTermDetection::hasTerminalDetection()
{ return terminal_detection; }
//----------------------------------------------------------------------
inline void FTermDetection::setXTerminal (bool on)
{ terminal_type.xterm = on; }
inline void FTermDetection::setXTerminal (bool enable)
{ terminal_type.xterm = enable; }
//----------------------------------------------------------------------
inline void FTermDetection::setAnsiTerminal (bool on)
{ terminal_type.ansi = on; }
inline void FTermDetection::setAnsiTerminal (bool enable)
{ terminal_type.ansi = enable; }
//----------------------------------------------------------------------
inline void FTermDetection::setRxvtTerminal (bool on)
{ terminal_type.rxvt = on; }
inline void FTermDetection::setRxvtTerminal (bool enable)
{ terminal_type.rxvt = enable; }
//----------------------------------------------------------------------
inline void FTermDetection::setUrxvtTerminal (bool on)
{ terminal_type.urxvt = on; }
inline void FTermDetection::setUrxvtTerminal (bool enable)
{ terminal_type.urxvt = enable; }
//----------------------------------------------------------------------
inline void FTermDetection::setMltermTerminal (bool on)
{ terminal_type.mlterm = on; }
inline void FTermDetection::setMltermTerminal (bool enable)
{ terminal_type.mlterm = enable; }
//----------------------------------------------------------------------
inline void FTermDetection::setPuttyTerminal (bool on)
{ terminal_type.putty = on; }
inline void FTermDetection::setPuttyTerminal (bool enable)
{ terminal_type.putty = enable; }
//----------------------------------------------------------------------
inline void FTermDetection::setKdeTerminal (bool on)
{ terminal_type.kde_konsole = on; }
inline void FTermDetection::setKdeTerminal (bool enable)
{ terminal_type.kde_konsole = enable; }
//----------------------------------------------------------------------
inline void FTermDetection::setGnomeTerminal (bool on)
{ terminal_type.gnome_terminal = on; }
inline void FTermDetection::setGnomeTerminal (bool enable)
{ terminal_type.gnome_terminal = enable; }
//----------------------------------------------------------------------
inline void FTermDetection::setKtermTerminal (bool on)
{ terminal_type.kterm = on; }
inline void FTermDetection::setKtermTerminal (bool enable)
{ terminal_type.kterm = enable; }
//----------------------------------------------------------------------
inline void FTermDetection::setTeraTerm (bool on)
{ terminal_type.tera_term = on; }
inline void FTermDetection::setTeraTerm (bool enable)
{ terminal_type.tera_term = enable; }
//----------------------------------------------------------------------
inline void FTermDetection::setCygwinTerminal (bool on)
{ terminal_type.cygwin = on; }
inline void FTermDetection::setCygwinTerminal (bool enable)
{ terminal_type.cygwin = enable; }
//----------------------------------------------------------------------
inline void FTermDetection::setMinttyTerm (bool on)
{ terminal_type.mintty = on; }
inline void FTermDetection::setMinttyTerm (bool enable)
{ terminal_type.mintty = enable; }
//----------------------------------------------------------------------
inline void FTermDetection::setLinuxTerm (bool on)
{ terminal_type.linux_con = on; }
inline void FTermDetection::setLinuxTerm (bool enable)
{ terminal_type.linux_con = enable; }
//----------------------------------------------------------------------
inline void FTermDetection::setFreeBSDTerm (bool on)
{ terminal_type.freebsd_con = on; }
inline void FTermDetection::setFreeBSDTerm (bool enable)
{ terminal_type.freebsd_con = enable; }
//----------------------------------------------------------------------
inline void FTermDetection::setNetBSDTerm (bool on)
{ terminal_type.netbsd_con = on; }
inline void FTermDetection::setNetBSDTerm (bool enable)
{ terminal_type.netbsd_con = enable; }
//----------------------------------------------------------------------
inline void FTermDetection::setOpenBSDTerm (bool on)
{ terminal_type.openbsd_con = on; }
inline void FTermDetection::setOpenBSDTerm (bool enable)
{ terminal_type.openbsd_con = enable; }
//----------------------------------------------------------------------
inline void FTermDetection::setSunTerminal (bool on)
{ terminal_type.sun_con = on; }
inline void FTermDetection::setSunTerminal (bool enable)
{ terminal_type.sun_con = enable; }
//----------------------------------------------------------------------
inline void FTermDetection::setScreenTerm (bool on)
{ terminal_type.screen = on; }
inline void FTermDetection::setScreenTerm (bool enable)
{ terminal_type.screen = enable; }
//----------------------------------------------------------------------
inline void FTermDetection::setTmuxTerm (bool on)
{ terminal_type.tmux = on; }
inline void FTermDetection::setTmuxTerm (bool enable)
{ terminal_type.tmux = enable; }
//----------------------------------------------------------------------
inline void FTermDetection::setTerminalDetection (bool on)
{ terminal_detection = on; }
inline void FTermDetection::setTerminalDetection (bool enable)
{ terminal_detection = enable; }
} // namespace finalcut

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

@ -165,8 +165,8 @@ inline void FTermXTerminal::setFTermDetection (FTermDetection* td)
{ term_detection = td; }
//----------------------------------------------------------------------
inline void FTermXTerminal::redefineDefaultColors (bool on)
{ xterm_default_colors = on; }
inline void FTermXTerminal::redefineDefaultColors (bool enable)
{ xterm_default_colors = enable; }
//----------------------------------------------------------------------
inline fc::xtermCursorStyle FTermXTerminal::getCursorStyle()

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

@ -319,7 +319,7 @@ class FVTerm
FTerm::initializationValues& getInitValues();
// Mutators
static void setInsertCursor (bool on);
static void setInsertCursor (bool);
static void setInsertCursor();
static void unsetInsertCursor();
static bool setUTF8 (bool);
@ -669,8 +669,8 @@ inline void FVTerm::setNormal()
}
//----------------------------------------------------------------------
inline bool FVTerm::setBold (bool on)
{ return (next_attribute.attr.bit.bold = on); }
inline bool FVTerm::setBold (bool enable)
{ return (next_attribute.attr.bit.bold = enable); }
//----------------------------------------------------------------------
inline bool FVTerm::setBold()
@ -681,8 +681,8 @@ inline bool FVTerm::unsetBold()
{ return setBold(false); }
//----------------------------------------------------------------------
inline bool FVTerm::setDim (bool on)
{ return (next_attribute.attr.bit.dim = on); }
inline bool FVTerm::setDim (bool enable)
{ return (next_attribute.attr.bit.dim = enable); }
//----------------------------------------------------------------------
inline bool FVTerm::setDim()
@ -693,8 +693,8 @@ inline bool FVTerm::unsetDim()
{ return setDim(false); }
//----------------------------------------------------------------------
inline bool FVTerm::setItalic (bool on)
{ return (next_attribute.attr.bit.italic = on); }
inline bool FVTerm::setItalic (bool enable)
{ return (next_attribute.attr.bit.italic = enable); }
//----------------------------------------------------------------------
inline bool FVTerm::setItalic()
@ -705,8 +705,8 @@ inline bool FVTerm::unsetItalic()
{ return setItalic(false); }
//----------------------------------------------------------------------
inline bool FVTerm::setUnderline (bool on)
{ return (next_attribute.attr.bit.underline = on); }
inline bool FVTerm::setUnderline (bool enable)
{ return (next_attribute.attr.bit.underline = enable); }
//----------------------------------------------------------------------
inline bool FVTerm::setUnderline()
@ -717,8 +717,8 @@ inline bool FVTerm::unsetUnderline()
{ return setUnderline(false); }
//----------------------------------------------------------------------
inline bool FVTerm::setBlink (bool on)
{ return (next_attribute.attr.bit.blink = on); }
inline bool FVTerm::setBlink (bool enable)
{ return (next_attribute.attr.bit.blink = enable); }
//----------------------------------------------------------------------
inline bool FVTerm::setBlink()
@ -729,8 +729,8 @@ inline bool FVTerm::unsetBlink()
{ return setBlink(false); }
//----------------------------------------------------------------------
inline bool FVTerm::setReverse (bool on)
{ return (next_attribute.attr.bit.reverse = on); }
inline bool FVTerm::setReverse (bool enable)
{ return (next_attribute.attr.bit.reverse = enable); }
//----------------------------------------------------------------------
inline bool FVTerm::setReverse()
@ -741,8 +741,8 @@ inline bool FVTerm::unsetReverse()
{ return setReverse(false); }
//----------------------------------------------------------------------
inline bool FVTerm::setStandout (bool on)
{ return (next_attribute.attr.bit.standout = on); }
inline bool FVTerm::setStandout (bool enable)
{ return (next_attribute.attr.bit.standout = enable); }
//----------------------------------------------------------------------
inline bool FVTerm::setStandout()
@ -753,8 +753,8 @@ inline bool FVTerm::unsetStandout()
{ return setStandout(false); }
//----------------------------------------------------------------------
inline bool FVTerm::setInvisible (bool on)
{ return (next_attribute.attr.bit.invisible = on); }
inline bool FVTerm::setInvisible (bool enable)
{ return (next_attribute.attr.bit.invisible = enable); }
//----------------------------------------------------------------------
inline bool FVTerm::setInvisible()
@ -765,8 +765,8 @@ inline bool FVTerm::unsetInvisible()
{ return setInvisible(false); }
//----------------------------------------------------------------------
inline bool FVTerm::setProtected (bool on)
{ return (next_attribute.attr.bit.protect = on); }
inline bool FVTerm::setProtected (bool enable)
{ return (next_attribute.attr.bit.protect = enable); }
//----------------------------------------------------------------------
inline bool FVTerm::setProtected()
@ -777,8 +777,8 @@ inline bool FVTerm::unsetProtected()
{ return setProtected(false); }
//----------------------------------------------------------------------
inline bool FVTerm::setCrossedOut (bool on)
{ return (next_attribute.attr.bit.crossed_out = on); }
inline bool FVTerm::setCrossedOut (bool enable)
{ return (next_attribute.attr.bit.crossed_out = enable); }
//----------------------------------------------------------------------
inline bool FVTerm::setCrossedOut()
@ -789,8 +789,8 @@ inline bool FVTerm::unsetCrossedOut()
{ return setCrossedOut(false); }
//----------------------------------------------------------------------
inline bool FVTerm::setDoubleUnderline (bool on)
{ return (next_attribute.attr.bit.dbl_underline = on); }
inline bool FVTerm::setDoubleUnderline (bool enable)
{ return (next_attribute.attr.bit.dbl_underline = enable); }
//----------------------------------------------------------------------
inline bool FVTerm::setDoubleUnderline()
@ -801,8 +801,8 @@ inline bool FVTerm::unsetDoubleUnderline()
{ return setDoubleUnderline(false); }
//----------------------------------------------------------------------
inline bool FVTerm::setAltCharset (bool on)
{ return (next_attribute.attr.bit.alt_charset = on); }
inline bool FVTerm::setAltCharset (bool enable)
{ return (next_attribute.attr.bit.alt_charset = enable); }
//----------------------------------------------------------------------
inline bool FVTerm::setAltCharset()
@ -813,8 +813,8 @@ inline bool FVTerm::unsetAltCharset()
{ return setAltCharset(false); }
//----------------------------------------------------------------------
inline bool FVTerm::setPCcharset (bool on)
{ return (next_attribute.attr.bit.pc_charset = on); }
inline bool FVTerm::setPCcharset (bool enable)
{ return (next_attribute.attr.bit.pc_charset = enable); }
//----------------------------------------------------------------------
inline bool FVTerm::setPCcharset()
@ -825,8 +825,8 @@ inline bool FVTerm::unsetPCcharset()
{ return setPCcharset(false); }
//----------------------------------------------------------------------
inline bool FVTerm::setTransparent (bool on)
{ return (next_attribute.attr.bit.transparent = on); }
inline bool FVTerm::setTransparent (bool enable)
{ return (next_attribute.attr.bit.transparent = enable); }
//----------------------------------------------------------------------
inline bool FVTerm::setTransparent()
@ -837,8 +837,8 @@ inline bool FVTerm::unsetTransparent()
{ return setTransparent(false); }
//----------------------------------------------------------------------
inline bool FVTerm::setTransShadow (bool on)
{ return (next_attribute.attr.bit.trans_shadow = on); }
inline bool FVTerm::setTransShadow (bool enable)
{ return (next_attribute.attr.bit.trans_shadow = enable); }
//----------------------------------------------------------------------
inline bool FVTerm::setTransShadow()
@ -849,8 +849,8 @@ inline bool FVTerm::unsetTransShadow()
{ return setTransShadow(false); }
//----------------------------------------------------------------------
inline bool FVTerm::setInheritBackground (bool on)
{ return (next_attribute.attr.bit.inherit_bg = on); }
inline bool FVTerm::setInheritBackground (bool enable)
{ return (next_attribute.attr.bit.inherit_bg = enable); }
//----------------------------------------------------------------------
inline bool FVTerm::setInheritBackground()
@ -1049,8 +1049,8 @@ inline void FVTerm::beep()
{ FTerm::beep(); }
//----------------------------------------------------------------------
inline void FVTerm::redefineDefaultColors (bool on)
{ FTerm::redefineDefaultColors(on); }
inline void FVTerm::redefineDefaultColors (bool enable)
{ FTerm::redefineDefaultColors(enable); }
//----------------------------------------------------------------------
inline char* FVTerm::moveCursor (int xold, int yold, int xnew, int ynew)
@ -1085,8 +1085,8 @@ inline FTerm::initializationValues& FVTerm::getInitValues()
{ return FTerm::init_values; }
//----------------------------------------------------------------------
inline void FVTerm::setInsertCursor (bool on)
{ return FTerm::setInsertCursor(on); }
inline void FVTerm::setInsertCursor (bool enable)
{ return FTerm::setInsertCursor(enable); }
//----------------------------------------------------------------------
inline void FVTerm::setInsertCursor()
@ -1097,8 +1097,8 @@ inline void FVTerm::unsetInsertCursor()
{ return FTerm::setInsertCursor(false); }
//----------------------------------------------------------------------
inline bool FVTerm::setUTF8 (bool on)
{ return FTerm::setUTF8(on); }
inline bool FVTerm::setUTF8 (bool enable)
{ return FTerm::setUTF8(enable); }
//----------------------------------------------------------------------
inline bool FVTerm::setUTF8()

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

@ -735,9 +735,9 @@ inline bool FWidget::setDisable()
{ return setEnable(false); }
//----------------------------------------------------------------------
inline bool FWidget::setVisibleCursor (bool on)
inline bool FWidget::setVisibleCursor (bool enable)
{
flags.visible_cursor = ( on ) ? true : (( hideable ) ? false : true);
flags.visible_cursor = ( enable ) ? true : (( hideable ) ? false : true);
return flags.visible_cursor;
}
@ -766,8 +766,8 @@ inline void FWidget::unsetFocusable()
{ flags.focusable = false; }
//----------------------------------------------------------------------
inline bool FWidget::ignorePadding (bool on)
{ return (ignore_padding = on); }
inline bool FWidget::ignorePadding (bool enable)
{ return (ignore_padding = enable); }
//----------------------------------------------------------------------
inline bool FWidget::ignorePadding()