Initial commit (upstream 1.3.4)

1 files changed, 1292 insertions, 0 deletions

diff --git a/src/imlib.c b/src/imlib.c
new file mode 100644
index 0000000..fc4dcf0
--- /dev/null
+++ b/src/imlib.c
@@ -0,0 +1,1292 @@
+/* imlib.c
+
+Copyright (C) 1999-2003 Tom Gilbert.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies of the Software and its documentation and acknowledgment shall be
+given in the documentation and software packages that this Software was
+used.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+*/
+
+#include "feh.h"
+#include "filelist.h"
+#include "winwidget.h"
+#include "options.h"
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <jpeglib.h>
+
+#include "transupp.h"
+
+Display *disp = NULL;
+Visual *vis = NULL;
+Screen *scr = NULL;
+Colormap cm;
+int depth;
+Atom wmDeleteWindow;
+XContext xid_context = 0;
+Window root = 0;
+
+/* Xinerama support */
+#ifdef HAVE_LIBXINERAMA
+XineramaScreenInfo *xinerama_screens = NULL;
+int xinerama_screen;
+int num_xinerama_screens;
+#endif /* HAVE_LIBXINERAMA */
+
+#ifdef HAVE_LIBXINERAMA
+void
+init_xinerama(void)
+{
+  if (opt.xinerama && XineramaIsActive(disp)) {
+    int major, minor;
+    xinerama_screen = 0;
+    XineramaQueryVersion(disp, &major, &minor);
+    xinerama_screens = XineramaQueryScreens(disp, &num_xinerama_screens);
+  }
+}
+#endif /* HAVE_LIBXINERAMA */
+
+void
+init_x_and_imlib(void)
+{
+   D_ENTER(4);
+
+   disp = XOpenDisplay(NULL);
+   if (!disp)
+      eprintf("Can't open X display. It *is* running, yeah?");
+   vis = DefaultVisual(disp, DefaultScreen(disp));
+   depth = DefaultDepth(disp, DefaultScreen(disp));
+   cm = DefaultColormap(disp, DefaultScreen(disp));
+   root = RootWindow(disp, DefaultScreen(disp));
+   scr = ScreenOfDisplay(disp, DefaultScreen(disp));
+   xid_context = XUniqueContext();
+
+#ifdef HAVE_LIBXINERAMA
+   init_xinerama();
+#endif /* HAVE_LIBXINERAMA */
+
+   imlib_context_set_display(disp);
+   imlib_context_set_visual(vis);
+   imlib_context_set_colormap(cm);
+   imlib_context_set_color_modifier(NULL);
+   imlib_context_set_progress_function(NULL);
+   imlib_context_set_operation(IMLIB_OP_COPY);
+   wmDeleteWindow = XInternAtom(disp, "WM_DELETE_WINDOW", False);
+
+   /* Initialise random numbers */
+   srand(getpid() * time(NULL) % ((unsigned int) -1));
+
+   /* Set up the font stuff */
+   imlib_add_path_to_font_path(".");
+   imlib_add_path_to_font_path(PREFIX "/share/feh/fonts");
+   imlib_add_path_to_font_path("./ttfonts");
+
+   D_RETURN_(4);
+}
+
+int
+feh_load_image_char(Imlib_Image * im, char *filename)
+{
+   feh_file *file;
+   int i;
+
+   D_ENTER(4);
+   file = feh_file_new(filename);
+   i = feh_load_image(im, file);
+   feh_file_free(file);
+   D_RETURN(4, i);
+}
+
+int
+feh_load_image(Imlib_Image * im, feh_file * file)
+{
+   Imlib_Load_Error err;
+
+   D_ENTER(4);
+   D(3, ("filename is %s, image is %p\n", file->filename, im));
+
+   if (!file || !file->filename)
+      D_RETURN(4, 0);
+
+   /* Handle URLs */
+   if ((!strncmp(file->filename, "http://", 7)) ||
+       (!strncmp(file->filename, "https://", 8)) ||
+       (!strncmp(file->filename, "ftp://", 6)))
+   {
+      char *tmpname = NULL;
+      char *tempcpy;
+
+      tmpname = feh_http_load_image(file->filename);
+      if (tmpname == NULL)
+         D_RETURN(4, 0);
+      *im = imlib_load_image_with_error_return(tmpname, &err);
+      if (im)
+      {
+         /* load the info now, in case it's needed after we delete the
+            temporary image file */
+         tempcpy = file->filename;
+         file->filename = tmpname;
+         feh_file_info_load(file, *im);
+         file->filename = tempcpy;
+      }
+      if ((opt.slideshow) && (opt.reload == 0))
+      {
+         /* Http, no reload, slideshow. Let's keep this image on hand... */
+         free(file->filename);
+         file->filename = estrdup(tmpname);
+      }
+      else
+      {
+         /* Don't cache the image if we're doing reload + http (webcams etc) */
+         if (!opt.keep_http)
+            unlink(tmpname);
+      }
+      if (!opt.keep_http)
+         add_file_to_rm_filelist(tmpname);
+      free(tmpname);
+   }
+   else
+   {
+      *im = imlib_load_image_with_error_return(file->filename, &err);
+   }
+
+   if ((err) || (!im))
+   {
+      if (opt.verbose && !opt.quiet)
+      {
+         fprintf(stdout, "\n");
+         reset_output = 1;
+      }
+      /* Check error code */
+      switch (err)
+      {
+        case IMLIB_LOAD_ERROR_FILE_DOES_NOT_EXIST:
+           if (!opt.quiet)
+              weprintf("%s - File does not exist", file->filename);
+           break;
+        case IMLIB_LOAD_ERROR_FILE_IS_DIRECTORY:
+           if (!opt.quiet)
+              weprintf("%s - Directory specified for image filename",
+                       file->filename);
+           break;
+        case IMLIB_LOAD_ERROR_PERMISSION_DENIED_TO_READ:
+           if (!opt.quiet)
+              weprintf("%s - No read access to directory", file->filename);
+           break;
+        case IMLIB_LOAD_ERROR_UNKNOWN:
+        case IMLIB_LOAD_ERROR_NO_LOADER_FOR_FILE_FORMAT:
+           if (!opt.quiet)
+              weprintf("%s - No Imlib2 loader for that file format",
+                       file->filename);
+           break;
+        case IMLIB_LOAD_ERROR_PATH_TOO_LONG:
+           if (!opt.quiet)
+              weprintf("%s - Path specified is too long", file->filename);
+           break;
+        case IMLIB_LOAD_ERROR_PATH_COMPONENT_NON_EXISTANT:
+           if (!opt.quiet)
+              weprintf("%s - Path component does not exist", file->filename);
+           break;
+        case IMLIB_LOAD_ERROR_PATH_COMPONENT_NOT_DIRECTORY:
+           if (!opt.quiet)
+              weprintf("%s - Path component is not a directory",
+                       file->filename);
+           break;
+        case IMLIB_LOAD_ERROR_PATH_POINTS_OUTSIDE_ADDRESS_SPACE:
+           if (!opt.quiet)
+              weprintf("%s - Path points outside address space",
+                       file->filename);
+           break;
+        case IMLIB_LOAD_ERROR_TOO_MANY_SYMBOLIC_LINKS:
+           if (!opt.quiet)
+              weprintf("%s - Too many levels of symbolic links",
+                       file->filename);
+           break;
+        case IMLIB_LOAD_ERROR_OUT_OF_MEMORY:
+           if (!opt.quiet)
+              weprintf("While loading %s - Out of memory", file->filename);
+           break;
+        case IMLIB_LOAD_ERROR_OUT_OF_FILE_DESCRIPTORS:
+           eprintf("While loading %s - Out of file descriptors",
+                   file->filename);
+           break;
+        case IMLIB_LOAD_ERROR_PERMISSION_DENIED_TO_WRITE:
+           if (!opt.quiet)
+              weprintf("%s - Cannot write to directory", file->filename);
+           break;
+        case IMLIB_LOAD_ERROR_OUT_OF_DISK_SPACE:
+           if (!opt.quiet)
+              weprintf("%s - Cannot write - out of disk space",
+                       file->filename);
+           break;
+        default:
+           if (!opt.quiet)
+              weprintf
+                 ("While loading %s - Unknown error (%d). Attempting to continue",
+                  file->filename, err);
+           break;
+      }
+      D(3, ("Load *failed*\n"));
+      D_RETURN(4, 0);
+   }
+
+   D(3, ("Loaded ok\n"));
+   D_RETURN(4, 1);
+}
+
+char *
+feh_http_load_image(char *url)
+{
+   char *tmpname;
+   char *tmpname_timestamper = NULL;
+   char *basename;
+   char *newurl = NULL;
+   char randnum[20];
+   int rnum;
+   char *path = NULL;
+
+   D_ENTER(4);
+
+   if (opt.keep_http)
+   {
+      if (opt.output_dir)
+         path = opt.output_dir;
+      else
+         path = "";
+   }
+   else
+      path = "/tmp/";
+
+   basename = strrchr(url, '/') + 1;
+   tmpname = feh_unique_filename(path, basename);
+
+   if (opt.wget_timestamp)
+   {
+      char cppid[10];
+      pid_t ppid;
+
+      ppid = getpid();
+      snprintf(cppid, sizeof(cppid), "%06ld", (long)ppid);
+      tmpname_timestamper =
+         estrjoin("", "/tmp/feh_", cppid, "_", basename, NULL);
+   }
+
+   if (opt.wget_timestamp)
+   {
+      newurl = estrdup(url);
+   }
+   else
+   {
+      rnum = rand();
+      snprintf(randnum, sizeof(randnum), "%d", rnum);
+      newurl = estrjoin("?", url, randnum, NULL);
+   }
+   D(3, ("newurl: %s\n", newurl));
+
+   if (opt.builtin_http)
+   {
+      /* state for HTTP header parser */
+#define SAW_NONE    1
+#define SAW_ONE_CM  2
+#define SAW_ONE_CJ  3
+#define SAW_TWO_CM  4
+#define IN_BODY     5
+
+#define OUR_BUF_SIZE 1024
+#define EOL "\015\012"
+
+      int sockno = 0;
+      int size;
+      int body = SAW_NONE;
+      struct sockaddr_in addr;
+      struct hostent *hptr;
+      char *hostname;
+      char *get_string;
+      char *host_string;
+      char *query_string;
+      char *get_url;
+      static char buf[OUR_BUF_SIZE];
+      char ua_string[] = "User-Agent: feh image viewer";
+      char accept_string[] = "Accept: image/*";
+      FILE *fp;
+
+      D(4, ("using builtin http collection\n"));
+      fp = fopen(tmpname, "w");
+      if (!fp)
+      {
+         weprintf("couldn't write to file %s:", tmpname);
+         free(tmpname);
+         D_RETURN(4, NULL);
+      }
+
+      hostname = feh_strip_hostname(newurl);
+      if (!hostname)
+      {
+         weprintf("couldn't work out hostname from %s:", newurl);
+         free(tmpname);
+         free(newurl);
+         D_RETURN(4, NULL);
+      }
+
+      D(4, ("trying hostname %s\n", hostname));
+
+      if (!(hptr = feh_gethostbyname(hostname)))
+      {
+         weprintf("error resolving host %s:", hostname);
+         free(hostname);
+         free(tmpname);
+         free(newurl);
+         D_RETURN(4, NULL);
+      }
+
+      /* Copy the address of the host to socket description. */
+      memcpy(&addr.sin_addr, hptr->h_addr, hptr->h_length);
+
+      /* Set port and protocol */
+      addr.sin_family = AF_INET;
+      addr.sin_port = htons(80);
+
+      if ((sockno = socket(PF_INET, SOCK_STREAM, 0)) == -1)
+      {
+         weprintf("error opening socket:");
+         free(tmpname);
+         free(hostname);
+         free(newurl);
+         D_RETURN(4, NULL);
+      }
+      if (connect(sockno, (struct sockaddr *) &addr, sizeof(addr)) == -1)
+      {
+         weprintf("error connecting socket:");
+         free(tmpname);
+         free(hostname);
+         free(newurl);
+         D_RETURN(4, NULL);
+      }
+
+      get_url = strchr(newurl, '/') + 2;
+      get_url = strchr(get_url, '/');
+
+      get_string = estrjoin(" ", "GET", get_url, "HTTP/1.0", NULL);
+      host_string = estrjoin(" ", "Host:", hostname, NULL);
+      query_string =
+         estrjoin(EOL, get_string, host_string, accept_string, ua_string, "",
+                  "", NULL);
+      /* At this point query_string looks something like
+         **
+         **    GET /dir/foo.jpg?123456 HTTP/1.0^M^J
+         **    Host: www.example.com^M^J
+         **    Accept: image/ *^M^J
+         **    User-Agent: feh image viewer^M^J
+         **    ^M^J
+         **
+         ** Host: is required by HTTP/1.1 and very important for some sites,
+         ** even with HTTP/1.0
+         **
+         ** -- BEG
+       */
+      if ((send(sockno, query_string, strlen(query_string), 0)) == -1)
+      {
+         free(get_string);
+         free(host_string);
+         free(query_string);
+         free(tmpname);
+         free(hostname);
+         free(newurl);
+         weprintf("error sending over socket:");
+         D_RETURN(4, NULL);
+      }
+      free(get_string);
+      free(host_string);
+      free(query_string);
+      free(hostname);
+      free(newurl);
+
+      while ((size = read(sockno, &buf, OUR_BUF_SIZE)))
+      {
+         if (body == IN_BODY)
+         {
+            fwrite(buf, 1, size, fp);
+         }
+         else
+         {
+            int i;
+
+            for (i = 0; i < size; i++)
+            {
+               /* We are looking for ^M^J^M^J, but will accept
+                  ** ^J^J from broken servers. Stray ^Ms will be
+                  ** ignored.
+                  **
+                  ** TODO:
+                  ** Checking the headers for a
+                  **    Content-Type: image/ *
+                  ** header would help detect problems with results.
+                  ** Maybe look at the response code too? But there is
+                  ** no fundamental reason why a 4xx or 5xx response
+                  ** could not return an image, it is just the 3xx
+                  ** series we need to worry about.
+                  **
+                  ** Also, grabbing the size from the Content-Length
+                  ** header and killing the connection after that
+                  ** many bytes where read would speed up closing the
+                  ** socket.
+                  ** -- BEG
+                */
+
+               switch (body)
+               {
+
+                 case IN_BODY:
+                    fwrite(buf + i, 1, size - i, fp);
+                    i = size;
+                    break;
+
+                 case SAW_ONE_CM:
+                    if (buf[i] == '\012')
+                    {
+                       body = SAW_ONE_CJ;
+                    }
+                    else
+                    {
+                       body = SAW_NONE;
+                    }
+                    break;
+
+                 case SAW_ONE_CJ:
+                    if (buf[i] == '\015')
+                    {
+                       body = SAW_TWO_CM;
+                    }
+                    else
+                    {
+                       if (buf[i] == '\012')
+                       {
+                          body = IN_BODY;
+                       }
+                       else
+                       {
+                          body = SAW_NONE;
+                       }
+                    }
+                    break;
+
+                 case SAW_TWO_CM:
+                    if (buf[i] == '\012')
+                    {
+                       body = IN_BODY;
+                    }
+                    else
+                    {
+                       body = SAW_NONE;
+                    }
+                    break;
+
+                 case SAW_NONE:
+                    if (buf[i] == '\015')
+                    {
+                       body = SAW_ONE_CM;
+                    }
+                    else
+                    {
+                       if (buf[i] == '\012')
+                       {
+                          body = SAW_ONE_CJ;
+                       }
+                    }
+                    break;
+
+               }                            /* switch */
+            }                               /* for i */
+         }
+      }                                     /* while read */
+      close(sockno);
+      fclose(fp);
+   }
+   else
+   {
+      int pid;
+      int status;
+
+      if ((pid = fork()) < 0)
+      {
+         weprintf("open url: fork failed:");
+         free(tmpname);
+         free(newurl);
+         D_RETURN(4, NULL);
+      }
+      else if (pid == 0)
+      {
+         char *quiet = NULL;
+
+         if (!opt.verbose)
+            quiet = estrdup("-q");
+
+         if (opt.wget_timestamp)
+         {
+            execlp("wget", "wget", "-N", "-O", tmpname_timestamper, newurl,
+                   quiet, (char*) NULL);
+         }
+         else
+         {
+            execlp("wget", "wget", "--cache", "0", newurl, "-O", tmpname,
+                   quiet, (char*) NULL);
+         }
+         eprintf("url: exec failed: wget:");
+      }
+      else
+      {
+         waitpid(pid, &status, 0);
+
+         if (!WIFEXITED(status) || WEXITSTATUS(status) != 0)
+         {
+            weprintf("url: wget failed to load URL %s\n", url);
+            free(tmpname);
+            free(newurl);
+            D_RETURN(4, NULL);
+         }
+         if (opt.wget_timestamp)
+         {
+            char cmd[2048];
+
+            snprintf(cmd, sizeof(cmd), "/bin/cp %s %s", tmpname_timestamper,
+                     tmpname);
+            system(cmd);
+         }
+      }
+   }
+
+   free(newurl);
+   D_RETURN(4, tmpname);
+}
+
+struct hostent *
+feh_gethostbyname(const char *name)
+{
+   struct hostent *hp;
+   unsigned long addr;
+
+   D_ENTER(3);
+   addr = (unsigned long) inet_addr(name);
+   if ((int) addr != -1)
+      hp = gethostbyaddr((char *) &addr, sizeof(addr), AF_INET);
+   else
+      hp = gethostbyname(name);
+   D_RETURN(3, hp);
+}
+
+char *
+feh_strip_hostname(char *url)
+{
+   char *ret;
+   char *start;
+   char *finish;
+   int len;
+
+   D_ENTER(3);
+
+   start = strchr(url, '/');
+   if (!start)
+      D_RETURN(3, NULL);
+
+   start += 2;
+
+   finish = strchr(start, '/');
+   if (!finish)
+      D_RETURN(3, NULL);
+
+   len = finish - start;
+
+   ret = emalloc(len + 1);
+   strncpy(ret, start, len);
+   ret[len] = '\0';
+   D_RETURN(3, ret);
+}
+
+void
+feh_draw_zoom(winwidget w)
+{
+   static Imlib_Font fn = NULL;
+   int tw = 0, th = 0;
+   Imlib_Image im = NULL;
+   char buf[100];
+   static DATA8 atab[256];
+
+   D_ENTER(4);
+
+   if (!w->im)
+      D_RETURN_(4);
+
+   if (!fn) {
+      fn = gib_imlib_load_font(DEFAULT_FONT);
+      memset(atab, 0, sizeof(atab));
+   }
+
+   if (!fn)
+   {
+      weprintf("Couldn't load font for zoom printing");
+      D_RETURN_(4);
+   }
+
+   snprintf(buf, sizeof(buf), "%.0f%%, %dx%d", w->zoom * 100,
+            (int) (w->im_w * w->zoom), (int) (w->im_h * w->zoom));
+
+   /* Work out how high the font is */
+   gib_imlib_get_text_size(fn, buf, NULL, &tw, &th, IMLIB_TEXT_TO_RIGHT);
+
+   tw += 3;
+   th += 3;
+   im = imlib_create_image(tw, th);
+   if (!im)
+      eprintf("Couldn't create image. Out of memory?");
+
+   gib_imlib_image_set_has_alpha(im, 1);
+   gib_imlib_apply_color_modifier_to_rectangle(im, 0, 0, tw, th,
+                                               NULL, NULL, NULL, atab);
+   gib_imlib_image_fill_rectangle(im, 0, 0, tw, th, 0, 0, 0, 0);
+
+   gib_imlib_text_draw(im, fn, NULL, 2, 2, buf, IMLIB_TEXT_TO_RIGHT,
+                       0, 0, 0, 255);
+   gib_imlib_text_draw(im, fn, NULL, 1, 1, buf, IMLIB_TEXT_TO_RIGHT,
+                       255, 255, 255, 255);
+   gib_imlib_render_image_on_drawable(w->bg_pmap, im, 0, w->h - th, 1, 1, 0);
+   gib_imlib_free_image_and_decache(im);
+   D_RETURN_(4);
+}
+
+void
+feh_draw_filename(winwidget w)
+{
+   static Imlib_Font fn = NULL;
+   int tw = 0, th = 0;
+   Imlib_Image im = NULL;
+   static DATA8 atab[256];
+   char *s = NULL;
+   int len = 0;
+
+   D_ENTER(4);
+
+   if ((!w->file) || (!FEH_FILE(w->file->data))
+       || (!FEH_FILE(w->file->data)->filename))
+      D_RETURN_(4);
+
+   if (!fn)
+   {
+      memset(atab, 0, sizeof(atab));
+      if (w->full_screen)
+         fn = gib_imlib_load_font(DEFAULT_FONT_BIG);
+      else
+         fn = gib_imlib_load_font(DEFAULT_FONT);
+   }
+
+   if (!fn)
+   {
+      weprintf("Couldn't load font for filename printing");
+      D_RETURN_(4);
+   }
+
+   /* Work out how high the font is */
+   gib_imlib_get_text_size(fn, FEH_FILE(w->file->data)->filename, NULL, &tw, &th,
+                           IMLIB_TEXT_TO_RIGHT);
+
+   /* tw is no longer correct, if the filename is shorter than
+    * the string "%d of %d" used below in fullscreen mode */
+   tw += 3;
+   th += 3;
+   im = imlib_create_image(tw, 2*th);
+   if (!im)
+      eprintf("Couldn't create image. Out of memory?");
+
+   gib_imlib_image_set_has_alpha(im, 1);
+   gib_imlib_apply_color_modifier_to_rectangle(im, 0, 0, tw, 2*th,
+                                               NULL, NULL, NULL, atab);
+   gib_imlib_image_fill_rectangle(im, 0, 0, tw, 2*th, 0, 0, 0, 0);
+
+   gib_imlib_text_draw(im, fn, NULL, 2, 2, FEH_FILE(w->file->data)->filename,
+                       IMLIB_TEXT_TO_RIGHT, 0, 0, 0, 255);
+   gib_imlib_text_draw(im, fn, NULL, 1, 1, FEH_FILE(w->file->data)->filename,
+                       IMLIB_TEXT_TO_RIGHT, 255, 255, 255, 255);
+   /* Print the position in the filelist, if we are in fullscreen and the
+    * list has more than one element */
+   if (w->full_screen && (gib_list_length(filelist)-1))
+   {
+      /* sic! */
+      len = snprintf(NULL, 0, "%d of %d", gib_list_length(filelist), gib_list_length(filelist))+1;
+      s = emalloc(len);
+      snprintf(s, len, "%d of %d",
+               gib_list_num(filelist, current_file) + 1,
+               gib_list_length(filelist));
+      /* This should somehow be right-aligned */
+      gib_imlib_text_draw(im, fn, NULL, 2, th+1, s, IMLIB_TEXT_TO_RIGHT, 0, 0, 0, 255);
+      gib_imlib_text_draw(im, fn, NULL, 1, th, s, IMLIB_TEXT_TO_RIGHT, 255, 255, 255, 255);
+      free(s);
+   }
+
+   gib_imlib_render_image_on_drawable(w->bg_pmap, im, 0, 0, 1, 1, 0);
+
+   gib_imlib_free_image_and_decache(im);
+   D_RETURN_(4);
+}
+
+char *build_caption_filename(feh_file *file) {
+  char *caption_filename;
+  char *s, *dir;
+  s = strrchr(file->filename, '/');
+  if (s) {
+    dir = estrdup(file->filename);
+    s = strrchr(dir, '/');
+    *s = '\0';
+  } else {
+    dir = estrdup(".");
+  }
+  caption_filename = estrjoin("",
+                              dir,
+                              "/",
+                              opt.caption_path,
+                              "/",
+                              file->name,
+                              ".txt",
+                              NULL);
+  free(dir);
+  return caption_filename;
+}
+
+void
+feh_draw_caption(winwidget w)
+{
+   static Imlib_Font fn = NULL;
+   int tw = 0, th = 0, ww, hh;
+   int x, y;
+   Imlib_Image im = NULL;
+   static DATA8 atab[256];
+   char *p;
+   gib_list *lines, *l;
+   static gib_style *caption_style = NULL;
+   feh_file *file;
+
+   D_ENTER(4);
+
+   if (!w->file) {
+     D_RETURN_(4);
+   }
+   file = FEH_FILE(w->file->data);
+   if (!file->filename) {
+     D_RETURN_(4);
+   }
+
+   if (!file->caption) {
+      char *caption_filename;
+      caption_filename = build_caption_filename(file);
+      /* read caption from file */
+      file->caption = ereadfile(caption_filename);
+      free(caption_filename);
+   }
+
+   if (file->caption == NULL) {
+     /* caption file is not there, we want to cache that, otherwise we'll stat
+      * the damn file every time we render the image. Reloading an image will
+      * always cause the caption to be reread though so we're safe to do so.
+      * (Before this bit was added, when zooming a captionless image with
+      * captions enabled, the captions file would be stat()d like 30 times a
+      * second) - don't forget this function is called from
+      * winwidget_render_image().
+      */
+     file->caption = estrdup("");
+     D_RETURN_(4);
+   }
+
+   if (file->caption == '\0') {
+     D_RETURN_(4);
+   }
+
+   if (!caption_style) {
+     caption_style = gib_style_new("caption");
+     caption_style->bits = gib_list_add_front(caption_style->bits,
+                                            gib_style_bit_new(0,0,0,0,0,0));
+     caption_style->bits = gib_list_add_front(caption_style->bits, 
+                                            gib_style_bit_new(1,1,0,0,0,255));
+   }
+
+   if (!fn)
+   {
+      memset(atab, 0, sizeof(atab));
+      if (w->full_screen)
+         fn = gib_imlib_load_font(DEFAULT_FONT_BIG);
+      else
+         fn = gib_imlib_load_font(DEFAULT_FONT);
+   }
+
+   if (!fn)
+   {
+      weprintf("Couldn't load font for caption printing");
+      D_RETURN_(4);
+   }
+
+   lines = feh_wrap_string(file->caption, w->w, w->h, fn, NULL);
+   if (!lines)
+     D_RETURN_(4);
+
+   /* Work out how high/wide the caption is */
+   l = lines;
+   while (l) {
+     p = (char *) l->data;
+     gib_imlib_get_text_size(fn, p, caption_style, &ww, &hh, IMLIB_TEXT_TO_RIGHT);
+     if (ww > tw)
+       tw = ww;
+     th += hh;
+     if (l->next)
+       th += 1; /* line spacing */
+     l = l->next;
+   }
+   
+   /* we don't want the caption overlay larger than our window */
+   if (th > w->h)
+     th = w->h;
+   if (tw > w->w)
+     tw = w->w;
+
+   im = imlib_create_image(tw, th);
+   if (!im)
+      eprintf("Couldn't create image. Out of memory?");
+
+   gib_imlib_image_set_has_alpha(im, 1);
+   gib_imlib_apply_color_modifier_to_rectangle(im, 0, 0, tw, th,
+                                               NULL, NULL, NULL, atab);
+   gib_imlib_image_fill_rectangle(im, 0, 0, tw, th, 0, 0, 0, 0);
+   
+   l = lines;
+   x = 0;
+   y = 0;
+   while (l) {
+     p = (char *) l->data;
+     gib_imlib_get_text_size(fn, p, caption_style, &ww, &hh, IMLIB_TEXT_TO_RIGHT);
+     x = (tw - ww) / 2;
+     if (w->caption_entry) {
+     gib_imlib_text_draw(im, fn, caption_style, x, y, p, IMLIB_TEXT_TO_RIGHT,
+                         255, 255, 0, 255);
+     } else {
+     gib_imlib_text_draw(im, fn, caption_style, x, y, p, IMLIB_TEXT_TO_RIGHT,
+                         255, 255, 255, 255);
+     }
+                
+     y += hh + 1; /* line spacing */
+     l = l->next;
+   }
+   
+   gib_imlib_render_image_on_drawable(w->bg_pmap, im, (w->w - tw) / 2, w->h - th, 1, 1, 0);
+   gib_imlib_free_image_and_decache(im);
+   gib_list_free_and_data(lines);
+   D_RETURN_(4);
+}
+
+
+unsigned char reset_output = 0;
+
+void
+feh_display_status(char stat)
+{
+   static int i = 0;
+   static int init_len = 0;
+   int j = 0;
+
+   D_ENTER(5);
+
+   D(5, ("filelist %p, filelist->next %p\n", filelist, filelist->next));
+
+   if (!init_len)
+      init_len = gib_list_length(filelist);
+
+   if (i)
+   {
+      if (reset_output)
+      {
+         /* There's just been an error message. Unfortunate ;) */
+         for (j = 0; j < (((i % 50) + ((i % 50) / 10)) + 7); j++)
+            fprintf(stdout, " ");
+      }
+
+      if (!(i % 50))
+      {
+         int len;
+         char buf[50];
+
+         len = gib_list_length(filelist);
+         snprintf(buf, sizeof(buf), " %5d/%d (%d)\n[%3d%%] ", i, init_len,
+                  len, ((int) ((float) i / init_len * 100)));
+         fprintf(stdout, buf);
+      }
+      else if ((!(i % 10)) && (!reset_output))
+         fprintf(stdout, " ");
+
+      reset_output = 0;
+   }
+   else
+      fprintf(stdout, "[  0%%] ");
+
+   fprintf(stdout, "%c", stat);
+   fflush(stdout);
+   i++;
+   D_RETURN_(5);
+}
+
+void feh_edit_inplace_orient(winwidget w, int orientation) {
+  int ret;
+  Imlib_Image old;
+  D_ENTER(4);
+  if(!w->file
+    || !w->file->data 
+    || !FEH_FILE(w->file->data)->filename)
+    D_RETURN_(4);
+
+  if (!strcmp(gib_imlib_image_format(w->im), "jpeg")) {
+    feh_edit_inplace_lossless_rotate(w, orientation);
+    feh_reload_image(w, 1, 1);
+    D_RETURN_(4);
+  }
+
+  ret = feh_load_image(&old, FEH_FILE(w->file->data));
+  if(ret) {
+    gib_imlib_image_orientate(old, orientation);
+    gib_imlib_save_image(old, FEH_FILE(w->file->data)->filename);
+    gib_imlib_free_image(old);
+    feh_reload_image(w, 1, 1);
+  } else {
+    weprintf("failed to load image from disk to edit it in place\n");
+  }
+  
+  D_RETURN_(4);
+}
+
+
+/* TODO max_height is ignored... Could use a function which generates a
+ * transparent text overlay image, with wrapping and all. Would be useful */
+gib_list *
+feh_wrap_string(char *text, int wrap_width, int max_height, Imlib_Font fn, gib_style * style)
+{
+   gib_list *ll, *lines = NULL, *list = NULL, *words;
+   gib_list *l = NULL;
+   char delim[2] = { '\n', '\0' };
+   int w, line_width;
+   int tw, th;
+   char *p, *pp;
+   char *line = NULL;
+   char *temp;
+   int space_width = 0, m_width = 0, t_width = 0, new_width = 0;
+
+   lines = gib_string_split(text, delim);
+
+   if (wrap_width)
+   {
+      gib_imlib_get_text_size(fn, "M M", style, &t_width, NULL,
+                              IMLIB_TEXT_TO_RIGHT);
+      gib_imlib_get_text_size(fn, "M", style, &m_width, NULL,
+                              IMLIB_TEXT_TO_RIGHT);
+      space_width = t_width - (2 * m_width);
+      w = wrap_width;
+      l = lines;
+      while (l)
+      {
+         line_width = 0;
+         p = (char *) l->data;
+         /* quick check to see if whole line fits okay */
+         gib_imlib_get_text_size(fn, p, style, &tw, &th, IMLIB_TEXT_TO_RIGHT);
+         if (tw <= w) {
+            list = gib_list_add_end(list, estrdup(p));
+         } else if (strlen(p) == 0) {
+            list = gib_list_add_end(list, estrdup(""));
+         } else if (!strcmp(p, " ")) {
+            list = gib_list_add_end(list, estrdup(" "));
+         } else {
+            words = gib_string_split(p, " ");
+            if (words) {
+               ll = words;
+               while (ll) {
+                  pp = (char *) ll->data;
+                  if (strcmp(pp, " ")) {
+                     gib_imlib_get_text_size(fn, pp, style, &tw, &th,
+                                             IMLIB_TEXT_TO_RIGHT);
+                     if (line_width == 0)
+                        new_width = tw;
+                     else
+                        new_width = line_width + space_width + tw;
+                     if (new_width <= w) {
+                        /* add word to line */
+                        if (line) {
+                           int len;
+
+                           len = strlen(line) + strlen(pp) + 2;
+                           temp = emalloc(len);
+                           snprintf(temp, len, "%s %s", line, pp);
+                           free(line);
+                           line = temp;
+                        } else {
+                          line = estrdup(pp);
+                        }
+                        line_width = new_width;
+                     } else if (line_width == 0) {
+                        /* can't fit single word in :/
+                           increase width limit to width of word
+                           and jam the bastard in anyhow */
+                        w = tw;
+                        line = estrdup(pp);
+                        line_width = new_width;
+                     } else {
+                        /* finish this line, start next and add word there */
+                        if (line) {
+                           list = gib_list_add_end(list, estrdup(line));
+                           free(line);
+                           line = NULL;
+                        }
+                        line = estrdup(pp);
+                        line_width = tw;
+                     }
+                  }
+                  ll = ll->next;
+               }
+               if (line) {
+                  /* finish last line */
+                  list = gib_list_add_end(list, estrdup(line));
+                  free(line);
+                  line = NULL;
+                  line_width = 0;
+               }
+               gib_list_free_and_data(words);
+            }
+         }
+         l = l->next;
+      }
+      gib_list_free_and_data(lines);
+      lines = list;
+   }
+   return lines;
+}
+
+void feh_edit_inplace_lossless_rotate(winwidget w, int orientation) {
+  FILE *input_file;
+  FILE *output_file;
+  struct jpeg_decompress_struct srcinfo;
+  struct jpeg_compress_struct dstinfo;
+  struct jpeg_error_mgr jsrcerr, jdsterr;
+  jvirt_barray_ptr * src_coef_arrays;
+  jvirt_barray_ptr * dst_coef_arrays;
+  JCOPY_OPTION copyoption;
+  jpeg_transform_info transformoption;
+  int len;
+  char *outfilename;
+  char *infilename = FEH_FILE(w->file->data)->filename;
+
+  copyoption = JCOPYOPT_ALL;
+  transformoption.transform = JXFORM_NONE;
+  transformoption.trim = FALSE;
+  transformoption.force_grayscale = FALSE;
+
+  if (orientation == 1) {
+    transformoption.transform = JXFORM_ROT_90;
+  } else if (orientation == 2) {
+    transformoption.transform = JXFORM_ROT_180;
+  } else {
+    transformoption.transform = JXFORM_ROT_270;
+  }
+  
+  if ((input_file = fopen(infilename, "rb")) == NULL) {
+    weprintf("couldn't open file for reading: %s\n", infilename);
+    D_RETURN_(4);
+  }
+  len = strlen(infilename) + sizeof(".tmp") + 1;
+  outfilename = emalloc(len);
+  snprintf(outfilename, len, "%s.tmp", infilename);
+
+  if ((output_file = fopen(outfilename, "wb")) == NULL) {
+    weprintf("couldn't open file for writing: %s\n", outfilename);
+    free(outfilename);
+    fclose(input_file);
+    D_RETURN_(4);
+  }
+
+  /* Initialize the JPEG decompression object with default error handling. */
+  srcinfo.err = jpeg_std_error(&jsrcerr);
+  jpeg_create_decompress(&srcinfo);
+
+  /* Initialize the JPEG compression object with default error handling. */
+  dstinfo.err = jpeg_std_error(&jdsterr);
+  jpeg_create_compress(&dstinfo);
+  jsrcerr.trace_level = jdsterr.trace_level;
+
+  /* Specify data source for decompression */
+  jpeg_stdio_src(&srcinfo, input_file);
+
+  /* Enable saving of extra markers that we want to copy */
+  jcopy_markers_setup(&srcinfo, copyoption);
+
+  /* Read file header */
+  (void) jpeg_read_header(&srcinfo, TRUE);
+
+  /* Any space needed by a transform option must be requested before
+   * jpeg_read_coefficients so that memory allocation will be done right.
+   */
+  jtransform_request_workspace(&srcinfo, &transformoption);
+
+  /* Read source file as DCT coefficients */
+  src_coef_arrays = jpeg_read_coefficients(&srcinfo);
+
+  /* Initialize destination compression parameters from source values */
+  jpeg_copy_critical_parameters(&srcinfo, &dstinfo);
+
+  /* Adjust destination parameters if required by transform options;
+   * also find out which set of coefficient arrays will hold the output.
+   */
+  dst_coef_arrays = jtransform_adjust_parameters(&srcinfo, &dstinfo,
+             src_coef_arrays,
+             &transformoption);
+
+  /* Specify data destination for compression */
+  jpeg_stdio_dest(&dstinfo, output_file);
+
+  /* Start compressor (note no image data is actually written here) */
+  jpeg_write_coefficients(&dstinfo, dst_coef_arrays);
+
+  /* Copy to the output file any extra markers that we want to preserve */
+  jcopy_markers_execute(&srcinfo, &dstinfo, copyoption);
+
+  /* Execute image transformation */
+  jtransform_execute_transformation(&srcinfo, &dstinfo,
+            src_coef_arrays,
+            &transformoption);
+
+  /* Finish compression and release memory */
+  jpeg_finish_compress(&dstinfo);
+  jpeg_destroy_compress(&dstinfo);
+
+  (void) jpeg_finish_decompress(&srcinfo);
+  jpeg_destroy_decompress(&srcinfo);
+
+  fclose(input_file);
+  fclose(output_file);
+
+  /* TODO fix EXIF tags (orientation, width, height) */
+
+  /* rename outfilename to infilename.. if it worked */
+  if (jsrcerr.num_warnings > 0) {
+    weprintf("got errors from libjpeg (%d), not replacing file\n", jsrcerr.num_warnings);
+  } else {
+    if (rename(outfilename, infilename)) {
+      weprintf("failed to replace file %s with %s\n", infilename, outfilename);
+    }
+  }
+  free(outfilename);
+}
+
+void
+feh_draw_actions(winwidget w)
+{
+   static Imlib_Font fn = NULL;
+   int tw = 0, th = 0;
+   int max_tw = 0;
+   int line_th = 0;
+   Imlib_Image im = NULL;
+   static DATA8 atab[256];
+   int i = 0;
+   int num_actions = 0;
+   
+   D_ENTER(4);
+
+// count the number of defined actions
+   for (num_actions=0;opt.actions[num_actions];num_actions++)
+   	;
+   if (num_actions == 0)
+      return;
+   
+   if ((!w->file) || (!FEH_FILE(w->file->data))
+       || (!FEH_FILE(w->file->data)->filename))
+      D_RETURN_(4);
+
+   if (!fn)
+   {
+      memset(atab, 0, sizeof(atab));
+      if (w->full_screen)
+         fn = gib_imlib_load_font(DEFAULT_FONT_BIG);
+      else
+         fn = gib_imlib_load_font(DEFAULT_FONT);
+   }
+
+   if (!fn)
+   {
+      weprintf("Couldn't load font for actions printing");
+      D_RETURN_(4);
+   }
+
+
+   gib_imlib_get_text_size(fn, "defined actions:", NULL, &tw, &th,
+                           IMLIB_TEXT_TO_RIGHT);
+// Check for the widest line
+   max_tw = tw; 
+   for (i=0;opt.actions[i];i++) {
+   gib_imlib_get_text_size(fn, opt.actions[i], NULL, &tw, &th,
+                           IMLIB_TEXT_TO_RIGHT);
+   	if (tw>max_tw) {
+	   max_tw = tw;
+	}
+   }
+
+   tw = max_tw;
+   tw += 3;
+   th += 3;
+   line_th = th;
+   th = (th*num_actions)+line_th;
+
+   im = imlib_create_image(tw, th);
+   if (!im)
+      eprintf("Couldn't create image. Out of memory?");
+
+   gib_imlib_image_set_has_alpha(im, 1);
+   gib_imlib_apply_color_modifier_to_rectangle(im, 0, 0, tw, th,
+                                               NULL, NULL, NULL, atab);
+   gib_imlib_image_fill_rectangle(im, 0, 0, tw, th, 0, 0, 0, 0);
+   
+   gib_imlib_text_draw(im, fn, NULL, 1, 1, "defined actions:",
+                       IMLIB_TEXT_TO_RIGHT, 0, 0, 0, 255);
+   gib_imlib_text_draw(im, fn, NULL, 2, 2, "defined actions:",
+                       IMLIB_TEXT_TO_RIGHT, 255, 255, 255, 255);
+
+   for(i=0;i<num_actions;i++)
+   {
+//    compose a line containing an index, a colon followed by the
+//    action.
+      char index[1];
+      char line[strlen(opt.actions[i])+5];
+      sprintf(index, "%d", i);
+      strcpy(line, index);
+      strcat(line, ": ");
+      strcat(line, opt.actions[i]);
+
+      gib_imlib_text_draw(im, fn, NULL, 2, ((i+1)*line_th)+2, line,
+                          IMLIB_TEXT_TO_RIGHT, 0, 0, 0, 255);
+      gib_imlib_text_draw(im, fn, NULL, 1, ((i+1)*line_th)+1, line,
+                          IMLIB_TEXT_TO_RIGHT, 255, 255, 255, 255);
+      free(line);
+   }
+
+   gib_imlib_render_image_on_drawable(w->bg_pmap, im, 0, 0, 1, 1, 0);
+
+   gib_imlib_free_image_and_decache(im);
+   D_RETURN_(4);
+}