Bmp File Viewer + extras (#2119)

* BMP initial

* Add vscode debug configuration as a template (#2109)

* usb serial debug interface & usb serial async msg (#2111)

* add serial_debug

* not use OSS

* add path print

* add string print and vec

* clean up

* clean up

* format

* add an async blocking bool

* add an async blocking bool - comment

* protect the unexpected tx

* naming

* remove demo code

* fix bottom-up format, and add auto extend, ..

* bmp write

* Minor additions

* Minor

* overwrite on create

* Tmp

* Basic view - WIP

* debug

* add literal str print in asyncmsg (#2113)

* add literal str print in asyncmsg

* remove debug things

* accept suggestion per gull

* fix documentary

* Fix bug (#2114)

* Disable Back button during Touch Calibration (#2115)

* ADS1100 (#2116)

* WIP

* WIP

* WIP

* Corrected name

* WIP

* WIP

* WIP

* WIP

* Added new calc

* WIP

* WIP

* WIP

* WIP

* WIP

* WIP

* Added debug serial lines

* WIP

* Fixed issue

* Fixed calculation issue

* Added voltage to performance DFU menu

* Added padding function and added voltage to perf menu

* Clean up

* Refactor

* Fixed linting

* Hides voltage if PP does not conatin IC

* WIP showing battery %

* made the percentage a int

* Added % to header

* Removed test UI

* Removed comment

* Added fix for precision too large

* Added fix for precision too large

* Linting

* widget

* auto zoom

* remove debug

* move in screen

* fix math

* remove test code

* fix

* fix compiler warning

* BMP File viewer

* Full screen

* bg instead of noice

* add comment

* Handle some not supported formats.

---------

Co-authored-by: E.T <tamas@eisenberger.hu>
Co-authored-by: sommermorgentraum <24917424+zxkmm@users.noreply.github.com>
Co-authored-by: Mark Thompson <129641948+NotherNgineer@users.noreply.github.com>
Co-authored-by: jLynx <admin@jlynx.net>

firmware/application/CMakeLists.txt

@@ -178,6 +178,7 @@ set(CPPSRC
 	${COMMON}/wm8731.cpp
 	${COMMON}/ads1110.cpp
 	${COMMON}/performance_counter.cpp
+	${COMMON}/bmpfile.cpp
 	app_settings.cpp
 	audio.cpp
 	baseband_api.cpp
@@ -261,6 +262,7 @@ set(CPPSRC
 	ui/ui_textentry.cpp
 	ui/ui_tone_key.cpp
 	ui/ui_transmitter.cpp
+	ui/ui_bmpview.cpp
 	apps/acars_app.cpp
 	apps/ais_app.cpp
 	apps/analog_audio_app.cpp
@@ -283,6 +285,7 @@ set(CPPSRC
 	apps/ui_aprs_rx.cpp
 	apps/ui_aprs_tx.cpp
 	apps/ui_bht_tx.cpp
+	apps/ui_bmp_file_viewer.cpp
 	apps/ui_btle_rx.cpp
 	# apps/ui_coasterp.cpp
 	apps/ui_debug.cpp

firmware/application/apps/ui_bmp_file_viewer.cpp

@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2024 HTotoo
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "ui_bmp_file_viewer.hpp"
+
+extern ui::SystemView* system_view_ptr;
+
+using namespace portapack;
+namespace fs = std::filesystem;
+
+namespace ui {
+
+BMPFileViewer::BMPFileViewer(
+    NavigationView& nav,
+    const std::filesystem::path& path)
+    : nav_{nav},
+      path_{path} {
+    add_children(
+        {&bmp});
+    bmp.set_enter_pass(true);  // pass the enter key to me, so i can exit. this will disable zoom + pos reset
+    set_focusable(true);
+    system_view_ptr->set_app_fullscreen(true);
+}
+
+BMPFileViewer::~BMPFileViewer() {
+    system_view_ptr->set_app_fullscreen(false);
+}
+
+void BMPFileViewer::focus() {
+    bmp.focus();
+}
+
+bool BMPFileViewer::on_key(KeyEvent k) {
+    if (k == KeyEvent::Select) {
+        nav_.pop();
+        return true;
+    }
+    return false;
+}
+
+void BMPFileViewer::paint(Painter&) {
+    bmp.load_bmp(path_);
+}
+
+}  // namespace ui

firmware/application/apps/ui_bmp_file_viewer.hpp

@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2024 HTotoo
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef __UI_BMP_FILE_VIEWER_H__
+#define __UI_BMP_FILE_VIEWER_H__
+
+#include "ui.hpp"
+#include "ui_navigation.hpp"
+#include "ui_painter.hpp"
+#include "ui_styles.hpp"
+#include "ui_widget.hpp"
+#include "file.hpp"
+#include "ui_bmpview.hpp"
+
+namespace ui {
+
+class BMPFileViewer : public View {
+   public:
+    BMPFileViewer(NavigationView& nav, const std::filesystem::path& path);
+    ~BMPFileViewer();
+    bool on_key(KeyEvent key) override;
+    void paint(Painter& painter) override;
+    void focus() override;
+
+   private:
+    NavigationView& nav_;
+    std::filesystem::path path_{};
+    BMPViewer bmp{{0, 0, 240, 320}};
+};
+
+}  // namespace ui
+
+#endif  // __UI_BMP_FILE_VIEWER_H__

firmware/application/apps/ui_fileman.cpp

@@ -29,11 +29,13 @@
 #include "ui_playlist.hpp"
 #include "ui_remote.hpp"
 #include "ui_ss_viewer.hpp"
+#include "ui_bmp_file_viewer.hpp"
 #include "ui_text_editor.hpp"
 #include "ui_iq_trim.hpp"
 #include "string_format.hpp"
 #include "portapack.hpp"
 #include "event_m0.hpp"
+#include "file_path.hpp"
 
 using namespace portapack;
 namespace fs = std::filesystem;
@@ -694,7 +696,12 @@ bool FileManagerView::handle_file_open() {
         nav_.push<ScreenshotViewer>(path);
         return true;
     } else if (path_iequal(bmp_ext, ext)) {
-        nav_.push<SplashViewer>(path);
+        if (path_iequal(current_path, u"/" + splash_dir)) {
+            nav_.push<SplashViewer>(path);  // splash, so load that viewer
+        } else {
+            nav_.push<BMPFileViewer>(path);  // any other bmp
+        }
+
         reload_current(false);
         return true;
     } else if (path_iequal(rem_ext, ext)) {

firmware/application/file.cpp

@@ -70,6 +70,10 @@ File::~File() {
     f_close(&f);
 }
 
+void File::close() {
+    f_close(&f);
+}
+
 File::Result<File::Size> File::read(void* data, Size bytes_to_read) {
     UINT bytes_read = 0;
     const auto result = f_read(&f, data, bytes_to_read, &bytes_read);
@@ -98,6 +102,10 @@ File::Offset File::tell() const {
     return f_tell(&f);
 }
 
+File::Result<bool> File::eof() {
+    return f_eof(&f);
+}
+
 File::Result<File::Offset> File::seek(Offset new_position) {
     /* NOTE: Returns *old* position, not new position */
     const auto old_position = tell();

firmware/application/file.hpp

@@ -332,6 +332,7 @@ class File {
 
     // TODO: Return Result<>.
     Optional<Error> open(const std::filesystem::path& filename, bool read_only = true, bool create = false);
+    void close();
     Optional<Error> append(const std::filesystem::path& filename);
     Optional<Error> create(const std::filesystem::path& filename);
 
@@ -342,6 +343,7 @@ class File {
     Result<Offset> seek(uint64_t Offset);
     Result<Offset> truncate();
     Size size() const;
+    Result<bool> eof();
 
     template <size_t N>
     Result<Size> write(const std::array<uint8_t, N>& data) {

firmware/application/string_format.cpp

@@ -188,7 +188,7 @@ std::string to_string_decimal_padding(float decimal, int8_t precision, const int
     result = to_string_dec_int(integer_part) + "." + to_string_dec_uint(fractional_part, precision, '0');
 
     // Add padding with spaces to meet the length requirement
-    if (result.length() < l) {
+    if (result.length() < (uint32_t)l) {
         int padding_length = l - result.length();
         std::string padding(padding_length, ' ');
         result = padding + result;

firmware/application/ui/ui_bmpview.cpp

@@ -0,0 +1,223 @@
+#include "ui_bmpview.hpp"
+#include "usb_serial_asyncmsg.hpp"
+#include "portapack.hpp"
+
+bool BMPViewer::load_bmp(const std::filesystem::path& file) {
+    if (!bmp.open(file, true)) return false;
+    // calc default zoom level to fit screen, and min / max zoom too
+    auto rect = screen_rect();
+    auto d_height = rect.height();
+    auto d_width = rect.width();
+    auto b_width = bmp.get_width();
+    auto b_height = bmp.get_real_height();
+    // aspects
+    // if image is smaller then our vp
+    auto x_w = d_width / b_width;
+    auto x_h = d_height / b_height;
+    if (x_w < 1 && x_h < 1) {
+        // not zoom in, but zoom out
+        x_w = b_width / d_width;
+        x_h = b_height / d_height;
+        x_w = (127 < x_w) ? 127 : x_w;
+        x_h = (127 < x_h) ? 127 : x_h;
+        zoom_fit = (x_h > x_w) ? -1 * x_h : -1 * x_w;
+    } else {
+        x_w = (127 < x_w) ? 127 : x_w;
+        x_h = (127 < x_h) ? 127 : x_h;
+        zoom_fit = (x_h > x_w) ? x_h : x_w;
+    }
+    if (zoom_fit > max_zoom) zoom_fit = max_zoom;
+    min_zoom = zoom_fit - 3;
+
+    reset_pos();
+    return true;
+}
+
+bool BMPViewer::move_pos(int32_t delta_x, int32_t delta_y) {
+    if (!bmp.is_loaded()) return false;
+
+    auto rect = screen_rect();
+    auto d_height = rect.height();
+    auto d_width = rect.width();
+    auto ocx = cx;  // save old pos
+    auto ocy = cy;
+    // top left protection
+    if (delta_x < 0 && cx <= (uint32_t)(-1 * delta_x))
+        cx = 0;
+    else
+        cx += delta_x;
+
+    if (delta_y < 0 && cy <= (uint32_t)(-1 * delta_y))
+        cy = 0;
+    else
+        cy += delta_y;
+    // right  bottom protection
+    float zt = zoom < 0 ? -1.0f / (float)zoom : (float)zoom;
+    if (zt == 0) zt = 1;
+    if (cy + (uint32_t)(d_height / zt) > bmp.get_real_height()) {
+        cy = (bmp.get_real_height() < (uint32_t)(d_height / zt)) ? 0 : bmp.get_real_height() - (uint32_t)(d_height / zt);
+    }
+    if (cx + (uint32_t)(d_width / zt) > bmp.get_width()) {
+        cx = (bmp.get_width() < (uint32_t)(d_width / zt)) ? 0 : bmp.get_width() - (uint32_t)(d_width / zt);
+    }
+    bool ret = !(cx == ocx && ocy == cy);  // was any change?
+    if (ret) set_dirty();
+    return ret;
+}
+
+void BMPViewer::set_zoom(int8_t new_zoom) {
+    if (!bmp.is_loaded()) return;
+    if (new_zoom > max_zoom) new_zoom = max_zoom;
+    if (new_zoom < min_zoom) new_zoom = min_zoom;
+    if (new_zoom == 0) new_zoom = 1;
+    if (new_zoom == -1) new_zoom = 1;
+    zoom = new_zoom;
+    auto rect = screen_rect();
+    auto d_height = rect.height();
+    auto d_width = rect.width();
+    if (zoom < 0) {
+        mvx = d_width / 3 * (-1.0 * zoom);
+        mvy = d_height / 3 * (-1.0 * zoom);
+    } else {
+        mvx = d_width / zoom / 3;
+        mvy = d_height / zoom / 3;
+    }
+    move_pos(0, 0);  // fix based on zoom, without real move (if not edge case)
+    set_dirty();
+}
+
+// reads a lint from the bmp's bx, by coordinate to the line that's size is cnt. according to zoom
+void BMPViewer::get_line(ui::Color* line, uint32_t bx, uint32_t by, uint32_t cnt) {
+    if (!bmp.is_loaded()) return;
+    uint32_t last_targetx = 65534;
+    for (uint32_t x = 0; x < cnt; x++) {
+        uint32_t targetx = (zoom < 0) ? bx + x * -1 * zoom : bx + x / zoom;  // on zoom out could probably avg the pixels, or apply some smoothing, but this is way faster.
+        if (last_targetx == targetx) {
+            line[x] = line[x - 1];
+            continue;
+        }
+        last_targetx = targetx;
+        if (!bmp.seek(targetx, by)) {
+            line[x] = Color::white();  // can't seek there
+        } else {
+            bmp.read_next_px(line[x], false);
+        }
+    }
+}
+
+void BMPViewer::paint(Painter& painter) {
+    if (!bmp.is_loaded()) {
+        painter.draw_string({48, 24}, ui::Styles::white, "Can't load BMP");
+        return;
+    }
+    // get where i can paint
+    auto rect = screen_rect();
+    auto d_height = rect.height();
+    auto d_width = rect.width();
+
+    uint32_t by = cy;  // we start to read from there
+    uint32_t last_by = 65534;
+    ui::Color* line = new ui::Color[d_width];
+    for (int32_t y = 0; y < d_height; y++) {
+        by = cy + ((zoom < 0) ? y * -1 * zoom : y / (int32_t)zoom);
+        if (by != last_by) get_line(line, cx, by, d_width);
+        last_by = by;
+        portapack::display.draw_pixels({rect.left(), rect.top() + y, d_width, 1}, line, d_width);
+    }
+    delete line;
+}
+
+int8_t BMPViewer::get_zoom() {
+    return zoom;
+}
+
+BMPViewer::BMPViewer(Rect parent_rect)
+    : Widget{parent_rect} {
+    set_focusable(true);
+}
+
+BMPViewer::BMPViewer(Rect parent_rect, const std::filesystem::path& file)
+    : Widget{parent_rect} {
+    set_focusable(true);
+    load_bmp(file);
+}
+
+void BMPViewer::on_focus() {
+    set_highlighted(true);
+}
+
+void BMPViewer::on_blur() {
+    set_dirty();
+}
+
+void BMPViewer::reset_pos() {
+    if (!bmp.is_loaded()) return;
+    cx = 0;
+    cy = 0;
+    set_zoom(zoom_fit);
+    set_dirty();
+}
+
+bool BMPViewer::on_key(const KeyEvent key) {
+    if (!bmp.is_loaded()) return false;
+    if (key == KeyEvent::Up) {
+        return move_pos(0, -1 * mvy);
+    }
+    if (key == KeyEvent::Down) {
+        return move_pos(0, mvy);
+    }
+    if (key == KeyEvent::Left) {
+        return move_pos(-1 * mvx, 0);
+    }
+    if (key == KeyEvent::Right) {
+        return move_pos(mvx, 0);
+    }
+    if (key == KeyEvent::Select) {
+        if (!enter_pass) {
+            reset_pos();
+            return true;
+        }
+    }
+    return false;
+}
+
+bool BMPViewer::on_encoder(EncoderEvent delta) {
+    if (!bmp.is_loaded()) return false;
+    if (delta > 0) {
+        set_zoom(zoom + delta);  // 0 handled in set_zoom
+        return true;
+    }
+    if (delta < 0) {
+        if (zoom == 1)  // not 0, but -1
+            set_zoom(-2);
+        else
+            set_zoom(zoom + delta);  // decrease
+        return true;
+    }
+    return false;
+}
+
+// sets if the enter key should be passed to parent or handled. true = pass it, false = handle as reset pos+zoom
+void BMPViewer::set_enter_pass(bool pass) {
+    enter_pass = pass;
+}
+
+bool BMPViewer::get_enter_pass() {
+    return enter_pass;
+}
+
+bool BMPViewer::on_keyboard(const KeyboardEvent event) {
+    if (!bmp.is_loaded()) return false;
+    if (event == '+') {
+        set_zoom(zoom + 1);
+        return true;
+    }
+    if (event == '-') {
+        if (zoom == 1)  // not 0, but -1
+            set_zoom(-2);
+        else
+            set_zoom(zoom - 1);  // decrease
+        return true;
+    }
+    return false;
+}

firmware/application/ui/ui_bmpview.hpp

@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2024 HTotoo
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef __UIBMPVIEW_H__
+#define __UIBMPVIEW_H__
+
+#include "ui.hpp"
+#include "ui_widget.hpp"
+#include "bmpfile.hpp"
+#include "ui_styles.hpp"
+
+class BMPViewer : public Widget {
+   public:
+    BMPViewer(Rect parent_rect);
+    BMPViewer(Rect parent_rect, const std::filesystem::path& file);
+    BMPViewer(const BMPViewer& other) = delete;
+    BMPViewer& operator=(const BMPViewer& other) = delete;
+
+    bool load_bmp(const std::filesystem::path& file);
+
+    void paint(Painter& painter) override;
+    void on_focus() override;
+    void on_blur() override;
+    bool on_key(const KeyEvent key) override;
+    bool on_encoder(EncoderEvent delta) override;
+    bool on_keyboard(const KeyboardEvent event) override;
+
+    void reset_pos();
+    void set_zoom(int8_t new_zoom);
+    int8_t get_zoom();
+
+    void set_enter_pass(bool pass);
+    bool get_enter_pass();
+
+   private:
+    void get_line(ui::Color* line, uint32_t bx, uint32_t by, uint32_t cnt);
+    bool move_pos(int32_t delta_x, int32_t delta_y);
+    BMPFile bmp{};
+    int8_t zoom = 1;      // positive = zoom in, negative = zoom out 0-invalid 1- no zoom
+    int8_t zoom_fit = 1;  // if this value is set, the image will fit the screen the most
+    int8_t max_zoom = 10;
+    int8_t min_zoom = -20;  // will be calculated on load
+    uint32_t cx = 0;        // current top-left coordinate
+    uint32_t cy = 0;
+    uint32_t mvx = 1;  // how much to move on key
+    uint32_t mvy = 1;
+    bool enter_pass = false;
+};
+
+#endif

firmware/application/ui_navigation.cpp

@@ -945,6 +945,15 @@ void SystemView::paint_overlay() {
     }
 }
 
+void SystemView::set_app_fullscreen(bool fullscreen) {
+    auto parent_rect = screen_rect();
+    Dim status_view_height = (fullscreen) ? 0 : 16;
+    status_view.hidden(fullscreen);
+    navigation_view.set_parent_rect(
+        {{0, status_view_height},
+         {parent_rect.width(), static_cast<Dim>(parent_rect.height() - status_view_height)}});
+}
+
 /* ***********************************************************************/
 
 void BMPView::focus() {

firmware/application/ui_navigation.hpp

@@ -377,6 +377,7 @@ class SystemView : public View {
     Context& context() const override;
     void toggle_overlay();
     void paint_overlay();
+    void set_app_fullscreen(bool fullscreen);
 
     NavigationView* get_navigation_view();
     SystemStatusView* get_status_view();

firmware/application/usb_serial_asyncmsg.hpp

@@ -120,6 +120,14 @@ void UsbSerialAsyncmsg::asyncmsg<uint64_t>(const uint64_t& data) {
     chprintf((BaseSequentialStream*)&SUSBD1, "%s\r\n", to_string_dec_int(data).c_str());
 }
 
+template <>
+void UsbSerialAsyncmsg::asyncmsg<float>(const float& data) {
+    if (!portapack::async_tx_enabled) {
+        return;
+    }
+    chprintf((BaseSequentialStream*)&SUSBD1, "%s\r\n", to_string_decimal(data, 7).c_str());
+}
+
 /// fs things
 
 template <>