implemented panel mode

This should bring us to feature parity with Sahli.

Author: kajott

README.md

@@ -22,15 +22,16 @@ Just run the executable to open the (initially blank) application window. Drag &
 
 Alternatively, run the executable with the full path of an image file as a command-line argument (e.g. by dragging and dropping an image file from the file manager onto the PixelView executable). In this case, PixelView will start up directly in full-screen mode and show the image.
 
-PixelView has three basic view modes:
+PixelView has four basic view modes:
 - **Fit** mode fits the whole image into the screen or window, leaving black bars around it if the aspect ratios don't match. This is the default mode when a new image is opened.
 - **Fill** mode shows the center of the image so that it fills the entire screen, cropping away parts of the image if the aspect ratios don't match.
 - **Free** mode can show any part of the image with any magnification. This mode is automatically entered if the user pans or zooms around in the image.
+- **Panel** mode is only available for *very* wide or tall images. It splits the whole image into multiple strips that are laid out on the screen next to each other, giving a good overview of the whole image.
 
 In addition, there's two scaling modes: normal and integer-only scaling. Normal mode allows any zoom level and will try to display the image with little to no aliasing at all times. In integer scaling mode, only integral scaling factors are allowed, with the following side effects:
 - When zooming in, pixels are shown as squares with an integer size, eliminating any aliasing.
 - The Fit and Fill modes will respect integer scaling too, possibly causing the image to _not_ fill the entire screen. The user can, however, allow some amount of cropping along the edges in order to enable a higher zoom level.
-- Integer scaling is not available for images with non-square pixels, because those features just don't mix.
+- Integer scaling is not available for images with non-square pixels or in panel mode, because those features just don't mix.
 
 For very tall or wide images, PixelView supports an automatic smooth scrolling feature where the visible area of the image is moved by a constant number of pixels with every video frame.
 
@@ -47,6 +48,7 @@ The following keyboard or mouse bindings are available:
 | **Z** or **Numpad Divide** | Switch to a 1:1 zoom mode, or Fit mode if already there.
 | **T** | Switch to 1:1 zoom, or Fill mode if already there. In addition, move the visible part to the upper-left corner of the image. This also switches the view mode to Free.
 | **I** | Toggle integer scaling.
+| **P** | Switch into panel mode, or return to Free mode from there. This does nothing if the image isn't extremely tall or wide.
 | **Numpad Plus** / **Numpad Minus** or **Mouse Wheel** | Zoom into or out of the image. This also switches the view mode to Free.
 | click and hold **Left** or **Middle Mouse Button** | Move the visible area ("panning"). This also switches the view mode to Free.
 | **Cursor Keys** | Move the visible area by a few pixels in one of the four main directions. This also switches the view mode to Free.

src/app.cpp

@@ -278,8 +278,20 @@ int PixelViewApp::run(int argc, char *argv[]) {
             glUseProgram(m_prog);
             glBindTexture(GL_TEXTURE_2D, m_tex);
             glUniform2f(m_locSize, float(m_imgWidth), float(m_imgHeight));
-            glUniform4f(m_locArea, float(m_currentArea.m[0]), float(m_currentArea.m[1]), float(m_currentArea.m[2]), float(m_currentArea.m[3]));
-            glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+            const Area *areas;
+            int count;
+            if ((m_viewMode == vmPanel) && !m_panelAreas.empty()) {
+                areas = m_panelAreas.data();
+                count = int(m_panelAreas.size());
+            } else {
+                areas = &m_currentArea;
+                count = 1;
+            }
+            while (count--) {
+                glUniform4f(m_locArea, float(areas->m[0]), float(areas->m[1]), float(areas->m[2]), float(areas->m[3]));
+                glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+                ++areas;
+            }
         }
 
         // draw the GUI and finish the frame
@@ -327,6 +339,7 @@ void PixelViewApp::handleKeyEvent(int key, int scancode, int action, int mods) {
         case GLFW_KEY_F10:
         case GLFW_KEY_Q: m_active = false; break;
         case GLFW_KEY_I: if (canDoIntegerZoom()) { m_integer = !m_integer; viewCfg("a"); } break;
+        case GLFW_KEY_P: if (m_viewMode == vmPanel) { viewCfg("fsx"); } else { m_viewMode = vmPanel; viewCfg("sx"); } break;
         case GLFW_KEY_S: if (ctrl) { saveConfig(); } else if (isScrolling()) { m_scrollX = m_scrollY = 0.0; } else { startScroll(); } break;
         case GLFW_KEY_T: cycleTopView(); break;
         case GLFW_KEY_Z:
@@ -399,6 +412,7 @@ void PixelViewApp::handleDropEvent(int path_count, const char* paths[]) {
 void PixelViewApp::handleResizeEvent(int width, int height) {
     m_screenWidth  = width;
     m_screenHeight = height;
+    computePanelGeometry();
     updateView();
 }
 
@@ -494,7 +508,11 @@ void PixelViewApp::startScroll(double speed, double dx, double dy) {
         // speed is specified -> set the speed
         m_scrollSpeed = speed;
     }
-    if ((dx != 0.0) || (dy != 0.0)) {
+    if (m_viewMode == vmPanel) {
+        // no scrolling allowed in panel mode
+        m_scrollX = m_scrollY = 0.0;
+        return;
+    } else if ((dx != 0.0) || (dy != 0.0)) {
         // direction is specified -> set the direction
         m_scrollX = dx;
         m_scrollY = dy;
@@ -623,8 +641,9 @@ void PixelViewApp::loadImage() {
 
     // load default view configuration
     m_aspect = 1.0;
-    m_viewMode = vmFit;
+    m_viewMode = m_prevViewMode = vmFit;
     m_x0 = m_y0 = 0.0;
+    computePanelGeometry();
 
     // try to load the configuration file
     char* extStart = &m_fileName[strlen(m_fileName)];
@@ -735,6 +754,13 @@ void PixelViewApp::updateView(bool usePivot, double pivotX, double pivotY) {
         return;  // no image loaded
     }
     clearStatus();
+    if ((m_viewMode == vmPanel) && !canUsePanelMode()) {
+        m_viewMode = vmFree;  // panel mode active, but not allowed: we can't tolerate that!
+    }
+    if ((m_viewMode != vmPanel) && (m_prevViewMode == vmPanel)) {
+        m_animate = false;  // don't allow animations when switching out of panel mode
+    }
+    m_prevViewMode = m_viewMode;
 
     // compute pivot position into relative coordinates
     double pivotRelX = (m_viewWidth  > 1.0) ? ((pivotX - m_x0) / m_viewWidth)  : 0.5;
@@ -744,7 +770,7 @@ void PixelViewApp::updateView(bool usePivot, double pivotX, double pivotY) {
     double rawWidth  = m_imgWidth  * std::max(m_aspect, 1.0);
     double rawHeight = m_imgHeight / std::min(m_aspect, 1.0);
     bool isInt = wantIntegerZoom();
-    bool autofit = (m_viewMode != vmFree);
+    bool autofit = (m_viewMode == vmFit) || (m_viewMode == vmFill);
     #ifdef DEBUG_UPDATE_VIEW
         printf("updateView: mode=%s int=%s imgSize=%dx%d rawSize=%.0fx%.0f screenSize=%.0fx%.0f ",
                (m_viewMode == vmFree) ? "free" : (m_viewMode == vmFill) ? "fill" : "fit ",
@@ -818,8 +844,69 @@ void PixelViewApp::updateView(bool usePivot, double pivotX, double pivotY) {
     #endif
 
     // convert into transform matrix
-    m_targetArea.m[0] =  2.0 * (m_viewWidth      / m_screenWidth);
-    m_targetArea.m[1] = -2.0 * (m_viewHeight     / m_screenHeight);
-    m_targetArea.m[2] =  2.0 * (std::floor(m_x0) / m_screenWidth)  - 1.0;
-    m_targetArea.m[3] = -2.0 * (std::floor(m_y0) / m_screenHeight) + 1.0;
+    setArea(m_targetArea, std::floor(m_x0), std::floor(m_y0), m_viewWidth, m_viewHeight);
+}
+
+void PixelViewApp::setArea(Area& a, double x0, double y0, double vw, double vh) {
+    a.m[0] =  2.0 * (vw / m_screenWidth);
+    a.m[1] = -2.0 * (vh / m_screenHeight);
+    a.m[2] =  2.0 * (x0 / m_screenWidth)  - 1.0;
+    a.m[3] = -2.0 * (y0 / m_screenHeight) + 1.0;
+}
+
+void PixelViewApp::computePanelGeometry() {
+    m_panelAreas.clear();
+
+    // compute raw image size with aspect ratio correction
+    double rawMajor = m_imgWidth * m_aspect;
+    double rawMinor = m_imgHeight;
+    double dispMajor = m_screenWidth;
+    double dispMinor = m_screenHeight;
+
+    // detect panel direction
+    bool wide = (rawMajor * dispMinor) > (rawMinor * dispMajor);
+
+    // turn the coordinates such that it looks as if we're always in wide mode
+    // (this avoids some serious code duplication further down the road)
+    if (!wide) {
+        std::swap(rawMajor,  rawMinor);
+        std::swap(dispMajor, dispMinor);
+    }
+
+    // detect panel count by probing increasing values until the
+    // minor axis doesn't fit the screen any longer
+    int panelCount;
+    double viewMajor, viewMinor;
+    auto updateViewSize = [&] () -> bool {
+        viewMajor = dispMajor * panelCount;
+        viewMinor = viewMajor * rawMinor / rawMajor;
+        return (viewMinor * panelCount) < dispMinor;
+    };
+    panelCount = 1;
+    while (updateViewSize()) { ++panelCount; }
+    if (panelCount <= 2) {
+        #ifndef NDEBUG
+            printf("panel mode: unavailable (%s mode, less than %d panel(s) fit)\n", wide ? "wide" : "tall", panelCount);
+        #endif
+        return;
+    }
+    --panelCount;
+    updateViewSize();
+    #ifndef NDEBUG
+        printf("panel mode: available (%s mode, %d panels of size %.1f)\n", wide ? "wide" : "tall", panelCount, viewMinor);
+    #endif
+
+    // layout the panels
+    double step = (dispMajor - viewMajor) / (panelCount - 1);  // deliberately negative
+    double gap = (dispMinor - panelCount * viewMinor) / (panelCount + 1);
+    m_panelAreas.resize(panelCount);
+    for (int i = 0;  i < panelCount;  ++i) {
+        double posMajor = i * step;
+        double posMinor = gap + i * (viewMinor + gap);
+        if (wide) {
+            setArea(m_panelAreas[i], posMajor, posMinor, viewMajor, viewMinor);
+        } else {
+            setArea(m_panelAreas[i], posMinor, posMajor, viewMinor, viewMajor);
+        }
+    }
 }

src/app.h

@@ -2,7 +2,7 @@
 
 #include <cstdint>
 
-#include <array>
+#include <vector>
 #include <functional>
 
 #define GLFW_INCLUDE_NONE
@@ -49,8 +49,10 @@ class PixelViewApp {
         vmFree = 0,  //!< free pan/zoom
         vmFit,       //!< auto-fit to the screen, with letterbox/pillarbox
         vmFill,      //!< fill the whole screen, truncate if necessary
+        vmPanel,     //!< panel mode: split into strips
     };
     ViewMode m_viewMode = vmFit;
+    ViewMode m_prevViewMode = vmFit;
     bool m_integer = false;
     double m_maxCrop = 0.0;
     double m_aspect = 1.0;
@@ -72,9 +74,11 @@ class PixelViewApp {
     struct Area { double m[4]; };
     Area m_currentArea = {{2.0, -2.0, -1.0, 1.0}};
     Area m_targetArea = {{2.0, -2.0, -1.0, 1.0}};
+    std::vector <Area> m_panelAreas;
     inline bool isZoomed() const { return (m_zoom < 0.9999) || (m_zoom > 1.0001); }
     inline bool isSquarePixels() const { return (m_aspect >= 0.9999) && (m_aspect <= 1.0001); }
-    inline bool canDoIntegerZoom() const { return isSquarePixels(); }
+    inline bool canDoIntegerZoom() const { return isSquarePixels() && (m_viewMode != vmPanel); }
+    inline bool canUsePanelMode() const { return !m_panelAreas.empty(); }
     inline bool wantIntegerZoom() const { return m_integer && canDoIntegerZoom(); }
     inline bool isScrolling() const { return (m_scrollX != 0.0) || (m_scrollY != 0.0); }
     struct WindowGeometry {
@@ -93,6 +97,8 @@ class PixelViewApp {
     bool saveConfig(const char* filename);
     void unloadImage();
     void updateView(bool usePivot, double pivotX, double pivotY);
+    void setArea(Area& a, double x0, double y0, double vw, double vh);
+    void computePanelGeometry();
     inline void updateView(bool usePivot=true) { updateView(usePivot, m_screenWidth * 0.5, m_screenHeight * 0.5); }
     void cursorPan(double dx, double dy, int mods);
     void cycleViewMode(bool with1x);
@@ -114,6 +120,7 @@ class PixelViewApp {
     // "universal" view configuration helper function to save some typing;
     // string-controlled:
     // - 'f' = set view mode to "free pan/zoom" (vmFree)
+    // - 'p' = enter panel mode (view mode = vmPanel)
     // - 'a' = enable animation
     // - 'x' = disable animation
     // - 's' = stop scrolling

src/app_cfgfile.cpp

@@ -84,10 +84,11 @@ void PixelViewApp::loadConfig(const char* filename) {
 
         // parse the actual line
         if (!strcmp(key, "mode")) {
-                 if (!strcmp(value, "free")) { m_viewMode = vmFree; }
-            else if (!strcmp(value, "fit"))  { m_viewMode = vmFit;  }
-            else if (!strcmp(value, "fill")) { m_viewMode = vmFill; }
-            else                             { invalidValue();      }
+                 if (!strcmp(value, "free"))  { m_viewMode = vmFree;  }
+            else if (!strcmp(value, "fit"))   { m_viewMode = vmFit;   }
+            else if (!strcmp(value, "fill"))  { m_viewMode = vmFill;  }
+            else if (!strcmp(value, "panel")) { m_viewMode = vmPanel; }
+            else                              { invalidValue();       }
         }
         if (!strcmp(key, "integer")) {
                  if (!strcmp(value, "yes") || !strcmp(value, "true")  || !strcmp(value, "on")  || (isFloat && (fval != 0.0))) { m_integer = true;  }
@@ -136,7 +137,7 @@ bool PixelViewApp::saveConfig(const char* filename) {
     if ((m_maxCrop > 0.0) || ((m_viewMode == vmFill) && m_integer)) {
         fprintf(f, "maxcrop %.0f\n", m_maxCrop * 100.0);
     }
-    fprintf(f, "mode %s\n", (m_viewMode == vmFree) ? "free" : (m_viewMode == vmFill) ? "fill" : "fit");
+    fprintf(f, "mode %s\n", (m_viewMode == vmFree) ? "free" : (m_viewMode == vmPanel) ? "panel" : (m_viewMode == vmFill) ? "fill" : "fit");
     if (canDoIntegerZoom()) {
         fprintf(f, "integer %s\n", m_integer ? "yes" : "no");
     }

src/app_ui.cpp

@@ -60,19 +60,22 @@ void PixelViewApp::uiConfigWindow() {
     if (ImGui::Begin("Display Configuration", &m_showConfig, ImGuiWindowFlags_NoNavInputs)) {
         ImGui::AlignTextToFramePadding();
         ImGui::TextUnformatted("view mode:");
-        ImGui::SameLine(); if (ImGui::RadioButton("free",          (m_viewMode == vmFree))) { viewCfg("f"); }
-        ImGui::SameLine(); if (ImGui::RadioButton("fit to screen", (m_viewMode == vmFit)))  { m_viewMode = vmFit;  viewCfg("sa"); }
-        ImGui::SameLine(); if (ImGui::RadioButton("fill screen",   (m_viewMode == vmFill))) { m_viewMode = vmFill; viewCfg("sa"); }
+        ImGui::SameLine(); if (ImGui::RadioButton("free",          (m_viewMode == vmFree)))  { viewCfg("f"); }
+        ImGui::SameLine(); if (ImGui::RadioButton("fit to screen", (m_viewMode == vmFit)))   { m_viewMode = vmFit;   viewCfg("sa"); }
+        ImGui::SameLine(); if (ImGui::RadioButton("fill screen",   (m_viewMode == vmFill)))  { m_viewMode = vmFill;  viewCfg("sa"); }
+        ImGui::SameLine(); ImGui::BeginDisabled(!canUsePanelMode());
+                           if (ImGui::RadioButton("panel",         (m_viewMode == vmPanel))) { m_viewMode = vmPanel; viewCfg("sx"); }
+                           ImGui::EndDisabled();
 
         ImGui::BeginDisabled(!canDoIntegerZoom());
         b = m_integer && canDoIntegerZoom();
         if (ImGui::Checkbox("integer scaling", &b)) { m_integer = b; viewCfg("sa"); }
         ImGui::EndDisabled();
 
         f = float(m_aspect);
-        if (ImGui::SliderFloat("pixel aspect", &f, 0.5f, 2.0f, "%.3f", ImGuiSliderFlags_Logarithmic)) { m_aspect = f; viewCfg("sx"); }
+        if (ImGui::SliderFloat("pixel aspect", &f, 0.5f, 2.0f, "%.3f", ImGuiSliderFlags_Logarithmic)) { m_aspect = f; computePanelGeometry(); viewCfg("sx"); }
         if (ImGui::BeginPopupContextItem()) {
-            if (ImGui::Selectable("reset to square pixels")) { m_aspect = 1.0; viewCfg("sa"); }
+            if (ImGui::Selectable("reset to square pixels")) { m_aspect = 1.0; computePanelGeometry(); viewCfg("sa"); }
             ImGui::EndPopup();
         }
 
@@ -81,14 +84,16 @@ void PixelViewApp::uiConfigWindow() {
         if (ImGui::SliderInt("max. crop", &i, 0, 50, "%d%%")) { m_maxCrop = 0.01 * i; viewCfg("sa"); }
         ImGui::EndDisabled();
 
+        ImGui::BeginDisabled((m_viewMode == vmPanel));
         f = float(m_zoom);
         if (ImGui::SliderFloat("zoom factor", &f, float(std::max(m_minZoom, 1.0/16)), 16.0f, "%.02fx", ImGuiSliderFlags_Logarithmic)) {
             m_zoom = f;
             viewCfg("fsx");
         }
+        ImGui::EndDisabled();
 
         auto posSlider = [&] (double &pos, double minPos, const char* title) {
-            bool centered = (minPos >= 0.0);
+            bool centered = (minPos >= 0.0) || (m_viewMode == vmPanel);
             float percent = std::min(100.0f, std::max(0.0f, float(centered ? 50.0 : (100.0 * (pos / minPos)))));
             ImGui::BeginDisabled(centered);
             if (ImGui::SliderFloat(title, &percent, 0.0f, 100.0f, "%.2f%%")) {