iv

@@ -0,0 +1,4 @@

+main

+*.o

+*.exe

+tags

@@ -0,0 +1,8 @@

+main : main.o

+	cc -O2 -o main main.o -lSDL2 -lSDL2_image

+

+main.o : main.c

+	cc -O2 -c -Wall main.c

+

+clean :

+	rm -f main.o main

@@ -0,0 +1,8 @@

+main : main.o

+	x86_64-w64-mingw32-gcc -O2 -mwindows -o main main.o -lmingw32 -lSDL2main -lSDL2 -lSDL2_image

+

+main.o : main.c

+	x86_64-w64-mingw32-gcc -O2 -mwindows -c -Wall main.c

+

+clean :

+	rm -f main.o main

@@ -0,0 +1,10 @@

+iv is an SDL-based image viewer.

+

+Changes on and after 2025-181 are tracked in Git.

+Older change history:

+- 2021-248 and before: main development (up thru v1.2)

+- 2022-233 -t TITLE option, getopts cleanup, smaller zoom steps (v1.3)

+- 2022-294 output coordinates from middle-click (v1.4)

+- 2022-324 better zooming (v1.5)

+- 2022-361 handle multiple files (v1.6)

+- 2023-227 accept SIGTERM to kill/quit (v1.7)

@@ -0,0 +1,9 @@

+[Desktop Entry]

+Type=Application

+Name=iv (Image Viewer)

+GenericName=Image viewer

+Comment=Look into images

+TryExec=iv

+Exec=/usr/local/bin/iv %U

+Terminal=false

+MimeType=image/bmp;image/jpeg;image/png;image/gif;image/svg+xml;image/tiff

@@ -0,0 +1,298 @@

+/* iv/main.c - see README */

+

+#include <libgen.h>

+#include <stdio.h>

+#include <stdlib.h>

+#include <string.h>

+#include <unistd.h>

+

+#include "SDL2/SDL.h"

+#include "SDL2/SDL_image.h"

+

+#define ZSH(a, b) ((a) * powf(2, b))

+#define CLAMP(a, x, b) ((x) < (a) ? (a) : ((x) > (b) ? (b) : (x)))

+#define APS 6

+#define FPS 60

+#define FRAMETIME (1000 / FPS)

+#define DZDS 0.25

+

+/* if cond is true, exit the program as a failure, with msg as the message,

+along with the SDL error, if showsdl is true */

+void cfail(int cond, char* msg, int showsdl) {

+    if (cond) {

+        fprintf(stderr, "Could not %s\n", msg);

+        if (showsdl) {

+            fprintf(stderr, "SDL: %s\n", SDL_GetError());

+        }

+        exit(EXIT_FAILURE);

+    }

+}

+

+int main(int argc, char** argv) {

+    /* load alpha checkers, relative to iv binary (not working directory) */

+    char* tpath = malloc(strlen(argv[0]) + 32);

+    cfail(!tpath, "allocate memory", 0);

+    sprintf(tpath, "%s/alpha_checker.bmp", dirname(argv[0]));

+    SDL_Surface* acs = SDL_LoadBMP(tpath);

+    cfail(!acs, "load alpha checker texture", 1);

+    int cw = acs->w;

+    int ch = acs->h;

+

+    /* require a file argument */

+    if (argc < 2) {

+        fprintf(stderr, "usage: iv -h or iv FILE\n");

+        exit(EXIT_FAILURE);

+    }

+

+    /* setup */

+    SDL_Init(SDL_INIT_VIDEO);

+    atexit(SDL_Quit);

+

+    /* process arguments */

+    int oc;

+    char* ct = NULL;

+    while ((oc = getopt(argc, argv, "ht:")) != -1) {

+        switch (oc) {

+            case 'h':

+                printf(

+                    "iv - image viewer\n"

+                    "\nUsage: iv [-t TITLE] FILES\n"

+                    "\n-t TITLE sets a custom window title\n"

+                    "\nClick and drag to pan\n"

+                    "Scroll to zoom\n"

+                    "Right-click or space key to centre image\n"

+                    "Middle-click to get coordinates at cursor\n"

+                    "Arrow keys to move between images in the list\n"

+                    "version 1.6\n"

+                );

+                exit(EXIT_SUCCESS);

+            case 't':

+                ct = optarg;

+                break;

+            case ':':

+            case '?':

+                cfail(1, "handle invalid options", 0);

+        }

+    }

+

+    /* load images before creating window, to determine window size */

+    cfail(optind >= argc, "find filename in options", 0);

+    int fc = argc - optind;

+    SDL_Surface** isurf = calloc(fc, sizeof (SDL_Surface*));

+    for (int i = 0; i < fc; i++) {

+        char* fname = argv[optind + i];

+        SDL_RWops* ir;

+        if (!strcmp(fname, "-")) {

+            ir = SDL_RWFromFP(stdin, 0);

+        } else {

+            ir = SDL_RWFromFile(fname, "r");

+        }

+        cfail(!ir, "open file", 1);

+        isurf[i] = IMG_Load_RW(ir, 1);

+        cfail(!isurf[i], "load image", 1);

+    }

+    int ci = 0;

+    int iw = isurf[ci]->w;

+    int ih = isurf[ci]->h;

+

+    /* create window and renderer */

+    char* title;

+    if (ct) {

+        title = ct;

+    } else {

+        title = malloc(strlen(argv[optind]) + 32);

+        cfail(!title, "allocate memory", 0);

+        sprintf(title, "iv: %s (%dx%d)", argv[optind], iw, ih);

+    }

+    SDL_Window* window = SDL_CreateWindow(

+        title, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, iw, ih,

+        SDL_WINDOW_RESIZABLE

+    );

+    cfail(!window, "create window", 1);

+    SDL_Renderer* ren = SDL_CreateRenderer(window, -1, 0);

+    cfail(!ren, "create renderer", 1);

+

+    /* make images into textures */

+    SDL_Texture** itex = calloc(fc, sizeof (SDL_Texture*));

+    for (int i = 0; i < fc; i++) {

+        itex[i] = SDL_CreateTextureFromSurface(ren, isurf[i]);

+        cfail(!itex[i], "create texture", 1);

+        SDL_FreeSurface(isurf[i]);

+    }

+    SDL_Texture* act = SDL_CreateTextureFromSurface(ren, acs);

+    cfail(!act, "create surface", 1);

+    SDL_FreeSurface(acs);

+

+    /* background (transparent black) */

+    cfail(SDL_SetRenderDrawColor(ren, 0, 0, 0, 0), "set colour", 1);

+

+    SDL_Event ev;

+    /* time measurements for framerate limitation */

+    uint32_t ta = SDL_GetTicks();

+    uint32_t tb;

+    int r = 1;

+    /* only bother to redraw if an event that requires it is found */

+    int ef;

+    /* window size */

+    int ww, wh;

+    /* zoom level */

+    float zoom = 0;

+    /* pan position (centre of image) */

+    int px = iw / 2;

+    int py = ih / 2;

+    /* keep track of mouse coordinates */

+    int mx = 0;

+    int my = 0;

+

+    while (r) {

+        SDL_GetWindowSize(window, &ww, &wh);

+        ef = 0;

+        while (SDL_PollEvent(&ev)) {

+            switch (ev.type) {

+

+                case SDL_KEYUP:

+                    int iic = 0;

+                    switch (ev.key.keysym.sym) {

+                        /* bring image back into focus when Space is pressed */

+                        case SDLK_SPACE:

+                            px = ww / 2;

+                            py = wh / 2;

+                            ef = 1;

+                            break;

+                        /* exit when Esc is pressed */

+                        case SDLK_ESCAPE:

+                            r = 0;

+                            break;

+                        /* navigate image list with arrow keys */

+                        case SDLK_LEFT:

+                        case SDLK_UP:

+                            if (ci > 0) {

+                                ci--;

+                                iic = 1;

+                            }

+                            break;

+                        case SDLK_RIGHT:

+                        case SDLK_DOWN:

+                            if (ci < fc - 1) {

+                                ci++;

+                                iic = 1;

+                            }

+                            break;

+                    }

+                    if (iic) {

+                        cfail(SDL_QueryTexture(itex[ci], NULL, NULL, &iw, &ih), "query texture", 1);

+                        zoom = 0;

+                        px = iw / 2;

+                        py = ih / 2;

+                        if (!ct) {

+                            free(title);

+                            title = malloc(strlen(argv[optind + ci]) + 32);

+                            cfail(!title, "allocate memory", 0);

+                            sprintf(title, "iv: %s (%dx%d)", argv[optind + ci], iw, ih);

+                            SDL_SetWindowTitle(window, title);

+                        }

+                        ef = 1;

+                    }

+                    break;

+

+                case SDL_MOUSEBUTTONDOWN:

+                    /* output coordinates of cursor in image on middle-click */

+                    if (ev.button.button == 2) {

+                        printf(

+                            "%.0f, %.0f\n",

+                            ZSH((float)ev.button.x - (float)px + ZSH(iw, zoom - 1.0), -zoom),

+                            ZSH((float)ev.button.y - (float)py + ZSH(ih, zoom - 1.0), -zoom)

+                        );

+                        fflush(stdout);

+                    }

+                    /* bring image back into focus on right-click */

+                    if (ev.button.button == 3) {

+                        px = ww / 2;

+                        py = wh / 2;

+                        ef = 1;

+                    }

+                    break;

+

+                case SDL_MOUSEMOTION:

+                    /* pan-dragging if mouse is down */

+                    if (SDL_GetMouseState(NULL, NULL) & SDL_BUTTON(1)) {

+                        int sw = ZSH(iw, zoom - 1.0);

+                        int sh = ZSH(ih, zoom - 1.0);

+                        /* clamp panning to edges of window,

+                        unless zoomed image is bigger than window */

+                        if (2 * sw > ww) {

+                            px += ev.motion.xrel;

+                        } else {

+                            px = CLAMP(sw, px + ev.motion.xrel, ww - sw);

+                        }

+                        if (2 * sh > wh) {

+                            py += ev.motion.yrel;

+                        } else {

+                            py = CLAMP(sh, py + ev.motion.yrel, wh - sh);

+                        }

+                        ef = 1;

+                    }

+                    mx = ev.motion.x;

+                    my = ev.motion.y;

+                    break;

+

+                case SDL_MOUSEWHEEL:

+                    /* scrolling changes zoom */

+                    zoom += DZDS * ev.wheel.y;

+                    px = mx - ZSH((mx - px), DZDS * ev.wheel.y);

+                    py = my - ZSH((my - py), DZDS * ev.wheel.y);

+                    ef = 1;

+                    break;

+

+                case SDL_QUIT:

+                    /* exit upon a quit signal */

+                    r = 0;

+                    break;

+

+                case SDL_WINDOWEVENT:

+                    switch (ev.window.event) {

+                        /* exit when window is closed */

+                        case SDL_WINDOWEVENT_CLOSE:

+                            r = 0;

+                            break;

+                        /* redraw required */

+                        case SDL_WINDOWEVENT_EXPOSED:

+                            ef = 1;

+                            break;

+                    }

+                    break;

+

+            }

+        }

+

+        if (ef) {

+            SDL_GetWindowSize(window, &ww, &wh);

+            /* clear to background colour */

+            cfail(SDL_RenderClear(ren), "clear screen", 1);

+            /* alpha checker background */

+            for (int i = 0; i < ww; i += APS * cw) {

+                for (int j = 0; j < wh; j += APS * ch) {

+                    cfail(SDL_RenderCopy(ren, act, NULL, &(SDL_Rect){

+                        .x = i, .y = j, .w = APS * cw, .h = APS * ch

+                    }), "draw checker background", 1);

+                }

+            }

+            /* render image */

+            cfail(SDL_RenderCopy(ren, itex[ci], NULL, &(SDL_Rect){

+                .x = px - ZSH(iw, zoom - 1.0), .y = py - ZSH(ih, zoom - 1.0),

+                .w = ZSH(iw, zoom), .h = ZSH(ih, zoom)

+            }), "display image", 1);

+            SDL_RenderPresent(ren);

+        }

+

+        /* limit framerate */

+        tb = SDL_GetTicks();

+        if (tb - ta < FRAMETIME) {

+            SDL_Delay(FRAMETIME - (tb - ta));

+        }

+        ta = tb;

+    }

+

+    SDL_DestroyWindow(window);

+    return 0;

+}