unofficial mirror of emacs-devel@gnu.org 
 help / color / mirror / code / Atom feed
* {PATCH] continuous scroll for doc-view (FOR REVIEW))
@ 2022-01-13 10:53 dalanicolai
  2022-01-13 10:58 ` dalanicolai
  2022-01-14  8:03 ` Juri Linkov
  0 siblings, 2 replies; 9+ messages in thread
From: dalanicolai @ 2022-01-13 10:53 UTC (permalink / raw)
  To: Emacs Devel

[-- Attachment #1: Type: text/plain, Size: 4145 bytes --]

I am not sure how to best handle this, but I figured I'll better keep you
involved (get feedback better sooner than later).

So I have got the code for a first 'working' example for the continuous
scroll.

Let me comment a little first:
So I've started from the Proof of Concept here
<https://github.com/dalanicolai/bookroll.el>, on which I commented
on more already in the thread here
<https://lists.gnu.org/archive/html/emacs-devel/2022-01/msg00663.html>
(original thread is here
<https://lists.gnu.org/archive/html/emacs-devel/2021-12/msg00938.html>).


A very short, but 'noteworthy' digression ...

I'd really like to mention that I get no hits when searching for that thread
<https://lists.gnu.org/archive/cgi-bin/namazu.cgi?query=Multi+image+PDF&submit=Search%21&idxname=emacs-devel&max=20&result=normal&sort=score>
(actually searching
for 'the original thread') when searching on `multi image PDF` in the Emacs
devel archive.
(This time) it is not due to too many results. Would be great if you could
inform me why that
does not work.


Back to the main subject...

So I will attach two files here, the first is an 'adapted' bookroll.el
file, and the second is a
a modified doc-view file that implements the first 'rudimentary' continuous
scroll for PDF
documents(despite the subject title of this message, I am simply attaching
the file,
as you can then more simply load and try it, while I guess you must be
capable of diffing it with
the latest doc-view.el file yourself ;).
For, now it only works on PDF documents (I hope all of them), because I
have to find good 'splitting points' for the various overlays (this was the
original approach
that I'd used in pdf-view, I prefer to keep the document it's contents in
the buffer and drawing
the overlays over it). For other types of documents I've tried to
'determine' split points using `forward-line`, but that did not give
satisfactory results.

I am not sure if the bookroll-mode should be a separate package (like
image-mode),
or that it could just get merged into doc-view. But it is as it is for the
development process.

So now some comments on the files/approach:

To understand the approach of bookmark.el, it is probably most useful to
look at the Proof
of Concept file to which I have linked already above. It simply draws a
triplet of images (pages)
for each page (and a doublet for the first and last pages), and then it
uses a 'currently-displayed-images' list, and refreshes pages when
necessary by comparing with that list. The current page is the page that
takes more than half of the window height.

In the single page doc-view there is a single overlay, that informs via its
properties many doc-view functions about which step to take next (it
controls the doc-view 'process'). In the bookroll
doc-view version, This overlay is kept as a 'control' overlay, which is not
used for containing images. The overlays for 'holding' the images are in
the `overlay-list`. (Although this solution
for the control overlay looks simple, it took me quite some investigation
and error and trial to
come up with it, which is also to say that I think it is a nice solution).

For now, the scrolling is too continuous (i.e. now separation indicator
between the pages), but I
am planning to embed the files in svg images (as I have done in djvu3.el
<https://github.com/dalanicolai/djvu3>), so that it will be easy
to draw a line between the pages

So, anyone who is interested can have a look at the code, and of course any
feedback and suggestions are welcome I am no experienced programmer, and I
am also fairly new to Emacs
(actually Spacemacs which I think is (also) a really great project). I am
only able to do this because of your great (documentation) work :) If you
find things that looks like 'bad developing
process practice', then I am very happy with good/better suggestions.

As I have to take care of 'fixing' the 'resizing/scaling/zoom'
functionality now, any comments
ideas on that part would be welcome in particular...

Quite obviously, to test it, load the bookmark.el file, then load the
doc-view.el file, open some PDF document and start scrolling using `j`/`k`.

[-- Attachment #2: Type: text/html, Size: 5037 bytes --]

^ permalink raw reply	[flat|nested] 9+ messages in thread

* Re: {PATCH] continuous scroll for doc-view (FOR REVIEW))
  2022-01-13 10:53 {PATCH] continuous scroll for doc-view (FOR REVIEW)) dalanicolai
@ 2022-01-13 10:58 ` dalanicolai
  2022-01-13 11:08   ` dalanicolai
  2022-01-14  8:03 ` Juri Linkov
  1 sibling, 1 reply; 9+ messages in thread
From: dalanicolai @ 2022-01-13 10:58 UTC (permalink / raw)
  To: Emacs Devel

[-- Attachment #1: Type: text/plain, Size: 4640 bytes --]

I have more or less no experiences with patches, so I hope you don't mind
that I am just quickly ask here;
so are (or can be) these kind of 'subcommits' and their commit messages
part of some final patch. Or is
there some other way to handle it?

On Thu, 13 Jan 2022 at 11:53, dalanicolai <dalanicolai@gmail.com> wrote:

> I am not sure how to best handle this, but I figured I'll better keep you
> involved (get feedback better sooner than later).
>
> So I have got the code for a first 'working' example for the continuous
> scroll.
>
> Let me comment a little first:
> So I've started from the Proof of Concept here
> <https://github.com/dalanicolai/bookroll.el>, on which I commented
> on more already in the thread here
> <https://lists.gnu.org/archive/html/emacs-devel/2022-01/msg00663.html>
> (original thread is here
> <https://lists.gnu.org/archive/html/emacs-devel/2021-12/msg00938.html>).
>
>
> A very short, but 'noteworthy' digression ...
>
> I'd really like to mention that I get no hits when searching for that
> thread
> <https://lists.gnu.org/archive/cgi-bin/namazu.cgi?query=Multi+image+PDF&submit=Search%21&idxname=emacs-devel&max=20&result=normal&sort=score>
> (actually searching
> for 'the original thread') when searching on `multi image PDF` in the
> Emacs devel archive.
> (This time) it is not due to too many results. Would be great if you could
> inform me why that
> does not work.
>
>
> Back to the main subject...
>
> So I will attach two files here, the first is an 'adapted' bookroll.el
> file, and the second is a
> a modified doc-view file that implements the first 'rudimentary'
> continuous scroll for PDF
> documents(despite the subject title of this message, I am simply attaching
> the file,
> as you can then more simply load and try it, while I guess you must be
> capable of diffing it with
> the latest doc-view.el file yourself ;).
> For, now it only works on PDF documents (I hope all of them), because I
> have to find good 'splitting points' for the various overlays (this was
> the original approach
> that I'd used in pdf-view, I prefer to keep the document it's contents in
> the buffer and drawing
> the overlays over it). For other types of documents I've tried to
> 'determine' split points using `forward-line`, but that did not give
> satisfactory results.
>
> I am not sure if the bookroll-mode should be a separate package (like
> image-mode),
> or that it could just get merged into doc-view. But it is as it is for the
> development process.
>
> So now some comments on the files/approach:
>
> To understand the approach of bookmark.el, it is probably most useful to
> look at the Proof
> of Concept file to which I have linked already above. It simply draws a
> triplet of images (pages)
> for each page (and a doublet for the first and last pages), and then it
> uses a 'currently-displayed-images' list, and refreshes pages when
> necessary by comparing with that list. The current page is the page that
> takes more than half of the window height.
>
> In the single page doc-view there is a single overlay, that informs via
> its properties many doc-view functions about which step to take next (it
> controls the doc-view 'process'). In the bookroll
> doc-view version, This overlay is kept as a 'control' overlay, which is
> not used for containing images. The overlays for 'holding' the images are
> in the `overlay-list`. (Although this solution
> for the control overlay looks simple, it took me quite some investigation
> and error and trial to
> come up with it, which is also to say that I think it is a nice solution).
>
> For now, the scrolling is too continuous (i.e. now separation indicator
> between the pages), but I
> am planning to embed the files in svg images (as I have done in djvu3.el
> <https://github.com/dalanicolai/djvu3>), so that it will be easy
> to draw a line between the pages
>
> So, anyone who is interested can have a look at the code, and of course
> any feedback and suggestions are welcome I am no experienced programmer,
> and I am also fairly new to Emacs
> (actually Spacemacs which I think is (also) a really great project). I am
> only able to do this because of your great (documentation) work :) If you
> find things that looks like 'bad developing
> process practice', then I am very happy with good/better suggestions.
>
> As I have to take care of 'fixing' the 'resizing/scaling/zoom'
> functionality now, any comments
> ideas on that part would be welcome in particular...
>
> Quite obviously, to test it, load the bookmark.el file, then load the
> doc-view.el file, open some PDF document and start scrolling using `j`/`k`.
>

[-- Attachment #2: Type: text/html, Size: 5766 bytes --]

^ permalink raw reply	[flat|nested] 9+ messages in thread

* Re: {PATCH] continuous scroll for doc-view (FOR REVIEW))
  2022-01-13 10:58 ` dalanicolai
@ 2022-01-13 11:08   ` dalanicolai
  0 siblings, 0 replies; 9+ messages in thread
From: dalanicolai @ 2022-01-13 11:08 UTC (permalink / raw)
  To: Emacs Devel

[-- Attachment #1: Type: text/plain, Size: 5426 bytes --]

Actually, I am not sure where I will focus on next. I think in pdf-tools,
the scaling part is already correctly taken
care of without extra work (while fixing that would probably take me a lot
of time in doc-view). Also, I have
mailed the current maintainer about merging pdf-tools into Emacs, and he is
certainly willing to do that
(and try to get Andread Politza, its original developer, to sign the
papers). So, I think that I will/should focus
now again on trying to get this working, fully, in pdf-tools (and see this
as a helpful exercise, pdf-tools for
sure is partly based on doc-view code).

On Thu, 13 Jan 2022 at 11:58, dalanicolai <dalanicolai@gmail.com> wrote:

> I have more or less no experiences with patches, so I hope you don't mind
> that I am just quickly ask here;
> so are (or can be) these kind of 'subcommits' and their commit messages
> part of some final patch. Or is
> there some other way to handle it?
>
> On Thu, 13 Jan 2022 at 11:53, dalanicolai <dalanicolai@gmail.com> wrote:
>
>> I am not sure how to best handle this, but I figured I'll better keep you
>> involved (get feedback better sooner than later).
>>
>> So I have got the code for a first 'working' example for the continuous
>> scroll.
>>
>> Let me comment a little first:
>> So I've started from the Proof of Concept here
>> <https://github.com/dalanicolai/bookroll.el>, on which I commented
>> on more already in the thread here
>> <https://lists.gnu.org/archive/html/emacs-devel/2022-01/msg00663.html>
>> (original thread is here
>> <https://lists.gnu.org/archive/html/emacs-devel/2021-12/msg00938.html>).
>>
>>
>> A very short, but 'noteworthy' digression ...
>>
>> I'd really like to mention that I get no hits when searching for that
>> thread
>> <https://lists.gnu.org/archive/cgi-bin/namazu.cgi?query=Multi+image+PDF&submit=Search%21&idxname=emacs-devel&max=20&result=normal&sort=score>
>> (actually searching
>> for 'the original thread') when searching on `multi image PDF` in the
>> Emacs devel archive.
>> (This time) it is not due to too many results. Would be great if you
>> could inform me why that
>> does not work.
>>
>>
>> Back to the main subject...
>>
>> So I will attach two files here, the first is an 'adapted' bookroll.el
>> file, and the second is a
>> a modified doc-view file that implements the first 'rudimentary'
>> continuous scroll for PDF
>> documents(despite the subject title of this message, I am simply
>> attaching the file,
>> as you can then more simply load and try it, while I guess you must be
>> capable of diffing it with
>> the latest doc-view.el file yourself ;).
>> For, now it only works on PDF documents (I hope all of them), because I
>> have to find good 'splitting points' for the various overlays (this was
>> the original approach
>> that I'd used in pdf-view, I prefer to keep the document it's contents in
>> the buffer and drawing
>> the overlays over it). For other types of documents I've tried to
>> 'determine' split points using `forward-line`, but that did not give
>> satisfactory results.
>>
>> I am not sure if the bookroll-mode should be a separate package (like
>> image-mode),
>> or that it could just get merged into doc-view. But it is as it is for
>> the development process.
>>
>> So now some comments on the files/approach:
>>
>> To understand the approach of bookmark.el, it is probably most useful to
>> look at the Proof
>> of Concept file to which I have linked already above. It simply draws a
>> triplet of images (pages)
>> for each page (and a doublet for the first and last pages), and then it
>> uses a 'currently-displayed-images' list, and refreshes pages when
>> necessary by comparing with that list. The current page is the page that
>> takes more than half of the window height.
>>
>> In the single page doc-view there is a single overlay, that informs via
>> its properties many doc-view functions about which step to take next (it
>> controls the doc-view 'process'). In the bookroll
>> doc-view version, This overlay is kept as a 'control' overlay, which is
>> not used for containing images. The overlays for 'holding' the images are
>> in the `overlay-list`. (Although this solution
>> for the control overlay looks simple, it took me quite some investigation
>> and error and trial to
>> come up with it, which is also to say that I think it is a nice solution).
>>
>> For now, the scrolling is too continuous (i.e. now separation indicator
>> between the pages), but I
>> am planning to embed the files in svg images (as I have done in djvu3.el
>> <https://github.com/dalanicolai/djvu3>), so that it will be easy
>> to draw a line between the pages
>>
>> So, anyone who is interested can have a look at the code, and of course
>> any feedback and suggestions are welcome I am no experienced programmer,
>> and I am also fairly new to Emacs
>> (actually Spacemacs which I think is (also) a really great project). I am
>> only able to do this because of your great (documentation) work :) If you
>> find things that looks like 'bad developing
>> process practice', then I am very happy with good/better suggestions.
>>
>> As I have to take care of 'fixing' the 'resizing/scaling/zoom'
>> functionality now, any comments
>> ideas on that part would be welcome in particular...
>>
>> Quite obviously, to test it, load the bookmark.el file, then load the
>> doc-view.el file, open some PDF document and start scrolling using `j`/`k`.
>>
>

[-- Attachment #2: Type: text/html, Size: 6807 bytes --]

^ permalink raw reply	[flat|nested] 9+ messages in thread

* Re: {PATCH] continuous scroll for doc-view (FOR REVIEW))
  2022-01-13 10:53 {PATCH] continuous scroll for doc-view (FOR REVIEW)) dalanicolai
  2022-01-13 10:58 ` dalanicolai
@ 2022-01-14  8:03 ` Juri Linkov
  2022-01-14 10:44   ` dalanicolai
  1 sibling, 1 reply; 9+ messages in thread
From: Juri Linkov @ 2022-01-14  8:03 UTC (permalink / raw)
  To: dalanicolai; +Cc: Emacs Devel

> I'd really like to mention that I get no hits when searching for that
> thread (actually searching
> for 'the original thread') when searching on `multi image PDF` in the Emacs
> devel archive.
> (This time) it is not due to too many results. Would be great if you could
> inform me why that does not work.

Trying to search any recent subject shows that indexing on mailing lists
was disabled for a few last months.

> So I will attach two files here, the first is an 'adapted' bookroll.el
> file, and the second is a
> a modified doc-view file that implements the first 'rudimentary' continuous
> scroll for PDF
> documents(despite the subject title of this message, I am simply attaching
> the file,
> as you can then more simply load and try it, while I guess you must be
> capable of diffing it with
> the latest doc-view.el file yourself ;).

Thanks, if you want you could attach whole files, because program files
take almost no space on mailing list archives, so this is not a problem
(the problem is when someone posts large screenshots, and even a video).

Or you can just make a copy of doc-view.el in your repository,
and send a message when you update it.

> I am not sure if the bookroll-mode should be a separate package (like image-mode),
> or that it could just get merged into doc-view. But it is as it is for the
> development process.

If it could be used for other images such as for image galleries,
then it should be a separate package like image-mode.

> To understand the approach of bookmark.el, it is probably most useful to
> look at the Proof
> of Concept file to which I have linked already above. It simply draws a
> triplet of images (pages)
> for each page (and a doublet for the first and last pages), and then it
> uses a 'currently-displayed-images' list, and refreshes pages when
> necessary by comparing with that list. The current page is the page that
> takes more than half of the window height.

A triplet or a doublet means that the scroll bar can't be used for
scrolling all pages?  Have you tried to prefill with overlays for all pages?



^ permalink raw reply	[flat|nested] 9+ messages in thread

* Re: {PATCH] continuous scroll for doc-view (FOR REVIEW))
  2022-01-14  8:03 ` Juri Linkov
@ 2022-01-14 10:44   ` dalanicolai
  2022-01-14 11:03     ` dalanicolai
  2022-01-15 18:13     ` Juri Linkov
  0 siblings, 2 replies; 9+ messages in thread
From: dalanicolai @ 2022-01-14 10:44 UTC (permalink / raw)
  To: Juri Linkov; +Cc: Emacs Devel


[-- Attachment #1.1: Type: text/plain, Size: 3745 bytes --]

>
> Thanks, if you want you could attach whole files, because program files
> take almost no space on mailing list archives, so this is not a problem
> (the problem is when someone posts large screenshots, and even a video).
>

I wanted to do that already... terrible how in the end I did forget to
attach the files...


> If it could be used for other images such as for image galleries,
> then it should be a separate package like image-mode.
>

Well, I think I really wouldn't want continuous scroll for images. So I
think a separate
library for image galleries would be better. I think the logic for only
showing full images
is a slightly simpler and therefore could be made more flexible. Creating
the overlays is
really just a few lines. But I am not sure, how exactly the code for an
image gallery
should look like. Maybe in the end, some code could be shared.

A triplet or a doublet means that the scroll bar can't be used for
> scrolling all pages?  Have you tried to prefill with overlays for all
> pages?
>

Yes, like in the Proof of Concept, all overlays are inserted at once, but
they are 'triplet'
only showing a triplet of images at the time. So the full buffer can be
scrolled with the
mouse/scroll-bar, but for some reason updating the images in that case does
not seem
to work yet (although from the code I would expect it should).

Anyway, This time I'll send the message including the attachments... you
can have a look
(see first message for instructions, if necessary).


On Fri, 14 Jan 2022 at 09:19, Juri Linkov <juri@linkov.net> wrote:

> > I'd really like to mention that I get no hits when searching for that
> > thread (actually searching
> > for 'the original thread') when searching on `multi image PDF` in the
> Emacs
> > devel archive.
> > (This time) it is not due to too many results. Would be great if you
> could
> > inform me why that does not work.
>
> Trying to search any recent subject shows that indexing on mailing lists
> was disabled for a few last months.
>
> > So I will attach two files here, the first is an 'adapted' bookroll.el
> > file, and the second is a
> > a modified doc-view file that implements the first 'rudimentary'
> continuous
> > scroll for PDF
> > documents(despite the subject title of this message, I am simply
> attaching
> > the file,
> > as you can then more simply load and try it, while I guess you must be
> > capable of diffing it with
> > the latest doc-view.el file yourself ;).
>
> Thanks, if you want you could attach whole files, because program files
> take almost no space on mailing list archives, so this is not a problem
> (the problem is when someone posts large screenshots, and even a video).
>
> Or you can just make a copy of doc-view.el in your repository,
> and send a message when you update it.
>
> > I am not sure if the bookroll-mode should be a separate package (like
> image-mode),
> > or that it could just get merged into doc-view. But it is as it is for
> the
> > development process.
>
> If it could be used for other images such as for image galleries,
> then it should be a separate package like image-mode.
>
> > To understand the approach of bookmark.el, it is probably most useful to
> > look at the Proof
> > of Concept file to which I have linked already above. It simply draws a
> > triplet of images (pages)
> > for each page (and a doublet for the first and last pages), and then it
> > uses a 'currently-displayed-images' list, and refreshes pages when
> > necessary by comparing with that list. The current page is the page that
> > takes more than half of the window height.
>
> A triplet or a doublet means that the scroll bar can't be used for
> scrolling all pages?  Have you tried to prefill with overlays for all
> pages?
>

[-- Attachment #1.2: Type: text/html, Size: 4976 bytes --]

[-- Attachment #2: doc-view.el --]
[-- Type: text/x-emacs-lisp, Size: 96141 bytes --]

;;; doc-view.el --- Document viewer for Emacs -*- lexical-binding: t -*-

;; Copyright (C) 2007-2022 Free Software Foundation, Inc.
;;
;; Author: Tassilo Horn <tsdh@gnu.org>
;; Keywords: files, pdf, ps, dvi

;; This file is part of GNU Emacs.

;; GNU Emacs is free software: you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation, either version 3 of the License, or
;; (at your option) any later version.

;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.

;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.

;;; Requirements:

;; Viewing PS/PDF/DVI files requires Ghostscript, `dvipdf' (comes with
;; Ghostscript) or `dvipdfm' (comes with teTeX or TeXLive) and
;; `pdftotext', which comes with xpdf (https://www.foolabs.com/xpdf/)
;; or poppler (https://poppler.freedesktop.org/).
;; Djvu documents require `ddjvu' (from DjVuLibre).
;; ODF files require `soffice' (from LibreOffice).

;;; Commentary:

;; DocView is a document viewer for Emacs.  It converts a number of
;; document formats (including PDF, PS, DVI, Djvu and ODF files) to a
;; set of PNG files, one PNG for each page, and displays the PNG
;; images inside an Emacs buffer.  This buffer uses `doc-view-mode'
;; which provides convenient key bindings for browsing the document.
;;
;; To use it simply open a document file with
;;
;;     C-x C-f ~/path/to/document RET
;;
;; and the document will be converted and displayed, if your Emacs supports PNG
;; images.  With `C-c C-c' you can toggle between the rendered images
;; representation and the source text representation of the document.
;;
;; Since conversion may take some time all the PNG images are cached in a
;; subdirectory of `doc-view-cache-directory' and reused when you want to view
;; that file again.  To reconvert a document hit `g' (`doc-view-reconvert-doc')
;; when displaying the document.  To delete all cached files use
;; `doc-view-clear-cache'.  To open the cache with dired, so that you can tidy
;; it out use `doc-view-dired-cache'.
;;
;; When conversion is underway the first page will be displayed as soon as it
;; is available and the available pages are refreshed every
;; `doc-view-conversion-refresh-interval' seconds.  If that variable is nil the
;; pages won't be displayed before conversion of the document finished
;; completely.
;;
;; DocView lets you select a slice of the displayed pages.  This slice
;; will be remembered and applied to all pages of the current
;; document.  This enables you to cut away the margins of a document
;; to save some space.  To select a slice you can use
;; `doc-view-set-slice' (bound to `c s') which will query you for the
;; coordinates of the slice's top-left corner and its width and
;; height.  A much more convenient way to do the same is offered by
;; the command `doc-view-set-slice-using-mouse' (bound to `c m').
;; After invocation you only have to press mouse-1 at the top-left
;; corner and drag it to the bottom-right corner of the desired slice.
;; Even more accurate and convenient is to use
;; `doc-view-set-slice-from-bounding-box' (bound to `c b') which uses
;; the BoundingBox information of the current page to set an optimal
;; slice.  To reset the slice use `doc-view-reset-slice' (bound to `c
;; r').
;;
;; You can also search within the document.  The command `doc-view-search'
;; (bound to `C-s') queries for a search regexp and initializes a list of all
;; matching pages and messages how many match-pages were found.  After that you
;; can jump to the next page containing a match with an additional `C-s'.  With
;; `C-r' you can do the same, but backwards.  To search for a new regexp give a
;; prefix arg to one of the search functions, e.g. by typing `C-u C-s'.  The
;; searching works by using a plain text representation of the document.  If
;; that doesn't already exist the first invocation of `doc-view-search' (or
;; `doc-view-search-backward') starts the conversion.  When that finishes and
;; you're still viewing the document (i.e. you didn't switch to another buffer)
;; you're queried for the regexp then.
;;
;; Dired users can simply hit `v' on a document file.  If it's a PS, PDF or DVI
;; it will be opened using `doc-view-mode'.
;;

;;; Configuration:

;; If the images are too small or too big you should set the "-rXXX" option in
;; `doc-view-ghostscript-options' to another value.  (The bigger your screen,
;; the higher the value.)
;;
;; This and all other options can be set with the customization interface.
;; Simply do
;;
;;     M-x customize-group RET doc-view RET
;;
;; and modify them to your needs.

;;; Todo:

;; - add print command.
;; - share more code with bookroll-mode.
;; - better menu.
;; - Bind slicing to a drag event.
;; - zoom the region around the cursor (like xdvi).
;; - get rid of the silly arrow in the fringe.
;; - improve anti-aliasing (pdf-utils gets it better).

;;;; About isearch support

;; I tried implementing isearch by setting
;; `isearch-search-fun-function' buffer-locally, but that didn't
;; work too good.  The function doing the real search was called
;; endlessly somehow.  But even if we'd get that working no real
;; isearch feeling comes up due to the missing match highlighting.
;; Currently I display all lines containing a match in a tooltip and
;; each C-s or C-r jumps directly to the next/previous page with a
;; match.  With isearch we could only display the current match.  So
;; we had to decide if another C-s jumps to the next page with a
;; match (thus only the first match in a page will be displayed in a
;; tooltip) or to the next match, which would do nothing visible
;; (except the tooltip) if the next match is on the same page.

;; And it's much slower than the current search facility, because
;; isearch really searches for each step forward or backward whereas
;; the current approach searches once and then it knows to which
;; pages to jump.

;; Anyway, if someone with better isearch knowledge wants to give it a try,
;; feel free to do it.  --Tassilo

;;; Code:

(require 'cl-lib)
(require 'dired)
;; TODO uncomment: (require 'bookroll-mode)
(require 'jka-compr)
(eval-when-compile (require 'subr-x))

;;;; Customization Options

(defgroup doc-view nil
  "In-buffer viewer for PDF, PostScript, DVI, and DJVU files."
  :link '(function-link doc-view)
  :version "22.2"
  :group 'applications
  :group 'data
  :group 'multimedia
  :prefix "doc-view-")

(defcustom doc-view-ghostscript-program
  (cond
   ((memq system-type '(windows-nt ms-dos))
    (cond
     ;; Windows Ghostscript
     ((executable-find "gswin64c") "gswin64c")
     ((executable-find "gswin32c") "gswin32c")
     ;; The GS wrapper coming with TeX Live
     ((executable-find "rungs") "rungs")
     ;; The MikTeX builtin GS Check if mgs is functional for external
     ;; non-MikTeX apps.  Was available under:
     ;; http://blog.miktex.org/post/2005/04/07/Starting-mgsexe-at-the-DOS-Prompt.aspx
     ((and (executable-find "mgs")
           (= 0 (shell-command "mgs -q -dNODISPLAY -c quit")))
      "mgs")))
   (t "gs"))
  "Program to convert PS and PDF files to PNG."
  :type 'file
  :version "27.1")

(defcustom doc-view-pdfdraw-program
  (cond
   ((executable-find "pdfdraw") "pdfdraw")
   ((executable-find "mudraw") "mudraw")
   ((executable-find "mutool") "mutool")
   (t "mudraw"))
  "Name of MuPDF's program to convert PDF files to PNG."
  :type 'file
  :version "24.4")

(defcustom doc-view-pdftotext-program-args '("-raw")
  "Parameters to give to the pdftotext command."
  :version "27.1"
  :type '(repeat string))

(defcustom doc-view-pdf->png-converter-function
  (if (executable-find doc-view-pdfdraw-program)
      #'doc-view-pdf->png-converter-mupdf
    #'doc-view-pdf->png-converter-ghostscript)
  "Function to call to convert a PDF file into a PNG file."
  :type '(radio
          (function-item doc-view-pdf->png-converter-ghostscript
                         :doc "Use ghostscript")
          (function-item doc-view-pdf->png-converter-mupdf
                         :doc "Use mupdf")
          function)
  :version "24.4")

(defcustom doc-view-ghostscript-options
  '("-dSAFER" ;; Avoid security problems when rendering files from untrusted
    ;; sources.
    "-dNOPAUSE" "-dTextAlphaBits=4"
    "-dBATCH" "-dGraphicsAlphaBits=4" "-dQUIET")
  "A list of options to give to ghostscript."
  :type '(repeat string))

(defcustom doc-view-ghostscript-device "png16m"
  "Output device to give to ghostscript."
  :type 'string
  :version "27.1")

(defcustom doc-view-resolution 100
  "Dots per inch resolution used to render the documents.
Higher values result in larger images."
  :type 'number)

(defcustom doc-view-scale-internally t
  "Whether we should try to rescale images ourselves.
If nil, the document is re-rendered every time the scaling factor is modified.
This only has an effect if the image libraries linked with Emacs support
scaling."
  :version "24.4"
  :type 'boolean)

(defcustom doc-view-image-width 850
  "Default image width.
Has only an effect if `doc-view-scale-internally' is non-nil and support for
scaling is compiled into Emacs."
  :version "24.1"
  :type 'number)

(defcustom doc-view-dvipdfm-program "dvipdfm"
  "Program to convert DVI files to PDF.

DVI file will be converted to PDF before the resulting PDF is
converted to PNG.

If this and `doc-view-dvipdf-program' are set,
`doc-view-dvipdf-program' will be preferred."
  :type 'file)

(defcustom doc-view-dvipdf-program "dvipdf"
  "Program to convert DVI files to PDF.

DVI file will be converted to PDF before the resulting PDF is
converted to PNG.

If this and `doc-view-dvipdfm-program' are set,
`doc-view-dvipdf-program' will be preferred."
  :type 'file)

(define-obsolete-variable-alias 'doc-view-unoconv-program
                                'doc-view-odf->pdf-converter-program
                                "24.4")

(defcustom doc-view-odf->pdf-converter-program
  (cond
   ((executable-find "soffice") "soffice")
   ((executable-find "unoconv") "unoconv")
   (t "soffice"))
  "Program to convert any file type readable by OpenOffice.org to PDF.

Needed for viewing OpenOffice.org (and MS Office) files."
  :version "24.4"
  :type 'file)

(defcustom doc-view-odf->pdf-converter-function
  (cond
   ((string-match "unoconv\\'" doc-view-odf->pdf-converter-program)
    #'doc-view-odf->pdf-converter-unoconv)
   ((string-match "soffice\\'" doc-view-odf->pdf-converter-program)
    #'doc-view-odf->pdf-converter-soffice))
  "Function to call to convert a ODF file into a PDF file."
  :type '(radio
          (function-item doc-view-odf->pdf-converter-unoconv
                         :doc "Use unoconv")
          (function-item doc-view-odf->pdf-converter-soffice
                         :doc "Use LibreOffice")
          function)
  :version "24.4")

(defcustom doc-view-ps2pdf-program "ps2pdf"
  "Program to convert PS files to PDF.

PS files will be converted to PDF before searching is possible."
  :type 'file)

(defcustom doc-view-pdftotext-program "pdftotext"
  "Program to convert PDF files to plain text.

Needed for searching."
  :type 'file)

(defcustom doc-view-cache-directory
  (expand-file-name (format "docview%d" (user-uid))
		    temporary-file-directory)
  "The base directory, where the PNG images will be saved."
  :type 'directory)

(defvar doc-view-conversion-buffer " *doc-view conversion output*"
  "The buffer where messages from the converter programs go to.")

(defcustom doc-view-conversion-refresh-interval 1
  "Interval in seconds between refreshes of the DocView buffer while converting.
After such a refresh newly converted pages will be available for
viewing.  If set to nil there won't be any refreshes and the
pages won't be displayed before conversion of the whole document
has finished."
  :type 'integer)

(defcustom doc-view-continuous nil
  "In Continuous mode reaching the page edge advances to next/previous page.
When non-nil, scrolling a line upward at the bottom edge of the page
moves to the next page, and scrolling a line downward at the top edge
of the page moves to the previous page."
  :type 'boolean
  :version "23.2")

(defcustom doc-view-continuous-scroll t
  "TODO write docstring"
  :type 'boolean
  :version "28.1")

;;;; Internal Variables

(defvar-local doc-view--current-converter-processes nil
  "Only used internally.")

(defun doc-view-new-window-function (winprops)
  ;; (message "New window %s for buf %s" (car winprops) (current-buffer))
  (cl-assert (or (eq t (car winprops))
                 (eq (window-buffer (car winprops)) (current-buffer))))
  (let* ((ol (bookroll-mode-window-get 'overlay winprops)))
    (if ol
        (progn
          (setq ol (copy-overlay ol))
          ;; `ol' might actually be dead.
          (move-overlay ol 1 1))
      (setq ol (make-overlay 1 1 nil t))
      (overlay-put ol 'doc-view t))
    (overlay-put ol 'window (car winprops))
    (unless (windowp (car winprops))
      ;; It's a pseudo entry.  Let's make sure it's not displayed (the
      ;; `window' property is only effective if its value is a window).
      (cl-assert (eq t (car winprops)))
      (delete-overlay ol))
    ;; (message "WINP %s" winprops)
    (bookroll-mode-window-put 'overlay ol winprops)
    (unless (eq (car winprops) t)
      (setq overlays (br-create-overlays-list))
      (let ((p (bookroll-mode-window-get 'page winprops)))
        (bookroll-mode-window-put 'overlays overlays winprops)))
    ;; (message "OVERLAYS %s" (doc-view-overlays))
    (when (and (windowp (car winprops))
               (stringp (overlay-get ol 'display))
               (null doc-view--current-converter-processes))
      ;; We're not displaying an image yet, so let's do so.  This happens when
      ;; the buffer is displayed for the first time.
      ;; Don't do it if there's a conversion is running, since in that case, it
      ;; will be done later.
      (with-selected-window (car winprops)
        (doc-view-goto-page (bookroll-mode-window-get 'page t))))))

;; (defun doc-view-new-window-function (winprops)
;;   ;; (message "New window %s for buf %s" (car winprops) (current-buffer))
;;   (cl-assert (or (eq t (car winprops))
;;                  (eq (window-buffer (car winprops)) (current-buffer))))
;;   (let ((ols (bookroll-mode-window-get 'overlays winprops))
;;         (ol-i)) ;; list indexes are shifted
;;     (unless ols
;;       (setq overlays (br-create-overlays-list))
;;       (overlay-put (nth (or al) overlays) 'doc-view t))
;;     (overlay-put (car overlays) 'window (car winprops))
;;     (unless (windowp (car winprops))
;;       ;; It's a pseudo entry.  Let's make sure it's not displayed (the
;;       ;; `window' property is only effective if its value is a window).
;;       (cl-assert (eq t (car winprops)))
;;       (delete-overlay (doc-view-control-overlay)))
;;     (bookroll-mode-window-put 'overlays overlays winprops)
;;     (when (and (windowp (car winprops))
;;                ;; (stringp (overlay-get overlays 'display))
;;                (null doc-view--current-converter-processes))
;;       ;; We're not displaying an image yet, so let's do so.  This happens when
;;       ;; the buffer is displayed for the first time.
;;       ;; Don't do it if there's a conversion is running, since in that case, it
;;       ;; will be done later.
;; (br-create-placeholders))))
;;       ;; (with-selected-window (car winprops)
;;       ;;   (doc-view-goto-page (bookroll-mode-window-get 'page t))))))

(defvar-local doc-view--current-files nil
  "Only used internally.")

(defvar-local doc-view--current-timer nil
  "Only used internally.")

(defvar-local doc-view--current-cache-dir nil
  "Only used internally.")

(defvar-local doc-view--current-search-matches nil
  "Only used internally.")

(defvar doc-view--pending-cache-flush nil
  "Only used internally.")

(defvar doc-view--buffer-file-name nil
  "Only used internally.
The file name used for conversion.  Normally it's the same as
`buffer-file-name', but for remote files, compressed files and
files inside an archive it is a temporary copy of
the (uncompressed, extracted) file residing in
`doc-view-cache-directory'.")

(defvar doc-view-doc-type nil
  "The type of document in the current buffer.
Can be `dvi', `pdf', `ps', `djvu' or `odf'.")

(defvar doc-view-single-page-converter-function nil
  "Function to call to convert a single page of the document to a bitmap file.
May operate on the source document or on some intermediate (typically PDF)
conversion of it.")

(defvar-local doc-view--image-type nil
  "The type of image in the current buffer.
Can be `png' or `tiff'.")

(defvar-local doc-view--image-file-pattern nil
  "The `format' pattern of image file names.
Typically \"page-%s.png\".")

;;;; DocView Keymaps

(defvar doc-view-mode-map
  (let ((map (make-sparse-keymap)))
    (set-keymap-parent map bookroll-mode-map)
    ;; Navigation in the document
    (define-key map (kbd "n")         'doc-view-next-page)
    (define-key map (kbd "p")         'doc-view-previous-page)
    (define-key map (kbd "<next>")    'forward-page)
    (define-key map (kbd "<prior>")   'backward-page)
    (define-key map [remap forward-page]  'doc-view-next-page)
    (define-key map [remap backward-page] 'doc-view-previous-page)
    (define-key map (kbd "SPC")       'doc-view-scroll-up-or-next-page)
    (define-key map (kbd "S-SPC")     'doc-view-scroll-down-or-previous-page)
    (define-key map (kbd "DEL")       'doc-view-scroll-down-or-previous-page)
    (define-key map (kbd "C-n")       'doc-view-next-line-or-next-page)
    (define-key map (kbd "<down>")    'doc-view-next-line-or-next-page)
    (define-key map (kbd "C-p")       'doc-view-previous-line-or-previous-page)
    (define-key map (kbd "<up>")      'doc-view-previous-line-or-previous-page)
    (define-key map (kbd "M-<")       'doc-view-first-page)
    (define-key map (kbd "M->")       'doc-view-last-page)
    (define-key map [remap goto-line] 'doc-view-goto-page)
    (define-key map (kbd "RET")       'image-next-line)
    ;; Zoom in/out.
    (define-key map "+"               'doc-view-enlarge)
    (define-key map "="               'doc-view-enlarge)
    (define-key map "-"               'doc-view-shrink)
    (define-key map "0"               'doc-view-scale-reset)
    (define-key map [remap text-scale-adjust] 'doc-view-scale-adjust)
    ;; Fit the image to the window
    (define-key map "W"               'doc-view-fit-width-to-window)
    (define-key map "H"               'doc-view-fit-height-to-window)
    (define-key map "P"               'doc-view-fit-page-to-window)
    (define-key map "F"               'doc-view-fit-window-to-page) ;F = frame
    ;; Killing the buffer (and the process)
    (define-key map (kbd "k")         'image-kill-buffer)
    (define-key map (kbd "K")         'doc-view-kill-proc)
    ;; Slicing the image
    (define-key map (kbd "c s")       'doc-view-set-slice)
    (define-key map (kbd "c m")       'doc-view-set-slice-using-mouse)
    (define-key map (kbd "c b")       'doc-view-set-slice-from-bounding-box)
    (define-key map (kbd "c r")       'doc-view-reset-slice)
    ;; Centering the image
    (define-key map (kbd "c h")       'doc-view-center-page-horizontally)
    (define-key map (kbd "c v")       'doc-view-center-page-vertically)
    ;; Searching
    (define-key map (kbd "C-s")       'doc-view-search)
    (define-key map (kbd "<find>")    'doc-view-search)
    (define-key map (kbd "C-r")       'doc-view-search-backward)
    ;; Show the tooltip
    (define-key map (kbd "C-t")       'doc-view-show-tooltip)
    ;; Toggle between text and image display or editing
    (define-key map (kbd "C-c C-c")   'doc-view-toggle-display)
    ;; Open a new buffer with doc's text contents
    (define-key map (kbd "C-c C-t")   'doc-view-open-text)
    (define-key map (kbd "r")         'revert-buffer)
    map)
  "Keymap used by `doc-view-mode' when displaying a doc as a set of images.")

(define-obsolete-function-alias 'doc-view-revert-buffer #'revert-buffer "27.1")
(defvar revert-buffer-preserve-modes)
(defun doc-view--revert-buffer (orig-fun &rest args)
  "Preserve the buffer's current mode and check PDF sanity."
  (if (< undo-outer-limit (* 2 (buffer-size)))
      ;; It's normal for this operation to result in a very large undo entry.
      (setq-local undo-outer-limit (* 2 (buffer-size))))
  (cl-labels ((revert ()
                      (let ((revert-buffer-preserve-modes t))
                        (apply orig-fun args)
                        ;; Update the cached version of the pdf file,
                        ;; too.  This is the one that's used when
                        ;; rendering (bug#26996).
                        (unless (equal buffer-file-name
                                       doc-view--buffer-file-name)
                          ;; FIXME: Lars says he needed to recreate
                          ;; the dir, we should figure out why.
                          (doc-view-make-safe-dir doc-view-cache-directory)
                          (write-region nil nil doc-view--buffer-file-name)))))
    (if (and (eq 'pdf doc-view-doc-type)
             (executable-find "pdfinfo"))
        ;; We don't want to revert if the PDF file is corrupted which
        ;; might happen when it is currently recompiled from a tex
        ;; file.  (TODO: We'd like to have something like that also
        ;; for other types, at least PS, but I don't know a good way
        ;; to test if a PS file is complete.)
        (if (= 0 (call-process "pdfinfo" nil nil nil
                               doc-view--buffer-file-name))
            (revert)
          (when (called-interactively-p 'interactive)
            (message "Can't revert right now because the file is corrupted.")))
      (revert))))


(easy-menu-define doc-view-menu doc-view-mode-map
  "Menu for Doc View mode."
  '("DocView"
    ["Next page"                doc-view-next-page
     :help                      "Go to the next page"]
    ["Previous page"            doc-view-previous-page
     :help                      "Go to the previous page"]
    ("Other Navigation"
     ["Go to page..."           doc-view-goto-page
      :help                     "Go to specific page"]
     "---"
     ["First page"              doc-view-first-page
      :help                     "View the first page"]
     ["Last page"               doc-view-last-page
      :help                     "View the last page"]
     "---"
     ["Move forward"            doc-view-scroll-up-or-next-page
      :help                     "Scroll page up or go to next page"]
     ["Move backward"           doc-view-scroll-down-or-previous-page
      :help                     "Scroll page down or go to previous page"])
    ("Continuous Scrolling"
     ["Off"                     (setq doc-view-continuous nil)
      :style radio :selected    (eq doc-view-continuous nil)
      :help                     "Scrolling stops at page beginning and end"]
     ["On"		        (setq doc-view-continuous t)
      :style radio :selected    (eq doc-view-continuous t)
      :help                     "Scrolling continues to next or previous page"]
     "---"
     ["Save as Default"         (customize-save-variable 'doc-view-continuous doc-view-continuous)
      :help                     "Save current continuous scrolling option as default"]
     )
    "---"
    ("Toggle edit/display"
     ["Edit document"           doc-view-toggle-display
      :style radio :selected    (eq major-mode 'doc-view--text-view-mode)]
     ["Display document"        (lambda ()) ; ignore but show no keybinding
      :style radio :selected    (eq major-mode 'doc-view-mode)])
    ("Adjust Display"
     ["Fit to window"           doc-view-fit-page-to-window
      :help                     "Fit the image to the window"]
     ["Fit width"               doc-view-fit-width-to-window
      :help                     "Fit the image width to the window width"]
     ["Fit height"              doc-view-fit-height-to-window
      :help                     "Fit the image height to the window height"]
     "---"
     ["Enlarge"                 doc-view-enlarge
      :help                     "Enlarge the document"]
     ["Shrink"                  doc-view-shrink
      :help                     "Shrink the document"]
     "---"
     ["Set Slice"               doc-view-set-slice-using-mouse
      :help                     "Set the slice of the images that should be displayed"]
     ["Set Slice (BoundingBox)" doc-view-set-slice-from-bounding-box
      :help                     "Set the slice from the document's BoundingBox information"]
     ["Set Slice (manual)"	doc-view-set-slice
      :help                     "Set the slice of the images that should be displayed"]
     ["Reset Slice"		doc-view-reset-slice
      :help                     "Reset the current slice"
      :enabled                  (bookroll-mode-window-get 'slice)])
    "---"
    ["New Search"               (doc-view-search t)
     :help                      "Initiate a new search"]
    ["Search Forward"           doc-view-search
     :help                      "Jump to the next match or initiate a new search"]
    ["Search Backward"          doc-view-search-backward
     :help                      "Jump to the previous match or initiate a new search"]
    ))

(defvar doc-view-minor-mode-map
  (let ((map (make-sparse-keymap)))
    ;; Toggle between text and image display or editing
    (define-key map (kbd "C-c C-c") 'doc-view-toggle-display)
    map)
  "Keymap used by `doc-view-minor-mode'.")

(easy-menu-define doc-view-minor-mode-menu doc-view-minor-mode-map
  "Menu for Doc View minor mode."
  '("DocView (edit)"
    ("Toggle edit/display"
     ["Edit document"           (lambda ()) ; ignore but show no keybinding
      :style radio :selected    (eq major-mode 'doc-view--text-view-mode)]
     ["Display document"        doc-view-toggle-display
      :style radio :selected    (eq major-mode 'doc-view-mode)])
    ["Exit DocView Mode" doc-view-minor-mode]))

;;;; Navigation Commands

;; FIXME: The doc-view-current-* definitions below are macros because they
;; map to accessors which we want to use via `setf' as well!
(defmacro doc-view-current-page (&optional win)
  `(bookroll-mode-window-get 'page ,win))
(defmacro doc-view-current-info () '(bookroll-mode-window-get 'info))
(defmacro doc-view-control-overlay () '(bookroll-mode-window-get 'overlay))
(defmacro doc-view-overlays () '(bookroll-mode-window-get 'overlays))
(defmacro doc-view-current-image () '(bookroll-mode-window-get 'image))
(defmacro doc-view-current-slice () '(bookroll-mode-window-get 'slice))

(defun doc-view-last-page-number ()
  (length doc-view--current-files))

(defun doc-view-goto-page (page)
  "View the page given by PAGE."
  (interactive "nPage: ")
  (let ((len (doc-view-last-page-number)))
    (if (< page 1)
	(setq page 1)
      (when (and (> page len)
                 ;; As long as the converter is running, we don't know
                 ;; how many pages will be available.
                 (null doc-view--current-converter-processes))
	(setq page len)))
    (force-mode-line-update)            ;To update `current-page'.
    (setf (doc-view-current-page) page
	  (doc-view-current-info)
	  (concat
	   (propertize
	    (format "Page %d of %d." page len) 'face 'bold)
	   ;; Tell user if converting isn't finished yet
	   (if doc-view--current-converter-processes
	       " (still converting...)\n"
	     "\n")
	   ;; Display context infos if this page matches the last search
	   (when (and doc-view--current-search-matches
		      (assq page doc-view--current-search-matches))
	     (concat (propertize "Search matches:\n" 'face 'bold)
		     (let ((contexts ""))
		       (dolist (m (cdr (assq page
					     doc-view--current-search-matches)))
			 (setq contexts (concat contexts "  - \"" m "\"\n")))
		       contexts)))))
    ;; Update the buffer
    ;; We used to find the file name from doc-view--current-files but
    ;; that's not right if the pages are not generated sequentially
    ;; or if the page isn't in doc-view--current-files yet.
    (let ((file (expand-file-name
                 (format doc-view--image-file-pattern page)
                 (doc-view--current-cache-dir))))
      (doc-view-insert-image file :pointer 'arrow)
      (when (and (not (file-exists-p file))
                 doc-view--current-converter-processes)
        ;; The PNG file hasn't been generated yet.
        (funcall doc-view-single-page-converter-function
		 doc-view--buffer-file-name file page
		 (let ((win (selected-window)))
		   (lambda ()
		     (and (eq (current-buffer) (window-buffer win))
			  ;; If we changed page in the mean
			  ;; time, don't mess things up.
			  (eq (doc-view-current-page win) page)
			  ;; Make sure we don't infloop.
			  (file-readable-p file)
			  (with-selected-window win
			    (doc-view-goto-page page))))))))
    ;; (message "D1 %s" (bookroll-mode-winprops))
    (overlay-put (doc-view-control-overlay)
		 'help-echo (doc-view-current-info))
    (goto-char (point-min))))

(defun doc-view-next-page (&optional arg)
  "Browse ARG pages forward."
  (interactive "p")
  (doc-view-goto-page (+ (doc-view-current-page) (or arg 1))))

(defun doc-view-previous-page (&optional arg)
  "Browse ARG pages backward."
  (interactive "p")
  (doc-view-goto-page (- (doc-view-current-page) (or arg 1))))

(defun doc-view-first-page ()
  "View the first page."
  (interactive)
  (doc-view-goto-page 1))

(defun doc-view-last-page ()
  "View the last page."
  (interactive)
  (doc-view-goto-page (doc-view-last-page-number)))

(defun doc-view-scroll-up-or-next-page (&optional arg)
  "Scroll page up ARG lines if possible, else goto next page.
When `doc-view-continuous' is non-nil, scrolling upward
at the bottom edge of the page moves to the next page.
Otherwise, goto next page only on typing SPC (ARG is nil)."
  (interactive "P")
  (if (or doc-view-continuous (null arg))
      (let ((hscroll (window-hscroll))
	    (cur-page (doc-view-current-page)))
	(when (= (window-vscroll nil t) (image-scroll-up arg))
	  (doc-view-next-page)
	  (when (/= cur-page (doc-view-current-page))
	    (image-bob)
	    (image-bol 1))
	  (set-window-hscroll (selected-window) hscroll)))
    (image-scroll-up arg)))

(defun doc-view-scroll-down-or-previous-page (&optional arg)
  "Scroll page down ARG lines if possible, else goto previous page.
When `doc-view-continuous' is non-nil, scrolling downward
at the top edge of the page moves to the previous page.
Otherwise, goto previous page only on typing DEL (ARG is nil)."
  (interactive "P")
  (if (or doc-view-continuous (null arg))
      (let ((hscroll (window-hscroll))
	    (cur-page (doc-view-current-page)))
	(when (= (window-vscroll nil t) (image-scroll-down arg))
	  (doc-view-previous-page)
	  (when (/= cur-page (doc-view-current-page))
	    (image-eob)
	    (image-bol 1))
	  (set-window-hscroll (selected-window) hscroll)))
    (image-scroll-down arg)))

(defun doc-view-next-line-or-next-page (&optional arg)
  "Scroll upward by ARG lines if possible, else goto next page.
When `doc-view-continuous' is non-nil, scrolling a line upward
at the bottom edge of the page moves to the next page."
  (interactive "p")
  (if doc-view-continuous
      (let ((hscroll (window-hscroll))
	    (cur-page (doc-view-current-page)))
	(when (= (window-vscroll nil t) (image-next-line arg))
	  (doc-view-next-page)
	  (when (/= cur-page (doc-view-current-page))
	    (image-bob)
	    (image-bol 1))
	  (set-window-hscroll (selected-window) hscroll)))
    (image-next-line arg)))

(defun doc-view-previous-line-or-previous-page (&optional arg)
  "Scroll downward by ARG lines if possible, else goto previous page.
When `doc-view-continuous' is non-nil, scrolling a line downward
at the top edge of the page moves to the previous page."
  (interactive "p")
  (if doc-view-continuous
      (let ((hscroll (window-hscroll))
	    (cur-page (doc-view-current-page)))
	(when (= (window-vscroll nil t) (image-previous-line arg))
	  (doc-view-previous-page)
	  (when (/= cur-page (doc-view-current-page))
	    (image-eob)
	    (image-bol 1))
	  (set-window-hscroll (selected-window) hscroll)))
    (image-previous-line arg)))

;;;; Utility Functions

(defun doc-view-kill-proc ()
  "Kill the current converter process(es)."
  (interactive)
  (while (consp doc-view--current-converter-processes)
    (ignore-errors ;; Some entries might not be processes, and maybe
		   ;; some are dead already?
      (kill-process (pop doc-view--current-converter-processes))))
  (when doc-view--current-timer
    (cancel-timer doc-view--current-timer)
    (setq doc-view--current-timer nil))
  (setq mode-line-process nil))

(define-obsolete-function-alias 'doc-view-kill-proc-and-buffer
  #'image-kill-buffer "25.1")

(defun doc-view-make-safe-dir (dir)
  (condition-case nil
      ;; Create temp files with strict access rights.  It's easy to
      ;; loosen them later, whereas it's impossible to close the
      ;; time-window of loose permissions otherwise.
      (with-file-modes #o0700 (make-directory dir))
    (file-already-exists
     ;; In case it was created earlier with looser rights.
     ;; We could check the mode info returned by file-attributes, but it's
     ;; a pain to parse and it may not tell you what we want under
     ;; non-standard file-systems.  So let's just say what we want and let
     ;; the underlying C code and file-system figure it out.
     ;; This also ends up checking a bunch of useful conditions: it makes
     ;; sure we have write-access to the directory and that we own it, thus
     ;; closing a bunch of security holes.
     (condition-case error
	 (set-file-modes dir #o0700 'nofollow)
       (file-error
	(error
	 (format "Unable to use temporary directory %s: %s"
		 dir (mapconcat #'identity (cdr error) " "))))))))

(defun doc-view--current-cache-dir ()
  "Return the directory where the png files of the current doc should be saved.
It's a subdirectory of `doc-view-cache-directory'."
  (if doc-view--current-cache-dir
      doc-view--current-cache-dir
    ;; Try and make sure doc-view-cache-directory exists and is safe.
    (doc-view-make-safe-dir doc-view-cache-directory)
    ;; Now compute the subdirectory to use.
    (setq doc-view--current-cache-dir
	  (file-name-as-directory
	   (expand-file-name
	    (concat (thread-last
                      (file-name-nondirectory doc-view--buffer-file-name)
                      ;; bug#13679
                      (subst-char-in-string ?% ?_)
                      ;; arc-mode concatenates archive name and file name
                      ;; with colon, which isn't allowed on MS-Windows.
                      (subst-char-in-string ?: ?_))
                    "-"
                    (let ((file doc-view--buffer-file-name))
                      (with-temp-buffer
                        (set-buffer-multibyte nil)
                        (insert-file-contents-literally file)
                        (md5 (current-buffer)))))
            doc-view-cache-directory)))))

;;;###autoload
(defun doc-view-mode-p (type)
  "Return non-nil if document type TYPE is available for `doc-view'.
Document types are symbols like `dvi', `ps', `pdf', or `odf' (any
OpenDocument format)."
  (and (display-graphic-p)
       (image-type-available-p 'png)
       (cond
	((eq type 'dvi)
	 (and (doc-view-mode-p 'pdf)
	      (or (and doc-view-dvipdf-program
		       (executable-find doc-view-dvipdf-program))
		  (and doc-view-dvipdfm-program
		       (executable-find doc-view-dvipdfm-program)))))
	((memq type '(postscript ps eps pdf))
	 (or (and doc-view-ghostscript-program
	          (executable-find doc-view-ghostscript-program))
             (and doc-view-pdfdraw-program
                  (executable-find doc-view-pdfdraw-program))))
	((eq type 'odf)
	 (and doc-view-odf->pdf-converter-program
	      (executable-find doc-view-odf->pdf-converter-program)
	      (doc-view-mode-p 'pdf)))
	((eq type 'djvu)
	 (executable-find "ddjvu"))
	(t ;; unknown image type
	 nil))))

;;;; Conversion Functions

(defvar doc-view-shrink-factor 1.125)

(defun doc-view-enlarge (factor)
  "Enlarge the document by FACTOR."
  (interactive (list doc-view-shrink-factor))
  (if doc-view-scale-internally
      (let ((new (ceiling (* factor doc-view-image-width))))
        (unless (equal new doc-view-image-width)
          (setq-local doc-view-image-width new)
          (doc-view-insert-image
           (plist-get (cdr (doc-view-current-image)) :file)
           :width doc-view-image-width)))
    (let ((new (ceiling (* factor doc-view-resolution))))
      (unless (equal new doc-view-resolution)
        (setq-local doc-view-resolution new)
        (doc-view-reconvert-doc)))))

(defun doc-view-shrink (factor)
  "Shrink the document by FACTOR."
  (interactive (list doc-view-shrink-factor))
  (doc-view-enlarge (/ 1.0 factor)))

(defun doc-view-scale-reset ()
  "Reset the document size/zoom level to the initial one."
  (interactive)
  (if doc-view-scale-internally
      (progn
	(kill-local-variable 'doc-view-image-width)
	(doc-view-insert-image
	 (plist-get (cdr (doc-view-current-image)) :file)
	 :width doc-view-image-width))
    (kill-local-variable 'doc-view-resolution)
    (doc-view-reconvert-doc)))

(defun doc-view-scale-adjust (factor)
  "Adjust the scale of the DocView page images by FACTOR.
FACTOR defaults to `doc-view-shrink-factor'.

The actual adjustment made depends on the final component of the
keybinding used to invoke the command, with all modifiers removed:

   +, =   Increase the image scale by FACTOR
   -      Decrease the image scale by FACTOR
   0      Reset the image scale to the initial scale"
  (interactive (list doc-view-shrink-factor))
  (let ((ev last-command-event)
	(echo-keystrokes nil))
    (pcase (event-basic-type ev)
      ((or ?+ ?=) (doc-view-enlarge factor))
      (?-         (doc-view-shrink factor))
      (?0         (doc-view-scale-reset)))))

(defun doc-view-fit-width-to-window ()
  "Fit the image width to the window width."
  (interactive)
  (let ((win-width (- (nth 2 (window-inside-pixel-edges))
                      (nth 0 (window-inside-pixel-edges))))
        (slice (doc-view-current-slice)))
    (if (not slice)
        (let ((img-width (car (image-display-size
                               (image-get-display-property) t))))
          (doc-view-enlarge (/ (float win-width) (float img-width))))

      ;; If slice is set
      (let* ((slice-width (nth 2 slice))
             (scale-factor (/ (float win-width) (float slice-width)))
             (new-slice (mapcar (lambda (x) (ceiling (* scale-factor x))) slice)))

        (doc-view-enlarge scale-factor)
        (setf (doc-view-current-slice) new-slice)
        (doc-view-goto-page (doc-view-current-page))))))

(defun doc-view-fit-height-to-window ()
  "Fit the image height to the window height."
  (interactive)
  (let ((win-height (- (nth 3 (window-inside-pixel-edges))
                       (nth 1 (window-inside-pixel-edges))))
        (slice (doc-view-current-slice)))
    (if (not slice)
        (let ((img-height (cdr (image-display-size
                                (image-get-display-property) t))))
          ;; When users call 'doc-view-fit-height-to-window',
          ;; they might want to go to next page by typing SPC
          ;; ONLY once. So I used '(- win-height 1)' instead of
          ;; 'win-height'
          (doc-view-enlarge (/ (float (- win-height 1)) (float img-height))))

      ;; If slice is set
      (let* ((slice-height (nth 3 slice))
             (scale-factor (/ (float (- win-height 1)) (float slice-height)))
             (new-slice (mapcar (lambda (x) (ceiling (* scale-factor x))) slice)))

        (doc-view-enlarge scale-factor)
        (setf (doc-view-current-slice) new-slice)
        (doc-view-goto-page (doc-view-current-page))))))

(defun doc-view-fit-page-to-window ()
  "Fit the image to the window.
More specifically, this function enlarges image by:

min {(window-width / image-width), (window-height / image-height)} times."
  (interactive)
  (let ((win-width (- (nth 2 (window-inside-pixel-edges))
                      (nth 0 (window-inside-pixel-edges))))
        (win-height (- (nth 3 (window-inside-pixel-edges))
                       (nth 1 (window-inside-pixel-edges))))
        (slice (doc-view-current-slice)))
    (if (not slice)
        (let ((img-width (car (image-display-size
                               (image-get-display-property) t)))
              (img-height (cdr (image-display-size
                                (image-get-display-property) t))))
          (doc-view-enlarge (min (/ (float win-width) (float img-width))
                                 (/ (float (- win-height 1))
                                    (float img-height)))))
      ;; If slice is set
      (let* ((slice-width (nth 2 slice))
             (slice-height (nth 3 slice))
             (scale-factor (min (/ (float win-width) (float slice-width))
                                (/ (float (- win-height 1))
                                   (float slice-height))))
             (new-slice (mapcar (lambda (x) (ceiling (* scale-factor x))) slice)))
        (doc-view-enlarge scale-factor)
        (setf (doc-view-current-slice) new-slice)
        (doc-view-goto-page (doc-view-current-page))))))

(defun doc-view-fit-window-to-page ()
  "Resize selected window so it just fits the current page.
Resize the containing frame if needed."
  (interactive)
  (let* ((slice (doc-view-current-slice))
         (img-width  (if slice (nth 2 slice)
                       (car (image-display-size
                             (image-get-display-property) t))))
         (img-height (if slice (nth 3 slice)
                       (cdr (image-display-size
                             (image-get-display-property) t))))
         (win-width  (- (nth 2 (window-inside-pixel-edges))
                        (nth 0 (window-inside-pixel-edges))))
         (win-height (- (nth 3 (window-inside-pixel-edges))
                        (nth 1 (window-inside-pixel-edges))))
         (width-diff  (- img-width  win-width))
         (height-diff (- img-height win-height))
         (new-frame-params
          ;; If we can't resize the window, try and resize the frame.
          ;; We used to compare the `window-width/height` and the
          ;; `frame-width/height` instead of catching the errors, but
          ;; it's too fiddly (e.g. in the presence of the miniwindow,
          ;; the height the frame should be equal to the height of the
          ;; root window +1).
          (append
           (condition-case nil
               (progn
                 (enlarge-window (/ width-diff (frame-char-width)) 'horiz)
                 nil)
             (error
              `((width  . (text-pixels
                           . ,(+ (frame-text-width) width-diff))))))
           (condition-case nil
               (progn
                 (enlarge-window (/ height-diff (frame-char-height)) nil)
                 nil)
             (error
              `((height  . (text-pixels
                            . ,(+ (frame-text-height) height-diff)))))))))
    (when new-frame-params
      (modify-frame-parameters (selected-frame) new-frame-params))))

(defun doc-view-center-page-horizontally ()
  "Center page horizontally when page is wider than window."
  (interactive)
  (let ((page-width (car (image-size (doc-view-current-image) 'pixel)))
        (window-width (window-body-width nil 'pixel))
        ;; How much do we scroll in order to center the page?
        (pixel-hscroll 0)
        ;; How many pixels are there in a column?
        (col-in-pixel (/ (window-body-width nil 'pixel)
                         (window-body-width nil))))
    (when (> page-width window-width)
      (setq pixel-hscroll (/ (- page-width window-width) 2))
      (set-window-hscroll (selected-window)
                          (/ pixel-hscroll col-in-pixel)))))

(defun doc-view-center-page-vertically ()
  "Center page vertically when page is wider than window."
  (interactive)
  (let ((page-height (cdr (image-size (doc-view-current-image) 'pixel)))
        (window-height (window-body-height nil 'pixel))
        ;; How much do we scroll in order to center the page?
        (pixel-scroll 0))
    (when (> page-height window-height)
      (setq pixel-scroll (/ (- page-height window-height) 2))
      (set-window-vscroll (selected-window) pixel-scroll 'pixel))))

(defun doc-view-reconvert-doc ()
  "Reconvert the current document.
Should be invoked when the cached images aren't up-to-date."
  (interactive)
  (doc-view-kill-proc)
  ;; Clear the old cached files
  (when (file-exists-p (doc-view--current-cache-dir))
    (delete-directory (doc-view--current-cache-dir) 'recursive))
  (kill-local-variable 'doc-view-last-page-number)
  (doc-view-initiate-display))

(defun doc-view-sentinel (proc event)
  "Generic sentinel for doc-view conversion processes."
  (if (not (string-match "finished" event))
      (message "DocView: process %s changed status to %s."
               (process-name proc)
	       (if (string-match "\\(.+\\)\n?\\'" event)
		   (match-string 1 event)
		 event))
    (when (buffer-live-p (process-get proc 'buffer))
      (with-current-buffer (process-get proc 'buffer)
        (setq doc-view--current-converter-processes
              (delq proc doc-view--current-converter-processes))
        (setq mode-line-process
              (if doc-view--current-converter-processes
                  (format ":%s" (car doc-view--current-converter-processes))))
        (funcall (process-get proc 'callback))))))

(defun doc-view-start-process (name program args callback)
  ;; Make sure the process is started in an existing directory, (rather than
  ;; some file-name-handler-managed dir, for example).
  (let* ((default-directory (or (unhandled-file-name-directory
                                 default-directory)
			      (expand-file-name "~/")))
         (proc (apply #'start-process name doc-view-conversion-buffer
                      program args)))
    (push proc doc-view--current-converter-processes)
    (setq mode-line-process (list (format ":%s" proc)))
    (set-process-sentinel proc 'doc-view-sentinel)
    (process-put proc 'buffer   (current-buffer))
    (process-put proc 'callback callback)))

(defun doc-view-dvi->pdf (dvi pdf callback)
  "Convert DVI to PDF asynchronously and call CALLBACK when finished."
  ;; Prefer dvipdf over dvipdfm, because the latter has problems if the DVI
  ;; references and includes other PS files.
  (if (and doc-view-dvipdf-program
	   (executable-find doc-view-dvipdf-program))
      (doc-view-start-process "dvi->pdf" doc-view-dvipdf-program
			      (list dvi pdf)
			      callback)
    (doc-view-start-process "dvi->pdf" doc-view-dvipdfm-program
			    (list "-o" pdf dvi)
			    callback)))

(defun doc-view-pdf-password-protected-ghostscript-p (pdf)
  "Return non-nil if a PDF file is password-protected.
The test is performed using `doc-view-ghostscript-program'."
  (with-temp-buffer
    (apply #'call-process doc-view-ghostscript-program nil (current-buffer)
           nil `(,@doc-view-ghostscript-options
                 "-sNODISPLAY"
                 ,pdf))
    (goto-char (point-min))
    (search-forward "This file requires a password for access." nil t)))

(defun doc-view-pdf->png-converter-ghostscript (pdf png page callback)
  (let ((pdf-passwd (if (doc-view-pdf-password-protected-ghostscript-p pdf)
                        (read-passwd "Enter password for PDF file: "))))
    (doc-view-start-process
     "pdf/ps->png" doc-view-ghostscript-program
     `(,@doc-view-ghostscript-options
       ,(concat "-sDEVICE=" doc-view-ghostscript-device)
       ,(format "-r%d" (round doc-view-resolution))
       ,@(if page `(,(format "-dFirstPage=%d" page)))
       ,@(if page `(,(format "-dLastPage=%d" page)))
       ,@(if pdf-passwd `(,(format "-sPDFPassword=%s" pdf-passwd)))
       ,(concat "-sOutputFile=" png)
       ,pdf)
     callback)))

(defalias 'doc-view-ps->png-converter-ghostscript
  'doc-view-pdf->png-converter-ghostscript)

(defun doc-view-djvu->tiff-converter-ddjvu (djvu tiff page callback)
  "Convert PAGE of a DJVU file to bitmap(s) asynchronously.
Call CALLBACK with no arguments when done.
If PAGE is nil, convert the whole document."
  (doc-view-start-process
   "djvu->tiff" "ddjvu"
   `("-format=tiff"
     ;; ddjvu only accepts the range 1-999.
     ,(format "-scale=%d" (round doc-view-resolution))
     ;; -eachpage was only added after djvulibre-3.5.25.3!
     ,@(unless page '("-eachpage"))
     ,@(if page `(,(format "-page=%d" page)))
     ,djvu
     ,tiff)
   callback))

(defun doc-view-pdfdraw-program-subcommand ()
  "Return the mutool subcommand replacing mudraw.
Recent MuPDF distributions replaced `mudraw' with `mutool draw'."
  (when (string-match "mutool[^/\\]*$" doc-view-pdfdraw-program)
    '("draw")))

(defun doc-view-pdf-password-protected-pdfdraw-p (pdf)
  "Return non-nil if a PDF file is password-protected.
The test is performed using `doc-view-pdfdraw-program'."
  (with-temp-buffer
    (apply #'call-process doc-view-pdfdraw-program nil (current-buffer) nil
           `(,@(doc-view-pdfdraw-program-subcommand)
             ,(concat "-o" null-device)
             ;; In case PDF isn't password-protected, "draw" only one page.
             ,pdf "1"))
    (goto-char (point-min))
    (search-forward "error: cannot authenticate password" nil t)))

(defun doc-view-pdf->png-converter-mupdf (pdf png page callback)
  (let ((pdf-passwd (if (doc-view-pdf-password-protected-pdfdraw-p pdf)
                        (read-passwd "Enter password for PDF file: "))))
    (doc-view-start-process
     "pdf->png" doc-view-pdfdraw-program
     `(,@(doc-view-pdfdraw-program-subcommand)
       ,(concat "-o" png)
       ,(format "-r%d" (round doc-view-resolution))
       ,@(if pdf-passwd `("-p" ,pdf-passwd))
       ,pdf
       ,@(if page `(,(format "%d" page))))
     callback)))

(defun doc-view-odf->pdf-converter-unoconv (odf callback)
  "Convert ODF to PDF asynchronously and call CALLBACK when finished.
The converted PDF is put into the current cache directory, and it
is named like ODF with the extension turned to pdf."
  (doc-view-start-process "odf->pdf" doc-view-odf->pdf-converter-program
			  (list "-f" "pdf" "-o" (doc-view--current-cache-dir) odf)
			  callback))

(defun doc-view-odf->pdf-converter-soffice (odf callback)
  "Convert ODF to PDF asynchronously and call CALLBACK when finished.
The converted PDF is put into the current cache directory, and it
is named like ODF with the extension turned to pdf."
  ;; FIXME: soffice doesn't work when there's another running
  ;; LibreOffice instance, in which case it returns success without
  ;; actually doing anything.  See LibreOffice bug
  ;; https://bugs.freedesktop.org/show_bug.cgi?id=37531.  A workaround
  ;; is to start soffice with a separate UserInstallation directory.
  (let ((tmp-user-install-dir (make-temp-file "libreoffice-docview" t)))
    (doc-view-start-process "odf->pdf" doc-view-odf->pdf-converter-program
			    (list
			     (concat "-env:UserInstallation=file://"
                                     ;; The URL must be
                                     ;; file:///C:/tmp/dir on Windows.
                                     ;; https://wiki.documentfoundation.org/UserProfile.
                                     (when (eq system-type 'windows-nt)
                                       "/")
				     tmp-user-install-dir)
			     "--headless" "--convert-to" "pdf"
			     "--outdir" (doc-view--current-cache-dir) odf)
			    (lambda ()
			      (delete-directory tmp-user-install-dir t)
			      (funcall callback)))))

(defun doc-view-pdf/ps->png (pdf-ps png)
  ;; FIXME: Fix name and docstring to account for djvu&tiff.
  "Convert PDF-PS to PNG asynchronously."
  (funcall
   (pcase doc-view-doc-type
     ('pdf doc-view-pdf->png-converter-function)
     ('djvu #'doc-view-djvu->tiff-converter-ddjvu)
     (_ #'doc-view-ps->png-converter-ghostscript))
   pdf-ps png nil
   (let ((resolution doc-view-resolution))
     (lambda ()
       ;; Only create the resolution file when it's all done, so it also
       ;; serves as a witness that the conversion is complete.
       (write-region (prin1-to-string resolution) nil
                     (expand-file-name "resolution.el"
                                       (doc-view--current-cache-dir))
                     nil 'silently)
       (when doc-view--current-timer
         (cancel-timer doc-view--current-timer)
         (setq doc-view--current-timer nil))
       (doc-view-display (current-buffer) 'force))))

  ;; Update the displayed pages as soon as they're done generating.
  (when doc-view-conversion-refresh-interval
    (setq doc-view--current-timer
          (run-at-time "1 secs" doc-view-conversion-refresh-interval
                       'doc-view-display
                       (current-buffer)))))

(declare-function clear-image-cache "image.c" (&optional filter))

(defun doc-view-document->bitmap (pdf png pages)
  "Convert a document file to bitmap images asynchronously.
Start by converting PAGES, and then the rest."
  (if (null pages)
      (doc-view-pdf/ps->png pdf png)
    ;; We could render several `pages' with a single process if they're
    ;; (almost) consecutive, but since in 99% of the cases, there'll be only
    ;; a single page anyway, and of the remaining 1%, few cases will have
    ;; consecutive pages, it's not worth the trouble.
    (let ((rest (cdr pages)))
      (funcall doc-view-single-page-converter-function
	       pdf (format png (car pages)) (car pages)
       (lambda ()
         (if rest
             (doc-view-document->bitmap pdf png rest)
           ;; Yippie, the important pages are done, update the display.
           (clear-image-cache)
           ;; For the windows that have a message (like "Welcome to
           ;; DocView") display property, clearing the image cache is
           ;; not sufficient.
           (dolist (win (get-buffer-window-list (current-buffer) nil 'visible))
             (with-selected-window win
	       (when (stringp (overlay-get (doc-view-overlays) 'display))
		 (doc-view-goto-page (doc-view-current-page)))))
           ;; Convert the rest of the pages.
           (doc-view-pdf/ps->png pdf png)))))))

(defun doc-view-pdf->txt (pdf txt callback)
  "Convert PDF to TXT asynchronously and call CALLBACK when finished."
  (or (executable-find doc-view-pdftotext-program)
      (error "You need the `pdftotext' program to convert a PDF to text"))
  (doc-view-start-process "pdf->txt" doc-view-pdftotext-program
                          (append doc-view-pdftotext-program-args
                                  (list pdf txt))
                          callback))

(defun doc-view-current-cache-doc-pdf ()
  "Return the name of the doc.pdf in the current cache dir.
This file exists only if the current document isn't a PDF or PS file already."
  (expand-file-name "doc.pdf" (doc-view--current-cache-dir)))

(defun doc-view-doc->txt (txt callback)
  "Convert the current document to text and call CALLBACK when done."
  (make-directory (doc-view--current-cache-dir) t)
  (pcase doc-view-doc-type
    ('pdf
     ;; Doc is a PDF, so convert it to TXT
     (doc-view-pdf->txt doc-view--buffer-file-name txt callback))
    ('ps
     ;; Doc is a PS, so convert it to PDF (which will be converted to
     ;; TXT thereafter).
     (let ((pdf (doc-view-current-cache-doc-pdf)))
       (doc-view-ps->pdf doc-view--buffer-file-name pdf
                         (lambda () (doc-view-pdf->txt pdf txt callback)))))
    ('dvi
     ;; Doc is a DVI.  This means that a doc.pdf already exists in its
     ;; cache subdirectory.
     (doc-view-pdf->txt (doc-view-current-cache-doc-pdf) txt callback))
    ('odf
     ;; Doc is some ODF (or MS Office) doc.  This means that a doc.pdf
     ;; already exists in its cache subdirectory.
     (doc-view-pdf->txt (doc-view-current-cache-doc-pdf) txt callback))
    (_ (error "DocView doesn't know what to do"))))

(defun doc-view-ps->pdf (ps pdf callback)
  "Convert PS to PDF asynchronously and call CALLBACK when finished."
  (or (executable-find doc-view-ps2pdf-program)
      (error "You need the `ps2pdf' program to convert PS to PDF"))
  (doc-view-start-process "ps->pdf" doc-view-ps2pdf-program
                          (list
                           ;; Avoid security problems when rendering files from
                           ;; untrusted sources.
                           "-dSAFER"
                           ;; in-file and out-file
                           ps pdf)
                          callback))

(defun doc-view-active-pages ()
  (let ((pages ()))
    (dolist (win (get-buffer-window-list (current-buffer) nil 'visible))
      (let ((page (bookroll-mode-window-get 'page win)))
        (unless (memq page pages) (push page pages))))
    pages))

(defun doc-view-convert-current-doc ()
  "Convert `doc-view--buffer-file-name' to a set of png files, one file per page.
Those files are saved in the directory given by the function
`doc-view--current-cache-dir'."
  ;; Let stale files still display while we recompute the new ones, so only
  ;; flush the cache when the conversion is over.  One of the reasons why it
  ;; is important to keep displaying the stale page is so that revert-buffer
  ;; preserves the horizontal/vertical scroll settings (which are otherwise
  ;; reset during the redisplay).
  (setq doc-view--pending-cache-flush t)
  (let ((png-file (expand-file-name
                   (format doc-view--image-file-pattern "%d")
                   (doc-view--current-cache-dir))))
    (make-directory (doc-view--current-cache-dir) t)
    (pcase doc-view-doc-type
      ('dvi
       ;; DVI files have to be converted to PDF before Ghostscript can process
       ;; it.
       (let ((pdf (doc-view-current-cache-doc-pdf)))
         (doc-view-dvi->pdf doc-view--buffer-file-name pdf
                            (lambda () (doc-view-pdf/ps->png pdf png-file)))))
      ('odf
       ;; ODF files have to be converted to PDF before Ghostscript can
       ;; process it.
       (let ((pdf (doc-view-current-cache-doc-pdf))
             (opdf (expand-file-name
                    (concat (file-name-base doc-view--buffer-file-name)
                            ".pdf")
                    doc-view--current-cache-dir))
             (png-file png-file))
	 ;; The unoconv tool only supports an output directory, but no
	 ;; file name.  It's named like the input file with the
	 ;; extension replaced by pdf.
         (funcall doc-view-odf->pdf-converter-function doc-view--buffer-file-name
                  (lambda ()
		    ;; Rename to doc.pdf
		    (rename-file opdf pdf)
		    (doc-view-pdf/ps->png pdf png-file)))))
      ((or 'pdf 'djvu)
       (let ((pages (doc-view-active-pages)))
         ;; Convert doc to bitmap images starting with the active pages.
         (doc-view-document->bitmap doc-view--buffer-file-name png-file pages)))
      (_
       ;; Convert to PNG images.
       (doc-view-pdf/ps->png doc-view--buffer-file-name png-file)))))

;;;; Slicing

(declare-function image-size "image.c" (spec &optional pixels frame))

(defun doc-view-set-slice (x y width height)
  "Set the slice of the images that should be displayed.
You can use this function to tell doc-view not to display the
margins of the document.  It prompts for the top-left corner (X
and Y) of the slice to display and its WIDTH and HEIGHT.

See `doc-view-set-slice-using-mouse' and
`doc-view-set-slice-from-bounding-box' for more convenient ways
to do that.  To reset the slice use `doc-view-reset-slice'."
  (interactive
   (let* ((size (image-size (doc-view-current-image) t))
	  (a (read-number (format "Top-left X (0..%d): " (car size))))
	  (b (read-number (format "Top-left Y (0..%d): " (cdr size))))
	  (c (read-number (format "Width (0..%d): " (- (car size) a))))
	  (d (read-number (format "Height (0..%d): " (- (cdr size) b)))))
     (list a b c d)))
  (setf (doc-view-current-slice) (list x y width height))
  ;; Redisplay
  (doc-view-goto-page (doc-view-current-page)))

(defun doc-view-set-slice-using-mouse ()
  "Set the slice of the images that should be displayed.
You set the slice by pressing mouse-1 at its top-left corner and
dragging it to its bottom-right corner.  See also
`doc-view-set-slice' and `doc-view-reset-slice'."
  (interactive)
  (let (x y w h done)
    (while (not done)
      (let ((e (read-event
		(concat "Press mouse-1 at the top-left corner and "
			"drag it to the bottom-right corner!"))))
	(when (eq (car e) 'drag-mouse-1)
	  (setq x (car (posn-object-x-y (event-start e))))
	  (setq y (cdr (posn-object-x-y (event-start e))))
	  (setq w (- (car (posn-object-x-y (event-end e))) x))
	  (setq h (- (cdr (posn-object-x-y (event-end e))) y))
	  (setq done t))))
    (doc-view-set-slice x y w h)))

(defun doc-view-get-bounding-box ()
  "Get the BoundingBox information of the current page."
  (let ((page (doc-view-current-page))
	(doc (let ((cache-doc (doc-view-current-cache-doc-pdf)))
	       (if (file-exists-p cache-doc)
		   cache-doc
		 doc-view--buffer-file-name))))
    (with-temp-buffer
      (when (eq 0 (ignore-errors
		    (process-file doc-view-ghostscript-program nil t
				  nil "-dSAFER" "-dBATCH" "-dNOPAUSE" "-q"
				  "-sDEVICE=bbox"
				  (format "-dFirstPage=%s" page)
				  (format "-dLastPage=%s" page)
				  doc)))
	(goto-char (point-min))
	(save-match-data
	  (when (re-search-forward
		 (concat "%%BoundingBox: "
			 "\\([[:digit:]]+\\) \\([[:digit:]]+\\) "
			 "\\([[:digit:]]+\\) \\([[:digit:]]+\\)")
                 nil t)
	    (mapcar #'string-to-number
		    (list (match-string 1)
			  (match-string 2)
			  (match-string 3)
			  (match-string 4)))))))))

(defvar doc-view-paper-sizes
  '((a4 595 842)
    (a4-landscape 842 595)
    (letter 612 792)
    (letter-landscape 792 612)
    (legal 612 1008)
    (legal-landscape 1008 612)
    (a3 842 1191)
    (a3-landscape 1191 842)
    (tabloid 792 1224)
    (ledger 1224 792))
  "An alist from paper size names to dimensions.")

(defun doc-view-guess-paper-size (iw ih)
  "Guess the paper size according to the aspect ratio."
  (cl-labels ((div (x y)
		   (round (/ (* 100.0 x) y))))
    (let ((ar (div iw ih))
	  (al (mapcar (lambda (l)
			(list (div (nth 1 l) (nth 2 l)) (car l)))
		      doc-view-paper-sizes)))
      (cadr (assoc ar al)))))

(defun doc-view-scale-bounding-box (ps iw ih bb)
  (list (/ (* (nth 0 bb) iw) (nth 1 (assoc ps doc-view-paper-sizes)))
	(/ (* (nth 1 bb) ih) (nth 2 (assoc ps doc-view-paper-sizes)))
	(/ (* (nth 2 bb) iw) (nth 1 (assoc ps doc-view-paper-sizes)))
	(/ (* (nth 3 bb) ih) (nth 2 (assoc ps doc-view-paper-sizes)))))

(defun doc-view-set-slice-from-bounding-box (&optional force-paper-size)
  "Set the slice from the document's BoundingBox information.
The result is that the margins are almost completely cropped,
much more accurate than could be done manually using
`doc-view-set-slice-using-mouse'."
  (interactive "P")
  (let ((bb (doc-view-get-bounding-box)))
    (if (not bb)
	(message "BoundingBox couldn't be determined")
      (let* ((is (image-size (doc-view-current-image) t))
	     (iw (car is))
	     (ih (cdr is))
	     (ps (or (and (null force-paper-size)
                          (doc-view-guess-paper-size iw ih))
		     (intern (completing-read "Paper size: "
                                              doc-view-paper-sizes
					      nil t))))
	     (bb (doc-view-scale-bounding-box ps iw ih bb))
	     (x1 (nth 0 bb))
	     (y1 (nth 1 bb))
	     (x2 (nth 2 bb))
	     (y2 (nth 3 bb)))
	;; We keep a 2 pixel margin.
	(doc-view-set-slice (- x1 2) (- ih y2 2)
			    (+ (- x2 x1) 4) (+ (- y2 y1) 4))))))

(defun doc-view-reset-slice ()
  "Reset the current slice.
After calling this function whole pages will be visible again."
  (interactive)
  (setf (doc-view-current-slice) nil)
  ;; Redisplay
  (doc-view-goto-page (doc-view-current-page)))

;;;; Display

(defun doc-view-info-pages ()
  (let ((file doc-view--buffer-file-name)
        pages
        page-sizes)
    (pcase doc-view-doc-type
      ((or 'pdf 'epub) (cond ((executable-find "mutool")
                              (with-temp-buffer
                                (call-process "mutool" nil t nil "info" "-M" file)
                                (buffer-string)
                                (goto-char (point-min))
                                (search-forward-regexp "^Pages: \\([0-9]*\\)")
                                (setq pages (string-to-number (match-string 1)))
                                (search-forward-regexp "\\[ 0 0 \\([0-9]*\\).* \\([0-9]*\\).* \\]")
                                (let ((page-size (cons (string-to-number (match-string 1))
                                                       (string-to-number (match-string 2)))))
                                  (setq page-sizes (make-list pages page-size))))
                              ;; TODO add alternative using `pdfinfo -box'
                              )))
      ('djvu (let* ((pages-info (mapcar (lambda (l)
                                          (split-string l "[ =]"))
                                        (process-lines "djvused" "-e" "'size'" file))))
                    (setq page-sizes (mapcar (lambda (dims)
                                               (let ((w (string-to-number (nth 1 dims)))
                                                     (h (string-to-number (nth 3 dims))))
                                                 (cons w h)))
                                             pages-info))
                    (setq pages (length page-sizes)))))
    (cons pages page-sizes)))

(defun doc-view-insert-image (file &rest args)
  "Insert the given png FILE.
ARGS is a list of image descriptors."
  (when doc-view--pending-cache-flush
    (clear-image-cache)
    (setq doc-view--pending-cache-flush nil))
  (let ((ol (doc-view-control-overlay)))
    ;; Only insert the image if the buffer is visible.
    (when (window-live-p (overlay-get ol 'window))
      (let* ((image (if (and file (file-readable-p file))
			(if (not doc-view-scale-internally)
			    (apply #'create-image file doc-view--image-type nil args)
			  (unless (member :width args)
			    (setq args `(,@args :width ,doc-view-image-width)))
                          (unless (member :transform-smoothing args)
                            (setq args `(,@args :transform-smoothing t)))
			  (apply #'create-image file doc-view--image-type nil args))))
	     (slice (doc-view-current-slice))
	     (img-width (and image (car (image-size image))))
	     (displayed-img-width (if (and image slice)
				      (* (/ (float (nth 2 slice))
					    (car (image-size image 'pixels)))
					 img-width)
				    img-width))
	     (window-width (window-width)))
	(setf (doc-view-current-image) image)
	;; In case the window is wider than the image, center the image
	;; horizontally.
	;; (overlay-put (nth (1- (doc-view-current-page)) overlays) 'before-string
	;; 	     (when (and image (> window-width displayed-img-width))
	;; 	       (propertize " " 'display
	;; 			   `(space :align-to (+ center (-0.5 . ,displayed-img-width))))))
	(overlay-put (nth (1- (doc-view-current-page)) overlays) 'display
		     (cond
		      (image
		       (if slice
			   (list (cons 'slice slice) image)
			 image))
		      ;; We're trying to display a page that doesn't exist.
		      (doc-view--current-converter-processes
		       ;; Maybe the page doesn't exist *yet*.
		       "Cannot display this page (yet)!")
		      (t
		       ;; Typically happens if the conversion process somehow
		       ;; failed.  Better not signal an error here because it
		       ;; could prevent a subsequent reconversion from fixing
		       ;; the problem.
		       (concat "Cannot display this page!\n"
			       "Maybe because of a conversion failure!"))))))))
	;; (let ((win (overlay-get (doc-view-control-overlay) 'window)))
	;;   (if (stringp (overlay-get (doc-view-control-overlay) 'display))
	;;       (progn            ;Make sure the text is not scrolled out of view.
	;; 	(set-window-hscroll win 0)
	;; 	(set-window-vscroll win 0))
	;;     (let ((hscroll (bookroll-mode-window-get 'hscroll win))
	;; 	  (vscroll (bookroll-mode-window-get 'vscroll win)))
	;;       ;; Reset scroll settings, in case they were changed.
	;;       (if hscroll (set-window-hscroll win hscroll))
	;;       (if vscroll (set-window-vscroll win vscroll t)))))))))

(defun doc-view-sort (a b)
  "Return non-nil if A should be sorted before B.
Predicate for sorting `doc-view--current-files'."
  (or (< (length a) (length b))
      (and (= (length a) (length b))
           (string< a b))))

(defun doc-view-display (buffer &optional force)
  "Start viewing the document in BUFFER.
If FORCE is non-nil, start viewing even if the document does not
have the page we want to view."
  (with-current-buffer buffer
    (let ((prev-pages doc-view--current-files))
      (setq doc-view--current-files
            (sort (directory-files (doc-view--current-cache-dir) t
                                   (format doc-view--image-file-pattern
                                           "[0-9]+")
                                   t)
                  'doc-view-sort))
      (unless (eq (length prev-pages) (length doc-view--current-files))
	(force-mode-line-update))
      (dolist (win (or (get-buffer-window-list buffer nil t)
		       (list t)))
	(let* ((page (doc-view-current-page win))
	       (pagefile (expand-file-name
                          (format doc-view--image-file-pattern page)
                          (doc-view--current-cache-dir))))
	  (when (or force
		    (and (not (member pagefile prev-pages))
			 (member pagefile doc-view--current-files)))
	    (if (windowp win)
		(with-selected-window win
		  (cl-assert (eq (current-buffer) buffer) t)
		  (doc-view-goto-page page))
	      (doc-view-goto-page page))))))))

(defun doc-view-buffer-message ()
  ;; Only show this message initially, not when refreshing the buffer (in which
  ;; case it's better to keep displaying the "stale" page while computing
  ;; the fresh new ones).
  (unless (overlay-get (doc-view-control-overlay) 'display)
    (overlay-put (doc-view-control-overlay) 'display
                 (concat (propertize "Welcome to DocView!" 'face 'bold)
                         "\n"
                         (substitute-command-keys "
If you see this buffer it means that the document you want to view is being
converted to PNG and the conversion of the first page hasn't finished yet or
`doc-view-conversion-refresh-interval' is set to nil.

For now these keys are useful:
\\<doc-view-mode-map>
\\[quit-window] : Bury this buffer.  Conversion will go on in background.
\\[image-kill-buffer] : Kill the conversion process and this buffer.
\\[doc-view-kill-proc] : Kill the conversion process.\n")))))

(declare-function tooltip-show "tooltip" (text &optional use-echo-area))

(defun doc-view-show-tooltip ()
  (interactive)
  (tooltip-show (doc-view-current-info)))

;; We define an own major mode for DocView's text display so that we
;; can easily distinguish when we want to toggle back because
;; text-mode is a likely candidate for a default major-mode
;; (bug#34451).
(define-derived-mode doc-view--text-view-mode text-mode "DV/Text"
  "View mode used in DocView's text buffers."
  (view-mode))

(defun doc-view-open-text ()
  "Display the current doc's contents as text."
  (interactive)
  (if doc-view--current-converter-processes
      (message "DocView: please wait till conversion finished.")
    (let ((txt (expand-file-name "doc.txt" (doc-view--current-cache-dir)))
          (page (doc-view-current-page)))
      (if (file-readable-p txt)
	  (let ((inhibit-read-only t)
		(buffer-undo-list t)
		(dv-bfn doc-view--buffer-file-name))
	    (erase-buffer)
            ;; FIXME: Replacing the buffer's PDF content with its txt rendering
            ;; is pretty risky.  We should probably use *another*
            ;; buffer instead, so there's much less risk of
            ;; overwriting the PDF file with some text rendering.
	    (set-buffer-multibyte t)
	    (insert-file-contents txt)
	    (doc-view--text-view-mode)
	    (setq-local doc-view--buffer-file-name dv-bfn)
	    (set-buffer-modified-p nil)
	    (doc-view-minor-mode)
            (goto-char (point-min))
            ;; Put point at the start of the page the user was
            ;; reading.  Pages are separated by Control-L characters.
            (re-search-forward page-delimiter nil t (1- page))
	    (add-hook 'write-file-functions
		      (lambda ()
                        ;; FIXME: If the user changes major mode and then
                        ;; saves the buffer, the PDF file will be clobbered
                        ;; with its txt rendering!
			(when (eq major-mode 'doc-view--text-view-mode)
			  (error "Cannot save text contents of document %s"
				 buffer-file-name)))
		      nil t))
	(doc-view-doc->txt txt 'doc-view-open-text)))))

;;;;; Toggle between editing and viewing

(defvar-local doc-view-saved-settings nil
  "Doc-view settings saved while in some other mode.")
(put 'doc-view-saved-settings 'permanent-local t)

(defun doc-view-toggle-display ()
  "Toggle between editing a document as text or viewing it."
  (interactive)
  (cond
   ((eq major-mode 'doc-view-mode)
    ;; Switch to editing mode
    (doc-view-kill-proc)
    (setq buffer-read-only nil)
    ;; Switch to the previously used major mode or fall back to
    ;; normal mode.
    (doc-view-fallback-mode)
    (doc-view-minor-mode 1))
   ((eq major-mode 'doc-view--text-view-mode)
    (let ((buffer-undo-list t))
      ;; We're currently viewing the document's text contents, so switch
      ;; back to .
      (setq buffer-read-only nil)
      (insert-file-contents doc-view--buffer-file-name nil nil nil t)
      (doc-view-fallback-mode)
      (doc-view-minor-mode 1)
      (set-buffer-modified-p nil)))
   (t
    ;; Switch to doc-view-mode
    (when (and (buffer-modified-p)
	       (y-or-n-p "The buffer has been modified.  Save the changes? "))
      (save-buffer))
    (doc-view-mode))))

;;;; Searching


(defun doc-view-search-internal (regexp file)
  "Return a list of FILE's pages that contain text matching REGEXP.
The value is an alist of the form (PAGE CONTEXTS) where PAGE is
the pagenumber and CONTEXTS are all lines of text containing a match."
  (with-temp-buffer
    (insert-file-contents file)
    (let ((page 1)
	  (lastpage 1)
	  matches)
      (while (re-search-forward (concat "\\(?:\\([\f]\\)\\|\\("
					regexp "\\)\\)") nil t)
	(when (match-string 1) (setq page (1+ page)))
	(when (match-string 2)
	  (if (/= page lastpage)
	      (push (cons page
			  (list (buffer-substring
				 (line-beginning-position)
				 (line-end-position))))
		    matches)
	    (setq matches (cons
			   (append
			    (or
			     ;; This page already is a match.
			     (car matches)
			     ;; This is the first match on page.
			     (list page))
			    (list (buffer-substring
				   (line-beginning-position)
				   (line-end-position))))
			   (cdr matches))))
	  (setq lastpage page)))
      (nreverse matches))))

(defun doc-view-search-no-of-matches (list)
  "Extract the number of matches from the search result LIST."
  (let ((no 0))
    (dolist (p list)
      (setq no (+ no (1- (length p)))))
    no))

(defun doc-view-search-backward (new-query)
  "Call `doc-view-search' for backward search.
If prefix NEW-QUERY is given, ask for a new regexp."
  (interactive "P")
  (doc-view-search new-query t))

(defun doc-view-search (new-query &optional backward)
  "Jump to the next match or initiate a new search if NEW-QUERY is given.
If the current document hasn't been transformed to plain text
till now do that first.
If BACKWARD is non-nil, jump to the previous match."
  (interactive "P")
  (if (and (not new-query)
	   doc-view--current-search-matches)
      (if backward
	  (doc-view-search-previous-match 1)
	(doc-view-search-next-match 1))
    ;; New search, so forget the old results.
    (setq doc-view--current-search-matches nil)
    (let ((txt (expand-file-name "doc.txt"
				 (doc-view--current-cache-dir))))
      (if (file-readable-p txt)
	  (progn
	    (setq doc-view--current-search-matches
		  (doc-view-search-internal
		   (read-from-minibuffer "Regexp: ")
		   txt))
	    (message "DocView: search yielded %d matches."
		     (doc-view-search-no-of-matches
		      doc-view--current-search-matches)))
	;; We must convert to TXT first!
	(if doc-view--current-converter-processes
	    (message "DocView: please wait till conversion finished.")
	  (doc-view-doc->txt txt (lambda () (doc-view-search nil))))))))

(defun doc-view-search-next-match (arg)
  "Go to the ARGth next matching page."
  (interactive "p")
  (let* ((next-pages (cl-remove-if
		      (lambda (i) (<= (car i) (doc-view-current-page)))
		      doc-view--current-search-matches))
	 (page (car (nth (1- arg) next-pages))))
    (if page
	(doc-view-goto-page page)
      (when (and
	     doc-view--current-search-matches
	     (y-or-n-p "No more matches after current page.  Wrap to first match? "))
	(doc-view-goto-page (caar doc-view--current-search-matches))))))

(defun doc-view-search-previous-match (arg)
  "Go to the ARGth previous matching page."
  (interactive "p")
  (let* ((prev-pages (cl-remove-if
		      (lambda (i) (>= (car i) (doc-view-current-page)))
		      doc-view--current-search-matches))
	 (page (car (nth (1- arg) (nreverse prev-pages)))))
    (if page
	(doc-view-goto-page page)
      (when (and
	     doc-view--current-search-matches
	     (y-or-n-p "No more matches before current page.  Wrap to last match? "))
	(doc-view-goto-page (caar (last doc-view--current-search-matches)))))))

;;;; User interface commands and the mode

(put 'doc-view-mode 'mode-class 'special)

(defun doc-view-already-converted-p ()
  "Return non-nil if the current doc was already converted."
  (and (file-exists-p (doc-view--current-cache-dir))
       ;; Check that the resolution info is there, otherwise it means
       ;; the conversion is incomplete.
       (file-readable-p (expand-file-name "resolution.el"
                                          (doc-view--current-cache-dir)))
       (> (length (directory-files
                   (doc-view--current-cache-dir)
                   nil (format doc-view--image-file-pattern "[0-9]+")))
          0)))

(defun doc-view-initiate-display ()
  ;; Switch to image display if possible.
  (if (doc-view-mode-p doc-view-doc-type)
      (progn
	(doc-view-buffer-message)
	(setf (doc-view-current-page) (or (doc-view-current-page) 1))
	(if (doc-view-already-converted-p)
	    (progn
	      (message "DocView: using cached files!")
	      ;; Load the saved resolution.
	      (let* ((res-file
                      (expand-file-name "resolution.el"
                                        (doc-view--current-cache-dir)))
                     (res
                      (with-temp-buffer
                        (when (file-readable-p res-file)
                          (insert-file-contents res-file)
                          (read (current-buffer))))))
                (when (numberp res)
		  (setq-local doc-view-resolution res)))
	      (doc-view-display (current-buffer) 'force))
	  (doc-view-convert-current-doc))
	(message
	 "%s"
	 (substitute-command-keys
	  (concat "Type \\[doc-view-toggle-display] to toggle between "
		  "editing or viewing the document."))))
    (if (image-type-available-p 'png)
        (message "Conversion utility \"%s\" not available for %s"
                 doc-view-ghostscript-program
	         (file-name-extension doc-view--buffer-file-name))
      (message "PNG support not available; can't view document"))
    (if (and (executable-find doc-view-pdftotext-program)
	     (y-or-n-p
	      "Unable to render file.  View extracted text instead? "))
	(doc-view-open-text)
      (doc-view-toggle-display))))

(defvar bookmark-make-record-function)

(defun doc-view-clone-buffer-hook ()
  ;; FIXME: There are several potential problems linked with reconversion
  ;; and auto-revert when we have indirect buffers because they share their
  ;; /tmp cache directory.  This sharing is good (you'd rather not reconvert
  ;; for each clone), but that means that clones need to collaborate a bit.
  ;; I guess it mostly means: detect when a reconversion process is already
  ;; running, and run the sentinel in all clones.
  ;;
  ;; Maybe the clones should really have a separate /tmp directory
  ;; so they could have a different resolution and you could use clones
  ;; for zooming.
  (remove-overlays (point-min) (point-max) 'doc-view t)
  (if (consp bookroll-mode-winprops-alist) (setq bookroll-mode-winprops-alist nil)))

(defun doc-view-set-doc-type ()
  "Figure out the current document type (`doc-view-doc-type')."
  (let ((name-types
	 (when buffer-file-name
	   (cdr (assoc-string
                 (file-name-extension buffer-file-name)
                 '(
                   ;; DVI
                   ("dvi" dvi)
                   ;; PDF
                   ("pdf" pdf) ("epdf" pdf)
                   ;; PostScript
                   ("ps" ps) ("eps" ps)
                   ;; DjVu
                   ("djvu" djvu)
                   ;; OpenDocument formats.
                   ("odt" odf) ("ods" odf) ("odp" odf) ("odg" odf)
                   ("odc" odf) ("odi" odf) ("odm" odf) ("ott" odf)
                   ("ots" odf) ("otp" odf) ("otg" odf)
                   ;; Microsoft Office formats (also handled by the odf
                   ;; conversion chain).
                   ("doc" odf) ("docx" odf) ("xls" odf) ("xlsx" odf)
                   ("ppt" odf) ("pps" odf) ("pptx" odf) ("rtf" odf))
		 t))))
	(content-types
	 (save-excursion
	   (goto-char (point-min))
	   (cond
	    ((looking-at "%!") '(ps))
	    ((looking-at "%PDF") '(pdf))
	    ((looking-at "\367\002") '(dvi))
	    ((looking-at "AT&TFORM") '(djvu))))))
    (setq-local
     doc-view-doc-type
     (car (or (nreverse (seq-intersection name-types content-types #'eq))
              (when (and name-types content-types)
                (error "Conflicting types: name says %s but content says %s"
                       name-types content-types))
              name-types content-types
              (error "Cannot determine the document type"))))))

(defun doc-view-set-up-single-converter ()
  "Find the right single-page converter for the current document type."
  (pcase-let ((`(,conv-function ,type ,extension)
               (pcase doc-view-doc-type
                 ('djvu (list #'doc-view-djvu->tiff-converter-ddjvu 'tiff "tif"))
                 (_     (list doc-view-pdf->png-converter-function  'png  "png")))))
    (setq-local doc-view-single-page-converter-function conv-function)
    (setq-local doc-view--image-type type)
    (setq-local doc-view--image-file-pattern (concat "page-%s." extension))))

;; desktop.el integration

(defun doc-view-desktop-save-buffer (_desktop-dirname)
  ;; FIXME: This is wrong, since this info is per-window but we only do it once
  ;; here for the buffer.  IOW it should be saved via something like
  ;; `window-persistent-parameters'.
  `((page . ,(doc-view-current-page))
    (slice . ,(doc-view-current-slice))))

(declare-function desktop-restore-file-buffer "desktop"
                  (buffer-filename buffer-name buffer-misc))

(defun doc-view-restore-desktop-buffer (file name misc)
  (let ((page  (cdr (assq 'page misc)))
	(slice (cdr (assq 'slice misc))))
    (desktop-restore-file-buffer file name misc)
    ;; FIXME: We need to run this code after displaying the buffer.
    (with-selected-window (or (get-buffer-window (current-buffer) 0)
			      (selected-window))
      ;; FIXME: This should be done for all windows restored that show
      ;; this buffer.  Basically, the page/slice should be saved as
      ;; window-parameters in the window-state(s) and then restoring this
      ;; window-state should call us back (to interpret/use those parameters).
      (doc-view-goto-page page)
      (when slice (apply #'doc-view-set-slice slice))
      (current-buffer))))

(add-to-list 'desktop-buffer-mode-handlers
	     '(doc-view-mode . doc-view-restore-desktop-buffer))

;; (setq trace-counter 0)

;; (defun trace-winprops ()
;;   (setq trace-counter (1+ trace-counter))
;;   (when-let (buf (get-buffer "Optics, 5th ed_ - Eugene Hecht.pdf"))
;;     (with-current-buffer buf
;;       (trace-values trace-counter bookroll-mode-winprops-alist))))

;; (add-hook 'post-command-hook #'trace-winprops)

;;;###autoload
(defun doc-view-mode ()
  "Major mode in DocView buffers.

DocView Mode is an Emacs document viewer.  It displays PDF, PS
and DVI files (as PNG images) in Emacs buffers.

You can use \\<doc-view-mode-map>\\[doc-view-toggle-display] to
toggle between displaying the document or editing it as text.
\\{doc-view-mode-map}"
  (interactive)

  (if (= (point-min) (point-max))
      ;; The doc is empty or doesn't exist at all, so fallback to
      ;; another mode.  We used to also check file-exists-p, but this
      ;; returns nil for tar members.
      (doc-view-fallback-mode)

    (major-mode-suspend)

    (dolist (var doc-view-saved-settings)
      (set (make-local-variable (car var)) (cdr var)))

    ;; Figure out the document type.
    (unless doc-view-doc-type
      (doc-view-set-doc-type))
    (doc-view-set-up-single-converter)
    (unless (memq doc-view-doc-type '(ps))
      (setq-local require-final-newline nil))

    ;; These modes will just display "1", so they're not very useful
    ;; in this mode.
    (setq-local global-linum-mode nil
                display-line-numbers-mode nil)

    (doc-view-make-safe-dir doc-view-cache-directory)
    ;; Handle compressed files, remote files, files inside archives
    (setq-local doc-view--buffer-file-name
		(convert-standard-filename
                 (cond
                  (jka-compr-really-do-compress
                   ;; FIXME: there's a risk of name conflicts here.
                   (expand-file-name
                    (file-name-nondirectory
                     (file-name-sans-extension buffer-file-name))
                    doc-view-cache-directory))
                  ;; Is the file readable by local processes?
                  ;; We used to use `file-remote-p' but it's unclear what it's
                  ;; supposed to return nil for things like local files accessed
                  ;; via `su' or via file://...
                  ((let ((file-name-handler-alist nil))
                     (not (and buffer-file-name
                               (file-readable-p buffer-file-name))))
                   ;; FIXME: there's a risk of name conflicts here.
                   (expand-file-name
                    (if buffer-file-name
			(file-name-nondirectory buffer-file-name)
                      (buffer-name))
                    doc-view-cache-directory))
                  (t buffer-file-name))))
    (when (not (string= doc-view--buffer-file-name buffer-file-name))
      (write-region nil nil doc-view--buffer-file-name))

    (add-function :around (local 'revert-buffer-function) #'doc-view--revert-buffer)

    (add-hook 'change-major-mode-hook
	      (lambda ()
		(doc-view-kill-proc)
		(remove-overlays (point-min) (point-max) 'doc-view t))
	      nil t)
    (add-hook 'clone-indirect-buffer-hook #'doc-view-clone-buffer-hook nil t)
    (add-hook 'kill-buffer-hook #'doc-view-kill-proc nil t)
    (setq-local desktop-save-buffer #'doc-view-desktop-save-buffer)

    (remove-overlays (point-min) (point-max) 'doc-view t) ;Just in case.
    ;; Keep track of display info ([vh]scroll, page number, overlays,
    ;; ...)  for each window in which this document is shown.
    (add-hook 'bookroll-mode-new-window-functions
	      #'doc-view-new-window-function nil t)
    (bookroll-mode-setup-winprops)

    (setq-local mode-line-position
                '(" P" (:eval (number-to-string (doc-view-current-page)))
                  "/" (:eval (number-to-string (doc-view-last-page-number)))))
    ;; Don't scroll unless the user specifically asked for it.
    (setq-local auto-hscroll-mode nil)
    (if (boundp 'mwheel-scroll-up-function) ; not --without-x build
        (setq-local mwheel-scroll-up-function
                    #'doc-view-scroll-up-or-next-page))
    (if (boundp 'mwheel-scroll-down-function)
        (setq-local mwheel-scroll-down-function
                    #'doc-view-scroll-down-or-previous-page))
    (setq-local cursor-type nil)
    (use-local-map doc-view-mode-map)
    (add-hook 'after-revert-hook #'doc-view-reconvert-doc nil t)
    (setq-local bookmark-make-record-function
                #'doc-view-bookmark-make-record)
    (setq mode-name "DocView"
	  buffer-read-only t
	  major-mode 'doc-view-mode)
    (let ((info (doc-view-info-pages)))
      (setq number-of-pages (car info)
            ;; TODO multiply by appropriate scaling factor
            image-sizes (cdr info)))
    (setq image-positions (let ((sum 0)
                                positions)
                            (dolist (s image-sizes)
                              (push sum positions)
                              (setq sum (+ sum (cdr s))))
                            (nreverse positions)))
    (doc-view-initiate-display)
    ;; Switch off view-mode explicitly, because doc-view-mode is the
    ;; canonical view mode for PDF/PS/DVI files.  This could be
    ;; switched on automatically depending on the value of
    ;; `view-read-only'.
    (setq-local view-read-only nil)
    (run-mode-hooks 'doc-view-mode-hook)
    (bookroll-mode)))

(defun doc-view-fallback-mode ()
  "Fallback to the previous or next best major mode."
  (let ((vars (if (derived-mode-p 'doc-view-mode)
                  (mapcar (lambda (var) (cons var (symbol-value var)))
                          '(doc-view-resolution
                            bookroll-mode-winprops-alist)))))
    (remove-overlays (point-min) (point-max) 'doc-view t)
    (major-mode-restore '(doc-view-mode-maybe doc-view-mode))
    (when vars
      (setq-local doc-view-saved-settings vars))))

;;;###autoload
(defun doc-view-mode-maybe ()
  "Switch to `doc-view-mode' if possible.
If the required external tools are not available, then fallback
to the next best mode."
  (condition-case nil
      (doc-view-set-doc-type)
    (error (doc-view-fallback-mode)))
  (if (doc-view-mode-p doc-view-doc-type)
      (doc-view-mode)
    (doc-view-fallback-mode)))

;;;###autoload
(define-minor-mode doc-view-minor-mode
  "Toggle displaying buffer via Doc View (Doc View minor mode).

See the command `doc-view-mode' for more information on this mode."
  :lighter " DocView"
  (when doc-view-minor-mode
    (add-hook 'change-major-mode-hook (lambda () (doc-view-minor-mode -1)) nil t)
    (message
     "%s"
     (substitute-command-keys
      "Type \\[doc-view-toggle-display] to toggle between editing or viewing the document."))))

(defun doc-view-clear-cache ()
  "Delete the whole cache (`doc-view-cache-directory')."
  (interactive)
  (dired-delete-file doc-view-cache-directory 'always))

(defun doc-view-dired-cache ()
  "Open `dired' in `doc-view-cache-directory'."
  (interactive)
  (dired doc-view-cache-directory))

;;;; Presentation mode

(defvar doc-view-presentation-mode-map
  (let ((map (make-sparse-keymap)))
    (define-key map "\e" 'doc-view-presentation-exit)
    (define-key map "q" 'doc-view-presentation-exit)
    ;; (define-key map "C" 'doc-view-convert-all-pages)
    map))

(defvar-local doc-view-presentation--src-data nil)

(defun doc-view-presentation-exit ()
  "Leave Doc-View's presentation mode."
  (interactive)
  (doc-view-presentation-mode -1))

(define-minor-mode doc-view-presentation-mode
  "Minor mode used while in presentation mode."
  :init-value nil :keymap doc-view-presentation-mode-map
  (if doc-view-presentation-mode
      (progn
        (setq-local mode-line-format nil)
        (doc-view-fit-page-to-window)
        ;; (doc-view-convert-all-pages)
        )
    (kill-local-variable 'mode-line-format)
    (let ((pn (doc-view-current-page))
          (win (selected-window)))
      (doc-view-presentation--propagate-pn doc-view-presentation--src-data pn)
      (setq doc-view-presentation--src-data nil)
      (with-selected-window win
        (if (and (one-window-p) (window-dedicated-p))
            (delete-frame))))))

(defun doc-view-presentation--propagate-pn (src-data pn)
  (when src-data
    (let ((win (car src-data)))
      (when (and (window-live-p win)
                 (eq (current-buffer) (window-buffer win)))
        (select-window win))
      (when (eq (doc-view-current-page) (cdr src-data))
        (doc-view-goto-page pn)))))

(defun doc-view-presentation ()
  "Put Doc-View in presentation mode."
  (interactive)
  (let* ((src-data (cons (selected-window) (doc-view-current-page)))
         (mal (display-monitor-attributes-list))
         (monitor-top 0)
         (monitor-left 0)
         (monitor-height (display-pixel-height))
         (monitor-width (display-pixel-width)))
    (dolist (attrs mal)
      (when (memq (selected-frame) (alist-get 'frames attrs))
        (let ((geom (alist-get 'geometry attrs)))
          (when geom
            (setq monitor-left (nth 0 geom))
            (setq monitor-top (nth 1 geom))
            (setq monitor-width (nth 2 geom))
            (setq monitor-height (nth 3 geom))))))
    (let ((frame (make-frame
                  `((minibuffer . nil)
                    (fullscreen . fullboth)
                    (height . ,(ceiling monitor-height (frame-char-height)))
                    ;; Don't use `ceiling' here since doc-view will center the
                    ;; image instead.
                    (width . ,(ceiling monitor-width (frame-char-width)))
                    (name . "Doc-View-Presentation")
                    (top . ,monitor-top) (left . ,monitor-left) (user-position . t)
                    (vertical-scroll-bars . nil)
                    (left-fringe . 0) (right-fringe . 0)
                    (menu-bar-lines . 0)
                    (tool-bar-lines . 0)))))
      (select-window (frame-root-window frame))
      (setq doc-view-presentation--src-data src-data)
      (set-window-dedicated-p (selected-window) t)
      (doc-view-presentation-mode 1))))


;;;; Bookmark integration

(declare-function bookmark-make-record-default
                  "bookmark" (&optional no-file no-context posn))
(declare-function bookmark-prop-get "bookmark" (bookmark prop))
(declare-function bookmark-default-handler "bookmark" (bmk))

(defun doc-view-bookmark-make-record ()
  (nconc (bookmark-make-record-default)
         `((page     . ,(doc-view-current-page))
           (handler  . doc-view-bookmark-jump))))

;;;###autoload
(defun doc-view-bookmark-jump (bmk)
  ;; This implements the `handler' function interface for record type
  ;; returned by `doc-view-bookmark-make-record', which see.
  (let ((page (bookmark-prop-get bmk 'page))
	(show-fn-sym (make-symbol "doc-view-bookmark-after-jump-hook")))
    (fset show-fn-sym
	  (lambda ()
	    (remove-hook 'bookmark-after-jump-hook show-fn-sym)
	    (when (not (eq major-mode 'doc-view-mode))
	      (doc-view-toggle-display))
	    (with-selected-window
		(or (get-buffer-window (current-buffer) 0)
		    (selected-window))
	      (doc-view-goto-page page))))
    (add-hook 'bookmark-after-jump-hook show-fn-sym)
    (bookmark-default-handler bmk)))

;; Obsolete.

(defun doc-view-intersection (l1 l2)
  (declare (obsolete seq-intersection "28.1"))
  (nreverse (seq-intersection l1 l2 #'eq)))

(provide 'doc-view)

;; Local Variables:
;; eval: (outline-minor-mode 1)
;; End:

;;; doc-view.el ends here

[-- Attachment #3: bookroll.el --]
[-- Type: text/x-emacs-lisp, Size: 14922 bytes --]

;;; bookroll.el --- Book roll providing continuous scroll for books etc. -*- lexical-binding:t -*-

;; Copyright (C) 2022 Free Software Foundation, Inc.
;;
;; Author: Daniel Nicolai <dalanicolai@gmail.com>
;; Keywords: files, multimedia
;; Package: emacs

;; This file is part of GNU Emacs.

;; GNU Emacs is free software: you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation, either version 3 of the License, or
;; (at your option) any later version.

;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.

;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.

;;; Commentary:

;;; Code:
(require 'cl-lib)
(require 'svg)

(defgroup bookroll nil
  "Bookroll sutomizations.")

(defvar-local bookroll-mode-winprops-alist t
  "Alist of windows to window properties.
Each element has the form (WINDOW . ALIST).
See `bookroll-mode-winprops'.")

(defcustom br-scroll-fraction 4
  "Set the scroll step size in 1/fraction of page.")

(defvar-local split-regexp "^[0-9]") ;; for column of numbers as placeholders
;; (defvar-local split-regexp "\n") ;; for column of numbers as placeholders
(defvar-local split-point-offset 1)

(defvar-local overlays-list '()) ;; we add a dummy overlay to make the overlay
                                     ;; indices match with the page-numbers
(defvar-local image-sizes nil)
;; (defvar-local image-sizes nil)
(defvar-local image-positions nil)
;; (defvar-local image-positions nil)
(defvar-local number-of-pages 0)

;; We start with the simplest solution (if this gives performance issues then we
;; can optimize/modify it later), that is always display a page triplet around
;; the currently viewed page, except for the first and last pages where we
;; display only a doublet.
(defvar-local currently-displayed-pages nil)

;;; Testing

;; create colored test images
(dotimes (i 3)
  (set (intern (format "im%s" (1+ i))) (let* ((w 800)
                                              (h 1600)
                                              (svg (svg-create w h)))
                                         (svg-rectangle svg 0 0 w h :fill-color (pcase i
                                                                                  (0 "red")
                                                                                  (1 "green")
                                                                                  (2 "blue")))
                                         (svg-image svg))))

;; create column of 'placeholders'
(defun br-test ()
  (interactive)
  (pop-to-buffer "bookroll-test")
  (erase-buffer)
  (bookroll-mode)
  (let ((inhibit-read-only t))
    (setq cursor-type nil)

    (setq image-sizes (make-list 1000 '(800 . 1600)))
    (setq image-positions (let ((sum 0)
                               positions)
                           (dolist (s image-sizes)
                             (push sum positions)
                             (setq sum (+ sum (cdr s))))
                           (nreverse positions)))
    (setq number-of-pages (length image-sizes))

    (dotimes (i 1000)
      (insert (number-to-string i))
      (insert "\n")))

  (br-create-overlays-list t)
  (br-create-placeholders)

  (goto-char (point-min))
  (br-goto-page 1))

;;; Code

(defun bookroll-mode-winprops (&optional window cleanup)
  "Return winprops of WINDOW.
A winprops object has the shape (WINDOW . ALIST).
WINDOW defaults to `selected-window' if it displays the current buffer, and
otherwise it defaults to t, used for times when the buffer is not displayed."
  (cond ((null window)
         (setq window
               (if (eq (current-buffer) (window-buffer)) (selected-window) t)))
        ((eq window t))
	      ((not (windowp window))
	       (error "Not a window: %s" window)))
  (when cleanup
    (setq bookroll-mode-winprops-alist
  	      (delq nil (mapcar (lambda (winprop)
			                        (let ((w (car-safe winprop)))
				                        (if (or (not (windowp w)) (window-live-p w))
				                            winprop)))
  			                    bookroll-mode-winprops-alist))))
  (let ((winprops (assq window bookroll-mode-winprops-alist)))
    ;; For new windows, set defaults from the latest.
    (if winprops
        ;; Move window to front.
        (setq bookroll-mode-winprops-alist
              (cons winprops (delq winprops bookroll-mode-winprops-alist)))
      (setq winprops (cons window
                           (copy-alist (cdar bookroll-mode-winprops-alist))))
      ;; Add winprops before running the hook, to avoid inf-loops if the hook
      ;; triggers window-configuration-change-hook.
      (setq bookroll-mode-winprops-alist
            (cons winprops bookroll-mode-winprops-alist))
      (run-hook-with-args 'bookroll-mode-new-window-functions winprops))
    winprops))

(defun bookroll-mode-window-get (prop &optional winprops)
  (declare (gv-setter (lambda (val)
                        `(bookroll-mode-window-put ,prop ,val ,winprops))))
  (unless (consp winprops) (setq winprops (bookroll-mode-winprops winprops)))
  (cdr (assq prop (cdr winprops))))

(defun bookroll-mode-window-put (prop val &optional winprops)
  (unless (consp winprops) (setq winprops (bookroll-mode-winprops winprops)))
  (unless (eq t (car winprops))
    (bookroll-mode-window-put prop val t))
  (setcdr winprops (cons (cons prop val)
                         (delq (assq prop (cdr winprops)) (cdr winprops)))))

(defun bookroll-set-window-vscroll (vscroll)
  (setf (bookroll-mode-window-get 'vscroll) vscroll)
  (set-window-vscroll (selected-window) vscroll t))

(defun bookroll-set-window-hscroll (ncol)
  (setf (bookroll-mode-window-get 'hscroll) ncol)
  (set-window-hscroll (selected-window) ncol))

(defun bookroll-mode-reapply-winprops ()
  ;; When set-window-buffer, set hscroll and vscroll to what they were
  ;; last time the image was displayed in this window.
  (when (listp bookroll-mode-winprops-alist)
    ;; Beware: this call to bookroll-mode-winprops can't be optimized away,
    ;; because it not only gets the winprops data but sets it up if needed
    ;; (e.g. it's used by doc-view to display the image in a new window).
    (let* ((winprops (bookroll-mode-winprops nil t))
           (hscroll (bookroll-mode-window-get 'hscroll winprops))
           (vscroll (bookroll-mode-window-get 'vscroll winprops)))
      (when (bookroll-get-display-property) ;Only do it if we display an image!
	      (if hscroll (set-window-hscroll (selected-window) hscroll))
	      (if vscroll (set-window-vscroll (selected-window) vscroll t))))))

(defun bookroll-mode-setup-winprops ()
  ;; Record current scroll settings.
  (unless (listp bookroll-mode-winprops-alist)
    (setq bookroll-mode-winprops-alist nil))
  (add-hook 'window-configuration-change-hook
	          #'bookroll-mode-reapply-winprops nil t))

(defun bookroll-get-display-property ()
  (get-char-property (point-min) 'display
                     ;; There might be different images for different displays.
                     (if (eq (window-buffer) (current-buffer))
                         (selected-window))))

;; TODO replace test sizes
(setq image-sizes (make-list 100 '(800 . 1600)))
(setq image-positions (let ((sum 0)
                            positions)
                        (dolist (s image-sizes)
                          (push sum positions)
                          (setq sum (+ sum (cdr s))))
                        (nreverse positions)))
(setq number-of-pages (length image-sizes))

(defun br-image-size (&optional page)
  (nth (- (or page (br-current-page)) 1) image-sizes))

(defun br-image-position (&optional page)
  (nth (- page 1) image-positions))

(defun br-create-empty-page (size)
  (pcase-let* ((`(,w . ,h) size))
               (svg-image (svg-create w h))))

(defun br-create-overlays-list (&optional include-first)
  "Create list over overlays spread out over the buffer contents.
Pass non-nil value for `include-first' when the buffer text starts
with a match.

The first element is a dummy element to make overlays indices
match with page-numbers."
  ;; first overlay starts at 1
  (let ((beg (goto-char (point-min))))
    (when include-first
      (push (make-overlay beg
                          (search-forward-regexp split-regexp
                                                 nil
                                                 t))
            overlays-list)
      ;; (setq beg (- (search-forward-regexp split-regexp nil t)
      ;;              1)))
      (setq beg (forward-line)))
    ;; We want to create an overlay for each page in the `image-sizes' list.
    ;; When include-first is non-nil then the list already contains a first
    ;; overlay. For both lists a last overlay is added after the loop to be sure
    ;; it extends to (point-max).
    (dolist (x (if include-first
                   (cddr image-sizes)
                 (cdr image-sizes)))
      (search-forward-regexp split-regexp nil t)
      ;; (forward-line)
      (push (make-overlay beg (- (point) 1 split-point-offset)) overlays-list)
      (setq beg (- (point) 1)))
    (push (make-overlay beg (point-max)) overlays-list)
    (setq overlays-list (nreverse overlays-list))))

;; TODO replace test sizes
(defun br-create-placeholders ()
  (let ((ph (br-create-empty-page '(800 . 1600)))
        (constant-size (cl-every #'eql image-sizes (cdr image-sizes))))
      (dotimes (i (length image-sizes))
        (let ((p (1+ i)));; shift by 1 to match with page numbers
          (overlay-put (nth p overlays-list) 'display (if constant-size
                                                               ph
                                                             (br-create-empty-page (nth i image-sizes))))))))

(defun br-current-page ()
  (interactive)
  (let ((i 0)
        (cur-pos (window-vscroll nil t)))
    (while (<= (nth (1+ i) image-positions) (+ cur-pos (/ (window-pixel-height) 2)))
      (setq i (1+ i)))
    (1+ i)))
    ;; (while (<= (print (nth (1+ i) image-positions)) (print (+ cur-pos (/ (window-pixel-height) 2))))
    ;;   (setq i (1+ i)))
    ;; (print (1+ i))))

(defun br-display-page (page image)
  (let ((elt (- page 1)))
    (overlay-put (nth elt (doc-view-overlays)) 'display image)))
                 ;; (pcase (% page 3)
                 ;;                               (0 im1)
                 ;;                               (1 im2)
                 ;;                               (2 im3)))))

(defun br-undisplay-page (page)
  (let ((elt (- page 1)))
    (overlay-put (nth elt overlays-list)
                 'display
                  (br-create-empty-page (car image-sizes)))))

(defun br-update-page-triplet (page)
  (let ((display-pages (pcase page
                         (1 '(1 2))
                         ((pred (= number-of-pages)) (list page (- page 1)))
                         (p (list (- p 1) p (+ p 1))))))
    ;; (let* ((image (if (and file (file-readable-p file))
		;; 	                (if (not (and doc-view-scale-internally
		;; 		                            (fboundp 'imagemagick-types)))
		;; 	                    (apply #'create-image file doc-view--image-type nil args)
		;; 	                  (unless (member :width args)
		;; 	                    (setq args `(,@args :width ,doc-view-image-width)))
		;; 	                  (apply #'create-image file 'imagemagick nil args))))
	  ;;        (slice (doc-view-current-slice))
	  ;;        (img-width (and image (car (image-size image))))
	  ;;        (displayed-img-width (if (and image slice)
		;; 		                            (* (/ (float (nth 2 slice))
		;; 			                                (car (image-size image 'pixels)))
		;; 			                             img-width)
		;; 		                          img-width))
	  ;;        (window-width (window-width)))
    (dolist (p currently-displayed-pages)
      (unless (member p display-pages)
        (br-undisplay-page p)))
    (dolist (p display-pages)
      ;; TODO separate pdf function from bookroll package
      (br-display-page p (let ((file (expand-file-name
                                      (format doc-view--image-file-pattern p)
                                      (doc-view--current-cache-dir))))
                           (doc-view-insert-image file :pointer 'arrow))))
                             ;; (if (and file (file-readable-p file))
			                       ;; (if (not (and doc-view-scale-internally
				                     ;;               (fboundp 'imagemagick-types)))
			                       ;;     (apply #'create-image file doc-view--image-type nil args)
			                       ;;   (unless (member :width args)
			                       ;;     (setq args `(,@args :width ,doc-view-image-width)))
			                       ;;   (apply #'create-image file 'imagemagick nil args)))))
    (setq currently-displayed-pages display-pages)))

(defun br-goto-page (page)
  (interactive "n")
  (br-update-page-triplet page)
  (let* ((elt (- page 1)))
    (set-window-vscroll nil (nth elt image-positions) t)))

(defun br-scroll-up ()
;; (defun pdf-view-next-line-or-next-page ()
  (interactive)
  ;; because pages could have different heights, we calculate the step size on each scroll
  ;; TODO define constant scroll size if doc has single page height
  (let ((scroll-step-size (/ (cdr (br-image-size)) br-scroll-fraction)))
    (set-window-vscroll nil (+ (window-vscroll nil t) scroll-step-size) t)
    ;; when current page changed after scrolling then update displayed pages
    (let ((current-page (br-current-page)))
        (br-update-page-triplet current-page))))

;; TODO separate pdf functions from bookroll package
(defun br-scroll-down ()
;; (defun pdf-view-previous-line-or-previous-page ()
  (interactive)
  ;; because pages could have different heights, we calculate the step size on each scroll
  ;; TODO define constant scroll size if doc has single page height
  (let ((scroll-step-size (/ (cdr (br-image-size)) br-scroll-fraction)))
    (set-window-vscroll nil (- (window-vscroll nil t) scroll-step-size) t)
    ;; when current page changed after scrolling then update displayed pages
    (let ((current-page (br-current-page)))
      (br-update-page-triplet current-page))))

(define-minor-mode bookroll-mode
  "This is a continuous scroll engine for rendering books."
  :keymap
  '(("j" . br-scroll-up)
    ("k" . br-scroll-down)
    ([mouse-4] . br-scroll-up)
    ((mouse-5) . br-scroll-down)))

(when (boundp 'evil-version)
  (evil-define-key 'evilified bookroll-mode-map "j" 'br-scroll-up)
  (evil-define-key 'evilified bookroll-mode-map "k" 'br-scroll-down))

^ permalink raw reply	[flat|nested] 9+ messages in thread

* Re: {PATCH] continuous scroll for doc-view (FOR REVIEW))
  2022-01-14 10:44   ` dalanicolai
@ 2022-01-14 11:03     ` dalanicolai
  2022-01-15 18:09       ` dalanicolai
  2022-01-15 18:13     ` Juri Linkov
  1 sibling, 1 reply; 9+ messages in thread
From: dalanicolai @ 2022-01-14 11:03 UTC (permalink / raw)
  To: Juri Linkov; +Cc: Emacs Devel

[-- Attachment #1: Type: text/plain, Size: 4387 bytes --]

About the mouse scrolling not working, I guess it is not filling the buffer
with empty svg's yet.
Although I still have to check that assumption. All seemed to work fine
with keyboard scrolling
(which I what I more or less use exclusively, e.g. jumping to page goes
faster by keyboard.
And there is a nice toc-mode <https://melpa.org/#/toc-mode> package for
quickly creating outlines. But anyway mouse scroliing
should also be supported of course).

On Fri, 14 Jan 2022 at 11:44, dalanicolai <dalanicolai@gmail.com> wrote:

> Thanks, if you want you could attach whole files, because program files
>> take almost no space on mailing list archives, so this is not a problem
>> (the problem is when someone posts large screenshots, and even a video).
>>
>
> I wanted to do that already... terrible how in the end I did forget to
> attach the files...
>
>
>> If it could be used for other images such as for image galleries,
>> then it should be a separate package like image-mode.
>>
>
> Well, I think I really wouldn't want continuous scroll for images. So I
> think a separate
> library for image galleries would be better. I think the logic for only
> showing full images
> is a slightly simpler and therefore could be made more flexible. Creating
> the overlays is
> really just a few lines. But I am not sure, how exactly the code for an
> image gallery
> should look like. Maybe in the end, some code could be shared.
>
> A triplet or a doublet means that the scroll bar can't be used for
>> scrolling all pages?  Have you tried to prefill with overlays for all
>> pages?
>>
>
> Yes, like in the Proof of Concept, all overlays are inserted at once, but
> they are 'triplet'
> only showing a triplet of images at the time. So the full buffer can be
> scrolled with the
> mouse/scroll-bar, but for some reason updating the images in that case
> does not seem
> to work yet (although from the code I would expect it should).
>
> Anyway, This time I'll send the message including the attachments... you
> can have a look
> (see first message for instructions, if necessary).
>
>
> On Fri, 14 Jan 2022 at 09:19, Juri Linkov <juri@linkov.net> wrote:
>
>> > I'd really like to mention that I get no hits when searching for that
>> > thread (actually searching
>> > for 'the original thread') when searching on `multi image PDF` in the
>> Emacs
>> > devel archive.
>> > (This time) it is not due to too many results. Would be great if you
>> could
>> > inform me why that does not work.
>>
>> Trying to search any recent subject shows that indexing on mailing lists
>> was disabled for a few last months.
>>
>> > So I will attach two files here, the first is an 'adapted' bookroll.el
>> > file, and the second is a
>> > a modified doc-view file that implements the first 'rudimentary'
>> continuous
>> > scroll for PDF
>> > documents(despite the subject title of this message, I am simply
>> attaching
>> > the file,
>> > as you can then more simply load and try it, while I guess you must be
>> > capable of diffing it with
>> > the latest doc-view.el file yourself ;).
>>
>> Thanks, if you want you could attach whole files, because program files
>> take almost no space on mailing list archives, so this is not a problem
>> (the problem is when someone posts large screenshots, and even a video).
>>
>> Or you can just make a copy of doc-view.el in your repository,
>> and send a message when you update it.
>>
>> > I am not sure if the bookroll-mode should be a separate package (like
>> image-mode),
>> > or that it could just get merged into doc-view. But it is as it is for
>> the
>> > development process.
>>
>> If it could be used for other images such as for image galleries,
>> then it should be a separate package like image-mode.
>>
>> > To understand the approach of bookmark.el, it is probably most useful to
>> > look at the Proof
>> > of Concept file to which I have linked already above. It simply draws a
>> > triplet of images (pages)
>> > for each page (and a doublet for the first and last pages), and then it
>> > uses a 'currently-displayed-images' list, and refreshes pages when
>> > necessary by comparing with that list. The current page is the page that
>> > takes more than half of the window height.
>>
>> A triplet or a doublet means that the scroll bar can't be used for
>> scrolling all pages?  Have you tried to prefill with overlays for all
>> pages?
>>
>

[-- Attachment #2: Type: text/html, Size: 5852 bytes --]

^ permalink raw reply	[flat|nested] 9+ messages in thread

* Re: {PATCH] continuous scroll for doc-view (FOR REVIEW))
  2022-01-14 11:03     ` dalanicolai
@ 2022-01-15 18:09       ` dalanicolai
  0 siblings, 0 replies; 9+ messages in thread
From: dalanicolai @ 2022-01-15 18:09 UTC (permalink / raw)
  To: Juri Linkov; +Cc: Emacs Devel

[-- Attachment #1: Type: text/plain, Size: 5192 bytes --]

I have not checked it, but probably to make the 'scaling' work, the
overlays must be drawn in a later stage.
I have it successfully working in pdf-tools, in the simple-continuous-scroll
branch of my pdf-tools fork
<https://github.com/dalanicolai/pdf-tools/tree/simple-continuous-scroll>.
The branch requires the latest version of bookroll.el
<https://github.com/dalanicolai/pdf-tools/tree/simple-continuous-scroll> to
be loaded first.
So, in case anybody is interested in reviewing any code, then probably
reviewing the pdf-tools code
would be more useful (or both the doc-view and the pdf-tools code).

On Fri, 14 Jan 2022 at 12:03, dalanicolai <dalanicolai@gmail.com> wrote:

> About the mouse scrolling not working, I guess it is not filling the
> buffer with empty svg's yet.
> Although I still have to check that assumption. All seemed to work fine
> with keyboard scrolling
> (which I what I more or less use exclusively, e.g. jumping to page goes
> faster by keyboard.
> And there is a nice toc-mode <https://melpa.org/#/toc-mode> package for
> quickly creating outlines. But anyway mouse scroliing
> should also be supported of course).
>
> On Fri, 14 Jan 2022 at 11:44, dalanicolai <dalanicolai@gmail.com> wrote:
>
>> Thanks, if you want you could attach whole files, because program files
>>> take almost no space on mailing list archives, so this is not a problem
>>> (the problem is when someone posts large screenshots, and even a video).
>>>
>>
>> I wanted to do that already... terrible how in the end I did forget to
>> attach the files...
>>
>>
>>> If it could be used for other images such as for image galleries,
>>> then it should be a separate package like image-mode.
>>>
>>
>> Well, I think I really wouldn't want continuous scroll for images. So I
>> think a separate
>> library for image galleries would be better. I think the logic for only
>> showing full images
>> is a slightly simpler and therefore could be made more flexible. Creating
>> the overlays is
>> really just a few lines. But I am not sure, how exactly the code for an
>> image gallery
>> should look like. Maybe in the end, some code could be shared.
>>
>> A triplet or a doublet means that the scroll bar can't be used for
>>> scrolling all pages?  Have you tried to prefill with overlays for all
>>> pages?
>>>
>>
>> Yes, like in the Proof of Concept, all overlays are inserted at once, but
>> they are 'triplet'
>> only showing a triplet of images at the time. So the full buffer can be
>> scrolled with the
>> mouse/scroll-bar, but for some reason updating the images in that case
>> does not seem
>> to work yet (although from the code I would expect it should).
>>
>> Anyway, This time I'll send the message including the attachments... you
>> can have a look
>> (see first message for instructions, if necessary).
>>
>>
>> On Fri, 14 Jan 2022 at 09:19, Juri Linkov <juri@linkov.net> wrote:
>>
>>> > I'd really like to mention that I get no hits when searching for that
>>> > thread (actually searching
>>> > for 'the original thread') when searching on `multi image PDF` in the
>>> Emacs
>>> > devel archive.
>>> > (This time) it is not due to too many results. Would be great if you
>>> could
>>> > inform me why that does not work.
>>>
>>> Trying to search any recent subject shows that indexing on mailing lists
>>> was disabled for a few last months.
>>>
>>> > So I will attach two files here, the first is an 'adapted' bookroll.el
>>> > file, and the second is a
>>> > a modified doc-view file that implements the first 'rudimentary'
>>> continuous
>>> > scroll for PDF
>>> > documents(despite the subject title of this message, I am simply
>>> attaching
>>> > the file,
>>> > as you can then more simply load and try it, while I guess you must be
>>> > capable of diffing it with
>>> > the latest doc-view.el file yourself ;).
>>>
>>> Thanks, if you want you could attach whole files, because program files
>>> take almost no space on mailing list archives, so this is not a problem
>>> (the problem is when someone posts large screenshots, and even a video).
>>>
>>> Or you can just make a copy of doc-view.el in your repository,
>>> and send a message when you update it.
>>>
>>> > I am not sure if the bookroll-mode should be a separate package (like
>>> image-mode),
>>> > or that it could just get merged into doc-view. But it is as it is for
>>> the
>>> > development process.
>>>
>>> If it could be used for other images such as for image galleries,
>>> then it should be a separate package like image-mode.
>>>
>>> > To understand the approach of bookmark.el, it is probably most useful
>>> to
>>> > look at the Proof
>>> > of Concept file to which I have linked already above. It simply draws a
>>> > triplet of images (pages)
>>> > for each page (and a doublet for the first and last pages), and then it
>>> > uses a 'currently-displayed-images' list, and refreshes pages when
>>> > necessary by comparing with that list. The current page is the page
>>> that
>>> > takes more than half of the window height.
>>>
>>> A triplet or a doublet means that the scroll bar can't be used for
>>> scrolling all pages?  Have you tried to prefill with overlays for all
>>> pages?
>>>
>>

[-- Attachment #2: Type: text/html, Size: 6935 bytes --]

^ permalink raw reply	[flat|nested] 9+ messages in thread

* Re: {PATCH] continuous scroll for doc-view (FOR REVIEW))
  2022-01-14 10:44   ` dalanicolai
  2022-01-14 11:03     ` dalanicolai
@ 2022-01-15 18:13     ` Juri Linkov
  2022-01-16 22:07       ` dalanicolai
  1 sibling, 1 reply; 9+ messages in thread
From: Juri Linkov @ 2022-01-15 18:13 UTC (permalink / raw)
  To: dalanicolai; +Cc: Emacs Devel

>     A triplet or a doublet means that the scroll bar can't be used for
>     scrolling all pages?  Have you tried to prefill with overlays for all
>     pages?
>
> Yes, like in the Proof of Concept, all overlays are inserted at once, but
> they are 'triplet'
> only showing a triplet of images at the time. So the full buffer can be
> scrolled with the mouse/scroll-bar

Thanks, I agree this is the right thing to do: placeholders for all pages,
and a triplet of images for the active page.

Also I noticed in your patch a new variable `doc-view-continuous-scroll'.
But it's not yet used?



^ permalink raw reply	[flat|nested] 9+ messages in thread

* Re: {PATCH] continuous scroll for doc-view (FOR REVIEW))
  2022-01-15 18:13     ` Juri Linkov
@ 2022-01-16 22:07       ` dalanicolai
  0 siblings, 0 replies; 9+ messages in thread
From: dalanicolai @ 2022-01-16 22:07 UTC (permalink / raw)
  To: Juri Linkov; +Cc: Emacs Devel

[-- Attachment #1: Type: text/plain, Size: 2251 bytes --]

The variable i created because I intended to make continuous scroll a
configurable option,
but in the end it was much easier to first implement it not as an option.

As I write below, I got continuous-scroll working very fine in pdf-tools.
But a drawback of the
design with the overlay and the placeholders, is that now it is not
(easily) possible to split
the buffer and scroll it in two different windows, because the
drawing/deleting of the images
effects the (overlays in the) other buffer also.

Anyway, as I mentioned already I was focusing on pdf-tools now, because it
seemed much
less work to me to implement continuous scroll there, while it provides
also a more powerful
pdf-reader/editor. I have successfully implemented continuous scroll and
got most basic
functionality like outline, links, annotations etc. working. So using it
works nice for the most part,
except when resizing the window, for some reason, the redisplay does not
work correctly there.
The overlay seems to be in the correct position. From checking the
`overlay-properties` it seems
 to also hold the image correctly, but even though the buffer has been
scrolled to the right position,
the overlay does not show the image (it shows an empty image, but when I
save the image from
the overlay and open it in image-mode, I do correctly see the image of a
page).

Maybe at some point, although pdf-tools is not yet part of core emacs, some
expert here might
like to have a look at it. The code can be found here
<https://github.com/dalanicolai/pdf-tools/tree/simple-continuous-scroll>.

On Sat, 15 Jan 2022 at 19:40, Juri Linkov <juri@linkov.net> wrote:

> >     A triplet or a doublet means that the scroll bar can't be used for
> >     scrolling all pages?  Have you tried to prefill with overlays for all
> >     pages?
> >
> > Yes, like in the Proof of Concept, all overlays are inserted at once, but
> > they are 'triplet'
> > only showing a triplet of images at the time. So the full buffer can be
> > scrolled with the mouse/scroll-bar
>
> Thanks, I agree this is the right thing to do: placeholders for all pages,
> and a triplet of images for the active page.
>
> Also I noticed in your patch a new variable `doc-view-continuous-scroll'.
> But it's not yet used?
>

[-- Attachment #2: Type: text/html, Size: 2856 bytes --]

^ permalink raw reply	[flat|nested] 9+ messages in thread

end of thread, other threads:[~2022-01-16 22:07 UTC | newest]

Thread overview: 9+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2022-01-13 10:53 {PATCH] continuous scroll for doc-view (FOR REVIEW)) dalanicolai
2022-01-13 10:58 ` dalanicolai
2022-01-13 11:08   ` dalanicolai
2022-01-14  8:03 ` Juri Linkov
2022-01-14 10:44   ` dalanicolai
2022-01-14 11:03     ` dalanicolai
2022-01-15 18:09       ` dalanicolai
2022-01-15 18:13     ` Juri Linkov
2022-01-16 22:07       ` dalanicolai

Code repositories for project(s) associated with this inbox:

	https://git.savannah.gnu.org/cgit/emacs.git

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).