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

Fixed a few minor bugs

This commit is contained in:
Markus Gans 2020-10-04 02:55:15 +02:00
parent c7d6af8b31
commit fb8baf8c5c
31 changed files with 118 additions and 117 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
examples/busy.cpp
View File

@ -89,7 +89,7 @@ Dialog::Dialog (FWidget* parent)
void Dialog::adjustSize()
{
finalcut::FDialog::adjustSize();
int x = int((getDesktopWidth() - getWidth()) / 2);
auto x = int((getDesktopWidth() - getWidth()) / 2);
const int y = 5;
if ( x < 1 )

6
examples/mouse.cpp
View File

@ -428,7 +428,7 @@ void MouseDraw::onClose (finalcut::FCloseEvent* ev)
//----------------------------------------------------------------------
void MouseDraw::draw()
{
const int y_max = int(getHeight());
const auto y_max = int(getHeight());
finalcut::FDialog::draw();
setColor();
@ -463,8 +463,8 @@ void MouseDraw::draw()
//----------------------------------------------------------------------
void MouseDraw::drawBrush (int x, int y, bool swap_color)
{
const int Cols = int(getWidth());
const int Lines = int(getHeight());
const auto Cols = int(getWidth());
const auto Lines = int(getHeight());
if ( x > 10 && x < Cols && y > 2 && y < Lines )
{

8
examples/opti-move.cpp
View File

@ -66,8 +66,8 @@ bool keyPressed()
void term_boundaries (int& x, int& y)
{
// checks and corrects the terminal boundaries
const int term_width = int(app->getDesktopWidth());
const int term_height = int(app->getDesktopHeight());
const auto term_width = int(app->getDesktopWidth());
const auto term_height = int(app->getDesktopHeight());
if ( x < 0 )
x = 0;
@ -230,8 +230,8 @@ int main (int argc, char* argv[])
app = &term_app;
// Get screen dimension
int xmax = int(term_app.getDesktopWidth() - 1);
int ymax = int(term_app.getDesktopHeight() - 1);
auto xmax = int(term_app.getDesktopWidth() - 1);
auto ymax = int(term_app.getDesktopHeight() - 1);
finalcut::FString line{std::size_t(xmax) + 1, '-'};
// Place the cursor in the upper left corner

20
examples/rotozoomer.cpp
View File

@ -129,10 +129,10 @@ void RotoZoomer::draw()
start = system_clock::now();
finalcut::FDialog::draw();
double cx = double(80.0 / 2.0 + (80.0 / 2.0 * std::sin(double(path) / 50.0)));
double cy = double(23.0 + (23.0 * std::cos(double(path) / 50.0)));
double r = double(128.0 + 96.0 * std::cos(double(path) / 10.0));
double a = double(path) / 50.0;
auto cx = double(80.0 / 2.0 + (80.0 / 2.0 * std::sin(double(path) / 50.0)));
auto cy = double(23.0 + (23.0 * std::cos(double(path) / 50.0)));
auto r = double(128.0 + 96.0 * std::cos(double(path) / 10.0));
auto a = double(path) / 50.0;
rotozoomer (cx, cy, r, a);
}
@ -141,12 +141,12 @@ void RotoZoomer::rotozoomer (double cx, double cy, double r, double a)
{
const int Cols = int(getClientWidth());
const int Lines = int(getClientHeight());
int Ax = int(4096.0 * (cx + r * std::cos(a)));
int Ay = int(4096.0 * (cy + r * std::sin(a)));
int Bx = int(4096.0 * (cx + r * std::cos(a + 2.02358)));
int By = int(4096.0 * (cy + r * std::sin(a + 2.02358)));
int Cx = int(4096.0 * (cx + r * std::cos(a - 1.11701)));
int Cy = int(4096.0 * (cy + r * std::sin(a - 1.11701)));
auto Ax = int(4096.0 * (cx + r * std::cos(a)));
auto Ay = int(4096.0 * (cy + r * std::sin(a)));
auto Bx = int(4096.0 * (cx + r * std::cos(a + 2.02358)));
auto By = int(4096.0 * (cy + r * std::sin(a + 2.02358)));
auto Cx = int(4096.0 * (cx + r * std::cos(a - 1.11701)));
auto Cy = int(4096.0 * (cy + r * std::sin(a - 1.11701)));
int dxdx = (Bx - Ax) / 80;
int dydx = (By - Ay) / 80;
int dxdy = (Cx - Ax) / 23;

4
examples/scrollview.cpp
View File

@ -118,8 +118,8 @@ Scrollview::~Scrollview()
void Scrollview::setScrollSize (const FSize& size)
{
FScrollView::setScrollSize (size);
const int width = int(size.getWidth());
const int height = int(size.getHeight());
const auto width = int(size.getWidth());
const auto height = int(size.getHeight());
go_south.setPos (FPoint{width - 5, 1});
go_west.setPos (FPoint{width - 5, height - 1});
go_north.setPos (FPoint{1, height - 1});

4
examples/term-attributes.cpp
View File

@ -177,8 +177,8 @@ void AttribDlg::cb_back()
//----------------------------------------------------------------------
void AttribDlg::adjustSize()
{
int x = int((getDesktopWidth() - getWidth()) / 2);
int y = int((getDesktopHeight() - getHeight()) / 2) + 1;
auto x = int((getDesktopWidth() - getWidth()) / 2);
auto y = int((getDesktopHeight() - getHeight()) / 2) + 1;
if ( x < 1 )
x = 1;

2
examples/transparent.cpp
View File

@ -213,7 +213,7 @@ MainWindow::MainWindow (finalcut::FWidget* parent)
ibg->unsetTransparentShadow();
// Set statusbar text for this window
setStatusbarMessage("Press Q to quit");
FDialog::setStatusbarMessage("Press Q to quit");
unsetTransparentShadow();
activateDialog();

4
examples/treeview.cpp
View File

@ -50,7 +50,7 @@ sInt64 stringToNumber (const finalcut::FString& str)
auto num_string = str.left(str.getLength() - 1);
num_string = num_string.replace(",", "");
num_string = num_string.replace('.', "");
sInt64 number = sInt64(num_string.toLong());
auto number = sInt64(num_string.toLong());
return number;
}
@ -405,7 +405,7 @@ void Treeview::adjustSize()
std::size_t h = getDesktopHeight() - 4;
setHeight (h, false);
int x = int((getDesktopWidth() - getWidth()) / 2);
auto x = int((getDesktopWidth() - getWidth()) / 2);
if ( x < 1 )
x = 1;

2
examples/watch.cpp
View File

@ -192,7 +192,7 @@ void Watch::cb_seconds()
//----------------------------------------------------------------------
void Watch::adjustSize()
{
const int pw = int(getDesktopWidth());
const auto pw = int(getDesktopWidth());
setX (1 + (pw - 22) / 2, false);
setY (3, false);
finalcut::FDialog::adjustSize();

10
examples/windows.cpp
View File

@ -243,7 +243,7 @@ class Window final : public finalcut::FDialog
Window::Window (finalcut::FWidget* parent)
: finalcut::FDialog{parent}
{
setSize ({40, 6});
FDialog::setSize ({40, 6});
// Menu bar item
File.setStatusbarMessage ("File management commands");
@ -355,8 +355,8 @@ void Window::adjustSize()
const std::size_t w = getDesktopWidth();
const std::size_t h = getDesktopHeight();
const int X = int(1 + (w - 40) / 2);
int Y = int(1 + (h - 22) / 2);
const auto X = int(1 + (w - 40) / 2);
auto Y = int(1 + (h - 22) / 2);
const int dx = ( w > 80 ) ? int(w - 80) / 2 : 0;
const int dy = ( h > 24 ) ? int(h - 24) / 2 : 0;
@ -371,7 +371,7 @@ void Window::adjustSize()
{
if ( (*iter)->is_open )
{
const int n = int(std::distance(first, iter));
const auto n = int(std::distance(first, iter));
const int x = dx + 5 + (n % 3) * 25 + int(n / 3) * 3;
const int y = dy + 11 + int(n / 3) * 3;
(*iter)->dgl->setPos (FPoint{x, y});
@ -469,7 +469,7 @@ void Window::cb_createWindows()
win_dat->dgl = win;
win_dat->is_open = true;
win->setText(win_dat->title);
const int n = int(std::distance(first, iter));
const auto n = int(std::distance(first, iter));
const int x = dx + 5 + (n % 3) * 25 + int(n / 3) * 3;
const int y = dy + 11 + int(n / 3) * 3;
win->setGeometry (FPoint{x, y}, FSize{20, 8});

2
src/fapplication.cpp
View File

@ -133,7 +133,7 @@ FWidget* FApplication::getKeyboardWidget()
FApplication::FLogPtr& FApplication::getLog()
{
// Global logger object
static FLogPtr* logger_ptr = new FLogPtr();
static auto logger_ptr = new FLogPtr();
if ( logger_ptr && logger_ptr->get() == nullptr )
{

14
src/fdialog.cpp
View File

@ -226,8 +226,8 @@ void FDialog::setPos (const FPoint& pos, bool)
if ( getTermGeometry().overlap(old_geometry) )
{
FRect restore{};
const std::size_t d_width = std::size_t(std::abs(dx));
const std::size_t d_height = std::size_t(std::abs(dy));
const auto d_width = std::size_t(std::abs(dx));
const auto d_height = std::size_t(std::abs(dy));
// dx > 0 : move left
// dx = 0 : move vertical
@ -354,8 +354,8 @@ void FDialog::setSize (const FSize& size, bool adjust)
// dh = 0 : scale only width
// dh < 0 : scale up height
const std::size_t d_width = std::size_t(dw);
const std::size_t d_height = std::size_t(dh);
const auto d_width = std::size_t(dw);
const auto d_height = std::size_t(dh);
// restoring the non-covered terminal areas
if ( dw > 0 )
@ -492,7 +492,7 @@ void FDialog::onKeyPress (FKeyEvent* ev)
//----------------------------------------------------------------------
void FDialog::onMouseDown (FMouseEvent* ev)
{
const int width = int(getWidth());
const auto width = int(getWidth());
const mouseStates ms =
{
@ -1500,7 +1500,7 @@ bool FDialog::isOutsideTerminal (const FPoint& pos) const
}
//----------------------------------------------------------------------
bool FDialog::isLeftOutside()
bool FDialog::isLeftOutside() const
{
if ( getX() > int(getMaxWidth()) )
return true;
@ -1509,7 +1509,7 @@ bool FDialog::isLeftOutside()
}
//----------------------------------------------------------------------
bool FDialog::isBottomOutside()
bool FDialog::isBottomOutside() const
{
if ( getY() > int(getMaxHeight()) )
return true;

4
src/ffiledialog.cpp
View File

@ -167,7 +167,7 @@ FFileDialog& FFileDialog::operator = (const FFileDialog& fdlg)
//----------------------------------------------------------------------
FString FFileDialog::getSelectedFile() const
{
const uLong n = uLong(filebrowser.currentItem() - 1);
const auto n = uLong(filebrowser.currentItem() - 1);
if ( dir_entries[n].directory )
return FString{""};
@ -823,7 +823,7 @@ void FFileDialog::cb_processRowChanged()
//----------------------------------------------------------------------
void FFileDialog::cb_processClicked()
{
const uLong n = uLong(filebrowser.currentItem() - 1);
const auto n = uLong(filebrowser.currentItem() - 1);
if ( dir_entries[n].directory )
changeDir(dir_entries[n].name);

14
src/fkeyboard.cpp
View File

@ -88,18 +88,18 @@ void FKeyboard::fetchKeyCode()
//----------------------------------------------------------------------
FString FKeyboard::getKeyName (const FKey keynum) const
{
const auto& key = std::find_if
const auto& found_key = std::find_if
(
fc::fkeyname.begin(),
fc::fkeyname.end(),
[&keynum] (fc::FKeyName kn)
[&keynum] (const fc::FKeyName& kn)
{
return (kn.num > 0 && kn.num == keynum);
}
);
if ( key != fc::fkeyname.end() )
return FString{key->string};
if ( found_key != fc::fkeyname.end() )
return FString{found_key->string};
if ( keynum > 32 && keynum < 127 )
return FString{char(keynum)};
@ -296,7 +296,7 @@ inline FKey FKeyboard::getSingleKey()
std::size_t n{};
std::size_t len{1};
const uChar firstchar = uChar(fifo_buf[0]);
const auto firstchar = uChar(fifo_buf[0]);
FKey keycode{};
// Look for a utf-8 character
@ -385,7 +385,7 @@ FKey FKeyboard::UTF8decode (const char utf8[]) const
for (std::size_t i{0}; i < len; ++i)
{
const uChar ch = uChar(utf8[i]);
const auto ch = uChar(utf8[i]);
if ( (ch & 0xc0) == 0x80 )
{
@ -478,7 +478,7 @@ void FKeyboard::parseKeyBuffer()
//----------------------------------------------------------------------
FKey FKeyboard::parseKeyString()
{
const uChar firstchar = uChar(fifo_buf[0]);
const auto firstchar = uChar(fifo_buf[0]);
if ( firstchar == ESC[0] )
{

8
src/flineedit.cpp
View File

@ -752,9 +752,9 @@ void FLineEdit::drawInputField()
// set the cursor to the insert pos.
const auto cursor_pos_column = getCursorColumnPos();
const int xpos = int(2 + cursor_pos_column
- text_offset_column
+ char_width_offset);
const auto xpos = int(2 + cursor_pos_column
- text_offset_column
+ char_width_offset);
setCursorPos ({xpos, 1});
}
@ -802,7 +802,7 @@ inline std::size_t FLineEdit::getCursorColumnPos() const
}
//----------------------------------------------------------------------
inline const FString FLineEdit::getPasswordText() const
inline FString FLineEdit::getPasswordText() const
{
return FString{text.getLength(), fc::Bullet}; // •
}

12
src/flistbox.cpp
View File

@ -692,7 +692,7 @@ inline void FListBox::mapKeyFunctions()
//----------------------------------------------------------------------
void FListBox::processKeyAction (FKeyEvent* ev)
{
const int idx = int(ev->key());
const auto idx = int(ev->key());
if ( key_map.find(idx) != key_map.end() )
{
@ -933,7 +933,7 @@ inline void FListBox::drawListBracketsLine ( int y
printLeftBracket (iter->brackets);
}
const std::size_t first = std::size_t(xoffset);
const auto first = std::size_t(xoffset);
const std::size_t max_width = getWidth() - nf_offset - 4 - b;
const FString element(getColumnSubString (getString(iter), first, max_width));
std::size_t column_width = getColumnWidth(element);
@ -1233,7 +1233,7 @@ void FListBox::wheelUp (int pagesize)
void FListBox::wheelDown (int pagesize)
{
const std::size_t element_count = getCount();
int yoffset_end = int(element_count - getClientHeight());
auto yoffset_end = int(element_count - getClientHeight());
if ( yoffset_end < 0 )
yoffset_end = 0;
@ -1366,7 +1366,7 @@ void FListBox::prevListItem (int distance)
void FListBox::nextListItem (int distance)
{
const std::size_t element_count = getCount();
const int yoffset_end = int(element_count - getClientHeight());
const auto yoffset_end = int(element_count - getClientHeight());
if ( current == element_count )
return;
@ -1407,7 +1407,7 @@ void FListBox::scrollToX (int val)
void FListBox::scrollToY (int val)
{
const std::size_t element_count = getCount();
const int yoffset_end = int(element_count - getClientHeight());
const auto yoffset_end = int(element_count - getClientHeight());
if ( yoffset == val )
return;
@ -1516,7 +1516,7 @@ inline void FListBox::firstPos()
inline void FListBox::lastPos()
{
const std::size_t element_count = getCount();
const int yoffset_end = int(element_count - getClientHeight());
const auto yoffset_end = int(element_count - getClientHeight());
current = element_count;
if ( current > getClientHeight() )

38
src/flistview.cpp
View File

@ -239,7 +239,7 @@ FString FListViewItem::getText (int column) const
return fc::emptyFString::get();
// Convert column position to address offset (index)
const std::size_t index = std::size_t(column - 1);
const auto index = std::size_t(column - 1);
return column_list[index];
}
@ -275,7 +275,7 @@ void FListViewItem::setText (int column, const FString& text)
if ( ! listview->header[index].fixed_width )
{
const int column_width = int(getColumnWidth(text));
const auto column_width = int(getColumnWidth(text));
if ( column_width > listview->header[index].width )
listview->header[index].width = column_width;
@ -705,7 +705,7 @@ fc::text_alignment FListView::getColumnAlignment (int column) const
return fc::alignLeft;
// Convert column position to address offset (index)
const std::size_t index = std::size_t(column - 1);
const auto index = std::size_t(column - 1);
return header[index].alignment;
}
@ -718,7 +718,7 @@ FString FListView::getColumnText (int column) const
return fc::emptyFString::get();
// Convert column position to address offset (index)
const std::size_t index = std::size_t(column - 1);
const auto index = std::size_t(column - 1);
return header[index].name;
}
@ -726,7 +726,7 @@ FString FListView::getColumnText (int column) const
fc::sorting_type FListView::getColumnSortType (int column) const
{
fc::sorting_type type;
const std::size_t col = std::size_t(column);
const auto col = std::size_t(column);
try
{
@ -764,7 +764,7 @@ void FListView::setColumnAlignment (int column, fc::text_alignment align)
return;
// Convert column position to address offset (index)
const std::size_t index = std::size_t(column - 1);
const auto index = std::size_t(column - 1);
header[index].alignment = align;
}
@ -777,11 +777,11 @@ void FListView::setColumnText (int column, const FString& label)
return;
// Convert column position to address offset (index)
std::size_t index = std::size_t(column - 1);
auto index = std::size_t(column - 1);
if ( ! header[index].fixed_width )
{
const int column_width = int(getColumnWidth(label));
const auto column_width = int(getColumnWidth(label));
if ( column_width > header[index].width )
header[index].width = column_width;
@ -1375,7 +1375,7 @@ void FListView::onFocusOut (FFocusEvent*)
//----------------------------------------------------------------------
void FListView::adjustViewport (const int element_count)
{
const int height = int(getClientHeight());
const auto height = int(getClientHeight());
if ( height <= 0 || element_count == 0 )
return;
@ -1511,7 +1511,7 @@ inline void FListView::mapKeyFunctions()
//----------------------------------------------------------------------
void FListView::processKeyAction (FKeyEvent* ev)
{
const int idx = int(ev->key());
const auto idx = int(ev->key());
if ( key_map.find(idx) != key_map.end() )
{
@ -1760,7 +1760,7 @@ void FListView::drawListLine ( const FListViewItem* item
{
static constexpr std::size_t ellipsis_length = 2;
const auto& text = item->column_list[col];
std::size_t width = std::size_t(header[col].width);
auto width = std::size_t(header[col].width);
const std::size_t column_width = getColumnWidth(text);
// Increment the value of col for the column position
// and the next iteration
@ -1989,7 +1989,7 @@ void FListView::drawHeadlineLabel (const headerItems::const_iterator& iter)
static constexpr std::size_t leading_space = 1;
const auto& text = iter->name;
FString txt{" " + text};
const std::size_t width = std::size_t(iter->width);
const auto width = std::size_t(iter->width);
std::size_t column_width = getColumnWidth(txt);
const std::size_t column_max = leading_space + width;
const headerItems::const_iterator first = header.begin();
@ -2169,7 +2169,7 @@ std::size_t FListView::determineLineWidth (FListViewItem* item)
for (auto&& header_item : header)
{
const std::size_t width = std::size_t(header_item.width);
const auto width = std::size_t(header_item.width);
const bool fixed_width = header_item.fixed_width;
if ( ! fixed_width )
@ -2276,7 +2276,7 @@ void FListView::mouseHeaderClicked()
{
static constexpr int leading_space = 1;
const bool has_sort_indicator( column == sort_column );
int click_width = int(getColumnWidth(item.name));
auto click_width = int(getColumnWidth(item.name));
if ( has_sort_indicator )
click_width += 2;
@ -2335,7 +2335,7 @@ void FListView::wheelDown (int pagesize)
if ( itemlist.empty() )
return;
const int element_count = int(getCount());
const auto element_count = int(getCount());
if ( current_iter.getPosition() + 1 == element_count )
return;
@ -2374,7 +2374,7 @@ bool FListView::dragScrollUp (int position_before)
//----------------------------------------------------------------------
bool FListView::dragScrollDown (int position_before)
{
const int element_count = int(getCount());
const auto element_count = int(getCount());
if ( position_before + 1 == element_count )
{
@ -2593,7 +2593,7 @@ inline void FListView::lastPos()
if ( itemlist.empty() )
return;
const int element_count = int(getCount());
const auto element_count = int(getCount());
current_iter += element_count - current_iter.getPosition() - 1;
const int difference = element_count - last_visible_line.getPosition() - 1;
first_visible_line += difference;
@ -2688,7 +2688,7 @@ void FListView::stepForward (int distance)
if ( itemlist.empty() )
return;
const int element_count = int(getCount());
const auto element_count = int(getCount());
if ( current_iter.getPosition() + 1 == element_count )
return;
@ -2769,7 +2769,7 @@ void FListView::scrollToX (int x)
void FListView::scrollToY (int y)
{
const int pagesize = int(getClientHeight()) - 1;
const int element_count = int(getCount());
const auto element_count = int(getCount());
if ( first_visible_line.getPosition() == y )
return;

4
src/fmouse.cpp
View File

@ -563,8 +563,8 @@ void FMouseX11::processEvent (struct timeval* time)
// Parse and interpret the X11 xterm mouse string
const auto& mouse_position = getPos();
const uChar x = uChar(x11_mouse[1] - 0x20);
const uChar y = uChar(x11_mouse[2] - 0x20);
const auto x = uChar(x11_mouse[1] - 0x20);
const auto y = uChar(x11_mouse[2] - 0x20);
const int btn = x11_mouse[0];
setNewPos (x, y);
clearButtonState();

2
src/fobject.cpp
View File

@ -254,7 +254,7 @@ bool FObject::isTimeout (const timeval* time, uInt64 timeout)
diff.tv_usec += 1000000;
}
const uInt64 diff_usec = uInt64((diff.tv_sec * 1000000) + diff.tv_usec);
const auto diff_usec = uInt64((diff.tv_sec * 1000000) + diff.tv_usec);
return ( diff_usec > timeout );
}

2
src/fscrollbar.cpp
View File

@ -411,7 +411,7 @@ void FScrollbar::onTimer (FTimerEvent*)
|| ( scroll_type == FScrollbar::scrollPageForward
&& slider_pos == slider_click_stop_pos ) )
{
const int max_slider_pos = int(bar_length - slider_length);
const auto max_slider_pos = int(bar_length - slider_length);
if ( scroll_type == FScrollbar::scrollPageBackward
&& slider_pos == 0 )

22
src/fscrollview.cpp
View File

@ -139,8 +139,8 @@ void FScrollView::setScrollSize (const FSize& size)
setChildPrintArea (viewport);
}
const int xoffset_end = int(getScrollWidth() - getViewportWidth());
const int yoffset_end = int(getScrollHeight() - getViewportHeight());
const auto xoffset_end = int(getScrollWidth() - getViewportWidth());
const auto yoffset_end = int(getScrollHeight() - getViewportHeight());
setTopPadding (1 - getScrollY());
setLeftPadding (1 - getScrollX());
setBottomPadding (1 - (yoffset_end - getScrollY()));
@ -352,8 +352,8 @@ void FScrollView::scrollTo (int x, int y)
int& yoffset = viewport_geometry.y1_ref();
const int xoffset_before = xoffset;
const int yoffset_before = yoffset;
const int xoffset_end = int(getScrollWidth() - getViewportWidth());
const int yoffset_end = int(getScrollHeight() - getViewportHeight());
const auto xoffset_end = int(getScrollWidth() - getViewportWidth());
const auto yoffset_end = int(getScrollHeight() - getViewportHeight());
const std::size_t save_width = viewport_geometry.getWidth();
const std::size_t save_height = viewport_geometry.getHeight();
x--;
@ -462,7 +462,7 @@ void FScrollView::drawBorder()
//----------------------------------------------------------------------
void FScrollView::onKeyPress (FKeyEvent* ev)
{
const int idx = int(ev->key());
const auto idx = int(ev->key());
if ( key_map.find(idx) != key_map.end() )
{
@ -658,8 +658,8 @@ void FScrollView::copy2area()
const int ay = getTermY() - printarea->offset_top;
const int dx = viewport_geometry.getX();
const int dy = viewport_geometry.getY();
int y_end = int(getViewportHeight());
int x_end = int(getViewportWidth());
auto y_end = int(getViewportHeight());
auto x_end = int(getViewportWidth());
// viewport width does not fit into the printarea
if ( printarea->width <= ax + x_end )
@ -694,7 +694,7 @@ void FScrollView::copy2area()
// private methods of FScrollView
//----------------------------------------------------------------------
inline const FPoint FScrollView::getViewportCursorPos() const
inline FPoint FScrollView::getViewportCursorPos() const
{
const auto& window = FWindow::getWindowWidget(this);
@ -726,8 +726,8 @@ void FScrollView::init()
resetColors();
setGeometry (FPoint{1, 1}, FSize{4, 4});
setMinimumSize (FSize{4, 4});
const int xoffset_end = int(getScrollWidth() - getViewportWidth());
const int yoffset_end = int(getScrollHeight() - getViewportHeight());
const auto xoffset_end = int(getScrollWidth() - getViewportWidth());
const auto yoffset_end = int(getScrollHeight() - getViewportHeight());
nf_offset = FTerm::isNewFont() ? 1 : 0;
setTopPadding (1 - getScrollY());
setLeftPadding (1 - getScrollX());
@ -767,7 +767,7 @@ inline void FScrollView::mapKeyFunctions()
key_map[fc::Fkey_end] = \
[this] ()
{
int yoffset_end = int(getScrollHeight() - getViewportHeight());
auto yoffset_end = int(getScrollHeight() - getViewportHeight());
scrollToY (1 + yoffset_end);
};
}

2
src/fstatusbar.cpp
View File

@ -516,7 +516,7 @@ void FStatusBar::init()
{
const auto& r = getRootWidget();
const std::size_t w = r->getWidth();
const int h = int(r->getHeight());
const auto h = int(r->getHeight());
// initialize geometry values
setGeometry (FPoint{1, h}, FSize{w, 1}, false);
setAlwaysOnTop();

6
src/ftermdetection.cpp
View File

@ -548,7 +548,7 @@ const char* FTermDetection::determineMaxColor (const char current_termtype[])
}
//----------------------------------------------------------------------
const FString FTermDetection::getXTermColorName (FColor color)
FString FTermDetection::getXTermColorName (FColor color)
{
FString color_str{""};
fd_set ifds{};
@ -629,7 +629,7 @@ const char* FTermDetection::parseAnswerbackMsg (const char current_termtype[])
}
//----------------------------------------------------------------------
const FString FTermDetection::getAnswerbackMsg()
FString FTermDetection::getAnswerbackMsg()
{
FString answerback{""};
fd_set ifds{};
@ -746,7 +746,7 @@ int FTermDetection::str2int (const FString& s)
}
//----------------------------------------------------------------------
const FString FTermDetection::getSecDA()
FString FTermDetection::getSecDA()
{
FString sec_da_str{""};

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

@ -200,8 +200,8 @@ class FDialog : public FWindow
void raiseActivateDialog();
void lowerActivateDialog();
bool isOutsideTerminal (const FPoint&) const;
bool isLeftOutside();
bool isBottomOutside();
bool isLeftOutside() const;
bool isBottomOutside() const;
bool isLowerRightResizeCorner (const mouseStates&) const;
void resizeMouseDown (const mouseStates&);
void resizeMouseUpMove (const mouseStates&, bool = false);

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

@ -185,7 +185,7 @@ class FLineEdit : public FWidget
std::size_t printTextField();
std::size_t printPassword();
std::size_t getCursorColumnPos() const;
const FString getPasswordText() const;
FString getPasswordText() const;
bool isPasswordField() const;
offsetPair endPosToOffset (std::size_t);
std::size_t clickPosToCursorPos (std::size_t);

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

@ -157,7 +157,7 @@ class FScrollView : public FWidget
static constexpr int horizontal_border_spacing = 2;
// Accessors
const FPoint getViewportCursorPos() const;
FPoint getViewportCursorPos() const;
// Methods
void init();

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

@ -55,6 +55,7 @@
#undef buttons // from term.h
#endif
#include <array>
#include <string>
#include <utility>
#include <vector>

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

@ -174,12 +174,12 @@ class FTermDetection final
static bool get256colorEnvString();
static const char* termtype_256color_quirks();
static const char* determineMaxColor (const char[]);
static const FString getXTermColorName (FColor);
static FString getXTermColorName (FColor);
static const char* parseAnswerbackMsg (const char[]);
static const FString getAnswerbackMsg();
static FString getAnswerbackMsg();
static const char* parseSecDA (const char[]);
static int str2int (const FString&);
static const FString getSecDA();
static FString getSecDA();
static const char* secDA_Analysis (const char[]);
static const char* secDA_Analysis_0 (const char[]);
static const char* secDA_Analysis_1 (const char[]);

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

@ -149,7 +149,7 @@ class FVTerm
FTermArea*& getVWin();
const FTermArea* getVWin() const;
FPoint getPrintCursor();
static const FChar getAttribute();
static FChar getAttribute();
FTerm& getFTerm() const;
// Mutators
@ -627,7 +627,7 @@ inline const FVTerm::FTermArea* FVTerm::getVWin() const
{ return vwin; }
//----------------------------------------------------------------------
inline const FChar FVTerm::getAttribute()
inline FChar FVTerm::getAttribute()
{ return next_attribute; }
//----------------------------------------------------------------------

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

@ -206,20 +206,20 @@ class FWidget : public FVTerm, public FObject
// Positioning and sizes accessors...
int getX() const;
int getY() const;
const FPoint getPos() const;
FPoint getPos() const;
int getTermX() const;
int getTermY() const;
const FPoint getTermPos() const;
FPoint getTermPos() const;
std::size_t getWidth() const;
std::size_t getHeight() const;
const FSize getSize() const;
FSize getSize() const;
int getTopPadding() const;
int getLeftPadding() const;
int getBottomPadding() const;
int getRightPadding() const;
std::size_t getClientWidth() const;
std::size_t getClientHeight() const;
const FSize getClientSize() const;
FSize getClientSize() const;
std::size_t getMaxWidth() const;
std::size_t getMaxHeight() const;
const FSize& getShadow() const;
@ -332,7 +332,7 @@ class FWidget : public FVTerm, public FObject
virtual void hide();
virtual bool focusFirstChild(); // widget focusing
virtual bool focusLastChild();
const FPoint termToWidgetPos (const FPoint&) const;
FPoint termToWidgetPos (const FPoint&) const;
void print (const FPoint&) override;
virtual void move (const FPoint&);
virtual void drawBorder();
@ -583,7 +583,7 @@ inline FStatusBar* FWidget::getStatusBar()
//----------------------------------------------------------------------
inline FWidget::FWidgetColorsPtr& FWidget::getColorTheme()
{
static FWidgetColorsPtr* color_theme = new FWidgetColorsPtr();
static auto color_theme = new FWidgetColorsPtr();
return *color_theme;
}
@ -616,7 +616,7 @@ inline int FWidget::getY() const // y-position relative to the widget
{ return adjust_wsize.getY(); }
//----------------------------------------------------------------------
inline const FPoint FWidget::getPos() const // position relative to the widget
inline FPoint FWidget::getPos() const // position relative to the widget
{
const FPoint& pos = adjust_wsize.getPos(); // initialize pos
return pos;
@ -631,7 +631,7 @@ inline int FWidget::getTermY() const // y-position on terminal
{ return woffset.getY1() + adjust_wsize.getY(); }
//----------------------------------------------------------------------
inline const FPoint FWidget::getTermPos() const // position on terminal
inline FPoint FWidget::getTermPos() const // position on terminal
{ return {getTermX(), getTermY()}; }
//----------------------------------------------------------------------
@ -643,7 +643,7 @@ inline std::size_t FWidget::getHeight() const
{ return adjust_wsize.getHeight(); }
//----------------------------------------------------------------------
inline const FSize FWidget::getSize() const
inline FSize FWidget::getSize() const
{
const FSize& size = adjust_wsize.getSize(); // initialize size
return size;
@ -674,7 +674,7 @@ inline std::size_t FWidget::getClientHeight() const
{ return wclient_offset.getHeight(); }
//----------------------------------------------------------------------
inline const FSize FWidget::getClientSize() const
inline FSize FWidget::getClientSize() const
{
const FSize& size = wclient_offset.getSize(); // initialize size
return size;
@ -1013,7 +1013,7 @@ inline void FWidget::delAccelerator()
{ delAccelerator(this); }
//----------------------------------------------------------------------
inline const FPoint FWidget::termToWidgetPos (const FPoint& tPos) const
inline FPoint FWidget::termToWidgetPos (const FPoint& tPos) const
{
return { tPos.getX() + 1 - woffset.getX1() - adjust_wsize.getX()
, tPos.getY() + 1 - woffset.getY1() - adjust_wsize.getY() };