bool on -> bool enable

examples/calculator.cpp

@@ -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 )
   {

src/fbutton.cpp

@@ -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;
 }
 
 //----------------------------------------------------------------------

src/fbuttongroup.cpp

@@ -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;
 }
 
 //----------------------------------------------------------------------

src/fdialog.cpp

@@ -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;
 }
 
 //----------------------------------------------------------------------

src/ffiledialog.cpp

@@ -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;

src/fkeyboard.cpp

@@ -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;
 

src/flabel.cpp

@@ -180,34 +180,34 @@ void FLabel::setAlignment (fc::text_alignment align)
 }
 
 //----------------------------------------------------------------------
-bool FLabel::setEmphasis (bool on)
+bool FLabel::setEmphasis (bool enable)
 {
-  if ( emphasis != on )
+  if ( emphasis != enable )
-    emphasis = on;
+    emphasis = enable;
 
-  return on;
+  return enable;
 }
 
 //----------------------------------------------------------------------
-bool FLabel::setReverseMode (bool on)
+bool FLabel::setReverseMode (bool enable)
 {
-  if ( reverse_mode != on )
+  if ( reverse_mode != enable )
-    reverse_mode = on;
+    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;
 }
 
 //----------------------------------------------------------------------

src/flineedit.cpp

@@ -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 )
   {

src/flistbox.cpp

@@ -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;
 }
 
 //----------------------------------------------------------------------

src/flistview.cpp

@@ -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 )
   {

src/fmenu.cpp

@@ -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);
 }
 
 //----------------------------------------------------------------------

src/fmenuitem.cpp

@@ -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;
 }
 
 //----------------------------------------------------------------------

src/fmouse.cpp

@@ -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;
+  gpm_mouse_enabled = enable;
-  return on;
+  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

src/fprogressbar.cpp

@@ -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;
 }
 
 //----------------------------------------------------------------------

src/fscrollview.cpp

@@ -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);
 }
 
 //----------------------------------------------------------------------

src/fstatusbar.cpp

@@ -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);
 }
 
 

src/fterm.cpp

@@ -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() )
+  if ( data->isUTF8() == enable )
-    return on;
+    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();
 

src/ftermios.cpp

@@ -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

src/ftermlinux.cpp

@@ -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

src/ftermxterminal.cpp

@@ -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();

src/ftextview.cpp

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

src/ftogglebutton.cpp

@@ -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();
   }
 

src/fvterm.cpp

@@ -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);

src/fwidget.cpp

@@ -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);
 }
 
 //----------------------------------------------------------------------

src/fwindow.cpp

@@ -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;
 }
 
 //----------------------------------------------------------------------

src/include/final/fbutton.h

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

src/include/final/flistbox.h

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

src/include/final/flistview.h

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

src/include/final/fmenu.h

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

src/include/final/fmessagebox.h

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

src/include/final/fterm.h

@@ -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);

src/include/final/ftermdetection.h

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

src/include/final/ftermxterminal.h

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

src/include/final/fvterm.h

@@ -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)
+inline bool FVTerm::setBold (bool enable)
-{ return (next_attribute.attr.bit.bold = on); }
+{ 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)
+inline bool FVTerm::setDim (bool enable)
-{ return (next_attribute.attr.bit.dim = on); }
+{ 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)
+inline bool FVTerm::setItalic (bool enable)
-{ return (next_attribute.attr.bit.italic = on); }
+{ 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)
+inline bool FVTerm::setUnderline (bool enable)
-{ return (next_attribute.attr.bit.underline = on); }
+{ 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)
+inline bool FVTerm::setBlink (bool enable)
-{ return (next_attribute.attr.bit.blink = on); }
+{ 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)
+inline bool FVTerm::setReverse (bool enable)
-{ return (next_attribute.attr.bit.reverse = on); }
+{ 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)
+inline bool FVTerm::setStandout (bool enable)
-{ return (next_attribute.attr.bit.standout = on); }
+{ 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)
+inline bool FVTerm::setInvisible (bool enable)
-{ return (next_attribute.attr.bit.invisible = on); }
+{ 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)
+inline bool FVTerm::setProtected (bool enable)
-{ return (next_attribute.attr.bit.protect = on); }
+{ 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)
+inline bool FVTerm::setCrossedOut (bool enable)
-{ return (next_attribute.attr.bit.crossed_out = on); }
+{ 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)
+inline bool FVTerm::setDoubleUnderline (bool enable)
-{ return (next_attribute.attr.bit.dbl_underline = on); }
+{ 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)
+inline bool FVTerm::setAltCharset (bool enable)
-{ return (next_attribute.attr.bit.alt_charset = on); }
+{ 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)
+inline bool FVTerm::setPCcharset (bool enable)
-{ return (next_attribute.attr.bit.pc_charset = on); }
+{ 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)
+inline bool FVTerm::setTransparent (bool enable)
-{ return (next_attribute.attr.bit.transparent = on); }
+{ 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)
+inline bool FVTerm::setTransShadow (bool enable)
-{ return (next_attribute.attr.bit.trans_shadow = on); }
+{ 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)
+inline bool FVTerm::setInheritBackground (bool enable)
-{ return (next_attribute.attr.bit.inherit_bg = on); }
+{ 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)
+inline void FVTerm::redefineDefaultColors (bool enable)
-{ FTerm::redefineDefaultColors(on); }
+{ 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)
+inline void FVTerm::setInsertCursor (bool enable)
-{ return FTerm::setInsertCursor(on); }
+{ 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)
+inline bool FVTerm::setUTF8 (bool enable)
-{ return FTerm::setUTF8(on); }
+{ return FTerm::setUTF8(enable); }
 
 //----------------------------------------------------------------------
 inline bool FVTerm::setUTF8()

src/include/final/fwidget.h

@@ -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)
+inline bool FWidget::ignorePadding (bool enable)
-{ return (ignore_padding = on); }
+{ return (ignore_padding = enable); }
 
 //----------------------------------------------------------------------
 inline bool FWidget::ignorePadding()