7 files changed, 388 insertions, 180 deletions

diff --git a/src/gempub.c b/src/gempub.c
new file mode 100644
index 00000000..45a4c1b3
--- /dev/null
+++ b/src/gempub.c
@@ -0,0 +1,210 @@
+/* Copyright 2021 Jaakko Keränen <jaakko.keranen@iki.fi>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
+
+#include "gempub.h"
+#include "gmutil.h"
+#include "lang.h"
+#include "defs.h"
+#include "ui/util.h"
+
+#include <the_Foundation/archive.h>
+#include <the_Foundation/file.h>
+#include <the_Foundation/path.h>
+
+const char *mimeType_Gempub = "application/gpub+zip";
+
+struct Impl_Gempub {
+    iArchive *arch;
+    iString baseUrl;
+    iString props[max_GempubProperty];
+};
+
+iDefineTypeConstruction(Gempub)
+    
+void init_Gempub(iGempub *d) {
+    d->arch = NULL;
+    init_String(&d->baseUrl);
+    iForIndices(i, d->props) {
+        init_String(&d->props[i]);
+    }    
+}
+
+void deinit_Gempub(iGempub *d) {
+    iForIndices(i, d->props) {
+        deinit_String(&d->props[i]);
+    }
+    deinit_String(&d->baseUrl);
+    iRelease(d->arch);
+}
+    
+static iBool parseMetadata_Gempub_(iGempub *d) {
+    iAssert(isOpen_Archive(d->arch));
+    /* Parse the metadata and check if the required contents are present. */
+    const iBlock *metadata = dataCStr_Archive(d->arch, "metadata.txt");
+    if (!metadata) {
+        return iFalse;
+    }
+    static const char *labels[max_GempubProperty] = {
+        "title:",
+        "index:",
+        "author:",
+        "language:",
+        "description:",
+        "published:",
+        "publishDate:",
+        "revisionDate:",
+        "copyright:",
+        "license:",
+        "version:",
+        "cover:",
+    };
+    /* Default values. */
+    setCStr_String(&d->props[title_GempubProperty], "Untitled Book");
+    setCStr_String(&d->props[cover_GempubProperty],
+                   entryCStr_Archive(d->arch, "cover.jpg") ? "cover.jpg" :
+                   entryCStr_Archive(d->arch, "cover.png") ? "cover.png" : "");
+    setCStr_String(&d->props[index_GempubProperty], "index.gmi");
+    iRangecc line = iNullRange;
+    while (nextSplit_Rangecc(range_Block(metadata), "\n", &line)) {
+        iRangecc clean = line;
+        trim_Rangecc(&clean);
+        iForIndices(i, d->props) {
+            if (startsWithCase_Rangecc(clean, labels[i])) {
+                setRange_String(&d->props[i],
+                                (iRangecc){ clean.start + strlen(labels[i]), clean.end });
+                trim_String(&d->props[i]);
+            }
+        }
+    }
+    return iTrue;
+}    
+
+iBool open_Gempub(iGempub *d, const iBlock *data) {
+    close_Gempub(d);
+    d->arch = new_Archive();
+    if (openData_Archive(d->arch, data) && parseMetadata_Gempub_(d)) {
+        return iTrue;
+    }
+    close_Gempub(d);
+    return iFalse;
+}
+
+iBool openFile_Gempub(iGempub *d, const iString *path) {
+    close_Gempub(d);
+    iFile *f = new_File(path);
+    if (open_File(f, readOnly_FileMode)) {
+        iBlock *data = readAll_File(f);
+        open_Gempub(d, data);
+        delete_Block(data);
+        setBaseUrl_Gempub(d, collect_String(makeFileUrl_String(path)));
+    }
+    iRelease(f);
+    return isOpen_Gempub(d);
+}
+
+iBool openUrl_Gempub(iGempub *d, const iString *url) {
+    if (!openFile_Gempub(d, collect_String(localFilePathFromUrl_String(url)))) {
+        setBaseUrl_Gempub(d, url);
+        close_Gempub(d);
+        return iFalse;
+    }
+    return iTrue;
+}
+
+void close_Gempub(iGempub *d) {
+    if (d->arch) {
+        iReleasePtr(&d->arch);
+    }
+    iForIndices(i, d->props) {
+        clear_String(&d->props[i]);
+    }
+}
+
+iBool isOpen_Gempub(const iGempub *d) {
+    return d->arch != NULL;
+}
+
+void setBaseUrl_Gempub(iGempub *d, const iString *url) {
+    set_String(&d->baseUrl, url);
+}
+
+static iBool hasProperty_Gempub_(const iGempub *d, enum iGempubProperty prop) {
+    return !isEmpty_String(&d->props[prop]);
+}
+
+static void appendProperty_Gempub_(const iGempub *d, const char *label,
+                                   enum iGempubProperty prop, iString *out) {
+    if (hasProperty_Gempub_(d, prop)) {
+        appendFormat_String(out, "%s %s\n", label, cstr_String(&d->props[prop]));
+    }
+}
+
+static iBool isRemote_Gempub_(const iGempub *d) {
+    return !equalCase_Rangecc(urlScheme_String(&d->baseUrl), "file");
+}
+
+iBlock *coverPageSource_Gempub(const iGempub *d) {
+    iAssert(!isEmpty_String(&d->baseUrl));
+    const iString *baseUrl = withSpacesEncoded_String(&d->baseUrl);
+    iString *out = new_String();
+    format_String(out, "# %s\n",
+                  cstr_String(&d->props[title_GempubProperty]));
+    if (!isEmpty_String(&d->props[description_GempubProperty])) {
+        appendFormat_String(out, "%s\n", cstr_String(&d->props[description_GempubProperty]));
+    }
+    appendCStr_String(out, "\n");
+    appendProperty_Gempub_(d, "Author:", author_GempubProperty, out);
+    if (!isRemote_Gempub_(d)) {
+        appendFormat_String(out, "\n=> %s " book_Icon " View Gempub contents\n",
+                            cstrCollect_String(concat_Path(baseUrl, &d->props[index_GempubProperty])));
+        if (hasProperty_Gempub_(d, cover_GempubProperty)) {
+            appendFormat_String(out, "\n=> %s  Cover image\n",
+                                cstrCollect_String(concat_Path(baseUrl, &d->props[cover_GempubProperty])));
+        }
+    }
+    else {
+        iString *key = collectNew_String(); /* TODO: add a helper for this */
+        toString_Sym(SDLK_s, KMOD_PRIMARY, key);
+        appendCStr_String(out, "\nThis Gempub book can be viewed after it has been saved locally. ");
+        appendFormat_String(out,
+                            cstr_Lang("error.unsupported.suggestsave"),
+                            cstr_String(key),
+                            saveToDownloads_Label);
+        translate_Lang(out);
+        appendCStr_String(out, "\n");
+    }
+    appendCStr_String(out, "\n## About this book\n");
+    appendProperty_Gempub_(d, "Version:", version_GempubProperty, out);
+    appendProperty_Gempub_(d, "Revision date:", revisionDate_GempubProperty, out);
+    if (hasProperty_Gempub_(d, publishDate_GempubProperty)) {
+        appendProperty_Gempub_(d, "Publish date:", publishDate_GempubProperty, out);
+    }
+    else {
+        appendProperty_Gempub_(d, "Published:", published_GempubProperty, out);
+    }
+    appendProperty_Gempub_(d, "Language:", language_GempubProperty, out);
+    appendProperty_Gempub_(d, "License:", license_GempubProperty, out);
+    appendProperty_Gempub_(d, "\u00a9", copyright_GempubProperty, out);
+    iBlock *output = copy_Block(utf8_String(out));
+    delete_String(out);
+    return output;
+}
diff --git a/src/gempub.h b/src/gempub.h
new file mode 100644
index 00000000..41d14824
--- /dev/null
+++ b/src/gempub.h
@@ -0,0 +1,58 @@
+/* Copyright 2021 Jaakko Keränen <jaakko.keranen@iki.fi>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
+
+#pragma once
+
+#include <the_Foundation/string.h>
+
+iDeclareType(Gempub)
+iDeclareTypeConstruction(Gempub)
+        
+enum iGempubProperty {
+    title_GempubProperty,
+    index_GempubProperty,
+    author_GempubProperty,
+    language_GempubProperty,
+    description_GempubProperty,
+    published_GempubProperty,
+    publishDate_GempubProperty,
+    revisionDate_GempubProperty,
+    copyright_GempubProperty,
+    license_GempubProperty,
+    version_GempubProperty,
+    cover_GempubProperty,            
+    max_GempubProperty
+};    
+    
+iBool       open_Gempub             (iGempub *, const iBlock *data);
+iBool       openFile_Gempub         (iGempub *, const iString *path);
+iBool       openUrl_Gempub          (iGempub *, const iString *url);
+void        close_Gempub            (iGempub *);
+
+void        setBaseUrl_Gempub       (iGempub *, const iString *baseUrl);
+
+iBool       isOpen_Gempub           (const iGempub *);
+iBlock *    coverPageSource_Gempub  (const iGempub *);
+
+const iString *property_Gempub      (const iGempub *, enum iGempubProperty);
+
+extern const char *mimeType_Gempub;
diff --git a/src/gmrequest.c b/src/gmrequest.c
index 8ab37c61..cdf4e582 100644
--- a/src/gmrequest.c
+++ b/src/gmrequest.c
@@ -535,21 +535,6 @@ void setUrl_GmRequest(iGmRequest *d, const iString *url) {
     urlEncodeSpaces_String(&d->url);
 }
 
-static const iString *findContainerArchive_(const iString *path) {
-    iBeginCollect();
-    while (!isEmpty_String(path) && cmp_String(path, ".")) {
-        iString *dir = newRange_String(dirName_Path(path));
-        if (endsWithCase_String(dir, ".zip") ||
-            endsWithCase_String(dir, ".gpub")) {
-            iEndCollect();
-            return collect_String(dir);
-        }
-        path = collect_String(dir);
-    }
-    iEndCollect();
-    return NULL;
-}
-
 static iBool isDirectory_(const iString *path) {
     /* TODO: move this to the_Foundation */
     iFileInfo *info = new_FileInfo(path);
@@ -652,7 +637,7 @@ void submit_GmRequest(iGmRequest *d) {
         }
         else if (open_File(f, readOnly_FileMode)) {
             resp->statusCode = success_GmStatusCode;
-            setCStr_String(&resp->meta, mediaTypeFromPath_String(path));
+            setCStr_String(&resp->meta, mediaType_Path(path));
             /* TODO: Detect text files based on contents? E.g., is the content valid UTF-8. */
             set_Block(&resp->body, collect_Block(readAll_File(f)));
             d->state = receivingBody_GmRequestState;
@@ -660,7 +645,7 @@ void submit_GmRequest(iGmRequest *d) {
         }
         else {
             /* It could be a path inside an archive. */
-            const iString *container = findContainerArchive_(path);
+            const iString *container = findContainerArchive_Path(path);
             if (container) {
                 iArchive *arch = iClob(new_Archive());
                 if (openFile_Archive(arch, container)) {
@@ -748,7 +733,7 @@ void submit_GmRequest(iGmRequest *d) {
                         const iBlock *data = data_Archive(arch, entryPath);
                         if (data) {
                             resp->statusCode = success_GmStatusCode;
-                            setCStr_String(&resp->meta, mediaTypeFromPath_String(entryPath));
+                            setCStr_String(&resp->meta, mediaType_Path(entryPath));
                             set_Block(&resp->body, data);
                         }
                         else {
diff --git a/src/gmutil.c b/src/gmutil.c
index 9f53ae87..a9d70fbb 100644
--- a/src/gmutil.c
+++ b/src/gmutil.c
@@ -438,7 +438,22 @@ iString *localFilePathFromUrl_String(const iString *d) {
     return path;
 }
 
-const char *mediaTypeFromPath_String(const iString *path) {
+const iString *findContainerArchive_Path(const iString *path) {
+    iBeginCollect();
+    while (!isEmpty_String(path) && cmp_String(path, ".")) {
+        iString *dir = newRange_String(dirName_Path(path));
+        if (endsWithCase_String(dir, ".zip") ||
+            endsWithCase_String(dir, ".gpub")) {
+            iEndCollect();
+            return collect_String(dir);
+        }
+        path = collect_String(dir);
+    }
+    iEndCollect();
+    return NULL;
+}
+
+const char *mediaType_Path(const iString *path) {
     if (endsWithCase_String(path, ".gmi") || endsWithCase_String(path, ".gemini")) {
         return "text/gemini; charset=utf-8";
     }
diff --git a/src/gmutil.h b/src/gmutil.h
index 7aedbc47..84f31e2e 100644
--- a/src/gmutil.h
+++ b/src/gmutil.h
@@ -119,7 +119,10 @@ iString *       localFilePathFromUrl_String(const iString *);
 void            urlEncodeSpaces_String  (iString *);
 const iString * withSpacesEncoded_String(const iString *);
 
-const char *    mediaTypeFromPath_String            (const iString *path);
+const char *    mediaType_Path                      (const iString *path);
 iRangecc        mediaTypeWithoutParameters_Rangecc  (iRangecc mime);
 
+const iString * findContainerArchive_Path           (const iString *path);
+
+
 const iString * feedEntryOpenCommand_String (const iString *url, int newTab); /* checks fragment */
diff --git a/src/mimehooks.c b/src/mimehooks.c
index 931c8138..364449ec 100644
--- a/src/mimehooks.c
+++ b/src/mimehooks.c
@@ -23,9 +23,9 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
 #include "mimehooks.h"
 #include "defs.h"
 #include "gmutil.h"
+#include "gempub.h"
 #include "app.h"
 
-#include <the_Foundation/archive.h>
 #include <the_Foundation/file.h>
 #include <the_Foundation/fileinfo.h>
 #include <the_Foundation/path.h>
@@ -203,112 +203,20 @@ finished:
     return output;
 }
 
-static void appendGemPubProperty_(iString *out, const char *key, const iString *value) {
-    if (!isEmpty_String(value)) {
-        appendFormat_String(out, "%s %s\n", key, cstr_String(value));
-    }
-}
-
-iBlock *translateGemPubCoverPage_(const iString *mime, const iBlock *source,
-                                  const iString *requestUrl) {
+iBlock *translateGemPubCoverPage_(const iBlock *source, const iString *requestUrl) {
     iBlock *output = NULL;
-    iArchive *arch = new_Archive();
-    if (openData_Archive(arch, source)) {
-        /* Parse the metadata and check if the required contents are present. */
-        const iBlock *metadata = dataCStr_Archive(arch, "metadata.txt");
-        if (!metadata) {
-            goto cleanup;
-        }
-        enum iGemPubProperty {
-            title_GemPubProperty,
-            index_GemPubProperty,
-            author_GemPubProperty,
-            language_GemPubProperty,
-            description_GemPubProperty,
-            published_GemPubProperty,
-            publishDate_GemPubProperty,
-            revisionDate_GemPubProperty,
-            copyright_GemPubProperty,
-            license_GemPubProperty,
-            version_GemPubProperty,
-            cover_GemPubProperty,            
-            max_GemPubProperty
-        };
-        static const char *labels[max_GemPubProperty] = {
-            "title:",
-            "index:",
-            "author:",
-            "language:",
-            "description:",
-            "published:",
-            "publishDate:",
-            "revisionDate:",
-            "copyright:",
-            "license:",
-            "version:",
-            "cover:",
-        };
-        iString *props[max_GemPubProperty];
-        iForIndices(i, props) {
-            props[i] = collectNew_String();
-        }
-        /* Default values. */
-        setCStr_String(props[title_GemPubProperty], "Untitled Book");
-        setCStr_String(props[cover_GemPubProperty],
-                       entryCStr_Archive(arch, "cover.jpg") ? "cover.jpg" :
-                       entryCStr_Archive(arch, "cover.png") ? "cover.png" : "");
-        setCStr_String(props[index_GemPubProperty], "index.gmi");
-        iRangecc line = iNullRange;
-        while (nextSplit_Rangecc(range_Block(metadata), "\n", &line)) {
-            iRangecc clean = line;
-            trim_Rangecc(&clean);
-            iForIndices(i, props) {
-                if (startsWithCase_Rangecc(clean, labels[i])) {
-                    setRange_String(props[i], (iRangecc){ clean.start + strlen(labels[i]), clean.end });
-                    trim_String(props[i]);
-                }
-            }
-        }
-        const iString *baseUrl = withSpacesEncoded_String(requestUrl);
-        iString *out = new_String();
-        format_String(out, "20 text/gemini; charset=utf-8\r\n"
-                      "# %s\n",
-                      cstr_String(props[title_GemPubProperty]));
-        if (!isEmpty_String(props[description_GemPubProperty])) {
-            appendFormat_String(out, "%s\n", cstr_String(props[description_GemPubProperty]));
-        }
-        appendCStr_String(out, "\n");
-        appendGemPubProperty_(out, "Author:", props[author_GemPubProperty]);
-        appendFormat_String(out, "\n=> %s " book_Icon " Book index page\n",
-                            cstrCollect_String(concat_Path(baseUrl, props[index_GemPubProperty])));
-        if (!isEmpty_String(props[cover_GemPubProperty])) {
-            appendFormat_String(out, "\n=> %s/%s  Cover image\n",
-                                cstr_String(baseUrl),
-                                cstr_String(props[cover_GemPubProperty]));
-        }
-        appendCStr_String(out, "\n## About this book\n");
-        appendGemPubProperty_(out, "Version:", props[version_GemPubProperty]);
-        appendGemPubProperty_(out, "Revision date:", props[revisionDate_GemPubProperty]);
-        if (!isEmpty_String(props[publishDate_GemPubProperty])) {
-            appendGemPubProperty_(out, "Publish date:", props[publishDate_GemPubProperty]);
-        }
-        else {
-            appendGemPubProperty_(out, "Published:", props[published_GemPubProperty]);
-        }
-        appendGemPubProperty_(out, "Language:", props[language_GemPubProperty]);
-        appendGemPubProperty_(out, "License:", props[license_GemPubProperty]);
-        appendGemPubProperty_(out, "\u00a9", props[copyright_GemPubProperty]);
-        output = copy_Block(utf8_String(out));
-        delete_String(out);
+    iGempub *gempub = new_Gempub();
+    if (open_Gempub(gempub, source)) {
+        setBaseUrl_Gempub(gempub, requestUrl);
+        output = newCStr_Block("20 text/gemini; charset=utf-8\r\n");
+        append_Block(output, collect_Block(coverPageSource_Gempub(gempub)));
     }
-cleanup:
-    iRelease(arch);
+    delete_Gempub(gempub);
     return output;
 }
 
 /*----------------------------------------------------------------------------------------------*/
 
-static const char *gpubMimeType_MimeHooks_      = "application/gpub+zip";
 static const char *mimeHooksFilename_MimeHooks_ = "mimehooks.txt";
 
 struct Impl_MimeHooks {
@@ -331,7 +239,7 @@ void deinit_MimeHooks(iMimeHooks *d) {
 static iBool checkGemPub_(const iString *mime, const iString *requestUrl) {
     /* Only process GemPub in local files. */
     return (equalCase_Rangecc(urlScheme_String(requestUrl), "file") &&
-            startsWithCase_String(mime, gpubMimeType_MimeHooks_));
+            startsWithCase_String(mime, mimeType_Gempub));
 }
 
 iBool willTryFilter_MimeHooks(const iMimeHooks *d, const iString *mime) {
@@ -367,7 +275,7 @@ iBlock *tryFilter_MimeHooks(const iMimeHooks *d, const iString *mime, const iBlo
     }
     /* Built-in filters. */
     if (checkGemPub_(mime, requestUrl)) {
-        iBlock *result = translateGemPubCoverPage_(mime, body, requestUrl);
+        iBlock *result = translateGemPubCoverPage_(body, requestUrl);
         if (result) {
             return result;
         }
diff --git a/src/ui/documentwidget.c b/src/ui/documentwidget.c
index 410b793e..f146a2df 100644
--- a/src/ui/documentwidget.c
+++ b/src/ui/documentwidget.c
@@ -30,6 +30,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
 #include "bookmarks.h"
 #include "command.h"
 #include "defs.h"
+#include "gempub.h"
 #include "gmcerts.h"
 #include "gmdocument.h"
 #include "gmrequest.h"
@@ -1051,7 +1052,7 @@ static void updateFetchProgress_DocumentWidget_(iDocumentWidget *d) {
 
 static const char *zipPageHeading_(const iRangecc mime) {
     if (equalCase_Rangecc(mime, "application/gpub+zip")) {
-        return book_Icon " Gempub Book";
+        return book_Icon " Gempub";
     }
     iRangecc type = iNullRange;
     nextSplit_Rangecc(mime, "/", &type); /* skip the part before the slash */
@@ -1065,6 +1066,56 @@ static const char *zipPageHeading_(const iRangecc mime) {
     return cstrCollect_String(heading);
 }
 
+static void postProcessRequestContent_DocumentWidget_(iDocumentWidget *d) {
+    if (!cmpCase_String(&d->sourceMime, "application/octet-stream") ||
+        !cmpCase_String(&d->sourceMime, mimeType_Gempub) ||
+        endsWithCase_String(d->mod.url, ".gpub")) {
+        iGempub *gempub = new_Gempub();
+        if (open_Gempub(gempub, &d->sourceContent)) {
+            setBaseUrl_Gempub(gempub, d->mod.url);
+            /* TODO: just return a String from coverPageSource_Gempub... */
+            setSource_DocumentWidget(d, collect_String(newBlock_String(collect_Block(coverPageSource_Gempub(gempub)))));
+            setCStr_String(&d->sourceMime, mimeType_Gempub);
+        }
+        delete_Gempub(gempub);
+    }
+    /* Gempub: Preload cover image. */ {
+        /* TODO: move to gempub.c along with other related code */
+        iString *localPath = localFilePathFromUrl_String(d->mod.url);
+        if (localPath) {
+            if (!iCmpStr(mediaType_Path(localPath), "application/gpub+zip")) {
+                iArchive *arch = iClob(new_Archive());
+                if (openFile_Archive(arch, localPath)) {
+                    iBool haveImage = iFalse;
+                    for (size_t linkId = 1; ; linkId++) {
+                        const iString *linkUrl = linkUrl_GmDocument(d->doc, linkId);
+                        if (!linkUrl) break;
+                        if (findLinkImage_Media(media_GmDocument(d->doc), linkId)) {
+                            continue; /* got this already */
+                        }
+                        if (linkFlags_GmDocument(d->doc, linkId) & imageFileExtension_GmLinkFlag) {
+                            iString *imgEntryPath = collect_String(localFilePathFromUrl_String(linkUrl));
+                            remove_Block(&imgEntryPath->chars, 0, size_String(localPath) + 1 /* slash, too */);
+                            setData_Media(media_GmDocument(d->doc),
+                                          linkId,
+                                          collectNewCStr_String(mediaType_Path(linkUrl)),
+                                          data_Archive(arch, imgEntryPath),
+                                          0);
+                            haveImage = iTrue;
+                        }
+                    }
+                    if (haveImage) {
+                        redoLayout_GmDocument(d->doc);
+                        updateVisible_DocumentWidget_(d);
+                        invalidate_DocumentWidget_(d);
+                    }
+                }
+            }
+            delete_String(localPath);
+        }
+    }
+}
+
 static void updateDocument_DocumentWidget_(iDocumentWidget *d, const iGmResponse *response,
                                            const iBool isInitialUpdate) {
     if (d->state == ready_RequestState) {
@@ -1113,12 +1164,17 @@ static void updateDocument_DocumentWidget_(iDocumentWidget *d, const iGmResponse
                     iString *key = collectNew_String();
                     toString_Sym(SDLK_s, KMOD_PRIMARY, key);
                     format_String(&str, "# %s\n"
-                                  "%s is a compressed archive.\n\n%s\n\n",
+                                  "%s is a compressed archive.\n\n",
                                   zipPageHeading_(param),
-                                  cstr_Rangecc(baseName_Path(d->mod.url)),
-                                  format_CStr(cstr_Lang("error.unsupported.suggestsave"),
-                                              cstr_String(key),
-                                              saveToDownloads_Label));
+                                  cstr_Rangecc(baseName_Path(d->mod.url)));
+                    iString *localPath = localFilePathFromUrl_String(d->mod.url);
+                    if (!localPath) {
+                        appendFormat_String(&str, "%s\n\n",
+                                            format_CStr(cstr_Lang("error.unsupported.suggestsave"),
+                                                        cstr_String(key),
+                                                        saveToDownloads_Label));
+                    }
+                    delete_String(localPath);
                     if (equalCase_Rangecc(urlScheme_String(d->mod.url), "file")) {
                         appendFormat_String(&str, "=> %s/ View archive contents\n",
                                             cstr_String(withSpacesEncoded_String(d->mod.url)));
@@ -1188,43 +1244,6 @@ static void updateDocument_DocumentWidget_(iDocumentWidget *d, const iGmResponse
         if (setSource) {
             setSource_DocumentWidget(d, &str);
         }
-        if (isRequestFinished) {
-            /* Gempub: Preload cover image. */ {
-                /* TODO: move to a gempub.c along with other related code */
-                iString *localPath = localFilePathFromUrl_String(d->mod.url);
-                if (localPath) {
-                    if (!iCmpStr(mediaTypeFromPath_String(localPath), "application/gpub+zip")) {
-                        iArchive *arch = iClob(new_Archive());
-                        if (openFile_Archive(arch, localPath)) {
-                            iBool haveImage = iFalse;
-                            for (size_t linkId = 1; ; linkId++) {
-                                const iString *linkUrl = linkUrl_GmDocument(d->doc, linkId);
-                                if (!linkUrl) break;
-                                if (findLinkImage_Media(media_GmDocument(d->doc), linkId)) {
-                                    continue; /* got this already */
-                                }
-                                if (linkFlags_GmDocument(d->doc, linkId) & imageFileExtension_GmLinkFlag) {
-                                    iString *imgEntryPath = collect_String(localFilePathFromUrl_String(linkUrl));
-                                    remove_Block(&imgEntryPath->chars, 0, size_String(localPath) + 1 /* slash, too */);
-                                    setData_Media(media_GmDocument(d->doc),
-                                                  linkId,
-                                                  collectNewCStr_String(mediaTypeFromPath_String(linkUrl)),
-                                                  data_Archive(arch, imgEntryPath),
-                                                  0);
-                                    haveImage = iTrue;
-                                }
-                            }
-                            if (haveImage) {
-                                redoLayout_GmDocument(d->doc);
-                                updateVisible_DocumentWidget_(d);
-                                invalidate_DocumentWidget_(d);
-                            }
-                        }
-                    }
-                    delete_String(localPath);
-                }
-            }
-        }
         deinit_String(&str);
     }
 }
@@ -1291,8 +1310,13 @@ static void cacheRunGlyphs_(void *data, const iGmRun *run) {
 }
 
 static void cacheDocumentGlyphs_DocumentWidget_(const iDocumentWidget *d) {
-    if (isExposed_Window(get_Window())) {
-        render_GmDocument(d->doc, (iRangei){ 0, size_GmDocument(d->doc).y }, cacheRunGlyphs_, NULL);
+    if (isFinishedLaunching_App() && isExposed_Window(get_Window())) {
+        /* Just cache the top of the document, since this is what we usually need. */
+        int maxY = height_Widget(&d->widget) * 2;
+        if (maxY == 0) {
+            maxY = size_GmDocument(d->doc).y;
+        }
+        render_GmDocument(d->doc, (iRangei){ 0, maxY }, cacheRunGlyphs_, NULL);
     }
 }
 
@@ -1302,26 +1326,28 @@ static iBool updateFromHistory_DocumentWidget_(iDocumentWidget *d) {
         const iGmResponse *resp = recent->cachedResponse;
         clear_ObjectList(d->media);
         reset_GmDocument(d->doc);
-        d->state = fetching_RequestState;
-        d->initNormScrollY = recent->normScrollY;
         resetWideRuns_DocumentWidget_(d);
-        /* Use the cached response data. */
-        updateTrust_DocumentWidget_(d, resp);
-        d->sourceTime = resp->when;
-        d->sourceStatus = success_GmStatusCode;
-        format_String(&d->sourceHeader, cstr_Lang("pageinfo.header.cached"));
-        d->drawBufs->flags |= updateTimestampBuf_DrawBufsFlag;
-        set_Block(&d->sourceContent, &resp->body);
-        updateDocument_DocumentWidget_(d, resp, iTrue);
-        init_Anim(&d->altTextOpacity, 0);
+        d->state = fetching_RequestState;
+        /* Do the fetch. */ {
+            d->initNormScrollY = recent->normScrollY;
+            /* Use the cached response data. */
+            updateTrust_DocumentWidget_(d, resp);
+            d->sourceTime   = resp->when;
+            d->sourceStatus = success_GmStatusCode;
+            format_String(&d->sourceHeader, cstr_Lang("pageinfo.header.cached"));
+            set_Block(&d->sourceContent, &resp->body);
+            updateDocument_DocumentWidget_(d, resp, iTrue);
+            postProcessRequestContent_DocumentWidget_(d);
+        }
         d->state = ready_RequestState;
+        init_Anim(&d->altTextOpacity, 0);
         reset_SmoothScroll(&d->scrollY);
         init_Anim(&d->scrollY.pos, d->initNormScrollY * size_GmDocument(d->doc).y);
         updateSideOpacity_DocumentWidget_(d, iFalse);
-        d->drawBufs->flags |= updateSideBuf_DrawBufsFlag;
         updateVisible_DocumentWidget_(d);
         moveSpan_SmoothScroll(&d->scrollY, 0, 0); /* clamp position to new max */
         cacheDocumentGlyphs_DocumentWidget_(d);
+        d->drawBufs->flags |= updateTimestampBuf_DrawBufsFlag | updateSideBuf_DrawBufsFlag;
         postCommandf_Root(as_Widget(d)->root, "document.changed doc:%p url:%s", d, cstr_String(d->mod.url));
         return iTrue;
     }
@@ -2143,10 +2169,12 @@ static iBool handleCommand_DocumentWidget_(iDocumentWidget *d, const char *cmd)
         checkResponse_DocumentWidget_(d);
         init_Anim(&d->scrollY.pos, d->initNormScrollY * size_GmDocument(d->doc).y); /* TODO: unless user already scrolled! */
         d->state = ready_RequestState;
+        postProcessRequestContent_DocumentWidget_(d);
         /* The response may be cached. */
         if (d->request) {
             if (!equal_Rangecc(urlScheme_String(d->mod.url), "about") &&
-                startsWithCase_String(meta_GmRequest(d->request), "text/")) {
+                (startsWithCase_String(meta_GmRequest(d->request), "text/") ||
+                 !cmp_String(&d->sourceMime, mimeType_Gempub))) {
                 setCachedResponse_History(d->mod.history, lockResponse_GmRequest(d->request));
                 unlockResponse_GmRequest(d->request);
             }
@@ -2856,6 +2884,7 @@ static iBool processEvent_DocumentWidget_(iDocumentWidget *d, const SDL_Event *e
                             0, 0, NULL });
                     }
                     if (willUseProxy_App(scheme) || isGemini ||
+                        equalCase_Rangecc(scheme, "file") ||
                         equalCase_Rangecc(scheme, "finger") ||
                         equalCase_Rangecc(scheme, "gopher")) {
                         isNative = iTrue;