[overlay] refine message when log view is empty

some more win stuff too

Author: tstack

.github/workflows/bins.yml

@@ -324,6 +324,13 @@ jobs:
           github-artifact-id: "${{steps.upload-unsigned-artifact.outputs.artifact-id}}"
           wait-for-completion: true
           output-artifact-directory: 'lnav-signed'
+      - name: upload-unsigned-artifact
+        id: upload-unsigned-artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: lnav-signed-windows-${{ matrix.arch }}.zip
+          path: "lnav-signed"
+          if-no-files-found: error
       - name: Upload windows archive
         uses: actions/upload-release-asset@v1.0.2
         if: ${{ inputs.upload_url != '' }}

.signpath/artifact-configurations/default.xml

@@ -9,6 +9,5 @@
                 </for-each>
             </pe-file-set>
         </directory>
-        <authenticode-sign/>
     </zip-file>
 </artifact-configuration>

appveyor.yml

@@ -268,7 +268,9 @@ path_transcoder::to_native(std::string arg)
 
     if (arg[0] == '/') {
         arg.erase(0, 1);
-        arg.insert(1, ":");
+        if (cget(arg, 1).value_or('\0') == '/') {
+            arg.insert(1, ":");
+        }
     }
     if (this->pt_root_name_capitalized.value()) {
         arg[0] = toupper(arg[0]);

src/base/fs_util.cc

@@ -765,6 +765,17 @@ field_overlay_source::list_value_for_overlay(
     this->build_meta_line(lv, value_out, row);
 }
 
+field_overlay_source::lss_state
+field_overlay_source::lss_state::from(logfile_sub_source& lss)
+{
+    return {
+        lss.get_filters().fs_generation,
+        lss.get_min_row_time(),
+        lss.get_max_row_time(),
+        lss.get_min_log_level(),
+    };
+}
+
 bool
 field_overlay_source::list_static_overlay(const listview_curses& lv,
                                           int y,
@@ -773,11 +784,60 @@ field_overlay_source::list_static_overlay(const listview_curses& lv,
 {
     const std::vector<attr_line_t>* lines = nullptr;
     if (this->fos_lss.text_line_count() == 0) {
-        if (this->fos_tss.empty()) {
+        if (this->fos_lss.file_count() > 0) {
+            auto curr_state = lss_state::from(this->fos_lss);
+            if (this->fos_static_lines.empty()
+                || curr_state != this->fos_static_lines_state)
+            {
+                auto msg = lnav::console::user_message::info(
+                    "All log messages are currently hidden");
+                if (curr_state.ls_min_time) {
+                    msg.with_note(attr_line_t("Logs before ")
+                                      .append_quoted(lnav::to_rfc3339_string(
+                                          curr_state.ls_min_time.value()))
+                                      .append(" are not being shown"));
+                }
+                if (curr_state.ls_max_time) {
+                    msg.with_note(attr_line_t("Logs after ")
+                                      .append_quoted(lnav::to_rfc3339_string(
+                                          curr_state.ls_max_time.value()))
+                                      .append(" are not being shown"));
+                }
+                if (curr_state.ls_min_level > log_level_t::LEVEL_UNKNOWN) {
+                    msg.with_note(
+                        attr_line_t("Logs with a level below ")
+                            .append_quoted(
+                                level_names[this->fos_lss.get_min_log_level()])
+                            .append(" are not being shown"));
+                }
+                auto& fs = this->fos_lss.get_filters();
+                for (const auto& filt : fs) {
+                    auto hits = this->fos_lss.get_filtered_count_for(
+                        filt->get_index());
+                    if (filt->get_type() == text_filter::EXCLUDE && hits == 0) {
+                        continue;
+                    }
+                    auto cmd = attr_line_t(":" + filt->to_command());
+                    readline_command_highlighter(cmd, std::nullopt);
+                    msg.with_note(
+                        attr_line_t("Filter ")
+                            .append_quoted(cmd)
+                            .append(" matched ")
+                            .append(lnav::roles::number(fmt::to_string(hits)))
+                            .append(" message(s) "));
+                }
+                this->fos_static_lines = msg.to_attr_line().split_lines();
+                this->fos_static_lines_state = curr_state;
+            }
+
+            lines = &this->fos_static_lines;
+        } else if (this->fos_tss.empty()) {
             lines = lnav::messages::view::no_files();
         } else {
             lines = lnav::messages::view::only_text_files();
         }
+    } else {
+        this->fos_static_lines.clear();
     }
 
     if (lines != nullptr && y < (ssize_t) lines->size()) {

src/field_overlay_source.cc

@@ -42,8 +42,7 @@
 
 class field_overlay_source : public text_overlay_menu {
 public:
-    explicit field_overlay_source(logfile_sub_source& lss,
-                                  text_sub_source& tss)
+    explicit field_overlay_source(logfile_sub_source& lss, text_sub_source& tss)
         : fos_lss(lss), fos_tss(tss), fos_log_helper(lss)
     {
     }
@@ -100,6 +99,28 @@ public:
         bool c_show_applicable_annotations{true};
     };
 
+    struct lss_state {
+        static lss_state from(logfile_sub_source& lss);
+
+        uint32_t ls_filter_generation{0};
+        std::optional<timeval> ls_min_time;
+        std::optional<timeval> ls_max_time;
+        log_level_t ls_min_level{log_level_t::LEVEL_UNKNOWN};
+
+        friend bool operator==(const lss_state& lhs, const lss_state& rhs)
+        {
+            return lhs.ls_filter_generation == rhs.ls_filter_generation
+                && lhs.ls_min_time == rhs.ls_min_time
+                && lhs.ls_max_time == rhs.ls_max_time
+                && lhs.ls_min_level == rhs.ls_min_level;
+        }
+
+        friend bool operator!=(const lss_state& lhs, const lss_state& rhs)
+        {
+            return !(lhs == rhs);
+        }
+    };
+
     std::stack<context> fos_contexts;
     logfile_sub_source& fos_lss;
     text_sub_source& fos_tss;
@@ -109,6 +130,8 @@ public:
     log_data_helper fos_log_helper;
     int fos_known_key_size{0};
     int fos_unknown_key_size{0};
+    std::vector<attr_line_t> fos_static_lines;
+    lss_state fos_static_lines_state;
     std::vector<attr_line_t> fos_lines;
     std::vector<attr_line_t> fos_meta_lines;
 

src/field_overlay_source.hh

@@ -1263,6 +1263,7 @@ filter_stack::delete_filter(const std::string& id)
     }
     if (iter != this->fs_filters.end()) {
         this->fs_filters.erase(iter);
+        this->fs_generation += 1;
         return true;
     }
 
@@ -1328,6 +1329,7 @@ void
 filter_stack::add_filter(const std::shared_ptr<text_filter>& filter)
 {
     this->fs_filters.push_back(filter);
+    this->fs_generation += 1;
 }
 
 void

src/textview_curses.cc

@@ -226,6 +226,7 @@ public:
         while (!this->fs_filters.empty()) {
             this->fs_filters.pop_back();
         }
+        this->fs_generation += 1;
     }
 
     void set_filter_enabled(const std::shared_ptr<text_filter>& filter,
@@ -236,6 +237,7 @@ public:
         } else {
             filter->disable();
         }
+        this->fs_generation += 1;
     }
 
     std::shared_ptr<text_filter> get_filter(const std::string& id);
@@ -246,6 +248,8 @@ public:
 
     void get_enabled_mask(uint32_t& filter_in_mask, uint32_t& filter_out_mask);
 
+    uint32_t fs_generation{0};
+
 private:
     const size_t fs_reserved;
     std::vector<std::shared_ptr<text_filter>> fs_filters;