zathura-0.3.8/AUTHORS0000664000175000017500000000175212501036512014756 0ustar sebastiansebastianzathura is written by: Moritz Lipp Sebastian Ramacher Other contributors are (in no particular order): Aepelzen Pavel Borzenkov Géraud Le Falher Glen Winters Ivan Sichmann Freitas Felix Herrmann int3 karottenreibe Johannes Meng J. Commelin Julian Orth Roland Schatz Abdó Roig-Maranges Benoît Knecht Rob Cornish Marwan Tanager Diego Joss Ignas Anikevicius Kamil Smardzewski oblique Maxime Chéramy Alexander Shabalin Lingzhu Xiang zathura-0.3.8/LICENSE0000664000175000017500000000154213216464200014713 0ustar sebastiansebastianCopyright (c) 2009-2017 pwmt.org This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 3. This notice may not be removed or altered from any source distribution. zathura-0.3.8/Makefile0000664000175000017500000002131113216464200015342 0ustar sebastiansebastian# See LICENSE file for license and copyright information include config.mk include colors.mk include common.mk # source files OSOURCE = $(sort $(wildcard ${PROJECT}/*.c) \ ${PROJECT}/resources.c) SOURCE_FILTER = ifneq (${WITH_SQLITE},0) CPPFLAGS += -DWITH_SQLITE else SOURCE_FILTER += ${PROJECT}/database-sqlite.c endif ifneq ($(WITH_MAGIC),0) CPPFLAGS += -DWITH_MAGIC endif ifneq ($(WITH_SYNCTEX),0) CPPFLAGS += -DWITH_SYNCTEX endif ifneq ($(wildcard ${VALGRIND_SUPPRESSION_FILE}),) VALGRIND_ARGUMENTS += --suppressions=${VALGRIND_SUPPRESSION_FILE} endif ifeq (,$(findstring -DZATHURA_PLUGINDIR,${CPPFLAGS})) CPPFLAGS += -DZATHURA_PLUGINDIR=\"${PLUGINDIR}\" endif ifeq (,$(findstring -DGETTEXT_PACKAGE,${CPPFLAGS})) CPPFLAGS += -DGETTEXT_PACKAGE=\"${PROJECT}\" endif ifeq (,$(findstring -DLOCALEDIR,${CPPFLAGS})) CPPFLAGS += -DLOCALEDIR=\"${LOCALEDIR}\" endif SOURCE = $(filter-out $(SOURCE_FILTER),$(OSOURCE)) OBJECTS = $(addprefix ${BUILDDIR_RELEASE}/,${SOURCE:.c=.o}) OBJECTS_DEBUG = $(addprefix ${BUILDDIR_DEBUG}/,${SOURCE:.c=.o}) OBJECTS_GCOV = $(addprefix ${BUILDDIR_GCOV}/,${SOURCE:.c=.o}) HEADERINST = $(addprefix ${PROJECT}/,version.h document.h macros.h page.h types.h plugin-api.h links.h) all: options ${PROJECT} po build-manpages # pkg-config based version checks .version-checks/%: config.mk $(QUIET)test $($(*)_VERSION_CHECK) -eq 0 || \ ${PKG_CONFIG} --atleast-version $($(*)_MIN_VERSION) $($(*)_PKG_CONFIG_NAME) || ( \ echo "The minimum required version of $(*) is $($(*)_MIN_VERSION)" && \ false \ ) @mkdir -p .version-checks $(QUIET)touch $@ options: @echo ${PROJECT} build options: @echo "CFLAGS = ${CFLAGS}" @echo "LIBS = ${LIBS}" @echo "DFLAGS = ${DFLAGS}" @echo "CC = ${CC}" # generated files ${PROJECT}/version.h: ${PROJECT}/version.h.in config.mk $(QUIET)sed -e 's/ZVMAJOR/${ZATHURA_VERSION_MAJOR}/' \ -e 's/ZVMINOR/${ZATHURA_VERSION_MINOR}/' \ -e 's/ZVREV/${ZATHURA_VERSION_REV}/' \ -e 's/ZVAPI/${ZATHURA_API_VERSION}/' \ -e 's/ZVABI/${ZATHURA_ABI_VERSION}/' ${PROJECT}/version.h.in > ${PROJECT}/version.h.tmp $(QUIET)mv ${PROJECT}/version.h.tmp ${PROJECT}/version.h ${PROJECT}/resources.%: data/zathura.gresource.xml config.mk $(call colorecho,GEN,$@) @mkdir -p ${DEPENDDIR}/$(dir $@) $(QUIET)$(GLIB_COMPILE_RESOURCES) --generate --c-name=zathura_resources --internal \ --dependency-file=$(DEPENDDIR)/$@.dep \ --sourcedir=data --target=$@ data/zathura.gresource.xml # common dependencies ${OBJECTS} ${OBJECTS_DEBUG} ${OBJECTS_GCOV}: config.mk \ .version-checks/GIRARA \ .version-checks/GLIB \ .version-checks/GTK \ ${PROJECT}/version.h \ ${PROJECT}/resources.h # rlease build ${BUILDDIR_RELEASE}/%.o: %.c $(call colorecho,CC,$<) @mkdir -p ${DEPENDDIR}/$(dir $@) @mkdir -p $(dir $(abspath $@)) $(QUIET)${CC} -c ${CPPFLAGS} ${CFLAGS} -o $@ $< -MMD -MF ${DEPENDDIR}/$@.dep ${BUILDDIR_RELEASE}/${BINDIR}/${PROJECT}: ${OBJECTS} $(call colorecho,CC,$@) @mkdir -p ${BUILDDIR_RELEASE}/${BINDIR} $(QUIET)${CC} ${SFLAGS} ${LDFLAGS} \ -o ${BUILDDIR_RELEASE}/${BINDIR}/${PROJECT} ${OBJECTS} ${LIBS} ${PROJECT}: ${BUILDDIR_RELEASE}/${BINDIR}/${PROJECT} release: ${PROJECT} run: release $(QUIET)./${BUILDDIR_RELEASE}/${BINDIR}/${PROJECT} # debug build ${BUILDDIR_DEBUG}/%.o: %.c $(call colorecho,CC,$<) @mkdir -p ${DEPENDDIR}/$(dir $@) @mkdir -p $(dir $(abspath $@)) $(QUIET)${CC} -c ${CPPFLAGS} ${CFLAGS} ${DFLAGS} \ -o $@ $< -MMD -MF ${DEPENDDIR}/$@.dep ${BUILDDIR_DEBUG}/${BINDIR}/${PROJECT}: ${OBJECTS_DEBUG} $(call colorecho,CC,$@) @mkdir -p ${BUILDDIR_DEBUG}/${BINDIR} $(QUIET)${CC} ${LDFLAGS} \ -o ${BUILDDIR_DEBUG}/${BINDIR}/${PROJECT} ${OBJECTS_DEBUG} ${LIBS} debug: ${BUILDDIR_DEBUG}/${BINDIR}/${PROJECT} run-debug: debug $(QUIET)./${BUILDDIR_DEBUG}/${BINDIR}/${PROJECT} # gcov build ${BUILDDIR_GCOV}/%.o: %.c $(call colorecho,CC,$<) @mkdir -p ${DEPENDDIR}/$(dir $@) @mkdir -p $(dir $(abspath $@)) $(QUIET)${CC} -c ${CPPFLAGS} ${CFLAGS} ${GCOV_CFLAGS} \ -o $@ $< -MMD -MF ${DEPENDDIR}/$@.dep ${BUILDDIR_GCOV}/${BINDIR}/${PROJECT}: ${OBJECTS_GCOV} $(call colorecho,CC,$@) @mkdir -p ${BUILDDIR_GCOV}/${BINDIR} $(QUIET)${CC} ${LDFLAGS} ${GCOV_CFLAGS} ${GCOV_LDFLAGS} \ -o ${BUILDDIR_GCOV}/${BINDIR}/${PROJECT} ${OBJECTS_GCOV} ${LIBS} gcov: options ${BUILDDIR_GCOV}/${BINDIR}/${PROJECT} $(QUIET)${MAKE} -C tests run-gcov $(call colorecho,LCOV,"Analyse data") $(QUIET)${LCOV_EXEC} ${LCOV_FLAGS} $(call colorecho,LCOV,"Generate report") $(QUIET)${GENHTML_EXEC} ${GENHTML_FLAGS} run-gcov: ${BUILDDIR_GCOV}/${BINDIR}/${PROJECT} $(QUIET)./${BUILDDIR_GCOV}/${BINDIR}/${PROJECT} # clean clean: $(QUIET)rm -rf \ ${BUILDDIR} \ ${DEPENDDIR} \ ${TARFILE} \ ${TARDIR} \ ${PROJECT}.pc \ ${PROJECT}/version.h \ ${PROJECT}/version.h.tmp \ ${PROJECT}/resources.c \ ${PROJECT}/resources.h \ $(PROJECT).info \ gcov \ .version-checks $(QUIET)$(MAKE) -C tests clean $(QUIET)$(MAKE) -C po clean $(QUIET)$(MAKE) -C doc clean ${PROJECT}.pc: ${PROJECT}.pc.in config.mk $(QUIET)echo project=${PROJECT} > ${PROJECT}.pc $(QUIET)echo version=${VERSION} >> ${PROJECT}.pc $(QUIET)echo apiversion=${ZATHURA_API_VERSION} >> ${PROJECT}.pc $(QUIET)echo abiversion=${ZATHURA_ABI_VERSION} >> ${PROJECT}.pc $(QUIET)echo includedir=${INCLUDEDIR} >> ${PROJECT}.pc $(QUIET)echo plugindir=${PLUGINDIR} >> ${PROJECT}.pc $(QUIET)echo GTK_VERSION=3 >> ${PROJECT}.pc $(QUIET)cat ${PROJECT}.pc.in >> ${PROJECT}.pc valgrind: debug $(QUIET)G_SLICE=always-malloc G_DEBUG=gc-friendly ${VALGRIND} ${VALGRIND_ARGUMENTS} \ ${BUILDDIR_DEBUG}/${BINDIR}/${PROJECT} gdb: debug $(QUIET)cgdb ${BUILDDIR_DEBUG}/${BINDIR}/${PROJECT} test: ${OBJECTS} $(QUIET)$(MAKE) -C tests run dist: clean build-manpages $(QUIET)tar -czf $(TARFILE) --exclude=.gitignore \ --transform 's,^,zathura-$(VERSION)/,' \ `git ls-files` \ doc/_build/$(PROJECT).1 doc/_build/$(PROJECT)rc.5 doc: $(QUIET)$(MAKE) -C doc po: $(QUIET)${MAKE} -C po update-po: $(QUIET)${MAKE} -C po update-po build-manpages: $(QUIET)${MAKE} -C doc man install-manpages: build-manpages $(call colorecho,INSTALL,"man pages") $(QUIET)mkdir -m 755 -p ${DESTDIR}${MANPREFIX}/man1 ${DESTDIR}${MANPREFIX}/man5 ifneq "$(wildcard doc/_build/${PROJECT}.1)" "" $(QUIET)install -m 644 doc/_build/${PROJECT}.1 ${DESTDIR}${MANPREFIX}/man1 endif ifneq "$(wildcard doc/_build/${PROJECT}rc.5)" "" $(QUIET)install -m 644 doc/_build/${PROJECT}rc.5 ${DESTDIR}${MANPREFIX}/man5 endif install-headers: ${PROJECT}.pc $(call colorecho,INSTALL,"header files") $(QUIET)mkdir -m 755 -p ${DESTDIR}${INCLUDEDIR}/${PROJECT} $(QUIET)install -m 644 ${HEADERINST} ${DESTDIR}${INCLUDEDIR}/${PROJECT} $(call colorecho,INSTALL,"pkgconfig file") $(QUIET)mkdir -m 755 -p ${DESTDIR}${LIBDIR}/pkgconfig $(QUIET)install -m 644 ${PROJECT}.pc ${DESTDIR}${LIBDIR}/pkgconfig install-dbus: $(call colorecho,INSTALL,"D-Bus interface definitions") $(QUIET)mkdir -m 755 -p $(DESTDIR)$(DBUSINTERFACEDIR) $(QUIET)install -m 644 data/org.pwmt.zathura.xml $(DESTDIR)$(DBUSINTERFACEDIR) install-appdata: $(call colorecho,INSTALL,"AppData file") $(QUIET)mkdir -m 755 -p $(DESTDIR)$(APPDATAPREFIX) $(QUIET)install -m 644 data/$(PROJECT).appdata.xml $(DESTDIR)$(APPDATAPREFIX) install: all install-headers install-manpages install-dbus install-appdata $(call colorecho,INSTALL,"executeable file") $(QUIET)mkdir -m 755 -p ${DESTDIR}${PREFIX}/bin $(QUIET)install -m 755 ${BUILDDIR_RELEASE}/${BINDIR}/${PROJECT} ${DESTDIR}${PREFIX}/bin $(QUIET)mkdir -m 755 -p ${DESTDIR}${DESKTOPPREFIX} $(call colorecho,INSTALL,"desktop file") $(QUIET)install -m 644 ${PROJECT}.desktop ${DESTDIR}${DESKTOPPREFIX} $(MAKE) -C po install uninstall-headers: $(call colorecho,UNINSTALL,"header files") $(QUIET)rm -rf ${DESTDIR}${INCLUDEDIR}/${PROJECT} $(call colorecho,UNINSTALL,"pkgconfig file") $(QUIET)rm -f ${DESTDIR}${LIBDIR}/pkgconfig/${PROJECT}.pc uninstall: uninstall-headers $(ECHO) removing executable file $(call colorecho,UNINSTALL,"executeable") $(QUIET)rm -f ${DESTDIR}${PREFIX}/bin/${PROJECT} $(call colorecho,UNINSTALL,"man pages") $(QUIET)rm -f ${DESTDIR}${MANPREFIX}/man1/${PROJECT}.1 $(QUIET)rm -f ${DESTDIR}${MANPREFIX}/man5/${PROJECT}rc.5 $(call colorecho,UNINSTALL,"desktop file") $(QUIET)rm -f ${DESTDIR}${DESKTOPPREFIX}/${PROJECT}.desktop $(call colorecho,UNINSTALL,"D-Bus interface definitions") $(QUIET)rm -f $(DESTDIR)$(DBUSINTERFACEDIR)/org.pwmt.zathura.xml $(call colorecho,UNINSTALL,"AppData file") $(QUIET)rm -f $(DESTDIR)$(APPDATAPREFIX)/$(PROJECT).appdata.xml $(MAKE) -C po uninstall DEPENDS = ${DEPENDDIRS:^=${DEPENDDIR}/}$(addprefix ${DEPENDDIR}/,${OBJECTS:.o=.o.dep}) -include ${DEPENDS} .PHONY: all options clean doc debug valgrind gdb dist doc install uninstall \ test po install-headers uninstall-headers update-po install-manpages \ build-manpages install-dbus zathura-0.3.8/README0000664000175000017500000000353613216464200014573 0ustar sebastiansebastianzathura - a document viewer =========================== zathura is a highly customizable and functional document viewer based on the girara user interface library and several document libraries. Requirements ------------ gtk3 (>= 3.6) glib (>= 2.50) girara (>= 0.2.8) sqlite3 (optional, >= 3.5.9) check (for tests) intltool libmagic from file(1) (optional, for mime-type detection) libsynctex from TeXLive (optional, for SyncTeX support) Sphinx (optional, for manpages and HTML documentation) doxygen (optional, for HTML documentation) breathe (optional, for HTML documentation) sphinx_rtd_theme (optional, for HTML documentation) Please note that you need to have a working pkg-config installation and that the Makefile is only compatible with GNU make. If you don't have a working pkg-config installation please set the GTK_INC, GTK_LIB, GIRARA_INC, GIRARA_LIB, SQLITE_INC and SQLITE_LIB variables accordingly. Also note that Sphinx is needed to build the manpages. If it is not installed, the man pages won't be built. For the HTML documentation, doxygen, breathe and sphinx_rtd_theme are needed in addition to Sphinx. If you don't want to build with support for sqlite databases, you can set WITH_SQLITE=0 and sqlite support won't be available. The use of magic to detect mime types is optional and can be disabled by setting WITH_MAGIC=0. If you pass these flags as a command line argument to make, you have to ensure to pass the same flags when executing the install target. If you want to build zathura's documentation, please install all python dependencies from the ./doc/requirements.txt file. Installation ------------ To build and install zathura: make install Uninstall --------- To delete zathura from your system, just type: make uninstall Bugs ---- Please report bugs at http://bugs.pwmt.org or contact us on our mailing list at zathura@lists.pwmt.org. zathura-0.3.8/colors.mk0000664000175000017500000000151012631275231015537 0ustar sebastiansebastian# See LICENSE file for license and copyright information ifeq ($(COLOR),1) # GCC diagnostics colors DIAGNOSTICS_COLOR_AVAILABLE ?= $(shell ($(CC) -fdiagnostics-color=always -E - /dev/null 2>/dev/null && echo 1) || echo 0) ifeq ($(DIAGNOSTICS_COLOR_AVAILABLE),1) CPPFLAGS += -fdiagnostics-color=always endif # colorful output TPUT ?= /usr/bin/tput TPUT_AVAILABLE ?= $(shell ${TPUT} -V 2>/dev/null) ifdef TPUT_AVAILABLE COLOR_NORMAL = `$(TPUT) sgr0` COLOR_ACTION = `$(TPUT) bold``$(TPUT) setaf 3` COLOR_COMMENT = `$(TPUT) bold``$(TPUT) setaf 2` COLOR_BRACKET = `$(TPUT) setaf 4` define colorecho @echo $(COLOR_BRACKET)" ["$(COLOR_ACTION)$1$(COLOR_BRACKET)"] "$(COLOR_COMMENT)$2$(COLOR_BRACKET) $(COLOR_NORMAL) endef else define colorecho @echo " [$1]" $2 endef endif else define colorecho @echo " [$1]" $2 endef endif zathura-0.3.8/common.mk0000664000175000017500000000017612501036512015526 0ustar sebastiansebastian# See LICENSE file for license and copyright information ifeq "$(VERBOSE)" "0" ECHO=@echo QUIET=@ else ECHO=@\# QUIET= endif zathura-0.3.8/config.mk0000664000175000017500000000770713216464211015517 0ustar sebastiansebastian# See LICENSE file for license and copyright information # zathura make config # project PROJECT = zathura ZATHURA_VERSION_MAJOR = 0 ZATHURA_VERSION_MINOR = 3 ZATHURA_VERSION_REV = 8 # If the API changes, the API version and the ABI version have to be bumped. ZATHURA_API_VERSION = 2 # If the ABI breaks for any reason, this has to be bumped. ZATHURA_ABI_VERSION = 3 VERSION = ${ZATHURA_VERSION_MAJOR}.${ZATHURA_VERSION_MINOR}.${ZATHURA_VERSION_REV} # version checks # If you want to disable any of the checks, set *_VERSION_CHECK to 0. # girara GIRARA_VERSION_CHECK ?= 1 GIRARA_MIN_VERSION = 0.2.8 GIRARA_PKG_CONFIG_NAME = girara-gtk3 # glib GLIB_VERSION_CHECK ?= 1 GLIB_MIN_VERSION = 2.50 GLIB_PKG_CONFIG_NAME = glib-2.0 # GTK GTK_VERSION_CHECK ?= 1 GTK_MIN_VERSION = 3.6 GTK_PKG_CONFIG_NAME = gtk+-3.0 # pkg-config binary PKG_CONFIG ?= pkg-config # glib-compile-resources GLIB_COMPILE_RESOURCES ?= glib-compile-resources # database # To disable support for the sqlite backend set WITH_SQLITE to 0. WITH_SQLITE ?= $(shell (${PKG_CONFIG} --atleast-version=3.5.9 sqlite3 && echo 1) || echo 0) # synctex # To disable support for synctex with libsynctex set WITH_SYNCTEX to 0. WITH_SYNCTEX ?= $(shell (${PKG_CONFIG} synctex && echo 1) || echo 0) # mimetype detection # To disable support for mimetype detction with libmagic set WITH_MAGIC to 0. WITH_MAGIC ?= 1 # paths PREFIX ?= /usr MANPREFIX ?= ${PREFIX}/share/man DESKTOPPREFIX ?= ${PREFIX}/share/applications APPDATAPREFIX ?= ${PREFIX}/share/metainfo LIBDIR ?= ${PREFIX}/lib INCLUDEDIR ?= ${PREFIX}/include DBUSINTERFACEDIR ?= ${PREFIX}/share/dbus-1/interfaces VIMFTPLUGINDIR ?= ${PREFIX}/share/vim/addons/ftplugin DEPENDDIR ?= .depend BUILDDIR ?= build BUILDDIR_RELEASE ?= ${BUILDDIR}/release BUILDDIR_DEBUG ?= ${BUILDDIR}/debug BUILDDIR_GCOV ?= ${BUILDDIR}/gcov BINDIR ?= bin # plugin directory PLUGINDIR ?= ${LIBDIR}/zathura # locale directory LOCALEDIR ?= ${PREFIX}/share/locale # libs ifeq (${GTK_INC}-${GTK_LIB},-) PKG_CONFIG_LIBS += gtk+-3.0 else INCS += ${GTK_INC} LIBS += ${GTK_LIB} endif ifeq (${GLIB_INC}-${GLIB_LIB},-) PKG_CONFIG_LIBS += gthread-2.0 gmodule-no-export-2.0 glib-2.0 else INCS += ${GLIB_INC} LIBS += ${GLIB_LIB} endif ifeq (${GIRARA_INC}-${GIRARA_LIB},-) PKG_CONFIG_LIBS += girara-gtk3 else INCS += ${GIRARA_INC} LIBS += ${GIRARA_LIB} endif ifneq (${WITH_SQLITE},0) ifeq (${SQLITE_INC}-${SQLITE_LIB},-) PKG_CONFIG_LIBS += sqlite3 else INCS += ${SQLITE_INC} LIBS += ${SQLITE_LIB} endif endif ifneq (${WITH_MAGIC},0) MAGIC_INC ?= MAGIC_LIB ?= -lmagic INCS += ${MAGIC_INC} LIBS += ${MAGIC_LIB} endif ifneq ($(WITH_SYNCTEX),0) ifeq (${SYNCTEX_INC}-${SYNCTEX_LIB},-) PKG_CONFIG_LIBS += synctex else INCS += ${SYNCTEX_INC} LIBS += ${SYNCTEX_LIB} endif endif ifneq (${PKG_CONFIG_LIBS},) INCS += $(shell ${PKG_CONFIG} --cflags ${PKG_CONFIG_LIBS}) LIBS += $(shell ${PKG_CONFIG} --libs ${PKG_CONFIG_LIBS}) endif LIBS += -lpthread -lm # pre-processor flags CPPFLAGS += -D_FILE_OFFSET_BITS=64 # compiler flags CFLAGS += -std=c11 -pedantic -Wall -Wno-format-zero-length -Wextra $(INCS) # debug DFLAGS ?= -g # linker flags LDFLAGS += -rdynamic # compiler CC ?= gcc # strip SFLAGS ?= -s # msgfmt MSGFMT ?= msgfmt # gcov & lcov GCOV_CFLAGS=-fprofile-arcs -ftest-coverage GCOV_LDFLAGS=-fprofile-arcs LCOV_OUTPUT=gcov LCOV_EXEC=lcov LCOV_FLAGS=--base-directory . --directory ${BUILDDIR_GCOV} --capture --rc \ lcov_branch_coverage=1 --output-file ${BUILDDIR_GCOV}/$(PROJECT).info GENHTML_EXEC=genhtml GENHTML_FLAGS=--rc lcov_branch_coverage=1 --output-directory ${LCOV_OUTPUT} ${BUILDDIR_GCOV}/$(PROJECT).info # valgrind VALGRIND = valgrind VALGRIND_ARGUMENTS = --tool=memcheck --leak-check=yes --leak-resolution=high \ --show-reachable=yes --log-file=zathura-valgrind.log VALGRIND_SUPPRESSION_FILE = zathura.suppression # set to something != 0 if you want verbose build output VERBOSE ?= 0 # gettext package name GETTEXT_PACKAGE ?= ${PROJECT} # colors COLOR ?= 1 # dist TARFILE = ${PROJECT}-${VERSION}.tar.gz TARDIR = ${PROJECT}-${VERSION} zathura-0.3.8/data/org.pwmt.zathura.xml0000664000175000017500000000376512501036512020601 0ustar sebastiansebastian zathura-0.3.8/data/tex_zathurasynctex.vim0000664000175000017500000000147012501036512021305 0ustar sebastiansebastian" See LICENSE file for license and copyright information " This is a sample plugin that can be used for synctex forward synchronization. " It currently uses latexsuite to obtain the file name of the document. If you " are not using latexsuite, it should be enough to adopt the calculation of " 'output' accordingly. " avoid re-execution if exists("b:did_zathura_synctex_plugin") || !exists("*Tex_GetMainFileName") finish endif let b:did_zathura_synctex_plugin = 1 function! Zathura_SyncTexForward() let source = expand("%:p") let input = shellescape(line(".").":".col(".").":".source) let output = Tex_GetMainFileName(":p:r").".pdf" let execstr = "zathura --synctex-forward=".input." ".shellescape(output) silent call system(execstr) endfunction nmap f :call Zathura_SyncTexForward() zathura-0.3.8/data/zathura.appdata.xml0000664000175000017500000000277112631275231020441 0ustar sebastiansebastian zathura.desktop CC0-1.0 Zlib

zathura is a highly customizable and functional document viewer. It provides a minimalistic and space saving interface as well as an easy usage that mainly focuses on keyboard interaction. zathura makes it possible to completely view and navigate through documents without using a mouse.

Other features include:

  • SyncTeX forward and backward synchronization support.
  • Quickmarks and bookmarks.
  • Automatic document reloading.

 https://pwmt.org/projects/zathura https://bugs.pwmt.org/project/zathura https://pwmt.org/projects/zathura/img/zathura-cover.png https://pwmt.org/projects/zathura/img/zathura-completion.png https://pwmt.org/projects/zathura/img/zathura-follow.png https://pwmt.org/projects/zathura/img/zathura-bookmarks.png zathura@lists.pwmt.org zathura-0.3.8/data/zathura.css_t0000664000175000017500000000031712501036512017326 0ustar sebastiansebastian/* Index mode colors */ #@session@ .indexmode { color: @index-fg@; background-color: @index-bg@; } #@session@ .indexmode:selected { color: @index-active-fg@; background-color: @index-active-bg@; } zathura-0.3.8/data/zathura.gresource.xml0000664000175000017500000000044413216464200021014 0ustar sebastiansebastian zathura.css_t org.pwmt.zathura.xml zathura-0.3.8/doc/Doxyfile0000664000175000017500000000123412501036512016154 0ustar sebastiansebastian# See LICENSE file for license and copyright information # General information PROJECT_NAME = zathura OUTPUT_DIRECTORY = ./_build/doxygen/ OUTPUT_LANGUAGE = English TAB_SIZE = 2 EXTRACT_ALL = YES OPTIMIZE_OUTPUT_FOR_C = YES DOXYFILE_ENCODING = UTF-8 TYPEDEF_HIDES_STRUCT = YES # Warning and progress messages QUIET = YES WARNINGS = YES WARN_IF_UNDOCUMENTED = YES # Input files INPUT = ../ EXCLUDE = ./tests ./doc FILE_PATTERNS = *.h *.c RECURSIVE = YES # Output files GENERATE_HTML = NO GENERATE_LATEX = NO GENERATE_RTF = NO GENERATE_XML = YES SOURCE_BROWSER = YES zathura-0.3.8/doc/Makefile0000664000175000017500000000334512750077577016141 0ustar sebastiansebastian# See LICENSE file for license and copyright information # include ../config.mk include ../common.mk include ../colors.mk include config.mk MAN_SOURCES=$(wildcard man/*.rst) $(wildcard man/*.txt) man/conf.py DOXYGEN_SOURCES=$(wildcard ../zathura/*.h) Doxyfile HTML_SOURCES=$(wildcard *.rst api/*.rst configuration/*.rst installation/*.rst usage/*.rst) conf.py SPHINX_OPTS+=-d $(SPHINX_BUILDDIR)/doctrees all: man html clean: $(call colorecho,RM,doc/$(SPHINX_BUILDDIR)) $(QUIET)rm -rf $(SPHINX_BUILDDIR)/ $(SPHINX_BUILDDIR)/html/index.html: $(HTML_SOURCES) $(SPHINX_BUILDDIR)/doxygen/xml/index.xml $(QUIET)mkdir -p $(SPHINX_BUILDDIR)/html $(call colorecho,DOC,"Build HTML documentation") $(QUIET)$(SPHINX_BIN) -b html $(SPHINX_OPTS) . $(SPHINX_BUILDDIR)/html $(SPHINX_BUILDDIR)/zathura.1: $(MAN_SOURCES) $(QUIET)mkdir -p $(SPHINX_BUILDDIR) $(call colorecho,DOC,"Build man pages") $(QUIET)$(SPHINX_BIN) -b man $(SPHINX_OPTS) man $(SPHINX_BUILDDIR) $(SPHINX_BUILDDIR)/zathurarc.5: $(SPHINX_BUILDDIR)/zathura.1 @if test -f $@; then :; else \ rm -f $(SPHINX_BUILDDIR)/zathura.1; \ $(MAKE) $(SPHINX_BUILDDIR)/zathura.1; \ fi $(SPHINX_BUILDDIR)/doxygen/xml/index.xml: $(DOXYGEN_SOURCES) $(QUIET)mkdir -p $(SPHINX_BUILDDIR)/doxygen/xml $(call colorecho,DOC,"Run doxygen") $(QUIET)$(DOXYGEN_BIN) Doxyfile ifeq ($(shell which $(SPHINX_BIN) >/dev/null 2>&1; echo $$?), 1) man: html: else man: $(SPHINX_BUILDDIR)/zathura.1 $(SPHINX_BUILDDIR)/zathurarc.5 # TODO: Make a better test for breathe and sphinx_rtd_theme ifeq ($(shell which $(DOXYGEN_BIN) >/dev/null 2>&1 && $(PYTHON_BIN) -c "import breathe; import sphinx_rtd_theme" >/dev/null 2>&1; echo $$?), 0) html: $(SPHINX_BUILDDIR)/html/index.html else html: endif endif .PHONY: clean html man all zathura-0.3.8/doc/api/index.rst0000664000175000017500000000121612501036512017060 0ustar sebastiansebastianAPI and Development =================== This guide should give a short introduction in the way zathura's plugin system works and how you can write your own plugin and let zathura use it. zathura's plugin system is quite simple. At startup zathura searches through a specified directory for shared objects and tries to load them as plugins. Each plugin has to register itself by a name, its version, a special function as well as its supported mimetypes to zathura. After the registration of the plugin zathura will automatically use it to open files with the previous defined mimetypes. That's it. .. toctree:: :maxdepth: 2 :hidden: plugin zathura-0.3.8/doc/api/plugin-development.rst0000664000175000017500000002105612501036512021573 0ustar sebastiansebastianExample - A minimalistic PDF plugin =================================== In this section we are going to develop a simplified version of the `zathura-pdf-poppler <../zathura-pdf-poppler>`_ plugin. For the sake of simplicity we are not discussing the build process of the plugin because we would recommend you to adapt our Makefiles from existing plugins. In addition we avoid most of the error handling that should be implemented. Prerequisites ~~~~~~~~~~~~~ In order to use the following described functions and macros you have to include the *plugin-api.h* header file: :: #include This automatically loads other header files for the *zathura\_document\_t*, *zathura\_page\_t* as well as all the other types that are necessary automatically. Register the plugin ~~~~~~~~~~~~~~~~~~~ As previously described each plugin has to register itself to zathura so that it can be used properly. Therefore we have introduced a macro called *ZATHURA\_PLUGIN\_REGISTER* which expects several parameters: - Plugin name *The name of the plugin* - Major version *The plugins major version* - Minor version *The plugins minor version* - Revision *The plugins revision* - Open function *The open function* - Mimetypes *A character array of supported mime types* In our case we are going to register our plugin "my plugin" with its version 1.0.1, the register function *register\_functions* and the list of supported mimetypes. :: ZATHURA_PLUGIN_REGISTER( "plugin-tutorial", 0, 1, 0, register_functions, ZATHURA_PLUGIN_MIMETYPES({ "application/pdf" }) ) This macro will automatically generate among others a function called *plugin\_register* which is used to register the plugin to zathura when it has been loaded. Register the plugin functions ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ In our macro we have defined that the function *register\_functions* is used to install our functions which will implement a certain functionality in the struct: :: void register_functions(zathura_plugin_functions_t* functions) { functions->document_open = plugin_document_open; functions->document_free = plugin_document_free; functions->page_init = plugin_page_init; functions->page_clear = plugin_page_clear; functions->page_render_cairo = plugin_page_render_cairo; } We are now going to give a short overview about the used functions in the above code snippet. For a complete documentation you should checkout the documentation of `zathura\_document\_functions\_t <../../doxygen>`_. A document instance consists out of a *zathura\_document\_t* document object that contains information about the document itself and a defined number of *zathura\_page\_t* page objects. There are several functions defined for those two types and they have to be implemented by the plugin. For our simple plugin which will only be capable of rendering a page we will need one function that is capable of opening the PDF document and setting up all necessary objects for further usage and one function which will clean up all the allocated objects afterwards. In addition we need two of those functions for page objects as well and one function that will actually implement the rendering process. Open and closing a document ~~~~~~~~~~~~~~~~~~~~~~~~~~~ The first thing we have to do when opening a document is to initialize all necessary objects and values that we are going to need for the future use of the plugin. Therefore we have to implement our *pdf\_document\_open* function: :: zathura_error_t plugin_document_open(zathura_document_t* document) { /* get path and password */ const char* path = zathura_document_get_path(document); const char* password = zathura_document_get_password(document); /* create document data */ char* uri = g_filename_to_uri(path, NULL, NULL); PopplerDocument* poppler_document = poppler_document_new_from_file(uri, password, NULL); g_free(uri); if (poppler_document == NULL) { return ZATHURA_ERROR_UNKNOWN; } /* save poppler document for further usage */ zathura_document_set_data(document, poppler_document); /* get number of pages */ unsigned int number_of_pages = poppler_document_get_n_pages(poppler_document); zathura_document_set_number_of_pages(document, number_of_pages); return ZATHURA_ERROR_OK; } To open the document we retrieve the *path* and the optional *password* of the document to create an instance of *PopplerDocument* which represents a document in the poppler library. If this fails for any reason (e.g.: the path does not exist, the user provided the incorrect password) we tell zathura that this function failed for an unknown reason. If we are lucky we continue and save the created *poppler\_document* object in the custom data field of the document so that we can access it later on. After that we determine the number of pages that the document contains so that zathura can initialize every single page. Since we have allocated the *poppler\_document* object we have to make sure that its resources will be freed when it is no longer needed. This happens in our *pdf\_document\_free* function: :: zathura_error_t plugin_document_free(zathura_document_t* document, PopplerDocument* poppler_document) { g_object_unref(poppler_document); return ZATHURA_ERROR_OK; } Page initialization ~~~~~~~~~~~~~~~~~~~ Each page has to be initialized so that zathura knows about its dimension. In addition this stage is used to store additional data in the page that will be used for further use with it. Therefore we are implementing *pdf\_page\_init* which will save the width and the height of the page in the given structure: :: zathura_error_t plugin_page_init(zathura_page_t* page) { unsigned int page_index = zathura_page_get_index(page); zathura_document_t* document = zathura_page_get_document(page); PopplerDocument* poppler_document = zathura_document_get_data(document); /* create poppler page */ PopplerPage* poppler_page = poppler_document_get_page(poppler_document, page_index); zathura_page_set_data(page, poppler_page); /* get page dimensions */ double width, height; poppler_page_get_size(poppler_page, &width, &height); zathura_page_set_width(page, width); zathura_page_set_height(page, height); return ZATHURA_ERROR_OK; } And we have to make sure that all requested resources are freed in the end: :: zathura_error_t plugin_page_clear(zathura_page_t* page, PopplerPage* poppler_page) { g_object_unref(poppler_page); return ZATHURA_ERROR_OK; } Render a page ~~~~~~~~~~~~~ After we have setup the document and the page objects we are ready to implement the render function which finally will be able to draw our page on a widget so that it can be viewed with zathura. This function has two additional parameters to the already known *zathura\_page\_t* object: One of them is a *cairo\_t* object which will be used to render the page, the other one is a flag called *printing* which determines if the rendered page should be rendered for the print process of zathura. For instance if this flag is set to true you should not render any rectangles around links in the document because they are totally worthless on paper: :: zathura_error_t pdf_page_render_cairo(zathura_page_t* page, cairo_t* cairo, bool printing) { if (printing == false) { poppler_page_render(poppler_page, cairo); } else { poppler_page_render_for_printing(poppler_page, cairo); } return ZATHURA_ERROR_OK; } In this case the *pdf\_page\_render\_cairo* function is very simplistic since all the work is done by the *poppler* library. In your case you might have to do some magic here to draw the page to the cairo object. Make sure to check out the source code of our plugins. Installation of the plugin ~~~~~~~~~~~~~~~~~~~~~~~~~~ As we suggested earlier the easiest way to build and install the plugin is to duplicate the *Makefile* (as long with its *common.mk* and *config.mk* files of one of our plugins. It already contains all necessary targets for building, installing and debugging the plugin. Otherwise you could build the above plugin with the following command: :: $ gcc -std=c99 -shared -fPIC -pedantic -Wall `pkg-config --cflags --libs poppler-glib zathura` \ -o pdf.so pdf.c After that you have to copy the *pdf.so* file into the directory where zathura looks for plugins (this is by default: */usr/lib/zathura*). zathura-0.3.8/doc/api/plugin.rst0000664000175000017500000000226112501036512017250 0ustar sebastiansebastianPlugin system ============= zathura's plugin system is quite simple. At startup zathura searches through a specified directory for shared objects and tries to load them as plugins. Each plugin has to register itself by a name, its version, a special function as well as its supported mimetypes to zathura. After the registration of the plugin zathura will automatically use it to open files with the previous defined mimetypes. That's it. Each plugin has to implement a basic set of functionality so that it can be used in a meaningful way with zathura. For instance it would not make any sense if the plugin was not able to render any page at all. On the contrary the export of images out of the document might not be considered as that important. We have predefined a certain set of functionality that a plugin can have and that can be used by zathura if it has been implemented by the plugin. When a plugin is loaded, zathura calls a certain function that the plugin **must implemented** in order to work correctly. This function gets a data structure which has to be filled with function pointers by the plugin, which are then used by the main application. .. toctree:: plugin-development zathura-0.3.8/doc/conf.py0000664000175000017500000000214612501036512015750 0ustar sebastiansebastian#!/usr/bin/env python3 # -*- coding: utf-8 -*- # # See LICENSE file for license and copyright information import sphinx_rtd_theme # -- General configuration ------------------------------------------------ extensions = [ 'sphinx.ext.todo', 'breathe' ] source_suffix = '.rst' master_doc = 'index' templates_path = ['_templates'] exclude_patterns = ['_build'] pygments_style = 'sphinx' # -- Project configuration ------------------------------------------------ project = 'zathura' copyright = '2014, pwmt.org' version = '0.2.7' release = '0.2.7' # -- Options for HTML output ---------------------------------------------- html_theme = 'sphinx_rtd_theme' html_theme_path = [sphinx_rtd_theme.get_html_theme_path()] html_static_path = ['_static'] htmlhelp_basename = 'zathuradoc' # -- Options for breathe --------------------------------------- breathe_projects = { "zathura": "_build/doxygen/xml" } breathe_default_project = "zathura" breathe_build_directory = "_build" breathe_projects_source = { "zathura": "../" } breathe_domain_by_extension = { "h" : "c", "c" : "c" } zathura-0.3.8/doc/config.mk0000664000175000017500000000040312501036512016241 0ustar sebastiansebastian# See LICENSE file for license and copyright information SPHINX_BIN ?= sphinx-build SPHINX_BUILDDIR = _build SPHINX_OPTS ?= DOXYGEN_BIN ?= doxygen # This needs to be the same python interpreter as used by sphinx-build PYTHON_BIN ?= python zathura-0.3.8/doc/configuration/index.rst0000664000175000017500000000130512501036512021155 0ustar sebastiansebastianConfiguration ============= .. toctree:: :maxdepth: 1 set map options The customization of zathura is be managed via a configuration file called *zathurarc*. By default zathura will evaluate the following files: - */etc/zathurarc* - *$XDG\_CONFIG\_HOME/zathura/zathurarc* (default: ~/.config/zathura/zathurarc) The *zathurarc* file is a simple plain text file that can be populated with various commands to change the behaviour and the look of zathura which we are going to describe in the following subsections. Each line (besides empty lines and comments (which start with a prepended *#*) is evaluated on its own, so it is not possible to write multiple commands in one single line. zathura-0.3.8/doc/configuration/map.rst0000664000175000017500000002076412501036512020635 0ustar sebastiansebastianmap - Mapping a shortcut ======================== It is possible to map or remap new key bindings to shortcut functions which allows a high level of customization. The *:map* command can also be used in the *zathurarc* file to make those changes permanent: :: map [mode] Mode ---- The *map* command expects several arguments where only the *binding* as well as the *shortcut-function* argument is required. Since zathura uses several modes it is possible to map bindings only for a specific mode by passing the *mode* argument which can take one of the following values: - normal (default) - visual - insert - fullscreen - index The brackets around the value are mandatory. Single key binding ~~~~~~~~~~~~~~~~~~ The (possible) second argument defines the used key binding that should be mapped to the shortcut function and is structured like the following. On the one hand it is possible to just assign single letters, numbers or signs to it: :: map a shortcut_function map b shortcut_function map c shortcut_function map 1 shortcut_function map 2 shortcut_function map 3 shortcut_function map ! shortcut_function map ? shortcut_function Using modifiers --------------- It is also possible to use modifiers like the *Control* or *Alt* button on the keyboard. It is possible to use the following modifiers: - A - *Alt* - C - *Control* - S - *Shift* Now it is required to define the *binding* with the following structure: :: map shortcut_function map shortcut_function Special keys ------------ zathura allows it also to assign keys like the space bar or the tab button which also have to be written in between angle brackets. The following special keys are currently available: +--------------+--------------------+ | Identifier | Description | +==============+====================+ | BackSpace | *Back space* | +--------------+--------------------+ | CapsLock | *Caps lock* | +--------------+--------------------+ | Esc | *Escape* | +--------------+--------------------+ | Down | *Arrow down* | +--------------+--------------------+ | Up | *Arrow up* | +--------------+--------------------+ | Left | *Arrow left* | +--------------+--------------------+ | Right | *Arrow right* | +--------------+--------------------+ | F1 | *F1* | +--------------+--------------------+ | F2 | *F2* | +--------------+--------------------+ | F3 | *F3* | +--------------+--------------------+ | F4 | *F4* | +--------------+--------------------+ | F5 | *F5* | +--------------+--------------------+ | F6 | *F6* | +--------------+--------------------+ | F7 | *F7* | +--------------+--------------------+ | F8 | *F8* | +--------------+--------------------+ | F9 | *F9* | +--------------+--------------------+ | F10 | *F10* | +--------------+--------------------+ | F11 | *F11* | +--------------+--------------------+ | F12 | *F12* | +--------------+--------------------+ | PageDown | *Page Down* | +--------------+--------------------+ | PageUp | *Page Up* | +--------------+--------------------+ | Return | *Return* | +--------------+--------------------+ | Space | *Space* | +--------------+--------------------+ | Super | *Windows button* | +--------------+--------------------+ | Tab | *Tab* | +--------------+--------------------+ Of course it is possible to combine those special keys with a modifier. The usage of those keys should be explained by the following examples: :: map shortcut_function map shortcut_function Mouse buttons ------------- It is also possible to map mouse buttons to shortcuts by using the following special keys: +--------------+--------------------+ | Identifier | Description | +==============+====================+ | Button1 | *Mouse button 1* | +--------------+--------------------+ | Button2 | *Mouse button 2* | +--------------+--------------------+ | Button3 | *Mouse button 3* | +--------------+--------------------+ | Button4 | *Mouse button 4* | +--------------+--------------------+ | Button5 | *Mouse button 5* | +--------------+--------------------+ They can also be combined with modifiers: :: map shortcut_function map shortcut_function Buffer commands --------------- If a mapping does not match one of the previous definition but is still a valid mapping it will be mapped as a buffer command: :: map abc quit map test quit Shortcut functions ------------------ The following shortcut functions can be mapped: +----------------------+----------------------------------------+ | Function | Description | +======================+========================================+ | abort | *Switch back to normal mode* | +----------------------+----------------------------------------+ | adjust\_window | *Adjust page width* | +----------------------+----------------------------------------+ | change\_mode | *Change current mode* | +----------------------+----------------------------------------+ | follow | *Follow a link* | +----------------------+----------------------------------------+ | focus\_inputbar | *Focus inputbar* | +----------------------+----------------------------------------+ | goto | *Go to a certain page* | +----------------------+----------------------------------------+ | index\_navigate | *Navigate through the index* | +----------------------+----------------------------------------+ | navigate | *Navigate to the next/previous page* | +----------------------+----------------------------------------+ | quit | *Quit zathura* | +----------------------+----------------------------------------+ | recolor | *Recolor the pages* | +----------------------+----------------------------------------+ | reload | *Reload the document* | +----------------------+----------------------------------------+ | rotate | *Rotate the page* | +----------------------+----------------------------------------+ | scroll | *Scroll* | +----------------------+----------------------------------------+ | search | *Search next/previous item* | +----------------------+----------------------------------------+ | set | *Set an option* | +----------------------+----------------------------------------+ | toggle\_fullscreen | *Toggle fullscreen* | +----------------------+----------------------------------------+ | toggle\_index | *Show or hide index* | +----------------------+----------------------------------------+ | toggle\_inputbar | *Show or hide inputbar* | +----------------------+----------------------------------------+ | toggle\_statusbar | *Show or hide statusbar* | +----------------------+----------------------------------------+ | zoom | *Zoom in or out* | +----------------------+----------------------------------------+ Pass arguments -------------- Some shortcut function require or have optional arguments which influence the behaviour of them. Those can be passed as the last argument: :: map zoom in map zoom out Possible arguments are: - bottom - default - down - full-down - full-up - half-down - half-up - in - left - next - out - previous - right - specific - top - up - best-fit - width - rotate-cw - rotate-ccw unmap - Removing a shortcut ~~~~~~~~~~~~~~~~~~~~~~~~~~~ In addition to mapping or remaping custom key bindings it is possible to remove existing ones by using the *:unmap* command. The command is used in the following way (the explanation of the parameters is described in the *map* section of this document :: unmap [mode] zathura-0.3.8/doc/configuration/options.rst0000664000175000017500000000636612750077577021603 0ustar sebastiansebastianConfiguration options ===================== General settings ---------------- .. describe:: abort-clear-search Defines if the search results should be cleared on abort. :type: Boolean :default: True .. describe:: adjust-open Defines which auto adjustment mode should be used if a document is loaded. Possible options are "best-fit" and "width". :type: String :default: best-fit .. describe:: advance-ds-per-row Defines if the number of pages per row should be honored when advancing a page. :type: Boolean :default: true .. describe:: database Defines the used database backend. Possible options are 'plain' and 'sqlite' :type: String :default: plain .. describe:: highlight-color Defines the color that is used for highlighting parts of the document (e.g.: show search results) :type: String :default: #9FBC00 .. describe:: highlight-active-color Defines the color that is used to show the current selected highlighted element (e.g: current search result) :type: String :default: #00BC00 .. describe:: highlight-transparency Defines the opacity of a highlighted element :type: Float :default: 0.5 .. describe:: page-padding The page padding defines the gap in pixels between each rendered page. :type: Integer :default: 1 .. describe:: page-store-threshold Pages that are not visible get unloaded after some time. Every page that has not been visible for page-store-treshold seconds will be unloaded. :type: Integer :default: 30 .. describe:: page-store-interval Defines the amount of seconds between the check to unload invisible pages. :type: Integer :default: 30 .. describe:: pages-per-row Defines the number of pages that are rendered next to each other in a row. :type: Integer :default: 1 .. describe:: recolor En/Disables recoloring :type: Boolean :default: false .. describe:: recolor-darkcolor Defines the color value that is used to represent dark colors in recoloring mode :type: String :default: #FFFFFF .. describe:: recolor-lightcolor Defines the color value that is used to represent light colors in recoloring mode :type: String :default: #000000 .. describe:: render-loading Defines if the "Loading..." text should be displayed if a page is rendered. :type: Boolean :default: true .. describe:: scroll-step Defines the step size of scrolling by calling the scroll command once :type: Float :default: 40 .. describe:: scroll-wrap Defines if the last/first page should be wrapped :type: Boolean :default: false .. describe:: zoom-max Defines the maximum percentage that the zoom level can be :type: Integer :default: 1000 .. describe:: zoom-min Defines the minimum percentage that the zoom level can be :type: Integer :default: 10 .. describe:: zoom-step Defines the amount of percent that is zoomed in or out on each comand. :type: Integer :default: 10 Girara settings --------------- Most of the options affecting the appearance of zathura are derived from the options that are offered by our user interface library called girara and can be found in its `documentation `_. Those values can also be set via the *zathurarc* file. zathura-0.3.8/doc/configuration/set.rst0000664000175000017500000000204513216464200020646 0ustar sebastiansebastianset - Changing options ====================== In addition to the built-in *:set* command zathura offers more options to be changed and makes those changes permanent. To overwrite an option you just have to add a line structured like the following :: set